changeset: 5581:56144c8593a8 tag: tip user: Aidan Kehoe <kehoea(a)parhasard.net&gt; date: Sun Oct 09 09:51:57 2011 +0100 files: man/ChangeLog man/internals/internals.texi modules/ChangeLog modules/canna/canna_api.c modules/ldap/eldap.c modules/postgresql/postgresql.c src/ChangeLog src/EmacsFrame.c src/README src/abbrev.c src/alloc.c src/buffer.c src/buffer.h src/bytecode.c src/callint.c src/casefiddle.c src/chartab.c src/cmdloop.c src/cmds.c src/console-gtk.c src/console-msw.c src/console-tty.c src/console-x.c src/console.c src/data.c src/database.c src/debug.c src/device-gtk.c src/device-msw.c src/device-tty.c src/device-x.c src/device.c src/dialog-msw.c src/dialog-x.c src/dired.c src/doc.c src/doprnt.c src/editfns.c src/elhash.c src/emacs.c src/emodules.c src/eval.c src/event-Xt.c src/event-msw.c src/event-stream.c src/event-xlike-inc.c src/events.c src/extents.c src/file-coding.c src/fileio.c src/floatfns.c src/fns.c src/font-lock.c src/font-mgr.c src/fontcolor-gtk.c src/fontcolor-msw.c src/fontcolor-x.c src/fontcolor.c src/frame-gtk.c src/frame-impl.h src/frame-msw.c src/frame-tty.c ! src/frame-x.c src/frame.c src/free-hook.c src/glyphs-eimage.c src/glyphs-gtk.c src/glyphs-msw.c src/glyphs-widget.c src/glyphs-x.c src/glyphs.c src/gpmevent.c src/gtk-glue.c src/gtk-xemacs.c src/gui-gtk.c src/gui-msw.c src/gui-x.c src/gui.c src/gutter.c src/gutter.h src/indent.c src/insdel.c src/intl-win32.c src/keymap.c src/line-number.c src/lisp-disunion.h src/lisp-union.h src/lisp.h src/lread.c src/lstream.c src/macros.c src/marker.c src/mc-alloc.c src/menubar-msw.c src/menubar.c src/minibuf.c src/mule-ccl.c src/mule-charset.c src/mule-coding.c src/mule-wnnfns.c src/number.c src/number.h src/print.c src/process-nt.c src/process-unix.c src/process.c src/profile.c src/ralloc.c src/rangetab.c src/redisplay-msw.c src/redisplay-output.c src/redisplay-xlike-inc.c src/redisplay.c src/scrollbar-gtk.c src/scrollbar-msw.c src/scrollbar-x.c src/scrollbar.c src/search.c src/select-gtk.c src/select-msw.c src/select-x.c src/select-xlike-inc.c src/select.c src/sgiplay.c src/sound.c src! /specifier.c src/specifier.h src/symbols.c src/syntax.c src/sy! ntax.h s rc/sysdep.c src/tests.c src/text.c src/toolbar-msw.c src/toolbar-xlike.c src/toolbar.c src/tooltalk.c src/tooltalk.h src/ui-byhand.c src/ui-gtk.c src/undo.c src/unicode.c src/win32.c src/window-impl.h src/window.c src/xemacs.def.in.in description: Mechanically change INT to FIXNUM in our sources. src/ChangeLog addition: 2011-10-09 Aidan Kehoe <kehoea(a)parhasard.net&gt; [...] Mechanically change INT (where it refers to non-bignum Lisp integers) to FIXNUM in our sources. Done for the following functions, enums, and macros: Lisp_Type_Int_Even, Lisp_Type_Int_Odd, INT_GCBITS, INT_VALBITS, make_int(), INTP(), XINT(), CHECK_INT(), XREALINT(), INT_PLUS(), INT_MINUS(), EMACS_INT_MAX (to MOST_POSITIVE_FIXNUM), EMACS_INT_MIN (to MOST_NEGATIVE_FIXNUM), NUMBER_FITS_IN_AN_EMACS_INT() to NUMBER_FITS_IN_A_FIXNUM(), XFLOATINT, XCHAR_OR_INT, INT_OR_FLOAT. The EMACS_INT typedef was not changed, it does not describe non-bignum Lisp integers. Script that did the change available in http://mid.gmane.org/20067.17650.181273.12014＠parhasard.net . modules/ChangeLog addition: 2011-10-09 Aidan Kehoe <kehoea(a)parhasard.net&gt; [...] Mechanically change INT to FIXNUM, where the usage describes non-bignum Lisp integers. See the src/ChangeLog entry for more details. man/ChangeLog addition: 2011-10-09 Aidan Kehoe <kehoea(a)parhasard.net&gt; * internals/internals.texi (How Lisp Objects Are Represented in C): * internals/internals.texi (Integers and Characters): Mechanically change INT to FIXNUM, where the usage describes non-bignum Lisp integers. diff -r a0e81357194e -r 56144c8593a8 man/ChangeLog --- a/man/ChangeLog Sat Oct 08 12:26:09 2011 +0100 +++ b/man/ChangeLog Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1,3 +1,10 ＠＠ +2011-10-09 Aidan Kehoe <kehoea(a)parhasard.net&gt; + + * internals/internals.texi (How Lisp Objects Are Represented in C): + * internals/internals.texi (Integers and Characters): + Mechanically change INT to FIXNUM, where the usage describes non-bignum + Lisp integers. + 2011-09-07 Aidan Kehoe <kehoea(a)parhasard.net&gt; * cl.texi (Function Bindings): diff -r a0e81357194e -r 56144c8593a8 man/internals/internals.texi --- a/man/internals/internals.texi Sat Oct 08 12:26:09 2011 +0100 +++ b/man/internals/internals.texi Sun Oct 09 09:51:57 2011 +0100 ＠＠ -7895,9 +7895,9 ＠＠ the ＠code{--use-union-type} option to ＠code{configure}. Various macros are used to convert between Lisp_Objects and the -corresponding C type. Macros of the form ＠code{XINT()}, ＠code{XCHAR()}, +corresponding C type. Macros of the form ＠code{XFIXNUM()}, ＠code{XCHAR()}, ＠code{XSTRING()}, ＠code{XSYMBOL()}, do any required bit shifting and/or -masking and cast it to the appropriate type. ＠code{XINT()} needs to be +masking and cast it to the appropriate type. ＠code{XFIXNUM()} needs to be a bit tricky so that negative numbers are properly sign-extended. Since integers are stored left-shifted, if the right-shift operator does an arithmetic shift (i.e. it leaves the most-significant bit as-is rather ＠＠ -7919,7 +7919,7 ＠＠ than just used in an expression. The reason for this is that standard C doesn't let you ``construct'' a structure (but GCC does). Granted, this sometimes isn't too convenient; for the case of integers, at least, you -can use the function ＠code{make_int()}, which constructs and +can use the function ＠code{make_fixnum()}, which constructs and ＠emph{returns} an integer Lisp object. Note that the ＠code{XSET＠var{TYPE}()} macros are also affected by ＠code{ERROR_CHECK_TYPES} and make sure that the structure is of the ＠＠ -8736,7 +8736,7 ＠＠ ＠cindex characters, integers and Integer and character Lisp objects are created from integers using the -functions ＠code{make_int()} and ＠code{make_char()}. (These are actually +functions ＠code{make_fixnum()} and ＠code{make_char()}. (These are actually macros on most systems.) These functions basically just do some moving of bits around, since the integral value of the object is stored directly in the ＠code{Lisp_Object}. diff -r a0e81357194e -r 56144c8593a8 modules/ChangeLog --- a/modules/ChangeLog Sat Oct 08 12:26:09 2011 +0100 +++ b/modules/ChangeLog Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1,3 +1,44 ＠＠ +2011-10-09 Aidan Kehoe <kehoea(a)parhasard.net&gt; + + * postgresql/postgresql.c (Fpq_conn_defaults): + * postgresql/postgresql.c (Fpq_client_encoding): + * postgresql/postgresql.c (Fpq_set_client_encoding): + * postgresql/postgresql.c (Fpq_pgconn): + * postgresql/postgresql.c (Fpq_ntuples): + * postgresql/postgresql.c (Fpq_nfields): + * postgresql/postgresql.c (Fpq_fname): + * postgresql/postgresql.c (Fpq_fnumber): + * postgresql/postgresql.c (Fpq_ftype): + * postgresql/postgresql.c (Fpq_fsize): + * postgresql/postgresql.c (Fpq_fmod): + * postgresql/postgresql.c (Fpq_get_value): + * postgresql/postgresql.c (Fpq_get_length): + * postgresql/postgresql.c (Fpq_get_is_null): + * postgresql/postgresql.c (Fpq_oid_value): + * postgresql/postgresql.c (Fpq_set_nonblocking): + * postgresql/postgresql.c (Fpq_flush): + * postgresql/postgresql.c (Fpq_notifies): + * postgresql/postgresql.c (Fpq_env_2_encoding): + * postgresql/postgresql.c (Fpq_lo_import): + * postgresql/postgresql.c (Fpq_lo_export): + * postgresql/postgresql.c (Fpq_get_line): + * postgresql/postgresql.c (Fpq_get_line_async): + * postgresql/postgresql.c (init_postgresql_from_environment): + * ldap/eldap.c (Fldap_open): + * ldap/eldap.c (Fldap_search_basic): + * ldap/eldap.c (Fldap_add): + * ldap/eldap.c (Fldap_modify): + * canna/canna_api.c (storeResults): + * canna/canna_api.c (Fcanna_initialize): + * canna/canna_api.c (Fcanna_set_width): + * canna/canna_api.c (Fcanna_change_mode): + * canna/canna_api.c (Fcanna_do_function): + * canna/canna_api.c (Fcanna_henkan_next): + * canna/canna_api.c (Fcanna_bunsetu_henkou): + * canna/canna_api.c (Fcanna_henkan_kakutei): + Mechanically change INT to FIXNUM, where the usage describes non-bignum + Lisp integers. See the src/ChangeLog entry for more details. + 2011-05-20 Jerry James <james(a)xemacs.org&gt; * base64/Makefile: Default DESTDIR to the empty string, and use it in diff -r a0e81357194e -r 56144c8593a8 modules/canna/canna_api.c --- a/modules/canna/canna_api.c Sat Oct 08 12:26:09 2011 +0100 +++ b/modules/canna/canna_api.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -237,7 +237,7 ＠＠ { /* 確定した文字列 (the confirmed string) */ Vcanna_kakutei_string = make_euc_string (buf, len); - val = make_int (len); + val = make_fixnum (len); /* 確定した文字列の読みの情報... (info about the reading of the confirmed string) */ Vcanna_kakutei_yomi = Vcanna_kakutei_romaji = Qnil; ＠＠ -375,8 +375,8 ＠＠ } else { - CHECK_INT (num); - kugiri = (XINT (num) == 1) ? (char *) 1 : (char *) 0; + CHECK_FIXNUM (num); + kugiri = (XFIXNUM (num) == 1) ? (char *) 1 : (char *) 0; } if (NILP (server)) ＠＠ -506,9 +506,9 ＠＠ */ (num)) { - CHECK_INT (num); + CHECK_FIXNUM (num); - jrKanjiControl (0, KC_SETWIDTH, (char *) XINT (num)); + jrKanjiControl (0, KC_SETWIDTH, (char *) XFIXNUM (num)); return Qnil; } ＠＠ -520,12 +520,12 ＠＠ jrKanjiStatusWithValue ksv; jrKanjiStatus ks; - CHECK_INT (num); + CHECK_FIXNUM (num); ksv.buffer = (unsigned char *) key_buffer; ksv.bytes_buffer = KEYTOSTRSIZE; ksv.ks = &ks; - ksv.val = XINT (num); + ksv.val = XFIXNUM (num); jrKanjiControl (0, KC_CHANGEMODE, (char *)&ksv); return storeResults (key_buffer, ksv.val, ksv.ks); } ＠＠ -596,7 +596,7 ＠＠ jrKanjiStatusWithValue ksv; jrKanjiStatus ks; - CHECK_INT (num); + CHECK_FIXNUM (num); if (NILP (ch)) { ＠＠ -611,7 +611,7 ＠＠ ksv.buffer = (unsigned char *) key_buffer; ksv.bytes_buffer = KEYTOSTRSIZE; ksv.ks = &ks; - ksv.val = XINT (num); + ksv.val = XFIXNUM (num); jrKanjiControl (0, KC_DO, (char *) &ksv); return storeResults (key_buffer, ksv.val, ksv.ks); } ＠＠ -762,12 +762,12 ＠＠ UExtbyte *p, RkBuf[RKBUFSIZE]; Lisp_Object res = Qnil; - CHECK_INT (bunsetsu); + CHECK_FIXNUM (bunsetsu); if (confirmContext () == 0) { return Qnil; } - RkGoTo (IRCP_context, XINT (bunsetsu)); + RkGoTo (IRCP_context, XFIXNUM (bunsetsu)); len = RkGetKanjiList (IRCP_context, RkBuf, RKBUFSIZE); p = RkBuf; for (i = 0 ; i < len ; i++) ＠＠ -793,16 +793,16 ＠＠ { int nbun, len; - CHECK_INT (bunsetsu); - CHECK_INT (bunlen); + CHECK_FIXNUM (bunsetsu); + CHECK_FIXNUM (bunlen); - nbun = XINT (bunsetsu); + nbun = XFIXNUM (bunsetsu); if (confirmContext () == 0) { return Qnil; } RkGoTo (IRCP_context, nbun); - len = byteLen (nbun, XINT (bunlen)); + len = byteLen (nbun, XFIXNUM (bunlen)); return kanjiYomiList (IRCP_context, RkResize (IRCP_context, len)); } ＠＠ -817,10 +817,10 ＠＠ { return Qnil; } - nbun = XINT(bun); + nbun = XFIXNUM(bun); RkGoTo (IRCP_context, nbun); - nkouho = XINT(kouho); + nkouho = XFIXNUM(kouho); RkXfer (IRCP_context, nkouho); return Qt; } diff -r a0e81357194e -r 56144c8593a8 modules/ldap/eldap.c --- a/modules/ldap/eldap.c Sat Oct 08 12:26:09 2011 +0100 +++ b/modules/ldap/eldap.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -234,8 +234,8 ＠＠ /* TCP Port */ if (EQ (keyword, Qport)) { - CHECK_INT (value); - ldap_port = XINT (value); + CHECK_FIXNUM (value); + ldap_port = XFIXNUM (value); } /* Authentication method */ if (EQ (keyword, Qauth)) ＠＠ -282,14 +282,14 ＠＠ /* Timelimit */ else if (EQ (keyword, Qtimelimit)) { - CHECK_INT (value); - ldap_timelimit = XINT (value); + CHECK_FIXNUM (value); + ldap_timelimit = XFIXNUM (value); } /* Sizelimit */ else if (EQ (keyword, Qsizelimit)) { - CHECK_INT (value); - ldap_sizelimit = XINT (value); + CHECK_FIXNUM (value); + ldap_sizelimit = XFIXNUM (value); } } } ＠＠ -473,7 +473,7 ＠＠ if (!NILP (attrs)) { CHECK_CONS (attrs); - ldap_attributes = alloca_array (char *, 1 + XINT (Flength (attrs))); + ldap_attributes = alloca_array (char *, 1 + XFIXNUM (Flength (attrs))); i = 0; { ＠＠ -628,7 +628,7 ＠＠ invalid_operation ("Cannot add void entry", entry); /* Build the ldap_mods array */ - len = (Elemcount) XINT (Flength (entry)); + len = (Elemcount) XFIXNUM (Flength (entry)); ldap_mods = alloca_array (LDAPMod, len); ldap_mods_ptrs = alloca_array (LDAPMod *, 1 + len); i = 0; ＠＠ -645,7 +645,7 ＠＠ values = XCDR (current); if (CONSP (values)) { - len = (Elemcount) XINT (Flength (values)); + len = (Elemcount) XFIXNUM (Flength (values)); bervals = alloca_array (struct berval, len); ldap_mods[i].mod_vals.modv_bvals = alloca_array (struct berval *, 1 + len); ＠＠ -724,7 +724,7 ＠＠ return Qnil; /* Build the ldap_mods array */ - len = (Elemcount) XINT (Flength (mods)); + len = (Elemcount) XFIXNUM (Flength (mods)); ldap_mods = alloca_array (LDAPMod, len); ldap_mods_ptrs = alloca_array (LDAPMod *, 1 + len); i = 0; ＠＠ -751,7 +751,7 ＠＠ ldap_mods[i].mod_type = LISP_STRING_TO_EXTERNAL (XCAR (current), Qnative); values = XCDR (current); - len = (Elemcount) XINT (Flength (values)); + len = (Elemcount) XFIXNUM (Flength (values)); bervals = alloca_array (struct berval, len); ldap_mods[i].mod_vals.modv_bvals = alloca_array (struct berval *, 1 + len); diff -r a0e81357194e -r 56144c8593a8 modules/postgresql/postgresql.c --- a/modules/postgresql/postgresql.c Sat Oct 08 12:26:09 2011 +0100 +++ b/modules/postgresql/postgresql.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -530,7 +530,7 ＠＠ build_extstring (pcio[0].val, PG_OS_CODING)), list3 (build_extstring (pcio[0].label, PG_OS_CODING), build_extstring (pcio[0].dispchar, PG_OS_CODING), - make_int (pcio[0].dispsize)))); + make_fixnum (pcio[0].dispsize)))); for (i = 1; pcio[i].keyword; i++) { ＠＠ -541,7 +541,7 ＠＠ build_extstring (pcio[i].val, PG_OS_CODING)), list3 (build_extstring (pcio[i].label, PG_OS_CODING), build_extstring (pcio[i].dispchar, PG_OS_CODING), - make_int (pcio[i].dispsize)))); + make_fixnum (pcio[i].dispsize)))); { Lisp_Object args[2]; args[0] = temp; ＠＠ -670,7 +670,7 ＠＠ P = (XPGCONN (conn))->pgconn; CHECK_LIVE_CONNECTION (P); - return make_int (PQclientEncoding (P)); + return make_fixnum (PQclientEncoding (P)); } DEFUN ("pq-set-client-encoding", Fpq_set_client_encoding, 2, 2, 0, /* ＠＠ -694,7 +694,7 ＠＠ if ((rc = PQsetClientEncoding (P, c_encoding)) < 0) signal_error (Qinvalid_argument, "bad encoding", Qunbound); else - return make_int (rc); + return make_fixnum (rc); } #endif ＠＠ -911,9 +911,9 ＠＠ char *PQport(PGconn *conn) */ if ((p = PQport(P))) - return make_int(atoi(p)); + return make_fixnum(atoi(p)); else - return make_int(-1); + return make_fixnum(-1); } else if (EQ (field, Qpqtty)) /* PQtty Returns the debug tty of the connection. ＠＠ -959,7 +959,7 ＠＠ this connection. int PQbackendPID(PGconn *conn); */ - return make_int (PQbackendPID(P)); + return make_fixnum (PQbackendPID(P)); else signal_error (Qinvalid_argument, "bad PGconn accessor", Qunbound); } ＠＠ -1159,7 +1159,7 ＠＠ R = (XPGRESULT (result))->pgresult; PUKE_IF_NULL (R); - return make_int (PQntuples (R)); + return make_fixnum (PQntuples (R)); } DEFUN ("pq-nfields", Fpq_nfields, 1, 1, 0, /* ＠＠ -1173,7 +1173,7 ＠＠ R = (XPGRESULT (result))->pgresult; PUKE_IF_NULL (R); - return make_int (PQnfields (R)); + return make_fixnum (PQnfields (R)); } DEFUN ("pq-binary-tuples", Fpq_binary_tuples, 1, 1, 0, /* ＠＠ -1199,11 +1199,11 ＠＠ PGresult *R; CHECK_PGRESULT (result); - CHECK_INT (field_index); + CHECK_FIXNUM (field_index); R = (XPGRESULT (result))->pgresult; PUKE_IF_NULL (R); - return build_extstring (PQfname (R, XINT (field_index)), PG_OS_CODING); + return build_extstring (PQfname (R, XFIXNUM (field_index)), PG_OS_CODING); } DEFUN ("pq-fnumber", Fpq_fnumber, 2, 2, 0, /* ＠＠ -1222,7 +1222,7 ＠＠ TO_EXTERNAL_FORMAT (LISP_STRING, field_name, C_STRING_ALLOCA, c_field_name, Qnative); - return make_int (PQfnumber (R, c_field_name)); + return make_fixnum (PQfnumber (R, c_field_name)); } DEFUN ("pq-ftype", Fpq_ftype, 2, 2, 0, /* ＠＠ -1235,11 +1235,11 ＠＠ PGresult *R; CHECK_PGRESULT (result); - CHECK_INT (field_num); + CHECK_FIXNUM (field_num); R = (XPGRESULT (result))->pgresult; PUKE_IF_NULL (R); - return make_int (PQftype (R, XINT (field_num))); + return make_fixnum (PQftype (R, XFIXNUM (field_num))); } DEFUN ("pq-fsize", Fpq_fsize, 2, 2, 0, /* ＠＠ -1251,11 +1251,11 ＠＠ PGresult *R; CHECK_PGRESULT (result); - CHECK_INT (field_index); + CHECK_FIXNUM (field_index); R = (XPGRESULT (result))->pgresult; PUKE_IF_NULL (R); - return make_int (PQftype (R, XINT (field_index))); + return make_fixnum (PQftype (R, XFIXNUM (field_index))); } DEFUN ("pq-fmod", Fpq_fmod, 2, 2, 0, /* ＠＠ -1267,11 +1267,11 ＠＠ PGresult *R; CHECK_PGRESULT (result); - CHECK_INT (field_index); + CHECK_FIXNUM (field_index); R = (XPGRESULT (result))->pgresult; PUKE_IF_NULL (R); - return make_int (PQfmod (R, XINT (field_index))); + return make_fixnum (PQfmod (R, XFIXNUM (field_index))); } DEFUN ("pq-get-value", Fpq_get_value, 3, 3, 0, /* ＠＠ -1283,12 +1283,12 ＠＠ PGresult *R; CHECK_PGRESULT (result); - CHECK_INT (tup_num); - CHECK_INT (field_num); + CHECK_FIXNUM (tup_num); + CHECK_FIXNUM (field_num); R = (XPGRESULT (result))->pgresult; PUKE_IF_NULL (R); - return build_extstring (PQgetvalue (R, XINT (tup_num), XINT (field_num)), + return build_extstring (PQgetvalue (R, XFIXNUM (tup_num), XFIXNUM (field_num)), PG_OS_CODING); } ＠＠ -1303,12 +1303,12 ＠＠ PGresult *R; CHECK_PGRESULT (result); - CHECK_INT (tup_num); - CHECK_INT (field_num); + CHECK_FIXNUM (tup_num); + CHECK_FIXNUM (field_num); R = (XPGRESULT (result))->pgresult; PUKE_IF_NULL (R); - return make_int (PQgetlength (R, XINT (tup_num), XINT (field_num))); + return make_fixnum (PQgetlength (R, XFIXNUM (tup_num), XFIXNUM (field_num))); } DEFUN ("pq-get-is-null", Fpq_get_is_null, 3, 3, 0, /* ＠＠ -1319,12 +1319,12 ＠＠ PGresult *R; CHECK_PGRESULT (result); - CHECK_INT (tup_num); - CHECK_INT (field_num); + CHECK_FIXNUM (tup_num); + CHECK_FIXNUM (field_num); R = (XPGRESULT (result))->pgresult; PUKE_IF_NULL (R); - return PQgetisnull (R, XINT (tup_num), XINT (field_num)) ? Qt : Qnil; + return PQgetisnull (R, XFIXNUM (tup_num), XFIXNUM (field_num)) ? Qt : Qnil; } DEFUN ("pq-cmd-status", Fpq_cmd_status, 1, 1, 0, /* ＠＠ -1367,10 +1367,10 ＠＠ PUKE_IF_NULL (R); #ifdef HAVE_POSTGRESQLV7 - return make_int (PQoidValue (R)); + return make_fixnum (PQoidValue (R)); #else /* Use the old interface */ - return make_int (atoi (PQoidStatus (R))); + return make_fixnum (atoi (PQoidStatus (R))); #endif } ＠＠ -1390,7 +1390,7 ＠＠ P = (XPGCONN (conn))->pgconn; CHECK_LIVE_CONNECTION (P); - return make_int (PQsetnonblocking (P, !NILP (arg))); + return make_fixnum (PQsetnonblocking (P, !NILP (arg))); } DEFUN ("pq-is-nonblocking", Fpq_is_nonblocking, 1, 1, 0, /* ＠＠ -1418,7 +1418,7 ＠＠ P = (XPGCONN (conn))->pgconn; CHECK_LIVE_CONNECTION (P); - return make_int (PQflush (P)); + return make_fixnum (PQflush (P)); } #endif ＠＠ -1446,7 +1446,7 ＠＠ { Lisp_Object temp; - temp = list2 (build_extstring (PGN->relname, PG_OS_CODING), make_int (PGN->be_pid)); + temp = list2 (build_extstring (PGN->relname, PG_OS_CODING), make_fixnum (PGN->be_pid)); free ((void *)PGN); return temp; } ＠＠ -1459,7 +1459,7 ＠＠ */ ()) { - return make_int (PQenv2encoding ()); + return make_fixnum (PQenv2encoding ()); } #endif /* MULE */ ＠＠ -1478,7 +1478,7 ＠＠ LISP_PATHNAME_CONVERT_OUT (filename, c_filename); - return make_int ((int)lo_import (P, c_filename)); + return make_fixnum ((int)lo_import (P, c_filename)); } DEFUN ("pq-lo-export", Fpq_lo_export, 3, 3, 0, /* ＠＠ -1489,7 +1489,7 ＠＠ char *c_filename; CHECK_PGCONN (conn); - CHECK_INT (oid); + CHECK_FIXNUM (oid); CHECK_STRING (filename); P = (XPGCONN (conn))->pgconn; ＠＠ -1497,7 +1497,7 ＠＠ LISP_PATHNAME_CONVERT_OUT (filename, c_filename); - return make_int ((int)lo_export (P, XINT (oid), c_filename)); + return make_fixnum ((int)lo_export (P, XFIXNUM (oid), c_filename)); } DEFUN ("pq-make-empty-pgresult", Fpq_make_empty_pgresult, 2, 2, 0, /* ＠＠ -1557,7 +1557,7 ＠＠ ret = PQgetline (P, buffer, sizeof (buffer)); - return Fcons (make_int (ret), build_extstring (buffer, PG_OS_CODING)); + return Fcons (make_fixnum (ret), build_extstring (buffer, PG_OS_CODING)); } DEFUN ("pq-put-line", Fpq_put_line, 2, 2, 0, /* ＠＠ -1625,7 +1625,7 ＠＠ if (ret == -1) return Qt; /* done! */ else if (!ret) return Qnil; /* no data yet */ - else return Fcons (make_int (ret), + else return Fcons (make_fixnum (ret), make_extstring ((Extbyte *) buffer, ret, PG_OS_CODING)); } ＠＠ -1907,7 +1907,7 ＠＠ FROB ("PGOPTIONS", VXPGOPTIONS); if ((p = egetenv ("PGPORT"))) - VXPGPORT = make_int (atoi ((char *) p)); + VXPGPORT = make_fixnum (atoi ((char *) p)); else VXPGPORT = Qnil; diff -r a0e81357194e -r 56144c8593a8 src/ChangeLog --- a/src/ChangeLog Sat Oct 08 12:26:09 2011 +0100 +++ b/src/ChangeLog Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1,3 +1,1013 ＠＠ +2011-10-09 Aidan Kehoe <kehoea(a)parhasard.net&gt; + + * EmacsFrame.c (EmacsFrameSetValues): + * README: + * abbrev.c (Fexpand_abbrev): + * abbrev.c (write_abbrev): + * abbrev.c (describe_abbrev): + * alloc.c (Fmake_list): + * alloc.c (Fmake_vector): + * alloc.c (Fmake_bit_vector): + * alloc.c (Fmake_byte_code): + * alloc.c (string_plist_ptr): + * alloc.c (Fmake_string): + * alloc.c (gc_plist_hack): + * alloc.c (garbage_collection_statistics): + * alloc.c (Fobject_memory_usage): + * alloc.c (Ftotal_object_memory_usage): + * alloc.c (Fconsing_since_gc): + * alloc.c (Fmemory_limit): + * alloc.c (Ftotal_memory_usage): + * alloc.c (common_init_alloc_early): + * buffer.c (finish_init_buffer): + * buffer.c (MARKED_SLOT): + * buffer.c (Fbuffer_modified_tick): + * buffer.c (set_buffer_internal): + * buffer.c (ADD_INT): + * buffer.c (Fstring_char_byte_converion_info): + * buffer.c (common_init_complex_vars_of_buffer): + * buffer.c (complex_vars_of_buffer): + * buffer.h: + * buffer.h (make_charbpos): + * bytecode.c: + * bytecode.c (meter_code): + * bytecode.c (bytecode_negate): + * bytecode.c (bytecode_arithcompare): + * bytecode.c (bytecode_arithop): + * bytecode.c (UNUSED): + * bytecode.c (check_opcode): + * bytecode.c (optimize_compiled_function): + * bytecode.c (set_compiled_function_documentation): + * bytecode.c (Fcompiled_function_stack_depth): + * bytecode.c (Fbyte_code): + * callint.c (Fcall_interactively): + * callint.c (Fprefix_numeric_value): + * callint.c (syms_of_callint): + * casefiddle.c (casify_word): + * chartab.c (nsubst_structures_mapper): + * chartab.c (decode_char_table_range): + * chartab.c (encode_char_table_range): + * chartab.c (Fmake_char_table): + * chartab.c (Fcopy_char_table): + * chartab.c (check_valid_char_table_value): + * chartab.c (Fcheck_category_at): + * chartab.c (Fset_category_table): + * chartab.c (Fcategory_designator_p): + * cmdloop.c (top_level_1): + * cmdloop.c (initial_command_loop): + * cmdloop.c (initial_error_handler): + * cmdloop.c (Fcommand_loop_1): + * cmds.c (Fforward_char): + * cmds.c (Fbackward_char): + * cmds.c (Fforward_line): + * cmds.c (Fpoint_at_bol): + * cmds.c (Fbeginning_of_line): + * cmds.c (Fpoint_at_eol): + * cmds.c (Fend_of_line): + * cmds.c (Fdelete_char): + * cmds.c (Fdelete_backward_char): + * cmds.c (Fself_insert_command): + * cmds.c (internal_self_insert): + * console-gtk.c (gtk_perhaps_init_unseen_key_defaults): + * console-msw.c (Fmswindows_message_box): + * console-tty.c (tty_init_console): + * console-x.c (x_canonicalize_console_connection): + * console.c (delete_console_internal): + * console.c (Fsuspend_console): + * console.c (common_init_complex_vars_of_console): + * console.c (MARKED_SLOT): + * data.c (eq_with_ebola_notice): + * data.c (Fsubr_min_args): + * data.c (Fsubr_max_args): + * data.c (Fchar_to_int): + * data.c (Fint_to_char): + * data.c (Ffixnump): + * data.c (Faref): + * data.c (Faset): + * data.c (number_char_or_marker_to_int_or_double): + * data.c (number_char_or_marker_to_double): + * data.c (fixnum_char_or_marker_to_int): + * data.c (ARITHCOMPARE_MANY): + * data.c (Fneq): + * data.c (Fzerop): + * data.c (word_to_lisp): + * data.c (lisp_to_word): + * data.c (Fnumber_to_string): + * data.c (Fstring_to_number): + * data.c (Fplus): + * data.c (Fminus): + * data.c (Ftimes): + * data.c (Fdiv): + * data.c (Fquo): + * data.c (Fmax): + * data.c (Fmin): + * data.c (Flogand): + * data.c (Flogior): + * data.c (Flogxor): + * data.c (Flognot): + * data.c (Frem): + * data.c (Fmod): + * data.c (Fash): + * data.c (Flsh): + * data.c (Fadd1): + * data.c (Fsub1): + * data.c (vars_of_data): + * database.c (Fopen_database): + * debug.c (FROB): + * debug.c (Fset_debug_class_types_to_check): + * device-gtk.c (Fgtk_display_visual_depth): + * device-gtk.c (gtk_device_system_metrics): + * device-msw.c (build_sysmetrics_cons): + * device-msw.c (build_devicecaps_cons): + * device-msw.c (mswindows_device_system_metrics): + * device-msw.c (FROB): + * device-msw.c (msprinter_device_system_metrics): + * device-msw.c (print_dialog_worker): + * device-msw.c (plist_get_margin): + * device-msw.c (plist_set_margin): + * device-msw.c (signal_enum_printer_error): + * device-msw.c (Fmswindows_printer_list): + * device-tty.c (tty_device_system_metrics): + * device-x.c (Fx_get_resource): + * device-x.c (Fx_display_visual_depth): + * device-x.c (x_device_system_metrics): + * device-x.c (Fx_server_version): + * device-x.c (Fx_valid_keysym_name_p): + * device.c (delete_device_internal): + * device.c (Fset_device_baud_rate): + * device.c (Fdevice_baud_rate): + * device.c (Fdevice_printer_p): + * dialog-msw.c (handle_directory_dialog_box): + * dialog-msw.c (handle_file_dialog_box): + * dialog-x.c (dbox_selection_callback): + * dialog-x.c (x_make_dialog_box_internal): + * dialog-x.c (syms_of_dialog_x): + * dired.c: + * dired.c (file_name_completion): + * dired.c (user_name_completion): + * dired.c (Ffile_attributes): + * doc.c (extract_object_file_name): + * doc.c (unparesseuxify_doc_string): + * doc.c (get_doc_string): + * doc.c (get_object_file_name): + * doc.c (Fbuilt_in_symbol_file): + * doc.c (Fdocumentation): + * doc.c (Fdocumentation_property): + * doc.c (Fsnarf_documentation): + * doc.c (verify_doc_mapper): + * doprnt.c (get_doprnt_args): + * doprnt.c (emacs_doprnt_1): + * editfns.c (buildmark): + * editfns.c (Fpoint): + * editfns.c (Fgoto_char): + * editfns.c (region_limit): + * editfns.c (save_excursion_save): + * editfns.c (Fbuffer_size): + * editfns.c (Fpoint_min): + * editfns.c (Fpoint_max): + * editfns.c (Fuser_login_name): + * editfns.c (Fuser_uid): + * editfns.c (Fuser_real_uid): + * editfns.c (Femacs_pid): + * editfns.c (Fcurrent_time): + * editfns.c (lisp_to_time): + * editfns.c (time_to_lisp): + * editfns.c (Fdecode_time): + * editfns.c (make_time): + * editfns.c (Fencode_time): + * editfns.c (Fcurrent_time_zone): + * editfns.c (Finsert_char): + * editfns.c (Fcompare_buffer_substrings): + * editfns.c (Ftranslate_region): + * editfns.c (save_restriction_save): + * elhash.c (lisp_object_general_hash): + * elhash.c (hash_table_size_validate): + * elhash.c (decode_hash_table_size): + * elhash.c (inchash_eq): + * elhash.c (Fhash_table_count): + * elhash.c (Fhash_table_size): + * elhash.c (internal_hash): + * elhash.c (Fdefine_hash_table_test): + * elhash.c (vars_of_elhash): + * emacs.c (make_argc_argv): + * emacs.c (main_1): + * emacs.c (Fkill_emacs): + * emacs.c (vars_of_emacs): + * emodules.c (Fload_module): + * emodules.c (module_load_unwind): + * eval.c: + * eval.c (Fsetq): + * eval.c (Fquote): + * eval.c (Ffunction): + * eval.c (Fdefmacro): + * eval.c (Fmacroexpand_internal): + * eval.c (Fthrow): + * eval.c (Fcall_with_condition_handler): + * eval.c (signal_wrong_number_of_arguments_error): + * eval.c (funcall_compiled_function): + * eval.c (function_argcount): + * eval.c (multiple_value_aset): + * eval.c (multiple_value_aref): + * eval.c (bind_multiple_value_limits): + * eval.c (multiple_value_call): + * eval.c (Fmultiple_value_call): + * eval.c (multiple_value_list_internal): + * eval.c (Fbacktrace_debug): + * eval.c (Fbacktrace): + * eval.c (Fbacktrace_frame): + * event-Xt.c (x_handle_sticky_modifiers): + * event-msw.c (dde_eval_string): + * event-stream.c (maybe_echo_keys): + * event-stream.c (lisp_number_to_milliseconds): + * event-stream.c (Fadd_timeout): + * event-stream.c (Fdisable_timeout): + * event-stream.c (Fadd_async_timeout): + * event-stream.c (Fdisable_async_timeout): + * event-stream.c (detect_input_pending): + * event-stream.c (Fnext_event): + * event-stream.c (Faccept_process_output): + * event-stream.c (Fsleep_for): + * event-stream.c (Fsit_for): + * event-stream.c (Frecent_keys): + * event-stream.c (Frecent_keys_ring_size): + * event-stream.c (Fset_recent_keys_ring_size): + * event-stream.c (Fdispatch_event): + * event-stream.c (Fcurrent_event_timestamp): + * event-stream.c (vars_of_event_stream): + * event-xlike-inc.c (USE_UNICODE_MAP): + * event-xlike-inc.c (endif): + * events.c (print_event): + * events.c (Fmake_event): + * events.c (nth_of_key_sequence_as_event): + * events.c (key_sequence_to_event_chain): + * events.c (Fevent_timestamp): + * events.c (TIMESTAMP_HALFSPACE): + * events.c (Fevent_timestamp_lessp): + * events.c (Fevent_button): + * events.c (Fevent_modifier_bits): + * events.c (Fevent_modifiers): + * events.c (Fevent_window_x_pixel): + * events.c (Fevent_window_y_pixel): + * events.c (Fevent_x_pixel): + * events.c (Fevent_y_pixel): + * events.c (Fevent_point): + * events.c (Fevent_closest_point): + * events.c (Fevent_x): + * events.c (Fevent_y): + * events.c (Fevent_modeline_position): + * events.c (Fevent_glyph_x_pixel): + * events.c (Fevent_glyph_y_pixel): + * events.c (Fevent_properties): + * extents.c: + * extents.c (print_extent_1): + * extents.c (extent_endpoint_external): + * extents.c (Fextent_length): + * extents.c (Fnext_extent_change): + * extents.c (Fprevious_extent_change): + * extents.c (report_extent_modification_mapper): + * extents.c (memoize_extent_face_internal): + * extents.c (Fset_extent_priority): + * extents.c (Fextent_priority): + * extents.c (Fextent_property): + * extents.c (extent_properties): + * extents.c (run_extent_copy_paste_internal): + * extents.c (next_previous_single_property_change_fn): + * file-coding.c (default_query_method): + * file-coding.c (encode_decode_coding_region): + * file-coding.c (gzip_print): + * file-coding.c (gzip_putprop): + * file-coding.c (gzip_getprop): + * fileio.c (close_file_unwind): + * fileio.c (Ffile_modes): + * fileio.c (Fset_file_modes): + * fileio.c (Fset_default_file_modes): + * fileio.c (Fdefault_file_modes): + * fileio.c (build_annotations): + * fileio.c (a_write): + * fileio.c (auto_save_error): + * fileio.c (do_auto_save_unwind): + * fileio.c (Fdo_auto_save): + * fileio.c (Fset_buffer_auto_saved): + * floatfns.c: + * floatfns.c (extract_float): + * floatfns.c (Fexpt): + * floatfns.c (Fabs): + * floatfns.c (Ffloat): + * floatfns.c (Flogb): + * floatfns.c (CONVERT_WITHOUT_NUMBER_TYPES): + * floatfns.c (MAYBE_CHAR_OR_MARKER): + * floatfns.c (ceiling_two_fixnum): + * floatfns.c (ceiling_two_bigfloat): + * floatfns.c (ceiling_one_bigfloat): + * floatfns.c (ceiling_one_mundane_arg): + * floatfns.c (floor_two_fixnum): + * floatfns.c (floor_two_bigfloat): + * floatfns.c (floor_one_bigfloat): + * floatfns.c (round_two_fixnum): + * floatfns.c (round_two_bigfloat): + * floatfns.c (round_one_bigfloat): + * floatfns.c (truncate_two_fixnum): + * floatfns.c (truncate_two_bigfloat): + * floatfns.c (truncate_one_bigfloat): + * floatfns.c (truncate_one_float): + * fns.c (print_bit_vector): + * fns.c (get_check_match_function_1): + * fns.c (Frandom): + * fns.c (Flength): + * fns.c (Fsafe_length): + * fns.c (Flist_length): + * fns.c (count_with_tail): + * fns.c (list_count_from_end): + * fns.c (string_count_from_end): + * fns.c (Fcompare_strings): + * fns.c (Fstring_modified_tick): + * fns.c (bump_string_modiff): + * fns.c (concat): + * fns.c (Fsubseq): + * fns.c (Fnthcdr): + * fns.c (Felt): + * fns.c (Flast): + * fns.c (Fnbutlast): + * fns.c (Fbutlast): + * fns.c (list_position_cons_before): + * fns.c (position): + * fns.c (FdeleteX): + * fns.c (FremoveX): + * fns.c (list_delete_duplicates_from_end): + * fns.c (Fdelete_duplicates): + * fns.c (Fremove_duplicates): + * fns.c (BIT_VECTOR_TO_OBJECT_ARRAY): + * fns.c (Fmerge): + * fns.c (list_sort): + * fns.c (FsortX): + * fns.c (plists_differ): + * fns.c (tweaked_internal_equal): + * fns.c (internal_equal_trapping_problems): + * fns.c (internal_equalp): + * fns.c (Ffill): + * fns.c (mapcarX): + * fns.c (shortest_length_among_sequences): + * fns.c (Fmapconcat): + * fns.c (Freduce): + * fns.c (replace_string_range_1): + * fns.c (Freplace): + * fns.c (Fnsubstitute): + * fns.c (Fsubstitute): + * fns.c (mismatch_from_end): + * fns.c (mismatch_list_list): + * fns.c (mismatch_list_string): + * fns.c (mismatch_list_array): + * fns.c (mismatch_string_array): + * fns.c (mismatch_string_string): + * fns.c (mismatch_array_array): + * fns.c (Fsearch): + * fns.c (Fload_average): + * fns.c (Ffeaturep): + * fns.c (base64_decode_1): + * fns.c (Fbase64_encode_region): + * fns.c (Fbase64_decode_region): + * fns.c (Fbase64_decode_string): + * font-lock.c (end_of_defun): + * font-lock.c (Fsyntactically_sectionize): + * font-mgr.c (Ffc_pattern_add): + * font-mgr.c (Ffc_pattern_get): + * font-mgr.c (Ffc_config_get_rescan_interval): + * font-mgr.c (Ffc_config_set_rescan_interval): + * font-mgr.c (Ffc_get_version): + * font-mgr.c (Ffc_init_reinitialize): + * fontcolor-gtk.c (gtk_color_instance_rgb_components): + * fontcolor-gtk.c (gtk_valid_color_name_p): + * fontcolor-msw.c (mswindows_color_instance_rgb_components): + * fontcolor-msw.c (mswindows_valid_color_name_p): + * fontcolor-x.c (x_color_instance_rgb_components): + * fontcolor-x.c (x_font_instance_properties): + * fontcolor-x.c (x_font_list): + * fontcolor.c (Ffont_instance_ascent): + * fontcolor.c (Ffont_instance_descent): + * fontcolor.c (Ffont_instance_width): + * fontcolor.c (Ffont_instance_proportional_p): + * frame-gtk.c (gtk_frame_property): + * frame-gtk.c (gtk_frame_properties): + * frame-gtk.c (gtk_set_frame_properties): + * frame-impl.h (FRAME_SCROLLBAR_WIDTH): + * frame-impl.h (FRAME_RAW_THEORETICAL_TOOLBAR_SIZE): + * frame-impl.h (FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH): + * frame-msw.c (mswindows_init_frame_1): + * frame-msw.c (mswindows_frame_property): + * frame-msw.c (mswindows_frame_properties): + * frame-msw.c (mswindows_set_frame_properties): + * frame-msw.c (msprinter_frame_property): + * frame-msw.c (msprinter_frame_properties): + * frame-msw.c (msprinter_set_frame_properties): + * frame-tty.c: + * frame-tty.c (tty_frame_property): + * frame-tty.c (tty_frame_properties): + * frame-x.c (x_frame_property): + * frame-x.c (x_frame_properties): + * frame-x.c (x_set_frame_properties): + * frame.c (Fmake_frame): + * frame.c (delete_frame_internal): + * frame.c (Fmouse_pixel_position): + * frame.c (Fmouse_position): + * frame.c (Fset_mouse_position): + * frame.c (Fset_mouse_pixel_position): + * frame.c (Fprint_job_page_number): + * frame.c (Fframe_modified_tick): + * frame.c (Fframe_property): + * frame.c (Fframe_properties): + * frame.c (Fframe_pixel_height): + * frame.c (Fframe_displayable_pixel_height): + * frame.c (Fframe_pixel_width): + * frame.c (Fframe_displayable_pixel_width): + * frame.c (Fset_frame_height): + * frame.c (Fset_frame_pixel_height): + * frame.c (Fset_frame_displayable_pixel_height): + * frame.c (Fset_frame_width): + * frame.c (Fset_frame_pixel_width): + * frame.c (Fset_frame_displayable_pixel_width): + * frame.c (Fset_frame_size): + * frame.c (Fset_frame_pixel_size): + * frame.c (Fset_frame_displayable_pixel_size): + * frame.c (Fset_frame_position): + * frame.c (adjust_frame_size): + * free-hook.c (Freally_free): + * free-hook.c (really_free_one_entry): + * glyphs-eimage.c (gif_instantiate): + * glyphs-eimage.c (GETCOLOR): + * glyphs-gtk.c (image_instance_convert_to_pointer): + * glyphs-gtk.c (init_image_instance_from_xbm_inline): + * glyphs-gtk.c (xbm_instantiate_1): + * glyphs-gtk.c (gtk_xbm_instantiate): + * glyphs-gtk.c (gtk_xpm_instantiate): + * glyphs-gtk.c (check_valid_string_or_int): + * glyphs-gtk.c (autodetect_normalize): + * glyphs-gtk.c (gtk_progress_gauge_redisplay): + * glyphs-gtk.c (gtk_register_gui_item): + * glyphs-gtk.c (gtk_tab_control_callback): + * glyphs-gtk.c (BUILD_GLYPH_INST): + * glyphs-msw.c (init_image_instance_from_dibitmap): + * glyphs-msw.c (mswindows_initialize_image_instance_icon): + * glyphs-msw.c (xpm_to_eimage): + * glyphs-msw.c (resource_name_to_resource): + * glyphs-msw.c (mswindows_resource_instantiate): + * glyphs-msw.c (init_image_instance_from_xbm_inline): + * glyphs-msw.c (xbm_instantiate_1): + * glyphs-msw.c (mswindows_xbm_instantiate): + * glyphs-msw.c (mswindows_register_gui_item): + * glyphs-msw.c (mswindows_subwindow_instantiate): + * glyphs-msw.c (mswindows_widget_instantiate): + * glyphs-msw.c (mswindows_progress_gauge_instantiate): + * glyphs-msw.c (mswindows_progress_gauge_redisplay): + * glyphs-msw.c (mswindows_control_wnd_proc): + * glyphs-widget.c: + * glyphs-widget.c (check_valid_int_or_function): + * glyphs-widget.c (widget_query_geometry): + * glyphs-widget.c (widget_instantiate): + * glyphs-widget.c (layout_update): + * glyphs-widget.c (layout_query_geometry): + * glyphs-widget.c (layout_layout): + * glyphs-widget.c (layout_property): + * glyphs-widget.c (Fwidget_logical_to_character_width): + * glyphs-widget.c (Fwidget_logical_to_character_height): + * glyphs-x.c (image_instance_convert_to_pointer): + * glyphs-x.c (init_image_instance_from_xbm_inline): + * glyphs-x.c (xbm_instantiate_1): + * glyphs-x.c (x_xbm_instantiate): + * glyphs-x.c (x_xpm_instantiate): + * glyphs-x.c (autodetect_normalize): + * glyphs-x.c (x_progress_gauge_redisplay): + * glyphs-x.c (BUILD_GLYPH_INST): + * glyphs.c: + * glyphs.c (process_image_string_instantiator): + * glyphs.c (check_valid_int): + * glyphs.c (alist_to_tagged_vector): + * glyphs.c (normalize_image_instantiator): + * glyphs.c (print_image_instance): + * glyphs.c (make_image_instance_1): + * glyphs.c (Fimage_instance_depth): + * glyphs.c (Fimage_instance_height): + * glyphs.c (Fimage_instance_width): + * glyphs.c (bitmap_to_lisp_data): + * glyphs.c (xbm_normalize): + * glyphs.c (pixmap_to_lisp_data): + * glyphs.c (image_instantiate): + * glyphs.c (image_going_to_add): + * glyphs.c (Fglyph_width): + * glyphs.c (Fglyph_ascent): + * glyphs.c (Fglyph_descent): + * glyphs.c (Fglyph_height): + * glyphs.c (glyph_baseline): + * glyphs.c (subwindow_instantiate): + * glyphs.c (Fimage_instance_subwindow_id): + * glyphs.c (Fresize_subwindow): + * glyphs.c (disable_glyph_animated_timeout): + * gpmevent.c (Fgpm_enable): + * gtk-glue.c (xemacs_list_to_array): + * gtk-xemacs.c (FROB_FACE): + * gtk-xemacs.c (smash_scrollbar_specifiers): + * gtk-xemacs.c (smash_toolbar_specifiers): + * gui-gtk.c (gcpro_popup_callbacks): + * gui-gtk.c (ungcpro_popup_callbacks): + * gui-gtk.c (get_gcpro_popup_callbacks): + * gui-msw.c (mswindows_handle_gui_wm_command): + * gui-x.c: + * gui-x.c (gcpro_popup_callbacks): + * gui-x.c (ungcpro_popup_callbacks): + * gui-x.c (popup_handled_p): + * gui.c (gui_item_id_hash): + * gutter.c (calculate_gutter_size): + * gutter.c (Fgutter_pixel_width): + * gutter.c (Fgutter_pixel_height): + * gutter.c (gutter_specs_changed_1): + * gutter.c (gutter_specs_changed): + * gutter.c (gutter_size_validate): + * gutter.c (specifier_vars_of_gutter): + * gutter.h (WINDOW_GUTTER_BORDER_WIDTH): + * indent.c (last_visible_position): + * indent.c (column_at_point): + * indent.c (Fcurrent_column): + * indent.c (Findent_to): + * indent.c (byte_spaces_at_point): + * indent.c (Fcurrent_indentation): + * indent.c (Fmove_to_column): + * indent.c (Fcompute_motion): + * indent.c (vertical_motion_1): + * indent.c (Fvertical_motion_pixels): + * indent.c (syms_of_indent): + * insdel.c (make_gap): + * insdel.c (signal_before_change): + * insdel.c (signal_after_change): + * insdel.c (buffer_insert_string_1): + * intl-win32.c: + * intl-win32.c (mswindows_get_code_page_charset): + * intl-win32.c (Fmswindows_get_locale_info): + * intl-win32.c (enum_code_page_fn): + * intl-win32.c (Fmswindows_get_console_code_page): + * intl-win32.c (Fmswindows_set_console_code_page): + * intl-win32.c (Fmswindows_get_console_output_code_page): + * intl-win32.c (Fmswindows_set_console_output_code_page): + * intl-win32.c (Fmswindows_get_code_page_charset): + * intl-win32.c (Fmswindows_get_valid_keyboard_layouts): + * intl-win32.c (Fmswindows_get_keyboard_layout): + * intl-win32.c (Fmswindows_set_keyboard_layout): + * intl-win32.c (mswindows_multibyte_to_unicode_putprop): + * intl-win32.c (mswindows_multibyte_to_unicode_getprop): + * intl-win32.c (mswindows_multibyte_to_unicode_print): + * keymap.c (MAKE_MODIFIER_HASH_KEY): + * keymap.c (print_keymap): + * keymap.c (get_keyelt): + * keymap.c (keymap_fullness): + * keymap.c (Fkeymap_fullness): + * keymap.c (event_matches_key_specifier_p): + * keymap.c (ensure_meta_prefix_char_keymapp): + * keymap.c (Fdefine_key): + * keymap.c (raw_lookup_key_mapper): + * keymap.c (lookup_events): + * keymap.c (get_relevant_keymaps): + * keymap.c (Fkey_binding): + * keymap.c (map_keymap_sorted): + * keymap.c (Faccessible_keymaps): + * keymap.c (Fkey_description): + * keymap.c (Fwhere_is_internal): + * keymap.c (where_is_recursive_mapper): + * keymap.c (describe_map_tree): + * keymap.c (describe_command): + * keymap.c (describe_map_mapper): + * keymap.c (describe_map_sort_predicate): + * keymap.c (describe_map): + * line-number.c (narrow_line_number_cache): + * line-number.c (get_nearest_line_number): + * line-number.c (add_position_to_cache): + * line-number.c (buffer_line_number): + * lisp-disunion.h: + * lisp-disunion.h (Lisp_Type_Fixnum_Bit): + * lisp-disunion.h (make_fixnum): + * lisp-disunion.h (FIXNUMP): + * lisp-disunion.h (Qzero): + * lisp-union.h: + * lisp-union.h (union Lisp_Object): + * lisp-union.h (XREALFIXNUM): + * lisp-union.h (FIXNUMP): + * lisp.h: + * lisp.h (enum Lisp_Type): + * lisp.h (FIXNUM_GCBITS): + * lisp.h (HACKEQ_UNSAFE): + * lisp.h (BITP): + * lisp.h (XFIXNUM): + * lisp.h (CHECK_FIXNUM): + * lisp.h (CONCHECK_FIXNUM): + * lisp.h (XCHAR_OR_FIXNUM): + * lisp.h (CHAR_INTP): + * lisp.h (CHECK_CHAR_COERCE_INT): + * lisp.h (CHECK_FIXNUM_COERCE_CHAR): + * lisp.h (CHECK_FIXNUM_COERCE_MARKER): + * lisp.h (CHECK_FIXNUM_COERCE_CHAR_OR_MARKER): + * lisp.h (XFLOATFIXNUM): + * lisp.h (CONCHECK_FIXNUM_OR_FLOAT): + * lisp.h (FIXNUM_OR_FLOATP): + * lisp.h (PARSE_KEYWORDS): + * lisp.h (ARRAY_DIMENSION_LIMIT): + * lread.c (pas_de_holgazan_ici): + * lread.c (load_force_doc_string_unwind): + * lread.c (close_load_descs): + * lread.c (Fload_internal): + * lread.c (decode_mode_1): + * lread.c (Feval_region): + * lread.c (Fread_from_string): + * lread.c (read_unicode_escape): + * lread.c (read_atom): + * lread.c (parse_integer): + * lread.c (read_structure): + * lread.c (read1): + * lread.c (read_vector): + * lread.c (read_compiled_function): + * lstream.c (make_lisp_buffer_stream_1): + * macros.c (Fstart_kbd_macro): + * macros.c (Fend_kbd_macro): + * macros.c (pop_kbd_macro_event): + * macros.c (Fexecute_kbd_macro): + * marker.c (Fmarker_position): + * marker.c (set_marker_internal): + * marker.c (copy_marker_1): + * marker.c (init_buffer_markers): + * marker.c (uninit_buffer_markers): + * mc-alloc.c (Fmc_alloc_memory_usage): + * mc-alloc.c (syms_of_mc_alloc): + * menubar-msw.c (allocate_menu_item_id): + * menubar-msw.c (populate_menu_add_item): + * menubar-msw.c (mswindows_handle_wm_command): + * menubar.c (Fcompare_menu_text): + * minibuf.c: + * minibuf.c (Fminibuffer_depth): + * minibuf.c (read_minibuffer_internal_unwind): + * minibuf.c (Fminibuffer_prompt_width): + * mule-ccl.c (CCL_CALL_FOR_MAP_INSTRUCTION): + * mule-ccl.c (CCL_WRITE_STRING): + * mule-ccl.c (ccl_driver): + * mule-ccl.c (resolve_symbol_ccl_program): + * mule-ccl.c (ccl_get_compiled_code): + * mule-ccl.c (setup_ccl_program): + * mule-ccl.c (Fccl_execute): + * mule-ccl.c (vars_of_mule_ccl): + * mule-charset.c: + * mule-charset.c (get_unallocated_leading_byte): + * mule-charset.c (Fmake_charset): + * mule-charset.c (Fcharset_from_attributes): + * mule-charset.c (Fcharset_dimension): + * mule-charset.c (Fcharset_property): + * mule-charset.c (Fcharset_id): + * mule-coding.c (Fdecode_shift_jis_char): + * mule-coding.c (Fencode_shift_jis_char): + * mule-coding.c (Fdecode_big5_char): + * mule-coding.c (Fencode_big5_char): + * mule-coding.c (charset_by_attributes_or_create_one): + * mule-coding.c (decode_unicode_char): + * mule-coding.c (fixed_width_skip_chars_data_given_strings): + * mule-coding.c (fixed_width_query): + * mule-wnnfns.c (Fwnn_dict_add): + * mule-wnnfns.c (Fwnn_dict_delete): + * mule-wnnfns.c (Fwnn_dict_list): + * mule-wnnfns.c (Fwnn_dict_comment): + * mule-wnnfns.c (Fwnn_begin_henkan): + * mule-wnnfns.c (Fwnn_zenkouho): + * mule-wnnfns.c (Fwnn_get_zenkouho): + * mule-wnnfns.c (Fwnn_zenkouho_bun): + * mule-wnnfns.c (Fwnn_zenkouho_suu): + * mule-wnnfns.c (Fwnn_dai_top): + * mule-wnnfns.c (Fwnn_dai_end): + * mule-wnnfns.c (Fwnn_kakutei): + * mule-wnnfns.c (Fwnn_bunsetu_henkou): + * mule-wnnfns.c (Fwnn_inspect): + * mule-wnnfns.c (Fwnn_bunsetu_kanji): + * mule-wnnfns.c (Fwnn_bunsetu_yomi): + * mule-wnnfns.c (Fwnn_bunsetu_suu): + * mule-wnnfns.c (Fwnn_hindo_update): + * mule-wnnfns.c (Fwnn_word_toroku): + * mule-wnnfns.c (Fwnn_word_sakujo): + * mule-wnnfns.c (Fwnn_word_use): + * mule-wnnfns.c (Fwnn_word_info): + * mule-wnnfns.c (Fwnn_hindo_set): + * mule-wnnfns.c (Fwnn_dict_search): + * mule-wnnfns.c (Fwnn_get_param): + * mule-wnnfns.c (Fwnn_set_param): + * mule-wnnfns.c (Fwnn_get_msg): + * mule-wnnfns.c (Fwnn_hinsi_dicts): + * mule-wnnfns.c (Fwnn_hinsi_list): + * mule-wnnfns.c (Fwnn_notrans_dict_add): + * mule-wnnfns.c (Fwnn_bmodify_dict_add): + * mule-wnnfns.c (Fwnn_okuri_flag): + * mule-wnnfns.c (Fwnn_prefix_flag): + * mule-wnnfns.c (Fwnn_freq_func): + * mule-wnnfns.c (Fwnn_numeric): + * mule-wnnfns.c (Fwnn_alphabet): + * mule-wnnfns.c (Fwnn_symbol): + * mule-wnnfns.c (Fwnn_version): + * mule-wnnfns.c (Fwnn_hinsi_number): + * mule-wnnfns.c (syms_of_mule_wnn): + * number.c: + * number.c (Fdenominator): + * number.c (Fbigfloat_get_precision): + * number.c (Fbigfloat_set_precision): + * number.c (default_float_precision_changed): + * number.c (Fcanonicalize_number): + * number.c (get_number_type): + * number.c (promote_args): + * number.c (Fcoerce_number): + * number.c (vars_of_number): + * number.h (INTEGERP): + * number.h (make_integer): + * number.h (NATNUMP): + * number.h (CHECK_NATNUM): + * print.c (output_string): + * print.c (print_vector_internal): + * print.c (print_cons): + * print.c (print_string): + * print.c (print_preprocess_inchash_eq): + * print.c (print_seen_once): + * print.c (print_nonsymbol_seen_once): + * print.c (print_sort_get_numbers): + * print.c (print_gensym_or_circle): + * print.c (nsubst_structures_descend): + * print.c (print_internal): + * print.c (restore_inhibit_non_essential_conversion_operations): + * print.c (begin_inhibit_non_essential_conversion_operations): + * print.c (debug_print_enter): + * print.c (debug_p4): + * process-nt.c (validate_signal_number): + * process-nt.c (nt_send_process): + * process-nt.c (nt_open_network_stream): + * process-nt.c (Fmswindows_set_process_priority): + * process-unix.c: + * process-unix.c (connect_to_file_descriptor): + * process-unix.c (get_internet_address): + * process-unix.c (child_setup): + * process-unix.c (unix_update_status_if_terminated): + * process-unix.c (unix_reap_exited_processes): + * process-unix.c (unix_send_process): + * process-unix.c (unix_kill_child_process): + * process-unix.c (unix_open_network_stream): + * process-unix.c (unix_open_multicast_group): + * process.c (create_process): + * process.c (Fstart_process_internal): + * process.c (Fset_process_window_size): + * process.c (read_process_output): + * process.c (status_message): + * process.c (status_notify): + * process.c (Fprocess_exit_status): + * process.c (decode_signal): + * process.c (Fprocess_send_eof): + * profile.c: + * profile.c (profile_sow_backtrace): + * profile.c (profile_reap_backtrace): + * profile.c (Fstart_profiling): + * profile.c (get_profiling_info_timing_maphash): + * profile.c (Fget_profiling_info): + * profile.c (set_profiling_info_timing_maphash): + * ralloc.c: + * ralloc.c (MLVAL): + * rangetab.c (Fget_range_table): + * rangetab.c (Fput_range_table): + * rangetab.c (Fmap_range_table): + * rangetab.c (rangetab_data_validate): + * redisplay-msw.c (mswindows_output_vertical_divider): + * redisplay-output.c (redisplay_move_cursor): + * redisplay-output.c (redisplay_output_layout): + * redisplay-output.c (redisplay_output_window): + * redisplay-output.c (redisplay_redraw_exposed_area_1): + * redisplay-output.c (redisplay_redraw_exposed_area): + * redisplay-output.c (bevel_modeline): + * redisplay-xlike-inc.c (XLIKE_get_gc): + * redisplay-xlike-inc.c (XLIKE_output_string): + * redisplay-xlike-inc.c (XLIKE_output_vertical_divider): + * redisplay-xlike-inc.c (XLIKE_output_blank): + * redisplay-xlike-inc.c (XLIKE_output_eol_cursor): + * redisplay.c (tab_char_width): + * redisplay.c (add_glyph_rune): + * redisplay.c (create_text_block): + * redisplay.c (generate_fstring_runes): + * redisplay.c (create_string_text_block): + * redisplay.c (regenerate_window): + * redisplay.c (regenerate_window_extents_only_changed): + * redisplay.c (regenerate_window_incrementally): + * redisplay.c (regenerate_window_point_center): + * redisplay.c (redisplay_window): + * redisplay.c (validate_line_start_cache): + * redisplay.c (update_line_start_cache): + * scrollbar-gtk.c (scrollbar_cb): + * scrollbar-msw.c (mswindows_handle_scrollbar_event): + * scrollbar-x.c (x_update_vertical_scrollbar_callback): + * scrollbar-x.c (x_update_horizontal_scrollbar_callback): + * scrollbar.c (scrollbar_reset_cursor): + * scrollbar.c (Fscrollbar_line_up): + * scrollbar.c (Fscrollbar_line_down): + * scrollbar.c (Fscrollbar_page_up): + * scrollbar.c (Fscrollbar_page_down): + * scrollbar.c (Fscrollbar_to_bottom): + * scrollbar.c (Fscrollbar_vertical_drag): + * scrollbar.c (Fscrollbar_set_hscroll): + * scrollbar.c (specifier_vars_of_scrollbar): + * search.c (string_match_1): + * search.c (skip_chars): + * search.c (search_command): + * search.c (Freplace_match): + * search.c (match_limit): + * search.c (Fmatch_data): + * search.c (Fstore_match_data): + * select-gtk.c (gtk_get_foreign_selection): + * select-msw.c (x_sym_p): + * select-msw.c (symbol_to_ms_cf): + * select-msw.c (ms_cf_to_symbol): + * select-msw.c (mswindows_own_selection): + * select-msw.c (mswindows_register_selection_data_type): + * select-msw.c (mswindows_selection_data_type_name): + * select-x.c: + * select-x.c (x_get_foreign_selection): + * select-x.c (Fx_get_cutbuffer_internal): + * select-x.c (Fx_rotate_cutbuffers_internal): + * select-xlike-inc.c (selection_data_to_lisp_data): + * select-xlike-inc.c (lisp_data_to_selection_data): + * select.c (Favailable_selection_types): + * sgiplay.c (close_sound_file): + * sgiplay.c (play_sound_file): + * sgiplay.c (restore_audio_port): + * sgiplay.c (audio_initialize): + * sgiplay.c (set_channels): + * sgiplay.c (set_output_format): + * sound.c (Fplay_sound_file): + * sound.c (parse_sound_alist_elt): + * sound.c (Fplay_sound): + * specifier.c: + * specifier.c (print_specifier): + * specifier.c (canonicalize_tag_set): + * specifier.c (call_charset_predicate): + * specifier.c (Fdefine_specifier_tag): + * specifier.c (specifier_instance_1): + * specifier.c (integer_validate): + * specifier.h (XFIXNUMEGER_SPECIFIER): + * symbols.c: + * symbols.c (Fintern): + * symbols.c (Fintern_soft): + * symbols.c (Funintern): + * symbols.c (oblookup): + * symbols.c (do_symval_forwarding): + * symbols.c (set_default_buffer_slot_variable): + * symbols.c (set_default_console_slot_variable): + * symbols.c (store_symval_forwarding): + * symbols.c (Fset): + * symbols.c (Fsetq_default): + * symbols.c (symbol_value_buffer_local_info): + * symbols.c (user_variable_alias_check_fun): + * symbols.c (Fuser_variable_p): + * syntax.c (Fsyntax_cache_info): + * syntax.c (Fset_syntax_table): + * syntax.c (reset_syntax_cache_range): + * syntax.c (update_syntax_cache): + * syntax.c (syntax_match): + * syntax.c (Fforward_word): + * syntax.c (Fforward_comment): + * syntax.c (scan_lists): + * syntax.c (Fscan_lists): + * syntax.c (Fscan_sexps): + * syntax.c (scan_sexps_forward): + * syntax.c (Fparse_partial_sexp): + * syntax.c (copy_to_mirrortab): + * syntax.c (copy_if_not_already_present): + * syntax.c (update_just_this_syntax_table): + * syntax.c (define_standard_syntax): + * syntax.c (SET_RANGE_SYNTAX): + * syntax.c (complex_vars_of_syntax): + * syntax.h: + * sysdep.c: + * sysdep.c (init_system_name): + * sysdep.c (get_random): + * tests.c: + * tests.c (test_hash_tables_mapper): + * tests.c (test_hash_tables_modifying_mapper): + * tests.c (test_hash_tables_predicate): + * tests.c (Ftest_hash_tables): + * text.c (get_buffer_pos_char): + * text.c (get_string_pos_char_1): + * text.c (non_ascii_valid_ichar_p): + * text.c (Fmake_char): + * text.c (Fchar_octet): + * text.c (Fsplit_char): + * toolbar-msw.c (allocate_toolbar_item_id): + * toolbar-msw.c (mswindows_clear_toolbar): + * toolbar-msw.c (mswindows_output_toolbar): + * toolbar-msw.c (mswindows_get_toolbar_button_text): + * toolbar-msw.c (mswindows_handle_toolbar_wm_command): + * toolbar-xlike.c (__prepare_button_area): + * toolbar-xlike.c (xlike_get_button_size): + * toolbar.c (Fcheck_toolbar_button_syntax): + * toolbar.c (specifier_vars_of_toolbar): + * tooltalk.c (tooltalk_constant_value): + * tooltalk.c (Fadd_tooltalk_message_arg): + * tooltalk.c (Fadd_tooltalk_pattern_arg): + * tooltalk.c (init_tooltalk): + * tooltalk.c (MAKE_CONSTANT): + * tooltalk.c (vars_of_tooltalk): + * tooltalk.h (CHECK_TOOLTALK_CONSTANT): + * tooltalk.h (VALID_TOOLTALK_MESSAGEP): + * ui-byhand.c (Fgtk_box_query_child_packing): + * ui-byhand.c (Fgtk_button_box_get_child_size): + * ui-byhand.c (Fgtk_calendar_get_date): + * ui-byhand.c (Fgtk_clist_get_text): + * ui-byhand.c (Fgtk_clist_get_selection): + * ui-byhand.c (Fgtk_clist_get_pixmap): + * ui-byhand.c (Fgtk_clist_get_pixtext): + * ui-byhand.c (Fgtk_editable_insert_text): + * ui-byhand.c (Fgtk_curve_get_vector): + * ui-byhand.c (Fgtk_notebook_query_tab_label_packing): + * ui-byhand.c (Fgtk_widget_get_pointer): + * ui-byhand.c (generic_toolbar_insert_item): + * ui-byhand.c (Fgtk_toolbar_insert_item): + * ui-byhand.c (Fgtk_ctree_recurse): + * ui-gtk.c: + * ui-gtk.c (import_gtk_enumeration_internal): + * ui-gtk.c (Fgtk_call_function): + * ui-gtk.c (__internal_callback_destroy): + * ui-gtk.c (Fgtk_signal_connect): + * ui-gtk.c (Fgtk_fundamental_type): + * ui-gtk.c (Fgtk_object_type): + * ui-gtk.c (Fgtk_describe_type): + * ui-gtk.c (gtk_type_to_lisp): + * ui-gtk.c (lisp_to_gtk_type): + * ui-gtk.c (lisp_to_gtk_ret_type): + * ui-gtk.c (get_enumeration): + * ui-gtk.c (symbol_to_enum): + * ui-gtk.c (flags_to_list): + * ui-gtk.c (enum_to_symbol): + * undo.c (undo_prelude): + * undo.c (record_insert): + * undo.c (record_delete): + * undo.c (record_property_change): + * undo.c (Fprimitive_undo): + * unicode.c (unicode_to_ichar): + * unicode.c (Fchar_to_unicode): + * unicode.c (Funicode_to_char): + * unicode.c (add_lisp_string_to_skip_chars_range): + * unicode.c (unicode_query): + * unicode.c (vars_of_unicode): + * win32.c (Fmswindows_shell_execute): + * window-impl.h (MODELINE_OFF_SHADOW_THICKNESS_ADJUSTED): + * window-impl.h (MODELINE_SHADOW_THICKNESS): + * window.c (window_divider_width): + * window.c (window_scrollbar_width): + * window.c (window_scrollbar_height): + * window.c (margin_width_internal): + * window.c (Fpos_visible_in_window_p): + * window.c (Fwindow_height): + * window.c (Fwindow_displayed_height): + * window.c (Fwindow_pixel_height): + * window.c (Fwindow_text_area_height): + * window.c (Fwindow_width): + * window.c (Fwindow_full_width): + * window.c (Fwindow_pixel_width): + * window.c (Fwindow_hscroll): + * window.c (Fmodeline_hscroll): + * window.c (Fset_modeline_hscroll): + * window.c (Fset_window_hscroll): + * window.c (Fwindow_pixel_edges): + * window.c (Fwindow_end): + * window.c (Fwindow_last_line_visible_height): + * window.c (Fset_window_point): + * window.c (Fset_window_start): + * window.c (unshow_buffer): + * window.c (Fother_window): + * window.c (window_loop): + * window.c (buffer_window_count): + * window.c (Fdelete_other_windows): + * window.c (Fset_window_buffer): + * window.c (Fselect_window): + * window.c (temp_output_buffer_show): + * window.c (Fsplit_window): + * window.c (Fenlarge_window): + * window.c (Fenlarge_window_pixels): + * window.c (Fshrink_window): + * window.c (Fshrink_window_pixels): + * window.c (window_scroll): + * window.c (Fscroll_left): + * window.c (Fscroll_right): + * window.c (Fcenter_to_window_line): + * window.c (Fmove_to_window_line): + * window.c (get_current_pixel_pos): + * window.c (Fcurrent_pixel_column): + * window.c (Fcurrent_pixel_row): + * window.c (specifier_vars_of_window): + * xemacs.def.in.in: + Mechanically change INT (where it refers to non-bignum Lisp + integers) to FIXNUM in our sources. Done for the following + functions, enums, and macros: Lisp_Type_Int_Even, + Lisp_Type_Int_Odd, INT_GCBITS, INT_VALBITS, make_int(), INTP(), + XINT(), CHECK_INT(), XREALINT(), INT_PLUS(), INT_MINUS(), + EMACS_INT_MAX (to MOST_POSITIVE_FIXNUM), EMACS_INT_MIN (to + MOST_NEGATIVE_FIXNUM), NUMBER_FITS_IN_AN_EMACS_INT() to + NUMBER_FITS_IN_A_FIXNUM(), XFLOATINT, XCHAR_OR_INT, INT_OR_FLOAT. + The EMACS_INT typedef was not changed, it does not describe + non-bignum Lisp integers. + Script that did the change available in + http://mid.gmane.org/20067.17650.181273.12014＠parhasard.net . + 2011-09-06 Aidan Kehoe <kehoea(a)parhasard.net&gt; * redisplay-tty.c (init_tty_for_redisplay): diff -r a0e81357194e -r 56144c8593a8 src/EmacsFrame.c --- a/src/EmacsFrame.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/EmacsFrame.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -396,13 +396,13 ＠＠ new_->emacs_frame.scrollbar_width) Fadd_spec_to_specifier (Vscrollbar_width, - make_int (new_->emacs_frame.scrollbar_width), + make_fixnum (new_->emacs_frame.scrollbar_width), wrap_frame (f), Qnil, Qnil); if (cur->emacs_frame.scrollbar_height != new_->emacs_frame.scrollbar_height) Fadd_spec_to_specifier (Vscrollbar_height, - make_int (new_->emacs_frame.scrollbar_height), + make_fixnum (new_->emacs_frame.scrollbar_height), wrap_frame (f), Qnil, Qnil); #endif /* HAVE_SCROLLBARS */ #ifdef HAVE_TOOLBARS ＠＠ -410,49 +410,49 ＠＠ new_->emacs_frame.top_toolbar_height) Fadd_spec_to_specifier (Vtoolbar_size[TOP_EDGE], - make_int (new_->emacs_frame.top_toolbar_height), + make_fixnum (new_->emacs_frame.top_toolbar_height), wrap_frame (f), Qnil, Qnil); if (cur->emacs_frame.bottom_toolbar_height != new_->emacs_frame.bottom_toolbar_height) Fadd_spec_to_specifier (Vtoolbar_size[BOTTOM_EDGE], - make_int (new_->emacs_frame.bottom_toolbar_height), + make_fixnum (new_->emacs_frame.bottom_toolbar_height), wrap_frame (f), Qnil, Qnil); if (cur->emacs_frame.left_toolbar_width != new_->emacs_frame.left_toolbar_width) Fadd_spec_to_specifier (Vtoolbar_size[LEFT_EDGE], - make_int (new_->emacs_frame.left_toolbar_width), + make_fixnum (new_->emacs_frame.left_toolbar_width), wrap_frame (f), Qnil, Qnil); if (cur->emacs_frame.right_toolbar_width != new_->emacs_frame.right_toolbar_width) Fadd_spec_to_specifier (Vtoolbar_size[RIGHT_EDGE], - make_int (new_->emacs_frame.right_toolbar_width), + make_fixnum (new_->emacs_frame.right_toolbar_width), wrap_frame (f), Qnil, Qnil); if (cur->emacs_frame.top_toolbar_border_width != new_->emacs_frame.top_toolbar_border_width) Fadd_spec_to_specifier (Vtoolbar_border_width[TOP_EDGE], - make_int (new_->emacs_frame.top_toolbar_border_width), + make_fixnum (new_->emacs_frame.top_toolbar_border_width), wrap_frame (f), Qnil, Qnil); if (cur->emacs_frame.bottom_toolbar_border_width != new_->emacs_frame.bottom_toolbar_border_width) Fadd_spec_to_specifier (Vtoolbar_border_width[BOTTOM_EDGE], - make_int (new_->emacs_frame.bottom_toolbar_border_width), + make_fixnum (new_->emacs_frame.bottom_toolbar_border_width), wrap_frame (f), Qnil, Qnil); if (cur->emacs_frame.left_toolbar_border_width != new_->emacs_frame.left_toolbar_border_width) Fadd_spec_to_specifier (Vtoolbar_border_width[LEFT_EDGE], - make_int (new_->emacs_frame.left_toolbar_border_width), + make_fixnum (new_->emacs_frame.left_toolbar_border_width), wrap_frame (f), Qnil, Qnil); if (cur->emacs_frame.right_toolbar_border_width != new_->emacs_frame.right_toolbar_border_width) Fadd_spec_to_specifier (Vtoolbar_border_width[RIGHT_EDGE], - make_int (new_->emacs_frame.right_toolbar_border_width), + make_fixnum (new_->emacs_frame.right_toolbar_border_width), wrap_frame (f), Qnil, Qnil); #endif /* HAVE_TOOLBARS */ diff -r a0e81357194e -r 56144c8593a8 src/README --- a/src/README Sat Oct 08 12:26:09 2011 +0100 +++ b/src/README Sun Oct 09 09:51:57 2011 +0100 ＠＠ -19,9 +19,9 ＠＠ is incompatible with the union form of Lisp objects, and use as an rvalue is likely to lead to errors and doesn't really save much time. Expressions of the form `XFASTINT (obj) = num;' get replaced - by `obj = make_int (num);' or `XSETINT (obj, num);' and + by `obj = make_fixnum (num);' or `XSETINT (obj, num);' and expressions of the form `num = XFASTINT (obj);' get replaced by - `num = XINT (obj);'. Use Qzero in place of `make_int (0)'. + `num = XFIXNUM (obj);'. Use Qzero in place of `make_fixnum (0)'. -- Use of XTYPE gets replaced by the appropriate predicate. Using XTYPE only works for the small number of types that are not stored diff -r a0e81357194e -r 56144c8593a8 src/abbrev.c --- a/src/abbrev.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/abbrev.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -370,13 +370,13 ＠＠ if (!abbrev_all_caps && scan_words (buf, point, -1) > scan_words (buf, abbrev_start, 1)) { - Fupcase_initials_region (make_int (abbrev_start), make_int (point), + Fupcase_initials_region (make_fixnum (abbrev_start), make_fixnum (point), wrap_buffer (buf)); } else { /* If expansion is one word, or if user says so, upcase it all. */ - Fupcase_region (make_int (abbrev_start), make_int (point), + Fupcase_region (make_fixnum (abbrev_start), make_fixnum (point), wrap_buffer (buf)); } } ＠＠ -390,7 +390,7 ＠＠ BUF_FETCH_CHAR (buf, pos))) pos++; /* Change just that. */ - Fupcase_initials_region (make_int (pos), make_int (pos + 1), + Fupcase_initials_region (make_fixnum (pos), make_fixnum (pos + 1), wrap_buffer (buf)); } ＠＠ -408,7 +408,7 ＠＠ /* This function can GC */ struct buffer *buf = current_buffer; - if (INTP (XSYMBOL (sym)->plist)) + if (FIXNUMP (XSYMBOL (sym)->plist)) { count = XSYMBOL (sym)->plist; system_flag = Qnil; ＠＠ -441,7 +441,7 ＠＠ /* This function can GC */ struct buffer *buf = current_buffer; - if (INTP (XSYMBOL (sym)->plist)) + if (FIXNUMP (XSYMBOL (sym)->plist)) { count = XSYMBOL (sym)->plist; system_flag = Qnil; ＠＠ -455,23 +455,23 ＠＠ if (NILP (XSYMBOL_VALUE (sym))) return; - one = make_int (1); + one = make_fixnum (1); Fprin1 (Fsymbol_name (sym), stream); if (!NILP (system_flag)) { buffer_insert_ascstring (buf, " (sys)"); - Findent_to (make_int (20), one, Qnil); + Findent_to (make_fixnum (20), one, Qnil); } else - Findent_to (make_int (15), one, Qnil); + Findent_to (make_fixnum (15), one, Qnil); Fprin1 (count, stream); - Findent_to (make_int (20), one, Qnil); + Findent_to (make_fixnum (20), one, Qnil); Fprin1 (XSYMBOL_VALUE (sym), stream); if (!NILP (XSYMBOL (sym)->function)) { - Findent_to (make_int (45), one, Qnil); + Findent_to (make_fixnum (45), one, Qnil); Fprin1 (XSYMBOL (sym)->function, stream); } buffer_insert_ascstring (buf, "\n"); diff -r a0e81357194e -r 56144c8593a8 src/alloc.c --- a/src/alloc.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/alloc.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1583,9 +1583,9 ＠＠ Lisp_Object val = Qnil; Elemcount size; - check_integer_range (length, Qzero, make_integer (EMACS_INT_MAX)); - - size = XINT (length); + check_integer_range (length, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); + + size = XFIXNUM (length); while (size--) val = Fcons (object, val); ＠＠ -1862,8 +1862,8 ＠＠ */ (length, object)) { - check_integer_range (length, Qzero, make_int (ARRAY_DIMENSION_LIMIT)); - return make_vector (XINT (length), object); + check_integer_range (length, Qzero, make_fixnum (ARRAY_DIMENSION_LIMIT)); + return make_vector (XFIXNUM (length), object); } DEFUN ("vector", Fvector, 0, MANY, 0, /* ＠＠ -2044,8 +2044,8 ＠＠ */ (length, bit)) { - check_integer_range (length, Qzero, make_int (ARRAY_DIMENSION_LIMIT)); - return make_bit_vector (XINT (length), bit); + check_integer_range (length, Qzero, make_fixnum (ARRAY_DIMENSION_LIMIT)); + return make_bit_vector (XFIXNUM (length), bit); } DEFUN ("bit-vector", Fbit_vector, 0, MANY, 0, /* ＠＠ -2135,7 +2135,7 ＠＠ if (nargs < 4 || nargs > 6) return Fsignal (Qwrong_number_of_arguments, - list2 (intern ("make-byte-code"), make_int (nargs))); + list2 (intern ("make-byte-code"), make_fixnum (nargs))); /* Check for valid formal parameter list now, to allow us to use SPECBIND_FAST_UNSAFE() later in funcall_compiled_function(). */ ＠＠ -2158,7 +2158,7 ＠＠ if (CONSP (instructions)) { CHECK_STRING (XCAR (instructions)); - CHECK_INT (XCDR (instructions)); + CHECK_FIXNUM (XCDR (instructions)); } else { ＠＠ -2170,8 +2170,8 ＠＠ CHECK_VECTOR (constants); f->constants = constants; - check_integer_range (stack_depth, Qzero, make_int (USHRT_MAX)); - f->stack_depth = (unsigned short) XINT (stack_depth); + check_integer_range (stack_depth, Qzero, make_fixnum (USHRT_MAX)); + f->stack_depth = (unsigned short) XFIXNUM (stack_depth); #ifdef COMPILED_FUNCTION_ANNOTATION_HACK f->annotated = Vload_file_name_internal; ＠＠ -2534,7 +2534,7 ＠＠ if (CONSP (*ptr) && EXTENT_INFOP (XCAR (*ptr))) ptr = &XCDR (*ptr); - if (CONSP (*ptr) && INTP (XCAR (*ptr))) + if (CONSP (*ptr) && FIXNUMP (XCAR (*ptr))) ptr = &XCDR (*ptr); return ptr; } ＠＠ -3006,26 +3006,26 ＠＠ */ (length, character)) { - check_integer_range (length, Qzero, make_int (ARRAY_DIMENSION_LIMIT)); + check_integer_range (length, Qzero, make_fixnum (ARRAY_DIMENSION_LIMIT)); CHECK_CHAR_COERCE_INT (character); { Ibyte init_str[MAX_ICHAR_LEN]; int len = set_itext_ichar (init_str, XCHAR (character)); - Lisp_Object val = make_uninit_string (len * XINT (length)); + Lisp_Object val = make_uninit_string (len * XFIXNUM (length)); if (len == 1) { /* Optimize the single-byte case */ memset (XSTRING_DATA (val), XCHAR (character), XSTRING_LENGTH (val)); XSET_STRING_ASCII_BEGIN (val, min (MAX_STRING_ASCII_BEGIN, - len * XINT (length))); + len * XFIXNUM (length))); } else { EMACS_INT i; Ibyte *ptr = XSTRING_DATA (val); - for (i = XINT (length); i; i--) + for (i = XFIXNUM (length); i; i--) { Ibyte *init_ptr = init_str; switch (len) ＠＠ -4046,7 +4046,7 ＠＠ /* C doesn't have local functions (or closures, or GC, or readable syntax, or portable numeric datatypes, or bit-vectors, or characters, or arrays, or exceptions, or ...) */ - return cons3 (intern (name), make_int (value), tail); + return cons3 (intern (name), make_fixnum (value), tail); } /* Pluralize a lowercase English word stored in BUF, assuming BUF has ＠＠ -4230,30 +4230,30 ＠＠ #ifdef NEW_GC return list6 - (Fcons (make_int (lrecord_stats[lrecord_type_cons].instances_in_use), - make_int (lrecord_stats[lrecord_type_cons] + (Fcons (make_fixnum (lrecord_stats[lrecord_type_cons].instances_in_use), + make_fixnum (lrecord_stats[lrecord_type_cons] .bytes_in_use_including_overhead)), - Fcons (make_int (lrecord_stats[lrecord_type_symbol].instances_in_use), - make_int (lrecord_stats[lrecord_type_symbol] + Fcons (make_fixnum (lrecord_stats[lrecord_type_symbol].instances_in_use), + make_fixnum (lrecord_stats[lrecord_type_symbol] .bytes_in_use_including_overhead)), - Fcons (make_int (lrecord_stats[lrecord_type_marker].instances_in_use), - make_int (lrecord_stats[lrecord_type_marker] + Fcons (make_fixnum (lrecord_stats[lrecord_type_marker].instances_in_use), + make_fixnum (lrecord_stats[lrecord_type_marker] .bytes_in_use_including_overhead)), - make_int (lrecord_stats[lrecord_type_string] + make_fixnum (lrecord_stats[lrecord_type_string] .bytes_in_use_including_overhead), - make_int (lrecord_stats[lrecord_type_vector] + make_fixnum (lrecord_stats[lrecord_type_vector] .bytes_in_use_including_overhead), object_memory_usage_stats (1)); #else /* not NEW_GC */ return - list6 (Fcons (make_int (gc_count_num_cons_in_use), - make_int (gc_count_num_cons_freelist)), - Fcons (make_int (gc_count_num_symbol_in_use), - make_int (gc_count_num_symbol_freelist)), - Fcons (make_int (gc_count_num_marker_in_use), - make_int (gc_count_num_marker_freelist)), - make_int (gc_count_string_total_size), - make_int (lrecord_stats[lrecord_type_vector].bytes_in_use + + list6 (Fcons (make_fixnum (gc_count_num_cons_in_use), + make_fixnum (gc_count_num_cons_freelist)), + Fcons (make_fixnum (gc_count_num_symbol_in_use), + make_fixnum (gc_count_num_symbol_freelist)), + Fcons (make_fixnum (gc_count_num_marker_in_use), + make_fixnum (gc_count_num_marker_freelist)), + make_fixnum (gc_count_string_total_size), + make_fixnum (lrecord_stats[lrecord_type_vector].bytes_in_use + lrecord_stats[lrecord_type_vector].bytes_freed + lrecord_stats[lrecord_type_vector].bytes_on_free_list), object_memory_usage_stats (1)); ＠＠ -4318,9 +4318,9 ＠＠ lisp_object_storage_size (object, &object_stats); val = Facons (Qobject_actually_requested, - make_int (object_stats.was_requested), val); + make_fixnum (object_stats.was_requested), val); val = Facons (Qobject_malloc_overhead, - make_int (object_stats.malloc_overhead), val); + make_fixnum (object_stats.malloc_overhead), val); assert (!object_stats.dynarr_overhead); assert (!object_stats.gap_overhead); ＠＠ -4331,15 +4331,15 ＠＠ val = Fcons (Qt, val); val = Facons (Qother_memory_actually_requested, - make_int (gustats.u.was_requested), val); + make_fixnum (gustats.u.was_requested), val); val = Facons (Qother_memory_malloc_overhead, - make_int (gustats.u.malloc_overhead), val); + make_fixnum (gustats.u.malloc_overhead), val); if (gustats.u.dynarr_overhead) val = Facons (Qother_memory_dynarr_overhead, - make_int (gustats.u.dynarr_overhead), val); + make_fixnum (gustats.u.dynarr_overhead), val); if (gustats.u.gap_overhead) val = Facons (Qother_memory_gap_overhead, - make_int (gustats.u.gap_overhead), val); + make_fixnum (gustats.u.gap_overhead), val); val = Fcons (Qnil, val); i = 0; ＠＠ -4350,7 +4350,7 ＠＠ val = Fcons (item, val); else { - val = Facons (item, make_int (gustats.othervals[i]), val); + val = Facons (item, make_fixnum (gustats.othervals[i]), val); i++; } } ＠＠ -4486,7 +4486,7 ＠＠ */ ()) { - return make_int (total_gc_usage + consing_since_gc); + return make_fixnum (total_gc_usage + consing_since_gc); } #endif /* ALLOC_TYPE_STATS */ ＠＠ -5540,7 +5540,7 ＠＠ */ ()) { - return make_int (consing_since_gc); + return make_fixnum (consing_since_gc); } #if 0 ＠＠ -5551,7 +5551,7 ＠＠ */ ()) { - return make_int ((EMACS_INT) sbrk (0) / 1024); + return make_fixnum ((EMACS_INT) sbrk (0) / 1024); } #endif ＠＠ -5564,7 +5564,7 ＠＠ */ ()) { - return make_int (total_data_usage ()); + return make_fixnum (total_data_usage ()); } #ifdef USE_VALGRIND ＠＠ -5600,7 +5600,7 ＠＠ common_init_alloc_early (void) { #ifndef Qzero - Qzero = make_int (0); /* Only used if Lisp_Object is a union type */ + Qzero = make_fixnum (0); /* Only used if Lisp_Object is a union type */ #endif #ifndef Qnull_pointer diff -r a0e81357194e -r 56144c8593a8 src/buffer.c --- a/src/buffer.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/buffer.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -636,7 +636,7 ＠＠ init_buffer_markers (b); init_buffer_syntax_cache (b); - b->generated_modeline_string = Fmake_string (make_int (84), make_int (' ')); + b->generated_modeline_string = Fmake_string (make_fixnum (84), make_fixnum (' ')); b->modeline_extent_table = make_lisp_hash_table (20, HASH_TABLE_KEY_WEAK, Qeq); ＠＠ -739,7 +739,7 ＠＠ /* For each slot that has a default value, copy that into the slot. */ #define MARKED_SLOT(slot) \ - { int mask = XINT (buffer_local_flags.slot); \ + { int mask = XFIXNUM (buffer_local_flags.slot); \ if ((mask > 0 || mask == -1 || mask == -3) \ && (first_time \ || NILP (Fget (XBUFFER (Vbuffer_local_symbols)->slot, \ ＠＠ -889,7 +889,7 ＠＠ { struct buffer *syms = XBUFFER (Vbuffer_local_symbols); #define MARKED_SLOT(slot) \ - { int mask = XINT (buffer_local_flags.slot); \ + { int mask = XFIXNUM (buffer_local_flags.slot); \ if (mask == 0 || mask == -1 \ || ((mask > 0) && (buf->local_var_flags & mask))) \ result = Fcons (Fcons (syms->slot, buf->slot), result); \ ＠＠ -969,7 +969,7 ＠＠ { struct buffer *buf = decode_buffer (buffer, 0); - return make_int (BUF_MODIFF (buf)); + return make_fixnum (BUF_MODIFF (buf)); }  DEFUN ("rename-buffer", Frename_buffer, 1, 2, ＠＠ -1513,7 +1513,7 ＠＠ Lisp_Object current_window = Fselected_window (Qnil); if (!NILP (current_window) && EQ(Fwindow_buffer (current_window), wrap_buffer (old_buf))) - Fset_window_point (current_window, make_int (BUF_PT (old_buf))); + Fset_window_point (current_window, make_fixnum (BUF_PT (old_buf))); /* Put the undo list back in the base buffer, so that it appears that an indirect buffer shares the undo list of its base. */ ＠＠ -1816,7 +1816,7 ＠＠ b = XBUFFER (buffer); #define ADD_INT(field) \ - plist = cons3 (make_int (b->text->field), \ + plist = cons3 (make_fixnum (b->text->field), \ intern_massaging_name (#field), plist) #define ADD_BOOL(field) \ plist = cons3 (b->text->field ? Qt : Qnil, \ ＠＠ -1843,11 +1843,11 ＠＠ Lisp_Object pos[NUM_CACHED_POSITIONS]; int i; for (i = 0; i < b->text->next_cache_pos; i++) - pos[i] = make_int (b->text->mule_charbpos_cache[i]); + pos[i] = make_fixnum (b->text->mule_charbpos_cache[i]); plist = cons3 (Flist (b->text->next_cache_pos, pos), intern ("mule-charbpos-cache"), plist); for (i = 0; i < b->text->next_cache_pos; i++) - pos[i] = make_int (b->text->mule_bytebpos_cache[i]); + pos[i] = make_fixnum (b->text->mule_bytebpos_cache[i]); plist = cons3 (Flist (b->text->next_cache_pos, pos), intern ("mule-bytebpos-cache"), plist); } ＠＠ -1866,9 +1866,9 ＠＠ Lisp_Object plist = Qnil; CHECK_STRING (string); - plist = cons3 (make_int (XSTRING_LENGTH (string)), + plist = cons3 (make_fixnum (XSTRING_LENGTH (string)), intern ("byte-length"), plist); - plist = cons3 (make_int (XSTRING_ASCII_BEGIN (string)), + plist = cons3 (make_fixnum (XSTRING_ASCII_BEGIN (string)), intern ("ascii-begin"), plist); return Fnreverse (plist); ＠＠ -2243,9 +2243,9 ＠＠ defs->modeline_format = build_ascstring ("%-"); /* reset in loaddefs.el */ defs->case_fold_search = Qt; defs->selective_display_ellipses = Qt; - defs->tab_width = make_int (8); + defs->tab_width = make_fixnum (8); defs->ctl_arrow = Qt; - defs->fill_column = make_int (70); + defs->fill_column = make_fixnum (70); defs->left_margin = Qzero; defs->saved_size = Qzero; /* lisp code wants int-or-nil */ defs->modtime = 0; ＠＠ -2267,9 +2267,9 ＠＠ * >0 is mask. Var is local if ((buffer->local_var_flags & mask) != 0) * Otherwise default is used. */ - Lisp_Object always_local_no_default = make_int (0); - Lisp_Object always_local_resettable = make_int (-1); - Lisp_Object resettable = make_int (-3); + Lisp_Object always_local_no_default = make_fixnum (0); + Lisp_Object always_local_resettable = make_fixnum (-1); + Lisp_Object resettable = make_fixnum (-3); /* Assign the local-flags to the slots that have default values. The local flag is a bit that is used in the buffer ＠＠ -2279,7 +2279,7 ＠＠ set_lheader_implementation ((struct lrecord_header *) &buffer_local_flags, &lrecord_buffer); - nuke_all_buffer_slots (&buffer_local_flags, make_int (-2)); + nuke_all_buffer_slots (&buffer_local_flags, make_fixnum (-2)); buffer_local_flags.filename = always_local_no_default; buffer_local_flags.directory = always_local_no_default; buffer_local_flags.backed_up = always_local_no_default; ＠＠ -2306,28 +2306,28 ＠＠ buffer_local_flags.category_table = resettable; #endif buffer_local_flags.display_time = always_local_no_default; - buffer_local_flags.display_count = make_int (0); - - buffer_local_flags.modeline_format = make_int (1<<0); - buffer_local_flags.abbrev_mode = make_int (1<<1); - buffer_local_flags.overwrite_mode = make_int (1<<2); - buffer_local_flags.case_fold_search = make_int (1<<3); - buffer_local_flags.auto_fill_function = make_int (1<<4); - buffer_local_flags.selective_display = make_int (1<<5); - buffer_local_flags.selective_display_ellipses = make_int (1<<6); - buffer_local_flags.tab_width = make_int (1<<7); - buffer_local_flags.truncate_lines = make_int (1<<8); - buffer_local_flags.ctl_arrow = make_int (1<<9); - buffer_local_flags.fill_column = make_int (1<<10); - buffer_local_flags.left_margin = make_int (1<<11); - buffer_local_flags.abbrev_table = make_int (1<<12); + buffer_local_flags.display_count = make_fixnum (0); + + buffer_local_flags.modeline_format = make_fixnum (1<<0); + buffer_local_flags.abbrev_mode = make_fixnum (1<<1); + buffer_local_flags.overwrite_mode = make_fixnum (1<<2); + buffer_local_flags.case_fold_search = make_fixnum (1<<3); + buffer_local_flags.auto_fill_function = make_fixnum (1<<4); + buffer_local_flags.selective_display = make_fixnum (1<<5); + buffer_local_flags.selective_display_ellipses = make_fixnum (1<<6); + buffer_local_flags.tab_width = make_fixnum (1<<7); + buffer_local_flags.truncate_lines = make_fixnum (1<<8); + buffer_local_flags.ctl_arrow = make_fixnum (1<<9); + buffer_local_flags.fill_column = make_fixnum (1<<10); + buffer_local_flags.left_margin = make_fixnum (1<<11); + buffer_local_flags.abbrev_table = make_fixnum (1<<12); #ifdef REGION_CACHE_NEEDS_WORK - buffer_local_flags.cache_long_line_scans = make_int (1<<13); + buffer_local_flags.cache_long_line_scans = make_fixnum (1<<13); #endif - buffer_local_flags.buffer_file_coding_system = make_int (1<<14); + buffer_local_flags.buffer_file_coding_system = make_fixnum (1<<14); /* #### Warning: 1<<31 is the largest number currently allowable - due to the XINT() handling of this value. With some + due to the XFIXNUM() handling of this value. With some rearrangement you can get 3 more bits. #### 3 more? 34 bits???? -ben */ ＠＠ -2867,8 +2867,8 ＠＠ slot of buffer_local_flags and vice-versa. Must be done after all DEFVAR_BUFFER_LOCAL() calls. */ #define MARKED_SLOT(slot) \ - assert ((XINT (buffer_local_flags.slot) != -2 && \ - XINT (buffer_local_flags.slot) != -3) \ + assert ((XFIXNUM (buffer_local_flags.slot) != -2 && \ + XFIXNUM (buffer_local_flags.slot) != -3) \ == !(NILP (XBUFFER (Vbuffer_local_symbols)->slot))); #include "bufslots.h" diff -r a0e81357194e -r 56144c8593a8 src/buffer.h --- a/src/buffer.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/buffer.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -647,7 +647,7 ＠＠ /* Given a Bytebpos, return the equivalent Charbpos as a Lisp Object. */ -#define make_charbpos(buf, ind) make_int (bytebpos_to_charbpos (buf, ind)) +#define make_charbpos(buf, ind) make_fixnum (bytebpos_to_charbpos (buf, ind)) /*----------------------------------------------------------------------*/ /* Converting between byte and memory positions */ diff -r a0e81357194e -r 56144c8593a8 src/bytecode.c --- a/src/bytecode.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/bytecode.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -223,9 +223,9 ＠＠ if (byte_metering_on) { Lisp_Object *p = XVECTOR_DATA (XVECTOR_DATA (Vbyte_code_meter)[this_opcode]); - p[0] = INT_PLUS1 (p[0]); + p[0] = FIXNUM_PLUS1 (p[0]); if (prev_opcode) - p[prev_opcode] = INT_PLUS1 (p[prev_opcode]); + p[prev_opcode] = FIXNUM_PLUS1 (p[prev_opcode]); } } ＠＠ -237,7 +237,7 ＠＠ { retry: - if (INTP (obj)) return make_integer (- XINT (obj)); + if (FIXNUMP (obj)) return make_integer (- XFIXNUM (obj)); if (FLOATP (obj)) return make_float (- XFLOAT_DATA (obj)); if (CHARP (obj)) return make_integer (- ((int) XCHAR (obj))); if (MARKERP (obj)) return make_integer (- ((int) marker_position (obj))); ＠＠ -291,7 +291,7 ＠＠ { case FIXNUM_T: { - EMACS_INT ival1 = XREALINT (obj1), ival2 = XREALINT (obj2); + EMACS_INT ival1 = XREALFIXNUM (obj1), ival2 = XREALFIXNUM (obj2); return ival1 < ival2 ? -1 : ival1 > ival2 ? 1 : 0; } #ifdef HAVE_BIGNUM ＠＠ -318,12 +318,12 ＠＠ { EMACS_INT ival1, ival2; - if (INTP (obj1)) ival1 = XINT (obj1); + if (FIXNUMP (obj1)) ival1 = XFIXNUM (obj1); else if (CHARP (obj1)) ival1 = XCHAR (obj1); else if (MARKERP (obj1)) ival1 = marker_position (obj1); else goto arithcompare_float; - if (INTP (obj2)) ival2 = XINT (obj2); + if (FIXNUMP (obj2)) ival2 = XFIXNUM (obj2); else if (CHARP (obj2)) ival2 = XCHAR (obj2); else if (MARKERP (obj2)) ival2 = marker_position (obj2); else goto arithcompare_float; ＠＠ -337,7 +337,7 ＠＠ double dval1, dval2; if (FLOATP (obj1)) dval1 = XFLOAT_DATA (obj1); - else if (INTP (obj1)) dval1 = (double) XINT (obj1); + else if (FIXNUMP (obj1)) dval1 = (double) XFIXNUM (obj1); else if (CHARP (obj1)) dval1 = (double) XCHAR (obj1); else if (MARKERP (obj1)) dval1 = (double) marker_position (obj1); else ＠＠ -347,7 +347,7 ＠＠ } if (FLOATP (obj2)) dval2 = XFLOAT_DATA (obj2); - else if (INTP (obj2)) dval2 = (double) XINT (obj2); + else if (FIXNUMP (obj2)) dval2 = (double) XFIXNUM (obj2); else if (CHARP (obj2)) dval2 = (double) XCHAR (obj2); else if (MARKERP (obj2)) dval2 = (double) marker_position (obj2); else ＠＠ -369,7 +369,7 ＠＠ { case FIXNUM_T: { - EMACS_INT ival1 = XREALINT (obj1), ival2 = XREALINT (obj2); + EMACS_INT ival1 = XREALFIXNUM (obj1), ival2 = XREALFIXNUM (obj2); switch (opcode) { case Bplus: ival1 += ival2; break; ＠＠ -512,7 +512,7 ＠＠ float_p = 0; - if (INTP (obj1)) ival1 = XINT (obj1); + if (FIXNUMP (obj1)) ival1 = XFIXNUM (obj1); else if (CHARP (obj1)) ival1 = XCHAR (obj1); else if (MARKERP (obj1)) ival1 = marker_position (obj1); else if (FLOATP (obj1)) ival1 = 0, float_p = 1; ＠＠ -522,7 +522,7 ＠＠ goto retry; } - if (INTP (obj2)) ival2 = XINT (obj2); + if (FIXNUMP (obj2)) ival2 = XFIXNUM (obj2); else if (CHARP (obj2)) ival2 = XCHAR (obj2); else if (MARKERP (obj2)) ival2 = marker_position (obj2); else if (FLOATP (obj2)) ival2 = 0, float_p = 1; ＠＠ -547,7 +547,7 ＠＠ case Bmax: if (ival1 < ival2) ival1 = ival2; break; case Bmin: if (ival1 > ival2) ival1 = ival2; break; } - return make_int (ival1); + return make_fixnum (ival1); } else { ＠＠ -925,8 +925,8 ＠＠ if (byte_metering_on && SYMBOLP (TOP)) { Lisp_Object val = Fget (TOP, Qbyte_code_meter, Qnil); - if (INTP (val)) - Fput (TOP, Qbyte_code_meter, make_int (XINT (val) + 1)); + if (FIXNUMP (val)) + Fput (TOP, Qbyte_code_meter, make_fixnum (XFIXNUM (val) + 1)); } #endif TOP_LVALUE = TOP; /* Ignore multiple values. */ ＠＠ -1103,12 +1103,12 ＠＠ #ifdef WITH_NUMBER_TYPES TOP_LVALUE = NUMBERP (TOP) ? Qt : Qnil; #else - TOP_LVALUE = INT_OR_FLOATP (TOP) ? Qt : Qnil; + TOP_LVALUE = FIXNUM_OR_FLOATP (TOP) ? Qt : Qnil; #endif break; case Bfixnump: - TOP_LVALUE = INTP (TOP) ? Qt : Qnil; + TOP_LVALUE = FIXNUMP (TOP) ? Qt : Qnil; break; case Beq: ＠＠ -1211,7 +1211,7 ＠＠ TOP_LVALUE = Fsub1 (TOP); #else Lisp_Object arg = TOP; - TOP_LVALUE = INTP (arg) ? INT_MINUS1 (arg) : Fsub1 (arg); + TOP_LVALUE = FIXNUMP (arg) ? FIXNUM_MINUS1 (arg) : Fsub1 (arg); #endif break; } ＠＠ -1221,7 +1221,7 ＠＠ TOP_LVALUE = Fadd1 (TOP); #else Lisp_Object arg = TOP; - TOP_LVALUE = INTP (arg) ? INT_PLUS1 (arg) : Fadd1 (arg); + TOP_LVALUE = FIXNUMP (arg) ? FIXNUM_PLUS1 (arg) : Fadd1 (arg); #endif break; } ＠＠ -1281,8 +1281,8 ＠＠ #ifdef HAVE_BIGNUM TOP_LVALUE = bytecode_arithop (arg1, arg2, opcode); #else - TOP_LVALUE = INTP (arg1) && INTP (arg2) ? - INT_PLUS (arg1, arg2) : + TOP_LVALUE = FIXNUMP (arg1) && FIXNUMP (arg2) ? + FIXNUM_PLUS (arg1, arg2) : bytecode_arithop (arg1, arg2, opcode); #endif break; ＠＠ -1295,8 +1295,8 ＠＠ #ifdef HAVE_BIGNUM TOP_LVALUE = bytecode_arithop (arg1, arg2, opcode); #else - TOP_LVALUE = INTP (arg1) && INTP (arg2) ? - INT_MINUS (arg1, arg2) : + TOP_LVALUE = FIXNUMP (arg1) && FIXNUMP (arg2) ? + FIXNUM_MINUS (arg1, arg2) : bytecode_arithop (arg1, arg2, opcode); #endif break; ＠＠ -1313,7 +1313,7 ＠＠ } case Bpoint: - PUSH (make_int (BUF_PT (current_buffer))); + PUSH (make_fixnum (BUF_PT (current_buffer))); break; case Binsert: ＠＠ -1407,11 +1407,11 ＠＠ break; case Bpoint_max: - PUSH (make_int (BUF_ZV (current_buffer))); + PUSH (make_fixnum (BUF_ZV (current_buffer))); break; case Bpoint_min: - PUSH (make_int (BUF_BEGV (current_buffer))); + PUSH (make_fixnum (BUF_BEGV (current_buffer))); break; case Bskip_chars_forward: ＠＠ -1592,7 +1592,7 ＠＠ } case Bcurrent_column: - PUSH (make_int (current_column (current_buffer))); + PUSH (make_fixnum (current_column (current_buffer))); break; case Bchar_after: ＠＠ -1744,8 +1744,8 ＠＠ make_integer (Vmultiple_values_limit)); check_integer_range (first, Qzero, upper); - speccount = make_int (bind_multiple_value_limits (XINT (first), - XINT (upper))); + speccount = make_fixnum (bind_multiple_value_limits (XFIXNUM (first), + XFIXNUM (upper))); PUSH (upper); PUSH (speccount); break; ＠＠ -1753,7 +1753,7 ＠＠ case Bmultiple_value_call: { - n = XINT (POP); + n = XFIXNUM (POP); DISCARD_PRESERVING_MULTIPLE_VALUES_UNSAFE (n - 1); /* Discard multiple values for the first (function) argument: */ TOP_LVALUE = TOP; ＠＠ -1803,7 +1803,7 ＠＠ (opcode == 0251) || (opcode > Bassq && opcode < Bconstant)) invalid_byte_code ("invalid opcode in instruction stream", - make_int (opcode)); + make_fixnum (opcode)); } /* Check that IDX is a valid offset into the `constants' vector */ ＠＠ -2240,7 +2240,7 ＠＠ program = alloca_array (Opbyte, 1 + 2 * XSTRING_LENGTH (f->instructions)); optimize_byte_code (f->instructions, f->constants, program, &program_length, &varbind_count); - f->specpdl_depth = (unsigned short) (XINT (Flength (f->arglist)) + + f->specpdl_depth = (unsigned short) (XFIXNUM (Flength (f->arglist)) + varbind_count); f->instructions = make_opaque (program, program_length * sizeof (Opbyte)); ＠＠ -2657,7 +2657,7 ＠＠ set_compiled_function_documentation (Lisp_Compiled_Function *f, Lisp_Object new_doc) { - assert (INTP (new_doc) || STRINGP (new_doc)); + assert (FIXNUMP (new_doc) || STRINGP (new_doc)); if (f->flags.documentationp) { ＠＠ -2759,7 +2759,7 ＠＠ (function)) { CHECK_COMPILED_FUNCTION (function); - return make_int (compiled_function_stack_depth (XCOMPILED_FUNCTION (function))); + return make_fixnum (compiled_function_stack_depth (XCOMPILED_FUNCTION (function))); } DEFUN ("compiled-function-doc-string", Fcompiled_function_doc_string, 1, 1, 0, /* ＠＠ -2881,7 +2881,7 ＠＠ CHECK_STRING (instructions); CHECK_VECTOR (constants); - check_integer_range (stack_depth, Qzero, make_int (USHRT_MAX)); + check_integer_range (stack_depth, Qzero, make_fixnum (USHRT_MAX)); /* Optimize the `instructions' string, just like when executing a regular compiled function, but don't save it for later since this is ＠＠ -2894,7 +2894,7 ＠＠ #ifdef ERROR_CHECK_BYTE_CODE program_length, #endif - XINT (stack_depth), + XFIXNUM (stack_depth), XVECTOR_DATA (constants)); } diff -r a0e81357194e -r 56144c8593a8 src/callint.c --- a/src/callint.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/callint.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -966,7 +966,7 ＠＠ temporarily, convert it to an integer now. */ for (argnum = 0; argnum < argcount; argnum++) if (!NILP (varies[argnum])) - args[argnum] = make_int (marker_position (args[argnum])); + args[argnum] = make_fixnum (marker_position (args[argnum])); single_console_state (); specbind (Qcommand_debug_status, Qnil); ＠＠ -986,15 +986,15 ＠＠ (raw)) { if (NILP (raw)) - return make_int (1); + return make_fixnum (1); if (EQ (raw, Qminus)) - return make_int (-1); - if (INTP (raw)) + return make_fixnum (-1); + if (FIXNUMP (raw)) return raw; - if (CONSP (raw) && INTP (XCAR (raw))) + if (CONSP (raw) && FIXNUMP (XCAR (raw))) return XCAR (raw); - return make_int (1); + return make_fixnum (1); } void diff -r a0e81357194e -r 56144c8593a8 src/casefiddle.c --- a/src/casefiddle.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/casefiddle.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -309,13 +309,13 ＠＠ Charbpos farend; struct buffer *buf = decode_buffer (buffer, 1); - CHECK_INT (arg); + CHECK_FIXNUM (arg); - farend = scan_words (buf, BUF_PT (buf), XINT (arg)); + farend = scan_words (buf, BUF_PT (buf), XFIXNUM (arg)); if (!farend) - farend = XINT (arg) > 0 ? BUF_ZV (buf) : BUF_BEGV (buf); + farend = XFIXNUM (arg) > 0 ? BUF_ZV (buf) : BUF_BEGV (buf); - casify_region_internal (flag, make_int (BUF_PT (buf)), make_int (farend), buf); + casify_region_internal (flag, make_fixnum (BUF_PT (buf)), make_fixnum (farend), buf); BUF_SET_PT (buf, max (BUF_PT (buf), farend)); return Qnil; } diff -r a0e81357194e -r 56144c8593a8 src/chartab.c --- a/src/chartab.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/chartab.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -159,10 +159,10 ＠＠ } case CHARTAB_RANGE_ROW: { - if (EQ (old, make_int (range->row)) == test_not_unboundp) + if (EQ (old, make_fixnum (range->row)) == test_not_unboundp) { - CHECK_INT (new_); - changed.row = XINT (new_); + CHECK_FIXNUM (new_); + changed.row = XFIXNUM (new_); put_char_table (table, range, Qunbound); put_char_table (table, &changed, value); ＠＠ -364,8 +364,8 ＠＠ range); outrange->type = CHARTAB_RANGE_ROW; outrange->charset = Fget_charset (elts[0]); - CHECK_INT (elts[1]); - outrange->row = XINT (elts[1]); + CHECK_FIXNUM (elts[1]); + outrange->row = XFIXNUM (elts[1]); switch (XCHARSET_TYPE (outrange->charset)) { case CHARSET_TYPE_94: ＠＠ -373,12 +373,12 ＠＠ sferror ("Charset in row vector must be multi-byte", outrange->charset); case CHARSET_TYPE_94X94: - check_integer_range (make_int (outrange->row), make_int (33), - make_int (126)); + check_integer_range (make_fixnum (outrange->row), make_fixnum (33), + make_fixnum (126)); break; case CHARSET_TYPE_96X96: - check_integer_range (make_int (outrange->row), make_int (32), - make_int (127)); + check_integer_range (make_fixnum (outrange->row), make_fixnum (32), + make_fixnum (127)); break; default: ABORT (); ＠＠ -409,7 +409,7 ＠＠ case CHARTAB_RANGE_ROW: return vector2 (XCHARSET_NAME (Fget_charset (range->charset)), - make_int (range->row)); + make_fixnum (range->row)); #endif case CHARTAB_RANGE_CHAR: return make_char (range->ch); ＠＠ -731,7 +731,7 ＠＠ /* Qgeneric not Qsyntax because a syntax table has a mirror table and we don't want infinite recursion */ ct->mirror_table = Fmake_char_table (Qgeneric); - set_char_table_default (ct->mirror_table, make_int (Sword)); + set_char_table_default (ct->mirror_table, make_fixnum (Sword)); XCHAR_TABLE (ct->mirror_table)->mirror_table_p = 1; XCHAR_TABLE (ct->mirror_table)->mirror_table = obj; } ＠＠ -832,7 +832,7 ＠＠ if (!EQ (ct->mirror_table, Qnil)) { ctnew->mirror_table = Fmake_char_table (Qgeneric); - set_char_table_default (ctnew->mirror_table, make_int (Sword)); + set_char_table_default (ctnew->mirror_table, make_fixnum (Sword)); XCHAR_TABLE (ctnew->mirror_table)->mirror_table = obj; XCHAR_TABLE (ctnew->mirror_table)->mirror_table_p = 1; XCHAR_TABLE (ctnew->mirror_table)->dirty = 1; ＠＠ -1076,16 +1076,16 ＠＠ { case CHAR_TABLE_TYPE_SYNTAX: if (!ERRB_EQ (errb, ERROR_ME)) - return INTP (value) || (CONSP (value) && INTP (XCAR (value)) + return FIXNUMP (value) || (CONSP (value) && FIXNUMP (XCAR (value)) && CHAR_OR_CHAR_INTP (XCDR (value))); if (CONSP (value)) { Lisp_Object cdr = XCDR (value); - CHECK_INT (XCAR (value)); + CHECK_FIXNUM (XCAR (value)); CHECK_CHAR_COERCE_INT (cdr); } else - CHECK_INT (value); + CHECK_FIXNUM (value); break; #ifdef MULE ＠＠ -1853,11 +1853,11 ＠＠ int des; struct buffer *buf = decode_buffer (buffer, 0); - CHECK_INT (position); + CHECK_FIXNUM (position); CHECK_CATEGORY_DESIGNATOR (designator); des = XCHAR (designator); ctbl = check_category_table (category_table, buf->category_table); - ch = BUF_FETCH_CHAR (buf, XINT (position)); + ch = BUF_FETCH_CHAR (buf, XFIXNUM (position)); return check_category_char (ch, ctbl, des, 0) ? Qt : Qnil; } ＠＠ -1922,7 +1922,7 ＠＠ category_table = check_category_table (category_table, Qnil); buf->category_table = category_table; /* Indicate that this buffer now has a specified category table. */ - buf->local_var_flags |= XINT (buffer_local_flags.category_table); + buf->local_var_flags |= XFIXNUM (buffer_local_flags.category_table); return category_table; } diff -r a0e81357194e -r 56144c8593a8 src/cmdloop.c --- a/src/cmdloop.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/cmdloop.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -164,7 +164,7 ＠＠ Fmswindows_message_box (build_msg_string ("Initialization error"), Qnil, Qnil); #endif - Fkill_emacs (make_int (-1)); + Fkill_emacs (make_fixnum (-1)); RETURN_NOT_REACHED (Qnil); } ＠＠ -249,7 +249,7 ＠＠ { message ("\ntemacs can only be run in -batch mode."); noninteractive = 1; /* prevent things under kill-emacs from blowing up */ - Fkill_emacs (make_int (-1)); + Fkill_emacs (make_fixnum (-1)); } #else else if (purify_flag) ＠＠ -321,7 +321,7 ＠＠ if (!noninteractive && (!CONSOLEP (Vselected_console) || CONSOLE_STREAM_P (XCONSOLE (Vselected_console)))) - Fkill_emacs (make_int (-1)); + Fkill_emacs (make_fixnum (-1)); /* End of -batch run causes exit here. */ if (noninteractive) ＠＠ -481,7 +481,7 ＠＠ message ("Error in command-loop!!"); Fset (intern ("last-error"), datum); /* #### Better/different name? */ - Fsit_for (make_int (2), Qnil); + Fsit_for (make_fixnum (2), Qnil); cold_load_command_error (datum, Qnil); return (Qt); } ＠＠ -494,7 +494,7 ＠＠ { if (!NILP (condition_case_1 (Qt, load1, load_me, initial_error_handler, Qnil))) - Fkill_emacs (make_int (-1)); + Fkill_emacs (make_fixnum (-1)); } for (;;) ＠＠ -568,7 +568,7 ＠＠ compatibility with Emacs 18. It's not even clear what the "right thing" is. */ if (!((STRINGP (Vexecuting_macro) || VECTORP (Vexecuting_macro)) - && XINT (Flength (Vexecuting_macro)) == 1)) + && XFIXNUM (Flength (Vexecuting_macro)) == 1)) Vlast_command = Qt; #ifndef LISP_COMMAND_LOOP ＠＠ -613,7 +613,7 ＠＠ if (!NILP (Vminibuffer_echo_wait_function)) call0 (Vminibuffer_echo_wait_function); else - Fsit_for (make_int (2), Qnil); + Fsit_for (make_fixnum (2), Qnil); clear_echo_area (selected_frame (), Qnil, 0); Vquit_flag = Qnil; /* see begin_dont_check_for_quit() */ unbind_to (count); diff -r a0e81357194e -r 56144c8593a8 src/cmds.c --- a/src/cmds.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/cmds.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -65,11 +65,11 ＠＠ n = 1; else { - CHECK_INT (count); - n = XINT (count); + CHECK_FIXNUM (count); + n = XFIXNUM (count); } - /* This used to just set point to point + XINT (count), and then check + /* This used to just set point to point + XFIXNUM (count), and then check to see if it was within boundaries. But now that SET_PT can potentially do a lot of stuff (calling entering and exiting hooks, etcetera), that's not a good approach. So we validate the ＠＠ -109,11 +109,11 ＠＠ (count, buffer)) { if (NILP (count)) - count = make_int (-1); + count = make_fixnum (-1); else { - CHECK_INT (count); - count = make_int (- XINT (count)); + CHECK_FIXNUM (count); + count = make_fixnum (- XFIXNUM (count)); } return Fforward_char (count, buffer); } ＠＠ -145,8 +145,8 ＠＠ n = 1; else { - CHECK_INT (count); - n = XINT (count); + CHECK_FIXNUM (count); + n = XFIXNUM (count); } negp = n <= 0; ＠＠ -158,7 +158,7 ＠＠ && BUF_FETCH_CHAR (buf, pos - 1) != '\n'))) shortage--; BUF_SET_PT (buf, pos); - return make_int (negp ? - shortage : shortage); + return make_fixnum (negp ? - shortage : shortage); } DEFUN ("point-at-bol", Fpoint_at_bol, 0, 2, 0, /* ＠＠ -174,11 +174,11 ＠＠ buffer = wrap_buffer (b); if (NILP (count)) - count = make_int (0); + count = make_fixnum (0); else { - CHECK_INT (count); - count = make_int (XINT (count) - 1); + CHECK_FIXNUM (count); + count = make_fixnum (XFIXNUM (count) - 1); } orig = BUF_PT (b); ＠＠ -186,7 +186,7 ＠＠ end = BUF_PT (b); BUF_SET_PT (b, orig); - return make_int (end); + return make_fixnum (end); } DEFUN ("beginning-of-line", Fbeginning_of_line, 0, 2, "_p", /* ＠＠ -204,7 +204,7 ＠＠ { struct buffer *b = decode_buffer (buffer, 1); - BUF_SET_PT (b, XINT (Fpoint_at_bol (count, buffer))); + BUF_SET_PT (b, XFIXNUM (Fpoint_at_bol (count, buffer))); return Qnil; } ＠＠ -223,11 +223,11 ＠＠ n = 1; else { - CHECK_INT (count); - n = XINT (count); + CHECK_FIXNUM (count); + n = XFIXNUM (count); } - return make_int (find_before_next_newline (buf, BUF_PT (buf), 0, + return make_fixnum (find_before_next_newline (buf, BUF_PT (buf), 0, n - (n <= 0))); } ＠＠ -246,7 +246,7 ＠＠ { struct buffer *b = decode_buffer (buffer, 1); - BUF_SET_PT (b, XINT (Fpoint_at_eol (count, buffer))); + BUF_SET_PT (b, XFIXNUM (Fpoint_at_eol (count, buffer))); return Qnil; } ＠＠ -267,8 +267,8 ＠＠ n = 1; else { - CHECK_INT (count); - n = XINT (count); + CHECK_FIXNUM (count); + n = XFIXNUM (count); } pos = BUF_PT (buf) + n; ＠＠ -311,11 +311,11 ＠＠ n = 1; else { - CHECK_INT (count); - n = XINT (count); + CHECK_FIXNUM (count); + n = XFIXNUM (count); } - return Fdelete_char (make_int (- n), killp); + return Fdelete_char (make_fixnum (- n), killp); } static void internal_self_insert (Ichar ch, int noautofill); ＠＠ -334,8 +334,8 ＠＠ /* Can't insert more than most-positive-fixnum characters, the buffer won't hold that many. */ - check_integer_range (count, Qzero, make_int (EMACS_INT_MAX)); - n = XINT (count); + check_integer_range (count, Qzero, make_fixnum (MOST_POSITIVE_FIXNUM)); + n = XFIXNUM (count); if (CHAR_OR_CHAR_INTP (Vlast_command_char)) c = Vlast_command_char; ＠＠ -396,7 +396,7 ＠＠ || (c1 != '\n' && BUF_FETCH_CHAR (buf, BUF_PT (buf)) != '\n')) && (EQ (overwrite, Qoverwrite_mode_binary) || BUF_FETCH_CHAR (buf, BUF_PT (buf)) != '\t' - || ((tab_width = XINT (buf->tab_width), tab_width <= 0) + || ((tab_width = XFIXNUM (buf->tab_width), tab_width <= 0) || tab_width > 20 || !((current_column (buf) + 1) % tab_width)))) { ＠＠ -467,8 +467,8 ＠＠ if (!NILP (Vself_insert_face) && EQ (Vlast_command, Vself_insert_face_command)) { - Lisp_Object before = make_int (BUF_PT (buf) - 1); - Lisp_Object after = make_int (BUF_PT (buf)); + Lisp_Object before = make_fixnum (BUF_PT (buf) - 1); + Lisp_Object after = make_fixnum (BUF_PT (buf)); Fput_text_property (before, after, Qface, Vself_insert_face, Qnil); Fput_text_property (before, after, Qstart_open, Qt, Qnil); Fput_text_property (before, after, Qend_open, Qnil, Qnil); diff -r a0e81357194e -r 56144c8593a8 src/console-gtk.c --- a/src/console-gtk.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/console-gtk.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -143,7 +143,7 ＠＠ char_to_associate #ifdef __GDK_KEYS_H__ = Funicode_to_char - (make_int(gdk_keyval_to_unicode + (make_fixnum(gdk_keyval_to_unicode (gdk_keyval_from_name(symbol_name))), Qnil); #else /* GTK 1.whatever doesn't. Use the X11 map. */ = gtk_keysym_to_character(gdk_keyval_from_name(symbol_name)); diff -r a0e81357194e -r 56144c8593a8 src/console-msw.c --- a/src/console-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/console-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -640,7 +640,7 ＠＠ #undef FROB invalid_argument ("Unknown return value from MessageBox()", - make_int (retval)); + make_fixnum (retval)); } return Qnil; diff -r a0e81357194e -r 56144c8593a8 src/console-tty.c --- a/src/console-tty.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/console-tty.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -114,7 +114,7 ＠＠ /* Determine the controlling process */ if (!NILP (controlling_process)) - CHECK_INT (controlling_process); + CHECK_FIXNUM (controlling_process); /* Open the specified console */ diff -r a0e81357194e -r 56144c8593a8 src/console-x.c --- a/src/console-x.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/console-x.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -238,7 +238,7 ＠＠ split_up_display_spec (connection, &hostname_length, &display_length, &screen_length); - hostname = Fsubseq (connection, Qzero, make_int (hostname_length)); + hostname = Fsubseq (connection, Qzero, make_fixnum (hostname_length)); hostname = canonicalize_host_name (hostname); connection = concat2 (hostname, make_string (XSTRING_DATA (connection) diff -r a0e81357194e -r 56144c8593a8 src/console.c --- a/src/console.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/console.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -704,7 +704,7 ＠＠ { int down_we_go = 0; - if ((XINT (Flength (Vconsole_list)) == 1) + if ((XFIXNUM (Flength (Vconsole_list)) == 1) /* if we just created the console, it might not be listed, or something ... */ && !NILP (memq_no_quit (console, Vconsole_list))) ＠＠ -724,7 +724,7 ＠＠ stderr_out (" Autosaving and exiting...\n"); Vwindow_system = Qnil; /* let it lie! */ preparing_for_armageddon = 1; - Fkill_emacs (make_int (70)); + Fkill_emacs (make_fixnum (70)); } else { ＠＠ -1054,7 +1054,7 ＠＠ } reset_one_console (con); event_stream_unselect_console (con); - sys_suspend_process (XINT (Fconsole_tty_controlling_process (console))); + sys_suspend_process (XFIXNUM (Fconsole_tty_controlling_process (console))); } #endif /* HAVE_TTY */ ＠＠ -1436,11 +1436,11 ＠＠ * #### We don't currently ever reset console variables, so there * is no current distinction between 0 and -1, and between -2 and -3. */ - Lisp_Object always_local_resettable = make_int (-1); + Lisp_Object always_local_resettable = make_fixnum (-1); #if 0 /* not used */ - Lisp_Object always_local_no_default = make_int (0); - Lisp_Object resettable = make_int (-3); + Lisp_Object always_local_no_default = make_fixnum (0); + Lisp_Object resettable = make_fixnum (-3); #endif /* Assign the local-flags to the slots that have default values. ＠＠ -1451,7 +1451,7 ＠＠ set_lheader_implementation ((struct lrecord_header *) &console_local_flags, &lrecord_console); - nuke_all_console_slots (&console_local_flags, make_int (-2)); + nuke_all_console_slots (&console_local_flags, make_fixnum (-2)); console_local_flags.defining_kbd_macro = always_local_resettable; console_local_flags.last_kbd_macro = always_local_resettable; console_local_flags.prefix_arg = always_local_resettable; ＠＠ -1462,10 +1462,10 ＠＠ console_local_flags.tty_erase_char = always_local_resettable; #endif - console_local_flags.function_key_map = make_int (1); + console_local_flags.function_key_map = make_fixnum (1); /* #### Warning, 0x4000000 (that's six zeroes) is the largest number - currently allowable due to the XINT() handling of this value. + currently allowable due to the XFIXNUM() handling of this value. With some rearrangement you can get 4 more bits. */ } } ＠＠ -1607,8 +1607,8 ＠＠ slot of console_local_flags and vice-versa. Must be done after all DEFVAR_CONSOLE_LOCAL() calls. */ #define MARKED_SLOT(slot) \ - assert ((XINT (console_local_flags.slot) != -2 && \ - XINT (console_local_flags.slot) != -3) \ + assert ((XFIXNUM (console_local_flags.slot) != -2 && \ + XFIXNUM (console_local_flags.slot) != -3) \ == !(NILP (XCONSOLE (Vconsole_local_symbols)->slot))); #include "conslots.h" } diff -r a0e81357194e -r 56144c8593a8 src/data.c --- a/src/data.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/data.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -78,7 +78,7 ＠＠ eq_with_ebola_notice (Lisp_Object obj1, Lisp_Object obj2) { if (debug_issue_ebola_notices - && ((CHARP (obj1) && INTP (obj2)) || (CHARP (obj2) && INTP (obj1)))) + && ((CHARP (obj1) && FIXNUMP (obj2)) || (CHARP (obj2) && FIXNUMP (obj1)))) { /* #### It would be really nice if this were a proper warning instead of brain-dead print to Qexternal_debugging_output. */ ＠＠ -321,7 +321,7 ＠＠ (subr)) { CHECK_SUBR (subr); - return make_int (XSUBR (subr)->min_args); + return make_fixnum (XSUBR (subr)->min_args); } DEFUN ("subr-max-args", Fsubr_max_args, 1, 1, 0, /* ＠＠ -336,7 +336,7 ＠＠ if (nargs == MANY || nargs == UNEVALLED) return Qnil; else - return make_int (nargs); + return make_fixnum (nargs); } DEFUN ("subr-interactive", Fsubr_interactive, 1, 1, 0, /* ＠＠ -395,7 +395,7 ＠＠ (character)) { CHECK_CHAR (character); - return make_int (XCHAR (character)); + return make_fixnum (XCHAR (character)); } DEFUN ("int-to-char", Fint_to_char, 1, 1, 0, /* ＠＠ -408,7 +408,7 ＠＠ { CHECK_INTEGER (integer); if (CHAR_INTP (integer)) - return make_char (XINT (integer)); + return make_char (XFIXNUM (integer)); else return Qnil; } ＠＠ -452,7 +452,7 ＠＠ */ (object)) { - return INTP (object) ? Qt : Qnil; + return FIXNUMP (object) ? Qt : Qnil; } DEFUN ("integerp", Fintegerp, 1, 1, 0, /* Return t if OBJECT is an integer, nil otherwise. ＠＠ -714,7 +714,7 ＠＠ retry: - if (INTP (index_)) idx = XINT (index_); + if (FIXNUMP (index_)) idx = XFIXNUM (index_); else if (CHARP (index_)) idx = XCHAR (index_); /* yuck! */ #ifdef HAVE_BIGNUM else if (BIGNUMP (index_)) ＠＠ -746,7 +746,7 ＠＠ { if (idx >= (EMACS_INT) bit_vector_length (XBIT_VECTOR (array))) goto range_error; - return make_int (bit_vector_bit (XBIT_VECTOR (array), idx)); + return make_fixnum (bit_vector_bit (XBIT_VECTOR (array), idx)); } else if (STRINGP (array)) { ＠＠ -775,7 +775,7 ＠＠ retry: - if (INTP (index_)) idx = XINT (index_); + if (FIXNUMP (index_)) idx = XFIXNUM (index_); else if (CHARP (index_)) idx = XCHAR (index_); /* yuck! */ #ifdef HAVE_BIGNUM else if (BIGNUMP (index_)) ＠＠ -851,7 +851,7 ＠＠ { retry: p->int_p = 1; - if (INTP (obj)) p->c.ival = XINT (obj); + if (FIXNUMP (obj)) p->c.ival = XFIXNUM (obj); else if (CHARP (obj)) p->c.ival = XCHAR (obj); else if (MARKERP (obj)) p->c.ival = marker_position (obj); else if (FLOATP (obj)) p->c.dval = XFLOAT_DATA (obj), p->int_p = 0; ＠＠ -866,7 +866,7 ＠＠ number_char_or_marker_to_double (Lisp_Object obj) { retry: - if (INTP (obj)) return (double) XINT (obj); + if (FIXNUMP (obj)) return (double) XFIXNUM (obj); else if (CHARP (obj)) return (double) XCHAR (obj); else if (MARKERP (obj)) return (double) marker_position (obj); else if (FLOATP (obj)) return XFLOAT_DATA (obj); ＠＠ -882,7 +882,7 ＠＠ fixnum_char_or_marker_to_int (Lisp_Object obj) { retry: - if (INTP (obj)) return XINT (obj); + if (FIXNUMP (obj)) return XFIXNUM (obj); else if (CHARP (obj)) return XCHAR (obj); else if (MARKERP (obj)) return marker_position (obj); else ＠＠ -939,7 +939,7 ＠＠ switch (promote_args (&obj1, &obj2)) \ { \ case FIXNUM_T: \ - if (!(XREALINT (obj1) c_op XREALINT (obj2))) \ + if (!(XREALFIXNUM (obj1) c_op XREALFIXNUM (obj2))) \ return Qnil; \ break; \ BIGNUM_CASE (op) \ ＠＠ -1069,7 +1069,7 ＠＠ switch (promote_args (&obj1, &obj2)) { case FIXNUM_T: - if (XREALINT (obj1) == XREALINT (obj2)) + if (XREALFIXNUM (obj1) == XREALFIXNUM (obj2)) return Qnil; break; #ifdef HAVE_BIGNUM ＠＠ -1130,7 +1130,7 ＠＠ (number)) { retry: - if (INTP (number)) + if (FIXNUMP (number)) return EQ (number, Qzero) ? Qt : Qnil; #ifdef HAVE_BIGNUM else if (BIGNUMP (number)) ＠＠ -1163,21 +1163,21 ＠＠ Lisp_Object word_to_lisp (unsigned int item) { - return Fcons (make_int (item >> 16), make_int (item & 0xffff)); + return Fcons (make_fixnum (item >> 16), make_fixnum (item & 0xffff)); } unsigned int lisp_to_word (Lisp_Object item) { - if (INTP (item)) - return XINT (item); + if (FIXNUMP (item)) + return XFIXNUM (item); else { Lisp_Object top = Fcar (item); Lisp_Object bot = Fcdr (item); - CHECK_INT (top); - CHECK_INT (bot); - return (XINT (top) << 16) | (XINT (bot) & 0xffff); + CHECK_FIXNUM (top); + CHECK_FIXNUM (bot); + return (XFIXNUM (top) << 16) | (XFIXNUM (bot) & 0xffff); } } ＠＠ -1230,7 +1230,7 ＠＠ { Ascbyte buffer[DECIMAL_PRINT_SIZE (long)]; - long_to_string (buffer, XINT (number)); + long_to_string (buffer, XFIXNUM (number)); return build_ascstring (buffer); } } ＠＠ -1270,8 +1270,8 ＠＠ b = 10; else { - check_integer_range (base, make_int (2), make_int (16)); - b = XINT (base); + check_integer_range (base, make_fixnum (2), make_fixnum (16)); + b = XFIXNUM (base); } p = XSTRING_DATA (string); ＠＠ -1379,7 +1379,7 ＠＠ save = *end; *end = '\0'; if (*p == '\0') - retval = make_int (0); + retval = make_fixnum (0); else { bignum_set_string (scratch_bignum, (const char *) p, b); ＠＠ -1393,11 +1393,11 ＠＠ { /* Use the system-provided functions for base 10. */ #if SIZEOF_EMACS_INT == SIZEOF_INT - return make_int (atoi ((char*) p)); + return make_fixnum (atoi ((char*) p)); #elif SIZEOF_EMACS_INT == SIZEOF_LONG - return make_int (atol ((char*) p)); + return make_fixnum (atol ((char*) p)); #elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG - return make_int (atoll ((char*) p)); + return make_fixnum (atoll ((char*) p)); #endif } else ＠＠ -1419,7 +1419,7 ＠＠ break; v = v * b + digit; } - return make_int (negative * v); + return make_fixnum (negative * v); } #endif /* HAVE_BIGNUM */ } ＠＠ -1435,7 +1435,7 ＠＠ { #ifdef WITH_NUMBER_TYPES REGISTER int i; - Lisp_Object accum = make_int (0), addend; + Lisp_Object accum = make_fixnum (0), addend; for (i = 0; i < nargs; i++) { ＠＠ -1443,7 +1443,7 ＠＠ switch (promote_args (&accum, &addend)) { case FIXNUM_T: - accum = make_integer (XREALINT (accum) + XREALINT (addend)); + accum = make_integer (XREALFIXNUM (accum) + XREALFIXNUM (addend)); break; #ifdef HAVE_BIGNUM case BIGNUM_T: ＠＠ -1494,7 +1494,7 ＠＠ } } - return make_int (iaccum); + return make_fixnum (iaccum); #endif /* WITH_NUMBER_TYPES */ } ＠＠ -1514,16 +1514,16 ＠＠ if (nargs == 1) { if (CHARP (accum)) - accum = make_int (XCHAR (accum)); + accum = make_fixnum (XCHAR (accum)); else if (MARKERP (accum)) - accum = make_int (marker_position (accum)); + accum = make_fixnum (marker_position (accum)); /* Invert the sign of accum */ CHECK_NUMBER (accum); switch (get_number_type (accum)) { case FIXNUM_T: - return make_integer (-XREALINT (accum)); + return make_integer (-XREALFIXNUM (accum)); #ifdef HAVE_BIGNUM case BIGNUM_T: bignum_neg (scratch_bignum, XBIGNUM_DATA (accum)); ＠＠ -1553,7 +1553,7 ＠＠ switch (promote_args (&accum, &subtrahend)) { case FIXNUM_T: - accum = make_integer (XREALINT (accum) - XREALINT (subtrahend)); + accum = make_integer (XREALFIXNUM (accum) - XREALFIXNUM (subtrahend)); break; #ifdef HAVE_BIGNUM case BIGNUM_T: ＠＠ -1614,7 +1614,7 ＠＠ } } - return make_int (iaccum); + return make_fixnum (iaccum); do_float: for (; args < args_end; args++) ＠＠ -1690,7 +1690,7 ＠＠ } } - return make_int (iaccum); + return make_fixnum (iaccum); #endif /* WITH_NUMBER_TYPES */ } ＠＠ -1711,7 +1711,7 ＠＠ if (nargs == 1) { i = 0; - accum = make_int (1); + accum = make_fixnum (1); } else { ＠＠ -1724,9 +1724,9 ＠＠ switch (promote_args (&accum, &divisor)) { case FIXNUM_T: - if (XREALINT (divisor) == 0) goto divide_by_zero; - bignum_set_long (scratch_bignum, XREALINT (accum)); - bignum_set_long (scratch_bignum2, XREALINT (divisor)); + if (XREALFIXNUM (divisor) == 0) goto divide_by_zero; + bignum_set_long (scratch_bignum, XREALFIXNUM (accum)); + bignum_set_long (scratch_bignum2, XREALFIXNUM (divisor)); accum = make_ratio_bg (scratch_bignum, scratch_bignum2); break; case BIGNUM_T: ＠＠ -1781,7 +1781,7 ＠＠ if (nargs == 1) { i = 0; - accum = make_int (1); + accum = make_fixnum (1); } else { ＠＠ -1794,8 +1794,8 ＠＠ switch (promote_args (&accum, &divisor)) { case FIXNUM_T: - if (XREALINT (divisor) == 0) goto divide_by_zero; - accum = make_integer (XREALINT (accum) / XREALINT (divisor)); + if (XREALFIXNUM (divisor) == 0) goto divide_by_zero; + accum = make_integer (XREALFIXNUM (accum) / XREALFIXNUM (divisor)); break; #ifdef HAVE_BIGNUM case BIGNUM_T: ＠＠ -1868,7 +1868,7 ＠＠ } } - return make_int (iaccum); + return make_fixnum (iaccum); divide_floats: for (; args < args_end; args++) ＠＠ -1902,9 +1902,9 ＠＠ while (!(CHARP (args[0]) || MARKERP (args[0]) || REALP (args[0]))) args[0] = wrong_type_argument (Qnumber_char_or_marker_p, args[0]); if (CHARP (args[0])) - args[0] = make_int (XCHAR (args[0])); + args[0] = make_fixnum (XCHAR (args[0])); else if (MARKERP (args[0])) - args[0] = make_int (marker_position (args[0])); + args[0] = make_fixnum (marker_position (args[0])); for (i = 1; i < nargs; i++) { comp1 = args[maxindex]; ＠＠ -1912,7 +1912,7 ＠＠ switch (promote_args (&comp1, &comp2)) { case FIXNUM_T: - if (XREALINT (comp1) < XREALINT (comp2)) + if (XREALFIXNUM (comp1) < XREALFIXNUM (comp2)) maxindex = i; break; #ifdef HAVE_BIGNUM ＠＠ -1970,7 +1970,7 ＠＠ } } - return make_int (imax); + return make_fixnum (imax); max_floats: while (args < args_end) ＠＠ -1999,9 +1999,9 ＠＠ while (!(CHARP (args[0]) || MARKERP (args[0]) || REALP (args[0]))) args[0] = wrong_type_argument (Qnumber_char_or_marker_p, args[0]); if (CHARP (args[0])) - args[0] = make_int (XCHAR (args[0])); + args[0] = make_fixnum (XCHAR (args[0])); else if (MARKERP (args[0])) - args[0] = make_int (marker_position (args[0])); + args[0] = make_fixnum (marker_position (args[0])); for (i = 1; i < nargs; i++) { comp1 = args[minindex]; ＠＠ -2009,7 +2009,7 ＠＠ switch (promote_args (&comp1, &comp2)) { case FIXNUM_T: - if (XREALINT (comp1) > XREALINT (comp2)) + if (XREALFIXNUM (comp1) > XREALFIXNUM (comp2)) minindex = i; break; #ifdef HAVE_BIGNUM ＠＠ -2067,7 +2067,7 ＠＠ } } - return make_int (imin); + return make_fixnum (imin); min_floats: while (args < args_end) ＠＠ -2092,16 +2092,16 ＠＠ Lisp_Object result, other; if (nargs == 0) - return make_int (~0); + return make_fixnum (~0); while (!(CHARP (args[0]) || MARKERP (args[0]) || INTEGERP (args[0]))) args[0] = wrong_type_argument (Qnumber_char_or_marker_p, args[0]); result = args[0]; if (CHARP (result)) - result = make_int (XCHAR (result)); + result = make_fixnum (XCHAR (result)); else if (MARKERP (result)) - result = make_int (marker_position (result)); + result = make_fixnum (marker_position (result)); for (i = 1; i < nargs; i++) { while (!(CHARP (args[i]) || MARKERP (args[i]) || INTEGERP (args[i]))) ＠＠ -2110,7 +2110,7 ＠＠ switch (promote_args (&result, &other)) { case FIXNUM_T: - result = make_int (XREALINT (result) & XREALINT (other)); + result = make_fixnum (XREALFIXNUM (result) & XREALFIXNUM (other)); break; case BIGNUM_T: bignum_and (scratch_bignum, XBIGNUM_DATA (result), ＠＠ -2127,7 +2127,7 ＠＠ while (args < args_end) bits &= fixnum_char_or_marker_to_int (*args++); - return make_int (bits); + return make_fixnum (bits); #endif /* HAVE_BIGNUM */ } ＠＠ -2144,16 +2144,16 ＠＠ Lisp_Object result, other; if (nargs == 0) - return make_int (0); + return make_fixnum (0); while (!(CHARP (args[0]) || MARKERP (args[0]) || INTEGERP (args[0]))) args[0] = wrong_type_argument (Qnumber_char_or_marker_p, args[0]); result = args[0]; if (CHARP (result)) - result = make_int (XCHAR (result)); + result = make_fixnum (XCHAR (result)); else if (MARKERP (result)) - result = make_int (marker_position (result)); + result = make_fixnum (marker_position (result)); for (i = 1; i < nargs; i++) { while (!(CHARP (args[i]) || MARKERP (args[i]) || INTEGERP (args[i]))) ＠＠ -2162,7 +2162,7 ＠＠ switch (promote_args (&result, &other)) { case FIXNUM_T: - result = make_int (XREALINT (result) | XREALINT (other)); + result = make_fixnum (XREALFIXNUM (result) | XREALFIXNUM (other)); break; case BIGNUM_T: bignum_ior (scratch_bignum, XBIGNUM_DATA (result), ＠＠ -2179,7 +2179,7 ＠＠ while (args < args_end) bits |= fixnum_char_or_marker_to_int (*args++); - return make_int (bits); + return make_fixnum (bits); #endif /* HAVE_BIGNUM */ } ＠＠ -2196,16 +2196,16 ＠＠ Lisp_Object result, other; if (nargs == 0) - return make_int (0); + return make_fixnum (0); while (!(CHARP (args[0]) || MARKERP (args[0]) || INTEGERP (args[0]))) args[0] = wrong_type_argument (Qinteger_char_or_marker_p, args[0]); result = args[0]; if (CHARP (result)) - result = make_int (XCHAR (result)); + result = make_fixnum (XCHAR (result)); else if (MARKERP (result)) - result = make_int (marker_position (result)); + result = make_fixnum (marker_position (result)); for (i = 1; i < nargs; i++) { while (!(CHARP (args[i]) || MARKERP (args[i]) || INTEGERP (args[i]))) ＠＠ -2213,7 +2213,7 ＠＠ other = args[i]; if (promote_args (&result, &other) == FIXNUM_T) { - result = make_int (XREALINT (result) ^ XREALINT (other)); + result = make_fixnum (XREALFIXNUM (result) ^ XREALFIXNUM (other)); } else { ＠＠ -2230,7 +2230,7 ＠＠ while (args < args_end) bits ^= fixnum_char_or_marker_to_int (*args++); - return make_int (bits); + return make_fixnum (bits); #endif /* !HAVE_BIGNUM */ } ＠＠ -2251,7 +2251,7 ＠＠ } #endif /* HAVE_BIGNUM */ - return make_int (~ fixnum_char_or_marker_to_int (number)); + return make_fixnum (~ fixnum_char_or_marker_to_int (number)); } DEFUN ("%", Frem, 2, 2, 0, /* ＠＠ -2268,9 +2268,9 ＠＠ if (promote_args (&number1, &number2) == FIXNUM_T) { - if (XREALINT (number2) == 0) + if (XREALFIXNUM (number2) == 0) Fsignal (Qarith_error, Qnil); - return make_int (XREALINT (number1) % XREALINT (number2)); + return make_fixnum (XREALFIXNUM (number1) % XREALFIXNUM (number2)); } else { ＠＠ -2287,7 +2287,7 ＠＠ if (ival2 == 0) Fsignal (Qarith_error, Qnil); - return make_int (ival1 % ival2); + return make_fixnum (ival1 % ival2); #endif /* HAVE_BIGNUM */ } ＠＠ -2324,12 +2324,12 ＠＠ case FIXNUM_T: { EMACS_INT ival; - if (XREALINT (y) == 0) goto divide_by_zero; - ival = XREALINT (x) % XREALINT (y); + if (XREALFIXNUM (y) == 0) goto divide_by_zero; + ival = XREALFIXNUM (x) % XREALFIXNUM (y); /* If the "remainder" comes out with the wrong sign, fix it. */ - if (XREALINT (y) < 0 ? ival > 0 : ival < 0) - ival += XREALINT (y); - return make_int (ival); + if (XREALFIXNUM (y) < 0 ? ival > 0 : ival < 0) + ival += XREALFIXNUM (y); + return make_fixnum (ival); } #ifdef HAVE_BIGNUM case BIGNUM_T: ＠＠ -2398,7 +2398,7 ＠＠ if (iod2.c.ival < 0 ? ival > 0 : ival < 0) ival += iod2.c.ival; - return make_int (ival); + return make_fixnum (ival); } #endif /* WITH_NUMBER_TYPES */ ＠＠ -2416,12 +2416,12 ＠＠ */ (value, count)) { - CHECK_INT_COERCE_CHAR (value); - CONCHECK_INT (count); - - return make_int (XINT (count) > 0 ? - XINT (value) << XINT (count) : - XINT (value) >> -XINT (count)); + CHECK_FIXNUM_COERCE_CHAR (value); + CONCHECK_FIXNUM (count); + + return make_fixnum (XFIXNUM (count) > 0 ? + XFIXNUM (value) << XFIXNUM (count) : + XFIXNUM (value) >> -XFIXNUM (count)); } DEFUN ("lsh", Flsh, 2, 2, 0, /* ＠＠ -2438,11 +2438,11 ＠＠ if (promote_args (&value, &count) == FIXNUM_T) { - if (XREALINT (count) <= 0) - return make_int (XREALINT (value) >> -XREALINT (count)); + if (XREALFIXNUM (count) <= 0) + return make_fixnum (XREALFIXNUM (value) >> -XREALFIXNUM (count)); /* Use bignums to avoid overflow */ - bignum_set_long (scratch_bignum2, XREALINT (value)); - bignum_lshift (scratch_bignum, scratch_bignum2, XREALINT (count)); + bignum_set_long (scratch_bignum2, XREALFIXNUM (value)); + bignum_lshift (scratch_bignum, scratch_bignum2, XREALFIXNUM (count)); return Fcanonicalize_number (make_bignum_bg (scratch_bignum)); } else ＠＠ -2465,12 +2465,12 ＠＠ return Fcanonicalize_number (make_bignum_bg (scratch_bignum2)); } #else /* !HAVE_BIGNUM */ - CHECK_INT_COERCE_CHAR (value); - CONCHECK_INT (count); - - return make_int (XINT (count) > 0 ? - XUINT (value) << XINT (count) : - XUINT (value) >> -XINT (count)); + CHECK_FIXNUM_COERCE_CHAR (value); + CONCHECK_FIXNUM (count); + + return make_fixnum (XFIXNUM (count) > 0 ? + XUINT (value) << XFIXNUM (count) : + XUINT (value) >> -XFIXNUM (count)); #endif /* HAVE_BIGNUM */ } ＠＠ -2482,7 +2482,7 ＠＠ { retry: - if (INTP (number)) return make_integer (XINT (number) + 1); + if (FIXNUMP (number)) return make_integer (XFIXNUM (number) + 1); if (CHARP (number)) return make_integer (XCHAR (number) + 1); if (MARKERP (number)) return make_integer (marker_position (number) + 1); if (FLOATP (number)) return make_float (XFLOAT_DATA (number) + 1.0); ＠＠ -2526,7 +2526,7 ＠＠ { retry: - if (INTP (number)) return make_integer (XINT (number) - 1); + if (FIXNUMP (number)) return make_integer (XFIXNUM (number) - 1); if (CHARP (number)) return make_integer (XCHAR (number) - 1); if (MARKERP (number)) return make_integer (marker_position (number) - 1); if (FLOATP (number)) return make_float (XFLOAT_DATA (number) - 1.0); ＠＠ -3650,12 +3650,12 ＠＠ DEFVAR_CONST_INT ("most-negative-fixnum", &Vmost_negative_fixnum /* The fixnum closest in value to negative infinity. */); - Vmost_negative_fixnum = EMACS_INT_MIN; + Vmost_negative_fixnum = MOST_NEGATIVE_FIXNUM; DEFVAR_CONST_INT ("most-positive-fixnum", &Vmost_positive_fixnum /* The fixnum closest in value to positive infinity. */); - Vmost_positive_fixnum = EMACS_INT_MAX; + Vmost_positive_fixnum = MOST_POSITIVE_FIXNUM; #ifdef DEBUG_XEMACS DEFVAR_BOOL ("debug-issue-ebola-notices", &debug_issue_ebola_notices /* diff -r a0e81357194e -r 56144c8593a8 src/database.c --- a/src/database.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/database.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -675,8 +675,8 ＠＠ } else { - CHECK_INT (mode); - modemask = XINT (mode); + CHECK_FIXNUM (mode); + modemask = XFIXNUM (mode); } if (NILP (codesys)) diff -r a0e81357194e -r 56144c8593a8 src/debug.c --- a/src/debug.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/debug.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -68,9 +68,9 ＠＠ else if (op == X_VALIDATE) \ return Qt; \ else if (op == X_SETTYPE) \ - active_debug_classes.types_of_##item = XINT (type); \ + active_debug_classes.types_of_##item = XFIXNUM (type); \ else if (op == X_TYPE) \ - retval = make_int (active_debug_classes.types_of_##item); \ + retval = make_fixnum (active_debug_classes.types_of_##item); \ if (op == X_INIT) active_debug_classes.types_of_##item = VALBITS; \ } ＠＠ -160,7 +160,7 ＠＠ */ (class_, type)) { - CHECK_INT (type); + CHECK_FIXNUM (type); if (NILP (xemacs_debug_loop (X_VALIDATE, class_, Qnil))) invalid_argument ("Invalid debug class", Qunbound); diff -r a0e81357194e -r 56144c8593a8 src/device-gtk.c --- a/src/device-gtk.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/device-gtk.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -431,7 +431,7 ＠＠ */ (device)) { - return make_int (DEVICE_GTK_DEPTH (decode_gtk_device (device))); + return make_fixnum (DEVICE_GTK_DEPTH (decode_gtk_device (device))); } static Lisp_Object ＠＠ -447,15 +447,15 ＠＠ switch (m) { case DM_size_device: - return Fcons (make_int (gdk_screen_width ()), - make_int (gdk_screen_height ())); + return Fcons (make_fixnum (gdk_screen_width ()), + make_fixnum (gdk_screen_height ())); case DM_size_device_mm: - return Fcons (make_int (gdk_screen_width_mm ()), - make_int (gdk_screen_height_mm ())); + return Fcons (make_fixnum (gdk_screen_width_mm ()), + make_fixnum (gdk_screen_height_mm ())); case DM_num_color_cells: - return make_int (gdk_colormap_get_system_size ()); + return make_fixnum (gdk_colormap_get_system_size ()); case DM_num_bit_planes: - return make_int (DEVICE_GTK_DEPTH (d)); + return make_fixnum (DEVICE_GTK_DEPTH (d)); #if 0 case DM_color_default: diff -r a0e81357194e -r 56144c8593a8 src/device-msw.c --- a/src/device-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/device-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -130,15 +130,15 ＠＠ static Lisp_Object build_sysmetrics_cons (int index1, int index2) { - return Fcons (index1 < 0 ? Qnil : make_int (GetSystemMetrics (index1)), - index2 < 0 ? Qnil : make_int (GetSystemMetrics (index2))); + return Fcons (index1 < 0 ? Qnil : make_fixnum (GetSystemMetrics (index1)), + index2 < 0 ? Qnil : make_fixnum (GetSystemMetrics (index2))); } static Lisp_Object build_devicecaps_cons (HDC hdc, int index1, int index2) { - return Fcons (index1 < 0 ? Qnil : make_int (GetDeviceCaps (hdc, index1)), - index2 < 0 ? Qnil : make_int (GetDeviceCaps (hdc, index2))); + return Fcons (index1 < 0 ? Qnil : make_fixnum (GetDeviceCaps (hdc, index1)), + index2 < 0 ? Qnil : make_fixnum (GetDeviceCaps (hdc, index2))); }  ＠＠ -323,27 +323,27 ＠＠ switch (m) { case DM_size_device: - return Fcons (make_int (GetDeviceCaps (hdc, HORZRES)), - make_int (GetDeviceCaps (hdc, VERTRES))); + return Fcons (make_fixnum (GetDeviceCaps (hdc, HORZRES)), + make_fixnum (GetDeviceCaps (hdc, VERTRES))); break; case DM_device_dpi: - return Fcons (make_int (GetDeviceCaps (hdc, LOGPIXELSX)), - make_int (GetDeviceCaps (hdc, LOGPIXELSY))); + return Fcons (make_fixnum (GetDeviceCaps (hdc, LOGPIXELSX)), + make_fixnum (GetDeviceCaps (hdc, LOGPIXELSY))); break; case DM_size_device_mm: - return Fcons (make_int (GetDeviceCaps (hdc, HORZSIZE)), - make_int (GetDeviceCaps (hdc, VERTSIZE))); + return Fcons (make_fixnum (GetDeviceCaps (hdc, HORZSIZE)), + make_fixnum (GetDeviceCaps (hdc, VERTSIZE))); break; case DM_num_bit_planes: /* this is what X means by bitplanes therefore we ought to be consistent. num planes is always 1 under mswindows and therefore useless */ - return make_int (GetDeviceCaps (hdc, BITSPIXEL)); + return make_fixnum (GetDeviceCaps (hdc, BITSPIXEL)); break; case DM_num_color_cells: /* #### SIZEPALETTE only valid if RC_PALETTE bit set in RASTERCAPS, what should we return for a non-palette-based device? */ - return make_int (GetDeviceCaps (hdc, SIZEPALETTE)); + return make_fixnum (GetDeviceCaps (hdc, SIZEPALETTE)); break; /*** Colors ***/ ＠＠ -383,15 +383,15 ＠＠ { RECT rc; mswindows_get_workspace_coords (&rc); - return Fcons (make_int (rc.right - rc.left), - make_int (rc.bottom - rc.top)); + return Fcons (make_fixnum (rc.right - rc.left), + make_fixnum (rc.bottom - rc.top)); } case DM_offset_workspace: { RECT rc; mswindows_get_workspace_coords (&rc); - return Fcons (make_int (rc.left), make_int (rc.top)); + return Fcons (make_fixnum (rc.left), make_fixnum (rc.top)); } /* ＠＠ -403,7 +403,7 ＠＠ /*** Features ***/ #define FROB(met, index) \ case DM_##met: \ - return make_int (GetSystemMetrics (index)); + return make_fixnum (GetSystemMetrics (index)); FROB (mouse_buttons, SM_CMOUSEBUTTONS); FROB (swap_buttons, SM_SWAPBUTTON); ＠＠ -600,7 +600,7 ＠＠ /* this is what X means by bitplanes therefore we ought to be consistent. num planes is always 1 under mswindows and therefore useless */ - return make_int (GetDeviceCaps (DEVICE_MSPRINTER_HDC (d), BITSPIXEL)); + return make_fixnum (GetDeviceCaps (DEVICE_MSPRINTER_HDC (d), BITSPIXEL)); case DM_num_color_cells: /* Printers are non-palette devices */ case DM_slow_device: /* Animation would be a really bad idea */ ＠＠ -794,13 +794,13 ＠＠ /* Do consing in reverse order. Number of copies */ - result = Fcons (Qcopies, Fcons (make_int (pd.nCopies), result)); + result = Fcons (Qcopies, Fcons (make_fixnum (pd.nCopies), result)); /* Page range */ if (pd.Flags & PD_PAGENUMS) { - result = Fcons (Qto_page, Fcons (make_int (pd.nToPage), result)); - result = Fcons (Qfrom_page, Fcons (make_int (pd.nFromPage), result)); + result = Fcons (Qto_page, Fcons (make_fixnum (pd.nToPage), result)); + result = Fcons (Qfrom_page, Fcons (make_fixnum (pd.nFromPage), result)); result = Fcons (Qselected_page_button, Fcons (Qpages, result)); } else if (pd.Flags & PD_SELECTION) ＠＠ -883,17 +883,17 ＠＠ plist_get_margin (Lisp_Object plist, Lisp_Object prop, int mm_p) { Lisp_Object val = - Fplist_get (plist, prop, make_int (mswindows_get_default_margin (prop))); - if (!INTP (val)) + Fplist_get (plist, prop, make_fixnum (mswindows_get_default_margin (prop))); + if (!FIXNUMP (val)) invalid_argument ("Margin value must be an integer", val); - return MulDiv (XINT (val), mm_p ? 254 : 100, 144); + return MulDiv (XFIXNUM (val), mm_p ? 254 : 100, 144); } static Lisp_Object plist_set_margin (Lisp_Object plist, Lisp_Object prop, int margin, int mm_p) { - Lisp_Object val = make_int (MulDiv (margin, 144, mm_p ? 254 : 100)); + Lisp_Object val = make_fixnum (MulDiv (margin, 144, mm_p ? 254 : 100)); return Fcons (prop, Fcons (val, plist)); } ＠＠ -1279,7 +1279,7 ＠＠ static void signal_enum_printer_error (void) { - invalid_operation ("Error enumerating printers", make_int (GetLastError ())); + invalid_operation ("Error enumerating printers", make_fixnum (GetLastError ())); } DEFUN ("mswindows-printer-list", Fmswindows_printer_list, 0, 0, 0, /* diff -r a0e81357194e -r 56144c8593a8 src/device-tty.c --- a/src/device-tty.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/device-tty.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -192,16 +192,16 ＠＠ switch (m) { case DM_size_device: - return Fcons (make_int (CONSOLE_TTY_DATA (con)->width), - make_int (CONSOLE_TTY_DATA (con)->height)); + return Fcons (make_fixnum (CONSOLE_TTY_DATA (con)->width), + make_fixnum (CONSOLE_TTY_DATA (con)->height)); case DM_num_bit_planes: { EMACS_INT l2 = (EMACS_INT) (log (CONSOLE_TTY_DATA (con)->colors) / log (2)); - return make_int (l2); + return make_fixnum (l2); } case DM_num_color_cells: - return make_int (CONSOLE_TTY_DATA (con)->colors); + return make_fixnum (CONSOLE_TTY_DATA (con)->colors); default: /* No such device metric property for TTY devices */ return Qunbound; } diff -r a0e81357194e -r 56144c8593a8 src/device-x.c --- a/src/device-x.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/device-x.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1617,10 +1617,10 ＠＠ else if (EQ (type, Qnatnum) && i < 0) return maybe_signal_continuable_error_2 (Qinvalid_argument, "Invalid numerical value for resource", - make_int (i), build_extstring (name_string, Qbinary), + make_fixnum (i), build_extstring (name_string, Qbinary), Qresource, errb); else - return make_int (i); + return make_fixnum (i); } else { ＠＠ -1735,7 +1735,7 ＠＠ */ (device)) { - return make_int (DEVICE_X_DEPTH (decode_x_device (device))); + return make_fixnum (DEVICE_X_DEPTH (decode_x_device (device))); } static Lisp_Object ＠＠ -1747,17 +1747,17 ＠＠ switch (m) { case DM_size_device: - return Fcons (make_int (DisplayWidth (dpy, DefaultScreen (dpy))), - make_int (DisplayHeight (dpy, DefaultScreen (dpy)))); + return Fcons (make_fixnum (DisplayWidth (dpy, DefaultScreen (dpy))), + make_fixnum (DisplayHeight (dpy, DefaultScreen (dpy)))); case DM_size_device_mm: - return Fcons (make_int (DisplayWidthMM (dpy, DefaultScreen (dpy))), - make_int (DisplayHeightMM (dpy, DefaultScreen (dpy)))); + return Fcons (make_fixnum (DisplayWidthMM (dpy, DefaultScreen (dpy))), + make_fixnum (DisplayHeightMM (dpy, DefaultScreen (dpy)))); case DM_num_bit_planes: - return make_int (DisplayPlanes (dpy, DefaultScreen (dpy))); + return make_fixnum (DisplayPlanes (dpy, DefaultScreen (dpy))); case DM_num_color_cells: - return make_int (DisplayCells (dpy, DefaultScreen (dpy))); + return make_fixnum (DisplayCells (dpy, DefaultScreen (dpy))); case DM_num_screens: - return make_int (ScreenCount (dpy)); + return make_fixnum (ScreenCount (dpy)); case DM_backing_store: switch (DoesBackingStore (DefaultScreenOfDisplay (dpy))) { ＠＠ -1798,9 +1798,9 ＠＠ { Display *dpy = get_x_display (device); - return list3 (make_int (ProtocolVersion (dpy)), - make_int (ProtocolRevision (dpy)), - make_int (VendorRelease (dpy))); + return list3 (make_fixnum (ProtocolVersion (dpy)), + make_fixnum (ProtocolRevision (dpy)), + make_fixnum (VendorRelease (dpy))); } DEFUN ("x-valid-keysym-name-p", Fx_valid_keysym_name_p, 1, 1, 0, /* diff -r a0e81357194e -r 56144c8593a8 src/device.c --- a/src/device.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/device.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -805,7 +805,7 ＠＠ int delete_console = 0; /* If we're deleting the only device on the console, delete the console. */ - if ((XINT (Flength (CONSOLE_DEVICE_LIST (c))) == 1) + if ((XFIXNUM (Flength (CONSOLE_DEVICE_LIST (c))) == 1) /* if we just created the device, it might not be listed, or something ... */ && !NILP (memq_no_quit (device, CONSOLE_DEVICE_LIST (c)))) ＠＠ -1031,9 +1031,9 ＠＠ */ (device, rate)) { - CHECK_INT (rate); + CHECK_FIXNUM (rate); - DEVICE_BAUD_RATE (decode_device (device)) = XINT (rate); + DEVICE_BAUD_RATE (decode_device (device)) = XFIXNUM (rate); return rate; } ＠＠ -1043,7 +1043,7 ＠＠ */ (device)) { - return make_int (DEVICE_BAUD_RATE (decode_device (device))); + return make_fixnum (DEVICE_BAUD_RATE (decode_device (device))); } DEFUN ("device-printer-p", Fdevice_printer_p, 0, 1, 0, /* diff -r a0e81357194e -r 56144c8593a8 src/dialog-msw.c --- a/src/dialog-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/dialog-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -447,7 +447,7 ＠＠ else signal_error (Qdialog_box_error, "Unable to create folder browser", - make_int (0)); + make_fixnum (0)); return ret; } ＠＠ -523,7 +523,7 ＠＠ signal_error (Qdialog_box_error, "Unknown common dialog box error???", - make_int (err)); + make_fixnum (err)); } } diff -r a0e81357194e -r 56144c8593a8 src/dialog-x.c --- a/src/dialog-x.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/dialog-x.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -94,7 +94,7 ＠＠ popup_selection_callback (widget, id, client_data); /* #### need to error-protect! will do so when i merge in my working ws */ - va_run_hook_with_args (Qdelete_dialog_box_hook, 1, make_int (id)); + va_run_hook_with_args (Qdelete_dialog_box_hook, 1, make_fixnum (id)); lw_destroy_all_widgets (id); /* The Motif dialog box sets the keyboard focus to itself. When it ＠＠ -289,7 +289,7 ＠＠ /* #### this could (theoretically) cause problems if we are up for a REALLY REALLY long time -- too big to fit into lisp integer. */ - return make_int (dbox_id); + return make_fixnum (dbox_id); } void diff -r a0e81357194e -r 56144c8593a8 src/dired.c --- a/src/dired.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/dired.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -507,7 +507,7 ＠＠ return bestmatch; if (matchcount == 1 && bestmatchsize == file_name_length) return Qt; - return Fsubseq (bestmatch, Qzero, make_int (bestmatchsize)); + return Fsubseq (bestmatch, Qzero, make_fixnum (bestmatchsize)); }  ＠＠ -669,7 +669,7 ＠＠ if (status_status_statui_statum_statu != NERR_Success && status_status_statui_statum_statu != ERROR_MORE_DATA) invalid_operation ("Error enumerating users", - make_int (GetLastError ())); + make_fixnum (GetLastError ())); for (i = 0; i < (int) entriesread; i++) { DO_REALLOC (user_cache.user_names, user_cache.size, ＠＠ -771,7 +771,7 ＠＠ return bestmatch; if (matchcount == 1 && bestmatchsize == user_name_length) return Qt; - return Fsubseq (bestmatch, Qzero, make_int (bestmatchsize)); + return Fsubseq (bestmatch, Qzero, make_fixnum (bestmatchsize)); }  ＠＠ -903,7 +903,7 ＠＠ } #ifndef HAVE_BIGNUM - size = make_integer (NUMBER_FITS_IN_AN_EMACS_INT (s.st_size) ? + size = make_integer (NUMBER_FITS_IN_A_FIXNUM (s.st_size) ? (EMACS_INT)s.st_size : -1); #else size = make_integer (s.st_size); ＠＠ -927,17 +927,17 ＠＠ RETURN_UNGCPRO (listn (12, mode, - make_int (s.st_nlink), - make_int (s.st_uid), - make_int (s.st_gid), + make_fixnum (s.st_nlink), + make_fixnum (s.st_uid), + make_fixnum (s.st_gid), make_time (s.st_atime), make_time (s.st_mtime), make_time (s.st_ctime), size, modestring, gid, - make_int (s.st_ino), - make_int (s.st_dev))); + make_fixnum (s.st_ino), + make_fixnum (s.st_dev))); }  diff -r a0e81357194e -r 56144c8593a8 src/doc.c --- a/src/doc.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/doc.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -66,7 +66,7 ＠＠ name_reloc = build_istring (name_nonreloc); return_me = list3 (build_msg_string ("Position out of range in doc string file"), - name_reloc, make_int (position)); + name_reloc, make_fixnum (position)); goto done; } ＠＠ -181,7 +181,7 ＠＠ name_reloc = build_istring (name_nonreloc); return_me = list3 (build_msg_string ("Position out of range in doc string file"), - name_reloc, make_int (position)); + name_reloc, make_fixnum (position)); goto done; } ＠＠ -271,7 +271,7 ＠＠ default: return_me = list2 (build_msg_string ("Invalid data in documentation file -- ^A followed by weird code"), - make_int (c)); + make_fixnum (c)); goto done; } } ＠＠ -317,16 +317,16 ＠＠ Lisp_Object name_reloc = Qnil; int standard_doc_file = 0; - if (INTP (filepos)) + if (FIXNUMP (filepos)) { file = Vinternal_doc_file_name; standard_doc_file = 1; - position = XINT (filepos); + position = XFIXNUM (filepos); } - else if (CONSP (filepos) && INTP (XCDR (filepos))) + else if (CONSP (filepos) && FIXNUMP (XCDR (filepos))) { file = XCAR (filepos); - position = XINT (XCDR (filepos)); + position = XFIXNUM (XCDR (filepos)); if (position < 0) position = - position; } ＠＠ -414,16 +414,16 ＠＠ Lisp_Object name_reloc = Qnil; int standard_doc_file = 0; - if (INTP (filepos)) + if (FIXNUMP (filepos)) { file = Vinternal_doc_file_name; standard_doc_file = 1; - position = XINT (filepos); + position = XFIXNUM (filepos); } - else if (CONSP (filepos) && INTP (XCDR (filepos))) + else if (CONSP (filepos) && FIXNUMP (XCDR (filepos))) { file = XCAR (filepos); - position = XINT (XCDR (filepos)); + position = XFIXNUM (XCDR (filepos)); if (position < 0) position = - position; } ＠＠ -532,7 +532,7 ＠＠ else { filename = get_object_file_name - (make_int (- (EMACS_INT) XSUBR (fun)->doc)); + (make_fixnum (- (EMACS_INT) XSUBR (fun)->doc)); return filename; } } ＠＠ -562,11 +562,11 ＠＠ if (!NILP(doc_offset)) { - if (INTP(doc_offset)) + if (FIXNUMP(doc_offset)) { filename = get_object_file_name - (XINT (doc_offset) > 0 ? doc_offset - : make_int (- XINT (doc_offset))); + (XFIXNUM (doc_offset) > 0 ? doc_offset + : make_fixnum (- XFIXNUM (doc_offset))); } else if (CONSP(doc_offset)) { ＠＠ -599,7 +599,7 ＠＠ if ((EMACS_INT) XSUBR (fun)->doc >= 0) doc = build_cistring (XSUBR (fun)->doc); else - doc = get_doc_string (make_int (- (EMACS_INT) XSUBR (fun)->doc)); + doc = get_doc_string (make_fixnum (- (EMACS_INT) XSUBR (fun)->doc)); } else if (COMPILED_FUNCTIONP (fun)) { ＠＠ -699,8 +699,8 ＠＠ GCPRO1 (doc); doc = Fget (symbol, prop, Qnil); - if (INTP (doc)) - doc = get_doc_string (XINT (doc) > 0 ? doc : make_int (- XINT (doc))); + if (FIXNUMP (doc)) + doc = get_doc_string (XFIXNUM (doc) > 0 ? doc : make_fixnum (- XFIXNUM (doc))); else if (CONSP (doc)) doc = get_doc_string (doc); #ifdef I18N3 ＠＠ -786,7 +786,7 ＠＠ sym = oblookup (Vobarray, p + 2, end - p - 2); if (SYMBOLP (sym)) { - Lisp_Object offset = make_int (pos + end + 1 - buf); + Lisp_Object offset = make_fixnum (pos + end + 1 - buf); /* Attach a docstring to a variable */ if (p[1] == 'V') { ＠＠ -801,12 +801,12 ＠＠ /* In the case of duplicate doc file entries, always take the later one. But if the doc is not an int (a string, say) leave it alone. */ - if (!INTP (old)) + if (!FIXNUMP (old)) goto weird; } Fput (sym, Qvariable_documentation, ((end[1] == '*') - ? make_int (- XINT (offset)) + ? make_fixnum (- XFIXNUM (offset)) : offset)); } /* Attach a docstring to a function. ＠＠ -851,7 +851,7 ＠＠ "subr", pos); goto weird; } - XSUBR (fun)->doc = (char *) (- XINT (offset)); + XSUBR (fun)->doc = (char *) (- XFIXNUM (offset)); } else if (CONSP (fun)) { ＠＠ -861,7 +861,7 ＠＠ { tem = Fcdr (Fcdr (fun)); if (CONSP (tem) && - INTP (XCAR (tem))) + FIXNUMP (XCAR (tem))) { Lisp_Object old = XCAR (tem); if (!ZEROP (old)) ＠＠ -876,7 +876,7 ＠＠ always take the later one. But if the doc is not an int (a string, say) leave it alone. */ - if (!INTP (old)) + if (!FIXNUMP (old)) goto weird; } XCAR (tem) = offset; ＠＠ -890,7 +890,7 ＠＠ { /* DOC string is a string not integer 0 */ #if 0 - weird_doc (sym, "!INTP(XCAR(tem))", + weird_doc (sym, "!FIXNUMP(XCAR(tem))", "function", pos); #endif goto cont; ＠＠ -920,7 +920,7 ＠＠ /* In the case of duplicate doc file entries, always take the later one. But if the doc is not an int (a string, say) leave it alone. */ - if (!INTP (old)) + if (!FIXNUMP (old)) goto weird; } ＠＠ -940,7 +940,7 ＠＠ { /* lose: */ signal_error (Qfile_error, "DOC file invalid at position", - make_int (pos)); + make_fixnum (pos)); weird: /* goto lose */; } ＠＠ -999,8 +999,8 ＠＠ doc = -1; tem = Fcdr (Fcdr (fun)); if (CONSP (tem) && - INTP (XCAR (tem))) - doc = XINT (XCAR (tem)); + FIXNUMP (XCAR (tem))) + doc = XFIXNUM (XCAR (tem)); } } else if (COMPILED_FUNCTIONP (fun)) ＠＠ -1011,8 +1011,8 ＠＠ else { Lisp_Object tem = compiled_function_documentation (f); - if (INTP (tem)) - doc = XINT (tem); + if (FIXNUMP (tem)) + doc = XFIXNUM (tem); } } diff -r a0e81357194e -r 56144c8593a8 src/doprnt.c --- a/src/doprnt.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/doprnt.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -371,7 +371,7 ＠＠ } if (j == Dynarr_length (specs)) - syntax_error ("No conversion spec for argument", make_int (i)); + syntax_error ("No conversion spec for argument", make_fixnum (i)); ch = spec->converter; ＠＠ -453,7 +453,7 ＠＠ if (nargs < get_args_needed (specs)) signal_error_1 (Qwrong_number_of_arguments, list3 (Qformat, - make_int (nargs), + make_fixnum (nargs), !NILP (format_reloc) ? format_reloc : make_string (format_nonreloc, format_length))); } ＠＠ -494,17 +494,17 ＠＠ struct printf_spec *nextspec = Dynarr_atp (specs, i + 1); Lisp_Object obj = largs[spec->argnum - 1]; - if (INTP (obj)) + if (FIXNUMP (obj)) { if (spec->forwarding_precision) { - nextspec->precision = XINT (obj); + nextspec->precision = XFIXNUM (obj); nextspec->minwidth = spec->minwidth; } else { - nextspec->minwidth = XINT (obj); - if (XINT (obj) < 0) + nextspec->minwidth = XFIXNUM (obj); + if (XFIXNUM (obj) < 0) { spec->minus_flag = 1; nextspec->minwidth = - nextspec->minwidth; ＠＠ -521,7 +521,7 ＠＠ if (largs && (spec->argnum < 1 || spec->argnum > nargs)) syntax_error ("Invalid repositioning argument", - make_int (spec->argnum)); + make_fixnum (spec->argnum)); else if (ch == 'S' || ch == 's') { ＠＠ -588,7 +588,7 ＠＠ { Lisp_Object obj = largs[spec->argnum - 1]; if (CHARP (obj)) - obj = make_int (XCHAR (obj)); + obj = make_fixnum (XCHAR (obj)); if (!NUMBERP (obj)) { /* WARNING! This MUST be big enough for the sprintf below */ ＠＠ -600,8 +600,8 ＠＠ } else if (strchr (double_converters, ch)) { - if (INTP (obj)) - arg.d = XINT (obj); + if (FIXNUMP (obj)) + arg.d = XFIXNUM (obj); else if (FLOATP (obj)) arg.d = XFLOAT_DATA (obj); #ifdef HAVE_BIGNUM ＠＠ -643,7 +643,7 ＠＠ obj = Fcanonicalize_number (make_bignum_bg (scratch_bignum)); #else /* !HAVE_BIGNUM */ - obj = make_int (bigfloat_to_long (XBIGFLOAT_DATA (obj))); + obj = make_fixnum (bigfloat_to_long (XBIGFLOAT_DATA (obj))); #endif /* HAVE_BIGNUM */ } #endif /* HAVE_BIGFLOAT */ ＠＠ -687,18 +687,18 ＠＠ } } #endif - if (INTP (obj)) + if (FIXNUMP (obj)) { if (strchr (unsigned_int_converters, ch)) { #ifdef HAVE_BIGNUM - if (XINT (obj) < 0) + if (XFIXNUM (obj) < 0) dead_wrong_type_argument (Qnatnump, obj); #endif arg.ul = (unsigned long) XUINT (obj); } else - arg.l = XINT (obj); + arg.l = XFIXNUM (obj); } } } diff -r a0e81357194e -r 56144c8593a8 src/editfns.c --- a/src/editfns.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/editfns.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -142,7 +142,7 ＠＠ buildmark (Charbpos val, Lisp_Object buffer) { Lisp_Object mark = Fmake_marker (); - Fset_marker (mark, make_int (val), buffer); + Fset_marker (mark, make_fixnum (val), buffer); return mark; } ＠＠ -154,7 +154,7 ＠＠ (buffer)) { struct buffer *b = decode_buffer (buffer, 1); - return make_int (BUF_PT (b)); + return make_fixnum (BUF_PT (b)); } DEFUN ("point-marker", Fpoint_marker, 0, 2, 0, /* ＠＠ -197,7 +197,7 ＠＠ Charbpos n = get_buffer_pos_char (b, position, GB_COERCE_RANGE); BUF_SET_PT (b, n); atomic_extent_goto_char_p = 1; - return make_int (n); + return make_fixnum (n); } static Lisp_Object ＠＠ -212,8 +212,8 ＠＠ #endif m = Fmarker_position (b->mark); if (NILP (m)) invalid_operation ("There is no region now", Qunbound); - if (!!(BUF_PT (b) < XINT (m)) == !!beginningp) - return make_int (BUF_PT (b)); + if (!!(BUF_PT (b) < XFIXNUM (m)) == !!beginningp) + return make_fixnum (BUF_PT (b)); else return m; } ＠＠ -312,8 +312,8 ＠＠ incorrect. --ben */ #ifdef ERROR_CHECK_TEXT - assert (XINT (Fpoint (Qnil)) == - XINT (Fmarker_position (Fpoint_marker (Qt, Qnil)))); + assert (XFIXNUM (Fpoint (Qnil)) == + XFIXNUM (Fmarker_position (Fpoint_marker (Qt, Qnil)))); #endif b = current_buffer; ＠＠ -415,7 +415,7 ＠＠ (buffer)) { struct buffer *b = decode_buffer (buffer, 1); - return make_int (BUF_SIZE (b)); + return make_fixnum (BUF_SIZE (b)); } DEFUN ("point-min", Fpoint_min, 0, 1, 0, /* ＠＠ -427,7 +427,7 ＠＠ (buffer)) { struct buffer *b = decode_buffer (buffer, 1); - return make_int (BUF_BEGV (b)); + return make_fixnum (BUF_BEGV (b)); } DEFUN ("point-min-marker", Fpoint_min_marker, 0, 1, 0, /* ＠＠ -451,7 +451,7 ＠＠ (buffer)) { struct buffer *b = decode_buffer (buffer, 1); - return make_int (BUF_ZV (b)); + return make_fixnum (BUF_ZV (b)); } DEFUN ("point-max-marker", Fpoint_max_marker, 0, 1, 0, /* ＠＠ -665,8 +665,8 ＠＠ if (!NILP (uid)) { - CHECK_INT (uid); - local_uid = XINT (uid); + CHECK_FIXNUM (uid); + local_uid = XFIXNUM (uid); returned_name = user_login_name (&local_uid); } else ＠＠ -750,7 +750,7 ＠＠ */ ()) { - return make_int (geteuid ()); + return make_fixnum (geteuid ()); } DEFUN ("user-real-uid", Fuser_real_uid, 0, 0, 0, /* ＠＠ -758,7 +758,7 ＠＠ */ ()) { - return make_int (getuid ()); + return make_fixnum (getuid ()); } DEFUN ("user-full-name", Fuser_full_name, 0, 1, 0, /* ＠＠ -910,7 +910,7 ＠＠ */ ()) { - return make_int (qxe_getpid ()); + return make_fixnum (qxe_getpid ()); } DEFUN ("current-time", Fcurrent_time, 0, 0, 0, /* ＠＠ -928,9 +928,9 ＠＠ EMACS_TIME t; EMACS_GET_TIME (t); - return list3 (make_int ((EMACS_SECS (t) >> 16) & 0xffff), - make_int ((EMACS_SECS (t) >> 0) & 0xffff), - make_int (EMACS_USECS (t))); + return list3 (make_fixnum ((EMACS_SECS (t) >> 16) & 0xffff), + make_fixnum ((EMACS_SECS (t) >> 0) & 0xffff), + make_fixnum (EMACS_USECS (t))); } DEFUN ("current-process-time", Fcurrent_process_time, 0, 0, 0, /* ＠＠ -979,10 +979,10 ＠＠ low = XCDR (specified_time); if (CONSP (low)) low = XCAR (low); - CHECK_INT (high); - CHECK_INT (low); - *result = (XINT (high) << 16) + (XINT (low) & 0xffff); - return *result >> 16 == XINT (high); + CHECK_FIXNUM (high); + CHECK_FIXNUM (low); + *result = (XFIXNUM (high) << 16) + (XFIXNUM (low) & 0xffff); + return *result >> 16 == XFIXNUM (high); } Lisp_Object time_to_lisp (time_t the_time); ＠＠ -990,7 +990,7 ＠＠ time_to_lisp (time_t the_time) { unsigned int item = (unsigned int) the_time; - return Fcons (make_int (item >> 16), make_int (item & 0xffff)); + return Fcons (make_fixnum (item >> 16), make_fixnum (item & 0xffff)); } size_t emacs_strftime (Extbyte *string, size_t max, const Extbyte *format, ＠＠ -1111,17 +1111,17 ＠＠ decoded_time = gmtime (&time_spec); return listn(9, - make_int (save_tm.tm_sec), - make_int (save_tm.tm_min), - make_int (save_tm.tm_hour), - make_int (save_tm.tm_mday), - make_int (save_tm.tm_mon + 1), - make_int (save_tm.tm_year + 1900), - make_int (save_tm.tm_wday), + make_fixnum (save_tm.tm_sec), + make_fixnum (save_tm.tm_min), + make_fixnum (save_tm.tm_hour), + make_fixnum (save_tm.tm_mday), + make_fixnum (save_tm.tm_mon + 1), + make_fixnum (save_tm.tm_year + 1900), + make_fixnum (save_tm.tm_wday), save_tm.tm_isdst ? Qt : Qnil, (decoded_time == NULL) ? Qnil - : make_int (difftm (&save_tm, decoded_time))); + : make_fixnum (difftm (&save_tm, decoded_time))); } static void set_time_zone_rule (Extbyte *tzstring); ＠＠ -1131,8 +1131,8 ＠＠ Lisp_Object make_time (time_t tiempo) { - return list2 (make_int (tiempo < 0 ? tiempo / 0x10000 : tiempo >> 16), - make_int (tiempo & 0xFFFF)); + return list2 (make_fixnum (tiempo < 0 ? tiempo / 0x10000 : tiempo >> 16), + make_fixnum (tiempo & 0xFFFF)); } DEFUN ("encode-time", Fencode_time, 6, MANY, 0, /* ＠＠ -1161,12 +1161,12 ＠＠ struct tm tm; Lisp_Object zone = (nargs > 6) ? args[nargs - 1] : Qnil; - CHECK_INT (*args); tm.tm_sec = XINT (*args++); /* second */ - CHECK_INT (*args); tm.tm_min = XINT (*args++); /* minute */ - CHECK_INT (*args); tm.tm_hour = XINT (*args++); /* hour */ - CHECK_INT (*args); tm.tm_mday = XINT (*args++); /* day */ - CHECK_INT (*args); tm.tm_mon = XINT (*args++) - 1; /* month */ - CHECK_INT (*args); tm.tm_year = XINT (*args++) - 1900;/* year */ + CHECK_FIXNUM (*args); tm.tm_sec = XFIXNUM (*args++); /* second */ + CHECK_FIXNUM (*args); tm.tm_min = XFIXNUM (*args++); /* minute */ + CHECK_FIXNUM (*args); tm.tm_hour = XFIXNUM (*args++); /* hour */ + CHECK_FIXNUM (*args); tm.tm_mday = XFIXNUM (*args++); /* day */ + CHECK_FIXNUM (*args); tm.tm_mon = XFIXNUM (*args++) - 1; /* month */ + CHECK_FIXNUM (*args); tm.tm_year = XFIXNUM (*args++) - 1900;/* year */ tm.tm_isdst = -1; ＠＠ -1185,10 +1185,10 ＠＠ if (STRINGP (zone)) tzstring = LISP_STRING_TO_EXTERNAL (zone, Qtime_zone_encoding); - else if (INTP (zone)) + else if (FIXNUMP (zone)) { - int abszone = abs (XINT (zone)); - sprintf (tzbuf, "XXX%s%d:%02d:%02d", "-" + (XINT (zone) < 0), + int abszone = abs (XFIXNUM (zone)); + sprintf (tzbuf, "XXX%s%d:%02d:%02d", "-" + (XFIXNUM (zone) < 0), abszone / (60*60), (abszone/60) % 60, abszone % 60); tzstring = tzbuf; } ＠＠ -1327,7 +1327,7 ＠＠ am%60); tem = build_istring (buf); } - return list2 (make_int (offset), tem); + return list2 (make_fixnum (offset), tem); } else return list2 (Qnil, Qnil); ＠＠ -1579,8 +1579,8 ＠＠ cou = 1; else { - CHECK_INT (count); - cou = XINT (count); + CHECK_FIXNUM (count); + cou = XFIXNUM (count); } charlen = set_itext_ichar (str, XCHAR (character)); ＠＠ -1718,17 +1718,17 ＠＠ c2 = TRT_TABLE_OF (trt, c2); } if (c1 < c2) - return make_int (- 1 - i); + return make_fixnum (- 1 - i); if (c1 > c2) - return make_int (i + 1); + return make_fixnum (i + 1); } /* The strings match as far as they go. If one is shorter, that one is less. */ if (length < len1) - return make_int (length + 1); + return make_fixnum (length + 1); else if (length < len2) - return make_int (- length - 1); + return make_fixnum (- length - 1); /* Same length too => they are equal. */ return Qzero; ＠＠ -1962,7 +1962,7 ＠＠ dead_wrong_type_argument (Qstringp, table); end_multiple_change (buf, mc_count); - return make_int (cnt); + return make_fixnum (cnt); } DEFUN ("delete-region", Fdelete_region, 2, 3, "r", /* ＠＠ -2070,8 +2070,8 ＠＠ But that was clearly before the advent of marker-insertion-type. --ben */ - Fset_marker (bottom, make_int (BUF_BEGV (buf)), wrap_buffer (buf)); - Fset_marker (top, make_int (BUF_ZV (buf)), wrap_buffer (buf)); + Fset_marker (bottom, make_fixnum (BUF_BEGV (buf)), wrap_buffer (buf)); + Fset_marker (top, make_fixnum (BUF_ZV (buf)), wrap_buffer (buf)); Fset_marker_insertion_type (top, Qt); return noseeum_cons (wrap_buffer (buf), noseeum_cons (bottom, top)); diff -r a0e81357194e -r 56144c8593a8 src/elhash.c --- a/src/elhash.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/elhash.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -289,9 +289,9 ＠＠ res = IGNORE_MULTIPLE_VALUES (Ffuncall (countof (args), args)); UNGCPRO; - if (INTP (res)) + if (FIXNUMP (res)) { - return (Hashcode) (XINT (res)); + return (Hashcode) (XFIXNUM (res)); } #ifdef HAVE_BIGNUM ＠＠ -820,7 +820,7 ＠＠ /* hash_table_size() can't handle excessively large sizes. */ maybe_signal_error_1 (Qargs_out_of_range, list3 (value, Qzero, - make_integer (EMACS_INT_MAX)), + make_integer (MOST_POSITIVE_FIXNUM)), Qhash_table, errb); return 0; } ＠＠ -841,7 +841,7 ＠＠ static Elemcount decode_hash_table_size (Lisp_Object obj) { - return NILP (obj) ? HASH_TABLE_DEFAULT_SIZE : XINT (obj); + return NILP (obj) ? HASH_TABLE_DEFAULT_SIZE : XFIXNUM (obj); } static int ＠＠ -1373,11 +1373,11 ＠＠ break; if (!HTENTRY_CLEAR_P (probe)) - probe->value = make_int (XINT (probe->value) + offset); + probe->value = make_fixnum (XFIXNUM (probe->value) + offset); else { probe->key = key; - probe->value = make_int (offset); + probe->value = make_fixnum (offset); if (++ht->count >= ht->rehash_count) { ＠＠ -1490,7 +1490,7 ＠＠ */ (hash_table)) { - return make_int (xhash_table (hash_table)->count); + return make_fixnum (xhash_table (hash_table)->count); } DEFUN ("hash-table-test", Fhash_table_test, 1, 1, 0, /* ＠＠ -1511,7 +1511,7 ＠＠ */ (hash_table)) { - return make_int (xhash_table (hash_table)->size); + return make_fixnum (xhash_table (hash_table)->size); } DEFUN ("hash-table-rehash-size", Fhash_table_rehash_size, 1, 1, 0, /* ＠＠ -2085,9 +2085,9 ＠＠ return LISP_HASH (make_char (CANONCASE (NULL, XCHAR (obj)))); } - if (INTP (obj)) + if (FIXNUMP (obj)) { - return FLOAT_HASHCODE_FROM_DOUBLE ((double) (XINT (obj))); + return FLOAT_HASHCODE_FROM_DOUBLE ((double) (XFIXNUM (obj))); } } ＠＠ -2206,7 +2206,7 ＠＠ min = Ffunction_min_args (equal_function); max = Ffunction_max_args (equal_function); - if (!((XINT (min) <= 2) && (NILP (max) || 2 <= XINT (max)))) + if (!((XFIXNUM (min) <= 2) && (NILP (max) || 2 <= XFIXNUM (max)))) { signal_wrong_number_of_arguments_error (equal_function, 2); } ＠＠ -2214,7 +2214,7 ＠＠ min = Ffunction_min_args (hash_function); max = Ffunction_max_args (hash_function); - if (!((XINT (min) <= 1) && (NILP (max) || 1 <= XINT (max)))) + if (!((XFIXNUM (min) <= 1) && (NILP (max) || 1 <= XFIXNUM (max)))) { signal_wrong_number_of_arguments_error (hash_function, 1); } ＠＠ -2403,7 +2403,7 ＠＠ assert (!NILP (Fassq (Qeql, weak_list_list))); assert (!NILP (Fassq (Qequal, weak_list_list))); assert (!NILP (Fassq (Qequalp, weak_list_list))); - assert (4 == XINT (Flength (weak_list_list))); + assert (4 == XFIXNUM (Flength (weak_list_list))); Vhash_table_test_weak_list = make_weak_list (WEAK_LIST_KEY_ASSOC); XWEAK_LIST_LIST (Vhash_table_test_weak_list) = weak_list_list; diff -r a0e81357194e -r 56144c8593a8 src/emacs.c --- a/src/emacs.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/emacs.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -735,7 +735,7 ＠＠ make_argc_argv (Lisp_Object argv_list, int *argc, Wexttext ***argv) { Lisp_Object next; - int n = XINT (Flength (argv_list)); + int n = XFIXNUM (Flength (argv_list)); REGISTER int i; *argv = xnew_array (Wexttext *, n + 1); ＠＠ -2060,7 +2060,7 ＠＠ - build_cistring() - build_ascstring() - make_vector() - - make_int() + - make_fixnum() - make_char() - make_extent() - ALLOC_NORMAL_LISP_OBJECT() ＠＠ -3788,7 +3788,7 ＠＠ voodoo_free_hook; #endif - exit (INTP (arg) ? XINT (arg) : 0); + exit (FIXNUMP (arg) ? XFIXNUM (arg) : 0); RETURN_NOT_REACHED (Qnil); } ＠＠ -4299,7 +4299,7 ＠＠ FSF Emacs: 19.23 XEmacs: 19.10 */ ); - Vemacs_major_version = make_int (EMACS_MAJOR_VERSION); + Vemacs_major_version = make_fixnum (EMACS_MAJOR_VERSION); DEFVAR_LISP ("emacs-minor-version", &Vemacs_minor_version /* Minor version number of this version of Emacs, as an integer. ＠＠ -4307,7 +4307,7 ＠＠ FSF Emacs: 19.23 XEmacs: 19.10 */ ); - Vemacs_minor_version = make_int (EMACS_MINOR_VERSION); + Vemacs_minor_version = make_fixnum (EMACS_MINOR_VERSION); DEFVAR_LISP ("emacs-patch-level", &Vemacs_patch_level /* The patch level of this version of Emacs, as an integer. ＠＠ -4317,7 +4317,7 ＠＠ earlier than 21.1.1 */ ); #ifdef EMACS_PATCH_LEVEL - Vemacs_patch_level = make_int (EMACS_PATCH_LEVEL); + Vemacs_patch_level = make_fixnum (EMACS_PATCH_LEVEL); #else Vemacs_patch_level = Qnil; #endif ＠＠ -4329,7 +4329,7 ＠＠ earlier than 20.3. */ ); #ifdef EMACS_BETA_VERSION - Vemacs_beta_version = make_int (EMACS_BETA_VERSION); + Vemacs_beta_version = make_fixnum (EMACS_BETA_VERSION); #else Vemacs_beta_version = Qnil; #endif diff -r a0e81357194e -r 56144c8593a8 src/emodules.c --- a/src/emodules.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/emodules.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -115,7 +115,7 ＠＠ mver = XSTRING_DATA (version); dlhandle = 0; - record_unwind_protect (module_load_unwind, make_int(modnum)); + record_unwind_protect (module_load_unwind, make_fixnum(modnum)); emodules_load (mod, mname, mver); unbind_to (speccount); ＠＠ -283,12 +283,12 ＠＠ if (CONSP (upto)) { - if (INTP (XCAR (upto))) - l = XINT (XCAR (upto)); + if (FIXNUMP (XCAR (upto))) + l = XFIXNUM (XCAR (upto)); free_cons (upto); } else - l = XINT (upto); + l = XFIXNUM (upto); /* * Here we need to go through and dlclose() (IN REVERSE ORDER!) any diff -r a0e81357194e -r 56144c8593a8 src/eval.c --- a/src/eval.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/eval.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1242,7 +1242,7 ＠＠ GET_LIST_LENGTH (args, nargs); if (nargs & 1) /* Odd number of arguments? */ - Fsignal (Qwrong_number_of_arguments, list2 (Qsetq, make_int (nargs))); + Fsignal (Qwrong_number_of_arguments, list2 (Qsetq, make_fixnum (nargs))); GC_PROPERTY_LIST_LOOP_3 (symbol, val, args) { ＠＠ -1281,7 +1281,7 ＠＠ if (nargs != 1) { Fsignal (Qwrong_number_of_arguments, - list2 (Qquote, make_int (nargs))); + list2 (Qquote, make_fixnum (nargs))); } return XCAR (args); ＠＠ -1363,7 +1363,7 ＠＠ if (nargs != 1) { Fsignal (Qwrong_number_of_arguments, - list2 (Qfunction, make_int (nargs))); + list2 (Qfunction, make_fixnum (nargs))); } return XCAR (args); ＠＠ -1410,7 +1410,7 ＠＠ /* This function can GC */ if (!NILP (Vmacro_declaration_function)) { - Lisp_Object declare = Fnth (make_int (2), args); + Lisp_Object declare = Fnth (make_fixnum (2), args); /* Sigh. This GNU interface is incompatible with the CL declare macro, and the latter is much older. ＠＠ -1426,7 +1426,7 ＠＠ if (STRINGP (declare)) { - declare = Fnth (make_int (3), args); + declare = Fnth (make_fixnum (3), args); } if (CONSP (declare) && EQ (Qdeclare, XCAR (declare))) ＠＠ -1601,7 +1601,7 ＠＠ if (EQ (XCAR (def), Qautoload)) { /* Autoloading function: will it be a macro when loaded? */ - tem = Felt (def, make_int (4)); + tem = Felt (def, make_fixnum (4)); if (EQ (tem, Qt) || EQ (tem, Qmacro)) { /* Yes, load it and try again. */ ＠＠ -1929,7 +1929,7 ＠＠ GET_LIST_LENGTH (args, nargs); if (nargs != 2) { - Fsignal (Qwrong_number_of_arguments, list2 (Qthrow, make_int (nargs))); + Fsignal (Qwrong_number_of_arguments, list2 (Qthrow, make_fixnum (nargs))); } tag = IGNORE_MULTIPLE_VALUES (Feval (XCAR(args))); ＠＠ -2309,8 +2309,8 ＠＠ Lisp_Object tem; tem = Ffunction_max_args (args[0]); - if (! (XINT (Ffunction_min_args (args[0])) <= 1 - && (NILP (tem) || 1 <= XINT (tem)))) + if (! (XFIXNUM (Ffunction_min_args (args[0])) <= 1 + && (NILP (tem) || 1 <= XFIXNUM (tem)))) invalid_argument ("Must be function of one argument", args[0]); /* (handler-fun . handler-args) but currently there are no handler-args */ ＠＠ -3042,7 +3042,7 ＠＠ signal_wrong_number_of_arguments_error (Lisp_Object function, int nargs) { return Fsignal (Qwrong_number_of_arguments, - list2 (function, make_int (nargs))); + list2 (function, make_fixnum (nargs))); } /* Used in list traversal macros for efficiency. */ ＠＠ -3705,7 +3705,7 ＠＠ if (EQ (fun, indirect_function (*backtrace_list->function, 0))) fun = *backtrace_list->function; return Fsignal (Qwrong_number_of_arguments, - list2 (fun, make_int (nargs))); + list2 (fun, make_fixnum (nargs))); } { ＠＠ -4275,11 +4275,11 ＠＠ optimize_compiled_function (function); if (function_min_args_p) - return make_int (f->min_args); + return make_fixnum (f->min_args); else if (f->max_args == MANY) return Qnil; else - return make_int (f->max_args); + return make_fixnum (f->max_args); } else if (CONSP (function)) { ＠＠ -4335,7 +4335,7 ＠＠ } } - return make_int (argcount); + return make_fixnum (argcount); } } ＠＠ -4633,8 +4633,8 ＠＠ if (index != 0 && (index < first_desired || index >= (first_desired + allocated_count))) { - args_out_of_range (make_int (first_desired), - make_int (first_desired + allocated_count)); + args_out_of_range (make_fixnum (first_desired), + make_fixnum (first_desired + allocated_count)); } mv->contents[index == 0 ? 0 : 1 + (index - first_desired)] = value; ＠＠ -4650,8 +4650,8 ＠＠ if (index != 0 && (index < first_desired || index >= (first_desired + allocated_count))) { - args_out_of_range (make_int (first_desired), - make_int (first_desired + allocated_count)); + args_out_of_range (make_fixnum (first_desired), + make_fixnum (first_desired + allocated_count)); } return mv->contents[index == 0 ? 0 : 1 + (index - first_desired)]; ＠＠ -4758,7 +4758,7 ＠＠ if (upper > Vmultiple_values_limit) { - args_out_of_range (make_int (upper), make_int (Vmultiple_values_limit)); + args_out_of_range (make_fixnum (upper), make_fixnum (Vmultiple_values_limit)); } /* In the event that something back up the stack wants more multiple ＠＠ -4793,7 +4793,7 ＠＠ multiple_value_call (int nargs, Lisp_Object *args) { /* The argument order here is horrible: */ - int i, speccount = XINT (args[3]); + int i, speccount = XFIXNUM (args[3]); Lisp_Object result = Qnil, head = Fcons (args[0], Qnil), list_offset; struct gcpro gcpro1, gcpro2; Lisp_Object apply_args[2]; ＠＠ -4866,13 +4866,13 ＠＠ gcpro1.nvars = ++i; /* The argument order is horrible here. */ - constructed_args[i] = make_int (0); + constructed_args[i] = make_fixnum (0); gcpro1.nvars = ++i; - constructed_args[i] = make_int (Vmultiple_values_limit); + constructed_args[i] = make_fixnum (Vmultiple_values_limit); gcpro1.nvars = ++i; speccount = bind_multiple_value_limits (0, Vmultiple_values_limit); - constructed_args[i] = make_int (speccount); + constructed_args[i] = make_fixnum (speccount); gcpro1.nvars = ++i; { ＠＠ -4889,8 +4889,8 ＠＠ Lisp_Object multiple_value_list_internal (int nargs, Lisp_Object *args) { - int first = XINT (args[0]), upper = XINT (args[1]), - speccount = XINT(args[2]); + int first = XFIXNUM (args[0]), upper = XFIXNUM (args[1]), + speccount = XFIXNUM(args[2]); Lisp_Object result = Qnil; assert (nargs == 4); ＠＠ -4955,7 +4955,7 ＠＠ if (nargs != 3) { Fsignal (Qwrong_number_of_arguments, - list2 (Qmultiple_value_list_internal, make_int (nargs))); + list2 (Qmultiple_value_list_internal, make_fixnum (nargs))); } argv[0] = IGNORE_MULTIPLE_VALUES (Feval (XCAR (args))); ＠＠ -4966,11 +4966,11 ＠＠ args = XCDR (args); argv[1] = IGNORE_MULTIPLE_VALUES (Feval (XCAR (args))); - check_integer_range (argv[1], Qzero, make_int (EMACS_INT_MAX)); + check_integer_range (argv[1], Qzero, make_fixnum (MOST_POSITIVE_FIXNUM)); check_integer_range (argv[0], Qzero, argv[1]); - upper = XINT (argv[1]); - first = XINT (argv[0]); + upper = XFIXNUM (argv[1]); + first = XFIXNUM (argv[0]); gcpro1.nvars = 2; ＠＠ -4978,7 +4978,7 ＠＠ the alternative would be to encode the number of arguments in the bytecode stream, which complicates things if we have more than 255 arguments. */ - argv[2] = make_int (bind_multiple_value_limits (first, upper)); + argv[2] = make_fixnum (bind_multiple_value_limits (first, upper)); gcpro1.nvars = 3; args = XCDR (args); ＠＠ -7046,9 +7046,9 ＠＠ REGISTER struct backtrace *backlist = backtrace_list; REGISTER int i; - CHECK_INT (level); - - for (i = 0; backlist && i < XINT (level); i++) + CHECK_FIXNUM (level); + + for (i = 0; backlist && i < XFIXNUM (level); i++) { backlist = backlist->next; } ＠＠ -7123,9 +7123,9 ＠＠ entering_debugger = 0; if (!NILP (detailed)) - Vprint_level = make_int (50); + Vprint_level = make_fixnum (50); else - Vprint_level = make_int (3); + Vprint_level = make_fixnum (3); print_readably = 0; print_escape_newlines = 1; ＠＠ -7243,10 +7243,10 ＠＠ REGISTER int i; Lisp_Object tem; - check_integer_range (nframes, Qzero, make_integer (EMACS_INT_MAX)); + check_integer_range (nframes, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); /* Find the frame requested. */ - for (i = XINT (nframes); backlist && (i-- > 0);) + for (i = XFIXNUM (nframes); backlist && (i-- > 0);) backlist = backlist->next; if (!backlist) ＠＠ -7600,7 +7600,7 ＠＠ This applies to `values', `values-list', `multiple-value-bind' and related macros and special operators. */); - Vmultiple_values_limit = EMACS_INT_MAX > INT_MAX ? INT_MAX : EMACS_INT_MAX; + Vmultiple_values_limit = MOST_POSITIVE_FIXNUM > INT_MAX ? INT_MAX : MOST_POSITIVE_FIXNUM; DEFVAR_LISP ("macro-declaration-function", &Vmacro_declaration_function /* Function to process declarations in a macro definition. diff -r a0e81357194e -r 56144c8593a8 src/event-Xt.c --- a/src/event-Xt.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/event-Xt.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -569,10 +569,10 ＠＠ && ((xd->last_downkey && ((keycode != xd->last_downkey || ev->xkey.time != xd->release_time))) - || (INTP (Vmodifier_keys_sticky_time) + || (FIXNUMP (Vmodifier_keys_sticky_time) && ev->xkey.time - + XINT (Vmodifier_keys_sticky_time)))))) + + XFIXNUM (Vmodifier_keys_sticky_time)))))) { xd->need_to_add_mask = 0; xd->last_downkey = 0; ＠＠ -630,9 +630,9 ＠＠ } if (xd->modifier_release_time - && INTP (Vmodifier_keys_sticky_time) + && FIXNUMP (Vmodifier_keys_sticky_time) && (ev->xkey.time - > xd->modifier_release_time + XINT (Vmodifier_keys_sticky_time))) + > xd->modifier_release_time + XFIXNUM (Vmodifier_keys_sticky_time))) { xd->need_to_add_mask = 0; xd->down_mask = 0; diff -r a0e81357194e -r 56144c8593a8 src/event-msw.c --- a/src/event-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/event-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1764,7 +1764,7 ＠＠ * If the read didn't get to the end of the string, we have a syntax * error in the string supplied by the user. */ - if (XINT (XCDR (obj)) != XSTRING_LENGTH (str)) + if (XFIXNUM (XCDR (obj)) != XSTRING_LENGTH (str)) return Qnil; GCPRO1 (obj); diff -r a0e81357194e -r 56144c8593a8 src/event-stream.c --- a/src/event-stream.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/event-stream.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -715,7 +715,7 ＠＠ if (echo_area_active (f) && !EQ (Qcommand, echo_area_status (f))) goto done; - if (INTP (Vecho_keystrokes) || FLOATP (Vecho_keystrokes)) + if (FIXNUMP (Vecho_keystrokes) || FLOATP (Vecho_keystrokes)) echo_keystrokes = extract_float (Vecho_keystrokes); else echo_keystrokes = 0; ＠＠ -1236,10 +1236,10 ＠＠ static unsigned long lisp_number_to_milliseconds (Lisp_Object secs, int allow_0) { - Lisp_Object args[] = { allow_0 ? Qzero : make_int (1), + Lisp_Object args[] = { allow_0 ? Qzero : make_fixnum (1), secs, /* (((unsigned int) 0xFFFFFFFF) / 1000) - 1 */ - make_int (4294967 - 1) }; + make_fixnum (4294967 - 1) }; if (!allow_0 && FLOATP (secs) && XFLOAT_DATA (secs) > 0) { ＠＠ -1251,12 +1251,12 ＠＠ args_out_of_range_3 (secs, args[0], args[2]); } - args[0] = make_int (1000); + args[0] = make_fixnum (1000); args[0] = Ftimes (2, args); - if (INTP (args[0])) + if (FIXNUMP (args[0])) { - return XINT (args[0]); + return XFIXNUM (args[0]); } return (unsigned long) extract_float (args[0]); ＠＠ -1304,8 +1304,8 ＠＠ int id; Lisp_Object lid; id = event_stream_generate_wakeup (msecs, msecs2, function, object, 0); - lid = make_int (id); - assert (id == XINT (lid)); + lid = make_fixnum (id); + assert (id == XFIXNUM (lid)); return lid; } ＠＠ -1320,8 +1320,8 ＠＠ */ (id)) { - CHECK_INT (id); - event_stream_disable_wakeup (XINT (id), 0); + CHECK_FIXNUM (id); + event_stream_disable_wakeup (XFIXNUM (id), 0); return Qnil; } ＠＠ -1383,8 +1383,8 ＠＠ int id; Lisp_Object lid; id = event_stream_generate_wakeup (msecs, msecs2, function, object, 1); - lid = make_int (id); - assert (id == XINT (lid)); + lid = make_fixnum (id); + assert (id == XFIXNUM (lid)); return lid; } ＠＠ -1399,8 +1399,8 ＠＠ */ (id)) { - CHECK_INT (id); - event_stream_disable_wakeup (XINT (id), 1); + CHECK_FIXNUM (id); + event_stream_disable_wakeup (XFIXNUM (id), 1); return Qnil; } ＠＠ -1798,7 +1798,7 ＠＠ if (!NILP (Vunread_command_event)) how_many--; - how_many -= XINT (Fsafe_length (Vunread_command_events)); + how_many -= XFIXNUM (Fsafe_length (Vunread_command_events)); if (how_many <= 0) return 1; ＠＠ -2348,16 +2348,16 ＠＠ EMACS_GET_TIME (t); if (!CONSP (Vlast_input_time)) Vlast_input_time = Fcons (Qnil, Qnil); - XCAR (Vlast_input_time) = make_int ((EMACS_SECS (t) >> 16) & 0xffff); - XCDR (Vlast_input_time) = make_int ((EMACS_SECS (t) >> 0) & 0xffff); + XCAR (Vlast_input_time) = make_fixnum ((EMACS_SECS (t) >> 16) & 0xffff); + XCDR (Vlast_input_time) = make_fixnum ((EMACS_SECS (t) >> 0) & 0xffff); if (!CONSP (Vlast_command_event_time)) Vlast_command_event_time = list3 (Qnil, Qnil, Qnil); XCAR (Vlast_command_event_time) = - make_int ((EMACS_SECS (t) >> 16) & 0xffff); + make_fixnum ((EMACS_SECS (t) >> 16) & 0xffff); XCAR (XCDR (Vlast_command_event_time)) = - make_int ((EMACS_SECS (t) >> 0) & 0xffff); + make_fixnum ((EMACS_SECS (t) >> 0) & 0xffff); XCAR (XCDR (XCDR (Vlast_command_event_time))) - = make_int (EMACS_USECS (t)); + = make_fixnum (EMACS_USECS (t)); } /* If this key came from the keyboard or from a keyboard macro, then it goes into the recent-keys and this-command-keys vectors. ＠＠ -2626,8 +2626,8 ＠＠ if (!NILP (timeout_msecs)) { check_integer_range (timeout_msecs, Qzero, - make_integer (EMACS_INT_MAX)); - msecs += XINT (timeout_msecs); + make_integer (MOST_POSITIVE_FIXNUM)); + msecs += XFIXNUM (timeout_msecs); } if (msecs) { ＠＠ -2640,7 +2640,7 ＠＠ count = specpdl_depth (); record_unwind_protect (sit_for_unwind, - timeout_enabled ? make_int (timeout_id) : Qnil); + timeout_enabled ? make_fixnum (timeout_id) : Qnil); recursive_sit_for = 1; while (!done && ＠＠ -2704,7 +2704,7 ＠＠ } } - unbind_to_1 (count, timeout_enabled ? make_int (timeout_id) : Qnil); + unbind_to_1 (count, timeout_enabled ? make_fixnum (timeout_id) : Qnil); Fdeallocate_event (event); ＠＠ -2737,7 +2737,7 ＠＠ event = Fmake_event (Qnil, Qnil); count = specpdl_depth (); - record_unwind_protect (sit_for_unwind, make_int (id)); + record_unwind_protect (sit_for_unwind, make_fixnum (id)); recursive_sit_for = 1; while (1) ＠＠ -2771,7 +2771,7 ＠＠ } } DONE_LABEL: - unbind_to_1 (count, make_int (id)); + unbind_to_1 (count, make_fixnum (id)); Fdeallocate_event (event); UNGCPRO; return Qnil; ＠＠ -2843,7 +2843,7 ＠＠ id = event_stream_generate_wakeup (msecs, 0, Qnil, Qnil, 0); count = specpdl_depth (); - record_unwind_protect (sit_for_unwind, make_int (id)); + record_unwind_protect (sit_for_unwind, make_fixnum (id)); recursive_sit_for = 1; while (1) ＠＠ -2892,7 +2892,7 ＠＠ } DONE_LABEL: - unbind_to_1 (count, make_int (id)); + unbind_to_1 (count, make_fixnum (id)); /* Put back the event (if any) that made Fsit_for() exit before the timeout. Note that it is being added to the back of the queue, which ＠＠ -3717,7 +3717,7 ＠＠ { check_integer_range (number, Qzero, make_integer (ARRAY_DIMENSION_LIMIT)); - nwanted = XINT (number); + nwanted = XFIXNUM (number); } /* Create the keys ring vector, if none present. */ ＠＠ -3771,7 +3771,7 ＠＠ */ ()) { - return make_int (recent_keys_ring_size); + return make_fixnum (recent_keys_ring_size); } DEFUN ("set-recent-keys-ring-size", Fset_recent_keys_ring_size, 1, 1, 0, /* ＠＠ -3783,14 +3783,14 ＠＠ int i, j, nkeys, start, min; struct gcpro gcpro1; - CHECK_INT (size); - if (XINT (size) <= 0) + CHECK_FIXNUM (size); + if (XFIXNUM (size) <= 0) invalid_argument ("Recent keys ring size must be positive", size); - if (XINT (size) == recent_keys_ring_size) + if (XFIXNUM (size) == recent_keys_ring_size) return size; GCPRO1 (new_vector); - new_vector = make_vector (XINT (size), Qnil); + new_vector = make_vector (XFIXNUM (size), Qnil); if (NILP (Vrecent_keys_ring)) { ＠＠ -3810,10 +3810,10 ＠＠ start = ((recent_keys_ring_index == nkeys) ? 0 : recent_keys_ring_index); } - if (XINT (size) > nkeys) + if (XFIXNUM (size) > nkeys) min = nkeys; else - min = XINT (size); + min = XFIXNUM (size); for (i = 0, j = start; i < min; i++) { ＠＠ -3821,7 +3821,7 ＠＠ if (++j >= recent_keys_ring_size) j = 0; } - recent_keys_ring_size = XINT (size); + recent_keys_ring_size = XFIXNUM (size); recent_keys_ring_index = (i < recent_keys_ring_size) ? i : 0; Vrecent_keys_ring = new_vector; ＠＠ -4570,9 +4570,9 ＠＠ if (NATNUMP (prop)) { magic_undo = 1; - if (INTP (prop)) + if (FIXNUMP (prop)) { - magic_undo_count = XINT (prop); + magic_undo_count = XFIXNUM (prop); } #ifdef HAVE_BIGNUM else if (BIGNUMP (prop) ＠＠ -4873,7 +4873,7 ＠＠ /* This junk is so that timestamps don't get to be negative, but contain as many bits as this particular emacs will allow. */ - return make_int (EMACS_INT_MAX & tiempo); + return make_fixnum (MOST_POSITIVE_FIXNUM & tiempo); }  ＠＠ -4989,7 +4989,7 ＠＠ DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes /* *Nonzero means echo unfinished commands after this many seconds of pause. */ ); - Vecho_keystrokes = make_int (1); + Vecho_keystrokes = make_fixnum (1); DEFVAR_INT ("auto-save-interval", &auto_save_interval /* *Number of keyboard input characters between auto-saves. ＠＠ -5223,7 +5223,7 ＠＠ This variable has no effect when `modifier-keys-are-sticky' is nil. Currently only implemented under X Window System. */ ); - Vmodifier_keys_sticky_time = make_int (500); + Vmodifier_keys_sticky_time = make_fixnum (500); Vcontrolling_terminal = Qnil; staticpro (&Vcontrolling_terminal); diff -r a0e81357194e -r 56144c8593a8 src/event-xlike-inc.c --- a/src/event-xlike-inc.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/event-xlike-inc.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -172,7 +172,7 ＠＠ && map[keysym - FIRST_KNOWN_##map ]) do \ { \ keysym -= FIRST_KNOWN_##map ; \ - return Funicode_to_char (make_int (map[keysym]), Qnil); \ + return Funicode_to_char (make_fixnum (map[keysym]), Qnil); \ } while (0) /* Maps to Unicode for X11 KeySyms, where we don't have a direct internal ＠＠ -603,7 +603,7 ＠＠ #x01000000-#x01000100. */ if (keysym >= 0x01000000 && keysym <= 0x0110FFFF) - return Funicode_to_char (make_int (keysym & 0xffffff), Qnil); + return Funicode_to_char (make_fixnum (keysym & 0xffffff), Qnil); if ((keysym & 0xff) < 0xa0) return Qnil; ＠＠ -697,7 +697,7 ＠＠ case 32: /* Currency. The lower sixteen bits of these keysyms happily correspond exactly to the Unicode code points of the associated characters */ - return Funicode_to_char (make_int (keysym & 0xffff), Qnil); + return Funicode_to_char (make_fixnum (keysym & 0xffff), Qnil); break; default: break; diff -r a0e81357194e -r 56144c8593a8 src/events.c --- a/src/events.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/events.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -323,11 +323,11 ＠＠ { Lisp_Object Vx, Vy; Vx = Fevent_x_pixel (obj); - assert (INTP (Vx)); + assert (FIXNUMP (Vx)); Vy = Fevent_y_pixel (obj); - assert (INTP (Vy)); + assert (FIXNUMP (Vy)); write_fmt_string (printcharfun, "#<motion-event %ld, %ld", - (long) XINT (Vx), (long) XINT (Vy)); + (long) XFIXNUM (Vx), (long) XFIXNUM (Vy)); break; } case process_event: ＠＠ -639,16 +639,16 ＠＠ } else if (EQ (keyword, Qbutton)) { - check_integer_range (value, Qzero, make_int (26)); + check_integer_range (value, Qzero, make_fixnum (26)); switch (EVENT_TYPE (e)) { case button_press_event: case button_release_event: - SET_EVENT_BUTTON_BUTTON (e, XINT (value)); + SET_EVENT_BUTTON_BUTTON (e, XFIXNUM (value)); break; case misc_user_event: - SET_EVENT_MISC_USER_BUTTON (e, XINT (value)); + SET_EVENT_MISC_USER_BUTTON (e, XFIXNUM (value)); break; default: WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword); ＠＠ -707,8 +707,8 ＠＠ case misc_user_event: /* Allow negative values, so we can specify toolbar positions. */ - CHECK_INT (value); - coord_x = XINT (value); + CHECK_FIXNUM (value); + coord_x = XFIXNUM (value); break; default: WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword); ＠＠ -724,8 +724,8 ＠＠ case button_release_event: case misc_user_event: /* Allow negative values; see above. */ - CHECK_INT (value); - coord_y = XINT (value); + CHECK_FIXNUM (value); + coord_y = XFIXNUM (value); break; default: WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword); ＠＠ -741,11 +741,11 ＠＠ SET_EVENT_TIMESTAMP (e, bignum_to_uint (XBIGNUM_DATA (value))); } #else - check_integer_range (value, Qzero, make_integer (EMACS_INT_MAX)); + check_integer_range (value, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); #endif - if (INTP (value)) + if (FIXNUMP (value)) { - SET_EVENT_TIMESTAMP (e, XINT (value)); + SET_EVENT_TIMESTAMP (e, XFIXNUM (value)); } else { ＠＠ -1456,7 +1456,7 ＠＠ nth_of_key_sequence_as_event (Lisp_Object seq, int n, Lisp_Object event) { assert (STRINGP (seq) || VECTORP (seq)); - assert (n < XINT (Flength (seq))); + assert (n < XFIXNUM (Flength (seq))); if (STRINGP (seq)) { ＠＠ -1476,7 +1476,7 ＠＠ Lisp_Object key_sequence_to_event_chain (Lisp_Object seq) { - int len = XINT (Flength (seq)); + int len = XFIXNUM (Flength (seq)); int i; Lisp_Object head = Qnil, tail = Qnil; ＠＠ -1763,10 +1763,10 ＠＠ bignums on builds that support them, but that involves consing and doesn't work on builds that don't support bignums. */ - return make_int (EMACS_INT_MAX & XEVENT_TIMESTAMP (event)); + return make_fixnum (MOST_POSITIVE_FIXNUM & XEVENT_TIMESTAMP (event)); } -#define TIMESTAMP_HALFSPACE (1L << (INT_VALBITS - 2)) +#define TIMESTAMP_HALFSPACE (1L << (FIXNUM_VALBITS - 2)) DEFUN ("event-timestamp<", Fevent_timestamp_lessp, 2, 2, 0, /* Return true if timestamp TIME1 is earlier than timestamp TIME2. ＠＠ -1777,11 +1777,11 ＠＠ { EMACS_INT t1, t2; - check_integer_range (time1, Qzero, make_integer (EMACS_INT_MAX)); - check_integer_range (time2, Qzero, make_integer (EMACS_INT_MAX)); + check_integer_range (time1, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); + check_integer_range (time2, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); - t1 = XINT (time1); - t2 = XINT (time2); + t1 = XFIXNUM (time1); + t2 = XFIXNUM (time2); if (t1 < t2) return t2 - t1 < TIMESTAMP_HALFSPACE ? Qt : Qnil; ＠＠ -1835,9 +1835,9 ＠＠ misc_user_event, Qbutton_event_p); #ifdef HAVE_WINDOW_SYSTEM if (XEVENT_TYPE (event) == misc_user_event) - return make_int (XEVENT_MISC_USER_BUTTON (event)); + return make_fixnum (XEVENT_MISC_USER_BUTTON (event)); else - return make_int (XEVENT_BUTTON_BUTTON (event)); + return make_fixnum (XEVENT_BUTTON_BUTTON (event)); #else /* !HAVE_WINDOW_SYSTEM */ return Qzero; #endif /* !HAVE_WINDOW_SYSTEM */ ＠＠ -1855,14 +1855,14 ＠＠ switch (XEVENT_TYPE (event)) { case key_press_event: - return make_int (XEVENT_KEY_MODIFIERS (event)); + return make_fixnum (XEVENT_KEY_MODIFIERS (event)); case button_press_event: case button_release_event: - return make_int (XEVENT_BUTTON_MODIFIERS (event)); + return make_fixnum (XEVENT_BUTTON_MODIFIERS (event)); case pointer_motion_event: - return make_int (XEVENT_MOTION_MODIFIERS (event)); + return make_fixnum (XEVENT_MOTION_MODIFIERS (event)); case misc_user_event: - return make_int (XEVENT_MISC_USER_MODIFIERS (event)); + return make_fixnum (XEVENT_MISC_USER_MODIFIERS (event)); default: event = wrong_type_argument (intern ("key-or-mouse-event-p"), event); goto again; ＠＠ -1914,7 +1914,7 ＠＠ */ (event)) { - int mod = XINT (Fevent_modifier_bits (event)); + int mod = XFIXNUM (Fevent_modifier_bits (event)); Lisp_Object result = Qnil; struct gcpro gcpro1; ＠＠ -1995,7 +1995,7 ＠＠ if (!event_x_y_pixel_internal (event, &x, &y, 1)) return wrong_type_argument (Qmouse_event_p, event); else - return make_int (x); + return make_fixnum (x); } DEFUN ("event-window-y-pixel", Fevent_window_y_pixel, 1, 1, 0, /* ＠＠ -2013,7 +2013,7 ＠＠ if (!event_x_y_pixel_internal (event, &x, &y, 1)) return wrong_type_argument (Qmouse_event_p, event); else - return make_int (y); + return make_fixnum (y); } DEFUN ("event-x-pixel", Fevent_x_pixel, 1, 1, 0, /* ＠＠ -2031,7 +2031,7 ＠＠ if (!event_x_y_pixel_internal (event, &x, &y, 0)) return wrong_type_argument (Qmouse_event_p, event); else - return make_int (x); + return make_fixnum (x); } DEFUN ("event-y-pixel", Fevent_y_pixel, 1, 1, 0, /* ＠＠ -2049,7 +2049,7 ＠＠ if (!event_x_y_pixel_internal (event, &x, &y, 0)) return wrong_type_argument (Qmouse_event_p, event); else - return make_int (y); + return make_fixnum (y); } /* Given an event, return a value: ＠＠ -2269,7 +2269,7 ＠＠ event_pixel_translation (event, 0, 0, 0, 0, &w, &bufp, 0, 0, 0, 0); - return w && bufp ? make_int (bufp) : Qnil; + return w && bufp ? make_fixnum (bufp) : Qnil; } DEFUN ("event-closest-point", Fevent_closest_point, 1, 1, 0, /* ＠＠ -2290,7 +2290,7 ＠＠ event_pixel_translation (event, 0, 0, 0, 0, 0, 0, &bufp, 0, 0, 0); - return bufp ? make_int (bufp) : Qnil; + return bufp ? make_fixnum (bufp) : Qnil; } DEFUN ("event-x", Fevent_x, 1, 1, 0, /* ＠＠ -2303,7 +2303,7 ＠＠ event_pixel_translation (event, &char_x, 0, 0, 0, 0, 0, 0, 0, 0, 0); - return make_int (char_x); + return make_fixnum (char_x); } DEFUN ("event-y", Fevent_y, 1, 1, 0, /* ＠＠ -2316,7 +2316,7 ＠＠ event_pixel_translation (event, 0, &char_y, 0, 0, 0, 0, 0, 0, 0, 0); - return make_int (char_y); + return make_fixnum (char_y); } DEFUN ("event-modeline-position", Fevent_modeline_position, 1, 1, 0, /* ＠＠ -2335,7 +2335,7 ＠＠ where = event_pixel_translation (event, 0, 0, 0, 0, 0, 0, 0, &mbufp, 0, 0); - return (mbufp < 0 || where != OVER_MODELINE) ? Qnil : make_int (mbufp); + return (mbufp < 0 || where != OVER_MODELINE) ? Qnil : make_fixnum (mbufp); } DEFUN ("event-glyph", Fevent_glyph, 1, 1, 0, /* ＠＠ -2378,7 +2378,7 ＠＠ event_pixel_translation (event, 0, 0, &obj_x, 0, &w, 0, 0, 0, 0, &extent); - return w && EXTENTP (extent) ? make_int (obj_x) : Qnil; + return w && EXTENTP (extent) ? make_fixnum (obj_x) : Qnil; } DEFUN ("event-glyph-y-pixel", Fevent_glyph_y_pixel, 1, 1, 0, /* ＠＠ -2394,7 +2394,7 ＠＠ event_pixel_translation (event, 0, 0, 0, &obj_y, &w, 0, 0, 0, 0, &extent); - return w && EXTENTP (extent) ? make_int (obj_y) : Qnil; + return w && EXTENTP (extent) ? make_fixnum (obj_y) : Qnil; } DEFUN ("event-toolbar-button", Fevent_toolbar_button, 1, 1, 0, /* ＠＠ -2494,7 +2494,7 ＠＠ case timeout_event: props = cons3 (Qobject, Fevent_object (event), props); props = cons3 (Qfunction, Fevent_function (event), props); - props = cons3 (Qid, make_int (EVENT_TIMEOUT_ID_NUMBER (e)), props); + props = cons3 (Qid, make_fixnum (EVENT_TIMEOUT_ID_NUMBER (e)), props); break; case key_press_event: diff -r a0e81357194e -r 56144c8593a8 src/extents.c --- a/src/extents.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/extents.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -2851,8 +2851,8 ＠＠ strcpy (bp, "detached"); else sprintf (bp, "%ld, %ld", - XINT (Fextent_start_position (obj)), - XINT (Fextent_end_position (obj))); + XFIXNUM (Fextent_start_position (obj)), + XFIXNUM (Fextent_end_position (obj))); bp += strlen (bp); *bp++ = (extent_end_open_p (anc) ? ')': ']'); if (!NILP (extent_end_glyph (anc))) *bp++ = '*'; ＠＠ -3129,7 +3129,7 ＠＠ if (extent_detached_p (extent)) return Qnil; else - return make_int (extent_endpoint_char (extent, endp)); + return make_fixnum (extent_endpoint_char (extent, endp)); } DEFUN ("extentp", Fextentp, 1, 1, 0, /* ＠＠ -3186,7 +3186,7 ＠＠ (extent)) { EXTENT e = decode_extent (extent, DE_MUST_BE_ATTACHED); - return make_int (extent_endpoint_char (e, 1) + return make_fixnum (extent_endpoint_char (e, 1) - extent_endpoint_char (e, 0)); } ＠＠ -3294,7 +3294,7 ＠＠ xpos = get_buffer_or_string_pos_byte (obj, pos, GB_ALLOW_PAST_ACCESSIBLE); xpos = extent_find_end_of_run (obj, xpos, 1); - return make_int (buffer_or_string_bytexpos_to_charxpos (obj, xpos)); + return make_fixnum (buffer_or_string_bytexpos_to_charxpos (obj, xpos)); } DEFUN ("previous-extent-change", Fprevious_extent_change, 1, 2, 0, /* ＠＠ -3310,7 +3310,7 ＠＠ xpos = get_buffer_or_string_pos_byte (obj, pos, GB_ALLOW_PAST_ACCESSIBLE); xpos = extent_find_beginning_of_run (obj, xpos, 1); - return make_int (buffer_or_string_bytexpos_to_charxpos (obj, xpos)); + return make_fixnum (buffer_or_string_bytexpos_to_charxpos (obj, xpos)); }  ＠＠ -4658,8 +4658,8 ＠＠ return 0; exobj = wrap_extent (extent); - startobj = make_int (closure->start); - endobj = make_int (closure->end); + startobj = make_fixnum (closure->start); + endobj = make_fixnum (closure->end); /* Now that we are sure to call elisp, set up an unwind-protect so inside_change_hook gets restored in case we throw. Also record ＠＠ -4776,8 +4776,8 ＠＠ maliciously side-effects the returned lists. */ - len = XINT (Flength (list)); - thelen = XINT (Flength (Vextent_face_reusable_list)); + len = XFIXNUM (Flength (list)); + thelen = XFIXNUM (Flength (Vextent_face_reusable_list)); oldtail = Qnil; tail = Qnil; GCPRO1 (oldtail); ＠＠ -4792,7 +4792,7 ＠＠ cons = Vextent_face_reusable_list; while (!NILP (XCDR (cons))) cons = XCDR (cons); - XCDR (cons) = Fmake_list (make_int (len - thelen), Qnil); + XCDR (cons) = Fmake_list (make_fixnum (len - thelen), Qnil); } else if (thelen > len) { ＠＠ -5139,9 +5139,9 ＠＠ { EXTENT e = decode_extent (extent, 0); - CHECK_INT (priority); + CHECK_FIXNUM (priority); e = extent_ancestor (e); - set_extent_priority (e, XINT (priority)); + set_extent_priority (e, XFIXNUM (priority)); signal_extent_property_changed (e, Qpriority, 1); return priority; } ＠＠ -5152,7 +5152,7 ＠＠ (extent)) { EXTENT e = decode_extent (extent, 0); - return make_int (extent_priority (e)); + return make_fixnum (extent_priority (e)); } DEFUN ("set-extent-property", Fset_extent_property, 3, 3, 0, /* ＠＠ -5510,7 +5510,7 ＠＠ else if (EQ (property, Qend_closed)) return extent_end_open_p (e) ? Qnil : Qt; else if (EQ (property, Qpriority)) - return make_int (extent_priority (e)); + return make_fixnum (extent_priority (e)); else if (EQ (property, Qread_only)) return extent_read_only (e); else if (EQ (property, Qinvisible)) ＠＠ -5601,7 +5601,7 ＠＠ ADD_PROP (Qbegin_glyph, extent_begin_glyph (anc)); if (extent_priority (anc) != 0) - ADD_PROP (Qpriority, make_int (extent_priority (anc))); + ADD_PROP (Qpriority, make_fixnum (extent_priority (anc))); if (!NILP (extent_initial_redisplay_function (anc))) ADD_PROP (Qinitial_redisplay_function, ＠＠ -5754,9 +5754,9 ＠＠ GCPRO3 (extent, copy_fn, object); if (BUFFERP (object)) flag = call3_in_buffer (XBUFFER (object), copy_fn, extent, - make_int (from), make_int (to)); + make_fixnum (from), make_fixnum (to)); else - flag = call3 (copy_fn, extent, make_int (from), make_int (to)); + flag = call3 (copy_fn, extent, make_fixnum (from), make_fixnum (to)); UNGCPRO; if (NILP (flag) || !EXTENT_LIVE_P (XEXTENT (extent))) return 0; ＠＠ -6887,7 +6887,7 ＠＠ if (blim < 0) return Qnil; else - return make_int (buffer_or_string_bytexpos_to_charxpos (object, blim)); + return make_fixnum (buffer_or_string_bytexpos_to_charxpos (object, blim)); } DEFUN ("next-single-property-change", Fnext_single_property_change, diff -r a0e81357194e -r 56144c8593a8 src/file-coding.c --- a/src/file-coding.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/file-coding.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -467,7 +467,7 ＠＠ allocated up to this point is safe_chars, and that's reachable from its entry in Vdefault_query_coding_region_chartab_cache */ - call3 (Qquery_coding_clear_highlights, make_int (pos), make_int (end), + call3 (Qquery_coding_clear_highlights, make_fixnum (pos), make_fixnum (end), wrap_buffer (buf)); } ＠＠ -521,8 +521,8 ＠＠ fail_range_end = pos; - Fput_range_table (make_int (fail_range_start), - make_int (fail_range_end), + Fput_range_table (make_fixnum (fail_range_start), + make_fixnum (fail_range_end), Qunencodable, result); previous_failed_reason = query_coding_succeeded; ＠＠ -530,12 +530,12 ＠＠ if (flags & QUERY_METHOD_HIGHLIGHT) { Lisp_Object extent - = Fmake_extent (make_int (fail_range_start), - make_int (fail_range_end), + = Fmake_extent (make_fixnum (fail_range_start), + make_fixnum (fail_range_end), wrap_buffer (buf)); Fset_extent_priority - (extent, make_int (2 + mouse_highlight_priority)); + (extent, make_fixnum (2 + mouse_highlight_priority)); Fset_extent_face (extent, Qquery_coding_warning_face); } } ＠＠ -2299,7 +2299,7 ＠＠ if (!NILP (auto_outstream)) Lstream_delete (XLSTREAM (auto_outstream)); Lstream_delete (XLSTREAM (lb_outstream)); - return make_int (retlen); + return make_fixnum (retlen); } } ＠＠ -4293,7 +4293,7 ＠＠ if (data->level == -1) write_ascstring (printcharfun, "default"); else - print_internal (make_int (data->level), printcharfun, 0); + print_internal (make_fixnum (data->level), printcharfun, 0); write_ascstring (printcharfun, ")"); } ＠＠ -4308,8 +4308,8 ＠＠ data->level = -1; else { - check_integer_range (value, Qzero, make_int (9)); - data->level = XINT (value); + check_integer_range (value, Qzero, make_fixnum (9)); + data->level = XFIXNUM (value); } } else ＠＠ -4327,7 +4327,7 ＠＠ { if (data->level == -1) return Qdefault; - return make_int (data->level); + return make_fixnum (data->level); } return Qunbound; diff -r a0e81357194e -r 56144c8593a8 src/fileio.c --- a/src/fileio.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/fileio.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -173,13 +173,13 ＠＠ { if (CONSP (fd)) { - if (INTP (XCAR (fd))) - retry_close (XINT (XCAR (fd))); + if (FIXNUMP (XCAR (fd))) + retry_close (XFIXNUM (XCAR (fd))); free_cons (fd); } else - retry_close (XINT (fd)); + retry_close (XFIXNUM (fd)); return Qnil; } ＠＠ -1851,9 +1851,9 ＠＠ } if (NILP (ok_if_already_exists) - || INTP (ok_if_already_exists)) + || FIXNUMP (ok_if_already_exists)) barf_or_query_if_file_exists (newname, "copy to it", - INTP (ok_if_already_exists), &out_st); + FIXNUMP (ok_if_already_exists), &out_st); else if (qxe_stat (XSTRING_DATA (newname), &out_st) < 0) out_st.st_mode = 0; ＠＠ -1862,7 +1862,7 ＠＠ if (ifd < 0) report_file_error ("Opening input file", filename); - record_unwind_protect (close_file_unwind, make_int (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. */ ＠＠ -1903,7 +1903,7 ＠＠ report_file_error ("Opening output file", newname); { - Lisp_Object ofd_locative = noseeum_cons (make_int (ofd), Qnil); + Lisp_Object ofd_locative = noseeum_cons (make_fixnum (ofd), Qnil); record_unwind_protect (close_file_unwind, ofd_locative); ＠＠ -2091,9 +2091,9 ＠＠ } if (NILP (ok_if_already_exists) - || INTP (ok_if_already_exists)) + || FIXNUMP (ok_if_already_exists)) barf_or_query_if_file_exists (newname, "rename to it", - INTP (ok_if_already_exists), 0); + FIXNUMP (ok_if_already_exists), 0); /* We have configure check for rename() and emulate using link()/unlink() if necessary. */ ＠＠ -2152,9 +2152,9 ＠＠ newname, ok_if_already_exists)); if (NILP (ok_if_already_exists) - || INTP (ok_if_already_exists)) + || FIXNUMP (ok_if_already_exists)) barf_or_query_if_file_exists (newname, "make it a new name", - INTP (ok_if_already_exists), 0); + FIXNUMP (ok_if_already_exists), 0); /* #### Emacs 20.6 contains an implementation of link() in w32.c. Need to port. */ #ifndef HAVE_LINK ＠＠ -2217,9 +2217,9 ＠＠ #ifdef HAVE_SYMLINK if (NILP (ok_if_already_exists) - || INTP (ok_if_already_exists)) + || FIXNUMP (ok_if_already_exists)) barf_or_query_if_file_exists (linkname, "make it a link", - INTP (ok_if_already_exists), 0); + FIXNUMP (ok_if_already_exists), 0); qxe_unlink (XSTRING_DATA (linkname)); if (0 > qxe_symlink (XSTRING_DATA (filename), ＠＠ -2746,7 +2746,7 ＠＠ #endif /* WIN32_NATIVE */ #endif /* 0 */ - return make_int (st.st_mode & 07777); + return make_fixnum (st.st_mode & 07777); } DEFUN ("set-file-modes", Fset_file_modes, 2, 2, 0, /* ＠＠ -2764,7 +2764,7 ＠＠ abspath = Fexpand_file_name (filename, current_buffer->directory); UNGCPRO; - CHECK_INT (mode); + CHECK_FIXNUM (mode); /* If the file name has special constructs in it, call the corresponding file handler. */ ＠＠ -2774,7 +2774,7 ＠＠ if (!NILP (handler)) return call3 (handler, Qset_file_modes, abspath, mode); - if (qxe_chmod (XSTRING_DATA (abspath), XINT (mode)) < 0) + if (qxe_chmod (XSTRING_DATA (abspath), XFIXNUM (mode)) < 0) report_file_error ("Doing chmod", abspath); return Qnil; ＠＠ -2789,9 +2789,9 ＠＠ */ (mode)) { - CHECK_INT (mode); - - umask ((~ XINT (mode)) & 0777); + CHECK_FIXNUM (mode); + + umask ((~ XFIXNUM (mode)) & 0777); return Qnil; } ＠＠ -2809,7 +2809,7 ＠＠ mode = umask (0); umask (mode); - return make_int ((~ mode) & 0777); + return make_fixnum ((~ mode) & 0777); }  DEFUN ("unix-sync", Funix_sync, 0, 0, "", /* ＠＠ -2973,12 +2973,12 ＠＠ #endif /* S_IFREG */ if (!NILP (start)) - CHECK_INT (start); + CHECK_FIXNUM (start); else start = Qzero; if (!NILP (end)) - CHECK_INT (end); + CHECK_FIXNUM (end); if (fd < 0) { ＠＠ -2991,7 +2991,7 ＠＠ if (!NILP (replace)) record_unwind_protect (restore_point_unwind, Fpoint_marker (Qnil, Qnil)); - record_unwind_protect (close_file_unwind, make_int (fd)); + record_unwind_protect (close_file_unwind, make_fixnum (fd)); /* Supposedly happens on VMS. */ if (st.st_size < 0) ＠＠ -3001,8 +3001,8 ＠＠ { if (!not_regular) { - end = make_int (st.st_size); - if (XINT (end) != st.st_size) + end = make_fixnum (st.st_size); + if (XFIXNUM (end) != st.st_size) out_of_memory ("Maximum buffer size exceeded", Qunbound); } } ＠＠ -3142,8 +3142,8 ＠＠ same_at_end += overlap; /* Arrange to read only the nonmatching middle part of the file. */ - start = make_int (same_at_start - BUF_BEGV (buf)); - end = make_int (st.st_size - (BUF_ZV (buf) - same_at_end)); + start = make_fixnum (same_at_start - BUF_BEGV (buf)); + end = make_fixnum (st.st_size - (BUF_ZV (buf) - same_at_end)); buffer_delete_range (buf, same_at_start, same_at_end, !NILP (visit) ? INSDEL_NO_LOCKING : 0); ＠＠ -3154,10 +3154,10 ＠＠ if (!not_regular) { - total = XINT (end) - XINT (start); + total = XFIXNUM (end) - XFIXNUM (start); /* Make sure point-max won't overflow after this insertion. */ - if (total != XINT (make_int (total))) + if (total != XFIXNUM (make_fixnum (total))) out_of_memory ("Maximum buffer size exceeded", Qunbound); } else ＠＠ -3165,13 +3165,13 ＠＠ will make the stream functions read as much as possible. */ total = -1; - if (XINT (start) != 0 + if (XFIXNUM (start) != 0 /* why was this here? asked jwz. The reason is that the replace-mode connivings above will normally put the file pointer other than where it should be. */ || (!NILP (replace) && do_speedy_insert)) { - if (lseek (fd, XINT (start), 0) < 0) + if (lseek (fd, XFIXNUM (start), 0) < 0) report_file_error ("Setting file position", filename); } ＠＠ -3257,7 +3257,7 ＠＠ call1 (Qcompute_buffer_file_truename, wrap_buffer (buf)); BUF_SAVE_MODIFF (buf) = BUF_MODIFF (buf); buf->auto_save_modified = BUF_MODIFF (buf); - buf->saved_size = make_int (BUF_SIZE (buf)); + buf->saved_size = make_fixnum (BUF_SIZE (buf)); #ifdef CLASH_DETECTION if (!NILP (buf->file_truename)) unlock_file (buf->file_truename); ＠＠ -3277,21 +3277,21 ＠＠ /* Decode file format */ if (inserted > 0 && !UNBOUNDP (XSYMBOL_FUNCTION (Qformat_decode))) { - Lisp_Object insval = call3 (Qformat_decode, Qnil, make_int (inserted), + Lisp_Object insval = call3 (Qformat_decode, Qnil, make_fixnum (inserted), visit); - CHECK_INT (insval); - inserted = XINT (insval); + CHECK_FIXNUM (insval); + inserted = XFIXNUM (insval); } if (inserted > 0) { GC_EXTERNAL_LIST_LOOP_2 (p, Vafter_insert_file_functions) { - Lisp_Object insval = call1 (p, make_int (inserted)); + Lisp_Object insval = call1 (p, make_fixnum (inserted)); if (!NILP (insval)) { - check_integer_range (insval, Qzero, make_int (EMACS_INT_MAX)); - inserted = XINT (insval); + check_integer_range (insval, Qzero, make_fixnum (MOST_POSITIVE_FIXNUM)); + inserted = XFIXNUM (insval); } } END_GC_EXTERNAL_LIST_LOOP (p); ＠＠ -3302,7 +3302,7 ＠＠ if (!NILP (val)) return (val); else - return (list2 (filename, make_int (inserted))); + return (list2 (filename, make_fixnum (inserted))); }  ＠＠ -3423,7 +3423,7 ＠＠ if (visiting) { BUF_SAVE_MODIFF (current_buffer) = BUF_MODIFF (current_buffer); - current_buffer->saved_size = make_int (BUF_SIZE (current_buffer)); + current_buffer->saved_size = make_fixnum (BUF_SIZE (current_buffer)); current_buffer->filename = visit_file; MARK_MODELINE_CHANGED; } ＠＠ -3481,7 +3481,7 ＠＠ } { - Lisp_Object desc_locative = Fcons (make_int (desc), Qnil); + Lisp_Object desc_locative = Fcons (make_fixnum (desc), Qnil); Lisp_Object instream = Qnil, outstream = Qnil; struct gcpro nngcpro1, nngcpro2; NNGCPRO2 (instream, outstream); ＠＠ -3600,7 +3600,7 ＠＠ if (visiting) { BUF_SAVE_MODIFF (current_buffer) = BUF_MODIFF (current_buffer); - current_buffer->saved_size = make_int (BUF_SIZE (current_buffer)); + current_buffer->saved_size = make_fixnum (BUF_SIZE (current_buffer)); current_buffer->filename = visit_file; MARK_MODELINE_CHANGED; } ＠＠ -3668,8 +3668,8 ＠＠ been dealt with by this function. */ if (current_buffer != given_buffer) { - start = make_int (BUF_BEGV (current_buffer)); - end = make_int (BUF_ZV (current_buffer)); + start = make_fixnum (BUF_BEGV (current_buffer)); + end = make_fixnum (BUF_ZV (current_buffer)); annotations = Qnil; } Flength (res); /* Check basic validity of return value */ ＠＠ -3700,8 +3700,8 ＠＠ original_buffer); if (current_buffer != given_buffer) { - start = make_int (BUF_BEGV (current_buffer)); - end = make_int (BUF_ZV (current_buffer)); + start = make_fixnum (BUF_BEGV (current_buffer)); + end = make_fixnum (BUF_ZV (current_buffer)); annotations = Qnil; } Flength (res); ＠＠ -3742,8 +3742,8 ＠＠ while (LISTP (*annot)) { tem = Fcar_safe (Fcar (*annot)); - if (INTP (tem)) - nextpos = XINT (tem); + if (FIXNUMP (tem)) + nextpos = XFIXNUM (tem); else nextpos = INT_MAX; #ifdef MULE ＠＠ -3985,11 +3985,11 ＠＠ clear_echo_area (selected_frame (), Qauto_saving, 1); Fding (Qt, Qauto_save_error, Qnil); message ("Auto-saving...error for %s", XSTRING_DATA (current_buffer->name)); - Fsleep_for (make_int (1)); + Fsleep_for (make_fixnum (1)); message ("Auto-saving...error!for %s", XSTRING_DATA (current_buffer->name)); - Fsleep_for (make_int (1)); + Fsleep_for (make_fixnum (1)); message ("Auto-saving...error for %s", XSTRING_DATA (current_buffer->name)); - Fsleep_for (make_int (1)); + Fsleep_for (make_fixnum (1)); return Qnil; } ＠＠ -4055,7 +4055,7 ＠＠ static Lisp_Object do_auto_save_unwind (Lisp_Object fd) { - retry_close (XINT (fd)); + retry_close (XFIXNUM (fd)); return (fd); } ＠＠ -4147,7 +4147,7 ＠＠ && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b) && b->auto_save_modified < BUF_MODIFF (b) /* -1 means we've turned off autosaving for a while--see below. */ - && XINT (b->saved_size) >= 0 + && XFIXNUM (b->saved_size) >= 0 && (do_handled_files || NILP (Ffind_file_name_handler (b->auto_save_file_name, Qwrite_region)))) ＠＠ -4163,11 +4163,11 ＠＠ continue; if (!preparing_for_armageddon && - (XINT (b->saved_size) * 10 + (XFIXNUM (b->saved_size) * 10 /* A short file is likely to change a large fraction; spare the user annoying messages. */ - && XINT (b->saved_size) > 5000 + && XFIXNUM (b->saved_size) > 5000 /* These messages are frequent and annoying for `*mail*'. */ && !NILP (b->filename) && NILP (no_message) ＠＠ -4182,9 +4182,9 ＠＠ XSTRING_DATA (b->name)); /* Turn off auto-saving until there's a real save, and prevent any more warnings. */ - b->saved_size = make_int (-1); + b->saved_size = make_fixnum (-1); if (!gc_in_progress) - Fsleep_for (make_int (1)); + Fsleep_for (make_fixnum (1)); continue; } set_buffer_internal (b); ＠＠ -4212,7 +4212,7 ＠＠ an error. */ if (listdesc >= 0) record_unwind_protect (do_auto_save_unwind, - make_int (listdesc)); + make_fixnum (listdesc)); } /* Record all the buffers that we are auto-saving in ＠＠ -4274,7 +4274,7 ＠＠ continue; b->auto_save_modified = BUF_MODIFF (b); - b->saved_size = make_int (BUF_SIZE (b)); + b->saved_size = make_fixnum (BUF_SIZE (b)); EMACS_GET_TIME (after_time); /* If auto-save took more than 60 seconds, assume it was an NFS failure that got a timeout. */ ＠＠ -4316,7 +4316,7 ＠＠ ()) { current_buffer->auto_save_modified = BUF_MODIFF (current_buffer); - current_buffer->saved_size = make_int (BUF_SIZE (current_buffer)); + current_buffer->saved_size = make_fixnum (BUF_SIZE (current_buffer)); current_buffer->auto_save_failure_time = -1; return Qnil; } diff -r a0e81357194e -r 56144c8593a8 src/floatfns.c --- a/src/floatfns.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/floatfns.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -132,14 +132,14 ＠＠ #else REGISTER EMACS_INT result = (EMACS_INT) x; - if (result > EMACS_INT_MAX || result < EMACS_INT_MIN) + if (result > MOST_POSITIVE_FIXNUM || result < MOST_NEGATIVE_FIXNUM) { if (!UNBOUNDP (num2)) range_error2 (name, num, num2); else range_error (name, num); } - return make_int (result); + return make_fixnum (result); #endif /* HAVE_BIGNUM */ } ＠＠ -203,8 +203,8 ＠＠ if (FLOATP (num)) return XFLOAT_DATA (num); - if (INTP (num)) - return (double) XINT (num); + if (FIXNUMP (num)) + return (double) XFIXNUM (num); #ifdef HAVE_BIGNUM if (BIGNUMP (num)) ＠＠ -444,26 +444,26 ＠＠ (number1, number2)) { #ifdef HAVE_BIGNUM - if (INTEGERP (number1) && INTP (number2)) + if (INTEGERP (number1) && FIXNUMP (number2)) { - if (INTP (number1)) + if (FIXNUMP (number1)) { - bignum_set_long (scratch_bignum2, XREALINT (number1)); - bignum_pow (scratch_bignum, scratch_bignum2, XREALINT (number2)); + bignum_set_long (scratch_bignum2, XREALFIXNUM (number1)); + bignum_pow (scratch_bignum, scratch_bignum2, XREALFIXNUM (number2)); } else bignum_pow (scratch_bignum, XBIGNUM_DATA (number1), - XREALINT (number2)); + XREALFIXNUM (number2)); return Fcanonicalize_number (make_bignum_bg (scratch_bignum)); } #endif - if (INTP (number1) && /* common lisp spec */ - INTP (number2)) /* don't promote, if both are ints */ + if (FIXNUMP (number1) && /* common lisp spec */ + FIXNUMP (number2)) /* don't promote, if both are ints */ { EMACS_INT retval; - EMACS_INT x = XINT (number1); - EMACS_INT y = XINT (number2); + EMACS_INT x = XFIXNUM (number1); + EMACS_INT y = XFIXNUM (number2); if (y < 0) { ＠＠ -485,7 +485,7 ＠＠ y = (EMACS_UINT) y >> 1; } } - return make_int (retval); + return make_fixnum (retval); } #if defined(HAVE_BIGFLOAT) && defined(bigfloat_pow) ＠＠ -711,12 +711,12 ＠＠ return number; } - if (INTP (number)) + if (FIXNUMP (number)) #ifdef HAVE_BIGNUM /* The most negative Lisp fixnum will overflow */ - return (XINT (number) >= 0) ? number : make_integer (- XINT (number)); + return (XFIXNUM (number) >= 0) ? number : make_integer (- XFIXNUM (number)); #else - return (XINT (number) >= 0) ? number : make_int (- XINT (number)); + return (XFIXNUM (number) >= 0) ? number : make_fixnum (- XFIXNUM (number)); #endif #ifdef HAVE_BIGNUM ＠＠ -758,8 +758,8 ＠＠ */ (number)) { - if (INTP (number)) - return make_float ((double) XINT (number)); + if (FIXNUMP (number)) + return make_float ((double) XFIXNUM (number)); #ifdef HAVE_BIGNUM if (BIGNUMP (number)) ＠＠ -804,11 +804,11 ＠＠ double f = extract_float (number); if (f == 0.0) - return make_int (EMACS_INT_MIN); + return make_fixnum (MOST_NEGATIVE_FIXNUM); #ifdef HAVE_LOGB { Lisp_Object val; - IN_FLOAT (val = make_int ((EMACS_INT) logb (f)), "logb", number); + IN_FLOAT (val = make_fixnum ((EMACS_INT) logb (f)), "logb", number); return val; } #else ＠＠ -816,7 +816,7 ＠＠ { int exqp; IN_FLOAT (frexp (f, &exqp), "logb", number); - return make_int (exqp - 1); + return make_fixnum (exqp - 1); } #else { ＠＠ -840,7 +840,7 ＠＠ f /= d; val += i; } - return make_int (val); + return make_fixnum (val); } #endif /* ! HAVE_FREXP */ #endif /* ! HAVE_LOGB */ ＠＠ -895,24 +895,24 ＠＠ does these conversions, we do them too for symmetry: */\ if (CHARP (number)) \ { \ - number = make_int (XCHAR (number)); \ + number = make_fixnum (XCHAR (number)); \ } \ else if (MARKERP (number)) \ { \ - number = make_int (marker_position (number)); \ + number = make_fixnum (marker_position (number)); \ } \ \ if (CHARP (divisor)) \ { \ - divisor = make_int (XCHAR (divisor)); \ + divisor = make_fixnum (XCHAR (divisor)); \ } \ else if (MARKERP (divisor)) \ { \ - divisor = make_int (marker_position (divisor)); \ + divisor = make_fixnum (marker_position (divisor)); \ } \ \ - CHECK_INT_OR_FLOAT (divisor); \ - if (INTP (number) && INTP (divisor)) \ + CHECK_FIXNUM_OR_FLOAT (divisor); \ + if (FIXNUMP (number) && FIXNUMP (divisor)) \ { \ return conversion##_two_fixnum (number, divisor, \ return_float); \ ＠＠ -988,13 +988,13 ＠＠ #define MAYBE_CHAR_OR_MARKER(conversion) do { \ if (CHARP (number)) \ { \ - return conversion##_one_mundane_arg (make_int (XCHAR (number)), \ + return conversion##_one_mundane_arg (make_fixnum (XCHAR (number)), \ divisor, return_float); \ } \ \ if (MARKERP (number)) \ { \ - return conversion##_one_mundane_arg (make_int \ + return conversion##_one_mundane_arg (make_fixnum \ (marker_position(number)), \ divisor, return_float); \ } \ ＠＠ -1007,8 +1007,8 ＠＠ ceiling_two_fixnum (Lisp_Object number, Lisp_Object divisor, int return_float) { - EMACS_INT i1 = XREALINT (number); - EMACS_INT i2 = XREALINT (divisor); + EMACS_INT i1 = XREALFIXNUM (number); + EMACS_INT i2 = XREALFIXNUM (divisor); EMACS_INT i3 = 0, i4 = 0; if (i2 == 0) ＠＠ -1062,11 +1062,11 ＠＠ if (!return_float) { - return values2 (make_int (i3), make_int (i4)); + return values2 (make_fixnum (i3), make_fixnum (i4)); } return values2 (make_float ((double)i3), - make_int (i4)); + make_fixnum (i4)); } #ifdef HAVE_BIGNUM ＠＠ -1160,7 +1160,7 ＠＠ bignum_set_bigfloat (scratch_bignum, scratch_bigfloat); res0 = Fcanonicalize_number (make_bignum_bg (scratch_bignum)); #else - res0 = make_int ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); + res0 = make_fixnum ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); #endif /* HAVE_BIGNUM */ } ＠＠ -1220,7 +1220,7 ＠＠ bignum_set_bigfloat (scratch_bignum, scratch_bigfloat); res0 = Fcanonicalize_number (make_bignum_bg (scratch_bignum)); #else - res0 = make_int ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); + res0 = make_fixnum ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); #endif /* HAVE_BIGNUM */ } ＠＠ -1288,9 +1288,9 ＠＠ if (return_float) { - if (INTP (number)) + if (FIXNUMP (number)) { - return values2 (make_float ((double) XINT (number)), Qzero); + return values2 (make_float ((double) XFIXNUM (number)), Qzero); } #ifdef HAVE_BIGNUM else if (BIGNUMP (number)) ＠＠ -1318,8 +1318,8 ＠＠ floor_two_fixnum (Lisp_Object number, Lisp_Object divisor, int return_float) { - EMACS_INT i1 = XREALINT (number); - EMACS_INT i2 = XREALINT (divisor); + EMACS_INT i1 = XREALFIXNUM (number); + EMACS_INT i2 = XREALFIXNUM (divisor); EMACS_INT i3 = 0, i4 = 0; Lisp_Object res0; ＠＠ -1342,10 +1342,10 ＠＠ } else { - res0 = make_int (i3); + res0 = make_fixnum (i3); } - return values2 (res0, make_int (i4)); + return values2 (res0, make_fixnum (i4)); } #ifdef HAVE_BIGNUM ＠＠ -1446,7 +1446,7 ＠＠ bignum_set_bigfloat (scratch_bignum, scratch_bigfloat); res0 = Fcanonicalize_number (make_bignum_bg (scratch_bignum)); #else - res0 = make_int ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); + res0 = make_fixnum ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); #endif /* HAVE_BIGNUM */ } ＠＠ -1507,7 +1507,7 ＠＠ bignum_set_bigfloat (scratch_bignum, scratch_bigfloat); res0 = Fcanonicalize_number (make_bignum_bg (scratch_bignum)); #else - res0 = make_int ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); + res0 = make_fixnum ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); #endif /* HAVE_BIGNUM */ } ＠＠ -1594,8 +1594,8 ＠＠ static Lisp_Object round_two_fixnum (Lisp_Object number, Lisp_Object divisor, int return_float) { - EMACS_INT i1 = XREALINT (number); - EMACS_INT i2 = XREALINT (divisor); + EMACS_INT i1 = XREALFIXNUM (number); + EMACS_INT i2 = XREALFIXNUM (divisor); EMACS_INT i0, hi2, flooring, floored, flsecond; if (i2 == 0) ＠＠ -1617,13 +1617,13 ＠＠ { i0 = floored - 1; return values2 (return_float ? make_float ((double)i0) : - make_int (i0), make_int (hi2)); + make_fixnum (i0), make_fixnum (hi2)); } else { return values2 (return_float ? make_float ((double)floored) : - make_int (floored), - make_int (flsecond - hi2)); + make_fixnum (floored), + make_fixnum (flsecond - hi2)); } } ＠＠ -1852,7 +1852,7 ＠＠ bignum_set_bigfloat (scratch_bignum, XBIGFLOAT_DATA (res0)); res0 = Fcanonicalize_number (make_bignum_bg (scratch_bignum)); #else - res0 = make_int ((EMACS_INT) bigfloat_to_long (XBIGFLOAT_DATA (res0))); + res0 = make_fixnum ((EMACS_INT) bigfloat_to_long (XBIGFLOAT_DATA (res0))); #endif /* HAVE_BIGNUM */ } ＠＠ -1904,7 +1904,7 ＠＠ bignum_set_bigfloat (scratch_bignum, XBIGFLOAT_DATA (res0)); res0 = Fcanonicalize_number (make_bignum_bg (scratch_bignum)); #else - res0 = make_int ((EMACS_INT) bigfloat_to_long + res0 = make_fixnum ((EMACS_INT) bigfloat_to_long (XBIGFLOAT_DATA (res0))); #endif /* HAVE_BIGNUM */ } ＠＠ -1994,8 +1994,8 ＠＠ truncate_two_fixnum (Lisp_Object number, Lisp_Object divisor, int return_float) { - EMACS_INT i1 = XREALINT (number); - EMACS_INT i2 = XREALINT (divisor); + EMACS_INT i1 = XREALFIXNUM (number); + EMACS_INT i2 = XREALFIXNUM (divisor); EMACS_INT i0; if (i2 == 0) ＠＠ -2010,11 +2010,11 ＠＠ if (return_float) { - return values2 (make_float ((double)i0), make_int (i1 - (i0 * i2))); + return values2 (make_float ((double)i0), make_fixnum (i1 - (i0 * i2))); } else { - return values2 (make_int (i0), make_int (i1 - (i0 * i2))); + return values2 (make_fixnum (i0), make_fixnum (i1 - (i0 * i2))); } } ＠＠ -2121,7 +2121,7 ＠＠ bignum_set_bigfloat (scratch_bignum, scratch_bigfloat); res0 = Fcanonicalize_number (make_bignum_bg (scratch_bignum)); #else - res0 = make_int ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); + res0 = make_fixnum ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); #endif /* HAVE_BIGNUM */ } ＠＠ -2187,7 +2187,7 ＠＠ bignum_set_bigfloat (scratch_bignum, scratch_bigfloat); res0 = Fcanonicalize_number (make_bignum_bg (scratch_bignum)); #else - res0 = make_int ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); + res0 = make_fixnum ((EMACS_INT) bigfloat_to_long (scratch_bigfloat)); #endif /* HAVE_BIGNUM */ } ＠＠ -2232,14 +2232,14 ＠＠ number, Qunbound); if (return_float) { - res0 = make_float ((double)XINT(res0)); + res0 = make_float ((double)XFIXNUM(res0)); return values2 (res0, make_float ((XFLOAT_DATA (number) - XFLOAT_DATA (res0)))); } else { return values2 (res0, make_float (XFLOAT_DATA (number) - - XREALINT (res0))); + - XREALFIXNUM (res0))); } } diff -r a0e81357194e -r 56144c8593a8 src/fns.c --- a/src/fns.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/fns.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -106,8 +106,8 ＠＠ Elemcount len = bit_vector_length (v); Elemcount last = len; - if (INTP (Vprint_length)) - last = min (len, XINT (Vprint_length)); + if (FIXNUMP (Vprint_length)) + last = min (len, XFIXNUM (Vprint_length)); write_ascstring (printcharfun, "#*"); for (i = 0; i < last; i++) { ＠＠ -621,7 +621,7 ＠＠ { force_eq_check: FROB (eq, 0); - else FROB (equal, (SYMBOLP (item) || INTP (item) || CHARP (item))); + else FROB (equal, (SYMBOLP (item) || FIXNUMP (item) || CHARP (item))); else FROB (equalp, (SYMBOLP (item))); else if (EQ (test, XSYMBOL_FUNCTION (Qstring_match))) { ＠＠ -824,15 +824,15 ＠＠ it's possible to get a quotient larger than limit; discarding these values eliminates the bias that would otherwise appear when using a large limit. */ - denominator = ((unsigned long)1 << INT_VALBITS) / XINT (limit); + denominator = ((unsigned long)1 << FIXNUM_VALBITS) / XFIXNUM (limit); do val = get_random () / denominator; - while (val >= XINT (limit)); + while (val >= XFIXNUM (limit)); } else val = get_random (); - return make_int (val); + return make_fixnum (val); }  /* Random data-structure functions */ ＠＠ -854,19 +854,19 ＠＠ { retry: if (STRINGP (sequence)) - return make_int (string_char_length (sequence)); + return make_fixnum (string_char_length (sequence)); else if (CONSP (sequence)) { Elemcount len; GET_EXTERNAL_LIST_LENGTH (sequence, len); - return make_int (len); + return make_fixnum (len); } else if (VECTORP (sequence)) - return make_int (XVECTOR_LENGTH (sequence)); + return make_fixnum (XVECTOR_LENGTH (sequence)); else if (NILP (sequence)) return Qzero; else if (BIT_VECTORP (sequence)) - return make_int (bit_vector_length (XBIT_VECTOR (sequence))); + return make_fixnum (bit_vector_length (XBIT_VECTOR (sequence))); else { check_losing_bytecode ("length", sequence); ＠＠ -894,7 +894,7 ＠＠ tortoise = XCDR (tortoise); } - return make_int (len); + return make_fixnum (len); } /* This is almost the above, but is defined by Common Lisp. We need it in C ＠＠ -923,7 +923,7 ＠＠ signal_malformed_list_error (list); } - return EQ (hare, tortoise) && len != 0 ? Qnil : make_int (len); + return EQ (hare, tortoise) && len != 0 ? Qnil : make_fixnum (len); }  static Lisp_Object string_count_from_end (Lisp_Object, Lisp_Object , ＠＠ -945,8 +945,8 ＠＠ Lisp_Object caller) { Lisp_Object item = args[0], sequence = args[1]; - Elemcount starting = 0, ending = EMACS_INT_MAX, encountered = 0; - Elemcount len, ii = 0, counting = EMACS_INT_MAX; + Elemcount starting = 0, ending = MOST_POSITIVE_FIXNUM, encountered = 0; + Elemcount len, ii = 0, counting = MOST_POSITIVE_FIXNUM; Boolint test_not_unboundp = 1; check_test_func_t check_test = NULL; ＠＠ -956,18 +956,18 ＠＠ CHECK_SEQUENCE (sequence); CHECK_NATNUM (start); - starting = BIGNUMP (start) ? 1 + EMACS_INT_MAX : XINT (start); + starting = BIGNUMP (start) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (start); if (!NILP (end)) { CHECK_NATNUM (end); - ending = BIGNUMP (end) ? 1 + EMACS_INT_MAX : XINT (end); + ending = BIGNUMP (end) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (end); } if (!NILP (count)) { CHECK_INTEGER (count); - counting = BIGNUMP (count) ? EMACS_INT_MAX + 1 : XINT (count); + counting = BIGNUMP (count) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (count); /* Our callers should have filtered out non-positive COUNT. */ assert (counting >= 0); ＠＠ -1004,7 +1004,7 ＠＠ it). */ if (!NILP (count) && !NILP (from_end)) { - counting = EMACS_INT_MAX; + counting = MOST_POSITIVE_FIXNUM; } { ＠＠ -1089,8 +1089,8 ＠＠ { Lisp_Object object = Qnil; - len = XINT (Flength (sequence)); - check_sequence_range (sequence, start, end, make_int (len)); + len = XFIXNUM (Flength (sequence)); + check_sequence_range (sequence, start, end, make_fixnum (len)); ending = min (ending, len); if (0 == len) ＠＠ -1103,7 +1103,7 ＠＠ { for (ii = starting; ii < ending && encountered < counting; ii++) { - object = Faref (sequence, make_int (ii)); + object = Faref (sequence, make_fixnum (ii)); if (check_test (test, key, item, object) == test_not_unboundp) { encountered++; ＠＠ -1114,7 +1114,7 ＠＠ { for (ii = ending - 1; ii >= starting && encountered < counting; ii--) { - object = Faref (sequence, make_int (ii)); + object = Faref (sequence, make_fixnum (ii)); if (check_test (test, key, item, object) == test_not_unboundp) { encountered++; ＠＠ -1132,8 +1132,8 ＠＠ Lisp_Object test, Lisp_Object key, Lisp_Object start, Lisp_Object end) { - Elemcount length = XINT (Flength (sequence)), ii = 0, starting = XINT (start); - Elemcount ending = NILP (end) ? length : XINT (end), encountered = 0; + Elemcount length = XFIXNUM (Flength (sequence)), ii = 0, starting = XFIXNUM (start); + Elemcount ending = NILP (end) ? length : XFIXNUM (end), encountered = 0; Lisp_Object *storage; struct gcpro gcpro1; ＠＠ -1176,7 +1176,7 ＠＠ Lisp_Object start, Lisp_Object end) { Elemcount length = string_char_length (sequence), ii = 0; - Elemcount starting = XINT (start), ending = NILP (end) ? length : XINT (end); + Elemcount starting = XFIXNUM (start), ending = NILP (end) ? length : XFIXNUM (end); Elemcount encountered = 0; Ibyte *cursor = XSTRING_DATA (sequence); Ibyte *endp = cursor + XSTRING_LENGTH (sequence); ＠＠ -1308,9 +1308,9 ＠＠ if (!res) return Qt; else if (res > 0) - return make_int (1 + matching); + return make_fixnum (1 + matching); else - return make_int (-1 - matching); + return make_fixnum (-1 - matching); } DEFUN ("string-lessp", Fstring_lessp, 2, 2, 0, /* ＠＠ -1385,7 +1385,7 ＠＠ (string)) { CHECK_STRING (string); - if (CONSP (XSTRING_PLIST (string)) && INTP (XCAR (XSTRING_PLIST (string)))) + if (CONSP (XSTRING_PLIST (string)) && FIXNUMP (XCAR (XSTRING_PLIST (string)))) return XCAR (XSTRING_PLIST (string)); else return Qzero; ＠＠ -1403,10 +1403,10 ＠＠ /* skip over extent info if it's there */ if (CONSP (*ptr) && EXTENT_INFOP (XCAR (*ptr))) ptr = &XCDR (*ptr); - if (CONSP (*ptr) && INTP (XCAR (*ptr))) - XCAR (*ptr) = make_int (1+XINT (XCAR (*ptr))); + if (CONSP (*ptr) && FIXNUMP (XCAR (*ptr))) + XCAR (*ptr) = make_fixnum (1+XFIXNUM (XCAR (*ptr))); else - *ptr = Fcons (make_int (1), *ptr); + *ptr = Fcons (make_fixnum (1), *ptr); }  ＠＠ -1630,7 +1630,7 ＠＠ else if (VECTORP (seq) || STRINGP (seq) || BIT_VECTORP (seq)) ; #if 0 /* removed for XEmacs 21 */ - else if (INTP (seq)) + else if (FIXNUMP (seq)) /* This is too revolting to think about but maintains compatibility with FSF (and lots and lots of old code). */ args[argnum] = Fnumber_to_string (seq); ＠＠ -1658,7 +1658,7 ＠＠ for (argnum = 0, total_length = 0; argnum < nargs; argnum++) { - Charcount thislen = XINT (Flength (args[argnum])); + Charcount thislen = XFIXNUM (Flength (args[argnum])); total_length += thislen; } ＠＠ -1671,7 +1671,7 ＠＠ /* In append, if all but last arg are nil, return last arg */ RETURN_UNGCPRO (last_tail); } - val = Fmake_list (make_int (total_length), Qnil); + val = Fmake_list (make_fixnum (total_length), Qnil); break; case c_vector: val = make_vector (total_length, Qnil); ＠＠ -1719,7 +1719,7 ＠＠ if (!CONSP (seq)) { - thisleni = XINT (Flength (seq)); + thisleni = XFIXNUM (Flength (seq)); } if (STRINGP (seq)) string_source_ptr = XSTRING_DATA (seq); ＠＠ -1751,10 +1751,10 ＠＠ else if (VECTORP (seq)) elt = XVECTOR_DATA (seq)[thisindex]; else if (BIT_VECTORP (seq)) - elt = make_int (bit_vector_bit (XBIT_VECTOR (seq), + elt = make_fixnum (bit_vector_bit (XBIT_VECTOR (seq), thisindex)); else - elt = Felt (seq, make_int (thisindex)); + elt = Felt (seq, make_fixnum (thisindex)); thisindex++; } ＠＠ -1771,7 +1771,7 ＠＠ else if (BIT_VECTORP (val)) { CHECK_BIT (elt); - set_bit_vector_bit (XBIT_VECTOR (val), toindex++, XINT (elt)); + set_bit_vector_bit (XBIT_VECTOR (val), toindex++, XFIXNUM (elt)); } else { ＠＠ -1900,17 +1900,17 ＠＠ */ (sequence, start, end)) { - Elemcount len, ss, ee = EMACS_INT_MAX, ii; + Elemcount len, ss, ee = MOST_POSITIVE_FIXNUM, ii; Lisp_Object result = Qnil; CHECK_SEQUENCE (sequence); - CHECK_INT (start); - ss = XINT (start); + CHECK_FIXNUM (start); + ss = XFIXNUM (start); if (!NILP (end)) { - CHECK_INT (end); - ee = XINT (end); + CHECK_FIXNUM (end); + ee = XFIXNUM (end); } if (STRINGP (sequence)) ＠＠ -1932,7 +1932,7 ＠＠ if (ss < 0 || ee < 0) { - len = XINT (Flength (sequence)); + len = XFIXNUM (Flength (sequence)); if (ss < 0) { ss = len + ss; ＠＠ -1952,7 +1952,7 ＠＠ if (0 != ss) { - sequence = Fnthcdr (make_int (ss), sequence); + sequence = Fnthcdr (make_fixnum (ss), sequence); } ii = ss + 1; ＠＠ -1989,7 +1989,7 ＠＠ } else { - len = XINT (Flength (sequence)); + len = XFIXNUM (Flength (sequence)); if (ss < 0) { ss = len + ss; ＠＠ -2006,7 +2006,7 ＠＠ ee = min (len, ee); } - check_sequence_range (sequence, start, end, make_int (len)); + check_sequence_range (sequence, start, end, make_fixnum (len)); if (VECTORP (sequence)) { ＠＠ -2260,7 +2260,7 ＠＠ REGISTER EMACS_INT i; REGISTER Lisp_Object tail = list; CHECK_NATNUM (n); - for (i = BIGNUMP (n) ? 1 + EMACS_INT_MAX : XINT (n); i; i--) + for (i = BIGNUMP (n) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (n); i; i--) { if (CONSP (tail)) tail = XCDR (tail); ＠＠ -2292,7 +2292,7 ＠＠ { /* This function can GC */ retry: - CHECK_INT_COERCE_CHAR (n); /* yuck! */ + CHECK_FIXNUM_COERCE_CHAR (n); /* yuck! */ if (LISTP (sequence)) { Lisp_Object tem = Fnthcdr (n, sequence); ＠＠ -2342,7 +2342,7 ＠＠ else { CHECK_NATNUM (n); - int_n = BIGNUMP (n) ? 1 + EMACS_INT_MAX : XINT (n); + int_n = BIGNUMP (n) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (n); } for (retval = tortoise = hare = list, count = 0; ＠＠ -2377,7 +2377,7 ＠＠ if (!NILP (n)) { CHECK_NATNUM (n); - int_n = BIGNUMP (n) ? 1 + EMACS_INT_MAX : XINT (n); + int_n = BIGNUMP (n) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (n); } if (CONSP (list)) ＠＠ -2425,7 +2425,7 ＠＠ if (!NILP (n)) { CHECK_NATNUM (n); - int_n = BIGNUMP (n) ? 1 + EMACS_INT_MAX : XINT (n); + int_n = BIGNUMP (n) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (n); } if (CONSP (list)) ＠＠ -2517,8 +2517,8 ＠＠ { struct gcpro gcpro1; Lisp_Object tail_before = Qnil; - Elemcount ii = 0, starting = XINT (start); - Elemcount ending = NILP (end) ? EMACS_INT_MAX : XINT (end); + Elemcount ii = 0, starting = XFIXNUM (start); + Elemcount ending = NILP (end) ? MOST_POSITIVE_FIXNUM : XFIXNUM (end); GCPRO1 (tail_before); ＠＠ -2882,16 +2882,16 ＠＠ Lisp_Object from_end, Lisp_Object default_, Lisp_Object caller) { Lisp_Object result = Qnil; - Elemcount starting = 0, ending = EMACS_INT_MAX, len, ii = 0; + Elemcount starting = 0, ending = MOST_POSITIVE_FIXNUM, len, ii = 0; CHECK_SEQUENCE (sequence); CHECK_NATNUM (start); - starting = INTP (start) ? XINT (start) : 1 + EMACS_INT_MAX; + starting = FIXNUMP (start) ? XFIXNUM (start) : 1 + MOST_POSITIVE_FIXNUM; if (!NILP (end)) { CHECK_NATNUM (end); - ending = INTP (end) ? XINT (end) : 1 + EMACS_INT_MAX; + ending = FIXNUMP (end) ? XFIXNUM (end) : 1 + MOST_POSITIVE_FIXNUM; } *object_out = default_; ＠＠ -2981,8 +2981,8 ＠＠ else { Lisp_Object object = Qnil; - len = XINT (Flength (sequence)); - check_sequence_range (sequence, start, end, make_int (len)); + len = XFIXNUM (Flength (sequence)); + check_sequence_range (sequence, start, end, make_fixnum (len)); ending = min (ending, len); if (0 == len) ＠＠ -2995,7 +2995,7 ＠＠ { for (ii = starting; ii < ending; ii++) { - object = Faref (sequence, make_int (ii)); + object = Faref (sequence, make_fixnum (ii)); if (check_test (test, key, item, object) == test_not_unboundp) { result = make_integer (ii); ＠＠ -3008,7 +3008,7 ＠＠ { for (ii = ending - 1; ii >= starting; ii--) { - object = Faref (sequence, make_int (ii)); + object = Faref (sequence, make_fixnum (ii)); if (check_test (test, key, item, object) == test_not_unboundp) { result = make_integer (ii); ＠＠ -3138,7 +3138,7 ＠＠ (int nargs, Lisp_Object *args)) { Lisp_Object item = args[0], sequence = args[1]; - Elemcount starting = 0, ending = EMACS_INT_MAX, counting = EMACS_INT_MAX; + Elemcount starting = 0, ending = MOST_POSITIVE_FIXNUM, counting = MOST_POSITIVE_FIXNUM; Elemcount len, ii = 0, encountered = 0, presenting = 0; Boolint test_not_unboundp = 1; check_test_func_t check_test = NULL; ＠＠ -3149,12 +3149,12 ＠＠ CHECK_SEQUENCE (sequence); CHECK_NATNUM (start); - starting = BIGNUMP (start) ? 1 + EMACS_INT_MAX : XINT (start); + starting = BIGNUMP (start) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (start); if (!NILP (end)) { CHECK_NATNUM (end); - ending = BIGNUMP (end) ? 1 + EMACS_INT_MAX : XINT (end); + ending = BIGNUMP (end) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (end); } if (!UNBOUNDP (count)) ＠＠ -3162,15 +3162,15 ＠＠ if (!NILP (count)) { CHECK_INTEGER (count); - if (INTP (count)) - { - counting = XINT (count); + if (FIXNUMP (count)) + { + counting = XFIXNUM (count); } #ifdef HAVE_BIGNUM else { counting = bignum_sign (XBIGNUM_DATA (count)) > 0 ? - 1 + EMACS_INT_MAX : EMACS_INT_MIN - 1; + 1 + MOST_POSITIVE_FIXNUM : MOST_NEGATIVE_FIXNUM - 1; } #endif ＠＠ -3220,7 +3220,7 ＠＠ return sequence; } - presenting = XINT (present); + presenting = XFIXNUM (present); /* If there are fewer items in the list than we have permission to delete, we don't need to differentiate between the :from-end ＠＠ -3274,7 +3274,7 ＠＠ !(presenting ? encountered == presenting : encountered == counting)) { check_sequence_range (args[1], start, end, - make_int (deleted + XINT (Flength (args[1])))); + make_fixnum (deleted + XFIXNUM (Flength (args[1])))); } return sequence; ＠＠ -3297,7 +3297,7 ＠＠ return sequence; } - presenting = XINT (present); + presenting = XFIXNUM (present); /* If there are fewer items in the list than we have permission to delete, we don't need to differentiate between the :from-end ＠＠ -3366,9 +3366,9 ＠＠ Lisp_Object *staging = NULL, *staging_cursor, *staging_limit; Elemcount positioning; - len = XINT (Flength (sequence)); - - check_sequence_range (sequence, start, end, make_int (len)); + len = XFIXNUM (Flength (sequence)); + + check_sequence_range (sequence, start, end, make_fixnum (len)); position0 = position (&object, item, sequence, check_test, test_not_unboundp, test, key, start, end, ＠＠ -3379,7 +3379,7 ＠＠ } ending = min (ending, len); - positioning = XINT (position0); + positioning = XFIXNUM (position0); encountered = 1; if (NILP (from_end)) ＠＠ -3390,14 +3390,14 ＠＠ ii = 0; while (ii < positioning) { - *staging_cursor++ = Faref (sequence, make_int (ii)); + *staging_cursor++ = Faref (sequence, make_fixnum (ii)); ii++; } ii = positioning + 1; while (ii < ending) { - object = Faref (sequence, make_int (ii)); + object = Faref (sequence, make_fixnum (ii)); if (encountered < counting && (check_test (test, key, item, object) == test_not_unboundp)) ＠＠ -3413,7 +3413,7 ＠＠ while (ii < len) { - *staging_cursor++ = Faref (sequence, make_int (ii)); + *staging_cursor++ = Faref (sequence, make_fixnum (ii)); ii++; } } ＠＠ -3425,14 +3425,14 ＠＠ ii = len - 1; while (ii > positioning) { - *--staging_cursor = Faref (sequence, make_int (ii)); + *--staging_cursor = Faref (sequence, make_fixnum (ii)); ii--; } ii = positioning - 1; while (ii >= starting) { - object = Faref (sequence, make_int (ii)); + object = Faref (sequence, make_fixnum (ii)); if (encountered < counting && (check_test (test, key, item, object) == test_not_unboundp)) ＠＠ -3449,7 +3449,7 ＠＠ while (ii >= 0) { - *--staging_cursor = Faref (sequence, make_int (ii)); + *--staging_cursor = Faref (sequence, make_fixnum (ii)); ii--; } ＠＠ -3502,7 +3502,7 ＠＠ { Lisp_Object item = args[0], sequence = args[1], matched_count = Qnil, tail = Qnil; - Elemcount starting = 0, ending = EMACS_INT_MAX, counting = EMACS_INT_MAX; + Elemcount starting = 0, ending = MOST_POSITIVE_FIXNUM, counting = MOST_POSITIVE_FIXNUM; Elemcount ii = 0, encountered = 0, presenting = 0; Boolint test_not_unboundp = 1; check_test_func_t check_test = NULL; ＠＠ -3517,26 +3517,26 ＠＠ } CHECK_NATNUM (start); - starting = BIGNUMP (start) ? 1 + EMACS_INT_MAX : XINT (start); + starting = BIGNUMP (start) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (start); if (!NILP (end)) { CHECK_NATNUM (end); - ending = BIGNUMP (end) ? 1 + EMACS_INT_MAX : XINT (end); + ending = BIGNUMP (end) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (end); } if (!NILP (count)) { CHECK_INTEGER (count); - if (INTP (count)) - { - counting = XINT (count); + if (FIXNUMP (count)) + { + counting = XFIXNUM (count); } #ifdef HAVE_BIGNUM else { counting = bignum_sign (XBIGNUM_DATA (count)) > 0 ? - 1 + EMACS_INT_MAX : -1 + EMACS_INT_MIN; + 1 + MOST_POSITIVE_FIXNUM : -1 + MOST_NEGATIVE_FIXNUM; } #endif ＠＠ -3576,7 +3576,7 ＠＠ if (!NILP (count) && !NILP (from_end)) { - presenting = XINT (matched_count); + presenting = XFIXNUM (matched_count); /* If there are fewer matching elements in the list than we have permission to delete, we don't need to differentiate between ＠＠ -3749,8 +3749,8 ＠＠ { Lisp_Object checking = Qnil, result = list; Lisp_Object keyed, positioned, position_cons = Qnil, result_tail; - Elemcount len = XINT (Flength (list)), pos, starting = XINT (start); - Elemcount ending = (NILP (end) ? len : XINT (end)), greatest_pos_seen = -1; + Elemcount len = XFIXNUM (Flength (list)), pos, starting = XFIXNUM (start); + Elemcount ending = (NILP (end) ? len : XFIXNUM (end)), greatest_pos_seen = -1; Elemcount ii = 0; struct gcpro gcpro1; ＠＠ -3788,10 +3788,10 ＠＠ while (!NILP ((positioned = list_position_cons_before (&position_cons, keyed, checking, check_test, test_not_unboundp, test, key, 0, - make_int (max (starting - pos, 0)), - make_int (ending - pos))))) + make_fixnum (max (starting - pos, 0)), + make_fixnum (ending - pos))))) { - pos = XINT (positioned) + pos; + pos = XFIXNUM (positioned) + pos; set_bit_vector_bit (deleting, pos, 1); greatest_pos_seen = max (greatest_pos_seen, pos); checking = NILP (position_cons) ? ＠＠ -3864,7 +3864,7 ＠＠ { Lisp_Object sequence = args[0], keyed = Qnil; Lisp_Object positioned = Qnil, ignore = Qnil; - Elemcount starting = 0, ending = EMACS_INT_MAX, len, ii = 0, jj = 0; + Elemcount starting = 0, ending = MOST_POSITIVE_FIXNUM, len, ii = 0, jj = 0; Boolint test_not_unboundp = 1; check_test_func_t check_test = NULL; struct gcpro gcpro1, gcpro2; ＠＠ -3875,12 +3875,12 ＠＠ CHECK_SEQUENCE (sequence); CHECK_NATNUM (start); - starting = BIGNUMP (start) ? 1 + EMACS_INT_MAX : XINT (start); + starting = BIGNUMP (start) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (start); if (!NILP (end)) { CHECK_NATNUM (end); - ending = BIGNUMP (end) ? 1 + EMACS_INT_MAX : XINT (end); + ending = BIGNUMP (end) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (end); } CHECK_KEY_ARGUMENT (key); ＠＠ -3907,10 +3907,10 ＠＠ = list_position_cons_before (&ignore, keyed, XCDR (tail), check_test, test_not_unboundp, test, key, - 0, make_int (max (starting + 0, make_fixnum (max (starting - (ii + 1), 0)), - make_int (ending + make_fixnum (ending - (ii + 1))); if (!NILP (positioned)) { ＠＠ -3946,9 +3946,9 ＠＠ = list_position_cons_before (&ignore, keyed, XCDR (tail), check_test, test_not_unboundp, test, key, 0, - make_int (max (starting + make_fixnum (max (starting - (ii + 1), 0)), - make_int (ending - (ii + 1))); + make_fixnum (ending - (ii + 1))); if (!NILP (positioned)) { /* We know this isn't the first iteration of the loop, ＠＠ -3978,8 +3978,8 ＠＠ if ((ii < starting || (ii < ending && !NILP (end)))) { check_sequence_range (args[0], start, end, - make_int (deleted - + XINT (Flength (args[0])))); + make_fixnum (deleted + + XFIXNUM (Flength (args[0])))); } } else ＠＠ -4282,12 +4282,12 ＠＠ { for (ii = starting; ii < ending; ii++) { - elt = KEY (key, make_int (bit_vector_bit (bv, ii))); + elt = KEY (key, make_fixnum (bit_vector_bit (bv, ii))); for (jj = ii + 1; jj < ending; jj++) { if (check_test (test, key, elt, - make_int (bit_vector_bit (bv, jj))) + make_fixnum (bit_vector_bit (bv, jj))) == test_not_unboundp) { set_bit_vector_bit (deleting, ii, 1); ＠＠ -4301,12 +4301,12 ＠＠ { for (ii = ending - 1; ii >= starting; ii--) { - elt = KEY (key, make_int (bit_vector_bit (bv, ii))); + elt = KEY (key, make_fixnum (bit_vector_bit (bv, ii))); for (jj = ii - 1; jj >= starting; jj--) { if (check_test (test, key, elt, - make_int (bit_vector_bit (bv, jj))) + make_fixnum (bit_vector_bit (bv, jj))) == test_not_unboundp) { set_bit_vector_bit (deleting, ii, 1); ＠＠ -4355,7 +4355,7 ＠＠ Lisp_Object sequence = args[0], keyed, positioned = Qnil; Lisp_Object result = sequence, result_tail = result, cursor = Qnil; Lisp_Object cons_with_shared_tail = Qnil; - Elemcount starting = 0, ending = EMACS_INT_MAX, ii = 0; + Elemcount starting = 0, ending = MOST_POSITIVE_FIXNUM, ii = 0; Boolint test_not_unboundp = 1; check_test_func_t check_test = NULL; struct gcpro gcpro1, gcpro2; ＠＠ -4372,12 +4372,12 ＠＠ } CHECK_NATNUM (start); - starting = BIGNUMP (start) ? 1 + EMACS_INT_MAX : XINT (start); + starting = BIGNUMP (start) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (start); if (!NILP (end)) { CHECK_NATNUM (end); - ending = BIGNUMP (end) ? 1 + EMACS_INT_MAX : XINT (end); + ending = BIGNUMP (end) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (end); } if (NILP (key)) ＠＠ -4404,9 +4404,9 ＠＠ = list_position_cons_before (&ignore, keyed, XCDR (tail), check_test, test_not_unboundp, test, key, 0, - make_int (max (starting + make_fixnum (max (starting - (ii + 1), 0)), - make_int (ending - (ii + 1))); + make_fixnum (ending - (ii + 1))); if (!NILP (positioned)) { sequence = result = result_tail = XCDR (tail); ＠＠ -4445,9 +4445,9 ＠＠ = list_position_cons_before (&ignore, keyed, XCDR (tail), check_test, test_not_unboundp, test, key, 0, - make_int (max (starting - (ii + 1), + make_fixnum (max (starting - (ii + 1), 0)), - make_int (ending - (ii + 1))); + make_fixnum (ending - (ii + 1))); if (!NILP (positioned)) { if (EQ (result, sequence)) ＠＠ -5044,7 +5044,7 ＠＠ c_array = alloca_array (Lisp_Object, len); \ for (counter = 0; counter < len; ++counter) \ { \ - c_array[counter] = make_int (bit_vector_bit (v, counter)); \ + c_array[counter] = make_fixnum (bit_vector_bit (v, counter)); \ } \ } while (0) ＠＠ -5136,8 +5136,8 ＠＠ } else { - Elemcount sequence_one_len = XINT (Flength (sequence_one)), - sequence_two_len = XINT (Flength (sequence_two)), i; + Elemcount sequence_one_len = XFIXNUM (Flength (sequence_one)), + sequence_two_len = XFIXNUM (Flength (sequence_two)), i; Elemcount output_len = 1 + sequence_one_len + sequence_two_len; Lisp_Object *output = alloca_array (Lisp_Object, output_len), *sequence_one_storage = NULL, *sequence_two_storage = NULL; ＠＠ -5243,10 +5243,10 ＠＠ Lisp_Object front = list; Lisp_Object len = Flength (list); - if (XINT (len) < 2) + if (XFIXNUM (len) < 2) return list; - len = make_int (XINT (len) / 2 - 1); + len = make_fixnum (XFIXNUM (len) / 2 - 1); tem = Fnthcdr (len, list); back = Fcdr (tem); Fsetcdr (tem, Qnil); ＠＠ -5352,7 +5352,7 ＠＠ for (i = 0; i < sequence_len; ++i) { - set_bit_vector_bit (v, i, XINT (sequence_carray [i])); + set_bit_vector_bit (v, i, XFIXNUM (sequence_carray [i])); } } ＠＠ -5387,8 +5387,8 ＠＠ Fcheck_valid_plist (a); Fcheck_valid_plist (b); - la = XINT (Flength (a)); - lb = XINT (Flength (b)); + la = XFIXNUM (Flength (a)); + lb = XFIXNUM (Flength (b)); m = (la > lb ? la : lb); fill = 0; keys = alloca_array (Lisp_Object, m); ＠＠ -6217,7 +6217,7 ＠＠ tweaked_internal_equal (Lisp_Object obj1, Lisp_Object obj2, Lisp_Object depth) { - return make_int (internal_equal (obj1, obj2, XINT (depth))); + return make_fixnum (internal_equal (obj1, obj2, XFIXNUM (depth))); } int ＠＠ -6233,11 +6233,11 ＠＠ va_call_trapping_problems (warning_class, warning_string, flags, p, (lisp_fn_t) tweaked_internal_equal, - 3, obj1, obj2, make_int (depth)); + 3, obj1, obj2, make_fixnum (depth)); if (UNBOUNDP (glorp)) return retval; else - return XINT (glorp); + return XFIXNUM (glorp); } int ＠＠ -6316,14 +6316,14 ＠＠ if (artype1 != artype2 && artype1 && artype2) { EMACS_INT i; - EMACS_INT l1 = XINT (Flength (obj1)); - EMACS_INT l2 = XINT (Flength (obj2)); + EMACS_INT l1 = XFIXNUM (Flength (obj1)); + EMACS_INT l2 = XFIXNUM (Flength (obj2)); /* Both arrays, but of different lengths */ if (l1 != l2) return 0; for (i = 0; i < l1; i++) - if (!internal_equalp (Faref (obj1, make_int (i)), - Faref (obj2, make_int (i)), depth + 1)) + if (!internal_equalp (Faref (obj1, make_fixnum (i)), + Faref (obj2, make_fixnum (i)), depth + 1)) return 0; return 1; } ＠＠ -6600,17 +6600,17 ＠＠ { Lisp_Object sequence = args[0]; Lisp_Object item = args[1]; - Elemcount starting, ending = EMACS_INT_MAX + 1, ii, len; + Elemcount starting, ending = MOST_POSITIVE_FIXNUM + 1, ii, len; PARSE_KEYWORDS (Ffill, nargs, args, 2, (start, end), (start = Qzero)); CHECK_NATNUM (start); - starting = BIGNUMP (start) ? EMACS_INT_MAX + 1 : XINT (start); + starting = BIGNUMP (start) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (start); if (!NILP (end)) { CHECK_NATNUM (end); - ending = BIGNUMP (end) ? EMACS_INT_MAX + 1 : XINT (end); + ending = BIGNUMP (end) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (end); } retry: ＠＠ -6628,7 +6628,7 ＠＠ CHECK_LISP_WRITEABLE (sequence); len = XVECTOR_LENGTH (sequence); - check_sequence_range (sequence, start, end, make_int (len)); + check_sequence_range (sequence, start, end, make_fixnum (len)); ending = min (ending, len); for (ii = starting; ii < ending; ++ii) ＠＠ -6642,11 +6642,11 ＠＠ int bit; CHECK_BIT (item); - bit = XINT (item); + bit = XFIXNUM (item); CHECK_LISP_WRITEABLE (sequence); len = bit_vector_length (v); - check_sequence_range (sequence, start, end, make_int (len)); + check_sequence_range (sequence, start, end, make_fixnum (len)); ending = min (ending, len); for (ii = starting; ii < ending; ++ii) ＠＠ -6987,7 +6987,7 ＠＠ case lrecord_type_bit_vector: { args[j + 1] - = make_int (bit_vector_bit (XBIT_VECTOR (sequences[j]), + = make_fixnum (bit_vector_bit (XBIT_VECTOR (sequences[j]), i)); break; } ＠＠ -7049,7 +7049,7 ＠＠ i < XVECTOR_LENGTH (lisp_vals) ? (XVECTOR_DATA (lisp_vals)[i] = called) : /* Let #'aset error. */ - Faset (lisp_vals, make_int (i), called); + Faset (lisp_vals, make_fixnum (i), called); break; } case lrecord_type_string: ＠＠ -7063,8 +7063,8 ＠＠ (BITP (called) && i < bit_vector_length (XBIT_VECTOR (lisp_vals))) ? set_bit_vector_bit (XBIT_VECTOR (lisp_vals), i, - XINT (called)) : - (void) Faset (lisp_vals, make_int (i), called); + XFIXNUM (called)) : + (void) Faset (lisp_vals, make_fixnum (i), called); break; } default: ＠＠ -7079,7 +7079,7 ＠＠ if (lisp_vals_staging != NULL) { CHECK_LISP_WRITEABLE (lisp_vals); - replace_string_range (lisp_vals, Qzero, make_int (call_count), + replace_string_range (lisp_vals, Qzero, make_fixnum (call_count), lisp_vals_staging, cursor); } } ＠＠ -7093,7 +7093,7 ＠＠ static Elemcount shortest_length_among_sequences (int nsequences, Lisp_Object *sequences) { - Elemcount len = 1 + EMACS_INT_MAX; + Elemcount len = 1 + MOST_POSITIVE_FIXNUM; Lisp_Object length = Qnil; int i; ＠＠ -7104,18 +7104,18 ＠＠ length = Flist_length (sequences[i]); if (!NILP (length)) { - len = min (len, XINT (length)); + len = min (len, XFIXNUM (length)); } } else { CHECK_SEQUENCE (sequences[i]); length = Flength (sequences[i]); - len = min (len, XINT (length)); - } - } - - if (len == 1 + EMACS_INT_MAX) + len = min (len, XFIXNUM (length)); + } + } + + if (len == 1 + MOST_POSITIVE_FIXNUM) { signal_circular_list_error (sequences[0]); } ＠＠ -7143,7 +7143,7 ＠＠ Lisp_Object function = args[0]; Lisp_Object sequence = args[1]; Lisp_Object separator = args[2]; - Elemcount len = EMACS_INT_MAX; + Elemcount len = MOST_POSITIVE_FIXNUM; Lisp_Object *args0; EMACS_INT i, nargs0; ＠＠ -7613,7 +7613,7 ＠＠ (int nargs, Lisp_Object *args)) { Lisp_Object function = args[0], sequence = args[1], accum = Qunbound; - Elemcount starting, ending = EMACS_INT_MAX + 1, ii = 0; + Elemcount starting, ending = MOST_POSITIVE_FIXNUM + 1, ii = 0; PARSE_KEYWORDS (Freduce, nargs, args, 5, (start, end, from_end, initial_value, key), ＠＠ -7621,7 +7621,7 ＠＠ CHECK_SEQUENCE (sequence); CHECK_NATNUM (start); - starting = BIGNUMP (start) ? EMACS_INT_MAX + 1 : XINT (start); + starting = BIGNUMP (start) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (start); CHECK_KEY_ARGUMENT (key); #define KEY(key, item) (EQ (Qidentity, key) ? item : \ ＠＠ -7632,7 +7632,7 ＠＠ if (!NILP (end)) { CHECK_NATNUM (end); - ending = BIGNUMP (end) ? EMACS_INT_MAX + 1 : XINT (end); + ending = BIGNUMP (end) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (end); } if (VECTORP (sequence)) ＠＠ -7640,7 +7640,7 ＠＠ Lisp_Vector *vv = XVECTOR (sequence); struct gcpro gcpro1; - check_sequence_range (sequence, start, end, make_int (vv->size)); + check_sequence_range (sequence, start, end, make_fixnum (vv->size)); ending = min (ending, vv->size); ＠＠ -7686,7 +7686,7 ＠＠ Lisp_Bit_Vector *bv = XBIT_VECTOR (sequence); struct gcpro gcpro1; - check_sequence_range (sequence, start, end, make_int (bv->size)); + check_sequence_range (sequence, start, end, make_fixnum (bv->size)); ending = min (ending, bv->size); GCPRO1 (accum); ＠＠ -7699,12 +7699,12 ＠＠ { if (NILP (from_end)) { - accum = KEY (key, make_int (bit_vector_bit (bv, starting))); + accum = KEY (key, make_fixnum (bit_vector_bit (bv, starting))); starting++; } else { - accum = KEY (key, make_int (bit_vector_bit (bv, ending - 1))); + accum = KEY (key, make_fixnum (bit_vector_bit (bv, ending - 1))); ending--; } } ＠＠ -7714,7 +7714,7 ＠＠ for (ii = starting; ii < ending; ++ii) { accum = CALL2 (function, accum, - KEY (key, make_int (bit_vector_bit (bv, ii)))); + KEY (key, make_fixnum (bit_vector_bit (bv, ii)))); } } else ＠＠ -7722,7 +7722,7 ＠＠ for (ii = ending - 1; ii >= starting; --ii) { accum = CALL2 (function, KEY (key, - make_int (bit_vector_bit (bv, + make_fixnum (bit_vector_bit (bv, ii))), accum); } ＠＠ -7802,9 +7802,9 ＠＠ Bytecount cursor_offset, byte_len = XSTRING_LENGTH (sequence); const Ibyte *cursor; - check_sequence_range (sequence, start, end, make_int (len)); + check_sequence_range (sequence, start, end, make_fixnum (len)); ending = min (ending, len); - starting = XINT (start); + starting = XFIXNUM (start); cursor = string_char_addr (sequence, ending - 1); cursor_offset = cursor - XSTRING_DATA (sequence); ＠＠ -7917,8 +7917,8 ＠＠ Elemcount counting = 0, len = 0; struct gcpro gcpro1; - len = XINT (Flength (sequence)); - check_sequence_range (sequence, start, end, make_int (len)); + len = XFIXNUM (Flength (sequence)); + check_sequence_range (sequence, start, end, make_fixnum (len)); ending = min (ending, len); /* :from-end with a list; make an alloca copy of the relevant list ＠＠ -8048,7 +8048,7 ＠＠ *pend = p + XSTRING_LENGTH (dest), *pcursor, item_buf[MAX_ICHAR_LEN]; Bytecount prefix_bytecount, source_len = source_limit - source; Charcount ii = 0, ending, len; - Charcount starting = BIGNUMP (start) ? EMACS_INT_MAX + 1 : XINT (start); + Charcount starting = BIGNUMP (start) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (start); Elemcount delta; while (ii < starting && p < pend) ＠＠ -8071,7 +8071,7 ＠＠ } else { - ending = BIGNUMP (end) ? EMACS_INT_MAX + 1 : XINT (end); + ending = BIGNUMP (end) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (end); while (ii < ending && pcursor < pend) { INC_IBYTEPTR (pcursor); ＠＠ -8082,7 +8082,7 ＠＠ if (pcursor == pend) { /* We have the length, check it for our callers. */ - check_sequence_range (dest, start, end, make_int (ii)); + check_sequence_range (dest, start, end, make_fixnum (ii)); } if (!(p == pend || p == pcursor)) ＠＠ -8151,8 +8151,8 ＠＠ { Lisp_Object sequence1 = args[0], sequence2 = args[1], result = sequence1; - Elemcount starting1, ending1 = EMACS_INT_MAX + 1, starting2; - Elemcount ending2 = EMACS_INT_MAX + 1, counting = 0, startcounting; + Elemcount starting1, ending1 = MOST_POSITIVE_FIXNUM + 1, starting2; + Elemcount ending2 = MOST_POSITIVE_FIXNUM + 1, counting = 0, startcounting; Boolint sequence1_listp, sequence2_listp, overwriting = EQ (sequence1, sequence2); ＠＠ -8165,20 +8165,20 ＠＠ CHECK_SEQUENCE (sequence2); CHECK_NATNUM (start1); - starting1 = BIGNUMP (start1) ? EMACS_INT_MAX + 1 : XINT (start1); + starting1 = BIGNUMP (start1) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (start1); CHECK_NATNUM (start2); - starting2 = BIGNUMP (start2) ? EMACS_INT_MAX + 1 : XINT (start2); + starting2 = BIGNUMP (start2) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (start2); if (!NILP (end1)) { CHECK_NATNUM (end1); - ending1 = BIGNUMP (end1) ? EMACS_INT_MAX + 1 : XINT (end1); + ending1 = BIGNUMP (end1) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (end1); } if (!NILP (end2)) { CHECK_NATNUM (end2); - ending2 = BIGNUMP (end2) ? EMACS_INT_MAX + 1 : XINT (end2); + ending2 = BIGNUMP (end2) ? MOST_POSITIVE_FIXNUM + 1 : XFIXNUM (end2); } sequence1_listp = LISTP (sequence1); ＠＠ -8227,7 +8227,7 ＠＠ if (CONSP (sequence2)) { - Elemcount len = XINT (Flength (sequence2)); + Elemcount len = XFIXNUM (Flength (sequence2)); Lisp_Object *subsequence = alloca_array (Lisp_Object, min (ending2, len)); Elemcount ii = 0; ＠＠ -8244,12 +8244,12 ＠＠ } check_sequence_range (sequence1, start1, end1, - /* The XINT (start2) is intentional here; we + /* The XFIXNUM (start2) is intentional here; we called #'length after doing (nthcdr start2 sequence2). */ - make_int (XINT (start2) + len)); + make_fixnum (XFIXNUM (start2) + len)); check_sequence_range (sequence2, start2, end2, - make_int (XINT (start2) + len)); + make_fixnum (XFIXNUM (start2) + len)); while (starting1 < ending1 && starting2 < ending2 && !NILP (sequence1)) ＠＠ -8284,8 +8284,8 ＠＠ if (pcursor == pend) { - check_sequence_range (sequence1, start1, end1, make_int (ii)); - check_sequence_range (sequence2, start2, end2, make_int (ii)); + check_sequence_range (sequence1, start1, end1, make_fixnum (ii)); + check_sequence_range (sequence2, start2, end2, make_fixnum (ii)); } else { ＠＠ -8293,23 +8293,23 ＠＠ staging = alloca_ibytes (pcursor - p); memcpy (staging, p, pcursor - p); replace_string_range (result, start1, - make_int (starting1), + make_fixnum (starting1), staging, staging + (pcursor - p)); } } else { - Elemcount seq_len = XINT (Flength (sequence2)), ii = 0, + Elemcount seq_len = XFIXNUM (Flength (sequence2)), ii = 0, subseq_len = min (min (ending1 - starting1, seq_len - starting1), min (ending2 - starting2, seq_len - starting2)); Lisp_Object *subsequence = alloca_array (Lisp_Object, subseq_len); - check_sequence_range (sequence1, start1, end1, make_int (seq_len)); - check_sequence_range (sequence2, start2, end2, make_int (seq_len)); + check_sequence_range (sequence1, start1, end1, make_fixnum (seq_len)); + check_sequence_range (sequence2, start2, end2, make_fixnum (seq_len)); while (starting2 < ending2 && ii < seq_len) { - subsequence[ii] = Faref (sequence2, make_int (starting2)); + subsequence[ii] = Faref (sequence2, make_fixnum (starting2)); ii++, starting2++; } ＠＠ -8317,7 +8317,7 ＠＠ while (starting1 < ending1 && ii < seq_len) { - Faset (sequence1, make_int (starting1), subsequence[ii]); + Faset (sequence1, make_fixnum (starting1), subsequence[ii]); ii++, starting1++; } } ＠＠ -8365,12 +8365,12 ＠＠ if (NILP (sequence1)) { check_sequence_range (args[0], start1, end1, - make_int (XINT (start1) + shortest_len)); + make_fixnum (XFIXNUM (start1) + shortest_len)); } else if (NILP (sequence2)) { check_sequence_range (args[1], start2, end2, - make_int (XINT (start2) + shortest_len)); + make_fixnum (XFIXNUM (start2) + shortest_len)); } } else if (sequence1_listp) ＠＠ -8405,26 +8405,26 ＠＠ if (NILP (sequence1)) { check_sequence_range (sequence1, start1, end1, - make_int (XINT (start1) + starting1)); + make_fixnum (XFIXNUM (start1) + starting1)); } if (s2_data == s2_end) { check_sequence_range (sequence2, start2, end2, - make_int (char_count)); + make_fixnum (char_count)); } } else { - Elemcount len2 = XINT (Flength (sequence2)); - check_sequence_range (sequence2, start2, end2, make_int (len2)); + Elemcount len2 = XFIXNUM (Flength (sequence2)); + check_sequence_range (sequence2, start2, end2, make_fixnum (len2)); ending2 = min (ending2, len2); while (starting2 < ending2 && starting1 < ending1 && !NILP (sequence1)) { CHECK_CONS (sequence1); - XSETCAR (sequence1, Faref (sequence2, make_int (starting2))); + XSETCAR (sequence1, Faref (sequence2, make_fixnum (starting2))); sequence1 = XCDR (sequence1); starting1++; starting2++; ＠＠ -8433,7 +8433,7 ＠＠ if (NILP (sequence1)) { check_sequence_range (args[0], start1, end1, - make_int (XINT (start1) + starting1)); + make_fixnum (XFIXNUM (start1) + starting1)); } } } ＠＠ -8445,7 +8445,7 ＠＠ Ibyte *staging, *cursor; Lisp_Object obj; - check_sequence_range (sequence1, start1, end1, make_int (len)); + check_sequence_range (sequence1, start1, end1, make_fixnum (len)); ending1 = min (ending1, len); count = ending1 - starting1; staging = cursor = alloca_ibytes (count * MAX_ICHAR_LEN); ＠＠ -8464,22 +8464,22 ＠＠ if (NILP (sequence2)) { check_sequence_range (sequence2, start2, end2, - make_int (XINT (start2) + ii)); - } - - replace_string_range (result, start1, make_int (XINT (start1) + ii), + make_fixnum (XFIXNUM (start2) + ii)); + } + + replace_string_range (result, start1, make_fixnum (XFIXNUM (start1) + ii), staging, cursor); } else { - Elemcount len = XINT (Flength (sequence1)); - - check_sequence_range (sequence1, start2, end1, make_int (len)); + Elemcount len = XFIXNUM (Flength (sequence1)); + + check_sequence_range (sequence1, start2, end1, make_fixnum (len)); ending1 = min (ending2, min (ending1, len)); while (starting1 < ending1 && !NILP (sequence2)) { - Faset (sequence1, make_int (starting1), + Faset (sequence1, make_fixnum (starting1), CONSP (sequence2) ? XCAR (sequence2) : Fcar (sequence2)); sequence2 = XCDR (sequence2); ＠＠ -8490,7 +8490,7 ＠＠ if (NILP (sequence2)) { check_sequence_range (args[1], start2, end2, - make_int (XINT (start2) + starting2)); + make_fixnum (XFIXNUM (start2) + starting2)); } } } ＠＠ -8502,7 +8502,7 ＠＠ *p2end = p2 + XSTRING_LENGTH (sequence2), *p2cursor; Charcount ii = 0, len1 = string_char_length (sequence1); - check_sequence_range (sequence1, start1, end1, make_int (len1)); + check_sequence_range (sequence1, start1, end1, make_fixnum (len1)); while (ii < starting2 && p2 < p2end) { ＠＠ -8522,23 +8522,23 ＠＠ if (p2cursor == p2end) { - check_sequence_range (sequence2, start2, end2, make_int (ii)); + check_sequence_range (sequence2, start2, end2, make_fixnum (ii)); } /* This isn't great; any error message won't necessarily reflect the END1 that was supplied to #'replace. */ - replace_string_range (result, start1, make_int (starting1), + replace_string_range (result, start1, make_fixnum (starting1), p2, p2cursor); } else if (STRINGP (sequence1)) { Ibyte *staging, *cursor; Elemcount count, len1 = string_char_length (sequence1); - Elemcount len2 = XINT (Flength (sequence2)), ii = 0; + Elemcount len2 = XFIXNUM (Flength (sequence2)), ii = 0; Lisp_Object obj; - check_sequence_range (sequence1, start1, end1, make_int (len1)); - check_sequence_range (sequence2, start2, end2, make_int (len2)); + check_sequence_range (sequence1, start1, end1, make_fixnum (len1)); + check_sequence_range (sequence2, start2, end2, make_fixnum (len2)); ending1 = min (ending1, len1); ending2 = min (ending2, len2); ＠＠ -8548,7 +8548,7 ＠＠ ii = 0; while (ii < count) { - obj = Faref (sequence2, make_int (starting2)); + obj = Faref (sequence2, make_fixnum (starting2)); CHECK_CHAR_COERCE_INT (obj); cursor += set_itext_ichar (cursor, XCHAR (obj)); ＠＠ -8556,16 +8556,16 ＠＠ } replace_string_range (result, start1, - make_int (XINT (start1) + count), + make_fixnum (XFIXNUM (start1) + count), staging, cursor); } else if (STRINGP (sequence2)) { Ibyte *p2 = XSTRING_DATA (sequence2), *p2end = p2 + XSTRING_LENGTH (sequence2); - Elemcount len1 = XINT (Flength (sequence1)), ii = 0; - - check_sequence_range (sequence1, start1, end1, make_int (len1)); + Elemcount len1 = XFIXNUM (Flength (sequence1)), ii = 0; + + check_sequence_range (sequence1, start1, end1, make_fixnum (len1)); ending1 = min (ending1, len1); while (ii < starting2 && p2 < p2end) ＠＠ -8576,7 +8576,7 ＠＠ while (p2 < p2end && starting1 < ending1 && starting2 < ending2) { - Faset (sequence1, make_int (starting1), + Faset (sequence1, make_fixnum (starting1), make_char (itext_ichar (p2))); INC_IBYTEPTR (p2); starting1++; ＠＠ -8586,24 +8586,24 ＠＠ if (p2 == p2end) { - check_sequence_range (sequence2, start2, end2, make_int (ii)); + check_sequence_range (sequence2, start2, end2, make_fixnum (ii)); } } else { - Elemcount len1 = XINT (Flength (sequence1)), - len2 = XINT (Flength (sequence2)); - - check_sequence_range (sequence1, start1, end1, make_int (len1)); - check_sequence_range (sequence2, start2, end2, make_int (len2)); + Elemcount len1 = XFIXNUM (Flength (sequence1)), + len2 = XFIXNUM (Flength (sequence2)); + + check_sequence_range (sequence1, start1, end1, make_fixnum (len1)); + check_sequence_range (sequence2, start2, end2, make_fixnum (len2)); ending1 = min (ending1, len1); ending2 = min (ending2, len2); while (starting1 < ending1 && starting2 < ending2) { - Faset (sequence1, make_int (starting1), - Faref (sequence2, make_int (starting2))); + Faset (sequence1, make_fixnum (starting1), + Faref (sequence2, make_fixnum (starting2))); starting1++; starting2++; } ＠＠ -8625,8 +8625,8 ＠＠ { Lisp_Object new_ = args[0], item = args[1], sequence = args[2]; Lisp_Object object_, position0; - Elemcount starting = 0, ending = EMACS_INT_MAX, encountered = 0; - Elemcount len, ii = 0, counting = EMACS_INT_MAX, presenting = 0; + Elemcount starting = 0, ending = MOST_POSITIVE_FIXNUM, encountered = 0; + Elemcount len, ii = 0, counting = MOST_POSITIVE_FIXNUM, presenting = 0; Boolint test_not_unboundp = 1; check_test_func_t check_test = NULL; ＠＠ -8636,26 +8636,26 ＠＠ CHECK_SEQUENCE (sequence); CHECK_NATNUM (start); - starting = BIGNUMP (start) ? 1 + EMACS_INT_MAX : XINT (start); + starting = BIGNUMP (start) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (start); if (!NILP (end)) { CHECK_NATNUM (end); - ending = BIGNUMP (end) ? 1 + EMACS_INT_MAX : XINT (end); + ending = BIGNUMP (end) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (end); } if (!NILP (count)) { CHECK_INTEGER (count); - if (INTP (count)) - { - counting = XINT (count); + if (FIXNUMP (count)) + { + counting = XFIXNUM (count); } #ifdef HAVE_BIGNUM else { counting = bignum_sign (XBIGNUM_DATA (count)) > 0 ? - 1 + EMACS_INT_MAX : -1 + EMACS_INT_MIN; + 1 + MOST_POSITIVE_FIXNUM : -1 + MOST_NEGATIVE_FIXNUM; } #endif ＠＠ -8680,7 +8680,7 ＠＠ return sequence; } - presenting = XINT (present); + presenting = XFIXNUM (present); presenting = presenting <= counting ? 0 : presenting - counting; } ＠＠ -8743,7 +8743,7 ＠＠ return sequence; } - presenting = XINT (present); + presenting = XFIXNUM (present); /* If there are fewer items in the string than we have permission to change, we don't need to differentiate ＠＠ -8801,7 +8801,7 ＠＠ if (0 != encountered) { CHECK_LISP_WRITEABLE (sequence); - replace_string_range (sequence, Qzero, make_int (ii), + replace_string_range (sequence, Qzero, make_fixnum (ii), staging, staging_cursor); } } ＠＠ -8810,8 +8810,8 ＠＠ Elemcount positioning; Lisp_Object object = Qnil; - len = XINT (Flength (sequence)); - check_sequence_range (sequence, start, end, make_int (len)); + len = XFIXNUM (Flength (sequence)); + check_sequence_range (sequence, start, end, make_fixnum (len)); position0 = position (&object, item, sequence, check_test, test_not_unboundp, test, key, start, end, from_end, ＠＠ -8822,7 +8822,7 ＠＠ return sequence; } - positioning = XINT (position0); + positioning = XFIXNUM (position0); ending = min (len, ending); Faset (sequence, position0, new_); ＠＠ -8832,12 +8832,12 ＠＠ { for (ii = positioning + 1; ii < ending; ii++) { - object_ = Faref (sequence, make_int (ii)); + object_ = Faref (sequence, make_fixnum (ii)); if (check_test (test, key, item, object_) == test_not_unboundp && encountered++ < counting) { - Faset (sequence, make_int (ii), new_); + Faset (sequence, make_fixnum (ii), new_); } else if (encountered == counting) { ＠＠ -8849,12 +8849,12 ＠＠ { for (ii = positioning - 1; ii >= starting; ii--) { - object_ = Faref (sequence, make_int (ii)); + object_ = Faref (sequence, make_fixnum (ii)); if (check_test (test, key, item, object_) == test_not_unboundp && encountered++ < counting) { - Faset (sequence, make_int (ii), new_); + Faset (sequence, make_fixnum (ii), new_); } else if (encountered == counting) { ＠＠ -8882,8 +8882,8 ＠＠ Lisp_Object new_ = args[0], item = args[1], sequence = args[2], tail = Qnil; Lisp_Object result = Qnil, result_tail = Qnil; Lisp_Object object, position0, matched_count; - Elemcount starting = 0, ending = EMACS_INT_MAX, encountered = 0; - Elemcount ii = 0, counting = EMACS_INT_MAX, presenting = 0; + Elemcount starting = 0, ending = MOST_POSITIVE_FIXNUM, encountered = 0; + Elemcount ii = 0, counting = MOST_POSITIVE_FIXNUM, presenting = 0; Boolint test_not_unboundp = 1; check_test_func_t check_test = NULL; struct gcpro gcpro1; ＠＠ -8895,12 +8895,12 ＠＠ CHECK_SEQUENCE (sequence); CHECK_NATNUM (start); - starting = BIGNUMP (start) ? 1 + EMACS_INT_MAX : XINT (start); + starting = BIGNUMP (start) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (start); if (!NILP (end)) { CHECK_NATNUM (end); - ending = BIGNUMP (end) ? 1 + EMACS_INT_MAX : XINT (end); + ending = BIGNUMP (end) ? 1 + MOST_POSITIVE_FIXNUM : XFIXNUM (end); } check_test = get_check_test_function (item, &test, test_not, if_, if_not, ＠＠ -8911,15 +8911,15 ＠＠ if (!NILP (count)) { CHECK_INTEGER (count); - if (INTP (count)) - { - counting = XINT (count); + if (FIXNUMP (count)) + { + counting = XFIXNUM (count); } #ifdef HAVE_BIGNUM else { counting = bignum_sign (XBIGNUM_DATA (count)) > 0 ? - 1 + EMACS_INT_MAX : -1 + EMACS_INT_MIN; + 1 + MOST_POSITIVE_FIXNUM : -1 + MOST_NEGATIVE_FIXNUM; } #endif ＠＠ -8956,7 +8956,7 ＠＠ if (!NILP (count) && !NILP (from_end)) { - presenting = XINT (matched_count); + presenting = XFIXNUM (matched_count); presenting = presenting <= counting ? 0 : presenting - counting; } ＠＠ -9427,20 +9427,20 ＠＠ Lisp_Object test, Lisp_Object key, Boolint UNUSED (return_sequence1_index)) { - Elemcount sequence1_len = XINT (Flength (sequence1)); - Elemcount sequence2_len = XINT (Flength (sequence2)), ii = 0; + Elemcount sequence1_len = XFIXNUM (Flength (sequence1)); + Elemcount sequence2_len = XFIXNUM (Flength (sequence2)), ii = 0; Elemcount starting1, ending1, starting2, ending2; Lisp_Object *sequence1_storage = NULL, *sequence2_storage = NULL; struct gcpro gcpro1, gcpro2; - check_sequence_range (sequence1, start1, end1, make_int (sequence1_len)); - starting1 = XINT (start1); - ending1 = INTP (end1) ? XINT (end1) : 1 + EMACS_INT_MAX; + check_sequence_range (sequence1, start1, end1, make_fixnum (sequence1_len)); + starting1 = XFIXNUM (start1); + ending1 = FIXNUMP (end1) ? XFIXNUM (end1) : 1 + MOST_POSITIVE_FIXNUM; ending1 = min (ending1, sequence1_len); - check_sequence_range (sequence2, start2, end2, make_int (sequence2_len)); - starting2 = XINT (start2); - ending2 = INTP (end2) ? XINT (end2) : 1 + EMACS_INT_MAX; + check_sequence_range (sequence2, start2, end2, make_fixnum (sequence2_len)); + starting2 = XFIXNUM (start2); + ending2 = FIXNUMP (end2) ? XFIXNUM (end2) : 1 + MOST_POSITIVE_FIXNUM; ending2 = min (ending2, sequence2_len); if (LISTP (sequence1)) ＠＠ -9480,7 +9480,7 ＠＠ for (ii = starting1; ii < ending1; ++ii) { sequence1_storage[ii - starting1] - = make_int (bit_vector_bit (vv, ii)); + = make_fixnum (bit_vector_bit (vv, ii)); } } else ＠＠ -9527,7 +9527,7 ＠＠ for (ii = starting2; ii < ending2; ++ii) { sequence2_storage[ii - starting2] - = make_int (bit_vector_bit (vv, ii)); + = make_fixnum (bit_vector_bit (vv, ii)); } } else ＠＠ -9572,22 +9572,22 ＠＠ { Lisp_Object sequence1_tortoise = sequence1, sequence2_tortoise = sequence2; Lisp_Object orig_sequence1 = sequence1, orig_sequence2 = sequence2; - Elemcount ending1 = EMACS_INT_MAX, ending2 = EMACS_INT_MAX; + Elemcount ending1 = MOST_POSITIVE_FIXNUM, ending2 = MOST_POSITIVE_FIXNUM; Elemcount starting1, starting2, counting, startcounting; Elemcount shortest_len = 0; struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; - starting1 = INTP (start1) ? XINT (start1) : 1 + EMACS_INT_MAX; - starting2 = INTP (start2) ? XINT (start2) : 1 + EMACS_INT_MAX; + starting1 = FIXNUMP (start1) ? XFIXNUM (start1) : 1 + MOST_POSITIVE_FIXNUM; + starting2 = FIXNUMP (start2) ? XFIXNUM (start2) : 1 + MOST_POSITIVE_FIXNUM; if (!NILP (end1)) { - ending1 = INTP (end1) ? XINT (end1) : 1 + EMACS_INT_MAX; + ending1 = FIXNUMP (end1) ? XFIXNUM (end1) : 1 + MOST_POSITIVE_FIXNUM; } if (!NILP (end2)) { - ending2 = INTP (end2) ? XINT (end2) : 1 + EMACS_INT_MAX; + ending2 = FIXNUMP (end2) ? XFIXNUM (end2) : 1 + MOST_POSITIVE_FIXNUM; } if (!ZEROP (start1)) ＠＠ -9636,7 +9636,7 ＠＠ : Fcar (sequence2) ) != test_not_unboundp) { UNGCPRO; - return make_integer (XINT (start1) + shortest_len); + return make_integer (XFIXNUM (start1) + shortest_len); } sequence1 = CONSP (sequence1) ? XCDR (sequence1) : Fcdr (sequence1); ＠＠ -9668,14 +9668,14 ＠＠ if (NILP (sequence1)) { - Lisp_Object args[] = { start1, make_int (shortest_len) }; + Lisp_Object args[] = { start1, make_fixnum (shortest_len) }; check_sequence_range (orig_sequence1, start1, end1, Fplus (countof (args), args)); } if (NILP (sequence2)) { - Lisp_Object args[] = { start2, make_int (shortest_len) }; + Lisp_Object args[] = { start2, make_fixnum (shortest_len) }; check_sequence_range (orig_sequence2, start2, end2, Fplus (countof (args), args)); } ＠＠ -9683,12 +9683,12 ＠＠ if ((!NILP (end1) && shortest_len != ending1 - starting1) || (!NILP (end2) && shortest_len != ending2 - starting2)) { - return make_integer (XINT (start1) + shortest_len); + return make_integer (XFIXNUM (start1) + shortest_len); } if ((NILP (end1) && CONSP (sequence1)) || (NILP (end2) && CONSP (sequence2))) { - return make_integer (XINT (start1) + shortest_len); + return make_integer (XFIXNUM (start1) + shortest_len); } return Qnil; ＠＠ -9711,12 +9711,12 ＠＠ Lisp_Object character, orig_list = list; struct gcpro gcpro1; - list_ending = INTP (list_end) ? XINT (list_end) : 1 + EMACS_INT_MAX; - list_starting = INTP (list_start) ? XINT (list_start) : 1 + EMACS_INT_MAX; - - string_ending = INTP (string_end) ? XINT (string_end) : 1 + EMACS_INT_MAX; + list_ending = FIXNUMP (list_end) ? XFIXNUM (list_end) : 1 + MOST_POSITIVE_FIXNUM; + list_starting = FIXNUMP (list_start) ? XFIXNUM (list_start) : 1 + MOST_POSITIVE_FIXNUM; + + string_ending = FIXNUMP (string_end) ? XFIXNUM (string_end) : 1 + MOST_POSITIVE_FIXNUM; string_starting - = INTP (string_start) ? XINT (string_start) : 1 + EMACS_INT_MAX; + = FIXNUMP (string_start) ? XFIXNUM (string_start) : 1 + MOST_POSITIVE_FIXNUM; while (char_count < string_starting && string_offset < string_len) { ＠＠ -9753,7 +9753,7 ＠＠ != test_not_unboundp) { UNGCPRO; - return make_integer (XINT (list_start) + char_count); + return make_integer (XFIXNUM (list_start) + char_count); } } else ＠＠ -9788,7 +9788,7 ＠＠ if (NILP (list)) { - Lisp_Object args[] = { list_start, make_int (char_count) }; + Lisp_Object args[] = { list_start, make_fixnum (char_count) }; check_sequence_range (orig_list, list_start, list_end, Fplus (countof (args), args)); } ＠＠ -9796,14 +9796,14 ＠＠ if (string_data == XSTRING_DATA (string) + XSTRING_LENGTH (string)) { check_sequence_range (string, string_start, string_end, - make_int (char_count)); + make_fixnum (char_count)); } if ((NILP (string_end) ? string_offset < string_len : string_starting < string_ending) || (NILP (list_end) ? !NILP (list) : list_starting < list_ending)) { - return make_integer (return_list_index ? XINT (list_start) + char_count : + return make_integer (return_list_index ? XFIXNUM (list_start) + char_count : char_count); } ＠＠ -9825,16 +9825,16 ＠＠ Lisp_Object orig_list = list; struct gcpro gcpro1; - list_ending = INTP (list_end) ? XINT (list_end) : 1 + EMACS_INT_MAX; - list_starting = INTP (list_start) ? XINT (list_start) : 1 + EMACS_INT_MAX; - - array_ending = INTP (array_end) ? XINT (array_end) : 1 + EMACS_INT_MAX; - array_starting = INTP (array_start) ? XINT (array_start) : 1 + EMACS_INT_MAX; - array_len = XINT (Flength (array)); + list_ending = FIXNUMP (list_end) ? XFIXNUM (list_end) : 1 + MOST_POSITIVE_FIXNUM; + list_starting = FIXNUMP (list_start) ? XFIXNUM (list_start) : 1 + MOST_POSITIVE_FIXNUM; + + array_ending = FIXNUMP (array_end) ? XFIXNUM (array_end) : 1 + MOST_POSITIVE_FIXNUM; + array_starting = FIXNUMP (array_start) ? XFIXNUM (array_start) : 1 + MOST_POSITIVE_FIXNUM; + array_len = XFIXNUM (Flength (array)); array_ending = min (array_ending, array_len); - check_sequence_range (array, array_start, array_end, make_int (array_len)); + check_sequence_range (array, array_start, array_end, make_fixnum (array_len)); if (!ZEROP (list_start)) { ＠＠ -9858,16 +9858,16 ＠＠ if (return_list_index) { if (check_match (test, key, CONSP (list) ? XCAR (list) : Fcar (list), - Faref (array, make_int (array_starting))) + Faref (array, make_fixnum (array_starting))) != test_not_unboundp) { UNGCPRO; - return make_integer (XINT (list_start) + ii); + return make_integer (XFIXNUM (list_start) + ii); } } else { - if (check_match (test, key, Faref (array, make_int (array_starting)), + if (check_match (test, key, Faref (array, make_fixnum (array_starting)), CONSP (list) ? XCAR (list) : Fcar (list)) != test_not_unboundp) { ＠＠ -9886,7 +9886,7 ＠＠ if (NILP (list)) { - Lisp_Object args[] = { list_start, make_int (ii) }; + Lisp_Object args[] = { list_start, make_fixnum (ii) }; check_sequence_range (orig_list, list_start, list_end, Fplus (countof (args), args)); } ＠＠ -9894,7 +9894,7 ＠＠ if (array_starting < array_ending || (NILP (list_end) ? !NILP (list) : list_starting < list_ending)) { - return make_integer (return_list_index ? XINT (list_start) + ii : + return make_integer (return_list_index ? XFIXNUM (list_start) + ii : array_starting); } ＠＠ -9916,15 +9916,15 ＠＠ Elemcount string_starting, string_ending; Lisp_Object character; - array_starting = INTP (array_start) ? XINT (array_start) : 1 + EMACS_INT_MAX; - array_ending = INTP (array_end) ? XINT (array_end) : 1 + EMACS_INT_MAX; - array_length = XINT (Flength (array)); - check_sequence_range (array, array_start, array_end, make_int (array_length)); + array_starting = FIXNUMP (array_start) ? XFIXNUM (array_start) : 1 + MOST_POSITIVE_FIXNUM; + array_ending = FIXNUMP (array_end) ? XFIXNUM (array_end) : 1 + MOST_POSITIVE_FIXNUM; + array_length = XFIXNUM (Flength (array)); + check_sequence_range (array, array_start, array_end, make_fixnum (array_length)); array_ending = min (array_ending, array_length); - string_ending = INTP (string_end) ? XINT (string_end) : 1 + EMACS_INT_MAX; + string_ending = FIXNUMP (string_end) ? XFIXNUM (string_end) : 1 + MOST_POSITIVE_FIXNUM; string_starting - = INTP (string_start) ? XINT (string_start) : 1 + EMACS_INT_MAX; + = FIXNUMP (string_start) ? XFIXNUM (string_start) : 1 + MOST_POSITIVE_FIXNUM; while (char_count < string_starting && string_offset < string_len) { ＠＠ -9941,7 +9941,7 ＠＠ if (return_string_index) { if (check_match (test, key, character, - Faref (array, make_int (array_starting))) + Faref (array, make_fixnum (array_starting))) != test_not_unboundp) { return make_integer (char_count); ＠＠ -9950,11 +9950,11 ＠＠ else { if (check_match (test, key, - Faref (array, make_int (array_starting)), + Faref (array, make_fixnum (array_starting)), character) != test_not_unboundp) { - return make_integer (XINT (array_start) + char_count); + return make_integer (XFIXNUM (array_start) + char_count); } } ＠＠ -9976,7 +9976,7 ＠＠ if (string_data == XSTRING_DATA (string) + XSTRING_LENGTH (string)) { check_sequence_range (string, string_start, string_end, - make_int (char_count)); + make_fixnum (char_count)); } if ((NILP (string_end) ? ＠＠ -9984,7 +9984,7 ＠＠ (NILP (array_end) ? !NILP (array) : array_starting < array_ending)) { return make_integer (return_string_index ? char_count : - XINT (array_start) + char_count); + XFIXNUM (array_start) + char_count); } return Qnil; ＠＠ -10008,13 +10008,13 ＠＠ Elemcount char_count2 = 0, string2_starting, string2_ending; Lisp_Object character1, character2; - string1_ending = INTP (string1_end) ? XINT (string1_end) : 1 + EMACS_INT_MAX; + string1_ending = FIXNUMP (string1_end) ? XFIXNUM (string1_end) : 1 + MOST_POSITIVE_FIXNUM; string1_starting - = INTP (string1_start) ? XINT (string1_start) : 1 + EMACS_INT_MAX; + = FIXNUMP (string1_start) ? XFIXNUM (string1_start) : 1 + MOST_POSITIVE_FIXNUM; string2_starting - = INTP (string2_start) ? XINT (string2_start) : 1 + EMACS_INT_MAX; - string2_ending = INTP (string2_end) ? XINT (string2_end) : 1 + EMACS_INT_MAX; + = FIXNUMP (string2_start) ? XFIXNUM (string2_start) : 1 + MOST_POSITIVE_FIXNUM; + string2_ending = FIXNUMP (string2_end) ? XFIXNUM (string2_end) : 1 + MOST_POSITIVE_FIXNUM; while (char_count1 < string1_starting && string1_offset < string1_len) { ＠＠ -10071,13 +10071,13 ＠＠ if (string1_data == XSTRING_DATA (string1) + XSTRING_LENGTH (string1)) { check_sequence_range (string1, string1_start, string1_end, - make_int (char_count1)); + make_fixnum (char_count1)); } if (string2_data == XSTRING_DATA (string2) + XSTRING_LENGTH (string2)) { check_sequence_range (string2, string2_start, string2_end, - make_int (char_count2)); + make_fixnum (char_count2)); } if ((!NILP (string1_end) && string1_starting < string1_ending) || ＠＠ -10104,24 +10104,24 ＠＠ Lisp_Object test, Lisp_Object key, Boolint UNUSED (return_array1_index)) { - Elemcount len1 = XINT (Flength (array1)), len2 = XINT (Flength (array2)); - Elemcount ending1 = EMACS_INT_MAX, ending2 = EMACS_INT_MAX; + Elemcount len1 = XFIXNUM (Flength (array1)), len2 = XFIXNUM (Flength (array2)); + Elemcount ending1 = MOST_POSITIVE_FIXNUM, ending2 = MOST_POSITIVE_FIXNUM; Elemcount starting1, starting2; - check_sequence_range (array1, start1, end1, make_int (len1)); - check_sequence_range (array2, start2, end2, make_int (len2)); - - starting1 = INTP (start1) ? XINT (start1) : 1 + EMACS_INT_MAX; - starting2 = INTP (start2) ? XINT (start2) : 1 + EMACS_INT_MAX; + check_sequence_range (array1, start1, end1, make_fixnum (len1)); + check_sequence_range (array2, start2, end2, make_fixnum (len2)); + + starting1 = FIXNUMP (start1) ? XFIXNUM (start1) : 1 + MOST_POSITIVE_FIXNUM; + starting2 = FIXNUMP (start2) ? XFIXNUM (start2) : 1 + MOST_POSITIVE_FIXNUM; if (!NILP (end1)) { - ending1 = INTP (end1) ? XINT (end1) : 1 + EMACS_INT_MAX; + ending1 = FIXNUMP (end1) ? XFIXNUM (end1) : 1 + MOST_POSITIVE_FIXNUM; } if (!NILP (end2)) { - ending2 = INTP (end2) ? XINT (end2) : 1 + EMACS_INT_MAX; + ending2 = FIXNUMP (end2) ? XFIXNUM (end2) : 1 + MOST_POSITIVE_FIXNUM; } ending1 = min (ending1, len1); ＠＠ -10129,8 +10129,8 ＠＠ while (starting1 < ending1 && starting2 < ending2) { - if (check_match (test, key, Faref (array1, make_int (starting1)), - Faref (array2, make_int (starting2))) + if (check_match (test, key, Faref (array1, make_fixnum (starting1)), + Faref (array2, make_fixnum (starting2))) != test_not_unboundp) { return make_integer (starting1); ＠＠ -10296,8 +10296,8 ＠＠ Boolint test_not_unboundp = 1, return_first = 0; check_test_func_t check_test = NULL, check_match = NULL; mismatch_func_t mismatch = NULL; - Elemcount starting1 = 0, ending1 = 1 + EMACS_INT_MAX, starting2 = 0; - Elemcount ending2 = 1 + EMACS_INT_MAX, ii = 0; + Elemcount starting1 = 0, ending1 = 1 + MOST_POSITIVE_FIXNUM, starting2 = 0; + Elemcount ending2 = 1 + MOST_POSITIVE_FIXNUM, ii = 0; Elemcount length1; Lisp_Object object = Qnil; struct gcpro gcpro1, gcpro2; ＠＠ -10311,9 +10311,9 ＠＠ CHECK_KEY_ARGUMENT (key); CHECK_NATNUM (start1); - starting1 = INTP (start1) ? XINT (start1) : 1 + EMACS_INT_MAX; + starting1 = FIXNUMP (start1) ? XFIXNUM (start1) : 1 + MOST_POSITIVE_FIXNUM; CHECK_NATNUM (start2); - starting2 = INTP (start2) ? XINT (start2) : 1 + EMACS_INT_MAX; + starting2 = FIXNUMP (start2) ? XFIXNUM (start2) : 1 + MOST_POSITIVE_FIXNUM; if (!NILP (end1)) { ＠＠ -10321,13 +10321,13 ＠＠ CHECK_NATNUM (end1); check_sequence_range (sequence1, start1, end1, len1); - ending1 = min (XINT (end1), XINT (len1)); + ending1 = min (XFIXNUM (end1), XFIXNUM (len1)); } else { end1 = Flength (sequence1); check_sequence_range (sequence1, start1, end1, end1); - ending1 = XINT (end1); + ending1 = XFIXNUM (end1); } length1 = ending1 - starting1; ＠＠ -10338,13 +10338,13 ＠＠ CHECK_NATNUM (end2); check_sequence_range (sequence2, start2, end2, len2); - ending2 = min (XINT (end2), XINT (len2)); + ending2 = min (XFIXNUM (end2), XFIXNUM (len2)); } else { end2 = Flength (sequence2); check_sequence_range (sequence2, start2, end2, end2); - ending2 = XINT (end2); + ending2 = XFIXNUM (end2); } check_match = get_check_match_function (&test, test_not, Qnil, Qnil, key, ＠＠ -10376,7 +10376,7 ＠＠ while (ii < ending2) { position0 = position (&object, first, sequence2, check_test, - test_not_unboundp, test, key, make_int (ii), + test_not_unboundp, test, key, make_fixnum (ii), end2, Qnil, Qnil, Qsearch); if (NILP (position0)) { ＠＠ -10384,16 +10384,16 ＠＠ return Qnil; } - if (length1 + XINT (position0) <= ending2 && + if (length1 + XFIXNUM (position0) <= ending2 && (return_first ? NILP (mismatch (sequence1, mismatch_start1, end1, sequence2, - make_int (1 + XINT (position0)), - make_int (length1 + XINT (position0)), + make_fixnum (1 + XFIXNUM (position0)), + make_fixnum (length1 + XFIXNUM (position0)), check_match, test_not_unboundp, test, key, 1)) : NILP (mismatch (sequence2, - make_int (1 + XINT (position0)), - make_int (length1 + XINT (position0)), + make_fixnum (1 + XFIXNUM (position0)), + make_fixnum (length1 + XFIXNUM (position0)), sequence1, mismatch_start1, end1, check_match, test_not_unboundp, test, key, 0)))) ＠＠ -10403,7 +10403,7 ＠＠ return position0; } - ii = XINT (position0) + 1; + ii = XFIXNUM (position0) + 1; } UNGCPRO; ＠＠ -10419,7 +10419,7 ＠＠ { position0 = position (&object, last, sequence2, check_test, test_not_unboundp, test, key, start2, - make_int (ii), Qt, Qnil, Qsearch); + make_fixnum (ii), Qt, Qnil, Qsearch); if (NILP (position0)) { ＠＠ -10427,24 +10427,24 ＠＠ return Qnil; } - if (XINT (position0) - length1 + 1 >= starting2 && + if (XFIXNUM (position0) - length1 + 1 >= starting2 && (return_first ? NILP (mismatch (sequence1, start1, mismatch_end1, sequence2, - make_int (XINT (position0) - length1 + 1), - make_int (XINT (position0)), + make_fixnum (XFIXNUM (position0) - length1 + 1), + make_fixnum (XFIXNUM (position0)), check_match, test_not_unboundp, test, key, 1)) : NILP (mismatch (sequence2, - make_int (XINT (position0) - length1 + 1), - make_int (XINT (position0)), + make_fixnum (XFIXNUM (position0) - length1 + 1), + make_fixnum (XFIXNUM (position0)), sequence1, start1, mismatch_end1, check_match, test_not_unboundp, test, key, 0)))) { UNGCPRO; - return make_int (XINT (position0) - length1 + 1); - } - - ii = XINT (position0); + return make_fixnum (XFIXNUM (position0) - length1 + 1); + } + + ii = XFIXNUM (position0); } UNGCPRO; ＠＠ -11099,7 +11099,7 ＠＠ while (loads-- > 0) { Lisp_Object load = (NILP (use_floats) ? - make_int ((int) (100.0 * load_ave[loads])) + make_fixnum ((int) (100.0 * load_ave[loads])) : make_float (load_ave[loads])); ret = Fcons (load, ret); } ＠＠ -11161,14 +11161,14 ＠＠ /* Original definition */ return NILP (Fmemq (fexp, Vfeatures)) ? Qnil : Qt; } - else if (INTP (fexp) || FLOATP (fexp)) + else if (FIXNUMP (fexp) || FLOATP (fexp)) { double d = extract_float (fexp); if (featurep_emacs_version == 0.0) { - featurep_emacs_version = XINT (Vemacs_major_version) + - (XINT (Vemacs_minor_version) / 100.0); + featurep_emacs_version = XFIXNUM (Vemacs_major_version) + + (XFIXNUM (Vemacs_minor_version) / 100.0); } return featurep_emacs_version >= d ? Qt : Qnil; } ＠＠ -11459,7 +11459,7 ＠＠ break; if (ec == '=') base64_conversion_error ("Illegal `=' character while decoding base64", - make_int (streampos)); + make_fixnum (streampos)); value = base64_char_to_value[ec] << 18; /* Process second byte of a quadruplet. */ ＠＠ -11469,7 +11469,7 ＠＠ Qunbound); if (ec == '=') base64_conversion_error ("Illegal `=' character while decoding base64", - make_int (streampos)); + make_fixnum (streampos)); value |= base64_char_to_value[ec] << 12; STORE_BYTE (e, value >> 16, ccnt); ＠＠ -11488,7 +11488,7 ＠＠ if (ec != '=') base64_conversion_error ("Padding `=' expected but not found while decoding base64", - make_int (streampos)); + make_fixnum (streampos)); continue; } ＠＠ -11561,7 +11561,7 ＠＠ BUF_SET_PT (buf, begv); /* We return the length of the encoded text. */ - return make_int (encoded_length); + return make_fixnum (encoded_length); } DEFUN ("base64-encode-string", Fbase64_encode_string, 1, 2, 0, /* ＠＠ -11635,7 +11635,7 ＠＠ if (old_pt >= begv && old_pt < zv) BUF_SET_PT (buf, begv); - return make_int (cc_decoded_length); + return make_fixnum (cc_decoded_length); } DEFUN ("base64-decode-string", Fbase64_decode_string, 1, 1, 0, /* diff -r a0e81357194e -r 56144c8593a8 src/font-lock.c --- a/src/font-lock.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/font-lock.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -265,7 +265,7 ＠＠ if (NILP (retval)) return BUF_ZV (buf); else - return XINT (retval); + return XFIXNUM (retval); } /* Set up context_cache for attempting to determine the syntactic context ＠＠ -741,7 +741,7 ＠＠ /* This function can GC */ struct buffer *buf = decode_buffer (buffer, 0); find_context (buf, BUF_PT (buf)); - return make_int (context_cache.depth); + return make_fixnum (context_cache.depth); } ＠＠ -819,10 +819,10 ＠＠ continue; /* Make sure not to pass in values that are outside the actual bounds of this function. */ - call4_in_buffer (buf, function, make_int (max (s, estart)), - make_int (eend == e ? e : eend - 1), + call4_in_buffer (buf, function, make_fixnum (max (s, estart)), + make_fixnum (eend == e ? e : eend - 1), context_to_symbol (this_context), - make_int (edepth)); + make_fixnum (edepth)); } DONE_LABEL: UNGCPRO; diff -r a0e81357194e -r 56144c8593a8 src/font-mgr.c --- a/src/font-mgr.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/font-mgr.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -296,9 +296,9 ＠＠ FcChar8 *str = (FcChar8 *) extract_fcapi_string (value); res = FcPatternAddString (fcpat, obj, str); } - else if (INTP (value)) + else if (FIXNUMP (value)) { - res = FcPatternAddInteger (fcpat, obj, XINT (value)); + res = FcPatternAddInteger (fcpat, obj, XFIXNUM (value)); } else if (FLOATP (value)) { ＠＠ -438,10 +438,10 ＠＠ { #ifdef HAVE_BIGNUM check_integer_range (id, Qzero, make_integer (INT_MAX)); - int_id = BIGNUMP (id) ? bignum_to_int (XBIGNUM_DATA (id)) : XINT (id); + int_id = BIGNUMP (id) ? bignum_to_int (XBIGNUM_DATA (id)) : XFIXNUM (id); #else - check_integer_range (id, Qzero, make_integer (EMACS_INT_MAX)); - int_id = XINT (id); + check_integer_range (id, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); + int_id = XFIXNUM (id); #endif } if (!NILP (type)) CHECK_SYMBOL (type); ＠＠ -458,7 +458,7 ＠＠ { case FcTypeInteger: return ((!NILP (type) && !EQ (type, Qinteger)) - ? Qfc_result_type_mismatch : make_int (fc_value.u.i)); + ? Qfc_result_type_mismatch : make_fixnum (fc_value.u.i)); case FcTypeDouble: return ((!NILP (type) && !EQ (type, intern ("double")) && !EQ (type, Qfloat)) ＠＠ -474,13 +474,13 ＠＠ return Qfc_result_type_mismatch; /* #### unimplemented return ((!NILP (type) && !EQ (type, intern ("matrix"))) - ? Qfc_result_type_mismatch : make_int (fc_value.u.m)); + ? Qfc_result_type_mismatch : make_fixnum (fc_value.u.m)); */ case FcTypeCharSet: return Qfc_result_type_mismatch; /* #### unimplemented return ((!NILP (type) && !EQ (type, intern ("charset"))) - ? Qfc_result_type_mismatch : make_int (fc_value.u.c)); + ? Qfc_result_type_mismatch : make_fixnum (fc_value.u.c)); */ } case FcResultTypeMismatch: ＠＠ -747,7 +747,7 ＠＠ (config)) { CHECK_FC_CONFIG (config); - return make_int (FcConfigGetRescanInterval (XFC_CONFIG_PTR (config))); + return make_fixnum (FcConfigGetRescanInterval (XFC_CONFIG_PTR (config))); } DEFUN ("fc-config-set-rescan-interval", Ffc_config_set_rescan_interval, 2, 2, 0, /* ＠＠ -758,9 +758,9 ＠＠ (config, rescan_interval)) { CHECK_FC_CONFIG (config); - CHECK_INT (rescan_interval); + CHECK_FIXNUM (rescan_interval); if (FcConfigSetRescanInterval (XFC_CONFIG_PTR (config), - XINT (rescan_interval)) == FcFalse) + XFIXNUM (rescan_interval)) == FcFalse) signal_error (Qio_error, "FcConfigSetRescanInverval barfed", intern ("fc-config-set-rescan-interval")); return Qnil; ＠＠ -1137,7 +1137,7 ＠＠ It's probably not a disaster if `(> (fc-get-version) fc-version)'. */ ()) { - return make_int (FcGetVersion ()); + return make_fixnum (FcGetVersion ()); } DEFUN ("fc-init-reinitialize", Ffc_init_reinitialize, 0, 0, 0, /* diff -r a0e81357194e -r 56144c8593a8 src/fontcolor-gtk.c --- a/src/fontcolor-gtk.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/fontcolor-gtk.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -196,9 +196,9 ＠＠ gtk_color_instance_rgb_components (struct Lisp_Color_Instance *c) { GdkColor *color = COLOR_INSTANCE_GTK_COLOR (c); - return (list3 (make_int (color->red), - make_int (color->green), - make_int (color->blue))); + return (list3 (make_fixnum (color->red), + make_fixnum (color->green), + make_fixnum (color->blue))); } static int diff -r a0e81357194e -r 56144c8593a8 src/fontcolor-msw.c --- a/src/fontcolor-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/fontcolor-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1425,9 +1425,9 ＠＠ mswindows_color_instance_rgb_components (Lisp_Color_Instance *c) { COLORREF color = COLOR_INSTANCE_MSWINDOWS_COLOR (c); - return list3 (make_int (GetRValue (color) * 257), - make_int (GetGValue (color) * 257), - make_int (GetBValue (color) * 257)); + return list3 (make_fixnum (GetRValue (color) * 257), + make_fixnum (GetGValue (color) * 257), + make_fixnum (GetBValue (color) * 257)); } static int diff -r a0e81357194e -r 56144c8593a8 src/fontcolor-x.c --- a/src/fontcolor-x.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/fontcolor-x.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -179,9 +179,9 ＠＠ x_color_instance_rgb_components (Lisp_Color_Instance *c) { XColor color = COLOR_INSTANCE_X_COLOR (c); - return (list3 (make_int (color.red), - make_int (color.green), - make_int (color.blue))); + return (list3 (make_fixnum (color.red), + make_fixnum (color.green), + make_fixnum (color.blue))); } static int ＠＠ -862,7 +862,7 ＠＠ : Qnil); } else - value = make_int (props [i].card32); + value = make_fixnum (props [i].card32); if (namestrext) XFree (namestrext); result = Fcons (Fcons (name, value), result); } ＠＠ -880,9 +880,9 ＠＠ patternext = LISP_STRING_TO_EXTERNAL (pattern, Qx_font_name_encoding); - if (!NILP(maxnumber) && INTP(maxnumber)) + if (!NILP(maxnumber) && FIXNUMP(maxnumber)) { - max_number = XINT(maxnumber); + max_number = XFIXNUM(maxnumber); } names = XListFonts (DEVICE_X_DISPLAY (XDEVICE (device)), diff -r a0e81357194e -r 56144c8593a8 src/fontcolor.c --- a/src/fontcolor.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/fontcolor.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -452,7 +452,7 ＠＠ (font_instance)) { CHECK_FONT_INSTANCE (font_instance); - return make_int (XFONT_INSTANCE (font_instance)->ascent); + return make_fixnum (XFONT_INSTANCE (font_instance)->ascent); } DEFUN ("font-instance-descent", Ffont_instance_descent, 1, 1, 0, /* ＠＠ -465,7 +465,7 ＠＠ (font_instance)) { CHECK_FONT_INSTANCE (font_instance); - return make_int (XFONT_INSTANCE (font_instance)->descent); + return make_fixnum (XFONT_INSTANCE (font_instance)->descent); } DEFUN ("font-instance-width", Ffont_instance_width, 1, 1, 0, /* ＠＠ -475,7 +475,7 ＠＠ (font_instance)) { CHECK_FONT_INSTANCE (font_instance); - return make_int (XFONT_INSTANCE (font_instance)->width); + return make_fixnum (XFONT_INSTANCE (font_instance)->width); } DEFUN ("font-instance-proportional-p", Ffont_instance_proportional_p, 1, 1, 0, /* diff -r a0e81357194e -r 56144c8593a8 src/frame-gtk.c --- a/src/frame-gtk.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/frame-gtk.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -245,8 +245,8 ＠＠ if (!GET_GTK_WIDGET_WINDOW(shell)) return Qzero; gdk_window_get_deskrelative_origin (GET_GTK_WIDGET_WINDOW (shell), &x, &y); - if (EQ (Qleft, property)) return make_int (x); - if (EQ (Qtop, property)) return make_int (y); + if (EQ (Qleft, property)) return make_fixnum (x); + if (EQ (Qtop, property)) return make_fixnum (y); } if (EQ (Qshell_widget, property)) { ＠＠ -300,8 +300,8 ＠＠ else gdk_window_get_deskrelative_origin (GET_GTK_WIDGET_WINDOW (shell), &x, &y); - props = cons3 (Qtop, make_int (y), props); - props = cons3 (Qleft, make_int (x), props); + props = cons3 (Qtop, make_fixnum (y), props); + props = cons3 (Qleft, make_fixnum (x), props); return props; } ＠＠ -428,30 +428,30 ＠＠ } else if (EQ (prop, Qwidth)) { - CHECK_INT (val); - width = XINT (val); + CHECK_FIXNUM (val); + width = XFIXNUM (val); width_specified_p = TRUE; continue; } else if (EQ (prop, Qheight)) { - CHECK_INT (val); - height = XINT (val); + CHECK_FIXNUM (val); + height = XFIXNUM (val); height_specified_p = TRUE; continue; } /* Further kludge the x/y. */ else if (EQ (prop, Qx)) { - CHECK_INT (val); - x = (gint) XINT (val); + CHECK_FIXNUM (val); + x = (gint) XFIXNUM (val); x_position_specified_p = TRUE; continue; } else if (EQ (prop, Qy)) { - CHECK_INT (val); - y = (gint) XINT (val); + CHECK_FIXNUM (val); + y = (gint) XFIXNUM (val); y_position_specified_p = TRUE; continue; } ＠＠ -491,13 +491,13 ＠＠ { Lisp_Object frame = wrap_frame (f); - Fset_frame_size (frame, make_int (width), make_int (height), Qnil); + Fset_frame_size (frame, make_fixnum (width), make_fixnum (height), Qnil); } if (position_specified_p) { Lisp_Object frame = wrap_frame (f); - Fset_frame_position (frame, make_int (x), make_int (y)); + Fset_frame_position (frame, make_fixnum (x), make_fixnum (y)); } } } diff -r a0e81357194e -r 56144c8593a8 src/frame-impl.h --- a/src/frame-impl.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/frame-impl.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -472,10 +472,10 ＠＠ #ifdef HAVE_SCROLLBARS #define FRAME_SCROLLBAR_WIDTH(f) \ (NILP ((f)->vertical_scrollbar_visible_p) ? \ - 0 : XINT ((f)->scrollbar_width)) + 0 : XFIXNUM ((f)->scrollbar_width)) #define FRAME_SCROLLBAR_HEIGHT(f) \ (NILP ((f)->horizontal_scrollbar_visible_p) ? \ - 0 : XINT ((f)->scrollbar_height)) + 0 : XFIXNUM ((f)->scrollbar_height)) #else #define FRAME_SCROLLBAR_WIDTH(f) 0 #define FRAME_SCROLLBAR_HEIGHT(f) 0 ＠＠ -558,11 +558,11 ＠＠ #define FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE(f, pos) \ (!NILP((f)->toolbar_buttons[pos]) && !NILP ((f)->toolbar_visible_p[pos])) #define FRAME_RAW_THEORETICAL_TOOLBAR_SIZE(f, pos) \ - (!NILP ((f)->toolbar_buttons[pos]) && INTP((f)->toolbar_size[pos]) ? \ - (XINT ((f)->toolbar_size[pos])) : 0) + (!NILP ((f)->toolbar_buttons[pos]) && FIXNUMP((f)->toolbar_size[pos]) ? \ + (XFIXNUM ((f)->toolbar_size[pos])) : 0) #define FRAME_RAW_THEORETICAL_TOOLBAR_BORDER_WIDTH(f, pos) \ - (!NILP ((f)->toolbar_buttons[pos]) && INTP((f)->toolbar_border_width[pos]) ? \ - (XINT ((f)->toolbar_border_width[pos])) : 0) + (!NILP ((f)->toolbar_buttons[pos]) && FIXNUMP((f)->toolbar_border_width[pos]) ? \ + (XFIXNUM ((f)->toolbar_border_width[pos])) : 0) #else #define FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE(f, pos) 0 #define FRAME_RAW_THEORETICAL_TOOLBAR_SIZE(f, pos) 0 ＠＠ -606,15 +606,15 ＠＠ (HAS_FRAMEMETH_P (f, initialize_frame_toolbars) \ && !NILP (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_visible_p[pos])) #define FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH(f, pos) \ - ((INTP (XWINDOW \ + ((FIXNUMP (XWINDOW \ (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_border_width[pos])) ? \ - (XINT (XWINDOW \ + (XFIXNUM (XWINDOW \ (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_border_width[pos])) \ : 0) #define FRAME_RAW_REAL_TOOLBAR_SIZE(f, pos) \ - ((INTP (XWINDOW \ + ((FIXNUMP (XWINDOW \ (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_size[pos])) ? \ - (XINT (XWINDOW \ + (XFIXNUM (XWINDOW \ (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_size[pos])) : 0) #define FRAME_REAL_TOOLBAR(f, pos) \ (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar[pos]) diff -r a0e81357194e -r 56144c8593a8 src/frame-msw.c --- a/src/frame-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/frame-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -155,19 +155,19 ＠＠ left = Fplist_get (props, Qleft, Qnil); if (!NILP (left)) - CHECK_INT (left); + CHECK_FIXNUM (left); top = Fplist_get (props, Qtop, Qnil); if (!NILP (top)) - CHECK_INT (top); + CHECK_FIXNUM (top); width = Fplist_get (props, Qwidth, Qnil); if (!NILP (width)) - CHECK_INT (width); + CHECK_FIXNUM (width); height = Fplist_get (props, Qheight, Qnil); if (!NILP (height)) - CHECK_INT (height); + CHECK_FIXNUM (height); #ifdef NEW_GC f->frame_data = XMSWINDOWS_FRAME (ALLOC_NORMAL_LISP_OBJECT (mswindows_frame)); ＠＠ -176,12 +176,12 ＠＠ #endif /* not NEW_GC */ FRAME_MSWINDOWS_TARGET_RECT (f) = xnew_and_zero (XEMACS_RECT_WH); - FRAME_MSWINDOWS_TARGET_RECT (f)->left = NILP (left) ? -1 : abs (XINT (left)); - FRAME_MSWINDOWS_TARGET_RECT (f)->top = NILP (top) ? -1 : abs (XINT (top)); + FRAME_MSWINDOWS_TARGET_RECT (f)->left = NILP (left) ? -1 : abs (XFIXNUM (left)); + FRAME_MSWINDOWS_TARGET_RECT (f)->top = NILP (top) ? -1 : abs (XFIXNUM (top)); FRAME_MSWINDOWS_TARGET_RECT (f)->width = NILP (width) ? -1 : - abs (XINT (width)); + abs (XFIXNUM (width)); FRAME_MSWINDOWS_TARGET_RECT (f)->height = NILP (height) ? -1 : - abs (XINT (height)); + abs (XFIXNUM (height)); /* Misc frame stuff */ FRAME_MSWINDOWS_MENU_HASH_TABLE (f) = Qnil; ＠＠ -613,7 +613,7 ＠＠ { RECT rc; GetWindowRect (FRAME_MSWINDOWS_HANDLE (f), &rc); - return make_int (EQ (Qtop, property) ? rc.top : rc.left); + return make_fixnum (EQ (Qtop, property) ? rc.top : rc.left); } if (EQ (Qwindow_id, property)) return mswindows_window_id (wrap_frame (f)); ＠＠ -640,8 +640,8 ＠＠ RECT rc; GetWindowRect (FRAME_MSWINDOWS_HANDLE (f), &rc); - props = cons3 (Qtop, make_int (rc.top), props); - props = cons3 (Qleft, make_int (rc.left), props); + props = cons3 (Qtop, make_fixnum (rc.top), props); + props = cons3 (Qleft, make_fixnum (rc.left), props); props = cons3 (Qwindow_id, mswindows_window_id (wrap_frame (f)), props); return props; ＠＠ -683,26 +683,26 ＠＠ } else if (EQ (prop, Qwidth)) { - CHECK_INT (val); - width = XINT (val); + CHECK_FIXNUM (val); + width = XFIXNUM (val); width_specified_p = TRUE; } else if (EQ (prop, Qheight)) { - CHECK_INT (val); - height = XINT (val); + CHECK_FIXNUM (val); + height = XFIXNUM (val); height_specified_p = TRUE; } else if (EQ (prop, Qleft)) { - CHECK_INT (val); - x = XINT (val); + CHECK_FIXNUM (val); + x = XFIXNUM (val); x_specified_p = TRUE; } else if (EQ (prop, Qtop)) { - CHECK_INT (val); - y = XINT (val); + CHECK_FIXNUM (val); + y = XFIXNUM (val); y_specified_p = TRUE; } } ＠＠ -1039,13 +1039,13 ＠＠ msprinter_frame_property (struct frame *f, Lisp_Object property) { if (EQ (Qleft_margin, property)) - return make_int (FRAME_MSPRINTER_LEFT_MARGIN (f)); + return make_fixnum (FRAME_MSPRINTER_LEFT_MARGIN (f)); else if (EQ (Qtop_margin, property)) - return make_int (FRAME_MSPRINTER_TOP_MARGIN (f)); + return make_fixnum (FRAME_MSPRINTER_TOP_MARGIN (f)); if (EQ (Qright_margin, property)) - return make_int (FRAME_MSPRINTER_RIGHT_MARGIN (f)); + return make_fixnum (FRAME_MSPRINTER_RIGHT_MARGIN (f)); else if (EQ (Qbottom_margin, property)) - return make_int (FRAME_MSPRINTER_BOTTOM_MARGIN (f)); + return make_fixnum (FRAME_MSPRINTER_BOTTOM_MARGIN (f)); else return Qunbound; } ＠＠ -1063,13 +1063,13 ＠＠ { Lisp_Object props = Qnil; props = cons3 (Qbottom_margin, - make_int (FRAME_MSPRINTER_BOTTOM_MARGIN (f)), props); + make_fixnum (FRAME_MSPRINTER_BOTTOM_MARGIN (f)), props); props = cons3 (Qright_margin, - make_int (FRAME_MSPRINTER_RIGHT_MARGIN (f)), props); + make_fixnum (FRAME_MSPRINTER_RIGHT_MARGIN (f)), props); props = cons3 (Qtop_margin, - make_int (FRAME_MSPRINTER_TOP_MARGIN (f)), props); + make_fixnum (FRAME_MSPRINTER_TOP_MARGIN (f)), props); props = cons3 (Qleft_margin, - make_int (FRAME_MSPRINTER_LEFT_MARGIN (f)), props); + make_fixnum (FRAME_MSPRINTER_LEFT_MARGIN (f)), props); return props; } ＠＠ -1095,10 +1095,10 ＠＠ check_integer_range (val, Qzero, make_integer (INT_MAX)); FRAME_MSPRINTER_CHARWIDTH (f) = BIGNUMP (val) ? bignum_to_int (XBIGNUM_DATA (val)) : - XINT (val); + XFIXNUM (val); #else CHECK_NATNUM (val); - FRAME_MSPRINTER_CHARWIDTH (f) = XINT (val); + FRAME_MSPRINTER_CHARWIDTH (f) = XFIXNUM (val); #endif } } ＠＠ -1111,10 +1111,10 ＠＠ check_integer_range (val, Qzero, make_integer (INT_MAX)); FRAME_MSPRINTER_CHARHEIGHT (f) = BIGNUMP (val) ? bignum_to_int (XBIGNUM_DATA (val)) : - XINT (val); + XFIXNUM (val); #else CHECK_NATNUM (val); - FRAME_MSPRINTER_CHARHEIGHT (f) = XINT (val); + FRAME_MSPRINTER_CHARHEIGHT (f) = XFIXNUM (val); #endif } } ＠＠ -1125,10 +1125,10 ＠＠ check_integer_range (val, Qzero, make_integer (INT_MAX)); FRAME_MSPRINTER_LEFT_MARGIN (f) = BIGNUMP (val) ? bignum_to_int (XBIGNUM_DATA (val)) : - XINT (val); + XFIXNUM (val); #else CHECK_NATNUM (val); - FRAME_MSPRINTER_LEFT_MARGIN (f) = XINT (val); + FRAME_MSPRINTER_LEFT_MARGIN (f) = XFIXNUM (val); #endif } else if (EQ (prop, Qtop_margin)) ＠＠ -1138,10 +1138,10 ＠＠ check_integer_range (val, Qzero, make_integer (INT_MAX)); FRAME_MSPRINTER_TOP_MARGIN (f) = BIGNUMP (val) ? bignum_to_int (XBIGNUM_DATA (val)) : - XINT (val); + XFIXNUM (val); #else CHECK_NATNUM (val); - FRAME_MSPRINTER_TOP_MARGIN (f) = XINT (val); + FRAME_MSPRINTER_TOP_MARGIN (f) = XFIXNUM (val); #endif } else if (EQ (prop, Qright_margin)) ＠＠ -1151,10 +1151,10 ＠＠ check_integer_range (val, Qzero, make_integer (INT_MAX)); FRAME_MSPRINTER_RIGHT_MARGIN (f) = BIGNUMP (val) ? bignum_to_int (XBIGNUM_DATA (val)) : - XINT (val); + XFIXNUM (val); #else CHECK_NATNUM (val); - FRAME_MSPRINTER_RIGHT_MARGIN (f) = XINT (val); + FRAME_MSPRINTER_RIGHT_MARGIN (f) = XFIXNUM (val); #endif } else if (EQ (prop, Qbottom_margin)) ＠＠ -1164,10 +1164,10 ＠＠ check_integer_range (val, Qzero, make_integer (INT_MAX)); FRAME_MSPRINTER_BOTTOM_MARGIN (f) = BIGNUMP (val) ? bignum_to_int (XBIGNUM_DATA (val)) : - XINT (val); + XFIXNUM (val); #else CHECK_NATNUM (val); - FRAME_MSPRINTER_BOTTOM_MARGIN (f) = XINT (val); + FRAME_MSPRINTER_BOTTOM_MARGIN (f) = XFIXNUM (val); #endif } } diff -r a0e81357194e -r 56144c8593a8 src/frame-tty.c --- a/src/frame-tty.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/frame-tty.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -187,7 +187,7 ＠＠ tty_frame_property (struct frame *f, Lisp_Object property) { if (EQ (Qframe_number, property)) - return make_int (f->order_count); + return make_fixnum (f->order_count); return Qunbound; } ＠＠ -203,7 +203,7 ＠＠ { Lisp_Object props = Qnil; - props = cons3 (Qframe_number, make_int (f->order_count), props); + props = cons3 (Qframe_number, make_fixnum (f->order_count), props); return props; } diff -r a0e81357194e -r 56144c8593a8 src/frame-x.c --- a/src/frame-x.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/frame-x.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -582,17 +582,17 ＠＠ if (!XtWindow(shell)) return Qzero; x_get_top_level_position (XtDisplay (shell), XtWindow (shell), &x, &y); - if (EQ (Qleft, property)) return make_int (x); - if (EQ (Qtop, property)) return make_int (y); + if (EQ (Qleft, property)) return make_fixnum (x); + if (EQ (Qtop, property)) return make_fixnum (y); } if (EQ (Qborder_width, property)) - return make_int (w->core.border_width); + return make_fixnum (w->core.border_width); if (EQ (Qinternal_border_width, property)) - return make_int (w->emacs_frame.internal_border_width); + return make_fixnum (w->emacs_frame.internal_border_width); if (EQ (Qborder_color, property)) return color_to_string (gw, w->core.border_pixel); if (EQ (Qinter_line_space, property)) - return make_int (w->emacs_frame.interline); + return make_fixnum (w->emacs_frame.interline); if (EQ (Qwindow_id, property)) return Fx_window_id (wrap_frame (f)); ＠＠ -622,21 +622,21 ＠＠ Position x, y; props = cons3 (Qwindow_id, Fx_window_id (wrap_frame (f)), props); - props = cons3 (Qinter_line_space, make_int (w->emacs_frame.interline), props); + props = cons3 (Qinter_line_space, make_fixnum (w->emacs_frame.interline), props); props = cons3 (Qborder_color, color_to_string (gw, w->core.border_pixel), props); props = cons3 (Qinternal_border_width, - make_int (w->emacs_frame.internal_border_width), props); - props = cons3 (Qborder_width, make_int (w->core.border_width), props); + make_fixnum (w->emacs_frame.internal_border_width), props); + props = cons3 (Qborder_width, make_fixnum (w->core.border_width), props); if (!XtWindow(shell)) x = y = 0; else x_get_top_level_position (XtDisplay (shell), XtWindow (shell), &x, &y); - props = cons3 (Qtop, make_int (y), props); - props = cons3 (Qleft, make_int (x), props); + props = cons3 (Qtop, make_fixnum (y), props); + props = cons3 (Qleft, make_fixnum (x), props); return props; } ＠＠ -789,7 +789,7 ＠＠ } else XtVaSetValues (w, XtVaTypedArg, extprop, XtRInt, - XINT (val), sizeof (int), + XFIXNUM (val), sizeof (int), NULL); } else if (SYMBOLP (prop)) ＠＠ -826,30 +826,30 ＠＠ instead of pixels. Yuck yuck yuck. */ if (!qxestrcmp_ascii (XSTRING_DATA (str), "width")) { - CHECK_INT (val); - width = XINT (val); + CHECK_FIXNUM (val); + width = XFIXNUM (val); width_specified_p = True; continue; } if (!qxestrcmp_ascii (XSTRING_DATA (str), "height")) { - CHECK_INT (val); - height = XINT (val); + CHECK_FIXNUM (val); + height = XFIXNUM (val); height_specified_p = True; continue; } /* Further kludge the x/y. */ if (!qxestrcmp_ascii (XSTRING_DATA (str), "x")) { - CHECK_INT (val); - x = (Position) XINT (val); + CHECK_FIXNUM (val); + x = (Position) XFIXNUM (val); x_position_specified_p = True; continue; } if (!qxestrcmp_ascii (XSTRING_DATA (str), "y")) { - CHECK_INT (val); - y = (Position) XINT (val); + CHECK_FIXNUM (val); + y = (Position) XFIXNUM (val); y_position_specified_p = True; continue; } ＠＠ -863,8 +863,8 ＠＠ strext = LISP_STRING_TO_EXTERNAL (str, Qxt_widget_arg_encoding); if (int_p) { - CHECK_INT (val); - Xt_SET_VALUE (w, strext, XINT (val)); + CHECK_FIXNUM (val); + Xt_SET_VALUE (w, strext, XFIXNUM (val)); } else if (EQ (val, Qt)) { ＠＠ -945,14 +945,14 ＠＠ { Lisp_Object frame = wrap_frame (f); - Fset_frame_size (frame, make_int (width), - make_int (height), Qnil); + Fset_frame_size (frame, make_fixnum (width), + make_fixnum (height), Qnil); } if (position_specified_p) { Lisp_Object frame = wrap_frame (f); - Fset_frame_position (frame, make_int (x), make_int (y)); + Fset_frame_position (frame, make_fixnum (x), make_fixnum (y)); } } } diff -r a0e81357194e -r 56144c8593a8 src/frame.c --- a/src/frame.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/frame.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1052,7 +1052,7 ＠＠ first_frame_on_console = (first_frame_on_device && - XINT (Flength (CONSOLE_DEVICE_LIST (XCONSOLE (DEVICE_CONSOLE (d))))) + XFIXNUM (Flength (CONSOLE_DEVICE_LIST (XCONSOLE (DEVICE_CONSOLE (d))))) == 1); /* #### all this calling of frame methods at various odd times ＠＠ -1907,7 +1907,7 ＠＠ /* Call the delete-device-hook and delete-console-hook now if appropriate, before we do any dangerous things -- they too could signal an error. */ - if (XINT (Flength (DEVICE_FRAME_LIST (d))) == 1) + if (XFIXNUM (Flength (DEVICE_FRAME_LIST (d))) == 1) { va_run_hook_with_args (Qdelete_device_hook, 1, device); if (!FRAME_LIVE_P (f)) /* Make sure the delete-device-hook didn't */ ＠＠ -1916,7 +1916,7 ＠＠ return; } - if (XINT (Flength (CONSOLE_DEVICE_LIST (con))) == 1) + if (XFIXNUM (Flength (CONSOLE_DEVICE_LIST (con))) == 1) { va_run_hook_with_args (Qdelete_console_hook, 1, console); if (!FRAME_LIVE_P (f)) /* Make sure the delete-console-hook didn't */ ＠＠ -2276,8 +2276,8 ＠＠ /* Adjust the position to be relative to the window. */ intx -= w->pixel_left; inty -= w->pixel_top; - x = make_int (intx); - y = make_int (inty); + x = make_fixnum (intx); + y = make_fixnum (inty); } } else if (FRAMEP (frame)) ＠＠ -2317,8 +2317,8 ＠＠ &obj1, &obj2); if (res == OVER_TEXT) { - lisp_x = make_int (x); - lisp_y = make_int (y); + lisp_x = make_fixnum (x); + lisp_y = make_fixnum (y); window = wrap_window (w); } } ＠＠ -2371,12 +2371,12 ＠＠ int pix_x, pix_y; CHECK_LIVE_WINDOW (window); - CHECK_INT (x); - CHECK_INT (y); + CHECK_FIXNUM (x); + CHECK_FIXNUM (y); /* Warping the mouse will cause EnterNotify and Focus events under X. */ w = XWINDOW (window); - glyph_to_pixel_translation (w, XINT (x), XINT (y), &pix_x, &pix_y); + glyph_to_pixel_translation (w, XFIXNUM (x), XFIXNUM (y), &pix_x, &pix_y); MAYBE_FRAMEMETH (XFRAME (w->frame), set_mouse_position, (w, pix_x, pix_y)); ＠＠ -2395,12 +2395,12 ＠＠ struct window *w; CHECK_LIVE_WINDOW (window); - CHECK_INT (x); - CHECK_INT (y); + CHECK_FIXNUM (x); + CHECK_FIXNUM (y); /* Warping the mouse will cause EnterNotify and Focus events under X. */ w = XWINDOW (window); - FRAMEMETH (XFRAME (w->frame), set_mouse_position, (w, XINT (x), XINT (y))); + FRAMEMETH (XFRAME (w->frame), set_mouse_position, (w, XFIXNUM (x), XFIXNUM (y))); return Qnil; } ＠＠ -2617,7 +2617,7 ＠＠ (frame)) { CHECK_PRINTER_FRAME (frame); - return make_int (FRAME_PAGENUMBER (XFRAME (frame))); + return make_fixnum (FRAME_PAGENUMBER (XFRAME (frame))); } DEFUN ("print-job-eject-page", Fprint_job_eject_page, 1, 1, 0, /* ＠＠ -2663,7 +2663,7 ＠＠ */ (frame)) { - return make_int (decode_frame (frame)->modiff); + return make_fixnum (decode_frame (frame)->modiff); } static void ＠＠ -2962,7 +2962,7 ＠＠ { int width, height; get_frame_char_size (f, &width, &height); - return make_int (EQ (Qheight, property) ? height : width); + return make_fixnum (EQ (Qheight, property) ? height : width); } /* NOTE: FSF returns Qnil instead of Qt for FRAME_HAS_MINIBUF_P. ＠＠ -3055,8 +3055,8 ＠＠ { int width, height; get_frame_char_size (f, &width, &height); - result = cons3 (Qwidth , make_int (width), result); - result = cons3 (Qheight, make_int (height), result); + result = cons3 (Qwidth , make_fixnum (width), result); + result = cons3 (Qheight, make_fixnum (height), result); } result = cons3 (Qname, f->name, result); ＠＠ -3081,7 +3081,7 ＠＠ int width, height; get_frame_new_total_pixel_size (f, &width, &height); - return make_int (height); + return make_fixnum (height); } DEFUN ("frame-displayable-pixel-height", Fframe_displayable_pixel_height, 0, 1, 0, /* ＠＠ -3093,7 +3093,7 ＠＠ int width, height; get_frame_new_displayable_pixel_size (f, &width, &height); - return make_int (height); + return make_fixnum (height); } DEFUN ("frame-pixel-width", Fframe_pixel_width, 0, 1, 0, /* ＠＠ -3105,7 +3105,7 ＠＠ int width, height; get_frame_new_total_pixel_size (f, &width, &height); - return make_int (width); + return make_fixnum (width); } DEFUN ("frame-displayable-pixel-width", Fframe_displayable_pixel_width, 0, 1, 0, /* ＠＠ -3117,7 +3117,7 ＠＠ int width, height; get_frame_new_displayable_pixel_size (f, &width, &height); - return make_int (width); + return make_fixnum (width); } DEFUN ("set-frame-height", Fset_frame_height, 2, 3, 0, /* ＠＠ -3132,9 +3132,9 ＠＠ int cwidth, cheight; int guwidth, guheight; - CHECK_INT (lines); + CHECK_FIXNUM (lines); get_frame_char_size (f, &cwidth, &cheight); - cheight = XINT (lines); + cheight = XFIXNUM (lines); frame_conversion_internal (f, SIZE_CHAR_CELL, cwidth, cheight, SIZE_FRAME_UNIT, &guwidth, &guheight); internal_set_frame_size (f, guwidth, guheight, !NILP (pretend)); ＠＠ -3153,9 +3153,9 ＠＠ int pwidth, pheight; int guwidth, guheight; - CHECK_INT (height); + CHECK_FIXNUM (height); get_frame_new_total_pixel_size (f, &pwidth, &pheight); - pheight = XINT (height); + pheight = XFIXNUM (height); frame_conversion_internal (f, SIZE_TOTAL_PIXEL, pwidth, pheight, SIZE_FRAME_UNIT, &guwidth, &guheight); internal_set_frame_size (f, guwidth, guheight, !NILP (pretend)); ＠＠ -3174,9 +3174,9 ＠＠ int pwidth, pheight; int guwidth, guheight; - CHECK_INT (height); + CHECK_FIXNUM (height); get_frame_new_displayable_pixel_size (f, &pwidth, &pheight); - pheight = XINT (height); + pheight = XFIXNUM (height); frame_conversion_internal (f, SIZE_DISPLAYABLE_PIXEL, pwidth, pheight, SIZE_FRAME_UNIT, &guwidth, &guheight); internal_set_frame_size (f, guwidth, guheight, !NILP (pretend)); ＠＠ -3196,9 +3196,9 ＠＠ int cwidth, cheight; int guwidth, guheight; - CHECK_INT (cols); + CHECK_FIXNUM (cols); get_frame_char_size (f, &cwidth, &cheight); - cwidth = XINT (cols); + cwidth = XFIXNUM (cols); frame_conversion_internal (f, SIZE_CHAR_CELL, cwidth, cheight, SIZE_FRAME_UNIT, &guwidth, &guheight); internal_set_frame_size (f, guwidth, guheight, !NILP (pretend)); ＠＠ -3217,9 +3217,9 ＠＠ int pwidth, pheight; int guwidth, guheight; - CHECK_INT (width); + CHECK_FIXNUM (width); get_frame_new_total_pixel_size (f, &pwidth, &pheight); - pwidth = XINT (width); + pwidth = XFIXNUM (width); frame_conversion_internal (f, SIZE_TOTAL_PIXEL, pwidth, pheight, SIZE_FRAME_UNIT, &guwidth, &guheight); internal_set_frame_size (f, guwidth, guheight, !NILP (pretend)); ＠＠ -3238,9 +3238,9 ＠＠ int pwidth, pheight; int guwidth, guheight; - CHECK_INT (width); + CHECK_FIXNUM (width); get_frame_new_displayable_pixel_size (f, &pwidth, &pheight); - pwidth = XINT (width); + pwidth = XFIXNUM (width); frame_conversion_internal (f, SIZE_DISPLAYABLE_PIXEL, pwidth, pheight, SIZE_FRAME_UNIT, &guwidth, &guheight); internal_set_frame_size (f, guwidth, guheight, !NILP (pretend)); ＠＠ -3258,9 +3258,9 ＠＠ struct frame *f = decode_frame (frame); int guwidth, guheight; - CHECK_INT (cols); - CHECK_INT (rows); - frame_conversion_internal (f, SIZE_CHAR_CELL, XINT (cols), XINT (rows), + CHECK_FIXNUM (cols); + CHECK_FIXNUM (rows); + frame_conversion_internal (f, SIZE_CHAR_CELL, XFIXNUM (cols), XFIXNUM (rows), SIZE_FRAME_UNIT, &guwidth, &guheight); internal_set_frame_size (f, guwidth, guheight, !NILP (pretend)); return wrap_frame (f); ＠＠ -3277,9 +3277,9 ＠＠ struct frame *f = decode_frame (frame); int guwidth, guheight; - CHECK_INT (width); - CHECK_INT (height); - frame_conversion_internal (f, SIZE_TOTAL_PIXEL, XINT (width), XINT (height), + CHECK_FIXNUM (width); + CHECK_FIXNUM (height); + frame_conversion_internal (f, SIZE_TOTAL_PIXEL, XFIXNUM (width), XFIXNUM (height), SIZE_FRAME_UNIT, &guwidth, &guheight); internal_set_frame_size (f, guwidth, guheight, !NILP (pretend)); return wrap_frame (f); ＠＠ -3296,10 +3296,10 ＠＠ struct frame *f = decode_frame (frame); int guwidth, guheight; - CHECK_INT (width); - CHECK_INT (height); + CHECK_FIXNUM (width); + CHECK_FIXNUM (height); frame_conversion_internal (f, SIZE_DISPLAYABLE_PIXEL, - XINT (width), XINT (height), + XFIXNUM (width), XFIXNUM (height), SIZE_FRAME_UNIT, &guwidth, &guheight); internal_set_frame_size (f, guwidth, guheight, !NILP (pretend)); return wrap_frame (f); ＠＠ -3314,10 +3314,10 ＠＠ (frame, xoffset, yoffset)) { struct frame *f = decode_frame (frame); - CHECK_INT (xoffset); - CHECK_INT (yoffset); - - MAYBE_FRAMEMETH (f, set_frame_position, (f, XINT (xoffset), XINT (yoffset))); + CHECK_FIXNUM (xoffset); + CHECK_FIXNUM (yoffset); + + MAYBE_FRAMEMETH (f, set_frame_position, (f, XFIXNUM (xoffset), XFIXNUM (yoffset))); return Qt; } ＠＠ -3897,8 +3897,8 ＠＠ 0)); if (keep_char_size) - Fset_frame_size (frame, make_int (FRAME_CHARWIDTH(f)), - make_int (FRAME_CHARHEIGHT(f)), Qnil); + Fset_frame_size (frame, make_fixnum (FRAME_CHARWIDTH(f)), + make_fixnum (FRAME_CHARHEIGHT(f)), Qnil); } if (!keep_char_size) diff -r a0e81357194e -r 56144c8593a8 src/free-hook.c --- a/src/free-hook.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/free-hook.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -376,12 +376,12 ＠＠ memset (free_queue, 0, sizeof (free_queue_entry) * FREE_QUEUE_LIMIT); current_free = 0; __free_hook = check_free; - lisp_count[0] = make_int (count[0]); - lisp_count[1] = make_int (count[1]); + lisp_count[0] = make_fixnum (count[0]); + lisp_count[1] = make_fixnum (count[1]); return Fcons (lisp_count[0], lisp_count[1]); } else - return Fcons (make_int (0), make_int (0)); + return Fcons (make_fixnum (0), make_fixnum (0)); } void diff -r a0e81357194e -r 56144c8593a8 src/glyphs-eimage.c --- a/src/glyphs-eimage.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/glyphs-eimage.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -788,7 +788,7 ＠＠ tid = add_glyph_animated_timeout (timeout > 10 ? timeout : 10, image_instance); if (!NILP (tid)) - IMAGE_INSTANCE_PIXMAP_TIMEOUT (ii) = XINT (tid); + IMAGE_INSTANCE_PIXMAP_TIMEOUT (ii) = XFIXNUM (tid); } unbind_to (speccount); ＠＠ -1031,7 +1031,7 ＠＠ Lisp_Object rgb = MAYBE_LISP_DEVMETH (XDEVICE (c->device), color_instance_rgb_components, (c)); -#define GETCOLOR(col) my_background.col = (unsigned short) XINT (XCAR (rgb)) +#define GETCOLOR(col) my_background.col = (unsigned short) XFIXNUM (XCAR (rgb)) GETCOLOR(red); rgb = XCDR (rgb); GETCOLOR(green); rgb = XCDR (rgb); GETCOLOR(blue); diff -r a0e81357194e -r 56144c8593a8 src/glyphs-gtk.c --- a/src/glyphs-gtk.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/glyphs-gtk.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -691,10 +691,10 ＠＠ int xhot = 0, yhot = 0; int w, h; - if (INTP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii))) - xhot = XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)); - if (INTP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii))) - yhot = XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)); + if (FIXNUMP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii))) + xhot = XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)); + if (FIXNUMP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii))) + yhot = XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)); w = IMAGE_INSTANCE_PIXMAP_WIDTH (ii); h = IMAGE_INSTANCE_PIXMAP_HEIGHT (ii); ＠＠ -1061,9 +1061,9 ＠＠ IMAGE_INSTANCE_GTK_CURSOR (ii) = gdk_cursor_new_from_pixmap (source, mask, &fg_color, &bg_color, !NILP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)) ? - XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)) : 0, + XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)) : 0, !NILP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)) ? - XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)) : 0); + XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)) : 0); } break; ＠＠ -1092,8 +1092,8 ＠＠ Qfile_name); mask = pixmap_from_xbm_inline (IMAGE_INSTANCE_DEVICE (ii), - XINT (XCAR (mask_data)), - XINT (XCAR (XCDR (mask_data))), + XFIXNUM (XCAR (mask_data)), + XFIXNUM (XCAR (XCDR (mask_data))), gcc_may_you_rot_in_hell); } ＠＠ -1117,8 +1117,8 ＠＠ gcc_go_home = LISP_STRING_TO_EXTERNAL (XCAR (XCDR (XCDR (data))), Qbinary); xbm_instantiate_1 (image_instance, instantiator, pointer_fg, - pointer_bg, dest_mask, XINT (XCAR (data)), - XINT (XCAR (XCDR (data))), gcc_go_home); + pointer_bg, dest_mask, XFIXNUM (XCAR (data)), + XFIXNUM (XCAR (XCDR (data))), gcc_go_home); }  ＠＠ -1327,8 +1327,8 ＠＠ case IMAGE_POINTER: /* #### Gtk does not give us access to the hotspots of a pixmap */ - IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_int(1); - IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_int(1); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_fixnum(1); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_fixnum(1); image_instance_convert_to_pointer (ii, instantiator, pointer_fg, ＠＠ -1550,10 +1550,10 ＠＠ void check_valid_string_or_int (Lisp_Object data) { - if (!INTP (data)) + if (!FIXNUMP (data)) CHECK_STRING (data); else - CHECK_INT (data); + CHECK_FIXNUM (data); } #endif ＠＠ -1604,10 +1604,10 ＠＠ alist = Fcons (Fcons (Q_file, filename), Fcons (Fcons (Q_data, data), alist)); if (xhot != -1) - alist = Fcons (Fcons (Q_hotspot_x, make_int (xhot)), + alist = Fcons (Fcons (Q_hotspot_x, make_fixnum (xhot)), alist); if (yhot != -1) - alist = Fcons (Fcons (Q_hotspot_y, make_int (yhot)), + alist = Fcons (Fcons (Q_hotspot_y, make_fixnum (yhot)), alist); alist = xbm_mask_file_munging (alist, filename, Qt, console_type); ＠＠ -2457,7 +2457,7 ＠＠ Lisp_Object val; val = XGUI_ITEM (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (ii))->value; - f = XFLOATINT (val); + f = XFLOATFIXNUM (val); gtk_progress_set_value (GTK_PROGRESS (IMAGE_INSTANCE_SUBWINDOW_ID (ii)), f); ＠＠ -2482,11 +2482,11 ＠＠ int id = gui_item_id_hash(FRAME_GTK_WIDGET_CALLBACK_HASH_TABLE(f), gui, WIDGET_GLYPH_SLOT); - Fputhash(make_int(id), image_instance, + Fputhash(make_fixnum(id), image_instance, FRAME_GTK_WIDGET_INSTANCE_HASH_TABLE (f)); - Fputhash(make_int(id), XGUI_ITEM (gui)->callback, + Fputhash(make_fixnum(id), XGUI_ITEM (gui)->callback, FRAME_GTK_WIDGET_CALLBACK_HASH_TABLE (f)); - Fputhash(make_int(id), XGUI_ITEM (gui)->callback_ex, + Fputhash(make_fixnum(id), XGUI_ITEM (gui)->callback_ex, FRAME_GTK_WIDGET_CALLBACK_EX_HASH_TABLE (f)); return id; } ＠＠ -2571,11 +2571,11 ＠＠ id = (int) gtk_object_get_data(GTK_OBJECT(page->child), GTK_DATA_TAB_HASHCODE_IDENTIFIER); - image_instance = Fgethash(make_int_verify(id), + image_instance = Fgethash(make_fixnum_verify(id), FRAME_GTK_WIDGET_INSTANCE_HASH_TABLE(f), Qnil); - callback = Fgethash(make_int(id), + callback = Fgethash(make_fixnum(id), FRAME_GTK_WIDGET_CALLBACK_HASH_TABLE(f), Qnil); - callback_ex = Fgethash(make_int(id), + callback_ex = Fgethash(make_fixnum(id), FRAME_GTK_WIDGET_CALLBACK_EX_HASH_TABLE(f), Qnil); update_subwindows_p = 1; ＠＠ -2931,8 +2931,8 ＠＠ Fadd_spec_to_specifier \ (GLYPH_IMAGE (XGLYPH (variable)), \ vector3 (Qxbm, Q_data, \ - list3 (make_int (name##_width), \ - make_int (name##_height), \ + list3 (make_fixnum (name##_width), \ + make_fixnum (name##_height), \ make_extstring ((Extbyte*) name##_bits, \ sizeof (name##_bits), \ Qbinary))), \ diff -r a0e81357194e -r 56144c8593a8 src/glyphs-msw.c --- a/src/glyphs-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/glyphs-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -387,8 +387,8 ＠＠ IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii) = bmp_info->bmiHeader.biHeight; IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = bmp_info->bmiHeader.biBitCount; - IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_int (x_hot); - IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_int (y_hot); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_fixnum (x_hot); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_fixnum (y_hot); init_image_instance_geometry (ii); if (create_mask) ＠＠ -616,8 +616,8 ＠＠ /* we rely on windows to do any resizing necessary */ x_icon.fIcon = cursor ? FALSE : TRUE; - x_icon.xHotspot = XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (image)); - x_icon.yHotspot = XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (image)); + x_icon.xHotspot = XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (image)); + x_icon.yHotspot = XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (image)); x_icon.hbmMask = IMAGE_INSTANCE_MSWINDOWS_MASK (image); x_icon.hbmColor = IMAGE_INSTANCE_MSWINDOWS_BITMAP (image); ＠＠ -831,7 +831,7 ＠＠ { signal_double_image_error_2 ("Parsing pixmap data", "unknown error", - make_int (result), image); + make_fixnum (result), image); } } ＠＠ -1169,8 +1169,8 ＠＠ : type == IMAGE_ICON ? icon_table : bitmap_table); - if (INTP (name)) - return XINT (name); + if (FIXNUMP (name)) + return XFIXNUM (name); else if (!STRINGP (name)) invalid_argument ("invalid resource identifier", name); ＠＠ -1282,8 +1282,8 ＠＠ GetIconInfo ((HICON)himage, &iconinfo); IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = iconinfo.hbmColor; IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = iconinfo.hbmMask; - IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_int (iconinfo.xHotspot); - IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_int (iconinfo.yHotspot); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_fixnum (iconinfo.xHotspot); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_fixnum (iconinfo.yHotspot); IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = (HICON) himage; } else ＠＠ -1291,8 +1291,8 ＠＠ IMAGE_INSTANCE_MSWINDOWS_ICON (ii) = NULL; IMAGE_INSTANCE_MSWINDOWS_BITMAP (ii) = (HBITMAP) himage; IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = NULL; - IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_int (0); - IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_int (0); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_fixnum (0); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_fixnum (0); } } ＠＠ -1473,8 +1473,8 ＠＠ IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_WIDTH (ii) = width; IMAGE_INSTANCE_MSWINDOWS_BITMAP_REAL_HEIGHT (ii) = height; IMAGE_INSTANCE_PIXMAP_DEPTH (ii) = 1; - IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_int (0); - IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_int (0); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_fixnum (0); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_fixnum (0); init_image_instance_geometry (ii); IMAGE_INSTANCE_MSWINDOWS_MASK (ii) = mask ? mask : ＠＠ -1572,8 +1572,8 ＠＠ Qbinary); mask = xbm_create_bitmap_from_data (hdc, ext_data, - XINT (XCAR (mask_data)), - XINT (XCAR (XCDR (mask_data))), + XFIXNUM (XCAR (mask_data)), + XFIXNUM (XCAR (XCDR (mask_data))), FALSE, PALETTERGB (0,0,0), PALETTERGB (255,255,255)); ＠＠ -1602,8 +1602,8 ＠＠ Qbinary); xbm_instantiate_1 (image_instance, instantiator, pointer_fg, - pointer_bg, dest_mask, XINT (XCAR (data)), - XINT (XCAR (XCDR (data))), ext_data); + pointer_bg, dest_mask, XFIXNUM (XCAR (data)), + XFIXNUM (XCAR (XCDR (data))), ext_data); } #ifdef HAVE_XFACE ＠＠ -2069,11 +2069,11 ＠＠ int id = gui_item_id_hash (FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f), gui, WIDGET_GLYPH_SLOT); - Fputhash (make_int (id), image_instance, + Fputhash (make_fixnum (id), image_instance, FRAME_MSWINDOWS_WIDGET_HASH_TABLE1 (f)); - Fputhash (make_int (id), XGUI_ITEM (gui)->callback, + Fputhash (make_fixnum (id), XGUI_ITEM (gui)->callback, FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f)); - Fputhash (make_int (id), XGUI_ITEM (gui)->callback_ex, + Fputhash (make_fixnum (id), XGUI_ITEM (gui)->callback_ex, FRAME_MSWINDOWS_WIDGET_HASH_TABLE3 (f)); return id; } ＠＠ -2122,7 +2122,7 ＠＠ NULL, /* must be null for this class */ NULL)) == NULL) gui_error ("window creation failed with code", - make_int (GetLastError())); + make_fixnum (GetLastError())); wnd = qxeCreateWindow (XETEXT ("STATIC"), XETEXT (""), WS_CHILD, ＠＠ -2262,7 +2262,7 ＠＠ NULL, /* must be null for this class */ NULL)) == NULL) gui_error ("window creation failed with code", - make_int (GetLastError())); + make_fixnum (GetLastError())); classext = ITEXT_TO_TSTR (class_); ＠＠ -2283,7 +2283,7 ＠＠ GWL_HINSTANCE), NULL)) == NULL) gui_error ("window creation failed with code", - make_int (GetLastError())); + make_fixnum (GetLastError())); IMAGE_INSTANCE_SUBWINDOW_ID (ii) = wnd; qxeSetWindowLong (wnd, GWL_USERDATA, (LONG)STORE_LISP_IN_VOID(image_instance)); ＠＠ -2455,9 +2455,9 ＠＠ XIMAGE_INSTANCE_FRAME (ii)))))); #endif val = XGUI_ITEM (IMAGE_INSTANCE_WIDGET_ITEMS (ii))->value; - CHECK_INT (val); + CHECK_FIXNUM (val); qxeSendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), - PBM_SETPOS, (WPARAM)XINT (val), 0); + PBM_SETPOS, (WPARAM)XFIXNUM (val), 0); } /* instantiate a tree view widget */ ＠＠ -2879,11 +2879,11 ＠＠ #ifdef DEBUG_WIDGET_OUTPUT stderr_out ("progress gauge displayed value on %p updated to %ld\n", WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), - XINT(val)); + XFIXNUM(val)); #endif - CHECK_INT (val); + CHECK_FIXNUM (val); qxeSendMessage (WIDGET_INSTANCE_MSWINDOWS_HANDLE (ii), - PBM_SETPOS, (WPARAM)XINT (val), 0); + PBM_SETPOS, (WPARAM)XFIXNUM (val), 0); } } diff -r a0e81357194e -r 56144c8593a8 src/glyphs-widget.c --- a/src/glyphs-widget.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/glyphs-widget.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -165,7 +165,7 ＠＠ static void check_valid_int_or_function (Lisp_Object data) { - if (!INTP (data) && !CONSP (data) && !SYMBOLP (data)) + if (!FIXNUMP (data) && !CONSP (data) && !SYMBOLP (data)) invalid_argument ("must be an integer or expresssion", data); } ＠＠ -578,15 +578,15 ＠＠ { dynamic_width = eval_within_redisplay (IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (ii)); - if (INTP (dynamic_width)) - *width = XINT (dynamic_width); + if (FIXNUMP (dynamic_width)) + *width = XFIXNUM (dynamic_width); } if (height && !NILP (IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii))) { dynamic_height = eval_within_redisplay (IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii)); - if (INTP (dynamic_height)) - *height = XINT (dynamic_height); + if (FIXNUMP (dynamic_height)) + *height = XFIXNUM (dynamic_height); } } } ＠＠ -770,33 +770,33 ＠＠ geometry gets called. */ if (!NILP (pixwidth)) /* pixwidth takes precendent */ { - if (!INTP (pixwidth)) + if (!FIXNUMP (pixwidth)) IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (ii) = pixwidth; else { - pw = XINT (pixwidth); + pw = XFIXNUM (pixwidth); IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii) = 0; } } else if (!NILP (width)) { - tw = XINT (width); + tw = XFIXNUM (width); IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii) = 0; } if (!NILP (pixheight)) { - if (!INTP (pixheight)) + if (!FIXNUMP (pixheight)) IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii) = pixheight; else { - ph = XINT (pixheight); + ph = XFIXNUM (pixheight); IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) = 0; } } - else if (!NILP (height) && XINT (height) > 1) + else if (!NILP (height) && XFIXNUM (height) > 1) { - th = XINT (height); + th = XFIXNUM (height); IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) = 0; } ＠＠ -848,7 +848,7 ＠＠ /* Pick up the margin width. */ if (!NILP (mwidth)) - IMAGE_INSTANCE_MARGIN_WIDTH (ii) = XINT (mwidth); + IMAGE_INSTANCE_MARGIN_WIDTH (ii) = XFIXNUM (mwidth); IMAGE_INSTANCE_WANTS_INITIAL_FOCUS (ii) = !NILP (ifocus); ＠＠ -1138,7 +1138,7 ＠＠ we have to deal with the border as well as the items. */ GCPRO1 (border); - if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (ii))) + if (FIXNUMP (IMAGE_INSTANCE_LAYOUT_BORDER (ii))) { border = XCAR (children); children = XCDR (children); ＠＠ -1163,7 +1163,7 ＠＠ border = Fcons (call1 (Qmake_glyph, border_inst), Qnil); structure_changed = 1; } - IMAGE_INSTANCE_LAYOUT_BORDER (ii) = make_int (0); + IMAGE_INSTANCE_LAYOUT_BORDER (ii) = make_fixnum (0); } else { ＠＠ -1341,7 +1341,7 ＠＠ luh = widget_logical_unit_height (ii); /* Pick up the border text if we have one. */ - if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (ii))) + if (FIXNUMP (IMAGE_INSTANCE_LAYOUT_BORDER (ii))) { glyph_query_geometry (XCAR (items), &gwidth, &gheight, disp, image_instance); ＠＠ -1379,8 +1379,8 ＠＠ { Lisp_Object dynamic_width = eval_within_redisplay (IMAGE_INSTANCE_WIDGET_WIDTH_SUBR (ii)); - if (INTP (dynamic_width)) - *width = XINT (dynamic_width); + if (FIXNUMP (dynamic_width)) + *width = XFIXNUM (dynamic_width); } else if (IMAGE_INSTANCE_SUBWINDOW_ORIENT (ii) == LAYOUT_HORIZONTAL) { ＠＠ -1401,8 +1401,8 ＠＠ { Lisp_Object dynamic_height = eval_within_redisplay (IMAGE_INSTANCE_WIDGET_HEIGHT_SUBR (ii)); - if (INTP (dynamic_height)) - *height = XINT (dynamic_height); + if (FIXNUMP (dynamic_height)) + *height = XFIXNUM (dynamic_height); } else if (IMAGE_INSTANCE_SUBWINDOW_LOGICAL_LAYOUT (ii)) { ＠＠ -1452,7 +1452,7 ＠＠ border that is drawn. The last is an offset and implies that the first item in the list of subcontrols is a text control that should be displayed on the border. */ - if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (ii))) + if (FIXNUMP (IMAGE_INSTANCE_LAYOUT_BORDER (ii))) { Lisp_Object border = XCAR (items); items = XCDR (items); ＠＠ -1462,7 +1462,7 ＠＠ of the border glyph. */ ph_adjust = gheight; /* The offset for the border is half the glyph height. */ - IMAGE_INSTANCE_LAYOUT_BORDER (ii) = make_int (gheight / 2); + IMAGE_INSTANCE_LAYOUT_BORDER (ii) = make_fixnum (gheight / 2); /* #### Really, what should this be? */ glyph_do_layout (border, gwidth, gheight, BORDER_FIDDLE_FACTOR, 0, ＠＠ -1594,7 +1594,7 ＠＠ Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); if (EQ (prop, Q_items)) { - if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (ii)) && + if (FIXNUMP (IMAGE_INSTANCE_LAYOUT_BORDER (ii)) && CONSP (IMAGE_INSTANCE_LAYOUT_CHILDREN (ii))) return Fcopy_sequence (XCDR (IMAGE_INSTANCE_LAYOUT_CHILDREN (ii))); ＠＠ -1651,8 +1651,8 ＠＠ if (NILP (domain)) domain = Fselected_frame (Qnil); - CHECK_INT (width); - w = XINT (width); + CHECK_FIXNUM (width); + w = XFIXNUM (width); if (HAS_DEVMETH_P (DOMAIN_XDEVICE (domain), widget_border_width)) border_width = DEVMETH (DOMAIN_XDEVICE (domain), widget_border_width, ()); ＠＠ -1661,7 +1661,7 ＠＠ neww = ROUND_UP (charwidth * w + 4 * border_width + 2 * widget_spacing (domain), charwidth) / charwidth; - return make_int (neww); + return make_fixnum (neww); } DEFUN ("widget-logical-to-character-height", Fwidget_logical_to_character_height, 1, 3, 0, /* ＠＠ -1685,18 +1685,18 ＠＠ { int h, newh, charheight; - CHECK_INT (height); + CHECK_FIXNUM (height); if (NILP (domain)) domain = Fselected_frame (Qnil); - h = XINT (height); + h = XFIXNUM (height); default_face_font_info (domain, 0, 0, 0, &charheight, 0); newh = ROUND_UP (logical_unit_height (Fsymbol_name (Qwidget), Vwidget_face, domain) * h, charheight) / charheight; - return make_int (newh); + return make_fixnum (newh); }  diff -r a0e81357194e -r 56144c8593a8 src/glyphs-x.c --- a/src/glyphs-x.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/glyphs-x.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -749,10 +749,10 ＠＠ int xhot = 0, yhot = 0; int w, h; - if (INTP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii))) - xhot = XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)); - if (INTP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii))) - yhot = XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)); + if (FIXNUMP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii))) + xhot = XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)); + if (FIXNUMP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii))) + yhot = XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)); w = IMAGE_INSTANCE_PIXMAP_WIDTH (ii); h = IMAGE_INSTANCE_PIXMAP_HEIGHT (ii); ＠＠ -1201,9 +1201,9 ＠＠ XCreatePixmapCursor (dpy, source, mask, &fg_color, &bg_color, !NILP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)) ? - XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)) : 0, + XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii)) : 0, !NILP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)) ? - XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)) : 0); + XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii)) : 0); } break; ＠＠ -1230,8 +1230,8 ＠＠ ext_data = LISP_STRING_TO_EXTERNAL (XCAR (XCDR (XCDR (mask_data))), Qbinary); mask = pixmap_from_xbm_inline (IMAGE_INSTANCE_DEVICE (ii), - XINT (XCAR (mask_data)), - XINT (XCAR (XCDR (mask_data))), + XFIXNUM (XCAR (mask_data)), + XFIXNUM (XCAR (XCDR (mask_data))), ext_data); } ＠＠ -1255,8 +1255,8 ＠＠ ext_data = LISP_STRING_TO_EXTERNAL (XCAR (XCDR (XCDR (data))), Qbinary); xbm_instantiate_1 (image_instance, instantiator, pointer_fg, - pointer_bg, dest_mask, XINT (XCAR (data)), - XINT (XCAR (XCDR (data))), ext_data); + pointer_bg, dest_mask, XFIXNUM (XCAR (data)), + XFIXNUM (XCAR (XCDR (data))), ext_data); }  ＠＠ -1516,7 +1516,7 ＠＠ xpm_free (&xpmattrs); signal_error_2 (Qgui_error, "Parsing pixmap data: unknown error code", - make_int (result), data); + make_fixnum (result), data); } } ＠＠ -1557,9 +1557,9 ＠＠ case IMAGE_POINTER: if (xpmattrs.valuemask & XpmHotspot) - IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_int (xpmattrs.x_hotspot); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii) = make_fixnum (xpmattrs.x_hotspot); if (xpmattrs.valuemask & XpmHotspot) - IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_int (xpmattrs.y_hotspot); + IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii) = make_fixnum (xpmattrs.y_hotspot); image_instance_convert_to_pointer (ii, instantiator, pointer_fg, pointer_bg); ＠＠ -1708,10 +1708,10 ＠＠ alist = Fcons (Fcons (Q_file, filename), Fcons (Fcons (Q_data, data), alist)); if (xhot != -1) - alist = Fcons (Fcons (Q_hotspot_x, make_int (xhot)), + alist = Fcons (Fcons (Q_hotspot_x, make_fixnum (xhot)), alist); if (yhot != -1) - alist = Fcons (Fcons (Q_hotspot_y, make_int (yhot)), + alist = Fcons (Fcons (Q_hotspot_y, make_fixnum (yhot)), alist); alist = xbm_mask_file_munging (alist, filename, Qt, console_type); ＠＠ -2679,7 +2679,7 ＠＠ { Lisp_Object val; val = XGUI_ITEM (IMAGE_INSTANCE_WIDGET_PENDING_ITEMS (p))->value; - Xt_SET_VALUE (IMAGE_INSTANCE_X_WIDGET_ID (p), XtNvalue, XINT (val)); + Xt_SET_VALUE (IMAGE_INSTANCE_X_WIDGET_ID (p), XtNvalue, XFIXNUM (val)); } } ＠＠ -3005,8 +3005,8 ＠＠ Fadd_spec_to_specifier \ (GLYPH_IMAGE (XGLYPH (variable)), \ vector3 (Qxbm, Q_data, \ - list3 (make_int (name##_width), \ - make_int (name##_height), \ + list3 (make_fixnum (name##_width), \ + make_fixnum (name##_height), \ make_extstring ((Extbyte *) name##_bits, \ sizeof (name##_bits), \ Qbinary))), \ diff -r a0e81357194e -r 56144c8593a8 src/glyphs.c --- a/src/glyphs.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/glyphs.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -345,16 +345,16 ＠＠ if (!NILP (XCDR (XCDR (mapping)))) { pos = XCAR (XCDR (XCDR (mapping))); - CHECK_INT (pos); - if (XINT (pos) < 0 || - XINT (pos) >= XVECTOR_LENGTH (typevec)) + CHECK_FIXNUM (pos); + if (XFIXNUM (pos) < 0 || + XFIXNUM (pos) >= XVECTOR_LENGTH (typevec)) args_out_of_range_3 - (pos, Qzero, make_int (XVECTOR_LENGTH (typevec) - 1)); + (pos, Qzero, make_fixnum (XVECTOR_LENGTH (typevec) - 1)); } newvec = Fcopy_sequence (typevec); - if (INTP (pos)) - XVECTOR_DATA (newvec)[XINT (pos)] = regexp; + if (FIXNUMP (pos)) + XVECTOR_DATA (newvec)[XFIXNUM (pos)] = regexp; GCPRO1 (newvec); image_validate (newvec); UNGCPRO; ＠＠ -405,7 +405,7 ＠＠ { if (!NILP (XCDR (XCDR (mapping)))) { - int pos = XINT (XCAR (XCDR (XCDR (mapping)))); + int pos = XFIXNUM (XCAR (XCDR (XCDR (mapping)))); Lisp_Object newvec = Fcopy_sequence (typevec); XVECTOR_DATA (newvec)[pos] = data; return newvec; ＠＠ -552,7 +552,7 ＠＠ void check_valid_int (Lisp_Object data) { - CHECK_INT (data); + CHECK_FIXNUM (data); } void ＠＠ -631,7 +631,7 ＠＠ Lisp_Object alist_to_tagged_vector (Lisp_Object tag, Lisp_Object alist) { - int len = 1 + 2 * XINT (Flength (alist)); + int len = 1 + 2 * XFIXNUM (Flength (alist)); Lisp_Object *elt = alloca_array (Lisp_Object, len); int i; Lisp_Object rest; ＠＠ -742,7 +742,7 ＠＠ if (STRINGP (instantiator)) instantiator = process_image_string_instantiator (instantiator, contype, - XINT (dest_mask)); + XFIXNUM (dest_mask)); /* Subsequent validation will pick this up. */ if (!VECTORP (instantiator)) return instantiator; ＠＠ -1034,13 +1034,13 ＠＠ write_ascstring (printcharfun, " ＠"); if (!NILP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii))) write_fmt_string (printcharfun, "%ld", - XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii))); + XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (ii))); else write_ascstring (printcharfun, "??"); write_ascstring (printcharfun, ","); if (!NILP (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii))) write_fmt_string (printcharfun, "%ld", - XINT (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii))); + XFIXNUM (IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (ii))); else write_ascstring (printcharfun, "??"); } ＠＠ -1533,7 +1533,7 ＠＠ dest_mask = decode_image_instance_type_list (dest_types); data = normalize_image_instantiator (data, DEVICE_TYPE (DOMAIN_XDEVICE (domain)), - make_int (dest_mask)); + make_fixnum (dest_mask)); GCPRO1 (data); /* After normalizing the data, it's always either an image instance (which we filtered out above) or a vector. */ ＠＠ -1808,7 +1808,7 ＠＠ case IMAGE_MONO_PIXMAP: case IMAGE_COLOR_PIXMAP: case IMAGE_POINTER: - return make_int (XIMAGE_INSTANCE_PIXMAP_DEPTH (image_instance)); + return make_fixnum (XIMAGE_INSTANCE_PIXMAP_DEPTH (image_instance)); default: return Qnil; ＠＠ -1830,7 +1830,7 ＠＠ case IMAGE_POINTER: case IMAGE_SUBWINDOW: case IMAGE_WIDGET: - return make_int (XIMAGE_INSTANCE_HEIGHT (image_instance)); + return make_fixnum (XIMAGE_INSTANCE_HEIGHT (image_instance)); default: return Qnil; ＠＠ -1852,7 +1852,7 ＠＠ case IMAGE_POINTER: case IMAGE_SUBWINDOW: case IMAGE_WIDGET: - return make_int (XIMAGE_INSTANCE_WIDTH (image_instance)); + return make_fixnum (XIMAGE_INSTANCE_WIDTH (image_instance)); default: return Qnil; ＠＠ -2703,7 +2703,7 ＠＠ Lisp_Object retval; int len = (w + 7) / 8 * h; - retval = list3 (make_int (w), make_int (h), + retval = list3 (make_fixnum (w), make_fixnum (h), make_extstring ((Extbyte *) data, len, Qbinary)); XFree (data); return retval; ＠＠ -2736,7 +2736,7 ＠＠ { signal_double_image_error_2 ("Reading bitmap file", "unknown error code", - make_int (result), name); + make_fixnum (result), name); } } ＠＠ -2838,10 +2838,10 ＠＠ Fcons (Fcons (Q_data, data), alist)); if (xhot != -1 && NILP (assq_no_quit (Q_hotspot_x, alist))) - alist = Fcons (Fcons (Q_hotspot_x, make_int (xhot)), + alist = Fcons (Fcons (Q_hotspot_x, make_fixnum (xhot)), alist); if (yhot != -1 && NILP (assq_no_quit (Q_hotspot_y, alist))) - alist = Fcons (Fcons (Q_hotspot_y, make_int (yhot)), + alist = Fcons (Fcons (Q_hotspot_y, make_fixnum (yhot)), alist); } ＠＠ -3041,7 +3041,7 ＠＠ { signal_double_image_error_2 ("Parsing pixmap file", "unknown error code", - make_int (result), name); + make_fixnum (result), name); break; } } ＠＠ -3349,7 +3349,7 ＠＠ /* First look in the device cache. */ if (DEVICEP (governing_domain)) { - subtable = Fgethash (make_int (dest_mask), + subtable = Fgethash (make_fixnum (dest_mask), XDEVICE (governing_domain)-> image_instance_cache, Qunbound); ＠＠ -3373,7 +3373,7 ＠＠ foreground and background of the pointer face. */ subtable = make_image_instance_cache_hash_table (); - Fputhash (make_int (dest_mask), subtable, + Fputhash (make_fixnum (dest_mask), subtable, XDEVICE (governing_domain)->image_instance_cache); instance = Qunbound; } ＠＠ -3579,7 +3579,7 ＠＠ possible_console_types = Fcons (contype, possible_console_types); } - if (XINT (Flength (possible_console_types)) > 1) + if (XFIXNUM (Flength (possible_console_types)) > 1) /* two conflicting console types specified */ return Qnil; ＠＠ -3594,7 +3594,7 ＠＠ Lisp_Object newinst = call_with_suspended_errors ((lisp_fn_t) normalize_image_instantiator, Qnil, Qimage, ERROR_ME_DEBUG_WARN, 3, instantiator, contype, - make_int (XIMAGE_SPECIFIER_ALLOWED (specifier))); + make_fixnum (XIMAGE_SPECIFIER_ALLOWED (specifier))); if (!NILP (newinst)) { ＠＠ -4073,7 +4073,7 ＠＠ window = wrap_window (decode_window (window)); CHECK_GLYPH (glyph); - return make_int (glyph_width (glyph, window)); + return make_fixnum (glyph_width (glyph, window)); } unsigned short ＠＠ -4145,7 +4145,7 ＠＠ window = wrap_window (decode_window (window)); CHECK_GLYPH (glyph); - return make_int (glyph_ascent (glyph, window)); + return make_fixnum (glyph_ascent (glyph, window)); } DEFUN ("glyph-descent", Fglyph_descent, 1, 2, 0, /* ＠＠ -4158,7 +4158,7 ＠＠ window = wrap_window (decode_window (window)); CHECK_GLYPH (glyph); - return make_int (glyph_descent (glyph, window)); + return make_fixnum (glyph_descent (glyph, window)); } /* This is redundant but I bet a lot of people expect it to exist. */ ＠＠ -4172,7 +4172,7 ＠＠ window = wrap_window (decode_window (window)); CHECK_GLYPH (glyph); - return make_int (glyph_height (glyph, window)); + return make_fixnum (glyph_height (glyph, window)); } static void ＠＠ -4226,14 +4226,14 ＠＠ /* #### look into error flag */ Qunbound, domain, ERROR_ME_DEBUG_WARN, 0, Qzero); - if (!NILP (retval) && !INTP (retval)) + if (!NILP (retval) && !FIXNUMP (retval)) retval = Qnil; - else if (INTP (retval)) + else if (FIXNUMP (retval)) { - if (XINT (retval) < 0) + if (XFIXNUM (retval) < 0) retval = Qzero; - if (XINT (retval) > 100) - retval = make_int (100); + if (XFIXNUM (retval) > 100) + retval = make_fixnum (100); } return retval; } ＠＠ -4939,20 +4939,20 ＠＠ IMAGE_INSTANCE_SUBWINDOW_ID (ii) = 0; IMAGE_INSTANCE_SUBWINDOW_DISPLAYEDP (ii) = 0; - if (INTP (width)) + if (FIXNUMP (width)) { int w = 1; - if (XINT (width) > 1) - w = XINT (width); + if (XFIXNUM (width) > 1) + w = XFIXNUM (width); IMAGE_INSTANCE_WIDTH (ii) = w; IMAGE_INSTANCE_SUBWINDOW_H_RESIZEP (ii) = 0; } - if (INTP (height)) + if (FIXNUMP (height)) { int h = 1; - if (XINT (height) > 1) - h = XINT (height); + if (XFIXNUM (height) > 1) + h = XFIXNUM (height); IMAGE_INSTANCE_HEIGHT (ii) = h; IMAGE_INSTANCE_SUBWINDOW_V_RESIZEP (ii) = 0; } ＠＠ -4985,7 +4985,7 ＠＠ (subwindow)) { CHECK_SUBWINDOW_IMAGE_INSTANCE (subwindow); - return make_int ((EMACS_INT) XIMAGE_INSTANCE_SUBWINDOW_ID (subwindow)); + return make_fixnum ((EMACS_INT) XIMAGE_INSTANCE_SUBWINDOW_ID (subwindow)); } DEFUN ("resize-subwindow", Fresize_subwindow, 1, 3, 0, /* ＠＠ -5003,12 +5003,12 ＠＠ if (NILP (width)) neww = IMAGE_INSTANCE_WIDTH (ii); else - neww = XINT (width); + neww = XFIXNUM (width); if (NILP (height)) newh = IMAGE_INSTANCE_HEIGHT (ii); else - newh = XINT (height); + newh = XFIXNUM (height); /* The actual resizing gets done asynchronously by update_subwindow. */ ＠＠ -5185,7 +5185,7 ＠＠ void disable_glyph_animated_timeout (int i) { - Fdisable_timeout (make_int (i)); + Fdisable_timeout (make_fixnum (i)); }  diff -r a0e81357194e -r 56144c8593a8 src/gpmevent.c --- a/src/gpmevent.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/gpmevent.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -584,8 +584,8 ＠＠ store_gpm_state (gpm_fd); gpm_process = connect_to_file_descriptor (build_cistring (process_name), Qnil, - make_int (gpm_fd), - make_int (gpm_fd)); + make_fixnum (gpm_fd), + make_fixnum (gpm_fd)); if (!NILP (gpm_process)) { diff -r a0e81357194e -r 56144c8593a8 src/gtk-glue.c --- a/src/gtk-glue.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/gtk-glue.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -197,7 +197,7 ＠＠ } else if (arg->type == GTK_TYPE_INT_ARRAY) { - FROB (gint, CHECK_INT, XINT); + FROB (gint, CHECK_FIXNUM, XFIXNUM); } else { diff -r a0e81357194e -r 56144c8593a8 src/gtk-xemacs.c --- a/src/gtk-xemacs.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/gtk-xemacs.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -178,7 +178,7 ＠＠ { \ FROB (Vdefault_face, Qbackground_pixmap, \ Fmake_image_instance (build_cistring (style->rc_style->bg_pixmap_name[GTK_STATE_NORMAL]), \ - f->device, Qnil, make_int (5))); \ + f->device, Qnil, make_fixnum (5))); \ } \ else \ { \ ＠＠ -214,8 +214,8 ＠＠ style = gtk_style_attach (style, GTK_WIDGET (DEVICE_GTK_APP_SHELL (XDEVICE (FRAME_DEVICE (f))))->window); - Fadd_spec_to_specifier (Vscrollbar_width, make_int (vsize), frame, Qnil, Qnil); - Fadd_spec_to_specifier (Vscrollbar_height, make_int (hsize), frame, Qnil, Qnil); + Fadd_spec_to_specifier (Vscrollbar_width, make_fixnum (vsize), frame, Qnil, Qnil); + Fadd_spec_to_specifier (Vscrollbar_height, make_fixnum (hsize), frame, Qnil, Qnil); } #endif /* HAVE_SCROLLBARS */ ＠＠ -230,7 +230,7 ＠＠ frame = wrap_frame (f); - Fadd_spec_to_specifier (Vtoolbar_shadow_thickness, make_int (klass->xthickness), + Fadd_spec_to_specifier (Vtoolbar_shadow_thickness, make_fixnum (klass->xthickness), Qnil, list2 (Qgtk, Qdefault), Qprepend); } #endif /* HAVE_TOOLBARS */ diff -r a0e81357194e -r 56144c8593a8 src/gui-gtk.c --- a/src/gui-gtk.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/gui-gtk.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -48,13 +48,13 ＠＠ void gcpro_popup_callbacks (GUI_ID id, Lisp_Object data) { - Vpopup_callbacks = Fcons (Fcons (make_int (id), data), Vpopup_callbacks); + Vpopup_callbacks = Fcons (Fcons (make_fixnum (id), data), Vpopup_callbacks); } void ungcpro_popup_callbacks (GUI_ID id) { - Lisp_Object lid = make_int (id); + Lisp_Object lid = make_fixnum (id); Lisp_Object this_callback = assq_no_quit (lid, Vpopup_callbacks); Vpopup_callbacks = delq_no_quit (this_callback, Vpopup_callbacks); } ＠＠ -62,7 +62,7 ＠＠ Lisp_Object get_gcpro_popup_callbacks (GUI_ID id) { - Lisp_Object lid = make_int (id); + Lisp_Object lid = make_fixnum (id); Lisp_Object this_callback = assq_no_quit (lid, Vpopup_callbacks); if (!NILP (this_callback)) diff -r a0e81357194e -r 56144c8593a8 src/gui-msw.c --- a/src/gui-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/gui-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -48,16 +48,16 ＠＠ frame = wrap_frame (f); - image_instance = Fgethash (make_int_verify (id), + image_instance = Fgethash (make_fixnum_verify (id), FRAME_MSWINDOWS_WIDGET_HASH_TABLE1 (f), Qnil); /* It is possible for a widget action to cause it to get out of sync with its instantiator. Thus it is necessary to signal this possibility. */ if (IMAGE_INSTANCEP (image_instance)) XIMAGE_INSTANCE_WIDGET_ACTION_OCCURRED (image_instance) = 1; - callback = Fgethash (make_int (id), + callback = Fgethash (make_fixnum (id), FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f), Qnil); - callback_ex = Fgethash (make_int (id), + callback_ex = Fgethash (make_fixnum (id), FRAME_MSWINDOWS_WIDGET_HASH_TABLE3 (f), Qnil); if (!NILP (callback_ex) && !UNBOUNDP (callback_ex)) diff -r a0e81357194e -r 56144c8593a8 src/gui-x.c --- a/src/gui-x.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/gui-x.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -108,7 +108,7 ＠＠ void gcpro_popup_callbacks (LWLIB_ID id) { - Lisp_Object lid = make_int (id); + Lisp_Object lid = make_fixnum (id); Lisp_Object this_callback = assq_no_quit (lid, Vpopup_callbacks); if (!NILP (this_callback)) ＠＠ -127,7 +127,7 ＠＠ void ungcpro_popup_callbacks (LWLIB_ID id) { - Lisp_Object lid = make_int (id); + Lisp_Object lid = make_fixnum (id); Lisp_Object this_callback = assq_no_quit (lid, Vpopup_callbacks); assert (!NILP (this_callback)); ＠＠ -138,7 +138,7 ＠＠ int popup_handled_p (LWLIB_ID id) { - return NILP (assq_no_quit (make_int (id), Vpopup_callbacks)); + return NILP (assq_no_quit (make_fixnum (id), Vpopup_callbacks)); } /* menu_item_descriptor_to_widget_value() et al. mallocs a diff -r a0e81357194e -r 56144c8593a8 src/gui.c --- a/src/gui.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/gui.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -617,7 +617,7 ＠＠ { int hashid = gui_item_hash (gitem, 0, 0); int id = GUI_ITEM_ID_BITS (hashid, slot); - while (!UNBOUNDP (Fgethash (make_int (id), hashtable, Qunbound))) + while (!UNBOUNDP (Fgethash (make_fixnum (id), hashtable, Qunbound))) { id = GUI_ITEM_ID_BITS (id + 1, slot); } diff -r a0e81357194e -r 56144c8593a8 src/gutter.c --- a/src/gutter.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/gutter.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -340,7 +340,7 ＠＠ /* Let GC happen again. */ exit_redisplay_critical_section (count); - ret = make_int (calculate_gutter_size_from_display_lines (pos, ddla)); + ret = make_fixnum (calculate_gutter_size_from_display_lines (pos, ddla)); free_display_lines (ddla); } ＠＠ -776,7 +776,7 ＠＠ get_gutter_coords (f, p, &x, &y, &width, &height); width -= (FRAME_GUTTER_BORDER_WIDTH (f, p) * 2); - return make_int (width); + return make_fixnum (width); } DEFUN ("gutter-pixel-height", Fgutter_pixel_height, 0, 2, 0, /* ＠＠ -797,7 +797,7 ＠＠ get_gutter_coords (f, p, &x, &y, &width, &height); height -= (FRAME_GUTTER_BORDER_WIDTH (f, p) * 2); - return make_int (height); + return make_fixnum (height); } DEFINE_SPECIFIER_TYPE (gutter); ＠＠ -862,7 +862,7 ＠＠ gutter_specs_changed_1 (Lisp_Object arg) { gutter_specs_changed (X1ST (arg), XWINDOW (X2ND (arg)), - X3RD (arg), (enum edge_pos) XINT (X4TH (arg))); + X3RD (arg), (enum edge_pos) XFIXNUM (X4TH (arg))); free_list (arg); } ＠＠ -873,7 +873,7 ＠＠ if (in_display) register_post_redisplay_action (gutter_specs_changed_1, list4 (specifier, wrap_window (w), - oldval, make_int (pos))); + oldval, make_fixnum (pos))); else { w->real_gutter[pos] = construct_window_gutter_spec (w, pos); ＠＠ -1004,7 +1004,7 ＠＠ if (NILP (instantiator)) return; - if (!INTP (instantiator) && !EQ (instantiator, Qautodetect)) + if (!FIXNUMP (instantiator) && !EQ (instantiator, Qautodetect)) invalid_argument ("Gutter size must be an integer or `autodetect'", instantiator); } ＠＠ -1527,11 +1527,11 ＠＠ fb = Fcons (Fcons (list1 (Qtty), Qzero), fb); #endif #ifdef HAVE_X_WINDOWS - fb = Fcons (Fcons (list1 (Qx), make_int (DEFAULT_GUTTER_BORDER_WIDTH)), fb); + fb = Fcons (Fcons (list1 (Qx), make_fixnum (DEFAULT_GUTTER_BORDER_WIDTH)), fb); #endif #ifdef HAVE_MS_WINDOWS fb = Fcons (Fcons (list1 (Qmsprinter), Qzero), fb); - fb = Fcons (Fcons (list1 (Qmswindows), make_int (DEFAULT_GUTTER_BORDER_WIDTH)), fb); + fb = Fcons (Fcons (list1 (Qmswindows), make_fixnum (DEFAULT_GUTTER_BORDER_WIDTH)), fb); #endif if (!NILP (fb)) set_specifier_fallback (Vdefault_gutter_border_width, fb); diff -r a0e81357194e -r 56144c8593a8 src/gutter.h --- a/src/gutter.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/gutter.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -55,11 +55,11 ＠＠ struct display_glyph_area* dga); #define WINDOW_GUTTER_BORDER_WIDTH(w, pos) \ - (INTP ((w)->gutter_border_width[pos]) ? XINT ((w)->gutter_border_width[pos]) : 0) + (FIXNUMP ((w)->gutter_border_width[pos]) ? XFIXNUM ((w)->gutter_border_width[pos]) : 0) #define WINDOW_GUTTER_SIZE(w, pos) \ - (INTP ((w)->gutter_size[pos]) ? XINT ((w)->gutter_size[pos]) : 0) + (FIXNUMP ((w)->gutter_size[pos]) ? XFIXNUM ((w)->gutter_size[pos]) : 0) #define WINDOW_GUTTER_SIZE_INTERNAL(w, pos) \ - (INTP ((w)->real_gutter_size[pos]) ? XINT ((w)->real_gutter_size[pos]) : 0) + (FIXNUMP ((w)->real_gutter_size[pos]) ? XFIXNUM ((w)->real_gutter_size[pos]) : 0) #define WINDOW_GUTTER_VISIBLE(w, pos) \ ((w)->gutter_visible_p[pos]) #define WINDOW_GUTTER(w, pos) \ diff -r a0e81357194e -r 56144c8593a8 src/indent.c --- a/src/indent.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/indent.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -67,7 +67,7 ＠＠ Lisp_Object value; buffer = wrap_buffer (buf); - value = Fprevious_single_char_property_change (make_int (pos), Qinvisible, + value = Fprevious_single_char_property_change (make_fixnum (pos), Qinvisible, buffer, Qnil); if (NILP (value)) return 0; /* no visible position found */ ＠＠ -78,7 +78,7 ＠＠ invisible extent. Not sure what the correct solution is here. Rethink indent-to? */ - return XINT (value); + return XFIXNUM (value); } #ifdef REGION_CACHE_NEEDS_WORK ＠＠ -125,7 +125,7 ＠＠ { int col; int tab_seen; - int tab_width = XINT (buf->tab_width); + int tab_width = XFIXNUM (buf->tab_width); int post_tab; Charbpos pos = init_pos; Ichar c; ＠＠ -263,7 +263,7 ＠＠ */ (buffer)) { - return make_int (current_column (decode_buffer (buffer, 0))); + return make_fixnum (current_column (decode_buffer (buffer, 0))); }  ＠＠ -279,27 +279,27 ＠＠ int mincol; int fromcol; struct buffer *buf = decode_buffer (buffer, 0); - int tab_width = XINT (buf->tab_width); + int tab_width = XFIXNUM (buf->tab_width); Charbpos opoint = 0; - CHECK_INT (column); + CHECK_FIXNUM (column); if (NILP (minimum)) minimum = Qzero; else - CHECK_INT (minimum); + CHECK_FIXNUM (minimum); buffer = wrap_buffer (buf); fromcol = current_column (buf); - mincol = fromcol + XINT (minimum); - if (mincol < XINT (column)) mincol = XINT (column); + mincol = fromcol + XFIXNUM (minimum); + if (mincol < XFIXNUM (column)) mincol = XFIXNUM (column); if (fromcol == mincol) - return make_int (mincol); + return make_fixnum (mincol); if (tab_width <= 0 || tab_width > 1000) tab_width = 8; - if (!NILP (Fextent_at (make_int (BUF_PT (buf)), buffer, Qinvisible, + if (!NILP (Fextent_at (make_fixnum (BUF_PT (buf)), buffer, Qinvisible, Qnil, Qnil))) { Charbpos last_visible = last_visible_position (BUF_PT (buf), buf); ＠＠ -316,13 +316,13 ＠＠ int n = mincol / tab_width - fromcol / tab_width; if (n != 0) { - Finsert_char (make_char ('\t'), make_int (n), Qnil, buffer); + Finsert_char (make_char ('\t'), make_fixnum (n), Qnil, buffer); fromcol = (mincol / tab_width) * tab_width; } } - Finsert_char (make_char (' '), make_int (mincol - fromcol), Qnil, buffer); + Finsert_char (make_char (' '), make_fixnum (mincol - fromcol), Qnil, buffer); last_known_column_buffer = buf; last_known_column = mincol; ＠＠ -333,7 +333,7 ＠＠ if (opoint > 0) BUF_SET_PT (buf, opoint); - return make_int (mincol); + return make_fixnum (mincol); } int ＠＠ -342,7 +342,7 ＠＠ Bytebpos byte_end = BYTE_BUF_ZV (b); int col = 0; Ichar c; - int tab_width = XINT (b->tab_width); + int tab_width = XFIXNUM (b->tab_width); if (tab_width <= 0 || tab_width > 1000) tab_width = 8; ＠＠ -370,10 +370,10 ＠＠ buffer = wrap_buffer (buf); - if (!NILP (Fextent_at (make_int (pos), buffer, Qinvisible, Qnil, Qnil))) + if (!NILP (Fextent_at (make_fixnum (pos), buffer, Qinvisible, Qnil, Qnil))) return Qzero; - return make_int (byte_spaces_at_point (buf, charbpos_to_bytebpos (buf, pos))); + return make_fixnum (byte_spaces_at_point (buf, charbpos_to_bytebpos (buf, pos))); }  ＠＠ -403,7 +403,7 ＠＠ int col = current_column (buf); int goal; Charbpos end; - int tab_width = XINT (buf->tab_width); + int tab_width = XFIXNUM (buf->tab_width); int prev_col = 0; Ichar c = 0; ＠＠ -411,8 +411,8 ＠＠ buffer = wrap_buffer (buf); if (tab_width <= 0 || tab_width > 1000) tab_width = 8; - check_integer_range (column, Qzero, make_integer (EMACS_INT_MAX)); - goal = XINT (column); + check_integer_range (column, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); + goal = XFIXNUM (column); retry: pos = BUF_PT (buf); ＠＠ -471,7 +471,7 ＠＠ if (!NILP (force) && col > goal && c == '\t' && prev_col < goal) { buffer_delete_range (buf, BUF_PT (buf) - 1, BUF_PT (buf), 0); - Findent_to (make_int (col - 1), Qzero, buffer); + Findent_to (make_fixnum (col - 1), Qzero, buffer); buffer_insert_emacs_char (buf, ' '); goto retry; } ＠＠ -480,7 +480,7 ＠＠ if (col < goal && !NILP (force) && !EQ (force, Qcoerce)) { col = goal; - Findent_to (make_int (col), Qzero, buffer); + Findent_to (make_fixnum (col), Qzero, buffer); } last_known_column_buffer = buf; ＠＠ -488,7 +488,7 ＠＠ last_known_column_point = BUF_PT (buf); last_known_column_modified = BUF_MODIFF (buf); - return make_int (col); + return make_fixnum (col); } #if 0 /* #### OK boys, this function needs to be present, I think. ＠＠ -541,36 +541,36 ＠＠ int hscroll, tab_offset; struct window *w = decode_window (window); - CHECK_INT_COERCE_MARKER (from); + CHECK_FIXNUM_COERCE_MARKER (from); CHECK_CONS (frompos); - CHECK_INT (XCAR (frompos)); - CHECK_INT (XCDR (frompos)); - CHECK_INT_COERCE_MARKER (to); + CHECK_FIXNUM (XCAR (frompos)); + CHECK_FIXNUM (XCDR (frompos)); + CHECK_FIXNUM_COERCE_MARKER (to); CHECK_CONS (topos); - CHECK_INT (XCAR (topos)); - CHECK_INT (XCDR (topos)); - CHECK_INT (width); + CHECK_FIXNUM (XCAR (topos)); + CHECK_FIXNUM (XCDR (topos)); + CHECK_FIXNUM (width); if (!NILP (offsets)) { CHECK_CONS (offsets); - CHECK_INT (XCAR (offsets)); - CHECK_INT (XCDR (offsets)); - hscroll = XINT (XCAR (offsets)); - tab_offset = XINT (XCDR (offsets)); + CHECK_FIXNUM (XCAR (offsets)); + CHECK_FIXNUM (XCDR (offsets)); + hscroll = XFIXNUM (XCAR (offsets)); + tab_offset = XFIXNUM (XCDR (offsets)); } else hscroll = tab_offset = 0; - pos = compute_motion (XINT (from), XINT (XCDR (frompos)), - XINT (XCAR (frompos)), - XINT (to), XINT (XCDR (topos)), - XINT (XCAR (topos)), - XINT (width), hscroll, tab_offset, w); + pos = compute_motion (XFIXNUM (from), XFIXNUM (XCDR (frompos)), + XFIXNUM (XCAR (frompos)), + XFIXNUM (to), XFIXNUM (XCDR (topos)), + XFIXNUM (XCAR (topos)), + XFIXNUM (width), hscroll, tab_offset, w); - charbpos = make_int (pos->charbpos); - hpos = make_int (pos->hpos); - vpos = make_int (pos->vpos); - prevhpos = make_int (pos->prevhpos); + charbpos = make_fixnum (pos->charbpos); + hpos = make_fixnum (pos->hpos); + vpos = make_fixnum (pos->vpos); + prevhpos = make_fixnum (pos->prevhpos); return list5 (charbpos, hpos, vpos, prevhpos, pos->contin ? Qt : Qnil); ＠＠ -715,7 +715,7 ＠＠ window = Fselected_window (Qnil); CHECK_LIVE_WINDOW (window); - CHECK_INT (lines); + CHECK_FIXNUM (lines); selected = (EQ (window, Fselected_window (Qnil))); ＠＠ -727,17 +727,17 ＠＠ vpos = pixels ? NULL : &value; vpix = pixels ? &value : NULL; - charbpos = vmotion_1 (w, orig, XINT (lines), vpos, vpix); + charbpos = vmotion_1 (w, orig, XFIXNUM (lines), vpos, vpix); /* Note that the buffer's point is set, not the window's point. */ if (selected) BUF_SET_PT (XBUFFER (w->buffer), charbpos); else set_marker_restricted (w->pointm[CURRENT_DISP], - make_int(charbpos), + make_fixnum(charbpos), w->buffer); - return make_int (value); + return make_fixnum (value); } DEFUN ("vertical-motion", Fvertical_motion, 1, 3, 0, /* ＠＠ -898,7 +898,7 ＠＠ window = Fselected_window (Qnil); CHECK_LIVE_WINDOW (window); - CHECK_INT (pixels); + CHECK_FIXNUM (pixels); selected = (EQ (window, Fselected_window (Qnil))); ＠＠ -907,18 +907,18 ＠＠ orig = selected ? BUF_PT (XBUFFER (w->buffer)) : marker_position (w->pointm[CURRENT_DISP]); - howto = INTP (how) ? XINT (how) : 0; + howto = FIXNUMP (how) ? XFIXNUM (how) : 0; - charbpos = vmotion_pixels (window, orig, XINT (pixels), howto, &motion); + charbpos = vmotion_pixels (window, orig, XFIXNUM (pixels), howto, &motion); if (selected) BUF_SET_PT (XBUFFER (w->buffer), charbpos); else set_marker_restricted (w->pointm[CURRENT_DISP], - make_int(charbpos), + make_fixnum(charbpos), w->buffer); - return make_int (motion); + return make_fixnum (motion); }  diff -r a0e81357194e -r 56144c8593a8 src/insdel.c --- a/src/insdel.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/insdel.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -498,7 +498,7 ＠＠ That won't work because so many places use `int'. */ if (BUF_Z (buf) - BUF_BEG (buf) + BUF_GAP_SIZE (buf) + increment - > EMACS_INT_MAX) + > MOST_POSITIVE_FIXNUM) out_of_memory ("Maximum buffer size exceeded", Qunbound); result = BUFFER_REALLOC (buf->text->beg, ＠＠ -820,12 +820,12 ＠＠ set_buffer_internal (buf); va_run_hook_with_args_trapping_problems (Qchange, Qbefore_change_functions, 2, - make_int (start), make_int (end), + make_fixnum (start), make_fixnum (end), INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION); /* Obsolete, for compatibility */ va_run_hook_with_args_trapping_problems (Qchange, Qbefore_change_function, 2, - make_int (start), make_int (end), + make_fixnum (start), make_fixnum (end), INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION); } } ＠＠ -909,14 +909,14 ＠＠ different arguments than what we were passed. */ va_run_hook_with_args_trapping_problems (Qchange, Qafter_change_functions, 3, - make_int (start), make_int (new_end), - make_int (orig_end - start), + make_fixnum (start), make_fixnum (new_end), + make_fixnum (orig_end - start), INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION); /* Obsolete, for compatibility */ va_run_hook_with_args_trapping_problems (Qchange, Qafter_change_function, 3, - make_int (start), make_int (new_end), - make_int (orig_end - start), + make_fixnum (start), make_fixnum (new_end), + make_fixnum (orig_end - start), INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION); } } ＠＠ -1092,7 +1092,7 ＠＠ #endif /* Make sure that point-max won't exceed the size of an emacs int. */ - if ((length + BUF_Z (buf)) > EMACS_INT_MAX) + if ((length + BUF_Z (buf)) > MOST_POSITIVE_FIXNUM) out_of_memory ("Maximum buffer size exceeded", Qunbound); /* theoretically not necessary -- caller should GCPRO. diff -r a0e81357194e -r 56144c8593a8 src/intl-win32.c --- a/src/intl-win32.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/intl-win32.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1017,7 +1017,7 ＠＠ (locale)) { LCID lcid = NILP (locale) ? current_locale : locale_to_lcid (locale); - return make_int (mswindows_locale_to_code_page (lcid)); + return make_fixnum (mswindows_locale_to_code_page (lcid)); } DEFUN ("mswindows-locale-oem-code-page", Fmswindows_locale_oem_code_page, ＠＠ -1028,7 +1028,7 ＠＠ (locale)) { LCID lcid = NILP (locale) ? current_locale : locale_to_lcid (locale); - return make_int (mswindows_locale_to_oem_code_page (lcid)); + return make_fixnum (mswindows_locale_to_oem_code_page (lcid)); } static DWORD ＠＠ -1184,7 +1184,7 ＠＠ (charset, code_page)) { charset = Fget_charset (charset); - CHECK_INT (code_page); + CHECK_FIXNUM (code_page); Fputhash (charset, code_page, Vmswindows_charset_code_page_table); return Qnil; } ＠＠ -1200,8 +1200,8 ＠＠ Lisp_Object charset_code_page; charset_code_page = Fmswindows_charset_code_page (XCAR (charset_tail)); - if (INTP (charset_code_page) && - code_page == XINT (charset_code_page)) + if (FIXNUMP (charset_code_page) && + code_page == XFIXNUM (charset_code_page)) { charset = Fget_charset (XCAR (charset_tail)); break; ＠＠ -1289,14 +1289,14 ＠＠ Extbyte abbrev_name[32] = { 0 }; Extbyte full_name[256] = { 0 }; - CHECK_INT (lcid); + CHECK_FIXNUM (lcid); - if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED)) + if (!IsValidLocale (XFIXNUM (lcid), LCID_SUPPORTED)) return Qnil; if (NILP (longform)) { - got_abbrev = qxeGetLocaleInfo (XINT (lcid), + got_abbrev = qxeGetLocaleInfo (XFIXNUM (lcid), LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP, abbrev_name, sizeof (abbrev_name)); ＠＠ -1305,7 +1305,7 ＠＠ } else if (EQ (longform, Qt)) { - got_full = qxeGetLocaleInfo (XINT (lcid), + got_full = qxeGetLocaleInfo (XFIXNUM (lcid), LOCALE_SLANGUAGE | LOCALE_USE_CP_ACP, full_name, sizeof (full_name)); if (got_full) ＠＠ -1313,8 +1313,8 ＠＠ } else if (NUMBERP (longform)) { - got_full = qxeGetLocaleInfo (XINT (lcid), - XINT (longform), + got_full = qxeGetLocaleInfo (XFIXNUM (lcid), + XFIXNUM (longform), full_name, sizeof (full_name)); if (got_full) return build_tstr_string (full_name); ＠＠ -1330,7 +1330,7 ＠＠ BOOL CALLBACK enum_code_page_fn (LPTSTR codepageNum) { DWORD id = atoi (codepageNum); - Vmswindows_valid_code_pages = Fcons (make_int (id), Vmswindows_valid_code_pages); + Vmswindows_valid_code_pages = Fcons (make_fixnum (id), Vmswindows_valid_code_pages); return TRUE; } ＠＠ -1352,7 +1352,7 ＠＠ */ ()) { - return make_int (GetConsoleCP ()); + return make_fixnum (GetConsoleCP ()); } DEFUN ("mswindows-set-console-code-page", Fmswindows_set_console_code_page, 1, 1, 0, /* ＠＠ -1362,15 +1362,15 ＠＠ */ (cp)) { - CHECK_INT (cp); + CHECK_FIXNUM (cp); - if (!IsValidCodePage (XINT (cp))) + if (!IsValidCodePage (XFIXNUM (cp))) return Qnil; - if (!SetConsoleCP (XINT (cp))) + if (!SetConsoleCP (XFIXNUM (cp))) return Qnil; - return make_int (GetConsoleCP ()); + return make_fixnum (GetConsoleCP ()); } DEFUN ("mswindows-get-console-output-code-page", Fmswindows_get_console_output_code_page, 0, 0, 0, /* ＠＠ -1378,7 +1378,7 ＠＠ */ ()) { - return make_int (GetConsoleOutputCP ()); + return make_fixnum (GetConsoleOutputCP ()); } DEFUN ("mswindows-set-console-output-code-page", Fmswindows_set_console_output_code_page, 1, 1, 0, /* ＠＠ -1388,15 +1388,15 ＠＠ */ (cp)) { - CHECK_INT (cp); + CHECK_FIXNUM (cp); - if (!IsValidCodePage (XINT (cp))) + if (!IsValidCodePage (XFIXNUM (cp))) return Qnil; - if (!SetConsoleOutputCP (XINT (cp))) + if (!SetConsoleOutputCP (XFIXNUM (cp))) return Qnil; - return make_int (GetConsoleOutputCP ()); + return make_fixnum (GetConsoleOutputCP ()); } DEFUN ("mswindows-get-code-page-charset", Fmswindows_get_code_page_charset, 1, 1, 0, /* ＠＠ -1407,13 +1407,13 ＠＠ { CHARSETINFO info; - CHECK_INT (cp); + CHECK_FIXNUM (cp); - if (!IsValidCodePage (XINT (cp))) + if (!IsValidCodePage (XFIXNUM (cp))) return Qnil; - if (TranslateCharsetInfo ((DWORD *) XINT (cp), &info, TCI_SRCCODEPAGE)) - return make_int (info.ciCharset); + if (TranslateCharsetInfo ((DWORD *) XFIXNUM (cp), &info, TCI_SRCCODEPAGE)) + return make_fixnum (info.ciCharset); return Qnil; } ＠＠ -1434,8 +1434,8 ＠＠ { DWORD kl = (DWORD) layouts[num_layouts]; - obj = Fcons (Fcons (make_int (kl & 0xffff), - make_int ((kl >> 16) & 0xffff)), + obj = Fcons (Fcons (make_fixnum (kl & 0xffff), + make_fixnum ((kl >> 16) & 0xffff)), obj); } } ＠＠ -1451,8 +1451,8 ＠＠ { DWORD kl = (DWORD) GetKeyboardLayout (dwWindowsThreadId); - return Fcons (make_int (kl & 0xffff), - make_int ((kl >> 16) & 0xffff)); + return Fcons (make_fixnum (kl & 0xffff), + make_fixnum ((kl >> 16) & 0xffff)); } DEFUN ("mswindows-set-keyboard-layout", Fmswindows_set_keyboard_layout, 1, 1, 0, /* ＠＠ -1465,11 +1465,11 ＠＠ DWORD kl; CHECK_CONS (layout); - CHECK_INT (XCAR (layout))); - CHECK_INT (XCDR (layout))); + CHECK_FIXNUM (XCAR (layout))); + CHECK_FIXNUM (XCDR (layout))); - kl = (XINT (XCAR (layout))) & 0xffff) - | (XINT (XCDR (layout))) << 16); + kl = (XFIXNUM (XCAR (layout))) & 0xffff) + | (XFIXNUM (XCDR (layout))) << 16); if (!ActivateKeyboardLayout ((HKL) kl, 0)) return Qnil; ＠＠ -1793,10 +1793,10 ＠＠ data->locale_type = MULTIBYTE_SPECIFIED_CODE_PAGE; #ifdef HAVE_BIGNUM check_integer_range (value, Qzero, make_integer (INT_MAX)); - data->cp = BIGNUMP (value) ? bignum_to_int (XBIGNUM_DATA (value)) : XINT (value); + data->cp = BIGNUMP (value) ? bignum_to_int (XBIGNUM_DATA (value)) : XFIXNUM (value); #else CHECK_NATNUM (value); - data->cp = XINT (value); + data->cp = XFIXNUM (value); #endif } } ＠＠ -1833,7 +1833,7 ＠＠ if (EQ (prop, Qcode_page)) { if (data->locale_type == MULTIBYTE_SPECIFIED_CODE_PAGE) - return make_int (data->cp); + return make_fixnum (data->cp); else switch (data->cp_type) { ＠＠ -1872,7 +1872,7 ＠＠ write_ascstring (printcharfun, "("); if (data->locale_type == MULTIBYTE_SPECIFIED_CODE_PAGE) - print_internal (make_int (data->cp), printcharfun, 1); + print_internal (make_fixnum (data->cp), printcharfun, 1); else { write_fmt_string_lisp (printcharfun, "%s, ", 1, mswindows_multibyte_to_unicode_getprop (cs, Qlocale)); diff -r a0e81357194e -r 56144c8593a8 src/keymap.c --- a/src/keymap.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/keymap.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -151,8 +151,8 ＠＠ #include "keymap-slots.h" }; -#define MAKE_MODIFIER_HASH_KEY(modifier) make_int (modifier) -#define MODIFIER_HASH_KEY_BITS(x) (INTP (x) ? XINT (x) : 0) +#define MAKE_MODIFIER_HASH_KEY(modifier) make_fixnum (modifier) +#define MODIFIER_HASH_KEY_BITS(x) (FIXNUMP (x) ? XFIXNUM (x) : 0)  ＠＠ -289,7 +289,7 ＠＠ write_fmt_string_lisp (printcharfun, "%S ", 1, keymap->name); } write_fmt_string (printcharfun, "size %ld 0x%x>", - (long) XINT (Fkeymap_fullness (obj)), + (long) XFIXNUM (Fkeymap_fullness (obj)), LISP_OBJECT_UID (obj)); } ＠＠ -1081,15 +1081,15 ＠＠ } else if (CONSP (idx)) { - if (!INTP (XCDR (idx))) + if (!FIXNUMP (XCDR (idx))) return Qnil; indirection.keysym = XCAR (idx); - indirection.modifiers = (unsigned char) XINT (XCDR (idx)); + indirection.modifiers = (unsigned char) XFIXNUM (XCDR (idx)); } else if (SYMBOLP (idx)) { indirection.keysym = idx; - SET_KEY_DATA_MODIFIERS (&indirection, XINT (XCDR (idx))); + SET_KEY_DATA_MODIFIERS (&indirection, XFIXNUM (XCDR (idx))); } else { ＠＠ -1237,7 +1237,7 ＠＠ struct gcpro gcpro1, gcpro2; keymap = get_keymap (keymap, 1, 1); - fullness = XINT (Fhash_table_count (XKEYMAP (keymap)->table)); + fullness = XFIXNUM (Fhash_table_count (XKEYMAP (keymap)->table)); GCPRO2 (keymap, sub_maps); for (sub_maps = keymap_submaps (keymap); !NILP (sub_maps); ＠＠ -1260,7 +1260,7 ＠＠ (keymap)) { /* This function can GC */ - return make_int (keymap_fullness (get_keymap (keymap, 1, 1))); + return make_fixnum (keymap_fullness (get_keymap (keymap, 1, 1))); }  ＠＠ -1556,7 +1556,7 ＠＠ struct gcpro gcpro1; if (XEVENT_TYPE (event) != key_press_event || NILP (key_specifier) || - (INTP (key_specifier) && !CHAR_INTP (key_specifier))) + (FIXNUMP (key_specifier) && !CHAR_INTP (key_specifier))) return 0; /* if the specifier is an integer such as 27, then it should match ＠＠ -1722,7 +1722,7 ＠＠ Lisp_Object mpc_binding; Lisp_Key_Data meta_key; if (NILP (Vmeta_prefix_char) || - (INTP (Vmeta_prefix_char) && !CHAR_INTP (Vmeta_prefix_char))) + (FIXNUMP (Vmeta_prefix_char) && !CHAR_INTP (Vmeta_prefix_char))) return; define_key_parser (Vmeta_prefix_char, &meta_key); ＠＠ -1733,7 +1733,7 ＠＠ if (indx == 0) new_keys = keys; else if (STRINGP (keys)) - new_keys = Fsubseq (keys, Qzero, make_int (indx)); + new_keys = Fsubseq (keys, Qzero, make_fixnum (indx)); else if (VECTORP (keys)) { new_keys = make_vector (indx, Qnil); ＠＠ -1909,7 +1909,7 ＠＠ else { keys = wrong_type_argument (Qsequencep, keys); - len = XINT (Flength (keys)); + len = XFIXNUM (Flength (keys)); } if (len == 0) return Qnil; ＠＠ -2100,7 +2100,7 ＠＠ /* Didn't find a keymap, and we have more keys. * Return a fixnum to indicate that keys were too long. */ - cmd = make_int (keys_so_far + 1); + cmd = make_fixnum (keys_so_far + 1); else cmd = raw_lookup_key (cmd, raw_keys + 1, remaining, keys_so_far + 1, accept_default); ＠＠ -2220,7 +2220,7 ＠＠ { tem = raw_lookup_key (keymaps[iii], raw_keys, nkeys, 0, accept_default); - if (INTP (tem)) + if (FIXNUMP (tem)) { /* Too long in some local map means don't look at global map */ tem = Qnil; ＠＠ -2377,7 +2377,7 ＠＠ keymap. */ if (EVENTP (terminal)) { - get_relevant_extent_keymaps (make_int (BUF_PT (current_buffer)), + get_relevant_extent_keymaps (make_fixnum (BUF_PT (current_buffer)), tem, Qnil, &closure); } get_relevant_minor_maps (tem, &closure); ＠＠ -2670,7 +2670,7 ＠＠ { Lisp_Object tem = Flookup_key (maps[i], keys, accept_default); - if (INTP (tem)) + if (FIXNUMP (tem)) { /* Too long in some local map means don't look at global map */ return Qnil; ＠＠ -2981,7 +2981,7 ＠＠ struct gcpro gcpro1; Lisp_Object contents = Qnil; - if (XINT (Fhash_table_count (keymap_table)) == 0) + if (XFIXNUM (Fhash_table_count (keymap_table)) == 0) return; GCPRO1 (contents); ＠＠ -3193,7 +3193,7 ＠＠ } else if (VECTORP (prefix) || STRINGP (prefix)) { - int len = XINT (Flength (prefix)); + int len = XFIXNUM (Flength (prefix)); Lisp_Object def; Lisp_Object p; int iii; ＠＠ -3216,7 +3216,7 ＠＠ for (iii = 0; iii < len; iii++) { Lisp_Key_Data key; - define_key_parser (Faref (prefix, make_int (iii)), &key); + define_key_parser (Faref (prefix, make_fixnum (iii)), &key); XVECTOR_DATA (p)[iii] = make_key_description (&key, 1); } NUNGCPRO; ＠＠ -3270,7 +3270,7 ＠＠ { Lisp_Object string = Qnil; /* Lisp_Object sep = Qnil; */ - int size = XINT (Flength (keys)); + int size = XFIXNUM (Flength (keys)); int i; for (i = 0; i < size; i++) ＠＠ -3496,7 +3496,7 ＠＠ Lisp_Object rest; int i; - nmaps = XINT (Flength (keymaps)); + nmaps = XFIXNUM (Flength (keymaps)); if (nmaps > countof (maps)) { gubbish = alloca_array (Lisp_Object, nmaps); ＠＠ -3666,7 +3666,7 ＠＠ { assert (firstonly); format_raw_keys (so_far, keys_count + 1, target_buffer); - return make_int (1); + return make_fixnum (1); } else if (firstonly) return raw_keys_to_keys (so_far, keys_count + 1); ＠＠ -3872,7 +3872,7 ＠＠ Lisp_Object elt = Fcar (maps); Lisp_Object tail; int no_prefix = (VECTORP (Fcar (elt)) - && XINT (Flength (Fcar (elt))) == 0); + && XFIXNUM (Flength (Fcar (elt))) == 0); struct gcpro ngcpro1, ngcpro2, ngcpro3; NGCPRO3 (sub_shadow, elt, tail); ＠＠ -3935,7 +3935,7 ＠＠ struct gcpro gcpro1; GCPRO1 (definition); - Findent_to (make_int (16), make_int (3), buffer); + Findent_to (make_fixnum (16), make_fixnum (3), buffer); if (keymapp) buffer_insert_ascstring (XBUFFER (buffer), "<< "); ＠＠ -4078,7 +4078,7 ＠＠ } /* Otherwise add it to the list to be sorted. */ - *(closure->list) = Fcons (Fcons (Fcons (keysym, make_int (modifiers)), + *(closure->list) = Fcons (Fcons (Fcons (keysym, make_fixnum (modifiers)), binding), *(closure->list)); } ＠＠ -4095,8 +4095,8 ＠＠ int bit1, bit2; obj1 = XCAR (obj1); obj2 = XCAR (obj2); - bit1 = XINT (XCDR (obj1)); - bit2 = XINT (XCDR (obj2)); + bit1 = XFIXNUM (XCDR (obj1)); + bit2 = XFIXNUM (XCDR (obj2)); if (bit1 != bit2) return bit1 < bit2; else ＠＠ -4214,7 +4214,7 ＠＠ { Lisp_Object elt = XCAR (XCAR (list)); Lisp_Object keysym = XCAR (elt); - int modifiers = XINT (XCDR (elt)); + int modifiers = XFIXNUM (XCDR (elt)); if (!NILP (elt_prefix)) buffer_insert_lisp_string (buf, elt_prefix); diff -r a0e81357194e -r 56144c8593a8 src/line-number.c --- a/src/line-number.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/line-number.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -111,7 +111,7 ＠＠ /* Calculating the line number of BUF_BEGV here is a bad idea, because there is absolutely no reason to do it before the next redisplay. We simply mark it as dirty instead. */ - LINE_NUMBER_BEGV (b) = make_int (-1); + LINE_NUMBER_BEGV (b) = make_fixnum (-1); } /* Invalidate the line number cache positions that lie after POS. */ ＠＠ -199,7 +199,7 ＠＠ will be stored in LINE. *LINE should be initialized to the line number of BEG (normally, - BEG will be BUF_BEGV, and *LINE will be XINT (LINE_NUMBER_BEGV). + BEG will be BUF_BEGV, and *LINE will be XFIXNUM (LINE_NUMBER_BEGV). This will initialize the cache, if necessary. */ static void get_nearest_line_number (struct buffer *b, Charbpos *beg, Charbpos pos, ＠＠ -223,7 +223,7 ＠＠ { length = howfar; *beg = newpos; - *line = XINT (XCDR (ring[i])); + *line = XFIXNUM (XCDR (ring[i])); } } } ＠＠ -244,9 +244,9 ＠＠ ring[i] = ring[i - 1]; /* ...and update it. */ - ring[0] = Fcons (Fset_marker (Fmake_marker (), make_int (pos), + ring[0] = Fcons (Fset_marker (Fmake_marker (), make_fixnum (pos), wrap_buffer (b)), - make_int (line)); + make_fixnum (line)); } /* Calculate the line number in buffer B at position POS. If CACHEP ＠＠ -280,21 +280,21 ＠＠ if (NILP (b->text->line_number_cache)) allocate_line_number_cache (b); /* If we don't know the line number of BUF_BEGV, calculate it now. */ - if (XINT (LINE_NUMBER_BEGV (b)) == -1) + if (XFIXNUM (LINE_NUMBER_BEGV (b)) == -1) { LINE_NUMBER_BEGV (b) = Qzero; /* #### This has a side-effect of changing the cache. */ LINE_NUMBER_BEGV (b) = - make_int (buffer_line_number (b, BUF_BEGV (b), 1)); + make_fixnum (buffer_line_number (b, BUF_BEGV (b), 1)); } - cached_lines = XINT (LINE_NUMBER_BEGV (b)); + cached_lines = XFIXNUM (LINE_NUMBER_BEGV (b)); get_nearest_line_number (b, &beg, pos, &cached_lines); } - scan_buffer (b, '\n', beg, pos, pos > beg ? EMACS_INT_MAX : -EMACS_INT_MAX, + scan_buffer (b, '\n', beg, pos, pos > beg ? MOST_POSITIVE_FIXNUM : -MOST_POSITIVE_FIXNUM, &shortage, 0); - line = EMACS_INT_MAX - shortage; + line = MOST_POSITIVE_FIXNUM - shortage; if (beg > pos) line = -line; line += cached_lines; ＠＠ -306,7 +306,7 ＠＠ add_position_to_cache (b, pos, line); /* Account for narrowing. If cache is not used, this is unnecessary, because we counted from BUF_BEGV anyway. */ - line -= XINT (LINE_NUMBER_BEGV (b)); + line -= XFIXNUM (LINE_NUMBER_BEGV (b)); } return line; diff -r a0e81357194e -r 56144c8593a8 src/lisp-disunion.h --- a/src/lisp-disunion.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/lisp-disunion.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -41,7 +41,7 ＠＠ The object is obtained by masking off the type bits. Bit 1 is used as a value bit by splitting the Lisp integer type - into two subtypes, Lisp_Type_Int_Even and Lisp_Type_Int_Odd. + into two subtypes, Lisp_Type_Fixnum_Even and Lisp_Type_Fixnum_Odd. By this trickery we get 31 bits for integers instead of 30. For non-integral types, the value bits of a Lisp_Object contain ＠＠ -67,46 +67,46 ＠＠ XTYPE The type bits of a Lisp_Object XPNTRVAL The value bits of a Lisp_Object storing a pointer XCHARVAL The value bits of a Lisp_Object storing a Ichar - XREALINT The value bits of a Lisp_Object storing an integer, signed + XREALFIXNUM The value bits of a Lisp_Object storing an integer, signed XUINT The value bits of a Lisp_Object storing an integer, unsigned - INTP Non-zero if this Lisp_Object is an integer + FIXNUMP Non-zero if this Lisp_Object is an integer Qzero Lisp Integer 0 EQ Non-zero if two Lisp_Objects are identical, not merely equal. */ typedef EMACS_INT Lisp_Object; -#define Lisp_Type_Int_Bit (Lisp_Type_Int_Even & Lisp_Type_Int_Odd) +#define Lisp_Type_Fixnum_Bit (Lisp_Type_Fixnum_Even & Lisp_Type_Fixnum_Odd) #define VALMASK (((1UL << VALBITS) - 1UL) << GCTYPEBITS) #define XTYPE(x) ((enum Lisp_Type) (((EMACS_UINT)(x)) & ~VALMASK)) #define XPNTRVAL(x) (x) /* This depends on Lisp_Type_Record == 0 */ #define XCHARVAL(x) ((x) >> GCBITS) -#define XREALINT(x) ((x) >> INT_GCBITS) -#define XUINT(x) ((EMACS_UINT)(x) >> INT_GCBITS) +#define XREALFIXNUM(x) ((x) >> FIXNUM_GCBITS) +#define XUINT(x) ((EMACS_UINT)(x) >> FIXNUM_GCBITS) #define wrap_pointer_1(ptr) ((Lisp_Object) (ptr)) DECLARE_INLINE_HEADER ( Lisp_Object -make_int_verify (EMACS_INT val) +make_fixnum_verify (EMACS_INT val) ) { - Lisp_Object obj = (Lisp_Object) ((val << INT_GCBITS) | Lisp_Type_Int_Bit); - type_checking_assert (XREALINT (obj) == val); + Lisp_Object obj = (Lisp_Object) ((val << FIXNUM_GCBITS) | Lisp_Type_Fixnum_Bit); + type_checking_assert (XREALFIXNUM (obj) == val); return obj; } -#define make_int(x) ((Lisp_Object) (((x) << INT_GCBITS) | Lisp_Type_Int_Bit)) +#define make_fixnum(x) ((Lisp_Object) (((x) << FIXNUM_GCBITS) | Lisp_Type_Fixnum_Bit)) #define make_char_1(x) ((Lisp_Object) (((x) << GCBITS) | Lisp_Type_Char)) -#define INTP(x) ((EMACS_UINT)(x) & Lisp_Type_Int_Bit) -#define INT_PLUS(x,y) ((x)+(y)-Lisp_Type_Int_Bit) -#define INT_MINUS(x,y) ((x)-(y)+Lisp_Type_Int_Bit) -#define INT_PLUS1(x) INT_PLUS (x, make_int (1)) -#define INT_MINUS1(x) INT_MINUS (x, make_int (1)) +#define FIXNUMP(x) ((EMACS_UINT)(x) & Lisp_Type_Fixnum_Bit) +#define FIXNUM_PLUS(x,y) ((x)+(y)-Lisp_Type_Fixnum_Bit) +#define FIXNUM_MINUS(x,y) ((x)-(y)+Lisp_Type_Fixnum_Bit) +#define FIXNUM_PLUS1(x) FIXNUM_PLUS (x, make_fixnum (1)) +#define FIXNUM_MINUS1(x) FIXNUM_MINUS (x, make_fixnum (1)) -#define Qzero make_int (0) +#define Qzero make_fixnum (0) #define Qnull_pointer ((Lisp_Object) 0) #define EQ(x,y) ((x) == (y)) diff -r a0e81357194e -r 56144c8593a8 src/lisp-union.h --- a/src/lisp-union.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/lisp-union.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -38,14 +38,14 ＠＠ struct { - signed EMACS_INT val : INT_VALBITS; - unsigned int bits : INT_GCBITS; + signed EMACS_INT val : FIXNUM_VALBITS; + unsigned int bits : FIXNUM_GCBITS; } s; struct { - EMACS_UINT val : INT_VALBITS; - unsigned int bits : INT_GCBITS; + EMACS_UINT val : FIXNUM_VALBITS; + unsigned int bits : FIXNUM_GCBITS; } u; #else /* non-valbits are at higher addresses */ struct ＠＠ -56,14 +56,14 ＠＠ struct { - unsigned int bits : INT_GCBITS; - signed EMACS_INT val : INT_VALBITS; + unsigned int bits : FIXNUM_GCBITS; + signed EMACS_INT val : FIXNUM_VALBITS; } s; struct { - unsigned int bits : INT_GCBITS; - EMACS_UINT val : INT_VALBITS; + unsigned int bits : FIXNUM_GCBITS; + EMACS_UINT val : FIXNUM_VALBITS; } u; #endif /* non-valbits are at higher addresses */ ＠＠ -81,26 +81,26 ＠＠ #define XCHARVAL(x) ((EMACS_INT)(x).gu.val) #define XPNTRVAL(x) ((x).ui) -#define XREALINT(x) ((EMACS_INT)(x).s.val) +#define XREALFIXNUM(x) ((EMACS_INT)(x).s.val) #define XUINT(x) ((EMACS_UINT)(x).u.val) #define XTYPE(x) ((x).gu.type) #define EQ(x,y) ((x).v == (y).v) DECLARE_INLINE_HEADER ( Lisp_Object -make_int_verify (EMACS_INT val) +make_fixnum_verify (EMACS_INT val) ) { Lisp_Object obj; obj.s.bits = 1; obj.s.val = val; - type_checking_assert (XREALINT (obj) == val); + type_checking_assert (XREALFIXNUM (obj) == val); return obj; } DECLARE_INLINE_HEADER ( Lisp_Object -make_int (EMACS_INT val) +make_fixnum (EMACS_INT val) ) { Lisp_Object obj; ＠＠ -132,11 +132,11 ＠＠ extern MODULE_API Lisp_Object Qnull_pointer, Qzero; -#define INTP(x) ((x).s.bits) -#define INT_PLUS(x,y) make_int (XINT (x) + XINT (y)) -#define INT_MINUS(x,y) make_int (XINT (x) - XINT (y)) -#define INT_PLUS1(x) make_int (XINT (x) + 1) -#define INT_MINUS1(x) make_int (XINT (x) - 1) +#define FIXNUMP(x) ((x).s.bits) +#define FIXNUM_PLUS(x,y) make_fixnum (XFIXNUM (x) + XFIXNUM (y)) +#define FIXNUM_MINUS(x,y) make_fixnum (XFIXNUM (x) - XFIXNUM (y)) +#define FIXNUM_PLUS1(x) make_fixnum (XFIXNUM (x) + 1) +#define FIXNUM_MINUS1(x) make_fixnum (XFIXNUM (x) - 1) /* WARNING!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! diff -r a0e81357194e -r 56144c8593a8 src/lisp.h --- a/src/lisp.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/lisp.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1658,9 +1658,9 ＠＠ enum Lisp_Type { Lisp_Type_Record, - Lisp_Type_Int_Even, + Lisp_Type_Fixnum_Even, Lisp_Type_Char, - Lisp_Type_Int_Odd + Lisp_Type_Fixnum_Odd }; #define POINTER_TYPE_P(type) ((type) == Lisp_Type_Record) ＠＠ -1673,19 +1673,19 ＠＠ #define GCMARKBITS 0 #define GCTYPEBITS 2 #define GCBITS 2 -#define INT_GCBITS 1 - -#define INT_VALBITS (BITS_PER_EMACS_INT - INT_GCBITS) +#define FIXNUM_GCBITS 1 + +#define FIXNUM_VALBITS (BITS_PER_EMACS_INT - FIXNUM_GCBITS) #define VALBITS (BITS_PER_EMACS_INT - GCBITS) /* This is badly named; it's not the maximum value that an EMACS_INT can have, it's the maximum value that a Lisp-visible fixnum can have (half the maximum value an EMACS_INT can have) and as such would be better called MOST_POSITIVE_FIXNUM. Similarly for MOST_NEGATIVE_FIXNUM. */ -#define EMACS_INT_MAX ((EMACS_INT) ((1UL << (INT_VALBITS - 1)) -1UL)) -#define EMACS_INT_MIN (-(EMACS_INT_MAX) - 1) +#define MOST_POSITIVE_FIXNUM ((EMACS_INT) ((1UL << (FIXNUM_VALBITS - 1)) -1UL)) +#define MOST_NEGATIVE_FIXNUM (-(MOST_POSITIVE_FIXNUM) - 1) /* WARNING: evaluates its arg twice. */ -#define NUMBER_FITS_IN_AN_EMACS_INT(num) \ - ((num) <= EMACS_INT_MAX && (num) >= EMACS_INT_MIN) +#define NUMBER_FITS_IN_A_FIXNUM(num) \ + ((num) <= MOST_POSITIVE_FIXNUM && (num) >= MOST_NEGATIVE_FIXNUM) #ifdef USE_UNION_TYPE # include "lisp-union.h" ＠＠ -1700,7 +1700,7 ＠＠ #define HACKEQ_UNSAFE(obj1, obj2) \ (EQ (obj1, obj2) || (!POINTER_TYPE_P (XTYPE (obj1)) \ && !POINTER_TYPE_P (XTYPE (obj2)) \ - && XCHAR_OR_INT (obj1) == XCHAR_OR_INT (obj2))) + && XCHAR_OR_FIXNUM (obj1) == XCHAR_OR_FIXNUM (obj2))) #ifdef DEBUG_XEMACS extern MODULE_API int debug_issue_ebola_notices; ＠＠ -1744,7 +1744,7 ＠＠ EMACS_UINT p = (EMACS_UINT) ptr; type_checking_assert ((p & 1) == 0); - return make_int (p >> 1); + return make_fixnum (p >> 1); } DECLARE_INLINE_HEADER ( ＠＠ -2740,7 +2740,7 ＠＠ #define CHECK_BIT_VECTOR(x) CHECK_RECORD (x, bit_vector) #define CONCHECK_BIT_VECTOR(x) CONCHECK_RECORD (x, bit_vector) -#define BITP(x) (INTP (x) && (XINT (x) == 0 || XINT (x) == 1)) +#define BITP(x) (FIXNUMP (x) && (XFIXNUM (x) == 0 || XFIXNUM (x) == 1)) #define CHECK_BIT(x) do { \ if (!BITP (x)) \ ＠＠ -2938,7 +2938,7 ＠＠ #define CONCHECK_MARKER(x) CONCHECK_RECORD (x, marker) /* The second check was looking for GCed markers still in use */ -/* assert (!INTP (XMARKER (x)->lheader.next.v)); */ +/* assert (!FIXNUMP (XMARKER (x)->lheader.next.v)); */ #define marker_next(m) ((m)->next) #define marker_prev(m) ((m)->prev) ＠＠ -2949,30 +2949,30 ＠＠ #ifdef ERROR_CHECK_TYPES -#define XINT(x) XINT_1 (x, __FILE__, __LINE__) +#define XFIXNUM(x) XFIXNUM_1 (x, __FILE__, __LINE__) DECLARE_INLINE_HEADER ( EMACS_INT -XINT_1 (Lisp_Object obj, const Ascbyte *file, int line) +XFIXNUM_1 (Lisp_Object obj, const Ascbyte *file, int line) ) { - assert_at_line (INTP (obj), file, line); - return XREALINT (obj); + assert_at_line (FIXNUMP (obj), file, line); + return XREALFIXNUM (obj); } #else /* not ERROR_CHECK_TYPES */ -#define XINT(obj) XREALINT (obj) +#define XFIXNUM(obj) XREALFIXNUM (obj) #endif /* (not) ERROR_CHECK_TYPES */ -#define CHECK_INT(x) do { \ - if (!INTP (x)) \ +#define CHECK_FIXNUM(x) do { \ + if (!FIXNUMP (x)) \ dead_wrong_type_argument (Qfixnump, x); \ } while (0) -#define CONCHECK_INT(x) do { \ - if (!INTP (x)) \ +#define CONCHECK_FIXNUM(x) do { \ + if (!FIXNUMP (x)) \ x = wrong_type_argument (Qfixnump, x); \ } while (0) ＠＠ -3054,15 +3054,15 ＠＠ #ifdef ERROR_CHECK_TYPES -#define XCHAR_OR_INT(x) XCHAR_OR_INT_1 (x, __FILE__, __LINE__) +#define XCHAR_OR_FIXNUM(x) XCHAR_OR_FIXNUM_1 (x, __FILE__, __LINE__) DECLARE_INLINE_HEADER ( EMACS_INT -XCHAR_OR_INT_1 (Lisp_Object obj, const Ascbyte *file, int line) +XCHAR_OR_FIXNUM_1 (Lisp_Object obj, const Ascbyte *file, int line) ) { - assert_at_line (INTP (obj) || CHARP (obj), file, line); - return CHARP (obj) ? XCHAR (obj) : XINT (obj); + assert_at_line (FIXNUMP (obj) || CHARP (obj), file, line); + return CHARP (obj) ? XCHAR (obj) : XFIXNUM (obj); } #else /* no error checking */ ＠＠ -3071,10 +3071,10 ＠＠ of a macro. */ DECLARE_INLINE_HEADER ( EMACS_INT -XCHAR_OR_INT (Lisp_Object obj) +XCHAR_OR_FIXNUM (Lisp_Object obj) ) { - return CHARP (obj) ? XCHAR (obj) : XINT (obj); + return CHARP (obj) ? XCHAR (obj) : XFIXNUM (obj); } #endif /* no error checking */ ＠＠ -3082,7 +3082,7 ＠＠ /* True of X is an integer whose value is the valid integral equivalent of a character. */ -#define CHAR_INTP(x) (INTP (x) && valid_ichar_p (XINT (x))) +#define CHAR_INTP(x) (FIXNUMP (x) && valid_ichar_p (XFIXNUM (x))) /* True of X is a character or an integral value that can be converted into a character. */ ＠＠ -3093,7 +3093,7 ＠＠ XCHAR_OR_CHAR_INT (Lisp_Object obj) ) { - return CHARP (obj) ? XCHAR (obj) : XINT (obj); + return CHARP (obj) ? XCHAR (obj) : XFIXNUM (obj); } /* Signal an error if CH is not a valid character or integer Lisp_Object. ＠＠ -3105,37 +3105,37 ＠＠ if (CHARP (x)) \ ; \ else if (CHAR_INTP (x)) \ - x = make_char (XINT (x)); \ + x = make_char (XFIXNUM (x)); \ else \ x = wrong_type_argument (Qcharacterp, x); \ } while (0) /* next three always continuable because they coerce their arguments. */ -#define CHECK_INT_COERCE_CHAR(x) do { \ - if (INTP (x)) \ +#define CHECK_FIXNUM_COERCE_CHAR(x) do { \ + if (FIXNUMP (x)) \ ; \ else if (CHARP (x)) \ - x = make_int (XCHAR (x)); \ + x = make_fixnum (XCHAR (x)); \ else \ x = wrong_type_argument (Qinteger_or_char_p, x); \ } while (0) -#define CHECK_INT_COERCE_MARKER(x) do { \ - if (INTP (x)) \ +#define CHECK_FIXNUM_COERCE_MARKER(x) do { \ + if (FIXNUMP (x)) \ ; \ else if (MARKERP (x)) \ - x = make_int (marker_position (x)); \ + x = make_fixnum (marker_position (x)); \ else \ x = wrong_type_argument (Qinteger_or_marker_p, x); \ } while (0) -#define CHECK_INT_COERCE_CHAR_OR_MARKER(x) do { \ - if (INTP (x)) \ +#define CHECK_FIXNUM_COERCE_CHAR_OR_MARKER(x) do { \ + if (FIXNUMP (x)) \ ; \ else if (CHARP (x)) \ - x = make_int (XCHAR (x)); \ + x = make_fixnum (XCHAR (x)); \ else if (MARKERP (x)) \ - x = make_int (marker_position (x)); \ + x = make_fixnum (marker_position (x)); \ else \ x = wrong_type_argument (Qinteger_char_or_marker_p, x); \ } while (0) ＠＠ -3164,19 +3164,19 ＠＠ #define float_data(f) ((f)->data.d) #define XFLOAT_DATA(x) float_data (XFLOAT (x)) -#define XFLOATINT(n) extract_float (n) - -#define CHECK_INT_OR_FLOAT(x) do { \ - if (!INT_OR_FLOATP (x)) \ +#define XFLOATFIXNUM(n) extract_float (n) + +#define CHECK_FIXNUM_OR_FLOAT(x) do { \ + if (!FIXNUM_OR_FLOATP (x)) \ dead_wrong_type_argument (Qnumberp, x); \ } while (0) -#define CONCHECK_INT_OR_FLOAT(x) do { \ - if (!INT_OR_FLOATP (x)) \ +#define CONCHECK_FIXNUM_OR_FLOAT(x) do { \ + if (!FIXNUM_OR_FLOATP (x)) \ x = wrong_type_argument (Qnumberp, x); \ } while (0) -# define INT_OR_FLOATP(x) (INTP (x) || FLOATP (x)) +# define FIXNUM_OR_FLOATP(x) (FIXNUMP (x) || FLOATP (x)) /* #### change for 64-bit machines */ #define FLOAT_HASHCODE_FROM_DOUBLE(dbl) \ ＠＠ -3585,7 +3585,7 ＠＠ keyword_count, keywords, keyword_defaults, \ /* Can't XSUBR (Fsymbol_function (...))->min_args, \ the function may be advised. */ \ - XINT (Ffunction_min_args \ + XFIXNUM (Ffunction_min_args \ (intern_massaging_name (1 + #function))), \ 0); \ assert (0 == strcmp (__func__, #function)) ＠＠ -4365,7 +4365,7 ＠＠ void disksave_object_finalization (void); void finish_object_memory_usage_stats (void); extern int purify_flag; -#define ARRAY_DIMENSION_LIMIT EMACS_INT_MAX +#define ARRAY_DIMENSION_LIMIT MOST_POSITIVE_FIXNUM extern Fixnum Varray_dimension_limit; #ifndef NEW_GC extern EMACS_INT gc_generation_number[1]; diff -r a0e81357194e -r 56144c8593a8 src/lread.c --- a/src/lread.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/lread.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -421,9 +421,9 ＠＠ Lisp_Object tem; EMACS_INT pos; - if (!INTP (XCDR (victim))) + if (!FIXNUMP (XCDR (victim))) invalid_byte_code ("Bogus doc string reference", victim); - pos = XINT (XCDR (victim)); + pos = XFIXNUM (XCDR (victim)); if (pos < 0) pos = -pos; /* kludge to mark a user variable */ tem = unparesseuxify_doc_string (fd, pos, 0, Vload_file_name_internal, 0); ＠＠ -438,7 +438,7 ＠＠ struct gcpro gcpro1; Lisp_Object list = Vload_force_doc_string_list; Lisp_Object tail; - int fd = XINT (XCAR (Vload_descriptor_list)); + int fd = XFIXNUM (XCAR (Vload_descriptor_list)); GCPRO1 (list); /* restore the old value first just in case an error occurs. */ ＠＠ -505,7 +505,7 ＠＠ { Lisp_Object tail; LIST_LOOP (tail, Vload_descriptor_list) - retry_close (XINT (XCAR (tail))); + retry_close (XFIXNUM (XCAR (tail))); } #ifdef I18N3 ＠＠ -728,7 +728,7 ＠＠ internal_bind_int (&load_in_progress, 1 + load_in_progress); record_unwind_protect (load_unwind, lispstream); internal_bind_lisp_object (&Vload_descriptor_list, - Fcons (make_int (fd), Vload_descriptor_list)); + Fcons (make_fixnum (fd), Vload_descriptor_list)); internal_bind_lisp_object (&Vload_file_name_internal, found); /* this is not a simple internal_bind. */ record_unwind_protect (load_force_doc_string_unwind, ＠＠ -844,8 +844,8 ＠＠ return R_OK; else if (INTEGERP (mode)) { - check_integer_range (mode, Qzero, make_int (7)); - return XINT (mode); + check_integer_range (mode, Qzero, make_fixnum (7)); + return XFIXNUM (mode); } else invalid_argument ("Invalid value", mode); ＠＠ -1582,7 +1582,7 ＠＠ /* This both uses start and checks its type. */ Fgoto_char (start, cbuf); - Fnarrow_to_region (make_int (BUF_BEGV (current_buffer)), end, cbuf); + Fnarrow_to_region (make_fixnum (BUF_BEGV (current_buffer)), end, cbuf); readevalloop (cbuf, XBUFFER (cbuf)->filename, Feval, !NILP (stream)); ＠＠ -1648,7 +1648,7 ＠＠ /* Yeah, it's ugly. Gonna make something of it? At least our reader is reentrant ... */ tem = - (Fcons (tem, make_int + (Fcons (tem, make_fixnum (string_index_byte_to_char (string, startval + Lstream_byte_count (XLSTREAM (lispstream)))))); ＠＠ -1702,10 +1702,10 ＠＠ if (i >= 0x110000 || i < 0) { - syntax_error ("Not a Unicode code point", make_int(i)); + syntax_error ("Not a Unicode code point", make_fixnum(i)); } - lisp_char = Funicode_to_char(make_int(i), Qnil); + lisp_char = Funicode_to_char(make_fixnum(i), Qnil); if (EQ(Qnil, lisp_char)) { ＠＠ -1716,7 +1716,7 ＠＠ An undesirable aspect to this error is that the code point is shown as a decimal integer, which is mostly unreadable. */ - syntax_error ("Unsupported Unicode code point", make_int(i)); + syntax_error ("Unsupported Unicode code point", make_fixnum(i)); } return XCHAR(lisp_char); ＠＠ -1970,7 +1970,7 ＠＠ number = atol (read_buffer); else ABORT (); - return make_int (number); + return make_fixnum (number); } #else return parse_integer ((Ibyte *) read_ptr, len, 10); ＠＠ -2061,10 +2061,10 ＠＠ { EMACS_INT int_result = negativland ? - (EMACS_INT) num : (EMACS_INT) num; - Lisp_Object result = make_int (int_result); - if (num && ((XINT (result) < 0) != negativland)) + Lisp_Object result = make_fixnum (int_result); + if (num && ((XFIXNUM (result) < 0) != negativland)) goto overflow; - if (XINT (result) != int_result) + if (XFIXNUM (result) != int_result) goto overflow; return result; } ＠＠ -2079,14 +2079,14 ＠＠ list3 (build_msg_string ("Integer constant overflow in reader"), make_string (buf, len), - make_int (base))); + make_fixnum (base))); #endif /* HAVE_BIGNUM */ loser: return Fsignal (Qinvalid_read_syntax, list3 (build_msg_string ("Invalid integer constant in reader"), make_string (buf, len), - make_int (base))); + make_fixnum (base))); } ＠＠ -2200,7 +2200,7 ＠＠ list = read_list (readcharfun, ')', 0, 0); orig_list = list; { - int len = XINT (Flength (list)); + int len = XFIXNUM (Flength (list)); if (len == 0) RETURN_UNGCPRO (continuable_read_syntax_error ("structure type not specified")); ＠＠ -2710,7 +2710,7 ＠＠ n += c - '0'; c = readchar (readcharfun); } - found = assq_no_quit (make_int (n), Vread_objects); + found = assq_no_quit (make_fixnum (n), Vread_objects); if (c == '=') { /* #n=object returns object, but associates it with ＠＠ -2720,13 +2720,13 ＠＠ return Fsignal (Qinvalid_read_syntax, list2 (build_msg_string ("Multiply defined object label"), - make_int (n))); + make_fixnum (n))); } else { Lisp_Object object; - found = Fcons (make_int (n), Qnil); + found = Fcons (make_fixnum (n), Qnil); /* Make FOUND a placeholder for the object that will be read. (We've just consed it, and it's not visible from Lisp, so there's no possibility of ＠＠ -2751,7 +2751,7 ＠＠ return Fsignal (Qinvalid_read_syntax, list2 (build_msg_string ("Undefined symbol label"), - make_int (n))); + make_fixnum (n))); } return Fsignal (Qinvalid_read_syntax, list1 (build_ascstring ("#"))); ＠＠ -3159,7 +3159,7 ＠＠ UNGCPRO; tem = s.head; - len = XINT (Flength (tem)); + len = XFIXNUM (Flength (tem)); s.head = make_vector (len, Qnil); ＠＠ -3192,7 +3192,7 ＠＠ because we need to handle the "doc reference" for the instructions and constants differently. */ stuff = read_list (readcharfun, terminator, 0, 0); - len = XINT (Flength (stuff)); + len = XFIXNUM (Flength (stuff)); if (len < COMPILED_STACK_DEPTH + 1 || len > COMPILED_DOMAIN + 1) return continuable_read_syntax_error ("#[...] used with wrong number of elements"); diff -r a0e81357194e -r 56144c8593a8 src/lstream.c --- a/src/lstream.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/lstream.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1684,15 +1684,15 ＠＠ Lisp_Object buffer = wrap_buffer (buf); marker = Fmake_marker (); - Fset_marker (marker, make_int (start), buffer); + Fset_marker (marker, make_fixnum (start), buffer); str->start = marker; marker = Fmake_marker (); - Fset_marker (marker, make_int (start), buffer); + Fset_marker (marker, make_fixnum (start), buffer); str->orig_start = marker; if (reading) { marker = Fmake_marker (); - Fset_marker (marker, make_int (end), buffer); + Fset_marker (marker, make_fixnum (end), buffer); str->end = marker; } else diff -r a0e81357194e -r 56144c8593a8 src/macros.c --- a/src/macros.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/macros.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -81,7 +81,7 ＠＠ { message ("Appending to kbd macro..."); con->kbd_macro_ptr = con->kbd_macro_end; - Fexecute_kbd_macro (con->last_kbd_macro, make_int (1)); + Fexecute_kbd_macro (con->last_kbd_macro, make_fixnum (1)); } con->defining_kbd_macro = Qt; ＠＠ -111,7 +111,7 ＠＠ if (NILP (arg)) repeat = -1; else - repeat = XINT (Fprefix_numeric_value (arg)); + repeat = XFIXNUM (Fprefix_numeric_value (arg)); if (!NILP (con->defining_kbd_macro)) { ＠＠ -137,7 +137,7 ＠＠ return Fexecute_kbd_macro (con->last_kbd_macro, Qzero); else return Fexecute_kbd_macro (con->last_kbd_macro, - make_int (repeat - 1)); + make_fixnum (repeat - 1)); } /* #### Read the comment in modeline.el to see why this ugliness is ＠＠ -184,7 +184,7 ＠＠ if (STRINGP (Vexecuting_macro) || VECTORP (Vexecuting_macro)) { - if (executing_macro_index < XINT (Flength (Vexecuting_macro))) + if (executing_macro_index < XFIXNUM (Flength (Vexecuting_macro))) { nth_of_key_sequence_as_event (Vexecuting_macro, executing_macro_index++, ＠＠ -260,7 +260,7 ＠＠ if (!NILP (count)) { count = Fprefix_numeric_value (count); - repeat = XINT (count); + repeat = XFIXNUM (count); } final = indirect_function (macro, 1); diff -r a0e81357194e -r 56144c8593a8 src/marker.c --- a/src/marker.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/marker.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -142,7 +142,7 ＠＠ (marker)) { CHECK_MARKER (marker); - return XMARKER (marker)->buffer ? make_int (marker_position (marker)) : Qnil; + return XMARKER (marker)->buffer ? make_fixnum (marker_position (marker)) : Qnil; } #if 0 /* useful debugging function */ ＠＠ -201,7 +201,7 ＠＠ return marker; } - CHECK_INT_COERCE_MARKER (position); + CHECK_FIXNUM_COERCE_MARKER (position); if (NILP (buffer)) b = current_buffer; else ＠＠ -220,7 +220,7 ＠＠ } } - charno = XINT (position); + charno = XFIXNUM (position); m = XMARKER (marker); if (restricted_p) ＠＠ -389,7 +389,7 ＠＠ while (1) { - if (INTP (marker) || MARKERP (marker)) + if (FIXNUMP (marker) || MARKERP (marker)) { if (noseeum) new_ = noseeum_make_marker (); ＠＠ -530,7 +530,7 ＠＠ b->point_marker = Fmake_marker (); Fset_marker (b->point_marker, /* For indirect buffers, point is already set. */ - b->base_buffer ? make_int (BUF_PT (b)) : make_int (1), + b->base_buffer ? make_fixnum (BUF_PT (b)) : make_fixnum (1), buf); } diff -r a0e81357194e -r 56144c8593a8 src/mc-alloc.c --- a/src/mc-alloc.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/mc-alloc.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1985,28 +1985,28 ＠＠ for (i = 0; i < N_FREE_PAGE_LISTS; i++) if (PLH_PAGE_COUNT (FREE_HEAP_PAGES(i)) > 0) free_plhs = - Facons (make_int (PLH_SIZE (FREE_HEAP_PAGES(i))), - list1 (make_int (PLH_PAGE_COUNT (FREE_HEAP_PAGES(i)))), + Facons (make_fixnum (PLH_SIZE (FREE_HEAP_PAGES(i))), + list1 (make_fixnum (PLH_PAGE_COUNT (FREE_HEAP_PAGES(i)))), free_plhs); for (i = 0; i < N_USED_PAGE_LISTS; i++) if (PLH_PAGE_COUNT (USED_HEAP_PAGES(i)) > 0) used_plhs = - Facons (make_int (PLH_SIZE (USED_HEAP_PAGES(i))), - list5 (make_int (PLH_PAGE_COUNT (USED_HEAP_PAGES(i))), - make_int (PLH_USED_CELLS (USED_HEAP_PAGES(i))), - make_int (PLH_USED_SPACE (USED_HEAP_PAGES(i))), - make_int (PLH_TOTAL_CELLS (USED_HEAP_PAGES(i))), - make_int (PLH_TOTAL_SPACE (USED_HEAP_PAGES(i)))), + Facons (make_fixnum (PLH_SIZE (USED_HEAP_PAGES(i))), + list5 (make_fixnum (PLH_PAGE_COUNT (USED_HEAP_PAGES(i))), + make_fixnum (PLH_USED_CELLS (USED_HEAP_PAGES(i))), + make_fixnum (PLH_USED_SPACE (USED_HEAP_PAGES(i))), + make_fixnum (PLH_TOTAL_CELLS (USED_HEAP_PAGES(i))), + make_fixnum (PLH_TOTAL_SPACE (USED_HEAP_PAGES(i)))), used_plhs); used_plhs = - Facons (make_int (0), - list5 (make_int (PLH_PAGE_COUNT(ARRAY_HEAP_PAGES)), - make_int (PLH_USED_CELLS (ARRAY_HEAP_PAGES)), - make_int (PLH_USED_SPACE (ARRAY_HEAP_PAGES)), - make_int (PLH_TOTAL_CELLS (ARRAY_HEAP_PAGES)), - make_int (PLH_TOTAL_SPACE (ARRAY_HEAP_PAGES))), + Facons (make_fixnum (0), + list5 (make_fixnum (PLH_PAGE_COUNT(ARRAY_HEAP_PAGES)), + make_fixnum (PLH_USED_CELLS (ARRAY_HEAP_PAGES)), + make_fixnum (PLH_USED_SPACE (ARRAY_HEAP_PAGES)), + make_fixnum (PLH_TOTAL_CELLS (ARRAY_HEAP_PAGES)), + make_fixnum (PLH_TOTAL_SPACE (ARRAY_HEAP_PAGES))), used_plhs); for (i = 0; i < N_HEAP_SECTIONS; i++) { ＠＠ -2016,16 +2016,16 ＠＠ } heap_sects = - list3 (make_int (N_HEAP_SECTIONS), - make_int (used_size), - make_int (real_size)); + list3 (make_fixnum (N_HEAP_SECTIONS), + make_fixnum (used_size), + make_fixnum (real_size)); - return Fcons (make_int (PAGE_SIZE), + return Fcons (make_fixnum (PAGE_SIZE), list5 (heap_sects, Fnreverse (used_plhs), Fnreverse (free_plhs), - make_int (sizeof (mc_allocator_globals)), - make_int (MC_MALLOCED_BYTES))); + make_fixnum (sizeof (mc_allocator_globals)), + make_fixnum (MC_MALLOCED_BYTES))); } #endif /* MEMORY_USAGE_STATS */ diff -r a0e81357194e -r 56144c8593a8 src/menubar-msw.c --- a/src/menubar-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/menubar-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -164,7 +164,7 ＠＠ do { id = MENU_ITEM_ID_BITS (id + 1); } while (GetMenuState (top_level_menu, id, MF_BYCOMMAND) != 0xFFFFFFFF); - return make_int (id); + return make_fixnum (id); } static HMENU ＠＠ -338,7 +338,7 ＠＠ pgui_item->suffix); Fputhash (id, pgui_item->callback, hash_tab); - item_info.wID = (UINT) XINT (id); + item_info.wID = (UINT) XFIXNUM (id); item_info.fType |= MFT_STRING; item_info.dwTypeData = (XELPTSTR) LISP_STRING_TO_TSTR (displayable_menu_item (gui_item, bar_p, &accel)); ＠＠ -671,7 +671,7 ＠＠ if (NILP (current_hash_table)) return Qnil; - data = Fgethash (make_int (id), current_hash_table, Qunbound); + data = Fgethash (make_fixnum (id), current_hash_table, Qunbound); if (UNBOUNDP (data)) { diff -r a0e81357194e -r 56144c8593a8 src/menubar.c --- a/src/menubar.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/menubar.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -352,10 +352,10 ＠＠ else if (*q == '%' && *(q + 1) == '_') q += 2; if (!*p || !*q) - return make_int (*p - *q); + return make_fixnum (*p - *q); val = DOWNCASE (0, itext_ichar (p)) - DOWNCASE (0, itext_ichar (q)); if (val) - return make_int (val); + return make_fixnum (val); INC_IBYTEPTR (p); INC_IBYTEPTR (q); } diff -r a0e81357194e -r 56144c8593a8 src/minibuf.c --- a/src/minibuf.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/minibuf.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -69,7 +69,7 ＠＠ */ ()) { - return make_int (minibuf_level); + return make_fixnum (minibuf_level); } /* The default buffer to use as the window-buffer of minibuffer windows */ ＠＠ -90,7 +90,7 ＠＠ XWINDOW (minibuf_window)->last_facechange[DESIRED_DISP] = Qzero; XWINDOW (minibuf_window)->last_facechange[CMOTION_DISP] = Qzero; Vminibuf_prompt = Felt (unwind_data, Qzero); - minibuf_level = XINT (Felt (unwind_data, make_int (1))); + minibuf_level = XFIXNUM (Felt (unwind_data, make_fixnum (1))); while (CONSP (unwind_data)) { Lisp_Object victim = unwind_data; ＠＠ -151,7 +151,7 ＠＠ record_unwind_protect (read_minibuffer_internal_unwind, noseeum_cons (Vminibuf_prompt, - noseeum_cons (make_int (minibuf_level), Qnil))); + noseeum_cons (make_fixnum (minibuf_level), Qnil))); Vminibuf_prompt = LISP_GETTEXT (prompt); /* NOTE: Here (or somewhere around here), in FSFmacs 19.30, ＠＠ -511,7 +511,7 ＠＠ return Qt; /* Else extract the part in which all completions agree */ - return Fsubseq (bestmatch, Qzero, make_int (bestmatchsize)); + return Fsubseq (bestmatch, Qzero, make_fixnum (bestmatchsize)); }  ＠＠ -666,7 +666,7 ＠＠ */ ()) { - return make_int (minibuf_prompt_width); + return make_fixnum (minibuf_prompt_width); } #endif /* 0 */ diff -r a0e81357194e -r 56144c8593a8 src/mule-ccl.c --- a/src/mule-ccl.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/mule-ccl.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -645,7 +645,7 ＠＠ stack_idx++; \ ccl_prog = called_ccl.prog; \ ic = CCL_HEADER_MAIN; \ - eof_ic = XINT (ccl_prog[CCL_HEADER_EOF]); \ + eof_ic = XFIXNUM (ccl_prog[CCL_HEADER_EOF]); \ /* The "if (1)" prevents warning \ "end-of loop code not reached" */ \ if (1) goto ccl_repeat; \ ＠＠ -797,7 +797,7 ＠＠ { \ for (i = 0; i < (len); i++) \ { \ - ch = ((XCHAR_OR_INT (ccl_prog[ic + (i / 3)])) \ + ch = ((XCHAR_OR_FIXNUM (ccl_prog[ic + (i / 3)])) \ if (ch == '\n') \ { \ ＠＠ -826,7 +826,7 ＠＠ { \ for (i = 0; i < (len); i++) \ { \ - ch = ((XCHAR_OR_INT (ccl_prog[ic + (i / 3)])) \ + ch = ((XCHAR_OR_FIXNUM (ccl_prog[ic + (i / 3)])) \ if (!ichar_multibyte_p(ch)) \ { \ ＠＠ -993,7 +993,7 ＠＠ } this_ic = ic; - code = XCHAR_OR_INT (ccl_prog[ic]); ic++; + code = XCHAR_OR_FIXNUM (ccl_prog[ic]); ic++; field1 = code >> 8; field2 = (code & 0xFF) >> 5; ＠＠ -1014,7 +1014,7 ＠＠ break; case CCL_SetConst: /* 00000000000000000000rrrXXXXX */ - reg[rrr] = XCHAR_OR_INT (ccl_prog[ic]); + reg[rrr] = XCHAR_OR_FIXNUM (ccl_prog[ic]); ic++; break; ＠＠ -1025,7 +1025,7 ＠＠ but the left one was already there so clearly the intention was an unsigned comparison. --ben */ if ((unsigned int) i < (unsigned int) j) - reg[rrr] = XCHAR_OR_INT (ccl_prog[ic + i]); + reg[rrr] = XCHAR_OR_FIXNUM (ccl_prog[ic + i]); ic += j; break; ＠＠ -1053,13 +1053,13 ＠＠ break; case CCL_WriteConstJump: /* A--D--D--R--E--S--S-000XXXXX */ - i = XCHAR_OR_INT (ccl_prog[ic]); + i = XCHAR_OR_FIXNUM (ccl_prog[ic]); CCL_WRITE_CHAR (i); ic += ADDR; break; case CCL_WriteConstReadJump: /* A--D--D--R--E--S--S-rrrXXXXX */ - i = XCHAR_OR_INT (ccl_prog[ic]); + i = XCHAR_OR_FIXNUM (ccl_prog[ic]); CCL_WRITE_CHAR (i); ic++; CCL_READ_CHAR (reg[rrr]); ＠＠ -1067,7 +1067,7 ＠＠ break; case CCL_WriteStringJump: /* A--D--D--R--E--S--S-000XXXXX */ - j = XCHAR_OR_INT (ccl_prog[ic]); + j = XCHAR_OR_FIXNUM (ccl_prog[ic]); ic++; CCL_WRITE_STRING (j); ic += ADDR - 1; ＠＠ -1075,11 +1075,11 ＠＠ case CCL_WriteArrayReadJump: /* A--D--D--R--E--S--S-rrrXXXXX */ i = reg[rrr]; - j = XCHAR_OR_INT (ccl_prog[ic]); + j = XCHAR_OR_FIXNUM (ccl_prog[ic]); /* #### see comment at CCL_SetArray */ if ((unsigned int) i < (unsigned int) j) { - i = XCHAR_OR_INT (ccl_prog[ic + 1 + i]); + i = XCHAR_OR_FIXNUM (ccl_prog[ic + 1 + i]); CCL_WRITE_CHAR (i); } ic += j + 2; ＠＠ -1098,9 +1098,9 ＠＠ case CCL_Branch: /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */ /* #### see comment at CCL_SetArray */ if ((unsigned int) reg[rrr] < (unsigned int) field1) - ic += XCHAR_OR_INT (ccl_prog[ic + reg[rrr]]); + ic += XCHAR_OR_FIXNUM (ccl_prog[ic + reg[rrr]]); else - ic += XCHAR_OR_INT (ccl_prog[ic + field1]); + ic += XCHAR_OR_FIXNUM (ccl_prog[ic + field1]); break; case CCL_ReadRegister: /* CCCCCCCCCCCCCCCCCCCCrrXXXXX */ ＠＠ -1108,7 +1108,7 ＠＠ { CCL_READ_CHAR (reg[rrr]); if (!field1) break; - code = XCHAR_OR_INT (ccl_prog[ic]); ic++; + code = XCHAR_OR_FIXNUM (ccl_prog[ic]); ic++; field1 = code >> 8; field2 = (code & 0xFF) >> 5; } ＠＠ -1117,7 +1117,7 ＠＠ case CCL_WriteExprConst: /* 1:00000OPERATION000RRR000XXXXX */ rrr = 7; i = reg[RRR]; - j = XCHAR_OR_INT (ccl_prog[ic]); + j = XCHAR_OR_FIXNUM (ccl_prog[ic]); op = field1 >> 6; jump_address = ic + 1; goto ccl_set_expr; ＠＠ -1128,7 +1128,7 ＠＠ i = reg[rrr]; CCL_WRITE_CHAR (i); if (!field1) break; - code = XCHAR_OR_INT (ccl_prog[ic]); ic++; + code = XCHAR_OR_FIXNUM (ccl_prog[ic]); ic++; field1 = code >> 8; field2 = (code & 0xFF) >> 5; } ＠＠ -1151,7 +1151,7 ＠＠ following code. */ if (rrr) { - prog_id = XCHAR_OR_INT (ccl_prog[ic]); + prog_id = XCHAR_OR_FIXNUM (ccl_prog[ic]); ic++; } else ＠＠ -1179,7 +1179,7 ＠＠ stack_idx++; ccl_prog = XVECTOR (XVECTOR (slot)->contents[1])->contents; ic = CCL_HEADER_MAIN; - eof_ic = XINT (ccl_prog[CCL_HEADER_EOF]); + eof_ic = XFIXNUM (ccl_prog[CCL_HEADER_EOF]); } break; ＠＠ -1198,7 +1198,7 ＠＠ /* #### see comment at CCL_SetArray */ if ((unsigned int) i < (unsigned int) field1) { - j = XCHAR_OR_INT (ccl_prog[ic + i]); + j = XCHAR_OR_FIXNUM (ccl_prog[ic + i]); CCL_WRITE_CHAR (j); } ic += field1; ＠＠ -1223,7 +1223,7 ＠＠ CCL_SUCCESS; case CCL_ExprSelfConst: /* 00000OPERATION000000rrrXXXXX */ - i = XCHAR_OR_INT (ccl_prog[ic]); + i = XCHAR_OR_FIXNUM (ccl_prog[ic]); ic++; op = field1 >> 6; goto ccl_expr_self; ＠＠ -1260,7 +1260,7 ＠＠ case CCL_SetExprConst: /* 00000OPERATION000RRRrrrXXXXX */ i = reg[RRR]; - j = XCHAR_OR_INT (ccl_prog[ic]); + j = XCHAR_OR_FIXNUM (ccl_prog[ic]); op = field1 >> 6; jump_address = ++ic; goto ccl_set_expr; ＠＠ -1276,9 +1276,9 ＠＠ CCL_READ_CHAR (reg[rrr]); case CCL_JumpCondExprConst: /* A--D--D--R--E--S--S-rrrXXXXX */ i = reg[rrr]; - op = XCHAR_OR_INT (ccl_prog[ic]); + op = XCHAR_OR_FIXNUM (ccl_prog[ic]); jump_address = ic++ + ADDR; - j = XCHAR_OR_INT (ccl_prog[ic]); + j = XCHAR_OR_FIXNUM (ccl_prog[ic]); ic++; rrr = 7; goto ccl_set_expr; ＠＠ -1287,9 +1287,9 ＠＠ CCL_READ_CHAR (reg[rrr]); case CCL_JumpCondExprReg: i = reg[rrr]; - op = XCHAR_OR_INT (ccl_prog[ic]); + op = XCHAR_OR_FIXNUM (ccl_prog[ic]); jump_address = ic++ + ADDR; - j = reg[XCHAR_OR_INT (ccl_prog[ic])]; + j = reg[XCHAR_OR_FIXNUM (ccl_prog[ic])]; ic++; rrr = 7; ＠＠ -1493,7 +1493,7 ＠＠ #if 0 /* XEmacs does not have translate_char or an equivalent. We do nothing on this operation. */ - op = XCHAR_OR_INT (ccl_prog[ic]); /* table */ + op = XCHAR_OR_FIXNUM (ccl_prog[ic]); /* table */ ic++; CCL_MAKE_CHAR (reg[RRR], reg[rrr], i); op = translate_char (GET_TRANSLATION_TABLE (op), i, -1, 0, 0); ＠＠ -1521,7 +1521,7 ＠＠ } else { - reg[rrr] = XCHAR_OR_INT(ucs); + reg[rrr] = XCHAR_OR_FIXNUM(ucs); if (-1 == reg[rrr]) { reg[rrr] = 0xFFFD; /* REPLACEMENT CHARACTER */ ＠＠ -1534,7 +1534,7 ＠＠ { Lisp_Object scratch; - scratch = Funicode_to_char(make_int(reg[rrr]), Qnil); + scratch = Funicode_to_char(make_fixnum(reg[rrr]), Qnil); if (!NILP(scratch)) { ＠＠ -1557,11 +1557,11 ＠＠ } case CCL_LookupIntConstTbl: - op = XCHAR_OR_INT (ccl_prog[ic]); /* table */ + op = XCHAR_OR_FIXNUM (ccl_prog[ic]); /* table */ ic++; { struct Lisp_Hash_Table *h = GET_HASH_TABLE (op); - htentry *e = find_htentry(make_int (reg[RRR]), h); + htentry *e = find_htentry(make_fixnum (reg[RRR]), h); Lisp_Object scratch; if (!HTENTRY_CLEAR_P(e)) ＠＠ -1588,18 +1588,18 ＠＠ break; case CCL_LookupCharConstTbl: - op = XCHAR_OR_INT (ccl_prog[ic]); /* table */ + op = XCHAR_OR_FIXNUM (ccl_prog[ic]); /* table */ ic++; CCL_MAKE_CHAR (reg[RRR], reg[rrr], i); { struct Lisp_Hash_Table *h = GET_HASH_TABLE (op); - htentry *e = find_htentry(make_int(i), h); + htentry *e = find_htentry(make_fixnum(i), h); if (!HTENTRY_CLEAR_P(e)) { - if (!INTP (e->value)) + if (!FIXNUMP (e->value)) CCL_INVALID_CMD; - reg[RRR] = XCHAR_OR_INT (e->value); + reg[RRR] = XCHAR_OR_FIXNUM (e->value); reg[7] = 1; /* r7 true for success */ } else ＠＠ -1613,7 +1613,7 ＠＠ Lisp_Object map, content, attrib, value; int point, size, fin_ic; - j = XCHAR_OR_INT (ccl_prog[ic++]); /* number of maps. */ + j = XCHAR_OR_FIXNUM (ccl_prog[ic++]); /* number of maps. */ fin_ic = ic + j; op = reg[rrr]; if ((j > reg[RRR]) && (j >= 0)) ＠＠ -1631,7 +1631,7 ＠＠ for (;i < j;i++) { size = XVECTOR (Vcode_conversion_map_vector)->size; - point = XCHAR_OR_INT (ccl_prog[ic++]); + point = XCHAR_OR_FIXNUM (ccl_prog[ic++]); if (point >= size) continue; map = XVECTOR (Vcode_conversion_map_vector)->contents[point]; ＠＠ -1648,7 +1648,7 ＠＠ /* check map type, [STARTPOINT VAL1 VAL2 ...] or [t ELEMENT STARTPOINT ENDPOINT] */ - if (INTP (content)) + if (FIXNUMP (content)) { point = XUINT (content); point = op - point + 1; ＠＠ -1674,10 +1674,10 ＠＠ if (NILP (content)) continue; - else if (INTP (content)) + else if (FIXNUMP (content)) { reg[RRR] = i; - reg[rrr] = XCHAR_OR_INT(content); + reg[rrr] = XCHAR_OR_FIXNUM(content); break; } else if (EQ (content, Qt) || EQ (content, Qlambda)) ＠＠ -1689,7 +1689,7 ＠＠ { attrib = XCAR (content); value = XCDR (content); - if (!INTP (attrib) || !INTP (value)) + if (!FIXNUMP (attrib) || !FIXNUMP (value)) continue; reg[RRR] = i; reg[rrr] = XUINT (value); ＠＠ -1728,7 +1728,7 ＠＠ stack_idx_of_map_multiple = 0; map_set_rest_length = - XCHAR_OR_INT (ccl_prog[ic++]); /* number of maps and separators. */ + XCHAR_OR_FIXNUM (ccl_prog[ic++]); /* number of maps and separators. */ fin_ic = ic + map_set_rest_length; op = reg[rrr]; ＠＠ -1796,7 +1796,7 ＠＠ do { for (;map_set_rest_length > 0;i++, ic++, map_set_rest_length--) { - point = XCHAR_OR_INT(ccl_prog[ic]); + point = XCHAR_OR_FIXNUM(ccl_prog[ic]); if (point < 0) { /* +1 is for including separator. */ ＠＠ -1827,7 +1827,7 ＠＠ /* check map type, [STARTPOINT VAL1 VAL2 ...] or [t ELEMENT STARTPOINT ENDPOINT] */ - if (INTP (content)) + if (FIXNUMP (content)) { point = XUINT (content); point = op - point + 1; ＠＠ -1855,9 +1855,9 ＠＠ continue; reg[RRR] = i; - if (INTP (content)) + if (FIXNUMP (content)) { - op = XCHAR_OR_INT (content); + op = XCHAR_OR_FIXNUM (content); i += map_set_rest_length - 1; ic += map_set_rest_length - 1; POP_MAPPING_STACK (map_set_rest_length, reg[rrr]); ＠＠ -1867,7 +1867,7 ＠＠ { attrib = XCAR (content); value = XCDR (content); - if (!INTP (attrib) || !INTP (value)) + if (!FIXNUMP (attrib) || !FIXNUMP (value)) continue; op = XUINT (value); i += map_set_rest_length - 1; ＠＠ -1915,7 +1915,7 ＠＠ { Lisp_Object map, attrib, value, content; int size, point; - j = XCHAR_OR_INT (ccl_prog[ic++]); /* map_id */ + j = XCHAR_OR_FIXNUM (ccl_prog[ic++]); /* map_id */ op = reg[rrr]; if (j >= XVECTOR (Vcode_conversion_map_vector)->size) { ＠＠ -1947,14 +1947,14 ＠＠ content = XVECTOR (map)->contents[point]; if (NILP (content)) reg[RRR] = -1; - else if (INTP (content)) - reg[rrr] = XCHAR_OR_INT (content); + else if (FIXNUMP (content)) + reg[rrr] = XCHAR_OR_FIXNUM (content); else if (EQ (content, Qt)); else if (CONSP (content)) { attrib = XCAR (content); value = XCDR (content); - if (!INTP (attrib) || !INTP (value)) + if (!FIXNUMP (attrib) || !FIXNUMP (value)) continue; reg[rrr] = XUINT(value); break; ＠＠ -2053,7 +2053,7 ＠＠ contents = XVECTOR (result)->contents[i]; /* XEmacs change; accept characters as well as integers, on the basis that most CCL code written doesn't make a distinction. */ - if (INTP (contents) || CHARP(contents)) + if (FIXNUMP (contents) || CHARP(contents)) continue; else if (CONSP (contents) && SYMBOLP (XCAR (contents)) ＠＠ -2123,7 +2123,7 ＠＠ if (! NATNUMP (val) || -1 != bytecode_arithcompare (val, Flength (Vccl_program_table))) return Qnil; - slot = XVECTOR_DATA (Vccl_program_table)[XINT (val)]; + slot = XVECTOR_DATA (Vccl_program_table)[XFIXNUM (val)]; if (! VECTORP (slot) || XVECTOR (slot)->size != 3 || ! VECTORP (XVECTOR_DATA (slot)[1])) ＠＠ -2167,8 +2167,8 ＠＠ ccl->size = XVECTOR_LENGTH (ccl_prog); ccl->prog = XVECTOR_DATA (ccl_prog); - ccl->eof_ic = XINT (XVECTOR_DATA (ccl_prog)[CCL_HEADER_EOF]); - ccl->buf_magnification = XINT (XVECTOR_DATA (ccl_prog)[CCL_HEADER_BUF_MAG]); + ccl->eof_ic = XFIXNUM (XVECTOR_DATA (ccl_prog)[CCL_HEADER_EOF]); + ccl->buf_magnification = XFIXNUM (XVECTOR_DATA (ccl_prog)[CCL_HEADER_BUF_MAG]); } ccl->ic = CCL_HEADER_MAIN; ccl->eol_type = CCL_CODING_EOL_LF; ＠＠ -2275,8 +2275,8 ＠＠ syntax_error ("Length of vector REGISTERS is not 8", Qunbound); for (i = 0; i < 8; i++) - ccl.reg[i] = (INTP (XVECTOR_DATA (reg)[i]) || CHARP (XVECTOR_DATA (reg)[i]) - ? XCHAR_OR_INT (XVECTOR_DATA (reg)[i]) + ccl.reg[i] = (FIXNUMP (XVECTOR_DATA (reg)[i]) || CHARP (XVECTOR_DATA (reg)[i]) + ? XCHAR_OR_FIXNUM (XVECTOR_DATA (reg)[i]) : 0); ccl_driver (&ccl, (const unsigned char *)0, ＠＠ -2284,10 +2284,10 ＠＠ CCL_MODE_ENCODING); QUIT; if (ccl.status != CCL_STAT_SUCCESS) - signal_error (Qccl_error, "Error in CCL program at code numbered ...", make_int (ccl.ic)); + signal_error (Qccl_error, "Error in CCL program at code numbered ...", make_fixnum (ccl.ic)); for (i = 0; i < 8; i++) - XVECTOR (reg)->contents[i] = make_int (ccl.reg[i]); + XVECTOR (reg)->contents[i] = make_fixnum (ccl.reg[i]); RETURN_UNGCPRO (Qnil); } ＠＠ -2340,16 +2340,16 ＠＠ for (i = 0; i < 8; i++) { if (NILP (XVECTOR_DATA (status)[i])) - XVECTOR_DATA (status)[i] = make_int (0); - if (INTP (XVECTOR_DATA (status)[i])) - ccl.reg[i] = XINT (XVECTOR_DATA (status)[i]); + XVECTOR_DATA (status)[i] = make_fixnum (0); + if (FIXNUMP (XVECTOR_DATA (status)[i])) + ccl.reg[i] = XFIXNUM (XVECTOR_DATA (status)[i]); if (CHARP (XVECTOR_DATA (status)[i])) ccl.reg[i] = XCHAR (XVECTOR_DATA (status)[i]); } - if (INTP (XVECTOR (status)->contents[i]) || + if (FIXNUMP (XVECTOR (status)->contents[i]) || CHARP (XVECTOR (status)->contents[i])) { - i = XCHAR_OR_INT (XVECTOR_DATA (status)[8]); + i = XCHAR_OR_FIXNUM (XVECTOR_DATA (status)[8]); if (ccl.ic < i && i < ccl.size) ccl.ic = i; } ＠＠ -2360,8 +2360,8 ＠＠ (int *) 0, CCL_MODE_DECODING); for (i = 0; i < 8; i++) - XVECTOR_DATA (status)[i] = make_int (ccl.reg[i]); - XVECTOR_DATA (status)[8] = make_int (ccl.ic); + XVECTOR_DATA (status)[i] = make_fixnum (ccl.reg[i]); + XVECTOR_DATA (status)[8] = make_fixnum (ccl.ic); UNGCPRO; val = make_string (Dynarr_begin (outbuf), produced); ＠＠ -2371,7 +2371,7 ＠＠ signal_error (Qccl_error, "Output buffer for the CCL programs overflow", Qunbound); if (ccl.status != CCL_STAT_SUCCESS && ccl.status != CCL_STAT_SUSPEND_BY_SRC) - signal_error (Qccl_error, "Error in CCL program at code numbered...", make_int (ccl.ic)); + signal_error (Qccl_error, "Error in CCL program at code numbered...", make_fixnum (ccl.ic)); return val; } ＠＠ -2416,7 +2416,7 ＠＠ /* Update this slot. */ XVECTOR_DATA (slot)[1] = ccl_prog; XVECTOR_DATA (slot)[2] = resolved; - return make_int (idx); + return make_fixnum (idx); } } ＠＠ -2426,7 +2426,7 ＠＠ Lisp_Object new_table; int j; - new_table = Fmake_vector (make_int (len * 2), Qnil); + new_table = Fmake_vector (make_fixnum (len * 2), Qnil); for (j = 0; j < len; j++) XVECTOR_DATA (new_table)[j] = XVECTOR_DATA (Vccl_program_table)[j]; ＠＠ -2436,15 +2436,15 ＠＠ { Lisp_Object elt; - elt = Fmake_vector (make_int (3), Qnil); + elt = Fmake_vector (make_fixnum (3), Qnil); XVECTOR_DATA (elt)[0] = name; XVECTOR_DATA (elt)[1] = ccl_prog; XVECTOR_DATA (elt)[2] = resolved; XVECTOR_DATA (Vccl_program_table)[idx] = elt; } - Fput (name, Qccl_program_idx, make_int (idx)); - return make_int (idx); + Fput (name, Qccl_program_idx, make_fixnum (idx)); + return make_fixnum (idx); } /* Register code conversion map. ＠＠ -2479,7 +2479,7 ＠＠ if (EQ (symbol, XCAR (slot))) { - idx = make_int (i); + idx = make_fixnum (i); XCDR (slot) = map; Fput (symbol, Qcode_conversion_map, map); Fput (symbol, Qcode_conversion_map_id, idx); ＠＠ -2489,7 +2489,7 ＠＠ if (i == len) { - Lisp_Object new_vector = Fmake_vector (make_int (len * 2), Qnil); + Lisp_Object new_vector = Fmake_vector (make_fixnum (len * 2), Qnil); int j; for (j = 0; j < len; j++) ＠＠ -2498,7 +2498,7 ＠＠ Vcode_conversion_map_vector = new_vector; } - idx = make_int (i); + idx = make_fixnum (i); Fput (symbol, Qcode_conversion_map, map); Fput (symbol, Qcode_conversion_map_id, idx); XVECTOR_DATA (Vcode_conversion_map_vector)[i] = Fcons (symbol, map); ＠＠ -2523,7 +2523,7 ＠＠ { staticpro (&Vccl_program_table); - Vccl_program_table = Fmake_vector (make_int (32), Qnil); + Vccl_program_table = Fmake_vector (make_fixnum (32), Qnil); #ifdef DEBUG_XEMACS DEFVAR_LISP ("ccl-program-table", ＠＠ -2539,7 +2539,7 ＠＠ DEFVAR_LISP ("code-conversion-map-vector", &Vcode_conversion_map_vector /* Vector of code conversion maps. */ ); - Vcode_conversion_map_vector = Fmake_vector (make_int (16), Qnil); + Vcode_conversion_map_vector = Fmake_vector (make_fixnum (16), Qnil); DEFVAR_LISP ("translation-hash-table-vector", &Vtranslation_hash_table_vector /* diff -r a0e81357194e -r 56144c8593a8 src/mule-charset.c --- a/src/mule-charset.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/mule-charset.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -302,7 +302,7 ＠＠ if (!lb) invalid_operation - ("No more character sets free for this dimension", make_int (dimension)); + ("No more character sets free for this dimension", make_fixnum (dimension)); return lb; } ＠＠ -507,32 +507,32 ＠＠ else if (EQ (keyword, Qdimension)) { - CHECK_INT (value); - dimension = XINT (value); + CHECK_FIXNUM (value); + dimension = XFIXNUM (value); if (dimension < 1 || dimension > 2) invalid_constant ("Invalid value for `dimension'", value); } else if (EQ (keyword, Qchars)) { - CHECK_INT (value); - chars = XINT (value); + CHECK_FIXNUM (value); + chars = XFIXNUM (value); if (chars != 94 && chars != 96) invalid_constant ("Invalid value for `chars'", value); } else if (EQ (keyword, Qcolumns)) { - CHECK_INT (value); - columns = XINT (value); + CHECK_FIXNUM (value); + columns = XFIXNUM (value); if (columns != 1 && columns != 2) invalid_constant ("Invalid value for `columns'", value); } else if (EQ (keyword, Qgraphic)) { - CHECK_INT (value); - graphic = XINT (value); + CHECK_FIXNUM (value); + graphic = XFIXNUM (value); if (graphic < 0 || graphic > 1) invalid_constant ("Invalid value for `graphic'", value); } ＠＠ -734,13 +734,13 ＠＠ int type; Lisp_Object obj = Qnil; - CHECK_INT (dimension); - dm = XINT (dimension); + CHECK_FIXNUM (dimension); + dm = XFIXNUM (dimension); if (dm < 1 || dm > 2) invalid_constant ("Invalid value for DIMENSION", dimension); - CHECK_INT (chars); - ch = XINT (chars); + CHECK_FIXNUM (chars); + ch = XFIXNUM (chars); if (ch != 94 && ch != 96) invalid_constant ("Invalid value for CHARS", chars); ＠＠ -808,7 +808,7 ＠＠ */ (charset)) { - return make_int (XCHARSET_DIMENSION (Fget_charset (charset))); + return make_fixnum (XCHARSET_DIMENSION (Fget_charset (charset))); } DEFUN ("charset-property", Fcharset_property, 2, 2, 0, /* ＠＠ -828,11 +828,11 ＠＠ if (EQ (prop, Qshort_name)) return CHARSET_SHORT_NAME (cs); if (EQ (prop, Qlong_name)) return CHARSET_LONG_NAME (cs); if (EQ (prop, Qdoc_string)) return CHARSET_DOC_STRING (cs); - if (EQ (prop, Qdimension)) return make_int (CHARSET_DIMENSION (cs)); - if (EQ (prop, Qcolumns)) return make_int (CHARSET_COLUMNS (cs)); - if (EQ (prop, Qgraphic)) return make_int (CHARSET_GRAPHIC (cs)); + if (EQ (prop, Qdimension)) return make_fixnum (CHARSET_DIMENSION (cs)); + if (EQ (prop, Qcolumns)) return make_fixnum (CHARSET_COLUMNS (cs)); + if (EQ (prop, Qgraphic)) return make_fixnum (CHARSET_GRAPHIC (cs)); if (EQ (prop, Qfinal)) return make_char (CHARSET_FINAL (cs)); - if (EQ (prop, Qchars)) return make_int (CHARSET_CHARS (cs)); + if (EQ (prop, Qchars)) return make_fixnum (CHARSET_CHARS (cs)); if (EQ (prop, Qregistries)) return CHARSET_REGISTRIES (cs); if (EQ (prop, Qencode_as_utf_8)) return CHARSET_ENCODE_AS_UTF_8 (cs) ? Qt : Qnil; ＠＠ -854,7 +854,7 ＠＠ */ (charset)) { - return make_int (XCHARSET_LEADING_BYTE (Fget_charset (charset))); + return make_fixnum (XCHARSET_LEADING_BYTE (Fget_charset (charset))); } /* #### We need to figure out which properties we really want to diff -r a0e81357194e -r 56144c8593a8 src/mule-coding.c --- a/src/mule-coding.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/mule-coding.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -239,10 +239,10 ＠＠ int c1, c2, s1, s2; CHECK_CONS (code); - CHECK_INT (XCAR (code)); - CHECK_INT (XCDR (code)); - s1 = XINT (XCAR (code)); - s2 = XINT (XCDR (code)); + CHECK_FIXNUM (XCAR (code)); + CHECK_FIXNUM (XCDR (code)); + s1 = XFIXNUM (XCAR (code)); + s2 = XFIXNUM (XCDR (code)); if (byte_shift_jis_two_byte_1_p (s1) && byte_shift_jis_two_byte_2_p (s2)) { ＠＠ -268,7 +268,7 ＠＠ if (EQ (charset, Vcharset_japanese_jisx0208)) { ENCODE_SHIFT_JIS (c1 | 0x80, c2 | 0x80, s1, s2); - return Fcons (make_int (s1), make_int (s2)); + return Fcons (make_fixnum (s1), make_fixnum (s2)); } else return Qnil; ＠＠ -596,9 +596,9 ＠＠ Ichar ch; CHECK_CONS (code); - CHECK_INT (XCAR (code)); - CHECK_INT (XCDR (code)); - ch = decode_big5_char (XINT (XCAR (code)), XINT (XCDR (code))); + CHECK_FIXNUM (XCAR (code)); + CHECK_FIXNUM (XCDR (code)); + ch = decode_big5_char (XFIXNUM (XCAR (code)), XFIXNUM (XCDR (code))); if (ch == -1) return Qnil; else ＠＠ -623,7 +623,7 ＠＠ { ENCODE_BIG5 (XCHARSET_LEADING_BYTE (charset), c1 | 0x80, c2 | 0x80, b1, b2); - return Fcons (make_int (b1), make_int (b2)); + return Fcons (make_fixnum (b1), make_fixnum (b2)); } else return Qnil; ＠＠ -1305,8 +1305,8 ＠＠ charset = Fmake_charset (Qunbound, Qnil, nconc2 (list6 (Qfinal, make_char (final), - Qchars, make_int (chars), - Qdimension, make_int (dim)), + Qchars, make_fixnum (chars), + Qdimension, make_fixnum (dim)), list2 (Qdirection, dir == CHARSET_LEFT_TO_RIGHT ? Ql2r : Qr2l))); ＠＠ -1818,7 +1818,7 ＠＠ int len; Lisp_Object chr; - chr = Funicode_to_char(make_int(ucs), Qnil); + chr = Funicode_to_char(make_fixnum(ucs), Qnil); assert (!NILP(chr)); len = set_itext_ichar (work, XCHAR(chr)); Dynarr_add_many (dst, work, len); ＠＠ -3607,7 +3607,7 ＠＠ assert (RANGE_TABLEP (result)); for (i = 0; i < fastmap_len; ++i) { - ranged = Fget_range_table (make_int (i), result, Qnil); + ranged = Fget_range_table (make_fixnum (i), result, Qnil); if (EQ (ranged, Qsucceeded)) { ＠＠ -3648,7 +3648,7 ＠＠ if (p == pend) break; cend = itext_ichar (p); - Fput_range_table (make_int (c), make_int (cend), Qsucceeded, + Fput_range_table (make_fixnum (c), make_fixnum (cend), Qsucceeded, result); while (c <= cend && c < fastmap_len) ＠＠ -3664,7 +3664,7 ＠＠ if (c < fastmap_len) fastmap[c] = query_coding_succeeded; - Fput_range_table (make_int (c), make_int (c), Qsucceeded, result); + Fput_range_table (make_fixnum (c), make_fixnum (c), Qsucceeded, result); } } ＠＠ -3694,7 +3694,7 ＠＠ if (p == pend) break; cend = itext_ichar (p); - Fput_range_table (make_int (c), make_int (cend), Qinvalid_sequence, + Fput_range_table (make_fixnum (c), make_fixnum (cend), Qinvalid_sequence, result); while (c <= cend && c < fastmap_len) ＠＠ -3710,7 +3710,7 ＠＠ if (c < fastmap_len) fastmap[c] = query_coding_invalid_sequence; - Fput_range_table (make_int (c), make_int (c), Qinvalid_sequence, + Fput_range_table (make_fixnum (c), make_fixnum (c), Qinvalid_sequence, result); } } ＠＠ -3754,7 +3754,7 ＠＠ /* It's okay to call Lisp here, the only non-stack object we may have allocated up to this point is skip_chars_range_table, and that's reachable from its entry in Vfixed_width_query_ranges_cache. */ - call3 (Qquery_coding_clear_highlights, make_int (pos), make_int (end), + call3 (Qquery_coding_clear_highlights, make_fixnum (pos), make_fixnum (end), wrap_buffer (buf)); } ＠＠ -3763,7 +3763,7 ＠＠ Ichar ch = BYTE_BUF_FETCH_CHAR (buf, pos_byte); if ((ch < (int) (sizeof(fastmap))) ? (fastmap[ch] == query_coding_succeeded) : - (EQ (Qsucceeded, Fget_range_table (make_int (ch), + (EQ (Qsucceeded, Fget_range_table (make_fixnum (ch), skip_chars_range_table, Qnil)))) { pos++; ＠＠ -3775,7 +3775,7 ＠＠ while ((pos < end) && ((!(flags & QUERY_METHOD_IGNORE_INVALID_SEQUENCES) && EQ (Qinvalid_sequence, Fget_range_table - (make_int (ch), skip_chars_range_table, Qnil)) + (make_fixnum (ch), skip_chars_range_table, Qnil)) && (failed_reason = query_coding_invalid_sequence)) || ((NILP ((checked_unicode = Fgethash (Fchar_to_unicode (make_char (ch)), ＠＠ -3818,8 +3818,8 ＠＠ fail_range_end = pos; - Fput_range_table (make_int (fail_range_start), - make_int (fail_range_end), + Fput_range_table (make_fixnum (fail_range_start), + make_fixnum (fail_range_end), (previous_failed_reason == query_coding_unencodable ? Qunencodable : Qinvalid_sequence), ＠＠ -3829,12 +3829,12 ＠＠ if (flags & QUERY_METHOD_HIGHLIGHT) { Lisp_Object extent - = Fmake_extent (make_int (fail_range_start), - make_int (fail_range_end), + = Fmake_extent (make_fixnum (fail_range_start), + make_fixnum (fail_range_end), wrap_buffer (buf)); Fset_extent_priority - (extent, make_int (2 + mouse_highlight_priority)); + (extent, make_fixnum (2 + mouse_highlight_priority)); Fset_extent_face (extent, Qquery_coding_warning_face); } } diff -r a0e81357194e -r 56144c8593a8 src/mule-wnnfns.c --- a/src/mule-wnnfns.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/mule-wnnfns.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -439,7 +439,7 ＠＠ int snum; CHECK_STRING (args[0]); CHECK_STRING (args[1]); - CHECK_INT (args[2]); + CHECK_FIXNUM (args[2]); if (! NILP (args[5])) CHECK_STRING (args[5]); if (! NILP (args[6])) CHECK_STRING (args[6]); if ((snum = check_wnn_server_type ()) == -1) return Qnil; ＠＠ -450,7 +450,7 ＠＠ LISP_STRING_TO_EXTERNAL (args[0], Qfile_name), LISP_STRING_TO_EXTERNAL (args[1], Qfile_name), wnnfns_norm ? WNN_DIC_ADD_NOR : WNN_DIC_ADD_REV, - XINT (args[2]), + XFIXNUM (args[2]), NILP (args[3]) ? WNN_DIC_RDONLY : WNN_DIC_RW, NILP (args[4]) ? WNN_DIC_RDONLY : WNN_DIC_RW, NILP (args[5]) ? 0 : ＠＠ -474,9 +474,9 ＠＠ { int no; int snum; - CHECK_INT (dicno); + CHECK_FIXNUM (dicno); if ((snum = check_wnn_server_type ()) == -1) return Qnil; - no = XINT (dicno); + no = XFIXNUM (dicno); if (!wnnfns_buf[snum]) return Qnil; if (jl_dic_delete (wnnfns_buf[snum], no) < 0) return Qnil; return Qt; ＠＠ -509,11 +509,11 ＠＠ dicinfo--; w2m (dicinfo->comment, comment, charset); val = - Fcons (Fcons (make_int (dicinfo->dic_no), + Fcons (Fcons (make_fixnum (dicinfo->dic_no), list4 (build_extstring (dicinfo->fname, Qfile_name), build_istring (comment), - make_int (dicinfo->gosuu), - make_int (dicinfo->nice))), val); + make_fixnum (dicinfo->gosuu), + make_fixnum (dicinfo->nice))), val); } return val; } ＠＠ -526,12 +526,12 ＠＠ { w_char wbuf[512]; int snum; - CHECK_INT (dicno); + CHECK_FIXNUM (dicno); CHECK_STRING (comment); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; m2w (XSTRING_DATA (comment), wbuf); - if (jl_dic_comment_set (wnnfns_buf[snum], XINT (dicno), wbuf) < 0) + if (jl_dic_comment_set (wnnfns_buf[snum], XFIXNUM (dicno), wbuf) < 0) return Qnil; return Qt; } ＠＠ -581,7 +581,7 ＠＠ if ((cnt = jl_ren_conv (wnnfns_buf[snum], wbuf, 0, -1, WNN_USE_MAE)) < 0) return Qnil; #endif - return make_int (cnt); + return make_fixnum (cnt); } DEFUN ("wnn-server-zenkouho", Fwnn_zenkouho, 2, 2, 0, /* ＠＠ -593,10 +593,10 ＠＠ int no, offset; int snum; int uniq_level; - CHECK_INT (bunNo); + CHECK_FIXNUM (bunNo); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; - no = XINT (bunNo); + no = XFIXNUM (bunNo); if (EQ(Vwnn_uniq_level, Qwnn_no_uniq)) uniq_level = WNN_NO_UNIQ; else if (EQ(Vwnn_uniq_level, Qwnn_uniq)) uniq_level = WNN_UNIQ; else uniq_level = WNN_UNIQ_KNJ; ＠＠ -612,7 +612,7 ＠＠ WNN_USE_MAE, uniq_level)) < 0) return Qnil; } - return make_int (offset); + return make_fixnum (offset); } ＠＠ -625,11 +625,11 ＠＠ w_char wbuf[256]; int snum; Lisp_Object charset; - CHECK_INT (kouhoNo); + CHECK_FIXNUM (kouhoNo); if ((snum = check_wnn_server_type ()) == -1) return Qnil; charset = charset_wnn_server_type[snum]; if (!wnnfns_buf[snum]) return Qnil; - jl_get_zenkouho_kanji (wnnfns_buf[snum], XINT (kouhoNo), wbuf); + jl_get_zenkouho_kanji (wnnfns_buf[snum], XFIXNUM (kouhoNo), wbuf); w2m (wbuf, kanji_buf, charset); return build_istring (kanji_buf); } ＠＠ -641,7 +641,7 ＠＠ { int snum; if ((snum = check_wnn_server_type ()) == -1) return Qnil; - return make_int (jl_zenkouho_bun (wnnfns_buf[snum])); + return make_fixnum (jl_zenkouho_bun (wnnfns_buf[snum])); } DEFUN ("wnn-server-zenkouho-suu", Fwnn_zenkouho_suu, 0, 0, 0, /* ＠＠ -651,7 +651,7 ＠＠ { int snum; if ((snum = check_wnn_server_type ()) == -1) return Qnil; - return make_int (jl_zenkouho_suu (wnnfns_buf[snum])); + return make_fixnum (jl_zenkouho_suu (wnnfns_buf[snum])); } DEFUN ("wnn-server-dai-top", Fwnn_dai_top, 1, 1, 0, /* ＠＠ -660,10 +660,10 ＠＠ (bunNo)) { int snum; - CHECK_INT (bunNo); + CHECK_FIXNUM (bunNo); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; - if (jl_dai_top (wnnfns_buf[snum], XINT (bunNo)) == 1) return Qt; + if (jl_dai_top (wnnfns_buf[snum], XFIXNUM (bunNo)) == 1) return Qt; else return Qnil; } ＠＠ -673,10 +673,10 ＠＠ (bunNo)) { int snum; - CHECK_INT (bunNo); + CHECK_FIXNUM (bunNo); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; - return make_int (dai_end (XINT (bunNo), snum)); + return make_fixnum (dai_end (XFIXNUM (bunNo), snum)); } DEFUN ("wnn-server-henkan-kakutei", Fwnn_kakutei, 2, 2, 0, /* ＠＠ -685,16 +685,16 ＠＠ (offset, dai)) { int snum; - CHECK_INT (offset); + CHECK_FIXNUM (offset); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; if (NILP (dai)) { - if (jl_set_jikouho (wnnfns_buf[snum], XINT (offset)) < 0) return Qnil; + if (jl_set_jikouho (wnnfns_buf[snum], XFIXNUM (offset)) < 0) return Qnil; } else { - if (jl_set_jikouho_dai (wnnfns_buf[snum], XINT (offset)) < 0) + if (jl_set_jikouho_dai (wnnfns_buf[snum], XFIXNUM (offset)) < 0) return Qnil; } return Qt; ＠＠ -707,21 +707,21 ＠＠ { int cnt, no; int snum; - CHECK_INT (bunNo); - CHECK_INT (len); + CHECK_FIXNUM (bunNo); + CHECK_FIXNUM (len); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; - no = XINT (bunNo); + no = XFIXNUM (bunNo); #ifdef WNN6 - if ((cnt = jl_fi_nobi_conv (wnnfns_buf[snum], no, XINT(len), -1, WNN_USE_MAE, + if ((cnt = jl_fi_nobi_conv (wnnfns_buf[snum], no, XFIXNUM(len), -1, WNN_USE_MAE, NILP (dai) ? WNN_SHO : WNN_DAI)) < 0) return Qnil; #else - if ((cnt = jl_nobi_conv (wnnfns_buf[snum], no, XINT(len), -1, WNN_USE_MAE, + if ((cnt = jl_nobi_conv (wnnfns_buf[snum], no, XFIXNUM(len), -1, WNN_USE_MAE, NILP (dai) ? WNN_SHO : WNN_DAI)) < 0) return Qnil; #endif - return make_int (cnt); + return make_fixnum (cnt); } DEFUN ("wnn-server-inspect", Fwnn_inspect, 1, 1, 0, /* ＠＠ -735,20 +735,20 ＠＠ int bun_no, yomilen, jirilen, i; int snum; Lisp_Object charset; - CHECK_INT (bunNo); + CHECK_FIXNUM (bunNo); if ((snum = check_wnn_server_type ()) == -1) return Qnil; charset = charset_wnn_server_type[snum]; if (!wnnfns_buf[snum]) return Qnil; - bun_no = XINT (bunNo); + bun_no = XFIXNUM (bunNo); val = Qnil; - val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->kangovect), val); - val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->daihyoka), val); - val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->hyoka), val); - val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->ima), val); - val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->hindo), val); - val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->hinsi), val); - val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->entry), val); - val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->dic_no), val); + val = Fcons (make_fixnum (wnnfns_buf[snum]->bun[bun_no]->kangovect), val); + val = Fcons (make_fixnum (wnnfns_buf[snum]->bun[bun_no]->daihyoka), val); + val = Fcons (make_fixnum (wnnfns_buf[snum]->bun[bun_no]->hyoka), val); + val = Fcons (make_fixnum (wnnfns_buf[snum]->bun[bun_no]->ima), val); + val = Fcons (make_fixnum (wnnfns_buf[snum]->bun[bun_no]->hindo), val); + val = Fcons (make_fixnum (wnnfns_buf[snum]->bun[bun_no]->hinsi), val); + val = Fcons (make_fixnum (wnnfns_buf[snum]->bun[bun_no]->entry), val); + val = Fcons (make_fixnum (wnnfns_buf[snum]->bun[bun_no]->dic_no), val); yomilen = jl_get_yomi (wnnfns_buf[snum], bun_no, bun_no + 1, wbuf); jirilen = wnnfns_buf[snum]->bun[bun_no]->jirilen; for (i = yomilen; i >= jirilen; i--) wbuf[i+1] = wbuf[i]; ＠＠ -783,14 +783,14 ＠＠ int kanji_len; int snum; Lisp_Object charset; - CHECK_INT (bunNo); + CHECK_FIXNUM (bunNo); if ((snum = check_wnn_server_type ()) == -1) return Qnil; charset = charset_wnn_server_type[snum]; if (!wnnfns_buf[snum]) return Qnil; - no = XINT (bunNo); + no = XFIXNUM (bunNo); kanji_len = jl_get_kanji (wnnfns_buf[snum], no, no + 1, wbuf); w2m (wbuf, kanji_buf, charset); - return Fcons (build_istring (kanji_buf), make_int (kanji_len)); + return Fcons (build_istring (kanji_buf), make_fixnum (kanji_len)); } DEFUN ("wnn-server-bunsetu-yomi", Fwnn_bunsetu_yomi, 1, 1, 0, /* ＠＠ -804,14 +804,14 ＠＠ int yomi_len; int snum; Lisp_Object charset; - CHECK_INT (bunNo); + CHECK_FIXNUM (bunNo); if ((snum = check_wnn_server_type ()) == -1) return Qnil; charset = charset_wnn_server_type[snum]; if (!wnnfns_buf[snum]) return Qnil; - no = XINT (bunNo); + no = XFIXNUM (bunNo); yomi_len = jl_get_yomi (wnnfns_buf[snum], no, no + 1, wbuf); w2m (wbuf, yomi_buf, charset); - return Fcons (build_istring (yomi_buf), make_int (yomi_len)); + return Fcons (build_istring (yomi_buf), make_fixnum (yomi_len)); } DEFUN ("wnn-server-bunsetu-suu", Fwnn_bunsetu_suu, 0, 0, 0, /* ＠＠ -822,7 +822,7 ＠＠ int snum; if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; - return make_int (jl_bun_suu (wnnfns_buf[snum])); + return make_fixnum (jl_bun_suu (wnnfns_buf[snum])); } DEFUN ("wnn-server-hindo-update", Fwnn_hindo_update, 0, 1, 0, /* ＠＠ -836,8 +836,8 ＠＠ if (NILP (bunNo)) no = -1; else { - CHECK_INT (bunNo); - no = XINT (bunNo); + CHECK_FIXNUM (bunNo); + no = XFIXNUM (bunNo); } if (!wnnfns_buf[snum]) return Qnil; #ifdef WNN6 ＠＠ -857,11 +857,11 ＠＠ { w_char yomi_buf[256], kanji_buf[256], comment_buf[256]; int snum; - CHECK_INT (dicno); + CHECK_FIXNUM (dicno); CHECK_STRING (kanji); CHECK_STRING (yomi); CHECK_STRING (comment); - CHECK_INT (hinsi); + CHECK_FIXNUM (hinsi); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; m2w (XSTRING_DATA (yomi), yomi_buf); ＠＠ -869,8 +869,8 ＠＠ w2y (yomi_buf); m2w (XSTRING_DATA (kanji), kanji_buf); m2w (XSTRING_DATA (comment), comment_buf); - if (jl_word_add (wnnfns_buf[snum], XINT (dicno), yomi_buf, kanji_buf, - comment_buf, XINT (hinsi), 0) < 0) + if (jl_word_add (wnnfns_buf[snum], XFIXNUM (dicno), yomi_buf, kanji_buf, + comment_buf, XFIXNUM (hinsi), 0) < 0) return Qnil; else return Qt; } ＠＠ -882,11 +882,11 ＠＠ (no, serial)) { int snum; - CHECK_INT (no); - CHECK_INT (serial); + CHECK_FIXNUM (no); + CHECK_FIXNUM (serial); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; - if (jl_word_delete (wnnfns_buf[snum], XINT (no), XINT (serial)) < 0) + if (jl_word_delete (wnnfns_buf[snum], XFIXNUM (no), XFIXNUM (serial)) < 0) return Qnil; else return Qt; } ＠＠ -898,11 +898,11 ＠＠ (no, serial)) { int snum; - CHECK_INT (no); - CHECK_INT (serial); + CHECK_FIXNUM (no); + CHECK_FIXNUM (serial); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; - if (jl_word_use (wnnfns_buf[snum], XINT (no), XINT (serial)) < 0) + if (jl_word_use (wnnfns_buf[snum], XFIXNUM (no), XFIXNUM (serial)) < 0) return Qnil; else return Qt; } ＠＠ -917,21 +917,21 ＠＠ Ibyte cbuf[512]; int snum; Lisp_Object charset; - CHECK_INT (no); - CHECK_INT (serial); + CHECK_FIXNUM (no); + CHECK_FIXNUM (serial); if ((snum = check_wnn_server_type ()) == -1) return Qnil; charset = charset_wnn_server_type[snum]; if (!wnnfns_buf[snum]) return Qnil; if ((info_buf = jl_word_info (wnnfns_buf[snum], - XINT (no), XINT (serial))) != NULL) + XFIXNUM (no), XFIXNUM (serial))) != NULL) { return Qnil; } else { val = Qnil; - val = Fcons (make_int (info_buf->hinshi), val); - val = Fcons (make_int (info_buf->hindo), val); + val = Fcons (make_fixnum (info_buf->hinshi), val); + val = Fcons (make_fixnum (info_buf->hindo), val); w2m (info_buf->com, cbuf, charset); val = Fcons (build_istring (cbuf), val); w2m (info_buf->kanji, cbuf, charset); ＠＠ -949,16 +949,16 ＠＠ (no, serial, hindo)) { int snum; - CHECK_INT (no); - CHECK_INT (serial); - CHECK_INT (hindo); + CHECK_FIXNUM (no); + CHECK_FIXNUM (serial); + CHECK_FIXNUM (hindo); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; if (js_hindo_set (jl_env_get (wnnfns_buf[snum]), - XINT (no), - XINT (serial), + XFIXNUM (no), + XFIXNUM (serial), WNN_HINDO_NOP, - XINT (hindo)) < 0) + XFIXNUM (hindo)) < 0) return Qnil; else return Qt; } ＠＠ -993,10 +993,10 ＠＠ wordinfo--; w2m (wordinfo->kanji, kanji_buf, charset); val = Fcons (Fcons (build_istring (kanji_buf), - list4 (make_int (wordinfo->hinshi), - make_int (wordinfo->hindo), - make_int (wordinfo->dic_no), - make_int (wordinfo->serial))), + list4 (make_fixnum (wordinfo->hinshi), + make_fixnum (wordinfo->hindo), + make_fixnum (wordinfo->dic_no), + make_fixnum (wordinfo->serial))), val); } return val; ＠＠ -1025,23 +1025,23 ＠＠ if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; if (jl_param_get (wnnfns_buf[snum], &param) < 0) return Qnil; - return Fcons (make_int (param.n), - Fcons (make_int (param.nsho), - Fcons (make_int (param.p1), - Fcons (make_int (param.p2), - Fcons (make_int (param.p3), - Fcons (make_int (param.p4), - Fcons (make_int (param.p5), - Fcons (make_int (param.p6), - Fcons (make_int (param.p7), - Fcons (make_int (param.p8), - Fcons (make_int (param.p9), - Fcons (make_int (param.p10), - Fcons (make_int (param.p11), - Fcons (make_int (param.p12), - Fcons (make_int (param.p13), - Fcons (make_int (param.p14), - Fcons (make_int (param.p15),Qnil))))))))))))))))); + return Fcons (make_fixnum (param.n), + Fcons (make_fixnum (param.nsho), + Fcons (make_fixnum (param.p1), + Fcons (make_fixnum (param.p2), + Fcons (make_fixnum (param.p3), + Fcons (make_fixnum (param.p4), + Fcons (make_fixnum (param.p5), + Fcons (make_fixnum (param.p6), + Fcons (make_fixnum (param.p7), + Fcons (make_fixnum (param.p8), + Fcons (make_fixnum (param.p9), + Fcons (make_fixnum (param.p10), + Fcons (make_fixnum (param.p11), + Fcons (make_fixnum (param.p12), + Fcons (make_fixnum (param.p13), + Fcons (make_fixnum (param.p14), + Fcons (make_fixnum (param.p15),Qnil))))))))))))))))); } DEFUN ("wnn-server-set-param", Fwnn_set_param, 1, 1, 0, /* ＠＠ -1066,8 +1066,8 ＠＠ EXTERNAL_PROPERTY_LIST_LOOP_3 (key, val, Vsetvalues_alist) { int setval; - CHECK_INT (val); - setval = XINT (val); + CHECK_FIXNUM (val); + setval = XFIXNUM (val); if (EQ (key, Qwnn_n)) param.n = setval; else if (EQ (key, Qwnn_nsho)) param.nsho = setval; else if (EQ (key, Qwnn_hindo)) param.p1 = setval; ＠＠ -1128,7 +1128,7 ＠＠ int snum; Lisp_Object charset; char langname[32]; -/* CHECK_INT (errno);*/ +/* CHECK_FIXNUM (errno);*/ if ((snum = check_wnn_server_type ()) == -1) return Qnil; charset = charset_wnn_server_type[snum]; switch (snum) ＠＠ -1149,7 +1149,7 ＠＠ break; } if (!wnnfns_buf[snum]) return Qnil; -/* msgp = msg_get (wnn_msg_cat, XINT (errno), 0, 0);*/ +/* msgp = msg_get (wnn_msg_cat, XFIXNUM (errno), 0, 0);*/ msgp = wnn_perror_lang (langname); c2m ((UExtbyte *) msgp, mbuf, charset); return build_istring (mbuf); ＠＠ -1206,16 +1206,16 ＠＠ int cnt; Lisp_Object val; int snum; - CHECK_INT (hinsi); + CHECK_FIXNUM (hinsi); if ((snum = check_wnn_server_type ()) == -1) return Qnil; if (!wnnfns_buf[snum]) return Qnil; - if ((cnt = jl_hinsi_dicts (wnnfns_buf[snum], XINT (hinsi), &area)) < 0) + if ((cnt = jl_hinsi_dicts (wnnfns_buf[snum], XFIXNUM (hinsi), &area)) < 0) return Qnil; val = Qnil; for (area += cnt; cnt > 0; cnt--) { area--; - val = Fcons (make_int (*area), val); + val = Fcons (make_fixnum (*area), val); } return val; } ＠＠ -1232,15 +1232,15 ＠＠ Ibyte cbuf[512]; int snum; Lisp_Object charset; - CHECK_INT (dicno); + CHECK_FIXNUM (dicno); CHECK_STRING (name); if ((snum = check_wnn_server_type ()) == -1) return Qnil; charset = charset_wnn_server_type[snum]; if (!wnnfns_buf[snum]) return Qnil; m2w (XSTRING_DATA (name), wbuf); - if ((cnt = jl_hinsi_list (wnnfns_buf[snum], XINT (dicno), wbuf, &area)) < 0) + if ((cnt = jl_hinsi_list (wnnfns_buf[snum], XFIXNUM (dicno), wbuf, &area)) < 0) return Qnil; - if (cnt == 0) return make_int (0); + if (cnt == 0) return make_fixnum (0); val = Qnil; for (area += cnt; cnt > 0; cnt--) { ＠＠ -1260,11 +1260,11 ＠＠ w_char *wname; int snum; Lisp_Object charset; - CHECK_INT (no); + CHECK_FIXNUM (no); if ((snum = check_wnn_server_type ()) == -1) return Qnil; charset = charset_wnn_server_type[snum]; if (!wnnfns_buf[snum]) return Qnil; - if ((wname = jl_hinsi_name (wnnfns_buf[snum], XINT (no))) == 0) return Qnil; + if ((wname = jl_hinsi_name (wnnfns_buf[snum], XFIXNUM (no))) == 0) return Qnil; w2m (wname, name, charset); return build_istring (name); } ＠＠ -1354,7 +1354,7 ＠＠ unsigned long vmask = 0; struct wnn_henkan_env henv; CHECK_STRING (args[0]); - CHECK_INT (args[1]); + CHECK_FIXNUM (args[1]); if (! NILP (args[3])) CHECK_STRING (args[3]); if ((snum = check_wnn_server_type()) == -1) return Qnil; if(!wnnfns_buf[snum]) return Qnil; ＠＠ -1373,7 +1373,7 ＠＠ 0, wnnfns_norm ? WNN_DIC_ADD_NOR : WNN_DIC_ADD_REV, - XINT (args[1]), + XFIXNUM (args[1]), WNN_DIC_RW, WNN_DIC_RW, NILP (args[3]) ? 0 : LISP_STRING_TO_EXTERNAL (args[3], ＠＠ -1423,7 +1423,7 ＠＠ unsigned long vmask = 0; struct wnn_henkan_env henv; CHECK_STRING (args[0]); - CHECK_INT (args[1]); + CHECK_FIXNUM (args[1]); if (! NILP (args[3])) CHECK_STRING (args[3]); if ((snum = check_wnn_server_type()) == -1) return Qnil; if(!wnnfns_buf[snum]) return Qnil; ＠＠ -1442,7 +1442,7 ＠＠ 0, wnnfns_norm ? WNN_DIC_ADD_NOR : WNN_DIC_ADD_REV, - XINT(args[1]), + XFIXNUM(args[1]), WNN_DIC_RW, WNN_DIC_RW, NILP (args[3]) ? 0 : LISP_STRING_TO_EXTERNAL (args[3], ＠＠ -1541,8 +1541,8 ＠＠ int snum, mode; unsigned long vmask = 0; struct wnn_henkan_env henv; - CHECK_INT (lmode); - mode = XINT (lmode); + CHECK_FIXNUM (lmode); + mode = XFIXNUM (lmode); if ((snum = check_wnn_server_type()) == -1) return Qnil; if(!wnnfns_buf[snum]) return Qnil; if(mode != WNN_OKURI_REGULATION && ＠＠ -1584,8 +1584,8 ＠＠ int snum, mode; unsigned long vmask = 0; struct wnn_henkan_env henv; - CHECK_INT (lmode); - mode = XINT (lmode); + CHECK_FIXNUM (lmode); + mode = XFIXNUM (lmode); if ((snum = check_wnn_server_type()) == -1) return Qnil; if(!wnnfns_buf[snum]) return Qnil; if(mode != WNN_KANA_KOUHO && mode != WNN_KANJI_KOUHO) ＠＠ -1643,8 +1643,8 ＠＠ int snum, mode; unsigned long vmask = 0; struct wnn_henkan_env henv; - CHECK_INT (lmode); - mode = XINT (lmode); + CHECK_FIXNUM (lmode); + mode = XFIXNUM (lmode); if ((snum = check_wnn_server_type()) == -1) return Qnil; if(!wnnfns_buf[snum]) return Qnil; if(mode != 0 && mode != 1 && mode != 2 && mode != 3 && mode != 4) ＠＠ -1666,8 +1666,8 ＠＠ int snum, mode; unsigned long vmask = 0; struct wnn_henkan_env henv; - CHECK_INT (lmode); - mode = XINT (lmode); + CHECK_FIXNUM (lmode); + mode = XFIXNUM (lmode); if ((snum = check_wnn_server_type()) == -1) return Qnil; if(!wnnfns_buf[snum]) return Qnil; if(mode != WNN_NUM_KANSUUJI && ＠＠ -1695,8 +1695,8 ＠＠ int snum, mode; unsigned long vmask = 0; struct wnn_henkan_env henv; - CHECK_INT (lmode); - mode = XINT (lmode); + CHECK_FIXNUM (lmode); + mode = XFIXNUM (lmode); if ((snum = check_wnn_server_type()) == -1) return Qnil; if(!wnnfns_buf[snum]) return Qnil; if(mode != WNN_ALP_HAN && mode != WNN_ALP_ZEN) ＠＠ -1718,8 +1718,8 ＠＠ int snum, mode; unsigned long vmask = 0; struct wnn_henkan_env henv; - CHECK_INT (lmode); - mode = XINT (lmode); + CHECK_FIXNUM (lmode); + mode = XFIXNUM (lmode); if ((snum = check_wnn_server_type()) == -1) return Qnil; if(!wnnfns_buf[snum]) return Qnil; if(mode != WNN_KIG_HAN && mode != WNN_KIG_JIS && mode != WNN_KIG_ASC) ＠＠ -1780,7 +1780,7 ＠＠ else cur_env = wnnfns_env_rev[snum]; if(js_version (cur_env->js_id,&serv,&libv) < 0) return Qnil; - return make_int (serv); + return make_fixnum (serv); } DEFUN ("wnn-server-hinsi-number", Fwnn_hinsi_number, 1, 1, 0, /* ＠＠ -1796,7 +1796,7 ＠＠ if (!wnnfns_buf[snum]) return Qnil; m2w (XSTRING_DATA (name), w_buf); if ((no = jl_hinsi_number (wnnfns_buf[snum], w_buf)) < 0) return Qnil; - return make_int (no); + return make_fixnum (no); } void diff -r a0e81357194e -r 56144c8593a8 src/number.c --- a/src/number.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/number.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -250,7 +250,7 ＠＠ (XRATIO_DENOMINATOR (rational))); } #endif - return make_int (1); + return make_fixnum (1); }  ＠＠ -332,7 +332,7 ＠＠ bignum_set_ulong (scratch_bignum, XBIGFLOAT_GET_PREC (f)); return Fcanonicalize_number (make_bignum_bg (scratch_bignum)); #else - return make_int ((int) XBIGFLOAT_GET_PREC (f)); + return make_fixnum ((int) XBIGFLOAT_GET_PREC (f)); #endif } ＠＠ -347,9 +347,9 ＠＠ unsigned long prec; CHECK_BIGFLOAT (f); - if (INTP (precision)) + if (FIXNUMP (precision)) { - prec = (XINT (precision) <= 0) ? 1UL : (unsigned long) XINT (precision); + prec = (XFIXNUM (precision) <= 0) ? 1UL : (unsigned long) XFIXNUM (precision); } #ifdef HAVE_BIGNUM else if (BIGNUMP (precision)) ＠＠ -378,8 +378,8 ＠＠ CONCHECK_INTEGER (*val); #ifdef HAVE_BIGFLOAT - if (INTP (*val)) - prec = XINT (*val); + if (FIXNUMP (*val)) + prec = XFIXNUM (*val); else { if (!bignum_fits_ulong_p (XBIGNUM_DATA (*val))) ＠＠ -446,8 +446,8 ＠＠ if (BIGNUMP (number) && bignum_fits_emacs_int_p (XBIGNUM_DATA (number))) { EMACS_INT n = bignum_to_emacs_int (XBIGNUM_DATA (number)); - if (NUMBER_FITS_IN_AN_EMACS_INT (n)) - number = make_int (n); + if (NUMBER_FITS_IN_A_FIXNUM (n)) + number = make_fixnum (n); } #endif return number; ＠＠ -456,7 +456,7 ＠＠ enum number_type get_number_type (Lisp_Object arg) { - if (INTP (arg)) + if (FIXNUMP (arg)) return FIXNUM_T; #ifdef HAVE_BIGNUM if (BIGNUMP (arg)) ＠＠ -492,9 +492,9 ＠＠ enum number_type current_type; if (CHARP (number)) - number = make_int (XCHAR (number)); + number = make_fixnum (XCHAR (number)); else if (MARKERP (number)) - number = make_int (marker_position (number)); + number = make_fixnum (marker_position (number)); /* Note that CHECK_NUMBER ensures that NUMBER is a supported type. Hence, we ABORT() in the #else sections below, because it shouldn't be possible ＠＠ -510,21 +510,21 ＠＠ return number; case BIGNUM_T: #ifdef HAVE_BIGNUM - return make_bignum (XREALINT (number)); + return make_bignum (XREALFIXNUM (number)); #else ABORT (); #endif /* HAVE_BIGNUM */ case RATIO_T: #ifdef HAVE_RATIO - return make_ratio (XREALINT (number), 1UL); + return make_ratio (XREALFIXNUM (number), 1UL); #else ABORT (); #endif /* HAVE_RATIO */ case FLOAT_T: - return make_float (XREALINT (number)); + return make_float (XREALFIXNUM (number)); case BIGFLOAT_T: #ifdef HAVE_BIGFLOAT - return make_bigfloat (XREALINT (number), precision); + return make_bigfloat (XREALFIXNUM (number), precision); #else ABORT (); #endif /* HAVE_BIGFLOAT */ ＠＠ -534,7 +534,7 ＠＠ switch (type) { case FIXNUM_T: - return make_int (bignum_to_long (XBIGNUM_DATA (number))); + return make_fixnum (bignum_to_long (XBIGNUM_DATA (number))); case BIGNUM_T: return number; case RATIO_T: ＠＠ -568,7 +568,7 ＠＠ case FIXNUM_T: bignum_div (scratch_bignum, XRATIO_NUMERATOR (number), XRATIO_DENOMINATOR (number)); - return make_int (bignum_to_long (scratch_bignum)); + return make_fixnum (bignum_to_long (scratch_bignum)); case BIGNUM_T: bignum_div (scratch_bignum, XRATIO_NUMERATOR (number), XRATIO_DENOMINATOR (number)); ＠＠ -627,7 +627,7 ＠＠ switch (type) { case FIXNUM_T: - return make_int (bigfloat_to_long (XBIGFLOAT_DATA (number))); + return make_fixnum (bigfloat_to_long (XBIGFLOAT_DATA (number))); case BIGNUM_T: #ifdef HAVE_BIGNUM bignum_set_bigfloat (scratch_bignum, XBIGFLOAT_DATA (number)); ＠＠ -666,13 +666,13 ＠＠ enum number_type type1, type2; if (CHARP (*arg1)) - *arg1 = make_int (XCHAR (*arg1)); + *arg1 = make_fixnum (XCHAR (*arg1)); else if (MARKERP (*arg1)) - *arg1 = make_int (marker_position (*arg1)); + *arg1 = make_fixnum (marker_position (*arg1)); if (CHARP (*arg2)) - *arg2 = make_int (XCHAR (*arg2)); + *arg2 = make_fixnum (XCHAR (*arg2)); else if (MARKERP (*arg2)) - *arg2 = make_int (marker_position (*arg2)); + *arg2 = make_fixnum (marker_position (*arg2)); CHECK_NUMBER (*arg1); CHECK_NUMBER (*arg2); ＠＠ -752,9 +752,9 ＠＠ { CHECK_INTEGER (precision); #ifdef HAVE_BIGNUM - if (INTP (precision)) + if (FIXNUMP (precision)) #endif /* HAVE_BIGNUM */ - prec = (unsigned long) XREALINT (precision); + prec = (unsigned long) XREALFIXNUM (precision); #ifdef HAVE_BIGNUM else { ＠＠ -824,7 +824,7 ＠＠ than `bigfloat-maximum-precision' to create Lisp bigfloat types with the indicated precision. */ default_float_precision_changed); - Vdefault_float_precision = make_int (0); + Vdefault_float_precision = make_fixnum (0); DEFVAR_CONST_LISP ("bigfloat-maximum-precision", &Vbigfloat_max_prec /* The maximum number of bits of precision a bigfloat can have. ＠＠ -834,9 +834,9 ＠＠ #ifdef HAVE_BIGFLOAT /* Don't create a bignum here. Otherwise, we lose with NEW_GC + pdump. See reinit_vars_of_number(). */ - Vbigfloat_max_prec = make_int (EMACS_INT_MAX); + Vbigfloat_max_prec = make_fixnum (MOST_POSITIVE_FIXNUM); #else - Vbigfloat_max_prec = make_int (0); + Vbigfloat_max_prec = make_fixnum (0); #endif /* HAVE_BIGFLOAT */ Fprovide (intern ("number-types")); diff -r a0e81357194e -r 56144c8593a8 src/number.h --- a/src/number.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/number.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -129,7 +129,7 ＠＠  /********************************* Integers *********************************/ /* Qintegerp in lisp.h */ -#define INTEGERP(x) (INTP(x) || BIGNUMP(x)) +#define INTEGERP(x) (FIXNUMP(x) || BIGNUMP(x)) #define CHECK_INTEGER(x) do { \ if (!INTEGERP (x)) \ dead_wrong_type_argument (Qintegerp, x); \ ＠＠ -141,9 +141,9 ＠＠ #ifdef HAVE_BIGNUM #define make_integer(x) \ - (NUMBER_FITS_IN_AN_EMACS_INT (x) ? make_int (x) : make_bignum (x)) + (NUMBER_FITS_IN_A_FIXNUM (x) ? make_fixnum (x) : make_bignum (x)) #else -#define make_integer(x) make_int (x) +#define make_integer(x) make_fixnum (x) #endif extern Fixnum Vmost_negative_fixnum, Vmost_positive_fixnum; ＠＠ -169,10 +169,10 ＠＠ NATNUMP. */ #ifdef HAVE_BIGNUM -#define NATNUMP(x) ((INTP (x) && XINT (x) >= 0) || \ +#define NATNUMP(x) ((FIXNUMP (x) && XFIXNUM (x) >= 0) || \ (BIGNUMP (x) && bignum_sign (XBIGNUM_DATA (x)) >= 0)) #else -#define NATNUMP(x) (INTP (x) && XINT (x) >= 0) +#define NATNUMP(x) (FIXNUMP (x) && XFIXNUM (x) >= 0) #endif #define CHECK_NATNUM(x) do { \ diff -r a0e81357194e -r 56144c8593a8 src/print.c --- a/src/print.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/print.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -513,7 +513,7 ＠＠ buffer_insert_string_1 (XMARKER (function)->buffer, spoint, nonreloc, reloc, offset, len, 0); - Fset_marker (function, make_int (spoint + cclen), + Fset_marker (function, make_fixnum (spoint + cclen), Fmarker_buffer (function)); } else if (FRAMEP (function)) ＠＠ -1410,9 +1410,9 ＠＠ struct gcpro gcpro1, gcpro2; GCPRO2 (obj, printcharfun); - if (INTP (Vprint_length)) + if (FIXNUMP (Vprint_length)) { - int max = XINT (Vprint_length); + int max = XFIXNUM (Vprint_length); if (max < len) last = max; } ＠＠ -1458,7 +1458,7 ＠＠ { int len; - int max = INTP (Vprint_length) ? XINT (Vprint_length) : INT_MAX; + int max = FIXNUMP (Vprint_length) ? XFIXNUM (Vprint_length) : INT_MAX; Lisp_Object tortoise; /* Use tortoise/hare to make sure circular lists don't infloop */ ＠＠ -1476,7 +1476,7 ＠＠ of events. All the other possibly-repeated structures always hand sub-objects to print_internal(). */ if (print_circle && - INTP (Fgethash (obj, Vprint_number_table, Qnil))) + FIXNUMP (Fgethash (obj, Vprint_number_table, Qnil))) { write_ascstring (printcharfun, ". "); print_internal (obj, printcharfun, escapeflag); ＠＠ -1540,10 +1540,10 ＠＠ struct gcpro gcpro1, gcpro2; GCPRO2 (obj, printcharfun); - if (INTP (Vprint_string_length) && - XINT (Vprint_string_length) < max) + if (FIXNUMP (Vprint_string_length) && + XFIXNUM (Vprint_string_length) < max) { - max = XINT (Vprint_string_length); + max = XFIXNUM (Vprint_string_length); bcmax = string_index_char_to_byte (obj, max); } if (max < 0) ＠＠ -1733,18 +1733,18 ＠＠ hte = find_htentry (obj, XHASH_TABLE (table)); } - extracted = XINT (hte->value); + extracted = XFIXNUM (hte->value); if (1 == extracted) { *seen_object_count += 1; hte->value - = make_int (1 | (*seen_object_count << PRINT_NUMBER_ORDINAL_SHIFT)); + = make_fixnum (1 | (*seen_object_count << PRINT_NUMBER_ORDINAL_SHIFT)); } else if ((extracted & PRINT_NUMBER_SEEN_MASK) == PRINT_NUMBER_SEEN_MASK) { /* Avoid the number overflowing the bit field. */ extracted = (extracted & ~PRINT_NUMBER_SEEN_MASK) | 2; - hte->value = make_int (extracted); + hte->value = make_fixnum (extracted); } return extracted & PRINT_NUMBER_SEEN_MASK; ＠＠ -1791,7 +1791,7 ＠＠ print_seen_once (Lisp_Object UNUSED (key), Lisp_Object value, void * UNUSED (extra_arg)) { - return 1 == ((XINT (value) & PRINT_NUMBER_SEEN_MASK)); + return 1 == ((XFIXNUM (value) & PRINT_NUMBER_SEEN_MASK)); } static int ＠＠ -1801,7 +1801,7 ＠＠ /* print_continuous_numbering is used for symbols, so we don't delete them from the print info hash table. It's less useful for other objects at the moment, though. */ - return !SYMBOLP (key) && (1 == ((XINT (value) & PRINT_NUMBER_SEEN_MASK))); + return !SYMBOLP (key) && (1 == ((XFIXNUM (value) & PRINT_NUMBER_SEEN_MASK))); } static int ＠＠ -1812,7 +1812,7 ＠＠ *preprocess_sort_ptr += 1; preprocess_sort->key = key; - preprocess_sort->count = XINT (value); + preprocess_sort->count = XFIXNUM (value); return 0; } ＠＠ -1877,7 +1877,7 ＠＠ Vprint_number_table, NULL); new_print_number_index - = XINT (Fhash_table_count (Vprint_number_table)); + = XFIXNUM (Fhash_table_count (Vprint_number_table)); if (new_print_number_index != print_number_index && new_print_number_index != old_print_number_index) ＠＠ -1901,7 +1901,7 ＠＠ ii++) { Fputhash (preprocess_sort[ii].key, - make_int ((preprocess_sort[ii].count + make_fixnum ((preprocess_sort[ii].count & ~PRINT_NUMBER_ORDINAL_MASK) | ((ii + 1) << PRINT_NUMBER_ORDINAL_SHIFT)), ＠＠ -1914,7 +1914,7 ＠＠ /* The new objects may include OBJ; update SEEN to reflect this. */ seen = Fgethash (obj, Vprint_number_table, Qnil); - if (INTP (seen)) + if (FIXNUMP (seen)) { goto prefix_this; } ＠＠ -1923,15 +1923,15 ＠＠ else { prefix_this: - if ((XINT (seen) & PRINT_NUMBER_SEEN_MASK) == 1 + if ((XFIXNUM (seen) & PRINT_NUMBER_SEEN_MASK) == 1 && !(print_continuous_numbering && SYMBOLP (obj))) { return PRINT_GENSYM_PRINT_AND_CLEANUP_TABLE; } - else if (XINT (seen) & PRINT_NUMBER_PRINTED_MASK) + else if (XFIXNUM (seen) & PRINT_NUMBER_PRINTED_MASK) { write_fmt_string (printcharfun, "#%d#", - (XINT (seen) & PRINT_NUMBER_ORDINAL_MASK) + (XFIXNUM (seen) & PRINT_NUMBER_ORDINAL_MASK) /* We're finished printing this object. */ ＠＠ -1940,12 +1940,12 ＠＠ else { write_fmt_string (printcharfun, "#%d=", - (XINT (seen) & PRINT_NUMBER_ORDINAL_MASK) + (XFIXNUM (seen) & PRINT_NUMBER_ORDINAL_MASK) /* We set PRINT_NUMBER_PRINTED_MASK immediately here, so the object itself is written as #%d# when printing its contents. */ - Fputhash (obj, make_int (XINT (seen) | PRINT_NUMBER_PRINTED_MASK), + Fputhash (obj, make_fixnum (XFIXNUM (seen) | PRINT_NUMBER_PRINTED_MASK), Vprint_number_table); /* This is the first time the object has been seen while ＠＠ -1971,14 +1971,14 ＠＠ seen = Fgethash (tree, number_table, Qnil); - if (INTP (seen)) + if (FIXNUMP (seen)) { - if (XINT (seen) & PRINT_NUMBER_PRINTED_MASK) + if (XFIXNUM (seen) & PRINT_NUMBER_PRINTED_MASK) { return tree; } - Fputhash (tree, make_int (XINT (seen) | PRINT_NUMBER_PRINTED_MASK), + Fputhash (tree, make_fixnum (XFIXNUM (seen) | PRINT_NUMBER_PRINTED_MASK), number_table); } ＠＠ -2081,11 +2081,11 ＠＠ switch (XTYPE (obj)) { - case Lisp_Type_Int_Even: - case Lisp_Type_Int_Odd: + case Lisp_Type_Fixnum_Even: + case Lisp_Type_Fixnum_Odd: { Ascbyte buf[DECIMAL_PRINT_SIZE (EMACS_INT)]; - long_to_string (buf, XINT (obj)); + long_to_string (buf, XFIXNUM (obj)); write_ascstring (printcharfun, buf); break; } ＠＠ -2315,8 +2315,8 ＠＠ if (CONSP (obj) || VECTORP (obj)) { /* If deeper than spec'd depth, print placeholder. */ - if (INTP (Vprint_level) - && print_depth > XINT (Vprint_level)) + if (FIXNUMP (Vprint_level) + && print_depth > XFIXNUM (Vprint_level)) { write_ascstring (printcharfun, "..."); break; ＠＠ -2636,7 +2636,7 ＠＠ static Lisp_Object restore_inhibit_non_essential_conversion_operations (Lisp_Object obj) { - inhibit_non_essential_conversion_operations = XINT (obj); + inhibit_non_essential_conversion_operations = XFIXNUM (obj); return Qnil; } ＠＠ -2648,7 +2648,7 ＠＠ int depth = record_unwind_protect (restore_inhibit_non_essential_conversion_operations, - make_int (inhibit_non_essential_conversion_operations)); + make_fixnum (inhibit_non_essential_conversion_operations)); inhibit_non_essential_conversion_operations = 1; return depth; } ＠＠ -2711,9 +2711,9 ＠＠ in_debug_print = 1; gc_currently_forbidden = 1; if (debug_print_length > 0) - Vprint_length = make_int (debug_print_length); + Vprint_length = make_fixnum (debug_print_length); if (debug_print_level > 0) - Vprint_level = make_int (debug_print_level); + Vprint_level = make_fixnum (debug_print_level); Vinhibit_quit = Qt; return specdepth; ＠＠ -2790,9 +2790,9 ＠＠ else debug_out ("%s", XSTRING_DATA (name)); } - else if (INTP (obj)) + else if (FIXNUMP (obj)) { - debug_out ("%ld", XINT (obj)); + debug_out ("%ld", XFIXNUM (obj)); } else if (FLOATP (obj)) { diff -r a0e81357194e -r 56144c8593a8 src/process-nt.c --- a/src/process-nt.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/process-nt.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -636,7 +636,7 ＠＠ if (signo != SIGKILL && signo != SIGTERM && signo != SIGQUIT && signo != SIGINT && signo != SIGHUP) - invalid_constant ("Signal number not supported", make_int (signo)); + invalid_constant ("Signal number not supported", make_fixnum (signo)); }  /*-----------------------------------------------------------------------*/ ＠＠ -1137,7 +1137,7 ＠＠ { /* Buffer is full. Wait, accepting input; that may allow the program to finish doing output and read more. */ - Faccept_process_output (Qnil, Qzero, make_int (wait_ms)); + Faccept_process_output (Qnil, Qzero, make_fixnum (wait_ms)); Lstream_flush (XLSTREAM (p->pipe_outstream)); wait_ms = min (1000, 2 * wait_ms); } ＠＠ -1337,8 +1337,8 ＠＠ if (!EQ (protocol, Qtcp)) invalid_constant ("Unsupported protocol", protocol); - if (INTP (service)) - port = htons ((unsigned short) XINT (service)); + if (FIXNUMP (service)) + port = htons ((unsigned short) XFIXNUM (service)); else { struct servent *svc_info; ＠＠ -1537,13 +1537,13 ＠＠ } else { - CHECK_INT (process); + CHECK_FIXNUM (process); /* Allow pid to be an internally generated one, or one obtained externally. This is necessary because real pids on Win95 are negative. */ - pid = XINT (process); + pid = XFIXNUM (process); p = find_process_from_pid (pid); if (p != NULL) pid = NT_DATA (p)->dwProcessId; diff -r a0e81357194e -r 56144c8593a8 src/process-unix.c --- a/src/process-unix.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/process-unix.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -171,10 +171,10 ＠＠ EMACS_INT inch; CHECK_STRING (name); - CHECK_INT (infd); - CHECK_INT (outfd); + CHECK_FIXNUM (infd); + CHECK_FIXNUM (outfd); - inch = XINT (infd); + inch = XFIXNUM (infd); if (get_process_from_usid (FD_TO_USID (inch))) invalid_operation ("There is already a process connected to fd", infd); if (!NILP (buffer)) ＠＠ -184,7 +184,7 ＠＠ XPROCESS (proc)->pid = Fcons (infd, name); XPROCESS (proc)->buffer = buffer; init_process_io_handles (XPROCESS (proc), (void *) inch, - (void *) XINT (outfd), (void *) -1, 0); + (void *) XFIXNUM (outfd), (void *) -1, 0); UNIX_DATA (XPROCESS (proc))->connected_via_filedesc_p = 1; event_stream_select_process (XPROCESS (proc), 1, 1); ＠＠ -464,7 +464,7 ＠＠ if (! (host_info_ptr == 0 && h_errno == TRY_AGAIN)) #endif break; - Fsleep_for (make_int (1)); + Fsleep_for (make_fixnum (1)); } if (host_info_ptr) { ＠＠ -528,7 +528,7 ＠＠ else continue; } - else if (INTP (tail_port) && (htons ((unsigned short) XINT (tail_port)) == port)) + else if (FIXNUMP (tail_port) && (htons ((unsigned short) XFIXNUM (tail_port)) == port)) break; } ＠＠ -927,7 +927,7 ＠＠ /* Set `env' to a vector of the strings in Vprocess_environment. */ /* + 2 to include PWD and terminating 0. */ - env = alloca_array (Ibyte *, XINT (Flength (Vprocess_environment)) + 2); + env = alloca_array (Ibyte *, XFIXNUM (Flength (Vprocess_environment)) + 2); { REGISTER Lisp_Object tail; Ibyte **new_env = env; ＠＠ -1348,7 +1348,7 ＠＠ #ifdef SIGCHLD EMACS_BLOCK_SIGNAL (SIGCHLD); #endif - if (waitpid (XINT (p->pid), &w, WNOHANG) == XINT (p->pid)) + if (waitpid (XFIXNUM (p->pid), &w, WNOHANG) == XFIXNUM (p->pid)) { p->tick++; update_status_from_wait_code (p, &w); ＠＠ -1396,7 +1396,7 ＠＠ { Lisp_Object proc = XCAR (tail); p = XPROCESS (proc); - if (INTP (p->pid) && XINT (p->pid) == pid) + if (FIXNUMP (p->pid) && XFIXNUM (p->pid) == pid) break; p = 0; } ＠＠ -1527,7 +1527,7 ＠＠ uses geometrically increasing timeouts (up to 1s). This might be a good idea here. N.B. timeout_secs = Qnil is faster than Qzero. */ - Faccept_process_output (Qnil, Qnil, make_int (10)); + Faccept_process_output (Qnil, Qnil, make_fixnum (10)); /* It could have *really* finished, deleting the process */ if (NILP(p->pipe_outstream)) return; ＠＠ -1761,7 +1761,7 ＠＠ the shell's subprocess is killed, which is the desired effect. The process group of p->pid is always p->pid, since it was created as a process group leader. */ - pgid = XINT (p->pid); + pgid = XFIXNUM (p->pid); /* Finally send the signal. */ if (EMACS_KILLPG (pgid, signo) == -1) ＠＠ -1885,11 +1885,11 ＠＠ * Caution: service can either be a string or int. * Convert to a C string for later use by getaddrinfo. */ - if (INTP (service)) + if (FIXNUMP (service)) { - snprintf (portbuf, sizeof (portbuf), "%ld", (long) XINT (service)); + snprintf (portbuf, sizeof (portbuf), "%ld", (long) XFIXNUM (service)); portstring = portbuf; - port = htons ((unsigned short) XINT (service)); + port = htons ((unsigned short) XFIXNUM (service)); } else { ＠＠ -1925,8 +1925,8 ＠＠ struct sockaddr_in address; volatile int i; - if (INTP (service)) - port = htons ((unsigned short) XINT (service)); + if (FIXNUMP (service)) + port = htons ((unsigned short) XFIXNUM (service)); else { struct servent *svc_info; ＠＠ -2119,10 +2119,10 ＠＠ CHECK_STRING (dest); check_integer_range (port, Qzero, make_integer (USHRT_MAX)); - theport = htons ((unsigned short) XINT (port)); + theport = htons ((unsigned short) XFIXNUM (port)); check_integer_range (ttl, Qzero, make_integer (UCHAR_MAX)); - thettl = (unsigned char) XINT (ttl); + thettl = (unsigned char) XFIXNUM (ttl); if ((udp = getprotobyname ("udp")) == NULL) invalid_operation ("No info available for UDP protocol", Qunbound); diff -r a0e81357194e -r 56144c8593a8 src/process.c --- a/src/process.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/process.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -630,7 +630,7 ＠＠ pid = PROCMETH (create_process, (p, argv, nargv, program, cur_dir, separate_err)); - p->pid = make_int (pid); + p->pid = make_fixnum (pid); if (PROCESS_READABLE_P (p)) event_stream_select_process (p, 1, 1); } ＠＠ -797,10 +797,10 ＠＠ /* Make the process marker point into the process buffer (if any). */ if (!NILP (buffer)) Fset_marker (XPROCESS (process)->mark, - make_int (BUF_ZV (XBUFFER (buffer))), buffer); + make_fixnum (BUF_ZV (XBUFFER (buffer))), buffer); if (!NILP (stderr_buffer)) Fset_marker (XPROCESS (process)->stderr_mark, - make_int (BUF_ZV (XBUFFER (stderr_buffer))), stderr_buffer); + make_fixnum (BUF_ZV (XBUFFER (stderr_buffer))), stderr_buffer); /* If an error occurs and we can't start the process, we want to remove it from the process list. This means that each error ＠＠ -975,11 +975,11 ＠＠ (process, height, width)) { CHECK_PROCESS (process); - check_integer_range (height, Qzero, make_integer (EMACS_INT_MAX)); - check_integer_range (width, Qzero, make_integer (EMACS_INT_MAX)); + check_integer_range (height, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); + check_integer_range (width, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); return MAYBE_INT_PROCMETH (set_window_size, - (XPROCESS (process), XINT (height), XINT (width))) <= 0 + (XPROCESS (process), XFIXNUM (height), XFIXNUM (width))) <= 0 ? Qnil : Qt; } ＠＠ -1081,8 +1081,8 ＠＠ asynchronously (i.e. from within QUIT). */ /* Don't catch errors here; we're not in any critical code. */ filter_result = call2 (filter, process, Qnil); - CHECK_INT (filter_result); - return XINT (filter_result); + CHECK_FIXNUM (filter_result); + return XFIXNUM (filter_result); } nbytes = Lstream_read (read_stderr ? XLSTREAM (DATA_ERRSTREAM (p)) : ＠＠ -1130,7 +1130,7 ＠＠ buffer_insert_raw_string (buf, chars, nbytes); #endif - Fset_marker (mark, make_int (BUF_PT (buf)), buffer); + Fset_marker (mark, make_fixnum (BUF_PT (buf)), buffer); MARK_MODELINE_CHANGED; unbind_to (spec); ＠＠ -1612,7 +1612,7 ＠＠ { if (code == 0) return build_msg_string ("finished\n"); - string = Fnumber_to_string (make_int (code)); + string = Fnumber_to_string (make_fixnum (code)); if (coredump) string2 = build_msg_string (" (core dumped)\n"); else ＠＠ -1680,7 +1680,7 ＠＠ /* #### extra check for terminated processes, in case a SIGCHLD got missed (this seems to happen sometimes, I'm not sure why). */ - if (INTP (p->pid)) + if (FIXNUMP (p->pid)) MAYBE_PROCMETH (update_status_if_terminated, (p)); this_process_tick = p->tick; ＠＠ -1729,7 +1729,7 ＠＠ Finsert (1, &p->name); buffer_insert_ascstring (current_buffer, " "); Finsert (1, &msg); - Fset_marker (p->mark, make_int (BUF_PT (current_buffer)), + Fset_marker (p->mark, make_fixnum (BUF_PT (current_buffer)), p->buffer); unbind_to (spec); ＠＠ -1792,7 +1792,7 ＠＠ (process)) { CHECK_PROCESS (process); - return make_int (XPROCESS (process)->exit_code); + return make_fixnum (XPROCESS (process)->exit_code); }  ＠＠ -1800,8 +1800,8 ＠＠ static int decode_signal (Lisp_Object signal_) { - if (INTP (signal_)) - return XINT (signal_); + if (FIXNUMP (signal_)) + return XFIXNUM (signal_); else { Ibyte *name; ＠＠ -2088,10 +2088,10 ＠＠ */ (pid, signal_)) { - CHECK_INT (pid); - - return make_int (PROCMETH_OR_GIVEN (kill_process_by_pid, - (XINT (pid), decode_signal (signal_)), + CHECK_FIXNUM (pid); + + return make_fixnum (PROCMETH_OR_GIVEN (kill_process_by_pid, + (XFIXNUM (pid), decode_signal (signal_)), -1)); } diff -r a0e81357194e -r 56144c8593a8 src/profile.c --- a/src/profile.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/profile.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -203,9 +203,9 ＠＠ profile_sow_backtrace (struct backtrace *bt) { bt->current_total_timing_val = - XINT (Fgethash (*bt->function, Vtotal_timing_profile_table, Qzero)); + XFIXNUM (Fgethash (*bt->function, Vtotal_timing_profile_table, Qzero)); bt->current_total_gc_usage_val = - XINT (Fgethash (*bt->function, Vtotal_gc_usage_profile_table, Qzero)); + XFIXNUM (Fgethash (*bt->function, Vtotal_gc_usage_profile_table, Qzero)); bt->function_being_called = 1; /* Need to think carefully about the exact order of operations here so that we don't end up with totals being less than function-only ＠＠ -255,11 +255,11 ＠＠ Fputhash (*bt->function, /* This works even when the total_ticks value has overwrapped. Same for total_consing below. */ - make_int ((EMACS_INT) (ticks - bt->total_ticks_at_start) + make_fixnum ((EMACS_INT) (ticks - bt->total_ticks_at_start) + bt->current_total_timing_val), Vtotal_timing_profile_table); Fputhash (*bt->function, - make_int ((EMACS_INT) + make_fixnum ((EMACS_INT) (total_consing - bt->total_consing_at_start) + bt->current_total_gc_usage_val), Vtotal_gc_usage_profile_table); ＠＠ -364,14 +364,14 ＠＠ else { #ifdef HAVE_BIGNUM - check_integer_range (microsecs, make_int (1000), make_integer (INT_MAX)); + check_integer_range (microsecs, make_fixnum (1000), make_integer (INT_MAX)); msecs = BIGNUMP (microsecs) ? bignum_to_int (XBIGNUM_DATA (microsecs)) : - XINT (microsecs); + XFIXNUM (microsecs); #else - check_integer_range (microsecs, make_int (1000), - make_integer (EMACS_INT_MAX)); - msecs = XINT (microsecs); + check_integer_range (microsecs, make_fixnum (1000), + make_integer (MOST_POSITIVE_FIXNUM)); + msecs = XFIXNUM (microsecs); #endif } if (msecs <= 0) ＠＠ -473,7 +473,7 ＠＠ key = GET_LISP_FROM_VOID (void_key); val = (EMACS_INT) void_val; - Fputhash (key, make_int (val), closure->timing); + Fputhash (key, make_fixnum (val), closure->timing); return 0; } ＠＠ -534,7 +534,7 ＠＠ if (!gethash (STORE_LISP_IN_VOID (QSprofile_overhead), big_profile_table, &overhead)) overhead = 0; - Fputhash (QSprofile_overhead, make_int ((EMACS_INT) overhead), + Fputhash (QSprofile_overhead, make_fixnum ((EMACS_INT) overhead), Vtotal_timing_profile_table); unbind_to (count); ＠＠ -560,12 +560,12 ＠＠ void *UNUSED (void_closure)) { /* This function does not GC */ - if (!INTP (val)) + if (!FIXNUMP (val)) invalid_argument_2 ("Function timing count is not an integer in given entry", key, val); - puthash (STORE_LISP_IN_VOID (key), (void *) XINT (val), big_profile_table); + puthash (STORE_LISP_IN_VOID (key), (void *) XFIXNUM (val), big_profile_table); return 0; } diff -r a0e81357194e -r 56144c8593a8 src/ralloc.c --- a/src/ralloc.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/ralloc.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1599,7 +1599,7 ＠＠ #define N_Meterables 12 /* Total number of meterables */ #define MEMMETER(x) {x;} #define MVAL(x) (meter[x]) -#define MLVAL(x) (make_int (meter[x])) +#define MLVAL(x) (make_fixnum (meter[x])) static int meter[N_Meterables]; DEFUN ("mmap-allocator-status", Fmmap_allocator_status, 0, 0, 0, /* diff -r a0e81357194e -r 56144c8593a8 src/rangetab.c --- a/src/rangetab.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/rangetab.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -474,9 +474,9 ＠＠ CHECK_RANGE_TABLE (range_table); rt = XRANGE_TABLE (range_table); - CHECK_INT_COERCE_CHAR (pos); + CHECK_FIXNUM_COERCE_CHAR (pos); - return get_range_table (XINT (pos), gap_array_length (rt->entries), + return get_range_table (XFIXNUM (pos), gap_array_length (rt->entries), gap_array_begin (rt->entries, struct range_table_entry), gap_array_gappos (rt->entries), ＠＠ -712,10 +712,10 ＠＠ EMACS_INT first, last; CHECK_RANGE_TABLE (range_table); - CHECK_INT_COERCE_CHAR (start); - first = XINT (start); - CHECK_INT_COERCE_CHAR (end); - last = XINT (end); + CHECK_FIXNUM_COERCE_CHAR (start); + first = XFIXNUM (start); + CHECK_FIXNUM_COERCE_CHAR (end); + last = XFIXNUM (end); if (first > last) invalid_argument_2 ("start must be <= end", start, end); ＠＠ -782,8 +782,8 ＠＠ { EMACS_INT premier = first, dernier = last; internal_to_external_adjust_ends (rt->type, &premier, &dernier); - args[1] = make_int (premier); - args[2] = make_int (dernier); + args[1] = make_fixnum (premier); + args[2] = make_fixnum (dernier); } args[3] = entry.val; Ffuncall (countof (args), args); ＠＠ -818,11 +818,11 ＠＠ /* #### should deal with ERRB */ EXTERNAL_PROPERTY_LIST_LOOP_3 (range, data, value) { - if (!INTP (range) && !CHARP (range) + if (!FIXNUMP (range) && !CHARP (range) && !(CONSP (range) && CONSP (XCDR (range)) && NILP (XCDR (XCDR (range))) - && (INTP (XCAR (range)) || CHARP (XCAR (range))) - && (INTP (XCAR (XCDR (range))) || CHARP (XCAR (XCDR (range)))))) + && (FIXNUMP (XCAR (range)) || CHARP (XCAR (range))) + && (FIXNUMP (XCAR (XCDR (range))) || CHARP (XCAR (XCDR (range)))))) sferror ("Invalid range format", range); } diff -r a0e81357194e -r 56144c8593a8 src/redisplay-msw.c --- a/src/redisplay-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/redisplay-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1159,10 +1159,10 ＠＠ struct frame *f = XFRAME (w->frame); HDC hdc = get_frame_dc (f, 1); RECT rect; - int spacing = XINT (w->vertical_divider_spacing); - int shadow = XINT (w->vertical_divider_shadow_thickness); + int spacing = XFIXNUM (w->vertical_divider_spacing); + int shadow = XFIXNUM (w->vertical_divider_shadow_thickness); int abs_shadow = abs (shadow); - int line_width = XINT (w->vertical_divider_line_width); + int line_width = XFIXNUM (w->vertical_divider_line_width); int div_left = WINDOW_RIGHT (w) - window_divider_width (w); int y1 = WINDOW_TOP (w); int y2 = WINDOW_BOTTOM (w); diff -r a0e81357194e -r 56144c8593a8 src/redisplay-output.c --- a/src/redisplay-output.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/redisplay-output.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -988,7 +988,7 ＠＠ { w->last_point_x[CURRENT_DISP] = x; w->last_point_y[CURRENT_DISP] = y; - Fset_marker (w->last_point[CURRENT_DISP], make_int (ADJ_CHARPOS), + Fset_marker (w->last_point[CURRENT_DISP], make_fixnum (ADJ_CHARPOS), w->buffer); dl->cursor_elt = x; return 1; ＠＠ -1099,7 +1099,7 ＠＠ w->last_point_x[CURRENT_DISP] = cur_rb; w->last_point_y[CURRENT_DISP] = cur_dl; Fset_marker (w->last_point[CURRENT_DISP], - make_int (ADJ_CHARPOS), w->buffer); + make_fixnum (ADJ_CHARPOS), w->buffer); if (!no_output_end) { ＠＠ -1474,13 +1474,13 ＠＠ style = EDGE_ETCHED_OUT; else if (EQ (IMAGE_INSTANCE_LAYOUT_BORDER (p), Qbevel_in)) style = EDGE_BEVEL_IN; - else if (INTP (IMAGE_INSTANCE_LAYOUT_BORDER (p))) + else if (FIXNUMP (IMAGE_INSTANCE_LAYOUT_BORDER (p))) { style = EDGE_ETCHED_IN; if (edges & EDGE_TOP) { - ypos += XINT (IMAGE_INSTANCE_LAYOUT_BORDER (p)); - height -= XINT (IMAGE_INSTANCE_LAYOUT_BORDER (p)); + ypos += XFIXNUM (IMAGE_INSTANCE_LAYOUT_BORDER (p)); + height -= XFIXNUM (IMAGE_INSTANCE_LAYOUT_BORDER (p)); } } else ＠＠ -2498,10 +2498,10 ＠＠ w->window_end_pos[CURRENT_DISP] = w->window_end_pos[DESIRED_DISP]; Fset_marker (w->start[CURRENT_DISP], - make_int (marker_position (w->start[DESIRED_DISP])), + make_fixnum (marker_position (w->start[DESIRED_DISP])), w->buffer); Fset_marker (w->pointm[CURRENT_DISP], - make_int (marker_position (w->pointm[DESIRED_DISP])), + make_fixnum (marker_position (w->pointm[DESIRED_DISP])), w->buffer); w->last_modified[CURRENT_DISP] = w->last_modified[DESIRED_DISP]; w->last_facechange[CURRENT_DISP] = w->last_facechange[DESIRED_DISP]; ＠＠ -2641,10 +2641,10 ＠＠ { assert (!in_display); redisplay_redraw_exposed_area (XFRAME (X1ST (arg)), - XINT (X2ND (arg)), - XINT (X3RD (arg)), - XINT (X4TH (arg)), - XINT (X5TH (arg))); + XFIXNUM (X2ND (arg)), + XFIXNUM (X3RD (arg)), + XFIXNUM (X4TH (arg)), + XFIXNUM (X5TH (arg))); free_list (arg); } ＠＠ -2664,9 +2664,9 ＠＠ { /* Not safe to do it now, so delay it */ register_post_redisplay_action (redisplay_redraw_exposed_area_1, - list5 (wrap_frame (f), make_int (x), - make_int (y), make_int (width), - make_int (height))); + list5 (wrap_frame (f), make_fixnum (x), + make_fixnum (y), make_fixnum (width), + make_fixnum (height))); return; } ＠＠ -2718,7 +2718,7 ＠＠ y = dl->ypos - dl->ascent - shadow_thickness; height = dl->ascent + dl->descent + 2 * shadow_thickness; - if (XINT (w->modeline_shadow_thickness) < 0) + if (XFIXNUM (w->modeline_shadow_thickness) < 0) { style = EDGE_BEVEL_IN; } diff -r a0e81357194e -r 56144c8593a8 src/redisplay-xlike-inc.c --- a/src/redisplay-xlike-inc.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/redisplay-xlike-inc.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -857,7 +857,7 ＠＠ } /* evil kludge! */ - if (!NILP (fg) && !COLOR_INSTANCEP (fg) && !INTP (fg)) + if (!NILP (fg) && !COLOR_INSTANCEP (fg) && !FIXNUMP (fg)) { /* #### I fixed one case where this was getting hit. It was a bad macro expansion (compiler bug). */ ＠＠ -871,7 +871,7 ＠＠ if (COLOR_INSTANCEP (fg)) XLIKE_SET_GC_COLOR (gcv.foreground, XCOLOR_INSTANCE_XLIKE_COLOR (fg)); else - XLIKE_SET_GC_PIXEL (gcv.foreground, XINT (fg)); + XLIKE_SET_GC_PIXEL (gcv.foreground, XFIXNUM (fg)); mask |= XLIKE_GC_FOREGROUND; } ＠＠ -880,7 +880,7 ＠＠ if (COLOR_INSTANCEP (bg)) XLIKE_SET_GC_COLOR (gcv.background, XCOLOR_INSTANCE_XLIKE_COLOR (bg)); else - XLIKE_SET_GC_PIXEL (gcv.background, XINT (bg)); + XLIKE_SET_GC_PIXEL (gcv.background, XFIXNUM (bg)); mask |= XLIKE_GC_BACKGROUND; } ＠＠ -927,7 +927,7 ＠＠ if (!NILP (lwidth)) { - gcv.line_width = XINT (lwidth); + gcv.line_width = XFIXNUM (lwidth); mask |= XLIKE_GC_LINE_WIDTH; } ＠＠ -1554,7 +1554,7 ＠＠ { gc = XLIKE_get_gc (f, Qnil, cursor_cachel->background, Qnil, Qnil, Qnil, - make_int (bar_width)); + make_fixnum (bar_width)); } else { ＠＠ -1787,9 +1787,9 ＠＠ get_builtin_face_cache_index (w, Vvertical_divider_face); width = window_divider_width (w); - shadow_thickness = XINT (w->vertical_divider_shadow_thickness); - spacing = XINT (w->vertical_divider_spacing); - line_width = XINT (w->vertical_divider_line_width); + shadow_thickness = XFIXNUM (w->vertical_divider_shadow_thickness); + spacing = XFIXNUM (w->vertical_divider_spacing); + line_width = XFIXNUM (w->vertical_divider_line_width); x = WINDOW_RIGHT (w) - width; ytop = WINDOW_TOP (w); ybottom = WINDOW_BOTTOM (w); ＠＠ -1940,7 +1940,7 ＠＠ gc = XLIKE_get_gc (f, Qnil, cursor_cachel->background, Qnil, Qnil, Qnil, - make_int (bar_width)); + make_fixnum (bar_width)); XLIKE_DRAW_LINE (dpy, x_win, gc, cursor_start + bar_width - 1, cursor_y, cursor_start + bar_width - 1, cursor_y + cursor_height - 1); ＠＠ -2108,7 +2108,7 ＠＠ gc = XLIKE_get_gc (f, Qnil, cursor_cachel->background, Qnil, Qnil, Qnil, - make_int (bar_width)); + make_fixnum (bar_width)); XLIKE_DRAW_LINE (dpy, x_win, gc, x + bar_width - 1, cursor_y, x + bar_width - 1, cursor_y + cursor_height - 1); } diff -r a0e81357194e -r 56144c8593a8 src/redisplay.c --- a/src/redisplay.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/redisplay.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -757,7 +757,7 ＠＠ tab_char_width (struct window *w) { struct buffer *b = XBUFFER (w->buffer); - int char_tab_width = XINT (b->tab_width); + int char_tab_width = XFIXNUM (b->tab_width); if (char_tab_width <= 0 || char_tab_width > 1000) char_tab_width = 8; ＠＠ -1954,12 +1954,12 ＠＠ /* A pixmap with an explicitly set baseline. We determine the contribution here. */ - else if (INTP (baseline)) + else if (FIXNUMP (baseline)) { int height = ascent + descent; int pix_ascent, pix_descent; - pix_ascent = height * XINT (baseline) / 100; + pix_ascent = height * XFIXNUM (baseline) / 100; pix_descent = height - pix_ascent; data->new_ascent = max (data->new_ascent, pix_ascent); ＠＠ -2147,8 +2147,8 ＠＠ only lines that start with less than selective_display columns of space will be displayed. If selective_display is t then all text after a ^M is invisible. */ - int selective = (INTP (b->selective_display) - ? XINT (b->selective_display) + int selective = (FIXNUMP (b->selective_display) + ? XFIXNUM (b->selective_display) : (!NILP (b->selective_display) ? -1 : 0)); /* The variable ctl-arrow allows the user to specify what characters ＠＠ -2933,13 +2933,13 ＠＠ dl->descent = data.new_descent; { - unsigned short ascent = (unsigned short) XINT (w->minimum_line_ascent); + unsigned short ascent = (unsigned short) XFIXNUM (w->minimum_line_ascent); if (dl->ascent < ascent) dl->ascent = ascent; } { - unsigned short descent = (unsigned short) XINT (w->minimum_line_descent); + unsigned short descent = (unsigned short) XFIXNUM (w->minimum_line_descent); if (dl->descent < descent) dl->descent = descent; ＠＠ -4348,9 +4348,9 ＠＠ goto tail_recurse; } } - else if (INTP (car)) - { - Charcount lim = XINT (car); + else if (FIXNUMP (car)) + { + Charcount lim = XFIXNUM (car); elt = XCDR (elt); ＠＠ -5180,13 +5180,13 ＠＠ dl->descent = data.new_descent; { - unsigned short ascent = (unsigned short) XINT (w->minimum_line_ascent); + unsigned short ascent = (unsigned short) XFIXNUM (w->minimum_line_ascent); if (dl->ascent < ascent) dl->ascent = ascent; } { - unsigned short descent = (unsigned short) XINT (w->minimum_line_descent); + unsigned short descent = (unsigned short) XFIXNUM (w->minimum_line_descent); if (dl->descent < descent) dl->descent = descent; ＠＠ -5206,7 +5206,7 ＠＠ if (truncate_win) data.dl->num_chars = string_column_at_point (disp_string, dl->end_charpos, - b ? XINT (b->tab_width) : 8); + b ? XFIXNUM (b->tab_width) : 8); else /* This doesn't correctly take into account tabs and control characters but if the window isn't being truncated then this ＠＠ -5493,8 +5493,8 ＠＠ reset_glyph_cachels (w); #endif - Fset_marker (w->start[type], make_int (start_pos), w->buffer); - Fset_marker (w->pointm[type], make_int (point), w->buffer); + Fset_marker (w->start[type], make_fixnum (start_pos), w->buffer); + Fset_marker (w->pointm[type], make_fixnum (point), w->buffer); w->last_point_x[type] = -1; w->last_point_y[type] = -1; ＠＠ -5736,7 +5736,7 ＠＠ under which this can happen, but I believe that it is probably a reasonable happening. */ if (!point_visible (w, pointm, CURRENT_DISP) - || XINT (w->last_modified[CURRENT_DISP]) < BUF_MODIFF (b)) + || XFIXNUM (w->last_modified[CURRENT_DISP]) < BUF_MODIFF (b)) return 0; /* If the cursor is moved we attempt to update it. If we succeed we ＠＠ -5817,10 +5817,10 ＠＠ structs which could lead to an assertion failure. However, if we fail the next thing that is going to happen is a full regen so we will actually end up being safe. */ - w->last_modified[DESIRED_DISP] = make_int (BUF_MODIFF (b)); - w->last_facechange[DESIRED_DISP] = make_int (BUF_FACECHANGE (b)); - Fset_marker (w->last_start[DESIRED_DISP], make_int (startp), w->buffer); - Fset_marker (w->last_point[DESIRED_DISP], make_int (pointm), w->buffer); + w->last_modified[DESIRED_DISP] = make_fixnum (BUF_MODIFF (b)); + w->last_facechange[DESIRED_DISP] = make_fixnum (BUF_FACECHANGE (b)); + Fset_marker (w->last_start[DESIRED_DISP], make_fixnum (startp), w->buffer); + Fset_marker (w->last_point[DESIRED_DISP], make_fixnum (pointm), w->buffer); first_line = last_line = line; while (line <= dla_end) ＠＠ -6029,11 +6029,11 ＠＠ business. Update everything and return success. */ if (end_unchanged >= ddl->charpos && end_unchanged <= ddl->end_charpos) { - w->last_modified[DESIRED_DISP] = make_int (BUF_MODIFF (b)); - w->last_facechange[DESIRED_DISP] = make_int (BUF_FACECHANGE (b)); - Fset_marker (w->last_start[DESIRED_DISP], make_int (startp), + w->last_modified[DESIRED_DISP] = make_fixnum (BUF_MODIFF (b)); + w->last_facechange[DESIRED_DISP] = make_fixnum (BUF_FACECHANGE (b)); + Fset_marker (w->last_start[DESIRED_DISP], make_fixnum (startp), w->buffer); - Fset_marker (w->last_point[DESIRED_DISP], make_int (pointm), + Fset_marker (w->last_point[DESIRED_DISP], make_fixnum (pointm), w->buffer); if (ddl->cursor_elt != -1) ＠＠ -6101,7 +6101,7 ＠＠ startp = start_with_line_at_pixpos (w, point, window_half_pixpos (w)); regenerate_window (w, startp, point, type); - Fset_marker (w->start[type], make_int (startp), w->buffer); + Fset_marker (w->start[type], make_fixnum (startp), w->buffer); return startp; } ＠＠ -6300,7 +6300,7 ＠＠ pointm = BUF_ZV (b); } } - Fset_marker (w->pointm[DESIRED_DISP], make_int (pointm), the_buffer); + Fset_marker (w->pointm[DESIRED_DISP], make_fixnum (pointm), the_buffer); /* Added 2-1-10 -- we should never have empty face or glyph cachels because we initialized them at startup and the only way to reduce ＠＠ -6360,7 +6360,7 ＠＠ else if (startp > BUF_ZV (b)) startp = BUF_ZV (b); } - Fset_marker (w->start[DESIRED_DISP], make_int (startp), the_buffer); + Fset_marker (w->start[DESIRED_DISP], make_fixnum (startp), the_buffer); truncation_changed = (find_window_mirror (w)->truncate_win != (unsigned int) window_truncation_on (w)); ＠＠ -6383,7 +6383,7 ＠＠ if (selected_globally) BUF_SET_PT (b, pointm); - Fset_marker (w->pointm[DESIRED_DISP], make_int (pointm), + Fset_marker (w->pointm[DESIRED_DISP], make_fixnum (pointm), the_buffer); /* #### BUFU amounts of overkill just to get the cursor ＠＠ -6396,8 +6396,8 ＠＠ /* If nothing has changed since the last redisplay, then we just need to make sure that point is still visible. */ - if (XINT (w->last_modified[CURRENT_DISP]) >= BUF_MODIFF (b) - && XINT (w->last_facechange[CURRENT_DISP]) >= BUF_FACECHANGE (b) + if (XFIXNUM (w->last_modified[CURRENT_DISP]) >= BUF_MODIFF (b) + && XFIXNUM (w->last_facechange[CURRENT_DISP]) >= BUF_FACECHANGE (b) && pointm >= startp /* This check is to make sure we restore the minibuffer after a temporary change to the echo area. */ ＠＠ -6507,8 +6507,8 ＠＠ && regenerate_window_incrementally (w, startp, pointm)) { if (f->modeline_changed - || XINT (w->last_modified[CURRENT_DISP]) < BUF_MODIFF (b) - || XINT (w->last_facechange[CURRENT_DISP]) < BUF_FACECHANGE (b)) + || XFIXNUM (w->last_modified[CURRENT_DISP]) < BUF_MODIFF (b) + || XFIXNUM (w->last_facechange[CURRENT_DISP]) < BUF_FACECHANGE (b)) regenerate_modeline (w); skip_output = 1; ＠＠ -6562,16 +6562,16 ＠＠ if (echo_active) { w->buffer = old_buffer; - Fset_marker (w->pointm[DESIRED_DISP], make_int (old_pointm), old_buffer); - Fset_marker (w->start[DESIRED_DISP], make_int (old_startp), old_buffer); + Fset_marker (w->pointm[DESIRED_DISP], make_fixnum (old_pointm), old_buffer); + Fset_marker (w->start[DESIRED_DISP], make_fixnum (old_startp), old_buffer); } /* These also have to be set before calling redisplay_output_window since it sets the CURRENT_DISP values based on them. */ - w->last_modified[DESIRED_DISP] = make_int (BUF_MODIFF (b)); - w->last_facechange[DESIRED_DISP] = make_int (BUF_FACECHANGE (b)); - Fset_marker (w->last_start[DESIRED_DISP], make_int (startp), w->buffer); - Fset_marker (w->last_point[DESIRED_DISP], make_int (pointm), w->buffer); + w->last_modified[DESIRED_DISP] = make_fixnum (BUF_MODIFF (b)); + w->last_facechange[DESIRED_DISP] = make_fixnum (BUF_FACECHANGE (b)); + Fset_marker (w->last_start[DESIRED_DISP], make_fixnum (startp), w->buffer); + Fset_marker (w->last_point[DESIRED_DISP], make_fixnum (pointm), w->buffer); if (!skip_output) { ＠＠ -6589,7 +6589,7 ＠＠ * with the window now. */ if (echo_active) - w->line_cache_last_updated = make_int (-1); + w->line_cache_last_updated = make_fixnum (-1); } /* #### This should be dependent on face changes and will need to be ＠＠ -7755,7 +7755,7 ＠＠ does redisplay will catch it pretty quickly we no longer invalidate the cache if it is set. This greatly speeds up dragging out regions with the mouse. */ - if (XINT (w->line_cache_last_updated) < BUF_MODIFF (b) + if (XFIXNUM (w->line_cache_last_updated) < BUF_MODIFF (b) || f->faces_changed || f->clip_changed) { ＠＠ -8413,7 +8413,7 ＠＠ low_bound = high_bound = -1; } - w->line_cache_last_updated = make_int (BUF_MODIFF (b)); + w->line_cache_last_updated = make_fixnum (BUF_MODIFF (b)); /* This could be integrated into the next two sections, but it is easier to follow what's going on by having it separate. */ diff -r a0e81357194e -r 56144c8593a8 src/scrollbar-gtk.c --- a/src/scrollbar-gtk.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/scrollbar-gtk.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -442,7 +442,7 ＠＠ case GTK_SCROLL_JUMP: inhibit_slider_size_change = 1; event_type = vertical ? Qscrollbar_vertical_drag : Qscrollbar_horizontal_drag; - event_data = Fcons (win, make_int ((int)adj->value)); + event_data = Fcons (win, make_fixnum ((int)adj->value)); break; default: ABORT(); diff -r a0e81357194e -r 56144c8593a8 src/scrollbar-msw.c --- a/src/scrollbar-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/scrollbar-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -307,7 +307,7 ＠＠ mswindows_enqueue_misc_user_event (frame, vert ? Qscrollbar_vertical_drag : Qscrollbar_horizontal_drag, - Fcons (win, make_int (value))); + Fcons (win, make_fixnum (value))); break; case SB_ENDSCROLL: ＠＠ -447,10 +447,10 ＠＠ if (DEVICEP (locale)) { add_spec_to_ghost_specifier (Vscrollbar_width, - make_int (GetSystemMetrics (SM_CXVSCROLL)), + make_fixnum (GetSystemMetrics (SM_CXVSCROLL)), locale, Qmswindows, Qnil); add_spec_to_ghost_specifier (Vscrollbar_height, - make_int (GetSystemMetrics (SM_CYHSCROLL)), + make_fixnum (GetSystemMetrics (SM_CYHSCROLL)), locale, Qmswindows, Qnil); } return Qnil; diff -r a0e81357194e -r 56144c8593a8 src/scrollbar-x.c --- a/src/scrollbar-x.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/scrollbar-x.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -453,7 +453,7 ＠＠ if (line > -1.0) line = -1.0; signal_special_Xt_user_event (frame, Qscrollbar_page_up, - Fcons (win, make_int ((int) line))); + Fcons (win, make_fixnum ((int) line))); } #else signal_special_Xt_user_event (frame, Qscrollbar_page_up, ＠＠ -477,7 +477,7 ＠＠ line = 1.0; signal_special_Xt_user_event (frame, Qscrollbar_page_down, Fcons (win, - make_int ((int) line))); + make_fixnum ((int) line))); } } #else ＠＠ -501,7 +501,7 ＠＠ vertical_drag_in_progress = 0; SCROLLBAR_X_VDRAG_ORIG_VALUE (instance) = data->slider_value; SCROLLBAR_X_VDRAG_ORIG_WINDOW_START (instance) = - XINT (Fwindow_start (win)); + XFIXNUM (Fwindow_start (win)); #else stupid_vertical_scrollbar_drag_hack = 0; #endif ＠＠ -527,7 +527,7 ＠＠ { SCROLLBAR_X_VDRAG_ORIG_VALUE (instance) = data->slider_value; SCROLLBAR_X_VDRAG_ORIG_WINDOW_START (instance) = - XINT (Fwindow_start (win)); + XFIXNUM (Fwindow_start (win)); } /* Could replace this piecewise linear scrolling with a ＠＠ -594,7 +594,7 ＠＠ value = SCROLLBAR_X_POS_DATA (instance).minimum; signal_special_Xt_user_event (frame, Qscrollbar_vertical_drag, - Fcons (win, make_int (value))); + Fcons (win, make_fixnum (value))); } break; ＠＠ -663,12 +663,12 ＠＠ #if defined (LWLIB_SCROLLBARS_LUCID) || defined (LWLIB_SCROLLBARS_ATHENA3D) signal_special_Xt_user_event (frame, Qscrollbar_horizontal_drag, (Fcons - (win, make_int (data->slider_value)))); + (win, make_fixnum (data->slider_value)))); #else signal_special_Xt_user_event (frame, Qscrollbar_horizontal_drag, (Fcons (win, - make_int (data->slider_value - 1)))); + make_fixnum (data->slider_value - 1)))); #endif break; default: diff -r a0e81357194e -r 56144c8593a8 src/scrollbar.c --- a/src/scrollbar.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/scrollbar.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -693,8 +693,8 ＠＠ accurate. We know this because either set-window-start or recenter was called immediately prior to it being called. */ Lisp_Object buf; - Charbpos start_pos = XINT (Fwindow_start (win)); - Charbpos ptint = XINT (orig_pt); + Charbpos start_pos = XFIXNUM (Fwindow_start (win)); + Charbpos ptint = XFIXNUM (orig_pt); struct window *w = XWINDOW (win); int selected = ((w == XWINDOW (Fselected_window (XFRAME (w->frame)->device))) ? 1 ＠＠ -704,16 +704,16 ＠＠ if (NILP (buf)) return; /* the window was deleted out from under us */ - if (ptint < XINT (Fwindow_start (win))) + if (ptint < XFIXNUM (Fwindow_start (win))) { if (selected) - Fgoto_char (make_int (start_pos), buf); + Fgoto_char (make_fixnum (start_pos), buf); else - Fset_window_point (win, make_int (start_pos)); + Fset_window_point (win, make_fixnum (start_pos)); } else if (!point_would_be_visible (XWINDOW (win), start_pos, ptint, 0)) { - Fmove_to_window_line (make_int (-1), win); + Fmove_to_window_line (make_fixnum (-1), win); if (selected) Fbeginning_of_line (Qnil, buf); ＠＠ -725,7 +725,7 ＠＠ pos = find_next_newline (XBUFFER (buf), marker_position (w->pointm[CURRENT_DISP]), -1); - Fset_window_point (win, make_int (pos)); + Fset_window_point (win, make_fixnum (pos)); } } else ＠＠ -746,7 +746,7 ＠＠ (window)) { CHECK_LIVE_WINDOW (window); - window_scroll (window, make_int (1), -1, ERROR_ME_NOT); + window_scroll (window, make_fixnum (1), -1, ERROR_ME_NOT); zmacs_region_stays = 1; return Qnil; } ＠＠ -760,7 +760,7 ＠＠ (window)) { CHECK_LIVE_WINDOW (window); - window_scroll (window, make_int (1), 1, ERROR_ME_NOT); + window_scroll (window, make_fixnum (1), 1, ERROR_ME_NOT); zmacs_region_stays = 1; return Qnil; } ＠＠ -790,15 +790,15 ＠＠ Charbpos charbpos; Lisp_Object value = Fcdr (object); - CHECK_INT (value); + CHECK_FIXNUM (value); Fmove_to_window_line (Qzero, window); /* can't use Fvertical_motion() because it moves the buffer point rather than the window's point. #### It does? Why does it take a window argument then? */ - charbpos = vmotion (XWINDOW (window), XINT (Fwindow_point (window)), - XINT (value), 0); - Fset_window_point (window, make_int (charbpos)); + charbpos = vmotion (XWINDOW (window), XFIXNUM (Fwindow_point (window)), + XFIXNUM (value), 0); + Fset_window_point (window, make_fixnum (charbpos)); Fcenter_to_window_line (Qzero, window); } ＠＠ -829,7 +829,7 ＠＠ else { Lisp_Object value = Fcdr (object); - CHECK_INT (value); + CHECK_FIXNUM (value); Fmove_to_window_line (value, window); Fcenter_to_window_line (Qzero, window); } ＠＠ -866,7 +866,7 ＠＠ { Lisp_Object orig_pt = Fwindow_point (window); Fset_window_point (window, Fpoint_max (Fwindow_buffer (window))); - Fcenter_to_window_line (make_int (-3), window); + Fcenter_to_window_line (make_fixnum (-3), window); scrollbar_reset_cursor (window, orig_pt); zmacs_region_stays = 1; return Qnil; ＠＠ -888,7 +888,7 ＠＠ orig_pt = Fwindow_point (window); Fset_marker (XWINDOW (window)->sb_point, value, Fwindow_buffer (window)); start_pos = scrollbar_point (XWINDOW (window), 1); - Fset_window_start (window, make_int (start_pos), Qnil); + Fset_window_start (window, make_fixnum (start_pos), Qnil); scrollbar_reset_cursor (window, orig_pt); Fsit_for(Qzero, Qnil); zmacs_region_stays = 1; ＠＠ -906,7 +906,7 ＠＠ CHECK_LIVE_WINDOW (window); if (!EQ (value, Qmax)) - CHECK_INT (value); + CHECK_FIXNUM (value); w = XWINDOW (window); wcw = window_char_width (w, 0) - 1; ＠＠ -914,10 +914,10 ＠＠ a visible truncation glyph. This calculation for max is bogus. */ max_len = w->max_line_len + 2; - if (EQ (value, Qmax) || (XINT (value) > (max_len - wcw))) + if (EQ (value, Qmax) || (XFIXNUM (value) > (max_len - wcw))) hscroll = max_len - wcw; else - hscroll = XINT (value); + hscroll = XFIXNUM (value); /* Can't allow this out of set-window-hscroll's acceptable range. */ /* #### What hell on the earth this code limits scroll size to the ＠＠ -928,7 +928,7 ＠＠ hscroll = (1 << (SHORTBITS - 1)) - 1; if (hscroll != w->hscroll) - Fset_window_hscroll (window, make_int (hscroll)); + Fset_window_hscroll (window, make_fixnum (hscroll)); return Qnil; } ＠＠ -1011,10 +1011,10 ＠＠ set_specifier_fallback (Vscrollbar_width, #ifdef HAVE_TTY - list2 (Fcons (list1 (Qtty), make_int (0)), - Fcons (Qnil, make_int (DEFAULT_SCROLLBAR_WIDTH))) + list2 (Fcons (list1 (Qtty), make_fixnum (0)), + Fcons (Qnil, make_fixnum (DEFAULT_SCROLLBAR_WIDTH))) #else - list1 (Fcons (Qnil, make_int (DEFAULT_SCROLLBAR_WIDTH))) + list1 (Fcons (Qnil, make_fixnum (DEFAULT_SCROLLBAR_WIDTH))) #endif ); set_specifier_caching (Vscrollbar_width, ＠＠ -1031,10 +1031,10 ＠＠ set_specifier_fallback (Vscrollbar_height, #ifdef HAVE_TTY - list2 (Fcons (list1 (Qtty), make_int (0)), - Fcons (Qnil, make_int (DEFAULT_SCROLLBAR_HEIGHT))) + list2 (Fcons (list1 (Qtty), make_fixnum (0)), + Fcons (Qnil, make_fixnum (DEFAULT_SCROLLBAR_HEIGHT))) #else - list1 (Fcons (Qnil, make_int (DEFAULT_SCROLLBAR_HEIGHT))) + list1 (Fcons (Qnil, make_fixnum (DEFAULT_SCROLLBAR_HEIGHT))) #endif ); set_specifier_caching (Vscrollbar_height, diff -r a0e81357194e -r 56144c8593a8 src/search.c --- a/src/search.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/search.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -438,8 +438,8 ＠＠ { Charcount len = string_char_length (string); - CHECK_INT (start); - s = XINT (start); + CHECK_FIXNUM (start); + s = XFIXNUM (start); if (s < 0 && -s <= len) s = len + s; else if (0 > s || s > len) ＠＠ -476,7 +476,7 ＠＠ if (val < 0) return Qnil; last_thing_searched = Qt; fixup_search_regs_for_string (string); - return make_int (string_index_byte_to_char (string, val)); + return make_fixnum (string_index_byte_to_char (string, val)); } DEFUN ("string-match", Fstring_match, 2, 4, 0, /* ＠＠ -895,8 +895,8 ＠＠ limit = forwardp ? BUF_ZV (buf) : BUF_BEGV (buf); else { - CHECK_INT_COERCE_MARKER (lim); - limit = XINT (lim); + CHECK_FIXNUM_COERCE_MARKER (lim); + limit = XFIXNUM (lim); /* In any case, don't allow scan outside bounds of buffer. */ if (limit > BUF_ZV (buf)) limit = BUF_ZV (buf); ＠＠ -953,7 +953,7 ＠＠ c++; } if (c <= cend) - Fput_range_table (make_int (c), make_int (cend), Qt, + Fput_range_table (make_fixnum (c), make_fixnum (cend), Qt, Vskip_chars_range_table); INC_IBYTEPTR (p); } ＠＠ -962,7 +962,7 ＠＠ if (c < 0400) fastmap[c] = 1; else - Fput_range_table (make_int (c), make_int (c), Qt, + Fput_range_table (make_fixnum (c), make_fixnum (c), Qt, Vskip_chars_range_table); } } ＠＠ -1033,7 +1033,7 ＠＠ { Ichar ch = BYTE_BUF_FETCH_CHAR (buf, pos_byte); if ((ch < 0400) ? fastmap[ch] : - (NILP (Fget_range_table (make_int (ch), + (NILP (Fget_range_table (make_fixnum (ch), Vskip_chars_range_table, Qnil)) == negate)) ＠＠ -1055,7 +1055,7 ＠＠ DEC_BYTEBPOS (buf, prev_pos_byte); ch = BYTE_BUF_FETCH_CHAR (buf, prev_pos_byte); if ((ch < 0400) ? fastmap[ch] : - (NILP (Fget_range_table (make_int (ch), + (NILP (Fget_range_table (make_fixnum (ch), Vskip_chars_range_table, Qnil)) == negate)) ＠＠ -1070,7 +1070,7 ＠＠ } QUIT; BOTH_BUF_SET_PT (buf, pos, pos_byte); - return make_int (BUF_PT (buf) - start_point); + return make_fixnum (BUF_PT (buf) - start_point); } } ＠＠ -1145,8 +1145,8 ＠＠ if (!NILP (count)) { - CHECK_INT (count); - n *= XINT (count); + CHECK_FIXNUM (count); + n *= XFIXNUM (count); } buf = decode_buffer (buffer, 0); ＠＠ -1155,8 +1155,8 ＠＠ lim = n > 0 ? BUF_ZV (buf) : BUF_BEGV (buf); else { - CHECK_INT_COERCE_MARKER (limit); - lim = XINT (limit); + CHECK_FIXNUM_COERCE_MARKER (limit); + lim = XFIXNUM (limit); if (n > 0 ? lim < BUF_PT (buf) : lim > BUF_PT (buf)) invalid_argument ("Invalid search limit (wrong side of point)", Qunbound); ＠＠ -1201,7 +1201,7 ＠＠ BUF_SET_PT (buf, np); - return make_int (np); + return make_fixnum (np); }  static int ＠＠ -2674,8 +2674,8 ＠＠ } else if (!NILP (strbuffer)) { - CHECK_INT (strbuffer); - sub = XINT (strbuffer); + CHECK_FIXNUM (strbuffer); + sub = XFIXNUM (strbuffer); if (sub < 0 || sub >= (int) search_regs.num_regs) invalid_argument ("match data register invalid", strbuffer); if (search_regs.start[sub] < 0) ＠＠ -2715,16 +2715,16 ＠＠ if (search_regs.start[sub] < BUF_BEGV (buf) || search_regs.start[sub] > search_regs.end[sub] || search_regs.end[sub] > BUF_ZV (buf)) - args_out_of_range (make_int (search_regs.start[sub]), - make_int (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[0] < 0 || search_regs.start[0] > search_regs.end[0] || search_regs.end[0] > string_char_length (string)) - args_out_of_range (make_int (search_regs.start[0]), - make_int (search_regs.end[0])); + args_out_of_range (make_fixnum (search_regs.start[0]), + make_fixnum (search_regs.end[0])); } if (NILP (fixedcase)) ＠＠ -2799,8 +2799,8 ＠＠ Lisp_Object before, after; speccount = specpdl_depth (); - before = Fsubseq (string, Qzero, make_int (search_regs.start[sub])); - after = Fsubseq (string, make_int (search_regs.end[sub]), Qnil); + before = Fsubseq (string, Qzero, make_fixnum (search_regs.start[sub])); + after = Fsubseq (string, make_fixnum (search_regs.end[sub]), Qnil); /* Do case substitution into REPLACEMENT if desired. */ if (NILP (literal)) ＠＠ -2887,11 +2887,11 ＠＠ Lisp_Object substring = Qnil; if (literal_end != literal_start) literal_text = Fsubseq (replacement, - make_int (literal_start), - make_int (literal_end)); + make_fixnum (literal_start), + make_fixnum (literal_end)); if (substart >= 0 && subend != substart) - substring = Fsubseq (string, make_int (substart), - make_int (subend)); + substring = Fsubseq (string, make_fixnum (substart), + make_fixnum (subend)); if (!NILP (literal_text) || !NILP (substring)) accum = concat3 (accum, literal_text, substring); literal_start = strpos + 1; ＠＠ -2901,8 +2901,8 ＠＠ if (strpos != literal_start) /* some literal text at end to be inserted */ replacement = concat2 (accum, Fsubseq (replacement, - make_int (literal_start), - make_int (strpos))); + make_fixnum (literal_start), + make_fixnum (strpos))); else replacement = accum; } ＠＠ -3000,8 +3000,8 ＠＠ if (c == '&') Finsert_buffer_substring (buffer, - make_int (search_regs.start[0] + offset), - make_int (search_regs.end[0] + offset)); + make_fixnum (search_regs.start[0] + offset), + make_fixnum (search_regs.end[0] + offset)); /* #### This logic is totally broken, since we can have backrefs like "\99", right? */ else if (c >= '1' && c <= '9' && ＠＠ -3010,8 +3010,8 ＠＠ if (search_regs.start[c - '0'] >= 1) Finsert_buffer_substring (buffer, - make_int (search_regs.start[c - '0'] + offset), - make_int (search_regs.end[c - '0'] + offset)); + make_fixnum (search_regs.start[c - '0'] + offset), + make_fixnum (search_regs.end[c - '0'] + offset)); } else if (c == 'U' || c == 'u' || c == 'L' || c == 'l' || c == 'E') ＠＠ -3045,11 +3045,11 ＠＠ search_regs.end[sub] + inslen, 0); if (case_action == all_caps) - Fupcase_region (make_int (BUF_PT (buf) - inslen), - make_int (BUF_PT (buf)), buffer); + Fupcase_region (make_fixnum (BUF_PT (buf) - inslen), + make_fixnum (BUF_PT (buf)), buffer); else if (case_action == cap_initial) - Fupcase_initials_region (make_int (BUF_PT (buf) - inslen), - make_int (BUF_PT (buf)), buffer); + Fupcase_initials_region (make_fixnum (BUF_PT (buf) - inslen), + make_fixnum (BUF_PT (buf)), buffer); /* Now go through and make all the case changes that were requested in the replacement string. */ ＠＠ -3101,14 +3101,14 ＠＠ { int n; - CHECK_INT (num); - n = XINT (num); + CHECK_FIXNUM (num); + n = XFIXNUM (num); if (n < 0 || n >= search_regs.num_regs) - args_out_of_range (num, make_int (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_int (beginningp ? search_regs.start[n] : search_regs.end[n]); + return make_fixnum (beginningp ? search_regs.start[n] : search_regs.end[n]); } DEFUN ("match-beginning", Fmatch_beginning, 1, 1, 0, /* ＠＠ -3167,18 +3167,18 ＠＠ if (EQ (last_thing_searched, Qt) || !NILP (integers)) { - data[2 * i] = make_int (start); - data[2 * i + 1] = make_int (search_regs.end[i]); + data[2 * i] = make_fixnum (start); + data[2 * i + 1] = make_fixnum (search_regs.end[i]); } else if (BUFFERP (last_thing_searched)) { data[2 * i] = Fmake_marker (); Fset_marker (data[2 * i], - make_int (start), + make_fixnum (start), last_thing_searched); data[2 * i + 1] = Fmake_marker (); Fset_marker (data[2 * i + 1], - make_int (search_regs.end[i]), + make_fixnum (search_regs.end[i]), last_thing_searched); } else ＠＠ -3236,7 +3236,7 ＠＠ last_thing_searched = Qt; /* Allocate registers if they don't already exist. */ - length = XINT (Flength (list)) / 2; + length = XFIXNUM (Flength (list)) / 2; num_regs = search_regs.num_regs; if (length > num_regs) ＠＠ -3273,16 +3273,16 ＠＠ last_thing_searched = wrap_buffer (XMARKER (marker)->buffer); } - CHECK_INT_COERCE_MARKER (marker); - search_regs.start[i] = XINT (marker); + CHECK_FIXNUM_COERCE_MARKER (marker); + search_regs.start[i] = XFIXNUM (marker); list = Fcdr (list); marker = Fcar (list); if (MARKERP (marker) && XMARKER (marker)->buffer == 0) marker = Qzero; - CHECK_INT_COERCE_MARKER (marker); - search_regs.end[i] = XINT (marker); + CHECK_FIXNUM_COERCE_MARKER (marker); + search_regs.end[i] = XFIXNUM (marker); } list = Fcdr (list); } diff -r a0e81357194e -r 56144c8593a8 src/select-gtk.c --- a/src/select-gtk.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/select-gtk.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -342,7 +342,7 ＠＠ /* add a timeout handler */ if (gtk_selection_timeout > 0) { - Lisp_Object id = Fadd_timeout (make_int (x_selection_timeout), + Lisp_Object id = Fadd_timeout (make_fixnum (x_selection_timeout), Qx_selection_reply_timeout_internal, Qnil, Qnil); record_unwind_protect (Fdisable_timeout, id); diff -r a0e81357194e -r 56144c8593a8 src/select-msw.c --- a/src/select-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/select-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -78,7 +78,7 ＠＠ static int x_sym_p (Lisp_Object value) { - if (NILP (value) || INTP (value)) + if (NILP (value) || FIXNUMP (value)) return 0; /* Check for some of the X symbols */ ＠＠ -101,7 +101,7 ＠＠ if (NILP (value)) return 0; /* If it's an integer, assume it's a format ID */ - if (INTP (value)) return (UINT) (XINT (value)); + if (FIXNUMP (value)) return (UINT) (XFIXNUM (value)); /* If it's a string, register the format(!) */ if (STRINGP (value)) ＠＠ -171,7 +171,7 ＠＠ case CF_DSPBITMAP: return QCF_DSPBITMAP; case CF_DSPMETAFILEPICT: return QCF_DSPMETAFILEPICT; case CF_DSPENHMETAFILE: return QCF_DSPENHMETAFILE; - default: return make_int ((int) format); + default: return make_fixnum ((int) format); } } ＠＠ -362,7 +362,7 ＠＠ if (!cf_is_autofreed (cfType)) { Lisp_Object alist_elt = Qnil, rest; - Lisp_Object cfType_int = make_int (cfType); + Lisp_Object cfType_int = make_fixnum (cfType); /* First check if there's an element in the alist for this type already. */ ＠＠ -440,7 +440,7 ＠＠ format = qxeRegisterClipboardFormat (nameext); if (format) - return make_int ((int) format); + return make_fixnum ((int) format); else return Qnil; } ＠＠ -453,8 +453,8 ＠＠ int numchars; /* If it's an integer, convert to a symbol if appropriate */ - if (INTP (type_id)) - type_id = ms_cf_to_symbol (XINT (type_id)); + if (FIXNUMP (type_id)) + type_id = ms_cf_to_symbol (XFIXNUM (type_id)); /* If this is a symbol, return it */ if (SYMBOLP (type_id)) diff -r a0e81357194e -r 56144c8593a8 src/select-x.c --- a/src/select-x.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/select-x.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -978,7 +978,7 ＠＠ /* add a timeout handler */ if (x_selection_timeout > 0) { - Lisp_Object id = Fadd_timeout (make_int (x_selection_timeout), + Lisp_Object id = Fadd_timeout (make_fixnum (x_selection_timeout), Qx_selection_reply_timeout_internal, Qnil, Qnil); record_unwind_protect (Fdisable_timeout, id); ＠＠ -1362,7 +1362,7 ＠＠ if (format != 8 || type != XA_STRING) invalid_state_2 ("Cut buffer doesn't contain 8-bit STRING data", x_atom_to_symbol (d, type), - make_int (format)); + make_fixnum (format)); /* We cheat - if the string contains an ESC character, that's technically not allowed in a STRING, so we assume it's ＠＠ -1467,8 +1467,8 ＠＠ Window window = RootWindow (display, 0); /* Cutbuffers are on frame 0 */ Atom props [8]; - CHECK_INT (n); - if (XINT (n) == 0) + CHECK_FIXNUM (n); + if (XFIXNUM (n) == 0) return n; if (! cut_buffers_initialized) initialize_cut_buffers (display, window); ＠＠ -1480,7 +1480,7 ＠＠ props[5] = XA_CUT_BUFFER5; props[6] = XA_CUT_BUFFER6; props[7] = XA_CUT_BUFFER7; - XRotateWindowProperties (display, window, props, 8, XINT (n)); + XRotateWindowProperties (display, window, props, 8, XFIXNUM (n)); return n; } diff -r a0e81357194e -r 56144c8593a8 src/select-xlike-inc.c --- a/src/select-xlike-inc.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/select-xlike-inc.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -110,9 +110,9 ＠＠ { Elemcount i; Elemcount len = size / sizeof (XE_ATOM_TYPE); - Lisp_Object v = Fmake_vector (make_int (len), Qzero); + Lisp_Object v = Fmake_vector (make_fixnum (len), Qzero); for (i = 0; i < len; i++) - Faset (v, make_int (i), XE_ATOM_TO_SYMBOL (d, ((XE_ATOM_TYPE *) data) [i])); + Faset (v, make_fixnum (i), XE_ATOM_TO_SYMBOL (d, ((XE_ATOM_TYPE *) data) [i])); return v; } } ＠＠ -124,7 +124,7 ＠＠ else if (format == 32 && size == sizeof (long)) return word_to_lisp (((unsigned long *) data) [0]); else if (format == 16 && size == sizeof (short)) - return make_int ((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). ＠＠ -149,7 +149,7 ＠＠ for (i = 0; i < size / 4; i++) { int j = (int) ((unsigned short *) data) [i]; - Faset (v, make_int (i), make_int (j)); + Faset (v, make_fixnum (i), make_fixnum (j)); } return v; } ＠＠ -160,7 +160,7 ＠＠ for (i = 0; i < size / 4; i++) { unsigned long j = ((unsigned long *) data) [i]; - Faset (v, make_int (i), word_to_lisp (j)); + Faset (v, make_fixnum (i), word_to_lisp (j)); } return v; } ＠＠ -239,18 +239,18 ＠＠ (*(XE_ATOM_TYPE **) data_ret) [0] = XE_SYMBOL_TO_ATOM (d, obj, 0); if (NILP (type)) type = QATOM; } - else if (INTP (obj) && - XINT (obj) <= 0x7FFF && - XINT (obj) >= -0x8000) + else if (FIXNUMP (obj) && + XFIXNUM (obj) <= 0x7FFF && + XFIXNUM (obj) >= -0x8000) { *format_ret = 16; *size_ret = 1; *data_ret = xnew_rawbytes (sizeof (short) + 1); (*data_ret) [sizeof (short)] = 0; - (*(short **) data_ret) [0] = (short) XINT (obj); + (*(short **) data_ret) [0] = (short) XFIXNUM (obj); if (NILP (type)) type = QINTEGER; } - else if (INTP (obj) || CONSP (obj)) + else if (FIXNUMP (obj) || CONSP (obj)) { *format_ret = 32; *size_ret = 1; ＠＠ -318,7 +318,7 ＠＠ for (i = 0; i < *size_ret; i++) if (CONSP (XVECTOR_DATA (obj) [i])) *format_ret = 32; - else if (!INTP (XVECTOR_DATA (obj) [i])) + else if (!FIXNUMP (XVECTOR_DATA (obj) [i])) syntax_error ("all elements of the vector must be integers or conses of integers", obj); diff -r a0e81357194e -r 56144c8593a8 src/select.c --- a/src/select.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/select.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -377,7 +377,7 ＠＠ && (NILP (type) || EQ (type, QSTRING) || EQ (type, QTEXT) || EQ (type, QCOMPOUND_TEXT))) types = Fcons (QTEXT, Fcons (QCOMPOUND_TEXT, Fcons (QSTRING, types))); - else if (INTP (value) && NILP (type)) + else if (FIXNUMP (value) && NILP (type)) types = Fcons (QINTEGER, types); else if (SYMBOLP (value) && NILP (type)) types = Fcons (QATOM, types); diff -r a0e81357194e -r 56144c8593a8 src/sgiplay.c --- a/src/sgiplay.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/sgiplay.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -194,7 +194,7 ＠＠ static Lisp_Object close_sound_file (Lisp_Object closure) { - close (XINT (closure)); + close (XFIXNUM (closure)); return Qnil; } ＠＠ -214,7 +214,7 ＠＠ file for us. */ return; - record_unwind_protect (close_sound_file, make_int (input_fd)); + record_unwind_protect (close_sound_file, make_fixnum (input_fd)); while ((bytes_read = read (input_fd, buffer, CHUNKSIZE)) > 0) { ＠＠ -246,9 +246,9 ＠＠ restore_audio_port (Lisp_Object closure) { Lisp_Object * contents = XVECTOR_DATA (closure); - saved_device_state[1] = XINT (contents[0]); - saved_device_state[3] = XINT (contents[1]); - saved_device_state[5] = XINT (contents[2]); + saved_device_state[1] = XFIXNUM (contents[0]); + saved_device_state[3] = XFIXNUM (contents[1]); + saved_device_state[5] = XFIXNUM (contents[2]); ALsetparams (AL_DEFAULT_DEVICE, saved_device_state, 6); return Qnil; } ＠＠ -302,9 +302,9 ＠＠ its initial characteristics after exit */ ALgetparams (desc.ac_device, saved_device_state, sizeof (saved_device_state) / sizeof (long)); - audio_port_state[0] = make_int (saved_device_state[1]); - audio_port_state[1] = make_int (saved_device_state[3]); - audio_port_state[2] = make_int (saved_device_state[5]); + audio_port_state[0] = make_fixnum (saved_device_state[1]); + audio_port_state[1] = make_fixnum (saved_device_state[3]); + audio_port_state[2] = make_fixnum (saved_device_state[5]); record_unwind_protect (restore_audio_port, Fvector (3, &audio_port_state[0])); ＠＠ -525,7 +525,7 ＠＠ #endif /* HAVE_STEREO */ default: report_sound_error ("Unsupported channel count", - make_int (nchan)); + make_fixnum (nchan)); return -1; } return 0; ＠＠ -561,7 +561,7 ＠＠ #endif #endif default: - report_sound_error ("Unsupported audio format", make_int (format)); + report_sound_error ("Unsupported audio format", make_fixnum (format)); return -1; } old_samplesize = ALgetwidth (config); diff -r a0e81357194e -r 56144c8593a8 src/sound.c --- a/src/sound.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/sound.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -124,8 +124,8 ＠＠ vol = bell_volume; else { - CHECK_INT (volume); - vol = XINT (volume); + CHECK_FIXNUM (volume); + vol = XFIXNUM (volume); } GCPRO1 (file); ＠＠ -245,14 +245,14 ＠＠ { *sound = XCAR (elt); } - else if (INT_OR_FLOATP (XCAR (elt)) && /* ( name <vol> . <sound> ) */ + else if (FIXNUM_OR_FLOATP (XCAR (elt)) && /* ( name <vol> . <sound> ) */ (SYMBOLP (XCDR (elt)) || STRINGP (XCDR (elt)))) { *volume = XCAR (elt); *sound = XCDR (elt); } - else if (INT_OR_FLOATP (XCAR (elt)) && /* ( name <vol> <sound> ) */ + else if (FIXNUM_OR_FLOATP (XCAR (elt)) && /* ( name <vol> <sound> ) */ CONSP (XCDR (elt)) && NILP (XCDR (XCDR (elt))) && (SYMBOLP (XCAR (XCDR (elt))) || ＠＠ -263,7 +263,7 ＠＠ } else if ((SYMBOLP (XCAR (elt)) || /* ( name <sound> . <vol> ) */ STRINGP (XCAR (elt))) && - INT_OR_FLOATP (XCDR (elt))) + FIXNUM_OR_FLOATP (XCDR (elt))) { *sound = XCAR (elt); *volume = XCDR (elt); ＠＠ -273,7 +273,7 ＠＠ STRINGP (XCAR (elt))) && CONSP (XCDR (elt)) && NILP (XCDR (XCDR (elt))) && - INT_OR_FLOATP (XCAR (XCDR (elt)))) + FIXNUM_OR_FLOATP (XCAR (XCDR (elt)))) { *sound = XCAR (elt); *volume = XCAR (XCDR (elt)); ＠＠ -292,16 +292,16 ＠＠ val = XCAR (val); if (EQ (key, Q_volume)) { - if (INT_OR_FLOATP (val)) *volume = val; + if (FIXNUM_OR_FLOATP (val)) *volume = val; } else if (EQ (key, Q_pitch)) { - if (INT_OR_FLOATP (val)) *pitch = val; + if (FIXNUM_OR_FLOATP (val)) *pitch = val; if (NILP (*sound)) *sound = Qt; } else if (EQ (key, Q_duration)) { - if (INT_OR_FLOATP (val)) *duration = val; + if (FIXNUM_OR_FLOATP (val)) *duration = val; if (NILP (*sound)) *sound = Qt; } else if (EQ (key, Q_sound)) ＠＠ -366,9 +366,9 ＠＠ } - vol = (INT_OR_FLOATP (volume) ? (int) XFLOATINT (volume) : bell_volume); - pit = (INT_OR_FLOATP (pitch) ? (int) XFLOATINT (pitch) : -1); - dur = (INT_OR_FLOATP (duration) ? (int) XFLOATINT (duration) : -1); + vol = (FIXNUM_OR_FLOATP (volume) ? (int) XFLOATFIXNUM (volume) : bell_volume); + pit = (FIXNUM_OR_FLOATP (pitch) ? (int) XFLOATFIXNUM (pitch) : -1); + dur = (FIXNUM_OR_FLOATP (duration) ? (int) XFLOATFIXNUM (duration) : -1); /* If the sound is a string, and we're connected to ALSA, NAS, or ESD, do that. Else if the sound is a string, and we're on console, play it diff -r a0e81357194e -r 56144c8593a8 src/specifier.c --- a/src/specifier.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/specifier.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -286,8 +286,8 ＠＠ /* #### Not obvious this is useful, and overrides user settings; if we resurrect this, create variables like `print-specifier-length' so it can be controlled. */ - specbind (Qprint_string_length, make_int (100)); - specbind (Qprint_length, make_int (5)); + specbind (Qprint_string_length, make_fixnum (100)); + specbind (Qprint_length, make_fixnum (5)); #endif the_specs = Fspecifier_specs (obj, Qglobal, Qnil, Qnil); if (NILP (the_specs)) ＠＠ -885,7 +885,7 ＠＠ static Lisp_Object canonicalize_tag_set (Lisp_Object tag_set) { - int len = XINT (Flength (tag_set)); + int len = XFIXNUM (Flength (tag_set)); Lisp_Object *tags, rest; int i, j; ＠＠ -1053,7 +1053,7 ＠＠ { struct gcpro gcpro1; Lisp_Object charpres = make_vector (NUM_MATCHSPEC_STAGES, Qnil); - int max_args = XINT (Ffunction_max_args (charset_predicate)); + int max_args = XFIXNUM (Ffunction_max_args (charset_predicate)); GCPRO1 (charpres); ＠＠ -1242,8 +1242,8 ＠＠ { Lisp_Object min_args = Ffunction_min_args (charset_predicate); Lisp_Object max_args = Ffunction_max_args (charset_predicate); - if (!(INTP (min_args) && XINT (min_args) == 1 && - INTP (max_args) && XINT (max_args) == 1)) + if (!(FIXNUMP (min_args) && XFIXNUM (min_args) == 1 && + FIXNUMP (max_args) && XFIXNUM (max_args) == 1)) { /* We only allow the stage argument to be specifed from C. */ invalid_change ("Charset predicate must take one argument", ＠＠ -2964,8 +2964,8 ＠＠ /* device had better be determined by now; abort if not. */ (void) DEVICE_CLASS (XDEVICE (device)); - depth = make_int (1 + XINT (depth)); - if (XINT (depth) > 20) + depth = make_fixnum (1 + XFIXNUM (depth)); + if (XFIXNUM (depth) > 20) { maybe_signal_error (Qstack_overflow, "Apparent loop in specifier inheritance", ＠＠ -3615,7 +3615,7 ＠＠ static void integer_validate (Lisp_Object instantiator) { - CHECK_INT (instantiator); + CHECK_FIXNUM (instantiator); } DEFUN ("integer-specifier-p", Finteger_specifier_p, 1, 1, 0, /* diff -r a0e81357194e -r 56144c8593a8 src/specifier.h --- a/src/specifier.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/specifier.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -547,7 +547,7 ＠＠ #define CONCHECK_GENERIC_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, generic) DECLARE_SPECIFIER_TYPE (integer); -#define XINTEGER_SPECIFIER(x) XSPECIFIER_TYPE (x, integer) +#define XFIXNUMEGER_SPECIFIER(x) XSPECIFIER_TYPE (x, integer) #define INTEGER_SPECIFIERP(x) SPECIFIER_TYPEP (x, integer) #define CHECK_INTEGER_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, integer) #define CONCHECK_INTEGER_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, integer) diff -r a0e81357194e -r 56144c8593a8 src/symbols.c --- a/src/symbols.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/symbols.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -245,11 +245,11 ＠＠ len = XSTRING_LENGTH (string); object = oblookup (obarray, XSTRING_DATA (string), len); - if (!INTP (object)) + if (!FIXNUMP (object)) /* Found it */ return object; - ptr = &XVECTOR_DATA (obarray)[XINT (object)]; + ptr = &XVECTOR_DATA (obarray)[XFIXNUM (object)]; object = Fmake_symbol (string); symbol = object; ＠＠ -301,7 +301,7 ＠＠ string = symbol_name (XSYMBOL (name)); tem = oblookup (obarray, XSTRING_DATA (string), XSTRING_LENGTH (string)); - if (INTP (tem) || (SYMBOLP (name) && !EQ (name, tem))) + if (FIXNUMP (tem) || (SYMBOLP (name) && !EQ (name, tem))) return default_; else return tem; ＠＠ -332,7 +332,7 ＠＠ } tem = oblookup (obarray, XSTRING_DATA (string), XSTRING_LENGTH (string)); - if (INTP (tem)) + if (FIXNUMP (tem)) return Qnil; /* If arg was a symbol, don't delete anything but that symbol itself. */ if (SYMBOLP (name) && !EQ (name, tem)) ＠＠ -423,7 +423,7 ＠＠ if (!tail) break; } - return make_int (hash); + return make_fixnum (hash); } /* An excellent string hashing function. ＠＠ -1209,7 +1209,7 ＠＠ { case SYMVAL_FIXNUM_FORWARD: case SYMVAL_CONST_FIXNUM_FORWARD: - return make_int (*((Fixnum *)symbol_value_forward_forward (fwd))); + return make_fixnum (*((Fixnum *)symbol_value_forward_forward (fwd))); case SYMVAL_BOOLEAN_FORWARD: case SYMVAL_CONST_BOOLEAN_FORWARD: ＠＠ -1271,7 +1271,7 ＠＠ = XSYMBOL_VALUE_FORWARD (valcontents); int offset = ((Rawbyte *) symbol_value_forward_forward (fwd) - (Rawbyte *) &buffer_local_flags); - int mask = XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd))); + int mask = XFIXNUM (*((Lisp_Object *) symbol_value_forward_forward (fwd))); int (*magicfun) (Lisp_Object simm, Lisp_Object *val, Lisp_Object in_object, int flags) = symbol_value_forward_magicfun (fwd); ＠＠ -1311,7 +1311,7 ＠＠ = XSYMBOL_VALUE_FORWARD (valcontents); int offset = ((Rawbyte *) symbol_value_forward_forward (fwd) - (Rawbyte *) &console_local_flags); - int mask = XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd))); + int mask = XFIXNUM (*((Lisp_Object *) symbol_value_forward_forward (fwd))); int (*magicfun) (Lisp_Object simm, Lisp_Object *val, Lisp_Object in_object, int flags) = symbol_value_forward_magicfun (fwd); ＠＠ -1379,10 +1379,10 ＠＠ switch (XSYMBOL_VALUE_MAGIC_TYPE (ovalue)) { case SYMVAL_FIXNUM_FORWARD: - CHECK_INT (newval); + CHECK_FIXNUM (newval); if (magicfun) magicfun (sym, &newval, Qnil, 0); - *((Fixnum *) symbol_value_forward_forward (fwd)) = XINT (newval); + *((Fixnum *) symbol_value_forward_forward (fwd)) = XFIXNUM (newval); return; case SYMVAL_BOOLEAN_FORWARD: ＠＠ -1947,7 +1947,7 ＠＠ { const struct symbol_value_forward *fwd = XSYMBOL_VALUE_FORWARD (valcontents); - int mask = XINT (*((Lisp_Object *) + int mask = XFIXNUM (*((Lisp_Object *) symbol_value_forward_forward (fwd))); if (mask > 0) /* Setting this variable makes it buffer-local */ ＠＠ -1959,7 +1959,7 ＠＠ { const struct symbol_value_forward *fwd = XSYMBOL_VALUE_FORWARD (valcontents); - int mask = XINT (*((Lisp_Object *) + int mask = XFIXNUM (*((Lisp_Object *) symbol_value_forward_forward (fwd))); if (mask > 0) /* Setting this variable makes it console-local */ ＠＠ -2243,7 +2243,7 ＠＠ if (nargs & 1) /* Odd number of arguments? */ Fsignal (Qwrong_number_of_arguments, - list2 (Qsetq_default, make_int (nargs))); + list2 (Qsetq_default, make_fixnum (nargs))); GC_PROPERTY_LIST_LOOP_3 (symbol, val, args) { ＠＠ -2547,7 +2547,7 ＠＠ int offset = ((Rawbyte *) symbol_value_forward_forward (fwd) - (Rawbyte *) &buffer_local_flags); int mask = - XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd))); + XFIXNUM (*((Lisp_Object *) symbol_value_forward_forward (fwd))); if (mask > 0) { ＠＠ -2642,7 +2642,7 ＠＠ int offset = ((Rawbyte *) symbol_value_forward_forward (fwd) - (Rawbyte *) &console_local_flags); int mask = - XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd))); + XFIXNUM (*((Lisp_Object *) symbol_value_forward_forward (fwd))); if (mask > 0) { ＠＠ -2698,7 +2698,7 ＠＠ { const struct symbol_value_forward *fwd = XSYMBOL_VALUE_FORWARD (valcontents); - int mask = XINT (*((Lisp_Object *) + int mask = XFIXNUM (*((Lisp_Object *) symbol_value_forward_forward (fwd))); if ((mask <= 0) || (buffer && (buffer->local_var_flags & mask))) /* Already buffer-local */ ＠＠ -2876,17 +2876,17 ＠＠ { Lisp_Object documentation = Fget (symbol, Qvariable_documentation, Qnil); - if ((INTP (documentation) && XINT (documentation) < 0) || + if ((FIXNUMP (documentation) && XFIXNUM (documentation) < 0) || (STRINGP (documentation) && (string_byte (documentation, 0) == '*')) || /* If (STRING . INTEGER), a negative integer means a user variable. */ (CONSP (documentation) && STRINGP (XCAR (documentation)) - && INTP (XCDR (documentation)) - && XINT (XCDR (documentation)) < 0) || + && FIXNUMP (XCDR (documentation)) + && XFIXNUM (XCDR (documentation)) < 0) || !NILP (Fcustom_variable_p (symbol))) { - return make_int(1); + return make_fixnum(1); } return Qzero; ＠＠ -2925,7 +2925,7 ＠＠ return Qnil; } - assert (EQ (make_int (1), mapped)); + assert (EQ (make_fixnum (1), mapped)); return Qt; } diff -r a0e81357194e -r 56144c8593a8 src/syntax.c --- a/src/syntax.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/syntax.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -194,8 +194,8 ＠＠ { struct buffer *buf = decode_buffer (buffer, 0); struct syntax_cache *cache = buf->syntax_cache; - return list4 (cache->start, cache->end, make_int (cache->prev_change), - make_int (cache->next_change)); + return list4 (cache->start, cache->end, make_fixnum (cache->prev_change), + make_fixnum (cache->next_change)); } #endif /* DEBUG_XEMACS */ ＠＠ -233,7 +233,7 ＠＠ buf->mirror_syntax_table = XCHAR_TABLE (syntax_table)->mirror_table; syntax_cache_table_was_changed (buf); /* Indicate that this buffer now has a specified syntax table. */ - buf->local_var_flags |= XINT (buffer_local_flags.syntax_table); + buf->local_var_flags |= XFIXNUM (buffer_local_flags.syntax_table); return syntax_table; } ＠＠ -292,8 +292,8 ＠＠ if (BUFFERP (cache->object)) { /* make known region zero-length and reset insertion behavior */ - Fset_marker (cache->start, make_int (1), cache->object); - Fset_marker (cache->end, make_int (1), cache->object); + Fset_marker (cache->start, make_fixnum (1), cache->object); + Fset_marker (cache->end, make_fixnum (1), cache->object); Fset_marker_insertion_type (cache->start, Qnil); Fset_marker_insertion_type (cache->end, Qt); } ＠＠ -301,8 +301,8 ＠＠ If so, also reset tables. */ if (valid_everywhere) { - cache->prev_change = EMACS_INT_MIN; - cache->next_change = EMACS_INT_MAX; + cache->prev_change = MOST_NEGATIVE_FIXNUM; + cache->next_change = MOST_POSITIVE_FIXNUM; } else /* valid nowhere */ { ＠＠ -490,13 +490,13 ＠＠ then we can safely make the end closed, so it will take in newly inserted text. (If such an extent is inserted, we will be informed through signal_syntax_cache_extent_changed().) */ - Fset_marker (cache->start, make_int (cache->prev_change), cache->object); + Fset_marker (cache->start, make_fixnum (cache->prev_change), cache->object); Fset_marker_insertion_type (cache->start, at_begin && NILP (extent_at (prev, cache->object, Qsyntax_table, NULL, EXTENT_AT_AT, 0)) ? Qnil : Qt); - Fset_marker (cache->end, make_int (cache->next_change), cache->object); + Fset_marker (cache->end, make_fixnum (cache->next_change), cache->object); Fset_marker_insertion_type (cache->end, at_end && NILP (extent_at (next, cache->object, Qsyntax_table, ＠＠ -513,10 +513,10 ＠＠ update_mirror_syntax_if_dirty (cache->mirror_table); #endif /* NOT_WORTH_THE_EFFORT */ } - else if (CONSP (tmp_table) && INTP (XCAR (tmp_table))) + else if (CONSP (tmp_table) && FIXNUMP (XCAR (tmp_table))) { cache->source = syntax_source_property_code; - cache->syntax_code = XINT (XCAR (tmp_table)); + cache->syntax_code = XFIXNUM (XCAR (tmp_table)); } else { ＠＠ -703,7 +703,7 ＠＠ if (CONSP (code)) code2 = XCAR (code); - if (SYNTAX_FROM_CODE (XINT (code2)) == Sinherit) + if (SYNTAX_FROM_CODE (XFIXNUM (code2)) == Sinherit) code = get_char_table (ch, Vstandard_syntax_table); return CONSP (code) ? XCDR (code) : Qnil; ＠＠ -867,8 +867,8 ＠＠ n = 1; else { - CHECK_INT (count); - n = XINT (count); + CHECK_FIXNUM (count); + n = XFIXNUM (count); } val = scan_words (buf, BUF_PT (buf), n); ＠＠ -1183,8 +1183,8 ＠＠ n = 1; else { - CHECK_INT (count); - n = XINT (count); + CHECK_FIXNUM (count); + n = XFIXNUM (count); } from = BUF_PT (buf); ＠＠ -1504,7 +1504,7 ＠＠ return Qnil; signal_error_2 (Qscan_error, "Containing expression ends prematurely", - make_int (last_good), make_int (from)); + make_fixnum (last_good), make_fixnum (from)); } break; ＠＠ -1678,7 +1678,7 ＠＠ return Qnil; signal_error_2 (Qscan_error, "Containing expression ends prematurely", - make_int (last_good), make_int (from)); + make_fixnum (last_good), make_fixnum (from)); } break; ＠＠ -1744,12 +1744,12 ＠＠ } - return (make_int (from)); + return (make_fixnum (from)); lose: if (!noerror) signal_error_2 (Qscan_error, "Unbalanced parentheses", - make_int (last_good), make_int (from)); + make_fixnum (last_good), make_fixnum (from)); return Qnil; } ＠＠ -1800,12 +1800,12 ＠＠ { struct buffer *buf; - CHECK_INT (from); - CHECK_INT (count); - CHECK_INT (depth); + CHECK_FIXNUM (from); + CHECK_FIXNUM (count); + CHECK_FIXNUM (depth); buf = decode_buffer (buffer, 0); - return scan_lists (buf, XINT (from), XINT (count), XINT (depth), 0, + return scan_lists (buf, XFIXNUM (from), XFIXNUM (count), XFIXNUM (depth), 0, !NILP (noerror)); } ＠＠ -1828,10 +1828,10 ＠＠ (from, count, buffer, noerror)) { struct buffer *buf = decode_buffer (buffer, 0); - CHECK_INT (from); - CHECK_INT (count); + CHECK_FIXNUM (from); + CHECK_FIXNUM (count); - return scan_lists (buf, XINT (from), XINT (count), 0, 1, !NILP (noerror)); + return scan_lists (buf, XFIXNUM (from), XFIXNUM (count), 0, 1, !NILP (noerror)); } DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, 0, 1, 0, /* ＠＠ -1901,7 +1901,7 ＠＠ { tem = Fcar (oldstate); /* elt 0, depth */ if (!NILP (tem)) - depth = XINT (tem); + depth = XFIXNUM (tem); else depth = 0; ＠＠ -1910,7 +1910,7 ＠＠ oldstate = Fcdr (oldstate); tem = Fcar (oldstate); /* elt 3, instring */ state.instring = ( !NILP (tem) - ? ( INTP (tem) ? XINT (tem) : ST_STRING_STYLE) + ? ( FIXNUMP (tem) ? XFIXNUM (tem) : ST_STRING_STYLE) : -1); oldstate = Fcdr (oldstate); ＠＠ -1932,7 +1932,7 ＠＠ oldstate = Fcdr (oldstate); /* elt 8, start of last comment/string */ tem = Fcar (oldstate); - state.comstr_start = NILP (tem) ? -1 : XINT (tem); + state.comstr_start = NILP (tem) ? -1 : XFIXNUM (tem); /* elt 9, char numbers of starts-of-expression of levels (starting from outermost). */ ＠＠ -1942,10 +1942,10 ＠＠ to change). */ while (!NILP (tem)) /* >= second enclosing sexps. */ { - curlevel->last = XINT (Fcar (tem)); + curlevel->last = XFIXNUM (Fcar (tem)); if (++curlevel == endlevel) stack_overflow ("Nesting too deep for parser", - make_int (curlevel - levelstart)); + make_fixnum (curlevel - levelstart)); curlevel->prev = -1; curlevel->last = -1; tem = Fcdr (tem); ＠＠ -2088,7 +2088,7 ＠＠ curlevel->last = from - 1; if (++curlevel == endlevel) stack_overflow ("Nesting too deep for parser", - make_int (curlevel - levelstart)); + make_fixnum (curlevel - levelstart)); curlevel->prev = -1; curlevel->last = -1; if (targetdepth == depth) goto done; ＠＠ -2198,7 +2198,7 ＠＠ state.location = from; state.levelstarts = Qnil; while (--curlevel >= levelstart) - state.levelstarts = Fcons (make_int (curlevel->last), + state.levelstarts = Fcons (make_fixnum (curlevel->last), state.levelstarts); *stateptr = state; ＠＠ -2248,8 +2248,8 ＠＠ if (!NILP (targetdepth)) { - CHECK_INT (targetdepth); - target = XINT (targetdepth); + CHECK_FIXNUM (targetdepth); + target = XFIXNUM (targetdepth); } else target = -100000; /* We won't reach this depth */ ＠＠ -2265,21 +2265,21 ＠＠ val = Qnil; val = Fcons (state.levelstarts, val); val = Fcons ((state.incomment || (state.instring >= 0)) - ? make_int (state.comstr_start) : Qnil, val); + ? make_fixnum (state.comstr_start) : Qnil, val); val = Fcons (state.comstyle ? (state.comstyle == ST_COMMENT_STYLE ? Qsyntax_table : Qt) : Qnil, val); - val = Fcons (make_int (state.mindepth), val); + val = Fcons (make_fixnum (state.mindepth), val); val = Fcons (state.quoted ? Qt : Qnil, val); val = Fcons (state.incomment ? Qt : Qnil, val); val = Fcons (state.instring < 0 ? Qnil : (state.instring == ST_STRING_STYLE - ? Qt : make_int (state.instring)), val); + ? Qt : make_fixnum (state.instring)), val); val = Fcons (state.thislevelstart < 0 ? Qnil : - make_int (state.thislevelstart), val); + make_fixnum (state.thislevelstart), val); val = Fcons (state.prevlevelstart < 0 ? Qnil : - make_int (state.prevlevelstart), val); - val = Fcons (make_int (state.depth), val); + make_fixnum (state.prevlevelstart), val); + val = Fcons (make_fixnum (state.depth), val); return val; } ＠＠ -2310,7 +2310,7 ＠＠ if (CONSP (val)) val = XCAR (val); - if (SYNTAX_FROM_CODE (XINT (val)) != Sinherit) + if (SYNTAX_FROM_CODE (XFIXNUM (val)) != Sinherit) put_char_table (mirrortab, range, val); return 0; } ＠＠ -2323,7 +2323,7 ＠＠ Lisp_Object mirrortab = GET_LISP_FROM_VOID (arg); if (CONSP (val)) val = XCAR (val); - if (SYNTAX_FROM_CODE (XINT (val)) != Sinherit) + if (SYNTAX_FROM_CODE (XFIXNUM (val)) != Sinherit) { Lisp_Object existing = updating_mirror_get_range_char_table (range, mirrortab, ＠＠ -2372,7 +2372,7 ＠＠ map_char_table (Vstandard_syntax_table, &range, copy_if_not_already_present, STORE_LISP_IN_VOID (mirrortab)); /* The resetting made the default be Qnil. Put it back to Sword. */ - set_char_table_default (mirrortab, make_int (Sword)); + set_char_table_default (mirrortab, make_fixnum (Sword)); XCHAR_TABLE (mirrortab)->dirty = 0; } ＠＠ -2473,7 +2473,7 ＠＠ define_standard_syntax (const UExtbyte *p, enum syntaxcode syn) { for (; *p; p++) - Fput_char_table (make_char (*p), make_int (syn), Vstandard_syntax_table); + Fput_char_table (make_char (*p), make_fixnum (syn), Vstandard_syntax_table); } void ＠＠ -2485,7 +2485,7 ＠＠ #define SET_RANGE_SYNTAX(start, end, syntax) \ do { \ for (i = start; i <= end; i++) \ - Fput_char_table(make_char(i), make_int(syntax), \ + Fput_char_table(make_char(i), make_fixnum(syntax), \ Vstandard_syntax_table); \ } while (0) ＠＠ -2505,7 +2505,7 ＠＠ staticpro (&Vsyntax_designator_chars_string); /* Default character syntax is word. */ - set_char_table_default (Vstandard_syntax_table, make_int (Sword)); + set_char_table_default (Vstandard_syntax_table, make_fixnum (Sword)); /* Control 0; treat as punctuation */ SET_RANGE_SYNTAX(0, 32, Spunct); ＠＠ -2526,10 +2526,10 ＠＠ for (p = (const UExtbyte *)"()[]{}"; *p; p+=2) { Fput_char_table (make_char (p[0]), - Fcons (make_int (Sopen), make_char (p[1])), + Fcons (make_fixnum (Sopen), make_char (p[1])), Vstandard_syntax_table); Fput_char_table (make_char (p[1]), - Fcons (make_int (Sclose), make_char (p[0])), + Fcons (make_fixnum (Sclose), make_char (p[0])), Vstandard_syntax_table); } diff -r a0e81357194e -r 56144c8593a8 src/syntax.h --- a/src/syntax.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/syntax.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -92,7 +92,7 ＠＠ { type_checking_assert (XCHAR_TABLE (table)->mirror_table_p); update_mirror_syntax_if_dirty (table); - return XINT (get_char_table_1 (c, table)); + return XFIXNUM (get_char_table_1 (c, table)); } #ifdef NOT_WORTH_THE_EFFORT ＠＠ -105,7 +105,7 ＠＠ ) { type_checking_assert (XCHAR_TABLE (table)->mirror_table_p); - return (enum syntaxcode) XINT (get_char_table_1 (c, table)); + return (enum syntaxcode) XFIXNUM (get_char_table_1 (c, table)); } #endif /* NOT_WORTH_THE_EFFORT */ diff -r a0e81357194e -r 56144c8593a8 src/sysdep.c --- a/src/sysdep.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/sysdep.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -2073,7 +2073,7 ＠＠ # ifdef TRY_AGAIN if (! (hp == 0 && h_errno == TRY_AGAIN)) break; - Fsleep_for (make_int (1)); + Fsleep_for (make_fixnum (1)); } # endif if (hp) ＠＠ -3483,19 +3483,19 ＠＠ get_random (void) { long val = random (); -#if INT_VALBITS > RAND_BITS +#if FIXNUM_VALBITS > RAND_BITS val = (val << RAND_BITS) ^ random (); -#if INT_VALBITS > 2*RAND_BITS +#if FIXNUM_VALBITS > 2*RAND_BITS val = (val << RAND_BITS) ^ random (); -#if INT_VALBITS > 3*RAND_BITS +#if FIXNUM_VALBITS > 3*RAND_BITS val = (val << RAND_BITS) ^ random (); -#if INT_VALBITS > 4*RAND_BITS +#if FIXNUM_VALBITS > 4*RAND_BITS val = (val << RAND_BITS) ^ random (); #endif /* need at least 5 */ #endif /* need at least 4 */ #endif /* need at least 3 */ #endif /* need at least 2 */ - return val & (EMACS_INT) ((1UL << INT_VALBITS) - 1); + return val & (EMACS_INT) ((1UL << FIXNUM_VALBITS) - 1); }  diff -r a0e81357194e -r 56144c8593a8 src/tests.c --- a/src/tests.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/tests.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -573,7 +573,7 ＠＠ void *extra_arg) { test_hash_tables_data *p = (test_hash_tables_data *) extra_arg; - p->sum += XINT (value); + p->sum += XFIXNUM (value); return 0; } ＠＠ -582,10 +582,10 ＠＠ void *extra_arg) { test_hash_tables_data *p = (test_hash_tables_data *) extra_arg; - Fputhash (make_int (- XINT (key)), - make_int (2 * XINT (value)), + Fputhash (make_fixnum (- XFIXNUM (key)), + make_fixnum (2 * XFIXNUM (value)), p->hash_table); - p->sum += XINT (value); + p->sum += XFIXNUM (value); return 0; } ＠＠ -594,7 +594,7 ＠＠ Lisp_Object UNUSED (value), void *UNUSED (extra_arg)) { - return XINT (key) < 0; + return XFIXNUM (key) < 0; } ＠＠ -615,8 +615,8 ＠＠ data.hash_table = make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, Qequal); - Fputhash (make_int (1), make_int (2), data.hash_table); - Fputhash (make_int (3), make_int (4), data.hash_table); + Fputhash (make_fixnum (1), make_fixnum (2), data.hash_table); + Fputhash (make_fixnum (3), make_fixnum (4), data.hash_table); data.sum = 0; elisp_maphash_unsafe (test_hash_tables_mapper, ＠＠ -674,7 +674,7 ＠＠ assert (GET_VOID_FROM_LISP (STORE_VOID_IN_LISP (pval)) == pval); \ } \ while (0) - assert (INT_VALBITS >= 31); + assert (FIXNUM_VALBITS >= 31); FROB (&baz); FROB (&baz.x); FROB (&baz.y); ＠＠ -689,12 +689,12 ＠＠ FROB (0x80808080); FROB (0xCAFEBABE); FROB (0xFFFFFFFE); -#if INT_VALBITS >= 63 +#if FIXNUM_VALBITS >= 63 FROB (0x0000808080808080); FROB (0x8080808080808080); FROB (0XDEADBEEFCAFEBABE); FROB (0XFFFFFFFFFFFFFFFE); -#endif /* INT_VALBITS >= 63 */ +#endif /* FIXNUM_VALBITS >= 63 */ return list1 (list3 (build_ascstring ("STORE_VOID_IN_LISP"), Qt, Qnil)); } diff -r a0e81357194e -r 56144c8593a8 src/text.c --- a/src/text.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/text.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -3649,8 +3649,8 ＠＠ Charbpos ind; Charbpos min_allowed, max_allowed; - CHECK_INT_COERCE_MARKER (pos); - ind = XINT (pos); + CHECK_FIXNUM_COERCE_MARKER (pos); + ind = XFIXNUM (pos); min_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_BEG (b) : BUF_BEGV (b); max_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_Z (b) : BUF_ZV (b); ＠＠ -3762,8 +3762,8 ＠＠ /* Computation of KNOWN_LENGTH is potentially expensive so we pass it in. */ - CHECK_INT (pos); - ccpos = XINT (pos); + CHECK_FIXNUM (pos); + ccpos = XFIXNUM (pos); if (ccpos < 0 && flags & GB_NEGATIVE_FROM_END) ccpos += max_allowed; ＠＠ -4745,7 +4745,7 ＠＠ #ifdef ENABLE_COMPOSITE_CHARS if (f1 + FIELD1_TO_OFFICIAL_LEADING_BYTE == LEADING_BYTE_COMPOSITE) { - if (UNBOUNDP (Fgethash (make_int (ch), + if (UNBOUNDP (Fgethash (make_fixnum (ch), Vcomposite_char_char2string_hash_table, Qunbound))) return 0; ＠＠ -4918,14 +4918,14 ＠＠ get_charset_limits (charset, &lowlim, &highlim); - CHECK_INT (arg1); + CHECK_FIXNUM (arg1); /* It is useful (and safe, according to Olivier Galibert) to strip the 8th bit off ARG1 and ARG2 because it allows programmers to write (make-char 'latin-iso8859-2 CODE) where code is the actual Latin 2 code of the character. */ - a1 = XINT (arg1) & 0x7f; + a1 = XFIXNUM (arg1) & 0x7f; if (a1 < lowlim || a1 > highlim) - args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim)); + args_out_of_range_3 (arg1, make_fixnum (lowlim), make_fixnum (highlim)); if (CHARSET_DIMENSION (cs) == 1) { ＠＠ -4935,10 +4935,10 ＠＠ return make_char (make_ichar (charset, a1, 0)); } - CHECK_INT (arg2); - a2 = XINT (arg2) & 0x7f; + CHECK_FIXNUM (arg2); + a2 = XFIXNUM (arg2) & 0x7f; if (a2 < lowlim || a2 > highlim) - args_out_of_range_3 (arg2, make_int (lowlim), make_int (highlim)); + args_out_of_range_3 (arg2, make_fixnum (lowlim), make_fixnum (highlim)); return make_char (make_ichar (charset, a1, a2)); #else ＠＠ -4949,14 +4949,14 ＠＠ else if (EQ (charset, Qcontrol_1)) lowlim = 0, highlim = 31; else lowlim = 0, highlim = 127; - CHECK_INT (arg1); + CHECK_FIXNUM (arg1); /* It is useful (and safe, according to Olivier Galibert) to strip the 8th bit off ARG1 and ARG2 because it allows programmers to write (make-char 'latin-iso8859-2 CODE) where code is the actual Latin 2 code of the character. */ - a1 = XINT (arg1) & 0x7f; + a1 = XFIXNUM (arg1) & 0x7f; if (a1 < lowlim || a1 > highlim) - args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim)); + args_out_of_range_3 (arg1, make_fixnum (lowlim), make_fixnum (highlim)); if (EQ (charset, Qascii)) return make_char (a1); ＠＠ -4991,9 +4991,9 ＠＠ BREAKUP_ICHAR (XCHAR (ch), charset, octet0, octet1); if (NILP (n) || EQ (n, Qzero)) - return make_int (octet0); - else if (EQ (n, make_int (1))) - return make_int (octet1); + return make_fixnum (octet0); + else if (EQ (n, make_fixnum (1))) + return make_fixnum (octet1); else invalid_constant ("Octet number must be 0 or 1", n); } ＠＠ -5018,11 +5018,11 ＠＠ if (XCHARSET_DIMENSION (charset) == 2) { - rc = list3 (XCHARSET_NAME (charset), make_int (c1), make_int (c2)); + rc = list3 (XCHARSET_NAME (charset), make_fixnum (c1), make_fixnum (c2)); } else { - rc = list2 (XCHARSET_NAME (charset), make_int (c1)); + rc = list2 (XCHARSET_NAME (charset), make_fixnum (c1)); } UNGCPRO; diff -r a0e81357194e -r 56144c8593a8 src/toolbar-msw.c --- a/src/toolbar-msw.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/toolbar-msw.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -65,7 +65,7 ＠＠ { /* hmm what do we generate an id based on */ int id = TOOLBAR_ITEM_ID_BITS (internal_hash (button->callback, 0, 0)); - while (!NILP (Fgethash (make_int (id), + while (!NILP (Fgethash (make_fixnum (id), FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE (f), Qnil))) { id = TOOLBAR_ITEM_ID_BITS (id + 1); ＠＠ -90,7 +90,7 ＠＠ { qxeSendMessage (toolbarwnd, TB_GETBUTTON, (WPARAM) i, (LPARAM) &info); - Fremhash (make_int (info.idCommand), + Fremhash (make_fixnum (info.idCommand), FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE (f)); qxeSendMessage (toolbarwnd, TB_DELETEBUTTON, (WPARAM) i, 0); } ＠＠ -321,7 +321,7 ＠＠ } } - Fputhash (make_int (tbbutton->idCommand), + Fputhash (make_fixnum (tbbutton->idCommand), button, FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE (f)); } ＠＠ -563,7 +563,7 ＠＠ Lisp_Object mswindows_get_toolbar_button_text (struct frame *f, int command_id) { - Lisp_Object button = Fgethash (make_int (command_id), + Lisp_Object button = Fgethash (make_fixnum (command_id), FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE (f), Qnil); if (!NILP (button)) ＠＠ -587,7 +587,7 ＠＠ /* Try to map the command id through the proper hash table */ Lisp_Object button, data, fn, arg, frame; - button = Fgethash (make_int (id), + button = Fgethash (make_fixnum (id), FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE (f), Qnil); if (NILP (button)) diff -r a0e81357194e -r 56144c8593a8 src/toolbar-xlike.c --- a/src/toolbar-xlike.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/toolbar-xlike.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -83,7 +83,7 ＠＠ Lisp_Object window = FRAME_LAST_NONMINIBUF_WINDOW (f); struct window *w = XWINDOW (window); int shadow_thickness; - int def_shadow_thickness = XINT (Fspecifier_instance (Vtoolbar_shadow_thickness, window, Qnil, Qnil)); + int def_shadow_thickness = XFIXNUM (Fspecifier_instance (Vtoolbar_shadow_thickness, window, Qnil, Qnil)); face_index toolbar_findex; if (tb->vertical) ＠＠ -335,7 +335,7 ＠＠ if (tb->blank) { if (!NILP (tb->down_glyph)) - size = XINT (tb->down_glyph); + size = XFIXNUM (tb->down_glyph); else size = DEFAULT_TOOLBAR_BLANK_SIZE; } ＠＠ -348,7 +348,7 ＠＠ change the glyph out from under us. Use a blank placeholder in that case. */ if (NILP (glyph)) - return XINT (f->toolbar_size[pos]); + return XFIXNUM (f->toolbar_size[pos]); if (vert) size = glyph_height (glyph, window); ＠＠ -360,7 +360,7 ＠＠ { /* If the glyph doesn't have a size we'll insert a blank placeholder instead. */ - return XINT (f->toolbar_size[pos]); + return XFIXNUM (f->toolbar_size[pos]); } size += shadow_thickness * 2; diff -r a0e81357194e -r 56144c8593a8 src/toolbar.c --- a/src/toolbar.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/toolbar.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1129,7 +1129,7 ＠＠ else value = elt[0]; - len = XINT (Flength (value)); + len = XFIXNUM (Flength (value)); if (len < 1) CTB_ERROR ("toolbar button glyph list must have at least 1 entry"); ＠＠ -1718,13 +1718,13 ＠＠ fb = Fcons (Fcons (list1 (Qtty), Qzero), fb); #endif #ifdef HAVE_GTK - fb = Fcons (Fcons (list1 (Qgtk), make_int (2)), fb); + fb = Fcons (Fcons (list1 (Qgtk), make_fixnum (2)), fb); #endif #ifdef HAVE_X_WINDOWS - fb = Fcons (Fcons (list1 (Qx), make_int (2)), fb); + fb = Fcons (Fcons (list1 (Qx), make_fixnum (2)), fb); #endif #ifdef HAVE_MS_WINDOWS - fb = Fcons (Fcons (list1 (Qmswindows), make_int (2)), fb); + fb = Fcons (Fcons (list1 (Qmswindows), make_fixnum (2)), fb); #endif if (!NILP (fb)) ＠＠ -1735,14 +1735,14 ＠＠ fb = Fcons (Fcons (list1 (Qtty), Qzero), fb); #endif #ifdef HAVE_GTK - fb = Fcons (Fcons (list1 (Qgtk), make_int (DEFAULT_TOOLBAR_HEIGHT)), fb); + fb = Fcons (Fcons (list1 (Qgtk), make_fixnum (DEFAULT_TOOLBAR_HEIGHT)), fb); #endif #ifdef HAVE_X_WINDOWS - fb = Fcons (Fcons (list1 (Qx), make_int (DEFAULT_TOOLBAR_HEIGHT)), fb); + fb = Fcons (Fcons (list1 (Qx), make_fixnum (DEFAULT_TOOLBAR_HEIGHT)), fb); #endif #ifdef HAVE_MS_WINDOWS fb = Fcons (Fcons (list1 (Qmswindows), - make_int (MSWINDOWS_DEFAULT_TOOLBAR_HEIGHT)), fb); + make_fixnum (MSWINDOWS_DEFAULT_TOOLBAR_HEIGHT)), fb); #endif if (!NILP (fb)) set_specifier_fallback (Vdefault_toolbar_height, fb); ＠＠ -1752,14 +1752,14 ＠＠ fb = Fcons (Fcons (list1 (Qtty), Qzero), fb); #endif #ifdef HAVE_GTK - fb = Fcons (Fcons (list1 (Qgtk), make_int (DEFAULT_TOOLBAR_WIDTH)), fb); + fb = Fcons (Fcons (list1 (Qgtk), make_fixnum (DEFAULT_TOOLBAR_WIDTH)), fb); #endif #ifdef HAVE_X_WINDOWS - fb = Fcons (Fcons (list1 (Qx), make_int (DEFAULT_TOOLBAR_WIDTH)), fb); + fb = Fcons (Fcons (list1 (Qx), make_fixnum (DEFAULT_TOOLBAR_WIDTH)), fb); #endif #ifdef HAVE_MS_WINDOWS fb = Fcons (Fcons (list1 (Qmswindows), - make_int (MSWINDOWS_DEFAULT_TOOLBAR_WIDTH)), fb); + make_fixnum (MSWINDOWS_DEFAULT_TOOLBAR_WIDTH)), fb); #endif if (!NILP (fb)) set_specifier_fallback (Vdefault_toolbar_width, fb); ＠＠ -1868,13 +1868,13 ＠＠ fb = Fcons (Fcons (list1 (Qtty), Qzero), fb); #endif #ifdef HAVE_X_WINDOWS - fb = Fcons (Fcons (list1 (Qx), make_int (DEFAULT_TOOLBAR_BORDER_WIDTH)), fb); + fb = Fcons (Fcons (list1 (Qx), make_fixnum (DEFAULT_TOOLBAR_BORDER_WIDTH)), fb); #endif #ifdef HAVE_GTK - fb = Fcons (Fcons (list1 (Qgtk), make_int (DEFAULT_TOOLBAR_BORDER_WIDTH)), fb); + fb = Fcons (Fcons (list1 (Qgtk), make_fixnum (DEFAULT_TOOLBAR_BORDER_WIDTH)), fb); #endif #ifdef HAVE_MS_WINDOWS - fb = Fcons (Fcons (list1 (Qmswindows), make_int (MSWINDOWS_DEFAULT_TOOLBAR_BORDER_WIDTH)), fb); + fb = Fcons (Fcons (list1 (Qmswindows), make_fixnum (MSWINDOWS_DEFAULT_TOOLBAR_BORDER_WIDTH)), fb); #endif if (!NILP (fb)) set_specifier_fallback (Vdefault_toolbar_border_width, fb); diff -r a0e81357194e -r 56144c8593a8 src/tooltalk.c --- a/src/tooltalk.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/tooltalk.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -291,10 +291,10 ＠＠ static int tooltalk_constant_value (Lisp_Object s) { - if (INTP (s)) - return XINT (s); + if (FIXNUMP (s)) + return XFIXNUM (s); else if (SYMBOLP (s)) - return XINT (XSYMBOL (s)->value); + return XFIXNUM (XSYMBOL (s)->value); else return 0; /* should never occur */ } ＠＠ -586,8 +586,8 ＠＠ EQ (attribute, (Qtt_arg_type)) || EQ (attribute, (Qtt_arg_val))) { - CHECK_INT (argn); - n = XINT (argn); + CHECK_FIXNUM (argn); + n = XFIXNUM (argn); } if (!VALID_TOOLTALK_MESSAGEP (m)) ＠＠ -609,7 +609,7 ＠＠ return tt_message_arg_bval_vector (m, n); else if (EQ (attribute, Qtt_args_count)) - return make_int (tt_message_args_count (m)); + return make_fixnum (tt_message_args_count (m)); else if (EQ (attribute, Qtt_address)) return tt_address_symbol (tt_message_address (m)); ＠＠ -618,13 +618,13 ＠＠ return tt_class_symbol (tt_message_class (m)); else if (EQ (attribute, Qtt_disposition)) - return make_int (tt_message_disposition (m)); + return make_fixnum (tt_message_disposition (m)); else if (EQ (attribute, Qtt_file)) return tt_build_c_string (tt_message_file (m)); else if (EQ (attribute, Qtt_gid)) - return make_int (tt_message_gid (m)); + return make_fixnum (tt_message_gid (m)); else if (EQ (attribute, Qtt_handler)) return tt_build_c_string (tt_message_handler (m)); ＠＠ -660,13 +660,13 ＠＠ return tt_state_symbol (tt_message_state (m)); else if (EQ (attribute, Qtt_status)) - return make_int (tt_message_status (m)); + return make_fixnum (tt_message_status (m)); else if (EQ (attribute, Qtt_status_string)) return tt_build_c_string (tt_message_status_string (m)); else if (EQ (attribute, Qtt_uid)) - return make_int (tt_message_uid (m)); + return make_fixnum (tt_message_uid (m)); else if (EQ (attribute, Qtt_callback)) return XTOOLTALK_MESSAGE (message_)->callback; ＠＠ -716,8 +716,8 ＠＠ EQ (attribute, (Qtt_arg_ival)) || EQ (attribute, (Qtt_arg_val))) { - CHECK_INT (argn); - n = XINT (argn); + CHECK_FIXNUM (argn); + n = XFIXNUM (argn); } if (!VALID_TOOLTALK_MESSAGEP (m)) ＠＠ -773,8 +773,8 ＠＠ } else if (EQ (attribute, Qtt_arg_ival)) { - CHECK_INT (value); - tt_message_arg_ival_set (m, n, XINT (value)); + CHECK_FIXNUM (value); + tt_message_arg_ival_set (m, n, XFIXNUM (value)); } else if (EQ (attribute, Qtt_arg_val)) { ＠＠ -785,8 +785,8 ＠＠ } else if (EQ (attribute, Qtt_status)) { - CHECK_INT (value); - tt_message_status_set (m, XINT (value)); + CHECK_FIXNUM (value); + tt_message_status_set (m, XFIXNUM (value)); } else if (EQ (attribute, Qtt_callback)) { ＠＠ -930,8 +930,8 ＠＠ value_ext = LISP_STRING_TO_EXTERNAL (value, Qtooltalk_encoding); tt_message_arg_add (m, n, vtype_ext, value_ext); } - else if (INTP (value)) - tt_message_iarg_add (m, n, vtype_ext, XINT (value)); + else if (FIXNUMP (value)) + tt_message_iarg_add (m, n, vtype_ext, XFIXNUM (value)); } return Qnil; ＠＠ -1129,8 +1129,8 ＠＠ value_ext = LISP_STRING_TO_EXTERNAL (value, Qtooltalk_encoding); tt_pattern_arg_add (p, n, vtype_ext, value_ext); } - else if (INTP (value)) - tt_pattern_iarg_add (p, n, vtype_ext, XINT (value)); + else if (FIXNUMP (value)) + tt_pattern_iarg_add (p, n, vtype_ext, XFIXNUM (value)); } return Qnil; ＠＠ -1254,7 +1254,7 ＠＠ if (tt_ptr_error (retval) != TT_OK) return; - Vtooltalk_fd = make_int (tt_fd ()); + Vtooltalk_fd = make_fixnum (tt_fd ()); tt_session_join (tt_default_session ()); ＠＠ -1422,7 +1422,7 ＠＠ #define MAKE_CONSTANT(name) do { \ defsymbol (&Q_ ## name, #name); \ - Fset (Q_ ## name, make_int (name)); \ + Fset (Q_ ## name, make_fixnum (name)); \ } while (0) MAKE_CONSTANT (TT_MODE_UNDEFINED); diff -r a0e81357194e -r 56144c8593a8 src/tooltalk.h --- a/src/tooltalk.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/tooltalk.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -40,7 +40,7 ＠＠ #define TOOLTALK_PATTERN_KEY 101 #define CHECK_TOOLTALK_CONSTANT(x) do { \ - if (!(INTP (x) || SYMBOLP (x))) \ + if (!(FIXNUMP (x) || SYMBOLP (x))) \ dead_wrong_type_argument (Qsymbolp, (x)); \ } while (0) diff -r a0e81357194e -r 56144c8593a8 src/ui-byhand.c --- a/src/ui-byhand.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/ui-byhand.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -57,8 +57,8 ＠＠ GTK_WIDGET (XGTK_OBJECT (child)->object), &expand, &fill, &padding, &pack_type); - result = Fcons (make_int (pack_type), result); - result = Fcons (make_int (padding), result); + result = Fcons (make_fixnum (pack_type), result); + result = Fcons (make_fixnum (padding), result); result = Fcons (fill ? Qt : Qnil, result); result = Fcons (expand ? Qt : Qnil, result); ＠＠ -76,7 +76,7 ＠＠ gtk_button_box_get_child_size_default (&width, &height); - return (Fcons (make_int (width), make_int (height))); + return (Fcons (make_fixnum (width), make_fixnum (height))); } /* void gtk_button_box_get_child_ipadding_default (gint *ipad_x, gint *ipad_y); */ ＠＠ -90,7 +90,7 ＠＠ gtk_button_box_get_child_ipadding_default (&x, &y); - return (Fcons (make_int (x), make_int (y))); + return (Fcons (make_fixnum (x), make_fixnum (y))); } /* void gtk_button_box_get_child_size (GtkButtonBox *widget, ＠＠ -112,7 +112,7 ＠＠ gtk_button_box_get_child_size (GTK_BUTTON_BOX (XGTK_OBJECT (box)->object), &width, &height); - return (Fcons (make_int (width), make_int (height))); + return (Fcons (make_fixnum (width), make_fixnum (height))); } /* void gtk_button_box_get_child_ipadding (GtkButtonBox *widget, gint *ipad_x, gint *ipad_y); */ ＠＠ -134,7 +134,7 ＠＠ gtk_button_box_get_child_ipadding (GTK_BUTTON_BOX (XGTK_OBJECT (box)->object), &x, &y); - return (Fcons (make_int (x), make_int (y))); + return (Fcons (make_fixnum (x), make_fixnum (y))); } /*void gtk_calendar_get_date (GtkCalendar *calendar, ＠＠ -159,7 +159,7 ＠＠ gtk_calendar_get_date (GTK_CALENDAR (XGTK_OBJECT (calendar)->object), &year, &month, &day); - return (list3 (make_int (year), make_int (month), make_int (day))); + return (list3 (make_fixnum (year), make_fixnum (month), make_fixnum (day))); } /* gint gtk_clist_get_text (GtkCList *clist, ＠＠ -176,15 +176,15 ＠＠ Lisp_Object rval = Qnil; CHECK_GTK_OBJECT (obj); - CHECK_INT (row); - CHECK_INT (column); + CHECK_FIXNUM (row); + CHECK_FIXNUM (column); if (!GTK_IS_CLIST (XGTK_OBJECT (obj)->object)) { wtaerror ("Object is not a GtkCList", obj); } - gtk_clist_get_text (GTK_CLIST (XGTK_OBJECT (obj)->object), XINT (row), XINT (column), &text); + gtk_clist_get_text (GTK_CLIST (XGTK_OBJECT (obj)->object), XFIXNUM (row), XFIXNUM (column), &text); if (text) { ＠＠ -211,8 +211,8 ＠＠ gint row, column; CHECK_GTK_OBJECT (obj); - CHECK_INT (x); - CHECK_INT (y); + CHECK_FIXNUM (x); + CHECK_FIXNUM (y); if (!GTK_IS_CLIST (XGTK_OBJECT (obj)->object)) { ＠＠ -220,9 +220,9 ＠＠ } gtk_clist_get_selection_info (GTK_CLIST (XGTK_OBJECT (obj)->object), - XINT (x), XINT (y), &row, &column); + XFIXNUM (x), XFIXNUM (y), &row, &column); - return (Fcons (make_int (row), make_int (column))); + return (Fcons (make_fixnum (row), make_fixnum (column))); } DEFUN ("gtk-clist-get-pixmap", Fgtk_clist_get_pixmap, 3, 3, 0, /* ＠＠ -234,8 +234,8 ＠＠ GdkBitmap *mask = NULL; CHECK_GTK_OBJECT (clist); - CHECK_INT (row); - CHECK_INT (column); + CHECK_FIXNUM (row); + CHECK_FIXNUM (column); if (!GTK_IS_CLIST (XGTK_OBJECT (clist)->object)) { ＠＠ -243,7 +243,7 ＠＠ } gtk_clist_get_pixmap (GTK_CLIST (XGTK_OBJECT (clist)->object), - XINT (row), XINT (column), + XFIXNUM (row), XFIXNUM (column), &pixmap, &mask); return (Fcons (pixmap ? build_gtk_boxed (pixmap, GTK_TYPE_GDK_WINDOW) : Qnil, ＠＠ -261,8 +261,8 ＠＠ guint8 spacing; CHECK_GTK_OBJECT (clist); - CHECK_INT (row); - CHECK_INT (column); + CHECK_FIXNUM (row); + CHECK_FIXNUM (column); if (!GTK_IS_CLIST (XGTK_OBJECT (clist)->object)) { ＠＠ -270,7 +270,7 ＠＠ } gtk_clist_get_pixtext (GTK_CLIST (XGTK_OBJECT (clist)->object), - XINT (row), XINT (column), &text, &spacing, + XFIXNUM (row), XFIXNUM (column), &text, &spacing, &pixmap, &mask); return (list3 (pixmap ? build_gtk_boxed (pixmap, GTK_TYPE_GDK_WINDOW) : Qnil, ＠＠ -312,9 +312,9 ＠＠ CHECK_GTK_OBJECT (obj); CHECK_STRING (string); - CHECK_INT (pos); + CHECK_FIXNUM (pos); - the_pos = XINT (pos); + the_pos = XFIXNUM (pos); if (!GTK_IS_EDITABLE (XGTK_OBJECT (obj)->object)) { ＠＠ -326,7 +326,7 ＠＠ XSTRING_LENGTH (string), &the_pos); - return (make_int (the_pos)); + return (make_fixnum (the_pos)); } DEFUN ("gtk-pixmap-get", Fgtk_pixmap_get, 1, 1, 0, /* ＠＠ -359,19 +359,19 ＠＠ int i; CHECK_GTK_OBJECT (curve); - CHECK_INT (length); + CHECK_FIXNUM (length); if (!GTK_IS_CURVE (XGTK_OBJECT (curve)->object)) { wtaerror ("Object is not a GtkCurve", curve); } - vector = alloca_array (gfloat, XINT (length)); + vector = alloca_array (gfloat, XFIXNUM (length)); - gtk_curve_get_vector (GTK_CURVE (XGTK_OBJECT (curve)->object), XINT (length), vector); - lisp_vector = make_vector (XINT (length), Qnil); + gtk_curve_get_vector (GTK_CURVE (XGTK_OBJECT (curve)->object), XFIXNUM (length), vector); + lisp_vector = make_vector (XFIXNUM (length), Qnil); - for (i = 0; i < XINT (length); i++) + for (i = 0; i < XFIXNUM (length); i++) { XVECTOR_DATA (lisp_vector)[i] = make_float (vector[i]); } ＠＠ -454,7 +454,7 ＠＠ GTK_WIDGET (XGTK_OBJECT (child)->object), &expand, &fill, &pack_type); - return (list3 (expand ? Qt : Qnil, fill ? Qt : Qnil, make_int (pack_type))); + return (list3 (expand ? Qt : Qnil, fill ? Qt : Qnil, make_fixnum (pack_type))); } DEFUN ("gtk-widget-get-pointer", Fgtk_widget_get_pointer, 1, 1, 0, /* ＠＠ -472,7 +472,7 ＠＠ gtk_widget_get_pointer (GTK_WIDGET (XGTK_OBJECT (widget)->object), &x, &y); - return (Fcons (make_int (x), make_int (y))); + return (Fcons (make_fixnum (x), make_fixnum (y))); } /* This is called whenever an item with a GUI_ID associated with it is ＠＠ -561,7 +561,7 ＠＠ GTK_WIDGET (XGTK_OBJECT (icon)->object), GTK_SIGNAL_FUNC (__generic_toolbar_callback), STORE_LISP_IN_VOID (callback), - XINT (position)); + XFIXNUM (position)); } ＠＠ -589,7 +589,7 ＠＠ */ (toolbar, text, tooltip_text, tooltip_private_text, icon, callback, position, data)) { - CHECK_INT (position); + CHECK_FIXNUM (position); return (generic_toolbar_insert_item (toolbar,text,tooltip_text,tooltip_private_text,icon,callback,data,Qnil,position)); } ＠＠ -654,7 +654,7 ＠＠ if (!NILP (depth)) { - CHECK_INT (depth); + CHECK_FIXNUM (depth); } closure = Fcons (func, data); ＠＠ -674,7 +674,7 ＠＠ (NILP (childfirstp) ? gtk_ctree_post_recursive_to_depth : gtk_ctree_pre_recursive_to_depth) (GTK_CTREE (XGTK_OBJECT (ctree)->object), NILP (node) ? NULL : (GtkCTreeNode *) XGTK_BOXED (node)->object, - XINT (depth), + XFIXNUM (depth), __emacs_gtk_ctree_recurse_internal, STORE_LISP_IN_VOID (closure)); } diff -r a0e81357194e -r 56144c8593a8 src/ui-gtk.c --- a/src/ui-gtk.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/ui-gtk.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -252,19 +252,19 ＠＠ if (NILP (Venumeration_info)) { - Venumeration_info = call2 (intern ("make-hashtable"), make_int (100), Qequal); + Venumeration_info = call2 (intern ("make-hashtable"), make_fixnum (100), Qequal); } while (vals && vals->value_name) { - assoc = Fcons (Fcons (intern (vals->value_nick), make_int (vals->value)), assoc); - assoc = Fcons (Fcons (intern (vals->value_name), make_int (vals->value)), assoc); + assoc = Fcons (Fcons (intern (vals->value_nick), make_fixnum (vals->value)), assoc); + assoc = Fcons (Fcons (intern (vals->value_name), make_fixnum (vals->value)), assoc); vals++; } assoc = Fnreverse (assoc); - Fputhash (make_int (the_type), assoc, Venumeration_info); + Fputhash (make_fixnum (the_type), assoc, Venumeration_info); } static void ＠＠ -693,7 +693,7 ＠＠ CHECK_FFI (func); CHECK_LIST (args); - n_args = XINT (Flength (args)); + n_args = XFIXNUM (Flength (args)); #ifdef XEMACS_IS_SMARTER_THAN_THE_PROGRAMMER /* #### I think this is too dangerous to enable by default. ＠＠ -709,14 +709,14 ＠＠ if (n_args > XFFI(func)->n_args) { return Fsignal (Qwrong_number_of_arguments, - list2 (func, make_int (n_args))); + list2 (func, make_fixnum (n_args))); } /* If they did not provide enough arguments, be nice and assume ** they wanted `nil' in there. */ for_append[0] = args; - for_append[1] = Fmake_list (make_int (XFFI(func)->n_args - n_args), Qnil); + for_append[1] = Fmake_list (make_fixnum (XFFI(func)->n_args - n_args), Qnil); args = Fappend (2, for_append); } ＠＠ -725,7 +725,7 ＠＠ { /* Signal an error if they do not pass in the correct # of arguments */ return Fsignal (Qwrong_number_of_arguments, - list2 (func, make_int (n_args))); + list2 (func, make_fixnum (n_args))); } #endif ＠＠ -1003,7 +1003,7 ＠＠ lisp_data = GET_LISP_FROM_VOID (data); - ungcpro_popup_callbacks (XINT (XCAR (lisp_data))); + ungcpro_popup_callbacks (XFIXNUM (XCAR (lisp_data))); } static void ＠＠ -1078,7 +1078,7 ＠＠ id = new_gui_id (); func = Fcons (cb_data, func); - func = Fcons (make_int (id), func); + func = Fcons (make_fixnum (id), func); gcpro_popup_callbacks (id, func); ＠＠ -1206,7 +1206,7 ＠＠ { invalid_argument ("Not a GTK type", type); } - return (make_int (GTK_FUNDAMENTAL_TYPE (t))); + return (make_fixnum (GTK_FUNDAMENTAL_TYPE (t))); } DEFUN ("gtk-object-type", Fgtk_object_type, 1, 1, 0, /* ＠＠ -1215,7 +1215,7 ＠＠ (object)) { CHECK_GTK_OBJECT (object); - return (make_int (GTK_OBJECT_TYPE (XGTK_OBJECT (object)->object))); + return (make_fixnum (GTK_OBJECT_TYPE (XGTK_OBJECT (object)->object))); } DEFUN ("gtk-describe-type", Fgtk_describe_type, 1, 1, 0, /* ＠＠ -1245,8 +1245,8 ＠＠ } else { - CHECK_INT (type); - t = XINT (type); + CHECK_FIXNUM (type); + t = XFIXNUM (type); } if (GTK_FUNDAMENTAL_TYPE (t) != GTK_TYPE_OBJECT) ＠＠ -1473,13 +1473,13 ＠＠ case GTK_TYPE_BOOL: return (GTK_VALUE_BOOL (*arg) ? Qt : Qnil); case GTK_TYPE_INT: - return (make_int (GTK_VALUE_INT (*arg))); + return (make_fixnum (GTK_VALUE_INT (*arg))); case GTK_TYPE_UINT: - return (make_int (GTK_VALUE_INT (*arg))); + return (make_fixnum (GTK_VALUE_INT (*arg))); case GTK_TYPE_LONG: /* I think these are wrong! */ - return (make_int (GTK_VALUE_INT (*arg))); + return (make_fixnum (GTK_VALUE_INT (*arg))); case GTK_TYPE_ULONG: /* I think these are wrong! */ - return (make_int (GTK_VALUE_INT (*arg))); + return (make_fixnum (GTK_VALUE_INT (*arg))); case GTK_TYPE_FLOAT: return (make_float (GTK_VALUE_FLOAT (*arg))); case GTK_TYPE_DOUBLE: ＠＠ -1583,19 +1583,19 ＠＠ } else { - CHECK_INT (obj); - GTK_VALUE_INT(*arg) = XINT (obj); + CHECK_FIXNUM (obj); + GTK_VALUE_INT(*arg) = XFIXNUM (obj); } break; case GTK_TYPE_LONG: case GTK_TYPE_ULONG: ABORT(); case GTK_TYPE_FLOAT: - CHECK_INT_OR_FLOAT (obj); + CHECK_FIXNUM_OR_FLOAT (obj); GTK_VALUE_FLOAT(*arg) = extract_float (obj); break; case GTK_TYPE_DOUBLE: - CHECK_INT_OR_FLOAT (obj); + CHECK_FIXNUM_OR_FLOAT (obj); GTK_VALUE_DOUBLE(*arg) = extract_float (obj); break; case GTK_TYPE_STRING: ＠＠ -1761,7 +1761,7 ＠＠ id = new_gui_id (); obj = Fcons (Qnil, obj); /* Empty data */ - obj = Fcons (make_int (id), obj); + obj = Fcons (make_fixnum (id), obj); gcpro_popup_callbacks (id, obj); ＠＠ -1863,19 +1863,19 ＠＠ } else { - CHECK_INT (obj); - *(GTK_RETLOC_INT(*arg)) = XINT (obj); + CHECK_FIXNUM (obj); + *(GTK_RETLOC_INT(*arg)) = XFIXNUM (obj); } break; case GTK_TYPE_LONG: case GTK_TYPE_ULONG: ABORT(); case GTK_TYPE_FLOAT: - CHECK_INT_OR_FLOAT (obj); + CHECK_FIXNUM_OR_FLOAT (obj); *(GTK_RETLOC_FLOAT(*arg)) = extract_float (obj); break; case GTK_TYPE_DOUBLE: - CHECK_INT_OR_FLOAT (obj); + CHECK_FIXNUM_OR_FLOAT (obj); *(GTK_RETLOC_DOUBLE(*arg)) = extract_float (obj); break; case GTK_TYPE_STRING: ＠＠ -2041,7 +2041,7 ＠＠ id = new_gui_id (); obj = Fcons (Qnil, obj); /* Empty data */ - obj = Fcons (make_int (id), obj); + obj = Fcons (make_fixnum (id), obj); gcpro_popup_callbacks (id, obj); ＠＠ -2104,15 +2104,15 ＠＠ if (NILP (Venumeration_info)) { - Venumeration_info = call2 (intern ("make-hashtable"), make_int (100), Qequal); + Venumeration_info = call2 (intern ("make-hashtable"), make_fixnum (100), Qequal); } - alist = Fgethash (make_int (t), Venumeration_info, Qnil); + alist = Fgethash (make_fixnum (t), Venumeration_info, Qnil); if (NILP (alist)) { import_gtk_enumeration_internal (t); - alist = Fgethash (make_int (t), Venumeration_info, Qnil); + alist = Fgethash (make_fixnum (t), Venumeration_info, Qnil); } return (alist); } ＠＠ -2135,9 +2135,9 ＠＠ invalid_argument ("Unknown value", obj); } - CHECK_INT (XCDR (value)); + CHECK_FIXNUM (XCDR (value)); - return (XINT (XCDR (value))); + return (XFIXNUM (XCDR (value))); } static guint ＠＠ -2176,10 +2176,10 ＠＠ while (!NILP (alist)) { - if (value & XINT (XCDR (XCAR (alist)))) + if (value & XFIXNUM (XCDR (XCAR (alist)))) { rval = Fcons (XCAR (XCAR (alist)), rval); - value &= ~(XINT (XCDR (XCAR (alist)))); + value &= ~(XFIXNUM (XCDR (XCAR (alist)))); } alist = XCDR (alist); } ＠＠ -2197,7 +2197,7 ＠＠ invalid_argument ("Unknown enumeration", build_cistring (gtk_type_name (t))); } - cell = Frassq (make_int (value), alist); + cell = Frassq (make_fixnum (value), alist); return (NILP (cell) ? Qnil : XCAR (cell)); } diff -r a0e81357194e -r 56144c8593a8 src/undo.c --- a/src/undo.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/undo.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -93,8 +93,8 ＠＠ saved again. */ b->undo_list = Fcons (Fcons (Qt, - Fcons (make_int ((b->modtime >> 16) & 0xffff), - make_int (b->modtime & 0xffff))), + Fcons (make_fixnum ((b->modtime >> 16) & 0xffff), + make_fixnum (b->modtime & 0xffff))), b->undo_list); } return 1; ＠＠ -120,17 +120,17 ＠＠ Lisp_Object elt; elt = XCAR (b->undo_list); if (CONSP (elt) - && INTP (XCAR (elt)) - && INTP (XCDR (elt)) - && XINT (XCDR (elt)) == beg) + && FIXNUMP (XCAR (elt)) + && FIXNUMP (XCDR (elt)) + && XFIXNUM (XCDR (elt)) == beg) { - XCDR (elt) = make_int (beg + length); + XCDR (elt) = make_fixnum (beg + length); return; } } - b->undo_list = Fcons (Fcons (make_int (beg), - make_int (beg + length)), + b->undo_list = Fcons (Fcons (make_fixnum (beg), + make_fixnum (beg + length)), b->undo_list); } ＠＠ -151,17 +151,17 ＠＠ && NILP (XCAR (b->undo_list))); if (BUF_PT (b) == beg + length) - sbeg = make_int (-beg); + sbeg = make_fixnum (-beg); else - sbeg = make_int (beg); + sbeg = make_fixnum (beg); /* If we are just after an undo boundary, and point wasn't at start of deleted range, record where it was. */ if (at_boundary && BUFFERP (last_point_position_buffer) && b == XBUFFER (last_point_position_buffer) - && last_point_position != XINT (sbeg)) - b->undo_list = Fcons (make_int (last_point_position), b->undo_list); + && last_point_position != XFIXNUM (sbeg)) + b->undo_list = Fcons (make_fixnum (last_point_position), b->undo_list); b->undo_list = Fcons (Fcons (make_string_from_buffer (b, beg, length), ＠＠ -222,8 +222,8 ＠＠ if (!undo_prelude (b, 1)) return; - lbeg = make_int (beg); - lend = make_int (beg + length); + lbeg = make_fixnum (beg); + lend = make_fixnum (beg + length); entry = Fcons (Qnil, Fcons (prop, Fcons (value, Fcons (lbeg, lend)))); b->undo_list = Fcons (entry, b->undo_list); } ＠＠ -370,8 +370,8 ＠＠ list = Fcdr (list); #endif - CHECK_INT (count); - arg = XINT (count); + CHECK_FIXNUM (count); + arg = XFIXNUM (count); next = Qnil; GCPRO2 (next, list); ＠＠ -393,10 +393,10 ＠＠ if (NILP (next)) break; /* Handle an integer by setting point to that value. */ - else if (INTP (next)) + else if (FIXNUMP (next)) BUF_SET_PT (current_buffer, charbpos_clip_to_bounds (BUF_BEGV (current_buffer), - XINT (next), + XFIXNUM (next), BUF_ZV (current_buffer))); else if (CONSP (next)) { ＠＠ -411,8 +411,8 ＠＠ if (!CONSP (cdr)) goto rotten; high = XCAR (cdr); low = XCDR (cdr); - if (!INTP (high) || !INTP (low)) goto rotten; - mod_time = (XINT (high) << 16) + XINT (low); + if (!FIXNUMP (high) || !FIXNUMP (low)) goto rotten; + mod_time = (XFIXNUM (high) << 16) + XFIXNUM (low); /* If this records an obsolete save (not matching the actual disk file) then don't mark unmodified. */ ＠＠ -434,7 +434,7 ＠＠ start = Fcar (cdr); end = Fcar (Fcdr (cdr)); - if (!INTP (start) || !INTP (end)) + if (!FIXNUMP (start) || !FIXNUMP (end)) goto rotten; Fset_extent_endpoints (extent_obj, start, end, Fcurrent_buffer ()); ＠＠ -455,23 +455,23 ＠＠ Fput_text_property (beg, end, prop, val, Qnil); } #endif /* FSFmacs */ - else if (INTP (car) && INTP (cdr)) + else if (FIXNUMP (car) && FIXNUMP (cdr)) { /* Element (BEG . END) means range was inserted. */ - if (XINT (car) < BUF_BEGV (current_buffer) - || XINT (cdr) > BUF_ZV (current_buffer)) + if (XFIXNUM (car) < BUF_BEGV (current_buffer) + || XFIXNUM (cdr) > BUF_ZV (current_buffer)) signal_error (Qinvalid_operation, "Changes to be undone are outside visible portion of buffer", Qunbound); /* Set point first thing, so that undoing this undo does not send point back to where it is now. */ Fgoto_char (car, Qnil); Fdelete_region (car, cdr, Qnil); } - else if (STRINGP (car) && INTP (cdr)) + else if (STRINGP (car) && FIXNUMP (cdr)) { /* Element (STRING . POS) means STRING was deleted. */ Lisp_Object membuf = car; - int pos = XINT (cdr); + int pos = XFIXNUM (cdr); if (pos < 0) { diff -r a0e81357194e -r 56144c8593a8 src/unicode.c --- a/src/unicode.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/unicode.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1139,7 +1139,7 ＠＠ (-1 == (i = get_free_codepoint(Vcurrent_jit_charset)))) { Ibyte setname[32]; - int number_of_jit_charsets = XINT (Vnumber_of_jit_charsets); + int number_of_jit_charsets = XFIXNUM (Vnumber_of_jit_charsets); Ascbyte last_jit_charset_final = XCHAR (Vlast_jit_charset_final); /* This final byte shit is, umm, not that cool. */ ＠＠ -1159,8 +1159,8 ＠＠ sidesteps the fact that our internal character -> Unicode mapping is not stable from one invocation to the next. */ nconc2 (list2(Qencode_as_utf_8, Qt), - nconc2 (list6(Qcolumns, make_int(1), Qchars, make_int(96), - Qdimension, make_int(2)), + nconc2 (list6(Qcolumns, make_fixnum(1), Qchars, make_fixnum(96), + Qdimension, make_fixnum(2)), list6(Qregistries, Qunicode_registries, Qfinal, make_char(last_jit_charset_final), /* This CCL program is initialised in ＠＠ -1169,7 +1169,7 ＠＠ /* Record for the Unicode infrastructure that we've created this character set. */ - Vnumber_of_jit_charsets = make_int (number_of_jit_charsets + 1); + Vnumber_of_jit_charsets = make_fixnum (number_of_jit_charsets + 1); Vlast_jit_charset_final = make_char (last_jit_charset_final + 1); i = get_free_codepoint(Vcurrent_jit_charset); ＠＠ -1370,9 +1370,9 ＠＠ CHECK_CHAR (character); - check_integer_range (code, Qzero, make_integer (EMACS_INT_MAX)); - - unicode = XINT (code); + check_integer_range (code, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); + + unicode = XFIXNUM (code); ichar = XCHAR (character); charset = ichar_charset (ichar); ＠＠ -1408,7 +1408,7 ＠＠ { CHECK_CHAR (character); #ifdef MULE - return make_int (ichar_to_unicode (XCHAR (character))); + return make_fixnum (ichar_to_unicode (XCHAR (character))); #else return Fchar_to_int (character); #endif /* MULE */ ＠＠ -1446,8 +1446,8 ＠＠ int lbs[NUM_LEADING_BYTES]; int c; - check_integer_range (code, Qzero, make_integer (EMACS_INT_MAX)); - c = XINT (code); + check_integer_range (code, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); + c = XFIXNUM (code); { EXTERNAL_LIST_LOOP_2 (elt, charsets) Fget_charset (elt); ＠＠ -1472,7 +1472,7 ＠＠ return make_char (ret); } #else - check_integer_range (code, Qzero, make_integer (EMACS_INT_MAX)); + check_integer_range (code, Qzero, make_integer (MOST_POSITIVE_FIXNUM)); return Fint_to_char (code); #endif /* MULE */ } ＠＠ -1531,18 +1531,18 ＠＠ charset = Fget_charset (charset); if (!NILP (start)) { - CHECK_INT (start); - st = XINT (start); + CHECK_FIXNUM (start); + st = XFIXNUM (start); } if (!NILP (end)) { - CHECK_INT (end); - en = XINT (end); + CHECK_FIXNUM (end); + en = XFIXNUM (end); } if (!NILP (offset)) { - CHECK_INT (offset); - of = XINT (offset); + CHECK_FIXNUM (offset); + of = XFIXNUM (offset); } if (!LISTP (flags)) ＠＠ -2892,14 +2892,14 ＠＠ if (p == pend) break; cend = itext_ichar (p); - Fput_range_table (make_int (c), make_int (cend), value, + Fput_range_table (make_fixnum (c), make_fixnum (cend), value, rtab); INC_IBYTEPTR (p); } else { - Fput_range_table (make_int (c), make_int (c), value, rtab); + Fput_range_table (make_fixnum (c), make_fixnum (c), value, rtab); } } } ＠＠ -2957,7 +2957,7 ＠＠ /* It's okay to call Lisp here, the only non-stack object we may have allocated up to this point is skip_chars_range_table, and that's reachable from its entry in Vfixed_width_query_ranges_cache. */ - call3 (Qquery_coding_clear_highlights, make_int (pos), make_int (end), + call3 (Qquery_coding_clear_highlights, make_fixnum (pos), make_fixnum (end), wrap_buffer (buf)); } ＠＠ -3008,7 +3008,7 ＠＠ { Ichar ch = BYTE_BUF_FETCH_CHAR (buf, pos_byte); if ((ch < 0x100 ? 1 : - (!EQ (Qnil, Fget_range_table (make_int (ch), skip_chars_range_table, + (!EQ (Qnil, Fget_range_table (make_fixnum (ch), skip_chars_range_table, Qnil))))) { pos++; ＠＠ -3062,8 +3062,8 ＠＠ fail_range_end = pos; - Fput_range_table (make_int (fail_range_start), - make_int (fail_range_end), + Fput_range_table (make_fixnum (fail_range_start), + make_fixnum (fail_range_end), (previous_failed_reason == query_coding_unencodable ? Qunencodable : Qinvalid_sequence), ＠＠ -3073,12 +3073,12 ＠＠ if (flags & QUERY_METHOD_HIGHLIGHT) { Lisp_Object extent - = Fmake_extent (make_int (fail_range_start), - make_int (fail_range_end), + = Fmake_extent (make_fixnum (fail_range_start), + make_fixnum (fail_range_end), wrap_buffer (buf)); Fset_extent_priority - (extent, make_int (2 + mouse_highlight_priority)); + (extent, make_fixnum (2 + mouse_highlight_priority)); Fset_extent_face (extent, Qquery_coding_warning_face); } } ＠＠ -3207,7 +3207,7 ＠＠ #ifdef MULE staticpro (&Vnumber_of_jit_charsets); - Vnumber_of_jit_charsets = make_int (0); + Vnumber_of_jit_charsets = make_fixnum (0); staticpro (&Vlast_jit_charset_final); Vlast_jit_charset_final = make_char (0x30); staticpro (&Vcharset_descr); diff -r a0e81357194e -r 56144c8593a8 src/win32.c --- a/src/win32.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/win32.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -350,8 +350,8 ＠＠ LISP_LOCAL_FILE_FORMAT_MAYBE_URL_TO_TSTR (document, doc); ret = (int) qxeShellExecute (NULL, opext, doc, parmext, path, - (INTP (show_flag) ? - XINT (show_flag) : SW_SHOWDEFAULT)); + (FIXNUMP (show_flag) ? + XFIXNUM (show_flag) : SW_SHOWDEFAULT)); } if (ret <= 32) diff -r a0e81357194e -r 56144c8593a8 src/window-impl.h --- a/src/window-impl.h Sat Oct 08 12:26:09 2011 +0100 +++ b/src/window-impl.h Sun Oct 09 09:51:57 2011 +0100 ＠＠ -270,12 +270,12 ＠＠ #define MODELINE_OFF_SHADOW_THICKNESS_ADJUSTED(win) \ abs ((!WINDOW_HAS_MODELINE_P (win) \ - ? ((XINT (win->modeline_shadow_thickness) > 1) \ - ? XINT (win->modeline_shadow_thickness) - 1 \ - : ((XINT (win->modeline_shadow_thickness) < -1) \ - ? XINT (win->modeline_shadow_thickness) + 1 \ - : XINT (win->modeline_shadow_thickness))) \ -: XINT (win->modeline_shadow_thickness))) + ? ((XFIXNUM (win->modeline_shadow_thickness) > 1) \ + ? XFIXNUM (win->modeline_shadow_thickness) - 1 \ + : ((XFIXNUM (win->modeline_shadow_thickness) < -1) \ + ? XFIXNUM (win->modeline_shadow_thickness) + 1 \ + : XFIXNUM (win->modeline_shadow_thickness))) \ +: XFIXNUM (win->modeline_shadow_thickness))) #define MODELINE_SHADOW_THICKNESS(win) \ (MODELINE_OFF_SHADOW_THICKNESS_ADJUSTED (win) > 10 \ diff -r a0e81357194e -r 56144c8593a8 src/window.c --- a/src/window.c Sat Oct 08 12:26:09 2011 +0100 +++ b/src/window.c Sun Oct 09 09:51:57 2011 +0100 ＠＠ -1031,11 +1031,11 ＠＠ if (FRAME_WIN_P (XFRAME (WINDOW_FRAME (w)))) return - XINT (w->vertical_divider_line_width) - + 2 * XINT (w->vertical_divider_spacing) - + 2 * abs (XINT (w->vertical_divider_shadow_thickness)); + XFIXNUM (w->vertical_divider_line_width) + + 2 * XFIXNUM (w->vertical_divider_spacing) + + 2 * abs (XFIXNUM (w->vertical_divider_shadow_thickness)); else - return XINT (w->vertical_divider_line_width) == 0 ? 0 : 1; + return XFIXNUM (w->vertical_divider_line_width) == 0 ? 0 : 1; } int ＠＠ -1049,7 +1049,7 ＠＠ /* #### when does NILP (w->buffer) happen? */ return 0; - return XINT (w->scrollbar_width); + return XFIXNUM (w->scrollbar_width); #else return 0; #endif /* HAVE_SCROLLBARS */ ＠＠ -1068,7 +1068,7 ＠＠ || !window_truncation_on (w)) return 0; - return XINT (w->scrollbar_height); + return XFIXNUM (w->scrollbar_height); #else return 0; #endif /* HAVE_SCROLLBARS */ ＠＠ -1167,8 +1167,8 ＠＠ return 0; window = wrap_window (w); - margin_cwidth = (left_margin ? XINT (w->left_margin_width) : - XINT (w->right_margin_width)); + margin_cwidth = (left_margin ? XFIXNUM (w->left_margin_width) : + XFIXNUM (w->right_margin_width)); default_face_width_and_height (window, &font_width, 0); ＠＠ -1176,7 +1176,7 ＠＠ subtract its width from the space available for the right margin. */ if (!left_margin) - window_cwidth -= XINT (w->left_margin_width); + window_cwidth -= XFIXNUM (w->left_margin_width); /* The margin cannot be wider than the window is. We allow the value to be bigger since it is possible for the user to enlarge ＠＠ -1485,8 +1485,8 ＠＠ posint = BUF_PT (buf); else { - CHECK_INT_COERCE_MARKER (pos); - posint = XINT (pos); + CHECK_FIXNUM_COERCE_MARKER (pos); + posint = XFIXNUM (pos); } if (posint < top || posint > BUF_ZV (buf)) ＠＠ -1573,7 +1573,7 ＠＠ */ (window)) { - return make_int (window_char_height (decode_window (window), 1)); + return make_fixnum (window_char_height (decode_window (window), 1)); } DEFUN ("window-displayed-height", Fwindow_displayed_height, 0, 1, 0, /* ＠＠ -1587,7 +1587,7 ＠＠ */ (window)) { - return make_int (window_displayed_height (decode_window (window))); + return make_fixnum (window_displayed_height (decode_window (window))); } DEFUN ("window-pixel-height", Fwindow_pixel_height, 0, 1, 0, /* ＠＠ -1596,7 +1596,7 ＠＠ */ (window)) { - return make_int (window_pixel_height (decode_window (window))); + return make_fixnum (window_pixel_height (decode_window (window))); } DEFUN ("window-text-area-height", Fwindow_text_area_height, 0, 1, 0, /* ＠＠ -1609,7 +1609,7 ＠＠ */ (window)) { - return make_int (window_char_height (decode_window (window), 0)); + return make_fixnum (window_char_height (decode_window (window), 0)); } DEFUN ("window-text-area-pixel-height", ＠＠ -1622,7 +1622,7 ＠＠ { struct window *w = decode_window (window); - return make_int (WINDOW_TEXT_HEIGHT (w)); + return make_fixnum (WINDOW_TEXT_HEIGHT (w)); } DEFUN ("window-displayed-text-pixel-height", ＠＠ -1670,12 +1670,12 ＠＠ line = Dynarr_atp (cache, i)->height; if (height + line > hlimit) - return make_int (!NILP (noclipped) ? height : hlimit); + return make_fixnum (!NILP (noclipped) ? height : hlimit); height += line; if (height == hlimit || Dynarr_atp (cache, i)->end >= eobuf) - return make_int (height); + return make_fixnum (height); } /* get here => need more cache lines. try again. */ ＠＠ -1685,7 +1685,7 ＠＠ needed += ((hlimit - height)*(nelt - elt) + height-1)/height + 3; } - RETURN_NOT_REACHED(make_int (0)); /* shut up compiler */ + RETURN_NOT_REACHED(make_fixnum (0)); /* shut up compiler */ } DEFUN ("window-width", Fwindow_width, 0, 1, 0, /* ＠＠ -1696,7 +1696,7 ＠＠ */ (window)) { - return make_int (window_char_width (decode_window (window), 0)); + return make_fixnum (window_char_width (decode_window (window), 0)); } DEFUN ("window-full-width", Fwindow_full_width, 0, 1, 0, /* ＠＠ -1706,7 +1706,7 ＠＠ */ (window)) { - return make_int (window_char_width (decode_window (window), 1)); + return make_fixnum (window_char_width (decode_window (window), 1)); } DEFUN ("window-pixel-width", Fwindow_pixel_width, 0, 1, 0, /* ＠＠ -1714,7 +1714,7 ＠＠ */ (window)) { - return make_int (decode_window (window)->pixel_width); + return make_fixnum (decode_window (window)->pixel_width); } DEFUN ("window-text-area-pixel-width", ＠＠ -1727,7 +1727,7 ＠＠ { struct window *w = decode_window (window); - return make_int (WINDOW_TEXT_WIDTH (w)); + return make_fixnum (WINDOW_TEXT_WIDTH (w)); } DEFUN ("window-hscroll", Fwindow_hscroll, 0, 1, 0, /* ＠＠ -1735,7 +1735,7 ＠＠ */ (window)) { - return make_int (decode_window (window)->hscroll); + return make_fixnum (decode_window (window)->hscroll); } DEFUN ("modeline-hscroll", Fmodeline_hscroll, 0, 1, 0, /* ＠＠ -1746,7 +1746,7 ＠＠ { struct window *w = decode_window (window); - return (WINDOW_HAS_MODELINE_P (w)) ? make_int ((int) w->modeline_hscroll) : + return (WINDOW_HAS_MODELINE_P (w)) ? make_fixnum ((int) w->modeline_hscroll) : Qnil; } ＠＠ -1764,14 +1764,14 ＠＠ { Charcount ncols; - CHECK_INT (ncol); - ncols = (XINT (ncol) <= 0) ? 0 : (Charcount) XINT (ncol); + CHECK_FIXNUM (ncol); + ncols = (XFIXNUM (ncol) <= 0) ? 0 : (Charcount) XFIXNUM (ncol); if (ncols != w->modeline_hscroll) { MARK_MODELINE_CHANGED; w->modeline_hscroll = ncols; } - return make_int ((int) ncols); + return make_fixnum ((int) ncols); } return Qnil; ＠＠ -1786,8 +1786,8 ＠＠ struct window *w; int ncols; - CHECK_INT (ncol); - ncols = XINT (ncol); + CHECK_FIXNUM (ncol); + ncols = XFIXNUM (ncol); if (ncols < 0) ncols = 0; w = decode_window (window); if (w->hscroll != ncols) ＠＠ -1811,10 +1811,10 ＠＠ int left = w->pixel_left - FRAME_PANED_LEFT_EDGE (f); int top = w->pixel_top - FRAME_PANED_TOP_EDGE (f); - return list4 (make_int (left), - make_int (top), - make_int (left + w->pixel_width), - make_int (top + w->pixel_height)); + return list4 (make_fixnum (left), + make_fixnum (top), + make_fixnum (left + w->pixel_width), + make_fixnum (top + w->pixel_height)); } DEFUN ("window-text-area-pixel-edges", ＠＠ -1833,10 +1833,10 ＠＠ int right = WINDOW_WIDTH (w) - window_right_gutter_width (w, 0); int bottom = WINDOW_HEIGHT (w) - window_bottom_gutter_height (w); - return list4 (make_int (left), - make_int (top), - make_int (right), - make_int (bottom)); + return list4 (make_fixnum (left), + make_fixnum (top), + make_fixnum (right), + make_fixnum (bottom)); } DEFUN ("window-point", Fwindow_point, 0, 1, 0, /* ＠＠ -1891,12 +1891,12 ＠＠ Lisp_Object buf; buf = w->buffer; CHECK_BUFFER (buf); - return make_int (BUF_Z (XBUFFER (buf)) - w->window_end_pos[CURRENT_DISP]); + return make_fixnum (BUF_Z (XBUFFER (buf)) - w->window_end_pos[CURRENT_DISP]); } else { Charbpos startp = marker_position (w->start[CURRENT_DISP]); - return make_int (end_of_last_line (w, startp)); + return make_fixnum (end_of_last_line (w, startp)); } } ＠＠ -1919,7 +1919,7 ＠＠ if (dl->clip == 0) return Qnil; - return make_int (dl->ascent + dl->descent - dl->clip); + return make_fixnum (dl->ascent + dl->descent - dl->clip); } DEFUN ("set-window-point", Fset_window_point, 2, 2, 0, /* ＠＠ -1935,7 +1935,7 ＠＠ { struct window *w = decode_window (window); - CHECK_INT_COERCE_MARKER (pos); + CHECK_FIXNUM_COERCE_MARKER (pos); /* Don't dereference selected-window because there may not be one -- e.g. at startup */ ＠＠ -1958,7 +1958,7 ＠＠ { struct window *w = decode_window (window); - CHECK_INT_COERCE_MARKER (pos); + CHECK_FIXNUM_COERCE_MARKER (pos); set_marker_restricted (w->start[CURRENT_DISP], pos, w->buffer); /* this is not right, but much easier than doing what is right. */ /* w->start_at_line_beg = 0; */ ＠＠ -2053,7 +2053,7 ＠＠ Fputhash (buf, marker, w->saved_point_cache); } Fset_marker (marker, - selected ? make_int (BUF_PT (b)) : w->pointm[CURRENT_DISP], + selected ? make_fixnum (BUF_PT (b)) : w->pointm[CURRENT_DISP], buf); marker = Fgethash (buf, w->saved_last_window_start_cache, Qnil); ＠＠ -2754,9 +2754,9 ＠＠ int i; Lisp_Object w; - CHECK_INT (count); + CHECK_FIXNUM (count); w = Fselected_window (Qnil); - i = XINT (count); + i = XFIXNUM (count); while (i > 0) { ＠＠ -2926,8 +2926,8 ＠＠ || (dedicated_too ? 0 : !NILP (p->dedicated))) break; if (NILP (best_window) - || (XINT (XWINDOW (best_window)->use_time) - > XINT (p->use_time))) + || (XFIXNUM (XWINDOW (best_window)->use_time) + > XFIXNUM (p->use_time))) best_window = w; break; } ＠＠ -2943,8 +2943,8 ＠＠ if (XBUFFER (p->buffer) == XBUFFER (obj)) { if (NILP (best_window) - || (XINT (XWINDOW (best_window)->use_time) - < XINT (p->use_time))) + || (XFIXNUM (XWINDOW (best_window)->use_time) + < XFIXNUM (p->use_time))) best_window = w; } break; ＠＠ -3044,7 +3044,7 ＠＠ } } - return type == GET_BUFFER_WINDOW_COUNT ? make_int (count) : best_window; + return type == GET_BUFFER_WINDOW_COUNT ? make_fixnum (count) : best_window; } #if 0 /* not currently used */ ＠＠ -3057,7 +3057,7 ＠＠ frame = wrap_frame (f); buffer = wrap_buffer (b); - return XINT (window_loop (GET_BUFFER_WINDOW_COUNT, buffer, 0, frame, 1, + return XFIXNUM (window_loop (GET_BUFFER_WINDOW_COUNT, buffer, 0, frame, 1, Qnil)); } ＠＠ -3205,7 +3205,7 ＠＠ */ (window)) { - return make_int (window_left_margin_width (decode_window (window))); + return make_fixnum (window_left_margin_width (decode_window (window))); } DEFUN ("window-right-margin-pixel-width", Fwindow_right_margin_pixel_width, ＠＠ -3215,7 +3215,7 ＠＠ */ (window)) { - return make_int (window_right_margin_width (decode_window (window))); + return make_fixnum (window_right_margin_width (decode_window (window))); } DEFUN ("delete-other-windows", Fdelete_other_windows, 0, 1, "", /* ＠＠ -3261,7 +3261,7 ＠＠ if (new_start >= BUF_BEGV (b) && new_start <= BUF_ZV (b)) { - Fset_marker (w->start[CURRENT_DISP], make_int (new_start), + Fset_marker (w->start[CURRENT_DISP], make_fixnum (new_start), w->buffer); w->start_at_line_beg = beginning_of_line_p (b, new_start); } ＠＠ -3700,17 +3700,17 ＠＠ w->modeline_hscroll = 0; #if 0 /* pre point caches */ Fset_marker (w->pointm[CURRENT_DISP], - make_int (BUF_PT (XBUFFER (buffer))), + make_fixnum (BUF_PT (XBUFFER (buffer))), buffer); set_marker_restricted (w->start[CURRENT_DISP], - make_int (XBUFFER (buffer)->last_window_start), + make_fixnum (XBUFFER (buffer)->last_window_start), buffer); #else { Lisp_Object marker = Fgethash (buffer, w->saved_point_cache, Qnil); Lisp_Object newpoint = - !NILP (marker) ? make_int (marker_position (marker)) : - make_int (BUF_PT (XBUFFER (buffer))); + !NILP (marker) ? make_fixnum (marker_position (marker)) : + make_fixnum (BUF_PT (XBUFFER (buffer))); /* Previously, we had in here set-window-point, which did one of the following two, but not both. However, that could result in pointm being in a different buffer from the window's buffer! Probably ＠＠ -3724,8 +3724,8 ＠＠ marker = Fgethash (buffer, w->saved_last_window_start_cache, Qnil); set_marker_restricted (w->start[CURRENT_DISP], !NILP (marker) ? - make_int (marker_position (marker)) : - make_int (XBUFFER (buffer)->last_window_start), + make_fixnum (marker_position (marker)) : + make_fixnum (XBUFFER (buffer)->last_window_start), buffer); } #endif ＠＠ -3756,9 +3756,9 ＠＠ Fset_buffer (buffer); } if (NILP (XBUFFER (buffer)->display_count)) - XBUFFER (buffer)->display_count = make_int (1); + XBUFFER (buffer)->display_count = make_fixnum (1); else - XBUFFER (buffer)->display_count = make_int (1 + XINT (XBUFFER (buffer)->display_count)); + XBUFFER (buffer)->display_count = make_fixnum (1 + XFIXNUM (XBUFFER (buffer)->display_count)); XBUFFER (buffer)->display_time = Fcurrent_time(); return Qnil; } ＠＠ -3783,7 +3783,7 ＠＠ if (!NILP (w->hchild) || !NILP (w->vchild)) invalid_operation ("Trying to select non-leaf window", Qunbound); - w->use_time = make_int (++window_select_count); + w->use_time = make_fixnum (++window_select_count); if (EQ (window, old_selected_window)) return window; ＠＠ -3795,7 +3795,7 ＠＠ struct window *ow = XWINDOW (old_selected_window); Fset_marker (ow->pointm[CURRENT_DISP], - make_int (BUF_PT (XBUFFER (ow->buffer))), + make_fixnum (BUF_PT (XBUFFER (ow->buffer))), ow->buffer); MARK_WINDOWS_CHANGED (ow); ＠＠ -3863,9 +3863,9 ＠＠ w = XWINDOW (window); w->hscroll = 0; w->modeline_hscroll = 0; - set_marker_restricted (w->start[CURRENT_DISP], make_int (1), buf); - set_marker_restricted (w->pointm[CURRENT_DISP], make_int (1), buf); - set_marker_restricted (w->sb_point, make_int (1), buf); + set_marker_restricted (w->start[CURRENT_DISP], make_fixnum (1), buf); + set_marker_restricted (w->pointm[CURRENT_DISP], make_fixnum (1), buf); + set_marker_restricted (w->sb_point, make_fixnum (1), buf); } }  ＠＠ -3956,8 +3956,8 ＠＠ } else { - CHECK_INT (size); - csize = XINT (size); + CHECK_FIXNUM (size); + csize = XFIXNUM (size); if (!NILP (horflag)) psize = window_char_width_to_pixel_width (o, csize, 0); else ＠＠ -3974,10 +3974,10 ＠＠ if (NILP (horflag)) { if (csize < window_min_height) - signal_error (Qinvalid_operation, "Window height too small (after splitting)", make_int (csize)); + signal_error (Qinvalid_operation, "Window height too small (after splitting)", make_fixnum (csize)); if (csize + window_min_height > window_char_height (o, 1)) signal_error (Qinvalid_operation, "Window height too small (after splitting)", - make_int (window_char_height (o, 1) - csize)); + make_fixnum (window_char_height (o, 1) - csize)); if (NILP (o->parent) || NILP (XWINDOW (o->parent)->vchild)) { ＠＠ -3996,10 +3996,10 ＠＠ else { if (csize < window_min_width) - signal_error (Qinvalid_operation, "Window width too small (after splitting)", make_int (csize)); + signal_error (Qinvalid_operation, "Window width too small (after splitting)", make_fixnum (csize)); if (csize + window_min_width > window_char_width (o, 0)) signal_error (Qinvalid_operation, "Window width too small (after splitting)", - make_int (window_char_width (o, 0) - csize)); + make_fixnum (window_char_width (o, 0) - csize)); if (NILP (o->parent) || NILP (XWINDOW (o->parent)->hchild)) { ＠＠ -4074,8 +4074,8 ＠＠ */ (count, horizontalp, window)) { - CHECK_INT (count); - change_window_height (window, XINT (count), horizontalp, /* inpixels */ 0); + CHECK_FIXNUM (count); + change_window_height (window, XFIXNUM (count), horizontalp, /* inpixels */ 0); return Qnil; } ＠＠ -4087,8 +4087,8 ＠＠ */ (count, horizontalp, window)) { - CHECK_INT (count); - change_window_height (window, XINT (count), horizontalp, /* inpixels */ 1); + CHECK_FIXNUM (count); + change_window_height (window, XFIXNUM (count), horizontalp, /* inpixels */ 1); return Qnil; } ＠＠ -4100,8 +4100,8 ＠＠ */ (count, horizontalp, window)) { - CHECK_INT (count); - change_window_height (window, -XINT (count), horizontalp, /* inpixels */ 0); + CHECK_FIXNUM (count); + change_window_height (window, -XFIXNUM (count), horizontalp, /* inpixels */ 0); return Qnil; } ＠＠ -4113,8 +4113,8 ＠＠ */ (count, horizontalp, window)) { - CHECK_INT (count); - change_window_height (window, -XINT (count), horizontalp, /* inpixels */ 1); + CHECK_FIXNUM (count); + change_window_height (window, -XFIXNUM (count), horizontalp, /* inpixels */ 1); return Qnil; } ＠＠ -4537,7 +4537,7 ＠＠ struct display_line* dl; if (selected) - point = make_int (BUF_PT (b)); + point = make_fixnum (BUF_PT (b)); else { Charbpos pos = marker_position (w->pointm[CURRENT_DISP]); ＠＠ -4547,7 +4547,7 ＠＠ else if (pos > BUF_ZV (b)) pos = BUF_ZV (b); - point = make_int (pos); + point = make_fixnum (pos); } /* Always set force_start so that redisplay_window will run ＠＠ -4560,10 +4560,10 ＠＠ tem = Fpos_visible_in_window_p (point, window, Qnil); if (NILP (tem)) { - Fvertical_motion (make_int (-window_char_height (w, 0) / 2), + Fvertical_motion (make_fixnum (-window_char_height (w, 0) / 2), window, Qnil); Fset_marker (w->start[CURRENT_DISP], point, w->buffer); - w->start_at_line_beg = beginning_of_line_p (b, XINT (point)); + w->start_at_line_beg = beginning_of_line_p (b, XFIXNUM (point)); WINDOW_TEXT_TOP_CLIP (w) = 0; MARK_WINDOWS_CHANGED (w); } ＠＠ -4575,7 +4575,7 ＠＠ else { count = Fprefix_numeric_value (count); - value = XINT (count) * direction; + value = XFIXNUM (count) * direction; if (!value) return; /* someone just made a pointless call */ ＠＠ -4612,8 +4612,8 ＠＠ /* Determine parameters to test for partial line scrolling with. */ dla = window_display_lines (w, CURRENT_DISP); - if (INTP (Vwindow_pixel_scroll_increment)) - fheight = XINT (Vwindow_pixel_scroll_increment); + if (FIXNUMP (Vwindow_pixel_scroll_increment)) + fheight = XFIXNUM (Vwindow_pixel_scroll_increment); else if (!NILP (Vwindow_pixel_scroll_increment)) default_face_width_and_height (window, &fwidth, &fheight); ＠＠ -4659,14 +4659,14 ＠＠ } else { - set_marker_restricted (w->start[CURRENT_DISP], make_int (startp), + set_marker_restricted (w->start[CURRENT_DISP], make_fixnum (startp), w->buffer); w->force_start = 1; w->start_at_line_beg = beginning_of_line_p (b, startp); MARK_WINDOWS_CHANGED (w); - if (!point_would_be_visible (w, startp, XINT (point), 0)) - Fset_window_point (wrap_window (w), make_int (startp)); + if (!point_would_be_visible (w, startp, XFIXNUM (point), 0)) + Fset_window_point (wrap_window (w), make_fixnum (startp)); } } } ＠＠ -4709,7 +4709,7 ＠＠ } else { - set_marker_restricted (w->start[CURRENT_DISP], make_int (startp), + set_marker_restricted (w->start[CURRENT_DISP], make_fixnum (startp), w->buffer); w->force_start = 1; w->start_at_line_beg = beginning_of_line_p (b, startp); ＠＠ -4733,7 +4733,7 ＠＠ WINDOW_TEXT_TOP_CLIP (w) = (dl->ascent + fheight * value); } - if (!point_would_be_visible (w, startp, XINT (point), 0)) + if (!point_would_be_visible (w, startp, XFIXNUM (point), 0)) { Charbpos new_point; ＠＠ -4742,7 +4742,7 ＠＠ else new_point = start_of_last_line (w, startp); - Fset_window_point (wrap_window (w), make_int (new_point)); + Fset_window_point (wrap_window (w), make_fixnum (new_point)); } } } ＠＠ -4772,17 +4772,17 ＠＠ if (startp >= old_startp) startp = vmotion (w, old_startp, -1, NULL); - set_marker_restricted (w->start[CURRENT_DISP], make_int (startp), + set_marker_restricted (w->start[CURRENT_DISP], make_fixnum (startp), w->buffer); w->force_start = 1; w->start_at_line_beg = beginning_of_line_p (b, startp); MARK_WINDOWS_CHANGED (w); - if (!point_would_be_visible (w, startp, XINT (point), 0)) + if (!point_would_be_visible (w, startp, XFIXNUM (point), 0)) { Charbpos new_point = start_of_last_line (w, startp); - Fset_window_point (wrap_window (w), make_int (new_point)); + Fset_window_point (wrap_window (w), make_fixnum (new_point)); } } } ＠＠ -4905,9 +4905,9 ＠＠ struct window *w = XWINDOW (window); int n = (NILP (count) ? window_char_width (w, 0) - 2 : - XINT (Fprefix_numeric_value (count))); - - return Fset_window_hscroll (window, make_int (w->hscroll + n)); + XFIXNUM (Fprefix_numeric_value (count))); + + return Fset_window_hscroll (window, make_fixnum (w->hscroll + n)); } DEFUN ("scroll-right", Fscroll_right, 0, 1, "_P", /* ＠＠ -4925,9 +4925,9 ＠＠ struct window *w = XWINDOW (window); int n = (NILP (count) ? window_char_width (w, 0) - 2 : - XINT (Fprefix_numeric_value (count))); - - return Fset_window_hscroll (window, make_int (w->hscroll - n)); + XFIXNUM (Fprefix_numeric_value (count))); + + return Fset_window_hscroll (window, make_fixnum (w->hscroll - n)); }  DEFUN ("center-to-window-line", Fcenter_to_window_line, 0, 2, "_P", /* ＠＠ -4947,11 +4947,11 ＠＠ else { n = Fprefix_numeric_value (n); - CHECK_INT (n); - startp = start_with_point_on_display_line (w, opoint, XINT (n)); + CHECK_FIXNUM (n); + startp = start_with_point_on_display_line (w, opoint, XFIXNUM (n)); } - Fset_marker (w->start[CURRENT_DISP], make_int (startp), w->buffer); + Fset_marker (w->start[CURRENT_DISP], make_fixnum (startp), w->buffer); w->start_at_line_beg = beginning_of_line_p (b, startp); w->force_start = 1; ＠＠ -4990,8 +4990,8 ＠＠ { int retval; - if (XINT (w->last_modified[CURRENT_DISP]) >= BUF_MODIFF (b) - && XINT (w->last_facechange[CURRENT_DISP]) >= BUF_FACECHANGE (b)) + if (XFIXNUM (w->last_modified[CURRENT_DISP]) >= BUF_MODIFF (b) + && XFIXNUM (w->last_facechange[CURRENT_DISP]) >= BUF_FACECHANGE (b)) { new_point = point_at_center (w, CURRENT_DISP, 0, 0); ＠＠ -5001,7 +5001,7 ＠＠ if (selected) BUF_SET_PT (b, new_point); else - Fset_window_point (window, make_int (new_point)); + Fset_window_point (window, make_fixnum (new_point)); retval = line_at_center (w, CURRENT_DISP, 0, 0); } ＠＠ -5023,19 +5023,19 ＠＠ if (selected) BUF_SET_PT (b, new_point); else - Fset_window_point (window, make_int (new_point)); + Fset_window_point (window, make_fixnum (new_point)); retval = line_at_center (w, CMOTION_DISP, start, BUF_PT (b)); } - return make_int (retval); + return make_fixnum (retval); } else { /* #### Is this going to work right when at eob? */ arg = Fprefix_numeric_value (arg); - if (XINT (arg) < 0) - arg = make_int (XINT (arg) + height); + if (XFIXNUM (arg) < 0) + arg = make_fixnum (XFIXNUM (arg) + height); } start = marker_position (w->start[CURRENT_DISP]); ＠＠ -5051,9 +5051,9 ＠＠ if (selected) BUF_SET_PT (b, new_point); else - Fset_window_point (window, make_int (new_point)); - - Fset_marker (w->start[CURRENT_DISP], make_int (new_point), + Fset_window_point (window, make_fixnum (new_point)); + + Fset_marker (w->start[CURRENT_DISP], make_fixnum (new_point), w->buffer); w->start_at_line_beg = beginning_of_line_p (b, new_point); w->force_start = 1; ＠＠ -5063,7 +5063,7 ＠＠ if (selected) BUF_SET_PT (b, start); else - Fset_window_point (window, make_int (start)); + Fset_window_point (window, make_fixnum (start)); } if (selected) ＠＠ -5073,9 +5073,9 ＠＠ int vpos; new_point = vmotion (XWINDOW (window), marker_position (w->pointm[CURRENT_DISP]), - XINT (arg), &vpos); - Fset_window_point (window, make_int (new_point)); - return make_int (vpos); + XFIXNUM (arg), &vpos); + Fset_window_point (window, make_fixnum (new_point)); + return make_fixnum (vpos); } } ＠＠ -5306,8 +5306,8 ＠＠ if (NILP (pos)) pos = Fwindow_point (window); - CHECK_INT (pos); - point = XINT (pos); + CHECK_FIXNUM (pos); + point = XFIXNUM (pos); if (Dynarr_length (dla) && Dynarr_begin (dla)->modeline) first_line = 1; ＠＠ -5369,7 +5369,7 ＠＠ if (!get_current_pixel_pos(window, pos, &w, &rb, &dl)) return Qnil; - return make_int (rb->xpos - WINDOW_LEFT (w)); + return make_fixnum (rb->xpos - WINDOW_LEFT (w)); } DEFUN ("current-pixel-row", Fcurrent_pixel_row, 0, 2, 0, /* ＠＠ -5392,7 +5392,7 ＠＠ if (!get_current_pixel_pos(window, pos, &w, &rb, &dl)) return Qnil; - return make_int (dl->ypos - dl->ascent - WINDOW_TOP (w)); + return make_fixnum (dl->ypos - dl->ascent - WINDOW_TOP (w)); }  ＠＠ -5657,7 +5657,7 ＠＠ which is probably what was expected. */ set_specifier_fallback (Vmodeline_shadow_thickness, list1 (Fcons (Qnil, Qzero))); - Fadd_spec_to_specifier (Vmodeline_shadow_thickness, make_int (2), + Fadd_spec_to_specifier (Vmodeline_shadow_thickness, make_fixnum (2), Qnil, Qnil, Qnil); set_specifier_caching (Vmodeline_shadow_thickness, offsetof (struct window, modeline_shadow_thickness), ＠＠ -5706,7 +5706,7 ＠＠ Vvertical_divider_shadow_thickness = Fmake_specifier (Qinteger); set_specifier_fallback (Vvertical_divider_shadow_thickness, list1 (Fcons (Qnil, Qzero))); - Fadd_spec_to_specifier (Vvertical_divider_shadow_thickness, make_int (2), + Fadd_spec_to_specifier (Vvertical_divider_shadow_thickness, make_fixnum (2), Qnil, Qnil, Qnil); set_specifier_caching (Vvertical_divider_shadow_thickness, offsetof (struct window, ＠＠ -5728,17 +5728,17 ＠＠ { Lisp_Object fb = Qnil; #ifdef HAVE_TTY - fb = Fcons (Fcons (list1 (Qtty), make_int (1)), fb); + fb = Fcons (Fcons (list1 (Qtty), make_fixnum (1)), fb); #endif #ifdef HAVE_GTK - fb = Fcons (Fcons (list1 (Qgtk), make_int (3)), fb); + fb = Fcons (Fcons (list1 (Qgtk), make_fixnum (3)), fb); #endif #ifdef HAVE_X_WINDOWS - fb = Fcons (Fcons (list1 (Qx), make_int (3)), fb); + fb = Fcons (Fcons (list1 (Qx), make_fixnum (3)), fb); #endif #ifdef HAVE_MS_WINDOWS /* #### This should be made magic and made to obey system settings */ - fb = Fcons (Fcons (list1 (Qmswindows), make_int (3)), fb); + fb = Fcons (Fcons (list1 (Qmswindows), make_fixnum (3)), fb); #endif set_specifier_fallback (Vvertical_divider_line_width, fb); } ＠＠ -5765,7 +5765,7 ＠＠ #ifdef HAVE_X_WINDOWS /* #### 3D dividers look great on MS Windows with spacing = 0. Should not the same value be the fallback under X? - kkm */ - fb = Fcons (Fcons (list1 (Qx), make_int (2)), fb); + fb = Fcons (Fcons (list1 (Qx), make_fixnum (2)), fb); #endif #ifdef HAVE_GTK fb = Fcons (Fcons (list1 (Qgtk), Qzero), fb); diff -r a0e81357194e -r 56144c8593a8 src/xemacs.def.in.in --- a/src/xemacs.def.in.in Sat Oct 08 12:26:09 2011 +0100 +++ b/src/xemacs.def.in.in Sun Oct 09 09:51:57 2011 +0100 ＠＠ -275,7 +275,7 ＠＠ Fthrow Fvector #ifdef XEMACS_DEFS_NEEDS_ERROR_CHECK_TYPES_DECLS -XINT_1 +XFIXNUM_1 #endif /* Exported variables */ ＠＠ -312,9 +312,9 ＠＠ Qconsp /* CHECK_CONS */ Qcritical /* QUIT, QUITP */ Qdelete -Qfixnump /* CHECK_INT */ +Qfixnump /* CHECK_FIXNUM */ Qfile_name /* Qdll_filename_encoding */ -Qintegerp /* CHECK_INT, CONCHECK_INT */ +Qintegerp /* CHECK_FIXNUM, CONCHECK_FIXNUM */ Qinvalid_argument Qnative Qnil _______________________________________________ XEmacs-Patches mailing list XEmacs-Patches(a)xemacs.org http://lists.xemacs.org/mailman/listinfo/xemacs-patches