changeset 5586:d8a11d5ebc9f

Merge refactored Xaw3d configure.ac.
author Stephen J. Turnbull <stephen@xemacs.org>
date Fri, 28 Oct 2011 23:52:26 +0900
parents d469c668462e (diff) 86d6adeb1cf4 (current diff)
children 3fde0e346ad7
files
diffstat 180 files changed, 4730 insertions(+), 3346 deletions(-) [+]
line wrap: on
line diff
--- a/lisp/ChangeLog	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/ChangeLog	Fri Oct 28 23:52:26 2011 +0900
@@ -1,3 +1,148 @@
+2011-10-17  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* startup.el (load-terminal-library):
+	Don't (getenv "TERM") here, call #'console-tty-terminal-type
+	instead, different gnuclient consoles can and should have
+	different terminal type function maps effective.
+
+2011-10-09  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* obsolete.el:
+	* obsolete.el (assq-delete-all):
+	* packages.el (package-provide):
+	* packages.el (package-suppress):
+	* mule/cyrillic.el ("Cyrillic-KOI8"):
+	* mule/cyrillic.el (koi8-u):
+	* mule/general-late.el (posix-charset-to-coding-system-hash):
+	* mule/latin.el:
+	* mule/latin.el (for):
+	* cl-extra.el:
+	* cl-extra.el (cl-extra):
+	* loadup.el (load-history):
+	Change any uses of #'remassq, #'remassoc and friends to calling
+	#'delete* with an appropriate key argument. Provide compatibility
+	implementations, mark them obsolete.
+
+2011-10-08  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* cl-macs.el:
+	* cl-macs.el (load-time-value):
+	* cl-macs.el (flet):
+	* cl-macs.el (labels):
+	* cl-macs.el (the):
+	* cl-macs.el (declare):
+	Move all these macros to the end of the file, since they're in
+	byte-compile-initial-macro-environment, and we don't want their
+	definitions to override that for the rest of the file during
+	byte-compilation. Happens not to matter right now, but avoids
+	surprises for anyone using the macros elsewhere in cl-macs down
+	the line.
+
+2011-10-08  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* bytecomp.el (byte-compile-initial-macro-environment):
+	In the compiler implementation of load-time-value, don't
+	byte-compile at macroexpansion time, delay that until
+	byte-compilation time, giving, e.g. labels a chance to do its
+	thing.
+
+2011-10-04  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* autoload.el (make-autoload):
+	Don't add arglist info to the autoload form's docstring if the
+	arglist info is already there.
+
+2011-10-04  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* bytecomp.el (byte-compile-funcall):
+	Correct a comment here, explaining why the optimizer doesn't
+	expand (funcall #'(lambda ...)) in some contexts with inline
+	labels, and why it's reasonable to do it here.
+
+2011-10-03  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* simple.el (handle-pre-motion-command-current-command-is-motion):
+	Implement #'keysyms-equal with #'labels + (declare (inline ...)),
+	instead of abusing macrolet to the same end.
+	* specifier.el (let-specifier):
+	* mule/mule-cmds.el (describe-language-environment):
+	* mule/mule-cmds.el (set-language-environment-coding-systems):
+	* mule/mule-x-init.el (x-use-halfwidth-roman-font):
+	* faces.el (Face-frob-property):
+	* keymap.el (key-sequence-list-description):
+	* lisp-mode.el (construct-lisp-mode-menu):
+	* loadhist.el (unload-feature):
+	* mouse.el (default-mouse-track-check-for-activation):
+	Declare various labels inline in dumped files when that reduces
+	the size of the dumped image. Declaring labels inline is normally
+	only worthwhile for inner loops and so on, but it's reasonable
+	exercise of the related code to have these changes in core.
+
+2011-10-03  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* bytecomp.el (byte-compile-funcall):
+	Sometimes the optimizer shirks its responsibility and doesn't
+	unfold a lambda when it should. Do this here, if optimization is
+	turned on; this makes inlining labels more consistent and
+	trustworthy.
+
+2011-10-02  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* bytecomp.el (byte-compile-initial-macro-environment):
+	Add #'declare to this, so it doesn't need to rely on
+	#'cl-compiling file to determine when we're byte-compiling.
+	Update #'labels to support declaring labels inline, as Common Lisp
+	requires.
+	* bytecomp.el (byte-compile-function-form):
+	Don't error if FUNCTION is quoting a non-lambda, non-symbol, just
+	return it.
+	* cl-extra.el (cl-macroexpand-all):
+	If a label name has been quoted, expand to the label placeholder
+	quoted with 'function. This allows the byte compiler to
+	distinguish between uses of the placeholder as data and uses in
+	contexts where it should be inlined.
+	* cl-macs.el:
+	* cl-macs.el (cl-do-proclaim):
+	When proclaming something as inline, if it is bound as a label,
+	don't modify the symbol's plist; instead, treat the first element
+	of its placeholder constant vector as a place to store compile
+	information.
+	* cl-macs.el (declare):
+	Leave processing declarations while compiling to the
+	implementation of #'declare in
+	byte-compile-initial-macro-environment.
+
+2011-09-25  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* files.el (binary-file-regexps):
+	Remove ELC files from this, many of them are escape-quoted, and
+	when opening them for viewing XEmacs should look at the coding
+	cookie and respect that.
+	* bytecomp.el (byte-compile-insert-header):
+	Always insert a coding cookie, now ELC files are no longer in
+	binary-file-regexps.
+
+2011-09-21  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* files.el (binary-file-regexps):
+	Update this, adding everything that maps to no-conversion or
+	no-conversion-multibyte in GNU's auto-mode-alist.
+	In particular, add PDFs, important given gnus' problem with them
+	of http://mid.gmane.org/m3r637lpm5.fsf@mikesoffice.com and the
+	associated thread, and Uwe's recent re-reporting of the same
+	problem.
+
+2011-09-21  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* select.el (select-convert-to-text):
+	* select.el (select-convert-to-utf-8-text):
+	Ignore extent information in these functions, other programs can't
+	do anything useful with it, and it actively interferes when
+	copying from an ERC buffer to external programs--
+	#'encode-coding-string complains that the string is read-only,
+	which is arguably in itself a separate problem, since it allocates
+	a new string there's no reason for it ever to throw that error.
+
 2011-09-11  Aidan Kehoe  <kehoea@parhasard.net>
 
 	* cl-macs.el (cl-defsubst-expand):
--- a/lisp/autoload.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/autoload.el	Fri Oct 28 23:52:26 2011 +0900
@@ -283,7 +283,11 @@
 	     (name (nth 1 form))
 	     (body (nthcdr (get car 'doc-string-elt) form))
 	     (doc (if (stringp (car body)) (pop body))))
-	(if (memq car '(defmacro defmacro* defun defun*))
+	(if (and (memq car '(defmacro defmacro* defun defun*))
+                 (not (and doc (save-match-data
+                                 (string-match
+                                  "[\n\t ]*\narguments: ?(\\(.*\\))\n?\\'"
+                                  doc)))))
 	    (let ((arglist (nth 2 form)))
 	      (setq doc (concat (or doc "")
 				"\n\narguments: "
--- a/lisp/bytecomp.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/bytecomp.el	Fri Oct 28 23:52:26 2011 +0900
@@ -494,17 +494,28 @@
 	   (if byte-compile-delete-errors
 	       form
 	     (funcall (cdr (symbol-function 'the)) type form))))
+    (declare
+     . ,#'(lambda (&rest specs)
+	    (while specs
+	      (if (listp cl-declare-stack) (push (car specs) cl-declare-stack))
+	      (cl-do-proclaim (pop specs) nil))))
     (load-time-value
-     . ,#'(lambda (form &optional read-only)
-            (let* ((gensym (gensym))
-                   (byte-compile-bound-variables
-                    (acons gensym byte-compile-global-bit
-                           byte-compile-bound-variables)))
-              (setq byte-compile-output-preface
-                    (byte-compile-top-level
-                     `(progn (setq ,gensym ,form) ,byte-compile-output-preface)
-                     t 'file))
-              `(symbol-value ',gensym))))
+     . ,(symbol-macrolet ((wrapper '#:load-time-value))
+          (put wrapper 'byte-compile
+               #'(lambda (form)
+                   (let* ((gensym (gensym))
+                          (byte-compile-bound-variables
+                           (acons gensym byte-compile-global-bit
+                                  byte-compile-bound-variables)))
+                     (setq byte-compile-output-preface
+                           (byte-compile-top-level
+                            `(progn
+                              (setq ,gensym (progn ,(second form)))
+                              ,byte-compile-output-preface)
+                            t 'file))
+                     (byte-compile-form `(symbol-value ',gensym) nil))))
+          #'(lambda (form &optional read-only)
+              (list wrapper form))))
     (labels
         . ,#'(lambda (bindings &rest body)
                (let* ((names (mapcar 'car bindings))
@@ -517,37 +528,116 @@
                       (placeholders
                        (mapcar #'(lambda (lambda)
                                    (make-byte-code (second lambda) "\xc0\x87"
-                                                   [42] 1))
+                                                   ;; This list is used for
+                                                   ;; the byte-optimize
+                                                   ;; property, if the
+                                                   ;; function is to be
+                                                   ;; inlined. See
+                                                   ;; cl-do-proclaim.
+                                                   (vector nil) 1))
                                lambdas))
                       (byte-compile-macro-environment
                        (pairlis names (mapcar
                                        #'(lambda (placeholder)
                                            `(lambda (&rest cl-labels-args)
+                                              ;; Be careful not to quote
+                                              ;; PLACEHOLDER, otherwise
+                                              ;; byte-optimize-funcall inlines
+                                              ;; it.
                                               (list* 'funcall ,placeholder
                                                      cl-labels-args)))
                                        placeholders)
                                 byte-compile-macro-environment))
                       (gensym (gensym)))
-                 (put gensym 'byte-compile-label-alist
-                      (pairlis placeholders
-                               (mapcar 'second (mapcar 'cl-macroexpand-all
-                                                       lambdas))))
-                 (put gensym 'byte-compile
-                      #'(lambda (form)
-                          (let* ((byte-compile-label-alist
-                                  (get (car form) 'byte-compile-label-alist)))
-                            (dolist (acons byte-compile-label-alist)
-                              (setf (cdr acons)
-                                    (byte-compile-lambda (cdr acons))))
-                            (byte-compile-body-do-effect
-                             (sublis byte-compile-label-alist (cdr form)
-                                     :test #'eq))
-                            (dolist (acons byte-compile-label-alist)
-                              (nsubst (cdr acons) (car acons)
-                                      byte-compile-label-alist :test #'eq
-                                      :descend-structures t)))))
-                 (cl-macroexpand-all (cons gensym body)
-                                     byte-compile-macro-environment))))
+                 (labels
+                     ((byte-compile-transform-labels (form names lambdas
+                                                      placeholders)
+                        (let* ((inline
+                                 (mapcan
+                                  #'(lambda (name placeholder lambda)
+                                      (and
+                                       (eq
+                                        (getf (aref
+                                               (compiled-function-constants
+                                                placeholder) 0)
+                                              'byte-optimizer)
+                                        'byte-compile-inline-expand)
+                                       `(((function ,placeholder)
+                                          ,(byte-compile-lambda lambda)
+                                          (function ,lambda)))))
+                                  names placeholders lambdas))
+                               (compiled
+                                (mapcar #'byte-compile-lambda 
+                                        (if (not inline)
+                                            lambdas
+                                          ;; See further down for the
+                                          ;; rationale of the sublis calls.
+                                          (sublis (pairlis
+                                                   (mapcar #'cadar inline)
+                                                   (mapcar #'third inline))
+                                                  (sublis
+                                                   (pairlis
+                                                    (mapcar #'car inline)
+                                                    (mapcar #'second inline))
+                                                   lambdas :test #'equal)
+                                                  :test #'eq))))
+                               elt)
+                          (mapc #'(lambda (placeholder function)
+                                    (nsubst function placeholder compiled
+                                            :test #'eq
+                                            :descend-structures t))
+                                placeholders compiled)
+                          (when inline
+                            (dolist (triad inline)
+                              (nsubst (setq elt (elt compiled
+                                                     (position (cadar triad)
+                                                               placeholders)))
+                                      (second triad) compiled :test #'eq
+                                      :descend-structures t)
+                              (setf (second triad) elt))
+                            ;; For inlined labels: first, replace uses of
+                            ;; the placeholder in places where it's not an
+                            ;; evident, explicit funcall (that is, where
+                            ;; it is not to be inlined) with the compiled
+                            ;; function:
+                            (setq form (sublis
+                                        (pairlis (mapcar #'car inline)
+                                                 (mapcar #'second inline))
+                                        form :test #'equal)
+                                  ;; Now replace uses of the placeholder
+                                  ;; where it is an evident funcall with the
+                                  ;; lambda, quoted as a function, to allow
+                                  ;; byte-optimize-funcall to do its
+                                  ;; thing. Note that the lambdas still have
+                                  ;; the placeholders, so there's no risk
+                                  ;; of recursive inlining.
+                                  form (sublis (pairlis
+                                                (mapcar #'cadar inline)
+                                                (mapcar #'third inline))
+                                               form :test #'eq)))
+                          (sublis (pairlis placeholders compiled) form
+                                  :test #'eq))))
+                   (put gensym 'byte-compile
+                        #'(lambda (form)
+                            (let* ((names (cadr (cl-pop2 form)))
+                                   (lambdas (mapcar #'cadr (cdr (pop form))))
+                                   (placeholders (cadr (pop form))))
+                              (byte-compile-body-do-effect
+                               (byte-compile-transform-labels form names
+                                                              lambdas
+                                                              placeholders)))))
+                   (put gensym 'byte-hunk-handler
+                        #'(lambda (form)
+                            (let* ((names (cadr (cl-pop2 form)))
+                                   (lambdas (mapcar #'cadr (cdr (pop form))))
+                                   (placeholders (cadr (pop form))))
+                              (byte-compile-file-form
+                               (cons 'progn
+                                     (byte-compile-transform-labels
+                                      form names lambdas placeholders))))))
+                   (cl-macroexpand-all `(,gensym ',names (list ,@lambdas)
+                                         ',placeholders ,@body)
+                                       byte-compile-macro-environment)))))
     (flet .
       ,#'(lambda (bindings &rest body)
            (let* ((names (mapcar 'car bindings))
@@ -1934,10 +2024,8 @@
      ";ELC"
      20
      "\000\000\000\n")
-    (when (not (eq (find-coding-system 'raw-text-unix)
-		   (find-coding-system buffer-file-coding-system)))
-      (insert (format ";;;###coding system: %s\n"
-		      (coding-system-name buffer-file-coding-system))))
+    (insert (format ";;;###coding system: %s\n"
+                    (coding-system-name buffer-file-coding-system)))
     (insert (format
 	     "\n(or %s\n    (error \"Loading this file requires %s\"))\n"
              (let ((print-readably t))
@@ -3701,10 +3789,9 @@
   (if (cddr form)
       (byte-compile-normal-call
        `(signal 'wrong-number-of-arguments '(function ,(length (cdr form)))))
-    (byte-compile-constant
-     (cond ((symbolp (nth 1 form))
-            (nth 1 form))
-           ((byte-compile-lambda (nth 1 form)))))))
+    (byte-compile-constant (if (eq 'lambda (car-safe (nth 1 form)))
+                               (byte-compile-lambda (nth 1 form))
+                             (nth 1 form)))))
 
 (defun byte-compile-insert (form)
   (cond ((null (cdr form))
@@ -4076,8 +4163,33 @@
            (byte-compile-constp (second form)))
       (byte-compile-callargs-warn (cons (cl-const-expr-val (second form))
                                         (nthcdr 2 form))))
-  (mapc 'byte-compile-form (cdr form))
-  (byte-compile-out 'byte-call (length (cdr (cdr form)))))
+  (if (and byte-optimize
+           (eq 'function (car-safe (cadr form)))
+           (eq 'lambda (car-safe (cadadr form)))
+	    (or
+	     (not (eq (setq form (cons (cadadr form) (cddr form)))
+		      (setq form (byte-compile-unfold-lambda form))))
+	     (prog1 nil (setq form `(funcall #',(car form) ,@(cdr form))))))
+      ;; The byte-compile part of the #'labels implementation, above,
+      ;; happens after macroexpansion and after the source optimizer has
+      ;; done its thing. When labels are to be made inline we can have code
+      ;; that looks like (funcall #'(lambda ...) ...), when the code that
+      ;; the optimizer saw looked like (funcall #<compiled-function ...>
+      ;; ...).
+      ;;
+      ;; So, the optimizer doesn't have the opportunity to transform the
+      ;; former to (let (...) ...), and it's reasonable to do that here (since
+      ;; the labels implementation doesn't change other code that would need
+      ;; running through the optimizer; the lambda itself has already been
+      ;; through the optimizer).
+      ;;
+      ;; Equally reasonable, and conceptually a bit clearer, would be to do
+      ;; the transformation to (funcall #'(lambda ...) ...) in the
+      ;; byte-optimizer, breaking most of the #'sublis calls out of the
+      ;; byte-compile method.
+      (byte-compile-form form)
+    (mapc 'byte-compile-form (cdr form))
+    (byte-compile-out 'byte-call (length (cdr (cdr form))))))
 
 
 (defun byte-compile-let (form)
--- a/lisp/cl-extra.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/cl-extra.el	Fri Oct 28 23:52:26 2011 +0900
@@ -619,8 +619,11 @@
                      (cl-macroexpand-all (nth 1 (nth 2 (nth 2 found))) env)
                    ;; It's an atom, almost certainly a compiled function;
                    ;; we're using the implementation of labels in
-                   ;; bytecomp.el.
-                  (nth 2 (nth 2 found)))
+                   ;; bytecomp.el. Quote it with FUNCTION so that code can
+                   ;; tell uses as data apart from the uses with funcall,
+                   ;; where it's unquoted. #### We should warn if (car form)
+                   ;; above is quote, rather than function.
+                   (list 'function (nth 2 (nth 2 found))))
 	       form))))
 	((memq (car form) '(defun defmacro))
 	 (list* (car form) (nth 1 form) (cl-macroexpand-body (cddr form) env)))
@@ -871,6 +874,30 @@
     (-1 (1- (length (format "%b" (- integer)))))
     (1 (length (format "%b" integer)))))
 
+;; These are here because labels and symbol-macrolet are not available in
+;; obsolete.el. They are, however, all marked as obsolete in that file.
+(symbol-macrolet ((not-nil '#:not-nil))
+  (labels ((car-or-not-nil (object)
+             (if (consp object) (car object) not-nil))
+           (cdr-or-not-nil (object)
+             (if (consp object) (cdr object) not-nil)))
+    (defalias 'remassoc
+      #'(lambda (key alist)
+         (delete* key alist :test #'equal
+                  :key (if key #'car-safe #'car-or-not-nil))))
+    (defalias 'remrassoc
+      #'(lambda (key alist)
+         (delete* key alist :test #'equal
+                  :key (if key #'cdr-safe #'cdr-or-not-nil))))
+    (defalias 'remrassq
+      #'(lambda (key alist)
+         (delete* key alist :test #'eq
+                  :key (if key #'cdr-safe #'cdr-or-not-nil))))
+    (defalias 'remassq
+      #'(lambda (key alist)
+         (delete* key alist :test #'eq
+                  :key (if key #'car-safe #'car-or-not-nil))))))
+
 (run-hooks 'cl-extra-load-hook)
 
 ;; XEmacs addition
--- a/lisp/cl-macs.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/cl-macs.el	Fri Oct 28 23:52:26 2011 +0900
@@ -621,12 +621,6 @@
 	     form)))
 	(t (eval form) form)))
 
-;;;###autoload
-(defmacro load-time-value (form &optional read-only)
-  "Like `progn', but evaluates the body at load time.
-The result of the body appears to the compiler as a quoted constant."
-  (list 'progn form))
-
 ;;; Conditional control structures.
 
 ;;;###autoload
@@ -1715,75 +1709,6 @@
 	      '(cl-progv-after))))
 
 ;;;###autoload
-(defmacro flet (functions &rest form)
-  "Make temporary function definitions.
-
-This is an analogue of `let' that operates on the function cell of FUNC
-rather than its value cell.  The FORMs are evaluated with the specified
-function definitions in place, then the definitions are undone (the FUNCs go
-back to their previous definitions, or lack thereof).  This is in
-contravention of Common Lisp, where `flet' makes a lexical, not a dynamic,
-function binding.
-
-Normally you should use `labels', not `flet'; `labels' does not have the
-problems caused by dynamic scope, is less expensive when byte-compiled, and
-allows lexical shadowing of functions with byte-codes and byte-compile
-methods, where `flet' will fail.  The byte-compiler will warn when this
-happens.
-
-If you need to shadow some existing function at run time, and that function
-has no associated byte code or compiler macro, then `flet' is appropriate.
-
-arguments: (((FUNCTION ARGLIST &body BODY) &rest FUNCTIONS) &body FORM)"
-  ;; XEmacs; leave warnings, errors and modifications of
-  ;; byte-compile-function-environment to the byte compiler. See
-  ;; byte-compile-initial-macro-environment in bytecomp.el.
-  (list*
-   'letf*
-   (mapcar
-    (function*
-     (lambda ((function . definition))
-       `((symbol-function ',function) 
-         ,(cons 'lambda (cdr (cl-transform-lambda definition function))))))
-    functions) form))
-
-;;;###autoload
-(defmacro labels (bindings &rest body)
-  "Make temporary function bindings.
-
-This is like `flet', except the bindings are lexical instead of dynamic.
-Unlike `flet', this macro is compliant with the Common Lisp standard with
-regard to the scope and extent of the function bindings.
-
-Each function may be called from within FORM, from within the BODY of the
-function itself (that is, recursively), and from any other function bodies
-in FUNCTIONS.
-
-Within FORM, to access the function definition of a bound function (for
-example, to pass it as a FUNCTION argument to `map'), quote its symbol name
-using `function'.
-
-arguments: (((FUNCTION ARGLIST &body BODY) &rest FUNCTIONS) &body FORM)
-"
-  ;; XEmacs; the byte-compiler has a much better implementation of `labels'
-  ;; in `byte-compile-initial-macro-environment' that is used in compiled
-  ;; code.
-  (let ((vars nil) (sets nil)
-        (byte-compile-macro-environment byte-compile-macro-environment))
-    (while bindings
-      (let ((var (gensym)))
-	(push var vars)
-	(push `#'(lambda ,@(cdr (cl-transform-lambda (cdar bindings)
-                                                     (caar bindings)))) sets)
-	(push var sets)
-	(push (list (car (pop bindings)) 'lambda '(&rest cl-labels-args)
-		       (list 'list* '(quote funcall) (list 'quote var)
-			     'cl-labels-args))
-		 byte-compile-macro-environment)))
-    (cl-macroexpand-all (list* 'lexical-let vars (cons (cons 'setq sets) body))
-			byte-compile-macro-environment)))
-
-;;;###autoload
 (defmacro* macrolet ((&rest macros) &body form)
   "Make temporary macro definitions.
 This is like `flet', but for macros instead of functions."
@@ -1938,20 +1863,6 @@
 
 ;;;###autoload
 (defmacro locally (&rest body) (cons 'progn body))
-;;;###autoload
-(defmacro the (type form)
-  "Assert that FORM gives a result of type TYPE, and return that result.
-
-TYPE is a Common Lisp type specifier.
-
-If macro expansion of a `the' form happens during byte compilation, and the
-byte compiler customization variable `byte-compile-delete-errors' is
-non-nil, `the' is equivalent to FORM without any type checks."
-  (if (cl-safe-expr-p form)
-      `(prog1 ,form (assert ,(cl-make-type-test form type) t))
-    (let ((saved (gensym)))
-      `(let ((,saved ,form))
-        (prog1 ,saved (assert ,(cl-make-type-test saved type) t))))))
 
 (defvar cl-proclaim-history t)    ; for future compilers
 (defvar cl-declare-stack t)       ; for future compilers
@@ -1969,18 +1880,38 @@
 
 	((eq (car-safe spec) 'inline)
 	 (while (setq spec (cdr spec))
-	   (or (memq (get (car spec) 'byte-optimizer)
-		     '(nil byte-compile-inline-expand))
-	       (error "%s already has a byte-optimizer, can't make it inline"
-		      (car spec)))
-	   (put (car spec) 'byte-optimizer 'byte-compile-inline-expand)))
-
+	   (let ((assq (cdr (assq (car spec) byte-compile-macro-environment))))
+	     (if (and (consp assq) (eq (nth 1 (nth 1 assq)) 'cl-labels-args)
+		      (atom (setq assq (nth 2 (nth 2 assq)))))
+		 ;; It's a label, and we're using the labels
+		 ;; implementation in bytecomp.el. Tell the compiler
+		 ;; to inline it, don't mark the symbol to be inlined
+		 ;; globally.
+		 (setf (getf (aref (compiled-function-constants assq) 0)
+                             'byte-optimizer)
+                       'byte-compile-inline-expand)
+	       (or (memq (get (car spec) 'byte-optimizer)
+			 '(nil byte-compile-inline-expand))
+		   (error
+		    "%s already has a byte-optimizer, can't make it inline"
+		    (car spec)))
+	       (put (car spec) 'byte-optimizer 'byte-compile-inline-expand)))))
 	((eq (car-safe spec) 'notinline)
 	 (while (setq spec (cdr spec))
-	   (if (eq (get (car spec) 'byte-optimizer)
-		   'byte-compile-inline-expand)
-	       (put (car spec) 'byte-optimizer nil))))
-
+	   (let ((assq (cdr (assq (car spec) byte-compile-macro-environment))))
+	     (if (and (consp assq) (eq (nth 1 (nth 1 assq)) 'cl-labels-args)
+		      (atom (setq assq (nth 2 (nth 2 assq)))))
+		 ;; It's a label, and we're using the labels
+		 ;; implementation in bytecomp.el. Tell the compiler
+		 ;; not to inline it.
+                 (if (eq 'byte-compile-inline-expand
+                         (getf (aref (compiled-function-constants assq) 0)
+                               'byte-optimizer))
+                     (remf (aref (compiled-function-constants assq) 0)
+                           'byte-optimizer))
+	       (if (eq (get (car spec) 'byte-optimizer)
+		       'byte-compile-inline-expand)
+		   (put (car spec) 'byte-optimizer nil))))))
 	((eq (car-safe spec) 'optimize)
 	 (let ((speed (assq (nth 1 (assq 'speed (cdr spec)))
 			    '((0 . nil) (1 . t) (2 . t) (3 . t))))
@@ -2012,16 +1943,6 @@
   (while p (cl-do-proclaim (pop p) t))
   (setq cl-proclaims-deferred nil))
 
-;;;###autoload
-(defmacro declare (&rest specs)
-  (if (cl-compiling-file)
-      (while specs
-	(if (listp cl-declare-stack) (push (car specs) cl-declare-stack))
-	(cl-do-proclaim (pop specs) nil)))
-  nil)
-
-
-
 ;;; Generalized variables.
 
 ;;;###autoload
@@ -3940,16 +3861,108 @@
 (proclaim '(inline cl-set-elt))
 
 ;;; Things that are side-effect-free.  Moved to byte-optimize.el
-;(mapcar (function (lambda (x) (put x 'side-effect-free t)))
-;	'(oddp evenp signum last butlast ldiff pairlis gcd lcm
-;	  isqrt floor* ceiling* truncate* round* mod* rem* subseq
-;	  list-length get* getf))
+;[...]
 
 ;;; Things that are side-effect-and-error-free.  Moved to byte-optimize.el
-;(mapcar (function (lambda (x) (put x 'side-effect-free 'error-free)))
-;	'(eql list* subst acons equalp random-state-p
-;	  copy-tree sublis))
-
+;[...]
+
+;; XEmacs; move the following macros to the end of this file, since the
+;; override the versions in byte-compile-initial-macro-environment for the
+;; duration of the file they're defined in.
+
+;;;###autoload
+(defmacro the (type form)
+  "Assert that FORM gives a result of type TYPE, and return that result.
+
+TYPE is a Common Lisp type specifier.
+
+If macro expansion of a `the' form happens during byte compilation, and the
+byte compiler customization variable `byte-compile-delete-errors' is
+non-nil, `the' is equivalent to FORM without any type checks."
+  (if (cl-safe-expr-p form)
+      `(prog1 ,form (assert ,(cl-make-type-test form type) t))
+    (let ((saved (gensym)))
+      `(let ((,saved ,form))
+        (prog1 ,saved (assert ,(cl-make-type-test saved type) t))))))
+
+;;;###autoload
+(defmacro declare (&rest specs)
+  nil)
+
+;;;###autoload
+(defmacro load-time-value (form &optional read-only)
+  "Like `progn', but evaluates the body at load time.
+The result of the body appears to the compiler as a quoted constant."
+  (list 'progn form))
+
+;;;###autoload
+(defmacro labels (bindings &rest body)
+  "Make temporary function bindings.
+
+This is like `flet', except the bindings are lexical instead of dynamic.
+Unlike `flet', this macro is compliant with the Common Lisp standard with
+regard to the scope and extent of the function bindings.
+
+Each function may be called from within FORM, from within the BODY of the
+function itself (that is, recursively), and from any other function bodies
+in FUNCTIONS.
+
+Within FORM, to access the function definition of a bound function (for
+example, to pass it as a FUNCTION argument to `map'), quote its symbol name
+using `function'.
+
+arguments: (((FUNCTION ARGLIST &body BODY) &rest FUNCTIONS) &body FORM)
+"
+  ;; XEmacs; the byte-compiler has a much better implementation of `labels'
+  ;; in `byte-compile-initial-macro-environment' that is used in compiled
+  ;; code.
+  (let ((vars nil) (sets nil)
+        (byte-compile-macro-environment byte-compile-macro-environment))
+    (while bindings
+      (let ((var (gensym)))
+	(push var vars)
+	(push `#'(lambda ,@(cdr (cl-transform-lambda (cdar bindings)
+                                                     (caar bindings)))) sets)
+	(push var sets)
+	(push (list (car (pop bindings)) 'lambda '(&rest cl-labels-args)
+		       (list 'list* '(quote funcall) (list 'quote var)
+			     'cl-labels-args))
+		 byte-compile-macro-environment)))
+    (cl-macroexpand-all (list* 'lexical-let vars (cons (cons 'setq sets) body))
+			byte-compile-macro-environment)))
+
+;;;###autoload
+(defmacro flet (functions &rest form)
+  "Make temporary function definitions.
+
+This is an analogue of `let' that operates on the function cell of FUNC
+rather than its value cell.  The FORMs are evaluated with the specified
+function definitions in place, then the definitions are undone (the FUNCs go
+back to their previous definitions, or lack thereof).  This is in
+contravention of Common Lisp, where `flet' makes a lexical, not a dynamic,
+function binding.
+
+Normally you should use `labels', not `flet'; `labels' does not have the
+problems caused by dynamic scope, is less expensive when byte-compiled, and
+allows lexical shadowing of functions with byte-codes and byte-compile
+methods, where `flet' will fail.  The byte-compiler will warn when this
+happens.
+
+If you need to shadow some existing function at run time, and that function
+has no associated byte code or compiler macro, then `flet' is appropriate.
+
+arguments: (((FUNCTION ARGLIST &body BODY) &rest FUNCTIONS) &body FORM)"
+  ;; XEmacs; leave warnings, errors and modifications of
+  ;; byte-compile-function-environment to the byte compiler. See
+  ;; byte-compile-initial-macro-environment in bytecomp.el.
+  (list*
+   'letf*
+   (mapcar
+    (function*
+     (lambda ((function . definition))
+       `((symbol-function ',function) 
+         ,(cons 'lambda (cdr (cl-transform-lambda definition function))))))
+    functions) form))
 
 (run-hooks 'cl-macs-load-hook)
 
--- a/lisp/faces.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/faces.el	Fri Oct 28 23:52:26 2011 +0900
@@ -1142,6 +1142,7 @@
        ;; end of labels
        )
 
+    (declare (inline global-locale nil-instantiator-ok))
     ;; the function itself
 
     (let* ((ffpdev Face-frob-property-device-considered-current)
--- a/lisp/files.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/files.el	Fri Oct 28 23:52:26 2011 +0900
@@ -1672,26 +1672,18 @@
 If it matches, mode MODE is selected.")
 
 (defvar binary-file-regexps
-  '("\\.\\(?:bz2\\|elc\\|g\\(if\\|z\\)\\|jp\\(eg\\|g\\)\\|png\\|t\\(ar\\|gz\\|iff\\)\\|[Zo]\\)\\'")
+  '("\\.\\(?:7[Zz]\\|ARC\\|E\\(?:AR\\|XE\\)\\|JAR\\|LZH\\|RAR\\|WAR\\|XPI\\|Z\\(?:IP\\|OO\\)\\|arc\\|bz2\\|e\\(?:ar\\|xe\\)\\|g\\(?:if\\|z\\)\\|j\\(?:ar\\|p\\(?:e?g\\)\\)\\|l\\(?:ha\\|zh\\)\\|odt\\|p\\(?:bm\\|df\\|gm\\|n[gm]\\|pm\\)\\|sx[cdimw]\\|t\\(?:ar\\|gz\\|iff\\)\\|war\\|xpi\\|z\\(?:ip\\|oo\\)\\|[Zo]\\)\\'")
   "List of regexps of filenames containing binary (non-text) data.")
-
 ;   (eval-when-compile
 ;     (require 'regexp-opt)
 ;     (list
 ;      (format "\\.\\(?:%s\\)\\'"
 ;	      (regexp-opt
-;	       '("tar"
-;		 "tgz"
-;		 "gz"
-;		 "bz2"
-;		 "Z"
-;		 "o"
-;		 "elc"
-;		 "png"
-;		 "gif"
-;		 "tiff"
-;		 "jpg"
-;		 "jpeg"))))))
+;               '("7Z" "7z" "ARC" "EAR" "EXE" "JAR" "LZH" "RAR" "WAR" "XPI" "Z"
+;                 "ZIP" "ZOO" "arc" "bz2" "ear" "exe" "gif" "gz" "jar"
+;                 "jpeg" "jpg" "lha" "lzh" "o" "odt" "pbm" "pdf" "pgm" "png"
+;                 "pnm" "ppm" "sxc" "sxd" "sxi" "sxm" "sxw" "tar" "tgz"
+;                 "tiff" "war" "xpi" "zip" "zoo")))))
 
 (defvar inhibit-first-line-modes-regexps
   binary-file-regexps
--- a/lisp/keymap.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/keymap.el	Fri Oct 28 23:52:26 2011 +0900
@@ -419,6 +419,7 @@
 		(vector keys)))))
     (labels ((event-to-list (ev)
                (append (event-modifiers ev) (list (event-key ev)))))
+      (declare (inline event-to-list))
       (mapvector
        #'(lambda (key)
 	   (let* ((full-key
--- a/lisp/lisp-mode.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/lisp-mode.el	Fri Oct 28 23:52:26 2011 +0900
@@ -45,6 +45,7 @@
 (defun construct-lisp-mode-menu (popup-p emacs-lisp-p)
   (labels ((popup-wrap (form)
              (if popup-p `(menu-call-at-event ',form) form)))
+    (declare (inline popup-wrap))
     `(,@(if emacs-lisp-p
 	  `(["%_Byte-Compile This File" ,(popup-wrap
 					  'emacs-lisp-byte-compile)]
--- a/lisp/loadhist.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/loadhist.el	Fri Oct 28 23:52:26 2011 +0900
@@ -178,6 +178,7 @@
     (labels ((reset-aload (x)
                (let ((aload (get x 'autoload)))
                  (if aload (fset x (cons 'autoload aload))))))
+      (declare (inline reset-aload)) 
       (mapc
        #'(lambda (x)
            (cond ((stringp x) nil)
--- a/lisp/loadup.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/loadup.el	Fri Oct 28 23:52:26 2011 +0900
@@ -225,7 +225,7 @@
                          (delete*
                           nil
                           (mapc #'(lambda (element)
-                                    (remassq 'defun element)
+                                    (delete* 'defun element :key #'car-safe)
                                     (delete-if
                                      #'(lambda (elt)
                                          (and
--- a/lisp/mouse.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/mouse.el	Fri Oct 28 23:52:26 2011 +0900
@@ -1251,6 +1251,7 @@
                (when ex
                  (funcall (extent-property ex property) event ex)
                  t))))
+    (declare (inline do-activate))
     (or
      (and (some #'(lambda (count button)
 		    (and (= click-count count)
--- a/lisp/mule/cyrillic.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/mule/cyrillic.el	Fri Oct 28 23:52:26 2011 +0900
@@ -418,7 +418,7 @@
 
 (set-language-info-alist
  "Cyrillic-KOI8"
- (remassq 'locale (copy-list (cdr (assoc "Russian" language-info-alist))))
+ (remove* 'locale (cdr (assoc "Russian" language-info-alist)) :key #'car)
  '("Cyrillic"))
 
 ;; KOI8-U, for Ukrainian.
--- a/lisp/mule/general-late.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/mule/general-late.el	Fri Oct 28 23:52:26 2011 +0900
@@ -46,13 +46,13 @@
       ;; fraction faster for those languages.
       language-info-alist
       (cons (assoc "Japanese" language-info-alist)
-	    (remassoc "Japanese" language-info-alist))
+	    (delete* "Japanese" language-info-alist :test #'equal :key #'car))
       language-info-alist 
       (cons (assoc "German" language-info-alist)
-	    (remassoc "German" language-info-alist))
+	    (delete* "German" language-info-alist :test #'equal :key #'car))
       language-info-alist
       (cons (assoc "English" language-info-alist)
-	    (remassoc "English" language-info-alist))
+	    (delete* "English" language-info-alist :test #'equal :key #'car))
 
       ;; Make Installation-string actually reflect the environment at
       ;; byte-compile time. (We can't necessarily decode it when version.el
--- a/lisp/mule/latin.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/mule/latin.el	Fri Oct 28 23:52:26 2011 +0900
@@ -2056,6 +2056,6 @@
   (setcar assocked
           (upcase (symbol-name coding-system)))
   (setcdr assocked
-          (remassq 'locale (cdr assocked))))
+          (delete* 'locale (cdr assocked) :key #'car)))
 
 ;;; latin.el ends here
--- a/lisp/mule/mule-cmds.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/mule/mule-cmds.el	Fri Oct 28 23:52:26 2011 +0900
@@ -838,6 +838,7 @@
     (labels ((princ-list (&rest args)
                (while args (princ (car args)) (setq args (cdr args)))
                (princ "\n")))
+      (declare (inline princ-list))
       (with-output-to-temp-buffer "*Help*"
 	(princ-list language-name " language environment" "\n")
 	(if (stringp doc)
@@ -1347,7 +1348,7 @@
              (if (memq eol-type '(lf crlf cr unix dos mac))
                  (coding-system-change-eol-conversion codesys eol-type)
                codesys)))
-
+    (declare (inline maybe-change-coding-system-with-eol))
     ;; initialize category mappings and priority list.
     (let* ((priority (get-language-info language-name 'coding-priority))
 	   (default-coding (car priority)))
--- a/lisp/mule/mule-x-init.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/mule/mule-x-init.el	Fri Oct 28 23:52:26 2011 +0900
@@ -47,7 +47,7 @@
              (let ((width1 (charset-font-width cs1))
                    (width2 (charset-font-width cs2)))
                (and width1 width2 (eq (+ width1 width1) width2)))))
-
+    (declare (inline charset-font-width))
     (when (eq 'x (device-type))
       (let ((original-registries (charset-registries 'ascii)))
         (condition-case nil
--- a/lisp/obsolete.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/obsolete.el	Fri Oct 28 23:52:26 2011 +0900
@@ -263,8 +263,8 @@
 
 (define-compatible-function-alias 'interactive-form 
   'function-interactive) ;GNU 21.1
-(define-compatible-function-alias 'assq-delete-all
-  'remassq) ;GNU 21.1
+(define-function 'assq-delete-all 'remassq) ;GNU 21.1
+(make-compatible 'assq-delete-all "use (delete* ITEM SEQUENCE :key #'car)")
 
 (defun makehash (&optional test)
   "Create a new hash table.
@@ -452,5 +452,15 @@
 (define-obsolete-variable-alias 'cl-macro-environment
   'byte-compile-macro-environment)
 
+;; Actual implementations of these functions are in cl-extra.el, after
+;; cl-macs is loaded, since those implementations use #'labels and
+;; #'symbol-macrolet. These APIs were always XEmacs-specific, were never
+;; widely used, and it was always more readable and more compatible to use
+;; the CL functions.
+(make-obsolete 'remassoc "use delete* with :test #'equal, :key #'car")
+(make-obsolete 'remassq "use delete* with :test #'eq, :key #'car")
+(make-obsolete 'remrassoc "use delete* with :test #'equal, :key #'cdr")
+(make-obsolete 'remrassq "use delete* with :test #'eq, :key #'cdr")
+
 (provide 'obsolete)
 ;;; obsolete.el ends here
--- a/lisp/packages.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/packages.el	Fri Oct 28 23:52:26 2011 +0900
@@ -111,7 +111,8 @@
 		  (list :version (car attributes))
 		attributes)))
     (setq packages-package-list
-	  (cons (cons name info) (remassq name packages-package-list)))))
+	  (cons (cons name info) (delete* name packages-package-list
+                                          :test #'eq :key #'car)))))
 
 (defun package-suppress (package file form)
   "Set up a package-suppress condition FORM for FILE in PACKAGE.
--- a/lisp/select.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/select.el	Fri Oct 28 23:52:26 2011 +0900
@@ -456,14 +456,14 @@
 ;; append handlers and buffer-kill handlers.
 (defun select-convert-to-text (selection type value)
   (cond ((stringp value)
-	 value)
+	 (substring-no-properties value))
 	((extentp value)
 	 (save-excursion
 	   (set-buffer (extent-object value))
 	   (save-restriction
 	     (widen)
-	     (buffer-substring (extent-start-position value)
-			       (extent-end-position value)))))
+	     (buffer-substring-no-properties (extent-start-position value)
+                                             (extent-end-position value)))))
 	((and (consp value)
 	      (markerp (car value))
 	      (markerp (cdr value)))
@@ -476,7 +476,7 @@
 			   (error "selection is in a killed buffer")))
 	   (save-restriction
 	     (widen)
-	     (buffer-substring (car value) (cdr value)))))
+	     (buffer-substring-no-properties (car value) (cdr value)))))
 	(t nil)))
 
 (defun select-convert-to-timestamp (selection type value)
@@ -485,16 +485,18 @@
 
 (defun select-convert-to-utf-8-text (selection type value)
   (cond ((stringp value)
-	 (cons 'UTF8_STRING (encode-coding-string value 'utf-8)))
+	 (cons 'UTF8_STRING (encode-coding-string
+                             (substring-no-properties value) 'utf-8)))
 	((extentp value)
 	 (save-excursion
 	   (set-buffer (extent-object value))
 	   (save-restriction
 	     (widen)
 	     (cons 'UTF8_STRING 
-		   (encode-coding-string 
-		    (buffer-substring (extent-start-position value)
-				      (extent-end-position value)) 'utf-8)))))
+		   (encode-coding-string (buffer-substring-no-properties
+                                          (extent-start-position value)
+                                          (extent-end-position value))
+                                         'utf-8)))))
 	((and (consp value)
 	      (markerp (car value))
 	      (markerp (cdr value)))
@@ -508,8 +510,8 @@
 	   (save-restriction
 	     (widen)
 	     (cons 'UTF8_STRING (encode-coding-string 
-				 (buffer-substring (car value) (cdr value))
-				 'utf-8)))))
+				 (buffer-substring-no-properties
+                                  (car value) (cdr value)) 'utf-8)))))
 	(t nil)))
 
 (defun select-coerce-to-text (selection type value)
--- a/lisp/simple.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/simple.el	Fri Oct 28 23:52:26 2011 +0900
@@ -2084,20 +2084,19 @@
 
 (defun handle-pre-motion-command-current-command-is-motion ()
   (and (key-press-event-p last-input-event)
-       (macrolet
-	   ((keysyms-equal (&rest args)
-	      `((lambda (a b)
-		  (when (and
-			 ;; As of now, none of the elements of
-			 ;; motion-keys-for-shifted-motion are non-symbols;
-			 ;; this redundant check saves a few hundred
-			 ;; funcalls on startup.
-			 (not (symbolp b)) 
-			 (characterp b))
-		    (setf (car char-list) b
-			  b (intern (concat char-list nil))))
-		  (eq a b))
-		,@args)))
+       (labels
+	   ((keysyms-equal (a b)
+              (when (and
+                     ;; As of now, none of the elements of
+                     ;; motion-keys-for-shifted-motion are non-symbols;
+                     ;; this redundant check saves a few hundred
+                     ;; funcalls on startup.
+                     (not (symbolp b)) 
+                     (characterp b))
+                (setf (car char-list) b
+                      b (intern (concat char-list nil))))
+              (eq a b)))
+         (declare (inline keysyms-equal) (special char-list))
          (loop
            for keysym in motion-keys-for-shifted-motion
            with key = (event-key last-input-event)
--- a/lisp/specifier.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/specifier.el	Fri Oct 28 23:52:26 2011 +0900
@@ -488,6 +488,7 @@
              (if (or (atom x) (eq (car x) 'quote))
                  (list x)
                (list (gensym name) x))))
+    (declare (inline gensym-frob))
     ;; VARLIST is a list of
     ;; ((SPECIFIERSYM SPECIFIER) (VALUE) (LOCALESYM LOCALE)
     ;;  (TAG-SET) (HOW-TO-ADD))
--- a/lisp/startup.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/lisp/startup.el	Fri Oct 28 23:52:26 2011 +0900
@@ -796,7 +796,7 @@
 
 (defun load-terminal-library ()
   (when term-file-prefix
-    (let ((term (getenv "TERM"))
+    (let ((term (console-tty-terminal-type))
 	  hyphend)
       (while (and term
 		  (not (load (concat term-file-prefix term) t t)))
--- a/man/ChangeLog	Fri Oct 14 03:54:46 2011 +0900
+++ b/man/ChangeLog	Fri Oct 28 23:52:26 2011 +0900
@@ -1,3 +1,37 @@
+2011-10-09  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* lispref/lists.texi (Association Lists):
+	Don't document #'remassoc, #'remassq and friends in detail;
+	they're XEmacs-specific and (delete* ... :key #'car) is
+	preferable.
+
+2011-10-09  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* internals/internals.texi (Top):
+	* internals/internals.texi (Authorship of XEmacs):
+	* internals/internals.texi (Modules for Other Aspects of the Lisp Interpreter and Object System):
+	* internals/internals.texi (Introduction to Writing C Code):
+	* internals/internals.texi (Working with Lisp Objects):
+	* internals/internals.texi (Adding Global Lisp Variables):
+	* internals/internals.texi (The XEmacs Object System (Abstractly Speaking)):
+	* internals/internals.texi (How Lisp Objects Are Represented in C):
+	* internals/internals.texi (Allocation of Objects in XEmacs Lisp):
+	* internals/internals.texi (Introduction to Allocation):
+	* internals/internals.texi (GCPROing):
+	* internals/internals.texi (mark_object):
+	* internals/internals.texi (sweep_bit_vectors_1):
+	* internals/internals.texi (Fixnums and Characters):
+	* internals/internals.texi (Future Work -- Unicode):
+	Say fixnum rather than integer when specifically talking about
+	fixed-width Lisp integers.
+
+2011-10-09  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* 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@parhasard.net>
 
 	* cl.texi (Function Bindings):
--- a/man/internals/internals.texi	Fri Oct 14 03:54:46 2011 +0900
+++ b/man/internals/internals.texi	Fri Oct 28 23:52:26 2011 +0900
@@ -467,7 +467,7 @@
 * Garbage Collection::          
 * GCPROing::                    
 * Garbage Collection - Step by Step::  
-* Integers and Characters::     
+* Fixnums and Characters::     
 * Allocation from Frob Blocks::  
 * lrecords::                    
 * Low-level allocation::        
@@ -948,9 +948,9 @@
 @item Objects
 @itemize @minus
 @item
-Conversion from 26-bit to 28-bit pointers and integers, lrecords, lcrecords: Richard Mlynarik, 1994
-@item
-Conversion to 32-bit pointers and 31-bit integers: Kyle Jones, Martin Buchholz
+Conversion from 26-bit to 28-bit pointers and fixnums, lrecords, lcrecords: Richard Mlynarik, 1994
+@item
+Conversion to 32-bit pointers and 31-bit fixnums: Kyle Jones, Martin Buchholz
 @item
 Portable dumper, object descriptions: Olivier Galibert
 @item
@@ -1154,7 +1154,7 @@
 
 @item Kyle Jones
 Author of the minimal tag bits support, which allows for 32-bit
-pointers and 31-bit integers.
+pointers and 31-bit fixnums.
 
 @item Olivier Galibert
 Author of the portable dumping mechanism.
@@ -1200,9 +1200,9 @@
 Steve Baur did some work on the purification and dump time code, and
 added Doug Lea Malloc support from Emacs 20.2 circa 1998.  Kyle Jones
 continued to work done by Mlynarik, reducing the number of primitive
-Lisp types so that there are only three: integer character and pointer
+Lisp types so that there are only three: fixnum, character, and pointer
 type, which encompasses all other types.  This allows for 31-bit
-integers and 32-bit pointers, although there is potential slowdown in
+fixnums and 32-bit pointers, although there is potential slowdown in
 some extra in directions when determining the type of an object, and
 some memory increase for the objects that previously were considered to
 be the most primitive types.  Martin Buchholz has recently (February
@@ -4084,7 +4084,7 @@
 @end example
 
 This module implements the @dfn{range table} Lisp object type, which
-provides for a mapping from ranges of integers to arbitrary Lisp
+provides for a mapping from ranges of fixnums to arbitrary Lisp
 objects.
 
 
@@ -4981,7 +4981,7 @@
 @item
 No C variables whose value is other than a Lisp_Object should begin
 with a capital V. (This includes C variables that forward into
-integer or boolean Lisp variables.)
+fixnums or boolean Lisp variables.)
 @item
 All global C variables whose value is a struct Lisp_Subr begin with a
 capital S. (This only occurs in connection with DEFUN ()).
@@ -5158,7 +5158,7 @@
   All Lisp objects are handled indirectly.  The @code{Lisp_Object}
 type is usually a pointer to a structure, except for a very small number
 of types with immediate representations (currently characters and
-integers).  However, these types cannot be directly operated on in C
+fixnums).  However, these types cannot be directly operated on in C
 code, either, so they can also be considered indirect.  Types that do
 not have an immediate representation always have a C typedef
 @code{Lisp_@var{type}} for a corresponding structure.
@@ -5209,7 +5209,7 @@
   @strong{Convention}: Global variables whose names begin with @samp{V}
 are variables that contain Lisp objects.  The convention here is that
 all global variables of type @code{Lisp_Object} begin with @samp{V}, and
-no others do (not even integer and boolean variables that have Lisp
+no others do (not even fixnum and boolean variables that have Lisp
 equivalents). Most of the time, these variables have equivalents in
 Lisp, which are defined via the @samp{DEFVAR} family of macros, but some
 don't.  Since the variable's value is a @code{Lisp_Object}, it can be
@@ -5722,7 +5722,7 @@
   Global variables whose names begin with @samp{V} are variables that
 contain Lisp objects.  The convention here is that all global variables
 of type @code{Lisp_Object} begin with @samp{V}, and all others don't
-(including integer and boolean variables that have Lisp
+(including fixnum and boolean variables that have Lisp
 equivalents). Most of the time, these variables have equivalents in
 Lisp, but some don't.  Those that do are declared this way by a call to
 @code{DEFVAR_LISP()} in the @code{vars_of_*()} initializer for the
@@ -7502,8 +7502,8 @@
   The basic Lisp objects are
 
 @table @code
-@item integer
-31 bits of precision, or 63 bits on 64-bit machines; the
+@item fixnum
+An integer with 31 bits of precision, or 63 bits on 64-bit machines; the
 reason for this is described below when the internal Lisp object
 representation is described.
 @item char
@@ -7516,22 +7516,16 @@
 of the char; this way, if the mapping between chars and integers
 changes, which is quite possible for Kanji characters and other extended
 characters, the same character will still be created.  Note that some
-primitives confuse chars and integers.  The worst culprit is @code{eq},
-which makes a special exception and considers a char to be @code{eq} to
-its integer equivalent, even though in no other case are objects of two
-different types @code{eq}.  The reason for this monstrosity is
-compatibility with existing code; the separation of char from integer
-came fairly recently.)
+primitives confuse chars and fixnum.
 @item float
 Same precision as a double in C.
 @item bignum
 @itemx ratio
 @itemx bigfloat
 As build-time options, arbitrary-precision numbers are available.
-Bignums are integers, and when available they remove the restriction on
-buffer size.  Ratios are non-integral rational numbers.  Bigfloats are
-arbitrary-precision floating point numbers, with precision specified at
-runtime.
+Bignums are integers.  Ratios are non-integral rational numbers.
+Bigfloats are arbitrary-precision floating point numbers, with
+precision specified at runtime.
 @item symbol
 An object that contains Lisp objects and is referred to by name;
 symbols are used to implement variables and named functions
@@ -7642,7 +7636,7 @@
 representation that is optimized to the way characters are represented
 as integers.
 @item range-table
-An object that maps from ranges of integers to arbitrary Lisp objects.
+An object that maps from ranges of fixnums to arbitrary Lisp objects.
 @end table
 
   And some strange special-purpose objects:
@@ -7869,13 +7863,13 @@
  [ 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 ]
 
    <---------------------------------------------------------> <->
-            a pointer to a structure, or an integer            tag
+            a pointer to a structure, or a fixnum              tag
 @end example
 
 A tag of 00 is used for all pointer object types, a tag of 10 is used
 for characters, and the other two tags 01 and 11 are joined together to
-form the integer object type.  This representation gives us 31 bit
-integers and 30 bit characters, while pointers are represented directly
+form the fixnum object type.  This representation gives us 31 bit
+fixnums and 30 bit characters, while pointers are represented directly
 without any bit masking or shifting.  This representation, though,
 assumes that pointers to structs are always aligned to multiples of 4,
 so the lower 2 bits are always zero.
@@ -7895,11 +7889,11 @@
 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
+fixnums are stored left-shifted, if the right-shift operator does an
 arithmetic shift (i.e. it leaves the most-significant bit as-is rather
 than shifting in a zero, so that it mimics a divide-by-two even for
 negative numbers) the shift to remove the tag bit is enough.  This is
@@ -7918,8 +7912,8 @@
 (@var{lvalue}, @var{result})}, i.e. they have to be a statement rather
 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
+sometimes isn't too convenient; for the case of fixnums, at least, you
+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
@@ -7950,7 +7944,7 @@
 * Garbage Collection::          
 * GCPROing::                    
 * Garbage Collection - Step by Step::  
-* Integers and Characters::     
+* Fixnums and Characters::     
 * Allocation from Frob Blocks::  
 * lrecords::                    
 * Low-level allocation::        
@@ -7993,7 +7987,7 @@
 @itemize @bullet
 @item
 (a) Those for whom the value directly represents the contents of the
-Lisp object.  Only two types are in this category: integers and
+Lisp object.  Only two types are in this category: fixnums and
 characters.  No special allocation or garbage collection is necessary
 for such objects.  Lisp objects of these types do not need to be
 @code{GCPRO}ed.
@@ -8234,7 +8228,7 @@
 it obviates the need for @code{GCPRO}ing, and allows garbage collection
 to happen at any point at all, such as during object allocation.
 
-@node Garbage Collection - Step by Step, Integers and Characters, GCPROing, Allocation of Objects in XEmacs Lisp
+@node Garbage Collection - Step by Step, Fixnums and Characters, GCPROing, Allocation of Objects in XEmacs Lisp
 @section Garbage Collection - Step by Step
 @cindex garbage collection - step by step
 
@@ -8504,8 +8498,8 @@
 @cindex @code{mark_object}
 
 The first thing that is checked while marking an object is whether the
-object is a real Lisp object @code{Lisp_Type_Record} or just an integer
-or a character. Integers and characters are the only two types that are
+object is a real Lisp object @code{Lisp_Type_Record} or just a fixnum
+or a character. Fixnums and characters are the only two types that are
 stored directly - without another level of indirection, and therefore they
 don't have to be marked and collected.
 @xref{How Lisp Objects Are Represented in C}.
@@ -8730,18 +8724,19 @@
 In addition, the bookkeeping information used for garbage
 collector's output purposes is updated.
 
-@node Integers and Characters, Allocation from Frob Blocks, Garbage Collection - Step by Step, Allocation of Objects in XEmacs Lisp
-@section Integers and Characters
+@node Fixnums and Characters, Allocation from Frob Blocks, Garbage Collection - Step by Step, Allocation of Objects in XEmacs Lisp
+@section Fixnums and Characters
 @cindex integers and characters
 @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
+@cindex fixnum and characters
+
+Fixnum and character Lisp objects are created from C integers using the
+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}.
 
-@node Allocation from Frob Blocks, lrecords, Integers and Characters, Allocation of Objects in XEmacs Lisp
+@node Allocation from Frob Blocks, lrecords, Fixnums and Characters, Allocation of Objects in XEmacs Lisp
 @section Allocation from Frob Blocks
 @cindex allocation from frob blocks
 @cindex frob blocks, allocation from
@@ -26219,10 +26214,10 @@
      unicode vector or list of codes charset-offset
 @end example
 
-  Establishes a mapping between a unicode codepoint (an integer) and
+  Establishes a mapping between a unicode codepoint (a fixnum) and
   one or more chars in a charset.  The mapping is automatically
   established in both directions.  Chars in a charset can be specified
-  either with an actual character or a codepoint (i.e. an integer)
+  either with an actual character or a codepoint (i.e. an fixnum)
   and the charset it's within.  If a sequence of chars or charset
   points is given, multiple mappings are established for consecutive
   unicode codepoints starting with the given one.  Charset codepoints
--- a/man/lispref/lists.texi	Fri Oct 14 03:54:46 2011 +0900
+++ b/man/lispref/lists.texi	Fri Oct 28 23:52:26 2011 +0900
@@ -1451,7 +1451,8 @@
   In XEmacs Lisp, it is @emph{not} an error if an element of an
 association list is not a cons cell.  The alist search functions simply
 ignore such elements.  Many other versions of Lisp signal errors in such
-cases.
+cases, and it is good practice to avoid adding non-cons-cells to association
+lists.
 
   Note that property lists are similar to association lists in several
 respects.  A property list behaves like an association list in which
@@ -1569,57 +1570,6 @@
 @end smallexample
 @end defun
 
-@defun remassoc key alist
-This function deletes by side effect any associations with key @var{key}
-in @var{alist}---i.e. it removes any elements from @var{alist} whose
-@code{car} is @code{equal} to @var{key}.  The modified @var{alist} is
-returned.
-
-If the first member of @var{alist} has a @code{car} that is @code{equal}
-to @var{key}, there is no way to remove it by side effect; therefore,
-write @code{(setq foo (remassoc key foo))} to be sure of changing the
-value of @code{foo}.
-@end defun
-
-@defun remassq key alist
-This function deletes by side effect any associations with key @var{key}
-in @var{alist}---i.e. it removes any elements from @var{alist} whose
-@code{car} is @code{eq} to @var{key}.  The modified @var{alist} is
-returned.
-
-This function is exactly like @code{remassoc}, but comparisons between
-@var{key} and keys in @var{alist} are done using @code{eq} instead of
-@code{equal}.
-@end defun
-
-@defun remrassoc value alist
-This function deletes by side effect any associations with value @var{value}
-in @var{alist}---i.e. it removes any elements from @var{alist} whose
-@code{cdr} is @code{equal} to @var{value}.  The modified @var{alist} is
-returned.
-
-If the first member of @var{alist} has a @code{car} that is @code{equal}
-to @var{value}, there is no way to remove it by side effect; therefore,
-write @code{(setq foo (remassoc value foo))} to be sure of changing the
-value of @code{foo}.
-
-@code{remrassoc} is like @code{remassoc} except that it compares the
-@sc{cdr} of each @var{alist} association instead of the @sc{car}.  You
-can think of this as ``reverse @code{remassoc}'', removing an association
-based on its value instead of its key.
-@end defun
-
-@defun remrassq value alist
-This function deletes by side effect any associations with value @var{value}
-in @var{alist}---i.e. it removes any elements from @var{alist} whose
-@code{cdr} is @code{eq} to @var{value}.  The modified @var{alist} is
-returned.
-
-This function is exactly like @code{remrassoc}, but comparisons between
-@var{value} and values in @var{alist} are done using @code{eq} instead of
-@code{equal}.
-@end defun
-
 @defun copy-alist alist
 @cindex copying alists
 This function returns a two-level deep copy of @var{alist}: it creates a
@@ -1671,6 +1621,14 @@
 @end smallexample
 @end defun
 
+For removing elements from alists, use @code{remove*} or @code{delete*} with
+appropriate @code{:key} arguments.  If it is necessary that XEmacs not error
+on encountering a non-cons in such a list, there are XEmacs-specific functions
+@code{remassq}, @code{remrassq}, @code{remassoc}, and @code{remrassoc} with
+this behavior, but they are neither available under GNU Emacs nor Common Lisp.
+They are marked as obsolete, and it is preferable to fix your code to avoid
+adding non-cons objects to alists.
+
 @node Property Lists
 @section Property Lists
 @cindex property list
--- a/modules/ChangeLog	Fri Oct 14 03:54:46 2011 +0900
+++ b/modules/ChangeLog	Fri Oct 28 23:52:26 2011 +0900
@@ -1,3 +1,44 @@
+2011-10-09  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* 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@xemacs.org>
 
 	* base64/Makefile: Default DESTDIR to the empty string, and use it in
--- a/modules/canna/canna_api.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/modules/canna/canna_api.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
 }
--- a/modules/ldap/eldap.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/modules/ldap/eldap.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/modules/postgresql/postgresql.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/modules/postgresql/postgresql.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
 
--- a/src/ChangeLog	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/ChangeLog	Fri Oct 28 23:52:26 2011 +0900
@@ -1,3 +1,1038 @@
+2011-10-09  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* fns.c (remassoc_no_quit):
+	* fns.c (remrassq_no_quit):
+	* fns.c (syms_of_fns):
+	* fontcolor-tty.c (Fregister_tty_color):
+	* fontcolor-tty.c (Funregister_tty_color):
+	* fontcolor-tty.c (Ffind_tty_color):
+	* lisp.h:
+	Remove Fremassq, Fremrassq, Fremassoc, Fremrassoc, they're
+	XEmacs-specific functions and Lisp callers should use (delete*
+	... :key #'car) anyway. Keep the non-Lisp-visible _no_quit
+	versions, calling FdeleteX from C with the appropriate arguments
+	is ungainly.
+
+2011-10-09  Aidan Kehoe  <kehoea@parhasard.net>
+
+	Do a couple of non-mechanical things that would otherwise have
+	been included in the last change.
+	* data.c:
+	* data.c (Ftype_of):
+	Return Qfixnum for fixnums, not Qinteger.
+	* lisp.h (MOST_POSITIVE_FIXNUM):
+	Delete an obsolete comment here.
+
+2011-10-09  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* 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@parhasard.net>
 
 	* redisplay-tty.c (init_tty_for_redisplay):
--- a/src/EmacsFrame.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/EmacsFrame.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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 */
 
--- a/src/README	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/README	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/abbrev.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/abbrev.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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");
--- a/src/alloc.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/alloc.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/buffer.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/buffer.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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"
 
--- a/src/buffer.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/buffer.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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		*/
--- a/src/bytecode.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/bytecode.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
 }
 
--- a/src/callint.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/callint.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/casefiddle.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/casefiddle.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
 }
--- a/src/chartab.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/chartab.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
 }
 
--- a/src/cmdloop.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/cmdloop.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/cmds.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/cmds.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/console-gtk.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/console-gtk.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
--- a/src/console-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/console-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -640,7 +640,7 @@
 #undef FROB
     
     invalid_argument ("Unknown return value from MessageBox()",
-		      make_int (retval));
+		      make_fixnum (retval));
   }
 
   return Qnil;
--- a/src/console-tty.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/console-tty.c	Fri Oct 28 23:52:26 2011 +0900
@@ -114,7 +114,7 @@
 
   /* Determine the controlling process */
   if (!NILP (controlling_process))
-    CHECK_INT (controlling_process);
+    CHECK_FIXNUM (controlling_process);
 
   /* Open the specified console */
 
--- a/src/console-x.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/console-x.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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)
--- a/src/console.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/console.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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"
 }
--- a/src/data.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/data.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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.
@@ -564,7 +564,7 @@
 
     case Lisp_Type_Char: return Qcharacter;
 
-    default: return Qinteger;
+    default: return Qfixnum;
     }
 }
 
@@ -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 /*
--- a/src/database.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/database.c	Fri Oct 28 23:52:26 2011 +0900
@@ -675,8 +675,8 @@
     }
   else
     {
-      CHECK_INT (mode);
-      modemask = XINT (mode);
+      CHECK_FIXNUM (mode);
+      modemask = XFIXNUM (mode);
     }
 
   if (NILP (codesys))
--- a/src/debug.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/debug.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
 
--- a/src/device-gtk.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/device-gtk.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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:
--- a/src/device-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/device-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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, /*
--- a/src/device-tty.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/device-tty.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
     }
--- a/src/device-x.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/device-x.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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, /*
--- a/src/device.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/device.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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, /*
--- a/src/dialog-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/dialog-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
 	}
     }
   
--- a/src/dialog-x.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/dialog-x.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/dired.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/dired.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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)));
 }
 
 
--- a/src/doc.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/doc.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
             }
 	}
 
--- a/src/doprnt.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/doprnt.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
 		    }
 		}
 	    }
--- a/src/editfns.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/editfns.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
--- a/src/elhash.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/elhash.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
--- a/src/emacs.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/emacs.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/emodules.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/emodules.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/eval.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/eval.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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.
--- a/src/event-Xt.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/event-Xt.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
 		      > (xd->modifier_release_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;
--- a/src/event-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/event-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/event-stream.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/event-stream.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/event-xlike-inc.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/event-xlike-inc.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
--- a/src/events.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/events.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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:
--- a/src/extents.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/extents.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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,
--- a/src/file-coding.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/file-coding.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
--- a/src/fileio.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/fileio.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
 		   > (BUF_Z (b) - BUF_BEG (b)) * 13)
 		  /* 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;
 }
--- a/src/floatfns.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/floatfns.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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)));
     }
 }
 
--- a/src/fns.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/fns.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
@@ -3642,41 +3642,12 @@
   return sequence;
 }
 
-DEFUN ("remassoc", Fremassoc, 2, 2, 0, /*
-Delete by side effect any elements of ALIST whose car is `equal' to KEY.
-The modified ALIST is returned.  If the first member of ALIST has a car
-that is `equal' to KEY, there is no way to remove it by side effect;
-therefore, write `(setq foo (remassoc key foo))' to be sure of changing
-the value of `foo'.
-*/
-       (key, alist))
-{
-  EXTERNAL_LIST_LOOP_DELETE_IF (elt, alist,
-				(CONSP (elt) &&
-				 internal_equal (key, XCAR (elt), 0)));
-  return alist;
-}
-
 Lisp_Object
 remassoc_no_quit (Lisp_Object key, Lisp_Object alist)
 {
-  int speccount = specpdl_depth ();
-  specbind (Qinhibit_quit, Qt);
-  return unbind_to_1 (speccount, Fremassoc (key, alist));
-}
-
-DEFUN ("remassq", Fremassq, 2, 2, 0, /*
-Delete by side effect any elements of ALIST whose car is `eq' to KEY.
-The modified ALIST is returned.  If the first member of ALIST has a car
-that is `eq' to KEY, there is no way to remove it by side effect;
-therefore, write `(setq foo (remassq key foo))' to be sure of changing
-the value of `foo'.
-*/
-       (key, alist))
-{
-  EXTERNAL_LIST_LOOP_DELETE_IF (elt, alist,
-				(CONSP (elt) &&
-				 EQ_WITH_EBOLA_NOTICE (key, XCAR (elt))));
+  LIST_LOOP_DELETE_IF (elt, alist,
+		       (CONSP (elt) &&
+                        internal_equal (key, XCAR (elt), 0)));
   return alist;
 }
 
@@ -3691,36 +3662,6 @@
   return alist;
 }
 
-DEFUN ("remrassoc", Fremrassoc, 2, 2, 0, /*
-Delete by side effect any elements of ALIST whose cdr is `equal' to VALUE.
-The modified ALIST is returned.  If the first member of ALIST has a car
-that is `equal' to VALUE, there is no way to remove it by side effect;
-therefore, write `(setq foo (remrassoc value foo))' to be sure of changing
-the value of `foo'.
-*/
-       (value, alist))
-{
-  EXTERNAL_LIST_LOOP_DELETE_IF (elt, alist,
-				(CONSP (elt) &&
-				 internal_equal (value, XCDR (elt), 0)));
-  return alist;
-}
-
-DEFUN ("remrassq", Fremrassq, 2, 2, 0, /*
-Delete by side effect any elements of ALIST whose cdr is `eq' to VALUE.
-The modified ALIST is returned.  If the first member of ALIST has a car
-that is `eq' to VALUE, there is no way to remove it by side effect;
-therefore, write `(setq foo (remrassq value foo))' to be sure of changing
-the value of `foo'.
-*/
-       (value, alist))
-{
-  EXTERNAL_LIST_LOOP_DELETE_IF (elt, alist,
-				(CONSP (elt) &&
-				 EQ_WITH_EBOLA_NOTICE (value, XCDR (elt))));
-  return alist;
-}
-
 /* Like Fremrassq, fast and unsafe; be careful */
 Lisp_Object
 remrassq_no_quit (Lisp_Object value, Lisp_Object alist)
@@ -3749,8 +3690,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 +3729,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 +3805,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 +3816,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 +3848,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 +3887,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 +3919,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 +4223,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 +4242,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 +4296,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 +4313,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 +4345,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 +4386,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 +4985,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 +5077,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 +5184,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 +5293,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 +5328,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 +6158,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 +6174,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 +6257,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 +6541,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 +6569,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 +6583,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 +6928,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 +6990,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 +7004,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 +7020,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 +7034,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 +7045,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 +7084,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 +7554,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 +7562,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 +7573,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 +7581,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 +7627,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 +7640,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 +7655,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 +7663,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 +7743,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 +7858,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 +7989,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 +8012,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 +8023,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 +8092,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 +8106,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 +8168,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 +8185,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 +8225,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 +8234,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 +8258,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 +8306,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 +8346,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 +8374,7 @@
           if (NILP (sequence1))
             {
               check_sequence_range (args[0], start1, end1,
-                                    make_int (XINT (start1) + starting1));
+                                    make_fixnum (XFIXNUM (start1) + starting1));
             }
         }
     }
@@ -8445,7 +8386,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 +8405,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 +8431,7 @@
           if (NILP (sequence2))
             {
               check_sequence_range (args[1], start2, end2,
-                                    make_int (XINT (start2) + starting2));
+                                    make_fixnum (XFIXNUM (start2) + starting2));
             }
         }
     }
@@ -8502,7 +8443,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 +8463,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 +8489,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 +8497,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 +8517,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 +8527,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 +8566,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 +8577,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 +8621,7 @@
 	      return sequence;
 	    }
 
-	  presenting = XINT (present);
+	  presenting = XFIXNUM (present);
 	  presenting = presenting <= counting ? 0 : presenting - counting;
 	}
 
@@ -8743,7 +8684,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 +8742,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 +8751,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 +8763,7 @@
 	  return sequence;
 	}
 
-      positioning = XINT (position0);
+      positioning = XFIXNUM (position0);
       ending = min (len, ending);
 
       Faset (sequence, position0, new_);
@@ -8832,12 +8773,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 +8790,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 +8823,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 +8836,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 +8852,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 +8897,7 @@
 
   if (!NILP (count) && !NILP (from_end))
     {
-      presenting = XINT (matched_count);
+      presenting = XFIXNUM (matched_count);
       presenting = presenting <= counting ? 0 : presenting - counting;
     }
 
@@ -9427,20 +9368,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 +9421,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 +9468,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 +9513,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 +9577,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 +9609,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 +9624,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 +9652,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 +9694,7 @@
               != test_not_unboundp)
             {
               UNGCPRO;
-              return make_integer (XINT (list_start) + char_count);
+              return make_integer (XFIXNUM (list_start) + char_count);
             }
         }
       else
@@ -9788,7 +9729,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 +9737,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 +9766,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 +9799,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 +9827,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 +9835,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 +9857,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 +9882,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 +9891,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 +9917,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 +9925,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 +9949,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 +10012,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 +10045,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 +10070,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 +10237,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 +10252,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 +10262,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 +10279,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 +10317,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 +10325,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 +10344,7 @@
               return position0;
             }
 
-          ii = XINT (position0) + 1;
+          ii = XFIXNUM (position0) + 1;
         }
 
       UNGCPRO;
@@ -10419,7 +10360,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 +10368,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 +11040,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 +11102,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 +11400,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 +11410,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 +11429,7 @@
 	  if (ec != '=')
 	    base64_conversion_error
 	      ("Padding `=' expected but not found while decoding base64",
-	       make_int (streampos));
+	       make_fixnum (streampos));
 	  continue;
 	}
 
@@ -11561,7 +11502,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 +11576,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, /*
@@ -11771,10 +11712,6 @@
 
   DEFSUBR (FdeleteX);
   DEFSUBR (FremoveX);
-  DEFSUBR (Fremassoc);
-  DEFSUBR (Fremassq);
-  DEFSUBR (Fremrassoc);
-  DEFSUBR (Fremrassq);
   DEFSUBR (Fdelete_duplicates);
   DEFSUBR (Fremove_duplicates);
   DEFSUBR (Fnreverse);
--- a/src/font-lock.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/font-lock.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
--- a/src/font-mgr.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/font-mgr.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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, /*
--- a/src/fontcolor-gtk.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/fontcolor-gtk.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/fontcolor-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/fontcolor-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/fontcolor-tty.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/fontcolor-tty.c	Fri Oct 28 23:52:26 2011 +0900
@@ -80,7 +80,7 @@
   CHECK_STRING (bg_string);
 
   color = Fintern (color, Qnil);
-  Vtty_color_alist = Fremassq (color, Vtty_color_alist);
+  Vtty_color_alist = remassq_no_quit (color, Vtty_color_alist);
   Vtty_color_alist = Fcons (Fcons (color, Fcons (fg_string, bg_string)),
 			    Vtty_color_alist);
 
@@ -95,7 +95,7 @@
   CHECK_STRING (color);
 
   color = Fintern (color, Qnil);
-  Vtty_color_alist = Fremassq (color, Vtty_color_alist);
+  Vtty_color_alist = remassq_no_quit (color, Vtty_color_alist);
   return Qnil;
 }
 
@@ -111,7 +111,7 @@
 
   CHECK_STRING (color);
 
-  result = Fassq (Fintern (color, Qnil), Vtty_color_alist);
+  result = assq_no_quit (Fintern (color, Qnil), Vtty_color_alist);
   if (!NILP (result))
     return list2 (Fcar (Fcdr (result)), Fcdr (Fcdr (result)));
   else
--- a/src/fontcolor-x.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/fontcolor-x.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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)),
--- a/src/fontcolor.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/fontcolor.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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, /*
--- a/src/frame-gtk.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/frame-gtk.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
 	  }
       }
   }
--- a/src/frame-impl.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/frame-impl.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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])
--- a/src/frame-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/frame-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
 	    }
 	}
--- a/src/frame-tty.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/frame-tty.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
 }
--- a/src/frame-x.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/frame-x.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
 	  }
       }
   }
--- a/src/frame.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/frame.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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)
--- a/src/free-hook.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/free-hook.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/glyphs-eimage.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/glyphs-eimage.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/glyphs-gtk.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/glyphs-gtk.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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))),		\
--- a/src/glyphs-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/glyphs-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
     }
 }
 
--- a/src/glyphs-widget.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/glyphs-widget.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
 }
 
 
--- a/src/glyphs-x.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/glyphs-x.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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))),		\
--- a/src/glyphs.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/glyphs.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
 }
 
 
--- a/src/gpmevent.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/gpmevent.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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))
 	{
--- a/src/gtk-glue.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/gtk-glue.c	Fri Oct 28 23:52:26 2011 +0900
@@ -197,7 +197,7 @@
     }
   else if (arg->type == GTK_TYPE_INT_ARRAY)
     {
-      FROB (gint, CHECK_INT, XINT);
+      FROB (gint, CHECK_FIXNUM, XFIXNUM);
     }
   else
     {
--- a/src/gtk-xemacs.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/gtk-xemacs.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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 */
--- a/src/gui-gtk.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/gui-gtk.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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))
--- a/src/gui-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/gui-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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))
--- a/src/gui-x.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/gui-x.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/gui.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/gui.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
     }
--- a/src/gutter.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/gutter.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/gutter.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/gutter.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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) \
--- a/src/indent.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/indent.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
 }
 
 
--- a/src/insdel.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/insdel.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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.
--- a/src/intl-win32.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/intl-win32.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
--- a/src/keymap.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/keymap.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/line-number.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/line-number.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
--- a/src/lisp-disunion.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/lisp-disunion.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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))
 
--- a/src/lisp-union.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/lisp-union.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
--- a/src/lisp.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/lisp.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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,15 @@
 #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 +1696,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 +1740,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 +2736,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 +2934,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 +2945,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 +3050,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 +3067,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 +3078,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 +3089,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 +3101,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 +3160,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 +3581,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 +4361,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];
@@ -5290,7 +5286,6 @@
 MODULE_API EXFUN (Fprovide, 1);
 MODULE_API EXFUN (Fput, 3);
 EXFUN (Frassq, 2);
-EXFUN (Fremassq, 2);
 EXFUN (Freplace_list, 2);
 MODULE_API EXFUN (Freverse, 1);
 EXFUN (Fsafe_length, 1);
--- a/src/lread.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/lread.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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");
--- a/src/lstream.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/lstream.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/macros.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/macros.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/marker.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/marker.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
 }
 
--- a/src/mc-alloc.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/mc-alloc.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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 */
 
--- a/src/menubar-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/menubar-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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))
     {
--- a/src/menubar.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/menubar.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
     }
--- a/src/minibuf.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/minibuf.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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 */
 
--- a/src/mule-ccl.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/mule-ccl.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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)]))       \
 		  >> ((2 - (i % 3)) * 8)) & 0xFF;		\
 	    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)]))       \
 		  >> ((2 - (i % 3)) * 8)) & 0xFF;		\
 	    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 /*
--- a/src/mule-charset.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/mule-charset.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/mule-coding.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/mule-coding.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
                 }
             }
--- a/src/mule-wnnfns.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/mule-wnnfns.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/number.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/number.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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"));
--- a/src/number.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/number.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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 {			\
--- a/src/print.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/print.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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)
                             >> PRINT_NUMBER_ORDINAL_SHIFT);
 
           /* 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)
                             >> PRINT_NUMBER_ORDINAL_SHIFT);
 
           /* 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))
     {
--- a/src/process-nt.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/process-nt.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
--- a/src/process-unix.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/process-unix.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/process.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/process.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
 }
 
--- a/src/profile.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/profile.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
 }
--- a/src/ralloc.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/ralloc.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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, /*
--- a/src/rangetab.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/rangetab.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
     }
 
--- a/src/redisplay-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/redisplay-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/redisplay-output.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/redisplay-output.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
     }
--- a/src/redisplay-xlike-inc.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/redisplay-xlike-inc.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
 	}
--- a/src/redisplay.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/redisplay.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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. */
--- a/src/scrollbar-gtk.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/scrollbar-gtk.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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();
--- a/src/scrollbar-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/scrollbar-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
--- a/src/scrollbar-x.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/scrollbar-x.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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:
--- a/src/scrollbar.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/scrollbar.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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,
--- a/src/search.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/search.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
     }
--- a/src/select-gtk.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/select-gtk.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/select-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/select-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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))
--- a/src/select-x.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/select-x.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
 }
 
--- a/src/select-xlike-inc.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/select-xlike-inc.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
 
--- a/src/select.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/select.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/sgiplay.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/sgiplay.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/sound.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/sound.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/src/specifier.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/specifier.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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, /*
--- a/src/specifier.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/specifier.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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)
--- a/src/symbols.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/symbols.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
 }
--- a/src/syntax.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/syntax.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
     }
 
--- a/src/syntax.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/syntax.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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 */
--- a/src/sysdep.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/sysdep.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
 }
 
 
--- a/src/tests.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/tests.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
 }
--- a/src/text.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/text.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
 
--- a/src/toolbar-msw.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/toolbar-msw.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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))
--- a/src/toolbar-xlike.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/toolbar-xlike.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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;
--- a/src/toolbar.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/toolbar.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/tooltalk.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/tooltalk.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/tooltalk.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/tooltalk.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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)
 
--- a/src/ui-byhand.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/ui-byhand.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
     }
--- a/src/ui-gtk.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/ui-gtk.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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));
 }
--- a/src/undo.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/undo.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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)
 		    {
--- a/src/unicode.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/unicode.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/win32.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/win32.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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)
--- a/src/window-impl.h	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/window-impl.h	Fri Oct 28 23:52:26 2011 +0900
@@ -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 		\
--- a/src/window.c	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/window.c	Fri Oct 28 23:52:26 2011 +0900
@@ -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);
--- a/src/xemacs.def.in.in	Fri Oct 14 03:54:46 2011 +0900
+++ b/src/xemacs.def.in.in	Fri Oct 28 23:52:26 2011 +0900
@@ -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
--- a/tests/ChangeLog	Fri Oct 14 03:54:46 2011 +0900
+++ b/tests/ChangeLog	Fri Oct 28 23:52:26 2011 +0900
@@ -1,3 +1,28 @@
+2011-10-03  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* automated/case-tests.el (uni-mappings):
+	* automated/database-tests.el (delete-database-files):
+	* automated/hash-table-tests.el (iterations):
+	* automated/lisp-tests.el (test1):
+	* automated/lisp-tests.el (a):
+	* automated/lisp-tests.el (cl-floor):
+	* automated/lisp-tests.el (foo):
+	* automated/lisp-tests.el (list-nreverse):
+	* automated/lisp-tests.el (needs-lexical-context):
+	* automated/mule-tests.el (featurep):
+	* automated/os-tests.el (original-string):
+	* automated/os-tests.el (with):
+	* automated/symbol-tests.el (check-weak-list-unique):
+	Replace #'flet with #'labels where appropriate in these tests,
+	following my own advice on style in the docstrings of those
+	functions.
+
+2011-10-02  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* automated/lisp-tests.el:
+	* automated/lisp-tests.el (+):
+	Test #'labels and inlining.
+
 2011-09-04  Aidan Kehoe  <kehoea@parhasard.net>
 
 	* automated/lisp-reader-tests.el:
--- a/tests/automated/case-tests.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/tests/automated/case-tests.el	Fri Oct 28 23:52:26 2011 +0900
@@ -1464,8 +1464,8 @@
 	    ;; finally, make the new mapping.
 	    (put-case-table-pair uc lc case-table))
 	  finally return case-table)))
-  (flet ((ismulti (uc lc)
-	   (or (gethash uc multi-hash) (gethash lc multi-hash))))
+  (labels ((ismulti (uc lc)
+             (or (gethash uc multi-hash) (gethash lc multi-hash))))
     (let (
 	  ;; All lowercase
 	  (lowermulti (with-output-to-string
--- a/tests/automated/database-tests.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/tests/automated/database-tests.el	Fri Oct 28 23:52:26 2011 +0900
@@ -34,12 +34,12 @@
      (push (file-name-directory load-file-name) load-path)
      (require 'test-harness))))
 
-(flet ((delete-database-files (filename)
-	(dolist (fn (list filename
-			  (concat filename ".db")
-			  (concat filename ".pag")
-			  (concat filename ".dir")))
-	  (ignore-file-errors (delete-file fn))))
+(labels ((delete-database-files (filename)
+           (dolist (fn (list filename
+                             (concat filename ".db")
+                             (concat filename ".pag")
+                             (concat filename ".dir")))
+             (ignore-file-errors (delete-file fn))))
 
        (test-database (db)
 	(Assert (databasep db))
--- a/tests/automated/hash-table-tests.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/tests/automated/hash-table-tests.el	Fri Oct 28 23:52:26 2011 +0900
@@ -145,16 +145,21 @@
       (Assert (= (hash-table-count ht) (decf count))))))
 
 (let ((iterations 5) (one 1.0) (two 2.0))
-  (flet ((check-copy
-	  (ht)
-	  (let ((copy-of-ht (copy-hash-table ht)))
-	    (Assert (equal ht copy-of-ht))
-	    (Assert (not (eq ht copy-of-ht)))
-	    (Assert (eq  (hash-table-count ht) (hash-table-count copy-of-ht)))
-	    (Assert (eq  (hash-table-type  ht) (hash-table-type  copy-of-ht)))
-	    (Assert (eq  (hash-table-size  ht) (hash-table-size  copy-of-ht)))
-	    (Assert (eql (hash-table-rehash-size ht) (hash-table-rehash-size copy-of-ht)))
-	    (Assert (eql (hash-table-rehash-threshold ht) (hash-table-rehash-threshold copy-of-ht))))))
+  (labels ((check-copy
+             (ht)
+             (let ((copy-of-ht (copy-hash-table ht)))
+               (Assert (equal ht copy-of-ht))
+               (Assert (not (eq ht copy-of-ht)))
+               (Assert (eq  (hash-table-count ht)
+                            (hash-table-count copy-of-ht)))
+               (Assert (eq  (hash-table-type  ht)
+                            (hash-table-type  copy-of-ht)))
+               (Assert (eq  (hash-table-size  ht)
+                         (hash-table-size  copy-of-ht)))
+               (Assert (eql (hash-table-rehash-size ht)
+                            (hash-table-rehash-size copy-of-ht)))
+               (Assert (eql (hash-table-rehash-threshold ht)
+                            (hash-table-rehash-threshold copy-of-ht))))))
 
   (let ((ht (make-hash-table :size 100 :rehash-threshold .6 :test 'eq)))
     (dotimes (j iterations)
--- a/tests/automated/lisp-tests.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/tests/automated/lisp-tests.el	Fri Oct 28 23:52:26 2011 +0900
@@ -570,11 +570,11 @@
 (Check-Error wrong-type-argument (% 10.0 2))
 (Check-Error wrong-type-argument (% 10 2.0))
 
-(flet ((test1 (x) (Assert (eql x (+ (% x 17) (* (/ x 17) 17))) x))
-       (test2 (x) (Assert (eql (- x) (+ (% (- x) 17) (* (/ (- x) 17) 17))) x))
-       (test3 (x) (Assert (eql x (+ (% (- x) 17) (* (/ (- x) 17) 17))) x))
-       (test4 (x) (Assert (eql (% x -17) (- (% (- x) 17))) x))
-       (test5 (x) (Assert (eql (% x -17) (% (- x) 17))) x))
+(labels ((test1 (x) (Assert (eql x (+ (% x 17) (* (/ x 17) 17))) x))
+         (test2 (x) (Assert (eql (- x) (+ (% (- x) 17) (* (/ (- x) 17) 17))) x))
+         (test3 (x) (Assert (eql x (+ (% (- x) 17) (* (/ (- x) 17) 17))) x))
+         (test4 (x) (Assert (eql (% x -17) (- (% (- x) 17))) x))
+         (test5 (x) (Assert (eql (% x -17) (% (- x) 17))) x))
   (test1 most-negative-fixnum)
   (if (featurep 'bignum)
       (progn
@@ -859,7 +859,7 @@
   (Assert (eq (rassoc "6" x) nil))
   (Assert (eq (rassq  "6" x) nil)))
 
-(flet ((a () (list '(1 . 2) 3 '(4 . 5))))
+(labels ((a () (list '(1 . 2) 3 '(4 . 5))))
   (Assert (let* ((x (a)) (y (remassoc  1 x))) (and (not (eq x y)) (equal y '(3 (4 . 5))))))
   (Assert (let* ((x (a)) (y (remassq   1 x))) (and (not (eq x y)) (equal y '(3 (4 . 5))))))
   (Assert (let* ((x (a)) (y (remrassoc 1 x))) (and (eq x y) (equal y (a)))))
@@ -899,7 +899,7 @@
     (Assert (let* ((x (a)) (y (old-delete 3 x))) (and (eq x y) (equal y '((1 . 2) (4 . 5))))))
     (Assert (let* ((x (a)) (y (old-delq   3 x))) (and (eq x y) (equal y '((1 . 2) (4 . 5))))))))
 
-(flet ((a () (list '("1" . "2") "3" '("4" . "5"))))
+(labels ((a () (list '("1" . "2") "3" '("4" . "5"))))
   (Assert (let* ((x (a)) (y (remassoc  "1" x))) (and (not (eq x y)) (equal y '("3" ("4" . "5"))))))
   (Assert (let* ((x (a)) (y (remassq   "1" x))) (and (eq x y) (equal y (a)))))
   (Assert (let* ((x (a)) (y (remrassoc "1" x))) (and (eq x y) (equal y (a)))))
@@ -1528,31 +1528,31 @@
    (load test-file-name nil t nil)
    (delete-file test-file-name))
 
-(flet ((cl-floor (x &optional y)
-	 (let ((q (floor x y)))
-	   (list q (- x (if y (* y q) q)))))
-       (cl-ceiling (x &optional y)
-	 (let ((res (cl-floor x y)))
-	   (if (= (car (cdr res)) 0) res
-	     (list (1+ (car res)) (- (car (cdr res)) (or y 1))))))
-       (cl-truncate (x &optional y)
-	 (if (eq (>= x 0) (or (null y) (>= y 0)))
-	     (cl-floor x y) (cl-ceiling x y)))
-       (cl-round (x &optional y)
-	 (if y
-	     (if (and (integerp x) (integerp y))
-		 (let* ((hy (/ y 2))
-			(res (cl-floor (+ x hy) y)))
-		   (if (and (= (car (cdr res)) 0)
-			    (= (+ hy hy) y)
-			    (/= (% (car res) 2) 0))
-		       (list (1- (car res)) hy)
-		     (list (car res) (- (car (cdr res)) hy))))
-	       (let ((q (round (/ x y))))
-		 (list q (- x (* q y)))))
-	   (if (integerp x) (list x 0)
-	     (let ((q (round x)))
-	       (list q (- x q))))))
+(labels ((cl-floor (x &optional y)
+           (let ((q (floor x y)))
+             (list q (- x (if y (* y q) q)))))
+         (cl-ceiling (x &optional y)
+           (let ((res (cl-floor x y)))
+             (if (= (car (cdr res)) 0) res
+               (list (1+ (car res)) (- (car (cdr res)) (or y 1))))))
+         (cl-truncate (x &optional y)
+           (if (eq (>= x 0) (or (null y) (>= y 0)))
+               (cl-floor x y) (cl-ceiling x y)))
+         (cl-round (x &optional y)
+           (if y
+               (if (and (integerp x) (integerp y))
+                   (let* ((hy (/ y 2))
+                          (res (cl-floor (+ x hy) y)))
+                     (if (and (= (car (cdr res)) 0)
+                              (= (+ hy hy) y)
+                              (/= (% (car res) 2) 0))
+                         (list (1- (car res)) hy)
+                       (list (car res) (- (car (cdr res)) hy))))
+                 (let ((q (round (/ x y))))
+                   (list q (- x (* q y)))))
+             (if (integerp x) (list x 0)
+               (let ((q (round x)))
+                 (list q (- x q))))))
        (Assert-rounding (first second &key
 			 one-floor-result two-floor-result 
 			 one-ffloor-result two-ffloor-result 
@@ -2099,24 +2099,24 @@
 
 ;; Multiple value tests. 
 
-(flet ((foo (x y) 
-	 (floor (+ x y) y))
-       (foo-zero (x y)
-	 (values (floor (+ x y) y)))
-       (multiple-value-function-returning-t ()
-	 (values t pi e degrees-to-radians radians-to-degrees))
-       (multiple-value-function-returning-nil ()
-	 (values nil pi e radians-to-degrees degrees-to-radians))
-       (function-throwing-multiple-values ()
-	 (let* ((listing '(0 3 4 nil "string" symbol))
-		(tail listing)
-		elt)
-	   (while t
-	     (setq tail (cdr listing)
-		   elt (car listing)
-		   listing tail)
-	     (when (null elt)
-	       (throw 'VoN61Lo4Y (multiple-value-function-returning-t)))))))
+(labels ((foo (x y) 
+           (floor (+ x y) y))
+         (foo-zero (x y)
+           (values (floor (+ x y) y)))
+         (multiple-value-function-returning-t ()
+           (values t pi e degrees-to-radians radians-to-degrees))
+         (multiple-value-function-returning-nil ()
+           (values nil pi e radians-to-degrees degrees-to-radians))
+         (function-throwing-multiple-values ()
+           (let* ((listing '(0 3 4 nil "string" symbol))
+                  (tail listing)
+                  elt)
+             (while t
+               (setq tail (cdr listing)
+                     elt (car listing)
+                     listing tail)
+               (when (null elt)
+                 (throw 'VoN61Lo4Y (multiple-value-function-returning-t)))))))
   (Assert
    (= (+ (floor 5 3) (floor 19 4)) (+ 1 4) 5)
    "Checking that multiple values are discarded correctly as func args")
@@ -2509,10 +2509,10 @@
   (Assert (equal expected (merge 'list list '(1) #'<))
 	  "checking merge's circularity checks are sane"))
 
-(flet ((list-nreverse (list)
-	 (do ((list1 list (cdr list1))
-	      (list2 nil (prog1 list1 (setcdr list1 list2))))
-	     ((atom list1) list2))))
+(labels ((list-nreverse (list)
+           (do ((list1 list (cdr list1))
+                (list2 nil (prog1 list1 (setcdr list1 list2))))
+               ((atom list1) list2))))
   (let* ((integers (loop for i from 0 to 6000 collect i))
 	 (characters (mapcan #'(lambda (integer)
 				 (if (char-int-p integer)
@@ -2898,16 +2898,17 @@
 ;; behave incorrectly when compiled for the contorted-example function of
 ;; CLTL2, whence the following test:
 
-(flet ((needs-lexical-context (first second third)
-	 (if (eql 0 first)
-	     (funcall second)
-	   (block awkward
-	     (+ 5 (needs-lexical-context
-		   (1- first)
-		   third
-		   #'(lambda () (return-from awkward 0)))
-		first)))))
-  (if (compiled-function-p (symbol-function 'needs-lexical-context))
+(labels ((needs-lexical-context (first second third)
+           (if (eql 0 first)
+               (funcall second)
+             (block awkward
+               (+ 5 (needs-lexical-context
+                     (1- first)
+                     third
+                     #'(lambda () (return-from awkward 0)))
+                  first)))))
+  (if (compiled-function-p
+       (ignore-errors (indirect-function #'needs-lexical-context)))
       (Known-Bug-Expect-Failure
        (Assert (eql 0 (needs-lexical-context 2 nil nil))
 	"the function special operator doesn't create a lexical context."))
@@ -2939,4 +2940,50 @@
   (Check-Error wrong-number-of-arguments (apply-partially))
   (Assert (equal (funcall construct-list) '(5 6 7))))
 
+;; Test labels and inlining.
+(labels
+    ((+ (&rest arguments)
+       ;; Shades of Java, hah.
+       (mapconcat #'prin1-to-string arguments ", "))
+     (print-with-commas (stream one two three four five)
+       (princ (+ one two three four five) stream))
+     (bookend (open close &rest arguments)
+       (refer-to-bookend (concat open (apply #'+ arguments) close)))
+     (refer-to-bookend (string)
+       (bookend "[" "]" string "hello" "there")))
+  (declare (inline + print-with-commas bookend refer-to-bookend))
+  (macrolet
+      ((with-first-arguments (&optional form)
+        (append form (list 1 [hi there] 40 "this is a string" pi)))
+       (with-second-arguments (&optional form)
+         (append form (list pi e ''hello ''there [40 50 60])))
+       (with-both-arguments (&optional form)
+         (append form
+                 (macroexpand '(with-first-arguments))
+                 (macroexpand '(with-second-arguments)))))
+
+    (with-temp-buffer
+      (Assert
+       (equal
+        (mapconcat #'prin1-to-string (with-first-arguments (list)) ", ")
+        (with-first-arguments (print-with-commas (current-buffer))))
+     "checking print-with-commas gives the expected result")
+      (Assert
+       (or
+        (not (compiled-function-p (indirect-function #'print-with-commas)))
+        (notany #'compiled-function-p
+                (compiled-function-constants
+                 (indirect-function #'print-with-commas))))
+       "checking the label + was inlined correctly")
+      (insert ", ")
+      ;; This call to + will be inline in compiled code, but there's
+      ;; no easy way for us to check that:
+      (Assert (null (insert (with-second-arguments (+)))))
+      (Assert (equal
+               (mapconcat #'prin1-to-string (with-both-arguments (list)) ", ")
+               (buffer-string))
+              "checking the buffer contents are as expected at the end.")
+      (Assert (not (funcall (intern "eq") #'bookend #'refer-to-bookend))
+	      "checking two mutually recursive functions compiled OK"))))
+
 ;;; end of lisp-tests.el
--- a/tests/automated/mule-tests.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/tests/automated/mule-tests.el	Fri Oct 28 23:52:26 2011 +0900
@@ -647,7 +647,7 @@
     finally (set-language-environment original-language-environment))
 
   (with-temp-buffer
-    (flet
+    (labels
         ((Assert-elc-is-escape-quoted ()
            "Assert the current buffer has an escape-quoted cookie if compiled."
            (save-excursion
--- a/tests/automated/os-tests.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/tests/automated/os-tests.el	Fri Oct 28 23:52:26 2011 +0900
@@ -62,13 +62,13 @@
       (while cases
         (setq case (car cases)
 	      cases (cdr cases))
-	(flet ((do-test (pos result)
-		 (erase-buffer)
-		 (insert original-string)
-		 (goto-char pos)
-		 (call-process-region 3 7 "tac" t t)
-		 (goto-char (point-min))
-		 (Assert (looking-at result))))
+	(labels ((do-test (pos result)
+                   (erase-buffer)
+                   (insert original-string)
+                   (goto-char pos)
+                   (call-process-region 3 7 "tac" t t)
+                   (goto-char (point-min))
+                   (Assert (looking-at result))))
 	  (do-test (car case) (cdr case)))))
     ;; if you're in that much of a hurry you can blow cat off
     ;; if you've done tac, but I'm not going to bother
@@ -80,13 +80,13 @@
       (while cases
         (setq case (car cases)
 	      cases (cdr cases))
-	(flet ((do-test (pos result)
-		 (erase-buffer)
-		 (insert original-string)
-		 (goto-char pos)
-		 (call-process-region 3 7 "cat" t t)
-		 (goto-char (point-min))
-		 (Assert (looking-at result))))
+	(labels ((do-test (pos result)
+                   (erase-buffer)
+                   (insert original-string)
+                   (goto-char pos)
+                   (call-process-region 3 7 "cat" t t)
+                   (goto-char (point-min))
+                   (Assert (looking-at result))))
 	  (do-test (car case) (cdr case)))))))
 
 (loop
--- a/tests/automated/symbol-tests.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/tests/automated/symbol-tests.el	Fri Oct 28 23:52:26 2011 +0900
@@ -66,20 +66,20 @@
     (Assert (not (eq interned uninterned)))
     (Assert (not (equal interned uninterned)))))
 
-(flet ((check-weak-list-unique (weak-list &optional reversep)
-	 "Check that elements of WEAK-LIST are referenced only there."
-	 (let ((len (length (weak-list-list weak-list))))
-	   (if (string-match "Using the new GC algorithms."
-			     Installation-string)
-	       (Implementation-Incomplete-Expect-Failure
-		(Assert (not (zerop len)))
-		(garbage-collect)
-		(Assert (eq (length (weak-list-list weak-list))
-			    (if (not reversep) 0 len))))
-	     (Assert (not (zerop len)))
-	     (garbage-collect)
-	     (Assert (eq (length (weak-list-list weak-list))
-			 (if (not reversep) 0 len)))))))
+(labels ((check-weak-list-unique (weak-list &optional reversep)
+           "Check that elements of WEAK-LIST are referenced only there."
+           (let ((len (length (weak-list-list weak-list))))
+             (if (string-match "Using the new GC algorithms."
+                               Installation-string)
+                 (Implementation-Incomplete-Expect-Failure
+                  (Assert (not (zerop len)))
+                  (garbage-collect)
+                  (Assert (eq (length (weak-list-list weak-list))
+                              (if (not reversep) 0 len))))
+               (Assert (not (zerop len)))
+               (garbage-collect)
+               (Assert (eq (length (weak-list-list weak-list))
+                           (if (not reversep) 0 len)))))))
   (let ((weak-list (make-weak-list))
 	(gc-cons-threshold most-positive-fixnum))
     ;; Symbols created with `make-symbol' and `gensym' should be fresh
--- a/tests/automated/syntax-tests.el	Fri Oct 14 03:54:46 2011 +0900
+++ b/tests/automated/syntax-tests.el	Fri Oct 28 23:52:26 2011 +0900
@@ -179,10 +179,10 @@
   (insert "a ( \"b (c\" (\"defg\") \")\") h\n")
 
   ;; #### This test should check *every* position.
-  (flet ((backward-up-list-moves-point-from-to (start expected-end)
-	   (goto-char start)
-	   (backward-up-list 1)
-	   (= (point) expected-end)))
+  (labels ((backward-up-list-moves-point-from-to (start expected-end)
+             (goto-char start)
+             (backward-up-list 1)
+             (= (point) expected-end)))
     (Known-Bug-Expect-Failure
      ;; Evgeny's case
      (Assert (backward-up-list-moves-point-from-to 16 12)))