mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-01 12:20:26 +02:00
Code Activity

* *.[ch]: Replace SCM_VALIDATE_INT w/ SCM_VALIDATE_INUM for

Browse source 
better consistency with the names of other SCM_VALIDATE_ macros
and better conformance to guile naming policy.
This commit is contained in:
Greg J. Badros 2000-01-05 19:00:03 +00:00
parent f5421cfc2a
commit 47c6b75ea9
27 changed files with 172 additions and 172 deletions
Download patch file Download diff file Expand all files Collapse all files

4
libguile/async.c
View file

@ -386,7 +386,7 @@ GUILE_PROC(scm_set_tick_rate, "set-tick-rate", 1, 0, 0,
#define FUNC_NAME s_scm_set_tick_rate #define FUNC_NAME s_scm_set_tick_rate
{ {
unsigned int old_n; unsigned int old_n;
SCM_VALIDATE_INT(1,n); SCM_VALIDATE_INUM(1,n);
old_n = scm_tick_rate; old_n = scm_tick_rate;
scm_desired_tick_rate = SCM_INUM (n); scm_desired_tick_rate = SCM_INUM (n);
scm_async_rate = 1 + scm_async_rate - scm_async_clock; scm_async_rate = 1 + scm_async_rate - scm_async_clock;
@ -404,7 +404,7 @@ GUILE_PROC(scm_set_switch_rate, "set-switch-rate", 1, 0, 0,
#define FUNC_NAME s_scm_set_switch_rate #define FUNC_NAME s_scm_set_switch_rate
{ {
unsigned int old_n; unsigned int old_n;
SCM_VALIDATE_INT(1,n); SCM_VALIDATE_INUM(1,n);
old_n = scm_switch_rate; old_n = scm_switch_rate;
scm_desired_switch_rate = SCM_INUM (n); scm_desired_switch_rate = SCM_INUM (n);
scm_async_rate = 1 + scm_async_rate - scm_async_clock; scm_async_rate = 1 + scm_async_rate - scm_async_clock;

2
libguile/backtrace.c
View file

@ -398,7 +398,7 @@ GUILE_PROC(scm_display_application, "display-application", 1, 2, 0,
if (SCM_UNBNDP (indent)) if (SCM_UNBNDP (indent))
indent = SCM_INUM0; indent = SCM_INUM0;
else else
SCM_VALIDATE_INT(3,indent); SCM_VALIDATE_INUM(3,indent);
if (SCM_FRAME_PROC_P (frame)) if (SCM_FRAME_PROC_P (frame))
/* Display an application. */ /* Display an application. */

4
libguile/debug.c
View file

@ -284,8 +284,8 @@ GUILE_PROC (scm_make_iloc, "make-iloc", 3, 0, 0,
"") "")
#define FUNC_NAME s_scm_make_iloc #define FUNC_NAME s_scm_make_iloc
{ {
SCM_VALIDATE_INT(1,frame); SCM_VALIDATE_INUM(1,frame);
SCM_VALIDATE_INT(2,binding); SCM_VALIDATE_INUM(2,binding);
return (SCM_ILOC00 return (SCM_ILOC00
+ SCM_IFRINC * SCM_INUM (frame) + SCM_IFRINC * SCM_INUM (frame)
+ (SCM_NFALSEP (cdrp) ? SCM_ICDR : 0) + (SCM_NFALSEP (cdrp) ? SCM_ICDR : 0)

2
libguile/error.c
View file

@ -119,7 +119,7 @@ GUILE_PROC (scm_strerror, "strerror", 1, 0, 0,
"Returns the Unix error message corresponding to @var{errno}, an integer.") "Returns the Unix error message corresponding to @var{errno}, an integer.")
#define FUNC_NAME s_scm_strerror #define FUNC_NAME s_scm_strerror
{ {
SCM_VALIDATE_INT(1,err); SCM_VALIDATE_INUM(1,err);
return scm_makfrom0str (strerror (SCM_INUM (err))); return scm_makfrom0str (strerror (SCM_INUM (err)));
} }
#undef FUNC_NAME #undef FUNC_NAME

26
libguile/filesys.c
View file

@ -143,8 +143,8 @@ as @code{-1}, then that ID is not changed.")
object = SCM_COERCE_OUTPORT (object); object = SCM_COERCE_OUTPORT (object);
SCM_VALIDATE_INT(2,owner); SCM_VALIDATE_INUM(2,owner);
SCM_VALIDATE_INT(3,group); SCM_VALIDATE_INUM(3,group);
if (SCM_INUMP (object) || (SCM_OPFPORTP (object))) if (SCM_INUMP (object) || (SCM_OPFPORTP (object)))
{ {
if (SCM_INUMP (object)) if (SCM_INUMP (object))
@ -184,7 +184,7 @@ The return value is unspecified.")
object = SCM_COERCE_OUTPORT (object); object = SCM_COERCE_OUTPORT (object);
SCM_VALIDATE_INT(2,mode); SCM_VALIDATE_INUM(2,mode);
if (SCM_INUMP (object) || SCM_OPFPORTP (object)) if (SCM_INUMP (object) || SCM_OPFPORTP (object))
{ {
if (SCM_INUMP (object)) if (SCM_INUMP (object))
@ -222,7 +222,7 @@ E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
} }
else else
{ {
SCM_VALIDATE_INT(1,mode); SCM_VALIDATE_INUM(1,mode);
mask = umask (SCM_INUM (mode)); mask = umask (SCM_INUM (mode));
} }
return SCM_MAKINUM (mask); return SCM_MAKINUM (mask);
@ -243,8 +243,8 @@ port.")
SCM_VALIDATE_ROSTRING(1,path); SCM_VALIDATE_ROSTRING(1,path);
SCM_COERCE_SUBSTR (path); SCM_COERCE_SUBSTR (path);
SCM_VALIDATE_INT_COPY(2,flags,iflags); SCM_VALIDATE_INUM_COPY(2,flags,iflags);
SCM_VALIDATE_INT_DEF_COPY(3,mode,0666,imode); SCM_VALIDATE_INUM_DEF_COPY(3,mode,0666,imode);
SCM_SYSCALL (fd = open (SCM_ROCHARS (path), iflags, imode)); SCM_SYSCALL (fd = open (SCM_ROCHARS (path), iflags, imode));
if (fd == -1) if (fd == -1)
SCM_SYSERROR; SCM_SYSERROR;
@ -289,7 +289,7 @@ for additional flags.")
int iflags; int iflags;
fd = SCM_INUM (scm_open_fdes (path, flags, mode)); fd = SCM_INUM (scm_open_fdes (path, flags, mode));
SCM_VALIDATE_INT_COPY(2,flags,iflags); SCM_VALIDATE_INUM_COPY(2,flags,iflags);
if (iflags & O_RDWR) if (iflags & O_RDWR)
{ {
if (iflags & O_APPEND) if (iflags & O_APPEND)
@ -328,7 +328,7 @@ their revealed counts set to zero.")
if (SCM_PORTP (fd_or_port)) if (SCM_PORTP (fd_or_port))
return scm_close_port (fd_or_port); return scm_close_port (fd_or_port);
SCM_VALIDATE_INT(1,fd_or_port); SCM_VALIDATE_INUM(1,fd_or_port);
fd = SCM_INUM (fd_or_port); fd = SCM_INUM (fd_or_port);
scm_evict_ports (fd); /* see scsh manual. */ scm_evict_ports (fd); /* see scsh manual. */
SCM_SYSCALL (rv = close (fd)); SCM_SYSCALL (rv = close (fd));
@ -635,7 +635,7 @@ umask. Otherwise they are set to the decimal value specified with
} }
else else
{ {
SCM_VALIDATE_INT(2,mode); SCM_VALIDATE_INUM(2,mode);
SCM_SYSCALL (rv = mkdir (SCM_ROCHARS (path), SCM_INUM (mode))); SCM_SYSCALL (rv = mkdir (SCM_ROCHARS (path), SCM_INUM (mode)));
} }
if (rv != 0) if (rv != 0)
@ -1003,7 +1003,7 @@ values instead of a list and has an additional select! interface.
timeout.tv_usec = 0; timeout.tv_usec = 0;
else else
{ {
SCM_VALIDATE_INT(5,usecs); SCM_VALIDATE_INUM(5,usecs);
timeout.tv_usec = SCM_INUM (usecs); timeout.tv_usec = SCM_INUM (usecs);
} }
} }
@ -1079,12 +1079,12 @@ The value used to indicate the "close on exec" flag with @code{F_GETFL} or
object = SCM_COERCE_OUTPORT (object); object = SCM_COERCE_OUTPORT (object);
SCM_VALIDATE_INT(2,cmd); SCM_VALIDATE_INUM(2,cmd);
if (SCM_OPFPORTP (object)) if (SCM_OPFPORTP (object))
fdes = SCM_FPORT_FDES (object); fdes = SCM_FPORT_FDES (object);
else else
{ {
SCM_VALIDATE_INT(1,object); SCM_VALIDATE_INUM(1,object);
fdes = SCM_INUM (object); fdes = SCM_INUM (object);
} }
if (SCM_NULLP (value)) if (SCM_NULLP (value))
@ -1120,7 +1120,7 @@ The return value is unspecified.")
} }
else else
{ {
SCM_VALIDATE_INT(1,object); SCM_VALIDATE_INUM(1,object);
fdes = SCM_INUM (object); fdes = SCM_INUM (object);
} }
if (fsync (fdes) == -1) if (fsync (fdes) == -1)

4
libguile/fports.c
View file

@ -178,7 +178,7 @@ The value used to indicate the "close on exec" flag with @code{F_GETFL} or
port = SCM_COERCE_OUTPORT (port); port = SCM_COERCE_OUTPORT (port);
SCM_VALIDATE_OPFPORT(1,port); SCM_VALIDATE_OPFPORT(1,port);
SCM_VALIDATE_INT_COPY(2,mode,cmode); SCM_VALIDATE_INUM_COPY(2,mode,cmode);
if (cmode != _IONBF && cmode != _IOFBF && cmode != _IOLBF) if (cmode != _IONBF && cmode != _IOFBF && cmode != _IOLBF)
scm_out_of_range (FUNC_NAME, mode); scm_out_of_range (FUNC_NAME, mode);
@ -201,7 +201,7 @@ The value used to indicate the "close on exec" flag with @code{F_GETFL} or
} }
else else
{ {
SCM_VALIDATE_INT_COPY(3,size,csize); SCM_VALIDATE_INUM_COPY(3,size,csize);
if (csize < 0 || (cmode == _IONBF && csize > 0)) if (csize < 0 || (cmode == _IONBF && csize > 0))
scm_out_of_range (FUNC_NAME, size); scm_out_of_range (FUNC_NAME, size);
} }

6
libguile/hash.c
View file

@ -154,7 +154,7 @@ table. Each function returns an integer in the range 0 to
@var{size}-1.") @var{size}-1.")
#define FUNC_NAME s_scm_hashq #define FUNC_NAME s_scm_hashq
{ {
SCM_VALIDATE_INT_MIN(2,n,0); SCM_VALIDATE_INUM_MIN(2,n,0);
return SCM_MAKINUM(scm_ihashq (obj, SCM_INUM (n))); return SCM_MAKINUM(scm_ihashq (obj, SCM_INUM (n)));
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -181,7 +181,7 @@ GUILE_PROC(scm_hashv, "hashv", 2, 0, 0,
"") "")
#define FUNC_NAME s_scm_hashv #define FUNC_NAME s_scm_hashv
{ {
SCM_VALIDATE_INT_MIN(2,n,0); SCM_VALIDATE_INUM_MIN(2,n,0);
return SCM_MAKINUM(scm_ihashv (obj, SCM_INUM (n))); return SCM_MAKINUM(scm_ihashv (obj, SCM_INUM (n)));
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -201,7 +201,7 @@ GUILE_PROC(scm_hash, "hash", 2, 0, 0,
"") "")
#define FUNC_NAME s_scm_hash #define FUNC_NAME s_scm_hash
{ {
SCM_VALIDATE_INT_MIN(2,n,0); SCM_VALIDATE_INUM_MIN(2,n,0);
return SCM_MAKINUM(scm_ihash(obj, SCM_INUM(n))); return SCM_MAKINUM(scm_ihash(obj, SCM_INUM(n)));
} }
#undef FUNC_NAME #undef FUNC_NAME

10
libguile/ioext.c
View file

@ -101,11 +101,11 @@ without encountering a delimiter, this value is @var{#f}.")
else else
SCM_VALIDATE_OPINPORT(4,port); SCM_VALIDATE_OPINPORT(4,port);
SCM_VALIDATE_INT_DEF_COPY(5,start,0,cstart); SCM_VALIDATE_INUM_DEF_COPY(5,start,0,cstart);
if (cstart < 0 || cstart >= cend) if (cstart < 0 || cstart >= cend)
scm_out_of_range (FUNC_NAME, start); scm_out_of_range (FUNC_NAME, start);
SCM_VALIDATE_INT_DEF_COPY(6,end,cend,tend); SCM_VALIDATE_INUM_DEF_COPY(6,end,cend,tend);
if (tend <= cstart || tend > cend) if (tend <= cstart || tend > cend)
scm_out_of_range (FUNC_NAME, end); scm_out_of_range (FUNC_NAME, end);
cend = tend; cend = tend;
@ -457,7 +457,7 @@ by @ref{File Ports, open-file}.")
{ {
SCM port; SCM port;
SCM_VALIDATE_INT(1,fdes); SCM_VALIDATE_INUM(1,fdes);
SCM_VALIDATE_ROSTRING(2,modes); SCM_VALIDATE_ROSTRING(2,modes);
SCM_COERCE_SUBSTR (modes); SCM_COERCE_SUBSTR (modes);
port = scm_fdes_to_port (SCM_INUM (fdes), SCM_ROCHARS (modes), SCM_BOOL_F); port = scm_fdes_to_port (SCM_INUM (fdes), SCM_ROCHARS (modes), SCM_BOOL_F);
@ -490,7 +490,7 @@ required value or @code{#t} if it was moved.")
port = SCM_COERCE_OUTPORT (port); port = SCM_COERCE_OUTPORT (port);
SCM_VALIDATE_OPFPORT(1,port); SCM_VALIDATE_OPFPORT(1,port);
SCM_VALIDATE_INT(2,fd); SCM_VALIDATE_INUM(2,fd);
stream = SCM_FSTREAM (port); stream = SCM_FSTREAM (port);
old_fd = stream->fdes; old_fd = stream->fdes;
new_fd = SCM_INUM (fd); new_fd = SCM_INUM (fd);
@ -519,7 +519,7 @@ underlying file descriptor, without changing their revealed counts.")
int int_fd; int int_fd;
int i; int i;
SCM_VALIDATE_INT_COPY(1,fd,int_fd); SCM_VALIDATE_INUM_COPY(1,fd,int_fd);
for (i = 0; i < scm_port_table_size; i++) for (i = 0; i < scm_port_table_size; i++)
{ {

10
libguile/list.c
View file

@ -332,7 +332,7 @@ GUILE_PROC(scm_list_ref, "list-ref", 2, 0, 0,
#define FUNC_NAME s_scm_list_ref #define FUNC_NAME s_scm_list_ref
{ {
register long i; register long i;
SCM_VALIDATE_INT_MIN_COPY(2,k,0,i); SCM_VALIDATE_INUM_MIN_COPY(2,k,0,i);
while (i-- > 0) { while (i-- > 0) {
SCM_ASRTGO(SCM_CONSP(lst), erout); SCM_ASRTGO(SCM_CONSP(lst), erout);
lst = SCM_CDR(lst); lst = SCM_CDR(lst);
@ -350,7 +350,7 @@ GUILE_PROC(scm_list_set_x, "list-set!", 3, 0, 0,
#define FUNC_NAME s_scm_list_set_x #define FUNC_NAME s_scm_list_set_x
{ {
register long i; register long i;
SCM_VALIDATE_INT_MIN_COPY(2,k,0,i); SCM_VALIDATE_INUM_MIN_COPY(2,k,0,i);
while (i-- > 0) { while (i-- > 0) {
SCM_ASRTGO(SCM_CONSP(lst), erout); SCM_ASRTGO(SCM_CONSP(lst), erout);
lst = SCM_CDR(lst); lst = SCM_CDR(lst);
@ -377,7 +377,7 @@ or returning the results of cdring @var{k} times down @var{lst}.")
#define FUNC_NAME s_scm_list_tail #define FUNC_NAME s_scm_list_tail
{ {
register long i; register long i;
SCM_VALIDATE_INT_MIN_COPY(2,k,0,i); SCM_VALIDATE_INUM_MIN_COPY(2,k,0,i);
while (i-- > 0) { while (i-- > 0) {
SCM_VALIDATE_CONS(1,lst); SCM_VALIDATE_CONS(1,lst);
lst = SCM_CDR(lst); lst = SCM_CDR(lst);
@ -393,7 +393,7 @@ GUILE_PROC(scm_list_cdr_set_x, "list-cdr-set!", 3, 0, 0,
#define FUNC_NAME s_scm_list_cdr_set_x #define FUNC_NAME s_scm_list_cdr_set_x
{ {
register long i; register long i;
SCM_VALIDATE_INT_MIN_COPY(2,k,0,i); SCM_VALIDATE_INUM_MIN_COPY(2,k,0,i);
while (i-- > 0) { while (i-- > 0) {
SCM_ASRTGO(SCM_CONSP(lst), erout); SCM_ASRTGO(SCM_CONSP(lst), erout);
lst = SCM_CDR(lst); lst = SCM_CDR(lst);
@ -420,7 +420,7 @@ return it.")
SCM * pos; SCM * pos;
register long i; register long i;
SCM_VALIDATE_INT_MIN_COPY(2,k,0,i); SCM_VALIDATE_INUM_MIN_COPY(2,k,0,i);
answer = SCM_EOL; answer = SCM_EOL;
pos = &answer; pos = &answer;
while (i-- > 0) while (i-- > 0)

6
libguile/net_db.c
View file

@ -175,8 +175,8 @@ with the local-address-within-network number @var{lna}.
unsigned long netnum; unsigned long netnum;
unsigned long lnanum; unsigned long lnanum;
SCM_VALIDATE_INT_COPY(1,net,netnum); SCM_VALIDATE_INUM_COPY(1,net,netnum);
SCM_VALIDATE_INT_COPY(2,lna,lnanum); SCM_VALIDATE_INUM_COPY(2,lna,lnanum);
addr = inet_makeaddr (netnum, lnanum); addr = inet_makeaddr (netnum, lnanum);
return scm_ulong2num (ntohl (addr.s_addr)); return scm_ulong2num (ntohl (addr.s_addr));
} }
@ -475,7 +475,7 @@ as its first argument; if given no arguments, it behaves like
} }
else else
{ {
SCM_VALIDATE_INT(1,name); SCM_VALIDATE_INUM(1,name);
entry = getservbyport (htons (SCM_INUM (name)), SCM_ROCHARS (proto)); entry = getservbyport (htons (SCM_INUM (name)), SCM_ROCHARS (proto));
} }
if (!entry) if (!entry)

68
libguile/numbers.c
View file

@ -122,7 +122,7 @@ GUILE_PROC (scm_odd_p, "odd?", 1, 0, 0,
return SCM_BOOL(1 & SCM_BDIGITS (n)[0]); return SCM_BOOL(1 & SCM_BDIGITS (n)[0]);
} }
#else #else
SCM_VALIDATE_INT(1,n); SCM_VALIDATE_INUM(1,n);
#endif #endif
return SCM_BOOL(4 & (int) n); return SCM_BOOL(4 & (int) n);
} }
@ -140,7 +140,7 @@ GUILE_PROC (scm_even_p, "even?", 1, 0, 0,
return SCM_NEGATE_BOOL(1 & SCM_BDIGITS (n)[0]); return SCM_NEGATE_BOOL(1 & SCM_BDIGITS (n)[0]);
} }
#else #else
SCM_VALIDATE_INT(1,n); SCM_VALIDATE_INUM(1,n);
#endif #endif
return SCM_NEGATE_BOOL(4 & (int) n); return SCM_NEGATE_BOOL(4 & (int) n);
} }
@ -528,8 +528,8 @@ Example:
return SCM_MAKINUM (-1); return SCM_MAKINUM (-1);
return n1; return n1;
} }
SCM_VALIDATE_INT_COPY(1,n1,i1); SCM_VALIDATE_INUM_COPY(1,n1,i1);
SCM_VALIDATE_INT_COPY(2,n2,i2); SCM_VALIDATE_INUM_COPY(2,n2,i2);
return scm_ulong2num (i1 & i2); return scm_ulong2num (i1 & i2);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -553,8 +553,8 @@ Example:
return SCM_INUM0; return SCM_INUM0;
return n1; return n1;
} }
SCM_VALIDATE_INT_COPY(1,n1,i1); SCM_VALIDATE_INUM_COPY(1,n1,i1);
SCM_VALIDATE_INT_COPY(2,n2,i2); SCM_VALIDATE_INUM_COPY(2,n2,i2);
return scm_ulong2num (i1 | i2); return scm_ulong2num (i1 | i2);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -578,8 +578,8 @@ Example:
return SCM_INUM0; return SCM_INUM0;
return n1; return n1;
} }
SCM_VALIDATE_INT_COPY(1,n1,i1); SCM_VALIDATE_INUM_COPY(1,n1,i1);
SCM_VALIDATE_INT_COPY(2,n2,i2); SCM_VALIDATE_INUM_COPY(2,n2,i2);
return scm_ulong2num (i1 ^ i2); return scm_ulong2num (i1 ^ i2);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -590,8 +590,8 @@ GUILE_PROC (scm_logtest, "logtest", 2, 0, 0,
#define FUNC_NAME s_scm_logtest #define FUNC_NAME s_scm_logtest
{ {
int i1, i2; int i1, i2;
SCM_VALIDATE_INT_COPY(1,n1,i1); SCM_VALIDATE_INUM_COPY(1,n1,i1);
SCM_VALIDATE_INT_COPY(2,n2,i2); SCM_VALIDATE_INUM_COPY(2,n2,i2);
return SCM_BOOL(i1 & i2); return SCM_BOOL(i1 & i2);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -603,8 +603,8 @@ GUILE_PROC (scm_logbit_p, "logbit?", 2, 0, 0,
#define FUNC_NAME s_scm_logbit_p #define FUNC_NAME s_scm_logbit_p
{ {
int i1, i2; int i1, i2;
SCM_VALIDATE_INT_COPY(1,n1,i1); SCM_VALIDATE_INUM_COPY(1,n1,i1);
SCM_VALIDATE_INT_COPY(2,n2,i2); SCM_VALIDATE_INUM_COPY(2,n2,i2);
return SCM_BOOL((1 << i1) & i2); return SCM_BOOL((1 << i1) & i2);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -623,8 +623,8 @@ GUILE_PROC1 (scm_logand, "logand", scm_tc7_asubr,
return SCM_MAKINUM (-1); return SCM_MAKINUM (-1);
return n1; return n1;
} }
SCM_VALIDATE_INT_COPY(1,n1,i1); SCM_VALIDATE_INUM_COPY(1,n1,i1);
SCM_VALIDATE_INT_COPY(2,n2,i2); SCM_VALIDATE_INUM_COPY(2,n2,i2);
return SCM_MAKINUM (i1 & i2); return SCM_MAKINUM (i1 & i2);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -641,8 +641,8 @@ GUILE_PROC1 (scm_logior, "logior", scm_tc7_asubr,
return SCM_INUM0; return SCM_INUM0;
return n1; return n1;
} }
SCM_VALIDATE_INT_COPY(1,n1,i1); SCM_VALIDATE_INUM_COPY(1,n1,i1);
SCM_VALIDATE_INT_COPY(2,n2,i2); SCM_VALIDATE_INUM_COPY(2,n2,i2);
return SCM_MAKINUM (i1 | i2); return SCM_MAKINUM (i1 | i2);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -659,8 +659,8 @@ GUILE_PROC1 (scm_logxor, "logxor", scm_tc7_asubr,
return SCM_INUM0; return SCM_INUM0;
return n1; return n1;
} }
SCM_VALIDATE_INT_COPY(1,n1,i1); SCM_VALIDATE_INUM_COPY(1,n1,i1);
SCM_VALIDATE_INT_COPY(2,n2,i2); SCM_VALIDATE_INUM_COPY(2,n2,i2);
return SCM_MAKINUM (i1 ^ i2); return SCM_MAKINUM (i1 ^ i2);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -676,8 +676,8 @@ GUILE_PROC (scm_logtest, "logtest", 2, 0, 0,
#define FUNC_NAME s_scm_logtest #define FUNC_NAME s_scm_logtest
{ {
int i1, i2; int i1, i2;
SCM_VALIDATE_INT_COPY(1,n1,i1); SCM_VALIDATE_INUM_COPY(1,n1,i1);
SCM_VALIDATE_INT_COPY(2,n2,i2); SCM_VALIDATE_INUM_COPY(2,n2,i2);
return SCM_BOOL(i1 & i2); return SCM_BOOL(i1 & i2);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -696,8 +696,8 @@ GUILE_PROC (scm_logbit_p, "logbit?", 2, 0, 0,
#define FUNC_NAME s_scm_logbit_p #define FUNC_NAME s_scm_logbit_p
{ {
int i1, i2; int i1, i2;
SCM_VALIDATE_INT_MIN_COPY(1,n1,0,i1); SCM_VALIDATE_INUM_MIN_COPY(1,n1,0,i1);
SCM_VALIDATE_INT_COPY(2,n2,i2); SCM_VALIDATE_INUM_COPY(2,n2,i2);
return SCM_BOOL((1 << i1) & i2); return SCM_BOOL((1 << i1) & i2);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -717,7 +717,7 @@ Example:
") ")
#define FUNC_NAME s_scm_lognot #define FUNC_NAME s_scm_lognot
{ {
SCM_VALIDATE_INT(1,n); SCM_VALIDATE_INUM(1,n);
return scm_difference (SCM_MAKINUM (-1L), n); return scm_difference (SCM_MAKINUM (-1L), n);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -743,7 +743,7 @@ Example:
else if (SCM_MAKINUM (-1L) == z1) else if (SCM_MAKINUM (-1L) == z1)
return SCM_BOOL_F == scm_even_p (z2) ? z1 : acc; return SCM_BOOL_F == scm_even_p (z2) ? z1 : acc;
#endif #endif
SCM_VALIDATE_INT_COPY(2,z2,i2); SCM_VALIDATE_INUM_COPY(2,z2,i2);
if (i2 < 0) if (i2 < 0)
{ {
i2 = -i2; i2 = -i2;
@ -779,7 +779,7 @@ Example:
{ {
/* GJB:FIXME:: what is going on here? */ /* GJB:FIXME:: what is going on here? */
SCM res = SCM_INUM (n); SCM res = SCM_INUM (n);
SCM_VALIDATE_INT(2,cnt); SCM_VALIDATE_INUM(2,cnt);
#ifdef SCM_BIGDIG #ifdef SCM_BIGDIG
if (cnt < 0) if (cnt < 0)
{ {
@ -793,7 +793,7 @@ Example:
else else
return scm_product (n, scm_integer_expt (SCM_MAKINUM (2), cnt)); return scm_product (n, scm_integer_expt (SCM_MAKINUM (2), cnt));
#else #else
SCM_VALIDATE_INT(1,n) SCM_VALIDATE_INUM(1,n)
cnt = SCM_INUM (cnt); cnt = SCM_INUM (cnt);
if (cnt < 0) if (cnt < 0)
return SCM_MAKINUM (SCM_SRS (res, -cnt)); return SCM_MAKINUM (SCM_SRS (res, -cnt));
@ -821,9 +821,9 @@ Example:
@end lisp") @end lisp")
#define FUNC_NAME s_scm_bit_extract #define FUNC_NAME s_scm_bit_extract
{ {
SCM_VALIDATE_INT(1,n); SCM_VALIDATE_INUM(1,n);
SCM_VALIDATE_INT_MIN(2,start,0); SCM_VALIDATE_INUM_MIN(2,start,0);
SCM_VALIDATE_INT_MIN(3,end,0); SCM_VALIDATE_INUM_MIN(3,end,0);
start = SCM_INUM (start); start = SCM_INUM (start);
end = SCM_INUM (end); end = SCM_INUM (end);
SCM_ASSERT (end >= start, SCM_MAKINUM (end), SCM_OUTOFRANGE, FUNC_NAME); SCM_ASSERT (end >= start, SCM_MAKINUM (end), SCM_OUTOFRANGE, FUNC_NAME);
@ -835,7 +835,7 @@ Example:
SCM_MAKINUM (1L)), SCM_MAKINUM (1L)),
scm_ash (n, SCM_MAKINUM (-start))); scm_ash (n, SCM_MAKINUM (-start)));
#else #else
SCM_VALIDATE_INT(1,n); SCM_VALIDATE_INUM(1,n);
#endif #endif
return SCM_MAKINUM ((SCM_INUM (n) >> start) & ((1L << (end - start)) - 1)); return SCM_MAKINUM ((SCM_INUM (n) >> start) & ((1L << (end - start)) - 1));
} }
@ -880,7 +880,7 @@ Example:
return SCM_MAKINUM (c); return SCM_MAKINUM (c);
} }
#else #else
SCM_VALIDATE_INT(1,n); SCM_VALIDATE_INUM(1,n);
#endif #endif
if ((nn = SCM_INUM (n)) < 0) if ((nn = SCM_INUM (n)) < 0)
nn = -1 - nn; nn = -1 - nn;
@ -930,7 +930,7 @@ Example:
return SCM_MAKINUM (c - 4 + l); return SCM_MAKINUM (c - 4 + l);
} }
#else #else
SCM_VALIDATE_INT(1,n); SCM_VALIDATE_INUM(1,n);
#endif #endif
if ((nn = SCM_INUM (n)) < 0) if ((nn = SCM_INUM (n)) < 0)
nn = -1 - nn; nn = -1 - nn;
@ -1862,7 +1862,7 @@ GUILE_PROC (scm_number_to_string, "number->string", 1, 1, 0,
#define FUNC_NAME s_scm_number_to_string #define FUNC_NAME s_scm_number_to_string
{ {
int base; int base;
SCM_VALIDATE_INT_MIN_DEF_COPY(2,radix,2,10,base); SCM_VALIDATE_INUM_MIN_DEF_COPY(2,radix,2,10,base);
#ifdef SCM_FLOATS #ifdef SCM_FLOATS
if (SCM_NINUMP (x)) if (SCM_NINUMP (x))
{ {
@ -2466,7 +2466,7 @@ GUILE_PROC (scm_string_to_number, "string->number", 1, 1, 0,
SCM answer; SCM answer;
int base; int base;
SCM_VALIDATE_ROSTRING(1,str); SCM_VALIDATE_ROSTRING(1,str);
SCM_VALIDATE_INT_MIN_DEF_COPY(2,radix,2,10,base); SCM_VALIDATE_INUM_MIN_DEF_COPY(2,radix,2,10,base);
answer = scm_istring2number (SCM_ROCHARS (str), answer = scm_istring2number (SCM_ROCHARS (str),
SCM_ROLENGTH (str), SCM_ROLENGTH (str),
base); base);

12
libguile/ports.c
View file

@ -454,7 +454,7 @@ GUILE_PROC(scm_pt_member, "pt-member", 1, 0, 0,
#define FUNC_NAME s_scm_pt_member #define FUNC_NAME s_scm_pt_member
{ {
int i; int i;
SCM_VALIDATE_INT_COPY (1,member,i); SCM_VALIDATE_INUM_COPY (1,member,i);
if (i < 0 || i >= scm_port_table_size) if (i < 0 || i >= scm_port_table_size)
return SCM_BOOL_F; return SCM_BOOL_F;
else else
@ -501,7 +501,7 @@ The return value is unspecified.")
{ {
port = SCM_COERCE_OUTPORT (port); port = SCM_COERCE_OUTPORT (port);
SCM_VALIDATE_PORT(1,port); SCM_VALIDATE_PORT(1,port);
SCM_VALIDATE_INT(2,rcount); SCM_VALIDATE_INUM(2,rcount);
SCM_REVEALED (port) = SCM_INUM (rcount); SCM_REVEALED (port) = SCM_INUM (rcount);
return SCM_UNSPECIFIED; return SCM_UNSPECIFIED;
} }
@ -1040,7 +1040,7 @@ the current position of a port can be obtained using:
object = SCM_COERCE_OUTPORT (object); object = SCM_COERCE_OUTPORT (object);
off = SCM_NUM2LONG (2,offset); off = SCM_NUM2LONG (2,offset);
SCM_VALIDATE_INT_COPY(3,whence,how); SCM_VALIDATE_INUM_COPY(3,whence,how);
if (how != SEEK_SET && how != SEEK_CUR && how != SEEK_END) if (how != SEEK_SET && how != SEEK_CUR && how != SEEK_END)
SCM_OUT_OF_RANGE (3, whence); SCM_OUT_OF_RANGE (3, whence);
if (SCM_OPPORTP (object)) if (SCM_OPPORTP (object))
@ -1055,7 +1055,7 @@ the current position of a port can be obtained using:
} }
else /* file descriptor?. */ else /* file descriptor?. */
{ {
SCM_VALIDATE_INT(1,object); SCM_VALIDATE_INUM(1,object);
rv = lseek (SCM_INUM (object), off, how); rv = lseek (SCM_INUM (object), off, how);
if (rv == -1) if (rv == -1)
SCM_SYSERROR; SCM_SYSERROR;
@ -1142,7 +1142,7 @@ GUILE_PROC (scm_set_port_line_x, "set-port-line!", 2, 0, 0,
{ {
port = SCM_COERCE_OUTPORT (port); port = SCM_COERCE_OUTPORT (port);
SCM_VALIDATE_OPENPORT(1,port); SCM_VALIDATE_OPENPORT(1,port);
SCM_VALIDATE_INT(2,line); SCM_VALIDATE_INUM(2,line);
return SCM_PTAB_ENTRY (port)->line_number = SCM_INUM (line); return SCM_PTAB_ENTRY (port)->line_number = SCM_INUM (line);
} }
#undef FUNC_NAME #undef FUNC_NAME
@ -1175,7 +1175,7 @@ current input port if none is specified.")
{ {
port = SCM_COERCE_OUTPORT (port); port = SCM_COERCE_OUTPORT (port);
SCM_VALIDATE_OPENPORT(1,port); SCM_VALIDATE_OPENPORT(1,port);
SCM_VALIDATE_INT(2,column); SCM_VALIDATE_INUM(2,column);
return SCM_PTAB_ENTRY (port)->column_number = SCM_INUM (column); return SCM_PTAB_ENTRY (port)->column_number = SCM_INUM (column);
} }
#undef FUNC_NAME #undef FUNC_NAME

38
libguile/posix.c
View file

@ -391,8 +391,8 @@ Interrupt signal.
@end defvar") @end defvar")
#define FUNC_NAME s_scm_kill #define FUNC_NAME s_scm_kill
{ {
SCM_VALIDATE_INT(1,pid); SCM_VALIDATE_INUM(1,pid);
SCM_VALIDATE_INT(2,sig); SCM_VALIDATE_INUM(2,sig);
/* Signal values are interned in scm_init_posix(). */ /* Signal values are interned in scm_init_posix(). */
if (kill ((int) SCM_INUM (pid), (int) SCM_INUM (sig)) != 0) if (kill ((int) SCM_INUM (pid), (int) SCM_INUM (sig)) != 0)
SCM_SYSERROR; SCM_SYSERROR;
@ -449,12 +449,12 @@ The integer status value.
int i; int i;
int status; int status;
int ioptions; int ioptions;
SCM_VALIDATE_INT(1,pid); SCM_VALIDATE_INUM(1,pid);
if (SCM_UNBNDP (options)) if (SCM_UNBNDP (options))
ioptions = 0; ioptions = 0;
else else
{ {
SCM_VALIDATE_INT(2,options); SCM_VALIDATE_INUM(2,options);
/* Flags are interned in scm_init_posix. */ /* Flags are interned in scm_init_posix. */
ioptions = SCM_INUM (options); ioptions = SCM_INUM (options);
} }
@ -475,7 +475,7 @@ call to @code{exit} or @code{_exit}, if any, otherwise @code{#f}.")
{ {
int lstatus; int lstatus;
SCM_VALIDATE_INT(1,status); SCM_VALIDATE_INUM(1,status);
/* On Ultrix, the WIF... macros assume their argument is an lvalue; /* On Ultrix, the WIF... macros assume their argument is an lvalue;
go figure. SCM_INUM does not yield an lvalue. */ go figure. SCM_INUM does not yield an lvalue. */
@ -495,7 +495,7 @@ process, if any, otherwise @code{#f}.")
{ {
int lstatus; int lstatus;
SCM_VALIDATE_INT(1,status); SCM_VALIDATE_INUM(1,status);
lstatus = SCM_INUM (status); lstatus = SCM_INUM (status);
if (WIFSIGNALED (lstatus)) if (WIFSIGNALED (lstatus))
@ -513,7 +513,7 @@ process, if any, otherwise @code{#f}.")
{ {
int lstatus; int lstatus;
SCM_VALIDATE_INT(1,status); SCM_VALIDATE_INUM(1,status);
lstatus = SCM_INUM (status); lstatus = SCM_INUM (status);
if (WIFSTOPPED (lstatus)) if (WIFSTOPPED (lstatus))
@ -598,7 +598,7 @@ the process has appropriate privileges.
The return value is unspecified.") The return value is unspecified.")
#define FUNC_NAME s_scm_setuid #define FUNC_NAME s_scm_setuid
{ {
SCM_VALIDATE_INT(1,id); SCM_VALIDATE_INUM(1,id);
if (setuid (SCM_INUM (id)) != 0) if (setuid (SCM_INUM (id)) != 0)
SCM_SYSERROR; SCM_SYSERROR;
return SCM_UNSPECIFIED; return SCM_UNSPECIFIED;
@ -612,7 +612,7 @@ the process has appropriate privileges.
The return value is unspecified.") The return value is unspecified.")
#define FUNC_NAME s_scm_setgid #define FUNC_NAME s_scm_setgid
{ {
SCM_VALIDATE_INT(1,id); SCM_VALIDATE_INUM(1,id);
if (setgid (SCM_INUM (id)) != 0) if (setgid (SCM_INUM (id)) != 0)
SCM_SYSERROR; SCM_SYSERROR;
return SCM_UNSPECIFIED; return SCM_UNSPECIFIED;
@ -630,7 +630,7 @@ The return value is unspecified.")
{ {
int rv; int rv;
SCM_VALIDATE_INT(1,id); SCM_VALIDATE_INUM(1,id);
#ifdef HAVE_SETEUID #ifdef HAVE_SETEUID
rv = seteuid (SCM_INUM (id)); rv = seteuid (SCM_INUM (id));
#else #else
@ -654,7 +654,7 @@ The return value is unspecified.")
{ {
int rv; int rv;
SCM_VALIDATE_INT(1,id); SCM_VALIDATE_INUM(1,id);
#ifdef HAVE_SETEUID #ifdef HAVE_SETEUID
rv = setegid (SCM_INUM (id)); rv = setegid (SCM_INUM (id));
#else #else
@ -690,8 +690,8 @@ The return value is unspecified.")
#define FUNC_NAME s_scm_setpgid #define FUNC_NAME s_scm_setpgid
{ {
#ifdef HAVE_SETPGID #ifdef HAVE_SETPGID
SCM_VALIDATE_INT(1,pid); SCM_VALIDATE_INUM(1,pid);
SCM_VALIDATE_INT(2,pgid); SCM_VALIDATE_INUM(2,pgid);
/* FIXME(?): may be known as setpgrp. */ /* FIXME(?): may be known as setpgrp. */
if (setpgid (SCM_INUM (pid), SCM_INUM (pgid)) != 0) if (setpgid (SCM_INUM (pid), SCM_INUM (pgid)) != 0)
SCM_SYSERROR; SCM_SYSERROR;
@ -815,7 +815,7 @@ controlling terminal. The return value is unspecified.")
port = SCM_COERCE_OUTPORT (port); port = SCM_COERCE_OUTPORT (port);
SCM_VALIDATE_OPFPORT(1,port); SCM_VALIDATE_OPFPORT(1,port);
SCM_VALIDATE_INT(2,pgid); SCM_VALIDATE_INUM(2,pgid);
fd = SCM_FPORT_FDES (port); fd = SCM_FPORT_FDES (port);
if (tcsetpgrp (fd, SCM_INUM (pgid)) == -1) if (tcsetpgrp (fd, SCM_INUM (pgid)) == -1)
SCM_SYSERROR; SCM_SYSERROR;
@ -1147,7 +1147,7 @@ test for existence of the file.
SCM_VALIDATE_ROSTRING(1,path); SCM_VALIDATE_ROSTRING(1,path);
if (SCM_SUBSTRP (path)) if (SCM_SUBSTRP (path))
path = scm_makfromstr (SCM_ROCHARS (path), SCM_ROLENGTH (path), 0); path = scm_makfromstr (SCM_ROCHARS (path), SCM_ROLENGTH (path), 0);
SCM_VALIDATE_INT(2,how); SCM_VALIDATE_INUM(2,how);
rv = access (SCM_ROCHARS (path), SCM_INUM (how)); rv = access (SCM_ROCHARS (path), SCM_INUM (how));
return SCM_NEGATE_BOOL(rv); return SCM_NEGATE_BOOL(rv);
} }
@ -1212,7 +1212,7 @@ is an empty string, the locale will be set using envirionment variables.")
char *clocale; char *clocale;
char *rv; char *rv;
SCM_VALIDATE_INT(1,category); SCM_VALIDATE_INUM(1,category);
if (SCM_UNBNDP (locale)) if (SCM_UNBNDP (locale))
{ {
clocale = NULL; clocale = NULL;
@ -1262,8 +1262,8 @@ The return value is unspecified.")
SCM_VALIDATE_ROSTRING(1,path); SCM_VALIDATE_ROSTRING(1,path);
SCM_VALIDATE_SYMBOL(2,type); SCM_VALIDATE_SYMBOL(2,type);
SCM_VALIDATE_INT(3,perms); SCM_VALIDATE_INUM(3,perms);
SCM_VALIDATE_INT(4,dev); SCM_VALIDATE_INUM(4,dev);
SCM_COERCE_SUBSTR (path); SCM_COERCE_SUBSTR (path);
p = SCM_CHARS (type); p = SCM_CHARS (type);
@ -1306,7 +1306,7 @@ The return value is unspecified.")
#define FUNC_NAME s_scm_nice #define FUNC_NAME s_scm_nice
{ {
#ifdef HAVE_NICE #ifdef HAVE_NICE
SCM_VALIDATE_INT(1,incr); SCM_VALIDATE_INUM(1,incr);
if (nice(SCM_INUM(incr)) != 0) if (nice(SCM_INUM(incr)) != 0)
SCM_SYSERROR; SCM_SYSERROR;
return SCM_UNSPECIFIED; return SCM_UNSPECIFIED;

4
libguile/regex-posix.c
View file

@ -237,11 +237,11 @@ the results of the match, or @code{#f} if no match could be found.")
SCM_VALIDATE_RGXP(1,rx); SCM_VALIDATE_RGXP(1,rx);
SCM_VALIDATE_ROSTRING(2,str); SCM_VALIDATE_ROSTRING(2,str);
SCM_VALIDATE_INT_DEF_COPY(3,start,0,offset); SCM_VALIDATE_INUM_DEF_COPY(3,start,0,offset);
SCM_ASSERT_RANGE (3,start,offset >= 0 && (unsigned) offset <= SCM_LENGTH (str)); SCM_ASSERT_RANGE (3,start,offset >= 0 && (unsigned) offset <= SCM_LENGTH (str));
if (SCM_UNBNDP (flags)) if (SCM_UNBNDP (flags))
flags = SCM_INUM0; flags = SCM_INUM0;
SCM_VALIDATE_INT(4,flags); SCM_VALIDATE_INUM(4,flags);
SCM_COERCE_SUBSTR (str); SCM_COERCE_SUBSTR (str);
/* re_nsub doesn't account for the `subexpression' representing the /* re_nsub doesn't account for the `subexpression' representing the

18
libguile/scm_validate.h
View file

@ -1,4 +1,4 @@
/* $Id: scm_validate.h,v 1.9 2000-01-05 16:16:57 gjb Exp $ */ /* $Id: scm_validate.h,v 1.10 2000-01-05 19:00:02 gjb Exp $ */
/* Copyright (C) 1999 Free Software Foundation, Inc. /* Copyright (C) 1999 Free Software Foundation, Inc.
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
@ -130,39 +130,39 @@
#define SCM_VALIDATE_REAL(pos,z) SCM_MAKE_VALIDATE(pos,z,REALP) #define SCM_VALIDATE_REAL(pos,z) SCM_MAKE_VALIDATE(pos,z,REALP)
#define SCM_VALIDATE_INT(pos,k) SCM_MAKE_VALIDATE(pos,k,INUMP) #define SCM_VALIDATE_INUM(pos,k) SCM_MAKE_VALIDATE(pos,k,INUMP)
#define SCM_VALIDATE_INT_COPY(pos,k,cvar) \ #define SCM_VALIDATE_INUM_COPY(pos,k,cvar) \
do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \ do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \
cvar = SCM_INUM(k); } while (0) cvar = SCM_INUM(k); } while (0)
#define SCM_VALIDATE_BIGINT(pos,k) SCM_MAKE_VALIDATE(pos,k,BIGP) #define SCM_VALIDATE_BIGINT(pos,k) SCM_MAKE_VALIDATE(pos,k,BIGP)
#define SCM_VALIDATE_INT_MIN(pos,k,min) \ #define SCM_VALIDATE_INUM_MIN(pos,k,min) \
do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \ do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \
SCM_ASSERT_RANGE(pos,k,(SCM_INUM(k) >= min)); } while (0) SCM_ASSERT_RANGE(pos,k,(SCM_INUM(k) >= min)); } while (0)
#define SCM_VALIDATE_INT_MIN_COPY(pos,k,min,cvar) \ #define SCM_VALIDATE_INUM_MIN_COPY(pos,k,min,cvar) \
do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \ do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \
cvar = SCM_INUM(k); \ cvar = SCM_INUM(k); \
SCM_ASSERT_RANGE(pos,k,(cvar >= min)); } while (0) SCM_ASSERT_RANGE(pos,k,(cvar >= min)); } while (0)
#define SCM_VALIDATE_INT_MIN_DEF_COPY(pos,k,min,default,cvar) \ #define SCM_VALIDATE_INUM_MIN_DEF_COPY(pos,k,min,default,cvar) \
do { if (SCM_UNBNDP(k)) k = SCM_MAKINUM(default); \ do { if (SCM_UNBNDP(k)) k = SCM_MAKINUM(default); \
SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \ SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \
cvar = SCM_INUM(k); \ cvar = SCM_INUM(k); \
SCM_ASSERT_RANGE(pos,k,(cvar >= min)); } while (0) SCM_ASSERT_RANGE(pos,k,(cvar >= min)); } while (0)
#define SCM_VALIDATE_INT_DEF(pos,k,default) \ #define SCM_VALIDATE_INUM_DEF(pos,k,default) \
do { if (SCM_UNDEFINED==k) k = SCM_MAKINUM(default); \ do { if (SCM_UNDEFINED==k) k = SCM_MAKINUM(default); \
else SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); } while (0) else SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); } while (0)
#define SCM_VALIDATE_INT_DEF_COPY(pos,k,default,cvar) \ #define SCM_VALIDATE_INUM_DEF_COPY(pos,k,default,cvar) \
do { if (SCM_UNDEFINED==k) { k = SCM_MAKINUM(default); cvar=default; } \ do { if (SCM_UNDEFINED==k) { k = SCM_MAKINUM(default); cvar=default; } \
else { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); cvar = SCM_INUM(k); } } while (0) else { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); cvar = SCM_INUM(k); } } while (0)
/* [low,high) */ /* [low,high) */
#define SCM_VALIDATE_INT_RANGE(pos,k,low,high) \ #define SCM_VALIDATE_INUM_RANGE(pos,k,low,high) \
do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \ do { SCM_ASSERT(SCM_INUMP(k), k, pos, FUNC_NAME); \
SCM_ASSERT_RANGE(pos,k,(SCM_INUM (k) >= low && ((unsigned) SCM_INUM (k)) < high)); \ SCM_ASSERT_RANGE(pos,k,(SCM_INUM (k) >= low && ((unsigned) SCM_INUM (k)) < high)); \
} while (0) } while (0)

12
libguile/scmsigs.c
View file

@ -222,7 +222,7 @@ structures.")
SCM *scheme_handlers = SCM_VELTS (*signal_handlers); SCM *scheme_handlers = SCM_VELTS (*signal_handlers);
SCM old_handler; SCM old_handler;
SCM_VALIDATE_INT_COPY(1,signum,csig); SCM_VALIDATE_INUM_COPY(1,signum,csig);
#if defined(HAVE_SIGACTION) #if defined(HAVE_SIGACTION)
#if defined(SA_RESTART) && defined(HAVE_RESTARTABLE_SYSCALLS) #if defined(SA_RESTART) && defined(HAVE_RESTARTABLE_SYSCALLS)
/* don't allow SA_RESTART to be omitted if HAVE_RESTARTABLE_SYSCALLS /* don't allow SA_RESTART to be omitted if HAVE_RESTARTABLE_SYSCALLS
@ -234,7 +234,7 @@ structures.")
#endif #endif
if (!SCM_UNBNDP (flags)) if (!SCM_UNBNDP (flags))
{ {
SCM_VALIDATE_INT(3,flags); SCM_VALIDATE_INUM(3,flags);
action.sa_flags |= SCM_INUM (flags); action.sa_flags |= SCM_INUM (flags);
} }
sigemptyset (&action.sa_mask); sigemptyset (&action.sa_mask);
@ -382,7 +382,7 @@ no previous alarm, the return value is zero.")
#define FUNC_NAME s_scm_alarm #define FUNC_NAME s_scm_alarm
{ {
unsigned int j; unsigned int j;
SCM_VALIDATE_INT(1,i); SCM_VALIDATE_INUM(1,i);
j = alarm (SCM_INUM (i)); j = alarm (SCM_INUM (i));
return SCM_MAKINUM (j); return SCM_MAKINUM (j);
} }
@ -410,7 +410,7 @@ of seconds remaining otherwise.")
#define FUNC_NAME s_scm_sleep #define FUNC_NAME s_scm_sleep
{ {
unsigned long j; unsigned long j;
SCM_VALIDATE_INT_MIN(1,i,0); SCM_VALIDATE_INUM_MIN(1,i,0);
#ifdef USE_THREADS #ifdef USE_THREADS
j = scm_thread_sleep (SCM_INUM(i)); j = scm_thread_sleep (SCM_INUM(i));
#else #else
@ -426,7 +426,7 @@ GUILE_PROC(scm_usleep, "usleep", 1, 0, 0,
"") "")
#define FUNC_NAME s_scm_usleep #define FUNC_NAME s_scm_usleep
{ {
SCM_VALIDATE_INT_MIN(1,i,0); SCM_VALIDATE_INUM_MIN(1,i,0);
#ifdef USE_THREADS #ifdef USE_THREADS
/* If we have threads, we use the thread system's sleep function. */ /* If we have threads, we use the thread system's sleep function. */
@ -456,7 +456,7 @@ Sends a specified signal @var{sig} to the current process, where
@var{sig} is as described for the kill procedure.") @var{sig} is as described for the kill procedure.")
#define FUNC_NAME s_scm_raise #define FUNC_NAME s_scm_raise
{ {
SCM_VALIDATE_INT(1,sig); SCM_VALIDATE_INUM(1,sig);
SCM_DEFER_INTS; SCM_DEFER_INTS;
if (kill (getpid (), (int) SCM_INUM (sig)) != 0) if (kill (getpid (), (int) SCM_INUM (sig)) != 0)
SCM_SYSERROR; SCM_SYSERROR;

2
libguile/simpos.c
View file

@ -130,7 +130,7 @@ is @var{status} if supplied, otherwise zero.")
int cstatus = 0; int cstatus = 0;
if (!SCM_UNBNDP (status)) if (!SCM_UNBNDP (status))
{ {
SCM_VALIDATE_INT(1,status); SCM_VALIDATE_INUM(1,status);
cstatus = SCM_INUM (status); cstatus = SCM_INUM (status);
} }
exit (cstatus); exit (cstatus);

44
libguile/socket.c
View file

@ -80,7 +80,7 @@ short integer.")
{ {
unsigned short c_in; unsigned short c_in;
SCM_VALIDATE_INT_COPY(1,in,c_in); SCM_VALIDATE_INUM_COPY(1,in,c_in);
if (c_in != SCM_INUM (in)) if (c_in != SCM_INUM (in))
SCM_OUT_OF_RANGE (1,in); SCM_OUT_OF_RANGE (1,in);
@ -97,7 +97,7 @@ integer.")
{ {
unsigned short c_in; unsigned short c_in;
SCM_VALIDATE_INT_COPY(1,in,c_in); SCM_VALIDATE_INUM_COPY(1,in,c_in);
if (c_in != SCM_INUM (in)) if (c_in != SCM_INUM (in))
SCM_OUT_OF_RANGE (1,in); SCM_OUT_OF_RANGE (1,in);
@ -163,9 +163,9 @@ it has been connected to another socket.")
int fd; int fd;
SCM result; SCM result;
SCM_VALIDATE_INT(1,family); SCM_VALIDATE_INUM(1,family);
SCM_VALIDATE_INT(2,style); SCM_VALIDATE_INUM(2,style);
SCM_VALIDATE_INT(3,proto); SCM_VALIDATE_INUM(3,proto);
fd = socket (SCM_INUM (family), SCM_INUM (style), SCM_INUM (proto)); fd = socket (SCM_INUM (family), SCM_INUM (style), SCM_INUM (proto));
result = SCM_SOCK_FD_TO_PORT (fd); result = SCM_SOCK_FD_TO_PORT (fd);
return result; return result;
@ -189,9 +189,9 @@ the only meaningful value for @var{protocol}.")
SCM a; SCM a;
SCM b; SCM b;
SCM_VALIDATE_INT(1,family); SCM_VALIDATE_INUM(1,family);
SCM_VALIDATE_INT(2,style); SCM_VALIDATE_INUM(2,style);
SCM_VALIDATE_INT(3,proto); SCM_VALIDATE_INUM(3,proto);
fam = SCM_INUM (family); fam = SCM_INUM (family);
@ -236,8 +236,8 @@ pair of integers.")
sock = SCM_COERCE_OUTPORT (sock); sock = SCM_COERCE_OUTPORT (sock);
SCM_VALIDATE_OPFPORT(1,sock); SCM_VALIDATE_OPFPORT(1,sock);
SCM_VALIDATE_INT_COPY(2,level,ilevel); SCM_VALIDATE_INUM_COPY(2,level,ilevel);
SCM_VALIDATE_INT_COPY(3,optname,ioptname); SCM_VALIDATE_INUM_COPY(3,optname,ioptname);
fd = SCM_FPORT_FDES (sock); fd = SCM_FPORT_FDES (sock);
if (getsockopt (fd, ilevel, ioptname, (void *) optval, &optlen) == -1) if (getsockopt (fd, ilevel, ioptname, (void *) optval, &optlen) == -1)
@ -300,8 +300,8 @@ The return value is unspecified.")
int ilevel, ioptname; int ilevel, ioptname;
sock = SCM_COERCE_OUTPORT (sock); sock = SCM_COERCE_OUTPORT (sock);
SCM_VALIDATE_OPFPORT(1,sock); SCM_VALIDATE_OPFPORT(1,sock);
SCM_VALIDATE_INT_COPY(2,level,ilevel); SCM_VALIDATE_INUM_COPY(2,level,ilevel);
SCM_VALIDATE_INT_COPY(3,optname,ioptname); SCM_VALIDATE_INUM_COPY(3,optname,ioptname);
fd = SCM_FPORT_FDES (sock); fd = SCM_FPORT_FDES (sock);
if (0); if (0);
#ifdef SO_LINGER #ifdef SO_LINGER
@ -332,7 +332,7 @@ The return value is unspecified.")
#ifdef SO_SNDBUF #ifdef SO_SNDBUF
else if (ilevel == SOL_SOCKET && ioptname == SO_SNDBUF) else if (ilevel == SOL_SOCKET && ioptname == SO_SNDBUF)
{ {
SCM_VALIDATE_INT(4,value); SCM_VALIDATE_INUM(4,value);
optlen = (int) sizeof (scm_sizet); optlen = (int) sizeof (scm_sizet);
(*(scm_sizet *) optval) = (scm_sizet) SCM_INUM (value); (*(scm_sizet *) optval) = (scm_sizet) SCM_INUM (value);
} }
@ -340,7 +340,7 @@ The return value is unspecified.")
#ifdef SO_RCVBUF #ifdef SO_RCVBUF
else if (ilevel == SOL_SOCKET && ioptname == SO_RCVBUF) else if (ilevel == SOL_SOCKET && ioptname == SO_RCVBUF)
{ {
SCM_VALIDATE_INT(4,value); SCM_VALIDATE_INUM(4,value);
optlen = (int) sizeof (scm_sizet); optlen = (int) sizeof (scm_sizet);
(*(scm_sizet *) optval) = (scm_sizet) SCM_INUM (value); (*(scm_sizet *) optval) = (scm_sizet) SCM_INUM (value);
} }
@ -348,7 +348,7 @@ The return value is unspecified.")
else else
{ {
/* Most options just take an int. */ /* Most options just take an int. */
SCM_VALIDATE_INT(4,value); SCM_VALIDATE_INUM(4,value);
optlen = (int) sizeof (int); optlen = (int) sizeof (int);
(*(int *) optval) = (int) SCM_INUM (value); (*(int *) optval) = (int) SCM_INUM (value);
} }
@ -382,7 +382,7 @@ The return value is unspecified.")
int fd; int fd;
sock = SCM_COERCE_OUTPORT (sock); sock = SCM_COERCE_OUTPORT (sock);
SCM_VALIDATE_OPFPORT(1,sock); SCM_VALIDATE_OPFPORT(1,sock);
SCM_VALIDATE_INT(2,how); SCM_VALIDATE_INUM(2,how);
SCM_ASSERT_RANGE(2,how,0 <= SCM_INUM (how) && 2 >= SCM_INUM (how)); SCM_ASSERT_RANGE(2,how,0 <= SCM_INUM (how) && 2 >= SCM_INUM (how));
fd = SCM_FPORT_FDES (sock); fd = SCM_FPORT_FDES (sock);
if (shutdown (fd, SCM_INUM (how)) == -1) if (shutdown (fd, SCM_INUM (how)) == -1)
@ -471,7 +471,7 @@ The return value is unspecified.")
sock = SCM_COERCE_OUTPORT (sock); sock = SCM_COERCE_OUTPORT (sock);
SCM_VALIDATE_OPFPORT(1,sock); SCM_VALIDATE_OPFPORT(1,sock);
SCM_VALIDATE_INT(2,fam); SCM_VALIDATE_INUM(2,fam);
fd = SCM_FPORT_FDES (sock); fd = SCM_FPORT_FDES (sock);
soka = scm_fill_sockaddr (SCM_INUM (fam), address, &args, 3, FUNC_NAME, &size); soka = scm_fill_sockaddr (SCM_INUM (fam), address, &args, 3, FUNC_NAME, &size);
if (connect (fd, soka, size) == -1) if (connect (fd, soka, size) == -1)
@ -528,7 +528,7 @@ The return value is unspecified.")
sock = SCM_COERCE_OUTPORT (sock); sock = SCM_COERCE_OUTPORT (sock);
SCM_VALIDATE_OPFPORT(1,sock); SCM_VALIDATE_OPFPORT(1,sock);
SCM_VALIDATE_INT(2,fam); SCM_VALIDATE_INUM(2,fam);
soka = scm_fill_sockaddr (SCM_INUM (fam), address, &args, 3, FUNC_NAME, &size); soka = scm_fill_sockaddr (SCM_INUM (fam), address, &args, 3, FUNC_NAME, &size);
fd = SCM_FPORT_FDES (sock); fd = SCM_FPORT_FDES (sock);
rv = bind (fd, soka, size); rv = bind (fd, soka, size);
@ -553,7 +553,7 @@ The return value is unspecified.")
int fd; int fd;
sock = SCM_COERCE_OUTPORT (sock); sock = SCM_COERCE_OUTPORT (sock);
SCM_VALIDATE_OPFPORT(1,sock); SCM_VALIDATE_OPFPORT(1,sock);
SCM_VALIDATE_INT(2,backlog); SCM_VALIDATE_INUM(2,backlog);
fd = SCM_FPORT_FDES (sock); fd = SCM_FPORT_FDES (sock);
if (listen (fd, SCM_INUM (backlog)) == -1) if (listen (fd, SCM_INUM (backlog)) == -1)
SCM_SYSERROR; SCM_SYSERROR;
@ -729,7 +729,7 @@ any unread buffered port data is ignored.")
SCM_VALIDATE_OPFPORT(1,sock); SCM_VALIDATE_OPFPORT(1,sock);
SCM_VALIDATE_STRING(2,buf); SCM_VALIDATE_STRING(2,buf);
SCM_VALIDATE_INT_DEF_COPY(3,flags,0,flg); SCM_VALIDATE_INUM_DEF_COPY(3,flags,0,flg);
fd = SCM_FPORT_FDES (sock); fd = SCM_FPORT_FDES (sock);
SCM_SYSCALL (rv = recv (fd, SCM_CHARS (buf), SCM_LENGTH (buf), flg)); SCM_SYSCALL (rv = recv (fd, SCM_CHARS (buf), SCM_LENGTH (buf), flg));
@ -760,7 +760,7 @@ any unflushed buffered port data is ignored.")
sock = SCM_COERCE_OUTPORT (sock); sock = SCM_COERCE_OUTPORT (sock);
SCM_VALIDATE_OPFPORT(1,sock); SCM_VALIDATE_OPFPORT(1,sock);
SCM_VALIDATE_ROSTRING(2,message); SCM_VALIDATE_ROSTRING(2,message);
SCM_VALIDATE_INT_DEF_COPY(3,flags,0,flg); SCM_VALIDATE_INUM_DEF_COPY(3,flags,0,flg);
fd = SCM_FPORT_FDES (sock); fd = SCM_FPORT_FDES (sock);
SCM_SYSCALL (rv = send (fd, SCM_ROCHARS (message), SCM_ROLENGTH (message), flg)); SCM_SYSCALL (rv = send (fd, SCM_ROCHARS (message), SCM_ROLENGTH (message), flg));
@ -875,7 +875,7 @@ any unflushed buffered port data is ignored.")
sock = SCM_COERCE_OUTPORT (sock); sock = SCM_COERCE_OUTPORT (sock);
SCM_VALIDATE_FPORT(1,sock); SCM_VALIDATE_FPORT(1,sock);
SCM_VALIDATE_ROSTRING(2,message); SCM_VALIDATE_ROSTRING(2,message);
SCM_VALIDATE_INT(3,fam); SCM_VALIDATE_INUM(3,fam);
fd = SCM_FPORT_FDES (sock); fd = SCM_FPORT_FDES (sock);
soka = scm_fill_sockaddr (SCM_INUM (fam), address, &args_and_flags, 4, soka = scm_fill_sockaddr (SCM_INUM (fam), address, &args_and_flags, 4,
FUNC_NAME, &size); FUNC_NAME, &size);

4
libguile/sort.c
View file

@ -441,9 +441,9 @@ GUILE_PROC (scm_restricted_vector_sort_x, "restricted-vector-sort!", 4, 0, 0,
vp = SCM_VELTS (vec); /* vector pointer */ vp = SCM_VELTS (vec); /* vector pointer */
vlen = SCM_LENGTH (vec); vlen = SCM_LENGTH (vec);
SCM_VALIDATE_INT_COPY(3,startpos,spos); SCM_VALIDATE_INUM_COPY(3,startpos,spos);
SCM_ASSERT_RANGE (3,startpos,(spos >= 0) && (spos <= vlen)); SCM_ASSERT_RANGE (3,startpos,(spos >= 0) && (spos <= vlen));
SCM_VALIDATE_INT_RANGE(4,endpos,0,vlen+1); SCM_VALIDATE_INUM_RANGE(4,endpos,0,vlen+1);
len = SCM_INUM (endpos) - spos; len = SCM_INUM (endpos) - spos;
quicksort (&vp[spos], len, size, scm_cmp_function (less), less); quicksort (&vp[spos], len, size, scm_cmp_function (less), less);

4
libguile/srcprop.c
View file

@ -281,7 +281,7 @@ GUILE_PROC (scm_set_source_property_x, "set-source-property!", 3, 0, 0,
} }
else if (scm_sym_line == key) else if (scm_sym_line == key)
{ {
SCM_VALIDATE_INT(3,datum); SCM_VALIDATE_INUM(3,datum);
if (SRCPROPSP (p)) if (SRCPROPSP (p))
SETSRCPROPLINE (p, SCM_INUM (datum)); SETSRCPROPLINE (p, SCM_INUM (datum));
else else
@ -291,7 +291,7 @@ GUILE_PROC (scm_set_source_property_x, "set-source-property!", 3, 0, 0,
} }
else if (scm_sym_column == key) else if (scm_sym_column == key)
{ {
SCM_VALIDATE_INT(3,datum); SCM_VALIDATE_INUM(3,datum);
if (SRCPROPSP (p)) if (SRCPROPSP (p))
SETSRCPROPCOL (p, SCM_INUM (datum)); SETSRCPROPCOL (p, SCM_INUM (datum));
else else

2
libguile/stacks.c
View file

@ -552,7 +552,7 @@ GUILE_PROC (scm_stack_ref, "stack-ref", 2, 0, 0,
#define FUNC_NAME s_scm_stack_ref #define FUNC_NAME s_scm_stack_ref
{ {
SCM_VALIDATE_STACK(1,stack); SCM_VALIDATE_STACK(1,stack);
SCM_VALIDATE_INT(2,i); SCM_VALIDATE_INUM(2,i);
SCM_ASSERT_RANGE (1,i, SCM_ASSERT_RANGE (1,i,
SCM_INUM (i) >= 0 && SCM_INUM (i) >= 0 &&
SCM_INUM (i) < SCM_STACK_LENGTH (stack)); SCM_INUM (i) < SCM_STACK_LENGTH (stack));

14
libguile/strings.c
View file

@ -254,7 +254,7 @@ GUILE_PROC(scm_make_string, "make-string", 1, 1, 0,
{ {
SCM res; SCM res;
register long i; register long i;
SCM_VALIDATE_INT_MIN_COPY(1,k,0,i); SCM_VALIDATE_INUM_MIN_COPY(1,k,0,i);
res = scm_makstr (i, 0); res = scm_makstr (i, 0);
if (!SCM_UNBNDP (chr)) if (!SCM_UNBNDP (chr))
{ {
@ -286,7 +286,7 @@ GUILE_PROC(scm_string_ref, "string-ref", 1, 1, 0,
#define FUNC_NAME s_scm_string_ref #define FUNC_NAME s_scm_string_ref
{ {
SCM_VALIDATE_ROSTRING(1,str); SCM_VALIDATE_ROSTRING(1,str);
SCM_VALIDATE_INT_DEF(2,k,0); SCM_VALIDATE_INUM_DEF(2,k,0);
SCM_ASSERT_RANGE (2,k,SCM_INUM (k) < SCM_ROLENGTH (str) && SCM_INUM (k) >= 0); SCM_ASSERT_RANGE (2,k,SCM_INUM (k) < SCM_ROLENGTH (str) && SCM_INUM (k) >= 0);
return SCM_MAKICHR (SCM_ROUCHARS (str)[SCM_INUM (k)]); return SCM_MAKICHR (SCM_ROUCHARS (str)[SCM_INUM (k)]);
} }
@ -298,7 +298,7 @@ GUILE_PROC(scm_string_set_x, "string-set!", 3, 0, 0,
#define FUNC_NAME s_scm_string_set_x #define FUNC_NAME s_scm_string_set_x
{ {
SCM_VALIDATE_RWSTRING(1,str); SCM_VALIDATE_RWSTRING(1,str);
SCM_VALIDATE_INT_RANGE(2,k,0,SCM_LENGTH(str)); SCM_VALIDATE_INUM_RANGE(2,k,0,SCM_LENGTH(str));
SCM_VALIDATE_CHAR(3,chr); SCM_VALIDATE_CHAR(3,chr);
SCM_UCHARS (str)[SCM_INUM (k)] = SCM_ICHR (chr); SCM_UCHARS (str)[SCM_INUM (k)] = SCM_ICHR (chr);
return SCM_UNSPECIFIED; return SCM_UNSPECIFIED;
@ -314,8 +314,8 @@ GUILE_PROC(scm_substring, "substring", 2, 1, 0,
{ {
long l; long l;
SCM_VALIDATE_ROSTRING(1,str); SCM_VALIDATE_ROSTRING(1,str);
SCM_VALIDATE_INT(2,start); SCM_VALIDATE_INUM(2,start);
SCM_VALIDATE_INT_DEF(3,end,SCM_ROLENGTH(str)); SCM_VALIDATE_INUM_DEF(3,end,SCM_ROLENGTH(str));
SCM_ASSERT_RANGE (2,start,SCM_INUM (start) <= SCM_ROLENGTH (str)); SCM_ASSERT_RANGE (2,start,SCM_INUM (start) <= SCM_ROLENGTH (str));
SCM_ASSERT_RANGE (2,end,SCM_INUM (end) <= SCM_ROLENGTH (str)); SCM_ASSERT_RANGE (2,end,SCM_INUM (end) <= SCM_ROLENGTH (str));
l = SCM_INUM (end)-SCM_INUM (start); l = SCM_INUM (end)-SCM_INUM (start);
@ -367,8 +367,8 @@ defaults to the end of @var{str}. The shared substring returned by
SCM len_str; SCM len_str;
SCM_VALIDATE_ROSTRING(1,str); SCM_VALIDATE_ROSTRING(1,str);
SCM_VALIDATE_INT_DEF_COPY(2,frm,0,f); SCM_VALIDATE_INUM_DEF_COPY(2,frm,0,f);
SCM_VALIDATE_INT_DEF_COPY(3,to,SCM_ROLENGTH(str),t); SCM_VALIDATE_INUM_DEF_COPY(3,to,SCM_ROLENGTH(str),t);
SCM_ASSERT_RANGE (2,frm,(f >= 0)); SCM_ASSERT_RANGE (2,frm,(f >= 0));
SCM_ASSERT_RANGE (3,to, (f <= t) && (t <= SCM_ROLENGTH (str))); SCM_ASSERT_RANGE (3,to, (f <= t) && (t <= SCM_ROLENGTH (str)));

10
libguile/strop.c
View file

@ -155,10 +155,10 @@ are different strings, it does not matter which function you use.")
long s1, s2, e, len; long s1, s2, e, len;
SCM_VALIDATE_STRING(1,str1); SCM_VALIDATE_STRING(1,str1);
SCM_VALIDATE_INT_COPY(2,start1,s1); SCM_VALIDATE_INUM_COPY(2,start1,s1);
SCM_VALIDATE_INT_COPY(3,end1,e); SCM_VALIDATE_INUM_COPY(3,end1,e);
SCM_VALIDATE_STRING(4,str2); SCM_VALIDATE_STRING(4,str2);
SCM_VALIDATE_INT_COPY(5,start2,s2); SCM_VALIDATE_INUM_COPY(5,start2,s2);
len = e - s1; len = e - s1;
SCM_ASSERT_RANGE (3,end1,len >= 0); SCM_ASSERT_RANGE (3,end1,len >= 0);
SCM_ASSERT_RANGE (2,start1,s1 <= SCM_LENGTH (str1) && s1 >= 0); SCM_ASSERT_RANGE (2,start1,s1 <= SCM_LENGTH (str1) && s1 >= 0);
@ -184,8 +184,8 @@ GUILE_PROC(scm_substring_fill_x, "substring-fill!", 4, 0, 0,
long i, e; long i, e;
char c; char c;
SCM_VALIDATE_STRING(1,str); SCM_VALIDATE_STRING(1,str);
SCM_VALIDATE_INT_COPY(2,start,i); SCM_VALIDATE_INUM_COPY(2,start,i);
SCM_VALIDATE_INT_COPY(3,end,e); SCM_VALIDATE_INUM_COPY(3,end,e);
SCM_VALIDATE_CHAR_COPY(4,fill,c); SCM_VALIDATE_CHAR_COPY(4,fill,c);
SCM_ASSERT_RANGE (2,start,i <= SCM_LENGTH (str) && i >= 0); SCM_ASSERT_RANGE (2,start,i <= SCM_LENGTH (str) && i >= 0);
SCM_ASSERT_RANGE (3,end,e <= SCM_LENGTH (str) && e >= 0); SCM_ASSERT_RANGE (3,end,e <= SCM_LENGTH (str) && e >= 0);

8
libguile/struct.c
View file

@ -391,7 +391,7 @@ can not be initialized by Scheme programs.")
SCM handle; SCM handle;
SCM_VALIDATE_VTABLE(1,vtable); SCM_VALIDATE_VTABLE(1,vtable);
SCM_VALIDATE_INT(2,tail_array_size); SCM_VALIDATE_INUM(2,tail_array_size);
layout = SCM_STRUCT_DATA (vtable)[scm_vtable_index_layout]; layout = SCM_STRUCT_DATA (vtable)[scm_vtable_index_layout];
basic_size = SCM_LENGTH (layout) / 2; basic_size = SCM_LENGTH (layout) / 2;
@ -497,7 +497,7 @@ provided, it will be interpreted as a print call-back function.
SCM handle; SCM handle;
SCM_VALIDATE_ROSTRING(1,extra_fields); SCM_VALIDATE_ROSTRING(1,extra_fields);
SCM_VALIDATE_INT(2,tail_array_size); SCM_VALIDATE_INUM(2,tail_array_size);
fields = scm_string_append (scm_listify (required_vtable_fields, fields = scm_string_append (scm_listify (required_vtable_fields,
extra_fields, extra_fields,
@ -543,7 +543,7 @@ integer value small enough to fit in one machine word.")
SCM_VALIDATE_STRUCT(1,handle); SCM_VALIDATE_STRUCT(1,handle);
SCM_VALIDATE_INT(2,pos); SCM_VALIDATE_INUM(2,pos);
layout = SCM_STRUCT_LAYOUT (handle); layout = SCM_STRUCT_LAYOUT (handle);
data = SCM_STRUCT_DATA (handle); data = SCM_STRUCT_DATA (handle);
@ -620,7 +620,7 @@ GUILE_PROC (scm_struct_set_x, "struct-set!", 3, 0, 0,
unsigned char field_type = 0; unsigned char field_type = 0;
SCM_VALIDATE_STRUCT(1,handle); SCM_VALIDATE_STRUCT(1,handle);
SCM_VALIDATE_INT(2,pos); SCM_VALIDATE_INUM(2,pos);
layout = SCM_STRUCT_LAYOUT (handle); layout = SCM_STRUCT_LAYOUT (handle);
data = SCM_STRUCT_DATA (handle); data = SCM_STRUCT_DATA (handle);

10
libguile/unif.c
View file

@ -1071,7 +1071,7 @@ GUILE_PROC(scm_uniform_vector_ref, "uniform-vector-ref", 2, 0, 0,
} }
else else
{ {
SCM_VALIDATE_INT(2,args); SCM_VALIDATE_INUM(2,args);
pos = SCM_INUM (args); pos = SCM_INUM (args);
} }
SCM_ASRTGO (pos >= 0 && pos < SCM_LENGTH (v), outrng); SCM_ASRTGO (pos >= 0 && pos < SCM_LENGTH (v), outrng);
@ -1261,7 +1261,7 @@ GUILE_PROC(scm_array_set_x, "array-set!", 2, 0, 1,
} }
else else
{ {
SCM_VALIDATE_INT_COPY(3,args,pos); SCM_VALIDATE_INUM_COPY(3,args,pos);
} }
SCM_ASRTGO (pos >= 0 && pos < SCM_LENGTH (v), outrng); SCM_ASRTGO (pos >= 0 && pos < SCM_LENGTH (v), outrng);
} }
@ -1741,7 +1741,7 @@ GUILE_PROC(scm_bit_count, "bit-count", 2, 0, 0,
{ {
long i; long i;
register unsigned long cnt = 0, w; register unsigned long cnt = 0, w;
SCM_VALIDATE_INT(2,seq); SCM_VALIDATE_INUM(2,seq);
switch SCM_TYP7 (seq) switch SCM_TYP7 (seq)
{ {
default: default:
@ -1779,7 +1779,7 @@ range @code{#f} is returned.")
long i, lenw, xbits, pos; long i, lenw, xbits, pos;
register unsigned long w; register unsigned long w;
SCM_VALIDATE_NIM (2,v); SCM_VALIDATE_NIM (2,v);
SCM_VALIDATE_INT_COPY(3,k,pos); SCM_VALIDATE_INUM_COPY(3,k,pos);
SCM_ASSERT ((pos <= SCM_LENGTH (v)) && (pos >= 0), SCM_ASSERT ((pos <= SCM_LENGTH (v)) && (pos >= 0),
k, SCM_OUTOFRANGE, FUNC_NAME); k, SCM_OUTOFRANGE, FUNC_NAME);
if (pos == SCM_LENGTH (v)) if (pos == SCM_LENGTH (v))
@ -2170,7 +2170,7 @@ appropriate type, no coercions are done.")
SCM ra; SCM ra;
scm_sizet k; scm_sizet k;
long n; long n;
SCM_VALIDATE_INT_COPY(1,ndim,k); SCM_VALIDATE_INUM_COPY(1,ndim,k);
while (k--) while (k--)
{ {
n = scm_ilength (row); n = scm_ilength (row);

14
libguile/vectors.c
View file

@ -204,7 +204,7 @@ GUILE_PROC (scm_make_vector, "make-vector", 1, 1, 0,
register long j; register long j;
register SCM *velts; register SCM *velts;
SCM_VALIDATE_INT_MIN(1,k,0); SCM_VALIDATE_INUM_MIN(1,k,0);
if (SCM_UNBNDP(fill)) if (SCM_UNBNDP(fill))
fill = SCM_UNSPECIFIED; fill = SCM_UNSPECIFIED;
i = SCM_INUM(k); i = SCM_INUM(k);
@ -275,10 +275,10 @@ GUILE_PROC (scm_vector_move_left_x, "vector-move-left!", 5, 0, 0,
long e; long e;
SCM_VALIDATE_VECTOR(1,vec1); SCM_VALIDATE_VECTOR(1,vec1);
SCM_VALIDATE_INT_COPY(2,start1,i); SCM_VALIDATE_INUM_COPY(2,start1,i);
SCM_VALIDATE_INT_COPY(3,end1,e); SCM_VALIDATE_INUM_COPY(3,end1,e);
SCM_VALIDATE_VECTOR(4,vec2); SCM_VALIDATE_VECTOR(4,vec2);
SCM_VALIDATE_INT_COPY(5,start2,j); SCM_VALIDATE_INUM_COPY(5,start2,j);
SCM_ASSERT (i <= SCM_LENGTH (vec1) && i >= 0, start1, SCM_OUTOFRANGE, FUNC_NAME); SCM_ASSERT (i <= SCM_LENGTH (vec1) && i >= 0, start1, SCM_OUTOFRANGE, FUNC_NAME);
SCM_ASSERT (j <= SCM_LENGTH (vec2) && j >= 0, start2, SCM_OUTOFRANGE, FUNC_NAME); SCM_ASSERT (j <= SCM_LENGTH (vec2) && j >= 0, start2, SCM_OUTOFRANGE, FUNC_NAME);
SCM_ASSERT (e <= SCM_LENGTH (vec1) && e >= 0, end1, SCM_OUTOFRANGE, FUNC_NAME); SCM_ASSERT (e <= SCM_LENGTH (vec1) && e >= 0, end1, SCM_OUTOFRANGE, FUNC_NAME);
@ -298,10 +298,10 @@ GUILE_PROC (scm_vector_move_right_x, "vector-move-right!", 5, 0, 0,
long e; long e;
SCM_VALIDATE_VECTOR(1,vec1); SCM_VALIDATE_VECTOR(1,vec1);
SCM_VALIDATE_INT_COPY(2,start1,i); SCM_VALIDATE_INUM_COPY(2,start1,i);
SCM_VALIDATE_INT_COPY(3,end1,e); SCM_VALIDATE_INUM_COPY(3,end1,e);
SCM_VALIDATE_VECTOR(4,vec2); SCM_VALIDATE_VECTOR(4,vec2);
SCM_VALIDATE_INT_COPY(5,start2,j); SCM_VALIDATE_INUM_COPY(5,start2,j);
SCM_ASSERT (i <= SCM_LENGTH (vec1) && i >= 0, start1, SCM_OUTOFRANGE, FUNC_NAME); SCM_ASSERT (i <= SCM_LENGTH (vec1) && i >= 0, start1, SCM_OUTOFRANGE, FUNC_NAME);
SCM_ASSERT (j <= SCM_LENGTH (vec2) && j >= 0, start2, SCM_OUTOFRANGE, FUNC_NAME); SCM_ASSERT (j <= SCM_LENGTH (vec2) && j >= 0, start2, SCM_OUTOFRANGE, FUNC_NAME);
SCM_ASSERT (e <= SCM_LENGTH (vec1) && e >= 0, end1, SCM_OUTOFRANGE, FUNC_NAME); SCM_ASSERT (e <= SCM_LENGTH (vec1) && e >= 0, end1, SCM_OUTOFRANGE, FUNC_NAME);

6
libguile/weaks.c
View file

@ -131,7 +131,7 @@ regular hash tables. (@pxref{Hash Tables})")
#define FUNC_NAME s_scm_make_weak_key_hash_table #define FUNC_NAME s_scm_make_weak_key_hash_table
{ {
SCM v; SCM v;
SCM_VALIDATE_INT(1,k); SCM_VALIDATE_INUM(1,k);
v = scm_make_weak_vector (k, SCM_EOL); v = scm_make_weak_vector (k, SCM_EOL);
SCM_ALLOW_INTS; SCM_ALLOW_INTS;
SCM_VELTS (v)[-1] = 1; SCM_VELTS (v)[-1] = 1;
@ -147,7 +147,7 @@ GUILE_PROC (scm_make_weak_value_hash_table, "make-weak-value-hash-table", 1, 0,
#define FUNC_NAME s_scm_make_weak_value_hash_table #define FUNC_NAME s_scm_make_weak_value_hash_table
{ {
SCM v; SCM v;
SCM_VALIDATE_INT(1,k); SCM_VALIDATE_INUM(1,k);
v = scm_make_weak_vector (k, SCM_EOL); v = scm_make_weak_vector (k, SCM_EOL);
SCM_ALLOW_INTS; SCM_ALLOW_INTS;
SCM_VELTS (v)[-1] = 2; SCM_VELTS (v)[-1] = 2;
@ -164,7 +164,7 @@ GUILE_PROC (scm_make_doubly_weak_hash_table, "make-doubly-weak-hash-table", 1, 0
#define FUNC_NAME s_scm_make_doubly_weak_hash_table #define FUNC_NAME s_scm_make_doubly_weak_hash_table
{ {
SCM v; SCM v;
SCM_VALIDATE_INT(1,k); SCM_VALIDATE_INUM(1,k);
v = scm_make_weak_vector (k, SCM_EOL); v = scm_make_weak_vector (k, SCM_EOL);
SCM_ALLOW_INTS; SCM_ALLOW_INTS;
SCM_VELTS (v)[-1] = 3; SCM_VELTS (v)[-1] = 3;