diff options
Diffstat (limited to 'lisp/emacs-lisp')
| -rw-r--r-- | lisp/emacs-lisp/autoload.el | 4 | ||||
| -rw-r--r-- | lisp/emacs-lisp/elint.el | 2 | ||||
| -rw-r--r-- | lisp/emacs-lisp/find-func.el | 189 | ||||
| -rw-r--r-- | lisp/emacs-lisp/lisp-mnt.el | 7 | ||||
| -rw-r--r-- | lisp/emacs-lisp/lisp-mode.el | 3 | ||||
| -rw-r--r-- | lisp/emacs-lisp/re-builder.el | 8 |
6 files changed, 137 insertions, 76 deletions
diff --git a/lisp/emacs-lisp/autoload.el b/lisp/emacs-lisp/autoload.el index 196786e9179..0a75a43827e 100644 --- a/lisp/emacs-lisp/autoload.el +++ b/lisp/emacs-lisp/autoload.el @@ -135,7 +135,7 @@ or macro definition or a defcustom)." (defun autoload-trim-file-name (file) - ;; Returns a relative pathname of FILE + ;; Returns a relative file path for FILE ;; starting from the directory that loaddefs.el is in. ;; That is normally a directory in load-path, ;; which means Emacs will be able to find FILE when it looks. @@ -273,7 +273,7 @@ are used." output-end) ;; If the autoload section we create here uses an absolute - ;; pathname for FILE in its header, and then Emacs is installed + ;; file name for FILE in its header, and then Emacs is installed ;; under a different path on another system, ;; `update-autoloads-here' won't be able to find the files to be ;; autoloaded. So, if FILE is in the same directory or a diff --git a/lisp/emacs-lisp/elint.el b/lisp/emacs-lisp/elint.el index 9454bfc9da3..d4967a7cd06 100644 --- a/lisp/emacs-lisp/elint.el +++ b/lisp/emacs-lisp/elint.el @@ -29,7 +29,7 @@ ;; mispellings and undefined variables, although it can also catch ;; function calls with the wrong number of arguments. -;; Before using, call `elint-initialize' to set up som argument +;; Before using, call `elint-initialize' to set up some argument ;; data. This takes a while. Then call elint-current-buffer or ;; elint-defun to lint a buffer or a defun. diff --git a/lisp/emacs-lisp/find-func.el b/lisp/emacs-lisp/find-func.el index a70adb4d423..7e2ac5aa883 100644 --- a/lisp/emacs-lisp/find-func.el +++ b/lisp/emacs-lisp/find-func.el @@ -1,6 +1,6 @@ ;;; find-func.el --- find the definition of the Emacs Lisp function near point -;; Copyright (C) 1997, 1999, 2001, 2004 Free Software Foundation, Inc. +;; Copyright (C) 1997, 1999, 2001, 2004, 2005 Free Software Foundation, Inc. ;; Author: Jens Petersen <petersen@kurims.kyoto-u.ac.jp> ;; Maintainer: petersen@kurims.kyoto-u.ac.jp @@ -76,16 +76,37 @@ Please send improvements and fixes to the maintainer." :version "21.1") (defcustom find-variable-regexp - (concat"^\\s-*(def[^umag]\\(\\w\\|\\s_\\)+\\*?" find-function-space-re "%s\\(\\s-\\|$\\)") + (concat"^\\s-*(def[^fumag]\\(\\w\\|\\s_\\)+\\*?" find-function-space-re "%s\\(\\s-\\|$\\)") "The regexp used by `find-variable' to search for a variable definition. -It should match right up to the variable name. The default value -avoids `defun', `defmacro', `defalias', `defadvice', `defgroup'. +Note it must contain a `%s' at the place where `format' +should insert the variable name. The default value +avoids `defun', `defmacro', `defalias', `defadvice', `defgroup', `defface'. Please send improvements and fixes to the maintainer." :type 'regexp :group 'find-function :version "21.1") +(defcustom find-face-regexp + (concat"^\\s-*(defface" find-function-space-re "%s\\(\\s-\\|$\\)") + "The regexp used by `find-face' to search for a face definition. +Note it must contain a `%s' at the place where `format' +should insert the face name. + +Please send improvements and fixes to the maintainer." + :type 'regexp + :group 'find-function + :version "21.4") + +(defvar find-function-regexp-alist + '((nil . find-function-regexp) + (defvar . find-variable-regexp) + (defface . find-face-regexp)) + "Alist mapping definition types into regexp variables. +Each regexp variable's value should actually be a format string +to be used to substitute the desired symbol name into the regexp.") +(put 'find-function-regexp-alist 'risky-local-variable t) + (defcustom find-function-source-path nil "The default list of directories where `find-function' searches. @@ -136,9 +157,9 @@ See the functions `find-function' and `find-variable'." If nil, do not try to find the source code of functions and variables defined in C.") -(defun find-function-C-source (fun-or-var file variable-p) +(defun find-function-C-source (fun-or-var file type) "Find the source location where SUBR-OR-VAR is defined in FILE. -VARIABLE-P should be non-nil for a variable or nil for a subroutine." +TYPE should be nil to find a function, or `defvar' to find a variable." (unless find-function-C-source-directory (setq find-function-C-source-directory (read-directory-name "Emacs C source dir: " nil nil t))) @@ -146,12 +167,12 @@ VARIABLE-P should be non-nil for a variable or nil for a subroutine." (unless (file-readable-p file) (error "The C source file %s is not available" (file-name-nondirectory file))) - (unless variable-p + (unless type (setq fun-or-var (indirect-function fun-or-var))) (with-current-buffer (find-file-noselect file) (goto-char (point-min)) (unless (re-search-forward - (if variable-p + (if type (concat "DEFVAR[A-Z_]*[ \t\n]*([ \t\n]*\"" (regexp-quote (symbol-name fun-or-var)) "\"") @@ -175,10 +196,12 @@ VARIABLE-P should be non-nil for a variable or nil for a subroutine." (condition-case nil (switch-to-buffer buf) (error (pop-to-buffer buf))))) ;;;###autoload -(defun find-function-search-for-symbol (symbol variable-p library) - "Search for SYMBOL. -If VARIABLE-P is nil, `find-function-regexp' is used, otherwise -`find-variable-regexp' is used. The search is done in library LIBRARY." +(defun find-function-search-for-symbol (symbol type library) + "Search for SYMBOL's definition of type TYPE in LIBRARY. +If TYPE is nil, look for a function definition. +Otherwise, TYPE specifies the kind of definition, +and it is interpreted via `find-function-regexp-alist'. +The search is done in the source for library LIBRARY." (if (null library) (error "Don't know where `%s' is defined" symbol)) ;; Some functions are defined as part of the construct @@ -186,14 +209,13 @@ If VARIABLE-P is nil, `find-function-regexp' is used, otherwise (while (and (symbolp symbol) (get symbol 'definition-name)) (setq symbol (get symbol 'definition-name))) (if (string-match "\\`src/\\(.*\\.c\\)\\'" library) - (find-function-C-source symbol (match-string 1 library) variable-p) + (find-function-C-source symbol (match-string 1 library) type) (if (string-match "\\.el\\(c\\)\\'" library) (setq library (substring library 0 (match-beginning 1)))) - (let* ((filename (find-library-name library))) + (let* ((filename (find-library-name library)) + (regexp-symbol (cdr (assq type find-function-regexp-alist)))) (with-current-buffer (find-file-noselect filename) - (let ((regexp (format (if variable-p - find-variable-regexp - find-function-regexp) + (let ((regexp (format (symbol-value regexp-symbol) (regexp-quote (symbol-name symbol)))) (case-fold-search)) (with-syntax-table emacs-lisp-mode-syntax-table @@ -245,55 +267,53 @@ in `load-path'." ((symbol-file function 'defun))))) (find-function-search-for-symbol function nil library)))) -(defalias 'function-at-point 'function-called-at-point) - -(defun find-function-read (&optional variable-p) +(defun find-function-read (&optional type) "Read and return an interned symbol, defaulting to the one near point. -If the optional VARIABLE-P is nil, then a function is gotten -defaulting to the value of the function `function-at-point', otherwise -a variable is asked for, with the default coming from -`variable-at-point'." - (let ((symb (funcall (if variable-p - 'variable-at-point - 'function-at-point))) +If TYPE is nil, insist on a symbol with a function definition. +Otherwise TYPE should be `defvar' or `defface'. +If TYPE is nil, defaults using `function-called-at-point', +otherwise uses `variable-at-point'." + (let ((symb (if (null type) + (function-called-at-point) + (if (eq type 'defvar) + (variable-at-point) + (variable-at-point t)))) + (predicate (cdr (assq type '((nil . fboundp) (defvar . boundp) + (defface . facep))))) + (prompt (cdr (assq type '((nil . "function") (defvar . "variable") + (defface . "face"))))) (enable-recursive-minibuffers t) val) (if (equal symb 0) (setq symb nil)) - (setq val (if variable-p - (completing-read - (concat "Find variable" - (if symb - (format " (default %s)" symb)) - ": ") - obarray 'boundp t nil) - (completing-read - (concat "Find function" - (if symb - (format " (default %s)" symb)) - ": ") - obarray 'fboundp t nil))) + (setq val (completing-read + (concat "Find " + prompt + (if symb + (format " (default %s)" symb)) + ": ") + obarray predicate t nil)) (list (if (equal val "") symb (intern val))))) -(defun find-function-do-it (symbol variable-p switch-fn) +(defun find-function-do-it (symbol type switch-fn) "Find Emacs Lisp SYMBOL in a buffer and display it. -If VARIABLE-P is nil, a function definition is searched for, otherwise -a variable definition is searched for. The start of a definition is -centered according to the variable `find-function-recenter-line'. -See also `find-function-after-hook' It is displayed with function SWITCH-FN. +TYPE is nil to search for a function definition, +or else `defvar' or `defface'. + +The variable `find-function-recenter-line' controls how +to recenter the display. SWITCH-FN is the function to call +to display and select the buffer. +See also `find-function-after-hook'. -Point is saved in the buffer if it is one of the current buffers." +Set mark before moving, if the buffer already existed." (let* ((orig-point (point)) (orig-buf (window-buffer)) (orig-buffers (buffer-list)) (buffer-point (save-excursion - (funcall (if variable-p - 'find-variable-noselect - 'find-function-noselect) - symbol))) + (find-definition-noselect symbol type))) (new-buf (car buffer-point)) (new-point (cdr buffer-point))) (when buffer-point @@ -309,9 +329,9 @@ Point is saved in the buffer if it is one of the current buffers." "Find the definition of the FUNCTION near point. Finds the Emacs Lisp library containing the definition of the function -near point (selected by `function-at-point') in a buffer and -places point before the definition. Point is saved in the buffer if -it is one of the current buffers. +near point (selected by `function-called-at-point') in a buffer and +places point before the definition. +Set mark before moving, if the buffer already existed. The library where FUNCTION is defined is searched for in `find-function-source-path', if non nil, otherwise in `load-path'. @@ -340,15 +360,15 @@ See `find-function' for more details." "Return a pair `(BUFFER . POINT)' pointing to the definition of SYMBOL. Finds the Emacs Lisp library containing the definition of SYMBOL -in a buffer and the point of the definition. The buffer is -not selected. +in a buffer, and the point of the definition. It does not switch +to the buffer or display it. 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")) (let ((library (or file (symbol-file variable 'defvar)))) - (find-function-search-for-symbol variable 'variable library))) + (find-function-search-for-symbol variable 'defvar library))) ;;;###autoload (defun find-variable (variable) @@ -356,35 +376,70 @@ The library where VARIABLE is defined is searched for in FILE or Finds the Emacs Lisp library containing the definition of the variable near point (selected by `variable-at-point') in a buffer and -places point before the definition. Point is saved in the buffer if -it is one of the current buffers. +places point before the definition. + +Set mark before moving, if the buffer already existed. The library where VARIABLE is defined is searched for in `find-function-source-path', if non nil, otherwise in `load-path'. See also `find-function-recenter-line' and `find-function-after-hook'." - (interactive (find-function-read 'variable)) - (find-function-do-it variable t 'switch-to-buffer)) + (interactive (find-function-read 'defvar)) + (find-function-do-it variable 'defvar 'switch-to-buffer)) ;;;###autoload (defun find-variable-other-window (variable) "Find, in another window, the definition of VARIABLE near point. See `find-variable' for more details." - (interactive (find-function-read 'variable)) - (find-function-do-it variable t 'switch-to-buffer-other-window)) + (interactive (find-function-read 'defvar)) + (find-function-do-it variable 'defvar 'switch-to-buffer-other-window)) ;;;###autoload (defun find-variable-other-frame (variable) "Find, in annother frame, the definition of VARIABLE near point. See `find-variable' for more details." - (interactive (find-function-read 'variable)) - (find-function-do-it variable t 'switch-to-buffer-other-frame)) + (interactive (find-function-read 'defvar)) + (find-function-do-it variable 'defvar 'switch-to-buffer-other-frame)) + +;;;###autoload +(defun find-definition-noselect (symbol type &optional file) + "Return a pair `(BUFFER . POINT)' pointing to the definition of SYMBOL. +TYPE says what type of definition: nil for a function, +`defvar' or `defface' for a variable or face. This functoin +does not switch to the buffer or display it. + +The library where SYMBOL is defined is searched for in FILE or +`find-function-source-path', if non nil, otherwise in `load-path'." + (if (not symbol) + (error "You didn't specify a symbol")) + (if (null type) + (find-function-noselect symbol) + (let ((library (or file (symbol-file symbol type)))) + (find-function-search-for-symbol symbol type library)))) + +;; For symmetry, this should be called find-face; but some programs +;; assume that, if that name is defined, it means something else. +;;;###autoload +(defun find-face-definition (face) + "Find the definition of FACE. FACE defaults to the name near point. + +Finds the Emacs Lisp library containing the definition of the face +near point (selected by `variable-at-point') in a buffer and +places point before the definition. + +Set mark before moving, if the buffer already existed. + +The library where FACE is defined is searched for in +`find-function-source-path', if non nil, otherwise in `load-path'. +See also `find-function-recenter-line' and `find-function-after-hook'." + (interactive (find-function-read 'defface)) + (find-function-do-it face 'defface 'switch-to-buffer)) ;;;###autoload (defun find-function-on-key (key) "Find the function that KEY invokes. KEY is a string. -Point is saved if FUNCTION is in the current buffer." +Set mark before moving, if the buffer already existed." (interactive "kFind function on key: ") (let (defn) (save-excursion @@ -412,7 +467,7 @@ Point is saved if FUNCTION is in the current buffer." (defun find-function-at-point () "Find directly the function at point in the other window." (interactive) - (let ((symb (function-at-point))) + (let ((symb (function-called-at-point))) (when symb (find-function-other-window symb)))) @@ -437,5 +492,5 @@ Point is saved if FUNCTION is in the current buffer." (provide 'find-func) -;;; arch-tag: 43ecd81c-74dc-4d9a-8f63-a61e55670d64 +;; arch-tag: 43ecd81c-74dc-4d9a-8f63-a61e55670d64 ;;; find-func.el ends here diff --git a/lisp/emacs-lisp/lisp-mnt.el b/lisp/emacs-lisp/lisp-mnt.el index 671f3c8ce2a..701da1c4dec 100644 --- a/lisp/emacs-lisp/lisp-mnt.el +++ b/lisp/emacs-lisp/lisp-mnt.el @@ -304,9 +304,14 @@ If FILE is nil, execute BODY in the current buffer." (if ,filesym (with-temp-buffer (insert-file-contents ,filesym) + (lisp-mode) ,@body) (save-excursion - ,@body))))) + ;; Switching major modes is too drastic, so just switch + ;; temporarily to the Lisp mode syntax table. + (with-syntax-table lisp-mode-syntax-table + ,@body)))))) + (put 'lm-with-file 'lisp-indent-function 1) (put 'lm-with-file 'edebug-form-spec t) diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el index f4364c38e8d..f181f3683f0 100644 --- a/lisp/emacs-lisp/lisp-mode.el +++ b/lisp/emacs-lisp/lisp-mode.el @@ -1125,7 +1125,8 @@ ENDPOS is encountered." (set-marker endmark nil)))) (defun indent-pp-sexp (&optional arg) - "Indent each line of the list or, with prefix ARG, pretty-printify the list." + "Indent each line of the list starting just after point, or prettyprint it. +A prefix argument specifies pretty-printing." (interactive "P") (if arg (save-excursion diff --git a/lisp/emacs-lisp/re-builder.el b/lisp/emacs-lisp/re-builder.el index 77a12167c30..019a45213c8 100644 --- a/lisp/emacs-lisp/re-builder.el +++ b/lisp/emacs-lisp/re-builder.el @@ -1,6 +1,6 @@ ;;; re-builder.el --- building Regexps with visual feedback -;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc. +;; Copyright (C) 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc. ;; Author: Detlev Zundel <dzu@gnu.org> ;; Keywords: matching, lisp, tools @@ -61,12 +61,12 @@ ;; even the auto updates go all the way. Forcing an update overrides ;; this limit allowing an easy way to see all matches. -;; Currently `re-builder' understands four different forms of input, -;; namely `read', `string', `sregex' and `lisp-re' syntax. Read +;; Currently `re-builder' understands five different forms of input, +;; namely `read', `string', `rx', `sregex' and `lisp-re' syntax. Read ;; syntax and string syntax are both delimited by `"'s and behave ;; according to their name. With the `string' syntax there's no need ;; to escape the backslashes and double quotes simplifying the editing -;; somewhat. The other two allow editing of symbolic regular +;; somewhat. The other three allow editing of symbolic regular ;; expressions supported by the packages of the same name. (`lisp-re' ;; is a package by me and its support may go away as it is nearly the ;; same as the `sregex' package in Emacs) |