diff --git a/src/c/all_symbols.d b/src/c/all_symbols.d
index 986c3e879..ecf513576 100644
--- a/src/c/all_symbols.d
+++ b/src/c/all_symbols.d
@@ -80,8 +80,8 @@ mangle_name(cl_object output, unsigned char *source, int l)
 	cl_object output;
 	cl_object package;
 	cl_object found = Cnil;
-	cl_object maxarg = MAKE_FIXNUM(CALL_ARGUMENTS_LIMIT);
-	cl_object minarg = MAKE_FIXNUM(0);
+	cl_object maxarg = ecl_make_fixnum(CALL_ARGUMENTS_LIMIT);
+	cl_object minarg = ecl_make_fixnum(0);
 	bool is_symbol;
 	cl_object name;
 @
@@ -98,7 +98,7 @@ mangle_name(cl_object output, unsigned char *source, int l)
 			found = Ct;
 			output = cl_format(4, Cnil,
 					   make_constant_base_string("ECL_SYM(~S,~D)"),
-					   name, MAKE_FIXNUM(p));
+					   name, ecl_make_fixnum(p));
 			@(return found output maxarg)
 		}
 	} else if (!Null(symbol)) {
@@ -112,7 +112,7 @@ mangle_name(cl_object output, unsigned char *source, int l)
 					found = Ct;
 					if (fun->cfun.narg >= 0) {
 					    minarg =
-					    maxarg = MAKE_FIXNUM(fun->cfun.narg);
+					    maxarg = ecl_make_fixnum(fun->cfun.narg);
 					}
 					break;
 				}
diff --git a/src/c/alloc.d b/src/c/alloc.d
index d50a56240..63e3957c1 100644
--- a/src/c/alloc.d
+++ b/src/c/alloc.d
@@ -234,7 +234,7 @@ ecl_alloc_object(cl_type t)
 	case t_fixnum:
 	  return MAKE_FIXNUM(0); /* Immediate fixnum */
 	case t_character:
-	  return CODE_CHAR('\0'); /* Immediate character */
+	  return ECL_CODE_CHAR('\0'); /* Immediate character */
 	default:;
 	}
 
diff --git a/src/c/alloc_2.d b/src/c/alloc_2.d
index 17cd3150e..9befc02b3 100644
--- a/src/c/alloc_2.d
+++ b/src/c/alloc_2.d
@@ -189,10 +189,10 @@ ecl_object_byte_size(cl_type t)
 {
         if (t == t_fixnum || t == t_character)
                 FEerror("ecl_object_byte_size invoked with an immediate type ~D",
-                        1, MAKE_FIXNUM(1));
+                        1, ecl_make_fixnum(1));
         if (t >= t_end)
                 FEerror("ecl_object_byte_size invoked with an unkown type ~D",
-                        1, MAKE_FIXNUM(1));
+                        1, ecl_make_fixnum(1));
         return type_info[t].size;
 }
 
@@ -277,7 +277,7 @@ allocate_object_own(register struct ecl_type_information *type_info)
 #endif /* GBC_BOEHM_OWN_ALLOCATOR */
 
 #ifdef GBC_BOEHM_OWN_MARKER
-#define IGNORABLE_POINTER(obj) (IMMEDIATE(obj) & 2)
+#define IGNORABLE_POINTER(obj) (ECL_IMMEDIATE(obj) & 2)
 #define GC_MARK_AND_PUSH(obj, msp, lim, src) \
         ((!IGNORABLE_POINTER(obj) &&				      \
 	  (GC_word)obj >= (GC_word)GC_least_plausible_heap_addr &&    \
@@ -540,9 +540,9 @@ ecl_alloc_object(cl_type t)
 	/* GC_MALLOC already resets objects */
 	switch (t) {
 	case t_fixnum:
-		return MAKE_FIXNUM(0); /* Immediate fixnum */
+		return ecl_make_fixnum(0); /* Immediate fixnum */
 	case t_character:
-		return CODE_CHAR(' '); /* Immediate character */
+		return ECL_CODE_CHAR(' '); /* Immediate character */
 #ifdef ECL_SSE2
 	case t_sse_pack:
 #endif
@@ -1113,7 +1113,7 @@ standard_finalizer(cl_object o)
 # endif
         case t_symbol: {
 		ecl_atomic_push(&cl_core.reused_indices,
-				MAKE_FIXNUM(o->symbol.binding));
+				ecl_make_fixnum(o->symbol.binding));
         }
 #endif /* ECL_THREADS */
 	default:;
@@ -1193,8 +1193,8 @@ cl_object
 si_gc_stats(cl_object enable)
 {
 	cl_object old_status;
-        cl_object size1 = MAKE_FIXNUM(0);
-        cl_object size2 = MAKE_FIXNUM(0);
+        cl_object size1 = ecl_make_fixnum(0);
+        cl_object size2 = ecl_make_fixnum(0);
         if (cl_core.gc_stats == 0) {
                 old_status = Cnil;
         } else if (GC_print_stats) {
@@ -1215,7 +1215,7 @@ si_gc_stats(cl_object enable)
         if (enable == Cnil) {
                 GC_print_stats = 0;
                 cl_core.gc_stats = 0;
-        } else if (enable == MAKE_FIXNUM(0)) {
+        } else if (enable == ecl_make_fixnum(0)) {
                 mpz_set_ui(cl_core.bytes_consed->big.big_num, 0);
                 mpz_set_ui(cl_core.gc_counter->big.big_num, 0);
         } else {
@@ -1380,7 +1380,7 @@ ecl_alloc_weak_pointer(cl_object o)
 	ecl_enable_interrupts_env(the_env);
 	obj->t = t_weak_pointer;
 	obj->value = o;
-        if (!FIXNUMP(o) && !CHARACTERP(o) && !Null(o)) {
+        if (!ECL_FIXNUMP(o) && !ECL_CHARACTERP(o) && !Null(o)) {
                 GC_general_register_disappearing_link((void**)&(obj->value), (void*)o);
                 si_set_finalizer((cl_object)obj, Ct);
         }
diff --git a/src/c/arch/ffi_x86.d b/src/c/arch/ffi_x86.d
index 3ec2c1534..6926bc8b2 100644
--- a/src/c/arch/ffi_x86.d
+++ b/src/c/arch/ffi_x86.d
@@ -191,7 +191,7 @@ ecl_dynamic_callback_execute(cl_object cbk_info, char *arg_buffer)
 	arg_buffer += 4; /* Skip return address */
 	for (i=0; !ecl_endp(argtypes); argtypes = CDR(argtypes), i++) {
 		tag = ecl_foreign_type_code(CAR(argtypes));
-		size = fix(si_size_of_foreign_elt_type(CAR(argtypes)));
+		size = ecl_fix(si_size_of_foreign_elt_type(CAR(argtypes)));
 		result = ecl_foreign_data_ref_elt(arg_buffer, tag);
 		ecl_stack_frame_push(frame,result);
 		{
@@ -325,7 +325,7 @@ ecl_dynamic_callback_make(cl_object data, enum ecl_ffi_calling_convention cc_typ
 		int mask = 3;
 
 		while (CONSP(arg_types)) {
-			int sz = fix(si_size_of_foreign_elt_type(CAR(arg_types)));
+			int sz = ecl_fix(si_size_of_foreign_elt_type(CAR(arg_types)));
 			byte_size += ((sz+mask)&(~mask));
 			arg_types = CDR(arg_types);
 		}
diff --git a/src/c/arch/ffi_x86_64.d b/src/c/arch/ffi_x86_64.d
index 8aeabd9cb..8c6f77211 100644
--- a/src/c/arch/ffi_x86_64.d
+++ b/src/c/arch/ffi_x86_64.d
@@ -246,7 +246,7 @@ ecl_dynamic_callback_execute(long i1, long i2, long i3, long i4, long i5, long i
 	arg_buffer += 2*sizeof(void*); /* Skip return address and base pointer */
 	for (i=0; !ecl_endp(argtypes); argtypes = CDR(argtypes), i++) {
 		tag = ecl_foreign_type_code(CAR(argtypes));
-		size = fix(si_size_of_foreign_elt_type(CAR(argtypes)));
+		size = ecl_fix(si_size_of_foreign_elt_type(CAR(argtypes)));
 		if (tag <= ECL_FFI_OBJECT) {
 			if (i_reg_index < MAX_INT_REGISTERS)
 				result = ecl_foreign_data_ref_elt(&i_reg[i_reg_index++], tag);
diff --git a/src/c/array.d b/src/c/array.d
index 7b52fd4f2..44774a642 100644
--- a/src/c/array.d
+++ b/src/c/array.d
@@ -63,15 +63,15 @@ FEbad_aet()
 static cl_index
 out_of_bounds_error(cl_index ndx, cl_object x)
 {
-	cl_object type = cl_list(3, @'integer', MAKE_FIXNUM(0),
-                                 MAKE_FIXNUM(x->array.dim));
+	cl_object type = cl_list(3, @'integer', ecl_make_fixnum(0),
+                                 ecl_make_fixnum(x->array.dim));
         FEwrong_type_argument(ecl_make_integer(ndx), type);
 }
 
 void
 FEwrong_dimensions(cl_object a, cl_index rank)
 {
-        cl_object list = cl_make_list(3, MAKE_FIXNUM(rank),
+        cl_object list = cl_make_list(3, ecl_make_fixnum(rank),
                                       @':initial-element', @'*');
         cl_object type = cl_list(3, @'array', @'*', list);
         FEwrong_type_argument(type, a);
@@ -84,7 +84,7 @@ checked_index(cl_object function, cl_object a, int which, cl_object index,
         cl_index output;
         unlikely_if (!ECL_FIXNUMP(index) || ecl_fixnum_minusp(index))
                 FEwrong_index(function, a, which, index, nonincl_limit);
-        output = fix(index);
+        output = ecl_fix(index);
         unlikely_if (output >= nonincl_limit)
                 FEwrong_index(function, a, which, index, nonincl_limit);
         return output;
@@ -95,7 +95,7 @@ ecl_to_index(cl_object n)
 {
 	switch (type_of(n)) {
 	case t_fixnum: {
-		cl_fixnum out = fix(n);
+		cl_fixnum out = ecl_fix(n);
 		if (out < 0 || out >= ADIMLIM)
 			FEtype_error_index(Cnil, out);
 		return out;
@@ -157,17 +157,17 @@ ecl_aref_unsafe(cl_object x, cl_index index)
 	case aet_object:
 		return x->array.self.t[index];
 	case aet_bc:
-		return CODE_CHAR(x->base_string.self[index]);
+		return ECL_CODE_CHAR(x->base_string.self[index]);
 #ifdef ECL_UNICODE
 	case aet_ch:
-                return CODE_CHAR(x->string.self[index]);
+                return ECL_CODE_CHAR(x->string.self[index]);
 #endif
 	case aet_bit:
 		index += x->vector.offset;
 		if (x->vector.self.bit[index/CHAR_BIT] & (0200>>index%CHAR_BIT))
-			return(MAKE_FIXNUM(1));
+			return(ecl_make_fixnum(1));
 		else
-			return(MAKE_FIXNUM(0));
+			return(ecl_make_fixnum(0));
 	case aet_fix:
 		return ecl_make_integer(x->array.self.fix[index]);
 	case aet_index:
@@ -210,7 +210,7 @@ ecl_aref(cl_object x, cl_index index)
                 FEwrong_type_nth_arg(@[aref], 1, x, @[array]);
         }
         if (ecl_unlikely(index >= x->array.dim)) {
-                FEwrong_index(@[row-major-aref], x, -1, MAKE_FIXNUM(index),
+                FEwrong_index(@[row-major-aref], x, -1, ecl_make_fixnum(index),
                               x->array.dim);
         }
         return ecl_aref_unsafe(x, index);
@@ -223,7 +223,7 @@ ecl_aref1(cl_object x, cl_index index)
                 FEwrong_type_nth_arg(@[aref], 1, x, @[array]);
         }
         if (ecl_unlikely(index >= x->array.dim)) {
-                FEwrong_index(@[aref], x, -1, MAKE_FIXNUM(index),
+                FEwrong_index(@[aref], x, -1, ecl_make_fixnum(index),
                               x->array.dim);
         }
         return ecl_aref_unsafe(x, index);
@@ -249,7 +249,7 @@ ecl_row_major_ptr(cl_object x, cl_index index, cl_index bytes)
 
 	/* don't check bounds if bytes == 0 */
         if (ecl_unlikely(bytes > 0 && offset + bytes > x->array.dim*elt_size)) {
-                FEwrong_index(@[row-major-aref], x, -1, MAKE_FIXNUM(index),
+                FEwrong_index(@[row-major-aref], x, -1, ecl_make_fixnum(index),
                               x->array.dim);
         }
 
@@ -402,7 +402,7 @@ si_make_pure_array(cl_object etype, cl_object dims, cl_object adj,
 {
 	cl_index r, s, i, j;
 	cl_object x;
-	if (FIXNUMP(dims)) {
+	if (ECL_FIXNUMP(dims)) {
 		return si_make_vector(etype, dims, adj, fillp, displ, disploff);
 	} else if (ecl_unlikely(!ECL_LISTP(dims))) {
                 FEwrong_type_nth_arg(@[make-array], 1, dims,
@@ -410,13 +410,13 @@ si_make_pure_array(cl_object etype, cl_object dims, cl_object adj,
         }
 	r = ecl_length(dims);
 	if (ecl_unlikely(r >= ARANKLIM)) {
-		FEerror("The array rank, ~R, is too large.", 1, MAKE_FIXNUM(r));
+		FEerror("The array rank, ~R, is too large.", 1, ecl_make_fixnum(r));
 	} else if (r == 1) {
 		return si_make_vector(etype, ECL_CONS_CAR(dims), adj, fillp,
 				      displ, disploff);
 	} else if (ecl_unlikely(!Null(fillp))) {
 		FEerror(":FILL-POINTER may not be specified for an array of rank ~D",
-			1, MAKE_FIXNUM(r));
+			1, ecl_make_fixnum(r));
 	}
 	x = ecl_alloc_object(t_array);
 	x->array.displaced = Cnil;
@@ -429,19 +429,19 @@ si_make_pure_array(cl_object etype, cl_object dims, cl_object adj,
                 cl_object d = ECL_CONS_CAR(dims);
                 if (ecl_unlikely(!ECL_FIXNUMP(d) ||
                                  ecl_fixnum_minusp(d) ||
-                                 ecl_fixnum_greater(d, MAKE_FIXNUM(ADIMLIM))))
+                                 ecl_fixnum_greater(d, ecl_make_fixnum(ADIMLIM))))
                 {
-                        cl_object type = ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                               MAKE_FIXNUM(ADIMLIM));
+                        cl_object type = ecl_make_integer_type(ecl_make_fixnum(0),
+                                                               ecl_make_fixnum(ADIMLIM));
                         FEwrong_type_nth_arg(@[make-array], 1, d, type);
                 }
-                j = fix(d);
+                j = ecl_fix(d);
 		s *= (x->array.dims[i] = j);
 		if (ecl_unlikely(s > ATOTLIM)) {
-                        cl_object type = ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                               MAKE_FIXNUM(ATOTLIM));
+                        cl_object type = ecl_make_integer_type(ecl_make_fixnum(0),
+                                                               ecl_make_fixnum(ATOTLIM));
                         FEwrong_type_key_arg(@[make-array], @[array-total-size],
-                                             MAKE_FIXNUM(s), type);
+                                             ecl_make_fixnum(s), type);
                 }
 	}
 	x->array.dim = s;
@@ -472,11 +472,11 @@ si_make_vector(cl_object etype, cl_object dim, cl_object adj,
 	aet = ecl_symbol_to_elttype(etype);
         if (ecl_unlikely(!ECL_FIXNUMP(dim) || ecl_fixnum_minusp(dim) ||
                          ecl_fixnum_greater(dim, ADIMLIM))) {
-                cl_object type = ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                       MAKE_FIXNUM(ADIMLIM));
+                cl_object type = ecl_make_integer_type(ecl_make_fixnum(0),
+                                                       ecl_make_fixnum(ADIMLIM));
                 FEwrong_type_nth_arg(@[make-array], 1, dim, type);
         }
-        d = fix(dim);
+        d = ecl_fix(dim);
 	if (aet == aet_bc) {
 		x = ecl_alloc_object(t_base_string);
                 x->base_string.elttype = (short)aet;
@@ -504,13 +504,13 @@ si_make_vector(cl_object etype, cl_object dim, cl_object adj,
 	} else if (fillp == Ct) {
 		x->vector.flags |= ECL_FLAG_HAS_FILL_POINTER;
 		f = d;
-	} else if (FIXNUMP(fillp) && ecl_fixnum_geq(fillp,MAKE_FIXNUM(0)) &&
-		   ((f = fix(fillp)) <= d)) {
+	} else if (ECL_FIXNUMP(fillp) && ecl_fixnum_geq(fillp,ecl_make_fixnum(0)) &&
+		   ((f = ecl_fix(fillp)) <= d)) {
 		x->vector.flags |= ECL_FLAG_HAS_FILL_POINTER;
 	} else {
 		fillp = ecl_type_error(@'make-array',"fill pointer",fillp,
 				       cl_list(3,@'or',cl_list(3,@'member',Cnil,Ct),
-					       cl_list(3,@'integer',MAKE_FIXNUM(0),
+					       cl_list(3,@'integer',ecl_make_fixnum(0),
 						       dim)));
 		goto AGAIN;
 	}
@@ -678,9 +678,9 @@ si_array_element_type_byte_size(cl_object type) {
         cl_elttype aet = ECL_ARRAYP(type) ?
                 type->array.elttype :
                 ecl_symbol_to_elttype(type);
-	cl_object size = MAKE_FIXNUM(ecl_aet_size[aet]);
+	cl_object size = ecl_make_fixnum(ecl_aet_size[aet]);
 	if (aet == aet_bit)
-		size = ecl_make_ratio(MAKE_FIXNUM(1),MAKE_FIXNUM(CHAR_BIT));
+		size = ecl_make_ratio(ecl_make_fixnum(1),ecl_make_fixnum(CHAR_BIT));
 	@(return size ecl_elttype_to_symbol(aet))
 }
 
@@ -751,7 +751,7 @@ ecl_displace(cl_object from, cl_object to, cl_object offset)
 	void *base;
 	cl_elttype totype, fromtype;
 	fromtype = from->array.elttype;
-        if (ecl_unlikely(!ECL_FIXNUMP(offset) || ((j = fix(offset)) < 0))) {
+        if (ecl_unlikely(!ECL_FIXNUMP(offset) || ((j = ecl_fix(offset)) < 0))) {
                 FEwrong_type_key_arg(@[adjust-array], @[:displaced-index-offset],
                                      offset, @[fixnum]);
         }
@@ -773,8 +773,8 @@ ecl_displace(cl_object from, cl_object to, cl_object offset)
                                 "because the total size of the to-array"
                                 "is too small.", 0);
                 if (j > maxdim) {
-                        cl_object type = ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                               MAKE_FIXNUM(maxdim));
+                        cl_object type = ecl_make_integer_type(ecl_make_fixnum(0),
+                                                               ecl_make_fixnum(maxdim));
                         FEwrong_type_key_arg(@[adjust-array], @[:displaced-index-offset],
                                              offset, type);
                 }
@@ -824,14 +824,14 @@ si_array_raw_data(cl_object x)
                 cl_index displ = data - to_array->vector.self.b8;
 		cl_object fillp = Cnil;
 		if (ECL_ARRAY_HAS_FILL_POINTER_P(x)) {
-			fillp = MAKE_FIXNUM(x->vector.fillp * ecl_aet_size[et]);
+			fillp = ecl_make_fixnum(x->vector.fillp * ecl_aet_size[et]);
 		}
                 output = si_make_vector(@'ext::byte8',
-                                        MAKE_FIXNUM(total_size),
+                                        ecl_make_fixnum(total_size),
                                         Cnil,
                                         fillp,
                                         si_array_raw_data(to_array),
-                                        MAKE_FIXNUM(displ));
+                                        ecl_make_fixnum(displ));
         }
         @(return output)
 }
@@ -849,14 +849,14 @@ cl_array_rank(cl_object a)
 {
         if (ecl_unlikely(!ECL_ARRAYP(a)))
                 FEwrong_type_only_arg(@[array-rank], a, @[array]);
-	@(return ((type_of(a) == t_array) ? MAKE_FIXNUM(a->array.rank)
-					  : MAKE_FIXNUM(1)))
+	@(return ((type_of(a) == t_array) ? ecl_make_fixnum(a->array.rank)
+					  : ecl_make_fixnum(1)))
 }
 
 cl_object
 cl_array_dimension(cl_object a, cl_object index)
 {
-	@(return MAKE_FIXNUM(ecl_array_dimension(a, ecl_to_size(index))))
+	@(return ecl_make_fixnum(ecl_array_dimension(a, ecl_to_size(index))))
 }
 
 cl_index
@@ -887,7 +887,7 @@ cl_array_total_size(cl_object a)
 {
         if (ecl_unlikely(!ECL_ARRAYP(a)))
                 FEwrong_type_only_arg(@[array-total-size], a, @[array]);
-	@(return MAKE_FIXNUM(a->array.dim))
+	@(return ecl_make_fixnum(a->array.dim))
 }
 
 cl_object
@@ -971,7 +971,7 @@ cl_array_displacement(cl_object a)
 			FEbad_aet();
 		}
 	}
-	ecl_return2(the_env, to_array, MAKE_FIXNUM(offset));
+	ecl_return2(the_env, to_array, ecl_make_fixnum(offset));
 }
 
 cl_object
@@ -1040,7 +1040,7 @@ cl_fill_pointer(cl_object a)
                 const char *type = "(AND VECTOR (SATISFIES ARRAY-HAS-FILL-POINTER-P))";
 		FEwrong_type_nth_arg(@[fill-pointer], 1, a, ecl_read_from_cstring(type));
 	}
-	ecl_return1(the_env, MAKE_FIXNUM(a->vector.fillp));
+	ecl_return1(the_env, ecl_make_fixnum(a->vector.fillp));
 }
 
 /*
@@ -1056,10 +1056,10 @@ si_fill_pointer_set(cl_object a, cl_object fp)
 		FEwrong_type_nth_arg(@[adjust-array], 1, a,
                                      ecl_read_from_cstring(type));
         }
-        if (ecl_unlikely(!ECL_FIXNUMP(fp) || ((i = fix(fp)) < 0) ||
+        if (ecl_unlikely(!ECL_FIXNUMP(fp) || ((i = ecl_fix(fp)) < 0) ||
                          (i > a->vector.dim))) {
-                cl_object type = ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                       MAKE_FIXNUM(a->vector.dim-1));
+                cl_object type = ecl_make_integer_type(ecl_make_fixnum(0),
+                                                       ecl_make_fixnum(a->vector.dim-1));
                 FEwrong_type_key_arg(@[adjust-array], @[:fill-pointer], fp, type);
         }
         a->vector.fillp = i;
diff --git a/src/c/big.d b/src/c/big.d
index e4d456851..82e8fa654 100644
--- a/src/c/big.d
+++ b/src/c/big.d
@@ -74,15 +74,15 @@ big_normalize(cl_object x)
 {
 	int s = x->big.big_size;
 	if (s == 0)
-                return(MAKE_FIXNUM(0));
+                return(ecl_make_fixnum(0));
 	if (s == 1) {
                 mp_limb_t y = x->big.big_limbs[0];
                 if (y <= MOST_POSITIVE_FIXNUM)
-                        return MAKE_FIXNUM(y);
+                        return ecl_make_fixnum(y);
 	} else if (s == -1) {
                 mp_limb_t y = x->big.big_limbs[0];
                 if (y <= -MOST_NEGATIVE_FIXNUM)
-                        return MAKE_FIXNUM(-y);
+                        return ecl_make_fixnum(-y);
 	}
 	return x;
 }
@@ -92,15 +92,15 @@ _ecl_big_register_normalize(cl_object x)
 {
 	int s = x->big.big_size;
 	if (s == 0)
-                return(MAKE_FIXNUM(0));
+                return(ecl_make_fixnum(0));
 	if (s == 1) {
                 mp_limb_t y = x->big.big_limbs[0];
                 if (y <= MOST_POSITIVE_FIXNUM)
-                        return MAKE_FIXNUM(y);
+                        return ecl_make_fixnum(y);
 	} else if (s == -1) {
                 mp_limb_t y = x->big.big_limbs[0];
                 if (y <= -MOST_NEGATIVE_FIXNUM)
-                        return MAKE_FIXNUM(-y);
+                        return ecl_make_fixnum(-y);
 	}
 	return _ecl_big_register_copy(x);
 }
@@ -152,7 +152,7 @@ _ecl_big_times_fix(cl_object b, cl_fixnum i)
 	cl_object z;
 
         if (i == 0)
-                return MAKE_FIXNUM(0);
+                return ecl_make_fixnum(0);
 	if (i == 1)
 		return b;
         size = (b->big.big_size < 0)? -b->big.big_size : b->big.big_size;
@@ -301,7 +301,7 @@ mp_free(void *ptr, size_t size)
 cl_fixnum
 fixint(cl_object x)
 {
-        if (FIXNUMP(x))
+        if (ECL_FIXNUMP(x))
                 return ecl_fix(x);
         if (ECL_BIGNUMP(x)) {
                 if (mpz_fits_slong_p(x->big.big_num)) {
@@ -314,7 +314,7 @@ fixint(cl_object x)
 cl_index
 fixnnint(cl_object x)
 {
-        if (FIXNUMP(x)) {
+        if (ECL_FIXNUMP(x)) {
                 cl_fixnum i = ecl_fix(x);
                 if (i >= 0)
                         return i;
@@ -323,8 +323,8 @@ fixnnint(cl_object x)
                         return mpz_get_ui(x->big.big_num);
                 }
         }
-	FEwrong_type_argument(cl_list(3, @'integer', MAKE_FIXNUM(0),
-				      MAKE_FIXNUM(MOST_POSITIVE_FIXNUM)),
+	FEwrong_type_argument(cl_list(3, @'integer', ecl_make_fixnum(0),
+				      ecl_make_fixnum(MOST_POSITIVE_FIXNUM)),
 			      x);
 }
 
diff --git a/src/c/big_ll.d b/src/c/big_ll.d
index 55d8807af..9d244219b 100644
--- a/src/c/big_ll.d
+++ b/src/c/big_ll.d
@@ -31,9 +31,9 @@ static cl_object
 big_normalize(cl_object x)
 {
 	if (x->big.big_num == 0ll)
-                return(MAKE_FIXNUM(0));
+                return(ecl_make_fixnum(0));
         if (x->big.big_num <= MOST_POSITIVE_FIXNUM && x->big.big_num >= MOST_NEGATIVE_FIXNUM)
-                return(MAKE_FIXNUM(x->big.big_num));
+                return(ecl_make_fixnum(x->big.big_num));
         return x;
 }
 
@@ -41,9 +41,9 @@ cl_object
 _ecl_big_register_normalize(cl_object x)
 {
 	if (x->big.big_num == 0ll)
-                return(MAKE_FIXNUM(0));
+                return(ecl_make_fixnum(0));
         if (x->big.big_num <= MOST_POSITIVE_FIXNUM && x->big.big_num >= MOST_NEGATIVE_FIXNUM)
-                return(MAKE_FIXNUM(x->big.big_num));
+                return(ecl_make_fixnum(x->big.big_num));
 	return _ecl_big_register_copy(x);
 }
 
diff --git a/src/c/cfun.d b/src/c/cfun.d
index 375a7f192..55846c39a 100644
--- a/src/c/cfun.d
+++ b/src/c/cfun.d
@@ -31,7 +31,7 @@ ecl_make_cfun(cl_objectfn_fixed c_function, cl_object name, cl_object cblock, in
 	cf->cfunfixed.name = name;
 	cf->cfunfixed.block = cblock;
         cf->cfunfixed.file = Cnil;
-        cf->cfunfixed.file_position = MAKE_FIXNUM(-1);
+        cf->cfunfixed.file_position = ecl_make_fixnum(-1);
 	cf->cfunfixed.narg = narg;
 	if (ecl_unlikely(narg < 0 || narg > C_ARGUMENTS_LIMIT))
                 FEprogram_error_noreturn("ecl_make_cfun: function requires "
@@ -50,7 +50,7 @@ ecl_make_cfun_va(cl_objectfn c_function, cl_object name, cl_object cblock)
 	cf->cfun.block = cblock;
 	cf->cfun.narg = -1;
         cf->cfun.file = Cnil;
-        cf->cfun.file_position = MAKE_FIXNUM(-1);
+        cf->cfun.file_position = ecl_make_fixnum(-1);
 	return cf;
 }
 
@@ -64,7 +64,7 @@ ecl_make_cclosure_va(cl_objectfn c_function, cl_object env, cl_object block)
 	cc->cclosure.env = env;
 	cc->cclosure.block = block;
         cc->cclosure.file = Cnil;
-        cc->cclosure.file_position = MAKE_FIXNUM(-1);
+        cc->cclosure.file_position = ecl_make_fixnum(-1);
 	return cc;
 }
 
diff --git a/src/c/character.d b/src/c/character.d
index 9716d6108..089b0096c 100644
--- a/src/c/character.d
+++ b/src/c/character.d
@@ -22,17 +22,17 @@
 ecl_character
 ecl_char_code(cl_object c)
 {
-	if (ecl_unlikely(!CHARACTERP(c)))
+	if (ecl_unlikely(!ECL_CHARACTERP(c)))
                 FEwrong_type_only_arg(@[char-code], c, @[character]);
-        return CHAR_CODE(c);
+        return ECL_CHAR_CODE(c);
 }
 
 ecl_base_char
 ecl_base_char_code(cl_object c)
 {
 #ifdef ECL_UNICODE
-	if (CHARACTERP(c)) {
-		cl_fixnum code = CHAR_CODE(c);
+	if (ECL_CHARACTERP(c)) {
+		cl_fixnum code = ECL_CHAR_CODE(c);
 		if (code <= 255) {
 			return (int)code;
 		}
@@ -118,19 +118,19 @@ ecl_string_case(cl_object s)
 	return upcase;
 }
 
-@(defun digit_char_p (c &optional (radix MAKE_FIXNUM(10)))
+@(defun digit_char_p (c &optional (radix ecl_make_fixnum(10)))
 @ {
 	cl_fixnum basis, value;
         if (ecl_unlikely(!ECL_FIXNUMP(radix) ||
-                         ecl_fixnum_lower(radix, MAKE_FIXNUM(2)) ||
-                         ecl_fixnum_greater(radix, MAKE_FIXNUM(36)))) {
+                         ecl_fixnum_lower(radix, ecl_make_fixnum(2)) ||
+                         ecl_fixnum_greater(radix, ecl_make_fixnum(36)))) {
                 FEwrong_type_nth_arg(@[digit-char-p], 2, radix,
-                                     ecl_make_integer_type(MAKE_FIXNUM(2),
-                                                           MAKE_FIXNUM(36)));
+                                     ecl_make_integer_type(ecl_make_fixnum(2),
+                                                           ecl_make_fixnum(36)));
         }
-        basis = fix(radix);
+        basis = ecl_fix(radix);
 	value = ecl_digitp(ecl_char_code(c), basis);
-	@(return ((value < 0)? Cnil: MAKE_FIXNUM(value)));
+	@(return ((value < 0)? Cnil: ecl_make_fixnum(value)));
 } @)
 
 /*
@@ -345,14 +345,14 @@ cl_character(cl_object x)
 #ifdef ECL_UNICODE
 	case t_string:
 		if (x->string.fillp == 1) {
-			x = CODE_CHAR(x->string.self[0]);
+			x = ECL_CODE_CHAR(x->string.self[0]);
 			break;
 		}
 		goto ERROR;
 #endif
 	case t_base_string:
 		if (x->base_string.fillp == 1) {
-			x = CODE_CHAR(x->base_string.self[0]);
+			x = ECL_CODE_CHAR(x->base_string.self[0]);
 			break;
 		}
 	default: ERROR:
@@ -365,7 +365,7 @@ cl_object
 cl_char_code(cl_object c)
 {
 	/* INV: ecl_char_code() checks the type of `c' */
-	@(return MAKE_FIXNUM(ecl_char_code(c)))
+	@(return ecl_make_fixnum(ecl_char_code(c)))
 }
 
 cl_object
@@ -375,9 +375,9 @@ cl_code_char(cl_object c)
 
 	switch (type_of(c)) {
 	case t_fixnum:
-		fc = fix(c);
+		fc = ecl_fix(c);
 		if (fc < CHAR_CODE_LIMIT && fc >= 0) {
-			c = CODE_CHAR(fc);
+			c = ECL_CODE_CHAR(fc);
 			break;
 		}
 	case t_bignum:
@@ -394,7 +394,7 @@ cl_char_upcase(cl_object c)
 {
 	/* INV: ecl_char_code() checks the type of `c' */
 	cl_fixnum code = ecl_char_code(c);
-	@(return CODE_CHAR(ecl_char_upcase(code)))
+	@(return ECL_CODE_CHAR(ecl_char_upcase(code)))
 }
 
 cl_object
@@ -402,28 +402,28 @@ cl_char_downcase(cl_object c)
 {
 	/* INV: ecl_char_code() checks the type of `c' */
 	cl_fixnum code = ecl_char_code(c);
-	@(return CODE_CHAR(ecl_char_downcase(code)))
+	@(return ECL_CODE_CHAR(ecl_char_downcase(code)))
 }
 
-@(defun digit_char (weight &optional (radix MAKE_FIXNUM(10)))
+@(defun digit_char (weight &optional (radix ecl_make_fixnum(10)))
 @ {
         cl_fixnum basis;
         cl_object output = Cnil;
         if (ecl_unlikely(!ECL_FIXNUMP(radix) ||
-                         ecl_fixnum_lower(radix, MAKE_FIXNUM(2)) ||
-                         ecl_fixnum_greater(radix, MAKE_FIXNUM(36)))) {
+                         ecl_fixnum_lower(radix, ecl_make_fixnum(2)) ||
+                         ecl_fixnum_greater(radix, ecl_make_fixnum(36)))) {
                 FEwrong_type_nth_arg(@[digit-char], 2, radix,
-                                     ecl_make_integer_type(MAKE_FIXNUM(2),
-                                                           MAKE_FIXNUM(36)));
+                                     ecl_make_integer_type(ecl_make_fixnum(2),
+                                                           ecl_make_fixnum(36)));
         }
-        basis = fix(radix);
+        basis = ecl_fix(radix);
 	switch (type_of(weight)) {
 	case t_fixnum: {
-		cl_fixnum value = fix(weight);
+		cl_fixnum value = ecl_fix(weight);
 		if (value >= 0) {
 			int dw = ecl_digit_char(value, basis);
 			if (dw >= 0) {
-				output = CODE_CHAR(dw);
+				output = ECL_CODE_CHAR(dw);
 			}
 		}
 		break;
@@ -451,7 +451,7 @@ cl_object
 cl_char_int(cl_object c)
 {
 	/* INV: ecl_char_code() checks the type of `c' */
-	return1(MAKE_FIXNUM(ecl_char_code(c)));
+	return1(ecl_make_fixnum(ecl_char_code(c)));
 }
 
 /* here we give every character an implicit name of the form 'u#' where # is a hexadecimal number,
@@ -482,7 +482,7 @@ cl_char_name(cl_object c)
                 start[0] = 'U';
 		output = make_base_string_copy((const char*)start);
 	} else {
-		output = ecl_gethash_safe(MAKE_FIXNUM(code), cl_core.char_names, Cnil);
+		output = ecl_gethash_safe(ecl_make_fixnum(code), cl_core.char_names, Cnil);
 	}
 	@(return output);
 }
@@ -495,12 +495,12 @@ cl_name_char(cl_object name)
 	name = cl_string(name);
 	c = ecl_gethash_safe(name, cl_core.char_names, Cnil);
         if (c != Cnil) {
-                c = CODE_CHAR(fix(c));
+                c = ECL_CODE_CHAR(ecl_fix(c));
         } else if (ecl_stringp(name) && (l = ecl_length(name))) {
-		c = cl_char(name, MAKE_FIXNUM(0));
+		c = cl_char(name, ecl_make_fixnum(0));
 		if (l == 1) {
 			(void)0;
-		} else if (c != CODE_CHAR('u') && c != CODE_CHAR('U')) {
+		} else if (c != ECL_CODE_CHAR('u') && c != ECL_CODE_CHAR('U')) {
 			c = Cnil;
 		} else {
 			cl_index used_l;
@@ -508,10 +508,10 @@ cl_name_char(cl_object name)
 			cl_index real_end = end;
 			c = ecl_parse_integer(name, 1, end, &real_end, 16);
 			used_l = real_end;
-			if (!FIXNUMP(c) || (used_l == (l - 1))) {
+			if (!ECL_FIXNUMP(c) || (used_l == (l - 1))) {
 				c = Cnil;
 			} else {
-				c = CODE_CHAR(fix(c));
+				c = ECL_CODE_CHAR(ecl_fix(c));
 			}
 		}
 	}
diff --git a/src/c/cinit.d b/src/c/cinit.d
index 0307b281d..000b52630 100644
--- a/src/c/cinit.d
+++ b/src/c/cinit.d
@@ -115,8 +115,8 @@ static cl_object si_simple_toplevel ()
                                 "ECL (Embeddable Common Lisp)\n",
                                 output);
                 ecl_force_output(output);
-                for (i = 1; i<fix(si_argc()); i++) {
-                        cl_object arg = si_argv(MAKE_FIXNUM(i));
+                for (i = 1; i<ecl_fix(si_argc()); i++) {
+                        cl_object arg = si_argv(ecl_make_fixnum(i));
                         cl_load(1, arg);
                 }
                 while (1) {
diff --git a/src/c/clos/accessor.d b/src/c/clos/accessor.d
index e3320a29e..41c5aa381 100644
--- a/src/c/clos/accessor.d
+++ b/src/c/clos/accessor.d
@@ -121,7 +121,7 @@ ecl_slot_reader_dispatch(cl_narg narg, cl_object instance)
 	}
 	index = e->value;
 	if (ECL_FIXNUMP(index)) {
-		value = instance->instance.slots[fix(index)];
+		value = instance->instance.slots[ecl_fix(index)];
 	} else {
 		unlikely_if (!ECL_CONSP(index)) {
 			FEerror("Error when accessing method cache for ~A", 1, gfun);
@@ -164,7 +164,7 @@ ecl_slot_writer_dispatch(cl_narg narg, cl_object value, cl_object instance)
 	}
 	index = e->value;
 	if (ECL_FIXNUMP(index)) {
-		instance->instance.slots[fix(index)] = value;
+		instance->instance.slots[ecl_fix(index)] = value;
 	} else {
 		unlikely_if (!ECL_CONSP(index)) {
 			FEerror("Error when accessing method cache for ~A", 1, gfun);
diff --git a/src/c/clos/cache.d b/src/c/clos/cache.d
index 511d8b0d3..f144344fa 100644
--- a/src/c/clos/cache.d
+++ b/src/c/clos/cache.d
@@ -20,8 +20,8 @@
 
 #define RECORD_KEY(e) ((e)[0])
 #define RECORD_VALUE(e) ((e)[1])
-#define RECORD_GEN(e) fix((e+2)[0])
-#define RECORD_GEN_SET(e,v) ((e+2)[0]=MAKE_FIXNUM(v))
+#define RECORD_GEN(e) ecl_fix((e+2)[0])
+#define RECORD_GEN_SET(e,v) ((e+2)[0]=ecl_make_fixnum(v))
 
 static void
 empty_cache(ecl_cache_ptr cache)
@@ -80,14 +80,14 @@ ecl_make_cache(cl_index key_size, cl_index cache_size)
 	ecl_cache_ptr cache = ecl_alloc(sizeof(struct ecl_cache));
 	cache->keys =
 		si_make_vector(Ct, /* element type */
-			       MAKE_FIXNUM(key_size), /* Maximum size */
+			       ecl_make_fixnum(key_size), /* Maximum size */
 			       Ct, /* adjustable */
-			       MAKE_FIXNUM(0), /* fill pointer */
+			       ecl_make_fixnum(0), /* fill pointer */
 			       Cnil, /* displaced */
 			       Cnil);
 	cache->table =
 		si_make_vector(Ct, /* element type */
-			       MAKE_FIXNUM(3*cache_size), /* Maximum size */
+			       ecl_make_fixnum(3*cache_size), /* Maximum size */
 			       Cnil, /* adjustable */
 			       Cnil, /* fill pointer */
 			       Cnil, /* displaced */
diff --git a/src/c/cmpaux.d b/src/c/cmpaux.d
index 37bf39209..c670e57da 100644
--- a/src/c/cmpaux.d
+++ b/src/c/cmpaux.d
@@ -59,9 +59,9 @@ ecl_to_char(cl_object x)
 {
 	switch (type_of(x)) {
 	case t_fixnum:
-		return fix(x);
+		return ecl_fix(x);
 	case t_character:
-		return CHAR_CODE(x);
+		return ECL_CHAR_CODE(x);
 	default:
 		FEerror("~S cannot be coerced to a C char.", 1, x);
 	}
@@ -74,7 +74,7 @@ ecl_to_fixnum(cl_object x)
 	case t_fixnum:
 	case t_bignum:
 		return fixint(x);
-/*	case t_character: return (cl_fixnum)CHAR_CODE(x); */
+/*	case t_character: return (cl_fixnum)ECL_CHAR_CODE(x); */
 	case t_ratio:
 		return (cl_fixnum)ecl_to_double(x);
 	case t_singlefloat:
@@ -115,11 +115,11 @@ ecl_to_unsigned_integer(cl_object x)
 float
 ecl_to_float(cl_object x)
 {
-	if (FIXNUMP(x)) return(fix(x));	/* Immediate fixnum */
+	if (ECL_FIXNUMP(x)) return(ecl_fix(x));	/* Immediate fixnum */
 
 	switch (type_of(x)) {
-/*	case t_fixnum: return fix(x);	*/
-/*	case t_character: return CHAR_CODE(x); */
+/*	case t_fixnum: return ecl_fix(x);	*/
+/*	case t_character: return ECL_CHAR_CODE(x); */
 	case t_bignum:
 	case t_ratio:
 		return ecl_to_double(x);
diff --git a/src/c/compiler.d b/src/c/compiler.d
index fe9cde6a6..fb8ffd84f 100644
--- a/src/c/compiler.d
+++ b/src/c/compiler.d
@@ -171,7 +171,7 @@ asm_end(cl_env_ptr env, cl_index beginning, cl_object definition) {
         cl_object file = ECL_SYM_VAL(env,@'ext::*source-location*'), position;
         if (Null(file)) {
                 file = ECL_SYM_VAL(env,@'*load-truename*');
-                position = MAKE_FIXNUM(0);
+                position = ecl_make_fixnum(0);
         } else {
                 position = cl_cdr(file);
                 file = cl_car(file);
@@ -439,13 +439,13 @@ asm_op2c(cl_env_ptr env, int code, cl_object o) {
  */
 
 #if 0
-#define new_location(env,x) MAKE_FIXNUM(0)
+#define new_location(env,x) ecl_make_fixnum(0)
 #else
 static cl_object
 new_location(const cl_compiler_ptr c_env)
 {
-	return CONS(MAKE_FIXNUM(c_env->env_depth),
-                    MAKE_FIXNUM(c_env->env_size++));
+	return CONS(ecl_make_fixnum(c_env->env_depth),
+                    ecl_make_fixnum(c_env->env_size++));
 }
 #endif
 
@@ -456,7 +456,7 @@ c_register_block(cl_env_ptr env, cl_object name)
 	cl_object loc = new_location(c_env);
 	c_env->variables = CONS(cl_list(4, @':block', name, Cnil, loc),
                                 c_env->variables);
-	return fix(ECL_CONS_CDR(loc));
+	return ecl_fix(ECL_CONS_CDR(loc));
 }
 
 static cl_index
@@ -466,7 +466,7 @@ c_register_tags(cl_env_ptr env, cl_object all_tags)
 	cl_object loc = new_location(c_env);
 	c_env->variables = CONS(cl_list(4, @':tag', all_tags, Cnil, loc),
                                 c_env->variables);
-	return fix(ECL_CONS_CDR(loc));
+	return ecl_fix(ECL_CONS_CDR(loc));
 }
 
 static void
@@ -536,7 +536,7 @@ guess_environment(cl_env_ptr env, cl_object interpreter_env)
                         cl_object record1 = ECL_CONS_CDR(record);
                         if (SYMBOLP(record0)) {
                                 c_register_var(env, record0, FALSE, TRUE);
-                        } else if (record1 == MAKE_FIXNUM(0)) {
+                        } else if (record1 == ecl_make_fixnum(0)) {
                                 c_register_tags(env, Cnil);
                         } else {
                                 c_register_block(env, record1);
@@ -555,9 +555,9 @@ c_new_env(cl_env_ptr the_env, cl_compiler_env_ptr new, cl_object env,
 		new->env_depth = old->env_depth + 1;
 	} else {
 		new->code_walker = ECL_SYM_VAL(the_env, @'si::*code-walker*');
-		new->constants = si_make_vector(Ct, MAKE_FIXNUM(16),
+		new->constants = si_make_vector(Ct, ecl_make_fixnum(16),
 						Ct, /* Adjustable */
-						MAKE_FIXNUM(0), /* Fillp */
+						ecl_make_fixnum(0), /* Fillp */
 						Cnil, /* displacement */
 						Cnil);
 		new->stepping = 0;
@@ -599,7 +599,7 @@ c_tag_ref(cl_env_ptr env, cl_object the_tag, cl_object the_type)
 			if (type == the_type) {
 				cl_object label = ecl_assql(the_tag, name);
 				if (!Null(label)) {
-					return CONS(MAKE_FIXNUM(n), ECL_CONS_CDR(label));
+					return CONS(ecl_make_fixnum(n), ECL_CONS_CDR(label));
 				}
 			}
 			n++;
@@ -609,7 +609,7 @@ c_tag_ref(cl_env_ptr env, cl_object the_tag, cl_object the_type)
 				/* Mark as used */
                                 record = ECL_CONS_CDR(record);
 				ECL_RPLACA(record, Ct);
-				return MAKE_FIXNUM(n);
+				return ecl_make_fixnum(n);
 			}
 			n++;
 		} else if (Null(name)) {
@@ -980,13 +980,13 @@ c_funcall(cl_env_ptr env, cl_object args, int flags) {
 	if (CONSP(name)) {
                 cl_object kind = ECL_CONS_CAR(name);
 		if (kind == @'function') {
-			if (cl_list_length(name) != MAKE_FIXNUM(2))
+			if (cl_list_length(name) != ecl_make_fixnum(2))
 				FEprogram_error_noreturn("FUNCALL: Invalid function name ~S",
                                                          1, name);
 			return c_call(env, CONS(CADR(name), args), flags);
 		}
 		if (kind == @'quote') {
-			if (cl_list_length(name) != MAKE_FIXNUM(2))
+			if (cl_list_length(name) != ecl_make_fixnum(2))
 				FEprogram_error_noreturn("FUNCALL: Invalid function name ~S",
                                                          1, name);
 			return c_call(env, CONS(CADR(name), args), flags | FLAG_GLOBAL);
@@ -1085,7 +1085,7 @@ c_catch(cl_env_ptr env, cl_object args, int flags) {
 
 	/* Compile binding of tag */
 	old_env = env->c_env->variables;
-	loc = c_register_block(env, MAKE_FIXNUM(0));
+	loc = c_register_block(env, ecl_make_fixnum(0));
 	asm_op(env, OP_CATCH);
 
 	/* Compile jump point */
@@ -1423,7 +1423,7 @@ asm_function(cl_env_ptr env, cl_object function, int flags) {
                         return FLAG_REG0;
 		} else {
 			/* Function from a FLET/LABELS form */
-			asm_op2(env, OP_LFUNCTION, fix(ndx));
+			asm_op2(env, OP_LFUNCTION, ecl_fix(ndx));
                         return FLAG_REG0;
 		}
 	}
@@ -1463,8 +1463,8 @@ c_go(cl_env_ptr env, cl_object args, int flags) {
 		FEprogram_error_noreturn("GO: Unknown tag ~S.", 1, tag);
 	if (!Null(args))
 		FEprogram_error_noreturn("GO: Too many arguments.",0);
-	asm_op2(env, OP_GO, fix(CAR(info)));
-	asm_arg(env, fix(CDR(info)));
+	asm_op2(env, OP_GO, ecl_fix(CAR(info)));
+	asm_arg(env, ecl_fix(CDR(info)));
 	return flags;
 }
 
@@ -1952,7 +1952,7 @@ c_return_aux(cl_env_ptr env, cl_object name, cl_object stmt, int flags)
 	if (stmt != Cnil)
 		FEprogram_error_noreturn("RETURN-FROM: Too many arguments.", 0);
 	compile_form(env, output, FLAG_VALUES);
-	asm_op2(env, OP_RETURN, fix(ndx));
+	asm_op2(env, OP_RETURN, ecl_fix(ndx));
 	return FLAG_VALUES;
 }
 
@@ -2040,7 +2040,7 @@ c_tagbody(cl_env_ptr env, cl_object args, int flags)
 		item_type = type_of(label);
 		if (item_type == t_symbol || item_type == t_fixnum ||
 	            item_type == t_bignum) {
-			labels = CONS(CONS(label,MAKE_FIXNUM(nt)), labels);
+			labels = CONS(CONS(label,ecl_make_fixnum(nt)), labels);
 			nt += 1;
 		}
 	}
@@ -2048,7 +2048,7 @@ c_tagbody(cl_env_ptr env, cl_object args, int flags)
 		compile_body(env, args, 0);
 		return compile_form(env, Cnil, flags);
 	}
-	asm_op2c(env, OP_BLOCK, MAKE_FIXNUM(0));
+	asm_op2c(env, OP_BLOCK, ecl_make_fixnum(0));
 	c_register_tags(env, labels);
 	asm_op2(env, OP_TAGBODY, nt);
 	tag_base = current_pc(env);
@@ -2208,7 +2208,7 @@ compile_constant(cl_env_ptr env, cl_object stmt, int flags)
                 maybe_make_load_forms(env, stmt);
                 if (stmt == Cnil) {
                         asm_op(env, push? OP_PUSHNIL : OP_NIL);
-                } else if (FIXNUMP(stmt) && (n = fix(stmt)) <= MAX_OPARG
+                } else if (ECL_FIXNUMP(stmt) && (n = ecl_fix(stmt)) <= MAX_OPARG
                            && n >= -MAX_OPARG) {
                         asm_op2(env, push? OP_PINT : OP_INT, n);
                 } else {
@@ -2283,7 +2283,7 @@ compile_form(cl_env_ptr env, cl_object stmt, int flags) {
 	if (SYMBOLP(function)) {
 		cl_object index = ecl_gethash(function, cl_core.compiler_dispatch);
 		if (index != OBJNULL) {
-			compiler_record *l = database + fix(index);
+			compiler_record *l = database + ecl_fix(index);
 			c_env->lexical_level += l->lexical_increment;
 			if (c_env->stepping && function != @'function' &&
 			    c_env->lexical_level)
@@ -2356,9 +2356,9 @@ eval_nontrivial_form(cl_env_ptr env, cl_object form) {
         frame.env = env;
         env->nvalues = 0;
         env->values[0] = Cnil;
-        new_c_env.constants = si_make_vector(Ct, MAKE_FIXNUM(16),
+        new_c_env.constants = si_make_vector(Ct, ecl_make_fixnum(16),
 					     Ct, /* Adjustable */
-					     MAKE_FIXNUM(0), /* Fillp */
+					     ecl_make_fixnum(0), /* Fillp */
 					     Cnil, /* displacement */
 					     Cnil);
         new_c_env.load_time_forms = Cnil;
@@ -2460,14 +2460,14 @@ compile_with_load_time_forms(cl_env_ptr env, cl_object form, int flags)
                         compile_with_load_time_forms(env, make_form, FLAG_REG0);
                         asm_op2(env, OP_CSET, loc);
                         compile_with_load_time_forms(env, init_form, FLAG_IGNORE);
-			ECL_RPLACA(p, MAKE_FIXNUM(loc));
+			ECL_RPLACA(p, ecl_make_fixnum(loc));
                         p = ECL_CONS_CDR(p);
                 } while (p != Cnil);
 		p = forms_list;
 		do {
-			cl_index loc = fix(ECL_CONS_CAR(p));
+			cl_index loc = ecl_fix(ECL_CONS_CAR(p));
 			/* Clear created constants (they cannot be printed) */
-			c_env->constants->vector.self.t[loc] = MAKE_FIXNUM(0);
+			c_env->constants->vector.self.t[loc] = ecl_make_fixnum(0);
 			p = ECL_CONS_CDR(p);
 		} while (p != Cnil);
                 restore_bytecodes(env, bytecodes);
@@ -2898,11 +2898,11 @@ OUTPUT:
 	if ((nreq+nopt+(!Null(rest))+nkey) >= CALL_ARGUMENTS_LIMIT)
 		FEprogram_error_noreturn("LAMBDA: Argument list ist too long, ~S.", 1,
 				org_lambda_list);
-	@(return CONS(MAKE_FIXNUM(nreq), lists[0])
-		 CONS(MAKE_FIXNUM(nopt), lists[1])
+	@(return CONS(ecl_make_fixnum(nreq), lists[0])
+		 CONS(ecl_make_fixnum(nopt), lists[1])
 		 rest
 		 key_flag
-		 CONS(MAKE_FIXNUM(nkey), lists[2])
+		 CONS(ecl_make_fixnum(nkey), lists[2])
 		 allow_other_keys
 		 lists[3])
 
@@ -3132,11 +3132,11 @@ init_compiler()
 {
 	cl_object dispatch_table =
 		cl_core.compiler_dispatch =
-		cl__make_hash_table(@'eq', MAKE_FIXNUM(128), /* size */
+		cl__make_hash_table(@'eq', ecl_make_fixnum(128), /* size */
                                     cl_core.rehash_size,
                                     cl_core.rehash_threshold);
 	int i;
 	for (i = 0; database[i].symbol; i++) {
-		ecl_sethash(database[i].symbol, dispatch_table, MAKE_FIXNUM(i));
+		ecl_sethash(database[i].symbol, dispatch_table, ecl_make_fixnum(i));
 	}
 }
diff --git a/src/c/disassembler.d b/src/c/disassembler.d
index 17a30c3ec..7d9d619c9 100644
--- a/src/c/disassembler.d
+++ b/src/c/disassembler.d
@@ -30,7 +30,7 @@ print_noarg(const char *s) {
 static void
 print_oparg(const char *s, cl_fixnum n) {
 	ecl_princ_str(s, Cnil);
-	ecl_princ(MAKE_FIXNUM(n), Cnil);
+	ecl_princ(ecl_make_fixnum(n), Cnil);
 }
 
 static void
@@ -42,7 +42,7 @@ print_arg(const char *s, cl_object x) {
 static void
 print_oparg_arg(const char *s, cl_fixnum n, cl_object x) {
 	ecl_princ_str(s, Cnil);
-	ecl_princ(MAKE_FIXNUM(n), Cnil);
+	ecl_princ(ecl_make_fixnum(n), Cnil);
 	ecl_princ_str(",", Cnil);
 	ecl_princ(x, Cnil);
 }
@@ -157,9 +157,9 @@ disassemble_tagbody(cl_object bytecodes, cl_opcode *vector) {
 	for (i=0; i<ntags; i++) {
 		GET_LABEL(destination, vector);
 		ecl_princ_str("\n\tTAG\t", Ct);
-		ecl_princ(MAKE_FIXNUM(i), Ct);
+		ecl_princ(ecl_make_fixnum(i), Ct);
 		ecl_princ_str(" @@ ", Ct);
-		ecl_princ(MAKE_FIXNUM(destination - base), Ct);
+		ecl_princ(ecl_make_fixnum(destination - base), Ct);
 	}
 	vector = disassemble(bytecodes, vector);
 	print_noarg("\t\t; tagbody");
@@ -182,7 +182,7 @@ disassemble(cl_object bytecodes, cl_opcode *vector) {
 		line_format = Cnil;
  BEGIN:
 	if (1) {
-		line_no = MAKE_FIXNUM(vector-base);
+		line_no = ecl_make_fixnum(vector-base);
 	} else {
 		line_no = @'*';
 	}
@@ -527,7 +527,7 @@ disassemble(cl_object bytecodes, cl_opcode *vector) {
 				goto OPARG;
 	case OP_VSETQ:		string = "VSETQ\t";
 				GET_OPARG(m, vector);
-				o = MAKE_FIXNUM(m);
+				o = ecl_make_fixnum(m);
 				GET_OPARG(n, vector);
 				goto OPARG_ARG;
 	case OP_SETQS:		string = "SETQS\t";
@@ -594,7 +594,7 @@ disassemble(cl_object bytecodes, cl_opcode *vector) {
 				goto ARG;
 
 	default:
-		FEerror("Unknown code ~S", 1, MAKE_FIXNUM(*(vector-1)));
+		FEerror("Unknown code ~S", 1, ecl_make_fixnum(*(vector-1)));
 		return vector;
 	NOARG:			print_noarg(string);
 				break;
diff --git a/src/c/dpp.c b/src/c/dpp.c
index 9031b7e83..d8af322ea 100755
--- a/src/c/dpp.c
+++ b/src/c/dpp.c
@@ -260,7 +260,7 @@ search_symbol(char *name, int *symbol_code, int code)
 		if (!strcasecmp(name, cl_symbols[i].name)) {
 			name = poolp;
                         if (code) {
-                                pushstr("MAKE_FIXNUM(/*");
+                                pushstr("ecl_make_fixnum(/*");
                                 pushstr(cl_symbols[i].name);
 				pushstr("*/");
 				if (i >= 1000)
@@ -695,7 +695,7 @@ put_declaration(void)
   if (nopt == 0 && !rest_flag && !key_flag) {
     put_lineno();
     fprintf(out, "\tif (ecl_unlikely(narg!=%d))", nreq);
-    fprintf(out, "\t   FEwrong_num_arguments(MAKE_FIXNUM(%d));\n",
+    fprintf(out, "\t   FEwrong_num_arguments(ecl_make_fixnum(%d));\n",
             function_code);
   } else {
     simple_varargs = !rest_flag && !key_flag && ((nreq + nopt) < 32);
@@ -721,7 +721,7 @@ put_declaration(void)
     if (nopt > 0 && !rest_flag && !key_flag) {
       fprintf(out, "|| narg > %d", nreq + nopt);
     }
-    fprintf(out, ")) FEwrong_num_arguments(MAKE_FIXNUM(%d));\n", function_code);
+    fprintf(out, ")) FEwrong_num_arguments(ecl_make_fixnum(%d));\n", function_code);
     for (i = 0;  i < nopt;  i++) {
       put_lineno();
       fprintf(out, "\tif (narg > %d) {\n", nreq+i);
diff --git a/src/c/error.d b/src/c/error.d
index d52ba16e1..dc9dd68ff 100644
--- a/src/c/error.d
+++ b/src/c/error.d
@@ -30,8 +30,8 @@
 static cl_object
 cl_symbol_or_object(cl_object x)
 {
-        if (FIXNUMP(x))
-                return (cl_object)(cl_symbols + fix(x));
+        if (ECL_FIXNUMP(x))
+                return (cl_object)(cl_symbols + ecl_fix(x));
         return x;
 }
 
@@ -57,7 +57,7 @@ ecl_internal_error(const char *s)
                         strerror(saved_errno));
         }
 	fflush(stderr);
-        si_dump_c_backtrace(MAKE_FIXNUM(32));
+        si_dump_c_backtrace(ecl_make_fixnum(32));
 #ifdef SIGIOT
 	signal(SIGIOT, SIG_DFL); /* avoid getting into a loop with abort */
 #endif
@@ -298,7 +298,7 @@ FEwrong_type_nth_arg(cl_object function, cl_narg narg, cl_object value, cl_objec
                                @'type-error', /* condition name */
                                Cnil, /* not correctable */
                                make_constant_base_string(message), /* format control */
-                               cl_list(4, function, MAKE_FIXNUM(narg),
+                               cl_list(4, function, ecl_make_fixnum(narg),
                                        value, type),
                                @':expected-type', type,
                                @':datum', value);
@@ -341,7 +341,7 @@ FEwrong_index(cl_object function, cl_object a, int which, cl_object ndx,
                 "the ~:R index into the object~% ~A~%"
                 "takes a value ~D out of the range ~A.";
         cl_object limit = ecl_make_integer(nonincl_limit-1);
-	cl_object type = ecl_make_integer_type(MAKE_FIXNUM(0), limit);
+	cl_object type = ecl_make_integer_type(ecl_make_fixnum(0), limit);
         cl_object message = make_constant_base_string((which<0) ? message1 : message2);
         cl_env_ptr env = ecl_process_env();
         struct ihs_frame tmp_ihs;
@@ -353,7 +353,7 @@ FEwrong_index(cl_object function, cl_object a, int which, cl_object ndx,
                  @'simple-type-error', /* condition name */
                  @':format-control', message,
                  @':format-arguments',
-                 cl_list(5, function, MAKE_FIXNUM(which+1), a, ndx, type),
+                 cl_list(5, function, ecl_make_fixnum(which+1), a, ndx, type),
                  @':expected-type', type,
                  @':datum', ndx);
 }
@@ -445,10 +445,10 @@ universal_error_handler(cl_object continue_string, cl_object datum,
         stream = cl_core.error_output;
         if (!Null(stream)) {
                 ecl_bds_bind(the_env, @'*print-readably*', Cnil);
-                ecl_bds_bind(the_env, @'*print-level*', MAKE_FIXNUM(3));
-                ecl_bds_bind(the_env, @'*print-length*', MAKE_FIXNUM(3));
+                ecl_bds_bind(the_env, @'*print-level*', ecl_make_fixnum(3));
+                ecl_bds_bind(the_env, @'*print-length*', ecl_make_fixnum(3));
                 ecl_bds_bind(the_env, @'*print-circle*', Cnil);
-                ecl_bds_bind(the_env, @'*print-base*', MAKE_FIXNUM(10));
+                ecl_bds_bind(the_env, @'*print-base*', ecl_make_fixnum(10));
                 writestr_stream("\n;;; Unhandled lisp initialization error",
                                 stream);
                 writestr_stream("\n;;; Message:\n", stream);
diff --git a/src/c/ffi.d b/src/c/ffi.d
index bdb839c75..6cb818d7a 100644
--- a/src/c/ffi.d
+++ b/src/c/ffi.d
@@ -459,17 +459,17 @@ ecl_foreign_data_ref_elt(void *p, enum ecl_ffi_tag tag)
 {
 	switch (tag) {
 	case ECL_FFI_CHAR:
-		return CODE_CHAR(*(char *)p);
+		return ECL_CODE_CHAR(*(char *)p);
 	case ECL_FFI_UNSIGNED_CHAR:
-		return CODE_CHAR(*(unsigned char *)p);
+		return ECL_CODE_CHAR(*(unsigned char *)p);
 	case ECL_FFI_BYTE:
-		return MAKE_FIXNUM(*(int8_t *)p);
+		return ecl_make_fixnum(*(int8_t *)p);
 	case ECL_FFI_UNSIGNED_BYTE:
-		return MAKE_FIXNUM(*(uint8_t *)p);
+		return ecl_make_fixnum(*(uint8_t *)p);
 	case ECL_FFI_SHORT:
-		return MAKE_FIXNUM(*(short *)p);
+		return ecl_make_fixnum(*(short *)p);
 	case ECL_FFI_UNSIGNED_SHORT:
-		return MAKE_FIXNUM(*(unsigned short *)p);
+		return ecl_make_fixnum(*(unsigned short *)p);
 	case ECL_FFI_INT:
 		return ecl_make_integer(*(int *)p);
 	case ECL_FFI_UNSIGNED_INT:
@@ -478,9 +478,9 @@ ecl_foreign_data_ref_elt(void *p, enum ecl_ffi_tag tag)
 		return ecl_make_integer(*(long *)p);
 #ifdef ecl_uint8_t
         case ECL_FFI_INT8_T:
-                return MAKE_FIXNUM(*(ecl_int8_t *)p);
+                return ecl_make_fixnum(*(ecl_int8_t *)p);
         case ECL_FFI_UINT8_T:
-                return MAKE_FIXNUM(*(ecl_uint8_t *)p);
+                return ecl_make_fixnum(*(ecl_uint8_t *)p);
 #endif
 #ifdef ecl_uint16_t
         case ECL_FFI_INT16_T:
@@ -659,14 +659,14 @@ cl_object
 si_size_of_foreign_elt_type(cl_object type)
 {
 	enum ecl_ffi_tag tag = ecl_foreign_type_code(type);
-	@(return MAKE_FIXNUM(ecl_foreign_type_table[tag].size))
+	@(return ecl_make_fixnum(ecl_foreign_type_table[tag].size))
 }
 
 cl_object
 si_alignment_of_foreign_elt_type(cl_object type)
 {
 	enum ecl_ffi_tag tag = ecl_foreign_type_code(type);
-	@(return MAKE_FIXNUM(ALIGNMENT(tag)))
+	@(return ecl_make_fixnum(ALIGNMENT(tag)))
 }
 
 cl_object
@@ -1017,7 +1017,7 @@ si_free_ffi_closure(cl_object closure)
 
         if (status != FFI_OK) {
                 FEerror("Unable to build callback. libffi returns ~D", 1,
-                        MAKE_FIXNUM(status));
+                        ecl_make_fixnum(status));
         }
 	si_put_sysprop(sym, @':callback', data);
         @(return closure_object);
diff --git a/src/c/ffi/cdata.d b/src/c/ffi/cdata.d
index 8929f09a5..94a1405e9 100644
--- a/src/c/ffi/cdata.d
+++ b/src/c/ffi/cdata.d
@@ -45,11 +45,11 @@ si_get_cdata(cl_object filename)
 		displaced = str_no_data;
         } else {
                 displaced = cl_funcall(8, @'make-array',
-                                       MAKE_FIXNUM(header->size),
+                                       ecl_make_fixnum(header->size),
                                        @':element-type', @'base-char',
                                        @':displaced-to', array,
                                        @':displaced-index-offset',
-                                       MAKE_FIXNUM(header->offset));
+                                       ecl_make_fixnum(header->offset));
         }
         @(return map displaced);
 }
@@ -76,7 +76,7 @@ si_add_cdata(cl_object filename, cl_object data)
                 unsigned char *c = (unsigned char *)&header;
                 int i;
                 for (i = 0; i < sizeof(header); i++) {
-                        ecl_write_byte(MAKE_FIXNUM(c[i]), stream);
+                        ecl_write_byte(ecl_make_fixnum(c[i]), stream);
                 }
         }
         cl_close(1, stream);
diff --git a/src/c/ffi/libraries.d b/src/c/ffi/libraries.d
index 5d715ec49..6ea0ea950 100644
--- a/src/c/ffi/libraries.d
+++ b/src/c/ffi/libraries.d
@@ -91,7 +91,7 @@ ecl_make_codeblock()
         block->cblock.cfuns_size = 0;
         block->cblock.cfuns = NULL;
         block->cblock.source = Cnil;
-        block->cblock.refs = MAKE_FIXNUM(0);
+        block->cblock.refs = ecl_make_fixnum(0);
         si_set_finalizer(block, Ct);
         return block;
 }
@@ -234,7 +234,7 @@ ecl_library_open_inner(cl_object filename, bool self_destruct)
 	block->cblock.cfuns_size = 0;
 	block->cblock.cfuns = NULL;
         block->cblock.source = Cnil;
-        block->cblock.refs = MAKE_FIXNUM(1);
+        block->cblock.refs = ecl_make_fixnum(1);
 
         ECL_WITH_GLOBAL_LOCK_BEGIN(the_env) {
 	ecl_disable_interrupts();
@@ -309,7 +309,7 @@ ecl_library_open(cl_object filename, bool force_reload) {
 	 * the case, we close the new copy to ensure we do refcounting
 	 * right.
 	 */
-	if (block->cblock.refs != MAKE_FIXNUM(1)) {
+	if (block->cblock.refs != ecl_make_fixnum(1)) {
                 if (force_reload) {
                         ecl_library_close(block);
                         filename = copy_object_file(filename);
@@ -425,7 +425,7 @@ ecl_library_close(cl_object block) {
         const cl_env_ptr the_env = ecl_process_env();
         ECL_WITH_GLOBAL_LOCK_BEGIN(the_env) {
                 ecl_disable_interrupts();
-                if (block->cblock.refs != MAKE_FIXNUM(1)) {
+                if (block->cblock.refs != ecl_make_fixnum(1)) {
                         block->cblock.refs = ecl_one_minus(block->cblock.refs);
                         block = Cnil;
                 } else if (block->cblock.handle != NULL) {
diff --git a/src/c/ffi/mmap.d b/src/c/ffi/mmap.d
index 5fbc3b581..1e1962bdf 100644
--- a/src/c/ffi/mmap.d
+++ b/src/c/ffi/mmap.d
@@ -23,7 +23,7 @@
 @(defun ext::mmap (filename
                    &key
                    (length Cnil)
-                   (offset MAKE_FIXNUM(0))
+                   (offset ecl_make_fixnum(0))
                    (direction @':input')
                    (element_type @'base-char')
                    (if_exists @':new-version')
@@ -64,7 +64,7 @@
                 else
                         len = ecl_to_unsigned_integer(length);
         }
-        output = si_make_vector(element_type, MAKE_FIXNUM(0), Cnil,
+        output = si_make_vector(element_type, ecl_make_fixnum(0), Cnil,
                                 Cnil, Cnil, Cnil);
         pa = mmap(0, len, c_prot, c_flags, fd,
                   ecl_integer_to_off_t(offset));
diff --git a/src/c/file.d b/src/c/file.d
index 6aa24c7c8..85d1ab298 100644
--- a/src/c/file.d
+++ b/src/c/file.d
@@ -310,7 +310,7 @@ generic_read_byte_unsigned8(cl_object strm)
 	if (strm->stream.ops->read_byte8(strm, &c, 1) < 1) {
 		return Cnil;
 	}
-	return MAKE_FIXNUM(c);
+	return ecl_make_fixnum(c);
 }
 
 static void
@@ -326,7 +326,7 @@ generic_read_byte_signed8(cl_object strm)
 	signed char c;
 	if (strm->stream.ops->read_byte8(strm, (unsigned char *)&c, 1) < 1)
 		return Cnil;
-	return MAKE_FIXNUM(c);
+	return ecl_make_fixnum(c);
 }
 
 static void
@@ -342,7 +342,7 @@ generic_read_byte_le(cl_object strm)
 	cl_index (*read_byte8)(cl_object, unsigned char *, cl_index);
 	unsigned char c;
 	cl_index nb, bs;
-	cl_object output = MAKE_FIXNUM(0);
+	cl_object output = ecl_make_fixnum(0);
 	read_byte8 = strm->stream.ops->read_byte8;
 	bs = strm->stream.byte_size;
 	for (nb = 0; bs >= 8; bs -= 8, nb += 8) {
@@ -350,10 +350,10 @@ generic_read_byte_le(cl_object strm)
 		if (read_byte8(strm, &c, 1) < 1)
 			return Cnil;
 		if (bs <= 8 && (strm->stream.flags & ECL_STREAM_SIGNED_BYTES))
-			aux = MAKE_FIXNUM((signed char)c);
+			aux = ecl_make_fixnum((signed char)c);
 		else
-			aux = MAKE_FIXNUM((unsigned char)c);
-		output = cl_logior(2, output, cl_ash(aux, MAKE_FIXNUM(nb)));
+			aux = ecl_make_fixnum((unsigned char)c);
+		output = cl_logior(2, output, cl_ash(aux, ecl_make_fixnum(nb)));
 	}
 	return output;
 }
@@ -366,11 +366,11 @@ generic_write_byte_le(cl_object c, cl_object strm)
 	write_byte8 = strm->stream.ops->write_byte8;
 	bs = strm->stream.byte_size;
 	do {
-		cl_object b = cl_logand(2, c, MAKE_FIXNUM(0xFF));
-		unsigned char aux = (unsigned char)fix(b);
+		cl_object b = cl_logand(2, c, ecl_make_fixnum(0xFF));
+		unsigned char aux = (unsigned char)ecl_fix(b);
 		if (write_byte8(strm, &aux, 1) < 1)
 			break;
-		c = cl_ash(c, MAKE_FIXNUM(-8));
+		c = cl_ash(c, ecl_make_fixnum(-8));
 		bs -= 8;
 	} while (bs);
 }
@@ -388,12 +388,12 @@ generic_read_byte(cl_object strm)
 		if (read_byte8(strm, &c, 1) < 1)
 			return Cnil;
 		if (output) {
-			output = cl_logior(2, MAKE_FIXNUM(c),
-					   cl_ash(output, MAKE_FIXNUM(8)));
+			output = cl_logior(2, ecl_make_fixnum(c),
+					   cl_ash(output, ecl_make_fixnum(8)));
 		} else if (strm->stream.flags & ECL_STREAM_SIGNED_BYTES) {
-			output = MAKE_FIXNUM((signed char)c);
+			output = ecl_make_fixnum((signed char)c);
 		} else {
-			output = MAKE_FIXNUM((unsigned char)c);
+			output = ecl_make_fixnum((unsigned char)c);
 		}
 	}
 	return output;
@@ -410,8 +410,8 @@ generic_write_byte(cl_object c, cl_object strm)
 		unsigned char aux;
 		cl_object b;
 		bs -= 8;
-		b = cl_logand(2, MAKE_FIXNUM(0xFF), bs? cl_ash(c, MAKE_FIXNUM(-bs)) : c);
-		aux = (unsigned char)fix(b);
+		b = cl_logand(2, ecl_make_fixnum(0xFF), bs? cl_ash(c, ecl_make_fixnum(-bs)) : c);
+		aux = (unsigned char)ecl_fix(b);
 		if (write_byte8(strm, &aux, 1) < 1)
 			break;
 	} while (bs);
@@ -499,7 +499,7 @@ generic_write_vector(cl_object strm, cl_object data, cl_index start, cl_index en
 #ifdef ECL_UNICODE
 	    elttype == aet_ch ||
 #endif
-	    (elttype == aet_object && CHARACTERP(ecl_elt(data, 0)))) {
+	    (elttype == aet_object && ECL_CHARACTERP(ecl_elt(data, 0)))) {
 		ecl_character (*write_char)(cl_object, ecl_character) = ops->write_char;			
 		for (; start < end; start++) {
 			write_char(strm, ecl_char_code(ecl_elt(data, start)));
@@ -527,7 +527,7 @@ generic_read_vector(cl_object strm, cl_object data, cl_index start, cl_index end
 		for (; start < end; start++) {
 			cl_fixnum c = read_char(strm);
 			if (c == EOF) break;
-			ecl_elt_set(data, start, CODE_CHAR(c));
+			ecl_elt_set(data, start, ECL_CODE_CHAR(c));
 		}
 	} else {
 		cl_object (*read_byte)(cl_object) = ops->read_byte;
@@ -563,7 +563,7 @@ eformat_unread_char(cl_object strm, ecl_character c)
 			ndx += strm->stream.encoder(strm, buffer+ndx, i);
 		}
 		while (ndx != 0) {
-			l = CONS(MAKE_FIXNUM(buffer[--ndx]), l);
+			l = CONS(ecl_make_fixnum(buffer[--ndx]), l);
 		}
 		strm->stream.byte_stack = l;
 		strm->stream.last_char = EOF;
@@ -926,7 +926,7 @@ user_decoder(cl_object stream)
 	if (ecl_read_byte8(stream, buffer, 1) < 1) {
 		return EOF;
 	}
-	character = ecl_gethash_safe(MAKE_FIXNUM(buffer[0]), table, Cnil);
+	character = ecl_gethash_safe(ecl_make_fixnum(buffer[0]), table, Cnil);
 	unlikely_if (Null(character)) {
                 return decoding_error(stream, buffer, 1);
 	}
@@ -935,23 +935,23 @@ user_decoder(cl_object stream)
 			return EOF;
 		} else {
 			cl_fixnum byte = (buffer[0]<<8) + buffer[1];
-			character = ecl_gethash_safe(MAKE_FIXNUM(byte), table, Cnil);
+			character = ecl_gethash_safe(ecl_make_fixnum(byte), table, Cnil);
 			unlikely_if (Null(character)) {
                                 return decoding_error(stream, buffer, 2);
 			}
 		}
 	}
-	return CHAR_CODE(character);
+	return ECL_CHAR_CODE(character);
 }
 
 static int
 user_encoder(cl_object stream, unsigned char *buffer, ecl_character c)
 {
-	cl_object byte = ecl_gethash_safe(CODE_CHAR(c), stream->stream.format_table, Cnil);
+	cl_object byte = ecl_gethash_safe(ECL_CODE_CHAR(c), stream->stream.format_table, Cnil);
 	if (Null(byte)) {
 		return encoding_error(stream, buffer, c);
 	} else {
-		cl_fixnum code = fix(byte);
+		cl_fixnum code = ecl_fix(byte);
 		if (code > 0xFF) {
 			buffer[1] = code & 0xFF; code >>= 8;
 			buffer[0] = code;
@@ -980,9 +980,9 @@ user_multistate_decoder(cl_object stream)
 			return EOF;
 		}
 		j = (j << 8) | buffer[i];
-		character = ecl_gethash_safe(MAKE_FIXNUM(j), table, Cnil);
-		if (CHARACTERP(character)) {
-			return CHAR_CODE(character);
+		character = ecl_gethash_safe(ecl_make_fixnum(j), table, Cnil);
+		if (ECL_CHARACTERP(character)) {
+			return ECL_CHAR_CODE(character);
 		}
 		unlikely_if (Null(character)) {
                         return decoding_error(stream, buffer, i);
@@ -1010,15 +1010,15 @@ user_multistate_encoder(cl_object stream, unsigned char *buffer, ecl_character c
 	cl_object p = table_list;
 	do {
 		cl_object table = ECL_CONS_CAR(p);
-		cl_object byte = ecl_gethash_safe(CODE_CHAR(c), table, Cnil);
+		cl_object byte = ecl_gethash_safe(ECL_CODE_CHAR(c), table, Cnil);
 		if (!Null(byte)) {
-			cl_fixnum code = fix(byte);
+			cl_fixnum code = ecl_fix(byte);
 			ecl_character n = 0;
 			if (p != table_list) {
 				/* Must output a escape sequence */
 				cl_object x = ecl_gethash_safe(Ct, table, Cnil);
 				while (!Null(x)) {
-					buffer[0] = fix(ECL_CONS_CAR(x));
+					buffer[0] = ecl_fix(ECL_CONS_CAR(x));
 					buffer++;
 					x = ECL_CONS_CDR(x);
 					n++;
@@ -1135,9 +1135,9 @@ clos_stream_read_byte8(cl_object strm, unsigned char *c, cl_index n)
 	cl_index i;
 	for (i = 0; i < n; i++) {
 		cl_object byte = _ecl_funcall2(@'gray::stream-read-byte', strm);
-		if (!FIXNUMP(byte))
+		if (!ECL_FIXNUMP(byte))
 			break;
-		c[i] = fix(byte);
+		c[i] = ecl_fix(byte);
 	}
 	return i;
 }
@@ -1148,8 +1148,8 @@ clos_stream_write_byte8(cl_object strm, unsigned char *c, cl_index n)
 	cl_index i;
 	for (i = 0; i < n; i++) {
 		cl_object byte = _ecl_funcall3(@'gray::stream-write-byte', strm,
-					 MAKE_FIXNUM(c[i]));
-		if (!FIXNUMP(byte))
+					 ecl_make_fixnum(c[i]));
+		if (!ECL_FIXNUMP(byte))
 			break;
 	}
 	return i;
@@ -1174,10 +1174,10 @@ clos_stream_read_char(cl_object strm)
 {
 	cl_object output = _ecl_funcall2(@'gray::stream-read-char', strm);
         cl_fixnum value;
-	if (CHARACTERP(output))
-                value = CHAR_CODE(output);
-        else if (FIXNUMP(output))
-                value = fix(output);
+	if (ECL_CHARACTERP(output))
+                value = ECL_CHAR_CODE(output);
+        else if (ECL_FIXNUMP(output))
+                value = ecl_fix(output);
 	else if (output == Cnil || output == @':eof')
 		return EOF;
         else
@@ -1190,14 +1190,14 @@ clos_stream_read_char(cl_object strm)
 static ecl_character
 clos_stream_write_char(cl_object strm, ecl_character c)
 {
-	_ecl_funcall3(@'gray::stream-write-char', strm, CODE_CHAR(c));
+	_ecl_funcall3(@'gray::stream-write-char', strm, ECL_CODE_CHAR(c));
 	return c;
 }
 
 static void
 clos_stream_unread_char(cl_object strm, ecl_character c)
 {
-	_ecl_funcall3(@'gray::stream-unread-char', strm, CODE_CHAR(c));
+	_ecl_funcall3(@'gray::stream-unread-char', strm, ECL_CODE_CHAR(c));
 }
 
 static int
@@ -1637,7 +1637,7 @@ ecl_make_string_input_stream(cl_object strng, cl_index istart, cl_index iend)
 	return strm;
 }
 
-@(defun make_string_input_stream (strng &o (istart MAKE_FIXNUM(0)) iend)
+@(defun make_string_input_stream (strng &o (istart ecl_make_fixnum(0)) iend)
         cl_index_pair p;
 @
 	strng = cl_string(strng);
@@ -1915,7 +1915,7 @@ broadcast_length(cl_object strm)
 {
 	cl_object l = BROADCAST_STREAM_LIST(strm);
 	if (Null(l))
-		return MAKE_FIXNUM(0);
+		return ecl_make_fixnum(0);
 	return ecl_file_length(ECL_CONS_CAR(l));
 }
 
@@ -1924,7 +1924,7 @@ broadcast_get_position(cl_object strm)
 {
 	cl_object l = BROADCAST_STREAM_LIST(strm);
 	if (Null(l))
-		return MAKE_FIXNUM(0);
+		return ecl_make_fixnum(0);
 	return ecl_file_position(ECL_CONS_CAR(l));
 }
 
@@ -2627,7 +2627,7 @@ consume_byte_stack(cl_object strm, unsigned char *c, cl_index n)
 		cl_object l = strm->stream.byte_stack;
 		if (l == Cnil)
 			return out + strm->stream.ops->read_byte8(strm, c, n);
-		*(c++) = fix(ECL_CONS_CAR(l));
+		*(c++) = ecl_fix(ECL_CONS_CAR(l));
 		out++;
 		n--;
 		strm->stream.byte_stack = l = ECL_CONS_CDR(l);
@@ -2758,8 +2758,8 @@ io_file_length(cl_object strm)
 	cl_object output = ecl_file_len(f);
 	if (strm->stream.byte_size != 8) {
 		cl_index bs = strm->stream.byte_size;
-		output = ecl_floor2(output, MAKE_FIXNUM(bs/8));
-		unlikely_if (VALUES(1) != MAKE_FIXNUM(0)) {
+		output = ecl_floor2(output, ecl_make_fixnum(bs/8));
+		unlikely_if (VALUES(1) != ecl_make_fixnum(0)) {
 			FEerror("File length is not on byte boundary", 0);
 		}
 	}
@@ -2793,7 +2793,7 @@ io_file_get_position(cl_object strm)
 		}
 	}
 	if (strm->stream.byte_size != 8) {
-		output = ecl_floor2(output, MAKE_FIXNUM(strm->stream.byte_size / 8));
+		output = ecl_floor2(output, ecl_make_fixnum(strm->stream.byte_size / 8));
 	}
 	return output;
 }
@@ -2810,7 +2810,7 @@ io_file_set_position(cl_object strm, cl_object large_disp)
 	} else {
 		if (strm->stream.byte_size != 8) {
 			large_disp = ecl_times(large_disp,
-					       MAKE_FIXNUM(strm->stream.byte_size / 8));
+					       ecl_make_fixnum(strm->stream.byte_size / 8));
 		}
 		disp = ecl_integer_to_off_t(large_disp);
 		mode = SEEK_SET;
@@ -3093,7 +3093,7 @@ set_stream_elt_type(cl_object stream, cl_fixnum byte_size, int flags,
 	stream->stream.ops->write_char = eformat_write_char;
 	switch (flags & ECL_STREAM_FORMAT) {
 	case ECL_STREAM_BINARY:
-		IO_STREAM_ELT_TYPE(stream) = cl_list(2, t, MAKE_FIXNUM(byte_size));
+		IO_STREAM_ELT_TYPE(stream) = cl_list(2, t, ecl_make_fixnum(byte_size));
 		stream->stream.format = t;
 		stream->stream.ops->read_char = not_character_read_char;
 		stream->stream.ops->write_char = not_character_write_char;
@@ -3184,7 +3184,7 @@ set_stream_elt_type(cl_object stream, cl_fixnum byte_size, int flags,
 #endif
 	default:
 		FEerror("Invalid or unsupported external format ~A with code ~D",
-			2, external_format, MAKE_FIXNUM(flags));
+			2, external_format, ecl_make_fixnum(flags));
  	}
 	t = @':LF';
 	if (stream->stream.ops->write_char == eformat_write_char &&
@@ -3426,8 +3426,8 @@ io_stream_length(cl_object strm)
 	cl_object output = ecl_file_len(fileno(f));
 	if (strm->stream.byte_size != 8) {
 		cl_index bs = strm->stream.byte_size;
-		output = ecl_floor2(output, MAKE_FIXNUM(bs/8));
-		unlikely_if (VALUES(1) != MAKE_FIXNUM(0)) {
+		output = ecl_floor2(output, ecl_make_fixnum(bs/8));
+		unlikely_if (VALUES(1) != ecl_make_fixnum(0)) {
 			FEerror("File length is not on byte boundary", 0);
 		}
 	}
@@ -3461,7 +3461,7 @@ io_stream_get_position(cl_object strm)
 		}
 	}
 	if (strm->stream.byte_size != 8) {
-		output = ecl_floor2(output, MAKE_FIXNUM(strm->stream.byte_size / 8));
+		output = ecl_floor2(output, ecl_make_fixnum(strm->stream.byte_size / 8));
 	}
 	return output;
 }
@@ -3478,7 +3478,7 @@ io_stream_set_position(cl_object strm, cl_object large_disp)
 	} else {
 		if (strm->stream.byte_size != 8) {
 			large_disp = ecl_times(large_disp,
-					       MAKE_FIXNUM(strm->stream.byte_size / 8));
+					       ecl_make_fixnum(strm->stream.byte_size / 8));
 		}
 		disp = ecl_integer_to_off_t(large_disp);
 		mode = SEEK_SET;
@@ -3875,7 +3875,7 @@ wcon_stream_read_byte8(cl_object strm, unsigned char *c, cl_index n)
 				} else {
 					strm->stream.byte_stack =
 						ecl_nconc(strm->stream.byte_stack,
-							  ecl_list1(MAKE_FIXNUM(aux[i])));
+							  ecl_list1(ecl_make_fixnum(aux[i])));
 				}
 			}
 		}
@@ -4078,7 +4078,7 @@ ecl_make_stream_from_FILE(cl_object fname, void *f, enum ecl_smmode smm,
 		break;
 #endif
 	default:
-		FEerror("Not a valid mode ~D for ecl_make_stream_from_FILE", 1, MAKE_FIXNUM(smm));
+		FEerror("Not a valid mode ~D for ecl_make_stream_from_FILE", 1, ecl_make_fixnum(smm));
 	}
 	set_stream_elt_type(stream, byte_size, flags, external_format);
 	IO_STREAM_FILENAME(stream) = fname; /* not really used */
@@ -4186,12 +4186,12 @@ si_file_stream_fd(cl_object s)
 	case smm_input:
 	case smm_output:
 	case smm_io:
-                ret = MAKE_FIXNUM(fileno(IO_STREAM_FILE(s)));
+                ret = ecl_make_fixnum(fileno(IO_STREAM_FILE(s)));
                 break;
 	case smm_input_file:
 	case smm_output_file:
 	case smm_io_file:
-                ret = MAKE_FIXNUM(IO_FILE_DESCRIPTOR(s));
+                ret = ecl_make_fixnum(IO_FILE_DESCRIPTOR(s));
                 break;
 	default:
 		ecl_internal_error("not a file stream");
@@ -4344,7 +4344,7 @@ make_sequence_input_stream(cl_object vector, cl_index istart, cl_index iend,
 }
 
 @(defun ext::make_sequence_input_stream (vector &key
-                                         (start MAKE_FIXNUM(0))
+                                         (start ecl_make_fixnum(0))
                                          (end Cnil)
                                          (external_format Cnil))
         cl_index_pair p;
@@ -4371,7 +4371,7 @@ seq_out_write_byte8(cl_object strm, unsigned char *c, cl_index n)
         if (delta < n) {
                 /* Not enough space, enlarge */
                 vector = _ecl_funcall3(@'adjust-array', vector,
-				       ecl_ash(MAKE_FIXNUM(last), 1));
+				       ecl_ash(ecl_make_fixnum(last), 1));
                 SEQ_OUTPUT_VECTOR(strm) = vector;
                 goto AGAIN;
         }
@@ -4715,7 +4715,7 @@ cl_file_string_length(cl_object stream, cl_object string)
 	if (stream->stream.mode == smm_broadcast) {
 		stream = BROADCAST_STREAM_LIST(stream);
 		if (Null(stream)) {
-			@(return MAKE_FIXNUM(1));
+			@(return ecl_make_fixnum(1));
 		} else {
 			goto BEGIN;
 		}
@@ -4735,12 +4735,12 @@ cl_file_string_length(cl_object stream, cl_object string)
 		break;
 	}
 	case t_character:
-		l = compute_char_size(stream, CHAR_CODE(string));
+		l = compute_char_size(stream, ECL_CHAR_CODE(string));
 		break;
 	default:
                 FEwrong_type_nth_arg(@[file-string-length], 2, string, @[string]);
 	}
-	@(return MAKE_FIXNUM(l))
+	@(return ecl_make_fixnum(l))
 }
 
 cl_object
@@ -4754,20 +4754,20 @@ si_do_write_sequence(cl_object seq, cl_object stream, cl_object s, cl_object e)
 	   object, and seq == Cnil i.f.f. t = t_symbol */
 	limit = ecl_length(seq);
         if (ecl_unlikely(!ECL_FIXNUMP(s) ||
-                         ((start = fix(s)) < 0) ||
+                         ((start = ecl_fix(s)) < 0) ||
                          (start > limit))) {
                 FEwrong_type_key_arg(@[write-sequence], @[:start], s,
-                                     ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                           MAKE_FIXNUM(limit-1)));
+                                     ecl_make_integer_type(ecl_make_fixnum(0),
+                                                           ecl_make_fixnum(limit-1)));
         }
 	if (e == Cnil) {
 		end = limit;
 	} else if (ecl_unlikely(!ECL_FIXNUMP(e) ||
-                                ((end = fix(e)) < 0) ||
+                                ((end = ecl_fix(e)) < 0) ||
                                 (end > limit))) {
                 FEwrong_type_key_arg(@[write-sequence], @[:end], e,
-                                     ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                           MAKE_FIXNUM(limit)));
+                                     ecl_make_integer_type(ecl_make_fixnum(0),
+                                                           ecl_make_fixnum(limit)));
         }
 	if (end <= start) {
 		goto OUTPUT;
@@ -4807,20 +4807,20 @@ si_do_read_sequence(cl_object seq, cl_object stream, cl_object s, cl_object e)
 	   object, and seq == Cnil i.f.f. t = t_symbol */
 	limit = ecl_length(seq);
         if (ecl_unlikely(!ECL_FIXNUMP(s) ||
-                         ((start = fix(s)) < 0) ||
+                         ((start = ecl_fix(s)) < 0) ||
                          (start > limit))) {
                 FEwrong_type_key_arg(@[read-sequence], @[:start], s,
-                                     ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                           MAKE_FIXNUM(limit-1)));
+                                     ecl_make_integer_type(ecl_make_fixnum(0),
+                                                           ecl_make_fixnum(limit-1)));
         }
 	if (e == Cnil) {
 		end = limit;
 	} else if (ecl_unlikely(!ECL_FIXNUMP(e) ||
-                                ((end = fix(e)) < 0) ||
+                                ((end = ecl_fix(e)) < 0) ||
                                 (end > limit))) {
                 FEwrong_type_key_arg(@[read-sequence], @[:end], e,
-                                     ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                           MAKE_FIXNUM(limit)));
+                                     ecl_make_integer_type(ecl_make_fixnum(0),
+                                                           ecl_make_fixnum(limit)));
         }
 	if (end <= start) {
 		goto OUTPUT;
@@ -4838,7 +4838,7 @@ si_do_read_sequence(cl_object seq, cl_object stream, cl_object s, cl_object e)
 				if (ischar) {
 					int i = ops->read_char(stream);
 					if (i < 0) goto OUTPUT;
-					c = CODE_CHAR(i);
+					c = ECL_CODE_CHAR(i);
 				} else {
 					c = ops->read_byte(stream);
 					if (c == Cnil) goto OUTPUT;
@@ -4851,7 +4851,7 @@ si_do_read_sequence(cl_object seq, cl_object stream, cl_object s, cl_object e)
 		start = ops->read_vector(stream, seq, start, end);
 	}
  OUTPUT:
-	@(return MAKE_FIXNUM(start))
+	@(return ecl_make_fixnum(start))
 }
 
 /**********************************************************************
@@ -4861,7 +4861,7 @@ si_do_read_sequence(cl_object seq, cl_object stream, cl_object s, cl_object e)
 cl_object
 si_file_column(cl_object strm)
 {
-	@(return MAKE_FIXNUM(ecl_file_column(strm)))
+	@(return ecl_make_fixnum(ecl_file_column(strm)))
 }
 
 cl_object
@@ -4877,7 +4877,7 @@ cl_file_length(cl_object strm)
 		output = ecl_file_position(file_stream);
 	} else {
 		if (position == @':start') {
-			position = MAKE_FIXNUM(0);
+			position = ecl_make_fixnum(0);
 		} else if (position == @':end') {
 			position = Cnil;
 		}
@@ -5010,7 +5010,7 @@ ecl_normalize_stream_element_type(cl_object element_type)
 	for (size = 8; 1; size++) {
 		cl_object type;
 		type = cl_list(2, sign>0? @'unsigned-byte' : @'signed-byte',
-			       MAKE_FIXNUM(size));
+			       ecl_make_fixnum(size));
 		if (_ecl_funcall3(@'subtypep', element_type, type) != Cnil) {
 			return size * sign;
 		}
@@ -5098,7 +5098,7 @@ ecl_open_stream(cl_object fn, enum ecl_smmode smm, cl_object if_exists,
 			}
 		}
 	} else {
-		FEerror("Illegal stream mode ~S", 1, MAKE_FIXNUM(smm));
+		FEerror("Illegal stream mode ~S", 1, ecl_make_fixnum(smm));
 	}
 	if (flags & ECL_STREAM_C_STREAM) {
 		FILE *fp;
@@ -5127,7 +5127,7 @@ ecl_open_stream(cl_object fn, enum ecl_smmode smm, cl_object if_exists,
 		output->stream.flags |= ECL_STREAM_MIGHT_SEEK;
 		si_set_finalizer(output, Ct);
 		/* Set file pointer to the correct position */
-		ecl_file_position_set(output, appending? Cnil : MAKE_FIXNUM(0));
+		ecl_file_position_set(output, appending? Cnil : ecl_make_fixnum(0));
 	}
 	return output;
 }
@@ -5279,7 +5279,7 @@ file_listen(int fileno)
 			break;
 		}
 		default:
-			FEerror("Unsupported Windows file type: ~A", 1, MAKE_FIXNUM(GetFileType(hnd)));
+			FEerror("Unsupported Windows file type: ~A", 1, ecl_make_fixnum(GetFileType(hnd)));
 			break;
 	}
 #endif
@@ -5321,7 +5321,7 @@ ecl_off_t_to_integer(ecl_off_t offset)
 	if (sizeof(ecl_off_t) == sizeof(cl_fixnum)) {
 		output = ecl_make_integer(offset);
 	} else if (offset <= MOST_POSITIVE_FIXNUM) {
-		output = MAKE_FIXNUM((cl_fixnum)offset);
+		output = ecl_make_fixnum((cl_fixnum)offset);
 	} else {
 		cl_object y = _ecl_big_register0();
 		if (sizeof(y->big.big_limbs[0]) == sizeof(cl_index)) {
@@ -5344,7 +5344,7 @@ ecl_integer_to_off_t(cl_object offset)
 	ecl_off_t output = 0;
 	if (sizeof(ecl_off_t) == sizeof(cl_fixnum)) {
 		output = fixint(offset);
-	} else if (FIXNUMP(offset)) {
+	} else if (ECL_FIXNUMP(offset)) {
 		output = fixint(offset);
 	} else if (ECL_BIGNUMP(offset)) {
 		if (sizeof(offset->big.big_limbs[0]) == sizeof(cl_index)) {
@@ -5523,7 +5523,7 @@ decoding_error(cl_object stream, unsigned char *buffer, int length)
 {
         cl_object octets = Cnil, code;
         while (length > 0) {
-                octets = CONS(MAKE_FIXNUM(buffer[--length]), octets);
+                octets = CONS(ecl_make_fixnum(buffer[--length]), octets);
         }
         code = _ecl_funcall4(@'ext::decoding-error', stream,
 			    cl_stream_external_format(stream),
diff --git a/src/c/format.d b/src/c/format.d
index 088629fdb..a39852423 100644
--- a/src/c/format.d
+++ b/src/c/format.d
@@ -118,7 +118,7 @@ fmt_error(format_stack fmt, const char *s)
 	cl_error(7, @'si::format-error',
 		 @':format-control', make_constant_base_string(s),
 		 @':control-string', fmt->ctl_str,
-		 @':offset', MAKE_FIXNUM(fmt->ctl_index));
+		 @':offset', ecl_make_fixnum(fmt->ctl_index));
 }
 
 static ecl_character
@@ -284,7 +284,7 @@ set_param(format_stack fmt, int i, int t, cl_object v)
 		return v;
 	else if ((t != INT && t != CHAR) ||
 		 (t == INT && !cl_integerp(fmt->param[i])) ||
-		 (t == CHAR && !CHARACTERP(fmt->param[i])))
+		 (t == CHAR && !ECL_CHARACTERP(fmt->param[i])))
 		fmt_error(fmt, "illegal parameter type");
 	return fmt->param[i];
 }
@@ -338,10 +338,10 @@ fmt_ascii(format_stack fmt, bool colon, bool atsign)
 	int l, i;
 
 	ensure_param(fmt, 4);
-	mincol = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
-	colinc = ecl_to_fix(set_param(fmt, 1, INT, MAKE_FIXNUM(1)));
-	minpad = ecl_to_fix(set_param(fmt, 2, INT, MAKE_FIXNUM(0)));
-	padchar = CHAR_CODE(set_param(fmt, 3, CHAR, CODE_CHAR(' ')));
+	mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
+	colinc = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(1)));
+	minpad = ecl_to_fix(set_param(fmt, 2, INT, ecl_make_fixnum(0)));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR(' ')));
 
 	fmt_prepare_aux_stream(fmt);
 	x = fmt_advance(fmt);
@@ -375,10 +375,10 @@ fmt_S_expression(format_stack fmt, bool colon, bool atsign)
 	int l, i;
 
 	ensure_param(fmt, 4);
-	mincol = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
-	colinc = ecl_to_fix(set_param(fmt, 1, INT, MAKE_FIXNUM(1)));
-	minpad = ecl_to_fix(set_param(fmt, 2, INT, MAKE_FIXNUM(0)));
-	padchar = CHAR_CODE(set_param(fmt, 3, CHAR, CODE_CHAR(' ')));
+	mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
+	colinc = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(1)));
+	minpad = ecl_to_fix(set_param(fmt, 2, INT, ecl_make_fixnum(0)));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR(' ')));
 
 	fmt_prepare_aux_stream(fmt);
 	x = fmt_advance(fmt);
@@ -412,10 +412,10 @@ fmt_integer(format_stack fmt, cl_object x, bool colon, bool atsign,
 	int l, l1;
 	int s;
 
-	if (!FIXNUMP(x) && type_of(x) != t_bignum) {
+	if (!ECL_FIXNUMP(x) && type_of(x) != t_bignum) {
 		fmt_prepare_aux_stream(fmt);
 		ecl_bds_bind(env, @'*print-escape*', Cnil);
-		ecl_bds_bind(env, @'*print-base*', MAKE_FIXNUM(radix));
+		ecl_bds_bind(env, @'*print-base*', ecl_make_fixnum(radix));
 		si_write_object(x, fmt->aux_stream);
 		ecl_bds_unwind_n(env, 2);
 		l = fmt->aux_string->base_string.fillp;
@@ -427,7 +427,7 @@ fmt_integer(format_stack fmt, cl_object x, bool colon, bool atsign,
 	}
 	fmt_prepare_aux_stream(fmt);
 	ecl_bds_bind(env, @'*print-radix*', Cnil);
-	ecl_bds_bind(env, @'*print-base*', MAKE_FIXNUM(radix));
+	ecl_bds_bind(env, @'*print-base*', ecl_make_fixnum(radix));
 	si_write_object(x, fmt->aux_stream);
 	ecl_bds_unwind_n(env, 2);
 	l = l1 = fmt->aux_string->base_string.fillp;
@@ -460,9 +460,9 @@ fmt_decimal(format_stack fmt, bool colon, bool atsign)
 	ecl_character padchar, commachar;
 
 	ensure_param(fmt, 3);
-	mincol = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
-	padchar = CHAR_CODE(set_param(fmt, 1, CHAR, CODE_CHAR(' ')));
-	commachar = CHAR_CODE(set_param(fmt, 2, CHAR, CODE_CHAR(',')));
+	mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 1, CHAR, ECL_CODE_CHAR(' ')));
+	commachar = ECL_CHAR_CODE(set_param(fmt, 2, CHAR, ECL_CODE_CHAR(',')));
 	fmt_integer(fmt, fmt_advance(fmt), colon, atsign,
 		    10, mincol, padchar, commachar);
 }
@@ -474,9 +474,9 @@ fmt_binary(format_stack fmt, bool colon, bool atsign)
 	ecl_character padchar, commachar;
 
 	ensure_param(fmt, 3);
-	mincol = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
-	padchar = CHAR_CODE(set_param(fmt, 1, CHAR, CODE_CHAR(' ')));
-	commachar = CHAR_CODE(set_param(fmt, 2, CHAR, CODE_CHAR(',')));
+	mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 1, CHAR, ECL_CODE_CHAR(' ')));
+	commachar = ECL_CHAR_CODE(set_param(fmt, 2, CHAR, ECL_CODE_CHAR(',')));
 	fmt_integer(fmt, fmt_advance(fmt), colon, atsign,
 		    2, mincol, padchar, commachar);
 }
@@ -488,9 +488,9 @@ fmt_octal(format_stack fmt, bool colon, bool atsign)
 	ecl_character padchar, commachar;
 
 	ensure_param(fmt, 3);
-	mincol = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
-	padchar = CHAR_CODE(set_param(fmt, 1, CHAR, CODE_CHAR(' ')));
-	commachar = CHAR_CODE(set_param(fmt, 2, CHAR, CODE_CHAR(',')));
+	mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 1, CHAR, ECL_CODE_CHAR(' ')));
+	commachar = ECL_CHAR_CODE(set_param(fmt, 2, CHAR, ECL_CODE_CHAR(',')));
 	fmt_integer(fmt, fmt_advance(fmt), colon, atsign,
 		    8, mincol, padchar, commachar);
 }
@@ -502,9 +502,9 @@ fmt_hexadecimal(format_stack fmt, bool colon, bool atsign)
 	ecl_character padchar, commachar;
 
 	ensure_param(fmt, 3);
-	mincol = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
-	padchar = CHAR_CODE(set_param(fmt, 1, CHAR, CODE_CHAR(' ')));
-	commachar = CHAR_CODE(set_param(fmt, 2, CHAR, CODE_CHAR(',')));
+	mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 1, CHAR, ECL_CODE_CHAR(' ')));
+	commachar = ECL_CHAR_CODE(set_param(fmt, 2, CHAR, ECL_CODE_CHAR(',')));
 	fmt_integer(fmt, fmt_advance(fmt), colon, atsign,
 		    16, mincol, padchar, commachar);
 }
@@ -637,8 +637,8 @@ fmt_radix(format_stack fmt, bool colon, bool atsign)
 		x = fmt_advance(fmt);
 		assert_type_integer(x);
 		if (atsign) {
-			if (FIXNUMP(x))
-				i = fix(x);
+			if (ECL_FIXNUMP(x))
+				i = ecl_fix(x);
 			else
 				i = -1;
 			if ((!colon && (i <= 0 || i >= 4000)) ||
@@ -654,7 +654,7 @@ fmt_radix(format_stack fmt, bool colon, bool atsign)
 		}
 		fmt_prepare_aux_stream(fmt);
 		ecl_bds_bind(env, @'*print-radix*', Cnil);
-		ecl_bds_bind(env, @'*print-base*', MAKE_FIXNUM(10));
+		ecl_bds_bind(env, @'*print-base*', ecl_make_fixnum(10));
 		si_write_object(x, fmt->aux_stream);
 		ecl_bds_unwind_n(env, 2);
 		s = 0;
@@ -686,14 +686,14 @@ fmt_radix(format_stack fmt, bool colon, bool atsign)
 		return;
 	}
 	ensure_param(fmt, 4);
-	radix = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(10)));
-	mincol = ecl_to_fix(set_param(fmt, 1, INT, MAKE_FIXNUM(0)));
-	padchar = CHAR_CODE(set_param(fmt, 2, CHAR, CODE_CHAR(' ')));
-	commachar = CHAR_CODE(set_param(fmt, 3, CHAR, CODE_CHAR(',')));
+	radix = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(10)));
+	mincol = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(0)));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 2, CHAR, ECL_CODE_CHAR(' ')));
+	commachar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR(',')));
 	x = fmt_advance(fmt);
 	assert_type_integer(x);
 	if (radix < 0 || radix > 36)
-		FEerror("~D is illegal as a radix.", 1, MAKE_FIXNUM(radix));
+		FEerror("~D is illegal as a radix.", 1, ecl_make_fixnum(radix));
 	fmt_integer(fmt, x, colon, atsign, radix, mincol, padchar, commachar);
 }
 
@@ -704,7 +704,7 @@ fmt_plural(format_stack fmt, bool colon, bool atsign)
 	if (colon) {
 		fmt_back_up(fmt);
 	}
-	if (ecl_eql(fmt_advance(fmt), MAKE_FIXNUM(1))) {
+	if (ecl_eql(fmt_advance(fmt), ecl_make_fixnum(1))) {
 		if (atsign)
 			ecl_write_char('y', fmt->stream);
 	      }
@@ -725,7 +725,7 @@ fmt_character(format_stack fmt, bool colon, bool atsign)
 	x = fmt_advance(fmt);
 	x = ecl_check_cl_type(@'format',x,t_character);
 	if (!colon && !atsign) {
-		ecl_write_char(CHAR_CODE(x), fmt->stream);
+		ecl_write_char(ECL_CHAR_CODE(x), fmt->stream);
 	} else {
 		fmt_prepare_aux_stream(fmt);
 		ecl_prin1(x, fmt->aux_stream);
@@ -861,16 +861,16 @@ fmt_fix_float(format_stack fmt, bool colon, bool atsign)
 	ensure_param(fmt, 5);
 	w = set_param_positive(fmt, 0, "illegal width");
 	d = set_param_positive(fmt, 1, "illegal number of digits");
-	k = ecl_to_fix(set_param(fmt, 2, INT, MAKE_FIXNUM(0)));
-	overflowchar = CHAR_CODE(set_param(fmt, 3, CHAR, CODE_CHAR('\0')));
-	padchar = CHAR_CODE(set_param(fmt, 4, CHAR, CODE_CHAR(' ')));
+	k = ecl_to_fix(set_param(fmt, 2, INT, ecl_make_fixnum(0)));
+	overflowchar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR('\0')));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 4, CHAR, ECL_CODE_CHAR(' ')));
 
 	x = fmt_advance(fmt);
-	if (FIXNUMP(x) ||
+	if (ECL_FIXNUMP(x) ||
 	    type_of(x) == t_bignum ||
 	    type_of(x) == t_ratio)
 		x = ecl_make_singlefloat(ecl_to_float(x));
-	if (!REAL_TYPE(type_of(x))) {
+	if (!ECL_REAL_TYPE_P(type_of(x))) {
 		if (fmt->nparam > 1) fmt->nparam = 1;
 		fmt_back_up(fmt);
 		fmt_decimal(fmt, colon, atsign);
@@ -946,7 +946,7 @@ fmt_fix_float(format_stack fmt, bool colon, bool atsign)
 		if (sign < 0 || atsign)
 			--w;
 		if (j > w && overflowchar != '\0') {
-			w = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
+			w = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
 			for (i = 0;  i < w;  i++)
 				ecl_write_char(overflowchar, fmt->stream);
 			return;
@@ -1034,17 +1034,17 @@ fmt_exponential_float(format_stack fmt, bool colon, bool atsign)
 	w = set_param_positive(fmt, 0, "illegal width");
 	d = set_param_positive(fmt, 1, "illegal number of digits");
 	e = set_param_positive(fmt, 2, "illegal number of digits in exponent");
-	k = ecl_to_fix(set_param(fmt, 3, INT, MAKE_FIXNUM(1)));
-	overflowchar = CHAR_CODE(set_param(fmt, 4, CHAR, CODE_CHAR('\0')));
-	padchar = CHAR_CODE(set_param(fmt, 5, CHAR, CODE_CHAR(' ')));
-	exponentchar = CHAR_CODE(set_param(fmt, 6, CHAR, CODE_CHAR('\0')));
+	k = ecl_to_fix(set_param(fmt, 3, INT, ecl_make_fixnum(1)));
+	overflowchar = ECL_CHAR_CODE(set_param(fmt, 4, CHAR, ECL_CODE_CHAR('\0')));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 5, CHAR, ECL_CODE_CHAR(' ')));
+	exponentchar = ECL_CHAR_CODE(set_param(fmt, 6, CHAR, ECL_CODE_CHAR('\0')));
 
 	x = fmt_advance(fmt);
-	if (FIXNUMP(x) ||
+	if (ECL_FIXNUMP(x) ||
 	    type_of(x) == t_bignum ||
 	    type_of(x) == t_ratio)
 		x = ecl_make_singlefloat(ecl_to_float(x));
-	if (!REAL_TYPE(type_of(x))) {
+	if (!ECL_REAL_TYPE_P(type_of(x))) {
 		if (fmt->nparam > 1) fmt->nparam = 1;
 		fmt_back_up(fmt);
 		fmt_decimal(fmt, colon, atsign);
@@ -1197,7 +1197,7 @@ fmt_exponential_float(format_stack fmt, bool colon, bool atsign)
 	return;
 
 OVER:
-	w = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
+	w = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
 	for (i = 0;  i < w;  i++)
 		ecl_write_char(overflowchar, fmt->stream);
 	return;
@@ -1218,13 +1218,13 @@ fmt_general_float(format_stack fmt, bool colon, bool atsign)
 	w = set_param_positive(fmt, 0, "illegal width");
 	d = set_param_positive(fmt, 1, "illegal number of digits");
 	e = set_param_positive(fmt, 2, "illegal number of digits in exponent");
-	k = ecl_to_fix(set_param(fmt, 3, INT, MAKE_FIXNUM(1)));
-	overflowchar = CHAR_CODE(set_param(fmt, 4, CHAR, CODE_CHAR('\0')));
-	padchar = CHAR_CODE(set_param(fmt, 5, CHAR, CODE_CHAR(' ')));
-	exponentchar = CHAR_CODE(set_param(fmt, 6, CHAR, CODE_CHAR('\0')));
+	k = ecl_to_fix(set_param(fmt, 3, INT, ecl_make_fixnum(1)));
+	overflowchar = ECL_CHAR_CODE(set_param(fmt, 4, CHAR, ECL_CODE_CHAR('\0')));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 5, CHAR, ECL_CODE_CHAR(' ')));
+	exponentchar = ECL_CHAR_CODE(set_param(fmt, 6, CHAR, ECL_CODE_CHAR('\0')));
 
 	x = fmt_advance(fmt);
-	if (!REAL_TYPE(type_of(x))) {
+	if (!ECL_REAL_TYPE_P(type_of(x))) {
 		if (fmt->nparam > 1) fmt->nparam = 1;
 		fmt_back_up(fmt);
 		fmt_decimal(fmt, colon, atsign);
@@ -1253,8 +1253,8 @@ fmt_general_float(format_stack fmt, bool colon, bool atsign)
 	dd = d - n;
 	if (0 <= dd && dd <= d) {
 		fmt->nparam = 5;
-		fmt->param[0] = MAKE_FIXNUM(ww);
-		fmt->param[1] = MAKE_FIXNUM(dd);
+		fmt->param[0] = ecl_make_fixnum(ww);
+		fmt->param[1] = ecl_make_fixnum(dd);
 		fmt->param[2] = Cnil;
 		fmt->param[3] = fmt->param[4];
 		fmt->param[4] = fmt->param[5];
@@ -1265,7 +1265,7 @@ fmt_general_float(format_stack fmt, bool colon, bool atsign)
 				ecl_write_char(padchar, fmt->stream);
 		return;
 	}
-	fmt->param[1] = MAKE_FIXNUM(d);
+	fmt->param[1] = ecl_make_fixnum(d);
 	fmt_back_up(fmt);
 	fmt_exponential_float(fmt, colon, atsign);
 }
@@ -1289,9 +1289,9 @@ fmt_dollars_float(format_stack fmt, bool colon, bool atsign)
 	if (n < 0) n = 1;
 	w = set_param_positive(fmt, 2, "illegal width");
 	if (w < 0) w = 0;
-	padchar = CHAR_CODE(set_param(fmt, 3, CHAR, CODE_CHAR(' ')));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR(' ')));
 	x = fmt_advance(fmt);
-	if (!REAL_TYPE(type_of(x))) {
+	if (!ECL_REAL_TYPE_P(type_of(x))) {
 		if (fmt->nparam < 3)
 			fmt->nparam = 0;
 		else {
@@ -1313,7 +1313,7 @@ fmt_dollars_float(format_stack fmt, bool colon, bool atsign)
 	if (w > 100 || exp > 100 || exp < -100) {
 		fmt->nparam = 6;
 		fmt->param[0] = fmt->param[2];
-		fmt->param[1] = MAKE_FIXNUM(d + n - 1);
+		fmt->param[1] = ecl_make_fixnum(d + n - 1);
 		fmt->param[5] = fmt->param[3];
 		fmt->param[2] =
 		fmt->param[3] =
@@ -1355,7 +1355,7 @@ fmt_percent(format_stack fmt, bool colon, bool atsign)
 	int n, i;
 
 	ensure_param(fmt, 1);
-	n = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(1)));
+	n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1)));
 	fmt_not_colon(fmt, colon);
 	fmt_not_atsign(fmt, atsign);
 	while (n-- > 0) {
@@ -1372,7 +1372,7 @@ fmt_ampersand(format_stack fmt, bool colon, bool atsign)
 	int n;
 
 	ensure_param(fmt, 1);
-	n = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(1)));
+	n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1)));
 	fmt_not_colon(fmt, colon);
 	fmt_not_atsign(fmt, atsign);
 	if (n == 0)
@@ -1390,7 +1390,7 @@ fmt_bar(format_stack fmt, bool colon, bool atsign)
 	int n;
 
 	ensure_param(fmt, 1);
-	n = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(1)));
+	n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1)));
 	fmt_not_colon(fmt, colon);
 	fmt_not_atsign(fmt, atsign);
 	while (n-- > 0)
@@ -1403,7 +1403,7 @@ fmt_tilde(format_stack fmt, bool colon, bool atsign)
 	int n;
 
 	ensure_param(fmt, 1);
-	n = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(1)));
+	n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1)));
 	fmt_not_colon(fmt, colon);
 	fmt_not_atsign(fmt, atsign);
 	while (n-- > 0)
@@ -1432,8 +1432,8 @@ fmt_tabulate(format_stack fmt, bool colon, bool atsign)
 
 	ensure_param(fmt, 2);
 	fmt_not_colon(fmt, colon);
-	colnum = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(1)));
-	colinc = ecl_to_fix(set_param(fmt, 1, INT, MAKE_FIXNUM(1)));
+	colnum = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1)));
+	colinc = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(1)));
 	if (!atsign) {
 		c = ecl_file_column(fmt->stream);
 		if (c < 0) {
@@ -1468,13 +1468,13 @@ fmt_asterisk(format_stack fmt, bool colon, bool atsign)
 	ensure_param(fmt, 1);
 	fmt_not_colon_atsign(fmt, colon, atsign);
 	if (atsign) {
-		n = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
+		n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
 		fmt_go(fmt, n);
 	} else if (colon) {
-		n = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(1)));
+		n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1)));
 		fmt_go(fmt, fmt_index(fmt) - n);
 	} else {
-		n = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(1)));
+		n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1)));
 		while (n-- > 0)
 			fmt_advance(fmt);
 	}
@@ -1632,11 +1632,11 @@ fmt_conditional(format_stack fmt, bool colon, bool atsign)
 		ensure_param(fmt, 1);
 		if (fmt->nparam == 0) {
 			x = fmt_advance(fmt);
-			if (!FIXNUMP(x))
+			if (!ECL_FIXNUMP(x))
 				fmt_error(fmt, "illegal argument for conditional");
-			n = fix(x);
+			n = ecl_fix(x);
 		} else
-			n = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
+			n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
 		i = fmt->ctl_index;
 		for (done = FALSE;;  --n) {
 			j = fmt_skip(fmt);
@@ -1688,7 +1688,7 @@ fmt_iteration(format_stack fmt, bool colon, bool atsign)
 	int up_colon;
 
 	ensure_param(fmt, 1);
-	n = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(1000000)));
+	n = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(1000000)));
 	i = fmt->ctl_index;
 	j = fmt_skip(fmt);
 	if (ecl_char(fmt->ctl_str, --j) != '}')
@@ -1800,10 +1800,10 @@ fmt_justification(format_stack fmt, volatile bool colon, bool atsign)
 	volatile int spare_spaces, line_length;
 
 	ensure_param(fmt, 4);
-	mincol = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
-	colinc = ecl_to_fix(set_param(fmt, 1, INT, MAKE_FIXNUM(1)));
-	minpad = ecl_to_fix(set_param(fmt, 2, INT, MAKE_FIXNUM(0)));
-	padchar = CHAR_CODE(set_param(fmt, 3, CHAR, CODE_CHAR(' ')));
+	mincol = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
+	colinc = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(1)));
+	minpad = ecl_to_fix(set_param(fmt, 2, INT, ecl_make_fixnum(0)));
+	padchar = ECL_CHAR_CODE(set_param(fmt, 3, CHAR, ECL_CODE_CHAR(' ')));
 
 	fields = Cnil;
 	for (;;) {
@@ -1913,18 +1913,18 @@ fmt_up_and_out(format_stack fmt, bool colon, bool atsign)
 		if (!fmt_more_args_p(fmt))
 			ecl_longjmp(*fmt->jmp_buf, ++colon);
 	} else if (fmt->nparam == 1) {
-		i = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
+		i = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
 		if (i == 0)
 			ecl_longjmp(*fmt->jmp_buf, ++colon);
 	} else if (fmt->nparam == 2) {
-		i = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
-		j = ecl_to_fix(set_param(fmt, 1, INT, MAKE_FIXNUM(0)));
+		i = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
+		j = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(0)));
 		if (i == j)
 			ecl_longjmp(*fmt->jmp_buf, ++colon);
 	} else {
-		i = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
-		j = ecl_to_fix(set_param(fmt, 1, INT, MAKE_FIXNUM(0)));
-		k = ecl_to_fix(set_param(fmt, 2, INT, MAKE_FIXNUM(0)));
+		i = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
+		j = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(0)));
+		k = ecl_to_fix(set_param(fmt, 2, INT, ecl_make_fixnum(0)));
 		if (i <= j && j <= k)
 			ecl_longjmp(*fmt->jmp_buf, ++colon);
 	}
@@ -1937,8 +1937,8 @@ fmt_semicolon(format_stack fmt, bool colon, bool atsign)
 	if (!colon)
 		fmt_error(fmt, "~~:; expected");
 	ensure_param(fmt, 2);
-	fmt->spare_spaces = ecl_to_fix(set_param(fmt, 0, INT, MAKE_FIXNUM(0)));
-	fmt->line_length = ecl_to_fix(set_param(fmt, 1, INT, MAKE_FIXNUM(72)));
+	fmt->spare_spaces = ecl_to_fix(set_param(fmt, 0, INT, ecl_make_fixnum(0)));
+	fmt->line_length = ecl_to_fix(set_param(fmt, 1, INT, ecl_make_fixnum(72)));
 }
 
 @(defun si::formatter-aux (strm string &rest args)
@@ -2020,24 +2020,24 @@ LOOP:
 			/* FIXME! A hack to solve the problem of bignums in arguments */
 			if (x == OBJNULL || !ecl_numberp(x))
 				fmt_error(fmt, "integer expected");
-			if (ecl_number_compare(x, MAKE_FIXNUM(FMT_VALUE_UPPER_LIMIT)) > 0) {
-				fmt->param[n] = MAKE_FIXNUM(FMT_VALUE_UPPER_LIMIT);
-			} else if (ecl_number_compare(x, MAKE_FIXNUM(FMT_VALUE_LOWER_LIMIT)) < 0) {
-				fmt->param[n] = MAKE_FIXNUM(FMT_VALUE_LOWER_LIMIT);
+			if (ecl_number_compare(x, ecl_make_fixnum(FMT_VALUE_UPPER_LIMIT)) > 0) {
+				fmt->param[n] = ecl_make_fixnum(FMT_VALUE_UPPER_LIMIT);
+			} else if (ecl_number_compare(x, ecl_make_fixnum(FMT_VALUE_LOWER_LIMIT)) < 0) {
+				fmt->param[n] = ecl_make_fixnum(FMT_VALUE_LOWER_LIMIT);
 			} else {
 				fmt->param[n] = x;
 			}
-			if (FIXNUMP(x)) {
+			if (ECL_FIXNUMP(x)) {
 				fmt->param[n] = x;
 			} else if (ecl_plusp(x)) {
-				fmt->param[n] = MAKE_FIXNUM(MOST_POSITIVE_FIXNUM);
+				fmt->param[n] = ecl_make_fixnum(MOST_POSITIVE_FIXNUM);
 			} else {
-				fmt->param[n] = MAKE_FIXNUM(MOST_NEGATIVE_FIXNUM);
+				fmt->param[n] = ecl_make_fixnum(MOST_NEGATIVE_FIXNUM);
 			}
 			break;
 
 		case '\'':
-			fmt->param[n] = CODE_CHAR(ctl_advance(fmt));
+			fmt->param[n] = ECL_CODE_CHAR(ctl_advance(fmt));
 			c = ctl_advance(fmt);
 			break;
 
@@ -2052,7 +2052,7 @@ LOOP:
 			break;
 
 		case '#':
-			fmt->param[n] = MAKE_FIXNUM(fmt_args_left(fmt));
+			fmt->param[n] = ecl_make_fixnum(fmt_args_left(fmt));
 			c = ctl_advance(fmt);
 			break;
 
@@ -2219,7 +2219,7 @@ DIRECTIVE:
 				 make_constant_base_string(
 "Cannot output to a non adjustable string."),
 				 @':control-string', string,
-				 @':offset', MAKE_FIXNUM(0));
+				 @':offset', ecl_make_fixnum(0));
                 }
 		strm = si_make_string_output_stream_from_string(strm);
 		if (null_strm == 0)
diff --git a/src/c/gbc-new.d b/src/c/gbc-new.d
index c8fa49612..4945cc185 100644
--- a/src/c/gbc-new.d
+++ b/src/c/gbc-new.d
@@ -50,7 +50,7 @@ get_mark_bit(void *x) {
 
 #define	inheap(pp)	((unsigned long)(pp) < (unsigned long)heap_end)
 #define VALID_DATA_ADDRESS(pp) \
-  !IMMEDIATE(pp) && (cl_index)DATA_START <= (cl_index)(pp) && (cl_index)(pp) < (cl_index)heap_end
+  !ECL_IMMEDIATE(pp) && (cl_index)DATA_START <= (cl_index)(pp) && (cl_index)(pp) < (cl_index)heap_end
 
 cl_object siVgc_verbose;
 cl_object siVgc_message;
@@ -101,8 +101,8 @@ register_root(cl_object *p)
 #define mark_displaced(ar) mark_object(ar)
 #define mark_contblock(x,s) {if (collect_blocks) _mark_contblock(x,s); }
 #if 1
-#define mark_object(x) if ((x != OBJNULL) && !IMMEDIATE(x)) _mark_object(x)
-#define mark_next(a) if ((a != OBJNULL) && !IMMEDIATE(a)) { x=(a); goto BEGIN; }
+#define mark_object(x) if ((x != OBJNULL) && !ECL_IMMEDIATE(x)) _mark_object(x)
+#define mark_next(a) if ((a != OBJNULL) && !ECL_IMMEDIATE(a)) { x=(a); goto BEGIN; }
 #else
 #define mark_object(x) _mark_object(x)
 #define mark_next(a) x=(a); goto BEGIN
@@ -123,7 +123,7 @@ _mark_object(cl_object x)
 BEGIN:
 #if 0
 	/* We cannot get here because mark_object() and mark_next() already check this */
-	if (IMMEDIATE(x)) return;	/* fixnum, character or locative */
+	if (ECL_IMMEDIATE(x)) return;	/* fixnum, character or locative */
 	if (x == OBJNULL)
 		return;
 #endif
@@ -946,25 +946,25 @@ _mark_contblock(void *x, size_t s)
 	cl_object *tl;
 @
 	NValues = 8;
-	VALUES(0) = MAKE_FIXNUM(real_maxpage);
-	VALUES(1) = MAKE_FIXNUM(available_pages());
-	VALUES(2) = MAKE_FIXNUM(ncbpage);
-	VALUES(3) = MAKE_FIXNUM(maxcbpage);
-	VALUES(4) = MAKE_FIXNUM(ncb);
-	VALUES(5) = MAKE_FIXNUM(cbgccount);
-	VALUES(6) = MAKE_FIXNUM(holepage);
+	VALUES(0) = ecl_make_fixnum(real_maxpage);
+	VALUES(1) = ecl_make_fixnum(available_pages());
+	VALUES(2) = ecl_make_fixnum(ncbpage);
+	VALUES(3) = ecl_make_fixnum(maxcbpage);
+	VALUES(4) = ecl_make_fixnum(ncb);
+	VALUES(5) = ecl_make_fixnum(cbgccount);
+	VALUES(6) = ecl_make_fixnum(holepage);
 	VALUES(7) = Cnil;
 	tl = &VALUES(7);
 	for (i = 0;  i < (int)t_end;  i++) {
 	  if (tm_table[i].tm_type == (enum type)i) {
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_nused), Cnil));
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_nfree), Cnil));
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_npage), Cnil));
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_maxpage), Cnil));
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_gccount), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_nused), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_nfree), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_npage), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_maxpage), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_gccount), Cnil));
 	  } else {
 	    tl = &CDR(*tl = CONS(Cnil, Cnil));
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_type), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_type), Cnil));
 	    tl = &CDR(*tl = CONS(Cnil, Cnil));
 	    tl = &CDR(*tl = CONS(Cnil, Cnil));
 	    tl = &CDR(*tl = CONS(Cnil, Cnil));
@@ -984,7 +984,7 @@ _mark_contblock(void *x, size_t s)
 
 @(defun si::gc-time ()
 @
-	@(return MAKE_FIXNUM(gc_time))
+	@(return ecl_make_fixnum(gc_time))
 @)
 
 void
diff --git a/src/c/gbc.d b/src/c/gbc.d
index 5549f7bf2..aae5bdcba 100644
--- a/src/c/gbc.d
+++ b/src/c/gbc.d
@@ -44,7 +44,7 @@ static int	*mark_table;
 #define clear_mark_bit(x) (MTword(x) ~= (~1 << MTbit(x)))
 
 #define VALID_DATA_ADDRESS(pp) \
-  (!IMMEDIATE(pp) && (heap_start <= (cl_ptr)(pp)) && ((cl_ptr)(pp) < heap_end))
+  (!ECL_IMMEDIATE(pp) && (heap_start <= (cl_ptr)(pp)) && ((cl_ptr)(pp) < heap_end))
 
 static bool	debug = FALSE;
 static int	maxpage;
@@ -96,8 +96,8 @@ si_gc(cl_object area)
 #define mark_displaced(ar) mark_object(ar)
 #define mark_contblock(x,s) {if (collect_blocks) _mark_contblock(x,s); }
 #if 1
-#define mark_object(x) if ((x != OBJNULL) && !IMMEDIATE(x)) _mark_object(x)
-#define mark_next(a) if ((a != OBJNULL) && !IMMEDIATE(a)) { x=(a); goto BEGIN; }
+#define mark_object(x) if ((x != OBJNULL) && !ECL_IMMEDIATE(x)) _mark_object(x)
+#define mark_next(a) if ((a != OBJNULL) && !ECL_IMMEDIATE(a)) { x=(a); goto BEGIN; }
 #else
 #define mark_object(x) _mark_object(x)
 #define mark_next(a) x=(a); goto BEGIN
@@ -116,7 +116,7 @@ _mark_object(cl_object x)
 BEGIN:
 #if 0
 	/* We cannot get here because mark_object() and mark_next() already check this */
-	if (IMMEDIATE(x)) return;	/* fixnum, character or locative */
+	if (ECL_IMMEDIATE(x)) return;	/* fixnum, character or locative */
 	if (x == OBJNULL)
 		return;
 #endif
@@ -926,25 +926,25 @@ _mark_contblock(void *x, cl_index s)
 	cl_object *tl;
 @
 	NVALUES = 8;
-	VALUES(0) = MAKE_FIXNUM(real_maxpage);
-	VALUES(1) = MAKE_FIXNUM(available_pages());
-	VALUES(2) = MAKE_FIXNUM(ncbpage);
-	VALUES(3) = MAKE_FIXNUM(maxcbpage);
-	VALUES(4) = MAKE_FIXNUM(ncb);
-	VALUES(5) = MAKE_FIXNUM(cbgccount);
-	VALUES(6) = MAKE_FIXNUM(holepage);
+	VALUES(0) = ecl_make_fixnum(real_maxpage);
+	VALUES(1) = ecl_make_fixnum(available_pages());
+	VALUES(2) = ecl_make_fixnum(ncbpage);
+	VALUES(3) = ecl_make_fixnum(maxcbpage);
+	VALUES(4) = ecl_make_fixnum(ncb);
+	VALUES(5) = ecl_make_fixnum(cbgccount);
+	VALUES(6) = ecl_make_fixnum(holepage);
 	VALUES(7) = Cnil;
 	tl = &VALUES(7);
 	for (i = 0;  i < (int)t_end;  i++) {
 	  if (tm_table[i].tm_type == (cl_type)i) {
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_nused), Cnil));
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_nfree), Cnil));
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_npage), Cnil));
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_maxpage), Cnil));
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_gccount), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_nused), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_nfree), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_npage), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_maxpage), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_gccount), Cnil));
 	  } else {
 	    tl = &CDR(*tl = CONS(Cnil, Cnil));
-	    tl = &CDR(*tl = CONS(MAKE_FIXNUM(tm_table[i].tm_type), Cnil));
+	    tl = &CDR(*tl = CONS(ecl_make_fixnum(tm_table[i].tm_type), Cnil));
 	    tl = &CDR(*tl = CONS(Cnil, Cnil));
 	    tl = &CDR(*tl = CONS(Cnil, Cnil));
 	    tl = &CDR(*tl = CONS(Cnil, Cnil));
@@ -964,7 +964,7 @@ _mark_contblock(void *x, cl_index s)
 
 @(defun si::gc-time ()
 @
-	@(return MAKE_FIXNUM(gc_time))
+	@(return ecl_make_fixnum(gc_time))
 @)
 
 cl_object
diff --git a/src/c/gfun.d b/src/c/gfun.d
index c4f0dbb4e..0b05e3352 100644
--- a/src/c/gfun.d
+++ b/src/c/gfun.d
@@ -124,7 +124,7 @@ fill_spec_vector(cl_object vector, cl_object frame, cl_object gf)
 	loop_for_on_unsafe(spec_how_list) {
 		cl_object spec_how = ECL_CONS_CAR(spec_how_list);
 		cl_object spec_type = ECL_CONS_CAR(spec_how);
-		int spec_position = fix(ECL_CONS_CDR(spec_how));
+		int spec_position = ecl_fix(ECL_CONS_CDR(spec_how));
 		unlikely_if (spec_position >= narg)
 			FEwrong_num_arguments(gf);
 		unlikely_if (spec_no >= vector->vector.dim)
diff --git a/src/c/hash.d b/src/c/hash.d
index b7772e7aa..6619481df 100644
--- a/src/c/hash.d
+++ b/src/c/hash.d
@@ -63,7 +63,7 @@ _hash_eql(cl_hashkey h, cl_object x)
 		h = _hash_eql(h, x->complex.real);
 		return _hash_eql(h, x->complex.imag);
 	case t_character:
-		return hash_word(h, CHAR_CODE(x));
+		return hash_word(h, ECL_CHAR_CODE(x));
 #ifdef ECL_SSE2
 	case t_sse_pack:
 		return hash_string(h, x->sse.data.b8, 16);
@@ -155,7 +155,7 @@ _hash_equalp(int depth, cl_hashkey h, cl_object x)
 	cl_index i, len;
 	switch (type_of(x)) {
 	case t_character:
-		return hash_word(h, ecl_char_upcase(CHAR_CODE(x)));
+		return hash_word(h, ecl_char_upcase(ECL_CHAR_CODE(x)));
 	case t_list:
 		if (Null(x)) {
 			return _hash_equalp(depth, h, Cnil_symbol->symbol.name);
@@ -183,7 +183,7 @@ _hash_equalp(int depth, cl_hashkey h, cl_object x)
 		}
 		return h;
 	case t_fixnum:
-		return hash_word(h, fix(x));
+		return hash_word(h, ecl_fix(x));
 	case t_singlefloat:
 		/* FIXME! We should be more precise here! */
 		return hash_word(h, (cl_index)sf(x));
@@ -423,7 +423,7 @@ _ecl_remhash_equalp(cl_object key, cl_object hashtable)
 static struct ecl_hashtable_entry *
 _ecl_hash_loop_pack(cl_hashkey h, cl_object key, cl_object hashtable)
 {
-        cl_object ho = MAKE_FIXNUM(h & 0xFFFFFFF);
+        cl_object ho = ecl_make_fixnum(h & 0xFFFFFFF);
         HASH_TABLE_LOOP(hkey, hvalue, h, (ho==hkey) && ecl_string_eq(key,SYMBOL_NAME(hvalue)));
 }
 
@@ -438,7 +438,7 @@ _ecl_gethash_pack(cl_object key, cl_object hashtable, cl_object def)
 static cl_object
 _ecl_sethash_pack(cl_object key, cl_object hashtable, cl_object value)
 {
-	HASH_TABLE_SET(h, _ecl_hash_loop_pack, _hash_equal(3, 0, key), MAKE_FIXNUM(h & 0xFFFFFFF));
+	HASH_TABLE_SET(h, _ecl_hash_loop_pack, _hash_equal(3, 0, key), ecl_make_fixnum(h & 0xFFFFFFF));
 }
 
 static bool
@@ -682,19 +682,19 @@ ecl_extend_hashtable(cl_object hashtable)
 	old_size = hashtable->hash.size;
 	/* We do the computation with lisp datatypes, just in case the sizes contain
 	 * weird numbers */
-	if (FIXNUMP(hashtable->hash.rehash_size)) {
+	if (ECL_FIXNUMP(hashtable->hash.rehash_size)) {
 		new_size_obj = ecl_plus(hashtable->hash.rehash_size,
-					MAKE_FIXNUM(old_size));
+					ecl_make_fixnum(old_size));
 	} else {
 		new_size_obj = ecl_times(hashtable->hash.rehash_size,
-					 MAKE_FIXNUM(old_size));
+					 ecl_make_fixnum(old_size));
 		new_size_obj = ecl_ceiling1(new_size_obj);
 	}
-	if (!FIXNUMP(new_size_obj)) {
+	if (!ECL_FIXNUMP(new_size_obj)) {
 		/* New size is too large */
 		new_size = old_size * 2;
 	} else {
-		new_size = fix(new_size_obj);
+		new_size = ecl_fix(new_size_obj);
 	}
         if (hashtable->hash.test == htt_pack) {
                 new = ecl_alloc_object(t_hashtable);
@@ -729,7 +729,7 @@ ecl_extend_hashtable(cl_object hashtable)
 
 @(defun make_hash_table (&key (test @'eql')
 			      (weakness Cnil)
-			      (size MAKE_FIXNUM(1024))
+			      (size ecl_make_fixnum(1024))
                               (rehash_size cl_core.rehash_size)
 			      (rehash_threshold cl_core.rehash_threshold))
 @
@@ -822,12 +822,12 @@ cl__make_hash_table(cl_object test, cl_object size, cl_object rehash_size,
 	}
         if (ecl_unlikely(!ECL_FIXNUMP(size) ||
                          ecl_fixnum_minusp(size) ||
-                         ecl_fixnum_geq(size,MAKE_FIXNUM(ATOTLIM)))) {
+                         ecl_fixnum_geq(size,ecl_make_fixnum(ATOTLIM)))) {
             FEwrong_type_key_arg(@[make-hash-table], @[:size], size,
-                                 ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                       MAKE_FIXNUM(ATOTLIM)));
+                                 ecl_make_integer_type(ecl_make_fixnum(0),
+                                                       ecl_make_fixnum(ATOTLIM)));
         }
-        hsize = fix(size);
+        hsize = ecl_fix(size);
 	if (hsize < 16) {
 		hsize = 16;
 	}
@@ -841,17 +841,17 @@ cl__make_hash_table(cl_object test, cl_object size, cl_object rehash_size,
 		goto AGAIN;
 	}
 	if (floatp(rehash_size)) {
-		if (ecl_number_compare(rehash_size, MAKE_FIXNUM(1)) < 0 ||
+		if (ecl_number_compare(rehash_size, ecl_make_fixnum(1)) < 0 ||
 		    ecl_minusp(rehash_size)) {
 			goto ERROR1;
 		}
 		rehash_size = ecl_make_doublefloat(ecl_to_double(rehash_size));
-	} else if (!FIXNUMP(rehash_size)) {
+	} else if (!ECL_FIXNUMP(rehash_size)) {
 		goto ERROR1;
 	}
 	while (!ecl_numberp(rehash_threshold) ||
 	       ecl_minusp(rehash_threshold) ||
-	       ecl_number_compare(rehash_threshold, MAKE_FIXNUM(1)) > 0)
+	       ecl_number_compare(rehash_threshold, ecl_make_fixnum(1)) > 0)
 	{
 		rehash_threshold =
 			ecl_type_error(@'make-hash-table',"rehash-threshold",
@@ -969,14 +969,14 @@ cl_object
 cl_hash_table_size(cl_object ht)
 {
 	assert_type_hash_table(@[hash-table-size], 1, ht);
-	@(return MAKE_FIXNUM(ht->hash.size))
+	@(return ecl_make_fixnum(ht->hash.size))
 }
 
 cl_object
 cl_hash_table_count(cl_object ht)
 {
 	assert_type_hash_table(@[hash-table-count], 1, ht);
-	@(return (MAKE_FIXNUM(ht->hash.entries)))
+	@(return (ecl_make_fixnum(ht->hash.entries)))
 }
 
 static cl_object
@@ -988,14 +988,14 @@ si_hash_table_iterate(cl_narg narg)
 	cl_object ht = CADR(env);
 	cl_fixnum i;
 	if (!Null(index)) {
-		i = fix(index);
+		i = ecl_fix(index);
 		if (i < 0)
 			i = -1;
 		for (; ++i < ht->hash.size; ) {
 			struct ecl_hashtable_entry e =
 				copy_entry(ht->hash.data + i, ht);
 			if (e.key != OBJNULL) {
-				cl_object ndx = MAKE_FIXNUM(i);
+				cl_object ndx = ecl_make_fixnum(i);
 				ECL_RPLACA(env, ndx);
 				@(return ndx e.key e.value)
 			}
@@ -1010,7 +1010,7 @@ si_hash_table_iterator(cl_object ht)
 {
 	assert_type_hash_table(@[si::hash-table-iterator], 1, ht);
 	@(return ecl_make_cclosure_va((cl_objectfn)si_hash_table_iterate,
-                                      cl_list(2, MAKE_FIXNUM(-1), ht),
+                                      cl_list(2, ecl_make_fixnum(-1), ht),
                                       @'si::hash-table-iterator'))
 }
 
@@ -1033,7 +1033,7 @@ cl_sxhash(cl_object key)
 {
 	cl_index output = _hash_equal(3, 0, key);
 	const cl_index mask = ((cl_index)1 << (FIXNUM_BITS - 3)) - 1;
-	@(return MAKE_FIXNUM(output & mask))
+	@(return ecl_make_fixnum(output & mask))
 }
 
 @(defun si::hash-eql (&rest args)
@@ -1043,7 +1043,7 @@ cl_sxhash(cl_object key)
 		cl_object o = cl_va_arg(args);
 		h = _hash_eql(h, o);
 	}
-	@(return MAKE_FIXNUM(h))
+	@(return ecl_make_fixnum(h))
 @)
 
 @(defun si::hash-equal (&rest args)
@@ -1053,7 +1053,7 @@ cl_sxhash(cl_object key)
 		cl_object o = cl_va_arg(args);
 		h = _hash_equal(3, h, o);
 	}
-	@(return MAKE_FIXNUM(h))
+	@(return ecl_make_fixnum(h))
 @)
 
 @(defun si::hash-equalp (&rest args)
@@ -1063,7 +1063,7 @@ cl_sxhash(cl_object key)
 		cl_object o = cl_va_arg(args);
 		h = _hash_equalp(3, h, o);
 	}
-	@(return MAKE_FIXNUM(h))
+	@(return ecl_make_fixnum(h))
 @)
 
 cl_object
diff --git a/src/c/instance.d b/src/c/instance.d
index 584763520..b2b1ac76d 100644
--- a/src/c/instance.d
+++ b/src/c/instance.d
@@ -91,9 +91,9 @@ si_instance_ref(cl_object x, cl_object index)
 
 	if (ecl_unlikely(!ECL_INSTANCEP(x)))
                 FEwrong_type_nth_arg(@[si::instance-ref], 1, x, @[ext::instance]);
-	if (ecl_unlikely(!FIXNUMP(index)))
+	if (ecl_unlikely(!ECL_FIXNUMP(index)))
 		FEwrong_type_nth_arg(@[si::instance-ref], 2, index, @[fixnum]);
-	i = fix(index);
+	i = ecl_fix(index);
 	if (ecl_unlikely(i < 0 || i >= (cl_fixnum)x->instance.length))
 		FEtype_error_index(x, i);
 	@(return x->instance.slots[i])
@@ -106,9 +106,9 @@ si_instance_ref_safe(cl_object x, cl_object index)
 
 	if (ecl_unlikely(!ECL_INSTANCEP(x)))
                 FEwrong_type_nth_arg(@[si::instance-ref], 1, x, @[ext::instance]);
-	if (ecl_unlikely(!FIXNUMP(index)))
+	if (ecl_unlikely(!ECL_FIXNUMP(index)))
 		FEwrong_type_nth_arg(@[si::instance-ref], 2, index, @[fixnum]);
-	i = fix(index);
+	i = ecl_fix(index);
 	if (ecl_unlikely(i < 0 || i >= x->instance.length))
 		FEtype_error_index(x, i);
 	x = x->instance.slots[i];
@@ -135,9 +135,9 @@ si_instance_set(cl_object x, cl_object index, cl_object value)
 
 	if (ecl_unlikely(!ECL_INSTANCEP(x)))
                 FEwrong_type_nth_arg(@[si::instance-set], 1, x, @[ext::instance]);
-	if (ecl_unlikely(!FIXNUMP(index)))
+	if (ecl_unlikely(!ECL_FIXNUMP(index)))
 		FEwrong_type_nth_arg(@[si::instance-set], 2, index, @[fixnum]);
-	i = fix(index);
+	i = ecl_fix(index);
 	if (ecl_unlikely(i >= (cl_fixnum)x->instance.length || i < 0))
 		FEtype_error_index(x, i);
 	x->instance.slots[i] = value;
@@ -147,7 +147,7 @@ si_instance_set(cl_object x, cl_object index, cl_object value)
 cl_object
 si_instancep(cl_object x)
 {
-	@(return (ECL_INSTANCEP(x) ? MAKE_FIXNUM(x->instance.length) : Cnil))
+	@(return (ECL_INSTANCEP(x) ? ecl_make_fixnum(x->instance.length) : Cnil))
 }
 
 cl_object
@@ -171,9 +171,9 @@ si_sl_makunbound(cl_object x, cl_object index)
 
 	if (ecl_unlikely(!ECL_INSTANCEP(x)))
                 FEwrong_type_nth_arg(@[si::sl-makunbound], 1, x, @[ext::instance]);
-	if (ecl_unlikely(!FIXNUMP(index)))
+	if (ecl_unlikely(!ECL_FIXNUMP(index)))
 		FEwrong_type_nth_arg(@[si::sl-makunbound], 2, index, @[fixnum]);
-	i = fix(index);
+	i = ecl_fix(index);
 	unlikely_if (i >= x->instance.length || i < 0)
 		FEtype_error_index(x, i);
 	x->instance.slots[i] = ECL_UNBOUND;
diff --git a/src/c/interpreter.d b/src/c/interpreter.d
index 43bdb2a2b..614cae36a 100644
--- a/src/c/interpreter.d
+++ b/src/c/interpreter.d
@@ -53,7 +53,7 @@ ecl_stack_set_size(cl_env_ptr env, cl_index tentative_new_size)
 	 * and friends, which take a sp=0 to have no arguments.
 	 */
 	if (top == 0) {
-                *(env->stack_top++) = MAKE_FIXNUM(0);
+                *(env->stack_top++) = ecl_make_fixnum(0);
         }
         return env->stack_top;
 }
@@ -363,14 +363,14 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 	CASE(OP_INT); {
 		cl_fixnum n;
 		GET_OPARG(n, vector);
-		reg0 = MAKE_FIXNUM(n);
+		reg0 = ecl_make_fixnum(n);
 		THREAD_NEXT;
 	}
 
 	CASE(OP_PINT); {
 		cl_fixnum n;
 		GET_OPARG(n, vector);
-		ECL_STACK_PUSH(the_env, MAKE_FIXNUM(n));
+		ECL_STACK_PUSH(the_env, ecl_make_fixnum(n));
 		THREAD_NEXT;
 	}
 
@@ -472,7 +472,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 		the stack (They all have been deposited by OP_PUSHVALUES)
 	*/
 	CASE(OP_MCALL); {
-		narg = fix(ECL_STACK_POP_UNSAFE(the_env));
+		narg = ecl_fix(ECL_STACK_POP_UNSAFE(the_env));
 		reg0 = ECL_STACK_REF(the_env,-narg-1);
 		goto DO_CALL;
 	}
@@ -751,7 +751,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 		GET_OPARG(lex_env_index, vector);
 		GET_OPARG(tag_ndx, vector);
 		cl_go(ecl_lex_env_get_tag(lex_env, lex_env_index),
-		      MAKE_FIXNUM(tag_ndx));
+		      ecl_make_fixnum(tag_ndx));
 		THREAD_NEXT;
 	}
 	/* OP_RETURN	n{arg}
@@ -976,13 +976,13 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 
 	CASE(OP_BLOCK); {
 		GET_DATA(reg0, vector, data);
-		reg1 = MAKE_FIXNUM(the_env->frame_id++);
+		reg1 = ecl_make_fixnum(the_env->frame_id++);
 		lex_env = bind_frame(lex_env, reg1, reg0);
 		THREAD_NEXT;
 	}
 	CASE(OP_DO); {
 		reg0 = Cnil;
-		reg1 = MAKE_FIXNUM(the_env->frame_id++);
+		reg1 = ecl_make_fixnum(the_env->frame_id++);
 		lex_env = bind_frame(lex_env, reg1, reg0);
 		THREAD_NEXT;
 	}
@@ -1032,7 +1032,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 			   are computed at compile time. */
 			cl_opcode *table = (cl_opcode *)ECL_STACK_REF(the_env,-1);
 			lex_env = ECL_STACK_REF(the_env,-2);
-			table = table + fix(the_env->values[0]) * OPARG_SIZE;
+			table = table + ecl_fix(the_env->values[0]) * OPARG_SIZE;
 			vector = table + *(cl_oparg *)table;
 		}
 		THREAD_NEXT;
@@ -1070,19 +1070,19 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 		ECL_STACK_PUSH_N(the_env, i+1);
 		the_env->values[0] = reg0;
 		memcpy(&ECL_STACK_REF(the_env, -(i+1)), the_env->values, i * sizeof(cl_object));
-		ECL_STACK_REF(the_env, -1) = MAKE_FIXNUM(the_env->nvalues);
+		ECL_STACK_REF(the_env, -1) = ecl_make_fixnum(the_env->nvalues);
 		THREAD_NEXT;
 	}
 	/* OP_PUSHMOREVALUES
 		Adds more values to the ones pushed by OP_PUSHVALUES.
 	*/
 	CASE(OP_PUSHMOREVALUES); {
-		cl_index n = fix(ECL_STACK_REF(the_env,-1));
+		cl_index n = ecl_fix(ECL_STACK_REF(the_env,-1));
 		cl_index i = the_env->nvalues;
 		ECL_STACK_PUSH_N(the_env, i);
 		the_env->values[0] = reg0;
 		memcpy(&ECL_STACK_REF(the_env, -(i+1)), the_env->values, i * sizeof(cl_object));
-		ECL_STACK_REF(the_env, -1) = MAKE_FIXNUM(n + i);
+		ECL_STACK_REF(the_env, -1) = ecl_make_fixnum(n + i);
 		THREAD_NEXT;
 	}
 	/* OP_POPVALUES
@@ -1090,7 +1090,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 	*/
 	CASE(OP_POPVALUES); {
 		cl_object *dest = the_env->values;
-		int n = the_env->nvalues = fix(ECL_STACK_POP_UNSAFE(the_env));
+		int n = the_env->nvalues = ecl_fix(ECL_STACK_POP_UNSAFE(the_env));
 		if (n == 0) {
 			*dest = reg0 = Cnil;
 			THREAD_NEXT;
@@ -1122,9 +1122,9 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 		The index N-th is extracted from the top of the stack.
 	*/
 	CASE(OP_NTHVAL); {
-		cl_fixnum n = fix(ECL_STACK_POP_UNSAFE(the_env));
+		cl_fixnum n = ecl_fix(ECL_STACK_POP_UNSAFE(the_env));
 		if (ecl_unlikely(n < 0)) {
-			FEerror("Wrong index passed to NTH-VAL", 1, MAKE_FIXNUM(n));
+			FEerror("Wrong index passed to NTH-VAL", 1, ecl_make_fixnum(n));
 		} else if ((cl_index)n >= the_env->nvalues) {
 			reg0 = Cnil;
 		} else if (n) {
@@ -1155,7 +1155,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 			vector = (cl_opcode *)ECL_STACK_POP_UNSAFE(the_env);
 			lex_env = ECL_STACK_POP_UNSAFE(the_env);
 			reg0 = the_env->values[0];
-			ECL_STACK_PUSH(the_env, MAKE_FIXNUM(the_env->nlj_fr - the_env->frs_top));
+			ECL_STACK_PUSH(the_env, ecl_make_fixnum(the_env->nlj_fr - the_env->frs_top));
 			goto PUSH_VALUES;
 		}
 		THREAD_NEXT;
@@ -1165,15 +1165,15 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 		ecl_frs_pop(the_env);
 		(void)ECL_STACK_POP_UNSAFE(the_env);
 		lex_env = ECL_STACK_POP_UNSAFE(the_env);
-		ECL_STACK_PUSH(the_env, MAKE_FIXNUM(1));
+		ECL_STACK_PUSH(the_env, ecl_make_fixnum(1));
 		goto PUSH_VALUES;
 	}
 	CASE(OP_PROTECT_EXIT); {
-		volatile cl_fixnum n = the_env->nvalues = fix(ECL_STACK_POP_UNSAFE(the_env));
+		volatile cl_fixnum n = the_env->nvalues = ecl_fix(ECL_STACK_POP_UNSAFE(the_env));
 		while (n--)
 			the_env->values[n] = ECL_STACK_POP_UNSAFE(the_env);
 		reg0 = the_env->values[0];
-		n = fix(ECL_STACK_POP_UNSAFE(the_env));
+		n = ecl_fix(ECL_STACK_POP_UNSAFE(the_env));
 		if (n <= 0)
 			ecl_unwind(the_env, the_env->frs_top + n);
 		THREAD_NEXT;
@@ -1189,11 +1189,11 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 		cl_object values = reg0;
 		cl_object vars = ECL_STACK_POP_UNSAFE(the_env);
 		cl_index n = ecl_progv(the_env, vars, values);
-		ECL_STACK_PUSH(the_env, MAKE_FIXNUM(n));
+		ECL_STACK_PUSH(the_env, ecl_make_fixnum(n));
 		THREAD_NEXT;
 	}
 	CASE(OP_EXIT_PROGV); {
-		cl_index n = fix(ECL_STACK_POP_UNSAFE(the_env));
+		cl_index n = ecl_fix(ECL_STACK_POP_UNSAFE(the_env));
 		ecl_bds_unwind(the_env, n);
 		THREAD_NEXT;
 	}
@@ -1255,7 +1255,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
 			/* We exit one stepping level */
 			ECL_SETQ(the_env, @'si::*step-level*',
 				 cl_1M(ECL_SYM_VAL(the_env, @'si::*step-level*')));
-		} else if (a == MAKE_FIXNUM(0)) {
+		} else if (a == ecl_make_fixnum(0)) {
 			/* We are back to the level in which the user
 			 * selected to step over. */
 			ECL_SETQ(the_env, @'si::*step-action*', Ct);
diff --git a/src/c/list.d b/src/c/list.d
index b4f5bf43c..3a96de935 100644
--- a/src/c/list.d
+++ b/src/c/list.d
@@ -301,7 +301,7 @@ cl_list_length(cl_object x)
 			slow = ECL_CONS_CDR(slow);
 		}
 	}
-	@(return MAKE_FIXNUM(n));
+	@(return ecl_make_fixnum(n));
 }
 
 cl_object
@@ -399,7 +399,7 @@ ecl_last(cl_object l, cl_index n)
 	}
 }
 
-@(defun last (l &optional (k MAKE_FIXNUM(1)))
+@(defun last (l &optional (k ecl_make_fixnum(1)))
 @
 	if (type_of(k) == t_bignum)
 		@(return l)
@@ -573,7 +573,7 @@ ecl_butlast(cl_object l, cl_index n)
 	}
 }
 
-@(defun butlast (lis &optional (nn MAKE_FIXNUM(1)))
+@(defun butlast (lis &optional (nn ecl_make_fixnum(1)))
 @
 	/* INV: No list has more than MOST_POSITIVE_FIXNUM elements */
 	if (type_of(nn) == t_bignum)
@@ -602,7 +602,7 @@ ecl_nbutlast(cl_object l, cl_index n)
 	return Cnil;
 }
 
-@(defun nbutlast (lis &optional (nn MAKE_FIXNUM(1)))
+@(defun nbutlast (lis &optional (nn ecl_make_fixnum(1)))
 @
 	/* INV: No list has more than MOST_POSITIVE_FIXNUM elements */
 	if (type_of(nn) == t_bignum)
diff --git a/src/c/load.d b/src/c/load.d
index c9c6371fa..66c773bc2 100644
--- a/src/c/load.d
+++ b/src/c/load.d
@@ -58,7 +58,7 @@ si_load_binary(cl_object filename, cl_object verbose,
                                                       make_constant_base_string("_"));
         }
 	basename = cl_pathname_name(1,filename);
-	basename = @si::base-string-concatenate(2, prefix, @string-upcase(1, funcall(4, @'nsubstitute', CODE_CHAR('_'), CODE_CHAR('-'), basename)));
+	basename = @si::base-string-concatenate(2, prefix, @string-upcase(1, funcall(4, @'nsubstitute', ECL_CODE_CHAR('_'), ECL_CODE_CHAR('-'), basename)));
 	block->cblock.entry = ecl_library_symbol(block, (char*)basename->base_string.self, 0);
 
 	if (block->cblock.entry == NULL) {
@@ -102,7 +102,7 @@ si_load_source(cl_object source, cl_object verbose, cl_object print, cl_object e
 			@(return Cnil)
 	}
 	CL_UNWIND_PROTECT_BEGIN(the_env) {
-		cl_object form_index = MAKE_FIXNUM(0);
+		cl_object form_index = ecl_make_fixnum(0);
                 cl_object pathname = ECL_SYM_VAL(the_env, @'*load-pathname*');
 		cl_object location = CONS(pathname, form_index);
 		ecl_bds_bind(the_env, @'ext::*source-location*', location);
diff --git a/src/c/main.d b/src/c/main.d
index 351d11eae..0df9defc1 100644
--- a/src/c/main.d
+++ b/src/c/main.d
@@ -107,7 +107,7 @@ cl_fixnum
 ecl_get_option(int option)
 {
 	if (option >= ECL_OPT_LIMIT || option < 0) {
-		FEerror("Invalid boot option ~D", 1, MAKE_FIXNUM(option));
+		FEerror("Invalid boot option ~D", 1, ecl_make_fixnum(option));
 	}
         return ecl_option_values[option];
 }
@@ -116,12 +116,12 @@ void
 ecl_set_option(int option, cl_fixnum value)
 {
 	if (option > ECL_OPT_LIMIT || option < 0) {
-		FEerror("Invalid boot option ~D", 1, MAKE_FIXNUM(option));
+		FEerror("Invalid boot option ~D", 1, ecl_make_fixnum(option));
 	} else {
 		if (option < ECL_OPT_BOOTED &&
 		    ecl_option_values[ECL_OPT_BOOTED]) {
 			FEerror("Cannot change option ~D while ECL is running",
-				1, MAKE_FIXNUM(option));
+				1, ecl_make_fixnum(option));
 		}
 		ecl_option_values[option] = value;
 	}
@@ -163,7 +163,7 @@ ecl_init_env(cl_env_ptr env)
         env->pending_interrupt = Cnil;
 	{
 		int size = ecl_option_values[ECL_OPT_SIGNAL_QUEUE_SIZE];
-		env->signal_queue = cl_make_list(1, MAKE_FIXNUM(size));
+		env->signal_queue = cl_make_list(1, ecl_make_fixnum(size));
 	}
 
 	init_stacks(env);
@@ -336,8 +336,8 @@ ecl_def_ct_double_float(dbl_zero_neg,-0.0,static,const);
 ecl_def_ct_long_float(ldbl_zero,0,static,const);
 ecl_def_ct_long_float(ldbl_zero_neg,-0.0l,static,const);
 #endif
-ecl_def_ct_ratio(plus_half,MAKE_FIXNUM(1),MAKE_FIXNUM(2),static,const);
-ecl_def_ct_ratio(minus_half,MAKE_FIXNUM(-1),MAKE_FIXNUM(2),static,const);
+ecl_def_ct_ratio(plus_half,ecl_make_fixnum(1),ecl_make_fixnum(2),static,const);
+ecl_def_ct_ratio(minus_half,ecl_make_fixnum(-1),ecl_make_fixnum(2),static,const);
 ecl_def_ct_single_float(flt_one,1,static,const);
 ecl_def_ct_single_float(flt_one_neg,-1,static,const);
 ecl_def_ct_single_float(flt_two,2,static,const);
@@ -392,7 +392,7 @@ struct cl_core_struct cl_core = {
 
 	(cl_object)&str_G_data, /* gensym_prefix */
 	(cl_object)&str_T_data, /* gentemp_prefix */
-	MAKE_FIXNUM(0), /* gentemp_counter */
+	ecl_make_fixnum(0), /* gentemp_counter */
 
 	Cnil, /* Jan1st1970UT */
 
@@ -632,9 +632,9 @@ cl_boot(int argc, char **argv)
 #endif
 
 #ifdef ECL_THREADS
-	env->bindings_array = si_make_vector(Ct, MAKE_FIXNUM(1024),
+	env->bindings_array = si_make_vector(Ct, ecl_make_fixnum(1024),
                                             Cnil, Cnil, Cnil, Cnil);
-        si_fill_array_with_elt(env->bindings_array, OBJNULL, MAKE_FIXNUM(0), Cnil);
+        si_fill_array_with_elt(env->bindings_array, OBJNULL, ecl_make_fixnum(0), Cnil);
         env->thread_local_bindings_size = env->bindings_array->vector.dim;
         env->thread_local_bindings = env->bindings_array->vector.self.t;
 	ECL_SET(@'mp::*current-process*', env->own_process);
@@ -646,12 +646,12 @@ cl_boot(int argc, char **argv)
          * need EQUALP because it has to be case insensitive.
 	 */
 	cl_core.char_names = aux =
-	    cl__make_hash_table(@'equalp', MAKE_FIXNUM(128), /* size */
+	    cl__make_hash_table(@'equalp', ecl_make_fixnum(128), /* size */
 				cl_core.rehash_size,
                                 cl_core.rehash_threshold);
 	for (i = 0; char_names[i].elt.self; i++) {
                 cl_object name = (cl_object)(char_names + i);
-		cl_object code = MAKE_FIXNUM(i);
+		cl_object code = ecl_make_fixnum(i);
 		ecl_sethash(name, aux, code);
 		ecl_sethash(code, aux, name);
 	}
@@ -659,10 +659,10 @@ cl_boot(int argc, char **argv)
          * iso_latin_names.h, but it can not be associated to the code
          * 10, because the default name must be Newline. Similar to
          * the other codes. */
-        ecl_sethash(str_null, aux, MAKE_FIXNUM(0));
-        ecl_sethash(str_linefeed, aux, MAKE_FIXNUM(10));
-        ecl_sethash(str_bell, aux, MAKE_FIXNUM(7));
-        ecl_sethash(str_escape, aux, MAKE_FIXNUM(27));
+        ecl_sethash(str_null, aux, ecl_make_fixnum(0));
+        ecl_sethash(str_linefeed, aux, ecl_make_fixnum(10));
+        ecl_sethash(str_bell, aux, ecl_make_fixnum(7));
+        ecl_sethash(str_escape, aux, ecl_make_fixnum(27));
 
         /*
          * Initialize logical pathname translations. This must come after
@@ -676,11 +676,11 @@ cl_boot(int argc, char **argv)
 	 * Initialize constants (strings, numbers and time).
 	 */
 	cl_core.system_properties =
-	    cl__make_hash_table(@'equal', MAKE_FIXNUM(1024), /* size */
+	    cl__make_hash_table(@'equal', ecl_make_fixnum(1024), /* size */
 				cl_core.rehash_size,
                                 cl_core.rehash_threshold);
 	cl_core.setf_definitions =
-	    cl__make_hash_table(@'eq', MAKE_FIXNUM(256), /* size */
+	    cl__make_hash_table(@'eq', ecl_make_fixnum(256), /* size */
 				cl_core.rehash_size,
                                 cl_core.rehash_threshold);
 
@@ -741,7 +741,7 @@ cl_boot(int argc, char **argv)
 	 */
 #ifdef CLOS
 	ECL_SET(@'si::*class-name-hash-table*',
-		cl__make_hash_table(@'eq', MAKE_FIXNUM(1024), /* size */
+		cl__make_hash_table(@'eq', ecl_make_fixnum(1024), /* size */
                                     cl_core.rehash_size,
                                     cl_core.rehash_threshold));
 #endif
@@ -785,7 +785,7 @@ cl_boot(int argc, char **argv)
 
 /************************* ENVIRONMENT ROUTINES ***********************/
 
-@(defun ext::quit (&optional (code MAKE_FIXNUM(0)) (kill_all_threads Ct))
+@(defun ext::quit (&optional (code ecl_make_fixnum(0)) (kill_all_threads Ct))
 @
 {
 #ifdef ECL_THREADS
@@ -814,20 +814,20 @@ cl_boot(int argc, char **argv)
 @(defun ext::exit (&optional (code ECL_SYM_VAL(ecl_process_env(),@'ext::*program-exit-code*')))
 @
         cl_shutdown();
-        exit(FIXNUMP(code)? fix(code) : 0);
+        exit(ECL_FIXNUMP(code)? ecl_fix(code) : 0);
 @)
 
 cl_object
 si_argc()
 {
-	@(return MAKE_FIXNUM(ARGC))
+	@(return ecl_make_fixnum(ARGC))
 }
 
 cl_object
 si_argv(cl_object index)
 {
-	if (FIXNUMP(index)) {
-		cl_fixnum i = fix(index);
+	if (ECL_FIXNUMP(index)) {
+		cl_fixnum i = ecl_fix(index);
 		if (i >= 0 && i < ARGC)
 			@(return make_base_string_copy(ARGV[i]));
 	}
diff --git a/src/c/num_arith.d b/src/c/num_arith.d
index b64065623..60a6cf830 100644
--- a/src/c/num_arith.d
+++ b/src/c/num_arith.d
@@ -27,11 +27,11 @@ ecl_integer_divide(cl_object x, cl_object y)
 	ty = type_of(y);
 	if (tx == t_fixnum) {
  		if (ty == t_fixnum) {
-			if (y == MAKE_FIXNUM(0))
+			if (y == ecl_make_fixnum(0))
 				FEdivision_by_zero(x, y);
-			return MAKE_FIXNUM(fix(x) / fix(y));
+			return ecl_make_fixnum(ecl_fix(x) / ecl_fix(y));
 		} else if (ty == t_bignum) {
-                        return _ecl_fix_divided_by_big(fix(x), y);
+                        return _ecl_fix_divided_by_big(ecl_fix(x), y);
 		} else {
                         FEwrong_type_nth_arg(@[round], 2, y, @[integer]);
                 }
@@ -40,7 +40,7 @@ ecl_integer_divide(cl_object x, cl_object y)
 		if (ty == t_bignum) {
 			return _ecl_big_divided_by_big(x, y);
 		} else if (ty == t_fixnum) {
-                        return _ecl_big_divided_by_fix(x, fix(y));
+                        return _ecl_big_divided_by_fix(x, ecl_fix(y));
 		} else {
                         FEwrong_type_nth_arg(@[round], 2, y, @[integer]);
 		}
@@ -52,7 +52,7 @@ ecl_integer_divide(cl_object x, cl_object y)
 	cl_object gcd;
 @
 	if (narg == 0)
-		@(return MAKE_FIXNUM(0))
+		@(return ecl_make_fixnum(0))
 	/* INV: ecl_gcd() checks types */
 	gcd = cl_va_arg(nums);
 	if (narg == 1) {
@@ -72,7 +72,7 @@ ecl_gcd(cl_object x, cl_object y)
 
 	switch (type_of(x)) {
 	case t_fixnum:
-                _ecl_big_set_fixnum(x_big, fix(x));
+                _ecl_big_set_fixnum(x_big, ecl_fix(x));
                 x = x_big;
 	case t_bignum:
 		break;
@@ -81,7 +81,7 @@ ecl_gcd(cl_object x, cl_object y)
 	}
 	switch (type_of(y)) {
 	case t_fixnum:
-                _ecl_big_set_fixnum(y_big, fix(y));
+                _ecl_big_set_fixnum(y_big, ecl_fix(y));
                 y = y_big;
 	case t_bignum:
                 break;
@@ -95,7 +95,7 @@ ecl_gcd(cl_object x, cl_object y)
 	cl_object lcm;
 @
 	if (narg == 0)
-		@(return MAKE_FIXNUM(1))
+		@(return ecl_make_fixnum(1))
 	/* INV: ecl_gcd() checks types. By placing `numi' before `lcm' in
 	   this call, we make sure that errors point to `numi' */
 	lcm = cl_va_arg(nums);
@@ -104,7 +104,7 @@ ecl_gcd(cl_object x, cl_object y)
 		cl_object numi = cl_va_arg(nums);
 		cl_object t = ecl_times(lcm, numi);
 		cl_object g = ecl_gcd(numi, lcm);
-		if (g != MAKE_FIXNUM(0))
+		if (g != ecl_make_fixnum(0))
 			lcm = ecl_divide(t, g);
 	}
 	@(return (ecl_minusp(lcm) ? ecl_negate(lcm) : lcm))
diff --git a/src/c/num_co.d b/src/c/num_co.d
index 25f1646f0..88aa5a878 100644
--- a/src/c/num_co.d
+++ b/src/c/num_co.d
@@ -117,7 +117,7 @@ cl_denominator(cl_object x)
 		break;
 	case t_fixnum:
 	case t_bignum:
-		x = MAKE_FIXNUM(1);
+		x = ecl_make_fixnum(1);
 		break;
 	default:
                 FEwrong_type_nth_arg(@[numerator],1,x,@[rational]);
@@ -134,7 +134,7 @@ ecl_floor1(cl_object x)
 	case t_fixnum:
 	case t_bignum:
 		v0 = x;
-		v1 = MAKE_FIXNUM(0);
+		v1 = ecl_make_fixnum(0);
 		break;
 	case t_ratio:
 		v0 = ecl_floor2(x->ratio.num, x->ratio.den);
@@ -176,21 +176,21 @@ ecl_floor2(cl_object x, cl_object y)
 	cl_object v0, v1;
 	cl_type ty;
         ty = type_of(y);
-	if (ecl_unlikely(!REAL_TYPE(ty))) {
+	if (ecl_unlikely(!ECL_REAL_TYPE_P(ty))) {
                 FEwrong_type_nth_arg(@[floor],2,y,@[real]);
 	}
 	switch(type_of(x)) {
 	case t_fixnum:
 		switch(ty) {
 		case t_fixnum: {	/* FIX / FIX */
-		  cl_fixnum a = fix(x), b = fix(y);
+		  cl_fixnum a = ecl_fix(x), b = ecl_fix(y);
 		  cl_fixnum q = a / b,  r = a % b;
 		  if ((r^b) < 0 && r) {	/* opposite sign and some remainder*/
-		    v0 = MAKE_FIXNUM(q-1);
-		    v1 = MAKE_FIXNUM(r+b);
+		    v0 = ecl_make_fixnum(q-1);
+		    v1 = ecl_make_fixnum(r+b);
 		  } else {
-		    v0 = MAKE_FIXNUM(q);
-		    v1 = MAKE_FIXNUM(r);
+		    v0 = ecl_make_fixnum(q);
+		    v1 = ecl_make_fixnum(r);
 		  }
 		  break;
 		}
@@ -201,7 +201,7 @@ ecl_floor2(cl_object x, cl_object y)
 		   *    y = - MOST_NEGATIVE_FIXNUM
 		   */
                   ECL_WITH_TEMP_BIGNUM(bx,4);
-                  _ecl_big_set_fixnum(bx, fix(x));
+                  _ecl_big_set_fixnum(bx, ecl_fix(x));
                   v0 = _ecl_big_floor(bx, y, &v1);
 		  break;
 		}
@@ -211,7 +211,7 @@ ecl_floor2(cl_object x, cl_object y)
 		  break;
 		case t_singlefloat: {	/* FIX / SF */
 		  float n = sf(y);
-		  float p = fix(x) / n;
+		  float p = ecl_fix(x) / n;
 		  float q = floorf(p);
 		  v0 = float_to_integer(q);
 		  v1 = ecl_make_singlefloat((p - q)*n);
@@ -219,7 +219,7 @@ ecl_floor2(cl_object x, cl_object y)
 		}
 		case t_doublefloat: {	/* FIX / DF */
 		  double n = df(y);
-		  double p = fix(x) / n;
+		  double p = ecl_fix(x) / n;
 		  double q = floor(p);
 		  v0 = double_to_integer(q);
 		  v1 = ecl_make_doublefloat((p - q)*n);
@@ -228,7 +228,7 @@ ecl_floor2(cl_object x, cl_object y)
 #ifdef ECL_LONG_FLOAT
 		case t_longfloat: {	/* FIX / LF */
 		  long double n = ecl_long_float(y);
-		  long double p = fix(x) / n;
+		  long double p = ecl_fix(x) / n;
 		  long double q = floorl(p);
 		  v0 = long_double_to_integer(q);
 		  v1 = ecl_make_longfloat((p - q)*n);
@@ -243,7 +243,7 @@ ecl_floor2(cl_object x, cl_object y)
 		switch(ty) {
 		case t_fixnum: {	/* BIG / FIX */
                   ECL_WITH_TEMP_BIGNUM(by,4);
-                  _ecl_big_set_fixnum(by, fix(y));
+                  _ecl_big_set_fixnum(by, ecl_fix(y));
                   v0 = _ecl_big_floor(x, by, &v1);
 		  break;
 		}
@@ -348,7 +348,7 @@ ecl_ceiling1(cl_object x)
 	case t_fixnum:
 	case t_bignum:
 		v0 = x;
-		v1 = MAKE_FIXNUM(0);
+		v1 = ecl_make_fixnum(0);
 		break;
 	case t_ratio:
 		v0 = ecl_ceiling2(x->ratio.num, x->ratio.den);
@@ -390,21 +390,21 @@ ecl_ceiling2(cl_object x, cl_object y)
 	cl_object v0, v1;
 	cl_type ty;
         ty = type_of(y);
-	if (ecl_unlikely(!REAL_TYPE(ty))) {
+	if (ecl_unlikely(!ECL_REAL_TYPE_P(ty))) {
 		FEwrong_type_nth_arg(@[ceiling],2, y, @[real]);
 	}
 	switch(type_of(x)) {
 	case t_fixnum:
 		switch(ty) {
 		case t_fixnum: {	/* FIX / FIX */
-		  cl_fixnum a = fix(x); cl_fixnum b = fix(y);
+		  cl_fixnum a = ecl_fix(x); cl_fixnum b = ecl_fix(y);
 		  cl_fixnum q = a / b;  cl_fixnum r = a % b;
 		  if ((r^b) > 0 && r) {	/* same signs and some remainder */
-		    v0 = MAKE_FIXNUM(q+1);
-		    v1 = MAKE_FIXNUM(r-b);
+		    v0 = ecl_make_fixnum(q+1);
+		    v1 = ecl_make_fixnum(r-b);
 		  } else {
-		    v0 = MAKE_FIXNUM(q);
-		    v1 = MAKE_FIXNUM(r);
+		    v0 = ecl_make_fixnum(q);
+		    v1 = ecl_make_fixnum(r);
 		  }
 		  break;
 		}
@@ -415,7 +415,7 @@ ecl_ceiling2(cl_object x, cl_object y)
 		   *    y = - MOST_NEGATIVE_FIXNUM
 		   */
                   ECL_WITH_TEMP_BIGNUM(bx,4);
-                  _ecl_big_set_fixnum(bx, fix(x));
+                  _ecl_big_set_fixnum(bx, ecl_fix(x));
                   v0 = _ecl_big_ceiling(bx, y, &v1);
 		  break;
 		}
@@ -425,7 +425,7 @@ ecl_ceiling2(cl_object x, cl_object y)
 		  break;
 		case t_singlefloat: {	/* FIX / SF */
 		  float n = sf(y);
-		  float p = fix(x)/n;
+		  float p = ecl_fix(x)/n;
 		  float q = ceilf(p);
 		  v0 = float_to_integer(q);
 		  v1 = ecl_make_singlefloat(p*n - q*n);
@@ -433,7 +433,7 @@ ecl_ceiling2(cl_object x, cl_object y)
 		}
 		case t_doublefloat: {	/* FIX / DF */
 		  double n = df(y);
-		  double p = fix(x)/n;
+		  double p = ecl_fix(x)/n;
 		  double q = ceil(p);
 		  v0 = double_to_integer(q);
 		  v1 = ecl_make_doublefloat(p*n - q*n);
@@ -442,7 +442,7 @@ ecl_ceiling2(cl_object x, cl_object y)
 #ifdef ECL_LONG_FLOAT
 		case t_longfloat: {	/* FIX / LF */
 		  long double n = ecl_long_float(y);
-		  long double p = fix(x)/n;
+		  long double p = ecl_fix(x)/n;
 		  long double q = ceill(p);
 		  v0 = long_double_to_integer(q);
 		  v1 = ecl_make_longfloat(p*n - q*n);
@@ -457,7 +457,7 @@ ecl_ceiling2(cl_object x, cl_object y)
 		switch(type_of(y)) {
 		case t_fixnum: {	/* BIG / FIX */
                   ECL_WITH_TEMP_BIGNUM(by,4);
-                  _ecl_big_set_fixnum(by, fix(y));
+                  _ecl_big_set_fixnum(by, ecl_fix(y));
                   v0 = _ecl_big_ceiling(x, by, &v1);
 		  break;
 		}
@@ -560,7 +560,7 @@ ecl_truncate1(cl_object x)
 	case t_fixnum:
 	case t_bignum:
 		v0 = x;
-		v1 = MAKE_FIXNUM(0);
+		v1 = ecl_make_fixnum(0);
 		break;
 	case t_ratio:
 		v0 = ecl_truncate2(x->ratio.num, x->ratio.den);
@@ -657,7 +657,7 @@ ecl_round1(cl_object x)
 	case t_fixnum:
 	case t_bignum:
 		v0 = x;
-		v1 = MAKE_FIXNUM(0);
+		v1 = ecl_make_fixnum(0);
 		break;
 	case t_ratio:
 		v0 = ecl_round2(x->ratio.num, x->ratio.den);
@@ -704,7 +704,7 @@ ecl_round2(cl_object x, cl_object y)
 	case t_fixnum:
 	case t_bignum:
 		v0 = q;
-		v1 = MAKE_FIXNUM(0);
+		v1 = ecl_make_fixnum(0);
 		break;
 	case t_ratio: {
 		cl_object q1 = ecl_integer_divide(q->ratio.num, q->ratio.den);
@@ -807,7 +807,7 @@ cl_decode_float(cl_object x)
 	default:
                 FEwrong_type_nth_arg(@[decode-float],1,x,@[float]);
 	}
-	ecl_return3(the_env, x, MAKE_FIXNUM(e), ecl_make_singlefloat(s));
+	ecl_return3(the_env, x, ecl_make_fixnum(e), ecl_make_singlefloat(s));
 }
 
 cl_object
@@ -816,8 +816,8 @@ cl_scale_float(cl_object x, cl_object y)
 	const cl_env_ptr the_env = ecl_process_env();
 	cl_fixnum k;
 
-	if (FIXNUMP(y)) {
-		k = fix(y);
+	if (ECL_FIXNUMP(y)) {
+		k = ecl_fix(y);
 	} else {
 		FEwrong_type_nth_arg(@[scale-float],2,y,@[fixnum]);
 	}
@@ -846,7 +846,7 @@ cl_float_radix(cl_object x)
 	if (ecl_unlikely(cl_floatp(x) != Ct)) {
 		FEwrong_type_nth_arg(@[float-radix],1,x,@[float]);
 	}
-	ecl_return1(the_env, MAKE_FIXNUM(FLT_RADIX));
+	ecl_return1(the_env, ecl_make_fixnum(FLT_RADIX));
 }
 
 int
@@ -870,7 +870,7 @@ ecl_signbit(cl_object x)
 	int negativep;
 @
 	if (!yp) {
-		y = cl_float(2, MAKE_FIXNUM(1), x);
+		y = cl_float(2, ecl_make_fixnum(1), x);
 	}
 	negativep = ecl_signbit(x);
 	switch (type_of(y)) {
@@ -903,14 +903,14 @@ cl_float_digits(cl_object x)
 	const cl_env_ptr the_env = ecl_process_env();
 	switch (type_of(x)) {
 	case t_singlefloat:
-		x = MAKE_FIXNUM(FLT_MANT_DIG);
+		x = ecl_make_fixnum(FLT_MANT_DIG);
 		break;
 	case t_doublefloat:
-		x = MAKE_FIXNUM(DBL_MANT_DIG);
+		x = ecl_make_fixnum(DBL_MANT_DIG);
 		break;
 #ifdef ECL_LONG_FLOAT
 	case t_longfloat:
-		x = MAKE_FIXNUM(LDBL_MANT_DIG);
+		x = ecl_make_fixnum(LDBL_MANT_DIG);
 		break;
 #endif
 	default:
@@ -975,7 +975,7 @@ cl_float_precision(cl_object x)
 	default:
 		FEwrong_type_nth_arg(@[float-precision],1,x,@[float]);
 	}
-	ecl_return1(the_env, MAKE_FIXNUM(precision));
+	ecl_return1(the_env, ecl_make_fixnum(precision));
 }
 
 cl_object
@@ -994,7 +994,7 @@ cl_integer_decode_float(cl_object x)
                 }
 		if (d == 0.0) {
 			e = 0;
-			x = MAKE_FIXNUM(0);
+			x = ecl_make_fixnum(0);
 		} else {
                         d = frexpl(d, &e);
 			x = long_double_to_integer(ldexpl(d, LDBL_MANT_DIG));
@@ -1011,7 +1011,7 @@ cl_integer_decode_float(cl_object x)
                 }
 		if (d == 0.0) {
 			e = 0;
-			x = MAKE_FIXNUM(0);
+			x = ecl_make_fixnum(0);
 		} else {
                         d = frexp(d, &e);
 			x = double_to_integer(ldexp(d, DBL_MANT_DIG));
@@ -1027,7 +1027,7 @@ cl_integer_decode_float(cl_object x)
                 }
 		if (d == 0.0) {
 			e = 0;
-			x = MAKE_FIXNUM(0);
+			x = ecl_make_fixnum(0);
 		} else {
                         d = frexpf(d, &e);
 			x = double_to_integer(ldexp(d, FLT_MANT_DIG));
@@ -1038,11 +1038,11 @@ cl_integer_decode_float(cl_object x)
 	default:
 		FEwrong_type_nth_arg(@[integer-decode-float],1,x,@[float]);
 	}
-	ecl_return3(the_env, x, MAKE_FIXNUM(e), MAKE_FIXNUM(s));
+	ecl_return3(the_env, x, ecl_make_fixnum(e), ecl_make_fixnum(s));
 }
 
 
-@(defun complex (r &optional (i MAKE_FIXNUM(0)))
+@(defun complex (r &optional (i ecl_make_fixnum(0)))
 @	/* INV: ecl_make_complex() checks types */
 	@(return ecl_make_complex(r, i))
 @)
@@ -1076,7 +1076,7 @@ cl_imagpart(cl_object x)
 	case t_fixnum:
 	case t_bignum:
 	case t_ratio:
-		x = MAKE_FIXNUM(0);
+		x = ecl_make_fixnum(0);
 		break;
 	case t_singlefloat:
                 if (signbit(sf(x)))
diff --git a/src/c/num_log.d b/src/c/num_log.d
index 9cec6dc26..80c1b433e 100644
--- a/src/c/num_log.d
+++ b/src/c/num_log.d
@@ -164,12 +164,12 @@ ecl_boole(int op, cl_object x, cl_object y)
 	case t_fixnum:
 		switch (type_of(y)) {
 		case t_fixnum: {
-			cl_fixnum z = fixnum_operations[op](fix(x), fix(y));
-			return MAKE_FIXNUM(z);
+			cl_fixnum z = fixnum_operations[op](ecl_fix(x), ecl_fix(y));
+			return ecl_make_fixnum(z);
 		}
 		case t_bignum: {
                         cl_object x_copy = _ecl_big_register0();
-                        _ecl_big_set_fixnum(x_copy, fix(x));
+                        _ecl_big_set_fixnum(x_copy, ecl_fix(x));
                         (_ecl_big_boole_operator(op))(x_copy, x_copy, y);
                         return _ecl_big_register_normalize(x_copy);
 		}
@@ -182,7 +182,7 @@ ecl_boole(int op, cl_object x, cl_object y)
 		switch (type_of(y)) {
 		case t_fixnum: {
 			cl_object z = _ecl_big_register1();
-                        _ecl_big_set_fixnum(z,fix(y));
+                        _ecl_big_set_fixnum(z,ecl_fix(y));
                         (_ecl_big_boole_operator(op))(x_copy, x, z);
 			_ecl_big_register_free(z);
 			break;
@@ -204,7 +204,7 @@ ecl_boole(int op, cl_object x, cl_object y)
 cl_object
 cl_lognot(cl_object x)
 {
-	return @logxor(2,x,MAKE_FIXNUM(-1));
+	return @logxor(2,x,ecl_make_fixnum(-1));
 }
 
 static cl_fixnum
@@ -214,7 +214,7 @@ count_bits(cl_object x)
 
 	switch (type_of(x)) {
 	case t_fixnum: {
-		cl_fixnum i = fix(x);
+		cl_fixnum i = ecl_fix(x);
 		cl_fixnum j = (i < 0) ? ~i : i;
 		for (count=0 ; j ; j >>= 1)
 			if (j & 1) count++;
@@ -249,7 +249,7 @@ ecl_ash(cl_object x, cl_fixnum w)
 	y = _ecl_big_register0();
 	if (w < 0) {
 		cl_index bits = -w;
-		if (FIXNUMP(x)) {
+		if (ECL_FIXNUMP(x)) {
 			/* The result of shifting a number further than the number
 			 * of digits it has is unpredictable in C. For instance, GCC
 			 * on intel masks out all bits of "bits" beyond the 5 and
@@ -257,18 +257,18 @@ ecl_ash(cl_object x, cl_fixnum w)
 			 * Furthermore, in general, shifting negative numbers leads
 			 * to implementation-specific results :-/
 			 */
-			cl_fixnum y = fix(x);
+			cl_fixnum y = ecl_fix(x);
 			if (bits >= FIXNUM_BITS) {
 				y = (y < 0)? -1 : 0;
 			} else {
 				y >>= bits;
 			}
-			return MAKE_FIXNUM(y);
+			return ecl_make_fixnum(y);
 		}
 		mpz_div_2exp(y->big.big_num, x->big.big_num, bits);
 	} else {
-		if (FIXNUMP(x)) {
-			_ecl_big_set_fixnum(y, fix(x));
+		if (ECL_FIXNUMP(x)) {
+			_ecl_big_set_fixnum(y, ecl_fix(x));
 			x = y;
 		}
 		mpz_mul_2exp(y->big.big_num, x->big.big_num, (unsigned long)w);
@@ -290,7 +290,7 @@ ecl_fixnum_bit_length(cl_fixnum i)
 @(defun logior (&rest nums)
 @
 	if (narg == 0)
-		@(return MAKE_FIXNUM(0))
+		@(return ecl_make_fixnum(0))
 	/* INV: log_op() checks types and outputs first argument as default. */
 	@(return log_op(narg, ECL_BOOLIOR, nums))
 @)
@@ -298,7 +298,7 @@ ecl_fixnum_bit_length(cl_fixnum i)
 @(defun logxor (&rest nums)
 @
 	if (narg == 0)
-		@(return MAKE_FIXNUM(0))
+		@(return ecl_make_fixnum(0))
 	/* INV: log_op() checks types and outputs first argument as default. */
 	@(return log_op(narg, ECL_BOOLXOR, nums))
 @)
@@ -306,7 +306,7 @@ ecl_fixnum_bit_length(cl_fixnum i)
 @(defun logand (&rest nums)
 @
 	if (narg == 0)
-		@(return MAKE_FIXNUM(-1))
+		@(return ecl_make_fixnum(-1))
 	/* INV: log_op() checks types and outputs first argument as default. */
 	@(return log_op(narg, ECL_BOOLAND, nums))
 @)
@@ -314,7 +314,7 @@ ecl_fixnum_bit_length(cl_fixnum i)
 @(defun logeqv (&rest nums)
 @
 	if (narg == 0)
-		@(return MAKE_FIXNUM(-1))
+		@(return ecl_make_fixnum(-1))
 	/* INV: log_op() checks types and outputs first argument as default. */
 	@(return log_op(narg, ECL_BOOLEQV, nums))
 @)
@@ -378,10 +378,10 @@ cl_logbitp(cl_object p, cl_object x)
 	bool i;
 
 	assert_type_integer(x);
-	if (FIXNUMP(p)) {
+	if (ECL_FIXNUMP(p)) {
 		cl_index n = ecl_to_size(p);
-		if (FIXNUMP(x)) {
-			cl_fixnum y = fix(x);
+		if (ECL_FIXNUMP(x)) {
+			cl_fixnum y = ecl_fix(x);
 			if (n >= FIXNUM_BITS) {
 				i = (y < 0);
 			} else {
@@ -392,8 +392,8 @@ cl_logbitp(cl_object p, cl_object x)
 		}
 	} else {
 		assert_type_non_negative_integer(p);
-		if (FIXNUMP(x))
-			i = (fix(x) < 0);
+		if (ECL_FIXNUMP(x))
+			i = (ecl_fix(x) < 0);
 		else
 			i = (_ecl_big_sign(x) < 0);
 	}
@@ -408,18 +408,18 @@ cl_ash(cl_object x, cl_object y)
 
         assert_type_integer(x);
 	assert_type_integer(y);
-	if (FIXNUMP(y))
-	  r = ecl_ash(x, fix(y));
+	if (ECL_FIXNUMP(y))
+	  r = ecl_ash(x, ecl_fix(y));
 	else {
 	  /*
 	    bit position represented by bignum is probably
 	    out of our address space. So, result is returned
 	    according to sign of integer.
 	    */
-	  if (FIXNUMP(x))
-	    if (FIXNUM_MINUSP(x))
+	  if (ECL_FIXNUMP(x))
+	    if (ecl_fixnum_minusp(x))
 	      sign_x = -1;
-	    else if (x == MAKE_FIXNUM(0))
+	    else if (x == ecl_make_fixnum(0))
 	      sign_x = 0;
 	    else
 	      sign_x = 1;
@@ -427,9 +427,9 @@ cl_ash(cl_object x, cl_object y)
 	    sign_x = _ecl_big_sign(x);
 	  if (_ecl_big_sign(y) < 0)
 	    if (sign_x < 0)
-	      r = MAKE_FIXNUM(-1);
+	      r = ecl_make_fixnum(-1);
 	    else
-	      r = MAKE_FIXNUM(0);
+	      r = ecl_make_fixnum(0);
 	  else if (sign_x == 0)
 	    r = x;
 	  else
@@ -441,7 +441,7 @@ cl_ash(cl_object x, cl_object y)
 cl_object
 cl_logcount(cl_object x)
 {
-	@(return MAKE_FIXNUM(count_bits(x)))
+	@(return ecl_make_fixnum(count_bits(x)))
 }
 
 cl_index
@@ -452,7 +452,7 @@ ecl_integer_length(cl_object x)
 
 	switch (type_of(x)) {
 	case t_fixnum:
-		i = fix(x);
+		i = ecl_fix(x);
 		count = ecl_fixnum_bit_length(i);
 		break;
 	case t_bignum:
@@ -469,7 +469,7 @@ ecl_integer_length(cl_object x)
 cl_object
 cl_integer_length(cl_object x)
 {
-	@(return MAKE_FIXNUM(ecl_integer_length(x)))
+	@(return ecl_make_fixnum(ecl_integer_length(x)))
 }
 
 cl_object
diff --git a/src/c/num_pred.d b/src/c/num_pred.d
index a6fc07a6a..0c6460e65 100644
--- a/src/c/num_pred.d
+++ b/src/c/num_pred.d
@@ -23,8 +23,8 @@
 int
 ecl_oddp(cl_object x)
 {
-	if (FIXNUMP(x))
-		return fix(x) & 1;
+	if (ECL_FIXNUMP(x))
+		return ecl_fix(x) & 1;
 	unlikely_if (!ECL_BIGNUMP(x))
                 FEwrong_type_only_arg(@[oddp], x, @[integer]);
         return _ecl_big_odd_p(x);
@@ -33,8 +33,8 @@ ecl_oddp(cl_object x)
 int
 ecl_evenp(cl_object x)
 {
-	if (FIXNUMP(x))
-		return ~fix(x) & 1;
+	if (ECL_FIXNUMP(x))
+		return ~ecl_fix(x) & 1;
 	unlikely_if (!ECL_BIGNUMP(x))
                 FEwrong_type_only_arg(@[evenp], x, @[integer]);
         return _ecl_big_even_p(x);
diff --git a/src/c/num_rand.d b/src/c/num_rand.d
index f4a4cb519..eb417f8bb 100644
--- a/src/c/num_rand.d
+++ b/src/c/num_rand.d
@@ -170,7 +170,7 @@ random_integer(cl_object limit, cl_object state)
         cl_object buffer;
         if (bit_length <= FIXNUM_BITS)
                 bit_length = FIXNUM_BITS;
-        buffer = ecl_ash(MAKE_FIXNUM(1), bit_length);
+        buffer = ecl_ash(ecl_make_fixnum(1), bit_length);
         for (bit_length = mpz_size(buffer->big.big_num); bit_length; ) {
                 buffer->big.big_limbs[--bit_length] =
                         generate_limb(state);
@@ -188,7 +188,7 @@ rando(cl_object x, cl_object rs)
 	switch (type_of(x)) {
 	case t_fixnum:
 #if FIXNUM_BITS <= 32
-                z = MAKE_FIXNUM(generate_int32(rs->random.value) % fix(x));
+                z = ecl_make_fixnum(generate_int32(rs->random.value) % ecl_fix(x));
                 break;
 #endif
 	case t_bignum:
diff --git a/src/c/number.d b/src/c/number.d
index a4713cd61..9dec93cde 100644
--- a/src/c/number.d
+++ b/src/c/number.d
@@ -73,7 +73,7 @@ ecl_make_integer(cl_fixnum l)
                 _ecl_big_set_fixnum(z, l);
                 return _ecl_big_register_copy(z);
 	}
-	return MAKE_FIXNUM(l);
+	return ecl_make_fixnum(l);
 }
 
 cl_object
@@ -84,14 +84,14 @@ ecl_make_unsigned_integer(cl_index l)
                 _ecl_big_set_index(z, l);
                 return _ecl_big_register_copy(z);
 	}
-	return MAKE_FIXNUM(l);
+	return ecl_make_fixnum(l);
 }
 
 int
 ecl_to_bit(cl_object x) {
-        if (ecl_unlikely((x != MAKE_FIXNUM(0)) && (x != MAKE_FIXNUM(1))))
+        if (ecl_unlikely((x != ecl_make_fixnum(0)) && (x != ecl_make_fixnum(1))))
                 FEwrong_type_nth_arg(@[coerce], 1, x, @[bit]);
-        return x == MAKE_FIXNUM(1);
+        return x == ecl_make_fixnum(1);
 }
 
 ecl_uint8_t
@@ -101,7 +101,7 @@ ecl_to_uint8_t(cl_object x) {
 		if (ecl_likely(aux >= 0 && aux <= 255))
 			return (ecl_uint8_t)aux;
 	}
-	FEwrong_type_argument(cl_list(2, @'unsigned-byte', MAKE_FIXNUM(8)),
+	FEwrong_type_argument(cl_list(2, @'unsigned-byte', ecl_make_fixnum(8)),
 			      x);
 }
 
@@ -112,7 +112,7 @@ ecl_to_int8_t(cl_object x) {
 		if (ecl_likely(aux >= -128 && aux <= 127))
 			return (ecl_uint8_t)aux;
 	}
-	FEwrong_type_argument(cl_list(2, @'signed-byte', MAKE_FIXNUM(8)),
+	FEwrong_type_argument(cl_list(2, @'signed-byte', ecl_make_fixnum(8)),
 			      x);
 }
 
@@ -126,8 +126,8 @@ ecl_to_ushort(cl_object x) {
                 }
 	}
 	FEwrong_type_argument(cl_list(3,@'integer',
-				      MAKE_FIXNUM(0),
-				      MAKE_FIXNUM(ushort_max)),
+				      ecl_make_fixnum(0),
+				      ecl_make_fixnum(ushort_max)),
 			      x);
 }
 
@@ -142,8 +142,8 @@ ecl_to_short(cl_object x) {
                 }
 	}
 	FEwrong_type_argument(cl_list(3,@'integer',
-				      MAKE_FIXNUM(short_min),
-				      MAKE_FIXNUM(short_max)),
+				      ecl_make_fixnum(short_min),
+				      ecl_make_fixnum(short_max)),
 			      x);
 }
 
@@ -162,8 +162,8 @@ ecl_to_uint16_t(cl_object x) {
                 }
 	}
 	FEwrong_type_argument(cl_list(3,@'integer',
-				      MAKE_FIXNUM(0),
-				      MAKE_FIXNUM(uint16_max)),
+				      ecl_make_fixnum(0),
+				      ecl_make_fixnum(uint16_max)),
 			      x);
 }
 
@@ -178,8 +178,8 @@ ecl_to_int16_t(cl_object x) {
                 }
 	}
 	FEwrong_type_argument(cl_list(3,@'integer',
-				      MAKE_FIXNUM(int16_min),
-				      MAKE_FIXNUM(int16_max)),
+				      ecl_make_fixnum(int16_min),
+				      ecl_make_fixnum(int16_max)),
 			      x);
 }
 #endif /* ecl_uint16_t */
@@ -189,12 +189,12 @@ ecl_uint32_t
 ecl_to_uint32_t(cl_object x) {
 	const uint32_t uint32_max = 0xFFFFFFFFUL;
 	if (ecl_likely(ECL_FIXNUMP(x))) {
-		cl_fixnum y = fix(x);
+		cl_fixnum y = ecl_fix(x);
 		if (ecl_likely(y >= 0 && y <= uint32_max)) {
 			return (ecl_uint32_t)y;
                 }
 	}
-	FEwrong_type_argument(cl_list(3,@'integer',MAKE_FIXNUM(0),
+	FEwrong_type_argument(cl_list(3,@'integer',ecl_make_fixnum(0),
 				      ecl_make_unsigned_integer(uint32_max)),
 			      x);
 }
@@ -203,8 +203,8 @@ ecl_int32_t
 ecl_to_int32_t(cl_object x) {
 	const int32_t int32_min = -0x80000000L;
 	const int32_t int32_max =  0x7FFFFFFFL;
-	if (ecl_likely(FIXNUMP(x))) {
-		cl_fixnum y = fix(x);
+	if (ecl_likely(ECL_FIXNUMP(x))) {
+		cl_fixnum y = ecl_fix(x);
 		if (ecl_likely(y >= int32_min && y <= int32_max)) {
 			return (ecl_int32_t)y;
                 }
@@ -220,7 +220,7 @@ ecl_to_int32_t(cl_object x) {
 ecl_uint64_t
 ecl_to_uint64_t(cl_object x) {
 	if (!ecl_minusp(x)) {
-		if (FIXNUMP(x)) {
+		if (ECL_FIXNUMP(x)) {
 			return (ecl_uint64_t)ecl_fix(x);
 		} else if (!ECL_BIGNUMP(x)) {
 			(void)0;
@@ -238,15 +238,15 @@ ecl_to_uint64_t(cl_object x) {
 			}
 		}
 	}
-	FEwrong_type_argument(cl_list(3,@'integer',MAKE_FIXNUM(0),
-				      ecl_one_minus(ecl_ash(MAKE_FIXNUM(1), 64))),
+	FEwrong_type_argument(cl_list(3,@'integer',ecl_make_fixnum(0),
+				      ecl_one_minus(ecl_ash(ecl_make_fixnum(1), 64))),
 			      x);
 }
 
 ecl_int64_t
 ecl_to_int64_t(cl_object x) {
-	if (FIXNUMP(x)) {
-		return (ecl_int64_t)fix(x);
+	if (ECL_FIXNUMP(x)) {
+		return (ecl_int64_t)ecl_fix(x);
 	} else if (!ECL_BIGNUMP(x)) {
 		(void)0;
 	} else if (mpz_fits_slong_p(x->big.big_num)) {
@@ -262,8 +262,8 @@ ecl_to_int64_t(cl_object x) {
 		}
 	}
 	FEwrong_type_argument(cl_list(3,@'integer',
-				      ecl_negate(ecl_ash(MAKE_FIXNUM(1), 63)),
-				      ecl_one_minus(ecl_ash(MAKE_FIXNUM(1), 63))),
+				      ecl_negate(ecl_ash(ecl_make_fixnum(1), 63)),
+				      ecl_one_minus(ecl_ash(ecl_make_fixnum(1), 63))),
 			      x);
 }
 
@@ -271,7 +271,7 @@ cl_object
 ecl_make_uint64_t(ecl_uint64_t i)
 {
         if (i <= MOST_POSITIVE_FIXNUM) {
-                return MAKE_FIXNUM(i);
+                return ecl_make_fixnum(i);
         } else if (i <= ~(ecl_uint32_t)0) {
                 return ecl_make_uint32_t(i);
         } else {
@@ -285,7 +285,7 @@ cl_object
 ecl_make_int64_t(ecl_int64_t i)
 {
         if (i >= MOST_NEGATIVE_FIXNUM && i <= MOST_POSITIVE_FIXNUM) {
-                return MAKE_FIXNUM(i);
+                return ecl_make_fixnum(i);
         } else {
                 cl_object aux = ecl_make_int32_t(i >> 32);
                 return cl_logior(2, ecl_ash(aux, 32), ecl_make_uint32_t((ecl_uint32_t)i));
@@ -334,8 +334,8 @@ ecl_make_long_long(ecl_long_long_t i) {
 ecl_ulong_long_t
 ecl_to_unsigned_long_long(cl_object x) {
 	if (!ecl_minusp(x)) {
-		if (FIXNUMP(x)) {
-			return (ecl_ulong_long_t)fix(x);
+		if (ECL_FIXNUMP(x)) {
+			return (ecl_ulong_long_t)ecl_fix(x);
 		} else if (!ECL_BIGNUMP(x)) {
 			(void)0;
 		} else if (mpz_fits_ulong_p(x->big.big_num)) {
@@ -355,8 +355,8 @@ ecl_to_unsigned_long_long(cl_object x) {
 			}
 		}
 	}
-	FEwrong_type_argument(cl_list(3,@'integer',MAKE_FIXNUM(0),
-				      ecl_one_minus(ecl_ash(MAKE_FIXNUM(1),
+	FEwrong_type_argument(cl_list(3,@'integer',ecl_make_fixnum(0),
+				      ecl_one_minus(ecl_ash(ecl_make_fixnum(1),
 							    ECL_LONG_LONG_BITS))),
 			      x);
 }
@@ -364,8 +364,8 @@ ecl_to_unsigned_long_long(cl_object x) {
 ecl_long_long_t
 ecl_to_long_long(cl_object x)
 {
-	if (FIXNUMP(x)) {
-		return (ecl_long_long_t)fix(x);
+	if (ECL_FIXNUMP(x)) {
+		return (ecl_long_long_t)ecl_fix(x);
 	} else if (!ECL_BIGNUMP(x)) {
 		(void)0;
 	} else if (mpz_fits_slong_p(x->big.big_num)) {
@@ -385,8 +385,8 @@ ecl_to_long_long(cl_object x)
 		}
 	}
 	FEwrong_type_argument(cl_list(3,@'integer',
-				      ecl_negate(ecl_ash(MAKE_FIXNUM(1), ECL_LONG_LONG_BITS-1)),
-				      ecl_one_minus(ecl_ash(MAKE_FIXNUM(1), ECL_LONG_LONG_BITS-1))),
+				      ecl_negate(ecl_ash(ecl_make_fixnum(1), ECL_LONG_LONG_BITS-1)),
+				      ecl_one_minus(ecl_ash(ecl_make_fixnum(1), ECL_LONG_LONG_BITS-1))),
 			      x);
 }
 
@@ -394,7 +394,7 @@ cl_object
 ecl_make_unsigned_long_long(ecl_ulong_long_t i)
 {
         if (i <= MOST_POSITIVE_FIXNUM) {
-                return MAKE_FIXNUM(i);
+                return ecl_make_fixnum(i);
         } else if (i <= ~(ecl_uint32_t)0) {
                 return ecl_make_uint32_t(i);
         } else {
@@ -408,7 +408,7 @@ cl_object
 ecl_make_long_long(ecl_long_long_t i)
 {
         if (i >= MOST_NEGATIVE_FIXNUM && i <= MOST_POSITIVE_FIXNUM) {
-                return MAKE_FIXNUM(i);
+                return ecl_make_fixnum(i);
         } else {
                 cl_object aux = ecl_make_int32_t(i >> 32);
                 return cl_logior(2, ecl_ash(aux, 32), ecl_make_uint32_t((ecl_uint32_t)i));
@@ -424,22 +424,22 @@ ecl_make_ratio(cl_object num, cl_object den)
 	cl_object g, r;
 
 	/* INV: the arguments NUM & DEN are integers */
-	if (den == MAKE_FIXNUM(0))
+	if (den == ecl_make_fixnum(0))
 		FEdivision_by_zero(num, den);
-	if (num == MAKE_FIXNUM(0) || den == MAKE_FIXNUM(1))
+	if (num == ecl_make_fixnum(0) || den == ecl_make_fixnum(1))
 		return(num);
 	if (ecl_minusp(den)) {
 		num = ecl_negate(num);
 		den = ecl_negate(den);
 	}
 	g = ecl_gcd(num, den);
-        if (g != MAKE_FIXNUM(1)) {
+        if (g != ecl_make_fixnum(1)) {
                 num = ecl_integer_divide(num, g);
                 den = ecl_integer_divide(den, g);
         }
-	if (den == MAKE_FIXNUM(1))
+	if (den == ecl_make_fixnum(1))
 		return num;
-	if (den == MAKE_FIXNUM(-1))
+	if (den == ecl_make_fixnum(-1))
 		return ecl_negate(num);
 	r = ecl_alloc_object(t_ratio);
 	r->ratio.num = num;
@@ -541,7 +541,7 @@ ecl_make_complex(cl_object r, cl_object i)
 	case t_ratio:
 		switch (ti) {
 		case t_fixnum:
-			if (i == MAKE_FIXNUM(0))
+			if (i == ecl_make_fixnum(0))
 				return(r);
 		case t_bignum:
 		case t_ratio:
@@ -623,8 +623,8 @@ ecl_make_complex(cl_object r, cl_object i)
 static cl_object
 into_bignum(cl_object bignum, cl_object integer)
 {
-        if (FIXNUMP(integer)) {
-                _ecl_big_set_fixnum(bignum, fix(integer));
+        if (ECL_FIXNUMP(integer)) {
+                _ecl_big_set_fixnum(bignum, ecl_fix(integer));
         } else {
                 mpz_set(bignum->big.big_num, integer->big.big_num);
         }
@@ -677,10 +677,10 @@ prepare_ratio_to_float(cl_object num, cl_object den, int digits, cl_fixnum *scal
                 if ((len - digits) == 1) {
                         if (ecl_oddp(fraction)) {
                                 cl_object one = ecl_minusp(num)?
-                                        MAKE_FIXNUM(-1) :
-                                        MAKE_FIXNUM(1);
-                                if (rem == MAKE_FIXNUM(0)) {
-                                        if (cl_logbitp(MAKE_FIXNUM(1), fraction)
+                                        ecl_make_fixnum(-1) :
+                                        ecl_make_fixnum(1);
+                                if (rem == ecl_make_fixnum(0)) {
+                                        if (cl_logbitp(ecl_make_fixnum(1), fraction)
                                             != Cnil)
                                                 fraction = ecl_plus(fraction, one);
                                 } else {
@@ -703,9 +703,9 @@ ratio_to_float(cl_object num, cl_object den)
         cl_object bits = prepare_ratio_to_float(num, den, FLT_MANT_DIG, &scale);
 #if (FIXNUM_BITS-ECL_TAG_BITS) >= FLT_MANT_DIG
         /* The output of prepare_ratio_to_float will always fit an integer */
-        float output = fix(bits);
+        float output = ecl_fix(bits);
 #else
-        float output = FIXNUMP(bits)? fix(bits) : _ecl_big_to_double(bits);
+        float output = ECL_FIXNUMP(bits)? ecl_fix(bits) : _ecl_big_to_double(bits);
 #endif
         return ldexpf(output, scale);
 }
@@ -718,9 +718,9 @@ ratio_to_double(cl_object num, cl_object den)
         cl_object bits = prepare_ratio_to_float(num, den, DBL_MANT_DIG, &scale);
 #if (FIXNUM_BITS-ECL_TAG_BITS) >= DBL_MANT_DIG
         /* The output of prepare_ratio_to_float will always fit an integer */
-        double output = fix(bits);
+        double output = ecl_fix(bits);
 #else
-        double output = FIXNUMP(bits)? fix(bits) : _ecl_big_to_double(bits);
+        double output = ECL_FIXNUMP(bits)? ecl_fix(bits) : _ecl_big_to_double(bits);
 #endif
         return ldexp(output, scale);
 }
@@ -733,10 +733,10 @@ ratio_to_long_double(cl_object num, cl_object den)
         cl_object bits = prepare_ratio_to_float(num, den, LDBL_MANT_DIG, &scale);
 #if (FIXNUM_BITS-ECL_TAG_BITS) >= LDBL_MANT_DIG
         /* The output of prepare_ratio_to_float will always fit an integer */
-        long double output = fix(bits);
+        long double output = ecl_fix(bits);
 #else
-        long double output = FIXNUMP(bits)?
-                (long double)fix(bits) :
+        long double output = ECL_FIXNUMP(bits)?
+                (long double)ecl_fix(bits) :
                 _ecl_big_to_long_double(bits);
 #endif
         return ldexpl(output, scale);
@@ -748,9 +748,9 @@ ecl_to_double(cl_object x)
 {
 	switch(type_of(x)) {
 	case t_fixnum:
-		return((double)(fix(x)));
+		return((double)(ecl_fix(x)));
 	case t_bignum:
-		return ratio_to_double(x, MAKE_FIXNUM(1));
+		return ratio_to_double(x, ecl_make_fixnum(1));
 	case t_ratio:
                 return ratio_to_double(x->ratio.num, x->ratio.den);
 	case t_singlefloat:
@@ -772,9 +772,9 @@ ecl_to_long_double(cl_object x)
 {
 	switch(type_of(x)) {
 	case t_fixnum:
-		return (long double)fix(x);
+		return (long double)ecl_fix(x);
 	case t_bignum:
-                return ratio_to_long_double(x, MAKE_FIXNUM(1));
+                return ratio_to_long_double(x, ecl_make_fixnum(1));
 	case t_ratio:
                 return ratio_to_long_double(x->ratio.num, x->ratio.den);
 	case t_singlefloat:
@@ -805,15 +805,15 @@ cl_rational(cl_object x)
 	case t_doublefloat:
 		d = df(x);
 	GO_ON:	if (d == 0) {
-			x = MAKE_FIXNUM(0);
+			x = ecl_make_fixnum(0);
 		} else {
 			int e;
 			d = frexp(d, &e);
 			e -= DBL_MANT_DIG;
 			x = double_to_integer(ldexp(d, DBL_MANT_DIG));
                         if (e != 0) {
-                                x = ecl_times(ecl_expt(MAKE_FIXNUM(FLT_RADIX),
-                                                       MAKE_FIXNUM(e)),
+                                x = ecl_times(ecl_expt(ecl_make_fixnum(FLT_RADIX),
+                                                       ecl_make_fixnum(e)),
                                               x);
                         }
 		}
@@ -822,7 +822,7 @@ cl_rational(cl_object x)
 	case t_longfloat: {
 		long double d = ecl_long_float(x);
 		if (d == 0) {
-			x = MAKE_FIXNUM(0);
+			x = ecl_make_fixnum(0);
 		} else {
 			int e;
 			d = frexpl(d, &e);
@@ -830,8 +830,8 @@ cl_rational(cl_object x)
                         d = ldexpl(d, LDBL_MANT_DIG);
 			x = long_double_to_integer(d);
 			if (e != 0) {
-				x = ecl_times(ecl_expt(MAKE_FIXNUM(FLT_RADIX),
-                                                       MAKE_FIXNUM(e)),
+				x = ecl_times(ecl_expt(ecl_make_fixnum(FLT_RADIX),
+                                                       ecl_make_fixnum(e)),
                                               x);
 			}
 		}
@@ -853,7 +853,7 @@ long_double_to_integer(long double d0)
         int e;
         long double d = frexpl(d0, &e);
         if (e <= fb) {
-                return MAKE_FIXNUM((cl_fixnum)d0);
+                return ecl_make_fixnum((cl_fixnum)d0);
         } else if (e > LDBL_MANT_DIG) {
                 return ecl_ash(long_double_to_integer(ldexp(d, LDBL_MANT_DIG)),
                                e - LDBL_MANT_DIG);
@@ -872,7 +872,7 @@ cl_object
 double_to_integer(double d)
 {
 	if (d <= MOST_POSITIVE_FIXNUM && d >= MOST_NEGATIVE_FIXNUM)
-		return MAKE_FIXNUM((cl_fixnum)d);
+		return ecl_make_fixnum((cl_fixnum)d);
 	else {
                 cl_object z = _ecl_big_register0();
                 _ecl_big_set_d(z, d);
@@ -884,7 +884,7 @@ cl_object
 float_to_integer(float d)
 {
 	if (d <= MOST_POSITIVE_FIXNUM && d >= MOST_NEGATIVE_FIXNUM)
-		return MAKE_FIXNUM((cl_fixnum)d);
+		return ecl_make_fixnum((cl_fixnum)d);
 	else {
                 cl_object z = _ecl_big_register0();
                 _ecl_big_set_d(z, d);
diff --git a/src/c/numbers/abs.d b/src/c/numbers/abs.d
index 3f861588e..8f1da1b0f 100644
--- a/src/c/numbers/abs.d
+++ b/src/c/numbers/abs.d
@@ -30,7 +30,7 @@ cl_abs(cl_object x)
 static cl_object
 ecl_abs_fixnum(cl_object x)
 {
-        return ecl_fixnum_minusp(x)? ecl_make_integer(-fix(x)) : x;
+        return ecl_fixnum_minusp(x)? ecl_make_integer(-ecl_fix(x)) : x;
 }
 
 static cl_object
@@ -88,7 +88,7 @@ ecl_abs_complex(cl_object x)
                         i = r; r = aux;
                 }
                 r = ecl_divide(r, i);
-                r = ecl_plus(MAKE_FIXNUM(1), ecl_times(r, r));
+                r = ecl_plus(ecl_make_fixnum(1), ecl_times(r, r));
                 return ecl_times(cl_sqrt(r), i);
         }
 }
diff --git a/src/c/numbers/atan.d b/src/c/numbers/atan.d
index cf94ff601..366873839 100644
--- a/src/c/numbers/atan.d
+++ b/src/c/numbers/atan.d
@@ -131,8 +131,8 @@ ecl_atan1(cl_object y)
 #if 0 /* ANSI states it should be this first part */
 		cl_object z = ecl_times(cl_core.imag_unit, y);
 		z = ecl_plus(ecl_log1(ecl_one_plus(z)),
-			     ecl_log1(ecl_minus(MAKE_FIXNUM(1), z)));
-		z = ecl_divide(z, ecl_times(MAKE_FIXNUM(2),
+			     ecl_log1(ecl_minus(ecl_make_fixnum(1), z)));
+		z = ecl_divide(z, ecl_times(ecl_make_fixnum(2),
 					    cl_core.imag_unit));
 #else
 		cl_object z1, z = ecl_times(cl_core.imag_unit, y);
@@ -146,7 +146,7 @@ ecl_atan1(cl_object y)
 #endif /* ANSI */
 		return z;
 	} else {
-		return ecl_atan2(y, MAKE_FIXNUM(1));
+		return ecl_atan2(y, ecl_make_fixnum(1));
 	}
 }
 
diff --git a/src/c/numbers/divide.d b/src/c/numbers/divide.d
index f2499d124..308cb0048 100644
--- a/src/c/numbers/divide.d
+++ b/src/c/numbers/divide.d
@@ -22,7 +22,7 @@
 	if (narg == 0)
 		FEwrong_num_arguments(@[/]);
 	if (narg == 1)
-		@(return ecl_divide(MAKE_FIXNUM(1), num))
+		@(return ecl_divide(ecl_make_fixnum(1), num))
 	while (--narg)
 		num = ecl_divide(num, cl_va_arg(nums));
 	@(return num)
@@ -47,7 +47,7 @@ MATH_DISPATCH2_BEGIN(x,y)
 {
         CASE_FIXNUM_FIXNUM;
         CASE_BIGNUM_FIXNUM {
-                if (y == MAKE_FIXNUM(0))
+                if (y == ecl_make_fixnum(0))
                         FEdivision_by_zero(x, y);
         }
         CASE_FIXNUM_BIGNUM;
@@ -60,10 +60,10 @@ MATH_DISPATCH2_BEGIN(x,y)
                                       y->ratio.num);
         }
         CASE_FIXNUM_SINGLE_FLOAT {
-                return ecl_make_singlefloat(fix(x) / ecl_single_float(y));
+                return ecl_make_singlefloat(ecl_fix(x) / ecl_single_float(y));
         }
         CASE_FIXNUM_DOUBLE_FLOAT {
-                return ecl_make_doublefloat(fix(x) / ecl_double_float(y));
+                return ecl_make_doublefloat(ecl_fix(x) / ecl_double_float(y));
         }
         CASE_BIGNUM_SINGLE_FLOAT;
         CASE_RATIO_SINGLE_FLOAT {
@@ -74,7 +74,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_doublefloat(ecl_to_double(x) / ecl_double_float(y));
         }
         CASE_RATIO_FIXNUM {
-                if (y == MAKE_FIXNUM(0)) {
+                if (y == ecl_make_fixnum(0)) {
                         FEdivision_by_zero(x,y);
                 }
         }
@@ -88,7 +88,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_ratio(num, den);
         }
         CASE_SINGLE_FLOAT_FIXNUM {
-                return ecl_make_singlefloat(ecl_single_float(x) / fix(y));
+                return ecl_make_singlefloat(ecl_single_float(x) / ecl_fix(y));
         }
         CASE_SINGLE_FLOAT_BIGNUM;
         CASE_SINGLE_FLOAT_RATIO {
@@ -101,7 +101,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_doublefloat(ecl_single_float(x) / ecl_double_float(y));
         }
         CASE_DOUBLE_FLOAT_FIXNUM {
-                return ecl_make_doublefloat(ecl_double_float(x) / fix(y));
+                return ecl_make_doublefloat(ecl_double_float(x) / ecl_fix(y));
         }
         CASE_DOUBLE_FLOAT_BIGNUM;
         CASE_DOUBLE_FLOAT_RATIO {
@@ -115,7 +115,7 @@ MATH_DISPATCH2_BEGIN(x,y)
         }
 #ifdef ECL_LONG_FLOAT
         CASE_FIXNUM_LONG_FLOAT {
-                return ecl_make_longfloat(fix(x) / ecl_long_float(y));
+                return ecl_make_longfloat(ecl_fix(x) / ecl_long_float(y));
         }
         CASE_BIGNUM_LONG_FLOAT;
         CASE_RATIO_LONG_FLOAT {
@@ -128,7 +128,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_longfloat(ecl_double_float(x) / ecl_long_float(y));
         }
         CASE_LONG_FLOAT_FIXNUM {
-                return ecl_make_longfloat(ecl_long_float(x) / fix(y));
+                return ecl_make_longfloat(ecl_long_float(x) / ecl_fix(y));
         }
         CASE_LONG_FLOAT_BIGNUM;
         CASE_LONG_FLOAT_RATIO {
@@ -164,7 +164,7 @@ MATH_DISPATCH2_BEGIN(x,y)
         CASE_DOUBLE_FLOAT_COMPLEX;
         CASE_FIXNUM_COMPLEX {
         COMPLEX_Y:
-                return complex_divide(x, MAKE_FIXNUM(0), y->complex.real, y->complex.imag);
+                return complex_divide(x, ecl_make_fixnum(0), y->complex.real, y->complex.imag);
         }
         CASE_COMPLEX_COMPLEX {
                 return complex_divide(x->complex.real, x->complex.imag,
@@ -187,7 +187,7 @@ ecl_divide(cl_object x, cl_object y)
 	case t_bignum:
 		switch (type_of(y)) {
 		case t_fixnum:
-			if (y == MAKE_FIXNUM(0))
+			if (y == ecl_make_fixnum(0))
 				FEdivision_by_zero(x, y);
 		case t_bignum:
 			if (ecl_minusp(y) == TRUE) {
@@ -214,7 +214,7 @@ ecl_divide(cl_object x, cl_object y)
 	case t_ratio:
 		switch (type_of(y)) {
 		case t_fixnum:
-			if (y == MAKE_FIXNUM(0))
+			if (y == ecl_make_fixnum(0))
 				FEdivision_by_zero(x, y);
 		case t_bignum:
 			z = ecl_times(x->ratio.den, y);
@@ -239,7 +239,7 @@ ecl_divide(cl_object x, cl_object y)
 	case t_singlefloat:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_singlefloat(sf(x) / fix(y));
+			return ecl_make_singlefloat(sf(x) / ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_singlefloat(sf(x) / ecl_to_double(y));
@@ -259,7 +259,7 @@ ecl_divide(cl_object x, cl_object y)
 	case t_doublefloat:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_doublefloat(df(x) / fix(y));
+			return ecl_make_doublefloat(df(x) / ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_doublefloat(df(x) / ecl_to_double(y));
@@ -280,7 +280,7 @@ ecl_divide(cl_object x, cl_object y)
 	case t_longfloat:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_longfloat(ecl_long_float(x) / fix(y));
+			return ecl_make_longfloat(ecl_long_float(x) / ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_longfloat(ecl_long_float(x) / ecl_to_double(y));
diff --git a/src/c/numbers/expt.d b/src/c/numbers/expt.d
index 4857b7989..b91805c25 100644
--- a/src/c/numbers/expt.d
+++ b/src/c/numbers/expt.d
@@ -66,7 +66,7 @@ expt_zero(cl_object x, cl_object y)
         case t_fixnum:
         case t_bignum:
         case t_ratio:
-                return MAKE_FIXNUM(1);
+                return ecl_make_fixnum(1);
         case t_singlefloat:
                 return singlefloat_one;
         case t_doublefloat:
@@ -78,7 +78,7 @@ expt_zero(cl_object x, cl_object y)
         case t_complex:
                 z = expt_zero((tx == t_complex)? x->complex.real : x,
                               (ty == t_complex)? y->complex.real : y);
-                return ecl_make_complex(z, MAKE_FIXNUM(0));
+                return ecl_make_complex(z, ecl_make_fixnum(0));
         default:
                 /* We will never reach this */
                 (void)0;
@@ -101,7 +101,7 @@ ecl_expt(cl_object x, cl_object y)
         if (ecl_zerop(x)) {
 		z = ecl_times(x, y);
 		if (!ecl_plusp(ty==t_complex?y->complex.real:y))
-			z = ecl_divide(MAKE_FIXNUM(1), z);
+			z = ecl_divide(ecl_make_fixnum(1), z);
 	} else if (ty != t_fixnum && ty != t_bignum) {
                 /* The following could be just
                    z = ecl_log1(x);
@@ -114,15 +114,15 @@ ecl_expt(cl_object x, cl_object y)
 	} else if (ecl_minusp(y)) {
 		z = ecl_negate(y);
 		z = ecl_expt(x, z);
-		z = ecl_divide(MAKE_FIXNUM(1), z);
+		z = ecl_divide(ecl_make_fixnum(1), z);
 	} else {
                 ECL_MATHERR_CLEAR;
-		z = MAKE_FIXNUM(1);
+		z = ecl_make_fixnum(1);
 		do {
 			/* INV: ecl_integer_divide outputs an integer */
 			if (!ecl_evenp(y))
 				z = ecl_times(z, x);
-			y = ecl_integer_divide(y, MAKE_FIXNUM(2));
+			y = ecl_integer_divide(y, ecl_make_fixnum(2));
 			if (ecl_zerop(y)) break;
 			x = ecl_times(x, x);
 		} while (1);
diff --git a/src/c/numbers/log.d b/src/c/numbers/log.d
index a70728280..1397a5c56 100644
--- a/src/c/numbers/log.d
+++ b/src/c/numbers/log.d
@@ -36,14 +36,14 @@ ecl_log1_complex_inner(cl_object r, cl_object i)
 		 * log(sqrt(a^2+p^2)) = log(2a^2)/2
 		 */
 		a = ecl_times(a, a);
-		a = ecl_divide(ecl_log1(ecl_plus(a, a)), MAKE_FIXNUM(2));
+		a = ecl_divide(ecl_log1(ecl_plus(a, a)), ecl_make_fixnum(2));
 		goto OUTPUT;
 	}
 	/* For the real part of the output we use the formula
 	 *	log(sqrt(p^2 + a^2)) = log(sqrt(p^2*(1 + (a/p)^2)))
 	 *			     = log(p) + log(1 + (a/p)^2)/2; */
 	a = ecl_divide(a, p);
-	a = ecl_plus(ecl_divide(ecl_log1p(ecl_times(a,a)), MAKE_FIXNUM(2)),
+	a = ecl_plus(ecl_divide(ecl_log1p(ecl_times(a,a)), ecl_make_fixnum(2)),
 		     ecl_log1(p));
  OUTPUT:
 	p = ecl_atan2(i, r);
@@ -54,10 +54,10 @@ static cl_object
 ecl_log1_bignum(cl_object x)
 {
         if (ecl_minusp(x)) {
-                return ecl_log1_complex_inner(x, MAKE_FIXNUM(0));
+                return ecl_log1_complex_inner(x, ecl_make_fixnum(0));
         } else {
                 cl_fixnum l = ecl_integer_length(x) - 1;
-                cl_object r = ecl_make_ratio(x, ecl_ash(MAKE_FIXNUM(1), l));
+                cl_object r = ecl_make_ratio(x, ecl_ash(ecl_make_fixnum(1), l));
                 float d = logf(number_to_float(r)) + l * logf(2.0);
                 return ecl_make_singlefloat(d);
         }
@@ -67,7 +67,7 @@ static cl_object
 ecl_log1_rational(cl_object x)
 {
         float f = number_to_float(x);
-        if (f < 0) return ecl_log1_complex_inner(x, MAKE_FIXNUM(0));
+        if (f < 0) return ecl_log1_complex_inner(x, ecl_make_fixnum(0));
         return ecl_make_singlefloat(logf(number_to_float(x)));
 }
 
@@ -76,7 +76,7 @@ ecl_log1_single_float(cl_object x)
 {
         float f = sf(x);
         if (isnan(f)) return x;
-        if (f < 0) return ecl_log1_complex_inner(x, MAKE_FIXNUM(0));
+        if (f < 0) return ecl_log1_complex_inner(x, ecl_make_fixnum(0));
         return ecl_make_singlefloat(logf(f));
 }
 
@@ -85,7 +85,7 @@ ecl_log1_double_float(cl_object x)
 {
         double f = df(x);
         if (isnan(f)) return x;
-        if (f < 0) return ecl_log1_complex_inner(x, MAKE_FIXNUM(0));
+        if (f < 0) return ecl_log1_complex_inner(x, ecl_make_fixnum(0));
         return ecl_make_doublefloat(log(f));
 }
 
@@ -95,7 +95,7 @@ ecl_log1_long_float(cl_object x)
 {
         long double f = ecl_long_float(x);
         if (isnan(f)) return x;
-        if (f < 0) return ecl_log1_complex_inner(x, MAKE_FIXNUM(0));
+        if (f < 0) return ecl_log1_complex_inner(x, ecl_make_fixnum(0));
         return ecl_make_longfloat(logl(f));
 }
 #endif
@@ -173,7 +173,7 @@ si_log1p(cl_object x)
 static cl_object
 ecl_log1p_simple(cl_object x)
 {
-        return ecl_log1_complex_inner(ecl_one_plus(x), MAKE_FIXNUM(0));
+        return ecl_log1_complex_inner(ecl_one_plus(x), ecl_make_fixnum(0));
 }
 
 static cl_object
diff --git a/src/c/numbers/minus.d b/src/c/numbers/minus.d
index 350f9dc42..72494d4d4 100644
--- a/src/c/numbers/minus.d
+++ b/src/c/numbers/minus.d
@@ -35,10 +35,10 @@ ecl_minus(cl_object x, cl_object y)
 MATH_DISPATCH2_BEGIN(x,y)
 {
         CASE_FIXNUM_FIXNUM {
-                return ecl_make_integer(fix(x) - fix(y));
+                return ecl_make_integer(ecl_fix(x) - ecl_fix(y));
         }
         CASE_FIXNUM_BIGNUM {
-                return _ecl_fix_minus_big(fix(x), y);
+                return _ecl_fix_minus_big(ecl_fix(x), y);
         }
         CASE_FIXNUM_RATIO;
         CASE_BIGNUM_RATIO {
@@ -47,13 +47,13 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_ratio(z, y->ratio.den);
         }
         CASE_FIXNUM_SINGLE_FLOAT {
-                return ecl_make_singlefloat(fix(x) - ecl_single_float(y));
+                return ecl_make_singlefloat(ecl_fix(x) - ecl_single_float(y));
         }
         CASE_FIXNUM_DOUBLE_FLOAT {
-                return ecl_make_doublefloat(fix(x) - ecl_double_float(y));
+                return ecl_make_doublefloat(ecl_fix(x) - ecl_double_float(y));
         }
         CASE_BIGNUM_FIXNUM {
-                return _ecl_big_plus_fix(x, -fix(y));
+                return _ecl_big_plus_fix(x, -ecl_fix(y));
         }
         CASE_BIGNUM_BIGNUM {
                 return _ecl_big_minus_big(x, y);
@@ -80,7 +80,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_ratio(z, z1);
         }
         CASE_SINGLE_FLOAT_FIXNUM {
-                return ecl_make_singlefloat(ecl_single_float(x) - fix(y));
+                return ecl_make_singlefloat(ecl_single_float(x) - ecl_fix(y));
         }
         CASE_SINGLE_FLOAT_BIGNUM;
         CASE_SINGLE_FLOAT_RATIO {
@@ -93,7 +93,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_doublefloat(ecl_single_float(x) - ecl_double_float(y));
         }
         CASE_DOUBLE_FLOAT_FIXNUM {
-                return ecl_make_doublefloat(ecl_double_float(x) - fix(y));
+                return ecl_make_doublefloat(ecl_double_float(x) - ecl_fix(y));
         }
         CASE_DOUBLE_FLOAT_BIGNUM;
         CASE_DOUBLE_FLOAT_RATIO {
@@ -107,7 +107,7 @@ MATH_DISPATCH2_BEGIN(x,y)
         }
 #ifdef ECL_LONG_FLOAT
         CASE_FIXNUM_LONG_FLOAT {
-                return ecl_make_longfloat(fix(x) - ecl_long_float(y));
+                return ecl_make_longfloat(ecl_fix(x) - ecl_long_float(y));
         }
         CASE_BIGNUM_LONG_FLOAT {
                 return ecl_make_longfloat(ecl_to_long_double(x) - ecl_long_float(y));
@@ -122,7 +122,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_longfloat(ecl_double_float(x) - ecl_long_float(y));
         }
         CASE_LONG_FLOAT_FIXNUM {
-                return ecl_make_longfloat(ecl_long_float(x) - fix(y));
+                return ecl_make_longfloat(ecl_long_float(x) - ecl_fix(y));
         }
         CASE_LONG_FLOAT_BIGNUM;
         CASE_LONG_FLOAT_RATIO {
@@ -184,20 +184,20 @@ ecl_minus(cl_object x, cl_object y)
 	case t_fixnum:
 		switch(type_of(y)) {
 		case t_fixnum:
-                        return ecl_make_integer(fix(x) - fix(y));
+                        return ecl_make_integer(ecl_fix(x) - ecl_fix(y));
 		case t_bignum:
-                        return _ecl_fix_minus_big(fix(x), y);
+                        return _ecl_fix_minus_big(ecl_fix(x), y);
 		case t_ratio:
 			z = ecl_times(x, y->ratio.den);
 			z = ecl_minus(z, y->ratio.num);
 			return ecl_make_ratio(z, y->ratio.den);
 		case t_singlefloat:
-			return ecl_make_singlefloat(fix(x) - sf(y));
+			return ecl_make_singlefloat(ecl_fix(x) - sf(y));
 		case t_doublefloat:
-			return ecl_make_doublefloat(fix(x) - df(y));
+			return ecl_make_doublefloat(ecl_fix(x) - df(y));
 #ifdef ECL_LONG_FLOAT
 		case t_longfloat:
-			return ecl_make_longfloat(fix(x) - ecl_long_float(y));
+			return ecl_make_longfloat(ecl_fix(x) - ecl_long_float(y));
 #endif
 		case t_complex:
 			goto COMPLEX;
@@ -207,7 +207,7 @@ ecl_minus(cl_object x, cl_object y)
 	case t_bignum:
 		switch (type_of(y)) {
 		case t_fixnum:
-                        return _ecl_big_plus_fix(x, -fix(y));
+                        return _ecl_big_plus_fix(x, -ecl_fix(y));
 		case t_bignum:
                         return _ecl_big_minus_big(x, y);
 		case t_ratio:
@@ -256,7 +256,7 @@ ecl_minus(cl_object x, cl_object y)
 	case t_singlefloat:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_singlefloat(sf(x) - fix(y));
+			return ecl_make_singlefloat(sf(x) - ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_singlefloat(sf(x) - ecl_to_double(y));
@@ -276,7 +276,7 @@ ecl_minus(cl_object x, cl_object y)
 	case t_doublefloat:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_doublefloat(df(x) - fix(y));
+			return ecl_make_doublefloat(df(x) - ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_doublefloat(df(x) - ecl_to_double(y));
diff --git a/src/c/numbers/negate.d b/src/c/numbers/negate.d
index 9c9a12ca8..b2fe1e2f4 100644
--- a/src/c/numbers/negate.d
+++ b/src/c/numbers/negate.d
@@ -21,7 +21,7 @@
 static cl_object
 ecl_negate_fix(cl_object x)
 {
-        return ecl_make_integer(-fix(x));
+        return ecl_make_integer(-ecl_fix(x));
 }
 
 static cl_object
diff --git a/src/c/numbers/number_compare.d b/src/c/numbers/number_compare.d
index 71f1bebdf..c4a4b6f65 100644
--- a/src/c/numbers/number_compare.d
+++ b/src/c/numbers/number_compare.d
@@ -41,10 +41,10 @@ ecl_number_compare(cl_object x, cl_object y)
 	ty = type_of(y);
 	switch (type_of(x)) {
 	case t_fixnum:
-	  	ix = fix(x);
+	  	ix = ecl_fix(x);
 		switch (ty) {
 		case t_fixnum:
-		  	iy = fix(y);
+		  	iy = ecl_fix(y);
 			if (ix < iy)
 				return(-1);
 			else return(ix != iy);
@@ -116,7 +116,7 @@ ecl_number_compare(cl_object x, cl_object y)
 	DOUBLEFLOAT0:
 		switch (ty) {
 		case t_fixnum:
-			return -double_fix_compare(fix(y), dx);
+			return -double_fix_compare(ecl_fix(y), dx);
 		case t_bignum:
 		case t_ratio:
 			x = cl_rational(x);
@@ -148,7 +148,7 @@ ecl_number_compare(cl_object x, cl_object y)
 		ldx = ecl_long_float(x);
 		switch (ty) {
 		case t_fixnum:
-			return -long_double_fix_compare(fix(y), ldx);
+			return -long_double_fix_compare(ecl_fix(y), ldx);
 		case t_bignum:
 		case t_ratio:
 			x = cl_rational(x);
diff --git a/src/c/numbers/number_equalp.d b/src/c/numbers/number_equalp.d
index 50e8d613d..f860d9838 100644
--- a/src/c/numbers/number_equalp.d
+++ b/src/c/numbers/number_equalp.d
@@ -48,12 +48,12 @@ ecl_number_equalp(cl_object x, cl_object y)
 		case t_ratio:
 			return 0;
 		case t_singlefloat:
-			return double_fix_compare(fix(x), ecl_single_float(y)) == 0;
+			return double_fix_compare(ecl_fix(x), ecl_single_float(y)) == 0;
 		case t_doublefloat:
-			return double_fix_compare(fix(x), ecl_double_float(y)) == 0;
+			return double_fix_compare(ecl_fix(x), ecl_double_float(y)) == 0;
 #ifdef ECL_LONG_FLOAT
 		case t_longfloat:
-			return long_double_fix_compare(fix(x), ecl_long_float(y)) == 0;
+			return long_double_fix_compare(ecl_fix(x), ecl_long_float(y)) == 0;
 #endif
 		case t_complex:
 			goto Y_COMPLEX;
@@ -108,7 +108,7 @@ ecl_number_equalp(cl_object x, cl_object y)
 	FLOAT:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return double_fix_compare(fix(y), dx) == 0;
+			return double_fix_compare(ecl_fix(y), dx) == 0;
 		case t_bignum:
 		case t_ratio:
 			x = cl_rational(x);
@@ -131,7 +131,7 @@ ecl_number_equalp(cl_object x, cl_object y)
 		long double dx = ecl_long_float(x);
 		switch (type_of(y)) {
 		case t_fixnum:
-			return long_double_fix_compare(fix(y), dx) == 0;
+			return long_double_fix_compare(ecl_fix(y), dx) == 0;
 		case t_bignum:
 		case t_ratio:
 			x = cl_rational(x);
diff --git a/src/c/numbers/one_minus.d b/src/c/numbers/one_minus.d
index 70c51ccd3..438fdc7a6 100644
--- a/src/c/numbers/one_minus.d
+++ b/src/c/numbers/one_minus.d
@@ -21,15 +21,15 @@
 static cl_object
 ecl_one_minus_fix(cl_object x)
 {
-        if (x == MAKE_FIXNUM(MOST_NEGATIVE_FIXNUM))
+        if (x == ecl_make_fixnum(MOST_NEGATIVE_FIXNUM))
                 return ecl_make_integer(MOST_NEGATIVE_FIXNUM-1);
-        return (cl_object)((cl_fixnum)x - ((cl_fixnum)MAKE_FIXNUM(1) - FIXNUM_TAG));
+        return (cl_object)((cl_fixnum)x - ((cl_fixnum)ecl_make_fixnum(1) - ECL_FIXNUM_TAG));
 }
 
 static cl_object
 ecl_one_minus_big(cl_object x)
 {
-        return ecl_minus(x, MAKE_FIXNUM(1));
+        return ecl_minus(x, ecl_make_fixnum(1));
 }
 
 static cl_object
diff --git a/src/c/numbers/one_plus.d b/src/c/numbers/one_plus.d
index 7306371a7..94f9e1d4b 100644
--- a/src/c/numbers/one_plus.d
+++ b/src/c/numbers/one_plus.d
@@ -21,15 +21,15 @@
 static cl_object
 ecl_one_plus_fix(cl_object x)
 {
-        if (x == MAKE_FIXNUM(MOST_POSITIVE_FIXNUM))
+        if (x == ecl_make_fixnum(MOST_POSITIVE_FIXNUM))
                 return ecl_make_integer(MOST_POSITIVE_FIXNUM+1);
-        return (cl_object)((cl_fixnum)x + ((cl_fixnum)MAKE_FIXNUM(1) - FIXNUM_TAG));
+        return (cl_object)((cl_fixnum)x + ((cl_fixnum)ecl_make_fixnum(1) - ECL_FIXNUM_TAG));
 }
 
 static cl_object
 ecl_one_plus_big(cl_object x)
 {
-        return ecl_plus(x, MAKE_FIXNUM(1));
+        return ecl_plus(x, ecl_make_fixnum(1));
 }
 
 static cl_object
diff --git a/src/c/numbers/plus.d b/src/c/numbers/plus.d
index dbd2e26a9..bbf48e0e9 100644
--- a/src/c/numbers/plus.d
+++ b/src/c/numbers/plus.d
@@ -17,7 +17,7 @@
 #include <ecl/impl/math_dispatch2.h>
 
 @(defun + (&rest nums)
-	cl_object sum = MAKE_FIXNUM(0);
+	cl_object sum = ecl_make_fixnum(0);
 @
 	/* INV: type check is in ecl_plus() */
 	while (narg--)
@@ -33,10 +33,10 @@ ecl_plus(cl_object x, cl_object y)
 MATH_DISPATCH2_BEGIN(x,y)
 {
         CASE_FIXNUM_FIXNUM {
-                return ecl_make_integer(fix(x) + fix(y));
+                return ecl_make_integer(ecl_fix(x) + ecl_fix(y));
         }
         CASE_FIXNUM_BIGNUM {
-                return _ecl_big_plus_fix(y, fix(x));
+                return _ecl_big_plus_fix(y, ecl_fix(x));
         }
         CASE_FIXNUM_RATIO;
         CASE_BIGNUM_RATIO {
@@ -45,13 +45,13 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_ratio(z, y->ratio.den);
         }
         CASE_FIXNUM_SINGLE_FLOAT {
-                return ecl_make_singlefloat(fix(x) + ecl_single_float(y));
+                return ecl_make_singlefloat(ecl_fix(x) + ecl_single_float(y));
         }
         CASE_FIXNUM_DOUBLE_FLOAT {
-                return ecl_make_doublefloat(fix(x) + ecl_double_float(y));
+                return ecl_make_doublefloat(ecl_fix(x) + ecl_double_float(y));
         }
         CASE_BIGNUM_FIXNUM {
-                return _ecl_big_plus_fix(x, fix(y));
+                return _ecl_big_plus_fix(x, ecl_fix(y));
         }
         CASE_BIGNUM_BIGNUM {
                 return _ecl_big_plus_big(x, y);
@@ -78,7 +78,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_ratio(z, z1);
         }
         CASE_SINGLE_FLOAT_FIXNUM {
-                return ecl_make_singlefloat(ecl_single_float(x) + fix(y));
+                return ecl_make_singlefloat(ecl_single_float(x) + ecl_fix(y));
         }
         CASE_SINGLE_FLOAT_BIGNUM;
         CASE_SINGLE_FLOAT_RATIO {
@@ -91,7 +91,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_doublefloat(ecl_single_float(x) + ecl_double_float(y));
         }
         CASE_DOUBLE_FLOAT_FIXNUM {
-                return ecl_make_doublefloat(ecl_double_float(x) + fix(y));
+                return ecl_make_doublefloat(ecl_double_float(x) + ecl_fix(y));
         }
         CASE_DOUBLE_FLOAT_BIGNUM;
         CASE_DOUBLE_FLOAT_RATIO {
@@ -105,7 +105,7 @@ MATH_DISPATCH2_BEGIN(x,y)
         }
 #ifdef ECL_LONG_FLOAT
         CASE_FIXNUM_LONG_FLOAT {
-                return ecl_make_longfloat(fix(x) + ecl_long_float(y));
+                return ecl_make_longfloat(ecl_fix(x) + ecl_long_float(y));
         }
         CASE_BIGNUM_LONG_FLOAT {
                 return ecl_make_longfloat(ecl_to_long_double(x) + ecl_long_float(y));
@@ -120,7 +120,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_longfloat(ecl_double_float(x) + ecl_long_float(y));
         }
         CASE_LONG_FLOAT_FIXNUM {
-                return ecl_make_longfloat(ecl_long_float(x) + fix(y));
+                return ecl_make_longfloat(ecl_long_float(x) + ecl_fix(y));
         }
         CASE_LONG_FLOAT_BIGNUM;
         CASE_LONG_FLOAT_RATIO {
@@ -182,20 +182,20 @@ ecl_plus(cl_object x, cl_object y)
 	case t_fixnum:
 	        switch (type_of(y)) {
 		case t_fixnum:
-                        return ecl_make_integer(fix(x) + fix(y));
+                        return ecl_make_integer(ecl_fix(x) + ecl_fix(y));
 		case t_bignum:
-                        return _ecl_big_plus_fix(y, fix(x));
+                        return _ecl_big_plus_fix(y, ecl_fix(x));
 		case t_ratio:
 			z = ecl_times(x, y->ratio.den);
 			z = ecl_plus(z, y->ratio.num);
 			return ecl_make_ratio(z, y->ratio.den);
 		case t_singlefloat:
-			return ecl_make_singlefloat(fix(x) + sf(y));
+			return ecl_make_singlefloat(ecl_fix(x) + sf(y));
 		case t_doublefloat:
-			return ecl_make_doublefloat(fix(x) + df(y));
+			return ecl_make_doublefloat(ecl_fix(x) + df(y));
 #ifdef ECL_LONG_FLOAT
 		case t_longfloat:
-			return ecl_make_longfloat(fix(x) + ecl_long_float(y));
+			return ecl_make_longfloat(ecl_fix(x) + ecl_long_float(y));
 #endif
 		case t_complex:
 		COMPLEX: /* INV: x is real, y is complex */
@@ -207,7 +207,7 @@ ecl_plus(cl_object x, cl_object y)
 	case t_bignum:
 		switch (type_of(y)) {
 		case t_fixnum:
-                        return _ecl_big_plus_fix(x, fix(y));
+                        return _ecl_big_plus_fix(x, ecl_fix(y));
 		case t_bignum:
                         return _ecl_big_plus_big(x, y);
 		case t_ratio:
@@ -256,7 +256,7 @@ ecl_plus(cl_object x, cl_object y)
 	case t_singlefloat:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_singlefloat(sf(x) + fix(y));
+			return ecl_make_singlefloat(sf(x) + ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_singlefloat(sf(x) + ecl_to_double(y));
@@ -276,7 +276,7 @@ ecl_plus(cl_object x, cl_object y)
 	case t_doublefloat:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_doublefloat(df(x) + fix(y));
+			return ecl_make_doublefloat(df(x) + ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_doublefloat(df(x) + ecl_to_double(y));
@@ -297,7 +297,7 @@ ecl_plus(cl_object x, cl_object y)
 	case t_longfloat:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_longfloat(ecl_long_float(x) + fix(y));
+			return ecl_make_longfloat(ecl_long_float(x) + ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_longfloat(ecl_long_float(x) + ecl_to_double(y));
diff --git a/src/c/numbers/sqrt.d b/src/c/numbers/sqrt.d
index c95fbf024..769a323c3 100644
--- a/src/c/numbers/sqrt.d
+++ b/src/c/numbers/sqrt.d
@@ -33,7 +33,7 @@ ecl_sqrt_rational(cl_object x)
 {
         if (ecl_minusp(x)) {
                 x = ecl_sqrt_rational(ecl_negate(x));
-                return ecl_make_complex(MAKE_FIXNUM(0), x);
+                return ecl_make_complex(ecl_make_fixnum(0), x);
         } else {
                 return ecl_make_singlefloat(sqrtf(number_to_float(x)));
         }
@@ -44,7 +44,7 @@ ecl_sqrt_single_float(cl_object x)
 {
         float f = sf(x);
         if (f < 0) {
-                return ecl_make_complex(MAKE_FIXNUM(0),
+                return ecl_make_complex(ecl_make_fixnum(0),
                                         ecl_make_singlefloat(sqrtf(-f)));
         } else {
                 return ecl_make_singlefloat(sqrtf(f));
@@ -56,7 +56,7 @@ ecl_sqrt_double_float(cl_object x)
 {
         double f = df(x);
         if (f < 0) {
-                return ecl_make_complex(MAKE_FIXNUM(0),
+                return ecl_make_complex(ecl_make_fixnum(0),
                                         ecl_make_doublefloat(sqrt(-f)));
         } else {
                 return ecl_make_doublefloat(sqrt(f));
@@ -69,7 +69,7 @@ ecl_sqrt_long_float(cl_object x)
 {
         long double f = ecl_long_float(x);
         if (f < 0) {
-                return ecl_make_complex(MAKE_FIXNUM(0),
+                return ecl_make_complex(ecl_make_fixnum(0),
                                         ecl_make_longfloat(sqrtl(-f)));
         } else {
                 return ecl_make_longfloat(sqrtl(f));
diff --git a/src/c/numbers/times.d b/src/c/numbers/times.d
index fce49f1c3..b69ff20e8 100644
--- a/src/c/numbers/times.d
+++ b/src/c/numbers/times.d
@@ -17,7 +17,7 @@
 #include <ecl/impl/math_dispatch2.h>
 
 @(defun * (&rest nums)
-	cl_object prod = MAKE_FIXNUM(1);
+	cl_object prod = ecl_make_fixnum(1);
 @
 	/* INV: type check in ecl_times() */
 	while (narg--)
@@ -33,10 +33,10 @@ ecl_times(cl_object x, cl_object y)
 MATH_DISPATCH2_BEGIN(x,y)
 {
         CASE_FIXNUM_FIXNUM {
-                return _ecl_fix_times_fix(fix(x), fix(y));
+                return _ecl_fix_times_fix(ecl_fix(x), ecl_fix(y));
         }
         CASE_FIXNUM_BIGNUM {
-                return _ecl_big_times_fix(y, fix(x));
+                return _ecl_big_times_fix(y, ecl_fix(x));
         }
         CASE_FIXNUM_RATIO;
         CASE_BIGNUM_RATIO {
@@ -44,13 +44,13 @@ MATH_DISPATCH2_BEGIN(x,y)
                                       y->ratio.den);
         }
         CASE_FIXNUM_SINGLE_FLOAT {
-                return ecl_make_singlefloat(fix(x) * ecl_single_float(y));
+                return ecl_make_singlefloat(ecl_fix(x) * ecl_single_float(y));
         }
         CASE_FIXNUM_DOUBLE_FLOAT {
-                return ecl_make_doublefloat(fix(x) * ecl_double_float(y));
+                return ecl_make_doublefloat(ecl_fix(x) * ecl_double_float(y));
         }
         CASE_BIGNUM_FIXNUM {
-                return _ecl_big_times_fix(x, fix(y));
+                return _ecl_big_times_fix(x, ecl_fix(y));
         }
         CASE_BIGNUM_BIGNUM {
                 return _ecl_big_times_big(x, y);
@@ -78,7 +78,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_doublefloat(ecl_to_double(x) * ecl_double_float(y));
         }
         CASE_SINGLE_FLOAT_FIXNUM {
-                return ecl_make_singlefloat(ecl_single_float(x) * fix(y));
+                return ecl_make_singlefloat(ecl_single_float(x) * ecl_fix(y));
         }
         CASE_SINGLE_FLOAT_BIGNUM;
         CASE_SINGLE_FLOAT_RATIO {
@@ -91,7 +91,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_doublefloat(ecl_single_float(x) * ecl_double_float(y));
         }
         CASE_DOUBLE_FLOAT_FIXNUM {
-                return ecl_make_doublefloat(ecl_double_float(x) * fix(y));
+                return ecl_make_doublefloat(ecl_double_float(x) * ecl_fix(y));
         }
         CASE_DOUBLE_FLOAT_BIGNUM;
         CASE_DOUBLE_FLOAT_RATIO {
@@ -105,7 +105,7 @@ MATH_DISPATCH2_BEGIN(x,y)
         }
 #ifdef ECL_LONG_FLOAT
         CASE_FIXNUM_LONG_FLOAT {
-                return ecl_make_longfloat(fix(x) * ecl_long_float(y));
+                return ecl_make_longfloat(ecl_fix(x) * ecl_long_float(y));
         }
         CASE_BIGNUM_LONG_FLOAT;
         CASE_RATIO_LONG_FLOAT {
@@ -118,7 +118,7 @@ MATH_DISPATCH2_BEGIN(x,y)
                 return ecl_make_longfloat(ecl_double_float(x) * ecl_long_float(y));
         }
         CASE_LONG_FLOAT_FIXNUM {
-                return ecl_make_longfloat(ecl_long_float(x) * fix(y));
+                return ecl_make_longfloat(ecl_long_float(x) * ecl_fix(y));
         }
         CASE_LONG_FLOAT_BIGNUM;
         CASE_LONG_FLOAT_RATIO {
@@ -181,19 +181,19 @@ ecl_times(cl_object x, cl_object y)
 	case t_fixnum:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return _ecl_fix_times_fix(fix(x),fix(y));
+			return _ecl_fix_times_fix(ecl_fix(x),ecl_fix(y));
 		case t_bignum:
-			return _ecl_big_times_fix(y, fix(x));
+			return _ecl_big_times_fix(y, ecl_fix(x));
 		case t_ratio:
 			z = ecl_times(x, y->ratio.num);
 			return ecl_make_ratio(z, y->ratio.den);
 		case t_singlefloat:
-			return ecl_make_singlefloat(fix(x) * sf(y));
+			return ecl_make_singlefloat(ecl_fix(x) * sf(y));
 		case t_doublefloat:
-			return ecl_make_doublefloat(fix(x) * df(y));
+			return ecl_make_doublefloat(ecl_fix(x) * df(y));
 #ifdef ECL_LONG_FLOAT
 		case t_longfloat:
-			return ecl_make_longfloat(fix(x) * ecl_long_float(y));
+			return ecl_make_longfloat(ecl_fix(x) * ecl_long_float(y));
 #endif
 		case t_complex:
 			goto COMPLEX;
@@ -203,7 +203,7 @@ ecl_times(cl_object x, cl_object y)
 	case t_bignum:
 		switch (type_of(y)) {
 		case t_fixnum:
-			return _ecl_big_times_fix(x, fix(y));
+			return _ecl_big_times_fix(x, ecl_fix(y));
 		case t_bignum:
 			return _ecl_big_times_big(x, y);
 		case t_ratio:
@@ -249,7 +249,7 @@ ecl_times(cl_object x, cl_object y)
 		float fx = sf(x);
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_singlefloat(fx * fix(y));
+			return ecl_make_singlefloat(fx * ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_singlefloat(fx * ecl_to_double(y));
@@ -270,7 +270,7 @@ ecl_times(cl_object x, cl_object y)
 	case t_doublefloat: {
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_doublefloat(df(x) * fix(y));
+			return ecl_make_doublefloat(df(x) * ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_doublefloat(df(x) * ecl_to_double(y));
@@ -296,7 +296,7 @@ ecl_times(cl_object x, cl_object y)
 		long double lx = ecl_long_float(x);
 		switch (type_of(y)) {
 		case t_fixnum:
-			return ecl_make_longfloat(lx * fix(y));
+			return ecl_make_longfloat(lx * ecl_fix(y));
 		case t_bignum:
 		case t_ratio:
 			return ecl_make_longfloat(lx * ecl_to_double(y));
diff --git a/src/c/numbers/zerop.d b/src/c/numbers/zerop.d
index dea8a32f4..3acfd1d5f 100644
--- a/src/c/numbers/zerop.d
+++ b/src/c/numbers/zerop.d
@@ -27,7 +27,7 @@ cl_zerop(cl_object x)
 static int
 ecl_zerop_fixnum(cl_object x)
 {
-        return x == MAKE_FIXNUM(0);
+        return x == ecl_make_fixnum(0);
 }
 
 static int
diff --git a/src/c/package.d b/src/c/package.d
index f62e11ae1..16d6990fb 100644
--- a/src/c/package.d
+++ b/src/c/package.d
@@ -111,7 +111,7 @@ static cl_object
 make_package_hashtable()
 {
 	return cl__make_hash_table(@'package', /* package hash table */
-				   MAKE_FIXNUM(128), /* initial size */
+				   ecl_make_fixnum(128), /* initial size */
                                    cl_core.rehash_size,
                                    cl_core.rehash_threshold);
 }
diff --git a/src/c/pathname.d b/src/c/pathname.d
index d49324abc..dae0d8d89 100644
--- a/src/c/pathname.d
+++ b/src/c/pathname.d
@@ -297,7 +297,7 @@ ecl_make_pathname(cl_object host, cl_object device, cl_object directory,
 		goto ERROR;
 	}
 	if (version != @':unspecific' && version != @':newest' &&
-	    version != @':wild' && version != Cnil && !FIXNUMP(version))
+	    version != @':wild' && version != Cnil && !ECL_FIXNUMP(version))
 	{
 		x = version;
 		component = @':version';
@@ -395,7 +395,7 @@ tilde_expand(cl_object pathname)
 static cl_object
 make_one(cl_object s, cl_index start, cl_index end)
 {
-	return cl_subseq(3, s, MAKE_FIXNUM(start), MAKE_FIXNUM(end));
+	return cl_subseq(3, s, ecl_make_fixnum(start), ecl_make_fixnum(end));
 }
 
 static int is_colon(int c) { return c == ':'; }
@@ -632,7 +632,7 @@ ecl_parse_namestring(cl_object s, cl_index start, cl_index end, cl_index *ep,
 	} else {
 		version = cl_parse_integer(3, aux, @':junk-allowed', Ct);
 		if (cl_integerp(version) != Cnil && ecl_plusp(version) &&
-		    fix(VALUES(1)) == ecl_length(aux))
+		    ecl_fix(VALUES(1)) == ecl_length(aux))
 			;
 		else if (cl_string_equal(2, aux, @':newest') != Cnil)
 			version = @':newest';
@@ -1020,12 +1020,12 @@ ecl_namestring(cl_object x, int flags)
 		    truncate_if_unreadable)
 			return Cnil;
 		if (host != Cnil) {
-			si_do_write_sequence(host, buffer, MAKE_FIXNUM(0), Cnil);
+			si_do_write_sequence(host, buffer, ecl_make_fixnum(0), Cnil);
 			writestr_stream(":", buffer);
 		}
 	} else {
 		if ((y = x->pathname.device) != Cnil) {
-			si_do_write_sequence(y, buffer, MAKE_FIXNUM(0), Cnil);
+			si_do_write_sequence(y, buffer, ecl_make_fixnum(0), Cnil);
 			writestr_stream(":", buffer);
 		}
 		if (host != Cnil) {
@@ -1035,7 +1035,7 @@ ecl_namestring(cl_object x, int flags)
 			}
 #endif
 			writestr_stream("//", buffer);
-			si_do_write_sequence(host, buffer, MAKE_FIXNUM(0), Cnil);
+			si_do_write_sequence(host, buffer, ecl_make_fixnum(0), Cnil);
 		}
 	}
 	l = x->pathname.directory;
@@ -1059,7 +1059,7 @@ ecl_namestring(cl_object x, int flags)
 		} else if (y == @':wild-inferiors') {
 			writestr_stream("**", buffer);
 		} else if (y != @':back') {
-			si_do_write_sequence(y, buffer, MAKE_FIXNUM(0), Cnil);
+			si_do_write_sequence(y, buffer, ecl_make_fixnum(0), Cnil);
 		} else {
 			/* Directory :back has no namestring representation */
 			return Cnil;
@@ -1067,7 +1067,7 @@ ecl_namestring(cl_object x, int flags)
 		ecl_write_char(logical? ';' : DIR_SEPARATOR, buffer);
 	} end_loop_for_in;
 NO_DIRECTORY:
-	if (ecl_file_position(buffer) == MAKE_FIXNUM(0)) {
+	if (ecl_file_position(buffer) == ecl_make_fixnum(0)) {
 		if ((ecl_stringp(x->pathname.name) &&
 		     ecl_member_char(':', x->pathname.name)) ||
 		    (ecl_stringp(x->pathname.type) &&
@@ -1079,7 +1079,7 @@ NO_DIRECTORY:
 		if (y == @':wild') {
 			writestr_stream("*", buffer);
 		} else {
-			si_do_write_sequence(y, buffer, MAKE_FIXNUM(0), Cnil);
+			si_do_write_sequence(y, buffer, ecl_make_fixnum(0), Cnil);
 		}
 	} else if (!logical && !Null(x->pathname.type)) {
                 /* #P".txt" is :NAME = ".txt" :TYPE = NIL and
@@ -1095,7 +1095,7 @@ NO_DIRECTORY:
 			writestr_stream(".*", buffer);
 		} else {
 			writestr_stream(".", buffer);
-			si_do_write_sequence(y, buffer, MAKE_FIXNUM(0), Cnil);
+			si_do_write_sequence(y, buffer, ecl_make_fixnum(0), Cnil);
 		}
 	}
 	y = x->pathname.version;
@@ -1106,12 +1106,12 @@ NO_DIRECTORY:
 				writestr_stream("*", buffer);
 			} else if (y == @':newest') {
 				si_do_write_sequence(ecl_symbol_name(y), buffer,
-						     MAKE_FIXNUM(0), Cnil);
+						     ecl_make_fixnum(0), Cnil);
 			} else {
 				/* Since the printer is not reentrant,
 				 * we cannot use cl_write and friends.
 				 */
-				int n = fix(y), i;
+				int n = ecl_fix(y), i;
 				char b[FIXNUM_BITS/2];
 				for (i = 0; n; i++) {
 					b[i] = n%10 + '0';
@@ -1157,7 +1157,7 @@ cl_namestring(cl_object x)
 
 @(defun parse_namestring (thing
 	&o host (defaults si_default_pathname_defaults())
-	&k (start MAKE_FIXNUM(0)) end junk_allowed
+	&k (start ecl_make_fixnum(0)) end junk_allowed
 	&a output)
 @
 	if (host != Cnil) {
@@ -1178,7 +1178,7 @@ cl_namestring(cl_object x)
 #endif
 		p = ecl_vector_start_end(@[parse-namestring], thing, start, end);
 		output = ecl_parse_namestring(thing, p.start, p.end, &ee, default_host);
-		start = MAKE_FIXNUM(ee);
+		start = ecl_make_fixnum(ee);
 		if (output == Cnil || ee != p.end) {
 			if (Null(junk_allowed)) {
 				FEparse_error("Cannot parse the namestring ~S~%"
diff --git a/src/c/predicate.d b/src/c/predicate.d
index 459434666..6b801a160 100644
--- a/src/c/predicate.d
+++ b/src/c/predicate.d
@@ -105,7 +105,14 @@ cl_object
 cl_realp(cl_object x)
 {
 	cl_type t = type_of(x);
-	@(return (REAL_TYPE(t) ? Ct : Cnil))
+	@(return (ECL_REAL_TYPE_P(t) ? Ct : Cnil))
+}
+
+bool
+ecl_realp(cl_object x)
+{
+        cl_type t = type_of(x);
+        return ECL_REAL_TYPE_P(t);
 }
 
 cl_object
@@ -117,14 +124,14 @@ cl_complexp(cl_object x)
 cl_object
 cl_characterp(cl_object x)
 {
-	@(return (CHARACTERP(x) ? Ct : Cnil))
+	@(return (ECL_CHARACTERP(x) ? Ct : Cnil))
 }
 
 #ifdef ECL_UNICODE
 cl_object
 si_base_char_p(cl_object c)
 {
-	@(return ((CHARACTERP(c) && BASE_CHAR_P(c))? Ct : Cnil))
+	@(return ((ECL_CHARACTERP(c) && ECL_BASE_CHAR_P(c))? Ct : Cnil))
 }
 #endif
 
@@ -272,7 +279,7 @@ ecl_eql(cl_object x, cl_object y)
 {
 	if (x == y)
 		return TRUE;
-        if (IMMEDIATE(x) || IMMEDIATE(y))
+        if (ECL_IMMEDIATE(x) || ECL_IMMEDIATE(y))
                 return FALSE;
         if (x->d.t != y->d.t)
                 return FALSE;
@@ -356,7 +363,7 @@ BEGIN:
 		return (tx == ty) && ecl_eql(x->complex.real, y->complex.real) &&
 			ecl_eql(x->complex.imag, y->complex.imag);
 	case t_character:
-		return (tx == ty) && (CHAR_CODE(x) == CHAR_CODE(y));
+		return (tx == ty) && (ECL_CHAR_CODE(x) == ECL_CHAR_CODE(y));
 	case t_base_string:
 #ifdef ECL_UNICODE
 	case t_string:
@@ -530,5 +537,5 @@ cl_equalp(cl_object x, cl_object y)
 cl_object
 si_fixnump(cl_object x)
 {
-	@(return (FIXNUMP(x) ? Ct : Cnil))
+	@(return (ECL_FIXNUMP(x) ? Ct : Cnil))
 }
diff --git a/src/c/print.d b/src/c/print.d
index c7761a15c..5bb9c79bb 100644
--- a/src/c/print.d
+++ b/src/c/print.d
@@ -33,8 +33,8 @@ ecl_print_base(void)
 {
 	cl_object object = ecl_symbol_value(@'*print-base*');
 	cl_fixnum base;
-	unlikely_if (!FIXNUMP(object) || (base = fix(object)) < 2 || base > 36) {
-		ECL_SETQ(ecl_process_env(), @'*print-base*', MAKE_FIXNUM(10));
+	unlikely_if (!ECL_FIXNUMP(object) || (base = ecl_fix(object)) < 2 || base > 36) {
+		ECL_SETQ(ecl_process_env(), @'*print-base*', ecl_make_fixnum(10));
 		FEerror("The value of *PRINT-BASE*~%  ~S~%"
                         "is not of the expected type (INTEGER 2 36)", 1, object);
 	}
@@ -49,7 +49,7 @@ ecl_print_level(void)
 	if (object == Cnil) {
 		level = MOST_POSITIVE_FIXNUM;
 	} else if (ECL_FIXNUMP(object)) {
-		level = fix(object);
+		level = ecl_fix(object);
 		if (level < 0) {
 		ERROR:	ECL_SETQ(ecl_process_env(), @'*print-level*', Cnil);
 			FEerror("The value of *PRINT-LEVEL*~%  ~S~%"
@@ -71,8 +71,8 @@ ecl_print_length(void)
 	cl_fixnum length;
 	if (object == Cnil) {
 		length = MOST_POSITIVE_FIXNUM;
-	} else if (FIXNUMP(object)) {
-		length = fix(object);
+	} else if (ECL_FIXNUMP(object)) {
+		length = ecl_fix(object);
 		unlikely_if (length < 0) {
 		ERROR:	ECL_SETQ(ecl_process_env(), @'*print-length*', Cnil);
 			FEerror("The value of *PRINT-LENGTH*~%  ~S~%"
@@ -215,11 +215,11 @@ ecl_print_circle(void)
 @
 	/* INV: ecl_char_code() checks the type of `c' */
  	strm = _ecl_stream_or_default_output(strm);
-	c = CODE_CHAR(ecl_write_char(ecl_char_code(c), strm));
+	c = ECL_CODE_CHAR(ecl_write_char(ecl_char_code(c), strm));
 	@(return c)
 @)
 
-@(defun write-string (strng &o strm &k (start MAKE_FIXNUM(0)) end)
+@(defun write-string (strng &o strm &k (start ecl_make_fixnum(0)) end)
 @
         unlikely_if (!ECL_STRINGP(strng))
                 FEwrong_type_nth_arg(@[write-string], 1, strng, @[string]);
@@ -233,7 +233,7 @@ ecl_print_circle(void)
 	@(return strng)
 @)
 
-@(defun write-line (strng &o strm &k (start MAKE_FIXNUM(0)) end)
+@(defun write-line (strng &o strm &k (start ecl_make_fixnum(0)) end)
 @
         unlikely_if (!ECL_STRINGP(strng))
                 FEwrong_type_nth_arg(@[write-line], 1, strng, @[string]);
@@ -303,7 +303,7 @@ cl_write_byte(cl_object integer, cl_object binary_output_stream)
 	@(return integer)
 }
 
-@(defun write-sequence (sequence stream &key (start MAKE_FIXNUM(0)) end)
+@(defun write-sequence (sequence stream &key (start ecl_make_fixnum(0)) end)
 @
 #ifdef ECL_CLOS_STREAMS
 	if (!ECL_ANSI_STREAM_P(stream)) {
diff --git a/src/c/printer/float_string_old.d b/src/c/printer/float_string_old.d
index 09967a559..6d09dd794 100644
--- a/src/c/printer/float_string_old.d
+++ b/src/c/printer/float_string_old.d
@@ -97,12 +97,12 @@ large_mantissa(cl_object r, cl_object mp, cl_object s)
 static cl_fixnum
 assert_floating_point_width(cl_object width)
 {
-        if (!FIXNUMP(width) || ecl_lower(width,MAKE_FIXNUM(1))) {
+        if (!ECL_FIXNUMP(width) || ecl_lower(width,ecl_make_fixnum(1))) {
                 FEerror("Invalid number of floating point digits."
                         "~%~A~%is not an integer within bounds",
                         1, width);
         }
-        return fix(width);
+        return ecl_fix(width);
 }
 
 static cl_object
@@ -111,7 +111,7 @@ float_string(cl_object digits_string,
              cl_object width, cl_object fdigits, cl_object scale, cl_object fmin)
 {
         cl_object r = fraction;
-        cl_object s = MAKE_FIXNUM(1);
+        cl_object s = ecl_make_fixnum(1);
         cl_object mm = s;
         cl_object mp = s;
         cl_fixnum i, k = 0, digits = 0, decpnt = 0, cutoff = 0;
@@ -120,9 +120,9 @@ float_string(cl_object digits_string,
         bool roundup = 0, cutoffp = 0, low = 0, high = 0;
 
         if (Null(digits_string)) {
-                digits_string = si_make_vector(@'base-char', MAKE_FIXNUM(10),
+                digits_string = si_make_vector(@'base-char', ecl_make_fixnum(10),
                                                Ct /* adjustable */,
-                                               MAKE_FIXNUM(0) /* fill pointer */,
+                                               ecl_make_fixnum(0) /* fill pointer */,
                                                Cnil /* displacement */,
                                                Cnil /* displ. offset */);
         }
@@ -131,17 +131,17 @@ float_string(cl_object digits_string,
          * calculations.
          */
         {
-                int sign = ecl_number_compare(exponent, MAKE_FIXNUM(0));
+                int sign = ecl_number_compare(exponent, ecl_make_fixnum(0));
                 if (sign > 0) {
                         r = cl_ash(fraction, exponent);
-                        mm = cl_ash(MAKE_FIXNUM(1), exponent);
+                        mm = cl_ash(ecl_make_fixnum(1), exponent);
                         mp = mm;
                 } else if (sign < 0) {
-                        s = cl_ash(MAKE_FIXNUM(1), ecl_negate(exponent));
+                        s = cl_ash(ecl_make_fixnum(1), ecl_negate(exponent));
                 }
         }
         /* Adjust error bounds m+ and m- for unequal gaps */
-        if (ecl_number_equalp(fraction, cl_ash(MAKE_FIXNUM(1), precision))) {
+        if (ecl_number_equalp(fraction, cl_ash(ecl_make_fixnum(1), precision))) {
                 mp = ecl_ash(mm, 1);
                 r = ecl_ash(r, 1);
                 s = ecl_ash(s, 1);
@@ -149,26 +149,26 @@ float_string(cl_object digits_string,
         /* Scale value by requested amount and update error bounds */
         if (!Null(scale)) {
                 if (ecl_minusp(scale)) {
-                        cl_object factor = cl_expt(MAKE_FIXNUM(10),
+                        cl_object factor = cl_expt(ecl_make_fixnum(10),
                                                    ecl_negate(scale));
                         s = ecl_times(s, factor);
                 } else {
-                        cl_object factor = cl_expt(MAKE_FIXNUM(10), scale);
+                        cl_object factor = cl_expt(ecl_make_fixnum(10), scale);
                         r = ecl_times(r, factor);
                         mm = ecl_times(mm, factor);
                         mp = ecl_times(mp, factor);
                 }
         }
-        while (ecl_lower(r, ecl_ceiling2(s, MAKE_FIXNUM(10)))) {
+        while (ecl_lower(r, ecl_ceiling2(s, ecl_make_fixnum(10)))) {
                 k--;
-                r = ecl_times(r, MAKE_FIXNUM(10));
-                mm = ecl_times(r, MAKE_FIXNUM(10));
-                mp = ecl_times(r, MAKE_FIXNUM(10));
+                r = ecl_times(r, ecl_make_fixnum(10));
+                mm = ecl_times(r, ecl_make_fixnum(10));
+                mp = ecl_times(r, ecl_make_fixnum(10));
         }
         do {
                 /* Ensure mantissa (r + m+)/s is smaller than one */
                 while (large_mantissa(r, mp, s)) {
-                        s = ecl_times(s, MAKE_FIXNUM(10));
+                        s = ecl_times(s, ecl_make_fixnum(10));
                         k++;
                 }
                 /* Determine the number of digits to generate */
@@ -203,11 +203,11 @@ float_string(cl_object digits_string,
                         y = s;
                         if (a < 0) {
                                 for (i = 0, a = -a; i < a; i++) {
-                                        y = ecl_ceiling2(y, MAKE_FIXNUM(10));
+                                        y = ecl_ceiling2(y, ecl_make_fixnum(10));
                                 } 
                         } else {
                                 for (i = 0, a = -a; i < a; i++) {
-                                        y = ecl_times(y, MAKE_FIXNUM(10));
+                                        y = ecl_times(y, ecl_make_fixnum(10));
                                 } 
                         }
                         mm = cl_max(2, y, mm);
@@ -231,10 +231,10 @@ float_string(cl_object digits_string,
                         ecl_string_push_extend(digits_string, '.');
                         decpnt = digits;
                 }
-                u = ecl_truncate2(ecl_times(r, MAKE_FIXNUM(10)), s);
+                u = ecl_truncate2(ecl_times(r, ecl_make_fixnum(10)), s);
                 r = VALUES(1);
-                mm = ecl_times(mm, MAKE_FIXNUM(10));
-                mp = ecl_times(mp, MAKE_FIXNUM(10));
+                mm = ecl_times(mm, ecl_make_fixnum(10));
+                mp = ecl_times(mp, ecl_make_fixnum(10));
                 low = ecl_lower(ecl_ash(r,1), mm);
                 sign = ecl_number_compare(ecl_ash(r,1), ecl_minus(ecl_ash(s,1),mp));
                 high = roundup? (sign >= 0) : (sign > 0);
@@ -242,21 +242,21 @@ float_string(cl_object digits_string,
                  * fraction digits as permitted */
                 if (low || high || (cutoffp && (k + cutoff <= 0)))
                         break;
-                ecl_string_push_extend(digits_string, ecl_digit_char(fix(u), 10));
+                ecl_string_push_extend(digits_string, ecl_digit_char(ecl_fix(u), 10));
                 digits++;
         } while(1);
         /* If cutof occured before first digit, then no digits generated at all */
         if (!cutoffp || (k + cutoff) >= 0) {
                 /* Last digit may need rounding */
-                int digit = fix(u);
+                int digit = ecl_fix(u);
                 if (low && !high)
-                        digit = fix(u);
+                        digit = ecl_fix(u);
                 else if (high && !low)
-                        digit = fix(u)+1;
+                        digit = ecl_fix(u)+1;
                 else if (ecl_lower(ecl_ash(r,1), s))
-                        digit = fix(u);
+                        digit = ecl_fix(u);
                 else
-                        digit = fix(u) + 1;
+                        digit = ecl_fix(u) + 1;
                 ecl_string_push_extend(digits_string, ecl_digit_char(digit, 10));
                 digits++;
         }
@@ -280,10 +280,10 @@ float_string(cl_object digits_string,
         /* All done */
         @(return
           digits_string
-          MAKE_FIXNUM(1+digits)
+          ecl_make_fixnum(1+digits)
           ((decpnt == 0)? Ct : Cnil)
           ((decpnt == digits)? Ct : Cnil)
-          MAKE_FIXNUM(decpnt))
+          ecl_make_fixnum(decpnt))
 }
 
 ecl_def_ct_base_string(str_dot,".",1,static,const);
@@ -295,11 +295,11 @@ ecl_def_ct_base_string(str_dot,".",1,static,const);
                 if (Null(fdigits)) {
                         cl_object s = cl_make_string(3, ecl_one_plus(fdigits),
                                                      @':initial-element',
-                                                     CODE_CHAR('0'));
+                                                     ECL_CODE_CHAR('0'));
                         ecl_char_set(s, 0, '.');
-                        @(return s cl_length(s) Ct cl_zerop(fdigits) MAKE_FIXNUM(0));
+                        @(return s cl_length(s) Ct cl_zerop(fdigits) ecl_make_fixnum(0));
                 } else {
-                        @(return str_dot MAKE_FIXNUM(1) Ct Ct MAKE_FIXNUM(0));
+                        @(return str_dot ecl_make_fixnum(1) Ct Ct ecl_make_fixnum(0));
                 }
         } else {
                 cl_object sig = cl_integer_decode_float(x);
@@ -307,7 +307,7 @@ ecl_def_ct_base_string(str_dot,".",1,static,const);
                 cl_object precision = cl_float_precision(x);
                 cl_object digits = cl_float_digits(x);
                 cl_object fudge = ecl_minus(digits, precision);
-                cl_object w = Null(width)? Cnil : cl_max(2, width, MAKE_FIXNUM(1));
+                cl_object w = Null(width)? Cnil : cl_max(2, width, ecl_make_fixnum(1));
                 return float_string(string, cl_ash(sig, ecl_negate(fudge)),
                                     ecl_plus(exp, fudge), precision, w,
                                     fdigits, scale, fmin);
diff --git a/src/c/printer/float_to_digits.d b/src/c/printer/float_to_digits.d
index 291cc315e..023d44639 100644
--- a/src/c/printer/float_to_digits.d
+++ b/src/c/printer/float_to_digits.d
@@ -15,8 +15,8 @@
 #include <ecl/ecl.h>
 #include <ecl/ecl-inl.h>
 
-#define PRINT_BASE MAKE_FIXNUM(10)
-#define EXPT_RADIX(x) ecl_ash(MAKE_FIXNUM(1),x)
+#define PRINT_BASE ecl_make_fixnum(10)
+#define EXPT_RADIX(x) ecl_ash(ecl_make_fixnum(1),x)
 
 typedef struct {
         cl_object r;
@@ -37,7 +37,7 @@ static float_approx *
 setup(cl_object number, float_approx *approx)
 {
         cl_object f = cl_integer_decode_float(number);
-        cl_fixnum e = fix(VALUES(1)), min_e;
+        cl_fixnum e = ecl_fix(VALUES(1)), min_e;
         bool limit_f = 0;
         switch (type_of(number)) {
         case t_singlefloat:
@@ -61,27 +61,27 @@ setup(cl_object number, float_approx *approx)
         if (e > 0) {
                 cl_object be = EXPT_RADIX(e);
                 if (limit_f) {
-                        cl_object be1 = ecl_times(be, MAKE_FIXNUM(FLT_RADIX));
+                        cl_object be1 = ecl_times(be, ecl_make_fixnum(FLT_RADIX));
                         approx->r = times2(ecl_times(f, be1));
-                        approx->s = MAKE_FIXNUM(FLT_RADIX*2);
+                        approx->s = ecl_make_fixnum(FLT_RADIX*2);
                         approx->mm = be;
                         approx->mp = be1;
                 } else {
                         approx->r = times2(ecl_times(f, be));
-                        approx->s = MAKE_FIXNUM(2);
+                        approx->s = ecl_make_fixnum(2);
                         approx->mm = be;
                         approx->mp = be;
                 }
         } else if (!limit_f || (e == min_e)) {
                 approx->r = times2(f);
                 approx->s = times2(EXPT_RADIX(-e));
-                approx->mp = MAKE_FIXNUM(1);
-                approx->mm = MAKE_FIXNUM(1);
+                approx->mp = ecl_make_fixnum(1);
+                approx->mm = ecl_make_fixnum(1);
         } else {
-                approx->r = times2(MAKE_FIXNUM(FLT_RADIX));
+                approx->r = times2(ecl_make_fixnum(FLT_RADIX));
                 approx->s = times2(EXPT_RADIX(1-e));
-                approx->mp = MAKE_FIXNUM(FLT_RADIX);
-                approx->mm = MAKE_FIXNUM(1);
+                approx->mp = ecl_make_fixnum(FLT_RADIX);
+                approx->mm = ecl_make_fixnum(1);
         }
         return approx;
 }
@@ -143,16 +143,16 @@ generate(cl_object digits, float_approx *approx)
                 if (tc1 || tc2) {
                         break;
                 }
-                ecl_string_push_extend(digits, ecl_digit_char(fix(d), 10));
+                ecl_string_push_extend(digits, ecl_digit_char(ecl_fix(d), 10));
         } while (1);
         if (tc2 && !tc1) {
-                digit = fix(d) + 1;
+                digit = ecl_fix(d) + 1;
         } else if (tc1 && !tc2) {
-                digit = fix(d);
+                digit = ecl_fix(d);
         } else if (ecl_lower(times2(approx->r), approx->s)) {
-                digit = fix(d);
+                digit = ecl_fix(d);
         } else {
-                digit = fix(d) + 1;
+                digit = ecl_fix(d) + 1;
         }
         ecl_string_push_extend(digits, ecl_digit_char(digit, 10));
         return digits;
@@ -164,10 +164,10 @@ change_precision(float_approx *approx, cl_object position, cl_object relativep)
         cl_fixnum pos;
         if (Null(position))
                 return;
-        pos = fix(position);
+        pos = ecl_fix(position);
         if (!Null(relativep)) {
-                cl_object k = MAKE_FIXNUM(0);
-                cl_object l = MAKE_FIXNUM(1);
+                cl_object k = ecl_make_fixnum(0);
+                cl_object l = ecl_make_fixnum(1);
                 while (ecl_lower(ecl_times(approx->s, l),
                                  ecl_plus(approx->r, approx->mp))) {
                         k = ecl_one_plus(k);
@@ -176,7 +176,7 @@ change_precision(float_approx *approx, cl_object position, cl_object relativep)
                 position = ecl_minus(k, position);
                 {
                         cl_object e1 = cl_expt(PRINT_BASE, position);
-                        cl_object e2 = ecl_divide(e1, MAKE_FIXNUM(2));
+                        cl_object e2 = ecl_divide(e1, ecl_make_fixnum(2));
                         cl_object e3 = cl_expt(PRINT_BASE, k); 
                         if (ecl_greatereq(ecl_plus(approx->r, ecl_times(approx->s, e1)),
                                           ecl_times(approx->s, e2)))
@@ -185,7 +185,7 @@ change_precision(float_approx *approx, cl_object position, cl_object relativep)
         }
         {
                 cl_object x = ecl_times(approx->s, cl_expt(PRINT_BASE, position));
-                cl_object e = ecl_divide(x, MAKE_FIXNUM(2));
+                cl_object e = ecl_divide(x, ecl_make_fixnum(2));
                 cl_object low = cl_max(2, approx->mm, e);
                 cl_object high = cl_max(2, approx->mp, e);
                 if (ecl_lowereq(approx->mm, low)) {
@@ -209,11 +209,11 @@ si_float_to_digits(cl_object digits, cl_object number, cl_object position,
         change_precision(approx, position, relativep);
         k = scale(approx);
         if (Null(digits))
-                digits = si_make_vector(@'base-char', MAKE_FIXNUM(10),
+                digits = si_make_vector(@'base-char', ecl_make_fixnum(10),
                                         Ct /* adjustable */,
-                                        MAKE_FIXNUM(0) /* fill pointer */,
+                                        ecl_make_fixnum(0) /* fill pointer */,
                                         Cnil /* displacement */,
                                         Cnil /* displ. offset */);
         generate(digits, approx);
-        @(return MAKE_FIXNUM(k) digits)
+        @(return ecl_make_fixnum(k) digits)
 }
diff --git a/src/c/printer/float_to_string.d b/src/c/printer/float_to_string.d
index 425f86f97..8e15022b7 100644
--- a/src/c/printer/float_to_string.d
+++ b/src/c/printer/float_to_string.d
@@ -19,9 +19,9 @@ cl_object
 _ecl_ensure_buffer(cl_object buffer, cl_fixnum length)
 {
         if (Null(buffer)) {
-                buffer = si_make_vector(@'base-char', MAKE_FIXNUM(length),
+                buffer = si_make_vector(@'base-char', ecl_make_fixnum(length),
                                         Ct /* adjustable */,
-                                        MAKE_FIXNUM(0) /* fill pointer */,
+                                        ecl_make_fixnum(0) /* fill pointer */,
                                         Cnil /* displacement */,
                                         Cnil /* displ. offset */);
         }
@@ -81,7 +81,7 @@ print_float_exponent(cl_object buffer, cl_object number, cl_fixnum exp)
         }
         if (e != 'e' || exp != 0) {
                 ecl_string_push_extend(buffer, e);
-                si_integer_to_string(buffer, MAKE_FIXNUM(exp), MAKE_FIXNUM(10),
+                si_integer_to_string(buffer, ecl_make_fixnum(exp), ecl_make_fixnum(10),
                                      Cnil, Cnil);
         }
 }
@@ -103,7 +103,7 @@ si_float_to_string_free(cl_object buffer_or_nil, cl_object number,
         base = ecl_length(buffer_or_nil);
         exp = si_float_to_digits(buffer_or_nil, number, Cnil, Cnil);
         buffer = VALUES(1);
-        e = fix(exp);
+        e = ecl_fix(exp);
 
         if (ecl_signbit(number)) {
                 insert_char(buffer, base++, '-');
diff --git a/src/c/printer/integer_to_string.d b/src/c/printer/integer_to_string.d
index 7896c5264..087395e79 100644
--- a/src/c/printer/integer_to_string.d
+++ b/src/c/printer/integer_to_string.d
@@ -20,10 +20,10 @@ bignum_to_string(cl_object buffer, cl_object x, cl_object base)
 {
         cl_index str_size;
         int b;
-        if (!FIXNUMP(base) || ((b = fix(base)) < 2) || (b > 36)) {
+        if (!ECL_FIXNUMP(base) || ((b = ecl_fix(base)) < 2) || (b > 36)) {
                 FEwrong_type_nth_arg(@[si::integer-to-string], 3, base,
-                                     cl_list(3, @'integer', MAKE_FIXNUM(2),
-                                             MAKE_FIXNUM(36)));
+                                     cl_list(3, @'integer', ecl_make_fixnum(2),
+                                             ecl_make_fixnum(36)));
         }
         str_size = mpz_sizeinbase(x->big.big_num, b);
         buffer = _ecl_ensure_buffer(buffer, str_size+1);
@@ -68,12 +68,12 @@ si_integer_to_string(cl_object buffer, cl_object integer,
                      cl_object base, cl_object radix, cl_object decimalp)
 {
         if (!Null(radix)) {
-                if (Null(decimalp) || base != MAKE_FIXNUM(10)) {
+                if (Null(decimalp) || base != ecl_make_fixnum(10)) {
                         buffer = _ecl_ensure_buffer(buffer, 10);
-                        write_base_prefix(buffer, fix(base));
+                        write_base_prefix(buffer, ecl_fix(base));
                 }
                 buffer = si_integer_to_string(buffer, integer, base, Cnil, Cnil);
-                if (!Null(decimalp) && base == MAKE_FIXNUM(10)) {
+                if (!Null(decimalp) && base == ecl_make_fixnum(10)) {
                         _ecl_string_push_c_string(buffer, ".");
                 }
                 @(return buffer)
@@ -81,7 +81,7 @@ si_integer_to_string(cl_object buffer, cl_object integer,
         switch (type_of(integer)) {
         case t_fixnum: {
                 cl_object big = _ecl_big_register0();
-                _ecl_big_set_fixnum(big, fix(integer));
+                _ecl_big_set_fixnum(big, ecl_fix(integer));
                 buffer = bignum_to_string(buffer, big, base);
                 _ecl_big_register_free(big);
                 return buffer;
diff --git a/src/c/printer/write_array.d b/src/c/printer/write_array.d
index 260660beb..f885543ed 100644
--- a/src/c/printer/write_array.d
+++ b/src/c/printer/write_array.d
@@ -60,7 +60,7 @@ write_array_inner(bool vector, cl_object x, cl_object stream)
 		if (n > 0) {
 			ecl_write_char('(', stream);
 			for (j=0; j<n; j++) {
-				si_write_object(MAKE_FIXNUM(adims[j]), stream);
+				si_write_object(ecl_make_fixnum(adims[j]), stream);
 				if (j < n-1)
 					ecl_write_char(' ', stream);
 			}
@@ -76,7 +76,7 @@ write_array_inner(bool vector, cl_object x, cl_object stream)
 	if (print_level >= n) {
 		/* We can write the elements of the array */
 		print_level -= n;
-		ecl_bds_bind(env, @'*print-level*', MAKE_FIXNUM(print_level));
+		ecl_bds_bind(env, @'*print-level*', ecl_make_fixnum(print_level));
 	} else {
 		/* The elements of the array are not printed */
 		n = print_level;
diff --git a/src/c/printer/write_code.d b/src/c/printer/write_code.d
index d5a3e89c7..6818f8f50 100644
--- a/src/c/printer/write_code.d
+++ b/src/c/printer/write_code.d
@@ -27,7 +27,7 @@ _ecl_write_bytecodes(cl_object x, cl_object stream)
                 cl_object lex = Cnil;
                 cl_object code_l=Cnil;
                 for ( i=x->bytecodes.code_size-1 ; i<(cl_index)(-1l) ; i-- )
-                        code_l = ecl_cons(MAKE_FIXNUM(((cl_opcode*)(x->bytecodes.code))[i]), code_l);
+                        code_l = ecl_cons(ecl_make_fixnum(((cl_opcode*)(x->bytecodes.code))[i]), code_l);
                 writestr_stream("#Y", stream);
                 si_write_ugly_object(cl_list(7, x->bytecodes.name, lex,
                                              Cnil /* x->bytecodes.definition */,
diff --git a/src/c/printer/write_list.d b/src/c/printer/write_list.d
index d9f107274..b1fbe910d 100644
--- a/src/c/printer/write_list.d
+++ b/src/c/printer/write_list.d
@@ -87,7 +87,7 @@ _ecl_write_list(cl_object x, cl_object stream)
                 ecl_write_char('#', stream);
                 return;
         }
-        ecl_bds_bind(env, @'*print-level*', MAKE_FIXNUM(print_level-1));
+        ecl_bds_bind(env, @'*print-level*', ecl_make_fixnum(print_level-1));
         ecl_write_char('(', stream);
         for (i = 0;  ;  i++) {
                 if (i >= print_length) {
diff --git a/src/c/printer/write_object.d b/src/c/printer/write_object.d
index 16c1ac288..5f4640e04 100644
--- a/src/c/printer/write_object.d
+++ b/src/c/printer/write_object.d
@@ -25,7 +25,7 @@ _ecl_will_print_as_hash(cl_object x)
 	cl_object circle_counter = ecl_symbol_value(@'si::*circle-counter*');
 	cl_object circle_stack = ecl_symbol_value(@'si::*circle-stack*');
 	cl_object code = ecl_gethash_safe(x, circle_stack, OBJNULL);
-	if (FIXNUMP(circle_counter)) {
+	if (ECL_FIXNUMP(circle_counter)) {
 		return !(code == OBJNULL || code == Cnil);
 	} else if (code == OBJNULL) {
 		/* Was not found before */
@@ -51,7 +51,7 @@ search_print_circle(cl_object x)
 	cl_object circle_stack = ecl_symbol_value(@'si::*circle-stack*');
 	cl_object code;
 
-	if (!FIXNUMP(circle_counter)) {
+	if (!ECL_FIXNUMP(circle_counter)) {
 		code = ecl_gethash_safe(x, circle_stack, OBJNULL);
 		if (code == OBJNULL) {
 			/* Was not found before */
@@ -72,14 +72,14 @@ search_print_circle(cl_object x)
 			return 0;
 		} else if (code == Ct) {
 			/* This object is referenced twice, but has no code yet */
-			cl_fixnum new_code = fix(circle_counter) + 1;
-			circle_counter = MAKE_FIXNUM(new_code);
+			cl_fixnum new_code = ecl_fix(circle_counter) + 1;
+			circle_counter = ecl_make_fixnum(new_code);
 			_ecl_sethash(x, circle_stack, circle_counter);
 			ECL_SETQ(ecl_process_env(), @'si::*circle-counter*',
 				 circle_counter);
 			return -new_code;
 		} else {
-			return fix(code);
+			return ecl_fix(code);
 		}
 	}
 }
@@ -98,7 +98,7 @@ si_write_object(cl_object x, cl_object stream)
 	}
 #endif /* ECL_CMU_FORMAT */
 	circle = ecl_print_circle();
-	if (circle && !Null(x) && !FIXNUMP(x) && !CHARACTERP(x) &&
+	if (circle && !Null(x) && !ECL_FIXNUMP(x) && !ECL_CHARACTERP(x) &&
 	    (LISTP(x) || (x->d.t != t_symbol) || (Null(x->symbol.hpack))))
 	{
 		cl_object circle_counter;
@@ -108,20 +108,20 @@ si_write_object(cl_object x, cl_object stream)
 			cl_env_ptr env = ecl_process_env();
 			cl_object hash =
 				cl__make_hash_table(@'eq',
-						    MAKE_FIXNUM(1024),
+						    ecl_make_fixnum(1024),
                                                     cl_core.rehash_size,
                                                     cl_core.rehash_threshold);
 			ecl_bds_bind(env, @'si::*circle-counter*', Ct);
 			ecl_bds_bind(env, @'si::*circle-stack*', hash);
 			si_write_object(x, cl_core.null_stream);
-			ECL_SETQ(env, @'si::*circle-counter*', MAKE_FIXNUM(0));
+			ECL_SETQ(env, @'si::*circle-counter*', ecl_make_fixnum(0));
 			si_write_object(x, stream);
 			cl_clrhash(hash);
 			ecl_bds_unwind_n(env, 2);
 			goto OUTPUT;
 		}
 		code = search_print_circle(x);
-		if (!FIXNUMP(circle_counter)) {
+		if (!ECL_FIXNUMP(circle_counter)) {
 			/* We are only inspecting the object to be printed. */
 			/* Only run X if it was not referenced before */
 			if (code != 0)
diff --git a/src/c/printer/write_sse.d b/src/c/printer/write_sse.d
index dcc7919ec..64666e0c9 100644
--- a/src/c/printer/write_sse.d
+++ b/src/c/printer/write_sse.d
@@ -77,10 +77,10 @@ write_sse_pack(cl_object x, cl_object stream)
 		for (i = 0; i < 16; i++) {
                         ecl_string_push_extend(buffer, ' ');
                         if (i%4 == 0) ecl_string_push_extend(buffer, ' ');
-                        si_integer_to_string(buffer, MAKE_FIXNUM(x->sse.data.b8[i]),
-                                             MAKE_FIXNUM(16), Cnil, Cnil);
+                        si_integer_to_string(buffer, ecl_make_fixnum(x->sse.data.b8[i]),
+                                             ecl_make_fixnum(16), Cnil, Cnil);
 		}
-                si_do_write_sequence(buffer, stream, MAKE_FIXNUM(0), Cnil);
+                si_do_write_sequence(buffer, stream, ecl_make_fixnum(0), Cnil);
                 si_put_buffer_string(buffer);
                 break;
         }
diff --git a/src/c/printer/write_ugly.d b/src/c/printer/write_ugly.d
index b2bca4e75..f1904a66a 100644
--- a/src/c/printer/write_ugly.d
+++ b/src/c/printer/write_ugly.d
@@ -68,10 +68,10 @@ write_integer(cl_object number, cl_object stream)
         cl_object s = si_get_buffer_string();
         int print_base = ecl_print_base();
         si_integer_to_string(s, number,
-                             MAKE_FIXNUM(print_base),
+                             ecl_make_fixnum(print_base),
                              ecl_symbol_value(@'*print-radix*'),
                              Ct /* decimal syntax */);
-        si_do_write_sequence(s, stream, MAKE_FIXNUM(0), Cnil);
+        si_do_write_sequence(s, stream, ecl_make_fixnum(0), Cnil);
         si_put_buffer_string(s);
 }
 
@@ -79,8 +79,8 @@ void
 _ecl_write_fixnum(cl_fixnum i, cl_object stream)
 {
         cl_object s = si_get_buffer_string();
-        si_integer_to_string(s, MAKE_FIXNUM(i), MAKE_FIXNUM(10), Cnil, Cnil);
-        si_do_write_sequence(s, stream, MAKE_FIXNUM(0), Cnil);
+        si_integer_to_string(s, ecl_make_fixnum(i), ecl_make_fixnum(10), Cnil, Cnil);
+        si_do_write_sequence(s, stream, ecl_make_fixnum(0), Cnil);
         si_put_buffer_string(s);
 }
 
@@ -89,14 +89,14 @@ write_ratio(cl_object r, cl_object stream)
 {
         cl_object s = si_get_buffer_string();
         int print_base = ecl_print_base();
-        si_integer_to_string(s, r->ratio.num, MAKE_FIXNUM(print_base),
+        si_integer_to_string(s, r->ratio.num, ecl_make_fixnum(print_base),
                              ecl_symbol_value(@'*print-radix*'),
                              Cnil /* decimal syntax */);
         ecl_string_push_extend(s, '/');
         si_integer_to_string(s, r->ratio.den,
-                             MAKE_FIXNUM(print_base),
+                             ecl_make_fixnum(print_base),
                              Cnil, Cnil);
-        si_do_write_sequence(s, stream, MAKE_FIXNUM(0), Cnil);
+        si_do_write_sequence(s, stream, ecl_make_fixnum(0), Cnil);
         si_put_buffer_string(s);
 }
 
@@ -114,21 +114,21 @@ static void
 write_float(cl_object f, cl_object stream)
 {
         cl_object s = si_get_buffer_string();
-        s = si_float_to_string_free(s, f, MAKE_FIXNUM(-3), MAKE_FIXNUM(8));
-        si_do_write_sequence(s, stream, MAKE_FIXNUM(0), Cnil);
+        s = si_float_to_string_free(s, f, ecl_make_fixnum(-3), ecl_make_fixnum(8));
+        si_do_write_sequence(s, stream, ecl_make_fixnum(0), Cnil);
         si_put_buffer_string(s);
 }
 
 static void
 write_character(cl_object x, cl_object stream)
 {
-        int i = CHAR_CODE(x);
+        int i = ECL_CHAR_CODE(x);
 	if (!ecl_print_escape() && !ecl_print_readably()) {
 		ecl_write_char(i, stream);
 	} else {
 		writestr_stream("#\\", stream);
 		if (i < 32 || i >= 127) {
-			cl_object name = cl_char_name(CODE_CHAR(i));
+			cl_object name = cl_char_name(ECL_CODE_CHAR(i));
 			writestr_stream((char*)name->base_string.self, stream);
 		} else {
 			ecl_write_char(i, stream);
@@ -323,7 +323,7 @@ write_structure(cl_object x, cl_object stream)
                 x = structure_to_list(x);
                 si_write_object(x, stream);
         } else {
-                _ecl_funcall4(print_function, x, stream, MAKE_FIXNUM(0));
+                _ecl_funcall4(print_function, x, stream, ecl_make_fixnum(0));
         }
 }
 #endif /* !CLOS */
@@ -361,7 +361,7 @@ write_foreign(cl_object x, cl_object stream)
 static void
 write_frame(cl_object x, cl_object stream)
 {
-        _ecl_write_unreadable(x, "frame", MAKE_FIXNUM(x->frame.size), stream);
+        _ecl_write_unreadable(x, "frame", ecl_make_fixnum(x->frame.size), stream);
 }
 
 static void
diff --git a/src/c/read.d b/src/c/read.d
index cfb070484..28aa84fd5 100644
--- a/src/c/read.d
+++ b/src/c/read.d
@@ -114,7 +114,7 @@ ecl_read_object_non_recursive(cl_object in)
 	const cl_env_ptr env = ecl_process_env();
 
 	ecl_bds_bind(env, @'si::*sharp-eq-context*', Cnil);
-	ecl_bds_bind(env, @'si::*backq-level*', MAKE_FIXNUM(0));
+	ecl_bds_bind(env, @'si::*backq-level*', ecl_make_fixnum(0));
 	x = ecl_read_object(in);
 	if (!Null(ECL_SYM_VAL(env, @'si::*sharp-eq-context*')))
 		x = patch_sharp(x);
@@ -137,8 +137,8 @@ invert_buffer_case(cl_object x, cl_object escape_list, int sign)
 	do {
 		if (escape_list != Cnil) {
 			cl_object escape_interval = CAR(escape_list);
-			high_limit = fix(CAR(escape_interval));
-			low_limit = fix(CDR(escape_interval));
+			high_limit = ecl_fix(CAR(escape_interval));
+			low_limit = ecl_fix(CDR(escape_interval));
 			escape_list = CDR(escape_list);
 		} else {
 			high_limit = low_limit = -1;
@@ -198,7 +198,7 @@ BEGIN:
 		if (ECL_HASH_TABLE_P(x)) {
 			o = dispatch_macro_character(x, in, c);
 		} else {
-			o = _ecl_funcall3(x, in, CODE_CHAR(c));
+			o = _ecl_funcall3(x, in, ECL_CODE_CHAR(c));
 		}
 		if (the_env->nvalues == 0) {
                         if (flags == ECL_READ_RETURN_IGNORABLE)
@@ -207,7 +207,7 @@ BEGIN:
                 }
 		unlikely_if (the_env->nvalues > 1) {
                         FEerror("The readmacro ~S returned ~D values.",
-                                2, x, MAKE_FIXNUM(the_env->nvalues));
+                                2, x, ecl_make_fixnum(the_env->nvalues));
                 }
 		return o;
 	}
@@ -266,8 +266,8 @@ LOOP:
 			c = ecl_read_char_noeof(in);
 			a = cat_constituent;
 			if (read_case == ecl_case_invert) {
-				escape_list = CONS(CONS(MAKE_FIXNUM(length),
-							MAKE_FIXNUM(length)),
+				escape_list = CONS(CONS(ecl_make_fixnum(length),
+							ecl_make_fixnum(length)),
 						   escape_list);
 			} else {
 				escape_list = Ct;
@@ -290,8 +290,8 @@ LOOP:
 				length++;
 			}
 			if (read_case == ecl_case_invert) {
-				escape_list = CONS(CONS(MAKE_FIXNUM(begin),
-							MAKE_FIXNUM(length-1)),
+				escape_list = CONS(CONS(ecl_make_fixnum(begin),
+							ecl_make_fixnum(length-1)),
 						   escape_list);
 			} else {
 				escape_list = Ct;
@@ -304,7 +304,7 @@ LOOP:
 		}
 		unlikely_if (ecl_invalid_character_p(c)) {
 			FEreader_error("Found invalid character ~:C", in,
-                                       1, CODE_CHAR(c));
+                                       1, ECL_CODE_CHAR(c));
 		}
 		if (read_case != ecl_case_preserve) {
 			if (ecl_upper_case_p(c)) {
@@ -410,7 +410,7 @@ si_read_object_or_ignore(cl_object in, cl_object eof)
 	const cl_env_ptr env = ecl_process_env();
 
 	ecl_bds_bind(env, @'si::*sharp-eq-context*', Cnil);
-	ecl_bds_bind(env, @'si::*backq-level*', MAKE_FIXNUM(0));
+	ecl_bds_bind(env, @'si::*backq-level*', ecl_make_fixnum(0));
         x = ecl_read_object_with_delimiter(in, EOF, ECL_READ_RETURN_IGNORABLE, 
                                            cat_constituent);
         if (x == OBJNULL) {
@@ -446,24 +446,24 @@ cl_object comma_reader(cl_object in, cl_object c)
 {
 	cl_object x, y;
 	const cl_env_ptr env = ecl_process_env();
-	cl_fixnum backq_level = fix(ECL_SYM_VAL(env, @'si::*backq-level*'));
+	cl_fixnum backq_level = ecl_fix(ECL_SYM_VAL(env, @'si::*backq-level*'));
 
 	unlikely_if (backq_level <= 0)
 		FEreader_error("A comma has appeared out of a backquote.", in, 0);
 	/* Read character & complain at EOF */
 	c = cl_peek_char(2,Cnil,in);
-	if (c == CODE_CHAR('@@')) {
+	if (c == ECL_CODE_CHAR('@@')) {
 		x = @'si::unquote-splice';
 		ecl_read_char(in);
-	} else if (c == CODE_CHAR('.')) {
+	} else if (c == ECL_CODE_CHAR('.')) {
 		x = @'si::unquote-nsplice';
 		ecl_read_char(in);
 	} else {
 		x = @'si::unquote';
 	}
-	ECL_SETQ(env, @'si::*backq-level*', MAKE_FIXNUM(backq_level-1));
+	ECL_SETQ(env, @'si::*backq-level*', ecl_make_fixnum(backq_level-1));
 	y = ecl_read_object(in);
-	ECL_SETQ(env, @'si::*backq-level*', MAKE_FIXNUM(backq_level));
+	ECL_SETQ(env, @'si::*backq-level*', ecl_make_fixnum(backq_level));
 	return cl_list(2, x, y);
 }
 
@@ -471,10 +471,10 @@ static
 cl_object backquote_reader(cl_object in, cl_object c)
 {
 	const cl_env_ptr the_env = ecl_process_env();
-	cl_fixnum backq_level = fix(ECL_SYM_VAL(the_env, @'si::*backq-level*'));
-	ECL_SETQ(the_env, @'si::*backq-level*', MAKE_FIXNUM(backq_level+1));
+	cl_fixnum backq_level = ecl_fix(ECL_SYM_VAL(the_env, @'si::*backq-level*'));
+	ECL_SETQ(the_env, @'si::*backq-level*', ecl_make_fixnum(backq_level+1));
 	in = ecl_read_object(in);
-	ECL_SETQ(the_env, @'si::*backq-level*', MAKE_FIXNUM(backq_level));
+	ECL_SETQ(the_env, @'si::*backq-level*', ecl_make_fixnum(backq_level));
 #if 0
 	@(return cl_macroexpand_1(2, cl_list(2, @'si::quasiquote', in), Cnil));
 #else
@@ -519,7 +519,7 @@ read_constituent(cl_object in)
 static cl_object
 double_quote_reader(cl_object in, cl_object c)
 {
-	int delim = CHAR_CODE(c);
+	int delim = ECL_CHAR_CODE(c);
 	cl_object rtbl = ecl_current_readtable();
 	cl_object token = si_get_buffer_string();
 	cl_object output;
@@ -568,12 +568,12 @@ dispatch_macro_character(cl_object table, cl_object in, int c)
 			c = ecl_read_char_noeof(in);
 			d = ecl_digitp(c, 10);
 		} while (d >= 0);
-		arg = MAKE_FIXNUM(i);
+		arg = ecl_make_fixnum(i);
 	} else {
 		arg = Cnil;
 	}
 	{
-		cl_object dc = CODE_CHAR(c);
+		cl_object dc = ECL_CODE_CHAR(c);
 		cl_object fun = ecl_gethash_safe(dc, table, Cnil);
 		unlikely_if (Null(fun)) {
 			FEreader_error("No dispatch function defined "
@@ -655,7 +655,7 @@ sharp_backslash_reader(cl_object in, cl_object c, cl_object d)
 	const cl_env_ptr the_env = ecl_process_env();
 	cl_object token;
 	if (d != Cnil && !read_suppress) {
-		unlikely_if (!FIXNUMP(d) || d != MAKE_FIXNUM(0)) {
+		unlikely_if (!ECL_FIXNUMP(d) || d != ecl_make_fixnum(0)) {
 			FEreader_error("~S is an illegal CHAR-FONT.", in, 1, d);
                 }
         }
@@ -664,10 +664,10 @@ sharp_backslash_reader(cl_object in, cl_object c, cl_object d)
 	if (token == Cnil) {
 		c = Cnil;
 	} else if (TOKEN_STRING_FILLP(token) == 1) {
-		c = CODE_CHAR(TOKEN_STRING_CHAR(token,0));
+		c = ECL_CODE_CHAR(TOKEN_STRING_CHAR(token,0));
 	} else if (TOKEN_STRING_FILLP(token) == 2 && TOKEN_STRING_CHAR_CMP(token,0,'^')) {
 		/*	#\^x	*/
-		c = CODE_CHAR(TOKEN_STRING_CHAR(token,1) & 037);
+		c = ECL_CODE_CHAR(TOKEN_STRING_CHAR(token,1) & 037);
 	} else {
 		cl_object nc = cl_name_char(token);
 		unlikely_if (Null(nc)) {
@@ -755,7 +755,7 @@ sharp_Y_reader(cl_object in, cl_object c, cl_object d)
         }
         rv->bytecodes.file = nth;
         if (ECL_ATOM(x)) {
-                nth = MAKE_FIXNUM(0);
+                nth = ecl_make_fixnum(0);
         } else {
                 nth = ECL_CONS_CAR(x);
                 x = ECL_CONS_CDR(x);
@@ -786,7 +786,7 @@ sharp_left_parenthesis_reader(cl_object in, cl_object c, cl_object d)
 	extern int _cl_backq_car(cl_object *);
 	const cl_env_ptr the_env = ecl_process_env();
 	cl_object v;
-	if (fix(ECL_SYM_VAL(the_env, @'si::*backq-level*')) > 0) {
+	if (ecl_fix(ECL_SYM_VAL(the_env, @'si::*backq-level*')) > 0) {
 		/* First case: ther might be unquoted elements in the vector.
 		 * Then we just create a form that generates the vector.
 		 */
@@ -820,7 +820,7 @@ sharp_left_parenthesis_reader(cl_object in, cl_object c, cl_object d)
 		   be smaller, and in that case...*/
 		cl_object last;
 		cl_index dim, i;
-                unlikely_if (!ECL_FIXNUMP(d) || ((dim = fix(d)) < 0) ||
+                unlikely_if (!ECL_FIXNUMP(d) || ((dim = ecl_fix(d)) < 0) ||
                              (dim > ADIMLIM)) {
                         FEreader_error("Invalid dimension size ~D in #()", in, 1, d);
                 }
@@ -871,14 +871,14 @@ sharp_asterisk_reader(cl_object in, cl_object c, cl_object d)
                              (x != '0' && x != '1'))
 		{
 			FEreader_error("Character ~:C is not allowed after #*",
-				       in, 1, CODE_CHAR(x));
+				       in, 1, ECL_CODE_CHAR(x));
 		}
-		ECL_STACK_PUSH(env, MAKE_FIXNUM(x == '1'));
+		ECL_STACK_PUSH(env, ecl_make_fixnum(x == '1'));
 	}
 	if (Null(d)) {
 		dim = dimcount;
 	} else {
-                unlikely_if (!ECL_FIXNUMP(d) || ((dim = fix(d)) < 0) ||
+                unlikely_if (!ECL_FIXNUMP(d) || ((dim = ecl_fix(d)) < 0) ||
                              (dim > ADIMLIM))
                 {
                         FEreader_error("Wrong vector dimension size ~D in #*.",
@@ -893,7 +893,7 @@ sharp_asterisk_reader(cl_object in, cl_object c, cl_object d)
 	x = ecl_alloc_simple_vector(dim, aet_bit);
 	for (i = 0; i < dim; i++) {
 		elt = (i < dimcount) ? env->stack[sp+i] : last;
-		if (elt == MAKE_FIXNUM(0))
+		if (elt == ecl_make_fixnum(0))
 			x->vector.self.bit[i/CHAR_BIT] &= ~(0200 >> i%CHAR_BIT);
 		else
 			x->vector.self.bit[i/CHAR_BIT] |= 0200 >> i%CHAR_BIT;
@@ -1009,7 +1009,7 @@ sharp_B_reader(cl_object in, cl_object c, cl_object d)
 {
 	if(d != Cnil && !read_suppress)
 		extra_argument('B', in, d);
-	@(return (read_number(in, 2, CODE_CHAR('B'))))
+	@(return (read_number(in, 2, ECL_CODE_CHAR('B'))))
 }
 
 static cl_object
@@ -1017,7 +1017,7 @@ sharp_O_reader(cl_object in, cl_object c, cl_object d)
 {
 	if(d != Cnil && !read_suppress)
 		extra_argument('O', in, d);
-	@(return (read_number(in, 8, CODE_CHAR('O'))))
+	@(return (read_number(in, 8, ECL_CODE_CHAR('O'))))
 }
 
 static cl_object
@@ -1025,7 +1025,7 @@ sharp_X_reader(cl_object in, cl_object c, cl_object d)
 {
 	if(d != Cnil && !read_suppress)
 		extra_argument('X', in, d);
-	@(return (read_number(in, 16, CODE_CHAR('X'))))
+	@(return (read_number(in, 16, ECL_CODE_CHAR('X'))))
 }
 
 static cl_object
@@ -1034,15 +1034,15 @@ sharp_R_reader(cl_object in, cl_object c, cl_object d)
 	int radix;
 	if (read_suppress) {
 		radix = 10;
-        } else unlikely_if (!FIXNUMP(d)) {
+        } else unlikely_if (!ECL_FIXNUMP(d)) {
 		FEreader_error("No radix was supplied in the #R readmacro.", in, 0);
         } else {
-		radix = fix(d);
+		radix = ecl_fix(d);
 		unlikely_if (radix > 36 || radix < 2) {
 			FEreader_error("~S is an illegal radix.", in, 1, d);
                 }
 	}
-	@(return (read_number(in, radix, CODE_CHAR('R'))))
+	@(return (read_number(in, radix, ECL_CODE_CHAR('R'))))
 }
 
 #define sharp_A_reader void_reader
@@ -1259,7 +1259,7 @@ patch_sharp(cl_object x)
 	const cl_env_ptr the_env = ecl_process_env();
 	cl_object pairs;
         cl_object table = 
-                cl__make_hash_table(@'eq', MAKE_FIXNUM(20), /* size */
+                cl__make_hash_table(@'eq', ecl_make_fixnum(20), /* size */
                                     cl_core.rehash_size,
                                     cl_core.rehash_threshold);
 
@@ -1428,9 +1428,9 @@ ecl_current_read_base(void)
 	cl_object x = ECL_SYM_VAL(the_env, @'*read-base*');
         cl_fixnum b;
 
-        unlikely_if (!ECL_FIXNUMP(x) || ((b = fix(x)) < 2) || (b > 36))
+        unlikely_if (!ECL_FIXNUMP(x) || ((b = ecl_fix(x)) < 2) || (b > 36))
         {
-                ECL_SETQ(the_env, @'*read-base*', MAKE_FIXNUM(10));
+                ECL_SETQ(the_env, @'*read-base*', ecl_make_fixnum(10));
                 FEerror("The value of *READ-BASE*~&  ~S~%"
                         "is not in the range (INTEGER 2 36)", 1, x);
         }
@@ -1571,7 +1571,7 @@ do_read_delimited_list(int d, cl_object in, bool proper_list)
 		l = do_read_delimited_list(delimiter, strm, 1);
 	} else {
 		ecl_bds_bind(the_env, @'si::*sharp-eq-context*', Cnil);
-		ecl_bds_bind(the_env, @'si::*backq-level*', MAKE_FIXNUM(0));
+		ecl_bds_bind(the_env, @'si::*backq-level*', ecl_make_fixnum(0));
 		l = do_read_delimited_list(delimiter, strm, 1);
 		if (!Null(ECL_SYM_VAL(the_env, @'si::*sharp-eq-context*')))
 			l = patch_sharp(l);
@@ -1634,7 +1634,7 @@ do_read_delimited_list(int d, cl_object in, bool proper_list)
 	strm = stream_or_default_input(strm);
 	c = ecl_read_char(strm);
 	if (c != EOF)
-		output = CODE_CHAR(c);
+		output = ECL_CODE_CHAR(c);
 	else if (Null(eof_errorp))
 		output = eof_value;
 	else
@@ -1671,7 +1671,7 @@ do_read_delimited_list(int d, cl_object in, bool proper_list)
 			do {
 				/* If the character belongs to the given class,
 				 * we're done. */
-				if (ecl_char_eq(CODE_CHAR(c), peek_type))
+				if (ecl_char_eq(ECL_CODE_CHAR(c), peek_type))
 					break;
 				/* Otherwise, consume the character and
 				 * peek the next one. */
@@ -1681,7 +1681,7 @@ do_read_delimited_list(int d, cl_object in, bool proper_list)
 		}
 	}
 	if (c != EOF) {
-		eof_value = CODE_CHAR(c);
+		eof_value = ECL_CODE_CHAR(c);
 	} else if (!Null(eof_errorp)) {
 		FEend_of_file(strm);
 	}
@@ -1711,7 +1711,7 @@ do_read_delimited_list(int d, cl_object in, bool proper_list)
 	if (f == ECL_LISTEN_AVAILABLE) {
 		int c = ecl_read_char(strm);
 		if (c != EOF) {
-			@(return CODE_CHAR(c));
+			@(return ECL_CODE_CHAR(c));
 		}
 	} else if (f == ECL_LISTEN_NO_CHAR) {
 		@(return @'nil');
@@ -1744,7 +1744,7 @@ do_read_delimited_list(int d, cl_object in, bool proper_list)
 	@(return c)
 @)
 
-@(defun read_sequence (sequence stream &key (start MAKE_FIXNUM(0)) end)
+@(defun read_sequence (sequence stream &key (start ecl_make_fixnum(0)) end)
 @
 #ifdef ECL_CLOS_STREAMS
 	if (!ECL_ANSI_STREAM_P(stream))
@@ -1827,9 +1827,9 @@ ecl_readtable_get(cl_object readtable, int c, cl_object *macro_or_table)
 		cat = cat_constituent;
 		m = Cnil;
 		if (!Null(hash)) {
-			cl_object pair = ecl_gethash_safe(CODE_CHAR(c), hash, Cnil);
+			cl_object pair = ecl_gethash_safe(ECL_CODE_CHAR(c), hash, Cnil);
 			if (!Null(pair)) {
-				cat = fix(ECL_CONS_CAR(pair));
+				cat = ecl_fix(ECL_CONS_CAR(pair));
 				m = ECL_CONS_CDR(pair);
 			}
 		}
@@ -1854,13 +1854,13 @@ ecl_readtable_set(cl_object readtable, int c, enum ecl_chattrib cat,
 	if (c >= RTABSIZE) {
 		cl_object hash = readtable->readtable.hash;
 		if (Null(hash)) {
-			hash = cl__make_hash_table(@'eql', MAKE_FIXNUM(128),
+			hash = cl__make_hash_table(@'eql', ecl_make_fixnum(128),
                                                    cl_core.rehash_size,
                                                    cl_core.rehash_threshold);
 			readtable->readtable.hash = hash;
 		}
-		_ecl_sethash(CODE_CHAR(c), hash,
-			    CONS(MAKE_FIXNUM(cat), macro_or_table));
+		_ecl_sethash(ECL_CODE_CHAR(c), hash,
+			    CONS(ecl_make_fixnum(cat), macro_or_table));
 	} else
 #endif
 	{
@@ -1932,7 +1932,7 @@ ecl_invalid_character_p(int c)
         assert_type_readtable(@[make-dispatch-macro-character], 3, readtable);
 	c = ecl_char_code(chr);
 	cat = Null(non_terminating_p)? cat_terminating : cat_non_terminating;
-	table = cl__make_hash_table(@'eql', MAKE_FIXNUM(128),
+	table = cl__make_hash_table(@'eql', ecl_make_fixnum(128),
                                     cl_core.rehash_size,
                                     cl_core.rehash_threshold);
 	ecl_readtable_set(readtable, c, cat, table);
@@ -1954,9 +1954,9 @@ ecl_invalid_character_p(int c)
 	}
 	subcode = ecl_char_code(subchr);
 	if (Null(fnc)) {
-		ecl_remhash(CODE_CHAR(subcode), table);
+		ecl_remhash(ECL_CODE_CHAR(subcode), table);
 	} else {
-		_ecl_sethash(CODE_CHAR(subcode), table, fnc);
+		_ecl_sethash(ECL_CODE_CHAR(subcode), table, fnc);
 	}
 	if (ecl_lower_case_p(subcode)) {
 		subcode = ecl_char_upcase(subcode);
@@ -1964,9 +1964,9 @@ ecl_invalid_character_p(int c)
 		subcode = ecl_char_downcase(subcode);
 	}
 	if (Null(fnc)) {
-		ecl_remhash(CODE_CHAR(subcode), table);
+		ecl_remhash(ECL_CODE_CHAR(subcode), table);
 	} else {
-		_ecl_sethash(CODE_CHAR(subcode), table, fnc);
+		_ecl_sethash(ECL_CODE_CHAR(subcode), table, fnc);
 	}
 	@(return Ct)
 @)
@@ -2015,7 +2015,7 @@ static void
 extra_argument(int c, cl_object stream, cl_object d)
 {
 	FEreader_error("~S is an extra argument for the #~C readmacro.",
-		       stream, 2, d, CODE_CHAR(c));
+		       stream, 2, d, ECL_CODE_CHAR(c));
 }
 
 
@@ -2071,54 +2071,54 @@ init_read(void)
 
 	cl_core.default_dispatch_macro = make_cf3(default_dispatch_macro_fun);
 
-	cl_make_dispatch_macro_character(3, CODE_CHAR('#'),
+	cl_make_dispatch_macro_character(3, ECL_CODE_CHAR('#'),
 					 Ct /* non terminating */, r);
 
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('C'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('C'),
 					make_cf3(sharp_C_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('\\'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('\\'),
 					make_cf3(sharp_backslash_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('\''),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('\''),
 					make_cf3(sharp_single_quote_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('('),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('('),
 					make_cf3(sharp_left_parenthesis_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('*'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('*'),
 					make_cf3(sharp_asterisk_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR(':'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR(':'),
 					make_cf3(sharp_colon_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('.'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('.'),
 					make_cf3(sharp_dot_reader), r);
 	/*  Used for fasload only. */
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('B'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('B'),
 					make_cf3(sharp_B_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('O'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('O'),
 					make_cf3(sharp_O_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('X'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('X'),
 					make_cf3(sharp_X_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('R'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('R'),
 					make_cf3(sharp_R_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('A'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('A'),
 					@'si::sharp-a-reader', r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('S'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('S'),
 					@'si::sharp-s-reader', r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('P'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('P'),
 					make_cf3(sharp_P_reader), r);
 
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('='),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('='),
 					make_cf3(sharp_eq_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('#'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('#'),
 					make_cf3(sharp_sharp_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('+'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('+'),
 					make_cf3(sharp_plus_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('-'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('-'),
 					make_cf3(sharp_minus_reader), r);
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('|'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('|'),
 					make_cf3(sharp_vertical_bar_reader), r);
 	/*  This is specific to this implementation  */
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('$'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('$'),
 					make_cf3(sharp_dollar_reader), r);
 	/*  This is specific to this implementation  */
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('Y'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('Y'),
 					make_cf3(sharp_Y_reader), r);
 	/*  This is specific to this implementation: ignore BOM  */
 #ifdef ECL_UNICODE
@@ -2133,7 +2133,7 @@ init_read(void)
 
 	ECL_SET(@'*readtable*',
 		r=ecl_copy_readtable(cl_core.standard_readtable, Cnil));
-	cl_set_dispatch_macro_character(4, CODE_CHAR('#'), CODE_CHAR('!'),
+	cl_set_dispatch_macro_character(4, ECL_CODE_CHAR('#'), ECL_CODE_CHAR('!'),
 					Cnil, r);
 	ECL_SET(@'*read-default-float-format*', @'single-float');
 
@@ -2167,7 +2167,7 @@ init_read(void)
                 val = cl_list(24,
                               /**pprint-dispatch-table**/ Cnil,
                               /**print-array**/ Ct,
-                              /**print-base**/ MAKE_FIXNUM(10),
+                              /**print-base**/ ecl_make_fixnum(10),
                               /**print-case**/ @':downcase',
                               /**print-circle**/ Ct,
                               /**print-escape**/ Ct,
@@ -2180,7 +2180,7 @@ init_read(void)
                               /**print-radix**/ Cnil,
                               /**print-readably**/ Ct,
                               /**print-right-margin**/ Cnil,
-                              /**read-base**/ MAKE_FIXNUM(10),
+                              /**read-base**/ ecl_make_fixnum(10),
                               /**read-default-float-format**/ @'single-float',
                               /**read-eval**/ Ct,
                               /**read-suppress**/ Cnil,
@@ -2217,7 +2217,7 @@ init_read(void)
                 val = cl_list(23,
                               /**pprint-dispatch-table**/ Cnil,
                               /**print-array**/ Ct,
-                              /**print-base**/ MAKE_FIXNUM(10),
+                              /**print-base**/ ecl_make_fixnum(10),
                               /**print-case**/ @':upcase',
                               /**print-circle**/ Cnil,
                               /**print-escape**/ Ct,
@@ -2230,7 +2230,7 @@ init_read(void)
                               /**print-radix**/ Cnil,
                               /**print-readably**/ Ct,
                               /**print-right-margin**/ Cnil,
-                              /**read-base**/ MAKE_FIXNUM(10),
+                              /**read-base**/ ecl_make_fixnum(10),
                               /**read-default-float-format**/ @'single-float',
                               /**read-eval**/ Ct,
                               /**read-suppress**/ Cnil,
@@ -2362,9 +2362,9 @@ ecl_init_module(cl_object block, void (*entry_point)(cl_object))
 
 		for (i = 0; i < block->cblock.cfuns_size; i++) {
 			const struct ecl_cfun *prototype = block->cblock.cfuns+i;
-			cl_index fname_location = fix(prototype->block);
+			cl_index fname_location = ecl_fix(prototype->block);
 			cl_object fname = VV[fname_location];
-			cl_index location = fix(prototype->name);
+			cl_index location = ecl_fix(prototype->name);
                         cl_object position = prototype->file_position;
 			int narg = prototype->narg;
 			VV[location] = narg<0?
@@ -2373,7 +2373,7 @@ ecl_init_module(cl_object block, void (*entry_point)(cl_object))
 				ecl_make_cfun((cl_objectfn_fixed)prototype->entry,
                                               fname, block, narg);
                         /* Add source file info */
-                        if (position != MAKE_FIXNUM(-1)) {
+                        if (position != ecl_make_fixnum(-1)) {
                                 ecl_set_function_source_file_info(VV[location],
                                                                   block->cblock.source,
                                                                   position);
diff --git a/src/c/reader/parse_integer.d b/src/c/reader/parse_integer.d
index 063911a82..47eb9b0d5 100644
--- a/src/c/reader/parse_integer.d
+++ b/src/c/reader/parse_integer.d
@@ -58,9 +58,9 @@ ecl_parse_integer(cl_object str, cl_index start, cl_index end,
 }
 
 @(defun parse_integer (strng
-		       &key (start MAKE_FIXNUM(0))
+		       &key (start ecl_make_fixnum(0))
 			    end
-			    (radix MAKE_FIXNUM(10))
+			    (radix ecl_make_fixnum(10))
 			    junk_allowed
 		       &aux x)
 	cl_index s, e, ep;
@@ -69,9 +69,9 @@ ecl_parse_integer(cl_object str, cl_index start, cl_index end,
         unlikely_if (!ECL_STRINGP(strng)) {
                 FEwrong_type_nth_arg(@[parse-integer], 1, strng, @[string]);
         }
-	unlikely_if (!FIXNUMP(radix) ||
-                     ecl_fixnum_lower(radix, MAKE_FIXNUM(2)) ||
-                     ecl_fixnum_greater(radix, MAKE_FIXNUM(36)))
+	unlikely_if (!ECL_FIXNUMP(radix) ||
+                     ecl_fixnum_lower(radix, ecl_make_fixnum(2)) ||
+                     ecl_fixnum_greater(radix, ecl_make_fixnum(36)))
         {
 		FEerror("~S is an illegal radix.", 1, radix);
         }
@@ -87,20 +87,20 @@ ecl_parse_integer(cl_object str, cl_index start, cl_index end,
 	}
 	if (s >= e) {
 		if (junk_allowed != Cnil)
-			@(return Cnil MAKE_FIXNUM(s))
+			@(return Cnil ecl_make_fixnum(s))
 		else
 			goto CANNOT_PARSE;
 	}
-	x = ecl_parse_integer(strng, s, e, &ep, fix(radix));
+	x = ecl_parse_integer(strng, s, e, &ep, ecl_fix(radix));
 	if (x == OBJNULL) {
 		if (junk_allowed != Cnil) {
-			@(return Cnil MAKE_FIXNUM(ep));
+			@(return Cnil ecl_make_fixnum(ep));
 		} else {
 			goto CANNOT_PARSE;
 		}
 	}
 	if (junk_allowed != Cnil) {
-		@(return x MAKE_FIXNUM(ep));
+		@(return x ecl_make_fixnum(ep));
 	}
 	for (s = ep; s < e; s++) {
 		unlikely_if (ecl_readtable_get(rtbl, ecl_char(strng, s), NULL)
@@ -110,5 +110,5 @@ CANNOT_PARSE:		FEparse_error("Cannot parse an integer in the string ~S.",
 				      Cnil, 1, strng);
 		}
 	}
-	@(return x MAKE_FIXNUM(e));
+	@(return x ecl_make_fixnum(e));
 } @)
diff --git a/src/c/reader/parse_number.d b/src/c/reader/parse_number.d
index 941a66742..7e513a13d 100644
--- a/src/c/reader/parse_number.d
+++ b/src/c/reader/parse_number.d
@@ -73,10 +73,10 @@ infinity(cl_index exp_char, int sign)
 static cl_object
 make_float(cl_object num, cl_object exp, cl_index exp_char, int sign)
 {
-        if (!FIXNUMP(exp)) {
+        if (!ECL_FIXNUMP(exp)) {
                 return infinity(exp_char, sign);
         } else {
-                cl_fixnum fix_exp = fix(exp);
+                cl_fixnum fix_exp = ecl_fix(exp);
                 if (fix_exp > 0) {
                         num = ecl_times(num, expt10(fix_exp));
                 } else if (fix_exp < 0) {
@@ -152,7 +152,7 @@ ecl_parse_number(cl_object str, cl_index start, cl_index end,
                         den = ecl_parse_integer(str, i, end, ep, radix);
                         if (den == OBJNULL || (*ep < end)) {
                                 return OBJNULL;
-                        } else if (den == MAKE_FIXNUM(0)) {
+                        } else if (den == ecl_make_fixnum(0)) {
                                 return Cnil;
                         } else {
                                 return ecl_make_ratio(num, den);
@@ -184,8 +184,8 @@ ecl_parse_number(cl_object str, cl_index start, cl_index end,
                         }
                         num = _ecl_big_register_normalize(num);
                         decimals = (decimal < i) ?
-                                MAKE_FIXNUM(decimal - i):
-                                MAKE_FIXNUM(0);
+                                ecl_make_fixnum(decimal - i):
+                                ecl_make_fixnum(0);
                         exp = ecl_parse_integer(str, ++i, end, ep, 10);
                         if (exp == OBJNULL || (*ep < end))
                                 return OBJNULL;
@@ -217,7 +217,7 @@ ecl_parse_number(cl_object str, cl_index start, cl_index end,
         if (decimal < i) {
                 if (!some_digit) goto NOT_A_NUMBER;
                 return make_float(_ecl_big_register_normalize(num),
-                                  MAKE_FIXNUM(decimal - i), 'e', sign);
+                                  ecl_make_fixnum(decimal - i), 'e', sign);
         } else {
                 if (sign < 0) _ecl_big_complement(num, num);
                 return _ecl_big_register_normalize(num);
diff --git a/src/c/sequence.d b/src/c/sequence.d
index 02e371fda..f2131b39f 100644
--- a/src/c/sequence.d
+++ b/src/c/sequence.d
@@ -30,25 +30,25 @@ ecl_sequence_start_end(cl_object fun, cl_object sequence,
 	unlikely_if (!ECL_FIXNUMP(start) || ecl_fixnum_minusp(start)) {
                 FEwrong_type_key_arg(fun, @[:start], start, @[unsigned-byte]);
         }
-        p.start = fix(start);
+        p.start = ecl_fix(start);
 	if (Null(end)) {
 		p.end = l;
 	} else {
-                unlikely_if (!FIXNUMP(end) || ecl_fixnum_minusp(end)) {
+                unlikely_if (!ECL_FIXNUMP(end) || ecl_fixnum_minusp(end)) {
                         FEwrong_type_key_arg(fun, @[:end], end,
                                              ecl_read_from_cstring("(OR NULL UNSIGNED-BYTE)"));
                 }
-		p.end = fix(end);
+		p.end = ecl_fix(end);
 		unlikely_if (p.end > l) {
-                        cl_object fillp = MAKE_FIXNUM(l);
+                        cl_object fillp = ecl_make_fixnum(l);
                         FEwrong_type_key_arg(fun, @[:end], end,
                                              ecl_make_integer_type(start, fillp));
                 }
 	}
         unlikely_if (p.end < p.start) {
                 FEwrong_type_key_arg(fun, @[:start], start,
-                                     ecl_make_integer_type(MAKE_FIXNUM(0),
-							   MAKE_FIXNUM(p.end)));
+                                     ecl_make_integer_type(ecl_make_fixnum(0),
+							   ecl_make_fixnum(p.end)));
         }
         return p;
 }
@@ -57,8 +57,8 @@ cl_object
 si_sequence_start_end(cl_object fun, cl_object sequence, cl_object start, cl_object end)
 {
 	cl_index_pair p = ecl_sequence_start_end(fun, sequence, start, end);
-	@(return MAKE_FIXNUM(p.start) MAKE_FIXNUM(p.end)
-          MAKE_FIXNUM(p.length));
+	@(return ecl_make_fixnum(p.start) ecl_make_fixnum(p.end)
+          ecl_make_fixnum(p.length));
 }
 
 cl_object
@@ -209,7 +209,7 @@ cl_copy_seq(cl_object x)
 cl_object
 cl_length(cl_object x)
 {
-	@(return MAKE_FIXNUM(ecl_length(x)))
+	@(return ecl_make_fixnum(ecl_length(x)))
 }
 
 cl_fixnum
diff --git a/src/c/serialize.d b/src/c/serialize.d
index 8219eddb4..2157e9a95 100644
--- a/src/c/serialize.d
+++ b/src/c/serialize.d
@@ -19,12 +19,12 @@
 #include <ecl/internal.h>
 
 struct fake_package {
-        HEADER;
+        _ECL_HDR;
         cl_object name;
 };
 
 struct fake_symbol {
-        HEADER;
+        _ECL_HDR;
         cl_object name;
         cl_object pack;
 };
@@ -104,7 +104,7 @@ alloc(pool_t pool, cl_index size)
         if (next_fillp >= pool->data->vector.dim) {
                 cl_index new_dim = next_fillp + next_fillp / 2;
                 pool->data = _ecl_funcall3(@'adjust-array', pool->data,
-					   MAKE_FIXNUM(new_dim));
+					   ecl_make_fixnum(new_dim));
         }
         pool->data->vector.fillp = next_fillp;
         return fillp;
@@ -114,14 +114,14 @@ static cl_object
 fix_to_ptr(cl_object ptr)
 {
         cl_fixnum i = (cl_fixnum)ptr;
-        return (cl_object)(i & ~IMMEDIATE_TAG);
+        return (cl_object)(i & ~ECL_IMMEDIATE_TAG);
 }
 
 static cl_object
 enqueue(pool_t pool, cl_object what)
 {
         cl_object record, index;
-        if (FIXNUMP(what) || CHARACTERP(what) || what == OBJNULL) {
+        if (ECL_FIXNUMP(what) || ECL_CHARACTERP(what) || what == OBJNULL) {
                 return what;
         }
 #ifdef ECL_SMALL_CONS
@@ -131,7 +131,7 @@ enqueue(pool_t pool, cl_object what)
         index = ecl_gethash_safe(what, pool->hash, OBJNULL);
         if (index == OBJNULL) {
                 cl_object cons;
-                index = MAKE_FIXNUM(pool->hash->hash.entries);
+                index = ecl_make_fixnum(pool->hash->hash.entries);
                 ecl_sethash(what, pool->hash, index);
                 cons = ecl_cons(what, Cnil);
                 ECL_RPLACD(pool->last, cons);
@@ -142,7 +142,7 @@ enqueue(pool_t pool, cl_object what)
 
 #ifdef ECL_SMALL_CONS
 typedef struct {
-        HEADER;
+        _ECL_HDR;
         cl_object car, cdr;
 } large_cons;
 typedef large_cons *large_cons_ptr;
@@ -304,15 +304,15 @@ static void
 init_pool(pool_t pool, cl_object root)
 {
         pool->data = si_make_vector(@'ext::byte8',
-                                    MAKE_FIXNUM(1024),
+                                    ecl_make_fixnum(1024),
                                     Ct,
-                                    MAKE_FIXNUM(2 * sizeof(cl_index)),
+                                    ecl_make_fixnum(2 * sizeof(cl_index)),
                                     Cnil,
-                                    MAKE_FIXNUM(0));
-        pool->hash = cl__make_hash_table(@'eql', MAKE_FIXNUM(256),
+                                    ecl_make_fixnum(0));
+        pool->hash = cl__make_hash_table(@'eql', ecl_make_fixnum(256),
                                          cl_core.rehash_size,
                                          cl_core.rehash_threshold);
-        ecl_sethash(root, pool->hash, MAKE_FIXNUM(0));
+        ecl_sethash(root, pool->hash, ecl_make_fixnum(0));
         pool->queue = ecl_list1(root);
         pool->last = pool->queue;
 }
@@ -433,7 +433,7 @@ reconstruct_one(uint8_t *data, cl_object *output)
 static cl_object
 get_object(cl_object o_or_index, cl_object *o_list)
 {
-        if (IMMEDIATE(o_or_index)) {
+        if (ECL_IMMEDIATE(o_or_index)) {
                 return o_or_index;
         } else {
                 cl_index i = (cl_index)o_or_index >> 2;
@@ -444,13 +444,13 @@ get_object(cl_object o_or_index, cl_object *o_list)
 static void
 fixup_vector(cl_object v, cl_object *o_list)
 {
-        if (!IMMEDIATE(v->vector.displaced)) {
+        if (!ECL_IMMEDIATE(v->vector.displaced)) {
                 cl_object disp = get_object(v->vector.displaced, o_list);
                 cl_object to = ECL_CONS_CAR(disp);
                 if (to != Cnil) {
                         cl_index offset = (cl_index)v->vector.self.b8;
                         v->vector.displaced = Cnil;
-                        ecl_displace(v, to, MAKE_FIXNUM(offset));
+                        ecl_displace(v, to, ecl_make_fixnum(offset));
                         return;
                 }
         }
@@ -519,7 +519,7 @@ ecl_deserialize(uint8_t *raw)
         }
         for (i = 0; i < num_el; i++) {
                 cl_object package = output[i];
-                if (!IMMEDIATE(package) && package->d.t == t_package) {
+                if (!ECL_IMMEDIATE(package) && package->d.t == t_package) {
                         cl_object name = get_object(package->pack.name,
                                                     output);
                         output[i] = ecl_find_package_nolock(name);
@@ -527,7 +527,7 @@ ecl_deserialize(uint8_t *raw)
         }
         for (i = 0; i < num_el; i++) {
                 cl_object symbol = output[i];
-                if (!IMMEDIATE(symbol) && symbol->d.t == t_symbol) {
+                if (!ECL_IMMEDIATE(symbol) && symbol->d.t == t_symbol) {
                         struct fake_symbol *s = (struct fake_symbol *)symbol;
                         cl_object name = get_object(s->name, output);
                         cl_object pack = get_object(s->pack, output);
diff --git a/src/c/sse2.d b/src/c/sse2.d
index 2b1d16a52..658f004c8 100644
--- a/src/c/sse2.d
+++ b/src/c/sse2.d
@@ -92,7 +92,7 @@ si_sse_pack_element_type(cl_object x)
                 FEwrong_type_nth_arg(@[ext::sse-pack-element-type], 1, x, @[ext::sse-pack]);
 	}
 
-	@(return ecl_elttype_to_symbol(x->sse.elttype) MAKE_FIXNUM(x->sse.elttype));
+	@(return ecl_elttype_to_symbol(x->sse.elttype) ecl_make_fixnum(x->sse.elttype));
 }
 
 /* Conversion to and from specialized vectors */
@@ -129,7 +129,7 @@ si_vector_to_sse_pack(cl_object x)
 	verify_sse_elttype(x->vector.elttype);
 
 	if (ecl_unlikely(x->vector.dim * ecl_aet_size[x->vector.elttype] != 16))
-		FEerror("Wrong vector size in VECTOR-TO-SSE-PACK: ~S",1,MAKE_FIXNUM(x->vector.dim));
+		FEerror("Wrong vector size in VECTOR-TO-SSE-PACK: ~S",1,ecl_make_fixnum(x->vector.dim));
 
 	ssev = ecl_alloc_object(t_sse_pack);
 	ssev->sse.elttype = x->vector.elttype;
diff --git a/src/c/stacks.d b/src/c/stacks.d
index bc44b12a6..174452074 100644
--- a/src/c/stacks.d
+++ b/src/c/stacks.d
@@ -70,7 +70,7 @@ ecl_cs_overflow(void)
 	else
                 ecl_unrecoverable_error(env, stack_overflow_msg);
 	cl_cerror(6, make_constant_base_string("Extend stack size"),
-		  @'ext::stack-overflow', @':size', MAKE_FIXNUM(size),
+		  @'ext::stack-overflow', @':size', ecl_make_fixnum(size),
 		  @':type', @'ext::c-stack');
 	size += size / 2;
 	cs_set_size(env, size);
@@ -155,7 +155,7 @@ ecl_bds_overflow(void)
 	}
 	env->bds_limit += margin;
 	cl_cerror(6, make_constant_base_string("Extend stack size"),
-		  @'ext::stack-overflow', @':size', MAKE_FIXNUM(size),
+		  @'ext::stack-overflow', @':size', ecl_make_fixnum(size),
 		  @':type', @'ext::binding-stack');
 	ecl_bds_set_size(env, size + (size / 2));
         return env->bds_top;
@@ -201,9 +201,9 @@ ecl_progv(cl_env_ptr env, cl_object vars0, cl_object values0)
 static bds_ptr
 get_bds_ptr(cl_object x)
 {
-	if (FIXNUMP(x)) {
+	if (ECL_FIXNUMP(x)) {
 		cl_env_ptr env = ecl_process_env();
-		bds_ptr p = env->bds_org + fix(x);
+		bds_ptr p = env->bds_org + ecl_fix(x);
 		if (env->bds_org <= p && p <= env->bds_top)
 			return(p);
 	}
@@ -214,7 +214,7 @@ cl_object
 si_bds_top()
 {
 	cl_env_ptr env = ecl_process_env();
-	@(return MAKE_FIXNUM(env->bds_top - env->bds_org))
+	@(return ecl_make_fixnum(env->bds_top - env->bds_org))
 }
 
 cl_object
@@ -249,7 +249,7 @@ ecl_new_binding_index(cl_env_ptr env, cl_object symbol)
 	if (new_index == ECL_MISSING_SPECIAL_BINDING) {
 		pool = ecl_atomic_pop(&cl_core.reused_indices);
 		if (!Null(pool)) {
-			new_index = fix(ECL_CONS_CAR(pool));
+			new_index = ecl_fix(ECL_CONS_CAR(pool));
 		} else {
 			new_index = ecl_atomic_index_incf(&cl_core.last_var_index);
 		}
@@ -264,9 +264,9 @@ static cl_object
 ecl_extend_bindings_array(cl_object vector)
 {
         cl_index new_size = cl_core.last_var_index * 1.25;
-        cl_object new_vector = si_make_vector(Ct, MAKE_FIXNUM(new_size), Cnil,
+        cl_object new_vector = si_make_vector(Ct, ecl_make_fixnum(new_size), Cnil,
                                               Cnil, Cnil, Cnil);
-        si_fill_array_with_elt(new_vector, OBJNULL, MAKE_FIXNUM(0), Cnil);
+        si_fill_array_with_elt(new_vector, OBJNULL, ecl_make_fixnum(0), Cnil);
         ecl_copy_subarray(new_vector, 0, vector, 0, vector->vector.dim);
         return new_vector;
 }
@@ -412,7 +412,7 @@ get_ihs_ptr(cl_index n)
 	cl_env_ptr env = ecl_process_env();
 	ihs_ptr p = env->ihs_top;
 	if (n > p->index)
-		FEerror("~D is an illegal IHS index.", 1, MAKE_FIXNUM(n));
+		FEerror("~D is an illegal IHS index.", 1, ecl_make_fixnum(n));
 	while (n < p->index)
 		p = p->next;
 	return p;
@@ -429,7 +429,7 @@ cl_object
 si_ihs_top(void)
 {
 	cl_env_ptr env = ecl_process_env();
-	@(return MAKE_FIXNUM(env->ihs_top->index))
+	@(return ecl_make_fixnum(env->ihs_top->index))
 }
 
 cl_object
@@ -447,7 +447,7 @@ si_ihs_next(cl_object x)
 cl_object
 si_ihs_bds(cl_object arg)
 {
-	@(return MAKE_FIXNUM(get_ihs_ptr(ecl_to_size(arg))->bds))
+	@(return ecl_make_fixnum(get_ihs_ptr(ecl_to_size(arg))->bds))
 }
 
 cl_object
@@ -507,7 +507,7 @@ frs_overflow(void)		/* used as condition in list.d */
 	}
 	env->frs_limit += margin;
 	cl_cerror(6, make_constant_base_string("Extend stack size"),
-		  @'ext::stack-overflow', @':size', MAKE_FIXNUM(size),
+		  @'ext::stack-overflow', @':size', ecl_make_fixnum(size),
 		  @':type', @'ext::frame-stack');
 	frs_set_size(env, size + size / 2);
 }
@@ -554,9 +554,9 @@ frs_sch (cl_object frame_id)
 static ecl_frame_ptr
 get_frame_ptr(cl_object x)
 {
-	if (FIXNUMP(x)) {
+	if (ECL_FIXNUMP(x)) {
 		cl_env_ptr env = ecl_process_env();
-		ecl_frame_ptr p = env->frs_org + fix(x);
+		ecl_frame_ptr p = env->frs_org + ecl_fix(x);
 		if (env->frs_org <= p && p <= env->frs_top)
 			return p;
 	}
@@ -567,13 +567,13 @@ cl_object
 si_frs_top()
 {
 	cl_env_ptr env = ecl_process_env();
-	@(return MAKE_FIXNUM(env->frs_top - env->frs_org))
+	@(return ecl_make_fixnum(env->frs_top - env->frs_org))
 }
 
 cl_object
 si_frs_bds(cl_object arg)
 {
-	@(return MAKE_FIXNUM(get_frame_ptr(arg)->frs_bds_top_index))
+	@(return ecl_make_fixnum(get_frame_ptr(arg)->frs_bds_top_index))
 }
 
 cl_object
@@ -585,7 +585,7 @@ si_frs_tag(cl_object arg)
 cl_object
 si_frs_ihs(cl_object arg)
 {
-	@(return MAKE_FIXNUM(get_frame_ptr(arg)->frs_ihs->index))
+	@(return ecl_make_fixnum(get_frame_ptr(arg)->frs_ihs->index))
 }
 
 cl_object
@@ -597,7 +597,7 @@ si_sch_frs_base(cl_object fr, cl_object ihs)
 	for (x = get_frame_ptr(fr); 
 	     x <= env->frs_top && x->frs_ihs->index < y;
 	     x++);
-	@(return ((x > env->frs_top) ? Cnil : MAKE_FIXNUM(x - env->frs_org)))
+	@(return ((x > env->frs_top) ? Cnil : ecl_make_fixnum(x - env->frs_org)))
 }
 
 /********************* INITIALIZATION ***********************/
diff --git a/src/c/string.d b/src/c/string.d
index 95db67c58..23c91b6d1 100644
--- a/src/c/string.d
+++ b/src/c/string.d
@@ -47,7 +47,7 @@ do_make_string(cl_index s, ecl_character code)
 #define do_make_string do_make_base_string
 #endif
 
-@(defun make_string (size &key (initial_element CODE_CHAR(' '))
+@(defun make_string (size &key (initial_element ECL_CODE_CHAR(' '))
 		     (element_type @'character'))
 	cl_index s;
 	cl_object x;
@@ -152,7 +152,7 @@ ecl_fits_in_base_string(cl_object s)
 	case t_string: {
 		cl_index i;
 		for (i = 0; i < s->string.fillp; i++) {
-			if (!BASE_CHAR_CODE_P(s->string.self[i]))
+			if (!ECL_BASE_CHAR_CODE_P(s->string.self[i]))
 				return 0;
 		}
 		return 1;
@@ -183,7 +183,7 @@ si_copy_to_simple_base_string(cl_object x)
 		y = ecl_alloc_simple_base_string(length);
 		for (index=0; index < length; index++) {
 			ecl_character c = x->string.self[index];
-			if (!BASE_CHAR_CODE_P(c))
+			if (!ECL_BASE_CHAR_CODE_P(c))
 				FEerror("Cannot coerce string ~A to a base-string", 1, x);
 			y->base_string.self[index] = c;
 		}
@@ -216,9 +216,9 @@ cl_string(cl_object x)
 		break;
 	case t_character: {
 		cl_object y;
-                ecl_character c = CHAR_CODE(x);
+                ecl_character c = ECL_CHAR_CODE(x);
 #ifdef ECL_UNICODE
-		if (BASE_CHAR_CODE_P(c)) {
+		if (ECL_BASE_CHAR_CODE_P(c)) {
 			y = ecl_alloc_simple_base_string(1);
 			y->base_string.self[0] = c;
 			x = y;
@@ -271,7 +271,7 @@ si_coerce_to_extended_string(cl_object x)
 		goto AGAIN;
 	case t_character:
 		y = ecl_alloc_simple_extended_string(1);
-		y->string.self[0] = CHAR_CODE(x);
+		y->string.self[0] = ECL_CHAR_CODE(x);
 		break;
 	case t_base_string: {
 		cl_index index, len = x->base_string.dim;
@@ -300,7 +300,7 @@ cl_object
 cl_char(cl_object object, cl_object index)
 {
 	cl_index position = ecl_to_index(index);
-	@(return CODE_CHAR(ecl_char(object, position)))
+	@(return ECL_CODE_CHAR(ecl_char(object, position)))
 }
 
 ecl_character
@@ -419,8 +419,8 @@ compare_base(unsigned char *s1, cl_index l1, unsigned char *s2, cl_index l2,
 	}
 }
 
-@(defun string= (string1 string2 &key (start1 MAKE_FIXNUM(0)) end1
-		                      (start2 MAKE_FIXNUM(0)) end2)
+@(defun string= (string1 string2 &key (start1 ecl_make_fixnum(0)) end1
+		                      (start2 ecl_make_fixnum(0)) end2)
         cl_index_pair p;
 	cl_index s1, e1, s2, e2;
 @
@@ -514,8 +514,8 @@ ecl_string_eq(cl_object x, cl_object y)
 }
 
 
-@(defun string_equal (string1 string2 &key (start1 MAKE_FIXNUM(0)) end1
-		                           (start2 MAKE_FIXNUM(0)) end2)
+@(defun string_equal (string1 string2 &key (start1 ecl_make_fixnum(0)) end1
+		                           (start2 ecl_make_fixnum(0)) end2)
 	cl_index s1, e1, s2, e2;
         cl_index_pair p;
 	int output;
@@ -566,8 +566,8 @@ string_compare(cl_narg narg, int sign1, int sign2, int case_sensitive, cl_va_lis
 
 	string1 = cl_string(string1);
 	string2 = cl_string(string2);
-	if (start1p == Cnil) start1 = MAKE_FIXNUM(0);
-	if (start2p == Cnil) start2 = MAKE_FIXNUM(0);
+	if (start1p == Cnil) start1 = ecl_make_fixnum(0);
+	if (start2p == Cnil) start2 = ecl_make_fixnum(0);
 	p = ecl_vector_start_end(@[string=], string1, start1, end1);
         s1 = p.start; e1 = p.end;
 	p = ecl_vector_start_end(@[string=], string2, start2, end2);
@@ -585,7 +585,7 @@ string_compare(cl_narg narg, int sign1, int sign2, int case_sensitive, cl_va_lis
 		e1 += s1;
 	}
 	if (output == sign1 || output == sign2) {
-		result = MAKE_FIXNUM(e1);
+		result = ecl_make_fixnum(e1);
 	} else {
 		result = Cnil;
 	}
@@ -656,14 +656,14 @@ ecl_member_char(ecl_character c, cl_object char_bag)
 	case t_list:
 		loop_for_in(char_bag) {
 			cl_object other = CAR(char_bag);
-			if (CHARACTERP(other) && c == CHAR_CODE(other))
+			if (ECL_CHARACTERP(other) && c == ECL_CHAR_CODE(other))
 				return(TRUE);
 		} end_loop_for_in;
 		return(FALSE);
 	case t_vector:
 		for (i = 0, f = char_bag->vector.fillp;  i < f;  i++) {
 			cl_object other = char_bag->vector.self.t[i];
-			if (CHARACTERP(other) && c == CHAR_CODE(other))
+			if (ECL_CHARACTERP(other) && c == ECL_CHAR_CODE(other))
 				return(TRUE);
 		}
 		return(FALSE);
@@ -711,7 +711,7 @@ string_trim0(bool left_trim, bool right_trim, cl_object char_bag, cl_object strn
 			}
 		}
 	}
-	return cl_subseq(3, strng, MAKE_FIXNUM(i), MAKE_FIXNUM(j));
+	return cl_subseq(3, strng, ecl_make_fixnum(i), ecl_make_fixnum(j));
 }
 
 cl_object
@@ -753,7 +753,7 @@ string_case(cl_narg narg, cl_object fun, ecl_casefun casefun, cl_va_list ARGS)
         strng = cl_string(strng);
         strng = cl_copy_seq(strng);
 	if (kstartp == Cnil)
-                kstart = MAKE_FIXNUM(0);
+                kstart = ecl_make_fixnum(0);
 	p = ecl_vector_start_end(fun, strng, kstart, kend);
 	b = TRUE;
 #ifdef ECL_UNICODE
@@ -836,7 +836,7 @@ nstring_case(cl_narg narg, cl_object fun, ecl_casefun casefun, cl_va_list ARGS)
         if (ecl_unlikely(!ECL_STRINGP(strng)))
                 FEwrong_type_nth_arg(fun, 1, strng, @[string]);
 	if (kstartp == Cnil)
-                kstart = MAKE_FIXNUM(0);
+                kstart = ecl_make_fixnum(0);
 	p = ecl_vector_start_end(fun, strng, kstart, kend);
 	b = TRUE;
 #ifdef ECL_UNICODE
diff --git a/src/c/structure.d b/src/c/structure.d
index 53001f76d..3c4aa0c3f 100644
--- a/src/c/structure.d
+++ b/src/c/structure.d
@@ -76,7 +76,7 @@ si_structure_subtype_p(cl_object x, cl_object y)
 #endif
 	if (narg >= ECL_SLOTS_LIMIT)
 		FEerror("Limit on structure size exceeded: ~S slots requested.",
-			1, MAKE_FIXNUM(narg));
+			1, ecl_make_fixnum(narg));
 	for (i = 0;  i < narg;  i++)
 		SLOT(x, i) = cl_va_arg(args);
 	@(return x)
@@ -145,7 +145,7 @@ si_structure_ref(cl_object x, cl_object type, cl_object index)
 	if (ecl_unlikely(type_of(x) != T_STRUCTURE ||
                          !structure_subtypep(STYPE(x), type)))
                 FEwrong_type_nth_arg(@[si::structure-ref], 1, x, type);
-	@(return SLOT(x, fix(index)))
+	@(return SLOT(x, ecl_fix(index)))
 }
 
 cl_object
@@ -164,7 +164,7 @@ si_structure_set(cl_object x, cl_object type, cl_object index, cl_object val)
 	if (ecl_unlikely(type_of(x) != T_STRUCTURE ||
                          !structure_subtypep(STYPE(x), type)))
                 FEwrong_type_nth_arg(@[si::structure-set], 1, x, type);
-	SLOT(x, fix(index)) = val;
+	SLOT(x, ecl_fix(index)) = val;
 	@(return val)
 }
 
diff --git a/src/c/symbol.d b/src/c/symbol.d
index fb748dab9..45c61f524 100644
--- a/src/c/symbol.d
+++ b/src/c/symbol.d
@@ -344,7 +344,7 @@ cl_symbol_name(cl_object x)
 	output = ecl_make_string_output_stream(64, 1);
 	ecl_bds_bind(the_env, @'*print-escape*', Cnil);
 	ecl_bds_bind(the_env, @'*print-readably*', Cnil);
-	ecl_bds_bind(the_env, @'*print-base*', MAKE_FIXNUM(10));
+	ecl_bds_bind(the_env, @'*print-base*', ecl_make_fixnum(10));
 	ecl_bds_bind(the_env, @'*print-radix*', Cnil);
 	si_write_ugly_object(prefix, output);
 	si_write_ugly_object(counter, output);
@@ -366,7 +366,7 @@ ONCE_MORE:
 	output = ecl_make_string_output_stream(64, 1);
 	ecl_bds_bind(the_env, @'*print-escape*', Cnil);
 	ecl_bds_bind(the_env, @'*print-readably*', Cnil);
-	ecl_bds_bind(the_env, @'*print-base*', MAKE_FIXNUM(10));
+	ecl_bds_bind(the_env, @'*print-base*', ecl_make_fixnum(10));
 	ecl_bds_bind(the_env, @'*print-radix*', Cnil);
 	si_write_ugly_object(prefix, output);
 	si_write_ugly_object(cl_core.gentemp_counter, output);
diff --git a/src/c/symbols_list.h b/src/c/symbols_list.h
index 995be9fbb..9ec2dc740 100755
--- a/src/c/symbols_list.h
+++ b/src/c/symbols_list.h
@@ -119,7 +119,7 @@ cl_symbols[] = {
 {"*DEFAULT-PATHNAME-DEFAULTS*", CL_SPECIAL, NULL, -1, OBJNULL},
 {"*ERROR-OUTPUT*", CL_SPECIAL, NULL, -1, OBJNULL},
 {"*FEATURES*", CL_SPECIAL, NULL, -1, OBJNULL},
-{"*GENSYM-COUNTER*", CL_SPECIAL, NULL, -1, MAKE_FIXNUM(0)},
+{"*GENSYM-COUNTER*", CL_SPECIAL, NULL, -1, ecl_make_fixnum(0)},
 {"*LOAD-PATHNAME*", CL_SPECIAL, NULL, -1, Cnil},
 {"*LOAD-PRINT*", CL_SPECIAL, NULL, -1, Cnil},
 {"*LOAD-TRUENAME*", CL_SPECIAL, NULL, -1, Cnil},
@@ -129,7 +129,7 @@ cl_symbols[] = {
 {EXT_ "*MODULE-PROVIDER-FUNCTIONS*", EXT_SPECIAL, NULL, -1, OBJNULL},
 {"*PACKAGE*", CL_SPECIAL, NULL, -1, OBJNULL},
 {"*PRINT-ARRAY*", CL_SPECIAL, NULL, -1, Ct},
-{"*PRINT-BASE*", CL_SPECIAL, NULL, -1, MAKE_FIXNUM(10)},
+{"*PRINT-BASE*", CL_SPECIAL, NULL, -1, ecl_make_fixnum(10)},
 {"*PRINT-CASE*", CL_SPECIAL, NULL, -1, OBJNULL},
 {"*PRINT-CIRCLE*", CL_SPECIAL, NULL, -1, Cnil},
 {"*PRINT-ESCAPE*", CL_SPECIAL, NULL, -1, Ct},
@@ -149,7 +149,7 @@ cl_symbols[] = {
 {"*PRINT-RIGHT-MARGIN*", CL_SPECIAL, NULL, -1, Cnil},
 {"*QUERY-IO*", CL_SPECIAL, NULL, -1, OBJNULL},
 {"*RANDOM-STATE*", CL_SPECIAL, NULL, -1, OBJNULL},
-{"*READ-BASE*", CL_SPECIAL, NULL, -1, MAKE_FIXNUM(10)},
+{"*READ-BASE*", CL_SPECIAL, NULL, -1, ecl_make_fixnum(10)},
 {"*READ-DEFAULT-FLOAT-FORMAT*", CL_SPECIAL, NULL, -1, OBJNULL},
 {"*READ-EVAL*", CL_SPECIAL, NULL, -1, Ct},
 {"*READ-SUPPRESS*", CL_SPECIAL, NULL, -1, Cnil},
@@ -186,17 +186,17 @@ cl_symbols[] = {
 {"ARITHMETIC-ERROR-OPERATION", CL_ORDINARY, NULL, -1, OBJNULL},
 {"ARRAY", CL_ORDINARY, NULL, -1, OBJNULL},
 {"ARRAY-DIMENSION", CL_ORDINARY, cl_array_dimension, 2, OBJNULL},
-{"ARRAY-DIMENSION-LIMIT", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ADIMLIM)},
+{"ARRAY-DIMENSION-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ADIMLIM)},
 {"ARRAY-DIMENSIONS", CL_ORDINARY, ECL_NAME(cl_array_dimensions), 1, OBJNULL},
 {"ARRAY-DISPLACEMENT", CL_ORDINARY, cl_array_displacement, 1, OBJNULL},
 {"ARRAY-ELEMENT-TYPE", CL_ORDINARY, cl_array_element_type, 1, OBJNULL},
 {"ARRAY-HAS-FILL-POINTER-P", CL_ORDINARY, cl_array_has_fill_pointer_p, 1, OBJNULL},
 {"ARRAY-IN-BOUNDS-P", CL_ORDINARY, ECL_NAME(cl_array_in_bounds_p), -1, OBJNULL},
 {"ARRAY-RANK", CL_ORDINARY, cl_array_rank, 1, OBJNULL},
-{"ARRAY-RANK-LIMIT", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ARANKLIM)},
+{"ARRAY-RANK-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ARANKLIM)},
 {"ARRAY-ROW-MAJOR-INDEX", CL_ORDINARY, ECL_NAME(cl_array_row_major_index), -1, OBJNULL},
 {"ARRAY-TOTAL-SIZE", CL_ORDINARY, cl_array_total_size, 1, OBJNULL},
-{"ARRAY-TOTAL-SIZE-LIMIT", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ATOTLIM)},
+{"ARRAY-TOTAL-SIZE-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ATOTLIM)},
 {"ARRAYP", CL_ORDINARY, cl_arrayp, 1, OBJNULL},
 {"ASH", CL_ORDINARY, cl_ash, 2, OBJNULL},
 {"ASIN", CL_ORDINARY, ECL_NAME(cl_asin), 1, OBJNULL},
@@ -227,22 +227,22 @@ cl_symbols[] = {
 {"BIT-XOR", CL_ORDINARY, ECL_NAME(cl_bit_xor), -1, OBJNULL},
 {"BLOCK", CL_FORM, NULL, -1, OBJNULL},
 {"BOOLE", CL_ORDINARY, cl_boole, 3, OBJNULL},
-{"BOOLE-1", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOL1)},
-{"BOOLE-2", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOL2)},
-{"BOOLE-AND", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLAND)},
-{"BOOLE-ANDC1", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLANDC1)},
-{"BOOLE-ANDC2", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLANDC2)},
-{"BOOLE-C1", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLC1)},
-{"BOOLE-C2", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLC2)},
-{"BOOLE-CLR", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLCLR)},
-{"BOOLE-EQV", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLEQV)},
-{"BOOLE-IOR", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLIOR)},
-{"BOOLE-NAND", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLNAND)},
-{"BOOLE-NOR", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLNOR)},
-{"BOOLE-ORC1", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLORC1)},
-{"BOOLE-ORC2", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLORC2)},
-{"BOOLE-SET", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLSET)},
-{"BOOLE-XOR", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_BOOLXOR)},
+{"BOOLE-1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOL1)},
+{"BOOLE-2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOL2)},
+{"BOOLE-AND", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLAND)},
+{"BOOLE-ANDC1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLANDC1)},
+{"BOOLE-ANDC2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLANDC2)},
+{"BOOLE-C1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLC1)},
+{"BOOLE-C2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLC2)},
+{"BOOLE-CLR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLCLR)},
+{"BOOLE-EQV", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLEQV)},
+{"BOOLE-IOR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLIOR)},
+{"BOOLE-NAND", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLNAND)},
+{"BOOLE-NOR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLNOR)},
+{"BOOLE-ORC1", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLORC1)},
+{"BOOLE-ORC2", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLORC2)},
+{"BOOLE-SET", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLSET)},
+{"BOOLE-XOR", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_BOOLXOR)},
 {"BOOLEAN", CL_ORDINARY, NULL, -1, OBJNULL},
 {"BOTH-CASE-P", CL_ORDINARY, cl_both_case_p, 1, OBJNULL},
 {"BOUNDP", CL_ORDINARY, cl_boundp, 1, OBJNULL},
@@ -267,7 +267,7 @@ cl_symbols[] = {
 {"CADDDR", CL_ORDINARY, cl_cadddr, 1, OBJNULL},
 {"CADDR", CL_ORDINARY, cl_caddr, 1, OBJNULL},
 {"CADR", CL_ORDINARY, cl_cadr, 1, OBJNULL},
-{"CALL-ARGUMENTS-LIMIT", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(CALL_ARGUMENTS_LIMIT)},
+{"CALL-ARGUMENTS-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(CALL_ARGUMENTS_LIMIT)},
 {"CAR", CL_ORDINARY, cl_car, 1, OBJNULL},
 {"CASE", CL_FORM, NULL, -1, OBJNULL},
 {"CATCH", CL_FORM, NULL, -1, OBJNULL},
@@ -293,7 +293,7 @@ cl_symbols[] = {
 {"CERROR", CL_ORDINARY, cl_cerror, -1, OBJNULL},
 {"CHAR", CL_ORDINARY, cl_char, 2, OBJNULL},
 {"CHAR-CODE", CL_ORDINARY, cl_char_code, 1, OBJNULL},
-{"CHAR-CODE-LIMIT", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(CHAR_CODE_LIMIT)},
+{"CHAR-CODE-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(CHAR_CODE_LIMIT)},
 {"CHAR-DOWNCASE", CL_ORDINARY, cl_char_downcase, 1, OBJNULL},
 {"CHAR-EQUAL", CL_ORDINARY, cl_char_equal, -1, OBJNULL},
 {"CHAR-GREATERP", CL_ORDINARY, cl_char_greaterp, -1, OBJNULL},
@@ -542,7 +542,7 @@ cl_symbols[] = {
 {"LABELS", CL_FORM, NULL, -1, OBJNULL},
 {"LAMBDA", CL_FORM, NULL, -1, OBJNULL},
 {"LAMBDA-LIST-KEYWORDS", CL_CONSTANT, NULL, -1, OBJNULL},
-{"LAMBDA-PARAMETERS-LIMIT", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(LAMBDA_PARAMETERS_LIMIT)},
+{"LAMBDA-PARAMETERS-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(LAMBDA_PARAMETERS_LIMIT)},
 {"LAST", CL_ORDINARY, cl_last, -1, OBJNULL},
 {"LCM", CL_ORDINARY, cl_lcm, -1, OBJNULL},
 {"LDB", CL_ORDINARY, ECL_NAME(cl_ldb), 2, OBJNULL},
@@ -650,12 +650,12 @@ cl_symbols[] = {
 {"MISMATCH", CL_ORDINARY, ECL_NAME(cl_mismatch), -1, OBJNULL},
 {"MOD", CL_ORDINARY, cl_mod, 2, OBJNULL},
 {"MOST-NEGATIVE-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_DOUBLE_FLOAT},
-{"MOST-NEGATIVE-FIXNUM", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(MOST_NEGATIVE_FIXNUM)},
+{"MOST-NEGATIVE-FIXNUM", CL_CONSTANT, NULL, -1, ecl_make_fixnum(MOST_NEGATIVE_FIXNUM)},
 {"MOST-NEGATIVE-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_LONG_FLOAT},
 {"MOST-NEGATIVE-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_SHORT_FLOAT},
 {"MOST-NEGATIVE-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_NEGATIVE_SINGLE_FLOAT},
 {"MOST-POSITIVE-DOUBLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_DOUBLE_FLOAT},
-{"MOST-POSITIVE-FIXNUM", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(MOST_POSITIVE_FIXNUM)},
+{"MOST-POSITIVE-FIXNUM", CL_CONSTANT, NULL, -1, ecl_make_fixnum(MOST_POSITIVE_FIXNUM)},
 {"MOST-POSITIVE-LONG-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_LONG_FLOAT},
 {"MOST-POSITIVE-SHORT-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_SHORT_FLOAT},
 {"MOST-POSITIVE-SINGLE-FLOAT", CL_CONSTANT, NULL, -1, ECL_MOST_POSITIVE_SINGLE_FLOAT},
@@ -665,7 +665,7 @@ cl_symbols[] = {
 {"MULTIPLE-VALUE-LIST", CL_FORM, NULL, -1, OBJNULL},
 {"MULTIPLE-VALUE-PROG1", CL_FORM, NULL, -1, OBJNULL},
 {"MULTIPLE-VALUE-SETQ", CL_FORM, NULL, -1, OBJNULL},
-{"MULTIPLE-VALUES-LIMIT", CL_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_MULTIPLE_VALUES_LIMIT)},
+{"MULTIPLE-VALUES-LIMIT", CL_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_MULTIPLE_VALUES_LIMIT)},
 {"NAME-CHAR", CL_ORDINARY, cl_name_char, 1, OBJNULL},
 {"NAMESTRING", CL_ORDINARY, cl_namestring, 1, OBJNULL},
 {"NBUTLAST", CL_ORDINARY, cl_nbutlast, -1, OBJNULL},
@@ -1105,7 +1105,7 @@ cl_symbols[] = {
 
 /* SYSTEM PACKAGE */
 {SYS_ "#!", SI_ORDINARY, NULL, -1, OBJNULL},
-{SYS_ "*BACKQ-LEVEL*", SI_SPECIAL, NULL, -1, MAKE_FIXNUM(0)},
+{SYS_ "*BACKQ-LEVEL*", SI_SPECIAL, NULL, -1, ecl_make_fixnum(0)},
 {SYS_ "*CBLOCK*", SI_SPECIAL, NULL, -1, Cnil},
 {SYS_ "*CIRCLE-COUNTER*", SI_SPECIAL, NULL, -1, Cnil},
 {SYS_ "*CIRCLE-STACK*", SI_SPECIAL, NULL, -1, OBJNULL},
@@ -1125,7 +1125,7 @@ cl_symbols[] = {
 {SYS_ "*PRINT-PACKAGE*", SI_SPECIAL, NULL, -1, Cnil},
 {SYS_ "*PRINT-STRUCTURE*", SI_SPECIAL, NULL, -1, Cnil},
 {SYS_ "*SHARP-EQ-CONTEXT*", SI_SPECIAL, NULL, -1, Cnil},
-{SYS_ "*STEP-LEVEL*", SI_SPECIAL, OBJNULL, -1, MAKE_FIXNUM(0)},
+{SYS_ "*STEP-LEVEL*", SI_SPECIAL, OBJNULL, -1, ecl_make_fixnum(0)},
 {SYS_ "*STEP-ACTION*", SI_SPECIAL, OBJNULL, -1, Cnil},
 {SYS_ ".", SI_ORDINARY, NULL, -1, OBJNULL},
 {SYS_ "UNQUOTE", SI_ORDINARY, NULL, -1, OBJNULL},
@@ -1144,7 +1144,7 @@ cl_symbols[] = {
 {SYS_ "BDS-VAL", SI_ORDINARY, si_bds_val, 1, OBJNULL},
 {SYS_ "BDS-VAR", SI_ORDINARY, si_bds_var, 1, OBJNULL},
 {SYS_ "BIT-ARRAY-OP", SI_ORDINARY, si_bit_array_op, 4, OBJNULL},
-{SYS_ "C-ARGUMENTS-LIMIT", SI_CONSTANT, NULL, -1, MAKE_FIXNUM(C_ARGUMENTS_LIMIT)},
+{SYS_ "C-ARGUMENTS-LIMIT", SI_CONSTANT, NULL, -1, ecl_make_fixnum(C_ARGUMENTS_LIMIT)},
 {SYS_ "CHAR-SET", SI_ORDINARY, si_char_set, 3, OBJNULL},
 {EXT_ "CHDIR", EXT_ORDINARY, si_chdir, -1, OBJNULL},
 {SYS_ "CLEAR-COMPILER-PROPERTIES", SI_ORDINARY, cl_identity, 1, OBJNULL},
@@ -1514,23 +1514,23 @@ cl_symbols[] = {
 {KEY_ "UNSIGNED-LONG", KEYWORD, NULL, -1, OBJNULL},
 {KEY_ "UNSIGNED-LONG-LONG", KEYWORD, NULL, -1, OBJNULL},
 {KEY_ "UNSIGNED-SHORT", KEYWORD, NULL, -1, OBJNULL},
-{SYS_ "C-CHAR-BIT", SI_CONSTANT, NULL, -1, MAKE_FIXNUM(CHAR_BIT)},
-{SYS_ "C-CHAR-MAX", SI_CONSTANT, NULL, -1, MAKE_FIXNUM(CHAR_MAX)},
-{SYS_ "C-CHAR-MIN", SI_CONSTANT, NULL, -1, MAKE_FIXNUM(CHAR_MIN)},
+{SYS_ "C-CHAR-BIT", SI_CONSTANT, NULL, -1, ecl_make_fixnum(CHAR_BIT)},
+{SYS_ "C-CHAR-MAX", SI_CONSTANT, NULL, -1, ecl_make_fixnum(CHAR_MAX)},
+{SYS_ "C-CHAR-MIN", SI_CONSTANT, NULL, -1, ecl_make_fixnum(CHAR_MIN)},
 {SYS_ "C-INT-MAX", SI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
 {SYS_ "C-INT-MIN", SI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
-{SYS_ "C-SHORT-MAX", SI_CONSTANT, NULL, -1, MAKE_FIXNUM(SHRT_MAX)},
-{SYS_ "C-SHORT-MIN", SI_CONSTANT, NULL, -1, MAKE_FIXNUM(SHRT_MIN)},
+{SYS_ "C-SHORT-MAX", SI_CONSTANT, NULL, -1, ecl_make_fixnum(SHRT_MAX)},
+{SYS_ "C-SHORT-MIN", SI_CONSTANT, NULL, -1, ecl_make_fixnum(SHRT_MIN)},
 {SYS_ "C-LONG-MAX", SI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
 {SYS_ "C-LONG-MIN", SI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
 {SYS_ "C-LONG-LONG-MAX",SI_CONSTANT,NULL,-1,OBJNULL}, /* See main.d */
-{SYS_ "C-UCHAR-MAX", SI_CONSTANT, NULL, -1, MAKE_FIXNUM(UCHAR_MAX)},
+{SYS_ "C-UCHAR-MAX", SI_CONSTANT, NULL, -1, ecl_make_fixnum(UCHAR_MAX)},
 {SYS_ "C-UINT-MAX", SI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
-{SYS_ "C-USHORT-MAX", SI_CONSTANT, NULL, -1, MAKE_FIXNUM(USHRT_MAX)},
+{SYS_ "C-USHORT-MAX", SI_CONSTANT, NULL, -1, ecl_make_fixnum(USHRT_MAX)},
 {SYS_ "C-ULONG-MAX", SI_CONSTANT, NULL, -1, OBJNULL}, /* See main.d */
 {SYS_ "C-ULONG-LONG-MAX",SI_CONSTANT,NULL,-1,OBJNULL}, /* See main.d */
 #ifdef ecl_long_long_t
-{SYS_ "C-LONG-LONG-BIT", SI_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_LONG_LONG_BITS)},
+{SYS_ "C-LONG-LONG-BIT", SI_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_LONG_LONG_BITS)},
 #else
 {SYS_ "C-LONG-LONG-BIT", SI_CONSTANT, NULL, -1, OBJNULL},
 #endif
@@ -1744,7 +1744,7 @@ cl_symbols[] = {
 {CLOS_ "DOCSTRING", CLOS_ORDINARY, NULL, -1, OBJNULL},
 #endif
 
-{SYS_ "CL-FIXNUM-BITS", SI_CONSTANT, NULL, -1, MAKE_FIXNUM(FIXNUM_BITS)},
+{SYS_ "CL-FIXNUM-BITS", SI_CONSTANT, NULL, -1, ecl_make_fixnum(FIXNUM_BITS)},
 {EXT_ "CL-FIXNUM", EXT_ORDINARY, NULL, -1, NULL},
 {EXT_ "CL-INDEX", EXT_ORDINARY, NULL, -1, NULL},
 
@@ -1911,7 +1911,7 @@ cl_symbols[] = {
 
 {EXT_ "FILL-ARRAY-WITH-ELT", EXT_ORDINARY, si_fill_array_with_elt, 4, OBJNULL},
 
-{EXT_ "+ECL-VERSION-NUMBER+", EXT_CONSTANT, NULL, -1, MAKE_FIXNUM(ECL_VERSION_NUMBER)},
+{EXT_ "+ECL-VERSION-NUMBER+", EXT_CONSTANT, NULL, -1, ecl_make_fixnum(ECL_VERSION_NUMBER)},
 
 {EXT_ "*BYTECODES-COMPILER*", EXT_SPECIAL, NULL, -1, Cnil},
 
@@ -1961,7 +1961,7 @@ cl_symbols[] = {
 
 {EXT_ "ARRAY-RAW-DATA", EXT_ORDINARY, si_array_raw_data, 1, OBJNULL},
 
-{EXT_ "*PROGRAM-EXIT-CODE*", EXT_SPECIAL, NULL, -1, MAKE_FIXNUM(0)},
+{EXT_ "*PROGRAM-EXIT-CODE*", EXT_SPECIAL, NULL, -1, ecl_make_fixnum(0)},
 {EXT_ "EXIT", EXT_ORDINARY, si_exit, -1, OBJNULL},
 
 {EXT_ "ENVIRON", EXT_ORDINARY, si_environ, 0, OBJNULL},
diff --git a/src/c/tcp.d b/src/c/tcp.d
index f7da63f05..09872bafa 100644
--- a/src/c/tcp.d
+++ b/src/c/tcp.d
@@ -275,17 +275,17 @@ si_open_client_stream(cl_object host, cl_object port)
 
    if (ecl_unlikely(!ECL_FIXNUMP(port) ||
                     ecl_fixnum_minusp(port) ||
-                    ecl_fixnum_greater(port,MAKE_FIXNUM(65536)))) {
+                    ecl_fixnum_greater(port,ecl_make_fixnum(65536)))) {
            FEwrong_type_nth_arg(@[si::open-client-stream], 2, port,
                                 ecl_read_from_cstring("(INTEGER 0 65535)"));
    }
-   p = fix(port);
+   p = ecl_fix(port);
 
    if (host->base_string.fillp > BUFSIZ - 1)
      FEerror("~S is a too long file name.", 1, host);
 
    ecl_disable_interrupts();
-   fd = connect_to_server((char*)host->base_string.self, fix(port)); 
+   fd = connect_to_server((char*)host->base_string.self, ecl_fix(port)); 
    ecl_enable_interrupts();
 
    if (fd == 0)
@@ -308,11 +308,11 @@ si_open_server_stream(cl_object port)
 
    if (ecl_unlikely(!ECL_FIXNUMP(port) ||
                     ecl_fixnum_minusp(port) ||
-                    ecl_fixnum_greater(port,MAKE_FIXNUM(65536)))) {
+                    ecl_fixnum_greater(port,ecl_make_fixnum(65536)))) {
            FEwrong_type_only_arg(@[si::open-client-stream], port,
                                  ecl_read_from_cstring("(INTEGER 0 65535)"));
    }
-   p = fix(port);
+   p = ecl_fix(port);
    ecl_disable_interrupts();
    fd = create_server_port(p);
    ecl_enable_interrupts();
@@ -379,7 +379,7 @@ si_lookup_host_entry(cl_object host_or_address)
 		he = gethostbyname((char*)host_or_address->base_string.self);
 		break;
 	case t_fixnum:
-		l = fix(host_or_address);
+		l = ecl_fix(host_or_address);
 		goto addr;
 	case t_bignum:
 		l = _ecl_big_to_ulong(host_or_address);
diff --git a/src/c/threads/barrier.d b/src/c/threads/barrier.d
index 8659f026a..484a3128d 100755
--- a/src/c/threads/barrier.d
+++ b/src/c/threads/barrier.d
@@ -39,7 +39,7 @@ ecl_make_barrier(cl_object name, cl_index count)
 @(defun mp::make-barrier (count &key name)
 @
 	if (count == Ct)
-		count = MAKE_FIXNUM(MOST_POSITIVE_FIXNUM);
+		count = ecl_make_fixnum(MOST_POSITIVE_FIXNUM);
 	@(return ecl_make_barrier(name, fixnnint(count)))
 @)
 
@@ -60,7 +60,7 @@ mp_barrier_count(cl_object barrier)
 	unlikely_if (type_of(barrier) != t_barrier) {
 		FEerror_not_a_barrier(barrier);
 	}
-	ecl_return1(env, MAKE_FIXNUM(barrier->barrier.count));
+	ecl_return1(env, ecl_make_fixnum(barrier->barrier.count));
 }
 
 cl_object
@@ -77,7 +77,7 @@ mp_barrier_arrivers_count(cl_object barrier)
 		arrivers = 0; /* Disabled barrier */
 	else
 		arrivers = count - arrivers;
-	ecl_return1(env, MAKE_FIXNUM(arrivers));
+	ecl_return1(env, ecl_make_fixnum(arrivers));
 }
 
 @(defun mp::barrier-unblock (barrier &key reset_count disable kill_waiting)
diff --git a/src/c/threads/mailbox.d b/src/c/threads/mailbox.d
index df0022f80..648672630 100755
--- a/src/c/threads/mailbox.d
+++ b/src/c/threads/mailbox.d
@@ -36,7 +36,7 @@ ecl_make_mailbox(cl_object name, cl_fixnum count)
 	mask = count - 1;
 	output->mailbox.name = name;
 	output->mailbox.data = si_make_vector(Ct, /* element type */
-					      MAKE_FIXNUM(count), /* size */
+					      ecl_make_fixnum(count), /* size */
 					      Cnil, /* adjustable */
 					      Cnil, /* fill pointer */
 					      Cnil, /* displaced to */
@@ -51,7 +51,7 @@ ecl_make_mailbox(cl_object name, cl_fixnum count)
         return output;
 }
 
-@(defun mp::make-mailbox (&key name (count MAKE_FIXNUM(128)))
+@(defun mp::make-mailbox (&key name (count ecl_make_fixnum(128)))
 @
 {
 	@(return ecl_make_mailbox(name, fixnnint(count)))
@@ -75,7 +75,7 @@ mp_mailbox_count(cl_object mailbox)
 	unlikely_if (type_of(mailbox) != t_mailbox) {
 		FEerror_not_a_mailbox(mailbox);
 	}
-	ecl_return1(env, MAKE_FIXNUM(mailbox->mailbox.data->vector.dim));
+	ecl_return1(env, ecl_make_fixnum(mailbox->mailbox.data->vector.dim));
 }
 
 cl_object
diff --git a/src/c/threads/mutex.d b/src/c/threads/mutex.d
index 289bb777c..a80b15fdf 100755
--- a/src/c/threads/mutex.d
+++ b/src/c/threads/mutex.d
@@ -97,7 +97,7 @@ mp_lock_count(cl_object lock)
 	unlikely_if (type_of(lock) != t_lock) {
 		FEerror_not_a_lock(lock);
 	}
-	ecl_return1(env, MAKE_FIXNUM(lock->lock.counter));
+	ecl_return1(env, ecl_make_fixnum(lock->lock.counter));
 }
 
 cl_object
diff --git a/src/c/threads/process.d b/src/c/threads/process.d
index 3d11565a8..4e396d45e 100755
--- a/src/c/threads/process.d
+++ b/src/c/threads/process.d
@@ -106,8 +106,8 @@ extend_process_vector()
 		cl_object other = cl_core.processes;
 		if (new_size > other->vector.dim) {
 			cl_object new = si_make_vector(Ct,
-						       MAKE_FIXNUM(new_size),
-						       MAKE_FIXNUM(other->vector.fillp),
+						       ecl_make_fixnum(new_size),
+						       ecl_make_fixnum(other->vector.fillp),
 						       Cnil, Cnil, Cnil);
 			ecl_copy_subarray(new, 0, other, 0, other->vector.dim);
 			cl_core.processes = new;
@@ -306,9 +306,9 @@ alloc_process(cl_object name, cl_object initial_bindings)
         process->process.exit_values = Cnil;
 	process->process.env = NULL;
 	if (initial_bindings != OBJNULL) {
-		array = si_make_vector(Ct, MAKE_FIXNUM(256),
+		array = si_make_vector(Ct, ecl_make_fixnum(256),
                                        Cnil, Cnil, Cnil, Cnil);
-                si_fill_array_with_elt(array, OBJNULL, MAKE_FIXNUM(0), Cnil);
+                si_fill_array_with_elt(array, OBJNULL, ecl_make_fixnum(0), Cnil);
 	} else {
 		array = cl_copy_seq(ecl_process_env()->bindings_array);
 	}
@@ -422,7 +422,7 @@ mp_suspend_loop()
         cl_env_ptr env = ecl_process_env();
         CL_CATCH_BEGIN(env,@'mp::suspend-loop') {
                 for ( ; ; ) {
-                        cl_sleep(MAKE_FIXNUM(100));
+                        cl_sleep(ecl_make_fixnum(100));
                 }
         } CL_CATCH_END;
 	ecl_return0(env);
@@ -743,8 +743,8 @@ init_threads(cl_env_ptr env)
 
 	{
 		cl_object v = si_make_vector(Ct, /* Element type */
-					   MAKE_FIXNUM(256), /* Size */
-					   MAKE_FIXNUM(0), /* fill pointer */
+					   ecl_make_fixnum(256), /* Size */
+					   ecl_make_fixnum(0), /* fill pointer */
 					   Cnil, Cnil, Cnil);
 		v->vector.self.t[0] = process;
 		v->vector.fillp = 1;
diff --git a/src/c/threads/queue.d b/src/c/threads/queue.d
index 1b53385ff..de4c57ede 100755
--- a/src/c/threads/queue.d
+++ b/src/c/threads/queue.d
@@ -112,7 +112,7 @@ waiting_time(cl_index iteration, struct ecl_timeval *start)
 {
 	/* Waiting time is smaller than 0.10 s */
 	double time;
-	cl_object top = MAKE_FIXNUM(10 * 1000);
+	cl_object top = ecl_make_fixnum(10 * 1000);
 	cl_object delta_big = elapsed_time(start);
 	_ecl_big_div_ui(delta_big, delta_big, iteration);
 	if (ecl_number_compare(delta_big, top) < 0) {
@@ -357,15 +357,15 @@ print_lock(char *prefix, cl_object l, ...)
 	va_list args;
 	va_start(args, l);
 	return;
-	if (l == Cnil || FIXNUMP(l->lock.name)) {
+	if (l == Cnil || ECL_FIXNUMP(l->lock.name)) {
 		cl_env_ptr env = ecl_process_env();
 		ecl_get_spinlock(env, &lock);
-		printf("\n%ld\t", fix(env->own_process->process.name));
+		printf("\n%ld\t", ecl_fix(env->own_process->process.name));
 		vprintf(prefix, args);
 		if (l != Cnil) {
 			cl_object p = l->lock.queue_list;
 			while (p != Cnil) {
-				printf(" %lx", fix(ECL_CONS_CAR(p)->process.name));
+				printf(" %lx", ecl_fix(ECL_CONS_CAR(p)->process.name));
 				p = ECL_CONS_CDR(p);
 			}
 		}
diff --git a/src/c/threads/semaphore.d b/src/c/threads/semaphore.d
index ed82a8275..ec1b3e9f3 100644
--- a/src/c/threads/semaphore.d
+++ b/src/c/threads/semaphore.d
@@ -38,7 +38,7 @@ ecl_make_semaphore(cl_object name, cl_fixnum count)
         return output;
 }
 
-@(defun mp::make-semaphore (&key name (count MAKE_FIXNUM(0)))
+@(defun mp::make-semaphore (&key name (count ecl_make_fixnum(0)))
 @
 {
 	@(return ecl_make_semaphore(name, fixnnint(count)))
@@ -62,7 +62,7 @@ mp_semaphore_count(cl_object semaphore)
 	unlikely_if (type_of(semaphore) != t_semaphore) {
 		FEerror_not_a_semaphore(semaphore);
 	}
-	ecl_return1(env, MAKE_FIXNUM(semaphore->semaphore.counter));
+	ecl_return1(env, ecl_make_fixnum(semaphore->semaphore.counter));
 }
 
 cl_object
@@ -75,7 +75,7 @@ mp_semaphore_wait_count(cl_object semaphore)
 	ecl_return1(env, cl_length(semaphore->semaphore.queue_list));
 }
 
-@(defun mp::signal-semaphore (semaphore &optional (count MAKE_FIXNUM(1)))
+@(defun mp::signal-semaphore (semaphore &optional (count ecl_make_fixnum(1)))
 @
 {
 	cl_fixnum n = fixnnint(count);
@@ -104,7 +104,7 @@ get_semaphore_inner(cl_env_ptr env, cl_object semaphore)
 		}
 		if (AO_compare_and_swap_full((AO_t*)&(semaphore->semaphore.counter),
 					     (AO_t)counter, (AO_t)(counter-1))) {
-			output = MAKE_FIXNUM(counter);
+			output = ecl_make_fixnum(counter);
 			break;
 		}
 		ecl_process_yield();
diff --git a/src/c/time.d b/src/c/time.d
index d31f13b07..61f1c6265 100644
--- a/src/c/time.d
+++ b/src/c/time.d
@@ -204,7 +204,7 @@ static cl_object
 timeval_to_time(long sec, long usec)
 {
 	cl_object milliseconds = ecl_plus(ecl_times(ecl_make_integer(sec),
-						    MAKE_FIXNUM(1000)),
+						    ecl_make_fixnum(1000)),
 					  ecl_make_integer(usec / 1000));
 	@(return milliseconds);
 }
@@ -238,9 +238,9 @@ init_unixtime(void)
 {
 	ecl_get_internal_real_time(&beginning);
 
-	ECL_SET(@'internal-time-units-per-second', MAKE_FIXNUM(1000));
+	ECL_SET(@'internal-time-units-per-second', ecl_make_fixnum(1000));
 
 	cl_core.Jan1st1970UT =
-	    ecl_times(MAKE_FIXNUM(24 * 60 * 60),
-			 MAKE_FIXNUM(17 + 365 * 70));
+	    ecl_times(ecl_make_fixnum(24 * 60 * 60),
+			 ecl_make_fixnum(17 + 365 * 70));
 }
diff --git a/src/c/typespec.d b/src/c/typespec.d
index 1d46bf964..fa2d993ec 100644
--- a/src/c/typespec.d
+++ b/src/c/typespec.d
@@ -24,8 +24,8 @@ FEtype_error_fixnum(cl_object x) {
 
 void
 FEtype_error_size(cl_object x) {
-	FEwrong_type_argument(cl_list(3, @'integer', MAKE_FIXNUM(0),
-				      MAKE_FIXNUM(MOST_POSITIVE_FIXNUM)),
+	FEwrong_type_argument(cl_list(3, @'integer', ecl_make_fixnum(0),
+				      ecl_make_fixnum(MOST_POSITIVE_FIXNUM)),
 			      x);
 }
 
@@ -63,12 +63,12 @@ FEcircular_list(cl_object x)
 void
 FEtype_error_index(cl_object seq, cl_fixnum ndx)
 {
-        cl_object n = MAKE_FIXNUM(ndx);
+        cl_object n = ecl_make_fixnum(ndx);
 	cl_index l = ECL_INSTANCEP(seq)? seq->instance.length : ecl_length(seq);
 	cl_error(9, @'simple-type-error', @':format-control',
 		    make_constant_base_string("~S is not a valid index into the object ~S"),
 		    @':format-arguments', cl_list(2, n, seq),
-		    @':expected-type', cl_list(3, @'integer', MAKE_FIXNUM(0), MAKE_FIXNUM(l-1)),
+		    @':expected-type', cl_list(3, @'integer', ecl_make_fixnum(0), ecl_make_fixnum(l-1)),
 		    @':datum', n);
 }
 
@@ -210,13 +210,13 @@ assert_type_non_negative_integer(cl_object p)
 	cl_type t = type_of(p);
 
 	if (t == t_fixnum) {
-		if (FIXNUM_PLUSP(p))
+		if (ecl_fixnum_plusp(p))
 			return;
 	} else if (t == t_bignum) {
 		if (_ecl_big_sign(p) >= 0)
 			return;
 	}
-	FEwrong_type_argument(cl_list(3,@'integer',MAKE_FIXNUM(0),@'*'), p);
+	FEwrong_type_argument(cl_list(3,@'integer',ecl_make_fixnum(0),@'*'), p);
 }
 
 void
@@ -249,7 +249,7 @@ cl_type_of(cl_object x)
 		t = cl_list(3, @'integer', x, x); break;
 #endif
 	case t_character: {
-		int i = CHAR_CODE(x);
+		int i = ECL_CHAR_CODE(x);
 		if (ecl_standard_char_p(i)) {
 			t = @'standard-char';
 		} else if (ecl_base_char_p(i)) {
@@ -281,14 +281,14 @@ cl_type_of(cl_object x)
 		if (ECL_ADJUSTABLE_ARRAY_P(x) ||
 		    !Null(CAR(x->vector.displaced))) {
 			t = cl_list(3, @'vector', ecl_elttype_to_symbol(ecl_array_elttype(x)),
-				    MAKE_FIXNUM(x->vector.dim));
+				    ecl_make_fixnum(x->vector.dim));
 		} else if (ECL_ARRAY_HAS_FILL_POINTER_P(x) ||
 			   (cl_elttype)x->vector.elttype != aet_object) {
 			t = cl_list(3, @'simple-array',
                                     ecl_elttype_to_symbol(ecl_array_elttype(x)),
 				    cl_array_dimensions(x));
 		} else {
-			t = cl_list(2, @'simple-vector', MAKE_FIXNUM(x->vector.dim));
+			t = cl_list(2, @'simple-vector', ecl_make_fixnum(x->vector.dim));
 		}
 		break;
 #ifdef ECL_UNICODE
@@ -299,7 +299,7 @@ cl_type_of(cl_object x)
 			t = @'array';
 		else
 			t = @'simple-array';
-		t = cl_list(3, t, @'character', cl_list(1, MAKE_FIXNUM(x->string.dim)));
+		t = cl_list(3, t, @'character', cl_list(1, ecl_make_fixnum(x->string.dim)));
 		break;
 #endif
 	case t_base_string:
@@ -309,7 +309,7 @@ cl_type_of(cl_object x)
 			t = @'array';
 		else
 			t = @'simple-array';
-		t = cl_list(3, t, @'base-char', cl_list(1, MAKE_FIXNUM(x->base_string.dim)));
+		t = cl_list(3, t, @'base-char', cl_list(1, ecl_make_fixnum(x->base_string.dim)));
 		break;
 	case t_bitvector:
 		if (ECL_ADJUSTABLE_ARRAY_P(x) ||
@@ -318,7 +318,7 @@ cl_type_of(cl_object x)
 			t = @'array';
 		else
 			t = @'simple-array';
-		t = cl_list(3, t, @'bit', cl_list(1, MAKE_FIXNUM(x->vector.dim)));
+		t = cl_list(3, t, @'bit', cl_list(1, ecl_make_fixnum(x->vector.dim)));
 		break;
 #ifndef CLOS
 	case t_structure:
diff --git a/src/c/unify.d b/src/c/unify.d
index 298c68e1b..fe38a85ed 100644
--- a/src/c/unify.d
+++ b/src/c/unify.d
@@ -148,7 +148,7 @@ RETRY:	switch (type_of(x)) {
 
 @(defun get_instance (x class arity)
 @
-	@(return (get_instance(x, class, fix(arity))?Ct:Cnil))
+	@(return (get_instance(x, class, ecl_fix(arity))?Ct:Cnil))
 @)
 
 
@@ -248,7 +248,7 @@ unify(object x, object y)
 
 @(defun make_locative (&optional (n 0))
 @
-	@(return (MAKE_LOCATIVE(fix(n))))
+	@(return (MAKE_LOCATIVE(ecl_fix(n))))
 @)
 
 @(defun locativep (obje)
diff --git a/src/c/unixfsys.d b/src/c/unixfsys.d
index 900288843..c4d87d8c6 100644
--- a/src/c/unixfsys.d
+++ b/src/c/unixfsys.d
@@ -672,7 +672,7 @@ ecl_homedir_pathname(cl_object user)
 	i = namestring->base_string.fillp;
 	if (!IS_DIR_SEPARATOR(namestring->base_string.self[i-1]))
 		namestring = si_base_string_concatenate(2, namestring,
-						        CODE_CHAR(DIR_SEPARATOR));
+						        ECL_CODE_CHAR(DIR_SEPARATOR));
 	return cl_parse_namestring(3, namestring, Cnil, Cnil);
 }
 
@@ -961,7 +961,7 @@ si_get_library_pathname(void)
 	ecl_enable_interrupts();
 	if (len == 0) {
 		FEerror("GetModuleFileName failed (last error = ~S)",
-			1, MAKE_FIXNUM(GetLastError()));
+			1, ecl_make_fixnum(GetLastError()));
 	}
 	s->base_string.fillp = len;
         /* GetModuleFileName returns a file name. We have to strip
@@ -1017,12 +1017,12 @@ si_mkdir(cl_object directory, cl_object mode)
 
         if (ecl_unlikely(!ECL_FIXNUMP(mode) ||
                          ecl_fixnum_minusp(mode) ||
-                         ecl_fixnum_greater(mode, MAKE_FIXNUM(0777)))) {
+                         ecl_fixnum_greater(mode, ecl_make_fixnum(0777)))) {
                 FEwrong_type_nth_arg(@[si::mkdir], 2, mode,
-                                     ecl_make_integer_type(MAKE_FIXNUM(0),
-                                                           MAKE_FIXNUM(0777)));
+                                     ecl_make_integer_type(ecl_make_fixnum(0),
+                                                           ecl_make_fixnum(0777)));
         }
-        modeint = fix(mode);
+        modeint = ecl_fix(mode);
 	{
 		/* Ensure a clean string, without trailing slashes,
 		 * and null terminated. */
diff --git a/src/c/unixint.d b/src/c/unixint.d
index ac36344f6..a50e4b7ae 100644
--- a/src/c/unixint.d
+++ b/src/c/unixint.d
@@ -455,7 +455,7 @@ handler_fn_prototype(non_evil_signal_handler, int sig, siginfo_t *siginfo, void
         the_env = ecl_process_env();
         unlikely_if (zombie_process(the_env))
                 return;
-        signal_object = ecl_gethash_safe(MAKE_FIXNUM(sig),
+        signal_object = ecl_gethash_safe(ecl_make_fixnum(sig),
 					 cl_core.known_signals,
 					 Cnil);
         handle_or_queue(the_env, signal_object, sig);
@@ -473,7 +473,7 @@ handler_fn_prototype(evil_signal_handler, int sig, siginfo_t *siginfo, void *dat
         the_env = ecl_process_env();
         unlikely_if (zombie_process(the_env))
                 return;
-        signal_object = ecl_gethash_safe(MAKE_FIXNUM(sig),
+        signal_object = ecl_gethash_safe(ecl_make_fixnum(sig),
 					 cl_core.known_signals,
 					 Cnil);
         handle_signal_now(signal_object, the_env->own_process);
@@ -565,7 +565,7 @@ asynchronous_signal_servicing_thread()
 			continue;
 		}
 #endif
-		signal_code = ecl_gethash_safe(MAKE_FIXNUM(signal_thread_msg.signo),
+		signal_code = ecl_gethash_safe(ecl_make_fixnum(signal_thread_msg.signo),
 					       cl_core.known_signals,
 					       Cnil);
 		if (!Null(signal_code)) {
@@ -783,7 +783,7 @@ ecl_check_pending_interrupts(cl_env_ptr env)
 static cl_object
 do_catch_signal(int code, cl_object action, cl_object process)
 {
-	cl_object code_fixnum = MAKE_FIXNUM(code);
+	cl_object code_fixnum = ecl_make_fixnum(code);
         if (action == Cnil || action == @':ignore') {
                 mysignal(code, SIG_IGN);
                 return Ct;
@@ -893,10 +893,10 @@ si_set_signal_handler(cl_object code, cl_object handler)
 	unlikely_if (ecl_gethash_safe(code, cl_core.known_signals, OBJNULL) == OBJNULL) {
 		illegal_signal_code(code);
 	}
-	code_int = fix(code);
+	code_int = ecl_fix(code);
 #ifdef GBC_BOEHM
 # ifdef SIGSEGV
-	unlikely_if ((code == MAKE_FIXNUM(SIGSEGV)) &&
+	unlikely_if ((code == ecl_make_fixnum(SIGSEGV)) &&
 		     ecl_option_values[ECL_OPT_INCREMENTAL_GC])
 		FEerror("It is not allowed to change the behavior of SIGSEGV.",
 			0);
@@ -1183,7 +1183,7 @@ asynchronous_signal_servicing_thread()
                                 continue;
                         }
 #endif
-			signal_code = ecl_gethash_safe(MAKE_FIXNUM(signo),
+			signal_code = ecl_gethash_safe(ecl_make_fixnum(signo),
 						       cl_core.known_signals,
 						       Cnil);
 			if (!Null(signal_code)) {
@@ -1222,8 +1222,8 @@ si_trap_fpe(cl_object condition, cl_object flag)
                         bits = FE_INVALID;
                 else if (condition == @'floating-point-inexact')
                         bits = FE_INEXACT;
-                else if (FIXNUMP(condition))
-			bits = fix(condition) & all;
+                else if (ECL_FIXNUMP(condition))
+			bits = ecl_fix(condition) & all;
                 if (flag == Cnil) {
                         bits = the_env->trap_fpe_bits & ~bits;
                 } else {
@@ -1243,7 +1243,7 @@ si_trap_fpe(cl_object condition, cl_object flag)
 # endif
 #endif
         the_env->trap_fpe_bits = bits;
-	@(return MAKE_FIXNUM(bits))
+	@(return ecl_make_fixnum(bits))
 }
 
 /*
@@ -1422,7 +1422,7 @@ install_fpe_signal_handlers()
 static void
 add_one_signal(cl_object hash_table, int signal, cl_object name, cl_object handler)
 {
-	cl_object code = MAKE_FIXNUM(signal);
+	cl_object code = ecl_make_fixnum(signal);
 	cl_export2(name, cl_core.ext_package);
 	si_Xmake_constant(name, code);
 	ecl_sethash(code, hash_table, handler);
@@ -1433,7 +1433,7 @@ create_signal_code_constants()
 {
 	cl_object hash =
 		cl_core.known_signals =
-		cl__make_hash_table(@'eql', MAKE_FIXNUM(128),
+		cl__make_hash_table(@'eql', ecl_make_fixnum(128),
 				    cl_core.rehash_size,
 				    cl_core.rehash_threshold);
 	int i;
diff --git a/src/c/unixsys.d b/src/c/unixsys.d
index cd2ac5e2d..9fb6a631e 100644
--- a/src/c/unixsys.d
+++ b/src/c/unixsys.d
@@ -45,14 +45,14 @@
 cl_object
 si_getpid(void)
 {
-	@(return MAKE_FIXNUM(getpid()))
+	@(return ecl_make_fixnum(getpid()))
 }
 
 cl_object
 si_getuid(void)
 {
 #if defined(ECL_MS_WINDOWS_HOST)
-        @(return MAKE_FIXNUM(0));
+        @(return ecl_make_fixnum(0));
 #else
 	@(return ecl_make_integer(getuid()));
 #endif
@@ -249,7 +249,7 @@ ecl_waitpid(cl_object pid, cl_object wait)
                 code = Cnil;
         } else {
                 status = @':exited';
-                code = MAKE_FIXNUM(exitcode);
+                code = ecl_make_fixnum(exitcode);
                 pid->foreign.data = NULL;
                 CloseHandle(*hProcess);
         }
@@ -270,16 +270,16 @@ ecl_waitpid(cl_object pid, cl_object wait)
                 code = Cnil;
                 pid = Cnil;
         } else {
-                pid = MAKE_FIXNUM(error);
+                pid = ecl_make_fixnum(error);
                 if (WIFEXITED(code_int)) {
                         status = @':exited';
-                        code = MAKE_FIXNUM(WEXITSTATUS(code_int));
+                        code = ecl_make_fixnum(WEXITSTATUS(code_int));
                 } else if (WIFSIGNALED(code_int)) {
                         status = @':signaled';
-                        code = MAKE_FIXNUM(WTERMSIG(code_int));
+                        code = ecl_make_fixnum(WTERMSIG(code_int));
                 } else if (WIFSTOPPED(code_int)) {
                         status = @':stopped';
-                        code = MAKE_FIXNUM(WSTOPSIG(code_int));
+                        code = ecl_make_fixnum(WSTOPSIG(code_int));
                 } else {
                         status = @':running';
                         code = Cnil;
@@ -295,7 +295,7 @@ si_wait_for_all_processes()
         const cl_env_ptr env = ecl_process_env();
 #if defined(SIGCHLD) && !defined(ECL_WINDOWS_HOST)
         do {
-                cl_object status = ecl_waitpid(MAKE_FIXNUM(-1), Cnil);
+                cl_object status = ecl_waitpid(ecl_make_fixnum(-1), Cnil);
                 cl_object code = env->values[1];
                 cl_object pid = env->values[2];
                 if (Null(pid)) {
@@ -769,7 +769,7 @@ ecl_stream_to_HANDLE(cl_object s, bool output)
         if (child_pid < 0) {
                 pid = Cnil;
         } else {
-                pid = MAKE_FIXNUM(child_pid);
+                pid = ecl_make_fixnum(child_pid);
         }
         set_external_process_pid(process, pid);
 	{
diff --git a/src/c/vector_push.d b/src/c/vector_push.d
index 1ecb5ed5a..f28264808 100644
--- a/src/c/vector_push.d
+++ b/src/c/vector_push.d
@@ -38,9 +38,9 @@ extend_vector(cl_object v, cl_index amount)
 	if (new_length > ADIMLIM)
 		new_length = ADIMLIM;
 	other = si_make_vector(cl_array_element_type(v),
-			       MAKE_FIXNUM(new_length), Ct,
-			       MAKE_FIXNUM(v->vector.fillp),
-			       Cnil, MAKE_FIXNUM(0));
+			       ecl_make_fixnum(new_length), Ct,
+			       ecl_make_fixnum(v->vector.fillp),
+			       Cnil, ecl_make_fixnum(0));
 	ecl_copy_subarray(other, 0, v, 0, v->vector.fillp);
 	return si_replace_array(v, other);
 }
@@ -68,23 +68,23 @@ ecl_string_push_extend(cl_object s, ecl_character c)
 cl_object
 cl_vector_push(cl_object value, cl_object v)
 {
-	cl_index f = fix(cl_fill_pointer(v));
+	cl_index f = ecl_fix(cl_fill_pointer(v));
 	if (f >= v->vector.dim) {
 		@(return Cnil);
 	} else {
 		ecl_aset1(v, v->vector.fillp, value);
-		@(return MAKE_FIXNUM(v->vector.fillp++));
+		@(return ecl_make_fixnum(v->vector.fillp++));
 	}
 }
 
-@(defun vector-push-extend (value v &optional (extent MAKE_FIXNUM(0)))
+@(defun vector-push-extend (value v &optional (extent ecl_make_fixnum(0)))
 @
 {
-	cl_index f = fix(cl_fill_pointer(v));
+	cl_index f = ecl_fix(cl_fill_pointer(v));
 	if (f >= v->vector.dim) {
 		v = extend_vector(v, ecl_to_size(extent));
 	}
 	ecl_aset1(v, v->vector.fillp, value);
-	@(return MAKE_FIXNUM(v->vector.fillp++));
+	@(return ecl_make_fixnum(v->vector.fillp++));
 }
 @)
diff --git a/src/cmp/cmparray.lsp b/src/cmp/cmparray.lsp
index 4bf4d6b09..4baa020d1 100644
--- a/src/cmp/cmparray.lsp
+++ b/src/cmp/cmparray.lsp
@@ -250,14 +250,14 @@
   `(c-inline
     (,array ,index ,limit) (:object :fixnum :fixnum) :void
     "if (ecl_unlikely((#1)>=(#2)))
-           FEwrong_index(Cnil,#0,-1,MAKE_FIXNUM(#1),#2);"
+           FEwrong_index(Cnil,#0,-1,ecl_make_fixnum(#1),#2);"
     :one-liner nil))
 
 (defmacro check-vector-in-bounds (vector index)
   `(c-inline
     (,vector ,index) (:object :fixnum) :void
     "if (ecl_unlikely((#1)>=(#0)->vector.dim))
-           FEwrong_index(Cnil,#0,-1,MAKE_FIXNUM(#1),(#0)->vector.dim);"
+           FEwrong_index(Cnil,#0,-1,ecl_make_fixnum(#1),(#0)->vector.dim);"
     :one-liner nil))
 
 (defconstant +array-dimension-accessor+
diff --git a/src/cmp/cmpffi.lsp b/src/cmp/cmpffi.lsp
index 8fbe11a11..39c936320 100755
--- a/src/cmp/cmpffi.lsp
+++ b/src/cmp/cmpffi.lsp
@@ -55,7 +55,7 @@
     :unsigned-byte
     #2=((unsigned-byte 8) "uint8_t" "ecl_make_uint8_t" "ecl_to_uint8_t" "ecl_fix")
     :fixnum
-    (fixnum "cl_fixnum" "MAKE_FIXNUM" "ecl_to_fixnum" "ecl_fix")
+    (fixnum "cl_fixnum" "ecl_make_fixnum" "ecl_to_fixnum" "ecl_fix")
     :int
     ((integer #.si:c-int-min #.si:c-int-max) "int"
      "ecl_make_int" "ecl_to_int" "ecl_to_int")
diff --git a/src/cmp/cmpnum.lsp b/src/cmp/cmpnum.lsp
index 59f138c48..d832e88d7 100644
--- a/src/cmp/cmpnum.lsp
+++ b/src/cmp/cmpnum.lsp
@@ -184,7 +184,7 @@
 (define-c-inliner / (return-type arg1 &rest arguments &aux arg2)
   (when (null arguments)
     (return (inline-arith-unop return-type arg1
-                               "ecl_divide(MAKE_FIXNUM(1),(#0))" "1/(#0)")))
+                               "ecl_divide(ecl_make_fixnum(1),(#0))" "1/(#0)")))
   (loop for arg2 = (pop arguments)
      for result = (inline-binop return-type arg1 arg2 'rational
 				"ecl_divide(#0,#1)" "(#0)/(#1)")
diff --git a/src/cmp/cmptag.lsp b/src/cmp/cmptag.lsp
index 244733761..748e5a6ea 100644
--- a/src/cmp/cmptag.lsp
+++ b/src/cmp/cmptag.lsp
@@ -157,7 +157,7 @@
 	  (when (and (tag-p tag) (plusp (tag-ref tag)))
 	    (setf (tag-label tag) (next-label))
 	    (setf (tag-unwind-exit tag) label)
-	    (wt-nl "if (cl_env_copy->values[0]==MAKE_FIXNUM(" (tag-index tag) "))")
+	    (wt-nl "if (cl_env_copy->values[0]==ecl_make_fixnum(" (tag-index tag) "))")
 	    (wt-go (tag-label tag))))
 	(when (var-ref-ccb tag-loc)
 	  (wt-nl "ecl_internal_error(\"GO found an inexistent tag\");"))
@@ -214,7 +214,7 @@
   (declare (ignore c1form))
   (if nonlocal
       (let ((var (tag-var tag)))
-	(wt-nl "cl_go(" var ",MAKE_FIXNUM(" (tag-index tag) "));"))
+	(wt-nl "cl_go(" var ",ecl_make_fixnum(" (tag-index tag) "));"))
       ;; local go
       (progn
 	(unwind-no-exit (tag-unwind-exit tag))
diff --git a/src/cmp/cmptop.lsp b/src/cmp/cmptop.lsp
index 45735d7fb..426291e65 100644
--- a/src/cmp/cmptop.lsp
+++ b/src/cmp/cmptop.lsp
@@ -469,7 +469,7 @@ return f2;
       (wt-nl "check_arg(" (length arg-types) ");"))
     (wt-nl "cl_env_copy->nvalues=1;")
     (wt-nl "return " (case return-type
-                            (FIXNUM "MAKE_FIXNUM")
+                            (FIXNUM "ecl_make_fixnum")
                             (CHARACTER "CODE_CHAR")
                             (DOUBLE-FLOAT "ecl_make_doublefloat")
                             (SINGLE-FLOAT "ecl_make_singlefloat")
@@ -857,7 +857,7 @@ return f2;
 					 (<= maxarg si:c-arguments-limit))
 				    maxarg
 				    -1)))
-                     (format stream "~%{0,0,~D,0,MAKE_FIXNUM(~D),MAKE_FIXNUM(~D),(cl_objectfn)~A,Cnil,MAKE_FIXNUM(~D)},"
+                     (format stream "~%{0,0,~D,0,ecl_make_fixnum(~D),ecl_make_fixnum(~D),(cl_objectfn)~A,Cnil,ecl_make_fixnum(~D)},"
                              narg
                              (vv-location loc)
                              (vv-location fname-loc)
diff --git a/src/cmp/cmpwt.lsp b/src/cmp/cmpwt.lsp
index cc6ac3756..4332299cb 100644
--- a/src/cmp/cmpwt.lsp
+++ b/src/cmp/cmpwt.lsp
@@ -214,7 +214,7 @@
   (let* ((*read-default-float-format* 'double-float)
 	 (*print-readably* t))
     (format stream
-	    "ecl_def_ct_ratio(~A,MAKE_FIXNUM(~D),MAKE_FIXNUM(~D),static,const);"
+	    "ecl_def_ct_ratio(~A,ecl_make_fixnum(~D),ecl_make_fixnum(~D),static,const);"
 	    name (numerator value) (denominator value))))
 
 (defun static-constant-delegate (name value stream)
diff --git a/src/cmp/sysfun.lsp b/src/cmp/sysfun.lsp
index 0d7eadc26..0a6e1eeb6 100644
--- a/src/cmp/sysfun.lsp
+++ b/src/cmp/sysfun.lsp
@@ -71,11 +71,11 @@
 ;;;
 
 (def-inline aref :unsafe (t t t) t
- "@0;ecl_aref_unsafe(#0,fix(#1)*(#0)->array.dims[1]+fix(#2))")
+ "@0;ecl_aref_unsafe(#0,ecl_fix(#1)*(#0)->array.dims[1]+ecl_fix(#2))")
 (def-inline aref :unsafe ((array t) t t) t
- "@0;(#0)->array.self.t[fix(#1)*(#0)->array.dims[1]+fix(#2)]")
+ "@0;(#0)->array.self.t[ecl_fix(#1)*(#0)->array.dims[1]+ecl_fix(#2)]")
 (def-inline aref :unsafe ((array bit) t t) :fixnum
- "@0;ecl_aref_bv(#0,fix(#1)*(#0)->array.dims[1]+fix(#2))")
+ "@0;ecl_aref_bv(#0,ecl_fix(#1)*(#0)->array.dims[1]+ecl_fix(#2))")
 (def-inline aref :unsafe ((array t) fixnum fixnum) t
  "@0;(#0)->array.self.t[#1*(#0)->array.dims[1]+#2]")
 (def-inline aref :unsafe ((array bit) fixnum fixnum) :fixnum
@@ -91,8 +91,8 @@
 
 (def-inline aref :always (t t) t "ecl_aref1(#0,ecl_to_size(#1))")
 (def-inline aref :always (t fixnum) t "ecl_aref1(#0,#1)")
-(def-inline aref :unsafe (t t) t "ecl_aref1(#0,fix(#1))")
-(def-inline aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,fix(#1))")
+(def-inline aref :unsafe (t t) t "ecl_aref1(#0,ecl_fix(#1))")
+(def-inline aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fix(#1))")
 (def-inline aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)")
 #+unicode
 (def-inline aref :unsafe ((array character) fixnum) :wchar
@@ -108,9 +108,9 @@
 
 (def-inline row-major-aref :always (t t) t "ecl_aref(#0,ecl_to_size(#1))")
 (def-inline row-major-aref :always (t fixnum) t "ecl_aref(#0,#1)")
-(def-inline row-major-aref :unsafe (t t) t "ecl_aref_unsafe(#0,fix(#1))")
+(def-inline row-major-aref :unsafe (t t) t "ecl_aref_unsafe(#0,ecl_fix(#1))")
 (def-inline row-major-aref :unsafe (t fixnum) t "ecl_aref_unsafe(#0,#1)")
-(def-inline row-major-aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,fix(#1))")
+(def-inline row-major-aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fix(#1))")
 (def-inline row-major-aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)")
 #+unicode
 (def-inline row-major-aref :unsafe ((array character) fixnum) :wchar
@@ -148,12 +148,12 @@
 
 (def-inline si:row-major-aset :always (t t t) t "ecl_aset(#0,ecl_to_size(#1),#2)")
 (def-inline si:row-major-aset :always (t fixnum t) t "ecl_aset(#0,#1,#2)")
-(def-inline si:row-major-aset :unsafe (t t t) t "ecl_aset_unsafe(#0,fix(#1),#2)")
+(def-inline si:row-major-aset :unsafe (t t t) t "ecl_aset_unsafe(#0,ecl_fix(#1),#2)")
 (def-inline si:row-major-aset :unsafe (t fixnum t) t "ecl_aset_unsafe(#0,#1,#2)")
 (def-inline si:row-major-aset :unsafe ((array t) fixnum t) t
  "(#0)->vector.self.t[#1]= #2")
 (def-inline si:row-major-aset :unsafe ((array bit) fixnum t) :fixnum
- "ecl_aset_bv(#0,#1,fix(#2))")
+ "ecl_aset_bv(#0,#1,ecl_fix(#2))")
 (def-inline si:row-major-aset :unsafe ((array bit) fixnum fixnum) :fixnum
  "ecl_aset_bv(#0,#1,#2)")
 (def-inline si:row-major-aset :unsafe ((array base-char) fixnum base-char) :unsigned-char
@@ -205,12 +205,12 @@
 
 (def-inline svref :always (t t) t "ecl_aref1(#0,ecl_to_size(#1))")
 (def-inline svref :always (t fixnum) t "ecl_aref1(#0,#1)")
-(def-inline svref :unsafe (t t) t "(#0)->vector.self.t[fix(#1)]")
+(def-inline svref :unsafe (t t) t "(#0)->vector.self.t[ecl_fix(#1)]")
 (def-inline svref :unsafe (t fixnum) t "(#0)->vector.self.t[#1]")
 
 (def-inline si:svset :always (t t t) t "ecl_aset1(#0,ecl_to_size(#1),#2)")
 (def-inline si:svset :always (t fixnum t) t "ecl_aset1(#0,#1,#2)")
-(def-inline si:svset :unsafe (t t t) t "((#0)->vector.self.t[fix(#1)]=(#2))")
+(def-inline si:svset :unsafe (t t t) t "((#0)->vector.self.t[ecl_fix(#1)]=(#2))")
 (def-inline si:svset :unsafe (t fixnum t) t "(#0)->vector.self.t[#1]= #2")
 
 (def-inline array-has-fill-pointer-p :always (t) :bool "@0;(ECL_ARRAYP(#0)?(void)0:FEtype_error_array(#0),ECL_ARRAY_HAS_FILL_POINTER_P(#0))")
@@ -364,12 +364,12 @@
 
 (def-inline nth :always (t t) t "ecl_nth(ecl_to_size(#0),#1)")
 (def-inline nth :always (fixnum t) t "ecl_nth(#0,#1)")
-(def-inline nth :unsafe (t t) t "ecl_nth(fix(#0),#1)")
+(def-inline nth :unsafe (t t) t "ecl_nth(ecl_fix(#0),#1)")
 (def-inline nth :unsafe (fixnum t) t "ecl_nth(#0,#1)")
 
 (def-inline nthcdr :always (t t) t "ecl_nthcdr(ecl_to_size(#0),#1)")
 (def-inline nthcdr :always (fixnum t) t "ecl_nthcdr(#0,#1)")
-(def-inline nthcdr :unsafe (t t) t "ecl_nthcdr(fix(#0),#1)")
+(def-inline nthcdr :unsafe (t t) t "ecl_nthcdr(ecl_fix(#0),#1)")
 (def-inline nthcdr :unsafe (fixnum t) t "ecl_nthcdr(#0,#1)")
 
 (def-inline last :always (t) t "ecl_last(#0,1)")
@@ -414,7 +414,7 @@
 (def-inline numerator :unsafe (integer) integer "(#0)")
 (def-inline numerator :unsafe (ratio) integer "(#0)->ratio.num")
 
-(def-inline denominator :unsafe (integer) integer "MAKE_FIXNUM(1)")
+(def-inline denominator :unsafe (integer) integer "ecl_make_fixnum(1)")
 (def-inline denominator :unsafe (ratio) integer "(#0)->ratio.den")
 
 (def-inline floor :always (t) (values &rest t) "ecl_floor1(#0)")
@@ -475,7 +475,7 @@
 
 ;; file num_log.d
 
-(def-inline logand :always nil t "MAKE_FIXNUM(-1)")
+(def-inline logand :always nil t "ecl_make_fixnum(-1)")
 (def-inline logand :always nil :fixnum "-1")
 (def-inline logand :always (t t) t "ecl_boole(ECL_BOOLAND,(#0),(#1))")
 (def-inline logand :always (fixnum fixnum) :fixnum "((#0) & (#1))")
@@ -486,12 +486,12 @@
 (def-inline logandc2 :always (t t) t "ecl_boole(ECL_BOOLANDC2,(#0),(#1))")
 (def-inline logandc2 :always (fixnum fixnum) :fixnum "((#0) & ~(#1))")
 
-(def-inline logeqv :always nil t "MAKE_FIXNUM(-1)")
+(def-inline logeqv :always nil t "ecl_make_fixnum(-1)")
 (def-inline logeqv :always nil :fixnum "-1")
 (def-inline logeqv :always (t t) t "ecl_boole(ECL_BOOLEQV,(#0),(#1))")
 (def-inline logeqv :always (fixnum fixnum) :fixnum "(~( (#0) ^ (#1) ))")
 
-(def-inline logior :always nil t "MAKE_FIXNUM(0)")
+(def-inline logior :always nil t "ecl_make_fixnum(0)")
 (def-inline logior :always nil :fixnum "0")
 (def-inline logior :always (t t) t "ecl_boole(ECL_BOOLIOR,(#0),(#1))")
 (def-inline logior :always (fixnum fixnum) :fixnum "((#0) | (#1))")
@@ -502,7 +502,7 @@
 (def-inline lognor :always (t t) t "ecl_boole(ECL_BOOLNOR,(#0),(#1))")
 (def-inline lognor :always (fixnum fixnum) :fixnum "(~( (#0) | (#1) ))")
 
-(def-inline lognot :always (t) t "ecl_boole(ECL_BOOLXOR,(#0),MAKE_FIXNUM(-1))")
+(def-inline lognot :always (t) t "ecl_boole(ECL_BOOLXOR,(#0),ecl_make_fixnum(-1))")
 (def-inline lognot :always (fixnum) :fixnum "(~(#0))")
 
 (def-inline logorc1 :always (t t) t "ecl_boole(ECL_BOOLORC1,(#0),(#1))")
@@ -511,7 +511,7 @@
 (def-inline logorc2 :always (t t) t "ecl_boole(ECL_BOOLORC2,(#0),(#1))")
 (def-inline logorc2 :always (fixnum fixnum) :fixnum "((#0) | ~(#1))")
 
-(def-inline logxor :always nil t "MAKE_FIXNUM(0)")
+(def-inline logxor :always nil t "ecl_make_fixnum(0)")
 (def-inline logxor :always nil :fixnum "0")
 (def-inline logxor :always (t t) t "ecl_boole(ECL_BOOLXOR,(#0),(#1))")
 (def-inline logxor :always (fixnum fixnum) :fixnum "((#0) ^ (#1))")
@@ -599,9 +599,9 @@
 
 (def-inline floatp :always (t) :bool "floatp(#0)")
 
-(def-inline characterp :always (t) :bool "CHARACTERP(#0)")
+(def-inline characterp :always (t) :bool "ECL_CHARACTERP(#0)")
 
-(def-inline base-char-p :always (character) :bool "BASE_CHAR_P(#0)")
+(def-inline base-char-p :always (character) :bool "ECL_BASE_CHAR_P(#0)")
 
 (def-inline stringp :always (t) :bool "@0;ECL_STRINGP(#0)")
 
@@ -617,8 +617,8 @@
 (def-inline eq :always (fixnum fixnum) :bool "(#0)==(#1)")
 
 (def-inline eql :always (t t) :bool "ecl_eql(#0,#1)")
-(def-inline eql :always (character t) :bool "(CODE_CHAR(#0)==(#1))")
-(def-inline eql :always (t character) :bool "((#0)==CODE_CHAR(#1))")
+(def-inline eql :always (character t) :bool "(ECL_CODE_CHAR(#0)==(#1))")
+(def-inline eql :always (t character) :bool "((#0)==ECL_CODE_CHAR(#1))")
 (def-inline eql :always (character character) :bool "(#0)==(#1)")
 (def-inline eql :always ((not (or complex bignum ratio float)) t) :bool
  "(#0)==(#1)")
@@ -655,16 +655,16 @@
 
 ;; file sequence.d
 
-(def-inline elt :always (t t) t "ecl_elt(#0,fix(#1))")
+(def-inline elt :always (t t) t "ecl_elt(#0,ecl_fix(#1))")
 (def-inline elt :always (t fixnum) t "ecl_elt(#0,#1)")
-(def-inline elt :always (vector t) t "ecl_aref1(#0,fix(#1))")
+(def-inline elt :always (vector t) t "ecl_aref1(#0,ecl_fix(#1))")
 (def-inline elt :always (vector fixnum) t "ecl_aref1(#0,#1)")
 
-(def-inline elt :unsafe (t t) t "ecl_elt(#0,fix(#1))")
+(def-inline elt :unsafe (t t) t "ecl_elt(#0,ecl_fix(#1))")
 (def-inline elt :unsafe (t fixnum) t "ecl_elt(#0,#1)")
-(def-inline elt :unsafe (vector t) t "ecl_aref_unsafe(#0,fix(#1))")
+(def-inline elt :unsafe (vector t) t "ecl_aref_unsafe(#0,ecl_fix(#1))")
 (def-inline elt :unsafe (vector fixnum) t "ecl_aref_unsafe(#0,#1)")
-(def-inline aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,fix(#1))")
+(def-inline aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fix(#1))")
 (def-inline aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)")
 #+unicode
 (def-inline aref :unsafe ((array character) fixnum) :wchar
@@ -683,7 +683,7 @@
 (def-inline si:elt-set :always (vector t t) t "ecl_aset1(#0,ecl_to_size(#1),#2)")
 (def-inline si:elt-set :always (vector fixnum t) t "ecl_aset1(#0,#1,#2)")
 
-(def-inline si:elt-set :unsafe (t t t) t "ecl_elt_set(#0,fix(#1),#2)")
+(def-inline si:elt-set :unsafe (t t t) t "ecl_elt_set(#0,ecl_fix(#1),#2)")
 (def-inline si:elt-set :unsafe (vector t t) t "ecl_aset_unsafe(#0,ecl_to_size(#1),#2)")
 (def-inline si:elt-set :unsafe (vector fixnum t) t "ecl_aset_unsafe(#0,#1,#2)")
 
@@ -697,7 +697,7 @@
 (def-inline char :always (t fixnum) t "ecl_aref1(#0,#1)")
 (def-inline char :always (t fixnum) :wchar "ecl_char(#0,#1)")
 #-unicode
-(def-inline char :unsafe (t t) t "CODE_CHAR((#0)->base_string.self[fix(#1)])")
+(def-inline char :unsafe (t t) t "ECL_CODE_CHAR((#0)->base_string.self[ecl_fix(#1)])")
 #-unicode
 (def-inline char :unsafe (t fixnum) :unsigned-char "(#0)->base_string.self[#1]")
 (def-inline char :unsafe (base-string fixnum) :unsigned-char "(#0)->base_string.self[#1]")
@@ -709,23 +709,23 @@
 (def-inline si:char-set :always (t fixnum character) :wchar "ecl_char_set(#0,#1,#2)")
 #-unicode
 (def-inline si:char-set :unsafe (t t t) t
- "@2;((#0)->base_string.self[fix(#1)]=ecl_char_code(#2),(#2))")
+ "@2;((#0)->base_string.self[ecl_fix(#1)]=ecl_char_code(#2),(#2))")
 #-unicode
 (def-inline si:char-set :unsafe (t fixnum character) :unsigned-char
  "(#0)->base_string.self[#1]= #2")
 (def-inline si:char-set :unsafe (base-string t t) t
- "@2;((#0)->base_string.self[fix(#1)]=ecl_char_code(#2),(#2))")
+ "@2;((#0)->base_string.self[ecl_fix(#1)]=ecl_char_code(#2),(#2))")
 (def-inline si:char-set :unsafe (base-string fixnum base-char) :unsigned-char
  "(#0)->base_string.self[#1]= #2")
 (def-inline si:char-set :unsafe (ext:extended-string t t) t
- "@2;((#0)->string.self[fix(#1)]=ecl_char_code(#2),(#2))")
+ "@2;((#0)->string.self[ecl_fix(#1)]=ecl_char_code(#2),(#2))")
 (def-inline si:char-set :unsafe (ext:extended-string fixnum character) :unsigned-char
  "(#0)->string.self[#1]= #2")
 
 (def-inline schar :always (t t) t "ecl_elt(#0,ecl_to_size(#1))")
 (def-inline schar :always (t fixnum) t "ecl_elt(#0,#1)")
 (def-inline schar :always (t fixnum) :wchar "ecl_char(#0,#1)")
-(def-inline schar :unsafe (base-string t) t "CODE_CHAR((#0)->base_string.self[fix(#1)])")
+(def-inline schar :unsafe (base-string t) t "ECL_CODE_CHAR((#0)->base_string.self[ecl_fix(#1)])")
 #-unicode
 (def-inline schar :unsafe (t fixnum) :unsigned-char "(#0)->base_string.self[#1]")
 (def-inline schar :unsafe (base-string fixnum) :unsigned-char "(#0)->base_string.self[#1]")
@@ -737,12 +737,12 @@
 (def-inline si:schar-set :always (t fixnum character) :wchar "ecl_char_set(#0,#1,#2)")
 #-unicode
 (def-inline si:schar-set :unsafe (t t t) t
- "@2;((#0)->base_string.self[fix(#1)]=ecl_char_code(#2),(#2))")
+ "@2;((#0)->base_string.self[ecl_fix(#1)]=ecl_char_code(#2),(#2))")
 #-unicode
 (def-inline si:schar-set :unsafe (t fixnum base-char) :unsigned-char
  "(#0)->base_string.self[#1]= #2")
 (def-inline si:schar-set :unsafe (base-string t t) t
- "@2;((#0)->base_string.self[fix(#1)]=ecl_char_code(#2),(#2))")
+ "@2;((#0)->base_string.self[ecl_fix(#1)]=ecl_char_code(#2),(#2))")
 (def-inline si:schar-set :unsafe (base-string fixnum base-char) :unsigned-char
  "(#0)->base_string.self[#1]= #2")
 #+unicode
@@ -789,13 +789,13 @@
 #+long-float
 (def-inline long-float-p :always (t) :bool "@0;ECL_LONG_FLOAT_P(#0)")
 
-(def-inline ext:fixnump :always (t) :bool "FIXNUMP(#0)")
+(def-inline ext:fixnump :always (t) :bool "ECL_FIXNUMP(#0)")
 (def-inline ext:fixnump :always (fixnum) :bool "1")
 
 (def-inline c::ldb1 :always (fixnum fixnum fixnum) :fixnum
  "((((~((cl_fixnum)-1 << (#0))) << (#1)) & (cl_fixnum)(#2)) >> (#1))")
 (def-inline c::ldb1 :always (fixnum fixnum fixnum) t
- "MAKE_FIXNUM((((~((cl_fixnum)-1 << (#0))) << (#1)) & (cl_fixnum)(#2)) >> (#1))")
+ "ecl_make_fixnum((((~((cl_fixnum)-1 << (#0))) << (#1)) & (cl_fixnum)(#2)) >> (#1))")
 
 ;; Functions only available with threads
 #+threads
diff --git a/src/cmp/test.lsp b/src/cmp/test.lsp
index 814c0a088..a76ad4394 100644
--- a/src/cmp/test.lsp
+++ b/src/cmp/test.lsp
@@ -1,4 +1,4 @@
-;;;;  -*- Mode: Lisp; Syntax: Common-Lisp; Package: C -*-
+y;;;;  -*- Mode: Lisp; Syntax: Common-Lisp; Package: C -*-
 ;;;;
 
 (in-package 'system)
diff --git a/src/h/external.h b/src/h/external.h
index c4dc09d15..f37ad434a 100755
--- a/src/h/external.h
+++ b/src/h/external.h
@@ -1026,21 +1026,21 @@ extern ECL_API cl_object ecl_make_unsigned_integer(cl_index i);
 extern ECL_API int ecl_to_bit(cl_object o);
 extern ECL_API ecl_uint8_t ecl_to_uint8_t(cl_object o);
 extern ECL_API ecl_int8_t ecl_to_int8_t(cl_object o);
-#define ecl_make_uint8_t(i) MAKE_FIXNUM(i)
-#define ecl_make_int8_t(i) MAKE_FIXNUM(i)
+#define ecl_make_uint8_t(i) ecl_make_fixnum(i)
+#define ecl_make_int8_t(i) ecl_make_fixnum(i)
 #if FIXNUM_BITS < 32
 # error "Unsupported platforms with FIXNUM_BITS < 32"
 #endif
 #ifdef ecl_uint16_t
 extern ECL_API ecl_uint16_t ecl_to_uint16_t(cl_object o);
 extern ECL_API ecl_int16_t ecl_to_int16_t(cl_object o);
-# define ecl_make_uint16_t(i) MAKE_FIXNUM(i)
-# define ecl_make_int16_t(i) MAKE_FIXNUM(i)
+# define ecl_make_uint16_t(i) ecl_make_fixnum(i)
+# define ecl_make_int16_t(i) ecl_make_fixnum(i)
 #endif /* ecl_uint16_t */
 extern ECL_API unsigned short ecl_to_ushort(cl_object o);
 extern ECL_API short ecl_to_short(cl_object o);
-#define ecl_make_short(n) MAKE_FIXNUM(n)
-#define ecl_make_ushort(n) MAKE_FIXNUM(n)
+#define ecl_make_short(n) ecl_make_fixnum(n)
+#define ecl_make_ushort(n) ecl_make_fixnum(n)
 #ifdef ecl_uint32_t
 # if FIXNUM_BITS == 32
 #  define ecl_to_uint32_t fixnnint
@@ -1048,8 +1048,8 @@ extern ECL_API short ecl_to_short(cl_object o);
 #  define ecl_make_uint32_t ecl_make_unsigned_integer
 #  define ecl_make_int32_t ecl_make_integer
 # else
-#  define ecl_make_uint32_t(i) MAKE_FIXNUM(i)
-#  define ecl_make_int32_t(i) MAKE_FIXNUM(i)
+#  define ecl_make_uint32_t(i) ecl_make_fixnum(i)
+#  define ecl_make_int32_t(i) ecl_make_fixnum(i)
 extern ECL_API ecl_uint32_t ecl_to_uint32_t(cl_object o);
 extern ECL_API ecl_int32_t ecl_to_int32_t(cl_object o);
 # endif
@@ -1398,6 +1398,7 @@ extern ECL_API cl_object si_fixnump(cl_object x);
 
 extern ECL_API bool floatp(cl_object x);
 extern ECL_API bool ecl_numberp(cl_object x);
+extern ECL_API bool ecl_realp(cl_object x);
 extern ECL_API bool ecl_eql(cl_object x, cl_object y);
 extern ECL_API bool ecl_equal(register cl_object x, cl_object y);
 extern ECL_API bool ecl_equalp(cl_object x, cl_object y);
diff --git a/src/h/impl/math_dispatch.h b/src/h/impl/math_dispatch.h
index fb1cfcae3..fe3cfee81 100644
--- a/src/h/impl/math_dispatch.h
+++ b/src/h/impl/math_dispatch.h
@@ -40,7 +40,7 @@ typedef cl_object (*math_one_arg_fn)(cl_object);
         complex };                                                      \
     cl_object ecl_##name(cl_object arg)                                 \
     {                                                                   \
-        int t = IMMEDIATE(arg);                                         \
+        int t = ECL_IMMEDIATE(arg);                                         \
         if (t == 0) {                                                   \
             t = arg->d.t;                                               \
             unlikely_if (t > t_complex) return name##failed(arg);       \
@@ -73,7 +73,7 @@ typedef int (*math_one_arg_bool_fn)(cl_object);
         complex };                                                      \
     int ecl_##name(cl_object arg)                                       \
     {                                                                   \
-        int t = IMMEDIATE(arg);                                         \
+        int t = ECL_IMMEDIATE(arg);                                         \
         if (t == 0) {                                                   \
             t = arg->d.t;                                               \
             unlikely_if (t > t_complex) return name##failed(arg);       \
diff --git a/src/h/legacy.h b/src/h/legacy.h
index 572aa367f..4b0a40259 100644
--- a/src/h/legacy.h
+++ b/src/h/legacy.h
@@ -19,6 +19,21 @@
 /*
  * LEGACY
  */
+#define CHARACTERP(o)		ECL_CHARACTERP(o)
+#define BASE_CHAR_P(o)		ECL_BASE_CHAR_P(o)
+#define BASE_CHAR_CODE_P(o)	ECL_BASE_CHAR_CODE_P(o)
+#define CODE_CHAR(o)		ECL_CODE_CHAR(o)
+#define CHAR_CODE(o)		ECL_CHAR_CODE(o)
+#define REAL_TYPE(t)		ECL_REAL_TYPE_P(t)
+#define IMMEDIATE(o)		ECL_IMMEDIATE(o)
+#define IMMEDIATE_TAG		ECL_IMMEDIATE_TAG
+
+#define FIXNUM_TAG		t_fixnum
+#define MAKE_FIXNUM(n)		ecl_make_fixnum(n)
+#define FIXNUM_MINUSP(n)	ecl_fixnum_minusp(n)
+#define FIXNUM_PLUSP(n)		ecl_fixnum_plusp(n)
+#define	fix(o)			ecl_fix(o)
+#define FIXNUMP(o)		ECL_FINXUMP(o)
 
 #define make_shortfloat(x) ecl_make_shortfloat(x);
 #define cl_def_c_function_va(sym,function) ecl_def_c_function_va(sym,function)
@@ -35,6 +50,7 @@
 #define si_bc_file(o) si_compiled_function_file(o)
 #define ARRAYP ECL_ARRAYP
 #define VECTORP ECL_VECTORP
+#define ARRAY_TYPE(t) (t >= t_array && t <= t_bitvector)
 #define c_string_to_object ecl_read_from_cstring
 
 #define big_register0_get _ecl_big_register0
diff --git a/src/h/object.h b/src/h/object.h
index 71b58ce84..74fdc0eb5 100644
--- a/src/h/object.h
+++ b/src/h/object.h
@@ -119,90 +119,85 @@ typedef cl_object (*cl_objectfn_fixed)();
 */
 
 #define ECL_TAG_BITS		2
-#define IMMEDIATE(o)		((cl_fixnum)(o) & 3)
-#define IMMEDIATE_TAG		3
+#define ECL_IMMEDIATE(o)	((cl_fixnum)(o) & 3)
+#define ECL_IMMEDIATE_TAG	3
 
 #define ecl_to_bool(x) ((x)!=Cnil)
 #define ecl_make_bool(x) ((x)? Ct : Cnil)
 
 /* Immediate fixnums:		*/
-#define FIXNUM_TAG		t_fixnum
-#define MAKE_FIXNUM(n)		((cl_object)(((cl_fixnum)(n) << 2) | FIXNUM_TAG))
-#define FIXNUM_MINUSP(n)	((cl_fixnum)(n) < 0)
-#define FIXNUM_PLUSP(n)		((cl_fixnum)(n) >= (cl_fixnum)MAKE_FIXNUM(0))
-#define	fix(obje)		(((cl_fixnum)(obje)) >> 2)
-#define FIXNUMP(o)		(IMMEDIATE(o) == t_fixnum)
-
-#define ECL_FIXNUMP(o)          (IMMEDIATE(o) == t_fixnum)
+#define ECL_FIXNUM_TAG		t_fixnum
+#define ECL_FIXNUMP(o)          (ECL_IMMEDIATE(o) == t_fixnum)
+#define ecl_make_fixnum(n)	((cl_object)(((cl_fixnum)(n) << 2) | t_fixnum))
 #define ecl_fixnum_lower(a,b)   ((cl_fixnum)(a) < (cl_fixnum)(b))
 #define ecl_fixnum_greater(a,b) ((cl_fixnum)(a) > (cl_fixnum)(b))
 #define ecl_fixnum_leq(a,b)     ((cl_fixnum)(a) <= (cl_fixnum)(b))
 #define ecl_fixnum_geq(a,b)     ((cl_fixnum)(a) >= (cl_fixnum)(b))
-#define ecl_fixnum_plusp(a)     ((cl_fixnum)(a) > (cl_fixnum)MAKE_FIXNUM(0))
+#define ecl_fixnum_plusp(a)     ((cl_fixnum)(a) > (cl_fixnum)ecl_make_fixnum(0))
 #define ecl_fixnum_minusp(a)    ((cl_fixnum)(a) < (cl_fixnum)(0))
 #define ecl_fix(a)              (((cl_fixnum)(a)) >> 2)
 
 /* Immediate characters:	*/
-#define CHARACTER_TAG		t_character
-#define CHARACTERP(o)		(IMMEDIATE(o) == t_character)
+#define ECL_CHARACTER_TAG	t_character
+#define ECL_CHARACTERP(o)	(ECL_IMMEDIATE(o) == t_character)
 #ifdef ECL_UNICODE
-#define BASE_CHAR_P(obje)	((((cl_fixnum)(obje)) & 0xFFFFFC03) == CHARACTER_TAG)
-#define BASE_CHAR_CODE_P(x)	((x & ~((cl_fixnum)0xFF)) == 0)
-#define	CODE_CHAR(c)		((cl_object)(((cl_fixnum)(c << 2)|CHARACTER_TAG)))
-#define	CHAR_CODE(obje)		(((cl_fixnum)(obje)) >> 2)
+#define ECL_BASE_CHAR_P(obje)	((((cl_fixnum)(obje)) & 0xFFFFFC03) == ECL_CHARACTER_TAG)
+#define ECL_BASE_CHAR_CODE_P(x)	((x & ~((cl_fixnum)0xFF)) == 0)
+#define	ECL_CODE_CHAR(c)	((cl_object)(((cl_fixnum)(c << 2)|ECL_CHARACTER_TAG)))
+#define	ECL_CHAR_CODE(obje)	(((cl_fixnum)(obje)) >> 2)
 #else
-#define	CODE_CHAR(c)		((cl_object)(((cl_fixnum)((c & 0xff) << 2)|CHARACTER_TAG)))
-#define	CHAR_CODE(obje)		((((cl_fixnum)(obje)) >> 2) & 0xff)
+#define ECL_BASE_CHAR_P(o)	ECL_CHARACTERP(o)
+#define	ECL_CODE_CHAR(c)	((cl_object)(((cl_fixnum)((c & 0xff) << 2)|ECL_CHARACTER_TAG)))
+#define	ECL_CHAR_CODE(obje)	((((cl_fixnum)(obje)) >> 2) & 0xff)
 #endif
 #define ECL_CHAR_CODE_RETURN	13
 #define ECL_CHAR_CODE_NEWLINE	10
 #define ECL_CHAR_CODE_LINEFEED	10
 
 #define ECL_NUMBER_TYPE_P(t)	(t >= t_fixnum && t <= t_complex)
-#define REAL_TYPE(t)		(t >= t_fixnum && t < t_complex)
-#define ARRAY_TYPE(t)		(t >= t_array && t <= t_bitvector)
-#define ECL_ARRAYP(x)		((IMMEDIATE(x) == 0) && (x)->d.t >= t_array && (x)->d.t <= t_bitvector)
-#define ECL_VECTORP(x)		((IMMEDIATE(x) == 0) && (x)->d.t >= t_vector && (x)->d.t <= t_bitvector)
-#define ECL_BIT_VECTOR_P(x)     ((IMMEDIATE(x) == 0) && ((x)->d.t == t_bitvector))
+#define ECL_REAL_TYPE_P(t)	(t >= t_fixnum && t < t_complex)
+#define ECL_ARRAYP(x)		((ECL_IMMEDIATE(x) == 0) && (x)->d.t >= t_array && (x)->d.t <= t_bitvector)
+#define ECL_VECTORP(x)		((ECL_IMMEDIATE(x) == 0) && (x)->d.t >= t_vector && (x)->d.t <= t_bitvector)
+#define ECL_BIT_VECTOR_P(x)     ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_bitvector))
 #ifdef ECL_UNICODE
-#define ECL_STRINGP(x)		((IMMEDIATE(x) == 0) && \
+#define ECL_STRINGP(x)		((ECL_IMMEDIATE(x) == 0) && \
                                  ((x)->d.t == t_base_string || (x)->d.t == t_string))
-#define ECL_EXTENDED_STRING_P(x) ((IMMEDIATE(x) == 0) && (x)->d.t == t_string)
+#define ECL_EXTENDED_STRING_P(x) ((ECL_IMMEDIATE(x) == 0) && (x)->d.t == t_string)
 #else
-#define ECL_STRINGP(x)		((IMMEDIATE(x) == 0) && ((x)->d.t == t_base_string))
+#define ECL_STRINGP(x)		((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_base_string))
 #define ECL_EXTENDED_STRING_P(x) 0
 #endif
-#define ECL_BASE_STRING_P(x)	((IMMEDIATE(x) == 0) && ((x)->d.t == t_base_string))
-#define ECL_HASH_TABLE_P(x)	((IMMEDIATE(x) == 0) && ((x)->d.t == t_hashtable))
-#define ECL_BIGNUMP(x)          ((IMMEDIATE(x) == 0) && ((x)->d.t == t_bignum))
-#define ECL_COMPLEXP(x)         ((IMMEDIATE(x) == 0) && ((x)->d.t == t_complex))
-#define ECL_RANDOM_STATE_P(x)   ((IMMEDIATE(x) == 0) && ((x)->d.t == t_random))
-#define ECL_SINGLE_FLOAT_P(x)   ((IMMEDIATE(x) == 0) && ((x)->d.t == t_singlefloat))
-#define ECL_DOUBLE_FLOAT_P(x)   ((IMMEDIATE(x) == 0) && ((x)->d.t == t_doublefloat))
+#define ECL_BASE_STRING_P(x)	((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_base_string))
+#define ECL_HASH_TABLE_P(x)	((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_hashtable))
+#define ECL_BIGNUMP(x)          ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_bignum))
+#define ECL_COMPLEXP(x)         ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_complex))
+#define ECL_RANDOM_STATE_P(x)   ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_random))
+#define ECL_SINGLE_FLOAT_P(x)   ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_singlefloat))
+#define ECL_DOUBLE_FLOAT_P(x)   ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_doublefloat))
 #ifdef ECL_LONG_FLOAT
-#define ECL_LONG_FLOAT_P(x)     ((IMMEDIATE(x) == 0) && ((x)->d.t == t_longfloat))
+#define ECL_LONG_FLOAT_P(x)     ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_longfloat))
 #endif
-#define ECL_PACKAGEP(x)         ((IMMEDIATE(x) == 0) && ((x)->d.t == t_package))
-#define ECL_PATHNAMEP(x)        ((IMMEDIATE(x) == 0) && ((x)->d.t == t_pathname))
-#define ECL_READTABLEP(x)       ((IMMEDIATE(x) == 0) && ((x)->d.t == t_readtable))
-#define ECL_FOREIGN_DATA_P(x)   ((IMMEDIATE(x) == 0) && ((x)->d.t == t_foreign))
+#define ECL_PACKAGEP(x)         ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_package))
+#define ECL_PATHNAMEP(x)        ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_pathname))
+#define ECL_READTABLEP(x)       ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_readtable))
+#define ECL_FOREIGN_DATA_P(x)   ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_foreign))
 #ifdef ECL_SSE2
-#define ECL_SSE_PACK_P(x)       ((IMMEDIATE(x) == 0) && ((x)->d.t == t_sse_pack))
+#define ECL_SSE_PACK_P(x)       ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_sse_pack))
 #endif
 
-#define HEADER			int8_t t, m, padding1, padding2
-#define HEADER1(field)		int8_t t, m, field, padding
-#define HEADER2(field1,field2)	int8_t t, m, field1, field2
+#define _ECL_HDR			int8_t t, m, padding1, padding2
+#define _ECL_HDR1(field)		int8_t t, m, field, padding
+#define _ECL_HDR2(field1,field2)	int8_t t, m, field1, field2
 
 struct ecl_singlefloat {
-	HEADER;
+	_ECL_HDR;
 	float SFVAL;	/*  singlefloat value  */
 };
 #define	sf(obje)	(obje)->SF.SFVAL
 #define ecl_single_float(o) ((o)->SF.SFVAL)
 
 struct ecl_doublefloat {
-	HEADER;
+	_ECL_HDR;
 	double DFVAL;	/*  doublefloat value  */
 };
 #define	df(obje)	(obje)->DF.DFVAL
@@ -210,14 +205,14 @@ struct ecl_doublefloat {
 
 #ifdef ECL_LONG_FLOAT
 struct ecl_long_float {
-	HEADER;
+	_ECL_HDR;
 	long double value;
 };
 #define ecl_long_float(o) ((o)->longfloat.value)
 #endif
 
 struct ecl_bignum {
-	HEADER;
+	_ECL_HDR;
 	mpz_t big_num;
 };
 #define big_dim		big_num->_mp_alloc
@@ -225,7 +220,7 @@ struct ecl_bignum {
 #define big_limbs	big_num->_mp_d
 
 struct ecl_ratio {
-	HEADER;
+	_ECL_HDR;
 	cl_object den;		/*  denominator, must be an integer  */
 	cl_object num;		/*  numerator, must be an integer  */
 };
@@ -234,7 +229,7 @@ struct ecl_ratio {
 #undef complex			/* Otherwise we cannot do x->complex.real */
 #endif
 struct ecl_complex {
-	HEADER;
+	_ECL_HDR;
 	cl_object real;		/*  real part, must be a number  */
 	cl_object imag;		/*  imaginary part, must be a number  */
 };
@@ -257,7 +252,7 @@ enum ecl_stype {		/*  symbol type  */
 #define ECLF_LAG_SPECIAL_VAR  4
 
 struct ecl_symbol {
-	HEADER2(stype, dynamic);/*  symbol type, special-variable-p */
+	_ECL_HDR2(stype, dynamic);/*  symbol type, special-variable-p */
 	cl_object value;	/*  global value of the symbol  */
 				/*  Coincides with cons.car  */
 	cl_object gfdef;	/*  global function definition  */
@@ -277,7 +272,7 @@ struct ecl_symbol {
 #define SYM_FUN(sym)	((sym)->symbol.gfdef)
 
 struct ecl_package {
-	HEADER1(locked);
+	_ECL_HDR1(locked);
 	cl_object name;		/*  package name, a string  */
 	cl_object nicknames;	/*  nicknames, list of strings  */
 	cl_object shadowings;	/*  shadowing symbol list  */
@@ -315,15 +310,15 @@ struct ecl_package {
  */
 
 #ifdef ECL_SMALL_CONS
-#define ECL_LISTP(x)    (IMMEDIATE(x) == t_list)
+#define ECL_LISTP(x)    (ECL_IMMEDIATE(x) == t_list)
 #define ECL_CONSP(x)    (LISTP(x) && !Null(x))
 #define ECL_ATOM(x)     (Null(x) || !LISTP(x))
-#define ECL_SYMBOLP(x)  (Null(x) || ((IMMEDIATE(x) == 0) && ((x)->d.t == t_symbol)))
+#define ECL_SYMBOLP(x)  (Null(x) || ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_symbol)))
 
-#define LISTP(x)	(IMMEDIATE(x) == t_list)
+#define LISTP(x)	(ECL_IMMEDIATE(x) == t_list)
 #define CONSP(x)	(LISTP(x) && !Null(x))
 #define ATOM(x)		(Null(x) || !LISTP(x))
-#define SYMBOLP(x)	(Null(x) || ((IMMEDIATE(x) == 0) && ((x)->d.t == t_symbol)))
+#define SYMBOLP(x)	(Null(x) || ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_symbol)))
 
 #define ECL_PTR_CONS(x)	(cl_object)((char*)(x) + t_list)
 #define ECL_CONS_PTR(x)	((struct ecl_cons *)((char *)(x) - t_list))
@@ -337,15 +332,15 @@ struct ecl_cons {
 	cl_object cdr;		/*  cdr  */
 };
 #else
-#define ECL_LISTP(x)    (IMMEDIATE(x)? Null(x) : ((x)->d.t == t_list))
-#define ECL_CONSP(x)    ((IMMEDIATE(x) == 0) && ((x)->d.t == t_list))
-#define ECL_ATOM(x)     (IMMEDIATE(x) || ((x)->d.t != t_list))
-#define ECL_SYMBOLP(x)  (Null(x) || ((IMMEDIATE(x) == 0) && ((x)->d.t == t_symbol)))
+#define ECL_LISTP(x)    (ECL_IMMEDIATE(x)? Null(x) : ((x)->d.t == t_list))
+#define ECL_CONSP(x)    ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_list))
+#define ECL_ATOM(x)     (ECL_IMMEDIATE(x) || ((x)->d.t != t_list))
+#define ECL_SYMBOLP(x)  (Null(x) || ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_symbol)))
 
-#define LISTP(x)	(IMMEDIATE(x)? Null(x) : ((x)->d.t == t_list))
-#define CONSP(x)	((IMMEDIATE(x) == 0) && ((x)->d.t == t_list))
-#define ATOM(x)		(IMMEDIATE(x) || ((x)->d.t != t_list))
-#define SYMBOLP(x)	(Null(x) || ((IMMEDIATE(x) == 0) && ((x)->d.t == t_symbol)))
+#define LISTP(x)	(ECL_IMMEDIATE(x)? Null(x) : ((x)->d.t == t_list))
+#define CONSP(x)	((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_list))
+#define ATOM(x)		(ECL_IMMEDIATE(x) || ((x)->d.t != t_list))
+#define SYMBOLP(x)	(Null(x) || ((ECL_IMMEDIATE(x) == 0) && ((x)->d.t == t_symbol)))
 
 #define ECL_CONS_CAR(x)	((x)->cons.car)
 #define ECL_CONS_CDR(x)	((x)->cons.cdr)
@@ -353,7 +348,7 @@ struct ecl_cons {
 #define ECL_RPLACD(x,v)	(ECL_CONS_CDR(x)=(v))
 
 struct ecl_cons {
-	HEADER;
+	_ECL_HDR;
 	cl_object car;		/*  car  */
 	cl_object cdr;		/*  cdr  */
 };
@@ -380,7 +375,7 @@ struct ecl_hashtable_entry {	/*  hash table entry  */
 };
 
 struct ecl_hashtable {		/*  hash table header  */
-	HEADER2(test,weak);
+	_ECL_HDR2(test,weak);
 	struct ecl_hashtable_entry *data; /*  pointer to the hash table  */
 	cl_index entries;	/*  number of entries  */
 	cl_index size;		/*  hash table size  */
@@ -454,7 +449,7 @@ union ecl_array_data {
 struct ecl_array {		/*  array header  */
 				/*  adjustable flag  */
 				/*  has-fill-pointer flag  */
-	HEADER2(elttype,flags);	/*  array element type, has fill ptr, adjustable-p */
+	_ECL_HDR2(elttype,flags);	/*  array element type, has fill ptr, adjustable-p */
 	cl_object displaced;	/*  displaced  */
 	cl_index dim;		/*  dimension  */
 	cl_index *dims;		/*  table of dimensions  */
@@ -466,7 +461,7 @@ struct ecl_array {		/*  array header  */
 struct ecl_vector {		/*  vector header  */
 				/*  adjustable flag  */
 				/*  has-fill-pointer flag  */
-	HEADER2(elttype,flags);	/*  array element type, has fill ptr, adjustable-p */
+	_ECL_HDR2(elttype,flags);	/*  array element type, has fill ptr, adjustable-p */
 	cl_object displaced;	/*  displaced  */
 	cl_index dim;		/*  dimension  */
 	cl_index fillp;		/*  fill pointer  */
@@ -479,7 +474,7 @@ struct ecl_vector {		/*  vector header  */
 struct ecl_base_string {	/*  string header  */
 				/*  adjustable flag  */
 				/*  has-fill-pointer flag  */
-	HEADER2(elttype,flags);	/*  array element type, has fill ptr, adjustable-p */
+	_ECL_HDR2(elttype,flags);	/*  array element type, has fill ptr, adjustable-p */
 	cl_object displaced;	/*  displaced  */
 	cl_index dim;       	/*  dimension  */
 				/*  string length  */
@@ -493,7 +488,7 @@ struct ecl_base_string {	/*  string header  */
 struct ecl_string {		/*  string header  */
 				/*  adjustable flag  */
 				/*  has-fill-pointer flag  */
-	HEADER2(elttype,flags);	/*  array element type, has fill ptr, adjustable-p */
+	_ECL_HDR2(elttype,flags);	/*  array element type, has fill ptr, adjustable-p */
 	cl_object displaced;	/*  displaced  */
 	cl_index dim;       	/*  dimension  */
 				/*  string length  */
@@ -513,7 +508,7 @@ struct ecl_string {		/*  string header  */
 #define SNAME(x)	CLASS_NAME(CLASS_OF(x))
 #else
 struct ecl_structure {		/*  structure header  */
-	HEADER;
+	_ECL_HDR;
 	cl_object name;		/*  structure name  */
 	cl_object *self;	/*  structure self  */
 	cl_fixnum length;	/*  structure length  */
@@ -621,12 +616,12 @@ typedef int (*cl_eformat_encoder)(cl_object stream, unsigned char *buffer, int c
 typedef cl_index (*cl_eformat_read_byte8)(cl_object object, unsigned char *buffer, cl_index n);
 
 #define ECL_ANSI_STREAM_P(o) \
-        (IMMEDIATE(o) == 0 && ((o)->d.t == t_stream))
+        (ECL_IMMEDIATE(o) == 0 && ((o)->d.t == t_stream))
 #define ECL_ANSI_STREAM_TYPE_P(o,m) \
-        (IMMEDIATE(o) == 0 && ((o)->d.t == t_stream) && ((o)->stream.mode == (m)))
+        (ECL_IMMEDIATE(o) == 0 && ((o)->d.t == t_stream) && ((o)->stream.mode == (m)))
 
 struct ecl_stream {
-	HEADER2(mode,closed);	/*  stream mode of enum smmode  */
+	_ECL_HDR2(mode,closed);	/*  stream mode of enum smmode  */
 				/*  closed stream?  */
 	struct ecl_file_ops *ops; /*  dispatch table  */
         union {
@@ -652,7 +647,7 @@ struct ecl_stream {
 };
 
 struct ecl_random {
-	HEADER;
+	_ECL_HDR;
 	cl_object value;	/*  random state value  */
 };
 
@@ -678,7 +673,7 @@ enum ecl_readtable_case {
 };
 
 struct ecl_readtable {		/*  read table  */
-	HEADER1(locked);
+	_ECL_HDR1(locked);
 	enum ecl_readtable_case read_case; /*  readtable-case  */
 	struct ecl_readtable_entry *table; /*  read table itself  */
 #ifdef ECL_UNICODE
@@ -687,7 +682,7 @@ struct ecl_readtable {		/*  read table  */
 };
 
 struct ecl_pathname {
-	HEADER1(logical);	/*  logical pathname?  */
+	_ECL_HDR1(logical);	/*  logical pathname?  */
 	cl_object host;		/*  host  */
 	cl_object device;	/*  device  */
 	cl_object directory;	/*  directory  */
@@ -697,7 +692,7 @@ struct ecl_pathname {
 };
 
 struct ecl_codeblock {
-	HEADER2(self_destruct,locked);	/*  delete DLL after gc */
+	_ECL_HDR2(self_destruct,locked);	/*  delete DLL after gc */
 					/*  do not garbage collect this library */
 	void	*handle;		/*  handle returned by dlopen  */
 	void	*entry;			/*  entry point  */
@@ -717,7 +712,7 @@ struct ecl_codeblock {
 };
 
 struct ecl_bytecodes {
-	HEADER;
+	_ECL_HDR;
 	cl_object name;		/*  function name  */
 	cl_object definition;	/*  function definition in list form  */
 	cl_objectfn entry;	/*  entry address (must match the position of
@@ -730,14 +725,14 @@ struct ecl_bytecodes {
 };
 
 struct ecl_bclosure {
-	HEADER;
+	_ECL_HDR;
 	cl_object code;
 	cl_object lex;
 	cl_objectfn entry;	/*  entry address  */
 };
 
 struct ecl_cfun {		/*  compiled function header  */
-	HEADER1(narg);
+	_ECL_HDR1(narg);
 	cl_object name;		/*  compiled function name  */
 	cl_object block;	/*  descriptor of C code block for GC  */
 	cl_objectfn entry;	/*  entry address  */
@@ -746,7 +741,7 @@ struct ecl_cfun {		/*  compiled function header  */
 };
 
 struct ecl_cfunfixed {		/*  compiled function header  */
-	HEADER1(narg);
+	_ECL_HDR1(narg);
 	cl_object name;		/*  compiled function name  */
 	cl_object block;	/*  descriptor of C code block for GC  */
 	cl_objectfn entry;	/*  entry address (must match the position of
@@ -757,7 +752,7 @@ struct ecl_cfunfixed {		/*  compiled function header  */
 };
 
 struct ecl_cclosure {		/*  compiled closure header  */
-	HEADER;
+	_ECL_HDR;
 	cl_object env;		/*  environment  */
 	cl_object block;	/*  descriptor of C code block for GC  */
 	cl_objectfn entry;	/*  entry address (must match the position of
@@ -852,14 +847,14 @@ enum ecl_ffi_calling_convention {
 };
 
 struct ecl_foreign {		/*  user defined datatype  */
-	HEADER;
+	_ECL_HDR;
 	cl_object tag;		/*  a tag identifying the type  */
 	cl_index size;		/*  the amount of memory allocated  */
 	char *data;		/*  the data itself  */
 };
 
 struct ecl_stack_frame {
-	HEADER;
+	_ECL_HDR;
 	cl_object *stack;	/*  Is this relative to the lisp stack?  */
 	cl_object *base;	/*  Start of frame  */
         cl_index size;		/*  Number of arguments  */
@@ -867,7 +862,7 @@ struct ecl_stack_frame {
 };
 
 struct ecl_weak_pointer {	/*  weak pointer to value  */
-	HEADER;
+	_ECL_HDR;
 	cl_object value;
 };
 
@@ -875,7 +870,7 @@ struct ecl_weak_pointer {	/*  weak pointer to value  */
 	dummy type
 */
 struct ecl_dummy {
-	HEADER;
+	_ECL_HDR;
 };
 
 #ifdef ECL_THREADS
@@ -886,7 +881,7 @@ enum {
         ECL_PROCESS_EXITING
 };
 struct ecl_process {
-	HEADER;
+	_ECL_HDR;
 	cl_object name;
 	cl_object function;
 	cl_object args;
@@ -909,13 +904,13 @@ struct ecl_process {
 #define ECL_WAKEUP_KILL 4
 
 struct ecl_queue {
-	HEADER;
+	_ECL_HDR;
 	cl_object list;
 	cl_object spinlock;
 };
 
 struct ecl_semaphore {
-	HEADER;
+	_ECL_HDR;
 	cl_object queue_list;
 	cl_object queue_spinlock;
         cl_object name;
@@ -923,7 +918,7 @@ struct ecl_semaphore {
 };
 
 struct ecl_barrier {
-	HEADER;
+	_ECL_HDR;
 	cl_object queue_list;
 	cl_object queue_spinlock;
         cl_object name;
@@ -932,7 +927,7 @@ struct ecl_barrier {
 };
 
 struct ecl_lock {
-	HEADER1(recursive);
+	_ECL_HDR1(recursive);
 	cl_object queue_list;
 	cl_object queue_spinlock;
         cl_object owner;       /* thread holding the lock or NIL */
@@ -941,7 +936,7 @@ struct ecl_lock {
 };
 
 struct ecl_mailbox {
-	HEADER;
+	_ECL_HDR;
 	cl_object name;
         cl_object data;
         cl_object reader_semaphore;
@@ -952,7 +947,7 @@ struct ecl_mailbox {
 };
 
 struct ecl_rwlock {
-	HEADER;
+	_ECL_HDR;
         cl_object name;
 #ifdef ECL_RWLOCK
         pthread_rwlock_t mutex;
@@ -962,7 +957,7 @@ struct ecl_rwlock {
 };
 
 struct ecl_condition_variable {
-        HEADER;
+        _ECL_HDR;
 	cl_object queue_list;
 	cl_object queue_spinlock;
 	cl_object lock;
@@ -978,7 +973,7 @@ struct ecl_condition_variable {
 #define CLASS_INFERIORS(x)	(x)->instance.slots[3+2]
 #define CLASS_SLOTS(x)		(x)->instance.slots[3+3]
 #define CLASS_CPL(x)		(x)->instance.slots[3+4]
-#define ECL_INSTANCEP(x)	((IMMEDIATE(x)==0) && ((x)->d.t==t_instance))
+#define ECL_INSTANCEP(x)	((ECL_IMMEDIATE(x)==0) && ((x)->d.t==t_instance))
 #define ECL_NOT_FUNCALLABLE	0
 #define ECL_STANDARD_DISPATCH	1
 #define ECL_RESTRICTED_DISPATCH	2
@@ -987,7 +982,7 @@ struct ecl_condition_variable {
 #define ECL_USER_DISPATCH	5
 
 struct ecl_instance {		/*  instance header  */
-	HEADER1(isgf);
+	_ECL_HDR1(isgf);
 	cl_index length;	/*  instance length  */
 	cl_object clas;		/*  instance class  */
 	cl_objectfn entry;	/*  entry address  */
@@ -1025,7 +1020,7 @@ union ecl_sse_data {
 };
 
 struct ecl_sse_pack {
-	HEADER1(elttype);
+	_ECL_HDR1(elttype);
 	union ecl_sse_data data;
 };
 #endif
@@ -1094,12 +1089,12 @@ union cl_lispunion {
 */
 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
 static inline cl_type type_of(cl_object o) {
-	int i = IMMEDIATE(o);
+	int i = ECL_IMMEDIATE(o);
 	return (i? (cl_type)i : (cl_type)(o->d.t));
 }
 #else
 #define	type_of(o) \
-	((cl_type)(IMMEDIATE(o) ? IMMEDIATE(o) : ((o)->d.t)))
+	((cl_type)(ECL_IMMEDIATE(o) ? ECL_IMMEDIATE(o) : ((o)->d.t)))
 #endif
 
 /*
diff --git a/src/h/stacks.h b/src/h/stacks.h
index aa73ca8d9..e91c4bb05 100755
--- a/src/h/stacks.h
+++ b/src/h/stacks.h
@@ -409,7 +409,7 @@ extern ECL_API ecl_frame_ptr _ecl_frs_push(register cl_env_ptr, register cl_obje
 	ecl_stack_pop_values(__the_env,__nr);	\
 	if (__unwinding) ecl_unwind(__the_env,__next_fr); } while(0)
 
-#define ECL_NEW_FRAME_ID(env) MAKE_FIXNUM(env->frame_id++)
+#define ECL_NEW_FRAME_ID(env) ecl_make_fixnum(env->frame_id++)
 
 #define CL_BLOCK_BEGIN(the_env,id) do {   			\
 	const cl_object __id = ECL_NEW_FRAME_ID(the_env);	\
diff --git a/src/lsp/mislib.lsp b/src/lsp/mislib.lsp
index c7be46884..800175d0b 100644
--- a/src/lsp/mislib.lsp
+++ b/src/lsp/mislib.lsp
@@ -147,7 +147,7 @@ Evaluates FORM, outputs the realtime and runtime used for the evaluation to
   else if (gtm.tm_wday == (ltm.tm_wday + 1) % 7)
     mw += 24*60;
 #endif
-  @(return) = ecl_make_ratio(MAKE_FIXNUM(mw),MAKE_FIXNUM(60));
+  @(return) = ecl_make_ratio(ecl_make_fixnum(mw),ecl_make_fixnum(60));
 }"
 		 :one-liner nil))
 
diff --git a/src/lsp/top.lsp b/src/lsp/top.lsp
index 9857dde1d..7ced7492c 100644
--- a/src/lsp/top.lsp
+++ b/src/lsp/top.lsp
@@ -910,7 +910,7 @@ Use special code 0 to cancel this operation.")
 #endif
 	default: {
 		ecl_base_char *p = (ecl_base_char*)value;
-		output = CODE_CHAR(*p);
+		output = ECL_CODE_CHAR(*p);
 		break;
 	}
 	}
diff --git a/src/util/emacs.el b/src/util/emacs.el
index 805ad08f7..29ee5dfb8 100644
--- a/src/util/emacs.el
+++ b/src/util/emacs.el
@@ -85,23 +85,6 @@
 		(set-buffer "emacs.el")
 		(concat (subseq (buffer-file-name (current-buffer)) 0 -13) x))
 	      '(
-"h/bytecodes.h"
-"h/config.h.in"
-"h/cs.h"
-"h/ecl-cmp.h"
-"h/ecl-inl.h"
-"h/ecl.h"
-"h/external.h"
-"h/impl/math_dispatch.h"
-"h/impl/math_dispatch2.h"
-"h/impl/math_fenv.h"
-"h/impl/math_fenv_msvc.h"
-"h/internal.h"
-"h/number.h"
-"h/object.h"
-"h/page.h"
-"h/stacks.h"
-"h/unify.h"
 "c/all_symbols.d"
 "c/alloc.d"
 "c/alloc_2.d"
@@ -122,8 +105,11 @@
 "c/char_ctype.d"
 "c/character.d"
 "c/cinit.d"
+"c/clos/accessor.d"
+"c/clos/cache.d"
 "c/cmpaux.d"
 "c/compiler.d"
+"c/cons.d"
 "c/disassembler.d"
 "c/dosdummy.d"
 "c/dostimes.d"
@@ -219,7 +205,10 @@
 "c/symbols_list2.h"
 "c/tcp.d"
 "c/threads/atomic.d"
+"c/threads/barrier.d"
 "c/threads/condition_variable.d"
+"c/threads/ecl_atomics.h"
+"c/threads/mailbox.d"
 "c/threads/mutex.d"
 "c/threads/process.d"
 "c/threads/queue.d"
@@ -227,79 +216,49 @@
 "c/threads/semaphore.d"
 "c/time.d"
 "c/typespec.d"
+"c/unicode/ucd-0000.c"
+"c/unicode/ucd-0016.c"
+"c/unicode/ucd-0032.c"
+"c/unicode/ucd-0048.c"
+"c/unicode/ucd-0064.c"
+"c/unicode/ucd-0080.c"
+"c/unicode/ucd-0096.c"
+"c/unicode/ucd.c"
+"c/unicode/ucd16-0000.c"
+"c/unicode/ucd16-0016.c"
+"c/unicode/ucd16-0032.c"
+"c/unicode/ucd16-0048.c"
+"c/unicode/ucd16-0064.c"
+"c/unicode/ucd16.c"
 "c/unify.d"
 "c/unixfsys.d"
 "c/unixint.d"
 "c/unixsys.d"
-"cmp/cmparray.lsp"
-"cmp/cmpbind.lsp"
-"cmp/cmpblock.lsp"
-"cmp/cmpc-inliner.lsp"
-"cmp/cmpc-wt.lsp"
-"cmp/cmpcall.lsp"
-"cmp/cmpcatch.lsp"
-"cmp/cmpcbk.lsp"
-"cmp/cmpclos.lsp"
-"cmp/cmpct.lsp"
-"cmp/cmpdefs.lsp"
-"cmp/cmpenv-api.lsp"
-"cmp/cmpenv-declaim.lsp"
-"cmp/cmpenv-declare.lsp"
-"cmp/cmpenv-fun.lsp"
-"cmp/cmpenv-proclaim.lsp"
-"cmp/cmpeval.lsp"
-"cmp/cmpexit.lsp"
-"cmp/cmpffi.lsp"
-"cmp/cmpflet.lsp"
-"cmp/cmpform.lsp"
-"cmp/cmpfun.lsp"
-"cmp/cmpglobals.lsp"
-"cmp/cmpif.lsp"
-"cmp/cmpinit.lsp"
-"cmp/cmpinline.lsp"
-"cmp/cmplam.lsp"
-"cmp/cmplet.lsp"
-"cmp/cmploc.lsp"
-"cmp/cmpmac.lsp"
-"cmp/cmpmain.lsp"
-"cmp/cmpmap.lsp"
-"cmp/cmpmulti.lsp"
-"cmp/cmpname.lsp"
-"cmp/cmpnum.lsp"
-"cmp/cmpopt-bits.lsp"
-"cmp/cmpopt-cons.lsp"
-"cmp/cmpopt-constant.lsp"
-"cmp/cmpopt-sequence.lsp"
-"cmp/cmpopt-type.lsp"
-"cmp/cmpopt.lsp"
-"cmp/cmpos-features.lsp"
-"cmp/cmpos-run.lsp"
-"cmp/cmpos-run.lsp~"
-"cmp/cmppackage.lsp"
-"cmp/cmppolicy.lsp"
-"cmp/cmpprop.lsp"
-"cmp/cmpspecial.lsp"
-"cmp/cmpstack.lsp"
-"cmp/cmpstructures.lsp"
-"cmp/cmptables.lsp"
-"cmp/cmptag.lsp"
-"cmp/cmptest.lsp"
-"cmp/cmptop.lsp"
-"cmp/cmptype-arith.lsp"
-"cmp/cmptype-prop.lsp"
-"cmp/cmptype.lsp"
-"cmp/cmptypes.lsp"
-"cmp/cmputil.lsp"
-"cmp/cmpvar.lsp"
-"cmp/cmpwt.lsp"
-"cmp/defsys.lsp.in"
-"cmp/load.lsp.in"
-"cmp/proclamations.lsp"
-"cmp/sysfun.lsp"
-"cmp/test.lsp"
+"c/vector_push.d"
+"h/bytecodes.h"
+"h/cache.h"
+"h/config.h.in"
+"h/cons.h"
+"h/cs.h"
+"h/ecl-cmp.h"
+"h/ecl-inl.h"
+"h/ecl.h"
+"h/external.h"
+"h/impl/math_dispatch.h"
+"h/impl/math_dispatch2.h"
+"h/impl/math_fenv.h"
+"h/impl/math_fenv_msvc.h"
+"h/internal.h"
+"h/legacy.h"
+"h/number.h"
+"h/object.h"
+"h/page.h"
+"h/stacks.h"
+"h/unify.h"
 "lsp/arraylib.lsp"
 "lsp/assert.lsp"
 "lsp/autoload.lsp"
+"lsp/cdr-5.lsp"
 "lsp/cmdline.lsp"
 "lsp/cmpinit.lsp"
 "lsp/cmuutil.lsp"
@@ -333,7 +292,6 @@
 "lsp/seqlib.lsp"
 "lsp/seqmacros.lsp"
 "lsp/setf.lsp"
-"lsp/split-sequence.lisp"
 "lsp/top.lsp"
 "lsp/trace.lsp"
 "lsp/unicode.lsp"
@@ -361,6 +319,73 @@
 "clos/stdmethod.lsp"
 "clos/streams.lsp"
 "clos/walk.lsp"
+"cmp/cmparray.lsp"
+"cmp/cmpbind.lsp"
+"cmp/cmpblock.lsp"
+"cmp/cmpc-inliner.lsp"
+"cmp/cmpc-wt.lsp"
+"cmp/cmpcall.lsp"
+"cmp/cmpcatch.lsp"
+"cmp/cmpcbk.lsp"
+"cmp/cmpclos.lsp"
+"cmp/cmpct.lsp"
+"cmp/cmpdefs.lsp"
+"cmp/cmpenv-api.lsp"
+"cmp/cmpenv-declaim.lsp"
+"cmp/cmpenv-declare.lsp"
+"cmp/cmpenv-fun.lsp"
+"cmp/cmpenv-proclaim.lsp"
+"cmp/cmpeval.lsp"
+"cmp/cmpexit.lsp"
+"cmp/cmpffi.lsp"
+"cmp/cmpflet.lsp"
+"cmp/cmpform.lsp"
+"cmp/cmpfun.lsp"
+"cmp/cmpglobals.lsp"
+"cmp/cmpif.lsp"
+"cmp/cmpinline.lsp"
+"cmp/cmplam.lsp"
+"cmp/cmplet.lsp"
+"cmp/cmploc.lsp"
+"cmp/cmpmac.lsp"
+"cmp/cmpmain.lsp"
+"cmp/cmpmap.lsp"
+"cmp/cmpmulti.lsp"
+"cmp/cmpname.lsp"
+"cmp/cmpnum.lsp"
+"cmp/cmpopt-bits.lsp"
+"cmp/cmpopt-clos.lsp"
+"cmp/cmpopt-cons.lsp"
+"cmp/cmpopt-constant.lsp"
+"cmp/cmpopt-printer.lsp"
+"cmp/cmpopt-sequence.lsp"
+"cmp/cmpopt-type.lsp"
+"cmp/cmpopt.lsp"
+"cmp/cmpos-features.lsp"
+"cmp/cmpos-run.lsp"
+"cmp/cmppackage.lsp"
+"cmp/cmppolicy.lsp"
+"cmp/cmpprop.lsp"
+"cmp/cmpspecial.lsp"
+"cmp/cmpstack.lsp"
+"cmp/cmpstructures.lsp"
+"cmp/cmptables.lsp"
+"cmp/cmptag.lsp"
+"cmp/cmptest.lsp"
+"cmp/cmptop.lsp"
+"cmp/cmptype-arith.lsp"
+"cmp/cmptype-assert.lsp"
+"cmp/cmptype-prop.lsp"
+"cmp/cmptype.lsp"
+"cmp/cmptypes.lsp"
+"cmp/cmputil.lsp"
+"cmp/cmpvar.lsp"
+"cmp/cmpwt.lsp"
+"cmp/defsys.lsp.in"
+"cmp/load.lsp.in"
+"cmp/proclamations.lsp"
+"cmp/sysfun.lsp"
+"cmp/test.lsp"
                 )))
 
 (mapcar 'find-file ecl-files)
@@ -371,3 +396,10 @@
 			 (and a (switch-to-buffer a)
 			      (revert-buffer t t))))
 	  ecl-files))
+
+(defun ecl-save ()
+  (interactive)
+  (mapcar '(lambda (x) (let ((a (find-buffer-visiting x)))
+			 (and a (switch-to-buffer a)
+			      (save-buffer 0))))
+	  ecl-files))