;ELC ;;; compiled by rms@mole.gnu.ai.mit.edu on Tue Jul 12 02:53:51 1994 ;;; from file /home/fsf/rms/e19/lisp/lisp.el ;;; emacs version 19.25.16. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19"))) (error "`/home/fsf/rms/e19/lisp/lisp.el' was compiled for Emacs 19")) (defvar defun-prompt-regexp nil "\ *Non-nil => regexp to ignore, before the character that starts a defun. This is only necessary if the opening paren or brace is not in column 0. See `beginning-of-defun'.") (make-variable-buffer-local (quote defun-prompt-regexp)) (defvar parens-require-spaces t "\ Non-nil => `insert-parentheses' should insert whitespace as needed.") (defalias 'forward-sexp #[(&optional arg) "`\"!bW " [arg 1 scan-sexps buffer-end 0 backward-prefix-chars] 3 "\ Move forward across one balanced expression (sexp). With argument, do it that many times. Negative arg -N means move backward across N balanced expressions." "p"]) (defalias 'backward-sexp #[(&optional arg) "[!" [arg 1 forward-sexp] 2 "\ Move backward across one balanced expression (sexp). With argument, do it that many times. Negative arg -N means move forward across N balanced expressions." "p"]) (defalias 'mark-sexp #[(arg) "\n!`)#" [push-mark forward-sexp arg nil t] 4 "\ Set mark ARG sexps from point. The place mark goes is the same place \\[forward-sexp] would move to with the same argument." "p"]) (defalias 'forward-list #[(&optional arg) "`#!b" [arg 1 scan-lists 0 buffer-end] 4 "\ Move forward across one balanced group of parentheses. With argument, do it that many times. Negative arg -N means move backward across N groups of parentheses." "p"]) (defalias 'backward-list #[(&optional arg) "[!" [arg 1 forward-list] 2 "\ Move backward across one balanced group of parentheses. With argument, do it that many times. Negative arg -N means move forward across N groups of parentheses." "p"]) (defalias 'down-list #[(arg) "V\n‚ U?(`\f#!b\fZ )" [arg 0 1 -1 inc scan-lists buffer-end] 5 "\ Move forward down one level of parentheses. With argument, do this that many times. A negative argument means move backward but still go down a level. In Lisp programs, an argument is required." "p"]) (defalias 'backward-up-list #[(arg) " [!" [up-list arg] 2 "\ Move backward out of one level of parentheses. With argument, do this that many times. A negative argument means move forward but still to a less deep spot. In Lisp programs, an argument is required." "p"]) (defalias 'up-list #[(arg) "V\n‚ U?(`\f#!b\fZ )" [arg 0 1 -1 inc scan-lists buffer-end] 5 "\ Move forward out of one level of parentheses. With argument, do this that many times. A negative argument means move backward but still to a less deep spot. In Lisp programs, an argument is required." "p"]) (defalias 'kill-sexp #[(arg) "`\n!`\")" [opoint forward-sexp arg kill-region] 3 "\ Kill the sexp (balanced expression) following the cursor. With argument, kill that many sexps after the cursor. Negative arg -N means kill N sexps before the cursor." "p"]) (defalias 'backward-kill-sexp #[(arg) " [!" [kill-sexp arg] 2 "\ Kill the sexp (balanced expression) preceding the cursor. With argument, kill that many sexps before the cursor. Negative arg -N means kill N sexps after the cursor." "p"]) (defalias 'beginning-of-defun #[(&optional arg) " !\nyÇ" [beginning-of-defun-raw arg 0 t] 2 "\ Move backward to the beginning of a defun. With argument, do it that many times. Negative arg -N means move forward to Nth following beginning of defun. Returns t unless search stops due to beginning or end of buffer. Normally a defun starts when there is an char with open-parenthesis syntax at the beginning of a line. If `defun-prompt-regexp' is non-nil, then a string which matches that regexp may precede the open-parenthesis, and point ends up at the beginning of the line." "p"]) (defalias 'beginning-of-defun-raw #[(&optional arg) "Wmu\f\fR&$2Sb2ˇ" [arg 0 1 re-search-backward defun-prompt-regexp "^\\s(\\|" "\\(" "\\)\\s(" "^\\s(" nil move t] 5 "\ Move point to the character that starts a defun. This is identical to beginning-of-defun, except that point does not move to the beginning of the line when `defun-prompt-regexp' is non-nil." "p"]) (defalias (quote buffer-end) #[(arg) "Vde" [arg 0] 2]) (defalias 'end-of-defun #[(&optional arg) "\nU\fVZ`dWZ`\f-!8o4u!!w!Ky`X *SW`!!y`Y!!w!yeb)T[)" [arg 0 1 t first nil npos pos beginning-of-defun-raw -1 forward-list " " looking-at "\\s<\\|\n" forward-sexp 2] 3 "\ Move forward to next end of defun. With argument, do it that many times. Negative argument -N means move back to Nth preceding end of defun. An end of a defun occurs right after the close-parenthesis that matches the open-parenthesis that starts a defun; see `beginning-of-defun'." "p"]) (defalias 'mark-defun #[nil "`! `# `Z#" [push-mark end-of-defun nil t beginning-of-defun re-search-backward "^\n" 1] 4 "\ Put mark at end of this defun, point at beginning. The defun marked is the one that contains point or follows point." nil]) (defalias 'insert-parentheses #[(arg) " ! =w %hz>%cc=3!c Cgz>Cc)" [arg prefix-numeric-value 0 " " nil parens-require-spaces (119 95 41) " " 40 forward-sexp 41 (119 95 40)] 2 "\ Put parentheses around next ARG sexps. Leave point after open-paren. No argument is equivalent to zero: just insert `()' and leave point between. If `parens-require-spaces' is non-nil, this command also inserts a space before and after, depending on the surrounding characters." "P"]) (defalias 'move-past-close-and-reindent #[nil "!u` ` U* u " [up-list 1 -1 before-paren back-to-indentation delete-indentation newline-and-indent] 2 "\ Move past next `)', delete indentation before it, then indent after it." nil]) (defalias 'lisp-complete-symbol #[nil "` Î !!gzUu`* {\n Sf=3̂4\n#=V\n\" \ni |c!\n#=@!!@D@BA)ߐ!*\"." [end syntax-table buffer-syntax ((set-syntax-table buffer-syntax)) set-syntax-table emacs-lisp-mode-syntax-table backward-sexp 1 39 beg pattern 40 fboundp #[(sym) " ! ! !" [boundp sym fboundp symbol-plist] 2] predicate try-completion obarray completion t message "Can't find completion for \"%s\"" ding "Making completion list..." all-completions #[nil "e`Z]b!)u" [4 looking-at " " -4] 3] completion-fixup-function list nil new intern " " "*Completions*" display-completion-list "Making completion list...%s" "done"] 5 "\ Perform completion on Lisp symbol preceding point. Compare that symbol against the known Lisp symbols. The context determines which symbols are considered. If the symbol starts just after an open-parenthesis, only symbols with function definitions are considered. Otherwise, all symbols with function definitions, values or properties are considered." nil])