;;; Descriptions of built-in functions in XEmacs 21.5
;;; Author: Jeremiah W. James a.k.a. Jerry James <james@xemacs.org>
;;;
;;; Copyright (C) 2007 by Jeremiah W. James
;;; FIXME: Choose a license

;;; The XEmacs 21.5 type tree.  Note that 't is the top-level all-inclusive
;;; type.  Note also that this type tree only MOSTLY follows the built-in
;;; XEmacs 21.5 types.  In some cases, we have provided "virtual" or
;;; conceptual types that allow for stricter type checking.  Also note that
;;; nil is ALWAYS a value of type null; it has no other type.  This makes many
;;; type descriptors more verbose, but allows us to check for misuses of nil.
(type-tree
 (t null (character string-char) (symbol keyword)
    (number (rational (int bignum (fixnum bit)) ratio) bigfloat float)
    (sequence (vector bit-vector obarray) list string) lrecord-list
    (function (fun hook-function) subr macro) weak-list hash-table lstream
    process charset coding-system (char-table category-table) char-table-entry
    range-table opaque opaque-ptr buffer extent extent-info extent-auxiliary
    marker event keymap command-builder timeout specifier
    (console tty-console stream-console)
    (device x-device gtk-device tty-device mswindows-device msprinter-device)
    (frame x-frame gtk-frame mswindows-frame) window window-mirror
    window-configuration gui-item popup-data toolbar-button
    scrollbar-instance color-instance font-instance image-instance glyph
    face fc-pattern database tooltalk-message tooltalk-pattern ldap pgconn
    pgresult devmode mswindows-dialog-id case-table emacs-ffi
    emacs-gtk-object emacs-gtk-boxed weak-box ephemeron free undefined
    string-indirect-data string-direct-data hash-table-entry syntax-cache
    buffer-text compiled-function-args dynarr face-cachel face-cachel-dynarr
    glyph-cachel glyph-cachel-dynarr gap-array-marker gap-array
    extent-list-marker extent-list stack-of-extents tty-color-instance-data
    tty-font-instance-data specifier-caching expose-ignore))

;;; The XEmacs 21.5 type equivalence table.  Each type descriptor on the left
;;; is equivalent to the type descriptor on the right.
;;; FIXME: This is far from complete.
(type-equiv
 (bignum (and int (not fixnum)))
 (bit (fixnum (0 . 1)))
 (bit-vector (vector bit))
 (fixnum (int (most-negative-fixnum . most-positive-fixnum)))
 (hook-function (fun () t))
 (obarray (vector (symbol :value string)))
 (sequence (sequence t)))

;;; The XEmacs 21.5 type abbreviation table.  These are like C typedefs,
;;; giving names to frequently used type descriptors.
(type-abbrev
 (abbrev-table obarray)
 (array (or string vector bit-vector))
 (boolean (member nil t))
 (natnum (fixnum (0 . *)))
 (hook (or hook-function (list hook-function)))
 (hook-symbol (symbol :value hook))
 (ordered (or number character marker)))

