diff --git a/doc/reference_manual.texi b/doc/reference_manual.texi index eb45bd473..0fce56b66 100644 --- a/doc/reference_manual.texi +++ b/doc/reference_manual.texi @@ -4335,7 +4335,7 @@ Mercury arguments declared with input modes are passed by value to the C function. For output arguments, the Mercury implementation will pass to the C function an address in which to store the result. If the Mercury procedure can fail, then its C function should return a -truth value of type @samp{Integer} indicating success or failure: +truth value of type @samp{MR_Integer} indicating success or failure: non-zero indicates success, and zero indicates failure. If the Mercury procedure is a Mercury function that cannot fail, and the function result has an output mode, then the C function should @@ -4838,19 +4838,20 @@ Mercury User's Guide, and the @samp{man} pages for @samp{mmc} and @samp{ml}. For each of the Mercury types @code{int}, @code{float}, @code{char}, and @code{string}, there is a C typedef for the corresponding type in C: -@code{Integer}, @code{Float}, @code{Char}, and @code{String} respectively. +@code{MR_Integer}, @code{MR_Float}, @code{MR_Char}, +and @code{MR_String} respectively. -In the current implementation, @samp{Integer} is a typedef for an -integral type whose size is the same size as a pointer; @samp{Float} is +In the current implementation, @samp{MR_Integer} is a typedef for an +integral type whose size is the same size as a pointer; @samp{MR_Float} is a typedef for @samp{double} (unless the program and the Mercury library was compiled with @samp{-DUSE_SINGLE_PREC_FLOAT}, in which case it is -a typedef for @samp{float}); @samp{Char} is a typedef for @samp{char}; -and @samp{String} is a typedef for @samp{Char *}. +a typedef for @samp{float}); @samp{MR_Char} is a typedef for @samp{char}; +and @samp{MR_String} is a typedef for @samp{MR_Char *}. Mercury variables of type @code{int}, @code{float}, @code{char}, or @code{string} are passed to and from C as C variables whose type is given by the corresponding typedef. Mercury variables of any other -type are passed as a @samp{Word}, which in the current implementation +type are passed as a @samp{MR_Word}, which in the current implementation is a typedef for an unsigned type whose size is the same size as a pointer. (Note: it would in fact be better for each Mercury type to map to a distinct abstract type in C, since that would be more type-safe, and thus we may @@ -5019,7 +5020,7 @@ on backtracking. @item @bullet{} @code{MR_trail_value()} Prototype: @example -void MR_trail_value(Word *@var{address}, Word @var{value}); +void MR_trail_value(MR_Word *@var{address}, MR_Word @var{value}); @end example Ensures that if future execution backtracks to the @@ -5028,7 +5029,7 @@ current choice point, then @var{value} will be placed in @var{address}. @item @bullet{} @code{MR_trail_current_value()} Prototype: @example -void MR_trail_current_value(Word *@var{address}); +void MR_trail_current_value(MR_Word *@var{address}); @end example Ensures that if future execution backtracks to the @@ -5068,7 +5069,7 @@ typedef enum @{ @} MR_untrail_reason; void MR_trail_function( - void (*@var{untrail_func})(Word, MR_untrail_reason), + void (*@var{untrail_func})(MR_Word, MR_untrail_reason), void *@var{value} ); @end example @@ -5269,20 +5270,20 @@ outweigh these costs will depend on your application. "update_int_ref"). :- pragma c_header_code(" -typedef Word Mercury_IntRef; -void new_int_ref(Mercury_IntRef *ref, Integer value); +typedef MR_Word Mercury_IntRef; +void new_int_ref(Mercury_IntRef *ref, MR_Integer value); void update_int_ref(Mercury_IntRef ref0, Mercury_IntRef *ref, - Integer *old_value, Integer new_value); + MR_Integer *old_value, MR_Integer new_value); "). :- pragma c_code(" typedef struct @{ MR_ChoicepointId prev_choicepoint; - Integer data; + MR_Integer data; @} C_IntRef; void -new_int_ref(Mercury_IntRef *ref, Integer value) +new_int_ref(Mercury_IntRef *ref, MR_Integer value) @{ C_IntRef *x = malloc(sizeof(C_IntRef)); x->prev_choicepoint = MR_current_choicepoint_id(); @@ -5292,7 +5293,7 @@ new_int_ref(Mercury_IntRef *ref, Integer value) void update_int_ref(Mercury_IntRef ref0, Mercury_IntRef *ref, - Integer *old_value, Integer new_value) + MR_Integer *old_value, MR_Integer new_value) @{ C_IntRef *x = (C_IntRef *) ref0; *old_value = x->data; @@ -5303,10 +5304,10 @@ update_int_ref(Mercury_IntRef ref0, Mercury_IntRef *ref, @{ /* trail both x->data and x->prev_choicepoint, since we're about to update them both*/ - assert(sizeof(x->data) == sizeof(Word)); - assert(sizeof(x->prev_choicepoint) == sizeof(Word)); - MR_trail_current_value((Word *)&x->data); - MR_trail_current_value((Word *)&x->prev_choicepoint); + assert(sizeof(x->data) == sizeof(MR_Word)); + assert(sizeof(x->prev_choicepoint) == sizeof(MR_Word)); + MR_trail_current_value((MR_Word *)&x->data); + MR_trail_current_value((MR_Word *)&x->prev_choicepoint); /* update x->prev_choicepoint to indicate that x->data's previous value has been trailed @@ -5576,7 +5577,7 @@ and so is not useful as is. It is meant only as an example. @example :- pragma c_header_code("#include "). -:- pragma c_header_code("Integer max;"). +:- pragma c_header_code("MR_Integer max;"). :- impure pred init_max is det. :- pragma c_code(init_max, diff --git a/runtime/machdeps/alpha_regs.h b/runtime/machdeps/alpha_regs.h index cd676e232..96a818f34 100644 --- a/runtime/machdeps/alpha_regs.h +++ b/runtime/machdeps/alpha_regs.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1994-1998 The University of Melbourne. +** Copyright (C) 1994-1998, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -24,13 +24,13 @@ #define NUM_REAL_REGS 7 -register Word mr0 __asm__("$9"); /* register s0 */ -register Word mr1 __asm__("$10"); /* register s1 */ -register Word mr2 __asm__("$11"); /* register s2 */ -register Word mr3 __asm__("$12"); /* register s3 */ -register Word mr4 __asm__("$13"); /* register s4 */ -register Word mr5 __asm__("$14"); /* register s5 */ -register Word mr6 __asm__("$15"); /* the frame pointer (fp) */ +register MR_Word mr0 __asm__("$9"); /* register s0 */ +register MR_Word mr1 __asm__("$10"); /* register s1 */ +register MR_Word mr2 __asm__("$11"); /* register s2 */ +register MR_Word mr3 __asm__("$12"); /* register s3 */ +register MR_Word mr4 __asm__("$13"); /* register s4 */ +register MR_Word mr5 __asm__("$14"); /* register s5 */ +register MR_Word mr6 __asm__("$15"); /* the frame pointer (fp) */ #define MR_real_reg_number_mr0 9 #define MR_real_reg_number_mr1 10 diff --git a/runtime/machdeps/i386_regs.h b/runtime/machdeps/i386_regs.h index 75da72ad4..8a284a158 100644 --- a/runtime/machdeps/i386_regs.h +++ b/runtime/machdeps/i386_regs.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1993-1998 The University of Melbourne. +** Copyright (C) 1993-1998, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -58,8 +58,8 @@ #define NUM_REAL_REGS 3 #endif -register Word mr0 __asm__("esi"); /* sp */ -register Word mr1 __asm__("edi"); /* succip */ +register MR_Word mr0 __asm__("esi"); /* sp */ +register MR_Word mr1 __asm__("edi"); /* succip */ #define MR_real_reg_number_mr0 esi #define MR_real_reg_number_mr1 edi @@ -67,7 +67,7 @@ register Word mr1 __asm__("edi"); /* succip */ #if PIC_REG #define mr2 MR_fake_reg[2] #else - register Word mr2 __asm__("ebx"); /* r1 */ + register MR_Word mr2 __asm__("ebx"); /* r1 */ #define MR_real_reg_number_mr2 ebx diff --git a/runtime/machdeps/m68k.h b/runtime/machdeps/m68k.h index 64f9f9388..e2e80e15e 100644 --- a/runtime/machdeps/m68k.h +++ b/runtime/machdeps/m68k.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1997 The University of Melbourne. +** Copyright (C) 1997, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -35,11 +35,11 @@ #define NUM_REAL_REGS 5 -register Word mr0 __asm__("a2"); /* sp */ -register Word mr1 __asm__("a3"); /* succip */ -register Word mr2 __asm__("d2"); /* r1 */ -register Word mr3 __asm__("d3"); /* r2 */ -register Word mr4 __asm__("d4"); /* r3 */ +register MR_Word mr0 __asm__("a2"); /* sp */ +register MR_Word mr1 __asm__("a3"); /* succip */ +register MR_Word mr2 __asm__("d2"); /* r1 */ +register MR_Word mr3 __asm__("d3"); /* r2 */ +register MR_Word mr4 __asm__("d4"); /* r3 */ #define save_regs_to_mem(save_area) ( \ save_area[0] = mr0, \ diff --git a/runtime/machdeps/mips_regs.h b/runtime/machdeps/mips_regs.h index 1b678081b..4fbaa86ca 100644 --- a/runtime/machdeps/mips_regs.h +++ b/runtime/machdeps/mips_regs.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1993-1997 The University of Melbourne. +** Copyright (C) 1993-1997, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -18,14 +18,14 @@ #define NUM_REAL_REGS 8 -register Word mr0 __asm__("s0"); -register Word mr1 __asm__("s1"); -register Word mr2 __asm__("s2"); -register Word mr3 __asm__("s3"); -register Word mr4 __asm__("s4"); -register Word mr5 __asm__("s5"); -register Word mr6 __asm__("s6"); -register Word mr7 __asm__("s7"); +register MR_Word mr0 __asm__("s0"); +register MR_Word mr1 __asm__("s1"); +register MR_Word mr2 __asm__("s2"); +register MR_Word mr3 __asm__("s3"); +register MR_Word mr4 __asm__("s4"); +register MR_Word mr5 __asm__("s5"); +register MR_Word mr6 __asm__("s6"); +register MR_Word mr7 __asm__("s7"); #define save_regs_to_mem(save_area) ( \ save_area[0] = mr0, \ diff --git a/runtime/machdeps/no_regs.h b/runtime/machdeps/no_regs.h index 82f777f82..347dfdd2c 100644 --- a/runtime/machdeps/no_regs.h +++ b/runtime/machdeps/no_regs.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1994-1997 The University of Melbourne. +** Copyright (C) 1994-1997, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -22,7 +22,7 @@ /* A pair of macros to save/restore all of the physical machine registers. They should copy/restore the physical machine registers to/from the memory pointed to by the supplied `save_area' - parameter (which should be a pointer of type `Word *'). + parameter (which should be a pointer of type `MR_Word *'). */ #define save_regs_to_mem(save_area) ((void)0) #define restore_regs_from_mem(save_area) ((void)0) @@ -31,7 +31,7 @@ registers that get clobbered by calling a C function. This is used for machines with register windows. They should copy/restore the windowed registers to/from the memory pointed to by the supplied `save_area' - parameter (which should be a pointer of type `Word *'). + parameter (which should be a pointer of type `MR_Word *'). */ #define save_transient_regs_to_mem(save_area) ((void)0) diff --git a/runtime/machdeps/pa_regs.h b/runtime/machdeps/pa_regs.h index 85967703d..89a51e10a 100644 --- a/runtime/machdeps/pa_regs.h +++ b/runtime/machdeps/pa_regs.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1994-1997 The University of Melbourne. +** Copyright (C) 1994-1997, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -18,14 +18,14 @@ #define NUM_REAL_REGS 8 -register Word mr0 __asm__("%r6"); -register Word mr1 __asm__("%r7"); -register Word mr2 __asm__("%r8"); -register Word mr3 __asm__("%r9"); -register Word mr4 __asm__("%r10"); -register Word mr5 __asm__("%r11"); -register Word mr6 __asm__("%r12"); -register Word mr7 __asm__("%r13"); +register MR_Word mr0 __asm__("%r6"); +register MR_Word mr1 __asm__("%r7"); +register MR_Word mr2 __asm__("%r8"); +register MR_Word mr3 __asm__("%r9"); +register MR_Word mr4 __asm__("%r10"); +register MR_Word mr5 __asm__("%r11"); +register MR_Word mr6 __asm__("%r12"); +register MR_Word mr7 __asm__("%r13"); #define save_regs_to_mem(save_area) ( \ save_area[0] = mr0, \ diff --git a/runtime/machdeps/rs6000_regs.h b/runtime/machdeps/rs6000_regs.h index d8faf0c4c..6a4b68b73 100644 --- a/runtime/machdeps/rs6000_regs.h +++ b/runtime/machdeps/rs6000_regs.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1996-1997 The University of Melbourne. +** Copyright (C) 1996-1997, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -19,16 +19,16 @@ #define NUM_REAL_REGS 10 -register Word mr0 __asm__("r13"); -register Word mr1 __asm__("r14"); -register Word mr2 __asm__("r15"); -register Word mr3 __asm__("r16"); -register Word mr4 __asm__("r17"); -register Word mr5 __asm__("r18"); -register Word mr6 __asm__("r19"); -register Word mr7 __asm__("r20"); -register Word mr8 __asm__("r21"); -register Word mr9 __asm__("r22"); +register MR_Word mr0 __asm__("r13"); +register MR_Word mr1 __asm__("r14"); +register MR_Word mr2 __asm__("r15"); +register MR_Word mr3 __asm__("r16"); +register MR_Word mr4 __asm__("r17"); +register MR_Word mr5 __asm__("r18"); +register MR_Word mr6 __asm__("r19"); +register MR_Word mr7 __asm__("r20"); +register MR_Word mr8 __asm__("r21"); +register MR_Word mr9 __asm__("r22"); #define save_regs_to_mem(save_area) ( \ save_area[0] = mr0, \ diff --git a/runtime/machdeps/sparc_regs.h b/runtime/machdeps/sparc_regs.h index 0f484e61c..43b4fe083 100644 --- a/runtime/machdeps/sparc_regs.h +++ b/runtime/machdeps/sparc_regs.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1993-1997 The University of Melbourne. +** Copyright (C) 1993-1997, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -29,16 +29,16 @@ #define NUM_REAL_REGS 10 -register Word mr0 __asm__("i0"); -register Word mr1 __asm__("i1"); /* potentially non-clobbered */ -register Word mr2 __asm__("i2"); /* potentially non-clobbered */ -register Word mr3 __asm__("i3"); /* potentially non-clobbered */ -register Word mr4 __asm__("i4"); /* potentially non-clobbered */ -register Word mr5 __asm__("i5"); /* potentially non-clobbered */ -register Word mr6 __asm__("l1"); -register Word mr7 __asm__("l2"); -register Word mr8 __asm__("l3"); -register Word mr9 __asm__("l4"); +register MR_Word mr0 __asm__("i0"); +register MR_Word mr1 __asm__("i1"); /* potentially non-clobbered */ +register MR_Word mr2 __asm__("i2"); /* potentially non-clobbered */ +register MR_Word mr3 __asm__("i3"); /* potentially non-clobbered */ +register MR_Word mr4 __asm__("i4"); /* potentially non-clobbered */ +register MR_Word mr5 __asm__("i5"); /* potentially non-clobbered */ +register MR_Word mr6 __asm__("l1"); +register MR_Word mr7 __asm__("l2"); +register MR_Word mr8 __asm__("l3"); +register MR_Word mr9 __asm__("l4"); /* we could use l5, l6, and l7 as well, */ /* but for the moment at least I'll leave them for gcc */ diff --git a/runtime/mercury.c b/runtime/mercury.c index 90c9c8bd9..07c9ccab2 100644 --- a/runtime/mercury.c +++ b/runtime/mercury.c @@ -685,7 +685,7 @@ mercury__builtin__do_compare__int_0_0( MR_Comparison_Result *result, MR_Box x, MR_Box y) { mercury__builtin____Compare____int_0_0(result, - (Integer) x, (Integer) y); + (MR_Integer) x, (MR_Integer) y); } static void @@ -811,31 +811,31 @@ mercury__private_builtin__do_compare__base_typeclass_info_1_0( /* provide definitions for functions declared `extern inline' */ -Word -create1(Word w1) +MR_Word +create1(MR_Word w1) { - Word *p = (Word *) MR_new_object(Word, 1 * sizeof(Word), "create1"); + MR_Word *p = (MR_Word *) MR_new_object(MR_Word, 1 * sizeof(MR_Word), "create1"); p[0] = w1; - return (Word) p; + return (MR_Word) p; } -Word -create2(Word w1, Word w2) +MR_Word +create2(MR_Word w1, MR_Word w2) { - Word *p = (Word *) MR_new_object(Word, 2 * sizeof(Word), "create2"); + MR_Word *p = (MR_Word *) MR_new_object(MR_Word, 2 * sizeof(MR_Word), "create2"); p[0] = w1; p[1] = w2; - return (Word) p; + return (MR_Word) p; } -Word -create3(Word w1, Word w2, Word w3) +MR_Word +create3(MR_Word w1, MR_Word w2, MR_Word w3) { - Word *p = (Word *) MR_new_object(Word, 3 * sizeof(Word), "create3"); + MR_Word *p = (MR_Word *) MR_new_object(MR_Word, 3 * sizeof(MR_Word), "create3"); p[0] = w1; p[1] = w2; p[2] = w3; - return (Word) p; + return (MR_Word) p; } #endif diff --git a/runtime/mercury.h b/runtime/mercury.h index 4f918647c..27d73c5dc 100644 --- a/runtime/mercury.h +++ b/runtime/mercury.h @@ -20,7 +20,7 @@ #include "mercury_conf.h" #include "mercury_types.h" -#include "mercury_float.h" /* for the `Float' type */ +#include "mercury_float.h" /* for the `MR_Float' type */ #include "mercury_tags.h" #include "mercury_grade.h" #include "mercury_thread.h" /* for the MR_*_GLOBAL_LOCK() macros */ @@ -56,31 +56,27 @@ */ /* -** The following types are used to represent the Mercury builtin types. -** See mercury_types.h and mercury_float.h. +** The types uses to represent the Mercury builtin types, +** MR_Char, MR_Float, MR_Integer, MR_String, and MR_ConstString, +** are defined in mercury_types.h and mercury_float.h. */ -typedef Char MR_Char; -typedef Float MR_Float; -typedef Integer MR_Integer; -typedef String MR_String; -typedef ConstString MR_ConstString; /* -** The MR_Box type is used for representing polymorphic types. +** The MR_Word type, which is used for representing user-defined +** types when we're using the low-level data representation, +** is defined in runtime/mercury_types.h. +*/ + +/* +** The MR_Box type, which is used for representing polymorphic +** types, is defined in runtime/mercury_types.h. */ -typedef void *MR_Box; /* ** The MR_ClosurePtr type is used for representing higher-order types. */ typedef const MR_Closure *MR_ClosurePtr; -/* -** With the low-level data representation, the MR_Word type -** is used for representing user-defined types. -*/ -typedef Word MR_Word; - /* ** Define some names for types that differ depending ** on whether --high-level-data is enabled. @@ -124,7 +120,7 @@ typedef Word MR_Word; */ typedef struct MR_TypeCtorInfo_Struct MR_TypeCtorInfo_Struct; typedef MR_DuExistLocn MR_DuExistLocnArray[]; -typedef ConstString MR_ConstStringArray[]; +typedef MR_ConstString MR_ConstStringArray[]; typedef MR_PseudoTypeInfo MR_PseudoTypeInfoArray[]; typedef const MR_EnumFunctorDesc * MR_EnumFunctorDescPtrArray[]; typedef const MR_DuFunctorDesc * MR_DuFunctorDescPtrArray[]; @@ -245,7 +241,7 @@ extern const MR_TypeCtorInfo_Struct ** that passes one of these, then we need to generate a reference to ** a dummy variable. We use this variable for that purpose. */ -extern Word mercury__private_builtin__dummy_var; +extern MR_Word mercury__private_builtin__dummy_var; /*---------------------------------------------------------------------------*/ /* diff --git a/runtime/mercury_accurate_gc.c b/runtime/mercury_accurate_gc.c index fa49d24fd..f71cbf1bd 100644 --- a/runtime/mercury_accurate_gc.c +++ b/runtime/mercury_accurate_gc.c @@ -1,5 +1,5 @@ /* -** Copyright (C) 1998-1999 The University of Melbourne. +** Copyright (C) 1998-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -19,17 +19,17 @@ /* ** Function prototypes. */ -static void garbage_collect(Code *saved_success, Word *stack_pointer, - Word *current_frame); +static void garbage_collect(MR_Code *saved_success, MR_Word *stack_pointer, + MR_Word *current_frame); static void garbage_collect_roots(void); -static void copy_value(MR_Live_Lval locn, Word *type_info, bool copy_regs, - Word *stack_pointer, Word *current_frame); +static void copy_value(MR_Live_Lval locn, MR_Word *type_info, bool copy_regs, + MR_Word *stack_pointer, MR_Word *current_frame); /* ** Global variables (only used in this module, however). */ -static Code *saved_success = (Code *) NULL; -static Word *saved_success_location = (Word *) NULL; +static MR_Code *saved_success = (MR_Code *) NULL; +static MR_Word *saved_success_location = (MR_Word *) NULL; static bool gc_scheduled = FALSE; static bool gc_running = FALSE; @@ -58,7 +58,7 @@ Define_extern_entry(mercury__garbage_collect_0_0); ** that the code will return to). */ void -MR_schedule_agc(Code *pc_at_signal, Word *sp_at_signal) +MR_schedule_agc(MR_Code *pc_at_signal, MR_Word *sp_at_signal) { MR_Stack_Layout_Label *layout; const MR_Stack_Layout_Entry *entry_layout; @@ -143,7 +143,7 @@ MR_schedule_agc(Code *pc_at_signal, Word *sp_at_signal) fprintf(stderr, "GC scheduled again. Replacing old scheduling," " and trying to schedule again.\n"); #endif - *saved_success_location = (Word) saved_success; + *saved_success_location = (MR_Word) saved_success; } gc_scheduled = TRUE; @@ -161,7 +161,7 @@ MR_schedule_agc(Code *pc_at_signal, Word *sp_at_signal) */ saved_success_location = &MR_based_stackvar(sp_at_signal, number); - saved_success = (Code *) *saved_success_location; + saved_success = (MR_Code *) *saved_success_location; #ifdef MR_DEBUG_AGC_SCHEDULING fprintf(stderr, "old succip: %ld (%lx) new: %ld (%lx)", @@ -175,7 +175,7 @@ MR_schedule_agc(Code *pc_at_signal, Word *sp_at_signal) ** Replace the old succip with the address of the ** garbage collector. */ - *saved_success_location = (Word) mercury__garbage_collect_0_0; + *saved_success_location = (MR_Word) mercury__garbage_collect_0_0; } else { /* @@ -226,20 +226,20 @@ END_MODULE ** (We use 4 space tabs here because of the depth of indentation). */ void -garbage_collect(Code *success_ip, Word *stack_pointer, Word *current_frame) +garbage_collect(MR_Code *success_ip, MR_Word *stack_pointer, MR_Word *current_frame) { MR_Internal *label, *first_label; int i, var_count, count; const MR_Stack_Layout_Label *internal_layout; const MR_Stack_Layout_Vars *vars; MemoryZone *old_heap, *new_heap; - Word *type_params; + MR_Word *type_params; bool succeeded; bool top_frame = TRUE; MR_MemoryList allocated_memory_cells = NULL; - Word *old_hp; + MR_Word *old_hp; MR_Stack_Layout_Entry *entry_layout; - Word *first_stack_pointer, *first_current_frame; + MR_Word *first_stack_pointer, *first_current_frame; old_heap = MR_ENGINE(heap_zone); @@ -316,7 +316,7 @@ garbage_collect(Code *success_ip, Word *stack_pointer, Word *current_frame) for (i = 0; i < var_count; i++) { MR_Stack_Layout_Var sl_var; MR_Live_Type sl_type; - Word *pseudo_type_info, *type_info; + MR_Word *pseudo_type_info, *type_info; sl_var = vars->MR_slvs_pairs[i]; if (MR_LIVE_TYPE_IS_VAR(sl_var.MR_slv_live_type)) { @@ -334,7 +334,7 @@ garbage_collect(Code *success_ip, Word *stack_pointer, Word *current_frame) MR_free(type_params); result = MR_stack_walk_step(entry_layout, &return_label_layout, - (Word **) &stack_pointer, ¤t_frame, &problem); + (MR_Word **) &stack_pointer, ¤t_frame, &problem); if (result == STEP_ERROR_BEFORE || result == STEP_ERROR_AFTER) { fatal_error(problem); @@ -388,8 +388,8 @@ garbage_collect(Code *success_ip, Word *stack_pointer, Word *current_frame) ** it is on the old heap). */ void -copy_value(MR_Live_Lval locn, Word *type_info, bool copy_regs, - Word *stack_pointer, Word *current_frame) +copy_value(MR_Live_Lval locn, MR_Word *type_info, bool copy_regs, + MR_Word *stack_pointer, MR_Word *current_frame) { int locn_num; @@ -477,7 +477,7 @@ garbage_collect_roots(void) ** Adds a new root to the extra roots. */ void -MR_agc_add_root(Word *root_addr, Word *type_info) +MR_agc_add_root(MR_Word *root_addr, MR_Word *type_info) { MR_RootList node; diff --git a/runtime/mercury_accurate_gc.h b/runtime/mercury_accurate_gc.h index 54c006221..e6db50712 100644 --- a/runtime/mercury_accurate_gc.h +++ b/runtime/mercury_accurate_gc.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1997-1998 The University of Melbourne. +** Copyright (C) 1997-1998, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -25,7 +25,7 @@ ** continuation pointer with the address of the garbage collector ** routine. */ -extern void MR_schedule_agc(Code *pc_at_signal, Word *sp_at_signal); +extern void MR_schedule_agc(MR_Code *pc_at_signal, MR_Word *sp_at_signal); /* ** Roots apart from the stacks are stored in this data structure. @@ -38,8 +38,8 @@ extern void MR_schedule_agc(Code *pc_at_signal, Word *sp_at_signal); */ struct MR_RootNode { - Word *root; - Word *type_info; + MR_Word *root; + MR_Word *type_info; struct MR_RootNode* next; }; @@ -51,7 +51,7 @@ typedef struct MR_RootNode *MR_RootList; ** described by type_info to the list of additional roots. */ -extern void MR_agc_add_root(Word *root_addr, Word *type_info); +extern void MR_agc_add_root(MR_Word *root_addr, MR_Word *type_info); /*---------------------------------------------------------------------------*/ #endif /* not MERCURY_ACCURATE_GC_H */ diff --git a/runtime/mercury_agc_debug.c b/runtime/mercury_agc_debug.c index eccae61e0..62f7c2ee2 100644 --- a/runtime/mercury_agc_debug.c +++ b/runtime/mercury_agc_debug.c @@ -1,5 +1,5 @@ /* -** Copyright (C) 1998-1999 The University of Melbourne. +** Copyright (C) 1998-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -19,7 +19,7 @@ ** Function prototypes. */ static void dump_live_value(MR_Live_Lval locn, MemoryZone *heap_zone, - Word * stack_pointer, Word *current_frame, + MR_Word * stack_pointer, MR_Word *current_frame, bool do_regs); /*---------------------------------------------------------------------------*/ @@ -28,7 +28,7 @@ static void dump_live_value(MR_Live_Lval locn, MemoryZone *heap_zone, void MR_agc_dump_roots(MR_RootList roots) { - Word saved_regs[MAX_FAKE_REG]; + MR_Word saved_regs[MAX_FAKE_REG]; fflush(NULL); fprintf(stderr, "Dumping roots\n"); @@ -52,7 +52,7 @@ MR_agc_dump_roots(MR_RootList roots) MR_virtual_hp = MR_ENGINE(debug_heap_zone->min); fflush(NULL); - MR_write_variable((Word) roots->type_info, *roots->root); + MR_write_variable((MR_Word) roots->type_info, *roots->root); fflush(NULL); fprintf(stderr, "\n"); @@ -67,15 +67,15 @@ MR_agc_dump_roots(MR_RootList roots) void MR_agc_dump_stack_frames(MR_Internal *label, MemoryZone *heap_zone, - Word *stack_pointer, Word *current_frame) + MR_Word *stack_pointer, MR_Word *current_frame) { - Word saved_regs[MAX_FAKE_REG]; + MR_Word saved_regs[MAX_FAKE_REG]; int i, var_count; const MR_Stack_Layout_Vars *vars; - Word *type_params, type_info, value; + MR_Word *type_params, type_info, value; MR_Stack_Layout_Entry *entry_layout; const MR_Stack_Layout_Label *layout; - const Code *success_ip; + const MR_Code *success_ip; bool top_frame = TRUE; layout = label->i_layout; @@ -179,7 +179,7 @@ MR_agc_dump_stack_frames(MR_Internal *label, MemoryZone *heap_zone, fatal_error("can only handle stackvars"); } - success_ip = (Code *) + success_ip = (MR_Code *) MR_based_stackvar(stack_pointer, number); stack_pointer = stack_pointer - entry_layout->MR_sle_stack_slots; @@ -194,11 +194,11 @@ MR_agc_dump_stack_frames(MR_Internal *label, MemoryZone *heap_zone, } static void -dump_live_value(MR_Live_Lval locn, MemoryZone *heap_zone, Word *stack_pointer, - Word *current_frame, bool do_regs) +dump_live_value(MR_Live_Lval locn, MemoryZone *heap_zone, MR_Word *stack_pointer, + MR_Word *current_frame, bool do_regs) { int locn_num; - Word value = 0; + MR_Word value = 0; int difference; bool have_value = FALSE; @@ -263,9 +263,9 @@ dump_live_value(MR_Live_Lval locn, MemoryZone *heap_zone, Word *stack_pointer, break; } if (have_value) { - if (value >= (Word) heap_zone->min && - value < (Word) heap_zone->hardmax) { - difference = (Word *) value - (Word *) heap_zone->min; + if (value >= (MR_Word) heap_zone->min && + value < (MR_Word) heap_zone->hardmax) { + difference = (MR_Word *) value - (MR_Word *) heap_zone->min; fprintf(stderr, "\thp[%d]\t(%lx)", difference, (long) value); } else { diff --git a/runtime/mercury_agc_debug.h b/runtime/mercury_agc_debug.h index 4de56952c..4458bac8c 100644 --- a/runtime/mercury_agc_debug.h +++ b/runtime/mercury_agc_debug.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1998 The University of Melbourne. +** Copyright (C) 1998, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -12,7 +12,7 @@ ** Debugging support for accurate garbage collection. */ -#include "mercury_types.h" /* for Word */ +#include "mercury_types.h" /* for MR_Word */ #include "mercury_label.h" /* for MR_Internal */ #include "mercury_memory_zones.h" /* for MemoryZone */ #include "mercury_accurate_gc.h" /* for MR_RootList */ @@ -29,7 +29,7 @@ */ extern void MR_agc_dump_stack_frames(MR_Internal *label, MemoryZone - *heap_zone, Word *stack_pointer, Word *current_frame); + *heap_zone, MR_Word *stack_pointer, MR_Word *current_frame); /* ** MR_agc_dump_roots: diff --git a/runtime/mercury_bootstrap.h b/runtime/mercury_bootstrap.h index a01c82546..4651d3956 100644 --- a/runtime/mercury_bootstrap.h +++ b/runtime/mercury_bootstrap.h @@ -23,8 +23,32 @@ #define MR_TypeCtorInfo_struct MR_TypeCtorInfo_Struct + #ifndef MR_NO_BACKWARDS_COMPAT +/* +** For a long time the Mercury C types were defined as Char, Float, +** Integer, Word, etc. There will doubtless be lots of C code in +** libraries that relies upon these names. +** +** People may have written code that relies upon these names, so +** if you remove these names you need to give warning (unlike some of +** the other changes in this file). +*/ + +typedef MR_Word Word; +typedef MR_Code Code; +typedef MR_Char Char; +typedef MR_Float Float; +typedef MR_Float64 Float64; +typedef MR_Integer Integer; +typedef MR_Unsigned Unsigned; +typedef MR_UnsignedChar UnsignedChar; +typedef MR_String String; +typedef MR_ConstString ConstString; +typedef MR_Bool Bool; + + #define COMPARE_EQUAL MR_COMPARE_EQUAL #define COMPARE_LESS MR_COMPARE_LESS #define COMPARE_GREATER MR_COMPARE_GREATER @@ -74,7 +98,7 @@ #define decr_sp(n) MR_decr_sp(n) #define push(w) ( \ - *MR_sp = (Word) (w), \ + *MR_sp = (MR_Word) (w), \ debugpush(*MR_sp, MR_sp), \ MR_sp = MR_sp + 1, \ detstack_overflow_check(), \ diff --git a/runtime/mercury_calls.h b/runtime/mercury_calls.h index 95f1353d7..33e9a3ced 100644 --- a/runtime/mercury_calls.h +++ b/runtime/mercury_calls.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1995-1999 The University of Melbourne. +** Copyright (C) 1995-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -23,7 +23,7 @@ } while (0) /* -** On some systems [basically those using PIC (Position Independent Code)], +** On some systems [basically those using PIC (Position Independent MR_Code)], ** if we're using gcc non-local gotos to jump between functions then ** we need to do ASM_FIXUP_REGS after each return from a procedure call. ** However, if we're using asm labels, then this is done in the diff --git a/runtime/mercury_conf.h.in b/runtime/mercury_conf.h.in index ec92ac538..3b87df977 100644 --- a/runtime/mercury_conf.h.in +++ b/runtime/mercury_conf.h.in @@ -83,9 +83,9 @@ ** in a Word, and hence must be boxed. ** Note that when bootstrapping from the source distribution, ** we initially build things without BOXED_FLOAT even on machines -** for which sizeof(Float) <= sizeof(Word). +** for which sizeof(MR_Float) <= sizeof(MR_Word). ** Conversely if BOXED_FLOAT is undefined, it implies that -** sizeof(Float) <= sizeof(Word). +** sizeof(MR_Float) <= sizeof(MR_Word). */ #undef BOXED_FLOAT diff --git a/runtime/mercury_conf_param.h b/runtime/mercury_conf_param.h index 0157e50e5..190555305 100644 --- a/runtime/mercury_conf_param.h +++ b/runtime/mercury_conf_param.h @@ -37,7 +37,7 @@ */ /* -** Code generation options: +** MR_Code generation options: ** ** MR_HIGHLEVEL_CODE ** MR_HIGHLEVEL_DATA @@ -68,7 +68,7 @@ ** ** USE_SINGLE_PREC_FLOAT: ** Use C's `float' rather than C's `double' for the -** Mercury floating point type (`Float'). +** Mercury floating point type (`MR_Float'). ** ** PARALLEL ** Enable support for parallelism [not yet working]. diff --git a/runtime/mercury_context.c b/runtime/mercury_context.c index 3c6c7b089..23778342f 100644 --- a/runtime/mercury_context.c +++ b/runtime/mercury_context.c @@ -207,7 +207,7 @@ flounder(void) ** block or not. */ static int -check_pending_contexts(Bool block) +check_pending_contexts(MR_Bool block) { #ifdef MR_CAN_DO_PENDING_IO diff --git a/runtime/mercury_context.h b/runtime/mercury_context.h index 9ee40c652..fe76256b4 100644 --- a/runtime/mercury_context.h +++ b/runtime/mercury_context.h @@ -47,7 +47,7 @@ #include -#include "mercury_types.h" /* for Word */ +#include "mercury_types.h" /* for MR_Word */ #include "mercury_trail.h" /* for MR_TrailEntry */ #include "mercury_memory.h" /* for MemoryZone */ #include "mercury_thread.h" /* for MercuryLock */ @@ -77,7 +77,7 @@ struct MR_context_struct { ** context in the runqueue. */ - Code *resume; + MR_Code *resume; /* ** a pointer to the code at which execution should resume when ** this context is next scheduled. @@ -92,28 +92,28 @@ struct MR_context_struct { */ #endif - Code *context_succip; + MR_Code *context_succip; /* succip for this context */ MemoryZone *detstack_zone; /* pointer to the detstack_zone for this context */ - Word *context_sp; + MR_Word *context_sp; /* saved stack pointer for this context */ MemoryZone *nondetstack_zone; /* pointer to the nondetstack_zone for this context */ - Word *context_maxfr; + MR_Word *context_maxfr; /* saved maxfr pointer for this context */ - Word *context_curfr; + MR_Word *context_curfr; /* saved curfr pointer for this context */ #ifdef MR_USE_MINIMAL_MODEL MemoryZone *generatorstack_zone; /* pointer to the generatorstack_zone for this context */ - Integer context_gen_next; + MR_Integer context_gen_next; /* saved generator stack index for this context */ MemoryZone *cutstack_zone; /* pointer to the cutstack_zone for this context */ - Integer context_cut_next; + MR_Integer context_cut_next; /* saved cut stack index for this context */ #endif @@ -128,9 +128,9 @@ struct MR_context_struct { /* saved MR_ticket_high_water for this context */ #endif - Word *context_hp; + MR_Word *context_hp; /* saved hp for this context */ - Word *min_hp_rec; + MR_Word *min_hp_rec; /* ** this pointer marks the minimum value of MR_hp to which we can ** truncate the heap on backtracking. See comments before the @@ -240,7 +240,7 @@ Declare_entry(do_runnext); #endif /* -** fork_new_context(Code *child, Code *parent, int numslots): +** fork_new_context(MR_Code *child, MR_Code *parent, int numslots): ** create a new context to execute the code at `child', and ** copy the topmost `numslots' from the current stackframe. ** The new context gets put on the runqueue, and the current diff --git a/runtime/mercury_debug.c b/runtime/mercury_debug.c index a01766618..8c011d903 100644 --- a/runtime/mercury_debug.c +++ b/runtime/mercury_debug.c @@ -17,7 +17,7 @@ /*--------------------------------------------------------------------*/ static void print_ordinary_regs(void); -static void MR_printdetslot_as_label(const Integer offset); +static void MR_printdetslot_as_label(const MR_Integer offset); /* debugging messages */ @@ -93,7 +93,7 @@ redo_msg(void) } void -call_msg(/* const */ Code *proc, /* const */ Code *succcont) +call_msg(/* const */ MR_Code *proc, /* const */ MR_Code *succcont) { printf("\ncalling "); printlabel(proc); printf("continuation "); printlabel(succcont); @@ -101,7 +101,7 @@ call_msg(/* const */ Code *proc, /* const */ Code *succcont) } void -tailcall_msg(/* const */ Code *proc) +tailcall_msg(/* const */ MR_Code *proc) { restore_transient_registers(); @@ -118,56 +118,56 @@ proceed_msg(void) } void -cr1_msg(Word val0, const Word *addr) +cr1_msg(MR_Word val0, const MR_Word *addr) { - printf("put value %9lx at ", (long) (Integer) val0); + printf("put value %9lx at ", (long) (MR_Integer) val0); printheap(addr); } void -cr2_msg(Word val0, Word val1, const Word *addr) +cr2_msg(MR_Word val0, MR_Word val1, const MR_Word *addr) { printf("put values %9lx,%9lx at ", - (long) (Integer) val0, (long) (Integer) val1); + (long) (MR_Integer) val0, (long) (MR_Integer) val1); printheap(addr); } void -incr_hp_debug_msg(Word val, const Word *addr) +incr_hp_debug_msg(MR_Word val, const MR_Word *addr) { #ifdef CONSERVATIVE_GC printf("allocated %ld words at %p\n", (long) val, addr); #else - printf("increment hp by %ld from ", (long) (Integer) val); + printf("increment hp by %ld from ", (long) (MR_Integer) val); printheap(addr); #endif } void -incr_sp_msg(Word val, const Word *addr) +incr_sp_msg(MR_Word val, const MR_Word *addr) { - printf("increment sp by %ld from ", (long) (Integer) val); + printf("increment sp by %ld from ", (long) (MR_Integer) val); printdetstack(addr); } void -decr_sp_msg(Word val, const Word *addr) +decr_sp_msg(MR_Word val, const MR_Word *addr) { - printf("decrement sp by %ld from ", (long) (Integer) val); + printf("decrement sp by %ld from ", (long) (MR_Integer) val); printdetstack(addr); } void -push_msg(Word val, const Word *addr) +push_msg(MR_Word val, const MR_Word *addr) { - printf("push value %9lx to ", (long) (Integer) val); + printf("push value %9lx to ", (long) (MR_Integer) val); printdetstack(addr); } void -pop_msg(Word val, const Word *addr) +pop_msg(MR_Word val, const MR_Word *addr) { - printf("pop value %9lx from ", (long) (Integer) val); + printf("pop value %9lx from ", (long) (MR_Integer) val); printdetstack(addr); } @@ -176,7 +176,7 @@ pop_msg(Word val, const Word *addr) #ifdef MR_DEBUG_GOTOS void -goto_msg(/* const */ Code *addr) +goto_msg(/* const */ MR_Code *addr) { printf("\ngoto "); printlabel(addr); @@ -186,14 +186,14 @@ void reg_msg(void) { int i; - Integer x; + MR_Integer x; for(i=1; i<=8; i++) { - x = (Integer) get_reg(i); + x = (MR_Integer) get_reg(i); #ifndef CONSERVATIVE_GC - if ((Integer) MR_ENGINE(heap_zone)->min <= x - && x < (Integer) MR_ENGINE(heap_zone)->top) { - x -= (Integer) MR_ENGINE(heap_zone)->min; + if ((MR_Integer) MR_ENGINE(heap_zone)->min <= x + && x < (MR_Integer) MR_ENGINE(heap_zone)->top) { + x -= (MR_Integer) MR_ENGINE(heap_zone)->min; } #endif printf("%8lx ", (long) x); @@ -210,9 +210,9 @@ reg_msg(void) /* debugging printing tools */ void -printint(Word n) +printint(MR_Word n) { - printf("int %ld\n", (long) (Integer) n); + printf("int %ld\n", (long) (MR_Integer) n); } void @@ -222,12 +222,12 @@ printstring(const char *s) } void -printheap(const Word *h) +printheap(const MR_Word *h) { #ifndef CONSERVATIVE_GC printf("ptr %p, offset %3ld words\n", (const void *) h, - (long) (Integer) (h - MR_ENGINE(heap_zone)->min)); + (long) (MR_Integer) (h - MR_ENGINE(heap_zone)->min)); #else printf("ptr %p\n", (const void *) h); @@ -235,13 +235,13 @@ printheap(const Word *h) } void -dumpframe(/* const */ Word *fr) +dumpframe(/* const */ MR_Word *fr) { reg int i; printf("frame at ptr %p, offset %3ld words\n", (const void *) fr, - (long) (Integer) (fr - MR_CONTEXT(nondetstack_zone)->min)); + (long) (MR_Integer) (fr - MR_CONTEXT(nondetstack_zone)->min)); printf("\t succip "); printlabel(MR_succip_slot(fr)); printf("\t redoip "); printlabel(MR_redoip_slot(fr)); printf("\t succfr "); printnondstack(MR_succfr_slot(fr)); @@ -249,7 +249,7 @@ dumpframe(/* const */ Word *fr) for (i = 1; &MR_based_framevar(fr,i) > MR_prevfr_slot(fr); i++) { printf("\t framevar(%d) %ld 0x%lx\n", - i, (long) (Integer) MR_based_framevar(fr,i), + i, (long) (MR_Integer) MR_based_framevar(fr,i), (unsigned long) MR_based_framevar(fr,i)); } } @@ -257,7 +257,7 @@ dumpframe(/* const */ Word *fr) void dumpnondstack(void) { - reg Word *fr; + reg MR_Word *fr; printf("\nnondstack dump\n"); for (fr = MR_maxfr; fr > MR_CONTEXT(nondetstack_zone)->min; @@ -295,15 +295,15 @@ static void print_ordinary_regs(void) { int i; - Integer value; + MR_Integer value; for (i = 0; i < 8; i++) { printf("r%d: ", i + 1); - value = (Integer) get_reg(i+1); + value = (MR_Integer) get_reg(i+1); #ifndef CONSERVATIVE_GC - if ((Integer) MR_ENGINE(heap_zone)->min <= value && - value < (Integer) MR_ENGINE(heap_zone)->top) { + if ((MR_Integer) MR_ENGINE(heap_zone)->min <= value && + value < (MR_Integer) MR_ENGINE(heap_zone)->top) { printf("(heap) "); } #endif @@ -321,72 +321,72 @@ print_ordinary_regs(void) #endif /* defined(MR_DEBUG_GOTOS) */ static void -MR_printdetslot_as_label(const Integer offset) +MR_printdetslot_as_label(const MR_Integer offset) { MR_printdetstackptr(&MR_CONTEXT(detstack_zone)->min[offset]); printf(" "); - printlabel((Code *) (MR_CONTEXT(detstack_zone)->min[offset])); + printlabel((MR_Code *) (MR_CONTEXT(detstack_zone)->min[offset])); } void -MR_printdetstackptr(const Word *s) +MR_printdetstackptr(const MR_Word *s) { MR_print_detstackptr(stdout, s); } void -MR_print_detstackptr(FILE *fp, const Word *s) +MR_print_detstackptr(FILE *fp, const MR_Word *s) { fprintf(fp, "det %3ld (%p)", - (long) (Integer) (s - MR_CONTEXT(detstack_zone)->min), + (long) (MR_Integer) (s - MR_CONTEXT(detstack_zone)->min), (const void *) s); } void -printdetstack(const Word *s) +printdetstack(const MR_Word *s) { printf("ptr %p, offset %3ld words\n", (const void *) s, - (long) (Integer) (s - MR_CONTEXT(detstack_zone)->min)); + (long) (MR_Integer) (s - MR_CONTEXT(detstack_zone)->min)); } void -MR_printnondstackptr(const Word *s) +MR_printnondstackptr(const MR_Word *s) { MR_print_nondstackptr(stdout, s); } void -MR_print_nondstackptr(FILE *fp, const Word *s) +MR_print_nondstackptr(FILE *fp, const MR_Word *s) { fprintf(fp, "non %3ld (%p)", - (long) (Integer) (s - MR_CONTEXT(nondetstack_zone)->min), + (long) (MR_Integer) (s - MR_CONTEXT(nondetstack_zone)->min), (const void *) s); } void -printnondstack(const Word *s) +printnondstack(const MR_Word *s) { printf("ptr %p, offset %3ld words\n", (const void *) s, - (long) (Integer) (s - MR_CONTEXT(nondetstack_zone)->min)); + (long) (MR_Integer) (s - MR_CONTEXT(nondetstack_zone)->min)); } void -MR_print_heapptr(FILE *fp, const Word *s) +MR_print_heapptr(FILE *fp, const MR_Word *s) { #ifdef CONSERVATIVE_GC fprintf(fp, "heap %ld (%p)", (long) s, (const void *) s); #else fprintf(fp, "heap %3ld (%p)", - (long) (Integer) (s - MR_ENGINE(heap_zone)->min), + (long) (MR_Integer) (s - MR_ENGINE(heap_zone)->min), (const void *) s); #endif } void -MR_print_label(FILE *fp, /* const */ Code *w) +MR_print_label(FILE *fp, /* const */ MR_Code *w) { MR_Internal *internal; @@ -416,7 +416,7 @@ MR_print_label(FILE *fp, /* const */ Code *w) } void -printlabel(/* const */ Code *w) +printlabel(/* const */ MR_Code *w) { MR_print_label(stdout, w); fprintf(stdout, "\n"); diff --git a/runtime/mercury_debug.h b/runtime/mercury_debug.h index 449d783a0..f823988d4 100644 --- a/runtime/mercury_debug.h +++ b/runtime/mercury_debug.h @@ -9,7 +9,7 @@ #ifndef MERCURY_DEBUG_H #define MERCURY_DEBUG_H -#include "mercury_types.h" /* for `Word' and `Code' */ +#include "mercury_types.h" /* for `MR_Word' and `MR_Code' */ #include /* for `FILE' */ /*---------------------------------------------------------------------------*/ @@ -149,43 +149,43 @@ extern void succeed_msg(void); extern void succeeddiscard_msg(void); extern void fail_msg(void); extern void redo_msg(void); -extern void call_msg(/* const */ Code *proc, /* const */ Code *succcont); -extern void tailcall_msg(/* const */ Code *proc); +extern void call_msg(/* const */ MR_Code *proc, /* const */ MR_Code *succcont); +extern void tailcall_msg(/* const */ MR_Code *proc); extern void proceed_msg(void); -extern void cr1_msg(Word val0, const Word *addr); -extern void cr2_msg(Word val0, Word val1, const Word *addr); -extern void incr_hp_debug_msg(Word val, const Word *addr); -extern void incr_sp_msg(Word val, const Word *addr); -extern void decr_sp_msg(Word val, const Word *addr); -extern void push_msg(Word val, const Word *addr); -extern void pop_msg(Word val, const Word *addr); +extern void cr1_msg(MR_Word val0, const MR_Word *addr); +extern void cr2_msg(MR_Word val0, MR_Word val1, const MR_Word *addr); +extern void incr_hp_debug_msg(MR_Word val, const MR_Word *addr); +extern void incr_sp_msg(MR_Word val, const MR_Word *addr); +extern void decr_sp_msg(MR_Word val, const MR_Word *addr); +extern void push_msg(MR_Word val, const MR_Word *addr); +extern void pop_msg(MR_Word val, const MR_Word *addr); #endif #ifdef MR_DEBUG_GOTOS -extern void goto_msg(/* const */ Code *addr); +extern void goto_msg(/* const */ MR_Code *addr); extern void reg_msg(void); #endif #ifdef MR_LOWLEVEL_DEBUG -extern void printint(Word n); +extern void printint(MR_Word n); extern void printstring(const char *s); -extern void printheap(const Word *h); -extern void dumpframe(/* const */ Word *); +extern void printheap(const MR_Word *h); +extern void dumpframe(/* const */ MR_Word *); extern void dumpnondstack(void); -extern void printlist(Word p); +extern void printlist(MR_Word p); extern void printframe(const char *); extern void printregs(const char *msg); #endif -extern void printdetstack(const Word *s); -extern void MR_printdetstackptr(const Word *s); -extern void MR_print_detstackptr(FILE *fp, const Word *s); -extern void printnondstack(const Word *s); -extern void MR_printnondstackptr(const Word *s); -extern void MR_print_nondstackptr(FILE *fp, const Word *s); -extern void MR_print_heapptr(FILE *fp, const Word *s); -extern void MR_print_label(FILE *fp, /* const */ Code *w); -extern void printlabel(/* const */ Code *w); +extern void printdetstack(const MR_Word *s); +extern void MR_printdetstackptr(const MR_Word *s); +extern void MR_print_detstackptr(FILE *fp, const MR_Word *s); +extern void printnondstack(const MR_Word *s); +extern void MR_printnondstackptr(const MR_Word *s); +extern void MR_print_nondstackptr(FILE *fp, const MR_Word *s); +extern void MR_print_heapptr(FILE *fp, const MR_Word *s); +extern void MR_print_label(FILE *fp, /* const */ MR_Code *w); +extern void printlabel(/* const */ MR_Code *w); /*---------------------------------------------------------------------------*/ diff --git a/runtime/mercury_deep_copy.c b/runtime/mercury_deep_copy.c index e99b4d408..33a800c57 100644 --- a/runtime/mercury_deep_copy.c +++ b/runtime/mercury_deep_copy.c @@ -110,10 +110,10 @@ ** MR_make_long_lived(): see mercury_deep_copy.h for documentation. */ -Word -MR_make_long_lived(Word term, MR_TypeInfo type_info, Word *lower_limit) +MR_Word +MR_make_long_lived(MR_Word term, MR_TypeInfo type_info, MR_Word *lower_limit) { - Word result; + MR_Word result; restore_transient_hp(); /* Because we play with MR_hp */ @@ -124,7 +124,7 @@ MR_make_long_lived(Word term, MR_TypeInfo type_info, Word *lower_limit) /* temporarily swap the heap with the global heap */ SWAP(MR_heap_zone, MR_global_heap_zone, MemoryZone *); - SWAP(MR_hp, MR_global_hp, Word *); + SWAP(MR_hp, MR_global_hp, MR_Word *); /* copy values from the heap to the global heap */ save_transient_hp(); @@ -134,7 +134,7 @@ MR_make_long_lived(Word term, MR_TypeInfo type_info, Word *lower_limit) /* swap the heap and global heap back again */ SWAP(MR_heap_zone, MR_global_heap_zone, MemoryZone *); - SWAP(MR_hp, MR_global_hp, Word *); + SWAP(MR_hp, MR_global_hp, MR_Word *); save_transient_hp(); /* Because we played with MR_hp */ diff --git a/runtime/mercury_deep_copy.h b/runtime/mercury_deep_copy.h index 441ec7a3b..a4cb0d9a9 100644 --- a/runtime/mercury_deep_copy.h +++ b/runtime/mercury_deep_copy.h @@ -9,7 +9,7 @@ #ifndef MERCURY_DEEP_COPY_H #define MERCURY_DEEP_COPY_H -#include "mercury_types.h" /* for `Word' */ +#include "mercury_types.h" /* for `MR_Word' */ #include "mercury_type_info.h" /* for `MR_TypeInfo' */ /* @@ -64,8 +64,8 @@ ** deep_copy to do both. */ -Word deep_copy(const Word *data_ptr, MR_TypeInfo type_info, - const Word *lower_limit, const Word *upper_limit); +MR_Word deep_copy(const MR_Word *data_ptr, MR_TypeInfo type_info, + const MR_Word *lower_limit, const MR_Word *upper_limit); /* ** agc_deep_copy: @@ -91,8 +91,8 @@ Word deep_copy(const Word *data_ptr, MR_TypeInfo type_info, ** Note: You cannot pass NULL as the lower_limit to agc_deep_copy ** (which is possible with normal deep_copy). */ -Word agc_deep_copy(Word *data_ptr, MR_TypeInfo type_info, - const Word *lower_limit, const Word *upper_limit); +MR_Word agc_deep_copy(MR_Word *data_ptr, MR_TypeInfo type_info, + const MR_Word *lower_limit, const MR_Word *upper_limit); /* ** MR_make_permanent: @@ -130,7 +130,7 @@ Word agc_deep_copy(Word *data_ptr, MR_TypeInfo type_info, #ifdef CONSERVATIVE_GC #define MR_make_long_lived(term, type_info, lower_limit) (term) #else - Word MR_make_long_lived(Word term, MR_TypeInfo type_info, Word *lower_limit); + MR_Word MR_make_long_lived(MR_Word term, MR_TypeInfo type_info, MR_Word *lower_limit); #endif #endif /* not MERCURY_DEEP_COPY_H */ diff --git a/runtime/mercury_deep_copy_body.h b/runtime/mercury_deep_copy_body.h index 89110162c..752563b46 100644 --- a/runtime/mercury_deep_copy_body.h +++ b/runtime/mercury_deep_copy_body.h @@ -15,23 +15,23 @@ /* ** Prototypes. */ -static Word copy_arg(maybeconst Word *parent_data_ptr, - maybeconst Word *data_ptr, +static MR_Word copy_arg(maybeconst MR_Word *parent_data_ptr, + maybeconst MR_Word *data_ptr, const MR_DuFunctorDesc *functor_descriptor, const MR_TypeInfoParams type_params, const MR_PseudoTypeInfo arg_pseudotype_info, - const Word *lower_limit, const Word *upper_limit); + const MR_Word *lower_limit, const MR_Word *upper_limit); static MR_TypeInfo copy_type_info(maybeconst MR_TypeInfo *type_info_ptr, - const Word *lower_limit, const Word *upper_limit); -static Word copy_typeclass_info(maybeconst Word *typeclass_info_ptr, - const Word *lower_limit, const Word *upper_limit); + const MR_Word *lower_limit, const MR_Word *upper_limit); +static MR_Word copy_typeclass_info(maybeconst MR_Word *typeclass_info_ptr, + const MR_Word *lower_limit, const MR_Word *upper_limit); -Word -copy(maybeconst Word *data_ptr, MR_TypeInfo type_info, - const Word *lower_limit, const Word *upper_limit) +MR_Word +copy(maybeconst MR_Word *data_ptr, MR_TypeInfo type_info, + const MR_Word *lower_limit, const MR_Word *upper_limit) { - Word data; - Word new_data; + MR_Word data; + MR_Word new_data; MR_TypeCtorInfo type_ctor_info; data = *data_ptr; @@ -51,7 +51,7 @@ try_again: { MR_DuPtagLayout *ptag_layout; int ptag; - Word *data_value; + MR_Word *data_value; ptag = MR_tag(data); ptag_layout = &type_ctor_info->type_layout.layout_du[ptag]; @@ -76,7 +76,7 @@ try_again: ** case MR_SECTAG_REMOTE: ** case MR_SECTAG_NONE: ** -** data_value = (Word *) MR_body(data, ptag); +** data_value = (MR_Word *) MR_body(data, ptag); ** if (in_range(data_value)) { ** const MR_DuFunctorDesc *functor_desc; ** const MR_DuExistInfo *exist_info; @@ -123,7 +123,7 @@ try_again: ** } ** ** for (i = 0; i < num_ti_plain; i++) { -** MR_field(0, new_data, cur_slot) = (Word) +** MR_field(0, new_data, cur_slot) = (MR_Word) ** copy_type_info((MR_TypeInfo *) ** &data_value[cur_slot], ** lower_limit, upper_limit); @@ -131,7 +131,7 @@ try_again: ** } ** ** for (i = 0; i < num_tci; i++) { -** MR_field(0, new_data, cur_slot) = (Word) +** MR_field(0, new_data, cur_slot) = (MR_Word) ** copy_typeclass_info(&data_value[cur_slot], ** lower_limit, upper_limit); ** cur_slot++; @@ -156,7 +156,7 @@ try_again: ** cur_slot++; ** } ** -** new_data = (Word) MR_mkword(ptag, new_data); +** new_data = (MR_Word) MR_mkword(ptag, new_data); ** leave_forwarding_pointer(data_ptr, new_data); ** } else { ** new_data = data; @@ -193,7 +193,7 @@ try_again: #define MR_DC_copy_exist_info \ for (i = 0; i < num_ti_plain; i++) { \ - MR_field(0, new_data, cur_slot) = (Word) \ + MR_field(0, new_data, cur_slot) = (MR_Word) \ copy_type_info((MR_TypeInfo *) \ &data_value[cur_slot], \ lower_limit, upper_limit); \ @@ -201,7 +201,7 @@ try_again: } \ \ for (i = 0; i < num_tci; i++) { \ - MR_field(0, new_data, cur_slot) = (Word) \ + MR_field(0, new_data, cur_slot) = (MR_Word) \ copy_typeclass_info(&data_value[cur_slot], \ lower_limit, upper_limit); \ cur_slot++; \ @@ -233,7 +233,7 @@ try_again: */ case MR_SECTAG_REMOTE: - data_value = (Word *) MR_body(data, ptag); + data_value = (MR_Word *) MR_body(data, ptag); if (in_range(data_value)) { MR_DC_decl sectag = data_value[0]; @@ -252,7 +252,7 @@ try_again: } MR_DC_copy_plain_args - new_data = (Word) MR_mkword(ptag, new_data); + new_data = (MR_Word) MR_mkword(ptag, new_data); leave_forwarding_pointer(data_ptr, new_data); } else { new_data = data; @@ -266,7 +266,7 @@ try_again: */ case MR_SECTAG_NONE: - data_value = (Word *) MR_body(data, ptag); + data_value = (MR_Word *) MR_body(data, ptag); if (in_range(data_value)) { MR_DC_decl sectag = 0; @@ -283,7 +283,7 @@ try_again: } MR_DC_copy_plain_args - new_data = (Word) MR_mkword(ptag, new_data); + new_data = (MR_Word) MR_mkword(ptag, new_data); leave_forwarding_pointer(data_ptr, new_data); } else { new_data = data; @@ -342,10 +342,10 @@ try_again: case MR_TYPECTOR_REP_FLOAT: #ifdef BOXED_FLOAT { - Word *data_value; + MR_Word *data_value; assert(MR_tag(data) == 0); - data_value = (Word *) MR_body(data, MR_mktag(0)); + data_value = (MR_Word *) MR_body(data, MR_mktag(0)); if (in_range(data_value)) { restore_transient_hp(); @@ -370,10 +370,11 @@ try_again: ** allocated unaligned storage by the C compiler. */ - if (in_range((Word *) data)) { + if (in_range((MR_Word *) data)) { incr_saved_hp_atomic(new_data, - (strlen((String) data) + sizeof(Word)) / sizeof(Word)); - strcpy((String) new_data, (String) data); + (strlen((MR_String) data) + sizeof(MR_Word)) / + sizeof(MR_Word)); + strcpy((MR_String) new_data, (MR_String) data); leave_forwarding_pointer(data_ptr, new_data); } else { new_data = data; @@ -384,21 +385,21 @@ try_again: case MR_TYPECTOR_REP_PRED: { - Word *data_value; + MR_Word *data_value; assert(MR_tag(data) == 0); - data_value = (Word *) MR_body(data, MR_mktag(0)); + data_value = (MR_Word *) MR_body(data, MR_mktag(0)); /* ** predicate closures store the number of curried arguments - ** as their first argument, the Code * as their second, and + ** as their first argument, the MR_Code * as their second, and ** then the arguments ** ** Their type-infos have a pointer to type_ctor_info for ** pred/0, arity, and then argument typeinfos. */ if (in_range(data_value)) { - Unsigned args, i; + MR_Unsigned args, i; MR_Closure *old_closure; MR_Closure *new_closure; MR_Closure_Layout *closure_layout; @@ -409,7 +410,7 @@ try_again: args = old_closure->MR_closure_num_hidden_args; /* create new closure */ - incr_saved_hp(LVALUE_CAST(Word, new_closure), args + 3); + incr_saved_hp(LVALUE_CAST(MR_Word, new_closure), args + 3); /* copy the fixed fields */ new_closure->MR_closure_layout = closure_layout; @@ -435,7 +436,7 @@ try_again: lower_limit, upper_limit); } - new_data = (Word) new_closure; + new_data = (MR_Word) new_closure; leave_forwarding_pointer(data_ptr, new_data); } else { new_data = data; @@ -446,18 +447,18 @@ try_again: case MR_TYPECTOR_REP_UNIV: { - Word *data_value; + MR_Word *data_value; assert(MR_tag(data) == 0); - data_value = (Word *) MR_body(data, MR_mktag(0)); + data_value = (MR_Word *) MR_body(data, MR_mktag(0)); /* if the univ is stored in range, copy it */ if (in_range(data_value)) { - Word *new_data_ptr; + MR_Word *new_data_ptr; /* allocate space for a univ */ incr_saved_hp(new_data, 2); - new_data_ptr = (Word *) new_data; + new_data_ptr = (MR_Word *) new_data; /* ** Copy the fields across. ** Note: we must copy the data before the type_info, @@ -471,7 +472,7 @@ try_again: data_value[UNIV_OFFSET_FOR_TYPEINFO], lower_limit, upper_limit); new_data_ptr[UNIV_OFFSET_FOR_TYPEINFO] = - (Word) copy_type_info( + (MR_Word) copy_type_info( (MR_TypeInfo *) &data_value[UNIV_OFFSET_FOR_TYPEINFO], lower_limit, upper_limit); leave_forwarding_pointer(data_ptr, new_data); @@ -488,16 +489,16 @@ try_again: case MR_TYPECTOR_REP_ARRAY: { - Word *data_value; + MR_Word *data_value; int i; assert(MR_tag(data) == 0); - data_value = (Word *) MR_body(data, MR_mktag(0)); + data_value = (MR_Word *) MR_body(data, MR_mktag(0)); if (in_range(data_value)) { MR_ArrayType *new_array; MR_ArrayType *old_array; - Integer array_size; + MR_Integer array_size; old_array = (MR_ArrayType *) data_value; array_size = old_array->size; @@ -509,7 +510,7 @@ try_again: MR_TYPEINFO_GET_FIRST_ORDER_ARG_VECTOR(type_info), (const MR_PseudoTypeInfo) 1, lower_limit, upper_limit); } - new_data = (Word) new_array; + new_data = (MR_Word) new_array; leave_forwarding_pointer(data_ptr, new_data); } else { new_data = data; @@ -519,18 +520,18 @@ try_again: break; case MR_TYPECTOR_REP_TYPEINFO: - new_data = (Word) copy_type_info((MR_TypeInfo *) data_ptr, + new_data = (MR_Word) copy_type_info((MR_TypeInfo *) data_ptr, lower_limit, upper_limit); break; case MR_TYPECTOR_REP_C_POINTER: { - Word *data_value; + MR_Word *data_value; int data_tag; /* XXX simplify: tag should be zero */ data_tag = MR_tag(data); - data_value = (Word *) MR_body(data, data_tag); + data_value = (MR_Word *) MR_body(data, data_tag); if (in_range(data_value)) { /* @@ -591,16 +592,16 @@ try_again: ** existentially quantified. */ -static Word -copy_arg(maybeconst Word *parent_data_ptr, maybeconst Word *data_ptr, +static MR_Word +copy_arg(maybeconst MR_Word *parent_data_ptr, maybeconst MR_Word *data_ptr, const MR_DuFunctorDesc *functor_descriptor, const MR_TypeInfoParams type_params, const MR_PseudoTypeInfo arg_pseudo_type_info, - const Word *lower_limit, const Word *upper_limit) + const MR_Word *lower_limit, const MR_Word *upper_limit) { MR_MemoryList allocated_memory_cells; MR_TypeInfo new_type_info; - Word new_data; + MR_Word new_data; allocated_memory_cells = NULL; new_type_info = MR_make_type_info_maybe_existq(type_params, @@ -614,14 +615,14 @@ copy_arg(maybeconst Word *parent_data_ptr, maybeconst Word *data_ptr, } static MR_TypeInfo -copy_type_info(maybeconst MR_TypeInfo *type_info_ptr, const Word *lower_limit, - const Word *upper_limit) +copy_type_info(maybeconst MR_TypeInfo *type_info_ptr, const MR_Word *lower_limit, + const MR_Word *upper_limit) { MR_TypeInfo type_info = *type_info_ptr; - if (in_range((Word *) type_info)) { + if (in_range((MR_Word *) type_info)) { MR_TypeCtorInfo type_ctor_info; - Word *new_type_info_arena; + MR_Word *new_type_info_arena; MR_TypeInfo *type_info_args; MR_TypeInfo *new_type_info_args; int arity; @@ -640,7 +641,7 @@ copy_type_info(maybeconst MR_TypeInfo *type_info_ptr, const Word *lower_limit, ** we can just return the type_ctor_info. */ - if ((Word) type_info == (Word) type_ctor_info) { + if ((MR_Word) type_info == (MR_Word) type_ctor_info) { return (MR_TypeInfo) type_ctor_info; } @@ -648,14 +649,14 @@ copy_type_info(maybeconst MR_TypeInfo *type_info_ptr, const Word *lower_limit, arity = MR_TYPEINFO_GET_HIGHER_ORDER_ARITY(type_info); type_info_args = MR_TYPEINFO_GET_HIGHER_ORDER_ARG_VECTOR(type_info); - incr_saved_hp(LVALUE_CAST(Word, new_type_info_arena), + incr_saved_hp(LVALUE_CAST(MR_Word, new_type_info_arena), MR_higher_order_type_info_size(arity)); MR_fill_in_higher_order_type_info(new_type_info_arena, type_ctor_info, arity, new_type_info_args); } else { arity = type_ctor_info->arity; type_info_args = MR_TYPEINFO_GET_FIRST_ORDER_ARG_VECTOR(type_info); - incr_saved_hp(LVALUE_CAST(Word, new_type_info_arena), + incr_saved_hp(LVALUE_CAST(MR_Word, new_type_info_arena), MR_first_order_type_info_size(arity)); MR_fill_in_first_order_type_info(new_type_info_arena, type_ctor_info, new_type_info_args); @@ -664,8 +665,8 @@ copy_type_info(maybeconst MR_TypeInfo *type_info_ptr, const Word *lower_limit, new_type_info_args[i] = copy_type_info(&type_info_args[i], lower_limit, upper_limit); } - leave_forwarding_pointer((Word *) type_info_ptr, - (Word) new_type_info_arena); + leave_forwarding_pointer((MR_Word *) type_info_ptr, + (MR_Word) new_type_info_arena); return (MR_TypeInfo) new_type_info_arena; } else { found_forwarding_pointer(type_info); @@ -673,15 +674,15 @@ copy_type_info(maybeconst MR_TypeInfo *type_info_ptr, const Word *lower_limit, } } -static Word -copy_typeclass_info(maybeconst Word *typeclass_info_ptr, - const Word *lower_limit, const Word *upper_limit) +static MR_Word +copy_typeclass_info(maybeconst MR_Word *typeclass_info_ptr, + const MR_Word *lower_limit, const MR_Word *upper_limit) { - Word *typeclass_info = (Word *) *typeclass_info_ptr; + MR_Word *typeclass_info = (MR_Word *) *typeclass_info_ptr; if (in_range(typeclass_info)) { - Word *base_typeclass_info; - Word *new_typeclass_info; + MR_Word *base_typeclass_info; + MR_Word *new_typeclass_info; int num_arg_typeinfos; int num_super; int num_instance_constraints; @@ -693,7 +694,7 @@ copy_typeclass_info(maybeconst Word *typeclass_info_ptr, ** allocated statically, so we never copy them. */ - base_typeclass_info = (Word *) *typeclass_info; + base_typeclass_info = (MR_Word *) *typeclass_info; num_instance_constraints = MR_typeclass_info_num_instance_constraints(typeclass_info); @@ -702,17 +703,17 @@ copy_typeclass_info(maybeconst Word *typeclass_info_ptr, - num_instance_constraints; num_super = MR_typeclass_info_num_superclasses(typeclass_info); num_arg_typeinfos = MR_typeclass_info_num_type_infos(typeclass_info); - incr_saved_hp(LVALUE_CAST(Word, new_typeclass_info), + incr_saved_hp(LVALUE_CAST(MR_Word, new_typeclass_info), num_instance_constraints + num_super + num_arg_typeinfos + 1); - new_typeclass_info[0] = (Word) base_typeclass_info; + new_typeclass_info[0] = (MR_Word) base_typeclass_info; /* ** First, copy typeinfos for unconstrained tvars from ** the instance declaration */ for (i = 1; i < num_unconstrained + 1; i++) { - new_typeclass_info[i] = (Word) copy_type_info( + new_typeclass_info[i] = (MR_Word) copy_type_info( (MR_TypeInfo *)(&typeclass_info[i]), lower_limit, upper_limit); } /* @@ -725,7 +726,7 @@ copy_typeclass_info(maybeconst Word *typeclass_info_ptr, i < num_unconstrained + num_instance_constraints + num_super + 1; i++) { - new_typeclass_info[i] = (Word) copy_typeclass_info( + new_typeclass_info[i] = (MR_Word) copy_typeclass_info( &typeclass_info[i], lower_limit, upper_limit); } @@ -738,14 +739,14 @@ copy_typeclass_info(maybeconst Word *typeclass_info_ptr, num_super + num_arg_typeinfos + 1; i++) { - new_typeclass_info[i] = (Word) copy_type_info( + new_typeclass_info[i] = (MR_Word) copy_type_info( (MR_TypeInfo *) &typeclass_info[i], lower_limit, upper_limit); } leave_forwarding_pointer(typeclass_info_ptr, - (Word) new_typeclass_info); - return (Word) new_typeclass_info; + (MR_Word) new_typeclass_info); + return (MR_Word) new_typeclass_info; } else { found_forwarding_pointer(typeclass_info); - return (Word) typeclass_info; + return (MR_Word) typeclass_info; } } diff --git a/runtime/mercury_engine.c b/runtime/mercury_engine.c index 0ce557622..a14743b6b 100644 --- a/runtime/mercury_engine.c +++ b/runtime/mercury_engine.c @@ -28,11 +28,11 @@ ENDINIT #endif -static void call_engine_inner(Code *entry_point) NO_RETURN; +static void call_engine_inner(MR_Code *entry_point) NO_RETURN; #ifndef USE_GCC_NONLOCAL_GOTOS - static Code *engine_done(void); - static Code *engine_init_registers(void); + static MR_Code *engine_done(void); + static MR_Code *engine_init_registers(void); #endif bool MR_debugflag[MR_MAXFLAG]; @@ -152,8 +152,8 @@ destroy_engine(MercuryEngine *eng) /*---------------------------------------------------------------------------*/ /* -** Word * -** MR_call_engine(Code *entry_point, bool catch_exceptions) +** MR_Word * +** MR_call_engine(MR_Code *entry_point, bool catch_exceptions) ** ** This routine calls a Mercury routine from C. ** @@ -203,14 +203,14 @@ destroy_engine(MercuryEngine *eng) ** and another portable version that works on standard ANSI C compilers. */ -Word * -MR_call_engine(Code *entry_point, bool catch_exceptions) +MR_Word * +MR_call_engine(MR_Code *entry_point, bool catch_exceptions) { jmp_buf curr_jmp_buf; jmp_buf * volatile prev_jmp_buf; #if defined(PROFILE_TIME) - Code * volatile prev_proc; + MR_Code * volatile prev_proc; #endif /* @@ -242,8 +242,8 @@ MR_call_engine(Code *entry_point, bool catch_exceptions) #endif if (setjmp(curr_jmp_buf)) { - Word * this_frame; - Word * exception; + MR_Word * this_frame; + MR_Word * exception; #ifdef MR_DEBUG_JMPBUFS printf("engine caught jmp %p %p\n", @@ -343,7 +343,7 @@ MR_call_engine(Code *entry_point, bool catch_exceptions) /* The gcc-specific version */ static void -call_engine_inner(Code *entry_point) +call_engine_inner(MR_Code *entry_point) { /* ** Allocate some space for local variables in other @@ -544,7 +544,7 @@ dump_prev_locations(void) {} ** would get mucked up because of the function call from call_engine_inner(). */ -static Code * +static MR_Code * engine_done(void) { MR_ENGINE(e_exception) = NULL; @@ -553,11 +553,11 @@ engine_done(void) longjmp(*(MR_ENGINE(e_jmp_buf)), 1); } -static Code * +static MR_Code * engine_init_registers(void) { restore_transient_registers(); - MR_succip = (Code *) engine_done; + MR_succip = (MR_Code *) engine_done; return NULL; } @@ -570,9 +570,9 @@ engine_init_registers(void) #define NUM_PREV_FPS 40 -typedef Code *Func(void); +typedef MR_Code *Func(void); -static Code *prev_fps[NUM_PREV_FPS]; +static MR_Code *prev_fps[NUM_PREV_FPS]; static int prev_fp_index = 0; void @@ -593,7 +593,7 @@ dump_prev_locations(void) } static void -call_engine_inner(Code *entry_point) +call_engine_inner(MR_Code *entry_point) { reg Func *fp; @@ -623,7 +623,7 @@ if (!MR_tracedebug) { #endif for (;;) { - prev_fps[prev_fp_index] = (Code *) fp; + prev_fps[prev_fp_index] = (MR_Code *) fp; if (++prev_fp_index >= NUM_PREV_FPS) prev_fp_index = 0; diff --git a/runtime/mercury_engine.h b/runtime/mercury_engine.h index a08f55c0a..f8f256e65 100644 --- a/runtime/mercury_engine.h +++ b/runtime/mercury_engine.h @@ -23,7 +23,7 @@ #include #include "mercury_std.h" /* for `bool' */ -#include "mercury_types.h" /* for `Code *' */ +#include "mercury_types.h" /* for `MR_Code *' */ #include "mercury_goto.h" /* for `Define_entry()' */ #include "mercury_thread.h" /* for pthread types */ #include "mercury_context.h" /* for MR_Context, MR_IF_USE_TRAIL */ @@ -84,16 +84,16 @@ typedef struct { jmp_buf env; /* ** used by calls to setjmp and longjmp */ - Word *saved_succip; - Word *saved_sp; - Word *saved_curfr; - Word *saved_maxfr; + MR_Word *saved_succip; + MR_Word *saved_sp; + MR_Word *saved_curfr; + MR_Word *saved_maxfr; MR_IF_USE_TRAIL(MR_TrailEntry *saved_trail_ptr;) - MR_IF_USE_TRAIL(Unsigned saved_ticket_counter;) - MR_IF_USE_TRAIL(Unsigned saved_ticket_high_water;) + MR_IF_USE_TRAIL(MR_Unsigned saved_ticket_counter;) + MR_IF_USE_TRAIL(MR_Unsigned saved_ticket_high_water;) #if NUM_REAL_REGS > 0 - Word regs[NUM_REAL_REGS]; + MR_Word regs[NUM_REAL_REGS]; #endif /* NUM_REAL_REGS > 0 */ } MR_jmp_buf; @@ -175,14 +175,14 @@ typedef struct MR_mercury_thread_list_struct { */ typedef struct MR_mercury_engine_struct { - Word fake_reg[MAX_FAKE_REG]; + MR_Word fake_reg[MAX_FAKE_REG]; /* The fake reg vector for this engine. */ #ifndef CONSERVATIVE_GC - Word *e_hp; + MR_Word *e_hp; /* The heap pointer for this engine */ - Word *e_sol_hp; + MR_Word *e_sol_hp; /* The solutions heap pointer for this engine */ - Word *e_global_hp; + MR_Word *e_global_hp; /* The global heap pointer for this engine */ #endif MR_Context *this_context; @@ -219,7 +219,7 @@ typedef struct MR_mercury_engine_struct { */ #endif jmp_buf *e_jmp_buf; - Word *e_exception; + MR_Word *e_exception; #ifndef CONSERVATIVE_GC MemoryZone *heap_zone; MemoryZone *solutions_heap_zone; @@ -325,7 +325,7 @@ extern void finalize_engine(MercuryEngine *engine); ** Functions that act on the current Mercury engine. ** See the comments in mercury_engine.c for documentation on MR_call_engine(). */ -extern Word * MR_call_engine(Code *entry_point, bool catch_exceptions); +extern MR_Word * MR_call_engine(MR_Code *entry_point, bool catch_exceptions); extern void terminate_engine(void); extern void dump_prev_locations(void); diff --git a/runtime/mercury_float.c b/runtime/mercury_float.c index 7a1ad0da3..99878f912 100644 --- a/runtime/mercury_float.c +++ b/runtime/mercury_float.c @@ -1,5 +1,5 @@ /* -** Copyright (C) 1997 The University of Melbourne. +** Copyright (C) 1997, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -9,37 +9,37 @@ /* ** The function `hash_float()' is used by the library predicate `float__hash' ** and also for hashing floats for `pragma fact_table' indexing. -** It computes a non-negative Integer hash value for a Float. -** The exact hash function used depend on the relative sizes of Float and -** Integer. +** It computes a non-negative MR_Integer hash value for a MR_Float. +** The exact hash function used depend on the relative sizes of MR_Float and +** MR_Integer. */ -union FloatInteger { - Float f; - Integer i; - Integer j[(sizeof(Float)/sizeof(Integer) > 0 - ? sizeof(Float)/sizeof(Integer) : 1)]; - char c[sizeof(Float)/sizeof(char)]; +union MR_Float_Integer { + MR_Float f; + MR_Integer i; + MR_Integer j[(sizeof(MR_Float)/sizeof(MR_Integer) > 0 + ? sizeof(MR_Float)/sizeof(MR_Integer) : 1)]; + char c[sizeof(MR_Float)/sizeof(char)]; }; -Integer -hash_float(Float f) +MR_Integer +hash_float(MR_Float f) { - union FloatInteger fi; + union MR_Float_Integer fi; size_t i; - Integer h = 0; + MR_Integer h = 0; fi.i = 0; fi.f = f; - if (sizeof(Float) <= sizeof(Integer)) { + if (sizeof(MR_Float) <= sizeof(MR_Integer)) { h = fi.i; - } else if (sizeof(Float) % sizeof(Integer) == 0) { - for (i = 0; i < sizeof(Float)/sizeof(Integer); i++) { + } else if (sizeof(MR_Float) % sizeof(MR_Integer) == 0) { + for (i = 0; i < sizeof(MR_Float)/sizeof(MR_Integer); i++) { h ^= fi.j[i]; } } else { - for (i = 0; i < sizeof(Float)/sizeof(char); i++) { + for (i = 0; i < sizeof(MR_Float)/sizeof(char); i++) { h ^= (h << 5); h ^= fi.c[i]; } diff --git a/runtime/mercury_float.h b/runtime/mercury_float.h index f155ee0ff..b6f801952 100644 --- a/runtime/mercury_float.h +++ b/runtime/mercury_float.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1995-1997, 1999 The University of Melbourne. +** Copyright (C) 1995-1997, 1999-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -10,51 +10,51 @@ #define MERCURY_FLOAT_H #include "mercury_conf.h" /* for BOXED_FLOAT */ -#include "mercury_types.h" /* for `Word' */ +#include "mercury_types.h" /* for `MR_Word' */ #ifdef USE_SINGLE_PREC_FLOAT -typedef float Float; +typedef float MR_Float; #else -typedef double Float; +typedef double MR_Float; #endif #ifdef BOXED_FLOAT -#define word_to_float(w) (*(Float *)(w)) +#define word_to_float(w) (*(MR_Float *)(w)) -#define FLOAT_WORDS ((sizeof(Float) + sizeof(Word) - 1) / sizeof(Word)) +#define FLOAT_WORDS ((sizeof(MR_Float) + sizeof(MR_Word) - 1) / sizeof(MR_Word)) #ifdef CONSERVATIVE_GC #define float_to_word(f) ( \ hp_alloc_atomic(FLOAT_WORDS), \ - *(Float *)(void *)(MR_hp - FLOAT_WORDS) = (f), \ - /* return */ (Word) (MR_hp - FLOAT_WORDS) \ + *(MR_Float *)(void *)(MR_hp - FLOAT_WORDS) = (f), \ + /* return */ (MR_Word) (MR_hp - FLOAT_WORDS) \ ) #else /* we need to ensure that what we allocated on the heap is properly aligned */ #define float_to_word(f) ( \ - ( (Word)MR_hp & (sizeof(Float) - 1) ? \ + ( (MR_Word)MR_hp & (sizeof(MR_Float) - 1) ? \ hp_alloc_atomic(1) : (void)0 ), \ hp_alloc_atomic(FLOAT_WORDS), \ - *(Float *)(void *)(MR_hp - FLOAT_WORDS) = (f), \ - /* return */ (Word) (MR_hp - FLOAT_WORDS) \ + *(MR_Float *)(void *)(MR_hp - FLOAT_WORDS) = (f), \ + /* return */ (MR_Word) (MR_hp - FLOAT_WORDS) \ ) #endif #ifdef __GNUC__ -#define float_const(f) ({ static const Float d = f; (Word)&d; }) +#define float_const(f) ({ static const MR_Float d = f; (MR_Word)&d; }) #else #define float_const(f) float_to_word(f) /* inefficient */ #endif #else /* not BOXED_FLOAT */ -/* unboxed float means we can assume sizeof(Float) == sizeof(Word) */ +/* unboxed float means we can assume sizeof(MR_Float) == sizeof(MR_Word) */ -union FloatWord { - Float f; - Word w; +union MR_Float_Word { + MR_Float f; + MR_Word w; }; #define float_const(f) float_to_word(f) @@ -62,20 +62,20 @@ union FloatWord { #ifdef __GNUC__ /* GNU C allows you to cast to a union type */ -#define float_to_word(f) (__extension__ ((union FloatWord)(Float)(f)).w) -#define word_to_float(w) (__extension__ ((union FloatWord)(Word)(w)).f) +#define float_to_word(f) (__extension__ ((union MR_Float_Word)(MR_Float)(f)).w) +#define word_to_float(w) (__extension__ ((union MR_Float_Word)(MR_Word)(w)).f) #else /* not __GNUC__ */ -static Word float_to_word(Float f) - { union FloatWord tmp; tmp.f = f; return tmp.w; } -static Float word_to_float(Word w) - { union FloatWord tmp; tmp.w = w; return tmp.f; } +static MR_Word float_to_word(MR_Float f) + { union MR_Float_Word tmp; tmp.f = f; return tmp.w; } +static MR_Float word_to_float(MR_Word w) + { union MR_Float_Word tmp; tmp.w = w; return tmp.f; } #endif /* not __GNUC__ */ #endif /* not BOXED_FLOAT */ -Integer hash_float(Float); +MR_Integer hash_float(MR_Float); #endif /* not MERCURY_FLOAT_H */ diff --git a/runtime/mercury_goto.h b/runtime/mercury_goto.h index e3adef000..7ad1d67b3 100644 --- a/runtime/mercury_goto.h +++ b/runtime/mercury_goto.h @@ -10,7 +10,7 @@ #define MERCURY_GOTO_H #include "mercury_conf.h" -#include "mercury_types.h" /* for `Code *' */ +#include "mercury_types.h" /* for `MR_Code *' */ #include "mercury_debug.h" /* for debuggoto() */ #include "mercury_label.h" /* for insert_{entry,internal}_label() */ #include "mercury_dummy.h" /* for dummy_identify_function() */ @@ -20,9 +20,9 @@ #define entry(label) paste(_entry_,label) #define skip(label) paste(skip_,label) -#define MR_ENTRY_LAYOUT(label) (const MR_Stack_Layout_Entry *) (Word) \ +#define MR_ENTRY_LAYOUT(label) (const MR_Stack_Layout_Entry *) (MR_Word) \ &(paste(mercury_data__layout__,label)) -#define MR_INTERNAL_LAYOUT(label) (const MR_Stack_Layout_Label *) (Word) \ +#define MR_INTERNAL_LAYOUT(label) (const MR_Stack_Layout_Label *) (MR_Word) \ &(paste(mercury_data__layout__,label)) #define MR_init_entry(label) init_entry(label) @@ -567,9 +567,9 @@ #else /* !defined(USE_ASM_LABELS) */ - #define Declare_entry(label) extern Code * entry(label) - #define Declare_static(label) static Code * entry(label) - #define Define_extern_entry(label) Code * entry(label) + #define Declare_entry(label) extern MR_Code * entry(label) + #define Declare_static(label) static MR_Code * entry(label) + #define Define_extern_entry(label) MR_Code * entry(label) #define Define_entry(label) \ } \ entry(label): \ @@ -639,51 +639,51 @@ /* !defined(USE_GCC_NONLOCAL_GOTOS) */ /* Define the type of a module initialization function */ - typedef Code * ModuleFunc(void); + typedef MR_Code * ModuleFunc(void); #define BEGIN_MODULE(module_name) \ - MR_MODULE_STATIC_OR_EXTERN Code* module_name(void); \ - MR_MODULE_STATIC_OR_EXTERN Code* module_name(void) { + MR_MODULE_STATIC_OR_EXTERN MR_Code* module_name(void); \ + MR_MODULE_STATIC_OR_EXTERN MR_Code* module_name(void) { #define BEGIN_CODE return 0; #define END_MODULE } - #define Declare_entry(label) extern Code *label(void) - #define Declare_static(label) static Code *label(void) - #define Define_extern_entry(label) Code *label(void) + #define Declare_entry(label) extern MR_Code *label(void) + #define Declare_static(label) static MR_Code *label(void) + #define Define_extern_entry(label) MR_Code *label(void) #define Define_entry(label) \ GOTO_LABEL(label); \ } \ - Code* label(void) { + MR_Code* label(void) { #define Define_static(label) \ GOTO_LABEL(label); \ } \ - static Code* label(void) { + static MR_Code* label(void) { #define init_entry(label) make_entry(stringify(label), label, label) #define init_entry_ai(label) make_entry_ai(stringify(label), label, label) #define init_entry_sl(label) make_entry_sl(stringify(label), label, label) - #define Declare_local(label) static Code *label(void) + #define Declare_local(label) static MR_Code *label(void) #define Define_local(label) \ GOTO_LABEL(label); \ } \ - static Code* label(void) { + static MR_Code* label(void) { #define init_local(label) make_local(stringify(label), label, label) #define init_local_ai(label) make_local_ai(stringify(label), label, label) #define init_local_sl(label) make_local_sl(stringify(label), label, label) - #define Declare_label(label) static Code *label(void) + #define Declare_label(label) static MR_Code *label(void) #define Define_label(label) \ GOTO_LABEL(label); \ } \ - static Code* label(void) { + static MR_Code* label(void) { #define init_label(label) make_label(stringify(label), label, label) #define init_label_ai(label) make_label_ai(stringify(label), label, label) #define init_label_sl(label) make_label_sl(stringify(label), label, label) - #define ENTRY(label) ((Code *) (label)) - #define STATIC(label) ((Code *) (label)) - #define LOCAL(label) ((Code *) (label)) - #define LABEL(label) ((Code *) (label)) + #define ENTRY(label) ((MR_Code *) (label)) + #define STATIC(label) ((MR_Code *) (label)) + #define LOCAL(label) ((MR_Code *) (label)) + #define LABEL(label) ((MR_Code *) (label)) /* ** The call to debuggoto() is in the driver function in mercury_engine.c, ** which is why the following definitions have no debuggoto(). @@ -699,7 +699,7 @@ /* definitions for computed gotos */ #define COMPUTED_GOTO(val, labels) \ - { static Code *jump_table[] = { \ + { static MR_Code *jump_table[] = { \ labels \ }; \ GOTO(jump_table[val]); \ diff --git a/runtime/mercury_heap.h b/runtime/mercury_heap.h index 3385a5ca8..84c4aa84e 100644 --- a/runtime/mercury_heap.h +++ b/runtime/mercury_heap.h @@ -9,7 +9,7 @@ #ifndef MERCURY_HEAP_H #define MERCURY_HEAP_H -#include "mercury_types.h" /* for `Word' */ +#include "mercury_types.h" /* for `MR_Word' */ #include "mercury_context.h" /* for min_heap_reclamation_point() */ #include "mercury_heap_profile.h" /* for MR_record_allocation() */ #include "mercury_std.h" /* for MR_EXTERN_INLINE */ @@ -22,11 +22,11 @@ #include "gc.h" #define tag_incr_hp_n(dest, tag, count) \ - ((dest) = (Word) MR_mkword((tag), \ - (Word) GC_MALLOC((count) * sizeof(Word)))) + ((dest) = (MR_Word) MR_mkword((tag), \ + (MR_Word) GC_MALLOC((count) * sizeof(MR_Word)))) #define tag_incr_hp_atomic(dest, tag, count) \ - ((dest) = (Word) MR_mkword((tag), \ - (Word) GC_MALLOC_ATOMIC((count) * sizeof(Word)))) + ((dest) = (MR_Word) MR_mkword((tag), \ + (MR_Word) GC_MALLOC_ATOMIC((count) * sizeof(MR_Word)))) #ifdef INLINE_ALLOC @@ -63,9 +63,9 @@ ( __builtin_constant_p(count) && (count) < 16 \ ? ({ void * temp; \ /* if size > 1, round up to an even number of words */ \ - Word num_words = ((count) == 1 ? 1 : 2 * (((count) + 1) / 2));\ + MR_Word num_words = ((count) == 1 ? 1 : 2 * (((count) + 1) / 2));\ GC_MALLOC_WORDS(temp, num_words); \ - (dest) = (Word) MR_mkword((tag), temp); \ + (dest) = (MR_Word) MR_mkword((tag), temp); \ }) \ : tag_incr_hp_n((dest), (tag), (count)) \ ) @@ -82,12 +82,12 @@ /* we use `MR_hp' as a convenient temporary here */ #define hp_alloc(count) ( \ - incr_hp(LVALUE_CAST(Word, MR_hp), (count)), \ + incr_hp(LVALUE_CAST(MR_Word, MR_hp), (count)), \ MR_hp += (count), \ (void)0 \ ) #define hp_alloc_atomic(count) ( \ - incr_hp_atomic(LVALUE_CAST(Word, MR_hp), (count)), \ + incr_hp_atomic(LVALUE_CAST(MR_Word, MR_hp), (count)), \ MR_hp += (count), \ (void)0 \ ) @@ -98,7 +98,7 @@ #define tag_incr_hp(dest, tag, count) \ ( \ - (dest) = (Word) MR_mkword(tag, (Word) MR_hp), \ + (dest) = (MR_Word) MR_mkword(tag, (MR_Word) MR_hp), \ debugincrhp(count, MR_hp), \ MR_hp += (count), \ heap_overflow_check(), \ @@ -107,7 +107,7 @@ #define tag_incr_hp_atomic(dest, tag, count) \ tag_incr_hp((dest), (tag), (count)) - #define mark_hp(dest) ((dest) = (Word) MR_hp) + #define mark_hp(dest) ((dest) = (MR_Word) MR_hp) /* ** When restoring MR_hp, we must make sure that we don't truncate the heap @@ -116,21 +116,21 @@ ** the set_min_heap_reclamation_point() macro. */ #define restore_hp(src) ( \ - LVALUE_CAST(Word, MR_hp) = (src), \ + LVALUE_CAST(MR_Word, MR_hp) = (src), \ (void)0 \ ) /* #define restore_hp(src) ( \ - LVALUE_CAST(Word, MR_hp) = \ - ( (Word) MR_min_hp_rec < (src) ? \ - (src) : (Word) MR_min_hp_rec ), \ + LVALUE_CAST(MR_Word, MR_hp) = \ + ( (MR_Word) MR_min_hp_rec < (src) ? \ + (src) : (MR_Word) MR_min_hp_rec ), \ (void)0 \ ) */ - #define hp_alloc(count) incr_hp(LVALUE_CAST(Word, MR_hp), count) - #define hp_alloc_atomic(count) incr_hp_atomic(LVALUE_CAST(Word, MR_hp), count) + #define hp_alloc(count) incr_hp(LVALUE_CAST(MR_Word, MR_hp), count) + #define hp_alloc_atomic(count) incr_hp_atomic(LVALUE_CAST(MR_Word, MR_hp), count) #define MR_free_heap(ptr) ((void)0) @@ -175,35 +175,35 @@ #ifdef MR_HIGHLEVEL_CODE -MR_EXTERN_INLINE Word create1(Word w1); -MR_EXTERN_INLINE Word create2(Word w1, Word w2); -MR_EXTERN_INLINE Word create3(Word w1, Word w2, Word w3) ; +MR_EXTERN_INLINE MR_Word create1(MR_Word w1); +MR_EXTERN_INLINE MR_Word create2(MR_Word w1, MR_Word w2); +MR_EXTERN_INLINE MR_Word create3(MR_Word w1, MR_Word w2, MR_Word w3) ; -MR_EXTERN_INLINE Word -create1(Word w1) +MR_EXTERN_INLINE MR_Word +create1(MR_Word w1) { - Word *p = (Word *) MR_new_object(Word, 1 * sizeof(Word), "create1"); + MR_Word *p = (MR_Word *) MR_new_object(MR_Word, 1 * sizeof(MR_Word), "create1"); p[0] = w1; - return (Word) p; + return (MR_Word) p; } -MR_EXTERN_INLINE Word -create2(Word w1, Word w2) +MR_EXTERN_INLINE MR_Word +create2(MR_Word w1, MR_Word w2) { - Word *p = (Word *) MR_new_object(Word, 2 * sizeof(Word), "create2"); + MR_Word *p = (MR_Word *) MR_new_object(MR_Word, 2 * sizeof(MR_Word), "create2"); p[0] = w1; p[1] = w2; - return (Word) p; + return (MR_Word) p; } -MR_EXTERN_INLINE Word -create3(Word w1, Word w2, Word w3) +MR_EXTERN_INLINE MR_Word +create3(MR_Word w1, MR_Word w2, MR_Word w3) { - Word *p = (Word *) MR_new_object(Word, 3 * sizeof(Word), "create3"); + MR_Word *p = (MR_Word *) MR_new_object(MR_Word, 3 * sizeof(MR_Word), "create3"); p[0] = w1; p[1] = w2; p[2] = w3; - return (Word) p; + return (MR_Word) p; } #define MR_create1_msg(w1, proclabel, type) \ @@ -225,29 +225,29 @@ create3(Word w1, Word w2, Word w3) #define create1(w1) \ ( \ hp_alloc(1), \ - MR_hp[-1] = (Word) (w1), \ + MR_hp[-1] = (MR_Word) (w1), \ debugcr1(MR_hp[-1], MR_hp), \ - /* return */ (Word) (MR_hp - 1) \ + /* return */ (MR_Word) (MR_hp - 1) \ ) /* used only by hand-written code not by the automatically generated code */ #define create2(w1, w2) \ ( \ hp_alloc(2), \ - MR_hp[-2] = (Word) (w1), \ - MR_hp[-1] = (Word) (w2), \ + MR_hp[-2] = (MR_Word) (w1), \ + MR_hp[-1] = (MR_Word) (w2), \ debugcr2(MR_hp[-2], MR_hp[-1], MR_hp), \ - /* return */ (Word) (MR_hp - 2) \ + /* return */ (MR_Word) (MR_hp - 2) \ ) /* used only by hand-written code not by the automatically generated code */ #define create3(w1, w2, w3) \ ( \ hp_alloc(3), \ - MR_hp[-3] = (Word) (w1), \ - MR_hp[-2] = (Word) (w2), \ - MR_hp[-1] = (Word) (w3), \ - /* return */ (Word) (MR_hp - 3) \ + MR_hp[-3] = (MR_Word) (w1), \ + MR_hp[-2] = (MR_Word) (w2), \ + MR_hp[-1] = (MR_Word) (w3), \ + /* return */ (MR_Word) (MR_hp - 3) \ ) /* used only by hand-written code not by the automatically generated code */ @@ -255,9 +255,9 @@ create3(Word w1, Word w2, Word w3) ( \ MR_maybe_record_allocation(1, proclabel, (type)), \ hp_alloc(1), \ - MR_hp[-1] = (Word) (w1), \ + MR_hp[-1] = (MR_Word) (w1), \ debugcr1(MR_hp[-1], MR_hp), \ - /* return */ (Word) (MR_hp - 1) \ + /* return */ (MR_Word) (MR_hp - 1) \ ) /* used only by hand-written code not by the automatically generated code */ @@ -265,10 +265,10 @@ create3(Word w1, Word w2, Word w3) ( \ MR_maybe_record_allocation(2, proclabel, (type)), \ hp_alloc(2), \ - MR_hp[-2] = (Word) (w1), \ - MR_hp[-1] = (Word) (w2), \ + MR_hp[-2] = (MR_Word) (w1), \ + MR_hp[-1] = (MR_Word) (w2), \ debugcr2(MR_hp[-2], MR_hp[-1], MR_hp), \ - /* return */ (Word) (MR_hp - 2) \ + /* return */ (MR_Word) (MR_hp - 2) \ ) /* used only by hand-written code not by the automatically generated code */ @@ -276,10 +276,10 @@ create3(Word w1, Word w2, Word w3) ( \ MR_maybe_record_allocation(3, proclabel, (type)), \ hp_alloc(3), \ - MR_hp[-3] = (Word) (w1), \ - MR_hp[-2] = (Word) (w2), \ - MR_hp[-1] = (Word) (w3), \ - /* return */ (Word) (MR_hp - 3) \ + MR_hp[-3] = (MR_Word) (w1), \ + MR_hp[-2] = (MR_Word) (w2), \ + MR_hp[-1] = (MR_Word) (w3), \ + /* return */ (MR_Word) (MR_hp - 3) \ ) #endif /* ! MR_HIGHLEVEL_CODE */ diff --git a/runtime/mercury_heap_profile.c b/runtime/mercury_heap_profile.c index 3f5ecc44b..87f1ed43b 100644 --- a/runtime/mercury_heap_profile.c +++ b/runtime/mercury_heap_profile.c @@ -1,5 +1,5 @@ /* -** Copyright (C) 1997, 1999 The University of Melbourne. +** Copyright (C) 1997, 1999-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -59,7 +59,7 @@ MR_increment_counter(MR_memprof_counter *counter, int size) */ static void MR_increment_table_entry(MR_memprof_table *table, const char *name, - Code *addr, int size) + MR_Code *addr, int size) { bool found; int diff; @@ -121,7 +121,7 @@ MR_increment_table_entry(MR_memprof_table *table, const char *name, ** in procedure `proc' for an object of type `type'. */ void -MR_record_allocation(int size, Code *proc_addr, +MR_record_allocation(int size, MR_Code *proc_addr, const char *proc_name, const char *type) { /* diff --git a/runtime/mercury_heap_profile.h b/runtime/mercury_heap_profile.h index 6fdbedb64..c5a09ef55 100644 --- a/runtime/mercury_heap_profile.h +++ b/runtime/mercury_heap_profile.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1998 The University of Melbourne. +** Copyright (C) 1998, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -18,7 +18,7 @@ #ifndef MERCURY_HEAP_PROFILE_H #define MERCURY_HEAP_PROFILE_H -#include "mercury_types.h" /* for `Code' */ +#include "mercury_types.h" /* for `MR_Code' */ /*---------------------------------------------------------------------------*/ @@ -133,7 +133,7 @@ typedef struct MR_memprof_counter typedef struct MR_memprof_record { const char *name; /* of the type or procedure */ - Code *addr; /* for procedures only */ + MR_Code *addr; /* for procedures only */ MR_memprof_counter counter; struct MR_memprof_record *left; /* left sub-tree */ struct MR_memprof_record *right; /* right sub-tree */ @@ -166,13 +166,13 @@ extern MR_memprof_table MR_memprof_types; ** The heap profiling information is recorded in the three global ** variables above. */ -extern void MR_record_allocation(int size, Code *proc_addr, +extern void MR_record_allocation(int size, MR_Code *proc_addr, const char *proc_name, const char *type); /* ** MR_prof_output_mem_tables(): ** Write out the information recorded by MR_record_allocation() -** to a pair of files `Prof.MemoryWords' and `Prof.MemoryCells'. +** to a pair of files `Prof.MemoryMR_Words' and `Prof.MemoryCells'. */ extern void MR_prof_output_mem_tables(void); diff --git a/runtime/mercury_ho_call.c b/runtime/mercury_ho_call.c index f9e3cc1d1..e41c36449 100644 --- a/runtime/mercury_ho_call.c +++ b/runtime/mercury_ho_call.c @@ -22,8 +22,8 @@ ENDINIT #include "mercury_imp.h" #include "mercury_ho_call.h" -static Word MR_generic_compare(MR_TypeInfo type_info, Word x, Word y); -static Word MR_generic_unify(MR_TypeInfo type_info, Word x, Word y); +static MR_Word MR_generic_compare(MR_TypeInfo type_info, MR_Word x, MR_Word y); +static MR_Word MR_generic_unify(MR_TypeInfo type_info, MR_Word x, MR_Word y); /* ** The called closure may contain only input arguments. The extra arguments @@ -133,7 +133,7 @@ Define_entry(mercury__do_call_closure); Define_entry(mercury__do_call_class_method); { - Code *destination; + MR_Code *destination; int num_in_args; int num_extra_instance_args; int i; @@ -181,8 +181,8 @@ Define_entry(mercury__unify_2_0); #define DECLARE_LOCALS \ MR_TypeCtorInfo type_ctor_info; \ MR_TypeInfo type_info; \ - Word x, y; \ - Code *saved_succip; + MR_Word x, y; \ + MR_Code *saved_succip; #define initialize() \ do { \ @@ -251,8 +251,8 @@ Define_entry(mercury__compare_3_3); #define DECLARE_LOCALS \ MR_TypeCtorInfo type_ctor_info; \ MR_TypeInfo type_info; \ - Word x, y; \ - Code *saved_succip; + MR_Word x, y; \ + MR_Code *saved_succip; #define initialize() \ do { \ @@ -293,8 +293,8 @@ Define_entry(mercury__compare_3_3); } END_MODULE -static Word -MR_generic_unify(MR_TypeInfo type_info, Word x, Word y) +static MR_Word +MR_generic_unify(MR_TypeInfo type_info, MR_Word x, MR_Word y) { #define DECLARE_LOCALS \ @@ -333,8 +333,8 @@ MR_generic_unify(MR_TypeInfo type_info, Word x, Word y) #undef attempt_msg } -static Word -MR_generic_compare(MR_TypeInfo type_info, Word x, Word y) +static MR_Word +MR_generic_compare(MR_TypeInfo type_info, MR_Word x, MR_Word y) { #define DECLARE_LOCALS \ diff --git a/runtime/mercury_ho_call.h b/runtime/mercury_ho_call.h index 25badbe35..730f5a2fb 100644 --- a/runtime/mercury_ho_call.h +++ b/runtime/mercury_ho_call.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1999 The University of Melbourne. +** Copyright (C) 1999, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -68,7 +68,7 @@ typedef struct MR_Closure_Layout_Struct { MR_Stack_Layout_Proc_Id proc_id; MR_Type_Param_Locns *type_params; - Integer num_all_args; + MR_Integer num_all_args; MR_PseudoTypeInfo arg_pseudo_type_info[MR_VARIABLE_SIZED]; } MR_Closure_Layout; @@ -93,9 +93,9 @@ typedef struct MR_Closure_Layout_Struct { typedef struct MR_Closure_Struct { MR_Closure_Layout *MR_closure_layout; - Code *MR_closure_code; - Unsigned MR_closure_num_hidden_args; - Word MR_closure_hidden_args_0[MR_VARIABLE_SIZED]; + MR_Code *MR_closure_code; + MR_Unsigned MR_closure_num_hidden_args; + MR_Word MR_closure_hidden_args_0[MR_VARIABLE_SIZED]; } MR_Closure; #define MR_closure_hidden_args(i) MR_closure_hidden_args_0[(i) - 1] diff --git a/runtime/mercury_imp.h b/runtime/mercury_imp.h index 33ea5ce16..c91c238e5 100644 --- a/runtime/mercury_imp.h +++ b/runtime/mercury_imp.h @@ -49,6 +49,7 @@ #include "mercury_library_types.h" #include "mercury_string.h" #include "mercury_float.h" +#include "mercury_bootstrap.h" #include "mercury_stack_trace.h" #include "mercury_accurate_gc.h" #include "mercury_stack_layout.h" @@ -80,6 +81,5 @@ #include "mercury_grade.h" -#include "mercury_bootstrap.h" #endif /* not MERCURY_IMP_H */ diff --git a/runtime/mercury_init.h b/runtime/mercury_init.h index 3ac4b055d..5a23c237c 100644 --- a/runtime/mercury_init.h +++ b/runtime/mercury_init.h @@ -78,7 +78,7 @@ extern int mercury_terminate(void); #include "mercury_regs.h" /* must come before system headers */ #include "mercury_goto.h" /* for Declare_entry */ -#include "mercury_types.h" /* for `Word' */ +#include "mercury_types.h" /* for `MR_Word' */ #include "mercury_wrapper.h" /* for do_init_modules, mercury_runtime_init(), mercury_runtime_main(), @@ -112,12 +112,12 @@ extern int mercury_terminate(void); extern void mercury_init_io(void); extern void ML_io_init_state(void); extern void ML_io_finalize_state(void); -extern void ML_io_stderr_stream(Word *); -extern void ML_io_stdout_stream(Word *); -extern void ML_io_stdin_stream(Word *); +extern void ML_io_stderr_stream(MR_Word *); +extern void ML_io_stdout_stream(MR_Word *); +extern void ML_io_stdin_stream(MR_Word *); -extern void ML_io_print_to_stream(Word, Word, Word); -extern void ML_io_print_to_cur_stream(Word, Word); +extern void ML_io_print_to_stream(MR_Word, MR_Word, MR_Word); +extern void ML_io_print_to_cur_stream(MR_Word, MR_Word); /* in trace/mercury_trace_internal.h */ extern char *MR_trace_getline(const char *, FILE *mdb_in, FILE *mdb_out); @@ -127,29 +127,29 @@ extern void MR_trace_init_external(void); extern void MR_trace_final_external(void); /* in browser/debugger_interface.h */ -extern void ML_DI_output_current_vars(Word, Word, Word); +extern void ML_DI_output_current_vars(MR_Word, MR_Word, MR_Word); /* output_current_vars/4 */ -extern void ML_DI_output_current_nth_var(Word, Word); +extern void ML_DI_output_current_nth_var(MR_Word, MR_Word); /* output_current_nth_var/3 */ -extern void ML_DI_output_current_live_var_names(Word, Word, Word); +extern void ML_DI_output_current_live_var_names(MR_Word, MR_Word, MR_Word); /* output_current_live_var_names/5 */ -extern void ML_DI_output_current_slots(Integer, Integer, Integer, Word, - String, String, Integer, Integer, Integer, String, Word); +extern void ML_DI_output_current_slots(MR_Integer, MR_Integer, MR_Integer, MR_Word, + MR_String, MR_String, MR_Integer, MR_Integer, MR_Integer, MR_String, MR_Word); /* output_current_slots/13 */ -extern bool ML_DI_found_match(Integer, Integer, Integer, Word, String, - String, Integer, Integer, Integer, Word, String, Word); +extern bool ML_DI_found_match(MR_Integer, MR_Integer, MR_Integer, MR_Word, MR_String, + MR_String, MR_Integer, MR_Integer, MR_Integer, MR_Word, MR_String, MR_Word); /* found_match/12 */ -extern void ML_DI_read_request_from_socket(Word, Word *, Integer *); -extern Integer ML_DI_get_var_number(Word); +extern void ML_DI_read_request_from_socket(MR_Word, MR_Word *, MR_Integer *); +extern MR_Integer ML_DI_get_var_number(MR_Word); /* in library/std_util.m */ -extern String ML_type_name(Word); +extern MR_String ML_type_name(MR_Word); /* in runtime/mercury_trace_base.c */ -extern Code *MR_trace_fake(const MR_Stack_Layout_Label *); +extern MR_Code *MR_trace_fake(const MR_Stack_Layout_Label *); /* in trace/mercury_trace.c */ -extern Code *MR_trace_real(const MR_Stack_Layout_Label *); +extern MR_Code *MR_trace_real(const MR_Stack_Layout_Label *); extern void MR_trace_interrupt_handler(void); /* in trace/mercury_trace_tables.c */ diff --git a/runtime/mercury_label.c b/runtime/mercury_label.c index bceb965ae..2e9e7941d 100644 --- a/runtime/mercury_label.c +++ b/runtime/mercury_label.c @@ -1,5 +1,5 @@ /* -** Copyright (C) 1994-1999 The University of Melbourne. +** Copyright (C) 1994-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -87,7 +87,7 @@ MR_do_init_label_tables(void) #ifdef MR_NEED_ENTRY_LABEL_INFO void -MR_insert_entry_label(const char *name, Code *addr, +MR_insert_entry_label(const char *name, MR_Code *addr, const MR_Stack_Layout_Entry *entry_layout) { MR_do_init_label_tables(); @@ -156,7 +156,7 @@ compare_entry_addr(const void *e1, const void *e2) } MR_Entry * -MR_prev_entry_by_addr(const Code *addr) +MR_prev_entry_by_addr(const MR_Code *addr) { int lo; int hi; @@ -201,7 +201,7 @@ MR_prev_entry_by_addr(const Code *addr) #endif void -MR_insert_internal_label(const char *name, Code *addr, +MR_insert_internal_label(const char *name, MR_Code *addr, const MR_Stack_Layout_Label *label_layout) { MR_Internal *internal; @@ -236,7 +236,7 @@ MR_insert_internal_label(const char *name, Code *addr, } MR_Internal * -MR_lookup_internal_by_addr(const Code *addr) +MR_lookup_internal_by_addr(const MR_Code *addr) { MR_do_init_label_tables(); do_init_modules(); @@ -264,13 +264,13 @@ internal_addr(const void *internal) static bool equal_addr(const void *addr1, const void *addr2) { - return ((const Code *) addr1) == ((const Code *) addr2); + return ((const MR_Code *) addr1) == ((const MR_Code *) addr2); } static int hash_addr(const void *addr) { - return (((Unsigned) addr) >> 3) % INTERNAL_SIZE; + return (((MR_Unsigned) addr) >> 3) % INTERNAL_SIZE; } void diff --git a/runtime/mercury_label.h b/runtime/mercury_label.h index 81b23412c..715ade720 100644 --- a/runtime/mercury_label.h +++ b/runtime/mercury_label.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1994-1998 The University of Melbourne. +** Copyright (C) 1994-1998, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -15,7 +15,7 @@ #ifndef MERCURY_LABEL_H #define MERCURY_LABEL_H -#include "mercury_types.h" /* for `Code *' */ +#include "mercury_types.h" /* for `MR_Code *' */ #include "mercury_dlist.h" /* for `List' */ #include "mercury_stack_layout.h" /* for `MR_Stack_Layout_*' */ @@ -37,7 +37,7 @@ */ typedef struct s_entry { - const Code *e_addr; + const MR_Code *e_addr; const MR_Stack_Layout_Entry *e_layout; const char *e_name; } MR_Entry; @@ -51,7 +51,7 @@ typedef struct s_entry { */ typedef struct s_internal { - const Code *i_addr; + const MR_Code *i_addr; const MR_Stack_Layout_Label *i_layout; const char *i_name; } MR_Internal; @@ -59,19 +59,19 @@ typedef struct s_internal { extern void MR_do_init_label_tables(void); #ifdef MR_NEED_ENTRY_LABEL_INFO - extern void MR_insert_entry_label(const char *name, Code *addr, + extern void MR_insert_entry_label(const char *name, MR_Code *addr, const MR_Stack_Layout_Entry *entry_layout); #else #define MR_insert_entry_label(n, a, l) /* nothing */ #endif /* not MR_NEED_ENTRY_LABEL_INFO */ #ifdef MR_NEED_ENTRY_LABEL_ARRAY - extern MR_Entry *MR_prev_entry_by_addr(const Code *addr); + extern MR_Entry *MR_prev_entry_by_addr(const MR_Code *addr); #endif /* MR_NEED_ENTRY_LABEL_ARRAY */ -extern void MR_insert_internal_label(const char *name, Code *addr, +extern void MR_insert_internal_label(const char *name, MR_Code *addr, const MR_Stack_Layout_Label *label_layout); -extern MR_Internal *MR_lookup_internal_by_addr(const Code *addr); +extern MR_Internal *MR_lookup_internal_by_addr(const MR_Code *addr); extern void MR_process_all_internal_labels(void f(const void *)); #endif /* not MERCURY_LABEL_H */ diff --git a/runtime/mercury_layout_util.c b/runtime/mercury_layout_util.c index 5a5500a96..baf5e0b2e 100644 --- a/runtime/mercury_layout_util.c +++ b/runtime/mercury_layout_util.c @@ -16,7 +16,7 @@ #include "mercury_layout_util.h" void -MR_copy_regs_to_saved_regs(int max_mr_num, Word *saved_regs) +MR_copy_regs_to_saved_regs(int max_mr_num, MR_Word *saved_regs) { /* ** In the process of browsing within the debugger, we call Mercury, @@ -44,7 +44,7 @@ MR_copy_regs_to_saved_regs(int max_mr_num, Word *saved_regs) } void -MR_copy_saved_regs_to_regs(int max_mr_num, Word *saved_regs) +MR_copy_saved_regs_to_regs(int max_mr_num, MR_Word *saved_regs) { /* ** We execute the converse procedure to MR_copy_regs_to_saved_regs. @@ -65,7 +65,7 @@ MR_copy_saved_regs_to_regs(int max_mr_num, Word *saved_regs) MR_TypeInfoParams MR_materialize_typeinfos(const MR_Stack_Layout_Vars *vars, - Word *saved_regs) + MR_Word *saved_regs) { return MR_materialize_typeinfos_base(vars, saved_regs, MR_saved_sp(saved_regs), MR_saved_curfr(saved_regs)); @@ -73,17 +73,17 @@ MR_materialize_typeinfos(const MR_Stack_Layout_Vars *vars, MR_TypeInfoParams MR_materialize_typeinfos_base(const MR_Stack_Layout_Vars *vars, - Word *saved_regs, Word *base_sp, Word *base_curfr) + MR_Word *saved_regs, MR_Word *base_sp, MR_Word *base_curfr) { MR_TypeInfoParams type_params; bool succeeded; - Integer count; + MR_Integer count; int i; if (vars->MR_slvs_tvars != NULL) { count = vars->MR_slvs_tvars->MR_tp_param_count; type_params = (MR_TypeInfoParams) - MR_NEW_ARRAY(Word, count + 1); + MR_NEW_ARRAY(MR_Word, count + 1); for (i = 0; i < count; i++) { if (vars->MR_slvs_tvars->MR_tp_param_locns[i] != 0) { @@ -130,23 +130,23 @@ MR_get_register_number_short(MR_Short_Lval locn) /* if you want to debug this code, you may want to set this var to TRUE */ static bool MR_print_locn = FALSE; -Word -MR_lookup_long_lval(MR_Long_Lval locn, Word *saved_regs, bool *succeeded) +MR_Word +MR_lookup_long_lval(MR_Long_Lval locn, MR_Word *saved_regs, bool *succeeded) { return MR_lookup_long_lval_base(locn, saved_regs, MR_saved_sp(saved_regs), MR_saved_curfr(saved_regs), succeeded); } -Word -MR_lookup_long_lval_base(MR_Long_Lval locn, Word *saved_regs, - Word *base_sp, Word *base_curfr, bool *succeeded) +MR_Word +MR_lookup_long_lval_base(MR_Long_Lval locn, MR_Word *saved_regs, + MR_Word *base_sp, MR_Word *base_curfr, bool *succeeded) { int locn_num; int offset; - Word value; - Word baseaddr; - Word sublocn; + MR_Word value; + MR_Word baseaddr; + MR_Word sublocn; *succeeded = FALSE; value = 0; @@ -248,20 +248,20 @@ MR_lookup_long_lval_base(MR_Long_Lval locn, Word *saved_regs, return value; } -Word -MR_lookup_short_lval(MR_Short_Lval locn, Word *saved_regs, bool *succeeded) +MR_Word +MR_lookup_short_lval(MR_Short_Lval locn, MR_Word *saved_regs, bool *succeeded) { return MR_lookup_short_lval_base(locn, saved_regs, MR_saved_sp(saved_regs), MR_saved_curfr(saved_regs), succeeded); } -Word -MR_lookup_short_lval_base(MR_Short_Lval locn, Word *saved_regs, - Word *base_sp, Word *base_curfr, bool *succeeded) +MR_Word +MR_lookup_short_lval_base(MR_Short_Lval locn, MR_Word *saved_regs, + MR_Word *base_sp, MR_Word *base_curfr, bool *succeeded) { int locn_num; - Word value; + MR_Word value; *succeeded = FALSE; value = 0; @@ -344,8 +344,8 @@ MR_lookup_short_lval_base(MR_Short_Lval locn, Word *saved_regs, bool MR_get_type_and_value(const MR_Stack_Layout_Vars *vars, int i, - Word *saved_regs, MR_TypeInfo *type_params, MR_TypeInfo *type_info, - Word *value) + MR_Word *saved_regs, MR_TypeInfo *type_params, MR_TypeInfo *type_info, + MR_Word *value) { return MR_get_type_and_value_base(vars, i, saved_regs, MR_saved_sp(saved_regs), MR_saved_curfr(saved_regs), @@ -354,8 +354,8 @@ MR_get_type_and_value(const MR_Stack_Layout_Vars *vars, int i, bool MR_get_type_and_value_base(const MR_Stack_Layout_Vars *vars, int i, - Word *saved_regs, Word *base_sp, Word *base_curfr, - MR_TypeInfo *type_params, MR_TypeInfo *type_info, Word *value) + MR_Word *saved_regs, MR_Word *base_sp, MR_Word *base_curfr, + MR_TypeInfo *type_params, MR_TypeInfo *type_info, MR_Word *value) { MR_PseudoTypeInfo pseudo_type_info; bool succeeded; @@ -377,7 +377,7 @@ MR_get_type_and_value_base(const MR_Stack_Layout_Vars *vars, int i, } bool -MR_get_type(const MR_Stack_Layout_Vars *vars, int i, Word *saved_regs, +MR_get_type(const MR_Stack_Layout_Vars *vars, int i, MR_Word *saved_regs, MR_TypeInfo *type_params, MR_TypeInfo *type_info) { return MR_get_type_base(vars, i, saved_regs, @@ -387,7 +387,7 @@ MR_get_type(const MR_Stack_Layout_Vars *vars, int i, Word *saved_regs, bool MR_get_type_base(const MR_Stack_Layout_Vars *vars, int i, - Word *saved_regs, Word *base_sp, Word *base_curfr, + MR_Word *saved_regs, MR_Word *base_sp, MR_Word *base_curfr, MR_TypeInfo *type_params, MR_TypeInfo *type_info) { MR_PseudoTypeInfo pseudo_type_info; @@ -399,9 +399,9 @@ MR_get_type_base(const MR_Stack_Layout_Vars *vars, int i, } void -MR_write_variable(Word type_info, Word value) +MR_write_variable(MR_Word type_info, MR_Word value) { - Word stdout_stream; + MR_Word stdout_stream; (*MR_io_stdout_stream)(&stdout_stream); (*MR_io_print_to_stream)(type_info, stdout_stream, value); diff --git a/runtime/mercury_layout_util.h b/runtime/mercury_layout_util.h index 849da42b5..410fbed77 100644 --- a/runtime/mercury_layout_util.h +++ b/runtime/mercury_layout_util.h @@ -8,17 +8,17 @@ #define MERCURY_LAYOUT_UTIL_H #include "mercury_std.h" -#include "mercury_types.h" /* for Word, etc. */ +#include "mercury_types.h" /* for MR_Word, etc. */ #include "mercury_stack_layout.h" /* for MR_Stack_Layout_Vars, etc. */ #include "mercury_type_info.h" /* for MR_TypeInfoParams, etc. */ /* ** These two functions copy the register state to and from the provided -** saved_regs array, which should have room for MAX_FAKE_REG Words. +** saved_regs array, which should have room for MAX_FAKE_REG MR_Words. */ -extern void MR_copy_regs_to_saved_regs(int max_mr_num, Word *saved_regs); -extern void MR_copy_saved_regs_to_regs(int max_mr_num, Word *saved_regs); +extern void MR_copy_regs_to_saved_regs(int max_mr_num, MR_Word *saved_regs); +extern void MR_copy_saved_regs_to_regs(int max_mr_num, MR_Word *saved_regs); /* ** A MR_Stack_Layout_Vars describes the variables that are live at a given @@ -50,11 +50,11 @@ extern void MR_copy_saved_regs_to_regs(int max_mr_num, Word *saved_regs); extern MR_TypeInfoParams MR_materialize_typeinfos( const MR_Stack_Layout_Vars *vars, - Word *saved_regs); + MR_Word *saved_regs); extern MR_TypeInfoParams MR_materialize_typeinfos_base( const MR_Stack_Layout_Vars *vars, - Word *saved_regs, - Word *base_sp, Word *base_curfr); + MR_Word *saved_regs, + MR_Word *base_sp, MR_Word *base_curfr); /* ** If the given encoded location refers to a register, return its number. @@ -77,15 +77,15 @@ extern int MR_get_register_number_short(MR_Short_Lval locn); ** non-null. */ -extern Word MR_lookup_long_lval(MR_Long_Lval locn, - Word *saved_regs, bool *succeeded); -extern Word MR_lookup_long_lval_base(MR_Long_Lval locn, - Word *saved_regs, Word *base_sp, Word *base_curfr, +extern MR_Word MR_lookup_long_lval(MR_Long_Lval locn, + MR_Word *saved_regs, bool *succeeded); +extern MR_Word MR_lookup_long_lval_base(MR_Long_Lval locn, + MR_Word *saved_regs, MR_Word *base_sp, MR_Word *base_curfr, bool *succeeded); -extern Word MR_lookup_short_lval(MR_Short_Lval locn, - Word *saved_regs, bool *succeeded); -extern Word MR_lookup_short_lval_base(MR_Short_Lval locn, - Word *saved_regs, Word *base_sp, Word *base_curfr, +extern MR_Word MR_lookup_short_lval(MR_Short_Lval locn, + MR_Word *saved_regs, bool *succeeded); +extern MR_Word MR_lookup_short_lval_base(MR_Short_Lval locn, + MR_Word *saved_regs, MR_Word *base_sp, MR_Word *base_curfr, bool *succeeded); /* @@ -114,18 +114,18 @@ extern Word MR_lookup_short_lval_base(MR_Short_Lval locn, */ extern bool MR_get_type_and_value(const MR_Stack_Layout_Vars *vars, - int var, Word *saved_regs, MR_TypeInfo *type_params, - MR_TypeInfo *type_info, Word *value); + int var, MR_Word *saved_regs, MR_TypeInfo *type_params, + MR_TypeInfo *type_info, MR_Word *value); extern bool MR_get_type_and_value_base(const MR_Stack_Layout_Vars *vars, - int var, Word *saved_regs, - Word *base_sp, Word *base_curfr, + int var, MR_Word *saved_regs, + MR_Word *base_sp, MR_Word *base_curfr, MR_TypeInfo *type_params, MR_TypeInfo *type_info, - Word *value); + MR_Word *value); extern bool MR_get_type(const MR_Stack_Layout_Vars *vars, int var, - Word *saved_regs, MR_TypeInfo *type_params, + MR_Word *saved_regs, MR_TypeInfo *type_params, MR_TypeInfo *type_info); extern bool MR_get_type_base(const MR_Stack_Layout_Vars *vars, int var, - Word *saved_regs, Word *base_sp, Word *base_curfr, + MR_Word *saved_regs, MR_Word *base_sp, MR_Word *base_curfr, MR_TypeInfo *type_params, MR_TypeInfo *type_info); /* @@ -135,6 +135,6 @@ extern bool MR_get_type_base(const MR_Stack_Layout_Vars *vars, int var, ** and it may also clobber the real registers. */ -extern void MR_write_variable(Word type_info, Word value); +extern void MR_write_variable(MR_Word type_info, MR_Word value); #endif /* MERCURY_LAYOUT_UTIL_H */ diff --git a/runtime/mercury_library_types.h b/runtime/mercury_library_types.h index 37295f944..d7fc79789 100644 --- a/runtime/mercury_library_types.h +++ b/runtime/mercury_library_types.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1998-1999 The University of Melbourne. +** Copyright (C) 1998-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -13,7 +13,7 @@ #define MERCURY_LIBRARY_TYPES_H #include /* for `FILE' */ -#include "mercury_types.h" /* for `Word' and `Integer' */ +#include "mercury_types.h" /* for `MR_Word' and `MR_Integer' */ #include "mercury_std.h" /* for MR_VARIABLE_SIZED */ /* @@ -34,10 +34,10 @@ typedef struct mercury_file { */ typedef struct { - Integer size; - Word elements[MR_VARIABLE_SIZED]; + MR_Integer size; + MR_Word elements[MR_VARIABLE_SIZED]; } MR_ArrayType; -#define MR_make_array(sz) ((MR_ArrayType *) MR_GC_NEW_ARRAY(Word, (sz) + 1)) +#define MR_make_array(sz) ((MR_ArrayType *) MR_GC_NEW_ARRAY(MR_Word, (sz) + 1)) #endif /* not MERCURY_LIBRARY_TYPES_H */ diff --git a/runtime/mercury_make_type_info_body.h b/runtime/mercury_make_type_info_body.h index 397861b90..4ad4219da 100644 --- a/runtime/mercury_make_type_info_body.h +++ b/runtime/mercury_make_type_info_body.h @@ -23,13 +23,13 @@ usual_func(const MR_TypeInfoParams type_info_params, MR_TypeInfo exist_func(const MR_TypeInfoParams type_info_params, - const MR_PseudoTypeInfo pseudo_type_info, const Word *data_value, + const MR_PseudoTypeInfo pseudo_type_info, const MR_Word *data_value, const MR_DuFunctorDesc *functor_desc MAYBE_DECLARE_ALLOC_ARG) { MR_TypeCtorInfo type_ctor_info; MR_TypeInfo expanded_type_info; - Word *type_info_arena; + MR_Word *type_info_arena; MR_PseudoTypeInfo *pseudo_type_info_arena; int arity; int start_region_size; @@ -58,7 +58,7 @@ exist_func(const MR_TypeInfoParams type_info_params, pseudo_type_info); /* no arguments - optimise common case */ - if ((Word) type_ctor_info == (Word) pseudo_type_info) { + if ((MR_Word) type_ctor_info == (MR_Word) pseudo_type_info) { return MR_pseudo_type_info_is_ground(pseudo_type_info); } @@ -105,11 +105,11 @@ exist_func(const MR_TypeInfoParams type_info_params, ALLOCATE_WORDS(type_info_arena, arity + start_region_size); memcpy(type_info_arena, - (Word *) pseudo_type_info, + (MR_Word *) pseudo_type_info, (arity + start_region_size) - * sizeof(Word)); + * sizeof(MR_Word)); } - type_info_arena[i] = (Word) expanded_type_info; + type_info_arena[i] = (MR_Word) expanded_type_info; } } diff --git a/runtime/mercury_memory.h b/runtime/mercury_memory.h index 92f7b1288..cc304e119 100644 --- a/runtime/mercury_memory.h +++ b/runtime/mercury_memory.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1994-1999 The University of Melbourne. +** Copyright (C) 1994-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -22,7 +22,7 @@ #include /* for size_t */ -#include "mercury_types.h" /* for Word */ +#include "mercury_types.h" /* for MR_Word */ #include "mercury_std.h" /* for bool */ #include "mercury_conf.h" /* for CONSERVATIVE_GC, etc. */ #ifdef CONSERVATIVE_GC diff --git a/runtime/mercury_memory_handlers.c b/runtime/mercury_memory_handlers.c index eb46bf333..e13a1999d 100644 --- a/runtime/mercury_memory_handlers.c +++ b/runtime/mercury_memory_handlers.c @@ -123,8 +123,8 @@ static void print_dump_stack(void); static bool try_munprotect(void *address, void *context); static char *explain_context(void *context); -static Code *get_pc_from_context(void *the_context); -static Word *get_sp_from_context(void *the_context); +static MR_Code *get_pc_from_context(void *the_context); +static MR_Word *get_sp_from_context(void *the_context); #define STDERR 2 @@ -135,10 +135,10 @@ try_munprotect(void *addr, void *context) #if !(defined(HAVE_SIGINFO) || defined(MR_WIN32_VIRTUAL_ALLOC)) return FALSE; #else - Word * fault_addr; + MR_Word * fault_addr; MemoryZone *zone; - fault_addr = (Word *) addr; + fault_addr = (MR_Word *) addr; zone = get_used_memory_zones(); @@ -174,7 +174,7 @@ try_munprotect(void *addr, void *context) } bool -null_handler(Word *fault_addr, MemoryZone *zone, void *context) +null_handler(MR_Word *fault_addr, MemoryZone *zone, void *context) { return FALSE; } @@ -203,15 +203,15 @@ fatal_abort(void *context, const char *main_msg, int dump) } bool -default_handler(Word *fault_addr, MemoryZone *zone, void *context) +default_handler(MR_Word *fault_addr, MemoryZone *zone, void *context) { #ifndef MR_CHECK_OVERFLOW_VIA_MPROTECT return FALSE; #else - Word *new_zone; + MR_Word *new_zone; size_t zone_size; - new_zone = (Word *) round_up((Unsigned) fault_addr + sizeof(Word), unit); + new_zone = (MR_Word *) round_up((MR_Unsigned) fault_addr + sizeof(MR_Word), unit); if (new_zone <= zone->hardmax) { zone_size = (char *)new_zone - (char *)zone->redzone; @@ -269,10 +269,10 @@ setup_signals(void) */ #ifndef MR_MSVC_STRUCTURED_EXCEPTIONS #ifdef SIGBUS - MR_setup_signal(SIGBUS, (Code *) bus_handler, TRUE, + MR_setup_signal(SIGBUS, (MR_Code *) bus_handler, TRUE, "Mercury runtime: cannot set SIGBUS handler"); #endif - MR_setup_signal(SIGSEGV, (Code *) segv_handler, TRUE, + MR_setup_signal(SIGSEGV, (MR_Code *) segv_handler, TRUE, "Mercury runtime: cannot set SIGSEGV handler"); #endif } @@ -722,7 +722,7 @@ MR_dump_exception_record(EXCEPTION_RECORD *rec) fprintf(stderr, "\n*** Exception record at 0x%08lx:", (unsigned long) rec); - fprintf(stderr, "\n*** Code : 0x%08lx (%s)", + fprintf(stderr, "\n*** MR_Code : 0x%08lx (%s)", (unsigned long) rec->ExceptionCode, MR_find_exception_name(rec->ExceptionCode)); fprintf(stderr, "\n*** Flags : 0x%08lx", @@ -836,18 +836,18 @@ MR_filter_win32_exception(LPEXCEPTION_POINTERS exception_ptrs) ** Given the signal context, return the program counter at the time ** of the signal, if available. If it is unavailable, return NULL. */ -static Code * +static MR_Code * get_pc_from_context(void *the_context) { - Code *pc_at_signal = NULL; + MR_Code *pc_at_signal = NULL; #if defined(HAVE_SIGCONTEXT_STRUCT) #ifdef PC_ACCESS struct sigcontext_struct *context = the_context; - pc_at_signal = (Code *) context->PC_ACCESS; + pc_at_signal = (MR_Code *) context->PC_ACCESS; #else - pc_at_signal = (Code *) NULL; + pc_at_signal = (MR_Code *) NULL; #endif #elif defined(HAVE_SIGINFO_T) @@ -857,21 +857,21 @@ get_pc_from_context(void *the_context) ucontext_t *context = the_context; #ifdef PC_ACCESS_GREG - pc_at_signal = (Code *) context->uc_mcontext.gregs[PC_ACCESS]; + pc_at_signal = (MR_Code *) context->uc_mcontext.gregs[PC_ACCESS]; #else - pc_at_signal = (Code *) context->uc_mcontext.PC_ACCESS; + pc_at_signal = (MR_Code *) context->uc_mcontext.PC_ACCESS; #endif #else /* not PC_ACCESS */ /* if PC_ACCESS is not set, we don't know the context */ - pc_at_signal = (Code *) NULL; + pc_at_signal = (MR_Code *) NULL; #endif /* not PC_ACCESS */ #else /* not HAVE_SIGINFO_T && not HAVE_SIGCONTEXT_STRUCT */ - pc_at_signal = (Code *) NULL; + pc_at_signal = (MR_Code *) NULL; #endif @@ -890,19 +890,19 @@ get_pc_from_context(void *the_context) ** machine register that is used for MR_sp. ** Need to fix this so it works when the register is in a fake reg too. */ -static Word * +static MR_Word * get_sp_from_context(void *the_context) { - Word *sp_at_signal = NULL; + MR_Word *sp_at_signal = NULL; #ifdef NATIVE_GC #if defined(HAVE_SIGCONTEXT_STRUCT) #ifdef PC_ACCESS struct sigcontext_struct *context = the_context; - sp_at_signal = (Word *) context->MR_real_reg_number_sp; + sp_at_signal = (MR_Word *) context->MR_real_reg_number_sp; #else - sp_at_signal = (Word *) NULL; + sp_at_signal = (MR_Word *) NULL; #endif #elif defined(HAVE_SIGINFO_T) @@ -912,9 +912,9 @@ get_sp_from_context(void *the_context) struct sigcontext *context = the_context; #ifdef PC_ACCESS_GREG - sp_at_signal = (Word *) context->gregs[MR_real_reg_number_sp]; + sp_at_signal = (MR_Word *) context->gregs[MR_real_reg_number_sp]; #else - sp_at_signal = (Word *) context->sc_regs[MR_real_reg_number_sp]; + sp_at_signal = (MR_Word *) context->sc_regs[MR_real_reg_number_sp]; #endif #else /* not PC_ACCESS */ @@ -923,17 +923,17 @@ get_sp_from_context(void *the_context) ** if PC_ACCESS is not set, we don't know how to get at the ** registers */ - sp_at_signal = (Word *) NULL; + sp_at_signal = (MR_Word *) NULL; #endif /* not PC_ACCESS */ #else /* not HAVE_SIGINFO_T && not HAVE_SIGCONTEXT_STRUCT */ - sp_at_signal = (Word *) NULL; + sp_at_signal = (MR_Word *) NULL; #endif #else /* !NATIVE_GC */ - sp_at_signal = (Word *) NULL; + sp_at_signal = (MR_Word *) NULL; #endif /* !NATIVE_GC */ return sp_at_signal; diff --git a/runtime/mercury_memory_zones.c b/runtime/mercury_memory_zones.c index 30e51c61b..23e1633ee 100644 --- a/runtime/mercury_memory_zones.c +++ b/runtime/mercury_memory_zones.c @@ -175,7 +175,7 @@ memalign(size_t unit, size_t size) /*---------------------------------------------------------------------------*/ -Word virtual_reg_map[MAX_REAL_REG] = VIRTUAL_REG_MAP_BODY; +MR_Word virtual_reg_map[MAX_REAL_REG] = VIRTUAL_REG_MAP_BODY; unsigned long num_uses[MAX_RN]; @@ -227,7 +227,7 @@ init_offsets() offset_vector = MR_GC_NEW_ARRAY(size_t, CACHE_SLICES - 1); - fake_reg_offset = (Unsigned) MR_fake_reg % pcache_size; + fake_reg_offset = (MR_Unsigned) MR_fake_reg % pcache_size; for (i = 0; i < CACHE_SLICES - 1; i++) { offset_vector[i] = @@ -321,9 +321,9 @@ next_offset(void) MemoryZone * create_zone(const char *name, int id, size_t size, size_t offset, size_t redsize, - bool ((*handler)(Word *addr, MemoryZone *zone, void *context))) + bool ((*handler)(MR_Word *addr, MemoryZone *zone, void *context))) { - Word *base; + MR_Word *base; size_t total_size; /* @@ -339,7 +339,7 @@ create_zone(const char *name, int id, size_t size, total_size = size + unit; #endif - base = (Word *) memalign(unit, total_size); + base = (MR_Word *) memalign(unit, total_size); if (base == NULL) { char buf[2560]; sprintf(buf, "unable allocate memory zone: %s#%d", name, id); @@ -350,7 +350,7 @@ create_zone(const char *name, int id, size_t size, } /* end create_zone() */ MemoryZone * -construct_zone(const char *name, int id, Word *base, +construct_zone(const char *name, int id, MR_Word *base, size_t size, size_t offset, size_t redsize, ZoneHandler handler) { @@ -378,8 +378,8 @@ construct_zone(const char *name, int id, Word *base, total_size = size; #endif /* MR_PROTECTPAGE */ - zone->top = (Word *) ((char *)base + total_size); - zone->min = (Word *) ((char *)base + offset); + zone->top = (MR_Word *) ((char *)base + total_size); + zone->min = (MR_Word *) ((char *)base + offset); #ifdef MR_LOWLEVEL_DEBUG zone->max = zone->min; #endif /* MR_LOWLEVEL_DEBUG */ @@ -388,8 +388,8 @@ construct_zone(const char *name, int id, Word *base, ** setup the redzone */ #ifdef MR_CHECK_OVERFLOW_VIA_MPROTECT - zone->redzone_base = zone->redzone = (Word *) - round_up((Unsigned)base + size - redsize, unit); + zone->redzone_base = zone->redzone = (MR_Word *) + round_up((MR_Unsigned)base + size - redsize, unit); if (MR_protect_pages((char *)zone->redzone, redsize + unit, MY_PROT) < 0) { @@ -405,7 +405,7 @@ construct_zone(const char *name, int id, Word *base, ** setup the hardzone */ #if defined(MR_PROTECTPAGE) - zone->hardmax = (Word *) round_up((Unsigned)zone->top - unit, unit); + zone->hardmax = (MR_Word *) round_up((MR_Unsigned)zone->top - unit, unit); if (MR_protect_pages((char *)zone->hardmax, unit, MY_PROT) < 0) { char buf[2560]; sprintf(buf, "unable to set %s#%d hardmax\n" diff --git a/runtime/mercury_memory_zones.h b/runtime/mercury_memory_zones.h index fa5ff8fb0..069e32476 100644 --- a/runtime/mercury_memory_zones.h +++ b/runtime/mercury_memory_zones.h @@ -22,7 +22,7 @@ #include /* for size_t */ -#include "mercury_types.h" /* for Word */ +#include "mercury_types.h" /* for MR_Word */ #include "mercury_std.h" /* for bool */ @@ -40,7 +40,7 @@ /* mr0 .. mr37, mr(38) ... mr(1000) ... */ /* used to lookup the fake_reg for a given real reg */ -extern Word virtual_reg_map[MAX_REAL_REG]; +extern MR_Word virtual_reg_map[MAX_REAL_REG]; /* used for counting register usage */ extern unsigned long num_uses[MAX_RN]; @@ -84,7 +84,7 @@ extern unsigned long num_uses[MAX_RN]; typedef struct MEMORY_ZONE MemoryZone; -typedef bool ZoneHandler(Word *addr, struct MEMORY_ZONE *zone, void *context); +typedef bool ZoneHandler(MR_Word *addr, struct MEMORY_ZONE *zone, void *context); struct MEMORY_ZONE { struct MEMORY_ZONE *next; /* the memory zones are organized as a @@ -95,19 +95,19 @@ struct MEMORY_ZONE { */ const char *name; /* name identifier */ int id; /* number */ - Word *bottom; /* beginning of the allocated area */ - Word *top; /* end of the allocated area */ - Word *min; /* lowest word of the area to be used */ - Word *max; /* highest word of the area to be used; + MR_Word *bottom; /* beginning of the allocated area */ + MR_Word *top; /* end of the allocated area */ + MR_Word *min; /* lowest word of the area to be used */ + MR_Word *max; /* highest word of the area to be used; computed only if MR_LOWLEVEL_DEBUG is enabled */ #ifdef MR_PROTECTPAGE - Word *hardmax; /* last page of the zone which can't be + MR_Word *hardmax; /* last page of the zone which can't be unprotected */ #endif /* MR_PROTECTPAGE */ #ifdef MR_CHECK_OVERFLOW_VIA_MPROTECT - Word *redzone_base; /* beginning of the original redzone */ - Word *redzone; /* beginning of the current redzone */ + MR_Word *redzone_base; /* beginning of the original redzone */ + MR_Word *redzone; /* beginning of the current redzone */ ZoneHandler *handler; /* handler for page faults in the redzone */ #endif /* MR_CHECK_OVERFLOW_VIA_MPROTECT */ @@ -205,7 +205,7 @@ MemoryZone *create_zone(const char *name, int id, ** [*] unit is a global variable containing the page size in bytes */ -MemoryZone *construct_zone(const char *name, int Id, Word *base, +MemoryZone *construct_zone(const char *name, int Id, MR_Word *base, size_t size, size_t offset, size_t redsize, ZoneHandler *handler); diff --git a/runtime/mercury_misc.c b/runtime/mercury_misc.c index 6920d1f76..35ee88ed0 100644 --- a/runtime/mercury_misc.c +++ b/runtime/mercury_misc.c @@ -67,7 +67,7 @@ MR_fatal_error(const char *fmt, ...) #undef MR_hash_string int -MR_hash_string(Word s) +MR_hash_string(MR_Word s) { MR_HASH_STRING_FUNC_BODY } diff --git a/runtime/mercury_prof.c b/runtime/mercury_prof.c index afd83ff59..a7419ae21 100644 --- a/runtime/mercury_prof.c +++ b/runtime/mercury_prof.c @@ -61,15 +61,15 @@ static const char * MR_time_method; */ typedef struct s_prof_call_node { - Code *Callee; - Code *Caller; + MR_Code *Callee; + MR_Code *Caller; unsigned long count; struct s_prof_call_node *left; struct s_prof_call_node *right; } prof_call_node; typedef struct s_prof_time_node { - Code *Addr; + MR_Code *Addr; unsigned long count; struct s_prof_time_node *left; struct s_prof_time_node *right; @@ -91,7 +91,7 @@ typedef struct s_prof_time_node { ** Global Variables */ -Code * volatile MR_prof_current_proc; +MR_Code * volatile MR_prof_current_proc; /* ** Private global variables @@ -300,7 +300,7 @@ prof_init_time_profile_method(void) */ void -MR_prof_call_profile(Code *Callee, Code *Caller) +MR_prof_call_profile(MR_Code *Callee, MR_Code *Caller) { prof_call_node *node, **node_addr, *new_node; int hash_value; @@ -356,7 +356,7 @@ prof_time_profile(int signum) { prof_time_node *node, **node_addr, *new_node; int hash_value; - Code *current_proc; + MR_Code *current_proc; /* Ignore any signals we get in this function or in prof_call_profile */ if (in_profiling_code) { @@ -467,7 +467,7 @@ print_addr_pair_node(FILE *fptr, prof_call_node *node) */ void -MR_prof_output_addr_decl(const char *name, const Code *address) +MR_prof_output_addr_decl(const char *name, const MR_Code *address) { if (!decl_fptr) { decl_fptr = checked_fopen("Prof.Decl", "create", "w"); diff --git a/runtime/mercury_prof.h b/runtime/mercury_prof.h index 77d6047f4..05f4fa41c 100644 --- a/runtime/mercury_prof.h +++ b/runtime/mercury_prof.h @@ -12,7 +12,7 @@ #ifndef MERCURY_PROF_H #define MERCURY_PROF_H -#include "mercury_types.h" /* for `Code *' */ +#include "mercury_types.h" /* for `MR_Code *' */ #include @@ -22,8 +22,6 @@ ** so that it can credit the time to the appropriate procedure. */ -extern Code * volatile MR_prof_current_proc; - /* ** A pointer to the "Prof.Decl" file. */ @@ -58,7 +56,7 @@ extern Code * volatile MR_prof_current_proc; #endif #ifdef PROFILE_CALLS - extern void MR_prof_call_profile(Code *, Code *); + extern void MR_prof_call_profile(MR_Code *, MR_Code *); #endif @@ -67,7 +65,7 @@ extern Code * volatile MR_prof_current_proc; ** mercury_label.c to record the address of each entry label. */ -extern void MR_prof_output_addr_decl(const char *name, const Code *address); +extern void MR_prof_output_addr_decl(const char *name, const MR_Code *address); /* diff --git a/runtime/mercury_prof_mem.c b/runtime/mercury_prof_mem.c index 3f6366385..bdcae5ff6 100644 --- a/runtime/mercury_prof_mem.c +++ b/runtime/mercury_prof_mem.c @@ -1,5 +1,5 @@ /* -** Copyright (C) 1996-1997, 1999 The University of Melbourne. +** Copyright (C) 1996-1997, 1999-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -24,7 +24,7 @@ #include "mercury_prof_mem.h" #include "mercury_memory.h" /* for MR_GC_malloc() */ -#include "mercury_types.h" /* for Word */ +#include "mercury_types.h" /* for MR_Word */ /*----------------------------------------------------------------------------*/ @@ -62,12 +62,12 @@ MR_prof_malloc(size_t size) ** up to the nearest multiple of the word size. ** ** Note that the current implementation of MR_prof_malloc only - ** guarantees that the memory will be Word-aligned; if you want to + ** guarantees that the memory will be MR_Word-aligned; if you want to ** allocate types that contain data types (e.g. `double') which might ** require stricter alignment than that, then you will need to ** change this to round the size up accordingly. */ - size = ((size + sizeof(Word) - 1) / sizeof(Word)) * sizeof(Word); + size = ((size + sizeof(MR_Word) - 1) / sizeof(MR_Word)) * sizeof(MR_Word); /* Here we waste a bit of space but hopefully not to much */ if (mem_left < size) { diff --git a/runtime/mercury_prof_mem.h b/runtime/mercury_prof_mem.h index 0f8bb0753..6f7b595ee 100644 --- a/runtime/mercury_prof_mem.h +++ b/runtime/mercury_prof_mem.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1996-1997, 1999 The University of Melbourne. +** Copyright (C) 1996-1997, 1999-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -24,7 +24,7 @@ ** Doing that is bad news, because MR_GC_malloc() is not re-entrant. ** ** Note that the current implementation of MR_prof_malloc only guarantees -** that the memory will be Word-aligned; if you want to allocate types +** that the memory will be MR_Word-aligned; if you want to allocate types ** that contain data types (e.g. `double') which might require stricter ** alignment than that, then you will need to change the implementation of ** MR_prof_malloc(). diff --git a/runtime/mercury_regorder.h b/runtime/mercury_regorder.h index 4f9260096..802350270 100644 --- a/runtime/mercury_regorder.h +++ b/runtime/mercury_regorder.h @@ -85,27 +85,27 @@ /* ** first, the "very special" registers -- these may go in real machine regs */ -#define MR_engine_base LVALUE_CAST(Word *, count_usage(MR_SP_RN, mr0)) -#define MR_succip LVALUE_CAST(Code *, count_usage(MR_SI_RN, mr2)) -#define MR_hp LVALUE_CAST(Word *, count_usage(MR_HP_RN, mr6)) -#define MR_sp LVALUE_CAST(Word *, count_usage(MR_SP_RN, mr1)) -#define MR_curfr LVALUE_CAST(Word *, count_usage(MR_CF_RN, mr9)) -#define MR_maxfr LVALUE_CAST(Word *, count_usage(MR_MF_RN, mr10)) +#define MR_engine_base LVALUE_CAST(MR_Word *, count_usage(MR_SP_RN, mr0)) +#define MR_succip LVALUE_CAST(MR_Code *, count_usage(MR_SI_RN, mr2)) +#define MR_hp LVALUE_CAST(MR_Word *, count_usage(MR_HP_RN, mr6)) +#define MR_sp LVALUE_CAST(MR_Word *, count_usage(MR_SP_RN, mr1)) +#define MR_curfr LVALUE_CAST(MR_Word *, count_usage(MR_CF_RN, mr9)) +#define MR_maxfr LVALUE_CAST(MR_Word *, count_usage(MR_MF_RN, mr10)) /* ** next, the remainder of the special registers -- these go in the ** fake_reg array, or in some cases in ordinary global variables. */ -#define MR_sol_hp LVALUE_CAST(Word *, count_usage(MR_SOL_HP_RN, mr(38))) -#define MR_min_hp_rec LVALUE_CAST(Word *, count_usage(MR_MIN_HP_REC, mr(39))) -#define MR_min_sol_hp_rec LVALUE_CAST(Word *, \ +#define MR_sol_hp LVALUE_CAST(MR_Word *, count_usage(MR_SOL_HP_RN, mr(38))) +#define MR_min_hp_rec LVALUE_CAST(MR_Word *, count_usage(MR_MIN_HP_REC, mr(39))) +#define MR_min_sol_hp_rec LVALUE_CAST(MR_Word *, \ count_usage(MR_MIN_HP_REC, mr(40))) -#define MR_global_hp LVALUE_CAST(Word *, \ +#define MR_global_hp LVALUE_CAST(MR_Word *, \ count_usage(MR_GLOBAL_HP_RN, mr(41))) -#define MR_gen_next LVALUE_CAST(Integer, \ +#define MR_gen_next LVALUE_CAST(MR_Integer, \ count_usage(MR_GEN_NEXT_RN, mr(42))) #define MR_gen_stack LVALUE_CAST(struct MR_GeneratorStackFrameStruct *, \ count_usage(MR_GEN_STACK_RN, mr(43))) -#define MR_cut_next LVALUE_CAST(Integer, \ +#define MR_cut_next LVALUE_CAST(MR_Integer, \ count_usage(MR_CUT_NEXT_RN, mr(44))) #define MR_cut_stack LVALUE_CAST(struct MR_CutStackFrameStruct *, \ count_usage(MR_CUT_STACK_RN, mr(45))) @@ -135,20 +135,20 @@ ** the real machine register. */ -#define MR_saved_succip(save_area) LVALUE_CAST(Code *, save_area[2]) -#define MR_saved_hp(save_area) LVALUE_CAST(Word *, save_area[6]) -#define MR_saved_sp(save_area) LVALUE_CAST(Word *, save_area[1]) -#define MR_saved_curfr(save_area) LVALUE_CAST(Word *, save_area[9]) -#define MR_saved_maxfr(save_area) LVALUE_CAST(Word *, save_area[10]) -#define MR_saved_sol_hp(save_area) LVALUE_CAST(Word *, save_area[38]) -#define MR_saved_min_hp_rec(save_area) LVALUE_CAST(Word *, save_area[39]) -#define MR_saved_min_sol_hp_rec(save_area) LVALUE_CAST(Word *, save_area[40]) -#define MR_saved_global_hp(save_area) LVALUE_CAST(Word *, save_area[41]) -#define MR_saved_gen_next(save_area) LVALUE_CAST(Integer, save_area[42]) +#define MR_saved_succip(save_area) LVALUE_CAST(MR_Code *, save_area[2]) +#define MR_saved_hp(save_area) LVALUE_CAST(MR_Word *, save_area[6]) +#define MR_saved_sp(save_area) LVALUE_CAST(MR_Word *, save_area[1]) +#define MR_saved_curfr(save_area) LVALUE_CAST(MR_Word *, save_area[9]) +#define MR_saved_maxfr(save_area) LVALUE_CAST(MR_Word *, save_area[10]) +#define MR_saved_sol_hp(save_area) LVALUE_CAST(MR_Word *, save_area[38]) +#define MR_saved_min_hp_rec(save_area) LVALUE_CAST(MR_Word *, save_area[39]) +#define MR_saved_min_sol_hp_rec(save_area) LVALUE_CAST(MR_Word *, save_area[40]) +#define MR_saved_global_hp(save_area) LVALUE_CAST(MR_Word *, save_area[41]) +#define MR_saved_gen_next(save_area) LVALUE_CAST(MR_Integer, save_area[42]) #define MR_saved_gen_stack(save_area) LVALUE_CAST( \ struct MR_GeneratorStackFrameStruct *,\ save_area[43]) -#define MR_saved_cut_next(save_area) LVALUE_CAST(Integer, save_area[44]) +#define MR_saved_cut_next(save_area) LVALUE_CAST(MR_Integer, save_area[44]) #define MR_saved_cut_stack(save_area) LVALUE_CAST( \ struct MR_CutStackFrameStruct *, \ save_area[45]) @@ -243,31 +243,31 @@ /* ** first, the "very special" registers -- these may go in real machine regs */ -#define MR_succip LVALUE_CAST(Code *, count_usage(MR_SI_RN, mr1)) -#define MR_hp LVALUE_CAST(Word *, count_usage(MR_HP_RN, mr5)) -#define MR_sp LVALUE_CAST(Word *, count_usage(MR_SP_RN, mr0)) -#define MR_curfr LVALUE_CAST(Word *, count_usage(MR_CF_RN, mr8)) -#define MR_maxfr LVALUE_CAST(Word *, count_usage(MR_MF_RN, mr9)) +#define MR_succip LVALUE_CAST(MR_Code *, count_usage(MR_SI_RN, mr1)) +#define MR_hp LVALUE_CAST(MR_Word *, count_usage(MR_HP_RN, mr5)) +#define MR_sp LVALUE_CAST(MR_Word *, count_usage(MR_SP_RN, mr0)) +#define MR_curfr LVALUE_CAST(MR_Word *, count_usage(MR_CF_RN, mr8)) +#define MR_maxfr LVALUE_CAST(MR_Word *, count_usage(MR_MF_RN, mr9)) /* ** next, the remainder of the special registers -- these go in the ** fake_reg array, or in some cases in ordinary global variables. */ -#define MR_sol_hp LVALUE_CAST(Word *, count_usage(MR_SOL_HP_RN, mr(37))) -#define MR_min_hp_rec LVALUE_CAST(Word *, count_usage(MR_MIN_HP_REC, mr(38))) -#define MR_min_sol_hp_rec LVALUE_CAST(Word *, \ +#define MR_sol_hp LVALUE_CAST(MR_Word *, count_usage(MR_SOL_HP_RN, mr(37))) +#define MR_min_hp_rec LVALUE_CAST(MR_Word *, count_usage(MR_MIN_HP_REC, mr(38))) +#define MR_min_sol_hp_rec LVALUE_CAST(MR_Word *, \ count_usage(MR_MIN_HP_REC, mr(39))) -#define MR_global_hp LVALUE_CAST(Word *, \ +#define MR_global_hp LVALUE_CAST(MR_Word *, \ count_usage(MR_GLOBAL_HP_RN, mr(40))) #define MR_trail_ptr count_usage(MR_TRAIL_PTR_RN, MR_trail_ptr_var) #define MR_ticket_counter \ count_usage(MR_TICKET_COUNTER_RN, MR_ticket_counter_var) #define MR_ticket_high_water \ count_usage(MR_TICKET_HIGH_WATER_RN, MR_ticket_high_water_var) -#define MR_gen_next LVALUE_CAST(Integer, \ +#define MR_gen_next LVALUE_CAST(MR_Integer, \ count_usage(MR_GEN_NEXT_RN, mr(41))) #define MR_gen_stack LVALUE_CAST(struct MR_GeneratorStackFrameStruct *, \ count_usage(MR_GEN_STACK_RN, mr(42))) -#define MR_cut_next LVALUE_CAST(Integer, \ +#define MR_cut_next LVALUE_CAST(MR_Integer, \ count_usage(MR_CUT_NEXT_RN, mr(43))) #define MR_cut_stack LVALUE_CAST(struct MR_CutStackFrameStruct *, \ count_usage(MR_CUT_STACK_RN, mr(44))) @@ -291,20 +291,20 @@ ** the real machine register. */ -#define MR_saved_succip(save_area) LVALUE_CAST(Code *, save_area[1]) -#define MR_saved_hp(save_area) LVALUE_CAST(Word *, save_area[5]) -#define MR_saved_sp(save_area) LVALUE_CAST(Word *, save_area[0]) -#define MR_saved_curfr(save_area) LVALUE_CAST(Word *, save_area[8]) -#define MR_saved_maxfr(save_area) LVALUE_CAST(Word *, save_area[9]) -#define MR_saved_sol_hp(save_area) LVALUE_CAST(Word *, save_area[37]) -#define MR_saved_min_hp_rec(save_area) LVALUE_CAST(Word *, save_area[38]) -#define MR_saved_min_sol_hp_rec(save_area) LVALUE_CAST(Word *, save_area[39]) -#define MR_saved_global_hp(save_area) LVALUE_CAST(Word *, save_area[40]) -#define MR_saved_gen_stack(save_area) LVALUE_CAST(Integer, save_area[41]) +#define MR_saved_succip(save_area) LVALUE_CAST(MR_Code *, save_area[1]) +#define MR_saved_hp(save_area) LVALUE_CAST(MR_Word *, save_area[5]) +#define MR_saved_sp(save_area) LVALUE_CAST(MR_Word *, save_area[0]) +#define MR_saved_curfr(save_area) LVALUE_CAST(MR_Word *, save_area[8]) +#define MR_saved_maxfr(save_area) LVALUE_CAST(MR_Word *, save_area[9]) +#define MR_saved_sol_hp(save_area) LVALUE_CAST(MR_Word *, save_area[37]) +#define MR_saved_min_hp_rec(save_area) LVALUE_CAST(MR_Word *, save_area[38]) +#define MR_saved_min_sol_hp_rec(save_area) LVALUE_CAST(MR_Word *, save_area[39]) +#define MR_saved_global_hp(save_area) LVALUE_CAST(MR_Word *, save_area[40]) +#define MR_saved_gen_stack(save_area) LVALUE_CAST(MR_Integer, save_area[41]) #define MR_saved_gen_next(save_area) LVALUE_CAST( \ struct MR_GeneratorStackFrameStruct *,\ save_area[42]) -#define MR_saved_cut_stack(save_area) LVALUE_CAST(Integer, save_area[43]) +#define MR_saved_cut_stack(save_area) LVALUE_CAST(MR_Integer, save_area[43]) #define MR_saved_cut_next(save_area) LVALUE_CAST( \ struct MR_CutStackFrameStruct *, \ save_area[44]) diff --git a/runtime/mercury_regs.c b/runtime/mercury_regs.c index 3863f3bfe..1ff6f5ee5 100644 --- a/runtime/mercury_regs.c +++ b/runtime/mercury_regs.c @@ -1,5 +1,5 @@ /* -** Copyright (C) 1997 The University of Melbourne. +** Copyright (C) 1997, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -10,7 +10,7 @@ #include -Word +MR_Word get_reg(int num) { restore_transient_registers(); @@ -57,8 +57,8 @@ get_reg(int num) return 0; } /* end get_reg() */ -Word -set_reg(int num, Word val) +MR_Word +set_reg(int num, MR_Word val) { restore_transient_registers(); switch (num) { diff --git a/runtime/mercury_regs.h b/runtime/mercury_regs.h index 038836abb..dc05f5da9 100644 --- a/runtime/mercury_regs.h +++ b/runtime/mercury_regs.h @@ -140,7 +140,7 @@ #define restore_registers() \ do { \ MR_engine_base = MR_thread_engine_base; \ - MR_fake_reg[0] = (Word) MR_engine_base; \ + MR_fake_reg[0] = (MR_Word) MR_engine_base; \ restore_regs_from_mem(MR_fake_reg); \ } while (0) #else @@ -160,7 +160,7 @@ #define restore_transient_registers() \ do { \ MR_engine_base = MR_thread_engine_base; \ - MR_fake_reg[0] = (Word) MR_engine_base; \ + MR_fake_reg[0] = (MR_Word) MR_engine_base; \ restore_transient_regs_from_mem(MR_fake_reg); \ } while (0) #else @@ -252,8 +252,8 @@ ** Currently they're buggy for n>32 and are not used except for debugging. */ -extern Word get_reg(int); -extern Word set_reg(int, Word); +extern MR_Word get_reg(int); +extern MR_Word set_reg(int, MR_Word); /* ** the following macros define a mapping from registers to indices into the diff --git a/runtime/mercury_signal.c b/runtime/mercury_signal.c index f38ec0219..ac6ba66cf 100644 --- a/runtime/mercury_signal.c +++ b/runtime/mercury_signal.c @@ -83,7 +83,7 @@ #endif void -MR_setup_signal(int sig, Code *handler, bool need_info, +MR_setup_signal(int sig, MR_Code *handler, bool need_info, const char *error_message) { #if defined(HAVE_SIGACTION) diff --git a/runtime/mercury_signal.h b/runtime/mercury_signal.h index 6885f3894..86c894560 100644 --- a/runtime/mercury_signal.h +++ b/runtime/mercury_signal.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1998 The University of Melbourne. +** Copyright (C) 1998, 2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -27,7 +27,7 @@ ** TRUE. Note that on some platforms, signal information is ** provided regardless of the value of need_info. */ -extern void MR_setup_signal(int sig, Code *handler, bool need_info, +extern void MR_setup_signal(int sig, MR_Code *handler, bool need_info, const char * error_message); diff --git a/runtime/mercury_stack_layout.h b/runtime/mercury_stack_layout.h index 58f342bb6..9e0146065 100644 --- a/runtime/mercury_stack_layout.h +++ b/runtime/mercury_stack_layout.h @@ -128,10 +128,10 @@ typedef enum { #define MR_LONG_LVAL_TYPE(Locn) \ ((MR_Long_Lval_Type) \ - (((Word) Locn) & ((1 << MR_LONG_LVAL_TAGBITS) - 1))) + (((MR_Word) Locn) & ((1 << MR_LONG_LVAL_TAGBITS) - 1))) #define MR_LONG_LVAL_NUMBER(Locn) \ - ((int) ((Word) Locn) >> MR_LONG_LVAL_TAGBITS) + ((int) ((MR_Word) Locn) >> MR_LONG_LVAL_TAGBITS) /* This must be in sync with stack_layout__offset_bits */ #define MR_LONG_LVAL_OFFSETBITS 6 @@ -140,16 +140,16 @@ typedef enum { ((int) ((LocnNumber) & ((1 << MR_LONG_LVAL_OFFSETBITS) - 1))) #define MR_LONG_LVAL_INDIRECT_BASE_LVAL(LocnNumber) \ - (((Word) (LocnNumber)) >> MR_LONG_LVAL_OFFSETBITS) + (((MR_Word) (LocnNumber)) >> MR_LONG_LVAL_OFFSETBITS) #define MR_LONG_LVAL_STACKVAR(n) \ - ((Word) ((n) << MR_LONG_LVAL_TAGBITS) + MR_LONG_LVAL_TYPE_STACKVAR) + ((MR_Word) ((n) << MR_LONG_LVAL_TAGBITS) + MR_LONG_LVAL_TYPE_STACKVAR) #define MR_LONG_LVAL_FRAMEVAR(n) \ - ((Word) ((n) << MR_LONG_LVAL_TAGBITS) + MR_LONG_LVAL_TYPE_FRAMEVAR) + ((MR_Word) ((n) << MR_LONG_LVAL_TAGBITS) + MR_LONG_LVAL_TYPE_FRAMEVAR) #define MR_LONG_LVAL_R_REG(n) \ - ((Word) ((n) << MR_LONG_LVAL_TAGBITS) + MR_LONG_LVAL_TYPE_R) + ((MR_Word) ((n) << MR_LONG_LVAL_TAGBITS) + MR_LONG_LVAL_TYPE_R) /* ** MR_Short_Lval is a MR_uint_least8_t which describes an location. This @@ -185,7 +185,7 @@ typedef enum { #define MR_SHORT_LVAL_TYPE(Locn) \ ((MR_Short_Lval_Type) \ - (((Word) Locn) & ((1 << MR_SHORT_LVAL_TAGBITS) - 1))) + (((MR_Word) Locn) & ((1 << MR_SHORT_LVAL_TAGBITS) - 1))) #define MR_SHORT_LVAL_STACKVAR(n) \ ((MR_Short_Lval) (((n) << MR_SHORT_LVAL_TAGBITS) \ @@ -258,7 +258,7 @@ typedef struct MR_Var_Name_Struct { */ typedef struct MR_Stack_Layout_Vars_Struct { - Integer MR_slvs_var_count; + MR_Integer MR_slvs_var_count; void *MR_slvs_locns_types; MR_Var_Name *MR_slvs_names; MR_Type_Param_Locns *MR_slvs_tvars; @@ -345,18 +345,18 @@ typedef struct MR_Stack_Layout_Vars_Struct { typedef struct MR_Stack_Layout_User_Proc_Struct { MR_PredFunc MR_user_pred_or_func; - ConstString MR_user_decl_module; - ConstString MR_user_def_module; - ConstString MR_user_name; + MR_ConstString MR_user_decl_module; + MR_ConstString MR_user_def_module; + MR_ConstString MR_user_name; MR_int_least16_t MR_user_arity; MR_int_least16_t MR_user_mode; } MR_Stack_Layout_User_Proc; typedef struct MR_Stack_Layout_Compiler_Proc_Struct { - ConstString MR_comp_type_name; - ConstString MR_comp_type_module; - ConstString MR_comp_def_module; - ConstString MR_comp_pred_name; + MR_ConstString MR_comp_type_name; + MR_ConstString MR_comp_type_module; + MR_ConstString MR_comp_def_module; + MR_ConstString MR_comp_pred_name; MR_int_least16_t MR_comp_arity; MR_int_least16_t MR_comp_mode; } MR_Stack_Layout_Compiler_Proc; @@ -368,7 +368,7 @@ typedef union MR_Stack_Layout_Proc_Id_Union { typedef struct MR_Stack_Layout_Entry_Struct { /* stack traversal group */ - Code *MR_sle_code_addr; + MR_Code *MR_sle_code_addr; MR_Long_Lval MR_sle_succip_locn; MR_int_least16_t MR_sle_stack_slots; MR_Determinism MR_sle_detism; @@ -391,14 +391,14 @@ typedef struct MR_Stack_Layout_Entry_Struct { #define MR_sle_comp MR_sle_proc_id.MR_proc_comp #define MR_ENTRY_LAYOUT_HAS_PROC_ID(entry) \ - ((Word) entry->MR_sle_user.MR_user_pred_or_func != -1) + ((MR_Word) entry->MR_sle_user.MR_user_pred_or_func != -1) #define MR_ENTRY_LAYOUT_HAS_EXEC_TRACE(entry) \ (MR_ENTRY_LAYOUT_HAS_PROC_ID(entry) \ && entry->MR_sle_call_label != NULL) #define MR_ENTRY_LAYOUT_COMPILER_GENERATED(entry) \ - ((Unsigned) entry->MR_sle_user.MR_user_pred_or_func \ + ((MR_Unsigned) entry->MR_sle_user.MR_user_pred_or_func \ > MR_FUNCTION) /* @@ -431,7 +431,7 @@ typedef struct MR_Stack_Layout_Entry_Struct { #define MR_MAKE_PROC_LAYOUT_ADDR(entry) STATIC(entry) #define MR_INIT_PROC_LAYOUT_ADDR(entry) do { } while (0) #else - #define MR_MAKE_PROC_LAYOUT_ADDR(entry) ((Code *) NULL) + #define MR_MAKE_PROC_LAYOUT_ADDR(entry) ((MR_Code *) NULL) #define MR_INIT_PROC_LAYOUT_ADDR(entry) \ do { \ ((MR_Stack_Layout_Entry *) & \ @@ -578,20 +578,20 @@ typedef struct MR_Stack_Layout_Label_Struct { */ typedef struct MR_Module_File_Layout_Struct { - String MR_mfl_filename; - Integer MR_mfl_label_count; + MR_String MR_mfl_filename; + MR_Integer MR_mfl_label_count; /* the following fields point to arrays of size MR_mfl_label_count */ MR_int_least16_t *MR_mfl_label_lineno; MR_Stack_Layout_Label **MR_mfl_label_layout; } MR_Module_File_Layout; typedef struct MR_Module_Layout_Struct { - String MR_ml_name; - Integer MR_ml_string_table_size; + MR_String MR_ml_name; + MR_Integer MR_ml_string_table_size; char *MR_ml_string_table; - Integer MR_ml_proc_count; + MR_Integer MR_ml_proc_count; MR_Stack_Layout_Entry **MR_ml_procs; - Integer MR_ml_filename_count; + MR_Integer MR_ml_filename_count; MR_Module_File_Layout **MR_ml_module_file_layout; } MR_Module_Layout; diff --git a/runtime/mercury_stack_trace.c b/runtime/mercury_stack_trace.c index cd51b3a53..3c2e5db08 100644 --- a/runtime/mercury_stack_trace.c +++ b/runtime/mercury_stack_trace.c @@ -1,5 +1,5 @@ /* -** Copyright (C) 1998-1999 The University of Melbourne. +** Copyright (C) 1998-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -18,7 +18,7 @@ static void MR_dump_stack_record_init(bool include_contexts); static void MR_dump_stack_record_frame(FILE *fp, const MR_Stack_Layout_Label *, - Word *base_sp, Word *base_curfr, + MR_Word *base_sp, MR_Word *base_curfr, MR_Print_Stack_Record print_stack_record); static void MR_dump_stack_record_flush(FILE *fp, MR_Print_Stack_Record print_stack_record); @@ -29,12 +29,12 @@ static void MR_maybe_print_parent_context(FILE *fp, bool print_parent, bool verbose, const char *filename, int lineno); /* see comments in mercury_stack_trace.h */ -Code *MR_stack_trace_bottom; -Word *MR_nondet_stack_trace_bottom; +MR_Code *MR_stack_trace_bottom; +MR_Word *MR_nondet_stack_trace_bottom; void -MR_dump_stack(Code *success_pointer, Word *det_stack_pointer, - Word *current_frame, bool include_trace_data) +MR_dump_stack(MR_Code *success_pointer, MR_Word *det_stack_pointer, + MR_Word *current_frame, bool include_trace_data) { #ifndef MR_STACK_TRACE fprintf(stderr, "Stack dump not available in this grade.\n"); @@ -65,7 +65,7 @@ MR_dump_stack(Code *success_pointer, Word *det_stack_pointer, const char * MR_dump_stack_from_layout(FILE *fp, const MR_Stack_Layout_Label *label_layout, - Word *det_stack_pointer, Word *current_frame, bool include_trace_data, + MR_Word *det_stack_pointer, MR_Word *current_frame, bool include_trace_data, bool include_contexts, MR_Print_Stack_Record print_stack_record) { MR_Stack_Walk_Step_Result result; @@ -73,10 +73,10 @@ MR_dump_stack_from_layout(FILE *fp, const MR_Stack_Layout_Label *label_layout, const MR_Stack_Layout_Label *cur_label_layout; const MR_Stack_Layout_Label *prev_label_layout; const char *problem; - Word *stack_trace_sp; - Word *stack_trace_curfr; - Word *old_trace_sp; - Word *old_trace_curfr; + MR_Word *stack_trace_sp; + MR_Word *stack_trace_curfr; + MR_Word *old_trace_sp; + MR_Word *old_trace_curfr; do_init_modules(); MR_dump_stack_record_init(include_contexts); @@ -132,7 +132,7 @@ MR_dump_stack_from_layout(FILE *fp, const MR_Stack_Layout_Label *label_layout, const MR_Stack_Layout_Label * MR_find_nth_ancestor(const MR_Stack_Layout_Label *label_layout, - int ancestor_level, Word **stack_trace_sp, Word **stack_trace_curfr, + int ancestor_level, MR_Word **stack_trace_sp, MR_Word **stack_trace_curfr, const char **problem) { MR_Stack_Walk_Step_Result result; @@ -169,7 +169,7 @@ MR_find_nth_ancestor(const MR_Stack_Layout_Label *label_layout, MR_Stack_Walk_Step_Result MR_stack_walk_step(const MR_Stack_Layout_Entry *entry_layout, const MR_Stack_Layout_Label **return_label_layout, - Word **stack_trace_sp_ptr, Word **stack_trace_curfr_ptr, + MR_Word **stack_trace_sp_ptr, MR_Word **stack_trace_curfr_ptr, const char **problem_ptr) { MR_Internal *label; @@ -177,7 +177,7 @@ MR_stack_walk_step(const MR_Stack_Layout_Entry *entry_layout, MR_Long_Lval_Type type; int number; int determinism; - Code *success; + MR_Code *success; *return_label_layout = NULL; @@ -202,7 +202,7 @@ MR_stack_walk_step(const MR_Stack_Layout_Entry *entry_layout, return STEP_ERROR_AFTER; } - success = (Code *) MR_based_stackvar(*stack_trace_sp_ptr, + success = (MR_Code *) MR_based_stackvar(*stack_trace_sp_ptr, number); *stack_trace_sp_ptr = *stack_trace_sp_ptr - entry_layout->MR_sle_stack_slots; @@ -231,7 +231,7 @@ MR_stack_walk_step(const MR_Stack_Layout_Entry *entry_layout, } void -MR_dump_nondet_stack_from_layout(FILE *fp, Word *base_maxfr) +MR_dump_nondet_stack_from_layout(FILE *fp, MR_Word *base_maxfr) { int frame_size; @@ -289,8 +289,8 @@ MR_dump_nondet_stack_from_layout(FILE *fp, Word *base_maxfr) static const MR_Stack_Layout_Entry *prev_entry_layout; static int prev_entry_layout_count; static int prev_entry_start_level; -static Word *prev_entry_base_sp; -static Word *prev_entry_base_curfr; +static MR_Word *prev_entry_base_sp; +static MR_Word *prev_entry_base_curfr; static const char *prev_entry_filename; static int prev_entry_linenumber; static bool prev_entry_context_mismatch; @@ -309,7 +309,7 @@ MR_dump_stack_record_init(bool include_contexts) static void MR_dump_stack_record_frame(FILE *fp, const MR_Stack_Layout_Label *label_layout, - Word *base_sp, Word *base_curfr, + MR_Word *base_sp, MR_Word *base_curfr, MR_Print_Stack_Record print_stack_record) { const MR_Stack_Layout_Entry *entry_layout; @@ -383,7 +383,7 @@ MR_dump_stack_record_flush(FILE *fp, MR_Print_Stack_Record print_stack_record) void MR_dump_stack_record_print(FILE *fp, const MR_Stack_Layout_Entry *entry_layout, - int count, int start_level, Word *base_sp, Word *base_curfr, + int count, int start_level, MR_Word *base_sp, MR_Word *base_curfr, const char *filename, int linenumber, bool context_mismatch) { fprintf(fp, "%4d ", start_level); @@ -441,13 +441,13 @@ MR_find_context(const MR_Stack_Layout_Label *label, const char **fileptr, void MR_print_call_trace_info(FILE *fp, const MR_Stack_Layout_Entry *entry, - Word *base_sp, Word *base_curfr) + MR_Word *base_sp, MR_Word *base_curfr) { bool print_details; if (base_sp != NULL && base_curfr != NULL) { if (MR_ENTRY_LAYOUT_HAS_EXEC_TRACE(entry)) { - Integer maybe_from_full = + MR_Integer maybe_from_full = entry->MR_sle_maybe_from_full; if (maybe_from_full > 0) { /* @@ -550,7 +550,7 @@ MR_print_proc_id(FILE *fp, const MR_Stack_Layout_Entry *entry) void MR_print_proc_id_trace_and_context(FILE *fp, MR_Context_Position pos, - const MR_Stack_Layout_Entry *entry, Word *base_sp, Word *base_curfr, + const MR_Stack_Layout_Entry *entry, MR_Word *base_sp, MR_Word *base_curfr, const char *path, const char *filename, int lineno, bool print_parent, const char *parent_filename, int parent_lineno, int indent) { diff --git a/runtime/mercury_stack_trace.h b/runtime/mercury_stack_trace.h index 5409e6ca0..5f1b0225e 100644 --- a/runtime/mercury_stack_trace.h +++ b/runtime/mercury_stack_trace.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1998-1999 The University of Melbourne. +** Copyright (C) 1998-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -40,8 +40,8 @@ ** using `:- external'. */ -extern void MR_dump_stack(Code *success_pointer, Word *det_stack_pointer, - Word *current_frame, bool include_trace_data); +extern void MR_dump_stack(MR_Code *success_pointer, MR_Word *det_stack_pointer, + MR_Word *current_frame, bool include_trace_data); /* ** MR_dump_stack_from_layout: @@ -59,13 +59,13 @@ extern void MR_dump_stack(Code *success_pointer, Word *det_stack_pointer, typedef void (*MR_Print_Stack_Record)(FILE *fp, const MR_Stack_Layout_Entry * proc_layout, int count, int level, - Word *base_sp, Word * base_curfr, + MR_Word *base_sp, MR_Word * base_curfr, const char *filename, int linenumber, bool context_mismatch); extern const char *MR_dump_stack_from_layout(FILE *fp, const MR_Stack_Layout_Label *label_layout, - Word *det_stack_pointer, Word *current_frame, + MR_Word *det_stack_pointer, MR_Word *current_frame, bool include_trace_data, bool include_contexts, MR_Print_Stack_Record print_stack_record); @@ -77,7 +77,7 @@ extern const char *MR_dump_stack_from_layout(FILE *fp, ** The value of maxfr should be in *base_maxfr. */ -extern void MR_dump_nondet_stack_from_layout(FILE *fp, Word *base_maxfr); +extern void MR_dump_nondet_stack_from_layout(FILE *fp, MR_Word *base_maxfr); /* ** MR_find_nth_ancestor: @@ -96,8 +96,8 @@ extern void MR_dump_nondet_stack_from_layout(FILE *fp, Word *base_maxfr); extern const MR_Stack_Layout_Label *MR_find_nth_ancestor( const MR_Stack_Layout_Label *label_layout, - int ancestor_level, Word **stack_trace_sp, - Word **stack_trace_curfr, const char **problem); + int ancestor_level, MR_Word **stack_trace_sp, + MR_Word **stack_trace_curfr, const char **problem); /* ** MR_stack_walk_step: @@ -126,7 +126,7 @@ typedef enum { extern MR_Stack_Walk_Step_Result MR_stack_walk_step(const MR_Stack_Layout_Entry *entry_layout, const MR_Stack_Layout_Label **return_label_layout, - Word **stack_trace_sp_ptr, Word **stack_trace_curfr_ptr, + MR_Word **stack_trace_sp_ptr, MR_Word **stack_trace_curfr_ptr, const char **problem_ptr); /* @@ -135,7 +135,7 @@ MR_stack_walk_step(const MR_Stack_Layout_Entry *entry_layout, ** reach a stack frame whose saved succip slot contains this address. */ -extern Code *MR_stack_trace_bottom; +extern MR_Code *MR_stack_trace_bottom; /* ** MR_nondet_stack_trace_bottom should be set to the address of the buffer @@ -144,7 +144,7 @@ extern Code *MR_stack_trace_bottom; ** the redoip and redofr slots of this frame may be hijacked. */ -extern Word *MR_nondet_stack_trace_bottom; +extern MR_Word *MR_nondet_stack_trace_bottom; /* ** The different Mercury determinisms are internally represented by integers. @@ -173,7 +173,7 @@ extern bool MR_find_context(const MR_Stack_Layout_Label *label, extern void MR_print_call_trace_info(FILE *fp, const MR_Stack_Layout_Entry *entry, - Word *base_sp, Word *base_curfr); + MR_Word *base_sp, MR_Word *base_curfr); /* ** MR_print_proc_id prints an identification of the given procedure, @@ -202,7 +202,7 @@ typedef enum { extern void MR_print_proc_id_trace_and_context(FILE *fp, MR_Context_Position pos, const MR_Stack_Layout_Entry *entry, - Word *base_sp, Word *base_curfr, const char *path, + MR_Word *base_sp, MR_Word *base_curfr, const char *path, const char *filename, int lineno, bool print_parent, const char *parent_filename, int parent_lineno, int indent); @@ -213,7 +213,7 @@ extern void MR_print_proc_id_trace_and_context(FILE *fp, extern void MR_dump_stack_record_print(FILE *fp, const MR_Stack_Layout_Entry *entry_layout, int count, - int start_level, Word *base_sp, Word *base_curfr, + int start_level, MR_Word *base_sp, MR_Word *base_curfr, const char *filename, int linenumber, bool context_mismatch); diff --git a/runtime/mercury_stacks.c b/runtime/mercury_stacks.c index 90bc8d38e..7a96492d7 100644 --- a/runtime/mercury_stacks.c +++ b/runtime/mercury_stacks.c @@ -34,11 +34,11 @@ #ifdef MR_USE_MINIMAL_MODEL -static void MR_print_gen_stack_entry(FILE *fp, Integer i); +static void MR_print_gen_stack_entry(FILE *fp, MR_Integer i); static void MR_cleanup_generator_ptr(MR_TrieNode generator_ptr); void -MR_push_generator(Word *frame_addr, MR_TrieNode table_addr) +MR_push_generator(MR_Word *frame_addr, MR_TrieNode table_addr) { MR_gen_stack[MR_gen_next].generator_frame = frame_addr; MR_gen_stack[MR_gen_next].generator_table = table_addr; @@ -93,7 +93,7 @@ MR_print_gen_stack(FILE *fp) } static void -MR_print_gen_stack_entry(FILE *fp, Integer i) +MR_print_gen_stack_entry(FILE *fp, MR_Integer i) { #ifdef MR_TABLE_DEBUG if (MR_tabledebug) { diff --git a/runtime/mercury_stacks.h b/runtime/mercury_stacks.h index e51530b7f..45e4f81cd 100644 --- a/runtime/mercury_stacks.h +++ b/runtime/mercury_stacks.h @@ -68,7 +68,7 @@ #define MR_DETFR (-3) /* sp, in model_det temp frames only */ /* -** Code that traverses the nondet stack depends on the relationship +** MR_Code that traverses the nondet stack depends on the relationship ** MR_NONDET_TEMP_SIZE < MR_DET_TEMP_SIZE < MR_NONDET_FIXED_SIZE. ** All three sizes are measured in words. */ @@ -80,22 +80,22 @@ #define MR_SAVEVAL (-MR_NONDET_FIXED_SIZE) /* saved values start at this offset */ -#define MR_prevfr_addr(fr) (&((Word *) (fr))[MR_PREVFR]) -#define MR_redoip_addr(fr) (&((Word *) (fr))[MR_REDOIP]) -#define MR_redofr_addr(fr) (&((Word *) (fr))[MR_REDOFR]) -#define MR_succip_addr(fr) (&((Word *) (fr))[MR_SUCCIP]) -#define MR_succfr_addr(fr) (&((Word *) (fr))[MR_SUCCFR]) -#define MR_detfr_addr(fr) (&((Word *) (fr))[MR_DETFR]) +#define MR_prevfr_addr(fr) (&((MR_Word *) (fr))[MR_PREVFR]) +#define MR_redoip_addr(fr) (&((MR_Word *) (fr))[MR_REDOIP]) +#define MR_redofr_addr(fr) (&((MR_Word *) (fr))[MR_REDOFR]) +#define MR_succip_addr(fr) (&((MR_Word *) (fr))[MR_SUCCIP]) +#define MR_succfr_addr(fr) (&((MR_Word *) (fr))[MR_SUCCFR]) +#define MR_detfr_addr(fr) (&((MR_Word *) (fr))[MR_DETFR]) #define MR_based_framevar_addr(fr, n) \ - (&(((Word *) (fr))[MR_SAVEVAL + 1 - (n)])) + (&(((MR_Word *) (fr))[MR_SAVEVAL + 1 - (n)])) -#define MR_prevfr_slot(fr) LVALUE_CAST(Word *, ((Word *) (fr))[MR_PREVFR]) -#define MR_redoip_slot(fr) LVALUE_CAST(Code *, ((Word *) (fr))[MR_REDOIP]) -#define MR_redofr_slot(fr) LVALUE_CAST(Word *, ((Word *) (fr))[MR_REDOFR]) -#define MR_succip_slot(fr) LVALUE_CAST(Code *, ((Word *) (fr))[MR_SUCCIP]) -#define MR_succfr_slot(fr) LVALUE_CAST(Word *, ((Word *) (fr))[MR_SUCCFR]) -#define MR_detfr_slot(fr) LVALUE_CAST(Word *, ((Word *) (fr))[MR_DETFR]) -#define MR_based_framevar(fr, n) (((Word *) (fr))[MR_SAVEVAL + 1 - (n)]) +#define MR_prevfr_slot(fr) LVALUE_CAST(MR_Word *, ((MR_Word *) (fr))[MR_PREVFR]) +#define MR_redoip_slot(fr) LVALUE_CAST(MR_Code *, ((MR_Word *) (fr))[MR_REDOIP]) +#define MR_redofr_slot(fr) LVALUE_CAST(MR_Word *, ((MR_Word *) (fr))[MR_REDOFR]) +#define MR_succip_slot(fr) LVALUE_CAST(MR_Code *, ((MR_Word *) (fr))[MR_SUCCIP]) +#define MR_succfr_slot(fr) LVALUE_CAST(MR_Word *, ((MR_Word *) (fr))[MR_SUCCFR]) +#define MR_detfr_slot(fr) LVALUE_CAST(MR_Word *, ((MR_Word *) (fr))[MR_DETFR]) +#define MR_based_framevar(fr, n) (((MR_Word *) (fr))[MR_SAVEVAL + 1 - (n)]) #define MR_framevar(n) MR_based_framevar(MR_curfr, n) @@ -105,8 +105,8 @@ #define MR_mkframe(predname, numslots, redoip) \ do { \ - reg Word *prevfr; \ - reg Word *succfr; \ + reg MR_Word *prevfr; \ + reg MR_Word *succfr; \ \ prevfr = MR_maxfr; \ succfr = MR_curfr; \ @@ -122,14 +122,14 @@ } while (0) /* convert a size in bytes to a size in words, rounding up if necessary */ -#define MR_bytes_to_words(x) (((x) + sizeof(Word) - 1) / sizeof(Word)) +#define MR_bytes_to_words(x) (((x) + sizeof(MR_Word) - 1) / sizeof(MR_Word)) /* just like mkframe, but also reserves space for a struct */ /* with the given tag at the bottom of the nondet stack frame */ #define MR_mkpragmaframe(predname, numslots, structname, redoip) \ do { \ - reg Word *prevfr; \ - reg Word *succfr; \ + reg MR_Word *prevfr; \ + reg MR_Word *succfr; \ \ prevfr = MR_maxfr; \ succfr = MR_curfr; \ @@ -147,8 +147,8 @@ #define MR_mktempframe(redoip) \ do { \ - reg Word *prevfr; \ - reg Word *succfr; \ + reg MR_Word *prevfr; \ + reg MR_Word *succfr; \ \ prevfr = MR_maxfr; \ succfr = MR_curfr; \ @@ -161,8 +161,8 @@ #define MR_mkdettempframe(redoip) \ do { \ - reg Word *prevfr; \ - reg Word *succfr; \ + reg MR_Word *prevfr; \ + reg MR_Word *succfr; \ \ prevfr = MR_maxfr; \ succfr = MR_curfr; \ @@ -175,7 +175,7 @@ } while (0) #define MR_succeed() do { \ - reg Word *childfr; \ + reg MR_Word *childfr; \ \ debugsucceed(); \ childfr = MR_curfr; \ @@ -185,7 +185,7 @@ #define MR_succeed_discard() \ do { \ - reg Word *childfr; \ + reg MR_Word *childfr; \ \ debugsucceeddiscard(); \ childfr = MR_curfr; \ @@ -259,11 +259,11 @@ enum MR_HandlerCodeModel { typedef struct MR_Exception_Handler_Frame_struct { /* ** The `code_model' field is used to identify what kind of - ** handler it is. It holds values of type MR_HandlerCodeModel - ** (see above), but it is declared to have type `Word' to ensure + ** handler it is. It holds values of type MR_HandlerMR_CodeModel + ** (see above), but it is declared to have type `MR_Word' to ensure ** that everything remains word-aligned. */ - Word code_model; + MR_Word code_model; /* ** If code_model is MR_MODEL_*_HANDLER, then @@ -271,7 +271,7 @@ typedef struct MR_Exception_Handler_Frame_struct { ** which will be a closure of the specified determinism. ** If code_model is MR_C_LONGJMP, then this field is unused. */ - Word handler; + MR_Word handler; /* ** The remaining fields hold stuff that must be saved in order @@ -279,18 +279,18 @@ typedef struct MR_Exception_Handler_Frame_struct { */ /* the det stack pointer */ - Word *stack_ptr; + MR_Word *stack_ptr; /* the trail state */ MR_IF_USE_TRAIL( - Word trail_ptr; - Word ticket_counter; + MR_Word trail_ptr; + MR_Word ticket_counter; ) /* the heap state */ MR_IF_NOT_CONSERVATIVE_GC( - Word *heap_ptr; - Word *solns_heap_ptr; + MR_Word *heap_ptr; + MR_Word *solns_heap_ptr; MemoryZone *heap_zone; ) } MR_Exception_Handler_Frame; @@ -356,11 +356,11 @@ typedef struct MR_Exception_Handler_Frame_struct { /* DEFINITIONS FOR GENERATOR STACK FRAMES */ typedef struct MR_GeneratorStackFrameStruct { - Word *generator_frame; + MR_Word *generator_frame; MR_TrieNode generator_table; } MR_GeneratorStackFrame; -extern void MR_push_generator(Word *frame_addr, +extern void MR_push_generator(MR_Word *frame_addr, MR_TrieNode table_addr); extern MR_Subgoal *MR_top_generator_table(void); extern void MR_pop_generator(void); @@ -375,8 +375,8 @@ struct MR_CutGeneratorListNode { }; typedef struct MR_CutStackFrameStruct { - Word *frame; - Integer gen_next; + MR_Word *frame; + MR_Integer gen_next; MR_CutGeneratorList generators; } MR_CutStackFrame; diff --git a/runtime/mercury_string.h b/runtime/mercury_string.h index 12f463f9b..68986a4ad 100644 --- a/runtime/mercury_string.h +++ b/runtime/mercury_string.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1995-1999 The University of Melbourne. +** Copyright (C) 1995-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -14,10 +14,10 @@ #include "mercury_heap.h" /* for incr_hp_atomic */ /* -** Mercury characters are given type `Char', which is a typedef for `char'. -** But BEWARE: when stored in an Integer, the value must be -** first cast to `UnsignedChar'. -** Mercury strings are stored as pointers to '\0'-terminated arrays of Char. +** Mercury characters are given type `MR_Char', which is a typedef for `char'. +** But BEWARE: when stored in an MR_Integer, the value must be +** first cast to `MR_UnsignedChar'. +** Mercury strings are stored as pointers to '\0'-terminated arrays of MR_Char. ** ** We may eventually move to using wchar_t for Mercury characters and strings, ** so it is important to use these typedefs. @@ -25,27 +25,27 @@ ** The actual typedefs are in mercury_types.h to avoid problems with ** circular #includes. ** -** typedef char Char; -** typedef unsigned char UnsignedChar; +** typedef char MR_Char; +** typedef unsigned char MR_UnsignedChar; ** -** typedef Char *String; -** typedef const Char *ConstString; +** typedef MR_Char *MR_String; +** typedef const MR_Char *MR_ConstString; */ /* ** string_const("...", len): ** Given a C string literal and its length, returns a Mercury string. */ -#define MR_string_const(string, len) ((String) string) +#define MR_string_const(string, len) ((MR_String) string) /* -** bool string_equal(ConstString s1, ConstString s2): +** bool string_equal(MR_ConstString s1, MR_ConstString s2): ** Return true iff the two Mercury strings s1 and s2 are equal. */ #define MR_string_equal(s1,s2) (strcmp((char*)(s1),(char*)(s2))==0) /* -** void MR_make_aligned_string(ConstString & ptr, const char * string): +** void MR_make_aligned_string(MR_ConstString & ptr, const char * string): ** Given a C string `string', set `ptr' to be a Mercury string ** with the same contents. (`ptr' must be an lvalue.) ** If the resulting Mercury string is to be used by Mercury code, @@ -63,14 +63,14 @@ */ #define MR_make_aligned_string(ptr, string) \ do { \ - if (MR_tag((Word) (string)) != 0) { \ + if (MR_tag((MR_Word) (string)) != 0) { \ MR_make_aligned_string_copy((ptr), (string)); \ } else { \ (ptr) = (string); \ } \ } while(0) -/* void MR_make_aligned_string_copy(ConstString &ptr, const char * string); +/* void MR_make_aligned_string_copy(MR_ConstString &ptr, const char * string); ** Same as make_aligned_string(ptr, string), except that the string ** is guaranteed to be copied. This is useful for copying C strings ** onto the Mercury heap. @@ -82,11 +82,11 @@ */ #define MR_make_aligned_string_copy(ptr, string) \ do { \ - Word make_aligned_string_tmp; \ + MR_Word make_aligned_string_tmp; \ char * make_aligned_string_ptr; \ \ incr_hp_atomic(make_aligned_string_tmp, \ - (strlen(string) + sizeof(Word)) / sizeof(Word)); \ + (strlen(string) + sizeof(MR_Word)) / sizeof(MR_Word)); \ make_aligned_string_ptr = \ (char *) make_aligned_string_tmp; \ strcpy(make_aligned_string_ptr, (string)); \ @@ -94,7 +94,7 @@ } while(0) /* -** do_hash_string(int & hash, Word string): +** do_hash_string(int & hash, MR_Word string): ** Given a Mercury string `string', set `hash' to the hash value ** for that string. (`hash' must be an lvalue.) ** @@ -109,9 +109,9 @@ { \ int len = 0; \ hash = 0; \ - while(((const Char *)(s))[len]) { \ + while(((MR_ConstString)(s))[len]) { \ hash ^= (hash << 5); \ - hash ^= ((const Char *)(s))[len]; \ + hash ^= ((MR_ConstString)(s))[len]; \ len++; \ } \ hash ^= len; \ @@ -121,7 +121,7 @@ ** MR_hash_string(s): ** Given a Mercury string `s', return a hash value for that string. */ -int MR_hash_string(Word); +int MR_hash_string(MR_Word); #ifdef __GNUC__ #define MR_hash_string(s) \ diff --git a/runtime/mercury_tabling.c b/runtime/mercury_tabling.c index f5f8083aa..95f32adea 100644 --- a/runtime/mercury_tabling.c +++ b/runtime/mercury_tabling.c @@ -33,19 +33,19 @@ typedef struct MR_AllocRecord_Struct MR_AllocRecord; struct MR_IntHashTableSlot_Struct { MR_IntHashTableSlot *next; MR_TableNode data; - Integer key; + MR_Integer key; }; struct MR_FloatHashTableSlot_Struct { MR_FloatHashTableSlot *next; MR_TableNode data; - Float key; + MR_Float key; }; struct MR_StringHashTableSlot_Struct { MR_StringHashTableSlot *next; MR_TableNode data; - String key; + MR_String key; }; typedef union { @@ -103,12 +103,12 @@ struct MR_AllocRecord_Struct { */ struct MR_HashTable_Struct { - Integer size; - Integer threshold; - Integer value_count; + MR_Integer size; + MR_Integer threshold; + MR_Integer value_count; MR_HashTableSlotPtr *hash_table; MR_HashTableSlotPtr freespace; - Integer freeleft; + MR_Integer freeleft; MR_AllocRecord *allocrecord; }; @@ -121,22 +121,22 @@ struct MR_HashTable_Struct { */ #define NUM_OF_PRIMES 16 -static Word primes[NUM_OF_PRIMES] = +static MR_Word primes[NUM_OF_PRIMES] = {127, 257, 509, 1021, 2053, 4099, 8191, 16381, 32771, 65537, 131071, 262147, 524287, 1048573, 2097143, 4194301}; /* Initial size of a new table */ #define HASH_TABLE_START_SIZE primes[0] -static Integer next_prime(Integer); +static MR_Integer next_prime(MR_Integer); /* ** Return the next prime number greater than the number received. ** If no such prime number can be found, compute an approximate one. */ -static Integer -next_prime(Integer old_size) +static MR_Integer +next_prime(MR_Integer old_size) { int i; @@ -172,16 +172,16 @@ next_prime(Integer old_size) */ #ifdef MR_TABLE_STATISTICS -static Unsigned MR_table_hash_resizes = 0; -static Unsigned MR_table_hash_allocs = 0; -static Unsigned MR_table_hash_lookups = 0; -static Unsigned MR_table_hash_inserts = 0; -static Unsigned MR_table_hash_lookup_probes = 0; -static Unsigned MR_table_hash_insert_probes = 0; +static MR_Unsigned MR_table_hash_resizes = 0; +static MR_Unsigned MR_table_hash_allocs = 0; +static MR_Unsigned MR_table_hash_lookups = 0; +static MR_Unsigned MR_table_hash_inserts = 0; +static MR_Unsigned MR_table_hash_lookup_probes = 0; +static MR_Unsigned MR_table_hash_insert_probes = 0; #endif #ifdef MR_TABLE_STATISTICS - #define DECLARE_PROBE_COUNT Integer probe_count = 0; + #define DECLARE_PROBE_COUNT MR_Integer probe_count = 0; #define record_probe_count() do { probe_count++; } while (0) #define record_lookup_count() do { \ MR_table_hash_lookup_probes += \ @@ -262,13 +262,13 @@ static Unsigned MR_table_hash_insert_probes = 0; #define MR_CREATE_HASH_TABLE(table_ptr, table_type, table_field, table_size) \ do { \ - Word i; \ + MR_Word i; \ MR_HashTable *newtable; \ \ newtable = MR_TABLE_NEW(MR_HashTable); \ \ newtable->size = table_size; \ - newtable->threshold = (Integer) ((float) table_size \ + newtable->threshold = (MR_Integer) ((float) table_size \ * MAX_LOAD_FACTOR); \ newtable->value_count = 0; \ newtable->freespace.table_field = NULL; \ @@ -287,8 +287,8 @@ static Unsigned MR_table_hash_insert_probes = 0; #define MR_GENERIC_HASH_LOOKUP_OR_ADD \ MR_HashTable *table; \ table_type *slot; \ - Integer abs_hash; \ - Integer home; \ + MR_Integer abs_hash; \ + MR_Integer home; \ DECLARE_PROBE_COUNT \ \ debug_key_msg(key, key_format, key_cast); \ @@ -311,7 +311,7 @@ static Unsigned MR_table_hash_insert_probes = 0; table_type *next_slot; \ \ new_size = next_prime(table->size); \ - new_threshold = (Integer) ((float) new_size \ + new_threshold = (MR_Integer) ((float) new_size \ * MAX_LOAD_FACTOR); \ debug_resize_msg(table->size, new_size, new_threshold); \ record_resize_count(); \ @@ -402,7 +402,7 @@ static Unsigned MR_table_hash_insert_probes = 0; return &slot->data; MR_TrieNode -MR_int_hash_lookup_or_add(MR_TrieNode t, Integer key) +MR_int_hash_lookup_or_add(MR_TrieNode t, MR_Integer key) { #define key_format "%ld" #define key_cast long @@ -426,14 +426,14 @@ MR_GENERIC_HASH_LOOKUP_OR_ADD */ MR_TrieNode -MR_float_hash_lookup_or_add(MR_TrieNode t, Float key) +MR_float_hash_lookup_or_add(MR_TrieNode t, MR_Float key) { #define key_format "%f" #define key_cast double #define table_type MR_FloatHashTableSlot #define table_field float_slot_ptr #define hash(key) (hash_float(key)) -#define equal_keys(k1, k2) (memcmp(&(k1), &(k2), sizeof(Float)) == 0) +#define equal_keys(k1, k2) (memcmp(&(k1), &(k2), sizeof(MR_Float)) == 0) MR_GENERIC_HASH_LOOKUP_OR_ADD #undef key_format #undef key_cast @@ -445,13 +445,13 @@ MR_GENERIC_HASH_LOOKUP_OR_ADD } MR_TrieNode -MR_string_hash_lookup_or_add(MR_TrieNode t, String key) +MR_string_hash_lookup_or_add(MR_TrieNode t, MR_String key) { #define key_format "%s" #define key_cast char * #define table_type MR_StringHashTableSlot #define table_field string_slot_ptr -#define hash(key) (MR_hash_string((Word) key)) +#define hash(key) (MR_hash_string((MR_Word) key)) #define equal_keys(k1, k2) (strtest(k1, k2) == 0) MR_GENERIC_HASH_LOOKUP_OR_ADD #undef key_format @@ -472,7 +472,7 @@ MR_GENERIC_HASH_LOOKUP_OR_ADD */ MR_TrieNode -MR_int_fix_index_lookup_or_add(MR_TrieNode t, Integer range, Integer key) +MR_int_fix_index_lookup_or_add(MR_TrieNode t, MR_Integer range, MR_Integer key) { if (t->MR_fix_table == NULL) { t->MR_fix_table = MR_TABLE_NEW_ARRAY(MR_TableNode, range); @@ -501,9 +501,9 @@ MR_int_fix_index_lookup_or_add(MR_TrieNode t, Integer range, Integer key) #define MR_START_TABLE_INIT_SIZE 1024 MR_TrieNode -MR_int_start_index_lookup_or_add(MR_TrieNode table, Integer start, Integer key) +MR_int_start_index_lookup_or_add(MR_TrieNode table, MR_Integer start, MR_Integer key) { - Integer diff, size; + MR_Integer diff, size; diff = key - start; @@ -526,7 +526,7 @@ MR_int_start_index_lookup_or_add(MR_TrieNode table, Integer start, Integer key) if (diff >= size) { MR_TableNode *new_array; - Integer new_size, i; + MR_Integer new_size, i; new_size = max(2 * size, diff + 1); new_array = MR_TABLE_NEW_ARRAY(MR_TableNode, new_size + 1); @@ -562,7 +562,7 @@ MR_type_info_lookup_or_add(MR_TrieNode table, MR_TypeInfo type_info) type_info = MR_collapse_equivalences(type_info); type_ctor_info = MR_TYPEINFO_GET_TYPE_CTOR_INFO(type_info); - node = MR_int_hash_lookup_or_add(table, (Integer) type_ctor_info); + node = MR_int_hash_lookup_or_add(table, (MR_Integer) type_ctor_info); /* ** All calls to MR_type_info_lookup_or_add that have the same value @@ -593,7 +593,7 @@ MR_type_info_lookup_or_add(MR_TrieNode table, MR_TypeInfo type_info) } MR_TrieNode -MR_type_class_info_lookup_or_add(MR_TrieNode table, Word *type_class_info) +MR_type_class_info_lookup_or_add(MR_TrieNode table, MR_Word *type_class_info) { fatal_error("tabling of typeclass_infos not yet implemented"); return NULL; @@ -611,7 +611,7 @@ MR_type_class_info_lookup_or_add(MR_TrieNode table, Word *type_class_info) */ MR_TrieNode -MR_table_type(MR_TrieNode table, MR_TypeInfo type_info, Word data) +MR_table_type(MR_TrieNode table, MR_TypeInfo type_info, MR_Word data) { MR_TypeCtorInfo type_ctor_info; @@ -640,8 +640,8 @@ MR_table_type(MR_TrieNode table, MR_TypeInfo type_info, Word data) const MR_DuExistInfo *exist_info; MR_TypeInfo arg_type_info; int ptag; - Word sectag; - Word *arg_vector; + MR_Word sectag; + MR_Word *arg_vector; int meta_args; int i; @@ -651,7 +651,7 @@ MR_table_type(MR_TrieNode table, MR_TypeInfo type_info, Word data) switch (ptag_layout->MR_sectag_locn) { case MR_SECTAG_NONE: functor_desc = ptag_layout->MR_sectag_alternatives[0]; - arg_vector = (Word *) MR_body(data, ptag); + arg_vector = (MR_Word *) MR_body(data, ptag); break; case MR_SECTAG_LOCAL: sectag = MR_unmkbody(data); @@ -663,7 +663,7 @@ MR_table_type(MR_TrieNode table, MR_TypeInfo type_info, Word data) case MR_SECTAG_REMOTE: sectag = MR_field(ptag, data, 0); functor_desc = ptag_layout->MR_sectag_alternatives[sectag]; - arg_vector = (Word *) MR_body(data, ptag) + 1; + arg_vector = (MR_Word *) MR_body(data, ptag) + 1; break; default: fatal_error("MR_table_type(): unknown sectag_locn"); @@ -706,7 +706,7 @@ MR_table_type(MR_TrieNode table, MR_TypeInfo type_info, Word data) arg_type_info = MR_make_type_info_maybe_existq( MR_TYPEINFO_GET_FIRST_ORDER_ARG_VECTOR(type_info), functor_desc->MR_du_functor_arg_types[i], - (Word *) MR_body(data, ptag), + (MR_Word *) MR_body(data, ptag), functor_desc, &allocated_memory_cells); } else { arg_type_info = MR_pseudo_type_info_is_ground( @@ -783,7 +783,7 @@ MR_table_type(MR_TrieNode table, MR_TypeInfo type_info, Word data) break; case MR_TYPECTOR_REP_STRING: - MR_DEBUG_TABLE_STRING(table, (String) data); + MR_DEBUG_TABLE_STRING(table, (MR_String) data); break; case MR_TYPECTOR_REP_PRED: @@ -795,7 +795,7 @@ MR_table_type(MR_TrieNode table, MR_TypeInfo type_info, Word data) */ #if 0 MR_closure closure; - Word num_hidden_args; + MR_Word num_hidden_args; int i; closure = (MR_Closure *) data; @@ -818,9 +818,9 @@ MR_table_type(MR_TrieNode table, MR_TypeInfo type_info, Word data) case MR_TYPECTOR_REP_UNIV: { - Word *data_value; + MR_Word *data_value; - data_value = (Word *) data; + data_value = (MR_Word *) data; MR_DEBUG_TABLE_TYPEINFO(table, (MR_TypeInfo) data_value[UNIV_OFFSET_FOR_TYPEINFO]); MR_DEBUG_TABLE_ANY(table, @@ -850,7 +850,7 @@ MR_table_type(MR_TrieNode table, MR_TypeInfo type_info, Word data) MR_TypeInfo new_type_info; MR_MemoryList allocated_memory_cells = NULL; MR_ArrayType *array; - Integer array_size; + MR_Integer array_size; int i; array = (MR_ArrayType *) data; @@ -965,7 +965,7 @@ MR_table_report_statistics(FILE *fp) static void save_state(MR_SavedState *saved_state, - Word *generator_maxfr, Word *generator_sp, + MR_Word *generator_maxfr, MR_Word *generator_sp, const char *who, const char *what) { restore_transient_registers(); @@ -1236,14 +1236,14 @@ Declare_entry(mercury__table_nondet_resume_1_0); static void extend_consumer_stacks(MR_Subgoal *leader, MR_Consumer *suspension) { - Word *arena_block; - Word *arena_start; - Word arena_size; - Word extension_size; - Word *saved_fr; - Word *real_fr; - Word frame_size; - Word offset; + MR_Word *arena_block; + MR_Word *arena_start; + MR_Word arena_size; + MR_Word extension_size; + MR_Word *saved_fr; + MR_Word *real_fr; + MR_Word frame_size; + MR_Word offset; #ifdef MR_TABLE_DEBUG if (MR_tablestackdebug) { @@ -1341,7 +1341,7 @@ extend_consumer_stacks(MR_Subgoal *leader, MR_Consumer *suspension) if (saved_fr - frame_size > suspension->saved_state.non_stack_block) { - *MR_redoip_addr(saved_fr) = (Word) ENTRY(do_fail); + *MR_redoip_addr(saved_fr) = (MR_Word) ENTRY(do_fail); #ifdef MR_TABLE_DEBUG if (MR_tabledebug) { @@ -1353,7 +1353,7 @@ extend_consumer_stacks(MR_Subgoal *leader, MR_Consumer *suspension) } #endif } else { - *MR_redoip_addr(saved_fr) = (Word) + *MR_redoip_addr(saved_fr) = (MR_Word) ENTRY(mercury__table_nondet_resume_1_0); #ifdef MR_TABLE_DEBUG if (MR_tabledebug) { @@ -1454,13 +1454,13 @@ Define_entry(mercury__table_nondet_suspend_2_0); MR_Subgoal *subgoal; MR_Consumer *consumer; MR_ConsumerList listnode; - Integer cur_gen; - Integer cur_cut; - Word *fr; - Word *prev_fr; - Word *stop_addr; - Word offset; - Word *clobber_addr; + MR_Integer cur_gen; + MR_Integer cur_cut; + MR_Word *fr; + MR_Word *prev_fr; + MR_Word *stop_addr; + MR_Word offset; + MR_Word *clobber_addr; /* ** This frame is not used in table_nondet_suspend, but it is copied @@ -1509,7 +1509,7 @@ Define_entry(mercury__table_nondet_suspend_2_0); */ assert(MR_prevfr_slot(fr) == (stop_addr - 1)); - *clobber_addr = (Word) + *clobber_addr = (MR_Word) ENTRY(mercury__table_nondet_resume_1_0); #ifdef MR_TABLE_DEBUG if (MR_tablestackdebug) { @@ -1535,7 +1535,7 @@ Define_entry(mercury__table_nondet_suspend_2_0); assert(MR_prevfr_slot(fr) != (stop_addr - 1)); - *clobber_addr = (Word) ENTRY(do_fail); + *clobber_addr = (MR_Word) ENTRY(do_fail); #ifdef MR_TABLE_DEBUG if (MR_tablestackdebug) { printf("clobbering redoip " @@ -1555,7 +1555,7 @@ Define_entry(mercury__table_nondet_suspend_2_0); cur_gen--; } else if (cur_cut > 0 && fr == MR_cut_stack[cur_cut].frame) { - *clobber_addr = (Word) ENTRY(MR_table_nondet_commit); + *clobber_addr = (MR_Word) ENTRY(MR_table_nondet_commit); #ifdef MR_TABLE_DEBUG if (MR_tablestackdebug) { printf("committing redoip of frame at "); @@ -1566,7 +1566,7 @@ Define_entry(mercury__table_nondet_suspend_2_0); cur_cut--; } else { - *clobber_addr = (Word) ENTRY(do_fail); + *clobber_addr = (MR_Word) ENTRY(do_fail); #ifdef MR_TABLE_DEBUG if (MR_tablestackdebug) { printf("clobbering redoip of frame at "); @@ -1830,7 +1830,7 @@ Define_label(mercury__table_nondet_resume_1_0_LoopOverSuspensions); MR_redoip_slot(MR_maxfr) = LABEL(mercury__table_nondet_resume_1_0_RedoPoint); MR_redofr_slot(MR_maxfr) = MR_maxfr; - MR_based_framevar(MR_maxfr, 1) = (Word) MR_cur_leader; + MR_based_framevar(MR_maxfr, 1) = (MR_Word) MR_cur_leader; Define_label(mercury__table_nondet_resume_1_0_ReturnAnswer); @@ -1842,7 +1842,7 @@ Define_label(mercury__table_nondet_resume_1_0_ReturnAnswer); ** since will not have changed in the meantime. */ - r1 = (Word) &MR_cur_leader->resume_info->cur_consumer_answer_list-> + r1 = (MR_Word) &MR_cur_leader->resume_info->cur_consumer_answer_list-> answer_data; MR_cur_leader->resume_info->cur_consumer->remaining_answer_list_ptr = diff --git a/runtime/mercury_tabling.h b/runtime/mercury_tabling.h index fbcd73d3c..1f8957433 100644 --- a/runtime/mercury_tabling.h +++ b/runtime/mercury_tabling.h @@ -126,13 +126,13 @@ typedef MR_ConsumerListNode *MR_ConsumerList; */ union MR_TableNode_Union { - Integer MR_integer; + MR_Integer MR_integer; MR_HashTable *MR_hash_table; MR_TableNode *MR_fix_table; MR_TableNode *MR_start_table; - Unsigned MR_simpletable_status; + MR_Unsigned MR_simpletable_status; MR_Subgoal *MR_subgoal; - Word *MR_answerblock; + MR_Word *MR_answerblock; }; #define MR_SIMPLETABLE_UNINITIALIZED 0 @@ -147,7 +147,7 @@ typedef enum { } MR_SubgoalStatus; struct MR_AnswerListNode_Struct { - Integer answer_num; + MR_Integer answer_num; MR_TableNode answer_data; /* always uses the MR_answerblock member */ MR_AnswerList next_answer; }; @@ -182,19 +182,19 @@ struct MR_AnswerListNode_Struct { */ typedef struct { - Code *succ_ip; - Word *s_p; - Word *cur_fr; - Word *max_fr; - Word *non_stack_block_start; - Word non_stack_block_size; - Word *non_stack_block; - Word *det_stack_block_start; - Word det_stack_block_size; - Word *det_stack_block; - Integer gen_next; + MR_Code *succ_ip; + MR_Word *s_p; + MR_Word *cur_fr; + MR_Word *max_fr; + MR_Word *non_stack_block_start; + MR_Word non_stack_block_size; + MR_Word *non_stack_block; + MR_Word *det_stack_block_start; + MR_Word det_stack_block_size; + MR_Word *det_stack_block; + MR_Integer gen_next; char *generator_stack_block; - Integer cut_next; + MR_Integer cut_next; char *cut_stack_block; } MR_SavedState; @@ -236,11 +236,11 @@ struct MR_Subgoal_Struct { MR_SubgoalList followers; MR_SubgoalList *followers_tail; MR_ResumeInfo *resume_info; - Word answer_table; /* Table of answers returned */ + MR_Word answer_table; /* Table of answers returned */ /* by the subgoal */ - Integer num_ans; /* # of answers returned */ + MR_Integer num_ans; /* # of answers returned */ /* by the subgoal */ - Integer num_committed_ans; + MR_Integer num_committed_ans; /* # of answers our leader */ /* is committed to returning */ /* to every consumer. */ @@ -254,10 +254,10 @@ struct MR_Subgoal_Struct { /* to the subgoal */ MR_ConsumerList *consumer_list_tail; /* As for answer_list_tail */ - Word *generator_maxfr; + MR_Word *generator_maxfr; /* MR_maxfr at the time of */ /* the call to the generator */ - Word *generator_sp; + MR_Word *generator_sp; /* MR_sp at the time of the */ /* call to the generator */ }; @@ -279,11 +279,11 @@ struct MR_Subgoal_Struct { */ extern MR_TrieNode MR_int_hash_lookup_or_add(MR_TrieNode table, - Integer key); + MR_Integer key); extern MR_TrieNode MR_float_hash_lookup_or_add(MR_TrieNode table, - Float key); + MR_Float key); extern MR_TrieNode MR_string_hash_lookup_or_add(MR_TrieNode table, - String key); + MR_String key); /* ** This function assumes that the table is a statically sized array, @@ -291,7 +291,7 @@ extern MR_TrieNode MR_string_hash_lookup_or_add(MR_TrieNode table, */ extern MR_TrieNode MR_int_fix_index_lookup_or_add(MR_TrieNode table, - Integer range, Integer key); + MR_Integer range, MR_Integer key); /* ** This function assumes that the table is an expandable array, @@ -299,7 +299,7 @@ extern MR_TrieNode MR_int_fix_index_lookup_or_add(MR_TrieNode table, */ extern MR_TrieNode MR_int_start_index_lookup_or_add(MR_TrieNode table, - Integer start, Integer key); + MR_Integer start, MR_Integer key); /* ** This function tables type_infos in a hash table. @@ -313,7 +313,7 @@ extern MR_TrieNode MR_type_info_lookup_or_add(MR_TrieNode table, */ extern MR_TrieNode MR_type_class_info_lookup_or_add(MR_TrieNode table, - Word *type_class_info); + MR_Word *type_class_info); /* ** This function tables values of arbitrary types; the form of the data @@ -321,7 +321,7 @@ extern MR_TrieNode MR_type_class_info_lookup_or_add(MR_TrieNode table, */ extern MR_TrieNode MR_table_type(MR_TrieNode table, - MR_TypeInfo type_info, Word data_value); + MR_TypeInfo type_info, MR_Word data_value); /* ** This function prints statistics about the operation of tabling, if the @@ -350,10 +350,10 @@ extern void MR_table_report_statistics(FILE *fp); MR_GC_realloc((pointer), (size)) #define table_allocate_words(size) \ - MR_GC_malloc(sizeof(Word) * (size)) + MR_GC_malloc(sizeof(MR_Word) * (size)) #define table_reallocate_words(pointer, size) \ - MR_GC_realloc((pointer), sizeof(Word) * (size)) + MR_GC_realloc((pointer), sizeof(MR_Word) * (size)) #define table_free(pointer) \ MR_GC_free((pointer)) @@ -388,7 +388,7 @@ extern void MR_table_report_statistics(FILE *fp); fatal_error("Sorry, not implemented: tabling in native gc grades") #define MR_table_list_cons(h, t) \ (fatal_error("Sorry, not implemented: tabling in native gc grades"), \ - (Word) 0) + (MR_Word) 0) #endif /* NATIVE_GC */ @@ -396,7 +396,7 @@ extern void MR_table_report_statistics(FILE *fp); MR_memcpy((dest), (source), (size)) #define table_copy_words(dest, source, size) \ - MR_memcpy((char *) (dest), (char *) (source), sizeof(Word) * (size)) + MR_memcpy((char *) (dest), (char *) (source), sizeof(MR_Word) * (size)) /*---------------------------------------------------------------------------*/ diff --git a/runtime/mercury_tabling_macros.h b/runtime/mercury_tabling_macros.h index bede40135..6b7c2ab71 100644 --- a/runtime/mercury_tabling_macros.h +++ b/runtime/mercury_tabling_macros.h @@ -333,7 +333,7 @@ #define MR_TABLE_CREATE_ANSWER_BLOCK(table, num_slots) \ do { \ - (table)->MR_answerblock = MR_TABLE_NEW_ARRAY(Word, \ + (table)->MR_answerblock = MR_TABLE_NEW_ARRAY(MR_Word, \ (num_slots)); \ if (MR_tabledebug) \ printf("allocated answer block %p -> %p, %d words\n",\ @@ -354,7 +354,7 @@ #define MR_TABLE_CREATE_ANSWER_BLOCK(table, num_slots) \ do { \ - (table)->MR_answerblock = MR_TABLE_NEW_ARRAY(Word, \ + (table)->MR_answerblock = MR_TABLE_NEW_ARRAY(MR_Word, \ (num_slots)); \ } while(0) diff --git a/runtime/mercury_tags.h b/runtime/mercury_tags.h index 4b65b4ff5..a9ba3af81 100644 --- a/runtime/mercury_tags.h +++ b/runtime/mercury_tags.h @@ -1,5 +1,5 @@ /* -** Copyright (C) 1993-1999 The University of Melbourne. +** Copyright (C) 1993-2000 The University of Melbourne. ** This file may only be copied under the terms of the GNU Library General ** Public License - see the file COPYING.LIB in the Mercury distribution. */ @@ -14,11 +14,11 @@ #include /* for `CHAR_BIT' */ #include "mercury_conf.h" /* for `LOW_TAG_BITS' */ -#include "mercury_types.h" /* for `Word' */ +#include "mercury_types.h" /* for `MR_Word' */ /* DEFINITIONS FOR WORD LAYOUT */ -#define MR_WORDBITS (CHAR_BIT * sizeof(Word)) +#define MR_WORDBITS (CHAR_BIT * sizeof(MR_Word)) /* TAGBITS specifies the number of bits in each word that we can use for tags */ #ifndef TAGBITS @@ -35,13 +35,13 @@ #ifdef HIGHTAGS -#define MR_mktag(t) ((Word)(t) << (WORDBITS - TAGBITS)) -#define MR_unmktag(w) ((Word)(w) >> (WORDBITS - TAGBITS)) -#define MR_tag(w) ((w) & ~(~(Word)0 >> TAGBITS)) +#define MR_mktag(t) ((MR_Word)(t) << (WORDBITS - TAGBITS)) +#define MR_unmktag(w) ((MR_Word)(w) >> (WORDBITS - TAGBITS)) +#define MR_tag(w) ((w) & ~(~(MR_Word)0 >> TAGBITS)) #define MR_mkbody(i) (i) #define MR_unmkbody(w) (w) -#define MR_body(w, t) ((w) & (~(Word)0 >> TAGBITS)) -#define MR_strip_tag(w) ((w) & (~(Word)0 >> TAGBITS)) +#define MR_body(w, t) ((w) & (~(MR_Word)0 >> TAGBITS)) +#define MR_strip_tag(w) ((w) & (~(MR_Word)0 >> TAGBITS)) #else /* ! HIGHTAGS */ @@ -49,28 +49,28 @@ #define MR_unmktag(w) (w) #define MR_tag(w) ((w) & ((1 << TAGBITS) - 1)) #define MR_mkbody(i) ((i) << TAGBITS) -#define MR_unmkbody(w) ((Word) (w) >> TAGBITS) -#define MR_body(w, t) ((Word) (w) - (t)) -#define MR_strip_tag(w) ((w) & (~(Word)0 << TAGBITS)) +#define MR_unmkbody(w) ((MR_Word) (w) >> TAGBITS) +#define MR_body(w, t) ((MR_Word) (w) - (t)) +#define MR_strip_tag(w) ((w) & (~(MR_Word)0 << TAGBITS)) #endif /* ! HIGHTAGS */ /* -** the result of MR_mkword() is cast to (Word *), not to (Word) +** the result of MR_mkword() is cast to (MR_Word *), not to (MR_Word) ** because MR_mkword() may be used in initializers for static constants ** and casts from pointers to integral types are not valid -** constant-expressions in ANSI C. It cannot be (const Word *) because +** constant-expressions in ANSI C. It cannot be (const MR_Word *) because ** some ANSI C compilers won't allow assignments where the RHS is of type ** const and the LHS is not declared const. */ -#define MR_mkword(t, p) ((Word *)((char *)(p) + (t))) +#define MR_mkword(t, p) ((MR_Word *)((char *)(p) + (t))) -#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_field(t, p, i) ((MR_Word *) MR_body((p), (t)))[i] +#define MR_const_field(t, p, i) ((const MR_Word *) MR_body((p), (t)))[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] +#define MR_mask_field(p, i) ((MR_Word *) MR_strip_tag(p))[i] +#define MR_const_mask_field(p, i) ((const MR_Word *) MR_strip_tag(p))[i] /* ** the following MR_list_* macros are used by handwritten C code @@ -89,13 +89,13 @@ #define MR_list_is_empty(list) (MR_tag(list) == MR_TAG_NIL) #define MR_list_head(list) MR_field(MR_TAG_CONS, (list), 0) #define MR_list_tail(list) MR_field(MR_TAG_CONS, (list), 1) -#define MR_list_empty() ((Word) MR_mkword(MR_TAG_NIL, MR_mkbody(0))) -#define MR_list_cons(head,tail) ((Word) MR_mkword(MR_TAG_CONS, \ +#define MR_list_empty() ((MR_Word) MR_mkword(MR_TAG_NIL, MR_mkbody(0))) +#define MR_list_cons(head,tail) ((MR_Word) MR_mkword(MR_TAG_CONS, \ create2((head),(tail)))) #define MR_list_empty_msg(proclabel) \ - ((Word) MR_mkword(MR_TAG_NIL, MR_mkbody(0))) + ((MR_Word) MR_mkword(MR_TAG_NIL, MR_mkbody(0))) #define MR_list_cons_msg(head,tail,proclabel) \ - ((Word) MR_mkword(MR_TAG_CONS, \ + ((MR_Word) MR_mkword(MR_TAG_CONS, \ MR_create2_msg((head),(tail), \ proclabel, "list:list/1"))) @@ -105,17 +105,17 @@ == MR_RAW_TAG_NIL) #define MR_list_head(list) MR_field(MR_mktag(0), (list), 1) #define MR_list_tail(list) MR_field(MR_mktag(0), (list), 2) -#define MR_list_empty() ((Word) MR_mkword(MR_mktag(0), \ +#define MR_list_empty() ((MR_Word) MR_mkword(MR_mktag(0), \ create1(MR_RAW_TAG_NIL))) -#define MR_list_cons(head,tail) ((Word) MR_mkword(MR_mktag(0), \ +#define MR_list_cons(head,tail) ((MR_Word) MR_mkword(MR_mktag(0), \ create3(MR_RAW_TAG_CONS, \ (head), (tail)))) #define MR_list_empty_msg(proclabel) \ - ((Word) MR_mkword(MR_mktag(0), \ + ((MR_Word) MR_mkword(MR_mktag(0), \ MR_create1_msg(MR_RAW_TAG_NIL, \ proclabel, "list:list/1"))) #define MR_list_cons_msg(head,tail,proclabel) \ - ((Word) MR_mkword(MR_mktag(0), \ + ((MR_Word) MR_mkword(MR_mktag(0), \ MR_create3_msg(MR_RAW_TAG_CONS, \ (head), (tail), \ proclabel, "list:list/1"))) diff --git a/runtime/mercury_trace_base.c b/runtime/mercury_trace_base.c index 505a20b4a..205b8771b 100644 --- a/runtime/mercury_trace_base.c +++ b/runtime/mercury_trace_base.c @@ -69,8 +69,8 @@ bool MR_trace_enabled = FALSE; ** variables. */ -Unsigned MR_trace_call_seqno = 0; -Unsigned MR_trace_call_depth = 0; +MR_Unsigned MR_trace_call_seqno = 0; +MR_Unsigned MR_trace_call_depth = 0; /* ** MR_trace_event_number is a simple counter of events. This is used in @@ -79,7 +79,7 @@ Unsigned MR_trace_call_depth = 0; ** can zero in on the source of the problem more quickly. */ -Unsigned MR_trace_event_number = 0; +MR_Unsigned MR_trace_event_number = 0; /* ** MR_trace_from_full is a boolean that is set before every call; @@ -94,7 +94,7 @@ Unsigned MR_trace_event_number = 0; ** control in the debugger when main/2 is called. */ -Bool MR_trace_from_full = TRUE; +MR_Bool MR_trace_from_full = TRUE; #ifdef MR_TRACE_HISTOGRAM @@ -126,7 +126,7 @@ const char *MR_port_names[] = "LATR", }; -Code * +MR_Code * MR_trace(const MR_Stack_Layout_Label *layout) { if (! MR_trace_enabled) { @@ -151,7 +151,7 @@ MR_tracing_not_enabled(void) "Mercury User's Guide.\n"); } -Code * +MR_Code * MR_trace_fake(const MR_Stack_Layout_Label *layout) { MR_tracing_not_enabled(); @@ -230,7 +230,7 @@ MR_trace_start(bool enabled) MR_trace_handler == MR_TRACE_INTERNAL) { MR_setup_signal(SIGINT, - (Code *) MR_address_of_trace_interrupt_handler, + (MR_Code *) MR_address_of_trace_interrupt_handler, FALSE, "mdb: cannot install SIGINT signal handler"); } } @@ -299,15 +299,15 @@ MR_trace_report_raw(int fd) } } -static Word MR_trace_exception_value = (Word) NULL; +static MR_Word MR_trace_exception_value = (MR_Word) NULL; void -MR_trace_set_exception_value(Word exception) +MR_trace_set_exception_value(MR_Word exception) { MR_trace_exception_value = exception; } -Word +MR_Word MR_trace_get_exception_value(void) { return MR_trace_exception_value; @@ -349,7 +349,7 @@ Define_entry(MR_do_trace_redo_fail_shallow); */ if (MR_redo_fromfull_framevar(MR_redofr_slot(MR_curfr))) { - Code *MR_jumpaddr; + MR_Code *MR_jumpaddr; save_transient_registers(); MR_jumpaddr = MR_trace((const MR_Stack_Layout_Label *) MR_redo_layout_framevar(MR_redofr_slot(MR_curfr))); @@ -375,7 +375,7 @@ Define_entry(MR_do_trace_redo_fail_deep); ** the code in library/exception.m similarly. */ { - Code *MR_jumpaddr; + MR_Code *MR_jumpaddr; save_transient_registers(); MR_jumpaddr = MR_trace((const MR_Stack_Layout_Label *) MR_redo_layout_framevar(MR_redofr_slot(MR_curfr))); diff --git a/runtime/mercury_trace_base.h b/runtime/mercury_trace_base.h index eb3fe4936..fcf5fb280 100644 --- a/runtime/mercury_trace_base.h +++ b/runtime/mercury_trace_base.h @@ -46,9 +46,9 @@ typedef enum { extern const char *MR_port_names[]; -#define MR_trace_incr_seq() ((Word) ++MR_trace_call_seqno) -#define MR_trace_incr_depth() ((Word) ++MR_trace_call_depth) -#define MR_trace_reset_depth(d) (MR_trace_call_depth = (Unsigned) (d)) +#define MR_trace_incr_seq() ((MR_Word) ++MR_trace_call_seqno) +#define MR_trace_incr_depth() ((MR_Word) ++MR_trace_call_depth) +#define MR_trace_reset_depth(d) (MR_trace_call_depth = (MR_Unsigned) (d)) /* ** MR_trace is called from Mercury modules compiled with tracing. @@ -61,8 +61,8 @@ extern const char *MR_port_names[]; ** after the event. (NULL means it should continue as usual.) */ -extern Code *MR_trace(const MR_Stack_Layout_Label *); -extern Code *MR_trace_fake(const MR_Stack_Layout_Label *); +extern MR_Code *MR_trace(const MR_Stack_Layout_Label *); +extern MR_Code *MR_trace_fake(const MR_Stack_Layout_Label *); /* ** MR_trace_init() is called from mercury_runtime_init() @@ -97,8 +97,8 @@ extern void MR_trace_final(void); ** XXX They should probably be in MercuryEngine. */ -extern Unsigned MR_trace_call_seqno; -extern Unsigned MR_trace_call_depth; +extern MR_Unsigned MR_trace_call_seqno; +extern MR_Unsigned MR_trace_call_depth; typedef enum { MR_TRACE_INTERNAL, @@ -108,8 +108,8 @@ typedef enum { extern MR_Trace_Type MR_trace_handler; extern bool MR_trace_enabled; -extern Unsigned MR_trace_event_number; -extern Bool MR_trace_from_full; +extern MR_Unsigned MR_trace_event_number; +extern MR_Bool MR_trace_from_full; /* ** These functions will report the number of the last event, @@ -132,8 +132,8 @@ extern void MR_tracing_not_enabled(void); ** which exception has been thrown. */ -extern void MR_trace_set_exception_value(Word exception); -extern Word MR_trace_get_exception_value(void); +extern void MR_trace_set_exception_value(MR_Word exception); +extern MR_Word MR_trace_get_exception_value(void); /* ** If MR_TRACE_HISTOGRAM is defined, MR_trace maintains two arrays of integers, diff --git a/runtime/mercury_trail.c b/runtime/mercury_trail.c index 57158eacb..674eace18 100644 --- a/runtime/mercury_trail.c +++ b/runtime/mercury_trail.c @@ -22,8 +22,8 @@ MemoryZone *MR_trail_zone; MR_TrailEntry *MR_trail_ptr_var; -Unsigned MR_ticket_counter_var = 1; -Unsigned MR_ticket_high_water_var = 1; +MR_Unsigned MR_ticket_counter_var = 1; +MR_Unsigned MR_ticket_high_water_var = 1; void MR_untrail_to(MR_TrailEntry *old_trail_ptr, MR_untrail_reason reason) diff --git a/runtime/mercury_trail.h b/runtime/mercury_trail.h index 4e0fb8c7a..b3796974a 100644 --- a/runtime/mercury_trail.h +++ b/runtime/mercury_trail.h @@ -56,7 +56,7 @@ */ /*---------------------------------------------------------------------------*/ -/* void MR_mark_ticket_stack(Word &); */ +/* void MR_mark_ticket_stack(MR_Word &); */ #define MR_mark_ticket_stack(save_ticket_counter) \ do { \ (save_ticket_counter) = MR_ticket_counter; \ @@ -74,13 +74,13 @@ MR_ticket_high_water = --MR_ticket_counter; \ } while(0) -/* void MR_prune_tickets_to(Word); */ +/* void MR_prune_tickets_to(MR_Word); */ #define MR_prune_tickets_to(save_ticket_counter) \ do { \ MR_ticket_counter = (save_ticket_counter); \ } while(0) -/* void MR_discard_tickets_to(Word); */ +/* void MR_discard_tickets_to(MR_Word); */ #define MR_discard_tickets_to(save_ticket_counter) \ do { \ MR_ticket_high_water = MR_ticket_counter = \ @@ -91,10 +91,10 @@ ** Called when we create a choice point ** (including semidet choice points). */ -/* void MR_store_ticket(Word &); */ +/* void MR_store_ticket(MR_Word &); */ #define MR_store_ticket(save_trail_ptr) \ do { \ - (save_trail_ptr) = (Word) MR_trail_ptr; \ + (save_trail_ptr) = (MR_Word) MR_trail_ptr; \ MR_ticket_counter = ++MR_ticket_high_water; \ } while(0) @@ -106,7 +106,7 @@ ** transient registers are not needed because ** MR_trail_ptr is never a real register. */ -/* void MR_reset_ticket(Word, MR_untrail_reason); */ +/* void MR_reset_ticket(MR_Word, MR_untrail_reason); */ #define MR_reset_ticket(old, kind) \ do { \ MR_TrailEntry *old_trail_ptr = \ @@ -205,8 +205,8 @@ typedef struct { #endif union { struct { - Word *MR_address; - Word MR_value; + MR_Word *MR_address; + MR_Word MR_value; } MR_val; struct { MR_untrail_func_type *MR_untrail_func; @@ -229,13 +229,13 @@ typedef struct { */ #define MR_get_trail_entry_kind(entry) \ ((MR_trail_entry_kind) \ - (MR_tag((Word) (entry)->MR_union.MR_val.MR_address))) + (MR_tag((MR_Word) (entry)->MR_union.MR_val.MR_address))) /* - ** Word * MR_get_trail_entry_address(const MR_trail_entry *); + ** MR_Word * MR_get_trail_entry_address(const MR_trail_entry *); */ #define MR_get_trail_entry_address(entry) \ - ((Word *) \ + ((MR_Word *) \ MR_body((entry)->MR_union.MR_val.MR_address, MR_value_trail_tag)) /* @@ -244,17 +244,17 @@ typedef struct { */ #define MR_get_trail_entry_untrail_func(entry) \ ((MR_untrail_func_type *) \ - MR_body((Word) (entry)->MR_union.MR_func.MR_untrail_func, \ + MR_body((MR_Word) (entry)->MR_union.MR_func.MR_untrail_func, \ MR_func_trail_tag)) /* ** void MR_store_value_trail_entry( - ** MR_trail_entry *entry, Word *address, Word value); + ** MR_trail_entry *entry, MR_Word *address, MR_Word value); */ #define MR_store_value_trail_entry(entry, address, value) \ do { \ (entry)->MR_union.MR_val.MR_address = \ - (Word *) (Word) \ + (MR_Word *) (MR_Word) \ MR_mkword(MR_value_trail_tag, (address)); \ (entry)->MR_union.MR_val.MR_value = (value); \ } while (0) @@ -266,7 +266,7 @@ typedef struct { #define MR_store_function_trail_entry(entry, func, datum) \ do { \ (entry)->MR_union.MR_func.MR_untrail_func = \ - (MR_untrail_func_type *) (Word) \ + (MR_untrail_func_type *) (MR_Word) \ MR_mkword(MR_func_trail_tag, (func)); \ (entry)->MR_union.MR_func.MR_datum = (datum); \ } while (0) @@ -281,7 +281,7 @@ typedef struct { /* ** void MR_store_value_trail_entry( - ** MR_trail_entry *entry, Word *address, Word value); + ** MR_trail_entry *entry, MR_Word *address, MR_Word value); */ #define MR_store_value_trail_entry(entry, address, value) \ do { \ @@ -303,7 +303,7 @@ typedef struct { #endif /* -** Word MR_get_trail_entry_value(const MR_trail_entry *); +** MR_Word MR_get_trail_entry_value(const MR_trail_entry *); */ #define MR_get_trail_entry_value(entry) \ ((entry)->MR_union.MR_val.MR_value) @@ -333,7 +333,7 @@ extern MR_TrailEntry *MR_trail_ptr_var; ** N.B. Use `MR_ticket_counter', defined in mercury_regorder.h, ** not `MR_ticket_counter_var'. */ -extern Unsigned MR_ticket_counter_var; +extern MR_Unsigned MR_ticket_counter_var; /* ** An integer variable that is incremented whenever we create a choice @@ -345,7 +345,7 @@ extern Unsigned MR_ticket_counter_var; ** N.B. Use `MR_ticket_high_water', defined in mercury_regorder.h, ** not `MR_ticket_high_water_var'. */ -extern Unsigned MR_ticket_high_water_var; +extern MR_Unsigned MR_ticket_high_water_var; /*---------------------------------------------------------------------------*/ /* @@ -358,7 +358,7 @@ extern Unsigned MR_ticket_high_water_var; /*---------------------------------------------------------------------------*/ /* -** void MR_trail_value(Word *address, Word value); +** void MR_trail_value(MR_Word *address, MR_Word value); ** ** Make sure that when the current execution is ** backtracked over, `value' is placed in `address'. @@ -371,7 +371,7 @@ extern Unsigned MR_ticket_high_water_var; } while(0); /* -** void MR_trail_current_value(Word *address); +** void MR_trail_current_value(MR_Word *address); ** ** Make sure that when the current execution is ** backtracked over, the value currently in `address' @@ -404,7 +404,7 @@ extern Unsigned MR_ticket_high_water_var; void MR_untrail_to(MR_TrailEntry *old_trail_ptr, MR_untrail_reason reason); /* abstract type */ -typedef Unsigned MR_ChoicepointId; +typedef MR_Unsigned MR_ChoicepointId; /* ** MR_ChoicepointId MR_current_choicepoint_id(void); diff --git a/runtime/mercury_type_info.c b/runtime/mercury_type_info.c index 69d0544ff..3e2afe0a9 100644 --- a/runtime/mercury_type_info.c +++ b/runtime/mercury_type_info.c @@ -22,7 +22,7 @@ static MR_TypeInfo MR_get_arg_type_info(const MR_TypeInfoParams type_info_params, - const MR_PseudoTypeInfo pseudo_type_info, const Word *data_value, + const MR_PseudoTypeInfo pseudo_type_info, const MR_Word *data_value, const MR_DuFunctorDesc *functor_desc); /*---------------------------------------------------------------------------*/ @@ -35,7 +35,7 @@ MR_get_arg_type_info(const MR_TypeInfoParams type_info_params, #define ALLOCATE_WORDS(target, size) \ do { \ MR_MemoryList node; \ - (target) = MR_GC_NEW_ARRAY(Word, \ + (target) = MR_GC_NEW_ARRAY(MR_Word, \ (size)); \ node = MR_GC_malloc(sizeof(*node)); \ node->data = (target); \ @@ -57,7 +57,7 @@ MR_get_arg_type_info(const MR_TypeInfoParams type_info_params, #define MAYBE_DECLARE_ALLOC_ARG #define MAYBE_PASS_ALLOC_ARG #define ALLOCATE_WORDS(target, size) \ - incr_saved_hp(LVALUE_CAST(Word, (target)), \ + incr_saved_hp(LVALUE_CAST(MR_Word, (target)), \ (size)) #include "mercury_make_type_info_body.h" #undef usual_func @@ -69,17 +69,17 @@ MR_get_arg_type_info(const MR_TypeInfoParams type_info_params, static MR_TypeInfo MR_get_arg_type_info(const MR_TypeInfoParams type_info_params, - const MR_PseudoTypeInfo pseudo_type_info, const Word *data_value, + const MR_PseudoTypeInfo pseudo_type_info, const MR_Word *data_value, const MR_DuFunctorDesc *functor_desc) { - Unsigned arg_num; + MR_Unsigned arg_num; const MR_DuExistInfo *exist_info; MR_DuExistLocn exist_locn; int exist_varnum; int slot; int offset; - arg_num = (Unsigned) pseudo_type_info; + arg_num = (MR_Unsigned) pseudo_type_info; if (MR_TYPE_VARIABLE_IS_UNIV_QUANT(pseudo_type_info)) { /* @@ -166,16 +166,16 @@ MR_compare_type_info(MR_TypeInfo t1, MR_TypeInfo t2) ** ANSI C doesn't guarantee much about pointer comparisons, ** so it is possible that this might not do the right thing ** on some obscure systems. - ** The casts to (Word) here are in the hope of increasing + ** The casts to (MR_Word) here are in the hope of increasing ** the chance that this will work on a segmented architecture. */ type_ctor_info_1 = MR_TYPEINFO_GET_TYPE_CTOR_INFO(type_info_1); type_ctor_info_2 = MR_TYPEINFO_GET_TYPE_CTOR_INFO(type_info_2); - if ((Unsigned) type_ctor_info_1 < (Unsigned) type_ctor_info_2) { + if ((MR_Unsigned) type_ctor_info_1 < (MR_Unsigned) type_ctor_info_2) { return MR_COMPARE_LESS; - } else if ((Unsigned) type_ctor_info_1 > (Unsigned) type_ctor_info_2) { + } else if ((MR_Unsigned) type_ctor_info_1 > (MR_Unsigned) type_ctor_info_2) { return MR_COMPARE_GREATER; } diff --git a/runtime/mercury_type_info.h b/runtime/mercury_type_info.h index 355aca687..8580ba2de 100644 --- a/runtime/mercury_type_info.h +++ b/runtime/mercury_type_info.h @@ -46,7 +46,7 @@ #define MERCURY_TYPE_INFO_H #include "mercury_std.h" /* for `MR_STRINGIFY' and `MR_PASTEn' */ -#include "mercury_types.h" /* for `Word' */ +#include "mercury_types.h" /* for `MR_Word' */ /*---------------------------------------------------------------------------*/ @@ -102,7 +102,7 @@ typedef const struct MR_PseudoTypeInfo_Almost_Struct *MR_PseudoTypeInfo; ** only through the macros defined below; the fields of the structures should ** not be accessed directly, and there should be no casts involving such ** values, except in the interface between code written in Mercury and code -** written in C, in which case casts to MR_(Pseudo)TypeInfo and back to Word +** written in C, in which case casts to MR_(Pseudo)TypeInfo and back to MR_Word ** may be required. If this discipline is followed, the macros should catch ** most errors, such as passing pseudo typeinfos where typeinfos are expected. ** @@ -135,7 +135,7 @@ typedef const struct MR_PseudoTypeInfo_Almost_Struct *MR_PseudoTypeInfo; #define MR_HIGHER_ORDER_TYPEINFO_STRUCT(NAME, ARITY) \ struct NAME { \ MR_TypeCtorInfo MR_ti_type_ctor_info; \ - Integer MR_ti_higher_order_arity; \ + MR_Integer MR_ti_higher_order_arity; \ MR_TypeInfo MR_ti_higher_order_arg_typeinfos[ARITY]; \ } #define MR_FIRST_ORDER_PSEUDOTYPEINFO_STRUCT(NAME, ARITY) \ @@ -146,7 +146,7 @@ typedef const struct MR_PseudoTypeInfo_Almost_Struct *MR_PseudoTypeInfo; #define MR_HIGHER_ORDER_PSEUDOTYPEINFO_STRUCT(NAME, ARITY) \ struct NAME { \ MR_TypeCtorInfo MR_pti_type_ctor_info; \ - Integer MR_pti_higher_order_arity; \ + MR_Integer MR_pti_higher_order_arity; \ MR_PseudoTypeInfo MR_pti_higher_order_arg_pseudo_typeinfos[ARITY]; \ } @@ -188,14 +188,14 @@ typedef MR_TypeInfo *MR_TypeInfoParams; #define MR_PSEUDO_TYPEINFO_IS_VARIABLE(T) \ ( MR_CHECK_EXPR_TYPE((T), MR_PseudoTypeInfo), \ - (Unsigned) (T) <= MR_PSEUDOTYPEINFO_MAX_VAR ) + (MR_Unsigned) (T) <= MR_PSEUDOTYPEINFO_MAX_VAR ) #define MR_TYPE_VARIABLE_IS_EXIST_QUANT(T) \ ( MR_CHECK_EXPR_TYPE((T), MR_PseudoTypeInfo), \ - (Word) (T) > MR_PSEUDOTYPEINFO_EXIST_VAR_BASE ) + (MR_Word) (T) > MR_PSEUDOTYPEINFO_EXIST_VAR_BASE ) #define MR_TYPE_VARIABLE_IS_UNIV_QUANT(T) \ ( MR_CHECK_EXPR_TYPE((T), MR_PseudoTypeInfo), \ - (Word) (T) <= MR_PSEUDOTYPEINFO_EXIST_VAR_BASE ) + (MR_Word) (T) <= MR_PSEUDOTYPEINFO_EXIST_VAR_BASE ) /* ** This macro converts a pseudo_type_info to a type_info. @@ -331,19 +331,19 @@ typedef MR_TypeInfo *MR_TypeInfoParams; */ #define MR_typeclass_info_num_extra_instance_args(tci) \ - ((Integer)(*(Word **)(tci))[0]) + ((MR_Integer)(*(MR_Word **)(tci))[0]) #define MR_typeclass_info_num_instance_constraints(tci) \ - ((Integer)(*(Word **)(tci))[1]) + ((MR_Integer)(*(MR_Word **)(tci))[1]) #define MR_typeclass_info_num_superclasses(tci) \ - ((Integer)(*(Word **)(tci))[2]) + ((MR_Integer)(*(MR_Word **)(tci))[2]) #define MR_typeclass_info_num_type_infos(tci) \ - ((Integer)(*(Word **)(tci))[3]) + ((MR_Integer)(*(MR_Word **)(tci))[3]) #define MR_typeclass_info_num_methods(tci) \ - ((Integer)(*(Word **)(tci))[4]) + ((MR_Integer)(*(MR_Word **)(tci))[4]) #define MR_typeclass_info_class_method(tci, n) \ - ((Code *)(*(Word **)tci)[(n+4)]) + ((MR_Code *)(*(MR_Word **)tci)[(n+4)]) #define MR_typeclass_info_arg_typeclass_info(tci, n) \ - (((Word *)(tci))[(n)]) + (((MR_Word *)(tci))[(n)]) /* ** The following have the same definitions. This is because @@ -352,9 +352,9 @@ typedef MR_TypeInfo *MR_TypeInfoParams; */ #define MR_typeclass_info_superclass_info(tci, n) \ - (((Word *)(tci))[MR_typeclass_info_num_extra_instance_args(tci) + (n)]) + (((MR_Word *)(tci))[MR_typeclass_info_num_extra_instance_args(tci) + (n)]) #define MR_typeclass_info_type_info(tci, n) \ - (((Word *)(tci))[MR_typeclass_info_num_extra_instance_args(tci) + (n)]) + (((MR_Word *)(tci))[MR_typeclass_info_num_extra_instance_args(tci) + (n)]) /*---------------------------------------------------------------------------*/ @@ -574,7 +574,7 @@ typedef enum { } MR_Sectag_Locn; typedef struct { - ConstString MR_du_functor_name; + MR_ConstString MR_du_functor_name; MR_int_least16_t MR_du_functor_orig_arity; MR_int_least16_t MR_du_functor_arg_type_contains_var; MR_Sectag_Locn MR_du_functor_sectag_locn; @@ -582,7 +582,7 @@ typedef struct { MR_int_least32_t MR_du_functor_secondary; MR_int_least32_t MR_du_functor_ordinal; const MR_PseudoTypeInfo *MR_du_functor_arg_types; - const ConstString *MR_du_functor_arg_names; + const MR_ConstString *MR_du_functor_arg_names; const MR_DuExistInfo *MR_du_functor_exist_info; } MR_DuFunctorDesc; @@ -617,14 +617,14 @@ typedef struct { /*---------------------------------------------------------------------------*/ typedef struct { - ConstString MR_enum_functor_name; + MR_ConstString MR_enum_functor_name; MR_int_least32_t MR_enum_functor_ordinal; } MR_EnumFunctorDesc; /*---------------------------------------------------------------------------*/ typedef struct { - ConstString MR_notag_functor_name; + MR_ConstString MR_notag_functor_name; MR_PseudoTypeInfo MR_notag_functor_arg_type; } MR_NotagFunctorDesc; @@ -715,7 +715,7 @@ typedef MR_PseudoTypeInfo MR_EquivLayout; */ typedef void * MR_ProcAddr; #else - typedef Code *MR_ProcAddr; + typedef MR_Code *MR_ProcAddr; #endif /*---------------------------------------------------------------------------*/ @@ -778,16 +778,16 @@ typedef union { */ struct MR_TypeCtorInfo_Struct { - Integer arity; + MR_Integer arity; MR_ProcAddr unify_pred; MR_ProcAddr new_unify_pred; MR_ProcAddr compare_pred; MR_TypeCtorRep type_ctor_rep; MR_ProcAddr solver_pred; MR_ProcAddr init_pred; - ConstString type_ctor_module_name; - ConstString type_ctor_name; - Integer type_ctor_version; + MR_ConstString type_ctor_module_name; + MR_ConstString type_ctor_name; + MR_Integer type_ctor_version; MR_TypeFunctors type_functors; MR_TypeLayout type_layout; MR_int_least32_t type_ctor_num_functors; @@ -1023,7 +1023,7 @@ extern MR_TypeInfo MR_create_type_info( extern MR_TypeInfo MR_create_type_info_maybe_existq( const MR_TypeInfoParams type_info_params, const MR_PseudoTypeInfo pseudo_type_info, - const Word *data_value, + const MR_Word *data_value, const MR_DuFunctorDesc *functor_descriptor); struct MR_MemoryCellNode { @@ -1040,7 +1040,7 @@ extern MR_TypeInfo MR_make_type_info( extern MR_TypeInfo MR_make_type_info_maybe_existq( const MR_TypeInfoParams type_info_params, const MR_PseudoTypeInfo pseudo_type_info, - const Word *data_value, + const MR_Word *data_value, const MR_DuFunctorDesc *functor_descriptor, MR_MemoryList *allocated); extern void MR_deallocate(MR_MemoryList allocated_memory_cells); diff --git a/runtime/mercury_types.h b/runtime/mercury_types.h index 2c0bf1aef..ce08c25c2 100644 --- a/runtime/mercury_types.h +++ b/runtime/mercury_types.h @@ -50,31 +50,32 @@ typedef signed char MR_int_least8_t; /* ** This section defines the basic types that we use. -** Note that we require sizeof(Word) == sizeof(Integer) == sizeof(Code*). +** Note that we require +** sizeof(MR_Word) == sizeof(MR_Integer) == sizeof(MR_Code*). */ -typedef MR_uintptr_t Word; -typedef MR_intptr_t Integer; -typedef MR_uintptr_t Unsigned; -typedef MR_intptr_t Bool; +typedef MR_uintptr_t MR_Word; +typedef MR_intptr_t MR_Integer; +typedef MR_uintptr_t MR_Unsigned; +typedef MR_intptr_t MR_Bool; /* -** `Code *' is used as a generic pointer-to-label type that can point +** `MR_Code *' is used as a generic pointer-to-label type that can point ** to any label defined using the Define_* macros in mercury_goto.h. */ -typedef void Code; +typedef void MR_Code; /* -** Float64 is required for the bytecode. +** MR_Float64 is required for the bytecode. ** XXX: We should also check for IEEE-754 compliance. */ #if MR_FLOAT_IS_64_BIT - typedef float Float64; + typedef float MR_Float64; #elif MR_DOUBLE_IS_64_BIT - typedef double Float64; + typedef double MR_Float64; #elif MR_LONG_DOUBLE_IS_64_BIT - typedef long double Float64; + typedef long double MR_Float64; #else #error "For Mercury bytecode, we require 64-bit IEEE-754 floating point" #endif @@ -85,11 +86,11 @@ typedef void Code; ** If you modify them, you will need to modify mercury_string.h as well. */ -typedef char Char; -typedef unsigned char UnsignedChar; +typedef char MR_Char; +typedef unsigned char MR_UnsignedChar; -typedef Char *String; -typedef const Char *ConstString; +typedef MR_Char *MR_String; +typedef const MR_Char *MR_ConstString; /* continuation function type, for --high-level-code option */ typedef void (*MR_NestedCont) (void); /* for --gcc-nested-functions */ @@ -104,4 +105,19 @@ typedef void (*MR_Cont) (void *); /* for --no-gcc-nested-functions */ #define SUCCESS_INDICATOR r1 #endif +/* +** The MR_Box type is used for representing polymorphic types. +** Currently this is only used in the MLDS C backend. +** +** Since it is used in some C code fragments, we define it as MR_Word +** in the low-level backend. +*/ +#ifdef MR_HIGHLEVEL_CODE +typedef void *MR_Box; +#else +typedef MR_Word MR_Box; +#endif + + + #endif /* not MERCURY_TYPES_H */ diff --git a/runtime/mercury_unify_compare_body.h b/runtime/mercury_unify_compare_body.h index f76c2d8de..7dc39270c 100644 --- a/runtime/mercury_unify_compare_body.h +++ b/runtime/mercury_unify_compare_body.h @@ -90,14 +90,14 @@ start_label: MR_DuPtagLayout *x_ptaglayout; MR_DuPtagLayout *y_ptaglayout; #else - Word x_ptag; - Word y_ptag; - Word x_sectag; - Word y_sectag; + MR_Word x_ptag; + MR_Word y_ptag; + MR_Word x_sectag; + MR_Word y_sectag; MR_DuPtagLayout *ptaglayout; #endif - Word *x_data_value; - Word *y_data_value; + MR_Word *x_data_value; + MR_Word *y_data_value; const MR_DuExistInfo *exist_info; int result; int cur_slot; @@ -114,7 +114,7 @@ start_label: \ ptag = MR_tag(data); \ ptaglayout = &type_ctor_info->type_layout.layout_du[ptag];\ - data_value = (Word *) MR_body(data, ptag); \ + data_value = (MR_Word *) MR_body(data, ptag); \ \ switch (ptaglayout->MR_sectag_locn) { \ case MR_SECTAG_LOCAL: \ @@ -158,8 +158,8 @@ start_label: } ptaglayout = &type_ctor_info->type_layout.layout_du[x_ptag]; - x_data_value = (Word *) MR_body(x, x_ptag); - y_data_value = (Word *) MR_body(y, y_ptag); + x_data_value = (MR_Word *) MR_body(x, x_ptag); + y_data_value = (MR_Word *) MR_body(y, y_ptag); switch (ptaglayout->MR_sectag_locn) { case MR_SECTAG_LOCAL: @@ -316,9 +316,9 @@ start_label: } #ifdef MR_UNIFY_COMPARE_BY_CTOR_REP_SPEC_1 else if (type_ctor_info->arity == 1) { - Word *args_base; + MR_Word *args_base; - args_base = (Word *) + args_base = (MR_Word *) MR_TYPEINFO_GET_FIRST_ORDER_ARG_VECTOR(type_info); r1 = args_base[1]; r2 = x; @@ -327,9 +327,9 @@ start_label: #endif #ifdef MR_UNIFY_COMPARE_BY_CTOR_REP_SPEC_2 else if (type_ctor_info->arity == 2) { - Word *args_base; + MR_Word *args_base; - args_base = (Word *) + args_base = (MR_Word *) MR_TYPEINFO_GET_FIRST_ORDER_ARG_VECTOR(type_info); r1 = args_base[1]; r2 = args_base[2]; @@ -340,10 +340,10 @@ start_label: else { int i; int type_arity; - Word *args_base; + MR_Word *args_base; type_arity = type_ctor_info->arity; - args_base = (Word *) + args_base = (MR_Word *) MR_TYPEINFO_GET_FIRST_ORDER_ARG_VECTOR(type_info); save_registers(); @@ -363,20 +363,20 @@ start_label: case MR_TYPECTOR_REP_INT: case MR_TYPECTOR_REP_CHAR: #ifdef select_compare_code - if ((Integer) x == (Integer) y) { + if ((MR_Integer) x == (MR_Integer) y) { return_answer(MR_COMPARE_EQUAL); - } else if ((Integer) x < (Integer) y) { + } else if ((MR_Integer) x < (MR_Integer) y) { return_answer(MR_COMPARE_LESS); } else { return_answer(MR_COMPARE_GREATER); } #else - return_answer((Integer) x == (Integer) y); + return_answer((MR_Integer) x == (MR_Integer) y); #endif case MR_TYPECTOR_REP_FLOAT: { - Float fx, fy; + MR_Float fx, fy; fx = word_to_float(x); fy = word_to_float(y); diff --git a/runtime/mercury_wrapper.c b/runtime/mercury_wrapper.c index 40f8c5f24..e601ae192 100644 --- a/runtime/mercury_wrapper.c +++ b/runtime/mercury_wrapper.c @@ -120,8 +120,8 @@ bool MR_profiling = TRUE; #include "mercury_array_macros.h" typedef struct { - ConstString type_stat_module; - ConstString type_stat_name; + MR_ConstString type_stat_module; + MR_ConstString type_stat_name; int type_stat_ctor_rep; long type_stat_count; } MR_TypeNameStat; @@ -189,7 +189,7 @@ void (*address_of_init_gc)(void); void (*program_entry_point)(void); /* normally main_2_p_0 (main/2) */ #else -Code *program_entry_point; +MR_Code *program_entry_point; /* normally mercury__main_2_0 (main/2) */ #endif @@ -198,19 +198,19 @@ void (*MR_library_initializer)(void); void (*MR_library_finalizer)(void); /* normally ML_io_finalize_state (io__finalize_state/2) */ -void (*MR_io_stderr_stream)(Word *); -void (*MR_io_stdout_stream)(Word *); -void (*MR_io_stdin_stream)(Word *); -void (*MR_io_print_to_cur_stream)(Word, Word); -void (*MR_io_print_to_stream)(Word, Word, Word); +void (*MR_io_stderr_stream)(MR_Word *); +void (*MR_io_stdout_stream)(MR_Word *); +void (*MR_io_stdin_stream)(MR_Word *); +void (*MR_io_print_to_cur_stream)(MR_Word, MR_Word); +void (*MR_io_print_to_stream)(MR_Word, MR_Word, MR_Word); -void (*MR_DI_output_current_ptr)(Integer, Integer, Integer, Word, String, - String, Integer, Integer, Integer, Word, String, Word, Word); +void (*MR_DI_output_current_ptr)(MR_Integer, MR_Integer, MR_Integer, MR_Word, MR_String, + MR_String, MR_Integer, MR_Integer, MR_Integer, MR_Word, MR_String, MR_Word, MR_Word); /* normally ML_DI_output_current (output_current/13) */ -bool (*MR_DI_found_match)(Integer, Integer, Integer, Word, String, String, - Integer, Integer, Integer, Word, String, Word); +bool (*MR_DI_found_match)(MR_Integer, MR_Integer, MR_Integer, MR_Word, MR_String, MR_String, + MR_Integer, MR_Integer, MR_Integer, MR_Word, MR_String, MR_Word); /* normally ML_DI_found_match (output_current/12) */ -void (*MR_DI_read_request_from_socket)(Word, Word *, Integer *); +void (*MR_DI_read_request_from_socket)(MR_Word, MR_Word *, MR_Integer *); /* ** This variable has been replaced by MR_io_print_to_*_stream, @@ -219,9 +219,9 @@ void (*MR_DI_read_request_from_socket)(Word, Word *, Integer *); ** been retired. */ -Code *MR_library_trace_browser; +MR_Code *MR_library_trace_browser; -Code *(*volatile MR_trace_func_ptr)(const MR_Stack_Layout_Label *); +MR_Code *(*volatile MR_trace_func_ptr)(const MR_Stack_Layout_Label *); void (*MR_address_of_trace_interrupt_handler)(void); @@ -263,7 +263,7 @@ mercury_runtime_init(int argc, char **argv) bool saved_trace_enabled; #if NUM_REAL_REGS > 0 - Word c_regs[NUM_REAL_REGS]; + MR_Word c_regs[NUM_REAL_REGS]; #endif /* @@ -893,7 +893,7 @@ void mercury_runtime_main(void) { #if NUM_REAL_REGS > 0 - Word c_regs[NUM_REAL_REGS]; + MR_Word c_regs[NUM_REAL_REGS]; #endif #if defined(MR_LOWLEVEL_DEBUG) && defined(USE_GCC_NONLOCAL_GOTOS) @@ -1034,7 +1034,7 @@ mercury_runtime_main(void) #ifdef MR_TYPE_CTOR_STATS -static ConstString MR_ctor_rep_name[] = { +static MR_ConstString MR_ctor_rep_name[] = { MR_CTOR_REP_NAMES }; @@ -1229,10 +1229,10 @@ BEGIN_CODE Define_entry(do_interpreter); MR_incr_sp(4); - MR_stackvar(1) = (Word) MR_hp; - MR_stackvar(2) = (Word) MR_succip; - MR_stackvar(3) = (Word) MR_maxfr; - MR_stackvar(4) = (Word) MR_curfr; + MR_stackvar(1) = (MR_Word) MR_hp; + MR_stackvar(2) = (MR_Word) MR_succip; + MR_stackvar(3) = (MR_Word) MR_maxfr; + MR_stackvar(4) = (MR_Word) MR_curfr; MR_mkframe("interpreter", 1, LABEL(global_fail)); @@ -1281,10 +1281,10 @@ Define_label(all_done); if (MR_profiling) MR_prof_turn_off_time_profiling(); #endif - MR_hp = (Word *) MR_stackvar(1); - MR_succip = (Code *) MR_stackvar(2); - MR_maxfr = (Word *) MR_stackvar(3); - MR_curfr = (Word *) MR_stackvar(4); + MR_hp = (MR_Word *) MR_stackvar(1); + MR_succip = (MR_Code *) MR_stackvar(2); + MR_maxfr = (MR_Word *) MR_stackvar(3); + MR_curfr = (MR_Word *) MR_stackvar(4); MR_decr_sp(4); #ifdef MR_LOWLEVEL_DEBUG @@ -1308,7 +1308,7 @@ int mercury_runtime_terminate(void) { #if NUM_REAL_REGS > 0 - Word c_regs[NUM_REAL_REGS]; + MR_Word c_regs[NUM_REAL_REGS]; #endif /* ** Save the callee-save registers; we're going to start using them diff --git a/runtime/mercury_wrapper.h b/runtime/mercury_wrapper.h index 59f2c2828..ba8dc8ace 100644 --- a/runtime/mercury_wrapper.h +++ b/runtime/mercury_wrapper.h @@ -67,17 +67,17 @@ extern int MR_load_aditi_rl_code(void); #ifdef MR_HIGHLEVEL_CODE extern void (*program_entry_point)(void); /* normally main_2_p_0 */ #else -extern Code *program_entry_point; /* normally mercury__main_2_0; */ +extern MR_Code *program_entry_point; /* normally mercury__main_2_0; */ #endif extern void (*MR_library_initializer)(void); extern void (*MR_library_finalizer)(void); -extern void (*MR_io_stderr_stream)(Word *); -extern void (*MR_io_stdout_stream)(Word *); -extern void (*MR_io_stdin_stream)(Word *); -extern void (*MR_io_print_to_cur_stream)(Word, Word); -extern void (*MR_io_print_to_stream)(Word, Word, Word); +extern void (*MR_io_stderr_stream)(MR_Word *); +extern void (*MR_io_stdout_stream)(MR_Word *); +extern void (*MR_io_stdin_stream)(MR_Word *); +extern void (*MR_io_print_to_cur_stream)(MR_Word, MR_Word); +extern void (*MR_io_print_to_stream)(MR_Word, MR_Word, MR_Word); extern void (*address_of_mercury_init_io)(void); extern void (*address_of_init_modules)(void); @@ -117,7 +117,7 @@ extern void (*MR_address_of_trace_final_external)(void); ** been retired. */ -extern Code *MR_library_trace_browser; +extern MR_Code *MR_library_trace_browser; /* ** MR_trace_func_ptr is set to either MR_trace_real (trace/mercury_trace.c), @@ -131,7 +131,7 @@ extern Code *MR_library_trace_browser; ** Since it is set from a signal handler, it must be declared `volatile'. */ -extern Code *(*volatile MR_trace_func_ptr)( +extern MR_Code *(*volatile MR_trace_func_ptr)( const MR_Stack_Layout_Label *); /* diff --git a/trace/mercury_trace.c b/trace/mercury_trace.c index 15653ebc3..df54325e8 100644 --- a/trace/mercury_trace.c +++ b/trace/mercury_trace.c @@ -63,8 +63,8 @@ Code *MR_trace_real(const MR_Stack_Layout_Label *layout); static Code *MR_trace_event(MR_Trace_Cmd_Info *cmd, bool interactive, const MR_Stack_Layout_Label *layout, MR_Trace_Port port, Unsigned seqno, Unsigned depth); -static Word MR_trace_find_input_arg(const MR_Stack_Layout_Label *label, - Word *saved_regs, MR_uint_least16_t var_num, +static MR_Word MR_trace_find_input_arg(const MR_Stack_Layout_Label *label, + MR_Word *saved_regs, MR_uint_least16_t var_num, bool *succeeded); /* @@ -82,7 +82,7 @@ static Word MR_trace_find_input_arg(const MR_Stack_Layout_Label *label, Code * MR_trace_real(const MR_Stack_Layout_Label *layout) { - Integer maybe_from_full; + MR_Integer maybe_from_full; Unsigned seqno; Unsigned depth; MR_Spy_Action action; @@ -325,7 +325,7 @@ MR_trace_event(MR_Trace_Cmd_Info *cmd, bool interactive, { Code *jumpaddr; MR_Event_Info event_info; - Word *saved_regs = event_info.MR_saved_regs; + MR_Word *saved_regs = event_info.MR_saved_regs; int max_r_num; event_info.MR_event_number = MR_trace_event_number; @@ -390,14 +390,14 @@ MR_trace_retry(MR_Event_Info *event_info, MR_Event_Details *event_details, const MR_Stack_Layout_Entry *entry; const MR_Stack_Layout_Label *call_label; const MR_Stack_Layout_Vars *input_args; - Word *args; + MR_Word *args; int arg_max; int arg_num; - Word arg_value; + MR_Word arg_value; int i; bool succeeded; const char *message; - Word *saved_regs; + MR_Word *saved_regs; saved_regs = event_info->MR_saved_regs; entry = event_info->MR_event_sll->MR_sll_entry; @@ -447,7 +447,7 @@ MR_trace_retry(MR_Event_Info *event_info, MR_Event_Details *event_details, } if (arg_num > 0) { - MR_ensure_big_enough(arg_num, arg, Word, + MR_ensure_big_enough(arg_num, arg, MR_Word, MR_INIT_ARG_COUNT); args[arg_num] = arg_value; } else { @@ -460,7 +460,7 @@ MR_trace_retry(MR_Event_Info *event_info, MR_Event_Details *event_details, if (MR_DETISM_DET_STACK(entry->MR_sle_detism)) { MR_Long_Lval location; - Word *this_frame; + MR_Word *this_frame; /* ** We are at a final port, so both curfr and maxfr @@ -476,7 +476,7 @@ MR_trace_retry(MR_Event_Info *event_info, MR_Event_Details *event_details, } this_frame = MR_saved_sp(saved_regs); - MR_saved_succip(saved_regs) = (Word *) + MR_saved_succip(saved_regs) = (MR_Word *) MR_based_stackvar(this_frame, MR_LONG_LVAL_NUMBER(location)); MR_saved_sp(saved_regs) -= entry->MR_sle_stack_slots; @@ -484,8 +484,8 @@ MR_trace_retry(MR_Event_Info *event_info, MR_Event_Details *event_details, #ifdef MR_USE_TRAIL if (entry->MR_sle_maybe_trail >= 0) { - Word ticket_counter; - Word trail_ptr; + MR_Word ticket_counter; + MR_Word trail_ptr; trail_ptr = MR_based_stackvar(this_frame, entry->MR_sle_maybe_trail); @@ -498,7 +498,7 @@ MR_trace_retry(MR_Event_Info *event_info, MR_Event_Details *event_details, } #endif } else { - Word *this_frame; + MR_Word *this_frame; /* ** We are at a final port, so sp must already have been reset @@ -516,8 +516,8 @@ MR_trace_retry(MR_Event_Info *event_info, MR_Event_Details *event_details, #ifdef MR_USE_TRAIL if (entry->MR_sle_maybe_trail >= 0) { - Word ticket_counter; - Word trail_ptr; + MR_Word ticket_counter; + MR_Word trail_ptr; trail_ptr = MR_based_framevar(this_frame, entry->MR_sle_maybe_trail); @@ -556,8 +556,8 @@ MR_trace_retry(MR_Event_Info *event_info, MR_Event_Details *event_details, } -static Word -MR_trace_find_input_arg(const MR_Stack_Layout_Label *label, Word *saved_regs, +static MR_Word +MR_trace_find_input_arg(const MR_Stack_Layout_Label *label, MR_Word *saved_regs, MR_uint_least16_t var_num, bool *succeeded) { const MR_Stack_Layout_Vars *vars; diff --git a/trace/mercury_trace.h b/trace/mercury_trace.h index 57eb04dab..94e8d99fa 100644 --- a/trace/mercury_trace.h +++ b/trace/mercury_trace.h @@ -34,7 +34,7 @@ typedef struct MR_Event_Info_Struct { MR_Trace_Port MR_trace_port; const MR_Stack_Layout_Label *MR_event_sll; const char *MR_event_path; - Word MR_saved_regs[MAX_FAKE_REG]; + MR_Word MR_saved_regs[MAX_FAKE_REG]; int MR_max_mr_num; } MR_Event_Info; diff --git a/trace/mercury_trace_browse.c b/trace/mercury_trace_browse.c index e37699a5d..51d2281cc 100644 --- a/trace/mercury_trace_browse.c +++ b/trace/mercury_trace_browse.c @@ -39,7 +39,7 @@ #include -static Word MR_trace_browser_state; +static MR_Word MR_trace_browser_state; static MR_TypeInfo MR_trace_browser_state_type; static void MR_trace_browse_ensure_init(void); @@ -52,7 +52,7 @@ MR_c_file_to_mercury_file(FILE *c_file, MercuryFile *mercury_file) } void -MR_trace_browse(Word type_info, Word value) +MR_trace_browse(MR_Word type_info, MR_Word value) { MercuryFile mdb_in, mdb_out; @@ -63,7 +63,7 @@ MR_trace_browse(Word type_info, Word value) MR_TRACE_CALL_MERCURY( ML_BROWSE_browse(type_info, value, - (Word) &mdb_in, (Word) &mdb_out, + (MR_Word) &mdb_in, (MR_Word) &mdb_out, MR_trace_browser_state, &MR_trace_browser_state); ); MR_trace_browser_state = MR_make_permanent(MR_trace_browser_state, @@ -81,14 +81,14 @@ MR_trace_browse(Word type_info, Word value) #ifdef MR_USE_EXTERNAL_DEBUGGER void -MR_trace_browse_external(Word type_info, Word value) +MR_trace_browse_external(MR_Word type_info, MR_Word value) { MR_trace_browse_ensure_init(); MR_TRACE_CALL_MERCURY( ML_BROWSE_browse_external(type_info, value, - (Word) &MR_debugger_socket_in, - (Word) &MR_debugger_socket_out, + (MR_Word) &MR_debugger_socket_in, + (MR_Word) &MR_debugger_socket_out, MR_trace_browser_state, &MR_trace_browser_state); ); MR_trace_browser_state = MR_make_permanent(MR_trace_browser_state, @@ -98,7 +98,7 @@ MR_trace_browse_external(Word type_info, Word value) #endif void -MR_trace_print(Word type_info, Word value) +MR_trace_print(MR_Word type_info, MR_Word value) { MercuryFile mdb_out; @@ -107,7 +107,7 @@ MR_trace_print(Word type_info, Word value) MR_c_file_to_mercury_file(MR_mdb_out, &mdb_out); MR_TRACE_CALL_MERCURY( - ML_BROWSE_print(type_info, value, (Word) &mdb_out, + ML_BROWSE_print(type_info, value, (MR_Word) &mdb_out, MR_trace_browser_state); ); } @@ -116,8 +116,8 @@ static void MR_trace_browse_ensure_init(void) { static bool done = FALSE; - Word typeinfo_type_word; - Word MR_trace_browser_state_type_word; + MR_Word typeinfo_type_word; + MR_Word MR_trace_browser_state_type_word; if (! done) { MR_TRACE_CALL_MERCURY( @@ -130,7 +130,7 @@ MR_trace_browse_ensure_init(void) ); MR_trace_browser_state_type = (MR_TypeInfo) MR_make_permanent( - (Word) MR_trace_browser_state_type, + (MR_Word) MR_trace_browser_state_type, (MR_TypeInfo) typeinfo_type_word); MR_trace_browser_state = MR_make_permanent( MR_trace_browser_state, @@ -143,8 +143,8 @@ void MR_trace_query(MR_Query_Type type, const char *options, int num_imports, char *imports[]) { - ConstString options_on_heap; - Word imports_list; + MR_ConstString options_on_heap; + MR_Word imports_list; MercuryFile mdb_in, mdb_out; int i; @@ -158,28 +158,28 @@ MR_trace_query(MR_Query_Type type, const char *options, int num_imports, imports_list = MR_list_empty(); for (i = num_imports; i > 0; i--) { - ConstString this_import; + MR_ConstString this_import; MR_make_aligned_string(this_import, imports[i - 1]); imports_list = MR_list_cons(this_import, imports_list); } ); MR_TRACE_CALL_MERCURY( - ML_query(type, imports_list, (String) options_on_heap, - (Word) &mdb_in, (Word) &mdb_out); + ML_query(type, imports_list, (MR_String) options_on_heap, + (MR_Word) &mdb_in, (MR_Word) &mdb_out); ); } #ifdef MR_USE_EXTERNAL_DEBUGGER void -MR_trace_query_external(MR_Query_Type type, String options, int num_imports, - Word imports_list) +MR_trace_query_external(MR_Query_Type type, MR_String options, int num_imports, + MR_Word imports_list) { MR_TRACE_CALL_MERCURY( ML_query_external(type, imports_list, options, - (Word) &MR_debugger_socket_in, - (Word) &MR_debugger_socket_out); + (MR_Word) &MR_debugger_socket_in, + (MR_Word) &MR_debugger_socket_out); ); } diff --git a/trace/mercury_trace_browse.h b/trace/mercury_trace_browse.h index 52dcd1b8f..8b553039a 100644 --- a/trace/mercury_trace_browse.h +++ b/trace/mercury_trace_browse.h @@ -15,20 +15,20 @@ #define MERCURY_TRACE_BROWSE_H #include "mercury_conf.h" /* for MR_USE_EXTERNAL_DEBUGGER */ -#include "mercury_types.h" /* for Word, String */ +#include "mercury_types.h" /* for MR_Word, MR_String */ /* ** Interactively browse a term. */ -extern void MR_trace_browse(Word type_info, Word value); +extern void MR_trace_browse(MR_Word type_info, MR_Word value); #ifdef MR_USE_EXTERNAL_DEBUGGER -extern void MR_trace_browse_external(Word type_info, Word value); +extern void MR_trace_browse_external(MR_Word type_info, MR_Word value); #endif /* ** Display a term (non-interactively). */ -extern void MR_trace_print(Word type_info, Word value); +extern void MR_trace_print(MR_Word type_info, MR_Word value); /* @@ -42,8 +42,8 @@ extern void MR_trace_query(MR_Query_Type type, const char *options, int num_imports, /* const */ char *imports[]); #ifdef MR_USE_EXTERNAL_DEBUGGER -extern void MR_trace_query_external(MR_Query_Type type, String options, - int num_imports, Word imports_list); +extern void MR_trace_query_external(MR_Query_Type type, MR_String options, + int num_imports, MR_Word imports_list); #endif #endif /* MERCURY_TRACE_BROWSE_H */ diff --git a/trace/mercury_trace_declarative.c b/trace/mercury_trace_declarative.c index fec3a7b73..6ed4ac86c 100644 --- a/trace/mercury_trace_declarative.c +++ b/trace/mercury_trace_declarative.c @@ -132,7 +132,7 @@ static Unsigned MR_trace_node_store; ** MR_trace_decl_ensure_init should be called before using the state. */ -static Word MR_trace_front_end_state; +static MR_Word MR_trace_front_end_state; static void MR_trace_decl_ensure_init(void); @@ -190,10 +190,10 @@ static MR_Trace_Node MR_trace_decl_neg_failure(MR_Event_Info *event_info, MR_Trace_Node prev); static MR_Trace_Node -MR_trace_decl_get_slot(const MR_Stack_Layout_Entry *entry, Word *saved_regs); +MR_trace_decl_get_slot(const MR_Stack_Layout_Entry *entry, MR_Word *saved_regs); static void -MR_trace_decl_set_slot(const MR_Stack_Layout_Entry *entry, Word *saved_regs, +MR_trace_decl_set_slot(const MR_Stack_Layout_Entry *entry, MR_Word *saved_regs, MR_Trace_Node node); static MR_Trace_Node @@ -217,15 +217,15 @@ MR_trace_same_construct(const char *p1, const char *p2); static bool MR_trace_single_component(const char *path); -static Word -MR_decl_make_atom(const MR_Stack_Layout_Label *layout, Word *saved_regs, +static MR_Word +MR_decl_make_atom(const MR_Stack_Layout_Label *layout, MR_Word *saved_regs, MR_Trace_Port port); -static ConstString +static MR_ConstString MR_decl_atom_name(const MR_Stack_Layout_Entry *entry); -static Word -MR_decl_atom_args(const MR_Stack_Layout_Label *layout, Word *saved_regs); +static MR_Word +MR_decl_atom_args(const MR_Stack_Layout_Label *layout, MR_Word *saved_regs); static const char * MR_trace_start_collecting(Unsigned event, Unsigned seqno, Unsigned maxdepth, @@ -248,7 +248,7 @@ static Code * MR_decl_handle_bug_found(Unsigned event, MR_Trace_Cmd_Info *cmd, MR_Event_Info *event_info, MR_Event_Details *event_details); -static String +static MR_String MR_trace_node_path(MR_Trace_Node node); static MR_Trace_Port @@ -445,7 +445,7 @@ static MR_Trace_Node MR_trace_decl_call(MR_Event_Info *event_info, MR_Trace_Node prev) { MR_Trace_Node node; - Word atom; + MR_Word atom; bool at_depth_limit; const MR_Stack_Layout_Label *layout = event_info->MR_event_sll; @@ -459,10 +459,10 @@ MR_trace_decl_call(MR_Event_Info *event_info, MR_Trace_Node prev) MR_PORT_CALL); MR_TRACE_CALL_MERCURY( node = (MR_Trace_Node) MR_DD_construct_call_node( - (Word) prev, atom, - (Word) event_info->MR_call_seqno, - (Word) event_info->MR_event_number, - (Word) at_depth_limit); + (MR_Word) prev, atom, + (MR_Word) event_info->MR_call_seqno, + (MR_Word) event_info->MR_event_number, + (MR_Word) at_depth_limit); ); #ifdef MR_USE_DECL_STACK_SLOT @@ -478,8 +478,8 @@ MR_trace_decl_exit(MR_Event_Info *event_info, MR_Trace_Node prev) { MR_Trace_Node node; MR_Trace_Node call; - Word last_interface; - Word atom; + MR_Word last_interface; + MR_Word atom; atom = MR_decl_make_atom(event_info->MR_event_sll, event_info->MR_saved_regs, @@ -495,11 +495,11 @@ MR_trace_decl_exit(MR_Event_Info *event_info, MR_Trace_Node prev) MR_TRACE_CALL_MERCURY( last_interface = MR_DD_call_node_get_last_interface( - (Word) call); + (MR_Word) call); node = (MR_Trace_Node) MR_DD_construct_exit_node( - (Word) prev, (Word) call, last_interface, - atom, (Word) event_info->MR_event_number); - MR_DD_call_node_set_last_interface((Word) call, (Word) node); + (MR_Word) prev, (MR_Word) call, last_interface, + atom, (MR_Word) event_info->MR_event_number); + MR_DD_call_node_set_last_interface((MR_Word) call, (MR_Word) node); ); return node; @@ -511,7 +511,7 @@ MR_trace_decl_redo(MR_Event_Info *event_info, MR_Trace_Node prev) MR_Trace_Node node; MR_Trace_Node call; MR_Trace_Node next; - Word last_interface; + MR_Word last_interface; #ifdef MR_USE_DECL_STACK_SLOT call = MR_trace_decl_get_slot(event_info->MR_event_sll->MR_sll_entry, @@ -530,8 +530,8 @@ MR_trace_decl_redo(MR_Event_Info *event_info, MR_Trace_Node prev) MR_TRACE_CALL_MERCURY( MR_trace_node_store++; - if (!MR_DD_trace_node_call(MR_trace_node_store, (Word) next, - (Word *) &call)) + if (!MR_DD_trace_node_call(MR_trace_node_store, (MR_Word) next, + (MR_Word *) &call)) { MR_fatal_error("MR_trace_decl_redo: no matching EXIT"); } @@ -540,11 +540,11 @@ MR_trace_decl_redo(MR_Event_Info *event_info, MR_Trace_Node prev) MR_TRACE_CALL_MERCURY( last_interface = MR_DD_call_node_get_last_interface( - (Word) call); + (MR_Word) call); node = (MR_Trace_Node) MR_DD_construct_redo_node( - (Word) prev, + (MR_Word) prev, last_interface); - MR_DD_call_node_set_last_interface((Word) call, (Word) node); + MR_DD_call_node_set_last_interface((MR_Word) call, (MR_Word) node); ); return node; @@ -556,7 +556,7 @@ MR_trace_decl_fail(MR_Event_Info *event_info, MR_Trace_Node prev) MR_Trace_Node node; MR_Trace_Node next; MR_Trace_Node call; - Word redo; + MR_Word redo; #ifdef MR_USE_DECL_STACK_SLOT call = MR_trace_decl_get_slot(event_info->MR_event_sll->MR_sll_entry, @@ -579,11 +579,11 @@ MR_trace_decl_fail(MR_Event_Info *event_info, MR_Trace_Node prev) #endif MR_TRACE_CALL_MERCURY( - redo = MR_DD_call_node_get_last_interface( (Word) call); + redo = MR_DD_call_node_get_last_interface( (MR_Word) call); node = (MR_Trace_Node) MR_DD_construct_fail_node( - (Word) prev, (Word) call, (Word) redo, - (Word) event_info->MR_event_number); - MR_DD_call_node_set_last_interface((Word) call, (Word) node); + (MR_Word) prev, (MR_Word) call, (MR_Word) redo, + (MR_Word) event_info->MR_event_number); + MR_DD_call_node_set_last_interface((MR_Word) call, (MR_Word) node); ); return node; } @@ -595,8 +595,8 @@ MR_trace_decl_cond(MR_Event_Info *event_info, MR_Trace_Node prev) MR_TRACE_CALL_MERCURY( node = (MR_Trace_Node) MR_DD_construct_cond_node( - (Word) prev, - (String) event_info->MR_event_path); + (MR_Word) prev, + (MR_String) event_info->MR_event_path); ); return node; } @@ -621,11 +621,11 @@ MR_trace_decl_then(MR_Event_Info *event_info, MR_Trace_Node prev) MR_decl_checkpoint_match(cond); MR_TRACE_CALL_MERCURY( - MR_DD_cond_node_set_status((Word) cond, + MR_DD_cond_node_set_status((MR_Word) cond, MR_TRACE_STATUS_SUCCEEDED); node = (MR_Trace_Node) MR_DD_construct_then_node( - (Word) prev, - (Word) cond); + (MR_Word) prev, + (MR_Word) cond); ); return node; } @@ -658,11 +658,11 @@ MR_trace_decl_else(MR_Event_Info *event_info, MR_Trace_Node prev) MR_decl_checkpoint_match(cond); MR_TRACE_CALL_MERCURY( - MR_DD_cond_node_set_status((Word) cond, + MR_DD_cond_node_set_status((MR_Word) cond, MR_TRACE_STATUS_FAILED); node = (MR_Trace_Node) MR_DD_construct_else_node( - (Word) prev, - (Word) cond); + (MR_Word) prev, + (MR_Word) cond); ); return node; } @@ -674,8 +674,8 @@ MR_trace_decl_neg_enter(MR_Event_Info *event_info, MR_Trace_Node prev) MR_TRACE_CALL_MERCURY( node = (MR_Trace_Node) MR_DD_construct_neg_node( - (Word) prev, - (String) event_info->MR_event_path); + (MR_Word) prev, + (MR_String) event_info->MR_event_path); ); return node; } @@ -708,11 +708,11 @@ MR_trace_decl_neg_success(MR_Event_Info *event_info, MR_Trace_Node prev) MR_decl_checkpoint_match(nege); MR_TRACE_CALL_MERCURY( - MR_DD_neg_node_set_status((Word) nege, + MR_DD_neg_node_set_status((MR_Word) nege, MR_TRACE_STATUS_SUCCEEDED); node = (MR_Trace_Node) MR_DD_construct_neg_succ_node( - (Word) prev, - (Word) nege); + (MR_Word) prev, + (MR_Word) nege); ); return node; } @@ -734,11 +734,11 @@ MR_trace_decl_neg_failure(MR_Event_Info *event_info, MR_Trace_Node prev) MR_decl_checkpoint_match(next); MR_TRACE_CALL_MERCURY( - MR_DD_neg_node_set_status((Word) next, + MR_DD_neg_node_set_status((MR_Word) next, MR_TRACE_STATUS_FAILED); node = (MR_Trace_Node) MR_DD_construct_neg_fail_node( - (Word) prev, - (Word) next); + (MR_Word) prev, + (MR_Word) next); ); return node; } @@ -750,8 +750,8 @@ MR_trace_decl_switch(MR_Event_Info *event_info, MR_Trace_Node prev) MR_TRACE_CALL_MERCURY( node = (MR_Trace_Node) MR_DD_construct_switch_node( - (Word) prev, - (String) event_info->MR_event_path); + (MR_Word) prev, + (MR_String) event_info->MR_event_path); ); return node; } @@ -766,8 +766,8 @@ MR_trace_decl_disj(MR_Event_Info *event_info, MR_Trace_Node prev) { MR_TRACE_CALL_MERCURY( node = (MR_Trace_Node) MR_DD_construct_first_disj_node( - (Word) prev, - (String) path); + (MR_Word) prev, + (MR_String) path); ); } else @@ -797,9 +797,9 @@ MR_trace_decl_disj(MR_Event_Info *event_info, MR_Trace_Node prev) MR_TRACE_CALL_MERCURY( node = (MR_Trace_Node) MR_DD_construct_later_disj_node( MR_trace_node_store, - (Word) prev, - (String) path, - (Word) first); + (MR_Word) prev, + (MR_String) path, + (MR_Word) first); ); } @@ -809,20 +809,20 @@ MR_trace_decl_disj(MR_Event_Info *event_info, MR_Trace_Node prev) #ifdef MR_USE_DECL_STACK_SLOT static MR_Trace_Node -MR_trace_decl_get_slot(const MR_Stack_Layout_Entry *entry, Word *saved_regs) +MR_trace_decl_get_slot(const MR_Stack_Layout_Entry *entry, MR_Word *saved_regs) { int decl_slot; - Word *saved_sp; - Word *saved_curfr; + MR_Word *saved_sp; + MR_Word *saved_curfr; MR_Trace_Node node; decl_slot = entry->MR_sle_maybe_decl_debug; if (MR_DETISM_DET_STACK(entry->MR_sle_detism)) { - saved_sp = (Word *) MR_saved_sp(saved_regs); + saved_sp = (MR_Word *) MR_saved_sp(saved_regs); node = (MR_Trace_Node) MR_based_stackvar(saved_sp, decl_slot); } else { - saved_curfr = (Word *) MR_saved_curfr(saved_regs); + saved_curfr = (MR_Word *) MR_saved_curfr(saved_regs); node = (MR_Trace_Node) MR_based_framevar(saved_curfr, decl_slot); } @@ -832,20 +832,20 @@ MR_trace_decl_get_slot(const MR_Stack_Layout_Entry *entry, Word *saved_regs) static void MR_trace_decl_set_slot(const MR_Stack_Layout_Entry *entry, - Word *saved_regs, MR_Trace_Node node) + MR_Word *saved_regs, MR_Trace_Node node) { int decl_slot; - Word *saved_sp; - Word *saved_curfr; + MR_Word *saved_sp; + MR_Word *saved_curfr; decl_slot = entry->MR_sle_maybe_decl_debug; if (MR_DETISM_DET_STACK(entry->MR_sle_detism)) { - saved_sp = (Word *) MR_saved_sp(saved_regs); - MR_based_stackvar(saved_sp, decl_slot) = (Word) node; + saved_sp = (MR_Word *) MR_saved_sp(saved_regs); + MR_based_stackvar(saved_sp, decl_slot) = (MR_Word) node; } else { - saved_curfr = (Word *) MR_saved_curfr(saved_regs); - MR_based_framevar(saved_curfr, decl_slot) = (Word) node; + saved_curfr = (MR_Word *) MR_saved_curfr(saved_regs); + MR_based_framevar(saved_curfr, decl_slot) = (MR_Word) node; } } @@ -983,13 +983,13 @@ MR_trace_single_component(const char *path) return (*path == '\0'); } -static Word -MR_decl_make_atom(const MR_Stack_Layout_Label *layout, Word *saved_regs, +static MR_Word +MR_decl_make_atom(const MR_Stack_Layout_Label *layout, MR_Word *saved_regs, MR_Trace_Port port) { - ConstString name; - Word arity; - Word atom; + MR_ConstString name; + MR_Word arity; + MR_Word atom; int i; const MR_Stack_Layout_Vars *vars; int arg_count; @@ -1005,14 +1005,14 @@ MR_decl_make_atom(const MR_Stack_Layout_Label *layout, Word *saved_regs, arity = entry->MR_sle_user.MR_user_arity; } MR_TRACE_CALL_MERCURY( - atom = MR_DD_construct_trace_atom((String) name, (Word) arity); + atom = MR_DD_construct_trace_atom((MR_String) name, (MR_Word) arity); ); arg_count = MR_trace_var_count(); for (i = 1; i <= arg_count; i++) { - Word arg; + MR_Word arg; MR_TypeInfo arg_type; - Word arg_value; + MR_Word arg_value; int arg_pos; const char *problem; @@ -1031,23 +1031,23 @@ MR_decl_make_atom(const MR_Stack_Layout_Label *layout, Word *saved_regs, tag_incr_hp(arg, MR_mktag(0), 2); ); MR_field(MR_mktag(0), arg, UNIV_OFFSET_FOR_TYPEINFO) = - (Word) arg_type; + (MR_Word) arg_type; MR_field(MR_mktag(0), arg, UNIV_OFFSET_FOR_DATA) = arg_value; MR_TRACE_CALL_MERCURY( atom = MR_DD_add_trace_atom_arg(atom, - (Word) arg_pos, arg); + (MR_Word) arg_pos, arg); ); } return atom; } -static ConstString +static MR_ConstString MR_decl_atom_name(const MR_Stack_Layout_Entry *entry) { - ConstString name; + MR_ConstString name; if (MR_ENTRY_LAYOUT_HAS_PROC_ID(entry)) { if (MR_ENTRY_LAYOUT_COMPILER_GENERATED(entry)) { @@ -1082,8 +1082,8 @@ MR_trace_decl_ensure_init(void) MR_TRACE_CALL_MERCURY( MR_trace_node_store = 0; MR_DD_decl_diagnosis_state_init( - (Word) &mdb_in, - (Word) &mdb_out, + (MR_Word) &mdb_in, + (MR_Word) &mdb_out, &MR_trace_front_end_state); ); done = TRUE; @@ -1236,7 +1236,7 @@ static Code * MR_decl_diagnosis(MR_Trace_Node root, MR_Trace_Cmd_Info *cmd, MR_Event_Info *event_info, MR_Event_Details *event_details) { - Word response; + MR_Word response; bool bug_found; bool require_subtree; Unsigned bug_event; @@ -1256,10 +1256,10 @@ MR_decl_diagnosis(MR_Trace_Node root, MR_Trace_Cmd_Info *cmd, &MR_trace_front_end_state ); bug_found = MR_DD_diagnoser_bug_found(response, - (Word *) &bug_event); + (MR_Word *) &bug_event); require_subtree = MR_DD_diagnoser_require_subtree(response, - (Word *) &final_event, - (Word *) &topmost_seqno); + (MR_Word *) &final_event, + (MR_Word *) &topmost_seqno); ); if (bug_found) { @@ -1326,20 +1326,20 @@ MR_decl_diagnosis_test(MR_Trace_Node root) stream.line_number = 1; MR_TRACE_CALL_MERCURY( - MR_DD_save_trace((Word) &stream, MR_trace_node_store, root); + MR_DD_save_trace((MR_Word) &stream, MR_trace_node_store, root); ); fclose(MR_trace_store_file); } -static String +static MR_String MR_trace_node_path(MR_Trace_Node node) { - String path; + MR_String path; MR_trace_node_store++; MR_TRACE_CALL_MERCURY( - path = MR_DD_trace_node_path(MR_trace_node_store, (Word) node); + path = MR_DD_trace_node_path(MR_trace_node_store, (MR_Word) node); ); return path; } @@ -1350,7 +1350,7 @@ MR_trace_node_port(MR_Trace_Node node) MR_Trace_Port port; MR_TRACE_CALL_MERCURY( - port = (MR_Trace_Port) MR_DD_trace_node_port((Word) node); + port = (MR_Trace_Port) MR_DD_trace_node_port((MR_Word) node); ); return port; } @@ -1363,8 +1363,8 @@ MR_trace_node_seqno(MR_Trace_Node node) MR_trace_node_store++; MR_TRACE_CALL_MERCURY( if (!MR_DD_trace_node_seqno(MR_trace_node_store, - (Word) node, - (Word *) &seqno)) + (MR_Word) node, + (MR_Word *) &seqno)) { MR_fatal_error("MR_trace_node_seqno: " "not an interface event"); @@ -1379,7 +1379,7 @@ MR_trace_node_first_disj(MR_Trace_Node node) MR_Trace_Node first; MR_TRACE_CALL_MERCURY( - if (!MR_DD_trace_node_first_disj((Word) node, (Word *) &first)) + if (!MR_DD_trace_node_first_disj((MR_Word) node, (MR_Word *) &first)) { MR_fatal_error("MR_trace_node_first_disj: " "not a DISJ event"); @@ -1443,7 +1443,7 @@ MR_decl_checkpoint_loc(const char *str, MR_Trace_Node node) fprintf(MR_mdb_out, "DD %s: %ld ", str, (long) node); MR_TRACE_CALL_MERCURY( - MR_DD_print_trace_node((Word) &mdb_out, (Word) node); + MR_DD_print_trace_node((MR_Word) &mdb_out, (MR_Word) node); ); fprintf(MR_mdb_out, "\n"); } diff --git a/trace/mercury_trace_declarative.h b/trace/mercury_trace_declarative.h index 2a48c4f86..a338beb82 100644 --- a/trace/mercury_trace_declarative.h +++ b/trace/mercury_trace_declarative.h @@ -35,10 +35,10 @@ extern bool MR_trace_start_decl_debug(const char *out, ** values in the definitions in browser/declarative_execution.m. */ -typedef Word MR_Trace_Node; +typedef MR_Word MR_Trace_Node; -#define MR_TRACE_STATUS_SUCCEEDED (Word) 0 -#define MR_TRACE_STATUS_FAILED (Word) 1 -#define MR_TRACE_STATUS_UNDECIDED (Word) 2 +#define MR_TRACE_STATUS_SUCCEEDED (MR_Word) 0 +#define MR_TRACE_STATUS_FAILED (MR_Word) 1 +#define MR_TRACE_STATUS_UNDECIDED (MR_Word) 2 #endif /* MERCURY_TRACE_DECLARATIVE_H */ diff --git a/trace/mercury_trace_external.c b/trace/mercury_trace_external.c index 9fed68f14..b19e15aea 100644 --- a/trace/mercury_trace_external.c +++ b/trace/mercury_trace_external.c @@ -103,7 +103,7 @@ typedef enum { MercuryFile MR_debugger_socket_in; MercuryFile MR_debugger_socket_out; -static String MR_mmc_options; +static MR_String MR_mmc_options; /* ** Type of a static variable that indicates in which mode the external @@ -125,21 +125,21 @@ static MR_external_debugger_mode_type ** a collect request. */ -static Word MR_collecting_variable; +static MR_Word MR_collecting_variable; /* ** Function pointer used to sent the collecting variable to the external ** debugger. */ -static void (*send_collect_result_ptr)(Word, Word); +static void (*send_collect_result_ptr)(MR_Word, MR_Word); /* ** Variable generated during the dynamic linking that is needed to close ** this linking properly. */ -static Word collect_lib_maybe_handle; +static MR_Word collect_lib_maybe_handle; /* ** Static variable that tells whether the list of arguments is available @@ -165,45 +165,45 @@ static void MR_send_message_to_socket_format(const char *format, ...) static void MR_send_message_to_socket(const char *message); static void MR_read_request_from_socket( - Word *debugger_request_ptr, - Integer *debugger_request_type_ptr); + MR_Word *debugger_request_ptr, + MR_Integer *debugger_request_type_ptr); static bool MR_found_match(const MR_Stack_Layout_Label *layout, MR_Trace_Port port, Unsigned seqno, Unsigned depth, /* XXX registers */ - const char *path, Word search_data); + const char *path, MR_Word search_data); static void MR_output_current_slots(const MR_Stack_Layout_Label *layout, MR_Trace_Port port, Unsigned seqno, Unsigned depth, const char *path); -static void MR_output_current_vars(Word var_list, Word string_list); -static void MR_output_current_nth_var(Word var); -static void MR_output_current_live_var_names(Word var_names_list, - Word type_list); -static Word MR_trace_make_var_list(void); -static Word MR_trace_make_var_names_list(void); -static Word MR_trace_make_type_list(void); -static Word MR_trace_make_nth_var(Word debugger_request); -static int MR_get_var_number(Word debugger_request); +static void MR_output_current_vars(MR_Word var_list, MR_Word string_list); +static void MR_output_current_nth_var(MR_Word var); +static void MR_output_current_live_var_names(MR_Word var_names_list, + MR_Word type_list); +static MR_Word MR_trace_make_var_list(void); +static MR_Word MR_trace_make_var_names_list(void); +static MR_Word MR_trace_make_type_list(void); +static MR_Word MR_trace_make_nth_var(MR_Word debugger_request); +static int MR_get_var_number(MR_Word debugger_request); static void MR_print_proc_id_to_socket(const MR_Stack_Layout_Entry *entry, - const char *extra, Word *base_sp, Word *base_curfr); + const char *extra, MR_Word *base_sp, MR_Word *base_curfr); static void MR_dump_stack_record_print_to_socket(FILE *fp, const MR_Stack_Layout_Entry *entry_layout, int count, - int start_level, Word *base_sp, Word *base_curfr, + int start_level, MR_Word *base_sp, MR_Word *base_curfr, const char *filename, int linenumber, bool context_mismatch); -static void MR_get_list_modules_to_import(Word debugger_request, - Integer *modules_list_length_ptr, - Word *modules_list_ptr); -static void MR_get_mmc_options(Word debugger_request, - String *mmc_options_ptr); -static void MR_get_object_file_name(Word debugger_request, - String *object_file_name_ptr); -static void MR_get_variable_name(Word debugger_request, - String *var_name_ptr); +static void MR_get_list_modules_to_import(MR_Word debugger_request, + MR_Integer *modules_list_length_ptr, + MR_Word *modules_list_ptr); +static void MR_get_mmc_options(MR_Word debugger_request, + MR_String *mmc_options_ptr); +static void MR_get_object_file_name(MR_Word debugger_request, + MR_String *object_file_name_ptr); +static void MR_get_variable_name(MR_Word debugger_request, + MR_String *var_name_ptr); static void MR_trace_browse_one_external(MR_Var_Spec which_var); -static void MR_COLLECT_filter(void (*filter_ptr)(Integer, Integer, Integer, - Word, Word, String, String, String, Integer, Integer, - Word, Integer, String, Word, Word *, Char *), Unsigned seqno, +static void MR_COLLECT_filter(void (*filter_ptr)(MR_Integer, MR_Integer, MR_Integer, + MR_Word, MR_Word, MR_String, MR_String, MR_String, MR_Integer, MR_Integer, + MR_Word, MR_Integer, MR_String, MR_Word, MR_Word *, MR_Char *), Unsigned seqno, Unsigned depth, MR_Trace_Port port, const MR_Stack_Layout_Label *layout, const char *path, bool *stop_collecting); @@ -280,12 +280,12 @@ MR_trace_init_external(void) struct sockaddr_un unix_address; struct sockaddr_in inet_address; struct sockaddr* addr; - Word debugger_request; - Integer debugger_request_type; + MR_Word debugger_request; + MR_Integer debugger_request_type; /* ** MR_mmc_options contains the options to pass to mmc when compiling - ** queries. We initialize it to the String "". + ** queries. We initialize it to the MR_String "". */ MR_TRACE_CALL_MERCURY(ML_DI_init_mercury_string(&MR_mmc_options)); @@ -476,20 +476,20 @@ MR_trace_final_external(void) Code * MR_trace_event_external(MR_Trace_Cmd_Info *cmd, MR_Event_Info *event_info) { - static Word search_data; - static void (*initialize_ptr)(Word *); - static void (*filter_ptr)(Integer, Integer, Integer, Word, - Word, String, String, String, Integer, - Integer, Word, Integer, String, Word, Word *, Char *); - static void (*get_collect_var_type_ptr)(Word *); + static MR_Word search_data; + static void (*initialize_ptr)(MR_Word *); + static void (*filter_ptr)(MR_Integer, MR_Integer, MR_Integer, MR_Word, + MR_Word, MR_String, MR_String, MR_String, MR_Integer, + MR_Integer, MR_Word, MR_Integer, MR_String, MR_Word, MR_Word *, MR_Char *); + static void (*get_collect_var_type_ptr)(MR_Word *); static bool collect_linked = FALSE; bool stop_collecting = FALSE; - Integer debugger_request_type; - Word debugger_request; - Word var_list; - Word var_names_list; - Word type_list; - Word var; + MR_Integer debugger_request_type; + MR_Word debugger_request; + MR_Word var_list; + MR_Word var_names_list; + MR_Word type_list; + MR_Word var; Code *jumpaddr = NULL; MR_Event_Details event_details; const char *message; @@ -499,10 +499,10 @@ MR_trace_event_external(MR_Trace_Cmd_Info *cmd, MR_Event_Info *event_info) Unsigned depth = event_info->MR_call_depth; MR_Trace_Port port = event_info->MR_trace_port; const char *path = event_info->MR_event_path; - Word *saved_regs = event_info->MR_saved_regs; - Integer modules_list_length; - Word modules_list; - static String MR_object_file_name; + MR_Word *saved_regs = event_info->MR_saved_regs; + MR_Integer modules_list_length; + MR_Word modules_list; + static MR_String MR_object_file_name; MR_trace_enabled = FALSE; @@ -766,8 +766,8 @@ MR_trace_event_external(MR_Trace_Cmd_Info *cmd, MR_Event_Info *event_info) case MR_REQUEST_LINK_COLLECT: { - Char result; - Word MR_collecting_variable_type; + MR_Char result; + MR_Word MR_collecting_variable_type; if (MR_debug_socket) { fprintf(stderr, "\nMercury runtime: " @@ -778,10 +778,10 @@ MR_trace_event_external(MR_Trace_Cmd_Info *cmd, MR_Event_Info *event_info) MR_TRACE_CALL_MERCURY( ML_CL_link_collect( MR_object_file_name, - (Word *) &filter_ptr, - (Word *) &initialize_ptr, - (Word *) &send_collect_result_ptr, - (Word *) &get_collect_var_type_ptr, + (MR_Word *) &filter_ptr, + (MR_Word *) &initialize_ptr, + (MR_Word *) &send_collect_result_ptr, + (MR_Word *) &get_collect_var_type_ptr, &collect_lib_maybe_handle, &result )); @@ -912,19 +912,19 @@ MR_output_current_slots(const MR_Stack_Layout_Label *layout, seqno, depth, port, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_comp.MR_comp_type_name, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_comp.MR_comp_type_module, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_comp.MR_comp_def_module, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_comp.MR_comp_pred_name, layout->MR_sll_entry->MR_sle_comp.MR_comp_arity, layout->MR_sll_entry->MR_sle_comp.MR_comp_mode, layout->MR_sll_entry->MR_sle_detism, - (String) (Word) path, - (Word) &MR_debugger_socket_out); + (MR_String) (MR_Word) path, + (MR_Word) &MR_debugger_socket_out); ); } else { MR_TRACE_CALL_MERCURY( @@ -934,63 +934,63 @@ MR_output_current_slots(const MR_Stack_Layout_Label *layout, depth, port, layout->MR_sll_entry->MR_sle_user.MR_user_pred_or_func, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_user.MR_user_decl_module, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_user.MR_user_def_module, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_user.MR_user_name, layout->MR_sll_entry->MR_sle_user.MR_user_arity, layout->MR_sll_entry->MR_sle_user.MR_user_mode, layout->MR_sll_entry->MR_sle_detism, - (String) (Word) path, - (Word) &MR_debugger_socket_out); + (MR_String) (MR_Word) path, + (MR_Word) &MR_debugger_socket_out); ); } } static void -MR_output_current_vars(Word var_list, Word string_list) +MR_output_current_vars(MR_Word var_list, MR_Word string_list) { MR_TRACE_CALL_MERCURY( ML_DI_output_current_vars( var_list, string_list, - (Word) &MR_debugger_socket_out); + (MR_Word) &MR_debugger_socket_out); ); } static void -MR_output_current_nth_var(Word var) +MR_output_current_nth_var(MR_Word var) { MR_TRACE_CALL_MERCURY( ML_DI_output_current_nth_var( var, - (Word) &MR_debugger_socket_out); + (MR_Word) &MR_debugger_socket_out); ); } static void -MR_output_current_live_var_names(Word var_names_list, Word type_list) +MR_output_current_live_var_names(MR_Word var_names_list, MR_Word type_list) { MR_TRACE_CALL_MERCURY( ML_DI_output_current_live_var_names( var_names_list, type_list, - (Word) &MR_debugger_socket_out); + (MR_Word) &MR_debugger_socket_out); ); } static void MR_read_request_from_socket( - Word *debugger_request_ptr, - Integer *debugger_request_type_ptr) + MR_Word *debugger_request_ptr, + MR_Integer *debugger_request_type_ptr) { fflush(MR_debugger_socket_in.file); MR_TRACE_CALL_MERCURY( ML_DI_read_request_from_socket( - (Word) &MR_debugger_socket_in, + (MR_Word) &MR_debugger_socket_in, debugger_request_ptr, debugger_request_type_ptr); ); @@ -1000,12 +1000,12 @@ static bool MR_found_match(const MR_Stack_Layout_Label *layout, MR_Trace_Port port, Unsigned seqno, Unsigned depth, /* XXX live vars */ - const char *path, Word search_data) + const char *path, MR_Word search_data) { bool result; /* XXX get live vars from registers */ - Word arguments = /* XXX FIXME!!! */ 0; + MR_Word arguments = /* XXX FIXME!!! */ 0; if (MR_ENTRY_LAYOUT_COMPILER_GENERATED(layout->MR_sll_entry)) { MR_TRACE_CALL_MERCURY( result = ML_DI_found_match_comp( @@ -1013,19 +1013,19 @@ MR_found_match(const MR_Stack_Layout_Label *layout, seqno, depth, port, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_comp.MR_comp_type_name, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_comp.MR_comp_type_module, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_comp.MR_comp_def_module, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_comp.MR_comp_pred_name, layout->MR_sll_entry->MR_sle_comp.MR_comp_arity, layout->MR_sll_entry->MR_sle_comp.MR_comp_mode, layout->MR_sll_entry->MR_sle_detism, arguments, - (String) (Word) path, + (MR_String) (MR_Word) path, search_data); ); } else { @@ -1036,17 +1036,17 @@ MR_found_match(const MR_Stack_Layout_Label *layout, depth, port, layout->MR_sll_entry->MR_sle_user.MR_user_pred_or_func, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_user.MR_user_decl_module, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_user.MR_user_def_module, - (String) + (MR_String) layout->MR_sll_entry->MR_sle_user.MR_user_name, layout->MR_sll_entry->MR_sle_user.MR_user_arity, layout->MR_sll_entry->MR_sle_user.MR_user_mode, layout->MR_sll_entry->MR_sle_detism, arguments, - (String) path, + (MR_String) path, search_data); ); } @@ -1082,16 +1082,16 @@ MR_send_message_to_socket(const char *message) ** are no live variables, return the empty list. */ -static Word +static MR_Word MR_trace_make_var_list(void) { const char *problem; int var_count; int i; MR_TypeInfo type_info; - Word value; - Word univ; - Word var_list; + MR_Word value; + MR_Word univ; + MR_Word var_list; var_count = MR_trace_var_count(); @@ -1111,7 +1111,7 @@ MR_trace_make_var_list(void) ); MR_field(MR_mktag(0), univ, UNIV_OFFSET_FOR_TYPEINFO) - = (Word) type_info; + = (MR_Word) type_info; MR_field(MR_mktag(0), univ, UNIV_OFFSET_FOR_DATA) = value; MR_TRACE_USE_HP( @@ -1131,14 +1131,14 @@ MR_trace_make_var_list(void) ** are no live variables, return the empty list. */ -static Word +static MR_Word MR_trace_make_var_names_list(void) { const char *problem; int var_count; int i; const char *name; - Word var_names_list; + MR_Word var_names_list; var_count = MR_trace_var_count(); @@ -1168,15 +1168,15 @@ MR_trace_make_var_names_list(void) ** are no live variables, return the empty list. */ -static Word +static MR_Word MR_trace_make_type_list(void) { const char *problem; int var_count; int i; MR_TypeInfo type_info; - String type_info_string; - Word type_list; + MR_String type_info_string; + MR_Word type_list; var_count = MR_trace_var_count(); @@ -1191,7 +1191,7 @@ MR_trace_make_type_list(void) } MR_TRACE_CALL_MERCURY( - type_info_string = ML_type_name((Word) type_info); + type_info_string = ML_type_name((MR_Word) type_info); ); MR_TRACE_USE_HP( type_list = MR_list_cons(type_info_string, type_list); @@ -1206,14 +1206,14 @@ MR_trace_make_type_list(void) ** Any memory needed will be allocated on the Mercury heap. */ -static Word -MR_trace_make_nth_var(Word debugger_request) +static MR_Word +MR_trace_make_nth_var(MR_Word debugger_request) { const char *problem; int var_number; MR_TypeInfo type_info; - Word value; - Word univ; + MR_Word value; + MR_Word univ; var_number = MR_get_var_number(debugger_request); /* debugger_request should be of the form: @@ -1226,7 +1226,7 @@ MR_trace_make_nth_var(Word debugger_request) &type_info, &value); if (problem == NULL) { MR_field(MR_mktag(0), univ, UNIV_OFFSET_FOR_TYPEINFO) - = (Word) type_info; + = (MR_Word) type_info; MR_field(MR_mktag(0), univ, UNIV_OFFSET_FOR_DATA) = value; } else { /* @@ -1245,7 +1245,7 @@ MR_trace_make_nth_var(Word debugger_request) */ static int -MR_get_var_number(Word debugger_request) +MR_get_var_number(MR_Word debugger_request) { int num; MR_TRACE_CALL_MERCURY( @@ -1284,7 +1284,7 @@ MR_get_var_number(Word debugger_request) static void MR_dump_stack_record_print_to_socket(FILE *fp, const MR_Stack_Layout_Entry *entry_layout, int count, int start_level, - Word *base_sp, Word *base_curfr, const char *filename, int linenumber, + MR_Word *base_sp, MR_Word *base_curfr, const char *filename, int linenumber, bool context_mismatch) { MR_send_message_to_socket_format("level(%d).\n", start_level); @@ -1293,7 +1293,7 @@ MR_dump_stack_record_print_to_socket(FILE *fp, static void MR_print_proc_id_to_socket(const MR_Stack_Layout_Entry *entry, - const char *extra, Word *base_sp, Word *base_curfr) + const char *extra, MR_Word *base_sp, MR_Word *base_curfr) { if (! MR_ENTRY_LAYOUT_HAS_PROC_ID(entry)) { MR_fatal_error("cannot retrieve procedure id without layout"); @@ -1302,7 +1302,7 @@ MR_print_proc_id_to_socket(const MR_Stack_Layout_Entry *entry, if (base_sp != NULL && base_curfr != NULL) { bool print_details = FALSE; if (MR_ENTRY_LAYOUT_HAS_EXEC_TRACE(entry)) { - Integer maybe_from_full = + MR_Integer maybe_from_full = entry->MR_sle_maybe_from_full; if (maybe_from_full > 0) { /* @@ -1400,8 +1400,8 @@ MR_print_proc_id_to_socket(const MR_Stack_Layout_Entry *entry, } static void -MR_get_list_modules_to_import(Word debugger_request, - Integer *modules_list_length_ptr, Word *modules_list_ptr) +MR_get_list_modules_to_import(MR_Word debugger_request, + MR_Integer *modules_list_length_ptr, MR_Word *modules_list_ptr) { MR_TRACE_CALL_MERCURY( ML_DI_get_list_modules_to_import( @@ -1412,7 +1412,7 @@ MR_get_list_modules_to_import(Word debugger_request, } static void -MR_get_mmc_options(Word debugger_request, String *mmc_options_ptr) +MR_get_mmc_options(MR_Word debugger_request, MR_String *mmc_options_ptr) { MR_TRACE_CALL_MERCURY( ML_DI_get_mmc_options( @@ -1422,7 +1422,7 @@ MR_get_mmc_options(Word debugger_request, String *mmc_options_ptr) } static void -MR_get_object_file_name(Word debugger_request, String *object_file_name_ptr) +MR_get_object_file_name(MR_Word debugger_request, MR_String *object_file_name_ptr) { MR_TRACE_CALL_MERCURY( ML_DI_get_object_file_name( @@ -1432,7 +1432,7 @@ MR_get_object_file_name(Word debugger_request, String *object_file_name_ptr) } static void -MR_get_variable_name(Word debugger_request, String *var_name_ptr) +MR_get_variable_name(MR_Word debugger_request, MR_String *var_name_ptr) { MR_TRACE_CALL_MERCURY( ML_DI_get_variable_name( @@ -1467,14 +1467,14 @@ MR_trace_browse_one_external(MR_Var_Spec var_spec) ** and dynamically link with the execution. */ static void -MR_COLLECT_filter(void (*filter_ptr)(Integer, Integer, Integer, Word, Word, - String, String, String, Integer, Integer, Word, Integer, String, Word, - Word *, Char *), Unsigned seqno, Unsigned depth, MR_Trace_Port port, +MR_COLLECT_filter(void (*filter_ptr)(MR_Integer, MR_Integer, MR_Integer, MR_Word, MR_Word, + MR_String, MR_String, MR_String, MR_Integer, MR_Integer, MR_Word, MR_Integer, MR_String, MR_Word, + MR_Word *, MR_Char *), Unsigned seqno, Unsigned depth, MR_Trace_Port port, const MR_Stack_Layout_Label *layout, const char *path, bool *stop_collecting) { - Char result; - Word arguments; + MR_Char result; + MR_Word arguments; /* ** Only pass the arguments list down filter @@ -1498,14 +1498,14 @@ MR_COLLECT_filter(void (*filter_ptr)(Integer, Integer, Integer, Word, Word, depth, port, layout->MR_sll_entry->MR_sle_user.MR_user_pred_or_func, - (String) layout->MR_sll_entry->MR_sle_user.MR_user_decl_module, - (String) layout->MR_sll_entry->MR_sle_user.MR_user_def_module, - (String) layout->MR_sll_entry->MR_sle_user.MR_user_name, + (MR_String) layout->MR_sll_entry->MR_sle_user.MR_user_decl_module, + (MR_String) layout->MR_sll_entry->MR_sle_user.MR_user_def_module, + (MR_String) layout->MR_sll_entry->MR_sle_user.MR_user_name, layout->MR_sll_entry->MR_sle_user.MR_user_arity, layout->MR_sll_entry->MR_sle_user.MR_user_mode, arguments, layout->MR_sll_entry->MR_sle_detism, - (String) path, + (MR_String) path, MR_collecting_variable, &MR_collecting_variable, &result)); @@ -1518,7 +1518,7 @@ MR_send_collect_result(void) MR_TRACE_CALL_MERCURY( (*send_collect_result_ptr)( MR_collecting_variable, - (Word) &MR_debugger_socket_out)); + (MR_Word) &MR_debugger_socket_out)); #if defined(HAVE_DLFCN_H) && defined(HAVE_DLCLOSE) MR_TRACE_CALL_MERCURY( ML_CL_unlink_collect(collect_lib_maybe_handle)); diff --git a/trace/mercury_trace_help.c b/trace/mercury_trace_help.c index 7eafedb64..4e7dd11a4 100644 --- a/trace/mercury_trace_help.c +++ b/trace/mercury_trace_help.c @@ -41,18 +41,18 @@ #include -static Word MR_trace_help_system; +static MR_Word MR_trace_help_system; static MR_TypeInfo MR_trace_help_system_type; -static Word MR_trace_help_stdout; +static MR_Word MR_trace_help_stdout; -static const char *MR_trace_help_add_node(Word path, const char *name, +static const char *MR_trace_help_add_node(MR_Word path, const char *name, int slot, const char *text); static void MR_trace_help_ensure_init(void); const char * MR_trace_add_cat(const char *category, int slot, const char *text) { - Word path; + MR_Word path; MR_trace_help_ensure_init(); MR_TRACE_USE_HP( @@ -65,7 +65,7 @@ const char * MR_trace_add_item(const char *category, const char *item, int slot, const char *text) { - Word path; + MR_Word path; char *category_on_heap; const char *result; @@ -81,9 +81,9 @@ MR_trace_add_item(const char *category, const char *item, int slot, } static const char * -MR_trace_help_add_node(Word path, const char *name, int slot, const char *text) +MR_trace_help_add_node(MR_Word path, const char *name, int slot, const char *text) { - Word result; + MR_Word result; char *msg; char *name_on_heap; char *text_on_heap; @@ -137,8 +137,8 @@ MR_trace_help_word(const char *word) void MR_trace_help_cat_item(const char *category, const char *item) { - Word path; - Word result; + MR_Word path; + MR_Word result; char *msg; char *category_on_heap; char *item_on_heap; @@ -168,9 +168,9 @@ static void MR_trace_help_ensure_init(void) { static bool done = FALSE; - Word typeinfo_type; - Word output_stream_type; - Word MR_trace_help_system_type_word; + MR_Word typeinfo_type; + MR_Word output_stream_type; + MR_Word MR_trace_help_system_type_word; if (! done) { MR_TRACE_CALL_MERCURY( @@ -185,7 +185,7 @@ MR_trace_help_ensure_init(void) ); MR_trace_help_system_type = (MR_TypeInfo) MR_make_permanent( - (Word) MR_trace_help_system_type, + (MR_Word) MR_trace_help_system_type, (MR_TypeInfo) typeinfo_type); MR_trace_help_system = MR_make_permanent(MR_trace_help_system, MR_trace_help_system_type); diff --git a/trace/mercury_trace_internal.c b/trace/mercury_trace_internal.c index f5b66a10e..0b7ff70b2 100644 --- a/trace/mercury_trace_internal.c +++ b/trace/mercury_trace_internal.c @@ -151,10 +151,10 @@ static MR_Next MR_trace_handle_cmd(char **words, int word_count, MR_Trace_Cmd_Info *cmd, MR_Event_Info *event_info, MR_Event_Details *event_details, Code **jumpaddr); static bool MR_parse_source_locn(char *word, const char **file, int *line); -static void MR_print_stack_regs(Word *saved_regs); -static void MR_print_heap_regs(Word *saved_regs); -static void MR_print_tabling_regs(Word *saved_regs); -static void MR_print_succip_reg(Word *saved_regs); +static void MR_print_stack_regs(MR_Word *saved_regs); +static void MR_print_heap_regs(MR_Word *saved_regs); +static void MR_print_tabling_regs(MR_Word *saved_regs); +static void MR_print_succip_reg(MR_Word *saved_regs); static bool MR_trace_options_strict_print(MR_Trace_Cmd_Info *cmd, char ***words, int *word_count, const char *cat, const char *item); @@ -174,8 +174,8 @@ static void MR_trace_do_noop(void); static void MR_trace_set_level_and_report(int ancestor_level, bool detailed); -static void MR_trace_print_var(Word type_info, Word value); -static void MR_trace_browse_var(Word type_info, Word value); +static void MR_trace_print_var(MR_Word type_info, MR_Word value); +static void MR_trace_browse_var(MR_Word type_info, MR_Word value); static const char *MR_trace_browse_exception(MR_Event_Info *event_info, MR_Browser browser); @@ -379,8 +379,8 @@ MR_trace_set_level_and_report(int ancestor_level, bool detailed) { const char *problem; const MR_Stack_Layout_Entry *entry; - Word *base_sp; - Word *base_curfr; + MR_Word *base_sp; + MR_Word *base_curfr; const char *filename; int lineno; int indent; @@ -410,7 +410,7 @@ MR_trace_set_level_and_report(int ancestor_level, bool detailed) } static void -MR_trace_print_var(Word type_info, Word value) +MR_trace_print_var(MR_Word type_info, MR_Word value) { fprintf(MR_mdb_out, "\t"); fflush(MR_mdb_out); @@ -419,7 +419,7 @@ MR_trace_print_var(Word type_info, Word value) } static void -MR_trace_browse_var(Word type_info, Word value) +MR_trace_browse_var(MR_Word type_info, MR_Word value) { /* XXX should use MR_mdb_in and MR_mdb_out */ MR_trace_browse(type_info, value); @@ -428,16 +428,16 @@ MR_trace_browse_var(Word type_info, Word value) static const char * MR_trace_browse_exception(MR_Event_Info *event_info, MR_Browser browser) { - Word type_info; - Word value; - Word exception; + MR_Word type_info; + MR_Word value; + MR_Word exception; if (event_info->MR_trace_port != MR_PORT_EXCEPTION) { return "command only available from EXCP ports"; } exception = MR_trace_get_exception_value(); - if (exception == (Word) NULL) { + if (exception == (MR_Word) NULL) { return "missing exception value"; } @@ -559,7 +559,7 @@ MR_trace_handle_cmd(char **words, int word_count, MR_Trace_Cmd_Info *cmd, Code **jumpaddr) { const MR_Stack_Layout_Label *layout; - Word *saved_regs; + MR_Word *saved_regs; layout = event_info->MR_event_sll; saved_regs = event_info->MR_saved_regs; @@ -1696,7 +1696,7 @@ MR_parse_source_locn(char *word, const char **file, int *line) } static void -MR_print_stack_regs(Word *saved_regs) +MR_print_stack_regs(MR_Word *saved_regs) { fprintf(MR_mdb_out, "sp = "); MR_print_detstackptr(MR_mdb_out, @@ -1711,7 +1711,7 @@ MR_print_stack_regs(Word *saved_regs) } static void -MR_print_heap_regs(Word *saved_regs) +MR_print_heap_regs(MR_Word *saved_regs) { fprintf(MR_mdb_out, "hp = "); MR_print_heapptr(MR_mdb_out, @@ -1729,7 +1729,7 @@ MR_print_heap_regs(Word *saved_regs) } static void -MR_print_tabling_regs(Word *saved_regs) +MR_print_tabling_regs(MR_Word *saved_regs) { fprintf(MR_mdb_out, "gen_next = %ld\n", (long) MR_saved_gen_next(saved_regs)); @@ -1738,7 +1738,7 @@ MR_print_tabling_regs(Word *saved_regs) } static void -MR_print_succip_reg(Word *saved_regs) +MR_print_succip_reg(MR_Word *saved_regs) { fprintf(MR_mdb_out, "succip = "); MR_print_label(MR_mdb_out, @@ -2394,7 +2394,7 @@ MR_trace_event_print_internal_report(MR_Event_Info *event_info) const char *filename, *parent_filename; int lineno, parent_lineno; const char *problem; /* not used */ - Word *base_sp, *base_curfr; + MR_Word *base_sp, *base_curfr; int indent; lineno = 0; diff --git a/trace/mercury_trace_spy.c b/trace/mercury_trace_spy.c index 313ecca99..5e838b52a 100644 --- a/trace/mercury_trace_spy.c +++ b/trace/mercury_trace_spy.c @@ -168,8 +168,8 @@ MR_event_matches_spy_point(const MR_Stack_Layout_Label *layout, MR_Spy_Action action; const MR_Stack_Layout_Label *parent; const char *problem; - Word *base_sp; - Word *base_curfr; + MR_Word *base_sp; + MR_Word *base_curfr; enabled = FALSE; action = MR_SPY_PRINT; @@ -400,8 +400,8 @@ MR_compare_spied_labels(const void *l1, const void *l2) label1 = (const MR_Spied_Label *) l1; label2 = (const MR_Spied_Label *) l2; - return (int) ((Integer) label1->spy_label - - (Integer) label2->spy_label); + return (int) ((MR_Integer) label1->spy_label + - (MR_Integer) label2->spy_label); } void diff --git a/trace/mercury_trace_vars.c b/trace/mercury_trace_vars.c index c2e89a45c..aae5465af 100644 --- a/trace/mercury_trace_vars.c +++ b/trace/mercury_trace_vars.c @@ -57,7 +57,7 @@ typedef struct { bool MR_var_is_ambiguous; int MR_var_hlds_number; MR_TypeInfo MR_var_type; - Word MR_var_value; + MR_Word MR_var_value; } MR_Var_Details; /* @@ -92,15 +92,15 @@ typedef struct { typedef struct { const MR_Stack_Layout_Label *MR_point_top_layout; - Word *MR_point_top_saved_regs; + MR_Word *MR_point_top_saved_regs; MR_Trace_Port MR_point_top_port; const char *MR_point_problem; int MR_point_level; const MR_Stack_Layout_Entry *MR_point_level_entry; const char *MR_point_level_filename; int MR_point_level_linenumber; - Word *MR_point_level_base_sp; - Word *MR_point_level_base_curfr; + MR_Word *MR_point_level_base_sp; + MR_Word *MR_point_level_base_curfr; int MR_point_var_count; int MR_point_var_max; MR_Var_Details *MR_point_vars; @@ -205,7 +205,7 @@ MR_trace_type_is_ignored(MR_PseudoTypeInfo pseudo_type_info) type_ctor_info = MR_PSEUDO_TYPEINFO_GET_TYPE_CTOR_INFO(pseudo_type_info); ignore_type_ctor_count = - sizeof(MR_trace_ignored_type_ctors) / sizeof(Word *); + sizeof(MR_trace_ignored_type_ctors) / sizeof(MR_Word *); for (i = 0; i < ignore_type_ctor_count; i++) { if (type_ctor_info == MR_trace_ignored_type_ctors[i]) { @@ -218,7 +218,7 @@ MR_trace_type_is_ignored(MR_PseudoTypeInfo pseudo_type_info) void MR_trace_init_point_vars(const MR_Stack_Layout_Label *top_layout, - Word *saved_regs, MR_Trace_Port port) + MR_Word *saved_regs, MR_Trace_Port port) { MR_point.MR_point_top_layout = top_layout; MR_point.MR_point_top_saved_regs = saved_regs; @@ -231,17 +231,17 @@ const char * MR_trace_set_level(int ancestor_level) { const char *problem; - Word *base_sp; - Word *base_curfr; + MR_Word *base_sp; + MR_Word *base_curfr; const MR_Stack_Layout_Label *top_layout; const MR_Stack_Layout_Label *level_layout; const MR_Stack_Layout_Entry *entry; const MR_Stack_Layout_Vars *vars; const MR_Var_Name *var_info; - Word *valid_saved_regs; + MR_Word *valid_saved_regs; int var_count; MR_TypeInfo *type_params; - Word value; + MR_Word value; MR_TypeInfo type_info; MR_PseudoTypeInfo pseudo_type_info; int i; @@ -252,7 +252,7 @@ MR_trace_set_level(int ancestor_level) char *s; const char *name; const char *string_table; - Integer string_table_size; + MR_Integer string_table_size; const char *filename; int linenumber; @@ -524,7 +524,7 @@ MR_trace_current_level(void) void MR_trace_current_level_details(const MR_Stack_Layout_Entry **entry_ptr, const char **filename_ptr, int *linenumber_ptr, - Word **base_sp_ptr, Word **base_curfr_ptr) + MR_Word **base_sp_ptr, MR_Word **base_curfr_ptr) { if (MR_point.MR_point_problem != NULL) { MR_fatal_error("cannot get details about current level"); @@ -581,7 +581,7 @@ MR_trace_list_vars(FILE *out) const char * MR_trace_return_var_info(int var_number, const char **name_ptr, - MR_TypeInfo *type_info_ptr, Word *value_ptr) + MR_TypeInfo *type_info_ptr, MR_Word *value_ptr) { const MR_Var_Details *details; const char *problem; @@ -820,8 +820,8 @@ MR_trace_browse_all(FILE *out, MR_Browser browser) } /* ML_arg() is defined in std_util.m */ -extern bool ML_arg(MR_TypeInfo term_type_info, Word *term, int arg_index, - MR_TypeInfo *arg_type_info_ptr, Word **arg_ptr); +extern bool ML_arg(MR_TypeInfo term_type_info, MR_Word *term, int arg_index, + MR_TypeInfo *arg_type_info_ptr, MR_Word **arg_ptr); static char * MR_trace_browse_var(FILE *out, MR_Var_Details *var, char *path, @@ -829,8 +829,8 @@ MR_trace_browse_var(FILE *out, MR_Var_Details *var, char *path, { MR_TypeInfo typeinfo; MR_TypeInfo new_typeinfo; - Word *value; - Word *new_value; + MR_Word *value; + MR_Word *new_value; char *old_path; int arg_num; int len; @@ -885,7 +885,7 @@ MR_trace_browse_var(FILE *out, MR_Var_Details *var, char *path, fflush(out); } - (*browser)((Word) typeinfo, *value); + (*browser)((MR_Word) typeinfo, *value); return NULL; } diff --git a/trace/mercury_trace_vars.h b/trace/mercury_trace_vars.h index 0ee241010..740962b6f 100644 --- a/trace/mercury_trace_vars.h +++ b/trace/mercury_trace_vars.h @@ -39,7 +39,7 @@ #include "mercury_types.h" #include "mercury_stack_layout.h" -typedef void (*MR_Browser)(Word type_info, Word value); +typedef void (*MR_Browser)(MR_Word type_info, MR_Word value); typedef enum { MR_VAR_SPEC_NUMBER, @@ -54,13 +54,13 @@ typedef struct { extern void MR_trace_init_point_vars( const MR_Stack_Layout_Label *top_layout, - Word *saved_regs, MR_Trace_Port port); + MR_Word *saved_regs, MR_Trace_Port port); extern const char *MR_trace_set_level(int ancestor_level); extern int MR_trace_current_level(void); extern void MR_trace_current_level_details( const MR_Stack_Layout_Entry **entry_ptr, const char **filename_ptr, int *linenumber_ptr, - Word **base_sp_ptr, Word **base_curfr_ptr); + MR_Word **base_sp_ptr, MR_Word **base_curfr_ptr); /* ** Return the number of live variables at the current point. If the required @@ -83,7 +83,7 @@ extern const char *MR_trace_list_vars(FILE *out); */ extern const char *MR_trace_return_var_info(int n, const char **name_ptr, - MR_TypeInfo *type_info_ptr, Word *value_ptr); + MR_TypeInfo *type_info_ptr, MR_Word *value_ptr); /* ** If the variable specified by n is a head variable, then store