;ELC ;;; compiled by rms@mole.gnu.ai.mit.edu on Tue Jun 20 10:25:49 1995 ;;; from file /home/fsf/rms/e19/lisp/simple.el ;;; emacs version 19.28.95.3. ;;; 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.28.90"))) (error "`simple.el' was compiled for Emacs 19.29 or later")) #@241 Insert a newline, and move to left margin of the new line if it's blank. The newline is marked with the text-property `hard'. With arg, insert that many newlines. In Auto Fill mode, if no numeric arg, break the preceding line if it's long. (defalias 'newline #[(&optional arg) "o?n`!`ZWn\f!`)! 1?7\f\f  !!*` U !VZ\"`$<>`B$* by! V``|)u\"+ۇ" [previous-property-change -2 2 looking-at page-delimiter beforepos was-page-start flag backward-char 1 10 arg auto-fill-function last-command-char self-insert-command prefix-numeric-value use-hard-newlines from get-text-property rear-nonsticky sticky put-text-property hard t 0 "[ ]$" current-left-margin nil move-to-left-margin] 7 (#$ . 474) "*P"]) #@187 Insert a newline and leave point before it. If there is a fill prefix and/or a left-margin, insert them on the new line if the line would have been blank. With arg N, insert N newlines. (defalias 'open-line #[(arg) "nn V`! bV@n4\f, j 4!yS b+" [fill-prefix do-fill-prefix current-left-margin 0 do-left-margin loc newline arg insert-and-inherit 1 nil] 3 (#$ . 1300) "*p"]) #@66 Split current line, moving portion beyond point vertically down. (defalias 'split-line #[nil "wi`! \"\nb*" [" " nil pos col newline 1 indent-to 0] 3 (#$ . 1724) "*"]) #@590 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. (defalias 'quoted-insert #[(arg) "\n=   V\"=\" ! V3\f! S#)" [overwrite-mode overwrite-mode-binary read-quoted-char read-char char arg 0 delete-char insert-and-inherit] 3 (#$ . 1911) "*p"]) #@178 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. (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 (#$ . 2729) "*P"]) #@100 Fixup white space between objects around point. Leave one space or none, according to the context. (defalias 'fixup-whitespace #[nil " !u!)?c)" [delete-horizontal-space looking-at "^\\|\\s)" -1 "$\\|\\s(\\|\\s'" 32] 2 (#$ . 3091) "*"]) #@42 Delete all spaces and tabs around point. (defalias 'delete-horizontal-space #[nil "x`w`|" [" " nil] 3 (#$ . 3351) "*"]) #@61 Delete all spaces and tabs around point, leaving one space. (defalias 'just-one-space #[nil "xgUuc`w`|" [" " nil 32 1] 3 (#$ . 3485) "*"]) #@175 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 '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 (#$ . 3650) "*"]) #@64 Move point to the first non-whitespace character on this line. (defalias 'back-to-indentation #[nil "yw" [0 " " nil] 2 (#$ . 4143) nil]) #@304 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 function `current-left-margin'. (defalias 'newline-and-indent #[nil "`x`| " [" " nil newline indent-according-to-mode] 3 (#$ . 4293) "*"]) #@379 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 function `current-left-margin'. (defalias 'reindent-then-newline-and-indent #[nil "`x`| ) " [" " nil indent-according-to-mode newline] 3 (#$ . 4720) "*"]) (defalias 'kill-forward-chars #[(arg) "<@=``\\\"" [arg - -1 kill-region] 4]) (defalias 'kill-backward-chars #[(arg) "<@=``Z\"" [arg - -1 kill-region] 4]) #@219 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. (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 (#$ . 5427) "*p\nP"]) #@112 Kill up to and including ARG'th occurrence of CHAR. Goes backward if ARG is negative; error if CHAR not found. (defalias 'zap-to-char #[(arg char) "` !ĉ $`\"" [kill-region search-forward char-to-string char nil arg] 7 (#$ . 5916) "p\ncZap to char: "]) #@350 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 beginning. If the buffer is narrowed, this command uses the beginning and size of the accessible part of the buffer. Don't use this command in Lisp programs! (goto-char (point-min)) is faster and avoids clobbering the mark. (defalias 'beginning-of-buffer #[(&optional arg) " deZ\n)e V\n! ť_% \n!_\\ť\\*eb)\n3y" [push-mark size arg 10000 prefix-numeric-value 10 1] 4 (#$ . 6181) "P"]) #@338 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 end. If the buffer is narrowed, this command uses the beginning and size of the accessible part of the buffer. Don't use this command in Lisp programs! (goto-char (point-max)) is faster and avoids clobbering the mark. (defalias 'end-of-buffer #[(&optional arg) " deZ\n'd V\n! ť_# \n!_ťZ(db)\n2y` b !`W*N`!!" [push-mark size arg 10000 prefix-numeric-value 10 1 old-point window-start vertical-motion window-height overlay-recenter recenter -3] 4 (#$ . 6720) "P"]) #@205 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. (defalias 'mark-whole-buffer #[nil "`!d#eb" [push-mark nil t] 4 (#$ . 7348) nil]) #@53 Print number of lines and characters in the region. (defalias 'count-lines-region #[(start end) " \f\"\f Z#" [message "Region has %d lines, %d characters" count-lines start end] 5 (#$ . 7647) "r"]) #@57 Print the current line number (in the buffer) of point. (defalias 'what-line #[nil "~y`\"T\"*" [0 message "Line %d" count-lines 1] 5 (#$ . 7855) nil]) #@204 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 'count-lines #[(start end) " }eb\n=T Ǝ$)\\$;\\)db UNnNTP+Z yZ*" [start end selective-display t match-data match-data ((store-match-data match-data)) 0 done re-search-forward "[\n ]" nil 40 1 buffer-size] 5 (#$ . 8023)]) #@62 Print info on cursor position (on screen and within buffer). (defalias 'what-cursor-position #[nil "ged` V ǥ S\\ ȥ], ʥ S_\\ ] U9΂> \"i \nUv UV\n TUg  \n&  & U\n TU!  \n&\f!  &\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, %d, 0x%x) point=%d of %d(%d%%) <%d - %d> column %d %s" single-key-description "Char: %s (0%o, %d, 0x%x) point=%d of %d(%d%%) column %d %s"] 14 (#$ . 8523) nil]) #@115 Major mode not specialized for anything in particular. Other major modes are defined by comparison with this one. (defalias 'fundamental-mode #[nil " " [kill-all-local-variables] 1 (#$ . 9205) nil]) #@54 Minibuffer keymap used for reading Lisp expressions. (defvar read-expression-map (cons (quote keymap) minibuffer-local-map) (#$ . 9412)) (byte-code " ##!  B ʇ" [define-key read-expression-map "" lisp-complete-symbol put eval-expression disabled t boundp read-expression-history nil current-load-list] 4) #@111 Evaluate EXPRESSION and print value in minibuffer. Value is also consed on to front of the variable `values'. (defalias 'eval-expression #[(expression) " !\nB\n@\"" [eval expression values prin1 t] 3 (#$ . 9744) (list (read-from-minibuffer "Eval: " nil read-expression-map t (quote read-expression-history)))]) #@178 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 'edit-and-eval-command #[(prompt command) " !\f%@;A @$ B !)" [read-from-minibuffer prompt prin1-to-string command read-expression-map t (command-history . 1) command-history eval] 6 (#$ . 10067)]) #@537 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. (defalias 'repeat-complex-command #[(arg) "S 8=!\fB%) @;, A\f @7\f B\f!? ," [arg command-history t nil newcmd minibuffer-history-sexp-flag minibuffer-history-position elt print-level read-from-minibuffer "Redo: " prin1-to-string read-expression-map eval ding] 8 (#$ . 10484) "p"]) #@124 Default minibuffer history list. This is used for all minibuffer input except when an alternate history list is specified. (defvar minibuffer-history nil (#$ . 11346)) #@166 Non-nil when doing history operations on `command-history'. More generally, indicates that the history list being acted on contains expressions rather than strings. (defvar minibuffer-history-sexp-flag nil (#$ . 11521)) (byte-code "!\fB\"" [minibuffer-history minibuffer-history-variable nil minibuffer-history-position boundp minibuffer-history-search-history current-load-list 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) #@216 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. (defalias 'previous-matching-history-element #[(regexp n) "J\nUi  Wɂ\\] G^\fU8 U5˂6!M S 8!)Q S 8\"WaȂb\\  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 print-level prin1-to-string erase-buffer elt command-history previous-matching-history-element next-matching-history-element] 6 (#$ . 12590) (byte-code "%ɘ%@'!' !+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 "" error "No previous history search regexp" prefix-numeric-value current-prefix-arg] 7)]) #@221 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. (defalias 'next-matching-history-element #[(regexp n) " \n[\"" [previous-matching-history-element regexp n] 3 (#$ . 13736) (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)]) #@72 Insert the next element of the minibuffer history into the minibuffer. (defalias 'next-history-element #[(n) "U\\ Z]\fJG^U U8 U)V, U3ǂ4![ S\fJ8\n T \n!)V\nc)eb)" [n 0 1 minibuffer-history-position minibuffer-history-variable narg error "End of history; no next item" "Beginning of history; no preceding item" erase-buffer elt minibuffer-history-sexp-flag nil print-level prin1-to-string] 4 (#$ . 14371) "p"]) #@77 Inserts the previous element of the minibuffer history into the minibuffer. (defalias 'previous-history-element #[(n) " [!" [next-history-element n] 2 (#$ . 14835) "p"]) #@75 Get next element of history which is a completion of minibuffer contents. (defalias 'next-complete-history-element #[(n) "`e`{!P\f\"b)" [point-at-start next-matching-history-element "^" regexp-quote n] 5 (#$ . 15013) "p"]) #@79 Get previous element of history which is a completion of minibuffer contents. (defalias 'previous-complete-history-element #[(n) " [!" [next-complete-history-element n] 2 (#$ . 15249) "p"]) #@61 Goto line ARG, counting from line 1 at beginning of buffer. (defalias 'goto-line #[(arg) " !~b = S$ Sy)" [prefix-numeric-value arg 1 selective-display t re-search-forward "[\n ]" nil end] 5 (#$ . 15447) "NGoto line: "]) (define-function (quote advertised-undo) (quote undo)) #@116 Undo some previous changes. Repeat this command to undo more changes. A numeric argument serves as a repeat count. (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 (#$ . 15747) "*p"]) #@73 Within a run of consecutive undo commands, list remaining to be undone. (defvar pending-undo-list nil (#$ . 16284)) #@126 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-start #[nil "=\n!" [buffer-undo-list t error "No undo information in this buffer" pending-undo-list] 2 (#$ . 16407)]) #@179 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. (defalias 'undo-more #[(count) "!\f\"" [pending-undo-list error "No further undo information" primitive-undo count] 3 (#$ . 16684)]) #@58 History list for some commands that read shell commands. (defvar shell-command-history nil (#$ . 17013)) #@66 Switch used to have the shell execute its command line argument. (defvar shell-command-switch "-c" (#$ . 17124)) #@961 Execute string COMMAND in inferior shell; display output, if any. If COMMAND ends in ampersand, execute it asynchronously. The output appears in the buffer `*Async Shell Command*'. Otherwise, COMMAND is executed synchronously. The output appears in the buffer `*Shell Command Output*'. If the output is one line, it is displayed in the echo area *as well*, but it is nonetheless available in buffer `*Shell Command Output*', even though that buffer is not automatically displayed. If there is no output, or if output is inserted in the current buffer, then `*Shell Command Output*' is deleted. The optional second argument OUTPUT-BUFFER, if non-nil, says to put the output in some other buffer. If OUTPUT-BUFFER is a buffer or buffer name, put the output there. If OUTPUT-BUFFER is not a buffer and not nil, insert output in current buffer. (This cannot be done asynchronously.) In either case, the output is inserted after point (leaving mark after it). (defalias 'shell-command #[(command &optional output-buffer) ",!,;,  &! `pb  Ύ \"@! ׉O !n!j!n!q !  %$\"\",`` $*" [output-buffer bufferp barf-if-buffer-read-only push-mark call-process shell-file-name nil t shell-command-switch command mark mark-marker match-data data ((store-match-data data)) string-match "[ ]*&[ ]*$" get-buffer-create "*Asynch 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" buffer-read-only 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 (#$ . 17244) (list (read-from-minibuffer "Shell command: " nil nil nil (quote shell-command-history)) current-prefix-arg)]) (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]) (defalias '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]) #@1017 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. The noninteractive arguments are START, END, COMMAND, OUTPUT-BUFFER, REPLACE. If REPLACE is non-nil, that means insert the output in place of text from START to END, putting point and mark around it. 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 if output is inserted in the current buffer, then `*Shell Command Output*' is deleted. If the optional fourth argument OUTPUT-BUFFER is non-nil, that says to put the output in some other buffer. If OUTPUT-BUFFER is a buffer or buffer name, put the output there. If OUTPUT-BUFFER is not a buffer and not nil, insert output in the current buffer. In either case, the output is inserted after point (leaving mark after it). (defalias 'shell-command-on-region #[(start end command &optional output-buffer replace) " X !X ;X` W b&  ʉ\f &!Kp=K!)V\fV ) ^!֎p=d|e |ed ʉ\f &ʉq )  \f &ʉ+" [replace output-buffer bufferp mark swap start push-mark call-process-region end shell-file-name t nil shell-command-switch 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)) buffer-read-only erase-buffer] 10 (#$ . 19733) (byte-code "‰% \f)" [read-from-minibuffer "Shell command on region: " nil shell-command-history string region-beginning region-end current-prefix-arg] 6)]) #@53 Keymap used while processing \[universal-argument]. (defconst universal-argument-map (byte-code "  # \"# # # # # # # # # # # # # # )" [make-sparse-keymap map define-key [t] universal-argument-other-key vector meta-prefix-char t [switch-frame] nil [21] universal-argument-more [45] universal-argument-minus [48] digit-argument [49] [50] [51] [52] [53] [54] [55] [56] [57]] 5) (#$ . 21758)) #@194 Number of argument-specifying events read by `universal-argument'. `universal-argument-other-key' uses this to discard those events from (this-command-keys), and reread only the final command. (defvar universal-argument-num-events nil (#$ . 22220)) #@389 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. (defalias 'universal-argument #[nil "C G\f" [4 prefix-arg this-command-keys universal-argument-num-events universal-argument-map overriding-terminal-local-map] 2 (#$ . 22476) nil]) (defalias 'universal-argument-more #[(arg) ":@_C G" [arg 4 prefix-arg nil overriding-terminal-local-map this-command-keys universal-argument-num-events] 2 nil "P"]) #@129 Begin a negative numeric argument for the next command. \[universal-argument] following digits or minus sign ends the argument. (defalias 'negative-argument #[(arg) " [= G" [arg prefix-arg - nil this-command-keys universal-argument-num-events universal-argument-map overriding-terminal-local-map] 2 (#$ . 23243) "P"]) #@124 Part of the numeric argument for the next command. \[universal-argument] following digits or minus sign ends the argument. (defalias 'digit-argument #[(arg) " \"Z ! _ W\f[\f\\; =8\fU1ɂ3\f[;\f) G \f " [logand last-command-char 127 48 digit arg 10 0 prefix-arg - this-command-keys universal-argument-num-events universal-argument-map overriding-terminal-local-map] 3 (#$ . 23597) "P"]) (defalias 'universal-argument-minus #[(arg) " !!" [arg universal-argument-other-key negative-argument] 2 nil "P"]) (defalias 'universal-argument-other-key #[(arg) "  ! * ɉ\n" [arg prefix-arg this-command-keys key listify-key-sequence keylist universal-argument-num-events unread-command-events reset-this-command-lengths nil overriding-terminal-local-map] 2 nil "P"]) #@66 Move forward ARG lines and position at first nonblank character. (defalias 'forward-to-indentation #[(arg) "yw" [arg " " nil] 2 (#$ . 24420) "p"]) #@67 Move backward ARG lines and position at first nonblank character. (defalias 'backward-to-indentation #[(arg) "[yw" [arg " " nil] 2 (#$ . 24579) "p"]) #@75 *If non-nil, `kill-line' with no arg at beg of line kills the whole line. (defvar kill-whole-line nil (#$ . -24741)) #@366 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. (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 (#$ . 24865) "P"]) #@558 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-cut-function nil (#$ . 25454)) #@969 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 interprogram-paste-function nil (#$ . 26070)) #@430 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. (defvar kill-ring nil (#$ . 27099)) #@70 *Maximum length of kill ring before oldest elements are thrown away. (defconst kill-ring-max 30 (#$ . -27570)) #@63 The tail of the kill ring whose car is the last thing yanked. (defvar kill-ring-yank-pointer nil (#$ . 27687)) #@294 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. Optional second argument REPLACE non-nil means that STRING will replace the front of the kill ring, rather than being added to the list. (defalias 'kill-new #[(string &optional replace) "!\n \f@\" \f\n-\n\fBG V- S\fơ\f:\n\"" [fboundp menu-bar-update-yank-menu string replace kill-ring kill-ring-max nil kill-ring-yank-pointer interprogram-cut-function t] 4 (#$ . 27805)]) #@185 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 'kill-append #[(string before-p) " \f\n @P @\nP\"" [kill-new before-p string kill-ring t] 3 (#$ . 28374)]) #@359 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. (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 (#$ . 28690)]) #@66 *Non-nil means don't signal an error for killing read-only text. (defvar kill-read-only-ok nil (#$ . -29388)) #@783 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. (defalias 'kill-region #[(beg end) "  \f$+ \f\"\"!}\f }=t=t \fUt \f] \f^Z\\ \f|@@;iAZ@@!+} \f\" \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" kill-region this-command barf-if-buffer-read-only buffer-undo-list t last-command 100 tail old-list undo-strong-limit kill-new] 6 (#$ . 29505) "r"]) #@147 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. (defalias 'copy-region-as-kill #[(beg end) "= \f{\f W\" \f{!Ƈ" [last-command kill-region kill-append beg end kill-new nil] 4 (#$ . 30788) "r"]) #@284 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. (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 (#$ . 31098) "r"]) #@67 Cause following command, if it kills, to append to previous kill. (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 (#$ . 31883) nil]) #@549 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. (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 (#$ . 32125) "*p"]) #@364 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]. (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 (#$ . 32911) "*P"]) #@118 Rotate the yanking point in the kill ring. With argument, rotate that many kills forward (or backward, if negative). (defalias 'rotate-yank-pointer #[(arg) " !" [current-kill arg] 2 (#$ . 33472) "p"]) #@120 Insert after point the contents of BUFFER. Puts mark after the inserted text. BUFFER may be a buffer or a buffer name. (defalias 'insert-buffer #[(buffer) " !\n !É qed)  #`)\f!+Ç" [bufferp buffer get-buffer nil newmark end start insert-buffer-substring push-mark] 4 (#$ . 33682) (list (progn (barf-if-buffer-read-only) (read-buffer "Insert buffer: " (other-buffer (current-buffer) t) t)))]) #@264 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. (defalias 'append-to-buffer #[(buffer start end) "p\n!q\f #*" [oldbuf get-buffer-create buffer insert-buffer-substring start end] 4 (#$ . 34105) (list (read-buffer "Append to buffer: " (other-buffer (current-buffer) t)) (region-beginning) (region-end))]) #@264 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. (defalias 'prepend-to-buffer #[(buffer start end) "p\n!q\f #+" [oldbuf get-buffer-create buffer insert-buffer-substring start end] 4 (#$ . 34637) "BPrepend to buffer: \nr"]) #@276 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. (defalias 'copy-to-buffer #[(buffer start end) "p\n!q  #+" [oldbuf get-buffer-create buffer erase-buffer insert-buffer-substring start end] 4 (#$ . 35089) "BCopy to buffer: \nr"]) #@268 *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. (defvar mark-even-if-inactive nil (#$ . -35563)) (byte-code "##" [put mark-inactive error-conditions (mark-inactive error) error-message "The mark is not active now"] 4) #@336 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 'mark #[(&optional force) " \n  !\"" [force transient-mark-mode mark-active mark-even-if-inactive marker-position mark-marker signal mark-inactive nil] 3 (#$ . 36017)]) #@152 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'. (defalias 'deactivate-mark #[nil " !" [transient-mark-mode nil mark-active run-hooks deactivate-mark-hook] 2 (#$ . 36558)]) (put (quote deactivate-mark) (quote byte-optimizer) (quote byte-compile-inline-expand)) #@701 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))). (defalias 'set-mark #[(pos) "! p! Ɖ" [pos t mark-active run-hooks activate-mark-hook mark-marker nil deactivate-mark-hook] 3 (#$ . 36936)]) #@68 The list of former marks of the current buffer, most recent first. (defvar mark-ring nil (#$ . 37804)) (byte-code "!#" [make-variable-buffer-local mark-ring put permanent-local t] 4) #@73 *Maximum size of mark ring. Start discarding off end if gets this big. (defconst mark-ring-max 16 (#$ . -38001)) #@52 The list of saved global marks, most recent first. (defvar global-mark-ring nil (#$ . 38121)) #@80 *Maximum size of global mark ring. Start discarding off end if gets this big. (defconst global-mark-ring-max 16 (#$ . -38221)) #@409 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. (defalias 'set-mark-command #[(arg) "\n‰#!!!b " [arg push-mark nil t mark error "No mark set in this buffer" pop-mark] 4 (#$ . 38356) "P"]) #@524 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 '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 (#$ . 38931)]) #@107 Pop off mark ring into the buffer's actual mark. Does not set point. Does nothing if mark ring is empty. (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 (#$ . 39903)]) (define-function (quote exchange-dot-and-mark) (quote exchange-point-and-mark)) #@149 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. (defalias 'exchange-point-and-mark #[nil "!\f!`!\nb)Ƈ" [mark t omark error "No mark set in this buffer" set-mark nil] 3 (#$ . 40306) nil]) #@393 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]. (defalias 'transient-mark-mode #[(arg) " ?!V" [arg transient-mark-mode prefix-numeric-value 0] 2 (#$ . 40613) "P"]) #@56 Pop off global mark ring and jump to the top location. (defalias 'pop-global-mark #[nil "@!A!@\f!\f!A@C qeY>dX@~b !+" [global-mark-ring marker-buffer error "No global mark set" marker buffer marker-position position switch-to-buffer] 3 (#$ . 41140) nil]) #@74 *If non-nil, `next-line' inserts newline to avoid `end of buffer' error. (defvar next-line-add-newlines t (#$ . -41449)) #@992 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, it inserts a newline character to create a line, and moves the cursor to that line. Otherwise it moves the cursor 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.). (defalias 'next-line #[(arg) "% U%`m!! b !)5t1ȏ5 !ć" [next-line-add-newlines arg 1 opoint nil newline line-move (line-move arg) (((beginning-of-buffer end-of-buffer) (ding)))] 3 (#$ . 41577) "p"]) #@612 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.). (defalias 'previous-line #[(arg) "t\f\f[!" [nil (byte-code " [!" [line-move arg] 2) (((beginning-of-buffer end-of-buffer) (ding))) line-move arg] 3 (#$ . 42806) "p"]) #@201 *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. (defconst track-eol nil (#$ . -43607)) #@87 *Semipermanent goal column for vertical motion, as set by \[set-goal-column], or nil. (defvar goal-column nil (#$ . -43852)) (make-variable-buffer-local (quote goal-column)) #@198 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. (defvar temporary-goal-column 0 (#$ . 44033)) #@98 *Non-nil means \[next-line] and \[previous-line] ignore invisible lines. Outline mode sets this. (defvar line-move-ignore-invisible nil (#$ . -44282)) (defalias 'line-move #[(arg) "`Ŏ=1=1 .l.n*=.˂/i\f xxVYVOSyy!by!en8WqԂr\"8V!U\"m`\"=>)`\"`\"b`!bSzW8y!U\"o/`S\"=>)/`S\"'`\"b`!bT\"@\f!," [t nil new opoint inhibit-point-motion-hooks ((byte-code "` bb" [new opoint nil inhibit-point-motion-hooks] 1)) last-command next-line previous-line track-eol end-of-line 9999 temporary-goal-column selective-display line-move-ignore-invisible arg 0 1 zerop signal beginning-of-buffer end-of-buffer vertical-motion get-char-property invisible prop buffer-invisibility-spec get-text-property next-single-property-change next-overlay-change -1 previous-single-property-change previous-overlay-change move-to-column goal-column] 4]) (put (quote set-goal-column) (quote disabled) t) #@381 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'. (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 (#$ . 45393) "P"]) #@214 *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. (defvar hscroll-step 0 (#$ . -46003)) #@65 Scrolls the selected window horizontally to make point visible. (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 (#$ . 46260)]) (defalias '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]) #@33 Scroll the "other window" down. (defalias 'scroll-other-window-down #[(lines) " =? ‚ ![!" [scroll-other-window lines - prefix-numeric-value] 3 (#$ . 47096) "P"]) #@160 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. (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 (#$ . 47278) "P"]) #@148 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. (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 (#$ . 47688) "P"]) #@277 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. (defalias 'transpose-chars #[(arg) " l u!\"" [arg -1 transpose-subr forward-char prefix-numeric-value] 4 (#$ . 48074) "*P"]) #@290 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. (defalias 'transpose-words #[(arg) "\n\"" [transpose-subr forward-word arg] 3 (#$ . 48494) "*p"]) #@129 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. (defalias 'transpose-sexps #[(arg) "\n\"" [transpose-subr forward-sexp arg] 3 (#$ . 48891) "*p"]) #@205 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. (defalias 'transpose-lines #[(arg) "\n\"" [transpose-subr #[(arg) "Um uy" [arg 1 nil newline] 2] arg] 3 (#$ . 49127) "*p"]) (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]) (defalias '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]) #@254 *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. (defconst comment-column 32 (#$ . -49976)) (make-variable-buffer-local (quote comment-column)) #@72 *String to insert to start a new comment, or nil if no comment syntax. (defconst comment-start nil (#$ . -50330)) #@202 *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-start-skip nil (#$ . -50451)) #@110 *String to insert to end a new comment. Should be an empty string if comments are terminated by end-of-line. (defconst comment-end "" (#$ . -50707)) #@180 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-hook nil (#$ . 50863)) #@158 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)) (#$ . 51097)) #@217 *String to insert to start a new comment on a line by itself. If nil, use `comment-start' instead. Note that the regular expression `comment-start-skip' should skip this string as well as the `comment-start' string. (defconst block-comment-start nil (#$ . -51345)) #@165 *String to insert to end a new comment on a line by itself. Should be an empty string if comments are terminated by end-of-line. If nil, use `comment-end' instead. (defconst block-comment-end nil (#$ . -51617)) #@75 Indent this line's comment to comment column, or insert an empty comment. (defalias 'indent-for-comment #[nil "y!)\f   ,!`) y #f ՕZՕbf\"\"`iu x Ubx`|jb̉c c),+" [0 looking-at "[ ]*$" empty block-comment-start comment-start starter block-comment-end comment-end ender 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 " "] 5 (#$ . 51834) "*"]) #@297 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. (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 (#$ . 52462) "P"]) #@112 Kill the comment on this line, if any. With argument, kill comments on that many lines starting with this one. (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 (#$ . 53039) "P"]) #@357 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. (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 (#$ . 53516) "r\nP"]) #@161 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. (defalias 'backward-word #[(arg) "[v" [arg] 1 (#$ . 54509) "p"]) #@37 Set mark arg words away from point. (defalias 'mark-word #[(arg) " v`)#" [push-mark arg nil t] 4 (#$ . 54742) "p"]) #@103 Kill characters forward until encountering the end of a word. With argument, do this that many times. (defalias 'kill-word #[(arg) "` v`\"" [kill-region arg] 3 (#$ . 54871) "p"]) #@104 Kill characters backward until encountering the end of a word. With argument, do this that many times. (defalias 'backward-kill-word #[(arg) " [!" [kill-word arg] 2 (#$ . 55060) "p"]) #@153 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. (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 (#$ . 55253)]) #@144 *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. (defconst fill-prefix nil (#$ . -55664)) (make-variable-buffer-local (quote fill-prefix)) #@57 *Regexp to match lines which should not be auto-filled. (defconst auto-fill-inhibit-regexp nil (#$ . -55903)) (defalias 'do-auto-fill #[nil " ?6 & =&i X6y` 5 !)? >E ) i\fV`\fT!ou!!?)xn#x^`,bn)ix`U)!b!) = #)iY))E ͉#," [nil give-up bol justify fc current-justification current-fill-column left 0 auto-fill-inhibit-regexp looking-at (full center right) unjustify-current-line t first bounce opoint move-to-column sentence-end-double-space -1 "\\. " "\\. " "^ \n" re-search-forward "[ ]" " " fill-point prev-column indent-new-comment-line justify-current-line] 4]) #@218 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 `current-fill-column' automatically breaks the line at a previous space. (defalias 'auto-fill-mode #[(&optional arg) " ?!Vĉ " [arg auto-fill-function prefix-numeric-value 0 do-auto-fill force-mode-line-update] 2 (#$ . 56652) "P"]) #@69 Automatically break line at a previous space, in insertion of text. (defalias 'auto-fill-function #[nil "" [nil] 1 (#$ . 57051)]) #@41 Unconditionally turn on Auto Fill mode. (defalias 'turn-on-auto-fill #[nil "!" [auto-fill-mode 1] 2 (#$ . 57189)]) #@128 Set `fill-column' to current column, or to argument if given. The variable `fill-column' has a separate value for each buffer. (defalias 'set-fill-column #[(arg) " \ni \"" [arg fill-column message "fill-column set to %d"] 3 (#$ . 57314) "P"]) #@190 *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]. (defconst comment-multi-line nil (#$ . -57575)) #@488 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]. The inserted newline is marked hard if `use-hard-newlines' is true, unless optional argument SOFT is non-nil. (defalias 'indent-new-comment-line #[(&optional soft) "x`w`|\f!! |\n{` y\n #){ȕBϔlooo y` y\n #)oȕjϔDbi`ϕ{))\n\n Ԛucul!u !, !*" [nil comstart comcol " " soft insert-and-inherit 10 newline 1 comment-multi-line comment-start-skip opoint -1 re-search-forward t 0 win comment-end comment-start comment-column "" indent-for-comment delete-char fill-prefix indent-according-to-mode indent-to-left-margin] 4 (#$ . 57819) nil]) #@239 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. (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 (#$ . 58876) "P"]) #@63 The string displayed in the mode line when in overwrite mode. (defconst overwrite-mode-textual " Ovwrt" (#$ . 59503)) #@70 The string displayed in the mode line when in binary overwrite mode. (defconst overwrite-mode-binary " Bin Ovwrt" (#$ . 59627)) #@464 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. (defalias 'overwrite-mode #[(arg) " ?!V " [arg overwrite-mode prefix-numeric-value 0 overwrite-mode-textual force-mode-line-update] 2 (#$ . 59762) "P"]) #@654 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'. (defalias 'binary-overwrite-mode #[(arg) " =?!V " [arg overwrite-mode overwrite-mode-binary prefix-numeric-value 0 force-mode-line-update] 2 (#$ . 60402) "P"]) #@50 *Non-nil means display line number in mode line. (defvar line-number-mode nil (#$ . -61239)) #@158 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. (defalias 'line-number-mode #[(arg) " ?!V " [arg line-number-mode prefix-numeric-value 0 force-mode-line-update] 2 (#$ . 61339) "P"]) #@71 *Non-nil means show matching open-paren when close-paren is inserted. (defvar blink-matching-paren t (#$ . -61649)) #@69 *If non-nil, is maximum distance to search for matching open-paren. (defconst blink-matching-paren-distance 12000 (#$ . -61771)) #@74 *The number of seconds that `blink-matching-open' will delay at a match. (defconst blink-matching-delay 1 (#$ . -61906)) #@68 Move cursor momentarily to the beginning of the sexp before point. (defalias 'blink-matching-open #[nil "`eTV`u!`)Z\"U` \n9e`\nZ]}̏)ZfzUZSff!U?  bb w!bӊxn)y`T{uwl)`{xo)xy`x`{T{QT{\" !\n?!," [blink-matching-paren logand -1 skip-syntax-backward "/\\" 1 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 blink-matching-delay message "Matches %s" " " 0 "\n " "..." "Mismatched parentheses" "Unmatched parenthesis"] 6 (#$ . 62033) nil]) (byte-code "" [blink-matching-open blink-paren-function] 1) #@153 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. (defalias 'keyboard-quit #[nil "\n!\"" [transient-mark-mode nil mark-active run-hooks deactivate-mark-hook signal quit] 3 (#$ . 62823) nil]) (define-key global-map "" (quote keyboard-quit)) #@211 Function to call to "quit" the current buffer, or nil if none. \[keyboard-escape-quit] calls this function when its more local actions (such as cancelling a prefix argument, minibuffer or region) do not apply. (defvar buffer-quit-function nil (#$ . 63185)) #@374 Exit the current "mode" (in a generalized sense of the word). This command can exit an interactive command such as `query-replace', can clear out a prefix argument or a region, can get out of the minibuffer or other recursive edit, cancel the use of the current buffer (for special-purpose buffers), or go back to just one window (by deleting all but the selected window). (defalias 'keyboard-escape-quit #[nil "=‡ V ‡//A! 8 !?A " [last-command mode-exited nil minibuffer-depth 0 abort-recursive-edit current-prefix-arg transient-mark-mode mark-active run-hooks deactivate-mark-hook buffer-quit-function one-window-p t delete-other-windows] 2 (#$ . 63449) nil]) (define-key global-map "" (quote keyboard-escape-quit)) #@339 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. (defalias 'set-variable #[(var val) " L" [var val] 2 (#$ . 64226) (byte-code "!\nN DF!&\n\"!,D" [read-variable "Set variable: " var (funcall myhelp) minibuffer-help-form #[nil "\n!!\n\"O!\n!' !\nJ!) q )ȑ" ["*Help*" prin1 var princ "\nDocumentation:\n" documentation-property variable-documentation 1 nil boundp 20 print-length "\n\nCurrent value: " standard-output help-mode] 5] myhelp variable-interactive prop call-interactively lambda (arg) interactive arg eval-minibuffer format "Set %s to value: "] 7)]) #@40 Local map for completion list buffers. (defvar completion-list-mode-map nil (#$ . 65139)) (byte-code ". \n#\n#\n#\n#\n#\n#\n)#" [completion-list-mode-map make-sparse-keymap map define-key [mouse-2] mouse-choose-completion [down-mouse-2] nil " " choose-completion "" delete-completion-window [left] previous-completion [right] next-completion put completion-list-mode mode-class special] 4) #@186 Record the buffer that was current when the completion list was requested. This is a local variable in the completion list buffer. Initial value is nil to avoid some compiler warnings. (defvar completion-reference-buffer nil (#$ . 65574)) #@320 Number of chars at beginning of minibuffer not involved in completion. This is a local variable in the completion list buffer but it talks about the buffer in `completion-reference-buffer'. If this is nil, it means to compare text to determine which part of the tail end of the buffer's text is involved in completion. (defvar completion-base-size nil (#$ . 65820)) #@90 Delete the completion list window. Go to the window from which completion was requested. (defalias 'delete-completion-window #[nil " ! ! !!)" [completion-reference-buffer buf delete-window selected-window get-buffer-window select-window] 3 (#$ . 66192) nil]) #@51 Move to the previous item in the completion list. (defalias 'previous-completion #[(n) " [!" [next-completion n] 2 (#$ . 66469) "p"]) #@118 Move to the next item in the completion list. WIth prefix argument N, move N items (negative N means move backward). (defalias 'next-completion #[(n) "V'm'`\"`\"b`\"b)SWVo?V`S\"B`\"b`\"b`\"b)T(" [n 0 get-text-property mouse-face prop next-single-property-change previous-single-property-change] 4 (#$ . 66612) "p"]) #@52 Choose the completion that point is in or next to. (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 (#$ . 66986) nil]) (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]) (defalias 'choose-completion-string #[(choice &optional buffer base-size) " !\"#  !#!eq 5 e\\`|: ! c` GZ`#\"`\") !ee )" [buffer completion-reference-buffer string-match "\\` \\*Minibuf-[0-9]+\\*\\'" buffer-name active-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-window minibuffer-completion-table exit-minibuffer] 4]) #@264 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. (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 (#$ . 68345) nil]) #@340 A function to customize how completions are identified in completion lists. `completion-setup-function' calls this function with no arguments each time it has found what it thinks is one completion. Point is at the end of the completion in the completion list buffer. If this function moves point, it can alter the end of that completion. (defvar completion-fixup-function nil (#$ . 68908)) (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]) (byte-code "\"\f##\f##" [add-hook completion-setup-hook completion-setup-function define-key minibuffer-local-completion-map [prior] switch-to-completions minibuffer-local-must-match-map [prior] ""] 4) #@36 Select the completion list window. (defalias 'switch-to-completions #[nil "!!eb!y" [select-window get-buffer-window "*Completions*" search-forward "\n\n" 1] 3 (#$ . 70074) nil]) (defalias 'event-apply-alt-modifier #[(ignore-prompt) " $!" [vector event-apply-modifier read-event alt 22 "A-"] 6]) (defalias 'event-apply-super-modifier #[(ignore-prompt) " $!" [vector event-apply-modifier read-event super 23 "s-"] 6]) (defalias 'event-apply-hyper-modifier #[(ignore-prompt) " $!" [vector event-apply-modifier read-event hyper 24 "H-"] 6]) (defalias 'event-apply-shift-modifier #[(ignore-prompt) " $!" [vector event-apply-modifier read-event shift 25 "S-"] 6]) (defalias 'event-apply-control-modifier #[(ignore-prompt) " $!" [vector event-apply-modifier read-event control 26 "C-"] 6]) (defalias 'event-apply-meta-modifier #[(ignore-prompt) " $!" [vector event-apply-modifier read-event meta 27 "M-"] 6]) #@233 Apply a modifier flag to event EVENT. SYMBOL is the name of this modifier, as a symbol. LSHIFTBY is the numeric value of this modifier, in keyboard events. PREFIX is the string that represents this modifier in an event type symbol. (defalias 'event-apply-modifier #[(event symbol lshiftby prefix) "c =:XYZX1Y1Z\f\"\" =ZXQYQ\f\"\"\f\"\" !>m9vx@!P!9AB)" [event symbol control 122 97 96 90 65 64 logior lsh 1 lshiftby shift event-modifiers event-type intern prefix symbol-name] 4 (#$ . 71035)]) (byte-code " # # # # # #\"" [define-key function-key-map [24 64 104] event-apply-hyper-modifier [24 64 115] event-apply-super-modifier [24 64 109] event-apply-meta-modifier [24 64 97] event-apply-alt-modifier [24 64 83] event-apply-shift-modifier [24 64 99] event-apply-control-modifier 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))] 4)