register Lisp_Object symbol;
{
Lisp_Object valcontents;
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
valcontents = SYMBOL_VALUE (symbol);
(symbol)
register Lisp_Object symbol;
{
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
return (EQ (XSYMBOL (symbol)->function, Qunbound) ? Qnil : Qt);
}
(symbol)
register Lisp_Object symbol;
{
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
if (XSYMBOL (symbol)->constant)
return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
Fset (symbol, Qunbound);
(symbol)
register Lisp_Object symbol;
{
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
if (NILP (symbol) || EQ (symbol, Qt))
return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
XSYMBOL (symbol)->function = Qunbound;
(symbol)
register Lisp_Object symbol;
{
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
if (EQ (XSYMBOL (symbol)->function, Qunbound))
return Fsignal (Qvoid_function, Fcons (symbol, Qnil));
return XSYMBOL (symbol)->function;
(symbol)
register Lisp_Object symbol;
{
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
return XSYMBOL (symbol)->plist;
}
{
register Lisp_Object name;
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
XSETSTRING (name, XSYMBOL (symbol)->name);
return name;
}
(symbol, definition)
register Lisp_Object symbol, definition;
{
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
if (NILP (symbol) || EQ (symbol, Qt))
return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
if (!NILP (Vautoload_queue) && !EQ (XSYMBOL (symbol)->function, Qunbound))
(symbol, newplist)
register Lisp_Object symbol, newplist;
{
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
XSYMBOL (symbol)->plist = newplist;
return newplist;
}
switch (XMISCTYPE (valcontents))
{
case Lisp_Misc_Intfwd:
- CHECK_NUMBER (newval, 1);
+ CHECK_NUMBER (newval);
*XINTFWD (valcontents)->intvar = XINT (newval);
if (*XINTFWD (valcontents)->intvar != XINT (newval))
error ("Value out of range for variable `%s'",
register Lisp_Object valcontents;
register Lisp_Object val;
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
valcontents = SYMBOL_VALUE (symbol);
if (BUFFER_LOCAL_VALUEP (valcontents)
if (NILP (buf->name))
return newval;
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
if (SYMBOL_CONSTANT_P (symbol)
&& (NILP (Fkeywordp (symbol))
|| !EQ (newval, SYMBOL_VALUE (symbol))))
{
register Lisp_Object valcontents;
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
valcontents = SYMBOL_VALUE (symbol);
/* For a built-in buffer-local variable, get the default value
{
register Lisp_Object valcontents, current_alist_element, alist_element_buffer;
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
valcontents = SYMBOL_VALUE (symbol);
/* Handle variables like case-fold-search that have special slots
(setq-default SYMBOL VALUE SYMBOL VALUE...)
This sets each SYMBOL's default value to the corresponding VALUE.
The VALUE for the Nth SYMBOL can refer to the new default values
-of previous SYMs. */)
+of previous SYMs.
+usage: (setq-default SYMBOL VALUE [SYMBOL VALUE...]) */)
(args)
Lisp_Object args;
{
{
register Lisp_Object tem, valcontents, newval;
- CHECK_SYMBOL (variable, 0);
+ CHECK_SYMBOL (variable);
valcontents = SYMBOL_VALUE (variable);
if (EQ (variable, Qnil) || EQ (variable, Qt) || KBOARD_OBJFWDP (valcontents))
works.
Do not use `make-local-variable' to make a hook variable buffer-local.
-Use `make-local-hook' instead. */)
+Instead, use `add-hook' and specify t for the LOCAL argument. */)
(variable)
register Lisp_Object variable;
{
register Lisp_Object tem, valcontents;
- CHECK_SYMBOL (variable, 0);
+ CHECK_SYMBOL (variable);
valcontents = SYMBOL_VALUE (variable);
if (EQ (variable, Qnil) || EQ (variable, Qt) || KBOARD_OBJFWDP (valcontents))
{
register Lisp_Object tem, valcontents;
- CHECK_SYMBOL (variable, 0);
+ CHECK_SYMBOL (variable);
valcontents = SYMBOL_VALUE (variable);
{
register Lisp_Object tem, valcontents, newval;
- CHECK_SYMBOL (variable, 0);
+ CHECK_SYMBOL (variable);
valcontents = SYMBOL_VALUE (variable);
if (EQ (variable, Qnil) || EQ (variable, Qt) || KBOARD_OBJFWDP (valcontents)
buf = current_buffer;
else
{
- CHECK_BUFFER (buffer, 0);
+ CHECK_BUFFER (buffer);
buf = XBUFFER (buffer);
}
- CHECK_SYMBOL (variable, 0);
+ CHECK_SYMBOL (variable);
valcontents = SYMBOL_VALUE (variable);
if (BUFFER_LOCAL_VALUEP (valcontents)
buf = current_buffer;
else
{
- CHECK_BUFFER (buffer, 0);
+ CHECK_BUFFER (buffer);
buf = XBUFFER (buffer);
}
- CHECK_SYMBOL (variable, 0);
+ CHECK_SYMBOL (variable);
valcontents = SYMBOL_VALUE (variable);
{
register int idxval;
- CHECK_NUMBER (idx, 1);
+ CHECK_NUMBER (idx);
idxval = XINT (idx);
if (STRINGP (array))
{
{
register int idxval;
- CHECK_NUMBER (idx, 1);
+ CHECK_NUMBER (idx);
idxval = XINT (idx);
if (!VECTORP (array) && !STRINGP (array) && !BOOL_VECTOR_P (array)
&& ! CHAR_TABLE_P (array))
if (idxval < 0 || idxval >= XSTRING (array)->size)
args_out_of_range (array, idx);
- CHECK_NUMBER (newelt, 2);
+ CHECK_NUMBER (newelt);
idxval_byte = string_char_to_byte (array, idxval);
p1 = &XSTRING (array)->data[idxval_byte];
{
if (idxval < 0 || idxval >= XSTRING (array)->size)
args_out_of_range (array, idx);
- CHECK_NUMBER (newelt, 2);
+ CHECK_NUMBER (newelt);
if (XINT (newelt) < 0 || SINGLE_BYTE_CHAR_P (XINT (newelt)))
XSTRING (array)->data[idxval] = XINT (newelt);
double f1 = 0, f2 = 0;
int floatp = 0;
- CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1, 0);
- CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2, 0);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num1);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (num2);
if (FLOATP (num1) || FLOATP (num2))
{
(number)
register Lisp_Object number;
{
- CHECK_NUMBER_OR_FLOAT (number, 0);
+ CHECK_NUMBER_OR_FLOAT (number);
if (FLOATP (number))
{
{
char buffer[VALBITS];
- CHECK_NUMBER_OR_FLOAT (number, 0);
+ CHECK_NUMBER_OR_FLOAT (number);
if (FLOATP (number))
{
int sign = 1;
Lisp_Object val;
- CHECK_STRING (string, 0);
+ CHECK_STRING (string);
if (NILP (base))
b = 10;
else
{
- CHECK_NUMBER (base, 1);
+ CHECK_NUMBER (base);
b = XINT (base);
if (b < 2 || b > 16)
Fsignal (Qargs_out_of_range, Fcons (base, Qnil));
{
/* Using args[argnum] as argument to CHECK_NUMBER_... */
val = args[argnum];
- CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val, argnum);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val);
if (FLOATP (val))
return float_arith_driver ((double) accum, argnum, code,
for (; argnum < nargs; argnum++)
{
val = args[argnum]; /* using args[argnum] as argument to CHECK_NUMBER_... */
- CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val, argnum);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val);
if (FLOATP (val))
{
}
DEFUN ("*", Ftimes, Stimes, 0, MANY, 0,
- doc: /* Returns product of any number of arguments, which are numbers or markers.
+ doc: /* Return product of any number of arguments, which are numbers or markers.
usage: (* &rest NUMBERS-OR-MARKERS) */)
(nargs, args)
int nargs;
}
DEFUN ("/", Fquo, Squo, 2, MANY, 0,
- doc: /* Returns first argument divided by all the remaining arguments.
+ doc: /* Return first argument divided by all the remaining arguments.
The arguments must be numbers or markers.
usage: (/ DIVIDEND DIVISOR &rest DIVISORS) */)
(nargs, args)
}
DEFUN ("%", Frem, Srem, 2, 2, 0,
- doc: /* Returns remainder of X divided by Y.
+ doc: /* Return remainder of X divided by Y.
Both must be integers or markers. */)
(x, y)
register Lisp_Object x, y;
{
Lisp_Object val;
- CHECK_NUMBER_COERCE_MARKER (x, 0);
- CHECK_NUMBER_COERCE_MARKER (y, 1);
+ CHECK_NUMBER_COERCE_MARKER (x);
+ CHECK_NUMBER_COERCE_MARKER (y);
if (XFASTINT (y) == 0)
Fsignal (Qarith_error, Qnil);
#endif /* ! HAVE_FMOD */
DEFUN ("mod", Fmod, Smod, 2, 2, 0,
- doc: /* Returns X modulo Y.
+ doc: /* Return X modulo Y.
The result falls between zero (inclusive) and Y (exclusive).
Both X and Y must be numbers or markers. */)
(x, y)
Lisp_Object val;
EMACS_INT i1, i2;
- CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (x, 0);
- CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (y, 1);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (x);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (y);
if (FLOATP (x) || FLOATP (y))
return fmod_float (x, y);
{
register Lisp_Object val;
- CHECK_NUMBER (value, 0);
- CHECK_NUMBER (count, 1);
+ CHECK_NUMBER (value);
+ CHECK_NUMBER (count);
if (XINT (count) >= BITS_PER_EMACS_INT)
XSETINT (val, 0);
{
register Lisp_Object val;
- CHECK_NUMBER (value, 0);
- CHECK_NUMBER (count, 1);
+ CHECK_NUMBER (value);
+ CHECK_NUMBER (count);
if (XINT (count) >= BITS_PER_EMACS_INT)
XSETINT (val, 0);
(number)
register Lisp_Object number;
{
- CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number, 0);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number);
if (FLOATP (number))
return (make_float (1.0 + XFLOAT_DATA (number)));
(number)
register Lisp_Object number;
{
- CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number, 0);
+ CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (number);
if (FLOATP (number))
return (make_float (-1.0 + XFLOAT_DATA (number)));
(number)
register Lisp_Object number;
{
- CHECK_NUMBER (number, 0);
+ CHECK_NUMBER (number);
XSETINT (number, ~XINT (number));
return number;
}