* scm_validate.h: Added SCM_VALIDATE_THREAD.
* *.c: Remove SCM_NIMP(X) when it is an extraneous pre-test given
that SCM_FOOP macros all now include SCM_NIMP in their expansion.
This simplifies lots of code, making it far more readable.
#define FUNC_NAME s_scm_sloppy_assq
{
- for (; SCM_NIMP (alist) && SCM_CONSP (alist); alist = SCM_CDR (alist))
+ for (; SCM_CONSP (alist); alist = SCM_CDR (alist))
{
SCM tmp = SCM_CAR(alist);
- if (SCM_NIMP (tmp) && SCM_CONSP (tmp) && (SCM_CAR (tmp)==x))
+ if (SCM_CONSP (tmp) && (SCM_CAR (tmp)==x))
return tmp;
}
return SCM_BOOL_F;
Recommended only for use in Guile internals.")
#define FUNC_NAME s_scm_sloppy_assv
{
- for (; SCM_NIMP (alist) && SCM_CONSP (alist); alist = SCM_CDR (alist))
+ for (; SCM_CONSP (alist); alist = SCM_CDR (alist))
{
SCM tmp = SCM_CAR(alist);
if (SCM_NIMP (tmp)
Recommended only for use in Guile internals.")
#define FUNC_NAME s_scm_sloppy_assoc
{
- for (; SCM_NIMP (alist) && SCM_CONSP (alist); alist = SCM_CDR (alist))
+ for (; SCM_CONSP (alist); alist = SCM_CDR (alist))
{
SCM tmp = SCM_CAR(alist);
if (SCM_NIMP (tmp)
for(;SCM_NIMP(alist);alist = SCM_CDR(alist)) {
SCM_ASRTGO(SCM_CONSP(alist), badlst);
tmp = SCM_CAR(alist);
- SCM_ASRTGO(SCM_NIMP(tmp) && SCM_CONSP(tmp), badlst);
+ SCM_ASRTGO(SCM_CONSP(tmp), badlst);
if SCM_NFALSEP(scm_eqv_p(SCM_CAR(tmp), x)) return tmp;
}
# ifndef SCM_RECKLESS
SCM handle;
handle = scm_sloppy_assq (key, alist);
- if (SCM_NIMP (handle) && SCM_CONSP (handle))
+ if (SCM_CONSP (handle))
{
return SCM_CDR (handle);
}
SCM handle;
handle = scm_sloppy_assv (key, alist);
- if (SCM_NIMP (handle) && SCM_CONSP (handle))
+ if (SCM_CONSP (handle))
{
return SCM_CDR (handle);
}
SCM handle;
handle = scm_sloppy_assoc (key, alist);
- if (SCM_NIMP (handle) && SCM_CONSP (handle))
+ if (SCM_CONSP (handle))
{
return SCM_CDR (handle);
}
SCM handle;
handle = scm_sloppy_assq (key, alist);
- if (SCM_NIMP (handle) && SCM_CONSP (handle))
+ if (SCM_CONSP (handle))
{
SCM_SETCDR (handle, val);
return alist;
SCM handle;
handle = scm_sloppy_assv (key, alist);
- if (SCM_NIMP (handle) && SCM_CONSP (handle))
+ if (SCM_CONSP (handle))
{
SCM_SETCDR (handle, val);
return alist;
SCM handle;
handle = scm_sloppy_assoc (key, alist);
- if (SCM_NIMP (handle) && SCM_CONSP (handle))
+ if (SCM_CONSP (handle))
{
SCM_SETCDR (handle, val);
return alist;
SCM handle;
handle = scm_sloppy_assq (key, alist);
- if (SCM_NIMP (handle) && SCM_CONSP (handle))
+ if (SCM_CONSP (handle))
{
return scm_delq_x (handle, alist);
}
SCM handle;
handle = scm_sloppy_assv (key, alist);
- if (SCM_NIMP (handle) && SCM_CONSP (handle))
+ if (SCM_CONSP (handle))
{
return scm_delv_x (handle, alist);
}
SCM handle;
handle = scm_sloppy_assoc (key, alist);
- if (SCM_NIMP (handle) && SCM_CONSP (handle))
+ if (SCM_CONSP (handle))
{
return scm_delete_x (handle, alist);
}
struct scm_async * it;
SCM_VALIDATE_NIMCONS(1,list_of_a);
a = SCM_CAR (list_of_a);
- SCM_ASSERT (SCM_NIMP (a) && SCM_ASYNCP (a), a, SCM_ARG1, FUNC_NAME);
+ SCM_ASSERT (SCM_ASYNCP (a), a, SCM_ARG1, FUNC_NAME);
it = SCM_ASYNC (a);
scm_mask_ints = 1;
if (it->got_it)
#include "throw.h"
#include "fluids.h"
+#include "scm_validate.h"
#include "backtrace.h"
/* {Error reporting and backtraces}
static void
display_header (SCM source, SCM port)
{
- SCM fname = (SCM_NIMP (source) && SCM_MEMOIZEDP (source)
+ SCM fname = (SCM_MEMOIZEDP (source)
? scm_source_property (source, scm_sym_filename)
: SCM_BOOL_F);
- if (SCM_NIMP (fname) && SCM_STRINGP (fname))
+ if (SCM_STRINGP (fname))
{
scm_prin1 (fname, port, 0);
scm_putc (':', port);
pstate->fancyp = 1;
pstate->level = 2;
pstate->length = 3;
- if (SCM_NIMP (pname) && SCM_ROSTRINGP (pname))
+ if (SCM_ROSTRINGP (pname))
{
if (SCM_NIMP (frame)
&& SCM_FRAMEP (frame)
else
scm_puts ("In procedure ", port);
scm_iprin1 (pname, port, pstate);
- if (SCM_NIMP (source) && SCM_MEMOIZEDP (source))
+ if (SCM_MEMOIZEDP (source))
{
scm_puts (" in expression ", port);
pstate->writingp = 1;
current_frame = scm_stack_ref (a->stack, SCM_INUM0);
source = SCM_FRAME_SOURCE (current_frame);
prev_frame = SCM_FRAME_PREV (current_frame);
- if (!(SCM_NIMP (source) && SCM_MEMOIZEDP (source))
+ if (!SCM_MEMOIZEDP (source)
&& prev_frame != SCM_BOOL_F)
source = SCM_FRAME_SOURCE (prev_frame);
if (SCM_FRAME_PROC_P (current_frame)
&& scm_procedure_p (SCM_FRAME_PROC (current_frame)) == SCM_BOOL_T)
pname = scm_procedure_name (SCM_FRAME_PROC (current_frame));
}
- if (!(SCM_NIMP (pname) && SCM_ROSTRINGP (pname)))
+ if (!SCM_ROSTRINGP (pname))
pname = a->subr;
- if ((SCM_NIMP (pname) && SCM_ROSTRINGP (pname))
- || (SCM_NIMP (source) && SCM_MEMOIZEDP (source)))
+ if (SCM_ROSTRINGP (pname) || SCM_MEMOIZEDP (source))
{
display_header (source, a->port);
display_expression (current_frame, pname, source, a->port);
{
pstate->length = print_params[i].length;
ptob->seek (sport, 0, SEEK_SET);
- if (SCM_NIMP (exp) && SCM_CONSP (exp))
+ if (SCM_CONSP (exp))
{
pstate->level = print_params[i].level - 1;
scm_iprlist (hdr, exp, tlr[0], sport, pstate);
"")
#define FUNC_NAME s_scm_display_application
{
- SCM_ASSERT (SCM_NIMP (frame) && SCM_FRAMEP (frame),
- frame, SCM_ARG1, s_display_application);
+ SCM_VALIDATE_FRAME(1,frame);
if (SCM_UNBNDP (port))
port = scm_cur_outp;
else
- SCM_ASSERT (SCM_NIMP (port) && SCM_OPOUTPORTP (port),
- port, SCM_ARG2, s_display_application);
+ SCM_VALIDATE_OPOUTPORT(2,port);
if (SCM_UNBNDP (indent))
indent = SCM_INUM0;
else
- SCM_ASSERT (SCM_INUMP (indent), indent, SCM_ARG3, s_display_application);
+ SCM_VALIDATE_INT(3,indent);
if (SCM_FRAME_PROC_P (frame))
/* Display an application. */
/* Display a special form. */
{
SCM source = SCM_FRAME_SOURCE (frame);
- SCM copy = (SCM_NIMP (source) && SCM_CONSP (source)
+ SCM copy = (SCM_CONSP (source)
? scm_source_property (source, scm_sym_copy)
: SCM_BOOL_F);
- SCM umcopy = (SCM_NIMP (source) && SCM_MEMOIZEDP (source)
+ SCM umcopy = (SCM_MEMOIZEDP (source)
? scm_unmemoize (source)
: SCM_BOOL_F);
display_frame_expr ("(",
- SCM_NIMP (copy) && SCM_CONSP (copy) ? copy : umcopy,
+ SCM_CONSP (copy) ? copy : umcopy,
")",
nfield + 1 + indentation,
sport,
a->port = SCM_COERCE_OUTPORT (a->port);
/* Argument checking and extraction. */
- SCM_ASSERT (SCM_NIMP (a->stack) && SCM_STACKP (a->stack),
+ SCM_ASSERT (SCM_STACKP (a->stack),
a->stack,
SCM_ARG1,
s_display_backtrace);
- SCM_ASSERT (SCM_NIMP (a->port) && SCM_OPOUTPORTP (a->port),
+ SCM_ASSERT (SCM_OPOUTPORTP (a->port),
a->port,
SCM_ARG2,
s_display_backtrace);
* If you write modifications of your own for GUILE, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice. */
+
+/* Software engineering face-lift by Greg J. Badros, 11-Dec-1999,
+ gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */
+
\f
+#include "scm_validate.h"
#include "coop-threads.h"
/* A counter of the current number of threads */
coop_m scm_critical_section_mutex;
-#ifdef __STDC__
void
scm_threads_init (SCM_STACKITEM *i)
-#else
-void
-scm_threads_init (i)
- SCM_STACKITEM *i;
-#endif
{
coop_init();
coop_global_main.data = 0; /* Initialized in init.c */
}
-#ifdef __STDC__
void
-scm_threads_mark_stacks ()
-#else
-void
-scm_threads_mark_stacks ()
-#endif
+scm_threads_mark_stacks (void)
{
coop_t *thread;
return thread;
}
-#ifdef __STDC__
SCM
scm_join_thread (SCM t)
-#else
-SCM
-scm_join_thread (t)
- SCM t;
-#endif
+#define FUNC_NAME s_join_thread
{
- SCM_ASSERT (SCM_NIMP (t) && SCM_THREADP (t), t, SCM_ARG1, s_join_thread);
+ SCM_VALIDATE_THREAD(1,t);
coop_join (SCM_THREAD_DATA (t));
return SCM_BOOL_T;
}
+#undef FUNC_NAME
-#ifdef __STDC__
SCM
-scm_yield ()
-#else
-SCM
-scm_yield ()
-#endif
+scm_yield (void)
{
/* Yield early */
scm_switch_counter = SCM_THREAD_SWITCH_COUNT;
return SCM_BOOL_T;
}
-#ifdef __STDC__
SCM
-scm_single_thread_p ()
-#else
-SCM
-scm_single_thread_p ()
-#endif
+scm_single_thread_p (void)
{
return (coop_global_runq.tail == &coop_global_runq.t
? SCM_BOOL_T
: SCM_BOOL_F);
}
-#ifdef __STDC__
SCM
-scm_make_mutex ()
-#else
-SCM
-scm_make_mutex ()
-#endif
+scm_make_mutex (void)
{
SCM m;
coop_m *data = (coop_m *) scm_must_malloc (sizeof (coop_m), "mutex");
return m;
}
-#ifdef __STDC__
SCM
scm_lock_mutex (SCM m)
-#else
-SCM
-scm_lock_mutex (m)
- SCM m;
-#endif
{
SCM_ASSERT (SCM_NIMP (m) && SCM_MUTEXP (m), m, SCM_ARG1, s_lock_mutex);
coop_mutex_lock (SCM_MUTEX_DATA (m));
return SCM_BOOL_T;
}
-#ifdef __STDC__
SCM
scm_unlock_mutex (SCM m)
-#else
-SCM
-scm_unlock_mutex (m)
- SCM m;
-#endif
{
- SCM_ASSERT (SCM_NIMP (m) && SCM_MUTEXP (m), m, SCM_ARG1, s_unlock_mutex);
+ SCM_ASSERT (SCM_MUTEXP (m), m, SCM_ARG1, s_unlock_mutex);
coop_mutex_unlock(SCM_MUTEX_DATA (m));
/* Yield early */
return SCM_BOOL_T;
}
-#ifdef __STDC__
SCM
-scm_make_condition_variable ()
-#else
-SCM
-scm_make_condition_variable ()
-#endif
+scm_make_condition_variable (void)
{
SCM c;
coop_c *data = (coop_c *) scm_must_malloc (sizeof (coop_c), "condvar");
return c;
}
-#ifdef __STDC__
SCM
scm_wait_condition_variable (SCM c, SCM m)
-#else
-SCM
-scm_wait_condition_variable (c, m)
- SCM c;
- SCM m;
-#endif
{
- SCM_ASSERT (SCM_NIMP (c) && SCM_CONDVARP (c),
+ SCM_ASSERT (SCM_CONDVARP (c),
c,
SCM_ARG1,
s_wait_condition_variable);
- SCM_ASSERT (SCM_NIMP (m) && SCM_MUTEXP (m),
+ SCM_ASSERT (SCM_MUTEXP (m),
m,
SCM_ARG2,
s_wait_condition_variable);
return SCM_BOOL_T;
}
-#ifdef __STDC__
SCM
scm_signal_condition_variable (SCM c)
-#else
-SCM
-scm_signal_condition_variable (c)
- SCM c;
-#endif
{
- SCM_ASSERT (SCM_NIMP (c) && SCM_CONDVARP (c),
+ SCM_ASSERT (SCM_CONDVARP (c),
c,
SCM_ARG1,
s_signal_condition_variable);
"")
#define FUNC_NAME s_scm_memoized_p
{
- return SCM_BOOL(SCM_NIMP (obj) && SCM_MEMOIZEDP (obj));
+ return SCM_BOOL(SCM_MEMOIZEDP (obj));
}
#undef FUNC_NAME
#define FUNC_NAME s_scm_make_gloc
{
#if 1 /* Unsafe */
- if (SCM_NIMP (var) && SCM_CONSP (var))
+ if (SCM_CONSP (var))
var = scm_cons (SCM_BOOL_F, var);
else
#endif
"")
#define FUNC_NAME s_scm_memcons
{
- if (SCM_NIMP (car) && SCM_MEMOIZEDP (car))
+ if (SCM_MEMOIZEDP (car))
{
/*fixme* environments may be two different but equal top-level envs */
if (!SCM_UNBNDP (env) && SCM_MEMOIZED_ENV (car) != env)
env = SCM_MEMOIZED_ENV (car);
car = SCM_MEMOIZED_EXP (car);
}
- if (SCM_NIMP (cdr) && SCM_MEMOIZEDP (cdr))
+ if (SCM_MEMOIZEDP (cdr))
{
if (!SCM_UNBNDP (env) && SCM_MEMOIZED_ENV (cdr) != env)
SCM_MISC_ERROR ("environment mismatch arg2 <-> arg3",
scm_reverse_lookup (SCM env, SCM data)
{
SCM names, values;
- while (SCM_NIMP (env) && SCM_CONSP (SCM_CAR (env)))
+ while (SCM_CONSP (SCM_CAR (env)))
{
names = SCM_CAAR (env);
values = SCM_CDAR (env);
- while (SCM_NIMP (names) && SCM_CONSP (names))
+ while (SCM_CONSP (names))
{
if (SCM_CAR (values) == data)
return SCM_CAR (names);
"")
#define FUNC_NAME s_scm_debug_object_p
{
- return SCM_BOOL(SCM_NIMP (obj) && SCM_DEBUGOBJP (obj));
+ return SCM_BOOL(SCM_DEBUGOBJP (obj));
}
#undef FUNC_NAME
char *dst, *src;
SCM str = SCM_CAR (args);
- SCM_ASSERT (SCM_NIMP (str) && SCM_ROSTRINGP (str), str, argn, subr);
+ SCM_ASSERT (SCM_ROSTRINGP (str), str, argn, subr);
len = 1 + SCM_ROLENGTH (str);
dst = (char *) scm_must_malloc ((long)len, subr);
src = SCM_ROCHARS (str);
static SCM
scm_coerce_rostring (SCM rostr,const char *subr,int argn)
{
- SCM_ASSERT (SCM_NIMP (rostr) && SCM_ROSTRINGP (rostr), rostr, argn, subr);
+ SCM_ASSERT (SCM_ROSTRINGP (rostr), rostr, argn, subr);
if (SCM_SUBSTRP (rostr))
rostr = scm_makfromstr (SCM_ROCHARS (rostr), SCM_ROLENGTH (rostr), 0);
return rostr;
fname = scm_coerce_rostring (fname, FUNC_NAME, SCM_ARG1);
/* collect flags */
- while (SCM_NIMP (rest) && SCM_CONSP (rest))
+ while (SCM_CONSP (rest))
{
SCM kw, val;
kw = SCM_CAR (rest);
rest = SCM_CDR (rest);
- if (!(SCM_NIMP (rest) && SCM_CONSP (rest)))
+ if (!SCM_CONSP (rest))
scm_misc_error (FUNC_NAME, "keyword without value", SCM_EOL);
val = SCM_CAR (rest);
{
void (*fptr)();
- if (SCM_NIMP (func) && SCM_ROSTRINGP (func))
+ if (SCM_ROSTRINGP (func))
func = scm_dynamic_func (func, dobj);
fptr = (void (*)()) scm_num2ulong (func, (char *)SCM_ARG1, FUNC_NAME);
SCM_DEFER_INTS;
int result, argc;
char **argv;
- if (SCM_NIMP (func) && SCM_ROSTRINGP (func))
+ if (SCM_ROSTRINGP (func))
func = scm_dynamic_func (func, dobj);
fptr = (int (*)(int, char **)) scm_num2ulong (func, (char *)SCM_ARG1,
else
goto memlambda;
}
- if (!(SCM_NIMP (SCM_CAR (proc)) && SCM_SYMBOLP (SCM_CAR (proc))))
+ if (!SCM_SYMBOLP (SCM_CAR (proc)))
goto badforms;
proc = SCM_CDR (proc);
}
{
arg1 = SCM_CAR (proc);
SCM_ASSYNT (2 == scm_ilength (arg1), xorig, scm_s_bindings, s_letstar);
- SCM_ASSYNT (SCM_NIMP (SCM_CAR (arg1)) && SCM_SYMBOLP (SCM_CAR (arg1)),
- xorig, scm_s_variable, s_letstar);
+ SCM_ASSYNT (SCM_SYMBOLP (SCM_CAR (arg1)), xorig, scm_s_variable, s_letstar);
*varloc = scm_cons2 (SCM_CAR (arg1), SCM_CAR (SCM_CDR (arg1)), SCM_EOL);
varloc = SCM_CDRLOC (SCM_CDR (*varloc));
proc = SCM_CDR (proc);
arg1 = SCM_CAR (proc);
len = scm_ilength (arg1);
SCM_ASSYNT (2 == len || 3 == len, xorig, scm_s_bindings, "do");
- SCM_ASSYNT (SCM_NIMP (SCM_CAR (arg1)) && SCM_SYMBOLP (SCM_CAR (arg1)),
- xorig, scm_s_variable, "do");
+ SCM_ASSYNT (SCM_SYMBOLP (SCM_CAR (arg1)), xorig, scm_s_variable, "do");
/* vars reversed here, inits and steps reversed at evaluation */
vars = scm_cons (SCM_CAR (arg1), vars); /* variable */
arg1 = SCM_CDR (arg1);
--depth;
label:
form = SCM_CDR (form);
- SCM_ASSERT (SCM_NIMP (form) && SCM_ECONSP (form) && SCM_NULLP (SCM_CDR (form)),
- form, SCM_ARG1, s_quasiquote);
+ SCM_ASSERT (SCM_ECONSP (form) && SCM_NULLP (SCM_CDR (form)),
+ form, SCM_ARG1, s_quasiquote);
if (0 == depth)
return evalcar (form, env);
return scm_cons2 (tmp, iqq (SCM_CAR (form), env, depth), SCM_EOL);
SCM_ASSYNT (scm_ilength (x) >= 2, arg1, scm_s_expression, s_define);
proc = SCM_CAR (x);
x = SCM_CDR (x);
- while (SCM_NIMP (proc) && SCM_CONSP (proc))
+ while (SCM_CONSP (proc))
{ /* nested define syntax */
x = scm_cons (scm_cons2 (scm_sym_lambda, SCM_CDR (proc), x), SCM_EOL);
proc = SCM_CAR (proc);
}
- SCM_ASSYNT (SCM_NIMP (proc) && SCM_SYMBOLP (proc),
+ SCM_ASSYNT (SCM_SYMBOLP (proc),
arg1, scm_s_variable, s_define);
SCM_ASSYNT (1 == scm_ilength (x), arg1, scm_s_expression, s_define);
if (SCM_TOP_LEVEL (env))
/* vars scm_list reversed here, inits reversed at evaluation */
arg1 = SCM_CAR (proc);
ASRTSYNTAX (2 == scm_ilength (arg1), scm_s_bindings);
- ASRTSYNTAX (SCM_NIMP (SCM_CAR (arg1)) && SCM_SYMBOLP (SCM_CAR (arg1)),
+ ASRTSYNTAX (SCM_SYMBOLP (SCM_CAR (arg1)),
scm_s_variable);
vars = scm_cons (SCM_CAR (arg1), vars);
*initloc = scm_cons (SCM_CAR (SCM_CDR (arg1)), SCM_EOL);
SCM_ASSYNT (scm_ilength (x) >= 2, xorig, scm_s_body, s_let);
proc = SCM_CAR (x);
if (SCM_NULLP (proc)
- || (SCM_NIMP (proc) && SCM_CONSP (proc)
- && SCM_NIMP (SCM_CAR (proc))
+ || (SCM_CONSP (proc)
&& SCM_CONSP (SCM_CAR (proc)) && SCM_NULLP (SCM_CDR (proc))))
{
/* null or single binding, let* is faster */
{ /* vars and inits both in order */
arg1 = SCM_CAR (proc);
SCM_ASSYNT (2 == scm_ilength (arg1), xorig, scm_s_bindings, s_let);
- SCM_ASSYNT (SCM_NIMP (SCM_CAR (arg1)) && SCM_SYMBOLP (SCM_CAR (arg1)),
+ SCM_ASSYNT (SCM_SYMBOLP (SCM_CAR (arg1)),
xorig, scm_s_variable, s_let);
*varloc = scm_cons (SCM_CAR (arg1), SCM_EOL);
varloc = SCM_CDRLOC (*varloc);
SCM x = SCM_CDR (xorig), vcell;
SCM_ASSYNT (scm_ilength (x) >= 1, xorig, scm_s_expression, "@fop");
vcell = scm_symbol_fref (SCM_CAR (x));
- SCM_ASSYNT (SCM_NIMP (vcell) && SCM_CONSP (vcell), x,
+ SCM_ASSYNT (SCM_CONSP (vcell), x,
"Symbol's function definition is void", NULL);
SCM_SETCAR (x, vcell + 1);
return x;
char *chrs = SCM_CHARS (proc) + SCM_LENGTH (proc) - 1;
while ('c' != *--chrs)
{
- SCM_ASSERT (SCM_NIMP (t.arg1) && SCM_CONSP (t.arg1),
+ SCM_ASSERT (SCM_CONSP (t.arg1),
t.arg1, SCM_ARG1, SCM_CHARS (proc));
t.arg1 = ('a' == *chrs) ? SCM_CAR (t.arg1) : SCM_CDR (t.arg1);
}
}
else
{
- /* SCM_ASRTGO(SCM_NIMP(args) && SCM_CONSP(args), wrongnumargs); */
+ /* SCM_ASRTGO(SCM_CONSP(args), wrongnumargs); */
args = scm_nconc2last (args);
#ifdef DEVAL
debug.vect[0].a.args = scm_cons (arg1, args);
char *chrs = SCM_CHARS (proc) + SCM_LENGTH (proc) - 1;
while ('c' != *--chrs)
{
- SCM_ASSERT (SCM_NIMP (arg1) && SCM_CONSP (arg1),
+ SCM_ASSERT (SCM_CONSP (arg1),
arg1, SCM_ARG1, SCM_CHARS (proc));
arg1 = ('a' == *chrs) ? SCM_CAR (arg1) : SCM_CDR (arg1);
}
RETURN (SCM_SUBRF (proc) (SCM_UNBNDP (arg1) ? SCM_EOL : scm_cons (arg1, args)))
#endif
case scm_tc7_lsubr_2:
- SCM_ASRTGO (SCM_NIMP (args) && SCM_CONSP (args), wrongnumargs);
+ SCM_ASRTGO (SCM_CONSP (args), wrongnumargs);
RETURN (SCM_SUBRF (proc) (arg1, SCM_CAR (args), SCM_CDR (args)))
case scm_tc7_asubr:
if (SCM_NULLP (args))
{
SCM x = SCM_CDR (xorig);
SCM_ASSYNT (2 == scm_ilength (x), xorig, scm_s_expression, scm_s_set_x);
- if (SCM_NIMP (SCM_CAR (x)) && SCM_SYMBOLP (SCM_CAR (x)))
+ if (SCM_SYMBOLP (SCM_CAR (x)))
return scm_cons (SCM_IM_SET_X, x);
- else if (SCM_NIMP (SCM_CAR (x)) && SCM_CONSP (SCM_CAR (x)))
+ else if (SCM_CONSP (SCM_CAR (x)))
return scm_cons (SCM_LIST2 (scm_sym_setter, SCM_CAAR (x)),
scm_append (SCM_LIST2 (SCM_CDAR (x), SCM_CDR (x))));
return scm_wta (xorig, scm_s_variable, scm_s_set_x);
b = SCM_CAR (frames);
if (SCM_NFALSEP (scm_procedure_p (b)))
break;
- SCM_ASSERT (SCM_NIMP (b) && SCM_CONSP (b),
+ SCM_ASSERT (SCM_CONSP (b),
env, SCM_ARG2, FUNC_NAME);
for (b = SCM_CAR (b); SCM_NIMP (b); b = SCM_CDR (b))
{
SCM arg1 = x;
x = SCM_CDR (x);
SCM_ASSYNT (SCM_TOP_LEVEL (env), arg1, "bad placement ", s_undefine);
- SCM_ASSYNT (SCM_NIMP (x) && SCM_CONSP (x) && SCM_CDR (x) == SCM_EOL,
+ SCM_ASSYNT (SCM_CONSP (x) && SCM_CDR (x) == SCM_EOL,
arg1, scm_s_expression, s_undefine);
x = SCM_CAR (x);
- SCM_ASSYNT (SCM_NIMP (x) && SCM_SYMBOLP (x), arg1, scm_s_variable, s_undefine);
+ SCM_ASSYNT (SCM_SYMBOLP (x), arg1, scm_s_variable, s_undefine);
arg1 = scm_sym2vcell (x, scm_env_top_level (env), SCM_BOOL_F);
SCM_ASSYNT (SCM_NFALSEP (arg1) && !SCM_UNBNDP (SCM_CDR (arg1)),
x, "variable already unbound ", s_undefine);
make_hook (SCM name, SCM n_args, const char *subr)
{
int n;
- SCM_ASSERT (SCM_FALSEP (name) || (SCM_NIMP (name) && SCM_SYMBOLP (name)),
+ SCM_ASSERT (SCM_FALSEP (name) || (SCM_SYMBOLP (name)),
name,
SCM_ARG1,
subr);
"")
#define FUNC_NAME s_scm_hook_p
{
- return SCM_BOOL(SCM_NIMP (x) && SCM_HOOKP (x));
+ return SCM_BOOL(SCM_HOOKP (x));
}
#undef FUNC_NAME
SCM_VALIDATE_INT(2,owner);
SCM_VALIDATE_INT(3,group);
- if (SCM_INUMP (object) || (SCM_NIMP (object) && SCM_OPFPORTP (object)))
+ if (SCM_INUMP (object) || (SCM_OPFPORTP (object)))
{
if (SCM_INUMP (object))
fdes = SCM_INUM (object);
}
else
{
- SCM_ASSERT (SCM_NIMP (object) && SCM_ROSTRINGP (object),
+ SCM_ASSERT (SCM_ROSTRINGP (object),
object, SCM_ARG1, FUNC_NAME);
SCM_COERCE_SUBSTR (object);
SCM_SYSCALL (rv = chown (SCM_ROCHARS (object),
object = SCM_COERCE_OUTPORT (object);
SCM_VALIDATE_INT(2,mode);
- if (SCM_INUMP (object) || (SCM_NIMP (object) && SCM_OPFPORTP (object)))
+ if (SCM_INUMP (object) || SCM_OPFPORTP (object))
{
if (SCM_INUMP (object))
fdes = SCM_INUM (object);
fd_or_port = SCM_COERCE_OUTPORT (fd_or_port);
- if (SCM_NIMP (fd_or_port) && SCM_PORTP (fd_or_port))
+ if (SCM_PORTP (fd_or_port))
return scm_close_port (fd_or_port);
SCM_VALIDATE_INT(1,fd_or_port);
fd = SCM_INUM (fd_or_port);
as returned by @code{opendir}.")
#define FUNC_NAME s_scm_directory_stream_p
{
- return SCM_BOOL(SCM_NIMP (obj) && SCM_DIRP (obj));
+ return SCM_BOOL(SCM_DIRP (obj));
}
#undef FUNC_NAME
{
int fd;
element = SCM_COERCE_OUTPORT (element);
- if (SCM_NIMP (element) && SCM_OPFPORTP (element))
+ if (SCM_OPFPORTP (element))
fd = SCM_FPORT_FDES (element);
else {
SCM_ASSERT (SCM_INUMP (element), element, arg, "select");
fill_select_type (SELECT_TYPE *set, SCM list, int arg)
{
int max_fd = 0, fd;
- if (SCM_NIMP (list) && SCM_VECTORP (list))
+ if (SCM_VECTORP (list))
{
int len = SCM_LENGTH (list);
SCM *ve = SCM_VELTS (list);
get_element (SELECT_TYPE *set, SCM element, SCM list)
{
element = SCM_COERCE_OUTPORT (element);
- if (SCM_NIMP (element) && SCM_OPFPORTP (element))
+ if (SCM_OPFPORTP (element))
{
if (FD_ISSET (SCM_FPORT_FDES (element), set))
list = scm_cons (element, list);
{
SCM answer_list = SCM_EOL;
- if (SCM_NIMP (list) && SCM_VECTORP (list))
+ if (SCM_VECTORP (list))
{
int len = SCM_LENGTH (list);
SCM *ve = SCM_VELTS (list);
int sreturn;
#define assert_set(x, arg) \
- SCM_ASSERT (scm_ilength (x) >= 0 || (SCM_NIMP (x) && SCM_VECTORP (x)), \
+ SCM_ASSERT (scm_ilength (x) >= 0 || (SCM_VECTORP (x)), \
x, arg, FUNC_NAME)
assert_set (reads, SCM_ARG1);
assert_set (writes, SCM_ARG2);
object = SCM_COERCE_OUTPORT (object);
SCM_VALIDATE_INT(2,cmd);
- if (SCM_NIMP (object) && SCM_OPFPORTP (object))
+ if (SCM_OPFPORTP (object))
fdes = SCM_FPORT_FDES (object);
else
{
object = SCM_COERCE_OUTPORT (object);
- if (SCM_NIMP (object) && SCM_OPFPORTP (object))
+ if (SCM_OPFPORTP (object))
{
scm_flush (object);
fdes = SCM_FPORT_FDES (object);
int i, j, len, end;
SCM_VALIDATE_ROSTRING(1,filename);
SCM_ASSERT (SCM_UNBNDP (suffix)
- || (SCM_NIMP (suffix) && SCM_ROSTRINGP (suffix)),
+ || (SCM_ROSTRINGP (suffix)),
suffix,
SCM_ARG2,
FUNC_NAME);
"")
#define FUNC_NAME s_scm_fluid_p
{
- return SCM_BOOL(SCM_NIMP (fl) && SCM_FLUIDP (fl));
+ return SCM_BOOL(SCM_FLUIDP (fl));
}
#undef FUNC_NAME
{
int fdes;
SCM name = SCM_PTAB_ENTRY (exp)->file_name;
- scm_puts (SCM_NIMP (name) && SCM_ROSTRINGP (name)
+ scm_puts (SCM_ROSTRINGP (name)
? SCM_ROCHARS (name)
: SCM_PTOBNAME (SCM_PTOBNUM (exp)),
port);
ptr = SCM_VELTS (w);
n = SCM_LENGTH (w);
for (j = 0; j < n; ++j)
- if (SCM_NIMP (ptr[j]) && SCM_FREEP (ptr[j]))
+ if (SCM_FREEP (ptr[j]))
ptr[j] = SCM_BOOL_F;
}
else /* if (SCM_IS_WHVEC_ANY (scm_weak_vectors[i])) */
key = SCM_CAAR (alist);
value = SCM_CDAR (alist);
- if ( (weak_keys && SCM_NIMP (key) && SCM_FREEP (key))
- || (weak_values && SCM_NIMP (value) && SCM_FREEP (value)))
+ if ( (weak_keys && SCM_FREEP (key))
+ || (weak_values && SCM_FREEP (value)))
{
*fixup = SCM_CDR (alist);
}
{
SCM *tail_ptr = &scm_protects;
- while (SCM_NIMP (*tail_ptr) && SCM_CONSP (*tail_ptr))
+ while (SCM_CONSP (*tail_ptr))
if (SCM_CAR (*tail_ptr) == obj)
{
*tail_ptr = SCM_CDR (*tail_ptr);
unsigned long dst_len;
unsigned long effective_length;
- SCM_ASSERT (SCM_NIMP (dst) && SCM_STRINGP (dst), dst, SCM_ARG3,
+ SCM_ASSERT (SCM_STRINGP (dst), dst, SCM_ARG3,
"gh_set_substr");
dst_ptr = SCM_CHARS (dst);
for (i = 0; i < n; ++i)
{
val = SCM_VELTS (obj)[i];
- if (!SCM_INUMP (val) && !(SCM_NIMP (val) && SCM_BIGP (val)))
+ if (!SCM_INUMP (val) && !SCM_BIGP (val))
scm_wrong_type_arg (0, 0, obj);
}
if (m == 0)
{
val = SCM_VELTS (obj)[i];
if (!SCM_INUMP (val)
- && !(SCM_NIMP (val) && (SCM_BIGP (val) || SCM_REALP (val))))
+ && !(SCM_BIGP (val) || SCM_REALP (val)))
scm_wrong_type_arg (0, 0, val);
}
if (m == 0)
{
val = SCM_VELTS (obj)[i];
if (!SCM_INUMP (val)
- && !(SCM_NIMP (val) && (SCM_BIGP (val) || SCM_REALP (val))))
+ && !(SCM_BIGP (val) || SCM_REALP (val)))
scm_wrong_type_arg (0, 0, val);
}
if (m == 0)
char *ret_str;
int len;
- SCM_ASSERT (SCM_NIMP (str) && SCM_ROSTRINGP (str), str, SCM_ARG3,
+ SCM_ASSERT (SCM_ROSTRINGP (str), str, SCM_ARG3,
"gh_scm2newstr");
/* protect str from GC while we copy off its data */
gh_get_substr (SCM src, char *dst, int start, int len)
{
int src_len, effective_length;
- SCM_ASSERT (SCM_NIMP (src) && SCM_ROSTRINGP (src), src, SCM_ARG3,
+ SCM_ASSERT (SCM_ROSTRINGP (src), src, SCM_ARG3,
"gh_get_substr");
scm_protect_object (src);
char *ret_str;
int len;
- SCM_ASSERT (SCM_NIMP (sym) && SCM_SYMBOLP (sym), sym, SCM_ARG3,
+ SCM_ASSERT (SCM_SYMBOLP (sym), sym, SCM_ARG3,
"gh_scm2newsymbol");
/* protect str from GC while we copy off its data */
if (SCM_ICHRP(obj))
return ((unsigned int)(scm_downcase(SCM_ICHR(obj)))) % n; /* downcase!?!! */
- if (SCM_NIMP(obj) && SCM_NUMP(obj))
+ if (SCM_NUMP(obj))
return (unsigned int) scm_hasher(obj, n, 10);
else
return ((unsigned int)obj) % n;
unsigned int k;
SCM h;
- SCM_ASSERT (SCM_NIMP (table) && SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_get_handle");
+ SCM_ASSERT (SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_get_handle");
if (SCM_LENGTH (table) == 0)
return SCM_EOL;
k = hash_fn (obj, SCM_LENGTH (table), closure);
unsigned int k;
SCM it;
- SCM_ASSERT (SCM_NIMP (table) && SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_create_handle_x");
+ SCM_ASSERT (SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_create_handle_x");
if (SCM_LENGTH (table) == 0)
return SCM_EOL;
k = hash_fn (obj, SCM_LENGTH (table), closure);
unsigned int k;
SCM h;
- SCM_ASSERT (SCM_NIMP (table) && SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_remove_x");
+ SCM_ASSERT (SCM_VECTORP (table), table, SCM_ARG1, "hash_fn_remove_x");
if (SCM_LENGTH (table) == 0)
return SCM_EOL;
k = hash_fn (obj, SCM_LENGTH (table), closure);
SCM ls = SCM_VELTS (table)[i], handle;
while (SCM_NNULLP (ls))
{
- SCM_ASSERT (SCM_NIMP (ls) && SCM_CONSP (ls),
+ SCM_ASSERT (SCM_CONSP (ls),
table, SCM_ARG1, s_scm_hash_fold);
handle = SCM_CAR (ls);
- SCM_ASSERT (SCM_NIMP (handle) && SCM_CONSP (handle),
+ SCM_ASSERT (SCM_CONSP (handle),
table, SCM_ARG1, s_scm_hash_fold);
result = fn (closure, SCM_CAR (handle), SCM_CDR (handle), result);
ls = SCM_CDR (ls);
port = SCM_COERCE_OUTPORT (port);
- if (!(SCM_NIMP (port) && SCM_OPFPORTP (port)))
+ if (!SCM_OPFPORTP (port))
return SCM_BOOL_F;
rv = isatty (SCM_FPORT_FDES (port));
it returns @code{#f} otherwise.")
#define FUNC_NAME s_scm_keyword_p
{
- return SCM_BOOL(SCM_NIMP(obj) && SCM_KEYWORDP (obj));
+ return SCM_BOOL(SCM_KEYWORDP (obj));
}
#undef FUNC_NAME
register long i;
SCM_VALIDATE_INT_MIN_COPY(2,k,0,i);
while (i-- > 0) {
- SCM_ASRTGO(SCM_NIMP(lst) && SCM_CONSP(lst), erout);
+ SCM_ASRTGO(SCM_CONSP(lst), erout);
lst = SCM_CDR(lst);
}
erout:
- SCM_ASSERT(SCM_NIMP(lst) && SCM_CONSP(lst),
+ SCM_ASSERT(SCM_CONSP(lst),
SCM_NULLP(lst)?k:lst, SCM_NULLP(lst)?SCM_OUTOFRANGE:SCM_ARG1, FUNC_NAME);
return SCM_CAR(lst);
}
register long i;
SCM_VALIDATE_INT_MIN_COPY(2,k,0,i);
while (i-- > 0) {
- SCM_ASRTGO(SCM_NIMP(lst) && SCM_CONSP(lst), erout);
+ SCM_ASRTGO(SCM_CONSP(lst), erout);
lst = SCM_CDR(lst);
}
erout:
- SCM_ASSERT(SCM_NIMP(lst) && SCM_CONSP(lst),
+ SCM_ASSERT(SCM_CONSP(lst),
SCM_NULLP(lst)?k:lst, SCM_NULLP(lst)?SCM_OUTOFRANGE:SCM_ARG1, FUNC_NAME);
SCM_SETCAR (lst, val);
return val;
register long i;
SCM_VALIDATE_INT_MIN_COPY(2,k,0,i);
while (i-- > 0) {
- SCM_ASRTGO(SCM_NIMP(lst) && SCM_CONSP(lst), erout);
+ SCM_ASRTGO(SCM_CONSP(lst), erout);
lst = SCM_CDR(lst);
}
erout:
- SCM_ASSERT(SCM_NIMP(lst) && SCM_CONSP(lst),
+ SCM_ASSERT(SCM_CONSP(lst),
SCM_NULLP(lst)?k:lst, SCM_NULLP(lst)?SCM_OUTOFRANGE:SCM_ARG1, FUNC_NAME);
SCM_SETCDR (lst, val);
return val;
fill_here = &newlst;
from_here = lst;
- while (SCM_NIMP (from_here) && SCM_CONSP (from_here))
+ while (SCM_CONSP (from_here))
{
SCM c;
c = scm_cons (SCM_CAR (from_here), SCM_CDR (from_here));
in writing Guile internals, not for high-level Scheme programs.")
#define FUNC_NAME s_scm_sloppy_memq
{
- for(; SCM_NIMP(lst) && SCM_CONSP (lst); lst = SCM_CDR(lst))
+ for(; SCM_CONSP (lst); lst = SCM_CDR(lst))
{
if (SCM_CAR(lst)==x)
return lst;
"")
#define FUNC_NAME s_scm_sloppy_memv
{
- for(; SCM_NIMP(lst) && SCM_CONSP (lst); lst = SCM_CDR(lst))
+ for(; SCM_CONSP (lst); lst = SCM_CDR(lst))
{
if (SCM_BOOL_F != scm_eqv_p (SCM_CAR(lst), x))
return lst;
"")
#define FUNC_NAME s_scm_sloppy_member
{
- for(; SCM_NIMP(lst) && SCM_CONSP (lst); lst = SCM_CDR(lst))
+ for(; SCM_CONSP (lst); lst = SCM_CDR(lst))
{
if (SCM_BOOL_F != scm_equal_p (SCM_CAR(lst), x))
return lst;
SCM *prev;
for (prev = &lst, walk = lst;
- SCM_NIMP (walk) && SCM_CONSP (walk);
+ SCM_CONSP (walk);
walk = SCM_CDR (walk))
{
if (SCM_CAR (walk) == item)
SCM *prev;
for (prev = &lst, walk = lst;
- SCM_NIMP (walk) && SCM_CONSP (walk);
+ SCM_CONSP (walk);
walk = SCM_CDR (walk))
{
if (SCM_BOOL_F != scm_eqv_p (SCM_CAR (walk), item))
SCM *prev;
for (prev = &lst, walk = lst;
- SCM_NIMP (walk) && SCM_CONSP (walk);
+ SCM_CONSP (walk);
walk = SCM_CDR (walk))
{
if (SCM_BOOL_F != scm_equal_p (SCM_CAR (walk), item))
SCM *prev;
for (prev = &lst, walk = lst;
- SCM_NIMP (walk) && SCM_CONSP (walk);
+ SCM_CONSP (walk);
walk = SCM_CDR (walk))
{
if (SCM_CAR (walk) == item)
SCM *prev;
for (prev = &lst, walk = lst;
- SCM_NIMP (walk) && SCM_CONSP (walk);
+ SCM_CONSP (walk);
walk = SCM_CDR (walk))
{
if (SCM_BOOL_F != scm_eqv_p (SCM_CAR (walk), item))
SCM *prev;
for (prev = &lst, walk = lst;
- SCM_NIMP (walk) && SCM_CONSP (walk);
+ SCM_CONSP (walk);
walk = SCM_CDR (walk))
{
if (SCM_BOOL_F != scm_equal_p (SCM_CAR (walk), item))
"")
#define FUNC_NAME s_scm_parse_path
{
- SCM_ASSERT (SCM_FALSEP (path) || (SCM_NIMP (path) && SCM_ROSTRINGP (path)),
+ SCM_ASSERT (SCM_FALSEP (path) || (SCM_ROSTRINGP (path)),
path,
SCM_ARG1, FUNC_NAME);
if (SCM_UNBNDP (tail))
for (walk = path; SCM_NIMP (walk); walk = SCM_CDR (walk))
{
SCM elt = SCM_CAR (walk);
- SCM_ASSERT (SCM_NIMP (elt) && SCM_ROSTRINGP (elt), elt,
+ SCM_ASSERT (SCM_ROSTRINGP (elt), elt,
"path is not a list of strings",
FUNC_NAME);
if (SCM_ROLENGTH (elt) > max_path_len)
for (walk = extensions; SCM_NIMP (walk); walk = SCM_CDR (walk))
{
SCM elt = SCM_CAR (walk);
- SCM_ASSERT (SCM_NIMP (elt) && SCM_ROSTRINGP (elt), elt,
+ SCM_ASSERT (SCM_ROSTRINGP (elt), elt,
"extension list is not a list of strings",
FUNC_NAME);
if (SCM_ROLENGTH (elt) > max_ext_len)
SCM m;
#endif
{
- SCM_ASSERT (SCM_NIMP (m) && SCM_MUTEXP (m), m, SCM_ARG1, s_lock_mutex);
+ SCM_ASSERT (SCM_MUTEXP (m), m, SCM_ARG1, s_lock_mutex);
pthread_mutex_lock (SCM_MUTEX_DATA (m));
return SCM_BOOL_T;
}
SCM m;
#endif
{
- SCM_ASSERT (SCM_NIMP (m) && SCM_MUTEXP (m), m, SCM_ARG1, s_unlock_mutex);
+ SCM_ASSERT (SCM_MUTEXP (m), m, SCM_ARG1, s_unlock_mutex);
pthread_mutex_unlock (SCM_MUTEX_DATA (m));
return SCM_BOOL_T;
}
SCM m;
#endif
{
- SCM_ASSERT (SCM_NIMP (c) && SCM_CONDVARP (c),
+ SCM_ASSERT (SCM_CONDVARP (c),
c,
SCM_ARG1,
s_wait_condition_variable);
- SCM_ASSERT (SCM_NIMP (m) && SCM_MUTEXP (m),
+ SCM_ASSERT (SCM_MUTEXP (m),
m,
SCM_ARG2,
s_wait_condition_variable);
SCM c;
#endif
{
- SCM_ASSERT (SCM_NIMP (c) && SCM_CONDVARP (c),
+ SCM_ASSERT (SCM_CONDVARP (c),
c,
SCM_ARG1,
s_signal_condition_variable);
return SCM_BOOL_F;
}
}
- else if (SCM_NIMP (name) && SCM_ROSTRINGP (name))
+ else if (SCM_ROSTRINGP (name))
{
SCM_COERCE_SUBSTR (name);
entry = gethostbyname (SCM_ROCHARS (name));
return SCM_BOOL_F;
}
}
- else if (SCM_NIMP (name) && SCM_ROSTRINGP (name))
+ else if (SCM_ROSTRINGP (name))
{
SCM_COERCE_SUBSTR (name);
entry = getnetbyname (SCM_ROCHARS (name));
return SCM_BOOL_F;
}
}
- else if (SCM_NIMP (name) && SCM_ROSTRINGP (name))
+ else if (SCM_ROSTRINGP (name))
{
SCM_COERCE_SUBSTR (name);
entry = getprotobyname (SCM_ROCHARS (name));
}
SCM_VALIDATE_ROSTRING(2,proto);
SCM_COERCE_SUBSTR (proto);
- if (SCM_NIMP (name) && SCM_ROSTRINGP (name))
+ if (SCM_ROSTRINGP (name))
{
SCM_COERCE_SUBSTR (name);
entry = getservbyname (SCM_ROCHARS (name), SCM_ROCHARS (proto));
if (SCM_INUMP (x))
return SCM_BOOL_T;
#ifdef SCM_BIGDIG
- if (SCM_NIMP (x) && SCM_BIGP (x))
+ if (SCM_BIGP (x))
return SCM_BOOL_T;
#endif
return SCM_BOOL_F;
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_GASSERT1 (SCM_NIMP (x) && SCM_BIGP (x), g_abs, x, SCM_ARG1, s_abs);
+ SCM_GASSERT1 (SCM_BIGP (x), g_abs, x, SCM_ARG1, s_abs);
if (SCM_TYP16 (x) == scm_tc16_bigpos)
return x;
return scm_copybig (x, 0);
if (SCM_NINUMP (x))
{
long w;
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT2 (SCM_BIGP (x),
g_quotient, x, y, SCM_ARG1, s_quotient);
if (SCM_NINUMP (y))
{
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
return scm_divbigbig (SCM_BDIGITS (x), SCM_NUMDIGS (x),
SCM_BDIGITS (y), SCM_NUMDIGS (y),
SCM_BIGSIGN (x) ^ SCM_BIGSIGN (y), 2);
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_quotient, x, y, SCM_ARG2, s_quotient);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT2 (SCM_BIGP (x),
g_remainder, x, y, SCM_ARG1, s_remainder);
if (SCM_NINUMP (y))
{
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
return scm_divbigbig (SCM_BDIGITS (x), SCM_NUMDIGS (x),
SCM_BDIGITS (y), SCM_NUMDIGS (y),
SCM_BIGSIGN (x), 0);
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_remainder, x, y, SCM_ARG2, s_remainder);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT2 (SCM_BIGP (x),
g_modulo, x, y, SCM_ARG1, s_modulo);
if (SCM_NINUMP (y))
{
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
return scm_divbigbig (SCM_BDIGITS (x), SCM_NUMDIGS (x),
SCM_BDIGITS (y), SCM_NUMDIGS (y),
SCM_BIGSIGN (y),
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_modulo, x, y, SCM_ARG2, s_modulo);
if (SCM_NINUMP (x))
{
big_gcd:
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT2 (SCM_BIGP (x),
g_gcd, x, y, SCM_ARG1, s_gcd);
if (SCM_BIGSIGN (x))
x = scm_copybig (x, 0);
newy:
if (SCM_NINUMP (y))
{
- SCM_GASSERT2 (SCM_NIMP (y) && SCM_BIGP (y),
+ SCM_GASSERT2 (SCM_BIGP (y),
g_gcd, x, y, SCM_ARGn, s_gcd);
if (SCM_BIGSIGN (y))
y = scm_copybig (y, 0);
#else
SCM_GASSERT2 (SCM_INUMP (n1)
|| SCM_UNBNDP (n1)
- || (SCM_NIMP (n1) && SCM_BIGP (n1)),
+ || (SCM_BIGP (n1)),
g_lcm, n1, n2, SCM_ARG1, s_lcm);
SCM_GASSERT2 (SCM_INUMP (n2)
|| SCM_UNBNDP (n2)
- || (SCM_NIMP (n2) && SCM_BIGP (n2)),
+ || (SCM_BIGP (n2)),
g_lcm, n1, n2, SCM_ARGn, s_lcm);
#endif
if (SCM_UNBNDP (n2))
if (SCM_BIGP (x))
return big2str (x, (unsigned int) base);
#ifndef SCM_RECKLESS
- if (!(SCM_INEXP (x)))
+ if (!SCM_INEXP (x))
{
badx:
scm_wta (x, (char *) SCM_ARG1, FUNC_NAME);
}
#endif
#else
- SCM_ASSERT (SCM_NIMP (x) && SCM_INEXP (x),
+ SCM_ASSERT (SCM_INEXP (x),
x, SCM_ARG1, s_number_to_string);
#endif
return scm_makfromstr (num_buf, iflo2str (x, num_buf), 0);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_ASSERT (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_ASSERT (SCM_BIGP (x),
x, SCM_ARG1, s_number_to_string);
return big2str (x, (unsigned int) base);
}
{ /* polar input for complex number */
/* get a `real' for scm_angle */
second = scm_istr2flo (&str[i], (long) (len - i), radix);
- if (!(SCM_NIMP (second) && SCM_INEXP (second)))
+ if (!SCM_INEXP (second))
return SCM_BOOL_F; /* not `real' */
if (SCM_CPLXP (second))
return SCM_BOOL_F; /* not `real' */
return scm_makdbl (res, lead_sgn);
/* get a `ureal' for complex part */
second = scm_istr2flo (&str[i], (long) ((len - i) - 1), radix);
- if (! (SCM_NIMP (second) && SCM_INEXP (second)))
+ if (!SCM_INEXP (second))
return SCM_BOOL_F; /* not `ureal' */
if (SCM_CPLXP (second))
return SCM_BOOL_F; /* not `ureal' */
if (SCM_INUMP (x))
return SCM_BOOL_T;
#ifdef SCM_FLOATS
- if (SCM_NIMP (x) && SCM_NUMP (x))
+ if (SCM_NUMP (x))
return SCM_BOOL_T;
#else
#ifdef SCM_BIGDIG
- if (SCM_NIMP (x) && SCM_NUMP (x))
+ if (SCM_NUMP (x))
return SCM_BOOL_T;
#endif
#endif
#define FUNC_NAME s_scm_inexact_p
{
#ifdef SCM_FLOATS
- if (SCM_NIMP (x) && SCM_INEXP (x))
+ if (SCM_INEXP (x))
return SCM_BOOL_T;
#endif
return SCM_BOOL_F;
if (SCM_NINUMP (x))
{
#ifdef SCM_BIGDIG
- if (!(SCM_NIMP (x)))
+ if (!SCM_NIMP (x))
{
badx:
SCM_WTA_DISPATCH_2 (g_eq_p, x, y, SCM_ARG1, s_eq_p);
}
SCM_ASRTGO (SCM_INEXP (x), badx);
#else
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_INEXP (x),
+ SCM_GASSERT2 (SCM_INEXP (x),
g_eq_p, x, y, SCM_ARG1, s_eq_p);
#endif
if (SCM_INUMP (y))
}
SCM_ASRTGO (SCM_INEXP (y), bady);
#else
- SCM_ASRTGO (SCM_NIMP (y) && SCM_INEXP (y), bady);
+ SCM_ASRTGO (SCM_INEXP (y), bady);
#endif
if (SCM_REALPART (x) != SCM_REALPART (y))
return SCM_BOOL_F;
SCM_ASRTGO (SCM_NIMP (y), bady);
if (SCM_BIGP (y))
return SCM_BOOL_F;
- if (!(SCM_INEXP (y)))
+ if (!SCM_INEXP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_eq_p, x, y, SCM_ARGn, s_eq_p);
}
#else
- if (!(SCM_NIMP (y) && SCM_INEXP (y)))
+ if (!SCM_INEXP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_eq_p, x, y, SCM_ARGn, s_eq_p);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT2 (SCM_BIGP (x),
g_eq_p, x, y, SCM_ARG1, s_eq_p);
if (SCM_INUMP (y))
return SCM_BOOL_F;
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
return SCM_BOOL(0 == scm_bigcomp (x, y));
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_eq_p, x, y, SCM_ARGn, s_eq_p);
if (SCM_NINUMP (x))
{
#ifdef SCM_BIGDIG
- if (!(SCM_NIMP (x)))
+ if (!SCM_NIMP (x))
{
badx:
SCM_WTA_DISPATCH_2 (g_less_p, x, y, SCM_ARG1, s_less_p);
}
SCM_ASRTGO (SCM_REALP (x), badx);
#else
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_REALP (x),
+ SCM_GASSERT2 (SCM_REALP (x),
g_less_p, x, y, SCM_ARG1, s_less_p);
#endif
if (SCM_INUMP (y))
return SCM_BOOL(SCM_REALPART (x) < scm_big2dbl (y));
SCM_ASRTGO (SCM_REALP (y), bady);
#else
- SCM_ASRTGO (SCM_NIMP (y) && SCM_REALP (y), bady);
+ SCM_ASRTGO (SCM_REALP (y), bady);
#endif
return SCM_BOOL(SCM_REALPART (x) < SCM_REALPART (y));
}
SCM_ASRTGO (SCM_NIMP (y), bady);
if (SCM_BIGP (y))
return SCM_NEGATE_BOOL(SCM_BIGSIGN (y));
- if (!(SCM_REALP (y)))
+ if (!SCM_REALP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_less_p, x, y, SCM_ARGn, s_less_p);
}
#else
- if (!(SCM_NIMP (y) && SCM_REALP (y)))
+ if (!SCM_REALP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_less_p, x, y, SCM_ARGn, s_less_p);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT2 (SCM_BIGP (x),
g_less_p, x, y, SCM_ARG1, s_less_p);
if (SCM_INUMP (y))
return SCM_BOOL(SCM_BIGSIGN (x));
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
return SCM_BOOL(1 == scm_bigcomp (x, y));
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_less_p, x, y, SCM_ARGn, s_less_p);
SCM_ASRTGO (SCM_NIMP (z), badz);
if (SCM_BIGP (z))
return SCM_BOOL_F;
- if (!(SCM_INEXP (z)))
+ if (!SCM_INEXP (z))
{
badz:
SCM_WTA_DISPATCH_1 (g_zero_p, z, SCM_ARG1, s_zero_p);
}
#else
- SCM_GASSERT1 (SCM_NIMP (z) && SCM_INEXP (z),
+ SCM_GASSERT1 (SCM_INEXP (z),
g_zero_p, z, SCM_ARG1, s_zero_p);
#endif
return SCM_BOOL(z == scm_flo0);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (z))
{
- SCM_GASSERT1 (SCM_NIMP (z) && SCM_BIGP (z),
+ SCM_GASSERT1 (SCM_BIGP (z),
g_zero_p, z, SCM_ARG1, s_zero_p);
return SCM_BOOL_F;
}
SCM_ASRTGO (SCM_NIMP (x), badx);
if (SCM_BIGP (x))
return SCM_BOOL(SCM_TYP16 (x) == scm_tc16_bigpos);
- if (!(SCM_REALP (x)))
+ if (!SCM_REALP (x))
{
badx:
SCM_WTA_DISPATCH_1 (g_positive_p, x, SCM_ARG1, s_positive_p);
}
#else
- SCM_GASSERT1 (SCM_NIMP (x) && SCM_REALP (x),
+ SCM_GASSERT1 (SCM_REALP (x),
g_positive_p, x, SCM_ARG1, s_positive_p);
#endif
return SCM_BOOL(SCM_REALPART (x) > 0.0);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_GASSERT1 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT1 (SCM_BIGP (x),
g_positive_p, x, SCM_ARG1, s_positive_p);
return SCM_BOOL(SCM_TYP16 (x) == scm_tc16_bigpos);
}
SCM_WTA_DISPATCH_1 (g_negative_p, x, SCM_ARG1, s_negative_p);
}
#else
- SCM_GASSERT1 (SCM_NIMP (x) && SCM_REALP (x),
+ SCM_GASSERT1 (SCM_REALP (x),
g_negative_p, x, SCM_ARG1, s_negative_p);
#endif
return SCM_BOOL(SCM_REALPART (x) < 0.0);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_GASSERT1 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT1 (SCM_BIGP (x),
g_negative_p, x, SCM_ARG1, s_negative_p);
return SCM_BOOL(SCM_TYP16 (x) == scm_tc16_bigneg);
}
}
SCM_ASRTGO (SCM_REALP (x), badx2);
#else
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_REALP (x),
+ SCM_GASSERT2 (SCM_REALP (x),
g_max, x, y, SCM_ARG1, s_max);
#endif
if (SCM_INUMP (y))
: x);
SCM_ASRTGO (SCM_REALP (y), bady);
#else
- SCM_ASRTGO (SCM_NIMP (y) && SCM_REALP (y), bady);
+ SCM_ASRTGO (SCM_REALP (y), bady);
#endif
return (SCM_REALPART (x) < SCM_REALPART (y)) ? y : x;
}
SCM_WTA_DISPATCH_2 (g_max, x, y, SCM_ARGn, s_max);
}
#else
- if (!(SCM_NIMP (y) && SCM_REALP (y)))
+ if (!SCM_REALP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_max, x, y, SCM_ARGn, s_max);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT2 (SCM_BIGP (x),
g_max, x, y, SCM_ARG1, s_max);
if (SCM_INUMP (y))
return SCM_BIGSIGN (x) ? y : x;
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
return (1 == scm_bigcomp (x, y)) ? y : x;
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_max, x, y, SCM_ARGn, s_max);
if (SCM_NINUMP (x))
{
#ifdef SCM_BIGDIG
- if (!(SCM_NIMP (x)))
+ if (!SCM_NIMP (x))
{
badx2:
SCM_WTA_DISPATCH_2 (g_min, x, y, SCM_ARG1, s_min);
}
SCM_ASRTGO (SCM_REALP (x), badx2);
#else
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_REALP (x),
+ SCM_GASSERT2 (SCM_REALP (x),
g_min, x, y, SCM_ARG1, s_min);
#endif
if (SCM_INUMP (y))
: x);
SCM_ASRTGO (SCM_REALP (y), bady);
#else
- SCM_ASRTGO (SCM_NIMP (y) && SCM_REALP (y), bady);
+ SCM_ASRTGO (SCM_REALP (y), bady);
#endif
return (SCM_REALPART (x) > SCM_REALPART (y)) ? y : x;
}
SCM_WTA_DISPATCH_2 (g_min, x, y, SCM_ARGn, s_min);
}
#else
- if (!(SCM_NIMP (y) && SCM_REALP (y)))
+ if (!SCM_REALP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_min, x, y, SCM_ARGn, s_min);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT2 (SCM_BIGP (x),
g_min, x, y, SCM_ARG1, s_min);
if (SCM_INUMP (y))
return SCM_BIGSIGN (x) ? x : y;
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
return (-1 == scm_bigcomp (x, y)) ? y : x;
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_min, x, y, SCM_ARGn, s_min);
}
SCM_ASRTGO (SCM_INEXP (x), badx2);
#else
- SCM_ASRTGO (SCM_NIMP (x) && SCM_INEXP (x), badx2);
+ SCM_ASRTGO (SCM_INEXP (x), badx2);
#endif
if (SCM_INUMP (y))
{
y = t;
goto bigreal;
}
- else if (!(SCM_INEXP (y)))
+ else if (!SCM_INEXP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_sum, x, y, SCM_ARGn, s_sum);
}
#else
- if (!(SCM_NIMP (y) && SCM_INEXP (y)))
+ if (!SCM_INEXP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_sum, x, y, SCM_ARGn, s_sum);
}
SCM_ASRTGO (SCM_INEXP (y), bady);
#else
- SCM_ASRTGO (SCM_NIMP (y) && SCM_INEXP (y), bady);
+ SCM_ASRTGO (SCM_INEXP (y), bady);
#endif
intreal:
return scm_makdbl (SCM_INUM (x) + SCM_REALPART (y),
if (SCM_NINUMP (x))
{
SCM t;
- SCM_ASRTGO (SCM_NIMP (x) && SCM_BIGP (x), badx2);
+ SCM_ASRTGO (SCM_BIGP (x), badx2);
if (SCM_INUMP (y))
{
t = x;
y = t;
goto intbig;
}
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
if (SCM_NUMDIGS (x) > SCM_NUMDIGS (y))
{
t = x;
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_sum, x, y, SCM_ARGn, s_sum);
SCM_ASRTGO (SCM_INEXP (y), bady);
#else
SCM_ASRTGO (SCM_INEXP (x), badx2);
- SCM_ASRTGO (SCM_NIMP (y) && SCM_INEXP (y), bady);
+ SCM_ASRTGO (SCM_INEXP (y), bady);
#endif
if (SCM_CPLXP (x))
{
y, 0x0100);
#endif
}
- if (!(SCM_INEXP (y)))
+ if (!SCM_INEXP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_difference, x, y, SCM_ARGn, s_difference);
}
#else
- if (!(SCM_NIMP (y) && SCM_INEXP (y)))
+ if (!SCM_INEXP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_difference, x, y, SCM_ARGn, s_difference);
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT2 (SCM_BIGP (x),
g_difference, x, y, SCM_ARG1, s_difference);
if (SCM_UNBNDP (y))
{
x, 0);
#endif
}
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
return (SCM_NUMDIGS (x) < SCM_NUMDIGS (y)) ?
scm_addbig (SCM_BDIGITS (x), SCM_NUMDIGS (x), SCM_BIGSIGN (x),
y, 0x0100) :
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_difference, x, y, SCM_ARGn, s_difference);
}
SCM_ASRTGO (SCM_INEXP (x), badx2);
#else
- SCM_ASRTGO (SCM_NIMP (x) && SCM_INEXP (x), badx2);
+ SCM_ASRTGO (SCM_INEXP (x), badx2);
#endif
if (SCM_INUMP (y))
{
SCM_WTA_DISPATCH_2 (g_product, x, y, SCM_ARGn, s_product);
}
#else
- if (!(SCM_NIMP (y) && SCM_INEXP (y)))
+ if (!SCM_INEXP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_product, x, y, SCM_ARGn, s_product);
}
SCM_ASRTGO (SCM_INEXP (y), bady);
#else
- SCM_ASRTGO (SCM_NIMP (y) && SCM_INEXP (y), bady);
+ SCM_ASRTGO (SCM_INEXP (y), bady);
#endif
intreal:
return scm_makdbl (SCM_INUM (x) * SCM_REALPART (y),
#ifdef SCM_BIGDIG
if (SCM_NINUMP (x))
{
- SCM_ASRTGO (SCM_NIMP (x) && SCM_BIGP (x), badx2);
+ SCM_ASRTGO (SCM_BIGP (x), badx2);
if (SCM_INUMP (y))
{
SCM t = x;
y = t;
goto intbig;
}
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
return scm_mulbig (SCM_BDIGITS (x), SCM_NUMDIGS (x),
SCM_BDIGITS (y), SCM_NUMDIGS (y),
SCM_BIGSIGN (x) ^ SCM_BIGSIGN (y));
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_product, x, y, SCM_ARGn, s_product);
}
SCM_ASRTGO (SCM_INEXP (y), bady);
#else
- SCM_ASRTGO (SCM_NIMP (y) && SCM_INEXP (y), bady);
+ SCM_ASRTGO (SCM_INEXP (y), bady);
#endif
if (SCM_REALP (y))
{
SCM_WTA_DISPATCH_2 (g_divide, x, y, SCM_ARGn, s_divide);
}
#else
- if (!(SCM_NIMP (y) && SCM_INEXP (y)))
+ if (!SCM_INEXP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_divide, x, y, SCM_ARGn, s_divide);
if (SCM_NINUMP (x))
{
SCM z;
- SCM_GASSERT2 (SCM_NIMP (x) && SCM_BIGP (x),
+ SCM_GASSERT2 (SCM_BIGP (x),
g_divide, x, y, SCM_ARG1, s_divide);
if (SCM_UNBNDP (y))
goto ov;
}
else
{
- SCM_ASRTGO (SCM_NIMP (y) && SCM_BIGP (y), bady);
+ SCM_ASRTGO (SCM_BIGP (y), bady);
z = scm_divbigbig (SCM_BDIGITS (x), SCM_NUMDIGS (x),
SCM_BDIGITS (y), SCM_NUMDIGS (y),
SCM_BIGSIGN (x) ^ SCM_BIGSIGN (y), 3);
}
if (SCM_NINUMP (y))
{
- if (!(SCM_NIMP (y) && SCM_BIGP (y)))
+ if (!SCM_BIGP (y))
{
bady:
SCM_WTA_DISPATCH_2 (g_divide, x, y, SCM_ARGn, s_divide);
else
{
#ifndef SCM_RECKLESS
- if (!(SCM_REALP (z1)))
+ if (!SCM_REALP (z1))
badz1:scm_wta (z1, (char *) SCM_ARG1, sstring);
#endif
xy->x = SCM_REALPART (z1);
}
#else
{
- SCM_ASSERT (SCM_NIMP (z1) && SCM_REALP (z1), z1, SCM_ARG1, sstring);
+ SCM_ASSERT (SCM_REALP (z1), z1, SCM_ARG1, sstring);
xy->x = SCM_REALPART (z1);
}
#endif
}
#else
{
- SCM_ASSERT (SCM_NIMP (z2) && SCM_REALP (z2), z2, SCM_ARG2, sstring);
+ SCM_ASSERT (SCM_REALP (z2), z2, SCM_ARG2, sstring);
xy->y = SCM_REALPART (z2);
}
#endif
SCM_WTA_DISPATCH_1 (g_real_part, z, SCM_ARG1, s_real_part);
}
#else
- SCM_GASSERT1 (SCM_NIMP (z) && SCM_INEXP (z),
+ SCM_GASSERT1 (SCM_INEXP (z),
g_real_part, z, SCM_ARG1, s_real_part);
#endif
if (SCM_CPLXP (z))
SCM_WTA_DISPATCH_1 (g_imag_part, z, SCM_ARG1, s_imag_part);
}
#else
- SCM_GASSERT1 (SCM_NIMP (z) && SCM_INEXP (z),
+ SCM_GASSERT1 (SCM_INEXP (z),
g_imag_part, z, SCM_ARG1, s_imag_part);
#endif
if (SCM_CPLXP (z))
SCM_WTA_DISPATCH_1 (g_magnitude, z, SCM_ARG1, s_magnitude);
}
#else
- SCM_GASSERT1 (SCM_NIMP (z) && SCM_INEXP (z),
+ SCM_GASSERT1 (SCM_INEXP (z),
g_magnitude, z, SCM_ARG1, s_magnitude);
#endif
if (SCM_CPLXP (z))
SCM_WTA_DISPATCH_1 (g_angle, z, SCM_ARG1, s_angle);
}
#else
- SCM_GASSERT1 (SCM_NIMP (z) && SCM_INEXP (z), g_angle, z, SCM_ARG1, s_angle);
+ SCM_GASSERT1 (SCM_INEXP (z), g_angle, z, SCM_ARG1, s_angle);
#endif
if (SCM_REALP (z))
{
"")
#define FUNC_NAME s_scm_entity_p
{
- return SCM_BOOL(SCM_NIMP (obj) && SCM_STRUCTP (obj) && SCM_I_ENTITYP (obj));
+ return SCM_BOOL(SCM_STRUCTP (obj) && SCM_I_ENTITYP (obj));
}
#undef FUNC_NAME
"")
#define FUNC_NAME s_scm_set_object_procedure_x
{
- SCM_ASSERT (SCM_NIMP (obj) && SCM_STRUCTP (obj)
+ SCM_ASSERT (SCM_STRUCTP (obj)
&& ((SCM_CLASS_FLAGS (obj) & SCM_CLASSF_OPERATOR)
|| (SCM_I_ENTITYP (obj)
&& !(SCM_OBJ_CLASS_FLAGS (obj)
"")
#define FUNC_NAME s_scm_object_procedure
{
- SCM_ASSERT (SCM_NIMP (obj) && SCM_STRUCTP (obj)
+ SCM_ASSERT (SCM_STRUCTP (obj)
&& ((SCM_CLASS_FLAGS (obj) & SCM_CLASSF_OPERATOR)
|| SCM_I_ENTITYP (obj)),
obj, SCM_ARG1, FUNC_NAME);
flags[i] = (unsigned long) options[i].val;
while (SCM_NNULLP (new_mode))
{
- SCM_ASSERT (SCM_NIMP (new_mode) && SCM_CONSP (new_mode),
+ SCM_ASSERT (SCM_CONSP (new_mode),
new_mode,
SCM_ARG1,
s);
SCM_VALIDATE_INT_COPY(3,whence,how);
if (how != SEEK_SET && how != SEEK_CUR && how != SEEK_END)
SCM_OUT_OF_RANGE (3, whence);
- if (SCM_NIMP (object) && SCM_OPPORTP (object))
+ if (SCM_OPPORTP (object))
{
scm_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (object);
if (SCM_UNBNDP (length))
{
/* must supply length if object is a filename. */
- if (SCM_NIMP (object) && SCM_ROSTRINGP (object))
+ if (SCM_ROSTRINGP (object))
scm_wrong_num_args (SCM_FUNC_NAME);
length = scm_seek (object, SCM_INUM0, SCM_MAKINUM (SEEK_CUR));
{
SCM_SYSCALL (rv = ftruncate (SCM_INUM (object), c_length));
}
- else if (SCM_NIMP (object) && SCM_OPOUTPORTP (object))
+ else if (SCM_OPOUTPORTP (object))
{
scm_port *pt = SCM_PTAB_ENTRY (object);
scm_ptob_descriptor *ptob = scm_ptobs + SCM_PTOBNUM (object);
int i;
SCM_ASSERT (SCM_NULLP (args)
- || (SCM_NIMP (args) && SCM_CONSP (args)),
+ || (SCM_CONSP (args)),
args, pos, subr);
num_args = scm_ilength (args);
execargv = (char **)
scm_sizet len;
char *dst;
char *src;
- SCM_ASSERT (SCM_NIMP (SCM_CAR (args)) && SCM_ROSTRINGP (SCM_CAR (args)),
+ SCM_ASSERT (SCM_ROSTRINGP (SCM_CAR (args)),
SCM_CAR (args), SCM_ARGn, subr);
len = 1 + SCM_ROLENGTH (SCM_CAR (args));
dst = (char *) scm_must_malloc ((long) len, subr);
char **result;
int i = 0;
- SCM_ASSERT (SCM_NULLP (envlist)
- || (SCM_NIMP (envlist) && SCM_CONSP (envlist)),
+ SCM_ASSERT (SCM_NULLP (envlist) || SCM_CONSP (envlist),
envlist, arg, proc);
num_strings = scm_ilength (envlist);
result = (char **) malloc ((num_strings + 1) * sizeof (char *));
env = SCM_ENV (exp);
scm_puts ("#<procedure", port);
}
- if (SCM_NIMP (name) && SCM_ROSTRINGP (name))
+ if (SCM_ROSTRINGP (name))
{
scm_putc (' ', port);
scm_puts (SCM_ROCHARS (name), port);
/* If PORT is a print-state/port pair, use that. Else create a new
print-state. */
- if (SCM_NIMP (port) && SCM_PORT_WITH_PS_P (port))
+ if (SCM_PORT_WITH_PS_P (port))
{
pstate_scm = SCM_PORT_WITH_PS_PS (port);
port = SCM_PORT_WITH_PS_PORT (port);
O(depth * N) instead of O(N^2). */
hare = SCM_CDR (exp);
tortoise = exp;
- while (SCM_NIMP (hare) && SCM_ECONSP (hare))
+ while (SCM_ECONSP (hare))
{
if (hare == tortoise)
goto fancy_printing;
proc = SCM_CAR (SCM_CODE (proc));
if (SCM_IMP (proc))
break;
- while (SCM_NIMP (proc) && SCM_CONSP (proc))
+ while (SCM_CONSP (proc))
{
++a;
proc = SCM_CDR (proc);
{
SCM_VALIDATE_PROC(1,proc);
return scm_acons (scm_sym_arity, scm_i_procedure_arity (proc),
- SCM_PROCPROPS (SCM_NIMP (proc) && SCM_CLOSUREP (proc)
+ SCM_PROCPROPS (SCM_CLOSUREP (proc)
? proc
: scm_stand_in_scm_proc (proc)));
}
"Set @var{obj}'s property list to @var{alist}.")
#define FUNC_NAME s_scm_set_procedure_properties_x
{
- if (!(SCM_NIMP (proc) && SCM_CLOSUREP (proc)))
+ if (!SCM_CLOSUREP (proc))
proc = scm_stand_in_scm_proc(proc);
SCM_VALIDATE_CLOSURE(1,proc);
SCM_SETPROCPROPS (proc, new_val);
}
SCM_VALIDATE_PROC(1,p);
assoc = scm_sloppy_assq (k,
- SCM_PROCPROPS (SCM_NIMP (p) && SCM_CLOSUREP (p)
+ SCM_PROCPROPS (SCM_CLOSUREP (p)
? p
: scm_stand_in_scm_proc (p)));
return (SCM_NIMP (assoc) ? SCM_CDR (assoc) : SCM_BOOL_F);
#define FUNC_NAME s_scm_set_procedure_property_x
{
SCM assoc;
- if (!(SCM_NIMP (p) && SCM_CLOSUREP (p)))
+ if (!SCM_CLOSUREP (p))
p = scm_stand_in_scm_proc(p);
SCM_VALIDATE_CLOSURE(1,p);
if (k == scm_sym_arity)
"")
#define FUNC_NAME s_scm_closure_p
{
- return SCM_BOOL(SCM_NIMP (obj) && SCM_CLOSUREP (obj));
+ return SCM_BOOL(SCM_CLOSUREP (obj));
}
#undef FUNC_NAME
"")
#define FUNC_NAME s_scm_procedure_with_setter_p
{
- return SCM_BOOL(SCM_NIMP (obj) && SCM_PROCEDURE_WITH_SETTER_P (obj));
+ return SCM_BOOL(SCM_PROCEDURE_WITH_SETTER_P (obj));
}
#undef FUNC_NAME
case scm_tc7_fvect:
{ /* scope */
float f, *ve = (float *) SCM_VELTS (ra);
- SCM_ASRTGO (SCM_NIMP (fill) && SCM_REALP (fill), badarg2);
+ SCM_ASRTGO (SCM_REALP (fill), badarg2);
f = SCM_REALPART (fill);
for (i = base; n--; i += inc)
ve[i] = f;
case scm_tc7_dvect:
{ /* scope */
double f, *ve = (double *) SCM_VELTS (ra);
- SCM_ASRTGO (SCM_NIMP (fill) && SCM_REALP (fill), badarg2);
+ SCM_ASRTGO (SCM_REALP (fill), badarg2);
f = SCM_REALPART (fill);
for (i = base; n--; i += inc)
ve[i] = f;
{ /* scope */
double fr, fi;
double (*ve)[2] = (double (*)[2]) SCM_VELTS (ra);
- SCM_ASRTGO (SCM_NIMP (fill) && SCM_INEXP (fill), badarg2);
+ SCM_ASRTGO (SCM_INEXP (fill), badarg2);
fr = SCM_REALPART (fill);
fi = (SCM_CPLXP (fill) ? SCM_IMAG (fill) : 0.0);
for (i = base; n--; i += inc)
if (SCM_INUMP(fill))
{
prot = scm_array_prototype (ra0);
- if (SCM_NIMP (prot) && SCM_INEXP (prot))
+ if (SCM_INEXP (prot))
fill = scm_makdbl ((double) SCM_INUM (fill), 0.0);
}
else
{
SCM tail, ra1 = SCM_CAR (lra);
- SCM v0 = (SCM_NIMP (ra0) && SCM_ARRAYP (ra0) ? SCM_ARRAY_V (ra0) : ra0);
+ SCM v0 = (SCM_ARRAYP (ra0) ? SCM_ARRAY_V (ra0) : ra0);
ra_iproc *p;
/* Check to see if order might matter.
This might be an argument for a separate
SERIAL-ARRAY-MAP! */
- if (v0 == ra1 || (SCM_NIMP (ra1) && SCM_ARRAYP (ra1) && v0 == SCM_ARRAY_V (ra1)))
+ if (v0 == ra1 || (SCM_ARRAYP (ra1) && v0 == SCM_ARRAY_V (ra1)))
if (ra0 != ra1 || (SCM_ARRAYP(ra0) && !SCM_ARRAY_CONTP(ra0)))
goto gencase;
for (tail = SCM_CDR (lra); SCM_NNULLP (tail); tail = SCM_CDR (tail))
{
ra1 = SCM_CAR (tail);
- if (v0 == ra1 || (SCM_NIMP (ra1) && SCM_ARRAYP (ra1) && v0 == SCM_ARRAY_V (ra1)))
+ if (v0 == ra1 || (SCM_ARRAYP (ra1) && v0 == SCM_ARRAY_V (ra1)))
goto gencase;
}
for (p = ra_asubrs; p->name; p++)
scm_c_default_rstate ()
{
SCM state = SCM_CDR (scm_var_random_state);
- SCM_ASSERT (SCM_NIMP (state) && SCM_RSTATEP (state),
+ SCM_ASSERT (SCM_RSTATEP (state),
state, "*random-state* contains bogus random state", 0);
return SCM_RSTATE (state);
}
{
copy = scm_cons (recsexpr (SCM_CAR (obj), line, column, filename),
SCM_UNDEFINED);
- while (SCM_NIMP (tmp = SCM_CDR (tmp)) && SCM_CONSP (tmp))
+ while ((tmp = SCM_CDR (tmp)) && SCM_CONSP (tmp))
{
SCM_SETCDR (copy, scm_cons (recsexpr (SCM_CAR (tmp),
line,
else
{
recsexpr (SCM_CAR (obj), line, column, filename);
- while (SCM_NIMP (tmp = SCM_CDR (tmp)) && SCM_CONSP (tmp))
+ while ((tmp = SCM_CDR (tmp)) && SCM_CONSP (tmp))
recsexpr (SCM_CAR (tmp), line, column, filename);
copy = SCM_UNDEFINED;
}
/* Build the head of the list structure. */
ans = tl = scm_cons (tmp, SCM_EOL);
if (SCM_COPY_SOURCE_P)
- ans2 = tl2 = scm_cons (SCM_NIMP (tmp) && SCM_CONSP (tmp)
+ ans2 = tl2 = scm_cons (SCM_CONSP (tmp)
? *copy
: tmp,
SCM_EOL);
{
SCM_SETCDR (tl, tmp = scm_lreadr (tok_buf, port, copy));
if (SCM_COPY_SOURCE_P)
- SCM_SETCDR (tl2, scm_cons (SCM_NIMP (tmp) && SCM_CONSP (tmp)
+ SCM_SETCDR (tl2, scm_cons (SCM_CONSP (tmp)
? *copy
: tmp,
SCM_EOL));
}
tl = SCM_SETCDR (tl, scm_cons (tmp, SCM_EOL));
if (SCM_COPY_SOURCE_P)
- tl2 = SCM_SETCDR (tl2, scm_cons (SCM_NIMP (tmp) && SCM_CONSP (tmp)
+ tl2 = SCM_SETCDR (tl2, scm_cons (SCM_CONSP (tmp)
? *copy
: tmp,
SCM_EOL));
@code{#f} otherwise.")
#define FUNC_NAME s_scm_regexp_p
{
- return SCM_BOOL(SCM_NIMP (x) && SCM_RGXP (x));
+ return SCM_BOOL(SCM_RGXP (x));
}
#undef FUNC_NAME
root_state = (scm_root_state *) scm_must_malloc (sizeof (scm_root_state),
"scm_make_root");
- if (SCM_NIMP (parent) && SCM_ROOTP (parent))
+ if (SCM_ROOTP (parent))
{
memcpy (root_state, SCM_ROOT_STATE (parent), sizeof (scm_root_state));
scm_copy_fluids (root_state);
-/* $Id: scm_validate.h,v 1.6 1999-12-13 00:52:43 gjb Exp $ */
+/* $Id: scm_validate.h,v 1.7 1999-12-16 20:48:04 gjb Exp $ */
/* Copyright (C) 1999 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify
do { SCM_ASSERT (SCM_NIMP (a) && SCM_ASYNCP (a), a, pos, FUNC_NAME); \
cvar = SCM_ASYNC(a); } while (0)
+#define SCM_VALIDATE_THREAD(pos,a) \
+ do { SCM_ASSERT (SCM_NIMP (a) && SCM_THREADP (a), a, pos, FUNC_NAME); } while (0)
+
#define SCM_VALIDATE_THUNK(pos,thunk) \
do { SCM_ASSERT (SCM_NFALSEP (scm_thunk_p (thunk)), thunk, pos, FUNC_NAME); } while (0)
{
#ifdef HAVE_STRUCT_LINGER
struct linger ling;
- SCM_ASSERT (SCM_NIMP (value) && SCM_CONSP (value)
+ SCM_ASSERT (SCM_CONSP (value)
&& SCM_INUMP (SCM_CAR (value))
&& SCM_INUMP (SCM_CDR (value)),
value, SCM_ARG4, FUNC_NAME);
memcpy (optval, (void *) &ling, optlen);
#else
scm_sizet ling;
- SCM_ASSERT (SCM_NIMP (value) && SCM_CONSP (value)
+ SCM_ASSERT (SCM_CONSP (value)
&& SCM_INUMP (SCM_CAR (value))
&& SCM_INUMP (SCM_CDR (value)),
value, SCM_ARG4, FUNC_NAME);
soka->sin_family = AF_INET;
soka->sin_addr.s_addr =
htonl (scm_num2ulong (address, (char *) which_arg, proc));
- SCM_ASSERT (SCM_NIMP (*args) && SCM_CONSP (*args), *args,
+ SCM_ASSERT (SCM_CONSP (*args), *args,
which_arg + 1, proc);
isport = SCM_CAR (*args);
*args = SCM_CDR (*args);
scm_must_malloc (sizeof (struct sockaddr_un), proc);
memset (soka, 0, sizeof (struct sockaddr_un));
soka->sun_family = AF_UNIX;
- SCM_ASSERT (SCM_NIMP (address) && SCM_ROSTRINGP (address), address,
+ SCM_ASSERT (SCM_ROSTRINGP (address), address,
which_arg, proc);
memcpy (soka->sun_path, SCM_ROCHARS (address),
1 + SCM_ROLENGTH (address));
if (scm_sym_breakpoint == key)
{
if (SCM_FALSEP (datum))
- CLEARSRCPROPBRK (SCM_NIMP (p) && SRCPROPSP (p)
+ CLEARSRCPROPBRK (SRCPROPSP (p)
? p
: SCM_WHASHSET (scm_source_whash, h,
scm_make_srcprops (0,
SCM_UNDEFINED,
p)));
else
- SETSRCPROPBRK (SCM_NIMP (p) && SRCPROPSP (p)
+ SETSRCPROPBRK (SRCPROPSP (p)
? p
: SCM_WHASHSET (scm_source_whash, h,
scm_make_srcprops (0,
else if (scm_sym_line == key)
{
SCM_VALIDATE_INT(3,datum);
- if (SCM_NIMP (p) && SRCPROPSP (p))
+ if (SRCPROPSP (p))
SETSRCPROPLINE (p, SCM_INUM (datum));
else
SCM_WHASHSET (scm_source_whash, h,
else if (scm_sym_column == key)
{
SCM_VALIDATE_INT(3,datum);
- if (SCM_NIMP (p) && SRCPROPSP (p))
+ if (SRCPROPSP (p))
SETSRCPROPCOL (p, SCM_INUM (datum));
else
SCM_WHASHSET (scm_source_whash, h,
}
else if (scm_sym_filename == key)
{
- if (SCM_NIMP (p) && SRCPROPSP (p))
+ if (SRCPROPSP (p))
SRCPROPFNAME (p) = datum;
else
SCM_WHASHSET (scm_source_whash, h, scm_make_srcprops (0, 0, datum, SCM_UNDEFINED, p));
}
else if (scm_sym_filename == key)
{
- if (SCM_NIMP (p) && SRCPROPSP (p))
+ if (SRCPROPSP (p))
SRCPROPCOPY (p) = datum;
else
SCM_WHASHSET (scm_source_whash, h, scm_make_srcprops (0, 0, SCM_UNDEFINED, datum, p));
get_applybody ()
{
SCM proc = SCM_CDR (scm_sym2vcell (scm_sym_apply, SCM_BOOL_F, SCM_BOOL_F));
- if (SCM_NIMP (proc) && SCM_CLOSUREP (proc))
+ if (SCM_CLOSUREP (proc))
return SCM_CADR (SCM_CODE (proc));
else
return SCM_UNDEFINED;
"Return @code{#t} if @var{obj} is a calling stack.")
#define FUNC_NAME s_scm_stack_p
{
- return SCM_BOOL(SCM_NIMP (obj) && SCM_STACKP (obj));
+ return SCM_BOOL(SCM_STACKP (obj));
}
#undef FUNC_NAME
SCM stack, id;
SCM obj, inner_cut, outer_cut;
- SCM_ASSERT (SCM_NIMP (args) && SCM_CONSP (args),
+ SCM_ASSERT (SCM_CONSP (args),
SCM_FUNC_NAME, SCM_WNA, NULL);
obj = SCM_CAR (args);
args = SCM_CDR (args);
SCM_STACK (stack) -> length = n;
/* Narrow the stack according to the arguments given to scm_make_stack. */
- while (n > 0 && SCM_NIMP (args) && SCM_CONSP (args))
+ while (n > 0 && SCM_CONSP (args))
{
inner_cut = SCM_CAR (args);
args = SCM_CDR (args);
- if (SCM_NIMP (args) && SCM_CONSP (args))
+ if (SCM_CONSP (args))
{
outer_cut = SCM_CAR (args);
args = SCM_CDR (args);
"")
#define FUNC_NAME s_scm_frame_p
{
- return SCM_BOOL(SCM_NIMP (obj) && SCM_FRAMEP (obj));
+ return SCM_BOOL(SCM_FRAMEP (obj));
}
#undef FUNC_NAME
char *buf;
/* if zone was supplied, set the environment temporarily. */
- SCM_ASSERT (SCM_NIMP (zone) && SCM_ROSTRINGP (zone), zone, pos, subr);
+ SCM_ASSERT (SCM_ROSTRINGP (zone), zone, pos, subr);
SCM_COERCE_SUBSTR (zone);
buf = scm_must_malloc (SCM_LENGTH (zone) + sizeof (tzvar) + 1,
subr);
SCM *velts;
int i;
- SCM_ASSERT (SCM_NIMP (sbd_time) && SCM_VECTORP (sbd_time)
+ SCM_ASSERT (SCM_VECTORP (sbd_time)
&& SCM_LENGTH (sbd_time) == 11,
sbd_time, pos, subr);
velts = SCM_VELTS (sbd_time);
{
SCM_ASSERT (SCM_INUMP (velts[i]), sbd_time, pos, subr);
}
- SCM_ASSERT (SCM_FALSEP (velts[10])
- || (SCM_NIMP (velts[10]) && SCM_STRINGP (velts[10])),
+ SCM_ASSERT (SCM_FALSEP (velts[10]) || SCM_STRINGP (velts[10]),
sbd_time, pos, subr);
lt->tm_sec = SCM_INUM (velts[0]);
for (len = 0, s = chrs; s != SCM_EOL; s = SCM_CDR (s))
if (SCM_ICHRP (SCM_CAR (s)))
len += 1;
- else if (SCM_NIMP (SCM_CAR (s)) && SCM_ROSTRINGP (SCM_CAR (s)))
+ else if (SCM_ROSTRINGP (SCM_CAR (s)))
len += SCM_ROLENGTH (SCM_CAR (s));
else
{
int upper;
int ch;
- SCM_ASSERT (SCM_NIMP (*str) && SCM_ROSTRINGP (*str), *str, SCM_ARG1, why);
+ SCM_ASSERT (SCM_ROSTRINGP (*str), *str, SCM_ARG1, why);
SCM_ASSERT (SCM_ICHRP (chr), chr, SCM_ARG2, why);
if (sub_start == SCM_BOOL_F)
int str_len;
SCM_ASSERT (SCM_INUMP(pos) && SCM_INUM(pos) >= 0, pos, SCM_ARG1, caller);
- SCM_ASSERT (SCM_NIMP(str) && SCM_ROSTRINGP(str), str, SCM_ARG1, caller);
+ SCM_ASSERT (SCM_ROSTRINGP(str), str, SCM_ARG1, caller);
str_len = SCM_ROLENGTH (str);
if (SCM_INUM (pos) > str_len)
scm_out_of_range (caller, pos);
"Return #t iff @var{obj} is a structure object, else #f.")
#define FUNC_NAME s_scm_struct_p
{
- return SCM_BOOL(SCM_NIMP (x) && SCM_STRUCTP (x));
+ return SCM_BOOL(SCM_STRUCTP (x));
}
#undef FUNC_NAME
SCM_VALIDATE_ROSTRING(2,s);
SCM_ASSERT((o == SCM_BOOL_F)
|| (o == SCM_BOOL_T)
- || (SCM_NIMP(o) && SCM_VECTORP(o)),
+ || (SCM_VECTORP(o)),
o, SCM_ARG1, FUNC_NAME);
softness = ((softp != SCM_UNDEFINED) && (softp != SCM_BOOL_F));
{
struct scm_body_thunk_data c;
- SCM_ASSERT ((SCM_NIMP(tag) && SCM_SYMBOLP(tag)) || tag == SCM_BOOL_T,
+ SCM_ASSERT (SCM_SYMBOLP(tag) || tag == SCM_BOOL_T,
tag, SCM_ARG1, FUNC_NAME);
c.tag = tag;
{
struct scm_body_thunk_data c;
- SCM_ASSERT ((SCM_NIMP(tag) && SCM_SYMBOLP(tag))
- || (tag == SCM_BOOL_T),
+ SCM_ASSERT (SCM_SYMBOLP(tag) || (tag == SCM_BOOL_T),
tag, SCM_ARG1, FUNC_NAME);
c.tag = tag;
abort ();
dynpair = SCM_CAR (winds);
- if (SCM_NIMP (dynpair) && SCM_CONSP (dynpair))
+ if (SCM_CONSP (dynpair))
{
SCM this_key = SCM_CAR (dynpair);
else
type = scm_tc7_ivect;
}
- else if (SCM_NIMP (prot) && SCM_SYMBOLP (prot) && (1 == SCM_LENGTH (prot)))
+ else if (SCM_SYMBOLP (prot) && (1 == SCM_LENGTH (prot)))
{
char s;
# ifdef SCM_FLOATS
# ifdef SCM_SINGLES
case scm_tc7_fvect:
- return nprot || SCM_BOOL(SCM_NIMP(prot) && SCM_SINGP(prot));
+ return nprot || SCM_BOOL(SCM_SINGP(prot));
# endif
case scm_tc7_dvect:
- return nprot || SCM_BOOL(SCM_NIMP(prot) && SCM_REALP(prot));
+ return nprot || SCM_BOOL(SCM_REALP(prot));
case scm_tc7_cvect:
- return nprot || SCM_BOOL(SCM_NIMP(prot) && SCM_CPLXP(prot));
+ return nprot || SCM_BOOL(SCM_CPLXP(prot));
# endif
case scm_tc7_vector:
case scm_tc7_wvect:
s_bad_spec, what);
s->lbnd = SCM_INUM (SCM_CAR (spec));
sp = SCM_CDR (spec);
- SCM_ASSERT (SCM_NIMP (sp) && SCM_CONSP (sp)
+ SCM_ASSERT (SCM_CONSP (sp)
&& SCM_INUMP (SCM_CAR (sp)) && SCM_NULLP (SCM_CDR (sp)),
spec, s_bad_spec, what);
s->ubnd = SCM_INUM (SCM_CAR (sp));
if (!SCM_UNBNDP (fill))
scm_array_fill_x (answer, fill);
- else if (SCM_NIMP (prot) && SCM_SYMBOLP (prot))
+ else if (SCM_SYMBOLP (prot))
scm_array_fill_x (answer, SCM_MAKINUM (0));
else
scm_array_fill_x (answer, prot);
else
dims = scm_cons (dims, SCM_EOL);
}
- SCM_ASSERT (SCM_NULLP (dims) || (SCM_NIMP (dims) && SCM_CONSP (dims)),
- dims, SCM_ARG1, FUNC_NAME);
+ SCM_ASSERT (SCM_NULLP (dims) || SCM_CONSP (dims),
+ dims, SCM_ARG1, FUNC_NAME);
ra = scm_shap2ra (dims, FUNC_NAME);
SCM_SETOR_CAR (ra, SCM_ARRAY_CONTIGUOUS);
s = SCM_ARRAY_DIMS (ra);
{
scm_array_fill_x (ra, fill);
}
- else if (SCM_NIMP (prot) && SCM_SYMBOLP (prot))
+ else if (SCM_SYMBOLP (prot))
scm_array_fill_x (ra, SCM_MAKINUM (0));
else
scm_array_fill_x (ra, prot);
((double *) SCM_CDR (v))[pos] = scm_num2dbl(obj, FUNC_NAME); break;
break;
case scm_tc7_cvect:
- SCM_ASRTGO (SCM_NIMP (obj) && SCM_INEXP (obj), badobj);
+ SCM_ASRTGO (SCM_INEXP (obj), badobj);
((double *) SCM_CDR (v))[2 * pos] = SCM_REALPART (obj);
((double *) SCM_CDR (v))[2 * pos + 1] = SCM_CPLXP (obj) ? SCM_IMAG (obj) : 0.0;
break;
port_or_fd = scm_cur_inp;
else
SCM_ASSERT (SCM_INUMP (port_or_fd)
- || (SCM_NIMP (port_or_fd) && SCM_OPINPORTP (port_or_fd)),
+ || (SCM_OPINPORTP (port_or_fd)),
port_or_fd, SCM_ARG2, FUNC_NAME);
vlen = SCM_LENGTH (v);
port_or_fd = scm_cur_outp;
else
SCM_ASSERT (SCM_INUMP (port_or_fd)
- || (SCM_NIMP (port_or_fd) && SCM_OPOUTPORTP (port_or_fd)),
+ || (SCM_OPOUTPORTP (port_or_fd)),
port_or_fd, SCM_ARG2, FUNC_NAME);
vlen = SCM_LENGTH (v);
"")
#define FUNC_NAME s_scm_variable_p
{
- return SCM_BOOL(SCM_NIMP(obj) && SCM_VARIABLEP (obj));
+ return SCM_BOOL(SCM_VARIABLEP (obj));
}
#undef FUNC_NAME
SCM
scm_vector_length(SCM v)
{
- SCM_GASSERT1(SCM_NIMP(v) && SCM_VECTORP(v),
+ SCM_GASSERT1(SCM_VECTORP(v),
g_vector_length, v, SCM_ARG1, s_vector_length);
return SCM_MAKINUM(SCM_LENGTH(v));
}
SCM
scm_vector_ref (SCM v, SCM k)
{
- SCM_GASSERT2 (SCM_NIMP (v) && SCM_VECTORP (v),
+ SCM_GASSERT2 (SCM_VECTORP (v),
g_vector_ref, v, k, SCM_ARG1, s_vector_ref);
SCM_GASSERT2 (SCM_INUMP (k),
g_vector_ref, v, k, SCM_ARG2, s_vector_ref);
SCM
scm_vector_set_x(SCM v, SCM k, SCM obj)
{
- SCM_GASSERTn (SCM_NIMP(v) && SCM_VECTORP(v),
+ SCM_GASSERTn (SCM_VECTORP(v),
g_vector_set_x, SCM_LIST3 (v, k, obj),
SCM_ARG1, s_vector_set_x);
SCM_GASSERTn (SCM_INUMP(k),
res = scm_make_weak_vector (SCM_MAKINUM (i), SCM_UNSPECIFIED);
data = SCM_VELTS (res);
for (;
- i && SCM_NIMP (l) && SCM_CONSP (l);
+ i && SCM_CONSP (l);
--i, l = SCM_CDR (l))
*data++ = SCM_CAR (l);
return res;
hashes are also weak vectors.")
#define FUNC_NAME s_scm_weak_vector_p
{
- return SCM_BOOL(SCM_NIMP (x) && SCM_WVECTP (x) && !SCM_IS_WHVEC (x));
+ return SCM_BOOL(SCM_WVECTP (x) && !SCM_IS_WHVEC (x));
}
#undef FUNC_NAME
hash table.")
#define FUNC_NAME s_scm_weak_key_hash_table_p
{
- return SCM_BOOL(SCM_NIMP (x) && SCM_WVECTP (x) && SCM_IS_WHVEC(x));
+ return SCM_BOOL(SCM_WVECTP (x) && SCM_IS_WHVEC(x));
}
#undef FUNC_NAME
"")
#define FUNC_NAME s_scm_weak_value_hash_table_p
{
- return SCM_BOOL(SCM_NIMP (x) && SCM_WVECTP (x) && SCM_IS_WHVEC_V(x));
+ return SCM_BOOL(SCM_WVECTP (x) && SCM_IS_WHVEC_V(x));
}
#undef FUNC_NAME
"")
#define FUNC_NAME s_scm_doubly_weak_hash_table_p
{
- return SCM_BOOL(SCM_NIMP (x) && SCM_WVECTP (x) && SCM_IS_WHVEC_B (x));
+ return SCM_BOOL(SCM_WVECTP (x) && SCM_IS_WHVEC_B (x));
}
#undef FUNC_NAME
HCoop / bpt / guile.git / commitdiff