;ELC ;;; compiled by rms@mole.gnu.ai.mit.edu on Sat Sep 3 19:34:50 1994 ;;; from file /home/fsf/rms/e19/lisp/simple.el ;;; emacs version 19.25.94.1. ;;; 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/simple.el' was compiled for Emacs 19")) (defalias 'open-line #[(arg) "n?no?# = ` BuV> 2ccS&)\nHu*" [fill-prefix do-fill-prefix flag buffer-undo-list t -1 arg 0 10 nil 1] 3 "\ Insert a newline and leave point before it. If there is a fill prefix, insert the fill prefix on the new line if the line would have been empty. With arg N, insert N newlines." "*p"]) (defalias 'split-line #[nil "wi`c \"\nb*" [" " nil pos col 10 indent-to 0] 3 "\ Split current line, moving portion beyond point vertically down." "*"]) (defalias 'quoted-insert #[(arg) "\n=  =!\f\")" [overwrite-mode overwrite-mode-binary read-quoted-char read-char char delete-char arg insert-char] 3 "\ Read next input character and insert it. This is useful for inserting control characters. You may also type up to 3 octal digits, to insert a character with that code. In overwrite mode, this function inserts the character anyway, and does not handle octal digits specially. This means that if you use overwrite as your normal editing mode, you can use this function to insert characters when necessary. In binary overwrite mode, this function does overwrite, and octal digits are interpreted as a character code. This is supposed to make this function useful in editing binary files." "*p"]) (defalias 'delete-indentation #[(&optional arg) "y \nyh=6``S|\f4`\fG\\dX4\f``\fG\\{4``\fG\\| " [0 arg 1 10 fill-prefix fixup-whitespace] 4 "\ Join this line to previous and fix up whitespace at join. If there is a fill prefix, delete it from the beginning of this line. With argument, join this line to following line." "*P"]) (defalias 'fixup-whitespace #[nil " !u!)?c)" [delete-horizontal-space looking-at "^\\|\\s)" -1 "$\\|\\s(\\|\\s'" 32] 2 "\ Fixup white space between objects around point. Leave one space or none, according to the context." "*"]) (defalias 'delete-horizontal-space #[nil "x`w`|" [" " nil] 3 "\ Delete all spaces and tabs around point." "*"]) (defalias 'just-one-space #[nil "xgUuc`w`|" [" " nil 32 1] 3 "\ Delete all spaces and tabs around point, leaving one space." "*"]) (defalias 'delete-blank-lines #[nil "y!\"!?\"o\"y!?)\nEy 2y`#By`Ce|\nM hy`#dy`ed|)!q`d|*" [nil singleblank thisblank 0 looking-at "[ ]*$" "[ ]*\n[ ]*$" -1 1 re-search-backward "[^ \n]" t re-search-forward "^[ ]*\n\\'"] 6 "\ On blank line, delete all surrounding blank lines, leaving just one. On isolated blank line, delete that one. On nonblank line, delete any immediately following blank lines." "*"]) (defalias 'back-to-indentation #[nil "yw" [0 " " nil] 2 "\ Move point to the first non-whitespace character on this line." nil]) (defalias 'newline-and-indent #[nil "`x`| " [" " nil newline indent-according-to-mode] 3 "\ Insert a newline, then indent according to major mode. Indentation is done using the value of `indent-line-function'. In programming language modes, this is the same as TAB. In some text modes, where TAB inserts a tab, this command indents to the column specified by the variable `left-margin'." "*"]) (defalias 'reindent-then-newline-and-indent #[nil "`x`| ) " [" " nil indent-according-to-mode newline] 3 "\ Reindent current line, insert newline, then indent the new line. Indentation of both lines is done according to the current major mode, which means calling the current value of `indent-line-function'. In programming language modes, this is the same as TAB. In some text modes, where TAB inserts a tab, this indents to the column specified by the variable `left-margin'." "*"]) (byte-code "\"\"" [defalias kill-forward-chars #[(arg) "<@=``\\\"" [arg - -1 kill-region] 4] kill-backward-chars #[(arg) "<@=``Z\"" [arg - -1 kill-region] 4]] 3) (defalias 'backward-delete-char-untabify #[(arg &optional killp) " V0o0hU&iu\fiZ\f\"!)u S* \"\fGl?G\")" [arg count 0 9 col -1 insert-char 32 delete-char 1 delete-backward-char killp overwrite-mode] 4 "\ Delete characters backward, changing tabs into spaces. Delete ARG chars, and kill (save in kill ring) if KILLP is non-nil. Interactively, ARG is the prefix arg (default 1) and KILLP is t if a prefix arg was specified." "*p\nP"]) (defalias 'zap-to-char #[(arg char) "` !ĉ $`\"" [kill-region search-forward char-to-string char nil arg] 7 "\ Kill up to and including ARG'th occurrence of CHAR. Goes backward if ARG is negative; error if CHAR not found." "p\ncZap to char: "]) (defalias 'beginning-of-buffer #[(&optional arg) " & V ! ť_' !_\\ť'eb /y" [push-mark arg buffer-size 10000 prefix-numeric-value 10 1] 3 "\ Move point to the beginning of the buffer; leave mark at previous position. With arg N, put point N/10 of the way from the true beginning. Don't use this command in Lisp programs! (goto-char (point-min)) is faster and avoids clobbering the mark." "P"]) (defalias 'end-of-buffer #[(&optional arg) " ( T V ! ť_$ !_ťZ)db 2y` b !`W*N`!!" [push-mark arg buffer-size 10000 prefix-numeric-value 10 1 old-point window-start vertical-motion window-height overlay-recenter recenter -3] 4 "\ Move point to the end of the buffer; leave mark at previous position. With arg N, put point N/10 of the way from the true end. Don't use this command in Lisp programs! (goto-char (point-max)) is faster and avoids clobbering the mark." "P"]) (defalias 'mark-whole-buffer #[nil "`!d#eb" [push-mark nil t] 4 "\ Put point at beginning and mark at end of buffer. You probably should not use this function in Lisp programs; it is usually a mistake for a Lisp function to use any subroutine that uses or sets the mark." nil]) (defalias 'count-lines-region #[(start end) " \f\"\f Z#" [message "Region has %d lines, %d characters" count-lines start end] 5 "\ Print number of lines and characters in the region." "r"]) (defalias 'what-line #[nil "~y`\"T\"*" [0 message "Line %d" count-lines 1] 5 "\ Print the current line number (in the buffer) of point." nil]) (defalias 'count-lines #[(start end) " Ž \f}eb =T$)\\$;\\)db \fUNnNTP)Z yZ," [match-data match-data ((store-match-data match-data)) start end selective-display t 0 done re-search-forward "[\n ]" nil 40 1 buffer-size] 5 "\ Return number of lines between START and END. This is usually the number of newlines between them, but can be one more if START is not equal to END and the greater of them is not at the start of a line."]) (defalias 'what-cursor-position #[nil "ged` V ǥ S\\ ȥ], ʥ S_\\ ] U9΂> \"i \nUv UV\n TUg  \n&  & U\n TU!  \n&\n!  &." [char beg end pos buffer-size total 50000 200 100 1 2 percent window-hscroll 0 "" format " Hscroll=%d" hscroll col message "point=%d of %d(%d%%) <%d - %d> column %d %s" "point=%d of %d(%d%%) column %d %s" "Char: %s (0%o) point=%d of %d(%d%%) <%d - %d> column %d %s" single-key-description "Char: %s (0%o) point=%d of %d(%d%%) column %d %s"] 12 "\ Print info on cursor position (on screen and within buffer)." nil]) (defalias 'fundamental-mode #[nil " " [kill-all-local-variables] 1 "\ Major mode not specialized for anything in particular. Other major modes are defined by comparison with this one." nil]) (defvar read-expression-map (cons (quote keymap) minibuffer-local-map) "\ Minibuffer keymap used for reading Lisp expressions.") (byte-code " ##! ʇ" [define-key read-expression-map "" lisp-complete-symbol put eval-expression disabled t boundp read-expression-history nil] 4) (defalias 'eval-expression #[(expression) " !\nB\n@\"" [eval expression values prin1 t] 3 "\ Evaluate EXPRESSION and print value in minibuffer. Value is also consed on to front of the variable `values'." (list (read-from-minibuffer "Eval: " nil read-expression-map t (quote read-expression-history)))]) (defalias 'edit-and-eval-command #[(prompt command) " !\f% !)" [read-from-minibuffer prompt prin1-to-string command read-expression-map t (command-history . 1) eval] 6 "\ Prompting with PROMPT, let user edit COMMAND and eval result. COMMAND is a Lisp expression. Let user edit that expression in the minibuffer, then read and evaluate the result."]) (defalias 'repeat-complex-command #[(arg) "S 89! B% @;( A\f @3\f B\f!; ," [arg command-history t nil newcmd minibuffer-history-sexp-flag minibuffer-history-position elt read-from-minibuffer "Redo: " prin1-to-string read-expression-map eval ding] 8 "\ Edit and re-evaluate last complex command, or ARGth from last. A complex command is one which used the minibuffer. The command is placed in the minibuffer as a Lisp form for editing. The result is executed, repeating the command as changed. If the command has been changed or is not the most recent previous command it is added to the front of the command history. You can use the minibuffer history commands \\\\[next-history-element] and \\[previous-history-element] to get different commands to edit and resubmit." "p"]) (defvar minibuffer-history nil "\ Default minibuffer history list. This is used for all minibuffer input except when an alternate history list is specified.") (defvar minibuffer-history-sexp-flag nil "\ Non-nil when doing history operations on `command-history'. More generally, indicates that the history list being acted on contains expressions rather than strings.") (byte-code "!\f\"" [minibuffer-history minibuffer-history-variable nil minibuffer-history-position boundp minibuffer-history-search-history mapcar #[(key-and-command) "\"" [mapcar #[(keymap-and-completionp) " @J\n@\nA: @ )#" [define-key keymap-and-completionp key-and-command command] 5] ((minibuffer-local-map) (minibuffer-local-ns-map) (minibuffer-local-completion-map . t) (minibuffer-local-must-match-map . t) (read-expression-map))] 3] (("n" next-history-element . next-complete-history-element) ([next] next-history-element . next-complete-history-element) ("p" previous-history-element . previous-complete-history-element) ([prior] previous-history-element . previous-complete-history-element) ("r" . previous-matching-history-element) ("s" . next-matching-history-element))] 3) (defalias 'previous-matching-history-element #[(regexp n) "J\nUe  Wɂ\\] G^\fU8 U5˂6!I S 8!M S 8\"W]Ȃ^\\  S 8|!~c)eb+@@=@@=A" [minibuffer-history-variable nil minibuffer-history-position pos prevpos history n 0 1 -1 error "No later matching history item" "No earlier matching history item" string-match regexp minibuffer-history-sexp-flag prin1-to-string erase-buffer elt command-history previous-matching-history-element next-matching-history-element] 6 "\ Find the previous history element that matches REGEXP. (Previous history elements refer to earlier actions.) With prefix argument N, search for Nth previous match. If N is negative, find the next or Nth next match." (byte-code "%ɘA@ !+D" [t enable-recursive-minibuffers nil minibuffer-history-sexp-flag read-from-minibuffer "Previous element matching (regexp): " minibuffer-local-map minibuffer-history-search-history regexp "" prefix-numeric-value current-prefix-arg] 7)]) (defalias 'next-matching-history-element #[(regexp n) " \n[\"" [previous-matching-history-element regexp n] 3 "\ Find the next history element that matches REGEXP. (The next history element refers to a more recent action.) With prefix argument N, search for Nth next match. If N is negative, find the previous or Nth previous match." (byte-code "%ɘA@ !+D" [t enable-recursive-minibuffers nil minibuffer-history-sexp-flag read-from-minibuffer "Next element matching (regexp): " minibuffer-local-map minibuffer-history-search-history regexp "" prefix-numeric-value current-prefix-arg] 7)]) (defalias 'next-history-element #[(n) " \nZ] JG^ \fU UƂ!? \fS J8 \n8 !: c)eb)" [1 minibuffer-history-position n minibuffer-history-variable narg error "End of history; no next item" "Beginning of history; no preceding item" erase-buffer elt minibuffer-history-sexp-flag prin1-to-string] 4 "\ Insert the next element of the minibuffer history into the minibuffer." "p"]) (defalias 'previous-history-element #[(n) " [!" [next-history-element n] 2 "\ Inserts the previous element of the minibuffer history into the minibuffer." "p"]) (defalias 'next-complete-history-element #[(n) "`e`{!P\f\"b)" [point-at-start next-matching-history-element "^" regexp-quote n] 5 "\ Get next element of history which is a completion of minibuffer contents." "p"]) (defalias 'previous-complete-history-element #[(n) " [!" [next-complete-history-element n] 2 "\ Get previous element of history which is a completion of minibuffer contents." "p"]) (defalias 'goto-line #[(arg) "~b =S$Sy)" [1 selective-display t re-search-forward "[\n ]" nil end arg] 5 "\ Goto line ARG, counting from line 1 at beginning of buffer." "NGoto line: "]) (define-function (quote advertised-undo) (quote undo)) (defalias 'undo #[(&optional arg) "  =!\n=\" !)!]]@]@T@\"A6* k k\f!*ˉ" [t this-command buffer-modified-p recent-auto-save-p recent-save modified selected-window minibuffer-window message "Undo!" last-command undo undo-start undo-more 1 arg buffer-undo-list nil done tail delq delete-auto-save-file-if-necessary] 4 "\ Undo some previous changes. Repeat this command to undo more changes. A numeric argument serves as a repeat count." "*p"]) (defvar pending-undo-list nil "\ Within a run of consecutive undo commands, list remaining to be undone.") (defalias 'undo-start #[nil "=\n!" [buffer-undo-list t error "No undo information in this buffer" pending-undo-list] 2 "\ Set `pending-undo-list' to the front of the undo list. The next call to `undo-more' will undo the most recently made change."]) (defalias 'undo-more #[(count) "!\f\"" [pending-undo-list error "No further undo information" primitive-undo count] 3 "\ Undo back N undo-boundaries beyond what was already undone recently. Call `undo-start' to get ready to undo recent changes, then call `undo-more' one or more times to undo them."]) (defvar shell-command-history nil "\ History list for some commands that read shell commands.") (defalias 'shell-command #[(command &optional flag) " \f&! `pb \f͎\"!։O!^!Z!^!q !\f%\"\"\",``$*" [flag barf-if-buffer-read-only push-mark call-process shell-file-name nil t "-c" command mark mark-marker match-data data ((store-match-data data)) string-match "[ ]*&[ ]*$" get-buffer-create "*Shell-Command*" default-directory proc directory buffer 0 get-buffer-process yes-or-no-p "A command is running. Kill it? " kill-process error "Shell command in progress" erase-buffer display-buffer start-process "Shell" (":%s") mode-line-process set-process-sentinel shell-command-sentinel set-process-filter shell-command-filter shell-command-on-region] 8 "\ Execute string COMMAND in inferior shell; display output, if any. If COMMAND ends in ampersand, execute it asynchronously. Optional second arg non-nil (prefix arg, if interactive) means insert output in current buffer after point (leave mark after it). This cannot be done asynchronously." (list (read-from-minibuffer "Shell command: " nil nil nil (quote shell-command-history)) current-prefix-arg)]) (byte-code "\"\"" [defalias shell-command-sentinel #[(process signal) " !>, !!, !AA@O# !q\f) !" [process-status process (exit signal) buffer-name process-buffer message "%s: %s." process-command signal 0 -1 nil mode-line-process delete-process] 6] shell-command-filter #[(proc string) "p\n! !! ʎ q`dU `db\f!." [obuf process-buffer proc buffer nil opoint get-buffer-window window window-start pos ((byte-code " \n\" \f b\fq" [set-window-start window pos opoint obuf] 3)) insert-before-markers string] 2]] 3) (defalias 'shell-command-on-region #[(start end command &optional flag interactive) "F \f` W  ɉ\f&!9p=9!) D D )!Վp=vd|e|edɉ\f&ɉq )\f&ɉ+" [flag interactive mark swap push-mark call-process-region start end shell-file-name t nil "-c" command get-buffer "*Shell Command Output*" shell-buffer kill-buffer exchange-point-and-mark get-buffer-create success buffer ((byte-code "q U‚ed\")U* #!!P I\fUIʊqeb``{)\"P!\")ˇ" [buffer buffer-size 0 count-lines lines success message "(Shell command completed with no output)" kill-buffer 1 "%s" nil set-window-start display-buffer] 5)) erase-buffer] 10 "\ Execute string COMMAND in inferior shell with region as input. Normally display output (if any) in temp buffer `*Shell Command Output*'; Prefix arg means replace the region with it. Noninteractive args are START, END, COMMAND, FLAG. Noninteractively FLAG means insert output in place of text from START to END, and put point at the end, but don't alter the mark. If the output is one line, it is displayed in the echo area, but it is nonetheless available in buffer `*Shell Command Output*' even though that buffer is not automatically displayed. If there is no output or output is inserted in the current buffer then `*Shell Command Output*' is deleted." (list (region-beginning) (region-end) (read-from-minibuffer "Shell command on region: " nil nil nil (quote shell-command-history)) current-prefix-arg (prefix-numeric-value current-prefix-arg))]) (defalias 'universal-argument #[nil "\"\n!ǚ _\" \n #*" [4 nil key factor read-key-sequence t key-binding universal-argument prefix-arg-internal] 4 "\ Begin a numeric argument for the following command. Digits or minus sign following \\[universal-argument] make up the numeric argument. \\[universal-argument] following the digits or minus sign ends the argument. \\[universal-argument] without digits or minus sign provides 4 as argument. Repeating \\[universal-argument] without digits or minus sign multiplies the argument by 4 each time." nil]) (byte-code "\"\"" [defalias prefix-arg-internal #[(key factor value) "\n\nW\n[\n=Ț3 [ \";pGUp̙pp\nX\nY_HZ\\ \"5 { C\n\n _ U!=\n \"\"!)" [1 sign value 0 -1 - nil key "-" factor read-key-sequence t "0" "9" 10 48 prefix-arg key-binding universal-argument describe-arg listify-key-sequence unread-command-events] 4] describe-arg #[(value sign) "\f _\":@\" W !" [value message "Arg: %d" sign "Arg: [%d]" 0 "Arg: -"] 4]] 3) (defalias 'digit-argument #[(arg) " \"!#" [prefix-arg-internal char-to-string logand last-command-char 127 nil arg] 5 "\ Part of the numeric argument for the next command. \\[universal-argument] following digits or minus sign ends the argument." "P"]) (defalias 'negative-argument #[(arg) " #" [prefix-arg-internal "-" nil arg] 4 "\ Begin a negative numeric argument for the next command. \\[universal-argument] following digits or minus sign ends the argument." "P"]) (defalias 'forward-to-indentation #[(arg) "yw" [arg " " nil] 2 "\ Move forward ARG lines and position at first nonblank character." "p"]) (defalias 'backward-to-indentation #[(arg) "[yw" [arg " " nil] 2 "\ Move backward ARG lines and position at first nonblank character." "p"]) (defvar kill-whole-line nil "\ *If non-nil, `kill-line' with no arg at beg of line kills the whole line.") (defalias 'kill-line #[(&optional arg) "`  !y/m\"!&,n,y/`\"" [kill-region arg prefix-numeric-value signal end-of-buffer nil looking-at "[ ]*$" kill-whole-line 1] 5 "\ Kill the rest of the current line; if no nonblanks there, kill thru newline. With prefix argument, kill that many lines from point. Negative arguments kill lines backward. When calling from a program, nil means \"no arg\", a number counts as a prefix arg. If `kill-whole-line' is non-nil, then kill the whole line when given no argument at the beginning of a line." "P"]) (defvar interprogram-cut-function nil "\ Function to call to make a killed region available to other programs. Most window systems provide some sort of facility for cutting and pasting text between the windows of different programs. This variable holds a function that Emacs calls whenever text is put in the kill ring, to make the new kill available to other programs. The function takes one or two arguments. The first argument, TEXT, is a string containing the text which should be made available. The second, PUSH, if non-nil means this is a \"new\" kill; nil means appending to an \"old\" kill.") (defvar interprogram-paste-function nil "\ Function to call to get text cut from other programs. Most window systems provide some sort of facility for cutting and pasting text between the windows of different programs. This variable holds a function that Emacs calls to obtain text that other programs have provided for pasting. The function should be called with no arguments. If the function returns nil, then no other program has provided such text, and the top of the Emacs kill ring should be used. If the function returns a string, that string should be put in the kill ring as the latest kill. Note that the function should return a string only if a program other than Emacs has provided a string for pasting; if Emacs provided the most recent string, the function should return nil. If it is difficult to tell whether Emacs or some other program provided the current string, it is probably good enough to return nil if the string is equal (according to `string=') to the last text Emacs provided.") (defvar kill-ring nil "\ List of killed text sequences. Since the kill ring is supposed to interact nicely with cut-and-paste facilities offered by window systems, use of this variable should interact nicely with `interprogram-cut-function' and `interprogram-paste-function'. The functions `kill-new', `kill-append', and `current-kill' are supposed to implement this interaction; you may want to use them instead of manipulating the kill ring directly.") (defconst kill-ring-max 30 "\ *Maximum length of kill ring before oldest elements are thrown away.") (defvar kill-ring-yank-pointer nil "\ The tail of the kill ring whose car is the last thing yanked.") (defalias 'kill-new #[(string) " BG\nV\nS á   \"" [string kill-ring kill-ring-max nil kill-ring-yank-pointer interprogram-cut-function t] 4 "\ Make STRING the latest kill in the kill ring. Set the kill-ring-yank pointer to point to it. If `interprogram-cut-function' is non-nil, apply it to STRING."]) (defalias 'kill-append #[(string before-p) " \f\n@P@\nP  @!" [kill-ring before-p string interprogram-cut-function] 3 "\ Append STRING to the end of the latest kill in the kill ring. If BEFORE-P is non-nil, prepend STRING to the kill. If `interprogram-cut-function' is set, pass the resulting kill to it."]) (defalias 'current-kill #[(n &optional do-not-move) "U\f\n\f\n  !) A%! GZG\"\f =\f \f@))" [n 0 interprogram-paste-function interprogram-paste nil interprogram-cut-function kill-new kill-ring error "Kill ring is empty" mod kill-ring-yank-pointer ARGth-kill-element do-not-move] 4 "\ Rotate the yanking point by N places, and then return that kill. If N is zero, `interprogram-paste-function' is set, and calling it returns a string, then that string is added to the front of the kill ring and returned as the latest kill. If optional arg DO-NOT-MOVE is non-nil, then don't actually move the yanking point; just return the Nth kill forward."]) (defvar kill-read-only-ok nil "\ *Non-nil means don't signal an error for killing read-only text.") (defalias 'kill-region #[(beg end) "  \f$\" \f\"! \f=m=m \fm \f] \f^Z\\\f \f|\f@@;`AQ@@!ω+ \f\" \f|" [buffer-read-only inhibit-read-only text-property-not-all beg end read-only nil copy-region-as-kill kill-read-only-ok message "Read only text copied to kill ring" barf-if-buffer-read-only buffer-undo-list t last-command kill-region 100 tail old-list undo-strong-limit kill-new this-command] 6 "\ Kill between point and mark. The text is deleted but saved in the kill ring. The command \\[yank] can retrieve it from there. (If you want to kill and then yank immediately, use \\[copy-region-as-kill].) If the buffer is read-only, Emacs will beep and refrain from deleting the text, but put the text in the kill ring anyway. This means that you can use the killing commands to copy text from a read-only buffer. This is the primitive for programs to kill text (as opposed to deleting it). Supply two arguments, character numbers indicating the stretch of text to be killed. Any command that calls this function is a \"kill command\". If the previous command was also a kill command, the text killed this time appends to the text killed last time to make one entry in the kill ring." "r"]) (defalias 'copy-region-as-kill #[(beg end) "= \f{\f W\" \f{!LJ" [last-command kill-region kill-append beg end kill-new this-command nil] 4 "\ Save the region as if killed, but don't kill it. If `interprogram-cut-function' is non-nil, also save the text for a window system cut and paste." "r"]) (defalias 'kill-ring-save #[(beg end) " \n\"t|` U\n ` \"S `pb! p b\f{ {{ !{!G^` Uq[O\"zO\"*+" [copy-region-as-kill beg end t inhibit-quit opoint other-end pos-visible-in-window-p selected-window mark-marker sit-for 1 quit-flag mark-active transient-mark-mode nil run-hooks deactivate-mark-hook current-kill 0 killed-text 40 message-len message "Saved text until \"%s\"" "Saved text from \"%s\""] 6 "\ Save the region as if killed, but don't kill it. This command is similar to `copy-region-as-kill', except that it gives visual feedback indicating the extent of the region being copied. If `interprogram-cut-function' is non-nil, also save the text for a window system cut and paste." "r"]) (defalias 'append-next-kill #[nil "t\n!" [kill-region this-command message "If the next command is a kill, it will append" last-command] 2 "\ Cause following command, if it kills, to append to previous kill." nil]) (defalias 'yank-pop #[(arg) "=\n!`!W`!| `p\n!c5! `pb)ˇ" [last-command yank error "Previous command was not a yank" this-command mark t before mark-marker current-kill arg nil] 4 "\ Replace just-yanked stretch of killed text with a different stretch. This command is allowed only immediately after a `yank' or a `yank-pop'. At such a time, the region contains a stretch of reinserted previously-killed text. `yank-pop' deletes that text and inserts in its place a different stretch of killed text. With no argument, the previous kill is inserted. With argument N, insert the Nth previous kill. If N is negative, this is a more recent kill. The sequence of kills wraps around, so that after the oldest one comes the newest one." "*p"]) (defalias 'yank #[(&optional arg) "`!\f<ł\f=ǂ\fS!c\f:/! `pbˇ" [t this-command push-mark current-kill arg 0 - -1 mark mark-marker yank nil] 4 "\ Reinsert the last stretch of killed text. More precisely, reinsert the stretch of killed text most recently killed OR yanked. Put point at end, and set mark at beginning. With just C-u as argument, same but put point at beginning (and mark at end). With argument N, reinsert the Nth most recently killed stretch of killed text. See also the command \\[yank-pop]." "*P"]) (defalias 'rotate-yank-pointer #[(arg) " !" [current-kill arg] 2 "\ Rotate the yanking point in the kill ring. With argument, rotate that many kills forward (or backward, if negative)." "p"]) (defalias 'insert-buffer #[(buffer) " !\n !É qed)  #`)\f!+Ç" [bufferp buffer get-buffer nil newmark end start insert-buffer-substring push-mark] 4 "\ Insert after point the contents of BUFFER. Puts mark after the inserted text. BUFFER may be a buffer or a buffer name." (list (progn (barf-if-buffer-read-only) (read-buffer "Insert buffer: " (other-buffer) t)))]) (defalias 'append-to-buffer #[(buffer start end) "p\n!q\f #*" [oldbuf get-buffer-create buffer insert-buffer-substring start end] 4 "\ Append to specified buffer the text of the region. It is inserted into that buffer before its point. When calling from a program, give three arguments: BUFFER (or buffer name), START and END. START and END specify the portion of the current buffer to be copied." (list (read-buffer "Append to buffer: " (other-buffer nil t)) (region-beginning) (region-end))]) (defalias 'prepend-to-buffer #[(buffer start end) "p\n!q\f #+" [oldbuf get-buffer-create buffer insert-buffer-substring start end] 4 "\ Prepend to specified buffer the text of the region. It is inserted into that buffer after its point. When calling from a program, give three arguments: BUFFER (or buffer name), START and END. START and END specify the portion of the current buffer to be copied." "BPrepend to buffer: \nr"]) (defalias 'copy-to-buffer #[(buffer start end) "p\n!q  #+" [oldbuf get-buffer-create buffer erase-buffer insert-buffer-substring start end] 4 "\ Copy to specified buffer the text of the region. It is inserted into that buffer, replacing existing text there. When calling from a program, give three arguments: BUFFER (or buffer name), START and END. START and END specify the portion of the current buffer to be copied." "BCopy to buffer: \nr"]) (defvar mark-even-if-inactive nil "\ *Non-nil means you can use the mark even when inactive. This option makes a difference in Transient Mark mode. When the option is non-nil, deactivation of the mark turns off region highlighting, but commands that use the mark behave as if the mark were still active.") (byte-code "##" [put mark-inactive error-conditions (mark-inactive error) error-message "The mark is not active now"] 4) (defalias 'mark #[(&optional force) "\f \f\n !\"" [force mark-active mark-even-if-inactive marker-position mark-marker signal mark-inactive nil] 3 "\ Return this buffer's mark value as integer; error if mark inactive. If optional argument FORCE is non-nil, access the mark value even if the mark is not currently active, and return nil if there is no mark at all. If you are using this in an editing command, you are most likely making a mistake; see the documentation of `set-mark'."]) (defalias 'deactivate-mark #[nil " !" [transient-mark-mode nil mark-active run-hooks deactivate-mark-hook] 2 "\ Deactivate the mark by setting `mark-active' to nil. (That makes a difference only in Transient Mark mode.) Also runs the hook `deactivate-mark-hook'."]) (put (quote deactivate-mark) (quote byte-optimizer) (quote byte-compile-inline-expand)) (defalias 'set-mark #[(pos) "! p! Ɖ" [pos t mark-active run-hooks activate-mark-hook mark-marker nil deactivate-mark-hook] 3 "\ Set this buffer's mark to POS. Don't use this function! That is to say, don't use this function unless you want the user to see that the mark has moved, and you want the previous mark position to be lost. Normally, when a new mark is set, the old one should go on the stack. This is why most applications should use push-mark, not set-mark. Novice Emacs Lisp programmers often try to use the mark for the wrong purposes. The mark saves a location for the user's convenience. Most editing commands should not alter the mark. To remember a location for internal use in the Lisp program, store it in a Lisp variable. Example: (let ((beg (point))) (forward-line 1) (delete-region beg (point)))."]) (defvar mark-ring nil "\ The list of former marks of the current buffer, most recent first.") (byte-code "!#" [make-variable-buffer-local mark-ring put permanent-local t] 4) (defconst mark-ring-max 16 "\ *Maximum size of mark ring. Start discarding off end if gets this big.") (defvar global-mark-ring nil "\ The list of saved global marks, most recent first.") (defconst global-mark-ring-max 16 "\ *Maximum size of global mark ring. Start discarding off end if gets this big.") (defalias 'set-mark-command #[(arg) "\n‰#!!!b " [arg push-mark nil t mark error "No mark set in this buffer" pop-mark] 4 "\ Set mark at where point is, or jump to mark. With no prefix argument, set mark, push old mark position on local mark ring, and push mark on global mark ring. With argument, jump to mark, and pop a new position for mark off the ring (does not affect global mark ring). Novice Emacs Lisp programmers often try to use the mark for the wrong purposes. See the documentation of `set-mark' for more information." "P"]) (defalias 'push-mark #[(&optional location nomsg activate) "!# !\fBG V# \f@Ɖ S\fơ +`p=@!p=a !BG\nVa\n@Ɖ\nSơ v\fv Vv!!!Ƈ" [mark t copy-marker mark-marker mark-ring mark-ring-max nil location global-mark-ring marker-buffer global-mark-ring-max nomsg executing-macro minibuffer-depth 0 message "Mark set" activate transient-mark-mode set-mark] 4 "\ Set mark at LOCATION (point, by default) and push old mark on mark ring. If the last global mark pushed was not in the current buffer, also push LOCATION on the global mark ring. Display `Mark set' unless the optional second arg NOMSG is non-nil. In Transient Mark mode, activate mark if optional third arg ACTIVATE non-nil. Novice Emacs Lisp programmers often try to use the mark for the wrong purposes. See the documentation of `set-mark' for more information. In Transient Mark mode, this does not activate the mark."]) (defalias 'pop-mark #[nil "0 !C @p !@ĉ!, A" [mark-ring copy-marker mark-marker transient-mark-mode nil mark-active run-hooks deactivate-mark-hook mark t ding] 3 "\ Pop off mark ring into the buffer's actual mark. Does not set point. Does nothing if mark ring is empty."]) (define-function (quote exchange-dot-and-mark) (quote exchange-point-and-mark)) (defalias 'exchange-point-and-mark #[nil "!\f!`!\nb)Ƈ" [mark t omark error "No mark set in this buffer" set-mark nil] 3 "\ Put the mark where point is now, and point where the mark is now. This command works even when the mark is not active, and it reactivates the mark." nil]) (defalias 'transient-mark-mode #[(arg) " ?!V" [arg transient-mark-mode prefix-numeric-value 0] 2 "\ Toggle Transient Mark mode. With arg, turn Transient Mark mode on if arg is positive, off otherwise. In Transient Mark mode, when the mark is active, the region is highlighted. Changing the buffer \"deactivates\" the mark. So do certain other operations that set the mark but whose main purpose is something else--for example, incremental search, \\[beginning-of-buffer], and \\[end-of-buffer]." "P"]) (defalias 'pop-global-mark #[nil "@!A!@\f!\f!A qeY:dX<~b !+" [global-mark-ring marker-buffer error "No global mark set" marker buffer marker-position position switch-to-buffer] 3 "\ Pop off global mark ring and jump to the top location." nil]) (defvar next-line-add-newlines t "\ *If non-nil, `next-line' inserts newline to avoid `end of buffer' error.") (defalias 'next-line #[(arg) "$ U$`mc b !)( !ć" [next-line-add-newlines arg 1 opoint nil 10 line-move] 2 "\ Move cursor vertically down ARG lines. If there is no character in the target line exactly under the current column, the cursor is positioned after the character in that line which spans this column, or at the end of the line if it is not long enough. If there is no line in the buffer after this one, behavior depends on the value of next-line-add-newlines. If non-nil, a newline character is inserted to create a line and the cursor moves to that line, otherwise the cursor is moved to the end of the buffer (if already at the end of the buffer, an error is signaled). The command \\[set-goal-column] can be used to create a semipermanent goal column to which this command always moves. Then it does not try to move vertically. This goal column is stored in `goal-column', which is nil when there is none. If you are thinking of using this in a Lisp program, consider using `forward-line' instead. It is usually easier to use and more reliable (no dependence on goal column, etc.)." "p"]) (defalias 'previous-line #[(arg) " [!‡" [line-move arg nil] 2 "\ Move cursor vertically up ARG lines. If there is no character in the target line exactly over the current column, the cursor is positioned after the character in that line which spans this column, or at the end of the line if it is not long enough. The command \\[set-goal-column] can be used to create a semipermanent goal column to which this command always moves. Then it does not try to move vertically. If you are thinking of using this in a Lisp program, consider using `forward-line' with a negative argument instead. It is usually easier to use and more reliable (no dependence on goal column, etc.)." "p"]) (defconst track-eol nil "\ *Non-nil means vertical motion starting at end of line keeps to ends of lines. This means moving to the end of each line moved onto. The beginning of a blank line does not count as the end of a line.") (defvar goal-column nil "\ *Semipermanent goal column for vertical motion, as set by \\[set-goal-column], or nil.") (make-variable-buffer-local (quote goal-column)) (defvar temporary-goal-column 0 "\ Current goal column for vertical motion. It is the column where point was at the start of current run of vertical motion commands. When the `track-eol' feature is doing its job, the value is 9999.") (byte-code "\"#" [defalias line-move #[(arg) "=%=% \"l\"n=\"ł#idVHV>Syy!Qy!Tno]΂^\"V!U{\"SfWy!U\"T!ˇ" [last-command next-line previous-line track-eol end-of-line 9999 temporary-goal-column selective-display arg 0 1 nil zerop signal beginning-of-buffer end-of-buffer vertical-motion -1 move-to-column goal-column] 4] put set-goal-column disabled t] 4) (defalias 'set-goal-column #[(arg) " !i!\n\"" [arg nil goal-column message "No goal column" substitute-command-keys "Goal column %d (use \\[set-goal-column] with an arg to unset it)"] 3 "\ Set the current horizontal position as a goal for \\[next-line] and \\[previous-line]. Those commands will move to this position in the line moved to rather than trying to keep the same horizontal position. With a non-nil argument, clears out the goal column so that \\[next-line] and \\[previous-line] resume vertical motion. The goal column is stored in the variable `goal-column'." "P"]) (defvar hscroll-step 0 "\ *The number of columns to try scrolling a window by when point moves out. If that fails to bring point back on frame, point is centered instead. If this is zero, point is always centered after it moves off frame.") (defalias 'hscroll-point-visible #[nil " q  V\f W??` W? by`)`Y>\") \f ^ S\fU\\gUaS\fZWw\f\\V )\f ԥZ ZZ^!)\fW!\fV!+)" [window-buffer truncate-lines window-hscroll 0 truncate-partial-width-windows window-width frame-width window-start ws-bol set-window-start nil hscroll-window-column here 1 left right 10 hscroll-step eol scroll-left 2 -5 scroll-right] 4 "\ Scrolls the selected window horizontally to make point visible."]) (defalias (quote hscroll-window-column) #[nil " y` by`)U b`) =7 U7\feU7 8 Z^\\  \f B`B B&A@," [window-hscroll hscroll 0 window-start startpos selected-window minibuffer-window 1 minibuffer-prompt-width hpos nil val compute-motion 1000000] 8]) (defalias 'scroll-other-window-down #[(lines) " =? ‚ ![!" [scroll-other-window lines - prefix-numeric-value] 3 "\ Scroll the \"other window\" down." "P"]) (defalias 'beginning-of-buffer-other-window #[(arg) " Ď\n!!!+" [selected-window other-window-for-scrolling window orig-window ((select-window orig-window)) select-window beginning-of-buffer arg recenter (t)] 2 "\ Move point to the beginning of the buffer in the other window. Leave mark at previous position. With arg N, put point N/10 of the way from the true beginning." "P"]) (defalias 'end-of-buffer-other-window #[(arg) " Ď\n!!!+" [selected-window other-window-for-scrolling window orig-window ((select-window orig-window)) select-window end-of-buffer arg recenter (t)] 2 "\ Move point to the end of the buffer in the other window. Leave mark at previous position. With arg N, put point N/10 of the way from the true end." "P"]) (defalias 'transpose-chars #[(arg) " l u!\"" [arg -1 transpose-subr forward-char prefix-numeric-value] 4 "\ Interchange characters around point, moving forward one character. With prefix arg ARG, effect is to take character before point and drag it forward past ARG other characters (backward if ARG negative). If no argument and at end of line, the previous two chars are exchanged." "*P"]) (defalias 'transpose-words #[(arg) "\n\"" [transpose-subr forward-word arg] 3 "\ Interchange words around point, leaving point at end of them. With prefix arg ARG, effect is to take word before or around point and drag it forward past ARG other words (backward if ARG negative). If ARG is zero, the words around or after point and around or after mark are interchanged." "*p"]) (defalias 'transpose-sexps #[(arg) "\n\"" [transpose-subr forward-sexp arg] 3 "\ Like \\[transpose-words] but applies to sexps. Does not work on a sexp that point is in the middle of if it is a list or string." "*p"]) (defalias 'transpose-lines #[(arg) "\n\"" [transpose-subr #[(arg) "Um uy" [arg 1 nil newline] 2] arg] 3 "\ Exchange current line and previous line, leaving point after both. With argument ARG, takes previous line and moves it past ARG lines. With argument 0, interchanges line point is in with line mark is in." "*p"]) (byte-code "\"\"" [defalias transpose-subr #[(mover arg) " U6!`!` b!`!` ) Ve!`!`!`!` b S7 W!`!`!`!` Tf," [nil end2 start2 end1 start1 arg 0 mover 1 -1 mark transpose-subr-1 exchange-point-and-mark] 5] transpose-subr-1 #[nil " ^\n ]V!\n{ { | bc\n W-\n6\nGGZ\\bG!c*" [end1 end2 start1 start2 error "Don't have two things to transpose" word2 word1 delete-char] 3]] 3) (defconst comment-column 32 "\ *Column to indent right-margin comments to. Setting this variable automatically makes it local to the current buffer. Each mode establishes a different default value for this variable; you can set the value for a particular mode using that mode's hook.") (make-variable-buffer-local (quote comment-column)) (defconst comment-start nil "\ *String to insert to start a new comment, or nil if no comment syntax defined.") (defconst comment-start-skip nil "\ *Regexp to match the start of a comment plus everything up to its body. If there are any \\(...\\) pairs, the comment delimiter text is held to begin at the place matched by the close of the first pair.") (defconst comment-end "" "\ *String to insert to end a new comment. Should be an empty string if comments are terminated by end-of-line.") (defconst comment-indent-hook nil "\ Obsolete variable for function to compute desired indentation for a comment. This function is called with no args with point at the beginning of the comment's starting delimiter.") (defconst comment-indent-function (quote (lambda nil comment-column)) "\ Function to compute desired indentation for a comment. This function is called with no args with point at the beginning of the comment's starting delimiter.") (defalias 'indent-for-comment #[nil "y !`)\n #@ ͕4͕b@\"\"`iO R U`bmx`|j~bĉ cc)," [0 comment-start error "No comment syntax defined" nil eolpos cpos indent begpos re-search-forward comment-start-skip move point-marker 1 skip-syntax-backward " " "^ " comment-indent-hook comment-indent-function " " comment-end] 4 "\ Indent this line's comment to comment column, or insert an empty comment." "*"]) (defalias 'set-comment-column #[(arg) "=\n!0y!y!Ĕbi\") i\"" [arg - kill-comment nil 0 re-search-backward comment-start-skip re-search-forward comment-column message "Comment column set to %d" indent-for-comment] 3 "\ Set the comment column based on point. With no arg, set the comment column to the current column. With just minus as arg, kill any comment on this line. With any other arg, set comment column to indentation of the previous comment and then align or create a comment on this line at that column." "P"]) (defalias 'kill-comment #[(arg) "!\f!Vf`y\n8\n!#w`y#UȔbx`\" )\f]yS*" [comment-start-skip error "No comment syntax defined" prefix-numeric-value arg nil endc count 0 "" comment-end re-search-forward regexp-quote move " " t kill-region indent-according-to-mode 1] 5 "\ Kill the comment on this line, if any. With argument, kill comments on that many lines starting with this one." "P"]) (defalias 'comment-region #[(beg end &optional arg) "! \fV \f) \n :2T !VT\nP\n P S9 \f} bm?;=nW=\n!!\nG!uTV\n!!\nG!) Ԙ=x`eZ GY G! !!) G[!TVx G! !! G!))y[!2\nc Ԙ2 c#[-" [comment-start error "No comment syntax is defined" beg end nil mid comment-end numarg ce cs arg t prefix-numeric-value 1 0 looking-at regexp-quote delete-char count "" " " backward-char "[ ]*$" search-forward "\n" move] 5 "\ Comment or uncomment each line in the region. With just C-u prefix arg, uncomment each line in region. Numeric prefix arg ARG means use ARG comment characters. If ARG is negative, delete that many comment characters instead. Comments are terminated on each line, even for syntax in which newline does not end the comment. Blank lines do not get comments." "r\nP"]) (defalias 'backward-word #[(arg) "[v" [arg] 1 "\ Move backward until encountering the end of a word. With argument, do this that many times. In programs, it is faster to call `forward-word' with negative arg." "p"]) (defalias 'mark-word #[(arg) " v`)#" [push-mark arg nil t] 4 "\ Set mark arg words away from point." "p"]) (defalias 'kill-word #[(arg) "` v`\"" [kill-region arg] 3 "\ Kill characters forward until encountering the end of a word. With argument, do this that many times." "p"]) (defalias 'backward-kill-word #[(arg) " [!" [kill-word arg] 2 "\ Kill characters backward until encountering the end of a word. With argument, do this that many times." "p"]) (defalias 'current-word #[(&optional strict) "```!`\nb!` \n=Y\n=Y?\\NJy`)\"nKNJ`)\"`!`S`!` {\\ {," [end start oldpoint skip-syntax-backward "w_" skip-syntax-forward strict "^w_" 0 nil] 3 "\ Return the word point is on (or a nearby word) as a string. If optional arg STRICT is non-nil, return nil unless point is within or adjacent to a word."]) (defconst fill-prefix nil "\ *String for filling to insert at front of new line, or nil for none. Setting this variable automatically makes it local to the current buffer.") (make-variable-buffer-local (quote fill-prefix)) (defconst auto-fill-inhibit-regexp nil "\ *Regexp to match lines which should not be auto-filled.") (defalias (quote do-auto-fill) #[nil "\ny\n!) ?i V` T!Poll lu!L!?)lxne #x+`,bn)ix`U) b )iY)))" [nil give-up auto-fill-inhibit-regexp 0 looking-at fill-column t first bounce opoint move-to-column sentence-end-double-space -1 "\\. " "\\. " "^ \n" re-search-forward "[ ]" " " fill-point prev-column indent-new-comment-line] 4]) (defalias 'auto-fill-mode #[(&optional arg) " ?!Vĉ !" [arg auto-fill-function prefix-numeric-value 0 do-auto-fill set-buffer-modified-p buffer-modified-p] 3 "\ Toggle auto-fill mode. With arg, turn Auto-Fill mode on if and only if arg is positive. In Auto-Fill mode, inserting a space at a column beyond `fill-column' automatically breaks the line at a previous space." "P"]) (defun auto-fill-function nil "\ Automatically break line at a previous space, in insertion of text." nil) (defalias 'turn-on-auto-fill #[nil "!" [auto-fill-mode 1] 2 "\ Unconditionally turn on Auto Fill mode."]) (defalias 'set-fill-column #[(arg) " \ni \"" [arg fill-column message "fill-column set to %d"] 3 "\ Set `fill-column' to current column, or to argument if given. The variable `fill-column' has a separate value for each buffer." "P"]) (defconst comment-multi-line nil "\ *Non-nil means \\[indent-new-comment-line] should continue same comment on new line, with no new terminator or starter. This is obsolete because you might as well use \\[newline-and-indent].") (defalias 'indent-new-comment-line #[nil "x`w`|c ed`y#)d˔\flXoXy`y#)X˔\f2\fbi`˕{))\n\n     Кu cul cu !,c *" [nil comstart comcol " " 10 comment-multi-line comment-start-skip opoint -1 re-search-forward t 0 win comment-end comment-start comment-column "" 1 indent-for-comment delete-char fill-prefix indent-according-to-mode] 4 "\ Break line at point and indent, continuing comment if within one. This indents the body of the continued comment under the previous comment line. This command is intended for styles where you write a comment per line, starting a new comment (and terminating it if necessary) on each line. If you want to continue one comment across several lines, use \\[newline-and-indent]." "*"]) (defalias 'set-selective-display #[(arg) "=\n!e`} b !)#!!) !\"\"\"\"" [selective-display t error "selective-display already in use for marked lines" window-start vertical-motion window-height current-vpos arg prefix-numeric-value recenter set-window-start selected-window princ "selective-display set to " prin1 "."] 4 "\ Set `selective-display' to ARG; clear it if no arg. When the value of `selective-display' is a number > 0, lines whose indentation is >= that value are not displayed. The variable `selective-display' has a separate value for each buffer." "P"]) (defconst overwrite-mode-textual " Ovwrt" "\ The string displayed in the mode line when in overwrite mode.") (defconst overwrite-mode-binary " Bin Ovwrt" "\ The string displayed in the mode line when in binary overwrite mode.") (defalias 'overwrite-mode #[(arg) " ?!V " [arg overwrite-mode prefix-numeric-value 0 overwrite-mode-textual force-mode-line-update] 2 "\ Toggle overwrite mode. With arg, turn overwrite mode on iff arg is positive. In overwrite mode, printing characters typed in replace existing text on a one-for-one basis, rather than pushing it to the right. At the end of a line, such characters extend the line. Before a tab, such characters insert until the tab is filled in. \\[quoted-insert] still inserts characters in overwrite mode; this is supposed to make it easier to insert characters when necessary." "P"]) (defalias 'binary-overwrite-mode #[(arg) " =?!V " [arg overwrite-mode overwrite-mode-binary prefix-numeric-value 0 force-mode-line-update] 2 "\ Toggle binary overwrite mode. With arg, turn binary overwrite mode on iff arg is positive. In binary overwrite mode, printing characters typed in replace existing text. Newlines are not treated specially, so typing at the end of a line joins the line to the next, with the typed character between them. Typing before a tab character simply replaces the tab with the character typed. \\[quoted-insert] replaces the text at the cursor, just as ordinary typing characters do. Note that binary overwrite mode is not its own minor mode; it is a specialization of overwrite-mode, entered by setting the `overwrite-mode' variable to `overwrite-mode-binary'." "P"]) (defvar line-number-mode nil "\ *Non-nil means display line number in mode line.") (defalias 'line-number-mode #[(arg) " ?!V " [arg line-number-mode prefix-numeric-value 0 force-mode-line-update] 2 "\ Toggle Line Number mode. With arg, turn Line Number mode on iff arg is positive. When Line Number mode is enabled, the line number appears in the mode line." "P"]) (defvar blink-matching-paren t "\ *Non-nil means show matching open-paren when close-paren is inserted.") (defconst blink-matching-paren-distance 12000 "\ *If non-nil, is maximum distance to search for matching open-paren.") (defalias 'blink-matching-open #[nil "`eTV`Zfz>?\n`-e`Z] }ɏ) J fzUJ Sf f!U?Q b c! bЊxn)|y` T{uwl) `{!xy`x`{ T{Q\"!?!," [2 (47 92) blink-matching-paren oldpos nil blinkpos mismatch blink-matching-paren-distance (byte-code " \"" [scan-sexps oldpos -1 blinkpos] 3) ((error)) 36 matching-paren pos-visible-in-window-p sit-for 1 message "Matches %s" " " 0 backward-char "\n " "..." "Mismatched parentheses" "Unmatched parenthesis"] 6 "\ Move cursor momentarily to the beginning of the sexp before point." nil]) (byte-code "" [blink-matching-open blink-paren-function] 1) (defalias 'keyboard-quit #[nil "\n!\"" [transient-mark-mode nil mark-active run-hooks deactivate-mark-hook signal quit] 3 "\ Signal a quit condition. During execution of Lisp code, this character causes a quit directly. At top-level, as an editor command, this simply beeps." nil]) (define-key global-map "" (quote keyboard-quit)) (defalias 'set-variable #[(var val) " L" [var val] 2 "\ Set VARIABLE to VALUE. VALUE is a Lisp object. When using this interactively, supply a Lisp expression for VALUE. If you want VALUE to be a string, you must surround it with doublequotes. If VARIABLE has a `variable-interactive' property, that is used as if it were the arg to `interactive' (which see) to interactively read the value." (byte-code "!\nN DF!&\n\"!,D" [read-variable "Set variable: " var (funcall myhelp) minibuffer-help-form #[nil "\n!!\n\"O!\n!' !\nJ!)ȑ" ["*Help*" prin1 var princ "\nDocumentation:\n" documentation-property variable-documentation 1 nil boundp 20 print-length "\n\nCurrent value: "] 5] myhelp variable-interactive prop call-interactively lambda (arg) interactive arg eval-minibuffer format "Set %s to value: "] 7)]) (byte-code "! * \f#\f#\f#\f#\f)#!9‡" [boundp completion-list-mode-map nil make-sparse-keymap map define-key [mouse-2] mouse-choose-completion [down-mouse-2] " " choose-completion [return] put completion-list-mode mode-class special completion-base-size] 4) (defalias 'choose-completion #[nil " \nm`\"``To1`S\"1`S`:!\"\"Jd{ \"l !l !v !v !) \f #-" [nil completion-reference-buffer completion-base-size base-size buffer completion end beg get-text-property mouse-face error "No completion here" previous-single-property-change next-single-property-change selected-window owindow one-window-p t selected-frame window-dedicated-p iconify-frame bury-buffer select-window choose-completion-string] 5 "\ Choose the completion that point is in or next to." nil]) (byte-code "\"\"" [defalias choose-completion-delete-max-match #[(string) "`G`eZ^`GZb  V<`` \\{ )   O)< Su !*" [string len opoint completion-ignore-case 0 tail 1 delete-char] 4] choose-completion-string #[(choice &optional buffer base-size) " !\"% ! !%!gq\n7\ne\\`|<\f!\fc`\fGZ`#\"`\") !gg )" [buffer completion-reference-buffer string-match "\\` \\*Minibuf-[0-9]+\\*\\'" buffer-name minibuffer-window-active-p minibuffer-window window-buffer error "Minibuffer is not active for completion" base-size choose-completion-delete-max-match choice remove-text-properties (mouse-face nil) get-buffer-window t window set-window-point minibuffer-completion-table exit-minibuffer] 4]] 3) (defalias 'completion-list-mode #[nil " \n!!!" [kill-all-local-variables use-local-map completion-list-mode-map "Completion List" mode-name completion-list-mode major-mode make-local-variable completion-base-size nil run-hooks completion-list-mode-hook] 2 "\ Major mode for buffers showing lists of possible completions. Type \\\\[choose-completion] in the completion list to select the completion near point. Use \\\\[mouse-choose-completion] to select one with the mouse." nil]) (byte-code "!\"\"\"" [boundp completion-fixup-function nil defalias completion-setup-function #[nil "p q !eb !c!cy#KΔ`; `$b*#*" [mainbuf standard-output completion-list-mode make-local-variable completion-reference-buffer window-system substitute-command-keys "Click \\[mouse-choose-completion] on a completion to select it.\n" "In this buffer, type \\[choose-completion] to select the completion near point.\n\n" 1 re-search-forward "[^ \n]+\\( [^ \n]+\\)*" nil t 0 end beg completion-fixup-function put-text-property mouse-face highlight] 5] add-hook completion-setup-hook mapcar #[(keypad-normal) "@A@\n #\n! !#*" [keypad-normal normal keypad put ascii-character define-key function-key-map vector] 5] ((kp-0 48) (kp-1 49) (kp-2 50) (kp-3 51) (kp-4 52) (kp-5 53) (kp-6 54) (kp-7 55) (kp-8 56) (kp-9 57) (kp-space 32) (kp-tab 9) (kp-enter 13) (kp-multiply 42) (kp-add 43) (kp-separator 44) (kp-subtract 45) (kp-decimal 46) (kp-divide 47) (kp-equal 61))] 3)