procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'feature/bignum'

Browse source
This commit is contained in:
Tom Tromey 2018-08-11 13:34:17 -06:00
commit 78ec68e18f
130 changed files with 10844 additions and 4956 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
configure.ac
View file

@ -4302,6 +4302,20 @@ AC_SUBST(KRB5LIB)
AC_SUBST(DESLIB)
AC_SUBST(KRB4LIB)
GMP_LIB=
GMP_OBJ=
HAVE_GMP=no
AC_CHECK_LIB(gmp, __gmpz_init, [
AC_CHECK_HEADERS(gmp.h, [
GMP_LIB=-lgmp
HAVE_GMP=yes
AC_DEFINE(HAVE_GMP, 1, [Define to 1 if you have gmp.h and -lgmp])])])
if test $HAVE_GMP = no; then
GMP_OBJ=mini-gmp.o
fi
AC_SUBST(GMP_LIB)
AC_SUBST(GMP_OBJ)
AC_CHECK_HEADERS(valgrind/valgrind.h)
AC_CHECK_MEMBERS([struct unipair.unicode], [], [], [[#include <linux/kd.h>]])
@ -5398,7 +5412,7 @@ emacs_config_features=
for opt in XAW3D XPM JPEG TIFF GIF PNG RSVG CAIRO IMAGEMAGICK SOUND GPM DBUS \
GCONF GSETTINGS NOTIFY ACL LIBSELINUX GNUTLS LIBXML2 FREETYPE M17N_FLT \
LIBOTF XFT ZLIB TOOLKIT_SCROLL_BARS X_TOOLKIT OLDXMENU X11 NS MODULES \
THREADS XWIDGETS LIBSYSTEMD JSON CANNOT_DUMP LCMS2; do
THREADS XWIDGETS LIBSYSTEMD JSON CANNOT_DUMP LCMS2 GMP; do
case $opt in
CANNOT_DUMP) eval val=\${$opt} ;;
@ -5450,6 +5464,7 @@ AS_ECHO([" Does Emacs use -lXaw3d? ${HAVE_XAW3D
Does Emacs use -lxft? ${HAVE_XFT}
Does Emacs use -lsystemd? ${HAVE_LIBSYSTEMD}
Does Emacs use -ljansson? ${HAVE_JSON}
Does Emacs use -lgmp? ${HAVE_GMP}
Does Emacs directly use zlib? ${HAVE_ZLIB}
Does Emacs have dynamic modules support? ${HAVE_MODULES}
Does Emacs use toolkit scroll bars? ${USE_TOOLKIT_SCROLL_BARS}

132
doc/lispref/numbers.texi
View file

@ -14,9 +14,9 @@
fractional parts, such as @minus{}4.5, 0.0, and 2.71828. They can
also be expressed in exponential notation: @samp{1.5e2} is the same as
@samp{150.0}; here, @samp{e2} stands for ten to the second power, and
that is multiplied by 1.5. Integer computations are exact, though
they may overflow. Floating-point computations often involve rounding
errors, as the numbers have a fixed amount of precision.
that is multiplied by 1.5. Integer computations are exact.
Floating-point computations often involve rounding errors, as the
numbers have a fixed amount of precision.
@menu
* Integer Basics:: Representation and range of integers.
@ -34,7 +34,15 @@ errors, as the numbers have a fixed amount of precision.
@node Integer Basics
@section Integer Basics
The range of values for an integer depends on the machine. The
Integers in Emacs Lisp can have arbitrary precision.
Under the hood, though, there are two kinds of integers: smaller
ones, called @dfn{fixnums}, and larger ones, called @dfn{bignums}
Some functions in Emacs only accept fixnums. Also, while fixnums can
always be compared for equality with @code{eq}, bignums require the
use of @code{eql}.
The range of values for a fixnum depends on the machine. The
minimum range is @minus{}536,870,912 to 536,870,911 (30 bits; i.e.,
@ifnottex
@minus{}2**29
@ -49,9 +57,7 @@ to
@tex
@math{2^{29}-1}),
@end tex
but many machines provide a wider range. Many examples in this
chapter assume the minimum integer width of 30 bits.
@cindex overflow
but many machines provide a wider range.
The Lisp reader reads an integer as a nonempty sequence
of decimal digits with optional initial sign and optional
@ -91,14 +97,8 @@ For example:
#24r1k @result{} 44
@end example
If an integer is outside the Emacs range, the Lisp reader ordinarily
signals an overflow. However, if a too-large plain integer ends in a
period, the Lisp reader treats it as a floating-point number instead.
This lets an Emacs Lisp program specify a large integer that is
quietly approximated by a floating-point number on machines with
limited word width. For example, @samp{536870912.} is a
floating-point number if Emacs integers are only 30 bits wide and is
an integer otherwise.
An integer is read as a fixnum if it is in the correct range.
Otherwise, it will be read as a bignum.
To understand how various functions work on integers, especially the
bitwise operators (@pxref{Bitwise Operations}), it is often helpful to
@ -141,16 +141,6 @@ In binary, the decimal integer 4 is 100. Consequently,
0111...111111 (30 bits total)
@end example
Since the arithmetic functions do not check whether integers go
outside their range, when you add 1 to 536,870,911, the value is the
negative integer @minus{}536,870,912:
@example
(+ 1 536870911)
@result{} -536870912
@result{} 1000...000000 (30 bits total)
@end example
Many of the functions described in this chapter accept markers for
arguments in place of numbers. (@xref{Markers}.) Since the actual
arguments to such functions may be either numbers or markers, we often
@ -160,8 +150,8 @@ value is a marker, its position value is used and its buffer is ignored.
@cindex largest Lisp integer
@cindex maximum Lisp integer
@defvar most-positive-fixnum
The value of this variable is the largest integer that Emacs Lisp can
handle. Typical values are
The value of this variable is the largest ``small'' integer that Emacs
Lisp can handle. Typical values are
@ifnottex
2**29 @minus{} 1
@end ifnottex
@ -181,8 +171,8 @@ on 64-bit platforms.
@cindex smallest Lisp integer
@cindex minimum Lisp integer
@defvar most-negative-fixnum
The value of this variable is the smallest integer that Emacs Lisp can
handle. It is negative. Typical values are
The value of this variable is the smallest small integer that Emacs
Lisp can handle. It is negative. Typical values are
@ifnottex
@minus{}2**29
@end ifnottex
@ -327,6 +317,20 @@ use otherwise), but the @code{zerop} predicate requires a number as
its argument. See also @code{integer-or-marker-p} and
@code{number-or-marker-p}, in @ref{Predicates on Markers}.
@defun bignump object
This predicate tests whether its argument is a large integer, and
returns @code{t} if so, @code{nil} otherwise. Large integers cannot
be compared with @code{eq}, only with @code{=} or @code{eql}. Also,
large integers are only available if Emacs was compiled with the GMP
library.
@end defun
@defun fixnump object
This predicate tests whether its argument is a small integer, and
returns @code{t} if so, @code{nil} otherwise. Small integers can be
compared with @code{eq}.
@end defun
@defun floatp object
This predicate tests whether its argument is floating point
and returns @code{t} if so, @code{nil} otherwise.
@ -367,17 +371,17 @@ if so, @code{nil} otherwise. The argument must be a number.
To test numbers for numerical equality, you should normally use
@code{=} instead of non-numeric comparison predicates like @code{eq},
@code{eql} and @code{equal}. Distinct floating-point objects can be
numerically equal. If you use @code{eq} to compare them, you test
whether they are the same @emph{object}; if you use @code{eql} or
@code{equal}, you test whether their values are
@code{eql} and @code{equal}. Distinct floating-point and large
integer objects can be numerically equal. If you use @code{eq} to
compare them, you test whether they are the same @emph{object}; if you
use @code{eql} or @code{equal}, you test whether their values are
@emph{indistinguishable}. In contrast, @code{=} uses numeric
comparison, and sometimes returns @code{t} when a non-numeric
comparison would return @code{nil} and vice versa. @xref{Float
Basics}.
In Emacs Lisp, each integer is a unique Lisp object.
Therefore, @code{eq} is equivalent to @code{=} where integers are
In Emacs Lisp, each small integer is a unique Lisp object.
Therefore, @code{eq} is equivalent to @code{=} where small integers are
concerned. It is sometimes convenient to use @code{eq} for comparing
an unknown value with an integer, because @code{eq} does not report an
error if the unknown value is not a number---it accepts arguments of
@ -405,15 +409,6 @@ Here's a function to do this:
fuzz-factor)))
@end example
@cindex CL note---integers vrs @code{eq}
@quotation
@b{Common Lisp note:} Comparing numbers in Common Lisp always requires
@code{=} because Common Lisp implements multi-word integers, and two
distinct integer objects can have the same numeric value. Emacs Lisp
can have just one integer object for any given value because it has a
limited range of integers.
@end quotation
@defun = number-or-marker &rest number-or-markers
This function tests whether all its arguments are numerically equal,
and returns @code{t} if so, @code{nil} otherwise.
@ -423,7 +418,8 @@ and returns @code{t} if so, @code{nil} otherwise.
This function acts like @code{eq} except when both arguments are
numbers. It compares numbers by type and numeric value, so that
@code{(eql 1.0 1)} returns @code{nil}, but @code{(eql 1.0 1.0)} and
@code{(eql 1 1)} both return @code{t}.
@code{(eql 1 1)} both return @code{t}. This can be used to compare
large integers as well as small ones.
@end defun
@defun /= number-or-marker1 number-or-marker2
@ -583,10 +579,6 @@ Except for @code{%}, each of these functions accepts both integer and
floating-point arguments, and returns a floating-point number if any
argument is floating point.
Emacs Lisp arithmetic functions do not check for integer overflow.
Thus @code{(1+ 536870911)} may evaluate to
@minus{}536870912, depending on your hardware.
@defun 1+ number-or-marker
This function returns @var{number-or-marker} plus 1.
For example,
@ -912,35 +904,6 @@ On the other hand, shifting one place to the right looks like this:
@noindent
As the example illustrates, shifting one place to the right divides the
value of a positive integer by two, rounding downward.
The function @code{lsh}, like all Emacs Lisp arithmetic functions, does
not check for overflow, so shifting left can discard significant bits
and change the sign of the number. For example, left shifting
536,870,911 produces @minus{}2 in the 30-bit implementation:
@example
(lsh 536870911 1) ; @r{left shift}
@result{} -2
@end example
In binary, the argument looks like this:
@example
@group
;; @r{Decimal 536,870,911}
0111...111111 (30 bits total)
@end group
@end example
@noindent
which becomes the following when left shifted:
@example
@group
;; @r{Decimal @minus{}2}
1111...111110 (30 bits total)
@end group
@end example
@end defun
@defun ash integer1 count
@ -967,19 +930,6 @@ looks like this:
@end group
@end example
In contrast, shifting the pattern of bits one place to the right with
@code{lsh} looks like this:
@example
@group
(lsh -6 -1) @result{} 536870909
;; @r{Decimal @minus{}6 becomes decimal 536,870,909.}
1111...111010 (30 bits total)
@result{}
0111...111101 (30 bits total)
@end group
@end example
Here are other examples:
@c !!! Check if lined up in smallbook format! XDVI shows problem

26
doc/lispref/objects.texi
View file

@ -166,7 +166,10 @@ latter are unique to Emacs Lisp.
@node Integer Type
@subsection Integer Type
The range of values for an integer depends on the machine. The
Under the hood, there are two kinds of integers---small integers,
called @dfn{fixnums}, and large integers, called @dfn{bignums}.
The range of values for a fixnum depends on the machine. The
minimum range is @minus{}536,870,912 to 536,870,911 (30 bits; i.e.,
@ifnottex
@minus{}2**29
@ -182,8 +185,14 @@ to
@math{2^{29}-1})
@end tex
but many machines provide a wider range.
Emacs Lisp arithmetic functions do not check for integer overflow. Thus
@code{(1+ 536870911)} is @minus{}536,870,912 if Emacs integers are 30 bits.
Bignums can have arbitrary precision. Operations that overflow a
fixnum will return a bignum instead.
Fixnums can be compared with @code{eq}, but bignums require
@code{eql} or @code{=}. The @code{fixnump} predicate can be used to
detect such small integers, and @code{bignump} can be used to detect
large integers.
The read syntax for integers is a sequence of (base ten) digits with an
optional sign at the beginning and an optional period at the end. The
@ -200,11 +209,6 @@ leading @samp{+} or a final @samp{.}.
@end example
@noindent
As a special exception, if a sequence of digits specifies an integer
too large or too small to be a valid integer object, the Lisp reader
reads it as a floating-point number (@pxref{Floating-Point Type}).
For instance, if Emacs integers are 30 bits, @code{536870912} is read
as the floating-point number @code{536870912.0}.
@xref{Numbers}, for more information.
@ -1895,6 +1899,9 @@ with references to further information.
@item arrayp
@xref{Array Functions, arrayp}.
@item bignump
@xref{Predicates on Numbers, floatp}.
@item bool-vector-p
@xref{Bool-Vectors, bool-vector-p}.
@ -1928,6 +1935,9 @@ with references to further information.
@item custom-variable-p
@xref{Variable Definitions, custom-variable-p}.
@item fixnump
@xref{Predicates on Numbers, floatp}.
@item floatp
@xref{Predicates on Numbers, floatp}.

17
etc/NEWS
View file

@ -24,6 +24,9 @@ When you add a new item, use the appropriate mark if you are sure it applies,
* Installation Changes in Emacs 27.1
** configure now checks for the GMP library. If not found, the
included "mini-gmp" library is used instead.
** The new configure option '--with-json' adds support for JSON using
the Jansson library. It is on by default; use 'configure
--with-json=no' to build without Jansson support. The new JSON
@ -766,15 +769,6 @@ as new-style, bind the new variable 'force-new-style-backquotes' to t.
integer, Emacs now signals an error if the number is too large for the
implementation to format.
+++
** The Lisp reader now signals an overflow for plain decimal integers
that do not end in '.' and are outside Emacs range. Formerly the Lisp
reader silently converted them to floating-point numbers, and signaled
overflow only for integers with a radix that are outside machine range.
To get the old behavior, set the new, experimental variable
read-integer-overflow-as-float to t and please email
30408@debbugs.gnu.org if you need that.
---
** Some functions and variables obsolete since Emacs 22 have been removed:
archive-mouse-extract, assoc-ignore-case, assoc-ignore-representation,
@ -832,6 +826,11 @@ Given a proper list as argument, this predicate returns its length;
otherwise, it returns nil. 'format-proper-list-p' is now an obsolete
alias for the new function.
+++
** Emacs Lisp integers can be of arbitrary precision. The new
predicates 'bignump' and 'fixnump' can be used to distinguish between
the types of integers.
** define-minor-mode automatically documents the meaning of ARG
+++

4
lisp/emacs-lisp/byte-opt.el
View file

@ -1195,14 +1195,14 @@
window-width zerop))
(side-effect-and-error-free-fns
'(arrayp atom
bobp bolp bool-vector-p
bignump bobp bolp bool-vector-p
buffer-end buffer-list buffer-size buffer-string bufferp
car-safe case-table-p cdr-safe char-or-string-p characterp
charsetp commandp cons consp
current-buffer current-global-map current-indentation
current-local-map current-minor-mode-maps current-time
eobp eolp eq equal eventp
floatp following-char framep
fixnump floatp following-char framep
get-largest-window get-lru-window
hash-table-p
identity ignore integerp integer-or-marker-p interactive-p

18
lisp/international/ccl.el
View file

@ -184,11 +184,19 @@
(defvar ccl-current-ic 0
"The current index for `ccl-program-vector'.")
;; The CCL compiled codewords are 28bits, but the CCL implementation
;; assumes that the codewords are sign-extended, so that data constants in
;; the upper part of the codeword are signed. This function truncates a
;; codeword to 28bits, and then sign extends the result to a fixnum.
(defun ccl-fixnum (code)
"Convert a CCL code word to a fixnum value."
(- (logxor (logand code #x0fffffff) #x08000000) #x08000000))
(defun ccl-embed-data (data &optional ic)
"Embed integer DATA in `ccl-program-vector' at `ccl-current-ic' and
increment it. If IC is specified, embed DATA at IC."
(if ic
(aset ccl-program-vector ic data)
(aset ccl-program-vector ic (ccl-fixnum data))
(let ((len (length ccl-program-vector)))
(if (>= ccl-current-ic len)
(let ((new (make-vector (* len 2) nil)))
@ -196,7 +204,7 @@ increment it. If IC is specified, embed DATA at IC."
(setq len (1- len))
(aset new len (aref ccl-program-vector len)))
(setq ccl-program-vector new))))
(aset ccl-program-vector ccl-current-ic data)
(aset ccl-program-vector ccl-current-ic (ccl-fixnum data))
(setq ccl-current-ic (1+ ccl-current-ic))))
(defun ccl-embed-symbol (symbol prop)
@ -230,7 +238,8 @@ proper index number for SYMBOL. PROP should be
`ccl-program-vector' at IC without altering the other bit field."
(let ((relative (- ccl-current-ic (1+ ic))))
(aset ccl-program-vector ic
(logior (aref ccl-program-vector ic) (ash relative 8)))))
(logior (aref ccl-program-vector ic)
(ccl-fixnum (ash relative 8))))))
(defun ccl-embed-code (op reg data &optional reg2)
"Embed CCL code for the operation OP and arguments REG and DATA in
@ -986,7 +995,8 @@ is a list of CCL-BLOCKs."
(defun ccl-get-next-code ()
"Return a CCL code in `ccl-code' at `ccl-current-ic'."
(prog1
(aref ccl-code ccl-current-ic)
(let ((code (aref ccl-code ccl-current-ic)))
(if (numberp code) (ccl-fixnum code) code))
(setq ccl-current-ic (1+ ccl-current-ic))))
(defun ccl-dump-1 ()

7
src/Makefile.in
View file

@ -322,6 +322,9 @@ INTERVALS_H = dispextern.h intervals.h composite.h
GETLOADAVG_LIBS = @GETLOADAVG_LIBS@
GMP_LIB = @GMP_LIB@
GMP_OBJ = @GMP_OBJ@
RUN_TEMACS = ./temacs
# Whether builds should contain details. '--no-build-details' or empty.
@ -403,7 +406,7 @@ base_obj = dispnew.o frame.o scroll.o xdisp.o menu.o $(XMENU_OBJ) window.o \
thread.o systhread.o \
$(if $(HYBRID_MALLOC),sheap.o) \
$(MSDOS_OBJ) $(MSDOS_X_OBJ) $(NS_OBJ) $(CYGWIN_OBJ) $(FONT_OBJ) \
$(W32_OBJ) $(WINDOW_SYSTEM_OBJ) $(XGSELOBJ) $(JSON_OBJ)
$(W32_OBJ) $(WINDOW_SYSTEM_OBJ) $(XGSELOBJ) $(JSON_OBJ) $(GMP_OBJ)
obj = $(base_obj) $(NS_OBJC_OBJ)
## Object files used on some machine or other.
@ -501,7 +504,7 @@ LIBES = $(LIBS) $(W32_LIBS) $(LIBS_GNUSTEP) $(LIBX_BASE) $(LIBIMAGE) \
$(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \
$(LIBGNUTLS_LIBS) $(LIB_PTHREAD) $(GETADDRINFO_A_LIBS) $(LCMS2_LIBS) \
$(NOTIFY_LIBS) $(LIB_MATH) $(LIBZ) $(LIBMODULES) $(LIBSYSTEMD_LIBS) \
$(JSON_LIBS)
$(JSON_LIBS) $(GMP_LIB)
## FORCE it so that admin/unidata can decide whether these files
## are up-to-date. Although since charprop depends on bootstrap-emacs,

206
src/alloc.c
View file

@ -2321,13 +2321,13 @@ a multibyte string even if INIT is an ASCII character. */)
int c;
EMACS_INT nbytes;
CHECK_NATNUM (length);
CHECK_FIXNAT (length);
CHECK_CHARACTER (init);
c = XFASTINT (init);
c = XFIXNAT (init);
if (ASCII_CHAR_P (c) && NILP (multibyte))
{
nbytes = XINT (length);
nbytes = XFIXNUM (length);
val = make_uninit_string (nbytes);
if (nbytes)
{
@ -2339,7 +2339,7 @@ a multibyte string even if INIT is an ASCII character. */)
{
unsigned char str[MAX_MULTIBYTE_LENGTH];
ptrdiff_t len = CHAR_STRING (c, str);
EMACS_INT string_len = XINT (length);
EMACS_INT string_len = XFIXNUM (length);
unsigned char *p, *beg, *end;
if (INT_MULTIPLY_WRAPV (len, string_len, &nbytes))
@ -2415,8 +2415,8 @@ LENGTH must be a number. INIT matters only in whether it is t or nil. */)
{
Lisp_Object val;
CHECK_NATNUM (length);
val = make_uninit_bool_vector (XFASTINT (length));
CHECK_FIXNAT (length);
val = make_uninit_bool_vector (XFIXNAT (length));
return bool_vector_fill (val, init);
}
@ -2894,9 +2894,9 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
(Lisp_Object length, Lisp_Object init)
{
Lisp_Object val = Qnil;
CHECK_NATNUM (length);
CHECK_FIXNAT (length);
for (EMACS_INT size = XFASTINT (length); 0 < size; size--)
for (EMACS_INT size = XFIXNAT (length); 0 < size; size--)
{
val = Fcons (init, val);
rarely_quit (size);
@ -3448,8 +3448,8 @@ symbol or a type descriptor. SLOTS is the number of non-type slots,
each initialized to INIT. */)
(Lisp_Object type, Lisp_Object slots, Lisp_Object init)
{
CHECK_NATNUM (slots);
EMACS_INT size = XFASTINT (slots) + 1;
CHECK_FIXNAT (slots);
EMACS_INT size = XFIXNAT (slots) + 1;
struct Lisp_Vector *p = allocate_record (size);
p->contents[0] = type;
for (ptrdiff_t i = 1; i < size; i++)
@ -3477,9 +3477,9 @@ DEFUN ("make-vector", Fmake_vector, Smake_vector, 2, 2, 0,
See also the function `vector'. */)
(Lisp_Object length, Lisp_Object init)
{
CHECK_NATNUM (length);
struct Lisp_Vector *p = allocate_vector (XFASTINT (length));
for (ptrdiff_t i = 0; i < XFASTINT (length); i++)
CHECK_FIXNAT (length);
struct Lisp_Vector *p = allocate_vector (XFIXNAT (length));
for (ptrdiff_t i = 0; i < XFIXNAT (length); i++)
p->contents[i] = init;
return make_lisp_ptr (p, Lisp_Vectorlike);
}
@ -3788,6 +3788,109 @@ build_marker (struct buffer *buf, ptrdiff_t charpos, ptrdiff_t bytepos)
return obj;
}
Lisp_Object
make_bignum_str (const char *num, int base)
{
Lisp_Object obj;
struct Lisp_Bignum *b;
int check;
obj = allocate_misc (Lisp_Misc_Bignum);
b = XBIGNUM (obj);
mpz_init (b->value);
check = mpz_set_str (b->value, num, base);
eassert (check == 0);
return obj;
}
/* Given an mpz_t, make a number. This may return a bignum or a
fixnum depending on VALUE. */
Lisp_Object
make_number (mpz_t value)
{
Lisp_Object obj;
struct Lisp_Bignum *b;
if (mpz_fits_slong_p (value))
{
long l = mpz_get_si (value);
if (!FIXNUM_OVERFLOW_P (l))
{
XSETINT (obj, l);
return obj;
}
}
/* Check if fixnum can be larger than long. */
if (sizeof (EMACS_INT) > sizeof (long))
{
size_t bits = mpz_sizeinbase (value, 2);
int sign = mpz_sgn (value);
if (bits < FIXNUM_BITS + (sign < 0))
{
EMACS_INT v = 0;
size_t limbs = mpz_size (value);
mp_size_t i;
for (i = 0; i < limbs; i++)
{
mp_limb_t limb = mpz_getlimbn (value, i);
v |= (EMACS_INT) ((EMACS_UINT) limb << (i * mp_bits_per_limb));
}
if (sign < 0)
v = -v;
if (!FIXNUM_OVERFLOW_P (v))
{
XSETINT (obj, v);
return obj;
}
}
}
obj = allocate_misc (Lisp_Misc_Bignum);
b = XBIGNUM (obj);
/* We could mpz_init + mpz_swap here, to avoid a copy, but the
resulting API seemed possibly confusing. */
mpz_init_set (b->value, value);
return obj;
}
void
mpz_set_intmax_slow (mpz_t result, intmax_t v)
{
/* If long is larger then a faster path is taken. */
eassert (sizeof (intmax_t) > sizeof (long));
bool negate = false;
if (v < 0)
{
v = -v;
negate = true;
}
mpz_set_uintmax_slow (result, (uintmax_t) v);
if (negate)
mpz_neg (result, result);
}
void
mpz_set_uintmax_slow (mpz_t result, uintmax_t v)
{
/* If long is larger then a faster path is taken. */
eassert (sizeof (uintmax_t) > sizeof (unsigned long));
/* COUNT = 1 means just a single word of the given size. ORDER = -1
is arbitrary since there's only a single word. ENDIAN = 0 means
use the native endian-ness. NAILS = 0 means use the whole
word. */
mpz_import (result, 1, -1, sizeof (uintmax_t), 0, 0, &v);
}
/* Return a newly created vector or string with specified arguments as
elements. If all the arguments are characters that can fit
@ -3804,8 +3907,8 @@ make_event_array (ptrdiff_t nargs, Lisp_Object *args)
/* The things that fit in a string
are characters that are in 0...127,
after discarding the meta bit and all the bits above it. */
if (!INTEGERP (args[i])
|| (XINT (args[i]) & ~(-CHAR_META)) >= 0200)
if (!FIXNUMP (args[i])
|| (XFIXNUM (args[i]) & ~(-CHAR_META)) >= 0200)
return Fvector (nargs, args);
/* Since the loop exited, we know that all the things in it are
@ -3813,12 +3916,12 @@ make_event_array (ptrdiff_t nargs, Lisp_Object *args)
{
Lisp_Object result;
result = Fmake_string (make_number (nargs), make_number (0), Qnil);
result = Fmake_string (make_fixnum (nargs), make_fixnum (0), Qnil);
for (i = 0; i < nargs; i++)
{
SSET (result, i, XINT (args[i]));
SSET (result, i, XFIXNUM (args[i]));
/* Move the meta bit to the right place for a string char. */
if (XINT (args[i]) & CHAR_META)
if (XFIXNUM (args[i]) & CHAR_META)
SSET (result, i, SREF (result, i) | 0x80);
}
@ -4700,7 +4803,7 @@ mark_maybe_object (Lisp_Object obj)
VALGRIND_MAKE_MEM_DEFINED (&obj, sizeof (obj));
#endif
if (INTEGERP (obj))
if (FIXNUMP (obj))
return;
void *po = XPNTR (obj);
@ -5180,7 +5283,7 @@ valid_pointer_p (void *p)
int
valid_lisp_object_p (Lisp_Object obj)
{
if (INTEGERP (obj))
if (FIXNUMP (obj))
return 1;
void *p = XPNTR (obj);
@ -5441,6 +5544,34 @@ make_pure_float (double num)
return new;
}
/* Value is a bignum object with value VALUE allocated from pure
space. */
static Lisp_Object
make_pure_bignum (struct Lisp_Bignum *value)
{
Lisp_Object new;
size_t i, nlimbs = mpz_size (value->value);
size_t nbytes = nlimbs * sizeof (mp_limb_t);
mp_limb_t *pure_limbs;
mp_size_t new_size;
struct Lisp_Bignum *b = pure_alloc (sizeof (struct Lisp_Bignum), Lisp_Misc);
b->type = Lisp_Misc_Bignum;
pure_limbs = pure_alloc (nbytes, -1);
for (i = 0; i < nlimbs; ++i)
pure_limbs[i] = mpz_getlimbn (value->value, i);
new_size = nlimbs;
if (mpz_sgn (value->value) < 0)
new_size = -new_size;
mpz_roinit_n (b->value, pure_limbs, new_size);
XSETMISC (new, b);
return new;
}
/* Return a vector with room for LEN Lisp_Objects allocated from
pure space. */
@ -5513,7 +5644,7 @@ static struct pinned_object
static Lisp_Object
purecopy (Lisp_Object obj)
{
if (INTEGERP (obj)
if (FIXNUMP (obj)
|| (! SYMBOLP (obj) && PURE_P (XPNTR (obj)))
|| SUBRP (obj))
return obj; /* Already pure. */
@ -5582,6 +5713,8 @@ purecopy (Lisp_Object obj)
/* Don't hash-cons it. */
return obj;
}
else if (BIGNUMP (obj))
obj = make_pure_bignum (XBIGNUM (obj));
else
{
AUTO_STRING (fmt, "Don't know how to purify: %S");
@ -5623,7 +5756,7 @@ inhibit_garbage_collection (void)
{
ptrdiff_t count = SPECPDL_INDEX ();
specbind (Qgc_cons_threshold, make_number (MOST_POSITIVE_FIXNUM));
specbind (Qgc_cons_threshold, make_fixnum (MOST_POSITIVE_FIXNUM));
return count;
}
@ -5633,7 +5766,7 @@ inhibit_garbage_collection (void)
static Lisp_Object
bounded_number (EMACS_INT number)
{
return make_number (min (MOST_POSITIVE_FIXNUM, number));
return make_fixnum (min (MOST_POSITIVE_FIXNUM, number));
}
/* Calculate total bytes of live objects. */
@ -5986,37 +6119,37 @@ garbage_collect_1 (void *end)
unbind_to (count, Qnil);
Lisp_Object total[] = {
list4 (Qconses, make_number (sizeof (struct Lisp_Cons)),
list4 (Qconses, make_fixnum (sizeof (struct Lisp_Cons)),
bounded_number (total_conses),
bounded_number (total_free_conses)),
list4 (Qsymbols, make_number (sizeof (struct Lisp_Symbol)),
list4 (Qsymbols, make_fixnum (sizeof (struct Lisp_Symbol)),
bounded_number (total_symbols),
bounded_number (total_free_symbols)),
list4 (Qmiscs, make_number (sizeof (union Lisp_Misc)),
list4 (Qmiscs, make_fixnum (sizeof (union Lisp_Misc)),
bounded_number (total_markers),
bounded_number (total_free_markers)),
list4 (Qstrings, make_number (sizeof (struct Lisp_String)),
list4 (Qstrings, make_fixnum (sizeof (struct Lisp_String)),
bounded_number (total_strings),
bounded_number (total_free_strings)),
list3 (Qstring_bytes, make_number (1),
list3 (Qstring_bytes, make_fixnum (1),
bounded_number (total_string_bytes)),
list3 (Qvectors,
make_number (header_size + sizeof (Lisp_Object)),
make_fixnum (header_size + sizeof (Lisp_Object)),
bounded_number (total_vectors)),
list4 (Qvector_slots, make_number (word_size),
list4 (Qvector_slots, make_fixnum (word_size),
bounded_number (total_vector_slots),
bounded_number (total_free_vector_slots)),
list4 (Qfloats, make_number (sizeof (struct Lisp_Float)),
list4 (Qfloats, make_fixnum (sizeof (struct Lisp_Float)),
bounded_number (total_floats),
bounded_number (total_free_floats)),
list4 (Qintervals, make_number (sizeof (struct interval)),
list4 (Qintervals, make_fixnum (sizeof (struct interval)),
bounded_number (total_intervals),
bounded_number (total_free_intervals)),
list3 (Qbuffers, make_number (sizeof (struct buffer)),
list3 (Qbuffers, make_fixnum (sizeof (struct buffer)),
bounded_number (total_buffers)),
#ifdef DOUG_LEA_MALLOC
list4 (Qheap, make_number (1024),
list4 (Qheap, make_fixnum (1024),
bounded_number ((mallinfo ().uordblks + 1023) >> 10),
bounded_number ((mallinfo ().fordblks + 1023) >> 10)),
#endif
@ -6151,7 +6284,7 @@ mark_char_table (struct Lisp_Vector *ptr, enum pvec_type pvectype)
{
Lisp_Object val = ptr->contents[i];
if (INTEGERP (val) || (SYMBOLP (val) && XSYMBOL (val)->u.s.gcmarkbit))
if (FIXNUMP (val) || (SYMBOLP (val) && XSYMBOL (val)->u.s.gcmarkbit))
continue;
if (SUB_CHAR_TABLE_P (val))
{
@ -6563,6 +6696,7 @@ mark_object (Lisp_Object arg)
break;
case Lisp_Misc_Ptr:
case Lisp_Misc_Bignum:
XMISCANY (obj)->gcmarkbit = true;
break;
@ -6982,6 +7116,8 @@ sweep_misc (void)
uptr->finalizer (uptr->p);
}
#endif
else if (mblk->markers[i].m.u_any.type == Lisp_Misc_Bignum)
mpz_clear (mblk->markers[i].m.u_bignum.value);
/* Set the type of the freed object to Lisp_Misc_Free.
We could leave the type alone, since nobody checks it,
but this might catch bugs faster. */

12
src/bidi.c
View file

@ -280,7 +280,7 @@ bidi_get_type (int ch, bidi_dir_t override)
if (ch < 0 || ch > MAX_CHAR)
emacs_abort ();
default_type = (bidi_type_t) XINT (CHAR_TABLE_REF (bidi_type_table, ch));
default_type = (bidi_type_t) XFIXNUM (CHAR_TABLE_REF (bidi_type_table, ch));
/* Every valid character code, even those that are unassigned by the
UCD, have some bidi-class property, according to
DerivedBidiClass.txt file. Therefore, if we ever get UNKNOWN_BT
@ -379,15 +379,15 @@ bidi_mirror_char (int c)
emacs_abort ();
val = CHAR_TABLE_REF (bidi_mirror_table, c);
if (INTEGERP (val))
if (FIXNUMP (val))
{
int v;
/* When debugging, check before assigning to V, so that the check
isn't broken by undefined behavior due to int overflow. */
eassert (CHAR_VALID_P (XINT (val)));
eassert (CHAR_VALID_P (XFIXNUM (val)));
v = XINT (val);
v = XFIXNUM (val);
/* Minimal test we must do in optimized builds, to prevent weird
crashes further down the road. */
@ -409,7 +409,7 @@ bidi_paired_bracket_type (int c)
if (c < 0 || c > MAX_CHAR)
emacs_abort ();
return (bidi_bracket_type_t) XINT (CHAR_TABLE_REF (bidi_brackets_table, c));
return (bidi_bracket_type_t) XFIXNUM (CHAR_TABLE_REF (bidi_brackets_table, c));
}
/* Determine the start-of-sequence (sos) directional type given the two
@ -1805,7 +1805,7 @@ bidi_explicit_dir_char (int ch)
eassert (ch == BIDI_EOB);
return false;
}
ch_type = (bidi_type_t) XINT (CHAR_TABLE_REF (bidi_type_table, ch));
ch_type = (bidi_type_t) XFIXNUM (CHAR_TABLE_REF (bidi_type_table, ch));
return (ch_type == LRE || ch_type == LRO
|| ch_type == RLE || ch_type == RLO
|| ch_type == PDF);

204
src/buffer.c
View file

@ -849,7 +849,7 @@ CLONE nil means the indirect buffer's state is reset to default values. */)
clone_per_buffer_values (b->base_buffer, b);
bset_filename (b, Qnil);
bset_file_truename (b, Qnil);
bset_display_count (b, make_number (0));
bset_display_count (b, make_fixnum (0));
bset_backed_up (b, Qnil);
bset_auto_save_file_name (b, Qnil);
set_buffer_internal_1 (b);
@ -939,7 +939,7 @@ reset_buffer (register struct buffer *b)
bset_file_format (b, Qnil);
bset_auto_save_file_format (b, Qt);
bset_last_selected_window (b, Qnil);
bset_display_count (b, make_number (0));
bset_display_count (b, make_fixnum (0));
bset_display_time (b, Qnil);
bset_enable_multibyte_characters
(b, BVAR (&buffer_defaults, enable_multibyte_characters));
@ -1102,8 +1102,8 @@ is first appended to NAME, to speed up finding a non-existent buffer. */)
{
char number[sizeof "-999999"];
/* Use XINT instead of XFASTINT to work around GCC bug 80776. */
int i = XINT (Frandom (make_number (1000000)));
/* Use XFIXNUM instead of XFIXNAT to work around GCC bug 80776. */
int i = XFIXNUM (Frandom (make_fixnum (1000000)));
eassume (0 <= i && i < 1000000);
AUTO_STRING_WITH_LEN (lnumber, number, sprintf (number, "-%d", i));
@ -1421,7 +1421,7 @@ text in that buffer is changed. It wraps around occasionally.
No argument or nil as argument means use current buffer as BUFFER. */)
(register Lisp_Object buffer)
{
return make_number (BUF_MODIFF (decode_buffer (buffer)));
return make_fixnum (BUF_MODIFF (decode_buffer (buffer)));
}
DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick,
@ -1436,7 +1436,7 @@ between these calls. No argument or nil as argument means use current
buffer as BUFFER. */)
(register Lisp_Object buffer)
{
return make_number (BUF_CHARS_MODIFF (decode_buffer (buffer)));
return make_fixnum (BUF_CHARS_MODIFF (decode_buffer (buffer)));
}
DEFUN ("rename-buffer", Frename_buffer, Srename_buffer, 1, 2,
@ -2203,7 +2203,7 @@ If the text under POSITION (which defaults to point) has the
if (NILP (position))
XSETFASTINT (position, PT);
else
CHECK_NUMBER (position);
CHECK_FIXNUM (position);
if (!NILP (BVAR (current_buffer, read_only))
&& NILP (Vinhibit_read_only)
@ -2233,16 +2233,16 @@ so the buffer is truly empty after this. */)
void
validate_region (register Lisp_Object *b, register Lisp_Object *e)
{
CHECK_NUMBER_COERCE_MARKER (*b);
CHECK_NUMBER_COERCE_MARKER (*e);
CHECK_FIXNUM_COERCE_MARKER (*b);
CHECK_FIXNUM_COERCE_MARKER (*e);
if (XINT (*b) > XINT (*e))
if (XFIXNUM (*b) > XFIXNUM (*e))
{
Lisp_Object tem;
tem = *b; *b = *e; *e = tem;
}
if (! (BEGV <= XINT (*b) && XINT (*e) <= ZV))
if (! (BEGV <= XFIXNUM (*b) && XFIXNUM (*e) <= ZV))
args_out_of_range_3 (Fcurrent_buffer (), *b, *e);
}
@ -2409,7 +2409,7 @@ results, see Info node `(elisp)Swapping Text'. */)
&& (EQ (XWINDOW (w)->contents, buf1)
|| EQ (XWINDOW (w)->contents, buf2)))
Fset_marker (XWINDOW (w)->pointm,
make_number
make_fixnum
(BUF_BEGV (XBUFFER (XWINDOW (w)->contents))),
XWINDOW (w)->contents);
/* Blindly copied from pointm part. */
@ -2417,14 +2417,14 @@ results, see Info node `(elisp)Swapping Text'. */)
&& (EQ (XWINDOW (w)->contents, buf1)
|| EQ (XWINDOW (w)->contents, buf2)))
Fset_marker (XWINDOW (w)->old_pointm,
make_number
make_fixnum
(BUF_BEGV (XBUFFER (XWINDOW (w)->contents))),
XWINDOW (w)->contents);
if (MARKERP (XWINDOW (w)->start)
&& (EQ (XWINDOW (w)->contents, buf1)
|| EQ (XWINDOW (w)->contents, buf2)))
Fset_marker (XWINDOW (w)->start,
make_number
make_fixnum
(XBUFFER (XWINDOW (w)->contents)->last_window_start),
XWINDOW (w)->contents);
w = Fnext_window (w, Qt, Qt);
@ -2547,7 +2547,7 @@ current buffer is cleared. */)
}
}
if (narrowed)
Fnarrow_to_region (make_number (begv), make_number (zv));
Fnarrow_to_region (make_fixnum (begv), make_fixnum (zv));
}
else
{
@ -2628,7 +2628,7 @@ current buffer is cleared. */)
TEMP_SET_PT (pt);
if (narrowed)
Fnarrow_to_region (make_number (begv), make_number (zv));
Fnarrow_to_region (make_fixnum (begv), make_fixnum (zv));
/* Do this first, so that chars_in_text asks the right question.
set_intervals_multibyte needs it too. */
@ -3212,17 +3212,17 @@ sort_overlays (Lisp_Object *overlay_vec, ptrdiff_t noverlays, struct window *w)
sortvec[j].priority = 0;
sortvec[j].spriority = 0;
}
else if (INTEGERP (tem))
else if (FIXNUMP (tem))
{
sortvec[j].priority = XINT (tem);
sortvec[j].priority = XFIXNUM (tem);
sortvec[j].spriority = 0;
}
else if (CONSP (tem))
{
Lisp_Object car = XCAR (tem);
Lisp_Object cdr = XCDR (tem);
sortvec[j].priority = INTEGERP (car) ? XINT (car) : 0;
sortvec[j].spriority = INTEGERP (cdr) ? XINT (cdr) : 0;
sortvec[j].priority = FIXNUMP (car) ? XFIXNUM (car) : 0;
sortvec[j].spriority = FIXNUMP (cdr) ? XFIXNUM (cdr) : 0;
}
j++;
}
@ -3290,7 +3290,7 @@ record_overlay_string (struct sortstrlist *ssl, Lisp_Object str,
ssl->buf[ssl->used].string = str;
ssl->buf[ssl->used].string2 = str2;
ssl->buf[ssl->used].size = size;
ssl->buf[ssl->used].priority = (INTEGERP (pri) ? XINT (pri) : 0);
ssl->buf[ssl->used].priority = (FIXNUMP (pri) ? XFIXNUM (pri) : 0);
ssl->used++;
if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
@ -3644,7 +3644,7 @@ fix_start_end_in_overlays (register ptrdiff_t start, register ptrdiff_t end)
if (endpos < startpos)
{
startpos = endpos;
Fset_marker (OVERLAY_START (overlay), make_number (startpos),
Fset_marker (OVERLAY_START (overlay), make_fixnum (startpos),
Qnil);
}
@ -3692,7 +3692,7 @@ fix_start_end_in_overlays (register ptrdiff_t start, register ptrdiff_t end)
if (endpos < startpos)
{
startpos = endpos;
Fset_marker (OVERLAY_START (overlay), make_number (startpos),
Fset_marker (OVERLAY_START (overlay), make_fixnum (startpos),
Qnil);
}
@ -3867,10 +3867,10 @@ for the rear of the overlay advance when text is inserted there
if (MARKERP (end) && !EQ (Fmarker_buffer (end), buffer))
signal_error ("Marker points into wrong buffer", end);
CHECK_NUMBER_COERCE_MARKER (beg);
CHECK_NUMBER_COERCE_MARKER (end);
CHECK_FIXNUM_COERCE_MARKER (beg);
CHECK_FIXNUM_COERCE_MARKER (end);
if (XINT (beg) > XINT (end))
if (XFIXNUM (beg) > XFIXNUM (end))
{
Lisp_Object temp;
temp = beg; beg = end; end = temp;
@ -3987,10 +3987,10 @@ buffer. */)
if (MARKERP (end) && !EQ (Fmarker_buffer (end), buffer))
signal_error ("Marker points into wrong buffer", end);
CHECK_NUMBER_COERCE_MARKER (beg);
CHECK_NUMBER_COERCE_MARKER (end);
CHECK_FIXNUM_COERCE_MARKER (beg);
CHECK_FIXNUM_COERCE_MARKER (end);
if (XINT (beg) > XINT (end))
if (XFIXNUM (beg) > XFIXNUM (end))
{
Lisp_Object temp;
temp = beg; beg = end; end = temp;
@ -4156,7 +4156,7 @@ If SORTED is non-nil, then sort them by decreasing priority. */)
Lisp_Object *overlay_vec;
Lisp_Object result;
CHECK_NUMBER_COERCE_MARKER (pos);
CHECK_FIXNUM_COERCE_MARKER (pos);
if (!buffer_has_overlays ())
return Qnil;
@ -4167,7 +4167,7 @@ If SORTED is non-nil, then sort them by decreasing priority. */)
/* Put all the overlays we want in a vector in overlay_vec.
Store the length in len. */
noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
noverlays = overlays_at (XFIXNUM (pos), 1, &overlay_vec, &len,
NULL, NULL, 0);
if (!NILP (sorted))
@ -4200,8 +4200,8 @@ end of the buffer. */)
Lisp_Object *overlay_vec;
Lisp_Object result;
CHECK_NUMBER_COERCE_MARKER (beg);
CHECK_NUMBER_COERCE_MARKER (end);
CHECK_FIXNUM_COERCE_MARKER (beg);
CHECK_FIXNUM_COERCE_MARKER (end);
if (!buffer_has_overlays ())
return Qnil;
@ -4211,7 +4211,7 @@ end of the buffer. */)
/* Put all the overlays we want in a vector in overlay_vec.
Store the length in len. */
noverlays = overlays_in (XINT (beg), XINT (end), 1, &overlay_vec, &len,
noverlays = overlays_in (XFIXNUM (beg), XFIXNUM (end), 1, &overlay_vec, &len,
NULL, NULL);
/* Make a list of them all. */
@ -4232,10 +4232,10 @@ the value is (point-max). */)
ptrdiff_t endpos;
Lisp_Object *overlay_vec;
CHECK_NUMBER_COERCE_MARKER (pos);
CHECK_FIXNUM_COERCE_MARKER (pos);
if (!buffer_has_overlays ())
return make_number (ZV);
return make_fixnum (ZV);
len = 10;
overlay_vec = xmalloc (len * sizeof *overlay_vec);
@ -4243,7 +4243,7 @@ the value is (point-max). */)
/* Put all the overlays we want in a vector in overlay_vec.
Store the length in len.
endpos gets the position where the next overlay starts. */
noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
noverlays = overlays_at (XFIXNUM (pos), 1, &overlay_vec, &len,
&endpos, 0, 1);
/* If any of these overlays ends before endpos,
@ -4260,7 +4260,7 @@ the value is (point-max). */)
}
xfree (overlay_vec);
return make_number (endpos);
return make_fixnum (endpos);
}
DEFUN ("previous-overlay-change", Fprevious_overlay_change,
@ -4274,14 +4274,14 @@ the value is (point-min). */)
Lisp_Object *overlay_vec;
ptrdiff_t len;
CHECK_NUMBER_COERCE_MARKER (pos);
CHECK_FIXNUM_COERCE_MARKER (pos);
if (!buffer_has_overlays ())
return make_number (BEGV);
return make_fixnum (BEGV);
/* At beginning of buffer, we know the answer;
avoid bug subtracting 1 below. */
if (XINT (pos) == BEGV)
if (XFIXNUM (pos) == BEGV)
return pos;
len = 10;
@ -4290,11 +4290,11 @@ the value is (point-min). */)
/* Put all the overlays we want in a vector in overlay_vec.
Store the length in len.
prevpos gets the position of the previous change. */
overlays_at (XINT (pos), 1, &overlay_vec, &len,
overlays_at (XFIXNUM (pos), 1, &overlay_vec, &len,
0, &prevpos, 1);
xfree (overlay_vec);
return make_number (prevpos);
return make_fixnum (prevpos);
}
/* These functions are for debugging overlays. */
@ -4332,9 +4332,9 @@ for positions far away from POS). */)
(Lisp_Object pos)
{
ptrdiff_t p;
CHECK_NUMBER_COERCE_MARKER (pos);
CHECK_FIXNUM_COERCE_MARKER (pos);
p = clip_to_bounds (PTRDIFF_MIN, XINT (pos), PTRDIFF_MAX);
p = clip_to_bounds (PTRDIFF_MIN, XFIXNUM (pos), PTRDIFF_MAX);
recenter_overlay_lists (current_buffer, p);
return Qnil;
}
@ -4442,7 +4442,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
Lisp_Object prop, overlay;
struct Lisp_Overlay *tail;
/* True if this change is an insertion. */
bool insertion = (after ? XFASTINT (arg3) == 0 : EQ (start, end));
bool insertion = (after ? XFIXNAT (arg3) == 0 : EQ (start, end));
overlay = Qnil;
tail = NULL;
@ -4470,18 +4470,18 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
ostart = OVERLAY_START (overlay);
oend = OVERLAY_END (overlay);
endpos = OVERLAY_POSITION (oend);
if (XFASTINT (start) > endpos)
if (XFIXNAT (start) > endpos)
break;
startpos = OVERLAY_POSITION (ostart);
if (insertion && (XFASTINT (start) == startpos
|| XFASTINT (end) == startpos))
if (insertion && (XFIXNAT (start) == startpos
|| XFIXNAT (end) == startpos))
{
prop = Foverlay_get (overlay, Qinsert_in_front_hooks);
if (!NILP (prop))
add_overlay_mod_hooklist (prop, overlay);
}
if (insertion && (XFASTINT (start) == endpos
|| XFASTINT (end) == endpos))
if (insertion && (XFIXNAT (start) == endpos
|| XFIXNAT (end) == endpos))
{
prop = Foverlay_get (overlay, Qinsert_behind_hooks);
if (!NILP (prop))
@ -4489,7 +4489,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
}
/* Test for intersecting intervals. This does the right thing
for both insertion and deletion. */
if (XFASTINT (end) > startpos && XFASTINT (start) < endpos)
if (XFIXNAT (end) > startpos && XFIXNAT (start) < endpos)
{
prop = Foverlay_get (overlay, Qmodification_hooks);
if (!NILP (prop))
@ -4508,17 +4508,17 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
oend = OVERLAY_END (overlay);
startpos = OVERLAY_POSITION (ostart);
endpos = OVERLAY_POSITION (oend);
if (XFASTINT (end) < startpos)
if (XFIXNAT (end) < startpos)
break;
if (insertion && (XFASTINT (start) == startpos
|| XFASTINT (end) == startpos))
if (insertion && (XFIXNAT (start) == startpos
|| XFIXNAT (end) == startpos))
{
prop = Foverlay_get (overlay, Qinsert_in_front_hooks);
if (!NILP (prop))
add_overlay_mod_hooklist (prop, overlay);
}
if (insertion && (XFASTINT (start) == endpos
|| XFASTINT (end) == endpos))
if (insertion && (XFIXNAT (start) == endpos
|| XFIXNAT (end) == endpos))
{
prop = Foverlay_get (overlay, Qinsert_behind_hooks);
if (!NILP (prop))
@ -4526,7 +4526,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
}
/* Test for intersecting intervals. This does the right thing
for both insertion and deletion. */
if (XFASTINT (end) > startpos && XFASTINT (start) < endpos)
if (XFIXNAT (end) > startpos && XFIXNAT (start) < endpos)
{
prop = Foverlay_get (overlay, Qmodification_hooks);
if (!NILP (prop))
@ -5082,41 +5082,41 @@ init_buffer_once (void)
/* 0 means not a lisp var, -1 means always local, else mask. */
memset (&buffer_local_flags, 0, sizeof buffer_local_flags);
bset_filename (&buffer_local_flags, make_number (-1));
bset_directory (&buffer_local_flags, make_number (-1));
bset_backed_up (&buffer_local_flags, make_number (-1));
bset_save_length (&buffer_local_flags, make_number (-1));
bset_auto_save_file_name (&buffer_local_flags, make_number (-1));
bset_read_only (&buffer_local_flags, make_number (-1));
bset_major_mode (&buffer_local_flags, make_number (-1));
bset_mode_name (&buffer_local_flags, make_number (-1));
bset_undo_list (&buffer_local_flags, make_number (-1));
bset_mark_active (&buffer_local_flags, make_number (-1));
bset_point_before_scroll (&buffer_local_flags, make_number (-1));
bset_file_truename (&buffer_local_flags, make_number (-1));
bset_invisibility_spec (&buffer_local_flags, make_number (-1));
bset_file_format (&buffer_local_flags, make_number (-1));
bset_auto_save_file_format (&buffer_local_flags, make_number (-1));
bset_display_count (&buffer_local_flags, make_number (-1));
bset_display_time (&buffer_local_flags, make_number (-1));
bset_enable_multibyte_characters (&buffer_local_flags, make_number (-1));
bset_filename (&buffer_local_flags, make_fixnum (-1));
bset_directory (&buffer_local_flags, make_fixnum (-1));
bset_backed_up (&buffer_local_flags, make_fixnum (-1));
bset_save_length (&buffer_local_flags, make_fixnum (-1));
bset_auto_save_file_name (&buffer_local_flags, make_fixnum (-1));
bset_read_only (&buffer_local_flags, make_fixnum (-1));
bset_major_mode (&buffer_local_flags, make_fixnum (-1));
bset_mode_name (&buffer_local_flags, make_fixnum (-1));
bset_undo_list (&buffer_local_flags, make_fixnum (-1));
bset_mark_active (&buffer_local_flags, make_fixnum (-1));
bset_point_before_scroll (&buffer_local_flags, make_fixnum (-1));
bset_file_truename (&buffer_local_flags, make_fixnum (-1));
bset_invisibility_spec (&buffer_local_flags, make_fixnum (-1));
bset_file_format (&buffer_local_flags, make_fixnum (-1));
bset_auto_save_file_format (&buffer_local_flags, make_fixnum (-1));
bset_display_count (&buffer_local_flags, make_fixnum (-1));
bset_display_time (&buffer_local_flags, make_fixnum (-1));
bset_enable_multibyte_characters (&buffer_local_flags, make_fixnum (-1));
/* These used to be stuck at 0 by default, but now that the all-zero value
means Qnil, we have to initialize them explicitly. */
bset_name (&buffer_local_flags, make_number (0));
bset_mark (&buffer_local_flags, make_number (0));
bset_local_var_alist (&buffer_local_flags, make_number (0));
bset_keymap (&buffer_local_flags, make_number (0));
bset_downcase_table (&buffer_local_flags, make_number (0));
bset_upcase_table (&buffer_local_flags, make_number (0));
bset_case_canon_table (&buffer_local_flags, make_number (0));
bset_case_eqv_table (&buffer_local_flags, make_number (0));
bset_minor_modes (&buffer_local_flags, make_number (0));
bset_width_table (&buffer_local_flags, make_number (0));
bset_pt_marker (&buffer_local_flags, make_number (0));
bset_begv_marker (&buffer_local_flags, make_number (0));
bset_zv_marker (&buffer_local_flags, make_number (0));
bset_last_selected_window (&buffer_local_flags, make_number (0));
bset_name (&buffer_local_flags, make_fixnum (0));
bset_mark (&buffer_local_flags, make_fixnum (0));
bset_local_var_alist (&buffer_local_flags, make_fixnum (0));
bset_keymap (&buffer_local_flags, make_fixnum (0));
bset_downcase_table (&buffer_local_flags, make_fixnum (0));
bset_upcase_table (&buffer_local_flags, make_fixnum (0));
bset_case_canon_table (&buffer_local_flags, make_fixnum (0));
bset_case_eqv_table (&buffer_local_flags, make_fixnum (0));
bset_minor_modes (&buffer_local_flags, make_fixnum (0));
bset_width_table (&buffer_local_flags, make_fixnum (0));
bset_pt_marker (&buffer_local_flags, make_fixnum (0));
bset_begv_marker (&buffer_local_flags, make_fixnum (0));
bset_zv_marker (&buffer_local_flags, make_fixnum (0));
bset_last_selected_window (&buffer_local_flags, make_fixnum (0));
idx = 1;
XSETFASTINT (BVAR (&buffer_local_flags, mode_line_format), idx); ++idx;
@ -5443,7 +5443,7 @@ syms_of_buffer (void)
{
staticpro (&last_overlay_modification_hooks);
last_overlay_modification_hooks
= Fmake_vector (make_number (10), Qnil);
= Fmake_vector (make_fixnum (10), Qnil);
staticpro (&QSFundamental);
staticpro (&Vbuffer_alist);
@ -5584,17 +5584,17 @@ Use the command `abbrev-mode' to change this variable. */);
doc: /* Non-nil if searches and matches should ignore case. */);
DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer, fill_column),
Qintegerp,
Qfixnump,
doc: /* Column beyond which automatic line-wrapping should happen.
Interactively, you can set the buffer local value using \\[set-fill-column]. */);
DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer, left_margin),
Qintegerp,
Qfixnump,
doc: /* Column for the default `indent-line-function' to indent to.
Linefeed indents to this column in Fundamental mode. */);
DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer, tab_width),
Qintegerp,
Qfixnump,
doc: /* Distance between tab stops (for display of tab characters), in columns.
NOTE: This controls the display width of a TAB character, and not
the size of an indentation step.
@ -5765,7 +5765,7 @@ If it is nil, that means don't auto-save this buffer. */);
Backing up is done before the first time the file is saved. */);
DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer, save_length),
Qintegerp,
Qfixnump,
doc: /* Length of current buffer when last read in, saved or auto-saved.
0 initially.
-1 means auto-saving turned off until next real save.
@ -5839,7 +5839,7 @@ In addition, a char-table has six extra slots to control the display of:
See also the functions `display-table-slot' and `set-display-table-slot'. */);
DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer, left_margin_cols),
Qintegerp,
Qfixnump,
doc: /* Width in columns of left marginal area for display of a buffer.
A value of nil means no marginal area.
@ -5847,7 +5847,7 @@ Setting this variable does not take effect until a new buffer is displayed
in a window. To make the change take effect, call `set-window-buffer'. */);
DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer, right_margin_cols),
Qintegerp,
Qfixnump,
doc: /* Width in columns of right marginal area for display of a buffer.
A value of nil means no marginal area.
@ -5855,7 +5855,7 @@ Setting this variable does not take effect until a new buffer is displayed
in a window. To make the change take effect, call `set-window-buffer'. */);
DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer, left_fringe_width),
Qintegerp,
Qfixnump,
doc: /* Width of this buffer's left fringe (in pixels).
A value of 0 means no left fringe is shown in this buffer's window.
A value of nil means to use the left fringe width from the window's frame.
@ -5864,7 +5864,7 @@ Setting this variable does not take effect until a new buffer is displayed
in a window. To make the change take effect, call `set-window-buffer'. */);
DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer, right_fringe_width),
Qintegerp,
Qfixnump,
doc: /* Width of this buffer's right fringe (in pixels).
A value of 0 means no right fringe is shown in this buffer's window.
A value of nil means to use the right fringe width from the window's frame.
@ -5881,12 +5881,12 @@ Setting this variable does not take effect until a new buffer is displayed
in a window. To make the change take effect, call `set-window-buffer'. */);
DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer, scroll_bar_width),
Qintegerp,
Qfixnump,
doc: /* Width of this buffer's vertical scroll bars in pixels.
A value of nil means to use the scroll bar width from the window's frame. */);
DEFVAR_PER_BUFFER ("scroll-bar-height", &BVAR (current_buffer, scroll_bar_height),
Qintegerp,
Qfixnump,
doc: /* Height of this buffer's horizontal scroll bars in pixels.
A value of nil means to use the scroll bar height from the window's frame. */);
@ -6156,7 +6156,7 @@ Setting this variable is very fast, much faster than scanning all the text in
the buffer looking for properties to change. */);
DEFVAR_PER_BUFFER ("buffer-display-count",
&BVAR (current_buffer, display_count), Qintegerp,
&BVAR (current_buffer, display_count), Qfixnump,
doc: /* A number incremented each time this buffer is displayed in a window.
The function `set-window-buffer' increments it. */);

8
src/buffer.h
View file

@ -295,7 +295,7 @@ extern void enlarge_buffer_text (struct buffer *, ptrdiff_t);
do \
{ \
Lisp_Object __pos = (pos); \
if (NUMBERP (__pos)) \
if (FIXED_OR_FLOATP (__pos)) \
{ \
charpos = __pos; \
bytepos = buf_charpos_to_bytepos (current_buffer, __pos); \
@ -1349,7 +1349,7 @@ extern int last_per_buffer_idx;
#define PER_BUFFER_IDX(OFFSET) \
XINT (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_flags))
XFIXNUM (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_flags))
/* Functions to get and set default value of the per-buffer
variable at offset OFFSET in the buffer structure. */
@ -1387,7 +1387,7 @@ downcase (int c)
{
Lisp_Object downcase_table = BVAR (current_buffer, downcase_table);
Lisp_Object down = CHAR_TABLE_REF (downcase_table, c);
return NATNUMP (down) ? XFASTINT (down) : c;
return FIXNATP (down) ? XFIXNAT (down) : c;
}
/* Upcase a character C, or make no change if that cannot be done. */
@ -1396,7 +1396,7 @@ upcase (int c)
{
Lisp_Object upcase_table = BVAR (current_buffer, upcase_table);
Lisp_Object up = CHAR_TABLE_REF (upcase_table, c);
return NATNUMP (up) ? XFASTINT (up) : c;
return FIXNATP (up) ? XFIXNAT (up) : c;
}
/* True if C is upper case. */

76
src/bytecode.c
View file

@ -63,14 +63,14 @@ along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
{ \
if (byte_metering_on) \
{ \
if (XFASTINT (METER_1 (this_code)) < MOST_POSITIVE_FIXNUM) \
if (XFIXNAT (METER_1 (this_code)) < MOST_POSITIVE_FIXNUM) \
XSETFASTINT (METER_1 (this_code), \
XFASTINT (METER_1 (this_code)) + 1); \
XFIXNAT (METER_1 (this_code)) + 1); \
if (last_code \
&& (XFASTINT (METER_2 (last_code, this_code)) \
&& (XFIXNAT (METER_2 (last_code, this_code)) \
< MOST_POSITIVE_FIXNUM)) \
XSETFASTINT (METER_2 (last_code, this_code), \
XFASTINT (METER_2 (last_code, this_code)) + 1); \
XFIXNAT (METER_2 (last_code, this_code)) + 1); \
} \
}
@ -346,7 +346,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
CHECK_STRING (bytestr);
CHECK_VECTOR (vector);
CHECK_NATNUM (maxdepth);
CHECK_FIXNAT (maxdepth);
ptrdiff_t const_length = ASIZE (vector);
@ -362,7 +362,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
Lisp_Object *vectorp = XVECTOR (vector)->contents;
unsigned char quitcounter = 1;
EMACS_INT stack_items = XFASTINT (maxdepth) + 1;
EMACS_INT stack_items = XFIXNAT (maxdepth) + 1;
USE_SAFE_ALLOCA;
void *alloc;
SAFE_ALLOCA_LISP_EXTRA (alloc, stack_items, bytestr_length);
@ -378,16 +378,16 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
if (!NILP (args_template))
{
eassert (INTEGERP (args_template));
ptrdiff_t at = XINT (args_template);
eassert (FIXNUMP (args_template));
ptrdiff_t at = XFIXNUM (args_template);
bool rest = (at & 128) != 0;
int mandatory = at & 127;
ptrdiff_t nonrest = at >> 8;
ptrdiff_t maxargs = rest ? PTRDIFF_MAX : nonrest;
if (! (mandatory <= nargs && nargs <= maxargs))
Fsignal (Qwrong_number_of_arguments,
list2 (Fcons (make_number (mandatory), make_number (nonrest)),
make_number (nargs)));
list2 (Fcons (make_fixnum (mandatory), make_fixnum (nonrest)),
make_fixnum (nargs)));
ptrdiff_t pushedargs = min (nonrest, nargs);
for (ptrdiff_t i = 0; i < pushedargs; i++, args++)
PUSH (*args);
@ -621,10 +621,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
{
Lisp_Object v1 = TOP;
Lisp_Object v2 = Fget (v1, Qbyte_code_meter);
if (INTEGERP (v2)
&& XINT (v2) < MOST_POSITIVE_FIXNUM)
if (FIXNUMP (v2)
&& XFIXNUM (v2) < MOST_POSITIVE_FIXNUM)
{
XSETINT (v2, XINT (v2) + 1);
XSETINT (v2, XFIXNUM (v2) + 1);
Fput (v1, Qbyte_code_meter, v2);
}
}
@ -832,8 +832,8 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
CASE (Bnth):
{
Lisp_Object v2 = POP, v1 = TOP;
CHECK_NUMBER (v1);
for (EMACS_INT n = XINT (v1); 0 < n && CONSP (v2); n--)
CHECK_FIXNUM (v1);
for (EMACS_INT n = XFIXNUM (v1); 0 < n && CONSP (v2); n--)
{
v2 = XCDR (v2);
rarely_quit (n);
@ -972,11 +972,15 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
NEXT;
CASE (Bsub1):
TOP = INTEGERP (TOP) ? make_number (XINT (TOP) - 1) : Fsub1 (TOP);
TOP = (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_NEGATIVE_FIXNUM
? make_fixnum (XFIXNUM (TOP) - 1)
: Fsub1 (TOP));
NEXT;
CASE (Badd1):
TOP = INTEGERP (TOP) ? make_number (XINT (TOP) + 1) : Fadd1 (TOP);
TOP = (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_POSITIVE_FIXNUM
? make_fixnum (XFIXNUM (TOP) + 1)
: Fadd1 (TOP));
NEXT;
CASE (Beqlsign):
@ -986,8 +990,8 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
TOP = arithcompare (v1, v2, ARITH_EQUAL);
else
{
CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1);
CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2);
CHECK_FIXNUM_OR_FLOAT_COERCE_MARKER (v1);
CHECK_FIXNUM_OR_FLOAT_COERCE_MARKER (v2);
TOP = EQ (v1, v2) ? Qt : Qnil;
}
NEXT;
@ -1027,7 +1031,9 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
NEXT;
CASE (Bnegate):
TOP = INTEGERP (TOP) ? make_number (- XINT (TOP)) : Fminus (1, &TOP);
TOP = (FIXNUMP (TOP) && XFIXNUM (TOP) != MOST_NEGATIVE_FIXNUM
? make_fixnum (- XFIXNUM (TOP))
: Fminus (1, &TOP));
NEXT;
CASE (Bplus):
@ -1063,7 +1069,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
}
CASE (Bpoint):
PUSH (make_natnum (PT));
PUSH (make_fixed_natnum (PT));
NEXT;
CASE (Bgoto_char):
@ -1089,7 +1095,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
}
CASE (Bpoint_min):
PUSH (make_natnum (BEGV));
PUSH (make_fixed_natnum (BEGV));
NEXT;
CASE (Bchar_after):
@ -1105,7 +1111,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
NEXT;
CASE (Bcurrent_column):
PUSH (make_natnum (current_column ()));
PUSH (make_fixed_natnum (current_column ()));
NEXT;
CASE (Bindent_to):
@ -1169,7 +1175,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
CASE (Bchar_syntax):
{
CHECK_CHARACTER (TOP);
int c = XFASTINT (TOP);
int c = XFIXNAT (TOP);
if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
MAKE_CHAR_MULTIBYTE (c);
XSETFASTINT (TOP, syntax_code_spec[SYNTAX (c)]);
@ -1262,8 +1268,8 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
{
/* Exchange args and then do nth. */
Lisp_Object v2 = POP, v1 = TOP;
CHECK_NUMBER (v2);
for (EMACS_INT n = XINT (v2); 0 < n && CONSP (v1); n--)
CHECK_FIXNUM (v2);
for (EMACS_INT n = XFIXNUM (v2); 0 < n && CONSP (v1); n--)
{
v1 = XCDR (v1);
rarely_quit (n);
@ -1415,7 +1421,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
{ /* Do a linear search if there are not many cases
FIXME: 5 is arbitrarily chosen. */
Lisp_Object hash_code = h->test.cmpfn
? make_number (h->test.hashfn (&h->test, v1)) : Qnil;
? make_fixnum (h->test.hashfn (&h->test, v1)) : Qnil;
for (i = h->count; 0 <= --i; )
if (EQ (v1, HASH_KEY (h, i))
@ -1431,9 +1437,9 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
if (i >= 0)
{
Lisp_Object val = HASH_VALUE (h, i);
if (BYTE_CODE_SAFE && !INTEGERP (val))
if (BYTE_CODE_SAFE && !FIXNUMP (val))
emacs_abort ();
op = XINT (val);
op = XFIXNUM (val);
goto op_branch;
}
}
@ -1468,14 +1474,14 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
Lisp_Object
get_byte_code_arity (Lisp_Object args_template)
{
eassert (NATNUMP (args_template));
EMACS_INT at = XINT (args_template);
eassert (FIXNATP (args_template));
EMACS_INT at = XFIXNUM (args_template);
bool rest = (at & 128) != 0;
int mandatory = at & 127;
EMACS_INT nonrest = at >> 8;
return Fcons (make_number (mandatory),
rest ? Qmany : make_number (nonrest));
return Fcons (make_fixnum (mandatory),
rest ? Qmany : make_fixnum (nonrest));
}
void
@ -1500,13 +1506,13 @@ If a symbol has a property named `byte-code-meter' whose value is an
integer, it is incremented each time that symbol's function is called. */);
byte_metering_on = false;
Vbyte_code_meter = Fmake_vector (make_number (256), make_number (0));
Vbyte_code_meter = Fmake_vector (make_fixnum (256), make_fixnum (0));
DEFSYM (Qbyte_code_meter, "byte-code-meter");
{
int i = 256;
while (i--)
ASET (Vbyte_code_meter, i,
Fmake_vector (make_number (256), make_number (0)));
Fmake_vector (make_fixnum (256), make_fixnum (0)));
}
#endif
}

28
src/callint.c
View file

@ -200,8 +200,8 @@ fix_command (Lisp_Object input, Lisp_Object values)
carelt = XCAR (elt);
/* If it is (if X Y), look at Y. */
if (EQ (carelt, Qif)
&& NILP (Fnthcdr (make_number (3), elt)))
elt = Fnth (make_number (2), elt);
&& NILP (Fnthcdr (make_fixnum (3), elt)))
elt = Fnth (make_fixnum (2), elt);
/* If it is (when ... Y), look at Y. */
else if (EQ (carelt, Qwhen))
{
@ -479,8 +479,8 @@ invoke it. If KEYS is omitted or nil, the return value of
case 'c': /* Character. */
/* Prompt in `minibuffer-prompt' face. */
Fput_text_property (make_number (0),
make_number (SCHARS (callint_message)),
Fput_text_property (make_fixnum (0),
make_fixnum (SCHARS (callint_message)),
Qface, Qminibuffer_prompt, callint_message);
args[i] = Fread_char (callint_message, Qnil, Qnil);
message1_nolog (0);
@ -531,8 +531,8 @@ invoke it. If KEYS is omitted or nil, the return value of
ptrdiff_t speccount1 = SPECPDL_INDEX ();
specbind (Qcursor_in_echo_area, Qt);
/* Prompt in `minibuffer-prompt' face. */
Fput_text_property (make_number (0),
make_number (SCHARS (callint_message)),
Fput_text_property (make_fixnum (0),
make_fixnum (SCHARS (callint_message)),
Qface, Qminibuffer_prompt, callint_message);
args[i] = Fread_key_sequence (callint_message,
Qnil, Qnil, Qnil, Qnil);
@ -542,7 +542,7 @@ invoke it. If KEYS is omitted or nil, the return value of
/* If the key sequence ends with a down-event,
discard the following up-event. */
Lisp_Object teml
= Faref (args[i], make_number (XINT (Flength (args[i])) - 1));
= Faref (args[i], make_fixnum (XFIXNUM (Flength (args[i])) - 1));
if (CONSP (teml))
teml = XCAR (teml);
if (SYMBOLP (teml))
@ -561,8 +561,8 @@ invoke it. If KEYS is omitted or nil, the return value of
ptrdiff_t speccount1 = SPECPDL_INDEX ();
specbind (Qcursor_in_echo_area, Qt);
/* Prompt in `minibuffer-prompt' face. */
Fput_text_property (make_number (0),
make_number (SCHARS (callint_message)),
Fput_text_property (make_fixnum (0),
make_fixnum (SCHARS (callint_message)),
Qface, Qminibuffer_prompt, callint_message);
args[i] = Fread_key_sequence_vector (callint_message,
Qnil, Qt, Qnil, Qnil);
@ -572,7 +572,7 @@ invoke it. If KEYS is omitted or nil, the return value of
/* If the key sequence ends with a down-event,
discard the following up-event. */
Lisp_Object teml
= Faref (args[i], make_number (XINT (Flength (args[i])) - 1));
= Faref (args[i], make_fixnum (XFIXNUM (Flength (args[i])) - 1));
if (CONSP (teml))
teml = XCAR (teml);
if (SYMBOLP (teml))
@ -589,7 +589,7 @@ invoke it. If KEYS is omitted or nil, the return value of
case 'U': /* Up event from last k or K. */
if (!NILP (up_event))
{
args[i] = Fmake_vector (make_number (1), up_event);
args[i] = Fmake_vector (make_fixnum (1), up_event);
up_event = Qnil;
visargs[i] = Fkey_description (args[i], Qnil);
}
@ -795,9 +795,9 @@ Its numeric meaning is what you would get from `(interactive "p")'. */)
XSETFASTINT (val, 1);
else if (EQ (raw, Qminus))
XSETINT (val, -1);
else if (CONSP (raw) && INTEGERP (XCAR (raw)))
XSETINT (val, XINT (XCAR (raw)));
else if (INTEGERP (raw))
else if (CONSP (raw) && FIXNUMP (XCAR (raw)))
XSETINT (val, XFIXNUM (XCAR (raw)));
else if (FIXNUMP (raw))
val = raw;
else
XSETFASTINT (val, 1);

24
src/callproc.c
View file

@ -83,7 +83,7 @@ static pid_t synch_process_pid;
#ifdef MSDOS
static Lisp_Object synch_process_tempfile;
#else
# define synch_process_tempfile make_number (0)
# define synch_process_tempfile make_fixnum (0)
#endif
/* Indexes of file descriptors that need closing on call_process_kill. */
@ -324,7 +324,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
#ifndef subprocesses
/* Without asynchronous processes we cannot have BUFFER == 0. */
if (nargs >= 3
&& (INTEGERP (CONSP (args[2]) ? XCAR (args[2]) : args[2])))
&& (FIXNUMP (CONSP (args[2]) ? XCAR (args[2]) : args[2])))
error ("Operating system cannot handle asynchronous subprocesses");
#endif /* subprocesses */
@ -403,7 +403,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
buffer = Qnil;
}
if (! (NILP (buffer) || EQ (buffer, Qt) || INTEGERP (buffer)))
if (! (NILP (buffer) || EQ (buffer, Qt) || FIXNUMP (buffer)))
{
Lisp_Object spec_buffer;
spec_buffer = buffer;
@ -431,7 +431,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
for (i = 0; i < CALLPROC_FDS; i++)
callproc_fd[i] = -1;
#ifdef MSDOS
synch_process_tempfile = make_number (0);
synch_process_tempfile = make_fixnum (0);
#endif
record_unwind_protect_ptr (call_process_kill, callproc_fd);
@ -440,7 +440,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
int ok;
ok = openp (Vexec_path, args[0], Vexec_suffixes, &path,
make_number (X_OK), false);
make_fixnum (X_OK), false);
if (ok < 0)
report_file_error ("Searching for program", args[0]);
}
@ -471,7 +471,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
path = ENCODE_FILE (path);
new_argv[0] = SSDATA (path);
discard_output = INTEGERP (buffer) || (NILP (buffer) && NILP (output_file));
discard_output = FIXNUMP (buffer) || (NILP (buffer) && NILP (output_file));
#ifdef MSDOS
if (! discard_output && ! STRINGP (output_file))
@ -670,7 +670,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
{
synch_process_pid = pid;
if (INTEGERP (buffer))
if (FIXNUMP (buffer))
{
if (tempfile_index < 0)
record_deleted_pid (pid, Qnil);
@ -703,7 +703,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
#endif /* not MSDOS */
if (INTEGERP (buffer))
if (FIXNUMP (buffer))
return unbind_to (count, Qnil);
if (BUFFERP (buffer))
@ -870,7 +870,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
coding-system used to decode the process output. */
if (inherit_process_coding_system)
call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
make_number (total_read));
make_fixnum (total_read));
}
bool wait_ok = true;
@ -903,7 +903,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
}
eassert (WIFEXITED (status));
return make_number (WEXITSTATUS (status));
return make_fixnum (WEXITSTATUS (status));
}
/* Create a temporary file suitable for storing the input data of
@ -1066,7 +1066,7 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
validate_region (&args[0], &args[1]);
start = args[0];
end = args[1];
empty_input = XINT (start) == XINT (end);
empty_input = XFIXNUM (start) == XFIXNUM (end);
}
if (!empty_input)
@ -1644,7 +1644,7 @@ syms_of_callproc (void)
staticpro (&Vtemp_file_name_pattern);
#ifdef MSDOS
synch_process_tempfile = make_number (0);
synch_process_tempfile = make_fixnum (0);
staticpro (&synch_process_tempfile);
#endif

20
src/casefiddle.c
View file

@ -152,7 +152,7 @@ case_character_impl (struct casing_str_buf *buf,
prop = CHAR_TABLE_REF (ctx->titlecase_char_table, ch);
if (CHARACTERP (prop))
{
cased = XFASTINT (prop);
cased = XFIXNAT (prop);
cased_is_set = true;
}
}
@ -225,7 +225,7 @@ do_casify_natnum (struct casing_context *ctx, Lisp_Object obj)
{
int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
| CHAR_SHIFT | CHAR_CTL | CHAR_META);
int ch = XFASTINT (obj);
int ch = XFIXNAT (obj);
/* If the character has higher bits set above the flags, return it unchanged.
It is not a real character. */
@ -250,7 +250,7 @@ do_casify_natnum (struct casing_context *ctx, Lisp_Object obj)
if (! multibyte)
MAKE_CHAR_UNIBYTE (cased);
return make_natnum (cased | flags);
return make_fixed_natnum (cased | flags);
}
static Lisp_Object
@ -319,7 +319,7 @@ casify_object (enum case_action flag, Lisp_Object obj)
struct casing_context ctx;
prepare_casing_context (&ctx, flag, false);
if (NATNUMP (obj))
if (FIXNATP (obj))
return do_casify_natnum (&ctx, obj);
else if (!STRINGP (obj))
wrong_type_argument (Qchar_or_string_p, obj);
@ -485,8 +485,8 @@ casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
struct casing_context ctx;
validate_region (&b, &e);
ptrdiff_t start = XFASTINT (b);
ptrdiff_t end = XFASTINT (e);
ptrdiff_t start = XFIXNAT (b);
ptrdiff_t end = XFIXNAT (e);
if (start == end)
/* Not modifying because nothing marked. */
return end;
@ -601,11 +601,11 @@ character positions to operate on. */)
static Lisp_Object
casify_word (enum case_action flag, Lisp_Object arg)
{
CHECK_NUMBER (arg);
ptrdiff_t farend = scan_words (PT, XINT (arg));
CHECK_FIXNUM (arg);
ptrdiff_t farend = scan_words (PT, XFIXNUM (arg));
if (!farend)
farend = XINT (arg) <= 0 ? BEGV : ZV;
SET_PT (casify_region (flag, make_number (PT), make_number (farend)));
farend = XFIXNUM (arg) <= 0 ? BEGV : ZV;
SET_PT (casify_region (flag, make_fixnum (PT), make_fixnum (farend)));
return Qnil;
}

32
src/casetab.c
View file

@ -179,7 +179,7 @@ set_canon (Lisp_Object case_table, Lisp_Object range, Lisp_Object elt)
Lisp_Object up = XCHAR_TABLE (case_table)->extras[0];
Lisp_Object canon = XCHAR_TABLE (case_table)->extras[1];
if (NATNUMP (elt))
if (FIXNATP (elt))
Fset_char_table_range (canon, range, Faref (case_table, Faref (up, elt)));
}
@ -191,21 +191,21 @@ set_canon (Lisp_Object case_table, Lisp_Object range, Lisp_Object elt)
static void
set_identity (Lisp_Object table, Lisp_Object c, Lisp_Object elt)
{
if (NATNUMP (elt))
if (FIXNATP (elt))
{
int from, to;
if (CONSP (c))
{
from = XINT (XCAR (c));
to = XINT (XCDR (c));
from = XFIXNUM (XCAR (c));
to = XFIXNUM (XCDR (c));
}
else
from = to = XINT (c);
from = to = XFIXNUM (c);
to++;
for (; from < to; from++)
CHAR_TABLE_SET (table, from, make_number (from));
CHAR_TABLE_SET (table, from, make_fixnum (from));
}
}
@ -217,24 +217,24 @@ set_identity (Lisp_Object table, Lisp_Object c, Lisp_Object elt)
static void
shuffle (Lisp_Object table, Lisp_Object c, Lisp_Object elt)
{
if (NATNUMP (elt))
if (FIXNATP (elt))
{
int from, to;
if (CONSP (c))
{
from = XINT (XCAR (c));
to = XINT (XCDR (c));
from = XFIXNUM (XCAR (c));
to = XFIXNUM (XCDR (c));
}
else
from = to = XINT (c);
from = to = XFIXNUM (c);
to++;
for (; from < to; from++)
{
Lisp_Object tem = Faref (table, elt);
Faset (table, elt, make_number (from));
Faset (table, make_number (from), tem);
Faset (table, elt, make_fixnum (from));
Faset (table, make_fixnum (from), tem);
}
}
}
@ -246,7 +246,7 @@ init_casetab_once (void)
Lisp_Object down, up, eqv;
DEFSYM (Qcase_table, "case-table");
Fput (Qcase_table, Qchar_table_extra_slots, make_number (3));
Fput (Qcase_table, Qchar_table_extra_slots, make_fixnum (3));
down = Fmake_char_table (Qcase_table, Qnil);
Vascii_downcase_table = down;
@ -255,7 +255,7 @@ init_casetab_once (void)
for (i = 0; i < 128; i++)
{
int c = (i >= 'A' && i <= 'Z') ? i + ('a' - 'A') : i;
CHAR_TABLE_SET (down, i, make_number (c));
CHAR_TABLE_SET (down, i, make_fixnum (c));
}
set_char_table_extras (down, 1, Fcopy_sequence (down));
@ -266,7 +266,7 @@ init_casetab_once (void)
for (i = 0; i < 128; i++)
{
int c = (i >= 'a' && i <= 'z') ? i + ('A' - 'a') : i;
CHAR_TABLE_SET (up, i, make_number (c));
CHAR_TABLE_SET (up, i, make_fixnum (c));
}
eqv = Fmake_char_table (Qcase_table, Qnil);
@ -276,7 +276,7 @@ init_casetab_once (void)
int c = ((i >= 'A' && i <= 'Z') ? i + ('a' - 'A')
: ((i >= 'a' && i <= 'z') ? i + ('A' - 'a')
: i));
CHAR_TABLE_SET (eqv, i, make_number (c));
CHAR_TABLE_SET (eqv, i, make_fixnum (c));
}
set_char_table_extras (down, 2, eqv);

52
src/category.c
View file

@ -103,7 +103,7 @@ those categories. */)
while (--len >= 0)
{
unsigned char cat = SREF (categories, len);
Lisp_Object category = make_number (cat);
Lisp_Object category = make_fixnum (cat);
CHECK_CATEGORY (category);
set_category_set (val, cat, 1);
@ -130,11 +130,11 @@ the current buffer's category table. */)
CHECK_STRING (docstring);
table = check_category_table (table);
if (!NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
error ("Category `%c' is already defined", (int) XFASTINT (category));
if (!NILP (CATEGORY_DOCSTRING (table, XFIXNAT (category))))
error ("Category `%c' is already defined", (int) XFIXNAT (category));
if (!NILP (Vpurify_flag))
docstring = Fpurecopy (docstring);
SET_CATEGORY_DOCSTRING (table, XFASTINT (category), docstring);
SET_CATEGORY_DOCSTRING (table, XFIXNAT (category), docstring);
return Qnil;
}
@ -148,7 +148,7 @@ category table. */)
CHECK_CATEGORY (category);
table = check_category_table (table);
return CATEGORY_DOCSTRING (table, XFASTINT (category));
return CATEGORY_DOCSTRING (table, XFIXNAT (category));
}
DEFUN ("get-unused-category", Fget_unused_category, Sget_unused_category,
@ -165,7 +165,7 @@ it defaults to the current buffer's category table. */)
for (i = ' '; i <= '~'; i++)
if (NILP (CATEGORY_DOCSTRING (table, i)))
return make_number (i);
return make_fixnum (i);
return Qnil;
}
@ -220,9 +220,9 @@ copy_category_entry (Lisp_Object table, Lisp_Object c, Lisp_Object val)
{
val = Fcopy_sequence (val);
if (CONSP (c))
char_table_set_range (table, XINT (XCAR (c)), XINT (XCDR (c)), val);
char_table_set_range (table, XFIXNUM (XCAR (c)), XFIXNUM (XCDR (c)), val);
else
char_table_set (table, XINT (c), val);
char_table_set (table, XFIXNUM (c), val);
}
/* Return a copy of category table TABLE. We can't simply use the
@ -271,8 +271,8 @@ DEFUN ("make-category-table", Fmake_category_table, Smake_category_table,
set_char_table_defalt (val, MAKE_CATEGORY_SET);
for (i = 0; i < (1 << CHARTAB_SIZE_BITS_0); i++)
set_char_table_contents (val, i, MAKE_CATEGORY_SET);
Fset_char_table_extra_slot (val, make_number (0),
Fmake_vector (make_number (95), Qnil));
Fset_char_table_extra_slot (val, make_fixnum (0),
Fmake_vector (make_fixnum (95), Qnil));
return val;
}
@ -303,7 +303,7 @@ usage: (char-category-set CHAR) */)
(Lisp_Object ch)
{
CHECK_CHARACTER (ch);
return CATEGORY_SET (XFASTINT (ch));
return CATEGORY_SET (XFIXNAT (ch));
}
DEFUN ("category-set-mnemonics", Fcategory_set_mnemonics,
@ -346,25 +346,25 @@ then delete CATEGORY from the category set instead of adding it. */)
int start, end;
int from, to;
if (INTEGERP (character))
if (FIXNUMP (character))
{
CHECK_CHARACTER (character);
start = end = XFASTINT (character);
start = end = XFIXNAT (character);
}
else
{
CHECK_CONS (character);
CHECK_CHARACTER_CAR (character);
CHECK_CHARACTER_CDR (character);
start = XFASTINT (XCAR (character));
end = XFASTINT (XCDR (character));
start = XFIXNAT (XCAR (character));
end = XFIXNAT (XCDR (character));
}
CHECK_CATEGORY (category);
table = check_category_table (table);
if (NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
error ("Undefined category: %c", (int) XFASTINT (category));
if (NILP (CATEGORY_DOCSTRING (table, XFIXNAT (category))))
error ("Undefined category: %c", (int) XFIXNAT (category));
set_value = NILP (reset);
@ -372,10 +372,10 @@ then delete CATEGORY from the category set instead of adding it. */)
{
from = start, to = end;
category_set = char_table_ref_and_range (table, start, &from, &to);
if (CATEGORY_MEMBER (XFASTINT (category), category_set) != NILP (reset))
if (CATEGORY_MEMBER (XFIXNAT (category), category_set) != NILP (reset))
{
category_set = Fcopy_sequence (category_set);
set_category_set (category_set, XFASTINT (category), set_value);
set_category_set (category_set, XFIXNAT (category), set_value);
category_set = hash_get_category_set (table, category_set);
char_table_set_range (table, start, to, category_set);
}
@ -423,12 +423,12 @@ word_boundary_p (int c1, int c2)
if (CONSP (elt)
&& (NILP (XCAR (elt))
|| (CATEGORYP (XCAR (elt))
&& CATEGORY_MEMBER (XFASTINT (XCAR (elt)), category_set1)
&& ! CATEGORY_MEMBER (XFASTINT (XCAR (elt)), category_set2)))
&& CATEGORY_MEMBER (XFIXNAT (XCAR (elt)), category_set1)
&& ! CATEGORY_MEMBER (XFIXNAT (XCAR (elt)), category_set2)))
&& (NILP (XCDR (elt))
|| (CATEGORYP (XCDR (elt))
&& ! CATEGORY_MEMBER (XFASTINT (XCDR (elt)), category_set1)
&& CATEGORY_MEMBER (XFASTINT (XCDR (elt)), category_set2))))
&& ! CATEGORY_MEMBER (XFIXNAT (XCDR (elt)), category_set1)
&& CATEGORY_MEMBER (XFIXNAT (XCDR (elt)), category_set2))))
return !default_result;
}
return default_result;
@ -440,13 +440,13 @@ init_category_once (void)
{
/* This has to be done here, before we call Fmake_char_table. */
DEFSYM (Qcategory_table, "category-table");
Fput (Qcategory_table, Qchar_table_extra_slots, make_number (2));
Fput (Qcategory_table, Qchar_table_extra_slots, make_fixnum (2));
Vstandard_category_table = Fmake_char_table (Qcategory_table, Qnil);
/* Set a category set which contains nothing to the default. */
set_char_table_defalt (Vstandard_category_table, MAKE_CATEGORY_SET);
Fset_char_table_extra_slot (Vstandard_category_table, make_number (0),
Fmake_vector (make_number (95), Qnil));
Fset_char_table_extra_slot (Vstandard_category_table, make_fixnum (0),
Fmake_vector (make_fixnum (95), Qnil));
}
void

12
src/category.h
View file

@ -59,7 +59,7 @@ along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
INLINE_HEADER_BEGIN
#define CATEGORYP(x) RANGED_INTEGERP (0x20, x, 0x7E)
#define CATEGORYP(x) RANGED_FIXNUMP (0x20, x, 0x7E)
#define CHECK_CATEGORY(x) \
CHECK_TYPE (CATEGORYP (x), Qcategoryp, x)
@ -68,7 +68,7 @@ INLINE_HEADER_BEGIN
(BOOL_VECTOR_P (x) && bool_vector_size (x) == 128)
/* Return a new empty category set. */
#define MAKE_CATEGORY_SET (Fmake_bool_vector (make_number (128), Qnil))
#define MAKE_CATEGORY_SET (Fmake_bool_vector (make_fixnum (128), Qnil))
#define CHECK_CATEGORY_SET(x) \
CHECK_TYPE (CATEGORY_SET_P (x), Qcategorysetp, x)
@ -77,7 +77,7 @@ INLINE_HEADER_BEGIN
#define CATEGORY_SET(c) char_category_set (c)
/* Return true if CATEGORY_SET contains CATEGORY.
Faster than '!NILP (Faref (category_set, make_number (category)))'. */
Faster than '!NILP (Faref (category_set, make_fixnum (category)))'. */
INLINE bool
CATEGORY_MEMBER (EMACS_INT category, Lisp_Object category_set)
{
@ -98,16 +98,16 @@ CHAR_HAS_CATEGORY (int ch, int category)
/* Return the doc string of CATEGORY in category table TABLE. */
#define CATEGORY_DOCSTRING(table, category) \
AREF (Fchar_table_extra_slot (table, make_number (0)), ((category) - ' '))
AREF (Fchar_table_extra_slot (table, make_fixnum (0)), ((category) - ' '))
/* Set the doc string of CATEGORY to VALUE in category table TABLE. */
#define SET_CATEGORY_DOCSTRING(table, category, value) \
ASET (Fchar_table_extra_slot (table, make_number (0)), ((category) - ' '), value)
ASET (Fchar_table_extra_slot (table, make_fixnum (0)), ((category) - ' '), value)
/* Return the version number of category table TABLE. Not used for
the moment. */
#define CATEGORY_TABLE_VERSION (table) \
Fchar_table_extra_slot (table, make_number (1))
Fchar_table_extra_slot (table, make_fixnum (1))
/* Return true if there is a word boundary between two
word-constituent characters C1 and C2 if they appear in this order.

188
src/ccl.c
View file

@ -629,7 +629,7 @@ do \
stack_idx++; \
ccl_prog = called_ccl.prog; \
ic = CCL_HEADER_MAIN; \
eof_ic = XFASTINT (ccl_prog[CCL_HEADER_EOF]); \
eof_ic = XFIXNAT (ccl_prog[CCL_HEADER_EOF]); \
goto ccl_repeat; \
} \
while (0)
@ -736,7 +736,7 @@ while (0)
#define GET_CCL_RANGE(var, ccl_prog, ic, lo, hi) \
do \
{ \
EMACS_INT prog_word = XINT ((ccl_prog)[ic]); \
EMACS_INT prog_word = XFIXNUM ((ccl_prog)[ic]); \
if (! ASCENDING_ORDER (lo, prog_word, hi)) \
CCL_INVALID_CMD; \
(var) = prog_word; \
@ -769,12 +769,12 @@ while (0)
CCL_INVALID_CMD; \
else if (dst + len <= dst_end) \
{ \
if (XFASTINT (ccl_prog[ic]) & 0x1000000) \
if (XFIXNAT (ccl_prog[ic]) & 0x1000000) \
for (ccli = 0; ccli < len; ccli++) \
*dst++ = XFASTINT (ccl_prog[ic + ccli]) & 0xFFFFFF; \
*dst++ = XFIXNAT (ccl_prog[ic + ccli]) & 0xFFFFFF; \
else \
for (ccli = 0; ccli < len; ccli++) \
*dst++ = ((XFASTINT (ccl_prog[ic + (ccli / 3)])) \
*dst++ = ((XFIXNAT (ccl_prog[ic + (ccli / 3)])) \
>> ((2 - (ccli % 3)) * 8)) & 0xFF; \
} \
else \
@ -926,14 +926,14 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
break;
case CCL_SetConst: /* 00000000000000000000rrrXXXXX */
reg[rrr] = XINT (ccl_prog[ic++]);
reg[rrr] = XFIXNUM (ccl_prog[ic++]);
break;
case CCL_SetArray: /* CCCCCCCCCCCCCCCCCCCCRRRrrrXXXXX */
i = reg[RRR];
j = field1 >> 3;
if (0 <= i && i < j)
reg[rrr] = XINT (ccl_prog[ic + i]);
reg[rrr] = XFIXNUM (ccl_prog[ic + i]);
ic += j;
break;
@ -961,13 +961,13 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
break;
case CCL_WriteConstJump: /* A--D--D--R--E--S--S-000XXXXX */
i = XINT (ccl_prog[ic]);
i = XFIXNUM (ccl_prog[ic]);
CCL_WRITE_CHAR (i);
ic += ADDR;
break;
case CCL_WriteConstReadJump: /* A--D--D--R--E--S--S-rrrXXXXX */
i = XINT (ccl_prog[ic]);
i = XFIXNUM (ccl_prog[ic]);
CCL_WRITE_CHAR (i);
ic++;
CCL_READ_CHAR (reg[rrr]);
@ -975,17 +975,17 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
break;
case CCL_WriteStringJump: /* A--D--D--R--E--S--S-000XXXXX */
j = XINT (ccl_prog[ic++]);
j = XFIXNUM (ccl_prog[ic++]);
CCL_WRITE_STRING (j);
ic += ADDR - 1;
break;
case CCL_WriteArrayReadJump: /* A--D--D--R--E--S--S-rrrXXXXX */
i = reg[rrr];
j = XINT (ccl_prog[ic]);
j = XFIXNUM (ccl_prog[ic]);
if (0 <= i && i < j)
{
i = XINT (ccl_prog[ic + 1 + i]);
i = XFIXNUM (ccl_prog[ic + 1 + i]);
CCL_WRITE_CHAR (i);
}
ic += j + 2;
@ -1004,7 +1004,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
case CCL_Branch: /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */
{
int ioff = 0 <= reg[rrr] && reg[rrr] < field1 ? reg[rrr] : field1;
int incr = XINT (ccl_prog[ic + ioff]);
int incr = XFIXNUM (ccl_prog[ic + ioff]);
ic += incr;
}
break;
@ -1023,7 +1023,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
case CCL_WriteExprConst: /* 1:00000OPERATION000RRR000XXXXX */
rrr = 7;
i = reg[RRR];
j = XINT (ccl_prog[ic]);
j = XFIXNUM (ccl_prog[ic]);
op = field1 >> 6;
jump_address = ic + 1;
goto ccl_set_expr;
@ -1056,7 +1056,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
/* If FFF is nonzero, the CCL program ID is in the
following code. */
if (rrr)
prog_id = XINT (ccl_prog[ic++]);
prog_id = XFIXNUM (ccl_prog[ic++]);
else
prog_id = field1;
@ -1081,7 +1081,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
stack_idx++;
ccl_prog = XVECTOR (AREF (slot, 1))->contents;
ic = CCL_HEADER_MAIN;
eof_ic = XFASTINT (ccl_prog[CCL_HEADER_EOF]);
eof_ic = XFIXNAT (ccl_prog[CCL_HEADER_EOF]);
}
break;
@ -1099,7 +1099,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
i = reg[rrr];
if (0 <= i && i < field1)
{
j = XINT (ccl_prog[ic + i]);
j = XFIXNUM (ccl_prog[ic + i]);
CCL_WRITE_CHAR (j);
}
ic += field1;
@ -1124,7 +1124,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
CCL_SUCCESS;
case CCL_ExprSelfConst: /* 00000OPERATION000000rrrXXXXX */
i = XINT (ccl_prog[ic++]);
i = XFIXNUM (ccl_prog[ic++]);
op = field1 >> 6;
goto ccl_expr_self;
@ -1160,7 +1160,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
case CCL_SetExprConst: /* 00000OPERATION000RRRrrrXXXXX */
i = reg[RRR];
j = XINT (ccl_prog[ic++]);
j = XFIXNUM (ccl_prog[ic++]);
op = field1 >> 6;
jump_address = ic;
goto ccl_set_expr;
@ -1178,8 +1178,8 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
case CCL_JumpCondExprConst: /* A--D--D--R--E--S--S-rrrXXXXX */
i = reg[rrr];
jump_address = ic + ADDR;
op = XINT (ccl_prog[ic++]);
j = XINT (ccl_prog[ic++]);
op = XFIXNUM (ccl_prog[ic++]);
j = XFIXNUM (ccl_prog[ic++]);
rrr = 7;
goto ccl_set_expr;
@ -1189,7 +1189,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
case CCL_JumpCondExprReg:
i = reg[rrr];
jump_address = ic + ADDR;
op = XINT (ccl_prog[ic++]);
op = XFIXNUM (ccl_prog[ic++]);
GET_CCL_RANGE (j, ccl_prog, ic++, 0, 7);
j = reg[j];
rrr = 7;
@ -1291,7 +1291,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
: -1));
h = GET_HASH_TABLE (eop);
eop = hash_lookup (h, make_number (reg[RRR]), NULL);
eop = hash_lookup (h, make_fixnum (reg[RRR]), NULL);
if (eop >= 0)
{
Lisp_Object opl;
@ -1318,14 +1318,14 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
i = CCL_DECODE_CHAR (reg[RRR], reg[rrr]);
h = GET_HASH_TABLE (eop);
eop = hash_lookup (h, make_number (i), NULL);
eop = hash_lookup (h, make_fixnum (i), NULL);
if (eop >= 0)
{
Lisp_Object opl;
opl = HASH_VALUE (h, eop);
if (! (INTEGERP (opl) && IN_INT_RANGE (XINT (opl))))
if (! (FIXNUMP (opl) && IN_INT_RANGE (XFIXNUM (opl))))
CCL_INVALID_CMD;
reg[RRR] = XINT (opl);
reg[RRR] = XFIXNUM (opl);
reg[7] = 1; /* r7 true for success */
}
else
@ -1340,7 +1340,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
ptrdiff_t size;
int fin_ic;
j = XINT (ccl_prog[ic++]); /* number of maps. */
j = XFIXNUM (ccl_prog[ic++]); /* number of maps. */
fin_ic = ic + j;
op = reg[rrr];
if ((j > reg[RRR]) && (j >= 0))
@ -1359,7 +1359,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
{
if (!VECTORP (Vcode_conversion_map_vector)) continue;
size = ASIZE (Vcode_conversion_map_vector);
point = XINT (ccl_prog[ic++]);
point = XFIXNUM (ccl_prog[ic++]);
if (! (0 <= point && point < size)) continue;
map = AREF (Vcode_conversion_map_vector, point);
@ -1375,19 +1375,19 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
/* check map type,
[STARTPOINT VAL1 VAL2 ...] or
[t ELEMENT STARTPOINT ENDPOINT] */
if (INTEGERP (content))
if (FIXNUMP (content))
{
point = XINT (content);
point = XFIXNUM (content);
if (!(point <= op && op - point + 1 < size)) continue;
content = AREF (map, op - point + 1);
}
else if (EQ (content, Qt))
{
if (size != 4) continue;
if (INTEGERP (AREF (map, 2))
&& XINT (AREF (map, 2)) <= op
&& INTEGERP (AREF (map, 3))
&& op < XINT (AREF (map, 3)))
if (FIXNUMP (AREF (map, 2))
&& XFIXNUM (AREF (map, 2)) <= op
&& FIXNUMP (AREF (map, 3))
&& op < XFIXNUM (AREF (map, 3)))
content = AREF (map, 1);
else
continue;
@ -1397,10 +1397,10 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
if (NILP (content))
continue;
else if (INTEGERP (content) && IN_INT_RANGE (XINT (content)))
else if (FIXNUMP (content) && IN_INT_RANGE (XFIXNUM (content)))
{
reg[RRR] = i;
reg[rrr] = XINT (content);
reg[rrr] = XFIXNUM (content);
break;
}
else if (EQ (content, Qt) || EQ (content, Qlambda))
@ -1412,11 +1412,11 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
{
attrib = XCAR (content);
value = XCDR (content);
if (! (INTEGERP (attrib) && INTEGERP (value)
&& IN_INT_RANGE (XINT (value))))
if (! (FIXNUMP (attrib) && FIXNUMP (value)
&& IN_INT_RANGE (XFIXNUM (value))))
continue;
reg[RRR] = i;
reg[rrr] = XINT (value);
reg[rrr] = XFIXNUM (value);
break;
}
else if (SYMBOLP (content))
@ -1453,7 +1453,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
stack_idx_of_map_multiple = 0;
/* Get number of maps and separators. */
map_set_rest_length = XINT (ccl_prog[ic++]);
map_set_rest_length = XFIXNUM (ccl_prog[ic++]);
fin_ic = ic + map_set_rest_length;
op = reg[rrr];
@ -1524,7 +1524,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
do {
for (;map_set_rest_length > 0;i++, ic++, map_set_rest_length--)
{
point = XINT (ccl_prog[ic]);
point = XFIXNUM (ccl_prog[ic]);
if (point < 0)
{
/* +1 is for including separator. */
@ -1554,19 +1554,19 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
/* check map type,
[STARTPOINT VAL1 VAL2 ...] or
[t ELEMENT STARTPOINT ENDPOINT] */
if (INTEGERP (content))
if (FIXNUMP (content))
{
point = XINT (content);
point = XFIXNUM (content);
if (!(point <= op && op - point + 1 < size)) continue;
content = AREF (map, op - point + 1);
}
else if (EQ (content, Qt))
{
if (size != 4) continue;
if (INTEGERP (AREF (map, 2))
&& XINT (AREF (map, 2)) <= op
&& INTEGERP (AREF (map, 3))
&& op < XINT (AREF (map, 3)))
if (FIXNUMP (AREF (map, 2))
&& XFIXNUM (AREF (map, 2)) <= op
&& FIXNUMP (AREF (map, 3))
&& op < XFIXNUM (AREF (map, 3)))
content = AREF (map, 1);
else
continue;
@ -1578,9 +1578,9 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
continue;
reg[RRR] = i;
if (INTEGERP (content) && IN_INT_RANGE (XINT (content)))
if (FIXNUMP (content) && IN_INT_RANGE (XFIXNUM (content)))
{
op = XINT (content);
op = XFIXNUM (content);
i += map_set_rest_length - 1;
ic += map_set_rest_length - 1;
POP_MAPPING_STACK (map_set_rest_length, reg[rrr]);
@ -1590,10 +1590,10 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
{
attrib = XCAR (content);
value = XCDR (content);
if (! (INTEGERP (attrib) && INTEGERP (value)
&& IN_INT_RANGE (XINT (value))))
if (! (FIXNUMP (attrib) && FIXNUMP (value)
&& IN_INT_RANGE (XFIXNUM (value))))
continue;
op = XINT (value);
op = XFIXNUM (value);
i += map_set_rest_length - 1;
ic += map_set_rest_length - 1;
POP_MAPPING_STACK (map_set_rest_length, reg[rrr]);
@ -1639,7 +1639,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
{
Lisp_Object map, attrib, value, content;
int point;
j = XINT (ccl_prog[ic++]); /* map_id */
j = XFIXNUM (ccl_prog[ic++]); /* map_id */
op = reg[rrr];
if (! (VECTORP (Vcode_conversion_map_vector)
&& j < ASIZE (Vcode_conversion_map_vector)))
@ -1656,29 +1656,29 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
map = XCDR (map);
if (! (VECTORP (map)
&& 0 < ASIZE (map)
&& INTEGERP (AREF (map, 0))
&& XINT (AREF (map, 0)) <= op
&& op - XINT (AREF (map, 0)) + 1 < ASIZE (map)))
&& FIXNUMP (AREF (map, 0))
&& XFIXNUM (AREF (map, 0)) <= op
&& op - XFIXNUM (AREF (map, 0)) + 1 < ASIZE (map)))
{
reg[RRR] = -1;
break;
}
point = op - XINT (AREF (map, 0)) + 1;
point = op - XFIXNUM (AREF (map, 0)) + 1;
reg[RRR] = 0;
content = AREF (map, point);
if (NILP (content))
reg[RRR] = -1;
else if (TYPE_RANGED_INTEGERP (int, content))
reg[rrr] = XINT (content);
else if (TYPE_RANGED_FIXNUMP (int, content))
reg[rrr] = XFIXNUM (content);
else if (EQ (content, Qt));
else if (CONSP (content))
{
attrib = XCAR (content);
value = XCDR (content);
if (!INTEGERP (attrib)
|| !TYPE_RANGED_INTEGERP (int, value))
if (!FIXNUMP (attrib)
|| !TYPE_RANGED_FIXNUMP (int, value))
continue;
reg[rrr] = XINT (value);
reg[rrr] = XFIXNUM (value);
break;
}
else if (SYMBOLP (content))
@ -1809,7 +1809,7 @@ resolve_symbol_ccl_program (Lisp_Object ccl)
for (i = 0; i < veclen; i++)
{
contents = AREF (result, i);
if (TYPE_RANGED_INTEGERP (int, contents))
if (TYPE_RANGED_FIXNUMP (int, contents))
continue;
else if (CONSP (contents)
&& SYMBOLP (XCAR (contents))
@ -1819,7 +1819,7 @@ resolve_symbol_ccl_program (Lisp_Object ccl)
(SYMBOL . PROPERTY). (get SYMBOL PROPERTY) should give
an index number. */
val = Fget (XCAR (contents), XCDR (contents));
if (RANGED_INTEGERP (0, val, INT_MAX))
if (RANGED_FIXNUMP (0, val, INT_MAX))
ASET (result, i, val);
else
unresolved = 1;
@ -1831,17 +1831,17 @@ resolve_symbol_ccl_program (Lisp_Object ccl)
may lead to a bug if, for instance, a translation table
and a code conversion map have the same name. */
val = Fget (contents, Qtranslation_table_id);
if (RANGED_INTEGERP (0, val, INT_MAX))
if (RANGED_FIXNUMP (0, val, INT_MAX))
ASET (result, i, val);
else
{
val = Fget (contents, Qcode_conversion_map_id);
if (RANGED_INTEGERP (0, val, INT_MAX))
if (RANGED_FIXNUMP (0, val, INT_MAX))
ASET (result, i, val);
else
{
val = Fget (contents, Qccl_program_idx);
if (RANGED_INTEGERP (0, val, INT_MAX))
if (RANGED_FIXNUMP (0, val, INT_MAX))
ASET (result, i, val);
else
unresolved = 1;
@ -1852,8 +1852,8 @@ resolve_symbol_ccl_program (Lisp_Object ccl)
return Qnil;
}
if (! (0 <= XINT (AREF (result, CCL_HEADER_BUF_MAG))
&& ASCENDING_ORDER (0, XINT (AREF (result, CCL_HEADER_EOF)),
if (! (0 <= XFIXNUM (AREF (result, CCL_HEADER_BUF_MAG))
&& ASCENDING_ORDER (0, XFIXNUM (AREF (result, CCL_HEADER_EOF)),
ASIZE (ccl))))
return Qnil;
@ -1881,15 +1881,15 @@ ccl_get_compiled_code (Lisp_Object ccl_prog, ptrdiff_t *idx)
return Qnil;
val = Fget (ccl_prog, Qccl_program_idx);
if (! NATNUMP (val)
|| XINT (val) >= ASIZE (Vccl_program_table))
if (! FIXNATP (val)
|| XFIXNUM (val) >= ASIZE (Vccl_program_table))
return Qnil;
slot = AREF (Vccl_program_table, XINT (val));
slot = AREF (Vccl_program_table, XFIXNUM (val));
if (! VECTORP (slot)
|| ASIZE (slot) != 4
|| ! VECTORP (AREF (slot, 1)))
return Qnil;
*idx = XINT (val);
*idx = XFIXNUM (val);
if (NILP (AREF (slot, 2)))
{
val = resolve_symbol_ccl_program (AREF (slot, 1));
@ -1920,8 +1920,8 @@ setup_ccl_program (struct ccl_program *ccl, Lisp_Object ccl_prog)
vp = XVECTOR (ccl_prog);
ccl->size = vp->header.size;
ccl->prog = vp->contents;
ccl->eof_ic = XINT (vp->contents[CCL_HEADER_EOF]);
ccl->buf_magnification = XINT (vp->contents[CCL_HEADER_BUF_MAG]);
ccl->eof_ic = XFIXNUM (vp->contents[CCL_HEADER_EOF]);
ccl->buf_magnification = XFIXNUM (vp->contents[CCL_HEADER_BUF_MAG]);
if (ccl->idx >= 0)
{
Lisp_Object slot;
@ -1956,8 +1956,8 @@ See the documentation of `define-ccl-program' for the detail of CCL program. */
return Qnil;
val = Fget (object, Qccl_program_idx);
return ((! NATNUMP (val)
|| XINT (val) >= ASIZE (Vccl_program_table))
return ((! FIXNATP (val)
|| XFIXNUM (val) >= ASIZE (Vccl_program_table))
? Qnil : Qt);
}
@ -1990,8 +1990,8 @@ programs. */)
error ("Length of vector REGISTERS is not 8");
for (i = 0; i < 8; i++)
ccl.reg[i] = (TYPE_RANGED_INTEGERP (int, AREF (reg, i))
? XINT (AREF (reg, i))
ccl.reg[i] = (TYPE_RANGED_FIXNUMP (int, AREF (reg, i))
? XFIXNUM (AREF (reg, i))
: 0);
ccl_driver (&ccl, NULL, NULL, 0, 0, Qnil);
@ -2000,7 +2000,7 @@ programs. */)
error ("Error in CCL program at %dth code", ccl.ic);
for (i = 0; i < 8; i++)
ASET (reg, i, make_number (ccl.reg[i]));
ASET (reg, i, make_fixnum (ccl.reg[i]));
return Qnil;
}
@ -2058,13 +2058,13 @@ usage: (ccl-execute-on-string CCL-PROGRAM STATUS STRING &optional CONTINUE UNIBY
for (i = 0; i < 8; i++)
{
if (NILP (AREF (status, i)))
ASET (status, i, make_number (0));
if (TYPE_RANGED_INTEGERP (int, AREF (status, i)))
ccl.reg[i] = XINT (AREF (status, i));
ASET (status, i, make_fixnum (0));
if (TYPE_RANGED_FIXNUMP (int, AREF (status, i)))
ccl.reg[i] = XFIXNUM (AREF (status, i));
}
if (INTEGERP (AREF (status, i)))
if (FIXNUMP (AREF (status, i)))
{
i = XFASTINT (AREF (status, 8));
i = XFIXNAT (AREF (status, 8));
if (ccl.ic < i && i < ccl.size)
ccl.ic = i;
}
@ -2139,8 +2139,8 @@ usage: (ccl-execute-on-string CCL-PROGRAM STATUS STRING &optional CONTINUE UNIBY
error ("CCL program interrupted at %dth code", ccl.ic);
for (i = 0; i < 8; i++)
ASET (status, i, make_number (ccl.reg[i]));
ASET (status, 8, make_number (ccl.ic));
ASET (status, i, make_fixnum (ccl.reg[i]));
ASET (status, 8, make_fixnum (ccl.ic));
val = make_specified_string ((const char *) outbuf, produced_chars,
outp - outbuf, NILP (unibyte_p));
@ -2193,7 +2193,7 @@ Return index number of the registered CCL program. */)
ASET (slot, 1, ccl_prog);
ASET (slot, 2, resolved);
ASET (slot, 3, Qt);
return make_number (idx);
return make_fixnum (idx);
}
}
@ -2211,8 +2211,8 @@ Return index number of the registered CCL program. */)
ASET (Vccl_program_table, idx, elt);
}
Fput (name, Qccl_program_idx, make_number (idx));
return make_number (idx);
Fput (name, Qccl_program_idx, make_fixnum (idx));
return make_fixnum (idx);
}
/* Register code conversion map.
@ -2251,7 +2251,7 @@ Return index number of the registered map. */)
if (EQ (symbol, XCAR (slot)))
{
idx = make_number (i);
idx = make_fixnum (i);
XSETCDR (slot, map);
Fput (symbol, Qcode_conversion_map, map);
Fput (symbol, Qcode_conversion_map_id, idx);
@ -2263,7 +2263,7 @@ Return index number of the registered map. */)
Vcode_conversion_map_vector = larger_vector (Vcode_conversion_map_vector,
1, -1);
idx = make_number (i);
idx = make_fixnum (i);
Fput (symbol, Qcode_conversion_map, map);
Fput (symbol, Qcode_conversion_map_id, idx);
ASET (Vcode_conversion_map_vector, i, Fcons (symbol, map));
@ -2275,7 +2275,7 @@ void
syms_of_ccl (void)
{
staticpro (&Vccl_program_table);
Vccl_program_table = Fmake_vector (make_number (32), Qnil);
Vccl_program_table = Fmake_vector (make_fixnum (32), Qnil);
DEFSYM (Qccl, "ccl");
DEFSYM (Qcclp, "cclp");
@ -2291,7 +2291,7 @@ syms_of_ccl (void)
DEFVAR_LISP ("code-conversion-map-vector", Vcode_conversion_map_vector,
doc: /* Vector of code conversion maps. */);
Vcode_conversion_map_vector = Fmake_vector (make_number (16), Qnil);
Vcode_conversion_map_vector = Fmake_vector (make_fixnum (16), Qnil);
DEFVAR_LISP ("font-ccl-encoder-alist", Vfont_ccl_encoder_alist,
doc: /* Alist of fontname patterns vs corresponding CCL program.

84
src/character.c
View file

@ -207,7 +207,7 @@ translate_char (Lisp_Object table, int c)
ch = CHAR_TABLE_REF (table, c);
if (CHARACTERP (ch))
c = XINT (ch);
c = XFIXNUM (ch);
}
else
{
@ -234,7 +234,7 @@ DEFUN ("max-char", Fmax_char, Smax_char, 0, 0, 0,
attributes: const)
(void)
{
return make_number (MAX_CHAR);
return make_fixnum (MAX_CHAR);
}
DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte,
@ -245,11 +245,11 @@ DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte,
int c;
CHECK_CHARACTER (ch);
c = XFASTINT (ch);
c = XFIXNAT (ch);
if (c >= 0x100)
error ("Not a unibyte character: %d", c);
MAKE_CHAR_MULTIBYTE (c);
return make_number (c);
return make_fixnum (c);
}
DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte,
@ -261,7 +261,7 @@ If the multibyte character does not represent a byte, return -1. */)
int cm;
CHECK_CHARACTER (ch);
cm = XFASTINT (ch);
cm = XFIXNAT (ch);
if (cm < 256)
/* Can't distinguish a byte read from a unibyte buffer from
a latin1 char, so let's let it slide. */
@ -269,7 +269,7 @@ If the multibyte character does not represent a byte, return -1. */)
else
{
int cu = CHAR_TO_BYTE_SAFE (cm);
return make_number (cu);
return make_fixnum (cu);
}
}
@ -294,7 +294,7 @@ char_width (int c, struct Lisp_Char_Table *dp)
if (GLYPH_CODE_P (ch))
c = GLYPH_CODE_CHAR (ch);
else if (CHARACTERP (ch))
c = XFASTINT (ch);
c = XFIXNUM (ch);
if (c >= 0)
{
int w = CHARACTER_WIDTH (c);
@ -318,9 +318,9 @@ usage: (char-width CHAR) */)
ptrdiff_t width;
CHECK_CHARACTER (ch);
c = XINT (ch);
c = XFIXNUM (ch);
width = char_width (c, buffer_display_table ());
return make_number (width);
return make_fixnum (width);
}
/* Return width of string STR of length LEN when displayed in the
@ -861,7 +861,7 @@ usage: (string &rest CHARACTERS) */)
for (i = 0; i < n; i++)
{
CHECK_CHARACTER (args[i]);
c = XINT (args[i]);
c = XFIXNUM (args[i]);
p += CHAR_STRING (c, p);
}
@ -884,7 +884,7 @@ usage: (unibyte-string &rest BYTES) */)
for (i = 0; i < n; i++)
{
CHECK_RANGED_INTEGER (args[i], 0, 255);
*p++ = XINT (args[i]);
*p++ = XFIXNUM (args[i]);
}
str = make_string_from_bytes ((char *) buf, n, p - buf);
@ -902,9 +902,9 @@ usage: (char-resolve-modifiers CHAR) */)
{
EMACS_INT c;
CHECK_NUMBER (character);
c = XINT (character);
return make_number (char_resolve_modifier_mask (c));
CHECK_FIXNUM (character);
c = XFIXNUM (character);
return make_fixnum (char_resolve_modifier_mask (c));
}
DEFUN ("get-byte", Fget_byte, Sget_byte, 0, 2, 0,
@ -931,14 +931,14 @@ character is not ASCII nor 8-bit character, an error is signaled. */)
}
else
{
CHECK_NUMBER_COERCE_MARKER (position);
if (XINT (position) < BEGV || XINT (position) >= ZV)
args_out_of_range_3 (position, make_number (BEGV), make_number (ZV));
pos = XFASTINT (position);
CHECK_FIXNUM_COERCE_MARKER (position);
if (XFIXNUM (position) < BEGV || XFIXNUM (position) >= ZV)
args_out_of_range_3 (position, make_fixnum (BEGV), make_fixnum (ZV));
pos = XFIXNAT (position);
p = CHAR_POS_ADDR (pos);
}
if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
return make_number (*p);
return make_fixnum (*p);
}
else
{
@ -949,21 +949,21 @@ character is not ASCII nor 8-bit character, an error is signaled. */)
}
else
{
CHECK_NATNUM (position);
if (XINT (position) >= SCHARS (string))
CHECK_FIXNAT (position);
if (XFIXNUM (position) >= SCHARS (string))
args_out_of_range (string, position);
pos = XFASTINT (position);
pos = XFIXNAT (position);
p = SDATA (string) + string_char_to_byte (string, pos);
}
if (! STRING_MULTIBYTE (string))
return make_number (*p);
return make_fixnum (*p);
}
c = STRING_CHAR (p);
if (CHAR_BYTE8_P (c))
c = CHAR_TO_BYTE8 (c);
else if (! ASCII_CHAR_P (c))
error ("Not an ASCII nor an 8-bit character: %d", c);
return make_number (c);
return make_fixnum (c);
}
/* Return true if C is an alphabetic character. */
@ -971,9 +971,9 @@ bool
alphabeticp (int c)
{
Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
if (! INTEGERP (category))
if (! FIXNUMP (category))
return false;
EMACS_INT gen_cat = XINT (category);
EMACS_INT gen_cat = XFIXNUM (category);
/* See UTS #18. There are additional characters that should be
here, those designated as Other_uppercase, Other_lowercase,
@ -994,9 +994,9 @@ bool
alphanumericp (int c)
{
Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
if (! INTEGERP (category))
if (! FIXNUMP (category))
return false;
EMACS_INT gen_cat = XINT (category);
EMACS_INT gen_cat = XFIXNUM (category);
/* See UTS #18. Same comment as for alphabeticp applies. FIXME. */
return (gen_cat == UNICODE_CATEGORY_Lu
@ -1016,9 +1016,9 @@ bool
graphicp (int c)
{
Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
if (! INTEGERP (category))
if (! FIXNUMP (category))
return false;
EMACS_INT gen_cat = XINT (category);
EMACS_INT gen_cat = XFIXNUM (category);
/* See UTS #18. */
return (!(gen_cat == UNICODE_CATEGORY_Zs /* space separator */
@ -1034,9 +1034,9 @@ bool
printablep (int c)
{
Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
if (! INTEGERP (category))
if (! FIXNUMP (category))
return false;
EMACS_INT gen_cat = XINT (category);
EMACS_INT gen_cat = XFIXNUM (category);
/* See UTS #18. */
return (!(gen_cat == UNICODE_CATEGORY_Cc /* control */
@ -1050,10 +1050,10 @@ bool
blankp (int c)
{
Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
if (! INTEGERP (category))
if (! FIXNUMP (category))
return false;
return XINT (category) == UNICODE_CATEGORY_Zs; /* separator, space */
return XFIXNUM (category) == UNICODE_CATEGORY_Zs; /* separator, space */
}
@ -1124,7 +1124,7 @@ syms_of_character (void)
Vector recording all translation tables ever defined.
Each element is a pair (SYMBOL . TABLE) relating the table to the
symbol naming it. The ID of a translation table is an index into this vector. */);
Vtranslation_table_vector = Fmake_vector (make_number (16), Qnil);
Vtranslation_table_vector = Fmake_vector (make_fixnum (16), Qnil);
DEFVAR_LISP ("auto-fill-chars", Vauto_fill_chars,
doc: /*
@ -1137,26 +1137,26 @@ Such characters have value t in this table. */);
DEFVAR_LISP ("char-width-table", Vchar_width_table,
doc: /*
A char-table for width (columns) of each character. */);
Vchar_width_table = Fmake_char_table (Qnil, make_number (1));
char_table_set_range (Vchar_width_table, 0x80, 0x9F, make_number (4));
Vchar_width_table = Fmake_char_table (Qnil, make_fixnum (1));
char_table_set_range (Vchar_width_table, 0x80, 0x9F, make_fixnum (4));
char_table_set_range (Vchar_width_table, MAX_5_BYTE_CHAR + 1, MAX_CHAR,
make_number (4));
make_fixnum (4));
DEFVAR_LISP ("printable-chars", Vprintable_chars,
doc: /* A char-table for each printable character. */);
Vprintable_chars = Fmake_char_table (Qnil, Qnil);
Fset_char_table_range (Vprintable_chars,
Fcons (make_number (32), make_number (126)), Qt);
Fcons (make_fixnum (32), make_fixnum (126)), Qt);
Fset_char_table_range (Vprintable_chars,
Fcons (make_number (160),
make_number (MAX_5_BYTE_CHAR)), Qt);
Fcons (make_fixnum (160),
make_fixnum (MAX_5_BYTE_CHAR)), Qt);
DEFVAR_LISP ("char-script-table", Vchar_script_table,
doc: /* Char table of script symbols.
It has one extra slot whose value is a list of script symbols. */);
DEFSYM (Qchar_script_table, "char-script-table");
Fput (Qchar_script_table, Qchar_table_extra_slots, make_number (1));
Fput (Qchar_script_table, Qchar_table_extra_slots, make_fixnum (1));
Vchar_script_table = Fmake_char_table (Qchar_script_table, Qnil);
DEFVAR_LISP ("script-representative-chars", Vscript_representative_chars,

8
src/character.h
View file

@ -123,7 +123,7 @@ enum
#define MAX_MULTIBYTE_LENGTH 5
/* Nonzero iff X is a character. */
#define CHARACTERP(x) (NATNUMP (x) && XFASTINT (x) <= MAX_CHAR)
#define CHARACTERP(x) (FIXNATP (x) && XFIXNAT (x) <= MAX_CHAR)
/* Nonzero iff C is valid as a character code. */
#define CHAR_VALID_P(c) UNSIGNED_CMP (c, <=, MAX_CHAR)
@ -559,7 +559,7 @@ enum
/* Return a non-outlandish value for the tab width. */
#define SANE_TAB_WIDTH(buf) \
sanitize_tab_width (XFASTINT (BVAR (buf, tab_width)))
sanitize_tab_width (XFIXNAT (BVAR (buf, tab_width)))
INLINE int
sanitize_tab_width (EMACS_INT width)
{
@ -595,7 +595,7 @@ sanitize_char_width (EMACS_INT width)
#define CHARACTER_WIDTH(c) \
(ASCII_CHAR_P (c) \
? ASCII_CHAR_WIDTH (c) \
: sanitize_char_width (XINT (CHAR_TABLE_REF (Vchar_width_table, c))))
: sanitize_char_width (XFIXNUM (CHAR_TABLE_REF (Vchar_width_table, c))))
/* If C is a variation selector, return the index of the
variation selector (1..256). Otherwise, return 0. */
@ -700,7 +700,7 @@ char_table_translate (Lisp_Object obj, int ch)
eassert (CHAR_VALID_P (ch));
eassert (CHAR_TABLE_P (obj));
obj = CHAR_TABLE_REF (obj, ch);
return CHARACTERP (obj) ? XINT (obj) : ch;
return CHARACTERP (obj) ? XFIXNUM (obj) : ch;
}
#if defined __GNUC__ && !defined __STRICT_ANSI__

284
src/charset.c
View file

@ -261,7 +261,7 @@ load_charset_map (struct charset *charset, struct charset_map_entries *entries,
{
int n = CODE_POINT_TO_INDEX (charset, max_code) + 1;
vec = Fmake_vector (make_number (n), make_number (-1));
vec = Fmake_vector (make_fixnum (n), make_fixnum (-1));
set_charset_attr (charset, charset_decoder, vec);
}
else
@ -340,12 +340,12 @@ load_charset_map (struct charset *charset, struct charset_map_entries *entries,
{
if (charset->method == CHARSET_METHOD_MAP)
for (; from_index < lim_index; from_index++, from_c++)
ASET (vec, from_index, make_number (from_c));
ASET (vec, from_index, make_fixnum (from_c));
else
for (; from_index < lim_index; from_index++, from_c++)
CHAR_TABLE_SET (Vchar_unify_table,
CHARSET_CODE_OFFSET (charset) + from_index,
make_number (from_c));
make_fixnum (from_c));
}
else if (control_flag == 2)
{
@ -357,13 +357,13 @@ load_charset_map (struct charset *charset, struct charset_map_entries *entries,
code = INDEX_TO_CODE_POINT (charset, code);
if (NILP (CHAR_TABLE_REF (table, from_c)))
CHAR_TABLE_SET (table, from_c, make_number (code));
CHAR_TABLE_SET (table, from_c, make_fixnum (code));
}
else
for (; from_index < lim_index; from_index++, from_c++)
{
if (NILP (CHAR_TABLE_REF (table, from_c)))
CHAR_TABLE_SET (table, from_c, make_number (from_index));
CHAR_TABLE_SET (table, from_c, make_fixnum (from_index));
}
}
else if (control_flag == 3)
@ -587,14 +587,14 @@ load_charset_map_from_vector (struct charset *charset, Lisp_Object vec, int cont
{
val2 = XCDR (val);
val = XCAR (val);
from = XFASTINT (val);
to = XFASTINT (val2);
from = XFIXNAT (val);
to = XFIXNAT (val2);
}
else
from = to = XFASTINT (val);
from = to = XFIXNAT (val);
val = AREF (vec, i + 1);
CHECK_NATNUM (val);
c = XFASTINT (val);
CHECK_FIXNAT (val);
c = XFIXNAT (val);
if (from < min_code || to > max_code || from > to || c > MAX_CHAR)
continue;
@ -675,11 +675,11 @@ map_charset_for_dump (void (*c_function) (Lisp_Object, Lisp_Object),
if (idx >= from_idx && idx <= to_idx)
{
if (NILP (XCAR (range)))
XSETCAR (range, make_number (c));
XSETCAR (range, make_fixnum (c));
}
else if (! NILP (XCAR (range)))
{
XSETCDR (range, make_number (c - 1));
XSETCDR (range, make_fixnum (c - 1));
if (c_function)
(*c_function) (arg, range);
else
@ -692,7 +692,7 @@ map_charset_for_dump (void (*c_function) (Lisp_Object, Lisp_Object),
{
if (! NILP (XCAR (range)))
{
XSETCDR (range, make_number (c));
XSETCDR (range, make_fixnum (c));
if (c_function)
(*c_function) (arg, range);
else
@ -734,7 +734,7 @@ map_charset_chars (void (*c_function)(Lisp_Object, Lisp_Object), Lisp_Object fun
map_charset_for_dump (c_function, function, arg, from, to);
}
range = Fcons (make_number (from_c), make_number (to_c));
range = Fcons (make_fixnum (from_c), make_fixnum (to_c));
if (NILP (function))
(*c_function) (arg, range);
else
@ -757,14 +757,14 @@ map_charset_chars (void (*c_function)(Lisp_Object, Lisp_Object), Lisp_Object fun
int offset;
subset_info = CHARSET_SUBSET (charset);
charset = CHARSET_FROM_ID (XFASTINT (AREF (subset_info, 0)));
offset = XINT (AREF (subset_info, 3));
charset = CHARSET_FROM_ID (XFIXNAT (AREF (subset_info, 0)));
offset = XFIXNUM (AREF (subset_info, 3));
from -= offset;
if (from < XFASTINT (AREF (subset_info, 1)))
from = XFASTINT (AREF (subset_info, 1));
if (from < XFIXNAT (AREF (subset_info, 1)))
from = XFIXNAT (AREF (subset_info, 1));
to -= offset;
if (to > XFASTINT (AREF (subset_info, 2)))
to = XFASTINT (AREF (subset_info, 2));
if (to > XFIXNAT (AREF (subset_info, 2)))
to = XFIXNAT (AREF (subset_info, 2));
map_charset_chars (c_function, function, arg, charset, from, to);
}
else /* i.e. CHARSET_METHOD_SUPERSET */
@ -777,8 +777,8 @@ map_charset_chars (void (*c_function)(Lisp_Object, Lisp_Object), Lisp_Object fun
int offset;
unsigned this_from, this_to;
charset = CHARSET_FROM_ID (XFASTINT (XCAR (XCAR (parents))));
offset = XINT (XCDR (XCAR (parents)));
charset = CHARSET_FROM_ID (XFIXNAT (XCAR (XCAR (parents))));
offset = XFIXNUM (XCDR (XCAR (parents)));
this_from = from > offset ? from - offset : 0;
this_to = to > offset ? to - offset : 0;
if (this_from < CHARSET_MIN_CODE (charset))
@ -811,7 +811,7 @@ range of code points (in CHARSET) of target characters. */)
from = CHARSET_MIN_CODE (cs);
else
{
from = XINT (from_code);
from = XFIXNUM (from_code);
if (from < CHARSET_MIN_CODE (cs))
from = CHARSET_MIN_CODE (cs);
}
@ -819,7 +819,7 @@ range of code points (in CHARSET) of target characters. */)
to = CHARSET_MAX_CODE (cs);
else
{
to = XINT (to_code);
to = XFIXNUM (to_code);
if (to > CHARSET_MAX_CODE (cs))
to = CHARSET_MAX_CODE (cs);
}
@ -854,9 +854,9 @@ usage: (define-charset-internal ...) */)
if (nargs != charset_arg_max)
Fsignal (Qwrong_number_of_arguments,
Fcons (intern ("define-charset-internal"),
make_number (nargs)));
make_fixnum (nargs)));
attrs = Fmake_vector (make_number (charset_attr_max), Qnil);
attrs = Fmake_vector (make_fixnum (charset_attr_max), Qnil);
CHECK_SYMBOL (args[charset_arg_name]);
ASET (attrs, charset_name, args[charset_arg_name]);
@ -867,12 +867,12 @@ usage: (define-charset-internal ...) */)
Lisp_Object min_byte_obj, max_byte_obj;
int min_byte, max_byte;
min_byte_obj = Faref (val, make_number (i * 2));
max_byte_obj = Faref (val, make_number (i * 2 + 1));
min_byte_obj = Faref (val, make_fixnum (i * 2));
max_byte_obj = Faref (val, make_fixnum (i * 2 + 1));
CHECK_RANGED_INTEGER (min_byte_obj, 0, 255);
min_byte = XINT (min_byte_obj);
min_byte = XFIXNUM (min_byte_obj);
CHECK_RANGED_INTEGER (max_byte_obj, min_byte, 255);
max_byte = XINT (max_byte_obj);
max_byte = XFIXNUM (max_byte_obj);
charset.code_space[i * 4] = min_byte;
charset.code_space[i * 4 + 1] = max_byte;
charset.code_space[i * 4 + 2] = max_byte - min_byte + 1;
@ -890,7 +890,7 @@ usage: (define-charset-internal ...) */)
else
{
CHECK_RANGED_INTEGER (val, 1, 4);
charset.dimension = XINT (val);
charset.dimension = XFIXNUM (val);
}
charset.code_linear_p
@ -970,10 +970,10 @@ usage: (define-charset-internal ...) */)
charset.iso_final = -1;
else
{
CHECK_NUMBER (val);
if (XINT (val) < '0' || XINT (val) > 127)
error ("Invalid iso-final-char: %"pI"d", XINT (val));
charset.iso_final = XINT (val);
CHECK_FIXNUM (val);
if (XFIXNUM (val) < '0' || XFIXNUM (val) > 127)
error ("Invalid iso-final-char: %"pI"d", XFIXNUM (val));
charset.iso_final = XFIXNUM (val);
}
val = args[charset_arg_iso_revision];
@ -982,7 +982,7 @@ usage: (define-charset-internal ...) */)
else
{
CHECK_RANGED_INTEGER (val, -1, 63);
charset.iso_revision = XINT (val);
charset.iso_revision = XFIXNUM (val);
}
val = args[charset_arg_emacs_mule_id];
@ -990,10 +990,10 @@ usage: (define-charset-internal ...) */)
charset.emacs_mule_id = -1;
else
{
CHECK_NATNUM (val);
if ((XINT (val) > 0 && XINT (val) <= 128) || XINT (val) >= 256)
error ("Invalid emacs-mule-id: %"pI"d", XINT (val));
charset.emacs_mule_id = XINT (val);
CHECK_FIXNAT (val);
if ((XFIXNUM (val) > 0 && XFIXNUM (val) <= 128) || XFIXNUM (val) >= 256)
error ("Invalid emacs-mule-id: %"pI"d", XFIXNUM (val));
charset.emacs_mule_id = XFIXNUM (val);
}
charset.ascii_compatible_p = ! NILP (args[charset_arg_ascii_compatible_p]);
@ -1010,7 +1010,7 @@ usage: (define-charset-internal ...) */)
CHECK_CHARACTER (val);
charset.method = CHARSET_METHOD_OFFSET;
charset.code_offset = XINT (val);
charset.code_offset = XFIXNUM (val);
i = CODE_POINT_TO_INDEX (&charset, charset.max_code);
if (MAX_CHAR - charset.code_offset < i)
@ -1043,14 +1043,14 @@ usage: (define-charset-internal ...) */)
val = args[charset_arg_subset];
parent = Fcar (val);
CHECK_CHARSET_GET_CHARSET (parent, parent_charset);
parent_min_code = Fnth (make_number (1), val);
CHECK_NATNUM (parent_min_code);
parent_max_code = Fnth (make_number (2), val);
CHECK_NATNUM (parent_max_code);
parent_code_offset = Fnth (make_number (3), val);
CHECK_NUMBER (parent_code_offset);
parent_min_code = Fnth (make_fixnum (1), val);
CHECK_FIXNAT (parent_min_code);
parent_max_code = Fnth (make_fixnum (2), val);
CHECK_FIXNAT (parent_max_code);
parent_code_offset = Fnth (make_fixnum (3), val);
CHECK_FIXNUM (parent_code_offset);
val = make_uninit_vector (4);
ASET (val, 0, make_number (parent_charset->id));
ASET (val, 0, make_fixnum (parent_charset->id));
ASET (val, 1, parent_min_code);
ASET (val, 2, parent_max_code);
ASET (val, 3, parent_code_offset);
@ -1089,14 +1089,14 @@ usage: (define-charset-internal ...) */)
cdr_part = XCDR (elt);
CHECK_CHARSET_GET_ID (car_part, this_id);
CHECK_TYPE_RANGED_INTEGER (int, cdr_part);
offset = XINT (cdr_part);
offset = XFIXNUM (cdr_part);
}
else
{
CHECK_CHARSET_GET_ID (elt, this_id);
offset = 0;
}
XSETCAR (val, Fcons (make_number (this_id), make_number (offset)));
XSETCAR (val, Fcons (make_fixnum (this_id), make_fixnum (offset)));
this_charset = CHARSET_FROM_ID (this_id);
if (charset.min_char > this_charset->min_char)
@ -1123,7 +1123,7 @@ usage: (define-charset-internal ...) */)
if (charset.hash_index >= 0)
{
new_definition_p = 0;
id = XFASTINT (CHARSET_SYMBOL_ID (args[charset_arg_name]));
id = XFIXNAT (CHARSET_SYMBOL_ID (args[charset_arg_name]));
set_hash_value_slot (hash_table, charset.hash_index, attrs);
}
else
@ -1158,7 +1158,7 @@ usage: (define-charset-internal ...) */)
new_definition_p = 1;
}
ASET (attrs, charset_id, make_number (id));
ASET (attrs, charset_id, make_fixnum (id));
charset.id = id;
charset_table[id] = charset;
@ -1174,7 +1174,7 @@ usage: (define-charset-internal ...) */)
charset.iso_final) = id;
if (new_definition_p)
Viso_2022_charset_list = nconc2 (Viso_2022_charset_list,
list1 (make_number (id)));
list1 (make_fixnum (id)));
if (ISO_CHARSET_TABLE (1, 0, 'J') == id)
charset_jisx0201_roman = id;
else if (ISO_CHARSET_TABLE (2, 0, '@') == id)
@ -1194,7 +1194,7 @@ usage: (define-charset-internal ...) */)
emacs_mule_bytes[charset.emacs_mule_id] = charset.dimension + 2;
if (new_definition_p)
Vemacs_mule_charset_list = nconc2 (Vemacs_mule_charset_list,
list1 (make_number (id)));
list1 (make_fixnum (id)));
}
if (new_definition_p)
@ -1202,29 +1202,29 @@ usage: (define-charset-internal ...) */)
Vcharset_list = Fcons (args[charset_arg_name], Vcharset_list);
if (charset.supplementary_p)
Vcharset_ordered_list = nconc2 (Vcharset_ordered_list,
list1 (make_number (id)));
list1 (make_fixnum (id)));
else
{
Lisp_Object tail;
for (tail = Vcharset_ordered_list; CONSP (tail); tail = XCDR (tail))
{
struct charset *cs = CHARSET_FROM_ID (XINT (XCAR (tail)));
struct charset *cs = CHARSET_FROM_ID (XFIXNUM (XCAR (tail)));
if (cs->supplementary_p)
break;
}
if (EQ (tail, Vcharset_ordered_list))
Vcharset_ordered_list = Fcons (make_number (id),
Vcharset_ordered_list = Fcons (make_fixnum (id),
Vcharset_ordered_list);
else if (NILP (tail))
Vcharset_ordered_list = nconc2 (Vcharset_ordered_list,
list1 (make_number (id)));
list1 (make_fixnum (id)));
else
{
val = Fcons (XCAR (tail), XCDR (tail));
XSETCDR (tail, val);
XSETCAR (tail, make_number (id));
XSETCAR (tail, make_fixnum (id));
}
}
charset_ordered_list_tick++;
@ -1254,22 +1254,22 @@ define_charset_internal (Lisp_Object name,
int i;
args[charset_arg_name] = name;
args[charset_arg_dimension] = make_number (dimension);
args[charset_arg_dimension] = make_fixnum (dimension);
val = make_uninit_vector (8);
for (i = 0; i < 8; i++)
ASET (val, i, make_number (code_space[i]));
ASET (val, i, make_fixnum (code_space[i]));
args[charset_arg_code_space] = val;
args[charset_arg_min_code] = make_number (min_code);
args[charset_arg_max_code] = make_number (max_code);
args[charset_arg_min_code] = make_fixnum (min_code);
args[charset_arg_max_code] = make_fixnum (max_code);
args[charset_arg_iso_final]
= (iso_final < 0 ? Qnil : make_number (iso_final));
args[charset_arg_iso_revision] = make_number (iso_revision);
= (iso_final < 0 ? Qnil : make_fixnum (iso_final));
args[charset_arg_iso_revision] = make_fixnum (iso_revision);
args[charset_arg_emacs_mule_id]
= (emacs_mule_id < 0 ? Qnil : make_number (emacs_mule_id));
= (emacs_mule_id < 0 ? Qnil : make_fixnum (emacs_mule_id));
args[charset_arg_ascii_compatible_p] = ascii_compatible ? Qt : Qnil;
args[charset_arg_supplementary_p] = supplementary ? Qt : Qnil;
args[charset_arg_invalid_code] = Qnil;
args[charset_arg_code_offset] = make_number (code_offset);
args[charset_arg_code_offset] = make_fixnum (code_offset);
args[charset_arg_map] = Qnil;
args[charset_arg_subset] = Qnil;
args[charset_arg_superset] = Qnil;
@ -1293,7 +1293,7 @@ define_charset_internal (Lisp_Object name,
args[charset_arg_code_offset]);
Fdefine_charset_internal (charset_arg_max, args);
return XINT (CHARSET_SYMBOL_ID (name));
return XFIXNUM (CHARSET_SYMBOL_ID (name));
}
@ -1396,19 +1396,19 @@ static bool
check_iso_charset_parameter (Lisp_Object dimension, Lisp_Object chars,
Lisp_Object final_char)
{
CHECK_NUMBER (dimension);
CHECK_NUMBER (chars);
CHECK_FIXNUM (dimension);
CHECK_FIXNUM (chars);
CHECK_CHARACTER (final_char);
if (! (1 <= XINT (dimension) && XINT (dimension) <= 3))
if (! (1 <= XFIXNUM (dimension) && XFIXNUM (dimension) <= 3))
error ("Invalid DIMENSION %"pI"d, it should be 1, 2, or 3",
XINT (dimension));
XFIXNUM (dimension));
bool chars_flag = XINT (chars) == 96;
if (! (chars_flag || XINT (chars) == 94))
error ("Invalid CHARS %"pI"d, it should be 94 or 96", XINT (chars));
bool chars_flag = XFIXNUM (chars) == 96;
if (! (chars_flag || XFIXNUM (chars) == 94))
error ("Invalid CHARS %"pI"d, it should be 94 or 96", XFIXNUM (chars));
int final_ch = XFASTINT (final_char);
int final_ch = XFIXNAT (final_char);
if (! ('0' <= final_ch && final_ch <= '~'))
error ("Invalid FINAL-CHAR `%c', it should be `0'..`~'", final_ch);
@ -1428,10 +1428,10 @@ return nil. */)
(Lisp_Object dimension, Lisp_Object chars)
{
bool chars_flag = check_iso_charset_parameter (dimension, chars,
make_number ('0'));
make_fixnum ('0'));
for (int final_char = '0'; final_char <= '?'; final_char++)
if (ISO_CHARSET_TABLE (XINT (dimension), chars_flag, final_char) < 0)
return make_number (final_char);
if (ISO_CHARSET_TABLE (XFIXNUM (dimension), chars_flag, final_char) < 0)
return make_fixnum (final_char);
return Qnil;
}
@ -1449,7 +1449,7 @@ if CHARSET is designated instead. */)
CHECK_CHARSET_GET_ID (charset, id);
bool chars_flag = check_iso_charset_parameter (dimension, chars, final_char);
ISO_CHARSET_TABLE (XINT (dimension), chars_flag, XFASTINT (final_char)) = id;
ISO_CHARSET_TABLE (XFIXNUM (dimension), chars_flag, XFIXNAT (final_char)) = id;
return Qnil;
}
@ -1550,8 +1550,8 @@ only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
bool multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
validate_region (&beg, &end);
from = XFASTINT (beg);
stop = to = XFASTINT (end);
from = XFIXNAT (beg);
stop = to = XFIXNAT (end);
if (from < GPT && GPT < to)
{
@ -1563,7 +1563,7 @@ only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
from_byte = CHAR_TO_BYTE (from);
charsets = Fmake_vector (make_number (charset_table_used), Qnil);
charsets = Fmake_vector (make_fixnum (charset_table_used), Qnil);
while (1)
{
find_charsets_in_text (BYTE_POS_ADDR (from_byte), stop - from,
@ -1600,7 +1600,7 @@ only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
CHECK_STRING (str);
charsets = Fmake_vector (make_number (charset_table_used), Qnil);
charsets = Fmake_vector (make_fixnum (charset_table_used), Qnil);
find_charsets_in_text (SDATA (str), SCHARS (str), SBYTES (str),
charsets, table,
STRING_MULTIBYTE (str));
@ -1621,8 +1621,8 @@ maybe_unify_char (int c, Lisp_Object val)
{
struct charset *charset;
if (INTEGERP (val))
return XFASTINT (val);
if (FIXNUMP (val))
return XFIXNAT (val);
if (NILP (val))
return c;
@ -1638,7 +1638,7 @@ maybe_unify_char (int c, Lisp_Object val)
{
val = CHAR_TABLE_REF (Vchar_unify_table, c);
if (! NILP (val))
c = XFASTINT (val);
c = XFIXNAT (val);
}
else
{
@ -1672,10 +1672,10 @@ decode_char (struct charset *charset, unsigned int code)
Lisp_Object subset_info;
subset_info = CHARSET_SUBSET (charset);
charset = CHARSET_FROM_ID (XFASTINT (AREF (subset_info, 0)));
code -= XINT (AREF (subset_info, 3));
if (code < XFASTINT (AREF (subset_info, 1))
|| code > XFASTINT (AREF (subset_info, 2)))
charset = CHARSET_FROM_ID (XFIXNAT (AREF (subset_info, 0)));
code -= XFIXNUM (AREF (subset_info, 3));
if (code < XFIXNAT (AREF (subset_info, 1))
|| code > XFIXNAT (AREF (subset_info, 2)))
c = -1;
else
c = DECODE_CHAR (charset, code);
@ -1688,8 +1688,8 @@ decode_char (struct charset *charset, unsigned int code)
c = -1;
for (; CONSP (parents); parents = XCDR (parents))
{
int id = XINT (XCAR (XCAR (parents)));
int code_offset = XINT (XCDR (XCAR (parents)));
int id = XFIXNUM (XCAR (XCAR (parents)));
int code_offset = XFIXNUM (XCDR (XCAR (parents)));
unsigned this_code = code - code_offset;
charset = CHARSET_FROM_ID (id);
@ -1714,7 +1714,7 @@ decode_char (struct charset *charset, unsigned int code)
decoder = CHARSET_DECODER (charset);
}
if (VECTORP (decoder))
c = XINT (AREF (decoder, char_index));
c = XFIXNUM (AREF (decoder, char_index));
else
c = GET_TEMP_CHARSET_WORK_DECODER (char_index);
}
@ -1762,8 +1762,8 @@ encode_char (struct charset *charset, int c)
{
Lisp_Object deunified = CHAR_TABLE_REF (deunifier, c);
if (INTEGERP (deunified))
code_index = XINT (deunified);
if (FIXNUMP (deunified))
code_index = XFIXNUM (deunified);
}
else
{
@ -1779,13 +1779,13 @@ encode_char (struct charset *charset, int c)
struct charset *this_charset;
subset_info = CHARSET_SUBSET (charset);
this_charset = CHARSET_FROM_ID (XFASTINT (AREF (subset_info, 0)));
this_charset = CHARSET_FROM_ID (XFIXNAT (AREF (subset_info, 0)));
code = ENCODE_CHAR (this_charset, c);
if (code == CHARSET_INVALID_CODE (this_charset)
|| code < XFASTINT (AREF (subset_info, 1))
|| code > XFASTINT (AREF (subset_info, 2)))
|| code < XFIXNAT (AREF (subset_info, 1))
|| code > XFIXNAT (AREF (subset_info, 2)))
return CHARSET_INVALID_CODE (charset);
code += XINT (AREF (subset_info, 3));
code += XFIXNUM (AREF (subset_info, 3));
return code;
}
@ -1796,8 +1796,8 @@ encode_char (struct charset *charset, int c)
parents = CHARSET_SUPERSET (charset);
for (; CONSP (parents); parents = XCDR (parents))
{
int id = XINT (XCAR (XCAR (parents)));
int code_offset = XINT (XCDR (XCAR (parents)));
int id = XFIXNUM (XCAR (XCAR (parents)));
int code_offset = XFIXNUM (XCDR (XCAR (parents)));
struct charset *this_charset = CHARSET_FROM_ID (id);
code = ENCODE_CHAR (this_charset, c);
@ -1827,7 +1827,7 @@ encode_char (struct charset *charset, int c)
val = CHAR_TABLE_REF (encoder, c);
if (NILP (val))
return CHARSET_INVALID_CODE (charset);
code = XINT (val);
code = XFIXNUM (val);
if (! CHARSET_COMPACT_CODES_P (charset))
code = INDEX_TO_CODE_POINT (charset, code);
}
@ -1863,7 +1863,7 @@ CODE-POINT may be a cons (HIGHER-16-BIT-VALUE . LOWER-16-BIT-VALUE). */)
code = cons_to_unsigned (code_point, UINT_MAX);
charsetp = CHARSET_FROM_ID (id);
c = DECODE_CHAR (charsetp, code);
return (c >= 0 ? make_number (c) : Qnil);
return (c >= 0 ? make_fixnum (c) : Qnil);
}
@ -1878,7 +1878,7 @@ Return nil if CHARSET doesn't include CH. */)
CHECK_CHARSET_GET_ID (charset, id);
CHECK_CHARACTER (ch);
c = XFASTINT (ch);
c = XFIXNAT (ch);
charsetp = CHARSET_FROM_ID (id);
code = ENCODE_CHAR (charsetp, c);
if (code == CHARSET_INVALID_CODE (charsetp))
@ -1910,10 +1910,10 @@ is specified. */)
? 0 : CHARSET_MIN_CODE (charsetp));
else
{
CHECK_NATNUM (code1);
if (XFASTINT (code1) >= 0x100)
args_out_of_range (make_number (0xFF), code1);
code = XFASTINT (code1);
CHECK_FIXNAT (code1);
if (XFIXNAT (code1) >= 0x100)
args_out_of_range (make_fixnum (0xFF), code1);
code = XFIXNAT (code1);
if (dimension > 1)
{
@ -1922,10 +1922,10 @@ is specified. */)
code |= charsetp->code_space[(dimension - 2) * 4];
else
{
CHECK_NATNUM (code2);
if (XFASTINT (code2) >= 0x100)
args_out_of_range (make_number (0xFF), code2);
code |= XFASTINT (code2);
CHECK_FIXNAT (code2);
if (XFIXNAT (code2) >= 0x100)
args_out_of_range (make_fixnum (0xFF), code2);
code |= XFIXNAT (code2);
}
if (dimension > 2)
@ -1935,10 +1935,10 @@ is specified. */)
code |= charsetp->code_space[(dimension - 3) * 4];
else
{
CHECK_NATNUM (code3);
if (XFASTINT (code3) >= 0x100)
args_out_of_range (make_number (0xFF), code3);
code |= XFASTINT (code3);
CHECK_FIXNAT (code3);
if (XFIXNAT (code3) >= 0x100)
args_out_of_range (make_fixnum (0xFF), code3);
code |= XFIXNAT (code3);
}
if (dimension > 3)
@ -1948,10 +1948,10 @@ is specified. */)
code |= charsetp->code_space[0];
else
{
CHECK_NATNUM (code4);
if (XFASTINT (code4) >= 0x100)
args_out_of_range (make_number (0xFF), code4);
code |= XFASTINT (code4);
CHECK_FIXNAT (code4);
if (XFIXNAT (code4) >= 0x100)
args_out_of_range (make_fixnum (0xFF), code4);
code |= XFIXNAT (code4);
}
}
}
@ -1963,7 +1963,7 @@ is specified. */)
c = DECODE_CHAR (charsetp, code);
if (c < 0)
error ("Invalid code(s)");
return make_number (c);
return make_fixnum (c);
}
@ -1983,7 +1983,7 @@ char_charset (int c, Lisp_Object charset_list, unsigned int *code_return)
while (CONSP (charset_list))
{
struct charset *charset = CHARSET_FROM_ID (XINT (XCAR (charset_list)));
struct charset *charset = CHARSET_FROM_ID (XFIXNUM (XCAR (charset_list)));
unsigned code = ENCODE_CHAR (charset, c);
if (code != CHARSET_INVALID_CODE (charset))
@ -2018,7 +2018,7 @@ CH in the charset. */)
Lisp_Object val;
CHECK_CHARACTER (ch);
c = XFASTINT (ch);
c = XFIXNAT (ch);
charset = CHAR_CHARSET (c);
if (! charset)
emacs_abort ();
@ -2028,7 +2028,7 @@ CH in the charset. */)
dimension = CHARSET_DIMENSION (charset);
for (val = Qnil; dimension > 0; dimension--)
{
val = Fcons (make_number (code & 0xFF), val);
val = Fcons (make_fixnum (code & 0xFF), val);
code >>= 8;
}
return Fcons (CHARSET_NAME (charset), val);
@ -2048,12 +2048,12 @@ that case, find the charset from what supported by that coding system. */)
CHECK_CHARACTER (ch);
if (NILP (restriction))
charset = CHAR_CHARSET (XINT (ch));
charset = CHAR_CHARSET (XFIXNUM (ch));
else
{
if (CONSP (restriction))
{
int c = XFASTINT (ch);
int c = XFIXNAT (ch);
for (; CONSP (restriction); restriction = XCDR (restriction))
{
@ -2066,7 +2066,7 @@ that case, find the charset from what supported by that coding system. */)
return Qnil;
}
restriction = coding_system_charset_list (restriction);
charset = char_charset (XINT (ch), restriction, NULL);
charset = char_charset (XFIXNUM (ch), restriction, NULL);
if (! charset)
return Qnil;
}
@ -2085,9 +2085,9 @@ If POS is out of range, the value is nil. */)
struct charset *charset;
ch = Fchar_after (pos);
if (! INTEGERP (ch))
if (! FIXNUMP (ch))
return ch;
charset = CHAR_CHARSET (XINT (ch));
charset = CHAR_CHARSET (XFIXNUM (ch));
return (CHARSET_NAME (charset));
}
@ -2104,8 +2104,8 @@ DIMENSION, CHARS, and FINAL-CHAR. */)
(Lisp_Object dimension, Lisp_Object chars, Lisp_Object final_char)
{
bool chars_flag = check_iso_charset_parameter (dimension, chars, final_char);
int id = ISO_CHARSET_TABLE (XINT (dimension), chars_flag,
XFASTINT (final_char));
int id = ISO_CHARSET_TABLE (XFIXNUM (dimension), chars_flag,
XFIXNAT (final_char));
return (id >= 0 ? CHARSET_NAME (CHARSET_FROM_ID (id)) : Qnil);
}
@ -2139,11 +2139,11 @@ HIGHESTP non-nil means just return the highest priority one. */)
Lisp_Object val = Qnil, list = Vcharset_ordered_list;
if (!NILP (highestp))
return CHARSET_NAME (CHARSET_FROM_ID (XINT (Fcar (list))));
return CHARSET_NAME (CHARSET_FROM_ID (XFIXNUM (Fcar (list))));
while (!NILP (list))
{
val = Fcons (CHARSET_NAME (CHARSET_FROM_ID (XINT (XCAR (list)))), val);
val = Fcons (CHARSET_NAME (CHARSET_FROM_ID (XFIXNUM (XCAR (list)))), val);
list = XCDR (list);
}
return Fnreverse (val);
@ -2165,10 +2165,10 @@ usage: (set-charset-priority &rest charsets) */)
for (i = 0; i < nargs; i++)
{
CHECK_CHARSET_GET_ID (args[i], id);
if (! NILP (Fmemq (make_number (id), old_list)))
if (! NILP (Fmemq (make_fixnum (id), old_list)))
{
old_list = Fdelq (make_number (id), old_list);
new_head = Fcons (make_number (id), new_head);
old_list = Fdelq (make_fixnum (id), old_list);
new_head = Fcons (make_fixnum (id), new_head);
}
}
Vcharset_non_preferred_head = old_list;
@ -2186,7 +2186,7 @@ usage: (set-charset-priority &rest charsets) */)
list_emacs_mule = Fcons (XCAR (old_list), list_emacs_mule);
if (charset_unibyte < 0)
{
struct charset *charset = CHARSET_FROM_ID (XINT (XCAR (old_list)));
struct charset *charset = CHARSET_FROM_ID (XFIXNUM (XCAR (old_list)));
if (CHARSET_DIMENSION (charset) == 1
&& CHARSET_ASCII_COMPATIBLE_P (charset)
@ -2211,7 +2211,7 @@ Return charset identification number of CHARSET. */)
int id;
CHECK_CHARSET_GET_ID (charset, id);
return make_number (id);
return make_fixnum (id);
}
struct charset_sort_data
@ -2237,7 +2237,7 @@ See also `charset-priority-list' and `set-charset-priority'. */)
(Lisp_Object charsets)
{
Lisp_Object len = Flength (charsets);
ptrdiff_t n = XFASTINT (len), i, j;
ptrdiff_t n = XFIXNAT (len), i, j;
int done;
Lisp_Object tail, elt, attrs;
struct charset_sort_data *sort_data;
@ -2252,7 +2252,7 @@ See also `charset-priority-list' and `set-charset-priority'. */)
elt = XCAR (tail);
CHECK_CHARSET_GET_ATTR (elt, attrs);
sort_data[i].charset = elt;
sort_data[i].id = id = XINT (CHARSET_ATTR_ID (attrs));
sort_data[i].id = id = XFIXNUM (CHARSET_ATTR_ID (attrs));
if (id < min_id)
min_id = id;
if (id > max_id)
@ -2262,7 +2262,7 @@ See also `charset-priority-list' and `set-charset-priority'. */)
done < n && CONSP (tail); tail = XCDR (tail), i++)
{
elt = XCAR (tail);
id = XFASTINT (elt);
id = XFIXNAT (elt);
if (id >= min_id && id <= max_id)
for (j = 0; j < n; j++)
if (sort_data[j].id == id)

6
src/charset.h
View file

@ -355,7 +355,7 @@ set_charset_attr (struct charset *charset, enum charset_attr_index idx,
\
if (! SYMBOLP (x) || (idx = CHARSET_SYMBOL_HASH_INDEX (x)) < 0) \
wrong_type_argument (Qcharsetp, (x)); \
id = XINT (AREF (HASH_VALUE (XHASH_TABLE (Vcharset_hash_table), idx), \
id = XFIXNUM (AREF (HASH_VALUE (XHASH_TABLE (Vcharset_hash_table), idx), \
charset_id)); \
} while (false)
@ -416,7 +416,7 @@ extern Lisp_Object Vchar_charset_set;
: (charset)->method == CHARSET_METHOD_MAP \
? (((charset)->code_linear_p \
&& VECTORP (CHARSET_DECODER (charset))) \
? XINT (AREF (CHARSET_DECODER (charset), \
? XFIXNUM (AREF (CHARSET_DECODER (charset), \
(code) - (charset)->min_code)) \
: decode_char ((charset), (code))) \
: decode_char ((charset), (code)))
@ -447,7 +447,7 @@ extern Lisp_Object charset_work;
? (charset_work = CHAR_TABLE_REF (CHARSET_ENCODER (charset), c), \
(NILP (charset_work) \
? (charset)->invalid_code \
: (unsigned) XFASTINT (charset_work))) \
: (unsigned) XFIXNAT (charset_work))) \
: encode_char (charset, c)) \
: encode_char (charset, c))))

96
src/chartab.c
View file

@ -118,14 +118,14 @@ the char-table has no extra slot. */)
n_extras = 0;
else
{
CHECK_NATNUM (n);
if (XINT (n) > 10)
CHECK_FIXNAT (n);
if (XFIXNUM (n) > 10)
args_out_of_range (n, Qnil);
n_extras = XINT (n);
n_extras = XFIXNUM (n);
}
size = CHAR_TABLE_STANDARD_SLOTS + n_extras;
vector = Fmake_vector (make_number (size), init);
vector = Fmake_vector (make_fixnum (size), init);
XSETPVECTYPE (XVECTOR (vector), PVEC_CHAR_TABLE);
set_char_table_parent (vector, Qnil);
set_char_table_purpose (vector, purpose);
@ -188,7 +188,7 @@ copy_char_table (Lisp_Object table)
int size = PVSIZE (table);
int i;
copy = Fmake_vector (make_number (size), Qnil);
copy = Fmake_vector (make_fixnum (size), Qnil);
XSETPVECTYPE (XVECTOR (copy), PVEC_CHAR_TABLE);
set_char_table_defalt (copy, XCHAR_TABLE (table)->defalt);
set_char_table_parent (copy, XCHAR_TABLE (table)->parent);
@ -571,12 +571,12 @@ DEFUN ("char-table-extra-slot", Fchar_table_extra_slot, Schar_table_extra_slot,
(Lisp_Object char_table, Lisp_Object n)
{
CHECK_CHAR_TABLE (char_table);
CHECK_NUMBER (n);
if (XINT (n) < 0
|| XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
CHECK_FIXNUM (n);
if (XFIXNUM (n) < 0
|| XFIXNUM (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
args_out_of_range (char_table, n);
return XCHAR_TABLE (char_table)->extras[XINT (n)];
return XCHAR_TABLE (char_table)->extras[XFIXNUM (n)];
}
DEFUN ("set-char-table-extra-slot", Fset_char_table_extra_slot,
@ -586,12 +586,12 @@ DEFUN ("set-char-table-extra-slot", Fset_char_table_extra_slot,
(Lisp_Object char_table, Lisp_Object n, Lisp_Object value)
{
CHECK_CHAR_TABLE (char_table);
CHECK_NUMBER (n);
if (XINT (n) < 0
|| XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
CHECK_FIXNUM (n);
if (XFIXNUM (n) < 0
|| XFIXNUM (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
args_out_of_range (char_table, n);
set_char_table_extras (char_table, XINT (n), value);
set_char_table_extras (char_table, XFIXNUM (n), value);
return value;
}
@ -608,15 +608,15 @@ a cons of character codes (for characters in the range), or a character code. *
if (NILP (range))
val = XCHAR_TABLE (char_table)->defalt;
else if (CHARACTERP (range))
val = CHAR_TABLE_REF (char_table, XFASTINT (range));
val = CHAR_TABLE_REF (char_table, XFIXNAT (range));
else if (CONSP (range))
{
int from, to;
CHECK_CHARACTER_CAR (range);
CHECK_CHARACTER_CDR (range);
from = XFASTINT (XCAR (range));
to = XFASTINT (XCDR (range));
from = XFIXNAT (XCAR (range));
to = XFIXNAT (XCDR (range));
val = char_table_ref_and_range (char_table, from, &from, &to);
/* Not yet implemented. */
}
@ -645,13 +645,13 @@ or a character code. Return VALUE. */)
else if (NILP (range))
set_char_table_defalt (char_table, value);
else if (CHARACTERP (range))
char_table_set (char_table, XINT (range), value);
char_table_set (char_table, XFIXNUM (range), value);
else if (CONSP (range))
{
CHECK_CHARACTER_CAR (range);
CHECK_CHARACTER_CDR (range);
char_table_set_range (char_table,
XINT (XCAR (range)), XINT (XCDR (range)), value);
XFIXNUM (XCAR (range)), XFIXNUM (XCDR (range)), value);
}
else
error ("Invalid RANGE argument to `set-char-table-range'");
@ -742,7 +742,7 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
int min_char, max_char;
/* Number of characters covered by one element of TABLE. */
int chars_in_block;
int from = XINT (XCAR (range)), to = XINT (XCDR (range));
int from = XFIXNUM (XCAR (range)), to = XFIXNUM (XCDR (range));
int i, c;
bool is_uniprop = UNIPROP_TABLE_P (top);
uniprop_decoder_t decoder = UNIPROP_GET_DECODER (top);
@ -783,7 +783,7 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
if (SUB_CHAR_TABLE_P (this))
{
if (to >= nextc)
XSETCDR (range, make_number (nextc - 1));
XSETCDR (range, make_fixnum (nextc - 1));
val = map_sub_char_table (c_function, function, this, arg,
val, range, top);
}
@ -807,7 +807,7 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
set_char_table_parent (parent, Qnil);
val = CHAR_TABLE_REF (parent, from);
set_char_table_parent (parent, temp);
XSETCDR (range, make_number (c - 1));
XSETCDR (range, make_fixnum (c - 1));
val = map_sub_char_table (c_function, function,
parent, arg, val, range,
parent);
@ -817,7 +817,7 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
}
if (! NILP (val) && different_value)
{
XSETCDR (range, make_number (c - 1));
XSETCDR (range, make_fixnum (c - 1));
if (EQ (XCAR (range), XCDR (range)))
{
if (c_function)
@ -843,10 +843,10 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
}
val = this;
from = c;
XSETCAR (range, make_number (c));
XSETCAR (range, make_fixnum (c));
}
}
XSETCDR (range, make_number (to));
XSETCDR (range, make_fixnum (to));
}
return val;
}
@ -864,7 +864,7 @@ map_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
Lisp_Object range, val, parent;
uniprop_decoder_t decoder = UNIPROP_GET_DECODER (table);
range = Fcons (make_number (0), make_number (MAX_CHAR));
range = Fcons (make_fixnum (0), make_fixnum (MAX_CHAR));
parent = XCHAR_TABLE (table)->parent;
val = XCHAR_TABLE (table)->ascii;
@ -878,7 +878,7 @@ map_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
while (NILP (val) && ! NILP (XCHAR_TABLE (table)->parent))
{
Lisp_Object temp;
int from = XINT (XCAR (range));
int from = XFIXNUM (XCAR (range));
parent = XCHAR_TABLE (table)->parent;
temp = XCHAR_TABLE (parent)->parent;
@ -957,7 +957,7 @@ map_sub_char_table_for_charset (void (*c_function) (Lisp_Object, Lisp_Object),
{
if (! NILP (XCAR (range)))
{
XSETCDR (range, make_number (c - 1));
XSETCDR (range, make_fixnum (c - 1));
if (c_function)
(*c_function) (arg, range);
else
@ -980,7 +980,7 @@ map_sub_char_table_for_charset (void (*c_function) (Lisp_Object, Lisp_Object),
{
if (! NILP (XCAR (range)))
{
XSETCDR (range, make_number (c - 1));
XSETCDR (range, make_fixnum (c - 1));
if (c_function)
(*c_function) (arg, range);
else
@ -991,7 +991,7 @@ map_sub_char_table_for_charset (void (*c_function) (Lisp_Object, Lisp_Object),
else
{
if (NILP (XCAR (range)))
XSETCAR (range, make_number (c));
XSETCAR (range, make_fixnum (c));
}
}
}
@ -1041,7 +1041,7 @@ map_char_table_for_charset (void (*c_function) (Lisp_Object, Lisp_Object),
{
if (! NILP (XCAR (range)))
{
XSETCDR (range, make_number (c - 1));
XSETCDR (range, make_fixnum (c - 1));
if (c_function)
(*c_function) (arg, range);
else
@ -1052,7 +1052,7 @@ map_char_table_for_charset (void (*c_function) (Lisp_Object, Lisp_Object),
}
if (! NILP (XCAR (range)))
{
XSETCDR (range, make_number (c - 1));
XSETCDR (range, make_fixnum (c - 1));
if (c_function)
(*c_function) (arg, range);
else
@ -1125,7 +1125,7 @@ uniprop_table_uncompress (Lisp_Object table, int idx)
{
int v = STRING_CHAR_ADVANCE (p);
set_sub_char_table_contents
(sub, idx++, v > 0 ? make_number (v) : Qnil);
(sub, idx++, v > 0 ? make_fixnum (v) : Qnil);
}
}
else if (*p == 2)
@ -1150,7 +1150,7 @@ uniprop_table_uncompress (Lisp_Object table, int idx)
}
}
while (count-- > 0)
set_sub_char_table_contents (sub, idx++, make_number (v));
set_sub_char_table_contents (sub, idx++, make_fixnum (v));
}
}
/* It seems that we don't need this function because C code won't need
@ -1174,8 +1174,8 @@ uniprop_decode_value_run_length (Lisp_Object table, Lisp_Object value)
{
Lisp_Object valvec = XCHAR_TABLE (table)->extras[4];
if (XINT (value) >= 0 && XINT (value) < ASIZE (valvec))
value = AREF (valvec, XINT (value));
if (XFIXNUM (value) >= 0 && XFIXNUM (value) < ASIZE (valvec))
value = AREF (valvec, XFIXNUM (value));
}
return value;
}
@ -1192,9 +1192,9 @@ uniprop_get_decoder (Lisp_Object table)
{
EMACS_INT i;
if (! INTEGERP (XCHAR_TABLE (table)->extras[1]))
if (! FIXNUMP (XCHAR_TABLE (table)->extras[1]))
return NULL;
i = XINT (XCHAR_TABLE (table)->extras[1]);
i = XFIXNUM (XCHAR_TABLE (table)->extras[1]);
if (i < 0 || i >= uniprop_decoder_count)
return NULL;
return uniprop_decoder[i];
@ -1227,7 +1227,7 @@ uniprop_encode_value_run_length (Lisp_Object table, Lisp_Object value)
break;
if (i == size)
wrong_type_argument (build_string ("Unicode property value"), value);
return make_number (i);
return make_fixnum (i);
}
@ -1240,17 +1240,17 @@ uniprop_encode_value_numeric (Lisp_Object table, Lisp_Object value)
Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->contents;
int i, size = ASIZE (XCHAR_TABLE (table)->extras[4]);
CHECK_NUMBER (value);
CHECK_FIXNUM (value);
for (i = 0; i < size; i++)
if (EQ (value, value_table[i]))
break;
value = make_number (i);
value = make_fixnum (i);
if (i == size)
set_char_table_extras (table, 4,
CALLN (Fvconcat,
XCHAR_TABLE (table)->extras[4],
Fmake_vector (make_number (1), value)));
return make_number (i);
Fmake_vector (make_fixnum (1), value)));
return make_fixnum (i);
}
static uniprop_encoder_t uniprop_encoder[] =
@ -1267,9 +1267,9 @@ uniprop_get_encoder (Lisp_Object table)
{
EMACS_INT i;
if (! INTEGERP (XCHAR_TABLE (table)->extras[2]))
if (! FIXNUMP (XCHAR_TABLE (table)->extras[2]))
return NULL;
i = XINT (XCHAR_TABLE (table)->extras[2]);
i = XFIXNUM (XCHAR_TABLE (table)->extras[2]);
if (i < 0 || i >= uniprop_encoder_count)
return NULL;
return uniprop_encoder[i];
@ -1300,8 +1300,8 @@ uniprop_table (Lisp_Object prop)
|| ! UNIPROP_TABLE_P (table))
return Qnil;
val = XCHAR_TABLE (table)->extras[1];
if (INTEGERP (val)
? (XINT (val) < 0 || XINT (val) >= uniprop_decoder_count)
if (FIXNUMP (val)
? (XFIXNUM (val) < 0 || XFIXNUM (val) >= uniprop_decoder_count)
: ! NILP (val))
return Qnil;
/* Prepare ASCII values in advance for CHAR_TABLE_REF. */
@ -1337,7 +1337,7 @@ CHAR-TABLE must be what returned by `unicode-property-table-internal'. */)
CHECK_CHARACTER (ch);
if (! UNIPROP_TABLE_P (char_table))
error ("Invalid Unicode property table");
val = CHAR_TABLE_REF (char_table, XINT (ch));
val = CHAR_TABLE_REF (char_table, XFIXNUM (ch));
decoder = uniprop_get_decoder (char_table);
return (decoder ? decoder (char_table, val) : val);
}
@ -1357,7 +1357,7 @@ CHAR-TABLE must be what returned by `unicode-property-table-internal'. */)
encoder = uniprop_get_encoder (char_table);
if (encoder)
value = encoder (char_table, value);
CHAR_TABLE_SET (char_table, XINT (ch), value);
CHAR_TABLE_SET (char_table, XFIXNUM (ch), value);
return Qnil;
}

62
src/cmds.c
View file

@ -35,9 +35,9 @@ DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
doc: /* Return buffer position N characters after (before if N negative) point. */)
(Lisp_Object n)
{
CHECK_NUMBER (n);
CHECK_FIXNUM (n);
return make_number (PT + XINT (n));
return make_fixnum (PT + XFIXNUM (n));
}
/* Add N to point; or subtract N if FORWARD is false. N defaults to 1.
@ -45,7 +45,7 @@ DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
static Lisp_Object
move_point (Lisp_Object n, bool forward)
{
/* This used to just set point to point + XINT (n), and then check
/* This used to just set point to point + XFIXNUM (n), and then check
to see if it was within boundaries. But now that SET_PT can
potentially do a lot of stuff (calling entering and exiting
hooks, etcetera), that's not a good approach. So we validate the
@ -56,9 +56,9 @@ move_point (Lisp_Object n, bool forward)
if (NILP (n))
XSETFASTINT (n, 1);
else
CHECK_NUMBER (n);
CHECK_FIXNUM (n);
new_point = PT + (forward ? XINT (n) : - XINT (n));
new_point = PT + (forward ? XFIXNUM (n) : - XFIXNUM (n));
if (new_point < BEGV)
{
@ -127,8 +127,8 @@ go to its beginning. */)
count = 1;
else
{
CHECK_NUMBER (n);
count = XINT (n);
CHECK_FIXNUM (n);
count = XFIXNUM (n);
}
shortage = scan_newline_from_point (count, &pos, &pos_byte);
@ -142,7 +142,7 @@ go to its beginning. */)
&& (FETCH_BYTE (PT_BYTE - 1) != '\n'))))
shortage--;
return make_number (count <= 0 ? - shortage : shortage);
return make_fixnum (count <= 0 ? - shortage : shortage);
}
DEFUN ("beginning-of-line", Fbeginning_of_line, Sbeginning_of_line, 0, 1, "^p",
@ -162,9 +162,9 @@ instead. For instance, `(forward-line 0)' does the same thing as
if (NILP (n))
XSETFASTINT (n, 1);
else
CHECK_NUMBER (n);
CHECK_FIXNUM (n);
SET_PT (XINT (Fline_beginning_position (n)));
SET_PT (XFIXNUM (Fline_beginning_position (n)));
return Qnil;
}
@ -187,11 +187,11 @@ to t. */)
if (NILP (n))
XSETFASTINT (n, 1);
else
CHECK_NUMBER (n);
CHECK_FIXNUM (n);
while (1)
{
newpos = XINT (Fline_end_position (n));
newpos = XFIXNUM (Fline_end_position (n));
SET_PT (newpos);
if (PT > newpos
@ -210,7 +210,7 @@ to t. */)
/* If we skipped something intangible
and now we're not really at eol,
keep going. */
n = make_number (1);
n = make_fixnum (1);
else
break;
}
@ -230,15 +230,15 @@ because it respects values of `delete-active-region' and `overwrite-mode'. */)
{
EMACS_INT pos;
CHECK_NUMBER (n);
CHECK_FIXNUM (n);
if (eabs (XINT (n)) < 2)
if (eabs (XFIXNUM (n)) < 2)
call0 (Qundo_auto_amalgamate);
pos = PT + XINT (n);
pos = PT + XFIXNUM (n);
if (NILP (killflag))
{
if (XINT (n) < 0)
if (XFIXNUM (n) < 0)
{
if (pos < BEGV)
xsignal0 (Qbeginning_of_buffer);
@ -274,12 +274,12 @@ a non-nil value for the inserted character. At the end, it runs
`post-self-insert-hook'. */)
(Lisp_Object n)
{
CHECK_NUMBER (n);
CHECK_FIXNUM (n);
if (XINT (n) < 0)
error ("Negative repetition argument %"pI"d", XINT (n));
if (XFIXNUM (n) < 0)
error ("Negative repetition argument %"pI"d", XFIXNUM (n));
if (XFASTINT (n) < 2)
if (XFIXNAT (n) < 2)
call0 (Qundo_auto_amalgamate);
/* Barf if the key that invoked this was not a character. */
@ -287,8 +287,8 @@ a non-nil value for the inserted character. At the end, it runs
bitch_at_user ();
else {
int character = translate_char (Vtranslation_table_for_input,
XINT (last_command_event));
int val = internal_self_insert (character, XFASTINT (n));
XFIXNUM (last_command_event));
int val = internal_self_insert (character, XFIXNAT (n));
if (val == 2)
Fset (Qundo_auto__this_command_amalgamating, Qnil);
frame_make_pointer_invisible (SELECTED_FRAME ());
@ -360,7 +360,7 @@ internal_self_insert (int c, EMACS_INT n)
if (EQ (overwrite, Qoverwrite_mode_binary))
chars_to_delete = min (n, PTRDIFF_MAX);
else if (c != '\n' && c2 != '\n'
&& (cwidth = XFASTINT (Fchar_width (make_number (c)))) != 0)
&& (cwidth = XFIXNAT (Fchar_width (make_fixnum (c)))) != 0)
{
ptrdiff_t pos = PT;
ptrdiff_t pos_byte = PT_BYTE;
@ -378,7 +378,7 @@ internal_self_insert (int c, EMACS_INT n)
character. In that case, the new point is set after
that character. */
ptrdiff_t actual_clm
= XFASTINT (Fmove_to_column (make_number (target_clm), Qnil));
= XFIXNAT (Fmove_to_column (make_fixnum (target_clm), Qnil));
chars_to_delete = PT - pos;
@ -408,8 +408,8 @@ internal_self_insert (int c, EMACS_INT n)
&& NILP (BVAR (current_buffer, read_only))
&& PT > BEGV
&& (SYNTAX (!NILP (BVAR (current_buffer, enable_multibyte_characters))
? XFASTINT (Fprevious_char ())
: UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
? XFIXNAT (Fprevious_char ())
: UNIBYTE_TO_CHAR (XFIXNAT (Fprevious_char ())))
== Sword))
{
EMACS_INT modiff = MODIFF;
@ -439,18 +439,18 @@ internal_self_insert (int c, EMACS_INT n)
int mc = ((NILP (BVAR (current_buffer, enable_multibyte_characters))
&& SINGLE_BYTE_CHAR_P (c))
? UNIBYTE_TO_CHAR (c) : c);
Lisp_Object string = Fmake_string (make_number (n), make_number (mc),
Lisp_Object string = Fmake_string (make_fixnum (n), make_fixnum (mc),
Qnil);
if (spaces_to_insert)
{
tem = Fmake_string (make_number (spaces_to_insert),
make_number (' '), Qnil);
tem = Fmake_string (make_fixnum (spaces_to_insert),
make_fixnum (' '), Qnil);
string = concat2 (string, tem);
}
replace_range (PT, PT + chars_to_delete, string, 1, 1, 1, 0);
Fforward_char (make_number (n));
Fforward_char (make_fixnum (n));
}
else if (n > 1)
{

418
src/coding.c
View file

File diff suppressed because it is too large Load diff

154
src/composite.c
View file

@ -193,12 +193,12 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
goto invalid_composition;
id = XCAR (prop);
if (INTEGERP (id))
if (FIXNUMP (id))
{
/* PROP should be Form-B. */
if (XINT (id) < 0 || XINT (id) >= n_compositions)
if (XFIXNUM (id) < 0 || XFIXNUM (id) >= n_compositions)
goto invalid_composition;
return XINT (id);
return XFIXNUM (id);
}
/* PROP should be Form-A.
@ -206,7 +206,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
if (!CONSP (id))
goto invalid_composition;
length = XCAR (id);
if (!INTEGERP (length) || XINT (length) != nchars)
if (!FIXNUMP (length) || XFIXNUM (length) != nchars)
goto invalid_composition;
components = XCDR (id);
@ -215,8 +215,8 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
by consulting composition_hash_table. The key for this table is
COMPONENTS (converted to a vector COMPONENTS-VEC) or, if it is
nil, vector of characters in the composition range. */
if (INTEGERP (components))
key = Fmake_vector (make_number (1), components);
if (FIXNUMP (components))
key = Fmake_vector (make_fixnum (1), components);
else if (STRINGP (components) || CONSP (components))
key = Fvconcat (1, &components);
else if (VECTORP (components))
@ -228,13 +228,13 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
for (i = 0; i < nchars; i++)
{
FETCH_STRING_CHAR_ADVANCE (ch, string, charpos, bytepos);
ASET (key, i, make_number (ch));
ASET (key, i, make_fixnum (ch));
}
else
for (i = 0; i < nchars; i++)
{
FETCH_CHAR_ADVANCE (ch, charpos, bytepos);
ASET (key, i, make_number (ch));
ASET (key, i, make_fixnum (ch));
}
}
else
@ -250,8 +250,8 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
key = HASH_KEY (hash_table, hash_index);
id = HASH_VALUE (hash_table, hash_index);
XSETCAR (prop, id);
XSETCDR (prop, Fcons (make_number (nchars), Fcons (key, XCDR (prop))));
return XINT (id);
XSETCDR (prop, Fcons (make_fixnum (nchars), Fcons (key, XCDR (prop))));
return XFIXNUM (id);
}
/* This composition is a new one. We must register it. */
@ -289,7 +289,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
composition rule). */
for (i = 0; i < len; i++)
{
if (!INTEGERP (key_contents[i]))
if (!FIXNUMP (key_contents[i]))
goto invalid_composition;
}
}
@ -298,14 +298,14 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
the cons cell of PROP because it is not shared. */
XSETFASTINT (id, n_compositions);
XSETCAR (prop, id);
XSETCDR (prop, Fcons (make_number (nchars), Fcons (key, XCDR (prop))));
XSETCDR (prop, Fcons (make_fixnum (nchars), Fcons (key, XCDR (prop))));
/* Register the composition in composition_hash_table. */
hash_index = hash_put (hash_table, key, id, hash_code);
method = (NILP (components)
? COMPOSITION_RELATIVE
: ((INTEGERP (components) || STRINGP (components))
: ((FIXNUMP (components) || STRINGP (components))
? COMPOSITION_WITH_ALTCHARS
: COMPOSITION_WITH_RULE_ALTCHARS));
@ -332,7 +332,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
for (i = 0; i < glyph_len; i++)
{
int this_width;
ch = XINT (key_contents[i]);
ch = XFIXNUM (key_contents[i]);
/* TAB in a composition means display glyphs with padding
space on the left or right. */
this_width = (ch == '\t' ? 1 : CHARACTER_WIDTH (ch));
@ -345,7 +345,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
/* Rule-base composition. */
double leftmost = 0.0, rightmost;
ch = XINT (key_contents[0]);
ch = XFIXNUM (key_contents[0]);
rightmost = ch != '\t' ? CHARACTER_WIDTH (ch) : 1;
for (i = 1; i < glyph_len; i += 2)
@ -354,8 +354,8 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
int this_width;
double this_left;
rule = XINT (key_contents[i]);
ch = XINT (key_contents[i + 1]);
rule = XFIXNUM (key_contents[i]);
ch = XFIXNUM (key_contents[i + 1]);
this_width = ch != '\t' ? CHARACTER_WIDTH (ch) : 1;
/* A composition rule is specified by an integer value
@ -431,9 +431,9 @@ find_composition (ptrdiff_t pos, ptrdiff_t limit,
if (limit > pos) /* search forward */
{
val = Fnext_single_property_change (make_number (pos), Qcomposition,
object, make_number (limit));
pos = XINT (val);
val = Fnext_single_property_change (make_fixnum (pos), Qcomposition,
object, make_fixnum (limit));
pos = XFIXNUM (val);
if (pos == limit)
return 0;
}
@ -442,9 +442,9 @@ find_composition (ptrdiff_t pos, ptrdiff_t limit,
if (get_property_and_range (pos - 1, Qcomposition, prop, start, end,
object))
return 1;
val = Fprevious_single_property_change (make_number (pos), Qcomposition,
object, make_number (limit));
pos = XINT (val);
val = Fprevious_single_property_change (make_fixnum (pos), Qcomposition,
object, make_fixnum (limit));
pos = XFIXNUM (val);
if (pos == limit)
return 0;
pos--;
@ -474,7 +474,7 @@ run_composition_function (ptrdiff_t from, ptrdiff_t to, Lisp_Object prop)
&& !composition_valid_p (start, end, prop))
to = end;
if (!NILP (Ffboundp (func)))
call2 (func, make_number (from), make_number (to));
call2 (func, make_fixnum (from), make_fixnum (to));
}
/* Make invalid compositions adjacent to or inside FROM and TO valid.
@ -519,7 +519,7 @@ update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
if (end > to)
max_pos = end;
if (from < end)
Fput_text_property (make_number (from), make_number (end),
Fput_text_property (make_fixnum (from), make_fixnum (end),
Qcomposition,
Fcons (XCAR (prop), XCDR (prop)), Qnil);
run_composition_function (start, end, prop);
@ -560,7 +560,7 @@ update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
the former to the copy of it. */
if (to < end)
{
Fput_text_property (make_number (start), make_number (to),
Fput_text_property (make_fixnum (start), make_fixnum (to),
Qcomposition,
Fcons (XCAR (prop), XCDR (prop)), Qnil);
max_pos = end;
@ -582,8 +582,8 @@ update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
specbind (Qinhibit_read_only, Qt);
specbind (Qinhibit_modification_hooks, Qt);
specbind (Qinhibit_point_motion_hooks, Qt);
Fremove_list_of_text_properties (make_number (min_pos),
make_number (max_pos),
Fremove_list_of_text_properties (make_fixnum (min_pos),
make_fixnum (max_pos),
list1 (Qauto_composed), Qnil);
unbind_to (count, Qnil);
}
@ -625,9 +625,9 @@ compose_text (ptrdiff_t start, ptrdiff_t end, Lisp_Object components,
{
Lisp_Object prop;
prop = Fcons (Fcons (make_number (end - start), components),
prop = Fcons (Fcons (make_fixnum (end - start), components),
modification_func);
Fput_text_property (make_number (start), make_number (end),
Fput_text_property (make_fixnum (start), make_fixnum (end),
Qcomposition, prop, string);
}
@ -669,12 +669,12 @@ composition_gstring_put_cache (Lisp_Object gstring, ptrdiff_t len)
len = j;
}
copy = Fmake_vector (make_number (len + 2), Qnil);
copy = Fmake_vector (make_fixnum (len + 2), Qnil);
LGSTRING_SET_HEADER (copy, Fcopy_sequence (header));
for (i = 0; i < len; i++)
LGSTRING_SET_GLYPH (copy, i, Fcopy_sequence (LGSTRING_GLYPH (gstring, i)));
i = hash_put (h, LGSTRING_HEADER (copy), copy, hash);
LGSTRING_SET_ID (copy, make_number (i));
LGSTRING_SET_ID (copy, make_fixnum (i));
return copy;
}
@ -692,7 +692,7 @@ DEFUN ("clear-composition-cache", Fclear_composition_cache,
Clear composition cache. */)
(void)
{
Lisp_Object args[] = {QCtest, Qequal, QCsize, make_number (311)};
Lisp_Object args[] = {QCtest, Qequal, QCsize, make_fixnum (311)};
gstring_hash_table = CALLMANY (Fmake_hash_table, args);
/* Fixme: We call Fclear_face_cache to force complete re-building of
display glyphs. But, it may be better to call this function from
@ -716,9 +716,9 @@ composition_gstring_p (Lisp_Object gstring)
&& ! CODING_SYSTEM_P (LGSTRING_FONT (gstring))))
return 0;
for (i = 1; i < ASIZE (LGSTRING_HEADER (gstring)); i++)
if (! NATNUMP (AREF (LGSTRING_HEADER (gstring), i)))
if (! FIXNATP (AREF (LGSTRING_HEADER (gstring), i)))
return 0;
if (! NILP (LGSTRING_ID (gstring)) && ! NATNUMP (LGSTRING_ID (gstring)))
if (! NILP (LGSTRING_ID (gstring)) && ! FIXNATP (LGSTRING_ID (gstring)))
return 0;
for (i = 0; i < LGSTRING_GLYPH_LEN (gstring); i++)
{
@ -801,7 +801,7 @@ fill_gstring_header (Lisp_Object header, ptrdiff_t from, ptrdiff_t from_byte,
if (VECTORP (header))
{
if (ASIZE (header) != len + 1)
args_out_of_range (header, make_number (len + 1));
args_out_of_range (header, make_fixnum (len + 1));
}
else
{
@ -820,7 +820,7 @@ fill_gstring_header (Lisp_Object header, ptrdiff_t from, ptrdiff_t from_byte,
FETCH_CHAR_ADVANCE_NO_CHECK (c, from, from_byte);
else
FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, string, from, from_byte);
ASET (header, i + 1, make_number (c));
ASET (header, i + 1, make_fixnum (c));
}
return header;
}
@ -836,7 +836,7 @@ fill_gstring_body (Lisp_Object gstring)
for (i = 0; i < len; i++)
{
Lisp_Object g = LGSTRING_GLYPH (gstring, i);
int c = XFASTINT (AREF (header, i + 1));
int c = XFIXNAT (AREF (header, i + 1));
if (NILP (g))
{
@ -852,7 +852,7 @@ fill_gstring_body (Lisp_Object gstring)
}
else
{
int width = XFASTINT (CHAR_TABLE_REF (Vchar_width_table, c));
int width = XFIXNAT (CHAR_TABLE_REF (Vchar_width_table, c));
LGLYPH_SET_CODE (g, c);
LGLYPH_SET_LBEARING (g, 0);
@ -881,7 +881,7 @@ autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos,
Lisp_Object string)
{
ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object pos = make_number (charpos);
Lisp_Object pos = make_fixnum (charpos);
ptrdiff_t to;
ptrdiff_t pt = PT, pt_byte = PT_BYTE;
Lisp_Object re, font_object, lgstring;
@ -917,7 +917,7 @@ autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos,
return unbind_to (count, Qnil);
}
#endif
lgstring = Fcomposition_get_gstring (pos, make_number (to), font_object,
lgstring = Fcomposition_get_gstring (pos, make_fixnum (to), font_object,
string);
if (NILP (LGSTRING_ID (lgstring)))
{
@ -926,7 +926,7 @@ autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos,
record_unwind_protect (restore_point_unwind,
build_marker (current_buffer, pt, pt_byte));
lgstring = safe_call (6, Vauto_composition_function, AREF (rule, 2),
pos, make_number (to), font_object, string);
pos, make_fixnum (to), font_object, string);
}
return unbind_to (count, lgstring);
}
@ -941,7 +941,7 @@ char_composable_p (int c)
return (c > ' '
&& (c == ZERO_WIDTH_NON_JOINER || c == ZERO_WIDTH_JOINER
|| (val = CHAR_TABLE_REF (Vunicode_category_table, c),
(INTEGERP (val) && (XINT (val) <= UNICODE_CATEGORY_So)))));
(FIXNUMP (val) && (XFIXNUM (val) <= UNICODE_CATEGORY_So)))));
}
/* Update cmp_it->stop_pos to the next position after CHARPOS (and
@ -1030,11 +1030,11 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
{
Lisp_Object elt = XCAR (val);
if (VECTORP (elt) && ASIZE (elt) == 3
&& NATNUMP (AREF (elt, 1))
&& charpos - 1 - XFASTINT (AREF (elt, 1)) >= start)
&& FIXNATP (AREF (elt, 1))
&& charpos - 1 - XFIXNAT (AREF (elt, 1)) >= start)
{
cmp_it->rule_idx = ridx;
cmp_it->lookback = XFASTINT (AREF (elt, 1));
cmp_it->lookback = XFIXNAT (AREF (elt, 1));
cmp_it->stop_pos = charpos - 1 - cmp_it->lookback;
cmp_it->ch = c;
return;
@ -1081,10 +1081,10 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
{
Lisp_Object elt = XCAR (val);
if (VECTORP (elt) && ASIZE (elt) == 3
&& NATNUMP (AREF (elt, 1))
&& charpos - XFASTINT (AREF (elt, 1)) > endpos)
&& FIXNATP (AREF (elt, 1))
&& charpos - XFIXNAT (AREF (elt, 1)) > endpos)
{
ptrdiff_t back = XFASTINT (AREF (elt, 1));
ptrdiff_t back = XFIXNAT (AREF (elt, 1));
ptrdiff_t cpos = charpos - back, bpos;
if (back == 0)
@ -1221,9 +1221,9 @@ composition_reseat_it (struct composition_it *cmp_it, ptrdiff_t charpos,
{
elt = XCAR (val);
if (! VECTORP (elt) || ASIZE (elt) != 3
|| ! INTEGERP (AREF (elt, 1)))
|| ! FIXNUMP (AREF (elt, 1)))
continue;
if (XFASTINT (AREF (elt, 1)) != cmp_it->lookback)
if (XFIXNAT (AREF (elt, 1)) != cmp_it->lookback)
goto no_composition;
lgstring = autocmp_chars (elt, charpos, bytepos, endpos,
w, face, string);
@ -1262,7 +1262,7 @@ composition_reseat_it (struct composition_it *cmp_it, ptrdiff_t charpos,
goto no_composition;
if (NILP (LGSTRING_ID (lgstring)))
lgstring = composition_gstring_put_cache (lgstring, -1);
cmp_it->id = XINT (LGSTRING_ID (lgstring));
cmp_it->id = XFIXNUM (LGSTRING_ID (lgstring));
int i;
for (i = 0; i < LGSTRING_GLYPH_LEN (lgstring); i++)
if (NILP (LGSTRING_GLYPH (lgstring, i)))
@ -1391,7 +1391,7 @@ composition_update_it (struct composition_it *cmp_it, ptrdiff_t charpos, ptrdiff
cmp_it->width = 0;
for (i = cmp_it->nchars - 1; i >= 0; i--)
{
c = XINT (LGSTRING_CHAR (gstring, from + i));
c = XFIXNUM (LGSTRING_CHAR (gstring, from + i));
cmp_it->nbytes += CHAR_BYTES (c);
cmp_it->width += CHARACTER_WIDTH (c);
}
@ -1559,9 +1559,9 @@ find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
{
Lisp_Object elt = XCAR (val);
if (VECTORP (elt) && ASIZE (elt) == 3 && NATNUMP (AREF (elt, 1)))
if (VECTORP (elt) && ASIZE (elt) == 3 && FIXNATP (AREF (elt, 1)))
{
EMACS_INT check_pos = cur.pos - XFASTINT (AREF (elt, 1));
EMACS_INT check_pos = cur.pos - XFIXNAT (AREF (elt, 1));
struct position_record check;
if (check_pos < head
@ -1739,8 +1739,8 @@ should be ignored. */)
if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
error ("Attempt to shape unibyte text");
validate_region (&from, &to);
frompos = XFASTINT (from);
topos = XFASTINT (to);
frompos = XFIXNAT (from);
topos = XFIXNAT (to);
frombyte = CHAR_TO_BYTE (frompos);
}
else
@ -1759,7 +1759,7 @@ should be ignored. */)
return gstring;
if (LGSTRING_GLYPH_LEN (gstring_work) < topos - frompos)
gstring_work = Fmake_vector (make_number (topos - frompos + 2), Qnil);
gstring_work = Fmake_vector (make_fixnum (topos - frompos + 2), Qnil);
LGSTRING_SET_HEADER (gstring_work, header);
LGSTRING_SET_ID (gstring_work, Qnil);
fill_gstring_body (gstring_work);
@ -1780,12 +1780,12 @@ for the composition. See `compose-region' for more details. */)
{
validate_region (&start, &end);
if (!NILP (components)
&& !INTEGERP (components)
&& !FIXNUMP (components)
&& !CONSP (components)
&& !STRINGP (components))
CHECK_VECTOR (components);
compose_text (XINT (start), XINT (end), components, modification_func, Qnil);
compose_text (XFIXNUM (start), XFIXNUM (end), components, modification_func, Qnil);
return Qnil;
}
@ -1820,11 +1820,11 @@ See `find-composition' for more details. */)
ptrdiff_t start, end, from, to;
int id;
CHECK_NUMBER_COERCE_MARKER (pos);
CHECK_FIXNUM_COERCE_MARKER (pos);
if (!NILP (limit))
{
CHECK_NUMBER_COERCE_MARKER (limit);
to = min (XINT (limit), ZV);
CHECK_FIXNUM_COERCE_MARKER (limit);
to = min (XFIXNUM (limit), ZV);
}
else
to = -1;
@ -1832,15 +1832,15 @@ See `find-composition' for more details. */)
if (!NILP (string))
{
CHECK_STRING (string);
if (XINT (pos) < 0 || XINT (pos) > SCHARS (string))
if (XFIXNUM (pos) < 0 || XFIXNUM (pos) > SCHARS (string))
args_out_of_range (string, pos);
}
else
{
if (XINT (pos) < BEGV || XINT (pos) > ZV)
if (XFIXNUM (pos) < BEGV || XFIXNUM (pos) > ZV)
args_out_of_range (Fcurrent_buffer (), pos);
}
from = XINT (pos);
from = XFIXNUM (pos);
if (!find_composition (from, to, &start, &end, &prop, string))
{
@ -1848,21 +1848,21 @@ See `find-composition' for more details. */)
&& ! NILP (Vauto_composition_mode)
&& find_automatic_composition (from, to, &start, &end, &gstring,
string))
return list3 (make_number (start), make_number (end), gstring);
return list3 (make_fixnum (start), make_fixnum (end), gstring);
return Qnil;
}
if ((end <= XINT (pos) || start > XINT (pos)))
if ((end <= XFIXNUM (pos) || start > XFIXNUM (pos)))
{
ptrdiff_t s, e;
if (find_automatic_composition (from, to, &s, &e, &gstring, string)
&& (e <= XINT (pos) ? e > end : s < start))
return list3 (make_number (s), make_number (e), gstring);
&& (e <= XFIXNUM (pos) ? e > end : s < start))
return list3 (make_fixnum (s), make_fixnum (e), gstring);
}
if (!composition_valid_p (start, end, prop))
return list3 (make_number (start), make_number (end), Qnil);
return list3 (make_fixnum (start), make_fixnum (end), Qnil);
if (NILP (detail_p))
return list3 (make_number (start), make_number (end), Qt);
return list3 (make_fixnum (start), make_fixnum (end), Qt);
if (composition_registered_p (prop))
id = COMPOSITION_ID (prop);
@ -1884,12 +1884,12 @@ See `find-composition' for more details. */)
relative_p = (method == COMPOSITION_WITH_RULE_ALTCHARS
? Qnil : Qt);
mod_func = COMPOSITION_MODIFICATION_FUNC (prop);
tail = list4 (components, relative_p, mod_func, make_number (width));
tail = list4 (components, relative_p, mod_func, make_fixnum (width));
}
else
tail = Qnil;
return Fcons (make_number (start), Fcons (make_number (end), tail));
return Fcons (make_fixnum (start), Fcons (make_fixnum (end), tail));
}
@ -1906,7 +1906,7 @@ syms_of_composite (void)
created compositions are repeatedly used in an Emacs session,
and thus it's not worth to save memory in such a way. So, we
make the table not weak. */
Lisp_Object args[] = {QCtest, Qequal, QCsize, make_number (311)};
Lisp_Object args[] = {QCtest, Qequal, QCsize, make_fixnum (311)};
composition_hash_table = CALLMANY (Fmake_hash_table, args);
staticpro (&composition_hash_table);
@ -1917,9 +1917,9 @@ syms_of_composite (void)
staticpro (&gstring_work_headers);
gstring_work_headers = make_uninit_vector (8);
for (i = 0; i < 8; i++)
ASET (gstring_work_headers, i, Fmake_vector (make_number (i + 2), Qnil));
ASET (gstring_work_headers, i, Fmake_vector (make_fixnum (i + 2), Qnil));
staticpro (&gstring_work);
gstring_work = Fmake_vector (make_number (10), Qnil);
gstring_work = Fmake_vector (make_fixnum (10), Qnil);
/* Text property `composition' should be nonsticky by default. */
Vtext_property_default_nonsticky

56
src/composite.h
View file

@ -59,17 +59,17 @@ enum composition_method {
INLINE bool
composition_registered_p (Lisp_Object prop)
{
return INTEGERP (XCAR (prop));
return FIXNUMP (XCAR (prop));
}
/* Return ID number of the already registered composition. */
#define COMPOSITION_ID(prop) XINT (XCAR (prop))
#define COMPOSITION_ID(prop) XFIXNUM (XCAR (prop))
/* Return length of the composition. */
#define COMPOSITION_LENGTH(prop) \
(composition_registered_p (prop) \
? XINT (XCAR (XCDR (prop))) \
: XINT (XCAR (XCAR (prop))))
? XFIXNUM (XCAR (XCDR (prop))) \
: XFIXNUM (XCAR (XCAR (prop))))
/* Return components of the composition. */
#define COMPOSITION_COMPONENTS(prop) \
@ -86,7 +86,7 @@ composition_registered_p (Lisp_Object prop)
/* Return the Nth glyph of composition specified by CMP. CMP is a
pointer to `struct composition'. */
#define COMPOSITION_GLYPH(cmp, n) \
XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table) \
XFIXNUM (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table) \
->key_and_value) \
->contents[cmp->hash_index * 2]) \
->contents[cmp->method == COMPOSITION_WITH_RULE_ALTCHARS \
@ -96,7 +96,7 @@ composition_registered_p (Lisp_Object prop)
rule-base composition specified by CMP. CMP is a pointer to
`struct composition'. */
#define COMPOSITION_RULE(cmp, n) \
XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table) \
XFIXNUM (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table) \
->key_and_value) \
->contents[cmp->hash_index * 2]) \
->contents[(n) * 2 - 1])
@ -213,7 +213,7 @@ composition_method (Lisp_Object prop)
Lisp_Object temp = XCDR (XCAR (prop));
return (NILP (temp)
? COMPOSITION_RELATIVE
: INTEGERP (temp) || STRINGP (temp)
: FIXNUMP (temp) || STRINGP (temp)
? COMPOSITION_WITH_ALTCHARS
: COMPOSITION_WITH_RULE_ALTCHARS);
}
@ -234,7 +234,7 @@ composition_valid_p (ptrdiff_t start, ptrdiff_t end, Lisp_Object prop)
&& (NILP (XCDR (XCAR (prop)))
|| STRINGP (XCDR (XCAR (prop)))
|| VECTORP (XCDR (XCAR (prop)))
|| INTEGERP (XCDR (XCAR (prop)))
|| FIXNUMP (XCDR (XCAR (prop)))
|| CONSP (XCDR (XCAR (prop))))))
&& COMPOSITION_LENGTH (prop) == end - start);
}
@ -274,41 +274,41 @@ enum lglyph_indices
LGLYPH_SIZE
};
#define LGLYPH_NEW() Fmake_vector (make_number (LGLYPH_SIZE), Qnil)
#define LGLYPH_FROM(g) XINT (AREF ((g), LGLYPH_IX_FROM))
#define LGLYPH_TO(g) XINT (AREF ((g), LGLYPH_IX_TO))
#define LGLYPH_CHAR(g) XINT (AREF ((g), LGLYPH_IX_CHAR))
#define LGLYPH_NEW() Fmake_vector (make_fixnum (LGLYPH_SIZE), Qnil)
#define LGLYPH_FROM(g) XFIXNUM (AREF ((g), LGLYPH_IX_FROM))
#define LGLYPH_TO(g) XFIXNUM (AREF ((g), LGLYPH_IX_TO))
#define LGLYPH_CHAR(g) XFIXNUM (AREF ((g), LGLYPH_IX_CHAR))
#define LGLYPH_CODE(g) \
(NILP (AREF ((g), LGLYPH_IX_CODE)) \
? FONT_INVALID_CODE \
: cons_to_unsigned (AREF (g, LGLYPH_IX_CODE), TYPE_MAXIMUM (unsigned)))
#define LGLYPH_WIDTH(g) XINT (AREF ((g), LGLYPH_IX_WIDTH))
#define LGLYPH_LBEARING(g) XINT (AREF ((g), LGLYPH_IX_LBEARING))
#define LGLYPH_RBEARING(g) XINT (AREF ((g), LGLYPH_IX_RBEARING))
#define LGLYPH_ASCENT(g) XINT (AREF ((g), LGLYPH_IX_ASCENT))
#define LGLYPH_DESCENT(g) XINT (AREF ((g), LGLYPH_IX_DESCENT))
#define LGLYPH_WIDTH(g) XFIXNUM (AREF ((g), LGLYPH_IX_WIDTH))
#define LGLYPH_LBEARING(g) XFIXNUM (AREF ((g), LGLYPH_IX_LBEARING))
#define LGLYPH_RBEARING(g) XFIXNUM (AREF ((g), LGLYPH_IX_RBEARING))
#define LGLYPH_ASCENT(g) XFIXNUM (AREF ((g), LGLYPH_IX_ASCENT))
#define LGLYPH_DESCENT(g) XFIXNUM (AREF ((g), LGLYPH_IX_DESCENT))
#define LGLYPH_ADJUSTMENT(g) AREF ((g), LGLYPH_IX_ADJUSTMENT)
#define LGLYPH_SET_FROM(g, val) ASET ((g), LGLYPH_IX_FROM, make_number (val))
#define LGLYPH_SET_TO(g, val) ASET ((g), LGLYPH_IX_TO, make_number (val))
#define LGLYPH_SET_CHAR(g, val) ASET ((g), LGLYPH_IX_CHAR, make_number (val))
#define LGLYPH_SET_FROM(g, val) ASET ((g), LGLYPH_IX_FROM, make_fixnum (val))
#define LGLYPH_SET_TO(g, val) ASET ((g), LGLYPH_IX_TO, make_fixnum (val))
#define LGLYPH_SET_CHAR(g, val) ASET ((g), LGLYPH_IX_CHAR, make_fixnum (val))
/* Callers must assure that VAL is not negative! */
#define LGLYPH_SET_CODE(g, val) \
ASET (g, LGLYPH_IX_CODE, \
val == FONT_INVALID_CODE ? Qnil : INTEGER_TO_CONS (val))
#define LGLYPH_SET_WIDTH(g, val) ASET ((g), LGLYPH_IX_WIDTH, make_number (val))
#define LGLYPH_SET_LBEARING(g, val) ASET ((g), LGLYPH_IX_LBEARING, make_number (val))
#define LGLYPH_SET_RBEARING(g, val) ASET ((g), LGLYPH_IX_RBEARING, make_number (val))
#define LGLYPH_SET_ASCENT(g, val) ASET ((g), LGLYPH_IX_ASCENT, make_number (val))
#define LGLYPH_SET_DESCENT(g, val) ASET ((g), LGLYPH_IX_DESCENT, make_number (val))
#define LGLYPH_SET_WIDTH(g, val) ASET ((g), LGLYPH_IX_WIDTH, make_fixnum (val))
#define LGLYPH_SET_LBEARING(g, val) ASET ((g), LGLYPH_IX_LBEARING, make_fixnum (val))
#define LGLYPH_SET_RBEARING(g, val) ASET ((g), LGLYPH_IX_RBEARING, make_fixnum (val))
#define LGLYPH_SET_ASCENT(g, val) ASET ((g), LGLYPH_IX_ASCENT, make_fixnum (val))
#define LGLYPH_SET_DESCENT(g, val) ASET ((g), LGLYPH_IX_DESCENT, make_fixnum (val))
#define LGLYPH_SET_ADJUSTMENT(g, val) ASET ((g), LGLYPH_IX_ADJUSTMENT, (val))
#define LGLYPH_XOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
? XINT (AREF (LGLYPH_ADJUSTMENT (g), 0)) : 0)
? XFIXNUM (AREF (LGLYPH_ADJUSTMENT (g), 0)) : 0)
#define LGLYPH_YOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
? XINT (AREF (LGLYPH_ADJUSTMENT (g), 1)) : 0)
? XFIXNUM (AREF (LGLYPH_ADJUSTMENT (g), 1)) : 0)
#define LGLYPH_WADJUST(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
? XINT (AREF (LGLYPH_ADJUSTMENT (g), 2)) : 0)
? XFIXNUM (AREF (LGLYPH_ADJUSTMENT (g), 2)) : 0)
extern Lisp_Object composition_gstring_put_cache (Lisp_Object, ptrdiff_t);
extern Lisp_Object composition_gstring_from_id (ptrdiff_t);

7
src/conf_post.h
View file

@ -202,6 +202,13 @@ extern void _DebPrint (const char *fmt, ...);
#endif
#endif
#ifdef emacs /* Don't do this for lib-src. */
/* Tell regex.c to use a type compatible with Emacs. */
#define RE_TRANSLATE_TYPE Lisp_Object
#define RE_TRANSLATE(TBL, C) char_table_translate (TBL, C)
#define RE_TRANSLATE_P(TBL) (!EQ (TBL, make_fixnum (0)))
#endif
/* Tell time_rz.c to use Emacs's getter and setter for TZ.
Only Emacs uses time_rz so this is OK. */
#define getenv_TZ emacs_getenv_TZ

693
src/data.c
View file

File diff suppressed because it is too large Load diff

74
src/dbusbind.c
View file

@ -201,8 +201,8 @@ xd_symbol_to_dbus_type (Lisp_Object object)
arguments to a D-Bus message. */
#define XD_OBJECT_TO_DBUS_TYPE(object) \
((EQ (object, Qt) || NILP (object)) ? DBUS_TYPE_BOOLEAN \
: (NATNUMP (object)) ? DBUS_TYPE_UINT32 \
: (INTEGERP (object)) ? DBUS_TYPE_INT32 \
: (FIXNATP (object)) ? DBUS_TYPE_UINT32 \
: (FIXNUMP (object)) ? DBUS_TYPE_INT32 \
: (FLOATP (object)) ? DBUS_TYPE_DOUBLE \
: (STRINGP (object)) ? DBUS_TYPE_STRING \
: (XD_DBUS_TYPE_P (object)) ? xd_symbol_to_dbus_type (object) \
@ -355,7 +355,7 @@ xd_signature (char *signature, int dtype, int parent_type, Lisp_Object object)
{
case DBUS_TYPE_BYTE:
case DBUS_TYPE_UINT16:
CHECK_NATNUM (object);
CHECK_FIXNAT (object);
sprintf (signature, "%c", dtype);
break;
@ -366,7 +366,7 @@ xd_signature (char *signature, int dtype, int parent_type, Lisp_Object object)
break;
case DBUS_TYPE_INT16:
CHECK_NUMBER (object);
CHECK_FIXNUM (object);
sprintf (signature, "%c", dtype);
break;
@ -378,7 +378,7 @@ xd_signature (char *signature, int dtype, int parent_type, Lisp_Object object)
case DBUS_TYPE_INT32:
case DBUS_TYPE_INT64:
case DBUS_TYPE_DOUBLE:
CHECK_NUMBER_OR_FLOAT (object);
CHECK_FIXNUM_OR_FLOAT (object);
sprintf (signature, "%c", dtype);
break;
@ -519,11 +519,11 @@ xd_signature (char *signature, int dtype, int parent_type, Lisp_Object object)
static intmax_t
xd_extract_signed (Lisp_Object x, intmax_t lo, intmax_t hi)
{
CHECK_NUMBER_OR_FLOAT (x);
if (INTEGERP (x))
CHECK_FIXNUM_OR_FLOAT (x);
if (FIXNUMP (x))
{
if (lo <= XINT (x) && XINT (x) <= hi)
return XINT (x);
if (lo <= XFIXNUM (x) && XFIXNUM (x) <= hi)
return XFIXNUM (x);
}
else
{
@ -547,11 +547,11 @@ xd_extract_signed (Lisp_Object x, intmax_t lo, intmax_t hi)
static uintmax_t
xd_extract_unsigned (Lisp_Object x, uintmax_t hi)
{
CHECK_NUMBER_OR_FLOAT (x);
if (INTEGERP (x))
CHECK_FIXNUM_OR_FLOAT (x);
if (FIXNUMP (x))
{
if (0 <= XINT (x) && XINT (x) <= hi)
return XINT (x);
if (0 <= XFIXNUM (x) && XFIXNUM (x) <= hi)
return XFIXNUM (x);
}
else
{
@ -566,7 +566,7 @@ xd_extract_unsigned (Lisp_Object x, uintmax_t hi)
if (xd_in_read_queued_messages)
Fthrow (Qdbus_error, Qnil);
else
args_out_of_range_3 (x, make_number (0), make_fixnum_or_float (hi));
args_out_of_range_3 (x, make_fixnum (0), make_fixnum_or_float (hi));
}
/* Append C value, extracted from Lisp OBJECT, to iteration ITER.
@ -584,9 +584,9 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
switch (dtype)
{
case DBUS_TYPE_BYTE:
CHECK_NATNUM (object);
CHECK_FIXNAT (object);
{
unsigned char val = XFASTINT (object) & 0xFF;
unsigned char val = XFIXNAT (object) & 0xFF;
XD_DEBUG_MESSAGE ("%c %u", dtype, val);
if (!dbus_message_iter_append_basic (iter, dtype, &val))
XD_SIGNAL2 (build_string ("Unable to append argument"), object);
@ -750,7 +750,7 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
if (!dbus_message_iter_open_container (iter, dtype,
signature, &subiter))
XD_SIGNAL3 (build_string ("Cannot open container"),
make_number (dtype), build_string (signature));
make_fixnum (dtype), build_string (signature));
break;
case DBUS_TYPE_VARIANT:
@ -763,7 +763,7 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
if (!dbus_message_iter_open_container (iter, dtype,
signature, &subiter))
XD_SIGNAL3 (build_string ("Cannot open container"),
make_number (dtype), build_string (signature));
make_fixnum (dtype), build_string (signature));
break;
case DBUS_TYPE_STRUCT:
@ -772,7 +772,7 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
XD_DEBUG_MESSAGE ("%c %s", dtype, XD_OBJECT_TO_STRING (object));
if (!dbus_message_iter_open_container (iter, dtype, NULL, &subiter))
XD_SIGNAL2 (build_string ("Cannot open container"),
make_number (dtype));
make_fixnum (dtype));
break;
}
@ -790,7 +790,7 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
/* Close the subiteration. */
if (!dbus_message_iter_close_container (iter, &subiter))
XD_SIGNAL2 (build_string ("Cannot close container"),
make_number (dtype));
make_fixnum (dtype));
}
}
@ -810,7 +810,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
dbus_message_iter_get_basic (iter, &val);
val = val & 0xFF;
XD_DEBUG_MESSAGE ("%c %u", dtype, val);
return make_number (val);
return make_fixnum (val);
}
case DBUS_TYPE_BOOLEAN:
@ -828,7 +828,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
dbus_message_iter_get_basic (iter, &val);
pval = val;
XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
return make_number (val);
return make_fixnum (val);
}
case DBUS_TYPE_UINT16:
@ -838,7 +838,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
dbus_message_iter_get_basic (iter, &val);
pval = val;
XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
return make_number (val);
return make_fixnum (val);
}
case DBUS_TYPE_INT32:
@ -1200,7 +1200,7 @@ this connection to those buses. */)
refcount = xd_get_connection_references (connection);
XD_DEBUG_MESSAGE ("Bus %s, Reference counter %"pD"d",
XD_OBJECT_TO_STRING (bus), refcount);
return make_number (refcount);
return make_fixnum (refcount);
}
DEFUN ("dbus-get-unique-name", Fdbus_get_unique_name, Sdbus_get_unique_name,
@ -1275,11 +1275,11 @@ usage: (dbus-message-internal &rest REST) */)
service = args[2];
handler = Qnil;
CHECK_NATNUM (message_type);
if (! (DBUS_MESSAGE_TYPE_INVALID < XFASTINT (message_type)
&& XFASTINT (message_type) < DBUS_NUM_MESSAGE_TYPES))
CHECK_FIXNAT (message_type);
if (! (DBUS_MESSAGE_TYPE_INVALID < XFIXNAT (message_type)
&& XFIXNAT (message_type) < DBUS_NUM_MESSAGE_TYPES))
XD_SIGNAL2 (build_string ("Invalid message type"), message_type);
mtype = XFASTINT (message_type);
mtype = XFIXNAT (message_type);
if ((mtype == DBUS_MESSAGE_TYPE_METHOD_CALL)
|| (mtype == DBUS_MESSAGE_TYPE_SIGNAL))
@ -1303,7 +1303,7 @@ usage: (dbus-message-internal &rest REST) */)
if (nargs < count)
xsignal2 (Qwrong_number_of_arguments,
Qdbus_message_internal,
make_number (nargs));
make_fixnum (nargs));
if ((mtype == DBUS_MESSAGE_TYPE_METHOD_CALL)
|| (mtype == DBUS_MESSAGE_TYPE_SIGNAL))
@ -1409,8 +1409,8 @@ usage: (dbus-message-internal &rest REST) */)
/* Check for timeout parameter. */
if ((count + 2 <= nargs) && EQ (args[count], QCtimeout))
{
CHECK_NATNUM (args[count+1]);
timeout = min (XFASTINT (args[count+1]), INT_MAX);
CHECK_FIXNAT (args[count+1]);
timeout = min (XFIXNAT (args[count+1]), INT_MAX);
count = count+2;
}
@ -1609,7 +1609,7 @@ xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
event.arg = Fcons ((uname == NULL ? Qnil : build_string (uname)),
event.arg);
event.arg = Fcons (make_fixnum_or_float (serial), event.arg);
event.arg = Fcons (make_number (mtype), event.arg);
event.arg = Fcons (make_fixnum (mtype), event.arg);
/* Add the bus symbol to the event. */
event.arg = Fcons (bus, event.arg);
@ -1754,28 +1754,28 @@ syms_of_dbusbind (void)
DEFVAR_LISP ("dbus-message-type-invalid",
Vdbus_message_type_invalid,
doc: /* This value is never a valid message type. */);
Vdbus_message_type_invalid = make_number (DBUS_MESSAGE_TYPE_INVALID);
Vdbus_message_type_invalid = make_fixnum (DBUS_MESSAGE_TYPE_INVALID);
DEFVAR_LISP ("dbus-message-type-method-call",
Vdbus_message_type_method_call,
doc: /* Message type of a method call message. */);
Vdbus_message_type_method_call = make_number (DBUS_MESSAGE_TYPE_METHOD_CALL);
Vdbus_message_type_method_call = make_fixnum (DBUS_MESSAGE_TYPE_METHOD_CALL);
DEFVAR_LISP ("dbus-message-type-method-return",
Vdbus_message_type_method_return,
doc: /* Message type of a method return message. */);
Vdbus_message_type_method_return
= make_number (DBUS_MESSAGE_TYPE_METHOD_RETURN);
= make_fixnum (DBUS_MESSAGE_TYPE_METHOD_RETURN);
DEFVAR_LISP ("dbus-message-type-error",
Vdbus_message_type_error,
doc: /* Message type of an error reply message. */);
Vdbus_message_type_error = make_number (DBUS_MESSAGE_TYPE_ERROR);
Vdbus_message_type_error = make_fixnum (DBUS_MESSAGE_TYPE_ERROR);
DEFVAR_LISP ("dbus-message-type-signal",
Vdbus_message_type_signal,
doc: /* Message type of a signal message. */);
Vdbus_message_type_signal = make_number (DBUS_MESSAGE_TYPE_SIGNAL);
Vdbus_message_type_signal = make_fixnum (DBUS_MESSAGE_TYPE_SIGNAL);
DEFVAR_LISP ("dbus-registered-objects-table",
Vdbus_registered_objects_table,

4
src/decompress.c
View file

@ -149,8 +149,8 @@ This function can be called only in unibyte buffers. */)
/* This is a unibyte buffer, so character positions and bytes are
the same. */
istart = XINT (start);
iend = XINT (end);
istart = XFIXNUM (start);
iend = XFIXNUM (end);
/* Do the following before manipulating the gap. */
modify_text (istart, iend);

22
src/dired.c
View file

@ -671,15 +671,15 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
/* Reject entries where the encoded strings match, but the
decoded don't. For example, "a" should not match "a-ring" on
file systems that store decomposed characters. */
Lisp_Object zero = make_number (0);
Lisp_Object zero = make_fixnum (0);
if (check_decoded && SCHARS (file) <= SCHARS (name))
{
/* FIXME: This is a copy of the code below. */
ptrdiff_t compare = SCHARS (file);
Lisp_Object cmp
= Fcompare_strings (name, zero, make_number (compare),
file, zero, make_number (compare),
= Fcompare_strings (name, zero, make_fixnum (compare),
file, zero, make_fixnum (compare),
completion_ignore_case ? Qt : Qnil);
if (!EQ (cmp, Qt))
continue;
@ -701,10 +701,10 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
/* FIXME: This is a copy of the code in Ftry_completion. */
ptrdiff_t compare = min (bestmatchsize, SCHARS (name));
Lisp_Object cmp
= Fcompare_strings (bestmatch, zero, make_number (compare),
name, zero, make_number (compare),
= Fcompare_strings (bestmatch, zero, make_fixnum (compare),
name, zero, make_fixnum (compare),
completion_ignore_case ? Qt : Qnil);
ptrdiff_t matchsize = EQ (cmp, Qt) ? compare : eabs (XINT (cmp)) - 1;
ptrdiff_t matchsize = EQ (cmp, Qt) ? compare : eabs (XFIXNUM (cmp)) - 1;
if (completion_ignore_case)
{
@ -729,13 +729,13 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
==
(matchsize + directoryp == SCHARS (bestmatch)))
&& (cmp = Fcompare_strings (name, zero,
make_number (SCHARS (file)),
make_fixnum (SCHARS (file)),
file, zero,
Qnil,
Qnil),
EQ (Qt, cmp))
&& (cmp = Fcompare_strings (bestmatch, zero,
make_number (SCHARS (file)),
make_fixnum (SCHARS (file)),
file, zero,
Qnil,
Qnil),
@ -769,8 +769,8 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
it does not require any change to be made. */
if (matchcount == 1 && !NILP (Fequal (bestmatch, file)))
return Qt;
bestmatch = Fsubstring (bestmatch, make_number (0),
make_number (bestmatchsize));
bestmatch = Fsubstring (bestmatch, make_fixnum (0),
make_fixnum (bestmatchsize));
return bestmatch;
}
@ -1009,7 +1009,7 @@ file_attributes (int fd, char const *name,
return CALLN (Flist,
file_type,
make_number (s.st_nlink),
make_fixnum (s.st_nlink),
(uname
? DECODE_SYSTEM (build_unibyte_string (uname))
: make_fixnum_or_float (s.st_uid)),

16
src/dispextern.h
View file

@ -306,24 +306,24 @@ INLINE int
GLYPH_CODE_CHAR (Lisp_Object gc)
{
return (CONSP (gc)
? XINT (XCAR (gc))
: XINT (gc) & MAX_CHAR);
? XFIXNUM (XCAR (gc))
: XFIXNUM (gc) & MAX_CHAR);
}
INLINE int
GLYPH_CODE_FACE (Lisp_Object gc)
{
return CONSP (gc) ? XINT (XCDR (gc)) : XINT (gc) >> CHARACTERBITS;
return CONSP (gc) ? XFIXNUM (XCDR (gc)) : XFIXNUM (gc) >> CHARACTERBITS;
}
#define SET_GLYPH_FROM_GLYPH_CODE(glyph, gc) \
do \
{ \
if (CONSP (gc)) \
SET_GLYPH (glyph, XINT (XCAR (gc)), XINT (XCDR (gc))); \
SET_GLYPH (glyph, XFIXNUM (XCAR (gc)), XFIXNUM (XCDR (gc))); \
else \
SET_GLYPH (glyph, (XINT (gc) & ((1 << CHARACTERBITS)-1)), \
(XINT (gc) >> CHARACTERBITS)); \
SET_GLYPH (glyph, (XFIXNUM (gc) & ((1 << CHARACTERBITS)-1)), \
(XFIXNUM (gc) >> CHARACTERBITS)); \
} \
while (false)
@ -1837,8 +1837,8 @@ GLYPH_CODE_P (Lisp_Object gc)
{
return (CONSP (gc)
? (CHARACTERP (XCAR (gc))
&& RANGED_INTEGERP (0, XCDR (gc), MAX_FACE_ID))
: (RANGED_INTEGERP
&& RANGED_FIXNUMP (0, XCDR (gc), MAX_FACE_ID))
: (RANGED_FIXNUMP
(0, gc,
(MAX_FACE_ID < TYPE_MAXIMUM (EMACS_INT) >> CHARACTERBITS
? ((EMACS_INT) MAX_FACE_ID << CHARACTERBITS) | MAX_CHAR

18
src/dispnew.c
View file

@ -5717,8 +5717,8 @@ additional wait period, in milliseconds; this is for backwards compatibility.
if (!NILP (milliseconds))
{
CHECK_NUMBER (milliseconds);
duration += XINT (milliseconds) / 1000.0;
CHECK_FIXNUM (milliseconds);
duration += XFIXNUM (milliseconds) / 1000.0;
}
if (duration > 0)
@ -5766,9 +5766,9 @@ sit_for (Lisp_Object timeout, bool reading, int display_option)
if (display_option > 1)
redisplay_preserve_echo_area (2);
if (INTEGERP (timeout))
if (FIXNUMP (timeout))
{
sec = XINT (timeout);
sec = XFIXNUM (timeout);
if (sec <= 0)
return Qt;
nsec = 0;
@ -5925,7 +5925,7 @@ pass nil for VARIABLE. */)
|| n + 20 < ASIZE (state) / 2)
/* Add 20 extra so we grow it less often. */
{
state = Fmake_vector (make_number (n + 20), Qlambda);
state = Fmake_vector (make_fixnum (n + 20), Qlambda);
if (! NILP (variable))
Fset (variable, state);
else
@ -6041,7 +6041,7 @@ init_display (void)
{
Vinitial_window_system = Qx;
#ifdef HAVE_X11
Vwindow_system_version = make_number (11);
Vwindow_system_version = make_fixnum (11);
#endif
#ifdef USE_NCURSES
/* In some versions of ncurses,
@ -6057,7 +6057,7 @@ init_display (void)
if (!inhibit_window_system)
{
Vinitial_window_system = Qw32;
Vwindow_system_version = make_number (1);
Vwindow_system_version = make_fixnum (1);
return;
}
#endif /* HAVE_NTGUI */
@ -6070,7 +6070,7 @@ init_display (void)
)
{
Vinitial_window_system = Qns;
Vwindow_system_version = make_number (10);
Vwindow_system_version = make_fixnum (10);
return;
}
#endif
@ -6223,7 +6223,7 @@ syms_of_display (void)
defsubr (&Sdump_redisplay_history);
#endif
frame_and_buffer_state = Fmake_vector (make_number (20), Qlambda);
frame_and_buffer_state = Fmake_vector (make_fixnum (20), Qlambda);
staticpro (&frame_and_buffer_state);
/* This is the "purpose" slot of a display table. */

4
src/disptab.h
View file

@ -72,14 +72,14 @@ extern struct Lisp_Char_Table *buffer_display_table (void);
/* Given BASE and LEN returned by the two previous macros,
return nonzero if GLYPH code G is aliased to a different code. */
#define GLYPH_ALIAS_P(base,len,g) \
(GLYPH_FACE (g) == DEFAULT_FACE_ID && GLYPH_CHAR (g) < (len) && INTEGERP (base[GLYPH_CHAR (g)]))
(GLYPH_FACE (g) == DEFAULT_FACE_ID && GLYPH_CHAR (g) < (len) && FIXNUMP (base[GLYPH_CHAR (g)]))
/* Follow all aliases for G in the glyph table given by (BASE,
LENGTH), and set G to the final glyph. */
#define GLYPH_FOLLOW_ALIASES(base, length, g) \
do { \
while (GLYPH_ALIAS_P ((base), (length), (g))) \
SET_GLYPH_CHAR ((g), XINT ((base)[GLYPH_CHAR (g)])); \
SET_GLYPH_CHAR ((g), XFIXNUM ((base)[GLYPH_CHAR (g)])); \
if (!GLYPH_CHAR_VALID_P (g)) \
SET_GLYPH_CHAR (g, ' '); \
} while (false)

28
src/doc.c
View file

@ -89,7 +89,7 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
ptrdiff_t count = SPECPDL_INDEX ();
USE_SAFE_ALLOCA;
if (INTEGERP (filepos))
if (FIXNUMP (filepos))
{
file = Vdoc_file_name;
pos = filepos;
@ -102,7 +102,7 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
else
return Qnil;
position = eabs (XINT (pos));
position = eabs (XFIXNUM (pos));
if (!STRINGP (Vdoc_directory))
return Qnil;
@ -339,7 +339,7 @@ string is passed through `substitute-command-keys'. */)
if (CONSP (fun) && EQ (XCAR (fun), Qmacro))
fun = XCDR (fun);
if (SUBRP (fun))
doc = make_number (XSUBR (fun)->doc);
doc = make_fixnum (XSUBR (fun)->doc);
else if (MODULE_FUNCTIONP (fun))
doc = XMODULE_FUNCTION (fun)->documentation;
else if (COMPILEDP (fun))
@ -351,7 +351,7 @@ string is passed through `substitute-command-keys'. */)
Lisp_Object tem = AREF (fun, COMPILED_DOC_STRING);
if (STRINGP (tem))
doc = tem;
else if (NATNUMP (tem) || CONSP (tem))
else if (FIXNATP (tem) || CONSP (tem))
doc = tem;
else
return Qnil;
@ -378,7 +378,7 @@ string is passed through `substitute-command-keys'. */)
doc = tem;
/* Handle a doc reference--but these never come last
in the function body, so reject them if they are last. */
else if ((NATNUMP (tem) || (CONSP (tem) && INTEGERP (XCDR (tem))))
else if ((FIXNATP (tem) || (CONSP (tem) && FIXNUMP (XCDR (tem))))
&& !NILP (XCDR (tem1)))
doc = tem;
else
@ -395,9 +395,9 @@ string is passed through `substitute-command-keys'. */)
/* If DOC is 0, it's typically because of a dumped file missing
from the DOC file (bug in src/Makefile.in). */
if (EQ (doc, make_number (0)))
if (EQ (doc, make_fixnum (0)))
doc = Qnil;
if (INTEGERP (doc) || CONSP (doc))
if (FIXNUMP (doc) || CONSP (doc))
{
Lisp_Object tem;
tem = get_doc_string (doc, 0, 0);
@ -437,9 +437,9 @@ aren't strings. */)
documentation_property:
tem = Fget (symbol, prop);
if (EQ (tem, make_number (0)))
if (EQ (tem, make_fixnum (0)))
tem = Qnil;
if (INTEGERP (tem) || (CONSP (tem) && INTEGERP (XCDR (tem))))
if (FIXNUMP (tem) || (CONSP (tem) && FIXNUMP (XCDR (tem))))
{
Lisp_Object doc = tem;
tem = get_doc_string (tem, 0, 0);
@ -486,10 +486,10 @@ store_function_docstring (Lisp_Object obj, EMACS_INT offset)
|| (EQ (tem, Qclosure) && (fun = XCDR (fun), 1)))
{
tem = Fcdr (Fcdr (fun));
if (CONSP (tem) && INTEGERP (XCAR (tem)))
if (CONSP (tem) && FIXNUMP (XCAR (tem)))
/* FIXME: This modifies typically pure hash-cons'd data, so its
correctness is quite delicate. */
XSETCAR (tem, make_number (offset));
XSETCAR (tem, make_fixnum (offset));
}
}
@ -503,7 +503,7 @@ store_function_docstring (Lisp_Object obj, EMACS_INT offset)
/* This bytecode object must have a slot for the
docstring, since we've found a docstring for it. */
if (PVSIZE (fun) > COMPILED_DOC_STRING)
ASET (fun, COMPILED_DOC_STRING, make_number (offset));
ASET (fun, COMPILED_DOC_STRING, make_fixnum (offset));
else
{
AUTO_STRING (format, "No docstring slot for %s");
@ -635,7 +635,7 @@ the same file name is found in the `doc-directory'. */)
|| !NILP (Fmemq (sym, delayed_init)))
&& strncmp (end, "\nSKIP", 5))
Fput (sym, Qvariable_documentation,
make_number ((pos + end + 1 - buf)
make_fixnum ((pos + end + 1 - buf)
* (end[1] == '*' ? -1 : 1)));
}
@ -671,7 +671,7 @@ default_to_grave_quoting_style (void)
Lisp_Object dv = DISP_CHAR_VECTOR (XCHAR_TABLE (Vstandard_display_table),
LEFT_SINGLE_QUOTATION_MARK);
return (VECTORP (dv) && ASIZE (dv) == 1
&& EQ (AREF (dv, 0), make_number ('`')));
&& EQ (AREF (dv, 0), make_fixnum ('`')));
}
/* Return the current effective text quoting style. */

68
src/dosfns.c
View file

@ -66,33 +66,33 @@ REGISTERS should be a vector produced by `make-register' and
int no;
union REGS inregs, outregs;
CHECK_NUMBER (interrupt);
no = (unsigned long) XINT (interrupt);
CHECK_FIXNUM (interrupt);
no = (unsigned long) XFIXNUM (interrupt);
CHECK_VECTOR (registers);
if (no < 0 || no > 0xff || ASIZE (registers) != 8)
return Qnil;
for (i = 0; i < 8; i++)
CHECK_NUMBER (AREF (registers, i));
CHECK_FIXNUM (AREF (registers, i));
inregs.x.ax = (unsigned long) XFASTINT (AREF (registers, 0));
inregs.x.bx = (unsigned long) XFASTINT (AREF (registers, 1));
inregs.x.cx = (unsigned long) XFASTINT (AREF (registers, 2));
inregs.x.dx = (unsigned long) XFASTINT (AREF (registers, 3));
inregs.x.si = (unsigned long) XFASTINT (AREF (registers, 4));
inregs.x.di = (unsigned long) XFASTINT (AREF (registers, 5));
inregs.x.cflag = (unsigned long) XFASTINT (AREF (registers, 6));
inregs.x.flags = (unsigned long) XFASTINT (AREF (registers, 7));
inregs.x.ax = (unsigned long) XFIXNAT (AREF (registers, 0));
inregs.x.bx = (unsigned long) XFIXNAT (AREF (registers, 1));
inregs.x.cx = (unsigned long) XFIXNAT (AREF (registers, 2));
inregs.x.dx = (unsigned long) XFIXNAT (AREF (registers, 3));
inregs.x.si = (unsigned long) XFIXNAT (AREF (registers, 4));
inregs.x.di = (unsigned long) XFIXNAT (AREF (registers, 5));
inregs.x.cflag = (unsigned long) XFIXNAT (AREF (registers, 6));
inregs.x.flags = (unsigned long) XFIXNAT (AREF (registers, 7));
int86 (no, &inregs, &outregs);
ASET (registers, 0, make_number (outregs.x.ax));
ASET (registers, 1, make_number (outregs.x.bx));
ASET (registers, 2, make_number (outregs.x.cx));
ASET (registers, 3, make_number (outregs.x.dx));
ASET (registers, 4, make_number (outregs.x.si));
ASET (registers, 5, make_number (outregs.x.di));
ASET (registers, 6, make_number (outregs.x.cflag));
ASET (registers, 7, make_number (outregs.x.flags));
ASET (registers, 0, make_fixnum (outregs.x.ax));
ASET (registers, 1, make_fixnum (outregs.x.bx));
ASET (registers, 2, make_fixnum (outregs.x.cx));
ASET (registers, 3, make_fixnum (outregs.x.dx));
ASET (registers, 4, make_fixnum (outregs.x.si));
ASET (registers, 5, make_fixnum (outregs.x.di));
ASET (registers, 6, make_fixnum (outregs.x.cflag));
ASET (registers, 7, make_fixnum (outregs.x.flags));
return registers;
}
@ -106,8 +106,8 @@ Return the updated VECTOR. */)
int offs, len;
char *buf;
CHECK_NUMBER (address);
offs = (unsigned long) XINT (address);
CHECK_FIXNUM (address);
offs = (unsigned long) XFIXNUM (address);
CHECK_VECTOR (vector);
len = ASIZE (vector);
if (len < 1 || len > 2048 || offs < 0 || offs > 0xfffff - len)
@ -116,7 +116,7 @@ Return the updated VECTOR. */)
dosmemget (offs, len, buf);
for (i = 0; i < len; i++)
ASET (vector, i, make_number (buf[i]));
ASET (vector, i, make_fixnum (buf[i]));
return vector;
}
@ -129,8 +129,8 @@ DEFUN ("msdos-memput", Fdos_memput, Sdos_memput, 2, 2, 0,
int offs, len;
char *buf;
CHECK_NUMBER (address);
offs = (unsigned long) XINT (address);
CHECK_FIXNUM (address);
offs = (unsigned long) XFIXNUM (address);
CHECK_VECTOR (vector);
len = ASIZE (vector);
if (len < 1 || len > 2048 || offs < 0 || offs > 0xfffff - len)
@ -139,8 +139,8 @@ DEFUN ("msdos-memput", Fdos_memput, Sdos_memput, 2, 2, 0,
for (i = 0; i < len; i++)
{
CHECK_NUMBER (AREF (vector, i));
buf[i] = (unsigned char) XFASTINT (AREF (vector, i)) & 0xFF;
CHECK_FIXNUM (AREF (vector, i));
buf[i] = (unsigned char) XFIXNAT (AREF (vector, i)) & 0xFF;
}
dosmemput (buf, len, offs);
@ -154,8 +154,8 @@ all keys; otherwise it is only used when the ALT key is pressed.
The current keyboard layout is available in dos-keyboard-code. */)
(Lisp_Object country_code, Lisp_Object allkeys)
{
CHECK_NUMBER (country_code);
if (!dos_set_keyboard (XINT (country_code), !NILP (allkeys)))
CHECK_FIXNUM (country_code);
if (!dos_set_keyboard (XFIXNUM (country_code), !NILP (allkeys)))
return Qnil;
return Qt;
}
@ -280,7 +280,7 @@ init_dosfns (void)
regs.x.ax = 0x3000;
intdos (&regs, &regs);
Vdos_version = Fcons (make_number (regs.h.al), make_number (regs.h.ah));
Vdos_version = Fcons (make_fixnum (regs.h.al), make_fixnum (regs.h.ah));
/* Obtain the country code via DPMI, use DJGPP transfer buffer. */
dpmiregs.x.ax = 0x3800;
@ -341,7 +341,7 @@ init_dosfns (void)
{
dos_windows_version = dpmiregs.x.ax;
Vdos_windows_version =
Fcons (make_number (dpmiregs.h.al), make_number (dpmiregs.h.ah));
Fcons (make_fixnum (dpmiregs.h.al), make_fixnum (dpmiregs.h.ah));
/* Save the current title of this virtual machine, so we can restore
it before exiting. Otherwise, Windows 95 will continue to use
@ -520,8 +520,8 @@ system_process_attributes (Lisp_Object pid)
int proc_id;
Lisp_Object attrs = Qnil;
CHECK_NUMBER_OR_FLOAT (pid);
proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
CHECK_FIXNUM_OR_FLOAT (pid);
proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XFIXNUM (pid);
if (proc_id == getpid ())
{
@ -555,13 +555,13 @@ system_process_attributes (Lisp_Object pid)
Vlocale_coding_system, 0);
attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
/* Pretend we have 0 as PPID. */
attrs = Fcons (Fcons (Qppid, make_number (0)), attrs);
attrs = Fcons (Fcons (Qppid, make_fixnum (0)), attrs);
attrs = Fcons (Fcons (Qpgrp, pid), attrs);
attrs = Fcons (Fcons (Qttname, build_string ("/dev/tty")), attrs);
/* We are never idle! */
tem = Fget_internal_run_time ();
attrs = Fcons (Fcons (Qtime, tem), attrs);
attrs = Fcons (Fcons (Qthcount, make_number (1)), attrs);
attrs = Fcons (Fcons (Qthcount, make_fixnum (1)), attrs);
attrs = Fcons (Fcons (Qstart,
Fsymbol_value (intern ("before-init-time"))),
attrs);

402
src/editfns.c
View file

File diff suppressed because it is too large Load diff

47
src/emacs-module.c
View file

@ -302,15 +302,15 @@ module_make_global_ref (emacs_env *env, emacs_value ref)
if (i >= 0)
{
Lisp_Object value = HASH_VALUE (h, i);
EMACS_INT refcount = XFASTINT (value) + 1;
EMACS_INT refcount = XFIXNAT (value) + 1;
if (MOST_POSITIVE_FIXNUM < refcount)
xsignal0 (Qoverflow_error);
value = make_natnum (refcount);
value = make_fixed_natnum (refcount);
set_hash_value_slot (h, i, value);
}
else
{
hash_put (h, new_obj, make_natnum (1), hashcode);
hash_put (h, new_obj, make_fixed_natnum (1), hashcode);
}
return lisp_to_value (module_assertions ? global_env : env, new_obj);
@ -329,9 +329,9 @@ module_free_global_ref (emacs_env *env, emacs_value ref)
if (i >= 0)
{
EMACS_INT refcount = XFASTINT (HASH_VALUE (h, i)) - 1;
EMACS_INT refcount = XFIXNAT (HASH_VALUE (h, i)) - 1;
if (refcount > 0)
set_hash_value_slot (h, i, make_natnum (refcount));
set_hash_value_slot (h, i, make_fixed_natnum (refcount));
else
{
eassert (refcount == 0);
@ -441,7 +441,7 @@ module_make_function (emacs_env *env, ptrdiff_t min_arity, ptrdiff_t max_arity,
? (min_arity <= MOST_POSITIVE_FIXNUM
&& max_arity == emacs_variadic_function)
: min_arity <= max_arity && max_arity <= MOST_POSITIVE_FIXNUM)))
xsignal2 (Qinvalid_arity, make_number (min_arity), make_number (max_arity));
xsignal2 (Qinvalid_arity, make_fixnum (min_arity), make_fixnum (max_arity));
struct Lisp_Module_Function *function = allocate_module_function ();
function->min_arity = min_arity;
@ -518,17 +518,32 @@ module_extract_integer (emacs_env *env, emacs_value n)
{
MODULE_FUNCTION_BEGIN (0);
Lisp_Object l = value_to_lisp (n);
CHECK_NUMBER (l);
return XINT (l);
CHECK_INTEGER (l);
if (BIGNUMP (l))
{
if (!mpz_fits_slong_p (XBIGNUM (l)->value))
xsignal1 (Qoverflow_error, l);
return mpz_get_si (XBIGNUM (l)->value);
}
return XFIXNUM (l);
}
static emacs_value
module_make_integer (emacs_env *env, intmax_t n)
{
Lisp_Object obj;
MODULE_FUNCTION_BEGIN (module_nil);
if (FIXNUM_OVERFLOW_P (n))
xsignal0 (Qoverflow_error);
return lisp_to_value (env, make_number (n));
{
mpz_t val;
mpz_init (val);
mpz_set_intmax (val, n);
obj = make_number (val);
mpz_clear (val);
}
else
obj = make_fixnum (n);
return lisp_to_value (env, obj);
}
static double
@ -640,7 +655,7 @@ check_vec_index (Lisp_Object lvec, ptrdiff_t i)
CHECK_VECTOR (lvec);
if (! (0 <= i && i < ASIZE (lvec)))
args_out_of_range_3 (make_fixnum_or_float (i),
make_number (0), make_number (ASIZE (lvec) - 1));
make_fixnum (0), make_fixnum (ASIZE (lvec) - 1));
}
static void
@ -749,7 +764,7 @@ DEFUN ("module-load", Fmodule_load, Smodule_load, 1, 1, 0,
{
if (FIXNUM_OVERFLOW_P (r))
xsignal0 (Qoverflow_error);
xsignal2 (Qmodule_init_failed, file, make_number (r));
xsignal2 (Qmodule_init_failed, file, make_fixnum (r));
}
module_signal_or_throw (&env_priv);
@ -763,7 +778,7 @@ funcall_module (Lisp_Object function, ptrdiff_t nargs, Lisp_Object *arglist)
eassume (0 <= func->min_arity);
if (! (func->min_arity <= nargs
&& (func->max_arity < 0 || nargs <= func->max_arity)))
xsignal2 (Qwrong_number_of_arguments, function, make_number (nargs));
xsignal2 (Qwrong_number_of_arguments, function, make_fixnum (nargs));
emacs_env pub;
struct emacs_env_private priv;
@ -802,8 +817,8 @@ module_function_arity (const struct Lisp_Module_Function *const function)
{
ptrdiff_t minargs = function->min_arity;
ptrdiff_t maxargs = function->max_arity;
return Fcons (make_number (minargs),
maxargs == MANY ? Qmany : make_number (maxargs));
return Fcons (make_fixnum (minargs),
maxargs == MANY ? Qmany : make_fixnum (maxargs));
}
@ -991,7 +1006,7 @@ lisp_to_value_bits (Lisp_Object o)
/* Compress O into the space of a pointer, possibly losing information. */
EMACS_UINT u = XLI (o);
if (INTEGERP (o))
if (FIXNUMP (o))
{
uintptr_t i = (u << VALBITS) + XTYPE (o);
return (emacs_value) i;

30
src/emacs.c
View file

@ -377,7 +377,7 @@ terminate_due_to_signal (int sig, int backtrace_limit)
totally_unblock_input ();
if (sig == SIGTERM || sig == SIGHUP || sig == SIGINT)
Fkill_emacs (make_number (sig));
Fkill_emacs (make_fixnum (sig));
shut_down_emacs (sig, Qnil);
emacs_backtrace (backtrace_limit);
@ -446,7 +446,7 @@ init_cmdargs (int argc, char **argv, int skip_args, char *original_pwd)
{
Lisp_Object found;
int yes = openp (Vexec_path, Vinvocation_name,
Vexec_suffixes, &found, make_number (X_OK), false);
Vexec_suffixes, &found, make_fixnum (X_OK), false);
if (yes == 1)
{
/* Add /: to the front of the name
@ -673,6 +673,20 @@ close_output_streams (void)
_exit (EXIT_FAILURE);
}
/* Wrapper function for GMP. */
static void *
xrealloc_for_gmp (void *ptr, size_t ignore, size_t size)
{
return xrealloc (ptr, size);
}
/* Wrapper function for GMP. */
static void
xfree_for_gmp (void *ptr, size_t ignore)
{
xfree (ptr);
}
/* ARGSUSED */
int
main (int argc, char **argv)
@ -771,6 +785,8 @@ main (int argc, char **argv)
init_standard_fds ();
atexit (close_output_streams);
mp_set_memory_functions (xmalloc, xrealloc_for_gmp, xfree_for_gmp);
sort_args (argc, argv);
argc = 0;
while (argv[argc]) argc++;
@ -2052,10 +2068,10 @@ all of which are called before Emacs is actually killed. */
unlink (SSDATA (listfile));
}
if (INTEGERP (arg))
exit_code = (XINT (arg) < 0
? XINT (arg) | INT_MIN
: XINT (arg) & INT_MAX);
if (FIXNUMP (arg))
exit_code = (XFIXNUM (arg) < 0
? XFIXNUM (arg) | INT_MIN
: XFIXNUM (arg) & INT_MAX);
else
exit_code = EXIT_SUCCESS;
exit (exit_code);
@ -2416,7 +2432,7 @@ decode_env_path (const char *evarname, const char *defalt, bool empty)
&& strncmp (path, emacs_dir_env, emacs_dir_len) == 0)
element = Fexpand_file_name (Fsubstring
(element,
make_number (emacs_dir_len),
make_fixnum (emacs_dir_len),
Qnil),
build_unibyte_string (emacs_dir));
#endif

56
src/eval.c
View file

@ -264,8 +264,8 @@ init_eval (void)
static void
restore_stack_limits (Lisp_Object data)
{
max_specpdl_size = XINT (XCAR (data));
max_lisp_eval_depth = XINT (XCDR (data));
max_specpdl_size = XFIXNUM (XCAR (data));
max_lisp_eval_depth = XFIXNUM (XCDR (data));
}
static void grow_specpdl (void);
@ -303,8 +303,8 @@ call_debugger (Lisp_Object arg)
/* Restore limits after leaving the debugger. */
record_unwind_protect (restore_stack_limits,
Fcons (make_number (old_max),
make_number (old_depth)));
Fcons (make_fixnum (old_max),
make_fixnum (old_depth)));
#ifdef HAVE_WINDOW_SYSTEM
if (display_hourglass_p)
@ -511,7 +511,7 @@ usage: (setq [SYM VAL]...) */)
Lisp_Object sym = XCAR (tail), lex_binding;
tail = XCDR (tail);
if (!CONSP (tail))
xsignal2 (Qwrong_number_of_arguments, Qsetq, make_number (nargs + 1));
xsignal2 (Qwrong_number_of_arguments, Qsetq, make_fixnum (nargs + 1));
Lisp_Object arg = XCAR (tail);
tail = XCDR (tail);
val = eval_sub (arg);
@ -938,7 +938,7 @@ usage: (let VARLIST BODY...) */)
CHECK_LIST (varlist);
/* Make space to hold the values to give the bound variables. */
EMACS_INT varlist_len = XFASTINT (Flength (varlist));
EMACS_INT varlist_len = XFIXNAT (Flength (varlist));
SAFE_ALLOCA_LISP (temps, varlist_len);
ptrdiff_t nvars = varlist_len;
@ -1991,12 +1991,12 @@ this does nothing and returns nil. */)
&& !AUTOLOADP (XSYMBOL (function)->u.s.function))
return Qnil;
if (!NILP (Vpurify_flag) && EQ (docstring, make_number (0)))
if (!NILP (Vpurify_flag) && EQ (docstring, make_fixnum (0)))
/* `read1' in lread.c has found the docstring starting with "\
and assumed the docstring will be provided by Snarf-documentation, so it
passed us 0 instead. But that leads to accidental sharing in purecopy's
hash-consing, so we use a (hopefully) unique integer instead. */
docstring = make_number (XHASH (function));
docstring = make_fixnum (XHASH (function));
return Fdefalias (function,
list5 (Qautoload, file, docstring, interactive, type),
Qnil);
@ -2016,7 +2016,7 @@ un_autoload (Lisp_Object oldqueue)
first = XCAR (queue);
second = Fcdr (first);
first = Fcar (first);
if (EQ (first, make_number (0)))
if (EQ (first, make_fixnum (0)))
Vfeatures = second;
else
Ffset (first, second);
@ -2041,7 +2041,7 @@ it defines a macro. */)
if (!CONSP (fundef) || !EQ (Qautoload, XCAR (fundef)))
return fundef;
Lisp_Object kind = Fnth (make_number (4), fundef);
Lisp_Object kind = Fnth (make_fixnum (4), fundef);
if (EQ (macro_only, Qmacro)
&& !(EQ (kind, Qt) || EQ (kind, Qmacro)))
return fundef;
@ -2230,9 +2230,9 @@ eval_sub (Lisp_Object form)
check_cons_list ();
if (XINT (numargs) < XSUBR (fun)->min_args
if (XFIXNUM (numargs) < XSUBR (fun)->min_args
|| (XSUBR (fun)->max_args >= 0
&& XSUBR (fun)->max_args < XINT (numargs)))
&& XSUBR (fun)->max_args < XFIXNUM (numargs)))
xsignal2 (Qwrong_number_of_arguments, original_fun, numargs);
else if (XSUBR (fun)->max_args == UNEVALLED)
@ -2244,9 +2244,9 @@ eval_sub (Lisp_Object form)
ptrdiff_t argnum = 0;
USE_SAFE_ALLOCA;
SAFE_ALLOCA_LISP (vals, XINT (numargs));
SAFE_ALLOCA_LISP (vals, XFIXNUM (numargs));
while (CONSP (args_left) && argnum < XINT (numargs))
while (CONSP (args_left) && argnum < XFIXNUM (numargs))
{
Lisp_Object arg = XCAR (args_left);
args_left = XCDR (args_left);
@ -2276,7 +2276,7 @@ eval_sub (Lisp_Object form)
args_left = Fcdr (args_left);
}
set_backtrace_args (specpdl + count, argvals, XINT (numargs));
set_backtrace_args (specpdl + count, argvals, XFIXNUM (numargs));
switch (i)
{
@ -2389,7 +2389,7 @@ usage: (apply FUNCTION &rest ARGUMENTS) */)
CHECK_LIST (spread_arg);
numargs = XINT (Flength (spread_arg));
numargs = XFIXNUM (Flength (spread_arg));
if (numargs == 0)
return Ffuncall (nargs - 1, args);
@ -2863,7 +2863,7 @@ funcall_subr (struct Lisp_Subr *subr, ptrdiff_t numargs, Lisp_Object *args)
{
Lisp_Object fun;
XSETSUBR (fun, subr);
xsignal2 (Qwrong_number_of_arguments, fun, make_number (numargs));
xsignal2 (Qwrong_number_of_arguments, fun, make_fixnum (numargs));
}
else if (subr->max_args == UNEVALLED)
@ -2944,7 +2944,7 @@ apply_lambda (Lisp_Object fun, Lisp_Object args, ptrdiff_t count)
Lisp_Object tem;
USE_SAFE_ALLOCA;
numargs = XFASTINT (Flength (args));
numargs = XFIXNAT (Flength (args));
SAFE_ALLOCA_LISP (arg_vector, numargs);
args_left = args;
@ -3006,7 +3006,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
if (size <= COMPILED_STACK_DEPTH)
xsignal1 (Qinvalid_function, fun);
syms_left = AREF (fun, COMPILED_ARGLIST);
if (INTEGERP (syms_left))
if (FIXNUMP (syms_left))
/* A byte-code object with an integer args template means we
shouldn't bind any arguments, instead just call the byte-code
interpreter directly; it will push arguments as necessary.
@ -3067,7 +3067,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
else if (i < nargs)
arg = arg_vector[i++];
else if (!optional)
xsignal2 (Qwrong_number_of_arguments, fun, make_number (nargs));
xsignal2 (Qwrong_number_of_arguments, fun, make_fixnum (nargs));
else
arg = Qnil;
@ -3084,7 +3084,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
if (!NILP (syms_left))
xsignal1 (Qinvalid_function, fun);
else if (i < nargs)
xsignal2 (Qwrong_number_of_arguments, fun, make_number (nargs));
xsignal2 (Qwrong_number_of_arguments, fun, make_fixnum (nargs));
if (!EQ (lexenv, Vinternal_interpreter_environment))
/* Instantiate a new lexical environment. */
@ -3191,7 +3191,7 @@ lambda_arity (Lisp_Object fun)
if (size <= COMPILED_STACK_DEPTH)
xsignal1 (Qinvalid_function, fun);
syms_left = AREF (fun, COMPILED_ARGLIST);
if (INTEGERP (syms_left))
if (FIXNUMP (syms_left))
return get_byte_code_arity (syms_left);
}
else
@ -3206,7 +3206,7 @@ lambda_arity (Lisp_Object fun)
xsignal1 (Qinvalid_function, fun);
if (EQ (next, Qand_rest))
return Fcons (make_number (minargs), Qmany);
return Fcons (make_fixnum (minargs), Qmany);
else if (EQ (next, Qand_optional))
optional = true;
else
@ -3220,7 +3220,7 @@ lambda_arity (Lisp_Object fun)
if (!NILP (syms_left))
xsignal1 (Qinvalid_function, fun);
return Fcons (make_number (minargs), make_number (maxargs));
return Fcons (make_fixnum (minargs), make_fixnum (maxargs));
}
DEFUN ("fetch-bytecode", Ffetch_bytecode, Sfetch_bytecode,
@ -3647,11 +3647,11 @@ get_backtrace_frame (Lisp_Object nframes, Lisp_Object base)
{
register EMACS_INT i;
CHECK_NATNUM (nframes);
CHECK_FIXNAT (nframes);
union specbinding *pdl = get_backtrace_starting_at (base);
/* Find the frame requested. */
for (i = XFASTINT (nframes); i > 0 && backtrace_p (pdl); i--)
for (i = XFIXNAT (nframes); i > 0 && backtrace_p (pdl); i--)
pdl = backtrace_next (pdl);
return pdl;
@ -3681,7 +3681,7 @@ DEFUN ("backtrace-debug", Fbacktrace_debug, Sbacktrace_debug, 2, 2, 0,
The debugger is entered when that frame exits, if the flag is non-nil. */)
(Lisp_Object level, Lisp_Object flag)
{
CHECK_NUMBER (level);
CHECK_FIXNUM (level);
union specbinding *pdl = get_backtrace_frame(level, Qnil);
if (backtrace_p (pdl))
@ -3852,7 +3852,7 @@ NFRAMES and BASE specify the activation frame to use, as in `backtrace-frame'.
{
union specbinding *frame = get_backtrace_frame (nframes, base);
union specbinding *prevframe
= get_backtrace_frame (make_number (XFASTINT (nframes) - 1), base);
= get_backtrace_frame (make_fixnum (XFIXNAT (nframes) - 1), base);
ptrdiff_t distance = specpdl_ptr - frame;
Lisp_Object result = Qnil;
eassert (distance >= 0);

144
src/fileio.c
View file

@ -691,7 +691,7 @@ This function does not grok magic file names. */)
memset (data + prefix_len, 'X', nX);
memcpy (data + prefix_len + nX, SSDATA (encoded_suffix), suffix_len);
int kind = (NILP (dir_flag) ? GT_FILE
: EQ (dir_flag, make_number (0)) ? GT_NOCREATE
: EQ (dir_flag, make_fixnum (0)) ? GT_NOCREATE
: GT_DIR);
int fd = gen_tempname (data, suffix_len, O_BINARY | O_CLOEXEC, kind);
bool failed = fd < 0;
@ -732,7 +732,7 @@ later creating the file, which opens all kinds of security holes.
For that reason, you should normally use `make-temp-file' instead. */)
(Lisp_Object prefix)
{
return Fmake_temp_file_internal (prefix, make_number (0),
return Fmake_temp_file_internal (prefix, make_fixnum (0),
empty_unibyte_string, Qnil);
}
@ -1945,9 +1945,9 @@ permissions. */)
#ifdef WINDOWSNT
if (NILP (ok_if_already_exists)
|| INTEGERP (ok_if_already_exists))
|| FIXNUMP (ok_if_already_exists))
barf_or_query_if_file_exists (newname, false, "copy to it",
INTEGERP (ok_if_already_exists), false);
FIXNUMP (ok_if_already_exists), false);
result = w32_copy_file (SSDATA (encoded_file), SSDATA (encoded_newname),
!NILP (keep_time), !NILP (preserve_uid_gid),
@ -2002,9 +2002,9 @@ permissions. */)
new_mask);
if (ofd < 0 && errno == EEXIST)
{
if (NILP (ok_if_already_exists) || INTEGERP (ok_if_already_exists))
if (NILP (ok_if_already_exists) || FIXNUMP (ok_if_already_exists))
barf_or_query_if_file_exists (newname, true, "copy to it",
INTEGERP (ok_if_already_exists), false);
FIXNUMP (ok_if_already_exists), false);
already_exists = true;
ofd = emacs_open (SSDATA (encoded_newname), O_WRONLY, 0);
}
@ -2365,7 +2365,7 @@ This is what happens in interactive use with M-x. */)
bool plain_rename = (case_only_rename
|| (!NILP (ok_if_already_exists)
&& !INTEGERP (ok_if_already_exists)));
&& !FIXNUMP (ok_if_already_exists)));
int rename_errno UNINIT;
if (!plain_rename)
{
@ -2383,7 +2383,7 @@ This is what happens in interactive use with M-x. */)
#endif
barf_or_query_if_file_exists (newname, rename_errno == EEXIST,
"rename to it",
INTEGERP (ok_if_already_exists),
FIXNUMP (ok_if_already_exists),
false);
plain_rename = true;
break;
@ -2476,9 +2476,9 @@ This is what happens in interactive use with M-x. */)
if (errno == EEXIST)
{
if (NILP (ok_if_already_exists)
|| INTEGERP (ok_if_already_exists))
|| FIXNUMP (ok_if_already_exists))
barf_or_query_if_file_exists (newname, true, "make it a new name",
INTEGERP (ok_if_already_exists), false);
FIXNUMP (ok_if_already_exists), false);
unlink (SSDATA (newname));
if (link (SSDATA (encoded_file), SSDATA (encoded_newname)) == 0)
return Qnil;
@ -2504,12 +2504,12 @@ This happens for interactive use with M-x. */)
Lisp_Object encoded_target, encoded_linkname;
CHECK_STRING (target);
if (INTEGERP (ok_if_already_exists))
if (FIXNUMP (ok_if_already_exists))
{
if (SREF (target, 0) == '~')
target = Fexpand_file_name (target, Qnil);
else if (SREF (target, 0) == '/' && SREF (target, 1) == ':')
target = Fsubstring_no_properties (target, make_number (2), Qnil);
target = Fsubstring_no_properties (target, make_fixnum (2), Qnil);
}
linkname = expand_cp_target (target, linkname);
@ -2533,9 +2533,9 @@ This happens for interactive use with M-x. */)
if (errno == EEXIST)
{
if (NILP (ok_if_already_exists)
|| INTEGERP (ok_if_already_exists))
|| FIXNUMP (ok_if_already_exists))
barf_or_query_if_file_exists (linkname, true, "make it a link",
INTEGERP (ok_if_already_exists), false);
FIXNUMP (ok_if_already_exists), false);
unlink (SSDATA (encoded_linkname));
if (symlink (SSDATA (encoded_target), SSDATA (encoded_linkname)) == 0)
return Qnil;
@ -3191,7 +3191,7 @@ Return nil, if file does not exist or is not accessible. */)
if (stat (SSDATA (absname), &st) < 0)
return Qnil;
return make_number (st.st_mode & 07777);
return make_fixnum (st.st_mode & 07777);
}
DEFUN ("set-file-modes", Fset_file_modes, Sset_file_modes, 2, 2,
@ -3208,7 +3208,7 @@ symbolic notation, like the `chmod' command from GNU Coreutils. */)
Lisp_Object handler;
absname = Fexpand_file_name (filename, BVAR (current_buffer, directory));
CHECK_NUMBER (mode);
CHECK_FIXNUM (mode);
/* If the file name has special constructs in it,
call the corresponding file handler. */
@ -3218,7 +3218,7 @@ symbolic notation, like the `chmod' command from GNU Coreutils. */)
encoded_absname = ENCODE_FILE (absname);
if (chmod (SSDATA (encoded_absname), XINT (mode) & 07777) < 0)
if (chmod (SSDATA (encoded_absname), XFIXNUM (mode) & 07777) < 0)
report_file_error ("Doing chmod", absname);
return Qnil;
@ -3239,9 +3239,9 @@ by having the corresponding bit in the mask reset. */)
(Lisp_Object mode)
{
mode_t oldrealmask, oldumask, newumask;
CHECK_NUMBER (mode);
CHECK_FIXNUM (mode);
oldrealmask = realmask;
newumask = ~ XINT (mode) & 0777;
newumask = ~ XFIXNUM (mode) & 0777;
block_input ();
realmask = newumask;
@ -3401,12 +3401,12 @@ verify (alignof (union read_non_regular) % GCALIGNMENT == 0);
static Lisp_Object
read_non_regular (Lisp_Object state)
{
union read_non_regular *data = XINTPTR (state);
union read_non_regular *data = XFIXNUMPTR (state);
int nbytes = emacs_read_quit (data->s.fd,
((char *) BEG_ADDR + PT_BYTE - BEG_BYTE
+ data->s.inserted),
data->s.trytry);
return make_number (nbytes);
return make_fixnum (nbytes);
}
@ -3424,8 +3424,8 @@ read_non_regular_quit (Lisp_Object ignore)
static off_t
file_offset (Lisp_Object val)
{
if (RANGED_INTEGERP (0, val, TYPE_MAXIMUM (off_t)))
return XINT (val);
if (RANGED_FIXNUMP (0, val, TYPE_MAXIMUM (off_t)))
return XFIXNUM (val);
if (FLOATP (val))
{
@ -3484,16 +3484,16 @@ restore_window_points (Lisp_Object window_markers, ptrdiff_t inserted,
Lisp_Object car = XCAR (window_markers);
Lisp_Object marker = XCAR (car);
Lisp_Object oldpos = XCDR (car);
if (MARKERP (marker) && INTEGERP (oldpos)
&& XINT (oldpos) > same_at_start
&& XINT (oldpos) < same_at_end)
if (MARKERP (marker) && FIXNUMP (oldpos)
&& XFIXNUM (oldpos) > same_at_start
&& XFIXNUM (oldpos) < same_at_end)
{
ptrdiff_t oldsize = same_at_end - same_at_start;
ptrdiff_t newsize = inserted;
double growth = newsize / (double)oldsize;
ptrdiff_t newpos
= same_at_start + growth * (XINT (oldpos) - same_at_start);
Fset_marker (marker, make_number (newpos), Qnil);
= same_at_start + growth * (XFIXNUM (oldpos) - same_at_start);
Fset_marker (marker, make_fixnum (newpos), Qnil);
}
}
}
@ -3606,8 +3606,8 @@ by calling `format-decode', which see. */)
val = call6 (handler, Qinsert_file_contents, filename,
visit, beg, end, replace);
if (CONSP (val) && CONSP (XCDR (val))
&& RANGED_INTEGERP (0, XCAR (XCDR (val)), ZV - PT))
inserted = XINT (XCAR (XCDR (val)));
&& RANGED_FIXNUMP (0, XCAR (XCDR (val)), ZV - PT))
inserted = XFIXNUM (XCAR (XCDR (val)));
goto handled;
}
@ -3792,7 +3792,7 @@ by calling `format-decode', which see. */)
insert_1_both ((char *) read_buf, nread, nread, 0, 0, 0);
TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
coding_system = call2 (Vset_auto_coding_function,
filename, make_number (nread));
filename, make_fixnum (nread));
set_buffer_internal (prev);
/* Discard the unwind protect for recovering the
@ -4271,7 +4271,7 @@ by calling `format-decode', which see. */)
break;
}
this = XINT (nbytes);
this = XFIXNUM (nbytes);
}
else
{
@ -4367,7 +4367,7 @@ by calling `format-decode', which see. */)
if (inserted > 0 && ! NILP (Vset_auto_coding_function))
{
coding_system = call2 (Vset_auto_coding_function,
filename, make_number (inserted));
filename, make_fixnum (inserted));
}
if (NILP (coding_system))
@ -4486,13 +4486,13 @@ by calling `format-decode', which see. */)
if (! NILP (Ffboundp (Qafter_insert_file_set_coding)))
{
insval = call2 (Qafter_insert_file_set_coding, make_number (inserted),
insval = call2 (Qafter_insert_file_set_coding, make_fixnum (inserted),
visit);
if (! NILP (insval))
{
if (! RANGED_INTEGERP (0, insval, ZV - PT))
if (! RANGED_FIXNUMP (0, insval, ZV - PT))
wrong_type_argument (intern ("inserted-chars"), insval);
inserted = XFASTINT (insval);
inserted = XFIXNAT (insval);
}
}
@ -4512,10 +4512,10 @@ by calling `format-decode', which see. */)
if (NILP (replace))
{
insval = call3 (Qformat_decode,
Qnil, make_number (inserted), visit);
if (! RANGED_INTEGERP (0, insval, ZV - PT))
Qnil, make_fixnum (inserted), visit);
if (! RANGED_FIXNUMP (0, insval, ZV - PT))
wrong_type_argument (intern ("inserted-chars"), insval);
inserted = XFASTINT (insval);
inserted = XFIXNAT (insval);
}
else
{
@ -4535,8 +4535,8 @@ by calling `format-decode', which see. */)
TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
insval = call3 (Qformat_decode,
Qnil, make_number (oinserted), visit);
if (! RANGED_INTEGERP (0, insval, ZV - PT))
Qnil, make_fixnum (oinserted), visit);
if (! RANGED_FIXNUMP (0, insval, ZV - PT))
wrong_type_argument (intern ("inserted-chars"), insval);
if (ochars_modiff == CHARS_MODIFF)
/* format_decode didn't modify buffer's characters => move
@ -4546,7 +4546,7 @@ by calling `format-decode', which see. */)
else
/* format_decode modified buffer's characters => consider
entire buffer changed and leave point at point-min. */
inserted = XFASTINT (insval);
inserted = XFIXNAT (insval);
}
/* For consistency with format-decode call these now iff inserted > 0
@ -4556,12 +4556,12 @@ by calling `format-decode', which see. */)
{
if (NILP (replace))
{
insval = call1 (XCAR (p), make_number (inserted));
insval = call1 (XCAR (p), make_fixnum (inserted));
if (!NILP (insval))
{
if (! RANGED_INTEGERP (0, insval, ZV - PT))
if (! RANGED_FIXNUMP (0, insval, ZV - PT))
wrong_type_argument (intern ("inserted-chars"), insval);
inserted = XFASTINT (insval);
inserted = XFIXNAT (insval);
}
}
else
@ -4574,10 +4574,10 @@ by calling `format-decode', which see. */)
EMACS_INT ochars_modiff = CHARS_MODIFF;
TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
insval = call1 (XCAR (p), make_number (oinserted));
insval = call1 (XCAR (p), make_fixnum (oinserted));
if (!NILP (insval))
{
if (! RANGED_INTEGERP (0, insval, ZV - PT))
if (! RANGED_FIXNUMP (0, insval, ZV - PT))
wrong_type_argument (intern ("inserted-chars"), insval);
if (ochars_modiff == CHARS_MODIFF)
/* after_insert_file_functions didn't modify
@ -4589,7 +4589,7 @@ by calling `format-decode', which see. */)
/* after_insert_file_functions did modify buffer's
characters => consider entire buffer changed and
leave point at point-min. */
inserted = XFASTINT (insval);
inserted = XFIXNAT (insval);
}
}
@ -4605,10 +4605,10 @@ by calling `format-decode', which see. */)
/* Adjust the last undo record for the size change during
the format conversion. */
Lisp_Object tem = XCAR (old_undo);
if (CONSP (tem) && INTEGERP (XCAR (tem))
&& INTEGERP (XCDR (tem))
&& XFASTINT (XCDR (tem)) == PT + old_inserted)
XSETCDR (tem, make_number (PT + inserted));
if (CONSP (tem) && FIXNUMP (XCAR (tem))
&& FIXNUMP (XCDR (tem))
&& XFIXNAT (XCDR (tem)) == PT + old_inserted)
XSETCDR (tem, make_fixnum (PT + inserted));
}
}
else
@ -4643,7 +4643,7 @@ by calling `format-decode', which see. */)
/* Retval needs to be dealt with in all cases consistently. */
if (NILP (val))
val = list2 (orig_filename, make_number (inserted));
val = list2 (orig_filename, make_fixnum (inserted));
return unbind_to (count, val);
}
@ -4946,7 +4946,7 @@ write_region (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
fn = SSDATA (encoded_filename);
open_flags = O_WRONLY | O_CREAT;
open_flags |= EQ (mustbenew, Qexcl) ? O_EXCL : !NILP (append) ? 0 : O_TRUNC;
if (NUMBERP (append))
if (FIXED_OR_FLOATP (append))
offset = file_offset (append);
else if (!NILP (append))
open_flags |= O_APPEND;
@ -4971,7 +4971,7 @@ write_region (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
record_unwind_protect_int (close_file_unwind, desc);
}
if (NUMBERP (append))
if (FIXED_OR_FLOATP (append))
{
off_t ret = lseek (desc, offset, SEEK_SET);
if (ret < 0)
@ -4985,14 +4985,14 @@ write_region (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
if (STRINGP (start))
ok = a_write (desc, start, 0, SCHARS (start), &annotations, &coding);
else if (XINT (start) != XINT (end))
ok = a_write (desc, Qnil, XINT (start), XINT (end) - XINT (start),
else if (XFIXNUM (start) != XFIXNUM (end))
ok = a_write (desc, Qnil, XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
&annotations, &coding);
else
{
/* If file was empty, still need to write the annotations. */
coding.mode |= CODING_MODE_LAST_BLOCK;
ok = a_write (desc, Qnil, XINT (end), 0, &annotations, &coding);
ok = a_write (desc, Qnil, XFIXNUM (end), 0, &annotations, &coding);
}
save_errno = errno;
@ -5154,7 +5154,7 @@ write_region (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
}
if (!auto_saving && !noninteractive)
message_with_string ((NUMBERP (append)
message_with_string ((FIXED_OR_FLOATP (append)
? "Updated %s"
: ! NILP (append)
? "Added to %s"
@ -5239,7 +5239,7 @@ build_annotations (Lisp_Object start, Lisp_Object end)
has written annotations to a temporary buffer, which is now
current. */
res = call5 (Qformat_annotate_function, XCAR (p), start, end,
original_buffer, make_number (i));
original_buffer, make_fixnum (i));
if (current_buffer != given_buffer)
{
XSETFASTINT (start, BEGV);
@ -5278,8 +5278,8 @@ a_write (int desc, Lisp_Object string, ptrdiff_t pos,
{
tem = Fcar_safe (Fcar (*annot));
nextpos = pos - 1;
if (INTEGERP (tem))
nextpos = XFASTINT (tem);
if (FIXNUMP (tem))
nextpos = XFIXNAT (tem);
/* If there are no more annotations in this range,
output the rest of the range all at once. */
@ -5460,7 +5460,7 @@ See Info node `(elisp)Modification Time' for more details. */)
{
int ns = current_buffer->modtime.tv_nsec;
if (ns < 0)
return make_number (UNKNOWN_MODTIME_NSECS - ns);
return make_fixnum (UNKNOWN_MODTIME_NSECS - ns);
return make_lisp_time (current_buffer->modtime);
}
@ -5478,10 +5478,10 @@ An argument specifies the modification time value to use
if (!NILP (time_flag))
{
struct timespec mtime;
if (INTEGERP (time_flag))
if (FIXNUMP (time_flag))
{
CHECK_RANGED_INTEGER (time_flag, -1, 0);
mtime = make_timespec (0, UNKNOWN_MODTIME_NSECS - XINT (time_flag));
mtime = make_timespec (0, UNKNOWN_MODTIME_NSECS - XFIXNUM (time_flag));
}
else
mtime = lisp_time_argument (time_flag);
@ -5547,9 +5547,9 @@ auto_save_1 (void)
/* But make sure we can overwrite it later! */
auto_save_mode_bits = (st.st_mode | 0600) & 0777;
else if (modes = Ffile_modes (BVAR (current_buffer, filename)),
INTEGERP (modes))
FIXNUMP (modes))
/* Remote files don't cooperate with stat. */
auto_save_mode_bits = (XINT (modes) | 0600) & 0777;
auto_save_mode_bits = (XFIXNUM (modes) | 0600) & 0777;
}
return
@ -5716,7 +5716,7 @@ A non-nil CURRENT-ONLY argument means save only current buffer. */)
&& BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)
&& BUF_AUTOSAVE_MODIFF (b) < BUF_MODIFF (b)
/* -1 means we've turned off autosaving for a while--see below. */
&& XINT (BVAR (b, save_length)) >= 0
&& XFIXNUM (BVAR (b, save_length)) >= 0
&& (do_handled_files
|| NILP (Ffind_file_name_handler (BVAR (b, auto_save_file_name),
Qwrite_region))))
@ -5731,11 +5731,11 @@ A non-nil CURRENT-ONLY argument means save only current buffer. */)
set_buffer_internal (b);
if (NILP (Vauto_save_include_big_deletions)
&& (XFASTINT (BVAR (b, save_length)) * 10
&& (XFIXNAT (BVAR (b, save_length)) * 10
> (BUF_Z (b) - BUF_BEG (b)) * 13)
/* A short file is likely to change a large fraction;
spare the user annoying messages. */
&& XFASTINT (BVAR (b, save_length)) > 5000
&& XFIXNAT (BVAR (b, save_length)) > 5000
/* These messages are frequent and annoying for `*mail*'. */
&& !NILP (BVAR (b, filename))
&& NILP (no_message))
@ -5748,7 +5748,7 @@ A non-nil CURRENT-ONLY argument means save only current buffer. */)
/* Turn off auto-saving until there's a real save,
and prevent any more warnings. */
XSETINT (BVAR (b, save_length), -1);
Fsleep_for (make_number (1), Qnil);
Fsleep_for (make_fixnum (1), Qnil);
continue;
}
if (!auto_saved && NILP (no_message))
@ -5777,7 +5777,7 @@ A non-nil CURRENT-ONLY argument means save only current buffer. */)
{
/* If we are going to restore an old message,
give time to read ours. */
sit_for (make_number (1), 0, 0);
sit_for (make_fixnum (1), 0, 0);
restore_message ();
}
else if (!auto_save_error_occurred)

81
src/floatfns.c
View file

@ -60,7 +60,7 @@ CHECK_FLOAT (Lisp_Object x)
double
extract_float (Lisp_Object num)
{
CHECK_NUMBER_OR_FLOAT (num);
CHECK_NUMBER (num);
return XFLOATINT (num);
}
@ -178,7 +178,7 @@ If X is zero, both parts (SGNFCAND and EXP) are zero. */)
double f = extract_float (x);
int exponent;
double sgnfcand = frexp (f, &exponent);
return Fcons (make_float (sgnfcand), make_number (exponent));
return Fcons (make_float (sgnfcand), make_fixnum (exponent));
}
DEFUN ("ldexp", Fldexp, Sldexp, 2, 2, 0,
@ -186,8 +186,8 @@ DEFUN ("ldexp", Fldexp, Sldexp, 2, 2, 0,
EXPONENT must be an integer. */)
(Lisp_Object sgnfcand, Lisp_Object exponent)
{
CHECK_NUMBER (exponent);
int e = min (max (INT_MIN, XINT (exponent)), INT_MAX);
CHECK_FIXNUM (exponent);
int e = min (max (INT_MIN, XFIXNUM (exponent)), INT_MAX);
return make_float (ldexp (extract_float (sgnfcand), e));
}
@ -204,18 +204,18 @@ DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
doc: /* Return the exponential ARG1 ** ARG2. */)
(Lisp_Object arg1, Lisp_Object arg2)
{
CHECK_NUMBER_OR_FLOAT (arg1);
CHECK_NUMBER_OR_FLOAT (arg2);
if (INTEGERP (arg1) /* common lisp spec */
&& INTEGERP (arg2) /* don't promote, if both are ints, and */
&& XINT (arg2) >= 0) /* we are sure the result is not fractional */
CHECK_FIXNUM_OR_FLOAT (arg1);
CHECK_FIXNUM_OR_FLOAT (arg2);
if (FIXNUMP (arg1) /* common lisp spec */
&& FIXNUMP (arg2) /* don't promote, if both are ints, and */
&& XFIXNUM (arg2) >= 0) /* we are sure the result is not fractional */
{ /* this can be improved by pre-calculating */
EMACS_INT y; /* some binary powers of x then accumulating */
EMACS_UINT acc, x; /* Unsigned so that overflow is well defined. */
Lisp_Object val;
x = XINT (arg1);
y = XINT (arg2);
x = XFIXNUM (arg1);
y = XFIXNUM (arg2);
acc = (y & 1 ? x : 1);
while ((y >>= 1) != 0)
@ -268,12 +268,28 @@ DEFUN ("abs", Fabs, Sabs, 1, 1, 0,
doc: /* Return the absolute value of ARG. */)
(register Lisp_Object arg)
{
CHECK_NUMBER_OR_FLOAT (arg);
CHECK_NUMBER (arg);
if (FLOATP (arg))
if (BIGNUMP (arg))
{
mpz_t val;
mpz_init (val);
mpz_abs (val, XBIGNUM (arg)->value);
arg = make_number (val);
mpz_clear (val);
}
else if (FIXNUMP (arg) && XFIXNUM (arg) == MOST_NEGATIVE_FIXNUM)
{
mpz_t val;
mpz_init (val);
mpz_set_intmax (val, - MOST_NEGATIVE_FIXNUM);
arg = make_number (val);
mpz_clear (val);
}
else if (FLOATP (arg))
arg = make_float (fabs (XFLOAT_DATA (arg)));
else if (XINT (arg) < 0)
XSETINT (arg, - XINT (arg));
else if (XFIXNUM (arg) < 0)
XSETINT (arg, - XFIXNUM (arg));
return arg;
}
@ -282,10 +298,12 @@ DEFUN ("float", Ffloat, Sfloat, 1, 1, 0,
doc: /* Return the floating point number equal to ARG. */)
(register Lisp_Object arg)
{
CHECK_NUMBER_OR_FLOAT (arg);
CHECK_NUMBER (arg);
if (INTEGERP (arg))
return make_float ((double) XINT (arg));
if (BIGNUMP (arg))
return make_float (mpz_get_d (XBIGNUM (arg)->value));
if (FIXNUMP (arg))
return make_float ((double) XFIXNUM (arg));
else /* give 'em the same float back */
return arg;
}
@ -304,7 +322,7 @@ This is the same as the exponent of a float. */)
(Lisp_Object arg)
{
EMACS_INT value;
CHECK_NUMBER_OR_FLOAT (arg);
CHECK_NUMBER (arg);
if (FLOATP (arg))
{
@ -321,15 +339,18 @@ This is the same as the exponent of a float. */)
else
value = MOST_POSITIVE_FIXNUM;
}
else if (BIGNUMP (arg))
value = mpz_sizeinbase (XBIGNUM (arg)->value, 2) - 1;
else
{
EMACS_INT i = eabs (XINT (arg));
eassert (FIXNUMP (arg));
EMACS_INT i = eabs (XFIXNUM (arg));
value = (i == 0
? MOST_NEGATIVE_FIXNUM
: EMACS_UINT_WIDTH - 1 - ecount_leading_zeros (i));
}
return make_number (value);
return make_fixnum (value);
}
@ -341,7 +362,7 @@ rounding_driver (Lisp_Object arg, Lisp_Object divisor,
EMACS_INT (*int_round2) (EMACS_INT, EMACS_INT),
const char *name)
{
CHECK_NUMBER_OR_FLOAT (arg);
CHECK_FIXNUM_OR_FLOAT (arg);
double d;
if (NILP (divisor))
@ -352,16 +373,16 @@ rounding_driver (Lisp_Object arg, Lisp_Object divisor,
}
else
{
CHECK_NUMBER_OR_FLOAT (divisor);
CHECK_FIXNUM_OR_FLOAT (divisor);
if (!FLOATP (arg) && !FLOATP (divisor))
{
if (XINT (divisor) == 0)
if (XFIXNUM (divisor) == 0)
xsignal0 (Qarith_error);
return make_number (int_round2 (XINT (arg), XINT (divisor)));
return make_fixnum (int_round2 (XFIXNUM (arg), XFIXNUM (divisor)));
}
double f1 = FLOATP (arg) ? XFLOAT_DATA (arg) : XINT (arg);
double f2 = FLOATP (divisor) ? XFLOAT_DATA (divisor) : XINT (divisor);
double f1 = FLOATP (arg) ? XFLOAT_DATA (arg) : XFIXNUM (arg);
double f2 = FLOATP (divisor) ? XFLOAT_DATA (divisor) : XFIXNUM (divisor);
if (! IEEE_FLOATING_POINT && f2 == 0)
xsignal0 (Qarith_error);
d = f1 / f2;
@ -376,7 +397,7 @@ rounding_driver (Lisp_Object arg, Lisp_Object divisor,
{
EMACS_INT ir = dr;
if (! FIXNUM_OVERFLOW_P (ir))
return make_number (ir);
return make_fixnum (ir);
}
xsignal2 (Qrange_error, build_string (name), arg);
}
@ -482,8 +503,8 @@ fmod_float (Lisp_Object x, Lisp_Object y)
{
double f1, f2;
f1 = FLOATP (x) ? XFLOAT_DATA (x) : XINT (x);
f2 = FLOATP (y) ? XFLOAT_DATA (y) : XINT (y);
f1 = FLOATP (x) ? XFLOAT_DATA (x) : XFIXNUM (x);
f2 = FLOATP (y) ? XFLOAT_DATA (y) : XFIXNUM (y);
f1 = fmod (f1, f2);

254
src/fns.c
View file

@ -77,18 +77,18 @@ See Info node `(elisp)Random Numbers' for more details. */)
seed_random (SSDATA (limit), SBYTES (limit));
val = get_random ();
if (INTEGERP (limit) && 0 < XINT (limit))
if (FIXNUMP (limit) && 0 < XFIXNUM (limit))
while (true)
{
/* Return the remainder, except reject the rare case where
get_random returns a number so close to INTMASK that the
remainder isn't random. */
EMACS_INT remainder = val % XINT (limit);
if (val - remainder <= INTMASK - XINT (limit) + 1)
return make_number (remainder);
EMACS_INT remainder = val % XFIXNUM (limit);
if (val - remainder <= INTMASK - XFIXNUM (limit) + 1)
return make_fixnum (remainder);
val = get_random ();
}
return make_number (val);
return make_fixnum (val);
}
/* Random data-structure functions. */
@ -121,7 +121,7 @@ To get the number of bytes, use `string-bytes'. */)
CHECK_LIST_END (sequence, sequence);
if (MOST_POSITIVE_FIXNUM < i)
error ("List too long");
val = make_number (i);
val = make_fixnum (i);
}
else if (NILP (sequence))
XSETFASTINT (val, 0);
@ -163,7 +163,7 @@ A proper list is neither circular nor dotted (i.e., its last cdr is nil). */
return Qnil;
if (MOST_POSITIVE_FIXNUM < len)
xsignal0 (Qoverflow_error);
return make_number (len);
return make_fixnum (len);
}
DEFUN ("string-bytes", Fstring_bytes, Sstring_bytes, 1, 1, 0,
@ -172,7 +172,7 @@ If STRING is multibyte, this may be greater than the length of STRING. */)
(Lisp_Object string)
{
CHECK_STRING (string);
return make_number (SBYTES (string));
return make_fixnum (SBYTES (string));
}
DEFUN ("string-distance", Fstring_distance, Sstring_distance, 2, 3, 0,
@ -238,7 +238,7 @@ Letter-case is significant, but text properties are ignored. */)
}
SAFE_FREE ();
return make_number (column[len1]);
return make_fixnum (column[len1]);
}
DEFUN ("string-equal", Fstring_equal, Sstring_equal, 2, 2, 0,
@ -292,10 +292,10 @@ If string STR1 is greater, the value is a positive number N;
/* For backward compatibility, silently bring too-large positive end
values into range. */
if (INTEGERP (end1) && SCHARS (str1) < XINT (end1))
end1 = make_number (SCHARS (str1));
if (INTEGERP (end2) && SCHARS (str2) < XINT (end2))
end2 = make_number (SCHARS (str2));
if (FIXNUMP (end1) && SCHARS (str1) < XFIXNUM (end1))
end1 = make_fixnum (SCHARS (str1));
if (FIXNUMP (end2) && SCHARS (str2) < XFIXNUM (end2))
end2 = make_fixnum (SCHARS (str2));
validate_subarray (str1, start1, end1, SCHARS (str1), &from1, &to1);
validate_subarray (str2, start2, end2, SCHARS (str2), &from2, &to2);
@ -320,8 +320,8 @@ If string STR1 is greater, the value is a positive number N;
if (! NILP (ignore_case))
{
c1 = XINT (Fupcase (make_number (c1)));
c2 = XINT (Fupcase (make_number (c2)));
c1 = XFIXNUM (Fupcase (make_fixnum (c1)));
c2 = XFIXNUM (Fupcase (make_fixnum (c2)));
}
if (c1 == c2)
@ -331,15 +331,15 @@ If string STR1 is greater, the value is a positive number N;
past the character that we are comparing;
hence we don't add or subtract 1 here. */
if (c1 < c2)
return make_number (- i1 + from1);
return make_fixnum (- i1 + from1);
else
return make_number (i1 - from1);
return make_fixnum (i1 - from1);
}
if (i1 < to1)
return make_number (i1 - from1 + 1);
return make_fixnum (i1 - from1 + 1);
if (i2 < to2)
return make_number (- i1 + from1 - 1);
return make_fixnum (- i1 + from1 - 1);
return Qt;
}
@ -667,7 +667,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
{
EMACS_INT len;
this = args[argnum];
len = XFASTINT (Flength (this));
len = XFIXNAT (Flength (this));
if (target_type == Lisp_String)
{
/* We must count the number of bytes needed in the string
@ -682,7 +682,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
{
ch = AREF (this, i);
CHECK_CHARACTER (ch);
c = XFASTINT (ch);
c = XFIXNAT (ch);
this_len_byte = CHAR_BYTES (c);
if (STRING_BYTES_BOUND - result_len_byte < this_len_byte)
string_overflow ();
@ -691,13 +691,13 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
some_multibyte = 1;
}
else if (BOOL_VECTOR_P (this) && bool_vector_size (this) > 0)
wrong_type_argument (Qintegerp, Faref (this, make_number (0)));
wrong_type_argument (Qintegerp, Faref (this, make_fixnum (0)));
else if (CONSP (this))
for (; CONSP (this); this = XCDR (this))
{
ch = XCAR (this);
CHECK_CHARACTER (ch);
c = XFASTINT (ch);
c = XFIXNAT (ch);
this_len_byte = CHAR_BYTES (c);
if (STRING_BYTES_BOUND - result_len_byte < this_len_byte)
string_overflow ();
@ -731,9 +731,9 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
/* Create the output object. */
if (target_type == Lisp_Cons)
val = Fmake_list (make_number (result_len), Qnil);
val = Fmake_list (make_fixnum (result_len), Qnil);
else if (target_type == Lisp_Vectorlike)
val = Fmake_vector (make_number (result_len), Qnil);
val = Fmake_vector (make_fixnum (result_len), Qnil);
else if (some_multibyte)
val = make_uninit_multibyte_string (result_len, result_len_byte);
else
@ -762,7 +762,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
this = args[argnum];
if (!CONSP (this))
thislen = Flength (this), thisleni = XINT (thislen);
thislen = Flength (this), thisleni = XFIXNUM (thislen);
/* Between strings of the same kind, copy fast. */
if (STRINGP (this) && STRINGP (val)
@ -849,7 +849,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
{
int c;
CHECK_CHARACTER (elt);
c = XFASTINT (elt);
c = XFIXNAT (elt);
if (some_multibyte)
toindex_byte += CHAR_STRING (c, SDATA (val) + toindex_byte);
else
@ -870,15 +870,15 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
{
this = args[textprops[argnum].argnum];
props = text_property_list (this,
make_number (0),
make_number (SCHARS (this)),
make_fixnum (0),
make_fixnum (SCHARS (this)),
Qnil);
/* If successive arguments have properties, be sure that the
value of `composition' property be the copy. */
if (last_to_end == textprops[argnum].to)
make_composition_value_copy (props);
add_text_properties_from_list (val, props,
make_number (textprops[argnum].to));
make_fixnum (textprops[argnum].to));
last_to_end = textprops[argnum].to + SCHARS (this);
}
}
@ -1280,9 +1280,9 @@ validate_subarray (Lisp_Object array, Lisp_Object from, Lisp_Object to,
{
EMACS_INT f, t;
if (INTEGERP (from))
if (FIXNUMP (from))
{
f = XINT (from);
f = XFIXNUM (from);
if (f < 0)
f += size;
}
@ -1291,9 +1291,9 @@ validate_subarray (Lisp_Object array, Lisp_Object from, Lisp_Object to,
else
wrong_type_argument (Qintegerp, from);
if (INTEGERP (to))
if (FIXNUMP (to))
{
t = XINT (to);
t = XFIXNUM (to);
if (t < 0)
t += size;
}
@ -1339,8 +1339,8 @@ With one argument, just copy STRING (with properties, if any). */)
res = make_specified_string (SSDATA (string) + from_byte,
ito - ifrom, to_byte - from_byte,
STRING_MULTIBYTE (string));
copy_text_properties (make_number (ifrom), make_number (ito),
string, make_number (0), res, Qnil);
copy_text_properties (make_fixnum (ifrom), make_fixnum (ito),
string, make_fixnum (0), res, Qnil);
}
else
res = Fvector (ito - ifrom, aref_addr (string, ifrom));
@ -1385,15 +1385,15 @@ substring_both (Lisp_Object string, ptrdiff_t from, ptrdiff_t from_byte,
ptrdiff_t size = CHECK_VECTOR_OR_STRING (string);
if (!(0 <= from && from <= to && to <= size))
args_out_of_range_3 (string, make_number (from), make_number (to));
args_out_of_range_3 (string, make_fixnum (from), make_fixnum (to));
if (STRINGP (string))
{
res = make_specified_string (SSDATA (string) + from_byte,
to - from, to_byte - from_byte,
STRING_MULTIBYTE (string));
copy_text_properties (make_number (from), make_number (to),
string, make_number (0), res, Qnil);
copy_text_properties (make_fixnum (from), make_fixnum (to),
string, make_fixnum (0), res, Qnil);
}
else
res = Fvector (to - from, aref_addr (string, from));
@ -1405,9 +1405,9 @@ DEFUN ("nthcdr", Fnthcdr, Snthcdr, 2, 2, 0,
doc: /* Take cdr N times on LIST, return the result. */)
(Lisp_Object n, Lisp_Object list)
{
CHECK_NUMBER (n);
CHECK_FIXNUM (n);
Lisp_Object tail = list;
for (EMACS_INT num = XINT (n); 0 < num; num--)
for (EMACS_INT num = XFIXNUM (n); 0 < num; num--)
{
if (! CONSP (tail))
{
@ -1432,7 +1432,7 @@ DEFUN ("elt", Felt, Selt, 2, 2, 0,
doc: /* Return element of SEQUENCE at index N. */)
(register Lisp_Object sequence, Lisp_Object n)
{
CHECK_NUMBER (n);
CHECK_FIXNUM (n);
if (CONSP (sequence) || NILP (sequence))
return Fcar (Fnthcdr (n, sequence));
@ -1690,7 +1690,7 @@ changing the value of a sequence `foo'. */)
cbytes = 1;
}
if (!INTEGERP (elt) || c != XINT (elt))
if (!FIXNUMP (elt) || c != XFIXNUM (elt))
{
++nchars;
nbytes += cbytes;
@ -1720,7 +1720,7 @@ changing the value of a sequence `foo'. */)
cbytes = 1;
}
if (!INTEGERP (elt) || c != XINT (elt))
if (!FIXNUMP (elt) || c != XFIXNUM (elt))
{
unsigned char *from = SDATA (seq) + ibyte;
unsigned char *to = SDATA (tem) + nbytes;
@ -1891,7 +1891,7 @@ sort_list (Lisp_Object list, Lisp_Object predicate)
front = list;
len = Flength (list);
length = XINT (len);
length = XFIXNUM (len);
if (length < 2)
return list;
@ -2000,7 +2000,7 @@ sort_vector (Lisp_Object vector, Lisp_Object predicate)
USE_SAFE_ALLOCA;
SAFE_ALLOCA_LISP (tmp, halflen);
for (ptrdiff_t i = 0; i < halflen; i++)
tmp[i] = make_number (0);
tmp[i] = make_fixnum (0);
sort_vector_inplace (predicate, len, XVECTOR (vector)->contents, tmp);
SAFE_FREE ();
}
@ -2223,6 +2223,8 @@ This differs from numeric comparison: (eql 0.0 -0.0) returns nil and
{
if (FLOATP (obj1))
return FLOATP (obj2) && same_float (obj1, obj2) ? Qt : Qnil;
else if (BIGNUMP (obj1))
return equal_no_quit (obj1, obj2) ? Qt : Qnil;
else
return EQ (obj1, obj2) ? Qt : Qnil;
}
@ -2363,6 +2365,8 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, enum equal_kind equal_kind,
&& (XMARKER (o1)->buffer == 0
|| XMARKER (o1)->bytepos == XMARKER (o2)->bytepos));
}
if (BIGNUMP (o1))
return mpz_cmp (XBIGNUM (o1)->value, XBIGNUM (o2)->value) == 0;
break;
case Lisp_Vectorlike:
@ -2456,7 +2460,7 @@ ARRAY is a vector, string, char-table, or bool-vector. */)
register unsigned char *p = SDATA (array);
int charval;
CHECK_CHARACTER (item);
charval = XFASTINT (item);
charval = XFIXNAT (item);
size = SCHARS (array);
if (STRING_MULTIBYTE (array))
{
@ -2608,7 +2612,7 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string. */)
(Lisp_Object function, Lisp_Object sequence, Lisp_Object separator)
{
USE_SAFE_ALLOCA;
EMACS_INT leni = XFASTINT (Flength (sequence));
EMACS_INT leni = XFIXNAT (Flength (sequence));
if (CHAR_TABLE_P (sequence))
wrong_type_argument (Qlistp, sequence);
EMACS_INT args_alloc = 2 * leni - 1;
@ -2637,7 +2641,7 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string. */)
(Lisp_Object function, Lisp_Object sequence)
{
USE_SAFE_ALLOCA;
EMACS_INT leni = XFASTINT (Flength (sequence));
EMACS_INT leni = XFIXNAT (Flength (sequence));
if (CHAR_TABLE_P (sequence))
wrong_type_argument (Qlistp, sequence);
Lisp_Object *args;
@ -2656,7 +2660,7 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string. */)
{
register EMACS_INT leni;
leni = XFASTINT (Flength (sequence));
leni = XFIXNAT (Flength (sequence));
if (CHAR_TABLE_P (sequence))
wrong_type_argument (Qlistp, sequence);
mapcar1 (leni, 0, function, sequence);
@ -2671,7 +2675,7 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string. */)
(Lisp_Object function, Lisp_Object sequence)
{
USE_SAFE_ALLOCA;
EMACS_INT leni = XFASTINT (Flength (sequence));
EMACS_INT leni = XFIXNAT (Flength (sequence));
if (CHAR_TABLE_P (sequence))
wrong_type_argument (Qlistp, sequence);
Lisp_Object *args;
@ -2736,7 +2740,7 @@ if `last-nonmenu-event' is nil, and `use-dialog-box' is non-nil. */)
Fding (Qnil);
Fdiscard_input ();
message1 ("Please answer yes or no.");
Fsleep_for (make_number (2), Qnil);
Fsleep_for (make_fixnum (2), Qnil);
}
}
@ -2768,7 +2772,7 @@ advisable. */)
while (loads-- > 0)
{
Lisp_Object load = (NILP (use_floats)
? make_number (100.0 * load_ave[loads])
? make_fixnum (100.0 * load_ave[loads])
: make_float (load_ave[loads]));
ret = Fcons (load, ret);
}
@ -2804,7 +2808,7 @@ particular subfeatures supported in this version of FEATURE. */)
CHECK_SYMBOL (feature);
CHECK_LIST (subfeatures);
if (!NILP (Vautoload_queue))
Vautoload_queue = Fcons (Fcons (make_number (0), Vfeatures),
Vautoload_queue = Fcons (Fcons (make_fixnum (0), Vfeatures),
Vautoload_queue);
tem = Fmemq (feature, Vfeatures);
if (NILP (tem))
@ -3056,7 +3060,7 @@ The data read from the system are decoded using `locale-coding-system'. */)
#ifdef DAY_1
else if (EQ (item, Qdays)) /* e.g. for calendar-day-name-array */
{
Lisp_Object v = Fmake_vector (make_number (7), Qnil);
Lisp_Object v = Fmake_vector (make_fixnum (7), Qnil);
const int days[7] = {DAY_1, DAY_2, DAY_3, DAY_4, DAY_5, DAY_6, DAY_7};
int i;
synchronize_system_time_locale ();
@ -3075,7 +3079,7 @@ The data read from the system are decoded using `locale-coding-system'. */)
#ifdef MON_1
else if (EQ (item, Qmonths)) /* e.g. for calendar-month-name-array */
{
Lisp_Object v = Fmake_vector (make_number (12), Qnil);
Lisp_Object v = Fmake_vector (make_fixnum (12), Qnil);
const int months[12] = {MON_1, MON_2, MON_3, MON_4, MON_5, MON_6, MON_7,
MON_8, MON_9, MON_10, MON_11, MON_12};
int i;
@ -3198,9 +3202,9 @@ into shorter lines. */)
validate_region (&beg, &end);
ibeg = CHAR_TO_BYTE (XFASTINT (beg));
iend = CHAR_TO_BYTE (XFASTINT (end));
move_gap_both (XFASTINT (beg), ibeg);
ibeg = CHAR_TO_BYTE (XFIXNAT (beg));
iend = CHAR_TO_BYTE (XFIXNAT (end));
move_gap_both (XFIXNAT (beg), ibeg);
/* We need to allocate enough room for encoding the text.
We need 33 1/3% more space, plus a newline every 76
@ -3225,21 +3229,21 @@ into shorter lines. */)
/* Now we have encoded the region, so we insert the new contents
and delete the old. (Insert first in order to preserve markers.) */
SET_PT_BOTH (XFASTINT (beg), ibeg);
SET_PT_BOTH (XFIXNAT (beg), ibeg);
insert (encoded, encoded_length);
SAFE_FREE ();
del_range_byte (ibeg + encoded_length, iend + encoded_length);
/* If point was outside of the region, restore it exactly; else just
move to the beginning of the region. */
if (old_pos >= XFASTINT (end))
old_pos += encoded_length - (XFASTINT (end) - XFASTINT (beg));
else if (old_pos > XFASTINT (beg))
old_pos = XFASTINT (beg);
if (old_pos >= XFIXNAT (end))
old_pos += encoded_length - (XFIXNAT (end) - XFIXNAT (beg));
else if (old_pos > XFIXNAT (beg))
old_pos = XFIXNAT (beg);
SET_PT (old_pos);
/* We return the length of the encoded text. */
return make_number (encoded_length);
return make_fixnum (encoded_length);
}
DEFUN ("base64-encode-string", Fbase64_encode_string, Sbase64_encode_string,
@ -3398,8 +3402,8 @@ If the region can't be decoded, signal an error and don't modify the buffer. */
validate_region (&beg, &end);
ibeg = CHAR_TO_BYTE (XFASTINT (beg));
iend = CHAR_TO_BYTE (XFASTINT (end));
ibeg = CHAR_TO_BYTE (XFIXNAT (beg));
iend = CHAR_TO_BYTE (XFIXNAT (end));
length = iend - ibeg;
@ -3409,7 +3413,7 @@ If the region can't be decoded, signal an error and don't modify the buffer. */
allength = multibyte ? length * 2 : length;
decoded = SAFE_ALLOCA (allength);
move_gap_both (XFASTINT (beg), ibeg);
move_gap_both (XFIXNAT (beg), ibeg);
decoded_length = base64_decode_1 ((char *) BYTE_POS_ADDR (ibeg),
decoded, length,
multibyte, &inserted_chars);
@ -3424,24 +3428,24 @@ If the region can't be decoded, signal an error and don't modify the buffer. */
/* Now we have decoded the region, so we insert the new contents
and delete the old. (Insert first in order to preserve markers.) */
TEMP_SET_PT_BOTH (XFASTINT (beg), ibeg);
TEMP_SET_PT_BOTH (XFIXNAT (beg), ibeg);
insert_1_both (decoded, inserted_chars, decoded_length, 0, 1, 0);
signal_after_change (XFASTINT (beg), 0, inserted_chars);
signal_after_change (XFIXNAT (beg), 0, inserted_chars);
SAFE_FREE ();
/* Delete the original text. */
del_range_both (PT, PT_BYTE, XFASTINT (end) + inserted_chars,
del_range_both (PT, PT_BYTE, XFIXNAT (end) + inserted_chars,
iend + decoded_length, 1);
/* If point was outside of the region, restore it exactly; else just
move to the beginning of the region. */
if (old_pos >= XFASTINT (end))
old_pos += inserted_chars - (XFASTINT (end) - XFASTINT (beg));
else if (old_pos > XFASTINT (beg))
old_pos = XFASTINT (beg);
if (old_pos >= XFIXNAT (end))
old_pos += inserted_chars - (XFIXNAT (end) - XFIXNAT (beg));
else if (old_pos > XFIXNAT (beg))
old_pos = XFIXNAT (beg);
SET_PT (old_pos > ZV ? ZV : old_pos);
return make_number (inserted_chars);
return make_fixnum (inserted_chars);
}
DEFUN ("base64-decode-string", Fbase64_decode_string, Sbase64_decode_string,
@ -3612,7 +3616,7 @@ set_hash_next (struct Lisp_Hash_Table *h, Lisp_Object next)
static void
set_hash_next_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, ptrdiff_t val)
{
gc_aset (h->next, idx, make_number (val));
gc_aset (h->next, idx, make_fixnum (val));
}
static void
set_hash_hash (struct Lisp_Hash_Table *h, Lisp_Object hash)
@ -3632,7 +3636,7 @@ set_hash_index (struct Lisp_Hash_Table *h, Lisp_Object index)
static void
set_hash_index_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, ptrdiff_t val)
{
gc_aset (h->index, idx, make_number (val));
gc_aset (h->index, idx, make_fixnum (val));
}
/* If OBJ is a Lisp hash table, return a pointer to its struct
@ -3735,7 +3739,7 @@ larger_vector (Lisp_Object vec, ptrdiff_t incr_min, ptrdiff_t nitems_max)
static ptrdiff_t
HASH_NEXT (struct Lisp_Hash_Table *h, ptrdiff_t idx)
{
return XINT (AREF (h->next, idx));
return XFIXNUM (AREF (h->next, idx));
}
/* Return the index of the element in hash table H that is the start
@ -3744,7 +3748,7 @@ HASH_NEXT (struct Lisp_Hash_Table *h, ptrdiff_t idx)
static ptrdiff_t
HASH_INDEX (struct Lisp_Hash_Table *h, ptrdiff_t idx)
{
return XINT (AREF (h->index, idx));
return XFIXNUM (AREF (h->index, idx));
}
/* Compare KEY1 and KEY2 in hash table HT using `eql'. Value is true
@ -3755,7 +3759,13 @@ cmpfn_eql (struct hash_table_test *ht,
Lisp_Object key1,
Lisp_Object key2)
{
return FLOATP (key1) && FLOATP (key2) && same_float (key1, key2);
if (FLOATP (key1)
&& FLOATP (key2)
&& same_float (key1, key2))
return true;
return (BIGNUMP (key1)
&& BIGNUMP (key2)
&& mpz_cmp (XBIGNUM (key1)->value, XBIGNUM (key2)->value) == 0);
}
@ -3809,7 +3819,9 @@ hashfn_equal (struct hash_table_test *ht, Lisp_Object key)
static EMACS_UINT
hashfn_eql (struct hash_table_test *ht, Lisp_Object key)
{
return FLOATP (key) ? hashfn_equal (ht, key) : hashfn_eq (ht, key);
return ((FLOATP (key) || BIGNUMP (key))
? hashfn_equal (ht, key)
: hashfn_eq (ht, key));
}
/* Value is a hash code for KEY for use in hash table H which uses as
@ -3908,10 +3920,10 @@ make_hash_table (struct hash_table_test test, EMACS_INT size,
h->rehash_threshold = rehash_threshold;
h->rehash_size = rehash_size;
h->count = 0;
h->key_and_value = Fmake_vector (make_number (2 * size), Qnil);
h->hash = Fmake_vector (make_number (size), Qnil);
h->next = Fmake_vector (make_number (size), make_number (-1));
h->index = Fmake_vector (make_number (index_size), make_number (-1));
h->key_and_value = Fmake_vector (make_fixnum (2 * size), Qnil);
h->hash = Fmake_vector (make_fixnum (size), Qnil);
h->next = Fmake_vector (make_fixnum (size), make_fixnum (-1));
h->index = Fmake_vector (make_fixnum (index_size), make_fixnum (-1));
h->pure = pure;
/* Set up the free list. */
@ -4006,8 +4018,8 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
set_hash_key_and_value (h, larger_vector (h->key_and_value,
2 * (new_size - old_size), -1));
set_hash_hash (h, larger_vector (h->hash, new_size - old_size, -1));
set_hash_index (h, Fmake_vector (make_number (index_size),
make_number (-1)));
set_hash_index (h, Fmake_vector (make_fixnum (index_size),
make_fixnum (-1)));
set_hash_next (h, larger_vecalloc (h->next, new_size - old_size, -1));
/* Update the free list. Do it so that new entries are added at
@ -4036,7 +4048,7 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
for (i = 0; i < old_size; ++i)
if (!NILP (HASH_HASH (h, i)))
{
EMACS_UINT hash_code = XUINT (HASH_HASH (h, i));
EMACS_UINT hash_code = XUFIXNUM (HASH_HASH (h, i));
ptrdiff_t start_of_bucket = hash_code % ASIZE (h->index);
set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket));
set_hash_index_slot (h, start_of_bucket, i);
@ -4065,7 +4077,7 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, EMACS_UINT *hash)
for (i = HASH_INDEX (h, start_of_bucket); 0 <= i; i = HASH_NEXT (h, i))
if (EQ (key, HASH_KEY (h, i))
|| (h->test.cmpfn
&& hash_code == XUINT (HASH_HASH (h, i))
&& hash_code == XUFIXNUM (HASH_HASH (h, i))
&& h->test.cmpfn (&h->test, key, HASH_KEY (h, i))))
break;
@ -4096,7 +4108,7 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value,
set_hash_value_slot (h, i, value);
/* Remember its hash code. */
set_hash_hash_slot (h, i, make_number (hash));
set_hash_hash_slot (h, i, make_fixnum (hash));
/* Add new entry to its collision chain. */
start_of_bucket = hash % ASIZE (h->index);
@ -4122,7 +4134,7 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
{
if (EQ (key, HASH_KEY (h, i))
|| (h->test.cmpfn
&& hash_code == XUINT (HASH_HASH (h, i))
&& hash_code == XUFIXNUM (HASH_HASH (h, i))
&& h->test.cmpfn (&h->test, key, HASH_KEY (h, i))))
{
/* Take entry out of collision chain. */
@ -4166,7 +4178,7 @@ hash_clear (struct Lisp_Hash_Table *h)
}
for (i = 0; i < ASIZE (h->index); ++i)
ASET (h->index, i, make_number (-1));
ASET (h->index, i, make_fixnum (-1));
h->next_free = 0;
h->count = 0;
@ -4433,6 +4445,20 @@ sxhash_bool_vector (Lisp_Object vec)
return SXHASH_REDUCE (hash);
}
/* Return a hash for a bignum. */
static EMACS_UINT
sxhash_bignum (struct Lisp_Bignum *bignum)
{
size_t i, nlimbs = mpz_size (bignum->value);
EMACS_UINT hash = 0;
for (i = 0; i < nlimbs; ++i)
hash = sxhash_combine (hash, mpz_getlimbn (bignum->value, i));
return SXHASH_REDUCE (hash);
}
/* Return a hash code for OBJ. DEPTH is the current depth in the Lisp
structure. Value is an unsigned integer clipped to INTMASK. */
@ -4448,10 +4474,16 @@ sxhash (Lisp_Object obj, int depth)
switch (XTYPE (obj))
{
case_Lisp_Int:
hash = XUINT (obj);
hash = XUFIXNUM (obj);
break;
case Lisp_Misc:
if (XMISCTYPE (obj) == Lisp_Misc_Bignum)
{
hash = sxhash_bignum (XBIGNUM (obj));
break;
}
FALLTHROUGH;
case Lisp_Symbol:
hash = XHASH (obj);
break;
@ -4502,7 +4534,7 @@ DEFUN ("sxhash-eq", Fsxhash_eq, Ssxhash_eq, 1, 1, 0,
If (eq A B), then (= (sxhash-eq A) (sxhash-eq B)). */)
(Lisp_Object obj)
{
return make_number (hashfn_eq (NULL, obj));
return make_fixnum (hashfn_eq (NULL, obj));
}
DEFUN ("sxhash-eql", Fsxhash_eql, Ssxhash_eql, 1, 1, 0,
@ -4510,7 +4542,7 @@ DEFUN ("sxhash-eql", Fsxhash_eql, Ssxhash_eql, 1, 1, 0,
If (eql A B), then (= (sxhash-eql A) (sxhash-eql B)). */)
(Lisp_Object obj)
{
return make_number (hashfn_eql (NULL, obj));
return make_fixnum (hashfn_eql (NULL, obj));
}
DEFUN ("sxhash-equal", Fsxhash_equal, Ssxhash_equal, 1, 1, 0,
@ -4518,7 +4550,7 @@ DEFUN ("sxhash-equal", Fsxhash_equal, Ssxhash_equal, 1, 1, 0,
If (equal A B), then (= (sxhash-equal A) (sxhash-equal B)). */)
(Lisp_Object obj)
{
return make_number (hashfn_equal (NULL, obj));
return make_fixnum (hashfn_equal (NULL, obj));
}
DEFUN ("make-hash-table", Fmake_hash_table, Smake_hash_table, 0, MANY, 0,
@ -4604,8 +4636,8 @@ usage: (make-hash-table &rest KEYWORD-ARGS) */)
EMACS_INT size;
if (NILP (size_arg))
size = DEFAULT_HASH_SIZE;
else if (NATNUMP (size_arg))
size = XFASTINT (size_arg);
else if (FIXNATP (size_arg))
size = XFIXNAT (size_arg);
else
signal_error ("Invalid hash table size", size_arg);
@ -4614,8 +4646,8 @@ usage: (make-hash-table &rest KEYWORD-ARGS) */)
i = get_key_arg (QCrehash_size, nargs, args, used);
if (!i)
rehash_size = DEFAULT_REHASH_SIZE;
else if (INTEGERP (args[i]) && 0 < XINT (args[i]))
rehash_size = - XINT (args[i]);
else if (FIXNUMP (args[i]) && 0 < XFIXNUM (args[i]))
rehash_size = - XFIXNUM (args[i]);
else if (FLOATP (args[i]) && 0 < (float) (XFLOAT_DATA (args[i]) - 1))
rehash_size = (float) (XFLOAT_DATA (args[i]) - 1);
else
@ -4664,7 +4696,7 @@ DEFUN ("hash-table-count", Fhash_table_count, Shash_table_count, 1, 1, 0,
doc: /* Return the number of elements in TABLE. */)
(Lisp_Object table)
{
return make_number (check_hash_table (table)->count);
return make_fixnum (check_hash_table (table)->count);
}
@ -4677,7 +4709,7 @@ DEFUN ("hash-table-rehash-size", Fhash_table_rehash_size,
if (rehash_size < 0)
{
EMACS_INT s = -rehash_size;
return make_number (min (s, MOST_POSITIVE_FIXNUM));
return make_fixnum (min (s, MOST_POSITIVE_FIXNUM));
}
else
return make_float (rehash_size + 1);
@ -4701,7 +4733,7 @@ without need for resizing. */)
(Lisp_Object table)
{
struct Lisp_Hash_Table *h = check_hash_table (table);
return make_number (HASH_TABLE_SIZE (h));
return make_fixnum (HASH_TABLE_SIZE (h));
}
@ -4929,16 +4961,16 @@ extract_data_from_object (Lisp_Object spec,
b = BEGV;
else
{
CHECK_NUMBER_COERCE_MARKER (start);
b = XINT (start);
CHECK_FIXNUM_COERCE_MARKER (start);
b = XFIXNUM (start);
}
if (NILP (end))
e = ZV;
else
{
CHECK_NUMBER_COERCE_MARKER (end);
e = XINT (end);
CHECK_FIXNUM_COERCE_MARKER (end);
e = XFIXNUM (end);
}
if (b > e)
@ -4993,7 +5025,7 @@ extract_data_from_object (Lisp_Object spec,
&& !NILP (Ffboundp (Vselect_safe_coding_system_function)))
/* Confirm that VAL can surely encode the current region. */
coding_system = call4 (Vselect_safe_coding_system_function,
make_number (b), make_number (e),
make_fixnum (b), make_fixnum (e),
coding_system, Qnil);
if (force_raw_text)
@ -5027,11 +5059,11 @@ extract_data_from_object (Lisp_Object spec,
#ifdef HAVE_GNUTLS3
/* Format: (iv-auto REQUIRED-LENGTH). */
if (! NATNUMP (start))
if (! FIXNATP (start))
error ("Without a length, `iv-auto' can't be used; see ELisp manual");
else
{
EMACS_INT start_hold = XFASTINT (start);
EMACS_INT start_hold = XFIXNAT (start);
object = make_uninit_string (start_hold);
gnutls_rnd (GNUTLS_RND_NONCE, SSDATA (object), start_hold);

432
src/font.c
View file

File diff suppressed because it is too large Load diff

14
src/font.h
View file

@ -185,16 +185,16 @@ enum font_property_index
/* Return the numeric weight value of FONT. */
#define FONT_WEIGHT_NUMERIC(font) \
(INTEGERP (AREF ((font), FONT_WEIGHT_INDEX)) \
? (XINT (AREF ((font), FONT_WEIGHT_INDEX)) >> 8) : -1)
(FIXNUMP (AREF ((font), FONT_WEIGHT_INDEX)) \
? (XFIXNUM (AREF ((font), FONT_WEIGHT_INDEX)) >> 8) : -1)
/* Return the numeric slant value of FONT. */
#define FONT_SLANT_NUMERIC(font) \
(INTEGERP (AREF ((font), FONT_SLANT_INDEX)) \
? (XINT (AREF ((font), FONT_SLANT_INDEX)) >> 8) : -1)
(FIXNUMP (AREF ((font), FONT_SLANT_INDEX)) \
? (XFIXNUM (AREF ((font), FONT_SLANT_INDEX)) >> 8) : -1)
/* Return the numeric width value of FONT. */
#define FONT_WIDTH_NUMERIC(font) \
(INTEGERP (AREF ((font), FONT_WIDTH_INDEX)) \
? (XINT (AREF ((font), FONT_WIDTH_INDEX)) >> 8) : -1)
(FIXNUMP (AREF ((font), FONT_WIDTH_INDEX)) \
? (XFIXNUM (AREF ((font), FONT_WIDTH_INDEX)) >> 8) : -1)
/* Return the symbolic weight value of FONT. */
#define FONT_WEIGHT_SYMBOLIC(font) \
font_style_symbolic (font, FONT_WEIGHT_INDEX, false)
@ -228,7 +228,7 @@ enum font_property_index
style-related font property index (FONT_WEIGHT/SLANT/WIDTH_INDEX).
VAL (integer or symbol) is the numeric or symbolic style value. */
#define FONT_SET_STYLE(font, prop, val) \
ASET ((font), prop, make_number (font_style_to_value (prop, val, true)))
ASET ((font), prop, make_fixnum (font_style_to_value (prop, val, true)))
#ifndef MSDOS
#define FONT_WIDTH(f) ((f)->max_width)

120
src/fontset.c
View file

@ -266,7 +266,7 @@ set_fontset_fallback (Lisp_Object fontset, Lisp_Object fallback)
#define RFONT_DEF_FACE(rfont_def) AREF (rfont_def, 0)
#define RFONT_DEF_SET_FACE(rfont_def, face_id) \
ASET ((rfont_def), 0, make_number (face_id))
ASET ((rfont_def), 0, make_fixnum (face_id))
#define RFONT_DEF_FONT_DEF(rfont_def) AREF (rfont_def, 1)
#define RFONT_DEF_SPEC(rfont_def) FONT_DEF_SPEC (AREF (rfont_def, 1))
#define RFONT_DEF_OBJECT(rfont_def) AREF (rfont_def, 2)
@ -276,12 +276,12 @@ set_fontset_fallback (Lisp_Object fontset, Lisp_Object fallback)
the order of listing by font backends, the higher bits represents
the order given by charset priority list. The smaller value is
preferable. */
#define RFONT_DEF_SCORE(rfont_def) XINT (AREF (rfont_def, 3))
#define RFONT_DEF_SCORE(rfont_def) XFIXNUM (AREF (rfont_def, 3))
#define RFONT_DEF_SET_SCORE(rfont_def, score) \
ASET ((rfont_def), 3, make_number (score))
ASET ((rfont_def), 3, make_fixnum (score))
#define RFONT_DEF_NEW(rfont_def, font_def) \
do { \
(rfont_def) = Fmake_vector (make_number (4), Qnil); \
(rfont_def) = Fmake_vector (make_fixnum (4), Qnil); \
ASET ((rfont_def), 1, (font_def)); \
RFONT_DEF_SET_SCORE ((rfont_def), 0); \
} while (0)
@ -328,10 +328,10 @@ fontset_ref (Lisp_Object fontset, int c)
(NILP (add) \
? (NILP (range) \
? (set_fontset_fallback \
(fontset, Fmake_vector (make_number (1), (elt)))) \
(fontset, Fmake_vector (make_fixnum (1), (elt)))) \
: ((void) \
Fset_char_table_range (fontset, range, \
Fmake_vector (make_number (1), elt)))) \
Fmake_vector (make_fixnum (1), elt)))) \
: fontset_add ((fontset), (range), (elt), (add)))
static void
@ -340,12 +340,12 @@ fontset_add (Lisp_Object fontset, Lisp_Object range, Lisp_Object elt, Lisp_Objec
Lisp_Object args[2];
int idx = (EQ (add, Qappend) ? 0 : 1);
args[1 - idx] = Fmake_vector (make_number (1), elt);
args[1 - idx] = Fmake_vector (make_fixnum (1), elt);
if (CONSP (range))
{
int from = XINT (XCAR (range));
int to = XINT (XCDR (range));
int from = XFIXNUM (XCAR (range));
int to = XFIXNUM (XCDR (range));
int from1, to1;
do {
@ -456,7 +456,7 @@ reorder_font_vector (Lisp_Object font_group, struct font *font)
qsort (XVECTOR (vec)->contents, size, word_size,
fontset_compare_rfontdef);
EMACS_INT low_tick_bits = charset_ordered_list_tick & MOST_POSITIVE_FIXNUM;
XSETCAR (font_group, make_number (low_tick_bits));
XSETCAR (font_group, make_fixnum (low_tick_bits));
}
/* Return a font-group (actually a cons (CHARSET_ORDERED_LIST_TICK
@ -496,7 +496,7 @@ fontset_get_font_group (Lisp_Object fontset, int c)
for C, or the fontset does not have fallback fonts. */
if (NILP (font_group))
{
font_group = make_number (0);
font_group = make_fixnum (0);
if (c >= 0)
/* Record that FONTSET does not specify fonts for C. As
there's a possibility that a font is found in a fallback
@ -520,7 +520,7 @@ fontset_get_font_group (Lisp_Object fontset, int c)
RFONT_DEF_SET_SCORE (rfont_def, i);
ASET (font_group, i, rfont_def);
}
font_group = Fcons (make_number (-1), font_group);
font_group = Fcons (make_fixnum (-1), font_group);
if (c >= 0)
char_table_set_range (fontset, from, to, font_group);
else
@ -561,7 +561,7 @@ fontset_find_font (Lisp_Object fontset, int c, struct face *face,
if (ASIZE (vec) > 1)
{
if (XINT (XCAR (font_group)) != charset_ordered_list_tick)
if (XFIXNUM (XCAR (font_group)) != charset_ordered_list_tick)
/* We have just created the font-group,
or the charset priorities were changed. */
reorder_font_vector (font_group, face->ascii_face->font);
@ -577,7 +577,7 @@ fontset_find_font (Lisp_Object fontset, int c, struct face *face,
break;
repertory = FONT_DEF_REPERTORY (RFONT_DEF_FONT_DEF (rfont_def));
if (XINT (repertory) == charset_id)
if (XFIXNUM (repertory) == charset_id)
{
charset_matched = i;
break;
@ -633,8 +633,8 @@ fontset_find_font (Lisp_Object fontset, int c, struct face *face,
/* This is a sign of not to try the other fonts. */
return Qt;
}
if (INTEGERP (RFONT_DEF_FACE (rfont_def))
&& XINT (RFONT_DEF_FACE (rfont_def)) < 0)
if (FIXNUMP (RFONT_DEF_FACE (rfont_def))
&& XFIXNUM (RFONT_DEF_FACE (rfont_def)) < 0)
/* We couldn't open this font last time. */
continue;
@ -711,7 +711,7 @@ fontset_find_font (Lisp_Object fontset, int c, struct face *face,
RFONT_DEF_NEW (rfont_def, font_def);
RFONT_DEF_SET_OBJECT (rfont_def, font_object);
RFONT_DEF_SET_SCORE (rfont_def, RFONT_DEF_SCORE (rfont_def));
new_vec = Fmake_vector (make_number (ASIZE (vec) + 1), Qnil);
new_vec = Fmake_vector (make_fixnum (ASIZE (vec) + 1), Qnil);
found_index++;
for (j = 0; j < found_index; j++)
ASET (new_vec, j, AREF (vec, j));
@ -727,7 +727,7 @@ fontset_find_font (Lisp_Object fontset, int c, struct face *face,
}
/* Record that no font in this font group supports C. */
FONTSET_SET (fontset, make_number (c), make_number (0));
FONTSET_SET (fontset, make_fixnum (c), make_fixnum (0));
return Qnil;
found:
@ -756,12 +756,12 @@ fontset_font (Lisp_Object fontset, int c, struct face *face, int id)
Lisp_Object base_fontset;
/* Try a font-group of FONTSET. */
FONT_DEFERRED_LOG ("current fontset: font for", make_number (c), Qnil);
FONT_DEFERRED_LOG ("current fontset: font for", make_fixnum (c), Qnil);
rfont_def = fontset_find_font (fontset, c, face, id, 0);
if (VECTORP (rfont_def))
return rfont_def;
if (NILP (rfont_def))
FONTSET_SET (fontset, make_number (c), make_number (0));
FONTSET_SET (fontset, make_fixnum (c), make_fixnum (0));
/* Try a font-group of the default fontset. */
base_fontset = FONTSET_BASE (fontset);
@ -771,37 +771,37 @@ fontset_font (Lisp_Object fontset, int c, struct face *face, int id)
set_fontset_default
(fontset,
make_fontset (FONTSET_FRAME (fontset), Qnil, Vdefault_fontset));
FONT_DEFERRED_LOG ("default fontset: font for", make_number (c), Qnil);
FONT_DEFERRED_LOG ("default fontset: font for", make_fixnum (c), Qnil);
default_rfont_def
= fontset_find_font (FONTSET_DEFAULT (fontset), c, face, id, 0);
if (VECTORP (default_rfont_def))
return default_rfont_def;
if (NILP (default_rfont_def))
FONTSET_SET (FONTSET_DEFAULT (fontset), make_number (c),
make_number (0));
FONTSET_SET (FONTSET_DEFAULT (fontset), make_fixnum (c),
make_fixnum (0));
}
/* Try a fallback font-group of FONTSET. */
if (! EQ (rfont_def, Qt))
{
FONT_DEFERRED_LOG ("current fallback: font for", make_number (c), Qnil);
FONT_DEFERRED_LOG ("current fallback: font for", make_fixnum (c), Qnil);
rfont_def = fontset_find_font (fontset, c, face, id, 1);
if (VECTORP (rfont_def))
return rfont_def;
/* Remember that FONTSET has no font for C. */
FONTSET_SET (fontset, make_number (c), Qt);
FONTSET_SET (fontset, make_fixnum (c), Qt);
}
/* Try a fallback font-group of the default fontset. */
if (! EQ (base_fontset, Vdefault_fontset)
&& ! EQ (default_rfont_def, Qt))
{
FONT_DEFERRED_LOG ("default fallback: font for", make_number (c), Qnil);
FONT_DEFERRED_LOG ("default fallback: font for", make_fixnum (c), Qnil);
rfont_def = fontset_find_font (FONTSET_DEFAULT (fontset), c, face, id, 1);
if (VECTORP (rfont_def))
return rfont_def;
/* Remember that the default fontset has no font for C. */
FONTSET_SET (FONTSET_DEFAULT (fontset), make_number (c), Qt);
FONTSET_SET (FONTSET_DEFAULT (fontset), make_fixnum (c), Qt);
}
return Qnil;
@ -830,7 +830,7 @@ make_fontset (Lisp_Object frame, Lisp_Object name, Lisp_Object base)
fontset = Fmake_char_table (Qfontset, Qnil);
set_fontset_id (fontset, make_number (id));
set_fontset_id (fontset, make_fixnum (id));
if (NILP (base))
set_fontset_name (fontset, name);
else
@ -892,7 +892,7 @@ free_face_fontset (struct frame *f, struct face *face)
next_fontset_id = face->fontset;
if (! NILP (FONTSET_DEFAULT (fontset)))
{
int id = XINT (FONTSET_ID (FONTSET_DEFAULT (fontset)));
int id = XFIXNUM (FONTSET_ID (FONTSET_DEFAULT (fontset)));
fontset = AREF (Vfontset_table, id);
eassert (!NILP (fontset) && ! BASE_FONTSET_P (fontset));
@ -973,7 +973,7 @@ face_for_char (struct frame *f, struct face *face, int c,
}
else
{
charset = Fget_char_property (make_number (pos), Qcharset, object);
charset = Fget_char_property (make_fixnum (pos), Qcharset, object);
if (CHARSETP (charset))
{
Lisp_Object val;
@ -981,7 +981,7 @@ face_for_char (struct frame *f, struct face *face, int c,
val = assq_no_quit (charset, Vfont_encoding_charset_alist);
if (CONSP (val) && CHARSETP (XCDR (val)))
charset = XCDR (val);
id = XINT (CHARSET_SYMBOL_ID (charset));
id = XFIXNUM (CHARSET_SYMBOL_ID (charset));
}
else
id = -1;
@ -990,8 +990,8 @@ face_for_char (struct frame *f, struct face *face, int c,
rfont_def = fontset_font (fontset, c, face, id);
if (VECTORP (rfont_def))
{
if (INTEGERP (RFONT_DEF_FACE (rfont_def)))
face_id = XINT (RFONT_DEF_FACE (rfont_def));
if (FIXNUMP (RFONT_DEF_FACE (rfont_def)))
face_id = XFIXNUM (RFONT_DEF_FACE (rfont_def));
else
{
Lisp_Object font_object;
@ -1003,12 +1003,12 @@ face_for_char (struct frame *f, struct face *face, int c,
}
else
{
if (INTEGERP (FONTSET_NOFONT_FACE (fontset)))
face_id = XINT (FONTSET_NOFONT_FACE (fontset));
if (FIXNUMP (FONTSET_NOFONT_FACE (fontset)))
face_id = XFIXNUM (FONTSET_NOFONT_FACE (fontset));
else
{
face_id = face_for_font (f, Qnil, face);
set_fontset_nofont_face (fontset, make_number (face_id));
set_fontset_nofont_face (fontset, make_fixnum (face_id));
}
}
eassert (face_id >= 0);
@ -1040,7 +1040,7 @@ font_for_char (struct face *face, int c, ptrdiff_t pos, Lisp_Object object)
}
else
{
charset = Fget_char_property (make_number (pos), Qcharset, object);
charset = Fget_char_property (make_fixnum (pos), Qcharset, object);
if (CHARSETP (charset))
{
Lisp_Object val;
@ -1048,7 +1048,7 @@ font_for_char (struct face *face, int c, ptrdiff_t pos, Lisp_Object object)
val = assq_no_quit (charset, Vfont_encoding_charset_alist);
if (CONSP (val) && CHARSETP (XCDR (val)))
charset = XCDR (val);
id = XINT (CHARSET_SYMBOL_ID (charset));
id = XFIXNUM (CHARSET_SYMBOL_ID (charset));
}
else
id = -1;
@ -1083,7 +1083,7 @@ make_fontset_for_ascii_face (struct frame *f, int base_fontset_id, struct face *
base_fontset = Vdefault_fontset;
fontset = make_fontset (frame, Qnil, base_fontset);
return XINT (FONTSET_ID (fontset));
return XFIXNUM (FONTSET_ID (fontset));
}
@ -1306,7 +1306,7 @@ free_realized_fontsets (Lisp_Object base)
tail = XCDR (tail))
{
struct frame *f = XFRAME (FONTSET_FRAME (this));
int face_id = XINT (XCDR (XCAR (tail)));
int face_id = XFIXNUM (XCDR (XCAR (tail)));
struct face *face = FACE_FROM_ID_OR_NULL (f, face_id);
/* Face THIS itself is also freed by the following call. */
@ -1399,7 +1399,7 @@ static void
set_fontset_font (Lisp_Object arg, Lisp_Object range)
{
Lisp_Object fontset, font_def, add, ascii, script_range_list;
int from = XINT (XCAR (range)), to = XINT (XCDR (range));
int from = XFIXNUM (XCAR (range)), to = XFIXNUM (XCDR (range));
fontset = AREF (arg, 0);
font_def = AREF (arg, 1);
@ -1412,11 +1412,11 @@ set_fontset_font (Lisp_Object arg, Lisp_Object range)
if (to < 0x80)
return;
from = 0x80;
range = Fcons (make_number (0x80), XCDR (range));
range = Fcons (make_fixnum (0x80), XCDR (range));
}
#define SCRIPT_FROM XINT (XCAR (XCAR (script_range_list)))
#define SCRIPT_TO XINT (XCDR (XCAR (script_range_list)))
#define SCRIPT_FROM XFIXNUM (XCAR (XCAR (script_range_list)))
#define SCRIPT_TO XFIXNUM (XCDR (XCAR (script_range_list)))
#define POP_SCRIPT_RANGE() script_range_list = XCDR (script_range_list)
for (; CONSP (script_range_list) && SCRIPT_TO < from; POP_SCRIPT_RANGE ())
@ -1424,11 +1424,11 @@ set_fontset_font (Lisp_Object arg, Lisp_Object range)
if (CONSP (script_range_list))
{
if (SCRIPT_FROM < from)
range = Fcons (make_number (SCRIPT_FROM), XCDR (range));
range = Fcons (make_fixnum (SCRIPT_FROM), XCDR (range));
while (CONSP (script_range_list) && SCRIPT_TO <= to)
POP_SCRIPT_RANGE ();
if (CONSP (script_range_list) && SCRIPT_FROM <= to)
XSETCAR (XCAR (script_range_list), make_number (to + 1));
XSETCAR (XCAR (script_range_list), make_fixnum (to + 1));
}
FONTSET_ADD (fontset, range, font_def, add);
@ -1547,7 +1547,7 @@ appended. By default, FONT-SPEC overrides the previous settings. */)
if (CHARACTERP (target))
{
if (XFASTINT (target) < 0x80)
if (XFIXNAT (target) < 0x80)
error ("Can't set a font for partial ASCII range");
range_list = list1 (Fcons (target, target));
}
@ -1559,9 +1559,9 @@ appended. By default, FONT-SPEC overrides the previous settings. */)
to = Fcdr (target);
CHECK_CHARACTER (from);
CHECK_CHARACTER (to);
if (XFASTINT (from) < 0x80)
if (XFIXNAT (from) < 0x80)
{
if (XFASTINT (from) != 0 || XFASTINT (to) < 0x7F)
if (XFIXNAT (from) != 0 || XFIXNAT (to) < 0x7F)
error ("Can't set a font for partial ASCII range");
ascii_changed = 1;
}
@ -1632,7 +1632,7 @@ appended. By default, FONT-SPEC overrides the previous settings. */)
if (ascii_changed)
{
Lisp_Object tail, fr;
int fontset_id = XINT (FONTSET_ID (fontset));
int fontset_id = XFIXNUM (FONTSET_ID (fontset));
set_fontset_ascii (fontset, fontname);
name = FONTSET_NAME (fontset);
@ -1765,7 +1765,7 @@ fontset_from_font (Lisp_Object font_object)
val = assoc_no_quit (font_spec, auto_fontset_alist);
if (CONSP (val))
return XINT (FONTSET_ID (XCDR (val)));
return XFIXNUM (FONTSET_ID (XCDR (val)));
if (num_auto_fontsets++ == 0)
alias = intern ("fontset-startup");
else
@ -1800,7 +1800,7 @@ fontset_from_font (Lisp_Object font_object)
set_fontset_ascii (fontset, font_name);
return XINT (FONTSET_ID (fontset));
return XFIXNUM (FONTSET_ID (fontset));
}
@ -1988,7 +1988,7 @@ patterns. */)
fontset = check_fontset_name (name, &frame);
CHECK_CHARACTER (ch);
c = XINT (ch);
c = XFIXNUM (ch);
list = Qnil;
while (1)
{
@ -2003,9 +2003,9 @@ patterns. */)
if (NILP (val))
return Qnil;
repertory = AREF (val, 1);
if (INTEGERP (repertory))
if (FIXNUMP (repertory))
{
struct charset *charset = CHARSET_FROM_ID (XINT (repertory));
struct charset *charset = CHARSET_FROM_ID (XFIXNUM (repertory));
if (! CHAR_CHARSET_P (c, charset))
continue;
@ -2064,7 +2064,7 @@ dump_fontset (Lisp_Object fontset)
{
Lisp_Object vec;
vec = Fmake_vector (make_number (3), Qnil);
vec = Fmake_vector (make_fixnum (3), Qnil);
ASET (vec, 0, FONTSET_ID (fontset));
if (BASE_FONTSET_P (fontset))
@ -2112,9 +2112,9 @@ void
syms_of_fontset (void)
{
DEFSYM (Qfontset, "fontset");
Fput (Qfontset, Qchar_table_extra_slots, make_number (8));
Fput (Qfontset, Qchar_table_extra_slots, make_fixnum (8));
DEFSYM (Qfontset_info, "fontset-info");
Fput (Qfontset_info, Qchar_table_extra_slots, make_number (1));
Fput (Qfontset_info, Qchar_table_extra_slots, make_fixnum (1));
DEFSYM (Qappend, "append");
DEFSYM (Qlatin, "latin");
@ -2122,12 +2122,12 @@ syms_of_fontset (void)
Vcached_fontset_data = Qnil;
staticpro (&Vcached_fontset_data);
Vfontset_table = Fmake_vector (make_number (32), Qnil);
Vfontset_table = Fmake_vector (make_fixnum (32), Qnil);
staticpro (&Vfontset_table);
Vdefault_fontset = Fmake_char_table (Qfontset, Qnil);
staticpro (&Vdefault_fontset);
set_fontset_id (Vdefault_fontset, make_number (0));
set_fontset_id (Vdefault_fontset, make_fixnum (0));
set_fontset_name
(Vdefault_fontset,
build_pure_c_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default"));

364
src/frame.c
View file

@ -153,17 +153,17 @@ frame_size_history_add (struct frame *f, Lisp_Object fun_symbol,
XSETFRAME (frame, f);
if (CONSP (frame_size_history)
&& INTEGERP (XCAR (frame_size_history))
&& 0 < XINT (XCAR (frame_size_history)))
&& FIXNUMP (XCAR (frame_size_history))
&& 0 < XFIXNUM (XCAR (frame_size_history)))
frame_size_history =
Fcons (make_number (XINT (XCAR (frame_size_history)) - 1),
Fcons (make_fixnum (XFIXNUM (XCAR (frame_size_history)) - 1),
Fcons (list4
(frame, fun_symbol,
((width > 0)
? list4 (make_number (FRAME_TEXT_WIDTH (f)),
make_number (FRAME_TEXT_HEIGHT (f)),
make_number (width),
make_number (height))
? list4 (make_fixnum (FRAME_TEXT_WIDTH (f)),
make_fixnum (FRAME_TEXT_HEIGHT (f)),
make_fixnum (width),
make_fixnum (height))
: Qnil),
rest),
XCDR (frame_size_history)));
@ -214,8 +214,8 @@ set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
if (FRAME_MINIBUF_ONLY_P (f))
return;
if (TYPE_RANGED_INTEGERP (int, value))
nlines = XINT (value);
if (TYPE_RANGED_FIXNUMP (int, value))
nlines = XFIXNUM (value);
else
nlines = 0;
@ -317,7 +317,7 @@ DEFUN ("frame-windows-min-size", Fframe_windows_min_size,
(Lisp_Object frame, Lisp_Object horizontal,
Lisp_Object ignore, Lisp_Object pixelwise)
{
return make_number (0);
return make_fixnum (0);
}
/**
@ -350,11 +350,11 @@ frame_windows_min_size (Lisp_Object frame, Lisp_Object horizontal,
int retval;
if ((!NILP (horizontal)
&& NUMBERP (par_size = get_frame_param (f, Qmin_width)))
&& FIXED_OR_FLOATP (par_size = get_frame_param (f, Qmin_width)))
|| (NILP (horizontal)
&& NUMBERP (par_size = get_frame_param (f, Qmin_height))))
&& FIXED_OR_FLOATP (par_size = get_frame_param (f, Qmin_height))))
{
int min_size = XINT (par_size);
int min_size = XFIXNUM (par_size);
/* Don't allow phantom frames. */
if (min_size < 1)
@ -367,7 +367,7 @@ frame_windows_min_size (Lisp_Object frame, Lisp_Object horizontal,
: FRAME_COLUMN_WIDTH (f)));
}
else
retval = XINT (call4 (Qframe_windows_min_size, frame, horizontal,
retval = XFIXNUM (call4 (Qframe_windows_min_size, frame, horizontal,
ignore, pixelwise));
/* Don't allow too small height of text-mode frames, or else cm.c
might abort in cmcheckmagic. */
@ -591,7 +591,7 @@ adjust_frame_size (struct frame *f, int new_width, int new_height, int inhibit,
frame_size_history_add
(f, Qadjust_frame_size_1, new_text_width, new_text_height,
list2 (parameter, make_number (inhibit)));
list2 (parameter, make_fixnum (inhibit)));
/* The following two values are calculated from the old window body
sizes and any "new" settings for scroll bars, dividers, fringes and
@ -737,8 +737,8 @@ adjust_frame_size (struct frame *f, int new_width, int new_height, int inhibit,
frame_size_history_add
(f, Qadjust_frame_size_3, new_text_width, new_text_height,
list4 (make_number (old_pixel_width), make_number (old_pixel_height),
make_number (new_pixel_width), make_number (new_pixel_height)));
list4 (make_fixnum (old_pixel_width), make_fixnum (old_pixel_height),
make_fixnum (new_pixel_width), make_fixnum (new_pixel_height)));
/* Assign new sizes. */
FRAME_TEXT_WIDTH (f) = new_text_width;
@ -1075,7 +1075,7 @@ make_initial_frame (void)
#endif
/* The default value of menu-bar-mode is t. */
set_menu_bar_lines (f, make_number (1), Qnil);
set_menu_bar_lines (f, make_fixnum (1), Qnil);
/* Allocate glyph matrices. */
adjust_frame_glyphs (f);
@ -1593,7 +1593,7 @@ candidate_frame (Lisp_Object candidate, Lisp_Object frame, Lisp_Object minibuf)
FRAME_FOCUS_FRAME (c)))
return candidate;
}
else if (INTEGERP (minibuf) && XINT (minibuf) == 0)
else if (FIXNUMP (minibuf) && XFIXNUM (minibuf) == 0)
{
if (FRAME_VISIBLE_P (c) || FRAME_ICONIFIED_P (c))
return candidate;
@ -1785,7 +1785,7 @@ check_minibuf_window (Lisp_Object frame, int select)
if (WINDOWP (minibuf_window) && EQ (f->minibuffer_window, minibuf_window))
{
Lisp_Object frames, this, window = make_number (0);
Lisp_Object frames, this, window = make_fixnum (0);
if (!EQ (frame, selected_frame)
&& FRAME_HAS_MINIBUF_P (XFRAME (selected_frame)))
@ -2315,8 +2315,8 @@ and returns whatever that function returns. */)
if (! NILP (x))
{
int col = XINT (x);
int row = XINT (y);
int col = XFIXNUM (x);
int row = XFIXNUM (y);
pixel_to_glyph_coords (f, col, row, &col, &row, NULL, 1);
XSETINT (x, col);
XSETINT (y, row);
@ -2425,19 +2425,19 @@ before calling this function on it, like this.
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (XFRAME (frame)))
/* Warping the mouse will cause enternotify and focus events. */
frame_set_mouse_position (XFRAME (frame), XINT (x), XINT (y));
frame_set_mouse_position (XFRAME (frame), XFIXNUM (x), XFIXNUM (y));
#else
#if defined (MSDOS)
if (FRAME_MSDOS_P (XFRAME (frame)))
{
Fselect_frame (frame, Qnil);
mouse_moveto (XINT (x), XINT (y));
mouse_moveto (XFIXNUM (x), XFIXNUM (y));
}
#else
#ifdef HAVE_GPM
{
Fselect_frame (frame, Qnil);
term_mouse_moveto (XINT (x), XINT (y));
term_mouse_moveto (XFIXNUM (x), XFIXNUM (y));
}
#endif
#endif
@ -2466,19 +2466,19 @@ before calling this function on it, like this.
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (XFRAME (frame)))
/* Warping the mouse will cause enternotify and focus events. */
frame_set_mouse_pixel_position (XFRAME (frame), XINT (x), XINT (y));
frame_set_mouse_pixel_position (XFRAME (frame), XFIXNUM (x), XFIXNUM (y));
#else
#if defined (MSDOS)
if (FRAME_MSDOS_P (XFRAME (frame)))
{
Fselect_frame (frame, Qnil);
mouse_moveto (XINT (x), XINT (y));
mouse_moveto (XFIXNUM (x), XFIXNUM (y));
}
#else
#ifdef HAVE_GPM
{
Fselect_frame (frame, Qnil);
term_mouse_moveto (XINT (x), XINT (y));
term_mouse_moveto (XFIXNUM (x), XFIXNUM (y));
}
#endif
#endif
@ -2982,7 +2982,7 @@ store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
if (! FRAME_WINDOW_P (f))
{
if (EQ (prop, Qmenu_bar_lines))
set_menu_bar_lines (f, val, make_number (FRAME_MENU_BAR_LINES (f)));
set_menu_bar_lines (f, val, make_fixnum (FRAME_MENU_BAR_LINES (f)));
else if (EQ (prop, Qname))
set_term_frame_name (f, val);
}
@ -3055,13 +3055,13 @@ If FRAME is omitted or nil, return information on the currently selected frame.
? (f->new_height / FRAME_LINE_HEIGHT (f))
: f->new_height)
: FRAME_LINES (f));
store_in_alist (&alist, Qheight, make_number (height));
store_in_alist (&alist, Qheight, make_fixnum (height));
width = (f->new_width
? (f->new_pixelwise
? (f->new_width / FRAME_COLUMN_WIDTH (f))
: f->new_width)
: FRAME_COLS (f));
store_in_alist (&alist, Qwidth, make_number (width));
store_in_alist (&alist, Qwidth, make_fixnum (width));
store_in_alist (&alist, Qmodeline, (FRAME_WANTS_MODELINE_P (f) ? Qt : Qnil));
store_in_alist (&alist, Qunsplittable, (FRAME_NO_SPLIT_P (f) ? Qt : Qnil));
store_in_alist (&alist, Qbuffer_list, f->buffer_list);
@ -3113,7 +3113,7 @@ If FRAME is nil, describe the currently selected frame. */)
else if (EQ (parameter, Qline_spacing) && f->extra_line_spacing == 0)
/* If this is non-zero, we can't determine whether the user specified
an integer or float value without looking through 'param_alist'. */
value = make_number (0);
value = make_fixnum (0);
else if (EQ (parameter, Qfont) && FRAME_X_P (f))
value = FRAME_FONT (f)->props[FONT_NAME_INDEX];
#endif /* HAVE_WINDOW_SYSTEM */
@ -3186,7 +3186,7 @@ list, but are otherwise ignored. */)
#endif
{
EMACS_INT length = XFASTINT (Flength (alist));
EMACS_INT length = XFIXNAT (Flength (alist));
ptrdiff_t i;
Lisp_Object *parms;
Lisp_Object *values;
@ -3234,10 +3234,10 @@ For a terminal frame, the value is always 1. */)
struct frame *f = decode_any_frame (frame);
if (FRAME_WINDOW_P (f))
return make_number (FRAME_LINE_HEIGHT (f));
return make_fixnum (FRAME_LINE_HEIGHT (f));
else
#endif
return make_number (1);
return make_fixnum (1);
}
@ -3253,10 +3253,10 @@ For a terminal screen, the value is always 1. */)
struct frame *f = decode_any_frame (frame);
if (FRAME_WINDOW_P (f))
return make_number (FRAME_COLUMN_WIDTH (f));
return make_fixnum (FRAME_COLUMN_WIDTH (f));
else
#endif
return make_number (1);
return make_fixnum (1);
}
DEFUN ("frame-native-width", Fframe_native_width,
@ -3270,10 +3270,10 @@ If FRAME is omitted or nil, the selected frame is used. */)
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
return make_number (FRAME_PIXEL_WIDTH (f));
return make_fixnum (FRAME_PIXEL_WIDTH (f));
else
#endif
return make_number (FRAME_TOTAL_COLS (f));
return make_fixnum (FRAME_TOTAL_COLS (f));
}
DEFUN ("frame-native-height", Fframe_native_height,
@ -3296,10 +3296,10 @@ to `frame-height'). */)
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
return make_number (FRAME_PIXEL_HEIGHT (f));
return make_fixnum (FRAME_PIXEL_HEIGHT (f));
else
#endif
return make_number (FRAME_TOTAL_LINES (f));
return make_fixnum (FRAME_TOTAL_LINES (f));
}
DEFUN ("tool-bar-pixel-width", Ftool_bar_pixel_width,
@ -3314,93 +3314,93 @@ is used. */)
struct frame *f = decode_any_frame (frame);
if (FRAME_WINDOW_P (f))
return make_number (FRAME_TOOLBAR_WIDTH (f));
return make_fixnum (FRAME_TOOLBAR_WIDTH (f));
#endif
return make_number (0);
return make_fixnum (0);
}
DEFUN ("frame-text-cols", Fframe_text_cols, Sframe_text_cols, 0, 1, 0,
doc: /* Return width in columns of FRAME's text area. */)
(Lisp_Object frame)
{
return make_number (FRAME_COLS (decode_any_frame (frame)));
return make_fixnum (FRAME_COLS (decode_any_frame (frame)));
}
DEFUN ("frame-text-lines", Fframe_text_lines, Sframe_text_lines, 0, 1, 0,
doc: /* Return height in lines of FRAME's text area. */)
(Lisp_Object frame)
{
return make_number (FRAME_LINES (decode_any_frame (frame)));
return make_fixnum (FRAME_LINES (decode_any_frame (frame)));
}
DEFUN ("frame-total-cols", Fframe_total_cols, Sframe_total_cols, 0, 1, 0,
doc: /* Return number of total columns of FRAME. */)
(Lisp_Object frame)
{
return make_number (FRAME_TOTAL_COLS (decode_any_frame (frame)));
return make_fixnum (FRAME_TOTAL_COLS (decode_any_frame (frame)));
}
DEFUN ("frame-total-lines", Fframe_total_lines, Sframe_total_lines, 0, 1, 0,
doc: /* Return number of total lines of FRAME. */)
(Lisp_Object frame)
{
return make_number (FRAME_TOTAL_LINES (decode_any_frame (frame)));
return make_fixnum (FRAME_TOTAL_LINES (decode_any_frame (frame)));
}
DEFUN ("frame-text-width", Fframe_text_width, Sframe_text_width, 0, 1, 0,
doc: /* Return text area width of FRAME in pixels. */)
(Lisp_Object frame)
{
return make_number (FRAME_TEXT_WIDTH (decode_any_frame (frame)));
return make_fixnum (FRAME_TEXT_WIDTH (decode_any_frame (frame)));
}
DEFUN ("frame-text-height", Fframe_text_height, Sframe_text_height, 0, 1, 0,
doc: /* Return text area height of FRAME in pixels. */)
(Lisp_Object frame)
{
return make_number (FRAME_TEXT_HEIGHT (decode_any_frame (frame)));
return make_fixnum (FRAME_TEXT_HEIGHT (decode_any_frame (frame)));
}
DEFUN ("frame-scroll-bar-width", Fscroll_bar_width, Sscroll_bar_width, 0, 1, 0,
doc: /* Return scroll bar width of FRAME in pixels. */)
(Lisp_Object frame)
{
return make_number (FRAME_SCROLL_BAR_AREA_WIDTH (decode_any_frame (frame)));
return make_fixnum (FRAME_SCROLL_BAR_AREA_WIDTH (decode_any_frame (frame)));
}
DEFUN ("frame-scroll-bar-height", Fscroll_bar_height, Sscroll_bar_height, 0, 1, 0,
doc: /* Return scroll bar height of FRAME in pixels. */)
(Lisp_Object frame)
{
return make_number (FRAME_SCROLL_BAR_AREA_HEIGHT (decode_any_frame (frame)));
return make_fixnum (FRAME_SCROLL_BAR_AREA_HEIGHT (decode_any_frame (frame)));
}
DEFUN ("frame-fringe-width", Ffringe_width, Sfringe_width, 0, 1, 0,
doc: /* Return fringe width of FRAME in pixels. */)
(Lisp_Object frame)
{
return make_number (FRAME_TOTAL_FRINGE_WIDTH (decode_any_frame (frame)));
return make_fixnum (FRAME_TOTAL_FRINGE_WIDTH (decode_any_frame (frame)));
}
DEFUN ("frame-internal-border-width", Fframe_internal_border_width, Sframe_internal_border_width, 0, 1, 0,
doc: /* Return width of FRAME's internal border in pixels. */)
(Lisp_Object frame)
{
return make_number (FRAME_INTERNAL_BORDER_WIDTH (decode_any_frame (frame)));
return make_fixnum (FRAME_INTERNAL_BORDER_WIDTH (decode_any_frame (frame)));
}
DEFUN ("frame-right-divider-width", Fright_divider_width, Sright_divider_width, 0, 1, 0,
doc: /* Return width (in pixels) of vertical window dividers on FRAME. */)
(Lisp_Object frame)
{
return make_number (FRAME_RIGHT_DIVIDER_WIDTH (decode_any_frame (frame)));
return make_fixnum (FRAME_RIGHT_DIVIDER_WIDTH (decode_any_frame (frame)));
}
DEFUN ("frame-bottom-divider-width", Fbottom_divider_width, Sbottom_divider_width, 0, 1, 0,
doc: /* Return width (in pixels) of horizontal window dividers on FRAME. */)
(Lisp_Object frame)
{
return make_number (FRAME_BOTTOM_DIVIDER_WIDTH (decode_any_frame (frame)));
return make_fixnum (FRAME_BOTTOM_DIVIDER_WIDTH (decode_any_frame (frame)));
}
DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 4, 0,
@ -3421,8 +3421,8 @@ multiple of the default frame font height. */)
CHECK_TYPE_RANGED_INTEGER (int, height);
pixel_height = (!NILP (pixelwise)
? XINT (height)
: XINT (height) * FRAME_LINE_HEIGHT (f));
? XFIXNUM (height)
: XFIXNUM (height) * FRAME_LINE_HEIGHT (f));
adjust_frame_size (f, -1, pixel_height, 1, !NILP (pretend), Qheight);
return Qnil;
@ -3446,8 +3446,8 @@ multiple of the default frame font width. */)
CHECK_TYPE_RANGED_INTEGER (int, width);
pixel_width = (!NILP (pixelwise)
? XINT (width)
: XINT (width) * FRAME_COLUMN_WIDTH (f));
? XFIXNUM (width)
: XFIXNUM (width) * FRAME_COLUMN_WIDTH (f));
adjust_frame_size (f, pixel_width, -1, 1, !NILP (pretend), Qwidth);
return Qnil;
@ -3469,11 +3469,11 @@ font height. */)
CHECK_TYPE_RANGED_INTEGER (int, height);
pixel_width = (!NILP (pixelwise)
? XINT (width)
: XINT (width) * FRAME_COLUMN_WIDTH (f));
? XFIXNUM (width)
: XFIXNUM (width) * FRAME_COLUMN_WIDTH (f));
pixel_height = (!NILP (pixelwise)
? XINT (height)
: XINT (height) * FRAME_LINE_HEIGHT (f));
? XFIXNUM (height)
: XFIXNUM (height) * FRAME_LINE_HEIGHT (f));
adjust_frame_size (f, pixel_width, pixel_height, 1, 0, Qsize);
return Qnil;
@ -3490,7 +3490,7 @@ display. */)
{
register struct frame *f = decode_live_frame (frame);
return Fcons (make_number (f->left_pos), make_number (f->top_pos));
return Fcons (make_fixnum (f->left_pos), make_fixnum (f->top_pos));
}
DEFUN ("set-frame-position", Fset_frame_position,
@ -3513,7 +3513,7 @@ bottom edge of FRAME's display. */)
if (FRAME_WINDOW_P (f))
{
#ifdef HAVE_WINDOW_SYSTEM
x_set_offset (f, XINT (x), XINT (y), 1);
x_set_offset (f, XFIXNUM (x), XFIXNUM (y), 1);
#endif
}
@ -3682,10 +3682,10 @@ frame_float (struct frame *f, Lisp_Object val, enum frame_float_type what,
}
/* Workarea available. */
parent_left = XINT (Fnth (make_number (0), workarea));
parent_top = XINT (Fnth (make_number (1), workarea));
parent_width = XINT (Fnth (make_number (2), workarea));
parent_height = XINT (Fnth (make_number (3), workarea));
parent_left = XFIXNUM (Fnth (make_fixnum (0), workarea));
parent_top = XFIXNUM (Fnth (make_fixnum (1), workarea));
parent_width = XFIXNUM (Fnth (make_fixnum (2), workarea));
parent_height = XFIXNUM (Fnth (make_fixnum (3), workarea));
*parent_done = 1;
}
}
@ -3713,12 +3713,12 @@ frame_float (struct frame *f, Lisp_Object val, enum frame_float_type what,
if (!NILP (outer_edges))
{
outer_minus_text_width
= (XINT (Fnth (make_number (2), outer_edges))
- XINT (Fnth (make_number (0), outer_edges))
= (XFIXNUM (Fnth (make_fixnum (2), outer_edges))
- XFIXNUM (Fnth (make_fixnum (0), outer_edges))
- FRAME_TEXT_WIDTH (f));
outer_minus_text_height
= (XINT (Fnth (make_number (3), outer_edges))
- XINT (Fnth (make_number (1), outer_edges))
= (XFIXNUM (Fnth (make_fixnum (3), outer_edges))
- XFIXNUM (Fnth (make_fixnum (1), outer_edges))
- FRAME_TEXT_HEIGHT (f));
}
else
@ -3867,22 +3867,22 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
if (EQ (prop, Qwidth))
{
if (RANGED_INTEGERP (0, val, INT_MAX))
width = XFASTINT (val) * FRAME_COLUMN_WIDTH (f) ;
if (RANGED_FIXNUMP (0, val, INT_MAX))
width = XFIXNAT (val) * FRAME_COLUMN_WIDTH (f) ;
else if (CONSP (val) && EQ (XCAR (val), Qtext_pixels)
&& RANGED_INTEGERP (0, XCDR (val), INT_MAX))
width = XFASTINT (XCDR (val));
&& RANGED_FIXNUMP (0, XCDR (val), INT_MAX))
width = XFIXNAT (XCDR (val));
else if (FLOATP (val))
width = frame_float (f, val, FRAME_FLOAT_WIDTH, &parent_done,
&outer_done, -1);
}
else if (EQ (prop, Qheight))
{
if (RANGED_INTEGERP (0, val, INT_MAX))
height = XFASTINT (val) * FRAME_LINE_HEIGHT (f);
if (RANGED_FIXNUMP (0, val, INT_MAX))
height = XFIXNAT (val) * FRAME_LINE_HEIGHT (f);
else if (CONSP (val) && EQ (XCAR (val), Qtext_pixels)
&& RANGED_INTEGERP (0, XCDR (val), INT_MAX))
height = XFASTINT (XCDR (val));
&& RANGED_FIXNUMP (0, XCDR (val), INT_MAX))
height = XFIXNAT (XCDR (val));
else if (FLOATP (val))
height = frame_float (f, val, FRAME_FLOAT_HEIGHT, &parent_done,
&outer_done, -1);
@ -3909,10 +3909,10 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
store_frame_param (f, prop, val);
param_index = Fget (prop, Qx_frame_parameter);
if (NATNUMP (param_index)
&& XFASTINT (param_index) < ARRAYELTS (frame_parms)
&& FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])
(*(FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
if (FIXNATP (param_index)
&& XFIXNAT (param_index) < ARRAYELTS (frame_parms)
&& FRAME_RIF (f)->frame_parm_handlers[XFIXNUM (param_index)])
(*(FRAME_RIF (f)->frame_parm_handlers[XFIXNUM (param_index)])) (f, val, old_value);
}
}
@ -3921,7 +3921,7 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
{
left_no_change = 1;
if (f->left_pos < 0)
left = list2 (Qplus, make_number (f->left_pos));
left = list2 (Qplus, make_fixnum (f->left_pos));
else
XSETINT (left, f->left_pos);
}
@ -3929,13 +3929,13 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
{
top_no_change = 1;
if (f->top_pos < 0)
top = list2 (Qplus, make_number (f->top_pos));
top = list2 (Qplus, make_fixnum (f->top_pos));
else
XSETINT (top, f->top_pos);
}
/* If one of the icon positions was not set, preserve or default it. */
if (! TYPE_RANGED_INTEGERP (int, icon_left))
if (! TYPE_RANGED_FIXNUMP (int, icon_left))
{
#ifdef HAVE_X_WINDOWS
icon_left_no_change = 1;
@ -3944,7 +3944,7 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
if (NILP (icon_left))
XSETINT (icon_left, 0);
}
if (! TYPE_RANGED_INTEGERP (int, icon_top))
if (! TYPE_RANGED_FIXNUMP (int, icon_top))
{
#ifdef HAVE_X_WINDOWS
icon_top_no_change = 1;
@ -3974,8 +3974,8 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
if ((!NILP (left) || !NILP (top))
&& ! (left_no_change && top_no_change)
&& ! (NUMBERP (left) && XINT (left) == f->left_pos
&& NUMBERP (top) && XINT (top) == f->top_pos))
&& ! (FIXED_OR_FLOATP (left) && XFIXNUM (left) == f->left_pos
&& FIXED_OR_FLOATP (top) && XFIXNUM (top) == f->top_pos))
{
int leftpos = 0;
int toppos = 0;
@ -3984,46 +3984,46 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
f->size_hint_flags &= ~ (XNegative | YNegative);
if (EQ (left, Qminus))
f->size_hint_flags |= XNegative;
else if (TYPE_RANGED_INTEGERP (int, left))
else if (TYPE_RANGED_FIXNUMP (int, left))
{
leftpos = XINT (left);
leftpos = XFIXNUM (left);
if (leftpos < 0)
f->size_hint_flags |= XNegative;
}
else if (CONSP (left) && EQ (XCAR (left), Qminus)
&& CONSP (XCDR (left))
&& RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
&& RANGED_FIXNUMP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
{
leftpos = - XINT (XCAR (XCDR (left)));
leftpos = - XFIXNUM (XCAR (XCDR (left)));
f->size_hint_flags |= XNegative;
}
else if (CONSP (left) && EQ (XCAR (left), Qplus)
&& CONSP (XCDR (left))
&& TYPE_RANGED_INTEGERP (int, XCAR (XCDR (left))))
leftpos = XINT (XCAR (XCDR (left)));
&& TYPE_RANGED_FIXNUMP (int, XCAR (XCDR (left))))
leftpos = XFIXNUM (XCAR (XCDR (left)));
else if (FLOATP (left))
leftpos = frame_float (f, left, FRAME_FLOAT_LEFT, &parent_done,
&outer_done, 0);
if (EQ (top, Qminus))
f->size_hint_flags |= YNegative;
else if (TYPE_RANGED_INTEGERP (int, top))
else if (TYPE_RANGED_FIXNUMP (int, top))
{
toppos = XINT (top);
toppos = XFIXNUM (top);
if (toppos < 0)
f->size_hint_flags |= YNegative;
}
else if (CONSP (top) && EQ (XCAR (top), Qminus)
&& CONSP (XCDR (top))
&& RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
&& RANGED_FIXNUMP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
{
toppos = - XINT (XCAR (XCDR (top)));
toppos = - XFIXNUM (XCAR (XCDR (top)));
f->size_hint_flags |= YNegative;
}
else if (CONSP (top) && EQ (XCAR (top), Qplus)
&& CONSP (XCDR (top))
&& TYPE_RANGED_INTEGERP (int, XCAR (XCDR (top))))
toppos = XINT (XCAR (XCDR (top)));
&& TYPE_RANGED_FIXNUMP (int, XCAR (XCDR (top))))
toppos = XFIXNUM (XCAR (XCDR (top)));
else if (FLOATP (top))
toppos = frame_float (f, top, FRAME_FLOAT_TOP, &parent_done,
&outer_done, 0);
@ -4054,7 +4054,7 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
#ifdef HAVE_X_WINDOWS
if ((!NILP (icon_left) || !NILP (icon_top))
&& ! (icon_left_no_change && icon_top_no_change))
x_wm_set_icon_position (f, XINT (icon_left), XINT (icon_top));
x_wm_set_icon_position (f, XFIXNUM (icon_left), XFIXNUM (icon_top));
#endif /* HAVE_X_WINDOWS */
SAFE_FREE ();
@ -4089,31 +4089,31 @@ x_report_frame_params (struct frame *f, Lisp_Object *alistptr)
store_in_alist (alistptr, Qtop, list2 (Qplus, tem));
store_in_alist (alistptr, Qborder_width,
make_number (f->border_width));
make_fixnum (f->border_width));
store_in_alist (alistptr, Qinternal_border_width,
make_number (FRAME_INTERNAL_BORDER_WIDTH (f)));
make_fixnum (FRAME_INTERNAL_BORDER_WIDTH (f)));
store_in_alist (alistptr, Qright_divider_width,
make_number (FRAME_RIGHT_DIVIDER_WIDTH (f)));
make_fixnum (FRAME_RIGHT_DIVIDER_WIDTH (f)));
store_in_alist (alistptr, Qbottom_divider_width,
make_number (FRAME_BOTTOM_DIVIDER_WIDTH (f)));
make_fixnum (FRAME_BOTTOM_DIVIDER_WIDTH (f)));
store_in_alist (alistptr, Qleft_fringe,
make_number (FRAME_LEFT_FRINGE_WIDTH (f)));
make_fixnum (FRAME_LEFT_FRINGE_WIDTH (f)));
store_in_alist (alistptr, Qright_fringe,
make_number (FRAME_RIGHT_FRINGE_WIDTH (f)));
make_fixnum (FRAME_RIGHT_FRINGE_WIDTH (f)));
store_in_alist (alistptr, Qscroll_bar_width,
(! FRAME_HAS_VERTICAL_SCROLL_BARS (f)
? make_number (0)
? make_fixnum (0)
: FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0
? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
? make_fixnum (FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
/* nil means "use default width"
for non-toolkit scroll bar.
ruler-mode.el depends on this. */
: Qnil));
store_in_alist (alistptr, Qscroll_bar_height,
(! FRAME_HAS_HORIZONTAL_SCROLL_BARS (f)
? make_number (0)
? make_fixnum (0)
: FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) > 0
? make_number (FRAME_CONFIG_SCROLL_BAR_HEIGHT (f))
? make_fixnum (FRAME_CONFIG_SCROLL_BAR_HEIGHT (f))
/* nil means "use default height"
for non-toolkit scroll bar. */
: Qnil));
@ -4143,7 +4143,7 @@ x_report_frame_params (struct frame *f, Lisp_Object *alistptr)
if (FRAME_X_OUTPUT (f)->parent_desc == FRAME_DISPLAY_INFO (f)->root_window)
tem = Qnil;
else
tem = make_natnum ((uintptr_t) FRAME_X_OUTPUT (f)->parent_desc);
tem = make_fixed_natnum ((uintptr_t) FRAME_X_OUTPUT (f)->parent_desc);
store_in_alist (alistptr, Qexplicit_name, (f->explicit_name ? Qt : Qnil));
store_in_alist (alistptr, Qparent_id, tem);
store_in_alist (alistptr, Qtool_bar_position, FRAME_TOOL_BAR_POSITION (f));
@ -4180,8 +4180,8 @@ x_set_line_spacing (struct frame *f, Lisp_Object new_value, Lisp_Object old_valu
{
if (NILP (new_value))
f->extra_line_spacing = 0;
else if (RANGED_INTEGERP (0, new_value, INT_MAX))
f->extra_line_spacing = XFASTINT (new_value);
else if (RANGED_FIXNUMP (0, new_value, INT_MAX))
f->extra_line_spacing = XFIXNAT (new_value);
else if (FLOATP (new_value))
{
int new_spacing = XFLOAT_DATA (new_value) * FRAME_LINE_HEIGHT (f) + 0.5;
@ -4208,7 +4208,7 @@ x_set_screen_gamma (struct frame *f, Lisp_Object new_value, Lisp_Object old_valu
if (NILP (new_value))
f->gamma = 0;
else if (NUMBERP (new_value) && XFLOATINT (new_value) > 0)
else if (FIXED_OR_FLOATP (new_value) && XFLOATINT (new_value) > 0)
/* The value 0.4545 is the normal viewing gamma. */
f->gamma = 1.0 / (0.4545 * XFLOATINT (new_value));
else
@ -4219,10 +4219,10 @@ x_set_screen_gamma (struct frame *f, Lisp_Object new_value, Lisp_Object old_valu
if (CONSP (bgcolor) && (bgcolor = XCDR (bgcolor), STRINGP (bgcolor)))
{
Lisp_Object parm_index = Fget (Qbackground_color, Qx_frame_parameter);
if (NATNUMP (parm_index)
&& XFASTINT (parm_index) < ARRAYELTS (frame_parms)
&& FRAME_RIF (f)->frame_parm_handlers[XFASTINT (parm_index)])
(*FRAME_RIF (f)->frame_parm_handlers[XFASTINT (parm_index)])
if (FIXNATP (parm_index)
&& XFIXNAT (parm_index) < ARRAYELTS (frame_parms)
&& FRAME_RIF (f)->frame_parm_handlers[XFIXNAT (parm_index)])
(*FRAME_RIF (f)->frame_parm_handlers[XFIXNAT (parm_index)])
(f, bgcolor, Qnil);
}
@ -4407,8 +4407,8 @@ x_set_left_fringe (struct frame *f, Lisp_Object new_value, Lisp_Object old_value
int old_width = FRAME_LEFT_FRINGE_WIDTH (f);
int new_width;
new_width = (RANGED_INTEGERP (-INT_MAX, new_value, INT_MAX)
? eabs (XINT (new_value)) : 8);
new_width = (RANGED_FIXNUMP (-INT_MAX, new_value, INT_MAX)
? eabs (XFIXNUM (new_value)) : 8);
if (new_width != old_width)
{
@ -4431,8 +4431,8 @@ x_set_right_fringe (struct frame *f, Lisp_Object new_value, Lisp_Object old_valu
int old_width = FRAME_RIGHT_FRINGE_WIDTH (f);
int new_width;
new_width = (RANGED_INTEGERP (-INT_MAX, new_value, INT_MAX)
? eabs (XINT (new_value)) : 8);
new_width = (RANGED_FIXNUMP (-INT_MAX, new_value, INT_MAX)
? eabs (XFIXNUM (new_value)) : 8);
if (new_width != old_width)
{
@ -4453,13 +4453,13 @@ x_set_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
CHECK_TYPE_RANGED_INTEGER (int, arg);
if (XINT (arg) == f->border_width)
if (XFIXNUM (arg) == f->border_width)
return;
if (FRAME_X_WINDOW (f) != 0)
error ("Cannot change the border width of a frame");
f->border_width = XINT (arg);
f->border_width = XFIXNUM (arg);
}
void
@ -4467,7 +4467,7 @@ x_set_right_divider_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
int old = FRAME_RIGHT_DIVIDER_WIDTH (f);
CHECK_TYPE_RANGED_INTEGER (int, arg);
int new = max (0, XINT (arg));
int new = max (0, XFIXNUM (arg));
if (new != old)
{
f->right_divider_width = new;
@ -4482,7 +4482,7 @@ x_set_bottom_divider_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval
{
int old = FRAME_BOTTOM_DIVIDER_WIDTH (f);
CHECK_TYPE_RANGED_INTEGER (int, arg);
int new = max (0, XINT (arg));
int new = max (0, XFIXNUM (arg));
if (new != old)
{
f->bottom_divider_width = new;
@ -4591,11 +4591,11 @@ x_set_scroll_bar_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
SET_FRAME_GARBAGED (f);
}
else if (RANGED_INTEGERP (1, arg, INT_MAX)
&& XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
else if (RANGED_FIXNUMP (1, arg, INT_MAX)
&& XFIXNAT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
{
FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFASTINT (arg);
FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + unit - 1) / unit;
FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFIXNAT (arg);
FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFIXNAT (arg) + unit - 1) / unit;
if (FRAME_X_WINDOW (f))
adjust_frame_size (f, -1, -1, 3, 0, Qscroll_bar_width);
@ -4621,11 +4621,11 @@ x_set_scroll_bar_height (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
SET_FRAME_GARBAGED (f);
}
else if (RANGED_INTEGERP (1, arg, INT_MAX)
&& XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_HEIGHT (f))
else if (RANGED_FIXNUMP (1, arg, INT_MAX)
&& XFIXNAT (arg) != FRAME_CONFIG_SCROLL_BAR_HEIGHT (f))
{
FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = XFASTINT (arg);
FRAME_CONFIG_SCROLL_BAR_LINES (f) = (XFASTINT (arg) + unit - 1) / unit;
FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = XFIXNAT (arg);
FRAME_CONFIG_SCROLL_BAR_LINES (f) = (XFIXNAT (arg) + unit - 1) / unit;
if (FRAME_X_WINDOW (f))
adjust_frame_size (f, -1, -1, 3, 0, Qscroll_bar_height);
@ -4664,11 +4664,11 @@ x_set_alpha (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
if (! (0 <= alpha && alpha <= 1.0))
args_out_of_range (make_float (0.0), make_float (1.0));
}
else if (INTEGERP (item))
else if (FIXNUMP (item))
{
EMACS_INT ialpha = XINT (item);
EMACS_INT ialpha = XFIXNUM (item);
if (! (0 <= ialpha && ialpha <= 100))
args_out_of_range (make_number (0), make_number (100));
args_out_of_range (make_fixnum (0), make_fixnum (100));
alpha = ialpha / 100.0;
}
else
@ -4980,13 +4980,13 @@ x_get_arg (Display_Info *dpyinfo, Lisp_Object alist, Lisp_Object param,
switch (type)
{
case RES_TYPE_NUMBER:
return make_number (atoi (SSDATA (tem)));
return make_fixnum (atoi (SSDATA (tem)));
case RES_TYPE_BOOLEAN_NUMBER:
if (!strcmp (SSDATA (tem), "on")
|| !strcmp (SSDATA (tem), "true"))
return make_number (1);
return make_number (atoi (SSDATA (tem)));
return make_fixnum (1);
return make_fixnum (atoi (SSDATA (tem)));
break;
case RES_TYPE_FLOAT:
@ -5215,11 +5215,11 @@ On Nextstep, this just calls `ns-parse-geometry'. */)
Lisp_Object element;
if (x >= 0 && (geometry & XNegative))
element = list3 (Qleft, Qminus, make_number (-x));
element = list3 (Qleft, Qminus, make_fixnum (-x));
else if (x < 0 && ! (geometry & XNegative))
element = list3 (Qleft, Qplus, make_number (x));
element = list3 (Qleft, Qplus, make_fixnum (x));
else
element = Fcons (Qleft, make_number (x));
element = Fcons (Qleft, make_fixnum (x));
result = Fcons (element, result);
}
@ -5228,18 +5228,18 @@ On Nextstep, this just calls `ns-parse-geometry'. */)
Lisp_Object element;
if (y >= 0 && (geometry & YNegative))
element = list3 (Qtop, Qminus, make_number (-y));
element = list3 (Qtop, Qminus, make_fixnum (-y));
else if (y < 0 && ! (geometry & YNegative))
element = list3 (Qtop, Qplus, make_number (y));
element = list3 (Qtop, Qplus, make_fixnum (y));
else
element = Fcons (Qtop, make_number (y));
element = Fcons (Qtop, make_fixnum (y));
result = Fcons (element, result);
}
if (geometry & WidthValue)
result = Fcons (Fcons (Qwidth, make_number (width)), result);
result = Fcons (Fcons (Qwidth, make_fixnum (width)), result);
if (geometry & HeightValue)
result = Fcons (Fcons (Qheight, make_number (height)), result);
result = Fcons (Fcons (Qheight, make_fixnum (height)), result);
return result;
}
@ -5295,11 +5295,11 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF);
if (RANGED_INTEGERP (1, Vtool_bar_button_margin, INT_MAX))
margin = XFASTINT (Vtool_bar_button_margin);
if (RANGED_FIXNUMP (1, Vtool_bar_button_margin, INT_MAX))
margin = XFIXNAT (Vtool_bar_button_margin);
else if (CONSP (Vtool_bar_button_margin)
&& RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
margin = XFASTINT (XCDR (Vtool_bar_button_margin));
&& RANGED_FIXNUMP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
margin = XFIXNAT (XCDR (Vtool_bar_button_margin));
else
margin = 0;
@ -5320,13 +5320,13 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
{
if (CONSP (width) && EQ (XCAR (width), Qtext_pixels))
{
CHECK_NUMBER (XCDR (width));
if ((XINT (XCDR (width)) < 0 || XINT (XCDR (width)) > INT_MAX))
CHECK_FIXNUM (XCDR (width));
if ((XFIXNUM (XCDR (width)) < 0 || XFIXNUM (XCDR (width)) > INT_MAX))
xsignal1 (Qargs_out_of_range, XCDR (width));
SET_FRAME_WIDTH (f, XINT (XCDR (width)));
SET_FRAME_WIDTH (f, XFIXNUM (XCDR (width)));
f->inhibit_horizontal_resize = true;
*x_width = XINT (XCDR (width));
*x_width = XFIXNUM (XCDR (width));
}
else if (FLOATP (width))
{
@ -5345,11 +5345,11 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
}
else
{
CHECK_NUMBER (width);
if ((XINT (width) < 0 || XINT (width) > INT_MAX))
CHECK_FIXNUM (width);
if ((XFIXNUM (width) < 0 || XFIXNUM (width) > INT_MAX))
xsignal1 (Qargs_out_of_range, width);
SET_FRAME_WIDTH (f, XINT (width) * FRAME_COLUMN_WIDTH (f));
SET_FRAME_WIDTH (f, XFIXNUM (width) * FRAME_COLUMN_WIDTH (f));
}
}
@ -5357,13 +5357,13 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
{
if (CONSP (height) && EQ (XCAR (height), Qtext_pixels))
{
CHECK_NUMBER (XCDR (height));
if ((XINT (XCDR (height)) < 0 || XINT (XCDR (height)) > INT_MAX))
CHECK_FIXNUM (XCDR (height));
if ((XFIXNUM (XCDR (height)) < 0 || XFIXNUM (XCDR (height)) > INT_MAX))
xsignal1 (Qargs_out_of_range, XCDR (height));
SET_FRAME_HEIGHT (f, XINT (XCDR (height)));
SET_FRAME_HEIGHT (f, XFIXNUM (XCDR (height)));
f->inhibit_vertical_resize = true;
*x_height = XINT (XCDR (height));
*x_height = XFIXNUM (XCDR (height));
}
else if (FLOATP (height))
{
@ -5382,11 +5382,11 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
}
else
{
CHECK_NUMBER (height);
if ((XINT (height) < 0) || (XINT (height) > INT_MAX))
CHECK_FIXNUM (height);
if ((XFIXNUM (height) < 0) || (XFIXNUM (height) > INT_MAX))
xsignal1 (Qargs_out_of_range, height);
SET_FRAME_HEIGHT (f, XINT (height) * FRAME_LINE_HEIGHT (f));
SET_FRAME_HEIGHT (f, XFIXNUM (height) * FRAME_LINE_HEIGHT (f));
}
}
@ -5409,16 +5409,16 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
}
else if (CONSP (top) && EQ (XCAR (top), Qminus)
&& CONSP (XCDR (top))
&& RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
&& RANGED_FIXNUMP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
{
f->top_pos = - XINT (XCAR (XCDR (top)));
f->top_pos = - XFIXNUM (XCAR (XCDR (top)));
window_prompting |= YNegative;
}
else if (CONSP (top) && EQ (XCAR (top), Qplus)
&& CONSP (XCDR (top))
&& TYPE_RANGED_INTEGERP (int, XCAR (XCDR (top))))
&& TYPE_RANGED_FIXNUMP (int, XCAR (XCDR (top))))
{
f->top_pos = XINT (XCAR (XCDR (top)));
f->top_pos = XFIXNUM (XCAR (XCDR (top)));
}
else if (FLOATP (top))
f->top_pos = frame_float (f, top, FRAME_FLOAT_TOP, &parent_done,
@ -5428,7 +5428,7 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
else
{
CHECK_TYPE_RANGED_INTEGER (int, top);
f->top_pos = XINT (top);
f->top_pos = XFIXNUM (top);
if (f->top_pos < 0)
window_prompting |= YNegative;
}
@ -5440,16 +5440,16 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
}
else if (CONSP (left) && EQ (XCAR (left), Qminus)
&& CONSP (XCDR (left))
&& RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
&& RANGED_FIXNUMP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
{
f->left_pos = - XINT (XCAR (XCDR (left)));
f->left_pos = - XFIXNUM (XCAR (XCDR (left)));
window_prompting |= XNegative;
}
else if (CONSP (left) && EQ (XCAR (left), Qplus)
&& CONSP (XCDR (left))
&& TYPE_RANGED_INTEGERP (int, XCAR (XCDR (left))))
&& TYPE_RANGED_FIXNUMP (int, XCAR (XCDR (left))))
{
f->left_pos = XINT (XCAR (XCDR (left)));
f->left_pos = XFIXNUM (XCAR (XCDR (left)));
}
else if (FLOATP (left))
f->left_pos = frame_float (f, left, FRAME_FLOAT_LEFT, &parent_done,
@ -5459,7 +5459,7 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
else
{
CHECK_TYPE_RANGED_INTEGER (int, left);
f->left_pos = XINT (left);
f->left_pos = XFIXNUM (left);
if (f->left_pos < 0)
window_prompting |= XNegative;
}
@ -5784,7 +5784,7 @@ syms_of_frame (void)
Lisp_Object v = (frame_parms[i].sym < 0
? intern_c_string (frame_parms[i].name)
: builtin_lisp_symbol (frame_parms[i].sym));
Fput (v, Qx_frame_parameter, make_number (i));
Fput (v, Qx_frame_parameter, make_fixnum (i));
}
}
@ -5817,7 +5817,7 @@ is a reasonable practice. See also the variable `x-resource-name'. */);
doc: /* The lower limit of the frame opacity (alpha transparency).
The value should range from 0 (invisible) to 100 (completely opaque).
You can also use a floating number between 0.0 and 1.0. */);
Vframe_alpha_lower_limit = make_number (20);
Vframe_alpha_lower_limit = make_fixnum (20);
#endif
DEFVAR_LISP ("default-frame-alist", Vdefault_frame_alist,

14
src/frame.h
View file

@ -699,7 +699,7 @@ fset_desired_tool_bar_string (struct frame *f, Lisp_Object val)
INLINE double
NUMVAL (Lisp_Object x)
{
return NUMBERP (x) ? XFLOATINT (x) : -1;
return FIXED_OR_FLOATP (x) ? XFLOATINT (x) : -1;
}
INLINE double
@ -1360,16 +1360,16 @@ FRAME_BOTTOM_DIVIDER_WIDTH (struct frame *f)
canonical char width is to be used. X must be a Lisp integer or
float. Value is a C integer. */
#define FRAME_PIXEL_X_FROM_CANON_X(F, X) \
(INTEGERP (X) \
? XINT (X) * FRAME_COLUMN_WIDTH (F) \
(FIXNUMP (X) \
? XFIXNUM (X) * FRAME_COLUMN_WIDTH (F) \
: (int) (XFLOAT_DATA (X) * FRAME_COLUMN_WIDTH (F)))
/* Convert canonical value Y to pixels. F is the frame whose
canonical character height is to be used. X must be a Lisp integer
or float. Value is a C integer. */
#define FRAME_PIXEL_Y_FROM_CANON_Y(F, Y) \
(INTEGERP (Y) \
? XINT (Y) * FRAME_LINE_HEIGHT (F) \
(FIXNUMP (Y) \
? XFIXNUM (Y) * FRAME_LINE_HEIGHT (F) \
: (int) (XFLOAT_DATA (Y) * FRAME_LINE_HEIGHT (F)))
/* Convert pixel-value X to canonical units. F is the frame whose
@ -1379,7 +1379,7 @@ FRAME_BOTTOM_DIVIDER_WIDTH (struct frame *f)
#define FRAME_CANON_X_FROM_PIXEL_X(F, X) \
((X) % FRAME_COLUMN_WIDTH (F) != 0 \
? make_float ((double) (X) / FRAME_COLUMN_WIDTH (F)) \
: make_number ((X) / FRAME_COLUMN_WIDTH (F)))
: make_fixnum ((X) / FRAME_COLUMN_WIDTH (F)))
/* Convert pixel-value Y to canonical units. F is the frame whose
canonical character height is to be used. Y is a C integer.
@ -1388,7 +1388,7 @@ FRAME_BOTTOM_DIVIDER_WIDTH (struct frame *f)
#define FRAME_CANON_Y_FROM_PIXEL_Y(F, Y) \
((Y) % FRAME_LINE_HEIGHT (F) \
? make_float ((double) (Y) / FRAME_LINE_HEIGHT (F)) \
: make_number ((Y) / FRAME_LINE_HEIGHT (F)))
: make_fixnum ((Y) / FRAME_LINE_HEIGHT (F)))

40
src/fringe.c
View file

@ -488,10 +488,10 @@ lookup_fringe_bitmap (Lisp_Object bitmap)
EMACS_INT bn;
bitmap = Fget (bitmap, Qfringe);
if (!INTEGERP (bitmap))
if (!FIXNUMP (bitmap))
return 0;
bn = XINT (bitmap);
bn = XFIXNUM (bitmap);
if (bn > NO_FRINGE_BITMAP
&& bn < max_used_fringe_bitmap
&& (bn < MAX_STANDARD_FRINGE_BITMAPS
@ -519,7 +519,7 @@ get_fringe_bitmap_name (int bn)
return Qnil;
bitmaps = Vfringe_bitmaps;
num = make_number (bn);
num = make_fixnum (bn);
while (CONSP (bitmaps))
{
@ -743,12 +743,12 @@ get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, in
return NO_FRINGE_BITMAP;
if (CONSP (bm1))
{
ln1 = XINT (Flength (bm1));
ln1 = XFIXNUM (Flength (bm1));
if (partial_p)
{
if (ln1 > ix2)
{
bm = Fnth (make_number (ix2), bm1);
bm = Fnth (make_fixnum (ix2), bm1);
if (!EQ (bm, Qt))
goto found;
}
@ -757,7 +757,7 @@ get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, in
{
if (ln1 > ix1)
{
bm = Fnth (make_number (ix1), bm1);
bm = Fnth (make_fixnum (ix1), bm1);
if (!EQ (bm, Qt))
goto found;
}
@ -778,12 +778,12 @@ get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, in
{
if (CONSP (bm2))
{
ln2 = XINT (Flength (bm2));
ln2 = XFIXNUM (Flength (bm2));
if (partial_p)
{
if (ln2 > ix2)
{
bm = Fnth (make_number (ix2), bm2);
bm = Fnth (make_fixnum (ix2), bm2);
if (!EQ (bm, Qt))
goto found;
}
@ -795,14 +795,14 @@ get_logical_fringe_bitmap (struct window *w, Lisp_Object bitmap, int right_p, in
if (ln1 > ix1)
{
bm = Fnth (make_number (ix1), bm1);
bm = Fnth (make_fixnum (ix1), bm1);
if (!EQ (bm, Qt))
goto found;
}
if (ln2 > ix1)
{
bm = Fnth (make_number (ix1), bm2);
bm = Fnth (make_fixnum (ix1), bm2);
if (!EQ (bm, Qt))
goto found;
return NO_FRINGE_BITMAP;
@ -1509,8 +1509,8 @@ If BITMAP already exists, the existing definition is replaced. */)
fb.height = h;
else
{
CHECK_NUMBER (height);
fb.height = max (0, min (XINT (height), 255));
CHECK_FIXNUM (height);
fb.height = max (0, min (XFIXNUM (height), 255));
if (fb.height > h)
{
fill1 = (fb.height - h) / 2;
@ -1522,8 +1522,8 @@ If BITMAP already exists, the existing definition is replaced. */)
fb.width = 8;
else
{
CHECK_NUMBER (width);
fb.width = max (0, min (XINT (width), 255));
CHECK_FIXNUM (width);
fb.width = max (0, min (XFIXNUM (width), 255));
}
fb.period = 0;
@ -1586,7 +1586,7 @@ If BITMAP already exists, the existing definition is replaced. */)
}
Vfringe_bitmaps = Fcons (bitmap, Vfringe_bitmaps);
Fput (bitmap, Qfringe, make_number (n));
Fput (bitmap, Qfringe, make_fixnum (n));
}
fb.dynamic = true;
@ -1604,8 +1604,8 @@ If BITMAP already exists, the existing definition is replaced. */)
b[j++] = 0;
for (i = 0; i < h && j < fb.height; i++)
{
Lisp_Object elt = Faref (bits, make_number (i));
b[j++] = NUMBERP (elt) ? XINT (elt) : 0;
Lisp_Object elt = Faref (bits, make_fixnum (i));
b[j++] = FIXED_OR_FLOATP (elt) ? XFIXNUM (elt) : 0;
}
for (i = 0; i < fill2 && j < fb.height; i++)
b[j++] = 0;
@ -1661,10 +1661,10 @@ Return nil if POS is not visible in WINDOW. */)
if (!NILP (pos))
{
CHECK_NUMBER_COERCE_MARKER (pos);
if (! (BEGV <= XINT (pos) && XINT (pos) <= ZV))
CHECK_FIXNUM_COERCE_MARKER (pos);
if (! (BEGV <= XFIXNUM (pos) && XFIXNUM (pos) <= ZV))
args_out_of_range (window, pos);
textpos = XINT (pos);
textpos = XFIXNUM (pos);
}
else if (w == XWINDOW (selected_window))
textpos = PT;

2
src/ftcrfont.c
View file

@ -137,7 +137,7 @@ ftcrfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
FT_UInt size;
block_input ();
size = XINT (AREF (entity, FONT_SIZE_INDEX));
size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
if (size == 0)
size = pixel_size;
font_object = font_build_object (VECSIZE (struct ftcrfont_info),

80
src/ftfont.c
View file

@ -196,7 +196,7 @@ ftfont_pattern_entity (FcPattern *p, Lisp_Object extra)
return Qnil;
file = (char *) str;
key = Fcons (build_unibyte_string (file), make_number (idx));
key = Fcons (build_unibyte_string (file), make_fixnum (idx));
cache = ftfont_lookup_cache (key, FTFONT_CACHE_FOR_ENTITY);
entity = XCAR (cache);
if (! NILP (entity))
@ -232,35 +232,35 @@ ftfont_pattern_entity (FcPattern *p, Lisp_Object extra)
{
if (numeric >= FC_WEIGHT_REGULAR && numeric < FC_WEIGHT_MEDIUM)
numeric = FC_WEIGHT_MEDIUM;
FONT_SET_STYLE (entity, FONT_WEIGHT_INDEX, make_number (numeric));
FONT_SET_STYLE (entity, FONT_WEIGHT_INDEX, make_fixnum (numeric));
}
if (FcPatternGetInteger (p, FC_SLANT, 0, &numeric) == FcResultMatch)
{
numeric += 100;
FONT_SET_STYLE (entity, FONT_SLANT_INDEX, make_number (numeric));
FONT_SET_STYLE (entity, FONT_SLANT_INDEX, make_fixnum (numeric));
}
if (FcPatternGetInteger (p, FC_WIDTH, 0, &numeric) == FcResultMatch)
{
FONT_SET_STYLE (entity, FONT_WIDTH_INDEX, make_number (numeric));
FONT_SET_STYLE (entity, FONT_WIDTH_INDEX, make_fixnum (numeric));
}
if (FcPatternGetDouble (p, FC_PIXEL_SIZE, 0, &dbl) == FcResultMatch)
{
ASET (entity, FONT_SIZE_INDEX, make_number (dbl));
ASET (entity, FONT_SIZE_INDEX, make_fixnum (dbl));
}
else
ASET (entity, FONT_SIZE_INDEX, make_number (0));
ASET (entity, FONT_SIZE_INDEX, make_fixnum (0));
if (FcPatternGetInteger (p, FC_SPACING, 0, &numeric) == FcResultMatch)
ASET (entity, FONT_SPACING_INDEX, make_number (numeric));
ASET (entity, FONT_SPACING_INDEX, make_fixnum (numeric));
if (FcPatternGetDouble (p, FC_DPI, 0, &dbl) == FcResultMatch)
{
int dpi = dbl;
ASET (entity, FONT_DPI_INDEX, make_number (dpi));
ASET (entity, FONT_DPI_INDEX, make_fixnum (dpi));
}
if (FcPatternGetBool (p, FC_SCALABLE, 0, &b) == FcResultMatch
&& b == FcTrue)
{
ASET (entity, FONT_SIZE_INDEX, make_number (0));
ASET (entity, FONT_AVGWIDTH_INDEX, make_number (0));
ASET (entity, FONT_SIZE_INDEX, make_fixnum (0));
ASET (entity, FONT_AVGWIDTH_INDEX, make_fixnum (0));
}
else
{
@ -276,7 +276,7 @@ ftfont_pattern_entity (FcPattern *p, Lisp_Object extra)
if (FT_Get_BDF_Property (ft_face, "AVERAGE_WIDTH", &rec) == 0
&& rec.type == BDF_PROPERTY_TYPE_INTEGER)
ASET (entity, FONT_AVGWIDTH_INDEX, make_number (rec.u.integer));
ASET (entity, FONT_AVGWIDTH_INDEX, make_fixnum (rec.u.integer));
FT_Done_Face (ft_face);
}
}
@ -390,7 +390,7 @@ ftfont_lookup_cache (Lisp_Object key, enum ftfont_cache_for cache_for)
? ! cache_data->ft_face : ! cache_data->fc_charset)
{
char *filename = SSDATA (XCAR (key));
int idx = XINT (XCDR (key));
int idx = XFIXNUM (XCDR (key));
if (cache_for == FTFONT_CACHE_FOR_FACE)
{
@ -600,9 +600,9 @@ ftfont_get_open_type_spec (Lisp_Object otf_spec)
continue;
len = Flength (val);
spec->features[i] =
(min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < XINT (len)
(min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < XFIXNUM (len)
? 0
: malloc (XINT (len) * sizeof *spec->features[i]));
: malloc (XFIXNUM (len) * sizeof *spec->features[i]));
if (! spec->features[i])
{
if (i > 0 && spec->features[0])
@ -646,10 +646,10 @@ ftfont_spec_pattern (Lisp_Object spec, char *otlayout, struct OpenTypeSpec **ots
/* Fontconfig doesn't support reverse-italic/oblique. */
return NULL;
if (INTEGERP (AREF (spec, FONT_DPI_INDEX)))
dpi = XINT (AREF (spec, FONT_DPI_INDEX));
if (INTEGERP (AREF (spec, FONT_AVGWIDTH_INDEX))
&& XINT (AREF (spec, FONT_AVGWIDTH_INDEX)) == 0)
if (FIXNUMP (AREF (spec, FONT_DPI_INDEX)))
dpi = XFIXNUM (AREF (spec, FONT_DPI_INDEX));
if (FIXNUMP (AREF (spec, FONT_AVGWIDTH_INDEX))
&& XFIXNUM (AREF (spec, FONT_AVGWIDTH_INDEX)) == 0)
scalable = 1;
registry = AREF (spec, FONT_REGISTRY_INDEX);
@ -686,8 +686,8 @@ ftfont_spec_pattern (Lisp_Object spec, char *otlayout, struct OpenTypeSpec **ots
key = XCAR (XCAR (extra)), val = XCDR (XCAR (extra));
if (EQ (key, QCdpi))
{
if (INTEGERP (val))
dpi = XINT (val);
if (FIXNUMP (val))
dpi = XFIXNUM (val);
}
else if (EQ (key, QClang))
{
@ -735,7 +735,7 @@ ftfont_spec_pattern (Lisp_Object spec, char *otlayout, struct OpenTypeSpec **ots
goto err;
for (chars = XCDR (chars); CONSP (chars); chars = XCDR (chars))
if (CHARACTERP (XCAR (chars))
&& ! FcCharSetAddChar (charset, XFASTINT (XCAR (chars))))
&& ! FcCharSetAddChar (charset, XFIXNAT (XCAR (chars))))
goto err;
}
}
@ -832,8 +832,8 @@ ftfont_list (struct frame *f, Lisp_Object spec)
}
val = Qnil;
}
if (INTEGERP (AREF (spec, FONT_SPACING_INDEX)))
spacing = XINT (AREF (spec, FONT_SPACING_INDEX));
if (FIXNUMP (AREF (spec, FONT_SPACING_INDEX)))
spacing = XFIXNUM (AREF (spec, FONT_SPACING_INDEX));
family = AREF (spec, FONT_FAMILY_INDEX);
if (! NILP (family))
{
@ -955,8 +955,8 @@ ftfont_list (struct frame *f, Lisp_Object spec)
!= FcResultMatch)
continue;
for (j = 0; j < ASIZE (chars); j++)
if (TYPE_RANGED_INTEGERP (FcChar32, AREF (chars, j))
&& FcCharSetHasChar (charset, XFASTINT (AREF (chars, j))))
if (TYPE_RANGED_FIXNUMP (FcChar32, AREF (chars, j))
&& FcCharSetHasChar (charset, XFIXNAT (AREF (chars, j))))
break;
if (j == ASIZE (chars))
continue;
@ -1016,12 +1016,12 @@ ftfont_match (struct frame *f, Lisp_Object spec)
if (! pattern)
return Qnil;
if (INTEGERP (AREF (spec, FONT_SIZE_INDEX)))
if (FIXNUMP (AREF (spec, FONT_SIZE_INDEX)))
{
FcValue value;
value.type = FcTypeDouble;
value.u.d = XINT (AREF (spec, FONT_SIZE_INDEX));
value.u.d = XFIXNUM (AREF (spec, FONT_SIZE_INDEX));
FcPatternAdd (pattern, FC_PIXEL_SIZE, value, FcFalse);
}
if (FcConfigSubstitute (NULL, pattern, FcMatchPattern) == FcTrue)
@ -1130,7 +1130,7 @@ ftfont_open2 (struct frame *f,
return Qnil;
}
}
size = XINT (AREF (entity, FONT_SIZE_INDEX));
size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
if (size == 0)
size = pixel_size;
if (FT_Set_Pixel_Sizes (ft_face, size, size) != 0)
@ -1148,7 +1148,7 @@ ftfont_open2 (struct frame *f,
font = XFONT_OBJECT (font_object);
ftfont_info = (struct ftfont_info *) font;
ftfont_info->ft_size = ft_face->size;
ftfont_info->index = XINT (idx);
ftfont_info->index = XFIXNUM (idx);
#ifdef HAVE_LIBOTF
ftfont_info->maybe_otf = (ft_face->face_flags & FT_FACE_FLAG_SFNT) != 0;
ftfont_info->otf = NULL;
@ -1160,8 +1160,8 @@ ftfont_open2 (struct frame *f,
font->encoding_charset = font->repertory_charset = -1;
upEM = ft_face->units_per_EM;
scalable = (INTEGERP (AREF (entity, FONT_AVGWIDTH_INDEX))
&& XINT (AREF (entity, FONT_AVGWIDTH_INDEX)) == 0);
scalable = (FIXNUMP (AREF (entity, FONT_AVGWIDTH_INDEX))
&& XFIXNUM (AREF (entity, FONT_AVGWIDTH_INDEX)) == 0);
if (scalable)
{
font->ascent = ft_face->ascender * size / upEM + 0.5;
@ -1174,8 +1174,8 @@ ftfont_open2 (struct frame *f,
font->descent = - ft_face->size->metrics.descender >> 6;
font->height = ft_face->size->metrics.height >> 6;
}
if (INTEGERP (AREF (entity, FONT_SPACING_INDEX)))
spacing = XINT (AREF (entity, FONT_SPACING_INDEX));
if (FIXNUMP (AREF (entity, FONT_SPACING_INDEX)))
spacing = XFIXNUM (AREF (entity, FONT_SPACING_INDEX));
else
spacing = FC_PROPORTIONAL;
if (spacing != FC_PROPORTIONAL
@ -1233,7 +1233,7 @@ ftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
{
Lisp_Object font_object;
FT_UInt size;
size = XINT (AREF (entity, FONT_SIZE_INDEX));
size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
if (size == 0)
size = pixel_size;
font_object = font_build_object (VECSIZE (struct ftfont_info),
@ -1250,7 +1250,7 @@ ftfont_close (struct font *font)
struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
Lisp_Object val, cache;
val = Fcons (font->props[FONT_FILE_INDEX], make_number (ftfont_info->index));
val = Fcons (font->props[FONT_FILE_INDEX], make_fixnum (ftfont_info->index));
cache = ftfont_lookup_cache (val, FTFONT_CACHE_FOR_FACE);
eassert (CONSP (cache));
val = XCDR (cache);
@ -2534,7 +2534,7 @@ ftfont_shape_by_flt (Lisp_Object lgstring, struct font *font,
flt = mflt_find (LGLYPH_CHAR (LGSTRING_GLYPH (lgstring, 0)),
&flt_font_ft.flt_font);
if (! flt)
return make_number (0);
return make_fixnum (0);
}
MFLTGlyphFT *glyphs = (MFLTGlyphFT *) gstring.glyphs;
@ -2603,13 +2603,13 @@ ftfont_shape_by_flt (Lisp_Object lgstring, struct font *font,
{
Lisp_Object vec = make_uninit_vector (3);
ASET (vec, 0, make_number (g->g.xoff >> 6));
ASET (vec, 1, make_number (g->g.yoff >> 6));
ASET (vec, 2, make_number (g->g.xadv >> 6));
ASET (vec, 0, make_fixnum (g->g.xoff >> 6));
ASET (vec, 1, make_fixnum (g->g.yoff >> 6));
ASET (vec, 2, make_fixnum (g->g.xadv >> 6));
LGLYPH_SET_ADJUSTMENT (lglyph, vec);
}
}
return make_number (i);
return make_fixnum (i);
}
Lisp_Object

12
src/gfilenotify.c
View file

@ -77,7 +77,7 @@ dir_monitor_callback (GFileMonitor *monitor,
/* Determine callback function. */
monitor_object = make_pointer_integer (monitor);
eassert (INTEGERP (monitor_object));
eassert (FIXNUMP (monitor_object));
watch_object = assq_no_quit (monitor_object, watch_list);
if (CONSP (watch_object))
@ -206,7 +206,7 @@ will be reported only in case of the `moved' event. */)
Lisp_Object watch_descriptor = make_pointer_integer (monitor);
/* Check the dicey assumption that make_pointer_integer is safe. */
if (! INTEGERP (watch_descriptor))
if (! FIXNUMP (watch_descriptor))
{
g_object_unref (monitor);
xsignal2 (Qfile_notify_error, build_string ("Unsupported file watcher"),
@ -239,8 +239,8 @@ WATCH-DESCRIPTOR should be an object returned by `gfile-add-watch'. */)
xsignal2 (Qfile_notify_error, build_string ("Not a watch descriptor"),
watch_descriptor);
eassert (INTEGERP (watch_descriptor));
GFileMonitor *monitor = XINTPTR (watch_descriptor);
eassert (FIXNUMP (watch_descriptor));
GFileMonitor *monitor = XFIXNUMPTR (watch_descriptor);
if (!g_file_monitor_is_cancelled (monitor) &&
!g_file_monitor_cancel (monitor))
xsignal2 (Qfile_notify_error, build_string ("Could not rm watch"),
@ -271,7 +271,7 @@ invalid. */)
return Qnil;
else
{
GFileMonitor *monitor = XINTPTR (watch_descriptor);
GFileMonitor *monitor = XFIXNUMPTR (watch_descriptor);
return g_file_monitor_is_cancelled (monitor) ? Qnil : Qt;
}
}
@ -290,7 +290,7 @@ If WATCH-DESCRIPTOR is not valid, nil is returned. */)
return Qnil;
else
{
GFileMonitor *monitor = XINTPTR (watch_descriptor);
GFileMonitor *monitor = XFIXNUMPTR (watch_descriptor);
return intern (G_OBJECT_TYPE_NAME (monitor));
}
}

92
src/gnutls.c
View file

@ -816,7 +816,7 @@ gnutls_make_error (int err)
}
check_memory_full (err);
return make_number (err);
return make_fixnum (err);
}
static void
@ -893,7 +893,7 @@ See also `gnutls-boot'. */)
{
CHECK_PROCESS (proc);
return make_number (GNUTLS_INITSTAGE (proc));
return make_fixnum (GNUTLS_INITSTAGE (proc));
}
DEFUN ("gnutls-errorp", Fgnutls_errorp, Sgnutls_errorp, 1, 1, 0,
@ -923,7 +923,7 @@ Usage: (gnutls-error-fatalp ERROR) */)
if (SYMBOLP (err))
{
code = Fget (err, Qgnutls_code);
if (NUMBERP (code))
if (FIXED_OR_FLOATP (code))
{
err = code;
}
@ -933,10 +933,10 @@ Usage: (gnutls-error-fatalp ERROR) */)
}
}
if (! TYPE_RANGED_INTEGERP (int, err))
if (! TYPE_RANGED_FIXNUMP (int, err))
error ("Not an error symbol or code");
if (0 == gnutls_error_is_fatal (XINT (err)))
if (0 == gnutls_error_is_fatal (XFIXNUM (err)))
return Qnil;
return Qt;
@ -955,7 +955,7 @@ usage: (gnutls-error-string ERROR) */)
if (SYMBOLP (err))
{
code = Fget (err, Qgnutls_code);
if (NUMBERP (code))
if (FIXED_OR_FLOATP (code))
{
err = code;
}
@ -965,10 +965,10 @@ usage: (gnutls-error-string ERROR) */)
}
}
if (! TYPE_RANGED_INTEGERP (int, err))
if (! TYPE_RANGED_FIXNUMP (int, err))
return build_string ("Not an error symbol or code");
return build_string (emacs_gnutls_strerror (XINT (err)));
return build_string (emacs_gnutls_strerror (XFIXNUM (err)));
}
DEFUN ("gnutls-deinit", Fgnutls_deinit, Sgnutls_deinit, 1, 1, 0,
@ -1012,7 +1012,7 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
check_memory_full (version);
if (version >= GNUTLS_E_SUCCESS)
res = nconc2 (res, list2 (intern (":version"),
make_number (version)));
make_fixnum (version)));
}
/* Serial. */
@ -1296,7 +1296,7 @@ returned as the :certificate entry. */)
check_memory_full (bits);
if (bits > 0)
result = nconc2 (result, list2 (intern (":diffie-hellman-prime-bits"),
make_number (bits)));
make_fixnum (bits)));
}
/* Key exchange. */
@ -1650,14 +1650,14 @@ one trustfile (usually a CA bundle). */)
state = XPROCESS (proc)->gnutls_state;
if (TYPE_RANGED_INTEGERP (int, loglevel))
if (TYPE_RANGED_FIXNUMP (int, loglevel))
{
gnutls_global_set_log_function (gnutls_log_function);
# ifdef HAVE_GNUTLS3
gnutls_global_set_audit_log_function (gnutls_audit_log_function);
# endif
gnutls_global_set_log_level (XINT (loglevel));
max_log_level = XINT (loglevel);
gnutls_global_set_log_level (XFIXNUM (loglevel));
max_log_level = XFIXNUM (loglevel);
XPROCESS (proc)->gnutls_log_level = max_log_level;
}
@ -1690,9 +1690,9 @@ one trustfile (usually a CA bundle). */)
XPROCESS (proc)->gnutls_x509_cred = x509_cred;
verify_flags = Fplist_get (proplist, QCverify_flags);
if (TYPE_RANGED_INTEGERP (unsigned int, verify_flags))
if (TYPE_RANGED_FIXNUMP (unsigned int, verify_flags))
{
gnutls_verify_flags = XFASTINT (verify_flags);
gnutls_verify_flags = XFIXNAT (verify_flags);
GNUTLS_LOG (2, max_log_level, "setting verification flags");
}
else if (NILP (verify_flags))
@ -1851,8 +1851,8 @@ one trustfile (usually a CA bundle). */)
GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_PRIORITY;
if (INTEGERP (prime_bits))
gnutls_dh_set_prime_bits (state, XUINT (prime_bits));
if (FIXNUMP (prime_bits))
gnutls_dh_set_prime_bits (state, XUFIXNUM (prime_bits));
ret = EQ (type, Qgnutls_x509pki)
? gnutls_credentials_set (state, GNUTLS_CRD_CERTIFICATE, x509_cred)
@ -1937,19 +1937,19 @@ The alist key is the cipher name. */)
Lisp_Object cp
= listn (CONSTYPE_HEAP, 15, cipher_symbol,
QCcipher_id, make_number (gca),
QCcipher_id, make_fixnum (gca),
QCtype, Qgnutls_type_cipher,
QCcipher_aead_capable, cipher_tag_size == 0 ? Qnil : Qt,
QCcipher_tagsize, make_number (cipher_tag_size),
QCcipher_tagsize, make_fixnum (cipher_tag_size),
QCcipher_blocksize,
make_number (gnutls_cipher_get_block_size (gca)),
make_fixnum (gnutls_cipher_get_block_size (gca)),
QCcipher_keysize,
make_number (gnutls_cipher_get_key_size (gca)),
make_fixnum (gnutls_cipher_get_key_size (gca)),
QCcipher_ivsize,
make_number (gnutls_cipher_get_iv_size (gca)));
make_fixnum (gnutls_cipher_get_iv_size (gca)));
ciphers = Fcons (cp, ciphers);
}
@ -2079,16 +2079,16 @@ gnutls_symmetric (bool encrypting, Lisp_Object cipher,
cipher);
info = XCDR (info);
}
else if (TYPE_RANGED_INTEGERP (gnutls_cipher_algorithm_t, cipher))
gca = XINT (cipher);
else if (TYPE_RANGED_FIXNUMP (gnutls_cipher_algorithm_t, cipher))
gca = XFIXNUM (cipher);
else
info = cipher;
if (!NILP (info) && CONSP (info))
{
Lisp_Object v = Fplist_get (info, QCcipher_id);
if (TYPE_RANGED_INTEGERP (gnutls_cipher_algorithm_t, v))
gca = XINT (v);
if (TYPE_RANGED_FIXNUMP (gnutls_cipher_algorithm_t, v))
gca = XFIXNUM (v);
}
ptrdiff_t key_size = gnutls_cipher_get_key_size (gca);
@ -2268,17 +2268,17 @@ name. */)
nonce_size = gnutls_mac_get_nonce_size (gma);
#endif
Lisp_Object mp = listn (CONSTYPE_HEAP, 11, gma_symbol,
QCmac_algorithm_id, make_number (gma),
QCmac_algorithm_id, make_fixnum (gma),
QCtype, Qgnutls_type_mac_algorithm,
QCmac_algorithm_length,
make_number (gnutls_hmac_get_len (gma)),
make_fixnum (gnutls_hmac_get_len (gma)),
QCmac_algorithm_keysize,
make_number (gnutls_mac_get_key_size (gma)),
make_fixnum (gnutls_mac_get_key_size (gma)),
QCmac_algorithm_noncesize,
make_number (nonce_size));
make_fixnum (nonce_size));
mac_algorithms = Fcons (mp, mac_algorithms);
}
@ -2303,11 +2303,11 @@ method name. */)
Lisp_Object gda_symbol = intern (gnutls_digest_get_name (gda));
Lisp_Object mp = listn (CONSTYPE_HEAP, 7, gda_symbol,
QCdigest_algorithm_id, make_number (gda),
QCdigest_algorithm_id, make_fixnum (gda),
QCtype, Qgnutls_type_digest_algorithm,
QCdigest_algorithm_length,
make_number (gnutls_hash_get_len (gda)));
make_fixnum (gnutls_hash_get_len (gda)));
digest_algorithms = Fcons (mp, digest_algorithms);
}
@ -2358,16 +2358,16 @@ itself. */)
hash_method);
info = XCDR (info);
}
else if (TYPE_RANGED_INTEGERP (gnutls_mac_algorithm_t, hash_method))
gma = XINT (hash_method);
else if (TYPE_RANGED_FIXNUMP (gnutls_mac_algorithm_t, hash_method))
gma = XFIXNUM (hash_method);
else
info = hash_method;
if (!NILP (info) && CONSP (info))
{
Lisp_Object v = Fplist_get (info, QCmac_algorithm_id);
if (TYPE_RANGED_INTEGERP (gnutls_mac_algorithm_t, v))
gma = XINT (v);
if (TYPE_RANGED_FIXNUMP (gnutls_mac_algorithm_t, v))
gma = XFIXNUM (v);
}
ptrdiff_t digest_length = gnutls_hmac_get_len (gma);
@ -2448,16 +2448,16 @@ the number itself. */)
digest_method);
info = XCDR (info);
}
else if (TYPE_RANGED_INTEGERP (gnutls_digest_algorithm_t, digest_method))
gda = XINT (digest_method);
else if (TYPE_RANGED_FIXNUMP (gnutls_digest_algorithm_t, digest_method))
gda = XFIXNUM (digest_method);
else
info = digest_method;
if (!NILP (info) && CONSP (info))
{
Lisp_Object v = Fplist_get (info, QCdigest_algorithm_id);
if (TYPE_RANGED_INTEGERP (gnutls_digest_algorithm_t, v))
gda = XINT (v);
if (TYPE_RANGED_FIXNUMP (gnutls_digest_algorithm_t, v))
gda = XFIXNUM (v);
}
ptrdiff_t digest_length = gnutls_hash_get_len (gda);
@ -2571,11 +2571,11 @@ syms_of_gnutls (void)
DEFSYM (Qlibgnutls_version, "libgnutls-version");
Fset (Qlibgnutls_version,
#ifdef HAVE_GNUTLS
make_number (GNUTLS_VERSION_MAJOR * 10000
make_fixnum (GNUTLS_VERSION_MAJOR * 10000
+ GNUTLS_VERSION_MINOR * 100
+ GNUTLS_VERSION_PATCH)
#else
make_number (-1)
make_fixnum (-1)
#endif
);
#ifdef HAVE_GNUTLS
@ -2619,19 +2619,19 @@ syms_of_gnutls (void)
DEFSYM (Qgnutls_e_interrupted, "gnutls-e-interrupted");
Fput (Qgnutls_e_interrupted, Qgnutls_code,
make_number (GNUTLS_E_INTERRUPTED));
make_fixnum (GNUTLS_E_INTERRUPTED));
DEFSYM (Qgnutls_e_again, "gnutls-e-again");
Fput (Qgnutls_e_again, Qgnutls_code,
make_number (GNUTLS_E_AGAIN));
make_fixnum (GNUTLS_E_AGAIN));
DEFSYM (Qgnutls_e_invalid_session, "gnutls-e-invalid-session");
Fput (Qgnutls_e_invalid_session, Qgnutls_code,
make_number (GNUTLS_E_INVALID_SESSION));
make_fixnum (GNUTLS_E_INVALID_SESSION));
DEFSYM (Qgnutls_e_not_ready_for_handshake, "gnutls-e-not-ready-for-handshake");
Fput (Qgnutls_e_not_ready_for_handshake, Qgnutls_code,
make_number (GNUTLS_E_APPLICATION_ERROR_MIN));
make_fixnum (GNUTLS_E_APPLICATION_ERROR_MIN));
defsubr (&Sgnutls_get_initstage);
defsubr (&Sgnutls_asynchronous_parameters);

24
src/gtkutil.c
View file

@ -963,7 +963,7 @@ xg_frame_set_char_size (struct frame *f, int width, int height)
{
frame_size_history_add
(f, Qxg_frame_set_char_size_1, width, height,
list2 (make_number (gheight), make_number (totalheight)));
list2 (make_fixnum (gheight), make_fixnum (totalheight)));
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
gwidth, totalheight);
@ -972,7 +972,7 @@ xg_frame_set_char_size (struct frame *f, int width, int height)
{
frame_size_history_add
(f, Qxg_frame_set_char_size_2, width, height,
list2 (make_number (gwidth), make_number (totalwidth)));
list2 (make_fixnum (gwidth), make_fixnum (totalwidth)));
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
totalwidth, gheight);
@ -981,7 +981,7 @@ xg_frame_set_char_size (struct frame *f, int width, int height)
{
frame_size_history_add
(f, Qxg_frame_set_char_size_3, width, height,
list2 (make_number (totalwidth), make_number (totalheight)));
list2 (make_fixnum (totalwidth), make_fixnum (totalheight)));
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
totalwidth, totalheight);
@ -4279,7 +4279,7 @@ draw_page (GtkPrintOperation *operation, GtkPrintContext *context,
gint page_nr, gpointer user_data)
{
Lisp_Object frames = *((Lisp_Object *) user_data);
struct frame *f = XFRAME (Fnth (make_number (page_nr), frames));
struct frame *f = XFRAME (Fnth (make_fixnum (page_nr), frames));
cairo_t *cr = gtk_print_context_get_cairo_context (context);
x_cr_draw_frame (cr, f);
@ -4296,7 +4296,7 @@ xg_print_frames_dialog (Lisp_Object frames)
gtk_print_operation_set_print_settings (print, print_settings);
if (page_setup != NULL)
gtk_print_operation_set_default_page_setup (print, page_setup);
gtk_print_operation_set_n_pages (print, XINT (Flength (frames)));
gtk_print_operation_set_n_pages (print, XFIXNUM (Flength (frames)));
g_signal_connect (print, "draw-page", G_CALLBACK (draw_page), &frames);
res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
NULL, NULL);
@ -4889,18 +4889,18 @@ update_frame_tool_bar (struct frame *f)
block_input ();
if (RANGED_INTEGERP (1, Vtool_bar_button_margin, INT_MAX))
if (RANGED_FIXNUMP (1, Vtool_bar_button_margin, INT_MAX))
{
hmargin = XFASTINT (Vtool_bar_button_margin);
vmargin = XFASTINT (Vtool_bar_button_margin);
hmargin = XFIXNAT (Vtool_bar_button_margin);
vmargin = XFIXNAT (Vtool_bar_button_margin);
}
else if (CONSP (Vtool_bar_button_margin))
{
if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin), INT_MAX))
hmargin = XFASTINT (XCAR (Vtool_bar_button_margin));
if (RANGED_FIXNUMP (1, XCAR (Vtool_bar_button_margin), INT_MAX))
hmargin = XFIXNAT (XCAR (Vtool_bar_button_margin));
if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
vmargin = XFASTINT (XCDR (Vtool_bar_button_margin));
if (RANGED_FIXNUMP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
vmargin = XFIXNAT (XCDR (Vtool_bar_button_margin));
}
/* The natural size (i.e. when GTK uses 0 as margin) looks best,

172
src/image.c
View file

@ -322,7 +322,7 @@ x_create_bitmap_from_file (struct frame *f, Lisp_Object file)
/* Search bitmap-file-path for the file, if appropriate. */
if (openp (Vx_bitmap_file_path, file, Qnil, &found,
make_number (R_OK), false)
make_fixnum (R_OK), false)
< 0)
return -1;
@ -761,23 +761,23 @@ parse_image_spec (Lisp_Object spec, struct image_keyword *keywords,
break;
case IMAGE_POSITIVE_INTEGER_VALUE:
if (! RANGED_INTEGERP (1, value, INT_MAX))
if (! RANGED_FIXNUMP (1, value, INT_MAX))
return 0;
break;
case IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR:
if (RANGED_INTEGERP (0, value, INT_MAX))
if (RANGED_FIXNUMP (0, value, INT_MAX))
break;
if (CONSP (value)
&& RANGED_INTEGERP (0, XCAR (value), INT_MAX)
&& RANGED_INTEGERP (0, XCDR (value), INT_MAX))
&& RANGED_FIXNUMP (0, XCAR (value), INT_MAX)
&& RANGED_FIXNUMP (0, XCDR (value), INT_MAX))
break;
return 0;
case IMAGE_ASCENT_VALUE:
if (SYMBOLP (value) && EQ (value, Qcenter))
break;
else if (RANGED_INTEGERP (0, value, 100))
else if (RANGED_FIXNUMP (0, value, 100))
break;
return 0;
@ -785,7 +785,7 @@ parse_image_spec (Lisp_Object spec, struct image_keyword *keywords,
/* Unlike the other integer-related cases, this one does not
verify that VALUE fits in 'int'. This is because callers
want EMACS_INT. */
if (!INTEGERP (value) || XINT (value) < 0)
if (!FIXNUMP (value) || XFIXNUM (value) < 0)
return 0;
break;
@ -799,12 +799,12 @@ parse_image_spec (Lisp_Object spec, struct image_keyword *keywords,
return 0;
case IMAGE_NUMBER_VALUE:
if (! NUMBERP (value))
if (! FIXED_OR_FLOATP (value))
return 0;
break;
case IMAGE_INTEGER_VALUE:
if (! TYPE_RANGED_INTEGERP (int, value))
if (! TYPE_RANGED_FIXNUMP (int, value))
return 0;
break;
@ -883,7 +883,7 @@ or omitted means use the selected frame. */)
size = Fcons (make_float ((double) width / FRAME_COLUMN_WIDTH (f)),
make_float ((double) height / FRAME_LINE_HEIGHT (f)));
else
size = Fcons (make_number (width), make_number (height));
size = Fcons (make_fixnum (width), make_fixnum (height));
}
else
error ("Invalid image specification");
@ -1004,9 +1004,9 @@ check_image_size (struct frame *f, int width, int height)
if (width <= 0 || height <= 0)
return 0;
if (INTEGERP (Vmax_image_size))
return (width <= XINT (Vmax_image_size)
&& height <= XINT (Vmax_image_size));
if (FIXNUMP (Vmax_image_size))
return (width <= XFIXNUM (Vmax_image_size)
&& height <= XFIXNUM (Vmax_image_size));
else if (FLOATP (Vmax_image_size))
{
if (f != NULL)
@ -1534,7 +1534,7 @@ clear_image_cache (struct frame *f, Lisp_Object filter)
}
}
}
else if (INTEGERP (Vimage_cache_eviction_delay))
else if (FIXNUMP (Vimage_cache_eviction_delay))
{
/* Free cache based on timestamp. */
struct timespec old, t;
@ -1547,7 +1547,7 @@ clear_image_cache (struct frame *f, Lisp_Object filter)
/* If the number of cached images has grown unusually large,
decrease the cache eviction delay (Bug#6230). */
delay = XINT (Vimage_cache_eviction_delay);
delay = XFIXNUM (Vimage_cache_eviction_delay);
if (nimages > 40)
delay = 1600 * delay / nimages / nimages;
delay = max (delay, 1);
@ -1761,11 +1761,11 @@ lookup_image (struct frame *f, Lisp_Object spec)
Lisp_Object value;
value = image_spec_value (spec, QCwidth, NULL);
img->width = (INTEGERP (value)
? XFASTINT (value) : DEFAULT_IMAGE_WIDTH);
img->width = (FIXNUMP (value)
? XFIXNAT (value) : DEFAULT_IMAGE_WIDTH);
value = image_spec_value (spec, QCheight, NULL);
img->height = (INTEGERP (value)
? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
img->height = (FIXNUMP (value)
? XFIXNAT (value) : DEFAULT_IMAGE_HEIGHT);
}
else
{
@ -1776,25 +1776,25 @@ lookup_image (struct frame *f, Lisp_Object spec)
int relief_bound;
ascent = image_spec_value (spec, QCascent, NULL);
if (INTEGERP (ascent))
img->ascent = XFASTINT (ascent);
if (FIXNUMP (ascent))
img->ascent = XFIXNAT (ascent);
else if (EQ (ascent, Qcenter))
img->ascent = CENTERED_IMAGE_ASCENT;
margin = image_spec_value (spec, QCmargin, NULL);
if (INTEGERP (margin))
img->vmargin = img->hmargin = XFASTINT (margin);
if (FIXNUMP (margin))
img->vmargin = img->hmargin = XFIXNAT (margin);
else if (CONSP (margin))
{
img->hmargin = XFASTINT (XCAR (margin));
img->vmargin = XFASTINT (XCDR (margin));
img->hmargin = XFIXNAT (XCAR (margin));
img->vmargin = XFIXNAT (XCDR (margin));
}
relief = image_spec_value (spec, QCrelief, NULL);
relief_bound = INT_MAX - max (img->hmargin, img->vmargin);
if (RANGED_INTEGERP (- relief_bound, relief, relief_bound))
if (RANGED_FIXNUMP (- relief_bound, relief, relief_bound))
{
img->relief = XINT (relief);
img->relief = XFIXNUM (relief);
img->hmargin += eabs (img->relief);
img->vmargin += eabs (img->relief);
}
@ -1973,7 +1973,7 @@ x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth,
x_destroy_x_image (*ximg);
*ximg = NULL;
image_error ("Image too large (%dx%d)",
make_number (width), make_number (height));
make_fixnum (width), make_fixnum (height));
return 0;
}
@ -2306,7 +2306,7 @@ x_find_image_fd (Lisp_Object file, int *pfd)
/* Try to find FILE in data-directory/images, then x-bitmap-file-path. */
fd = openp (search_path, file, Qnil, &file_found,
pfd ? Qt : make_number (R_OK), false);
pfd ? Qt : make_fixnum (R_OK), false);
if (fd >= 0 || fd == -2)
{
file_found = ENCODE_FILE (file_found);
@ -2512,8 +2512,8 @@ xbm_image_p (Lisp_Object object)
return 0;
data = kw[XBM_DATA].value;
width = XFASTINT (kw[XBM_WIDTH].value);
height = XFASTINT (kw[XBM_HEIGHT].value);
width = XFIXNAT (kw[XBM_WIDTH].value);
height = XFIXNAT (kw[XBM_HEIGHT].value);
/* Check type of data, and width and height against contents of
data. */
@ -2875,7 +2875,7 @@ xbm_read_bitmap_data (struct frame *f, char *contents, char *end,
{
if (!inhibit_image_error)
image_error ("Image too large (%dx%d)",
make_number (*width), make_number (*height));
make_fixnum (*width), make_fixnum (*height));
goto failure;
}
bytes_per_line = (*width + 7) / 8 + padding_p;
@ -3061,8 +3061,8 @@ xbm_load (struct frame *f, struct image *img)
/* Get specified width, and height. */
if (!in_memory_file_p)
{
img->width = XFASTINT (fmt[XBM_WIDTH].value);
img->height = XFASTINT (fmt[XBM_HEIGHT].value);
img->width = XFIXNAT (fmt[XBM_WIDTH].value);
img->height = XFIXNAT (fmt[XBM_HEIGHT].value);
eassert (img->width > 0 && img->height > 0);
if (!check_image_size (f, img->width, img->height))
{
@ -4000,7 +4000,7 @@ xpm_make_color_table_v (void (**put_func) (Lisp_Object, const char *, int,
{
*put_func = xpm_put_color_table_v;
*get_func = xpm_get_color_table_v;
return Fmake_vector (make_number (256), Qnil);
return Fmake_vector (make_fixnum (256), Qnil);
}
static void
@ -4168,7 +4168,7 @@ xpm_load_image (struct frame *f,
if (!NILP (Fxw_display_color_p (frame)))
best_key = XPM_COLOR_KEY_C;
else if (!NILP (Fx_display_grayscale_p (frame)))
best_key = (XFASTINT (Fx_display_planes (frame)) > 2
best_key = (XFIXNAT (Fx_display_planes (frame)) > 2
? XPM_COLOR_KEY_G : XPM_COLOR_KEY_G4);
else
best_key = XPM_COLOR_KEY_M;
@ -4239,7 +4239,7 @@ xpm_load_image (struct frame *f,
color_val = Qt;
else if (x_defined_color (f, SSDATA (XCDR (specified_color)),
&cdef, 0))
color_val = make_number (cdef.pixel);
color_val = make_fixnum (cdef.pixel);
}
}
if (NILP (color_val) && max_key > 0)
@ -4247,7 +4247,7 @@ xpm_load_image (struct frame *f,
if (xstrcasecmp (max_color, "None") == 0)
color_val = Qt;
else if (x_defined_color (f, max_color, &cdef, 0))
color_val = make_number (cdef.pixel);
color_val = make_fixnum (cdef.pixel);
}
if (!NILP (color_val))
(*put_color_table) (color_table, beg, chars_per_pixel, color_val);
@ -4267,7 +4267,7 @@ xpm_load_image (struct frame *f,
(*get_color_table) (color_table, str, chars_per_pixel);
XPutPixel (ximg, x, y,
(INTEGERP (color_val) ? XINT (color_val)
(FIXNUMP (color_val) ? XFIXNUM (color_val)
: FRAME_FOREGROUND_PIXEL (f)));
#ifndef HAVE_NS
XPutPixel (mask_img, x, y,
@ -4928,20 +4928,20 @@ x_edge_detection (struct frame *f, struct image *img, Lisp_Object matrix,
if (CONSP (matrix))
{
for (i = 0;
i < 9 && CONSP (matrix) && NUMBERP (XCAR (matrix));
i < 9 && CONSP (matrix) && FIXED_OR_FLOATP (XCAR (matrix));
++i, matrix = XCDR (matrix))
trans[i] = XFLOATINT (XCAR (matrix));
}
else if (VECTORP (matrix) && ASIZE (matrix) >= 9)
{
for (i = 0; i < 9 && NUMBERP (AREF (matrix, i)); ++i)
for (i = 0; i < 9 && FIXED_OR_FLOATP (AREF (matrix, i)); ++i)
trans[i] = XFLOATINT (AREF (matrix, i));
}
if (NILP (color_adjust))
color_adjust = make_number (0xffff / 2);
color_adjust = make_fixnum (0xffff / 2);
if (i == 9 && NUMBERP (color_adjust))
if (i == 9 && FIXED_OR_FLOATP (color_adjust))
x_detect_edges (f, img, trans, XFLOATINT (color_adjust));
}
@ -5093,9 +5093,9 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
{
int rgb[3], i;
for (i = 0; i < 3 && CONSP (how) && NATNUMP (XCAR (how)); ++i)
for (i = 0; i < 3 && CONSP (how) && FIXNATP (XCAR (how)); ++i)
{
rgb[i] = XFASTINT (XCAR (how)) & 0xffff;
rgb[i] = XFIXNAT (XCAR (how)) & 0xffff;
how = XCDR (how);
}
@ -7280,9 +7280,9 @@ tiff_load (struct frame *f, struct image *img)
}
image = image_spec_value (img->spec, QCindex, NULL);
if (INTEGERP (image))
if (FIXNUMP (image))
{
EMACS_INT ino = XFASTINT (image);
EMACS_INT ino = XFIXNAT (image);
if (! (TYPE_MINIMUM (tdir_t) <= ino && ino <= TYPE_MAXIMUM (tdir_t)
&& TIFFSetDirectory (tiff, ino)))
{
@ -7324,7 +7324,7 @@ tiff_load (struct frame *f, struct image *img)
if (count > 1)
img->lisp_data = Fcons (Qcount,
Fcons (make_number (count),
Fcons (make_fixnum (count),
img->lisp_data));
TIFFClose (tiff);
@ -7746,7 +7746,7 @@ gif_load (struct frame *f, struct image *img)
/* Which sub-image are we to display? */
{
Lisp_Object image_number = image_spec_value (img->spec, QCindex, NULL);
idx = INTEGERP (image_number) ? XFASTINT (image_number) : 0;
idx = FIXNUMP (image_number) ? XFIXNAT (image_number) : 0;
if (idx < 0 || idx >= gif->ImageCount)
{
image_error ("Invalid image number `%s' in image `%s'",
@ -8000,7 +8000,7 @@ gif_load (struct frame *f, struct image *img)
/* Append (... FUNCTION "BYTES") */
{
img->lisp_data
= Fcons (make_number (ext->Function),
= Fcons (make_fixnum (ext->Function),
Fcons (make_unibyte_string ((char *) ext->Bytes,
ext->ByteCount),
img->lisp_data));
@ -8021,7 +8021,7 @@ gif_load (struct frame *f, struct image *img)
if (gif->ImageCount > 1)
img->lisp_data = Fcons (Qcount,
Fcons (make_number (gif->ImageCount),
Fcons (make_fixnum (gif->ImageCount),
img->lisp_data));
if (gif_close (gif, &gif_err) == GIF_ERROR)
@ -8102,33 +8102,33 @@ compute_image_size (size_t width, size_t height,
double scale = 1;
value = image_spec_value (spec, QCscale, NULL);
if (NUMBERP (value))
if (FIXED_OR_FLOATP (value))
scale = XFLOATINT (value);
value = image_spec_value (spec, QCmax_width, NULL);
if (NATNUMP (value))
max_width = min (XFASTINT (value), INT_MAX);
if (FIXNATP (value))
max_width = min (XFIXNAT (value), INT_MAX);
value = image_spec_value (spec, QCmax_height, NULL);
if (NATNUMP (value))
max_height = min (XFASTINT (value), INT_MAX);
if (FIXNATP (value))
max_height = min (XFIXNAT (value), INT_MAX);
/* If width and/or height is set in the display spec assume we want
to scale to those values. If either h or w is unspecified, the
unspecified should be calculated from the specified to preserve
aspect ratio. */
value = image_spec_value (spec, QCwidth, NULL);
if (NATNUMP (value))
if (FIXNATP (value))
{
desired_width = min (XFASTINT (value) * scale, INT_MAX);
desired_width = min (XFIXNAT (value) * scale, INT_MAX);
/* :width overrides :max-width. */
max_width = -1;
}
value = image_spec_value (spec, QCheight, NULL);
if (NATNUMP (value))
if (FIXNATP (value))
{
desired_height = min (XFASTINT (value) * scale, INT_MAX);
desired_height = min (XFIXNAT (value) * scale, INT_MAX);
/* :height overrides :max-height. */
max_height = -1;
}
@ -8573,7 +8573,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
find out things about it. */
image = image_spec_value (img->spec, QCindex, NULL);
ino = INTEGERP (image) ? XFASTINT (image) : 0;
ino = FIXNUMP (image) ? XFIXNAT (image) : 0;
image_wand = NewMagickWand ();
if (filename)
@ -8583,9 +8583,9 @@ imagemagick_load_image (struct frame *f, struct image *img,
Lisp_Object lwidth = image_spec_value (img->spec, QCwidth, NULL);
Lisp_Object lheight = image_spec_value (img->spec, QCheight, NULL);
if (NATNUMP (lwidth) && NATNUMP (lheight))
if (FIXNATP (lwidth) && FIXNATP (lheight))
{
MagickSetSize (image_wand, XFASTINT (lwidth), XFASTINT (lheight));
MagickSetSize (image_wand, XFIXNAT (lwidth), XFIXNAT (lheight));
MagickSetDepth (image_wand, 8);
}
filename_hint = imagemagick_filename_hint (img->spec, hint_buffer);
@ -8628,7 +8628,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
if (MagickGetNumberImages (image_wand) > 1)
img->lisp_data =
Fcons (Qcount,
Fcons (make_number (MagickGetNumberImages (image_wand)),
Fcons (make_fixnum (MagickGetNumberImages (image_wand)),
img->lisp_data));
/* If we have an animated image, get the new wand based on the
@ -8678,26 +8678,26 @@ imagemagick_load_image (struct frame *f, struct image *img,
efficient. */
crop = image_spec_value (img->spec, QCcrop, NULL);
if (CONSP (crop) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop)))
if (CONSP (crop) && TYPE_RANGED_FIXNUMP (size_t, XCAR (crop)))
{
/* After some testing, it seems MagickCropImage is the fastest crop
function in ImageMagick. This crop function seems to do less copying
than the alternatives, but it still reads the entire image into memory
before cropping, which is apparently difficult to avoid when using
imagemagick. */
size_t crop_width = XINT (XCAR (crop));
size_t crop_width = XFIXNUM (XCAR (crop));
crop = XCDR (crop);
if (CONSP (crop) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop)))
if (CONSP (crop) && TYPE_RANGED_FIXNUMP (size_t, XCAR (crop)))
{
size_t crop_height = XINT (XCAR (crop));
size_t crop_height = XFIXNUM (XCAR (crop));
crop = XCDR (crop);
if (CONSP (crop) && TYPE_RANGED_INTEGERP (ssize_t, XCAR (crop)))
if (CONSP (crop) && TYPE_RANGED_FIXNUMP (ssize_t, XCAR (crop)))
{
ssize_t crop_x = XINT (XCAR (crop));
ssize_t crop_x = XFIXNUM (XCAR (crop));
crop = XCDR (crop);
if (CONSP (crop) && TYPE_RANGED_INTEGERP (ssize_t, XCAR (crop)))
if (CONSP (crop) && TYPE_RANGED_FIXNUMP (ssize_t, XCAR (crop)))
{
ssize_t crop_y = XINT (XCAR (crop));
ssize_t crop_y = XFIXNUM (XCAR (crop));
MagickCropImage (image_wand, crop_width, crop_height,
crop_x, crop_y);
}
@ -9551,7 +9551,7 @@ gs_image_p (Lisp_Object object)
if (CONSP (tem))
{
for (i = 0; i < 4; ++i, tem = XCDR (tem))
if (!CONSP (tem) || !INTEGERP (XCAR (tem)))
if (!CONSP (tem) || !FIXNUMP (XCAR (tem)))
return 0;
if (!NILP (tem))
return 0;
@ -9561,7 +9561,7 @@ gs_image_p (Lisp_Object object)
if (ASIZE (tem) != 4)
return 0;
for (i = 0; i < 4; ++i)
if (!INTEGERP (AREF (tem, i)))
if (!FIXNUMP (AREF (tem, i)))
return 0;
}
else
@ -9589,10 +9589,10 @@ gs_load (struct frame *f, struct image *img)
= 1/72 in, xdpi and ydpi are stored in the frame's X display
info. */
pt_width = image_spec_value (img->spec, QCpt_width, NULL);
in_width = INTEGERP (pt_width) ? XFASTINT (pt_width) / 72.0 : 0;
in_width = FIXNUMP (pt_width) ? XFIXNAT (pt_width) / 72.0 : 0;
in_width *= FRAME_RES_X (f);
pt_height = image_spec_value (img->spec, QCpt_height, NULL);
in_height = INTEGERP (pt_height) ? XFASTINT (pt_height) / 72.0 : 0;
in_height = FIXNUMP (pt_height) ? XFIXNAT (pt_height) / 72.0 : 0;
in_height *= FRAME_RES_Y (f);
if (! (in_width <= INT_MAX && in_height <= INT_MAX
@ -9643,8 +9643,8 @@ gs_load (struct frame *f, struct image *img)
loader = intern ("gs-load-image");
img->lisp_data = call6 (loader, frame, img->spec,
make_number (img->width),
make_number (img->height),
make_fixnum (img->width),
make_fixnum (img->height),
window_and_pixmap_id,
pixel_colors);
return PROCESSP (img->lisp_data);
@ -9768,7 +9768,7 @@ DEFUN ("lookup-image", Flookup_image, Slookup_image, 1, 1, 0,
id = lookup_image (SELECTED_FRAME (), spec);
debug_print (spec);
return make_number (id);
return make_fixnum (id);
}
#endif /* GLYPH_DEBUG */
@ -9933,27 +9933,27 @@ non-numeric, there is no explicit limit on the size of images. */);
DEFSYM (Qlibpng_version, "libpng-version");
Fset (Qlibpng_version,
#if HAVE_PNG
make_number (PNG_LIBPNG_VER)
make_fixnum (PNG_LIBPNG_VER)
#else
make_number (-1)
make_fixnum (-1)
#endif
);
DEFSYM (Qlibgif_version, "libgif-version");
Fset (Qlibgif_version,
#ifdef HAVE_GIF
make_number (GIFLIB_MAJOR * 10000
make_fixnum (GIFLIB_MAJOR * 10000
+ GIFLIB_MINOR * 100
+ GIFLIB_RELEASE)
#else
make_number (-1)
make_fixnum (-1)
#endif
);
DEFSYM (Qlibjpeg_version, "libjpeg-version");
Fset (Qlibjpeg_version,
#if HAVE_JPEG
make_number (JPEG_LIB_VERSION)
make_fixnum (JPEG_LIB_VERSION)
#else
make_number (-1)
make_fixnum (-1)
#endif
);
#endif
@ -10038,7 +10038,7 @@ a large number of images, the actual eviction time may be shorter.
The value can also be nil, meaning the cache is never cleared.
The function `clear-image-cache' disregards this variable. */);
Vimage_cache_eviction_delay = make_number (300);
Vimage_cache_eviction_delay = make_fixnum (300);
#ifdef HAVE_IMAGEMAGICK
DEFVAR_INT ("imagemagick-render-type", imagemagick_render_type,
doc: /* Integer indicating which ImageMagick rendering method to use.

150
src/indent.c
View file

@ -116,7 +116,7 @@ disptab_matches_widthtab (struct Lisp_Char_Table *disptab, struct Lisp_Vector *w
for (i = 0; i < 256; i++)
if (character_width (i, disptab)
!= XFASTINT (widthtab->contents[i]))
!= XFIXNAT (widthtab->contents[i]))
return 0;
return 1;
@ -235,24 +235,24 @@ skip_invisible (ptrdiff_t pos, ptrdiff_t *next_boundary_p, ptrdiff_t to, Lisp_Ob
/* As for text properties, this gives a lower bound
for where the invisible text property could change. */
proplimit = Fnext_property_change (position, buffer, Qt);
if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
if (XFIXNAT (overlay_limit) < XFIXNAT (proplimit))
proplimit = overlay_limit;
/* PROPLIMIT is now a lower bound for the next change
in invisible status. If that is plenty far away,
use that lower bound. */
if (XFASTINT (proplimit) > pos + 100 || XFASTINT (proplimit) >= to)
*next_boundary_p = XFASTINT (proplimit);
if (XFIXNAT (proplimit) > pos + 100 || XFIXNAT (proplimit) >= to)
*next_boundary_p = XFIXNAT (proplimit);
/* Otherwise, scan for the next `invisible' property change. */
else
{
/* Don't scan terribly far. */
XSETFASTINT (proplimit, min (pos + 100, to));
/* No matter what, don't go past next overlay change. */
if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
if (XFIXNAT (overlay_limit) < XFIXNAT (proplimit))
proplimit = overlay_limit;
tmp = Fnext_single_property_change (position, Qinvisible,
buffer, proplimit);
end = XFASTINT (tmp);
end = XFIXNAT (tmp);
#if 0
/* Don't put the boundary in the middle of multibyte form if
there is no actual property change. */
@ -472,7 +472,7 @@ check_display_width (ptrdiff_t pos, ptrdiff_t col, ptrdiff_t *endpos)
Lisp_Object val, overlay;
if (CONSP (val = get_char_property_and_overlay
(make_number (pos), Qdisplay, Qnil, &overlay))
(make_fixnum (pos), Qdisplay, Qnil, &overlay))
&& EQ (Qspace, XCAR (val)))
{ /* FIXME: Use calc_pixel_width_or_height. */
Lisp_Object plist = XCDR (val), prop;
@ -483,16 +483,16 @@ check_display_width (ptrdiff_t pos, ptrdiff_t col, ptrdiff_t *endpos)
: MOST_POSITIVE_FIXNUM);
if ((prop = Fplist_get (plist, QCwidth),
RANGED_INTEGERP (0, prop, INT_MAX))
RANGED_FIXNUMP (0, prop, INT_MAX))
|| (prop = Fplist_get (plist, QCrelative_width),
RANGED_INTEGERP (0, prop, INT_MAX)))
width = XINT (prop);
RANGED_FIXNUMP (0, prop, INT_MAX)))
width = XFIXNUM (prop);
else if (FLOATP (prop) && 0 <= XFLOAT_DATA (prop)
&& XFLOAT_DATA (prop) <= INT_MAX)
width = (int)(XFLOAT_DATA (prop) + 0.5);
else if ((prop = Fplist_get (plist, QCalign_to),
RANGED_INTEGERP (col, prop, align_to_max)))
width = XINT (prop) - col;
RANGED_FIXNUMP (col, prop, align_to_max)))
width = XFIXNUM (prop) - col;
else if (FLOATP (prop) && col <= XFLOAT_DATA (prop)
&& (XFLOAT_DATA (prop) <= align_to_max))
width = (int)(XFLOAT_DATA (prop) + 0.5) - col;
@ -751,16 +751,16 @@ string_display_width (Lisp_Object string, Lisp_Object beg, Lisp_Object end)
e = SCHARS (string);
else
{
CHECK_NUMBER (end);
e = XINT (end);
CHECK_FIXNUM (end);
e = XFIXNUM (end);
}
if (NILP (beg))
b = 0;
else
{
CHECK_NUMBER (beg);
b = XINT (beg);
CHECK_FIXNUM (beg);
b = XFIXNUM (beg);
}
/* Make a pointer for decrementing through the chars before point. */
@ -820,32 +820,32 @@ The return value is the column where the insertion ends. */)
register ptrdiff_t fromcol;
int tab_width = SANE_TAB_WIDTH (current_buffer);
CHECK_NUMBER (column);
CHECK_FIXNUM (column);
if (NILP (minimum))
XSETFASTINT (minimum, 0);
CHECK_NUMBER (minimum);
CHECK_FIXNUM (minimum);
fromcol = current_column ();
mincol = fromcol + XINT (minimum);
if (mincol < XINT (column)) mincol = XINT (column);
mincol = fromcol + XFIXNUM (minimum);
if (mincol < XFIXNUM (column)) mincol = XFIXNUM (column);
if (fromcol == mincol)
return make_number (mincol);
return make_fixnum (mincol);
if (indent_tabs_mode)
{
Lisp_Object n;
XSETFASTINT (n, mincol / tab_width - fromcol / tab_width);
if (XFASTINT (n) != 0)
if (XFIXNAT (n) != 0)
{
Finsert_char (make_number ('\t'), n, Qt);
Finsert_char (make_fixnum ('\t'), n, Qt);
fromcol = (mincol / tab_width) * tab_width;
}
}
XSETFASTINT (column, mincol - fromcol);
Finsert_char (make_number (' '), column, Qt);
Finsert_char (make_fixnum (' '), column, Qt);
last_known_column = mincol;
last_known_column_point = PT;
@ -866,7 +866,7 @@ following any initial whitespace. */)
ptrdiff_t posbyte;
find_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, NULL, &posbyte, 1);
return make_number (position_indentation (posbyte));
return make_fixnum (position_indentation (posbyte));
}
static ptrdiff_t
@ -994,8 +994,8 @@ The return value is the current column. */)
EMACS_INT col;
EMACS_INT goal;
CHECK_NATNUM (column);
goal = XINT (column);
CHECK_FIXNAT (column);
goal = XFIXNUM (column);
col = goal;
pos = ZV;
@ -1020,13 +1020,13 @@ The return value is the current column. */)
first so that a marker at the end of the tab gets
adjusted. */
SET_PT_BOTH (PT - 1, PT_BYTE - 1);
Finsert_char (make_number (' '), make_number (goal - prev_col), Qt);
Finsert_char (make_fixnum (' '), make_fixnum (goal - prev_col), Qt);
/* Now delete the tab, and indent to COL. */
del_range (PT, PT + 1);
goal_pt = PT;
goal_pt_byte = PT_BYTE;
Findent_to (make_number (col), Qnil);
Findent_to (make_fixnum (col), Qnil);
SET_PT_BOTH (goal_pt, goal_pt_byte);
/* Set the last_known... vars consistently. */
@ -1036,13 +1036,13 @@ The return value is the current column. */)
/* If line ends prematurely, add space to the end. */
if (col < goal && EQ (force, Qt))
Findent_to (make_number (col = goal), Qnil);
Findent_to (make_fixnum (col = goal), Qnil);
last_known_column = col;
last_known_column_point = PT;
last_known_column_modified = MODIFF;
return make_number (col);
return make_fixnum (col);
}
/* compute_motion: compute buffer posn given screen posn and vice versa */
@ -1128,8 +1128,8 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
bool ctl_arrow = !NILP (BVAR (current_buffer, ctl_arrow));
struct Lisp_Char_Table *dp = window_display_table (win);
EMACS_INT selective
= (INTEGERP (BVAR (current_buffer, selective_display))
? XINT (BVAR (current_buffer, selective_display))
= (FIXNUMP (BVAR (current_buffer, selective_display))
? XFIXNUM (BVAR (current_buffer, selective_display))
: !NILP (BVAR (current_buffer, selective_display)) ? -1 : 0);
ptrdiff_t selective_rlen
= (selective && dp && VECTORP (DISP_INVIS_VECTOR (dp))
@ -1338,9 +1338,9 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
if (!NILP (Vtruncate_partial_width_windows)
&& (total_width < FRAME_COLS (XFRAME (WINDOW_FRAME (win)))))
{
if (INTEGERP (Vtruncate_partial_width_windows))
if (FIXNUMP (Vtruncate_partial_width_windows))
truncate
= total_width < XFASTINT (Vtruncate_partial_width_windows);
= total_width < XFIXNAT (Vtruncate_partial_width_windows);
else
truncate = 1;
}
@ -1533,7 +1533,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
/* Is this character part of the current run? If so, extend
the run. */
if (pos - 1 == width_run_end
&& XFASTINT (width_table[c]) == width_run_width)
&& XFIXNAT (width_table[c]) == width_run_width)
width_run_end = pos;
/* The previous run is over, since this is a character at a
@ -1548,7 +1548,7 @@ compute_motion (ptrdiff_t from, ptrdiff_t frombyte, EMACS_INT fromvpos,
width_run_start, width_run_end);
/* Start recording a new width run. */
width_run_width = XFASTINT (width_table[c]);
width_run_width = XFIXNAT (width_table[c]);
width_run_start = pos - 1;
width_run_end = pos;
}
@ -1754,48 +1754,48 @@ visible section of the buffer, and pass LINE and COL as TOPOS. */)
ptrdiff_t hscroll;
int tab_offset;
CHECK_NUMBER_COERCE_MARKER (from);
CHECK_FIXNUM_COERCE_MARKER (from);
CHECK_CONS (frompos);
CHECK_NUMBER_CAR (frompos);
CHECK_NUMBER_CDR (frompos);
CHECK_NUMBER_COERCE_MARKER (to);
CHECK_FIXNUM_CAR (frompos);
CHECK_FIXNUM_CDR (frompos);
CHECK_FIXNUM_COERCE_MARKER (to);
if (!NILP (topos))
{
CHECK_CONS (topos);
CHECK_NUMBER_CAR (topos);
CHECK_NUMBER_CDR (topos);
CHECK_FIXNUM_CAR (topos);
CHECK_FIXNUM_CDR (topos);
}
if (!NILP (width))
CHECK_NUMBER (width);
CHECK_FIXNUM (width);
if (!NILP (offsets))
{
CHECK_CONS (offsets);
CHECK_NUMBER_CAR (offsets);
CHECK_NUMBER_CDR (offsets);
if (! (0 <= XINT (XCAR (offsets)) && XINT (XCAR (offsets)) <= PTRDIFF_MAX
&& 0 <= XINT (XCDR (offsets)) && XINT (XCDR (offsets)) <= INT_MAX))
CHECK_FIXNUM_CAR (offsets);
CHECK_FIXNUM_CDR (offsets);
if (! (0 <= XFIXNUM (XCAR (offsets)) && XFIXNUM (XCAR (offsets)) <= PTRDIFF_MAX
&& 0 <= XFIXNUM (XCDR (offsets)) && XFIXNUM (XCDR (offsets)) <= INT_MAX))
args_out_of_range (XCAR (offsets), XCDR (offsets));
hscroll = XINT (XCAR (offsets));
tab_offset = XINT (XCDR (offsets));
hscroll = XFIXNUM (XCAR (offsets));
tab_offset = XFIXNUM (XCDR (offsets));
}
else
hscroll = tab_offset = 0;
w = decode_live_window (window);
if (XINT (from) < BEGV || XINT (from) > ZV)
args_out_of_range_3 (from, make_number (BEGV), make_number (ZV));
if (XINT (to) < BEGV || XINT (to) > ZV)
args_out_of_range_3 (to, make_number (BEGV), make_number (ZV));
if (XFIXNUM (from) < BEGV || XFIXNUM (from) > ZV)
args_out_of_range_3 (from, make_fixnum (BEGV), make_fixnum (ZV));
if (XFIXNUM (to) < BEGV || XFIXNUM (to) > ZV)
args_out_of_range_3 (to, make_fixnum (BEGV), make_fixnum (ZV));
pos = compute_motion (XINT (from), CHAR_TO_BYTE (XINT (from)),
XINT (XCDR (frompos)),
XINT (XCAR (frompos)), 0,
XINT (to),
pos = compute_motion (XFIXNUM (from), CHAR_TO_BYTE (XFIXNUM (from)),
XFIXNUM (XCDR (frompos)),
XFIXNUM (XCAR (frompos)), 0,
XFIXNUM (to),
(NILP (topos)
? window_internal_height (w)
: XINT (XCDR (topos))),
: XFIXNUM (XCDR (topos))),
(NILP (topos)
? (window_body_width (w, 0)
- (
@ -1803,8 +1803,8 @@ visible section of the buffer, and pass LINE and COL as TOPOS. */)
FRAME_WINDOW_P (XFRAME (w->frame)) ? 0 :
#endif
1))
: XINT (XCAR (topos))),
(NILP (width) ? -1 : XINT (width)),
: XFIXNUM (XCAR (topos))),
(NILP (width) ? -1 : XFIXNUM (width)),
hscroll, tab_offset, w);
XSETFASTINT (bufpos, pos->bufpos);
@ -1831,8 +1831,8 @@ vmotion (register ptrdiff_t from, register ptrdiff_t from_byte,
register ptrdiff_t first;
ptrdiff_t lmargin = hscroll > 0 ? 1 - hscroll : 0;
ptrdiff_t selective
= (INTEGERP (BVAR (current_buffer, selective_display))
? clip_to_bounds (-1, XINT (BVAR (current_buffer, selective_display)),
= (FIXNUMP (BVAR (current_buffer, selective_display))
? clip_to_bounds (-1, XFIXNUM (BVAR (current_buffer, selective_display)),
PTRDIFF_MAX)
: !NILP (BVAR (current_buffer, selective_display)) ? -1 : 0);
Lisp_Object window;
@ -1870,7 +1870,7 @@ vmotion (register ptrdiff_t from, register ptrdiff_t from_byte,
&& indented_beyond_p (prevline, bytepos, selective))
/* Watch out for newlines with `invisible' property.
When moving upward, check the newline before. */
|| (propval = Fget_char_property (make_number (prevline - 1),
|| (propval = Fget_char_property (make_fixnum (prevline - 1),
Qinvisible,
text_prop_object),
TEXT_PROP_MEANS_INVISIBLE (propval))))
@ -1920,7 +1920,7 @@ vmotion (register ptrdiff_t from, register ptrdiff_t from_byte,
&& indented_beyond_p (prevline, bytepos, selective))
/* Watch out for newlines with `invisible' property.
When moving downward, check the newline after. */
|| (propval = Fget_char_property (make_number (prevline),
|| (propval = Fget_char_property (make_fixnum (prevline),
Qinvisible,
text_prop_object),
TEXT_PROP_MEANS_INVISIBLE (propval))))
@ -2016,8 +2016,8 @@ numbers on display. */)
return make_float ((double) pixel_width / FRAME_COLUMN_WIDTH (f));
}
else if (!NILP (pixelwise))
return make_number (pixel_width);
return make_number (width);
return make_fixnum (pixel_width);
return make_fixnum (width);
}
/* In window W (derived from WINDOW), return x coordinate for column
@ -2045,8 +2045,8 @@ restore_window_buffer (Lisp_Object list)
wset_buffer (w, XCAR (list));
list = XCDR (list);
set_marker_both (w->pointm, w->contents,
XFASTINT (XCAR (list)),
XFASTINT (XCAR (XCDR (list))));
XFIXNAT (XCAR (list)),
XFIXNAT (XCAR (XCDR (list))));
}
DEFUN ("vertical-motion", Fvertical_motion, Svertical_motion, 1, 3, 0,
@ -2100,15 +2100,15 @@ whether or not it is currently displayed in some window. */)
lines = XCDR (lines);
}
CHECK_NUMBER (lines);
CHECK_FIXNUM (lines);
w = decode_live_window (window);
if (XBUFFER (w->contents) != current_buffer)
{
/* Set the window's buffer temporarily to the current buffer. */
Lisp_Object old = list4 (window, w->contents,
make_number (marker_position (w->pointm)),
make_number (marker_byte_position (w->pointm)));
make_fixnum (marker_position (w->pointm)),
make_fixnum (marker_byte_position (w->pointm)));
record_unwind_protect (restore_window_buffer, old);
wset_buffer (w, Fcurrent_buffer ());
set_marker_both (w->pointm, w->contents,
@ -2118,7 +2118,7 @@ whether or not it is currently displayed in some window. */)
if (noninteractive)
{
struct position pos;
pos = *vmotion (PT, PT_BYTE, XINT (lines), w);
pos = *vmotion (PT, PT_BYTE, XFIXNUM (lines), w);
SET_PT_BOTH (pos.bufpos, pos.bytepos);
it.vpos = pos.vpos;
}
@ -2128,7 +2128,7 @@ whether or not it is currently displayed in some window. */)
int first_x;
bool overshoot_handled = 0;
bool disp_string_at_start_p = 0;
ptrdiff_t nlines = XINT (lines);
ptrdiff_t nlines = XFIXNUM (lines);
int vpos_init = 0;
double start_col UNINIT;
int start_x UNINIT;
@ -2356,7 +2356,7 @@ whether or not it is currently displayed in some window. */)
bidi_unshelve_cache (itdata, 0);
}
return unbind_to (count, make_number (it.vpos));
return unbind_to (count, make_fixnum (it.vpos));
}

16
src/inotify.c
View file

@ -176,7 +176,7 @@ inotifyevent_to_event (Lisp_Object watch, struct inotify_event const *ev)
{
Lisp_Object name;
uint32_t mask;
CONS_TO_INTEGER (Fnth (make_number (3), watch), uint32_t, mask);
CONS_TO_INTEGER (Fnth (make_fixnum (3), watch), uint32_t, mask);
if (! (mask & ev->mask))
return Qnil;
@ -194,7 +194,7 @@ inotifyevent_to_event (Lisp_Object watch, struct inotify_event const *ev)
mask_to_aspects (ev->mask),
name,
INTEGER_TO_CONS (ev->cookie)),
Fnth (make_number (2), watch));
Fnth (make_fixnum (2), watch));
}
/* Add a new watch to watch-descriptor WD watching FILENAME and using
@ -220,7 +220,7 @@ add_watch (int wd, Lisp_Object filename,
/* Assign a watch ID that is not already in use, by looking
for a gap in the existing sorted list. */
for (; ! NILP (XCDR (tail)); tail = XCDR (tail), id++)
if (!EQ (XCAR (XCAR (XCDR (tail))), make_number (id)))
if (!EQ (XCAR (XCAR (XCDR (tail))), make_fixnum (id)))
break;
if (MOST_POSITIVE_FIXNUM < id)
emacs_abort ();
@ -229,7 +229,7 @@ add_watch (int wd, Lisp_Object filename,
/* Insert the newly-assigned ID into the previously-discovered gap,
which is possibly at the end of the list. Inserting it there
keeps the list sorted. */
watch_id = make_number (id);
watch_id = make_fixnum (id);
watch = list4 (watch_id, filename, callback, mask);
XSETCDR (tail, Fcons (watch, XCDR (tail)));
@ -446,12 +446,12 @@ static bool
valid_watch_descriptor (Lisp_Object wd)
{
return (CONSP (wd)
&& (RANGED_INTEGERP (0, XCAR (wd), INT_MAX)
&& (RANGED_FIXNUMP (0, XCAR (wd), INT_MAX)
|| (CONSP (XCAR (wd))
&& RANGED_INTEGERP ((MOST_POSITIVE_FIXNUM >> 16) + 1,
&& RANGED_FIXNUMP ((MOST_POSITIVE_FIXNUM >> 16) + 1,
XCAR (XCAR (wd)), INT_MAX >> 16)
&& RANGED_INTEGERP (0, XCDR (XCAR (wd)), (1 << 16) - 1)))
&& NATNUMP (XCDR (wd)));
&& RANGED_FIXNUMP (0, XCDR (XCAR (wd)), (1 << 16) - 1)))
&& FIXNATP (XCDR (wd)));
}
DEFUN ("inotify-rm-watch", Finotify_rm_watch, Sinotify_rm_watch, 1, 1, 0,

34
src/insdel.c
View file

@ -930,7 +930,7 @@ insert_1_both (const char *string,
offset_intervals (current_buffer, PT, nchars);
if (!inherit && buffer_intervals (current_buffer))
set_text_properties (make_number (PT), make_number (PT + nchars),
set_text_properties (make_fixnum (PT), make_fixnum (PT + nchars),
Qnil, Qnil, Qnil);
adjust_point (nchars, nbytes);
@ -1936,7 +1936,7 @@ prepare_to_modify_buffer_1 (ptrdiff_t start, ptrdiff_t end,
if (preserve_ptr)
{
Lisp_Object preserve_marker;
preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil);
preserve_marker = Fcopy_marker (make_fixnum (*preserve_ptr), Qnil);
verify_interval_modification (current_buffer, start, end);
*preserve_ptr = marker_position (preserve_marker);
unchain_marker (XMARKER (preserve_marker));
@ -2046,7 +2046,7 @@ invalidate_buffer_caches (struct buffer *buf, ptrdiff_t start, ptrdiff_t end)
#define PRESERVE_VALUE \
if (preserve_ptr && NILP (preserve_marker)) \
preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
preserve_marker = Fcopy_marker (make_fixnum (*preserve_ptr), Qnil)
#define RESTORE_VALUE \
if (! NILP (preserve_marker)) \
@ -2103,8 +2103,8 @@ signal_before_change (ptrdiff_t start_int, ptrdiff_t end_int,
ptrdiff_t count = SPECPDL_INDEX ();
struct rvoe_arg rvoe_arg;
start = make_number (start_int);
end = make_number (end_int);
start = make_fixnum (start_int);
end = make_fixnum (end_int);
preserve_marker = Qnil;
start_marker = Qnil;
end_marker = Qnil;
@ -2210,26 +2210,26 @@ signal_after_change (ptrdiff_t charpos, ptrdiff_t lendel, ptrdiff_t lenins)
/* Actually run the hook functions. */
CALLN (Frun_hook_with_args, Qafter_change_functions,
make_number (charpos), make_number (charpos + lenins),
make_number (lendel));
make_fixnum (charpos), make_fixnum (charpos + lenins),
make_fixnum (lendel));
/* There was no error: unarm the reset_on_error. */
rvoe_arg.errorp = 0;
}
if (buffer_has_overlays ())
report_overlay_modification (make_number (charpos),
make_number (charpos + lenins),
report_overlay_modification (make_fixnum (charpos),
make_fixnum (charpos + lenins),
1,
make_number (charpos),
make_number (charpos + lenins),
make_number (lendel));
make_fixnum (charpos),
make_fixnum (charpos + lenins),
make_fixnum (lendel));
/* After an insertion, call the text properties
insert-behind-hooks or insert-in-front-hooks. */
if (lendel == 0)
report_interval_modification (make_number (charpos),
make_number (charpos + lenins));
report_interval_modification (make_fixnum (charpos),
make_fixnum (charpos + lenins));
unbind_to (count, Qnil);
}
@ -2287,17 +2287,17 @@ DEFUN ("combine-after-change-execute", Fcombine_after_change_execute,
elt = XCAR (tail);
if (! CONSP (elt))
continue;
thisbeg = XINT (XCAR (elt));
thisbeg = XFIXNUM (XCAR (elt));
elt = XCDR (elt);
if (! CONSP (elt))
continue;
thisend = XINT (XCAR (elt));
thisend = XFIXNUM (XCAR (elt));
elt = XCDR (elt);
if (! CONSP (elt))
continue;
thischange = XINT (XCAR (elt));
thischange = XFIXNUM (XCAR (elt));
/* Merge this range into the accumulated range. */
change += thischange;

50
src/intervals.c
View file

@ -1557,8 +1557,8 @@ graft_intervals_into_buffer (INTERVAL source, ptrdiff_t position,
if (!inherit && tree && length > 0)
{
XSETBUFFER (buf, buffer);
set_text_properties_1 (make_number (position),
make_number (position + length),
set_text_properties_1 (make_fixnum (position),
make_fixnum (position + length),
Qnil, buf,
find_interval (tree, position));
}
@ -1793,7 +1793,7 @@ adjust_for_invis_intang (ptrdiff_t pos, ptrdiff_t test_offs, ptrdiff_t adj,
/* POS + ADJ would be beyond the buffer bounds, so do no adjustment. */
return pos;
test_pos = make_number (pos + test_offs);
test_pos = make_fixnum (pos + test_offs);
invis_propval
= get_char_property_and_overlay (test_pos, Qinvisible, Qnil,
@ -1806,7 +1806,7 @@ adjust_for_invis_intang (ptrdiff_t pos, ptrdiff_t test_offs, ptrdiff_t adj,
such that an insertion at POS would inherit it. */
&& (NILP (invis_overlay)
/* Invisible property is from a text-property. */
? (text_property_stickiness (Qinvisible, make_number (pos), Qnil)
? (text_property_stickiness (Qinvisible, make_fixnum (pos), Qnil)
== (test_offs == 0 ? 1 : -1))
/* Invisible property is from an overlay. */
: (test_offs == 0
@ -1926,8 +1926,8 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
if (! NILP (intangible_propval))
{
while (XINT (pos) > BEGV
&& EQ (Fget_char_property (make_number (XINT (pos) - 1),
while (XFIXNUM (pos) > BEGV
&& EQ (Fget_char_property (make_fixnum (XFIXNUM (pos) - 1),
Qintangible, Qnil),
intangible_propval))
pos = Fprevious_char_property_change (pos, Qnil);
@ -1937,7 +1937,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
property is `front-sticky', perturb it to be one character
earlier -- this ensures that point can never move to the
beginning of an invisible/intangible/front-sticky region. */
charpos = adjust_for_invis_intang (XINT (pos), 0, -1, 0);
charpos = adjust_for_invis_intang (XFIXNUM (pos), 0, -1, 0);
}
}
else
@ -1954,12 +1954,12 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
/* If preceding char is intangible,
skip forward over all chars with matching intangible property. */
intangible_propval = Fget_char_property (make_number (charpos - 1),
intangible_propval = Fget_char_property (make_fixnum (charpos - 1),
Qintangible, Qnil);
if (! NILP (intangible_propval))
{
while (XINT (pos) < ZV
while (XFIXNUM (pos) < ZV
&& EQ (Fget_char_property (pos, Qintangible, Qnil),
intangible_propval))
pos = Fnext_char_property_change (pos, Qnil);
@ -1969,7 +1969,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
property is `rear-sticky', perturb it to be one character
later -- this ensures that point can never move to the
end of an invisible/intangible/rear-sticky region. */
charpos = adjust_for_invis_intang (XINT (pos), -1, 1, 0);
charpos = adjust_for_invis_intang (XFIXNUM (pos), -1, 1, 0);
}
}
@ -2026,18 +2026,18 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos)
enter_after = Qnil;
if (! EQ (leave_before, enter_before) && !NILP (leave_before))
call2 (leave_before, make_number (old_position),
make_number (charpos));
call2 (leave_before, make_fixnum (old_position),
make_fixnum (charpos));
if (! EQ (leave_after, enter_after) && !NILP (leave_after))
call2 (leave_after, make_number (old_position),
make_number (charpos));
call2 (leave_after, make_fixnum (old_position),
make_fixnum (charpos));
if (! EQ (enter_before, leave_before) && !NILP (enter_before))
call2 (enter_before, make_number (old_position),
make_number (charpos));
call2 (enter_before, make_fixnum (old_position),
make_fixnum (charpos));
if (! EQ (enter_after, leave_after) && !NILP (enter_after))
call2 (enter_after, make_number (old_position),
make_number (charpos));
call2 (enter_after, make_fixnum (old_position),
make_fixnum (charpos));
}
}
@ -2055,7 +2055,7 @@ move_if_not_intangible (ptrdiff_t position)
if (! NILP (Vinhibit_point_motion_hooks))
/* If intangible is inhibited, always move point to POSITION. */
;
else if (PT < position && XINT (pos) < ZV)
else if (PT < position && XFIXNUM (pos) < ZV)
{
/* We want to move forward, so check the text before POSITION. */
@ -2065,23 +2065,23 @@ move_if_not_intangible (ptrdiff_t position)
/* If following char is intangible,
skip back over all chars with matching intangible property. */
if (! NILP (intangible_propval))
while (XINT (pos) > BEGV
&& EQ (Fget_char_property (make_number (XINT (pos) - 1),
while (XFIXNUM (pos) > BEGV
&& EQ (Fget_char_property (make_fixnum (XFIXNUM (pos) - 1),
Qintangible, Qnil),
intangible_propval))
pos = Fprevious_char_property_change (pos, Qnil);
}
else if (XINT (pos) > BEGV)
else if (XFIXNUM (pos) > BEGV)
{
/* We want to move backward, so check the text after POSITION. */
intangible_propval = Fget_char_property (make_number (XINT (pos) - 1),
intangible_propval = Fget_char_property (make_fixnum (XFIXNUM (pos) - 1),
Qintangible, Qnil);
/* If following char is intangible,
skip forward over all chars with matching intangible property. */
if (! NILP (intangible_propval))
while (XINT (pos) < ZV
while (XFIXNUM (pos) < ZV
&& EQ (Fget_char_property (pos, Qintangible, Qnil),
intangible_propval))
pos = Fnext_char_property_change (pos, Qnil);
@ -2096,7 +2096,7 @@ move_if_not_intangible (ptrdiff_t position)
try moving to POSITION (which means we actually move farther
if POSITION is inside of intangible text). */
if (XINT (pos) != PT)
if (XFIXNUM (pos) != PT)
SET_PT (position);
}

12
src/json.c
View file

@ -289,8 +289,8 @@ json_parse_error (const json_error_t *error)
#endif
xsignal (symbol,
list5 (json_build_string (error->text),
json_build_string (error->source), make_natnum (error->line),
make_natnum (error->column), make_natnum (error->position)));
json_build_string (error->source), make_fixed_natnum (error->line),
make_fixed_natnum (error->column), make_fixed_natnum (error->position)));
}
static void
@ -487,10 +487,10 @@ lisp_to_json (Lisp_Object lisp, struct json_configuration *conf)
return json_check (json_false ());
else if (EQ (lisp, Qt))
return json_check (json_true ());
else if (INTEGERP (lisp))
else if (FIXNUMP (lisp))
{
CHECK_TYPE_RANGED_INTEGER (json_int_t, lisp);
return json_check (json_integer (XINT (lisp)));
return json_check (json_integer (XFIXNUM (lisp)));
}
else if (FLOATP (lisp))
return json_check (json_real (XFLOAT_DATA (lisp)));
@ -740,7 +740,7 @@ json_to_lisp (json_t *json, struct json_configuration *conf)
size_t size = json_array_size (json);
if (FIXNUM_OVERFLOW_P (size))
xsignal0 (Qoverflow_error);
Lisp_Object result = Fmake_vector (make_natnum (size), Qunbound);
Lisp_Object result = Fmake_vector (make_fixed_natnum (size), Qunbound);
for (ptrdiff_t i = 0; i < size; ++i)
ASET (result, i,
json_to_lisp (json_array_get (json, i), conf));
@ -760,7 +760,7 @@ json_to_lisp (json_t *json, struct json_configuration *conf)
if (FIXNUM_OVERFLOW_P (size))
xsignal0 (Qoverflow_error);
result = CALLN (Fmake_hash_table, QCtest, Qequal, QCsize,
make_natnum (size));
make_fixed_natnum (size));
struct Lisp_Hash_Table *h = XHASH_TABLE (result);
const char *key_str;
json_t *value;

372
src/keyboard.c
View file

File diff suppressed because it is too large Load diff

8
src/keyboard.h
View file

@ -391,7 +391,7 @@ extern void unuse_menu_items (void);
#define EVENT_END(event) (CAR_SAFE (CDR_SAFE (CDR_SAFE (event))))
/* Extract the click count from a multi-click event. */
#define EVENT_CLICK_COUNT(event) (Fnth (make_number (2), (event)))
#define EVENT_CLICK_COUNT(event) (Fnth (make_fixnum (2), (event)))
/* Extract the fields of a position. */
#define POSN_WINDOW(posn) (CAR_SAFE (posn))
@ -399,17 +399,17 @@ extern void unuse_menu_items (void);
#define POSN_SET_POSN(posn,x) (XSETCAR (XCDR (posn), (x)))
#define POSN_WINDOW_POSN(posn) (CAR_SAFE (CDR_SAFE (CDR_SAFE (posn))))
#define POSN_TIMESTAMP(posn) (CAR_SAFE (CDR_SAFE (CDR_SAFE (CDR_SAFE (posn)))))
#define POSN_SCROLLBAR_PART(posn) (Fnth (make_number (4), (posn)))
#define POSN_SCROLLBAR_PART(posn) (Fnth (make_fixnum (4), (posn)))
/* A cons (STRING . STRING-CHARPOS), or nil in mouse-click events.
It's a cons if the click is over a string in the mode line. */
#define POSN_STRING(posn) (Fnth (make_number (4), (posn)))
#define POSN_STRING(posn) (Fnth (make_fixnum (4), (posn)))
/* If POSN_STRING is nil, event refers to buffer location. */
#define POSN_INBUFFER_P(posn) (NILP (POSN_STRING (posn)))
#define POSN_BUFFER_POSN(posn) (Fnth (make_number (5), (posn)))
#define POSN_BUFFER_POSN(posn) (Fnth (make_fixnum (5), (posn)))
/* Getting the kind of an event head. */
#define EVENT_HEAD_KIND(event_head) \

218
src/keymap.c
View file

@ -159,7 +159,7 @@ in case you use it as a menu with `x-popup-menu'. */)
void
initial_define_key (Lisp_Object keymap, int key, const char *defname)
{
store_in_keymap (keymap, make_number (key), intern_c_string (defname));
store_in_keymap (keymap, make_fixnum (key), intern_c_string (defname));
}
void
@ -248,7 +248,7 @@ get_keymap (Lisp_Object object, bool error_if_not_keymap, bool autoload)
{
Lisp_Object tail;
tail = Fnth (make_number (4), tem);
tail = Fnth (make_fixnum (4), tem);
if (EQ (tail, Qkeymap))
{
if (autoload)
@ -379,28 +379,28 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
be put in the canonical order. */
if (SYMBOLP (idx))
idx = reorder_modifiers (idx);
else if (INTEGERP (idx))
else if (FIXNUMP (idx))
/* Clobber the high bits that can be present on a machine
with more than 24 bits of integer. */
XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
XSETFASTINT (idx, XFIXNUM (idx) & (CHAR_META | (CHAR_META - 1)));
/* Handle the special meta -> esc mapping. */
if (INTEGERP (idx) && XFASTINT (idx) & meta_modifier)
if (FIXNUMP (idx) && XFIXNAT (idx) & meta_modifier)
{
/* See if there is a meta-map. If there's none, there is
no binding for IDX, unless a default binding exists in MAP. */
Lisp_Object event_meta_binding, event_meta_map;
/* A strange value in which Meta is set would cause
infinite recursion. Protect against that. */
if (XINT (meta_prefix_char) & CHAR_META)
meta_prefix_char = make_number (27);
if (XFIXNUM (meta_prefix_char) & CHAR_META)
meta_prefix_char = make_fixnum (27);
event_meta_binding = access_keymap_1 (map, meta_prefix_char, t_ok,
noinherit, autoload);
event_meta_map = get_keymap (event_meta_binding, 0, autoload);
if (CONSP (event_meta_map))
{
map = event_meta_map;
idx = make_number (XFASTINT (idx) & ~meta_modifier);
idx = make_fixnum (XFIXNAT (idx) & ~meta_modifier);
}
else if (t_ok)
/* Set IDX to t, so that we only find a default binding. */
@ -473,15 +473,15 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx,
}
else if (VECTORP (binding))
{
if (INTEGERP (idx) && XFASTINT (idx) < ASIZE (binding))
val = AREF (binding, XFASTINT (idx));
if (FIXNUMP (idx) && XFIXNAT (idx) < ASIZE (binding))
val = AREF (binding, XFIXNAT (idx));
}
else if (CHAR_TABLE_P (binding))
{
/* Character codes with modifiers
are not included in a char-table.
All character codes without modifiers are included. */
if (INTEGERP (idx) && (XFASTINT (idx) & CHAR_MODIFIER_MASK) == 0)
if (FIXNUMP (idx) && (XFIXNAT (idx) & CHAR_MODIFIER_MASK) == 0)
{
val = Faref (binding, idx);
/* nil has a special meaning for char-tables, so
@ -567,7 +567,7 @@ map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val)
it in place. */
if (CONSP (key))
key = Fcons (XCAR (key), XCDR (key));
union map_keymap *md = XINTPTR (args);
union map_keymap *md = XFIXNUMPTR (args);
map_keymap_item (md->s.fun, md->s.args, key, val, md->s.data);
}
}
@ -782,10 +782,10 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
be put in the canonical order. */
if (SYMBOLP (idx))
idx = reorder_modifiers (idx);
else if (INTEGERP (idx))
else if (FIXNUMP (idx))
/* Clobber the high bits that can be present on a machine
with more than 24 bits of integer. */
XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
XSETFASTINT (idx, XFIXNUM (idx) & (CHAR_META | (CHAR_META - 1)));
/* Scan the keymap for a binding of idx. */
{
@ -807,22 +807,22 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
elt = XCAR (tail);
if (VECTORP (elt))
{
if (NATNUMP (idx) && XFASTINT (idx) < ASIZE (elt))
if (FIXNATP (idx) && XFIXNAT (idx) < ASIZE (elt))
{
CHECK_IMPURE (elt, XVECTOR (elt));
ASET (elt, XFASTINT (idx), def);
ASET (elt, XFIXNAT (idx), def);
return def;
}
else if (CONSP (idx) && CHARACTERP (XCAR (idx)))
{
int from = XFASTINT (XCAR (idx));
int to = XFASTINT (XCDR (idx));
int from = XFIXNAT (XCAR (idx));
int to = XFIXNAT (XCDR (idx));
if (to >= ASIZE (elt))
to = ASIZE (elt) - 1;
for (; from <= to; from++)
ASET (elt, from, def);
if (to == XFASTINT (XCDR (idx)))
if (to == XFIXNAT (XCDR (idx)))
/* We have defined all keys in IDX. */
return def;
}
@ -833,7 +833,7 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
/* Character codes with modifiers
are not included in a char-table.
All character codes without modifiers are included. */
if (NATNUMP (idx) && !(XFASTINT (idx) & CHAR_MODIFIER_MASK))
if (FIXNATP (idx) && !(XFIXNAT (idx) & CHAR_MODIFIER_MASK))
{
Faset (elt, idx,
/* nil has a special meaning for char-tables, so
@ -870,11 +870,11 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
&& CHARACTERP (XCAR (idx))
&& CHARACTERP (XCAR (elt)))
{
int from = XFASTINT (XCAR (idx));
int to = XFASTINT (XCDR (idx));
int from = XFIXNAT (XCAR (idx));
int to = XFIXNAT (XCDR (idx));
if (from <= XFASTINT (XCAR (elt))
&& to >= XFASTINT (XCAR (elt)))
if (from <= XFIXNAT (XCAR (elt))
&& to >= XFIXNAT (XCAR (elt)))
{
XSETCDR (elt, def);
if (from == to)
@ -1093,7 +1093,7 @@ binding KEY to DEF is added at the front of KEYMAP. */)
if (VECTORP (def) && ASIZE (def) > 0 && CONSP (AREF (def, 0)))
{ /* DEF is apparently an XEmacs-style keyboard macro. */
Lisp_Object tmp = Fmake_vector (make_number (ASIZE (def)), Qnil);
Lisp_Object tmp = Fmake_vector (make_fixnum (ASIZE (def)), Qnil);
ptrdiff_t i = ASIZE (def);
while (--i >= 0)
{
@ -1108,7 +1108,7 @@ binding KEY to DEF is added at the front of KEYMAP. */)
idx = 0;
while (1)
{
c = Faref (key, make_number (idx));
c = Faref (key, make_fixnum (idx));
if (CONSP (c))
{
@ -1123,8 +1123,8 @@ binding KEY to DEF is added at the front of KEYMAP. */)
if (SYMBOLP (c))
silly_event_symbol_error (c);
if (INTEGERP (c)
&& (XINT (c) & meta_bit)
if (FIXNUMP (c)
&& (XFIXNUM (c) & meta_bit)
&& !metized)
{
c = meta_prefix_char;
@ -1132,17 +1132,17 @@ binding KEY to DEF is added at the front of KEYMAP. */)
}
else
{
if (INTEGERP (c))
XSETINT (c, XINT (c) & ~meta_bit);
if (FIXNUMP (c))
XSETINT (c, XFIXNUM (c) & ~meta_bit);
metized = 0;
idx++;
}
if (!INTEGERP (c) && !SYMBOLP (c)
if (!FIXNUMP (c) && !SYMBOLP (c)
&& (!CONSP (c)
/* If C is a range, it must be a leaf. */
|| (INTEGERP (XCAR (c)) && idx != length)))
|| (FIXNUMP (XCAR (c)) && idx != length)))
message_with_string ("Key sequence contains invalid event %s", c, 1);
if (idx == length)
@ -1165,8 +1165,8 @@ binding KEY to DEF is added at the front of KEYMAP. */)
error; key might be a vector, not a string. */
error ("Key sequence %s starts with non-prefix key %s%s",
SDATA (Fkey_description (key, Qnil)),
SDATA (Fkey_description (Fsubstring (key, make_number (0),
make_number (idx)),
SDATA (Fkey_description (Fsubstring (key, make_fixnum (0),
make_fixnum (idx)),
Qnil)),
trailing_esc);
}
@ -1201,7 +1201,7 @@ remapping in all currently active keymaps. */)
else
command = Flookup_key (Fcons (Qkeymap, keymaps),
command_remapping_vector, Qnil);
return INTEGERP (command) ? Qnil : command;
return FIXNUMP (command) ? Qnil : command;
}
/* Value is number if KEY is too long; nil if valid but has no definition. */
@ -1240,18 +1240,18 @@ recognize the default bindings, just as `read-key-sequence' does. */)
idx = 0;
while (1)
{
c = Faref (key, make_number (idx++));
c = Faref (key, make_fixnum (idx++));
if (CONSP (c) && lucid_event_type_list_p (c))
c = Fevent_convert_list (c);
/* Turn the 8th bit of string chars into a meta modifier. */
if (STRINGP (key) && XINT (c) & 0x80 && !STRING_MULTIBYTE (key))
XSETINT (c, (XINT (c) | meta_modifier) & ~0x80);
if (STRINGP (key) && XFIXNUM (c) & 0x80 && !STRING_MULTIBYTE (key))
XSETINT (c, (XFIXNUM (c) | meta_modifier) & ~0x80);
/* Allow string since binding for `menu-bar-select-buffer'
includes the buffer name in the key sequence. */
if (!INTEGERP (c) && !SYMBOLP (c) && !CONSP (c) && !STRINGP (c))
if (!FIXNUMP (c) && !SYMBOLP (c) && !CONSP (c) && !STRINGP (c))
message_with_string ("Key sequence contains invalid event %s", c, 1);
cmd = access_keymap (keymap, c, t_ok, 0, 1);
@ -1260,7 +1260,7 @@ recognize the default bindings, just as `read-key-sequence' does. */)
keymap = get_keymap (cmd, 0, 1);
if (!CONSP (keymap))
return make_number (idx);
return make_fixnum (idx);
maybe_quit ();
}
@ -1300,7 +1300,7 @@ silly_event_symbol_error (Lisp_Object c)
int modifiers;
parsed = parse_modifiers (c);
modifiers = XFASTINT (XCAR (XCDR (parsed)));
modifiers = XFIXNAT (XCAR (XCDR (parsed)));
base = XCAR (parsed);
name = Fsymbol_name (base);
/* This alist includes elements such as ("RET" . "\\r"). */
@ -1474,7 +1474,7 @@ current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
static ptrdiff_t
click_position (Lisp_Object position)
{
EMACS_INT pos = (INTEGERP (position) ? XINT (position)
EMACS_INT pos = (FIXNUMP (position) ? XFIXNUM (position)
: MARKERP (position) ? marker_position (position)
: PT);
if (! (BEGV <= pos && pos <= ZV))
@ -1552,13 +1552,13 @@ like in the respective argument of `key-binding'. */)
Lisp_Object pos;
pos = POSN_BUFFER_POSN (position);
if (INTEGERP (pos)
&& XINT (pos) >= BEG && XINT (pos) <= Z)
if (FIXNUMP (pos)
&& XFIXNUM (pos) >= BEG && XFIXNUM (pos) <= Z)
{
local_map = get_local_map (XINT (pos),
local_map = get_local_map (XFIXNUM (pos),
current_buffer, Qlocal_map);
keymap = get_local_map (XINT (pos),
keymap = get_local_map (XFIXNUM (pos),
current_buffer, Qkeymap);
}
}
@ -1575,9 +1575,9 @@ like in the respective argument of `key-binding'. */)
pos = XCDR (string);
string = XCAR (string);
if (INTEGERP (pos)
&& XINT (pos) >= 0
&& XINT (pos) < SCHARS (string))
if (FIXNUMP (pos)
&& XFIXNUM (pos) >= 0
&& XFIXNUM (pos) < SCHARS (string))
{
map = Fget_text_property (pos, Qlocal_map, string);
if (!NILP (map))
@ -1667,7 +1667,7 @@ specified buffer position instead of point are used.
value = Flookup_key (Fcons (Qkeymap, Fcurrent_active_maps (Qt, position)),
key, accept_default);
if (NILP (value) || INTEGERP (value))
if (NILP (value) || FIXNUMP (value))
return Qnil;
/* If the result of the ordinary keymap lookup is an interactive
@ -1745,7 +1745,7 @@ bindings; see the description of `lookup-key' for more details about this. */)
for (i = j = 0; i < nmaps; i++)
if (!NILP (maps[i])
&& !NILP (binding = Flookup_key (maps[i], key, accept_default))
&& !INTEGERP (binding))
&& !FIXNUMP (binding))
{
if (KEYMAPP (binding))
maps[j++] = Fcons (modes[i], binding);
@ -1843,7 +1843,7 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *
Lisp_Object maps = d->maps;
Lisp_Object tail = d->tail;
Lisp_Object thisseq = d->thisseq;
bool is_metized = d->is_metized && INTEGERP (key);
bool is_metized = d->is_metized && FIXNUMP (key);
Lisp_Object tem;
cmd = get_keymap (get_keyelt (cmd, 0), 0, 0);
@ -1854,12 +1854,12 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *
while (!NILP (tem = Frassq (cmd, maps)))
{
Lisp_Object prefix = XCAR (tem);
ptrdiff_t lim = XINT (Flength (XCAR (tem)));
if (lim <= XINT (Flength (thisseq)))
ptrdiff_t lim = XFIXNUM (Flength (XCAR (tem)));
if (lim <= XFIXNUM (Flength (thisseq)))
{ /* This keymap was already seen with a smaller prefix. */
ptrdiff_t i = 0;
while (i < lim && EQ (Faref (prefix, make_number (i)),
Faref (thisseq, make_number (i))))
while (i < lim && EQ (Faref (prefix, make_fixnum (i)),
Faref (thisseq, make_fixnum (i))))
i++;
if (i >= lim)
/* `prefix' is a prefix of `thisseq' => there's a cycle. */
@ -1879,10 +1879,10 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *
if (is_metized)
{
int meta_bit = meta_modifier;
Lisp_Object last = make_number (XINT (Flength (thisseq)) - 1);
Lisp_Object last = make_fixnum (XFIXNUM (Flength (thisseq)) - 1);
tem = Fcopy_sequence (thisseq);
Faset (tem, last, make_number (XINT (key) | meta_bit));
Faset (tem, last, make_fixnum (XFIXNUM (key) | meta_bit));
/* This new sequence is the same length as
thisseq, so stick it in the list right
@ -1910,7 +1910,7 @@ then the value includes only maps for prefixes that start with PREFIX. */)
(Lisp_Object keymap, Lisp_Object prefix)
{
Lisp_Object maps, tail;
EMACS_INT prefixlen = XFASTINT (Flength (prefix));
EMACS_INT prefixlen = XFIXNAT (Flength (prefix));
if (!NILP (prefix))
{
@ -1933,7 +1933,7 @@ then the value includes only maps for prefixes that start with PREFIX. */)
int i, i_byte, c;
Lisp_Object copy;
copy = Fmake_vector (make_number (SCHARS (prefix)), Qnil);
copy = Fmake_vector (make_fixnum (SCHARS (prefix)), Qnil);
for (i = 0, i_byte = 0; i < SCHARS (prefix);)
{
int i_before = i;
@ -1941,7 +1941,7 @@ then the value includes only maps for prefixes that start with PREFIX. */)
FETCH_STRING_CHAR_ADVANCE (c, prefix, i, i_byte);
if (SINGLE_BYTE_CHAR_P (c) && (c & 0200))
c ^= 0200 | meta_modifier;
ASET (copy, i_before, make_number (c));
ASET (copy, i_before, make_fixnum (c));
}
prefix = copy;
}
@ -1969,11 +1969,11 @@ then the value includes only maps for prefixes that start with PREFIX. */)
data.thisseq = Fcar (XCAR (tail));
data.maps = maps;
data.tail = tail;
last = make_number (XINT (Flength (data.thisseq)) - 1);
last = make_fixnum (XFIXNUM (Flength (data.thisseq)) - 1);
/* Does the current sequence end in the meta-prefix-char? */
data.is_metized = (XINT (last) >= 0
data.is_metized = (XFIXNUM (last) >= 0
/* Don't metize the last char of PREFIX. */
&& XINT (last) >= prefixlen
&& XFIXNUM (last) >= prefixlen
&& EQ (Faref (data.thisseq, last), meta_prefix_char));
/* Since we can't run lisp code, we can't scan autoloaded maps. */
@ -1997,7 +1997,7 @@ For an approximate inverse of this, see `kbd'. */)
EMACS_INT i;
ptrdiff_t i_byte;
Lisp_Object *args;
EMACS_INT size = XINT (Flength (keys));
EMACS_INT size = XFIXNUM (Flength (keys));
Lisp_Object list;
Lisp_Object sep = build_string (" ");
Lisp_Object key;
@ -2006,7 +2006,7 @@ For an approximate inverse of this, see `kbd'. */)
USE_SAFE_ALLOCA;
if (!NILP (prefix))
size += XINT (Flength (prefix));
size += XFIXNUM (Flength (prefix));
/* This has one extra element at the end that we don't pass to Fconcat. */
EMACS_INT size4;
@ -2043,7 +2043,7 @@ For an approximate inverse of this, see `kbd'. */)
else if (VECTORP (list))
size = ASIZE (list);
else if (CONSP (list))
size = XINT (Flength (list));
size = XFIXNUM (Flength (list));
else
wrong_type_argument (Qarrayp, list);
@ -2072,9 +2072,9 @@ For an approximate inverse of this, see `kbd'. */)
if (add_meta)
{
if (!INTEGERP (key)
if (!FIXNUMP (key)
|| EQ (key, meta_prefix_char)
|| (XINT (key) & meta_modifier))
|| (XFIXNUM (key) & meta_modifier))
{
args[len++] = Fsingle_key_description (meta_prefix_char, Qnil);
args[len++] = sep;
@ -2082,7 +2082,7 @@ For an approximate inverse of this, see `kbd'. */)
continue;
}
else
XSETINT (key, XINT (key) | meta_modifier);
XSETINT (key, XFIXNUM (key) | meta_modifier);
add_meta = 0;
}
else if (EQ (key, meta_prefix_char))
@ -2108,7 +2108,7 @@ push_key_description (EMACS_INT ch, char *p)
c2 = c & ~(alt_modifier | ctrl_modifier | hyper_modifier
| meta_modifier | shift_modifier | super_modifier);
if (! CHARACTERP (make_number (c2)))
if (! CHARACTERP (make_fixnum (c2)))
{
/* KEY_DESCRIPTION_SIZE is large enough for this. */
p += sprintf (p, "[%d]", c);
@ -2226,7 +2226,7 @@ around function keys and event symbols. */)
if (CONSP (key) && lucid_event_type_list_p (key))
key = Fevent_convert_list (key);
if (CONSP (key) && INTEGERP (XCAR (key)) && INTEGERP (XCDR (key)))
if (CONSP (key) && FIXNUMP (XCAR (key)) && FIXNUMP (XCDR (key)))
/* An interval from a map-char-table. */
{
AUTO_STRING (dot_dot, "..");
@ -2237,10 +2237,10 @@ around function keys and event symbols. */)
key = EVENT_HEAD (key);
if (INTEGERP (key)) /* Normal character. */
if (FIXNUMP (key)) /* Normal character. */
{
char tem[KEY_DESCRIPTION_SIZE];
char *p = push_key_description (XINT (key), tem);
char *p = push_key_description (XFIXNUM (key), tem);
*p = 0;
return make_specified_string (tem, -1, p - tem, 1);
}
@ -2306,7 +2306,7 @@ See Info node `(elisp)Describing Characters' for examples. */)
CHECK_CHARACTER (character);
c = XINT (character);
c = XFIXNUM (character);
if (!ASCII_CHAR_P (c))
{
int len = CHAR_STRING (c, (unsigned char *) str);
@ -2328,7 +2328,7 @@ static int
preferred_sequence_p (Lisp_Object seq)
{
EMACS_INT i;
EMACS_INT len = XFASTINT (Flength (seq));
EMACS_INT len = XFIXNAT (Flength (seq));
int result = 1;
for (i = 0; i < len; i++)
@ -2338,11 +2338,11 @@ preferred_sequence_p (Lisp_Object seq)
XSETFASTINT (ii, i);
elt = Faref (seq, ii);
if (!INTEGERP (elt))
if (!FIXNUMP (elt))
return 0;
else
{
int modifiers = XINT (elt) & (CHAR_MODIFIER_MASK & ~CHAR_META);
int modifiers = XFIXNUM (elt) & (CHAR_MODIFIER_MASK & ~CHAR_META);
if (modifiers == where_is_preferred_modifier)
result = 2;
else if (modifiers)
@ -2373,10 +2373,10 @@ shadow_lookup (Lisp_Object shadow, Lisp_Object key, Lisp_Object flag,
for (tail = shadow; CONSP (tail); tail = XCDR (tail))
{
value = Flookup_key (XCAR (tail), key, flag);
if (NATNUMP (value))
if (FIXNATP (value))
{
value = Flookup_key (XCAR (tail),
Fsubstring (key, make_number (0), value), flag);
Fsubstring (key, make_fixnum (0), value), flag);
if (!NILP (value))
return Qnil;
}
@ -2463,13 +2463,13 @@ where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
this = Fcar (XCAR (maps));
map = Fcdr (XCAR (maps));
last = make_number (XINT (Flength (this)) - 1);
last_is_meta = (XINT (last) >= 0
last = make_fixnum (XFIXNUM (Flength (this)) - 1);
last_is_meta = (XFIXNUM (last) >= 0
&& EQ (Faref (this, last), meta_prefix_char));
/* if (nomenus && !preferred_sequence_p (this)) */
if (nomenus && XINT (last) >= 0
&& SYMBOLP (tem = Faref (this, make_number (0)))
if (nomenus && XFIXNUM (last) >= 0
&& SYMBOLP (tem = Faref (this, make_fixnum (0)))
&& !NILP (Fmemq (XCAR (parse_modifiers (tem)), Vmouse_events)))
/* If no menu entries should be returned, skip over the
keymaps bound to `menu-bar' and `tool-bar' and other
@ -2646,9 +2646,9 @@ The optional 5th arg NO-REMAP alters how command remapping is handled:
if (! NILP (sequence))
{
Lisp_Object tem1;
tem1 = Faref (sequence, make_number (ASIZE (sequence) - 1));
tem1 = Faref (sequence, make_fixnum (ASIZE (sequence) - 1));
if (STRINGP (tem1))
Faset (sequence, make_number (ASIZE (sequence) - 1),
Faset (sequence, make_fixnum (ASIZE (sequence) - 1),
build_string ("(any string)"));
}
@ -2717,10 +2717,10 @@ where_is_internal_1 (Lisp_Object key, Lisp_Object binding, Lisp_Object args, voi
return;
/* We have found a match. Construct the key sequence where we found it. */
if (INTEGERP (key) && last_is_meta)
if (FIXNUMP (key) && last_is_meta)
{
sequence = Fcopy_sequence (this);
Faset (sequence, last, make_number (XINT (key) | meta_modifier));
Faset (sequence, last, make_fixnum (XFIXNUM (key) | meta_modifier));
}
else
{
@ -2786,7 +2786,7 @@ You type Translation\n\
bufend = push_key_description (translate[c], buf);
insert (buf, bufend - buf);
Findent_to (make_number (16), make_number (1));
Findent_to (make_fixnum (16), make_fixnum (1));
bufend = push_key_description (c, buf);
insert (buf, bufend - buf);
@ -2962,7 +2962,7 @@ key binding\n\
elt_prefix = Fcar (elt);
if (ASIZE (elt_prefix) >= 1)
{
tem = Faref (elt_prefix, make_number (0));
tem = Faref (elt_prefix, make_fixnum (0));
if (EQ (tem, Qmenu_bar))
maps = Fdelq (elt, maps);
}
@ -3011,7 +3011,7 @@ key binding\n\
else
{
shmap = Flookup_key (shmap, Fcar (elt), Qt);
if (INTEGERP (shmap))
if (FIXNUMP (shmap))
shmap = Qnil;
}
@ -3066,7 +3066,7 @@ describe_command (Lisp_Object definition, Lisp_Object args)
else
description_column = 16;
Findent_to (make_number (description_column), make_number (1));
Findent_to (make_fixnum (description_column), make_fixnum (1));
previous_description_column = description_column;
if (SYMBOLP (definition))
@ -3088,7 +3088,7 @@ describe_translation (Lisp_Object definition, Lisp_Object args)
{
register Lisp_Object tem1;
Findent_to (make_number (16), make_number (1));
Findent_to (make_fixnum (16), make_fixnum (1));
if (SYMBOLP (definition))
{
@ -3125,12 +3125,12 @@ static int
describe_map_compare (const void *aa, const void *bb)
{
const struct describe_map_elt *a = aa, *b = bb;
if (INTEGERP (a->event) && INTEGERP (b->event))
return ((XINT (a->event) > XINT (b->event))
- (XINT (a->event) < XINT (b->event)));
if (!INTEGERP (a->event) && INTEGERP (b->event))
if (FIXNUMP (a->event) && FIXNUMP (b->event))
return ((XFIXNUM (a->event) > XFIXNUM (b->event))
- (XFIXNUM (a->event) < XFIXNUM (b->event)));
if (!FIXNUMP (a->event) && FIXNUMP (b->event))
return 1;
if (INTEGERP (a->event) && !INTEGERP (b->event))
if (FIXNUMP (a->event) && !FIXNUMP (b->event))
return -1;
if (SYMBOLP (a->event) && SYMBOLP (b->event))
return (!NILP (Fstring_lessp (a->event, b->event)) ? -1
@ -3170,7 +3170,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
/* This vector gets used to present single keys to Flookup_key. Since
that is done once per keymap element, we don't want to cons up a
fresh vector every time. */
kludge = Fmake_vector (make_number (1), Qnil);
kludge = Fmake_vector (make_fixnum (1), Qnil);
definition = Qnil;
map = call1 (Qkeymap_canonicalize, map);
@ -3198,7 +3198,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
/* Ignore bindings whose "prefix" are not really valid events.
(We get these in the frames and buffers menu.) */
if (!(SYMBOLP (event) || INTEGERP (event)))
if (!(SYMBOLP (event) || FIXNUMP (event)))
continue;
if (nomenu && EQ (event, Qmenu_bar))
@ -3282,10 +3282,10 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
definition = vect[i].definition;
/* Find consecutive chars that are identically defined. */
if (INTEGERP (vect[i].event))
if (FIXNUMP (vect[i].event))
{
while (i + 1 < slots_used
&& EQ (vect[i+1].event, make_number (XINT (vect[i].event) + 1))
&& EQ (vect[i+1].event, make_fixnum (XFIXNUM (vect[i].event) + 1))
&& !NILP (Fequal (vect[i + 1].definition, definition))
&& vect[i].shadowed == vect[i + 1].shadowed)
i++;
@ -3328,7 +3328,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
static void
describe_vector_princ (Lisp_Object elt, Lisp_Object fun)
{
Findent_to (make_number (16), make_number (1));
Findent_to (make_fixnum (16), make_fixnum (1));
call1 (fun, elt);
Fterpri (Qnil, Qnil);
}
@ -3407,7 +3407,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
if (!keymap_p)
{
/* Call Fkey_description first, to avoid GC bug for the other string. */
if (!NILP (prefix) && XFASTINT (Flength (prefix)) > 0)
if (!NILP (prefix) && XFIXNAT (Flength (prefix)) > 0)
{
Lisp_Object tem = Fkey_description (prefix, Qnil);
AUTO_STRING (space, " ");
@ -3419,7 +3419,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
/* This vector gets used to present single keys to Flookup_key. Since
that is done once per vector element, we don't want to cons up a
fresh vector every time. */
kludge = Fmake_vector (make_number (1), Qnil);
kludge = Fmake_vector (make_fixnum (1), Qnil);
if (partial)
suppress = intern ("suppress-keymap");
@ -3469,7 +3469,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
if (!NILP (tem)) continue;
}
character = make_number (starting_i);
character = make_fixnum (starting_i);
ASET (kludge, 0, character);
/* If this binding is shadowed by some other map, ignore it. */
@ -3541,7 +3541,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
{
insert (" .. ", 4);
ASET (kludge, 0, make_number (i));
ASET (kludge, 0, make_fixnum (i));
if (!NILP (elt_prefix))
insert1 (elt_prefix);
@ -3618,7 +3618,7 @@ syms_of_keymap (void)
/* Now we are ready to set up this property, so we can
create char tables. */
Fput (Qkeymap, Qchar_table_extra_slots, make_number (0));
Fput (Qkeymap, Qchar_table_extra_slots, make_fixnum (0));
/* Initialize the keymaps standardly used.
Each one is the value of a Lisp variable, and is also
@ -3719,7 +3719,7 @@ be preferred. */);
DEFSYM (Qremap, "remap");
DEFSYM (QCadvertised_binding, ":advertised-binding");
command_remapping_vector = Fmake_vector (make_number (2), Qremap);
command_remapping_vector = Fmake_vector (make_fixnum (2), Qremap);
staticpro (&command_remapping_vector);
where_is_cache_keymaps = Qt;

40
src/kqueue.c
View file

@ -55,15 +55,15 @@ kqueue_directory_listing (Lisp_Object directory_files)
result = Fcons
(list5 (/* inode. */
Fnth (make_number (11), XCAR (dl)),
Fnth (make_fixnum (11), XCAR (dl)),
/* filename. */
XCAR (XCAR (dl)),
/* last modification time. */
Fnth (make_number (6), XCAR (dl)),
Fnth (make_fixnum (6), XCAR (dl)),
/* last status change time. */
Fnth (make_number (7), XCAR (dl)),
Fnth (make_fixnum (7), XCAR (dl)),
/* size. */
Fnth (make_number (8), XCAR (dl))),
Fnth (make_fixnum (8), XCAR (dl))),
result);
}
return result;
@ -78,7 +78,7 @@ kqueue_generate_event (Lisp_Object watch_object, Lisp_Object actions,
struct input_event event;
/* Check, whether all actions shall be monitored. */
flags = Fnth (make_number (2), watch_object);
flags = Fnth (make_fixnum (2), watch_object);
action = actions;
do {
if (NILP (action))
@ -101,7 +101,7 @@ kqueue_generate_event (Lisp_Object watch_object, Lisp_Object actions,
NILP (file1)
? Fcons (file, Qnil)
: list2 (file, file1))),
Fnth (make_number (3), watch_object));
Fnth (make_fixnum (3), watch_object));
kbd_buffer_store_event (&event);
}
}
@ -121,7 +121,7 @@ kqueue_compare_dir_list (Lisp_Object watch_object)
pending_dl = Qnil;
deleted_dl = Qnil;
old_directory_files = Fnth (make_number (4), watch_object);
old_directory_files = Fnth (make_fixnum (4), watch_object);
old_dl = kqueue_directory_listing (old_directory_files);
/* When the directory is not accessible anymore, it has been deleted. */
@ -155,14 +155,14 @@ kqueue_compare_dir_list (Lisp_Object watch_object)
if (strcmp (SSDATA (XCAR (XCDR (old_entry))),
SSDATA (XCAR (XCDR (new_entry)))) == 0) {
/* Modification time has been changed, the file has been written. */
if (NILP (Fequal (Fnth (make_number (2), old_entry),
Fnth (make_number (2), new_entry))))
if (NILP (Fequal (Fnth (make_fixnum (2), old_entry),
Fnth (make_fixnum (2), new_entry))))
kqueue_generate_event
(watch_object, Fcons (Qwrite, Qnil), XCAR (XCDR (old_entry)), Qnil);
/* Status change time has been changed, the file attributes
have changed. */
if (NILP (Fequal (Fnth (make_number (3), old_entry),
Fnth (make_number (3), new_entry))))
if (NILP (Fequal (Fnth (make_fixnum (3), old_entry),
Fnth (make_fixnum (3), new_entry))))
kqueue_generate_event
(watch_object, Fcons (Qattrib, Qnil),
XCAR (XCDR (old_entry)), Qnil);
@ -233,8 +233,8 @@ kqueue_compare_dir_list (Lisp_Object watch_object)
(watch_object, Fcons (Qcreate, Qnil), XCAR (XCDR (entry)), Qnil);
/* Check size of that file. */
Lisp_Object size = Fnth (make_number (4), entry);
if (FLOATP (size) || (XINT (size) > 0))
Lisp_Object size = Fnth (make_fixnum (4), entry);
if (FLOATP (size) || (XFIXNUM (size) > 0))
kqueue_generate_event
(watch_object, Fcons (Qwrite, Qnil), XCAR (XCDR (entry)), Qnil);
@ -270,7 +270,7 @@ kqueue_compare_dir_list (Lisp_Object watch_object)
report_file_error ("Pending events list not empty", pending_dl);
/* Replace old directory listing with the new one. */
XSETCDR (Fnthcdr (make_number (3), watch_object),
XSETCDR (Fnthcdr (make_fixnum (3), watch_object),
Fcons (new_directory_files, Qnil));
return;
}
@ -293,7 +293,7 @@ kqueue_callback (int fd, void *data)
}
/* Determine descriptor and file name. */
descriptor = make_number (kev.ident);
descriptor = make_fixnum (kev.ident);
watch_object = assq_no_quit (descriptor, watch_list);
if (CONSP (watch_object))
file = XCAR (XCDR (watch_object));
@ -306,7 +306,7 @@ kqueue_callback (int fd, void *data)
actions = Fcons (Qdelete, actions);
if (kev.fflags & NOTE_WRITE) {
/* Check, whether this is a directory event. */
if (NILP (Fnth (make_number (4), watch_object)))
if (NILP (Fnth (make_fixnum (4), watch_object)))
actions = Fcons (Qwrite, actions);
else
kqueue_compare_dir_list (watch_object);
@ -395,7 +395,7 @@ only when the upper directory of the renamed file is watched. */)
maxfd = 256;
/* We assume 50 file descriptors are sufficient for the rest of Emacs. */
if ((maxfd - 50) < XINT (Flength (watch_list)))
if ((maxfd - 50) < XFIXNUM (Flength (watch_list)))
xsignal2
(Qfile_notify_error,
build_string ("File watching not possible, no file descriptor left"),
@ -449,7 +449,7 @@ only when the upper directory of the renamed file is watched. */)
}
/* Store watch object in watch list. */
Lisp_Object watch_descriptor = make_number (fd);
Lisp_Object watch_descriptor = make_fixnum (fd);
if (NILP (Ffile_directory_p (file)))
watch_object = list4 (watch_descriptor, file, flags, callback);
else {
@ -473,8 +473,8 @@ WATCH-DESCRIPTOR should be an object returned by `kqueue-add-watch'. */)
xsignal2 (Qfile_notify_error, build_string ("Not a watch descriptor"),
watch_descriptor);
eassert (INTEGERP (watch_descriptor));
int fd = XINT (watch_descriptor);
eassert (FIXNUMP (watch_descriptor));
int fd = XFIXNUM (watch_descriptor);
if ( fd >= 0)
emacs_close (fd);

22
src/lcms.c
View file

@ -92,7 +92,7 @@ static bool
parse_lab_list (Lisp_Object lab_list, cmsCIELab *color)
{
#define PARSE_LAB_LIST_FIELD(field) \
if (CONSP (lab_list) && NUMBERP (XCAR (lab_list))) \
if (CONSP (lab_list) && FIXED_OR_FLOATP (XCAR (lab_list))) \
{ \
color->field = XFLOATINT (XCAR (lab_list)); \
lab_list = XCDR (lab_list); \
@ -137,15 +137,15 @@ chroma, and hue, respectively. The parameters each default to 1. */)
signal_error ("Invalid color", color1);
if (NILP (kL))
Kl = 1.0f;
else if (!(NUMBERP (kL) && (Kl = XFLOATINT(kL))))
else if (!(FIXED_OR_FLOATP (kL) && (Kl = XFLOATINT(kL))))
wrong_type_argument(Qnumberp, kL);
if (NILP (kC))
Kc = 1.0f;
else if (!(NUMBERP (kC) && (Kc = XFLOATINT(kC))))
else if (!(FIXED_OR_FLOATP (kC) && (Kc = XFLOATINT(kC))))
wrong_type_argument(Qnumberp, kC);
if (NILP (kL))
Kh = 1.0f;
else if (!(NUMBERP (kH) && (Kh = XFLOATINT(kH))))
else if (!(FIXED_OR_FLOATP (kH) && (Kh = XFLOATINT(kH))))
wrong_type_argument(Qnumberp, kH);
return make_float (cmsCIE2000DeltaE (&Lab1, &Lab2, Kl, Kc, Kh));
@ -183,7 +183,7 @@ static bool
parse_xyz_list (Lisp_Object xyz_list, cmsCIEXYZ *color)
{
#define PARSE_XYZ_LIST_FIELD(field) \
if (CONSP (xyz_list) && NUMBERP (XCAR (xyz_list))) \
if (CONSP (xyz_list) && FIXED_OR_FLOATP (XCAR (xyz_list))) \
{ \
color->field = 100.0 * XFLOATINT (XCAR (xyz_list)); \
xyz_list = XCDR (xyz_list); \
@ -202,7 +202,7 @@ static bool
parse_jch_list (Lisp_Object jch_list, cmsJCh *color)
{
#define PARSE_JCH_LIST_FIELD(field) \
if (CONSP (jch_list) && NUMBERP (XCAR (jch_list))) \
if (CONSP (jch_list) && FIXED_OR_FLOATP (XCAR (jch_list))) \
{ \
color->field = XFLOATINT (XCAR (jch_list)); \
jch_list = XCDR (jch_list); \
@ -223,7 +223,7 @@ static bool
parse_jab_list (Lisp_Object jab_list, lcmsJab_t *color)
{
#define PARSE_JAB_LIST_FIELD(field) \
if (CONSP (jab_list) && NUMBERP (XCAR (jab_list))) \
if (CONSP (jab_list) && FIXED_OR_FLOATP (XCAR (jab_list))) \
{ \
color->field = XFLOATINT (XCAR (jab_list)); \
jab_list = XCDR (jab_list); \
@ -243,7 +243,7 @@ parse_viewing_conditions (Lisp_Object view, const cmsCIEXYZ *wp,
cmsViewingConditions *vc)
{
#define PARSE_VIEW_CONDITION_FLOAT(field) \
if (CONSP (view) && NUMBERP (XCAR (view))) \
if (CONSP (view) && FIXED_OR_FLOATP (XCAR (view))) \
{ \
vc->field = XFLOATINT (XCAR (view)); \
view = XCDR (view); \
@ -251,10 +251,10 @@ parse_viewing_conditions (Lisp_Object view, const cmsCIEXYZ *wp,
else \
return false;
#define PARSE_VIEW_CONDITION_INT(field) \
if (CONSP (view) && NATNUMP (XCAR (view))) \
if (CONSP (view) && FIXNATP (XCAR (view))) \
{ \
CHECK_RANGED_INTEGER (XCAR (view), 1, 4); \
vc->field = XINT (XCAR (view)); \
vc->field = XFIXNUM (XCAR (view)); \
view = XCDR (view); \
} \
else \
@ -554,7 +554,7 @@ Valid range of TEMPERATURE is from 4000K to 25000K. */)
}
#endif
CHECK_NUMBER_OR_FLOAT (temperature);
CHECK_FIXNUM_OR_FLOAT (temperature);
tempK = XFLOATINT (temperature);
if (!(cmsWhitePointFromTemp (&whitepoint, tempK)))

255
src/lisp.h
View file

@ -30,6 +30,11 @@ along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
#include <float.h>
#include <inttypes.h>
#include <limits.h>
#ifdef HAVE_GMP
#include <gmp.h>
#else
#include "mini-gmp.h"
#endif
#include <intprops.h>
#include <verify.h>
@ -352,14 +357,14 @@ typedef EMACS_INT Lisp_Word;
# endif
#endif
#define lisp_h_CHECK_NUMBER(x) CHECK_TYPE (INTEGERP (x), Qintegerp, x)
#define lisp_h_CHECK_FIXNUM(x) CHECK_TYPE (FIXNUMP (x), Qfixnump, x)
#define lisp_h_CHECK_SYMBOL(x) CHECK_TYPE (SYMBOLP (x), Qsymbolp, x)
#define lisp_h_CHECK_TYPE(ok, predicate, x) \
((ok) ? (void) 0 : wrong_type_argument (predicate, x))
#define lisp_h_CONSP(x) (XTYPE (x) == Lisp_Cons)
#define lisp_h_EQ(x, y) (XLI (x) == XLI (y))
#define lisp_h_FLOATP(x) (XTYPE (x) == Lisp_Float)
#define lisp_h_INTEGERP(x) ((XTYPE (x) & (Lisp_Int0 | ~Lisp_Int1)) == Lisp_Int0)
#define lisp_h_FIXNUMP(x) ((XTYPE (x) & (Lisp_Int0 | ~Lisp_Int1)) == Lisp_Int0)
#define lisp_h_MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
#define lisp_h_MISCP(x) (XTYPE (x) == Lisp_Misc)
#define lisp_h_NILP(x) EQ (x, Qnil)
@ -377,15 +382,15 @@ typedef EMACS_INT Lisp_Word;
#define lisp_h_XCDR(c) XCONS (c)->u.s.u.cdr
#define lisp_h_XCONS(a) \
(eassert (CONSP (a)), XUNTAG (a, Lisp_Cons, struct Lisp_Cons))
#define lisp_h_XHASH(a) XUINT (a)
#define lisp_h_XHASH(a) XUFIXNUM (a)
#ifndef GC_CHECK_CONS_LIST
# define lisp_h_check_cons_list() ((void) 0)
#endif
#if USE_LSB_TAG
# define lisp_h_make_number(n) \
# define lisp_h_make_fixnum(n) \
XIL ((EMACS_INT) (((EMACS_UINT) (n) << INTTYPEBITS) + Lisp_Int0))
# define lisp_h_XFASTINT(a) XINT (a)
# define lisp_h_XINT(a) (XLI (a) >> INTTYPEBITS)
# define lisp_h_XFIXNAT(a) XFIXNUM (a)
# define lisp_h_XFIXNUM(a) (XLI (a) >> INTTYPEBITS)
# ifdef __CHKP__
# define lisp_h_XSYMBOL(a) \
(eassert (SYMBOLP (a)), \
@ -418,13 +423,13 @@ typedef EMACS_INT Lisp_Word;
# define XIL(i) lisp_h_XIL (i)
# define XLP(o) lisp_h_XLP (o)
# define XPL(p) lisp_h_XPL (p)
# define CHECK_NUMBER(x) lisp_h_CHECK_NUMBER (x)
# define CHECK_FIXNUM(x) lisp_h_CHECK_FIXNUM (x)
# define CHECK_SYMBOL(x) lisp_h_CHECK_SYMBOL (x)
# define CHECK_TYPE(ok, predicate, x) lisp_h_CHECK_TYPE (ok, predicate, x)
# define CONSP(x) lisp_h_CONSP (x)
# define EQ(x, y) lisp_h_EQ (x, y)
# define FLOATP(x) lisp_h_FLOATP (x)
# define INTEGERP(x) lisp_h_INTEGERP (x)
# define FIXNUMP(x) lisp_h_FIXNUMP (x)
# define MARKERP(x) lisp_h_MARKERP (x)
# define MISCP(x) lisp_h_MISCP (x)
# define NILP(x) lisp_h_NILP (x)
@ -442,9 +447,9 @@ typedef EMACS_INT Lisp_Word;
# define check_cons_list() lisp_h_check_cons_list ()
# endif
# if USE_LSB_TAG
# define make_number(n) lisp_h_make_number (n)
# define XFASTINT(a) lisp_h_XFASTINT (a)
# define XINT(a) lisp_h_XINT (a)
# define make_fixnum(n) lisp_h_make_fixnum (n)
# define XFIXNAT(a) lisp_h_XFIXNAT (a)
# define XFIXNUM(a) lisp_h_XFIXNUM (a)
# define XSYMBOL(a) lisp_h_XSYMBOL (a)
# define XTYPE(a) lisp_h_XTYPE (a)
# endif
@ -481,7 +486,7 @@ enum Lisp_Type
whose first member indicates the subtype. */
Lisp_Misc = 1,
/* Integer. XINT (obj) is the integer value. */
/* Integer. XFIXNUM (obj) is the integer value. */
Lisp_Int0 = 2,
Lisp_Int1 = USE_LSB_TAG ? 6 : 3,
@ -516,6 +521,7 @@ enum Lisp_Misc_Type
#ifdef HAVE_MODULES
Lisp_Misc_User_Ptr,
#endif
Lisp_Misc_Bignum,
/* This is not a type code. It is for range checking. */
Lisp_Misc_Limit
};
@ -1026,21 +1032,21 @@ enum More_Lisp_Bits
#if USE_LSB_TAG
INLINE Lisp_Object
(make_number) (EMACS_INT n)
(make_fixnum) (EMACS_INT n)
{
return lisp_h_make_number (n);
return lisp_h_make_fixnum (n);
}
INLINE EMACS_INT
(XINT) (Lisp_Object a)
(XFIXNUM) (Lisp_Object a)
{
return lisp_h_XINT (a);
return lisp_h_XFIXNUM (a);
}
INLINE EMACS_INT
(XFASTINT) (Lisp_Object a)
(XFIXNAT) (Lisp_Object a)
{
EMACS_INT n = lisp_h_XFASTINT (a);
EMACS_INT n = lisp_h_XFIXNAT (a);
eassume (0 <= n);
return n;
}
@ -1054,7 +1060,7 @@ INLINE EMACS_INT
/* Make a Lisp integer representing the value of the low order
bits of N. */
INLINE Lisp_Object
make_number (EMACS_INT n)
make_fixnum (EMACS_INT n)
{
EMACS_INT int0 = Lisp_Int0;
if (USE_LSB_TAG)
@ -1073,7 +1079,7 @@ make_number (EMACS_INT n)
/* Extract A's value as a signed integer. */
INLINE EMACS_INT
XINT (Lisp_Object a)
XFIXNUM (Lisp_Object a)
{
EMACS_INT i = XLI (a);
if (! USE_LSB_TAG)
@ -1084,14 +1090,14 @@ XINT (Lisp_Object a)
return i >> INTTYPEBITS;
}
/* Like XINT (A), but may be faster. A must be nonnegative.
/* Like XFIXNUM (A), but may be faster. A must be nonnegative.
If ! USE_LSB_TAG, this takes advantage of the fact that Lisp
integers have zero-bits in their tags. */
INLINE EMACS_INT
XFASTINT (Lisp_Object a)
XFIXNAT (Lisp_Object a)
{
EMACS_INT int0 = Lisp_Int0;
EMACS_INT n = USE_LSB_TAG ? XINT (a) : XLI (a) - (int0 << VALBITS);
EMACS_INT n = USE_LSB_TAG ? XFIXNUM (a) : XLI (a) - (int0 << VALBITS);
eassume (0 <= n);
return n;
}
@ -1100,14 +1106,14 @@ XFASTINT (Lisp_Object a)
/* Extract A's value as an unsigned integer. */
INLINE EMACS_UINT
XUINT (Lisp_Object a)
XUFIXNUM (Lisp_Object a)
{
EMACS_UINT i = XLI (a);
return USE_LSB_TAG ? i >> INTTYPEBITS : i & INTMASK;
}
/* Return A's (Lisp-integer sized) hash. Happens to be like XUINT
right now, but XUINT should only be applied to objects we know are
/* Return A's (Lisp-integer sized) hash. Happens to be like XUFIXNUM
right now, but XUFIXNUM should only be applied to objects we know are
integers. */
INLINE EMACS_INT
@ -1116,13 +1122,13 @@ INLINE EMACS_INT
return lisp_h_XHASH (a);
}
/* Like make_number (N), but may be faster. N must be in nonnegative range. */
/* Like make_fixnum (N), but may be faster. N must be in nonnegative range. */
INLINE Lisp_Object
make_natnum (EMACS_INT n)
make_fixed_natnum (EMACS_INT n)
{
eassert (0 <= n && n <= MOST_POSITIVE_FIXNUM);
EMACS_INT int0 = Lisp_Int0;
return USE_LSB_TAG ? make_number (n) : XIL (n + (int0 << VALBITS));
return USE_LSB_TAG ? make_fixnum (n) : XIL (n + (int0 << VALBITS));
}
/* Return true if X and Y are the same object. */
@ -1155,13 +1161,13 @@ make_lisp_ptr (void *ptr, enum Lisp_Type type)
}
INLINE bool
(INTEGERP) (Lisp_Object x)
(FIXNUMP) (Lisp_Object x)
{
return lisp_h_INTEGERP (x);
return lisp_h_FIXNUMP (x);
}
#define XSETINT(a, b) ((a) = make_number (b))
#define XSETFASTINT(a, b) ((a) = make_natnum (b))
#define XSETINT(a, b) ((a) = make_fixnum (b))
#define XSETFASTINT(a, b) ((a) = make_fixed_natnum (b))
#define XSETCONS(a, b) ((a) = make_lisp_ptr (b, Lisp_Cons))
#define XSETVECTOR(a, b) ((a) = make_lisp_ptr (b, Lisp_Vectorlike))
#define XSETSTRING(a, b) ((a) = make_lisp_ptr (b, Lisp_String))
@ -1212,7 +1218,7 @@ INLINE bool
bits set, which makes this conversion inherently unportable. */
INLINE void *
XINTPTR (Lisp_Object a)
XFIXNUMPTR (Lisp_Object a)
{
return XUNTAG (a, Lisp_Int0, char);
}
@ -1221,7 +1227,7 @@ INLINE Lisp_Object
make_pointer_integer (void *p)
{
Lisp_Object a = TAG_PTR (Lisp_Int0, p);
eassert (INTEGERP (a) && XINTPTR (a) == p);
eassert (FIXNUMP (a) && XFIXNUMPTR (a) == p);
return a;
}
@ -2372,10 +2378,10 @@ extern Lisp_Object make_misc_ptr (void *);
/* A mint_ptr object OBJ represents a C-language pointer P efficiently.
Preferably (and typically), OBJ is a Lisp integer I such that
XINTPTR (I) == P, as this represents P within a single Lisp value
XFIXNUMPTR (I) == P, as this represents P within a single Lisp value
without requiring any auxiliary memory. However, if P would be
damaged by being tagged as an integer and then untagged via
XINTPTR, then OBJ is a Lisp_Misc_Ptr with pointer component P.
XFIXNUMPTR, then OBJ is a Lisp_Misc_Ptr with pointer component P.
mint_ptr objects are efficiency hacks intended for C code.
Although xmint_ptr can be given any mint_ptr generated by non-buggy
@ -2389,21 +2395,21 @@ INLINE Lisp_Object
make_mint_ptr (void *a)
{
Lisp_Object val = TAG_PTR (Lisp_Int0, a);
return INTEGERP (val) && XINTPTR (val) == a ? val : make_misc_ptr (a);
return FIXNUMP (val) && XFIXNUMPTR (val) == a ? val : make_misc_ptr (a);
}
INLINE bool
mint_ptrp (Lisp_Object x)
{
return INTEGERP (x) || (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Ptr);
return FIXNUMP (x) || (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Ptr);
}
INLINE void *
xmint_pointer (Lisp_Object a)
{
eassert (mint_ptrp (a));
if (INTEGERP (a))
return XINTPTR (a);
if (FIXNUMP (a))
return XFIXNUMPTR (a);
return XUNTAG (a, Lisp_Misc, struct Lisp_Misc_Ptr)->pointer;
}
@ -2456,6 +2462,14 @@ struct Lisp_Free
union Lisp_Misc *chain;
};
struct Lisp_Bignum
{
ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Bignum */
bool_bf gcmarkbit : 1;
unsigned spacer : 15;
mpz_t value;
};
/* To get the type field of a union Lisp_Misc, use XMISCTYPE.
It uses one of these struct subtypes to get the type field. */
@ -2470,6 +2484,7 @@ union Lisp_Misc
#ifdef HAVE_MODULES
struct Lisp_User_Ptr u_user_ptr;
#endif
struct Lisp_Bignum u_bignum;
};
INLINE union Lisp_Misc *
@ -2519,6 +2534,25 @@ XUSER_PTR (Lisp_Object a)
}
#endif
INLINE bool
BIGNUMP (Lisp_Object x)
{
return MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Bignum;
}
INLINE struct Lisp_Bignum *
XBIGNUM (Lisp_Object a)
{
eassert (BIGNUMP (a));
return XUNTAG (a, Lisp_Misc, struct Lisp_Bignum);
}
INLINE bool
INTEGERP (Lisp_Object x)
{
return FIXNUMP (x) || BIGNUMP (x);
}
/* Forwarding pointer to an int variable.
This is allowed only in the value cell of a symbol,
@ -2556,7 +2590,7 @@ struct Lisp_Buffer_Objfwd
{
enum Lisp_Fwd_Type type; /* = Lisp_Fwd_Buffer_Obj */
int offset;
/* One of Qnil, Qintegerp, Qsymbolp, Qstringp, Qfloatp or Qnumberp. */
/* One of Qnil, Qfixnump, Qsymbolp, Qstringp, Qfloatp or Qnumberp. */
Lisp_Object predicate;
};
@ -2722,26 +2756,38 @@ enum char_bits
/* Data type checking. */
INLINE bool
NUMBERP (Lisp_Object x)
FIXED_OR_FLOATP (Lisp_Object x)
{
return INTEGERP (x) || FLOATP (x);
return FIXNUMP (x) || FLOATP (x);
}
INLINE bool
FIXNATP (Lisp_Object x)
{
return FIXNUMP (x) && 0 <= XFIXNUM (x);
}
INLINE bool
NATNUMP (Lisp_Object x)
{
return INTEGERP (x) && 0 <= XINT (x);
if (BIGNUMP (x))
return mpz_sgn (XBIGNUM (x)->value) >= 0;
return FIXNUMP (x) && 0 <= XFIXNUM (x);
}
INLINE bool
NUMBERP (Lisp_Object x)
{
return INTEGERP (x) || FLOATP (x);
}
INLINE bool
RANGED_INTEGERP (intmax_t lo, Lisp_Object x, intmax_t hi)
RANGED_FIXNUMP (intmax_t lo, Lisp_Object x, intmax_t hi)
{
return INTEGERP (x) && lo <= XINT (x) && XINT (x) <= hi;
return FIXNUMP (x) && lo <= XFIXNUM (x) && XFIXNUM (x) <= hi;
}
#define TYPE_RANGED_INTEGERP(type, x) \
(INTEGERP (x) \
&& (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XINT (x) : 0 <= XINT (x)) \
&& XINT (x) <= TYPE_MAXIMUM (type))
#define TYPE_RANGED_FIXNUMP(type, x) \
(FIXNUMP (x) \
&& (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XFIXNUM (x) : 0 <= XFIXNUM (x)) \
&& XFIXNUM (x) <= TYPE_MAXIMUM (type))
INLINE bool
AUTOLOADP (Lisp_Object x)
@ -2809,9 +2855,9 @@ CHECK_LIST_END (Lisp_Object x, Lisp_Object y)
}
INLINE void
(CHECK_NUMBER) (Lisp_Object x)
(CHECK_FIXNUM) (Lisp_Object x)
{
lisp_h_CHECK_NUMBER (x);
lisp_h_CHECK_FIXNUM (x);
}
INLINE void
@ -2835,21 +2881,21 @@ CHECK_ARRAY (Lisp_Object x, Lisp_Object predicate)
CHECK_TYPE (ARRAYP (x), predicate, x);
}
INLINE void
CHECK_NATNUM (Lisp_Object x)
CHECK_FIXNAT (Lisp_Object x)
{
CHECK_TYPE (NATNUMP (x), Qwholenump, x);
CHECK_TYPE (FIXNATP (x), Qwholenump, x);
}
#define CHECK_RANGED_INTEGER(x, lo, hi) \
do { \
CHECK_NUMBER (x); \
if (! ((lo) <= XINT (x) && XINT (x) <= (hi))) \
CHECK_FIXNUM (x); \
if (! ((lo) <= XFIXNUM (x) && XFIXNUM (x) <= (hi))) \
args_out_of_range_3 \
(x, \
make_number ((lo) < 0 && (lo) < MOST_NEGATIVE_FIXNUM \
make_fixnum ((lo) < 0 && (lo) < MOST_NEGATIVE_FIXNUM \
? MOST_NEGATIVE_FIXNUM \
: (lo)), \
make_number (min (hi, MOST_POSITIVE_FIXNUM))); \
make_fixnum (min (hi, MOST_POSITIVE_FIXNUM))); \
} while (false)
#define CHECK_TYPE_RANGED_INTEGER(type, x) \
do { \
@ -2859,27 +2905,49 @@ CHECK_NATNUM (Lisp_Object x)
CHECK_RANGED_INTEGER (x, 0, TYPE_MAXIMUM (type)); \
} while (false)
#define CHECK_NUMBER_COERCE_MARKER(x) \
#define CHECK_FIXNUM_COERCE_MARKER(x) \
do { \
if (MARKERP ((x))) \
XSETFASTINT (x, marker_position (x)); \
else \
CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x); \
CHECK_TYPE (FIXNUMP (x), Qinteger_or_marker_p, x); \
} while (false)
INLINE double
XFLOATINT (Lisp_Object n)
{
return FLOATP (n) ? XFLOAT_DATA (n) : XINT (n);
if (BIGNUMP (n))
return mpz_get_d (XBIGNUM (n)->value);
return FLOATP (n) ? XFLOAT_DATA (n) : XFIXNUM (n);
}
INLINE void
CHECK_NUMBER_OR_FLOAT (Lisp_Object x)
CHECK_FIXNUM_OR_FLOAT (Lisp_Object x)
{
CHECK_TYPE (FIXED_OR_FLOATP (x), Qnumberp, x);
}
INLINE void
CHECK_NUMBER (Lisp_Object x)
{
CHECK_TYPE (NUMBERP (x), Qnumberp, x);
}
#define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \
INLINE void
CHECK_INTEGER (Lisp_Object x)
{
CHECK_TYPE (INTEGERP (x), Qnumberp, x);
}
#define CHECK_FIXNUM_OR_FLOAT_COERCE_MARKER(x) \
do { \
if (MARKERP (x)) \
XSETFASTINT (x, marker_position (x)); \
else \
CHECK_TYPE (FIXED_OR_FLOATP (x), Qnumber_or_marker_p, x); \
} while (false)
#define CHECK_NUMBER_COERCE_MARKER(x) \
do { \
if (MARKERP (x)) \
XSETFASTINT (x, marker_position (x)); \
@ -2887,21 +2955,29 @@ CHECK_NUMBER_OR_FLOAT (Lisp_Object x)
CHECK_TYPE (NUMBERP (x), Qnumber_or_marker_p, x); \
} while (false)
#define CHECK_INTEGER_COERCE_MARKER(x) \
do { \
if (MARKERP (x)) \
XSETFASTINT (x, marker_position (x)); \
else \
CHECK_TYPE (INTEGERP (x), Qnumber_or_marker_p, x); \
} while (false)
/* Since we can't assign directly to the CAR or CDR fields of a cons
cell, use these when checking that those fields contain numbers. */
INLINE void
CHECK_NUMBER_CAR (Lisp_Object x)
CHECK_FIXNUM_CAR (Lisp_Object x)
{
Lisp_Object tmp = XCAR (x);
CHECK_NUMBER (tmp);
CHECK_FIXNUM (tmp);
XSETCAR (x, tmp);
}
INLINE void
CHECK_NUMBER_CDR (Lisp_Object x)
CHECK_FIXNUM_CDR (Lisp_Object x)
{
Lisp_Object tmp = XCDR (x);
CHECK_NUMBER (tmp);
CHECK_FIXNUM (tmp);
XSETCDR (x, tmp);
}
@ -3324,7 +3400,7 @@ extern Lisp_Object arithcompare (Lisp_Object num1, Lisp_Object num2,
I should not have side effects. */
#define INTEGER_TO_CONS(i) \
(! FIXNUM_OVERFLOW_P (i) \
? make_number (i) \
? make_fixnum (i) \
: EXPR_SIGNED (i) ? intbig_to_lisp (i) : uintbig_to_lisp (i))
extern Lisp_Object intbig_to_lisp (intmax_t);
extern Lisp_Object uintbig_to_lisp (uintmax_t);
@ -3574,25 +3650,54 @@ extern Lisp_Object list5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object,
enum constype {CONSTYPE_HEAP, CONSTYPE_PURE};
extern Lisp_Object listn (enum constype, ptrdiff_t, Lisp_Object, ...);
extern Lisp_Object make_bignum_str (const char *num, int base);
extern Lisp_Object make_number (mpz_t value);
extern void mpz_set_intmax_slow (mpz_t result, intmax_t v);
extern void mpz_set_uintmax_slow (mpz_t result, uintmax_t v);
INLINE void
mpz_set_intmax (mpz_t result, intmax_t v)
{
/* mpz_set_si works in terms of long, but Emacs may use a wider
integer type, and so sometimes will have to construct the mpz_t
by hand. */
if (sizeof (intmax_t) > sizeof (long) && (long) v != v)
mpz_set_intmax_slow (result, v);
else
mpz_set_si (result, v);
}
INLINE void
mpz_set_uintmax (mpz_t result, uintmax_t v)
{
/* mpz_set_ui works in terms of unsigned long, but Emacs may use a
wider integer type, and so sometimes will have to construct the
mpz_t by hand. */
if (sizeof (uintmax_t) > sizeof (unsigned long) && (unsigned long) v != v)
mpz_set_uintmax_slow (result, v);
else
mpz_set_ui (result, v);
}
/* Build a frequently used 2/3/4-integer lists. */
INLINE Lisp_Object
list2i (EMACS_INT x, EMACS_INT y)
{
return list2 (make_number (x), make_number (y));
return list2 (make_fixnum (x), make_fixnum (y));
}
INLINE Lisp_Object
list3i (EMACS_INT x, EMACS_INT y, EMACS_INT w)
{
return list3 (make_number (x), make_number (y), make_number (w));
return list3 (make_fixnum (x), make_fixnum (y), make_fixnum (w));
}
INLINE Lisp_Object
list4i (EMACS_INT x, EMACS_INT y, EMACS_INT w, EMACS_INT h)
{
return list4 (make_number (x), make_number (y),
make_number (w), make_number (h));
return list4 (make_fixnum (x), make_fixnum (y),
make_fixnum (w), make_fixnum (h));
}
extern Lisp_Object make_uninit_bool_vector (EMACS_INT);
@ -3786,7 +3891,7 @@ LOADHIST_ATTACH (Lisp_Object x)
}
extern int openp (Lisp_Object, Lisp_Object, Lisp_Object,
Lisp_Object *, Lisp_Object, bool);
enum { S2N_IGNORE_TRAILING = 1, S2N_OVERFLOW_TO_FLOAT = 2 };
enum { S2N_IGNORE_TRAILING = 1 };
extern Lisp_Object string_to_number (char const *, int, int);
extern void map_obarray (Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
Lisp_Object);
@ -4486,7 +4591,7 @@ extern void init_system_name (void);
in a Lisp fixnum. */
#define make_fixnum_or_float(val) \
(FIXNUM_OVERFLOW_P (val) ? make_float (val) : make_number (val))
(FIXNUM_OVERFLOW_P (val) ? make_float (val) : make_fixnum (val))
/* SAFE_ALLOCA normally allocates memory on the stack, but if size is
larger than MAX_ALLOCA, use xmalloc to avoid overflowing the stack. */

202
src/lread.c
View file

@ -335,7 +335,7 @@ readchar (Lisp_Object readcharfun, bool *multibyte)
if (NILP (tem))
return -1;
return XINT (tem);
return XFIXNUM (tem);
read_multibyte:
if (unread_char >= 0)
@ -467,7 +467,7 @@ unreadchar (Lisp_Object readcharfun, int c)
unread_char = c;
}
else
call1 (readcharfun, make_number (c));
call1 (readcharfun, make_fixnum (c));
}
static int
@ -665,7 +665,7 @@ read_filtered_event (bool no_switch_frame, bool ascii_required,
delayed_switch_frame = Qnil;
/* Compute timeout. */
if (NUMBERP (seconds))
if (FIXED_OR_FLOATP (seconds))
{
double duration = XFLOATINT (seconds);
struct timespec wait_time = dtotimespec (duration);
@ -676,8 +676,8 @@ read_filtered_event (bool no_switch_frame, bool ascii_required,
retry:
do
val = read_char (0, Qnil, (input_method ? Qnil : Qt), 0,
NUMBERP (seconds) ? &end_time : NULL);
while (INTEGERP (val) && XINT (val) == -2); /* wrong_kboard_jmpbuf */
FIXED_OR_FLOATP (seconds) ? &end_time : NULL);
while (FIXNUMP (val) && XFIXNUM (val) == -2); /* wrong_kboard_jmpbuf */
if (BUFFERP (val))
goto retry;
@ -695,7 +695,7 @@ read_filtered_event (bool no_switch_frame, bool ascii_required,
goto retry;
}
if (ascii_required && !(NUMBERP (seconds) && NILP (val)))
if (ascii_required && !(FIXED_OR_FLOATP (seconds) && NILP (val)))
{
/* Convert certain symbols to their ASCII equivalents. */
if (SYMBOLP (val))
@ -708,12 +708,12 @@ read_filtered_event (bool no_switch_frame, bool ascii_required,
/* Merge this symbol's modifier bits
with the ASCII equivalent of its basic code. */
if (!NILP (tem1))
XSETFASTINT (val, XINT (tem1) | XINT (Fcar (Fcdr (tem))));
XSETFASTINT (val, XFIXNUM (tem1) | XFIXNUM (Fcar (Fcdr (tem))));
}
}
/* If we don't have a character now, deal with it appropriately. */
if (!INTEGERP (val))
if (!FIXNUMP (val))
{
if (error_nonascii)
{
@ -770,7 +770,7 @@ floating-point value. */)
val = read_filtered_event (1, 1, 1, ! NILP (inherit_input_method), seconds);
return (NILP (val) ? Qnil
: make_number (char_resolve_modifier_mask (XINT (val))));
: make_fixnum (char_resolve_modifier_mask (XFIXNUM (val))));
}
DEFUN ("read-event", Fread_event, Sread_event, 0, 3, 0,
@ -814,7 +814,7 @@ floating-point value. */)
val = read_filtered_event (1, 1, 0, ! NILP (inherit_input_method), seconds);
return (NILP (val) ? Qnil
: make_number (char_resolve_modifier_mask (XINT (val))));
: make_fixnum (char_resolve_modifier_mask (XFIXNUM (val))));
}
DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
@ -823,7 +823,7 @@ DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
{
if (!infile)
error ("get-file-char misused");
return make_number (readbyte_from_stdio ());
return make_fixnum (readbyte_from_stdio ());
}
@ -1349,7 +1349,7 @@ Return t if the file exists and loads successfully. */)
if (!NILP (nomessage) && !force_load_messages)
{
Lisp_Object msg_file;
msg_file = Fsubstring (found, make_number (0), make_number (-1));
msg_file = Fsubstring (found, make_fixnum (0), make_fixnum (-1));
message_with_string ("Source file `%s' newer than byte-compiled file",
msg_file, 1);
}
@ -1664,7 +1664,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
string = make_string (fn, fnlen);
handler = Ffind_file_name_handler (string, Qfile_exists_p);
if ((!NILP (handler) || (!NILP (predicate) && !EQ (predicate, Qt)))
&& !NATNUMP (predicate))
&& !FIXNATP (predicate))
{
bool exists;
if (NILP (predicate) || EQ (predicate, Qt))
@ -1703,12 +1703,12 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
pfn = SSDATA (encoded_fn);
/* Check that we can access or open it. */
if (NATNUMP (predicate))
if (FIXNATP (predicate))
{
fd = -1;
if (INT_MAX < XFASTINT (predicate))
if (INT_MAX < XFIXNAT (predicate))
last_errno = EINVAL;
else if (faccessat (AT_FDCWD, pfn, XFASTINT (predicate),
else if (faccessat (AT_FDCWD, pfn, XFIXNAT (predicate),
AT_EACCESS)
== 0)
{
@ -1741,7 +1741,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes,
if (fd >= 0)
{
if (newer && !NATNUMP (predicate))
if (newer && !FIXNATP (predicate))
{
struct timespec mtime = get_stat_mtime (&st);
@ -1992,11 +1992,11 @@ readevalloop (Lisp_Object readcharfun,
/* Set point and ZV around stuff to be read. */
Fgoto_char (start);
if (!NILP (end))
Fnarrow_to_region (make_number (BEGV), end);
Fnarrow_to_region (make_fixnum (BEGV), end);
/* Just for cleanliness, convert END to a marker
if it is an integer. */
if (INTEGERP (end))
if (FIXNUMP (end))
end = Fpoint_max_marker ();
}
@ -2226,7 +2226,7 @@ the end of STRING. */)
CHECK_STRING (string);
/* `read_internal_start' sets `read_from_string_index'. */
ret = read_internal_start (string, start, end);
return Fcons (ret, make_number (read_from_string_index));
return Fcons (ret, make_fixnum (read_from_string_index));
}
/* Function to set up the global context we need in toplevel read
@ -2312,7 +2312,7 @@ read0 (Lisp_Object readcharfun)
return val;
xsignal1 (Qinvalid_read_syntax,
Fmake_string (make_number (1), make_number (c), Qnil));
Fmake_string (make_fixnum (1), make_fixnum (c), Qnil));
}
/* Grow a read buffer BUF that contains OFFSET useful bytes of data,
@ -2351,15 +2351,15 @@ character_name_to_code (char const *name, ptrdiff_t name_len)
? string_to_number (name + 1, 16, 0)
: call2 (Qchar_from_name, make_unibyte_string (name, name_len), Qt));
if (! RANGED_INTEGERP (0, code, MAX_UNICODE_CHAR)
|| char_surrogate_p (XINT (code)))
if (! RANGED_FIXNUMP (0, code, MAX_UNICODE_CHAR)
|| char_surrogate_p (XFIXNUM (code)))
{
AUTO_STRING (format, "\\N{%s}");
AUTO_STRING_WITH_LEN (namestr, name, name_len);
xsignal1 (Qinvalid_read_syntax, CALLN (Fformat, format, namestr));
}
return XINT (code);
return XFIXNUM (code);
}
/* Bound on the length of a Unicode character name. As of
@ -2583,7 +2583,7 @@ read_escape (Lisp_Object readcharfun, bool stringp)
AUTO_STRING (format,
"Invalid character U+%04X in character name");
xsignal1 (Qinvalid_read_syntax,
CALLN (Fformat, format, make_natnum (c)));
CALLN (Fformat, format, make_fixed_natnum (c)));
}
/* Treat multiple adjacent whitespace characters as a
single space character. This makes it easier to use
@ -2635,6 +2635,13 @@ digit_to_number (int character, int base)
return digit < base ? digit : -1;
}
static void
free_contents (void *p)
{
void **ptr = (void **) p;
xfree (*ptr);
}
/* Read an integer in radix RADIX using READCHARFUN to read
characters. RADIX must be in the interval [2..36]; if it isn't, a
read error is signaled . Value is the integer read. Signals an
@ -2646,17 +2653,24 @@ read_integer (Lisp_Object readcharfun, EMACS_INT radix)
{
/* Room for sign, leading 0, other digits, trailing null byte.
Also, room for invalid syntax diagnostic. */
char buf[max (1 + 1 + UINTMAX_WIDTH + 1,
sizeof "integer, radix " + INT_STRLEN_BOUND (EMACS_INT))];
size_t len = max (1 + 1 + UINTMAX_WIDTH + 1,
sizeof "integer, radix " + INT_STRLEN_BOUND (EMACS_INT));
char *buf = NULL;
char *p = buf;
int valid = -1; /* 1 if valid, 0 if not, -1 if incomplete. */
ptrdiff_t count = SPECPDL_INDEX ();
if (radix < 2 || radix > 36)
valid = 0;
else
{
int c, digit;
buf = xmalloc (len);
record_unwind_protect_ptr (free_contents, &buf);
p = buf;
c = READCHAR;
if (c == '-' || c == '+')
{
@ -2682,8 +2696,15 @@ read_integer (Lisp_Object readcharfun, EMACS_INT radix)
valid = 0;
if (valid < 0)
valid = 1;
if (p < buf + sizeof buf)
*p++ = c;
/* Allow 1 extra byte for the \0. */
if (p + 1 == buf + len)
{
ptrdiff_t where = p - buf;
len *= 2;
buf = xrealloc (buf, len);
p = buf + where;
}
*p++ = c;
c = READCHAR;
}
@ -2696,14 +2717,8 @@ read_integer (Lisp_Object readcharfun, EMACS_INT radix)
invalid_syntax (buf);
}
if (p == buf + sizeof buf)
{
memset (p - 3, '.', 3);
xsignal1 (Qoverflow_error, make_unibyte_string (buf, sizeof buf));
}
*p = '\0';
return string_to_number (buf, radix, 0);
return unbind_to (count, string_to_number (buf, radix, 0));
}
@ -2768,9 +2783,9 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
if (!EQ (head, Qhash_table))
{
ptrdiff_t size = XINT (Flength (tmp));
ptrdiff_t size = XFIXNUM (Flength (tmp));
Lisp_Object record = Fmake_record (CAR_SAFE (tmp),
make_number (size - 1),
make_fixnum (size - 1),
Qnil);
for (int i = 1; i < size; i++)
{
@ -2855,24 +2870,24 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
/* Sub char-table can't be read as a regular
vector because of a two C integer fields. */
Lisp_Object tbl, tmp = read_list (1, readcharfun);
ptrdiff_t size = XINT (Flength (tmp));
ptrdiff_t size = XFIXNUM (Flength (tmp));
int i, depth, min_char;
struct Lisp_Cons *cell;
if (size == 0)
error ("Zero-sized sub char-table");
if (! RANGED_INTEGERP (1, XCAR (tmp), 3))
if (! RANGED_FIXNUMP (1, XCAR (tmp), 3))
error ("Invalid depth in sub char-table");
depth = XINT (XCAR (tmp));
depth = XFIXNUM (XCAR (tmp));
if (chartab_size[depth] != size - 2)
error ("Invalid size in sub char-table");
cell = XCONS (tmp), tmp = XCDR (tmp), size--;
free_cons (cell);
if (! RANGED_INTEGERP (0, XCAR (tmp), MAX_CHAR))
if (! RANGED_FIXNUMP (0, XCAR (tmp), MAX_CHAR))
error ("Invalid minimum character in sub-char-table");
min_char = XINT (XCAR (tmp));
min_char = XFIXNUM (XCAR (tmp));
cell = XCONS (tmp), tmp = XCDR (tmp), size--;
free_cons (cell);
@ -2897,7 +2912,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
if (c == '"')
{
Lisp_Object tmp, val;
EMACS_INT size_in_chars = bool_vector_bytes (XFASTINT (length));
EMACS_INT size_in_chars = bool_vector_bytes (XFIXNAT (length));
unsigned char *data;
UNREAD (c);
@ -2908,17 +2923,17 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
when the number of bits was a multiple of 8.
Accept such input in case it came from an old
version. */
&& ! (XFASTINT (length)
&& ! (XFIXNAT (length)
== (SCHARS (tmp) - 1) * BOOL_VECTOR_BITS_PER_CHAR)))
invalid_syntax ("#&...");
val = make_uninit_bool_vector (XFASTINT (length));
val = make_uninit_bool_vector (XFIXNAT (length));
data = bool_vector_uchar_data (val);
memcpy (data, SDATA (tmp), size_in_chars);
/* Clear the extraneous bits in the last byte. */
if (XINT (length) != size_in_chars * BOOL_VECTOR_BITS_PER_CHAR)
if (XFIXNUM (length) != size_in_chars * BOOL_VECTOR_BITS_PER_CHAR)
data[size_in_chars - 1]
&= (1 << (XINT (length) % BOOL_VECTOR_BITS_PER_CHAR)) - 1;
&= (1 << (XFIXNUM (length) % BOOL_VECTOR_BITS_PER_CHAR)) - 1;
return val;
}
invalid_syntax ("#&...");
@ -3131,7 +3146,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
struct Lisp_Hash_Table *h
= XHASH_TABLE (read_objects_map);
EMACS_UINT hash;
Lisp_Object number = make_number (n);
Lisp_Object number = make_fixnum (n);
ptrdiff_t i = hash_lookup (h, number, &hash);
if (i >= 0)
@ -3146,7 +3161,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
/* If it can be recursive, remember it for
future substitutions. */
if (! SYMBOLP (tem)
&& ! NUMBERP (tem)
&& ! FIXED_OR_FLOATP (tem)
&& ! (STRINGP (tem) && !string_intervals (tem)))
{
struct Lisp_Hash_Table *h2
@ -3182,7 +3197,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
{
struct Lisp_Hash_Table *h
= XHASH_TABLE (read_objects_map);
ptrdiff_t i = hash_lookup (h, make_number (n), NULL);
ptrdiff_t i = hash_lookup (h, make_fixnum (n), NULL);
if (i >= 0)
return HASH_VALUE (h, i);
}
@ -3290,13 +3305,13 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
Other literal whitespace like NL, CR, and FF are not accepted,
as there are well-established escape sequences for these. */
if (c == ' ' || c == '\t')
return make_number (c);
return make_fixnum (c);
if (c == '(' || c == ')' || c == '[' || c == ']'
|| c == '"' || c == ';')
{
CHECK_LIST (Vlread_unescaped_character_literals);
Lisp_Object char_obj = make_natnum (c);
Lisp_Object char_obj = make_fixed_natnum (c);
if (NILP (Fmemq (char_obj, Vlread_unescaped_character_literals)))
Vlread_unescaped_character_literals =
Fcons (char_obj, Vlread_unescaped_character_literals);
@ -3316,7 +3331,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
&& strchr ("\"';()[]#?`,.", next_char) != NULL));
UNREAD (next_char);
if (ok)
return make_number (c);
return make_fixnum (c);
invalid_syntax ("?");
}
@ -3425,7 +3440,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
return zero instead. This is for doc strings
that we are really going to find in etc/DOC.nn.nn. */
if (!NILP (Vpurify_flag) && NILP (Vdoc_file_name) && cancel)
return unbind_to (count, make_number (0));
return unbind_to (count, make_fixnum (0));
if (! force_multibyte && force_singlebyte)
{
@ -3512,9 +3527,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
if (!quoted && !uninterned_symbol)
{
int flags = (read_integer_overflow_as_float
? S2N_OVERFLOW_TO_FLOAT : 0);
Lisp_Object result = string_to_number (read_buffer, 10, flags);
Lisp_Object result = string_to_number (read_buffer, 10, 0);
if (! NILP (result))
return unbind_to (count, result);
}
@ -3523,7 +3536,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
int ch = STRING_CHAR ((unsigned char *) read_buffer);
if (confusable_symbol_character_p (ch))
xsignal2 (Qinvalid_read_syntax, build_string ("strange quote"),
CALLN (Fstring, make_number (ch)));
CALLN (Fstring, make_fixnum (ch)));
}
{
Lisp_Object result;
@ -3566,7 +3579,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
if (EQ (Vread_with_symbol_positions, Qt)
|| EQ (Vread_with_symbol_positions, readcharfun))
Vread_symbol_positions_list
= Fcons (Fcons (result, make_number (start_position)),
= Fcons (Fcons (result, make_fixnum (start_position)),
Vread_symbol_positions_list);
return unbind_to (count, result);
}
@ -3603,7 +3616,7 @@ substitute_object_recurse (struct subst *subst, Lisp_Object subtree)
bother looking them up; we're done. */
if (SYMBOLP (subtree)
|| (STRINGP (subtree) && !string_intervals (subtree))
|| NUMBERP (subtree))
|| FIXED_OR_FLOATP (subtree))
return subtree;
/* If we've been to this node before, don't explore it again. */
@ -3681,12 +3694,10 @@ substitute_in_interval (INTERVAL interval, void *arg)
/* Convert STRING to a number, assuming base BASE. When STRING has
floating point syntax and BASE is 10, return a nearest float. When
STRING has integer syntax, return a fixnum if the integer fits, and
signal an overflow otherwise (unless BASE is 10 and STRING ends in
period or FLAGS & S2N_OVERFLOW_TO_FLOAT is nonzero; in this case,
return a nearest float instead). Otherwise, return nil. If FLAGS
& S2N_IGNORE_TRAILING is nonzero, consider just the longest prefix
of STRING that has valid syntax. */
STRING has integer syntax, return a fixnum if the integer fits, or
else a bignum. Otherwise, return nil. If FLAGS &
S2N_IGNORE_TRAILING is nonzero, consider just the longest prefix of
STRING that has valid syntax. */
Lisp_Object
string_to_number (char const *string, int base, int flags)
@ -3789,29 +3800,17 @@ string_to_number (char const *string, int base, int flags)
range, use its value, preferably as a fixnum. */
if (leading_digit >= 0 && ! float_syntax)
{
if (state & INTOVERFLOW)
{
/* Unfortunately there's no simple and accurate way to convert
non-base-10 numbers that are out of C-language range. */
if (base != 10)
flags = 0;
}
else if (n <= (negative ? -MOST_NEGATIVE_FIXNUM : MOST_POSITIVE_FIXNUM))
if ((state & INTOVERFLOW) == 0
&& n <= (negative ? -MOST_NEGATIVE_FIXNUM : MOST_POSITIVE_FIXNUM))
{
EMACS_INT signed_n = n;
return make_number (negative ? -signed_n : signed_n);
return make_fixnum (negative ? -signed_n : signed_n);
}
else
value = n;
if (! (state & DOT_CHAR) && ! (flags & S2N_OVERFLOW_TO_FLOAT))
{
AUTO_STRING (fmt, ("%s (base %d) is out of fixnum range; "
"maybe set `read-integer-overflow-as-float'?"));
AUTO_STRING_WITH_LEN (arg, string, cp - string);
xsignal1 (Qoverflow_error,
CALLN (Fformat_message, fmt, arg, make_number (base)));
}
/* Skip a leading "+". */
if (signedp && !negative)
++string;
return make_bignum_str (string, base);
}
/* Either the number uses float syntax, or it does not fit into a fixnum.
@ -3836,11 +3835,11 @@ read_vector (Lisp_Object readcharfun, bool bytecodeflag)
tem = read_list (1, readcharfun);
len = Flength (tem);
if (bytecodeflag && XFASTINT (len) <= COMPILED_STACK_DEPTH)
if (bytecodeflag && XFIXNAT (len) <= COMPILED_STACK_DEPTH)
error ("Invalid byte code");
vector = Fmake_vector (len, Qnil);
size = XFASTINT (len);
size = XFIXNAT (len);
ptr = XVECTOR (vector)->contents;
for (i = 0; i < size; i++)
{
@ -3978,8 +3977,8 @@ read_list (bool flag, Lisp_Object readcharfun)
if (ch == ')')
{
if (doc_reference == 1)
return make_number (0);
if (doc_reference == 2 && INTEGERP (XCDR (val)))
return make_fixnum (0);
if (doc_reference == 2 && FIXNUMP (XCDR (val)))
{
char *saved = NULL;
file_offset saved_position;
@ -3994,7 +3993,7 @@ read_list (bool flag, Lisp_Object readcharfun)
multibyte. */
/* Position is negative for user variables. */
EMACS_INT pos = eabs (XINT (XCDR (val)));
EMACS_INT pos = eabs (XFIXNUM (XCDR (val)));
if (pos >= saved_doc_string_position
&& pos < (saved_doc_string_position
+ saved_doc_string_length))
@ -4099,7 +4098,7 @@ intern_sym (Lisp_Object sym, Lisp_Object obarray, Lisp_Object index)
SET_SYMBOL_VAL (XSYMBOL (sym), sym);
}
ptr = aref_addr (obarray, XINT (index));
ptr = aref_addr (obarray, XFIXNUM (index));
set_symbol_next (sym, SYMBOLP (*ptr) ? XSYMBOL (*ptr) : NULL);
*ptr = sym;
return sym;
@ -4157,7 +4156,7 @@ define_symbol (Lisp_Object sym, char const *str)
if (! EQ (sym, Qunbound))
{
Lisp_Object bucket = oblookup (initial_obarray, str, len, len);
eassert (INTEGERP (bucket));
eassert (FIXNUMP (bucket));
intern_sym (sym, initial_obarray, bucket);
}
}
@ -4203,7 +4202,7 @@ it defaults to the value of `obarray'. */)
string = SYMBOL_NAME (name);
tem = oblookup (obarray, SSDATA (string), SCHARS (string), SBYTES (string));
if (INTEGERP (tem) || (SYMBOLP (name) && !EQ (name, tem)))
if (FIXNUMP (tem) || (SYMBOLP (name) && !EQ (name, tem)))
return Qnil;
else
return tem;
@ -4235,7 +4234,7 @@ usage: (unintern NAME OBARRAY) */)
tem = oblookup (obarray, SSDATA (string),
SCHARS (string),
SBYTES (string));
if (INTEGERP (tem))
if (FIXNUMP (tem))
return Qnil;
/* If arg was a symbol, don't delete anything but that symbol itself. */
if (SYMBOLP (name) && !EQ (name, tem))
@ -4261,7 +4260,7 @@ usage: (unintern NAME OBARRAY) */)
ASET (obarray, hash, sym);
}
else
ASET (obarray, hash, make_number (0));
ASET (obarray, hash, make_fixnum (0));
}
else
{
@ -4304,7 +4303,7 @@ oblookup (Lisp_Object obarray, register const char *ptr, ptrdiff_t size, ptrdiff
hash = hash_string (ptr, size_byte) % obsize;
bucket = AREF (obarray, hash);
oblookup_last_bucket_number = hash;
if (EQ (bucket, make_number (0)))
if (EQ (bucket, make_fixnum (0)))
;
else if (!SYMBOLP (bucket))
error ("Bad data in guts of obarray"); /* Like CADR error message. */
@ -4365,7 +4364,7 @@ OBARRAY defaults to the value of `obarray'. */)
void
init_obarray (void)
{
Vobarray = Fmake_vector (make_number (OBARRAY_SIZE), make_number (0));
Vobarray = Fmake_vector (make_fixnum (OBARRAY_SIZE), make_fixnum (0));
initial_obarray = Vobarray;
staticpro (&initial_obarray);
@ -4854,13 +4853,6 @@ were read in. */);
doc: /* Non-nil means read recursive structures using #N= and #N# syntax. */);
Vread_circle = Qt;
DEFVAR_BOOL ("read-integer-overflow-as-float",
read_integer_overflow_as_float,
doc: /* Non-nil means `read' quietly treats an out-of-range integer as floating point.
Nil (the default) means signal an overflow unless the integer ends in `.'.
This variable is experimental; email 30408@debbugs.gnu.org if you need it. */);
read_integer_overflow_as_float = false;
DEFVAR_LISP ("load-path", Vload_path,
doc: /* List of directories to search for files to load.
Each element is a string (directory file name) or nil (meaning

62
src/macfont.m
View file

@ -851,7 +851,7 @@ static void mac_font_get_glyphs_for_variants (CFDataRef, UTF32Char,
* ((point->y - (point - 1)->y)
/ (point->x - (point - 1)->x)));
FONT_SET_STYLE (spec_or_entity, numeric_traits[i].index,
make_number (lround (floatval)));
make_fixnum (lround (floatval)));
}
}
@ -864,16 +864,16 @@ static void mac_font_get_glyphs_for_variants (CFDataRef, UTF32Char,
cfnumber_get_font_symbolic_traits_value (num, &sym_traits);
spacing = (sym_traits & kCTFontTraitMonoSpace
? FONT_SPACING_MONO : FONT_SPACING_PROPORTIONAL);
ASET (spec_or_entity, FONT_SPACING_INDEX, make_number (spacing));
ASET (spec_or_entity, FONT_SPACING_INDEX, make_fixnum (spacing));
}
CFRelease (dict);
}
num = CTFontDescriptorCopyAttribute (desc, kCTFontSizeAttribute);
if (num && CFNumberGetValue (num, kCFNumberCGFloatType, &floatval))
ASET (spec_or_entity, FONT_SIZE_INDEX, make_number (floatval));
ASET (spec_or_entity, FONT_SIZE_INDEX, make_fixnum (floatval));
else
ASET (spec_or_entity, FONT_SIZE_INDEX, make_number (0));
ASET (spec_or_entity, FONT_SIZE_INDEX, make_fixnum (0));
if (num)
CFRelease (num);
}
@ -903,22 +903,22 @@ static void mac_font_get_glyphs_for_variants (CFDataRef, UTF32Char,
cfnumber_get_font_symbolic_traits_value (num, &sym_traits);
CFRelease (dict);
}
if (EQ (AREF (entity, FONT_SIZE_INDEX), make_number (0)))
ASET (entity, FONT_AVGWIDTH_INDEX, make_number (0));
if (EQ (AREF (entity, FONT_SIZE_INDEX), make_fixnum (0)))
ASET (entity, FONT_AVGWIDTH_INDEX, make_fixnum (0));
ASET (entity, FONT_EXTRA_INDEX, Fcopy_sequence (extra));
name = CTFontDescriptorCopyAttribute (desc, kCTFontNameAttribute);
font_put_extra (entity, QCfont_entity,
Fcons (make_mint_ptr ((void *) name),
make_number (sym_traits)));
make_fixnum (sym_traits)));
if (synth_sym_traits & kCTFontTraitItalic)
FONT_SET_STYLE (entity, FONT_SLANT_INDEX,
make_number (FONT_SLANT_SYNTHETIC_ITALIC));
make_fixnum (FONT_SLANT_SYNTHETIC_ITALIC));
if (synth_sym_traits & kCTFontTraitBold)
FONT_SET_STYLE (entity, FONT_WEIGHT_INDEX,
make_number (FONT_WEIGHT_SYNTHETIC_BOLD));
make_fixnum (FONT_WEIGHT_SYNTHETIC_BOLD));
if (synth_sym_traits & kCTFontTraitMonoSpace)
ASET (entity, FONT_SPACING_INDEX,
make_number (FONT_SPACING_SYNTHETIC_MONO));
make_fixnum (FONT_SPACING_SYNTHETIC_MONO));
return entity;
}
@ -1798,9 +1798,9 @@ static int macfont_variation_glyphs (struct font *, int c,
continue;
len = Flength (val);
spec->features[i] =
(min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < XINT (len)
(min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < XFIXNUM (len)
? 0
: malloc (XINT (len) * sizeof *spec->features[i]));
: malloc (XFIXNUM (len) * sizeof *spec->features[i]));
if (! spec->features[i])
{
if (i > 0 && spec->features[0])
@ -1940,9 +1940,9 @@ static int macfont_variation_glyphs (struct font *, int c,
{
UniChar unichars[2];
CFIndex count =
macfont_store_utf32char_to_unichars (XFASTINT (XCAR (chars)),
macfont_store_utf32char_to_unichars (XFIXNAT (XCAR (chars)),
unichars);
CFRange range = CFRangeMake (XFASTINT (XCAR (chars)), 1);
CFRange range = CFRangeMake (XFIXNAT (XCAR (chars)), 1);
CFStringAppendCharacters (string, unichars, count);
CFCharacterSetAddCharactersInRange (cs, range);
@ -1981,10 +1981,10 @@ static int macfont_variation_glyphs (struct font *, int c,
for (i = 0; i < ARRAYELTS (numeric_traits); i++)
{
tmp = AREF (spec, numeric_traits[i].index);
if (INTEGERP (tmp))
if (FIXNUMP (tmp))
{
CGPoint *point = numeric_traits[i].points;
CGFloat floatval = (XINT (tmp) >> 8); // XXX
CGFloat floatval = (XFIXNUM (tmp) >> 8); // XXX
CFNumberRef num;
while (point->y < floatval)
@ -2069,9 +2069,9 @@ static int macfont_variation_glyphs (struct font *, int c,
ptrdiff_t j;
for (j = 0; j < ASIZE (chars); j++)
if (TYPE_RANGED_INTEGERP (UTF32Char, AREF (chars, j))
if (TYPE_RANGED_FIXNUMP (UTF32Char, AREF (chars, j))
&& CFCharacterSetIsLongCharacterMember (desc_charset,
XFASTINT (AREF (chars, j))))
XFIXNAT (AREF (chars, j))))
break;
if (j == ASIZE (chars))
result = false;
@ -2161,8 +2161,8 @@ static int macfont_variation_glyphs (struct font *, int c,
languages = CFDictionaryGetValue (attributes, kCTFontLanguagesAttribute);
if (INTEGERP (AREF (spec, FONT_SPACING_INDEX)))
spacing = XINT (AREF (spec, FONT_SPACING_INDEX));
if (FIXNUMP (AREF (spec, FONT_SPACING_INDEX)))
spacing = XFIXNUM (AREF (spec, FONT_SPACING_INDEX));
traits = ((CFMutableDictionaryRef)
CFDictionaryGetValue (attributes, kCTFontTraitsAttribute));
@ -2532,9 +2532,9 @@ So we use CTFontDescriptorCreateMatchingFontDescriptor (no
|| ! CONSP (XCDR (val)))
return Qnil;
font_name = xmint_pointer (XCAR (XCDR (val)));
sym_traits = XINT (XCDR (XCDR (val)));
sym_traits = XFIXNUM (XCDR (XCDR (val)));
size = XINT (AREF (entity, FONT_SIZE_INDEX));
size = XFIXNUM (AREF (entity, FONT_SIZE_INDEX));
if (size == 0)
size = pixel_size;
@ -2563,7 +2563,7 @@ So we use CTFontDescriptorCreateMatchingFontDescriptor (no
macfont_info->cgfont = CTFontCopyGraphicsFont (macfont, NULL);
val = assq_no_quit (QCdestination, AREF (entity, FONT_EXTRA_INDEX));
if (CONSP (val) && EQ (XCDR (val), make_number (1)))
if (CONSP (val) && EQ (XCDR (val), make_fixnum (1)))
macfont_info->screen_font = mac_screen_font_create_with_name (font_name,
size);
else
@ -2584,8 +2584,8 @@ So we use CTFontDescriptorCreateMatchingFontDescriptor (no
macfont_info->synthetic_bold_p = 1;
if (sym_traits & kCTFontTraitMonoSpace)
macfont_info->spacing = MACFONT_SPACING_MONO;
else if (INTEGERP (AREF (entity, FONT_SPACING_INDEX))
&& (XINT (AREF (entity, FONT_SPACING_INDEX))
else if (FIXNUMP (AREF (entity, FONT_SPACING_INDEX))
&& (XFIXNUM (AREF (entity, FONT_SPACING_INDEX))
== FONT_SPACING_SYNTHETIC_MONO))
macfont_info->spacing = MACFONT_SPACING_SYNTHETIC_MONO;
if (macfont_info->synthetic_italic_p || macfont_info->synthetic_bold_p)
@ -2992,7 +2992,7 @@ So we use CTFontDescriptorCreateMatchingFontDescriptor (no
if (NILP (lglyph))
{
lglyph = Fmake_vector (make_number (LGLYPH_SIZE), Qnil);
lglyph = Fmake_vector (make_fixnum (LGLYPH_SIZE), Qnil);
LGSTRING_SET_GLYPH (lgstring, i, lglyph);
}
@ -3046,17 +3046,17 @@ So we use CTFontDescriptorCreateMatchingFontDescriptor (no
{
Lisp_Object vec;
vec = Fmake_vector (make_number (3), Qnil);
ASET (vec, 0, make_number (xoff));
ASET (vec, 1, make_number (yoff));
ASET (vec, 2, make_number (wadjust));
vec = Fmake_vector (make_fixnum (3), Qnil);
ASET (vec, 0, make_fixnum (xoff));
ASET (vec, 1, make_fixnum (yoff));
ASET (vec, 2, make_fixnum (wadjust));
LGLYPH_SET_ADJUSTMENT (lglyph, vec);
}
}
unblock_input ();
return make_number (used);
return make_fixnum (used);
}
/* Structures for the UVS subtable (format 14) in the cmap table. */

22
src/macros.c
View file

@ -97,9 +97,9 @@ macro before appending to it. */)
for (i = 0; i < len; i++)
{
Lisp_Object c;
c = Faref (KVAR (current_kboard, Vlast_kbd_macro), make_number (i));
if (cvt && NATNUMP (c) && (XFASTINT (c) & 0x80))
XSETFASTINT (c, CHAR_META | (XFASTINT (c) & ~0x80));
c = Faref (KVAR (current_kboard, Vlast_kbd_macro), make_fixnum (i));
if (cvt && FIXNATP (c) && (XFIXNAT (c) & 0x80))
XSETFASTINT (c, CHAR_META | (XFIXNAT (c) & ~0x80));
current_kboard->kbd_macro_buffer[i] = c;
}
@ -110,7 +110,7 @@ macro before appending to it. */)
for consistency of behavior. */
if (NILP (no_exec))
Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro),
make_number (1), Qnil);
make_fixnum (1), Qnil);
message1 ("Appending to kbd macro...");
}
@ -154,7 +154,7 @@ each iteration of the macro. Iteration stops if LOOPFUNC returns nil. */)
if (NILP (repeat))
XSETFASTINT (repeat, 1);
else
CHECK_NUMBER (repeat);
CHECK_FIXNUM (repeat);
if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
{
@ -162,11 +162,11 @@ each iteration of the macro. Iteration stops if LOOPFUNC returns nil. */)
message1 ("Keyboard macro defined");
}
if (XFASTINT (repeat) == 0)
if (XFIXNAT (repeat) == 0)
Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro), repeat, loopfunc);
else if (XINT (repeat) > 1)
else if (XFIXNUM (repeat) > 1)
{
XSETINT (repeat, XINT (repeat) - 1);
XSETINT (repeat, XFIXNUM (repeat) - 1);
Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro),
repeat, loopfunc);
}
@ -267,7 +267,7 @@ pop_kbd_macro (Lisp_Object info)
Lisp_Object tem;
Vexecuting_kbd_macro = XCAR (info);
tem = XCDR (info);
executing_kbd_macro_index = XINT (XCAR (tem));
executing_kbd_macro_index = XFIXNUM (XCAR (tem));
Vreal_this_command = XCDR (tem);
run_hook (Qkbd_macro_termination_hook);
}
@ -293,7 +293,7 @@ each iteration of the macro. Iteration stops if LOOPFUNC returns nil. */)
if (!NILP (count))
{
count = Fprefix_numeric_value (count);
repeat = XINT (count);
repeat = XFIXNUM (count);
}
final = indirect_function (macro);
@ -301,7 +301,7 @@ each iteration of the macro. Iteration stops if LOOPFUNC returns nil. */)
error ("Keyboard macros must be strings or vectors");
tem = Fcons (Vexecuting_kbd_macro,
Fcons (make_number (executing_kbd_macro_index),
Fcons (make_fixnum (executing_kbd_macro_index),
Vreal_this_command));
record_unwind_protect (pop_kbd_macro, tem);

12
src/marker.c
View file

@ -447,7 +447,7 @@ DEFUN ("marker-position", Fmarker_position, Smarker_position, 1, 1, 0,
{
CHECK_MARKER (marker);
if (XMARKER (marker)->buffer)
return make_number (XMARKER (marker)->charpos);
return make_fixnum (XMARKER (marker)->charpos);
return Qnil;
}
@ -521,11 +521,11 @@ set_marker_internal (Lisp_Object marker, Lisp_Object position,
{
register ptrdiff_t charpos, bytepos;
/* Do not use CHECK_NUMBER_COERCE_MARKER because we
/* Do not use CHECK_FIXNUM_COERCE_MARKER because we
don't want to call buf_charpos_to_bytepos if POSITION
is a marker and so we know the bytepos already. */
if (INTEGERP (position))
charpos = XINT (position), bytepos = -1;
if (FIXNUMP (position))
charpos = XFIXNUM (position), bytepos = -1;
else if (MARKERP (position))
{
charpos = XMARKER (position)->charpos;
@ -712,7 +712,7 @@ see `marker-insertion-type'. */)
register Lisp_Object new;
if (!NILP (marker))
CHECK_TYPE (INTEGERP (marker) || MARKERP (marker), Qinteger_or_marker_p, marker);
CHECK_TYPE (FIXNUMP (marker) || MARKERP (marker), Qinteger_or_marker_p, marker);
new = Fmake_marker ();
Fset_marker (new, marker,
@ -752,7 +752,7 @@ DEFUN ("buffer-has-markers-at", Fbuffer_has_markers_at, Sbuffer_has_markers_at,
register struct Lisp_Marker *tail;
register ptrdiff_t charpos;
charpos = clip_to_bounds (BEG, XINT (position), Z);
charpos = clip_to_bounds (BEG, XFIXNUM (position), Z);
for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
if (tail->charpos == charpos)

34
src/menu.c
View file

@ -86,7 +86,7 @@ init_menu_items (void)
if (NILP (menu_items))
{
menu_items_allocated = 60;
menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
menu_items = Fmake_vector (make_fixnum (menu_items_allocated), Qnil);
}
menu_items_inuse = Qt;
@ -134,11 +134,11 @@ restore_menu_items (Lisp_Object saved)
menu_items_inuse = (! NILP (menu_items) ? Qt : Qnil);
menu_items_allocated = (VECTORP (menu_items) ? ASIZE (menu_items) : 0);
saved = XCDR (saved);
menu_items_used = XINT (XCAR (saved));
menu_items_used = XFIXNUM (XCAR (saved));
saved = XCDR (saved);
menu_items_n_panes = XINT (XCAR (saved));
menu_items_n_panes = XFIXNUM (XCAR (saved));
saved = XCDR (saved);
menu_items_submenu_depth = XINT (XCAR (saved));
menu_items_submenu_depth = XFIXNUM (XCAR (saved));
}
/* Push the whole state of menu_items processing onto the specpdl.
@ -148,9 +148,9 @@ void
save_menu_items (void)
{
Lisp_Object saved = list4 (!NILP (menu_items_inuse) ? menu_items : Qnil,
make_number (menu_items_used),
make_number (menu_items_n_panes),
make_number (menu_items_submenu_depth));
make_fixnum (menu_items_used),
make_fixnum (menu_items_n_panes),
make_fixnum (menu_items_submenu_depth));
record_unwind_protect (restore_menu_items, saved);
menu_items_inuse = Qnil;
menu_items = Qnil;
@ -532,7 +532,7 @@ parse_single_submenu (Lisp_Object item_key, Lisp_Object item_name,
USE_SAFE_ALLOCA;
length = Flength (maps);
len = XINT (length);
len = XFIXNUM (length);
/* Convert the list MAPS into a vector MAPVEC. */
SAFE_ALLOCA_LISP (mapvec, len);
@ -1079,7 +1079,7 @@ into menu items. */)
if (!FRAME_LIVE_P (f))
return Qnil;
pixel_to_glyph_coords (f, XINT (x), XINT (y), &col, &row, NULL, 1);
pixel_to_glyph_coords (f, XFIXNUM (x), XFIXNUM (y), &col, &row, NULL, 1);
if (0 <= row && row < FRAME_MENU_BAR_LINES (f))
{
Lisp_Object items, item;
@ -1099,10 +1099,10 @@ into menu items. */)
pos = AREF (items, i + 3);
if (NILP (str))
return item;
if (XINT (pos) <= col
if (XFIXNUM (pos) <= col
/* We use <= so the blank between 2 items on a TTY is
considered part of the previous item. */
&& col <= XINT (pos) + menu_item_width (SDATA (str)))
&& col <= XFIXNUM (pos) + menu_item_width (SDATA (str)))
{
item = AREF (items, i);
return item;
@ -1202,9 +1202,9 @@ x_popup_menu_1 (Lisp_Object position, Lisp_Object menu)
int cur_x, cur_y;
x_relative_mouse_position (new_f, &cur_x, &cur_y);
/* cur_x/y may be negative, so use make_number. */
x = make_number (cur_x);
y = make_number (cur_y);
/* cur_x/y may be negative, so use make_fixnum. */
x = make_fixnum (cur_x);
y = make_fixnum (cur_y);
}
}
else
@ -1268,8 +1268,8 @@ x_popup_menu_1 (Lisp_Object position, Lisp_Object menu)
? (EMACS_INT) INT_MIN - ypos
: MOST_NEGATIVE_FIXNUM),
INT_MAX - ypos);
xpos += XINT (x);
ypos += XINT (y);
xpos += XFIXNUM (x);
ypos += XFIXNUM (y);
XSETFRAME (Vmenu_updating_frame, f);
}
@ -1309,7 +1309,7 @@ x_popup_menu_1 (Lisp_Object position, Lisp_Object menu)
else if (CONSP (menu) && KEYMAPP (XCAR (menu)))
{
/* We were given a list of keymaps. */
EMACS_INT nmaps = XFASTINT (Flength (menu));
EMACS_INT nmaps = XFIXNAT (Flength (menu));
Lisp_Object *maps;
ptrdiff_t i;
USE_SAFE_ALLOCA;

4452
src/mini-gmp.c Normal file
View file

File diff suppressed because it is too large Load diff

300
src/mini-gmp.h Normal file
View file

@ -0,0 +1,300 @@
/* mini-gmp, a minimalistic implementation of a GNU GMP subset.
Copyright 2011-2015, 2017 Free Software Foundation, Inc.
This file is part of the GNU MP Library.
The GNU MP Library is free software; you can redistribute it and/or modify
it under the terms of either:
* the GNU Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at your
option) any later version.
or
* the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any
later version.
or both in parallel, as here.
The GNU MP Library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the GNU MP Library. If not,
see https://www.gnu.org/licenses/. */
/* About mini-gmp: This is a minimal implementation of a subset of the
GMP interface. It is intended for inclusion into applications which
have modest bignums needs, as a fallback when the real GMP library
is not installed.
This file defines the public interface. */
#ifndef __MINI_GMP_H__
#define __MINI_GMP_H__
/* For size_t */
#include <stddef.h>
#if defined (__cplusplus)
extern "C" {
#endif
void mp_set_memory_functions (void *(*) (size_t),
void *(*) (void *, size_t, size_t),
void (*) (void *, size_t));
void mp_get_memory_functions (void *(**) (size_t),
void *(**) (void *, size_t, size_t),
void (**) (void *, size_t));
typedef unsigned long mp_limb_t;
typedef long mp_size_t;
typedef unsigned long mp_bitcnt_t;
typedef mp_limb_t *mp_ptr;
typedef const mp_limb_t *mp_srcptr;
typedef struct
{
int _mp_alloc; /* Number of *limbs* allocated and pointed
to by the _mp_d field. */
int _mp_size; /* abs(_mp_size) is the number of limbs the
last field points to. If _mp_size is
negative this is a negative number. */
mp_limb_t *_mp_d; /* Pointer to the limbs. */
} __mpz_struct;
typedef __mpz_struct mpz_t[1];
typedef __mpz_struct *mpz_ptr;
typedef const __mpz_struct *mpz_srcptr;
extern const int mp_bits_per_limb;
void mpn_copyi (mp_ptr, mp_srcptr, mp_size_t);
void mpn_copyd (mp_ptr, mp_srcptr, mp_size_t);
void mpn_zero (mp_ptr, mp_size_t);
int mpn_cmp (mp_srcptr, mp_srcptr, mp_size_t);
int mpn_zero_p (mp_srcptr, mp_size_t);
mp_limb_t mpn_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_add_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t mpn_add (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t mpn_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_sub_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t mpn_sub (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t mpn_mul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_addmul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_submul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
void mpn_mul_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void mpn_sqr (mp_ptr, mp_srcptr, mp_size_t);
int mpn_perfect_square_p (mp_srcptr, mp_size_t);
mp_size_t mpn_sqrtrem (mp_ptr, mp_ptr, mp_srcptr, mp_size_t);
mp_limb_t mpn_lshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_limb_t mpn_rshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_bitcnt_t mpn_scan0 (mp_srcptr, mp_bitcnt_t);
mp_bitcnt_t mpn_scan1 (mp_srcptr, mp_bitcnt_t);
void mpn_com (mp_ptr, mp_srcptr, mp_size_t);
mp_limb_t mpn_neg (mp_ptr, mp_srcptr, mp_size_t);
mp_bitcnt_t mpn_popcount (mp_srcptr, mp_size_t);
mp_limb_t mpn_invert_3by2 (mp_limb_t, mp_limb_t);
#define mpn_invert_limb(x) mpn_invert_3by2 ((x), 0)
size_t mpn_get_str (unsigned char *, int, mp_ptr, mp_size_t);
mp_size_t mpn_set_str (mp_ptr, const unsigned char *, size_t, int);
void mpz_init (mpz_t);
void mpz_init2 (mpz_t, mp_bitcnt_t);
void mpz_clear (mpz_t);
#define mpz_odd_p(z) (((z)->_mp_size != 0) & (int) (z)->_mp_d[0])
#define mpz_even_p(z) (! mpz_odd_p (z))
int mpz_sgn (const mpz_t);
int mpz_cmp_si (const mpz_t, long);
int mpz_cmp_ui (const mpz_t, unsigned long);
int mpz_cmp (const mpz_t, const mpz_t);
int mpz_cmpabs_ui (const mpz_t, unsigned long);
int mpz_cmpabs (const mpz_t, const mpz_t);
int mpz_cmp_d (const mpz_t, double);
int mpz_cmpabs_d (const mpz_t, double);
void mpz_abs (mpz_t, const mpz_t);
void mpz_neg (mpz_t, const mpz_t);
void mpz_swap (mpz_t, mpz_t);
void mpz_add_ui (mpz_t, const mpz_t, unsigned long);
void mpz_add (mpz_t, const mpz_t, const mpz_t);
void mpz_sub_ui (mpz_t, const mpz_t, unsigned long);
void mpz_ui_sub (mpz_t, unsigned long, const mpz_t);
void mpz_sub (mpz_t, const mpz_t, const mpz_t);
void mpz_mul_si (mpz_t, const mpz_t, long int);
void mpz_mul_ui (mpz_t, const mpz_t, unsigned long int);
void mpz_mul (mpz_t, const mpz_t, const mpz_t);
void mpz_mul_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_addmul_ui (mpz_t, const mpz_t, unsigned long int);
void mpz_addmul (mpz_t, const mpz_t, const mpz_t);
void mpz_submul_ui (mpz_t, const mpz_t, unsigned long int);
void mpz_submul (mpz_t, const mpz_t, const mpz_t);
void mpz_cdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_fdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_tdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_cdiv_q (mpz_t, const mpz_t, const mpz_t);
void mpz_fdiv_q (mpz_t, const mpz_t, const mpz_t);
void mpz_tdiv_q (mpz_t, const mpz_t, const mpz_t);
void mpz_cdiv_r (mpz_t, const mpz_t, const mpz_t);
void mpz_fdiv_r (mpz_t, const mpz_t, const mpz_t);
void mpz_tdiv_r (mpz_t, const mpz_t, const mpz_t);
void mpz_cdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_fdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_tdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_cdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_fdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_tdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_mod (mpz_t, const mpz_t, const mpz_t);
void mpz_divexact (mpz_t, const mpz_t, const mpz_t);
int mpz_divisible_p (const mpz_t, const mpz_t);
int mpz_congruent_p (const mpz_t, const mpz_t, const mpz_t);
unsigned long mpz_cdiv_qr_ui (mpz_t, mpz_t, const mpz_t, unsigned long);
unsigned long mpz_fdiv_qr_ui (mpz_t, mpz_t, const mpz_t, unsigned long);
unsigned long mpz_tdiv_qr_ui (mpz_t, mpz_t, const mpz_t, unsigned long);
unsigned long mpz_cdiv_q_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_fdiv_q_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_tdiv_q_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_cdiv_r_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_fdiv_r_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_tdiv_r_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_cdiv_ui (const mpz_t, unsigned long);
unsigned long mpz_fdiv_ui (const mpz_t, unsigned long);
unsigned long mpz_tdiv_ui (const mpz_t, unsigned long);
unsigned long mpz_mod_ui (mpz_t, const mpz_t, unsigned long);
void mpz_divexact_ui (mpz_t, const mpz_t, unsigned long);
int mpz_divisible_ui_p (const mpz_t, unsigned long);
unsigned long mpz_gcd_ui (mpz_t, const mpz_t, unsigned long);
void mpz_gcd (mpz_t, const mpz_t, const mpz_t);
void mpz_gcdext (mpz_t, mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_lcm_ui (mpz_t, const mpz_t, unsigned long);
void mpz_lcm (mpz_t, const mpz_t, const mpz_t);
int mpz_invert (mpz_t, const mpz_t, const mpz_t);
void mpz_sqrtrem (mpz_t, mpz_t, const mpz_t);
void mpz_sqrt (mpz_t, const mpz_t);
int mpz_perfect_square_p (const mpz_t);
void mpz_pow_ui (mpz_t, const mpz_t, unsigned long);
void mpz_ui_pow_ui (mpz_t, unsigned long, unsigned long);
void mpz_powm (mpz_t, const mpz_t, const mpz_t, const mpz_t);
void mpz_powm_ui (mpz_t, const mpz_t, unsigned long, const mpz_t);
void mpz_rootrem (mpz_t, mpz_t, const mpz_t, unsigned long);
int mpz_root (mpz_t, const mpz_t, unsigned long);
void mpz_fac_ui (mpz_t, unsigned long);
void mpz_2fac_ui (mpz_t, unsigned long);
void mpz_mfac_uiui (mpz_t, unsigned long, unsigned long);
void mpz_bin_uiui (mpz_t, unsigned long, unsigned long);
int mpz_probab_prime_p (const mpz_t, int);
int mpz_tstbit (const mpz_t, mp_bitcnt_t);
void mpz_setbit (mpz_t, mp_bitcnt_t);
void mpz_clrbit (mpz_t, mp_bitcnt_t);
void mpz_combit (mpz_t, mp_bitcnt_t);
void mpz_com (mpz_t, const mpz_t);
void mpz_and (mpz_t, const mpz_t, const mpz_t);
void mpz_ior (mpz_t, const mpz_t, const mpz_t);
void mpz_xor (mpz_t, const mpz_t, const mpz_t);
mp_bitcnt_t mpz_popcount (const mpz_t);
mp_bitcnt_t mpz_hamdist (const mpz_t, const mpz_t);
mp_bitcnt_t mpz_scan0 (const mpz_t, mp_bitcnt_t);
mp_bitcnt_t mpz_scan1 (const mpz_t, mp_bitcnt_t);
int mpz_fits_slong_p (const mpz_t);
int mpz_fits_ulong_p (const mpz_t);
long int mpz_get_si (const mpz_t);
unsigned long int mpz_get_ui (const mpz_t);
double mpz_get_d (const mpz_t);
size_t mpz_size (const mpz_t);
mp_limb_t mpz_getlimbn (const mpz_t, mp_size_t);
void mpz_realloc2 (mpz_t, mp_bitcnt_t);
mp_srcptr mpz_limbs_read (mpz_srcptr);
mp_ptr mpz_limbs_modify (mpz_t, mp_size_t);
mp_ptr mpz_limbs_write (mpz_t, mp_size_t);
void mpz_limbs_finish (mpz_t, mp_size_t);
mpz_srcptr mpz_roinit_n (mpz_t, mp_srcptr, mp_size_t);
#define MPZ_ROINIT_N(xp, xs) {{0, (xs),(xp) }}
void mpz_set_si (mpz_t, signed long int);
void mpz_set_ui (mpz_t, unsigned long int);
void mpz_set (mpz_t, const mpz_t);
void mpz_set_d (mpz_t, double);
void mpz_init_set_si (mpz_t, signed long int);
void mpz_init_set_ui (mpz_t, unsigned long int);
void mpz_init_set (mpz_t, const mpz_t);
void mpz_init_set_d (mpz_t, double);
size_t mpz_sizeinbase (const mpz_t, int);
char *mpz_get_str (char *, int, const mpz_t);
int mpz_set_str (mpz_t, const char *, int);
int mpz_init_set_str (mpz_t, const char *, int);
/* This long list taken from gmp.h. */
/* For reference, "defined(EOF)" cannot be used here. In g++ 2.95.4,
<iostream> defines EOF but not FILE. */
#if defined (FILE) \
|| defined (H_STDIO) \
|| defined (_H_STDIO) /* AIX */ \
|| defined (_STDIO_H) /* glibc, Sun, SCO */ \
|| defined (_STDIO_H_) /* BSD, OSF */ \
|| defined (__STDIO_H) /* Borland */ \
|| defined (__STDIO_H__) /* IRIX */ \
|| defined (_STDIO_INCLUDED) /* HPUX */ \
|| defined (__dj_include_stdio_h_) /* DJGPP */ \
|| defined (_FILE_DEFINED) /* Microsoft */ \
|| defined (__STDIO__) /* Apple MPW MrC */ \
|| defined (_MSL_STDIO_H) /* Metrowerks */ \
|| defined (_STDIO_H_INCLUDED) /* QNX4 */ \
|| defined (_ISO_STDIO_ISO_H) /* Sun C++ */ \
|| defined (__STDIO_LOADED) /* VMS */
size_t mpz_out_str (FILE *, int, const mpz_t);
#endif
void mpz_import (mpz_t, size_t, int, size_t, int, size_t, const void *);
void *mpz_export (void *, size_t *, int, size_t, int, size_t, const mpz_t);
#if defined (__cplusplus)
}
#endif
#endif /* __MINI_GMP_H__ */

74
src/minibuf.c
View file

@ -157,7 +157,7 @@ string_to_object (Lisp_Object val, Lisp_Object defalt)
}
expr_and_pos = Fread_from_string (val, Qnil, Qnil);
pos = XINT (Fcdr (expr_and_pos));
pos = XFIXNUM (Fcdr (expr_and_pos));
if (pos != SCHARS (val))
{
/* Ignore trailing whitespace; any other trailing junk
@ -198,7 +198,7 @@ read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
/* Check, whether we need to suppress echoing. */
if (CHARACTERP (Vread_hide_char))
hide_char = XFASTINT (Vread_hide_char);
hide_char = XFIXNAT (Vread_hide_char);
/* Manipulate tty. */
if (hide_char)
@ -291,7 +291,7 @@ Return (point-min) if current buffer is not a minibuffer. */)
{
/* This function is written to be most efficient when there's a prompt. */
Lisp_Object beg, end, tem;
beg = make_number (BEGV);
beg = make_fixnum (BEGV);
tem = Fmemq (Fcurrent_buffer (), Vminibuffer_list);
if (NILP (tem))
@ -299,7 +299,7 @@ Return (point-min) if current buffer is not a minibuffer. */)
end = Ffield_end (beg, Qnil, Qnil);
if (XINT (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
if (XFIXNUM (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
return beg;
else
return end;
@ -311,7 +311,7 @@ DEFUN ("minibuffer-contents", Fminibuffer_contents,
If the current buffer is not a minibuffer, return its entire contents. */)
(void)
{
ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
ptrdiff_t prompt_end = XFIXNUM (Fminibuffer_prompt_end ());
return make_buffer_string (prompt_end, ZV, 1);
}
@ -321,7 +321,7 @@ DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
If the current buffer is not a minibuffer, return its entire contents. */)
(void)
{
ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
ptrdiff_t prompt_end = XFIXNUM (Fminibuffer_prompt_end ());
return make_buffer_string (prompt_end, ZV, 0);
}
@ -393,13 +393,13 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
CHECK_STRING (initial);
if (!NILP (backup_n))
{
CHECK_NUMBER (backup_n);
CHECK_FIXNUM (backup_n);
/* Convert to distance from end of input. */
if (XINT (backup_n) < 1)
if (XFIXNUM (backup_n) < 1)
/* A number too small means the beginning of the string. */
pos = - SCHARS (initial);
else
pos = XINT (backup_n) - 1 - SCHARS (initial);
pos = XFIXNUM (backup_n) - 1 - SCHARS (initial);
}
}
else
@ -431,7 +431,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
&& NILP (Vexecuting_kbd_macro))
{
val = read_minibuf_noninteractive (map, initial, prompt,
make_number (pos),
make_fixnum (pos),
expflag, histvar, histpos, defalt,
allow_props, inherit_input_method);
return unbind_to (count, val);
@ -478,7 +478,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
minibuf_save_list));
minibuf_save_list
= Fcons (minibuf_prompt,
Fcons (make_number (minibuf_prompt_width),
Fcons (make_fixnum (minibuf_prompt_width),
Fcons (Vhelp_form,
Fcons (Vcurrent_prefix_arg,
Fcons (Vminibuffer_history_position,
@ -610,11 +610,11 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
Finsert (1, &minibuf_prompt);
if (PT > BEG)
{
Fput_text_property (make_number (BEG), make_number (PT),
Fput_text_property (make_fixnum (BEG), make_fixnum (PT),
Qfront_sticky, Qt, Qnil);
Fput_text_property (make_number (BEG), make_number (PT),
Fput_text_property (make_fixnum (BEG), make_fixnum (PT),
Qrear_nonsticky, Qt, Qnil);
Fput_text_property (make_number (BEG), make_number (PT),
Fput_text_property (make_fixnum (BEG), make_fixnum (PT),
Qfield, Qt, Qnil);
if (CONSP (Vminibuffer_prompt_properties))
{
@ -633,10 +633,10 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
Lisp_Object val = XCAR (list);
list = XCDR (list);
if (EQ (key, Qface))
Fadd_face_text_property (make_number (BEG),
make_number (PT), val, Qt, Qnil);
Fadd_face_text_property (make_fixnum (BEG),
make_fixnum (PT), val, Qt, Qnil);
else
Fput_text_property (make_number (BEG), make_number (PT),
Fput_text_property (make_fixnum (BEG), make_fixnum (PT),
key, val, Qnil);
}
}
@ -651,7 +651,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
if (!NILP (initial))
{
Finsert (1, &initial);
Fforward_char (make_number (pos));
Fforward_char (make_fixnum (pos));
}
clear_message (1, 1);
@ -721,7 +721,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
Lisp_Object
get_minibuffer (EMACS_INT depth)
{
Lisp_Object tail = Fnthcdr (make_number (depth), Vminibuffer_list);
Lisp_Object tail = Fnthcdr (make_fixnum (depth), Vminibuffer_list);
if (NILP (tail))
{
tail = list1 (Qnil);
@ -788,12 +788,12 @@ read_minibuf_unwind (void)
/* Restore prompt, etc, from outer minibuffer level. */
Lisp_Object key_vec = Fcar (minibuf_save_list);
eassert (VECTORP (key_vec));
this_command_key_count = XFASTINT (Flength (key_vec));
this_command_key_count = XFIXNAT (Flength (key_vec));
this_command_keys = key_vec;
minibuf_save_list = Fcdr (minibuf_save_list);
minibuf_prompt = Fcar (minibuf_save_list);
minibuf_save_list = Fcdr (minibuf_save_list);
minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list));
minibuf_prompt_width = XFIXNAT (Fcar (minibuf_save_list));
minibuf_save_list = Fcdr (minibuf_save_list);
Vhelp_form = Fcar (minibuf_save_list);
minibuf_save_list = Fcdr (minibuf_save_list);
@ -995,7 +995,7 @@ the current input method and the setting of`enable-multibyte-characters'. */)
{
CHECK_STRING (prompt);
return read_minibuf (Vminibuffer_local_ns_map, initial, prompt,
0, Qminibuffer_history, make_number (0), Qnil, 0,
0, Qminibuffer_history, make_fixnum (0), Qnil, 0,
!NILP (inherit_input_method));
}
@ -1195,7 +1195,7 @@ is used to further constrain the set of candidates. */)
return call3 (collection, string, predicate, Qnil);
bestmatch = bucket = Qnil;
zero = make_number (0);
zero = make_fixnum (0);
/* If COLLECTION is not a list, set TAIL just for gc pro. */
tail = collection;
@ -1261,7 +1261,7 @@ is used to further constrain the set of candidates. */)
if (STRINGP (eltstring)
&& SCHARS (string) <= SCHARS (eltstring)
&& (tem = Fcompare_strings (eltstring, zero,
make_number (SCHARS (string)),
make_fixnum (SCHARS (string)),
string, zero, Qnil,
completion_ignore_case ? Qt : Qnil),
EQ (Qt, tem)))
@ -1323,11 +1323,11 @@ is used to further constrain the set of candidates. */)
{
compare = min (bestmatchsize, SCHARS (eltstring));
tem = Fcompare_strings (bestmatch, zero,
make_number (compare),
make_fixnum (compare),
eltstring, zero,
make_number (compare),
make_fixnum (compare),
completion_ignore_case ? Qt : Qnil);
matchsize = EQ (tem, Qt) ? compare : eabs (XINT (tem)) - 1;
matchsize = EQ (tem, Qt) ? compare : eabs (XFIXNUM (tem)) - 1;
if (completion_ignore_case)
{
@ -1348,13 +1348,13 @@ is used to further constrain the set of candidates. */)
==
(matchsize == SCHARS (bestmatch))
&& (tem = Fcompare_strings (eltstring, zero,
make_number (SCHARS (string)),
make_fixnum (SCHARS (string)),
string, zero,
Qnil,
Qnil),
EQ (Qt, tem))
&& (tem = Fcompare_strings (bestmatch, zero,
make_number (SCHARS (string)),
make_fixnum (SCHARS (string)),
string, zero,
Qnil,
Qnil),
@ -1447,7 +1447,7 @@ with a space are ignored unless STRING itself starts with a space. */)
if (type == 0)
return call3 (collection, string, predicate, Qt);
allmatches = bucket = Qnil;
zero = make_number (0);
zero = make_fixnum (0);
/* If COLLECTION is not a list, set TAIL just for gc pro. */
tail = collection;
@ -1519,9 +1519,9 @@ with a space are ignored unless STRING itself starts with a space. */)
&& SREF (string, 0) == ' ')
|| SREF (eltstring, 0) != ' ')
&& (tem = Fcompare_strings (eltstring, zero,
make_number (SCHARS (string)),
make_fixnum (SCHARS (string)),
string, zero,
make_number (SCHARS (string)),
make_fixnum (SCHARS (string)),
completion_ignore_case ? Qt : Qnil),
EQ (Qt, tem)))
{
@ -1694,9 +1694,9 @@ the values STRING, PREDICATE and `lambda'. */)
if (SYMBOLP (tail))
while (1)
{
if (EQ (Fcompare_strings (string, make_number (0), Qnil,
if (EQ (Fcompare_strings (string, make_fixnum (0), Qnil,
Fsymbol_name (tail),
make_number (0) , Qnil, Qt),
make_fixnum (0) , Qnil, Qt),
Qt))
{
tem = tail;
@ -1839,8 +1839,8 @@ single string, rather than a cons cell whose car is a string. */)
thiscar = Fsymbol_name (thiscar);
else if (!STRINGP (thiscar))
continue;
tem = Fcompare_strings (thiscar, make_number (0), Qnil,
key, make_number (0), Qnil,
tem = Fcompare_strings (thiscar, make_fixnum (0), Qnil,
key, make_fixnum (0), Qnil,
case_fold);
if (EQ (tem, Qt))
return elt;
@ -1854,7 +1854,7 @@ DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
doc: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
(void)
{
return make_number (minibuf_level);
return make_fixnum (minibuf_level);
}
DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,

44
src/msdos.c
View file

@ -223,8 +223,8 @@ them. This happens with wheeled mice on Windows 9X, for example. */)
{
int n;
CHECK_NUMBER (nbuttons);
n = XINT (nbuttons);
CHECK_FIXNUM (nbuttons);
n = XFIXNUM (nbuttons);
if (n < 2 || n > 3)
xsignal2 (Qargs_out_of_range,
build_string ("only 2 or 3 mouse buttons are supported"),
@ -322,8 +322,8 @@ mouse_get_pos (struct frame **f, int insist, Lisp_Object *bar_window,
*bar_window = Qnil;
mouse_get_xy (&ix, &iy);
*time = event_timestamp ();
*x = make_number (mouse_last_x = ix);
*y = make_number (mouse_last_y = iy);
*x = make_fixnum (mouse_last_x = ix);
*y = make_fixnum (mouse_last_y = iy);
}
static void
@ -539,8 +539,8 @@ dos_set_window_size (int *rows, int *cols)
(video_name, "screen-dimensions-%dx%d",
*rows, *cols), Qnil));
if (INTEGERP (video_mode)
&& (video_mode_value = XINT (video_mode)) > 0)
if (FIXNUMP (video_mode)
&& (video_mode_value = XFIXNUM (video_mode)) > 0)
{
regs.x.ax = video_mode_value;
int86 (0x10, &regs, &regs);
@ -742,21 +742,21 @@ IT_set_cursor_type (struct frame *f, Lisp_Object cursor_type)
Lisp_Object bar_parms = XCDR (cursor_type);
int width;
if (INTEGERP (bar_parms))
if (FIXNUMP (bar_parms))
{
/* Feature: negative WIDTH means cursor at the top
of the character cell, zero means invisible cursor. */
width = XINT (bar_parms);
width = XFIXNUM (bar_parms);
msdos_set_cursor_shape (f, width >= 0 ? DEFAULT_CURSOR_START : 0,
width);
}
else if (CONSP (bar_parms)
&& INTEGERP (XCAR (bar_parms))
&& INTEGERP (XCDR (bar_parms)))
&& FIXNUMP (XCAR (bar_parms))
&& FIXNUMP (XCDR (bar_parms)))
{
int start_line = XINT (XCDR (bar_parms));
int start_line = XFIXNUM (XCDR (bar_parms));
width = XINT (XCAR (bar_parms));
width = XFIXNUM (XCAR (bar_parms));
msdos_set_cursor_shape (f, start_line, width);
}
}
@ -1321,7 +1321,7 @@ IT_frame_up_to_date (struct frame *f)
if (EQ (BVAR (b,cursor_type), Qt))
new_cursor = frame_desired_cursor;
else if (NILP (BVAR (b, cursor_type))) /* nil means no cursor */
new_cursor = Fcons (Qbar, make_number (0));
new_cursor = Fcons (Qbar, make_fixnum (0));
else
new_cursor = BVAR (b, cursor_type);
}
@ -1564,7 +1564,7 @@ void
IT_set_frame_parameters (struct frame *f, Lisp_Object alist)
{
Lisp_Object tail;
int i, j, length = XINT (Flength (alist));
int i, j, length = XFIXNUM (Flength (alist));
Lisp_Object *parms
= (Lisp_Object *) alloca (length * word_size);
Lisp_Object *values
@ -1791,7 +1791,7 @@ internal_terminal_init (void)
}
Vinitial_window_system = Qpc;
Vwindow_system_version = make_number (27); /* RE Emacs version */
Vwindow_system_version = make_fixnum (27); /* RE Emacs version */
tty->terminal->type = output_msdos_raw;
/* If Emacs was dumped on DOS/V machine, forget the stale VRAM
@ -2423,11 +2423,11 @@ dos_rawgetc (void)
sc = regs.h.ah;
total_doskeys += 2;
ASET (recent_doskeys, recent_doskeys_index, make_number (c));
ASET (recent_doskeys, recent_doskeys_index, make_fixnum (c));
recent_doskeys_index++;
if (recent_doskeys_index == NUM_RECENT_DOSKEYS)
recent_doskeys_index = 0;
ASET (recent_doskeys, recent_doskeys_index, make_number (sc));
ASET (recent_doskeys, recent_doskeys_index, make_fixnum (sc));
recent_doskeys_index++;
if (recent_doskeys_index == NUM_RECENT_DOSKEYS)
recent_doskeys_index = 0;
@ -2609,7 +2609,7 @@ dos_rawgetc (void)
if (code == 0)
continue;
if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
if (!hlinfo->mouse_face_hidden && FIXNUMP (Vmouse_highlight))
{
clear_mouse_face (hlinfo);
hlinfo->mouse_face_hidden = 1;
@ -2718,8 +2718,8 @@ dos_rawgetc (void)
event.code = button_num;
event.modifiers = dos_get_modifiers (0)
| (press ? down_modifier : up_modifier);
event.x = make_number (x);
event.y = make_number (y);
event.x = make_fixnum (x);
event.y = make_fixnum (y);
event.frame_or_window = selected_frame;
event.arg = Qnil;
event.timestamp = event_timestamp ();
@ -4196,7 +4196,7 @@ msdos_fatal_signal (int sig)
void
syms_of_msdos (void)
{
recent_doskeys = Fmake_vector (make_number (NUM_RECENT_DOSKEYS), Qnil);
recent_doskeys = Fmake_vector (make_fixnum (NUM_RECENT_DOSKEYS), Qnil);
staticpro (&recent_doskeys);
#ifndef HAVE_X_WINDOWS
@ -4207,7 +4207,7 @@ syms_of_msdos (void)
DEFVAR_LISP ("dos-unsupported-char-glyph", Vdos_unsupported_char_glyph,
doc: /* Glyph to display instead of chars not supported by current codepage.
This variable is used only by MS-DOS terminals. */);
Vdos_unsupported_char_glyph = make_number ('\177');
Vdos_unsupported_char_glyph = make_fixnum ('\177');
#endif

156
src/nsfns.m
View file

@ -209,7 +209,7 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
if (keys && [keys length] )
{
key = [keys characterAtIndex: 0];
res = make_number (key|super_modifier);
res = make_fixnum (key|super_modifier);
}
else
{
@ -589,8 +589,8 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
if (FRAME_MINIBUF_ONLY_P (f))
return;
if (TYPE_RANGED_INTEGERP (int, value))
nlines = XINT (value);
if (TYPE_RANGED_FIXNUMP (int, value))
nlines = XFIXNUM (value);
else
nlines = 0;
@ -627,8 +627,8 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
if (FRAME_MINIBUF_ONLY_P (f))
return;
if (RANGED_INTEGERP (0, value, INT_MAX))
nlines = XFASTINT (value);
if (RANGED_FIXNUMP (0, value, INT_MAX))
nlines = XFIXNAT (value);
else
nlines = 0;
@ -686,7 +686,7 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
int old_width = FRAME_INTERNAL_BORDER_WIDTH (f);
CHECK_TYPE_RANGED_INTEGER (int, arg);
f->internal_border_width = XINT (arg);
f->internal_border_width = XFIXNUM (arg);
if (FRAME_INTERNAL_BORDER_WIDTH (f) < 0)
f->internal_border_width = 0;
@ -884,10 +884,10 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
icon_y = x_get_arg (dpyinfo, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
{
CHECK_NUMBER (icon_x);
CHECK_NUMBER (icon_y);
f->output_data.ns->icon_top = XINT (icon_y);
f->output_data.ns->icon_left = XINT (icon_x);
CHECK_FIXNUM (icon_x);
CHECK_FIXNUM (icon_y);
f->output_data.ns->icon_top = XFIXNUM (icon_y);
f->output_data.ns->icon_left = XFIXNUM (icon_x);
}
else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
error ("Both left and top icon corners of icon must be specified");
@ -1086,7 +1086,7 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
if (EQ (parent, Qunbound))
parent = Qnil;
if (! NILP (parent))
CHECK_NUMBER (parent);
CHECK_FIXNUM (parent);
/* make_frame_without_minibuffer can run Lisp code and garbage collect. */
/* No need to protect DISPLAY because that's not used after passing
@ -1127,9 +1127,9 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
record_unwind_protect (unwind_create_frame, frame);
f->output_data.ns->window_desc = desc_ctr++;
if (TYPE_RANGED_INTEGERP (Window, parent))
if (TYPE_RANGED_FIXNUMP (Window, parent))
{
f->output_data.ns->parent_desc = XFASTINT (parent);
f->output_data.ns->parent_desc = XFIXNAT (parent);
f->output_data.ns->explicit_parent = 1;
}
else
@ -1170,7 +1170,7 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
/* use for default font name */
id font = [NSFont userFixedPitchFontOfSize: -1.0]; /* default */
x_default_parameter (f, parms, Qfontsize,
make_number (0 /* (int)[font pointSize] */),
make_fixnum (0 /* (int)[font pointSize] */),
"fontSize", "FontSize", RES_TYPE_NUMBER);
// Remove ' Regular', not handled by backends.
char *fontname = xstrdup ([[font displayName] UTF8String]);
@ -1184,14 +1184,14 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
}
unblock_input ();
x_default_parameter (f, parms, Qborder_width, make_number (0),
x_default_parameter (f, parms, Qborder_width, make_fixnum (0),
"borderwidth", "BorderWidth", RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qinternal_border_width, make_number (2),
x_default_parameter (f, parms, Qinternal_border_width, make_fixnum (2),
"internalBorderWidth", "InternalBorderWidth",
RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qright_divider_width, make_number (0),
x_default_parameter (f, parms, Qright_divider_width, make_fixnum (0),
NULL, NULL, RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qbottom_divider_width, make_number (0),
x_default_parameter (f, parms, Qbottom_divider_width, make_fixnum (0),
NULL, NULL, RES_TYPE_NUMBER);
/* default vertical scrollbars on right on Mac */
@ -1226,10 +1226,10 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
/* Read comment about this code in corresponding place in xfns.c. */
tem = x_get_arg (dpyinfo, parms, Qmin_width, NULL, NULL, RES_TYPE_NUMBER);
if (NUMBERP (tem))
if (FIXED_OR_FLOATP (tem))
store_frame_param (f, Qmin_width, tem);
tem = x_get_arg (dpyinfo, parms, Qmin_height, NULL, NULL, RES_TYPE_NUMBER);
if (NUMBERP (tem))
if (FIXED_OR_FLOATP (tem))
store_frame_param (f, Qmin_height, tem);
adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 5, 1,
@ -1275,11 +1275,11 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
variables; ignore them here. */
x_default_parameter (f, parms, Qmenu_bar_lines,
NILP (Vmenu_bar_mode)
? make_number (0) : make_number (1),
? make_fixnum (0) : make_fixnum (1),
NULL, NULL, RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qtool_bar_lines,
NILP (Vtool_bar_mode)
? make_number (0) : make_number (1),
? make_fixnum (0) : make_fixnum (1),
NULL, NULL, RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qbuffer_predicate, Qnil, "bufferPredicate",
@ -1781,7 +1781,7 @@ Frames are listed from topmost (first) to bottommost (last). */)
(Lisp_Object terminal)
{
check_ns_display_info (terminal);
return make_number (1);
return make_fixnum (1);
}
@ -1791,7 +1791,7 @@ Frames are listed from topmost (first) to bottommost (last). */)
{
struct ns_display_info *dpyinfo = check_ns_display_info (terminal);
return make_number (x_display_pixel_height (dpyinfo) / (92.0/25.4));
return make_fixnum (x_display_pixel_height (dpyinfo) / (92.0/25.4));
}
@ -1801,7 +1801,7 @@ Frames are listed from topmost (first) to bottommost (last). */)
{
struct ns_display_info *dpyinfo = check_ns_display_info (terminal);
return make_number (x_display_pixel_width (dpyinfo) / (92.0/25.4));
return make_fixnum (x_display_pixel_width (dpyinfo) / (92.0/25.4));
}
@ -2135,7 +2135,7 @@ Frames are listed from topmost (first) to bottommost (last). */)
// coerce the result to the appropriate ObjC type
desc = [returnDescriptor coerceToDescriptorType: typeUTF8Text];
if (desc)
*result = make_number([desc int32Value]);
*result = make_fixnum([desc int32Value]);
}
}
}
@ -2362,7 +2362,7 @@ Frames are listed from topmost (first) to bottommost (last). */)
{
struct ns_display_info *dpyinfo = check_ns_display_info (terminal);
return make_number (x_display_pixel_width (dpyinfo));
return make_fixnum (x_display_pixel_width (dpyinfo));
}
@ -2373,7 +2373,7 @@ Frames are listed from topmost (first) to bottommost (last). */)
{
struct ns_display_info *dpyinfo = check_ns_display_info (terminal);
return make_number (x_display_pixel_height (dpyinfo));
return make_fixnum (x_display_pixel_height (dpyinfo));
}
#ifdef NS_IMPL_COCOA
@ -2476,7 +2476,7 @@ Frames are listed from topmost (first) to bottommost (last). */)
int primary_monitor,
const char *source)
{
Lisp_Object monitor_frames = Fmake_vector (make_number (n_monitors), Qnil);
Lisp_Object monitor_frames = Fmake_vector (make_fixnum (n_monitors), Qnil);
Lisp_Object frame, rest;
NSArray *screens = [NSScreen screens];
int i;
@ -2617,7 +2617,7 @@ Frames are listed from topmost (first) to bottommost (last). */)
(Lisp_Object terminal)
{
check_ns_display_info (terminal);
return make_number
return make_fixnum
(NSBitsPerPixelFromDepth ([[[NSScreen screens] objectAtIndex:0] depth]));
}
@ -2629,7 +2629,7 @@ Frames are listed from topmost (first) to bottommost (last). */)
{
struct ns_display_info *dpyinfo = check_ns_display_info (terminal);
/* We force 24+ bit depths to 24-bit to prevent an overflow. */
return make_number (1 << min (dpyinfo->n_planes, 24));
return make_fixnum (1 << min (dpyinfo->n_planes, 24));
}
/* TODO: move to xdisp or similar */
@ -2653,15 +2653,15 @@ Frames are listed from topmost (first) to bottommost (last). */)
right = Fcdr (Fassq (Qright, parms));
bottom = Fcdr (Fassq (Qbottom, parms));
if ((!INTEGERP (left) && !INTEGERP (right))
|| (!INTEGERP (top) && !INTEGERP (bottom)))
if ((!FIXNUMP (left) && !FIXNUMP (right))
|| (!FIXNUMP (top) && !FIXNUMP (bottom)))
pt = [NSEvent mouseLocation];
else
{
/* Absolute coordinates. */
pt.x = INTEGERP (left) ? XINT (left) : XINT (right);
pt.x = FIXNUMP (left) ? XFIXNUM (left) : XFIXNUM (right);
pt.y = (x_display_pixel_height (FRAME_DISPLAY_INFO (f))
- (INTEGERP (top) ? XINT (top) : XINT (bottom))
- (FIXNUMP (top) ? XFIXNUM (top) : XFIXNUM (bottom))
- height);
}
@ -2681,30 +2681,30 @@ Frames are listed from topmost (first) to bottommost (last). */)
versions of macOS and in GNUstep. */
/* Ensure in bounds. (Note, screen origin = lower left.) */
if (INTEGERP (left) || INTEGERP (right))
if (FIXNUMP (left) || FIXNUMP (right))
*root_x = pt.x;
else if (pt.x + XINT (dx) <= screen.frame.origin.x)
else if (pt.x + XFIXNUM (dx) <= screen.frame.origin.x)
*root_x = screen.frame.origin.x;
else if (pt.x + XINT (dx) + width
else if (pt.x + XFIXNUM (dx) + width
<= screen.frame.origin.x + screen.frame.size.width)
/* It fits to the right of the pointer. */
*root_x = pt.x + XINT (dx);
else if (width + XINT (dx) <= pt.x)
*root_x = pt.x + XFIXNUM (dx);
else if (width + XFIXNUM (dx) <= pt.x)
/* It fits to the left of the pointer. */
*root_x = pt.x - width - XINT (dx);
*root_x = pt.x - width - XFIXNUM (dx);
else
/* Put it left justified on the screen -- it ought to fit that way. */
*root_x = screen.frame.origin.x;
if (INTEGERP (top) || INTEGERP (bottom))
if (FIXNUMP (top) || FIXNUMP (bottom))
*root_y = pt.y;
else if (pt.y - XINT (dy) - height >= screen.frame.origin.y)
else if (pt.y - XFIXNUM (dy) - height >= screen.frame.origin.y)
/* It fits below the pointer. */
*root_y = pt.y - height - XINT (dy);
else if (pt.y + XINT (dy) + height
*root_y = pt.y - height - XFIXNUM (dy);
else if (pt.y + XFIXNUM (dy) + height
<= screen.frame.origin.y + screen.frame.size.height)
/* It fits above the pointer. */
*root_y = pt.y + XINT (dy);
*root_y = pt.y + XFIXNUM (dy);
else
/* Put it on the top. */
*root_y = screen.frame.origin.y + screen.frame.size.height - height;
@ -2729,19 +2729,19 @@ Frames are listed from topmost (first) to bottommost (last). */)
str = SSDATA (string);
f = decode_window_system_frame (frame);
if (NILP (timeout))
timeout = make_number (5);
timeout = make_fixnum (5);
else
CHECK_NATNUM (timeout);
CHECK_FIXNAT (timeout);
if (NILP (dx))
dx = make_number (5);
dx = make_fixnum (5);
else
CHECK_NUMBER (dx);
CHECK_FIXNUM (dx);
if (NILP (dy))
dy = make_number (-10);
dy = make_fixnum (-10);
else
CHECK_NUMBER (dy);
CHECK_FIXNUM (dy);
block_input ();
if (ns_tooltip == nil)
@ -2765,7 +2765,7 @@ Frames are listed from topmost (first) to bottommost (last). */)
compute_tip_xy (f, parms, dx, dy, (int)size.width, (int)size.height,
&root_x, &root_y);
[ns_tooltip showAtX: root_x Y: root_y for: XINT (timeout)];
[ns_tooltip showAtX: root_x Y: root_y for: XFIXNUM (timeout)];
unblock_input ();
return unbind_to (count, Qnil);
@ -2812,44 +2812,44 @@ ATTRIBUTES return the outer edges of FRAME (Qouter_edges), the inner
/* Construct list. */
if (EQ (attribute, Qouter_edges))
return list4 (make_number (f->left_pos), make_number (f->top_pos),
make_number (f->left_pos + outer_width),
make_number (f->top_pos + outer_height));
return list4 (make_fixnum (f->left_pos), make_fixnum (f->top_pos),
make_fixnum (f->left_pos + outer_width),
make_fixnum (f->top_pos + outer_height));
else if (EQ (attribute, Qnative_edges))
return list4 (make_number (native_left), make_number (native_top),
make_number (native_right), make_number (native_bottom));
return list4 (make_fixnum (native_left), make_fixnum (native_top),
make_fixnum (native_right), make_fixnum (native_bottom));
else if (EQ (attribute, Qinner_edges))
return list4 (make_number (native_left + internal_border_width),
make_number (native_top
return list4 (make_fixnum (native_left + internal_border_width),
make_fixnum (native_top
+ tool_bar_height
+ internal_border_width),
make_number (native_right - internal_border_width),
make_number (native_bottom - internal_border_width));
make_fixnum (native_right - internal_border_width),
make_fixnum (native_bottom - internal_border_width));
else
return
listn (CONSTYPE_HEAP, 10,
Fcons (Qouter_position,
Fcons (make_number (f->left_pos),
make_number (f->top_pos))),
Fcons (make_fixnum (f->left_pos),
make_fixnum (f->top_pos))),
Fcons (Qouter_size,
Fcons (make_number (outer_width),
make_number (outer_height))),
Fcons (make_fixnum (outer_width),
make_fixnum (outer_height))),
Fcons (Qexternal_border_size,
(fullscreen
? Fcons (make_number (0), make_number (0))
: Fcons (make_number (border), make_number (border)))),
? Fcons (make_fixnum (0), make_fixnum (0))
: Fcons (make_fixnum (border), make_fixnum (border)))),
Fcons (Qtitle_bar_size,
Fcons (make_number (0), make_number (title_height))),
Fcons (make_fixnum (0), make_fixnum (title_height))),
Fcons (Qmenu_bar_external, Qnil),
Fcons (Qmenu_bar_size, Fcons (make_number (0), make_number (0))),
Fcons (Qmenu_bar_size, Fcons (make_fixnum (0), make_fixnum (0))),
Fcons (Qtool_bar_external,
FRAME_EXTERNAL_TOOL_BAR (f) ? Qt : Qnil),
Fcons (Qtool_bar_position, FRAME_TOOL_BAR_POSITION (f)),
Fcons (Qtool_bar_size,
Fcons (make_number (tool_bar_width),
make_number (tool_bar_height))),
Fcons (make_fixnum (tool_bar_width),
make_fixnum (tool_bar_height))),
Fcons (Qinternal_border_width,
make_number (internal_border_width)));
make_fixnum (internal_border_width)));
}
DEFUN ("ns-frame-geometry", Fns_frame_geometry, Sns_frame_geometry, 0, 1, 0,
@ -2947,13 +2947,13 @@ value is a list of the form (LEFT, TOP, RIGHT, BOTTOM). All values are
CHECK_TYPE_RANGED_INTEGER (int, x);
CHECK_TYPE_RANGED_INTEGER (int, y);
mouse_x = screen_frame.origin.x + XINT (x);
mouse_x = screen_frame.origin.x + XFIXNUM (x);
if (screen == primary_screen)
mouse_y = screen_frame.origin.y + XINT (y);
mouse_y = screen_frame.origin.y + XFIXNUM (y);
else
mouse_y = (primary_screen_height - screen_frame.size.height
- screen_frame.origin.y) + XINT (y);
- screen_frame.origin.y) + XFIXNUM (y);
CGPoint mouse_pos = CGPointMake(mouse_x, mouse_y);
CGWarpMouseCursorPosition (mouse_pos);
@ -2976,8 +2976,8 @@ The position is returned as a cons cell (X . Y) of the
NSScreen *screen = [[view window] screen];
NSPoint pt = [NSEvent mouseLocation];
return Fcons(make_number(pt.x - screen.frame.origin.x),
make_number(screen.frame.size.height -
return Fcons(make_fixnum(pt.x - screen.frame.origin.x),
make_fixnum(screen.frame.size.height -
(pt.y - screen.frame.origin.y)));
}

24
src/nsfont.m
View file

@ -186,24 +186,24 @@ static void ns_glyph_metrics (struct nsfont_info *font_info,
FONT_SET_STYLE (font_entity, FONT_WEIGHT_INDEX,
traits & NSFontBoldTrait ? Qbold : Qmedium);
/* FONT_SET_STYLE (font_entity, FONT_WEIGHT_INDEX,
make_number (100 + 100
make_fixnum (100 + 100
* ns_attribute_fvalue (desc, NSFontWeightTrait)));*/
FONT_SET_STYLE (font_entity, FONT_SLANT_INDEX,
traits & NSFontItalicTrait ? Qitalic : Qnormal);
/* FONT_SET_STYLE (font_entity, FONT_SLANT_INDEX,
make_number (100 + 100
make_fixnum (100 + 100
* ns_attribute_fvalue (desc, NSFontSlantTrait)));*/
FONT_SET_STYLE (font_entity, FONT_WIDTH_INDEX,
traits & NSFontCondensedTrait ? Qcondensed :
traits & NSFontExpandedTrait ? Qexpanded : Qnormal);
/* FONT_SET_STYLE (font_entity, FONT_WIDTH_INDEX,
make_number (100 + 100
make_fixnum (100 + 100
* ns_attribute_fvalue (desc, NSFontWidthTrait)));*/
ASET (font_entity, FONT_SIZE_INDEX, make_number (0));
ASET (font_entity, FONT_AVGWIDTH_INDEX, make_number (0));
ASET (font_entity, FONT_SIZE_INDEX, make_fixnum (0));
ASET (font_entity, FONT_AVGWIDTH_INDEX, make_fixnum (0));
ASET (font_entity, FONT_SPACING_INDEX,
make_number([desc symbolicTraits] & NSFontMonoSpaceTrait
make_fixnum([desc symbolicTraits] & NSFontMonoSpaceTrait
? FONT_SPACING_MONO : FONT_SPACING_PROPORTIONAL));
ASET (font_entity, FONT_EXTRA_INDEX, extra);
@ -445,8 +445,8 @@ but also for ascii (which causes unnecessary font substitution). */
{
for (; CONSP (range_list); range_list = XCDR (range_list))
{
int start = XINT (XCAR (XCAR (range_list)));
int end = XINT (XCDR (XCAR (range_list)));
int start = XFIXNUM (XCAR (XCAR (range_list)));
int end = XFIXNUM (XCDR (XCAR (range_list)));
if (NSFONT_TRACE)
debug_print (XCAR (range_list));
if (end < 0x10000)
@ -576,7 +576,7 @@ but also for ascii (which causes unnecessary font substitution). */
/* Add synthItal member if needed. */
family = [fdesc objectForKey: NSFontFamilyAttribute];
if (family != nil && !foundItal && XINT (Flength (list)) > 0)
if (family != nil && !foundItal && XFIXNUM (Flength (list)) > 0)
{
NSFontDescriptor *s1 = [NSFontDescriptor new];
NSFontDescriptor *sDesc
@ -596,7 +596,7 @@ but also for ascii (which causes unnecessary font substitution). */
if (NSFONT_TRACE)
fprintf (stderr, " Returning %"pI"d entities.\n",
XINT (Flength (list)));
XFIXNUM (Flength (list)));
return list;
}
@ -668,7 +668,7 @@ Properties to be considered are same as for list(). */
if (NSFONT_TRACE)
fprintf (stderr, "nsfont: list families returning %"pI"d entries\n",
XINT (Flength (list)));
XFIXNUM (Flength (list)));
unblock_input ();
return list;
@ -705,7 +705,7 @@ Properties to be considered are same as for list(). */
{
/* try to get it out of frame params */
Lisp_Object tem = get_frame_param (f, Qfontsize);
pixel_size = NILP (tem) ? 0 : XFASTINT (tem);
pixel_size = NILP (tem) ? 0 : XFIXNAT (tem);
}
tem = AREF (font_entity, FONT_ADSTYLE_INDEX);

18
src/nsimage.m
View file

@ -85,10 +85,10 @@ Updated by Christian Limpach (chris@nice.ch)
eassert (valid_image_p (img->spec));
lisp_index = Fplist_get (XCDR (img->spec), QCindex);
index = INTEGERP (lisp_index) ? XFASTINT (lisp_index) : 0;
index = FIXNUMP (lisp_index) ? XFIXNAT (lisp_index) : 0;
lisp_rotation = Fplist_get (XCDR (img->spec), QCrotation);
rotation = NUMBERP (lisp_rotation) ? XFLOATINT (lisp_rotation) : 0;
rotation = FIXED_OR_FLOATP (lisp_rotation) ? XFLOATINT (lisp_rotation) : 0;
if (STRINGP (spec_file))
{
@ -113,7 +113,7 @@ Updated by Christian Limpach (chris@nice.ch)
if (![eImg setFrame: index])
{
add_to_log ("Unable to set index %d for image %s",
make_number (index), img->spec);
make_fixnum (index), img->spec);
return 0;
}
@ -495,7 +495,7 @@ - (Lisp_Object)getMetadata
floatValue];
if (frames > 1)
metadata = Fcons (Qcount, Fcons (make_number (frames), metadata));
metadata = Fcons (Qcount, Fcons (make_fixnum (frames), metadata));
if (delay > 0)
metadata = Fcons (Qdelay, Fcons (make_float (delay), metadata));
}
@ -532,19 +532,19 @@ - (void)setSizeFromSpec: (Lisp_Object) spec
double width = -1, height = -1, max_width = -1, max_height = -1;
value = Fplist_get (spec, QCscale);
if (NUMBERP (value))
if (FIXED_OR_FLOATP (value))
scale = XFLOATINT (value) ;
value = Fplist_get (spec, QCmax_width);
if (NUMBERP (value))
if (FIXED_OR_FLOATP (value))
max_width = XFLOATINT (value);
value = Fplist_get (spec, QCmax_height);
if (NUMBERP (value))
if (FIXED_OR_FLOATP (value))
max_height = XFLOATINT (value);
value = Fplist_get (spec, QCwidth);
if (NUMBERP (value))
if (FIXED_OR_FLOATP (value))
{
width = XFLOATINT (value) * scale;
/* :width overrides :max-width. */
@ -552,7 +552,7 @@ - (void)setSizeFromSpec: (Lisp_Object) spec
}
value = Fplist_get (spec, QCheight);
if (NUMBERP (value))
if (FIXED_OR_FLOATP (value))
{
height = XFLOATINT (value) * scale;
/* :height overrides :max-height. */

2
src/nsmenu.m
View file

@ -377,7 +377,7 @@
{
string = AREF (items, 4*i+1);
if (EQ (string, make_number (0))) // FIXME: Why??? --Stef
if (EQ (string, make_fixnum (0))) // FIXME: Why??? --Stef
continue;
if (NILP (string))
{

14
src/nsselect.m
View file

@ -90,20 +90,20 @@ Updated by Christian Limpach (chris@nice.ch)
clean_local_selection_data (Lisp_Object obj)
{
if (CONSP (obj)
&& INTEGERP (XCAR (obj))
&& FIXNUMP (XCAR (obj))
&& CONSP (XCDR (obj))
&& INTEGERP (XCAR (XCDR (obj)))
&& FIXNUMP (XCAR (XCDR (obj)))
&& NILP (XCDR (XCDR (obj))))
obj = Fcons (XCAR (obj), XCDR (obj));
if (CONSP (obj)
&& INTEGERP (XCAR (obj))
&& INTEGERP (XCDR (obj)))
&& FIXNUMP (XCAR (obj))
&& FIXNUMP (XCDR (obj)))
{
if (XINT (XCAR (obj)) == 0)
if (XFIXNUM (XCAR (obj)) == 0)
return XCDR (obj);
if (XINT (XCAR (obj)) == -1)
return make_number (- XINT (XCDR (obj)));
if (XFIXNUM (XCAR (obj)) == -1)
return make_fixnum (- XFIXNUM (XCDR (obj)));
}
if (VECTORP (obj))

40
src/nsterm.m
View file

@ -1913,11 +1913,11 @@ breaks live resize (resizing with a mouse), so don't do it if
frame_size_history_add
(f, Qx_set_window_size_1, width, height,
list5 (Fcons (make_number (pixelwidth), make_number (pixelheight)),
Fcons (make_number (wr.size.width), make_number (wr.size.height)),
make_number (f->border_width),
make_number (FRAME_NS_TITLEBAR_HEIGHT (f)),
make_number (FRAME_TOOLBAR_HEIGHT (f))));
list5 (Fcons (make_fixnum (pixelwidth), make_fixnum (pixelheight)),
Fcons (make_fixnum (wr.size.width), make_fixnum (wr.size.height)),
make_fixnum (f->border_width),
make_fixnum (FRAME_NS_TITLEBAR_HEIGHT (f)),
make_fixnum (FRAME_TOOLBAR_HEIGHT (f))));
[window setFrame: wr display: YES];
@ -2480,8 +2480,8 @@ so some key presses (TAB) are swallowed by the system. */
if (FLOATP (Vframe_alpha_lower_limit))
alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
else if (INTEGERP (Vframe_alpha_lower_limit))
alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
else if (FIXNUMP (Vframe_alpha_lower_limit))
alpha_min = (XFIXNUM (Vframe_alpha_lower_limit)) / 100.0;
if (alpha < 0.0)
return;
@ -3520,8 +3520,8 @@ Note that CURSOR_WIDTH is meaningful only for (h)bar cursors.
BOOL underline_at_descent_line, use_underline_position_properties;
Lisp_Object val = buffer_local_value (Qunderline_minimum_offset,
s->w->contents);
if (INTEGERP (val))
minimum_offset = XFASTINT (val);
if (FIXNUMP (val))
minimum_offset = XFIXNAT (val);
else
minimum_offset = 1;
val = buffer_local_value (Qx_underline_at_descent_line,
@ -5342,7 +5342,7 @@ Needs to be here because ns_initialize_display_info () uses AppKit classes.
{
color = XCAR (color_map);
name = SSDATA (XCAR (color));
c = XINT (XCDR (color));
c = XFIXNUM (XCDR (color));
[cl setColor:
[NSColor colorForEmacsRed: RED_FROM_ULONG (c) / 255.0
green: GREEN_FROM_ULONG (c) / 255.0
@ -6155,7 +6155,7 @@ - (void)changeFont: (id)sender
emacs_event->code = KEY_NS_CHANGE_FONT;
size = [newFont pointSize];
ns_input_fontsize = make_number (lrint (size));
ns_input_fontsize = make_fixnum (lrint (size));
ns_input_font = build_string ([[newFont familyName] UTF8String]);
EV_TRAILER (e);
}
@ -6234,7 +6234,7 @@ most recently updated (I guess), which is not the correct one. */
[NSCursor setHiddenUntilMouseMoves: YES];
if (hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
if (hlinfo->mouse_face_hidden && FIXNUMP (Vmouse_highlight))
{
clear_mouse_face (hlinfo);
hlinfo->mouse_face_hidden = 1;
@ -6684,8 +6684,8 @@ - (void)mouseDown: (NSEvent *)theEvent
static int totalDeltaX, totalDeltaY;
int lineHeight;
if (NUMBERP (ns_mwheel_line_height))
lineHeight = XINT (ns_mwheel_line_height);
if (FIXED_OR_FLOATP (ns_mwheel_line_height))
lineHeight = XFIXNUM (ns_mwheel_line_height);
else
{
/* FIXME: Use actual line height instead of the default. */
@ -6754,7 +6754,7 @@ - (void)mouseDown: (NSEvent *)theEvent
return;
emacs_event->kind = horizontal ? HORIZ_WHEEL_EVENT : WHEEL_EVENT;
emacs_event->arg = (make_number (lines));
emacs_event->arg = (make_fixnum (lines));
emacs_event->code = 0;
emacs_event->modifiers = EV_MODIFIERS (theEvent) |
@ -9341,11 +9341,11 @@ Convert an X font name (XLFD) to an NS font name.
DEFSYM (Qfile, "file");
DEFSYM (Qurl, "url");
Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
Fput (Qcontrol, Qmodifier_value, make_number (ctrl_modifier));
Fput (Qalt, Qmodifier_value, make_fixnum (alt_modifier));
Fput (Qhyper, Qmodifier_value, make_fixnum (hyper_modifier));
Fput (Qmeta, Qmodifier_value, make_fixnum (meta_modifier));
Fput (Qsuper, Qmodifier_value, make_fixnum (super_modifier));
Fput (Qcontrol, Qmodifier_value, make_fixnum (ctrl_modifier));
DEFVAR_LISP ("ns-input-file", ns_input_file,
"The file specified in the last NS event.");

73
src/print.c
View file

@ -266,7 +266,7 @@ printchar_to_stream (unsigned int ch, FILE *stream)
break;
if (! (i < n))
break;
ch = XFASTINT (AREF (dv, i));
ch = XFIXNAT (AREF (dv, i));
}
}
@ -279,7 +279,7 @@ static void
printchar (unsigned int ch, Lisp_Object fun)
{
if (!NILP (fun) && !EQ (fun, Qt))
call1 (fun, make_number (ch));
call1 (fun, make_fixnum (ch));
else
{
unsigned char str[MAX_MULTIBYTE_LENGTH];
@ -525,9 +525,9 @@ PRINTCHARFUN defaults to the value of `standard-output' (which see). */)
{
if (NILP (printcharfun))
printcharfun = Vstandard_output;
CHECK_NUMBER (character);
CHECK_FIXNUM (character);
PRINTPREPARE;
printchar (XINT (character), printcharfun);
printchar (XFIXNUM (character), printcharfun);
PRINTFINISH;
return character;
}
@ -776,8 +776,8 @@ You can call `print' while debugging emacs, and pass it this function
to make it write to the debugging output. */)
(Lisp_Object character)
{
CHECK_NUMBER (character);
printchar_to_stream (XINT (character), stderr);
CHECK_FIXNUM (character);
printchar_to_stream (XFIXNUM (character), stderr);
return character;
}
@ -1208,11 +1208,11 @@ print_preprocess (Lisp_Object obj)
&& SYMBOLP (obj)
&& !SYMBOL_INTERNED_P (obj)))
{ /* OBJ appears more than once. Let's remember that. */
if (!INTEGERP (num))
if (!FIXNUMP (num))
{
print_number_index++;
/* Negative number indicates it hasn't been printed yet. */
Fputhash (obj, make_number (- print_number_index),
Fputhash (obj, make_fixnum (- print_number_index),
Vprint_number_table);
}
print_depth--;
@ -1350,12 +1350,12 @@ print_prune_string_charset (Lisp_Object string)
{
if (NILP (print_prune_charset_plist))
print_prune_charset_plist = list1 (Qcharset);
Fremove_text_properties (make_number (0),
make_number (SCHARS (string)),
Fremove_text_properties (make_fixnum (0),
make_fixnum (SCHARS (string)),
print_prune_charset_plist, string);
}
else
Fset_text_properties (make_number (0), make_number (SCHARS (string)),
Fset_text_properties (make_fixnum (0), make_fixnum (SCHARS (string)),
Qnil, string);
}
return string;
@ -1391,9 +1391,9 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
/* Don't print more bytes than the specified maximum.
Negative values of print-length are invalid. Treat them
like a print-length of nil. */
if (NATNUMP (Vprint_length)
&& XFASTINT (Vprint_length) < size_in_bytes)
size_in_bytes = XFASTINT (Vprint_length);
if (FIXNATP (Vprint_length)
&& XFIXNAT (Vprint_length) < size_in_bytes)
size_in_bytes = XFIXNAT (Vprint_length);
for (ptrdiff_t i = 0; i < size_in_bytes; i++)
{
@ -1505,8 +1505,8 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
ptrdiff_t size = real_size;
/* Don't print more elements than the specified maximum. */
if (NATNUMP (Vprint_length) && XFASTINT (Vprint_length) < size)
size = XFASTINT (Vprint_length);
if (FIXNATP (Vprint_length) && XFIXNAT (Vprint_length) < size)
size = XFIXNAT (Vprint_length);
printchar ('(', printcharfun);
for (ptrdiff_t i = 0; i < size; i++)
@ -1636,8 +1636,8 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
/* Don't print more elements than the specified maximum. */
ptrdiff_t n
= (NATNUMP (Vprint_length) && XFASTINT (Vprint_length) < size
? XFASTINT (Vprint_length) : size);
= (FIXNATP (Vprint_length) && XFIXNAT (Vprint_length) < size
? XFIXNAT (Vprint_length) : size);
print_c_string ("#s(", printcharfun);
for (ptrdiff_t i = 0; i < n; i ++)
@ -1697,9 +1697,9 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
}
/* Don't print more elements than the specified maximum. */
if (NATNUMP (Vprint_length)
&& XFASTINT (Vprint_length) < size)
size = XFASTINT (Vprint_length);
if (FIXNATP (Vprint_length)
&& XFIXNAT (Vprint_length) < size)
size = XFIXNAT (Vprint_length);
for (int i = idx; i < size; i++)
{
@ -1789,16 +1789,16 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
{
/* With the print-circle feature. */
Lisp_Object num = Fgethash (obj, Vprint_number_table, Qnil);
if (INTEGERP (num))
if (FIXNUMP (num))
{
EMACS_INT n = XINT (num);
EMACS_INT n = XFIXNUM (num);
if (n < 0)
{ /* Add a prefix #n= if OBJ has not yet been printed;
that is, its status field is nil. */
int len = sprintf (buf, "#%"pI"d=", -n);
strout (buf, len, len, printcharfun);
/* OBJ is going to be printed. Remember that fact. */
Fputhash (obj, make_number (- n), Vprint_number_table);
Fputhash (obj, make_fixnum (- n), Vprint_number_table);
}
else
{
@ -1816,7 +1816,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
{
case_Lisp_Int:
{
int len = sprintf (buf, "%"pI"d", XINT (obj));
int len = sprintf (buf, "%"pI"d", XFIXNUM (obj));
strout (buf, len, len, printcharfun);
}
break;
@ -1991,8 +1991,8 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
case Lisp_Cons:
/* If deeper than spec'd depth, print placeholder. */
if (INTEGERP (Vprint_level)
&& print_depth > XINT (Vprint_level))
if (FIXNUMP (Vprint_level)
&& print_depth > XFIXNUM (Vprint_level))
print_c_string ("...", printcharfun);
else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
&& EQ (XCAR (obj), Qquote))
@ -2033,8 +2033,8 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
/* Negative values of print-length are invalid in CL.
Treat them like nil, as CMUCL does. */
printmax_t print_length = (NATNUMP (Vprint_length)
? XFASTINT (Vprint_length)
printmax_t print_length = (FIXNATP (Vprint_length)
? XFIXNAT (Vprint_length)
: TYPE_MAXIMUM (printmax_t));
printmax_t i = 0;
@ -2057,7 +2057,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
if (i != 0)
{
Lisp_Object num = Fgethash (obj, Vprint_number_table, Qnil);
if (INTEGERP (num))
if (FIXNUMP (num))
{
print_c_string (" . ", printcharfun);
print_object (obj, printcharfun, escapeflag);
@ -2169,6 +2169,15 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
}
break;
case Lisp_Misc_Bignum:
{
struct Lisp_Bignum *b = XBIGNUM (obj);
char *str = mpz_get_str (NULL, 10, b->value);
record_unwind_protect_ptr (xfree, str);
print_c_string (str, printcharfun);
}
break;
default:
goto badtype;
}
@ -2207,9 +2216,9 @@ print_interval (INTERVAL interval, Lisp_Object printcharfun)
if (NILP (interval->plist))
return;
printchar (' ', printcharfun);
print_object (make_number (interval->position), printcharfun, 1);
print_object (make_fixnum (interval->position), printcharfun, 1);
printchar (' ', printcharfun);
print_object (make_number (interval->position + LENGTH (interval)),
print_object (make_fixnum (interval->position + LENGTH (interval)),
printcharfun, 1);
printchar (' ', printcharfun);
print_object (interval->plist, printcharfun, 1);

194
src/process.c
View file

@ -684,12 +684,12 @@ static Lisp_Object
status_convert (int w)
{
if (WIFSTOPPED (w))
return Fcons (Qstop, Fcons (make_number (WSTOPSIG (w)), Qnil));
return Fcons (Qstop, Fcons (make_fixnum (WSTOPSIG (w)), Qnil));
else if (WIFEXITED (w))
return Fcons (Qexit, Fcons (make_number (WEXITSTATUS (w)),
return Fcons (Qexit, Fcons (make_fixnum (WEXITSTATUS (w)),
WCOREDUMP (w) ? Qt : Qnil));
else if (WIFSIGNALED (w))
return Fcons (Qsignal, Fcons (make_number (WTERMSIG (w)),
return Fcons (Qsignal, Fcons (make_fixnum (WTERMSIG (w)),
WCOREDUMP (w) ? Qt : Qnil));
else
return Qrun;
@ -718,7 +718,7 @@ decode_status (Lisp_Object l, Lisp_Object *symbol, Lisp_Object *code,
if (SYMBOLP (l))
{
*symbol = l;
*code = make_number (0);
*code = make_fixnum (0);
*coredump = 0;
}
else
@ -747,7 +747,7 @@ status_message (struct Lisp_Process *p)
{
char const *signame;
synchronize_system_messages_locale ();
signame = strsignal (XFASTINT (code));
signame = strsignal (XFIXNAT (code));
if (signame == 0)
string = build_string ("unknown");
else
@ -761,7 +761,7 @@ status_message (struct Lisp_Process *p)
c1 = STRING_CHAR (SDATA (string));
c2 = downcase (c1);
if (c1 != c2)
Faset (string, make_number (0), make_number (c2));
Faset (string, make_fixnum (0), make_fixnum (c2));
}
AUTO_STRING (suffix, coredump ? " (core dumped)\n" : "\n");
return concat2 (string, suffix);
@ -769,10 +769,10 @@ status_message (struct Lisp_Process *p)
else if (EQ (symbol, Qexit))
{
if (NETCONN1_P (p))
return build_string (XFASTINT (code) == 0
return build_string (XFIXNAT (code) == 0
? "deleted\n"
: "connection broken by remote peer\n");
if (XFASTINT (code) == 0)
if (XFIXNAT (code) == 0)
return build_string ("finished\n");
AUTO_STRING (prefix, "exited abnormally with code ");
string = Fnumber_to_string (code);
@ -1064,7 +1064,7 @@ nil, indicating the current buffer's process. */)
p->raw_status_new = 0;
if (NETCONN1_P (p) || SERIALCONN1_P (p) || PIPECONN1_P (p))
{
pset_status (p, list2 (Qexit, make_number (0)));
pset_status (p, list2 (Qexit, make_fixnum (0)));
p->tick = ++process_tick;
status_notify (p, NULL);
redisplay_preserve_echo_area (13);
@ -1083,7 +1083,7 @@ nil, indicating the current buffer's process. */)
update_status (p);
symbol = CONSP (p->status) ? XCAR (p->status) : p->status;
if (! (EQ (symbol, Qsignal) || EQ (symbol, Qexit)))
pset_status (p, list2 (Qsignal, make_number (SIGKILL)));
pset_status (p, list2 (Qsignal, make_fixnum (SIGKILL)));
p->tick = ++process_tick;
status_notify (p, NULL);
@ -1151,7 +1151,7 @@ If PROCESS has not yet exited or died, return 0. */)
update_status (XPROCESS (process));
if (CONSP (XPROCESS (process)->status))
return XCAR (XCDR (XPROCESS (process)->status));
return make_number (0);
return make_fixnum (0);
}
DEFUN ("process-id", Fprocess_id, Sprocess_id, 1, 1, 0,
@ -1383,7 +1383,7 @@ nil otherwise. */)
if (NETCONN_P (process)
|| XPROCESS (process)->infd < 0
|| (set_window_size (XPROCESS (process)->infd,
XINT (height), XINT (width))
XFIXNUM (height), XFIXNUM (width))
< 0))
return Qnil;
else
@ -1584,12 +1584,12 @@ Return nil if format of ADDRESS is invalid. */)
for (i = 0; i < nargs; i++)
{
if (! RANGED_INTEGERP (0, p->contents[i], 65535))
if (! RANGED_FIXNUMP (0, p->contents[i], 65535))
return Qnil;
if (nargs <= 5 /* IPv4 */
&& i < 4 /* host, not port */
&& XINT (p->contents[i]) > 255)
&& XFIXNUM (p->contents[i]) > 255)
return Qnil;
args[i + 1] = p->contents[i];
@ -1789,7 +1789,7 @@ usage: (make-process &rest ARGS) */)
val = Vcoding_system_for_read;
if (NILP (val))
{
ptrdiff_t nargs2 = 3 + XINT (Flength (command));
ptrdiff_t nargs2 = 3 + XFIXNUM (Flength (command));
Lisp_Object tem2;
SAFE_ALLOCA_LISP (args2, nargs2);
ptrdiff_t i = 0;
@ -1819,7 +1819,7 @@ usage: (make-process &rest ARGS) */)
{
if (EQ (coding_systems, Qt))
{
ptrdiff_t nargs2 = 3 + XINT (Flength (command));
ptrdiff_t nargs2 = 3 + XFIXNUM (Flength (command));
Lisp_Object tem2;
SAFE_ALLOCA_LISP (args2, nargs2);
ptrdiff_t i = 0;
@ -1864,7 +1864,7 @@ usage: (make-process &rest ARGS) */)
{
tem = Qnil;
openp (Vexec_path, program, Vexec_suffixes, &tem,
make_number (X_OK), false);
make_fixnum (X_OK), false);
if (NILP (tem))
report_file_error ("Searching for program", program);
tem = Fexpand_file_name (tem, Qnil);
@ -2503,9 +2503,9 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, ptrdiff_t len)
{
DECLARE_POINTER_ALIAS (sin, struct sockaddr_in, sa);
len = sizeof (sin->sin_addr) + 1;
address = Fmake_vector (make_number (len), Qnil);
address = Fmake_vector (make_fixnum (len), Qnil);
p = XVECTOR (address);
p->contents[--len] = make_number (ntohs (sin->sin_port));
p->contents[--len] = make_fixnum (ntohs (sin->sin_port));
cp = (unsigned char *) &sin->sin_addr;
break;
}
@ -2515,11 +2515,11 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, ptrdiff_t len)
DECLARE_POINTER_ALIAS (sin6, struct sockaddr_in6, sa);
DECLARE_POINTER_ALIAS (ip6, uint16_t, &sin6->sin6_addr);
len = sizeof (sin6->sin6_addr) / 2 + 1;
address = Fmake_vector (make_number (len), Qnil);
address = Fmake_vector (make_fixnum (len), Qnil);
p = XVECTOR (address);
p->contents[--len] = make_number (ntohs (sin6->sin6_port));
p->contents[--len] = make_fixnum (ntohs (sin6->sin6_port));
for (i = 0; i < len; i++)
p->contents[i] = make_number (ntohs (ip6[i]));
p->contents[i] = make_fixnum (ntohs (ip6[i]));
return address;
}
#endif
@ -2547,8 +2547,8 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, ptrdiff_t len)
#endif
default:
len -= offsetof (struct sockaddr, sa_family) + sizeof (sa->sa_family);
address = Fcons (make_number (sa->sa_family),
Fmake_vector (make_number (len), Qnil));
address = Fcons (make_fixnum (sa->sa_family),
Fmake_vector (make_fixnum (len), Qnil));
p = XVECTOR (XCDR (address));
cp = (unsigned char *) &sa->sa_family + sizeof (sa->sa_family);
break;
@ -2556,7 +2556,7 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, ptrdiff_t len)
i = 0;
while (i < len)
p->contents[i++] = make_number (*cp++);
p->contents[i++] = make_fixnum (*cp++);
return address;
}
@ -2566,8 +2566,8 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, ptrdiff_t len)
static Lisp_Object
conv_addrinfo_to_lisp (struct addrinfo *res)
{
Lisp_Object protocol = make_number (res->ai_protocol);
eassert (XINT (protocol) == res->ai_protocol);
Lisp_Object protocol = make_fixnum (res->ai_protocol);
eassert (XFIXNUM (protocol) == res->ai_protocol);
return Fcons (protocol, conv_sockaddr_to_lisp (res->ai_addr, res->ai_addrlen));
}
@ -2602,14 +2602,14 @@ get_lisp_to_sockaddr_size (Lisp_Object address, int *familyp)
return sizeof (struct sockaddr_un);
}
#endif
else if (CONSP (address) && TYPE_RANGED_INTEGERP (int, XCAR (address))
else if (CONSP (address) && TYPE_RANGED_FIXNUMP (int, XCAR (address))
&& VECTORP (XCDR (address)))
{
struct sockaddr *sa;
p = XVECTOR (XCDR (address));
if (MAX_ALLOCA - sizeof sa->sa_family < p->header.size)
return 0;
*familyp = XINT (XCAR (address));
*familyp = XFIXNUM (XCAR (address));
return p->header.size + sizeof (sa->sa_family);
}
return 0;
@ -2639,7 +2639,7 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
{
DECLARE_POINTER_ALIAS (sin, struct sockaddr_in, sa);
len = sizeof (sin->sin_addr) + 1;
hostport = XINT (p->contents[--len]);
hostport = XFIXNUM (p->contents[--len]);
sin->sin_port = htons (hostport);
cp = (unsigned char *)&sin->sin_addr;
sa->sa_family = family;
@ -2650,12 +2650,12 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
DECLARE_POINTER_ALIAS (sin6, struct sockaddr_in6, sa);
DECLARE_POINTER_ALIAS (ip6, uint16_t, &sin6->sin6_addr);
len = sizeof (sin6->sin6_addr) / 2 + 1;
hostport = XINT (p->contents[--len]);
hostport = XFIXNUM (p->contents[--len]);
sin6->sin6_port = htons (hostport);
for (i = 0; i < len; i++)
if (INTEGERP (p->contents[i]))
if (FIXNUMP (p->contents[i]))
{
int j = XFASTINT (p->contents[i]) & 0xffff;
int j = XFIXNAT (p->contents[i]) & 0xffff;
ip6[i] = ntohs (j);
}
sa->sa_family = family;
@ -2686,8 +2686,8 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
}
for (i = 0; i < len; i++)
if (INTEGERP (p->contents[i]))
*cp++ = XFASTINT (p->contents[i]) & 0xff;
if (FIXNUMP (p->contents[i]))
*cp++ = XFIXNAT (p->contents[i]) & 0xff;
}
#ifdef DATAGRAM_SOCKETS
@ -2818,8 +2818,8 @@ set_socket_option (int s, Lisp_Object opt, Lisp_Object val)
case SOPT_INT:
{
int optval;
if (TYPE_RANGED_INTEGERP (int, val))
optval = XINT (val);
if (TYPE_RANGED_FIXNUMP (int, val))
optval = XFIXNUM (val);
else
error ("Bad option value for %s", name);
ret = setsockopt (s, sopt->optlevel, sopt->optnum,
@ -2857,8 +2857,8 @@ set_socket_option (int s, Lisp_Object opt, Lisp_Object val)
linger.l_onoff = 1;
linger.l_linger = 0;
if (TYPE_RANGED_INTEGERP (int, val))
linger.l_linger = XINT (val);
if (TYPE_RANGED_FIXNUMP (int, val))
linger.l_linger = XFIXNUM (val);
else
linger.l_onoff = NILP (val) ? 0 : 1;
ret = setsockopt (s, sopt->optlevel, sopt->optnum,
@ -3102,7 +3102,7 @@ usage: (make-serial-process &rest ARGS) */)
if (NILP (Fplist_member (contact, QCspeed)))
error (":speed not specified");
if (!NILP (Fplist_get (contact, QCspeed)))
CHECK_NUMBER (Fplist_get (contact, QCspeed));
CHECK_FIXNUM (Fplist_get (contact, QCspeed));
name = Fplist_get (contact, QCname);
if (NILP (name))
@ -3357,7 +3357,7 @@ connect_network_socket (Lisp_Object proc, Lisp_Object addrinfos,
{
Lisp_Object addrinfo = XCAR (addrinfos);
addrinfos = XCDR (addrinfos);
int protocol = XINT (XCAR (addrinfo));
int protocol = XFIXNUM (XCAR (addrinfo));
Lisp_Object ip_address = XCDR (addrinfo);
#ifdef WINDOWSNT
@ -3464,7 +3464,7 @@ connect_network_socket (Lisp_Object proc, Lisp_Object addrinfos,
DECLARE_POINTER_ALIAS (psa1, struct sockaddr, &sa1);
if (getsockname (s, psa1, &len1) == 0)
{
Lisp_Object service = make_number (ntohs (sa1.sin_port));
Lisp_Object service = make_fixnum (ntohs (sa1.sin_port));
contact = Fplist_put (contact, QCservice, service);
/* Save the port number so that we can stash it in
the process object later. */
@ -3922,7 +3922,7 @@ usage: (make-network-process &rest ARGS) */)
if (!get_lisp_to_sockaddr_size (address, &family))
error ("Malformed :address");
addrinfos = list1 (Fcons (make_number (any_protocol), address));
addrinfos = list1 (Fcons (make_fixnum (any_protocol), address));
goto open_socket;
}
@ -3946,8 +3946,8 @@ usage: (make-network-process &rest ARGS) */)
#endif
else if (EQ (tem, Qipv4))
family = AF_INET;
else if (TYPE_RANGED_INTEGERP (int, tem))
family = XINT (tem);
else if (TYPE_RANGED_FIXNUMP (int, tem))
family = XFIXNUM (tem);
else
error ("Unknown address family");
@ -3986,7 +3986,7 @@ usage: (make-network-process &rest ARGS) */)
CHECK_STRING (service);
if (sizeof address_un.sun_path <= SBYTES (service))
error ("Service name too long");
addrinfos = list1 (Fcons (make_number (any_protocol), service));
addrinfos = list1 (Fcons (make_fixnum (any_protocol), service));
goto open_socket;
}
#endif
@ -4013,10 +4013,10 @@ usage: (make-network-process &rest ARGS) */)
portstring = "0";
portstringlen = 1;
}
else if (INTEGERP (service))
else if (FIXNUMP (service))
{
portstring = portbuf;
portstringlen = sprintf (portbuf, "%"pI"d", XINT (service));
portstringlen = sprintf (portbuf, "%"pI"d", XFIXNUM (service));
}
else
{
@ -4101,8 +4101,8 @@ usage: (make-network-process &rest ARGS) */)
if (EQ (service, Qt))
port = 0;
else if (INTEGERP (service))
port = XINT (service);
else if (FIXNUMP (service))
port = XFIXNUM (service);
else
{
CHECK_STRING (service);
@ -4175,8 +4175,8 @@ usage: (make-network-process &rest ARGS) */)
/* :server QLEN */
p->is_server = !NILP (server);
if (TYPE_RANGED_INTEGERP (int, server))
p->backlog = XINT (server);
if (TYPE_RANGED_FIXNUMP (int, server))
p->backlog = XFIXNUM (server);
/* :nowait BOOL */
if (!p->is_server && socktype != SOCK_DGRAM && nowait)
@ -4400,7 +4400,7 @@ network_interface_info (Lisp_Object ifname)
{
if (flags & 1)
{
elt = Fcons (make_number (fnum), elt);
elt = Fcons (make_fixnum (fnum), elt);
}
}
}
@ -4411,21 +4411,21 @@ network_interface_info (Lisp_Object ifname)
#if defined (SIOCGIFHWADDR) && defined (HAVE_STRUCT_IFREQ_IFR_HWADDR)
if (ioctl (s, SIOCGIFHWADDR, &rq) == 0)
{
Lisp_Object hwaddr = Fmake_vector (make_number (6), Qnil);
Lisp_Object hwaddr = Fmake_vector (make_fixnum (6), Qnil);
register struct Lisp_Vector *p = XVECTOR (hwaddr);
int n;
any = 1;
for (n = 0; n < 6; n++)
p->contents[n] = make_number (((unsigned char *)
p->contents[n] = make_fixnum (((unsigned char *)
&rq.ifr_hwaddr.sa_data[0])
[n]);
elt = Fcons (make_number (rq.ifr_hwaddr.sa_family), hwaddr);
elt = Fcons (make_fixnum (rq.ifr_hwaddr.sa_family), hwaddr);
}
#elif defined (HAVE_GETIFADDRS) && defined (LLADDR)
if (getifaddrs (&ifap) != -1)
{
Lisp_Object hwaddr = Fmake_vector (make_number (6), Qnil);
Lisp_Object hwaddr = Fmake_vector (make_fixnum (6), Qnil);
register struct Lisp_Vector *p = XVECTOR (hwaddr);
struct ifaddrs *it;
@ -4442,9 +4442,9 @@ network_interface_info (Lisp_Object ifname)
memcpy (linkaddr, LLADDR (sdl), sdl->sdl_alen);
for (n = 0; n < 6; n++)
p->contents[n] = make_number (linkaddr[n]);
p->contents[n] = make_fixnum (linkaddr[n]);
elt = Fcons (make_number (it->ifa_addr->sa_family), hwaddr);
elt = Fcons (make_fixnum (it->ifa_addr->sa_family), hwaddr);
break;
}
}
@ -4630,13 +4630,13 @@ is nil, from any process) before the timeout expired. */)
if (!NILP (millisec))
{ /* Obsolete calling convention using integers rather than floats. */
CHECK_NUMBER (millisec);
CHECK_FIXNUM (millisec);
if (NILP (seconds))
seconds = make_float (XINT (millisec) / 1000.0);
seconds = make_float (XFIXNUM (millisec) / 1000.0);
else
{
CHECK_NUMBER (seconds);
seconds = make_float (XINT (millisec) / 1000.0 + XINT (seconds));
CHECK_FIXNUM (seconds);
seconds = make_float (XFIXNUM (millisec) / 1000.0 + XFIXNUM (seconds));
}
}
@ -4645,11 +4645,11 @@ is nil, from any process) before the timeout expired. */)
if (!NILP (seconds))
{
if (INTEGERP (seconds))
if (FIXNUMP (seconds))
{
if (XINT (seconds) > 0)
if (XFIXNUM (seconds) > 0)
{
secs = XINT (seconds);
secs = XFIXNUM (seconds);
nsecs = 0;
}
}
@ -4673,7 +4673,7 @@ is nil, from any process) before the timeout expired. */)
Qnil,
!NILP (process) ? XPROCESS (process) : NULL,
(NILP (just_this_one) ? 0
: !INTEGERP (just_this_one) ? 1 : -1))
: !FIXNUMP (just_this_one) ? 1 : -1))
<= 0)
? Qnil : Qt);
}
@ -4702,7 +4702,7 @@ server_accept_connection (Lisp_Object server, int channel)
if (!would_block (code) && !NILP (ps->log))
call3 (ps->log, server, Qnil,
concat3 (build_string ("accept failed with code"),
Fnumber_to_string (make_number (code)),
Fnumber_to_string (make_fixnum (code)),
build_string ("\n")));
return;
}
@ -4730,9 +4730,9 @@ server_accept_connection (Lisp_Object server, int channel)
args[nargs++] = procname_format_in;
nargs++;
unsigned char *ip = (unsigned char *)&saddr.in.sin_addr.s_addr;
service = make_number (ntohs (saddr.in.sin_port));
service = make_fixnum (ntohs (saddr.in.sin_port));
for (int i = 0; i < 4; i++)
args[nargs++] = make_number (ip[i]);
args[nargs++] = make_fixnum (ip[i]);
args[nargs++] = service;
}
break;
@ -4743,9 +4743,9 @@ server_accept_connection (Lisp_Object server, int channel)
args[nargs++] = procname_format_in6;
nargs++;
DECLARE_POINTER_ALIAS (ip6, uint16_t, &saddr.in6.sin6_addr);
service = make_number (ntohs (saddr.in.sin_port));
service = make_fixnum (ntohs (saddr.in.sin_port));
for (int i = 0; i < 8; i++)
args[nargs++] = make_number (ip6[i]);
args[nargs++] = make_fixnum (ip6[i]);
args[nargs++] = service;
}
break;
@ -4754,7 +4754,7 @@ server_accept_connection (Lisp_Object server, int channel)
default:
args[nargs++] = procname_format_default;
nargs++;
args[nargs++] = make_number (connect_counter);
args[nargs++] = make_fixnum (connect_counter);
break;
}
@ -5676,7 +5676,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
deactivate_process (proc);
if (EQ (XPROCESS (proc)->status, Qrun))
pset_status (XPROCESS (proc),
list2 (Qexit, make_number (0)));
list2 (Qexit, make_fixnum (0)));
}
else
{
@ -5687,7 +5687,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
update_status (XPROCESS (proc));
if (EQ (XPROCESS (proc)->status, Qrun))
pset_status (XPROCESS (proc),
list2 (Qexit, make_number (256)));
list2 (Qexit, make_fixnum (256)));
}
}
if (FD_ISSET (channel, &Writeok)
@ -5739,7 +5739,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
else
{
p->tick = ++process_tick;
pset_status (p, list2 (Qfailed, make_number (xerrno)));
pset_status (p, list2 (Qfailed, make_fixnum (xerrno)));
}
deactivate_process (proc);
if (!NILP (addrinfos))
@ -5808,7 +5808,7 @@ read_process_output_error_handler (Lisp_Object error_val)
cmd_error_internal (error_val, "error in process filter: ");
Vinhibit_quit = Qt;
update_echo_area ();
Fsleep_for (make_number (2), Qnil);
Fsleep_for (make_fixnum (2), Qnil);
return Qt;
}
@ -6126,7 +6126,7 @@ Otherwise it discards the output. */)
/* If the restriction isn't what it should be, set it. */
if (old_begv != BEGV || old_zv != ZV)
Fnarrow_to_region (make_number (old_begv), make_number (old_zv));
Fnarrow_to_region (make_fixnum (old_begv), make_fixnum (old_zv));
bset_read_only (current_buffer, old_read_only);
SET_PT_BOTH (opoint, opoint_byte);
@ -6173,7 +6173,7 @@ write_queue_push (struct Lisp_Process *p, Lisp_Object input_obj,
obj = make_unibyte_string (buf, len);
}
entry = Fcons (obj, Fcons (make_number (offset), make_number (len)));
entry = Fcons (obj, Fcons (make_fixnum (offset), make_fixnum (len)));
if (front)
pset_write_queue (p, Fcons (entry, p->write_queue));
@ -6201,8 +6201,8 @@ write_queue_pop (struct Lisp_Process *p, Lisp_Object *obj,
*obj = XCAR (entry);
offset_length = XCDR (entry);
*len = XINT (XCDR (offset_length));
offset = XINT (XCAR (offset_length));
*len = XFIXNUM (XCDR (offset_length));
offset = XFIXNUM (XCAR (offset_length));
*buf = SSDATA (*obj) + offset;
return 1;
@ -6420,7 +6420,7 @@ send_process (Lisp_Object proc, const char *buf, ptrdiff_t len,
else if (errno == EPIPE)
{
p->raw_status_new = 0;
pset_status (p, list2 (Qexit, make_number (256)));
pset_status (p, list2 (Qexit, make_fixnum (256)));
p->tick = ++process_tick;
deactivate_process (proc);
error ("process %s no longer connected to pipe; closed it",
@ -6456,11 +6456,11 @@ set up yet, this function will block until socket setup has completed. */)
validate_region (&start, &end);
start_byte = CHAR_TO_BYTE (XINT (start));
end_byte = CHAR_TO_BYTE (XINT (end));
start_byte = CHAR_TO_BYTE (XFIXNUM (start));
end_byte = CHAR_TO_BYTE (XFIXNUM (end));
if (XINT (start) < GPT && XINT (end) > GPT)
move_gap_both (XINT (start), start_byte);
if (XFIXNUM (start) < GPT && XFIXNUM (end) > GPT)
move_gap_both (XFIXNUM (start), start_byte);
if (NETCONN_P (proc))
wait_while_connecting (proc);
@ -6542,7 +6542,7 @@ process group. */)
if (gid == p->pid)
return Qnil;
if (gid != -1)
return make_number (gid);
return make_fixnum (gid);
return Qt;
}
@ -6847,16 +6847,16 @@ SIGCODE may be an integer, or a symbol whose name is a signal name. */)
{
Lisp_Object tem = Fget_process (process);
if (NILP (tem))
tem = string_to_number (SSDATA (process), 10, S2N_OVERFLOW_TO_FLOAT);
tem = string_to_number (SSDATA (process), 10, 0);
process = tem;
}
else if (!NUMBERP (process))
else if (!FIXED_OR_FLOATP (process))
process = get_process (process);
if (NILP (process))
return process;
if (NUMBERP (process))
if (FIXED_OR_FLOATP (process))
CONS_TO_INTEGER (process, pid_t, pid);
else
{
@ -6866,10 +6866,10 @@ SIGCODE may be an integer, or a symbol whose name is a signal name. */)
error ("Cannot signal process %s", SDATA (XPROCESS (process)->name));
}
if (INTEGERP (sigcode))
if (FIXNUMP (sigcode))
{
CHECK_TYPE_RANGED_INTEGER (int, sigcode);
signo = XINT (sigcode);
signo = XFIXNUM (sigcode);
}
else
{
@ -6883,7 +6883,7 @@ SIGCODE may be an integer, or a symbol whose name is a signal name. */)
error ("Undefined signal name %s", name);
}
return make_number (kill (pid, signo));
return make_fixnum (kill (pid, signo));
}
DEFUN ("process-send-eof", Fprocess_send_eof, Sprocess_send_eof, 0, 1, 0,
@ -7053,11 +7053,11 @@ handle_child_signal (int sig)
if (! CONSP (head))
continue;
xpid = XCAR (head);
if (all_pids_are_fixnums ? INTEGERP (xpid) : NUMBERP (xpid))
if (all_pids_are_fixnums ? FIXNUMP (xpid) : FIXED_OR_FLOATP (xpid))
{
pid_t deleted_pid;
if (INTEGERP (xpid))
deleted_pid = XINT (xpid);
if (FIXNUMP (xpid))
deleted_pid = XFIXNUM (xpid);
else
deleted_pid = XFLOAT_DATA (xpid);
if (child_status_changed (deleted_pid, 0, 0))
@ -7123,7 +7123,7 @@ exec_sentinel_error_handler (Lisp_Object error_val)
cmd_error_internal (error_val, "error in process sentinel: ");
Vinhibit_quit = Qt;
update_echo_area ();
Fsleep_for (make_number (2), Qnil);
Fsleep_for (make_fixnum (2), Qnil);
return Qt;
}

24
src/profiler.c
View file

@ -55,7 +55,7 @@ make_log (EMACS_INT heap_size, EMACS_INT max_stack_depth)
ptrdiff_t i = ASIZE (h->key_and_value) >> 1;
while (i > 0)
set_hash_key_slot (h, --i,
Fmake_vector (make_number (max_stack_depth), Qnil));
Fmake_vector (make_fixnum (max_stack_depth), Qnil));
return log;
}
@ -80,12 +80,12 @@ static EMACS_INT approximate_median (log_t *log,
{
eassert (size > 0);
if (size < 2)
return XINT (HASH_VALUE (log, start));
return XFIXNUM (HASH_VALUE (log, start));
if (size < 3)
/* Not an actual median, but better for our application than
choosing either of the two numbers. */
return ((XINT (HASH_VALUE (log, start))
+ XINT (HASH_VALUE (log, start + 1)))
return ((XFIXNUM (HASH_VALUE (log, start))
+ XFIXNUM (HASH_VALUE (log, start + 1)))
/ 2);
else
{
@ -110,7 +110,7 @@ static void evict_lower_half (log_t *log)
for (i = 0; i < size; i++)
/* Evict not only values smaller but also values equal to the median,
so as to make sure we evict something no matter what. */
if (XINT (HASH_VALUE (log, i)) <= median)
if (XFIXNUM (HASH_VALUE (log, i)) <= median)
{
Lisp_Object key = HASH_KEY (log, i);
{ /* FIXME: we could make this more efficient. */
@ -156,15 +156,15 @@ record_backtrace (log_t *log, EMACS_INT count)
ptrdiff_t j = hash_lookup (log, backtrace, &hash);
if (j >= 0)
{
EMACS_INT old_val = XINT (HASH_VALUE (log, j));
EMACS_INT old_val = XFIXNUM (HASH_VALUE (log, j));
EMACS_INT new_val = saturated_add (old_val, count);
set_hash_value_slot (log, j, make_number (new_val));
set_hash_value_slot (log, j, make_fixnum (new_val));
}
else
{ /* BEWARE! hash_put in general can allocate memory.
But currently it only does that if log->next_free is -1. */
eassert (0 <= log->next_free);
ptrdiff_t j = hash_put (log, backtrace, make_number (count), hash);
ptrdiff_t j = hash_put (log, backtrace, make_fixnum (count), hash);
/* Let's make sure we've put `backtrace' right where it
already was to start with. */
eassert (index == j);
@ -266,14 +266,14 @@ setup_cpu_timer (Lisp_Object sampling_interval)
struct timespec interval;
int billion = 1000000000;
if (! RANGED_INTEGERP (1, sampling_interval,
if (! RANGED_FIXNUMP (1, sampling_interval,
(TYPE_MAXIMUM (time_t) < EMACS_INT_MAX / billion
? ((EMACS_INT) TYPE_MAXIMUM (time_t) * billion
+ (billion - 1))
: EMACS_INT_MAX)))
return -1;
current_sampling_interval = XINT (sampling_interval);
current_sampling_interval = XFIXNUM (sampling_interval);
interval = make_timespec (current_sampling_interval / billion,
current_sampling_interval % billion);
emacs_sigaction_init (&action, deliver_profiler_signal);
@ -422,8 +422,8 @@ Before returning, a new log is allocated for future samples. */)
cpu_log = (profiler_cpu_running
? make_log (profiler_log_size, profiler_max_stack_depth)
: Qnil);
Fputhash (Fmake_vector (make_number (1), QAutomatic_GC),
make_number (cpu_gc_count),
Fputhash (Fmake_vector (make_fixnum (1), QAutomatic_GC),
make_fixnum (cpu_gc_count),
result);
cpu_gc_count = 0;
return result;

92
src/search.c
View file

@ -402,8 +402,8 @@ string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start,
{
ptrdiff_t len = SCHARS (string);
CHECK_NUMBER (start);
pos = XINT (start);
CHECK_FIXNUM (start);
pos = XFIXNUM (start);
if (pos < 0 && -pos <= len)
pos = len + pos;
else if (0 > pos || pos > len)
@ -448,7 +448,7 @@ string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start,
= string_byte_to_char (string, search_regs.end[i]);
}
return make_number (string_byte_to_char (string, val));
return make_fixnum (string_byte_to_char (string, val));
}
DEFUN ("string-match", Fstring_match, Sstring_match, 2, 3, 0,
@ -1038,8 +1038,8 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
if (!NILP (count))
{
CHECK_NUMBER (count);
n *= XINT (count);
CHECK_FIXNUM (count);
n *= XFIXNUM (count);
}
CHECK_STRING (string);
@ -1052,8 +1052,8 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
}
else
{
CHECK_NUMBER_COERCE_MARKER (bound);
lim = XINT (bound);
CHECK_FIXNUM_COERCE_MARKER (bound);
lim = XFIXNUM (bound);
if (n > 0 ? lim < PT : lim > PT)
error ("Invalid search bound (wrong side of point)");
if (lim > ZV)
@ -1099,7 +1099,7 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
eassert (BEGV <= np && np <= ZV);
SET_PT (np);
return make_number (np);
return make_fixnum (np);
}
/* Return true if REGEXP it matches just one constant string. */
@ -1154,9 +1154,9 @@ do \
if (! NILP (trt)) \
{ \
Lisp_Object temp; \
temp = Faref (trt, make_number (d)); \
if (INTEGERP (temp)) \
out = XINT (temp); \
temp = Faref (trt, make_fixnum (d)); \
if (FIXNUMP (temp)) \
out = XFIXNUM (temp); \
else \
out = d; \
} \
@ -2423,10 +2423,10 @@ since only regular expressions have distinguished subexpressions. */)
sub = 0;
else
{
CHECK_NUMBER (subexp);
if (! (0 <= XINT (subexp) && XINT (subexp) < search_regs.num_regs))
args_out_of_range (subexp, make_number (search_regs.num_regs));
sub = XINT (subexp);
CHECK_FIXNUM (subexp);
if (! (0 <= XFIXNUM (subexp) && XFIXNUM (subexp) < search_regs.num_regs))
args_out_of_range (subexp, make_fixnum (search_regs.num_regs));
sub = XFIXNUM (subexp);
}
if (NILP (string))
@ -2434,16 +2434,16 @@ since only regular expressions have distinguished subexpressions. */)
if (search_regs.start[sub] < BEGV
|| search_regs.start[sub] > search_regs.end[sub]
|| search_regs.end[sub] > ZV)
args_out_of_range (make_number (search_regs.start[sub]),
make_number (search_regs.end[sub]));
args_out_of_range (make_fixnum (search_regs.start[sub]),
make_fixnum (search_regs.end[sub]));
}
else
{
if (search_regs.start[sub] < 0
|| search_regs.start[sub] > search_regs.end[sub]
|| search_regs.end[sub] > SCHARS (string))
args_out_of_range (make_number (search_regs.start[sub]),
make_number (search_regs.end[sub]));
args_out_of_range (make_fixnum (search_regs.start[sub]),
make_fixnum (search_regs.end[sub]));
}
if (NILP (fixedcase))
@ -2528,9 +2528,9 @@ since only regular expressions have distinguished subexpressions. */)
{
Lisp_Object before, after;
before = Fsubstring (string, make_number (0),
make_number (search_regs.start[sub]));
after = Fsubstring (string, make_number (search_regs.end[sub]), Qnil);
before = Fsubstring (string, make_fixnum (0),
make_fixnum (search_regs.start[sub]));
after = Fsubstring (string, make_fixnum (search_regs.end[sub]), Qnil);
/* Substitute parts of the match into NEWTEXT
if desired. */
@ -2593,8 +2593,8 @@ since only regular expressions have distinguished subexpressions. */)
middle = Qnil;
accum = concat3 (accum, middle,
Fsubstring (string,
make_number (substart),
make_number (subend)));
make_fixnum (substart),
make_fixnum (subend)));
lastpos = pos;
lastpos_byte = pos_byte;
}
@ -2783,12 +2783,12 @@ since only regular expressions have distinguished subexpressions. */)
}
if (case_action == all_caps)
Fupcase_region (make_number (search_regs.start[sub]),
make_number (newpoint),
Fupcase_region (make_fixnum (search_regs.start[sub]),
make_fixnum (newpoint),
Qnil);
else if (case_action == cap_initial)
Fupcase_initials_region (make_number (search_regs.start[sub]),
make_number (newpoint));
Fupcase_initials_region (make_fixnum (search_regs.start[sub]),
make_fixnum (newpoint));
if (search_regs.start[sub] != sub_start
|| search_regs.end[sub] != sub_end
@ -2812,16 +2812,16 @@ match_limit (Lisp_Object num, bool beginningp)
{
EMACS_INT n;
CHECK_NUMBER (num);
n = XINT (num);
CHECK_FIXNUM (num);
n = XFIXNUM (num);
if (n < 0)
args_out_of_range (num, make_number (0));
args_out_of_range (num, make_fixnum (0));
if (search_regs.num_regs <= 0)
error ("No match data, because no search succeeded");
if (n >= search_regs.num_regs
|| search_regs.start[n] < 0)
return Qnil;
return (make_number ((beginningp) ? search_regs.start[n]
return (make_fixnum ((beginningp) ? search_regs.start[n]
: search_regs.end[n]));
}
@ -2911,11 +2911,11 @@ Return value is undefined if the last search failed. */)
{
data[2 * i] = Fmake_marker ();
Fset_marker (data[2 * i],
make_number (start),
make_fixnum (start),
last_thing_searched);
data[2 * i + 1] = Fmake_marker ();
Fset_marker (data[2 * i + 1],
make_number (search_regs.end[i]),
make_fixnum (search_regs.end[i]),
last_thing_searched);
}
else
@ -2992,7 +2992,7 @@ If optional arg RESEAT is non-nil, make markers on LIST point nowhere. */)
/* Allocate registers if they don't already exist. */
{
EMACS_INT length = XFASTINT (Flength (list)) / 2;
EMACS_INT length = XFIXNAT (Flength (list)) / 2;
if (length > search_regs.num_regs)
{
@ -3040,7 +3040,7 @@ If optional arg RESEAT is non-nil, make markers on LIST point nowhere. */)
XSETBUFFER (last_thing_searched, XMARKER (marker)->buffer);
}
CHECK_NUMBER_COERCE_MARKER (marker);
CHECK_FIXNUM_COERCE_MARKER (marker);
from = marker;
if (!NILP (reseat) && MARKERP (m))
@ -3057,13 +3057,13 @@ If optional arg RESEAT is non-nil, make markers on LIST point nowhere. */)
if (MARKERP (marker) && XMARKER (marker)->buffer == 0)
XSETFASTINT (marker, 0);
CHECK_NUMBER_COERCE_MARKER (marker);
if (PTRDIFF_MIN <= XINT (from) && XINT (from) <= PTRDIFF_MAX
&& PTRDIFF_MIN <= XINT (marker)
&& XINT (marker) <= PTRDIFF_MAX)
CHECK_FIXNUM_COERCE_MARKER (marker);
if (PTRDIFF_MIN <= XFIXNUM (from) && XFIXNUM (from) <= PTRDIFF_MAX
&& PTRDIFF_MIN <= XFIXNUM (marker)
&& XFIXNUM (marker) <= PTRDIFF_MAX)
{
search_regs.start[i] = XINT (from);
search_regs.end[i] = XINT (marker);
search_regs.start[i] = XFIXNUM (from);
search_regs.end[i] = XFIXNUM (marker);
}
else
{
@ -3349,11 +3349,11 @@ the buffer. If the buffer doesn't have a cache, the value is nil. */)
NULL, true);
if (shortage != 0 || i >= nl_count_cache)
break;
ASET (cache_newlines, i, make_number (found - 1));
ASET (cache_newlines, i, make_fixnum (found - 1));
}
/* Fill the rest of slots with an invalid position. */
for ( ; i < nl_count_cache; i++)
ASET (cache_newlines, i, make_number (-1));
ASET (cache_newlines, i, make_fixnum (-1));
}
/* Now do the same, but without using the cache. */
@ -3371,10 +3371,10 @@ the buffer. If the buffer doesn't have a cache, the value is nil. */)
NULL, true);
if (shortage != 0 || i >= nl_count_buf)
break;
ASET (buf_newlines, i, make_number (found - 1));
ASET (buf_newlines, i, make_fixnum (found - 1));
}
for ( ; i < nl_count_buf; i++)
ASET (buf_newlines, i, make_number (-1));
ASET (buf_newlines, i, make_fixnum (-1));
}
/* Construct the value and return it. */

12
src/sound.c
View file

@ -385,9 +385,9 @@ parse_sound (Lisp_Object sound, Lisp_Object *attrs)
/* Volume must be in the range 0..100 or unspecified. */
if (!NILP (attrs[SOUND_VOLUME]))
{
if (INTEGERP (attrs[SOUND_VOLUME]))
if (FIXNUMP (attrs[SOUND_VOLUME]))
{
EMACS_INT volume = XINT (attrs[SOUND_VOLUME]);
EMACS_INT volume = XFIXNUM (attrs[SOUND_VOLUME]);
if (! (0 <= volume && volume <= 100))
return 0;
}
@ -1400,8 +1400,8 @@ Internal use only, use `play-sound' instead. */)
/* Set up a device. */
current_sound_device->file = attrs[SOUND_DEVICE];
if (INTEGERP (attrs[SOUND_VOLUME]))
current_sound_device->volume = XFASTINT (attrs[SOUND_VOLUME]);
if (FIXNUMP (attrs[SOUND_VOLUME]))
current_sound_device->volume = XFIXNAT (attrs[SOUND_VOLUME]);
else if (FLOATP (attrs[SOUND_VOLUME]))
current_sound_device->volume = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
@ -1423,9 +1423,9 @@ Internal use only, use `play-sound' instead. */)
file = Fexpand_file_name (attrs[SOUND_FILE], Vdata_directory);
file = ENCODE_FILE (file);
if (INTEGERP (attrs[SOUND_VOLUME]))
if (FIXNUMP (attrs[SOUND_VOLUME]))
{
ui_volume_tmp = XFASTINT (attrs[SOUND_VOLUME]);
ui_volume_tmp = XFIXNAT (attrs[SOUND_VOLUME]);
}
else if (FLOATP (attrs[SOUND_VOLUME]))
{

190
src/syntax.c
View file

@ -491,7 +491,7 @@ parse_sexp_propertize (ptrdiff_t charpos)
{
EMACS_INT modiffs = CHARS_MODIFF;
safe_call1 (Qinternal__syntax_propertize,
make_number (min (zv, 1 + charpos)));
make_fixnum (min (zv, 1 + charpos)));
if (modiffs != CHARS_MODIFF)
error ("parse-sexp-propertize-function modified the buffer!");
if (syntax_propertize__done <= charpos
@ -609,14 +609,14 @@ find_defun_start (ptrdiff_t pos, ptrdiff_t pos_byte)
if (!NILP (Vcomment_use_syntax_ppss))
{
EMACS_INT modiffs = CHARS_MODIFF;
Lisp_Object ppss = call1 (Qsyntax_ppss, make_number (pos));
Lisp_Object ppss = call1 (Qsyntax_ppss, make_fixnum (pos));
if (modiffs != CHARS_MODIFF)
error ("syntax-ppss modified the buffer!");
TEMP_SET_PT_BOTH (opoint, opoint_byte);
Lisp_Object boc = Fnth (make_number (8), ppss);
if (NUMBERP (boc))
Lisp_Object boc = Fnth (make_fixnum (8), ppss);
if (FIXED_OR_FLOATP (boc))
{
find_start_value = XINT (boc);
find_start_value = XFIXNUM (boc);
find_start_value_byte = CHAR_TO_BYTE (find_start_value);
}
else
@ -953,7 +953,7 @@ back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop,
{
adjusted = true;
find_start_value
= CONSP (state.levelstarts) ? XINT (XCAR (state.levelstarts))
= CONSP (state.levelstarts) ? XFIXNUM (XCAR (state.levelstarts))
: state.thislevelstart >= 0 ? state.thislevelstart
: find_start_value;
find_start_value_byte = CHAR_TO_BYTE (find_start_value);
@ -1119,9 +1119,9 @@ this is probably the wrong function to use, because it can't take
{
int char_int;
CHECK_CHARACTER (character);
char_int = XINT (character);
char_int = XFIXNUM (character);
SETUP_BUFFER_SYNTAX_TABLE ();
return make_number (syntax_code_spec[SYNTAX (char_int)]);
return make_fixnum (syntax_code_spec[SYNTAX (char_int)]);
}
DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 1, 0,
@ -1131,7 +1131,7 @@ DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 1, 0,
int char_int;
enum syntaxcode code;
CHECK_CHARACTER (character);
char_int = XINT (character);
char_int = XFIXNUM (character);
SETUP_BUFFER_SYNTAX_TABLE ();
code = SYNTAX (char_int);
if (code == Sopen || code == Sclose)
@ -1166,7 +1166,7 @@ the value of a `syntax-table' text property. */)
int len;
int character = STRING_CHAR_AND_LENGTH (p, len);
XSETINT (match, character);
if (XFASTINT (match) == ' ')
if (XFIXNAT (match) == ' ')
match = Qnil;
p += len;
}
@ -1213,7 +1213,7 @@ the value of a `syntax-table' text property. */)
return AREF (Vsyntax_code_object, val);
else
/* Since we can't use a shared object, let's make a new one. */
return Fcons (make_number (val), match);
return Fcons (make_fixnum (val), match);
}
/* I really don't know why this is interactive
@ -1278,7 +1278,7 @@ usage: (modify-syntax-entry CHAR NEWENTRY &optional SYNTAX-TABLE) */)
if (CONSP (c))
SET_RAW_SYNTAX_ENTRY_RANGE (syntax_table, c, newentry);
else
SET_RAW_SYNTAX_ENTRY (syntax_table, XINT (c), newentry);
SET_RAW_SYNTAX_ENTRY (syntax_table, XFIXNUM (c), newentry);
/* We clear the regexp cache, since character classes can now have
different values from those in the compiled regexps.*/
@ -1320,13 +1320,13 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
first = XCAR (value);
match_lisp = XCDR (value);
if (!INTEGERP (first) || !(NILP (match_lisp) || CHARACTERP (match_lisp)))
if (!FIXNUMP (first) || !(NILP (match_lisp) || CHARACTERP (match_lisp)))
{
insert_string ("invalid");
return syntax;
}
syntax_code = XINT (first) & INT_MAX;
syntax_code = XFIXNUM (first) & INT_MAX;
code = syntax_code & 0377;
start1 = SYNTAX_FLAGS_COMSTART_FIRST (syntax_code);
start2 = SYNTAX_FLAGS_COMSTART_SECOND (syntax_code);
@ -1349,7 +1349,7 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
if (NILP (match_lisp))
insert (" ", 1);
else
insert_char (XINT (match_lisp));
insert_char (XFIXNUM (match_lisp));
if (start1)
insert ("1", 1);
@ -1414,7 +1414,7 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
if (!NILP (match_lisp))
{
insert_string (", matches ");
insert_char (XINT (match_lisp));
insert_char (XFIXNUM (match_lisp));
}
if (start1)
@ -1481,10 +1481,10 @@ scan_words (ptrdiff_t from, EMACS_INT count)
func = CHAR_TABLE_REF (Vfind_word_boundary_function_table, ch0);
if (! NILP (Ffboundp (func)))
{
pos = call2 (func, make_number (from - 1), make_number (end));
if (INTEGERP (pos) && from < XINT (pos) && XINT (pos) <= ZV)
pos = call2 (func, make_fixnum (from - 1), make_fixnum (end));
if (FIXNUMP (pos) && from < XFIXNUM (pos) && XFIXNUM (pos) <= ZV)
{
from = XINT (pos);
from = XFIXNUM (pos);
from_byte = CHAR_TO_BYTE (from);
}
}
@ -1530,10 +1530,10 @@ scan_words (ptrdiff_t from, EMACS_INT count)
func = CHAR_TABLE_REF (Vfind_word_boundary_function_table, ch1);
if (! NILP (Ffboundp (func)))
{
pos = call2 (func, make_number (from), make_number (beg));
if (INTEGERP (pos) && BEGV <= XINT (pos) && XINT (pos) < from)
pos = call2 (func, make_fixnum (from), make_fixnum (beg));
if (FIXNUMP (pos) && BEGV <= XFIXNUM (pos) && XFIXNUM (pos) < from)
{
from = XINT (pos);
from = XFIXNUM (pos);
from_byte = CHAR_TO_BYTE (from);
}
}
@ -1587,16 +1587,16 @@ instead. See Info node `(elisp) Word Motion' for details. */)
if (NILP (arg))
XSETFASTINT (arg, 1);
else
CHECK_NUMBER (arg);
CHECK_FIXNUM (arg);
val = orig_val = scan_words (PT, XINT (arg));
val = orig_val = scan_words (PT, XFIXNUM (arg));
if (! orig_val)
val = XINT (arg) > 0 ? ZV : BEGV;
val = XFIXNUM (arg) > 0 ? ZV : BEGV;
/* Avoid jumping out of an input field. */
tmp = Fconstrain_to_field (make_number (val), make_number (PT),
tmp = Fconstrain_to_field (make_fixnum (val), make_fixnum (PT),
Qnil, Qnil, Qnil);
val = XFASTINT (tmp);
val = XFIXNAT (tmp);
SET_PT (val);
return val == orig_val ? Qt : Qnil;
@ -1677,16 +1677,16 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
if (NILP (lim))
XSETINT (lim, forwardp ? ZV : BEGV);
else
CHECK_NUMBER_COERCE_MARKER (lim);
CHECK_FIXNUM_COERCE_MARKER (lim);
/* In any case, don't allow scan outside bounds of buffer. */
if (XINT (lim) > ZV)
if (XFIXNUM (lim) > ZV)
XSETFASTINT (lim, ZV);
if (XINT (lim) < BEGV)
if (XFIXNUM (lim) < BEGV)
XSETFASTINT (lim, BEGV);
multibyte = (!NILP (BVAR (current_buffer, enable_multibyte_characters))
&& (XINT (lim) - PT != CHAR_TO_BYTE (XINT (lim)) - PT_BYTE));
&& (XFIXNUM (lim) - PT != CHAR_TO_BYTE (XFIXNUM (lim)) - PT_BYTE));
string_multibyte = SBYTES (string) > SCHARS (string);
memset (fastmap, 0, sizeof fastmap);
@ -1722,7 +1722,7 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
error ("Invalid ISO C character class");
if (cc != -1)
{
iso_classes = Fcons (make_number (cc), iso_classes);
iso_classes = Fcons (make_fixnum (cc), iso_classes);
i_byte = ch - str;
continue;
}
@ -1818,7 +1818,7 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
error ("Invalid ISO C character class");
if (cc != -1)
{
iso_classes = Fcons (make_number (cc), iso_classes);
iso_classes = Fcons (make_fixnum (cc), iso_classes);
i_byte = ch - str;
continue;
}
@ -1937,13 +1937,13 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
if (forwardp)
{
endp = (XINT (lim) == GPT) ? GPT_ADDR : CHAR_POS_ADDR (XINT (lim));
stop = (pos < GPT && GPT < XINT (lim)) ? GPT_ADDR : endp;
endp = (XFIXNUM (lim) == GPT) ? GPT_ADDR : CHAR_POS_ADDR (XFIXNUM (lim));
stop = (pos < GPT && GPT < XFIXNUM (lim)) ? GPT_ADDR : endp;
}
else
{
endp = CHAR_POS_ADDR (XINT (lim));
stop = (pos >= GPT && GPT > XINT (lim)) ? GAP_END_ADDR : endp;
endp = CHAR_POS_ADDR (XFIXNUM (lim));
stop = (pos >= GPT && GPT > XFIXNUM (lim)) ? GAP_END_ADDR : endp;
}
/* This code may look up syntax tables using functions that rely on the
@ -2095,7 +2095,7 @@ skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
SET_PT_BOTH (pos, pos_byte);
SAFE_FREE ();
return make_number (PT - start_point);
return make_fixnum (PT - start_point);
}
}
@ -2116,19 +2116,19 @@ skip_syntaxes (bool forwardp, Lisp_Object string, Lisp_Object lim)
if (NILP (lim))
XSETINT (lim, forwardp ? ZV : BEGV);
else
CHECK_NUMBER_COERCE_MARKER (lim);
CHECK_FIXNUM_COERCE_MARKER (lim);
/* In any case, don't allow scan outside bounds of buffer. */
if (XINT (lim) > ZV)
if (XFIXNUM (lim) > ZV)
XSETFASTINT (lim, ZV);
if (XINT (lim) < BEGV)
if (XFIXNUM (lim) < BEGV)
XSETFASTINT (lim, BEGV);
if (forwardp ? (PT >= XFASTINT (lim)) : (PT <= XFASTINT (lim)))
return make_number (0);
if (forwardp ? (PT >= XFIXNAT (lim)) : (PT <= XFIXNAT (lim)))
return make_fixnum (0);
multibyte = (!NILP (BVAR (current_buffer, enable_multibyte_characters))
&& (XINT (lim) - PT != CHAR_TO_BYTE (XINT (lim)) - PT_BYTE));
&& (XFIXNUM (lim) - PT != CHAR_TO_BYTE (XFIXNUM (lim)) - PT_BYTE));
memset (fastmap, 0, sizeof fastmap);
@ -2173,8 +2173,8 @@ skip_syntaxes (bool forwardp, Lisp_Object string, Lisp_Object lim)
while (true)
{
p = BYTE_POS_ADDR (pos_byte);
endp = XINT (lim) == GPT ? GPT_ADDR : CHAR_POS_ADDR (XINT (lim));
stop = pos < GPT && GPT < XINT (lim) ? GPT_ADDR : endp;
endp = XFIXNUM (lim) == GPT ? GPT_ADDR : CHAR_POS_ADDR (XFIXNUM (lim));
stop = pos < GPT && GPT < XFIXNUM (lim) ? GPT_ADDR : endp;
do
{
@ -2206,8 +2206,8 @@ skip_syntaxes (bool forwardp, Lisp_Object string, Lisp_Object lim)
else
{
p = BYTE_POS_ADDR (pos_byte);
endp = CHAR_POS_ADDR (XINT (lim));
stop = pos >= GPT && GPT > XINT (lim) ? GAP_END_ADDR : endp;
endp = CHAR_POS_ADDR (XFIXNUM (lim));
stop = pos >= GPT && GPT > XFIXNUM (lim) ? GAP_END_ADDR : endp;
if (multibyte)
{
@ -2257,7 +2257,7 @@ skip_syntaxes (bool forwardp, Lisp_Object string, Lisp_Object lim)
done:
SET_PT_BOTH (pos, pos_byte);
return make_number (PT - start_point);
return make_fixnum (PT - start_point);
}
}
@ -2276,7 +2276,7 @@ in_classes (int c, Lisp_Object iso_classes)
elt = XCAR (iso_classes);
iso_classes = XCDR (iso_classes);
if (re_iswctype (c, XFASTINT (elt)))
if (re_iswctype (c, XFIXNAT (elt)))
fits_class = 1;
}
@ -2443,8 +2443,8 @@ between them, return t; otherwise return nil. */)
int dummy2;
unsigned short int quit_count = 0;
CHECK_NUMBER (count);
count1 = XINT (count);
CHECK_FIXNUM (count);
count1 = XFIXNUM (count);
stop = count1 > 0 ? ZV : BEGV;
from = PT;
@ -2794,7 +2794,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
if (depth < min_depth)
xsignal3 (Qscan_error,
build_string ("Containing expression ends prematurely"),
make_number (last_good), make_number (from));
make_fixnum (last_good), make_fixnum (from));
break;
case Sstring:
@ -2950,7 +2950,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
if (depth < min_depth)
xsignal3 (Qscan_error,
build_string ("Containing expression ends prematurely"),
make_number (last_good), make_number (from));
make_fixnum (last_good), make_fixnum (from));
break;
case Sendcomment:
@ -3030,7 +3030,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
lose:
xsignal3 (Qscan_error,
build_string ("Unbalanced parentheses"),
make_number (last_good), make_number (from));
make_fixnum (last_good), make_fixnum (from));
}
DEFUN ("scan-lists", Fscan_lists, Sscan_lists, 3, 3, 0,
@ -3054,11 +3054,11 @@ before we have scanned over COUNT lists, return nil if the depth at
that point is zero, and signal an error if the depth is nonzero. */)
(Lisp_Object from, Lisp_Object count, Lisp_Object depth)
{
CHECK_NUMBER (from);
CHECK_NUMBER (count);
CHECK_NUMBER (depth);
CHECK_FIXNUM (from);
CHECK_FIXNUM (count);
CHECK_FIXNUM (depth);
return scan_lists (XINT (from), XINT (count), XINT (depth), 0);
return scan_lists (XFIXNUM (from), XFIXNUM (count), XFIXNUM (depth), 0);
}
DEFUN ("scan-sexps", Fscan_sexps, Sscan_sexps, 2, 2, 0,
@ -3074,10 +3074,10 @@ If the beginning or end is reached between groupings
but before count is used up, nil is returned. */)
(Lisp_Object from, Lisp_Object count)
{
CHECK_NUMBER (from);
CHECK_NUMBER (count);
CHECK_FIXNUM (from);
CHECK_FIXNUM (count);
return scan_lists (XINT (from), XINT (count), 0, 1);
return scan_lists (XFIXNUM (from), XFIXNUM (count), 0, 1);
}
DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, Sbackward_prefix_chars,
@ -3217,8 +3217,8 @@ do { prev_from = from; \
while (!NILP (tem)) /* >= second enclosing sexps. */
{
Lisp_Object temhd = Fcar (tem);
if (RANGED_INTEGERP (PTRDIFF_MIN, temhd, PTRDIFF_MAX))
curlevel->last = XINT (temhd);
if (RANGED_FIXNUMP (PTRDIFF_MIN, temhd, PTRDIFF_MAX))
curlevel->last = XFIXNUM (temhd);
if (++curlevel == endlevel)
curlevel--; /* error ("Nesting too deep for parser"); */
curlevel->prev = -1;
@ -3463,7 +3463,7 @@ do { prev_from = from; \
state->location_byte = from_byte;
state->levelstarts = Qnil;
while (curlevel > levelstart)
state->levelstarts = Fcons (make_number ((--curlevel)->last),
state->levelstarts = Fcons (make_fixnum ((--curlevel)->last),
state->levelstarts);
state->prev_syntax = (SYNTAX_FLAGS_COMSTARTEND_FIRST (prev_from_syntax)
|| state->quoted) ? prev_from_syntax : Smax;
@ -3491,7 +3491,7 @@ internalize_parse_state (Lisp_Object external, struct lisp_parse_state *state)
{
tem = Fcar (external);
if (!NILP (tem))
state->depth = XINT (tem);
state->depth = XFIXNUM (tem);
else
state->depth = 0;
@ -3501,13 +3501,13 @@ internalize_parse_state (Lisp_Object external, struct lisp_parse_state *state)
tem = Fcar (external);
/* Check whether we are inside string_fence-style string: */
state->instring = (!NILP (tem)
? (CHARACTERP (tem) ? XFASTINT (tem) : ST_STRING_STYLE)
? (CHARACTERP (tem) ? XFIXNAT (tem) : ST_STRING_STYLE)
: -1);
external = Fcdr (external);
tem = Fcar (external);
state->incomment = (!NILP (tem)
? (INTEGERP (tem) ? XINT (tem) : -1)
? (FIXNUMP (tem) ? XFIXNUM (tem) : -1)
: 0);
external = Fcdr (external);
@ -3521,21 +3521,21 @@ internalize_parse_state (Lisp_Object external, struct lisp_parse_state *state)
tem = Fcar (external);
state->comstyle = (NILP (tem)
? 0
: (RANGED_INTEGERP (0, tem, ST_COMMENT_STYLE)
? XINT (tem)
: (RANGED_FIXNUMP (0, tem, ST_COMMENT_STYLE)
? XFIXNUM (tem)
: ST_COMMENT_STYLE));
external = Fcdr (external);
tem = Fcar (external);
state->comstr_start =
RANGED_INTEGERP (PTRDIFF_MIN, tem, PTRDIFF_MAX) ? XINT (tem) : -1;
RANGED_FIXNUMP (PTRDIFF_MIN, tem, PTRDIFF_MAX) ? XFIXNUM (tem) : -1;
external = Fcdr (external);
tem = Fcar (external);
state->levelstarts = tem;
external = Fcdr (external);
tem = Fcar (external);
state->prev_syntax = NILP (tem) ? Smax : XINT (tem);
state->prev_syntax = NILP (tem) ? Smax : XFIXNUM (tem);
}
}
@ -3584,16 +3584,16 @@ Sixth arg COMMENTSTOP non-nil means stop after the start of a comment.
if (!NILP (targetdepth))
{
CHECK_NUMBER (targetdepth);
target = XINT (targetdepth);
CHECK_FIXNUM (targetdepth);
target = XFIXNUM (targetdepth);
}
else
target = TYPE_MINIMUM (EMACS_INT); /* We won't reach this depth. */
validate_region (&from, &to);
internalize_parse_state (oldstate, &state);
scan_sexps_forward (&state, XINT (from), CHAR_TO_BYTE (XINT (from)),
XINT (to),
scan_sexps_forward (&state, XFIXNUM (from), CHAR_TO_BYTE (XFIXNUM (from)),
XFIXNUM (to),
target, !NILP (stopbefore),
(NILP (commentstop)
? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)));
@ -3601,32 +3601,32 @@ Sixth arg COMMENTSTOP non-nil means stop after the start of a comment.
SET_PT_BOTH (state.location, state.location_byte);
return
Fcons (make_number (state.depth),
Fcons (make_fixnum (state.depth),
Fcons (state.prevlevelstart < 0
? Qnil : make_number (state.prevlevelstart),
? Qnil : make_fixnum (state.prevlevelstart),
Fcons (state.thislevelstart < 0
? Qnil : make_number (state.thislevelstart),
? Qnil : make_fixnum (state.thislevelstart),
Fcons (state.instring >= 0
? (state.instring == ST_STRING_STYLE
? Qt : make_number (state.instring)) : Qnil,
? Qt : make_fixnum (state.instring)) : Qnil,
Fcons (state.incomment < 0 ? Qt :
(state.incomment == 0 ? Qnil :
make_number (state.incomment)),
make_fixnum (state.incomment)),
Fcons (state.quoted ? Qt : Qnil,
Fcons (make_number (state.mindepth),
Fcons (make_fixnum (state.mindepth),
Fcons ((state.comstyle
? (state.comstyle == ST_COMMENT_STYLE
? Qsyntax_table
: make_number (state.comstyle))
: make_fixnum (state.comstyle))
: Qnil),
Fcons (((state.incomment
|| (state.instring >= 0))
? make_number (state.comstr_start)
? make_fixnum (state.comstr_start)
: Qnil),
Fcons (state.levelstarts,
Fcons (state.prev_syntax == Smax
? Qnil
: make_number (state.prev_syntax),
: make_fixnum (state.prev_syntax),
Qnil)))))))))));
}
@ -3642,11 +3642,11 @@ init_syntax_once (void)
/* Create objects which can be shared among syntax tables. */
Vsyntax_code_object = make_uninit_vector (Smax);
for (i = 0; i < Smax; i++)
ASET (Vsyntax_code_object, i, Fcons (make_number (i), Qnil));
ASET (Vsyntax_code_object, i, Fcons (make_fixnum (i), Qnil));
/* Now we are ready to set up this property, so we can
create syntax tables. */
Fput (Qsyntax_table, Qchar_table_extra_slots, make_number (0));
Fput (Qsyntax_table, Qchar_table_extra_slots, make_fixnum (0));
temp = AREF (Vsyntax_code_object, Swhitespace);
@ -3678,21 +3678,21 @@ init_syntax_once (void)
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '%', temp);
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '(',
Fcons (make_number (Sopen), make_number (')')));
Fcons (make_fixnum (Sopen), make_fixnum (')')));
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, ')',
Fcons (make_number (Sclose), make_number ('(')));
Fcons (make_fixnum (Sclose), make_fixnum ('(')));
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '[',
Fcons (make_number (Sopen), make_number (']')));
Fcons (make_fixnum (Sopen), make_fixnum (']')));
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, ']',
Fcons (make_number (Sclose), make_number ('[')));
Fcons (make_fixnum (Sclose), make_fixnum ('[')));
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '{',
Fcons (make_number (Sopen), make_number ('}')));
Fcons (make_fixnum (Sopen), make_fixnum ('}')));
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '}',
Fcons (make_number (Sclose), make_number ('{')));
Fcons (make_fixnum (Sclose), make_fixnum ('{')));
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '"',
Fcons (make_number (Sstring), Qnil));
Fcons (make_fixnum (Sstring), Qnil));
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '\\',
Fcons (make_number (Sescape), Qnil));
Fcons (make_fixnum (Sescape), Qnil));
temp = AREF (Vsyntax_code_object, Ssymbol);
for (i = 0; i < 10; i++)

2
src/syntax.h
View file

@ -118,7 +118,7 @@ INLINE int
syntax_property_with_flags (int c, bool via_property)
{
Lisp_Object ent = syntax_property_entry (c, via_property);
return CONSP (ent) ? XINT (XCAR (ent)) : Swhitespace;
return CONSP (ent) ? XFIXNUM (XCAR (ent)) : Swhitespace;
}
INLINE int
SYNTAX_WITH_FLAGS (int c)

58
src/sysdep.c
View file

@ -2850,8 +2850,8 @@ serial_configure (struct Lisp_Process *p,
tem = Fplist_get (contact, QCspeed);
else
tem = Fplist_get (p->childp, QCspeed);
CHECK_NUMBER (tem);
err = cfsetspeed (&attr, XINT (tem));
CHECK_FIXNUM (tem);
err = cfsetspeed (&attr, XFIXNUM (tem));
if (err != 0)
report_file_error ("Failed cfsetspeed", tem);
childp2 = Fplist_put (childp2, QCspeed, tem);
@ -2862,17 +2862,17 @@ serial_configure (struct Lisp_Process *p,
else
tem = Fplist_get (p->childp, QCbytesize);
if (NILP (tem))
tem = make_number (8);
CHECK_NUMBER (tem);
if (XINT (tem) != 7 && XINT (tem) != 8)
tem = make_fixnum (8);
CHECK_FIXNUM (tem);
if (XFIXNUM (tem) != 7 && XFIXNUM (tem) != 8)
error (":bytesize must be nil (8), 7, or 8");
summary[0] = XINT (tem) + '0';
summary[0] = XFIXNUM (tem) + '0';
#if defined (CSIZE) && defined (CS7) && defined (CS8)
attr.c_cflag &= ~CSIZE;
attr.c_cflag |= ((XINT (tem) == 7) ? CS7 : CS8);
attr.c_cflag |= ((XFIXNUM (tem) == 7) ? CS7 : CS8);
#else
/* Don't error on bytesize 8, which should be set by cfmakeraw. */
if (XINT (tem) != 8)
if (XFIXNUM (tem) != 8)
error ("Bytesize cannot be changed");
#endif
childp2 = Fplist_put (childp2, QCbytesize, tem);
@ -2916,18 +2916,18 @@ serial_configure (struct Lisp_Process *p,
else
tem = Fplist_get (p->childp, QCstopbits);
if (NILP (tem))
tem = make_number (1);
CHECK_NUMBER (tem);
if (XINT (tem) != 1 && XINT (tem) != 2)
tem = make_fixnum (1);
CHECK_FIXNUM (tem);
if (XFIXNUM (tem) != 1 && XFIXNUM (tem) != 2)
error (":stopbits must be nil (1 stopbit), 1, or 2");
summary[2] = XINT (tem) + '0';
summary[2] = XFIXNUM (tem) + '0';
#if defined (CSTOPB)
attr.c_cflag &= ~CSTOPB;
if (XINT (tem) == 2)
if (XFIXNUM (tem) == 2)
attr.c_cflag |= CSTOPB;
#else
/* Don't error on 1 stopbit, which should be set by cfmakeraw. */
if (XINT (tem) != 1)
if (XFIXNUM (tem) != 1)
error ("Stopbits cannot be configured");
#endif
childp2 = Fplist_put (childp2, QCstopbits, tem);
@ -3261,7 +3261,7 @@ system_process_attributes (Lisp_Object pid)
Lisp_Object decoded_cmd;
ptrdiff_t count;
CHECK_NUMBER_OR_FLOAT (pid);
CHECK_FIXNUM_OR_FLOAT (pid);
CONS_TO_INTEGER (pid, pid_t, proc_id);
sprintf (procfn, "/proc/%"pMd, proc_id);
if (stat (procfn, &st) < 0)
@ -3369,8 +3369,8 @@ system_process_attributes (Lisp_Object pid)
ltime_from_jiffies (cstime + cutime,
clocks_per_sec)),
attrs);
attrs = Fcons (Fcons (Qpri, make_number (priority)), attrs);
attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs);
attrs = Fcons (Fcons (Qpri, make_fixnum (priority)), attrs);
attrs = Fcons (Fcons (Qnice, make_fixnum (niceness)), attrs);
attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount)),
attrs);
tnow = current_timespec ();
@ -3495,7 +3495,7 @@ system_process_attributes (Lisp_Object pid)
Lisp_Object decoded_cmd;
ptrdiff_t count;
CHECK_NUMBER_OR_FLOAT (pid);
CHECK_FIXNUM_OR_FLOAT (pid);
CONS_TO_INTEGER (pid, pid_t, proc_id);
sprintf (procfn, "/proc/%"pMd, proc_id);
if (stat (procfn, &st) < 0)
@ -3563,8 +3563,8 @@ system_process_attributes (Lisp_Object pid)
attrs = Fcons (Fcons (Qtime, make_lisp_time (pinfo.pr_time)), attrs);
attrs = Fcons (Fcons (Qctime, make_lisp_time (pinfo.pr_ctime)), attrs);
attrs = Fcons (Fcons (Qpri, make_number (pinfo.pr_lwp.pr_pri)), attrs);
attrs = Fcons (Fcons (Qnice, make_number (pinfo.pr_lwp.pr_nice)), attrs);
attrs = Fcons (Fcons (Qpri, make_fixnum (pinfo.pr_lwp.pr_pri)), attrs);
attrs = Fcons (Fcons (Qnice, make_fixnum (pinfo.pr_lwp.pr_nice)), attrs);
attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (pinfo.pr_nlwp)),
attrs);
@ -3630,7 +3630,7 @@ system_process_attributes (Lisp_Object pid)
Lisp_Object attrs = Qnil;
Lisp_Object decoded_comm;
CHECK_NUMBER_OR_FLOAT (pid);
CHECK_FIXNUM_OR_FLOAT (pid);
CONS_TO_INTEGER (pid, int, proc_id);
mib[3] = proc_id;
@ -3697,8 +3697,8 @@ system_process_attributes (Lisp_Object pid)
attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (proc.ki_tpgid)), attrs);
attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (proc.ki_rusage.ru_minflt)), attrs);
attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (proc.ki_rusage.ru_majflt)), attrs);
attrs = Fcons (Fcons (Qcminflt, make_number (proc.ki_rusage_ch.ru_minflt)), attrs);
attrs = Fcons (Fcons (Qcmajflt, make_number (proc.ki_rusage_ch.ru_majflt)), attrs);
attrs = Fcons (Fcons (Qcminflt, make_fixnum (proc.ki_rusage_ch.ru_minflt)), attrs);
attrs = Fcons (Fcons (Qcmajflt, make_fixnum (proc.ki_rusage_ch.ru_majflt)), attrs);
attrs = Fcons (Fcons (Qutime, make_lisp_timeval (proc.ki_rusage.ru_utime)),
attrs);
@ -3720,11 +3720,11 @@ system_process_attributes (Lisp_Object pid)
attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (proc.ki_numthreads)),
attrs);
attrs = Fcons (Fcons (Qpri, make_number (proc.ki_pri.pri_native)), attrs);
attrs = Fcons (Fcons (Qnice, make_number (proc.ki_nice)), attrs);
attrs = Fcons (Fcons (Qpri, make_fixnum (proc.ki_pri.pri_native)), attrs);
attrs = Fcons (Fcons (Qnice, make_fixnum (proc.ki_nice)), attrs);
attrs = Fcons (Fcons (Qstart, make_lisp_timeval (proc.ki_start)), attrs);
attrs = Fcons (Fcons (Qvsize, make_number (proc.ki_size >> 10)), attrs);
attrs = Fcons (Fcons (Qrss, make_number (proc.ki_rssize * pagesize >> 10)),
attrs = Fcons (Fcons (Qvsize, make_fixnum (proc.ki_size >> 10)), attrs);
attrs = Fcons (Fcons (Qrss, make_fixnum (proc.ki_rssize * pagesize >> 10)),
attrs);
now = current_timespec ();
@ -3810,7 +3810,7 @@ system_process_attributes (Lisp_Object pid)
Lisp_Object attrs = Qnil;
Lisp_Object decoded_comm;
CHECK_NUMBER_OR_FLOAT (pid);
CHECK_FIXNUM_OR_FLOAT (pid);
CONS_TO_INTEGER (pid, int, proc_id);
mib[3] = proc_id;
@ -3900,7 +3900,7 @@ system_process_attributes (Lisp_Object pid)
}
starttime = proc.kp_proc.p_starttime;
attrs = Fcons (Fcons (Qnice, make_number (proc.kp_proc.p_nice)), attrs);
attrs = Fcons (Fcons (Qnice, make_fixnum (proc.kp_proc.p_nice)), attrs);
attrs = Fcons (Fcons (Qstart, make_lisp_timeval (starttime)), attrs);
now = current_timespec ();

34
src/term.c
View file

@ -1359,7 +1359,7 @@ term_get_fkeys_1 (void)
char *sequence = tgetstr (keys[i].cap, address);
if (sequence)
Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (sequence),
Fmake_vector (make_number (1),
Fmake_vector (make_fixnum (1),
intern (keys[i].name)));
}
@ -1379,13 +1379,13 @@ term_get_fkeys_1 (void)
/* Define f0 first, so that f10 takes precedence in case the
key sequences happens to be the same. */
Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (k0),
Fmake_vector (make_number (1), intern ("f0")));
Fmake_vector (make_fixnum (1), intern ("f0")));
Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (k_semi),
Fmake_vector (make_number (1), intern ("f10")));
Fmake_vector (make_fixnum (1), intern ("f10")));
}
else if (k0)
Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (k0),
Fmake_vector (make_number (1), intern (k0_name)));
Fmake_vector (make_fixnum (1), intern (k0_name)));
}
/* Set up cookies for numbered function keys above f10. */
@ -1408,7 +1408,7 @@ term_get_fkeys_1 (void)
{
sprintf (fkey, "f%d", i);
Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (sequence),
Fmake_vector (make_number (1),
Fmake_vector (make_fixnum (1),
intern (fkey)));
}
}
@ -1425,7 +1425,7 @@ term_get_fkeys_1 (void)
char *sequence = tgetstr (cap2, address); \
if (sequence) \
Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (sequence), \
Fmake_vector (make_number (1), \
Fmake_vector (make_fixnum (1), \
intern (sym))); \
}
@ -2050,7 +2050,7 @@ TERMINAL does not refer to a text terminal. */)
{
struct terminal *t = decode_tty_terminal (terminal);
return make_number (t ? t->display_info.tty->TN_max_colors : 0);
return make_fixnum (t ? t->display_info.tty->TN_max_colors : 0);
}
#ifndef DOS_NT
@ -2137,7 +2137,7 @@ set_tty_color_mode (struct tty_display_info *tty, struct frame *f)
tem = assq_no_quit (Qtty_color_mode, f->param_alist);
val = CONSP (tem) ? XCDR (tem) : Qnil;
if (INTEGERP (val))
if (FIXNUMP (val))
color_mode = val;
else if (SYMBOLP (tty_color_mode_alist))
{
@ -2147,7 +2147,7 @@ set_tty_color_mode (struct tty_display_info *tty, struct frame *f)
else
color_mode = Qnil;
mode = TYPE_RANGED_INTEGERP (int, color_mode) ? XINT (color_mode) : 0;
mode = TYPE_RANGED_FIXNUMP (int, color_mode) ? XFIXNUM (color_mode) : 0;
if (mode != tty->previous_color_mode)
{
@ -2805,8 +2805,8 @@ mouse_get_xy (int *x, int *y)
&time_dummy);
if (!NILP (lmx))
{
*x = XINT (lmx);
*y = XINT (lmy);
*x = XFIXNUM (lmx);
*y = XFIXNUM (lmy);
}
}
@ -3403,9 +3403,9 @@ tty_menu_help_callback (char const *help_string, int pane, int item)
pane_name = first_item[MENU_ITEMS_ITEM_NAME];
/* (menu-item MENU-NAME PANE-NUMBER) */
menu_object = list3 (Qmenu_item, pane_name, make_number (pane));
menu_object = list3 (Qmenu_item, pane_name, make_fixnum (pane));
show_help_echo (help_string ? build_string (help_string) : Qnil,
Qnil, menu_object, make_number (item));
Qnil, menu_object, make_fixnum (item));
}
struct tty_pop_down_menu
@ -3477,7 +3477,7 @@ tty_menu_new_item_coords (struct frame *f, int which, int *x, int *y)
pos = AREF (items, i + 3);
if (NILP (str))
return;
ix = XINT (pos);
ix = XFIXNUM (pos);
if (ix <= *x
/* We use <= so the blank between 2 items on a TTY is
considered part of the previous item. */
@ -3488,14 +3488,14 @@ tty_menu_new_item_coords (struct frame *f, int which, int *x, int *y)
if (which == TTYM_NEXT)
{
if (i < last_i)
*x = XINT (AREF (items, i + 4 + 3));
*x = XFIXNUM (AREF (items, i + 4 + 3));
else
*x = 0; /* Wrap around to the first item. */
}
else if (prev_x < 0)
{
/* Wrap around to the last item. */
*x = XINT (AREF (items, last_i + 3));
*x = XFIXNUM (AREF (items, last_i + 3));
}
else
*x = prev_x;
@ -3754,7 +3754,7 @@ tty_menu_show (struct frame *f, int x, int y, int menuflags,
case TTYM_NEXT:
case TTYM_PREV:
tty_menu_new_item_coords (f, status, &item_x, &item_y);
entry = Fcons (make_number (item_x), make_number (item_y));
entry = Fcons (make_fixnum (item_x), make_fixnum (item_y));
break;
case TTYM_FAILURE:

2
src/termhooks.h
View file

@ -346,7 +346,7 @@ enum {
FIXNUM_BITS, so using it to represent a modifier key means that
characters thus modified have different integer equivalents
depending on the architecture they're running on. Oh, and
applying XINT to a character whose 2^28 bit is set might sign-extend
applying XFIXNUM to a character whose 2^28 bit is set might sign-extend
it, so you get a bunch of bits in the mask you didn't want.
The CHAR_ macros are defined in lisp.h. */

4
src/terminal.c
View file

@ -551,10 +551,10 @@ calculate_glyph_code_table (struct terminal *t)
struct unimapdesc unimapdesc = { entry_ct, entries };
if (ioctl (fd, GIO_UNIMAP, &unimapdesc) == 0)
{
glyphtab = Fmake_char_table (Qnil, make_number (-1));
glyphtab = Fmake_char_table (Qnil, make_fixnum (-1));
for (int i = 0; i < unimapdesc.entry_ct; i++)
char_table_set (glyphtab, entries[i].unicode,
make_number (entries[i].fontpos));
make_fixnum (entries[i].fontpos));
break;
}
if (errno != ENOMEM)

248
src/textprop.c
View file

@ -79,7 +79,7 @@ text_read_only (Lisp_Object propval)
static void
modify_text_properties (Lisp_Object buffer, Lisp_Object start, Lisp_Object end)
{
ptrdiff_t b = XINT (start), e = XINT (end);
ptrdiff_t b = XFIXNUM (start), e = XFIXNUM (end);
struct buffer *buf = XBUFFER (buffer), *old = current_buffer;
set_buffer_internal (buf);
@ -137,15 +137,15 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin,
ptrdiff_t searchpos;
CHECK_STRING_OR_BUFFER (object);
CHECK_NUMBER_COERCE_MARKER (*begin);
CHECK_NUMBER_COERCE_MARKER (*end);
CHECK_FIXNUM_COERCE_MARKER (*begin);
CHECK_FIXNUM_COERCE_MARKER (*end);
/* If we are asked for a point, but from a subr which operates
on a range, then return nothing. */
if (EQ (*begin, *end) && begin != end)
return NULL;
if (XINT (*begin) > XINT (*end))
if (XFIXNUM (*begin) > XFIXNUM (*end))
{
Lisp_Object n;
n = *begin;
@ -157,8 +157,8 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin,
{
register struct buffer *b = XBUFFER (object);
if (!(BUF_BEGV (b) <= XINT (*begin) && XINT (*begin) <= XINT (*end)
&& XINT (*end) <= BUF_ZV (b)))
if (!(BUF_BEGV (b) <= XFIXNUM (*begin) && XFIXNUM (*begin) <= XFIXNUM (*end)
&& XFIXNUM (*end) <= BUF_ZV (b)))
args_out_of_range (*begin, *end);
i = buffer_intervals (b);
@ -166,24 +166,24 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin,
if (BUF_BEGV (b) == BUF_ZV (b))
return NULL;
searchpos = XINT (*begin);
searchpos = XFIXNUM (*begin);
}
else
{
ptrdiff_t len = SCHARS (object);
if (! (0 <= XINT (*begin) && XINT (*begin) <= XINT (*end)
&& XINT (*end) <= len))
if (! (0 <= XFIXNUM (*begin) && XFIXNUM (*begin) <= XFIXNUM (*end)
&& XFIXNUM (*end) <= len))
args_out_of_range (*begin, *end);
XSETFASTINT (*begin, XFASTINT (*begin));
XSETFASTINT (*begin, XFIXNAT (*begin));
if (begin != end)
XSETFASTINT (*end, XFASTINT (*end));
XSETFASTINT (*end, XFIXNAT (*end));
i = string_intervals (object);
if (len == 0)
return NULL;
searchpos = XINT (*begin);
searchpos = XFIXNUM (*begin);
}
if (!i)
@ -544,7 +544,7 @@ interval_of (ptrdiff_t position, Lisp_Object object)
}
if (!(beg <= position && position <= end))
args_out_of_range (make_number (position), make_number (position));
args_out_of_range (make_fixnum (position), make_fixnum (position));
if (beg == end || !i)
return NULL;
@ -572,7 +572,7 @@ If POSITION is at the end of OBJECT, the value is nil. */)
it means it's the end of OBJECT.
There are no properties at the very end,
since no character follows. */
if (XINT (position) == LENGTH (i) + i->position)
if (XFIXNUM (position) == LENGTH (i) + i->position)
return Qnil;
return i->plist;
@ -604,7 +604,7 @@ get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop,
{
struct window *w = 0;
CHECK_NUMBER_COERCE_MARKER (position);
CHECK_FIXNUM_COERCE_MARKER (position);
if (NILP (object))
XSETBUFFER (object, current_buffer);
@ -621,14 +621,14 @@ get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop,
Lisp_Object *overlay_vec;
struct buffer *obuf = current_buffer;
if (XINT (position) < BUF_BEGV (XBUFFER (object))
|| XINT (position) > BUF_ZV (XBUFFER (object)))
if (XFIXNUM (position) < BUF_BEGV (XBUFFER (object))
|| XFIXNUM (position) > BUF_ZV (XBUFFER (object)))
xsignal1 (Qargs_out_of_range, position);
set_buffer_temp (XBUFFER (object));
USE_SAFE_ALLOCA;
GET_OVERLAYS_AT (XINT (position), overlay_vec, noverlays, NULL, false);
GET_OVERLAYS_AT (XFIXNUM (position), overlay_vec, noverlays, NULL, false);
noverlays = sort_overlays (overlay_vec, noverlays, w);
set_buffer_temp (obuf);
@ -714,8 +714,8 @@ before LIMIT. LIMIT is a no-op if it is greater than (point-max). */)
temp = Fnext_overlay_change (position);
if (! NILP (limit))
{
CHECK_NUMBER_COERCE_MARKER (limit);
if (XINT (limit) < XINT (temp))
CHECK_FIXNUM_COERCE_MARKER (limit);
if (XFIXNUM (limit) < XFIXNUM (temp))
temp = limit;
}
return Fnext_property_change (position, Qnil, temp);
@ -740,8 +740,8 @@ before LIMIT. LIMIT is a no-op if it is less than (point-min). */)
temp = Fprevious_overlay_change (position);
if (! NILP (limit))
{
CHECK_NUMBER_COERCE_MARKER (limit);
if (XINT (limit) > XINT (temp))
CHECK_FIXNUM_COERCE_MARKER (limit);
if (XFIXNUM (limit) > XFIXNUM (temp))
temp = limit;
}
return Fprevious_property_change (position, Qnil, temp);
@ -774,10 +774,10 @@ last valid position in OBJECT. */)
if (NILP (position))
{
if (NILP (limit))
position = make_number (SCHARS (object));
position = make_fixnum (SCHARS (object));
else
{
CHECK_NUMBER (limit);
CHECK_FIXNUM (limit);
position = limit;
}
}
@ -796,26 +796,26 @@ last valid position in OBJECT. */)
Fset_buffer (object);
}
CHECK_NUMBER_COERCE_MARKER (position);
CHECK_FIXNUM_COERCE_MARKER (position);
initial_value = Fget_char_property (position, prop, object);
if (NILP (limit))
XSETFASTINT (limit, ZV);
else
CHECK_NUMBER_COERCE_MARKER (limit);
CHECK_FIXNUM_COERCE_MARKER (limit);
if (XFASTINT (position) >= XFASTINT (limit))
if (XFIXNAT (position) >= XFIXNAT (limit))
{
position = limit;
if (XFASTINT (position) > ZV)
if (XFIXNAT (position) > ZV)
XSETFASTINT (position, ZV);
}
else
while (true)
{
position = Fnext_char_property_change (position, limit);
if (XFASTINT (position) >= XFASTINT (limit))
if (XFIXNAT (position) >= XFIXNAT (limit))
{
position = limit;
break;
@ -859,10 +859,10 @@ first valid position in OBJECT. */)
if (NILP (position))
{
if (NILP (limit))
position = make_number (0);
position = make_fixnum (0);
else
{
CHECK_NUMBER (limit);
CHECK_FIXNUM (limit);
position = limit;
}
}
@ -880,30 +880,30 @@ first valid position in OBJECT. */)
Fset_buffer (object);
}
CHECK_NUMBER_COERCE_MARKER (position);
CHECK_FIXNUM_COERCE_MARKER (position);
if (NILP (limit))
XSETFASTINT (limit, BEGV);
else
CHECK_NUMBER_COERCE_MARKER (limit);
CHECK_FIXNUM_COERCE_MARKER (limit);
if (XFASTINT (position) <= XFASTINT (limit))
if (XFIXNAT (position) <= XFIXNAT (limit))
{
position = limit;
if (XFASTINT (position) < BEGV)
if (XFIXNAT (position) < BEGV)
XSETFASTINT (position, BEGV);
}
else
{
Lisp_Object initial_value
= Fget_char_property (make_number (XFASTINT (position) - 1),
= Fget_char_property (make_fixnum (XFIXNAT (position) - 1),
prop, object);
while (true)
{
position = Fprevious_char_property_change (position, limit);
if (XFASTINT (position) <= XFASTINT (limit))
if (XFIXNAT (position) <= XFIXNAT (limit))
{
position = limit;
break;
@ -911,7 +911,7 @@ first valid position in OBJECT. */)
else
{
Lisp_Object value
= Fget_char_property (make_number (XFASTINT (position) - 1),
= Fget_char_property (make_fixnum (XFIXNAT (position) - 1),
prop, object);
if (!EQ (value, initial_value))
@ -948,7 +948,7 @@ past position LIMIT; return LIMIT if nothing is found before LIMIT. */)
XSETBUFFER (object, current_buffer);
if (!NILP (limit) && !EQ (limit, Qt))
CHECK_NUMBER_COERCE_MARKER (limit);
CHECK_FIXNUM_COERCE_MARKER (limit);
i = validate_interval_range (object, &position, &position, soft);
@ -976,19 +976,19 @@ past position LIMIT; return LIMIT if nothing is found before LIMIT. */)
next = next_interval (i);
while (next && intervals_equal (i, next)
&& (NILP (limit) || next->position < XFASTINT (limit)))
&& (NILP (limit) || next->position < XFIXNAT (limit)))
next = next_interval (next);
if (!next
|| (next->position
>= (INTEGERP (limit)
? XFASTINT (limit)
>= (FIXNUMP (limit)
? XFIXNAT (limit)
: (STRINGP (object)
? SCHARS (object)
: BUF_ZV (XBUFFER (object))))))
return limit;
else
return make_number (next->position);
return make_fixnum (next->position);
}
DEFUN ("next-single-property-change", Fnext_single_property_change,
@ -1015,7 +1015,7 @@ past position LIMIT; return LIMIT if nothing is found before LIMIT. */)
XSETBUFFER (object, current_buffer);
if (!NILP (limit))
CHECK_NUMBER_COERCE_MARKER (limit);
CHECK_FIXNUM_COERCE_MARKER (limit);
i = validate_interval_range (object, &position, &position, soft);
if (!i)
@ -1025,19 +1025,19 @@ past position LIMIT; return LIMIT if nothing is found before LIMIT. */)
next = next_interval (i);
while (next
&& EQ (here_val, textget (next->plist, prop))
&& (NILP (limit) || next->position < XFASTINT (limit)))
&& (NILP (limit) || next->position < XFIXNAT (limit)))
next = next_interval (next);
if (!next
|| (next->position
>= (INTEGERP (limit)
? XFASTINT (limit)
>= (FIXNUMP (limit)
? XFIXNAT (limit)
: (STRINGP (object)
? SCHARS (object)
: BUF_ZV (XBUFFER (object))))))
return limit;
else
return make_number (next->position);
return make_fixnum (next->position);
}
DEFUN ("previous-property-change", Fprevious_property_change,
@ -1062,30 +1062,30 @@ back past position LIMIT; return LIMIT if nothing is found until LIMIT. */)
XSETBUFFER (object, current_buffer);
if (!NILP (limit))
CHECK_NUMBER_COERCE_MARKER (limit);
CHECK_FIXNUM_COERCE_MARKER (limit);
i = validate_interval_range (object, &position, &position, soft);
if (!i)
return limit;
/* Start with the interval containing the char before point. */
if (i->position == XFASTINT (position))
if (i->position == XFIXNAT (position))
i = previous_interval (i);
previous = previous_interval (i);
while (previous && intervals_equal (previous, i)
&& (NILP (limit)
|| (previous->position + LENGTH (previous) > XFASTINT (limit))))
|| (previous->position + LENGTH (previous) > XFIXNAT (limit))))
previous = previous_interval (previous);
if (!previous
|| (previous->position + LENGTH (previous)
<= (INTEGERP (limit)
? XFASTINT (limit)
<= (FIXNUMP (limit)
? XFIXNAT (limit)
: (STRINGP (object) ? 0 : BUF_BEGV (XBUFFER (object))))))
return limit;
else
return make_number (previous->position + LENGTH (previous));
return make_fixnum (previous->position + LENGTH (previous));
}
DEFUN ("previous-single-property-change", Fprevious_single_property_change,
@ -1112,12 +1112,12 @@ back past position LIMIT; return LIMIT if nothing is found until LIMIT. */)
XSETBUFFER (object, current_buffer);
if (!NILP (limit))
CHECK_NUMBER_COERCE_MARKER (limit);
CHECK_FIXNUM_COERCE_MARKER (limit);
i = validate_interval_range (object, &position, &position, soft);
/* Start with the interval containing the char before point. */
if (i && i->position == XFASTINT (position))
if (i && i->position == XFIXNAT (position))
i = previous_interval (i);
if (!i)
@ -1128,17 +1128,17 @@ back past position LIMIT; return LIMIT if nothing is found until LIMIT. */)
while (previous
&& EQ (here_val, textget (previous->plist, prop))
&& (NILP (limit)
|| (previous->position + LENGTH (previous) > XFASTINT (limit))))
|| (previous->position + LENGTH (previous) > XFIXNAT (limit))))
previous = previous_interval (previous);
if (!previous
|| (previous->position + LENGTH (previous)
<= (INTEGERP (limit)
? XFASTINT (limit)
<= (FIXNUMP (limit)
? XFIXNAT (limit)
: (STRINGP (object) ? 0 : BUF_BEGV (XBUFFER (object))))))
return limit;
else
return make_number (previous->position + LENGTH (previous));
return make_fixnum (previous->position + LENGTH (previous));
}
/* Used by add-text-properties and add-face-text-property. */
@ -1164,8 +1164,8 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
if (!i)
return Qnil;
s = XINT (start);
len = XINT (end) - s;
s = XFIXNUM (start);
len = XFIXNUM (end) - s;
/* If this interval already has the properties, we can skip it. */
if (interval_has_all_properties (properties, i))
@ -1221,8 +1221,8 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
if (interval_has_all_properties (properties, i))
{
if (BUFFERP (object))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
eassert (modified);
return Qt;
@ -1232,8 +1232,8 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
{
add_properties (properties, i, object, set_type);
if (BUFFERP (object))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
return Qt;
}
@ -1243,8 +1243,8 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
copy_properties (unchanged, i);
add_properties (properties, i, object, set_type);
if (BUFFERP (object))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
return Qt;
}
@ -1363,8 +1363,8 @@ set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties,
/* If we want no properties for a whole string,
get rid of its intervals. */
if (NILP (properties) && STRINGP (object)
&& XFASTINT (start) == 0
&& XFASTINT (end) == SCHARS (object))
&& XFIXNAT (start) == 0
&& XFIXNAT (end) == SCHARS (object))
{
if (!string_intervals (object))
return Qnil;
@ -1413,8 +1413,8 @@ set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties,
set_text_properties_1 (start, end, properties, object, i);
if (BUFFERP (object) && !NILP (coherent_change_p))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
return Qt;
}
@ -1431,15 +1431,15 @@ set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object propertie
register ptrdiff_t s, len;
INTERVAL unchanged;
if (XINT (start) < XINT (end))
if (XFIXNUM (start) < XFIXNUM (end))
{
s = XINT (start);
len = XINT (end) - s;
s = XFIXNUM (start);
len = XFIXNUM (end) - s;
}
else if (XINT (end) < XINT (start))
else if (XFIXNUM (end) < XFIXNUM (start))
{
s = XINT (end);
len = XINT (start) - s;
s = XFIXNUM (end);
len = XFIXNUM (start) - s;
}
else
return;
@ -1531,8 +1531,8 @@ Use `set-text-properties' if you want to remove all text properties. */)
if (!i)
return Qnil;
s = XINT (start);
len = XINT (end) - s;
s = XFIXNUM (start);
len = XFIXNUM (end) - s;
/* If there are no properties on this entire interval, return. */
if (! interval_has_some_properties (properties, i))
@ -1589,8 +1589,8 @@ Use `set-text-properties' if you want to remove all text properties. */)
{
eassert (modified);
if (BUFFERP (object))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
return Qt;
}
@ -1598,8 +1598,8 @@ Use `set-text-properties' if you want to remove all text properties. */)
{
remove_properties (properties, Qnil, i, object);
if (BUFFERP (object))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
return Qt;
}
@ -1609,8 +1609,8 @@ Use `set-text-properties' if you want to remove all text properties. */)
copy_properties (unchanged, i);
remove_properties (properties, Qnil, i, object);
if (BUFFERP (object))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
return Qt;
}
@ -1643,8 +1643,8 @@ Return t if any property was actually removed, nil otherwise. */)
if (!i)
return Qnil;
s = XINT (start);
len = XINT (end) - s;
s = XFIXNUM (start);
len = XFIXNUM (end) - s;
/* If there are no properties on the interval, return. */
if (! interval_has_some_properties_list (properties, i))
@ -1687,9 +1687,9 @@ Return t if any property was actually removed, nil otherwise. */)
if (modified)
{
if (BUFFERP (object))
signal_after_change (XINT (start),
XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
return Qt;
}
else
@ -1701,8 +1701,8 @@ Return t if any property was actually removed, nil otherwise. */)
modify_text_properties (object, start, end);
remove_properties (Qnil, properties, i, object);
if (BUFFERP (object))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
return Qt;
}
else
@ -1714,8 +1714,8 @@ Return t if any property was actually removed, nil otherwise. */)
modify_text_properties (object, start, end);
remove_properties (Qnil, properties, i, object);
if (BUFFERP (object))
signal_after_change (XINT (start), XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start), XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
return Qt;
}
}
@ -1733,9 +1733,9 @@ Return t if any property was actually removed, nil otherwise. */)
if (modified)
{
if (BUFFERP (object))
signal_after_change (XINT (start),
XINT (end) - XINT (start),
XINT (end) - XINT (start));
signal_after_change (XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start),
XFIXNUM (end) - XFIXNUM (start));
return Qt;
}
else
@ -1762,7 +1762,7 @@ markers). If OBJECT is a string, START and END are 0-based indices into it. */
i = validate_interval_range (object, &start, &end, soft);
if (!i)
return (!NILP (value) || EQ (start, end) ? Qnil : start);
e = XINT (end);
e = XFIXNUM (end);
while (i)
{
@ -1771,9 +1771,9 @@ markers). If OBJECT is a string, START and END are 0-based indices into it. */
if (EQ (textget (i->plist, property), value))
{
pos = i->position;
if (pos < XINT (start))
pos = XINT (start);
return make_number (pos);
if (pos < XFIXNUM (start))
pos = XFIXNUM (start);
return make_fixnum (pos);
}
i = next_interval (i);
}
@ -1798,8 +1798,8 @@ markers). If OBJECT is a string, START and END are 0-based indices into it. */
i = validate_interval_range (object, &start, &end, soft);
if (!i)
return (NILP (value) || EQ (start, end)) ? Qnil : start;
s = XINT (start);
e = XINT (end);
s = XFIXNUM (start);
e = XFIXNUM (end);
while (i)
{
@ -1809,7 +1809,7 @@ markers). If OBJECT is a string, START and END are 0-based indices into it. */
{
if (i->position > s)
s = i->position;
return make_number (s);
return make_fixnum (s);
}
i = next_interval (i);
}
@ -1827,7 +1827,7 @@ int
text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
{
bool ignore_previous_character;
Lisp_Object prev_pos = make_number (XINT (pos) - 1);
Lisp_Object prev_pos = make_fixnum (XFIXNUM (pos) - 1);
Lisp_Object front_sticky;
bool is_rear_sticky = true, is_front_sticky = false; /* defaults */
Lisp_Object defalt = Fassq (prop, Vtext_property_default_nonsticky);
@ -1835,7 +1835,7 @@ text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
if (NILP (buffer))
XSETBUFFER (buffer, current_buffer);
ignore_previous_character = XINT (pos) <= BUF_BEGV (XBUFFER (buffer));
ignore_previous_character = XFIXNUM (pos) <= BUF_BEGV (XBUFFER (buffer));
if (ignore_previous_character || (CONSP (defalt) && !NILP (XCDR (defalt))))
is_rear_sticky = false;
@ -1907,11 +1907,11 @@ copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src,
if (!i)
return Qnil;
CHECK_NUMBER_COERCE_MARKER (pos);
CHECK_FIXNUM_COERCE_MARKER (pos);
{
Lisp_Object dest_start, dest_end;
e = XINT (pos) + (XINT (end) - XINT (start));
e = XFIXNUM (pos) + (XFIXNUM (end) - XFIXNUM (start));
if (MOST_POSITIVE_FIXNUM < e)
args_out_of_range (pos, end);
dest_start = pos;
@ -1921,9 +1921,9 @@ copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src,
validate_interval_range (dest, &dest_start, &dest_end, soft);
}
s = XINT (start);
e = XINT (end);
p = XINT (pos);
s = XFIXNUM (start);
e = XFIXNUM (end);
p = XFIXNUM (pos);
stuff = Qnil;
@ -1948,7 +1948,7 @@ copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src,
if (! NILP (plist))
/* Must defer modifications to the interval tree in case
src and dest refer to the same string or buffer. */
stuff = Fcons (list3 (make_number (p), make_number (p + len), plist),
stuff = Fcons (list3 (make_fixnum (p), make_fixnum (p + len), plist),
stuff);
i = next_interval (i);
@ -1991,8 +1991,8 @@ text_property_list (Lisp_Object object, Lisp_Object start, Lisp_Object end, Lisp
i = validate_interval_range (object, &start, &end, soft);
if (i)
{
ptrdiff_t s = XINT (start);
ptrdiff_t e = XINT (end);
ptrdiff_t s = XFIXNUM (start);
ptrdiff_t e = XFIXNUM (end);
while (s < e)
{
@ -2015,7 +2015,7 @@ text_property_list (Lisp_Object object, Lisp_Object start, Lisp_Object end, Lisp
}
if (!NILP (plist))
result = Fcons (list3 (make_number (s), make_number (s + len),
result = Fcons (list3 (make_fixnum (s), make_fixnum (s + len),
plist),
result);
@ -2043,8 +2043,8 @@ add_text_properties_from_list (Lisp_Object object, Lisp_Object list, Lisp_Object
Lisp_Object item, start, end, plist;
item = XCAR (list);
start = make_number (XINT (XCAR (item)) + XINT (delta));
end = make_number (XINT (XCAR (XCDR (item))) + XINT (delta));
start = make_fixnum (XFIXNUM (XCAR (item)) + XFIXNUM (delta));
end = make_fixnum (XFIXNUM (XCAR (XCDR (item))) + XFIXNUM (delta));
plist = XCAR (XCDR (XCDR (item)));
Fadd_text_properties (start, end, plist, object);
@ -2062,7 +2062,7 @@ Lisp_Object
extend_property_ranges (Lisp_Object list, Lisp_Object old_end, Lisp_Object new_end)
{
Lisp_Object prev = Qnil, head = list;
ptrdiff_t max = XINT (new_end);
ptrdiff_t max = XFIXNUM (new_end);
for (; CONSP (list); prev = list, list = XCDR (list))
{
@ -2071,9 +2071,9 @@ extend_property_ranges (Lisp_Object list, Lisp_Object old_end, Lisp_Object new_e
item = XCAR (list);
beg = XCAR (item);
end = XINT (XCAR (XCDR (item)));
end = XFIXNUM (XCAR (XCDR (item)));
if (XINT (beg) >= max)
if (XFIXNUM (beg) >= max)
{
/* The start-point is past the end of the new string.
Discard this property. */
@ -2082,7 +2082,7 @@ extend_property_ranges (Lisp_Object list, Lisp_Object old_end, Lisp_Object new_e
else
XSETCDR (prev, XCDR (list));
}
else if ((end == XINT (old_end) && end != max)
else if ((end == XFIXNUM (old_end) && end != max)
|| end > max)
{
/* Either the end-point is past the end of the new string,
@ -2287,8 +2287,8 @@ verify_interval_modification (struct buffer *buf,
hooks = Fnreverse (hooks);
while (! NILP (hooks))
{
call_mod_hooks (Fcar (hooks), make_number (start),
make_number (end));
call_mod_hooks (Fcar (hooks), make_fixnum (start),
make_fixnum (end));
hooks = Fcdr (hooks);
}
}

20
src/undo.c
View file

@ -74,7 +74,7 @@ record_point (ptrdiff_t beg)
&& point_before_last_command_or_undo != beg
&& buffer_before_last_command_or_undo == current_buffer )
bset_undo_list (current_buffer,
Fcons (make_number (point_before_last_command_or_undo),
Fcons (make_fixnum (point_before_last_command_or_undo),
BVAR (current_buffer, undo_list)));
}
@ -102,11 +102,11 @@ record_insert (ptrdiff_t beg, ptrdiff_t length)
Lisp_Object elt;
elt = XCAR (BVAR (current_buffer, undo_list));
if (CONSP (elt)
&& INTEGERP (XCAR (elt))
&& INTEGERP (XCDR (elt))
&& XINT (XCDR (elt)) == beg)
&& FIXNUMP (XCAR (elt))
&& FIXNUMP (XCDR (elt))
&& XFIXNUM (XCDR (elt)) == beg)
{
XSETCDR (elt, make_number (beg + length));
XSETCDR (elt, make_fixnum (beg + length));
return;
}
}
@ -153,7 +153,7 @@ record_marker_adjustments (ptrdiff_t from, ptrdiff_t to)
XSETMISC (marker, m);
bset_undo_list
(current_buffer,
Fcons (Fcons (marker, make_number (adjustment)),
Fcons (Fcons (marker, make_fixnum (adjustment)),
BVAR (current_buffer, undo_list)));
}
}
@ -352,14 +352,14 @@ truncate_undo_list (struct buffer *b)
/* If by the first boundary we have already passed undo_outer_limit,
we're heading for memory full, so offer to clear out the list. */
if (INTEGERP (Vundo_outer_limit)
&& size_so_far > XINT (Vundo_outer_limit)
if (FIXNUMP (Vundo_outer_limit)
&& size_so_far > XFIXNUM (Vundo_outer_limit)
&& !NILP (Vundo_outer_limit_function))
{
Lisp_Object tem;
/* Normally the function this calls is undo-outer-limit-truncate. */
tem = call1 (Vundo_outer_limit_function, make_number (size_so_far));
tem = call1 (Vundo_outer_limit_function, make_fixnum (size_so_far));
if (! NILP (tem))
{
/* The function is responsible for making
@ -472,7 +472,7 @@ In fact, this calls the function which is the value of
`undo-outer-limit-function' with one argument, the size.
The text above describes the behavior of the function
that variable usually specifies. */);
Vundo_outer_limit = make_number (12000000);
Vundo_outer_limit = make_fixnum (12000000);
DEFVAR_LISP ("undo-outer-limit-function", Vundo_outer_limit_function,
doc: /* Function to call when an undo list exceeds `undo-outer-limit'.

2
src/w16select.c
View file

@ -536,7 +536,7 @@ DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_dat
message3 (make_unibyte_string (system_error_msg, sizeof (system_error_msg) - 1));
break;
}
sit_for (make_number (2), 0, 2);
sit_for (make_fixnum (2), 0, 2);
}
done:

46
src/w32.c
View file

@ -7042,8 +7042,8 @@ system_process_attributes (Lisp_Object pid)
double pcpu;
BOOL result = FALSE;
CHECK_NUMBER_OR_FLOAT (pid);
proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
CHECK_FIXNUM_OR_FLOAT (pid);
proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XFIXNUM (pid);
h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
@ -7074,7 +7074,7 @@ system_process_attributes (Lisp_Object pid)
attrs = Fcons (Fcons (Qppid,
make_fixnum_or_float (pe.th32ParentProcessID)),
attrs);
attrs = Fcons (Fcons (Qpri, make_number (pe.pcPriClassBase)),
attrs = Fcons (Fcons (Qpri, make_fixnum (pe.pcPriClassBase)),
attrs);
attrs = Fcons (Fcons (Qthcount,
make_fixnum_or_float (pe.cntThreads)),
@ -9214,7 +9214,7 @@ network_interface_get_info (Lisp_Object ifname)
res);
else if (strcmp (namebuf, SSDATA (ifname)) == 0)
{
Lisp_Object hwaddr = Fmake_vector (make_number (6), Qnil);
Lisp_Object hwaddr = Fmake_vector (make_fixnum (6), Qnil);
register struct Lisp_Vector *p = XVECTOR (hwaddr);
Lisp_Object flags = Qnil;
int n;
@ -9243,11 +9243,11 @@ network_interface_get_info (Lisp_Object ifname)
/* Hardware address and its family. */
for (n = 0; n < adapter->AddressLength; n++)
p->contents[n] = make_number ((int) adapter->Address[n]);
p->contents[n] = make_fixnum ((int) adapter->Address[n]);
/* Windows does not support AF_LINK or AF_PACKET family
of addresses. Use an arbitrary family number that is
identical to what GNU/Linux returns. */
res = Fcons (Fcons (make_number (1), hwaddr), res);
res = Fcons (Fcons (make_fixnum (1), hwaddr), res);
/* Network mask. */
sa.sin_family = AF_INET;
@ -9309,9 +9309,9 @@ network_interface_get_info (Lisp_Object ifname)
Fcons (intern ("up"), Qnil))), Qnil);
/* 772 is what 3 different GNU/Linux systems report for
the loopback interface. */
res = Fcons (Fcons (make_number (772),
Fmake_vector (make_number (6),
make_number (0))),
res = Fcons (Fcons (make_fixnum (772),
Fmake_vector (make_fixnum (6),
make_fixnum (0))),
res);
sa.sin_addr.s_addr = sys_inet_addr ("255.0.0.0");
res = Fcons (conv_sockaddr_to_lisp ((struct sockaddr *) &sa,
@ -9456,7 +9456,7 @@ w32_read_registry (HKEY rootkey, Lisp_Object lkey, Lisp_Object lname)
val = make_uninit_vector (vsize);
for (i = 0; i < vsize; i++)
ASET (val, i, make_number (dbuf[i]));
ASET (val, i, make_fixnum (dbuf[i]));
retval = val;
break;
@ -10106,8 +10106,8 @@ serial_configure (struct Lisp_Process *p, Lisp_Object contact)
tem = Fplist_get (contact, QCspeed);
else
tem = Fplist_get (p->childp, QCspeed);
CHECK_NUMBER (tem);
dcb.BaudRate = XINT (tem);
CHECK_FIXNUM (tem);
dcb.BaudRate = XFIXNUM (tem);
childp2 = Fplist_put (childp2, QCspeed, tem);
/* Configure bytesize. */
@ -10116,12 +10116,12 @@ serial_configure (struct Lisp_Process *p, Lisp_Object contact)
else
tem = Fplist_get (p->childp, QCbytesize);
if (NILP (tem))
tem = make_number (8);
CHECK_NUMBER (tem);
if (XINT (tem) != 7 && XINT (tem) != 8)
tem = make_fixnum (8);
CHECK_FIXNUM (tem);
if (XFIXNUM (tem) != 7 && XFIXNUM (tem) != 8)
error (":bytesize must be nil (8), 7, or 8");
dcb.ByteSize = XINT (tem);
summary[0] = XINT (tem) + '0';
dcb.ByteSize = XFIXNUM (tem);
summary[0] = XFIXNUM (tem) + '0';
childp2 = Fplist_put (childp2, QCbytesize, tem);
/* Configure parity. */
@ -10160,14 +10160,14 @@ serial_configure (struct Lisp_Process *p, Lisp_Object contact)
else
tem = Fplist_get (p->childp, QCstopbits);
if (NILP (tem))
tem = make_number (1);
CHECK_NUMBER (tem);
if (XINT (tem) != 1 && XINT (tem) != 2)
tem = make_fixnum (1);
CHECK_FIXNUM (tem);
if (XFIXNUM (tem) != 1 && XFIXNUM (tem) != 2)
error (":stopbits must be nil (1 stopbit), 1, or 2");
summary[2] = XINT (tem) + '0';
if (XINT (tem) == 1)
summary[2] = XFIXNUM (tem) + '0';
if (XFIXNUM (tem) == 1)
dcb.StopBits = ONESTOPBIT;
else if (XINT (tem) == 2)
else if (XFIXNUM (tem) == 2)
dcb.StopBits = TWOSTOPBITS;
childp2 = Fplist_put (childp2, QCstopbits, tem);

10
src/w32console.c
View file

@ -493,7 +493,7 @@ w32con_set_terminal_modes (struct terminal *t)
/* Initialize input mode: interrupt_input off, no flow control, allow
8 bit character input, standard quit char. */
Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
Fset_input_mode (Qnil, Qnil, make_fixnum (2), Qnil);
}
/* hmmm... perhaps these let us bracket screen changes so that we can flush
@ -791,7 +791,7 @@ DEFUN ("set-screen-color", Fset_screen_color, Sset_screen_color, 2, 2, 0,
Arguments should be indices between 0 and 15, see w32console.el. */)
(Lisp_Object foreground, Lisp_Object background)
{
char_attr_normal = XFASTINT (foreground) + (XFASTINT (background) << 4);
char_attr_normal = XFIXNAT (foreground) + (XFIXNAT (background) << 4);
Frecenter (Qnil, Qt);
return Qt;
@ -805,8 +805,8 @@ See w32console.el and `tty-defined-color-alist' for mapping of indices
to colors. */)
(void)
{
return Fcons (make_number (char_attr_normal & 0x000f),
Fcons (make_number ((char_attr_normal >> 4) & 0x000f), Qnil));
return Fcons (make_fixnum (char_attr_normal & 0x000f),
Fcons (make_fixnum ((char_attr_normal >> 4) & 0x000f), Qnil));
}
DEFUN ("set-cursor-size", Fset_cursor_size, Sset_cursor_size, 1, 1, 0,
@ -814,7 +814,7 @@ DEFUN ("set-cursor-size", Fset_cursor_size, Sset_cursor_size, 1, 1, 0,
(Lisp_Object size)
{
CONSOLE_CURSOR_INFO cci;
cci.dwSize = XFASTINT (size);
cci.dwSize = XFIXNAT (size);
cci.bVisible = TRUE;
(void) SetConsoleCursorInfo (cur_screen, &cci);

16
src/w32cygwinx.c
View file

@ -116,14 +116,14 @@ The following %-sequences are provided:
}
status = listn (CONSTYPE_HEAP, 8,
Fcons (make_number ('L'), line_status),
Fcons (make_number ('B'), battery_status),
Fcons (make_number ('b'), battery_status_symbol),
Fcons (make_number ('p'), load_percentage),
Fcons (make_number ('s'), seconds),
Fcons (make_number ('m'), minutes),
Fcons (make_number ('h'), hours),
Fcons (make_number ('t'), remain));
Fcons (make_fixnum ('L'), line_status),
Fcons (make_fixnum ('B'), battery_status),
Fcons (make_fixnum ('b'), battery_status_symbol),
Fcons (make_fixnum ('p'), load_percentage),
Fcons (make_fixnum ('s'), seconds),
Fcons (make_fixnum ('m'), minutes),
Fcons (make_fixnum ('h'), hours),
Fcons (make_fixnum ('t'), remain));
}
return status;
}

Some files were not shown because too many files have changed in this diff Show more