[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
scratch/func-type-decls 1d630a5e08a 2/2: Move entries from comp-known-ty
|
From: |
Andrea Corallo |
|
Subject: |
scratch/func-type-decls 1d630a5e08a 2/2: Move entries from comp-known-type-specifiers to DEFUN |
|
Date: |
Fri, 23 Feb 2024 04:27:13 -0500 (EST) |
branch: scratch/func-type-decls
commit 1d630a5e08a389b03602c3209dcf17e10d8e89d5
Author: Andrea Corallo <acorallo@gnu.org>
Commit: Andrea Corallo <acorallo@gnu.org>
Move entries from comp-known-type-specifiers to DEFUN
---
lisp/emacs-lisp/comp-common.el | 321 ++---------------------------------------
src/alloc.c | 26 +++-
src/buffer.c | 24 ++-
src/casefiddle.c | 9 +-
src/casetab.c | 6 +-
src/character.c | 18 ++-
src/charset.c | 9 +-
src/data.c | 207 +++++++++++++++++---------
src/doc.c | 3 +-
src/editfns.c | 91 ++++++++----
src/emacs.c | 6 +-
src/eval.c | 9 +-
src/fileio.c | 24 ++-
src/filelock.c | 3 +-
src/floatfns.c | 72 ++++++---
src/fns.c | 141 ++++++++++++------
src/frame.c | 12 +-
src/indent.c | 3 +-
src/keyboard.c | 18 ++-
src/keymap.c | 15 +-
src/lread.c | 6 +-
src/marker.c | 6 +-
src/print.c | 6 +-
src/process.c | 3 +-
src/search.c | 3 +-
src/syntax.c | 12 +-
src/timefns.c | 34 ++++-
src/window.c | 47 ++++--
28 files changed, 565 insertions(+), 569 deletions(-)
diff --git a/lisp/emacs-lisp/comp-common.el b/lisp/emacs-lisp/comp-common.el
index ca21ed05bb4..fe9c6f87565 100644
--- a/lisp/emacs-lisp/comp-common.el
+++ b/lisp/emacs-lisp/comp-common.el
@@ -69,344 +69,51 @@ Used to modify the compiler environment."
:version "28.1")
(defconst comp-known-type-specifiers
- `(
- ;; Functions we can trust not to be redefined, or, if redefined,
- ;; to expose the same type. The vast majority of these are
- ;; either pure or primitive; the original list is the union of
- ;; pure + side-effect-free-fns + side-effect-and-error-free-fns:
- (% (function ((or number marker) (or number marker)) number))
- (* (function (&rest (or number marker)) number))
- (+ (function (&rest (or number marker)) number))
- (- (function (&rest (or number marker)) number))
- (/ (function ((or number marker) &rest (or number marker)) number))
- (/= (function ((or number marker) (or number marker)) boolean))
- (1+ (function ((or number marker)) number))
- (1- (function ((or number marker)) number))
- (< (function ((or number marker) &rest (or number marker)) boolean))
- (<= (function ((or number marker) &rest (or number marker)) boolean))
- (= (function ((or number marker) &rest (or number marker)) boolean))
- (> (function ((or number marker) &rest (or number marker)) boolean))
- (>= (function ((or number marker) &rest (or number marker)) boolean))
- (abs (function (number) number))
- (acos (function (number) float))
- (append (function (&rest t) t))
- (aref (function (t fixnum) t))
- (arrayp (function (t) boolean))
- (ash (function (integer integer) integer))
- (asin (function (number) float))
- (assq (function (t list) list))
- (atan (function (number &optional number) float))
- (atom (function (t) boolean))
- (bignump (function (t) boolean))
- (bobp (function () boolean))
- (bolp (function () boolean))
- (bool-vector-count-consecutive
- (function (bool-vector boolean integer) fixnum))
- (bool-vector-count-population (function (bool-vector) fixnum))
- (bool-vector-not (function (bool-vector &optional bool-vector)
bool-vector))
- (bool-vector-p (function (t) boolean))
- (bool-vector-subsetp (function (bool-vector bool-vector) boolean))
- (boundp (function (symbol) boolean))
+ ;; Functions we can trust not to be redefined, or, if redefined,
+ ;; to expose the same type. The vast majority of these are
+ ;; either pure or primitive; the original list is the union of
+ ;; pure + side-effect-free-fns + side-effect-and-error-free-fns:
+ `((bignump (function (t) boolean))
(buffer-end (function ((or number marker)) integer))
- (buffer-file-name (function (&optional buffer) (or string null)))
- (buffer-list (function (&optional frame) list))
- (buffer-local-variables (function (&optional buffer) list))
- (buffer-modified-p
- (function (&optional buffer) (or boolean (member autosaved))))
- (buffer-size (function (&optional buffer) integer))
- (buffer-string (function () string))
- (buffer-substring
- (function ((or integer marker) (or integer marker)) string))
- (bufferp (function (t) boolean))
- (byte-code-function-p (function (t) boolean))
- (capitalize (function (or integer string) (or integer string)))
- (car (function (list) t))
- (car-less-than-car (function (list list) boolean))
- (car-safe (function (t) t))
- (case-table-p (function (t) boolean))
- (cdr (function (list) t))
- (cdr-safe (function (t) t))
- (ceiling (function (number &optional number) integer))
- (char-after (function (&optional (or marker integer)) (or fixnum null)))
- (char-before (function (&optional (or marker integer)) (or fixnum null)))
- (char-equal (function (integer integer) boolean))
- (char-or-string-p (function (t) boolean))
- (char-to-string (function (fixnum) string))
- (char-width (function (fixnum) fixnum))
- (characterp (function (t &optional t) boolean))
- (charsetp (function (t) boolean))
- (commandp (function (t &optional t) boolean))
- (compare-strings
- (function (string (or integer marker null) (or integer marker null) string
- (or integer marker null) (or integer marker null)
- &optional t)
- (or (member t) fixnum)))
- (concat (function (&rest sequence) string))
- (cons (function (t t) cons))
- (consp (function (t) boolean))
- (coordinates-in-window-p
- (function (cons window)
- (or cons null
- (member bottom-divider right-divider mode-line header-line
- tab-line left-fringe right-fringe vertical-line
- left-margin right-margin))))
- (copy-alist (function (list) list))
- (copy-marker (function (&optional (or integer marker) boolean) marker))
- (copy-sequence (function (sequence) sequence))
- (copysign (function (float float) float))
- (cos (function (number) float))
(count-lines
(function ((or integer marker) (or integer marker) &optional t) integer))
- (current-buffer (function () buffer))
- (current-global-map (function () cons))
- (current-indentation (function () integer))
- (current-local-map (function () (or cons null)))
- (current-minor-mode-maps (function () (or cons null)))
- (current-time (function () cons))
- (current-time-string (function (&optional (or number list)
- (or symbol string cons integer))
- string))
- (current-time-zone (function (&optional (or number list)
- (or symbol string cons integer))
- cons))
(custom-variable-p (function (symbol) t))
- (decode-char (function (cons t) (or fixnum null)))
- (decode-time (function (&optional (or number list)
- (or symbol string cons integer)
- symbol)
- cons))
- (default-boundp (function (symbol) boolean))
- (default-value (function (symbol) t))
(degrees-to-radians (function (number) float))
- (documentation
- (function ((or function symbol subr) &optional t) (or null string)))
- (downcase (function ((or fixnum string)) (or fixnum string)))
- (elt (function (sequence integer) t))
- (encode-char (function (fixnum symbol) (or fixnum null)))
- (encode-time (function (cons &rest t) cons))
- (eobp (function () boolean))
- (eolp (function () boolean))
- (eq (function (t t) boolean))
- (eql (function (t t) boolean))
- (equal (function (t t) boolean))
- (error-message-string (function (list) string))
(eventp (function (t) boolean))
- (exp (function (number) float))
- (expt (function (number number) number))
- (fboundp (function (symbol) boolean))
- (fceiling (function (float) float))
- (featurep (function (symbol &optional symbol) boolean))
- (ffloor (function (float) float))
- (file-directory-p (function (string) boolean))
- (file-exists-p (function (string) boolean))
- (file-locked-p (function (string) (or boolean string)))
- (file-name-absolute-p (function (string) boolean))
- (file-newer-than-file-p (function (string string) boolean))
- (file-readable-p (function (string) boolean))
- (file-symlink-p (function (string) (or boolean string)))
- (file-writable-p (function (string) boolean))
(fixnump (function (t) boolean))
- (float (function (number) float))
- (float-time (function (&optional (or number list)) float))
- (floatp (function (t) boolean))
- (floor (function (number &optional number) integer))
- (following-char (function () fixnum))
- (format (function (string &rest t) string))
- (format-time-string (function (string &optional (or number list)
- (or symbol string cons integer))
- string))
- (frame-first-window (function ((or frame window)) window))
- (frame-root-window (function (&optional (or frame window)) window))
- (frame-selected-window (function (&optional (or frame window)) window))
- (frame-visible-p (function (frame) (or boolean (member icon))))
- (framep (function (t) symbol))
- (fround (function (float) float))
- (ftruncate (function (float) float))
- (get (function (symbol symbol) t))
- (get-buffer (function ((or buffer string)) (or buffer null)))
- (get-buffer-window
- (function (&optional (or buffer string) (or symbol (integer 0 0)))
- (or null window)))
- (get-file-buffer (function (string) (or null buffer)))
(get-largest-window (function (&optional t t t) (or window null)))
(get-lru-window (function (&optional t t t) (or window null)))
(getenv (function (string &optional frame) (or null string)))
- (gethash (function (t hash-table &optional t) t))
- (hash-table-count (function (hash-table) integer))
- (hash-table-p (function (t) boolean))
- (identity (function (t) t))
(ignore (function (&rest t) null))
- (int-to-string (function (number) string))
- (integer-or-marker-p (function (t) boolean))
- (integerp (function (t) boolean))
(interactive-p (function () boolean))
- (intern-soft (function ((or string symbol) &optional vector) symbol))
- (invocation-directory (function () string))
- (invocation-name (function () string))
- (isnan (function (float) boolean))
- (keymap-parent (function (cons) (or cons null)))
- (keymapp (function (t) boolean))
- (keywordp (function (t) boolean))
(last (function (list &optional integer) list))
(lax-plist-get (function (list t) t))
- (ldexp (function (number integer) float))
- (length (function (t) (integer 0 *)))
- (length< (function (sequence fixnum) boolean))
- (length= (function (sequence fixnum) boolean))
- (length> (function (sequence fixnum) boolean))
- (line-beginning-position (function (&optional integer) integer))
- (line-end-position (function (&optional integer) integer))
- (list (function (&rest t) list))
- (listp (function (t) boolean))
- (local-variable-if-set-p (function (symbol &optional buffer) boolean))
- (local-variable-p (function (symbol &optional buffer) boolean))
- (locale-info (function ((member codeset days months paper)) (or null
string)))
- (log (function (number number) float))
(log10 (function (number) float))
- (logand (function (&rest (or integer marker)) integer))
- (logb (function (number) integer))
- (logcount (function (integer) integer))
- (logior (function (&rest (or integer marker)) integer))
- (lognot (function (integer) integer))
- (logxor (function (&rest (or integer marker)) integer))
;; (lsh (function ((integer ,most-negative-fixnum *) integer) integer)) ?
(lsh (function (integer integer) integer))
- (make-byte-code
- (function ((or fixnum list) string vector integer &optional string t
- &rest t)
- vector))
- (make-list (function (integer t) list))
- (make-marker (function () marker))
- (make-string (function (integer fixnum &optional t) string))
- (make-symbol (function (string) symbol))
(mark (function (&optional t) (or integer null)))
- (mark-marker (function () marker))
- (marker-buffer (function (marker) (or buffer null)))
- (markerp (function (t) boolean))
- (max (function ((or number marker) &rest (or number marker)) number))
- (max-char (function (&optional t) fixnum))
- (member (function (t list) list))
(memory-limit (function () integer))
- (memq (function (t list) list))
- (memql (function (t list) list))
- (min (function ((or number marker) &rest (or number marker)) number))
- (minibuffer-selected-window (function () (or window null)))
- (minibuffer-window (function (&optional frame) window))
- (mod
- (function ((or number marker) (or number marker))
- (or (integer 0 *) (float 0 *))))
(mouse-movement-p (function (t) boolean))
- (multibyte-char-to-unibyte (function (fixnum) fixnum))
- (natnump (function (t) boolean))
- (next-window (function (&optional window t t) window))
- (nlistp (function (t) boolean))
- (not (function (t) boolean))
- (nth (function (integer list) t))
- (nthcdr (function (integer t) t))
- (null (function (t) boolean))
- (number-or-marker-p (function (t) boolean))
- (number-to-string (function (number) string))
- (numberp (function (t) boolean))
(one-window-p (function (&optional t t) boolean))
- (overlayp (function (t) boolean))
- (parse-colon-path (function (string) list))
- (plist-get (function (list t &optional t) t))
- (plist-member (function (list t &optional t) list))
- (point (function () integer))
- (point-marker (function () marker))
- (point-max (function () integer))
- (point-min (function () integer))
- (preceding-char (function () fixnum))
- (previous-window (function (&optional window t t) window))
- (prin1-to-string (function (t &optional t t) string))
- (processp (function (t) boolean))
- (proper-list-p (function (t) (or fixnum null)))
- (propertize (function (string &rest t) string))
(radians-to-degrees (function (number) float))
- (rassoc (function (t list) list))
- (rassq (function (t list) list))
- (read-from-string (function (string &optional integer integer) cons))
- (recent-keys (function (&optional (or cons null)) vector))
- (recursion-depth (function () integer))
(regexp-opt (function (list) string))
- (regexp-quote (function (string) string))
- (region-beginning (function () integer))
- (region-end (function () integer))
- (reverse (function (sequence) sequence))
- (round (function (number &optional number) integer))
- (safe-length (function (t) integer))
- (selected-frame (function () frame))
- (selected-window (function () window))
- (sequencep (function (t) boolean))
- (sin (function (number) float))
- (sqrt (function (number) float))
- (standard-case-table (function () char-table))
- (standard-syntax-table (function () char-table))
- (string (function (&rest fixnum) string))
- (string-as-multibyte (function (string) string))
- (string-as-unibyte (function (string) string))
- (string-equal (function ((or string symbol) (or string symbol)) boolean))
- (string-lessp (function ((or string symbol) (or string symbol)) boolean))
- (string-make-multibyte (function (string) string))
- (string-make-unibyte (function (string) string))
- (string-search (function (string string &optional integer) (or integer
null)))
- (string-to-char (function (string) fixnum))
- (string-to-multibyte (function (string) string))
- (string-to-number (function (string &optional integer) number))
- (string-to-syntax (function (string) (or cons null)))
- (string< (function ((or string symbol) (or string symbol)) boolean))
- (string= (function ((or string symbol) (or string symbol)) boolean))
- (stringp (function (t) boolean))
- (subrp (function (t) boolean))
- (substring
- (function ((or string vector) &optional integer integer) (or string
vector)))
- (sxhash (function (t) integer))
- (sxhash-eq (function (t) integer))
- (sxhash-eql (function (t) integer))
- (sxhash-equal (function (t) integer))
- (symbol-function (function (symbol) t))
- (symbol-name (function (symbol) string))
- (symbol-plist (function (symbol) list))
- (symbol-value (function (symbol) t))
- (symbolp (function (t) boolean))
- (syntax-table (function () char-table))
- (syntax-table-p (function (t) boolean))
- (tan (function (number) float))
- (this-command-keys (function () string))
- (this-command-keys-vector (function () vector))
- (this-single-command-keys (function () vector))
- (this-single-command-raw-keys (function () vector))
- (time-convert (function ((or number list) &optional (or symbol integer))
- (or cons number)))
- (truncate (function (number &optional number) integer))
- (type-of (function (t) symbol))
- (unibyte-char-to-multibyte (function (fixnum) fixnum)) ;; byte is fixnum
- (upcase (function ((or fixnum string)) (or fixnum string)))
- (user-full-name (function (&optional integer) (or string null)))
- (user-login-name (function (&optional integer) (or string null)))
- (user-original-login-name (function (&optional integer) (or string null)))
- (user-real-login-name (function () string))
- (user-real-uid (function () integer))
- (user-uid (function () integer))
- (vconcat (function (&rest sequence) vector))
- (vector (function (&rest t) vector))
- (vectorp (function (t) boolean))
- (visible-frame-list (function () list))
- (wholenump (function (t) boolean))
- (window-configuration-p (function (t) boolean))
- (window-live-p (function (t) boolean))
- (window-valid-p (function (t) boolean))
- (windowp (function (t) boolean))
(zerop (function (number) boolean))
;; Type hints
(comp-hint-fixnum (function (t) fixnum))
(comp-hint-cons (function (t) cons))
;; Non returning functions
- (throw (function (t t) nil))
(error (function (string &rest t) nil))
- (signal (function (symbol t) nil)))
+ ;; Primitives
+ ,@(let (res)
+ (mapatoms (lambda (atom)
+ (when-let ((f (symbol-function atom))
+ (primitive (subr-primitive-p f))
+ (type (subr-type f)))
+ (push `(,atom ,type) res))))
+ res))
"Alist used for type propagation.")
+
(defconst comp-limple-calls '(call
callref
direct-call
diff --git a/src/alloc.c b/src/alloc.c
index 8c94c7eb33c..0782978b702 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -2333,7 +2333,8 @@ DEFUN ("make-string", Fmake_string, Smake_string, 2, 3, 0,
LENGTH must be an integer.
INIT must be an integer that represents a character.
If optional argument MULTIBYTE is non-nil, the result will be
-a multibyte string even if INIT is an ASCII character. */)
+a multibyte string even if INIT is an ASCII character. */,
+(function (integer fixnum &optional t) string))
(Lisp_Object length, Lisp_Object init, Lisp_Object multibyte)
{
Lisp_Object val;
@@ -2855,7 +2856,8 @@ free_cons (struct Lisp_Cons *ptr)
}
DEFUN ("cons", Fcons, Scons, 2, 2, 0,
- doc: /* Create a new cons, give it CAR and CDR as components, and
return it. */)
+ doc: /* Create a new cons, give it CAR and CDR as components, and
return it. */,
+(function (t t) cons))
(Lisp_Object car, Lisp_Object cdr)
{
register Lisp_Object val;
@@ -2973,7 +2975,8 @@ pure_listn (ptrdiff_t count, Lisp_Object arg1, ...)
DEFUN ("list", Flist, Slist, 0, MANY, 0,
doc: /* Return a newly created list with specified arguments as
elements.
Allows any number of arguments, including zero.
-usage: (list &rest OBJECTS) */)
+usage: (list &rest OBJECTS) */,
+(function (&rest t) list))
(ptrdiff_t nargs, Lisp_Object *args)
{
register Lisp_Object val;
@@ -2989,7 +2992,8 @@ usage: (list &rest OBJECTS) */)
DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
- doc: /* Return a newly created list of length LENGTH, with each element
being INIT. */)
+ doc: /* Return a newly created list of length LENGTH, with each element
being INIT. */,
+(function (integer t) list))
(Lisp_Object length, Lisp_Object init)
{
Lisp_Object val = Qnil;
@@ -3777,7 +3781,8 @@ make_vector (ptrdiff_t length, Lisp_Object init)
DEFUN ("vector", Fvector, Svector, 0, MANY, 0,
doc: /* Return a newly created vector with specified arguments as
elements.
Allows any number of arguments, including zero.
-usage: (vector &rest OBJECTS) */)
+usage: (vector &rest OBJECTS) */,
+(function (&rest t) vector))
(ptrdiff_t nargs, Lisp_Object *args)
{
Lisp_Object val = make_uninit_vector (nargs);
@@ -3801,7 +3806,10 @@ of arguments (ignoring &rest) and the R bit specifies
whether there is a &rest
argument to catch the left-over arguments. If such an integer is used, the
arguments will not be dynamically bound but will be instead pushed on the
stack before executing the byte-code.
-usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING
INTERACTIVE-SPEC &rest ELEMENTS) */)
+usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING
INTERACTIVE-SPEC &rest ELEMENTS) */,
+(function ((or fixnum list) string vector integer &optional string t
+ &rest t)
+ vector))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (! ((FIXNUMP (args[COMPILED_ARGLIST])
@@ -3939,7 +3947,8 @@ init_symbol (Lisp_Object val, Lisp_Object name)
DEFUN ("make-symbol", Fmake_symbol, Smake_symbol, 1, 1, 0,
doc: /* Return a newly allocated uninterned symbol whose name is NAME.
-Its value is void, and its function definition and property list are nil. */)
+Its value is void, and its function definition and property list are nil. */,
+(function (string) symbol))
(Lisp_Object name)
{
Lisp_Object val;
@@ -4023,7 +4032,8 @@ build_overlay (bool front_advance, bool rear_advance,
}
DEFUN ("make-marker", Fmake_marker, Smake_marker, 0, 0, 0,
- doc: /* Return a newly allocated marker which does not point at any
place. */)
+ doc: /* Return a newly allocated marker which does not point at any
place. */,
+(function () marker))
(void)
{
struct Lisp_Marker *p = ALLOCATE_PLAIN_PSEUDOVECTOR (struct Lisp_Marker,
diff --git a/src/buffer.c b/src/buffer.c
index d67e1d67cd6..e5ef712b4fe 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -418,7 +418,8 @@ DEFUN ("buffer-list", Fbuffer_list, Sbuffer_list, 0, 1, 0,
doc: /* Return a list of all live buffers.
If the optional arg FRAME is a frame, return the buffer list in the
proper order for that frame: the buffers shown in FRAME come first,
-followed by the rest of the buffers. */)
+followed by the rest of the buffers. */,
+(function (&optional frame) list))
(Lisp_Object frame)
{
Lisp_Object general;
@@ -473,7 +474,8 @@ DEFUN ("get-buffer", Fget_buffer, Sget_buffer, 1, 1, 0,
doc: /* Return the buffer named BUFFER-OR-NAME.
BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
is a string and there is no buffer with that name, return nil. If
-BUFFER-OR-NAME is a buffer, return it as given. */)
+BUFFER-OR-NAME is a buffer, return it as given. */,
+(function ((or buffer string)) (or buffer null)))
(register Lisp_Object buffer_or_name)
{
if (BUFFERP (buffer_or_name))
@@ -487,7 +489,8 @@ DEFUN ("get-file-buffer", Fget_file_buffer,
Sget_file_buffer, 1, 1, 0,
doc: /* Return the buffer visiting file FILENAME (a string).
The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
If there is no such live buffer, return nil.
-See also `find-buffer-visiting'. */)
+See also `find-buffer-visiting'. */,
+(function (string) (or null buffer)))
(register Lisp_Object filename)
{
register Lisp_Object tail, buf, handler;
@@ -1278,7 +1281,8 @@ Return nil if BUFFER has been killed. */)
DEFUN ("buffer-file-name", Fbuffer_file_name, Sbuffer_file_name, 0, 1, 0,
doc: /* Return name of file BUFFER is visiting, or nil if none.
-No argument or nil as argument means use the current buffer. */)
+No argument or nil as argument means use the current buffer. */,
+(function (&optional buffer) (or string null)))
(register Lisp_Object buffer)
{
return BVAR (decode_buffer (buffer), filename);
@@ -1433,7 +1437,8 @@ DEFUN ("buffer-local-variables", Fbuffer_local_variables,
Most elements look like (SYMBOL . VALUE), describing one variable.
For a symbol that is locally unbound, just the symbol appears in the value.
Note that storing new VALUEs in these elements doesn't change the variables.
-No argument or nil as argument means use current buffer as BUFFER. */)
+No argument or nil as argument means use current buffer as BUFFER. */,
+(function (&optional buffer) list))
(Lisp_Object buffer)
{
struct buffer *buf = decode_buffer (buffer);
@@ -1466,7 +1471,8 @@ DEFUN ("buffer-modified-p", Fbuffer_modified_p,
Sbuffer_modified_p,
No argument or nil as argument means use current buffer as BUFFER.
If BUFFER was autosaved since it was last modified, this function
-returns the symbol `autosaved'. */)
+returns the symbol `autosaved'. */,
+(function (&optional buffer) (or boolean (member autosaved))))
(Lisp_Object buffer)
{
struct buffer *buf = decode_buffer (buffer);
@@ -2245,7 +2251,8 @@ the current buffer's major mode. */)
}
DEFUN ("current-buffer", Fcurrent_buffer, Scurrent_buffer, 0, 0, 0,
- doc: /* Return the current buffer as a Lisp object. */)
+ doc: /* Return the current buffer as a Lisp object. */,
+(function () buffer))
(void)
{
register Lisp_Object buf;
@@ -3533,7 +3540,8 @@ adjust_overlays_for_delete (ptrdiff_t pos, ptrdiff_t
length)
DEFUN ("overlayp", Foverlayp, Soverlayp, 1, 1, 0,
- doc: /* Return t if OBJECT is an overlay. */)
+ doc: /* Return t if OBJECT is an overlay. */,
+(function (t) boolean))
(Lisp_Object object)
{
return (OVERLAYP (object) ? Qt : Qnil);
diff --git a/src/casefiddle.c b/src/casefiddle.c
index b252f07ae13..be08dce8f20 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -374,7 +374,8 @@ The argument object is not altered--the value is a copy.
If argument
is a character, characters which map to multiple code points when
cased, e.g. fi, are returned unchanged.
-See also `capitalize', `downcase' and `upcase-initials'. */)
+See also `capitalize', `downcase' and `upcase-initials'. */,
+(function ((or fixnum string)) (or fixnum string)))
(Lisp_Object obj)
{
return casify_object (CASE_UP, obj);
@@ -391,7 +392,8 @@ argument, and downcasing it would turn it into a multibyte
string
\"C\" rules instead. To accurately downcase according to the current
locale, the string must be converted into multibyte first.
-The argument object is not altered--the value is a copy. */)
+The argument object is not altered--the value is a copy. */,
+(function ((or fixnum string)) (or fixnum string)))
(Lisp_Object obj)
{
return casify_object (CASE_DOWN, obj);
@@ -407,7 +409,8 @@ type. (See `downcase' for further details about the type.)
The argument object is not altered--the value is a copy. If argument
is a character, characters which map to multiple code points when
-cased, e.g. fi, are returned unchanged. */)
+cased, e.g. fi, are returned unchanged. */,
+(function (or integer string) (or integer string)))
(Lisp_Object obj)
{
return casify_object (CASE_CAPITALIZE, obj);
diff --git a/src/casetab.c b/src/casetab.c
index 41e9004e10f..73f06b12093 100644
--- a/src/casetab.c
+++ b/src/casetab.c
@@ -34,7 +34,8 @@ static void shuffle (Lisp_Object table, Lisp_Object c,
Lisp_Object elt);
DEFUN ("case-table-p", Fcase_table_p, Scase_table_p, 1, 1, 0,
doc: /* Return t if OBJECT is a case table.
-See `set-case-table' for more information on these data structures. */)
+See `set-case-table' for more information on these data structures. */,
+(function (t) boolean))
(Lisp_Object object)
{
Lisp_Object up, canon, eqv;
@@ -71,7 +72,8 @@ DEFUN ("current-case-table", Fcurrent_case_table,
Scurrent_case_table, 0, 0, 0,
DEFUN ("standard-case-table", Fstandard_case_table, Sstandard_case_table, 0,
0, 0,
doc: /* Return the standard case table.
-This is the one used for new buffers. */)
+This is the one used for new buffers. */,
+(function () char-table))
(void)
{
return Vascii_downcase_table;
diff --git a/src/character.c b/src/character.c
index dcad8f83793..f6e170c1880 100644
--- a/src/character.c
+++ b/src/character.c
@@ -172,7 +172,8 @@ In Emacs Lisp, characters are represented by character
codes, which
are non-negative integers. The function `max-char' returns the
maximum character code.
usage: (characterp OBJECT) */
- attributes: const)
+ attributes: const,
+(function (t &optional t) boolean))
(Lisp_Object object, Lisp_Object ignore)
{
return (CHARACTERP (object) ? Qt : Qnil);
@@ -182,7 +183,8 @@ DEFUN ("max-char", Fmax_char, Smax_char, 0, 1, 0,
doc: /* Return the maximum character code.
If UNICODE is non-nil, return the maximum character code defined
by the Unicode Standard. */
- attributes: const)
+ attributes: const,
+(function (&optional t) fixnum))
(Lisp_Object unicode)
{
return (!NILP (unicode)
@@ -192,7 +194,8 @@ by the Unicode Standard. */
DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte,
Sunibyte_char_to_multibyte, 1, 1, 0,
- doc: /* Convert the byte CH to multibyte character. */)
+ doc: /* Convert the byte CH to multibyte character. */,
+(function (fixnum) fixnum))
(Lisp_Object ch)
{
int c;
@@ -207,7 +210,8 @@ DEFUN ("unibyte-char-to-multibyte",
Funibyte_char_to_multibyte,
DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte,
Smultibyte_char_to_unibyte, 1, 1, 0,
doc: /* Convert the multibyte character CH to a byte.
-If the multibyte character does not represent a byte, return -1. */)
+If the multibyte character does not represent a byte, return -1. */,
+(function (fixnum) fixnum))
(Lisp_Object ch)
{
int cm;
@@ -267,7 +271,8 @@ metrics of the character's glyph as determined by its font.
If the display table in effect replaces CHAR on display with
something else, the function returns the width of the replacement.
Tab is taken to occupy `tab-width' columns.
-usage: (char-width CHAR) */)
+usage: (char-width CHAR) */,
+(function (fixnum) fixnum))
(Lisp_Object ch)
{
int c;
@@ -843,7 +848,8 @@ string_escape_byte8 (Lisp_Object string)
DEFUN ("string", Fstring, Sstring, 0, MANY, 0,
doc: /*
Concatenate all the argument characters and make the result a string.
-usage: (string &rest CHARACTERS) */)
+usage: (string &rest CHARACTERS) */,
+(function (&rest fixnum) string))
(ptrdiff_t n, Lisp_Object *args)
{
ptrdiff_t nbytes = 0;
diff --git a/src/charset.c b/src/charset.c
index 4bacc011e85..252a18a83b3 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -648,7 +648,8 @@ load_charset (struct charset *charset, int control_flag)
DEFUN ("charsetp", Fcharsetp, Scharsetp, 1, 1, 0,
- doc: /* Return non-nil if and only if OBJECT is a charset.*/)
+ doc: /* Return non-nil if and only if OBJECT is a charset.*/,
+(function (t) boolean))
(Lisp_Object object)
{
return (CHARSETP (object) ? Qt : Qnil);
@@ -1837,7 +1838,8 @@ DEFUN ("decode-char", Fdecode_char, Sdecode_char, 2, 2, 0,
Return nil if CODE-POINT is not valid in CHARSET.
CODE-POINT may be a cons (HIGHER-16-BIT-VALUE . LOWER-16-BIT-VALUE),
-although this usage is obsolescent. */)
+although this usage is obsolescent. */,
+(function (cons t) (or fixnum null)))
(Lisp_Object charset, Lisp_Object code_point)
{
int c, id;
@@ -1855,7 +1857,8 @@ although this usage is obsolescent. */)
DEFUN ("encode-char", Fencode_char, Sencode_char, 2, 2, 0,
doc: /* Encode the character CH into a code-point of CHARSET.
Return the encoded code-point as an integer,
-or nil if CHARSET doesn't support CH. */)
+or nil if CHARSET doesn't support CH. */,
+(function (fixnum symbol) (or fixnum null)))
(Lisp_Object ch, Lisp_Object charset)
{
int c, id;
diff --git a/src/data.c b/src/data.c
index 9e8c00a31e6..0a2f865920b 100644
--- a/src/data.c
+++ b/src/data.c
@@ -172,7 +172,8 @@ circular_list (Lisp_Object list)
DEFUN ("eq", Feq, Seq, 2, 2, 0,
doc: /* Return t if the two args are the same Lisp object. */
- attributes: const)
+ attributes: const,
+(function (t t) boolean))
(Lisp_Object obj1, Lisp_Object obj2)
{
if (EQ (obj1, obj2))
@@ -182,7 +183,8 @@ DEFUN ("eq", Feq, Seq, 2, 2, 0,
DEFUN ("null", Fnull, Snull, 1, 1, 0,
doc: /* Return t if OBJECT is nil, and return nil otherwise. */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(Lisp_Object object)
{
if (NILP (object))
@@ -193,7 +195,8 @@ DEFUN ("null", Fnull, Snull, 1, 1, 0,
DEFUN ("type-of", Ftype_of, Stype_of, 1, 1, 0,
doc: /* Return a symbol representing the type of OBJECT.
The symbol returned names the object's basic type;
-for example, (type-of 1) returns `integer'. */)
+for example, (type-of 1) returns `integer'. */,
+(function (t) symbol))
(Lisp_Object object)
{
switch (XTYPE (object))
@@ -288,7 +291,8 @@ for example, (type-of 1) returns `integer'. */)
DEFUN ("consp", Fconsp, Sconsp, 1, 1, 0,
doc: /* Return t if OBJECT is a cons cell. */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(Lisp_Object object)
{
if (CONSP (object))
@@ -298,7 +302,8 @@ DEFUN ("consp", Fconsp, Sconsp, 1, 1, 0,
DEFUN ("atom", Fatom, Satom, 1, 1, 0,
doc: /* Return t if OBJECT is not a cons cell. This includes nil. */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(Lisp_Object object)
{
if (CONSP (object))
@@ -309,7 +314,8 @@ DEFUN ("atom", Fatom, Satom, 1, 1, 0,
DEFUN ("listp", Flistp, Slistp, 1, 1, 0,
doc: /* Return t if OBJECT is a list, that is, a cons cell or nil.
Otherwise, return nil. */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(Lisp_Object object)
{
if (CONSP (object) || NILP (object))
@@ -319,7 +325,8 @@ Otherwise, return nil. */
DEFUN ("nlistp", Fnlistp, Snlistp, 1, 1, 0,
doc: /* Return t if OBJECT is not a list. Lists include nil. */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(Lisp_Object object)
{
if (CONSP (object) || NILP (object))
@@ -349,7 +356,8 @@ DEFUN ("symbol-with-pos-p", Fsymbol_with_pos_p,
Ssymbol_with_pos_p, 1, 1, 0,
DEFUN ("symbolp", Fsymbolp, Ssymbolp, 1, 1, 0,
doc: /* Return t if OBJECT is a symbol. */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(Lisp_Object object)
{
if (SYMBOLP (object))
@@ -360,7 +368,8 @@ DEFUN ("symbolp", Fsymbolp, Ssymbolp, 1, 1, 0,
DEFUN ("keywordp", Fkeywordp, Skeywordp, 1, 1, 0,
doc: /* Return t if OBJECT is a keyword.
This means that it is a symbol with a print name beginning with `:'
-interned in the initial obarray. */)
+interned in the initial obarray. */,
+(function (t) boolean))
(Lisp_Object object)
{
if (SYMBOLP (object)
@@ -371,7 +380,8 @@ interned in the initial obarray. */)
}
DEFUN ("vectorp", Fvectorp, Svectorp, 1, 1, 0,
- doc: /* Return t if OBJECT is a vector. */)
+ doc: /* Return t if OBJECT is a vector. */,
+(function (t) boolean))
(Lisp_Object object)
{
if (VECTORP (object))
@@ -390,7 +400,8 @@ DEFUN ("recordp", Frecordp, Srecordp, 1, 1, 0,
DEFUN ("stringp", Fstringp, Sstringp, 1, 1, 0,
doc: /* Return t if OBJECT is a string. */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(Lisp_Object object)
{
if (STRINGP (object))
@@ -429,7 +440,8 @@ DEFUN ("vector-or-char-table-p", Fvector_or_char_table_p,
}
DEFUN ("bool-vector-p", Fbool_vector_p, Sbool_vector_p, 1, 1, 0,
- doc: /* Return t if OBJECT is a bool-vector. */)
+ doc: /* Return t if OBJECT is a bool-vector. */,
+(function (t) boolean))
(Lisp_Object object)
{
if (BOOL_VECTOR_P (object))
@@ -438,7 +450,8 @@ DEFUN ("bool-vector-p", Fbool_vector_p, Sbool_vector_p, 1,
1, 0,
}
DEFUN ("arrayp", Farrayp, Sarrayp, 1, 1, 0,
- doc: /* Return t if OBJECT is an array (string or vector). */)
+ doc: /* Return t if OBJECT is an array (string or vector). */,
+(function (t) boolean))
(Lisp_Object object)
{
if (ARRAYP (object))
@@ -447,7 +460,8 @@ DEFUN ("arrayp", Farrayp, Sarrayp, 1, 1, 0,
}
DEFUN ("sequencep", Fsequencep, Ssequencep, 1, 1, 0,
- doc: /* Return t if OBJECT is a sequence (list or array). */)
+ doc: /* Return t if OBJECT is a sequence (list or array). */,
+(function (t) boolean))
(register Lisp_Object object)
{
if (CONSP (object) || NILP (object) || ARRAYP (object))
@@ -456,7 +470,8 @@ DEFUN ("sequencep", Fsequencep, Ssequencep, 1, 1, 0,
}
DEFUN ("bufferp", Fbufferp, Sbufferp, 1, 1, 0,
- doc: /* Return t if OBJECT is an editor buffer. */)
+ doc: /* Return t if OBJECT is an editor buffer. */,
+(function (t) boolean))
(Lisp_Object object)
{
if (BUFFERP (object))
@@ -465,7 +480,8 @@ DEFUN ("bufferp", Fbufferp, Sbufferp, 1, 1, 0,
}
DEFUN ("markerp", Fmarkerp, Smarkerp, 1, 1, 0,
- doc: /* Return t if OBJECT is a marker (editor pointer). */)
+ doc: /* Return t if OBJECT is a marker (editor pointer). */,
+(function (t) boolean))
(Lisp_Object object)
{
if (MARKERP (object))
@@ -485,7 +501,8 @@ DEFUN ("user-ptrp", Fuser_ptrp, Suser_ptrp, 1, 1, 0,
#endif
DEFUN ("subrp", Fsubrp, Ssubrp, 1, 1, 0,
- doc: /* Return t if OBJECT is a built-in function. */)
+ doc: /* Return t if OBJECT is a built-in function. */,
+(function (t) boolean))
(Lisp_Object object)
{
if (SUBRP (object))
@@ -495,7 +512,8 @@ DEFUN ("subrp", Fsubrp, Ssubrp, 1, 1, 0,
DEFUN ("byte-code-function-p", Fbyte_code_function_p, Sbyte_code_function_p,
1, 1, 0,
- doc: /* Return t if OBJECT is a byte-compiled function object. */)
+ doc: /* Return t if OBJECT is a byte-compiled function object. */,
+(function (t) boolean))
(Lisp_Object object)
{
if (COMPILEDP (object))
@@ -513,7 +531,8 @@ DEFUN ("module-function-p", Fmodule_function_p,
Smodule_function_p, 1, 1, NULL,
DEFUN ("char-or-string-p", Fchar_or_string_p, Schar_or_string_p, 1, 1, 0,
doc: /* Return t if OBJECT is a character or a string. */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(register Lisp_Object object)
{
if (CHARACTERP (object) || STRINGP (object))
@@ -523,7 +542,8 @@ DEFUN ("char-or-string-p", Fchar_or_string_p,
Schar_or_string_p, 1, 1, 0,
DEFUN ("integerp", Fintegerp, Sintegerp, 1, 1, 0,
doc: /* Return t if OBJECT is an integer. */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(Lisp_Object object)
{
if (INTEGERP (object))
@@ -532,7 +552,8 @@ DEFUN ("integerp", Fintegerp, Sintegerp, 1, 1, 0,
}
DEFUN ("integer-or-marker-p", Finteger_or_marker_p, Sinteger_or_marker_p, 1,
1, 0,
- doc: /* Return t if OBJECT is an integer or a marker (editor pointer).
*/)
+ doc: /* Return t if OBJECT is an integer or a marker (editor pointer).
*/,
+(function (t) boolean))
(register Lisp_Object object)
{
if (MARKERP (object) || INTEGERP (object))
@@ -542,7 +563,9 @@ DEFUN ("integer-or-marker-p", Finteger_or_marker_p,
Sinteger_or_marker_p, 1, 1,
DEFUN ("natnump", Fnatnump, Snatnump, 1, 1, 0,
doc: /* Return t if OBJECT is a nonnegative integer. */
- attributes: const)
+ attributes: const,
+(function (t) boolean),
+(function (t) boolean))
(Lisp_Object object)
{
return ((FIXNUMP (object) ? 0 <= XFIXNUM (object)
@@ -552,7 +575,8 @@ DEFUN ("natnump", Fnatnump, Snatnump, 1, 1, 0,
DEFUN ("numberp", Fnumberp, Snumberp, 1, 1, 0,
doc: /* Return t if OBJECT is a number (floating point or integer). */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(Lisp_Object object)
{
if (NUMBERP (object))
@@ -563,7 +587,8 @@ DEFUN ("numberp", Fnumberp, Snumberp, 1, 1, 0,
DEFUN ("number-or-marker-p", Fnumber_or_marker_p,
Snumber_or_marker_p, 1, 1, 0,
- doc: /* Return t if OBJECT is a number or a marker. */)
+ doc: /* Return t if OBJECT is a number or a marker. */,
+(function (t) boolean))
(Lisp_Object object)
{
if (NUMBERP (object) || MARKERP (object))
@@ -573,7 +598,8 @@ DEFUN ("number-or-marker-p", Fnumber_or_marker_p,
DEFUN ("floatp", Ffloatp, Sfloatp, 1, 1, 0,
doc: /* Return t if OBJECT is a floating point number. */
- attributes: const)
+ attributes: const,
+(function (t) boolean))
(Lisp_Object object)
{
if (FLOATP (object))
@@ -616,14 +642,16 @@ DEFUN ("car", Fcar, Scar, 1, 1, 0,
Error if LIST is not nil and not a cons cell. See also `car-safe'.
See Info node `(elisp)Cons Cells' for a discussion of related basic
-Lisp concepts such as car, cdr, cons cell and list. */)
+Lisp concepts such as car, cdr, cons cell and list. */,
+(function (list) t))
(register Lisp_Object list)
{
return CAR (list);
}
DEFUN ("car-safe", Fcar_safe, Scar_safe, 1, 1, 0,
- doc: /* Return the car of OBJECT if it is a cons cell, or else nil. */)
+ doc: /* Return the car of OBJECT if it is a cons cell, or else nil. */,
+(function (t) t))
(Lisp_Object object)
{
return CAR_SAFE (object);
@@ -634,14 +662,16 @@ DEFUN ("cdr", Fcdr, Scdr, 1, 1, 0,
Error if LIST is not nil and not a cons cell. See also `cdr-safe'.
See Info node `(elisp)Cons Cells' for a discussion of related basic
-Lisp concepts such as cdr, car, cons cell and list. */)
+Lisp concepts such as cdr, car, cons cell and list. */,
+(function (list) t))
(register Lisp_Object list)
{
return CDR (list);
}
DEFUN ("cdr-safe", Fcdr_safe, Scdr_safe, 1, 1, 0,
- doc: /* Return the cdr of OBJECT if it is a cons cell, or else nil. */)
+ doc: /* Return the cdr of OBJECT if it is a cons cell, or else nil. */,
+(function (t) t))
(Lisp_Object object)
{
return CDR_SAFE (object);
@@ -672,7 +702,8 @@ DEFUN ("setcdr", Fsetcdr, Ssetcdr, 2, 2, 0,
DEFUN ("boundp", Fboundp, Sboundp, 1, 1, 0,
doc: /* Return t if SYMBOL's value is not void.
Note that if `lexical-binding' is in effect, this refers to the
-global value outside of any lexical scope. */)
+global value outside of any lexical scope. */,
+(function (symbol) boolean))
(register Lisp_Object symbol)
{
Lisp_Object valcontents;
@@ -714,7 +745,8 @@ global value outside of any lexical scope. */)
breaking backward compatibility, as some users of fboundp may
expect t in particular, rather than any true value. */
DEFUN ("fboundp", Ffboundp, Sfboundp, 1, 1, 0,
- doc: /* Return t if SYMBOL's function definition is not void. */)
+ doc: /* Return t if SYMBOL's function definition is not void. */,
+(function (symbol) boolean))
(Lisp_Object symbol)
{
CHECK_SYMBOL (symbol);
@@ -758,7 +790,8 @@ See also `makunbound'. */)
}
DEFUN ("symbol-function", Fsymbol_function, Ssymbol_function, 1, 1, 0,
- doc: /* Return SYMBOL's function definition, or nil if that is void.
*/)
+ doc: /* Return SYMBOL's function definition, or nil if that is void.
*/,
+(function (symbol) t))
(Lisp_Object symbol)
{
CHECK_SYMBOL (symbol);
@@ -766,7 +799,8 @@ DEFUN ("symbol-function", Fsymbol_function,
Ssymbol_function, 1, 1, 0,
}
DEFUN ("symbol-plist", Fsymbol_plist, Ssymbol_plist, 1, 1, 0,
- doc: /* Return SYMBOL's property list. */)
+ doc: /* Return SYMBOL's property list. */,
+(function (symbol) list))
(Lisp_Object symbol)
{
CHECK_SYMBOL (symbol);
@@ -777,7 +811,8 @@ DEFUN ("symbol-name", Fsymbol_name, Ssymbol_name, 1, 1, 0,
doc: /* Return SYMBOL's name, a string.
Warning: never alter the string returned by `symbol-name'.
-Doing that might make Emacs dysfunctional, and might even crash Emacs. */)
+Doing that might make Emacs dysfunctional, and might even crash Emacs. */,
+(function (symbol) string))
(register Lisp_Object symbol)
{
register Lisp_Object name;
@@ -1570,7 +1605,8 @@ find_symbol_value (Lisp_Object symbol)
DEFUN ("symbol-value", Fsymbol_value, Ssymbol_value, 1, 1, 0,
doc: /* Return SYMBOL's value. Error if that is void.
Note that if `lexical-binding' is in effect, this returns the
-global value outside of any lexical scope. */)
+global value outside of any lexical scope. */,
+(function (symbol) t))
(Lisp_Object symbol)
{
Lisp_Object val;
@@ -1930,7 +1966,8 @@ DEFUN ("default-boundp", Fdefault_boundp,
Sdefault_boundp, 1, 1, 0,
doc: /* Return t if SYMBOL has a non-void default value.
A variable may have a buffer-local value. This function says whether
the variable has a non-void value outside of the current buffer
-context. Also see `default-value'. */)
+context. Also see `default-value'. */,
+(function (symbol) boolean))
(Lisp_Object symbol)
{
register Lisp_Object value;
@@ -1943,7 +1980,8 @@ DEFUN ("default-value", Fdefault_value, Sdefault_value,
1, 1, 0,
doc: /* Return SYMBOL's default value.
This is the value that is seen in buffers that do not have their own values
for this variable. The default value is meaningful for variables with
-local bindings in certain buffers. */)
+local bindings in certain buffers. */,
+(function (symbol) t))
(Lisp_Object symbol)
{
Lisp_Object value = default_value (symbol);
@@ -2334,7 +2372,8 @@ DEFUN ("local-variable-p", Flocal_variable_p,
Slocal_variable_p,
doc: /* Non-nil if VARIABLE has a local binding in buffer BUFFER.
BUFFER defaults to the current buffer.
-Also see `buffer-local-boundp'.*/)
+Also see `buffer-local-boundp'.*/,
+(function (symbol &optional buffer) boolean))
(Lisp_Object variable, Lisp_Object buffer)
{
struct buffer *buf = decode_buffer (buffer);
@@ -2385,7 +2424,8 @@ BUFFER defaults to the current buffer.
More precisely, return non-nil if either VARIABLE already has a local
value in BUFFER, or if VARIABLE is automatically buffer-local (see
-`make-variable-buffer-local'). */)
+`make-variable-buffer-local'). */,
+(function (symbol &optional buffer) boolean))
(register Lisp_Object variable, Lisp_Object buffer)
{
struct Lisp_Symbol *sym;
@@ -2484,7 +2524,8 @@ function indirections to find the final function binding
and return it. */)
DEFUN ("aref", Faref, Saref, 2, 2, 0,
doc: /* Return the element of ARRAY at index IDX.
ARRAY may be a vector, a string, a char-table, a bool-vector, a record,
-or a byte-code object. IDX starts at 0. */)
+or a byte-code object. IDX starts at 0. */,
+(function (t fixnum) t))
(register Lisp_Object array, Lisp_Object idx)
{
register EMACS_INT idxval;
@@ -2776,7 +2817,8 @@ arithcompare_driver (ptrdiff_t nargs, Lisp_Object *args,
DEFUN ("=", Feqlsign, Seqlsign, 1, MANY, 0,
doc: /* Return t if args, all numbers or markers, are equal.
-usage: (= NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
+usage: (= NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */,
+(function ((or number marker) &rest (or number marker)) boolean))
(ptrdiff_t nargs, Lisp_Object *args)
{
return arithcompare_driver (nargs, args, ARITH_EQUAL);
@@ -2784,7 +2826,8 @@ usage: (= NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
DEFUN ("<", Flss, Slss, 1, MANY, 0,
doc: /* Return t if each arg (a number or marker), is less than the
next arg.
-usage: (< NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
+usage: (< NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */,
+(function ((or number marker) &rest (or number marker)) boolean))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 2 && FIXNUMP (args[0]) && FIXNUMP (args[1]))
@@ -2795,7 +2838,8 @@ usage: (< NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
DEFUN (">", Fgtr, Sgtr, 1, MANY, 0,
doc: /* Return t if each arg (a number or marker) is greater than the
next arg.
-usage: (> NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
+usage: (> NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */,
+(function ((or number marker) &rest (or number marker)) boolean))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 2 && FIXNUMP (args[0]) && FIXNUMP (args[1]))
@@ -2806,7 +2850,8 @@ usage: (> NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
DEFUN ("<=", Fleq, Sleq, 1, MANY, 0,
doc: /* Return t if each arg (a number or marker) is less than or equal
to the next.
-usage: (<= NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
+usage: (<= NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */,
+(function ((or number marker) &rest (or number marker)) boolean))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 2 && FIXNUMP (args[0]) && FIXNUMP (args[1]))
@@ -2817,7 +2862,8 @@ usage: (<= NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
DEFUN (">=", Fgeq, Sgeq, 1, MANY, 0,
doc: /* Return t if each arg (a number or marker) is greater than or
equal to the next.
-usage: (>= NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
+usage: (>= NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */,
+(function ((or number marker) &rest (or number marker)) boolean))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 2 && FIXNUMP (args[0]) && FIXNUMP (args[1]))
@@ -2827,7 +2873,8 @@ usage: (>= NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
}
DEFUN ("/=", Fneq, Sneq, 2, 2, 0,
- doc: /* Return t if first arg is not equal to second arg. Both must be
numbers or markers. */)
+ doc: /* Return t if first arg is not equal to second arg. Both must be
numbers or markers. */,
+(function ((or number marker) (or number marker)) boolean))
(register Lisp_Object num1, Lisp_Object num2)
{
return arithcompare (num1, num2, ARITH_NOTEQUAL);
@@ -2980,7 +3027,9 @@ fixnum_to_string (EMACS_INT number, char *buffer, char
*end)
DEFUN ("number-to-string", Fnumber_to_string, Snumber_to_string, 1, 1, 0,
doc: /* Return the decimal representation of NUMBER as a string.
Uses a minus sign if negative.
-NUMBER may be an integer or a floating point number. */)
+NUMBER may be an integer or a floating point number. */,
+(function (number) string),
+(function (number) string))
(Lisp_Object number)
{
char buffer[max (FLOAT_TO_STRING_BUFSIZE, INT_BUFSIZE_BOUND (EMACS_INT))];
@@ -3009,7 +3058,8 @@ STRING cannot be parsed as an integer or floating point
number.
If BASE, interpret STRING as a number in that base. If BASE isn't
present, base 10 is used. BASE must be between 2 and 16 (inclusive).
-If the base used is not 10, STRING is always parsed as an integer. */)
+If the base used is not 10, STRING is always parsed as an integer. */,
+(function (string &optional integer) number))
(register Lisp_Object string, Lisp_Object base)
{
int b;
@@ -3219,7 +3269,8 @@ arith_driver (enum arithop code, ptrdiff_t nargs,
Lisp_Object *args,
DEFUN ("+", Fplus, Splus, 0, MANY, 0,
doc: /* Return sum of any number of arguments, which are numbers or
markers.
-usage: (+ &rest NUMBERS-OR-MARKERS) */)
+usage: (+ &rest NUMBERS-OR-MARKERS) */,
+(function (&rest (or number marker)) number))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 0)
@@ -3232,7 +3283,8 @@ DEFUN ("-", Fminus, Sminus, 0, MANY, 0,
doc: /* Negate number or subtract numbers or markers and return the
result.
With one arg, negates it. With more than one arg,
subtracts all but the first from the first.
-usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS) */)
+usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS) */,
+(function (&rest (or number marker)) number))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 0)
@@ -3252,7 +3304,8 @@ usage: (- &optional NUMBER-OR-MARKER &rest
MORE-NUMBERS-OR-MARKERS) */)
DEFUN ("*", Ftimes, Stimes, 0, MANY, 0,
doc: /* Return product of any number of arguments, which are numbers or
markers.
-usage: (* &rest NUMBERS-OR-MARKERS) */)
+usage: (* &rest NUMBERS-OR-MARKERS) */,
+(function (&rest (or number marker)) number))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 0)
@@ -3266,7 +3319,8 @@ DEFUN ("/", Fquo, Squo, 1, MANY, 0,
With two or more arguments, return first argument divided by the rest.
With one argument, return 1 divided by the argument.
The arguments must be numbers or markers.
-usage: (/ NUMBER &rest DIVISORS) */)
+usage: (/ NUMBER &rest DIVISORS) */,
+(function ((or number marker) &rest (or number marker)) number))
(ptrdiff_t nargs, Lisp_Object *args)
{
Lisp_Object a = check_number_coerce_marker (args[0]);
@@ -3350,7 +3404,8 @@ integer_remainder (Lisp_Object num, Lisp_Object den, bool
modulo)
DEFUN ("%", Frem, Srem, 2, 2, 0,
doc: /* Return remainder of X divided by Y.
-Both must be integers or markers. */)
+Both must be integers or markers. */,
+(function ((or number marker) (or number marker)) number))
(Lisp_Object x, Lisp_Object y)
{
x = check_integer_coerce_marker (x);
@@ -3361,7 +3416,9 @@ Both must be integers or markers. */)
DEFUN ("mod", Fmod, Smod, 2, 2, 0,
doc: /* Return X modulo Y.
The result falls between zero (inclusive) and Y (exclusive).
-Both X and Y must be numbers or markers. */)
+Both X and Y must be numbers or markers. */,
+(function ((or number marker) (or number marker))
+ (or (integer 0 *) (float 0 *))))
(Lisp_Object x, Lisp_Object y)
{
x = check_number_coerce_marker (x);
@@ -3390,7 +3447,8 @@ minmax_driver (ptrdiff_t nargs, Lisp_Object *args,
DEFUN ("max", Fmax, Smax, 1, MANY, 0,
doc: /* Return largest of all the arguments (which must be numbers or
markers).
The value is always a number; markers are converted to numbers.
-usage: (max NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
+usage: (max NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */,
+(function ((or number marker) &rest (or number marker)) number))
(ptrdiff_t nargs, Lisp_Object *args)
{
return minmax_driver (nargs, args, ARITH_GRTR);
@@ -3399,7 +3457,8 @@ usage: (max NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS)
*/)
DEFUN ("min", Fmin, Smin, 1, MANY, 0,
doc: /* Return smallest of all the arguments (which must be numbers or
markers).
The value is always a number; markers are converted to numbers.
-usage: (min NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */)
+usage: (min NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS) */,
+(function ((or number marker) &rest (or number marker)) number))
(ptrdiff_t nargs, Lisp_Object *args)
{
return minmax_driver (nargs, args, ARITH_LESS);
@@ -3408,7 +3467,8 @@ usage: (min NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS)
*/)
DEFUN ("logand", Flogand, Slogand, 0, MANY, 0,
doc: /* Return bitwise-and of all the arguments.
Arguments may be integers, or markers converted to integers.
-usage: (logand &rest INTS-OR-MARKERS) */)
+usage: (logand &rest INTS-OR-MARKERS) */,
+(function (&rest (or integer marker)) integer))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 0)
@@ -3420,7 +3480,8 @@ usage: (logand &rest INTS-OR-MARKERS) */)
DEFUN ("logior", Flogior, Slogior, 0, MANY, 0,
doc: /* Return bitwise-or of all the arguments.
Arguments may be integers, or markers converted to integers.
-usage: (logior &rest INTS-OR-MARKERS) */)
+usage: (logior &rest INTS-OR-MARKERS) */,
+(function (&rest (or integer marker)) integer))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 0)
@@ -3432,7 +3493,8 @@ usage: (logior &rest INTS-OR-MARKERS) */)
DEFUN ("logxor", Flogxor, Slogxor, 0, MANY, 0,
doc: /* Return bitwise-exclusive-or of all the arguments.
Arguments may be integers, or markers converted to integers.
-usage: (logxor &rest INTS-OR-MARKERS) */)
+usage: (logxor &rest INTS-OR-MARKERS) */,
+(function (&rest (or integer marker)) integer))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 0)
@@ -3445,7 +3507,8 @@ DEFUN ("logcount", Flogcount, Slogcount, 1, 1, 0,
doc: /* Return population count of VALUE.
This is the number of one bits in the two's complement representation
of VALUE. If VALUE is negative, return the number of zero bits in the
-representation. */)
+representation. */,
+(function (integer) integer))
(Lisp_Object value)
{
CHECK_INTEGER (value);
@@ -3480,7 +3543,8 @@ is the same as that of VALUE.
In terms of bits, when COUNT is positive, the function moves
the bits of VALUE to the left, adding zero bits on the right; when
COUNT is negative, it moves the bits of VALUE to the right,
-discarding bits. */)
+discarding bits. */,
+(function (integer integer) integer))
(Lisp_Object value, Lisp_Object count)
{
CHECK_INTEGER (value);
@@ -3562,7 +3626,8 @@ expt_integer (Lisp_Object x, Lisp_Object y)
DEFUN ("1+", Fadd1, Sadd1, 1, 1, 0,
doc: /* Return NUMBER plus one. NUMBER may be a number or a marker.
-Markers are converted to integers. */)
+Markers are converted to integers. */,
+(function ((or number marker)) number))
(Lisp_Object number)
{
number = check_number_coerce_marker (number);
@@ -3577,7 +3642,8 @@ Markers are converted to integers. */)
DEFUN ("1-", Fsub1, Ssub1, 1, 1, 0,
doc: /* Return NUMBER minus one. NUMBER may be a number or a marker.
-Markers are converted to integers. */)
+Markers are converted to integers. */,
+(function ((or number marker)) number))
(Lisp_Object number)
{
number = check_number_coerce_marker (number);
@@ -3591,7 +3657,8 @@ Markers are converted to integers. */)
}
DEFUN ("lognot", Flognot, Slognot, 1, 1, 0,
- doc: /* Return the bitwise complement of NUMBER. NUMBER must be an
integer. */)
+ doc: /* Return the bitwise complement of NUMBER. NUMBER must be an
integer. */,
+(function (integer) integer))
(register Lisp_Object number)
{
CHECK_INTEGER (number);
@@ -3880,7 +3947,8 @@ Return the destination vector if it changed or nil
otherwise. */)
DEFUN ("bool-vector-subsetp", Fbool_vector_subsetp,
Sbool_vector_subsetp, 2, 2, 0,
doc: /* Return t if every t value in A is also t in B, nil otherwise.
-A and B must be bool vectors of the same length. */)
+A and B must be bool vectors of the same length. */,
+(function (bool-vector bool-vector) boolean))
(Lisp_Object a, Lisp_Object b)
{
return bool_vector_binop_driver (a, b, b, bool_vector_subsetp);
@@ -3891,7 +3959,8 @@ DEFUN ("bool-vector-not", Fbool_vector_not,
doc: /* Compute ~A, set complement.
If optional second argument B is given, store result into B.
A and B must be bool vectors of the same length.
-Return the destination vector. */)
+Return the destination vector. */,
+(function (bool-vector &optional bool-vector) bool-vector))
(Lisp_Object a, Lisp_Object b)
{
EMACS_INT nr_bits;
@@ -3931,7 +4000,8 @@ DEFUN ("bool-vector-count-population",
Fbool_vector_count_population,
Sbool_vector_count_population, 1, 1, 0,
doc: /* Count how many elements in A are t.
A is a bool vector. To count A's nil elements, subtract the return
-value from A's length. */)
+value from A's length. */,
+(function (bool-vector) fixnum))
(Lisp_Object a)
{
EMACS_INT count;
@@ -3955,7 +4025,8 @@ value from A's length. */)
DEFUN ("bool-vector-count-consecutive", Fbool_vector_count_consecutive,
Sbool_vector_count_consecutive, 3, 3, 0,
doc: /* Count how many consecutive elements in A equal B starting at I.
-A is a bool vector, B is t or nil, and I is an index into A. */)
+A is a bool vector, B is t or nil, and I is an index into A. */,
+(function (bool-vector boolean integer) fixnum))
(Lisp_Object a, Lisp_Object b, Lisp_Object i)
{
EMACS_INT count;
diff --git a/src/doc.c b/src/doc.c
index b5a9ed498af..d380efb6e3e 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -374,7 +374,8 @@ OBJECT can be either a string or a reference if it's kept
externally. */)
DEFUN ("documentation", Fdocumentation, Sdocumentation, 1, 2, 0,
doc: /* Return the documentation string of FUNCTION.
Unless a non-nil second argument RAW is given, the
-string is passed through `substitute-command-keys'. */)
+string is passed through `substitute-command-keys'. */,
+(function ((or function symbol subr) &optional t) (or null string)))
(Lisp_Object function, Lisp_Object raw)
{
Lisp_Object doc;
diff --git a/src/editfns.c b/src/editfns.c
index cce52cddbf8..12c0f9f8d90 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -148,7 +148,8 @@ init_editfns (void)
DEFUN ("char-to-string", Fchar_to_string, Schar_to_string, 1, 1, 0,
doc: /* Convert arg CHAR to a string containing that character.
-usage: (char-to-string CHAR) */)
+usage: (char-to-string CHAR) */,
+(function (fixnum) string))
(Lisp_Object character)
{
int c, len;
@@ -174,7 +175,8 @@ DEFUN ("byte-to-string", Fbyte_to_string, Sbyte_to_string,
1, 1, 0,
}
DEFUN ("string-to-char", Fstring_to_char, Sstring_to_char, 1, 1, 0,
- doc: /* Return the first character in STRING. */)
+ doc: /* Return the first character in STRING. */,
+(function (string) fixnum))
(Lisp_Object string)
{
CHECK_STRING (string);
@@ -187,7 +189,8 @@ DEFUN ("string-to-char", Fstring_to_char, Sstring_to_char,
1, 1, 0,
DEFUN ("point", Fpoint, Spoint, 0, 0, 0,
doc: /* Return value of point, as an integer.
-Beginning of buffer is position (point-min). */)
+Beginning of buffer is position (point-min). */,
+(function () integer))
(void)
{
Lisp_Object temp;
@@ -196,7 +199,8 @@ Beginning of buffer is position (point-min). */)
}
DEFUN ("point-marker", Fpoint_marker, Spoint_marker, 0, 0, 0,
- doc: /* Return value of point, as a marker object. */)
+ doc: /* Return value of point, as a marker object. */,
+(function () marker))
(void)
{
return build_marker (current_buffer, PT, PT_BYTE);
@@ -249,14 +253,16 @@ region_limit (bool beginningp)
}
DEFUN ("region-beginning", Fregion_beginning, Sregion_beginning, 0, 0, 0,
- doc: /* Return the integer value of point or mark, whichever is
smaller. */)
+ doc: /* Return the integer value of point or mark, whichever is
smaller. */,
+(function () integer))
(void)
{
return region_limit (1);
}
DEFUN ("region-end", Fregion_end, Sregion_end, 0, 0, 0,
- doc: /* Return the integer value of point or mark, whichever is larger.
*/)
+ doc: /* Return the integer value of point or mark, whichever is larger.
*/,
+(function () integer))
(void)
{
return region_limit (0);
@@ -265,7 +271,8 @@ DEFUN ("region-end", Fregion_end, Sregion_end, 0, 0, 0,
DEFUN ("mark-marker", Fmark_marker, Smark_marker, 0, 0, 0,
doc: /* Return this buffer's mark, as a marker object.
Watch out! Moving this marker changes the mark position.
-If you set the marker not to point anywhere, the buffer will have no mark. */)
+If you set the marker not to point anywhere, the buffer will have no mark. */,
+(function () marker))
(void)
{
return BVAR (current_buffer, mark);
@@ -706,7 +713,8 @@ unconstrained result. If N is nil or 1, and a front-sticky
field
starts at point, the scan stops as soon as it starts. To ignore field
boundaries, bind `inhibit-field-text-motion' to t.
-This function does not move point. */)
+This function does not move point. */,
+(function (&optional integer) integer))
(Lisp_Object n)
{
ptrdiff_t count, charpos = bol (n, &count);
@@ -762,7 +770,8 @@ unconstrained result. If N is nil or 1, and a rear-sticky
field ends
at point, the scan stops as soon as it starts. To ignore field
boundaries bind `inhibit-field-text-motion' to t.
-This function does not move point. */)
+This function does not move point. */,
+(function (&optional integer) integer))
(Lisp_Object n)
{
/* Return END_POS constrained to the current input field. */
@@ -858,7 +867,8 @@ This does not take narrowing into account; to count the
number of
characters in the accessible portion of the current buffer, use
`(- (point-max) (point-min))', and to count the number of characters
in the accessible portion of some other BUFFER, use
-`(with-current-buffer BUFFER (- (point-max) (point-min)))'. */)
+`(with-current-buffer BUFFER (- (point-max) (point-min)))'. */,
+(function (&optional buffer) integer))
(Lisp_Object buffer)
{
if (NILP (buffer))
@@ -873,7 +883,8 @@ in the accessible portion of some other BUFFER, use
DEFUN ("point-min", Fpoint_min, Spoint_min, 0, 0, 0,
doc: /* Return the minimum permissible value of point in the current
buffer.
-This is 1, unless narrowing (a buffer restriction) is in effect. */)
+This is 1, unless narrowing (a buffer restriction) is in effect. */,
+(function () integer))
(void)
{
Lisp_Object temp;
@@ -892,7 +903,8 @@ This is the beginning, unless narrowing (a buffer
restriction) is in effect. */
DEFUN ("point-max", Fpoint_max, Spoint_max, 0, 0, 0,
doc: /* Return the maximum permissible value of point in the current
buffer.
This is (1+ (buffer-size)), unless narrowing (a buffer restriction)
-is in effect, in which case it is less. */)
+is in effect, in which case it is less. */,
+(function () integer))
(void)
{
Lisp_Object temp;
@@ -963,7 +975,8 @@ If BYTEPOS is out of range, the value is nil. */)
DEFUN ("following-char", Ffollowing_char, Sfollowing_char, 0, 0, 0,
doc: /* Return the character following point, as a number.
-At the end of the buffer or accessible region, return 0. */)
+At the end of the buffer or accessible region, return 0. */,
+(function () fixnum))
(void)
{
Lisp_Object temp;
@@ -976,7 +989,8 @@ At the end of the buffer or accessible region, return 0.
*/)
DEFUN ("preceding-char", Fprevious_char, Sprevious_char, 0, 0, 0,
doc: /* Return the character preceding point, as a number.
-At the beginning of the buffer or accessible region, return 0. */)
+At the beginning of the buffer or accessible region, return 0. */,
+(function () fixnum))
(void)
{
Lisp_Object temp;
@@ -995,7 +1009,8 @@ At the beginning of the buffer or accessible region,
return 0. */)
DEFUN ("bobp", Fbobp, Sbobp, 0, 0, 0,
doc: /* Return t if point is at the beginning of the buffer.
-If the buffer is narrowed, this means the beginning of the narrowed part. */)
+If the buffer is narrowed, this means the beginning of the narrowed part. */,
+(function () boolean))
(void)
{
if (PT == BEGV)
@@ -1005,7 +1020,8 @@ If the buffer is narrowed, this means the beginning of
the narrowed part. */)
DEFUN ("eobp", Feobp, Seobp, 0, 0, 0,
doc: /* Return t if point is at the end of the buffer.
-If the buffer is narrowed, this means the end of the narrowed part. */)
+If the buffer is narrowed, this means the end of the narrowed part. */,
+(function () boolean))
(void)
{
if (PT == ZV)
@@ -1014,7 +1030,8 @@ If the buffer is narrowed, this means the end of the
narrowed part. */)
}
DEFUN ("bolp", Fbolp, Sbolp, 0, 0, 0,
- doc: /* Return t if point is at the beginning of a line. */)
+ doc: /* Return t if point is at the beginning of a line. */,
+(function () boolean))
(void)
{
if (PT == BEGV || FETCH_BYTE (PT_BYTE - 1) == '\n')
@@ -1024,7 +1041,8 @@ DEFUN ("bolp", Fbolp, Sbolp, 0, 0, 0,
DEFUN ("eolp", Feolp, Seolp, 0, 0, 0,
doc: /* Return t if point is at the end of a line.
-`End of a line' includes point being at the end of the buffer. */)
+`End of a line' includes point being at the end of the buffer. */,
+(function () boolean))
(void)
{
if (PT == ZV || FETCH_BYTE (PT_BYTE) == '\n')
@@ -1035,7 +1053,8 @@ DEFUN ("eolp", Feolp, Seolp, 0, 0, 0,
DEFUN ("char-after", Fchar_after, Schar_after, 0, 1, 0,
doc: /* Return character in current buffer at position POS.
POS is an integer or a marker and defaults to point.
-If POS is out of range, the value is nil. */)
+If POS is out of range, the value is nil. */,
+(function (&optional (or marker integer)) (or fixnum null)))
(Lisp_Object pos)
{
register ptrdiff_t pos_byte;
@@ -1067,7 +1086,8 @@ If POS is out of range, the value is nil. */)
DEFUN ("char-before", Fchar_before, Schar_before, 0, 1, 0,
doc: /* Return character in current buffer preceding position POS.
POS is an integer or a marker and defaults to point.
-If POS is out of range, the value is nil. */)
+If POS is out of range, the value is nil. */,
+(function (&optional (or marker integer)) (or fixnum null)))
(Lisp_Object pos)
{
register Lisp_Object val;
@@ -1116,7 +1136,9 @@ Also, if the environment variables LOGNAME or USER are
set,
that determines the value of this function.
If optional argument UID is an integer, return the login name
-of the user with that uid, or nil if there is no such user. */)
+of the user with that uid, or nil if there is no such user. */,
+(function (&optional integer) (or string null)),
+(function (&optional integer) (or string null)))
(Lisp_Object uid)
{
struct passwd *pw;
@@ -1142,7 +1164,8 @@ DEFUN ("user-real-login-name", Fuser_real_login_name,
Suser_real_login_name,
0, 0, 0,
doc: /* Return the name of the user's real uid, as a string.
This ignores the environment variables LOGNAME and USER, so it differs from
-`user-login-name' when running under `su'. */)
+`user-login-name' when running under `su'. */,
+(function () string))
(void)
{
/* Set up the user name info if we didn't do it before.
@@ -1154,7 +1177,8 @@ This ignores the environment variables LOGNAME and USER,
so it differs from
}
DEFUN ("user-uid", Fuser_uid, Suser_uid, 0, 0, 0,
- doc: /* Return the effective uid of Emacs, as an integer. */)
+ doc: /* Return the effective uid of Emacs, as an integer. */,
+(function () integer))
(void)
{
uid_t euid = geteuid ();
@@ -1162,7 +1186,8 @@ DEFUN ("user-uid", Fuser_uid, Suser_uid, 0, 0, 0,
}
DEFUN ("user-real-uid", Fuser_real_uid, Suser_real_uid, 0, 0, 0,
- doc: /* Return the real uid of Emacs, as an integer. */)
+ doc: /* Return the real uid of Emacs, as an integer. */,
+(function () integer))
(void)
{
uid_t uid = getuid ();
@@ -1215,7 +1240,8 @@ name, or nil if there is no such user.
If the full name includes commas, remove everything starting with
the first comma, because the \\='gecos\\=' field of the \\='/etc/passwd\\='
file
-is in general a comma-separated list. */)
+is in general a comma-separated list. */,
+(function (&optional integer) (or string null)))
(Lisp_Object uid)
{
struct passwd *pw;
@@ -1652,7 +1678,8 @@ The string returned is multibyte if the buffer is
multibyte.
This function copies the text properties of that part of the buffer
into the result string; if you don't want the text properties,
-use `buffer-substring-no-properties' instead. */)
+use `buffer-substring-no-properties' instead. */,
+(function ((or integer marker) (or integer marker)) string))
(Lisp_Object start, Lisp_Object end)
{
register ptrdiff_t b, e;
@@ -1687,7 +1714,8 @@ of the buffer.
This function copies the text properties of that part of the buffer
into the result string; if you don’t want the text properties,
-use `buffer-substring-no-properties' instead. */)
+use `buffer-substring-no-properties' instead. */,
+(function () string))
(void)
{
return make_buffer_string_both (BEGV, BEGV_BYTE, ZV, ZV_BYTE, 1);
@@ -3251,7 +3279,8 @@ Remaining arguments form a sequence of PROPERTY VALUE
pairs for text
properties to add to the result.
See Info node `(elisp) Text Properties' for more information.
-usage: (propertize STRING &rest PROPERTIES) */)
+usage: (propertize STRING &rest PROPERTIES) */,
+(function (string &rest t) string))
(ptrdiff_t nargs, Lisp_Object *args)
{
Lisp_Object properties, string;
@@ -3363,7 +3392,8 @@ given width.
Text properties, if any, are copied from the format-string to the
produced text.
-usage: (format STRING &rest OBJECTS) */)
+usage: (format STRING &rest OBJECTS) */,
+(function (string &rest t) string))
(ptrdiff_t nargs, Lisp_Object *args)
{
return styled_format (nargs, args, false);
@@ -4326,7 +4356,8 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool
message)
DEFUN ("char-equal", Fchar_equal, Schar_equal, 2, 2, 0,
doc: /* Return t if two characters match, optionally ignoring case.
Both arguments must be characters (i.e. integers).
-Case is ignored if `case-fold-search' is non-nil in the current buffer. */)
+Case is ignored if `case-fold-search' is non-nil in the current buffer. */,
+(function (integer integer) boolean))
(register Lisp_Object c1, Lisp_Object c2)
{
int i1, i2;
diff --git a/src/emacs.c b/src/emacs.c
index f4bfb9a6bbd..dc2c28d75d3 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -660,7 +660,8 @@ init_cmdargs (int argc, char **argv, int skip_args, char
const *original_pwd)
DEFUN ("invocation-name", Finvocation_name, Sinvocation_name, 0, 0, 0,
doc: /* Return the program name that was used to run Emacs.
-Any directory names are omitted. */)
+Any directory names are omitted. */,
+(function () string))
(void)
{
return Fcopy_sequence (Vinvocation_name);
@@ -668,7 +669,8 @@ Any directory names are omitted. */)
DEFUN ("invocation-directory", Finvocation_directory, Sinvocation_directory,
0, 0, 0,
- doc: /* Return the directory name in which the Emacs executable was
located. */)
+ doc: /* Return the directory name in which the Emacs executable was
located. */,
+(function () string))
(void)
{
return Fcopy_sequence (Vinvocation_directory);
diff --git a/src/eval.c b/src/eval.c
index 95eb21909d2..63428b58054 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1289,7 +1289,8 @@ unwind_to_catch (struct handler *catch, enum
nonlocal_exit type,
DEFUN ("throw", Fthrow, Sthrow, 2, 2, 0,
doc: /* Throw to the catch for TAG and return VALUE from it.
Both TAG and VALUE are evalled. */
- attributes: noreturn)
+ attributes: noreturn,
+(function (t t) nil))
(register Lisp_Object tag, Lisp_Object value)
{
struct handler *c;
@@ -1737,7 +1738,8 @@ See Info anchor `(elisp)Definition of signal' for some
details on how this
error message is constructed.
If the signal is handled, DATA is made available to the handler.
See also the function `condition-case'. */
- attributes: noreturn)
+ attributes: noreturn,
+(function (symbol t) nil))
(Lisp_Object error_symbol, Lisp_Object data)
{
/* If they call us with nonsensical arguments, produce "peculiar error". */
@@ -2130,7 +2132,8 @@ fourth argument, and some of the built-in functions of
Lisp.
Also, a symbol satisfies `commandp' if its function definition does so.
If the optional argument FOR-CALL-INTERACTIVELY is non-nil,
-then strings and vectors are not accepted. */)
+then strings and vectors are not accepted. */,
+(function (t &optional t) boolean))
(Lisp_Object function, Lisp_Object for_call_interactively)
{
register Lisp_Object fun;
diff --git a/src/fileio.c b/src/fileio.c
index 483498fd879..b3149bb6786 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -2964,7 +2964,8 @@ DEFUN ("file-name-absolute-p", Ffile_name_absolute_p,
Sfile_name_absolute_p,
doc: /* Return t if FILENAME is an absolute file name.
On Unix, absolute file names start with `/'. In Emacs, an absolute
file name can also start with an initial `~' or `~USER' component,
-where USER is a valid login name. */)
+where USER is a valid login name. */,
+(function (string) boolean))
(Lisp_Object filename)
{
CHECK_STRING (filename);
@@ -3008,7 +3009,8 @@ Return nil if FILENAME does not exist, or if there was
trouble
determining whether the file exists.
See also `file-readable-p' and `file-attributes'.
This returns nil for a symlink to a nonexistent file.
-Use `file-symlink-p' to test for such links. */)
+Use `file-symlink-p' to test for such links. */,
+(function (string) boolean))
(Lisp_Object filename)
{
return check_file_access (filename, Qfile_exists_p, F_OK);
@@ -3026,14 +3028,16 @@ purpose, though.) */)
DEFUN ("file-readable-p", Ffile_readable_p, Sfile_readable_p, 1, 1, 0,
doc: /* Return t if file FILENAME exists and you can read it.
-See also `file-exists-p' and `file-attributes'. */)
+See also `file-exists-p' and `file-attributes'. */,
+(function (string) boolean))
(Lisp_Object filename)
{
return check_file_access (filename, Qfile_readable_p, R_OK);
}
DEFUN ("file-writable-p", Ffile_writable_p, Sfile_writable_p, 1, 1, 0,
- doc: /* Return t if file FILENAME can be written or created by you. */)
+ doc: /* Return t if file FILENAME can be written or created by you. */,
+(function (string) boolean))
(Lisp_Object filename)
{
Lisp_Object absname, dir, encoded;
@@ -3160,7 +3164,8 @@ The value is the link target, as a string.
Return nil if FILENAME does not exist or is not a symbolic link,
of there was trouble determining whether the file is a symbolic link.
-This function does not check whether the link target exists. */)
+This function does not check whether the link target exists. */,
+(function (string) (or boolean string)))
(Lisp_Object filename)
{
Lisp_Object handler;
@@ -3187,7 +3192,8 @@ empty string (\"\"). This quirk is due to Emacs
interpreting the
empty string (in some cases) as the current directory.
Symbolic links to directories count as directories.
-See `file-symlink-p' to distinguish symlinks. */)
+See `file-symlink-p' to distinguish symlinks. */,
+(function (string) boolean))
(Lisp_Object filename)
{
Lisp_Object absname = expand_and_dir_to_file (filename);
@@ -3788,7 +3794,8 @@ DEFUN ("unix-sync", Funix_sync, Sunix_sync, 0, 0, "",
DEFUN ("file-newer-than-file-p", Ffile_newer_than_file_p,
Sfile_newer_than_file_p, 2, 2, 0,
doc: /* Return t if file FILE1 is newer than file FILE2.
If FILE1 does not exist, the answer is nil;
-otherwise, if FILE2 does not exist, the answer is t. */)
+otherwise, if FILE2 does not exist, the answer is t. */,
+(function (string string) boolean))
(Lisp_Object file1, Lisp_Object file2)
{
struct stat st1, st2;
@@ -5735,7 +5742,8 @@ write_region (Lisp_Object start, Lisp_Object end,
Lisp_Object filename,
}
DEFUN ("car-less-than-car", Fcar_less_than_car, Scar_less_than_car, 2, 2, 0,
- doc: /* Return t if (car A) is numerically less than (car B). */)
+ doc: /* Return t if (car A) is numerically less than (car B). */,
+(function (list list) boolean))
(Lisp_Object a, Lisp_Object b)
{
Lisp_Object ca = Fcar (a), cb = Fcar (b);
diff --git a/src/filelock.c b/src/filelock.c
index 8c27b226900..fcf352fe18e 100644
--- a/src/filelock.c
+++ b/src/filelock.c
@@ -730,7 +730,8 @@ unlock_buffer (struct buffer *buffer)
DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 1, 1, 0,
doc: /* Return a value indicating whether FILENAME is locked.
The value is nil if the FILENAME is not locked,
-t if it is locked by you, else a string saying which user has locked it. */)
+t if it is locked by you, else a string saying which user has locked it. */,
+(function (string) (or boolean string)))
(Lisp_Object filename)
{
#ifdef MSDOS
diff --git a/src/floatfns.c b/src/floatfns.c
index 4492815c765..da0c9b36594 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -83,7 +83,8 @@ extract_float (Lisp_Object num)
/* Trig functions. */
DEFUN ("acos", Facos, Sacos, 1, 1, 0,
- doc: /* Return the inverse cosine of ARG. */)
+ doc: /* Return the inverse cosine of ARG. */,
+(function (number) float))
(Lisp_Object arg)
{
double d = extract_float (arg);
@@ -92,7 +93,8 @@ DEFUN ("acos", Facos, Sacos, 1, 1, 0,
}
DEFUN ("asin", Fasin, Sasin, 1, 1, 0,
- doc: /* Return the inverse sine of ARG. */)
+ doc: /* Return the inverse sine of ARG. */,
+(function (number) float))
(Lisp_Object arg)
{
double d = extract_float (arg);
@@ -105,7 +107,8 @@ DEFUN ("atan", Fatan, Satan, 1, 2, 0,
If only one argument Y is given, return the inverse tangent of Y.
If two arguments Y and X are given, return the inverse tangent of Y
divided by X, i.e. the angle in radians between the vector (X, Y)
-and the x-axis. */)
+and the x-axis. */,
+(function (number &optional number) float))
(Lisp_Object y, Lisp_Object x)
{
double d = extract_float (y);
@@ -121,7 +124,8 @@ and the x-axis. */)
}
DEFUN ("cos", Fcos, Scos, 1, 1, 0,
- doc: /* Return the cosine of ARG. */)
+ doc: /* Return the cosine of ARG. */,
+(function (number) float))
(Lisp_Object arg)
{
double d = extract_float (arg);
@@ -130,7 +134,8 @@ DEFUN ("cos", Fcos, Scos, 1, 1, 0,
}
DEFUN ("sin", Fsin, Ssin, 1, 1, 0,
- doc: /* Return the sine of ARG. */)
+ doc: /* Return the sine of ARG. */,
+(function (number) float))
(Lisp_Object arg)
{
double d = extract_float (arg);
@@ -139,7 +144,8 @@ DEFUN ("sin", Fsin, Ssin, 1, 1, 0,
}
DEFUN ("tan", Ftan, Stan, 1, 1, 0,
- doc: /* Return the tangent of ARG. */)
+ doc: /* Return the tangent of ARG. */,
+(function (number) float))
(Lisp_Object arg)
{
double d = extract_float (arg);
@@ -148,7 +154,8 @@ DEFUN ("tan", Ftan, Stan, 1, 1, 0,
}
DEFUN ("isnan", Fisnan, Sisnan, 1, 1, 0,
- doc: /* Return non-nil if argument X is a NaN. */)
+ doc: /* Return non-nil if argument X is a NaN. */,
+(function (float) boolean))
(Lisp_Object x)
{
CHECK_FLOAT (x);
@@ -163,7 +170,8 @@ DEFUN ("isnan", Fisnan, Sisnan, 1, 1, 0,
DEFUN ("copysign", Fcopysign, Scopysign, 2, 2, 0,
doc: /* Copy sign of X2 to value of X1, and return the result.
-Cause an error if X1 or X2 is not a float. */)
+Cause an error if X1 or X2 is not a float. */,
+(function (float float) float))
(Lisp_Object x1, Lisp_Object x2)
{
double f1, f2;
@@ -199,7 +207,8 @@ If X is zero, both parts (SGNFCAND and EXP) are zero. */)
DEFUN ("ldexp", Fldexp, Sldexp, 2, 2, 0,
doc: /* Return SGNFCAND * 2**EXPONENT, as a floating point number.
-EXPONENT must be an integer. */)
+EXPONENT must be an integer. */,
+(function (number integer) float))
(Lisp_Object sgnfcand, Lisp_Object exponent)
{
CHECK_FIXNUM (exponent);
@@ -208,7 +217,8 @@ EXPONENT must be an integer. */)
}
DEFUN ("exp", Fexp, Sexp, 1, 1, 0,
- doc: /* Return the exponential base e of ARG. */)
+ doc: /* Return the exponential base e of ARG. */,
+(function (number) float))
(Lisp_Object arg)
{
double d = extract_float (arg);
@@ -217,7 +227,8 @@ DEFUN ("exp", Fexp, Sexp, 1, 1, 0,
}
DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
- doc: /* Return the exponential ARG1 ** ARG2. */)
+ doc: /* Return the exponential ARG1 ** ARG2. */,
+(function (number number) number))
(Lisp_Object arg1, Lisp_Object arg2)
{
CHECK_NUMBER (arg1);
@@ -233,7 +244,8 @@ DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
DEFUN ("log", Flog, Slog, 1, 2, 0,
doc: /* Return the natural logarithm of ARG.
-If the optional argument BASE is given, return log ARG using that base. */)
+If the optional argument BASE is given, return log ARG using that base. */,
+(function (number number) float))
(Lisp_Object arg, Lisp_Object base)
{
double d = extract_float (arg);
@@ -257,7 +269,8 @@ If the optional argument BASE is given, return log ARG
using that base. */)
}
DEFUN ("sqrt", Fsqrt, Ssqrt, 1, 1, 0,
- doc: /* Return the square root of ARG. */)
+ doc: /* Return the square root of ARG. */,
+(function (number) float))
(Lisp_Object arg)
{
double d = extract_float (arg);
@@ -266,7 +279,8 @@ DEFUN ("sqrt", Fsqrt, Ssqrt, 1, 1, 0,
}
DEFUN ("abs", Fabs, Sabs, 1, 1, 0,
- doc: /* Return the absolute value of ARG. */)
+ doc: /* Return the absolute value of ARG. */,
+(function (number) number))
(Lisp_Object arg)
{
CHECK_NUMBER (arg);
@@ -294,7 +308,8 @@ DEFUN ("abs", Fabs, Sabs, 1, 1, 0,
}
DEFUN ("float", Ffloat, Sfloat, 1, 1, 0,
- doc: /* Return the floating point number equal to ARG. */)
+ doc: /* Return the floating point number equal to ARG. */,
+(function (number) float))
(register Lisp_Object arg)
{
CHECK_NUMBER (arg);
@@ -304,7 +319,8 @@ DEFUN ("float", Ffloat, Sfloat, 1, 1, 0,
DEFUN ("logb", Flogb, Slogb, 1, 1, 0,
doc: /* Returns largest integer <= the base 2 log of the magnitude of
ARG.
-This is the same as the exponent of a float. */)
+This is the same as the exponent of a float. */,
+(function (number) integer))
(Lisp_Object arg)
{
EMACS_INT value;
@@ -521,7 +537,8 @@ trunc (double d)
DEFUN ("ceiling", Fceiling, Sceiling, 1, 2, 0,
doc: /* Return the smallest integer no less than ARG.
This rounds the value towards +inf.
-With optional DIVISOR, return the smallest integer no less than ARG/DIVISOR.
*/)
+With optional DIVISOR, return the smallest integer no less than ARG/DIVISOR.
*/,
+(function (number &optional number) integer))
(Lisp_Object arg, Lisp_Object divisor)
{
return rounding_driver (arg, divisor, ceil, mpz_cdiv_q, ceiling2);
@@ -530,7 +547,8 @@ With optional DIVISOR, return the smallest integer no less
than ARG/DIVISOR. */
DEFUN ("floor", Ffloor, Sfloor, 1, 2, 0,
doc: /* Return the largest integer no greater than ARG.
This rounds the value towards -inf.
-With optional DIVISOR, return the largest integer no greater than ARG/DIVISOR.
*/)
+With optional DIVISOR, return the largest integer no greater than ARG/DIVISOR.
*/,
+(function (number &optional number) integer))
(Lisp_Object arg, Lisp_Object divisor)
{
return rounding_driver (arg, divisor, floor, mpz_fdiv_q, floor2);
@@ -543,7 +561,8 @@ With optional DIVISOR, return the nearest integer to
ARG/DIVISOR.
Rounding a value equidistant between two integers may choose the
integer closer to zero, or it may prefer an even integer, depending on
your machine. For example, (round 2.5) can return 3 on some
-systems, but 2 on others. */)
+systems, but 2 on others. */,
+(function (number &optional number) integer))
(Lisp_Object arg, Lisp_Object divisor)
{
return rounding_driver (arg, divisor, emacs_rint, rounddiv_q, round2);
@@ -559,7 +578,8 @@ identity (double x)
DEFUN ("truncate", Ftruncate, Struncate, 1, 2, 0,
doc: /* Truncate a floating point number to an int.
Rounds ARG toward zero.
-With optional DIVISOR, truncate ARG/DIVISOR. */)
+With optional DIVISOR, truncate ARG/DIVISOR. */,
+(function (number &optional number) integer))
(Lisp_Object arg, Lisp_Object divisor)
{
return rounding_driver (arg, divisor, identity, mpz_tdiv_q, truncate2);
@@ -583,7 +603,8 @@ fmod_float (Lisp_Object x, Lisp_Object y)
DEFUN ("fceiling", Ffceiling, Sfceiling, 1, 1, 0,
doc: /* Return the smallest integer no less than ARG, as a float.
-\(Round toward +inf.) */)
+\(Round toward +inf.) */,
+(function (float) float))
(Lisp_Object arg)
{
CHECK_FLOAT (arg);
@@ -594,7 +615,8 @@ DEFUN ("fceiling", Ffceiling, Sfceiling, 1, 1, 0,
DEFUN ("ffloor", Fffloor, Sffloor, 1, 1, 0,
doc: /* Return the largest integer no greater than ARG, as a float.
-\(Round toward -inf.) */)
+\(Round toward -inf.) */,
+(function (float) float))
(Lisp_Object arg)
{
CHECK_FLOAT (arg);
@@ -604,7 +626,8 @@ DEFUN ("ffloor", Fffloor, Sffloor, 1, 1, 0,
}
DEFUN ("fround", Ffround, Sfround, 1, 1, 0,
- doc: /* Return the nearest integer to ARG, as a float. */)
+ doc: /* Return the nearest integer to ARG, as a float. */,
+(function (float) float))
(Lisp_Object arg)
{
CHECK_FLOAT (arg);
@@ -615,7 +638,8 @@ DEFUN ("fround", Ffround, Sfround, 1, 1, 0,
DEFUN ("ftruncate", Fftruncate, Sftruncate, 1, 1, 0,
doc: /* Truncate a floating point number to an integral float value.
-\(Round toward zero.) */)
+\(Round toward zero.) */,
+(function (float) float))
(Lisp_Object arg)
{
CHECK_FLOAT (arg);
diff --git a/src/fns.c b/src/fns.c
index 0a9692f36e8..40fdfb2733d 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -50,7 +50,8 @@ static EMACS_UINT sxhash_obj (Lisp_Object, int);
DEFUN ("identity", Fidentity, Sidentity, 1, 1, 0,
doc: /* Return the ARGUMENT unchanged. */
- attributes: const)
+ attributes: const,
+(function (t) t))
(Lisp_Object argument)
{
return argument;
@@ -134,7 +135,8 @@ To get the number of bytes, use `string-bytes'.
If the length of a list is being computed to compare to a (small)
number, the `length<', `length>' and `length=' functions may be more
-efficient. */)
+efficient. */,
+(function (t) (integer 0 *)))
(Lisp_Object sequence)
{
EMACS_INT val;
@@ -163,7 +165,8 @@ DEFUN ("safe-length", Fsafe_length, Ssafe_length, 1, 1, 0,
doc: /* Return the length of a list, but avoid error or infinite loop.
This function never gets an error. If LIST is not really a list,
it returns 0. If LIST is circular, it returns an integer that is at
-least the number of distinct elements. */)
+least the number of distinct elements. */,
+(function (t) integer))
(Lisp_Object list)
{
intptr_t len = 0;
@@ -196,7 +199,8 @@ EMACS_INT length_internal (Lisp_Object sequence, int len)
DEFUN ("length<", Flength_less, Slength_less, 2, 2, 0,
doc: /* Return non-nil if SEQUENCE is shorter than LENGTH.
See `length' for allowed values of SEQUENCE and how elements are
-counted. */)
+counted. */,
+(function (sequence fixnum) boolean))
(Lisp_Object sequence, Lisp_Object length)
{
CHECK_FIXNUM (length);
@@ -211,7 +215,8 @@ counted. */)
DEFUN ("length>", Flength_greater, Slength_greater, 2, 2, 0,
doc: /* Return non-nil if SEQUENCE is longer than LENGTH.
See `length' for allowed values of SEQUENCE and how elements are
-counted. */)
+counted. */,
+(function (sequence fixnum) boolean))
(Lisp_Object sequence, Lisp_Object length)
{
CHECK_FIXNUM (length);
@@ -226,7 +231,8 @@ counted. */)
DEFUN ("length=", Flength_equal, Slength_equal, 2, 2, 0,
doc: /* Return non-nil if SEQUENCE has length equal to LENGTH.
See `length' for allowed values of SEQUENCE and how elements are
-counted. */)
+counted. */,
+(function (sequence fixnum) boolean))
(Lisp_Object sequence, Lisp_Object length)
{
CHECK_FIXNUM (length);
@@ -244,7 +250,8 @@ counted. */)
DEFUN ("proper-list-p", Fproper_list_p, Sproper_list_p, 1, 1, 0,
doc: /* Return OBJECT's length if it is a proper list, nil otherwise.
A proper list is neither circular nor dotted (i.e., its last cdr is nil). */
- attributes: const)
+ attributes: const,
+(function (t) (or fixnum null)))
(Lisp_Object object)
{
intptr_t len = 0;
@@ -341,7 +348,9 @@ DEFUN ("string-equal", Fstring_equal, Sstring_equal, 2, 2,
0,
Case is significant, but text properties are ignored.
Symbols are also allowed; their print names are used instead.
-See also `string-equal-ignore-case'. */)
+See also `string-equal-ignore-case'. */,
+(function ((or string symbol) (or string symbol)) boolean),
+(function ((or string symbol) (or string symbol)) boolean))
(register Lisp_Object s1, Lisp_Object s2)
{
if (SYMBOLP (s1))
@@ -378,7 +387,11 @@ The value is t if the strings (or specified portions)
match.
If string STR1 is less, the value is a negative number N;
- 1 - N is the number of characters that match at the beginning.
If string STR1 is greater, the value is a positive number N;
- N - 1 is the number of characters that match at the beginning. */)
+ N - 1 is the number of characters that match at the beginning. */,
+(function (string (or integer marker null) (or integer marker null) string
+ (or integer marker null) (or integer marker null)
+ &optional t)
+ (or (member t) fixnum)))
(Lisp_Object str1, Lisp_Object start1, Lisp_Object end1, Lisp_Object str2,
Lisp_Object start2, Lisp_Object end2, Lisp_Object ignore_case)
{
@@ -469,7 +482,9 @@ load_unaligned_size_t (const void *p)
DEFUN ("string-lessp", Fstring_lessp, Sstring_lessp, 2, 2, 0,
doc: /* Return non-nil if STRING1 is less than STRING2 in lexicographic
order.
Case is significant.
-Symbols are also allowed; their print names are used instead. */)
+Symbols are also allowed; their print names are used instead. */,
+(function ((or string symbol) (or string symbol)) boolean),
+(function ((or string symbol) (or string symbol)) boolean))
(Lisp_Object string1, Lisp_Object string2)
{
if (SYMBOLP (string1))
@@ -711,7 +726,8 @@ Each argument may be a list, vector or string.
All arguments except the last argument are copied. The last argument
is just used as the tail of the new list.
-usage: (append &rest SEQUENCES) */)
+usage: (append &rest SEQUENCES) */,
+(function (&rest t) t))
(ptrdiff_t nargs, Lisp_Object *args)
{
if (nargs == 0)
@@ -726,7 +742,8 @@ Each argument may be a string or a list or vector of
characters (integers).
Values of the `composition' property of the result are not guaranteed
to be `eq'.
-usage: (concat &rest SEQUENCES) */)
+usage: (concat &rest SEQUENCES) */,
+(function (&rest sequence) string))
(ptrdiff_t nargs, Lisp_Object *args)
{
return concat_to_string (nargs, args);
@@ -736,7 +753,8 @@ DEFUN ("vconcat", Fvconcat, Svconcat, 0, MANY, 0,
doc: /* Concatenate all the arguments and make the result a vector.
The result is a vector whose elements are the elements of all the arguments.
Each argument may be a list, vector or string.
-usage: (vconcat &rest SEQUENCES) */)
+usage: (vconcat &rest SEQUENCES) */,
+(function (&rest sequence) vector))
(ptrdiff_t nargs, Lisp_Object *args)
{
return concat_to_vector (nargs, args);
@@ -749,7 +767,8 @@ The elements of a list, vector or record are not copied;
they are
shared with the original. See Info node `(elisp) Sequence Functions'
for more details about this sharing and its effects.
If the original sequence is empty, this function may return
-the same empty object instead of its copy. */)
+the same empty object instead of its copy. */,
+(function (sequence) sequence))
(Lisp_Object arg)
{
if (NILP (arg)) return arg;
@@ -1363,7 +1382,8 @@ newly created string with no text properties. If STRING
is multibyte
or entirely ASCII, it is returned unchanged. In particular, when
STRING is unibyte and entirely ASCII, the returned string is unibyte.
\(When the characters are all ASCII, Emacs primitives will treat the
-string the same way whether it is unibyte or multibyte.) */)
+string the same way whether it is unibyte or multibyte.) */,
+(function (string) string))
(Lisp_Object string)
{
CHECK_STRING (string);
@@ -1385,7 +1405,8 @@ DEFUN ("string-make-unibyte", Fstring_make_unibyte,
Sstring_make_unibyte,
1, 1, 0,
doc: /* Return the unibyte equivalent of STRING.
Multibyte character codes above 255 are converted to unibyte
-by taking just the low 8 bits of each character's code. */)
+by taking just the low 8 bits of each character's code. */,
+(function (string) string))
(Lisp_Object string)
{
CHECK_STRING (string);
@@ -1399,7 +1420,8 @@ DEFUN ("string-as-unibyte", Fstring_as_unibyte,
Sstring_as_unibyte,
If STRING is unibyte, the result is STRING itself.
Otherwise it is a newly created string, with no text properties.
If STRING is multibyte and contains a character of charset
-`eight-bit', it is converted to the corresponding single byte. */)
+`eight-bit', it is converted to the corresponding single byte. */,
+(function (string) string))
(Lisp_Object string)
{
CHECK_STRING (string);
@@ -1429,7 +1451,8 @@ See also `string-to-multibyte'.
Beware, this often doesn't really do what you think it does.
It is similar to (decode-coding-string STRING \\='utf-8-emacs).
If you're not sure, whether to use `string-as-multibyte' or
-`string-to-multibyte', use `string-to-multibyte'. */)
+`string-to-multibyte', use `string-to-multibyte'. */,
+(function (string) string))
(Lisp_Object string)
{
CHECK_STRING (string);
@@ -1464,7 +1487,8 @@ the corresponding multibyte character of charset
`eight-bit'.
This differs from `string-as-multibyte' by converting each byte of a correct
utf-8 sequence to an eight-bit character, not just bytes that don't form a
-correct sequence. */)
+correct sequence. */,
+(function (string) string))
(Lisp_Object string)
{
CHECK_STRING (string);
@@ -1510,7 +1534,8 @@ This is an alist which represents the same mapping from
objects to objects,
but does not share the alist structure with ALIST.
The objects mapped (cars and cdrs of elements of the alist)
are shared, however.
-Elements of ALIST that are not conses are also shared. */)
+Elements of ALIST that are not conses are also shared. */,
+(function (list) list))
(Lisp_Object alist)
{
CHECK_LIST (alist);
@@ -1579,7 +1604,8 @@ The STRING argument may also be a vector. In that case,
the return
value is a new vector that contains the elements between index FROM
\(inclusive) and index TO (exclusive) of that vector argument.
-With one argument, just copy STRING (with properties, if any). */)
+With one argument, just copy STRING (with properties, if any). */,
+(function ((or string vector) &optional integer integer) (or string vector)))
(Lisp_Object string, Lisp_Object from, Lisp_Object to)
{
Lisp_Object res;
@@ -1738,7 +1764,8 @@ Otherwise, return LIST after truncating it. */)
}
DEFUN ("nthcdr", Fnthcdr, Snthcdr, 2, 2, 0,
- doc: /* Take cdr N times on LIST, return the result. */)
+ doc: /* Take cdr N times on LIST, return the result. */,
+(function (integer t) t))
(Lisp_Object n, Lisp_Object list)
{
Lisp_Object tail = list;
@@ -1832,14 +1859,16 @@ DEFUN ("nthcdr", Fnthcdr, Snthcdr, 2, 2, 0,
DEFUN ("nth", Fnth, Snth, 2, 2, 0,
doc: /* Return the Nth element of LIST.
-N counts from zero. If LIST is not that long, nil is returned. */)
+N counts from zero. If LIST is not that long, nil is returned. */,
+(function (integer list) t))
(Lisp_Object n, Lisp_Object list)
{
return Fcar (Fnthcdr (n, list));
}
DEFUN ("elt", Felt, Selt, 2, 2, 0,
- doc: /* Return element of SEQUENCE at index N. */)
+ doc: /* Return element of SEQUENCE at index N. */,
+(function (sequence integer) t))
(Lisp_Object sequence, Lisp_Object n)
{
if (CONSP (sequence) || NILP (sequence))
@@ -1883,7 +1912,8 @@ eq_comparable_value (Lisp_Object x)
DEFUN ("member", Fmember, Smember, 2, 2, 0,
doc: /* Return non-nil if ELT is an element of LIST. Comparison done
with `equal'.
-The value is actually the tail of LIST whose car is ELT. */)
+The value is actually the tail of LIST whose car is ELT. */,
+(function (t list) list))
(Lisp_Object elt, Lisp_Object list)
{
if (eq_comparable_value (elt))
@@ -1898,7 +1928,8 @@ The value is actually the tail of LIST whose car is ELT.
*/)
DEFUN ("memq", Fmemq, Smemq, 2, 2, 0,
doc: /* Return non-nil if ELT is an element of LIST. Comparison done
with `eq'.
-The value is actually the tail of LIST whose car is ELT. */)
+The value is actually the tail of LIST whose car is ELT. */,
+(function (t list) list))
(Lisp_Object elt, Lisp_Object list)
{
Lisp_Object tail = list;
@@ -1911,7 +1942,8 @@ The value is actually the tail of LIST whose car is ELT.
*/)
DEFUN ("memql", Fmemql, Smemql, 2, 2, 0,
doc: /* Return non-nil if ELT is an element of LIST. Comparison done
with `eql'.
-The value is actually the tail of LIST whose car is ELT. */)
+The value is actually the tail of LIST whose car is ELT. */,
+(function (t list) list))
(Lisp_Object elt, Lisp_Object list)
{
Lisp_Object tail = list;
@@ -1945,7 +1977,8 @@ The value is actually the tail of LIST whose car is ELT.
*/)
DEFUN ("assq", Fassq, Sassq, 2, 2, 0,
doc: /* Return non-nil if KEY is `eq' to the car of an element of ALIST.
The value is actually the first element of ALIST whose car is KEY.
-Elements of ALIST that are not conses are ignored. */)
+Elements of ALIST that are not conses are ignored. */,
+(function (t list) list))
(Lisp_Object key, Lisp_Object alist)
{
Lisp_Object tail = alist;
@@ -2026,7 +2059,8 @@ assoc_no_quit (Lisp_Object key, Lisp_Object alist)
DEFUN ("rassq", Frassq, Srassq, 2, 2, 0,
doc: /* Return non-nil if KEY is `eq' to the cdr of an element of ALIST.
-The value is actually the first element of ALIST whose cdr is KEY. */)
+The value is actually the first element of ALIST whose cdr is KEY. */,
+(function (t list) list))
(Lisp_Object key, Lisp_Object alist)
{
Lisp_Object tail = alist;
@@ -2039,7 +2073,8 @@ The value is actually the first element of ALIST whose
cdr is KEY. */)
DEFUN ("rassoc", Frassoc, Srassoc, 2, 2, 0,
doc: /* Return non-nil if KEY is `equal' to the cdr of an element of
ALIST.
-The value is actually the first element of ALIST whose cdr equals KEY. */)
+The value is actually the first element of ALIST whose cdr equals KEY. */,
+(function (t list) list))
(Lisp_Object key, Lisp_Object alist)
{
if (eq_comparable_value (key))
@@ -2274,7 +2309,8 @@ This function may destructively modify SEQ to produce the
value. */)
DEFUN ("reverse", Freverse, Sreverse, 1, 1, 0,
doc: /* Return the reversed copy of list, vector, or string SEQ.
-See also the function `nreverse', which is used more often. */)
+See also the function `nreverse', which is used more often. */,
+(function (sequence) sequence))
(Lisp_Object seq)
{
Lisp_Object new;
@@ -2508,7 +2544,8 @@ This function returns the value corresponding to the
given PROP, or
nil if PROP is not one of the properties on the list. The comparison
with PROP is done using PREDICATE, which defaults to `eq'.
-This function doesn't signal an error if PLIST is invalid. */)
+This function doesn't signal an error if PLIST is invalid. */,
+(function (list t &optional t) t))
(Lisp_Object plist, Lisp_Object prop, Lisp_Object predicate)
{
if (NILP (predicate))
@@ -2545,7 +2582,8 @@ plist_get (Lisp_Object plist, Lisp_Object prop)
DEFUN ("get", Fget, Sget, 2, 2, 0,
doc: /* Return the value of SYMBOL's PROPNAME property.
-This is the last value stored with `(put SYMBOL PROPNAME VALUE)'. */)
+This is the last value stored with `(put SYMBOL PROPNAME VALUE)'. */,
+(function (symbol symbol) t))
(Lisp_Object symbol, Lisp_Object propname)
{
CHECK_SYMBOL (symbol);
@@ -2645,7 +2683,8 @@ The comparison with PROP is done using PREDICATE, which
defaults to
Unlike `plist-get', this allows you to distinguish between a missing
property and a property with the value nil.
-The value is actually the tail of PLIST whose car is PROP. */)
+The value is actually the tail of PLIST whose car is PROP. */,
+(function (list t &optional t) list))
(Lisp_Object plist, Lisp_Object prop, Lisp_Object predicate)
{
if (NILP (predicate))
@@ -2685,7 +2724,8 @@ DEFUN ("eql", Feql, Seql, 2, 2, 0,
Integers with the same value are `eql'.
Floating-point values with the same sign, exponent and fraction are `eql'.
This differs from numeric comparison: (eql 0.0 -0.0) returns nil and
-\(eql 0.0e+NaN 0.0e+NaN) returns t, whereas `=' does the opposite. */)
+\(eql 0.0e+NaN 0.0e+NaN) returns t, whereas `=' does the opposite. */,
+(function (t t) boolean))
(Lisp_Object obj1, Lisp_Object obj2)
{
if (FLOATP (obj1))
@@ -2705,7 +2745,8 @@ Conses are compared by comparing the cars and the cdrs.
Vectors and strings are compared element by element.
Numbers are compared via `eql', so integers do not equal floats.
\(Use `=' if you want integers and floats to be able to be equal.)
-Symbols must match exactly. */)
+Symbols must match exactly. */,
+(function (t t) boolean))
(Lisp_Object o1, Lisp_Object o2)
{
return internal_equal (o1, o2, EQUAL_PLAIN, 0, Qnil) ? Qt : Qnil;
@@ -3330,7 +3371,8 @@ Use this to conditionalize execution of lisp code based
on the
presence or absence of Emacs or environment extensions.
Use `provide' to declare that a feature is available. This function
looks at the value of the variable `features'. The optional argument
-SUBFEATURE can be used to check a specific subfeature of FEATURE. */)
+SUBFEATURE can be used to check a specific subfeature of FEATURE. */,
+(function (symbol &optional symbol) boolean))
(Lisp_Object feature, Lisp_Object subfeature)
{
register Lisp_Object tem;
@@ -3571,7 +3613,8 @@ If the system can't provide such information through a
call to
See also Info node `(libc)Locales'.
-The data read from the system are decoded using `locale-coding-system'. */)
+The data read from the system are decoded using `locale-coding-system'. */,
+(function ((member codeset days months paper)) (or null string)))
(Lisp_Object item)
{
char *str = NULL;
@@ -5321,7 +5364,8 @@ DEFUN ("sxhash-eq", Fsxhash_eq, Ssxhash_eq, 1, 1, 0,
doc: /* Return an integer hash code for OBJ suitable for `eq'.
If (eq A B), then (= (sxhash-eq A) (sxhash-eq B)).
-Hash codes are not guaranteed to be preserved across Emacs sessions. */)
+Hash codes are not guaranteed to be preserved across Emacs sessions. */,
+(function (t) integer))
(Lisp_Object obj)
{
return reduce_emacs_uint_to_fixnum (sxhash_eq (obj));
@@ -5332,7 +5376,8 @@ DEFUN ("sxhash-eql", Fsxhash_eql, Ssxhash_eql, 1, 1, 0,
If (eql A B), then (= (sxhash-eql A) (sxhash-eql B)), but the opposite
isn't necessarily true.
-Hash codes are not guaranteed to be preserved across Emacs sessions. */)
+Hash codes are not guaranteed to be preserved across Emacs sessions. */,
+(function (t) integer))
(Lisp_Object obj)
{
return reduce_emacs_uint_to_fixnum (sxhash_eql (obj));
@@ -5343,7 +5388,9 @@ DEFUN ("sxhash-equal", Fsxhash_equal, Ssxhash_equal, 1,
1, 0,
If (equal A B), then (= (sxhash-equal A) (sxhash-equal B)), but the
opposite isn't necessarily true.
-Hash codes are not guaranteed to be preserved across Emacs sessions. */)
+Hash codes are not guaranteed to be preserved across Emacs sessions. */,
+(function (t) integer),
+(function (t) integer))
(Lisp_Object obj)
{
return reduce_emacs_uint_to_fixnum (sxhash (obj));
@@ -5530,7 +5577,8 @@ DEFUN ("copy-hash-table", Fcopy_hash_table,
Scopy_hash_table, 1, 1, 0,
DEFUN ("hash-table-count", Fhash_table_count, Shash_table_count, 1, 1, 0,
- doc: /* Return the number of elements in TABLE. */)
+ doc: /* Return the number of elements in TABLE. */,
+(function (hash-table) integer))
(Lisp_Object table)
{
struct Lisp_Hash_Table *h = check_hash_table (table);
@@ -5609,7 +5657,8 @@ DEFUN ("hash-table-weakness", Fhash_table_weakness,
Shash_table_weakness,
DEFUN ("hash-table-p", Fhash_table_p, Shash_table_p, 1, 1, 0,
- doc: /* Return t if OBJ is a Lisp hash table object. */)
+ doc: /* Return t if OBJ is a Lisp hash table object. */,
+(function (t) boolean))
(Lisp_Object obj)
{
return HASH_TABLE_P (obj) ? Qt : Qnil;
@@ -5630,7 +5679,8 @@ DEFUN ("clrhash", Fclrhash, Sclrhash, 1, 1, 0,
DEFUN ("gethash", Fgethash, Sgethash, 2, 3, 0,
doc: /* Look up KEY in TABLE and return its associated value.
-If KEY is not found, return DFLT which defaults to nil. */)
+If KEY is not found, return DFLT which defaults to nil. */,
+(function (t hash-table &optional t) t))
(Lisp_Object key, Lisp_Object table, Lisp_Object dflt)
{
struct Lisp_Hash_Table *h = check_hash_table (table);
@@ -6262,7 +6312,8 @@ The optional START-POS argument says where to start
searching in
HAYSTACK and defaults to zero (start at the beginning).
It must be between zero and the length of HAYSTACK, inclusive.
-Case is always significant and text properties are ignored. */)
+Case is always significant and text properties are ignored. */,
+(function (string string &optional integer) (or integer null)))
(register Lisp_Object needle, Lisp_Object haystack, Lisp_Object start_pos)
{
ptrdiff_t start_byte = 0, haybytes;
diff --git a/src/frame.c b/src/frame.c
index abd6ef00901..f1d6eedaa62 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -229,7 +229,8 @@ Value is:
`pgtk' for an Emacs frame running on pure GTK.
`haiku' for an Emacs frame running in Haiku.
`android' for an Emacs frame running in Android.
-See also `frame-live-p'. */)
+See also `frame-live-p'. */,
+(function (t) symbol))
(Lisp_Object object)
{
if (!FRAMEP (object))
@@ -1656,7 +1657,8 @@ necessarily represent user-visible input focus. */)
}
DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
- doc: /* Return the frame that is now selected. */)
+ doc: /* Return the frame that is now selected. */,
+(function () frame))
(void)
{
return selected_frame;
@@ -2970,7 +2972,8 @@ usually not displayed at all, even in a window system's
\"taskbar\".
If FRAME is a text terminal frame, this always returns t.
Such frames are always considered visible, whether or not they are
-currently being displayed on the terminal. */)
+currently being displayed on the terminal. */,
+(function (frame) (or boolean (member icon))))
(Lisp_Object frame)
{
CHECK_LIVE_FRAME (frame);
@@ -2984,7 +2987,8 @@ currently being displayed on the terminal. */)
DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
0, 0, 0,
- doc: /* Return a list of all frames now \"visible\" (being updated).
*/)
+ doc: /* Return a list of all frames now \"visible\" (being updated).
*/,
+(function () list))
(void)
{
Lisp_Object tail, frame, value = Qnil;
diff --git a/src/indent.c b/src/indent.c
index 3094a9d3089..d31cd9677ba 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -938,7 +938,8 @@ DEFUN ("current-indentation", Fcurrent_indentation,
Scurrent_indentation,
This is the horizontal position of the character following any initial
whitespace.
Text that has an invisible property is considered as having width 0, unless
-`buffer-invisibility-spec' specifies that it is replaced by an ellipsis. */)
+`buffer-invisibility-spec' specifies that it is replaced by an ellipsis. */,
+(function () integer))
(void)
{
ptrdiff_t posbyte;
diff --git a/src/keyboard.c b/src/keyboard.c
index 4b5e20fb24c..cd86431becc 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -11666,7 +11666,8 @@ The saved keystrokes are shown by `view-lossage'. */)
DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 1, 0,
doc: /* Return vector of last few events, not counting those from
keyboard macros.
If INCLUDE-CMDS is non-nil, include the commands that were run,
-represented as pseudo-events of the form (nil . COMMAND). */)
+represented as pseudo-events of the form (nil . COMMAND). */,
+(function (&optional (or cons null)) vector))
(Lisp_Object include_cmds)
{
bool cmds = !NILP (include_cmds);
@@ -11700,7 +11701,8 @@ However, if the command has called `read-key-sequence',
it returns
the last key sequence that has been read.
The value is a string or a vector.
-See also `this-command-keys-vector'. */)
+See also `this-command-keys-vector'. */,
+(function () string))
(void)
{
return make_event_array (this_command_key_count,
@@ -11745,7 +11747,8 @@ DEFUN ("this-command-keys-vector",
Fthis_command_keys_vector, Sthis_command_keys
However, if the command has called `read-key-sequence', it returns
the last key sequence that has been read.
-See also `this-command-keys'. */)
+See also `this-command-keys'. */,
+(function () vector))
(void)
{
return Fvector (this_command_key_count,
@@ -11757,7 +11760,8 @@ DEFUN ("this-single-command-keys",
Fthis_single_command_keys,
doc: /* Return the key sequence that invoked this command.
More generally, it returns the last key sequence read, either by
the command loop or by `read-key-sequence'.
-The value is always a vector. */)
+The value is always a vector. */,
+(function () vector))
(void)
{
ptrdiff_t nkeys = this_command_key_count - this_single_command_key_start;
@@ -11773,7 +11777,8 @@ More generally, it returns the last key sequence read,
either by
the command loop or by `read-key-sequence'.
Unlike `this-single-command-keys', this function's value
shows the events before all translations (except for input methods).
-The value is always a vector. */)
+The value is always a vector. */,
+(function () vector))
(void)
{
return Fvector (raw_keybuf_count, XVECTOR (raw_keybuf)->contents);
@@ -11801,7 +11806,8 @@ KEEP-RECORD is non-nil. */)
}
DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0,
- doc: /* Return the current depth in recursive edits. */)
+ doc: /* Return the current depth in recursive edits. */,
+(function () integer))
(void)
{
EMACS_INT sum;
diff --git a/src/keymap.c b/src/keymap.c
index 10378767c65..d10421d3b7d 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -142,7 +142,8 @@ A keymap is a list (keymap . ALIST),
or a symbol whose function definition is itself a keymap.
ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
a vector of densely packed bindings for small character codes
-is also allowed as an element. */)
+is also allowed as an element. */,
+(function (t) boolean))
(Lisp_Object object)
{
return (KEYMAPP (object) ? Qt : Qnil);
@@ -255,7 +256,8 @@ keymap_parent (Lisp_Object keymap, bool autoload)
DEFUN ("keymap-parent", Fkeymap_parent, Skeymap_parent, 1, 1, 0,
doc: /* Return the parent keymap of KEYMAP.
-If KEYMAP has no parent, return nil. */)
+If KEYMAP has no parent, return nil. */,
+(function (cons) (or cons null)))
(Lisp_Object keymap)
{
return keymap_parent (keymap, 1);
@@ -1906,21 +1908,24 @@ If KEYMAP is nil, that means no local keymap. */)
DEFUN ("current-local-map", Fcurrent_local_map, Scurrent_local_map, 0, 0, 0,
doc: /* Return current buffer's local keymap, or nil if it has none.
-Normally the local keymap is set by the major mode with `use-local-map'. */)
+Normally the local keymap is set by the major mode with `use-local-map'. */,
+(function () (or cons null)))
(void)
{
return BVAR (current_buffer, keymap);
}
DEFUN ("current-global-map", Fcurrent_global_map, Scurrent_global_map, 0, 0, 0,
- doc: /* Return the current global keymap. */)
+ doc: /* Return the current global keymap. */,
+(function () cons))
(void)
{
return current_global_map;
}
DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps,
Scurrent_minor_mode_maps, 0, 0, 0,
- doc: /* Return a list of keymaps for the minor modes of the current
buffer. */)
+ doc: /* Return a list of keymaps for the minor modes of the current
buffer. */,
+(function () (or cons null)))
(void)
{
Lisp_Object *maps;
diff --git a/src/lread.c b/src/lread.c
index c11c641440d..788e5f4998b 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -2774,7 +2774,8 @@ FINAL-STRING-INDEX is an integer giving the position of
the next
remaining character in STRING. START and END optionally delimit
a substring of STRING from which to read; they default to 0 and
\(length STRING) respectively. Negative values are counted from
-the end of STRING. */)
+the end of STRING. */,
+(function (string &optional integer integer) cons))
(Lisp_Object string, Lisp_Object start, Lisp_Object end)
{
Lisp_Object ret;
@@ -5035,7 +5036,8 @@ DEFUN ("intern-soft", Fintern_soft, Sintern_soft, 1, 2, 0,
NAME may be a string or a symbol. If it is a symbol, that exact
symbol is searched for.
A second optional argument specifies the obarray to use;
-it defaults to the value of `obarray'. */)
+it defaults to the value of `obarray'. */,
+(function ((or string symbol) &optional vector) symbol))
(Lisp_Object name, Lisp_Object obarray)
{
register Lisp_Object tem, string;
diff --git a/src/marker.c b/src/marker.c
index 1559dd52719..11ab273725e 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -434,7 +434,8 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
DEFUN ("marker-buffer", Fmarker_buffer, Smarker_buffer, 1, 1, 0,
doc: /* Return the buffer that MARKER points into, or nil if none.
-Returns nil if MARKER points into a dead buffer. */)
+Returns nil if MARKER points into a dead buffer. */,
+(function (marker) (or buffer null)))
(register Lisp_Object marker)
{
register Lisp_Object buf;
@@ -752,7 +753,8 @@ If argument is a number, makes a new marker pointing
at that position in the current buffer.
If MARKER is not specified, the new marker does not point anywhere.
The optional argument TYPE specifies the insertion type of the new marker;
-see `marker-insertion-type'. */)
+see `marker-insertion-type'. */,
+(function (&optional (or integer marker) boolean) marker))
(register Lisp_Object marker, Lisp_Object type)
{
register Lisp_Object new;
diff --git a/src/print.c b/src/print.c
index e2252562915..7ef88014f97 100644
--- a/src/print.c
+++ b/src/print.c
@@ -794,7 +794,8 @@ a list, a buffer, a window, a frame, etc.
See `prin1' for the meaning of OVERRIDES.
-A printed representation of an object is text which describes that object. */)
+A printed representation of an object is text which describes that object. */,
+(function (t &optional t t) string))
(Lisp_Object object, Lisp_Object noescape, Lisp_Object overrides)
{
specpdl_ref count = SPECPDL_INDEX ();
@@ -1020,7 +1021,8 @@ DEFUN ("error-message-string", Ferror_message_string,
Serror_message_string,
1, 1, 0,
doc: /* Convert an error value (ERROR-SYMBOL . DATA) to an error
message.
See Info anchor `(elisp)Definition of signal' for some details on how this
-error message is constructed. */)
+error message is constructed. */,
+(function (list) string))
(Lisp_Object obj)
{
struct buffer *old = current_buffer;
diff --git a/src/process.c b/src/process.c
index 48a2c0c8e53..410e05a3032 100644
--- a/src/process.c
+++ b/src/process.c
@@ -999,7 +999,8 @@ free_dns_request (Lisp_Object proc)
DEFUN ("processp", Fprocessp, Sprocessp, 1, 1, 0,
- doc: /* Return t if OBJECT is a process. */)
+ doc: /* Return t if OBJECT is a process. */,
+(function (t) boolean))
(Lisp_Object object)
{
return PROCESSP (object) ? Qt : Qnil;
diff --git a/src/search.c b/src/search.c
index f2d1f1f5449..a433ab5de1d 100644
--- a/src/search.c
+++ b/src/search.c
@@ -3185,7 +3185,8 @@ record_unwind_save_match_data (void)
/* Quote a string to deactivate reg-expr chars */
DEFUN ("regexp-quote", Fregexp_quote, Sregexp_quote, 1, 1, 0,
- doc: /* Return a regexp string which matches exactly STRING and nothing
else. */)
+ doc: /* Return a regexp string which matches exactly STRING and nothing
else. */,
+(function (string) string))
(Lisp_Object string)
{
char *in, *out, *end;
diff --git a/src/syntax.c b/src/syntax.c
index a4ad61328e6..0ba8764b466 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -968,7 +968,8 @@ back_comment (ptrdiff_t from, ptrdiff_t from_byte,
ptrdiff_t stop,
DEFUN ("syntax-table-p", Fsyntax_table_p, Ssyntax_table_p, 1, 1, 0,
doc: /* Return t if OBJECT is a syntax table.
-Currently, any char-table counts as a syntax table. */)
+Currently, any char-table counts as a syntax table. */,
+(function (t) boolean))
(Lisp_Object object)
{
if (CHAR_TABLE_P (object)
@@ -986,7 +987,8 @@ check_syntax_table (Lisp_Object obj)
DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 0, 0,
doc: /* Return the current syntax table.
-This is the one specified by the current buffer. */)
+This is the one specified by the current buffer. */,
+(function () char-table))
(void)
{
return BVAR (current_buffer, syntax_table);
@@ -995,7 +997,8 @@ This is the one specified by the current buffer. */)
DEFUN ("standard-syntax-table", Fstandard_syntax_table,
Sstandard_syntax_table, 0, 0, 0,
doc: /* Return the standard syntax table.
-This is the one used for new buffers. */)
+This is the one used for new buffers. */,
+(function () char-table))
(void)
{
return Vstandard_syntax_table;
@@ -1138,7 +1141,8 @@ DEFUN ("string-to-syntax", Fstring_to_syntax,
Sstring_to_syntax, 1, 1, 0,
STRING should be a string of the form allowed as argument of
`modify-syntax-entry'. The return value is a raw syntax descriptor: a
cons cell (CODE . MATCHING-CHAR) which can be used, for example, as
-the value of a `syntax-table' text property. */)
+the value of a `syntax-table' text property. */,
+(function (string) (or cons null)))
(Lisp_Object string)
{
const unsigned char *p;
diff --git a/src/timefns.c b/src/timefns.c
index 0ecbb6e6793..39ba988c6d5 100644
--- a/src/timefns.c
+++ b/src/timefns.c
@@ -1282,7 +1282,8 @@ forms of a time value.
WARNING: Since the result is floating point, it may not be exact.
If precise time stamps are required, use either `time-convert',
-or (if you need time as a string) `format-time-string'. */)
+or (if you need time as a string) `format-time-string'. */,
+(function (&optional (or number list)) float))
(Lisp_Object specified_time)
{
return (FLOATP (specified_time) ? specified_time
@@ -1462,7 +1463,10 @@ The modifiers are:
For example, to produce full ISO 8601 format, use "%FT%T%z".
-usage: (format-time-string FORMAT-STRING &optional TIME ZONE) */)
+usage: (format-time-string FORMAT-STRING &optional TIME ZONE) */,
+(function (string &optional (or number list)
+ (or symbol string cons integer))
+ string))
(Lisp_Object format_string, Lisp_Object timeval, Lisp_Object zone)
{
struct timespec t = lisp_time_argument (timeval);
@@ -1511,7 +1515,11 @@ seconds, i.e., the number of seconds east of Greenwich.
(Note that
Common Lisp has different meanings for DOW and UTCOFF, and its
SEC is always an integer between 0 and 59.)
-usage: (decode-time &optional TIME ZONE FORM) */)
+usage: (decode-time &optional TIME ZONE FORM) */,
+(function (&optional (or number list)
+ (or symbol string cons integer)
+ symbol)
+ cons))
(Lisp_Object specified_time, Lisp_Object zone, Lisp_Object form)
{
/* Compute broken-down local time LOCAL_TM from SPECIFIED_TIME and ZONE. */
@@ -1646,7 +1654,8 @@ Out-of-range values for SECOND through MONTH are brought
into range
via date arithmetic. This can be tricky especially when combined with
DST; see Info node `(elisp)Time Conversion' for details and caveats.
-usage: (encode-time TIME &rest OBSOLESCENT-ARGUMENTS) */)
+usage: (encode-time TIME &rest OBSOLESCENT-ARGUMENTS) */,
+(function (cons &rest t) cons))
(ptrdiff_t nargs, Lisp_Object *args)
{
struct tm tm;
@@ -1758,7 +1767,9 @@ significant 16 bits, and USEC and PSEC are the
microsecond and
picosecond counts.
If FORM is nil, the behavior depends on `current-time-list',
-but new code should not rely on it. */)
+but new code should not rely on it. */,
+(function ((or number list) &optional (or symbol integer))
+ (or cons number)))
(Lisp_Object time, Lisp_Object form)
{
/* FIXME: Any reason why we don't offer a `float` output format option as
@@ -1789,7 +1800,8 @@ significant bits of the seconds, LOW has the least
significant 16
bits, and USEC and PSEC are the microsecond and picosecond counts.
You can use `time-convert' to get a particular timestamp form
-regardless of the value of `current-time-list'. */)
+regardless of the value of `current-time-list'. */,
+(function () cons))
(void)
{
return make_lisp_time (current_timespec ());
@@ -1825,7 +1837,10 @@ The optional ZONE is omitted or nil for Emacs local
time, t for
Universal Time, `wall' for system wall clock time, or a string as in
the TZ environment variable. It can also be a list (as from
`current-time-zone') or an integer (as from `decode-time') applied
-without consideration for daylight saving time. */)
+without consideration for daylight saving time. */,
+(function (&optional (or number list)
+ (or symbol string cons integer))
+ string))
(Lisp_Object specified_time, Lisp_Object zone)
{
time_t value = lisp_seconds_argument (specified_time);
@@ -1876,7 +1891,10 @@ without consideration for daylight saving time.
Some operating systems cannot provide all this information to Emacs;
in this case, `current-time-zone' returns a list containing nil for
-the data it can't find. */)
+the data it can't find. */,
+(function (&optional (or number list)
+ (or symbol string cons integer))
+ cons))
(Lisp_Object specified_time, Lisp_Object zone)
{
struct timespec value;
diff --git a/src/window.c b/src/window.c
index 565ad00804f..f724e316942 100644
--- a/src/window.c
+++ b/src/window.c
@@ -311,7 +311,8 @@ wset_old_buffer (struct window *w, Lisp_Object val)
}
DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
- doc: /* Return t if OBJECT is a window and nil otherwise. */)
+ doc: /* Return t if OBJECT is a window and nil otherwise. */,
+(function (t) boolean))
(Lisp_Object object)
{
return WINDOWP (object) ? Qt : Qnil;
@@ -320,7 +321,8 @@ DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
DEFUN ("window-valid-p", Fwindow_valid_p, Swindow_valid_p, 1, 1, 0,
doc: /* Return t if OBJECT is a valid window and nil otherwise.
A valid window is either a window that displays a buffer or an internal
-window. Windows that have been deleted are not valid. */)
+window. Windows that have been deleted are not valid. */,
+(function (t) boolean))
(Lisp_Object object)
{
return WINDOW_VALID_P (object) ? Qt : Qnil;
@@ -329,7 +331,8 @@ window. Windows that have been deleted are not valid. */)
DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0,
doc: /* Return t if OBJECT is a live window and nil otherwise.
A live window is a window that displays a buffer.
-Internal windows and deleted windows are not live. */)
+Internal windows and deleted windows are not live. */,
+(function (t) boolean))
(Lisp_Object object)
{
return WINDOW_LIVE_P (object) ? Qt : Qnil;
@@ -348,7 +351,8 @@ DEFUN ("frame-root-window", Fframe_root_window,
Sframe_root_window, 0, 1, 0,
doc: /* Return the root window of FRAME-OR-WINDOW.
If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
With a frame argument, return that frame's root window.
-With a window argument, return the root window of that window's frame. */)
+With a window argument, return the root window of that window's frame. */,
+(function (&optional (or frame window)) window))
(Lisp_Object frame_or_window)
{
Lisp_Object window;
@@ -368,7 +372,8 @@ With a window argument, return the root window of that
window's frame. */)
DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0,
doc: /* Return the minibuffer window for frame FRAME.
-If FRAME is omitted or nil, it defaults to the selected frame. */)
+If FRAME is omitted or nil, it defaults to the selected frame. */,
+(function (&optional frame) window))
(Lisp_Object frame)
{
return FRAME_MINIBUF_WINDOW (decode_live_frame (frame));
@@ -389,7 +394,8 @@ DEFUN ("frame-first-window", Fframe_first_window,
Sframe_first_window, 0, 1, 0,
If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
Else if FRAME-OR-WINDOW denotes a valid window, return the first window
of that window's frame. If FRAME-OR-WINDOW denotes a live frame, return
-the first window of that frame. */)
+the first window of that frame. */,
+(function ((or frame window)) window))
(Lisp_Object frame_or_window)
{
Lisp_Object window;
@@ -416,7 +422,8 @@ DEFUN ("frame-selected-window", Fframe_selected_window,
If omitted, FRAME-OR-WINDOW defaults to the currently selected frame.
Else if FRAME-OR-WINDOW denotes a valid window, return the selected
window of that window's frame. If FRAME-OR-WINDOW denotes a live frame,
-return the selected window of that frame. */)
+return the selected window of that frame. */,
+(function (&optional (or frame window)) window))
(Lisp_Object frame_or_window)
{
Lisp_Object window;
@@ -484,7 +491,8 @@ DEFUN ("selected-window", Fselected_window,
Sselected_window, 0, 0, 0,
The selected window is the window in which the standard cursor for
selected windows appears and to which many commands apply.
-Also see `old-selected-window' and `minibuffer-selected-window'. */)
+Also see `old-selected-window' and `minibuffer-selected-window'. */,
+(function () window))
(void)
{
return selected_window;
@@ -1553,7 +1561,12 @@ If they are in the right fringe of WINDOW,
`right-fringe' is returned.
If they are on the border between WINDOW and its right sibling,
`vertical-line' is returned.
If they are in the windows's left or right marginal areas, `left-margin'\n\
- or `right-margin' is returned. */)
+ or `right-margin' is returned. */,
+(function (cons window)
+ (or cons null
+ (member bottom-divider
right-divider mode-line header-line
+ tab-line left-fringe
right-fringe vertical-line
+ left-margin right-margin))))
(register Lisp_Object coordinates, Lisp_Object window)
{
struct window *w;
@@ -2922,7 +2935,8 @@ others.
If you use consistent values for MINIBUF and ALL-FRAMES, you can use
`next-window' to iterate through the entire cycle of acceptable
windows, eventually ending up back at the window you started with.
-`previous-window' traverses the same cycle, in the reverse order. */)
+`previous-window' traverses the same cycle, in the reverse order. */,
+(function (&optional window t t) window))
(Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
{
return next_window (window, minibuf, all_frames, true);
@@ -2962,7 +2976,8 @@ If you use consistent values for MINIBUF and ALL-FRAMES,
you can
use `previous-window' to iterate through the entire cycle of
acceptable windows, eventually ending up back at the window you
started with. `next-window' traverses the same cycle, in the
-reverse order. */)
+reverse order. */,
+(function (&optional window t t) window))
(Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
{
return next_window (window, minibuf, all_frames, false);
@@ -3243,7 +3258,9 @@ The optional argument ALL-FRAMES specifies the frames to
consider:
- A frame means consider all windows on that frame only.
Any other value of ALL-FRAMES means consider all windows on the
-selected frame and no others. */)
+selected frame and no others. */,
+(function (&optional (or buffer string) (or symbol (integer 0 0)))
+ (or null window)))
(Lisp_Object buffer_or_name, Lisp_Object all_frames)
{
Lisp_Object buffer;
@@ -6596,7 +6613,8 @@ by this function. This happens in an interactive call.
*/)
DEFUN ("minibuffer-selected-window", Fminibuffer_selected_window,
Sminibuffer_selected_window, 0, 0, 0,
doc: /* Return window selected just before minibuffer window was
selected.
-Return nil if the selected window is not a minibuffer window. */)
+Return nil if the selected window is not a minibuffer window. */,
+(function () (or window null)))
(void)
{
if (minibuf_level > 0
@@ -7070,7 +7088,8 @@ struct saved_window
((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
DEFUN ("window-configuration-p", Fwindow_configuration_p,
Swindow_configuration_p, 1, 1, 0,
- doc: /* Return t if OBJECT is a window-configuration object. */)
+ doc: /* Return t if OBJECT is a window-configuration object. */,
+(function (t) boolean))
(Lisp_Object object)
{
return WINDOW_CONFIGURATIONP (object) ? Qt : Qnil;