But, for the moment, we are not using this slot. */
#define CATEGORYP(x) \
- (INTEGERP ((x)) && XFASTINT ((x)) >= 0x20 && XFASTINT ((x)) <= 0x7E)
+ (FIXNUMP ((x)) && XFASTINT ((x)) >= 0x20 && XFASTINT ((x)) <= 0x7E)
#define CHECK_CATEGORY(x, i) \
do { \
(BOOL_VECTOR_P ((x)) && (EMACS_INT) (XBOOL_VECTOR ((x))->size) == 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))
/* Make CATEGORY_SET includes (if VAL is t) or excludes (if VAL is
nil) CATEGORY. */
&& NILP (temp = XCHAR_TABLE (table)->defalt)) \
table = XCHAR_TABLE (table)->parent; \
else \
- temp = Faref (table, make_number (c)); \
+ temp = Faref (table, make_fixnum (c)); \
temp; })
#else
#define CATEGORY_SET(c) \
- Faref (current_buffer->category_table, make_number (c))
+ Faref (current_buffer->category_table, make_fixnum (c))
#endif
/* Return the doc string of CATEGORY in category table TABLE. */
#define CATEGORY_DOCSTRING(table, category) \
- XVECTOR (Fchar_table_extra_slot (table, make_number (0)))->contents[(category) - ' ']
+ XVECTOR (Fchar_table_extra_slot (table, make_fixnum (0)))->contents[(category) - ' ']
/* 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 1 if there is a word boundary between two word-constituent
characters C1 and C2 if they appear in this order, else return 0.
if (c < 0) c = MAKE_CHAR (charset, (c1 & 0x7F) , (c2 & 0x7F));
if (!CHAR_TABLE_P (table)
- || (ch = Faref (table, make_number (c)), !NATNUMP (ch)))
+ || (ch = Faref (table, make_fixnum (c)), !NATNUMP (ch)))
return c;
SPLIT_CHAR (XFASTINT (ch), alt_charset, alt_c1, alt_c2);
if (! NILP (Vnonascii_translation_table))
{
- c = XINT (Faref (Vnonascii_translation_table, make_number (c)));
+ c = XINT (Faref (Vnonascii_translation_table, make_fixnum (c)));
if (c >= 0400 && ! char_valid_p (c, 0))
c = c_save + DEFAULT_NONASCII_INSERT_OFFSET;
}
on Vnonascii_translation_table or nonascii_insert_offset. If
REV_TBL is non-nil, it should be a reverse table of
Vnonascii_translation_table, i.e. what given by:
- Fchar_table_extra_slot (Vnonascii_translation_table, make_number (0)) */
+ Fchar_table_extra_slot (Vnonascii_translation_table, make_fixnum (0)) */
int
multibyte_char_to_unibyte (c, rev_tbl)
if (! CHAR_TABLE_P (rev_tbl)
&& CHAR_TABLE_P (Vnonascii_translation_table))
rev_tbl = Fchar_table_extra_slot (Vnonascii_translation_table,
- make_number (0));
+ make_fixnum (0));
if (CHAR_TABLE_P (rev_tbl))
{
Lisp_Object temp;
- temp = Faref (rev_tbl, make_number (c));
- if (INTEGERP (temp))
+ temp = Faref (rev_tbl, make_fixnum (c));
+ if (FIXNUMP (temp))
c = XINT (temp);
if (c >= 256)
c = (c_save & 0177) + 0200;
if (NILP (CHARSET_TABLE_ENTRY (charset)))
CHARSET_TABLE_ENTRY (charset)
- = Fmake_vector (make_number (CHARSET_MAX_IDX), Qnil);
+ = Fmake_vector (make_fixnum (CHARSET_MAX_IDX), Qnil);
if (NILP (long_name))
long_name = short_name;
}
CHARSET_TABLE_INFO (charset, CHARSET_ID_IDX) = charset_id;
- CHARSET_TABLE_INFO (charset, CHARSET_BYTES_IDX) = make_number (bytes);
+ CHARSET_TABLE_INFO (charset, CHARSET_BYTES_IDX) = make_fixnum (bytes);
CHARSET_TABLE_INFO (charset, CHARSET_DIMENSION_IDX) = dimension;
CHARSET_TABLE_INFO (charset, CHARSET_CHARS_IDX) = chars;
CHARSET_TABLE_INFO (charset, CHARSET_WIDTH_IDX) = width;
CHARSET_TABLE_INFO (charset, CHARSET_DIRECTION_IDX) = direction;
CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_BASE_IDX)
- = make_number (leading_code_base);
+ = make_fixnum (leading_code_base);
CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_EXT_IDX)
- = make_number (leading_code_ext);
+ = make_fixnum (leading_code_ext);
CHARSET_TABLE_INFO (charset, CHARSET_ISO_FINAL_CHAR_IDX) = iso_final_char;
CHARSET_TABLE_INFO (charset, CHARSET_ISO_GRAPHIC_PLANE_IDX)
= iso_graphic_plane;
&& CHARSET_DIRECTION (i) != XINT (direction))
{
CHARSET_TABLE_INFO (charset, CHARSET_REVERSE_CHARSET_IDX)
- = make_number (i);
+ = make_fixnum (i);
CHARSET_TABLE_INFO (i, CHARSET_REVERSE_CHARSET_IDX) = charset_id;
break;
}
if (i > MAX_CHARSET)
/* No such a charset. */
CHARSET_TABLE_INFO (charset, CHARSET_REVERSE_CHARSET_IDX)
- = make_number (-1);
+ = make_fixnum (-1);
}
if (charset != CHARSET_ASCII && charset != CHARSET_8_BIT_GRAPHIC
for (charset = from; charset < to; charset++)
if (!CHARSET_DEFINED_P (charset)) break;
- return make_number (charset < to ? charset : 0);
+ return make_fixnum (charset < to ? charset : 0);
}
DEFUN ("define-charset", Fdefine_charset, Sdefine_charset, 3, 3, 0,
vec = XVECTOR (info_vector)->contents;
if (XVECTOR (info_vector)->size != 9
- || !INTEGERP (vec[0]) || !(XINT (vec[0]) == 1 || XINT (vec[0]) == 2)
- || !INTEGERP (vec[1]) || !(XINT (vec[1]) == 94 || XINT (vec[1]) == 96)
- || !INTEGERP (vec[2]) || !(XINT (vec[2]) == 1 || XINT (vec[2]) == 2)
- || !INTEGERP (vec[3]) || !(XINT (vec[3]) == 0 || XINT (vec[3]) == 1)
- || !INTEGERP (vec[4])
+ || !FIXNUMP (vec[0]) || !(XINT (vec[0]) == 1 || XINT (vec[0]) == 2)
+ || !FIXNUMP (vec[1]) || !(XINT (vec[1]) == 94 || XINT (vec[1]) == 96)
+ || !FIXNUMP (vec[2]) || !(XINT (vec[2]) == 1 || XINT (vec[2]) == 2)
+ || !FIXNUMP (vec[3]) || !(XINT (vec[3]) == 0 || XINT (vec[3]) == 1)
+ || !FIXNUMP (vec[4])
|| !(XINT (vec[4]) == -1 || XINT (vec[4]) >= '0' && XINT (vec[4]) <= '~')
- || !INTEGERP (vec[5])
+ || !FIXNUMP (vec[5])
|| !(XINT (vec[5]) == -1 || XINT (vec[5]) == 0 || XINT (vec[5]) == 1)
|| !STRINGP (vec[6])
|| !STRINGP (vec[7])
XINT (chars));
for (final_char = '0'; final_char <= '?'; final_char++)
{
- if (ISO_CHARSET_TABLE (dimension, chars, make_number (final_char)) < 0)
+ if (ISO_CHARSET_TABLE (dimension, chars, make_fixnum (final_char)) < 0)
break;
}
- return (final_char <= '?' ? make_number (final_char) : Qnil);
+ return (final_char <= '?' ? make_fixnum (final_char) : Qnil);
}
DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset, Sdeclare_equiv_charset,
{
if (c1 < 0 || c1 > 0x7F)
goto invalid_code_posints;
- return make_number (c1);
+ return make_fixnum (c1);
}
else if (charset_id == CHARSET_8_BIT_CONTROL)
{
c1 = 0x80;
else if (c1 < 0x80 || c1 > 0x9F)
goto invalid_code_posints;
- return make_number (c1);
+ return make_fixnum (c1);
}
else if (charset_id == CHARSET_8_BIT_GRAPHIC)
{
c1 = 0xA0;
else if (c1 < 0xA0 || c1 > 0xFF)
goto invalid_code_posints;
- return make_number (c1);
+ return make_fixnum (c1);
}
else if (c1 < 0 || c1 > 0xFF || c2 < 0 || c2 > 0xFF)
goto invalid_code_posints;
? !CHAR_COMPONENTS_VALID_P (charset_id, c1, 0x20)
: !CHAR_COMPONENTS_VALID_P (charset_id, c1, c2)))
goto invalid_code_posints;
- return make_number (MAKE_CHAR (charset_id, c1, c2));
+ return make_fixnum (MAKE_CHAR (charset_id, c1, c2));
invalid_code_posints:
error ("Invalid code points for charset ID %d: %d %d", charset_id, c1, c2);
SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
return (c2 >= 0
? Fcons (CHARSET_SYMBOL (charset),
- Fcons (make_number (c1), Fcons (make_number (c2), Qnil)))
- : Fcons (CHARSET_SYMBOL (charset), Fcons (make_number (c1), Qnil)));
+ Fcons (make_fixnum (c1), Fcons (make_fixnum (c2), Qnil)))
+ : Fcons (CHARSET_SYMBOL (charset), Fcons (make_fixnum (c1), Qnil)));
}
DEFUN ("char-charset", Fchar_charset, Schar_charset, 1, 1, 0,
int charset;
ch = Fchar_after (pos);
- if (! INTEGERP (ch))
+ if (! FIXNUMP (ch))
return ch;
charset = CHAR_CHARSET (XINT (ch));
return CHARSET_SYMBOL (charset);
c = unibyte_char_to_multibyte (c);
if (c < 0)
error ("Can't convert to multibyte character: %d", XINT (ch));
- return make_number (c);
+ return make_fixnum (c);
}
DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte,
c = multibyte_char_to_unibyte (c, Qnil);
if (c < 0)
error ("Can't convert to unibyte character: %d", XINT (ch));
- return make_number (c);
+ return make_fixnum (c);
}
DEFUN ("char-bytes", Fchar_bytes, Schar_bytes, 1, 1, 0,
Lisp_Object ch;
{
CHECK_NUMBER (ch, 0);
- return make_number (1);
+ return make_fixnum (1);
}
/* Return how many bytes C will occupy in a multibyte buffer.
from = min (XFASTINT (beg), XFASTINT (end));
to = max (XFASTINT (beg), XFASTINT (end));
- return make_number (to - from);
+ return make_fixnum (to - from);
}
/* Return the number of characters in the NBYTES bytes at PTR.
/* Now we are ready to set up this property, so we can
create the charset table. */
- Fput (Qcharset_table, Qchar_table_extra_slots, make_number (0));
+ Fput (Qcharset_table, Qchar_table_extra_slots, make_fixnum (0));
Vcharset_table = Fmake_char_table (Qcharset_table, Qnil);
Qunknown = intern ("unknown");
staticpro (&Qunknown);
- Vcharset_symbol_table = Fmake_vector (make_number (MAX_CHARSET + 1),
+ Vcharset_symbol_table = Fmake_vector (make_fixnum (MAX_CHARSET + 1),
Qunknown);
/* Setup tables. */
val = Qnil;
for (i = 0x81; i < 0x90; i++)
- val = Fcons (make_number ((i - 0x70) << 7), val);
+ val = Fcons (make_fixnum ((i - 0x70) << 7), val);
for (; i < 0x9A; i++)
- val = Fcons (make_number ((i - 0x8F) << 14), val);
+ val = Fcons (make_fixnum ((i - 0x8F) << 14), val);
for (i = 0xA0; i < 0xF0; i++)
- val = Fcons (make_number ((i - 0x70) << 7), val);
+ val = Fcons (make_fixnum ((i - 0x70) << 7), val);
for (; i < 0xFF; i++)
- val = Fcons (make_number ((i - 0xE0) << 14), val);
+ val = Fcons (make_fixnum ((i - 0xE0) << 14), val);
Vgeneric_character_list = Fnreverse (val);
}
/* Define special charsets ascii, eight-bit-control, and
eight-bit-graphic. */
- update_charset_table (make_number (CHARSET_ASCII),
- make_number (1), make_number (94),
- make_number (1),
- make_number (0),
- make_number ('B'),
- make_number (0),
+ update_charset_table (make_fixnum (CHARSET_ASCII),
+ make_fixnum (1), make_fixnum (94),
+ make_fixnum (1),
+ make_fixnum (0),
+ make_fixnum ('B'),
+ make_fixnum (0),
build_string ("ASCII"),
Qnil, /* same as above */
build_string ("ASCII (ISO646 IRV)"));
CHARSET_SYMBOL (CHARSET_ASCII) = Qascii;
Fput (Qascii, Qcharset, CHARSET_TABLE_ENTRY (CHARSET_ASCII));
- update_charset_table (make_number (CHARSET_8_BIT_CONTROL),
- make_number (1), make_number (96),
- make_number (4),
- make_number (0),
- make_number (-1),
- make_number (-1),
+ update_charset_table (make_fixnum (CHARSET_8_BIT_CONTROL),
+ make_fixnum (1), make_fixnum (96),
+ make_fixnum (4),
+ make_fixnum (0),
+ make_fixnum (-1),
+ make_fixnum (-1),
build_string ("8-bit control code (0x80..0x9F)"),
Qnil, /* same as above */
Qnil); /* same as above */
Fput (Qeight_bit_control, Qcharset,
CHARSET_TABLE_ENTRY (CHARSET_8_BIT_CONTROL));
- update_charset_table (make_number (CHARSET_8_BIT_GRAPHIC),
- make_number (1), make_number (96),
- make_number (4),
- make_number (0),
- make_number (-1),
- make_number (-1),
+ update_charset_table (make_fixnum (CHARSET_8_BIT_GRAPHIC),
+ make_fixnum (1), make_fixnum (96),
+ make_fixnum (4),
+ make_fixnum (0),
+ make_fixnum (-1),
+ make_fixnum (-1),
build_string ("8-bit graphic char (0xA0..0xFF)"),
Qnil, /* same as above */
Qnil); /* same as above */
Qauto_fill_chars = intern ("auto-fill-chars");
staticpro (&Qauto_fill_chars);
- Fput (Qauto_fill_chars, Qchar_table_extra_slots, make_number (0));
+ Fput (Qauto_fill_chars, Qchar_table_extra_slots, make_fixnum (0));
defsubr (&Sdefine_charset);
defsubr (&Sgeneric_character_list);
DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector,
"Vector of cons cell of a symbol and translation table ever defined.\n\
An ID of a translation table is an index of this vector.");
- Vtranslation_table_vector = Fmake_vector (make_number (16), Qnil);
+ Vtranslation_table_vector = Fmake_vector (make_fixnum (16), Qnil);
DEFVAR_INT ("leading-code-private-11", &leading_code_private_11,
"Leading-code of private TYPE9N charset of column-width 1.");
"A char-table for characters which invoke auto-filling.\n\
Such characters have value t in this table.");
Vauto_fill_chars = Fmake_char_table (Qauto_fill_chars, Qnil);
- CHAR_TABLE_SET (Vauto_fill_chars, make_number (' '), Qt);
- CHAR_TABLE_SET (Vauto_fill_chars, make_number ('\n'), Qt);
+ CHAR_TABLE_SET (Vauto_fill_chars, make_fixnum (' '), Qt);
+ CHAR_TABLE_SET (Vauto_fill_chars, make_fixnum ('\n'), Qt);
}
#endif /* emacs */
{
CHECK_NUMBER (n, 0);
- return make_number (PT + XINT (n));
+ return make_fixnum (PT + XINT (n));
}
DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p",
&& (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,
{
int column = current_column ();
- value = Fdelete_char (make_number (-XINT (n)), killflag);
+ value = Fdelete_char (make_fixnum (-XINT (n)), killflag);
i = column - current_column ();
- Finsert_char (make_number (' '), make_number (i), Qnil);
+ Finsert_char (make_fixnum (' '), make_fixnum (i), Qnil);
/* Whitespace chars are ASCII chars, so we can simply subtract. */
SET_PT_BOTH (PT - i, PT_BYTE - i);
}
else
- value = Fdelete_char (make_number (-XINT (n)), killflag);
+ value = Fdelete_char (make_fixnum (-XINT (n)), killflag);
return value;
}
CHECK_NUMBER (n, 0);
/* Barf if the key that invoked this was not a character. */
- if (!INTEGERP (last_command_char))
+ if (!FIXNUMP (last_command_char))
bitch_at_user ();
else if (XINT (n) >= 2 && NILP (current_buffer->overwrite_mode))
{
/* The bulk of the copies of this char can be inserted simply.
We don't have to handle a user-specified face specially
because it will get inherited from the first char inserted. */
- Finsert_char (make_number (modified_char), n, Qt);
+ Finsert_char (make_fixnum (modified_char), n, Qt);
/* The last one might want to auto-fill. */
internal_self_insert (character, 0);
}
&& XINT (current_buffer->tab_width) > 0
&& XFASTINT (current_buffer->tab_width) < 20
&& (target_clm = (current_column ()
- + XINT (Fchar_width (make_number (c)))),
+ + XINT (Fchar_width (make_fixnum (c)))),
target_clm % XFASTINT (current_buffer->tab_width)))))
{
int pos = PT;
character. In that case, the new point is set after
that character. */
int actual_clm
- = XFASTINT (Fmove_to_column (make_number (target_clm), Qnil));
+ = XFASTINT (Fmove_to_column (make_fixnum (target_clm), Qnil));
chars_to_delete = PT - pos;
string = make_string_from_bytes (str, 1, len);
if (spaces_to_insert)
{
- tem = Fmake_string (make_number (spaces_to_insert),
- make_number (' '));
+ tem = Fmake_string (make_fixnum (spaces_to_insert),
+ make_fixnum (' '));
string = concat2 (tem, string);
}
replace_range (PT, PT + chars_to_delete, string, 1, 1, 1);
- Fforward_char (make_number (1 + spaces_to_insert));
+ Fforward_char (make_fixnum (1 + spaces_to_insert));
}
else
insert_and_inherit (str, len);
if (!NILP (Vself_insert_face)
&& EQ (current_kboard->Vlast_command, Vself_insert_face_command))
{
- Fput_text_property (make_number (PT - 1), make_number (PT),
+ Fput_text_property (make_fixnum (PT - 1), make_fixnum (PT),
Qface, Vself_insert_face, Qnil);
Vself_insert_face = Qnil;
}
\
if (final_char < '0' || final_char >= 128) \
goto label_invalid_code; \
- charset = ISO_CHARSET_TABLE (make_number (dimension), \
- make_number (chars), \
- make_number (final_char)); \
+ charset = ISO_CHARSET_TABLE (make_fixnum (dimension), \
+ make_fixnum (chars), \
+ make_fixnum (final_char)); \
c = MAKE_CHAR (charset, 0, 0); \
if (charset >= 0 \
&& (CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) == reg \
if (!NILP (val))
{
val = Fget (val, Qcoding_category_index);
- if (INTEGERP (val))
+ if (FIXNUMP (val))
coding->category_idx = XINT (val);
else
goto label_invalid_coding_system;
{
charset = get_charset_id (Fcar_safe (XCAR (val)));
if (charset >= 0
- && (temp = Fcdr_safe (XCAR (val)), INTEGERP (temp))
+ && (temp = Fcdr_safe (XCAR (val)), FIXNUMP (temp))
&& (i = XINT (temp), (i >= 0 && (i + '@') < 128)))
CODING_SPEC_ISO_REVISION_NUMBER (coding, charset) = i;
val = XCDR (val);
= CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION;
for (i = 0; i < 4; i++)
{
- if (INTEGERP (flags[i])
+ if (FIXNUMP (flags[i])
&& (charset = XINT (flags[i]), CHARSET_VALID_P (charset))
|| (charset = get_charset_id (flags[i])) >= 0)
{
tail = flags[i];
coding->flags |= CODING_FLAG_ISO_DESIGNATION;
- if (INTEGERP (XCAR (tail))
+ if (FIXNUMP (XCAR (tail))
&& (charset = XINT (XCAR (tail)),
CHARSET_VALID_P (charset))
|| (charset = get_charset_id (XCAR (tail))) >= 0)
tail = XCDR (tail);
while (CONSP (tail))
{
- if (INTEGERP (XCAR (tail))
+ if (FIXNUMP (XCAR (tail))
&& (charset = XINT (XCAR (tail)),
CHARSET_VALID_P (charset))
|| (charset = get_charset_id (XCAR (tail))) >= 0)
for (; CONSP (val); val = XCDR (val))
{
this = XCAR (val);
- if (INTEGERP (this)
+ if (FIXNUMP (this)
&& XINT (this) >= 0 && XINT (this) < 256)
coding->spec.ccl.valid_codes[XINT (this)] = 1;
else if (CONSP (this)
- && INTEGERP (XCAR (this))
- && INTEGERP (XCDR (this)))
+ && FIXNUMP (XCAR (this))
+ && FIXNUMP (XCDR (this)))
{
int start = XINT (XCAR (this));
int end = XINT (XCDR (this));
for (i = 0; i < len; i++)
{
ch = (STRINGP (val)
- ? Faref (val, make_number (i))
+ ? Faref (val, make_fixnum (i))
: XVECTOR (val)->contents[i]);
CODING_ADD_COMPOSITION_COMPONENT (coding, XINT (ch));
}
}
- else /* INTEGERP (val) */
+ else /* FIXNUMP (val) */
CODING_ADD_COMPOSITION_COMPONENT (coding, XINT (val));
}
CODING_ADD_COMPOSITION_END (coding, end - from);
Lisp_Object args[MAX_COMPOSITION_COMPONENTS * 2 - 1];
for (j = 0; j < len; j++)
- args[j] = make_number (data[4 + j]);
+ args[j] = make_fixnum (data[4 + j]);
components = (method == COMPOSITION_WITH_ALTCHARS
? Fstring (len, args) : Fvector (len, args));
}
region. Here, we must suppress all modification hooks. */
saved_inhibit_modification_hooks = inhibit_modification_hooks;
inhibit_modification_hooks = 1;
- Fset_text_properties (make_number (from), make_number (to), Qnil, Qnil);
+ Fset_text_properties (make_fixnum (from), make_fixnum (to), Qnil, Qnil);
inhibit_modification_hooks = saved_inhibit_modification_hooks;
}
functions while this pre-write-conversion is running. */
inhibit_pre_post_conversion = 1;
call2 (coding->pre_write_conversion,
- make_number (from), make_number (to));
+ make_fixnum (from), make_fixnum (to));
inhibit_pre_post_conversion = 0;
/* Discard the unwind protect. */
specpdl_ptr--;
/* We should not call any more pre-write/post-read-conversion
functions while this post-read-conversion is running. */
inhibit_pre_post_conversion = 1;
- val = call1 (coding->post_read_conversion, make_number (inserted));
+ val = call1 (coding->post_read_conversion, make_fixnum (inserted));
inhibit_pre_post_conversion = 0;
/* Discard the unwind protect. */
specpdl_ptr--;
UNGCPRO;
inhibit_pre_post_conversion = 1;
if (encodep)
- call2 (coding->pre_write_conversion, make_number (BEG), make_number (Z));
+ call2 (coding->pre_write_conversion, make_fixnum (BEG), make_fixnum (Z));
else
{
TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
- call1 (coding->post_read_conversion, make_number (Z - BEG));
+ call1 (coding->post_read_conversion, make_fixnum (Z - BEG));
}
inhibit_pre_post_conversion = 0;
str = make_buffer_string (BEG, Z, 1);
/* This element was already checked. Ignore it. */
continue;
/* Remember that we checked this element. */
- CHAR_TABLE_SET (work_table, make_number (idx), Qt);
+ CHAR_TABLE_SET (work_table, make_fixnum (idx), Qt);
/* If there are some safe coding systems for C and we have
already found the other set of coding systems for the
Lisp_Object args[2];
args[0] = safe_codings;
args[1] = Fchar_table_extra_slot (Vchar_coding_system_table,
- make_number (0));
+ make_fixnum (0));
safe_codings = Fappend (2, args);
}
else
to = XFASTINT (end);
if (NILP (coding_system))
- return make_number (to - from);
+ return make_fixnum (to - from);
if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
code_convert_region (from, CHAR_TO_BYTE (from), to, CHAR_TO_BYTE (to),
&coding, encodep, 1);
Vlast_coding_system_used = coding.symbol;
- return make_number (coding.produced_char);
+ return make_fixnum (coding.produced_char);
}
DEFUN ("decode-coding-region", Fdecode_coding_region, Sdecode_coding_region,
error ("Too few arguments");
operation = args[0];
if (!SYMBOLP (operation)
- || !INTEGERP (target_idx = Fget (operation, Qtarget_idx)))
+ || !FIXNUMP (target_idx = Fget (operation, Qtarget_idx)))
error ("Invalid first argument");
if (nargs < 1 + XINT (target_idx))
error ("Too few arguments for operation: %s",
XSYMBOL (operation)->name->data);
target = args[XINT (target_idx) + 1];
if (!(STRINGP (target)
- || (EQ (operation, Qopen_network_stream) && INTEGERP (target))))
+ || (EQ (operation, Qopen_network_stream) && FIXNUMP (target))))
error ("Invalid argument %d", XINT (target_idx) + 1);
chain = ((EQ (operation, Qinsert_file_contents)
&& ((STRINGP (target)
&& STRINGP (XCAR (elt))
&& fast_string_match (XCAR (elt), target) >= 0)
- || (INTEGERP (target) && EQ (target, XCAR (elt)))))
+ || (FIXNUMP (target) && EQ (target, XCAR (elt)))))
{
val = XCDR (elt);
/* Here, if VAL is both a valid coding system and a valid
Fset (Qcoding_system_history, Qnil);
/* Target FILENAME is the first argument. */
- Fput (Qinsert_file_contents, Qtarget_idx, make_number (0));
+ Fput (Qinsert_file_contents, Qtarget_idx, make_fixnum (0));
/* Target FILENAME is the third argument. */
- Fput (Qwrite_region, Qtarget_idx, make_number (2));
+ Fput (Qwrite_region, Qtarget_idx, make_fixnum (2));
Qcall_process = intern ("call-process");
staticpro (&Qcall_process);
/* Target PROGRAM is the first argument. */
- Fput (Qcall_process, Qtarget_idx, make_number (0));
+ Fput (Qcall_process, Qtarget_idx, make_fixnum (0));
Qcall_process_region = intern ("call-process-region");
staticpro (&Qcall_process_region);
/* Target PROGRAM is the third argument. */
- Fput (Qcall_process_region, Qtarget_idx, make_number (2));
+ Fput (Qcall_process_region, Qtarget_idx, make_fixnum (2));
Qstart_process = intern ("start-process");
staticpro (&Qstart_process);
/* Target PROGRAM is the third argument. */
- Fput (Qstart_process, Qtarget_idx, make_number (2));
+ Fput (Qstart_process, Qtarget_idx, make_fixnum (2));
Qopen_network_stream = intern ("open-network-stream");
staticpro (&Qopen_network_stream);
/* Target SERVICE is the fourth argument. */
- Fput (Qopen_network_stream, Qtarget_idx, make_number (3));
+ Fput (Qopen_network_stream, Qtarget_idx, make_fixnum (3));
Qcoding_system = intern ("coding-system");
staticpro (&Qcoding_system);
staticpro (&Qcoding_category_index);
Vcoding_category_table
- = Fmake_vector (make_number (CODING_CATEGORY_IDX_MAX), Qnil);
+ = Fmake_vector (make_fixnum (CODING_CATEGORY_IDX_MAX), Qnil);
staticpro (&Vcoding_category_table);
{
int i;
XVECTOR (Vcoding_category_table)->contents[i]
= intern (coding_category_name[i]);
Fput (XVECTOR (Vcoding_category_table)->contents[i],
- Qcoding_category_index, make_number (i));
+ Qcoding_category_index, make_fixnum (i));
}
}
Qtranslation_table = intern ("translation-table");
staticpro (&Qtranslation_table);
- Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (1));
+ Fput (Qtranslation_table, Qchar_table_extra_slots, make_fixnum (1));
Qtranslation_table_id = intern ("translation-table-id");
staticpro (&Qtranslation_table_id);
Setting this variable twice is harmless.
But don't staticpro it here--that is done in alloc.c. */
Qchar_table_extra_slots = intern ("char-table-extra-slots");
- Fput (Qsafe_chars, Qchar_table_extra_slots, make_number (0));
- Fput (Qchar_coding_system, Qchar_table_extra_slots, make_number (1));
+ Fput (Qsafe_chars, Qchar_table_extra_slots, make_fixnum (0));
+ Fput (Qchar_coding_system, Qchar_table_extra_slots, make_fixnum (1));
Qvalid_codes = intern ("valid-codes");
staticpro (&Qvalid_codes);
`accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file\n\
or reading output of a subprocess.\n\
Only 128th through 159th elements has a meaning.");
- Vlatin_extra_code_table = Fmake_vector (make_number (256), Qnil);
+ Vlatin_extra_code_table = Fmake_vector (make_fixnum (256), Qnil);
DEFVAR_LISP ("select-safe-coding-system-function",
&Vselect_safe_coding_system_function,
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 (!CONSP (id))
goto invalid_composition;
length = XCAR (id);
- if (!INTEGERP (length) || XINT (length) != nchars)
+ if (!FIXNUMP (length) || XINT (length) != nchars)
goto invalid_composition;
components = XCDR (id);
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))
key = components;
else if (NILP (components))
{
- key = Fmake_vector (make_number (nchars), Qnil);
+ key = Fmake_vector (make_fixnum (nchars), Qnil);
if (STRINGP (string))
for (i = 0; i < nchars; i++)
{
FETCH_STRING_CHAR_ADVANCE (ch, string, charpos, bytepos);
- XVECTOR (key)->contents[i] = make_number (ch);
+ XVECTOR (key)->contents[i] = make_fixnum (ch);
}
else
for (i = 0; i < nchars; i++)
{
FETCH_CHAR_ADVANCE (ch, charpos, bytepos);
- XVECTOR (key)->contents[i] = make_number (ch);
+ XVECTOR (key)->contents[i] = make_fixnum (ch);
}
}
else
key = HASH_KEY (hash_table, hash_index);
id = HASH_VALUE (hash_table, hash_index);
XCAR (prop) = id;
- XCDR (prop) = Fcons (make_number (nchars), Fcons (key, XCDR (prop)));
+ XCDR (prop) = Fcons (make_fixnum (nchars), Fcons (key, XCDR (prop)));
return XINT (id);
}
composition rule). */
for (i = 0; i < len; i++)
{
- if (!INTEGERP (key_contents[i]))
+ if (!FIXNUMP (key_contents[i]))
goto invalid_composition;
}
}
the cons cell of PROP because it is not shared. */
XSETFASTINT (id, n_compositions);
XCAR (prop) = id;
- XCDR (prop) = Fcons (make_number (nchars), Fcons (key, XCDR (prop)));
+ XCDR (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);
cmp->method = (NILP (components)
? COMPOSITION_RELATIVE
- : ((INTEGERP (components) || STRINGP (components))
+ : ((FIXNUMP (components) || STRINGP (components))
? COMPOSITION_WITH_ALTCHARS
: COMPOSITION_WITH_RULE_ALTCHARS));
cmp->hash_index = hash_index;
if (limit > pos) /* search forward */
{
- val = Fnext_single_property_change (make_number (pos), Qcomposition,
- object, make_number (limit));
+ val = Fnext_single_property_change (make_fixnum (pos), Qcomposition,
+ object, make_fixnum (limit));
pos = XINT (val);
if (pos == limit)
return 0;
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));
+ val = Fprevious_single_property_change (make_fixnum (pos), Qcomposition,
+ object, make_fixnum (limit));
pos = XINT (val);
if (pos == limit)
return 0;
&& !COMPOSITION_VALID_P (start, end, prop))
to = end;
if (!NILP (func))
- call2 (func, make_number (from), make_number (to));
+ call2 (func, make_fixnum (from), make_fixnum (to));
else if (!NILP (Ffboundp (Vcompose_chars_after_function)))
call3 (Vcompose_chars_after_function,
- make_number (from), make_number (to), Qnil);
+ make_fixnum (from), make_fixnum (to), Qnil);
}
/* Make invalid compositions adjacent to or inside FROM and TO valid.
&& find_composition (from - 1, -1, &start, &end, &prop, Qnil))
{
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);
To avoid it, in such a case, we change the property of
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);
run_composition_function (start, end, prop);
{
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);
}
&& !NILP (Ffboundp (XCDR (elt))))
{
if (STRINGP (string))
- val = Fstring_match (XCAR (elt), string, make_number (start));
+ val = Fstring_match (XCAR (elt), string, make_fixnum (start));
else
{
val = Flooking_at (XCAR (elt));
if (!NILP (val))
- val = make_number (start);
+ val = make_fixnum (start);
}
- if (INTEGERP (val) && XFASTINT (val) == start)
+ if (FIXNUMP (val) && XFASTINT (val) == start)
{
- to = Fmatch_end (make_number (0));
+ to = Fmatch_end (make_fixnum (0));
val = call4 (XCDR (elt), val, to, XCAR (elt), string);
- if (INTEGERP (val) && XINT (val) > 1)
+ if (FIXNUMP (val) && XINT (val) > 1)
{
start += XINT (val);
if (STRINGP (string))
{
validate_region (&start, &end);
if (!NILP (components)
- && !INTEGERP (components)
+ && !FIXNUMP (components)
&& !CONSP (components)
&& !STRINGP (components))
CHECK_VECTOR (components, 2);
if (!find_composition (start, end, &start, &end, &prop, string))
return Qnil;
if (!COMPOSITION_VALID_P (start, end, prop))
- return Fcons (make_number (start), Fcons (make_number (end),
+ return Fcons (make_fixnum (start), Fcons (make_fixnum (end),
Fcons (Qnil, Qnil)));
if (NILP (detail_p))
- return Fcons (make_number (start), Fcons (make_number (end),
+ return Fcons (make_fixnum (start), Fcons (make_fixnum (end),
Fcons (Qt, Qnil)));
if (COMPOSITION_REGISTERD_P (prop))
tail = Fcons (components,
Fcons (relative_p,
Fcons (mod_func,
- Fcons (make_number (width), Qnil))));
+ Fcons (make_fixnum (width), Qnil))));
}
else
tail = Qnil;
- return Fcons (make_number (start), Fcons (make_number (end), tail));
+ return Fcons (make_fixnum (start), Fcons (make_fixnum (end), tail));
}
\f
args[2] = QCweakness;
args[3] = Qnil;
args[4] = QCsize;
- args[5] = make_number (311);
+ args[5] = make_fixnum (311);
composition_hash_table = Fmake_hash_table (6, args);
staticpro (&composition_hash_table);
}
But don't staticpro it here--that is done in alloc.c. */
Qchar_table_extra_slots = intern ("char-table-extra-slots");
- Fput (Qcomposition_function_table, Qchar_table_extra_slots, make_number (0));
+ Fput (Qcomposition_function_table, Qchar_table_extra_slots, make_fixnum (0));
DEFVAR_LISP ("composition-function-table", &Vcomposition_function_table,
"Char table of patterns and functions to make a composition.\n\
extern Lisp_Object composition_temp;
/* Return 1 iff the composition is already registered. */
-#define COMPOSITION_REGISTERD_P(prop) INTEGERP (XCAR (prop))
+#define COMPOSITION_REGISTERD_P(prop) FIXNUMP (XCAR (prop))
/* Return ID number of the already registered composition. */
#define COMPOSITION_ID(prop) XINT (XCAR (prop))
: (composition_temp = XCDR (XCAR (prop)), \
(NILP (composition_temp) \
? COMPOSITION_RELATIVE \
- : ((INTEGERP (composition_temp) || STRINGP (composition_temp)) \
+ : ((FIXNUMP (composition_temp) || STRINGP (composition_temp)) \
? COMPOSITION_WITH_ALTCHARS \
: COMPOSITION_WITH_RULE_ALTCHARS))))
(NILP (composition_temp) \
|| STRINGP (composition_temp) \
|| VECTORP (composition_temp) \
- || INTEGERP (composition_temp) \
+ || FIXNUMP (composition_temp) \
|| CONSP (composition_temp)))))) \
&& (end - start) == COMPOSITION_LENGTH (prop))
file-attributes on filenames, both of which can throw, so we must
do a proper unwind-protect. */
record_unwind_protect (directory_files_internal_unwind,
- Fcons (make_number (((unsigned long) d) >> 16),
- make_number (((unsigned long) d) & 0xffff)));
+ Fcons (make_fixnum (((unsigned long) d) >> 16),
+ make_fixnum (((unsigned long) d) & 0xffff)));
directory_nbytes = STRING_BYTES (XSTRING (directory));
re_match_object = Qt;
}
if (matchcount == 1 && bestmatchsize == XSTRING (file)->size)
return Qt;
- bestmatch = Fsubstring (bestmatch, make_number (0),
- make_number (bestmatchsize));
+ bestmatch = Fsubstring (bestmatch, make_fixnum (0),
+ make_fixnum (bestmatchsize));
/* Now that we got the right initial segment of BESTMATCH,
decode it from the coding system in use. */
bestmatch = DECODE_FILE (bestmatch);
if (xabfhc.xab$w_verlimit == 32767)
return Qnil; /* No version limit */
else
- return make_number (xabfhc.xab$w_verlimit);
+ return make_fixnum (xabfhc.xab$w_verlimit);
}
#endif /* VMS */
make_time (time)
time_t time;
{
- return Fcons (make_number (time >> 16),
- Fcons (make_number (time & 0177777), Qnil));
+ return Fcons (make_fixnum (time >> 16),
+ Fcons (make_fixnum (time & 0177777), Qnil));
}
DEFUN ("file-attributes", Ffile_attributes, Sfile_attributes, 1, 1, 0,
values[0] = Ffile_symlink_p (filename); break;
#endif
}
- values[1] = make_number (s.st_nlink);
- values[2] = make_number (s.st_uid);
- values[3] = make_number (s.st_gid);
+ values[1] = make_fixnum (s.st_nlink);
+ values[2] = make_fixnum (s.st_uid);
+ values[3] = make_fixnum (s.st_gid);
values[4] = make_time (s.st_atime);
values[5] = make_time (s.st_mtime);
values[6] = make_time (s.st_ctime);
- values[7] = make_number (s.st_size);
+ values[7] = make_fixnum (s.st_size);
/* If the size is out of range for an integer, return a float. */
if (XINT (values[7]) != s.st_size)
values[7] = make_float ((double)s.st_size);
if (s.st_ino & (((EMACS_INT) (-1)) << VALBITS))
/* To allow inode numbers larger than VALBITS, separate the bottom
16 bits. */
- values[10] = Fcons (make_number (s.st_ino >> 16),
- make_number (s.st_ino & 0xffff));
+ values[10] = Fcons (make_fixnum (s.st_ino >> 16),
+ make_fixnum (s.st_ino & 0xffff));
else
/* But keep the most common cases as integers. */
- values[10] = make_number (s.st_ino);
+ values[10] = make_fixnum (s.st_ino);
/* Likewise for device. */
if (s.st_dev & (((EMACS_INT) (-1)) << VALBITS))
- values[11] = Fcons (make_number (s.st_dev >> 16),
- make_number (s.st_dev & 0xffff));
+ values[11] = Fcons (make_fixnum (s.st_dev >> 16),
+ make_fixnum (s.st_dev & 0xffff));
else
- values[11] = make_number (s.st_dev);
+ values[11] = make_fixnum (s.st_dev);
return Flist (sizeof(values) / sizeof(values[0]), values);
}
/* Window end is invalid, if inside of the rows that
are invalidated. */
- if (INTEGERP (w->window_end_vpos)
+ if (FIXNUMP (w->window_end_vpos)
&& XFASTINT (w->window_end_vpos) >= i)
w->window_end_valid = Qnil;
if (!WINDOW_RIGHTMOST_P (w))
{
struct Lisp_Char_Table *dp = window_display_table (w);
- right_border_glyph = (dp && INTEGERP (DISP_BORDER_GLYPH (dp))
+ right_border_glyph = (dp && FIXNUMP (DISP_BORDER_GLYPH (dp))
? XINT (DISP_BORDER_GLYPH (dp))
: '|');
}
|= it.glyph_row->contains_overlapping_glyphs_p;
glyph_row->displays_text_p = 1;
- w->window_end_vpos = make_number (max (w->cursor.vpos,
+ w->window_end_vpos = make_fixnum (max (w->cursor.vpos,
XFASTINT (w->window_end_vpos)));
if (!NILP (Vshow_trailing_whitespace))
{
int x, y;
x = (WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos)
- + (INTEGERP (w->left_margin_width)
+ + (FIXNUMP (w->left_margin_width)
? XFASTINT (w->left_margin_width)
: 0));
y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
{
int x, y;
x = (WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos)
- + (INTEGERP (w->left_margin_width)
+ + (FIXNUMP (w->left_margin_width)
? XFASTINT (w->left_margin_width)
: 0));
y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
int x = WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos);
int y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
- if (INTEGERP (w->left_margin_width))
+ if (FIXNUMP (w->left_margin_width))
x += XFASTINT (w->left_margin_width);
/* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
if (n > XVECTOR (frame_and_buffer_state)->size
|| n + 20 < XVECTOR (frame_and_buffer_state)->size / 2)
/* Add 20 extra so we grow it less often. */
- frame_and_buffer_state = Fmake_vector (make_number (n + 20), Qlambda);
+ frame_and_buffer_state = Fmake_vector (make_fixnum (n + 20), Qlambda);
vecp = XVECTOR (frame_and_buffer_state)->contents;
FOR_EACH_FRAME (tail, frame)
{
{
Vwindow_system = intern ("x");
#ifdef HAVE_X11
- Vwindow_system_version = make_number (11);
+ Vwindow_system_version = make_fixnum (11);
#else
- Vwindow_system_version = make_number (10);
+ Vwindow_system_version = make_fixnum (10);
#endif
#if defined (LINUX) && defined (HAVE_LIBNCURSES)
/* In some versions of ncurses,
if (!inhibit_window_system)
{
Vwindow_system = intern ("w32");
- Vwindow_system_version = make_number (1);
+ Vwindow_system_version = make_fixnum (1);
adjust_frame_glyphs_initially ();
return;
}
if (!inhibit_window_system)
{
Vwindow_system = intern ("mac");
- Vwindow_system_version = make_number (1);
+ Vwindow_system_version = make_fixnum (1);
adjust_frame_glyphs_initially ();
return;
}
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);
Qdisplay_table = intern ("display-table");
/* 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) ((g) < (len) && INTEGERP (base[g]))
+#define GLYPH_ALIAS_P(base,len,g) ((g) < (len) && FIXNUMP (base[g]))
/* Assuming that GLYPH_SIMPLE_P (BASE, LEN, G) is 1,
return the alias for G. */
int offset, position;
Lisp_Object file, tem;
- if (INTEGERP (filepos))
+ if (FIXNUMP (filepos))
{
file = Vdoc_file_name;
position = XINT (filepos);
else if ((EMACS_INT) XSUBR (fun)->doc >= 0)
doc = build_string (XSUBR (fun)->doc);
else
- doc = get_doc_string (make_number (- (EMACS_INT) XSUBR (fun)->doc),
+ doc = get_doc_string (make_fixnum (- (EMACS_INT) XSUBR (fun)->doc),
0, 0);
if (! NILP (tem = Fassq (function, Vhelp_manyarg_func_alist)))
doc = concat3 (doc, build_string ("\n"), Fcdr (tem));
Lisp_Object tem;
tem = Fget (symbol, prop);
- if (INTEGERP (tem))
- tem = get_doc_string (XINT (tem) > 0 ? tem : make_number (- XINT (tem)), 0, 0);
- else if (CONSP (tem) && INTEGERP (XCDR (tem)))
+ if (FIXNUMP (tem))
+ tem = get_doc_string (XINT (tem) > 0 ? tem : make_fixnum (- XINT (tem)), 0, 0);
+ else if (CONSP (tem) && FIXNUMP (XCDR (tem)))
tem = get_doc_string (tem, 0, 0);
else if (!STRINGP (tem))
/* Feval protects its argument. */
if (EQ (tem, Qlambda) || EQ (tem, Qautoload))
{
tem = Fcdr (Fcdr (fun));
- if (CONSP (tem) && INTEGERP (XCAR (tem)))
+ if (CONSP (tem) && FIXNUMP (XCAR (tem)))
XSETFASTINT (XCAR (tem), offset);
}
else if (EQ (tem, Qmacro))
and make it negative for a user-variable
(doc starts with a `*'). */
Fput (sym, Qvariable_documentation,
- make_number ((pos + end + 1 - buf)
+ make_fixnum ((pos + end + 1 - buf)
* (end[1] == '*' ? -1 : 1)));
}
useful even when there is a menu bar. */
if (!NILP (tem))
{
- firstkey = Faref (tem, make_number (0));
+ firstkey = Faref (tem, make_fixnum (0));
if (EQ (firstkey, Qmenu_bar))
tem = Qnil;
}
int86 (no, &inregs, &outregs);
- XVECTOR (registers)->contents[0] = make_number (outregs.x.ax);
- XVECTOR (registers)->contents[1] = make_number (outregs.x.bx);
- XVECTOR (registers)->contents[2] = make_number (outregs.x.cx);
- XVECTOR (registers)->contents[3] = make_number (outregs.x.dx);
- XVECTOR (registers)->contents[4] = make_number (outregs.x.si);
- XVECTOR (registers)->contents[5] = make_number (outregs.x.di);
- XVECTOR (registers)->contents[6] = make_number (outregs.x.cflag);
- XVECTOR (registers)->contents[7] = make_number (outregs.x.flags);
+ XVECTOR (registers)->contents[0] = make_fixnum (outregs.x.ax);
+ XVECTOR (registers)->contents[1] = make_fixnum (outregs.x.bx);
+ XVECTOR (registers)->contents[2] = make_fixnum (outregs.x.cx);
+ XVECTOR (registers)->contents[3] = make_fixnum (outregs.x.dx);
+ XVECTOR (registers)->contents[4] = make_fixnum (outregs.x.si);
+ XVECTOR (registers)->contents[5] = make_fixnum (outregs.x.di);
+ XVECTOR (registers)->contents[6] = make_fixnum (outregs.x.cflag);
+ XVECTOR (registers)->contents[7] = make_fixnum (outregs.x.flags);
return registers;
}
dosmemget (offs, len, buf);
for (i = 0; i < len; i++)
- XVECTOR (vector)->contents[i] = make_number (buf[i]);
+ XVECTOR (vector)->contents[i] = make_fixnum (buf[i]);
return vector;
}
regs.x.ax = 0x3000;
intdos (®s, ®s);
- 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;
{
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
/* If the user name claimed in the environment vars differs from
the real uid, use the claimed name to find the full name. */
tem = Fstring_equal (Vuser_login_name, Vuser_real_login_name);
- Vuser_full_name = Fuser_full_name (NILP (tem)? make_number (geteuid())
+ Vuser_full_name = Fuser_full_name (NILP (tem)? make_fixnum (geteuid())
: Vuser_login_name);
p = (unsigned char *) getenv ("NAME");
error ("There is no region now");
if ((PT < XFASTINT (m)) == beginningp)
- m = make_number (PT);
+ m = make_fixnum (PT);
return m;
}
{
Lisp_Object prev_pos, rear_non_sticky;
- prev_pos = make_number (XINT (pos) - 1);
+ prev_pos = make_fixnum (XINT (pos) - 1);
rear_non_sticky = Fget_text_property (prev_pos, Qrear_nonsticky, Qnil);
if (EQ (rear_non_sticky, Qnil)
= get_char_property_and_overlay (pos, Qfield, Qnil, &after_overlay);
before_field
= (XFASTINT (pos) > BEGV
- ? get_char_property_and_overlay (make_number (XINT (pos) - 1),
+ ? get_char_property_and_overlay (make_fixnum (XINT (pos) - 1),
Qfield, Qnil,
&before_overlay)
: Qnil);
{
int beg;
find_field (pos, escape_from_edge, &beg, 0);
- return make_number (beg);
+ return make_fixnum (beg);
}
DEFUN ("field-end", Ffield_end, Sfield_end, 0, 2, 0,
{
int end;
find_field (pos, escape_from_edge, 0, &end);
- return make_number (end);
+ return make_fixnum (end);
}
DEFUN ("constrain-to-field", Fconstrain_to_field, Sconstrain_to_field, 2, 5, 0,
orig = PT;
orig_byte = PT_BYTE;
- Fforward_line (make_number (XINT (n) - 1));
+ Fforward_line (make_fixnum (XINT (n) - 1));
end = PT;
SET_PT_BOTH (orig, orig_byte);
/* Return END constrained to the current input field. */
- return Fconstrain_to_field (make_number (end), make_number (orig),
+ return Fconstrain_to_field (make_fixnum (end), make_fixnum (orig),
XINT (n) != 1 ? Qt : Qnil,
Qt, Qnil);
}
end_pos = find_before_next_newline (orig, 0, XINT (n) - (XINT (n) <= 0));
/* Return END_POS constrained to the current input field. */
- return Fconstrain_to_field (make_number (end_pos), make_number (orig),
+ return Fconstrain_to_field (make_fixnum (end_pos), make_fixnum (orig),
Qnil, Qt, Qnil);
}
\f
BUFFERP (tem1)
/* ...and it shows the current buffer. */
&& XBUFFER (tem1) == current_buffer)))
- Fset_window_point (tem, make_number (PT));
+ Fset_window_point (tem, make_fixnum (PT));
UNGCPRO;
return Qnil;
Lisp_Object buffer;
{
if (NILP (buffer))
- return make_number (Z - BEG);
+ return make_fixnum (Z - BEG);
else
{
CHECK_BUFFER (buffer, 1);
- return make_number (BUF_Z (XBUFFER (buffer))
+ return make_fixnum (BUF_Z (XBUFFER (buffer))
- BUF_BEG (XBUFFER (buffer)));
}
}
CHECK_NUMBER_COERCE_MARKER (position, 1);
if (XINT (position) < BEG || XINT (position) > Z)
return Qnil;
- return make_number (CHAR_TO_BYTE (XINT (position)));
+ return make_fixnum (CHAR_TO_BYTE (XINT (position)));
}
DEFUN ("byte-to-position", Fbyte_to_position, Sbyte_to_position, 1, 1, 0,
CHECK_NUMBER (bytepos, 1);
if (XINT (bytepos) < BEG_BYTE || XINT (bytepos) > Z_BYTE)
return Qnil;
- return make_number (BYTE_TO_CHAR (XINT (bytepos)));
+ return make_fixnum (BYTE_TO_CHAR (XINT (bytepos)));
}
\f
DEFUN ("following-char", Ffollowing_char, Sfollowing_char, 0, 0, 0,
pos_byte = CHAR_TO_BYTE (XINT (pos));
}
- return make_number (FETCH_CHAR (pos_byte));
+ return make_fixnum (FETCH_CHAR (pos_byte));
}
DEFUN ("char-before", Fchar_before, Schar_before, 0, 1, 0,
/* Set up the user name info if we didn't do it before.
(That can happen if Emacs is dumpable
but you decide to run `temacs -l loadup' and not dump. */
- if (INTEGERP (Vuser_login_name))
+ if (FIXNUMP (Vuser_login_name))
init_editfns ();
if (NILP (uid))
/* Set up the user name info if we didn't do it before.
(That can happen if Emacs is dumpable
but you decide to run `temacs -l loadup' and not dump. */
- if (INTEGERP (Vuser_login_name))
+ if (FIXNUMP (Vuser_login_name))
init_editfns ();
return Vuser_real_login_name;
}
"Return the effective uid of Emacs, as an integer.")
()
{
- return make_number (geteuid ());
+ return make_fixnum (geteuid ());
}
DEFUN ("user-real-uid", Fuser_real_uid, Suser_real_uid, 0, 0, 0,
"Return the real uid of Emacs, as an integer.")
()
{
- return make_number (getuid ());
+ return make_fixnum (getuid ());
}
DEFUN ("user-full-name", Fuser_full_name, Suser_full_name, 0, 1, 0,
register unsigned char *r;
Lisp_Object login;
- login = Fuser_login_name (make_number (pw->pw_uid));
+ login = Fuser_login_name (make_fixnum (pw->pw_uid));
r = (unsigned char *) alloca (strlen (p) + XSTRING (login)->size + 1);
bcopy (p, r, q - p);
r[q - p] = 0;
"Return the process ID of Emacs, as an integer.")
()
{
- return make_number (getpid ());
+ return make_fixnum (getpid ());
}
DEFUN ("current-time", Fcurrent_time, Scurrent_time, 0, 0, 0,
tzstring = "UTC0";
else if (STRINGP (zone))
tzstring = (char *) XSTRING (zone)->data;
- else if (INTEGERP (zone))
+ else if (FIXNUMP (zone))
{
int abszone = abs (XINT (zone));
sprintf (tzbuf, "XXX%s%d:%02d:%02d", "-" + (XINT (zone) < 0),
sprintf (buf, "%c%02d%02d", (offset < 0 ? '-' : '+'), am/60, am%60);
s = buf;
}
- return Fcons (make_number (offset), Fcons (build_string (s), Qnil));
+ return Fcons (make_fixnum (offset), Fcons (build_string (s), Qnil));
}
else
- return Fmake_list (make_number (2), Qnil);
+ return Fmake_list (make_fixnum (2), Qnil);
}
/* This holds the value of `environ' produced by the previous
{
val = args[argnum];
retry:
- if (INTEGERP (val))
+ if (FIXNUMP (val))
{
unsigned char str[MAX_MULTIBYTE_LENGTH];
int len;
{
update_buffer_properties (start, end);
- tem = Fnext_property_change (make_number (start), Qnil, make_number (end));
- tem1 = Ftext_properties_at (make_number (start), Qnil);
+ tem = Fnext_property_change (make_fixnum (start), Qnil, make_fixnum (end));
+ tem1 = Ftext_properties_at (make_fixnum (start), Qnil);
if (XINT (tem) != end || !NILP (tem1))
copy_intervals_to_string (result, current_buffer, start,
c2 = XINT (trt[c2]);
}
if (c1 < c2)
- return make_number (- 1 - chars);
+ return make_fixnum (- 1 - chars);
if (c1 > c2)
- return make_number (chars + 1);
+ return make_fixnum (chars + 1);
chars++;
}
/* The strings match as far as they go.
If one is shorter, that one is less. */
if (chars < endp1 - begp1)
- return make_number (chars + 1);
+ return make_fixnum (chars + 1);
else if (chars < endp2 - begp2)
- return make_number (- chars - 1);
+ return make_fixnum (- chars - 1);
/* Same length too => they are equal. */
- return make_number (0);
+ return make_fixnum (0);
}
\f
static Lisp_Object
pos++;
}
- return make_number (cnt);
+ return make_fixnum (cnt);
}
DEFUN ("delete-region", Fdelete_region, Sdelete_region, 2, 2, "r",
properties = Fcons (args[i], Fcons (args[i + 1], properties));
}
- Fadd_text_properties (make_number (0),
- make_number (XSTRING (string)->size),
+ Fadd_text_properties (make_fixnum (0),
+ make_fixnum (XSTRING (string)->size),
properties, string);
RETURN_UNGCPRO (string);
}
thissize = CONVERTED_BYTE_SIZE (multibyte, args[n]);
}
/* Would get MPV otherwise, since Lisp_Int's `point' to low memory. */
- else if (INTEGERP (args[n]) && *format != 's')
+ else if (FIXNUMP (args[n]) && *format != 's')
{
/* The following loop assumes the Lisp type indicates
the proper way to pass the argument.
info[n].end = end;
}
}
- else if (INTEGERP (args[n]) || FLOATP (args[n]))
+ else if (FIXNUMP (args[n]) || FLOATP (args[n]))
{
int this_nchars;
format - this_format_start);
this_format[format - this_format_start] = 0;
- if (INTEGERP (args[n]))
+ if (FIXNUMP (args[n]))
sprintf (p, this_format, XINT (args[n]));
else
sprintf (p, this_format, XFLOAT_DATA (args[n]));
struct gcpro gcpro1;
/* Add text properties from the format string. */
- len = make_number (XSTRING (args[0])->size);
- props = text_property_list (args[0], make_number (0), len, Qnil);
+ len = make_fixnum (XSTRING (args[0])->size);
+ props = text_property_list (args[0], make_fixnum (0), len, Qnil);
GCPRO1 (props);
if (CONSP (props))
{
- new_len = make_number (XSTRING (val)->size);
+ new_len = make_fixnum (XSTRING (val)->size);
extend_property_ranges (props, len, new_len);
- add_text_properties_from_list (val, props, make_number (0));
+ add_text_properties_from_list (val, props, make_fixnum (0));
}
/* Add text properties from arguments. */
for (n = 1; n < nargs; ++n)
if (info[n].end)
{
- len = make_number (XSTRING (args[n])->size);
- new_len = make_number (info[n].end - info[n].start);
- props = text_property_list (args[n], make_number (0), len, Qnil);
+ len = make_fixnum (XSTRING (args[n])->size);
+ new_len = make_fixnum (info[n].end - info[n].start);
+ props = text_property_list (args[n], make_fixnum (0), len, Qnil);
extend_property_ranges (props, len, new_len);
/* If successive arguments have properites, be sure that
the value of `composition' property be the copy. */
if (n > 1 && info[n - 1].end)
make_composition_value_copy (props);
add_text_properties_from_list (val, props,
- make_number (info[n].start));
+ make_fixnum (info[n].start));
}
UNGCPRO;
tmp_interval1 = copy_intervals (cur_intv, start1, len1);
tmp_interval2 = copy_intervals (cur_intv, start2, len2);
- Fset_text_properties (make_number (start1), make_number (end2),
+ Fset_text_properties (make_fixnum (start1), make_fixnum (end2),
Qnil, Qnil);
/* First region smaller than second. */
record_change (start2, len2);
tmp_interval1 = copy_intervals (cur_intv, start1, len1);
tmp_interval2 = copy_intervals (cur_intv, start2, len2);
- Fset_text_properties (make_number (start1), make_number (end1),
+ Fset_text_properties (make_fixnum (start1), make_fixnum (end1),
Qnil, Qnil);
- Fset_text_properties (make_number (start2), make_number (end2),
+ Fset_text_properties (make_fixnum (start2), make_fixnum (end2),
Qnil, Qnil);
if (len1_byte > 20000)
tmp_interval1 = copy_intervals (cur_intv, start1, len1);
tmp_interval_mid = copy_intervals (cur_intv, end1, len_mid);
tmp_interval2 = copy_intervals (cur_intv, start2, len2);
- Fset_text_properties (make_number (start1), make_number (end2),
+ Fset_text_properties (make_fixnum (start1), make_fixnum (end2),
Qnil, Qnil);
/* holds region 2 */
tmp_interval1 = copy_intervals (cur_intv, start1, len1);
tmp_interval_mid = copy_intervals (cur_intv, end1, len_mid);
tmp_interval2 = copy_intervals (cur_intv, start2, len2);
- Fset_text_properties (make_number (start1), make_number (end2),
+ Fset_text_properties (make_fixnum (start1), make_fixnum (end2),
Qnil, Qnil);
/* holds region 1 */
if (STRINGP (Vauto_save_list_file_name))
unlink (XSTRING (Vauto_save_list_file_name)->data);
- exit (INTEGERP (arg) ? XINT (arg)
+ exit (FIXNUMP (arg) ? XINT (arg)
#ifdef VMS
: 1
#else
are to be bound to zero. */
if (!EQ (Vmocklisp_arguments, Qt))
{
- val = make_number (0);
+ val = make_fixnum (0);
while (!NILP (args) && (tem = Fcar (args), SYMBOLP (tem)))
{
QUIT;
return Qnil;
documentation = Fget (variable, Qvariable_documentation);
- if (INTEGERP (documentation) && XINT (documentation) < 0)
+ if (FIXNUMP (documentation) && XINT (documentation) < 0)
return Qt;
if (STRINGP (documentation)
&& ((unsigned char) XSTRING (documentation)->data[0] == '*'))
/* If it is (STRING . INTEGER), a negative integer means a user variable. */
if (CONSP (documentation)
&& STRINGP (XCAR (documentation))
- && INTEGERP (XCDR (documentation))
+ && FIXNUMP (XCDR (documentation))
&& XINT (XCDR (documentation)) < 0)
return Qt;
/* Customizable? */
if (EQ (XCAR (def), Qautoload))
{
/* Autoloading function: will it be a macro when loaded? */
- tem = Fnth (make_number (4), def);
+ tem = Fnth (make_fixnum (4), def);
if (EQ (tem, Qt) || EQ (tem, Qmacro))
/* Yes, load it and try again. */
{
specbind (next, arg_vector[i++]);
else if (!optional)
return Fsignal (Qwrong_number_of_arguments,
- Fcons (fun, Fcons (make_number (nargs), Qnil)));
+ Fcons (fun, Fcons (make_fixnum (nargs), Qnil)));
else
specbind (next, Qnil);
}
return Fsignal (Qinvalid_function, Fcons (fun, Qnil));
else if (i < nargs)
return Fsignal (Qwrong_number_of_arguments,
- Fcons (fun, Fcons (make_number (nargs), Qnil)));
+ Fcons (fun, Fcons (make_fixnum (nargs), Qnil)));
if (CONSP (fun))
val = Fprogn (XCDR (XCDR (fun)));
encoded_newname = ENCODE_FILE (newname);
if (NILP (ok_if_already_exists)
- || INTEGERP (ok_if_already_exists))
+ || FIXNUMP (ok_if_already_exists))
barf_or_query_if_file_exists (encoded_newname, "copy to it",
- INTEGERP (ok_if_already_exists), &out_st, 0);
+ FIXNUMP (ok_if_already_exists), &out_st, 0);
else if (stat (XSTRING (encoded_newname)->data, &out_st) < 0)
out_st.st_mode = 0;
if (ifd < 0)
report_file_error ("Opening input file", Fcons (file, Qnil));
- record_unwind_protect (close_file_unwind, make_number (ifd));
+ record_unwind_protect (close_file_unwind, make_fixnum (ifd));
/* We can only copy regular files and symbolic links. Other files are not
copyable by us. */
if (ofd < 0)
report_file_error ("Opening output file", Fcons (newname, Qnil));
- record_unwind_protect (close_file_unwind, make_number (ofd));
+ record_unwind_protect (close_file_unwind, make_fixnum (ofd));
immediate_quit = 1;
QUIT;
if (NILP (Fstring_equal (Fdowncase (file), Fdowncase (newname))))
#endif
if (NILP (ok_if_already_exists)
- || INTEGERP (ok_if_already_exists))
+ || FIXNUMP (ok_if_already_exists))
barf_or_query_if_file_exists (encoded_newname, "rename to it",
- INTEGERP (ok_if_already_exists), 0, 0);
+ FIXNUMP (ok_if_already_exists), 0, 0);
#ifndef BSD4_1
if (0 > rename (XSTRING (encoded_file)->data, XSTRING (encoded_newname)->data))
#else
encoded_newname = ENCODE_FILE (newname);
if (NILP (ok_if_already_exists)
- || INTEGERP (ok_if_already_exists))
+ || FIXNUMP (ok_if_already_exists))
barf_or_query_if_file_exists (encoded_newname, "make it a new name",
- INTEGERP (ok_if_already_exists), 0, 0);
+ FIXNUMP (ok_if_already_exists), 0, 0);
unlink (XSTRING (newname)->data);
if (0 > link (XSTRING (encoded_file)->data, XSTRING (encoded_newname)->data))
encoded_linkname = ENCODE_FILE (linkname);
if (NILP (ok_if_already_exists)
- || INTEGERP (ok_if_already_exists))
+ || FIXNUMP (ok_if_already_exists))
barf_or_query_if_file_exists (encoded_linkname, "make it a link",
- INTEGERP (ok_if_already_exists), 0, 0);
+ FIXNUMP (ok_if_already_exists), 0, 0);
if (0 > symlink (XSTRING (encoded_filename)->data,
XSTRING (encoded_linkname)->data))
{
st.st_mode |= S_IEXEC;
#endif /* MSDOS && __DJGPP__ < 2 */
- 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, 0,
if (!NILP (replace))
record_unwind_protect (restore_point_unwind, Fpoint_marker ());
- record_unwind_protect (close_file_unwind, make_number (fd));
+ record_unwind_protect (close_file_unwind, make_fixnum (fd));
/* Supposedly happens on VMS. */
if (! not_regular && st.st_size < 0)
insert_1_both (read_buf, nread, nread, 0, 0, 0);
TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
val = call2 (Vset_auto_coding_function,
- filename, make_number (nread));
+ filename, make_fixnum (nread));
set_buffer_internal (prev);
/* Remove the binding for standard-output. */
if (inserted > 0 && ! NILP (Vset_auto_coding_function))
{
val = call2 (Vset_auto_coding_function,
- filename, make_number (inserted));
+ filename, make_fixnum (inserted));
}
if (NILP (val))
}
insval = call3 (Qformat_decode,
- Qnil, make_number (inserted), visit);
+ Qnil, make_fixnum (inserted), visit);
CHECK_NUMBER (insval, 0);
inserted = XFASTINT (insval);
p = Vafter_insert_file_functions;
while (!NILP (p))
{
- insval = call1 (Fcar (p), make_number (inserted));
+ insval = call1 (Fcar (p), make_fixnum (inserted));
if (!NILP (insval))
{
CHECK_NUMBER (insval, 0);
/* ??? Retval needs to be dealt with in all cases consistently. */
if (NILP (val))
val = Fcons (orig_filename,
- Fcons (make_number (inserted),
+ Fcons (make_fixnum (inserted),
Qnil));
RETURN_UNGCPRO (unbind_to (count, val));
report_file_error ("Opening output file", Fcons (filename, Qnil));
}
- record_unwind_protect (close_file_unwind, make_number (desc));
+ record_unwind_protect (close_file_unwind, make_fixnum (desc));
if (!NILP (append) && !NILP (Ffile_regular_p (filename)))
{
#else
/* Whether VMS or not, we must move the gap to the next of newline
when we must put designation sequences at beginning of line. */
- if (INTEGERP (start)
+ if (FIXNUMP (start)
&& coding.type == coding_type_iso2022
&& coding.flags & CODING_FLAG_ISO_DESIGNATE_AT_BOL
&& GPT > BEG && GPT_ADDR[-1] != '\n')
has written annotations to a temporary buffer, which is now
current. */
res = call5 (Qformat_annotate_function, Fcar (p), start, end,
- original_buffer, make_number (i));
+ original_buffer, make_fixnum (i));
if (current_buffer != given_buffer)
{
XSETFASTINT (start, BEGV);
{
tem = Fcar_safe (Fcar (*annot));
nextpos = pos - 1;
- if (INTEGERP (tem))
+ if (FIXNUMP (tem))
nextpos = XFASTINT (tem);
/* If there are no more annotations in this range,
message2 (XSTRING (msg)->data, nbytes, STRING_MULTIBYTE (msg));
else
message2_nolog (XSTRING (msg)->data, nbytes, STRING_MULTIBYTE (msg));
- Fsleep_for (make_number (1), Qnil);
+ Fsleep_for (make_fixnum (1), Qnil);
}
UNGCPRO;
record_unwind_protect (do_auto_save_unwind, lispstream);
record_unwind_protect (do_auto_save_unwind_1,
- make_number (minibuffer_auto_raise));
+ make_fixnum (minibuffer_auto_raise));
minibuffer_auto_raise = 0;
auto_saving = 1;
/* Turn off auto-saving until there's a real save,
and prevent any more warnings. */
XSETINT (b->save_length, -1);
- Fsleep_for (make_number (1), Qnil);
+ Fsleep_for (make_fixnum (1), Qnil);
continue;
}
set_buffer_internal (b);
args[0] = insdef;
args[1] = initial;
insdef = Fconcat (2, args);
- pos = make_number (XSTRING (double_dollars (dir))->size);
+ pos = make_fixnum (XSTRING (double_dollars (dir))->size);
insdef = Fcons (double_dollars (insdef), pos);
}
else
insdef = double_dollars (insdef);
}
else if (STRINGP (initial))
- insdef = Fcons (double_dollars (initial), make_number (0));
+ insdef = Fcons (double_dollars (initial), make_fixnum (0));
else
insdef = Qnil;
if (!NILP (sequence))
wrong_type_argument (Qlistp, sequence);
- val = make_number (i);
+ val = make_fixnum (i);
}
else if (NILP (sequence))
XSETFASTINT (val, 0);
Lisp_Object string;
{
CHECK_STRING (string, 1);
- return make_number (STRING_BYTES (XSTRING (string)));
+ return make_fixnum (STRING_BYTES (XSTRING (string)));
}
DEFUN ("string-equal", Fstring_equal, Sstring_equal, 2, 2, 0,
CHECK_STRING (str1, 0);
CHECK_STRING (str2, 1);
if (NILP (start1))
- start1 = make_number (0);
+ start1 = make_fixnum (0);
if (NILP (start2))
- start2 = make_number (0);
+ start2 = make_fixnum (0);
CHECK_NATNUM (start1, 2);
CHECK_NATNUM (start2, 3);
if (! NILP (end1))
{
Lisp_Object tem;
- tem = Fupcase (make_number (c1));
+ tem = Fupcase (make_fixnum (c1));
c1 = XINT (tem);
- tem = Fupcase (make_number (c2));
+ tem = Fupcase (make_fixnum (c2));
c2 = XINT (tem);
}
past the character that we are comparing;
hence we don't add or subtract 1 here. */
if (c1 < c2)
- return make_number (- i1 + XINT (start1));
+ return make_fixnum (- i1 + XINT (start1));
else
- return make_number (i1 - XINT (start1));
+ return make_fixnum (i1 - XINT (start1));
}
if (i1 < end1_char)
- return make_number (i1 - XINT (start1) + 1);
+ return make_fixnum (i1 - XINT (start1) + 1);
if (i2 < end2_char)
- return make_number (- i1 + XINT (start1) - 1);
+ return make_fixnum (- i1 + XINT (start1) - 1);
return Qt;
}
for (i = 0; i < len; i++)
{
ch = XVECTOR (this)->contents[i];
- if (! INTEGERP (ch))
+ if (! FIXNUMP (ch))
wrong_type_argument (Qintegerp, ch);
this_len_byte = CHAR_BYTES (XINT (ch));
result_len_byte += this_len_byte;
some_multibyte = 1;
}
else if (BOOL_VECTOR_P (this) && XBOOL_VECTOR (this)->size > 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);
- if (! INTEGERP (ch))
+ if (! FIXNUMP (ch))
wrong_type_argument (Qintegerp, ch);
this_len_byte = CHAR_BYTES (XINT (ch));
result_len_byte += this_len_byte;
/* 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
{
this = args[textprops[argnum].argnum];
props = text_property_list (this,
- make_number (0),
- make_number (XSTRING (this)->size),
+ make_fixnum (0),
+ make_fixnum (XSTRING (this)->size),
Qnil);
/* If successive arguments have properites, 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 + XSTRING (this)->size;
}
}
from_byte = string_char_to_byte (string, from_char);
if (!(0 <= from_char && from_char <= to_char && to_char <= size))
- args_out_of_range_3 (string, make_number (from_char),
- make_number (to_char));
+ args_out_of_range_3 (string, make_fixnum (from_char),
+ make_fixnum (to_char));
if (STRINGP (string))
{
res = make_specified_string (XSTRING (string)->data + from_byte,
to_char - from_char, to_byte - from_byte,
STRING_MULTIBYTE (string));
- copy_text_properties (make_number (from_char), make_number (to_char),
- string, make_number (0), res, Qnil);
+ copy_text_properties (make_fixnum (from_char), make_fixnum (to_char),
+ string, make_fixnum (0), res, Qnil);
}
else
res = Fvector (to_char - from_char,
size = XVECTOR (string)->size;
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 (XSTRING (string)->data + 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,
cbytes = 1;
}
- if (!INTEGERP (elt) || c != XINT (elt))
+ if (!FIXNUMP (elt) || c != XINT (elt))
{
++nchars;
nbytes += cbytes;
cbytes = 1;
}
- if (!INTEGERP (elt) || c != XINT (elt))
+ if (!FIXNUMP (elt) || c != XINT (elt))
{
unsigned char *from = &XSTRING (seq)->data[ibyte];
unsigned char *to = &XSTRING (tem)->data[nbytes];
if (EQ (range, Qnil))
return XCHAR_TABLE (char_table)->defalt;
- else if (INTEGERP (range))
+ else if (FIXNUMP (range))
return Faref (char_table, range);
else if (SYMBOLP (range))
{
CHECK_VECTOR (charset_info, 0);
return Faref (char_table,
- make_number (XINT (XVECTOR (charset_info)->contents[0])
+ make_fixnum (XINT (XVECTOR (charset_info)->contents[0])
+ 128));
}
else if (VECTORP (range))
{
if (XVECTOR (range)->size == 1)
return Faref (char_table,
- make_number (XINT (XVECTOR (range)->contents[0]) + 128));
+ make_fixnum (XINT (XVECTOR (range)->contents[0]) + 128));
else
{
int size = XVECTOR (range)->size;
CHECK_VECTOR (charset_info, 0);
return Faset (char_table,
- make_number (XINT (XVECTOR (charset_info)->contents[0])
+ make_fixnum (XINT (XVECTOR (charset_info)->contents[0])
+ 128),
value);
}
- else if (INTEGERP (range))
+ else if (FIXNUMP (range))
Faset (char_table, range, value);
else if (VECTORP (range))
{
if (XVECTOR (range)->size == 1)
return Faset (char_table,
- make_number (XINT (XVECTOR (range)->contents[0]) + 128),
+ make_fixnum (XINT (XVECTOR (range)->contents[0]) + 128),
value);
else
{
int ch;
{
Lisp_Object value;
- value = Faref (table, make_number (ch));
- if (! INTEGERP (value))
+ value = Faref (table, make_fixnum (ch));
+ if (! FIXNUMP (value))
return ch;
return XINT (value);
}
{
Lisp_Object elt = XCHAR_TABLE (subtable)->contents[i];
if (c_function)
- (*c_function) (arg, make_number (i), elt);
+ (*c_function) (arg, make_fixnum (i), elt);
else
- call2 (function, make_number (i), elt);
+ call2 (function, make_fixnum (i), elt);
}
#if 0 /* If the char table has entries for higher characters,
we should report them. */
c2 = depth >= 2 ? XFASTINT (indices[2]) : 0;
c = MAKE_CHAR (charset, c1, c2);
if (c_function)
- (*c_function) (arg, make_number (c), elt);
+ (*c_function) (arg, make_fixnum (c), elt);
else
- call2 (function, make_number (c), elt);
+ call2 (function, make_fixnum (c), elt);
}
}
}
/* If we need to quit, quit with cursor_in_echo_area = 0. */
QUIT;
- key = Fmake_vector (make_number (1), obj);
+ key = Fmake_vector (make_fixnum (1), obj);
def = Flookup_key (map, key, Qt);
if (EQ (def, intern ("skip")))
Fding (Qnil);
Fdiscard_input ();
message ("Please answer yes or no.");
- Fsleep_for (make_number (2), Qnil);
+ Fsleep_for (make_fixnum (2), Qnil);
}
}
\f
while (loads-- > 0)
{
Lisp_Object load = (NILP (use_floats) ?
- make_number ((int) (100.0 * load_ave[loads]))
+ make_fixnum ((int) (100.0 * load_ave[loads]))
: make_float (load_ave[loads]));
ret = Fcons (load, ret);
}
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,
old_pos = XFASTINT (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,
args[0] = h->user_hash_function;
args[1] = key;
hash = Ffuncall (2, args);
- if (!INTEGERP (hash))
+ if (!FIXNUMP (hash))
Fsignal (Qerror,
list2 (build_string ("Invalid hash code returned from \
user-supplied hash function"),
/* Preconditions. */
xassert (SYMBOLP (test));
- xassert (INTEGERP (size) && XINT (size) >= 0);
- xassert ((INTEGERP (rehash_size) && XINT (rehash_size) > 0)
+ xassert (FIXNUMP (size) && XINT (size) >= 0);
+ xassert ((FIXNUMP (rehash_size) && XINT (rehash_size) > 0)
|| (FLOATP (rehash_size) && XFLOATINT (rehash_size) > 1.0));
xassert (FLOATP (rehash_threshold)
&& XFLOATINT (rehash_threshold) > 0
&& XFLOATINT (rehash_threshold) <= 1.0);
if (XFASTINT (size) == 0)
- size = make_number (1);
+ size = make_fixnum (1);
/* Allocate a table and initialize it. */
h = allocate_hash_table ();
h->weak = weak;
h->rehash_threshold = rehash_threshold;
h->rehash_size = rehash_size;
- h->count = make_number (0);
- h->key_and_value = Fmake_vector (make_number (2 * sz), Qnil);
+ h->count = make_fixnum (0);
+ h->key_and_value = Fmake_vector (make_fixnum (2 * sz), Qnil);
h->hash = Fmake_vector (size, Qnil);
h->next = Fmake_vector (size, Qnil);
/* Cast to int here avoids losing with gcc 2.95 on Tru64/Alpha... */
index_size = next_almost_prime ((int) (sz / XFLOATINT (rehash_threshold)));
- h->index = Fmake_vector (make_number (index_size), Qnil);
+ h->index = Fmake_vector (make_fixnum (index_size), Qnil);
/* Set up the free list. */
for (i = 0; i < sz - 1; ++i)
- HASH_NEXT (h, i) = make_number (i + 1);
- h->next_free = make_number (0);
+ HASH_NEXT (h, i) = make_fixnum (i + 1);
+ h->next_free = make_fixnum (0);
XSET_HASH_TABLE (table, h);
xassert (HASH_TABLE_P (table));
int old_size = HASH_TABLE_SIZE (h);
int i, new_size, index_size;
- if (INTEGERP (h->rehash_size))
+ if (FIXNUMP (h->rehash_size))
new_size = old_size + XFASTINT (h->rehash_size);
else
new_size = old_size * XFLOATINT (h->rehash_size);
h->key_and_value = larger_vector (h->key_and_value, 2 * new_size, Qnil);
h->next = larger_vector (h->next, new_size, Qnil);
h->hash = larger_vector (h->hash, new_size, Qnil);
- h->index = Fmake_vector (make_number (index_size), Qnil);
+ h->index = Fmake_vector (make_fixnum (index_size), Qnil);
/* Update the free list. Do it so that new entries are added at
the end of the free list. This makes some operations like
maphash faster. */
for (i = old_size; i < new_size - 1; ++i)
- HASH_NEXT (h, i) = make_number (i + 1);
+ HASH_NEXT (h, i) = make_fixnum (i + 1);
if (!NILP (h->next_free))
{
!NILP (next))
last = next;
- HASH_NEXT (h, XFASTINT (last)) = make_number (old_size);
+ HASH_NEXT (h, XFASTINT (last)) = make_fixnum (old_size);
}
else
XSETFASTINT (h->next_free, old_size);
unsigned hash_code = XUINT (HASH_HASH (h, i));
int start_of_bucket = hash_code % XVECTOR (h->index)->size;
HASH_NEXT (h, i) = HASH_INDEX (h, start_of_bucket);
- HASH_INDEX (h, start_of_bucket) = make_number (i);
+ HASH_INDEX (h, start_of_bucket) = make_fixnum (i);
}
}
}
/* Increment count after resizing because resizing may fail. */
maybe_resize_hash_table (h);
- h->count = make_number (XFASTINT (h->count) + 1);
+ h->count = make_fixnum (XFASTINT (h->count) + 1);
/* Store key/value in the key_and_value vector. */
i = XFASTINT (h->next_free);
HASH_VALUE (h, i) = value;
/* Remember its hash code. */
- HASH_HASH (h, i) = make_number (hash);
+ HASH_HASH (h, i) = make_fixnum (hash);
/* Add new entry to its collision chain. */
start_of_bucket = hash % XVECTOR (h->index)->size;
HASH_NEXT (h, i) = HASH_INDEX (h, start_of_bucket);
- HASH_INDEX (h, start_of_bucket) = make_number (i);
+ HASH_INDEX (h, start_of_bucket) = make_fixnum (i);
return i;
}
the free list. */
HASH_KEY (h, i) = HASH_VALUE (h, i) = HASH_HASH (h, i) = Qnil;
HASH_NEXT (h, i) = h->next_free;
- h->next_free = make_number (i);
- h->count = make_number (XFASTINT (h->count) - 1);
+ h->next_free = make_fixnum (i);
+ h->count = make_fixnum (XFASTINT (h->count) - 1);
xassert (XINT (h->count) >= 0);
break;
}
for (i = 0; i < size; ++i)
{
- HASH_NEXT (h, i) = i < size - 1 ? make_number (i + 1) : Qnil;
+ HASH_NEXT (h, i) = i < size - 1 ? make_fixnum (i + 1) : Qnil;
HASH_KEY (h, i) = Qnil;
HASH_VALUE (h, i) = Qnil;
HASH_HASH (h, i) = Qnil;
for (i = 0; i < XVECTOR (h->index)->size; ++i)
XVECTOR (h->index)->contents[i] = Qnil;
- h->next_free = make_number (0);
- h->count = make_number (0);
+ h->next_free = make_fixnum (0);
+ h->count = make_fixnum (0);
}
}
HASH_KEY (h, i) = HASH_VALUE (h, i) = Qnil;
HASH_HASH (h, i) = Qnil;
- h->count = make_number (XFASTINT (h->count) - 1);
+ h->count = make_fixnum (XFASTINT (h->count) - 1);
}
}
else
Lisp_Object obj;
{
unsigned hash = sxhash (obj, 0);;
- return make_number (hash);
+ return make_fixnum (hash);
}
if (!CONSP (prop) || XFASTINT (Flength (prop)) < 2)
Fsignal (Qerror, list2 (build_string ("Invalid hash table test"),
test));
- user_test = Fnth (make_number (0), prop);
- user_hash = Fnth (make_number (1), prop);
+ user_test = Fnth (make_fixnum (0), prop);
+ user_hash = Fnth (make_fixnum (1), prop);
}
else
user_test = user_hash = Qnil;
/* See if there's a `:size SIZE' argument. */
i = get_key_arg (QCsize, nargs, args, used);
- size = i < 0 ? make_number (DEFAULT_HASH_SIZE) : args[i];
- if (!INTEGERP (size) || XINT (size) < 0)
+ size = i < 0 ? make_fixnum (DEFAULT_HASH_SIZE) : args[i];
+ if (!FIXNUMP (size) || XINT (size) < 0)
Fsignal (Qerror,
list2 (build_string ("Invalid hash table size"),
size));
i = get_key_arg (QCrehash_size, nargs, args, used);
rehash_size = i < 0 ? make_float (DEFAULT_REHASH_SIZE) : args[i];
if (!NUMBERP (rehash_size)
- || (INTEGERP (rehash_size) && XINT (rehash_size) <= 0)
+ || (FIXNUMP (rehash_size) && XINT (rehash_size) <= 0)
|| XFLOATINT (rehash_size) <= 1.0)
Fsignal (Qerror,
list2 (build_string ("Invalid hash table rehash size"),
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));
}
}
if (!(0 <= start_char && start_char <= end_char && end_char <= size))
- args_out_of_range_3 (object, make_number (start_char),
- make_number (end_char));
+ args_out_of_range_3 (object, make_fixnum (start_char),
+ make_fixnum (end_char));
}
else
{
&& !NILP (Ffboundp (Vselect_safe_coding_system_function)))
/* Confirm that VAL can surely encode the current region. */
coding_system = call3 (Vselect_safe_coding_system_function,
- make_number (b), make_number (e),
+ make_fixnum (b), make_fixnum (e),
coding_system);
if (force_raw_text)
Lisp_Object tem;
int i;
- tem = Fmake_vector (make_number (size + 8), Qnil);
+ tem = Fmake_vector (make_fixnum (size + 8), Qnil);
for (i = 0; i < size; i++)
AREF (tem, i) = AREF (Vfontset_table, i);
Vfontset_table = tem;
fontset = Fmake_char_table (Qfontset, Qnil);
- FONTSET_ID (fontset) = make_number (id);
+ FONTSET_ID (fontset) = make_fixnum (id);
FONTSET_NAME (fontset) = name;
FONTSET_FRAME (fontset) = frame;
FONTSET_BASE (fontset) = base;
/* Record the face ID in FONTSET at the same index as the
information in the base fontset. */
- FONTSET_SET (fontset, c, make_number (face_id));
+ FONTSET_SET (fontset, c, make_fixnum (face_id));
return face_id;
}
if (CONSP (XCAR (tmp))
&& ((i = get_charset_id (XCAR (XCAR (tmp))))
>= 0)
- && INTEGERP (XCDR (XCAR (tmp)))
+ && FIXNUMP (XCDR (XCAR (tmp)))
&& XFASTINT (XCDR (XCAR (tmp))) < 4)
fontp->encoding[i]
= XFASTINT (XCDR (XCAR (tmp)));
if (face
&& !NILP (fontset)
&& !BASE_FONTSET_P (fontset))
- FONTSET_SET (fontset, c, make_number (face->id));
+ FONTSET_SET (fontset, c, make_fixnum (face->id));
return fontp;
}
else
{
c = MAKE_CHAR (charset, 0, 0);
- elements = Fcons (Fcons (make_number (c), tem), elements);
+ elements = Fcons (Fcons (make_fixnum (c), tem), elements);
}
}
error ("No ASCII font in the fontlist");
fontset = make_fontset (Qnil, name, Qnil);
- FONTSET_ASCII (fontset) = Fcons (make_number (0), ascii_font);
+ FONTSET_ASCII (fontset) = Fcons (make_fixnum (0), ascii_font);
for (; CONSP (elements); elements = XCDR (elements))
{
elt = XCAR (elements);
if (STRINGP (fontname))
{
fontname = Fdowncase (fontname);
- elt = Fcons (make_number (from), font_family_registry (fontname, 0));
+ elt = Fcons (make_fixnum (from), font_family_registry (fontname, 0));
}
else
{
CHECK_STRING (registry, 2);
registry = Fdowncase (registry);
}
- elt = Fcons (make_number (from), Fcons (family, registry));
+ elt = Fcons (make_fixnum (from), Fcons (family, registry));
}
/* The arg FRAME is kept for backward compatibility. We only check
if (!fontp)
return Qnil;
- info = Fmake_vector (make_number (7), Qnil);
+ info = Fmake_vector (make_fixnum (7), Qnil);
XVECTOR (info)->contents[0] = build_string (fontp->name);
XVECTOR (info)->contents[1] = build_string (fontp->full_name);
- XVECTOR (info)->contents[2] = make_number (fontp->size);
- XVECTOR (info)->contents[3] = make_number (fontp->height);
- XVECTOR (info)->contents[4] = make_number (fontp->baseline_offset);
- XVECTOR (info)->contents[5] = make_number (fontp->relative_compose);
- XVECTOR (info)->contents[6] = make_number (fontp->default_ascent);
+ XVECTOR (info)->contents[2] = make_fixnum (fontp->size);
+ XVECTOR (info)->contents[3] = make_fixnum (fontp->height);
+ XVECTOR (info)->contents[4] = make_fixnum (fontp->baseline_offset);
+ XVECTOR (info)->contents[5] = make_fixnum (fontp->relative_compose);
+ XVECTOR (info)->contents[6] = make_fixnum (fontp->default_ascent);
return info;
}
CHECK_NUMBER_COERCE_MARKER (position, 0);
pos = XINT (position);
if (pos < BEGV || pos >= ZV)
- args_out_of_range_3 (position, make_number (BEGV), make_number (ZV));
+ args_out_of_range_3 (position, make_fixnum (BEGV), make_fixnum (ZV));
pos_byte = CHAR_TO_BYTE (pos);
c = FETCH_CHAR (pos_byte);
if (! CHAR_VALID_P (c, 0))
(LAST FONT-INFO FONT-INFO ...), where FONT-INFO is (CHAR-OR-RANGE
FONT-SPEC). See the comment for accumulate_font_info for the
detail. */
- val = Fcons (Fcons (make_number (0),
+ val = Fcons (Fcons (make_fixnum (0),
Fcons (XCDR (FONTSET_ASCII (fontset)), Qnil)),
Qnil);
val = Fcons (val, val);
{
int c;
elt = XCAR (tail);
- if (INTEGERP (XCAR (elt)))
+ if (FIXNUMP (XCAR (elt)))
{
int charset, c1, c2;
c = XINT (XCAR (elt));
struct face *face;
face_id = FONTSET_REF_VIA_BASE (realized[i], c);
- if (INTEGERP (face_id))
+ if (FIXNUMP (face_id))
{
face = FACE_FROM_ID (f, XINT (face_id));
if (face && face->font && face->font_name)
elt = XCAR (elt);
fontp = (*query_font_func) (f, XSTRING (elt)->data);
}
- val = Fmake_vector (make_number (3), val);
- AREF (val, 0) = fontp ? make_number (fontp->size) : make_number (0);
- AREF (val, 1) = fontp ? make_number (fontp->height) : make_number (0);
+ val = Fmake_vector (make_fixnum (3), val);
+ AREF (val, 0) = fontp ? make_fixnum (fontp->size) : make_fixnum (0);
+ AREF (val, 1) = fontp ? make_fixnum (fontp->height) : make_fixnum (0);
return val;
}
Qfontset = intern ("fontset");
staticpro (&Qfontset);
- Fput (Qfontset, Qchar_table_extra_slots, make_number (3));
+ Fput (Qfontset, Qchar_table_extra_slots, make_fixnum (3));
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);
- FONTSET_ID (Vdefault_fontset) = make_number (0);
+ FONTSET_ID (Vdefault_fontset) = make_fixnum (0);
FONTSET_NAME (Vdefault_fontset)
= build_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default");
#if defined (macintosh)
FONTSET_ASCII (Vdefault_fontset)
- = Fcons (make_number (0),
+ = Fcons (make_fixnum (0),
build_string ("-apple-monaco-medium-r-*--*-120-*-*-*-*-mac-roman"));
#elif defined (WINDOWSNT)
FONTSET_ASCII (Vdefault_fontset)
- = Fcons (make_number (0),
+ = Fcons (make_fixnum (0),
build_string ("-*-courier new-normal-r-*-*-*-100-*-*-*-*-iso8859-1"));
#else
FONTSET_ASCII (Vdefault_fontset)
- = Fcons (make_number (0),
+ = Fcons (make_fixnum (0),
build_string ("-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1"));
#endif
AREF (Vfontset_table, 0) = Vdefault_fontset;
XSETFASTINT (w->top, XFASTINT (w->top) + n);
XSETFASTINT (w->height, XFASTINT (w->height) - n);
- if (INTEGERP (w->orig_top))
+ if (FIXNUMP (w->orig_top))
XSETFASTINT (w->orig_top, XFASTINT (w->orig_top) + n);
- if (INTEGERP (w->orig_height))
+ if (FIXNUMP (w->orig_height))
XSETFASTINT (w->orig_height, XFASTINT (w->orig_height) - n);
/* Handle just the top child in a vertical split. */
if (FRAME_MINIBUF_ONLY_P (f))
return;
- if (INTEGERP (value))
+ if (FIXNUMP (value))
nlines = XINT (value);
else
nlines = 0;
if (FRAME_VISIBLE_P (XFRAME (f)))
return f;
}
- else if (INTEGERP (minibuf) && XINT (minibuf) == 0)
+ else if (FIXNUMP (minibuf) && XINT (minibuf) == 0)
{
FRAME_SAMPLE_VISIBILITY (XFRAME (f));
if (FRAME_VISIBLE_P (XFRAME (f))
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);
}
}
store_in_alist (&alist, Qname, f->name);
height = (FRAME_NEW_HEIGHT (f) ? FRAME_NEW_HEIGHT (f) : FRAME_HEIGHT (f));
- store_in_alist (&alist, Qheight, make_number (height));
+ store_in_alist (&alist, Qheight, make_fixnum (height));
width = (FRAME_NEW_WIDTH (f) ? FRAME_NEW_WIDTH (f) : FRAME_WIDTH (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, Qminibuffer,
(! FRAME_HAS_MINIBUF_P (f) ? Qnil
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
- return make_number (x_char_height (f));
+ return make_fixnum (x_char_height (f));
else
#endif
- return make_number (1);
+ return make_fixnum (1);
}
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
- return make_number (x_char_width (f));
+ return make_fixnum (x_char_width (f));
else
#endif
- return make_number (1);
+ return make_fixnum (1);
}
DEFUN ("frame-pixel-height", Fframe_pixel_height,
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
- return make_number (x_pixel_height (f));
+ return make_fixnum (x_pixel_height (f));
else
#endif
- return make_number (FRAME_HEIGHT (f));
+ return make_fixnum (FRAME_HEIGHT (f));
}
DEFUN ("frame-pixel-width", Fframe_pixel_width,
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
- return make_number (x_pixel_width (f));
+ return make_fixnum (x_pixel_width (f));
else
#endif
- return make_number (FRAME_WIDTH (f));
+ return make_fixnum (FRAME_WIDTH (f));
}
\f
DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
float. Value is a C integer. */
#define PIXEL_X_FROM_CANON_X(F, X) \
- (INTEGERP (X) \
+ (FIXNUMP (X) \
? XINT (X) * CANON_X_UNIT (F) \
: (int) (XFLOAT_DATA (X) * CANON_X_UNIT (F)))
or float. Value is a C integer. */
#define PIXEL_Y_FROM_CANON_Y(F, Y) \
- (INTEGERP (Y) \
+ (FIXNUMP (Y) \
? XINT (Y) * CANON_Y_UNIT (F) \
: (int) (XFLOAT_DATA (Y) * CANON_Y_UNIT (F)))
#define CANON_X_FROM_PIXEL_X(F, X) \
((X) % CANON_X_UNIT (F) != 0 \
? make_float ((double) (X) / CANON_X_UNIT (F)) \
- : make_number ((X) / CANON_X_UNIT (F)))
+ : make_fixnum ((X) / CANON_X_UNIT (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.
#define CANON_Y_FROM_PIXEL_Y(F, Y) \
((Y) % CANON_Y_UNIT (F) \
? make_float ((double) (Y) / CANON_Y_UNIT (F)) \
- : make_number ((Y) / CANON_Y_UNIT (F)))
+ : make_fixnum ((Y) / CANON_Y_UNIT (F)))
#endif /* not EMACS_FRAME_H */
struct Lisp_Vector *widthtab;
if (!VECTORP (buf->width_table))
- buf->width_table = Fmake_vector (make_number (256), make_number (0));
+ buf->width_table = Fmake_vector (make_fixnum (256), make_fixnum (0));
widthtab = XVECTOR (buf->width_table);
if (widthtab->size != 256)
abort ();
next_element_from_display_vector does it. */
Lisp_Object entry = AREF (charvec, i);
- if (INTEGERP (entry)
+ if (FIXNUMP (entry)
&& GLYPH_CHAR_VALID_P (XFASTINT (entry)))
c = FAST_GLYPH_CHAR (XFASTINT (entry));
else
next_element_from_display_vector does it. */
Lisp_Object entry = AREF (charvec, i);
- if (INTEGERP (entry)
+ if (FIXNUMP (entry)
&& GLYPH_CHAR_VALID_P (XFASTINT (entry)))
c = FAST_GLYPH_CHAR (XFASTINT (entry));
else
if (mincol < XINT (column)) mincol = XINT (column);
if (fromcol == mincol)
- return make_number (mincol);
+ return make_fixnum (mincol);
if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
XSETFASTINT (n, mincol / tab_width - fromcol / tab_width);
if (XFASTINT (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;
next_element_from_display_vector does it. */
Lisp_Object entry = AREF (charvec, i);
- if (INTEGERP (entry)
+ if (FIXNUMP (entry)
&& GLYPH_CHAR_VALID_P (XFASTINT (entry)))
c = FAST_GLYPH_CHAR (XFASTINT (entry));
else
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. */
/* 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;
register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
register struct Lisp_Char_Table *dp = window_display_table (win);
int selective
- = (INTEGERP (current_buffer->selective_display)
+ = (FIXNUMP (current_buffer->selective_display)
? XINT (current_buffer->selective_display)
: !NILP (current_buffer->selective_display) ? -1 : 0);
int prev_hpos = 0;
next_element_from_display_vector does it. */
Lisp_Object entry = AREF (charvec, i);
- if (INTEGERP (entry)
+ if (FIXNUMP (entry)
&& GLYPH_CHAR_VALID_P (XFASTINT (entry)))
c = FAST_GLYPH_CHAR (XFASTINT (entry));
else
CHECK_LIVE_WINDOW (window, 0);
if (XINT (from) < BEGV || XINT (from) > ZV)
- args_out_of_range_3 (from, make_number (BEGV), make_number (ZV));
+ args_out_of_range_3 (from, make_fixnum (BEGV), make_fixnum (ZV));
if (XINT (to) < BEGV || XINT (to) > ZV)
- args_out_of_range_3 (to, make_number (BEGV), make_number (ZV));
+ args_out_of_range_3 (to, make_fixnum (BEGV), make_fixnum (ZV));
pos = compute_motion (XINT (from), XINT (XCDR (frompos)),
XINT (XCAR (frompos)), 0,
int from_byte;
int lmargin = hscroll > 0 ? 1 - hscroll : 0;
int selective
- = (INTEGERP (current_buffer->selective_display)
+ = (FIXNUMP (current_buffer->selective_display)
? XINT (current_buffer->selective_display)
: !NILP (current_buffer->selective_display) ? -1 : 0);
Lisp_Object window;
if (BUFFERP (old_buffer))
w->buffer = old_buffer;
- RETURN_UNGCPRO (make_number (it.vpos));
+ RETURN_UNGCPRO (make_fixnum (it.vpos));
}
if (CHAR_TABLE_P (Vnonascii_translation_table))
{
tbl = Fchar_table_extra_slot (Vnonascii_translation_table,
- make_number (0));
+ make_fixnum (0));
if (!CHAR_TABLE_P (tbl))
tbl = Qnil;
}
offset_intervals (current_buffer, PT, nchars);
if (!inherit && BUF_INTERVALS (current_buffer) != 0)
- 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);
{
Lisp_Object preserve_marker;
struct gcpro gcpro1;
- preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil);
+ preserve_marker = Fcopy_marker (make_fixnum (*preserve_ptr), Qnil);
GCPRO1 (preserve_marker);
verify_interval_modification (current_buffer, start, end);
*preserve_ptr = marker_position (preserve_marker);
#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)) \
if (inhibit_modification_hooks)
return;
- 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;
&& current_buffer != XBUFFER (combine_after_change_buffer))
Fcombine_after_change_execute ();
- elt = Fcons (make_number (charpos - BEG),
- Fcons (make_number (Z - (charpos - lendel + lenins)),
- Fcons (make_number (lenins - lendel), Qnil)));
+ elt = Fcons (make_fixnum (charpos - BEG),
+ Fcons (make_fixnum (Z - (charpos - lendel + lenins)),
+ Fcons (make_fixnum (lenins - lendel), Qnil)));
combine_after_change_list
= Fcons (elt, combine_after_change_list);
combine_after_change_buffer = Fcurrent_buffer ();
if (!NILP (current_buffer->overlays_before)
|| !NILP (current_buffer->overlays_after))
- 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));
}
Lisp_Object
int saved_inhibit_modification_hooks = inhibit_modification_hooks;
XSETBUFFER (buf, buffer);
inhibit_modification_hooks = 1;
- Fset_text_properties (make_number (position),
- make_number (position + length),
+ Fset_text_properties (make_fixnum (position),
+ make_fixnum (position + length),
Qnil, buf);
inhibit_modification_hooks = saved_inhibit_modification_hooks;
}
if (backwards)
{
- intangible_propval = Fget_char_property (make_number (charpos),
+ intangible_propval = Fget_char_property (make_fixnum (charpos),
Qintangible, Qnil);
/* If following char is intangible,
skip back over all chars with matching intangible property. */
if (! NILP (intangible_propval))
while (XINT (pos) > BUF_BEGV (buffer)
- && EQ (Fget_char_property (make_number (XINT (pos) - 1),
+ && EQ (Fget_char_property (make_fixnum (XINT (pos) - 1),
Qintangible, Qnil),
intangible_propval))
pos = Fprevious_char_property_change (pos, Qnil);
}
else
{
- intangible_propval = Fget_char_property (make_number (charpos - 1),
+ intangible_propval = Fget_char_property (make_fixnum (charpos - 1),
Qintangible, Qnil);
/* If following char is intangible,
enter_before = 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));
}
}
\f
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),
+ && EQ (Fget_char_property (make_fixnum (XINT (pos) - 1),
Qintangible, Qnil),
intangible_propval))
pos = Fprevious_char_property_change (pos, Qnil);
{
/* 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 (XINT (pos) - 1),
Qintangible, Qnil);
/* If following char is intangible,
casts to get around this, it will break some development work in
progress. */
#define SET_INTERVAL_PARENT(i,p) (eassert (!INT_LISPLIKE (p)),(i)->up_obj = 0, (i)->up.interval = (p))
-#define SET_INTERVAL_OBJECT(i,o) (eassert (!INTEGERP (o)), eassert (BUFFERP (o) || STRINGP (o)),(i)->up_obj = 1, (i)->up.obj = (o))
+#define SET_INTERVAL_OBJECT(i,o) (eassert (!FIXNUMP (o)), eassert (BUFFERP (o) || STRINGP (o)),(i)->up_obj = 1, (i)->up.obj = (o))
#define INTERVAL_PARENT(i) (eassert((i) != 0 && (i)->up_obj == 0),(i)->up.interval)
#define GET_INTERVAL_OBJECT(d,s) (eassert((s)->up_obj == 1), (d) = (s)->up.obj)
{ \
int newsize = 2 * XVECTOR (raw_keybuf)->size; \
Lisp_Object new; \
- new = Fmake_vector (make_number (newsize), Qnil); \
+ new = Fmake_vector (make_fixnum (newsize), Qnil); \
bcopy (XVECTOR (raw_keybuf)->contents, XVECTOR (new)->contents, \
raw_keybuf_count * sizeof (Lisp_Object)); \
raw_keybuf = new; \
/* If someone has passed us a composite event, use its head symbol. */
c = EVENT_HEAD (c);
- if (INTEGERP (c))
+ if (FIXNUMP (c))
{
int ch = XINT (c);
{
Lisp_Object new_keys;
- new_keys = Fmake_vector (make_number (size * 2), Qnil);
+ new_keys = Fmake_vector (make_fixnum (size * 2), Qnil);
bcopy (XVECTOR (this_command_keys)->contents,
XVECTOR (new_keys)->contents,
size * sizeof (Lisp_Object));
any_kboard_state ();
#endif
- return make_number (0);
+ return make_fixnum (0);
}
/* Take actions on handling an error. DATA is the data that describes
if (kill_emacs_p)
{
Fterpri (stream);
- Fkill_emacs (make_number (-1));
+ Fkill_emacs (make_fixnum (-1));
}
}
\f
if (!NILP (Vquit_flag))
{
Vquit_flag = Qnil;
- Vunread_command_events = Fcons (make_number (quit_char), Qnil);
+ Vunread_command_events = Fcons (make_fixnum (quit_char), Qnil);
}
}
}
else if (EQ (Vthis_command, Qself_insert_command)
/* Try this optimization only on ascii keystrokes. */
- && INTEGERP (last_command_char))
+ && FIXNUMP (last_command_char))
{
unsigned int c = XINT (last_command_char);
int value;
stop_other_atimers (poll_timer);
stop_polling ();
- specbind (Qpolling_period, make_number (new));
+ specbind (Qpolling_period, make_fixnum (new));
/* Start a new alarm with the new period. */
start_polling ();
#endif
/* Undo what read_char_x_menu_prompt did when it unread
additional keys returned by Fx_popup_menu. */
if (CONSP (c)
- && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
+ && (SYMBOLP (XCAR (c)) || FIXNUMP (XCAR (c)))
&& NILP (XCDR (c)))
c = XCAR (c);
/* Undo what read_char_x_menu_prompt did when it unread
additional keys returned by Fx_popup_menu. */
if (CONSP (c)
- && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
+ && (SYMBOLP (XCAR (c)) || FIXNUMP (XCAR (c)))
&& NILP (XCDR (c)))
c = XCAR (c);
/* Undo what read_char_x_menu_prompt did when it unread
additional keys returned by Fx_popup_menu. */
if (CONSP (c)
- && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
+ && (SYMBOLP (XCAR (c)) || FIXNUMP (XCAR (c)))
&& NILP (XCDR (c)))
c = XCAR (c);
reread = 1;
RETURN_UNGCPRO (c);
}
- c = Faref (Vexecuting_macro, make_number (executing_macro_index));
+ c = Faref (Vexecuting_macro, make_fixnum (executing_macro_index));
if (STRINGP (Vexecuting_macro)
&& (XINT (c) & 0x80))
XSETFASTINT (c, CHAR_META | (XINT (c) & ~0x80));
&& !current_kboard->immediate_echo
&& this_command_key_count > 0
&& ! noninteractive
- && (FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
+ && (FLOATP (Vecho_keystrokes) || FIXNUMP (Vecho_keystrokes))
&& NILP (Fzerop (Vecho_keystrokes))
&& (/* No message. */
NILP (echo_area_buffer[0])
/* Auto save if enough time goes by without input. */
if (commandflag != 0
&& num_nonmacro_input_events > last_auto_save
- && INTEGERP (Vauto_save_timeout)
+ && FIXNUMP (Vauto_save_timeout)
&& XINT (Vauto_save_timeout) > 0)
{
Lisp_Object tem0;
}
/* Terminate Emacs in batch mode if at eof. */
- if (noninteractive && INTEGERP (c) && XINT (c) < 0)
- Fkill_emacs (make_number (1));
+ if (noninteractive && FIXNUMP (c) && XINT (c) < 0)
+ Fkill_emacs (make_fixnum (1));
- if (INTEGERP (c))
+ if (FIXNUMP (c))
{
/* Add in any extra modifiers, where appropriate. */
if ((extra_keyboard_modifiers & CHAR_CTL)
}
/* Handle things that only apply to characters. */
- if (INTEGERP (c))
+ if (FIXNUMP (c))
{
/* If kbd_buffer_get_event gave us an EOF, return that. */
if (XINT (c) == -1)
/* Wipe the echo area.
But first, if we are about to use an input method,
save the echo area contents for it to refer to. */
- if (INTEGERP (c)
+ if (FIXNUMP (c)
&& ! NILP (Vinput_method_function)
&& (unsigned) XINT (c) >= ' '
&& (unsigned) XINT (c) != 127
reread_for_input_method:
from_macro:
/* Pass this to the input method, if appropriate. */
- if (INTEGERP (c)
+ if (FIXNUMP (c)
&& ! NILP (Vinput_method_function)
/* Don't run the input method within a key sequence,
after the first event of the key sequence. */
{
/* (help-echo FRAME HELP WINDOW OBJECT POS). */
Lisp_Object help, object, position, window;
- help = Fnth (make_number (2), c);
- window = Fnth (make_number (3), c);
- object = Fnth (make_number (4), c);
- position = Fnth (make_number (5), c);
+ help = Fnth (make_fixnum (2), c);
+ window = Fnth (make_fixnum (3), c);
+ object = Fnth (make_fixnum (4), c);
+ position = Fnth (make_fixnum (5), c);
show_help_echo (help, window, object, position, 0);
goto retry;
}
before_command_echo_length = echo_length ();
/* Don't echo mouse motion events. */
- if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
+ if ((FLOATP (Vecho_keystrokes) || FIXNUMP (Vecho_keystrokes))
&& NILP (Fzerop (Vecho_keystrokes))
&& ! (EVENT_HAS_PARAMETERS (c)
&& EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
unbind_to (count, Qnil);
redisplay ();
- if (EQ (c, make_number (040)))
+ if (EQ (c, make_fixnum (040)))
{
cancel_echoing ();
do
before_command_echo_length = echo_length ();
/* Don't echo mouse motion events. */
- if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
+ if ((FLOATP (Vecho_keystrokes) || FIXNUMP (Vecho_keystrokes))
&& NILP (Fzerop (Vecho_keystrokes)))
{
echo_char (c);
{
Lisp_Object help;
- help = Fnth (make_number (2), c);
+ help = Fnth (make_fixnum (2), c);
if (STRINGP (help))
{
int last_idx;
if (!CONSP (last_c)
|| !EQ (XCAR (last_c), Qhelp_echo)
- || (last_help = Fnth (make_number (2), last_c),
+ || (last_help = Fnth (make_fixnum (2), last_c),
!EQ (last_help, help)))
{
total_keys++;
If you, dear reader, have a better idea, you've got the source. :-) */
if (dribble)
{
- if (INTEGERP (c))
+ if (FIXNUMP (c))
{
if (XUINT (c) < 0x100)
putc (XINT (c), dribble);
{
kb->kbd_queue
= Fcons (make_lispy_switch_frame (event->frame_or_window),
- Fcons (make_number (c), Qnil));
+ Fcons (make_fixnum (c), Qnil));
kb->kbd_queue_has_data = 1;
for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
{
bufp->kind = HELP_EVENT;
bufp->frame_or_window = frame;
bufp->arg = object;
- bufp->x = make_number (pos);
+ bufp->x = make_fixnum (pos);
bufp->code = 0;
++bufp;
event.kind = HELP_EVENT;
event.frame_or_window = frame;
event.arg = Qnil;
- event.x = make_number (0);
+ event.x = make_fixnum (0);
event.code = 0;
kbd_buffer_store_event (&event);
event.kind = HELP_EVENT;
event.frame_or_window = frame;
event.arg = help;
- event.x = make_number (0);
+ event.x = make_fixnum (0);
event.code = 1;
kbd_buffer_store_event (&event);
}
}
vector = XVECTOR (timer)->contents;
- if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
- || !INTEGERP (vector[3])
+ if (!FIXNUMP (vector[1]) || !FIXNUMP (vector[2])
+ || !FIXNUMP (vector[3])
|| ! NILP (vector[0]))
{
timers = XCDR (timers);
}
vector = XVECTOR (timer)->contents;
- if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
- || !INTEGERP (vector[3])
+ if (!FIXNUMP (vector[1]) || !FIXNUMP (vector[2])
+ || !FIXNUMP (vector[3])
|| ! NILP (vector[0]))
{
idle_timers = XCDR (idle_timers);
= Fcons (event->frame_or_window,
Fcons (Qmenu_bar,
Fcons (Fcons (event->x, event->y),
- Fcons (make_number (event->timestamp),
+ Fcons (make_fixnum (event->timestamp),
Qnil))));
return Fcons (item, Fcons (position, Qnil));
posn = part == 1 ? Qmode_line : Qheader_line;
string = mode_line_string (w, wx, wy, part == 1, &charpos);
if (STRINGP (string))
- string_info = Fcons (string, make_number (charpos));
+ string_info = Fcons (string, make_fixnum (charpos));
}
else if (part == 2)
posn = Qvertical_line;
Lisp_Object object;
struct display_pos p;
buffer_posn_from_coords (w, &wx, &wy, &object, &p);
- posn = make_number (CHARPOS (p.pos));
+ posn = make_fixnum (CHARPOS (p.pos));
if (STRINGP (object))
string_info
= Fcons (object,
- make_number (CHARPOS (p.string_pos)));
+ make_fixnum (CHARPOS (p.string_pos)));
}
}
= Fcons (window,
Fcons (posn,
Fcons (Fcons (event->x, event->y),
- Fcons (make_number (event->timestamp),
+ Fcons (make_fixnum (event->timestamp),
(NILP (string_info)
? Qnil
: Fcons (string_info, Qnil))))));
= Fcons (window,
Fcons (Qvertical_scroll_bar,
Fcons (portion_whole,
- Fcons (make_number (event->timestamp),
+ Fcons (make_fixnum (event->timestamp),
Fcons (part, Qnil)))));
}
#endif /* not USE_TOOLKIT_SCROLL_BARS */
&& XINT (event->y) == last_mouse_y
&& button_down_time != 0
&& (EQ (Vdouble_click_time, Qt)
- || (INTEGERP (Vdouble_click_time)
+ || (FIXNUMP (Vdouble_click_time)
&& ((int)(event->timestamp - button_down_time)
< XINT (Vdouble_click_time)))));
last_mouse_button = button;
pair. */
Lisp_Object down;
- down = Fnth (make_number (2), start_pos);
+ down = Fnth (make_fixnum (2), start_pos);
if (EQ (event->x, XCAR (down)) && EQ (event->y, XCDR (down)))
/* Mouse hasn't moved. */
event->modifiers |= click_modifier;
/* Avoid generating a drag event if the mouse
hasn't actually moved off the buffer position. */
- window1 = Fnth (make_number (0), position);
- posn1 = Fnth (make_number (1), position);
- window2 = Fnth (make_number (0), start_pos);
- posn2 = Fnth (make_number (1), start_pos);
+ window1 = Fnth (make_fixnum (0), position);
+ posn1 = Fnth (make_fixnum (1), position);
+ window2 = Fnth (make_fixnum (0), start_pos);
+ posn2 = Fnth (make_fixnum (1), start_pos);
if (EQ (window1, window2) && EQ (posn1, posn2))
event->modifiers |= click_modifier;
else if (event->modifiers & (double_modifier | triple_modifier))
return Fcons (head,
Fcons (position,
- Fcons (make_number (double_click_count),
+ Fcons (make_fixnum (double_click_count),
Qnil)));
else
return Fcons (head,
= Fcons (window,
Fcons (Qvertical_scroll_bar,
Fcons (portion_whole,
- Fcons (make_number (event->timestamp),
+ Fcons (make_fixnum (event->timestamp),
Fcons (part, Qnil)))));
/* Always treat scroll bar events as clicks. */
= Fcons (window,
Fcons (Qvertical_scroll_bar,
Fcons (portion_whole,
- Fcons (make_number (event->timestamp),
+ Fcons (make_fixnum (event->timestamp),
Fcons (part, Qnil)))));
}
struct display_pos p;
buffer_posn_from_coords (XWINDOW (window), &column, &row,
&object, &p);
- posn = make_number (CHARPOS (p.pos));
+ posn = make_fixnum (CHARPOS (p.pos));
}
}
= Fcons (window,
Fcons (posn,
Fcons (Fcons (event->x, event->y),
- Fcons (make_number (event->timestamp),
+ Fcons (make_fixnum (event->timestamp),
Qnil))));
head = modify_event_symbol (0, event->modifiers,
&mouse_wheel_syms, 1);
return Fcons (head,
Fcons (position,
- Fcons (make_number (event->code),
+ Fcons (make_fixnum (event->code),
Qnil)));
}
}
Lisp_Object object;
struct display_pos p;
buffer_posn_from_coords (w, &wx, &wy, &object, &p);
- posn = make_number (CHARPOS (p.pos));
+ posn = make_fixnum (CHARPOS (p.pos));
}
}
= Fcons (window,
Fcons (posn,
Fcons (Fcons (event->x, event->y),
- Fcons (make_number (event->timestamp),
+ Fcons (make_fixnum (event->timestamp),
Qnil))));
head = modify_event_symbol (0, event->modifiers,
(Fcons (Fcons (bar_window,
Fcons (Qvertical_scroll_bar,
Fcons (Fcons (x, y),
- Fcons (make_number (time),
+ Fcons (make_fixnum (time),
Fcons (part_sym,
Qnil))))),
Qnil)));
Lisp_Object object;
struct display_pos p;
buffer_posn_from_coords (w, &wx, &wy, &object, &p);
- posn = make_number (CHARPOS (p.pos));
+ posn = make_fixnum (CHARPOS (p.pos));
}
}
else if (frame != 0)
Fcons (Fcons (window,
Fcons (posn,
Fcons (Fcons (x, y),
- Fcons (make_number (time),
+ Fcons (make_fixnum (time),
Qnil)))),
Qnil));
}
if (SYMBOLP (base) && XSYMBOL (base)->name->size == 1)
XSETINT (base, XSYMBOL (base)->name->data[0]);
- if (INTEGERP (base))
+ if (FIXNUMP (base))
{
/* Turn (shift a) into A. */
if ((modifiers & shift_modifier) != 0
/* Turn (control a) into C-a. */
if (modifiers & ctrl_modifier)
- return make_number ((modifiers & ~ctrl_modifier)
+ return make_fixnum ((modifiers & ~ctrl_modifier)
| make_ctrl_char (XINT (base)));
else
- return make_number (modifiers | XINT (base));
+ return make_fixnum (modifiers | XINT (base));
}
else if (SYMBOLP (base))
return apply_modifiers (modifiers, base);
{
Lisp_Object elt;
elt = XCAR (tail);
- if (! (INTEGERP (elt) || SYMBOLP (elt)))
+ if (! (FIXNUMP (elt) || SYMBOLP (elt)))
return 0;
}
if (!NILP (old))
menu_bar_items_vector = old;
else
- menu_bar_items_vector = Fmake_vector (make_number (24), Qnil);
+ menu_bar_items_vector = Fmake_vector (make_fixnum (24), Qnil);
menu_bar_items_index = 0;
GCPRO1 (menu_bar_items_vector);
if (i + 4 > XVECTOR (menu_bar_items_vector)->size)
{
Lisp_Object tem;
- tem = Fmake_vector (make_number (2 * i), Qnil);
+ tem = Fmake_vector (make_fixnum (2 * i), Qnil);
bcopy (XVECTOR (menu_bar_items_vector)->contents,
XVECTOR (tem)->contents, i * sizeof (Lisp_Object));
menu_bar_items_vector = tem;
if (i + 4 > XVECTOR (menu_bar_items_vector)->size)
{
Lisp_Object tem;
- tem = Fmake_vector (make_number (2 * i), Qnil);
+ tem = Fmake_vector (make_fixnum (2 * i), Qnil);
bcopy (XVECTOR (menu_bar_items_vector)->contents,
XVECTOR (tem)->contents, i * sizeof (Lisp_Object));
menu_bar_items_vector = tem;
XVECTOR (menu_bar_items_vector)->contents[i++]
= XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
XVECTOR (menu_bar_items_vector)->contents[i++] = Fcons (item, Qnil);
- XVECTOR (menu_bar_items_vector)->contents[i++] = make_number (0);
+ XVECTOR (menu_bar_items_vector)->contents[i++] = make_fixnum (0);
menu_bar_items_index = i;
}
/* We did find an item for this KEY. Add ITEM to its list of maps. */
/* Create item_properties vector if necessary. */
if (NILP (item_properties))
item_properties
- = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE + 1), Qnil);
+ = Fmake_vector (make_fixnum (ITEM_PROPERTY_ENABLE + 1), Qnil);
/* Initialize optional entries. */
for (i = ITEM_PROPERTY_DEF; i < ITEM_PROPERTY_ENABLE; i++)
}
else
tool_bar_item_properties
- = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS), Qnil);
+ = Fmake_vector (make_fixnum (TOOL_BAR_ITEM_NSLOTS), Qnil);
/* Set defaults. */
PROP (TOOL_BAR_ITEM_KEY) = key;
if (VECTORP (reuse))
tool_bar_items_vector = reuse;
else
- tool_bar_items_vector = Fmake_vector (make_number (64), Qnil);
+ tool_bar_items_vector = Fmake_vector (make_fixnum (64), Qnil);
ntool_bar_items = 0;
}
Lisp_Object new_vector;
int old_size = XVECTOR (tool_bar_items_vector)->size;
- new_vector = Fmake_vector (make_number (2 * old_size), Qnil);
+ new_vector = Fmake_vector (make_fixnum (2 * old_size), Qnil);
bcopy (XVECTOR (tool_bar_items_vector)->contents,
XVECTOR (new_vector)->contents,
old_size * sizeof (Lisp_Object));
{
record_menu_key (XCAR (tem));
if (SYMBOLP (XCAR (tem))
- || INTEGERP (XCAR (tem)))
+ || FIXNUMP (XCAR (tem)))
XCAR (tem)
= Fcons (XCAR (tem), Qnil);
}
}
/* Ignore the element if it has no prompt string. */
- if (INTEGERP (event) && parse_menu_item (elt, 0, -1))
+ if (FIXNUMP (event) && parse_menu_item (elt, 0, -1))
{
/* 1 if the char to type matches the string. */
int char_matches;
while (BUFFERP (obj));
current_kboard->defining_kbd_macro = orig_defn_macro;
- if (!INTEGERP (obj))
+ if (!FIXNUMP (obj))
return obj;
else
ch = XINT (obj);
if (! EQ (obj, menu_prompt_more_char)
- && (!INTEGERP (menu_prompt_more_char)
- || ! EQ (obj, make_number (Ctl (XINT (menu_prompt_more_char))))))
+ && (!FIXNUMP (menu_prompt_more_char)
+ || ! EQ (obj, make_fixnum (Ctl (XINT (menu_prompt_more_char))))))
{
if (!NILP (current_kboard->defining_kbd_macro))
store_kbd_macro_char (obj);
if (!NILP (prompt))
echo_prompt (prompt);
else if (cursor_in_echo_area
- && (FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
+ && (FLOATP (Vecho_keystrokes) || FIXNUMP (Vecho_keystrokes))
&& NILP (Fzerop (Vecho_keystrokes)))
/* This doesn't put in a dash if the echo buffer is empty, so
you don't always see a dash hanging out in the minibuffer. */
{
key = keybuf[t];
add_command_key (key);
- if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
+ if ((FLOATP (Vecho_keystrokes) || FIXNUMP (Vecho_keystrokes))
&& NILP (Fzerop (Vecho_keystrokes)))
echo_char (key);
}
/* read_char returns -1 at the end of a macro.
Emacs 18 handles this by returning immediately with a
zero, so that's what we'll do. */
- if (INTEGERP (key) && XINT (key) == -1)
+ if (FIXNUMP (key) && XINT (key) == -1)
{
t = 0;
/* The Microsoft C compiler can't handle the goto that
if (CONSP (start) && CONSP (XCDR (start)))
{
pos = POSN_BUFFER_POSN (start);
- if (INTEGERP (pos)
+ if (FIXNUMP (pos)
&& XINT (pos) >= BEG && XINT (pos) <= Z)
{
map_here = get_local_map (XINT (pos),
use the corresponding lower-case letter instead. */
if (first_binding == nmaps && ! function_key_possible
&& ! key_translation_possible
- && INTEGERP (key)
+ && FIXNUMP (key)
&& ((((XINT (key) & 0x3ffff)
< XCHAR_TABLE (current_buffer->downcase_table)->size)
&& UPPERCASEP (XINT (key) & 0x3ffff))
Better ideas? */
for (; t < mock_input; t++)
{
- if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
+ if ((FLOATP (Vecho_keystrokes) || FIXNUMP (Vecho_keystrokes))
&& NILP (Fzerop (Vecho_keystrokes)))
echo_char (keybuf[t]);
add_command_key (keybuf[t]);
strcpy (buf, "- ");
else if (CONSP (prefixarg) && XINT (XCAR (prefixarg)) == 4)
strcpy (buf, "C-u ");
- else if (CONSP (prefixarg) && INTEGERP (XCAR (prefixarg)))
+ else if (CONSP (prefixarg) && FIXNUMP (XCAR (prefixarg)))
{
if (sizeof (int) == sizeof (EMACS_INT))
sprintf (buf, "%d ", XINT (XCAR (prefixarg)));
else
abort ();
}
- else if (INTEGERP (prefixarg))
+ else if (FIXNUMP (prefixarg))
{
if (sizeof (int) == sizeof (EMACS_INT))
sprintf (buf, "%d ", XINT (prefixarg));
str = XSTRING (function);
for (i = 0; i < str->size; i++)
- add_command_key (Faref (function, make_number (i)));
+ add_command_key (Faref (function, make_fixnum (i)));
- add_command_key (make_number ('\015'));
+ add_command_key (make_fixnum ('\015'));
}
UNGCPRO;
/* If the command has a key binding, print it now. */
if (!NILP (bindings)
- && ! (VECTORP (bindings) && EQ (Faref (bindings, make_number (0)),
+ && ! (VECTORP (bindings) && EQ (Faref (bindings, make_fixnum (0)),
Qmouse_movement)))
{
/* But first wait, and skip the message if there is input. */
so display our message immediately. */
delay_time = 0;
- if (!NILP (Fsit_for (make_number (delay_time), Qnil, Qnil))
+ if (!NILP (Fsit_for (make_fixnum (delay_time), Qnil, Qnil))
&& ! CONSP (Vunread_command_events))
{
Lisp_Object binding;
strlen (newmessage),
STRING_MULTIBYTE (binding));
if (!NILP (Fsit_for ((NUMBERP (Vsuggest_key_bindings)
- ? Vsuggest_key_bindings : make_number (2)),
+ ? Vsuggest_key_bindings : make_fixnum (2)),
Qnil, Qnil))
&& message_p)
restore_message ();
Lisp_Object interrupt, flow, meta, quit;
{
if (!NILP (quit)
- && (!INTEGERP (quit) || XINT (quit) < 0 || XINT (quit) > 0400))
+ && (!FIXNUMP (quit) || XINT (quit) < 0 || XINT (quit) > 0400))
error ("set-input-mode: QUIT must be an ASCII character");
#ifdef POLL_FOR_INPUT
val[0] = interrupt_input ? Qt : Qnil;
val[1] = flow_control ? Qt : Qnil;
- val[2] = meta_key == 2 ? make_number (0) : meta_key == 1 ? Qt : Qnil;
+ val[2] = meta_key == 2 ? make_fixnum (0) : meta_key == 1 ? Qt : Qnil;
XSETFASTINT (val[3], quit_char);
return Flist (sizeof (val) / sizeof (val[0]), val);
recent_keys_index = 0;
kbd_fetch_ptr = kbd_buffer;
kbd_store_ptr = kbd_buffer;
- kbd_buffer_gcpro = Fmake_vector (make_number (2 * KBD_BUFFER_SIZE), Qnil);
+ kbd_buffer_gcpro = Fmake_vector (make_fixnum (2 * KBD_BUFFER_SIZE), Qnil);
#ifdef HAVE_MOUSE
do_mouse_tracking = Qnil;
#endif
}
}
- button_down_location = Fmake_vector (make_number (1), Qnil);
+ button_down_location = Fmake_vector (make_fixnum (1), Qnil);
staticpro (&button_down_location);
- mouse_syms = Fmake_vector (make_number (1), Qnil);
+ mouse_syms = Fmake_vector (make_fixnum (1), Qnil);
staticpro (&mouse_syms);
{
int i;
int len = sizeof (modifier_names) / sizeof (modifier_names[0]);
- modifier_symbols = Fmake_vector (make_number (len), Qnil);
+ modifier_symbols = Fmake_vector (make_fixnum (len), Qnil);
for (i = 0; i < len; i++)
if (modifier_names[i])
XVECTOR (modifier_symbols)->contents[i] = intern (modifier_names[i]);
staticpro (&modifier_symbols);
}
- recent_keys = Fmake_vector (make_number (NUM_RECENT_KEYS), Qnil);
+ recent_keys = Fmake_vector (make_fixnum (NUM_RECENT_KEYS), Qnil);
staticpro (&recent_keys);
- this_command_keys = Fmake_vector (make_number (40), Qnil);
+ this_command_keys = Fmake_vector (make_fixnum (40), Qnil);
staticpro (&this_command_keys);
- raw_keybuf = Fmake_vector (make_number (30), Qnil);
+ raw_keybuf = Fmake_vector (make_fixnum (30), Qnil);
staticpro (&raw_keybuf);
Qextended_command_history = intern ("extended-command-history");
Fset (Qextended_command_history, Qnil);
staticpro (&Qextended_command_history);
- kbd_buffer_gcpro = Fmake_vector (make_number (2 * KBD_BUFFER_SIZE), Qnil);
+ kbd_buffer_gcpro = Fmake_vector (make_fixnum (2 * KBD_BUFFER_SIZE), Qnil);
staticpro (&kbd_buffer_gcpro);
accent_key_syms = Qnil;
DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes,
"*Nonzero means echo unfinished commands after this many seconds of pause.\n\
The value may be integer or floating point.");
- Vecho_keystrokes = make_number (1);
+ Vecho_keystrokes = make_fixnum (1);
DEFVAR_INT ("polling-period", &polling_period,
"*Interval between polling for input during Lisp execution.\n\
Measured in milliseconds. nil means disable double-click recognition;\n\
t means double-clicks have no time limit and are detected\n\
by position only.");
- Vdouble_click_time = make_number (500);
+ Vdouble_click_time = make_fixnum (500);
DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus,
"*Non-nil means inhibit local map menu bar menus.");
DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout,
"*How long to display an echo-area message when the minibuffer is active.\n\
If the value is not a number, such messages don't time out.");
- Vminibuffer_message_timeout = make_number (2);
+ Vminibuffer_message_timeout = make_fixnum (2);
}
void
#define EVENT_END(event) (XCAR (XCDR (XCDR (event))))
/* Extract the click count from a multi-click event. */
-#define EVENT_CLICK_COUNT(event) (Fnth ((event), make_number (2)))
+#define EVENT_CLICK_COUNT(event) (Fnth ((event), make_fixnum (2)))
/* Extract the fields of a position. */
#define POSN_WINDOW(posn) (XCAR (posn))
#define POSN_WINDOW_POSN(posn) (XCAR (XCDR (XCDR (posn))))
#define POSN_TIMESTAMP(posn) \
(XCAR (XCDR (XCDR (XCDR (posn)))))
-#define POSN_SCROLLBAR_PART(posn) (Fnth ((posn), make_number (4)))
+#define POSN_SCROLLBAR_PART(posn) (Fnth ((posn), make_fixnum (4)))
/* 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))
/* Some of the event heads. */
extern Lisp_Object Qswitch_frame;
int key;
char *defname;
{
- store_in_keymap (keymap, make_number (key), intern (defname));
+ store_in_keymap (keymap, make_fixnum (key), intern (defname));
}
void
{
Lisp_Object tail;
- tail = Fnth (make_number (4), tem);
+ tail = Fnth (make_fixnum (4), tem);
if (EQ (tail, Qkeymap))
{
if (autoload)
if (VECTORP (XCAR (list)))
for (i = 0; i < XVECTOR (XCAR (list))->size; i++)
if (CONSP (XVECTOR (XCAR (list))->contents[i]))
- fix_submap_inheritance (keymap, make_number (i),
+ fix_submap_inheritance (keymap, make_fixnum (i),
XVECTOR (XCAR (list))->contents[i]);
if (CHAR_TABLE_P (XCAR (list)))
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)));
/* Handle the special meta -> esc mapping. */
- if (INTEGERP (idx) && XUINT (idx) & meta_modifier)
+ if (FIXNUMP (idx) && XUINT (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. */
if (CONSP (meta_map))
{
map = meta_map;
- idx = make_number (XUINT (idx) & ~meta_modifier);
+ idx = make_fixnum (XUINT (idx) & ~meta_modifier);
}
else if (t_ok)
/* Set IDX to t, so that we only find a default binding. */
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)));
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);
- if (INTEGERP (c)
+ if (FIXNUMP (c)
&& (XINT (c) & meta_bit)
&& !metized)
{
}
else
{
- if (INTEGERP (c))
+ if (FIXNUMP (c))
XSETINT (c, XINT (c) & ~meta_bit);
metized = 0;
idx++;
}
- if (! INTEGERP (c) && ! SYMBOLP (c) && ! CONSP (c))
+ if (! FIXNUMP (c) && ! SYMBOLP (c) && ! CONSP (c))
error ("Key sequence contains invalid events");
if (idx == length)
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);
keymap = get_keymap (cmd, 0, 1);
if (!CONSP (keymap))
- RETURN_UNGCPRO (make_number (idx));
+ RETURN_UNGCPRO (make_fixnum (idx));
QUIT;
}
{
value = Flookup_key (current_kboard->Voverriding_terminal_local_map,
key, accept_default);
- if (! NILP (value) && !INTEGERP (value))
+ if (! NILP (value) && !FIXNUMP (value))
RETURN_UNGCPRO (value);
}
else if (!NILP (Voverriding_local_map))
{
value = Flookup_key (Voverriding_local_map, key, accept_default);
- if (! NILP (value) && !INTEGERP (value))
+ if (! NILP (value) && !FIXNUMP (value))
RETURN_UNGCPRO (value);
}
else
if (! NILP (maps[i]))
{
value = Flookup_key (maps[i], key, accept_default);
- if (! NILP (value) && !INTEGERP (value))
+ if (! NILP (value) && !FIXNUMP (value))
RETURN_UNGCPRO (value);
}
if (! NILP (local))
{
value = Flookup_key (local, key, accept_default);
- if (! NILP (value) && !INTEGERP (value))
+ if (! NILP (value) && !FIXNUMP (value))
RETURN_UNGCPRO (value);
}
if (! NILP (local))
{
value = Flookup_key (local, key, accept_default);
- if (! NILP (value) && !INTEGERP (value))
+ if (! NILP (value) && !FIXNUMP (value))
RETURN_UNGCPRO (value);
}
}
value = Flookup_key (current_global_map, key, accept_default);
UNGCPRO;
- if (! NILP (value) && !INTEGERP (value))
+ if (! NILP (value) && !FIXNUMP (value))
return value;
return Qnil;
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);
int i, i_byte, c;
Lisp_Object copy;
- copy = Fmake_vector (make_number (XSTRING (prefix)->size), Qnil);
+ copy = Fmake_vector (make_fixnum (XSTRING (prefix)->size), Qnil);
for (i = 0, i_byte = 0; i < XSTRING (prefix)->size;)
{
int i_before = i;
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;
}
return Qnil;
}
else
- maps = Fcons (Fcons (Fmake_vector (make_number (0), Qnil),
+ maps = Fcons (Fcons (Fmake_vector (make_fixnum (0), Qnil),
get_keymap (keymap, 1, 0)),
Qnil);
thisseq = Fcar (Fcar (tail));
thismap = Fcdr (Fcar (tail));
- last = make_number (XINT (Flength (thisseq)) - 1);
+ last = make_fixnum (XINT (Flength (thisseq)) - 1);
is_metized = (XINT (last) >= 0
/* Don't metize the last char of PREFIX. */
&& XINT (last) >= prefixlen
Lisp_Object indices[3];
map_char_table (accessible_keymaps_char_table, Qnil,
- elt, Fcons (Fcons (maps, make_number (is_metized)),
+ elt, Fcons (Fcons (maps, make_fixnum (is_metized)),
Fcons (tail, thisseq)),
0, indices);
}
int meta_bit = meta_modifier;
tem = Fcopy_sequence (thisseq);
- Faset (tem, last, make_number (i | meta_bit));
+ Faset (tem, last, make_fixnum (i | meta_bit));
/* This new sequence is the same length as
thisseq, so stick it in the list right
}
else
{
- tem = append_key (thisseq, make_number (i));
+ tem = append_key (thisseq, make_fixnum (i));
nconc2 (tail, Fcons (Fcons (tem, cmd), Qnil));
}
}
/* If the last key in thisseq is meta-prefix-char, and
this entry is a binding for an ascii keystroke,
turn it into a meta-ized keystroke. */
- if (is_metized && INTEGERP (elt))
+ if (is_metized && FIXNUMP (elt))
{
Lisp_Object element;
if (is_metized)
{
int meta_bit = meta_modifier;
- Lisp_Object last = make_number (XINT (Flength (thisseq)) - 1);
+ Lisp_Object last = make_fixnum (XINT (Flength (thisseq)) - 1);
tem = Fcopy_sequence (thisseq);
- Faset (tem, last, make_number (XINT (index) | meta_bit));
+ Faset (tem, last, make_fixnum (XINT (index) | meta_bit));
/* This new sequence is the same length as
thisseq, so stick it in the list right
key = EVENT_HEAD (key);
- if (INTEGERP (key)) /* Normal character */
+ if (FIXNUMP (key)) /* Normal character */
{
unsigned int charset, c1, c2;
int without_bits = XINT (key) & ~((-1) << CHARACTERBITS);
XSETFASTINT (ii, i);
elt = Faref (seq, ii);
- if (!INTEGERP (elt)
+ if (!FIXNUMP (elt)
|| (XUINT (elt) & ~CHAR_META) >= 0x80)
return 0;
}
this = Fcar (Fcar (maps));
map = Fcdr (Fcar (maps));
- last = make_number (XINT (Flength (this)) - 1);
+ last = make_fixnum (XINT (Flength (this)) - 1);
last_is_meta = (XINT (last) >= 0
&& EQ (Faref (this, last), meta_prefix_char));
/* if (nomenus && !ascii_sequence_p (this)) */
if (nomenus && XINT (last) >= 0
- && !INTEGERP (Faref (this, make_number (0))))
+ && !FIXNUMP (Faref (this, make_fixnum (0))))
/* If no menu entries should be returned, skip over the
keymaps bound to `menu-bar' and `tool-bar' and other
non-ascii prefixes like `C-down-mouse-2'. */
args = Fcons (Fcons (Fcons (definition, noindirect),
Qnil), /* Result accumulator. */
Fcons (Fcons (this, last),
- Fcons (make_number (nomenus),
- make_number (last_is_meta))));
+ Fcons (make_fixnum (nomenus),
+ make_fixnum (last_is_meta))));
map_char_table (where_is_internal_2, Qnil, elt, args,
0, indices);
sequences = XCDR (XCAR (args));
return Qnil;
/* 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 (XINT (key) | meta_modifier));
}
else
sequence = append_key (this, key);
bufend = push_key_description (translate[c], buf, 1);
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, 1);
insert (buf, bufend - buf);
prefix = Fcar (elt);
if (XVECTOR (prefix)->size >= 1)
{
- tem = Faref (prefix, make_number (0));
+ tem = Faref (prefix, make_fixnum (0));
if (EQ (tem, Qmenu_bar))
maps = Fdelq (elt, maps);
}
else
{
shmap = Flookup_key (shmap, Fcar (elt), Qt);
- if (INTEGERP (shmap))
+ if (FIXNUMP (shmap))
shmap = Qnil;
}
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))
{
register Lisp_Object tem1;
- Findent_to (make_number (16), make_number (1));
+ Findent_to (make_fixnum (16), make_fixnum (1));
if (SYMBOLP (definition))
{
/* 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;
GCPRO3 (elt_prefix, definition, kludge);
/* Ignore bindings whose "keys" 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))
describe_vector_princ (elt)
Lisp_Object elt;
{
- Findent_to (make_number (16), make_number (1));
+ Findent_to (make_fixnum (16), make_fixnum (1));
Fprinc (elt, Qnil);
Fterpri (Qnil);
}
/* 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);
GCPRO3 (elt_prefix, definition, kludge);
if (partial)
{
Lisp_Object tem;
- ASET (kludge, 0, make_number (character));
+ ASET (kludge, 0, make_fixnum (character));
tem = shadow_lookup (shadow, kludge, Qt);
if (!NILP (tem)) continue;
{
Lisp_Object tem;
- ASET (kludge, 0, make_number (character));
+ ASET (kludge, 0, make_fixnum (character));
tem = Flookup_key (entire_map, kludge, Qt);
if (! EQ (tem, definition))
else if (CHAR_TABLE_P (vector))
{
if (complete_char)
- insert1 (Fsingle_key_description (make_number (character), Qnil));
+ insert1 (Fsingle_key_description (make_fixnum (character), Qnil));
else
{
/* Print the information for this character set. */
}
else
{
- insert1 (Fsingle_key_description (make_number (character), Qnil));
+ insert1 (Fsingle_key_description (make_fixnum (character), Qnil));
}
/* If we find a sub char-table within a char-table,
{
if (char_table_depth == 0)
{
- insert1 (Fsingle_key_description (make_number (i), Qnil));
+ insert1 (Fsingle_key_description (make_fixnum (i), Qnil));
}
else if (complete_char)
{
}
else
{
- insert1 (Fsingle_key_description (make_number (i), Qnil));
+ insert1 (Fsingle_key_description (make_fixnum (i), Qnil));
}
}
/* 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
}
for (i = 0; i < len; i++)
current_kboard->kbd_macro_buffer[i]
- = Faref (current_kboard->Vlast_kbd_macro, make_number (i));
+ = Faref (current_kboard->Vlast_kbd_macro, make_fixnum (i));
current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer + len;
current_kboard->kbd_macro_end = current_kboard->kbd_macro_ptr;
/* Re-execute the macro we are appending to,
for consistency of behavior. */
Fexecute_kbd_macro (current_kboard->Vlast_kbd_macro,
- make_number (1));
+ make_fixnum (1));
message ("Appending to kbd macro...");
}
error ("Keyboard macros must be strings or vectors");
tem = Fcons (Vexecuting_macro,
- Fcons (make_number (executing_macro_index),
+ Fcons (make_fixnum (executing_macro_index),
real_this_command));
record_unwind_protect (pop_kbd_macro, tem);
{
CHECK_MARKER (marker, 0);
if (XMARKER (marker)->buffer)
- return make_number (XMARKER (marker)->charpos);
+ return make_fixnum (XMARKER (marker)->charpos);
return Qnil;
}
{
register Lisp_Object new;
- if (! (INTEGERP (marker) || MARKERP (marker)))
+ if (! (FIXNUMP (marker) || MARKERP (marker)))
marker = wrong_type_argument (Qinteger_or_marker_p, marker);
new = Fmake_marker ();
Fcons (minibuf_window, 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,
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);
- Fadd_text_properties (make_number (BEG), make_number (PT),
+ Fadd_text_properties (make_fixnum (BEG), make_fixnum (PT),
Vminibuffer_prompt_properties, Qnil);
}
if (!NILP (initial))
{
Finsert (1, &initial);
- if (INTEGERP (backup_n))
+ if (FIXNUMP (backup_n))
Fforward_char (backup_n);
}
/* Make minibuffer contents into a string. */
Fset_buffer (minibuffer);
if (allow_props)
- val = Ffield_string (make_number (ZV));
+ val = Ffield_string (make_fixnum (ZV));
else
- val = Ffield_string_no_properties (make_number (ZV));
+ val = Ffield_string_no_properties (make_fixnum (ZV));
/* VAL is the string of minibuffer text. */
/* Truncate if requested. */
length = Fget (Vminibuffer_history_variable, Qhistory_length);
if (NILP (length)) length = Vhistory_length;
- if (INTEGERP (length))
+ if (FIXNUMP (length))
{
if (XINT (length) <= 0)
Fset (Vminibuffer_history_variable, Qnil);
GCPRO1 (default_value);
val = read_minibuf (keymap, initial_contents, prompt,
- make_number (pos), !NILP (read),
+ make_fixnum (pos), !NILP (read),
histvar, histpos, default_value,
minibuffer_allow_text_properties,
!NILP (inherit_input_method));
CHECK_STRING (initial_contents, 1);
return read_minibuf (Vminibuffer_local_map, initial_contents,
prompt, Qnil, 1, Qminibuffer_history,
- make_number (0), Qnil, 0, 0);
+ make_fixnum (0), Qnil, 0, 0);
}
DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
CHECK_STRING (initial, 1);
return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
- 0, Qminibuffer_history, make_number (0), Qnil, 0,
+ 0, Qminibuffer_history, make_fixnum (0), Qnil, 0,
!NILP (inherit_input_method));
}
if (STRINGP (eltstring)
&& XSTRING (string)->size <= XSTRING (eltstring)->size
- && (tem = Fcompare_strings (eltstring, make_number (0),
- make_number (XSTRING (string)->size),
- string, make_number (0), Qnil,
+ && (tem = Fcompare_strings (eltstring, make_fixnum (0),
+ make_fixnum (XSTRING (string)->size),
+ string, make_fixnum (0), Qnil,
completion_ignore_case ?Qt : Qnil),
EQ (Qt, tem)))
{
else
{
compare = min (bestmatchsize, XSTRING (eltstring)->size);
- tem = Fcompare_strings (bestmatch, make_number (0),
- make_number (compare),
- eltstring, make_number (0),
- make_number (compare),
+ tem = Fcompare_strings (bestmatch, make_fixnum (0),
+ make_fixnum (compare),
+ eltstring, make_fixnum (0),
+ make_fixnum (compare),
completion_ignore_case ? Qt : Qnil);
if (EQ (tem, Qt))
matchsize = compare;
((matchsize == XSTRING (eltstring)->size)
==
(matchsize == XSTRING (bestmatch)->size)
- && (tem = Fcompare_strings (eltstring, make_number (0),
- make_number (XSTRING (string)->size),
- string, make_number (0),
+ && (tem = Fcompare_strings (eltstring, make_fixnum (0),
+ make_fixnum (XSTRING (string)->size),
+ string, make_fixnum (0),
Qnil,
Qnil),
EQ (Qt, tem))
- && (tem = Fcompare_strings (bestmatch, make_number (0),
- make_number (XSTRING (string)->size),
- string, make_number (0),
+ && (tem = Fcompare_strings (bestmatch, make_fixnum (0),
+ make_fixnum (XSTRING (string)->size),
+ string, make_fixnum (0),
Qnil,
Qnil),
! EQ (Qt, tem))))
/* Return t if the supplied string is an exact match (counting case);
it does not require any change to be made. */
if (matchcount == 1 && bestmatchsize == XSTRING (string)->size
- && (tem = Fcompare_strings (bestmatch, make_number (0),
- make_number (bestmatchsize),
- string, make_number (0),
- make_number (bestmatchsize),
+ && (tem = Fcompare_strings (bestmatch, make_fixnum (0),
+ make_fixnum (bestmatchsize),
+ string, make_fixnum (0),
+ make_fixnum (bestmatchsize),
Qnil),
EQ (Qt, tem)))
return Qt;
&& XSTRING (string)->data[0] == ' ')
|| XSTRING (eltstring)->data[0] != ' '
|| NILP (hide_spaces))
- && (tem = Fcompare_strings (eltstring, make_number (0),
- make_number (XSTRING (string)->size),
- string, make_number (0),
- make_number (XSTRING (string)->size),
+ && (tem = Fcompare_strings (eltstring, make_fixnum (0),
+ make_fixnum (XSTRING (string)->size),
+ string, make_fixnum (0),
+ make_fixnum (XSTRING (string)->size),
completion_ignore_case ? Qt : Qnil),
EQ (Qt, tem)))
{
val = read_minibuf (NILP (require_match)
? Vminibuffer_local_completion_map
: Vminibuffer_local_must_match_map,
- init, prompt, make_number (pos), 0,
+ init, prompt, make_fixnum (pos), 0,
histvar, histpos, def, 0,
!NILP (inherit_input_method));
Lisp_Object last;
struct gcpro gcpro1, gcpro2;
- completion = Ftry_completion (Ffield_string (make_number (ZV)),
+ completion = Ftry_completion (Ffield_string (make_fixnum (ZV)),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
last = last_exact_completion;
return 1;
}
- string = Ffield_string (make_number (ZV));
+ string = Ffield_string (make_fixnum (ZV));
/* COMPLETEDP should be true if some completion was done, which
doesn't include simply changing the case of the entered string.
if (!EQ (tem, Qt))
/* Rewrite the user's input. */
{
- Fdelete_field (make_number (ZV)); /* Some completion happened */
+ Fdelete_field (make_fixnum (ZV)); /* Some completion happened */
Finsert (1, &completion);
if (! completedp)
}
/* It did find a match. Do we match some possibility exactly now? */
- tem = test_completion (Ffield_string (make_number (ZV)));
+ tem = test_completion (Ffield_string (make_fixnum (ZV)));
if (NILP (tem))
{
/* not an exact match */
last_exact_completion = completion;
if (!NILP (last))
{
- tem = Ffield_string (make_number (ZV));
+ tem = Ffield_string (make_fixnum (ZV));
if (!NILP (Fequal (tem, last)))
Fminibuffer_completion_help ();
}
thiscar = Fcar (elt);
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,
completion_ignore_case ? Qt : Qnil);
if (EQ (tem, Qt))
return elt;
struct buffer *obuf = current_buffer;
Fset_buffer (XWINDOW (window)->buffer);
- tem = Fpos_visible_in_window_p (make_number (ZV), window, Qnil);
+ tem = Fpos_visible_in_window_p (make_fixnum (ZV), window, Qnil);
if (! NILP (tem))
/* If end is in view, scroll up to the beginning. */
- Fset_window_start (window, make_number (BEGV), Qnil);
+ Fset_window_start (window, make_fixnum (BEGV), Qnil);
else
/* Else scroll down one screen. */
Fscroll_other_window (Qnil);
case 1:
if (PT != ZV)
- Fgoto_char (make_number (ZV));
+ Fgoto_char (make_fixnum (ZV));
temp_echo_area_glyphs (" [Sole completion]");
break;
case 3:
if (PT != ZV)
- Fgoto_char (make_number (ZV));
+ Fgoto_char (make_fixnum (ZV));
temp_echo_area_glyphs (" [Complete, but not unique]");
break;
}
Lisp_Object
complete_and_exit_1 ()
{
- return make_number (do_completion ());
+ return make_fixnum (do_completion ());
}
/* This one is called by internal_condition_case if an error happens.
complete_and_exit_2 (ignore)
Lisp_Object ignore;
{
- return make_number (1);
+ return make_fixnum (1);
}
DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit,
Lisp_Object val;
/* Allow user to specify null string */
- if (XINT (Ffield_beginning (make_number (ZV), Qnil)) == ZV)
+ if (XINT (Ffield_beginning (make_fixnum (ZV), Qnil)) == ZV)
goto exit;
- if (!NILP (test_completion (Ffield_string (make_number (ZV)))))
+ if (!NILP (test_completion (Ffield_string (make_fixnum (ZV)))))
goto exit;
/* Call do_completion, but ignore errors. */
/* We keep calling Fbuffer_string rather than arrange for GC to
hold onto a pointer to one of the strings thus made. */
- completion = Ftry_completion (Ffield_string (make_number (ZV)),
+ completion = Ftry_completion (Ffield_string (make_fixnum (ZV)),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
if (NILP (completion))
return Qnil;
#if 0 /* How the below code used to look, for reference. */
- tem = Ffield_string (make_number (ZV));
+ tem = Ffield_string (make_fixnum (ZV));
b = XSTRING (tem)->data;
i = ZV - 1 - XSTRING (completion)->size;
p = XSTRING (completion)->data;
int buffer_nchars, completion_nchars;
CHECK_STRING (completion, 0);
- tem = Ffield_string (make_number (ZV));
+ tem = Ffield_string (make_fixnum (ZV));
GCPRO2 (completion, tem);
/* If reading a file name,
expand any $ENVVAR refs in the buffer and in TEM. */
if (! EQ (substituted, tem))
{
tem = substituted;
- Fdelete_field (make_number (ZV));
+ Fdelete_field (make_fixnum (ZV));
insert_from_string (tem, 0, 0, XSTRING (tem)->size,
STRING_BYTES (XSTRING (tem)), 0);
}
i = buffer_nchars - completion_nchars;
if (i > 0
||
- (tem1 = Fcompare_strings (tem, make_number (0),
- make_number (buffer_nchars),
- completion, make_number (0),
- make_number (buffer_nchars),
+ (tem1 = Fcompare_strings (tem, make_fixnum (0),
+ make_fixnum (buffer_nchars),
+ completion, make_fixnum (0),
+ make_fixnum (buffer_nchars),
completion_ignore_case ? Qt : Qnil),
! EQ (tem1, Qt)))
{
buffer_nchars -= i;
while (i > 0)
{
- tem1 = Fcompare_strings (tem, make_number (start_pos), Qnil,
- completion, make_number (0),
- make_number (buffer_nchars),
+ tem1 = Fcompare_strings (tem, make_fixnum (start_pos), Qnil,
+ completion, make_fixnum (0),
+ make_fixnum (buffer_nchars),
completion_ignore_case ? Qt : Qnil);
start_pos++;
if (EQ (tem1, Qt))
}
#endif /* Rewritten code */
- prompt_end_charpos = XINT (Ffield_beginning (make_number (ZV), Qnil));
+ prompt_end_charpos = XINT (Ffield_beginning (make_fixnum (ZV), Qnil));
{
int prompt_end_bytepos;
if (i == XSTRING (completion)->size)
{
GCPRO1 (completion);
- tem = Ftry_completion (concat2 (Ffield_string (make_number (ZV)), build_string (" ")),
+ tem = Ftry_completion (concat2 (Ffield_string (make_fixnum (ZV)), build_string (" ")),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
UNGCPRO;
{
GCPRO1 (completion);
tem =
- Ftry_completion (concat2 (Ffield_string (make_number (ZV)), build_string ("-")),
+ Ftry_completion (concat2 (Ffield_string (make_fixnum (ZV)), build_string ("-")),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
UNGCPRO;
/* Otherwise insert in minibuffer the chars we got */
- Fdelete_field (make_number (ZV));
+ Fdelete_field (make_fixnum (ZV));
insert_from_string (completion, 0, 0, i, i_byte, 1);
return Qt;
}
{
if (BUFFERP (Vstandard_output))
{
- tem = Findent_to (make_number (35), make_number (2));
+ tem = Findent_to (make_fixnum (35), make_fixnum (2));
column = XINT (tem);
}
Lisp_Object completions;
message ("Making completion list...");
- completions = Fall_completions (Ffield_string (make_number (ZV)),
+ completions = Fall_completions (Ffield_string (make_fixnum (ZV)),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate,
Qt);
"Terminate minibuffer input.")
()
{
- if (INTEGERP (last_command_char))
+ if (FIXNUMP (last_command_char))
internal_self_insert (XINT (last_command_char), 0);
else
bitch_at_user ();
"Return current depth of activations of minibuffer, a nonnegative integer.")
()
{
- return make_number (minibuf_level);
+ return make_fixnum (minibuf_level);
}
DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
insert_string (m);
SET_PT_BOTH (opoint, opoint_byte);
Vinhibit_quit = Qt;
- Fsit_for (make_number (2), Qnil, Qnil);
+ Fsit_for (make_fixnum (2), Qnil, Qnil);
del_range_both (osize, osize_byte, ZV, ZV_BYTE, 1);
SET_PT_BOTH (opoint, opoint_byte);
if (!NILP (Vquit_flag))
{
Vquit_flag = Qnil;
- Vunread_command_events = Fcons (make_number (quit_char), Qnil);
+ Vunread_command_events = Fcons (make_fixnum (quit_char), Qnil);
}
Vinhibit_quit = oinhibit;
}
()
{
if (EQ (Vmocklisp_arguments, Qinteractive))
- return make_number (0);
+ return make_fixnum (0);
return Flength (Vmocklisp_arguments);
}
{
tem = args[argnum];
retry:
- if (INTEGERP (tem))
+ if (FIXNUMP (tem))
tem = Fnumber_to_string (tem);
if (STRINGP (tem))
insert1 (tem);
*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
video_mode = XSYMBOL (Fintern_soft (build_string (video_name),
Qnil))-> value;
- if (INTEGERP (video_mode)
+ if (FIXNUMP (video_mode)
&& (video_mode_value = XINT (video_mode)) > 0)
{
regs.x.ax = video_mode_value;
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);
}
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));
/* If we're on a string with `help-echo' text property,
arrange for the help to be displayed. This is done by
setting the global variable help_echo to the help string. */
- help = Fget_text_property (make_number (glyph->charpos),
+ help = Fget_text_property (make_fixnum (glyph->charpos),
Qhelp_echo, glyph->object);
if (!NILP (help))
{
XSETINT (end, (BUF_Z (XBUFFER (w->buffer))
- XFASTINT (w->window_end_pos)));
before
- = Fprevious_single_property_change (make_number (pos + 1),
+ = Fprevious_single_property_change (make_fixnum (pos + 1),
Qmouse_face,
w->buffer, beginning);
after
&& glyph->charpos >= BEGV
&& glyph->charpos < ZV)))
{
- help = Fget_text_property (make_number (glyph->charpos),
+ help = Fget_text_property (make_fixnum (glyph->charpos),
Qhelp_echo, glyph->object);
if (!NILP (help))
{
if (EQ (b->cursor_type, Qt))
new_cursor = frame_desired_cursor;
else if (NILP (b->cursor_type)) /* nil means no cursor */
- new_cursor = Fcons (Qbar, make_number (0));
+ new_cursor = Fcons (Qbar, make_fixnum (0));
else
new_cursor = b->cursor_type;
}
}
Vwindow_system = intern ("pc");
- Vwindow_system_version = make_number (1);
+ Vwindow_system_version = make_fixnum (1);
sf->output_method = output_msdos_raw;
/* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
total_doskeys += 2;
XVECTOR (recent_doskeys)->contents[recent_doskeys_index++]
- = make_number (c);
+ = make_fixnum (c);
if (recent_doskeys_index == NUM_RECENT_DOSKEYS)
recent_doskeys_index = 0;
XVECTOR (recent_doskeys)->contents[recent_doskeys_index++]
- = make_number (sc);
+ = make_fixnum (sc);
if (recent_doskeys_index == NUM_RECENT_DOSKEYS)
recent_doskeys_index = 0;
event.kind = HELP_EVENT;
event.frame_or_window = selected_frame;
event.arg = help_echo_object;
- event.x = make_number (help_echo_pos);
+ event.x = make_fixnum (help_echo_pos);
event.timestamp = event_timestamp ();
event.code = 0;
kbd_buffer_store_event (&event);
syms_of_msdos ()
{
- 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
help_echo = Qnil;
WAITTYPE 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 (WRETCODE (w)),
+ return Fcons (Qexit, Fcons (make_fixnum (WRETCODE (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;
{
if (code == 0)
return build_string ("finished\n");
- string = Fnumber_to_string (make_number (code));
+ string = Fnumber_to_string (make_fixnum (code));
string2 = build_string (coredump ? " (core dumped)\n" : "\n");
return concat2 (build_string ("exited abnormally with code "),
concat2 (string, string2));
XPROCESS (process)->raw_status_high = Qnil;
if (NETCONN_P (process))
{
- XPROCESS (process)->status = Fcons (Qexit, Fcons (make_number (0), Qnil));
+ XPROCESS (process)->status = Fcons (Qexit, Fcons (make_fixnum (0), Qnil));
XSETINT (XPROCESS (process)->tick, ++process_tick);
}
else if (XINT (XPROCESS (process)->infd) >= 0)
Fkill_process (process, Qnil);
/* Do this now, since remove_process will make sigchld_handler do nothing. */
XPROCESS (process)->status
- = Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil));
+ = Fcons (Qsignal, Fcons (make_fixnum (SIGKILL), Qnil));
XSETINT (XPROCESS (process)->tick, ++process_tick);
status_notify ();
}
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,
continue;
Finsert (1, &p->name);
- Findent_to (make_number (13), minspace);
+ Findent_to (make_fixnum (13), minspace);
if (!NILP (p->raw_status_low))
update_status (p);
if (EQ (symbol, Qsignal) || EQ (symbol, Qexit))
remove_process (proc);
- Findent_to (make_number (22), minspace);
+ Findent_to (make_fixnum (22), minspace);
if (NILP (p->buffer))
insert_string ("(none)");
else if (NILP (XBUFFER (p->buffer)->name))
else
Finsert (1, &XBUFFER (p->buffer)->name);
- Findent_to (make_number (37), minspace);
+ Findent_to (make_fixnum (37), minspace);
if (STRINGP (p->tty_name))
Finsert (1, &p->tty_name);
else
insert_string ("(none)");
- Findent_to (make_number (49), minspace);
+ Findent_to (make_fixnum (49), minspace);
if (NETCONN_P (proc))
{
#endif /* not VMS */
XPROCESS (proc)->decoding_buf = make_uninit_string (0);
- XPROCESS (proc)->decoding_carryover = make_number (0);
+ XPROCESS (proc)->decoding_carryover = make_fixnum (0);
XPROCESS (proc)->encoding_buf = make_uninit_string (0);
- XPROCESS (proc)->encoding_carryover = make_number (0);
+ XPROCESS (proc)->encoding_carryover = make_fixnum (0);
XPROCESS (proc)->inherit_coding_system_flag
= (NILP (buffer) || !inherit_process_coding_system
#ifdef HAVE_GETADDRINFO
/* SERVICE can either be a string or int.
Convert to a C string for later use by getaddrinfo. */
- if (INTEGERP (service))
+ if (FIXNUMP (service))
{
sprintf (portbuf, "%ld", (long) XINT (service));
portstring = portbuf;
portstring = XSTRING (service)->data;
}
#else /* HAVE_GETADDRINFO */
- if (INTEGERP (service))
+ if (FIXNUMP (service))
port = htons ((unsigned short) XINT (service));
else
{
/* Make us close S if quit. */
count1 = specpdl_ptr - specpdl;
- record_unwind_protect (close_file_unwind, make_number (s));
+ record_unwind_protect (close_file_unwind, make_fixnum (s));
loop:
/* A delay here is needed on some FreeBSD systems,
and it is harmless, since this retrying takes time anyway
and should be infrequent. */
- Fsleep_for (make_number (1), Qnil);
+ Fsleep_for (make_fixnum (1), Qnil);
retry++;
goto loop;
}
#endif
#endif
break;
- Fsleep_for (make_number (1), Qnil);
+ Fsleep_for (make_fixnum (1), Qnil);
}
if (host_info_ptr == 0)
report_file_error ("error creating socket", Fcons (name, Qnil));
count1 = specpdl_ptr - specpdl;
- record_unwind_protect (close_file_unwind, make_number (s));
+ record_unwind_protect (close_file_unwind, make_fixnum (s));
/* Kernel bugs (on Ultrix at least) cause lossage (not just EINTR)
when connect is interrupted. So let's not let it get interrupted.
/* A delay here is needed on some FreeBSD systems,
and it is harmless, since this retrying takes time anyway
and should be infrequent. */
- Fsleep_for (make_number (1), Qnil);
+ Fsleep_for (make_fixnum (1), Qnil);
retry++;
goto loop;
}
proc_encode_coding_system[outch]);
XPROCESS (proc)->decoding_buf = make_uninit_string (0);
- XPROCESS (proc)->decoding_carryover = make_number (0);
+ XPROCESS (proc)->decoding_carryover = make_fixnum (0);
XPROCESS (proc)->encoding_buf = make_uninit_string (0);
- XPROCESS (proc)->encoding_carryover = make_number (0);
+ XPROCESS (proc)->encoding_carryover = make_fixnum (0);
XPROCESS (proc)->inherit_coding_system_flag
= (NILP (buffer) || !inherit_process_coding_system
{
CHECK_NUMBER (timeout_msecs, 2);
useconds = XINT (timeout_msecs);
- if (!INTEGERP (timeout))
+ if (!FIXNUMP (timeout))
XSETINT (timeout, 0);
{
update_status (XPROCESS (proc));
if (EQ (XPROCESS (proc)->status, Qrun))
XPROCESS (proc)->status
- = Fcons (Qexit, Fcons (make_number (256), Qnil));
+ = Fcons (Qexit, Fcons (make_fixnum (256), Qnil));
}
}
} /* end for each file descriptor */
cmd_error_internal (error, "error in process filter: ");
Vinhibit_quit = Qt;
update_echo_area ();
- Fsleep_for (make_number (2), Qnil);
+ Fsleep_for (make_fixnum (2), Qnil);
return Qt;
}
/* 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));
/* Handling the process output should not deactivate the mark. */
Vdeactivate_mark = odeactivate;
#endif
XPROCESS (proc)->raw_status_low = Qnil;
XPROCESS (proc)->raw_status_high = Qnil;
- XPROCESS (proc)->status = Fcons (Qexit, Fcons (make_number (256), Qnil));
+ XPROCESS (proc)->status = Fcons (Qexit, Fcons (make_fixnum (256), Qnil));
XSETINT (XPROCESS (proc)->tick, ++process_tick);
deactivate_process (proc);
#ifdef VMS
else if (!strcmp (name, NAME)) \
XSETINT (sigcode, VALUE)
- if (INTEGERP (sigcode))
+ if (FIXNUMP (sigcode))
;
else
{
#undef handle_signal
- return make_number (kill (XINT (pid), XINT (sigcode)));
+ return make_fixnum (kill (XINT (pid), XINT (sigcode)));
}
DEFUN ("process-send-eof", Fprocess_send_eof, Sprocess_send_eof, 0, 1, 0,
{
proc = XCDR (XCAR (tail));
p = XPROCESS (proc);
- if (INTEGERP (p->pid) && XINT (p->pid) == -1)
+ if (FIXNUMP (p->pid) && XINT (p->pid) == -1)
break;
p = 0;
}
cmd_error_internal (error, "error in process sentinel: ");
Vinhibit_quit = Qt;
update_echo_area ();
- Fsleep_for (make_number (2), Qnil);
+ Fsleep_for (make_fixnum (2), Qnil);
return Qt;
}
}
cp->regexp = Qnil;
- cp->buf.translate = (! NILP (translate) ? translate : make_number (0));
+ cp->buf.translate = (! NILP (translate) ? translate : make_fixnum (0));
cp->posix = posix;
cp->buf.multibyte = multibyte;
BLOCK_INPUT;
if (XSTRING (cp->regexp)->size == XSTRING (pattern)->size
&& STRING_MULTIBYTE (cp->regexp) == STRING_MULTIBYTE (pattern)
&& !NILP (Fstring_equal (cp->regexp, pattern))
- && EQ (cp->buf.translate, (! NILP (translate) ? translate : make_number (0)))
+ && EQ (cp->buf.translate, (! NILP (translate) ? translate : make_fixnum (0)))
&& cp->posix == posix
&& cp->buf.multibyte == multibyte)
break;
= 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,
/* If we are not in selective display mode,
check only for newlines. */
int selective_display = (!NILP (current_buffer->selective_display)
- && !INTEGERP (current_buffer->selective_display));
+ && !FIXNUMP (current_buffer->selective_display));
/* The code that follows is like scan_buffer
but checks for either newline or carriage return. */
SET_PT (np);
- return make_number (np);
+ return make_fixnum (np);
}
\f
/* Return 1 if REGEXP it matches just one constant string. */
if (! NILP (trt)) \
{ \
Lisp_Object temp; \
- temp = Faref (trt, make_number (d)); \
- if (INTEGERP (temp)) \
+ temp = Faref (trt, make_fixnum (d)); \
+ if (FIXNUMP (temp)) \
out = XINT (temp); \
else \
out = d; \
CHECK_NUMBER (subexp, 3);
sub = XINT (subexp);
if (sub < 0 || sub >= search_regs.num_regs)
- args_out_of_range (subexp, make_number (search_regs.num_regs));
+ args_out_of_range (subexp, make_fixnum (search_regs.num_regs));
}
if (NILP (string))
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] > XSTRING (string)->size)
- 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))
{
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. */
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;
}
rev_tbl= (!buf_multibyte && CHAR_TABLE_P (Vnonascii_translation_table)
? Fchar_table_extra_slot (Vnonascii_translation_table,
- make_number (0))
+ make_fixnum (0))
: Qnil);
substed_alloc_size = length * 2 + 100;
del_range (search_regs.start[sub] + inslen, search_regs.end[sub] + inslen);
if (case_action == all_caps)
- Fupcase_region (make_number (PT - inslen), make_number (PT));
+ Fupcase_region (make_fixnum (PT - inslen), make_fixnum (PT));
else if (case_action == cap_initial)
- Fupcase_initials_region (make_number (PT - inslen), make_number (PT));
+ Fupcase_initials_region (make_fixnum (PT - inslen), make_fixnum (PT));
newpoint = PT;
CHECK_NUMBER (num, 0);
n = XINT (num);
if (n < 0 || n >= search_regs.num_regs)
- args_out_of_range (num, make_number (search_regs.num_regs));
+ args_out_of_range (num, make_fixnum (search_regs.num_regs));
if (search_regs.num_regs <= 0
|| 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]));
}
{
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
/* 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]))
{
if (XINT (attrs[SOUND_VOLUME]) < 0
|| XINT (attrs[SOUND_VOLUME]) > 100)
strcpy (sd.file, XSTRING (attrs[SOUND_DEVICE])->data);
}
- if (INTEGERP (attrs[SOUND_VOLUME]))
+ if (FIXNUMP (attrs[SOUND_VOLUME]))
sd.volume = XFASTINT (attrs[SOUND_VOLUME]);
else if (FLOATP (attrs[SOUND_VOLUME]))
sd.volume = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
#endif
}
}
- return(make_number(win_fd));
+ return(make_fixnum(win_fd));
}
\f
/*
gl_state.use_global = 0;
CHECK_NUMBER (character, 0);
char_int = XINT (character);
- return make_number (syntax_code_spec[(int) SYNTAX (char_int)]);
+ return make_fixnum (syntax_code_spec[(int) SYNTAX (char_int)]);
}
DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 1, 0,
return XVECTOR (Vsyntax_code_object)->contents[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);
}
/* This comment supplies the doc string for modify-syntax-entry,
char str[2];
Lisp_Object first, match_lisp;
- Findent_to (make_number (16), make_number (1));
+ Findent_to (make_fixnum (16), make_fixnum (1));
if (NILP (value))
{
first = XCAR (value);
match_lisp = XCDR (value);
- if (!INTEGERP (first) || !(NILP (match_lisp) || INTEGERP (match_lisp)))
+ if (!FIXNUMP (first) || !(NILP (match_lisp) || FIXNUMP (match_lisp)))
{
insert_string ("invalid\n");
return;
val = XINT (count) > 0 ? ZV : BEGV;
/* Avoid jumping out of an input field. */
- val = XFASTINT (Fconstrain_to_field (make_number (val), make_number (PT),
+ val = XFASTINT (Fconstrain_to_field (make_fixnum (val), make_fixnum (PT),
Qt, Qnil, Qnil));
SET_PT (val);
SET_PT_BOTH (pos, pos_byte);
immediate_quit = 0;
- return make_number (PT - start_point);
+ return make_fixnum (PT - start_point);
}
}
\f
if (depth < min_depth)
Fsignal (Qscan_error,
Fcons (build_string ("Containing expression ends prematurely"),
- Fcons (make_number (last_good),
- Fcons (make_number (from), Qnil))));
+ Fcons (make_fixnum (last_good),
+ Fcons (make_fixnum (from), Qnil))));
break;
case Sstring:
if (depth < min_depth)
Fsignal (Qscan_error,
Fcons (build_string ("Containing expression ends prematurely"),
- Fcons (make_number (last_good),
- Fcons (make_number (from), Qnil))));
+ Fcons (make_fixnum (last_good),
+ Fcons (make_fixnum (from), Qnil))));
break;
case Sendcomment:
lose:
Fsignal (Qscan_error,
Fcons (build_string ("Unbalanced parentheses"),
- Fcons (make_number (last_good),
- Fcons (make_number (from), Qnil))));
+ Fcons (make_fixnum (last_good),
+ Fcons (make_fixnum (from), Qnil))));
/* NOTREACHED */
}
tem = Fcar (oldstate);
/* Check whether we are inside string_fence-style string: */
state.instring = (!NILP (tem)
- ? (INTEGERP (tem) ? XINT (tem) : ST_STRING_STYLE)
+ ? (FIXNUMP (tem) ? XINT (tem) : ST_STRING_STYLE)
: -1);
oldstate = Fcdr (oldstate);
tem = Fcar (oldstate);
state.incomment = (!NILP (tem)
- ? (INTEGERP (tem) ? XINT (tem) : -1)
+ ? (FIXNUMP (tem) ? XINT (tem) : -1)
: 0);
oldstate = Fcdr (oldstate);
state.location = from;
state.levelstarts = Qnil;
while (--curlevel >= levelstart)
- state.levelstarts = Fcons (make_number (curlevel->last),
+ state.levelstarts = Fcons (make_fixnum (curlevel->last),
state.levelstarts);
immediate_quit = 0;
SET_PT (state.location);
- return Fcons (make_number (state.depth),
- Fcons (state.prevlevelstart < 0 ? Qnil : make_number (state.prevlevelstart),
- Fcons (state.thislevelstart < 0 ? Qnil : make_number (state.thislevelstart),
+ return Fcons (make_fixnum (state.depth),
+ Fcons (state.prevlevelstart < 0 ? Qnil : make_fixnum (state.prevlevelstart),
+ Fcons (state.thislevelstart < 0 ? 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 : Qt) :
Qnil),
Fcons (((state.incomment
|| (state.instring >= 0))
- ? make_number (state.comstr_start)
+ ? make_fixnum (state.comstr_start)
: Qnil),
Fcons (state.levelstarts, Qnil))))))))));
}
Qchar_table_extra_slots = intern ("char-table-extra-slots");
/* Create objects which can be shared among syntax tables. */
- Vsyntax_code_object = Fmake_vector (make_number (Smax), Qnil);
+ Vsyntax_code_object = Fmake_vector (make_fixnum (Smax), Qnil);
for (i = 0; i < XVECTOR (Vsyntax_code_object)->size; i++)
XVECTOR (Vsyntax_code_object)->contents[i]
- = Fcons (make_number (i), Qnil);
+ = 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 = XVECTOR (Vsyntax_code_object)->contents[(int) Swhitespace];
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 ((int) Sstring), Qnil));
+ Fcons (make_fixnum ((int) Sstring), Qnil));
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '\\',
- Fcons (make_number ((int) Sescape), Qnil));
+ Fcons (make_fixnum ((int) Sescape), Qnil));
temp = XVECTOR (Vsyntax_code_object)->contents[(int) Ssymbol];
for (i = 0; i < 10; i++)
#define SET_RAW_SYNTAX_ENTRY(table, c, val) \
((c) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
? (XCHAR_TABLE (table)->contents[(unsigned char) (c)] = (val)) \
- : Faset ((table), make_number (c), (val)))
+ : Faset ((table), make_fixnum (c), (val)))
/* Fetch the syntax entry for char C in syntax table TABLE.
This macro is called only when C is less than CHAR_TABLE_ORDINARY_SLOTS.
? SYNTAX_ENTRY_FOLLOW_PARENT (CURRENT_SYNTAX_TABLE, \
(unsigned char) (c)) \
: Faref (CURRENT_SYNTAX_TABLE, \
- make_number (c)))
+ make_fixnum (c)))
/* Extract the information from the entry for character C
in the current syntax table. */
break;
if (count >= 5)
break;
- Fsleep_for (make_number (1), Qnil);
+ Fsleep_for (make_fixnum (1), Qnil);
}
if (hp)
{
char *sequence = tgetstr (keys[i].cap, address);
if (sequence)
Fdefine_key (Vfunction_key_map, build_string (sequence),
- Fmake_vector (make_number (1),
+ Fmake_vector (make_fixnum (1),
intern (keys[i].name)));
}
if (k_semi)
{
Fdefine_key (Vfunction_key_map, build_string (k_semi),
- Fmake_vector (make_number (1), intern ("f10")));
+ Fmake_vector (make_fixnum (1), intern ("f10")));
k0_name = "f0";
}
if (k0)
Fdefine_key (Vfunction_key_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. */
{
sprintf (fkey, "f%d", i);
Fdefine_key (Vfunction_key_map, build_string (sequence),
- Fmake_vector (make_number (1),
+ Fmake_vector (make_fixnum (1),
intern (fkey)));
}
}
char *sequence = tgetstr (cap2, address); \
if (sequence) \
Fdefine_key (Vfunction_key_map, build_string (sequence), \
- Fmake_vector (make_number (1), \
+ Fmake_vector (make_fixnum (1), \
intern (sym))); \
}
temp_it.dp = NULL;
temp_it.what = IT_CHARACTER;
temp_it.len = 1;
- temp_it.object = make_number (0);
+ temp_it.object = make_fixnum (0);
bzero (&temp_it.current, sizeof temp_it.current);
if (what == IT_CONTINUATION)
{
/* Continuation glyph. */
if (it->dp
- && INTEGERP (DISP_CONTINUE_GLYPH (it->dp))
+ && FIXNUMP (DISP_CONTINUE_GLYPH (it->dp))
&& GLYPH_CHAR_VALID_P (XINT (DISP_CONTINUE_GLYPH (it->dp))))
{
temp_it.c = FAST_GLYPH_CHAR (XINT (DISP_CONTINUE_GLYPH (it->dp)));
{
/* Truncation glyph. */
if (it->dp
- && INTEGERP (DISP_TRUNC_GLYPH (it->dp))
+ && FIXNUMP (DISP_TRUNC_GLYPH (it->dp))
&& GLYPH_CHAR_VALID_P (XINT (DISP_TRUNC_GLYPH (it->dp))))
{
temp_it.c = FAST_GLYPH_CHAR (XINT (DISP_TRUNC_GLYPH (it->dp)));
}
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 || NULL_INTERVAL_P (i))
return NULL_INTERVAL;
if (NILP (position))
{
if (NILP (limit))
- position = make_number (XSTRING (object)->size);
+ position = make_fixnum (XSTRING (object)->size);
else
position = limit;
}
if (NILP (position))
{
if (NILP (limit))
- position = make_number (XSTRING (object)->size);
+ position = make_fixnum (XSTRING (object)->size);
else
position = limit;
}
else
{
Lisp_Object initial_value =
- Fget_char_property (make_number (XFASTINT (position) - 1),
+ Fget_char_property (make_fixnum (XFASTINT (position) - 1),
prop, object);
for (;;)
else
{
Lisp_Object value =
- Fget_char_property (make_number (XFASTINT (position) - 1),
+ Fget_char_property (make_fixnum (XFASTINT (position) - 1),
prop, object);
if (!EQ (value, initial_value))
if (! NILP (limit) && !(next->position < XFASTINT (limit)))
return limit;
- return make_number (next->position);
+ return make_fixnum (next->position);
}
DEFUN ("previous-property-change", Fprevious_property_change,
&& !(previous->position + LENGTH (previous) > XFASTINT (limit)))
return limit;
- return make_number (previous->position + LENGTH (previous));
+ return make_fixnum (previous->position + LENGTH (previous));
}
DEFUN ("previous-single-property-change", Fprevious_single_property_change,
&& !(previous->position + LENGTH (previous) > XFASTINT (limit)))
return limit;
- return make_number (previous->position + LENGTH (previous));
+ return make_fixnum (previous->position + LENGTH (previous));
}
\f
/* Callers note, this can GC when OBJECT is a buffer (or nil). */
pos = i->position;
if (pos < XINT (start))
pos = XINT (start);
- return make_number (pos);
+ return make_fixnum (pos);
}
i = next_interval (i);
}
{
if (i->position > s)
s = i->position;
- return make_number (s);
+ return make_fixnum (s);
}
i = next_interval (i);
}
{
/* Must defer modifications to the interval tree in case src
and dest refer to the same string or buffer. */
- stuff = Fcons (Fcons (make_number (p),
- Fcons (make_number (p + len),
+ stuff = Fcons (Fcons (make_fixnum (p),
+ Fcons (make_fixnum (p + len),
Fcons (plist, Qnil))),
stuff);
}
}
if (!NILP (plist))
- result = Fcons (Fcons (make_number (s),
- Fcons (make_number (s + len),
+ result = Fcons (Fcons (make_fixnum (s),
+ Fcons (make_fixnum (s + len),
Fcons (plist, Qnil))),
result);
Lisp_Object item, start, end, plist, tem;
item = XCAR (list);
- start = make_number (XINT (XCAR (item)) + XINT (delta));
- end = make_number (XINT (XCAR (XCDR (item))) + XINT (delta));
+ start = make_fixnum (XINT (XCAR (item)) + XINT (delta));
+ end = make_fixnum (XINT (XCAR (XCDR (item))) + XINT (delta));
plist = XCAR (XCDR (XCDR (item)));
tem = Fadd_text_properties (start, end, plist, object);
hooks = Fnreverse (hooks);
while (! EQ (hooks, Qnil))
{
- 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);
}
UNGCPRO;
Lisp_Object elt;
elt = XCAR (current_buffer->undo_list);
if (CONSP (elt)
- && INTEGERP (XCAR (elt))
- && INTEGERP (XCDR (elt))
+ && FIXNUMP (XCAR (elt))
+ && FIXNUMP (XCDR (elt))
&& XINT (XCDR (elt)) == beg)
{
XSETINT (XCDR (elt), beg + length);
&& BUFFERP (last_point_position_buffer)
&& current_buffer == XBUFFER (last_point_position_buffer))
current_buffer->undo_list
- = Fcons (make_number (last_point_position), current_buffer->undo_list);
+ = Fcons (make_fixnum (last_point_position), current_buffer->undo_list);
current_buffer->undo_list
= Fcons (Fcons (string, sbeg), current_buffer->undo_list);
XSETBUFFER (last_undo_buffer, current_buffer);
current_buffer->undo_list
- = Fcons (Fcons (marker, make_number (adjustment)),
+ = Fcons (Fcons (marker, make_fixnum (adjustment)),
current_buffer->undo_list);
}
if (NILP (next))
break;
/* Handle an integer by setting point to that value. */
- if (INTEGERP (next))
+ if (FIXNUMP (next))
SET_PT (clip_to_bounds (BEGV, XINT (next), ZV));
else if (CONSP (next))
{
Fput_text_property (beg, end, prop, val, Qnil);
}
- else if (INTEGERP (car) && INTEGERP (cdr))
+ else if (FIXNUMP (car) && FIXNUMP (cdr))
{
/* Element (BEG . END) means range was inserted. */
Fgoto_char (car);
Fdelete_region (car, cdr);
}
- else if (STRINGP (car) && INTEGERP (cdr))
+ else if (STRINGP (car) && FIXNUMP (cdr))
{
/* Element (STRING . POS) means STRING was deleted. */
Lisp_Object membuf;
SET_PT (pos);
}
}
- else if (MARKERP (car) && INTEGERP (cdr))
+ else if (MARKERP (car) && FIXNUMP (cdr))
{
/* (MARKER . INTEGER) means a marker MARKER
was adjusted by INTEGER. */
if (XMARKER (car)->buffer)
Fset_marker (car,
- make_number (marker_position (car) - XINT (cdr)),
+ make_fixnum (marker_position (car) - XINT (cdr)),
Fmarker_buffer (car));
}
}
/* 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
for (i = 0; i < sizeof (x_frame_parms) / sizeof (x_frame_parms[0]); i++)
Fput (intern (x_frame_parms[i].name), Qx_frame_parameter,
- make_number (i));
+ make_fixnum (i));
}
\f
/* Change the parameters of frame F as specified by ALIST.
{
left_no_change = 1;
if (f->output_data.w32->left_pos < 0)
- left = Fcons (Qplus, Fcons (make_number (f->output_data.w32->left_pos), Qnil));
+ left = Fcons (Qplus, Fcons (make_fixnum (f->output_data.w32->left_pos), Qnil));
else
XSETINT (left, f->output_data.w32->left_pos);
}
{
top_no_change = 1;
if (f->output_data.w32->top_pos < 0)
- top = Fcons (Qplus, Fcons (make_number (f->output_data.w32->top_pos), Qnil));
+ top = Fcons (Qplus, Fcons (make_fixnum (f->output_data.w32->top_pos), Qnil));
else
XSETINT (top, f->output_data.w32->top_pos);
}
/* If one of the icon positions was not set, preserve or default it. */
- if (EQ (icon_left, Qunbound) || ! INTEGERP (icon_left))
+ if (EQ (icon_left, Qunbound) || ! FIXNUMP (icon_left))
{
icon_left_no_change = 1;
icon_left = Fcdr (Fassq (Qicon_left, f->param_alist));
if (NILP (icon_left))
XSETINT (icon_left, 0);
}
- if (EQ (icon_top, Qunbound) || ! INTEGERP (icon_top))
+ if (EQ (icon_top, Qunbound) || ! FIXNUMP (icon_top))
{
icon_top_no_change = 1;
icon_top = Fcdr (Fassq (Qicon_top, f->param_alist));
if (width != FRAME_WIDTH (f)
|| height != FRAME_HEIGHT (f)
|| FRAME_NEW_HEIGHT (f) || FRAME_NEW_WIDTH (f))
- Fset_frame_size (frame, make_number (width), make_number (height));
+ Fset_frame_size (frame, make_fixnum (width), make_fixnum (height));
if ((!NILP (left) || !NILP (top))
&& ! (left_no_change && top_no_change)
f->output_data.w32->size_hint_flags &= ~ (XNegative | YNegative);
if (EQ (left, Qminus))
f->output_data.w32->size_hint_flags |= XNegative;
- else if (INTEGERP (left))
+ else if (FIXNUMP (left))
{
leftpos = XINT (left);
if (leftpos < 0)
}
else if (CONSP (left) && EQ (XCAR (left), Qminus)
&& CONSP (XCDR (left))
- && INTEGERP (XCAR (XCDR (left))))
+ && FIXNUMP (XCAR (XCDR (left))))
{
leftpos = - XINT (XCAR (XCDR (left)));
f->output_data.w32->size_hint_flags |= XNegative;
}
else if (CONSP (left) && EQ (XCAR (left), Qplus)
&& CONSP (XCDR (left))
- && INTEGERP (XCAR (XCDR (left))))
+ && FIXNUMP (XCAR (XCDR (left))))
{
leftpos = XINT (XCAR (XCDR (left)));
}
if (EQ (top, Qminus))
f->output_data.w32->size_hint_flags |= YNegative;
- else if (INTEGERP (top))
+ else if (FIXNUMP (top))
{
toppos = XINT (top);
if (toppos < 0)
}
else if (CONSP (top) && EQ (XCAR (top), Qminus)
&& CONSP (XCDR (top))
- && INTEGERP (XCAR (XCDR (top))))
+ && FIXNUMP (XCAR (XCDR (top))))
{
toppos = - XINT (XCAR (XCDR (top)));
f->output_data.w32->size_hint_flags |= YNegative;
}
else if (CONSP (top) && EQ (XCAR (top), Qplus)
&& CONSP (XCDR (top))
- && INTEGERP (XCAR (XCDR (top))))
+ && FIXNUMP (XCAR (XCDR (top))))
{
toppos = XINT (XCAR (XCDR (top)));
}
store_in_alist (alistptr, Qtop, Fcons (Qplus, Fcons (tem, Qnil)));
store_in_alist (alistptr, Qborder_width,
- make_number (f->output_data.w32->border_width));
+ make_fixnum (f->output_data.w32->border_width));
store_in_alist (alistptr, Qinternal_border_width,
- make_number (f->output_data.w32->internal_border_width));
+ make_fixnum (f->output_data.w32->internal_border_width));
sprintf (buf, "%ld", (long) FRAME_W32_WINDOW (f));
store_in_alist (alistptr, Qwindow_id,
build_string (buf));
if (name[num] == '\n')
name[num] = 0;
cmap = Fcons (Fcons (build_string (name),
- make_number (RGB (red, green, blue))),
+ make_fixnum (RGB (red, green, blue))),
cmap);
}
}
for (i = 0; i < sizeof (w32_color_map) / sizeof (w32_color_map[0]);
pc++, i++)
cmap = Fcons (Fcons (build_string (pc->name),
- make_number (pc->colorref)),
+ make_fixnum (pc->colorref)),
cmap);
UNBLOCK_INPUT;
}
else if (CONSP (arg)
&& EQ (XCAR (arg), Qbar)
- && INTEGERP (XCDR (arg))
+ && FIXNUMP (XCDR (arg))
&& XINT (XCDR (arg)) >= 0)
{
type = BAR_CURSOR;
XSETFASTINT (w->top, XFASTINT (w->top) + n);
XSETFASTINT (w->height, XFASTINT (w->height) - n);
- if (INTEGERP (w->orig_top))
+ if (FIXNUMP (w->orig_top))
XSETFASTINT (w->orig_top, XFASTINT (w->orig_top) + n);
- if (INTEGERP (w->orig_height))
+ if (FIXNUMP (w->orig_height))
XSETFASTINT (w->orig_height, XFASTINT (w->orig_height) - n);
/* Handle just the top child in a vertical split. */
if (FRAME_MINIBUF_ONLY_P (f))
return;
- if (INTEGERP (value))
+ if (FIXNUMP (value))
nlines = XINT (value);
else
nlines = 0;
return;
/* Use VALUE only if an integer >= 0. */
- if (INTEGERP (value) && XINT (value) >= 0)
+ if (FIXNUMP (value) && XINT (value) >= 0)
nlines = XFASTINT (value);
else
nlines = 0;
x_set_window_size (f, 0, FRAME_WIDTH (f), FRAME_HEIGHT (f));
do_pending_window_change (0);
}
- else if (INTEGERP (arg) && XINT (arg) > 0
+ else if (FIXNUMP (arg) && XINT (arg) > 0
&& XFASTINT (arg) != FRAME_SCROLL_BAR_PIXEL_WIDTH (f))
{
FRAME_SCROLL_BAR_PIXEL_WIDTH (f) = XFASTINT (arg);
switch (type)
{
case RES_TYPE_NUMBER:
- return make_number (atoi (XSTRING (tem)->data));
+ return make_fixnum (atoi (XSTRING (tem)->data));
case RES_TYPE_FLOAT:
return make_float (atof (XSTRING (tem)->data));
Lisp_Object element;
if (x >= 0 && (geometry & XNegative))
- element = Fcons (Qleft, Fcons (Qminus, Fcons (make_number (-x), Qnil)));
+ element = Fcons (Qleft, Fcons (Qminus, Fcons (make_fixnum (-x), Qnil)));
else if (x < 0 && ! (geometry & XNegative))
- element = Fcons (Qleft, Fcons (Qplus, Fcons (make_number (x), Qnil)));
+ element = Fcons (Qleft, Fcons (Qplus, Fcons (make_fixnum (x), Qnil)));
else
- element = Fcons (Qleft, make_number (x));
+ element = Fcons (Qleft, make_fixnum (x));
result = Fcons (element, result);
}
Lisp_Object element;
if (y >= 0 && (geometry & YNegative))
- element = Fcons (Qtop, Fcons (Qminus, Fcons (make_number (-y), Qnil)));
+ element = Fcons (Qtop, Fcons (Qminus, Fcons (make_fixnum (-y), Qnil)));
else if (y < 0 && ! (geometry & YNegative))
- element = Fcons (Qtop, Fcons (Qplus, Fcons (make_number (y), Qnil)));
+ element = Fcons (Qtop, Fcons (Qplus, Fcons (make_fixnum (y), Qnil)));
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;
}
}
else if (CONSP (tem0) && EQ (XCAR (tem0), Qminus)
&& CONSP (XCDR (tem0))
- && INTEGERP (XCAR (XCDR (tem0))))
+ && FIXNUMP (XCAR (XCDR (tem0))))
{
f->output_data.w32->top_pos = - XINT (XCAR (XCDR (tem0)));
window_prompting |= YNegative;
}
else if (CONSP (tem0) && EQ (XCAR (tem0), Qplus)
&& CONSP (XCDR (tem0))
- && INTEGERP (XCAR (XCDR (tem0))))
+ && FIXNUMP (XCAR (XCDR (tem0))))
{
f->output_data.w32->top_pos = XINT (XCAR (XCDR (tem0)));
}
}
else if (CONSP (tem1) && EQ (XCAR (tem1), Qminus)
&& CONSP (XCDR (tem1))
- && INTEGERP (XCAR (XCDR (tem1))))
+ && FIXNUMP (XCAR (XCDR (tem1))))
{
f->output_data.w32->left_pos = - XINT (XCAR (XCDR (tem1)));
window_prompting |= XNegative;
}
else if (CONSP (tem1) && EQ (XCAR (tem1), Qplus)
&& CONSP (XCDR (tem1))
- && INTEGERP (XCAR (XCDR (tem1))))
+ && FIXNUMP (XCAR (XCDR (tem1))))
{
f->output_data.w32->left_pos = XINT (XCAR (XCDR (tem1)));
}
key code and modifier combination to capture. */
Lisp_Object w32_grabbed_keys;
-#define HOTKEY(vk,mods) make_number (((vk) & 255) | ((mods) << 8))
+#define HOTKEY(vk,mods) make_fixnum (((vk) & 255) | ((mods) << 8))
#define HOTKEY_ID(k) (XFASTINT (k) & 0xbfff)
#define HOTKEY_VK_CODE(k) (XFASTINT (k) & 255)
#define HOTKEY_MODIFIERS(k) (XFASTINT (k) >> 8)
Lisp_Object key = XCAR (keylist);
/* Deleted entries get set to nil. */
- if (!INTEGERP (key))
+ if (!FIXNUMP (key))
continue;
RegisterHotKey (hwnd, HOTKEY_ID (key),
{
Lisp_Object key = XCAR (keylist);
- if (!INTEGERP (key))
+ if (!FIXNUMP (key))
continue;
UnregisterHotKey (hwnd, HOTKEY_ID (key));
"font", "Font", RES_TYPE_STRING);
}
- x_default_parameter (f, parms, Qborder_width, make_number (2),
+ x_default_parameter (f, parms, Qborder_width, make_fixnum (2),
"borderWidth", "BorderWidth", RES_TYPE_NUMBER);
/* This defaults to 2 in order to match xterm. We recognize either
internalBorderWidth or internalBorder (which is what xterm calls
parms);
}
/* Default internalBorderWidth to 0 on Windows to match other programs. */
- x_default_parameter (f, parms, Qinternal_border_width, make_number (0),
+ x_default_parameter (f, parms, Qinternal_border_width, make_fixnum (0),
"internalBorderWidth", "InternalBorder", RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qvertical_scroll_bars, Qright,
"verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL);
happen. */
init_frame_faces (f);
- x_default_parameter (f, parms, Qmenu_bar_lines, make_number (1),
+ x_default_parameter (f, parms, Qmenu_bar_lines, make_fixnum (1),
"menuBar", "MenuBar", RES_TYPE_NUMBER);
- x_default_parameter (f, parms, Qtool_bar_lines, make_number (0),
+ x_default_parameter (f, parms, Qtool_bar_lines, make_fixnum (0),
"toolBar", "ToolBar", RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
"bufferPredicate", "BufferPredicate", RES_TYPE_SYMBOL);
? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF);
- if (INTEGERP (Vtool_bar_button_margin)
+ if (FIXNUMP (Vtool_bar_button_margin)
&& XINT (Vtool_bar_button_margin) > 0)
margin = XFASTINT (Vtool_bar_button_margin);
else if (CONSP (Vtool_bar_button_margin)
- && INTEGERP (XCDR (Vtool_bar_button_margin))
+ && FIXNUMP (XCDR (Vtool_bar_button_margin))
&& XINT (XCDR (Vtool_bar_button_margin)) > 0)
margin = XFASTINT (XCDR (Vtool_bar_button_margin));
else
/* Look for Same charset and a valid codepage (or non-int
which means ignore). */
if (w32_charset == charset_type
- && (!INTEGERP (codepage) || codepage == CP_DEFAULT
+ && (!FIXNUMP (codepage) || codepage == CP_DEFAULT
|| IsValidCodePage (XINT (codepage))))
{
/* If we don't have a match already, then this is the
return CP_8BIT;
else if (XFASTINT (codepage) == XFASTINT (Qt))
return CP_UNICODE;
- else if (INTEGERP (codepage))
+ else if (FIXNUMP (codepage))
return XINT (codepage);
else
return CP_UNKNOWN;
/* Scalable fonts are as big as you want them to be. */
lplf->elfLogFont.lfHeight = lpef->logfont.lfHeight;
lplf->elfLogFont.lfWidth = lpef->logfont.lfWidth;
- width = make_number (lpef->logfont.lfWidth);
+ width = make_fixnum (lpef->logfont.lfWidth);
}
else
{
else
continue;
}
- if (!INTEGERP (XCDR (tem)))
+ if (!FIXNUMP (XCDR (tem)))
{
/* Since we don't yet know the size of the font, we must
load it and try GetTextMetrics. */
hdc = GetDC (dpyinfo->root_window);
oldobj = SelectObject (hdc, thisinfo.hfont);
if (GetTextMetrics (hdc, &thisinfo.tm))
- XCDR (tem) = make_number (FONT_WIDTH (&thisinfo));
+ XCDR (tem) = make_fixnum (FONT_WIDTH (&thisinfo));
else
- XCDR (tem) = make_number (0);
+ XCDR (tem) = make_fixnum (0);
SelectObject (hdc, oldobj);
ReleaseDC (dpyinfo->root_window, hdc);
DeleteObject(thisinfo.hfont);
{
Lisp_Object rgb[3];
- rgb[0] = make_number ((GetRValue (foo.pixel) << 8)
+ rgb[0] = make_fixnum ((GetRValue (foo.pixel) << 8)
| GetRValue (foo.pixel));
- rgb[1] = make_number ((GetGValue (foo.pixel) << 8)
+ rgb[1] = make_fixnum ((GetGValue (foo.pixel) << 8)
| GetGValue (foo.pixel));
- rgb[2] = make_number ((GetBValue (foo.pixel) << 8)
+ rgb[2] = make_fixnum ((GetBValue (foo.pixel) << 8)
| GetBValue (foo.pixel));
return Flist (3, rgb);
}
{
struct w32_display_info *dpyinfo = check_x_display_info (display);
- return make_number (dpyinfo->width);
+ return make_fixnum (dpyinfo->width);
}
DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
{
struct w32_display_info *dpyinfo = check_x_display_info (display);
- return make_number (dpyinfo->height);
+ return make_fixnum (dpyinfo->height);
}
DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
{
struct w32_display_info *dpyinfo = check_x_display_info (display);
- return make_number (dpyinfo->n_planes * dpyinfo->n_cbits);
+ return make_fixnum (dpyinfo->n_planes * dpyinfo->n_cbits);
}
DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
ReleaseDC (dpyinfo->root_window, hdc);
- return make_number (cap);
+ return make_fixnum (cap);
}
DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
{
struct w32_display_info *dpyinfo = check_x_display_info (display);
- return make_number (1);
+ return make_fixnum (1);
}
DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
(display)
Lisp_Object display;
{
- return Fcons (make_number (w32_major_version),
- Fcons (make_number (w32_minor_version),
- Fcons (make_number (w32_build_number), Qnil)));
+ return Fcons (make_fixnum (w32_major_version),
+ Fcons (make_fixnum (w32_minor_version),
+ Fcons (make_fixnum (w32_build_number), Qnil)));
}
DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
(display)
Lisp_Object display;
{
- return make_number (1);
+ return make_fixnum (1);
}
DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
ReleaseDC (dpyinfo->root_window, hdc);
- return make_number (cap);
+ return make_fixnum (cap);
}
DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
ReleaseDC (dpyinfo->root_window, hdc);
- return make_number (cap);
+ return make_fixnum (cap);
}
DEFUN ("x-display-backing-store", Fx_display_backing_store,
break;
case IMAGE_POSITIVE_INTEGER_VALUE:
- if (!INTEGERP (value) || XINT (value) <= 0)
+ if (!FIXNUMP (value) || XINT (value) <= 0)
return 0;
break;
case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR:
- if (INTEGERP (value) && XINT (value) >= 0)
+ if (FIXNUMP (value) && XINT (value) >= 0)
break;
if (CONSP (value)
- && INTEGERP (XCAR (value)) && INTEGERP (XCDR (value))
+ && FIXNUMP (XCAR (value)) && FIXNUMP (XCDR (value))
&& XINT (XCAR (value)) >= 0 && XINT (XCDR (value)) >= 0)
break;
return 0;
case IMAGE_ASCENT_VALUE:
if (SYMBOLP (value) && EQ (value, Qcenter))
break;
- else if (INTEGERP (value)
+ else if (FIXNUMP (value)
&& XINT (value) >= 0
&& XINT (value) <= 100)
break;
return 0;
case IMAGE_NON_NEGATIVE_INTEGER_VALUE:
- if (!INTEGERP (value) || XINT (value) < 0)
+ if (!FIXNUMP (value) || XINT (value) < 0)
return 0;
break;
return 0;
case IMAGE_NUMBER_VALUE:
- if (!INTEGERP (value) && !FLOATP (value))
+ if (!FIXNUMP (value) && !FLOATP (value))
return 0;
break;
case IMAGE_INTEGER_VALUE:
- if (!INTEGERP (value))
+ if (!FIXNUMP (value))
return 0;
break;
{
struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
- if (c && INTEGERP (Vimage_cache_eviction_delay))
+ if (c && FIXNUMP (Vimage_cache_eviction_delay))
{
EMACS_TIME t;
unsigned long old;
Lisp_Object value;
value = image_spec_value (spec, QCwidth, NULL);
- img->width = (INTEGERP (value)
+ img->width = (FIXNUMP (value)
? XFASTINT (value) : DEFAULT_IMAGE_WIDTH);
value = image_spec_value (spec, QCheight, NULL);
- img->height = (INTEGERP (value)
+ img->height = (FIXNUMP (value)
? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
}
else
Lisp_Object ascent, margin, relief;
ascent = image_spec_value (spec, QCascent, NULL);
- if (INTEGERP (ascent))
+ if (FIXNUMP (ascent))
img->ascent = XFASTINT (ascent);
else if (EQ (ascent, Qcenter))
img->ascent = CENTERED_IMAGE_ASCENT;
margin = image_spec_value (spec, QCmargin, NULL);
- if (INTEGERP (margin) && XINT (margin) >= 0)
+ if (FIXNUMP (margin) && XINT (margin) >= 0)
img->vmargin = img->hmargin = XFASTINT (margin);
- else if (CONSP (margin) && INTEGERP (XCAR (margin))
- && INTEGERP (XCDR (margin)))
+ else if (CONSP (margin) && FIXNUMP (XCAR (margin))
+ && FIXNUMP (XCDR (margin)))
{
if (XINT (XCAR (margin)) > 0)
img->hmargin = XFASTINT (XCAR (margin));
}
relief = image_spec_value (spec, QCrelief, NULL);
- if (INTEGERP (relief))
+ if (FIXNUMP (relief))
{
img->relief = XINT (relief);
img->hmargin += abs (img->relief);
}
image = image_spec_value (img->spec, QCindex, NULL);
- ino = INTEGERP (image) ? XFASTINT (image) : 0;
+ ino = FIXNUMP (image) ? XFASTINT (image) : 0;
if (ino >= gif->ImageCount)
{
image_error ("Invalid image number `%s' in image `%s'",
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;
if (XVECTOR (tem)->size != 4)
return 0;
for (i = 0; i < 4; ++i)
- if (!INTEGERP (XVECTOR (tem)->contents[i]))
+ if (!FIXNUMP (XVECTOR (tem)->contents[i]))
return 0;
}
else
loader = intern ("gs-load-image");
img->data.lisp_val = 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);
UNGCPRO;
cancel_hourglass ();
- if (INTEGERP (Vhourglass_delay)
+ if (FIXNUMP (Vhourglass_delay)
&& XINT (Vhourglass_delay) > 0)
secs = XFASTINT (Vhourglass_delay);
else if (FLOATP (Vhourglass_delay)
"font", "Font", RES_TYPE_STRING);
}
- x_default_parameter (f, parms, Qborder_width, make_number (2),
+ x_default_parameter (f, parms, Qborder_width, make_fixnum (2),
"borderWidth", "BorderWidth", RES_TYPE_NUMBER);
/* This defaults to 2 in order to match xterm. We recognize either
parms);
}
- x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
+ x_default_parameter (f, parms, Qinternal_border_width, make_fixnum (1),
"internalBorderWidth", "internalBorderWidth",
RES_TYPE_NUMBER);
CHECK_STRING (string, 0);
f = check_x_frame (frame);
if (NILP (timeout))
- timeout = make_number (5);
+ timeout = make_fixnum (5);
else
CHECK_NATNUM (timeout, 2);
if (NILP (dx))
- dx = make_number (5);
+ dx = make_fixnum (5);
else
CHECK_NUMBER (dx, 5);
if (NILP (dy))
- dy = make_number (-10);
+ dy = make_fixnum (-10);
else
CHECK_NUMBER (dy, 6);
if (NILP (last_show_tip_args))
- last_show_tip_args = Fmake_vector (make_number (3), Qnil);
+ last_show_tip_args = Fmake_vector (make_fixnum (3), Qnil);
if (!NILP (tip_frame))
{
if (NILP (Fassq (Qname, parms)))
parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
if (NILP (Fassq (Qinternal_border_width, parms)))
- parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
+ parms = Fcons (Fcons (Qinternal_border_width, make_fixnum (3)), parms);
if (NILP (Fassq (Qborder_width, parms)))
- parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
+ parms = Fcons (Fcons (Qborder_width, make_fixnum (1)), parms);
if (NILP (Fassq (Qborder_color, parms)))
parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
if (NILP (Fassq (Qbackground_color, parms)))
columns x 40 lines. If someone wants to show a larger tip, he
will loose. I don't think this is a realistic case. */
w = XWINDOW (FRAME_ROOT_WINDOW (f));
- w->left = w->top = make_number (0);
- w->width = make_number (80);
- w->height = make_number (40);
+ w->left = w->top = make_fixnum (0);
+ w->width = make_fixnum (80);
+ w->height = make_fixnum (40);
adjust_glyphs (f);
w->pseudo_window_p = 1;
id = lookup_image (SELECTED_FRAME (), spec);
debug_print (spec);
- return make_number (id);
+ return make_fixnum (id);
}
#endif /* GLYPH_DEBUG != 0 */
(STRINGP (parameters) ?
XSTRING (parameters)->data : NULL),
XSTRING (current_dir)->data,
- (INTEGERP (show_flag) ?
+ (FIXNUMP (show_flag) ?
XINT (show_flag) : SW_SHOWDEFAULT))
> 32)
return Qt;
GCPRO1 (key);
- c = Faref (key, make_number (0));
+ c = Faref (key, make_fixnum (0));
if (CONSP (c) && lucid_event_type_list_p (c))
c = Fevent_convert_list (c);
UNGCPRO;
- if (! INTEGERP (c) && ! SYMBOLP (c))
+ if (! FIXNUMP (c) && ! SYMBOLP (c))
error ("Key definition is invalid");
/* Work out the base key and the modifiers. */
abort ();
vk_code = lookup_vk_code (XSYMBOL (c)->name->data);
}
- else if (INTEGERP (c))
+ else if (FIXNUMP (c))
{
lisp_modifiers = XINT (c) & ~CHARACTERBITS;
/* Many ascii characters are their own virtual key code. */
{
Lisp_Object item;
- if (!INTEGERP (key))
+ if (!FIXNUMP (key))
key = w32_parse_hot_key (key);
item = Fmemq (key, w32_grabbed_keys);
if (lispy_function_keys[vk_code])
key = intern (lispy_function_keys[vk_code]);
else
- key = make_number (vk_code);
+ key = make_fixnum (vk_code);
key = Fcons (key, Qnil);
if (w32_modifiers & MOD_SHIFT)
return Qnil;
if (!dwWindowsThreadId)
- return make_number (w32_console_toggle_lock_key (vk_code, new_state));
+ return make_fixnum (w32_console_toggle_lock_key (vk_code, new_state));
if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_TOGGLE_LOCK_KEY,
(WPARAM) vk_code, (LPARAM) new_state))
{
MSG msg;
GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
- return make_number (msg.wParam);
+ return make_fixnum (msg.wParam);
}
return Qnil;
}
DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
"*Seconds to wait before displaying an hourglass pointer.\n\
Value must be an integer or float.");
- Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
+ Vhourglass_delay = make_fixnum (DEFAULT_HOURGLASS_DELAY);
DEFVAR_LISP ("x-sensitive-text-pointer-shape",
&Vx_sensitive_text_pointer_shape,
When an image has not been displayed this many seconds, remove it\n\
from the image cache. Value must be an integer or nil with nil\n\
meaning don't clear the cache.");
- Vimage_cache_eviction_delay = make_number (30 * 60);
+ Vimage_cache_eviction_delay = make_fixnum (30 * 60);
DEFVAR_LISP ("w32-bdf-filename-alist",
&Vw32_bdf_filename_alist,
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_used = 0;
old = menu_items;
menu_items_allocated *= 2;
- menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
+ menu_items = Fmake_vector (make_fixnum (menu_items_allocated), Qnil);
bcopy (XVECTOR (old)->contents, XVECTOR (menu_items)->contents,
old_size * sizeof (Lisp_Object));
}
/* (menu-item MENU-NAME PANE-NUMBER) */
menu_object = Fcons (Qmenu_item,
Fcons (pane_name,
- Fcons (make_number (pane), Qnil)));
+ Fcons (make_fixnum (pane), Qnil)));
show_help_echo (info.dwItemData ?
build_string ((char *) info.dwItemData) : Qnil,
- Qnil, menu_object, make_number (item), 1);
+ Qnil, menu_object, make_fixnum (item), 1);
}
}
do_quoting = 1;
/* Override escape char by binding w32-quote-process-args to
desired character, or use t for auto-selection. */
- if (INTEGERP (Vw32_quote_process_args))
+ if (FIXNUMP (Vw32_quote_process_args))
escape_char = XINT (Vw32_quote_process_args);
else
escape_char = is_cygnus_app ? '"' : '\\';
human-readable form.")
()
{
- return make_number (GetThreadLocale ());
+ return make_fixnum (GetThreadLocale ());
}
DWORD int_from_hex (char * s)
BOOL CALLBACK enum_locale_fn (LPTSTR localeNum)
{
DWORD id = int_from_hex (localeNum);
- Vw32_valid_locale_ids = Fcons (make_number (id), Vw32_valid_locale_ids);
+ Vw32_valid_locale_ids = Fcons (make_fixnum (id), Vw32_valid_locale_ids);
return TRUE;
}
Lisp_Object userp;
{
if (NILP (userp))
- return make_number (GetSystemDefaultLCID ());
- return make_number (GetUserDefaultLCID ());
+ return make_fixnum (GetSystemDefaultLCID ());
+ return make_fixnum (GetUserDefaultLCID ());
}
/* Reply is not needed. */
PostThreadMessage (dwWindowsThreadId, WM_EMACS_SETLOCALE, XINT (lcid), 0);
- return make_number (GetThreadLocale ());
+ return make_fixnum (GetThreadLocale ());
}
BOOL CALLBACK enum_codepage_fn (LPTSTR codepageNum)
{
DWORD id = atoi (codepageNum);
- Vw32_valid_codepages = Fcons (make_number (id), Vw32_valid_codepages);
+ Vw32_valid_codepages = Fcons (make_fixnum (id), Vw32_valid_codepages);
return TRUE;
}
"Return current Windows codepage for console input.")
()
{
- return make_number (GetConsoleCP ());
+ return make_fixnum (GetConsoleCP ());
}
if (!SetConsoleCP (XINT (cp)))
return Qnil;
- return make_number (GetConsoleCP ());
+ return make_fixnum (GetConsoleCP ());
}
"Return current Windows codepage for console output.")
()
{
- return make_number (GetConsoleOutputCP ());
+ return make_fixnum (GetConsoleOutputCP ());
}
if (!SetConsoleOutputCP (XINT (cp)))
return Qnil;
- return make_number (GetConsoleOutputCP ());
+ return make_fixnum (GetConsoleOutputCP ());
}
return Qnil;
if (TranslateCharsetInfo ((DWORD *) XINT (cp), &info, TCI_SRCCODEPAGE))
- return make_number (info.ciCharset);
+ return make_fixnum (info.ciCharset);
return Qnil;
}
{
DWORD kl = (DWORD) layouts[num_layouts];
- obj = Fcons (Fcons (make_number (kl & 0xffff),
- make_number ((kl >> 16) & 0xffff)),
+ obj = Fcons (Fcons (make_fixnum (kl & 0xffff),
+ make_fixnum ((kl >> 16) & 0xffff)),
obj);
}
}
{
DWORD kl = (DWORD) GetKeyboardLayout (dwWindowsThreadId);
- return Fcons (make_number (kl & 0xffff),
- make_number ((kl >> 16) & 0xffff));
+ return Fcons (make_fixnum (kl & 0xffff),
+ make_fixnum ((kl >> 16) & 0xffff));
}
ASCENT must be in the range 0 <= ASCENT <= 100. */
#define NUMVAL(X) \
- ((INTEGERP (X) || FLOATP (X)) \
+ ((FIXNUMP (X) || FLOATP (X)) \
? XFLOATINT (X) \
: - 1)
&& font_info->default_ascent
&& CHAR_TABLE_P (Vuse_default_ascent)
&& !NILP (Faref (Vuse_default_ascent,
- make_number (it->char_to_display))))
+ make_fixnum (it->char_to_display))))
highest = font_info->default_ascent + boff;
/* Draw the first glyph at the normal position. It may be
if (font_info && font_info->relative_compose
&& (! CHAR_TABLE_P (Vignore_relative_composition)
|| NILP (Faref (Vignore_relative_composition,
- make_number (ch)))))
+ make_fixnum (ch)))))
{
if (- descent >= font_info->relative_compose)
/* If we're on a string with `help-echo' text property,
arrange for the help to be displayed. This is done by
setting the global variable help_echo to the help string. */
- help = Fget_text_property (make_number (glyph->charpos),
+ help = Fget_text_property (make_fixnum (glyph->charpos),
Qhelp_echo, glyph->object);
if (!NILP (help))
{
}
/* Change the mouse pointer according to what is under X/Y. */
- map = Fget_text_property (make_number (glyph->charpos),
+ map = Fget_text_property (make_fixnum (glyph->charpos),
Qlocal_map, glyph->object);
if (KEYMAPP (map))
cursor = f->output_data.w32->nontext_cursor;
else
{
- map = Fget_text_property (make_number (glyph->charpos),
+ map = Fget_text_property (make_fixnum (glyph->charpos),
Qkeymap, glyph->object);
if (KEYMAPP (map))
cursor = f->output_data.w32->nontext_cursor;
XSETINT (end, (BUF_Z (XBUFFER (w->buffer))
- XFASTINT (w->window_end_pos)));
before
- = Fprevious_single_property_change (make_number (pos + 1),
+ = Fprevious_single_property_change (make_fixnum (pos + 1),
Qmouse_face,
w->buffer, beginning);
after
|| (BUFFERP (glyph->object)
&& glyph->charpos >= BEGV
&& glyph->charpos < ZV))
- help = Fget_text_property (make_number (glyph->charpos),
+ help = Fget_text_property (make_fixnum (glyph->charpos),
Qhelp_echo, glyph->object);
if (!NILP (help))
struct frame *f = XFRAME (WINDOW_FRAME (w));
HWND hwnd;
struct scroll_bar *bar
- = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
+ = XSCROLL_BAR (Fmake_vector (make_fixnum (SCROLL_BAR_VEC_SIZE), Qnil));
BLOCK_INPUT;
/* 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);
/* Create the window thread - it will terminate itself or when the app terminates */
(window)
Lisp_Object window;
{
- return make_number (window_internal_width (decode_window (window)));
+ return make_fixnum (window_internal_width (decode_window (window)));
}
DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
if (XINT (w->hscroll) != hscroll)
XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
- w->hscroll = make_number (hscroll);
+ w->hscroll = make_fixnum (hscroll);
return ncol;
}
register struct window *w = decode_window (window);
return Fcons (w->left, Fcons (w->top,
- Fcons (make_number (WINDOW_RIGHT_EDGE (w)),
- Fcons (make_number (XFASTINT (w->top)
+ Fcons (make_fixnum (WINDOW_RIGHT_EDGE (w)),
+ Fcons (make_fixnum (XFASTINT (w->top)
+ XFASTINT (w->height)),
Qnil))));
}
move_it_vertically (&it, window_box_height (w));
if (it.current_y < it.last_visible_y)
move_it_past_eol (&it);
- value = make_number (IT_CHARPOS (it));
+ value = make_fixnum (IT_CHARPOS (it));
if (old_buffer)
set_buffer_internal (old_buffer);
FRAME_SAMPLE_VISIBILITY (f);
candidate_p = FRAME_VISIBLE_P (f);
}
- else if (INTEGERP (all_frames) && XINT (all_frames) == 0)
+ else if (FIXNUMP (all_frames) && XINT (all_frames) == 0)
{
FRAME_SAMPLE_VISIBILITY (f);
candidate_p = FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f);
}
/* Set redisplay hints. */
- w->last_modified = make_number (0);
- w->last_overlay_modified = make_number (0);
+ w->last_modified = make_fixnum (0);
+ w->last_overlay_modified = make_fixnum (0);
windows_or_buffers_changed++;
FRAME_WINDOW_SIZES_CHANGED (XFRAME (w->frame)) = 1;
{
sideward = &w->vchild;
forward = &w->hchild;
- w->width = make_number (size);
+ w->width = make_fixnum (size);
}
else
{
sideward = &w->hchild;
forward = &w->vchild;
- w->height = make_number (size);
+ w->height = make_fixnum (size);
w->orig_height = Qnil;
}
/* The top or left edge position of this child equals the
bottom or right edge of its predecessor. */
if (width_p)
- c->left = make_number (last_pos);
+ c->left = make_fixnum (last_pos);
else
- c->top = make_number (last_pos);
+ c->top = make_fixnum (last_pos);
/* If this child can be resized, do it. */
if (resize_fixed_p || !window_fixed_size_p (c, width_p, 0))
b->last_selected_window = window;
/* Update time stamps of buffer display. */
- if (INTEGERP (b->display_count))
+ if (FIXNUMP (b->display_count))
XSETINT (b->display_count, XINT (b->display_count) + 1);
b->display_time = Fcurrent_time ();
XSETFASTINT (w->window_end_vpos, 0);
bzero (&w->last_cursor, sizeof w->last_cursor);
w->window_end_valid = Qnil;
- w->hscroll = w->min_hscroll = make_number (0);
+ w->hscroll = w->min_hscroll = make_fixnum (0);
w->vscroll = 0;
set_marker_both (w->pointm, buffer, BUF_PT (b), BUF_PT_BYTE (b));
set_marker_restricted (w->start,
- make_number (b->last_window_start),
+ make_fixnum (b->last_window_start),
buffer);
w->start_at_line_beg = Qnil;
w->force_start = Qnil;
window = Fget_largest_window (Qvisible);
/* If that didn't work, try iconified frames. */
if (NILP (window))
- window = Fget_largest_window (make_number (0));
+ window = Fget_largest_window (make_fixnum (0));
if (NILP (window))
window = Fget_largest_window (Qt);
}
window = Fget_largest_window (Qvisible);
/* If that didn't work, try iconified frames. */
if (NILP (window))
- window = Fget_buffer_window (buffer, make_number (0));
+ window = Fget_buffer_window (buffer, make_fixnum (0));
if (NILP (window))
- window = Fget_largest_window (make_number (0));
+ window = Fget_largest_window (make_fixnum (0));
/* Try invisible frames. */
if (NILP (window))
window = Fget_buffer_window (buffer, Qt);
for (child = w->vchild; !NILP (child); child = c->next)
{
c = XWINDOW (child);
- c->top = make_number (last_top);
+ c->top = make_fixnum (last_top);
shrink_window_lowest_first (c, XFASTINT (c->height));
last_top += XFASTINT (c->height);
}
switch (action)
{
case CHECK_ORIG_SIZES:
- if (!INTEGERP (w->orig_top) || !INTEGERP (w->orig_height))
+ if (!FIXNUMP (w->orig_top) || !FIXNUMP (w->orig_height))
return 0;
break;
break;
case RESTORE_ORIG_SIZES:
- xassert (INTEGERP (w->orig_top) && INTEGERP (w->orig_height));
+ xassert (FIXNUMP (w->orig_top) && FIXNUMP (w->orig_height));
w->top = w->orig_top;
w->height = w->orig_height;
w->orig_height = w->orig_top = Qnil;
shrink_window_lowest_first (root, XFASTINT (root->height) - delta);
/* Grow the mini-window. */
- w->top = make_number (XFASTINT (root->top) + XFASTINT (root->height));
- w->height = make_number (XFASTINT (w->height) + delta);
+ w->top = make_fixnum (XFASTINT (root->top) + XFASTINT (root->height));
+ w->height = make_fixnum (XFASTINT (w->height) + delta);
XSETFASTINT (w->last_modified, 0);
XSETFASTINT (w->last_overlay_modified, 0);
/* If PT is not visible in WINDOW, move back one half of
the screen. */
- tem = Fpos_visible_in_window_p (make_number (PT), window, Qnil);
+ tem = Fpos_visible_in_window_p (make_fixnum (PT), window, Qnil);
if (NILP (tem))
{
/* Move backward half the height of the window. Performance note:
if (! vscrolled)
{
/* Set the window start, and set up the window for redisplay. */
- set_marker_restricted (w->start, make_number (IT_CHARPOS (it)),
+ set_marker_restricted (w->start, make_fixnum (IT_CHARPOS (it)),
w->buffer);
w->start_at_line_beg = Fbolp ();
w->update_mode_line = Qt;
if (NILP (tem))
{
- Fvertical_motion (make_number (- (ht / 2)), window);
+ Fvertical_motion (make_fixnum (- (ht / 2)), window);
startpos = PT;
}
SET_PT (startpos);
lose = n < 0 && PT == BEGV;
- Fvertical_motion (make_number (n), window);
+ Fvertical_motion (make_fixnum (n), window);
pos = PT;
pos_byte = PT_BYTE;
bolp = Fbolp ();
if (whole && !NILP (Vscroll_preserve_screen_position))
{
SET_PT_BOTH (pos, pos_byte);
- Fvertical_motion (make_number (original_vpos), window);
+ Fvertical_motion (make_fixnum (original_vpos), window);
}
/* If we scrolled forward, put point enough lines down
that it is outside the scroll margin. */
if (this_scroll_margin > 0)
{
SET_PT_BOTH (pos, pos_byte);
- Fvertical_motion (make_number (this_scroll_margin), window);
+ Fvertical_motion (make_fixnum (this_scroll_margin), window);
top_margin = PT;
}
else
else if (!NILP (Vscroll_preserve_screen_position))
{
SET_PT_BOTH (pos, pos_byte);
- Fvertical_motion (make_number (original_vpos), window);
+ Fvertical_motion (make_fixnum (original_vpos), window);
}
else
SET_PT (top_margin);
/* If we scrolled backward, put point near the end of the window
but not within the scroll margin. */
SET_PT_BOTH (pos, pos_byte);
- tem = Fvertical_motion (make_number (ht - this_scroll_margin), window);
+ tem = Fvertical_motion (make_fixnum (ht - this_scroll_margin), window);
if (XFASTINT (tem) == ht - this_scroll_margin)
bottom_margin = PT;
else
if (!NILP (Vscroll_preserve_screen_position))
{
SET_PT_BOTH (pos, pos_byte);
- Fvertical_motion (make_number (original_vpos), window);
+ Fvertical_motion (make_fixnum (original_vpos), window);
}
else
- Fvertical_motion (make_number (-1), window);
+ Fvertical_motion (make_fixnum (-1), window);
}
}
}
arg = Fprefix_numeric_value (arg);
hscroll = XINT (w->hscroll) + XINT (arg);
- result = Fset_window_hscroll (selected_window, make_number (hscroll));
+ result = Fset_window_hscroll (selected_window, make_fixnum (hscroll));
if (interactive_p (0))
w->min_hscroll = w->hscroll;
arg = Fprefix_numeric_value (arg);
hscroll = XINT (w->hscroll) - XINT (arg);
- result = Fset_window_hscroll (selected_window, make_number (hscroll));
+ result = Fset_window_hscroll (selected_window, make_fixnum (hscroll));
if (interactive_p (0))
w->min_hscroll = w->hscroll;
int ht = window_internal_height (w);
if (center_p)
- arg = make_number (ht / 2);
+ arg = make_fixnum (ht / 2);
else if (XINT (arg) < 0)
- arg = make_number (XINT (arg) + ht);
+ arg = make_fixnum (XINT (arg) + ht);
pos = *vmotion (PT, - XINT (arg), w);
charpos = pos.bufpos;
struct window *w = decode_window (window);
int pixel_height = window_box_height (w);
int line_height = pixel_height / CANON_Y_UNIT (XFRAME (w->frame));
- return make_number (line_height);
+ return make_fixnum (line_height);
}
if (start < BEGV || start > ZV)
{
int height = window_internal_height (w);
- Fvertical_motion (make_number (- (height / 2)), window);
+ Fvertical_motion (make_fixnum (- (height / 2)), window);
set_marker_both (w->start, w->buffer, PT, PT_BYTE);
w->start_at_line_beg = Fbolp ();
w->force_start = Qt;
#if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
if (XFASTINT (data->frame_menu_bar_lines)
!= previous_frame_menu_bar_lines)
- x_set_menu_bar_lines (f, data->frame_menu_bar_lines, make_number (0));
+ x_set_menu_bar_lines (f, data->frame_menu_bar_lines, make_fixnum (0));
#ifdef HAVE_WINDOW_SYSTEM
if (XFASTINT (data->frame_tool_bar_lines)
!= previous_frame_tool_bar_lines)
- x_set_tool_bar_lines (f, data->frame_tool_bar_lines, make_number (0));
+ x_set_tool_bar_lines (f, data->frame_tool_bar_lines, make_fixnum (0));
#endif
#endif
w->buffer = Fcdr (Fcar (Vbuffer_alist));
/* This will set the markers to beginning of visible
range. */
- set_marker_restricted (w->start, make_number (0), w->buffer);
- set_marker_restricted (w->pointm, make_number (0),w->buffer);
+ set_marker_restricted (w->start, make_fixnum (0), w->buffer);
+ set_marker_restricted (w->pointm, make_fixnum (0),w->buffer);
w->start_at_line_beg = Qt;
}
else
{
/* Set window markers at start of visible range. */
if (XMARKER (w->start)->buffer == 0)
- set_marker_restricted (w->start, make_number (0),
+ set_marker_restricted (w->start, make_fixnum (0),
w->buffer);
if (XMARKER (w->pointm)->buffer == 0)
set_marker_restricted_both (w->pointm, w->buffer,
0, 0, 0);
#if defined (HAVE_WINDOW_SYSTEM) || defined (MSDOS)
if (previous_frame_menu_bar_lines != FRAME_MENU_BAR_LINES (f))
- x_set_menu_bar_lines (f, make_number (previous_frame_menu_bar_lines),
- make_number (0));
+ x_set_menu_bar_lines (f, make_fixnum (previous_frame_menu_bar_lines),
+ make_fixnum (0));
#ifdef HAVE_WINDOW_SYSTEM
if (previous_frame_tool_bar_lines != FRAME_TOOL_BAR_LINES (f))
- x_set_tool_bar_lines (f, make_number (previous_frame_tool_bar_lines),
- make_number (0));
+ x_set_tool_bar_lines (f, make_fixnum (previous_frame_tool_bar_lines),
+ make_fixnum (0));
#endif
#endif
data->focus_frame = FRAME_FOCUS_FRAME (f);
XSETINT (data->min_height, window_min_height);
XSETINT (data->min_width, window_min_width);
- tem = Fmake_vector (make_number (n_windows), Qnil);
+ tem = Fmake_vector (make_fixnum (n_windows), Qnil);
data->saved_windows = tem;
for (i = 0; i < n_windows; i++)
XVECTOR (tem)->contents[i]
- = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE), Qnil);
+ = Fmake_vector (make_fixnum (SAVED_WINDOW_VECTOR_SIZE), Qnil);
save_window_save (FRAME_ROOT_WINDOW (f), XVECTOR (tem), 0);
XSETWINDOW_CONFIGURATION (tem, data);
return (tem);
/* Check widths < 0 and translate a zero width to nil.
Margins that are too wide have to be checked elsewhere. */
- if ((INTEGERP (left) && XINT (left) < 0)
+ if ((FIXNUMP (left) && XINT (left) < 0)
|| (FLOATP (left) && XFLOAT_DATA (left) <= 0))
XSETFASTINT (left, 0);
- if (INTEGERP (left) && XFASTINT (left) == 0)
+ if (FIXNUMP (left) && XFASTINT (left) == 0)
left = Qnil;
- if ((INTEGERP (right) && XINT (right) < 0)
+ if ((FIXNUMP (right) && XINT (right) < 0)
|| (FLOATP (right) && XFLOAT_DATA (right) <= 0))
XSETFASTINT (right, 0);
- if (INTEGERP (right) && XFASTINT (right) == 0)
+ if (FIXNUMP (right) && XFASTINT (right) == 0)
right = Qnil;
w->left_margin_width = left;
if (FRAME_WINDOW_P (f))
result = CANON_Y_FROM_PIXEL_Y (f, -w->vscroll);
else
- result = make_number (0);
+ result = make_fixnum (0);
return result;
}
if (area == TEXT_AREA)
{
- if (INTEGERP (w->left_margin_width))
+ if (FIXNUMP (w->left_margin_width))
width -= XFASTINT (w->left_margin_width);
- if (INTEGERP (w->right_margin_width))
+ if (FIXNUMP (w->right_margin_width))
width -= XFASTINT (w->right_margin_width);
}
else if (area == LEFT_MARGIN_AREA)
- width = (INTEGERP (w->left_margin_width)
+ width = (FIXNUMP (w->left_margin_width)
? XFASTINT (w->left_margin_width) : 0);
else if (area == RIGHT_MARGIN_AREA)
- width = (INTEGERP (w->right_margin_width)
+ width = (FIXNUMP (w->right_margin_width)
? XFASTINT (w->right_margin_width) : 0);
}
/* -1 means everything between a CR and the following line end
is invisible. >0 means lines indented more than this value are
invisible. */
- it->selective = (INTEGERP (current_buffer->selective_display)
+ it->selective = (FIXNUMP (current_buffer->selective_display)
? XFASTINT (current_buffer->selective_display)
: (!NILP (current_buffer->selective_display)
? -1 : 0));
&& XMARKER (w->redisplay_end_trigger)->buffer != 0)
it->redisplay_end_trigger_charpos
= marker_position (w->redisplay_end_trigger);
- else if (INTEGERP (w->redisplay_end_trigger))
+ else if (FIXNUMP (w->redisplay_end_trigger))
it->redisplay_end_trigger_charpos = XINT (w->redisplay_end_trigger);
/* Correct bogus values of tab_width. */
&& CHARPOS (pos->string_pos) < 0
&& charpos > BEGV
&& (XSETWINDOW (window, w),
- prop = Fget_char_property (make_number (charpos),
+ prop = Fget_char_property (make_fixnum (charpos),
Qinvisible, window),
!TEXT_PROP_MEANS_INVISIBLE (prop)))
{
- prop = Fget_char_property (make_number (charpos - 1), Qinvisible,
+ prop = Fget_char_property (make_fixnum (charpos - 1), Qinvisible,
window);
if (TEXT_PROP_MEANS_INVISIBLE (prop)
&& TEXT_PROP_MEANS_INVISIBLE_WITH_ELLIPSIS (prop))
properties. */
object = it->string;
limit = Qnil;
- position = make_number (IT_STRING_CHARPOS (*it));
+ position = make_fixnum (IT_STRING_CHARPOS (*it));
}
else
{
/* Set up variables for computing the stop position from text
property changes. */
XSETBUFFER (object, current_buffer);
- limit = make_number (IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT);
- position = make_number (IT_CHARPOS (*it));
+ limit = make_fixnum (IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT);
+ position = make_fixnum (IT_CHARPOS (*it));
}
if (!NULL_INTERVAL_P (next_iv))
{
- if (INTEGERP (limit)
+ if (FIXNUMP (limit)
&& next_iv->position >= XFASTINT (limit))
/* No text property change up to limit. */
it->stop_charpos = min (XFASTINT (limit), it->stop_charpos);
&& it->s == NULL
&& !NILP (Vfontification_functions)
&& !NILP (Vrun_hooks)
- && (pos = make_number (IT_CHARPOS (*it)),
+ && (pos = make_fixnum (IT_CHARPOS (*it)),
prop = Fget_char_property (pos, Qfontified, Qnil),
NILP (prop)))
{
/* Get the value of the invisible text property at the
current position. Value will be nil if there is no such
property. */
- charpos = make_number (IT_STRING_CHARPOS (*it));
+ charpos = make_fixnum (IT_STRING_CHARPOS (*it));
prop = Fget_text_property (charpos, Qinvisible, it->string);
if (!NILP (prop)
/* Text at current position is invisible. The next
change in the property is at position end_charpos.
Move IT's current position to that position. */
- if (INTEGERP (end_charpos)
+ if (FIXNUMP (end_charpos)
&& XFASTINT (end_charpos) < XFASTINT (limit))
{
struct text_pos old;
Lisp_Object pos, prop;
/* First of all, is there invisible text at this position? */
- pos = make_number (IT_CHARPOS (*it));
+ pos = make_fixnum (IT_CHARPOS (*it));
prop = Fget_char_property (pos, Qinvisible, it->window);
/* If we are on invisible text, skip over it. */
the char before the given position, i.e. if we
get visible_p = 1, this means that the char at
newpos is visible. */
- pos = make_number (newpos);
+ pos = make_fixnum (newpos);
prop = Fget_char_property (pos, Qinvisible, it->window);
visible_p = !TEXT_PROP_MEANS_INVISIBLE (prop);
}
if (!it->string_from_display_prop_p)
it->area = TEXT_AREA;
- prop = Fget_char_property (make_number (position->charpos),
+ prop = Fget_char_property (make_fixnum (position->charpos),
Qdisplay, object);
if (NILP (prop))
return HANDLED_NORMALLY;
Lisp_Object end;
struct text_pos end_pos;
- end = Fnext_single_char_property_change (make_number (CHARPOS (start_pos)),
+ end = Fnext_single_char_property_change (make_fixnum (CHARPOS (start_pos)),
Qdisplay, object, Qnil);
CHARPOS (end_pos) = XFASTINT (end);
if (STRINGP (object))
&& (EQ (XCAR (it->font_height), Qplus)
|| EQ (XCAR (it->font_height), Qminus))
&& CONSP (XCDR (it->font_height))
- && INTEGERP (XCAR (XCDR (it->font_height))))
+ && FIXNUMP (XCAR (XCDR (it->font_height))))
{
/* `(+ N)' or `(- N)' where N is an integer. */
int steps = XINT (XCAR (XCDR (it->font_height)));
Lisp_Object string;
int around_charpos;
{
- Lisp_Object around = make_number (around_charpos);
+ Lisp_Object around = make_fixnum (around_charpos);
Lisp_Object limit, prop, pos;
const int MAX_DISTANCE = 1000;
int found = 0;
- pos = make_number (around_charpos);
- limit = make_number (min (XINT (pos) + MAX_DISTANCE, ZV));
+ pos = make_fixnum (around_charpos);
+ limit = make_fixnum (min (XINT (pos) + MAX_DISTANCE, ZV));
while (!found && !EQ (pos, limit))
{
prop = Fget_char_property (pos, Qdisplay, Qnil);
if (!found)
{
- pos = make_number (around_charpos);
- limit = make_number (max (XINT (pos) - MAX_DISTANCE, BEGV));
+ pos = make_fixnum (around_charpos);
+ limit = make_fixnum (max (XINT (pos) - MAX_DISTANCE, BEGV));
while (!found && !EQ (pos, limit))
{
prop = Fget_char_property (pos, Qdisplay, Qnil);
entries[n].string = (STRING); \
entries[n].overlay = (OVERLAY); \
priority = Foverlay_get ((OVERLAY), Qpriority); \
- entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0; \
+ entries[n].priority = FIXNUMP (priority) ? XINT (priority) : 0; \
entries[n].after_string_p = (AFTER_P); \
++n; \
} \
overlays, we can just use the position of the newline in
buffer text. */
if (it->stop_charpos >= limit
- || ((pos = Fnext_single_property_change (make_number (start),
+ || ((pos = Fnext_single_property_change (make_fixnum (start),
Qdisplay,
- Qnil, make_number (limit)),
+ Qnil, make_fixnum (limit)),
NILP (pos))
&& next_overlay_change (start) == ZV))
{
{
Lisp_Object prop;
- prop = Fget_char_property (make_number (IT_CHARPOS (*it)),
+ prop = Fget_char_property (make_fixnum (IT_CHARPOS (*it)),
Qinvisible, it->window);
if (TEXT_PROP_MEANS_INVISIBLE (prop))
visible_p = 0;
{
/* Set IT->ctl_chars[0] to the glyph for `^'. */
if (it->dp
- && INTEGERP (DISP_CTRL_GLYPH (it->dp))
+ && FIXNUMP (DISP_CTRL_GLYPH (it->dp))
&& GLYPH_CHAR_VALID_P (XINT (DISP_CTRL_GLYPH (it->dp))))
g = XINT (DISP_CTRL_GLYPH (it->dp));
else
/* Set IT->ctl_chars[0] to the glyph for `\\'. */
if (it->dp
- && INTEGERP (DISP_ESCAPE_GLYPH (it->dp))
+ && FIXNUMP (DISP_ESCAPE_GLYPH (it->dp))
&& GLYPH_CHAR_VALID_P (XFASTINT (DISP_ESCAPE_GLYPH (it->dp))))
escape_glyph = XFASTINT (DISP_ESCAPE_GLYPH (it->dp));
else
IT's face is restored in set_iterator_to_next. */
it->saved_face_id = it->face_id;
- if (INTEGERP (*it->dpvec)
+ if (FIXNUMP (*it->dpvec)
&& GLYPH_CHAR_VALID_P (XFASTINT (*it->dpvec)))
{
int lface_id;
xassert (it != NULL && start_charpos <= end_charpos);
/* Is text at START invisible? */
- prop = Fget_char_property (make_number (start_charpos), Qinvisible,
+ prop = Fget_char_property (make_fixnum (start_charpos), Qinvisible,
it->window);
if (TEXT_PROP_MEANS_INVISIBLE (prop))
invisible_found_p = 1;
else
{
- limit = Fnext_single_char_property_change (make_number (start_charpos),
+ limit = Fnext_single_char_property_change (make_fixnum (start_charpos),
Qinvisible, Qnil,
- make_number (end_charpos));
+ make_fixnum (end_charpos));
invisible_found_p = XFASTINT (limit) < end_charpos;
}
Vwith_echo_area_save_vector = Qnil;
if (NILP (vector))
- vector = Fmake_vector (make_number (7), Qnil);
+ vector = Fmake_vector (make_fixnum (7), Qnil);
XSETBUFFER (AREF (vector, i), current_buffer); ++i;
AREF (vector, i) = Vdeactivate_mark, ++i;
- AREF (vector, i) = make_number (windows_or_buffers_changed), ++i;
+ AREF (vector, i) = make_fixnum (windows_or_buffers_changed), ++i;
if (w)
{
XSETWINDOW (AREF (vector, i), w); ++i;
AREF (vector, i) = w->buffer; ++i;
- AREF (vector, i) = make_number (XMARKER (w->pointm)->charpos); ++i;
- AREF (vector, i) = make_number (XMARKER (w->pointm)->bytepos); ++i;
+ AREF (vector, i) = make_fixnum (XMARKER (w->pointm)->charpos); ++i;
+ AREF (vector, i) = make_fixnum (XMARKER (w->pointm)->bytepos); ++i;
}
else
{
/* Compute the max. number of lines specified by the user. */
if (FLOATP (Vmax_mini_window_height))
max_height = XFLOATINT (Vmax_mini_window_height) * total_height;
- else if (INTEGERP (Vmax_mini_window_height))
+ else if (FIXNUMP (Vmax_mini_window_height))
max_height = XINT (Vmax_mini_window_height);
else
max_height = total_height / 4;
/* Reuse f->desired_tool_bar_string, if possible. */
if (size < size_needed || NILP (f->desired_tool_bar_string))
- f->desired_tool_bar_string = Fmake_string (make_number (size_needed),
- make_number (' '));
+ f->desired_tool_bar_string = Fmake_string (make_fixnum (size_needed),
+ make_fixnum (' '));
else
{
props = list4 (Qdisplay, Qnil, Qmenu_item, Qnil);
- Fremove_text_properties (make_number (0), make_number (size),
+ Fremove_text_properties (make_fixnum (0), make_fixnum (size),
props, f->desired_tool_bar_string);
}
: DEFAULT_TOOL_BAR_BUTTON_RELIEF);
hmargin = vmargin = relief;
- if (INTEGERP (Vtool_bar_button_margin)
+ if (FIXNUMP (Vtool_bar_button_margin)
&& XINT (Vtool_bar_button_margin) > 0)
{
hmargin += XFASTINT (Vtool_bar_button_margin);
}
else if (CONSP (Vtool_bar_button_margin))
{
- if (INTEGERP (XCAR (Vtool_bar_button_margin))
+ if (FIXNUMP (XCAR (Vtool_bar_button_margin))
&& XINT (XCAR (Vtool_bar_button_margin)) > 0)
hmargin += XFASTINT (XCAR (Vtool_bar_button_margin));
- if (INTEGERP (XCDR (Vtool_bar_button_margin))
+ if (FIXNUMP (XCDR (Vtool_bar_button_margin))
&& XINT (XCDR (Vtool_bar_button_margin)) > 0)
vmargin += XFASTINT (XCDR (Vtool_bar_button_margin));
}
selected. */
if (selected_p)
{
- plist = Fplist_put (plist, QCrelief, make_number (-relief));
+ plist = Fplist_put (plist, QCrelief, make_fixnum (-relief));
hmargin -= relief;
vmargin -= relief;
}
raised relief. */
plist = Fplist_put (plist, QCrelief,
(selected_p
- ? make_number (-relief)
- : make_number (relief)));
+ ? make_fixnum (-relief)
+ : make_fixnum (relief)));
hmargin -= relief;
vmargin -= relief;
}
if (hmargin || vmargin)
{
if (hmargin == vmargin)
- plist = Fplist_put (plist, QCmargin, make_number (hmargin));
+ plist = Fplist_put (plist, QCmargin, make_fixnum (hmargin));
else
plist = Fplist_put (plist, QCmargin,
- Fcons (make_number (hmargin),
- make_number (vmargin)));
+ Fcons (make_fixnum (hmargin),
+ make_fixnum (vmargin)));
}
/* If button is not enabled, and we don't have special images
vector. */
image = Fcons (Qimage, plist);
props = list4 (Qdisplay, image,
- Qmenu_item, make_number (i * TOOL_BAR_ITEM_NSLOTS));
+ Qmenu_item, make_fixnum (i * TOOL_BAR_ITEM_NSLOTS));
/* Let the last image hide all remaining spaces in the tool bar
string. The string can be longer than needed when we reuse a
end = XSTRING (f->desired_tool_bar_string)->size;
else
end = i + 1;
- Fadd_text_properties (make_number (i), make_number (end),
+ Fadd_text_properties (make_fixnum (i), make_fixnum (end),
props, f->desired_tool_bar_string);
#undef PROP
}
}
}
- return make_number (nlines);
+ return make_fixnum (nlines);
}
clear_glyph_matrix (w->desired_matrix);
Fmodify_frame_parameters (frame,
Fcons (Fcons (Qtool_bar_lines,
- make_number (nlines)),
+ make_fixnum (nlines)),
Qnil));
if (XFASTINT (w->height) != old_height)
fonts_changed_p = 1;
/* Get the text property `menu-item' at pos. The value of that
property is the start index of this item's properties in
F->tool_bar_items. */
- prop = Fget_text_property (make_number (glyph->charpos),
+ prop = Fget_text_property (make_fixnum (glyph->charpos),
Qmenu_item, f->current_tool_bar_string);
- if (INTEGERP (prop))
+ if (FIXNUMP (prop))
{
*prop_idx = XINT (prop);
success_p = 1;
if (XFASTINT (w->hscroll) != hscroll)
{
XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
- w->hscroll = make_number (hscroll);
+ w->hscroll = make_fixnum (hscroll);
hscrolled_p = 1;
}
}
/* If selective display, can't optimize if changes start at the
beginning of the line. */
if (unchanged_p
- && INTEGERP (current_buffer->selective_display)
+ && FIXNUMP (current_buffer->selective_display)
&& XINT (current_buffer->selective_display) > 0
&& (BEG_UNCHANGED < start || GPT <= start))
unchanged_p = 0;
/* Record a function that resets redisplaying_p to its old value
when we leave this function. */
count = BINDING_STACK_SIZE ();
- record_unwind_protect (unwind_redisplay, make_number (redisplaying_p));
+ record_unwind_protect (unwind_redisplay, make_fixnum (redisplaying_p));
++redisplaying_p;
retry:
struct buffer *b = XBUFFER (w->buffer);
w->last_modified
- = make_number (accurate_p ? BUF_MODIFF (b) : 0);
+ = make_fixnum (accurate_p ? BUF_MODIFF (b) : 0);
w->last_overlay_modified
- = make_number (accurate_p ? BUF_OVERLAY_MODIFF (b) : 0);
+ = make_fixnum (accurate_p ? BUF_OVERLAY_MODIFF (b) : 0);
w->last_had_star
= BUF_MODIFF (b) > BUF_SAVE_MODIFF (b) ? Qt : Qnil;
w->last_cursor_off_p = w->cursor_off_p;
if (w == XWINDOW (selected_window))
- w->last_point = make_number (BUF_PT (b));
+ w->last_point = make_fixnum (BUF_PT (b));
else
- w->last_point = make_number (XMARKER (w->pointm)->charpos);
+ w->last_point = make_fixnum (XMARKER (w->pointm)->charpos);
}
}
frames. */
if (row->displays_text_p)
while (glyph < end
- && INTEGERP (glyph->object)
+ && FIXNUMP (glyph->object)
&& glyph->charpos < 0)
{
x += glyph->pixel_width;
}
while (glyph < end
- && !INTEGERP (glyph->object)
+ && !FIXNUMP (glyph->object)
&& (!BUFFERP (glyph->object)
|| glyph->charpos < pt_old))
{
if (!NILP (Vwindow_scroll_functions))
{
run_hook_with_args_2 (Qwindow_scroll_functions, window,
- make_number (CHARPOS (startp)));
+ make_fixnum (CHARPOS (startp)));
SET_TEXT_POS_FROM_MARKER (startp, w->start);
/* In case the hook functions switch buffers. */
if (current_buffer != XBUFFER (w->buffer))
&& NILP (w->region_showing)
&& NILP (Vshow_trailing_whitespace)
/* Right after splitting windows, last_point may be nil. */
- && INTEGERP (w->last_point)
+ && FIXNUMP (w->last_point)
/* This code is not used for mini-buffer for the sake of the case
of redisplaying to replace an echo area message; since in
that case the mini-buffer contents per se are usually
larger than the window. This should really be fixed in
window.c. I don't have this on my list, now, so we do
approximately the same as the old redisplay code. --gerd. */
- && INTEGERP (w->window_end_vpos)
+ && FIXNUMP (w->window_end_vpos)
&& XFASTINT (w->window_end_vpos) < w->current_matrix->nrows
&& (FRAME_WINDOW_P (f)
|| !MARKERP (Voverlay_arrow_position)
startp = run_window_scroll_functions (window, startp);
}
- w->last_modified = make_number (0);
- w->last_overlay_modified = make_number (0);
+ w->last_modified = make_fixnum (0);
+ w->last_overlay_modified = make_fixnum (0);
if (CHARPOS (startp) < BEGV)
SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
else if (CHARPOS (startp) > ZV)
try_to_scroll:
- w->last_modified = make_number (0);
- w->last_overlay_modified = make_number (0);
+ w->last_modified = make_fixnum (0);
+ w->last_overlay_modified = make_fixnum (0);
/* Redisplay the mode line. Select the buffer properly for that. */
if (!update_mode_line)
&& !FRAME_WINDOW_P (f)
&& !WINDOW_FULL_WIDTH_P (w))
/* Line number to display. */
- || INTEGERP (w->base_line_pos)
+ || FIXNUMP (w->base_line_pos)
/* Column number is displayed and different from the one displayed. */
|| (!NILP (w->column_number_displayed)
&& XFASTINT (w->column_number_displayed) != current_column ()))
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
w->window_end_pos
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
+ = make_fixnum (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
w->window_end_vpos
- = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
+ = make_fixnum (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
xassert (MATRIX_ROW (w->desired_matrix, XFASTINT (w->window_end_vpos))
->displays_text_p);
}
else
{
w->window_end_bytepos = 0;
- w->window_end_pos = w->window_end_vpos = make_number (0);
+ w->window_end_pos = w->window_end_vpos = make_fixnum (0);
}
/* But that is not valid info until redisplay finishes. */
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_reused_text_row);
w->window_end_pos
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_reused_text_row));
+ = make_fixnum (Z - MATRIX_ROW_END_CHARPOS (last_reused_text_row));
w->window_end_vpos
- = make_number (MATRIX_ROW_VPOS (last_reused_text_row,
+ = make_fixnum (MATRIX_ROW_VPOS (last_reused_text_row,
w->current_matrix));
}
else if (last_text_row)
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
w->window_end_pos
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
+ = make_fixnum (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
w->window_end_vpos
- = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
+ = make_fixnum (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
}
else
{
/* This window must be completely empty. */
w->window_end_bytepos = 0;
- w->window_end_pos = w->window_end_vpos = make_number (0);
+ w->window_end_pos = w->window_end_vpos = make_fixnum (0);
}
w->window_end_valid = Qnil;
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
w->window_end_pos
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
+ = make_fixnum (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
w->window_end_vpos
- = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
+ = make_fixnum (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
}
else
{
w->window_end_vpos
- = make_number (XFASTINT (w->window_end_vpos) - nrows_scrolled);
+ = make_fixnum (XFASTINT (w->window_end_vpos) - nrows_scrolled);
}
w->window_end_valid = Qnil;
/* We have to compute the window end anew since text
can have been added/removed after it. */
w->window_end_pos
- = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
+ = make_fixnum (Z - MATRIX_ROW_END_CHARPOS (row));
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
first_unchanged_at_end_row);
xassert (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
- w->window_end_pos = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
+ w->window_end_pos = make_fixnum (Z - MATRIX_ROW_END_CHARPOS (row));
w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
w->window_end_vpos
- = make_number (MATRIX_ROW_VPOS (row, w->current_matrix));
+ = make_fixnum (MATRIX_ROW_VPOS (row, w->current_matrix));
xassert (w->window_end_bytepos >= 0);
IF_DEBUG (debug_method_add (w, "A"));
}
else if (last_text_row_at_end)
{
w->window_end_pos
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end));
+ = make_fixnum (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end));
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row_at_end);
w->window_end_vpos
- = make_number (MATRIX_ROW_VPOS (last_text_row_at_end, desired_matrix));
+ = make_fixnum (MATRIX_ROW_VPOS (last_text_row_at_end, desired_matrix));
xassert (w->window_end_bytepos >= 0);
IF_DEBUG (debug_method_add (w, "B"));
}
end of the window, i.e. the last row with text is to be found
in the desired matrix. */
w->window_end_pos
- = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
+ = make_fixnum (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
w->window_end_bytepos
= Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
w->window_end_vpos
- = make_number (MATRIX_ROW_VPOS (last_text_row, desired_matrix));
+ = make_fixnum (MATRIX_ROW_VPOS (last_text_row, desired_matrix));
xassert (w->window_end_bytepos >= 0);
}
else if (first_unchanged_at_end_row == NULL
}
xassert (row != NULL);
- w->window_end_vpos = make_number (vpos + 1);
- w->window_end_pos = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
+ w->window_end_vpos = make_fixnum (vpos + 1);
+ w->window_end_pos = make_fixnum (Z - MATRIX_ROW_END_CHARPOS (row));
w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
xassert (w->window_end_bytepos >= 0);
IF_DEBUG (debug_method_add (w, "C"));
CHECK_NUMBER (row, 0);
dump_glyph_row (XWINDOW (selected_window)->current_matrix,
XINT (row),
- INTEGERP (glyphs) ? XINT (glyphs) : 2);
+ FIXNUMP (glyphs) ? XINT (glyphs) : 2);
return Qnil;
}
{
struct frame *sf = SELECTED_FRAME ();
struct glyph_matrix *m = (XWINDOW (sf->tool_bar_window)->current_matrix);
- dump_glyph_row (m, XINT (row), INTEGERP (glyphs) ? XINT (glyphs) : 2);
+ dump_glyph_row (m, XINT (row), FIXNUMP (glyphs) ? XINT (glyphs) : 2);
return Qnil;
}
p += it.len;
/* Get its face. */
- ilisp = make_number (p - arrow_string);
+ ilisp = make_fixnum (p - arrow_string);
face = Fget_text_property (ilisp, Qface, Voverlay_arrow_string);
it.face_id = compute_char_face (f, it.c, face);
truncate_it.glyph_row = &scratch_glyph_row;
truncate_it.glyph_row->used[TEXT_AREA] = 0;
CHARPOS (truncate_it.position) = BYTEPOS (truncate_it.position) = -1;
- truncate_it.object = make_number (0);
+ truncate_it.object = make_fixnum (0);
produce_special_glyphs (&truncate_it, IT_TRUNCATION);
/* Overwrite glyphs from IT with truncation glyphs. */
it->what = IT_CHARACTER;
bzero (&it->position, sizeof it->position);
- it->object = make_number (0);
+ it->object = make_fixnum (0);
it->c = ' ';
it->len = 1;
it->what = IT_CHARACTER;
bzero (&it->position, sizeof it->position);
- it->object = make_number (0);
+ it->object = make_fixnum (0);
it->c = ' ';
it->len = 1;
it->face_id = face->id;
and continuation glyphs. */
while (glyph >= start
&& glyph->type == CHAR_GLYPH
- && INTEGERP (glyph->object))
+ && FIXNUMP (glyph->object))
--glyph;
/* If last glyph is a space or stretch, and it's trailing
break;
/* Remember where item was displayed. */
- AREF (items, i + 3) = make_number (it.hpos);
+ AREF (items, i + 3) = make_fixnum (it.hpos);
/* Display the item, pad with one space. */
if (it.current_x < it.last_visible_x)
elt = XCAR (elt);
goto tail_recurse;
}
- else if (INTEGERP (car))
+ else if (FIXNUMP (car))
{
register int lim = XINT (car);
elt = XCDR (elt);
eoltype = eol_mnemonic_undecided;
else if (VECTORP (eolvalue)) /* Not yet decided. */
eoltype = eol_mnemonic_undecided;
- else /* INTEGERP (eolvalue) -- 0:LF, 1:CRLF, 2:CR */
+ else /* FIXNUMP (eolvalue) -- 0:LF, 1:CRLF, 2:CR */
eoltype = (XFASTINT (eolvalue) == 0
? eol_mnemonic_unix
: (XFASTINT (eolvalue) == 1
eol_str = XSTRING (eoltype)->data;
eol_str_len = XSTRING (eoltype)->size;
}
- else if (INTEGERP (eoltype)
+ else if (FIXNUMP (eoltype)
&& CHAR_VALID_P (XINT (eoltype), 0))
{
eol_str = (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH);
case 'c':
{
int col = current_column ();
- w->column_number_displayed = make_number (col);
+ w->column_number_displayed = make_fixnum (col);
pint2str (decode_mode_spec_buf, field_width, col);
return decode_mode_spec_buf;
}
w->base_line_pos = Qnil;
/* If the buffer is very big, don't waste time. */
- if (INTEGERP (Vline_number_display_limit)
+ if (FIXNUMP (Vline_number_display_limit)
&& BUF_ZV (b) - BUF_BEGV (b) > XINT (Vline_number_display_limit))
{
w->base_line_pos = Qnil;
go back past it. */
if (startpos == BUF_BEGV (b))
{
- w->base_line_number = make_number (topline);
- w->base_line_pos = make_number (BUF_BEGV (b));
+ w->base_line_number = make_fixnum (topline);
+ w->base_line_pos = make_fixnum (BUF_BEGV (b));
}
else if (nlines < height + 25 || nlines > height * 3 + 50
|| linepos == BUF_BEGV (b))
goto no_value;
}
- w->base_line_number = make_number (topline - nlines);
- w->base_line_pos = make_number (BYTE_TO_CHAR (position));
+ w->base_line_number = make_fixnum (topline - nlines);
+ w->base_line_pos = make_fixnum (BYTE_TO_CHAR (position));
}
/* Now count lines from the start pos to point. */
/* If we are not in selective display mode,
check only for newlines. */
int selective_display = (!NILP (current_buffer->selective_display)
- && !INTEGERP (current_buffer->selective_display));
+ && !FIXNUMP (current_buffer->selective_display));
if (count > 0)
{
"Maximum number of lines to keep in the message log buffer.\n\
If nil, disable message logging. If t, log messages but don't truncate\n\
the buffer when it becomes large.");
- Vmessage_log_max = make_number (50);
+ Vmessage_log_max = make_fixnum (50);
DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions,
"Functions called before redisplay, if window sizes have changed.\n\
Otherwise, value should be a pair of integers `(HORZ : VERT)' with\n\
HORZ specifying the horizontal margin, and VERT specifying the\n\
vertical margin.");
- Vtool_bar_button_margin = make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN);
+ Vtool_bar_button_margin = make_fixnum (DEFAULT_TOOL_BAR_BUTTON_MARGIN);
DEFVAR_INT ("tool-bar-button-relief", &tool_bar_button_relief,
"Relief thickness of tool-bar buttons.");
struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (root_window)));
int i;
- XWINDOW (root_window)->top = make_number (FRAME_TOP_MARGIN (f));
+ XWINDOW (root_window)->top = make_fixnum (FRAME_TOP_MARGIN (f));
set_window_height (root_window,
FRAME_HEIGHT (f) - 1 - FRAME_TOP_MARGIN (f),
0);
- mini_w->top = make_number (FRAME_HEIGHT (f) - 1);
+ mini_w->top = make_fixnum (FRAME_HEIGHT (f) - 1);
set_window_height (minibuf_window, 1, 0);
- XWINDOW (root_window)->width = make_number (FRAME_WIDTH (f));
- mini_w->width = make_number (FRAME_WIDTH (f));
+ XWINDOW (root_window)->width = make_fixnum (FRAME_WIDTH (f));
+ mini_w->width = make_fixnum (FRAME_WIDTH (f));
scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
scratch_glyph_row.glyphs[TEXT_AREA + 1]
/* The default ellipsis glyphs `...'. */
for (i = 0; i < 3; ++i)
- default_invis_vector[i] = make_number ('.');
+ default_invis_vector[i] = make_fixnum ('.');
}
#ifdef HAVE_WINDOW_SYSTEM
Lisp_Object coldesc;
XSETFRAME (frame, f);
- coldesc = call2 (Qtty_color_by_index, make_number (idx), frame);
+ coldesc = call2 (Qtty_color_by_index, make_fixnum (idx), frame);
if (!NILP (coldesc))
return XCAR (coldesc);
/* Get the list of fonts matching pattern. 100 should suffice. */
nfonts = DEFAULT_FONT_LIST_LIMIT;
- if (INTEGERP (Vfont_list_limit) && XINT (Vfont_list_limit) > 0)
+ if (FIXNUMP (Vfont_list_limit) && XINT (Vfont_list_limit) > 0)
nfonts = XFASTINT (Vfont_list_limit);
*fonts = (struct font_name *) xmalloc (nfonts * sizeof **fonts);
nfonts = font_list (f, Qnil, family, Qnil, &fonts);
for (i = nfonts - 1; i >= 0; --i)
{
- Lisp_Object v = Fmake_vector (make_number (8), Qnil);
+ Lisp_Object v = Fmake_vector (make_fixnum (8), Qnil);
char *tem;
ASET (v, 0, build_string (fonts[i].fields[XLFD_FAMILY]));
ASET (v, 1, xlfd_symbolic_swidth (fonts + i));
- ASET (v, 2, make_number (xlfd_point_size (f, fonts + i)));
+ ASET (v, 2, make_fixnum (xlfd_point_size (f, fonts + i)));
ASET (v, 3, xlfd_symbolic_weight (fonts + i));
ASET (v, 4, xlfd_symbolic_slant (fonts + i));
ASET (v, 5, xlfd_fixed_p (fonts + i) ? Qt : Qnil);
fonts until we have them all. */
for (limit = 500;;)
{
- specbind (intern ("font-list-limit"), make_number (limit));
+ specbind (intern ("font-list-limit"), make_fixnum (limit));
nfonts = font_list (f, Qnil, Qnil, Qnil, &fonts);
if (nfonts == limit)
xassert (UNSPECIFIEDP (attrs[LFACE_SWIDTH_INDEX])
|| SYMBOLP (attrs[LFACE_SWIDTH_INDEX]));
xassert (UNSPECIFIEDP (attrs[LFACE_AVGWIDTH_INDEX])
- || INTEGERP (attrs[LFACE_AVGWIDTH_INDEX]));
+ || FIXNUMP (attrs[LFACE_AVGWIDTH_INDEX]));
xassert (UNSPECIFIEDP (attrs[LFACE_HEIGHT_INDEX])
- || INTEGERP (attrs[LFACE_HEIGHT_INDEX])
+ || FIXNUMP (attrs[LFACE_HEIGHT_INDEX])
|| FLOATP (attrs[LFACE_HEIGHT_INDEX])
|| FUNCTIONP (attrs[LFACE_HEIGHT_INDEX]));
xassert (UNSPECIFIEDP (attrs[LFACE_WEIGHT_INDEX])
xassert (UNSPECIFIEDP (attrs[LFACE_BOX_INDEX])
|| SYMBOLP (attrs[LFACE_BOX_INDEX])
|| STRINGP (attrs[LFACE_BOX_INDEX])
- || INTEGERP (attrs[LFACE_BOX_INDEX])
+ || FIXNUMP (attrs[LFACE_BOX_INDEX])
|| CONSP (attrs[LFACE_BOX_INDEX]));
xassert (UNSPECIFIEDP (attrs[LFACE_INVERSE_INDEX])
|| SYMBOLP (attrs[LFACE_INVERSE_INDEX]));
else
pt = pixel_point_size (f, font_info->height * 10);
xassert (pt > 0);
- LFACE_HEIGHT (lface) = make_number (pt);
+ LFACE_HEIGHT (lface) = make_fixnum (pt);
}
if (force_p || UNSPECIFIEDP (LFACE_SWIDTH (lface)))
if (force_p || UNSPECIFIEDP (LFACE_AVGWIDTH (lface)))
LFACE_AVGWIDTH (lface)
= (have_xlfd_p
- ? make_number (font.numeric[XLFD_AVGWIDTH])
+ ? make_fixnum (font.numeric[XLFD_AVGWIDTH])
: Qunspecified);
if (force_p || UNSPECIFIEDP (LFACE_WEIGHT (lface)))
{
int result = 0;
- if (INTEGERP (from))
+ if (FIXNUMP (from))
result = XINT (from);
else if (NUMBERP (from))
result = XFLOATINT (from) * XINT (to);
{
if (EQ (XCAR(from), Qplus) || EQ (XCAR(from), Qminus))
{
- if (INTEGERP (XCAR (XCDR (from))))
+ if (FIXNUMP (XCAR (XCDR (from))))
{
int inc = XINT (XCAR (XCDR (from)));
if (EQ (XCAR (from), Qminus))
}
if (result > 0)
- return make_number (result);
+ return make_fixnum (result);
else
return invalid;
}
for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
if (!UNSPECIFIEDP (from[i]))
- if (i == LFACE_HEIGHT_INDEX && !INTEGERP (from[i]))
+ if (i == LFACE_HEIGHT_INDEX && !FIXNUMP (from[i]))
to[i] = merge_face_heights (from[i], to[i], to[i], cycle_check);
else
to[i] = from[i];
#define CYCLE_CHECK(check, el, suspicious) \
(NILP (check) \
- ? make_number (0) \
- : (INTEGERP (check) \
+ ? make_fixnum (0) \
+ : (FIXNUMP (check) \
? (XFASTINT (check) < (suspicious) \
- ? make_number (XFASTINT (check) + 1) \
+ ? make_fixnum (XFASTINT (check) + 1) \
: Fcons (el, Qnil)) \
: (!NILP (Fmemq ((el), (check))) \
? Qnil \
else if (EQ (keyword, QCbox))
{
if (EQ (value, Qt))
- value = make_number (1);
- if (INTEGERP (value)
+ value = make_fixnum (1);
+ if (FIXNUMP (value)
|| STRINGP (value)
|| CONSP (value)
|| NILP (value))
/* Add a global definition if there is none. */
if (NILP (global_lface))
{
- global_lface = Fmake_vector (make_number (LFACE_VECTOR_SIZE),
+ global_lface = Fmake_vector (make_fixnum (LFACE_VECTOR_SIZE),
Qunspecified);
AREF (global_lface, 0) = Qface;
Vface_new_frame_defaults = Fcons (Fcons (face, global_lface),
}
lface_id_to_name[next_lface_id] = face;
- Fput (face, Qface, make_number (next_lface_id));
+ Fput (face, Qface, make_fixnum (next_lface_id));
++next_lface_id;
}
else if (f == NULL)
{
if (NILP (lface))
{
- lface = Fmake_vector (make_number (LFACE_VECTOR_SIZE),
+ lface = Fmake_vector (make_fixnum (LFACE_VECTOR_SIZE),
Qunspecified);
AREF (lface, 0) = Qface;
f->face_alist = Fcons (Fcons (face, lface), f->face_alist);
/* If FRAME is 0, change face on all frames, and change the
default for new frames. */
- if (INTEGERP (frame) && XINT (frame) == 0)
+ if (FIXNUMP (frame) && XINT (frame) == 0)
{
Lisp_Object tail;
Finternal_set_lisp_face_attribute (face, attr, value, Qt);
(EQ (face, Qdefault) ? value :
/* The default face must have an absolute size, otherwise, we do
a test merge with a random height to see if VALUE's ok. */
- merge_face_heights (value, make_number(10), Qnil, Qnil));
+ merge_face_heights (value, make_fixnum(10), Qnil, Qnil));
- if (!INTEGERP(test) || XINT(test) <= 0)
+ if (!FIXNUMP(test) || XINT(test) <= 0)
signal_error ("Invalid face height", value);
}
/* Allow t meaning a simple box of width 1 in foreground color
of the face. */
if (EQ (value, Qt))
- value = make_number (1);
+ value = make_fixnum (1);
if (UNSPECIFIEDP (value))
valid_p = 1;
else if (NILP (value))
valid_p = 1;
- else if (INTEGERP (value))
+ else if (FIXNUMP (value))
valid_p = XINT (value) != 0;
else if (STRINGP (value))
valid_p = XSTRING (value)->size > 0;
if (EQ (k, QCline_width))
{
- if (!INTEGERP (v) || XINT (v) == 0)
+ if (!FIXNUMP (v) || XINT (v) == 0)
break;
}
else if (EQ (k, QCcolor))
Lisp_Object value;
int signal_p;
{
- Lisp_Object result = make_number (0);
+ Lisp_Object result = make_fixnum (0);
xassert (STRINGP (value));
value = Qunspecified;
else if (EQ (attr, QCheight))
{
- value = Fstring_to_number (value, make_number (10));
+ value = Fstring_to_number (value, make_fixnum (10));
if (XINT (value) <= 0)
signal_error ("Invalid face height from X resource", value);
}
{
/* Look up a face for a slightly smaller/larger font. */
pt += delta;
- attrs[LFACE_HEIGHT_INDEX] = make_number (pt);
+ attrs[LFACE_HEIGHT_INDEX] = make_fixnum (pt);
new_face_id = lookup_face (f, attrs, 0, NULL);
new_face = FACE_FROM_ID (f, new_face_id);
face = FACE_FROM_ID (f, face_id);
bcopy (face->lface, attrs, sizeof attrs);
- attrs[LFACE_HEIGHT_INDEX] = make_number (height);
+ attrs[LFACE_HEIGHT_INDEX] = make_fixnum (height);
face_id = lookup_face (f, attrs, 0, NULL);
#endif /* HAVE_WINDOW_SYSTEM */
{
LFACE_FAMILY (lface) = build_string ("default");
LFACE_SWIDTH (lface) = Qnormal;
- LFACE_HEIGHT (lface) = make_number (1);
+ LFACE_HEIGHT (lface) = make_fixnum (1);
LFACE_WEIGHT (lface) = Qnormal;
LFACE_SLANT (lface) = Qnormal;
LFACE_AVGWIDTH (lface) = Qunspecified;
face->box = FACE_SIMPLE_BOX;
face->box_line_width = 1;
}
- else if (INTEGERP (box))
+ else if (FIXNUMP (box))
{
/* Simple box of specified line width in foreground color of the
face. */
if (EQ (keyword, QCline_width))
{
- if (INTEGERP (value) && XINT (value) != 0)
+ if (FIXNUMP (value) && XINT (value) != 0)
face->box_line_width = XINT (value);
}
else if (EQ (keyword, QCcolor))
prop = Fget_text_property (position, propname, w->buffer);
XSETFASTINT (limit1, (limit < endpos ? limit : endpos));
end = Fnext_single_property_change (position, propname, w->buffer, limit1);
- if (INTEGERP (end))
+ if (FIXNUMP (end))
endpos = XINT (end);
/* Look at properties from overlays. */
short, so set the limit to the end of the string. */
XSETFASTINT (limit, XSTRING (string)->size);
end = Fnext_single_property_change (position, prop_name, string, limit);
- if (INTEGERP (end))
+ if (FIXNUMP (end))
*endptr = XFASTINT (end);
else
*endptr = -1;
fprintf (stderr, "\n");
for (i = 0; i < FRAME_FACE_CACHE (SELECTED_FRAME ())->used; ++i)
- Fdump_face (make_number (i));
+ Fdump_face (make_fixnum (i));
}
else
{
"*Limit for font matching.\n\
If an integer > 0, font matching functions won't load more than\n\
that number of fonts when searching for a matching font.");
- Vfont_list_limit = make_number (DEFAULT_FONT_LIST_LIMIT);
+ Vfont_list_limit = make_fixnum (DEFAULT_FONT_LIST_LIMIT);
DEFVAR_LISP ("face-new-frame-defaults", &Vface_new_frame_defaults,
"List of global face definitions (for internal use only.)");
for (i = 0; i < sizeof (x_frame_parms) / sizeof (x_frame_parms[0]); i++)
Fput (intern (x_frame_parms[i].name), Qx_frame_parameter,
- make_number (i));
+ make_fixnum (i));
}
\f
/* Change the parameters of frame F as specified by ALIST.
{
left_no_change = 1;
if (f->output_data.x->left_pos < 0)
- left = Fcons (Qplus, Fcons (make_number (f->output_data.x->left_pos), Qnil));
+ left = Fcons (Qplus, Fcons (make_fixnum (f->output_data.x->left_pos), Qnil));
else
XSETINT (left, f->output_data.x->left_pos);
}
{
top_no_change = 1;
if (f->output_data.x->top_pos < 0)
- top = Fcons (Qplus, Fcons (make_number (f->output_data.x->top_pos), Qnil));
+ top = Fcons (Qplus, Fcons (make_fixnum (f->output_data.x->top_pos), Qnil));
else
XSETINT (top, f->output_data.x->top_pos);
}
/* If one of the icon positions was not set, preserve or default it. */
- if (EQ (icon_left, Qunbound) || ! INTEGERP (icon_left))
+ if (EQ (icon_left, Qunbound) || ! FIXNUMP (icon_left))
{
icon_left_no_change = 1;
icon_left = Fcdr (Fassq (Qicon_left, f->param_alist));
if (NILP (icon_left))
XSETINT (icon_left, 0);
}
- if (EQ (icon_top, Qunbound) || ! INTEGERP (icon_top))
+ if (EQ (icon_top, Qunbound) || ! FIXNUMP (icon_top))
{
icon_top_no_change = 1;
icon_top = Fcdr (Fassq (Qicon_top, f->param_alist));
if (width != FRAME_WIDTH (f)
|| height != FRAME_HEIGHT (f)
|| FRAME_NEW_HEIGHT (f) || FRAME_NEW_WIDTH (f))
- Fset_frame_size (frame, make_number (width), make_number (height));
+ Fset_frame_size (frame, make_fixnum (width), make_fixnum (height));
if ((!NILP (left) || !NILP (top))
&& ! (left_no_change && top_no_change)
f->output_data.x->size_hint_flags &= ~ (XNegative | YNegative);
if (EQ (left, Qminus))
f->output_data.x->size_hint_flags |= XNegative;
- else if (INTEGERP (left))
+ else if (FIXNUMP (left))
{
leftpos = XINT (left);
if (leftpos < 0)
}
else if (CONSP (left) && EQ (XCAR (left), Qminus)
&& CONSP (XCDR (left))
- && INTEGERP (XCAR (XCDR (left))))
+ && FIXNUMP (XCAR (XCDR (left))))
{
leftpos = - XINT (XCAR (XCDR (left)));
f->output_data.x->size_hint_flags |= XNegative;
}
else if (CONSP (left) && EQ (XCAR (left), Qplus)
&& CONSP (XCDR (left))
- && INTEGERP (XCAR (XCDR (left))))
+ && FIXNUMP (XCAR (XCDR (left))))
{
leftpos = XINT (XCAR (XCDR (left)));
}
if (EQ (top, Qminus))
f->output_data.x->size_hint_flags |= YNegative;
- else if (INTEGERP (top))
+ else if (FIXNUMP (top))
{
toppos = XINT (top);
if (toppos < 0)
}
else if (CONSP (top) && EQ (XCAR (top), Qminus)
&& CONSP (XCDR (top))
- && INTEGERP (XCAR (XCDR (top))))
+ && FIXNUMP (XCAR (XCDR (top))))
{
toppos = - XINT (XCAR (XCDR (top)));
f->output_data.x->size_hint_flags |= YNegative;
}
else if (CONSP (top) && EQ (XCAR (top), Qplus)
&& CONSP (XCDR (top))
- && INTEGERP (XCAR (XCDR (top))))
+ && FIXNUMP (XCAR (XCDR (top))))
{
toppos = XINT (XCAR (XCDR (top)));
}
store_in_alist (alistptr, Qtop, Fcons (Qplus, Fcons (tem, Qnil)));
store_in_alist (alistptr, Qborder_width,
- make_number (f->output_data.x->border_width));
+ make_fixnum (f->output_data.x->border_width));
store_in_alist (alistptr, Qinternal_border_width,
- make_number (f->output_data.x->internal_border_width));
+ make_fixnum (f->output_data.x->internal_border_width));
sprintf (buf, "%ld", (long) FRAME_X_WINDOW (f));
store_in_alist (alistptr, Qwindow_id,
build_string (buf));
}
else if (CONSP (arg)
&& EQ (XCAR (arg), Qbar)
- && INTEGERP (XCDR (arg))
+ && FIXNUMP (XCDR (arg))
&& XINT (XCDR (arg)) >= 0)
{
type = BAR_CURSOR;
XSETFASTINT (w->top, XFASTINT (w->top) + n);
XSETFASTINT (w->height, XFASTINT (w->height) - n);
- if (INTEGERP (w->orig_top))
+ if (FIXNUMP (w->orig_top))
XSETFASTINT (w->orig_top, XFASTINT (w->orig_top) + n);
- if (INTEGERP (w->orig_height))
+ if (FIXNUMP (w->orig_height))
XSETFASTINT (w->orig_height, XFASTINT (w->orig_height) - n);
/* Handle just the top child in a vertical split. */
if (FRAME_MINIBUF_ONLY_P (f))
return;
- if (INTEGERP (value))
+ if (FIXNUMP (value))
nlines = XINT (value);
else
nlines = 0;
return;
/* Use VALUE only if an integer >= 0. */
- if (INTEGERP (value) && XINT (value) >= 0)
+ if (FIXNUMP (value) && XINT (value) >= 0)
nlines = XFASTINT (value);
else
nlines = 0;
x_set_window_size (f, 0, FRAME_WIDTH (f), FRAME_HEIGHT (f));
do_pending_window_change (0);
}
- else if (INTEGERP (arg) && XINT (arg) > 0
+ else if (FIXNUMP (arg) && XINT (arg) > 0
&& XFASTINT (arg) != FRAME_SCROLL_BAR_PIXEL_WIDTH (f))
{
if (XFASTINT (arg) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM)
switch (type)
{
case RES_TYPE_NUMBER:
- return make_number (atoi (XSTRING (tem)->data));
+ return make_fixnum (atoi (XSTRING (tem)->data));
case RES_TYPE_FLOAT:
return make_float (atof (XSTRING (tem)->data));
Lisp_Object element;
if (x >= 0 && (geometry & XNegative))
- element = Fcons (Qleft, Fcons (Qminus, Fcons (make_number (-x), Qnil)));
+ element = Fcons (Qleft, Fcons (Qminus, Fcons (make_fixnum (-x), Qnil)));
else if (x < 0 && ! (geometry & XNegative))
- element = Fcons (Qleft, Fcons (Qplus, Fcons (make_number (x), Qnil)));
+ element = Fcons (Qleft, Fcons (Qplus, Fcons (make_fixnum (x), Qnil)));
else
- element = Fcons (Qleft, make_number (x));
+ element = Fcons (Qleft, make_fixnum (x));
result = Fcons (element, result);
}
Lisp_Object element;
if (y >= 0 && (geometry & YNegative))
- element = Fcons (Qtop, Fcons (Qminus, Fcons (make_number (-y), Qnil)));
+ element = Fcons (Qtop, Fcons (Qminus, Fcons (make_fixnum (-y), Qnil)));
else if (y < 0 && ! (geometry & YNegative))
- element = Fcons (Qtop, Fcons (Qplus, Fcons (make_number (y), Qnil)));
+ element = Fcons (Qtop, Fcons (Qplus, Fcons (make_fixnum (y), Qnil)));
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;
}
}
else if (CONSP (tem0) && EQ (XCAR (tem0), Qminus)
&& CONSP (XCDR (tem0))
- && INTEGERP (XCAR (XCDR (tem0))))
+ && FIXNUMP (XCAR (XCDR (tem0))))
{
f->output_data.x->top_pos = - XINT (XCAR (XCDR (tem0)));
window_prompting |= YNegative;
}
else if (CONSP (tem0) && EQ (XCAR (tem0), Qplus)
&& CONSP (XCDR (tem0))
- && INTEGERP (XCAR (XCDR (tem0))))
+ && FIXNUMP (XCAR (XCDR (tem0))))
{
f->output_data.x->top_pos = XINT (XCAR (XCDR (tem0)));
}
}
else if (CONSP (tem1) && EQ (XCAR (tem1), Qminus)
&& CONSP (XCDR (tem1))
- && INTEGERP (XCAR (XCDR (tem1))))
+ && FIXNUMP (XCAR (XCDR (tem1))))
{
f->output_data.x->left_pos = - XINT (XCAR (XCDR (tem1)));
window_prompting |= XNegative;
}
else if (CONSP (tem1) && EQ (XCAR (tem1), Qplus)
&& CONSP (XCDR (tem1))
- && INTEGERP (XCAR (XCDR (tem1))))
+ && FIXNUMP (XCAR (XCDR (tem1))))
{
f->output_data.x->left_pos = XINT (XCAR (XCDR (tem1)));
}
xlwmenu_default_font = f->output_data.x->font;
#endif
- x_default_parameter (f, parms, Qborder_width, make_number (2),
+ x_default_parameter (f, parms, Qborder_width, make_fixnum (2),
"borderWidth", "BorderWidth", RES_TYPE_NUMBER);
/* This defaults to 2 in order to match xterm. We recognize either
parms = Fcons (Fcons (Qinternal_border_width, value),
parms);
}
- x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
+ x_default_parameter (f, parms, Qinternal_border_width, make_fixnum (1),
"internalBorderWidth", "internalBorderWidth",
RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qvertical_scroll_bars, Qleft,
happen. */
init_frame_faces (f);
- x_default_parameter (f, parms, Qmenu_bar_lines, make_number (1),
+ x_default_parameter (f, parms, Qmenu_bar_lines, make_fixnum (1),
"menuBar", "MenuBar", RES_TYPE_NUMBER);
- x_default_parameter (f, parms, Qtool_bar_lines, make_number (1),
+ x_default_parameter (f, parms, Qtool_bar_lines, make_fixnum (1),
"toolBar", "ToolBar", RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
"bufferPredicate", "BufferPredicate",
? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF);
- if (INTEGERP (Vtool_bar_button_margin)
+ if (FIXNUMP (Vtool_bar_button_margin)
&& XINT (Vtool_bar_button_margin) > 0)
margin = XFASTINT (Vtool_bar_button_margin);
else if (CONSP (Vtool_bar_button_margin)
- && INTEGERP (XCDR (Vtool_bar_button_margin))
+ && FIXNUMP (XCDR (Vtool_bar_button_margin))
&& XINT (XCDR (Vtool_bar_button_margin)) > 0)
margin = XFASTINT (XCDR (Vtool_bar_button_margin));
else
{
Lisp_Object rgb[3];
- rgb[0] = make_number (foo.red);
- rgb[1] = make_number (foo.green);
- rgb[2] = make_number (foo.blue);
+ rgb[0] = make_fixnum (foo.red);
+ rgb[1] = make_fixnum (foo.green);
+ rgb[2] = make_fixnum (foo.blue);
return Flist (3, rgb);
}
else
{
struct x_display_info *dpyinfo = check_x_display_info (display);
- return make_number (dpyinfo->width);
+ return make_fixnum (dpyinfo->width);
}
DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
{
struct x_display_info *dpyinfo = check_x_display_info (display);
- return make_number (dpyinfo->height);
+ return make_fixnum (dpyinfo->height);
}
DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
{
struct x_display_info *dpyinfo = check_x_display_info (display);
- return make_number (dpyinfo->n_planes);
+ return make_fixnum (dpyinfo->n_planes);
}
DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
{
struct x_display_info *dpyinfo = check_x_display_info (display);
- return make_number (DisplayCells (dpyinfo->display,
+ return make_fixnum (DisplayCells (dpyinfo->display,
XScreenNumberOfScreen (dpyinfo->screen)));
}
{
struct x_display_info *dpyinfo = check_x_display_info (display);
- return make_number (MAXREQUEST (dpyinfo->display));
+ return make_fixnum (MAXREQUEST (dpyinfo->display));
}
DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
struct x_display_info *dpyinfo = check_x_display_info (display);
Display *dpy = dpyinfo->display;
- return Fcons (make_number (ProtocolVersion (dpy)),
- Fcons (make_number (ProtocolRevision (dpy)),
- Fcons (make_number (VendorRelease (dpy)), Qnil)));
+ return Fcons (make_fixnum (ProtocolVersion (dpy)),
+ Fcons (make_fixnum (ProtocolRevision (dpy)),
+ Fcons (make_fixnum (VendorRelease (dpy)), Qnil)));
}
DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
{
struct x_display_info *dpyinfo = check_x_display_info (display);
- return make_number (ScreenCount (dpyinfo->display));
+ return make_fixnum (ScreenCount (dpyinfo->display));
}
DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
{
struct x_display_info *dpyinfo = check_x_display_info (display);
- return make_number (HeightMMOfScreen (dpyinfo->screen));
+ return make_fixnum (HeightMMOfScreen (dpyinfo->screen));
}
DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
{
struct x_display_info *dpyinfo = check_x_display_info (display);
- return make_number (WidthMMOfScreen (dpyinfo->screen));
+ return make_fixnum (WidthMMOfScreen (dpyinfo->screen));
}
DEFUN ("x-display-backing-store", Fx_display_backing_store,
break;
case IMAGE_POSITIVE_INTEGER_VALUE:
- if (!INTEGERP (value) || XINT (value) <= 0)
+ if (!FIXNUMP (value) || XINT (value) <= 0)
return 0;
break;
case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR:
- if (INTEGERP (value) && XINT (value) >= 0)
+ if (FIXNUMP (value) && XINT (value) >= 0)
break;
if (CONSP (value)
- && INTEGERP (XCAR (value)) && INTEGERP (XCDR (value))
+ && FIXNUMP (XCAR (value)) && FIXNUMP (XCDR (value))
&& XINT (XCAR (value)) >= 0 && XINT (XCDR (value)) >= 0)
break;
return 0;
case IMAGE_ASCENT_VALUE:
if (SYMBOLP (value) && EQ (value, Qcenter))
break;
- else if (INTEGERP (value)
+ else if (FIXNUMP (value)
&& XINT (value) >= 0
&& XINT (value) <= 100)
break;
return 0;
case IMAGE_NON_NEGATIVE_INTEGER_VALUE:
- if (!INTEGERP (value) || XINT (value) < 0)
+ if (!FIXNUMP (value) || XINT (value) < 0)
return 0;
break;
return 0;
case IMAGE_NUMBER_VALUE:
- if (!INTEGERP (value) && !FLOATP (value))
+ if (!FIXNUMP (value) && !FLOATP (value))
return 0;
break;
case IMAGE_INTEGER_VALUE:
- if (!INTEGERP (value))
+ if (!FIXNUMP (value))
return 0;
break;
size = Fcons (make_float ((double) width / CANON_X_UNIT (f)),
make_float ((double) height / CANON_Y_UNIT (f)));
else
- size = Fcons (make_number (width), make_number (height));
+ size = Fcons (make_fixnum (width), make_fixnum (height));
}
else
error ("Invalid image specification");
{
struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
- if (c && INTEGERP (Vimage_cache_eviction_delay))
+ if (c && FIXNUMP (Vimage_cache_eviction_delay))
{
EMACS_TIME t;
unsigned long old;
Lisp_Object value;
value = image_spec_value (spec, QCwidth, NULL);
- img->width = (INTEGERP (value)
+ img->width = (FIXNUMP (value)
? XFASTINT (value) : DEFAULT_IMAGE_WIDTH);
value = image_spec_value (spec, QCheight, NULL);
- img->height = (INTEGERP (value)
+ img->height = (FIXNUMP (value)
? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
}
else
Lisp_Object ascent, margin, relief;
ascent = image_spec_value (spec, QCascent, NULL);
- if (INTEGERP (ascent))
+ if (FIXNUMP (ascent))
img->ascent = XFASTINT (ascent);
else if (EQ (ascent, Qcenter))
img->ascent = CENTERED_IMAGE_ASCENT;
margin = image_spec_value (spec, QCmargin, NULL);
- if (INTEGERP (margin) && XINT (margin) >= 0)
+ if (FIXNUMP (margin) && XINT (margin) >= 0)
img->vmargin = img->hmargin = XFASTINT (margin);
- else if (CONSP (margin) && INTEGERP (XCAR (margin))
- && INTEGERP (XCDR (margin)))
+ else if (CONSP (margin) && FIXNUMP (XCAR (margin))
+ && FIXNUMP (XCDR (margin)))
{
if (XINT (XCAR (margin)) > 0)
img->hmargin = XFASTINT (XCAR (margin));
}
relief = image_spec_value (spec, QCrelief, NULL);
- if (INTEGERP (relief))
+ if (FIXNUMP (relief))
{
img->relief = XINT (relief);
img->hmargin += abs (img->relief);
}
if (NILP (color_adjust))
- color_adjust = make_number (0xffff / 2);
+ color_adjust = make_fixnum (0xffff / 2);
if (i == 9 && NUMBERP (color_adjust))
x_detect_edges (f, img, trans, (int) XFLOATINT (color_adjust));
}
image = image_spec_value (img->spec, QCindex, NULL);
- ino = INTEGERP (image) ? XFASTINT (image) : 0;
+ ino = FIXNUMP (image) ? XFASTINT (image) : 0;
if (ino >= gif->ImageCount)
{
image_error ("Invalid image number `%s' in image `%s'",
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;
if (XVECTOR (tem)->size != 4)
return 0;
for (i = 0; i < 4; ++i)
- if (!INTEGERP (XVECTOR (tem)->contents[i]))
+ if (!FIXNUMP (XVECTOR (tem)->contents[i]))
return 0;
}
else
loader = intern ("gs-load-image");
img->data.lisp_val = 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);
UNGCPRO;
cancel_hourglass ();
- if (INTEGERP (Vhourglass_delay)
+ if (FIXNUMP (Vhourglass_delay)
&& XINT (Vhourglass_delay) > 0)
secs = XFASTINT (Vhourglass_delay);
else if (FLOATP (Vhourglass_delay)
"font", "Font", RES_TYPE_STRING);
}
- x_default_parameter (f, parms, Qborder_width, make_number (2),
+ x_default_parameter (f, parms, Qborder_width, make_fixnum (2),
"borderWidth", "BorderWidth", RES_TYPE_NUMBER);
/* This defaults to 2 in order to match xterm. We recognize either
parms);
}
- x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
+ x_default_parameter (f, parms, Qinternal_border_width, make_fixnum (1),
"internalBorderWidth", "internalBorderWidth",
RES_TYPE_NUMBER);
/* Move the tooltip window where the mouse pointer is. Resize and
show it. */
- if (!INTEGERP (left) && !INTEGERP (top))
+ if (!FIXNUMP (left) && !FIXNUMP (top))
{
BLOCK_INPUT;
XQueryPointer (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
UNBLOCK_INPUT;
}
- if (INTEGERP (top))
+ if (FIXNUMP (top))
*root_y = XINT (top);
else if (*root_y + XINT (dy) - height < 0)
*root_y -= XINT (dy);
*root_y += XINT (dy);
}
- if (INTEGERP (left))
+ if (FIXNUMP (left))
*root_x = XINT (left);
else if (*root_x + XINT (dx) + width > FRAME_X_DISPLAY_INFO (f)->width)
*root_x -= width + XINT (dx);
CHECK_STRING (string, 0);
f = check_x_frame (frame);
if (NILP (timeout))
- timeout = make_number (5);
+ timeout = make_fixnum (5);
else
CHECK_NATNUM (timeout, 2);
if (NILP (dx))
- dx = make_number (5);
+ dx = make_fixnum (5);
else
CHECK_NUMBER (dx, 5);
if (NILP (dy))
- dy = make_number (-10);
+ dy = make_fixnum (-10);
else
CHECK_NUMBER (dy, 6);
if (NILP (last_show_tip_args))
- last_show_tip_args = Fmake_vector (make_number (3), Qnil);
+ last_show_tip_args = Fmake_vector (make_fixnum (3), Qnil);
if (!NILP (tip_frame))
{
if (NILP (Fassq (Qname, parms)))
parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
if (NILP (Fassq (Qinternal_border_width, parms)))
- parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
+ parms = Fcons (Fcons (Qinternal_border_width, make_fixnum (3)), parms);
if (NILP (Fassq (Qborder_width, parms)))
- parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
+ parms = Fcons (Fcons (Qborder_width, make_fixnum (1)), parms);
if (NILP (Fassq (Qborder_color, parms)))
parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
if (NILP (Fassq (Qbackground_color, parms)))
columns x 40 lines. If someone wants to show a larger tip, he
will loose. I don't think this is a realistic case. */
w = XWINDOW (FRAME_ROOT_WINDOW (f));
- w->left = w->top = make_number (0);
- w->width = make_number (80);
- w->height = make_number (40);
+ w->left = w->top = make_fixnum (0);
+ w->width = make_fixnum (80);
+ w->height = make_fixnum (40);
adjust_glyphs (f);
w->pseudo_window_p = 1;
DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
"*Seconds to wait before displaying an hourglass pointer.\n\
Value must be an integer or float.");
- Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
+ Vhourglass_delay = make_fixnum (DEFAULT_HOURGLASS_DELAY);
#if 0 /* This doesn't really do anything. */
DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape,
When an image has not been displayed this many seconds, remove it\n\
from the image cache. Value must be an integer or nil with nil\n\
meaning don't clear the cache.");
- Vimage_cache_eviction_delay = make_number (30 * 60);
+ Vimage_cache_eviction_delay = make_fixnum (30 * 60);
#ifdef USE_X_TOOLKIT
Fprovide (intern ("x-toolkit"));
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_used = 0;
old = menu_items;
menu_items_allocated *= 2;
- menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
+ menu_items = Fmake_vector (make_fixnum (menu_items_allocated), Qnil);
bcopy (XVECTOR (old)->contents, XVECTOR (menu_items)->contents,
old_size * sizeof (Lisp_Object));
}
/* (menu-item MENU-NAME PANE-NUMBER) */
menu_object = Fcons (Qmenu_item,
Fcons (pane_name,
- Fcons (make_number (pane), Qnil)));
+ Fcons (make_fixnum (pane), Qnil)));
show_help_echo (help_string ? build_string (help_string) : Qnil,
- Qnil, menu_object, make_number (item), 1);
+ Qnil, menu_object, make_fixnum (item), 1);
}
int gap = maxwidth - STRING_BYTES (XSTRING (item_name));
#ifdef C_ALLOCA
Lisp_Object spacer;
- spacer = Fmake_string (make_number (gap), make_number (' '));
+ spacer = Fmake_string (make_fixnum (gap), make_fixnum (' '));
item_name = concat2 (item_name, spacer);
item_name = concat2 (item_name, descrip);
item_data = XSTRING (item_name)->data;
/* Set double click time of list boxes in the file selection
dialog from `double-click-time'. */
- if (INTEGERP (Vdouble_click_time) && XINT (Vdouble_click_time) > 0)
+ if (FIXNUMP (Vdouble_click_time) && XINT (Vdouble_click_time) > 0)
{
sprintf (line, "%s*fsb*DirList.doubleClickInterval: %d",
myclass, XFASTINT (Vdouble_click_time));
if (STRINGP (check)
|| VECTORP (check)
|| SYMBOLP (check)
- || INTEGERP (check)
+ || FIXNUMP (check)
|| NILP (value))
return value;
/* Check for a value that cons_to_long could handle. */
else if (CONSP (check)
- && INTEGERP (XCAR (check))
- && (INTEGERP (XCDR (check))
+ && FIXNUMP (XCAR (check))
+ && (FIXNUMP (XCDR (check))
||
(CONSP (XCDR (check))
- && INTEGERP (XCAR (XCDR (check)))
+ && FIXNUMP (XCAR (XCDR (check)))
&& NILP (XCDR (XCDR (check))))))
return value;
else
return x_atom_to_symbol (dpyinfo, display, *((Atom *) data));
else
{
- Lisp_Object v = Fmake_vector (make_number (size / sizeof (Atom)),
- make_number (0));
+ Lisp_Object v = Fmake_vector (make_fixnum (size / sizeof (Atom)),
+ make_fixnum (0));
for (i = 0; i < size / sizeof (Atom); i++)
- Faset (v, make_number (i),
+ Faset (v, make_fixnum (i),
x_atom_to_symbol (dpyinfo, display, ((Atom *) data) [i]));
return v;
}
else if (format == 32 && size == sizeof (long))
return long_to_cons (((unsigned long *) data) [0]);
else if (format == 16 && size == sizeof (short))
- return make_number ((int) (((unsigned short *) data) [0]));
+ return make_fixnum ((int) (((unsigned short *) data) [0]));
/* Convert any other kind of data to a vector of numbers, represented
as above (as an integer, or a cons of two 16 bit integers.)
{
int i;
Lisp_Object v;
- v = Fmake_vector (make_number (size / 2), make_number (0));
+ v = Fmake_vector (make_fixnum (size / 2), make_fixnum (0));
for (i = 0; i < size / 2; i++)
{
int j = (int) ((unsigned short *) data) [i];
- Faset (v, make_number (i), make_number (j));
+ Faset (v, make_fixnum (i), make_fixnum (j));
}
return v;
}
else
{
int i;
- Lisp_Object v = Fmake_vector (make_number (size / 4), make_number (0));
+ Lisp_Object v = Fmake_vector (make_fixnum (size / 4), make_fixnum (0));
for (i = 0; i < size / 4; i++)
{
unsigned long j = ((unsigned long *) data) [i];
- Faset (v, make_number (i), long_to_cons (j));
+ Faset (v, make_fixnum (i), long_to_cons (j));
}
return v;
}
(*(Atom **) data_ret) [0] = symbol_to_x_atom (dpyinfo, display, obj);
if (NILP (type)) type = QATOM;
}
- else if (INTEGERP (obj)
+ else if (FIXNUMP (obj)
&& XINT (obj) < 0xFFFF
&& XINT (obj) > -0xFFFF)
{
(*(short **) data_ret) [0] = (short) XINT (obj);
if (NILP (type)) type = QINTEGER;
}
- else if (INTEGERP (obj)
- || (CONSP (obj) && INTEGERP (XCAR (obj))
- && (INTEGERP (XCDR (obj))
+ else if (FIXNUMP (obj)
+ || (CONSP (obj) && FIXNUMP (XCAR (obj))
+ && (FIXNUMP (XCDR (obj))
|| (CONSP (XCDR (obj))
- && INTEGERP (XCAR (XCDR (obj)))))))
+ && FIXNUMP (XCAR (XCDR (obj)))))))
{
*format_ret = 32;
*size_ret = 1;
for (i = 0; i < *size_ret; i++)
if (CONSP (XVECTOR (obj)->contents [i]))
*format_ret = 32;
- else if (!INTEGERP (XVECTOR (obj)->contents [i]))
+ else if (!FIXNUMP (XVECTOR (obj)->contents [i]))
Fsignal (Qerror, /* Qselection_error */
Fcons (build_string
("elements of selection vector must be integers or conses of integers"),
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)
return XCDR (obj);
if (XINT (XCAR (obj)) == -1)
- return make_number (- XINT (XCDR (obj)));
+ return make_fixnum (- XINT (XCDR (obj)));
}
if (VECTORP (obj))
{
Lisp_Object copy;
if (size == 1)
return clean_local_selection_data (XVECTOR (obj)->contents [0]);
- copy = Fmake_vector (make_number (size), Qnil);
+ copy = Fmake_vector (make_fixnum (size), Qnil);
for (i = 0; i < size; i++)
XVECTOR (copy)->contents [i]
= clean_local_selection_data (XVECTOR (obj)->contents [i]);
Fsignal (Qerror,
Fcons (build_string ("cut buffer doesn't contain 8-bit data"),
Fcons (x_atom_to_symbol (dpyinfo, display, type),
- Fcons (make_number (format), Qnil))));
+ Fcons (make_fixnum (format), Qnil))));
ret = (bytes ? make_string ((char *) data, bytes) : Qnil);
/* Use xfree, not XFree, because x_get_window_property
ASCENT must be in the range 0 <= ASCENT <= 100. */
#define NUMVAL(X) \
- ((INTEGERP (X) || FLOATP (X)) \
+ ((FIXNUMP (X) || FLOATP (X)) \
? XFLOATINT (X) \
: - 1)
&& font_info->default_ascent
&& CHAR_TABLE_P (Vuse_default_ascent)
&& !NILP (Faref (Vuse_default_ascent,
- make_number (it->char_to_display))))
+ make_fixnum (it->char_to_display))))
highest = font_info->default_ascent + boff;
/* Draw the first glyph at the normal position. It may be
if (font_info && font_info->relative_compose
&& (! CHAR_TABLE_P (Vignore_relative_composition)
|| NILP (Faref (Vignore_relative_composition,
- make_number (ch)))))
+ make_fixnum (ch)))))
{
if (- descent >= font_info->relative_compose)
/* If we're on a string with `help-echo' text property,
arrange for the help to be displayed. This is done by
setting the global variable help_echo to the help string. */
- help = Fget_text_property (make_number (glyph->charpos),
+ help = Fget_text_property (make_fixnum (glyph->charpos),
Qhelp_echo, glyph->object);
if (!NILP (help))
{
}
/* Change the mouse pointer according to what is under X/Y. */
- map = Fget_text_property (make_number (glyph->charpos),
+ map = Fget_text_property (make_fixnum (glyph->charpos),
Qlocal_map, glyph->object);
if (KEYMAPP (map))
cursor = f->output_data.x->nontext_cursor;
else
{
- map = Fget_text_property (make_number (glyph->charpos),
+ map = Fget_text_property (make_fixnum (glyph->charpos),
Qkeymap, glyph->object);
if (KEYMAPP (map))
cursor = f->output_data.x->nontext_cursor;
ZV = Z;
/* Is this char mouse-active or does it have help-echo? */
- position = make_number (pos);
+ position = make_fixnum (pos);
if (BUFFERP (object))
{
int ignore;
beginning = Fmarker_position (w->start);
- end = make_number (BUF_Z (XBUFFER (object))
+ end = make_fixnum (BUF_Z (XBUFFER (object))
- XFASTINT (w->window_end_pos));
before
- = Fprevious_single_property_change (make_number (pos + 1),
+ = Fprevious_single_property_change (make_fixnum (pos + 1),
Qmouse_face,
object, beginning);
after
Lisp_Object b, e;
int ignore;
- b = Fprevious_single_property_change (make_number (pos + 1),
+ b = Fprevious_single_property_change (make_fixnum (pos + 1),
Qmouse_face,
object, Qnil);
e = Fnext_single_property_change (position, Qmouse_face,
object, Qnil);
if (NILP (b))
- b = make_number (0);
+ b = make_fixnum (0);
if (NILP (e))
- e = make_number (XSTRING (object)->size - 1);
+ e = make_fixnum (XSTRING (object)->size - 1);
fast_find_string_pos (w, XINT (b), object,
&dpyinfo->mouse_face_beg_col,
&dpyinfo->mouse_face_beg_row,
&& charpos >= 0
&& charpos < XSTRING (object)->size)
{
- help = Fget_text_property (make_number (charpos),
+ help = Fget_text_property (make_fixnum (charpos),
Qhelp_echo, object);
if (NILP (help))
{
int pos = string_buffer_position (w, object, start);
if (pos > 0)
{
- help = Fget_text_property (make_number (pos),
+ help = Fget_text_property (make_fixnum (pos),
Qhelp_echo, w->buffer);
if (!NILP (help))
{
else if (BUFFERP (object)
&& charpos >= BEGV
&& charpos < ZV)
- help = Fget_text_property (make_number (charpos), Qhelp_echo,
+ help = Fget_text_property (make_fixnum (charpos), Qhelp_echo,
object);
if (!NILP (help))
ievent->timestamp = XtLastTimestampProcessed (FRAME_X_DISPLAY (f));
ievent->part = ev->data.l[1];
ievent->code = ev->data.l[2];
- ievent->x = make_number ((int) ev->data.l[3]);
- ievent->y = make_number ((int) ev->data.l[4]);
+ ievent->x = make_fixnum ((int) ev->data.l[3]);
+ ievent->y = make_fixnum ((int) ev->data.l[4]);
ievent->modifiers = 0;
}
case XmCR_DRAG:
{
int slider_size;
- int dragging_down_p = (INTEGERP (bar->dragging)
+ int dragging_down_p = (FIXNUMP (bar->dragging)
&& XINT (bar->dragging) <= cs->value);
/* Get the slider size. */
whole = XM_SB_RANGE;
portion = min (cs->value - XM_SB_MIN, XM_SB_MAX - slider_size);
part = scroll_bar_handle;
- bar->dragging = make_number (cs->value);
+ bar->dragging = make_fixnum (cs->value);
}
}
break;
part = scroll_bar_handle;
window_being_scrolled = bar->window;
- bar->dragging = make_number (portion);
+ bar->dragging = make_fixnum (portion);
last_scroll_bar_part = part;
x_send_scroll_bar_event (bar->window, part, portion, whole);
}
{
struct frame *f = XFRAME (w->frame);
struct scroll_bar *bar
- = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
+ = XSCROLL_BAR (Fmake_vector (make_fixnum (SCROLL_BAR_VEC_SIZE), Qnil));
BLOCK_INPUT;
The cache is an alist of the form:
((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
tem = XCDR (dpyinfo->name_list_element);
- key = Fcons (Fcons (pattern, make_number (maxnames)),
+ key = Fcons (Fcons (pattern, make_fixnum (maxnames)),
allow_scalable_fonts_p ? Qt : Qnil);
list = Fassoc (key, tem);
if (!NILP (list))
>= 0))
/* We can set the value of PIXEL_SIZE to the
width of this font. */
- list = Fcons (Fcons (tem, make_number (width)), list);
+ list = Fcons (Fcons (tem, make_fixnum (width)), list);
else
/* For the moment, width is not known. */
list = Fcons (Fcons (tem, Qnil), list);
continue;
}
- if (!INTEGERP (XCDR (tem)))
+ if (!FIXNUMP (XCDR (tem)))
{
/* Since we have not yet known the size of this font, we
must try slow function call XLoadQueryFont. */
{
XCDR (tem)
= (thisinfo->min_bounds.width == 0
- ? make_number (0)
- : make_number (thisinfo->max_bounds.width));
+ ? make_fixnum (0)
+ : make_fixnum (thisinfo->max_bounds.width));
XFreeFont (dpy, thisinfo);
}
else
/* For unknown reason, the previous call of XListFont had
returned a font which can't be opened. Record the size
as 0 not to try to open it again. */
- XCDR (tem) = make_number (0);
+ XCDR (tem) = make_fixnum (0);
}
found_size = XINT (XCDR (tem));
the cache for x_list_fonts. */
Lisp_Object lispy_name = build_string (fontname);
Lisp_Object lispy_full_name = build_string (fontp->full_name);
- Lisp_Object key = Fcons (Fcons (lispy_name, make_number (256)),
+ Lisp_Object key = Fcons (Fcons (lispy_name, make_fixnum (256)),
Qnil);
XCDR (dpyinfo->name_list_element)
= Fcons (Fcons (key,
Fcons (Fcons (lispy_full_name,
- make_number (fontp->size)),
+ make_fixnum (fontp->size)),
Qnil)),
XCDR (dpyinfo->name_list_element));
if (full_name)
{
- key = Fcons (Fcons (lispy_full_name, make_number (256)),
+ key = Fcons (Fcons (lispy_full_name, make_fixnum (256)),
Qnil);
XCDR (dpyinfo->name_list_element)
= Fcons (Fcons (key,
Fcons (Fcons (lispy_full_name,
- make_number (fontp->size)),
+ make_fixnum (fontp->size)),
Qnil)),
XCDR (dpyinfo->name_list_element));
}
projects / emacs.git / commitdiff