commit: Use Common Lisp-derived builtins in a few more places in core Lisp.
13 years, 1 month
Aidan Kehoe
Aidan Kehoe
changeset: 5367:8b70d37ab80e
tag: tip
user: Aidan Kehoe <kehoea(a)parhasard.net>
date: Tue Mar 08 23:57:21 2011 +0000
files: lisp/ChangeLog lisp/cl-macs.el lisp/etags.el lisp/frame.el
description:
Use Common Lisp-derived builtins in a few more places in core Lisp.
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* cl-macs.el:
* cl-macs.el (loop):
* cl-macs.el (cl-expand-do-loop):
* cl-macs.el (shiftf):
* cl-macs.el (rotatef):
* cl-macs.el (assert):
* cl-macs.el (cl-defsubst-expand):
* etags.el (buffer-tag-table-list):
* frame.el:
* frame.el (frame-notice-user-settings):
* frame.el (minibuffer-frame-list):
* frame.el (get-frame-for-buffer-noselect):
Use Common Lisp-derived builtins in a few more places, none of
them performance-critical, but the style is better.
diff -r f00192e1cd49 -r 8b70d37ab80e lisp/ChangeLog
--- a/lisp/ChangeLog Tue Mar 08 23:41:52 2011 +0000
+++ b/lisp/ChangeLog Tue Mar 08 23:57:21 2011 +0000
＠＠ -1,3 +1,20 ＠＠
+2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * cl-macs.el:
+ * cl-macs.el (loop):
+ * cl-macs.el (cl-expand-do-loop):
+ * cl-macs.el (shiftf):
+ * cl-macs.el (rotatef):
+ * cl-macs.el (assert):
+ * cl-macs.el (cl-defsubst-expand):
+ * etags.el (buffer-tag-table-list):
+ * frame.el:
+ * frame.el (frame-notice-user-settings):
+ * frame.el (minibuffer-frame-list):
+ * frame.el (get-frame-for-buffer-noselect):
+ Use Common Lisp-derived builtins in a few more places, none of
+ them performance-critical, but the style is better.
+
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* buff-menu.el (list-buffers-noselect):
diff -r f00192e1cd49 -r 8b70d37ab80e lisp/cl-macs.el
--- a/lisp/cl-macs.el Tue Mar 08 23:41:52 2011 +0000
+++ b/lisp/cl-macs.el Tue Mar 08 23:57:21 2011 +0000
＠＠ -1066,7 +1066,7 ＠＠
Specify the name for block surrounding the loop, in place of nil.
(See `block'.)
"
- (if (not (memq t (mapcar 'symbolp (delq nil (delq t (copy-list clauses))))))
+ (if (notany #'symbolp (set-difference clauses '(nil t)))
(list 'block nil (list* 'while t clauses))
(let ((loop-name nil) (loop-bindings nil)
(loop-body nil) (loop-steps nil)
＠＠ -1648,12 +1648,12 ＠＠
steps)
(list* 'while (list 'not (car endtest))
(append body
- (let ((sets (mapcar
+ (let ((sets (mapcan
#'(lambda (c)
(and (consp c) (cdr (cdr c))
- (list (car c) (nth 2 c))))
+ (list
+ (list (car c) (nth 2 c)))))
steps)))
- (setq sets (delq nil sets))
(and sets
(list (cons (if (or star (not (cdr sets)))
'setq 'psetq)
＠＠ -2579,7 +2579,7 ＠＠
Example: (shiftf A B C) sets A to B, B to C, and returns the old A.
Each PLACE may be a symbol, or any generalized variable allowed by `setf'."
;; XEmacs change: use iteration instead of recursion
- (if (not (memq nil (mapcar 'symbolp (butlast (cons place args)))))
+ (if (every #'symbolp (butlast (cons place args)))
(list* 'prog1 place
(let ((sets nil))
(while args
＠＠ -2600,7 +2600,7 ＠＠
"Rotate left among PLACES.
Example: (rotatef A B C) sets A to B, B to C, and C to A. It returns nil.
Each PLACE may be a symbol, or any generalized variable allowed by `setf'."
- (if (not (memq nil (mapcar 'symbolp places)))
+ (if (every #'symbolp places)
(and (cdr places)
(let ((sets nil)
(first (car places)))
＠＠ -3127,11 +3127,7 ＠＠
omitted, a default message listing FORM itself is used."
(and (or (not (cl-compiling-file))
(< cl-optimize-speed 3) (= cl-optimize-safety 3))
- (let ((sargs (and show-args (delq nil (mapcar
- #'(lambda (x)
- (and (not (cl-const-expr-p x))
- x))
- (cdr form))))))
+ (let ((sargs (and show-args (remove-if #'cl-const-expr-p (cdr form)))))
(list 'progn
(list 'or form
(if string
＠＠ -3226,13 +3222,12 ＠＠
(defun cl-defsubst-expand (argns body simple whole unsafe &rest argvs)
(if (and whole (not (cl-safe-expr-p (cons 'progn argvs)))) whole
(if (cl-simple-exprs-p argvs) (setq simple t))
- (let ((lets (delq nil
- (mapcar* #'(lambda (argn argv)
- (if (or simple (cl-const-expr-p argv))
- (progn (setq body (subst argv argn body))
- (and unsafe (list argn argv)))
- (list argn argv)))
- argns argvs))))
+ (let ((lets (mapcan #'(lambda (argn argv)
+ (if (or simple (cl-const-expr-p argv))
+ (progn (setq body (subst argv argn body))
+ (and unsafe (list (list argn argv))))
+ (list (list argn argv))))
+ argns argvs)))
(if lets (list 'let lets body) body))))
diff -r f00192e1cd49 -r 8b70d37ab80e lisp/etags.el
--- a/lisp/etags.el Tue Mar 08 23:41:52 2011 +0000
+++ b/lisp/etags.el Tue Mar 08 23:57:21 2011 +0000
＠＠ -243,16 +243,15 ＠＠
(push expression result)
(error "Expression in tag-table-alist evaluated to non-string")))))
(setq result
- (mapcar
+ (mapcan
(lambda (name)
(when (file-directory-p name)
(setq name (concat (file-name-as-directory name) "TAGS")))
(and (file-readable-p name)
;; get-tag-table-buffer has side-effects
- (symbol-value-in-buffer 'buffer-file-name
- (get-tag-table-buffer name))))
- result))
- (setq result (delq nil result))
+ (list (symbol-value-in-buffer 'buffer-file-name
+ (get-tag-table-buffer name))))))
+ result)
;; If no TAGS file has been found, ask the user explicitly.
;; #### tags-file-name is *evil*.
(or result tags-file-name
diff -r f00192e1cd49 -r 8b70d37ab80e lisp/frame.el
--- a/lisp/frame.el Tue Mar 08 23:41:52 2011 +0000
+++ b/lisp/frame.el Tue Mar 08 23:57:21 2011 +0000
＠＠ -475,12 +475,13 ＠＠
;; onto a new frame. The default-minibuffer-frame
;; variable must be handled similarly.
(let ((users-of-initial
- (filtered-frame-list
+ (remove-if-not
#'(lambda (frame)
(and (not (eq frame frame-initial-frame))
(eq (window-frame
(minibuffer-window frame))
- frame-initial-frame))))))
+ frame-initial-frame)))
+ (frame-list))))
(if (or users-of-initial
(eq default-minibuffer-frame frame-initial-frame))
＠＠ -488,10 +489,11 ＠＠
;; are only minibuffers.
(let* ((new-surrogate
(car
- (or (filtered-frame-list
+ (or (remove-if-not
#'(lambda (frame)
(eq 'only
- (frame-property frame 'minibuffer))))
+ (frame-property frame 'minibuffer)))
+ (frame-list))
(minibuffer-frame-list))))
(new-minibuffer (minibuffer-window new-surrogate)))
＠＠ -674,29 +676,22 ＠＠
;; XEmacs change: Emacs has make-frame here. We have it in C, so no need for
;; frame-creation-function.
-;; XEmacs addition: support optional DEVICE argument.
+;; XEmacs addition: support optional DEVICE argument, use delete-if-not.
(defun filtered-frame-list (predicate &optional device)
"Return a list of all live frames which satisfy PREDICATE.
If optional second arg DEVICE is non-nil, restrict the frames
returned to that device."
- (let ((frames (if device (device-frame-list device)
- (frame-list)))
- good-frames)
- (while (consp frames)
- (if (funcall predicate (car frames))
- (setq good-frames (cons (car frames) good-frames)))
- (setq frames (cdr frames)))
- good-frames))
+ (delete-if-not predicate
+ (if device (device-frame-list device) (frame-list))))
;; XEmacs addition: support optional DEVICE argument.
(defun minibuffer-frame-list (&optional device)
"Return a list of all frames with their own minibuffers.
If optional second arg DEVICE is non-nil, restrict the frames
returned to that device."
- (filtered-frame-list
- #'(lambda (frame)
- (eq frame (window-frame (minibuffer-window frame))))
- device))
+ (delete-if-not
+ #'(lambda (frame) (eq frame (window-frame (minibuffer-window frame))))
+ (if device (device-frame-list device) (frame-list))))
;; XEmacs omission: Emacs has frames-on-display-list here, but that is
;; essentially equivalent to supplying the optional DEVICE argument to
＠＠ -1745,9 +1740,10 ＠＠
(or (plist-get default-frame-plist 'name)
default-frame-name))
(frames
- (sort (filtered-frame-list #'(lambda (x)
- (or (frame-visible-p x)
- (frame-iconified-p x))))
+ (sort (remove-if-not #'(lambda (x)
+ (or (frame-visible-p x)
+ (frame-iconified-p x)))
+ (frame-list))
#'(lambda (s1 s2)
(cond ((and (frame-visible-p s1)
(not (frame-visible-p s2))))
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://lists.xemacs.org/mailman/listinfo/xemacs-patches
- 1 participants
- 0 comments
[COMMIT] Remove redundant functions, format.el, use functions from cl*.el instead.
13 years, 1 month
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed.
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1299623569 0
# Node ID dbae25a8949df112e6f92b0960880662f548a8d7
# Parent 0f9aa4eb4bece8c5ca3a200b6458daf60088bef0
Remove redundant functions, format.el, use functions from cl*.el instead.
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* format.el (format-delq-cons): Removed.
* format.el (format-make-relatively-unique): Removed.
* format.el (format-common-tail): Removed.
* format.el (format-reorder): Removed.
* format.el (format-annotate-region):
* format.el (format-annotate-single-property-change):
* format.el (format-annotate-atomic-property-change):
Remove various functions from this file that re-implemented Common
Lisp functions that we have built-in.
diff -r 0f9aa4eb4bec -r dbae25a8949d lisp/ChangeLog
--- a/lisp/ChangeLog Tue Mar 08 21:00:36 2011 +0000
+++ b/lisp/ChangeLog Tue Mar 08 22:32:49 2011 +0000
＠＠ -1,3 +1,15 ＠＠
+2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * format.el (format-delq-cons): Removed.
+ * format.el (format-make-relatively-unique): Removed.
+ * format.el (format-common-tail): Removed.
+ * format.el (format-reorder): Removed.
+ * format.el (format-annotate-region):
+ * format.el (format-annotate-single-property-change):
+ * format.el (format-annotate-atomic-property-change):
+ Remove various functions from this file that re-implemented Common
+ Lisp functions that we have built-in.
+
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* select.el (selection-preferred-types):
diff -r 0f9aa4eb4bec -r dbae25a8949d lisp/format.el
--- a/lisp/format.el Tue Mar 08 21:00:36 2011 +0000
+++ b/lisp/format.el Tue Mar 08 22:32:49 2011 +0000
＠＠ -437,68 +437,6 ＠＠
(match-beginning 0)))))
(setq alist (cdr alist)))))))
-;;; Some list-manipulation functions that we need.
-
-(defun format-delq-cons (cons list)
- "Remove the given CONS from LIST by side effect,
-and return the new LIST. Since CONS could be the first element
-of LIST, write `\(setq foo \(format-delq-cons element foo))' to be sure of
-changing the value of `foo'."
- (if (eq cons list)
- (cdr list)
- (let ((p list))
- (while (not (eq (cdr p) cons))
- (if (null p) (error "format-delq-cons: not an element."))
- (setq p (cdr p)))
- ;; Now (cdr p) is the cons to delete
- (setcdr p (cdr cons))
- list)))
-
-;; XEmacs: this is #'nset-exclusive-or with a :test of #'equal, though we
-;; probably don't want to replace it right now.
-(defun format-make-relatively-unique (a b)
- "Delete common elements of lists A and B, return as pair.
-Compares using `equal'."
- (let* ((acopy (copy-sequence a))
- (bcopy (copy-sequence b))
- (tail acopy))
- (while tail
- (let ((dup (member (car tail) bcopy))
- (next (cdr tail)))
- (if dup (setq acopy (format-delq-cons tail acopy)
- bcopy (format-delq-cons dup bcopy)))
- (setq tail next)))
- (cons acopy bcopy)))
-
-(defun format-common-tail (a b)
- "Given two lists that have a common tail, return it.
-Compares with `equal', and returns the part of A that is equal to the
-equivalent part of B. If even the last items of the two are not equal,
-returns nil."
- (let ((la (length a))
- (lb (length b)))
- ;; Make sure they are the same length
- (if (> la lb)
- (setq a (nthcdr (- la lb) a))
- (setq b (nthcdr (- lb la) b))))
- (while (not (equal a b))
- (setq a (cdr a)
- b (cdr b)))
- a)
-
-(defun format-reorder (items order)
- "Arrange ITEMS to following partial ORDER.
-Elements of ITEMS equal to elements of ORDER will be rearranged to follow the
-ORDER. Unmatched items will go last."
- (if order
- (let ((item (member (car order) items)))
- (if item
- (cons (car item)
- (format-reorder (format-delq-cons item items)
- (cdr order)))
- (format-reorder items (cdr order))))
- items))
-
(put 'face 'format-list-valued t) ; These text-properties take values
(put 'unknown 'format-list-valued t) ; that are lists, the elements of which
; should be considered separately.
＠＠ -820,7 +758,11 ＠＠
(< loc to)))
(or loc (setq loc from))
(let* ((ans (format-annotate-location loc (= loc from) ignore trans))
- (neg-ans (format-reorder (aref ans 0) open-ans))
+ (neg-ans (sort* (aref ans 0) '<
+:key #'(lambda (object)
+ (or
+ (position object open-ans :test 'equal)
+ most-positive-fixnum))))
(pos-ans (aref ans 1))
(ignored (aref ans 2)))
(setq not-found (append ignored not-found)
＠＠ -929,7 +871,6 ＠＠
(if (or (consp old) (consp new))
(let* ((old (if (listp old) old (list old)))
(new (if (listp new) new (list new)))
- ;; (tail (format-common-tail old new))
close open)
(while old
(setq close
＠＠ -943,7 +884,9 ＠＠
prop-alist nil (car new)))
open)
new (cdr new)))
- (format-make-relatively-unique close open))
+ (cons
+ (set-difference close open :stable t)
+ (set-difference open close :stable t)))
(format-annotate-atomic-property-change prop-alist old new)))))
(defun format-annotate-atomic-property-change (prop-alist old new)
＠＠ -980,7 +923,9 ＠＠
(let ((close (and old (cdr (assoc old prop-alist))))
(open (and new (cdr (assoc new prop-alist)))))
(if (or close open)
- (format-make-relatively-unique close open)
+ (cons
+ (set-difference close open :stable t)
+ (set-difference open close :stable t))
;; Call "Default" function, if any
(let ((default (assq nil prop-alist)))
(if default
--
“Apart from the nine-banded armadillo, man is the only natural host of
Mycobacterium leprae, although it can be grown in the footpads of mice.”
-- Kumar & Clark, Clinical Medicine, summarising improbable leprosy research
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://lists.xemacs.org/mailman/listinfo/xemacs-patches
- 1 participants
- 0 comments
commit: Remove redundant functions, format.el, use functions from cl*.el instead.
13 years, 1 month
Aidan Kehoe
Aidan Kehoe
changeset: 5365:dbae25a8949d
tag: tip
user: Aidan Kehoe <kehoea(a)parhasard.net>
date: Tue Mar 08 22:32:49 2011 +0000
files: lisp/ChangeLog lisp/format.el
description:
Remove redundant functions, format.el, use functions from cl*.el instead.
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* format.el (format-delq-cons): Removed.
* format.el (format-make-relatively-unique): Removed.
* format.el (format-common-tail): Removed.
* format.el (format-reorder): Removed.
* format.el (format-annotate-region):
* format.el (format-annotate-single-property-change):
* format.el (format-annotate-atomic-property-change):
Remove various functions from this file that re-implemented Common
Lisp functions that we have built-in.
diff -r 0f9aa4eb4bec -r dbae25a8949d lisp/ChangeLog
--- a/lisp/ChangeLog Tue Mar 08 21:00:36 2011 +0000
+++ b/lisp/ChangeLog Tue Mar 08 22:32:49 2011 +0000
＠＠ -1,3 +1,15 ＠＠
+2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * format.el (format-delq-cons): Removed.
+ * format.el (format-make-relatively-unique): Removed.
+ * format.el (format-common-tail): Removed.
+ * format.el (format-reorder): Removed.
+ * format.el (format-annotate-region):
+ * format.el (format-annotate-single-property-change):
+ * format.el (format-annotate-atomic-property-change):
+ Remove various functions from this file that re-implemented Common
+ Lisp functions that we have built-in.
+
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* select.el (selection-preferred-types):
diff -r 0f9aa4eb4bec -r dbae25a8949d lisp/format.el
--- a/lisp/format.el Tue Mar 08 21:00:36 2011 +0000
+++ b/lisp/format.el Tue Mar 08 22:32:49 2011 +0000
＠＠ -437,68 +437,6 ＠＠
(match-beginning 0)))))
(setq alist (cdr alist)))))))
-;;; Some list-manipulation functions that we need.
-
-(defun format-delq-cons (cons list)
- "Remove the given CONS from LIST by side effect,
-and return the new LIST. Since CONS could be the first element
-of LIST, write `\(setq foo \(format-delq-cons element foo))' to be sure of
-changing the value of `foo'."
- (if (eq cons list)
- (cdr list)
- (let ((p list))
- (while (not (eq (cdr p) cons))
- (if (null p) (error "format-delq-cons: not an element."))
- (setq p (cdr p)))
- ;; Now (cdr p) is the cons to delete
- (setcdr p (cdr cons))
- list)))
-
-;; XEmacs: this is #'nset-exclusive-or with a :test of #'equal, though we
-;; probably don't want to replace it right now.
-(defun format-make-relatively-unique (a b)
- "Delete common elements of lists A and B, return as pair.
-Compares using `equal'."
- (let* ((acopy (copy-sequence a))
- (bcopy (copy-sequence b))
- (tail acopy))
- (while tail
- (let ((dup (member (car tail) bcopy))
- (next (cdr tail)))
- (if dup (setq acopy (format-delq-cons tail acopy)
- bcopy (format-delq-cons dup bcopy)))
- (setq tail next)))
- (cons acopy bcopy)))
-
-(defun format-common-tail (a b)
- "Given two lists that have a common tail, return it.
-Compares with `equal', and returns the part of A that is equal to the
-equivalent part of B. If even the last items of the two are not equal,
-returns nil."
- (let ((la (length a))
- (lb (length b)))
- ;; Make sure they are the same length
- (if (> la lb)
- (setq a (nthcdr (- la lb) a))
- (setq b (nthcdr (- lb la) b))))
- (while (not (equal a b))
- (setq a (cdr a)
- b (cdr b)))
- a)
-
-(defun format-reorder (items order)
- "Arrange ITEMS to following partial ORDER.
-Elements of ITEMS equal to elements of ORDER will be rearranged to follow the
-ORDER. Unmatched items will go last."
- (if order
- (let ((item (member (car order) items)))
- (if item
- (cons (car item)
- (format-reorder (format-delq-cons item items)
- (cdr order)))
- (format-reorder items (cdr order))))
- items))
-
(put 'face 'format-list-valued t) ; These text-properties take values
(put 'unknown 'format-list-valued t) ; that are lists, the elements of which
; should be considered separately.
＠＠ -820,7 +758,11 ＠＠
(< loc to)))
(or loc (setq loc from))
(let* ((ans (format-annotate-location loc (= loc from) ignore trans))
- (neg-ans (format-reorder (aref ans 0) open-ans))
+ (neg-ans (sort* (aref ans 0) '<
+:key #'(lambda (object)
+ (or
+ (position object open-ans :test 'equal)
+ most-positive-fixnum))))
(pos-ans (aref ans 1))
(ignored (aref ans 2)))
(setq not-found (append ignored not-found)
＠＠ -929,7 +871,6 ＠＠
(if (or (consp old) (consp new))
(let* ((old (if (listp old) old (list old)))
(new (if (listp new) new (list new)))
- ;; (tail (format-common-tail old new))
close open)
(while old
(setq close
＠＠ -943,7 +884,9 ＠＠
prop-alist nil (car new)))
open)
new (cdr new)))
- (format-make-relatively-unique close open))
+ (cons
+ (set-difference close open :stable t)
+ (set-difference open close :stable t)))
(format-annotate-atomic-property-change prop-alist old new)))))
(defun format-annotate-atomic-property-change (prop-alist old new)
＠＠ -980,7 +923,9 ＠＠
(let ((close (and old (cdr (assoc old prop-alist))))
(open (and new (cdr (assoc new prop-alist)))))
(if (or close open)
- (format-make-relatively-unique close open)
+ (cons
+ (set-difference close open :stable t)
+ (set-difference open close :stable t))
;; Call "Default" function, if any
(let ((default (assq nil prop-alist)))
(if default
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://lists.xemacs.org/mailman/listinfo/xemacs-patches
- 1 participants
- 0 comments
[COMMIT] Make my Lisp a little more sophisticated, select.el.
13 years, 1 month
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed.
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1299618036 0
# Node ID 0f9aa4eb4bece8c5ca3a200b6458daf60088bef0
# Parent 311f6817efc24a2f7946186eaed71e20bc6ed5ab
Make my Lisp a little more sophisticated, select.el.
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* select.el (selection-preferred-types):
* select.el (cut-copy-clear-internal):
* select.el (create-image-functions):
* select.el (select-convert-from-image/gif):
* select.el (select-convert-from-image/jpeg):
* select.el (select-convert-from-image/png):
* select.el (select-convert-from-image/tiff):
* select.el (select-convert-from-image/xpm):
* select.el (select-convert-from-image/xbm):
* select.el (selection-converter-in-alist):
Make my Lisp a little more sophisticated in this file.
diff -r 311f6817efc2 -r 0f9aa4eb4bec lisp/ChangeLog
--- a/lisp/ChangeLog Tue Mar 08 18:12:48 2011 +0000
+++ b/lisp/ChangeLog Tue Mar 08 21:00:36 2011 +0000
＠＠ -1,3 +1,17 ＠＠
+2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * select.el (selection-preferred-types):
+ * select.el (cut-copy-clear-internal):
+ * select.el (create-image-functions):
+ * select.el (select-convert-from-image/gif):
+ * select.el (select-convert-from-image/jpeg):
+ * select.el (select-convert-from-image/png):
+ * select.el (select-convert-from-image/tiff):
+ * select.el (select-convert-from-image/xpm):
+ * select.el (select-convert-from-image/xbm):
+ * select.el (selection-converter-in-alist):
+ Make my Lisp a little more sophisticated in this file.
+
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* package-ui.el (pui-add-required-packages):
diff -r 311f6817efc2 -r 0f9aa4eb4bec lisp/select.el
--- a/lisp/select.el Tue Mar 08 18:12:48 2011 +0000
+++ b/lisp/select.el Tue Mar 08 21:00:36 2011 +0000
＠＠ -38,10 +38,11 ＠＠
;; Mozilla will happily give us broken COMPOUND_TEXT where a non-broken
;; UTF8_STRING is available.
(defvar selection-preferred-types
- (let ((res '(UTF8_STRING COMPOUND_TEXT STRING image/png image/gif
- image/jpeg image/tiff image/xpm image/xbm)))
- (unless (featurep 'mule) (delq 'COMPOUND_TEXT res))
- res)
+ `(UTF8_STRING ,＠(and (featurep 'mule) '(COMPOUND_TEXT)) STRING
+ ,＠(mapcan #'(lambda (format)
+ (and (featurep format)
+ (list (intern (format "image/%s" format)))))
+ '(png gif jpeg tiff xpm xbm)))
"An ordered list of X11 type atoms for selections we want to receive.
We prefer UTF8_STRING over COMPOUND_TEXT, for compatibility with a certain
widely-used browser suite, and COMPOUND_TEXT over STRING. (COMPOUND_TEXT
＠＠ -379,7 +380,7 ＠＠
(buffer-live-p (marker-buffer (cdr data))))))
(defun cut-copy-clear-internal (mode)
- (or (memq mode '(cut copy clear)) (error "unkown mode %S" mode))
+ (or (memq mode '(cut copy clear)) (error "unknown mode %S" mode))
(or (selection-owner-p)
(error "XEmacs does not own the primary selection"))
(setq last-command nil)
＠＠ -777,26 +778,19 ＠＠
(set-extent-end-glyph extent glyph)
str)))
-;; Could automate defining these functions these with a macro, but damned if
-;; I can get that to work. Anyway, this is more readable.
-
-(defun select-convert-from-image/gif (selection type value)
- (if (featurep 'gif) (select-convert-from-image-data 'gif value)))
-
-(defun select-convert-from-image/jpeg (selection type value)
- (if (featurep 'jpeg) (select-convert-from-image-data 'jpeg value)))
-
-(defun select-convert-from-image/png (selection type value)
- (if (featurep 'png) (select-convert-from-image-data 'png value)))
-
-(defun select-convert-from-image/tiff (selection type value)
- (if (featurep 'tiff) (select-convert-from-image-data 'tiff value)))
-
-(defun select-convert-from-image/xpm (selection type value)
- (if (featurep 'xpm) (select-convert-from-image-data 'xpm value)))
-
-(defun select-convert-from-image/xbm (selection type value)
- (if (featurep 'xbm) (select-convert-from-image-data 'xbm value)))
+(macrolet
+ ((create-image-functions (&rest formats)
+ (cons
+ 'progn
+ (mapcar
+ #'(lambda (format)
+ `(if (featurep ',format)
+ (defalias (intern (concat "select-convert-from-image/"
+ ,(symbol-name format)))
+ #'(lambda (selection type value)
+ (select-convert-from-image-data ',format
+ value))))) formats))))
+ (create-image-functions gif jpeg png tiff xpm xbm))
;;; CF_xxx conversions
(defun select-convert-from-cf-text (selection type value)
＠＠ -931,7 +925,7 ＠＠
;; Types listed here can be selections foreign to XEmacs
(setq selection-converter-in-alist
- '(; Specific types that get handled by generic converters
+ `(; Specific types that get handled by generic converters
(INTEGER . select-convert-from-integer)
(TIMESTAMP . select-convert-from-integer)
(LENGTH . select-convert-from-integer)
＠＠ -948,13 +942,12 ＠＠
(text/html . select-convert-from-utf-16-le-text) ; Mozilla
(text/_moz_htmlcontext . select-convert-from-utf-16-le-text)
(text/_moz_htmlinfo . select-convert-from-utf-16-le-text)
- (image/png . select-convert-from-image/png)
- (image/gif . select-convert-from-image/gif)
- (image/jpeg . select-convert-from-image/jpeg )
- (image/tiff . select-convert-from-image/tiff )
- (image/xpm . select-convert-from-image/xpm)
- (image/xbm . select-convert-from-image/xbm)
- ))
+ ,＠(loop
+ for format in '(gif jpeg png tiff xpm xbm)
+ nconc (if (featurep format)
+ (list (cons (intern (format "image/%s" format))
+ (intern (format "select-convert-from-image/%s"
+ format))))))))
;; Types listed here have special coercion functions that can munge
;; other types. This can also be used to add special features - e.g.
--
“Apart from the nine-banded armadillo, man is the only natural host of
Mycobacterium leprae, although it can be grown in the footpads of mice.”
-- Kumar & Clark, Clinical Medicine, summarising improbable leprosy research
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://lists.xemacs.org/mailman/listinfo/xemacs-patches
- 1 participants
- 0 comments
commit: Make my Lisp a little more sophisticated, select.el.
13 years, 1 month
Aidan Kehoe
Aidan Kehoe
changeset: 5364:0f9aa4eb4bec
tag: tip
user: Aidan Kehoe <kehoea(a)parhasard.net>
date: Tue Mar 08 21:00:36 2011 +0000
files: lisp/ChangeLog lisp/select.el
description:
Make my Lisp a little more sophisticated, select.el.
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* select.el (selection-preferred-types):
* select.el (cut-copy-clear-internal):
* select.el (create-image-functions):
* select.el (select-convert-from-image/gif):
* select.el (select-convert-from-image/jpeg):
* select.el (select-convert-from-image/png):
* select.el (select-convert-from-image/tiff):
* select.el (select-convert-from-image/xpm):
* select.el (select-convert-from-image/xbm):
* select.el (selection-converter-in-alist):
Make my Lisp a little more sophisticated in this file.
diff -r 311f6817efc2 -r 0f9aa4eb4bec lisp/ChangeLog
--- a/lisp/ChangeLog Tue Mar 08 18:12:48 2011 +0000
+++ b/lisp/ChangeLog Tue Mar 08 21:00:36 2011 +0000
＠＠ -1,3 +1,17 ＠＠
+2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * select.el (selection-preferred-types):
+ * select.el (cut-copy-clear-internal):
+ * select.el (create-image-functions):
+ * select.el (select-convert-from-image/gif):
+ * select.el (select-convert-from-image/jpeg):
+ * select.el (select-convert-from-image/png):
+ * select.el (select-convert-from-image/tiff):
+ * select.el (select-convert-from-image/xpm):
+ * select.el (select-convert-from-image/xbm):
+ * select.el (selection-converter-in-alist):
+ Make my Lisp a little more sophisticated in this file.
+
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* package-ui.el (pui-add-required-packages):
diff -r 311f6817efc2 -r 0f9aa4eb4bec lisp/select.el
--- a/lisp/select.el Tue Mar 08 18:12:48 2011 +0000
+++ b/lisp/select.el Tue Mar 08 21:00:36 2011 +0000
＠＠ -38,10 +38,11 ＠＠
;; Mozilla will happily give us broken COMPOUND_TEXT where a non-broken
;; UTF8_STRING is available.
(defvar selection-preferred-types
- (let ((res '(UTF8_STRING COMPOUND_TEXT STRING image/png image/gif
- image/jpeg image/tiff image/xpm image/xbm)))
- (unless (featurep 'mule) (delq 'COMPOUND_TEXT res))
- res)
+ `(UTF8_STRING ,＠(and (featurep 'mule) '(COMPOUND_TEXT)) STRING
+ ,＠(mapcan #'(lambda (format)
+ (and (featurep format)
+ (list (intern (format "image/%s" format)))))
+ '(png gif jpeg tiff xpm xbm)))
"An ordered list of X11 type atoms for selections we want to receive.
We prefer UTF8_STRING over COMPOUND_TEXT, for compatibility with a certain
widely-used browser suite, and COMPOUND_TEXT over STRING. (COMPOUND_TEXT
＠＠ -379,7 +380,7 ＠＠
(buffer-live-p (marker-buffer (cdr data))))))
(defun cut-copy-clear-internal (mode)
- (or (memq mode '(cut copy clear)) (error "unkown mode %S" mode))
+ (or (memq mode '(cut copy clear)) (error "unknown mode %S" mode))
(or (selection-owner-p)
(error "XEmacs does not own the primary selection"))
(setq last-command nil)
＠＠ -777,26 +778,19 ＠＠
(set-extent-end-glyph extent glyph)
str)))
-;; Could automate defining these functions these with a macro, but damned if
-;; I can get that to work. Anyway, this is more readable.
-
-(defun select-convert-from-image/gif (selection type value)
- (if (featurep 'gif) (select-convert-from-image-data 'gif value)))
-
-(defun select-convert-from-image/jpeg (selection type value)
- (if (featurep 'jpeg) (select-convert-from-image-data 'jpeg value)))
-
-(defun select-convert-from-image/png (selection type value)
- (if (featurep 'png) (select-convert-from-image-data 'png value)))
-
-(defun select-convert-from-image/tiff (selection type value)
- (if (featurep 'tiff) (select-convert-from-image-data 'tiff value)))
-
-(defun select-convert-from-image/xpm (selection type value)
- (if (featurep 'xpm) (select-convert-from-image-data 'xpm value)))
-
-(defun select-convert-from-image/xbm (selection type value)
- (if (featurep 'xbm) (select-convert-from-image-data 'xbm value)))
+(macrolet
+ ((create-image-functions (&rest formats)
+ (cons
+ 'progn
+ (mapcar
+ #'(lambda (format)
+ `(if (featurep ',format)
+ (defalias (intern (concat "select-convert-from-image/"
+ ,(symbol-name format)))
+ #'(lambda (selection type value)
+ (select-convert-from-image-data ',format
+ value))))) formats))))
+ (create-image-functions gif jpeg png tiff xpm xbm))
;;; CF_xxx conversions
(defun select-convert-from-cf-text (selection type value)
＠＠ -931,7 +925,7 ＠＠
;; Types listed here can be selections foreign to XEmacs
(setq selection-converter-in-alist
- '(; Specific types that get handled by generic converters
+ `(; Specific types that get handled by generic converters
(INTEGER . select-convert-from-integer)
(TIMESTAMP . select-convert-from-integer)
(LENGTH . select-convert-from-integer)
＠＠ -948,13 +942,12 ＠＠
(text/html . select-convert-from-utf-16-le-text) ; Mozilla
(text/_moz_htmlcontext . select-convert-from-utf-16-le-text)
(text/_moz_htmlinfo . select-convert-from-utf-16-le-text)
- (image/png . select-convert-from-image/png)
- (image/gif . select-convert-from-image/gif)
- (image/jpeg . select-convert-from-image/jpeg )
- (image/tiff . select-convert-from-image/tiff )
- (image/xpm . select-convert-from-image/xpm)
- (image/xbm . select-convert-from-image/xbm)
- ))
+ ,＠(loop
+ for format in '(gif jpeg png tiff xpm xbm)
+ nconc (if (featurep format)
+ (list (cons (intern (format "image/%s" format))
+ (intern (format "select-convert-from-image/%s"
+ format))))))))
;; Types listed here have special coercion functions that can munge
;; other types. This can also be used to add special features - e.g.
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://lists.xemacs.org/mailman/listinfo/xemacs-patches
- 1 participants
- 0 comments
[COMMIT] Remove various redundant wrapper lambdas, core lisp.
13 years, 1 month
Aidan Kehoe
Aidan Kehoe
APPROVE COMMIT
NOTE: This patch has been committed.
# HG changeset patch
# User Aidan Kehoe <kehoea(a)parhasard.net>
# Date 1299607968 0
# Node ID 311f6817efc24a2f7946186eaed71e20bc6ed5ab
# Parent 1cfe6b84efbf9690361027a8d37acd95a20f7cf7
Remove various redundant wrapper lambdas, core lisp.
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* package-ui.el (pui-add-required-packages):
* packages.el (packages-handle-package-dumped-lisps):
* bytecomp-runtime.el (byte-compile-with-fboundp):
* bytecomp-runtime.el (globally-declare-fboundp):
* bytecomp-runtime.el
(byte-compile-with-byte-compiler-warnings-suppressed):
* mule/devan-util.el (devanagari-reorder-glyphs-for-composition):
* mule/devan-util.el (devanagari-compose-to-one-glyph):
* mule/japanese.el:
* mule/japanese.el ("Japanese"):
* mule/make-coding-system.el (fixed-width-generate-helper):
* mule/mule-category.el (defined-category-list):
* mule/mule-category.el (undefined-category-designator):
Style change: remove redundant lambdas, things like (mapcar
#'(lambda (pkg) (symbol-name pkg)) ...) => (mapcar #'symbol-name ...).
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/ChangeLog
--- a/lisp/ChangeLog Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/ChangeLog Tue Mar 08 18:12:48 2011 +0000
＠＠ -1,3 +1,21 ＠＠
+2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * package-ui.el (pui-add-required-packages):
+ * packages.el (packages-handle-package-dumped-lisps):
+ * bytecomp-runtime.el (byte-compile-with-fboundp):
+ * bytecomp-runtime.el (globally-declare-fboundp):
+ * bytecomp-runtime.el
+ (byte-compile-with-byte-compiler-warnings-suppressed):
+ * mule/devan-util.el (devanagari-reorder-glyphs-for-composition):
+ * mule/devan-util.el (devanagari-compose-to-one-glyph):
+ * mule/japanese.el:
+ * mule/japanese.el ("Japanese"):
+ * mule/make-coding-system.el (fixed-width-generate-helper):
+ * mule/mule-category.el (defined-category-list):
+ * mule/mule-category.el (undefined-category-designator):
+ Style change: remove redundant lambdas, things like (mapcar
+ #'(lambda (pkg) (symbol-name pkg)) ...) => (mapcar #'symbol-name ...).
+
2011-02-16 Aidan Kehoe <kehoea(a)parhasard.net>
* bytecomp.el (byte-compile-normal-call):
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/bytecomp-runtime.el
--- a/lisp/bytecomp-runtime.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/bytecomp-runtime.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -310,7 +310,7 ＠＠
(let ((symbols (eval (car (cdr form)))))
(unless (consp symbols)
(setq symbols (list symbols)))
- (setq symbols (mapcar #'(lambda (sym) (cons sym nil)) symbols))
+ (setq symbols (mapcar #'list symbols))
(setq byte-compile-unresolved-functions
(set-difference byte-compile-unresolved-functions symbols
:key #'car))
＠＠ -427,7 +427,7 ＠＠
;; have an autoload later in the file for any functions in FUNCTIONS.
;; This is not something that code should ever do, though.)
(setq byte-compile-autoload-environment
- (append (mapcar #'(lambda (sym) (cons sym nil)) functions)
+ (append (mapcar #'list functions)
byte-compile-autoload-environment)))
nil)
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/mule/devan-util.el
--- a/lisp/mule/devan-util.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/mule/devan-util.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -1057,8 +1057,7 ＠＠
(setq ordered-glyphs
(append ordered-glyphs
(list (assq glyph devanagari-composition-rules))))))
- (sort ordered-glyphs #'(lambda (x y) (< (car (cdr x)) (car (cdr y)))))))
-
+ (sort* ordered-glyphs '< :key 'cadr)))
;;(devanagari-compose-to-one-glyph "$(5"5!X![(B") => "4$(6!Xv#"5t%![0!X"5![1(B"
(defun devanagari-compose-to-one-glyph (devanagari-string)
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/mule/japanese.el
--- a/lisp/mule/japanese.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/mule/japanese.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -444,44 +444,38 ＠＠
;; little helps there.)
(set-language-info "Japanese"
'native-coding-system
- (list
- ;; first, see if an explicit encoding was given.
- (lambda (locale)
- (let ((case-fold-search t))
- (cond
- ;; many unix versions
- ((string-match "\\.euc" locale) 'euc-jp)
- ((string-match "\\.sjis" locale) 'shift-jis)
+ ;; first, see if an explicit encoding was given.
+ (lambda (locale)
+ (let ((case-fold-search t))
+ (cond
+ ;; many unix versions
+ ((string-match "\\.euc" locale) 'euc-jp)
+ ((string-match "\\.sjis" locale) 'shift-jis)
- ;; X11R6 (CJKV p. 471)
- ((string-match "\\.jis7" locale) 'jis7)
- ((string-match "\\.jis8" locale) 'jis8)
- ((string-match "\\.mscode" locale) 'shift-jis)
- ((string-match "\\.pjis" locale) 'iso-2022-jp)
- ((string-match "\\.ujis" locale) 'euc-jp)
+ ;; X11R6 (CJKV p. 471)
+ ((string-match "\\.jis7" locale) 'jis7)
+ ((string-match "\\.jis8" locale) 'jis8)
+ ((string-match "\\.mscode" locale) 'shift-jis)
+ ((string-match "\\.pjis" locale) 'iso-2022-jp)
+ ((string-match "\\.ujis" locale) 'euc-jp)
- ;; other names in X11R6 locale.alias
- ((string-match "\\.ajec" locale) 'euc-jp)
- ((string-match "-euc" locale) 'euc-jp)
- ((string-match "\\.iso-2022-jp" locale) 'iso-2022-jp)
- ((string-match "\\.jis" locale) 'jis7) ;; or just jis?
- )))
+ ;; other names in X11R6 locale.alias
+ ((string-match "\\.ajec" locale) 'euc-jp)
+ ((string-match "-euc" locale) 'euc-jp)
+ ((string-match "\\.iso-2022-jp" locale) 'iso-2022-jp)
+ ((string-match "\\.jis" locale) 'jis7) ;; or just jis?
- ;; aix (CJKV p. 465)
- (lambda (locale)
- (when (eq system-type 'aix)
- (cond
- ((string-match "^Ja_JP" locale) 'shift-jis)
- ((string-match "^ja_JP" locale) 'euc-jp))))
+ ;; aix (CJKV p. 465)
+ ((and (eq system-type 'aix)
+ (string-match "^Ja_JP" locale)) 'shift-jis)
+ ((and (eq system-type 'aix)
+ (string-match "^ja_JP" locale)) 'euc-jp)
- ;; other X11R6 locale.alias
- (lambda (locale)
- (cond
+ ;; other X11R6 locale.alias
((string-match "^Jp_JP" locale) 'euc-jp)
((and (eq system-type 'hpux) (eq locale "japanese"))
- 'shift-jis)))
-
- ;; fallback
- 'euc-jp))
+ 'shift-jis)
+ ;; fallback
+ (t 'euc-jp)))))
;;; japanese.el ends here
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/mule/make-coding-system.el
--- a/lisp/mule/make-coding-system.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/mule/make-coding-system.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -68,10 +68,7 ＠＠
(repeat)))) nil))
(first-part compiled)
(last-part
- (member-if-not (lambda (entr) (eq #xBFFE entr))
- (member-if
- (lambda (entr) (eq #xBFFE entr))
- first-part))))
+ (member* #xBFFE (member* #xBFFE first-part) :test-not 'eql)))
(while compiled
(when (eq #xBFFE (cadr compiled))
(assert (= vec-len (search '(#xBFFE) (cdr compiled)
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/mule/mule-category.el
--- a/lisp/mule/mule-category.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/mule/mule-category.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -64,11 +64,7 ＠＠
(defun defined-category-list ()
"Return a list of the currently defined categories.
Categories are given by their designators."
- (let (list)
- (maphash #'(lambda (key value)
- (setq list (cons key list)))
- defined-category-hashtable)
- (nreverse list)))
+ (hash-table-key-list defined-category-hashtable))
(defun undefined-category-designator ()
"Return an undefined category designator, or nil if there are none."
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/package-ui.el
--- a/lisp/package-ui.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/package-ui.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -435,9 +435,7 ＠＠
(save-window-excursion
(with-output-to-temp-buffer tmpbuf
(display-completion-list (sort
- (mapcar #'(lambda (pkg)
- (symbol-name pkg))
- dependencies)
+ (mapcar #'symbol-name dependencies)
'string<)
:activate-callback nil
:help-string "Required packages:\n"
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/packages.el
--- a/lisp/packages.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/packages.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -517,9 +517,7 ＠＠
(load file-name)
;; dumped-lisp.el could have set this ...
(if package-lisp
- (mapcar #'(lambda (base)
- (funcall handle base))
- package-lisp))))))
+ (mapcar handle package-lisp))))))
package-load-path))
(defun packages-load-package-dumped-lisps (package-load-path)
--
“Apart from the nine-banded armadillo, man is the only natural host of
Mycobacterium leprae, although it can be grown in the footpads of mice.”
-- Kumar & Clark, Clinical Medicine, summarising improbable leprosy research
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://lists.xemacs.org/mailman/listinfo/xemacs-patches
- 1 participants
- 0 comments
commit: Remove various redundant wrapper lambdas, core lisp.
13 years, 1 month
Aidan Kehoe
Aidan Kehoe
changeset: 5363:311f6817efc2
tag: tip
user: Aidan Kehoe <kehoea(a)parhasard.net>
date: Tue Mar 08 18:12:48 2011 +0000
files: lisp/ChangeLog lisp/bytecomp-runtime.el lisp/mule/devan-util.el lisp/mule/japanese.el lisp/mule/make-coding-system.el lisp/mule/mule-category.el lisp/package-ui.el lisp/packages.el
description:
Remove various redundant wrapper lambdas, core lisp.
2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
* package-ui.el (pui-add-required-packages):
* packages.el (packages-handle-package-dumped-lisps):
* bytecomp-runtime.el (byte-compile-with-fboundp):
* bytecomp-runtime.el (globally-declare-fboundp):
* bytecomp-runtime.el
(byte-compile-with-byte-compiler-warnings-suppressed):
* mule/devan-util.el (devanagari-reorder-glyphs-for-composition):
* mule/devan-util.el (devanagari-compose-to-one-glyph):
* mule/japanese.el:
* mule/japanese.el ("Japanese"):
* mule/make-coding-system.el (fixed-width-generate-helper):
* mule/mule-category.el (defined-category-list):
* mule/mule-category.el (undefined-category-designator):
Style change: remove redundant lambdas, things like (mapcar
#'(lambda (pkg) (symbol-name pkg)) ...) => (mapcar #'symbol-name ...).
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/ChangeLog
--- a/lisp/ChangeLog Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/ChangeLog Tue Mar 08 18:12:48 2011 +0000
＠＠ -1,3 +1,21 ＠＠
+2011-03-08 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * package-ui.el (pui-add-required-packages):
+ * packages.el (packages-handle-package-dumped-lisps):
+ * bytecomp-runtime.el (byte-compile-with-fboundp):
+ * bytecomp-runtime.el (globally-declare-fboundp):
+ * bytecomp-runtime.el
+ (byte-compile-with-byte-compiler-warnings-suppressed):
+ * mule/devan-util.el (devanagari-reorder-glyphs-for-composition):
+ * mule/devan-util.el (devanagari-compose-to-one-glyph):
+ * mule/japanese.el:
+ * mule/japanese.el ("Japanese"):
+ * mule/make-coding-system.el (fixed-width-generate-helper):
+ * mule/mule-category.el (defined-category-list):
+ * mule/mule-category.el (undefined-category-designator):
+ Style change: remove redundant lambdas, things like (mapcar
+ #'(lambda (pkg) (symbol-name pkg)) ...) => (mapcar #'symbol-name ...).
+
2011-02-16 Aidan Kehoe <kehoea(a)parhasard.net>
* bytecomp.el (byte-compile-normal-call):
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/bytecomp-runtime.el
--- a/lisp/bytecomp-runtime.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/bytecomp-runtime.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -310,7 +310,7 ＠＠
(let ((symbols (eval (car (cdr form)))))
(unless (consp symbols)
(setq symbols (list symbols)))
- (setq symbols (mapcar #'(lambda (sym) (cons sym nil)) symbols))
+ (setq symbols (mapcar #'list symbols))
(setq byte-compile-unresolved-functions
(set-difference byte-compile-unresolved-functions symbols
:key #'car))
＠＠ -427,7 +427,7 ＠＠
;; have an autoload later in the file for any functions in FUNCTIONS.
;; This is not something that code should ever do, though.)
(setq byte-compile-autoload-environment
- (append (mapcar #'(lambda (sym) (cons sym nil)) functions)
+ (append (mapcar #'list functions)
byte-compile-autoload-environment)))
nil)
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/mule/devan-util.el
--- a/lisp/mule/devan-util.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/mule/devan-util.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -1057,8 +1057,7 ＠＠
(setq ordered-glyphs
(append ordered-glyphs
(list (assq glyph devanagari-composition-rules))))))
- (sort ordered-glyphs #'(lambda (x y) (< (car (cdr x)) (car (cdr y)))))))
-
+ (sort* ordered-glyphs '< :key 'cadr)))
;;(devanagari-compose-to-one-glyph "$(5"5!X![(B") => "4$(6!Xv#"5t%![0!X"5![1(B"
(defun devanagari-compose-to-one-glyph (devanagari-string)
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/mule/japanese.el
--- a/lisp/mule/japanese.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/mule/japanese.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -444,44 +444,38 ＠＠
;; little helps there.)
(set-language-info "Japanese"
'native-coding-system
- (list
- ;; first, see if an explicit encoding was given.
- (lambda (locale)
- (let ((case-fold-search t))
- (cond
- ;; many unix versions
- ((string-match "\\.euc" locale) 'euc-jp)
- ((string-match "\\.sjis" locale) 'shift-jis)
+ ;; first, see if an explicit encoding was given.
+ (lambda (locale)
+ (let ((case-fold-search t))
+ (cond
+ ;; many unix versions
+ ((string-match "\\.euc" locale) 'euc-jp)
+ ((string-match "\\.sjis" locale) 'shift-jis)
- ;; X11R6 (CJKV p. 471)
- ((string-match "\\.jis7" locale) 'jis7)
- ((string-match "\\.jis8" locale) 'jis8)
- ((string-match "\\.mscode" locale) 'shift-jis)
- ((string-match "\\.pjis" locale) 'iso-2022-jp)
- ((string-match "\\.ujis" locale) 'euc-jp)
+ ;; X11R6 (CJKV p. 471)
+ ((string-match "\\.jis7" locale) 'jis7)
+ ((string-match "\\.jis8" locale) 'jis8)
+ ((string-match "\\.mscode" locale) 'shift-jis)
+ ((string-match "\\.pjis" locale) 'iso-2022-jp)
+ ((string-match "\\.ujis" locale) 'euc-jp)
- ;; other names in X11R6 locale.alias
- ((string-match "\\.ajec" locale) 'euc-jp)
- ((string-match "-euc" locale) 'euc-jp)
- ((string-match "\\.iso-2022-jp" locale) 'iso-2022-jp)
- ((string-match "\\.jis" locale) 'jis7) ;; or just jis?
- )))
+ ;; other names in X11R6 locale.alias
+ ((string-match "\\.ajec" locale) 'euc-jp)
+ ((string-match "-euc" locale) 'euc-jp)
+ ((string-match "\\.iso-2022-jp" locale) 'iso-2022-jp)
+ ((string-match "\\.jis" locale) 'jis7) ;; or just jis?
- ;; aix (CJKV p. 465)
- (lambda (locale)
- (when (eq system-type 'aix)
- (cond
- ((string-match "^Ja_JP" locale) 'shift-jis)
- ((string-match "^ja_JP" locale) 'euc-jp))))
+ ;; aix (CJKV p. 465)
+ ((and (eq system-type 'aix)
+ (string-match "^Ja_JP" locale)) 'shift-jis)
+ ((and (eq system-type 'aix)
+ (string-match "^ja_JP" locale)) 'euc-jp)
- ;; other X11R6 locale.alias
- (lambda (locale)
- (cond
+ ;; other X11R6 locale.alias
((string-match "^Jp_JP" locale) 'euc-jp)
((and (eq system-type 'hpux) (eq locale "japanese"))
- 'shift-jis)))
-
- ;; fallback
- 'euc-jp))
+ 'shift-jis)
+ ;; fallback
+ (t 'euc-jp)))))
;;; japanese.el ends here
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/mule/make-coding-system.el
--- a/lisp/mule/make-coding-system.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/mule/make-coding-system.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -68,10 +68,7 ＠＠
(repeat)))) nil))
(first-part compiled)
(last-part
- (member-if-not (lambda (entr) (eq #xBFFE entr))
- (member-if
- (lambda (entr) (eq #xBFFE entr))
- first-part))))
+ (member* #xBFFE (member* #xBFFE first-part) :test-not 'eql)))
(while compiled
(when (eq #xBFFE (cadr compiled))
(assert (= vec-len (search '(#xBFFE) (cdr compiled)
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/mule/mule-category.el
--- a/lisp/mule/mule-category.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/mule/mule-category.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -64,11 +64,7 ＠＠
(defun defined-category-list ()
"Return a list of the currently defined categories.
Categories are given by their designators."
- (let (list)
- (maphash #'(lambda (key value)
- (setq list (cons key list)))
- defined-category-hashtable)
- (nreverse list)))
+ (hash-table-key-list defined-category-hashtable))
(defun undefined-category-designator ()
"Return an undefined category designator, or nil if there are none."
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/package-ui.el
--- a/lisp/package-ui.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/package-ui.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -435,9 +435,7 ＠＠
(save-window-excursion
(with-output-to-temp-buffer tmpbuf
(display-completion-list (sort
- (mapcar #'(lambda (pkg)
- (symbol-name pkg))
- dependencies)
+ (mapcar #'symbol-name dependencies)
'string<)
:activate-callback nil
:help-string "Required packages:\n"
diff -r 1cfe6b84efbf -r 311f6817efc2 lisp/packages.el
--- a/lisp/packages.el Tue Mar 01 14:18:54 2011 +0000
+++ b/lisp/packages.el Tue Mar 08 18:12:48 2011 +0000
＠＠ -517,9 +517,7 ＠＠
(load file-name)
;; dumped-lisp.el could have set this ...
(if package-lisp
- (mapcar #'(lambda (base)
- (funcall handle base))
- package-lisp))))))
+ (mapcar handle package-lisp))))))
package-load-path))
(defun packages-load-package-dumped-lisps (package-load-path)
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://lists.xemacs.org/mailman/listinfo/xemacs-patches
- 1 participants
- 0 comments
[COMMIT] Change "special form" to "special operator" in the manuals, too
13 years, 1 month
Aidan Kehoe
Aidan Kehoe
V�]=�)U�����չ�ѕ�䰁ѡ�����Յ�́��ٔ�ͽ���������Ʌ�䁅���Ёݡ�Ё�ᅍѱ䁥́�)�����������Ʌѽȁ����ݡ�Ё�ͻ�eа�����$������eЁ���ɕ�Ёѡ�и()AAI=Y�
=55%P()9=Q�Q��́��э����́�����������ѕ��((��! �������͕Ё��э�(��U͕ȁ�����-����������ɡ�ͅɐ�����(���є����������Ԁ�(��9����%��Ɉ啘ŕ�х������Չ�����������ՐŘ��Ռ��(��A�ɕ�Ѐ��Մ������јՄ�������͔�ʼn���є�х��͈є�)
�����������������ɴ��Ѽ�������������ɅѽȈ����ѡ�����Յ�̰�ѽ�((���Ĵ�̴�Ā������-�����������ɡ�ͅɐ�����(($������ɕ���������̹ѕᤀ�Uͥ���%�ѕɅ�ѥٔ��($������ɕ����������ѕᤀ�م���ɥ���
��������($������ɕ����������ѕᤀ�
��������չ�ѥ���=�����̤�($������ɕ������ɽ��ѕᤀ�M��Օ�������($������ɕ������ɽ��ѕᤀ�
����ѥ����̤�($������ɕ������ɽ��ѕᤀ�
���������
����ѥ��̤�($������ɕ������ɽ��ѕᤀ�%ѕɅѥ����($������ɕ������ɽ��ѕᤀ�
�э������Q�ɽܤ�($������ɕ������ɽ��ѕᤀ�!���������ɽ�̤�($������ɕ������ɽ��ѕᤀ�
������̤�($������ɕ���������ѕᤀ�Q����Ʌ��������̤�($������ɕ���م��ѕᤀ�Eսѥ����($������ɕ���م��ѕᤀ�5ձѥ����م�Օ̤�($������ɕ���Ʌ��̹ѕᤀ�%���Ё���̤�($������ɕ���չ�ѥ��̹ѕᤀ�ɝյ��Ё1��Ф�($������ɕ���չ�ѥ��̹ѕᤀ���������չ�ѥ��̤�($������ɕ���չ�ѥ��̹ѕᤀ����嵽�́չ�ѥ��̤�($������ɕ����ѕɹ�ѥ������ѥ���ѕᤀ�1�ٕ��́Aɥ��ѥٕ̤�($������ɕ����ѕɹ�ѥ������ѥ���ѕᤀ�������M��������ѥ����($������ɕ�����ɼ�ѕᤀ��M������չ�ѥ����͍ɥ�ѥ����($������ɕ�����ɼ�ѕᤀ��M������Y�ɥ������͍ɥ�ѥ����($������ɕ������̹ѕᤀ�M��́���1���̤�($������ɕ�����ɽ̹ѕᤀ���������5��ɽ̤�($������ɕ�����ɽ̹ѕᤀ� ����սє��($������ɕ����ͥѥ��̹ѕᤀ����ͥ��̤�($������ɕ����ͥѥ��̹ѕᤀ�9��ɽݥ����($������ɕ��͕�ɍ�����ѕᤀ�M�٥���5�э���ф��($������ɕ��͕�Օ���̹ѕᤀ�M��Օ����չ�ѥ��̤�($������ɕ��͕�Օ���̹ѕᤀ��Ʌ�չ�ѥ��̤�($������ɕ�����������̹ѕᤀ�������M��������ѥ��̤�($������ɕ��مɥ����̹ѕᤀ�1�����Y�ɥ����̤�($������ɕ��مɥ����̹ѕᤀ���������Y�ɥ����̤�($������ɕ��مɥ����̹ѕᤀ�M��ѥ���Y�ɥ����̤�($������ɕ��مɥ����̹ѕᤀ����ձЁY��Ք��($������ɕ��ݥ����̹ѕᤀ�M����ѥ���]�����̤�($������ɕ��ݥ����̹ѕᤀ�]����܁
������Ʌѥ��̤�(%9�������ȁ�͔����������ͥ����ݔ���������ȁ�͔�ѡ��ѕɴ���������(%��ɴ�쁥��ѕ����͔��������M�������=��Ʌѽ��U�����չ�ѕ��(%ѡ�ɔ�́���݅䁥��ѕ���Ѽ�ɕ����������������������������()������ȁ�Մ������јԀ�Ȁ�Ɉ啘ŕ�х������
�����1��(����������
�����1��%M�Ё���������������Ā�����(����������
�����1��%QՔ�5�Ȁ�Ā�������Ԁ���Ā�����)
- 1 participants
- 0 comments
commit: Automated merge with file:///home/aidan/xemacs-21.5-checked-out
13 years, 1 month
Aidan Kehoe
Aidan Kehoe
ClamAV 0.96
changeset: 5362:1cfe6b84efbf
tag: tip
parent: 5360:46b53e84ea7a
parent: 5361:62b9ef1ed4ac
user: Aidan Kehoe <kehoea(a)parhasard.net>
date: Tue Mar 01 14:18:54 2011 +0000
description:
Automated merge with file:///home/aidan/xemacs-21.5-checked-out
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://lists.xemacs.org/mailman/listinfo/xemacs-patches
- 1 participants
- 0 comments
commit: Change "special form" to "special operator" in the manuals, too
13 years, 1 month
Aidan Kehoe
Aidan Kehoe
ClamAV 0.96
changeset: 5361:62b9ef1ed4ac
parent: 5359:f5a5501814f5
user: Aidan Kehoe <kehoea(a)parhasard.net>
date: Tue Mar 01 14:18:45 2011 +0000
files: man/ChangeLog man/cl.texi man/lispref/commands.texi man/lispref/compile.texi man/lispref/control.texi man/lispref/display.texi man/lispref/eval.texi man/lispref/frames.texi man/lispref/functions.texi man/lispref/internationalization.texi man/lispref/intro.texi man/lispref/lists.texi man/lispref/macros.texi man/lispref/positions.texi man/lispref/searching.texi man/lispref/sequences.texi man/lispref/specifiers.texi man/lispref/variables.texi man/lispref/windows.texi
description:
Change "special form" to "special operator" in the manuals, too
2011-03-01 Aidan Kehoe <kehoea(a)parhasard.net>
* lispref/commands.texi (Using Interactive):
* lispref/compile.texi (Eval During Compile):
* lispref/compile.texi (Compiled-Function Objects):
* lispref/control.texi (Sequencing):
* lispref/control.texi (Conditionals):
* lispref/control.texi (Combining Conditions):
* lispref/control.texi (Iteration):
* lispref/control.texi (Catch and Throw):
* lispref/control.texi (Handling Errors):
* lispref/control.texi (Cleanups):
* lispref/display.texi (Temporary Displays):
* lispref/eval.texi (Quoting):
* lispref/eval.texi (Multiple values):
* lispref/frames.texi (Input Focus):
* lispref/functions.texi (Argument List):
* lispref/functions.texi (Defining Functions):
* lispref/functions.texi (Anonymous Functions):
* lispref/internationalization.texi (Level 3 Primitives):
* lispref/internationalization.texi (Domain Specification):
* lispref/intro.texi (A Sample Function Description):
* lispref/intro.texi (A Sample Variable Description):
* lispref/lists.texi (Sets And Lists):
* lispref/macros.texi (Defining Macros):
* lispref/macros.texi (Backquote):
* lispref/positions.texi (Excursions):
* lispref/positions.texi (Narrowing):
* lispref/searching.texi (Saving Match Data):
* lispref/sequences.texi (Sequence Functions):
* lispref/sequences.texi (Array Functions):
* lispref/specifiers.texi (Adding Specifications):
* lispref/variables.texi (Local Variables):
* lispref/variables.texi (Defining Variables):
* lispref/variables.texi (Setting Variables):
* lispref/variables.texi (Default Value):
* lispref/windows.texi (Selecting Windows):
* lispref/windows.texi (Window Configurations):
No longer use ＠defspec, since we no longer use the term "special
form"; instead use ＠deffn {Special Operator}. Unfortunately
there's no way in texinfo to redefine ＠defspec in one place.
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/ChangeLog
--- a/man/ChangeLog Sat Feb 19 11:03:46 2011 +0000
+++ b/man/ChangeLog Tue Mar 01 14:18:45 2011 +0000
＠＠ -1,3 +1,69 ＠＠
+2011-03-01 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * lispref/commands.texi (Using Interactive):
+ * lispref/compile.texi (Eval During Compile):
+ * lispref/compile.texi (Compiled-Function Objects):
+ * lispref/control.texi (Sequencing):
+ * lispref/control.texi (Conditionals):
+ * lispref/control.texi (Combining Conditions):
+ * lispref/control.texi (Iteration):
+ * lispref/control.texi (Catch and Throw):
+ * lispref/control.texi (Handling Errors):
+ * lispref/control.texi (Cleanups):
+ * lispref/display.texi (Temporary Displays):
+ * lispref/eval.texi (Quoting):
+ * lispref/eval.texi (Multiple values):
+ * lispref/frames.texi (Input Focus):
+ * lispref/functions.texi (Argument List):
+ * lispref/functions.texi (Defining Functions):
+ * lispref/functions.texi (Anonymous Functions):
+ * lispref/internationalization.texi (Level 3 Primitives):
+ * lispref/internationalization.texi (Domain Specification):
+ * lispref/intro.texi (A Sample Function Description):
+ * lispref/intro.texi (A Sample Variable Description):
+ * lispref/lists.texi (Sets And Lists):
+ * lispref/macros.texi (Defining Macros):
+ * lispref/macros.texi (Backquote):
+ * lispref/positions.texi (Excursions):
+ * lispref/positions.texi (Narrowing):
+ * lispref/searching.texi (Saving Match Data):
+ * lispref/sequences.texi (Sequence Functions):
+ * lispref/sequences.texi (Array Functions):
+ * lispref/specifiers.texi (Adding Specifications):
+ * lispref/variables.texi (Local Variables):
+ * lispref/variables.texi (Defining Variables):
+ * lispref/variables.texi (Setting Variables):
+ * lispref/variables.texi (Default Value):
+ * lispref/windows.texi (Selecting Windows):
+ * lispref/windows.texi (Window Configurations):
+ No longer use ＠defspec, since we no longer use the term "special
+ form"; instead use ＠deffn {Special Operator}. Unfortunately
+ there's no way in texinfo to redefine ＠defspec in one place.
+
+2011-03-01 Aidan Kehoe <kehoea(a)parhasard.net>
+
+ * cl.texi (Argument Lists):
+ * cl.texi (Time of Evaluation):
+ * cl.texi (Type Predicates):
+ * cl.texi (Assignment):
+ * cl.texi (Basic Setf):
+ * cl.texi (Modify Macros):
+ * cl.texi (Customizing Setf):
+ * cl.texi (Dynamic Bindings):
+ * cl.texi (Lexical Bindings):
+ * cl.texi (Function Bindings):
+ * cl.texi (Macro Bindings):
+ * cl.texi (Conditionals):
+ * cl.texi (Blocks and Exits):
+ * cl.texi (Iteration):
+ * cl.texi (Loop Basics):
+ * cl.texi (Macros):
+ * cl.texi (Declarations):
+ * cl.texi (Property Lists):
+ * cl.texi (Structures):
+ * cl.texi (Assertions):
+ * cl.texi (Efficiency Concerns):
+
2011-02-19 Aidan Kehoe <kehoea(a)parhasard.net>
* lispref/lists.texi (Sets And Lists):
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/cl.texi
--- a/man/cl.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/cl.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -381,14 +381,14 ＠＠
Instead, this package defines alternates for several Lisp forms
which you must use if you need Common Lisp argument lists.
-＠defspec defun* name arglist body...
+＠deffn {Special Operator} defun* name arglist body...
This form is identical to the regular ＠code{defun} form, except
that ＠var{arglist} is allowed to be a full Common Lisp argument
list. Also, the function body is enclosed in an implicit block
called ＠var{name}; ＠pxref{Blocks and Exits}.
-＠end defspec
-
-＠defspec defsubst* name arglist body...
+＠end deffn
+
+＠deffn {Special Operator} defsubst* name arglist body...
This is just like ＠code{defun*}, except that the function that
is defined is automatically proclaimed ＠code{inline}, i.e.,
calls to it may be expanded into in-line code by the byte compiler.
＠＠ -398,9 +398,9 ＠＠
efficient inline expansions. In particular, ＠code{defsubst*}
arranges for the processing of keyword arguments, default values,
etc., to be done at compile-time whenever possible.
-＠end defspec
-
-＠defspec defmacro* name arglist body...
+＠end deffn
+
+＠deffn {Special Operator} defmacro* name arglist body...
This is identical to the regular ＠code{defmacro} form,
except that ＠var{arglist} is allowed to be a full Common Lisp
argument list. The ＠code{&environment} keyword is supported as
＠＠ -409,13 +409,13 ＠＠
cannot be implemented with the current Emacs Lisp interpreter.
The macro expander body is enclosed in an implicit block called
＠var{name}.
-＠end defspec
-
-＠defspec function* symbol-or-lambda
+＠end deffn
+
+＠deffn {Special Operator} function* symbol-or-lambda
This is identical to the regular ＠code{function} form,
except that if the argument is a ＠code{lambda} form then that
form may use a full Common Lisp argument list.
-＠end defspec
+＠end deffn
Also, all forms (such as ＠code{defsetf} and ＠code{flet}) defined
in this package that include ＠var{arglist}s in their syntax allow
＠＠ -606,7 +606,7 ＠＠
at compile-time so that later parts of the file can refer to the
macros that are defined.
-＠defspec eval-when (situations...) forms...
+＠deffn {Special Operator} eval-when (situations...) forms...
This form controls when the body ＠var{forms} are evaluated.
The ＠var{situations} list may contain any set of the symbols
＠code{compile}, ＠code{load}, and ＠code{eval} (or their long-winded
＠＠ -678,7 +678,7 ＠＠
certain top-level forms, like ＠code{defmacro} (sort-of) and
＠code{require}, as if they were wrapped in ＠code{(eval-when
(compile load eval) ＠dots{})}.
-＠end defspec
+＠end deffn
Emacs 19 includes two special operators related to ＠code{eval-when}.
One of these, ＠code{eval-when-compile}, is not quite equivalent to
＠＠ -690,7 +690,7 ＠＠
equivalent to ＠samp{(eval-when (compile load eval) ＠dots{})} and
so is not itself defined by this package.
-＠defspec eval-when-compile forms...
+＠deffn {Special Operator} eval-when-compile forms...
The ＠var{forms} are evaluated at compile-time; at execution time,
this form acts like a quoted constant of the resulting value. Used
at top-level, ＠code{eval-when-compile} is just like ＠samp{eval-when
＠＠ -699,9 +699,9 ＠＠
or other reasons.
This form is similar to the ＠samp{#.} syntax of true Common Lisp.
-＠end defspec
-
-＠defspec load-time-value form
+＠end deffn
+
+＠deffn {Special Operator} load-time-value form
The ＠var{form} is evaluated at load-time; at execution time,
this form acts like a quoted constant of the resulting value.
＠＠ -742,7 +742,7 ＠＠
", and loaded on: "
--temp--))
＠end example
-＠end defspec
+＠end deffn
＠node Function Aliases, , Time of Evaluation, Program Structure
＠section Function Aliases
＠＠ -869,7 +869,7 ＠＠
error.
＠end defun
-＠defspec deftype name arglist forms...
+＠deffn {Special Operator} deftype name arglist forms...
This macro defines a new type called ＠var{name}. It is similar
to ＠code{defmacro} in many ways; when ＠var{name} is encountered
as a type name, the body ＠var{forms} are evaluated and should
＠＠ -897,7 +897,7 ＠＠
The last example shows how the Common Lisp ＠code{unsigned-byte}
type specifier could be implemented if desired; this package does
not implement ＠code{unsigned-byte} by default.
-＠end defspec
+＠end deffn
The ＠code{typecase} and ＠code{check-type} macros also use type
names. ＠xref{Conditionals}. ＠xref{Assertions}. The ＠code{map},
＠＠ -989,7 +989,7 ＠＠
The ＠code{psetq} form is just like ＠code{setq}, except that multiple
assignments are done in parallel rather than sequentially.
-＠defspec psetq [symbol form]＠dots{}
+＠deffn {Special Operator} psetq [symbol form]＠dots{}
This macro is used to assign to several
variables simultaneously. Given only one ＠var{symbol} and ＠var{form},
it has the same effect as ＠code{setq}. Given several ＠var{symbol}
＠＠ -1017,7 +1017,7 ＠＠
＠pxref{Modify Macros}.)
＠code{psetq} always returns ＠code{nil}.
-＠end defspec
+＠end deffn
＠node Generalized Variables, Variable Bindings, Assignment, Control Structure
＠section Generalized Variables
＠＠ -1055,7 +1055,7 ＠＠
The ＠code{setf} macro is the most basic way to operate on generalized
variables.
-＠defspec setf [place form]＠dots{}
+＠deffn {Special Operator} setf [place form]＠dots{}
This macro evaluates ＠var{form} and stores it in ＠var{place}, which
must be a valid generalized variable form. If there are several
＠var{place} and ＠var{form} pairs, the assignments are done sequentially
＠＠ -1218,7 +1218,7 ＠＠
the form ＠code{(setf (wrong-order ＠var{a} ＠var{b}) 17)} will
evaluate ＠var{b} first, then ＠var{a}, just as in an actual call
to ＠code{wrong-order}.
-＠end defspec
+＠end deffn
＠node Modify Macros, Customizing Setf, Basic Setf, Generalized Variables
＠subsection Modify Macros
＠＠ -1228,15 +1228,15 ＠＠
that operate on generalized variables. Many are interesting and
useful even when the ＠var{place} is just a variable name.
-＠defspec psetf [place form]＠dots{}
+＠deffn {Special Operator} psetf [place form]＠dots{}
This macro is to ＠code{setf} what ＠code{psetq} is to ＠code{setq}:
When several ＠var{place}s and ＠var{form}s are involved, the
assignments take place in parallel rather than sequentially.
Specifically, all subforms are evaluated from left to right, then
all the assignments are done (in an undefined order).
-＠end defspec
-
-＠defspec incf place &optional x
+＠end deffn
+
+＠deffn {Special Operator} incf place &optional x
This macro increments the number stored in ＠var{place} by one, or
by ＠var{x} if specified. The incremented value is returned. For
example, ＠code{(incf i)} is equivalent to ＠code{(setq i (1+ i))}, and
＠＠ -1274,35 +1274,35 ＠＠
As a more Emacs-specific example of ＠code{incf}, the expression
＠code{(incf (point) ＠var{n})} is essentially equivalent to
＠code{(forward-char ＠var{n})}.
-＠end defspec
-
-＠defspec decf place &optional x
+＠end deffn
+
+＠deffn {Special Operator} decf place &optional x
This macro decrements the number stored in ＠var{place} by one, or
by ＠var{x} if specified.
-＠end defspec
-
-＠defspec pop place
+＠end deffn
+
+＠deffn {Special Operator} pop place
This macro removes and returns the first element of the list stored
in ＠var{place}. It is analogous to ＠code{(prog1 (car ＠var{place})
(setf ＠var{place} (cdr ＠var{place})))}, except that it takes care
to evaluate all subforms only once.
-＠end defspec
-
-＠defspec push x place
+＠end deffn
+
+＠deffn {Special Operator} push x place
This macro inserts ＠var{x} at the front of the list stored in
＠var{place}. It is analogous to ＠code{(setf ＠var{place} (cons
＠var{x} ＠var{place}))}, except for evaluation of the subforms.
-＠end defspec
-
-＠defspec pushnew x place ＠t{&key :test :test-not :key}
+＠end deffn
+
+＠deffn {Special Operator} pushnew x place ＠t{&key :test :test-not :key}
This macro inserts ＠var{x} at the front of the list stored in
＠var{place}, but only if ＠var{x} was not ＠code{eql} to any
existing element of the list. The optional keyword arguments
are interpreted in the same way as for ＠code{adjoin}.
＠xref{Lists as Sets}.
-＠end defspec
-
-＠defspec shiftf place＠dots{} newvalue
+＠end deffn
+
+＠deffn {Special Operator} shiftf place＠dots{} newvalue
This macro shifts the ＠var{place}s left by one, shifting in the
value of ＠var{newvalue} (which may be any Lisp expression, not just
a generalized variable), and returning the value shifted out of
＠＠ -1320,9 +1320,9 ＠＠
＠noindent
except that the subforms of ＠var{a}, ＠var{b}, and ＠var{c} are actually
evaluated only once each and in the apparent order.
-＠end defspec
-
-＠defspec rotatef place＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} rotatef place＠dots{}
This macro rotates the ＠var{place}s left by one in circular fashion.
Thus, ＠code{(rotatef ＠var{a} ＠var{b} ＠var{c} ＠var{d})} is equivalent to
＠＠ -1337,12 +1337,12 ＠＠
except for the evaluation of subforms. ＠code{rotatef} always
returns ＠code{nil}. Note that ＠code{(rotatef ＠var{a} ＠var{b})}
conveniently exchanges ＠var{a} and ＠var{b}.
-＠end defspec
+＠end deffn
The following macros were invented for this package; they have no
analogues in Common Lisp.
-＠defspec letf (bindings＠dots{}) forms＠dots{}
+＠deffn {Special Operator} letf (bindings＠dots{}) forms＠dots{}
This macro is analogous to ＠code{let}, but for generalized variables
rather than just symbols. Each ＠var{binding} should be of the form
＠code{(＠var{place} ＠var{value})}; the original contents of the
＠＠ -1392,14 +1392,14 ＠＠
variables and calls to ＠code{symbol-value} and ＠code{symbol-function}.
If the symbol is not bound on entry, it is simply made unbound by
＠code{makunbound} or ＠code{fmakunbound} on exit.
-＠end defspec
-
-＠defspec letf* (bindings＠dots{}) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} letf* (bindings＠dots{}) forms＠dots{}
This macro is to ＠code{letf} what ＠code{let*} is to ＠code{let}:
It does the bindings in sequential rather than parallel order.
-＠end defspec
-
-＠defspec callf ＠var{function} ＠var{place} ＠var{args}＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} callf ＠var{function} ＠var{place} ＠var{args}＠dots{}
This is the ``generic'' modify macro. It calls ＠var{function},
which should be an unquoted function name, macro name, or lambda.
It passes ＠var{place} and ＠var{args} as arguments, and assigns the
＠＠ -1416,14 +1416,14 ＠＠
＠xref{Customizing Setf}, for ＠code{define-modify-macro}, a way
to create even more concise notations for modify macros. Note
again that ＠code{callf} is an extension to standard Common Lisp.
-＠end defspec
-
-＠defspec callf2 ＠var{function} ＠var{arg1} ＠var{place} ＠var{args}＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} callf2 ＠var{function} ＠var{arg1} ＠var{place} ＠var{args}＠dots{}
This macro is like ＠code{callf}, except that ＠var{place} is
the ＠emph{second} argument of ＠var{function} rather than the
first. For example, ＠code{(push ＠var{x} ＠var{place})} is
equivalent to ＠code{(callf2 cons ＠var{x} ＠var{place})}.
-＠end defspec
+＠end deffn
The ＠code{callf} and ＠code{callf2} macros serve as building
blocks for other macros like ＠code{incf}, ＠code{pushnew}, and
＠＠ -1439,7 +1439,7 ＠＠
＠code{defsetf}, and ＠code{define-setf-method}, that allow the
user to extend generalized variables in various ways.
-＠defspec define-modify-macro name arglist function [doc-string]
+＠deffn {Special Operator} define-modify-macro name arglist function [doc-string]
This macro defines a ``read-modify-write'' macro similar to
＠code{incf} and ＠code{decf}. The macro ＠var{name} is defined
to take a ＠var{place} argument followed by additional arguments
＠＠ -1480,9 +1480,9 ＠＠
using ＠code{get-setf-method}, or consult the source file
＠file{cl-macs.el} to see how to use the internal ＠code{setf}
building blocks.
-＠end defspec
-
-＠defspec defsetf access-fn update-fn
+＠end deffn
+
+＠deffn {Special Operator} defsetf access-fn update-fn
This is the simpler of two ＠code{defsetf} forms. Where
＠var{access-fn} is the name of a function which accesses a place,
this declares ＠var{update-fn} to be the corresponding store
＠＠ -1525,9 +1525,9 ＠＠
(defsetf symbol-value set)
(defsetf buffer-name rename-buffer t)
＠end example
-＠end defspec
-
-＠defspec defsetf access-fn arglist (store-var) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} defsetf access-fn arglist (store-var) forms＠dots{}
This is the second, more complex, form of ＠code{defsetf}. It is
rather like ＠code{defmacro} except for the additional ＠var{store-var}
argument. The ＠var{forms} should return a Lisp form which stores
＠＠ -1556,9 +1556,9 ＠＠
(defsetf nth (n x) (store)
(list 'setcar (list 'nthcdr n x) store))
＠end example
-＠end defspec
-
-＠defspec define-setf-method access-fn arglist forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} define-setf-method access-fn arglist forms＠dots{}
This is the most general way to create new place forms. When
a ＠code{setf} to ＠var{access-fn} with arguments described by
＠var{arglist} is expanded, the ＠var{forms} are evaluated and
＠＠ -1603,7 +1603,7 ＠＠
use this setf-method will optimize away most temporaries that
turn out to be unnecessary, so there is little reason for the
setf-method itself to optimize.
-＠end defspec
+＠end deffn
＠defun get-setf-method place &optional env
This function returns the setf-method for ＠var{place}, by
＠＠ -1669,7 +1669,7 ＠＠
at compile-time. The ＠code{progv} form provides an easy way to
bind variables whose names are computed at run-time.
-＠defspec progv symbols values forms＠dots{}
+＠deffn {Special Operator} progv symbols values forms＠dots{}
This form establishes ＠code{let}-style variable bindings on a
set of variables computed at run-time. The expressions
＠var{symbols} and ＠var{values} are evaluated, and must return lists
＠＠ -1679,7 +1679,7 ＠＠
are made unbound (as if by ＠code{makunbound}) inside the body.
If ＠var{symbols} is shorter than ＠var{values}, the excess values
are ignored.
-＠end defspec
+＠end deffn
＠node Lexical Bindings, Function Bindings, Dynamic Bindings, Variable Bindings
＠subsection Lexical Bindings
＠＠ -1688,7 +1688,7 ＠＠
The ＠dfn{CL} package defines the following macro which
more closely follows the Common Lisp ＠code{let} form:
-＠defspec lexical-let (bindings＠dots{}) forms＠dots{}
+＠deffn {Special Operator} lexical-let (bindings＠dots{}) forms＠dots{}
This form is exactly like ＠code{let} except that the bindings it
establishes are purely lexical. Lexical bindings are similar to
local variables in a language like C: Only the code physically
＠＠ -1788,12 +1788,12 ＠＠
The ＠code{lexical-let} form is an extension to Common Lisp. In
true Common Lisp, all bindings are lexical unless declared otherwise.
-＠end defspec
-
-＠defspec lexical-let* (bindings＠dots{}) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} lexical-let* (bindings＠dots{}) forms＠dots{}
This form is just like ＠code{lexical-let}, except that the bindings
are made sequentially in the manner of ＠code{let*}.
-＠end defspec
+＠end deffn
＠node Function Bindings, Macro Bindings, Lexical Bindings, Variable Bindings
＠subsection Function Bindings
＠＠ -1802,7 +1802,7 ＠＠
These forms make ＠code{let}-like bindings to functions instead
of variables.
-＠defspec flet (bindings＠dots{}) forms＠dots{}
+＠deffn {Special Operator} flet (bindings＠dots{}) forms＠dots{}
This form establishes ＠code{let}-style bindings on the function
cells of symbols rather than on the value cells. Each ＠var{binding}
must be a list of the form ＠samp{(＠var{name} ＠var{arglist}
＠＠ -1841,14 +1841,14 ＠＠
argument notation supported by ＠code{defun*}; also, the function
body is enclosed in an implicit block as if by ＠code{defun*}.
＠xref{Program Structure}.
-＠end defspec
-
-＠defspec labels (bindings＠dots{}) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} labels (bindings＠dots{}) forms＠dots{}
The ＠code{labels} form is a synonym for ＠code{flet}. (In Common
Lisp, ＠code{labels} and ＠code{flet} differ in ways that depend on
their lexical scoping; these distinctions vanish in dynamically
scoped Emacs Lisp.)
-＠end defspec
+＠end deffn
＠node Macro Bindings, , Function Bindings, Variable Bindings
＠subsection Macro Bindings
＠＠ -1856,7 +1856,7 ＠＠
＠noindent
These forms create local macros and ``symbol macros.''
-＠defspec macrolet (bindings＠dots{}) forms＠dots{}
+＠deffn {Special Operator} macrolet (bindings＠dots{}) forms＠dots{}
This form is analogous to ＠code{flet}, but for macros instead of
functions. Each ＠var{binding} is a list of the same form as the
arguments to ＠code{defmacro*} (i.e., a macro name, argument list,
＠＠ -1868,9 +1868,9 ＠＠
affect only calls that appear physically within the body
＠var{forms}, possibly after expansion of other macros in the
body.
-＠end defspec
-
-＠defspec symbol-macrolet (bindings＠dots{}) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} symbol-macrolet (bindings＠dots{}) forms＠dots{}
This form creates ＠dfn{symbol macros}, which are macros that look
like variable references rather than function calls. Each
＠var{binding} is a list ＠samp{(＠var{var} ＠var{expansion})};
＠＠ -1935,7 +1935,7 ＠＠
＠xref{Loop Facility}, for a description of the ＠code{loop} macro.
This package defines a nonstandard ＠code{in-ref} loop clause that
works much like ＠code{my-dolist}.
-＠end defspec
+＠end deffn
＠node Conditionals, Blocks and Exits, Variable Bindings, Control Structure
＠section Conditionals
＠＠ -1944,7 +1944,7 ＠＠
These conditional forms augment Emacs Lisp's simple ＠code{if},
＠code{and}, ＠code{or}, and ＠code{cond} forms.
-＠defspec when test forms＠dots{}
+＠deffn {Special Operator} when test forms＠dots{}
This is a variant of ＠code{if} where there are no ``else'' forms,
and possibly several ``then'' forms. In particular,
＠＠ -1958,9 +1958,9 ＠＠
＠example
(if ＠var{test} (progn ＠var{a} ＠var{b} ＠var{c}) nil)
＠end example
-＠end defspec
-
-＠defspec unless test forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} unless test forms＠dots{}
This is a variant of ＠code{if} where there are no ``then'' forms,
and possibly several ``else'' forms:
＠＠ -1974,9 +1974,9 ＠＠
＠example
(when (not ＠var{test}) ＠var{a} ＠var{b} ＠var{c})
＠end example
-＠end defspec
-
-＠defspec case keyform clause＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} case keyform clause＠dots{}
This macro evaluates ＠var{keyform}, then compares it with the key
values listed in the various ＠var{clause}s. Whichever clause matches
the key is executed; comparison is done by ＠code{eql}. If no clause
＠＠ -2010,15 +2010,15 ＠＠
((?\r ?\n) (do-ret-thing))
(t (do-other-thing)))
＠end example
-＠end defspec
-
-＠defspec ecase keyform clause＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} ecase keyform clause＠dots{}
This macro is just like ＠code{case}, except that if the key does
not match any of the clauses, an error is signalled rather than
simply returning ＠code{nil}.
-＠end defspec
-
-＠defspec typecase keyform clause＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} typecase keyform clause＠dots{}
This macro is a version of ＠code{case} that checks for types
rather than values. Each ＠var{clause} is of the form
＠samp{(＠var{type} ＠var{body}...)}. ＠xref{Type Predicates},
＠＠ -2035,13 +2035,13 ＠＠
The type specifier ＠code{t} matches any type of object; the word
＠code{otherwise} is also allowed. To make one clause match any of
several types, use an ＠code{(or ...)} type specifier.
-＠end defspec
-
-＠defspec etypecase keyform clause＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} etypecase keyform clause＠dots{}
This macro is just like ＠code{typecase}, except that if the key does
not match any of the clauses, an error is signalled rather than
simply returning ＠code{nil}.
-＠end defspec
+＠end deffn
＠node Blocks and Exits, Iteration, Conditionals, Control Structure
＠section Blocks and Exits
＠＠ -2054,7 +2054,7 ＠＠
optimizing byte-compiler to omit the costly ＠code{catch} step if the
body of the block does not actually ＠code{return-from} the block.
-＠defspec block name forms＠dots{}
+＠deffn {Special Operator} block name forms＠dots{}
The ＠var{forms} are evaluated as if by a ＠code{progn}. However,
if any of the ＠var{forms} execute ＠code{(return-from ＠var{name})},
they will jump out and return directly from the ＠code{block} form.
＠＠ -2093,20 +2093,20 ＠＠
that jump to it. This means that ＠code{do} loops and ＠code{defun*}
functions which don't use ＠code{return} don't pay the overhead to
support it.
-＠end defspec
-
-＠defspec return-from name [result]
+＠end deffn
+
+＠deffn {Special Operator} return-from name [result]
This macro returns from the block named ＠var{name}, which must be
an (unevaluated) symbol. If a ＠var{result} form is specified, it
is evaluated to produce the result returned from the ＠code{block}.
Otherwise, ＠code{nil} is returned.
-＠end defspec
-
-＠defspec return [result]
+＠end deffn
+
+＠deffn {Special Operator} return [result]
This macro is exactly like ＠code{(return-from nil ＠var{result})}.
Common Lisp loops like ＠code{do} and ＠code{dolist} implicitly enclose
themselves in ＠code{nil} blocks.
-＠end defspec
+＠end deffn
＠node Iteration, Loop Facility, Blocks and Exits, Control Structure
＠section Iteration
＠＠ -2116,7 +2116,7 ＠＠
looping constructs to complement Emacs Lisp's basic ＠code{while}
loop.
-＠defspec loop forms＠dots{}
+＠deffn {Special Operator} loop forms＠dots{}
The ＠dfn{CL} package supports both the simple, old-style meaning of
＠code{loop} and the extremely powerful and flexible feature known as
the ＠dfn{Loop Facility} or ＠dfn{Loop Macro}. This more advanced
＠＠ -2144,9 +2144,9 ＠＠
(This is not a restriction in practice, since a plain symbol
in the above notation would simply access and throw away the
value of a variable.)
-＠end defspec
-
-＠defspec do (spec＠dots{}) (end-test [result＠dots{}]) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} do (spec＠dots{}) (end-test [result＠dots{}]) forms＠dots{}
This macro creates a general iterative loop. Each ＠var{spec} is
of the form
＠＠ -2192,9 +2192,9 ＠＠
((or (null x) (null y))
(nreverse z)))
＠end example
-＠end defspec
-
-＠defspec do* (spec＠dots{}) (end-test [result＠dots{}]) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} do* (spec＠dots{}) (end-test [result＠dots{}]) forms＠dots{}
This is to ＠code{do} what ＠code{let*} is to ＠code{let}. In
particular, the initial values are bound as if by ＠code{let*}
rather than ＠code{let}, and the steps are assigned as if by
＠＠ -2212,18 +2212,18 ＠＠
(nreverse z))
(push (f x y) z))
＠end example
-＠end defspec
-
-＠defspec dolist (var list [result]) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} dolist (var list [result]) forms＠dots{}
This is a more specialized loop which iterates across the elements
of a list. ＠var{list} should evaluate to a list; the body ＠var{forms}
are executed with ＠var{var} bound to each element of the list in
turn. Finally, the ＠var{result} form (or ＠code{nil}) is evaluated
with ＠var{var} bound to ＠code{nil} to produce the result returned by
the loop. The loop is surrounded by an implicit ＠code{nil} block.
-＠end defspec
-
-＠defspec dotimes (var count [result]) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} dotimes (var count [result]) forms＠dots{}
This is a more specialized loop which iterates a specified number
of times. The body is executed with ＠var{var} bound to the integers
from zero (inclusive) to ＠var{count} (exclusive), in turn. Then
＠＠ -2231,9 +2231,9 ＠＠
number of iterations that were done (i.e., ＠code{(max 0 ＠var{count})})
to get the return value for the loop form. The loop is surrounded
by an implicit ＠code{nil} block.
-＠end defspec
-
-＠defspec do-symbols (var [obarray [result]]) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} do-symbols (var [obarray [result]]) forms＠dots{}
This loop iterates over all interned symbols. If ＠var{obarray}
is specified and is not ＠code{nil}, it loops over all symbols in
that obarray. For each symbol, the body ＠var{forms} are evaluated
＠＠ -2241,12 +2241,12 ＠＠
an unspecified order. Afterward the ＠var{result} form, if any,
is evaluated (with ＠var{var} bound to ＠code{nil}) to get the return
value. The loop is surrounded by an implicit ＠code{nil} block.
-＠end defspec
-
-＠defspec do-all-symbols (var [result]) forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} do-all-symbols (var [result]) forms＠dots{}
This is identical to ＠code{do-symbols} except that the ＠var{obarray}
argument is omitted; it always iterates over the default obarray.
-＠end defspec
+＠end deffn
＠xref{Mapping over Sequences}, for some more functions for
iterating over vectors or lists.
＠＠ -2286,7 +2286,7 ＠＠
takes place at byte-compile time; compiled ＠code{loop}s are just
as efficient as the equivalent ＠code{while} loops written longhand.
-＠defspec loop clauses＠dots{}
+＠deffn {Special Operator} loop clauses＠dots{}
A loop construct consists of a series of ＠var{clause}s, each
introduced by a symbol like ＠code{for} or ＠code{do}. Clauses
are simply strung together in the argument list of ＠code{loop},
＠＠ -2325,7 +2325,7 ＠＠
(Because the loop body is enclosed in an implicit block, you can
also use regular Lisp ＠code{return} or ＠code{return-from} to
break out of the loop.)
-＠end defspec
+＠end deffn
The following sections give some examples of the Loop Macro in
action, and describe the particular loop clauses in great detail.
＠＠ -3003,7 +3003,7 ＠＠
Destructuring is made available to the user by way of the
following macro:
-＠defspec destructuring-bind arglist expr forms＠dots{}
+＠deffn {Special Operator} destructuring-bind arglist expr forms＠dots{}
This macro expands to code which executes ＠var{forms}, with
the variables in ＠var{arglist} bound to the list of values
returned by ＠var{expr}. The ＠var{arglist} can include all
＠＠ -3012,13 +3012,13 ＠＠
is not allowed.) The macro expansion will signal an error
if ＠var{expr} returns a list of the wrong number of arguments
or with incorrect keyword arguments.
-＠end defspec
+＠end deffn
This package also includes the Common Lisp ＠code{define-compiler-macro}
facility, which allows you to define compile-time expansions and
optimizations for your functions.
-＠defspec define-compiler-macro name arglist forms＠dots{}
+＠deffn {Special Operator} define-compiler-macro name arglist forms＠dots{}
This form is similar to ＠code{defmacro}, except that it only expands
calls to ＠var{name} at compile-time; calls processed by the Lisp
interpreter are not expanded, nor are they expanded by the
＠＠ -3052,7 +3052,7 ＠＠
＠code{member*} call is left intact. (The actual compiler macro
for ＠code{member*} optimizes a number of other cases, including
common ＠code{:test} predicates.)
-＠end defspec
+＠end deffn
＠defun compiler-macroexpand form
This function is analogous to ＠code{macroexpand}, except that it
＠＠ -3094,7 +3094,7 ＠＠
is evaluated and thus should normally be quoted.
＠end defun
-＠defspec declaim decl-specs＠dots{}
+＠deffn {Special Operator} declaim decl-specs＠dots{}
This macro is like ＠code{proclaim}, except that it takes any number
of ＠var{decl-spec} arguments, and the arguments are unevaluated and
unquoted. The ＠code{declaim} macro also puts an ＠code{(eval-when
＠＠ -3103,22 +3103,22 ＠＠
since normally the declarations are meant to influence the way the
compiler treats the rest of the file that contains the ＠code{declaim}
form.)
-＠end defspec
-
-＠defspec declare decl-specs＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} declare decl-specs＠dots{}
This macro is used to make declarations within functions and other
code. Common Lisp allows declarations in various locations, generally
at the beginning of any of the many ``implicit ＠code{progn}s''
throughout Lisp syntax, such as function bodies, ＠code{let} bodies,
etc. Currently the only declaration understood by ＠code{declare}
is ＠code{special}.
-＠end defspec
-
-＠defspec locally declarations＠dots{} forms＠dots{}
+＠end deffn
+
+＠deffn {Special Operator} locally declarations＠dots{} forms＠dots{}
In this package, ＠code{locally} is no different from ＠code{progn}.
-＠end defspec
-
-＠defspec the type form
+＠end deffn
+
+＠deffn {Special Operator} the type form
Type information provided by ＠code{the} is ignored in this package;
in other words, ＠code{(the ＠var{type} ＠var{form})} is equivalent
to ＠var{form}. Future versions of the optimizing byte-compiler may
＠＠ -3131,7 +3131,7 ＠＠
compiler would have enough information to expand the loop in-line.
For now, Emacs Lisp will treat the above code as exactly equivalent
to ＠code{(mapcar 'car foo)}.
-＠end defspec
+＠end deffn
Each ＠var{decl-spec} in a ＠code{proclaim}, ＠code{declaim}, or
＠code{declare} should be a list beginning with a symbol that says
＠＠ -3313,7 +3313,7 ＠＠
expression.
＠end defun
-＠defspec remf place property
+＠deffn {Special Operator} remf place property
This macro removes the property-value pair for ＠var{property} from
the property list stored at ＠var{place}, which is any ＠code{setf}-able
place expression. It returns true if the property was found. Note
＠＠ -3321,7 +3321,7 ＠＠
effectively do a ＠code{(setf ＠var{place} (cddr ＠var{place}))},
whereas if it occurs later, this simply uses ＠code{setcdr} to splice
out the property and value cells.
-＠end defspec
+＠end deffn
＠iftex
＠secno=2
＠＠ -4677,7 +4677,7 ＠＠
implements structures as vectors (or lists upon request) with a
special ``tag'' symbol to identify them.
-＠defspec defstruct name slots＠dots{}
+＠deffn {Special Operator} defstruct name slots＠dots{}
The ＠code{defstruct} form defines a new structure type called
＠var{name}, with the specified ＠var{slots}. (The ＠var{slots}
may begin with a string which documents the structure type.)
＠＠ -4984,7 +4984,7 ＠＠
specifies a number of slots to be skipped between the last slot
of the included type and the first new slot.
＠end table
-＠end defspec
+＠end deffn
Except as noted, the ＠code{defstruct} facility of this package is
entirely compatible with that of Common Lisp.
＠＠ -5007,7 +5007,7 ＠＠
away the following assertions. Because assertions might be optimized
away, it is a bad idea for them to include side-effects.
-＠defspec assert test-form [show-args string args＠dots{}]
+＠deffn {Special Operator} assert test-form [show-args string args＠dots{}]
This form verifies that ＠var{test-form} is true (i.e., evaluates to
a non-＠code{nil} value). If so, it returns ＠code{nil}. If the test
is not satisfied, ＠code{assert} signals an error.
＠＠ -5030,9 +5030,9 ＠＠
true Common Lisp, the second argument gives a list of ＠var{places}
which can be ＠code{setf}'d by the user before continuing from the
error.
-＠end defspec
-
-＠defspec check-type place type &optional string
+＠end deffn
+
+＠deffn {Special Operator} check-type place type &optional string
This form verifies that ＠var{place} evaluates to a value of type
＠var{type}. If so, it returns ＠code{nil}. If not, ＠code{check-type}
signals a continuable ＠code{wrong-type-argument} error. The default
＠＠ -5051,18 +5051,18 ＠＠
should be a ＠var{place} suitable for use by ＠code{setf}, because
＠code{check-type} signals a continuable error that allows the user to
modify ＠var{place}, most simply by returning a value from the debugger.
-＠end defspec
+＠end deffn
The following error-related macro is also defined:
-＠defspec ignore-errors forms＠dots{}
+＠deffn {Special Operator} ignore-errors forms＠dots{}
This executes ＠var{forms} exactly like a ＠code{progn}, except that
errors are ignored during the ＠var{forms}. More precisely, if
an error is signalled then ＠code{ignore-errors} immediately
aborts execution of the ＠var{forms} and returns ＠code{nil}.
If the ＠var{forms} complete successfully, ＠code{ignore-errors}
returns the result of the last ＠var{form}.
-＠end defspec
+＠end deffn
＠node Efficiency Concerns, Common Lisp Compatibility, Assertions, Top
＠appendix Efficiency Concerns
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/commands.texi
--- a/man/lispref/commands.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/commands.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -120,7 +120,7 ＠＠
This section describes how to write the ＠code{interactive} form that
makes a Lisp function an interactively-callable command.
-＠defspec interactive arg-descriptor
+＠deffn {Special Operator} interactive arg-descriptor
＠cindex argument descriptors
This special operator declares that the function in which it appears is a
command, and that it may therefore be called interactively (via
＠＠ -139,7 +139,7 ＠＠
＠code{interactive} form are executed, but at this time
＠code{interactive} simply returns ＠code{nil} without even evaluating its
argument.
-＠end defspec
+＠end deffn
There are three possibilities for the argument ＠var{arg-descriptor}:
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/compile.texi
--- a/man/lispref/compile.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/compile.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -691,7 +691,7 ＠＠
These features permit you to write code to be evaluated during
compilation of a program.
-＠defspec eval-and-compile body
+＠deffn {Special Operator} eval-and-compile body
This form marks ＠var{body} to be evaluated both when you compile the
containing code and when you run it (whether compiled or not).
＠＠ -699,9 +699,9 ＠＠
and referring to that file with ＠code{require}. Using ＠code{require} is
preferable if there is a substantial amount of code to be executed in
this way.
-＠end defspec
+＠end deffn
-＠defspec eval-when-compile body
+＠deffn {Special Operator} eval-when-compile body
This form marks ＠var{body} to be evaluated at compile time and not when
the compiled program is loaded. The result of evaluation by the
compiler becomes a constant which appears in the compiled program. When
＠＠ -712,7 +712,7 ＠＠
＠code{(eval-when (compile eval) ＠dots{})}. Elsewhere, the Common Lisp
＠samp{#.} reader macro (but not when interpreting) is closer to what
＠code{eval-when-compile} does.
-＠end defspec
+＠end deffn
＠node Compiled-Function Objects
＠section Compiled-Function Objects
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/control.texi
--- a/man/lispref/control.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/control.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -76,7 +76,7 ＠＠
needed now most often inside an ＠code{unwind-protect}, ＠code{and},
＠code{or}, or in the ＠var{then}-part of an ＠code{if}.
-＠defspec progn forms＠dots{}
+＠deffn {Special Operator} progn forms＠dots{}
This special operator evaluates all of the ＠var{forms}, in textual
order, returning the result of the final form.
＠＠ -91,12 +91,12 ＠＠
＠result{} "The third form"
＠end group
＠end example
-＠end defspec
+＠end deffn
Two other control constructs likewise evaluate a series of forms but return
a different value:
-＠defspec prog1 form1 forms＠dots{}
+＠deffn {Special Operator} prog1 form1 forms＠dots{}
This special operator evaluates ＠var{form1} and all of the ＠var{forms}, in
textual order, returning the result of ＠var{form1}.
＠＠ -118,9 +118,9 ＠＠
＠example
(prog1 (car x) (setq x (cdr x)))
＠end example
-＠end defspec
+＠end deffn
-＠defspec prog2 form1 form2 forms＠dots{}
+＠deffn {Special Operator} prog2 form1 form2 forms＠dots{}
This special operator evaluates ＠var{form1}, ＠var{form2}, and all of the
following ＠var{forms}, in textual order, returning the result of
＠var{form2}.
＠＠ -136,7 +136,7 ＠＠
＠result{} "The second form"
＠end group
＠end example
-＠end defspec
+＠end deffn
＠node Conditionals
＠section Conditionals
＠＠ -146,7 +146,7 ＠＠
has two conditional forms: ＠code{if}, which is much the same as in other
languages, and ＠code{cond}, which is a generalized case statement.
-＠defspec if condition then-form else-forms＠dots{}
+＠deffn {Special Operator} if condition then-form else-forms＠dots{}
＠code{if} chooses between the ＠var{then-form} and the ＠var{else-forms}
based on the value of ＠var{condition}. If the evaluated ＠var{condition} is
non-＠code{nil}, ＠var{then-form} is evaluated and the result returned.
＠＠ -169,9 +169,9 ＠＠
＠result{} very-false
＠end group
＠end example
-＠end defspec
+＠end deffn
-＠defspec cond clause＠dots{}
+＠deffn {Special Operator} cond clause＠dots{}
＠code{cond} chooses among an arbitrary number of alternatives. Each
＠var{clause} in the ＠code{cond} must be a list. The ＠sc{car} of this
list is the ＠var{condition}; the remaining elements, if any, the
＠＠ -239,7 +239,7 ＠＠
＠noindent
This expression is a ＠code{cond} which returns ＠code{foo} if the value
of ＠code{a} is 1, and returns the string ＠code{"default"} otherwise.
-＠end defspec
+＠end deffn
Any conditional construct can be expressed with ＠code{cond} or with
＠code{if}. Therefore, the choice between them is a matter of style.
＠＠ -268,7 +268,7 ＠＠
using the name ＠code{null} if you are testing for an empty list.
＠end defun
-＠defspec and conditions＠dots{}
+＠deffn {Special Operator} and conditions＠dots{}
The ＠code{and} special operator tests whether all the ＠var{conditions} are
true. It works by evaluating the ＠var{conditions} one by one in the
order written.
＠＠ -320,9 +320,9 ＠＠
(cond (＠var{arg1} (cond (＠var{arg2} ＠var{arg3}))))
＠end group
＠end example
-＠end defspec
+＠end deffn
-＠defspec or conditions＠dots{}
+＠deffn {Special Operator} or conditions＠dots{}
The ＠code{or} special operator tests whether at least one of the
＠var{conditions} is true. It works by evaluating all the
＠var{conditions} one by one in the order written.
＠＠ -369,7 +369,7 ＠＠
This is not completely equivalent because it can evaluate ＠var{arg1} or
＠var{arg2} twice. By contrast, ＠code{(or ＠var{arg1} ＠var{arg2}
＠var{arg3})} never evaluates any argument more than once.
-＠end defspec
+＠end deffn
＠node Iteration
＠section Iteration
＠＠ -381,7 +381,7 ＠＠
of a list, or once for each integer from 0 to ＠var{n}. You can do this
in XEmacs Lisp with the special operator ＠code{while}:
-＠defspec while condition forms＠dots{}
+＠deffn {Special Operator} while condition forms＠dots{}
＠code{while} first evaluates ＠var{condition}. If the result is
non-＠code{nil}, it evaluates ＠var{forms} in textual order. Then it
reevaluates ＠var{condition}, and if the result is non-＠code{nil}, it
＠＠ -427,7 +427,7 ＠＠
This moves forward one line and continues moving by lines until it
reaches an empty. It is unusual in that the ＠code{while} has no body,
just the end test (which also does the real work of moving point).
-＠end defspec
+＠end deffn
＠node Nonlocal Exits
＠section Nonlocal Exits
＠＠ -499,15 +499,7 ＠＠
＠code{throw} can be used in commands such as ＠code{exit-recursive-edit}
that throw back to the editor command loop (＠pxref{Recursive Editing}).
-＠cindex CL note---only ＠code{throw} in Emacs
-＠quotation
-＠b{Common Lisp note:} Most other versions of Lisp, including Common Lisp,
-have several ways of transferring control nonsequentially: ＠code{return},
-＠code{return-from}, and ＠code{go}, for example. XEmacs Lisp has only
-＠code{throw}.
-＠end quotation
-
-＠defspec catch tag body＠dots{}
+＠deffn {Special Operator} catch tag body＠dots{}
＠cindex tag on run time stack
＠code{catch} establishes a return point for the ＠code{throw} function. The
return point is distinguished from other such return points by ＠var{tag},
＠＠ -522,7 +514,7 ＠＠
If a ＠code{throw} is done within ＠var{body} specifying the same value
＠var{tag}, the ＠code{catch} exits immediately; the value it returns is
whatever was specified as the second argument of ＠code{throw}.
-＠end defspec
+＠end deffn
＠defun throw tag value
The purpose of ＠code{throw} is to return from a return point previously
＠＠ -1028,7 +1020,7 ＠＠
by an error handler (though using ＠code{throw} when there is no suitable
＠code{catch} signals an error that can be handled).
-＠defspec condition-case var protected-form handlers＠dots{}
+＠deffn {Special Operator} condition-case var protected-form handlers＠dots{}
This special operator establishes the error handlers ＠var{handlers} around
the execution of ＠var{protected-form}. If ＠var{protected-form} executes
without error, the value it returns becomes the value of the
＠＠ -1077,7 +1069,7 ＠＠
If ＠var{var} is ＠code{nil}, that means no variable is bound. Then the
error symbol and associated data are not available to the handler.
-＠end defspec
+＠end deffn
＠cindex ＠code{arith-error} example
Here is an example of using ＠code{condition-case} to handle the error
＠＠ -1252,7 +1244,7 ＠＠
temporarily put a data structure in an inconsistent state; it permits
you to ensure the data are consistent in the event of an error or throw.
-＠defspec unwind-protect body cleanup-forms＠dots{}
+＠deffn {Special Operator} unwind-protect body cleanup-forms＠dots{}
＠cindex cleanup forms
＠cindex protected forms
＠cindex error cleanup
＠＠ -1278,7 +1270,7 ＠＠
The number of currently active ＠code{unwind-protect} forms counts,
together with the number of local variable bindings, against the limit
＠code{max-specpdl-size} (＠pxref{Local Variables}).
-＠end defspec
+＠end deffn
For example, here we make an invisible buffer for temporary use, and
make sure to kill it before finishing:
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/display.texi
--- a/man/lispref/display.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/display.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -720,7 +720,7 ＠＠
and then present it to the user for perusal rather than for editing.
Many of the help commands use this feature.
-＠defspec with-output-to-temp-buffer buffer-name forms＠dots{}
+＠deffn {Special Operator} with-output-to-temp-buffer buffer-name forms＠dots{}
This function executes ＠var{forms} while arranging to insert any
output they print into the buffer named ＠var{buffer-name}. The buffer
is then shown in some window for viewing, displayed but not selected.
＠＠ -760,7 +760,7 ＠＠
---------- Buffer: foo ----------
＠end group
＠end example
-＠end defspec
+＠end deffn
＠defvar temp-buffer-show-function
If this variable is non-＠code{nil}, ＠code{with-output-to-temp-buffer}
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/eval.texi
--- a/man/lispref/eval.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/eval.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -663,9 +663,9 ＠＠
not necessary to quote self-evaluating objects such as numbers, strings,
and vectors.)
-＠defspec quote object
+＠deffn {Special Operator} quote object
This special operator returns ＠var{object}, without evaluating it.
-＠end defspec
+＠end deffn
＠cindex ＠samp{'} for quoting
＠cindex quoting using apostrophe
＠＠ -743,48 +743,48 ＠＠
values.
＠end defun
-＠defspec multiple-value-bind (var＠dots{}) values-form forms＠dots{}
+＠deffn {Special Operator} multiple-value-bind (var＠dots{}) values-form forms＠dots{}
This special operator evaluates ＠var{values-form}, which may return
multiple values. It then binds the ＠var{var}s to these respective values,
as if by ＠code{let}, and then executes the body ＠var{forms}.
If there are more ＠var{var}s than values, the extra ＠var{var}s
are bound to ＠code{nil}. If there are fewer ＠var{var}s than
values, the excess values are ignored.
-＠end defspec
+＠end deffn
-＠defspec multiple-value-setq (var＠dots{}) form
+＠deffn {Special Operator} multiple-value-setq (var＠dots{}) form
This special operator evaluates ＠var{form}, which may return multiple
values. It then sets the ＠var{var}s to these respective values, as if by
＠code{setq}. Extra ＠var{var}s or values are treated the same as
in ＠code{multiple-value-bind}.
-＠end defspec
+＠end deffn
-＠defspec multiple-value-call function forms＠dots{}
+＠deffn {Special Operator} multiple-value-call function forms＠dots{}
This special operator evaluates function, discarding any multiple
values. It then evaluates ＠var{forms}, preserving any multiple values,
and calls ＠var{function} as a function with the results. Conceptually, this
function is a version of ＠code{apply'}that by-passes the multiple values
infrastructure, treating multiple values as intercalated lists.
-＠end defspec
+＠end deffn
-＠defspec multiple-value-list form
+＠deffn {Special Operator} multiple-value-list form
This special operator evaluates ＠var{form} and returns a list of the
multiple values given by it.
-＠end defspec
+＠end deffn
-＠defspec multiple-value-prog1 first body＠dots{}
+＠deffn {Special Operator} multiple-value-prog1 first body＠dots{}
This special operator evaluates the form ＠var{first}, then the
forms ＠var{body}. It returns the value given by ＠var{first}, preserving
any multiple values. This is identical to ＠code{prog1}, except that
＠code{prog1} always discards multiple values.
-＠end defspec
+＠end deffn
-＠defspec nth-value n form
+＠deffn {Special Operator} nth-value n form
This special operator evaluates ＠var{form} and returns the ＠var{n}th
value it gave. ＠var{n} must be an integer of value zero or more.
If ＠var{form} gave insufficient multiple values, ＠code{nth-value}
returns ＠code{nil}.
-＠end defspec
+＠end deffn
＠defvar multiple-values-limit
This constant describes the exclusive upper bound on the number of
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/frames.texi
--- a/man/lispref/frames.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/frames.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -785,18 +785,18 ＠＠
＠code{focus-follows-mouse}.
＠end defun
-＠defspec save-selected-frame forms＠dots{}
+＠deffn {Special Operator} save-selected-frame forms＠dots{}
This special operator records the selected frame, executes ＠var{forms} in
sequence, then restores the earlier selected frame. The value returned
is the value of the last form.
-＠end defspec
+＠end deffn
-＠defspec with-selected-frame frame forms＠dots{}
+＠deffn {Special Operator} with-selected-frame frame forms＠dots{}
This special operator records the selected frame, then selects ＠var{frame}
and executes ＠var{forms} in sequence. After the last form is finished,
the earlier selected frame is restored. The value returned is the value
of the last form.
-＠end defspec
+＠end deffn
＠ignore (FSF Emacs, continued from defun select-frame)
XEmacs cooperates with the X server and the window managers by arranging
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/functions.texi
--- a/man/lispref/functions.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/functions.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -337,8 +337,9 ＠＠
＠cindex CL note---default optional arg
＠quotation
＠b{Common Lisp note:} Common Lisp allows the function to specify what
-default value to use when an optional argument is omitted; XEmacs Lisp
-always uses ＠code{nil}.
+default value to use when an optional argument is omitted; this is
+available in XEmacs Lisp with the ＠code{defun*} macro, an alternative to
+＠code{defun}.
＠end quotation
For example, an argument list that looks like this:
＠＠ -474,7 +475,7 ＠＠
is called ＠dfn{defining a function}, and it is done with the
＠code{defun} special operator.
-＠defspec defun name argument-list body-forms
+＠deffn {Special Operator} defun name argument-list body-forms
＠code{defun} is the usual way to define new Lisp functions. It
defines the symbol ＠var{name} as a function that looks like this:
＠＠ -543,7 +544,7 ＠＠
without any hesitation or notification. Redefining a function already
defined is often done deliberately, and there is no way to distinguish
deliberate redefinition from unintentional redefinition.
-＠end defspec
+＠end deffn
＠defun define-function name definition
＠defunx defalias name definition
＠＠ -833,14 +834,14 ＠＠
In such cases, we usually use the special operator ＠code{function} instead
of simple quotation to quote the anonymous function.
-＠defspec function function-object
+＠deffn {Special Operator} function function-object
＠cindex function quoting
This special operator returns ＠var{function-object} without evaluating it.
In this, it is equivalent to ＠code{quote}. However, it serves as a
note to the XEmacs Lisp compiler that ＠var{function-object} is intended
to be used only as a function, and therefore can safely be compiled.
Contrast this with ＠code{quote}, in ＠ref{Quoting}.
-＠end defspec
+＠end deffn
Using ＠code{function} instead of ＠code{quote} makes a difference
inside a function or macro that you are going to compile. For example:
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/internationalization.texi
--- a/man/lispref/internationalization.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/internationalization.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -83,7 +83,7 ＠＠
nothing.
＠end defun
-＠defspec domain string
+＠deffn {Special Operator} domain string
This function specifies the text domain used for translating documentation
strings and interactive prompts of a function. For example, write:
＠＠ -94,7 +94,7 ＠＠
to specify ＠code{emacs-foo} as the text domain of the function ＠code{foo}.
The ``call'' to ＠code{domain} is actually a declaration rather than a
function; when actually called, ＠code{domain} just returns ＠code{nil}.
-＠end defspec
+＠end deffn
＠defun domain-of function
This function returns the text domain of ＠var{function}; it returns
＠＠ -145,19 +145,19 ＠＠
For variables and constants which have documentation strings, specify the
domain after the documentation.
-＠defspec defvar symbol [value [doc-string [domain]]]
+＠deffn {Special Operator} defvar symbol [value [doc-string [domain]]]
Example:
＠example
(defvar weight 250 "Weight of gorilla, in pounds." "emacs-gorilla")
＠end example
-＠end defspec
+＠end deffn
-＠defspec defconst symbol [value [doc-string [domain]]]
+＠deffn {Special Operator} defconst symbol [value [doc-string [domain]]]
Example:
＠example
(defconst limbs 4 "Number of limbs" "emacs-gorilla")
＠end example
-＠end defspec
+＠end deffn
＠defun autoload function filename &optional docstring interactive type
This function defines ＠var{function} to autoload from ＠var{filename}
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/intro.texi
--- a/man/lispref/intro.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/intro.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -787,7 +787,7 ＠＠
arguments. Parentheses are used when several arguments are grouped into
additional levels of list structure. Here is an example:
-＠defspec count-loop (＠var{var} [＠var{from} ＠var{to} [＠var{inc}]]) ＠var{body}＠dots{}
+＠deffn {Special Operator} count-loop (＠var{var} [＠var{from} ＠var{to} [＠var{inc}]]) ＠var{body}＠dots{}
This imaginary special operator implements a loop that executes the
＠var{body} forms and then increments the variable ＠var{var} on each
iteration. On the first iteration, the variable has the value
＠＠ -817,7 +817,7 ＠＠
＠var{inc} may optionally be specified as well. These arguments are
grouped with the argument ＠var{var} into a list, to distinguish them
from ＠var{body}, which includes all remaining elements of the form.
-＠end defspec
+＠end deffn
＠node A Sample Variable Description
＠subsubsection A Sample Variable Description
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/lists.texi
--- a/man/lispref/lists.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/lists.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -1271,7 +1271,7 ＠＠
＠end example
In the following example, the ＠code{(4)} that ＠code{remove*} attempts to match
-and the ＠code{(4)} in the ＠code{sample-list} are not ＠code{eq}:
+and the ＠code{(4)} in the ＠code{sample-list} are not ＠code{eql}:
＠example
＠group
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/macros.texi
--- a/man/lispref/macros.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/macros.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -212,7 +212,7 ＠＠
In practice, almost all Lisp macros have names, and they are usually
defined with the special operator ＠code{defmacro}.
-＠defspec defmacro name argument-list body-forms＠dots{}
+＠deffn {Special Operator} defmacro name argument-list body-forms＠dots{}
＠code{defmacro} defines the symbol ＠var{name} as a macro that looks
like this:
＠＠ -229,7 +229,7 ＠＠
(＠pxref{Argument List}). Macros may have a documentation string, but
any ＠code{interactive} declaration is ignored since macros cannot be
called interactively.
-＠end defspec
+＠end deffn
＠node Backquote
＠section Backquote
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/positions.texi
--- a/man/lispref/positions.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/positions.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -766,7 +766,7 ＠＠
described elsewhere (see ＠ref{Window Configurations} and ＠pxref{Frame
Configurations}).
-＠defspec save-excursion forms＠dots{}
+＠deffn {Special Operator} save-excursion forms＠dots{}
＠cindex mark excursion
＠cindex point excursion
＠cindex current buffer excursion
＠＠ -810,29 +810,29 ＠＠
(set-marker (mark-marker) old-mark)))
＠end group
＠end example
-＠end defspec
+＠end deffn
-＠defspec save-current-buffer forms＠dots{}
+＠deffn {Special Operator} save-current-buffer forms＠dots{}
This special operator is similar to ＠code{save-excursion} but it only
saves and restores the current buffer. Beginning with XEmacs 20.3,
＠code{save-current-buffer} is a primitive.
-＠end defspec
+＠end deffn
-＠defspec with-current-buffer buffer forms＠dots{}
+＠deffn {Special Operator} with-current-buffer buffer forms＠dots{}
This macro evaluates ＠var{forms} with ＠var{buffer} as the current
buffer. It returns the value of the last form.
-＠end defspec
+＠end deffn
-＠defspec with-temp-file filename forms＠dots{}
+＠deffn {Special Operator} with-temp-file filename forms＠dots{}
This macro creates a new buffer, evaluates ＠var{forms} there, and
writes the buffer to ＠var{filename}. It returns the value of the last form
evaluated.
-＠end defspec
+＠end deffn
-＠defspec save-selected-window forms＠dots{}
+＠deffn {Special Operator} save-selected-window forms＠dots{}
This macro is similar to ＠code{save-excursion} but it saves and
restores the selected window and nothing else.
-＠end defspec
+＠end deffn
＠node Narrowing
＠section Narrowing
＠＠ -893,7 +893,7 ＠＠
＠var{buffer} defaults to the current buffer if omitted.
＠end deffn
-＠defspec save-restriction body＠dots{}
+＠deffn {Special Operator} save-restriction body＠dots{}
This special operator saves the current bounds of the accessible portion,
evaluates the ＠var{body} forms, and finally restores the saved bounds,
thus restoring the same state of narrowing (or absence thereof) formerly
＠＠ -972,4 +972,4 ＠＠
---------- Buffer: foo ----------
＠end group
＠end example
-＠end defspec
+＠end deffn
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/searching.texi
--- a/man/lispref/searching.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/searching.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -1458,10 +1458,10 ＠＠
You can save and restore the match data with ＠code{save-match-data}:
-＠defspec save-match-data body＠dots{}
+＠deffn {Special Operator} save-match-data body＠dots{}
This special operator executes ＠var{body}, saving and restoring the match
data around it.
-＠end defspec
+＠end deffn
Emacs automatically saves and restores the match data when it runs
process filter functions (＠pxref{Filter Functions}) and process
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/sequences.texi
--- a/man/lispref/sequences.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/sequences.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -219,6 +219,44 ＠＠
＠code{nth} (＠pxref{List Elements}).
＠end defun
+＠defun fill sequence object ＠t{&key :start :end}
+This function fills the sequence ＠var{sequence} with ＠var{object}, so
+that each element of ＠var{sequence} between the indices specified by
+＠code{:start} (inclusive) and ＠code{:end} (exclusive), is ＠var{object}.
+It returns ＠var{sequence}.
+
+＠example
+＠group
+(setq a [a b c d e f g])
+ ＠result{} [a b c d e f g]
+(fill a 0 :end 2)
+ ＠result{} [0 0 c d e f g]
+(fill a 0)
+ ＠result{} [0 0 0 0 0 0 0]
+a
+ ＠result{} [0 0 0 0 0 0 0]
+＠end group
+
+＠group
+(setq s "When in the course")
+ ＠result{} "When in the course"
+(fill s ?-)
+ ＠result{} "------------------"
+＠end group
+
+＠group
+(setq bv #*1101)
+ ＠result{} #*1101
+(fill bv 0)
+ ＠result{} #*0000
+＠end group
+＠end example
+
+If ＠var{sequence} is of a type that cannot hold ＠var{object} (
+bit-vector can only hold the integers one or zero, strings can only hold
+characters) a ＠code{wrong-type-argument} error results.
+＠end defun
+
＠node Arrays
＠section Arrays
＠cindex array
＠＠ -380,39 +418,6 ＠＠
＠result{} 0
bv
＠result{} #*1101
-＠end group
-＠end example
-
-If ＠var{array} is a string and ＠var{object} is not a character, a
-＠code{wrong-type-argument} error results.
-＠end defun
-
-＠defun fillarray array object
-This function fills the array ＠var{array} with ＠var{object}, so that
-each element of ＠var{array} is ＠var{object}. It returns ＠var{array}.
-
-＠example
-＠group
-(setq a [a b c d e f g])
- ＠result{} [a b c d e f g]
-(fillarray a 0)
- ＠result{} [0 0 0 0 0 0 0]
-a
- ＠result{} [0 0 0 0 0 0 0]
-＠end group
-
-＠group
-(setq s "When in the course")
- ＠result{} "When in the course"
-(fillarray s ?-)
- ＠result{} "------------------"
-＠end group
-
-＠group
-(setq bv #*1101)
- ＠result{} #*1101
-(fillarray bv 0)
- ＠result{} #*0000
＠end group
＠end example
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/specifiers.texi
--- a/man/lispref/specifiers.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/specifiers.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -875,7 +875,7 ＠＠
＠code{add-spec-list-to-specifier}.
＠end defun
-＠defspec let-specifier specifier-list &rest body
+＠deffn {Special Operator} let-specifier specifier-list &rest body
This macro temporarily adds specifications to specifiers,
evaluates forms in ＠var{body} and restores the specifiers to their
previous states. The specifiers and their temporary specifications are
＠＠ -912,7 +912,7 ＠＠
(let-specifier ((modeline-shadow-thickness 0 (selected-window)))
(sit-for 1))
＠end example
-＠end defspec
+＠end deffn
＠defun set-specifier specifier value &optional locale tag-set how-to-add
This function adds some specifications to ＠var{specifier}. ＠var{value}
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/variables.texi
--- a/man/lispref/variables.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/variables.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -168,7 +168,7 ＠＠
The special operators ＠code{let} and ＠code{let*} exist to create
local bindings.
-＠defspec let (bindings＠dots{}) forms＠dots{}
+＠deffn {Special Operator} let (bindings＠dots{}) forms＠dots{}
This special operator binds variables according to ＠var{bindings} and then
evaluates all of the ＠var{forms} in textual order. The ＠code{let}-form
returns the value of the last form in ＠var{forms}.
＠＠ -196,9 +196,9 ＠＠
＠result{} (1 2)
＠end group
＠end example
-＠end defspec
+＠end deffn
-＠defspec let* (bindings＠dots{}) forms＠dots{}
+＠deffn {Special Operator} let* (bindings＠dots{}) forms＠dots{}
This special operator is like ＠code{let}, but it binds each variable right
after computing its local value, before computing the local value for
the next variable. Therefore, an expression in ＠var{bindings} can
＠＠ -218,7 +218,7 ＠＠
＠result{} (1 1)
＠end group
＠end example
-＠end defspec
+＠end deffn
Here is a complete list of the other facilities that create local
bindings:
＠＠ -403,7 +403,7 ＠＠
files, and override the default values given in the definitions. For
this reason, user options must be defined with ＠code{defvar}.
-＠defspec defvar symbol [value [doc-string]]
+＠deffn {Special Operator} defvar symbol [value [doc-string]]
This special operator defines ＠var{symbol} as a value and initializes it.
The definition informs a person reading your code that ＠var{symbol} is
used as a variable that programs are likely to set or change. It is
＠＠ -491,9 +491,9 ＠＠
The ＠code{defvar} form returns ＠var{symbol}, but it is normally used
at top level in a file where its value does not matter.
-＠end defspec
+＠end deffn
-＠defspec defconst symbol [value [doc-string]]
+＠deffn {Special Operator} defconst symbol [value [doc-string]]
This special operator defines ＠var{symbol} as a value and initializes it.
It informs a person reading your code that ＠var{symbol} has a global
value, established here, that will not normally be changed or locally
＠＠ -530,7 +530,7 ＠＠
＠result{} 3
＠end group
＠end example
-＠end defspec
+＠end deffn
＠defun user-variable-p variable
＠cindex user option
＠＠ -615,7 +615,7 ＠＠
form ＠code{setq}. When you need to compute the choice of variable at
run time, use the function ＠code{set}.
-＠defspec setq [symbol form]＠dots{}
+＠deffn {Special Operator} setq [symbol form]＠dots{}
This special operator is the most common method of changing a variable's
value. Each ＠var{symbol} is given a new value, which is the result of
evaluating the corresponding ＠var{form}. The most-local existing
＠＠ -655,7 +655,7 ＠＠
＠result{} 11
＠end group
＠end example
-＠end defspec
+＠end deffn
＠defun set symbol value
This function sets ＠var{symbol}'s value to ＠var{value}, then returns
＠＠ -1253,7 +1253,7 ＠＠
＠code{symbol-value}.
＠end defun
-＠defspec setq-default symbol value
+＠deffn {Special Operator} setq-default symbol value
This sets the default value of ＠var{symbol} to ＠var{value}. It does not
evaluate ＠var{symbol}, but does evaluate ＠var{value}. The value of the
＠code{setq-default} form is ＠var{value}.
＠＠ -1314,7 +1314,7 ＠＠
＠result{} another-default
＠end group
＠end example
-＠end defspec
+＠end deffn
＠defun set-default symbol value
This function is like ＠code{setq-default}, except that ＠var{symbol} is
diff -r f5a5501814f5 -r 62b9ef1ed4ac man/lispref/windows.texi
--- a/man/lispref/windows.texi Sat Feb 19 11:03:46 2011 +0000
+++ b/man/lispref/windows.texi Tue Mar 01 14:18:45 2011 +0000
＠＠ -442,12 +442,12 ＠＠
＠end example
＠end defun
-＠defspec save-selected-window forms＠dots{}
+＠deffn {Special Operator} save-selected-window forms＠dots{}
This macro records the selected window, executes ＠var{forms} in
sequence, then restores the earlier selected window. It does not save
or restore anything about the sizes, arrangement or contents of windows;
therefore, if the ＠var{forms} change them, the changes are permanent.
-＠end defspec
+＠end deffn
＠cindex finding windows
The following functions choose one of the windows on the screen,
＠＠ -1969,7 +1969,7 ＠＠
＠end example
＠end defun
-＠defspec save-window-excursion forms＠dots{}
+＠deffn {Special Operator} save-window-excursion forms＠dots{}
This macro records the window configuration, executes ＠var{forms}
in sequence, then restores the earlier window configuration. The window
configuration includes the value of point and the portion of the buffer
＠＠ -2005,7 +2005,7 ＠＠
;; ＠r{The frame is now split again.}
＠end group
＠end example
-＠end defspec
+＠end deffn
＠defun window-configuration-p object
This function returns ＠code{t} if ＠var{object} is a window configuration.
_______________________________________________
XEmacs-Patches mailing list
XEmacs-Patches(a)xemacs.org
http://lists.xemacs.org/mailman/listinfo/xemacs-patches
- 1 participants
- 0 comments