;;; The XEmacs 21.5 builtin functions.  Each entry is the symbol name,
;;; followed by the type descriptor bound to that symbol's function slot.
(builtin-functions

 ;; abbrev.c
 (expand-abbrev (fun () (or null symbol)))
 (insert-abbrev-table-description
  (fun ((symbol :value abbrev-table) &optional t) null))

 ;; alloc.c
 (cons (fun (:A null) (list :A 1))
       (fun (:A (list :A :B)) (list :A (+ :B 1)))
       (fun (:A :B) (cons :A :B)))
 (list (fun (&rest :A) (list :A :num-args)))
 (make-list (fun (:A :B) (list :B :A)))
 (make-vector (fun (:A :B) (vector :B :A)))
 (vector (fun (&rest :A) (vector :A :num-args)))
 (make-bit-vector (:A bit) (bit-vector :A))
 (bit-vector (&rest bit) (bit-vector :num-args))
 (make-byte-code (fun ((or null (list symbol))
		       (or string (cons string fixnum)) ;; FIXME: nonnegative?
		       (or null (vector
				 (or symbol string
				     (cons (or symbol string) fixnum))))
		       natnum &optional string list)
		      fun))
 (make-symbol (fun (string) symbol))
 (make-marker (fun () marker))
 (make-string (fun (natnum (or character fixnum)) string))
 (string (fun (&rest (or null (list (or character fixnum)))) string))
 (purecopy (fun (:A) :A))
 (object-memory-usage-stats (fun () (list (types string fixnum))))
 (garbage-collect (fun () null))
 (consing-since-gc (fun () natnum))
 (total-memory-usage (fun () natnum))
 (object-memory-usage (fun () natnum))

 ;; balloon-x.c
 (show-balloon-help (fun (string) null))
 (hide-balloon-help (fun () null))
 (balloon-help-move-to-pointer (fun () null))

 ;; buffer.c
 (bufferp (fun (buffer) (member t))
	  (fun (t) null))
 (buffer-live-p (fun (t) boolean))
 (buffer-list (fun (&optional (or (member t) frame)) (list buffer)))
 (decode-buffer (fun ((or null string buffer)) buffer))
 (get-buffer (fun ((or string buffer)) (or null buffer)))
 (get-file-buffer (fun (string) (or null buffer)))
 (get-buffer-create (fun ((or string buffer)) buffer))
 (make-indirect-buffer (fun ((or buffer string) string) buffer))
 (generate-new-buffer-name (fun (string &optional string) string))
 (buffer-name (fun (&optional buffer) string))
 (buffer-file-name (fun (&optional buffer) string))
 (buffer-base-buffer (fun ((or null string buffer)) (or null buffer)))
 (buffer-indirect-children (fun ((or null string buffer)) (list buffer)))
 (buffer-local-variables (fun (&optional (or string buffer))
			      (list (or symbol (cons symbol t)))))
 (buffer-modified-p (fun (&optional (or string buffer)) boolean))
 (set-buffer-modified-p (fun (:A &optional (or string buffer)) :A))
 (buffer-modified-tick (fun (&optional (or string buffer)) fixnum))
 (rename-buffer (fun (string &optional t) string))
 (other-buffer (fun (&optional buffer (or string frame) t) buffer))
 (buffer-disable-undo (fun (&optional (or string buffer)) null))
 (buffer-enable-undo (fun (&optional (or string buffer)) null))
 (kill-buffer (fun ((or null string buffer)) boolean))
 (record-buffer (fun (buffer) null))
 (set-buffer-major-mode (fun ((or string buffer)) null))
 (current-buffer (fun () buffer))
 (set-buffer (fun ((or string buffer)) buffer))
 (barf-if-buffer-read-only
  (fun (&optional (or string buffer) (or fixnum marker) (or fixnum marker))
       null))
 (bury-buffer (fun (&optional (or string buffer) (or string buffer)) null))
 (erase-buffer (fun (&optional (or string buffer)) null))
 (kill-all-local-variables (fun () null))
 (buffer-memory-usage (fun (buffer) (list (or null (cons symbol fixnum)))))
 (buffer-char-byte-conversion-info (fun (buffer) (list symbol t)))
 (string-char-byte-conversion-info (fun (string) (list symbol t)))

 ;; bytecode.c
 (compiled-function-p (fun (t) boolean))
 (compiled-function-arglist (fun (function) (list symbol)))
 (compiled-function-instructions (fun (function) string))
 (compiled-function-constants (fun (function) (vector symbol)))
 (compiled-function-stack-depth (fun (function) fixnum))
 (compiled-function-doc-string (fun (function) string))
 (compiled-function-interactive (fun (function) (or null (list symbol))))
 (compiled-function-annotation (fun (function) (or string symbol)))
 (compiled-function-domain (fun (function) t))
 (fetch-bytecode (fun (function) function))
 (optimize-compiled-function (fun (function) null))
 (byte-code (fun (string (vector symbol) fixnum) t))

 ;; callint.c
 (interactive (fun (&rest t) null))
 (quote-maybe (fun (null) null)
	      (fun ((member t)) (member t))
	      (fun (fixnum) fixnum)
	      (fun (float) float)
	      (fun (character) character)
	      (fun (string) string)
	      (fun ((vector :A :B)) (vector :A :B))
	      (fun (keyword) keyword)
	      (fun ((bit-vector :A)) (bit-vector :A))
	      (fun (t) list))
 (call-interactively (fun ((fun () t) &optional symbol
			   (or string (vector event)))
			  t))
 ;; FIXME: a list of what?  It starts with a number.  What else do we know?
 (prefix-numeric-value (fun ((or symbol fixnum list)) fixnum))

 ;; casefiddle.c
 (upcase (restrict ((:A (or character string)))
		   (fun (:A &optional (or string buffer)) :A)))
 (downcase (restrict ((:A (or character string)))
		     (fun (:A &optional (or string buffer)) :A)))
 (capitalize (restrict ((:A (or character string)))
		       (fun (:A &optional (or string buffer)) :A)))
 (upcase-initials (restrict ((:A (or character string)))
			    (fun (:A &optional (or string buffer)) :A)))
 (upcase-region (fun ((or fixnum marker) (or fixnum marker)
		      &optional (or string buffer))
		     null))
 (downcase-region (fun ((or fixnum marker) (or fixnum marker)
			&optional (or string buffer))
		       null))
 (capitalize-region (fun ((or fixnum marker) (or fixnum marker)
			  &optional (or string buffer))
			 null))
 (upcase-initials-region (fun ((or fixnum marker) (or fixnum marker)
			       &optional (or string buffer))
			      null))
 (upcase-word (fun (fixnum &optional (or string buffer)) null))
 (downcase-word (fun (fixnum &optional (or string buffer)) null))
 (capitalize-word (fun (fixnum &optional (or string buffer)) null))

 ;; casetab.c
 (make-case-table (fun () case-table))
 (case-table-p (fun (t) boolean))
 (get-case-table (fun ((member 'downcase 'upcase) character case-table)
		      character))
 (put-case-table (fun ((member 'downcase 'upcase) character character
		       case-table)
		      null))
 (put-case-table-pair (fun (character character case-table) null))
 (copy-case-table (fun (case-table) case-table))
 (current-case-table (fun (&optional (or string buffer)) case-table))
 (standard-case-table (fun () case-table))
 (set-case-table (fun (case-table) case-table))
 (set-standard-case-table (fun (case-table) case-table))

 ;; chartab.c
 (char-table-p (fun (t) boolean))
 (char-table-type-list (fun () (list symbol)))
 (valid-char-table-type-p (fun (symbol) boolean))
 (char-table-type (fun (char-table) symbol))
 (reset-char-table (fun (char-table) null))
 (make-char-table (fun (symbol) char-table))
 ;; FIXME: produces the same kind of char-table as its arg!
 (copy-char-table (fun (char-table) char-table))
 (char-table-default (fun (char-table)
			  (or null character fixnum
			      (cons fixnum (or character fixnum)))))
 (set-char-table-default (fun (char-table
			       (or null character fixnum
				   (cons fixnum (or character fixnum))))
			      null))
 (get-char-table (fun ((or character fixnum) char-table)
		      (or null character fixnum
			  (cons fixnum (or character fixnum)))))
 ;; FIXME: The return type is (or null character fixnum
 ;; (cons fixnum (or character fixnum))) if there is one value, and is the type
 ;; of the optional argument otherwise.
 (get-range-char-table (fun ((or character charset fixnum (member t)
				 (vector (types charset fixnum) 2))
			     char-table &optional t)
			    t))
 (valid-char-table-value-p (fun ((or null character fixnum
				     (cons fixnum (or character fixnum))))
				boolean))
 (check-valid-char-table-value (fun ((or null character fixnum
					 (cons fixnum (or character fixnum)))
				     symbol)
				    null))
 (put-char-table (fun ((or symbol character charset
			   (vector (types charset fixnum) 2)) char-table)
		      null))
 (remove-char-table (fun ((or (member t) character charset
			      (vector (types charset fixnum) 2)) char-table)
			 null))
 (map-char-table (fun ((fun ((or (member t) character charset
				 (vector (types charset fixnum) 2))
			     (or null character fixnum
				 (cons fixnum (or character fixnum))))
			    t)
		       char-table
		       &optional (or (member t) character charset
				     (vector (types charset fixnum) 2)))
		      t))
 (category-table-p (fun (t) boolean))
 (check-category-at (fun (fixnum character &optional (or buffer string)
				 category-table)
			 boolean))
 (char-in-category-p (fun (character character &optional category-table)
			  boolean))
 (category-table (fun (&optional (or buffer string)) category-tabl))
 (standard-category-table (fun () category-table))
 (copy-category-table (fun (category-table) category-table))
 (set-category-table (fun (category-table &optional (or buffer string))
			  category-table))
 (category-designator-p (fun (t) boolean))
 (category-table-value-p (fun (t) boolean))

 ;; cmdloop.c
 (really-early-error-handler (fun ((fun ((cons symbol (list t))) t)) null))
 (recursive-edit (fun () null))
 (command-loop-1 (fun () null))

 ;; cmds.c
 (forward-char (fun (&optional fixnum (or buffer string)) null))
 (backward-char (fun (&optional fixnum (or buffer string)) null))
 (forward-line (fun (&optional fixnum (or buffer string)) fixnum))
 (point-at-bol (fun (&optional fixnum (or buffer string)) fixnum))
 (beginning-of-line (fun (&optional fixnum (or buffer string)) null))
 (point-at-eol (fun (&optional fixnum (or buffer string)) fixnum))
 (end-of-line (fun (&optional fixnum (or buffer string)) null))
 (delete-char (fun (&optional fixnum t) null))
 (delete-backward-char (fun (&optional fixnum t) null))
 (self-insert-command (fun (natnum) null))
 (self-insert-internal (fun (or character fixnum) null))

 ;; console.c
 (valid-console-type-p (fun (symbol) boolean))
 (console-type-list (fun () (list symbol)))
 (cdfw-console (fun ((or console device frame window)) console))
 (cdfw-console (fun (t) null))
 (selected-console (fun () console))
 (select-console (fun (console) null))
 (consolep (fun (console) (member t))
	   (fun (t) null))
 (console-live-p (fun (t) boolean))
 (console-type (fun (&optional console) symbol))
 (console-name (fun (&optional console) string))
 (console-connection (fun (&optional console) (or null string)))
 (find-console (fun (string &optional symbol) (or null console)))
 (get-console (fun (string &optional symbol) console))
 (delete-console (fun (console &optional t) null))
 (console-list (fun () (list console)))
 (console-device-list (fun (&optional console) (list device)))
 (console-enable-input (fun (console) null))
 (console-disable-input (fun (console) null))
 (console-on-window-system-p (fun (&optional console) boolean))
 (suspend-emacs (fun (&optional string) null))
 (suspend-console (fun (&optional console) null))
 (resume-console (fun (console) null))
 (set-input-mode (fun (t t t &optional (or character fixnum) console) null))
 (current-input-mode (fun (&optional console)
			  (list (types null t t character) 4)))

 ;; console-msw.c
 (mswindows-debugging-output (restrict ((:A (or character fixnum string))
					(fun (:A) :A))))
 (mswindows-message-box
  (fun (string &optional (or symbol (list symbol)) string) null))

 ;; console-tty.c
 (console-tty-terminal-type (fun (&optional tty-console) string))
 (console-tty-controlling-process (fun (&optional tty-console) fixnum))
 (console-tty-input-coding-system (fun (&optional tty-console) coding-system))
 (set-console-tty-input-coding-system
  (fun (&optional tty-console coding-system) null))
 (console-tty-output-coding-system (fun (&optional tty-console) coding-system))
 (set-console-tty-output-coding-system
  (fun (&optional tty-console coding-system) null))
 (console-tty-multiple-width (fun (&optional tty-console) boolean))
 (set-console-tty-multiple-width (fun (&optional tty-console boolean) null))
 (set-console-tty-coding-system (fun (&optional tty-console coding-system)
				     null))

 ;; data.c
 (wrong-type-argument (fun ((fun (:A) t) :A) :A))
 (eq (fun (t t) boolean))
 (old-eq (fun (t t) boolean))
 (null (fun (null) (member t))
       (fun (t) null))
 (consp (fun (cons) (member t))
	(fun (t) null))
 (atom (fun (cons) null)
       (fun (t) (member t)))
 (listp (fun (list) (member t))
	(fun (t) null))
 (nlistp (fun (list) null)
	 (fun (t) (member t)))
 (true-list-p (fun (t) boolean))
 (symbolp (fun (symbol) (member t))
	  (fun (t) null))
 (keywordp (fun (t) boolean))
 (vectorp (fun (vector) (member t))
	  (fun (t) null))
 (bit-vectorp (fun (bit-vector) (member t))
	      (fun (t) null))
 (stringp (fun (string) (member t))
	  (fun (t) null))
 (arrayp (fun (array) (member t))
	 (fun (t) null))
 (sequencep (fun (sequence) (member t))
	    (fun (t) null))
 (markerp (fun (marker) (member t))
	  (fun (t) null))
 (subrp (fun (subr) (member t))
	(fun (t) null))
 (subr-min-args (fun (subr) natnum))
 (subr-max-args (fun (subr) (or null natnum)))
 (subr-interactive (fun (subr) (or null (list (types symbol string) 2))))
 (characterp (fun (character) (member t))
	     (fun (t) null))
 (char-to-int (fun (character) fixnum))
 (int-to-char (fun (fixnum) (or null character)))
 (char-int-p (fun (t) boolean))
 (char-or-char-int-p (fun (t) boolean))
 (char-or-string-p (fun ((or character string)) (member t))
		   (fun (t) null))
 (fixnump (fun (fixnum) (member t))
	  (fun (t) null))
 (integerp (fun (int) (member t))
	   (fun (t) null))
 (integer-or-marker-p (fun ((or int marker)) (member t))
		      (fun (t) null))
 (integer-or-char-p (fun ((or int character)) (member t))
		    (fun (t) null))
 (integer-char-or-marker-p (fun ((or int character marker)) (member t))
			   (fun (t) null))
 (natnump (fun (t) boolean))
 (nonnegativep (fun (t) boolean))
 (bitp (fun (bit) (member t))
       (fun (t) null))
 (numberp (fun (number) (member t))
	  (fun (t) null))
 (number-or-marker-p (fun ((or number marker)) (member t))
		     (fun (t) null))
 (number-char-or-marker-p (fun (ordered) (member t))
			  (fun (t) null))
 (floatp (fun (float) (member t))
	 (fun (t) null))
 (type-of (fun (t) symbol))
 (car (fun ((cons :A :B)) :A)
      (fun ((list :A)) :A)
      (fun (list) t)
      (fun (null) null))
 (car-safe (fun ((cons :A :B)) :A)
	   (fun ((list :A)) :A)
	   (fun (list) t)
	   (fun (null) null))
 (cdr (fun ((cons :A :B)) :B)
      (fun ((list :A :B)) (list :A (- :B 1)))
      (fun ((list :A)) (or null (list :A)))
      (fun (list) (or null list))
      (fun (null) null))
 (cdr-safe (fun ((cons :A :B)) :B)
	   (fun ((list :A :B)) (list :A (- :B 1)))
	   (fun ((list :A)) (or null (list :A)))
	   (fun (list) (or null list))
	   (fun (null) null))
 (setcar (fun ((cons :A :B) :C) (cons :C :B))
	 (fun ((list :A :B) :A) (list :A :B))
	 (fun (list) list))
 (setcdr (fun ((cons :A :B) null) (list :A 1))
	 (fun ((cons :A :B) :C) (cons :A :C))
	 (fun ((list :A :B) null) (list :A 1))
	 (fun ((list :A :B) (list :A :C)) (list :A (+ :C 1)))
	 (fun (list t) list))
 (indirect-function (fun (symbol) fun)
		    (fun (:A) :A))
 (aref (fun (string (or character natnum)) character)
       (fun (bit-vector (or character natnum)) bit)
       (fun ((vector :A) (or character natnum)) :A))
 (aset (fun (string (or character natnum) character) character)
       (fun (bit-vector (or character natnum) bit) bit)
       (fun ((vector :A) (or character natnum) :A) :A))
 (= (fun (ordered &rest ordered) boolean))
 (< (fun (ordered &rest ordered) boolean))
 (> (fun (ordered &rest ordered) boolean))
 (<= (fun (ordered &rest ordered) boolean))
 (>= (fun (ordered &rest ordered) boolean))
 (/= (fun (ordered &rest ordered) boolean))
 (zerop (fun (number) boolean))
 (number-to-string (fun (number) string))
 (string-to-number (fun (string) number))
 (+ (fun (&rest ordered) number))
 (- (fun (ordered &rest ordered) number))
 (* (fun (&rest ordered) number))
 (div (fun (ordered &rest ordered) number))
 (/ (fun (ordered &rest ordered) number))
 (max (fun (ordered &rest ordered) number))
 (min (fun (ordered &rest ordered) number))
 (logand (fun (&rest ordered) number))
 (logior (fun (&rest ordered) number))
 (logxor (fun (&rest ordered) number))
 (lognot (fun (ordered) number))
 (% (fun (ordered ordered) number))
 (mod (fun (ordered ordered) number))
 (ash (fun ((or int character) int) int))
 (lsh (fun (ordered int) int))
 (1+ (fun (ordered) number))
 (1- (fun (ordered) number))
 (weak-list-p (fun (weak-list) (member t))
	      (fun (t) null))
 (make-weak-list (fun (&optional symbol) weak-list))
 (weak-list-type (fun (weak-list) symbol))
 (weak-list-list (fun (weak-list) (or null list)))
 (set-weak-list-list (fun (weak-list list) list))
 (make-weak-box (fun (:A) (weak-box :A)))
 (weak-box-ref (fun ((weak-box :A)) (or null :A)))
 (weak-box-p (fun (weak-box) (member t))
	     (fun (t) null))
 (make-ephemeron (fun (:A :B &optional (fun (:B) t)) (ephemeron :A :B)))
 (ephemeron-ref (fun ((ephemeron :A :B)) :B))
 (ephemeron-p (fun (ephemeron) (member t))
	      (fun (t) null))

 ;; database.c
 (close-database (fun (database) null))
 (database-type (fun (database) symbol))
 (database-subtype (fun (database) (or null symbol)))
 (database-live-p (fun (t) boolean))
 (database-file-name (fun (database) string))
 (databasep (fun (database) (member t))
	    (fun (t) null))
 (database-last-error (fun (&optional database) string))
 (open-database
  (fun (string &optional symbol symbol string fixnum coding-system)
       (or null database)))
 (put-database (fun (string string database &optional t) boolean))
 (remove-database (fun (string database) boolean))
 (get-database (fun (string database &optional :A) (or string :A)))
 (map-database (fun ((fun (string string) t) database) null))

 ;; debug.c
 (add-debug-class-to-check (fun (symbol) (list symbol)))
 (delete-debug-class-to-check (fun (symbol) (or null (list symbol))))
 (debug-classes-being-checked (fun () (or null (list symbol))))
 (debug-classes-list (fun () (list symbol)))
 (set-debug-classes-to-check (fun ((or null (list symbol)))
				  (or null (list symbol))))
 (set-debug-class-types-to-check (fun (symbol fixnum) fixnum))
 (debug-types-being-checked (fun (symbol) fixnum))

 ;; device.c
 (valid-device-class-p (fun (symbol) boolean))
 (device-class-list (fun () (list symbol)))
 (dfw-device (fun ((or device frame window)) device)
	     (fun (t) null))
 (selected-device (fun (&optional console) device))
 (select-device (fun (device) null))
 (set-device-selected-frame (fun (device frame) frame))
 (devicep (fun (device) (member t))
	  (fun (t) null))
 (device-live-p (fun (t) boolean))
 (device-name (fun (&optional device) string))
 (device-connection (fun (&optional device) (or null string)))
 (device-console (fun (&optional device) console))
 (default-device (fun (&optional symbol) (or null device)))
 (find-device (fun (string &optional symbol) (or null device)))
 (get-device (fun (string &optional symbol) device))
 (make-device (fun (symbol (or null string) &optional list) device))
 (delete-device (fun (device &optional t) null))
 (device-frame-list (fun (&optional device) (list frame)))
 (device-class (fun (&optional device) symbol))
 (set-device-class (fun (device symbol) null))
 (set-device-baud-rate (fun (device fixnum) fixnum))
 (device-baud-rate (fun (&optional device) fixnum))
 (device-printer-p (fun (&optional device) boolean))
 ;; FIXME: There are a lot of possibilities; do we need to list them all?
 (device-system-metric (fun (device &optional symbol t) t))
 (device-system-metrics (fun (&optional device) list))
 (domain-device-type (fun (&optional (or window frame device console)) symbol))

 ;; device-gtk.c
 (gtk-init (fun ((list string)) (member t)))
 (gtk-display-visual-class (fun (&optional gtk-device) symbol))
 (gtk-display-visual-depth (fun (&optional gtk-device) fixnum))
 (gtk-keysym-on-keyboard-p (fun ((or string symbol) gtk-device) boolean))
 (gtk-grab-pointer (fun (&optional gtk-device glyph t) boolean))
 (gtk-ungrab-pointer (fun (&optional gtk-device) null))
 (gtk-grab-keyboard (fun (&optional gtk-device) (member t)))
 (gtk-ungrab-keyboard (fun (&optional t) null))
 ;; FIXME: A list of what?
 (gtk-style-info (fun (&optional gtk-device) (or null list)))

 ;; device-msw.c
 (msprinter-get-settings (fun (msprinter-device) devmode))
 (msprinter-select-settings (fun (msprinter-device devmode) devmode))
 (msprinter-apply-settings (fun (msprinter-device devmode) devmode))
 (msprinter-settings-copy (fun (devmode) devmode))
 (msprinter-settings-despecialize (fun (devmode) null))
 (mswindows-get-default-printer (fun () (or null string)))
 (mswindows-printer-list (fun () (or (list string)
				     (list (types null :repeat string)))))

 ;; device-x.c
 (x-debug-mode (fun (:A &optional x-device) :A))
 (x-get-resource
  (fun (string string (member 'string) &optional
	       (or buffer frame device (member 'global)) x-device t)
       string)
  (fun (string string (member 'boolean) &optional
	       (or buffer frame device (member 'global)) x-device t)
       (list boolean 1))
  (fun (string string (member 'integer 'natnum) &optional
	       (or buffer frame device (member 'global)) x-device t)
       fixnum))
 (x-get-resource-prefix (fun ((or buffer frame device (member 'global))
			      &optional x-device)
			     (or null (cons string string))))
 (x-put-resource (fun (string &optional x-device) null))
 (default-x-device (fun () x-device))
 (x-display-visual-class (fun (&optional x-device)
			      (member
			       'static-gray 'gray-scale 'static-color
			       'pseudo-color 'true-color 'direct-color)))
 (x-display-visual-depth (fun (&optional x-device) fixnum))
 (x-server-vendor (fun (&optional x-device) string))
 (x-server-version (fun (&optional x-device) (list fixnum 3)))
 (x-valid-keysym-name-p (fun (string) boolean))
 (x-keysym-hash-table (fun (&optional x-device) hash-table))
 (x-keysym-on-keyboard-sans-modifiers-p
  (fun ((or string symbol) &optional x-device) boolean))
 (x-keysym-on-keyboard-p (fun ((or string symbol) &optional x-device) boolean))
 (x-grab-pointer (fun (&optional x-device glyph t) boolean))
 (x-ungrab-pointer (fun (&optional (or x-device (member t))) null))
 (x-grab-keyboard (fun (&optional x-device) boolean))
 (x-ungrab-keyboard (fun (&optional x-device) null))
 (x-get-font-path (fun (&optional x-device) (list string)))
 (x-set-font-path (fun ((or null (list string)) &optional x-device) null))

 ;; dialog.c
 (make-dialog-box-internal (fun (symbol (list (types :repeat keyword t)))
				(or null fixnum string)))

 ;; dired.c
 (directory-files (fun (string &optional t string t t)
		       (or null (list string))))
 (file-name-completion (fun (string string) (or boolean string)))
 (file-name-all-completions (fun (string string) (or null (list string))))
 (user-name-completion (fun (string) (or null string)))
 (user-name-completion-1 (fun (string) (cons (or null string) boolean)))
 (user-name-all-completions (fun (string) (or null string)))
 (file-attributes
  (fun (string)
       (or null (list (types (or boolean string) fixnum fixnum fixnum
			     (list fixnum 2) (list fixnum 2) (list fixnum 2)
			     int string boolean fixnum fixnum)))))

 ;; dired-msw.c
 (mswindows-insert-directory (fun (string string &optional t t) t))

 ;; doc.c
 (built-in-symbol-file (fun (symbol &optional (member 'defun 'defvar)) string))
 (documentation (fun (symbol &optional t) string))
 (documentation-property (fun (symbol symbol &optional t) string))
 (Snarf-documentation (fun (string) null))
 (Verify-documentation (fun () boolean))
 (substitute-command-keys (fun (string) (or null string)))

 ;; editfns.c
 (char-to-string (fun ((or character event fixnum)) string))
 (string-to-char (fun (string) (or null character)))
 (point (fun (&optional buffer) fixnum))
 (point-marker (fun (&optional t buffer) marker))
 (goto-char (fun ((or fixnum marker) &optional buffer) fixnum))
 (region-beginning (fun (&optional buffer) fixnum))
 (region-end (fun (&optional buffer) fixnum))
 (mark-marker (fun (&optional t buffer) (or null marker)))
 ;; FIXME: These are wrong.  They are like progn, which is similarly broken.
 (save-excursion (fun (:A) :A))
 (save-current-buffer (fun (:A) :A))
 ;; END FIXME
 (buffer-size (fun (&optional buffer) fixnum))
 (point-min (fun (&optional buffer) fixnum))
 (point-min-marker (fun (&optional buffer) marker))
 (point-max (fun (&optional buffer) fixnum))
 (point-max-marker (fun (&optional buffer) marker))
 (following-char (fun (&optional buffer) (or character (member 0))))
 (preceding-char (fun (&optional buffer) (or character (member 0))))
 (bobp (fun (&optional buffer) boolean))
 (eobp (fun (&optional buffer) boolean))
 (bolp (fun (&optional buffer) boolean))
 (eolp (fun (&optional buffer) boolean))
 (char-after (fun (&optional (or fixnum marker) buffer) (or null character)))
 (char-before (fun (&optional (or fixnum marker) buffer) (or null character)))
 (temp-directory (fun () string))
 (user-login-name (fun (&optional fixnum) (or null string)))
 (user-real-login-name (fun () string))
 (user-uid (fun () fixnum))
 (user-real-uid (fun () fixnum))
 (user-full-name (fun (&optional (or fixnum string)) (or null string)))
 (user-home-directory (fun () (or null string)))
 (system-name (fun () string))
 (emacs-pid (fun () fixnum))
 (current-time (fun () (list fixnum 3)))
 (current-process-time (fun () (list float 3)))
 (format-time-string (fun (string &optional (cons fixnum fixnum)) string))
 (decode-time (fun (&optional (list (cons fixnum fixnum)))
		   (list fixnum fixnum fixnum fixnum fixnum fixnum fixnum
			 boolean fixnum)))
 (encode-time
  (fun (fixnum fixnum fixnum fixnum fixnum fixnum &optional
	       (or fixnum string (list (types fixnum string) 2)))
       (list fixnum 2))
  (fun (fixnum fixnum fixnum fixnum fixnum fixnum &optional t t
	       (or fixnum string (list (types fixnum string) 2)))
       (list fixnum 2)))
 (current-time-string
  (fun (&optional (or (cons fixnum fixnum)
		      (list (types fixnum (cons fixnum t)) 2)))
       string))
 (current-time-zone
  (fun (&optional (or (cons fixnum fixnum)
		      (list (types fixnum (cons fixnum t)) 2)))
       (list (types fixnum string) 2)))
 (set-time-zone-rule (fun ((or null string)) null))
 (insert (fun (&rest (or character fixnum string)) null))
 (insert-before-markers (fun (&rest (or character fixnum string)) null))
 (insert-string (fun (string &optional buffer) null))
 (insert-char (fun ((or character fixnum) &optional fixnum t buffer) null))
 (buffer-substring (fun (&optional fixnum fixnum buffer) string))
 (buffer-substring-no-properties (fun (&optional fixnum fixnum buffer) string))
 (insert-buffer-substring (fun (buffer &optional fixnum fixnum) null))
 (compare-buffer-substrings (fun (buffer fixnum fixnum buffer fixnum fixnum)
				 fixnum))
 (subst-char-in-region (fun (fixnum fixnum (or character fixnum)
				    (or character fixnum) &optional t)
			    null))
 (translate-region
  (fun (fixnum fixnum
	       (or char-table string (vector (or null character string))))
       fixnum))
 (delete-region (fun (fixnum fixnum &optional buffer) null))
 (widen (fun (&optional buffer) null))
 (narrow-to-region (fun (fixnum fixnum &optional buffer) null))
 ;; FIXME: This is wrong.  It is like progn, which is similarly broken.
 (save-restriction (fun (&rest :A) :A))
 (format (fun (string &rest t) string))
 (char-equal
  (fun ((or character fixnum) (or character fixnum) &optional buffer) boolean))
 (char= (fun ((or character fixnum) (or character fixnum)) boolean))
 (transpose-regions (fixnum fixnum fixnum fixnum &optional t) null)
 )

;;; The XEmacs 21.5 builtin variables.  Each entry is the symbol name,
;;; followed by the type descriptor bound to that symbol's value slot.
(builtin-vars

 ;; abbrev.c
 (global-abbrev-table (or null abbrev-table))
 (last-abbrev (or null (symbol :value string)))
 (last-abbrev-text (or null string))
 (last-abbrev-location fixnum)
 (abbrev-start-location (or null fixnum marker))
 (abbrev-start-location-buffer (or null buffer))
 (abbrev-all-caps boolean)
 (pre-abbrev-expand-hook hook-symbol)

 ;; alloc.c
 ;; The next two are only defined if USE_VALGRIND is defined
 ;; FIXME: Do valgrind-leak-check and valgrind-quick-leak-check sometime
 (debug-allocation fixnum)
 (debug-allocation-backtrace-length fixnum)
 (purify-flag boolean)

 ;; buffer.c
 (change-major-mode-hook hook)
 (find-file-compare-truenames boolean)
 (find-file-use-truenames boolean)
 (before-change-functions (list (fun (fixnum fixnum) t)))
 (after-change-functions (list (fun (marker marker natnum) t)))
 (before-change-function (fun (fixnum fixnum) t))
 (after-change-function (fun (fixnum fixnum natnum) t))
 (first-change-hook hook)
 (undo-threshold natnum)
 (undo-high-threshold natnum)
 (inhibit-read-only (or boolean (list symbol)))
 (kill-buffer-query-functions hook)
 (delete-auto-save-files boolean)
 (modeline-format (or null string symbol glyph specifier list))
 (major-mode symbol)
 (mode-name string)
 (abbrev-mode t)
 (case-fold-search t)
 (fill-column fixnum)
 (left-margin fixnum)
 (tab-width fixnum)
 (ctl-arrow (or null symbol fixnum))
 (truncate-lines (or null symbol))
 (default-directory string)
 (buffer-file-coding-system symbol)
 (auto-fill-function (or null hook-function))
 (buffer-file-name (or null string))
 (buffer-file-truename (or null string))
 (buffer-auto-save-file-name (or null string))
 (buffer-read-only t)
 (buffer-backed-up t)
 (buffer-saved-size integer)
 (selective-display (or null fixnum symbol))
 (selective-display-ellipses boolean)
 (local-abbrev-table (or null abbrev-table))
 (overwrite-mode (member nil 'overwrite-mode-textual 'overwrite-mode-binary))
 ;; FIXME: It will be painful, but we should give the element types
 (buffer-undo-list list)
 (point-before-scroll (or null fixnum))
 ;; FIXME: The list is in a fixed format.  Can we represent it?
 (buffer-file-format (or null list))
 (buffer-invisibility-spec (or symbol (list symbol) (cons symbol boolean)))
 (generated-modeline-string string)

 ;; bytecode.c
 (byte-code-meter (vector (vector fixnum)))
 (byte-metering-on boolean)

 ;; callint.c
 ;; FIXME: a list of what?  It starts with a number.  What else do we know?
 (current-prefix-arg (or fixnum symbol list))
 (command-history list)
 ;; FIXME: What can this really hold?
 (command-debug-status t)

 ;; chartab.c
 (word-combining-categories (list (cons character character)))
 (word-separating-categories (list (cons character character)))

 ;; cmdloop.c
 (command-loop-level natnum)
 (disabled-command-hook hook)
 (leave-window-hook hook)
 (enter-window-hook hook)
 (minibuffer-echo-wait-function (or null hook-function))
 (top-level t)

 ;; cmds.c
 (self-insert-face (or null face))
 (self-insert-face-command (or null hook-function))
 (blink-paren-function (or null hook-function))
 (auto-fill-chars char-table)

 ;; console.c
 (create-console-hook hook)
 (delete-console-hook hook)

 ;; console-msw.c
 (mswindows-seen-characters (or null hash-table))

 ;; console-stream.c
 (terminal-console (or null console))
 (terminal-device (or null device))
 (terminal-frame (or null frame))

 ;; console-tty.c
 (tty-seen-characters (or null hash-table))

 ;; console-x.c
 (wedge-metacity t)

 ;; data.c
 (debug-issue-ebola-notices boolean)
 (debug-ebola-backtrace-length fixnum)

 ;; database.c
 (database-coding-system coding-system)

 ;; device.c
 (create-device-hook hook)
 (delete-device-hook hook)

 ;; device-gtk.c
 (gtk-initial-argv-list (or null (list string)))
 (gtk-initial-geometry (or null string))

 ;; device-x.c
 (x-emacs-application-class (or null string))
 (x-initial-argv-list (or null (list string)))
 (x-app-defaults-directory (or null string))

 ;; dialog.c
 (delete-dialog-box-hook hook)

 ;; dialog-msw.c
 (default-file-dialog-filter-alist (list (cons string string)))

 ;; dired.c
 (completion-ignored-extensions (list string))

 ;; dired-msw.c
 (mswindows-ls-sort-case-insensitive boolean)
 (mswindows-ls-round-file-size natnum)

 ;; doc.c
 (internal-doc-file-name string)

 ;; dragdrop.c
 (dragdrop-protocols (list symbol))

 ;; editfns.c
 (zmacs-regions boolean)
 (zmacs-region-active-p boolean)
 (zmacs-region-stays boolean)
 (atomic-extent-goto-char-p boolean)
 (user-full-name string)
 )

;;; The XEmacs 21.5 symbol groups.  These are symbols that, if one is defined,
;;; all are defined.  The defining condition is also stated.  Symbols not
;;; listed here are assumed to be defined always.
(groups
 ((ifdef ALLOC_TYPE_STATS) object-memory-usage object-memory-usage-stats)
 ((ifdef BYTE_CODE_METER) byte-code-meter byte-metering-on)
 ((ifdef COMPILED_FUNCTION_ANNOTATION_HACK) compiled-function-annotation)
 ((ifdef DEBUG_XEMACS) add-debug-class-to-check debug-allocation
  debug-allocation-backtrace-length debug-classes-being-checked
  debug-classes-list debug-ebola-backtrace-length debug-issue-ebola-notices
  debug-types-being-checked delete-debug-class-to-check
  set-debug-class-types-to-check set-debug-classes-to-check)
 ((and (ifdef DEBUG_XEMACS) (featurep 'mule))
  buffer-char-byte-conversion-info string-char-byte-conversion-info)
 ((ifdef HAVE_DATABASE) close-database database-file-name
  database-coding-system database-last-error database-live-p database-subtype
  database-type databasep get-database map-database open-database put-database
  remove-database)
 ((ifdef HAVE_DRAGNDROP) dragdrop-protocols)
 ((ifdef MEMORY_USAGE_STATS) buffer-memory-usage)
 ((ifndef old) selective-display-ellipses)
 ((featurep 'bignum) fixnump)
 ((featurep 'c-balloon-help)
  balloon-help-move-to-pointer hide-balloon-help show-balloon-help)
 ((featurep 'dialog) delete-dialog-box-hook make-dialog-box-internal)
 ((and (featurep 'dialog) (featurep 'mswindows))
  default-file-dialog-filter-alist)
 ((featurep 'gtk) gtk-display-visual-class gtk-display-visual-depth
  gtk-grab-keyboard gtk-grab-pointer gtk-init gtk-initial-argv-list
  gtk-initial-geometry gtk-keysym-on-keyboard-p gtk-style-info
  gtk-ungrab-keyboard gtk-ungrab-pointer)
 ((featurep 'mule) category-designator-p category-table category-table-p
  category-table-value-p char-in-category-p check-category-at
  copy-category-table set-category-table standard-category-table
  word-combining-categories word-separating-categories)
 ((and (featurep 'mule) (featurep 'x)) x-app-defaults-directory)
 ((featurep 'mswindows) msprinter-apply-settings msprinter-get-settings
  msprinter-select-settings msprinter-settings-copy
  msprinter-settings-despecialize mswindows-debugging-output
  mswindows-get-default-printer mswindows-insert-directory
  mswindows-ls-round-file-size mswindows-ls-sort-case-insensitive
  mswindows-message-box mswindows-printer-list mswindows-seen-characters)
 ((featurep 'ratio) div)
 ((featurep 'x) default-x-device x-debug-mode x-display-visual-class
  x-display-visual-depth x-emacs-application-class x-get-font-path
  x-get-resource x-get-resource-prefix x-grab-keyboard x-grab-pointer
  x-initial-argv-list x-keysym-hash-table x-keysym-on-keyboard-p
  x-keysym-on-keyboard-sans-modifiers-p x-put-resource x-server-vendor
  x-server-version x-set-font-path x-ungrab-keyboard x-ungrab-pointer
  x-valid-keysym-name-p)
 )