procyberian/emacs
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Trailing whitepace deleted.

Browse source
This commit is contained in:
Juanma Barranquero 2003-02-04 13:24:35 +00:00
parent f1180544bb
commit a1506d2977
271 changed files with 3408 additions and 3408 deletions
Download patch file Download diff file Expand all files Collapse all files

16
lisp/emacs-lisp/authors.el
View file

@ -92,7 +92,7 @@ files.")
("Per Abrahamsen" "Per Abhiddenware")
("Peter S. Galbraith" "Peter S Galbraith")
("Richard M. Stallman" "Richard M. Stallman,,," "Richard Stallman"
"rms" "rms@gnu.org")
"rms" "rms@gnu.org")
("Robert J. Chassell" "Bob Chassell")
("Roland B. Roberts" "Roland B Roberts" "Roland Roberts")
("Rui-Tao Dong" "Rui-Tao Dong ~{6-Hpln~}")
@ -110,7 +110,7 @@ files.")
"Alist of author aliases.
Each entry is of the form (REALNAME REGEXP...). If an author's name
matches one of the REGEXPs, use REALNAME instead.
matches one of the REGEXPs, use REALNAME instead.
If REALNAME is nil, ignore that author.")
@ -321,7 +321,7 @@ the file name."
(setq authors-checked-files-alist
(cons (cons file valid) authors-checked-files-alist))
(unless valid
(setq authors-invalid-file-names
(setq authors-invalid-file-names
(cons (format "%s:%d: unrecognized `%s' for %s"
log-file
(1+ (count-lines (point-min) pos))
@ -510,7 +510,7 @@ TABLE is a hash table to add author information to."
CHANGES is an alist of entries (FILE (ACTION . COUNT) ...), as produced by
`authors-scan-change-log'.
The element added to `authors-author-list' is (AUTHOR WROTE CHANGED), where
WROTE and CHANGED are lists of the files written and changed by AUTHOR."
WROTE and CHANGED are lists of the files written and changed by AUTHOR."
(when author
(let ((nchanged 0)
wrote-list
@ -549,7 +549,7 @@ WROTE and CHANGED are lists of the files written and changed by AUTHOR."
(defun authors (root)
"Extract author information from change logs and Lisp source files.
ROOT is the root directory under which to find the files. If called
interactively, ROOT is read from the minibuffer.
interactively, ROOT is read from the minibuffer.
Result is a buffer *Authors* containing authorship information, and a
buffer *Authors Errors* containing references to unknown files."
(interactive "DEmacs source directory: ")
@ -575,14 +575,14 @@ buffer *Authors Errors* containing references to unknown files."
(set-buffer (get-buffer-create buffer-name))
(erase-buffer)
(set-buffer-file-coding-system authors-coding-system)
(insert
(insert
"Many people have contributed code included in the Free Software
Foundation's distribution of GNU Emacs. To show our appreciation for
their public spirit, we list here in alphabetical order a condensed
list of their contributions.\n")
(let (authors-author-list a)
(maphash #'authors-add-to-author-list table)
(setq authors-author-list
(setq authors-author-list
(sort authors-author-list
(lambda (a b) (string-lessp (car a) (car b)))))
(dolist (a authors-author-list)
@ -607,7 +607,7 @@ list of their contributions.\n")
(insert "\n "))
(insert " " file))
(insert "\n")))))
(insert "\nLocal" " Variables:\ncoding: "
(insert "\nLocal" " Variables:\ncoding: "
(symbol-name authors-coding-system) "\nEnd:\n")
(message "Generating buffer %s... done" buffer-name)
(unless noninteractive

2
lisp/emacs-lisp/autoload.el
View file

@ -318,7 +318,7 @@ are used."
(setq autoload form))
(let ((autoload-print-form-outbuf outbuf))
(autoload-print-form autoload)))
;; Copy the rest of the line to the output.
(princ (buffer-substring
(progn

4
lisp/emacs-lisp/backquote.el
View file

@ -142,7 +142,7 @@ Vectors work just like lists. Nested backquotes are permitted."
;; Scan this list-level, setting LISTS to a list of forms,
;; each of which produces a list of elements
;; that should go in this level.
;; The order of LISTS is backwards.
;; The order of LISTS is backwards.
;; If there are non-splicing elements (constant or variable)
;; at the beginning, put them in FIRSTLIST,
;; as a list of tagged values (TAG . FORM).
@ -172,7 +172,7 @@ Vectors work just like lists. Nested backquotes are permitted."
(if (or rest list)
(setq lists (cons (backquote-listify list (backquote-process rest))
lists)))
;; Turn LISTS into a form that produces the combined list.
;; Turn LISTS into a form that produces the combined list.
(setq expression
(if (or (cdr lists)
(eq (car-safe (car lists)) backquote-splice-symbol))

44
lisp/emacs-lisp/bindat.el
View file

@ -33,22 +33,22 @@
;; and encoding binary data formats like these is made simple using a
;; structure specification which closely resembles the C style
;; structure declarations.
;;
;;
;; Encoded (binary) data is stored in a unibyte string or vector,
;; while the decoded data is stored in an alist with (FIELD . VALUE)
;; while the decoded data is stored in an alist with (FIELD . VALUE)
;; pairs.
;; Example:
;; Consider the following C structures:
;;
;;
;; struct header {
;; unsigned long dest_ip;
;; unsigned long src_ip;
;; unsigned short dest_port;
;; unsigned short src_port;
;; };
;;
;;
;; struct data {
;; unsigned char type;
;; unsigned char opcode;
@ -56,22 +56,22 @@
;; unsigned char id[8]; /* nul-terminated string */
;; unsigned char data[/* (length + 3) & ~3 */];
;; };
;;
;;
;; struct packet {
;; struct header header;
;; unsigned char items;
;; unsigned char filler[3];
;; struct data item[/* items */];
;; };
;;
;;
;; The corresponding Lisp bindat specification looks like this:
;;
;;
;; (setq header-spec
;; '((dest-ip ip)
;; (src-ip ip)
;; (dest-port u16)
;; (src-port u16)))
;;
;;
;; (setq data-spec
;; '((type u8)
;; (opcode u8)
@ -79,20 +79,20 @@
;; (id strz 8)
;; (data vec (length))
;; (align 4)))
;;
;;
;; (setq packet-spec
;; '((header struct header-spec)
;; (items u8)
;; (fill 3)
;; (item repeat (items)
;; ((struct data-spec)))))
;;
;;
;;
;; A binary data representation may look like
;; [ 192 168 1 100 192 168 1 101 01 28 21 32 2 0 0 0
;; [ 192 168 1 100 192 168 1 101 01 28 21 32 2 0 0 0
;; 2 3 5 0 ?A ?B ?C ?D ?E ?F 0 0 1 2 3 4 5 0 0 0
;; 1 4 7 0 ?B ?C ?D ?E ?F ?G 0 0 6 7 8 9 10 11 12 0 ]
;;
;;
;; The corresponding decoded structure looks like
;;
;; ((header
@ -176,7 +176,7 @@
;; A `union' specification
;; ([FIELD] union TAG_VAL (TAG SPEC) ... [(t SPEC)])
;; is interpreted by evalling TAG_VAL and then comparing that to
;; is interpreted by evalling TAG_VAL and then comparing that to
;; each TAG using equal; if a match is found, the corresponding SPEC
;; is used.
;; If TAG is a form (eval EXPR), EXPR is evalled with `tag' bound to the
@ -204,7 +204,7 @@
(string-to-char (substring raw-data pos (1+ pos)))
(aref raw-data pos))
(setq pos (1+ pos))))
(defun bindat--unpack-u16 ()
(let* ((a (bindat--unpack-u8)) (b (bindat--unpack-u8)))
(logior (lsh a 8) b)))
@ -341,7 +341,7 @@
(setq struct (cons (cons field data) struct))
(setq struct (append data struct))))))
struct))
(defun bindat-unpack (spec raw-data &optional pos)
"Return structured data according to SPEC for binary data in RAW-DATA.
RAW-DATA is a string or vector. Optional third arg POS specifies the
@ -365,7 +365,7 @@ e.g. corresponding to STRUCT.FIELD1[INDEX2].FIELD3..."
struct)
;; Calculate raw-data length of structured data
;; Calculate raw-data length of structured data
(defvar bindat--fixed-length-alist
'((u8 . 1) (byte . 1)
@ -398,7 +398,7 @@ e.g. corresponding to STRUCT.FIELD1[INDEX2].FIELD3..."
(setq len (apply 'bindat-get-field struct len)))
(if (not len)
(setq len 1))
(cond
(cond
((eq type 'eval)
(if field
(setq struct (cons (cons field (eval len)) struct))
@ -446,7 +446,7 @@ e.g. corresponding to STRUCT.FIELD1[INDEX2].FIELD3..."
(defun bindat--pack-u8 (v)
(aset raw-data pos (logand v 255))
(setq pos (1+ pos)))
(defun bindat--pack-u16 (v)
(aset raw-data pos (logand (lsh v -8) 255))
(aset raw-data (1+ pos) (logand v 255))
@ -513,7 +513,7 @@ e.g. corresponding to STRUCT.FIELD1[INDEX2].FIELD3..."
(aset raw-data (+ pos i) (aref v i))
(setq i (1+ i)))
(setq pos (+ pos len))))
(t
(t
(setq pos (+ pos len)))))
(defun bindat--pack-group (struct spec)
@ -540,7 +540,7 @@ e.g. corresponding to STRUCT.FIELD1[INDEX2].FIELD3..."
(setq len (apply 'bindat-get-field struct len)))
(if (not len)
(setq len 1))
(cond
(cond
((eq type 'eval)
(if field
(setq struct (cons (cons field (eval len)) struct))
@ -601,7 +601,7 @@ only that many elements from VECT."
(setq i (1- i)
s (cons (format (if (= i 0) fmt fmt2) (aref vect i)) s)))
(apply 'concat s)))
(defun bindat-vector-to-dec (vect &optional sep)
"Format vector VECT in decimal format separated by dots.
If optional second arg SEP is a string, use that as separator."

66
lisp/emacs-lisp/byte-opt.el
View file

@ -31,7 +31,7 @@
;; You can, however, make a faster pig."
;;
;; Or, to put it another way, the emacs byte compiler is a VW Bug. This code
;; makes it be a VW Bug with fuel injection and a turbocharger... You're
;; makes it be a VW Bug with fuel injection and a turbocharger... You're
;; still not going to make it go faster than 70 mph, but it might be easier
;; to get it there.
;;
@ -62,17 +62,17 @@
;; Simple defsubsts often produce forms like
;; (let ((v1 (f1)) (v2 (f2)) ...)
;; (FN v1 v2 ...))
;; It would be nice if we could optimize this to
;; It would be nice if we could optimize this to
;; (FN (f1) (f2) ...)
;; but we can't unless FN is dynamically-safe (it might be dynamically
;; referring to the bindings that the lambda arglist established.)
;; One of the uncountable lossages introduced by dynamic scope...
;;
;; Maybe there should be a control-structure that says "turn on
;; Maybe there should be a control-structure that says "turn on
;; fast-and-loose type-assumptive optimizations here." Then when
;; we see a form like (car foo) we can from then on assume that
;; the variable foo is of type cons, and optimize based on that.
;; But, this won't win much because of (you guessed it) dynamic
;; But, this won't win much because of (you guessed it) dynamic
;; scope. Anything down the stack could change the value.
;; (Another reason it doesn't work is that it is perfectly valid
;; to call car with a null argument.) A better approach might
@ -107,7 +107,7 @@
;;
;; However, if there was even a single let-binding around the COND,
;; it could not be byte-compiled, because there would be an "unbind"
;; byte-op between the final "call" and "return." Adding a
;; byte-op between the final "call" and "return." Adding a
;; Bunbind_all byteop would fix this.
;;
;; (defun foo (x y z) ... (foo a b c))
@ -129,8 +129,8 @@
;;
;; Wouldn't it be nice if Emacs Lisp had lexical scope.
;;
;; Idea: the form (lexical-scope) in a file means that the file may be
;; compiled lexically. This proclamation is file-local. Then, within
;; Idea: the form (lexical-scope) in a file means that the file may be
;; compiled lexically. This proclamation is file-local. Then, within
;; that file, "let" would establish lexical bindings, and "let-dynamic"
;; would do things the old way. (Or we could use CL "declare" forms.)
;; We'd have to notice defvars and defconsts, since those variables should
@ -140,10 +140,10 @@
;; in the file being compiled (doing a boundp check isn't good enough.)
;; Fdefvar() would have to be modified to add something to the plist.
;;
;; A major disadvantage of this scheme is that the interpreter and compiler
;; would have different semantics for files compiled with (dynamic-scope).
;; A major disadvantage of this scheme is that the interpreter and compiler
;; would have different semantics for files compiled with (dynamic-scope).
;; Since this would be a file-local optimization, there would be no way to
;; modify the interpreter to obey this (unless the loader was hacked
;; modify the interpreter to obey this (unless the loader was hacked
;; in some grody way, but that's a really bad idea.)
;; Other things to consider:
@ -157,7 +157,7 @@
;;;;; error free also they may act as true-constants.
;;;(disassemble (lambda (x) (and (point) (foo))))
;;;;; When
;;;;; When
;;;;; - all but one arguments to a function are constant
;;;;; - the non-constant argument is an if-expression (cond-expression?)
;;;;; then the outer function can be distributed. If the guarding
@ -285,7 +285,7 @@
form))))))
;;; ((lambda ...) ...)
;;;
;;;
(defun byte-compile-unfold-lambda (form &optional name)
(or name (setq name "anonymous lambda"))
(let ((lambda (car form))
@ -338,13 +338,13 @@
(byte-compile-warn
"attempt to open-code `%s' with too many arguments" name))
form)
;; The following leads to infinite recursion when loading a
;; file containing `(defsubst f () (f))', and then trying to
;; byte-compile that file.
;(setq body (mapcar 'byte-optimize-form body)))
(let ((newform
(let ((newform
(if bindings
(cons 'let (cons (nreverse bindings) body))
(cons 'progn body))))
@ -427,21 +427,21 @@
(cons (byte-optimize-form (nth 1 form) t)
(cons (byte-optimize-form (nth 2 form) for-effect)
(byte-optimize-body (cdr (cdr (cdr form))) t)))))
((memq fn '(save-excursion save-restriction save-current-buffer))
;; those subrs which have an implicit progn; it's not quite good
;; enough to treat these like normal function calls.
;; This can turn (save-excursion ...) into (save-excursion) which
;; will be optimized away in the lap-optimize pass.
(cons fn (byte-optimize-body (cdr form) for-effect)))
((eq fn 'with-output-to-temp-buffer)
;; this is just like the above, except for the first argument.
(cons fn
(cons
(byte-optimize-form (nth 1 form) nil)
(byte-optimize-body (cdr (cdr form)) for-effect))))
((eq fn 'if)
(when (< (length form) 3)
(byte-compile-warn "too few arguments for `if'"))
@ -450,7 +450,7 @@
(cons
(byte-optimize-form (nth 2 form) for-effect)
(byte-optimize-body (nthcdr 3 form) for-effect)))))
((memq fn '(and or)) ; remember, and/or are control structures.
;; take forms off the back until we can't any more.
;; In the future it could conceivably be a problem that the
@ -474,7 +474,7 @@
(byte-compile-warn "misplaced interactive spec: `%s'"
(prin1-to-string form))
nil)
((memq fn '(defun defmacro function
condition-case save-window-excursion))
;; These forms are compiled as constants or by breaking out
@ -490,7 +490,7 @@
(cons fn
(cons (byte-optimize-form (nth 1 form) for-effect)
(cdr (cdr form)))))
((eq fn 'catch)
;; the body of a catch is compiled (and thus optimized) as a
;; top-level form, so don't do it here. The tag is never
@ -523,7 +523,7 @@
(not (eq form
(setq form (compiler-macroexpand form)))))
(byte-optimize-form form for-effect))
((not (symbolp fn))
(byte-compile-warn "`%s' is a malformed function"
(prin1-to-string fn))
@ -552,7 +552,7 @@
;; appending a nil here might not be necessary, but it can't hurt.
(byte-optimize-form
(cons 'progn (append (cdr form) '(nil))) t))
(t
;; Otherwise, no args can be considered to be for-effect,
;; even if the called function is for-effect, because we
@ -622,7 +622,7 @@
((keywordp ,form))))
;; If the function is being called with constant numeric args,
;; evaluate as much as possible at compile-time. This optimizer
;; evaluate as much as possible at compile-time. This optimizer
;; assumes that the function is associative, like + or *.
(defun byte-optimize-associative-math (form)
(let ((args nil)
@ -816,7 +816,7 @@
(cons (/ (nth 1 form) last)
(byte-compile-butlast (cdr (cdr form)))))
last nil))))
(cond
(cond
;;; ((null (cdr (cdr form)))
;;; (nth 1 form))
((eq (nth 1 form) 0)
@ -912,7 +912,7 @@
(put 'cdr-safe 'byte-optimizer 'byte-optimize-predicate)
;; I'm not convinced that this is necessary. Doesn't the optimizer loop
;; I'm not convinced that this is necessary. Doesn't the optimizer loop
;; take care of this? - Jamie
;; I think this may some times be necessary to reduce ie (quote 5) to 5,
;; so arithmetic optimizers recognize the numeric constant. - Hallvard
@ -1169,7 +1169,7 @@
nil
form))
;;; enumerating those functions which need not be called if the returned
;;; enumerating those functions which need not be called if the returned
;;; value is not used. That is, something like
;;; (progn (list (something-with-side-effects) (yow))
;;; (foo))
@ -1233,7 +1233,7 @@
zerop))
(side-effect-and-error-free-fns
'(arrayp atom
bobp bolp bool-vector-p
bobp bolp bool-vector-p
buffer-end buffer-list buffer-size buffer-string bufferp
car-safe case-table-p cdr-safe char-or-string-p commandp cons consp
current-buffer current-global-map current-indentation
@ -1440,7 +1440,7 @@
byte-current-buffer byte-interactive-p))
(defconst byte-compile-side-effect-free-ops
(nconc
(nconc
'(byte-varref byte-nth byte-memq byte-car byte-cdr byte-length byte-aref
byte-symbol-value byte-get byte-concat2 byte-concat3 byte-sub1 byte-add1
byte-eqlsign byte-gtr byte-lss byte-leq byte-geq byte-diff byte-negate
@ -1472,7 +1472,7 @@
;;; varbind pop-up-windows
;;; not
;;;
;;; we break the program, because it will appear that pop-up-windows and
;;; we break the program, because it will appear that pop-up-windows and
;;; old-pop-ups are not EQ when really they are. So we have to know what
;;; the BOOL variables are, and not perform this optimization on them.
@ -1619,7 +1619,7 @@
;; goto-X-if-non-nil goto-Y X: --> goto-Y-if-nil X:
;;
;; it is wrong to do the same thing for the -else-pop variants.
;;
;;
((and (or (eq 'byte-goto-if-nil (car lap0))
(eq 'byte-goto-if-not-nil (car lap0))) ; gotoX
(eq 'byte-goto (car lap1)) ; gotoY
@ -1722,7 +1722,7 @@
str (concat str " %s")
i (1+ i))))
(if opt-p
(let ((tagstr
(let ((tagstr
(if (eq 'TAG (car (car tmp)))
(format "%d:" (car (cdr (car tmp))))
(or (car tmp) ""))))
@ -1903,7 +1903,7 @@
(byte-goto-if-not-nil-else-pop .
byte-goto-if-nil-else-pop))))
newtag)
(nth 1 newtag)
)
(setcdr tmp (cons (setcdr lap0 newtag) (cdr tmp)))

6
lisp/emacs-lisp/checkdoc.el
View file

@ -426,7 +426,7 @@ be re-created.")
;; end of a word in a conglomerate.
(modify-syntax-entry ?- "w" checkdoc-syntax-table)
)
;;; Compatibility
;;
@ -940,7 +940,7 @@ Optional argument TAKE-NOTES causes all errors to be logged."
(checkdoc-show-diagnostics)))
(goto-char p))
(if (interactive-p) (message "Checking interactive message text...done.")))
;;;###autoload
(defun checkdoc-eval-defun ()
"Evaluate the current form with `eval-defun' and check its documentation.
@ -2340,7 +2340,7 @@ The default boundary is the entire buffer."
(while (setq type (checkdoc-message-text-next-string end))
(setq e (checkdoc-message-text-engine type)))
e))
(defun checkdoc-message-text-next-string (end)
"Move cursor to the next checkable message string after point.
Return the message classification.

6
lisp/emacs-lisp/cl-indent.el
View file

@ -132,7 +132,7 @@ If nil, indent backquoted lists as data, i.e., like quoted lists."
(+ loop-indentation lisp-loop-keyword-indentation))
(t
(+ loop-indentation lisp-loop-forms-indentation)))))
;;;###autoload
(defun common-lisp-indent-function (indent-point state)
@ -140,8 +140,8 @@ If nil, indent backquoted lists as data, i.e., like quoted lists."
(looking-at "([Ll][Oo][Oo][Pp]"))
(common-lisp-loop-part-indentation indent-point state)
(common-lisp-indent-function-1 indent-point state)))
(defun common-lisp-indent-function-1 (indent-point state)
(let ((normal-indent (current-column)))
;; Walk up list levels until we see something

2
lisp/emacs-lisp/cl-macs.el
View file

@ -1368,7 +1368,7 @@ lexical closures as in Common Lisp."
(set (car cl-closure-vars) [bad-lexical-ref])
(list (car x) (cadr x) (car cl-closure-vars))))
bindings))
(ebody
(ebody
(cl-macroexpand-all
(cons 'progn body)
(nconc (mapcar (function (lambda (x)

88
lisp/emacs-lisp/cl-specs.el
View file

@ -7,7 +7,7 @@
;; LCD Archive Entry:
;; cl-specs.el|Daniel LaLiberte|liberte@holonexus.org
;; |Edebug specs for cl.el
;; |$Date: 2001/07/16 12:22:59 $|1.1|
;; |$Date: 2002/10/01 17:00:27 $|1.1|
;; This file is part of GNU Emacs.
@ -53,22 +53,22 @@
(def-edebug-spec ecase case)
(def-edebug-spec do
((&rest &or symbolp (symbolp &optional form form))
(form body)
(form body)
cl-declarations body))
(def-edebug-spec do* do)
(def-edebug-spec dolist
(def-edebug-spec dolist
((symbolp form &optional form) cl-declarations body))
(def-edebug-spec dotimes dolist)
(def-edebug-spec do-symbols
((symbolp &optional form form) cl-declarations body))
(def-edebug-spec do-all-symbols
(def-edebug-spec do-all-symbols
((symbolp &optional form) cl-declarations body))
;; Multiple values
(def-edebug-spec multiple-value-list (form))
(def-edebug-spec multiple-value-call (function-form body))
(def-edebug-spec multiple-value-bind
(def-edebug-spec multiple-value-bind
((&rest symbolp) form cl-declarations body))
(def-edebug-spec multiple-value-setq ((&rest symbolp) form))
(def-edebug-spec multiple-value-prog1 (form body))
@ -84,11 +84,11 @@
(def-edebug-spec flet ((&rest (defun*)) cl-declarations body))
(def-edebug-spec labels flet)
(def-edebug-spec macrolet
((&rest (&define name (&rest arg) cl-declarations-or-string def-body))
(def-edebug-spec macrolet
((&rest (&define name (&rest arg) cl-declarations-or-string def-body))
cl-declarations body))
(def-edebug-spec symbol-macrolet
(def-edebug-spec symbol-macrolet
((&rest (symbol sexp)) cl-declarations body))
(def-edebug-spec destructuring-bind
@ -105,13 +105,13 @@
(def-edebug-spec letf* letf)
(def-edebug-spec defsetf
(&define name
(def-edebug-spec defsetf
(&define name
[&or [symbolp &optional stringp]
[cl-lambda-list (symbolp)]]
cl-declarations-or-string def-body))
(def-edebug-spec define-setf-method
(def-edebug-spec define-setf-method
(&define name cl-lambda-list cl-declarations-or-string def-body))
(def-edebug-spec define-modify-macro
@ -128,8 +128,8 @@
(def-edebug-spec incf (place &optional form))
(def-edebug-spec decf incf)
(def-edebug-spec push (form place)) ; different for CL
(def-edebug-spec pushnew
(form place &rest
(def-edebug-spec pushnew
(form place &rest
&or [[&or ":test" ":test-not" ":key"] function-form]
[edebug-keywordp form]))
(def-edebug-spec pop (place)) ; different for CL
@ -180,7 +180,7 @@
;; Declarations
(def-edebug-spec cl-decl-spec
(def-edebug-spec cl-decl-spec
((symbolp &rest sexp)))
(def-edebug-spec cl-declarations
@ -214,17 +214,17 @@
(&or ([&or (symbolp arg) arg] &optional def-form arg) arg))
;; The lambda list for macros is different from that of normal lambdas.
;; Note that &environment is only allowed as first or last items in the
;; Note that &environment is only allowed as first or last items in the
;; top level list.
(def-edebug-spec cl-macro-list
(([&optional "&environment" arg]
[&rest cl-macro-arg]
[&optional ["&optional" &rest
[&optional ["&optional" &rest
&or (cl-macro-arg &optional def-form cl-macro-arg) arg]]
[&optional [[&or "&rest" "&body"] cl-macro-arg]]
[&optional ["&key" [&rest
[&or ([&or (symbolp cl-macro-arg) arg]
[&optional ["&key" [&rest
[&or ([&or (symbolp cl-macro-arg) arg]
&optional def-form cl-macro-arg)
arg]]
&optional "&allow-other-keys"]]
@ -239,11 +239,11 @@
(def-edebug-spec cl-macro-list1
(([&optional "&whole" arg] ;; only allowed at lower levels
[&rest cl-macro-arg]
[&optional ["&optional" &rest
[&optional ["&optional" &rest
&or (cl-macro-arg &optional def-form cl-macro-arg) arg]]
[&optional [[&or "&rest" "&body"] cl-macro-arg]]
[&optional ["&key" [&rest
[&or ([&or (symbolp cl-macro-arg) arg]
[&optional ["&key" [&rest
[&or ([&or (symbolp cl-macro-arg) arg]
&optional def-form cl-macro-arg)
arg]]
&optional "&allow-other-keys"]]
@ -262,7 +262,7 @@
def-body))
(def-edebug-spec defsubst* defun*)
(def-edebug-spec defmacro*
(def-edebug-spec defmacro*
(&define name cl-macro-list cl-declarations-or-string def-body))
(def-edebug-spec define-compiler-macro defmacro*)
@ -280,7 +280,7 @@
(def-edebug-spec function-form
;; form at the end could also handle "function",
;; but recognize it specially to avoid wrapping function forms.
(&or ([&or "quote" "function"] &or symbolp lambda-expr)
(&or ([&or "quote" "function"] &or symbolp lambda-expr)
("function*" function*)
form))
@ -293,7 +293,7 @@
(&define ; makes top-level form not be wrapped
[&or symbolp
(gate
symbolp &rest
symbolp &rest
(&or [":conc-name" &or stringp "nil"]
[":constructor" symbolp &optional cl-lambda-list]
[":copier" symbolp]
@ -329,7 +329,7 @@
(def-edebug-spec loop
([&optional ["named" symbolp]]
[&rest
[&rest
&or
["repeat" form]
loop-for-as
@ -351,36 +351,36 @@
&rest ["and" loop-for-as-subclause]))
(def-edebug-spec loop-for-as-subclause
(loop-var
(loop-var
loop-type-spec
&or
&or
[[&or "in" "on" "in-ref" "across-ref"]
form &optional ["by" function-form]]
["=" form &optional ["then" form]]
["across" form]
["being"
["being"
[&or "the" "each"]
&or
[[&or "element" "elements"]
&or
[[&or "element" "elements"]
[&or "of" "in" "of-ref"] form
&optional "using" ["index" symbolp]];; is this right?
[[&or "hash-key" "hash-keys"
"hash-value" "hash-values"]
[&or "of" "in"]
hash-table-p &optional ["using" ([&or "hash-value" "hash-values"
hash-table-p &optional ["using" ([&or "hash-value" "hash-values"
"hash-key" "hash-keys"] sexp)]]
[[&or "symbol" "present-symbol" "external-symbol"
"symbols" "present-symbols" "external-symbols"]
[&or "in" "of"] package-p]
;; Extensions for Emacs Lisp, including Lucid Emacs.
[[&or "frame" "frames"
"screen" "screens"
"buffer" "buffers"]]
[[&or "window" "windows"]
[[&or "window" "windows"]
[&or "of" "in"] form]
[[&or "overlay" "overlays"
@ -388,23 +388,23 @@
[&or "of" "in"] form
&optional [[&or "from" "to"] form]]
[[&or "interval" "intervals"]
[[&or "interval" "intervals"]
[&or "in" "of"] form
&optional [[&or "from" "to"] form]
["property" form]]
[[&or "key-code" "key-codes"
"key-seq" "key-seqs"
"key-binding" "key-bindings"]
"key-binding" "key-bindings"]
[&or "in" "of"] form
&optional ["using" ([&or "key-code" "key-codes"
"key-seq" "key-seqs"
"key-binding" "key-bindings"]
"key-binding" "key-bindings"]
sexp)]]
;; For arbitrary extensions, recognize anything else.
[symbolp &rest &or symbolp form]
]
;; arithmetic - must be last since all parts are optional.
[[&optional [[&or "from" "downfrom" "upfrom"] form]]
[&optional [[&or "to" "downto" "upto" "below" "above"] form]]
@ -412,10 +412,10 @@
]))
(def-edebug-spec loop-initial-final
(&or ["initially"
(&or ["initially"
;; [&optional &or "do" "doing"] ;; CLtL2 doesn't allow this.
&rest loop-non-atomic-expr]
["finally" &or
["finally" &or
[[&optional &or "do" "doing"] &rest loop-non-atomic-expr]
["return" form]]))
@ -425,11 +425,11 @@
(def-edebug-spec loop-clause
(&or
[[&or "while" "until" "always" "never" "thereis"] form]
[[&or "collect" "collecting"
"append" "appending"
"nconc" "nconcing"
"concat" "vconcat"] form
"concat" "vconcat"] form
[&optional ["into" loop-var]]]
[[&or "count" "counting"
@ -455,7 +455,7 @@
(def-edebug-spec loop-var
;; The symbolp must be last alternative to recognize e.g. (a b . c)
;; loop-var =>
;; loop-var =>
;; (loop-var . [&or nil loop-var])
;; (symbolp . [&or nil loop-var])
;; (symbolp . loop-var)

38
lisp/emacs-lisp/crm.el
View file

@ -85,7 +85,7 @@
;; -tip: use M-f and M-b for ease of navigation among elements.
;;; History:
;;
;;
;; 2000-04-10:
;;
;; first revamped version
@ -211,7 +211,7 @@ and return t."
;; no candidate found
nil
(progn
;;
;;
(setq crm-beginning-of-element (match-beginning 1))
(setq crm-end-of-element end-index)
;; string to the left of the current element
@ -226,7 +226,7 @@ and return t."
"Return t if CANDIDATE is an exact match for a valid completion."
(let ((completions
;; TODO: verify whether the arguments are appropriate
(all-completions
(all-completions
candidate crm-completion-table minibuffer-completion-predicate)))
(if (member candidate completions)
t
@ -271,20 +271,20 @@ The meanings of the return values are:
minibuffer-completion-predicate))
(setq last crm-last-exact-completion)
(setq crm-last-exact-completion nil)
(catch 'crm-exit
(if (null completion) ; no possible completion
(progn
(crm-temp-echo-area-glyphs " [No match]")
(throw 'crm-exit 0)))
(if (eq completion t) ; was already an exact and unique completion
(throw 'crm-exit 1))
(setq completedp
(null (string-equal completion crm-current-element)))
(if completedp
(progn
(erase-buffer)
@ -295,7 +295,7 @@ The meanings of the return values are:
(backward-char (length crm-right-of-element))
;; TODO: is this correct?
(setq crm-current-element completion)))
(if (null (crm-test-completion crm-current-element))
(progn
(if completedp ; some completion happened
@ -306,13 +306,13 @@ The meanings of the return values are:
(throw 'crm-exit 6))
(if completedp
(throw 'crm-exit 4)))
(setq crm-last-exact-completion completion)
(if (not (null last))
(progn
(if (not (null (equal crm-current-element last)))
(crm-minibuffer-completion-help))))
;; returning -- was already an exact completion
(throw 'crm-exit 3)))))
@ -472,24 +472,24 @@ to the location of mismatch and do not exit.
This function is modeled after `minibuffer_complete_and_exit' in src/minibuf.c"
(interactive)
(if (not (crm-find-current-element))
nil
(let (result)
(setq result
(catch 'crm-exit
(if (eq (point-min) (point-max))
(throw 'crm-exit t))
;; TODO: this test is suspect?
(if (not (null (crm-test-completion crm-current-element)))
(throw 'crm-exit "check"))
;; TODO: determine how to detect errors
(let ((result (crm-do-completion)))
(cond
((or (eq 1 result)
(eq 3 result))
@ -501,7 +501,7 @@ This function is modeled after `minibuffer_complete_and_exit' in src/minibuf.c"
nil)
(throw 'crm-exit "check")))
(nil)))))
(if (null result)
nil
(if (equal result "check")
@ -541,7 +541,7 @@ and TAB to `crm-minibuffer-complete'."
(define-key crm-local-completion-map
(kbd "TAB")
(function crm-minibuffer-complete)))
(unless crm-local-must-match-map
(setq crm-local-must-match-map (make-sparse-keymap))
(set-keymap-parent crm-local-must-match-map

44
lisp/emacs-lisp/cust-print.el
View file

@ -34,7 +34,7 @@
;; print-length since the standard routines are being replaced. Also,
;; to print custom types constructed from lists and vectors, use
;; custom-print-list and custom-print-vector. See the documentation
;; strings of these variables for more details.
;; strings of these variables for more details.
;; If the results of your expressions contain circular references to
;; other parts of the same structure, the standard Emacs print
@ -131,7 +131,7 @@
;;This is defined by emacs.")
(defcustom print-level nil
"*Controls how many levels deep a nested data object will print.
"*Controls how many levels deep a nested data object will print.
If nil, printing proceeds recursively and may lead to
max-lisp-eval-depth being exceeded or an error may occur:
@ -147,7 +147,7 @@ level 1."
(defcustom print-circle nil
"*Controls the printing of recursive structures.
"*Controls the printing of recursive structures.
If nil, printing proceeds recursively and may lead to
`max-lisp-eval-depth' being exceeded or an error may occur:
@ -196,7 +196,7 @@ Don't modify this variable directly. Use `add-custom-printer' and
(defun add-custom-printer (pred printer)
"Add a pair of PREDICATE and PRINTER to `custom-printers'.
Any pair that has the same PREDICATE is first removed."
(setq custom-printers (cons (cons pred printer)
(setq custom-printers (cons (cons pred printer)
(delq (assq pred custom-printers)
custom-printers)))
;; Rather than updating here, we could wait until cust-print-top-level is called.
@ -220,9 +220,9 @@ Any pair that has the same PREDICATE is first removed."
;; (byte-compile
`(lambda (object)
(cond
,@(mapcar (function
,@(mapcar (function
(lambda (pair)
`((,(car pair) object)
`((,(car pair) object)
(,(cdr pair) object))))
custom-printers)
;; Otherwise return nil.
@ -236,7 +236,7 @@ Any pair that has the same PREDICATE is first removed."
;;====================================================
(defun cust-print-set-function-cell (symbol-pair)
(defalias (car symbol-pair)
(defalias (car symbol-pair)
(symbol-function (car (cdr symbol-pair)))))
(defun cust-print-original-princ (object &optional stream)) ; dummy def
@ -268,7 +268,7 @@ by running `custom-print-uninstall'."
(error custom-error)
))
t)
(defun custom-print-uninstall ()
"Reset print functions to their emacs subroutines."
(interactive)
@ -335,7 +335,7 @@ second argument NOESCAPE is non-nil.
This is the custom-print replacement for the standard `prin1-to-string'."
(let ((buf (get-buffer-create " *custom-print-temp*")))
;; We must erase the buffer before printing in case an error
;; We must erase the buffer before printing in case an error
;; occurred during the last prin1-to-string and we are in debugger.
(save-excursion
(set-buffer buf)
@ -364,7 +364,7 @@ This is the custom-print replacement for the standard `print'."
(defun custom-format (fmt &rest args)
"Format a string out of a control-string and arguments.
"Format a string out of a control-string and arguments.
The first argument is a control string. It, and subsequent arguments
substituted into it, become the value, which is a string.
It may contain %s or %d or %c to substitute successive following arguments.
@ -385,8 +385,8 @@ characters."
(custom-prin1-to-string arg)
arg)))
args)))
(defun custom-message (fmt &rest args)
"Print a one-line message at the bottom of the screen.
The first argument is a control string.
@ -401,7 +401,7 @@ See `custom-format' for the details."
;; It doesn't work to princ the result of custom-format as in:
;; (cust-print-original-princ (apply 'custom-format fmt args))
;; because the echo area requires special handling
;; to avoid duplicating the output.
;; to avoid duplicating the output.
;; cust-print-original-message does it right.
(apply 'cust-print-original-message fmt
(mapcar (function (lambda (arg)
@ -409,7 +409,7 @@ See `custom-format' for the details."
(custom-prin1-to-string arg)
arg)))
args)))
(defun custom-error (fmt &rest args)
"Signal an error, making error message by passing all args to `format'.
@ -435,12 +435,12 @@ See `custom-format' for the details."
;; Set up for printing.
(let ((standard-output (or stream standard-output))
;; circle-table will be non-nil if anything is circular.
(circle-table (and print-circle
(circle-table (and print-circle
(cust-print-preprocess-circle-tree object)))
(cust-print-current-level (or print-level -1)))
(defalias 'cust-print-original-printer emacs-printer)
(defalias 'cust-print-low-level-prin
(defalias 'cust-print-low-level-prin
(cond
((or custom-printers
circle-table
@ -451,7 +451,7 @@ See `custom-format' for the details."
(or print-level print-length)))
'cust-print-print-object)
(t 'cust-print-original-printer)))
(defalias 'cust-print-prin
(defalias 'cust-print-prin
(if circle-table 'cust-print-print-circular 'cust-print-low-level-prin))
(cust-print-prin object)
@ -461,7 +461,7 @@ See `custom-format' for the details."
(defun cust-print-print-object (object)
;; Test object type and print accordingly.
;; Could be called as either cust-print-low-level-prin or cust-print-prin.
(cond
(cond
((null object) (cust-print-original-printer object))
((cust-print-use-custom-printer object) object)
((consp object) (cust-print-list object))
@ -561,7 +561,7 @@ See `custom-format' for the details."
;;==================================
(defun cust-print-preprocess-circle-tree (object)
;; Fill up the table.
;; Fill up the table.
(let (;; Table of tags for each object in an object to be printed.
;; A tag is of the form:
;; ( <object> <nil-t-or-id-number> )
@ -600,8 +600,8 @@ See `custom-format' for the details."
(defun cust-print-walk-circle-tree (object)
(let (read-equivalent-p tag)
(while object
(setq read-equivalent-p
(or (numberp object)
(setq read-equivalent-p
(or (numberp object)
(and (symbolp object)
;; Check if it is uninterned.
(eq object (intern-soft (symbol-name object)))))
@ -617,7 +617,7 @@ See `custom-format' for the details."
(cons (list object)
(cdr circle-table)))))
(setq object
(cond
(cond
(tag ;; No need to descend since we have already.
nil)

2
lisp/emacs-lisp/debug.el
View file

@ -338,7 +338,7 @@ That buffer should be current already."
;; Make the unchanged part of the backtrace inaccessible
;; so it won't be scanned.
(narrow-to-region (point-min) new-end)))
;; Scan the new part of the backtrace, inserting xrefs.
(goto-char (point-min))
(while (progn

2
lisp/emacs-lisp/disass.el
View file

@ -88,7 +88,7 @@ redefine OBJECT if it is a symbol."
(setq macro t
obj (cdr obj)))
(if (and (listp obj) (eq (car obj) 'byte-code))
(setq obj (list 'lambda nil obj)))
(setq obj (list 'lambda nil obj)))
(if (and (listp obj) (not (eq (car obj) 'lambda)))
(error "not a function"))
(if (consp obj)

2
lisp/emacs-lisp/easy-mmode.el
View file

@ -228,7 +228,7 @@ With zero or negative ARG turn mode off.
,(if keymap keymap-sym
`(if (boundp ',keymap-sym)
(symbol-value ',keymap-sym))))
;; If the mode is global, call the function according to the default.
,(if globalp
`(if (and load-file-name (not (equal ,init-value ,mode)))

400
lisp/emacs-lisp/edebug.el
View file

File diff suppressed because it is too large Load diff

10
lisp/emacs-lisp/ewoc.el
View file

@ -92,7 +92,7 @@
;; In the mean time `grep '^(.*ewoc-[^-]' emacs-lisp/ewoc.el' can help
;; you find all the exported functions:
;;
;;
;; (defun ewoc-create (pretty-printer &optional header footer)
;; (defalias 'ewoc-data 'ewoc--node-data)
;; (defun ewoc-location (node)
@ -394,8 +394,8 @@ MAP-FUNCTION is applied to the first element first.
If MAP-FUNCTION returns non-nil the element will be refreshed (its
pretty-printer will be called once again).
Note that the buffer for EWOC will be current buffer when MAP-FUNCTION
is called. MAP-FUNCTION must restore the current buffer to BUFFER before
Note that the buffer for EWOC will be current buffer when MAP-FUNCTION
is called. MAP-FUNCTION must restore the current buffer to BUFFER before
it returns, if it changes it.
If more than two arguments are given, the remaining
@ -410,7 +410,7 @@ arguments will be passed to MAP-FUNCTION."
(defun ewoc-filter (ewoc predicate &rest args)
"Remove all elements in EWOC for which PREDICATE returns nil.
Note that the buffer for EWOC will be current-buffer when PREDICATE
Note that the buffer for EWOC will be current-buffer when PREDICATE
is called. PREDICATE must restore the current buffer before it returns
if it changes it.
The PREDICATE is called with the element as its first argument. If any
@ -478,7 +478,7 @@ If the EWOC is empty, nil is returned."
;; best-guess is now a "best guess".
;; Find the correct node. First determine in which direction
;; it lies, and then move in that direction until it is found.
(cond
;; Is pos after the guess?
((>= pos

2
lisp/emacs-lisp/find-func.el
View file

@ -312,7 +312,7 @@ The library where VARIABLE is defined is searched for in FILE or
`find-function-source-path', if non nil, otherwise in `load-path'."
(if (not variable)
(error "You didn't specify a variable"))
;; Fixme: I think `symbol-file' should be fixed instead. -- fx
;; Fixme: I think `symbol-file' should be fixed instead. -- fx
(let ((library (or file (symbol-file (cons 'defvar variable)))))
(find-function-search-for-symbol variable 'variable library)))

2
lisp/emacs-lisp/gulp.el
View file

@ -103,7 +103,7 @@ is left in the `*gulp*' buffer at the end."
(while (setq node (car m-p-alist))
(setq msg (gulp-create-message (cdr node) time))
(setq mail-setup-hook
(lambda ()
(lambda ()
(mail-subject)
(insert "It's time for Emacs updates again")
(goto-char (point-max))

12
lisp/emacs-lisp/levents.el
View file

@ -98,8 +98,8 @@ in is the second. This function contains knowledge about what the codes
mean -- for example, the number 9 is converted to the character Tab,
not the distinct character Control-I.
Beware that character-to-event and event-to-character are not strictly
inverse functions, since events contain much more information than the
Beware that character-to-event and event-to-character are not strictly
inverse functions, since events contain much more information than the
ASCII character set can encode."
ch)
@ -214,11 +214,11 @@ In this emulation, it returns nil for non-mouse-related events."
(defun event-to-character (event &optional lenient)
"Returns the closest ASCII approximation to the given event object.
If the event isn't a keypress, this returns nil.
If the second argument is non-nil, then this is lenient in its
If the second argument is non-nil, then this is lenient in its
translation; it will ignore modifier keys other than control and meta,
and will ignore the shift modifier on those characters which have no
shifted ASCII equivalent (Control-Shift-A for example, will be mapped to
the same ASCII code as Control-A.) If the second arg is nil, then nil
and will ignore the shift modifier on those characters which have no
shifted ASCII equivalent (Control-Shift-A for example, will be mapped to
the same ASCII code as Control-A.) If the second arg is nil, then nil
will be returned for events which have no direct ASCII equivalent."
(if (symbolp event)
(and lenient

30
lisp/emacs-lisp/lisp-mnt.el
View file

@ -32,7 +32,7 @@
;; First, it knows about the header conventions for library packages.
;; One entry point supports generating synopses from a library directory.
;; Another can be used to check for missing headers in library files.
;;
;;
;; Another entry point automatically addresses bug mail to a package's
;; maintainer or author.
@ -40,11 +40,11 @@
;; This file is an example of the header conventions. Note the following
;; features:
;;
;;
;; * Header line --- makes it possible to extract a one-line summary of
;; the package's uses automatically for use in library synopses, KWIC
;; indexes and the like.
;;
;;
;; Format is three semicolons, followed by the filename, followed by
;; three dashes, followed by the summary. All fields space-separated.
;;
@ -55,13 +55,13 @@
;; ;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
;;
;; * A blank line
;;
;;
;; * Author line --- contains the name and net address of at least
;; the principal author.
;;
;;
;; If there are multiple authors, they should be listed on continuation
;; lines led by ;;<TAB>, like this:
;;
;;
;; ;; Author: Ashwin Ram <Ram-Ashwin@cs.yale.edu>
;; ;; Dave Sill <de5@ornl.gov>
;; ;; David Lawrence <tale@pawl.rpi.edu>
@ -69,10 +69,10 @@
;; ;; Joe Wells <jbw@maverick.uswest.com>
;; ;; Dave Brennan <brennan@hal.com>
;; ;; Eric Raymond <esr@snark.thyrsus.com>
;;
;;
;; This field may have some special values; notably "FSF", meaning
;; "Free Software Foundation".
;;
;;
;; * Maintainer line --- should be a single name/address as in the Author
;; line, or an address only, or the string "FSF". If there is no maintainer
;; line, the person(s) in the Author field are presumed to be it. The example
@ -81,19 +81,19 @@
;; that does "send mail to the author" without having to mine the name out by
;; hand. Please be careful about surrounding the network address with <> if
;; there's also a name in the field.
;;
;;
;; * Created line --- optional, gives the original creation date of the
;; file. For historical interest, basically.
;;
;;
;; * Version line --- intended to give the reader a clue if they're looking
;; at a different version of the file than the one they're accustomed to. This
;; may be an RCS or SCCS header.
;;
;;
;; * Adapted-By line --- this is for FSF's internal use. The person named
;; in this field was the one responsible for installing and adapting the
;; package for the distribution. (This file doesn't have one because the
;; author *is* one of the maintainers.)
;;
;;
;; * Keywords line --- used by the finder code (now under construction)
;; for finding Emacs Lisp code related to a topic.
;;
@ -104,13 +104,13 @@
;;
;; * Commentary line --- enables Lisp code to find the developer's and
;; maintainers' explanations of the package internals.
;;
;;
;; * Change log line --- optional, exists to terminate the commentary
;; section and start a change-log part, if one exists.
;;
;;
;; * Code line --- exists so Lisp can know where commentary and/or
;; change-log sections end.
;;
;;
;; * Footer line --- marks end-of-file so it can be distinguished from
;; an expanded formfeed or the results of truncation.

10
lisp/emacs-lisp/lisp-mode.el
View file

@ -403,16 +403,16 @@ which see."
(defun last-sexp-setup-props (beg end value alt1 alt2)
"Set up text properties for the output of `eval-last-sexp-1'.
BEG and END are the start and end of the output in current-buffer.
VALUE is the Lisp value printed, ALT1 and ALT2 are strings for the
VALUE is the Lisp value printed, ALT1 and ALT2 are strings for the
alternative printed representations that can be displayed."
(let ((map (make-sparse-keymap)))
(define-key map "\C-m" 'last-sexp-toggle-display)
(define-key map [down-mouse-2] 'mouse-set-point)
(define-key map [mouse-2] 'last-sexp-toggle-display)
(add-text-properties
beg end
beg end
`(printed-value (,value ,alt1 ,alt2)
mouse-face highlight
mouse-face highlight
keymap ,map
help-echo "RET, mouse-2: toggle abbreviated display"
rear-nonsticky (mouse-face keymap help-echo
@ -430,7 +430,7 @@ alternative printed representations that can be displayed."
(point (point)))
(delete-region beg end)
(insert (nth 1 value))
(last-sexp-setup-props beg (point)
(last-sexp-setup-props beg (point)
(nth 0 value)
(nth 2 value)
(nth 1 value))
@ -508,7 +508,7 @@ With argument, print output into current buffer."
(not (null print-level)))
(not (string= unabbreviated
(buffer-substring-no-properties beg end))))
(last-sexp-setup-props beg end value
(last-sexp-setup-props beg end value
unabbreviated
(buffer-substring-no-properties beg end))
))))))

2
lisp/emacs-lisp/pp.el
View file

@ -31,7 +31,7 @@
:prefix "pp-"
:group 'lisp)
(defcustom pp-escape-newlines t
(defcustom pp-escape-newlines t
"*Value of `print-escape-newlines' used by pp-* functions."
:type 'boolean
:group 'pp)

2
lisp/emacs-lisp/re-builder.el
View file

@ -269,7 +269,7 @@ Except for Lisp syntax this is the same as `reb-regexp'.")
(define-key reb-lisp-mode-map "\C-c"
(lookup-key reb-mode-map "\C-c"))
(defvar reb-subexp-mode-map
(defvar reb-subexp-mode-map
(let ((m (make-keymap)))
(suppress-keymap m)
;; Again share the "\C-c" keymap for the commands

2
lisp/emacs-lisp/regexp-opt.el
View file

@ -218,7 +218,7 @@ in REGEXP."
(regexp-quote
(concat (nreverse (string-to-list xiffus))))
close-group))
;; Otherwise, divide the list into those that start with a
;; particular letter and those that do not, and recurse on them.
(let* ((char (char-to-string (string-to-char (car strings))))

20
lisp/emacs-lisp/rx.el
View file

@ -78,8 +78,8 @@
;; (and line-start ?\n)))
;;
;; "\\$[I]d: [^ ]+ \\([^ ]+\\) "
;; (rx (and "$Id: "
;; (1+ (not (in " ")))
;; (rx (and "$Id: "
;; (1+ (not (in " ")))
;; " "
;; (submatch (1+ (not (in " "))))
;; " "))
@ -90,7 +90,7 @@
;; etc.
;;; History:
;;
;;
;;; Code:
@ -244,7 +244,7 @@ See also `rx-constituents'."
(while (and (not (null op)) (symbolp op))
(setq op (cdr (assq op rx-constituents))))
op)
(defun rx-check (form)
"Check FORM according to its car's parsing info."
@ -396,7 +396,7 @@ FORM is either `(repeat N FORM1)' or `(repeat N M FORM1)'."
(defun rx-kleene (form)
"Parse and produce code from FORM.
FORM is `(OP FORM1)', where OP is one of the `zero-or-one',
`zero-or-more' etc. operators.
`zero-or-more' etc. operators.
If OP is one of `*', `+', `?', produce a greedy regexp.
If OP is one of `*?', `+?', `??', produce a non-greedy regexp.
If OP is anything else, produce a greedy regexp if `rx-greedy-flag'
@ -463,7 +463,7 @@ of all atomic regexps."
(cdr (assq form rx-categories)))
(error "Unknown category `%s'" form))
t)
(defun rx-category (form)
"Parse and produce code from FORM, which is `(category SYMBOL ...)'."
@ -511,7 +511,7 @@ NO-GROUP non-nil means don't put shy groups around the result."
info)
((null info)
(error "Unknown Rx form `%s'" form))
(t
(t
(funcall (nth 0 info) form)))))
((consp form)
(let ((info (rx-info (car form))))
@ -549,7 +549,7 @@ CHAR
matches any character in SET. SET may be a character or string.
Ranges of characters can be specified as `A-Z' in strings.
'(in SET)'
'(in SET)'
like `any'.
`(not (any SET))'
@ -751,7 +751,7 @@ CHAR
`(one-or-more SEXP)'
matches one or more occurrences of A.
`(1+ SEXP)'
like `one-or-more'.
@ -763,7 +763,7 @@ CHAR
`(zero-or-one SEXP)'
matches zero or one occurrences of A.
`(optional SEXP)'
like `zero-or-one'.

8
lisp/emacs-lisp/shadow.el
View file

@ -74,7 +74,7 @@ the file in position 2i+1. Emacs Lisp file suffixes \(.el and .elc\)
are stripped from the file names in the list.
See the documentation for `list-load-path-shadows' for further information."
(or path (setq path load-path))
(let (true-names ; List of dirs considered.
@ -86,7 +86,7 @@ See the documentation for `list-load-path-shadows' for further information."
files-seen-this-dir ; Files seen so far in this dir.
file) ; The current file.
(while path
(setq dir (directory-file-name (file-truename (or (car path) "."))))
@ -125,7 +125,7 @@ See the documentation for `list-load-path-shadows' for further information."
;; This test prevents us declaring that XXX.el shadows
;; XXX.elc (or vice-versa) when they are in the same directory.
(setq files-seen-this-dir (cons file files-seen-this-dir))
(if (setq orig-dir (assoc file files))
;; This file was seen before, we have a shadowing.
;; Report it unless the files are identical.
@ -202,7 +202,7 @@ considered to shadow a later file XXX.el, and vice-versa.
When run interactively, the shadowings \(if any\) are displayed in a
buffer called `*Shadows*'. Shadowings are located by calling the
\(non-interactive\) companion function, `find-emacs-lisp-shadows'."
(interactive)
(let* ((path (copy-sequence load-path))
(tem path)

6
lisp/emacs-lisp/syntax.el
View file

@ -113,7 +113,7 @@ avoid a more expansive scan.
Point is at POS when this function returns."
;; Default values.
(unless pos (setq pos (point)))
;;
;;
(let ((old-ppss (cdr syntax-ppss-last))
(old-pos (car syntax-ppss-last))
(ppss nil)
@ -129,7 +129,7 @@ Point is at POS when this function returns."
(incf (car (aref syntax-ppss-stats 0)))
(incf (cdr (aref syntax-ppss-stats 0)) (- pos old-pos))
(parse-partial-sexp old-pos pos nil nil old-ppss))
(cond
;; Use OLD-PPSS if possible and close enough.
((and (not old-pos) old-ppss
@ -253,7 +253,7 @@ Point is at POS when this function returns."
syntax-ppss-max-span))
(push pair syntax-ppss-cache)
(setcar syntax-ppss-cache pair)))))))))
(setq syntax-ppss-last (cons pos ppss))
ppss)))

4
lisp/emacs-lisp/tq.el
View file

@ -25,7 +25,7 @@
;; Boston, MA 02111-1307, USA.
;;; Commentary:
;; manages receiving a stream asynchronously,
;; parsing it into transactions, and then calling
;; handler functions
@ -68,7 +68,7 @@ to a tcp server on another machine."
(defun tq-queue-head-closure (tq) (car (cdr (car (tq-queue tq)))))
(defun tq-queue-empty (tq) (not (tq-queue tq)))
(defun tq-queue-pop (tq) (setcar tq (cdr (car tq))) (null (car tq)))
;;; must add to queue before sending!
(defun tq-enqueue (tq question regexp closure fn)

2
lisp/emacs-lisp/unsafep.el
View file

@ -212,7 +212,7 @@ of symbols with local bindings."
(defun unsafep-function (fun)
"Return nil if FUN is a safe function
\(either a safe lambda or a symbol that names a safe function). Otherwise
result is a reason code."
result is a reason code."
(cond
((eq (car-safe fun) 'lambda)
(unsafep fun unsafep-vars))