;;; compiled by roland@geech.gnu.ai.mit.edu on Sun May 16 22:36:42 1993 ;;; from file /gd/gnu/emacs/19.0/lisp/lisp.el ;;; emacs version 19.6.3. ;;; bytecomp version FSF 2.08 ;;; optimization is on. (defvar defun-prompt-regexp nil "\ Non-nil => regexp to ignore, before the `(' that starts a defun.") (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?(` #!b Z )" [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?(` #!b Z )" [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) "W!  R#$,!͇" [arg 0 forward-char 1 re-search-backward defun-prompt-regexp "^\\s(\\|" "\\(" "\\)\\s(" "^\\s(" nil move forward-line t] 5 "\ 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." "p"]) (fset (quote buffer-end) #[(arg) "Vde" [arg 0] 2]) (defalias 'end-of-defun #[(&optional arg) "\nU V]`dW]` .!!:o6!!!!!N!`X *SW`!!!`Y!!!!!eb)T^)" [arg 0 1 t first nil npos pos forward-char beginning-of-defun -1 forward-list skip-chars-forward " " looking-at "\\s<\\|\n" forward-line forward-sexp 2 "[;\n]"] 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) " ! =!h!>\"cc=0!cg!>=c)" [arg prefix-numeric-value 0 skip-chars-forward " " char-syntax (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." "P"]) (defalias 'move-past-close-and-reindent #[nil "!!` ` U* ! " [up-list 1 forward-char -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 "` Î !!g!U!`*  \"  Sf=7ς8 #=Z \"  \"o \"c! #=@!!@D@BA!)!)\"." [end syntax-table buffer-syntax ((set-syntax-table buffer-syntax)) set-syntax-table emacs-lisp-mode-syntax-table backward-sexp 1 char-syntax 39 forward-char beg buffer-substring pattern 40 fboundp #[(sym) " ! ! !" [boundp sym fboundp symbol-plist] 2] predicate try-completion obarray completion t message "Can't find completion for \"%s\"" ding string= delete-region "Making completion list..." all-completions list nil new intern " " nreverse " *Completions*" display-completion-list "Making completion list...%s" "done"] 5 "\ Perform completion on Lisp symbol preceding point. That symbol is compared against the symbols that exist and any additional characters determined by what is there are inserted. 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])