mirrors/ecl
1
Fork 0
mirror of https://gitlab.com/embeddable-common-lisp/ecl.git synced 2026-01-28 07:22:27 -08:00
Code Issues Projects Releases Packages Wiki Activity

CHARACTERP, BASE_CHAR_P, BASE_CHAR_CODE_P, CODE_CHAR, CHAR_CODE, REAL_TYPE, IMMEDIATE, IMMEDIATE_TAG, FIXNUM_TAG, FIXNUM_MINUSP, FIXNUM_PLUSP, FIXNUMP and fix get the ecl_ prefix

Browse source
This commit is contained in:
Juan Jose Garcia Ripoll 2012-06-06 11:19:55 +02:00
parent 6f2fd54130
commit 64a9168434
109 changed files with 1489 additions and 1438 deletions
Download patch file Download diff file Expand all files Collapse all files

66
src/c/printer/float_string_old.d
View file

@ -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);

48
src/c/printer/float_to_digits.d
View file

@ -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)
}

8
src/c/printer/float_to_string.d
View file

@ -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++, '-');

14
src/c/printer/integer_to_string.d
View file

@ -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;

4
src/c/printer/write_array.d
View file

@ -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;

2
src/c/printer/write_code.d
View file

@ -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 */,

2
src/c/printer/write_list.d
View file

@ -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) {

18
src/c/printer/write_object.d
View file

@ -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)

6
src/c/printer/write_sse.d
View file

@ -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;
}

26
src/c/printer/write_ugly.d
View file

@ -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