static Lisp_Object swap_in_symval_forwarding P_ ((Lisp_Object, Lisp_Object));
-int most_positive_fixnum, most_negative_fixnum;
+Lisp_Object Vmost_positive_fixnum, Vmost_negative_fixnum;
void
register Lisp_Object tem;
do
{
- if (!EQ (Vmocklisp_arguments, Qt))
- {
- if (STRINGP (value) &&
- (EQ (predicate, Qintegerp) || EQ (predicate, Qinteger_or_marker_p)))
- return Fstring_to_number (value, Qnil);
- if (INTEGERP (value) && EQ (predicate, Qstringp))
- return Fnumber_to_string (value);
- }
-
/* If VALUE is not even a valid Lisp object, abort here
where we can get a backtrace showing where it came from. */
if ((unsigned int) XGCTYPE (value) >= Lisp_Type_Limit)
Lisp_Object object;
{
if (SYMBOLP (object)
- && XSYMBOL (object)->name->data[0] == ':'
+ && SREF (SYMBOL_NAME (object), 0) == ':'
&& SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P (object))
return Qt;
return Qnil;
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);
}
DEFUN ("makunbound", Fmakunbound, Smakunbound, 1, 1, 0,
- doc: /* Make SYMBOL's value be void. */)
+ doc: /* Make SYMBOL's value be void.
+Return SYMBOL. */)
(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);
}
DEFUN ("fmakunbound", Ffmakunbound, Sfmakunbound, 1, 1, 0,
- doc: /* Make SYMBOL's function definition be void. */)
+ doc: /* Make SYMBOL's function definition be void.
+Return SYMBOL. */)
(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);
- XSETSTRING (name, XSYMBOL (symbol)->name);
+ CHECK_SYMBOL (symbol);
+ name = SYMBOL_NAME (symbol);
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))
return definition;
}
-DEFUN ("defalias", Fdefalias, Sdefalias, 2, 2, 0,
+extern Lisp_Object Qfunction_documentation;
+
+DEFUN ("defalias", Fdefalias, Sdefalias, 2, 3, 0,
doc: /* Set SYMBOL's function definition to DEFINITION, and return DEFINITION.
-Associates the function with the current load file, if any. */)
- (symbol, definition)
- register Lisp_Object symbol, definition;
-{
+Associates the function with the current load file, if any.
+The optional third argument DOCSTRING specifies the documentation string
+for SYMBOL; if it is omitted or nil, SYMBOL uses the documentation string
+determined by DEFINITION. */)
+ (symbol, definition, docstring)
+ register Lisp_Object symbol, definition, docstring;
+{
+ if (CONSP (XSYMBOL (symbol)->function)
+ && EQ (XCAR (XSYMBOL (symbol)->function), Qautoload))
+ LOADHIST_ATTACH (Fcons (Qt, symbol));
definition = Ffset (symbol, definition);
LOADHIST_ATTACH (symbol);
+ if (!NILP (docstring))
+ Fput (symbol, Qfunction_documentation, docstring);
return definition;
}
(symbol, newplist)
register Lisp_Object symbol, newplist;
{
- CHECK_SYMBOL (symbol, 0);
+ CHECK_SYMBOL (symbol);
XSYMBOL (symbol)->plist = newplist;
return newplist;
}
hare = XSYMBOL (hare)->value;
if (!XSYMBOL (hare)->indirect_variable)
break;
-
+
hare = XSYMBOL (hare)->value;
tortoise = XSYMBOL (tortoise)->value;
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'",
- XSYMBOL (symbol)->name->data);
+ SDATA (SYMBOL_NAME (symbol)));
break;
case Lisp_Misc_Boolfwd:
type = PER_BUFFER_TYPE (offset);
if (XINT (type) == -1)
- error ("Variable %s is read-only", XSYMBOL (symbol)->name->data);
+ error ("Variable %s is read-only", SDATA (SYMBOL_NAME (symbol)));
if (! NILP (type) && ! NILP (newval)
&& XTYPE (newval) != XINT (type))
Lisp_Object symbol;
{
Lisp_Object valcontents, cdr;
-
+
valcontents = SYMBOL_VALUE (symbol);
if (!BUFFER_LOCAL_VALUEP (valcontents)
&& !SOME_BUFFER_LOCAL_VALUEP (valcontents))
/* Unload the previously loaded binding. */
Fsetcdr (XCAR (cdr),
do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents)->realvalue));
-
+
/* Select the global binding in the symbol. */
XSETCAR (cdr, cdr);
store_symval_forwarding (symbol, valcontents, XCDR (cdr), NULL);
Lisp_Object symbol, valcontents;
{
register Lisp_Object tem1;
-
+
tem1 = XBUFFER_LOCAL_VALUE (valcontents)->buffer;
if (NILP (tem1)
{
if (XSYMBOL (symbol)->indirect_variable)
symbol = indirect_variable (symbol);
-
+
/* Unload the previously loaded binding. */
tem1 = XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr);
Fsetcdr (tem1,
{
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))))
return Fsignal (Qsetting_constant, Fcons (symbol, Qnil));
innercontents = valcontents = SYMBOL_VALUE (symbol);
-
+
if (BUFFER_OBJFWDP (valcontents))
{
int offset = XBUFFER_OBJFWD (valcontents)->offset;
and load that binding. */
else
{
- tem1 = Fcons (symbol, Fcdr (current_alist_element));
+ tem1 = Fcons (symbol, XCDR (current_alist_element));
buf->local_var_alist
= Fcons (tem1, buf->local_var_alist);
}
{
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
if (idx > 0)
{
struct buffer *b;
-
+
for (b = all_buffers; b; b = b->next)
if (!PER_BUFFER_VALUE_P (b, idx))
PER_BUFFER_VALUE (b, offset) = value;
DEFUN ("setq-default", Fsetq_default, Ssetq_default, 2, UNEVALLED, 0,
doc: /* Set the default value of variable VAR to VALUE.
VAR, the variable name, is literal (not evaluated);
-VALUE is an expression and it is evaluated.
+VALUE is an expression: it is evaluated and its value returned.
The default value of a variable is seen in buffers
that do not have their own values for the variable.
do
{
val = Feval (Fcar (Fcdr (args_left)));
- symbol = Fcar (args_left);
+ symbol = XCAR (args_left);
Fset_default (symbol, val);
- args_left = Fcdr (Fcdr (args_left));
+ args_left = Fcdr (XCDR (args_left));
}
while (!NILP (args_left));
in which case the default value is in effect.
Note that binding the variable with `let', or setting it while
a `let'-style binding made in this buffer is in effect,
-does not make the variable buffer-local.
+does not make the variable buffer-local. Return VARIABLE.
The function `default-value' gets the default value and `set-default' sets it. */)
(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))
- error ("Symbol %s may not be buffer-local", XSYMBOL (variable)->name->data);
+ error ("Symbol %s may not be buffer-local", SDATA (SYMBOL_NAME (variable)));
if (BUFFER_LOCAL_VALUEP (valcontents) || BUFFER_OBJFWDP (valcontents))
return variable;
Other buffers will continue to share a common default value.
\(The buffer-local value of VARIABLE starts out as the same value
VARIABLE previously had. If VARIABLE was void, it remains void.\)
-See also `make-variable-buffer-local'.
+See also `make-variable-buffer-local'. Return VARIABLE.
If the variable is already arranged to become local when set,
this function causes a local value to exist for this buffer,
{
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))
- error ("Symbol %s may not be buffer-local", XSYMBOL (variable)->name->data);
+ error ("Symbol %s may not be buffer-local", SDATA (SYMBOL_NAME (variable)));
if (BUFFER_LOCAL_VALUEP (valcontents) || BUFFER_OBJFWDP (valcontents))
{
DEFUN ("kill-local-variable", Fkill_local_variable, Skill_local_variable,
1, 1, "vKill Local Variable: ",
doc: /* Make VARIABLE no longer have a separate value in the current buffer.
-From now on the default value will apply in this buffer. */)
+From now on the default value will apply in this buffer. Return VARIABLE. */)
(variable)
register Lisp_Object variable;
{
register Lisp_Object tem, valcontents;
- CHECK_SYMBOL (variable, 0);
+ CHECK_SYMBOL (variable);
valcontents = SYMBOL_VALUE (variable);
doc: /* Enable VARIABLE to have frame-local bindings.
When a frame-local binding exists in the current frame,
it is in effect whenever the current buffer has no buffer-local binding.
-A frame-local binding is actual a frame parameter value;
-thus, any given frame has a local binding for VARIABLE
-if it has a value for the frame parameter named VARIABLE.
-See `modify-frame-parameters'. */)
+A frame-local binding is actually a frame parameter value;
+thus, any given frame has a local binding for VARIABLE if it has
+a value for the frame parameter named VARIABLE. Return VARIABLE.
+See `modify-frame-parameters' for how to set frame parameters. */)
(variable)
register Lisp_Object 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)
|| BUFFER_OBJFWDP (valcontents))
- error ("Symbol %s may not be frame-local", XSYMBOL (variable)->name->data);
+ error ("Symbol %s may not be frame-local", SDATA (SYMBOL_NAME (variable)));
if (BUFFER_LOCAL_VALUEP (valcontents)
|| SOME_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);
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))
{
int c, idxval_byte;
- if (idxval < 0 || idxval >= XSTRING (array)->size)
+ if (idxval < 0 || idxval >= SCHARS (array))
args_out_of_range (array, idx);
if (! STRING_MULTIBYTE (array))
- return make_number ((unsigned char) XSTRING (array)->data[idxval]);
+ return make_number ((unsigned char) SREF (array, idxval));
idxval_byte = string_char_to_byte (array, idxval);
- c = STRING_CHAR (&XSTRING (array)->data[idxval_byte],
- STRING_BYTES (XSTRING (array)) - idxval_byte);
+ c = STRING_CHAR (SDATA (array) + idxval_byte,
+ SBYTES (array) - idxval_byte);
return make_number (c);
}
else if (BOOL_VECTOR_P (array))
DEFUN ("aset", Faset, Saset, 3, 3, 0,
doc: /* Store into the element of ARRAY at index IDX the value NEWELT.
-ARRAY may be a vector, a string, a char-table or a bool-vector.
-IDX starts at 0. */)
+Return NEWELT. ARRAY may be a vector, a string, a char-table or a
+bool-vector. IDX starts at 0. */)
(array, idx, newelt)
register Lisp_Object array;
Lisp_Object idx, newelt;
{
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))
int idxval_byte, prev_bytes, new_bytes;
unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *p0 = workbuf, *p1;
- if (idxval < 0 || idxval >= XSTRING (array)->size)
+ if (idxval < 0 || idxval >= SCHARS (array))
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];
+ p1 = SDATA (array) + idxval_byte;
PARSE_MULTIBYTE_SEQ (p1, nbytes - idxval_byte, prev_bytes);
new_bytes = CHAR_STRING (XINT (newelt), p0);
if (prev_bytes != new_bytes)
{
/* We must relocate the string data. */
- int nchars = XSTRING (array)->size;
- int nbytes = STRING_BYTES (XSTRING (array));
+ int nchars = SCHARS (array);
+ int nbytes = SBYTES (array);
unsigned char *str;
str = (nbytes <= MAX_ALLOCA
? (unsigned char *) alloca (nbytes)
: (unsigned char *) xmalloc (nbytes));
- bcopy (XSTRING (array)->data, str, nbytes);
+ bcopy (SDATA (array), str, nbytes);
allocate_string_data (XSTRING (array), nchars,
nbytes + new_bytes - prev_bytes);
- bcopy (str, XSTRING (array)->data, idxval_byte);
- p1 = XSTRING (array)->data + idxval_byte;
+ bcopy (str, SDATA (array), idxval_byte);
+ p1 = SDATA (array) + idxval_byte;
bcopy (str + idxval_byte + prev_bytes, p1 + new_bytes,
nbytes - (idxval_byte + prev_bytes));
if (nbytes > MAX_ALLOCA)
}
else
{
- if (idxval < 0 || idxval >= XSTRING (array)->size)
+ if (idxval < 0 || idxval >= SCHARS (array))
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);
+ SSET (array, idxval, XINT (newelt));
else
{
/* We must relocate the string data while converting it to
multibyte. */
int idxval_byte, prev_bytes, new_bytes;
unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *p0 = workbuf, *p1;
- unsigned char *origstr = XSTRING (array)->data, *str;
+ unsigned char *origstr = SDATA (array), *str;
int nchars, nbytes;
- nchars = XSTRING (array)->size;
+ nchars = SCHARS (array);
nbytes = idxval_byte = count_size_as_multibyte (origstr, idxval);
nbytes += count_size_as_multibyte (origstr + idxval,
nchars - idxval);
str = (nbytes <= MAX_ALLOCA
? (unsigned char *) alloca (nbytes)
: (unsigned char *) xmalloc (nbytes));
- copy_text (XSTRING (array)->data, str, nchars, 0, 1);
+ copy_text (SDATA (array), str, nchars, 0, 1);
PARSE_MULTIBYTE_SEQ (str + idxval_byte, nbytes - idxval_byte,
prev_bytes);
new_bytes = CHAR_STRING (XINT (newelt), p0);
allocate_string_data (XSTRING (array), nchars,
nbytes + new_bytes - prev_bytes);
- bcopy (str, XSTRING (array)->data, idxval_byte);
- p1 = XSTRING (array)->data + idxval_byte;
+ bcopy (str, SDATA (array), idxval_byte);
+ p1 = SDATA (array) + idxval_byte;
while (new_bytes--)
*p1++ = *p0++;
bcopy (str + idxval_byte + prev_bytes, p1,
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))
{
}
\f
DEFUN ("number-to-string", Fnumber_to_string, Snumber_to_string, 1, 1, 0,
- doc: /* Convert NUMBER to a string by printing it in decimal.
+ doc: /* Return the decimal representation of NUMBER as a string.
Uses a minus sign if negative.
NUMBER may be an integer or a floating point number. */)
(number)
{
char buffer[VALBITS];
- CHECK_NUMBER_OR_FLOAT (number, 0);
+ CHECK_NUMBER_OR_FLOAT (number);
if (FLOATP (number))
{
return -1;
else
return digit;
-}
+}
DEFUN ("string-to-number", Fstring_to_number, Sstring_to_number, 1, 2, 0,
- doc: /* Convert STRING to a number by parsing it as a decimal number.
+ doc: /* Parse STRING as a decimal number and return the number.
This parses both integers and floating point numbers.
It ignores leading spaces and tabs.
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));
/* Skip any whitespace at the front of the number. Some versions of
atoi do this anyway, so we might as well make Emacs lisp consistent. */
- p = XSTRING (string)->data;
+ p = SDATA (string);
while (*p == ' ' || *p == '\t')
p++;
}
else if (*p == '+')
p++;
-
+
if (isfloat_string (p) && b == 10)
val = make_float (sign * atof (p));
else
{
/* 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 ("-", Fminus, Sminus, 0, MANY, 0,
- doc: /* Negate number or subtract numbers or markers.
+ doc: /* Negate number or subtract numbers or markers and return the result.
With one arg, negates it. With more than one arg,
subtracts all but the first from the first.
usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS) */)
}
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);
DEFUN ("lsh", Flsh, Slsh, 2, 2, 0,
doc: /* Return VALUE with its bits shifted left by COUNT.
If COUNT is negative, shifting is actually to the right.
-In this case, zeros are shifted in on the left. */)
+In this case, zeros are shifted in on the left. */)
(value, count)
register Lisp_Object value, count;
{
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;
}
XSYMBOL (Qwholenump)->function = XSYMBOL (Qnatnump)->function;
- DEFVAR_INT ("most-positive-fixnum", &most_positive_fixnum,
- doc: /* The largest value that is representable in a Lisp integer. */);
- most_positive_fixnum = MOST_POSITIVE_FIXNUM;
-
- DEFVAR_INT ("most-negative-fixnum", &most_negative_fixnum,
- doc: /* The smallest value that is representable in a Lisp integer. */);
- most_negative_fixnum = MOST_NEGATIVE_FIXNUM;
+ DEFVAR_LISP ("most-positive-fixnum", &Vmost_positive_fixnum,
+ doc: /* The largest value that is representable in a Lisp integer. */);
+ Vmost_positive_fixnum = make_number (MOST_POSITIVE_FIXNUM);
+
+ DEFVAR_LISP ("most-negative-fixnum", &Vmost_negative_fixnum,
+ doc: /* The smallest value that is representable in a Lisp integer. */);
+ Vmost_negative_fixnum = make_number (MOST_NEGATIVE_FIXNUM);
}
SIGTYPE
HCoop / bpt / emacs.git / blobdiff