;ELC ;;; compiled by kwzh@hal.gnu.ai.mit.edu on Mon Apr 17 19:45:09 1995 ;;; from file /gd/gnu/emacs/19.0/lisp/lisp.el ;;; emacs version 19.28.90.26. ;;; 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 "`/gd/gnu/emacs/19.0/lisp/lisp.el' was compiled for Emacs 19")) #@172 *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'. (defvar defun-prompt-regexp nil (#$ . -478)) (make-variable-buffer-local (quote defun-prompt-regexp)) #@69 Non-nil => `insert-parentheses' should insert whitespace as needed. (defvar parens-require-spaces t (#$ . 757)) #@159 Move forward across one balanced expression (sexp). With argument, do it that many times. Negative arg -N means move backward across N balanced expressions. (defalias 'forward-sexp #[(&optional arg) "`\"!bW " [arg 1 scan-sexps buffer-end 0 backward-prefix-chars] 3 (#$ . 876) "p"]) #@159 Move backward across one balanced expression (sexp). With argument, do it that many times. Negative arg -N means move forward across N balanced expressions. (defalias 'backward-sexp #[(&optional arg) "[!" [arg 1 forward-sexp] 2 (#$ . 1187) "p"]) #@124 Set mark ARG sexps from point. The place mark goes is the same place \[forward-sexp] would move to with the same argument. (defalias 'mark-sexp #[(arg) "\n!`)#" [push-mark forward-sexp arg nil t] 4 (#$ . 1450) "p"]) #@162 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. (defalias 'forward-list #[(&optional arg) "`#!b" [arg 1 scan-lists 0 buffer-end] 4 (#$ . 1680) "p"]) #@162 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. (defalias 'backward-list #[(&optional arg) "[!" [arg 1 forward-list] 2 (#$ . 1964) "p"]) #@195 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. (defalias 'down-list #[(arg) "V\n‚ U?(`\f#!b\fZ )" [arg 0 1 -1 inc scan-lists buffer-end] 5 (#$ . 2230) "p"]) #@201 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. (defalias 'backward-up-list #[(arg) " [!" [up-list arg] 2 (#$ . 2567) "p"]) #@201 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. (defalias 'up-list #[(arg) "V\n‚ U?(`\f#!b\fZ )" [arg 0 1 -1 inc scan-lists buffer-end] 5 (#$ . 2852) "p"]) #@167 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. (defalias 'kill-sexp #[(arg) "`\n!`\")" [opoint forward-sexp arg kill-region] 3 (#$ . 3193) "p"]) #@167 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. (defalias 'backward-kill-sexp #[(arg) " [!" [kill-sexp arg] 2 (#$ . 3470) "p"]) #@484 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. (defalias 'beginning-of-defun #[(&optional arg) " !\nyÇ" [beginning-of-defun-raw arg 0 t] 2 (#$ . 3725) "p"]) #@191 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. (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 (#$ . 4331) "p"]) (defalias 'buffer-end #[(arg) "Vde" [arg 0] 2]) #@284 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'. (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 (#$ . 4806) "p"]) #@118 Put mark at end of this defun, point at beginning. The defun marked is the one that contains point or follows point. (defalias 'mark-defun #[nil "`! `# `Z#" [push-mark end-of-defun nil t beginning-of-defun re-search-backward "^\n" 1] 4 (#$ . 5433) nil]) #@280 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. (defalias 'insert-parentheses #[(arg) " ! =w )o)hz>)cc=7!c Lm?Lgz>Lc)" [arg prefix-numeric-value 0 " " nil parens-require-spaces (119 95 41) " " 40 forward-sexp 41 (119 95 40)] 2 (#$ . 5709) "P"]) #@73 Move past next `)', delete indentation before it, then indent after it. (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 (#$ . 6240) nil]) #@354 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. (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 (#$ . 6506) nil])