;ELC ;;; compiled by jwz@thalidomide on Sat May 21 06:43:58 1994 ;;; from file /th/jwz/emacs19/lisp/prim/simple.el ;;; emacs version 19.10 Lucid (beta25). ;;; bytecomp version 2.24; 26-Apr-94. ;;; 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 "This file was compiled for Emacs 19.")) (fset 'open-line #[(arg) "?no? =` BuV ccSj)\nu*" [nil do-fill-prefix flag buffer-undo-list t -1 arg 0 fill-prefix 10 1] 3 "\ Insert a newline and leave point before it. With arg N, insert N newlines." "*p"]) (fset 'split-line #[nil "wi`c \"\nb*" [" " nil pos col 10 indent-to 0] 3 "\ Split current line, moving portion beyond point vertically down." "*"]) (fset 'quoted-insert #[(arg) "= =! \")" [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"]) (fset 'delete-indentation #[(&optional arg) "y yh=``S| ` G\\dX `` G\\{`` G\\| " [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"]) (fset '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." "*"]) (fset 'delete-horizontal-space #[nil "x`w`|" [" " nil] 3 "\ Delete all spaces and tabs around point." "*"]) (fset 'just-one-space #[nil "xgUuc`w`|" [" " nil 32 1] 3 "\ Delete all spaces and tabs around point, leaving one space." "*"]) (fset 'delete-blank-lines #[nil "y!!?oy!?)\ny y`#y`e|\n y`#y`d|)!`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 all blank lines that follow it." "*"]) (fset 'back-to-indentation #[nil "yw" [0 " " nil] 2 "\ Move point to the first non-whitespace character on this line." "_"]) (fset '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'." "*"]) (fset '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 "MM" [kill-forward-chars #[(arg) "<@=``\\\"" [arg - -1 kill-region] 4] kill-backward-chars #[(arg) "<@=``Z\"" [arg - -1 kill-region] 4]] 2) (fset 'backward-delete-char-untabify #[(arg &optional killp) " VohUiu iZ \"!)u SX* \" l?\")" [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 prefix arg is was specified." "*p\nP"]) (fset '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: "]) (fset '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"]) (fset 'end-of-buffer #[(&optional arg) " d!? T V ! ǥ_ !_ǥZdb y\n!)" [push-mark pos-visible-in-window-p scroll-to-end arg buffer-size 10000 prefix-numeric-value 10 1 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"]) (fset 'mark-beginning-of-buffer #[(&optional arg) " V ! ť_ !_\\ťe#" [push-mark arg buffer-size 10000 prefix-numeric-value 10 nil t] 4 "\ Push a mark at the beginning of the buffer; leave point where it is. With arg N, push mark N/10 of the way from the true beginning." "P"]) (define-function 'mark-bob 'mark-beginning-of-buffer) (fset 'mark-end-of-buffer #[(&optional arg) " T V ! ť_ !_ťZd#" [push-mark arg buffer-size 10000 prefix-numeric-value 10 nil t] 5 "\ Push a mark at the end of the buffer; leave point where it is. With arg N, push mark N/10 of the way from the true end." "P"]) (define-function 'mark-eob 'mark-end-of-buffer) (fset '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]) (fset 'eval-current-buffer #[(&optional printflag) "p \"" [eval-buffer printflag] 3 "\ Evaluate the current buffer as Lisp code. Programs can pass argument PRINTFLAG which controls printing of output: nil means discard it; anything else is stream for print." nil]) (byte-code "MM" [count-words-buffer #[(b) "pq!ed\"\"*" [b buf message gettext "Buffer has %d words" count-words-region] 6 nil "b"] count-words-region #[(start end) "\nb` Wvw Tr! \" *" [0 n start end 1 message gettext "Region has %d words"] 3 nil "r"]] 2) (fset 'count-lines-region #[(start end) " \n\"! \n Z# )" [count-lines start end n message gettext "Region has %d lines, %d characters"] 5 "\ Print number of lines and characters in the region." "_r"]) (fset 'count-lines-buffer #[(b) "pqed\"!\ndeZ#\n+" [b nil cnt buf count-lines message gettext "Region has %d lines, %d characters"] 6 "\ Print number of lines and charcters in the specified buffer." "_b"]) (fset 'what-line #[nil "~y!`\"T\"*" [0 message gettext "Line %d" count-lines 1] 5 "\ Print the current line number (in the buffer) of point." "_"]) (fset 'count-lines #[(start end) " Ž }eb =$\\p$\\pdb UnT) 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."]) (fset 'what-cursor-position #[nil "ged` V ǥ S\\ ȥ] ʥ S_\\ ] UΪ \"i \nU U\n TU!  \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 gettext "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" text-char-description "Char: %s (0%o) point=%d of %d(%d%%) column %d %s"] 12 "\ Print info on cursor position (on screen and within buffer)." "_"]) (fset '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]) (fset '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'." "xEval: "]) (fset 'edit-and-eval-command #[(prompt command &optional history) "\nŏ#!" [eval read-minibuffer prompt nil (byte-code " !)" [t print-readably prin1-to-string command] 2) ((error (prin1-to-string command))) history (command-history . 1)] 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."]) (fset 'repeat-complex-command #[(arg) "! S 8! B#" [edit-and-eval-command gettext "Redo: " arg command-history error ""] 5 "\ 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"]) (fset '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 'advertised-undo 'undo) (fset 'undo #[(&optional arg) "  =!! = !!@@@\"A]* !*̉" [t this-command buffer-modified-p recent-auto-save-p recent-save modified selected-window minibuffer-window message gettext "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.") (fset 'undo-start #[nil "=!!" [buffer-undo-list t error gettext "No undo information in this buffer" pending-undo-list] 3 "\ Set `pending-undo-list' to the front of the undo list. The next call to `undo-more' will undo the most recently made change."]) (fset 'undo-more #[(count) "!! \"" [pending-undo-list error gettext "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."]) (fset 'call-with-transparent-undo #[(fn &rest args) "pƎ \"-" [nil -1 obuffer undo-threshold undo-high-threshold buffer-undo-list ((byte-code "q~  G \"w," [obuffer nil buffer-read-only buffer-undo-list tail t primitive-undo] 4)) apply fn args] 4 "\ Apply FN to ARGS, and then undo all changes made by FN to the current buffer. The undo records are processed even if FN returns non-locally. There is no trace of the changes made by FN in the buffer's undo history. You can use this in a write-file-hooks function with continue-save-buffer to make the contents of a disk file differ from its in-memory buffer."]) (fset 'start-process-shell-command #[(name buffer &rest args) "= $ #P%" [system-type vax-vms apply start-process name buffer args shell-file-name "-c" "exec " mapconcat identity " "] 10 "\ Start a program in a subprocess. Return the process object for it. Args are NAME BUFFER COMMAND &rest COMMAND-ARGS. NAME is name for process. It is modified if necessary to make it unique. BUFFER is the buffer or (buffer-name) to associate with the process. Process output goes at end of that buffer, unless you specify an output stream or filter function to handle the output. BUFFER may be also nil, meaning that this process is not associated with any buffer Third arg is command name, the name of a shell command. Remaining arguments are the arguments for the command. Wildcards and redirection are handle as usual in the shell."]) (fset 'call-process-region #[(start end program &optional deletep buffer displayp &rest args) "=!!Ǝ %  | &*" [system-type vax-vms make-temp-name "tmp:emacs" "/tmp/emacs" temp ((byte-code "" [nil (delete-file temp) ((file-error))] 3)) write-region start end nil silent deletep apply call-process program buffer displayp args] 7 "\ Send text from START to END to a synchronous process running PROGRAM. Delete the text if fourth arg DELETE is non-nil. Insert output in BUFFER before point; t means current buffer; nil for BUFFER means discard it; 0 means discard and don't wait. Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted. Remaining args are passed to PROGRAM at startup as command args. If BUFFER is nil, returns immediately with value nil. Otherwise waits for PROGRAM to terminate and returns a numeric exit status or a signal description string. If you quit, the process is first killed with SIGINT, then with SIGKILL if you quit again before the process exits."]) (fset 'shell-command #[(command &optional flag) " &!  ̎\"!щO!``$*" [flag barf-if-buffer-read-only push-mark call-process shell-file-name nil t "-c" command exchange-point-and-mark match-data data ((store-match-data data)) string-match "[ ]*&[ ]*$" require background 0 shell-command-on-region] 7 "\ 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." (byte-code "!! D" [read-shell-command gettext "Shell command: " current-prefix-arg] 3)]) (fset 'shell-command-on-region #[(start end command &optional flag interactive) " ` W ɉ & !)!!Վp=d|e|edɉ &ɉq ) &ɉ," [flag interactive mark swap push-mark call-process-region start end shell-file-name t nil "-c" command exchange-point-and-mark get-buffer-create gettext "*Shell Command Output*" default-directory directory success buffer ((byte-code "q Uªed\")U !!! Uˊqeb``{)\"!\")̇" [buffer buffer-size 0 count-lines lines success message gettext "(Shell command completed with no output)" kill-buffer 1 "%s" nil set-window-start display-buffer] 5)) erase-buffer] 9 "\ 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." (byte-code "` ^` ]!! !" [mark read-shell-command gettext "Shell command on region: " current-prefix-arg prefix-numeric-value] 6)]) (fset 'universal-argument #[nil "  ! _q #+" [4 last-command-event nil key start-char factor next-command-event prefix-arg-internal] 5 "\ 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 "MM" [prefix-arg-internal #[(event factor value) "!!  W [  = = [!!j!c Y X  _ Z\\ !!R!KC  _ U!!!= \"*" [t zmacs-region-stays 1 nil char sign key-press-event-p event event-key value 0 -1 - 45 factor next-command-event 48 57 10 prefix-arg key-binding vector universal-argument describe-prefix-arg unread-command-event] 4] describe-prefix-arg #[(value sign) "! _\":!@\" W!!" [value message gettext "Arg: %d" sign "Arg: [%d]" 0 "Arg: -"] 4]] 2) (fset 'digit-argument #[(arg) " #" [prefix-arg-internal last-command-event nil arg] 4 "\ Part of the numeric argument for the next command. \\[universal-argument] following digits or minus sign ends the argument." "P"]) (fset 'negative-argument #[(arg) " \" #" [prefix-arg-internal character-to-event 45 allocate-event nil arg] 4 "\ Begin a negative numeric argument for the next command. \\[universal-argument] following digits or minus sign ends the argument." "P"]) (fset 'forward-to-indentation #[(arg) "yw" [arg " " nil] 2 "\ Move forward ARG lines and position at first nonblank character." "p"]) (fset '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.") (fset 'kill-line #[(&optional arg) "` !ym\"!ny`)\"" [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 kill-hooks nil "\ Functions run when something is added to the Emacs kill ring. These functions are called with one argument, the string most recently cut or copied. You can use this to, for example, make the most recent kill become the X Clipboard selection.") (defvar kill-ring nil "\ List of killed text sequences. In order to maintain correct interaction with cut-and-paste facilities offered by window systems, the functions `kill-new', `kill-append', and `current-kill' should be used to access the kill ring, instead of using this variable directly.") (defvar 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.") (fset 'kill-new #[(string) " BG\nV\nS á \"" [string kill-ring kill-ring-max nil kill-ring-yank-pointer run-hook-with-args kill-hooks] 4 "\ Make STRING the latest kill in the kill ring. Set the kill-ring-yank pointer to point to it. Runs `kill-hooks'."]) (fset 'kill-append #[(string before-p) " \n@P@\nP\n\"" [kill-ring before-p string run-hook-with-args kill-hooks] 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. Runs `kill-hooks'."]) (fset 'current-kill #[(n &optional do-not-move) "!! GZG\"@)" [kill-ring error gettext "Kill ring is empty" mod n kill-ring-yank-pointer tem do-not-move] 3 "\ Rotate the yanking point by N places, and then return that kill. If optional arg DO-NOT-MOVE is non-nil, then don't actually move the yanking point; just return the Nth kill forward."]) (fset 'kill-region #[(beg end &optional verbose) " !!!! ] ^Z\"! ] ^Z\" ==  ] ^Z\\ | ;As@@!ω* \" |" [beg end error zmacs-regions gettext "The region is not active now" "The mark is not set now" verbose buffer-read-only message "Copying %d characters" "Killing %d characters" buffer-undo-list t last-command kill-region 100 nil tail undo-high-threshold kill-new this-command copy-region-as-kill] 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].) 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\np"]) (fset 'copy-region-as-kill #[(beg end) "= { W\" {!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. Runs `kill-hooks'." "r"]) (fset 'kill-ring-save #[(beg end) " \n\"t` U\n ` \"b! b +" [copy-region-as-kill beg end t inhibit-quit opoint other-end pos-visible-in-window-p selected-window sit-for 0 quit-flag mark zmacs-deactivate-region] 3 "\ 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." "r"]) (fset 'append-next-kill #[nil "t!!" [kill-region this-command message gettext "If the next command is a kill, it will append" last-command] 3 "\ Cause following command, if it kills, to append to previous kill." "_"]) (fset 'yank-pop #[(arg) "=!!`!W`!|`! !c!)" [last-command yank error gettext "Previous command was not a yank" this-command mark t before set-mark current-kill arg exchange-point-and-mark] 3 "\ 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"]) (fset 'yank #[(&optional arg) "`! <Ū =Ǫ S!c :!ɉ" [t this-command push-mark current-kill arg 0 - -1 exchange-point-and-mark yank] 3 "\ 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"]) (fset '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"]) (fset 'insert-buffer #[(buffer) " ! !É qed)  #`) !+Ç" [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." (byte-code " ! #C" [barf-if-buffer-read-only read-buffer gettext "Insert buffer: " other-buffer t] 4)]) (fset 'append-to-buffer #[(buffer start end) "p\n!q #*" [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." (byte-code "!\"# E" [read-buffer gettext "Append to buffer: " other-buffer nil t region-beginning region-end] 5)]) (fset 'prepend-to-buffer #[(buffer start end) "p\n!q #+" [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"]) (fset '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"]) (fset 'mark #[(&optional force) " !\n!)" [mark-marker force m marker-position] 3 "\ Return this buffer's mark value as integer, or nil if no mark. If `zmacs-regions' is true, then this returns nil unless the region is currently in the active (highlighted) state. With an argument of t, this returns the mark (if there is one) regardless of the active-region state. You should *generally* not use the mark unless the region is active, if the user has expressed a preference for the active-region model. If you are using this in an editing command, you are most likely making a mistake; see the documentation of `set-mark'."]) (fset 'set-mark #[(pos) "!\np" [mark-marker t pos] 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 saved former marks of the current buffer, most recent first.") (make-variable-buffer-local 'mark-ring) (defvar 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.") (fset 'set-mark-command #[(arg) "‰#!!!!b " [arg push-mark nil t mark error gettext "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"]) (fset 'push-mark #[(&optional location nomsg activate-region) "!!! BG V @Ɖ S ơ`!  @!p=!! B G V  @Ɖ S ơ  V!! Ƈ" [mark t copy-marker mark-marker mark-ring mark-ring-max nil set-mark location global-mark-ring marker-buffer global-mark-ring-max nomsg executing-macro minibuffer-depth 0 message gettext "Mark set" activate-region zmacs-activate-region] 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. Activate mark if optional third arg ACTIVATE-REGION 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."]) (fset 'pop-mark #[nil "!!C@!@ʼn! A" [mark-ring copy-marker mark-marker t set-mark nil mark ding] 4 "\ Pop off mark ring into the buffer's actual mark. Does not set point. Does nothing if mark ring is empty."]) (define-function 'exchange-dot-and-mark 'exchange-point-and-mark) (fset 'exchange-point-and-mark #[(&optional dont-activate-region) "!!!`!\nb )ɇ" [mark t omark error gettext "No mark set in this buffer" set-mark dont-activate-region zmacs-activate-region nil] 4 "\ Put the mark where point is now, and point where the mark is now." nil]) (fset 'mark-something #[(mark-fn movement-fn arg) " \n= `W [ b !`)#" [push-mark last-command mark-fn mark arg movement-fn nil t] 4 "\ internal function used by mark-sexp, mark-word, etc."]) (fset 'pop-global-mark #[nil "!@ ! !A qeYdX~b !+" [global-mark-ring error "No global mark set" marker marker-buffer buffer marker-position position switch-to-buffer] 2 "\ 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.") (fset 'next-line #[(arg) " U`y `Uh=c b !) !Ƈ" [next-line-add-newlines arg 1 opoint 10 line-move nil] 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"]) (fset '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"]) (defvar 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 '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 "M#" [line-move #[(arg) "=!! ! \n=!! ! )" [line-move (byte-code "== ln=Ūi y!n Wͪ\" V!U\" S e Wy!U\" T e!χ" [last-command next-line previous-line track-eol end-of-line 9999 temporary-goal-column selective-display zerop arg throw line-move 0 beginning-of-buffer end-of-buffer nil vertical-motion 1 -1 move-to-column goal-column] 5) signal beginning-of-buffer message gettext "Beginning of buffer" move-to-column goal-column temporary-goal-column ding end-of-buffer "End of buffer"] 4] put set-goal-column disabled t] 4) (fset 'set-goal-column #[(arg) "!!i!!\n\"" [arg nil goal-column message gettext "No goal column" substitute-command-keys "Goal column %d (use \\[set-goal-column] with an arg to unset it)"] 4 "\ 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"]) (fset 'transpose-chars #[(arg) "lu!\"" [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"]) (fset '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"]) (fset '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"]) (fset '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 "MM" [transpose-subr #[(mover arg) " U!`!`!b!`!` )! V!`!`!`!` b ST W!`!`!`!` TW," [nil end2 start2 end1 start1 arg 0 mover 1 -1 mark t transpose-subr-1 exchange-point-and-mark] 5] transpose-subr-1 #[nil " ^\n ]V!!\n{ { | bc\n W\n\nGGZ\\bG!c*" [end1 end2 start1 start2 error gettext "Don't have two things to transpose" word2 word1 delete-char] 3]] 2) (defvar 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 'comment-column) (defvar comment-start nil "\ *String to insert to start a new comment, or nil if no comment syntax defined.") (defvar 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.") (defvar 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. Use `comment-indent-function' instead. This function is called with no args with point at the beginning of the comment's starting delimiter.") (defvar comment-indent-function '(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.") (fset 'indent-for-comment #[nil "y !!`)  # ΕΕb\"\"` i  U bx` |jbʼn cc)," [0 comment-start error gettext "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." "*"]) (fset 'set-comment-column #[(arg) "=!y!y!Ĕbi!\") i!\"" [arg - kill-comment nil 0 re-search-backward comment-start-skip re-search-forward comment-column message gettext "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"]) (fset 'kill-comment #[(arg) "!! !V̊`y  !#w`y#ɔbx`\" ) yS0*" [comment-start-skip error gettext "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"]) (fset 'comment-region #[(beg end &optional arg) "! V  ) \n : !V\nP\n P Sg } bm?$=W=\n!!\nG!pTV\n!!\nG!f) Ԙ=x`eZ GYNJ G! !!) G[!TVx G! !! G!)W)yU!\nc Ԙ c#U-" [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"]) (fset '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"]) (fset 'mark-word #[(arg) " #" [mark-something mark-word forward-word arg] 4 "\ Set mark arg words away from point." "p"]) (fset '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"]) (fset '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"]) (fset 'current-word #[(&optional strict) "```!`\nb!` \n=\n=?NJy`)\"nNJ`)\"`!``!` { {," [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. If point is not between two word-constituent characters, but immediately follows one, move back first. Otherwise, if point precedes a word constituent, move forward first. Otherwise, move backwards until a word constituent is found and get that word; if you a newlines is reached first, move forward instead."]) (defvar 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 'fill-prefix) (defvar auto-fill-inhibit-regexp nil "\ *Regexp to match lines which should not be auto-filled.") (fset 'do-auto-fill #[nil "\ny\n!) ?i V` T!o u!!?)xn #xG`,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]) (defvar 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].") (fset 'indent-new-comment-line #[nil "x`w`|c Ȋ`y#)˔ loy`y#)˔ ^ bi`˕{))\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]." "*"]) (fset '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) (fset 'turn-on-auto-fill #[nil "!" [auto-fill-mode 1] 2 "\ Unconditionally turn on Auto Fill mode."]) (fset 'set-fill-column #[(arg) "i! \"" [arg fill-column message gettext "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"]) (fset 'set-selective-display #[(arg) "=!!e`} b !)  !!) !\"!\"\"\"" [selective-display t error gettext "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"]) (defvar overwrite-mode-textual (purecopy " Ovwrt") "\ The string displayed in the mode line when in overwrite mode.") (defvar overwrite-mode-binary (purecopy " Bin Ovwrt") "\ The string displayed in the mode line when in binary overwrite mode.") (fset '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"]) (fset '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"]) (fset '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.") (defvar blink-matching-paren-distance 12000 "\ *If non-nil, is maximum distance to search for matching open-paren.") (fset 'blink-matching-open #[nil "`eTV`Zfz>?\n` e` Z] }ˏ)fzU Sf fH\"\"U?b !b!xn)y`T{uwl)`{!xy`x`{T{Q\"!! ?!!-" [2 (47 92) blink-matching-paren oldpos t parse-sexp-ignore-comments nil blinkpos mismatch blink-matching-paren-distance (byte-code " \"" [scan-sexps oldpos -1 blinkpos] 3) ((error)) 36 logand lsh syntax-table -8 255 pos-visible-in-window-p sit-for 1 message gettext "Matches %s" " " 0 backward-char "\n " "..." "Mismatched parentheses" "Unmatched parenthesis"] 6 "\ Move cursor momentarily to the beginning of the sexp before point." "_"]) (byte-code "" [blink-matching-open blink-paren-function] 1) (fset '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 "!! N  DF!! \"!,D" [read-variable gettext "Set variable: " var (funcall myhelp) minibuffer-help-form #[nil "! !!! \"O! ! !! J!)ɑ" [gettext "*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)])