;ELC ;;; Compiled by rms@psilocin.ai.mit.edu on Tue Aug 18 03:22:57 1998 ;;; from file /gd/gnu/emacs/lisp/comint.el ;;; in Emacs version 20.2.98.3 ;;; with bytecomp version 2.48 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`comint.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (byte-code "\302\303!\210\304\305\306\307\310%\210\304\311\306\312\305%\210\304\313\306\314 \315\305&\207" [:group :prefix require ring custom-declare-group comint nil "General command interpreter in a window stuff." processes comint-completion "Completion facilities in comint" comint-source "Source finding facilities in comint" "comint-"] 8) #@371 Regexp to recognise prompts in the inferior process. Defaults to "^", the null string at BOL. Good choices: Canonical Lisp: "^[^> \n]*>+:? *" (Lucid, franz, kcl, T, cscheme, oaklisp) Lucid Common Lisp: "^\\(>\\|\\(->\\)+\\) *" franz: "^\\(->\\|<[0-9]*>:\\) *" kcl: "^>+ *" shell: "^[^#$%>\n]*[#$%>] *" T: "^>+ *" This is a good thing to set in mode hooks. (defvar comint-prompt-regexp "^" (#$ . 950)) #@382 List of characters to recognise as separate arguments in input. Strings comprising a character in this list will separate the arguments surrounding them, and also be regarded as arguments in their own right (unlike whitespace). See `comint-arguments'. Defaults to the empty list. For shells, a good value is (?\| ?& ?< ?> ?\( ?\) ?;). This is a good thing to set in mode hooks. (defvar comint-delimiter-argument-list nil (#$ . 1372)) #@398 *If non-nil, expand input command history references on completion. This mirrors the optional behavior of tcsh (its autoexpand and histlit). If the value is `input', then the expansion is seen on input. If the value is `history', then the expansion is only when inserting into the buffer's input ring. See also `comint-magic-space' and `comint-dynamic-complete'. This variable is buffer-local. (custom-declare-variable 'comint-input-autoexpand 'nil '(#$ . -1816) :type '(choice (const :tag "off" nil) (const input) (const history) (other :tag "on" t)) :group 'comint) #@143 *If non-nil, don't add input matching the last on the input ring. This mirrors the optional behavior of bash. This variable is buffer-local. (custom-declare-variable 'comint-input-ignoredups 'nil '(#$ . -2394) :type 'boolean :group 'comint) #@199 *If non-nil, name of the file to read/write input history. See also `comint-read-input-ring' and `comint-write-input-ring'. This variable is buffer-local, and is a good thing to set in mode hooks. (custom-declare-variable 'comint-input-ring-file-name 'nil '(#$ . -2643) :type 'boolean :group 'comint) #@282 *Controls whether input to interpreter causes window to scroll. If nil, then do not scroll. If t or `all', scroll all windows showing buffer. If `this', scroll only the selected window. The default is nil. See `comint-preinput-scroll-to-bottom'. This variable is buffer-local. (custom-declare-variable 'comint-scroll-to-bottom-on-input 'nil '(#$ . -2952) :type '(choice (const :tag "off" nil) (const t) (const all) (const this)) :group 'comint) #@405 *Controls whether interpreter output causes window to scroll. If nil, then do not scroll. If t or `all', scroll all windows showing buffer. If `this', scroll only the selected window. If `others', scroll only those that are not the selected window. The default is nil. See variable `comint-scroll-show-maximum-output' and function `comint-postoutput-scroll-to-bottom'. This variable is buffer-local. (custom-declare-variable 'comint-scroll-to-bottom-on-output 'nil '(#$ . -3408) :type '(choice (const :tag "off" nil) (const t) (const all) (const this) (const others)) :group 'comint) #@262 *Controls how interpreter output causes window to scroll. If non-nil, then show the maximum output when the window is scrolled. See variable `comint-scroll-to-bottom-on-output' and function `comint-postoutput-scroll-to-bottom'. This variable is buffer-local. (custom-declare-variable 'comint-scroll-show-maximum-output 'nil '(#$ . -4003) :type 'boolean :group 'comint) #@206 *The maximum size in lines for comint buffers. Comint buffers are truncated from the top to be no greater than this number, if the function `comint-truncate-buffer' is on `comint-output-filter-functions'. (custom-declare-variable 'comint-buffer-maximum-size '1024 '(#$ . -4381) :type 'integer :group 'comint) #@29 Size of input history ring. (defvar comint-input-ring-size 32 (#$ . 4696)) #@183 *If non-nil, assume that the subprocess echoes any input. If so, delete one copy of the input so that only one copy eventually appears in the buffer. This variable is buffer-local. (custom-declare-variable 'comint-process-echoes 'nil '(#$ . -4778) :type 'boolean :group 'comint) #@117 *Regexp matching prompts for passwords in the inferior process. This is used by `comint-watch-for-password-prompt'. (custom-declare-variable 'comint-password-prompt-regexp '"\\(\\([Oo]ld \\|[Nn]ew \\|'s \\|^\\)[Pp]assword\\|pass phrase\\):\\s *\\'" '(#$ . -5065) :type 'regexp :group 'comint) #@318 Function that returns old text in comint mode. This function is called when return is typed while the point is in old text. It returns the text to be submitted as process input. The default is `comint-get-old-input-default', which grabs the current line, and strips off leading text matching `comint-prompt-regexp'. (defvar comint-get-old-input 'comint-get-old-input-default (#$ . 5365)) #@190 List of functions called to perform completion. Functions should return non-nil if completion was performed. See also `comint-dynamic-complete'. This is a good thing to set in mode hooks. (defvar comint-dynamic-complete-functions '(comint-replace-by-expanded-history comint-dynamic-complete-filename) (#$ . 5761)) #@203 Predicate for filtering additions to input history. Takes one argument, the input. If non-nil, the input may be saved on the input history list. Default is to save anything that isn't all whitespace. (defvar comint-input-filter #[(str) "\301\302\"?\207" [str string-match "\\`\\s *\\'"] 3] (#$ . 6083)) #@160 Functions to call before input is sent to the process. These functions get one argument, a string containing the text to send. This variable is buffer-local. (defvar comint-input-filter-functions nil (#$ . 6396)) #@479 Functions to call after output is inserted into the buffer. One possible function is `comint-postoutput-scroll-to-bottom'. These functions get one argument, a string containing the text as originally inserted. Note that this might not be the same as the buffer contents between `comint-last-output-start' and the buffer's `process-mark', if other filter functions have already modified the buffer. See also `comint-preoutput-filter-functions'. This variable is buffer-local. (defvar comint-output-filter-functions '(comint-postoutput-scroll-to-bottom) (#$ . 6617)) #@312 Function to actually send to PROCESS the STRING submitted by user. Usually this is just `comint-simple-send', but if your mode needs to massage the input string, put a different function here. `comint-simple-send' just sends the string plus a newline. This is called from the user command `comint-send-input'. (defvar comint-input-sender 'comint-simple-send (#$ . 7192)) #@89 *Non-nil means go to the end of the line before sending input. See `comint-send-input'. (custom-declare-variable 'comint-eol-on-send 't '(#$ . -7570) :type 'boolean :group 'comint) #@82 Called upon entry into comint-mode This is run before the process is cranked up. (custom-declare-variable 'comint-mode-hook ''nil '(#$ . 7757) :type 'hook :group 'comint) #@330 Called each time a process is exec'd by `comint-exec'. This is called after the process is cranked up. It is useful for things that must be done each time a process is executed in a comint mode buffer (e.g., `(process-kill-without-query)'). In contrast, the `comint-mode-hook' is only executed once when the buffer is created. (custom-declare-variable 'comint-exec-hook ''nil '(#$ . 7935) :type 'hook :group 'comint) (byte-code "\302\300!\204\303\300 B\303\207" [comint-mode-map current-load-list boundp nil] 2) #@126 Non-nil if communications via pty; false if by pipe. Buffer local. This is to work around a bug in Emacs process signaling. (defvar comint-ptyp t (#$ . 8460)) (byte-code "\302\300!\204\303\300 B\304 B\305 B\306 B\303\207" [comint-input-ring current-load-list boundp nil comint-last-input-start comint-last-input-end comint-last-output-start] 2) #@40 Index of last matched history element. (defvar comint-input-ring-index nil (#$ . 8819)) #@47 Input previously used to match input history. (defvar comint-matching-input-from-input-string "" (#$ . 8913)) (byte-code "\302\300!\204\303\300 B\302\207" [comint-save-input-ring-index current-load-list boundp "Last input ring index which you copied.\nThis is to support the command \\[comint-get-next-from-history]."] 2) #@116 Non-nil if you are accumulating input lines to send as input together. The command \[comint-accumulate] sets this. (defvar comint-accum-marker nil (#$ . 9246)) (byte-code "\300\301\302\303#\210\300\304\305\306#\210\300\307\305\306#\210\300\310\305\306#\210\300\303\305\306#\210\300\311\305\306#\210\300\312\305\306#\210\300\313\305\306#\210\300\314\305\306#\210\300\315\305\306#\210\300\316\305\306#\210\300\317\305\306#\210\300\320\321\322#\207" [put comint-replace-by-expanded-history menu-enable comint-input-autoexpand comint-input-ring permanent-local t comint-input-ring-index comint-save-input-ring-index comint-input-filter-functions comint-output-filter-functions comint-preoutput-filter-functions comint-scroll-to-bottom-on-input comint-scroll-to-bottom-on-output comint-scroll-show-maximum-output comint-ptyp comint-mode mode-class special] 4) #@1724 Major mode for interacting with an inferior interpreter. Interpreter name is same as buffer name, sans the asterisks. Return at end of buffer sends line as input. Return not at end copies rest of line to end and sends it. Setting variable `comint-eol-on-send' means jump to the end of the line before submitting new input. This mode is customised to create major modes such as Inferior Lisp mode, Shell mode, etc. This can be done by setting the hooks `comint-input-filter-functions', `comint-input-filter', `comint-input-sender' and `comint-get-old-input' to appropriate functions, and the variable `comint-prompt-regexp' to the appropriate regular expression. An input history is maintained of size `comint-input-ring-size', and can be accessed with the commands \[comint-next-input], \[comint-previous-input], and \[comint-dynamic-list-input-ring]. Input ring history expansion can be achieved with the commands \[comint-replace-by-expanded-history] or \[comint-magic-space]. Input ring expansion is controlled by the variable `comint-input-autoexpand', and addition is controlled by the variable `comint-input-ignoredups'. Commands with no default key bindings include `send-invisible', `comint-dynamic-complete', `comint-dynamic-list-filename-completions', and `comint-magic-space'. Input to, and output from, the subprocess can cause the window to scroll to the end of the buffer. See variables `comint-output-filter-functions', `comint-preoutput-filter-functions', `comint-scroll-to-bottom-on-input', and `comint-scroll-to-bottom-on-output'. If you accidentally suspend your process, use \[comint-continue-subjob] to continue it. \{comint-mode-map} Entry to this mode runs the hooks on `comint-mode-hook'. (defalias 'comint-mode #[nil "\306 \210\307\310\311\312 !\210\313\304!\210\314 \211e\315\223\210\313\305!\210\314 \211e\315\223\210\313\316!\210\314 \313\317!\210\313\320!\210\313\321!\210\313\322!\210\323\321!\203H\204N\324!\313\325!\210\313\326!\210\323\325!\203a\204d\315\323\326!\203o\204r\315\313\327!\210\313\330!\210\313\331!\210\313\332!\210\333\334!\210\313\335!\210\313\336!\210\333\337!\210\313\340!\210\313\341!\210\313\342!\210\313\343!\210\313\344!\210\313\345!\210\313\346!\210\347\346\350\"\210\333\351!\210\313\352!\210\313\353!\210\313\354!\210\313\355!\210\313\356!\210\313\357!\210\314 \211/\315\211\223\210\360\361!\207" [major-mode mode-name mode-line-process comint-mode-map comint-last-input-start comint-last-input-end kill-all-local-variables comint-mode "Comint" (":%s") use-local-map make-local-variable make-marker nil comint-last-output-start comint-prompt-regexp comint-input-ring-size comint-input-ring comint-input-ring-file-name boundp make-ring comint-input-ring-index comint-save-input-ring-index comint-matching-input-from-input-string comint-input-autoexpand comint-input-ignoredups comint-delimiter-argument-list make-local-hook comint-dynamic-complete-functions comint-completion-fignore comint-get-old-input comint-input-filter-functions comint-input-filter comint-input-sender comint-eol-on-send comint-scroll-to-bottom-on-input comint-scroll-to-bottom-on-output comint-scroll-show-maximum-output pre-command-hook add-hook comint-preinput-scroll-to-bottom comint-output-filter-functions comint-ptyp comint-exec-hook comint-process-echoes comint-file-name-chars comint-file-name-quote-list comint-accum-marker run-hooks comint-mode-hook] 4 (#$ . 10109) nil]) (byte-code "\204\334\302 \303\304\305#\210\303\306\307#\210\303\310\305#\210\303\311\307#\210\303\312\313#\210\303\314\315#\210\303\316\317#\210\303\320\321#\210\303\322\323#\210\303\324\325#\210\303\326\327#\210\303\330\331#\210\303\332\333#\210\303\334\335#\210\303\336\337#\210\303\340\341#\210\303\342\343#\210\303\344\345#\210\303\346\347#\210\303\350\351#\210\303\352\353#\210\303\354\323#\210\303\355\356#\210\303\357\360#\210\303\361\362#\210\303\363\364#\210\303\365\366#\210\303\367\370\302\370!B#\210\303\371\372#\210\303\373\374#\210\303\375\376#\210\303\377\201@#\210\303\201A\201B\302\201B!B#\210\303\201C\201D#\210\303\201E\201F#\210\303\201G\201H#\210\303\201I\201J#\210\303\201K\201L#\210\303\201M\201N#\210\303\201O\201P#\210\303\201Q\201R#\210\303\201S\201T#\210\303\201U\201V#\210\303\201W\201X#\210\303\201Y\201Z#\210\303\201[\201\\#\210\303\201]\201^#\210\303\201_\201`#\210\303\201a\201b#\210\303\201c\201d#\210\303\201e\201f\302\201f!B#\210\303\201g\201h#\210\303\201i\201j#\210\303\201k\201l#\210\303\201m\201n#\210\303\201o\201p#\210\303\201q\201r#\210\201s\201t \"\302\207" [comint-mode-map menu-bar-final-items make-sparse-keymap define-key "p" comint-previous-input "n" comint-next-input [C-up] [C-down] "r" comint-previous-matching-input "s" comint-next-matching-input [3 -134217614] comint-previous-matching-input-from-input [3 -134217613] comint-next-matching-input-from-input "\f" comint-show-output " " comint-send-input "" comint-delchar-or-maybe-eof " " comint-accumulate "" comint-get-next-from-history "" comint-bol-or-process-mark "" comint-kill-input "" backward-kill-word "" comint-interrupt-subjob "" comint-stop-subjob "" comint-quit-subjob " " comint-copy-old-input "" comint-kill-output "" "" comint-show-maximum-output "\f" comint-dynamic-list-input-ring "" comint-next-prompt "" comint-previous-prompt "" comint-send-eof [menu-bar completion] "Complete" [menu-bar completion complete-expand] ("Expand File Name" . comint-replace-by-expanded-filename) [menu-bar completion complete-listing] ("File Completion Listing" . comint-dynamic-list-filename-completions) [menu-bar completion complete-file] ("Complete File Name" . comint-dynamic-complete-filename) [menu-bar completion complete] ("Complete Before Point" . comint-dynamic-complete) [menu-bar inout] "In/Out" [menu-bar inout kill-output] ("Kill Current Output Group" . comint-kill-output) [menu-bar inout next-prompt] ("Forward Output Group" . comint-next-prompt) [menu-bar inout previous-prompt] ("Backward Output Group" . comint-previous-prompt) [menu-bar inout show-maximum-output] ("Show Maximum Output" . comint-show-maximum-output) [menu-bar inout show-output] ("Show Current Output Group" . comint-show-output) [menu-bar inout kill-input] ("Kill Current Input" . comint-kill-input) [menu-bar inout copy-input] ("Copy Old Input" . comint-copy-old-input) [menu-bar inout forward-matching-history] ("Forward Matching Input..." . comint-forward-matching-input) [menu-bar inout backward-matching-history] ("Backward Matching Input..." . comint-backward-matching-input) [menu-bar inout next-matching-history] ("Next Matching Input..." . comint-next-matching-input) [menu-bar inout previous-matching-history] ("Previous Matching Input..." . comint-previous-matching-input) [menu-bar inout next-matching-history-from-input] ("Next Matching Current Input" . comint-next-matching-input-from-input) [menu-bar inout previous-matching-history-from-input] ("Previous Matching Current Input" . comint-previous-matching-input-from-input) [menu-bar inout next-history] ("Next Input" . comint-next-input) [menu-bar inout previous-history] ("Previous Input" . comint-previous-input) [menu-bar inout list-history] ("List Input History" . comint-dynamic-list-input-ring) [menu-bar inout expand-history] ("Expand History Before Point" . comint-replace-by-expanded-history) [menu-bar signals] "Signals" [menu-bar signals eof] ("EOF" . comint-send-eof) [menu-bar signals kill] ("KILL" . comint-kill-subjob) [menu-bar signals quit] ("QUIT" . comint-quit-subjob) [menu-bar signals cont] ("CONT" . comint-continue-subjob) [menu-bar signals stop] ("STOP" . comint-stop-subjob) [menu-bar signals break] ("BREAK" . comint-interrupt-subjob) append (completion inout signals)] 6) #@170 Return t if there is a living process associated w/buffer BUFFER. Living means the status is `open', `run', or `stop'. BUFFER can be either a buffer or the name of one. (defalias 'comint-check-proc #[(buffer) "\302!\211\205 \303 !\304>)\207" [buffer proc get-buffer-process process-status (open run stop)] 3 (#$ . 17975)]) #@559 Make a comint process NAME in a buffer, running PROGRAM. The name of the buffer is made by surrounding NAME with `*'s. PROGRAM should be either a string denoting an executable program to create via `start-process', or a cons pair of the form (HOST . SERVICE) denoting a TCP connection to be opened via `open-network-stream'. If there is already a running process in that buffer, it is not restarted. Optional third arg STARTFILE is the name of a file to send the contents of to the process. If PROGRAM is a string, any more args are arguments to PROGRAM. (defalias 'make-comint #[(name program &optional startfile &rest switches) "\305\306!\204\n\307\310!\210\311\312\312Q!\313 !\204'\212 q\210\314 \210)\315 \n \f%\210 )\207" [name buffer program startfile switches fboundp start-process error "Multi-processing is not supported for this system" get-buffer-create "*" comint-check-proc comint-mode comint-exec] 6 (#$ . 18308)]) #@285 Run PROGRAM in a comint buffer and switch to it. The buffer name is made by surrounding the file name of PROGRAM with `*'s. The file name is used to make a symbol name, such as `comint-sh-hook', and any hooks on this symbol are run in the buffer. See `make-comint' and `comint-exec'. (defalias 'comint-run #[(program) "\302!\303\304 \"!\210\305\306\307 \310Q!!)\207" [program name file-name-nondirectory switch-to-buffer make-comint run-hooks intern-soft "comint-" "-hook"] 5 (#$ . 19252) "sRun program: "]) #@265 Start up a process in buffer BUFFER for comint modes. Blasts any old process running in the buffer. Doesn't set the buffer mode. You can use this to cheaply run a series of processes in the same comint buffer. The hook `comint-exec-hook' is run after each exec. (defalias 'comint-exec #[(buffer name command startfile switches) "\212q\210\306!\211\203\307 !\210)\n:\203!\310 \n@\nA$\202'\311 \n\f$\312 \313\"\210\314\315!\210  db\210\316 !`\317\223\210\203^\320\321!\210db\210\322!\210`d{`d|\210\323 \"\210\324\325!\210*\207" [buffer proc command name switches process-connection-type get-buffer-process delete-process open-network-stream comint-exec-1 set-process-filter comint-output-filter make-local-variable comint-ptyp process-mark nil sleep-for 1 insert-file-contents comint-send-string run-hooks comint-exec-hook startfile] 6 (#$ . 19770)]) (defalias 'comint-exec-1 #[(name buffer command switches) "\306\300!\203\203\307\310\311\312\313 \"E\202\314\311\315\313 \"D\316\317!?\205%\320C\244 \244\321\n!\2032\n\2025\322 !\323\211\211\211\324\325 !\"#%\326!\211$@$A)\327\330!!\203o\331\332\"\333\203\200 \204\200\331\334\"\333\f\203\214\335 #\210.\207" [system-uses-terminfo process-environment default-directory directory-sep-char changed encoding boundp "TERM=dumb" "TERMCAP=" format "COLUMNS=%d" frame-width "TERM=emacs" "TERMCAP=emacs:co#%d:tc=unknown:" getenv "EMACS" "EMACS=t" file-accessible-directory-p char-to-string nil apply start-process process-coding-system vectorp coding-system-eol-type coding-system-change-eol-conversion dos t unix set-process-coding-system decoding proc name buffer command switches coding-systems] 7]) #@625 Sets the buffer's `comint-input-ring' from a history file. The name of the file is given by the variable `comint-input-ring-file-name'. The history ring is of size `comint-input-ring-size', regardless of file size. If `comint-input-ring-file-name' is nil this function does nothing. If the optional argument SILENT is non-nil, we say nothing about a failure to read the history file. This function is useful for major mode commands and mode hooks. The structure of the history file should be one input command per line, with the most recent command last. See also `comint-input-ignoredups' and `comint-write-input-ring'. (defalias 'comint-read-input-ring #[(&optional silent) "\203\n\306\232\203\f\307\207\310!\204 \206|\311\312\"\207\313\314!\315\316\n!\317\216\212q\210~\210\320 \210\321 !\210db\210\f\nW\203s\322\323\307\324#\203s\325\224\325\225{\203e\326 !\204e\327 \315\"\230\204k\330 \"\210)\fT\211\202<* \307\211,\207" [comint-input-ring-file-name silent comint-input-ring-size ring count file "" nil file-readable-p message "Cannot read history file %s" get-buffer-create " *temp*" 0 make-ring ((kill-buffer history-buf)) erase-buffer insert-file-contents re-search-backward "^[ ]*\\([^#\n].*\\)[ ]*$" t 1 ring-empty-p ring-ref ring-insert-at-beginning history-buf history comint-input-ignoredups comint-input-ring comint-input-ring-index] 6 (#$ . 21499)]) #@355 Writes the buffer's `comint-input-ring' to a history file. The name of the file is given by the variable `comint-input-ring-file-name'. The original contents of the file are lost if `comint-input-ring' is not empty. If `comint-input-ring-file-name' is nil this function does nothing. Useful within process sentinels. See also `comint-read-input-ring'. (defalias 'comint-write-input-ring #[nil "\203\306\232\204 \203\307 !\203\310\207\311!\204!\312\313\"\207\314\315! \316 !\212\nq\210\317 \210 \320V\203H S\321 \"\322\261\210\2024\323\324 \310\f\310\325%\210\326\310!-\207" [comint-input-ring-file-name comint-input-ring history-buf ring file index "" ring-empty-p nil file-writable-p message "Cannot write history file %s" get-buffer-create " *Temp Input History*" ring-length erase-buffer 0 ring-ref 10 write-region buffer-string no-message kill-buffer] 6 (#$ . 22913)]) #@49 List in help buffer the buffer's input history. (defalias 'comint-dynamic-list-input-ring #[nil "\306!\203\f\307!\203\310\311!\207\312\313\314!S\315 \n\316Y\2030\317\n\"\fB\nS\211\202 \220\320\f!\210 q\210\321y\210\322\323\312\324#\205K\325\326!\210\202<\221\210\327\316!\210\310\330!\210\331 \211\332=\203d\333 !\202i C\211-\207" [comint-input-ring conf index history-buffer history ch ring-p ring-empty-p message "No history" nil " *Input History*" ring-length current-window-configuration 0 ring-ref display-completion-list 3 search-backward "completion" move replace-match "history reference" sit-for "Hit space to flush" read-event 32 set-window-configuration unread-command-events] 6 (#$ . 23817) nil]) (defalias 'comint-regexp-arg #[(prompt) "\305 \306\211\211\303%\211\307\230\203 \211A@\240\202\n\310\f!*D\207" [last-command prompt regexp minibuffer-history-search-history current-prefix-arg read-from-minibuffer nil "" prefix-numeric-value] 7]) (defalias 'comint-search-arg #[(arg) "\303 \204 \304\305!\207\203\306!\203\304\307!\207 \310U\203!\311\312\207 \207" [comint-input-ring arg comint-input-ring-index comint-after-pmark-p error "Not at command line" ring-empty-p "Empty input ring" 0 nil 1] 2]) (defalias 'comint-search-start #[(arg) "\203\303 \304V\203\305\202\306\\\307\n!\"\207 \304Y\203\304\207\307\n!S\207" [comint-input-ring-index arg comint-input-ring mod 0 1 -1 ring-length] 4]) #@97 Return the string ARG places along the input ring. Moves relative to `comint-input-ring-index'. (defalias 'comint-previous-input-string #[(arg) "\303 \203\304\n \\\305!\"\202\n\"\207" [comint-input-ring comint-input-ring-index arg ring-ref mod ring-length] 6 (#$ . 25277)]) #@40 Cycle backwards through input history. (defalias 'comint-previous-input #[(arg) "\301\302\"\207" [arg comint-previous-matching-input "."] 3 (#$ . 25563) "*p"]) #@39 Cycle forwards through input history. (defalias 'comint-next-input #[(arg) "\301[!\207" [arg comint-previous-input] 2 (#$ . 25730) "*p"]) #@113 Return the string matching REGEXP ARG places along the input ring. Moves relative to `comint-input-ring-index'. (defalias 'comint-previous-matching-input-string #[(regexp arg) "\304 \"\211\205 \305 \n\")\207" [regexp arg pos comint-input-ring comint-previous-matching-input-string-position ring-ref] 4 (#$ . 25876)]) #@122 Return the index matching REGEXP ARG places along the input ring. Moves relative to START, or `comint-input-ring-index'. (defalias 'comint-previous-matching-input-string-position #[(regexp arg &optional start) "\306!\203\f\307!\203\310\311!\210\312!\n\313V\203\314\202\315\316\f\206(\317\n! Z \"\320\320\n\313U\204\200\204\200 \316 \\ \" W\203n\204n\321\322 \"\"\204n\316 \\ \"\211U\202H\n\313V\203y\nS\202{\nT\211\2024\321\322 \"\"\205\214 -\207" [comint-input-ring len arg motion start n ring-p ring-empty-p error "No history" ring-length 0 1 -1 mod comint-search-start nil string-match ring-ref tried-each-ring-item prev regexp] 6 (#$ . 26203)]) #@218 Search backwards through input history for match for REGEXP. (Previous history elements are earlier commands.) With prefix argument N, search for Nth previous match. If N is negative, find the next or Nth next match. (defalias 'comint-previous-matching-input #[(regexp arg) "\306!\307 \"\211\204\310\311!\202.\n\312\313\nT\"\210\314\f!\206&\315\316p!!`|\210\317 \n\"c)\207" [arg regexp pos comint-input-ring-index comint-accum-marker comint-input-ring comint-search-arg comint-previous-matching-input-string-position error "Not found" message "History item: %d" marker-position process-mark get-buffer-process ring-ref] 4 (#$ . 26909) (comint-regexp-arg "Previous input matching (regexp): ")]) #@227 Search forwards through input history for match for REGEXP. (Later history elements are more recent commands.) With prefix argument N, search for Nth following match. If N is negative, find the previous or Nth previous match. (defalias 'comint-next-matching-input #[(regexp arg) "\302 [\"\207" [regexp arg comint-previous-matching-input] 3 (#$ . 27619) (comint-regexp-arg "Next input matching (regexp): ")]) #@238 Search backwards through input history for match for current input. (Previous history elements are earlier commands.) With prefix argument N, search for Nth previous match. If N is negative, search forwards for the -Nth following match. (defalias 'comint-previous-matching-input-from-input #[(arg) "\305>\204\306 !\206\307\310p!!`{\311\312\313\314\n!P\f\"\207" [last-command comint-accum-marker comint-matching-input-from-input-string comint-input-ring-index arg (comint-previous-matching-input-from-input comint-next-matching-input-from-input) marker-position process-mark get-buffer-process nil comint-previous-matching-input "^" regexp-quote] 4 (#$ . 28035) "p"]) #@243 Search forwards through input history for match for current input. (Following history elements are more recent commands.) With prefix argument N, search for Nth following match. If N is negative, search backwards for the -Nth previous match. (defalias 'comint-next-matching-input-from-input #[(arg) "\301[!\207" [arg comint-previous-matching-input-from-input] 2 (#$ . 28716) "p"]) #@837 Expand input command history references before point. Expansion is dependent on the value of `comint-input-autoexpand'. This function depends on the buffer's idea of the input history, which may not match the command interpreter's idea, assuming it has one. Assumes history syntax is like typical Un*x shells'. However, since emacs cannot know the interpreter's idea of input line numbers, assuming it has one, it cannot expand absolute input line number references. If the optional argument SILENT is non-nil, never complain even if history reference seems erroneous. If the optional argument START is non-nil, that specifies the start of the text to scan for history references, rather than the logical beginning of line. See `comint-magic-space' and `comint-replace-by-expanded-history-before-point'. Returns t if successful. (defalias 'comint-replace-by-expanded-history #[(&optional silent start) "\205%\306\307 \"\205%\212\310y\210\311\n!)\205%\312 \313\f \"\210 \312 U)?\207" [comint-input-autoexpand comint-get-old-input comint-prompt-regexp previous-modified-tick silent start string-match "!\\|^\\^" 0 looking-at buffer-modified-tick comint-replace-by-expanded-history-before-point] 3 (#$ . 29105) nil]) #@272 Expand directory stack reference before point. See `comint-replace-by-expanded-history'. Returns t if successful. If the optional argument START is non-nil, that specifies the start of the text to scan for history references, rather than the logical beginning of line. (defalias 'comint-replace-by-expanded-history-before-point #[(silent &optional start) "\212\212\306\210`)`Z\206\307\306!\210`\310\212\306\210` Z)w\210`\212\306\210` Z)W\205\203\306h\311U\204;\312`\"\203B`Tb\210\202\313\314!\203S\315\225b\210\316\317!\210\202\313\320!\203\217\321\322\224\322\225{!S\211\323\f!X\203\203\324\325\326 !\327\224\327\225#\330\211#\210 \316\331 T\"\210\202\213\315\225b\210\316\332!\210)\202\313\333!\204\233\313\334!\203\260\324\325\326\315!\322\224\322\225#\330\211#\210\316\335!\210\202\313\336!\2032\322\224\322\225/\327\2240\327\22510\206\313 1\206\322/{2\337 3\340\216\313\341!*\203\346\342\202\347\3434\337 3\344\216\3454\3462!P\322\"*\2115\204\315\225b\2106\204-\316\347!\210\350 \210\202-5\324\325\351\f5\"\352\224\352\225#\330\211#\210\316\3315T\"\210.\202\313\353!\203}\322\224\322\225{\327\224\327\225{\306578\324\326\315!\330\211#\210`5\315\224b\210\35485\330#\204n6\204y\355\347!\210\202y\3247\330\211#\210\316\356!\210+\202\322u\210\202+\207" [start toend comint-input-ring-index number comint-input-ring mb1 nil comint-bol "^!^" 92 comint-within-quotes looking-at "![0-9]+\\($\\|[^-]\\)" 0 message "Absolute reference cannot be expanded" "!-\\([0-9]+\\)\\(:?[0-9^$*-]+\\)?" string-to-number 1 ring-length replace-match comint-args comint-previous-input-string 2 t "History item: %d" "Relative reference exceeds input history size" "!!?:?\\([0-9^$*-]+\\)" "!!" "History item: previous" "!\\??\\({\\(.+\\)}\\|\\(\\sw+\\)\\)\\(:?[0-9^$*-]+\\)?" match-data ((set-match-data save-match-data-internal)) "!\\?" "" "^" ((set-match-data save-match-data-internal)) comint-previous-matching-input-string-position regexp-quote "Not found" ding ring-ref 4 "\\^\\([^^]+\\)\\^?\\([^^]*\\)\\^?" search-forward error "History item: substituted" me1 mb2 me2 exp save-match-data-internal pref pos silent new old] 6 (#$ . 30339)]) #@145 Expand input history references before point and insert ARG spaces. A useful command to bind to SPC. See `comint-replace-by-expanded-history'. (defalias 'comint-magic-space #[(arg) "\301 \210\302!\207" [arg comint-replace-by-expanded-history self-insert-command] 2 (#$ . 32547) "p"]) #@92 Return t if the number of quotes between BEG and END is odd. Quotes are single and double. (defalias 'comint-within-quotes #[(beg end) "\304\305 #\304\306 #\307 \310\"\311U\206\307\n\310\"\311U*\207" [beg end countdq countsq comint-how-many-region "\\(^\\|[^\\\\]\\)'" "\\(^\\|[^\\\\]\\)\"" mod 2 1] 5 (#$ . 32839)]) #@54 Return number of matches for REGEXP from BEG to END. (defalias 'comint-how-many-region #[(regexp beg end) "\305\212\306 \307\216\nb\210\310 \f\311#\203T\202 +)\207" [count save-match-data-internal beg regexp end 0 match-data ((set-match-data save-match-data-internal)) re-search-forward t] 4 (#$ . 33168)]) (defalias 'comint-args #[(string begin end) "\306 \307\216 \204\310\n\311\312#\202k f\313=\203 T\202 {\314\315\f\"\203,\316\202D\314\317\f\"\2037\311\202D\f\320\230\203A\312\202D\321\f!\314\322\f\"\203P\312\202b\314\323\f\"\203a\321\f\311\225\312O!\202b \310\n #+*\207" [save-match-data-internal begin string end range nth match-data ((set-match-data save-match-data-internal)) comint-arguments 0 nil 58 string-match "^[*^]" 1 "^-" "$" string-to-number "[-*$]$" "-" mth] 4]) (defalias 'comint-delim-arg #[(arg) "\204 C\207\306\307 G \nW\203W H \211>\2037 \nW\203L H=\203L T\211\202\" \nW\203L H>\204L T\211\2028 O\fB*\202\f+\207" [comint-delimiter-argument-list arg len pos args start nil 0 char] 4]) #@360 Return from STRING the NTH to MTH arguments. NTH and/or MTH can be nil, which means the last argument. Returned arguments are separated by single spaces. We assume whitespace separates arguments, except within quotes. Also, a run of one or more of a single character in `comint-delimiter-argument-list' is a separate argument. Argument 0 is the command name. (defalias 'comint-arguments #[(string nth mth) "\306\307\310\211\307\211\211\211\203\fX\203l\311 #\203l \203@ \310\224U\203@\310\225\206<\312\224\202 \203` O\203U\nB\202[\313\n!\244\fT\312\224\310\224\310\225\202 \203\214 O\203\201\nB\202\207\313\n!\244\fT\206\223\fS\203\240\fZS\202\241\310\314\315\233\237\233\316#.\n\207" [quotes value str beg count pos "[^ \n \"'`\\]+\\|\\\\[\"'`\\]+\\|\\(\"\\([^\"\\]\\|\\\\.\\)*\"\\|'[^']*'\\|`[^`]*`\\)" nil 0 string-match 1 comint-delim-arg mapconcat #[(a) "\207" [a] 1] " " args argpart mth string nth m n] 8 (#$ . 34247)]) #@1887 Send input to process. After the process output mark, sends all text from the process mark to point as input to the process. Before the process output mark, calls value of variable `comint-get-old-input' to retrieve old input, copies it to the process mark, and sends it. If variable `comint-process-echoes' is nil, a terminal newline is also inserted into the buffer and sent to the process (if it is non-nil, all text from the process mark to point is deleted, since it is assumed the remote process will re-echo it). Any history reference may be expanded depending on the value of the variable `comint-input-autoexpand'. The list of function names contained in the value of `comint-input-filter-functions' is called on the input before sending it. The input is entered into the input history ring, if the value of variable `comint-input-filter' returns non-nil when called on the input. If variable `comint-eol-on-send' is non-nil, then point is moved to the end of line before sending the input. The values of `comint-get-old-input', `comint-input-filter-functions', and `comint-input-filter' are chosen according to the command interpreter running in the buffer. E.g., If the interpreter is the csh, comint-get-old-input is the default: take the current line, discard any initial string matching regexp comint-prompt-regexp. comint-input-filter-functions monitors input for "cd", "pushd", and "popd" commands. When it sees one, it cd's the buffer. comint-input-filter is the default: returns t if the input isn't all white space. If the comint is Lucid Common Lisp, comint-get-old-input snarfs the sexp ending at point. comint-input-filter-functions does nothing. comint-input-filter returns nil if the input matches input-filter-regexp, which matches (1) all whitespace (2) :a, :c, etc. Similarly for Soar, Scheme, etc. (defalias 'comint-send-input #[nil "\306p!\211\204\307\310!\202\336\311!`\312 !Y\203'\n\203!\313\210 `{\2022  b\210\fc\210\f)\314=\204> \202F\315\316 \"\210 `{\f\317=\204T\f\202k\315\316 \"\210 `{`\fc\210 |\210\f*\203y `|\210\202}\320\321!\210!\203\252 \203\243\322!!\203\243\323!!\204\243\324!\325\"\230\204\252\326!\"\210\327\330\f\331P\"\210\"#\313\"$ \313\223\210%`\313\223\210\311!`\313\223\210&\313\211\223\210'\f\"\210\327\332\333\",)\207" [proc pmark comint-eol-on-send comint-get-old-input copy intxt get-buffer-process error "Current buffer has no process" process-mark marker-position nil input comint-replace-by-expanded-history t history insert-before-markers 10 ring-p ring-empty-p ring-ref 0 ring-insert run-hook-with-args comint-input-filter-functions "\n" comint-output-filter-functions "" comint-input-autoexpand start comint-process-echoes comint-input-filter comint-input-ignoredups comint-input-ring comint-input-ring-index comint-save-input-ring-index comint-last-input-start comint-last-input-end comint-accum-marker comint-input-sender] 5 (#$ . 35266) nil]) #@223 Functions to call before output is inserted into the buffer. These functions get one argument, a string containing the text to be inserted. They return the string as it should be inserted. This variable is buffer-local. (defvar comint-preoutput-filter-functions nil (#$ . 38305)) (defalias 'comint-output-filter #[(process string) "\306!\n\211\203\f\203 @\f! A\211\204\n)\f\205\320 \205\320\307 !\205\320p\310\211\211 q\210`ed\310\fG\310~\210\311!b\210``X\203a\\`W\203o\\` X\203z \\\312\f!\210\313\314 !`U\203\220\315\314 `\fGZ\"\210\203\254\316!\203\254`U\203\254\211Z\310\223\210\310\223\210\311!`\310\223\210\317 \210+ }\210b\210\320\321\f\"\210q,)\207" [process oprocbuf comint-preoutput-filter-functions functions string oend process-buffer buffer-name nil process-mark insert-before-markers window-start selected-window set-window-start marker-buffer force-mode-line-update run-hook-with-args comint-output-filter-functions obeg opoint obuf ostart nchars buffer-read-only comint-last-input-end comint-last-output-start] 5]) #@386 Go to the end of buffer in all windows showing it. Movement occurs if point in the selected window is not after the process mark, and `this-command' is an insertion command. Insertion commands recognised are `self-insert-command', `comint-magic-space', `yank', and `hilit-yank'. Depends on the value of `comint-scroll-to-bottom-on-input'. This function should be a pre-command hook. (defalias 'comint-preinput-scroll-to-bottom #[nil "\2052 \306>\2052\307 p\310 !\f\2051`\311\f!W\2051 \312=\203,db\2021\313\314\315\316#,\207" [comint-scroll-to-bottom-on-input this-command selected current process scroll (self-insert-command comint-magic-space yank hilit-yank) selected-window get-buffer-process process-mark this walk-windows #[(window) "\304! =\205\n\305=\204\n\306=\205\307!\210db\210\307 !\207" [window current scroll selected window-buffer t all select-window] 2] nil t] 4 (#$ . 39425)]) #@292 Go to the end of buffer in all windows showing it. Does not scroll if the current line is the last line in the buffer. Depends on the value of `comint-scroll-to-bottom-on-output' and `comint-scroll-show-maximum-output'. This function should be in the list `comint-output-filter-functions'. (defalias 'comint-postoutput-scroll-to-bottom #[(string) "\305 p\306 ! \307\216\n\205\310\311\312\313#-\207" [selected current process comint-scroll-to-bottom-on-output scroll selected-window get-buffer-process ((set-buffer current)) walk-windows #[(window) "\306! =\205b\307!\210`\310\n!W\203I \311=\204D \312=\204D \313=\203,\f=\204D \314=\2038\f=\203D\315 !\203I` Y\203I\310\n!b\210\203_`\310\n!Y\203_\212db\210\316\317!\210)\307\f!\207" [window current process scroll selected comint-last-output-start window-buffer select-window process-mark t all this others marker-position recenter -1 comint-scroll-show-maximum-output] 3] nil t] 4 (#$ . 40347)]) #@132 Truncate the buffer to `comint-buffer-maximum-size'. This function could be on `comint-output-filter-functions' or bound to a key. (defalias 'comint-truncate-buffer #[(&optional string) "\212\301\302p!!b\210[y\210\303y\210e`|)\207" [comint-buffer-maximum-size process-mark get-buffer-process 0] 3 (#$ . 41324) nil]) #@141 Strip trailing `^M' characters from the current output group. This function could be on `comint-output-filter-functions' or bound to a key. (defalias 'comint-strip-ctrl-m #[(&optional string) "\301\302p!!\212\303\304\305\217\210\306\307\310#\205\311\312\310\211#\210\202\f*\207" [pmark process-mark get-buffer-process nil (byte-code "t\203\202 b\207" [comint-last-input-end comint-last-output-start] 1) ((error)) re-search-forward " +$" t replace-match ""] 4 (#$ . 41648) nil]) (defalias 'shell-strip-ctrl-m 'comint-strip-ctrl-m) #@56 Put the end of the buffer at the bottom of the window. (defalias 'comint-show-maximum-output #[nil "db\210\300\301!\207" [recenter -1] 2 (#$ . 42194) nil]) #@122 Default for `comint-get-old-input'. Take the current line, and discard any initial text matching `comint-prompt-regexp'. (defalias 'comint-get-old-input-default #[nil "\212\301y\210\302 \210`\303\210`{*\207" [beg 0 comint-skip-prompt nil] 2 (#$ . 42357)]) #@114 Insert after prompt old input at point as new input to be edited. Calls `comint-get-old-input' to get old input. (defalias 'comint-copy-old-input #[nil " \303p! \204\304\305!\202\306 !b\210\nc*\207" [comint-get-old-input process input get-buffer-process error "Current buffer has no process" process-mark] 3 (#$ . 42623) nil]) #@130 Skip past the text matching regexp `comint-prompt-regexp'. If this takes us past the end of the current line, don't skip at all. (defalias 'comint-skip-prompt #[nil "\212\302\210`)\303 !\205\304\225X\205\304\225b)\207" [eol comint-prompt-regexp nil looking-at 0] 2 (#$ . 42964)]) #@55 Return t if point is after the process output marker. (defalias 'comint-after-pmark-p #[nil "\301\302p!!\303!`X)\207" [pmark process-mark get-buffer-process marker-position] 3 (#$ . 43257)]) #@145 Default function for sending to PROC input STRING. This just sends STRING plus a newline. To override this, set the hook `comint-input-sender'. (defalias 'comint-simple-send #[(proc string) "\302 \"\210\302\303\"\207" [proc string comint-send-string "\n"] 3 (#$ . 43457)]) #@271 Goes to the beginning of line, then skips past the prompt, if any. If prefix argument is given (\[universal-argument]) the prompt is not skipped. The prompt skip is done by skipping text matching the regular expression `comint-prompt-regexp', a buffer local variable. (defalias 'comint-bol #[(arg) "\301y\210?\205\n\302 \207" [arg 0 comint-skip-prompt] 1 (#$ . 43739) "P"]) #@673 Read a single line of text from user without echoing, and return it. Prompt with argument PROMPT, a string. Optional argument STARS causes input to be echoed with '*' characters on the prompt line. Input ends with RET, LFD, or ESC. DEL or C-h rubs out. C-u kills line. C-g aborts (if `inhibit-quit' is set because e.g. this function was called from a process filter and C-g is pressed, this function returns nil rather than a string). Note that the keystrokes comprising the text can still be recovered (temporarily) with \[view-lossage]. Some people find this worrysome. Once the caller uses the password, it can erase the password by doing (fillarray STRING 0). (defalias 'comint-read-noecho #[(prompt &optional stars) "\306\307\310\211\311\307\211\204\242\203'\312\313\314G\315\"#\210\202-\312\316\"\210\317 \211\320U\203?\311\311\211\202\f\321U\204Q\f\322U\204Q\f\323U\203W\311\211\202\f\324U\203i\325\310\"\210\306\202\f\326U\204\210\f\327U\204\210\330\f!P\325\310\"\210 \202G\310V\203\211GS\310I\210\310\331O\202\203\266\307\211\312\332!\210\333\311!\210\202\274\312\306!\210.\207" [done message-log-max cursor-in-echo-area echo-keystrokes c newans "" nil 0 t message "%s%s" make-string 42 "%s" read-char-exclusive 7 13 10 27 21 fillarray 8 127 char-to-string -1 "Quit" beep ans stars prompt quit-flag] 8 (#$ . 44124)]) #@222 Read a string without echoing. Then send it to the process running in the current buffer. The string is sent using `comint-input-sender'. Security bug: your string can still be temporarily recovered with \[view-lossage]. (defalias 'send-invisible #[(str) "\303p!\211\204\304\305!\202. ;\203\n \"\202.\306\307\310\"\211;\203*\311 !\202-\312\313!))\207" [proc str comint-input-sender get-buffer-process error "Current buffer has no process" comint-read-noecho "Non-echoed text: " t send-invisible message "Warning: text will be echoed"] 4 (#$ . 45537) "P"]) #@305 Prompt in the minibuffer for password and send without echoing. This function uses `send-invisible' to read and send a password to the buffer's process if STRING contains a password prompt defined by `comint-password-prompt-regexp'. This function could be in the list `comint-output-filter-functions'. (defalias 'comint-watch-for-password-prompt #[(string) "\302 \"\205\n\303\304!\207" [comint-password-prompt-regexp string string-match send-invisible nil] 3 (#$ . 46111)]) (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias comint-send-string process-send-string comint-send-region process-send-region] 3) #@80 Kill all output from interpreter since last input. Does not delete the prompt. (defalias 'comint-kill-output #[nil "\304p!\305\212\306 !b\210\307y\210\310  \n|\210\306 !b\210\311\n`{P\n`|\210*\312 \"*\207" [replacement proc pmark comint-last-input-end get-buffer-process nil process-mark 0 point-marker "*** output flushed ***\n" comint-output-filter] 3 (#$ . 46737) nil]) #@127 Display start of this batch of interpreter output at top of window. Sets mark to the value of point when this command is run. (defalias 'comint-show-output #[nil "\302 \210`\303 !\206\fdb\210\304y\210\305\306 `\"\210\307 )\207" [pos comint-last-input-end push-mark marker-position -1 set-window-start selected-window comint-skip-prompt] 3 (#$ . 47122) nil]) #@109 Interrupt the current subjob. This command also kills the pending input between the process-mark and point. (defalias 'comint-interrupt-subjob #[nil "\301 \210\302\303\"\207" [comint-ptyp comint-kill-input interrupt-process nil] 3 (#$ . 47489) nil]) #@119 Send kill signal to the current subjob. This command also kills the pending input between the process-mark and point. (defalias 'comint-kill-subjob #[nil "\301 \210\302\303\"\207" [comint-ptyp comint-kill-input kill-process nil] 3 (#$ . 47747) nil]) #@119 Send quit signal to the current subjob. This command also kills the pending input between the process-mark and point. (defalias 'comint-quit-subjob #[nil "\301 \210\302\303\"\207" [comint-ptyp comint-kill-input quit-process nil] 3 (#$ . 48005) nil]) #@371 Stop the current subjob. This command also kills the pending input between the process-mark and point. WARNING: if there is no current subjob, you can end up suspending the top-level process running in the buffer. If you accidentally do this, use \[comint-continue-subjob] to resume the process. (This is not a problem with most shells, since they ignore this signal.) (defalias 'comint-stop-subjob #[nil "\301 \210\302\303\"\207" [comint-ptyp comint-kill-input stop-process nil] 3 (#$ . 48263) nil]) #@111 Send CONT signal to process buffer's process group. Useful if you accidentally suspend the top-level process. (defalias 'comint-continue-subjob #[nil "\301\302\"\207" [comint-ptyp continue-process nil] 3 (#$ . 48773) nil]) #@63 Kill all text from last stuff output by interpreter to point. (defalias 'comint-kill-input #[nil "\301\302p!!`\303!V\205\304`\")\207" [pmark process-mark get-buffer-process marker-position kill-region] 3 (#$ . 49003) nil]) #@139 Delete ARG characters forward or send an EOF to subprocess. Sends an EOF only if point is at the end of the buffer and there is no input. (defalias 'comint-delchar-or-maybe-eof #[(arg) "\302p!m\203\203`\303\304!!U\203\305 \202\306 !)\207" [proc arg get-buffer-process marker-position process-mark process-send-eof delete-char] 4 (#$ . 49238) "p"]) #@46 Send an EOF to the current buffer's process. (defalias 'comint-send-eof #[nil "\300 \207" [process-send-eof] 1 (#$ . 49603) nil]) #@229 Search backward through buffer for match for REGEXP. Matches are searched for on lines that match `comint-prompt-regexp'. With prefix argument N, search for Nth previous match. If N is negative, find the next or Nth next match. (defalias 'comint-backward-matching-input #[(regexp arg) "\305 Q\212 \306V\203\306\202\307\210\310\n\311\312 $\205`)\211\204,\313\314!\210\315 \2022\fb\210\316\311!*\207" [comint-prompt-regexp regexp re arg pos ".*" 0 1 re-search-backward nil t message "Not found" ding comint-bol] 6 (#$ . 49740) (comint-regexp-arg "Backward input matching (regexp): ")]) #@237 Search forward through buffer for match for REGEXP. Matches are searched for on lines that match `comint-prompt-regexp'. With prefix argument N, search for Nth following match. If N is negative, find the previous or Nth previous match. (defalias 'comint-forward-matching-input #[(regexp arg) "\302 [\"\207" [regexp arg comint-backward-matching-input] 3 (#$ . 50343) (comint-regexp-arg "Forward input matching (regexp): ")]) #@75 Move to end of Nth next prompt in the buffer. See `comint-prompt-regexp'. (defalias 'comint-next-prompt #[(n) "\n\303V\203\f\304\202 \303\210\305\n!\210\306 )\207" [comint-prompt-regexp paragraph-start n 0 1 forward-paragraph comint-skip-prompt] 2 (#$ . 50774) "p"]) #@79 Move to end of Nth previous prompt in the buffer. See `comint-prompt-regexp'. (defalias 'comint-previous-prompt #[(n) "\301[!\207" [n comint-next-prompt] 2 (#$ . 51052) "p"]) (defalias 'comint-source-default #[(previous-dir/file source-modes) "\203 \n>\203\305!\306!B\207 \206\f\307B\207" [buffer-file-name major-mode source-modes previous-dir/file default-directory file-name-directory file-name-nondirectory nil] 3]) (defalias 'comint-check-source #[(fname) "\303!\211\205$\304 !\205$\305\306\307\310 !\"!\205$p q\210\311 \210\nq))\207" [fname buff old-buffer get-file-buffer buffer-modified-p y-or-n-p format "Save buffer %s first? " buffer-name save-buffer] 6]) #@66 Return string around POINT that starts the current line, or nil. (defalias 'comint-extract-string #[nil "\212`\305y\210`\306\210`b\210\307\310 \311#\205`Tb\210\312\310\n\311#\205(`S \2054\f\2054 \f{.\207" [point bol eol start end 0 nil search-backward "\"" t search-forward] 4 (#$ . 51740)]) (defalias 'comint-get-source #[(prompt prev-dir/file source-modes mustmatch-p) "\306 \"\307 \211\205\310\311\312\217\205\313 !?\211\203\"\314 !\202$\n@\f\203/\315 !\2021\nA\316\203C\317\320#\202E \211P$\321\322!!.C\207" [prev-dir/file source-modes def stringfile sfile-p defdir comint-source-default comint-extract-string nil (file-exists-p stringfile) ((error)) file-directory-p file-name-directory file-name-nondirectory read-file-name format "%s(default %s) " expand-file-name substitute-in-file-name deffile prompt mustmatch-p ans] 6]) (defalias 'comint-proc-query #[(proc str) "\306!\307!\310 !\210 q\210\311 !\312\n!\313 \"\210\314!\210\315 \f\"?\205K\316\f!\317\f\n\"\210\320\321!\210\315\f\"\204E\322!\202J\317\f\"),\207" [proc proc-buf proc-mark proc-pt proc-win str process-buffer process-mark display-buffer get-buffer-window marker-position comint-send-string accept-process-output pos-visible-in-window-p window-point set-window-point sit-for 0 push-mark opoint] 3]) #@114 *If non-nil, automatically list possibilities on partial completion. This mirrors the optional behavior of tcsh. (custom-declare-variable 'comint-completion-autolist 'nil '(#$ . -53086) :type 'boolean :group 'comint-completion) #@264 *If non-nil, add a `/' to completed directories, ` ' to file names. If a cons pair, it should be of the form (DIRSUFFIX . FILESUFFIX) where DIRSUFFIX and FILESUFFIX are strings added on unambiguous or exact completion. This mirrors the optional behavior of tcsh. (custom-declare-variable 'comint-completion-addsuffix 't '(#$ . -53321) :type 'boolean :group 'comint-completion) #@188 *If non-nil, use shortest completion if characters cannot be added. This mirrors the optional behavior of tcsh. A non-nil value is useful if `comint-completion-autolist' is non-nil too. (custom-declare-variable 'comint-completion-recexact 'nil '(#$ . -53705) :type 'boolean :group 'comint-completion) #@182 *List of suffixes to be disregarded during file completion. This mirrors the optional behavior of bash and tcsh. Note that this applies to `comint-dynamic-complete-filename' only. (custom-declare-variable 'comint-completion-fignore 'nil '(#$ . -54014) :type '(repeat (string :tag "Suffix")) :group 'comint-completion) #@171 Prefix prepended to absolute file names taken from process input. This is used by comint's and shell's completion functions, and by shell's directory tracking functions. (defvar comint-file-name-prefix "" (#$ . 54340)) #@198 String of characters valid in a file name. Note that all non-ASCII characters are considered valid in a file name regardless of what this variable says. This is a good thing to set in mode hooks. (defvar comint-file-name-chars (byte-code "\301>\203\302\207\303\207" [system-type (ms-dos windows-nt) "~/A-Za-z0-9_^$!#%&{}@`'.,:()-" "~/A-Za-z0-9+@:_.$#%,={}-"] 2) (#$ . 54566)) #@102 List of characters to quote with `' when in a file name. This is a good thing to set in mode hooks. (defvar comint-file-name-quote-list nil (#$ . 54953)) (defalias 'comint-directory #[(directory) "\302\303!\203 P\202!\207" [directory comint-file-name-prefix expand-file-name file-name-absolute-p] 3]) #@222 Return the word of WORD-CHARS at point, or nil if non is found. Word constituents are considered to be those in WORD-CHARS, which is like the inside of a "[...]" (see `skip-chars-forward'), plus all non-ASCII characters. (defalias 'comint-word #[(word-chars) "\212\303\304Q`\305\n\306\307#\203#g\310Y\204h\311=\203#\312\313!\210\202o\203-\314\n!\2030\313u\210` W\205?\315` D!\210\316\317!+\207" [word-chars here non-word-chars "[^\\\\" "]" re-search-backward nil move 128 92 backward-char 1 looking-at set-match-data match-string 0] 4 (#$ . 55269)]) #@179 Return FILENAME with environment variables substituted. Supports additional environment variable syntax of the command interpreter (e.g., the percent notation of cmd.exe on NT). (defalias 'comint-substitute-in-file-name #[(filename) "\306!\n\307>\203:\310\211\311 \312\216\313\314 \"\2039 \315\224\315\225O\316\f!\203-\316\f!\202.\317\320 \310\211 $\202, )\207" [filename name system-type env-var-val env-var-name save-match-data-internal substitute-in-file-name (ms-dos windows-nt) nil match-data ((set-match-data save-match-data-internal)) string-match "%\\([^\\\\/]*\\)%" 1 getenv "" replace-match] 5 (#$ . 55838)]) #@114 Return the filename at point, or nil if non is found. Environment variables are substituted. See `comint-word'. (defalias 'comint-match-partial-filename #[nil "\302!\211\205 \303\304 !!)\207" [comint-file-name-chars filename comint-word comint-substitute-in-file-name comint-unquote-filename] 4 (#$ . 56478)]) #@108 Return FILENAME with magic characters quoted. Magic characters are those in `comint-file-name-quote-list'. (defalias 'comint-quote-filename #[(filename) "\204 \207\304\305\306\307\310#\"\311 \312\216\313\n \"\203%\314\315\316\211 $\202 +\207" [comint-file-name-quote-list filename regexp save-match-data-internal format "\\(^\\|[^\\]\\)\\([%s]\\)" mapconcat char-to-string "" match-data ((set-match-data save-match-data-internal)) string-match replace-match "\\1\\\\\\2" nil] 6 (#$ . 56799)]) #@50 Return FILENAME with quoted characters unquoted. (defalias 'comint-unquote-filename #[(filename) "\204 \207\304 \305\216\306\307\310 #\203#\311\312\313\211 $\306\224T\202 ) *\207" [comint-file-name-quote-list filename save-match-data-internal i match-data ((set-match-data save-match-data-internal)) 0 string-match "\\\\\\(.\\)" replace-match "\\1" nil] 5 (#$ . 57308)]) #@212 Dynamically perform completion at point. Calls the functions in `comint-dynamic-complete-functions' to perform completion until a function returns non-nil, at which point completion is assumed to have occurred. (defalias 'comint-dynamic-complete #[nil "\300\301!\207" [run-hook-with-args-until-success comint-dynamic-complete-functions] 2 (#$ . 57696) nil]) #@705 Dynamically complete the filename at point. Completes if after a filename. See `comint-match-partial-filename' and `comint-dynamic-complete-as-filename'. This function is similar to `comint-replace-by-expanded-filename', except that it won't change parts of the filename already entered in the buffer; it just adds completion characters to the end of the filename. A completions listing may be shown in a help buffer if completion is ambiguous. Completion is dependent on the value of `comint-completion-addsuffix', `comint-completion-recexact' and `comint-completion-fignore', and the timing of completions listing is dependent on the value of `comint-completion-autolist'. Returns t if successful. (defalias 'comint-dynamic-complete-filename #[nil "\300 \205\301\302 !\204\303\304!\210\305 \207" [comint-match-partial-filename window-minibuffer-p selected-window message "Completing file name..." comint-dynamic-complete-as-filename] 2 (#$ . 58061) nil]) #@112 Dynamically complete at point as a filename. See `comint-dynamic-complete-filename'. Returns t if successful. (defalias 'comint-dynamic-complete-as-filename #[nil "\306>\n\307\310 !\311\204\312\202&:\204#\313 !\202&@!\2041\312\202>:\204;\314\202>A\"\315 \206F\312#\316#!$\317#!%$\203`\320$!\202b&'\321%'\"\211(\204{\322\323#\"\210\324\202)(\311=\203\221\"c\210\f\204)\322\325!\210\202)(\312\230\203\236\326 \210\202)\327'!(P)\330\331(!%G\324O!c\210\321('\"9\203\331\332)!\203\312!\202\314\"c\210\f\204(\322\333!\210\202(*\203 \203 %(\230\203 \334)!\203 \332)!\203\376!\202\"c\210\f\204(\322\335!\210\202(+\204%(\230\203 \326 \210\202(\f\204(\322\336!\210) . \207" [system-type completion-ignore-case comint-completion-fignore completion-ignored-extensions minibuffer-p success (ms-dos windows-nt) window-minibuffer-p selected-window t "" char-to-string " " comint-match-partial-filename file-name-directory file-name-nondirectory comint-directory file-name-completion message "No completions of %s" nil "Sole completion" comint-dynamic-list-filename-completions file-name-as-directory comint-quote-filename directory-file-name file-directory-p "Completed" file-exists-p "Completed shortest" "Partially completed" comint-completion-addsuffix directory-sep-char dirsuffix filesuffix filename pathdir pathnondir default-directory directory completion file comint-completion-recexact comint-completion-autolist] 5 (#$ . 59033)]) #@477 Dynamically expand and complete the filename at point. Replace the filename with an expanded, canonicalised and completed replacement. "Expanded" means environment variables (e.g., $HOME) and `~'s are replaced with the corresponding directories. "Canonicalised" means `..' and `.' are removed, and the filename is made absolute instead of relative. For expansion see `expand-file-name' and `substitute-in-file-name'. For completion see `comint-dynamic-complete-filename'. (defalias 'comint-replace-by-expanded-filename #[nil "\300\301\302 !\303\211#\210\304 \207" [replace-match expand-file-name comint-match-partial-filename t comint-dynamic-complete-filename] 4 (#$ . 60563) nil]) #@592 Dynamically complete STUB from CANDIDATES list. This function inserts completion characters at point by completing STUB from the strings in CANDIDATES. A completions listing may be shown in a help buffer if completion is ambiguous. Returns nil if no completion was inserted. Returns `sole' if completed with the only completion match. Returns `shortest' if completed with the shortest of the completion matches. Returns `partial' if completed as far as possible with the completion matches. Returns `listed' if a completion listing was shown. See also `comint-dynamic-complete-filename'. (defalias 'comint-dynamic-simple-complete #[(stub candidates) "\306>\n\204\f\307\202\n:\204\310\202\nA\311\312\f\"\313 \f\"\211\2040\314\315 \"\210\316\202\251G\317U\203^@\211 \230\203J\314\320!\210\202V G\316Oc\210\314\321!\210 c\210)\322\202\251\323 \f\"\211 G\316Oc\210\203\216\n\203\216 \230\203\216\235\203\216 c\210\314\324!\210\325\202\250\204\232 \230\203\243\326!\210\327\202\250\314\330!\210\331),\207" [system-type completion-ignore-case comint-completion-addsuffix suffix candidates stub (ms-dos windows-nt) "" " " mapcar #[(x) "C\207" [x] 1] all-completions message "No completions of %s" nil 1 "Sole completion" "Completed" sole try-completion "Completed shortest" shortest comint-dynamic-list-completions listed "Partially completed" partial completions completion comint-completion-recexact comint-completion-autolist] 4 (#$ . 61257)]) #@68 List in help buffer possible completions of the filename at point. (defalias 'comint-dynamic-list-filename-completions #[nil "\306>\307 \206\n\310\311\n!\312\n! \203\313 !\202 \314\f\"\211\2042\315\316\n\"\2029\317\320\321\"!.\207" [system-type completion-ignore-case filename pathdir pathnondir default-directory (ms-dos windows-nt) comint-match-partial-filename "" file-name-directory file-name-nondirectory comint-directory file-name-all-completions message "No completions of %s" comint-dynamic-list-completions mapcar comint-quote-filename directory completions] 5 (#$ . 62758) nil]) #@77 List in help buffer sorted COMPLETIONS. Typing SPC flushes the help buffer. (defalias 'comint-dynamic-list-completions #[(completions) "\306 \307\220\310\311 \312\"!\221\210\313\314!\210\315\211\212\316\307!q\210\317\315!\211\320H\211:\205J\n\211A@):\205J\321\n\211A@)\211@)!\316\307!=\205J\322 !\323=)\203X\323\n!\210\324!\202j\n\325=\203d\324!\202j\326 !\211+\207" [conf completions first key event position current-window-configuration "*Completions*" display-completion-list sort string-lessp message "Hit space to flush" nil get-buffer read-key-sequence 0 window-buffer key-binding mouse-choose-completion set-window-configuration 32 listify-key-sequence unread-command-events] 6 (#$ . 63374)]) #@208 After fetching a line from input history, this fetches the following line. In other words, this recalls the input line after the line you recalled last. You can use this to repeat a sequence of input lines. (defalias 'comint-get-next-from-history #[nil "\203 T\302\303!\207\304\305!\207" [comint-save-input-ring-index comint-input-ring-index comint-next-input 1 message "No previous history command"] 2 (#$ . 64100) nil]) #@301 Accumulate a line to send as input along with more lines. This inserts a newline so that you can enter more text to be sent along with this line. Use \[comint-send-input] to send all the accumulated input, at once. The entire accumulated text becomes one item in the input history when you send it. (defalias 'comint-accumulate #[nil "\303c\210`\304\223\210 \205 S\211\207" [comint-accum-marker comint-input-ring-index comint-save-input-ring-index "\n" nil] 3 (#$ . 64533) nil]) #@131 Move point to the process mark. The process mark separates output, and input already sent, from input that has not yet been sent. (defalias 'comint-goto-process-mark #[nil "\301p!\206 \302\303!\304!b\210\305\306!)\207" [proc get-buffer-process error "Current buffer has no process" process-mark message "Point is now at the process mark"] 2 (#$ . 65024) nil]) #@581 Move point beginning of line (after prompt) or to the process mark. The first time you use this command, it moves to the beginning of the line (but after the prompt, if any). If you repeat it again immediately, it moves point to the process mark. The process mark separates the process output, along with input already sent, from input that has not yet been sent. Ordinarily, the process mark is at the beginning of the current input line; but if you have used \[comint-accumulate] to send multiple lines at once, the process mark is at the beginning of the accumulated input. (defalias 'comint-bol-or-process-mark #[nil "\301=\204\n\302\303!\207\304 \207" [last-command comint-bol-or-process-mark comint-bol nil comint-goto-process-mark] 2 (#$ . 65394) nil]) #@32 Set the process mark at point. (defalias 'comint-set-process-mark #[nil "\301p!\206 \302\303!\304!`\305\223\210\306\307!)\207" [proc get-buffer-process error "Current buffer has no process" process-mark nil message "Process mark set"] 3 (#$ . 66165) nil]) (provide 'comint)