;ELC ;;; compiled by jwz@thalidomide on Sun May 15 00:43:16 1994 ;;; from file /th/jwz/emacs19/lisp/comint/comint.el ;;; emacs version 19.10 Lucid (beta23). ;;; 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.")) (byte-code "!" ["2.03" comint-version require ring] 2) (defvar comint-prompt-regexp "^" "\ Regexp to recognise prompts in the inferior process. Defaults to \"^\", the null string at BOL. Good choices: Canonical Lisp: \"^[^> ]*>+:? *\" (Lucid, franz, kcl, T, cscheme, oaklisp) Lucid Common Lisp: \"^\\\\(>\\\\|\\\\(->\\\\)+\\\\) *\" franz: \"^\\\\(->\\\\|<[0-9]*>:\\\\) *\" kcl: \"^>+ *\" shell: \"^[^#$%>]*[#$%>] *\" T: \"^>+ *\" The pattern should begin with \"^\". It can match text on more than one line. This pattern gets handed to re-search-backward, not looking-at. This is a good thing to set in mode hooks.") (defvar comint-delimiter-argument-list nil "\ 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. Good choices: shell: (\"|\" \"&\" \"<\" \">\" \"(\" \")\" \";\") This is a good thing to set in mode hooks.") (defvar comint-input-autoexpand nil "\ *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.") (defvar comint-input-ignoredups t "\ *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.") (defvar comint-input-ring-file-name nil "\ *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.") (defvar comint-scroll-to-bottom-on-input nil "\ *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.") (defvar comint-scroll-to-bottom-on-output nil "\ *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.") (defvar comint-scroll-show-maximum-output nil "\ *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.") (defvar comint-input-ring-size 32 "\ Size of input history ring.") (defvar comint-process-echoes nil "\ *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.") (defvar comint-get-old-input 'comint-get-old-input-default "\ 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-append-old-input nil "\ *If nil, old text selected by \\[comint-send-input] is re-sent immediately. If non-nil, the old text is appended to the end of the buffer, and a prompting message is printed. This flag does not affect the behavior of \\[comint-send-input] after the process output mark.") (defvar comint-after-partial-filename-command 'comint-after-partial-filename "\ Function that returns non-nil if point is after a file name. By default this is `comint-after-partial-filename'. This is a good thing to set in mode hooks.") (defvar comint-dynamic-complete-filename-command 'comint-dynamic-complete-filename "\ Function that dynamically completes the file name at point. By default this is `comint-dynamic-complete-filename', though an alternative is `comint-replace-by-expanded-filename'. This is a good thing to set in mode hooks.") (defvar comint-dynamic-complete-command-command 'comint-dynamic-complete-filename "\ Function that dynamically completes the command at point. By default this is `comint-dynamic-complete-filename'. This is a good thing to set in mode hooks.") (defvar comint-get-current-command 'comint-get-old-input-default "\ Function that returns the current command including arguments. By default this is `comint-get-old-input-default', meaning the whole line. This is a good thing to set in mode hooks.") (defvar comint-input-sentinel 'ignore "\ Called on each input submitted to comint mode process by `comint-send-input'. Thus it can, for instance, track cd/pushd/popd commands issued to a shell.") (defvar comint-input-filter #[(str) "\n\"?\nGV" [string-match "\\`\\s *\\'" str 2] 3] "\ Predicate for filtering additions to input history. Only inputs answering true to this function are saved on the input history list. Default is to save anything longer than two characters that isn't all whitespace.") (defvar comint-output-filter-functions '(comint-postoutput-scroll-to-bottom) "\ 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 just inserted. This variable is buffer-local.") (defvar comint-input-sender 'comint-simple-send "\ 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-eol-on-send t "\ *Non-nil means go to the end of the line before sending input. See `comint-send-input'.") (defvar comint-mode-hook nil "\ Called upon entry into comint-mode This is run before the process is cranked up.") (defvar comint-exec-hook nil "\ 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.") (byte-code "!‡" [boundp comint-mode-map nil] 2) (defvar comint-ptyp t "\ Non-nil if communications via pty; false if by pipe. Buffer local. This is to work around a bug in Emacs process signalling.") (byte-code "!‡" [boundp comint-input-ring nil] 2) (defvar comint-input-ring-index nil "\ Index of last matched history element.") (defvar comint-matching-input-from-input-string "" "\ Input previously used to match input history.") (byte-code "########" [put comint-input-ring permanent-local t comint-input-ring-index comint-input-autoexpand comint-output-filter-functions comint-scroll-to-bottom-on-input comint-scroll-to-bottom-on-output comint-scroll-show-maximum-output comint-ptyp] 4) (fset 'comint-mode #[nil " !! \n!  !  !!!!!!!!!!!!!!!!!!!!!!!!!\"!!!!!" [kill-all-local-variables comint-mode major-mode "Comint" mode-name (": %s") mode-line-process use-local-map comint-mode-map make-local-variable comint-last-input-start make-marker comint-last-input-end 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 nil comint-matching-input-from-input-string comint-input-autoexpand comint-input-ignoredups comint-delimiter-argument-list comint-after-partial-filename-command comint-dynamic-complete-filename-command comint-dynamic-complete-command-command comint-get-current-command comint-get-old-input comint-input-sentinel 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 run-hooks comint-mode-hook] 3 "\ 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-sentinel', `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-list-dynamic-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-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'." nil]) (byte-code " \"####################-" [comint-mode-map make-sparse-keymap set-keymap-name define-key "p" comint-previous-matching-input-from-input "n" comint-next-matching-input-from-input "r" comint-previous-matching-input "s" comint-next-matching-input " " comint-send-input "" comint-bol "" comint-kill-input "" backward-kill-word "" comint-interrupt-subjob "" comint-stop-subjob "" comint-quit-subjob " " comint-copy-old-input "" comint-kill-output "" comint-show-output "" comint-show-maximum-output "" comint-dynamic-list-input-ring "" comint-next-prompt "" comint-previous-prompt "" comint-send-eof button3 comint-popup-menu ("Command Interpreter Commands" ["Kill Command Output" comint-kill-output t] ["Goto Next Prompt" comint-next-prompt t] ["Goto Previous Prompt" comint-previous-prompt t] ["Kill Input" comint-kill-input t] "----" ["Previous Input" comint-previous-matching-input-from-input t] ["Next Input" comint-next-matching-input-from-input t] ["Previous Input matching Regexp..." 'comint-previous-matching-input t] ["Next Input matching Regexp..." 'comint-next-matching-input t] ["List Command History" comint-dynamic-list-input-ring t] "----" ["Send STOP Signal" comint-stop-subjob t] ["Send CONT Signal" comint-continue-subjob t] ["Send INT Signal" comint-interrupt-subjob t] ["Send EOF Signal" comint-send-eof t] ["Send KILL Signal" comint-kill-subjob t] ["Send QUIT Signal" comint-quit-subjob t]) comint-menu] 4) (fset 'comint-popup-menu #[(event) "  BD\" !)" [comint-make-history-menu history popup-menu append comint-menu "---" "Command History"] 6 "\ Display the comint-mode menu." "@e"]) (fset 'comint-check-proc #[(buffer) " !\n!>)" [get-buffer-process buffer proc process-status (run stop)] 3 "\ Return t if there is a living process associated w/buffer BUFFER. Living means the status is `run' or `stop'. BUFFER can be either a buffer or the name of one."]) (fset 'make-comint #[(name program &optional startfile &rest switches) "\nQ! ! q ) \n % )" [get-buffer-create "*" name buffer comint-check-proc comint-mode comint-exec program startfile switches] 6 "\ Make a comint process NAME in a buffer, running PROGRAM. The name of the buffer is made by surrounding NAME with `*'s. 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. Any more args are arguments to PROGRAM."]) (byte-code "\"\"" [define-function make-shell make-comint make-obsolete] 3) (fset 'comint-exec #[(buffer name command startfile switches) "q!\n!) $\n\"!  db\n!`Γ!db!`d{`d|\n\"!*" [buffer get-buffer-process proc delete-process comint-exec-1 name command switches set-process-filter comint-output-filter make-local-variable comint-ptyp process-connection-type process-mark nil startfile sleep-for 1 insert-file-contents comint-send-string run-hooks comint-exec-hook] 6 "\ 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."]) (fset 'comint-exec-1 #[(name buffer command switches) " \"E  \n %)" ["EMACS=t" "TERM=emacs" format "TERMCAP=emacs:co#%d:tc=unknown" screen-width process-environment apply start-process name buffer command switches] 6]) (fset 'comint-read-input-ring #[nil "!\"!!  !q~eb#ΔΕ{!\"\")T) !**" [comint-input-ring-file-name nil file-readable-p message "Cannot read history file %s" get-file-buffer make-ring comint-input-ring-size ring history-buf find-file-noselect re-search-forward "^\\s *\\([^#].*\\)\\s *$" t 1 history comint-input-ignoredups ring-empty-p ring-ref 0 ring-insert kill-buffer comint-input-ring comint-input-ring-index] 4 "\ 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. Useful within mode or mode hooks. The structure of the history file should be one input command per line, and most recent command last. See also `comint-input-ignoredups' and `comint-write-input-ring'."]) (fset 'comint-write-input-ring #[nil "\n\n!ć!\"!\n\n   !\nq VS \"ұi  %!-" [comint-input-ring-file-name "" comint-input-ring ring-empty-p nil file-writable-p message "Cannot write history file %s" get-buffer-create " *Temp Input History*" history-buf ring file ring-length index erase-buffer 0 ring-ref 10 write-region buffer-string no-message kill-buffer] 6 "\ 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'."]) (fset 'comint-restore-window-config #[(conf &optional message) " =\n\"!!   !=̪  )  =̪ C)!" [selected-window minibuffer-window message "%s" "Press space to flush" sit-for 0 fboundp next-command-event ch event-to-character 32 t unread-command-event nil read-event unread-command-events set-window-configuration conf] 4]) (fset 'comint-dynamic-list-input-ring #[nil " ! !! !S  \n  \nY \n\" B \nS\nj  ! qy#!s !," [ring-p comint-input-ring ring-empty-p message "No history" nil " *Input History*" ring-length current-window-configuration conf index history-buffer history 0 ring-ref display-completion-list 3 search-backward "completion" move replace-match "history reference" comint-restore-window-config] 6 "\ List in help buffer the buffer's input history." nil]) (defvar comint-history-menu-max 40 "\ *Maximum number of entries to display on the Comint command-history menu.") (byte-code "MMMMM" [comint-make-history-menu #[nil " !? !?É !S Y\n\nW \"D# B TSO ," [ring-p comint-input-ring ring-empty-p nil ring-length 0 count index hist menu comint-history-menu-max ring-ref vector comint-menu-history t] 5] comint-menu-history #[(string) "dbp!!`|\nc" [process-mark get-buffer-process string] 3] comint-regexp-arg #[(prompt) "\n %ǘ A@ !+D" [nil minibuffer-history-sexp-flag last-command read-from-minibuffer prompt minibuffer-history-search-history regexp "" prefix-numeric-value current-prefix-arg] 7] comint-search-arg #[(arg) " ! !!U ʇ" [comint-after-pmark-p error "Not at command line" comint-input-ring ring-empty-p "Empty input ring" arg 0 nil comint-input-ring-index 1] 2] comint-search-start #[(arg) "\nVĪ\\!\"\nYÇ!S" [comint-input-ring-index mod arg 0 1 -1 ring-length comint-input-ring] 4]] 2) (fset 'comint-previous-input-string #[(arg) " \n \n\\ !\" \"" [ring-ref comint-input-ring comint-input-ring-index mod arg ring-length] 6 "\ Return the string ARG places along the input ring. Moves relative to `comint-input-ring-index'."]) (fset 'comint-previous-input #[(arg) "\n\"" [comint-previous-matching-input "." arg] 3 "\ Cycle backwards through input history." "*p"]) (fset 'comint-next-input #[(arg) " [!" [comint-previous-input arg] 2 "\ Cycle forwards through input history." "*p"]) (fset 'comint-previous-matching-input-string #[(regexp arg) " \n\" \")" [comint-previous-matching-input-string-position regexp arg pos ring-ref comint-input-ring] 4 "\ Return the string matching REGEXP ARG places along the input ring. Moves relative to `comint-input-ring-index'."]) (fset 'comint-previous-matching-input-string-position #[(regexp arg &optional start) " ! !! !Vɪ  ! Z\"U \\\"W \"\" \\\"UWVST- \"\"-" [ring-p comint-input-ring ring-empty-p error "No history" ring-length len arg 0 1 -1 motion mod start comint-search-start n nil tried-each-ring-item prev string-match regexp ring-ref] 6 "\ Return the index matching REGEXP ARG places along the input ring. Moves relative to START, or `comint-input-ring-index'."]) (fset 'comint-previous-matching-input #[(regexp arg) " ! \"!  T\"p!!`| \"c)" [comint-search-arg arg comint-previous-matching-input-string-position regexp pos error "Not found" comint-input-ring-index message "History item: %d" process-mark get-buffer-process ring-ref comint-input-ring] 4 "\ 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." (comint-regexp-arg "Previous input matching (regexp): ")]) (fset 'comint-next-matching-input #[(regexp arg) " \n[\"" [comint-previous-matching-input regexp arg] 3 "\ 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." (comint-regexp-arg "Next input matching (regexp): ")]) (fset 'comint-previous-matching-input-from-input #[(arg) ">p!!`{ !P\n\"" [last-command (comint-previous-matching-input-from-input comint-next-matching-input-from-input) process-mark get-buffer-process comint-matching-input-from-input-string nil comint-input-ring-index comint-previous-matching-input "^" regexp-quote arg] 4 "\ 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, find the next or Nth next match." "p"]) (fset 'comint-next-matching-input-from-input #[(arg) " [!" [comint-previous-matching-input-from-input arg] 2 "\ Search forwards 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, find the next or Nth next match." "p"]) (fset 'comint-replace-by-expanded-history #[nil "`)`Z!`Ŋ` Z)#bȔbhU\n`\"ȕbY!ȕb!J!єѕ{!S!X!ؔؕ#Ɖ#T\"ȕb!) !!!єѕ#Ɖ#!єѕؔ ؕ! !{\" $!*突) $)\"!P\"*-!ȕb --T\"-\"#Ɖ#.!єѕ{ؔؕ{-34!Ɖ#`-Ȕb4-#3Ɖ#! +ȕb+" [nil comint-bol start toend re-search-forward "[!^]" t comint-input-ring-index 0 92 comint-within-quotes looking-at "![0-9]+\\($\\|[^-]\\)" message "Absolute reference cannot be expanded" "!-\\([0-9]+\\)\\(:?[0-9^$*-]+\\)?" string-to-number 1 number ring-length comint-input-ring replace-match comint-args comint-previous-input-string 2 "History item: %d" "Relative reference exceeds input history size" "!!?:?\\([0-9^$*-]+\\)" "!!" "!\\??\\({\\(.+\\)}\\|\\(\\sw+\\)\\)\\(:?[0-9^$*-]+\\)?" mb1 me1 mb2 me2 exp match-data _match_data_ ((store-match-data _match_data_)) "!\\?" "" "^" pref ((store-match-data _match_data_)) comint-previous-matching-input-string-position regexp-quote pos "Not found" ding ring-ref 4 "\\^\\([^^]+\\)\\^?\\([^^]*\\)\\^?" new old search-forward] 6 "\ Expand input command history references before point. 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. See also `comint-magic-space'." nil]) (fset 'comint-magic-space #[(arg) " \n!" [comint-replace-by-expanded-history self-insert-command arg] 2 "\ Expand input history references before point and insert ARG spaces. A useful command to bind to SPC. See `comint-replace-by-expanded-history'." "p"]) (fset 'comint-within-quotes #[(beg end) "\n #\n #\"U \"U*" [comint-how-many-region "\\(^\\|[^\\\\]\\)'" beg end "\\(^\\|[^\\\\]\\)\"" countdq countsq mod 2 1] 5 "\ Return t if the number of quotes between BEG and END is odd. Quotes are single and double."]) (fset 'comint-how-many-region #[(regexp beg end) " Ď b# Tr+ )" [0 count match-data _match_data_ ((store-match-data _match_data_)) beg re-search-forward regexp end t] 4 "\ Return number of matches for REGEXP from BEG to END."]) (byte-code "MM" [comint-args #[(string begin end) " Ž # f= T  {\n\n\"ͪ\n\"ƪ\nϘǪ\n!\n\"Ǫ\n\"\nƕO! #+*" [match-data _match_data_ ((store-match-data _match_data_)) begin comint-arguments string 0 nil 58 end range string-match "^[*^]" 1 "^-" "$" string-to-number nth "[-*$]$" "-" mth] 4] comint-delim-arg #[(arg) " \" C#\"#R# #= #=Ε ΔOBW," [comint-delimiter-argument-list string-match "[\"'`]" arg format "\\([^%s]" mapconcat #[(d) " !" [regexp-quote d] 2] "" "\\|" #[(d) "\n!P" ["\\\\" regexp-quote d] 3] "\\)+" #[(d) " !P" [regexp-quote d "+"] 2] nil 0 pos args delim-str not-delim] 6]] 2) (fset 'comint-arguments #[(string nth mth) " #•” O ! e\n GS G ZS    #." ["\\(\\S \\|\\(\"[^\"]*\"\\|'[^']*'\\|`[^`]*`\\)\\)+" nil 0 str pos args arg string-match string comint-delim-arg nth mth m n mapconcat (lambda (a) a) " "] 5 "\ 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. Arguments are assumed to be delimited by whitespace. Strings comprising characters in the variable `comint-delimiter-argument-list' are treated as delimiters and arguments. Argument 0 is the command name."]) (fset 'comint-send-input #[nil "p!! ! ! `Y\n `{  bd b c )= `{==# `{ `|c #)  b!! `|c!!!\"\"\"!# \"$% ȓ&`ȓ !`ȓ'((@P!(A(o).)" [get-buffer-process proc error "Current buffer has no process" process-mark pmark marker-position pmark-val nil append-here comint-eol-on-send comint-get-old-input copy push-mark comint-append-old-input intxt comint-input-autoexpand input comint-replace-by-expanded-history history comint-arguments 0 message substitute-command-keys "(\\[comint-send-input] to confirm)" comint-process-echoes 10 comint-input-filter comint-input-ignoredups ring-p comint-input-ring ring-empty-p ring-ref ring-insert comint-input-sentinel comint-input-sender comint-input-ring-index comint-last-input-start comint-last-input-end comint-output-filter-functions functions "\n"] 5 "\ 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 value of variable `comint-input-sentinel' 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. If variable `comint-append-old-input' is non-nil, then the results of calling `comint-get-old-input' are appended to the end of the buffer. The new input will combine with any partially-typed text already present after the process output mark. Point is moved just before the newly appended input, and a message is displayed prompting the user to type \\[comint-send-input] again. `comint-get-old-input', `comint-input-sentinel', 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-sentinel 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-sentinel 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." nil]) (byte-code "M!" [comint-output-filter #[(process string) " !\n!pĉ\nq`ed G\n  ~ !b`\n`X \\`W \\` X  \\ ! !`U ` GZ\"!`U Zē\nē !`ē + }b@ !Aq)q,)" [process-buffer process oprocbuf buffer-name nil oend obeg opoint obuf string ostart nchars buffer-read-only process-mark insert-before-markers window-start selected-window set-window-start comint-last-input-end marker-buffer comint-last-output-start force-mode-line-update comint-output-filter-functions functions] 5] boundp comint-scroll-to-bottom-on-input-commands (self-insert-command yank mouse-yank-at-click hilit-yank)] 2) (fset 'comint-preinput-scroll-to-bottom #[nil " \n> p !`!W !?#," [comint-scroll-to-bottom-on-input this-command comint-scroll-to-bottom-on-input-commands selected-window selected current get-buffer-process process scroll process-mark window-minibuffer-p walk-windows #[(window) " !\n= = = = = d\"" [window-buffer window current scroll t all this selected set-window-point] 3] not-minibuf t] 4 "\ 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 those in `comint-scroll-to-bottom-on-input-commands'. Depends on the value of `comint-scroll-to-bottom-on-input'. This function should be a pre-command hook."]) (fset 'comint-postoutput-scroll-to-bottom #[(string) " p\n!  #," [selected-window selected current get-buffer-process process comint-scroll-to-bottom-on-output scroll walk-windows #[(window) " !\n= ! !W===\n ==\n = ! ! GZY !\" ! !Yd \"? d\" )" [window-buffer window current window-point process-mark process scroll t all this selected others string set-window-point comint-scroll-show-maximum-output pos-visible-in-window-p recenter] 4] nil t] 4 "\ 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'."]) (fset 'comint-show-maximum-output #[nil "db!" [recenter -1] 2 "\ Put the end of the buffer at the bottom of the window." nil]) (fset 'comint-get-old-input-default #[nil "y `\n`{*" [0 comint-skip-prompt beg nil] 2 "\ Default for `comint-get-old-input'. Take the current line, and discard any initial text matching `comint-prompt-regexp'."]) (fset 'comint-copy-old-input #[nil " p!\n!\n!b c*" [comint-get-old-input get-buffer-process process input error "Current buffer has no process" process-mark] 3 "\ Insert after prompt old input at point as new input to be edited. Calls `comint-get-old-input' to get old input." nil]) (fset 'comint-skip-prompt #[nil "`)y`) b \n#)ǔ`XǕ`VǕ XǕb*" [nil -10 search-limit eol re-search-backward comint-prompt-regexp t 0] 4 "\ 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."]) (fset 'comint-after-pmark-p #[nil "p!!\n!`X)" [process-mark get-buffer-process pmark marker-position] 3 "\ Return t if point is after the process output marker."]) (fset 'comint-simple-send #[(proc string) " \n\" \"" [comint-send-string proc string "\n"] 3 "\ Default function for sending to PROC input STRING. This just sends STRING plus a newline. To override this, set the hook `comint-input-sender'."]) (fset 'comint-bol #[(arg) "y ? " [0 arg comint-skip-prompt] 1 "\ 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. If you don't like this command, bind C-a to `beginning-of-line' in your hook, `comint-mode-hook'." "_P"]) (fset 'comint-read-noecho #[(prompt &optional stars) " !" [read-passwd prompt] 2 "\ Read a password from the user. See documentation of `read-passwd' for more info."]) (fset 'send-invisible #[(str) "p!! ; \"\" \")" [get-buffer-process proc error "Current buffer has no process" comint-send-string str comint-read-noecho "Non-echoed text: " t "\n"] 6 "\ Read a string without echoing. Then send it to the process running in the current buffer. A new-line is additionally sent. String is not saved on comint input history list. Security bug: your string can still be temporarily recovered with \\[view-lossage]." "P"]) (defvar comint-input-chunk-size 512 "\ *Long inputs are sent to comint processes in chunks of this size. If your process is choking on big inputs, try lowering the value.") (fset 'comint-send-string #[(proc str) "G\n^  O\" W \n\\ !  ^O\")^*" [str len comint-input-chunk-size i process-send-string proc 0 next-i accept-process-output sit-for] 7 "\ Send PROCESS the contents of STRING as input. This is equivalent to `process-send-string', except that long input strings are broken up into chunks of size `comint-input-chunk-size'. Processes are given a chance to output between chunks. This can help prevent processes from hanging when you send them long inputs on some OS's."]) (fset 'comint-send-region #[(proc start end) " \n {\"" [comint-send-string proc start end] 4 "\ Sends to PROC the region delimited by START and END. This is a replacement for `process-send-region' that tries to keep your process from hanging on long inputs. See `comint-send-string'."]) (fset 'comint-kill-output #[nil "p!!by  \"c `ɓ)" [process-mark get-buffer-process 0 point-marker pmark kill-region comint-last-input-end "*** output flushed ***\n" comint-skip-prompt nil] 3 "\ Kill all output from interpreter since last input. Does not delete the prompt." nil]) (fset 'comint-show-output #[nil "` by `\"!b )" [pos comint-last-input-end -1 set-window-start selected-window pos-visible-in-window-p comint-skip-prompt] 3 "\ Display start of this batch of interpreter output at top of window. Also put cursor there if the current position is not visible." nil]) (fset 'comint-interrupt-subjob #[nil "\n\"" [interrupt-process nil comint-ptyp] 3 "\ Interrupt the current subjob." nil]) (fset 'comint-kill-subjob #[nil "\n\"" [kill-process nil comint-ptyp] 3 "\ Send kill signal to the current subjob." nil]) (fset 'comint-quit-subjob #[nil "\n\"" [quit-process nil comint-ptyp] 3 "\ Send quit signal to the current subjob." nil]) (fset 'comint-stop-subjob #[nil "\n\"" [stop-process nil comint-ptyp] 3 "\ Stop the current subjob. 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.)" nil]) (fset 'comint-continue-subjob #[nil "\n\"" [continue-process nil comint-ptyp] 3 "\ Send CONT signal to process buffer's process group. Useful if you accidentally suspend the top-level process." nil]) (fset 'comint-kill-input #[nil "p!!`\n!V\n`\")" [process-mark get-buffer-process pmark marker-position kill-region] 3 "\ Kill all text from last stuff output by interpreter to point." nil]) (fset 'comint-delchar-or-maybe-eof #[(arg) "m \n!" [process-send-eof delete-char arg] 2 "\ Delete ARG characters forward, or (if at eob) send an EOF to subprocess." "p"]) (fset 'comint-send-eof #[nil " " [process-send-eof] 1 "\ Send an EOF to the current buffer's process." nil]) (fset 'comint-backward-matching-input #[(regexp arg) "\nQ VŪ $`)\n! \nb!*" [comint-prompt-regexp ".*" regexp re arg 0 1 re-search-backward nil t pos message "Not found" ding comint-bol] 6 "\ 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." (comint-regexp-arg "Backward input matching (regexp): ")]) (fset 'comint-forward-matching-input #[(regexp arg) " \n[\"" [comint-backward-matching-input regexp arg] 3 "\ 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." (comint-regexp-arg "Forward input matching (regexp): ")]) (fset 'comint-next-prompt #[(n) "\nVĪ\n! )" [comint-prompt-regexp paragraph-start n 0 1 forward-paragraph comint-skip-prompt] 2 "\ Move to end of Nth next prompt in the buffer. See `comint-prompt-regexp'." "_p"]) (fset 'comint-previous-prompt #[(n) " [!" [comint-next-prompt n] 2 "\ Move to end of Nth previous prompt in the buffer. See `comint-prompt-regexp'." "_p"]) (byte-code "MM" [comint-source-default #[(previous-dir/file source-modes) " \n>!!B B" [buffer-file-name major-mode source-modes file-name-directory file-name-nondirectory previous-dir/file default-directory nil] 3] comint-check-source #[(fname) " !\n!\n!\"!p\nq q))" [get-file-buffer fname buff buffer-modified-p y-or-n-p format "Save buffer %s first? " buffer-name old-buffer save-buffer] 6]] 2) (fset 'comint-extract-string #[nil "`y``b\n#`Tb #`S\n\n\n{." [point 0 bol nil eol search-backward "\"" t start search-forward end] 4 "\ Return string around POINT that starts the current line, or nil."]) (byte-code "MM" [comint-get-source #[(prompt prev-dir/file source-modes mustmatch-p) " \n\" ȏ !?\n ! @ \n ! A# P$!!.C" [comint-source-default prev-dir/file source-modes def comint-extract-string stringfile nil (file-exists-p stringfile) ((error)) file-directory-p sfile-p file-name-directory defdir file-name-nondirectory deffile read-file-name format "%s(default %s) " prompt mustmatch-p ans expand-file-name substitute-in-file-name] 6] comint-proc-query #[(proc str) " ! !\n!\nq\n! !  \" ! \"? ! \"! \"! \")," [process-buffer proc proc-buf process-mark proc-mark display-buffer get-buffer-window marker-position proc-pt proc-win comint-send-string str accept-process-output pos-visible-in-window-p window-point opoint set-window-point sit-for 0 push-mark] 3]] 2) (defvar comint-completion-autolist nil "\ *If non-nil, automatically list possiblities on partial completion. This mirrors the optional behavior of tcsh.") (defvar comint-completion-addsuffix t "\ *If non-nil, add a `/' to completed directories, ` ' to file names. This mirrors the optional behavior of tcsh.") (defvar comint-completion-recexact nil "\ *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.") (defvar comint-file-name-prefix "" "\ 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.") (fset 'comint-directory #[(directory) "\n! \nP\n!" [expand-file-name file-name-absolute-p directory comint-file-name-prefix] 3]) (fset 'comint-match-partial-filename #[nil "#u!!!̔̕{!)" [re-search-backward "[^~/A-Za-z0-9+@:_.$#,={}-]" nil move 1 looking-at "[~/A-Za-z0-9+@:_.$#,={}-]" error "No filename to complete" re-search-forward "[~/A-Za-z0-9+@:_.$#,={}-]+" substitute-in-file-name 0] 4 "\ Return the filename at point, or signal an error. Environment variables are substituted."]) (fset 'comint-match-partial-variable #[nil "#u!!!˔˕{)" [re-search-backward "[^A-Za-z0-9_${}]" nil move 1 looking-at "\\$" error "" re-search-forward "\\${?[A-Za-z0-9_]+}?" 0] 4 "\ Return the variable at point, or signal an error."]) (fset 'comint-after-partial-filename #[nil "  Ď \"*ǔ!`)=?)" [comint-match-partial-filename filename match-data _match_data_ ((store-match-data _match_data_)) string-match "/" 0 comint-bol nil] 3 "\ Returns t if point is after a file name. File names are assumed to contain `/'s or not be the first item in the input. See also `comint-bol'."]) (fset 'comint-dynamic-complete #[nil " \n \" U   )" [buffer-modified-tick previous-modified-tick comint-input-autoexpand string-match "[!^]" comint-get-current-command comint-replace-by-expanded-history comint-after-partial-filename-command comint-dynamic-complete-filename-command comint-dynamic-complete-command-command] 3 "\ Dynamically complete/expand the command/filename/history at point. If the text contains (a non-absolute line reference) `!' or `^' and `comint-input-autoexpand' is non-nil, then an attempt is made to complete the history. The value of the variable `comint-after-partial-filename-command' is used to match file names. Otherwise, an attempt is made to complete the command. See also the variables `comint-after-partial-filename-command', `comint-dynamic-complete-filename-command', and `comint-dynamic-complete-command-command', and functions `comint-replace-by-expanded-history' and `comint-magic-space'." nil]) (fset 'comint-dynamic-complete-filename #[nil "  ! ! ! \n\n\" =  \"  =c! ט \n! Pەb !GOc \n\"9!ުc !!ުc!\" !)." [nil completion-ignore-case comint-match-partial-filename filename file-name-directory pathdir file-name-nondirectory pathnondir comint-directory default-directory directory file-name-completion completion selected-window minibuffer-window no-message message "No completions of %s" ding t comint-completion-addsuffix " " "Sole completion" "" comint-dynamic-list-filename-completions file-name-as-directory file 0 directory-file-name file-directory-p "/" comint-completion-recexact file-exists-p "Completed shortest" comint-completion-autolist "Partially completed"] 3 "\ Dynamically complete the filename at point. 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' and `comint-completion-recexact', and the timing of completions listing is dependent on the value of `comint-completion-autolist'." nil]) (fset 'comint-replace-by-expanded-filename #[nil " !É# " [replace-match expand-file-name comint-match-partial-filename t comint-dynamic-complete-filename] 4 "\ 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'." nil]) (fset 'comint-dynamic-complete-variable #[nil "  \"O \"Ȫ \"ʪ \"\"\" GU@!!GOc! c!ުc)\"!GOc! !ު߱!#!!)." [nil completion-ignore-case comint-match-partial-variable variable string-match "[^$({]" varname "{" "}" "(" ")" "" protection mapcar #[(x) "\"OC" [x 0 string-match "="] 5] process-environment variables #[(var) " P!!!" [file-directory-p comint-directory substitute-in-file-name "$" var] 5] var-directory-p all-completions completions message "No completions of %s" ding 1 completion "Sole completion" directory-file-name "Completed" comint-completion-addsuffix "/" " " try-completion comint-completion-recexact "Completed shortest" comint-completion-autolist comint-dynamic-list-completions "Partially completed"] 5 "\ Dynamically complete the environment variable at point. This function is similar to `comint-dynamic-complete-filename', except that it searches `process-environment' for completion candidates. Note that this may not be the same as the interpreter's idea of variable names. The main problem with this type of completion is that `process-environment' is the environment which Emacs started with. Emacs does not track changes to the environment made by the interpreter. Perhaps it would be more accurate if this function was called `comint-dynamic-complete-process-environment-variable'. See also `comint-dynamic-complete-filename'." nil]) (fset 'comint-dynamic-simple-complete #[(stub candidates) " \" \"\" GU@ ! GOc!c) \" GOc  c! !!)+" [nil completion-ignore-case mapcar #[(x) "C" [x] 1] candidates all-completions stub completions message "No completions of %s" ding 1 completion "Sole completion" "Completed" comint-completion-addsuffix " " try-completion comint-completion-recexact "Completed shortest" comint-completion-autolist comint-dynamic-list-completions "Partially completed"] 4 "\ 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. See also `comint-dynamic-complete-filename'."]) (fset 'comint-dynamic-list-filename-completions #[nil "  ! ! ! \n\n\"  ! \" ." [nil completion-ignore-case comint-match-partial-filename filename file-name-directory pathdir file-name-nondirectory pathnondir comint-directory default-directory directory file-name-all-completions completions comint-dynamic-list-completions message "No completions of %s" ding] 4 "\ List in help buffer possible completions of the filename at point." nil]) (fset 'comint-dynamic-list-completions #[(completions) "  \"! !)" [current-window-configuration conf " *Completions*" display-completion-list sort completions string-lessp comint-restore-window-config] 5 "\ List in help buffer sorted COMPLETIONS. Typing SPC flushes the help buffer."]) (byte-code " \"\"" [lookup-key global-map "" global-set-key comint-find-source-code] 3) (defconst comint-source-location-patterns '(("\\(^\\|[ ]\\)\\([^ \n]+\\): *\\([0-9]+\\):[ ]*\\(.*\\)" (grep cpp) (2 3 4)) ("#\\(line\\)? *\\([0-9]+\\) *\"\\([^\"\n]+\\)\"" cpp (3 2)) ("\"\\([^\"\n]+\\)\", line +\\([0-9]+\\)\\(:[ ]+\\(.*\\)\\)?" cc (1 2 4)) ("line +\\([0-9]+\\) +of +\\([^ \n]+\\)\\(:[ ]+\\(.*\\)\\)?" f77 (2 1 4)) ("\\(^\\(.*\\)[ ]+at \\)?line +\\([0-9]+\\) +[in of file]+ +\"\\([^\"\n]+\\)\"" dbx (4 3 2)) ("\"\\([^\"\n]+\\)\":\\([0-9]+\\)" dbx (1 2)) ("\"\\([^\"\n]+\\):\\([0-9]+\\)\"" centerline (1 2)) (": *\\([^ \n)]+\\) *(\\([0-9]+\\))" lint (1 2)) ("\\(^\\|[ ]\\)\\([^ \n)]+\\) *(\\([0-9]+\\)) *:" lint (2 3)) ("( +\\([^ \n)]+\\) *(\\([0-9]+\\)) +)" lint (1 2)) ("[\"`']\\([^\"`'\n]+\\)[\"`'], line +\\([0-9]+\\)" troff (1 2)) ("\"\\([^\"\n]+\\)\" *\\([0-9]+\\):" ri (1 2)) ("[Ff]ile +\\([^ \n]+\\), line +\\([0-9]+\\)" mod (1 2)) ("\\(^\\|[ ]\\)\\([^ \n)]+\\) *\\[\\([0-9]+\\)\\] *:[ ]+\\(.*\\)" ksh (2 3 4)) ("\\(^\\|[ ]\\)\\([^ \n:]+\\):[ ]+\\(.*\\)[ ]+[, at]*line +\\([0-9]+\\)" sh (2 4 3) -1)) "\ Series of regexps matching file number locations. Each list entry is a 3-list of a regexp, a program name, and up to 3 numbers. The numbers name regexp fields which will hold the file, line number, and associated diagnostic message (if any). The program name is a symbol or list of symbols, and is returned unexamined from `comint-extract-source-location'; it should be a guess at who produced the message, e.g., 'cc'. In the case of multiple matches, `comint-extract-source-location' will return the leftmost, longest match of the highest priority. The priority of most patterns is 0, but a fourth element on the list, if present, specifies a different priority. The regexps initially stored here are based on the one in compile.el (although the pattern containing 'of' must also contain 'line'). They are also drawn from the Unix filters 'error' and 'fwarn'. The patterns are known to recognize errors from the following Un*x language processors: cpp, cc, dbx, lex, f77, Centerline C, sh (Bourne), lint, mod The following language processors do not incorporate file names in every error message, and so are more difficult to accomodate: yacc, pc, csh ") (fset 'comint-extract-source-location #[(&optional start end commands markers) "y`)`);!q ced $):@:\neZ‰  <C }P@AdbA@:A@A@@Ai*2@#(‰y`@!V!8VUVUWU V  !,r*A@\"8$@%$A@&$8')! !)%!)&!)'!+,-./.;.\"!.!.\"-,+. . " [start 0 nil end get-buffer-create "*Extract File and Line*" erase-buffer comint-extract-source-location commands markers comint-source-location-patterns 1 -999999 set-found-data found-data found-pat found-end found-beg found-prio found-bol pat ptr #[(data) "@ ! É)Al " [found-data m markerp nil data] 4] ismem t re-search-backward prio bol beg re-search-forward error "comint-extract-source-location botch" 3 match-data command 2 fields f1 f2 f3 #[(fn) " \nV \n! !B\n {*" [fn end beg markers copy-marker] 4] get-field store-match-data mend mstart diagnostic line file string-match "\\`[0-9]+\\'" string-to-int] 10 "\ Return a 6-list of (file line command diagnostic mstart mend), obtained by parsing the current buffer between START and END, which default to the bounds of the current line. Use the list comint-source-location-patterns to guide parsing. The match returned will be on the latest line containing a match, but will be the earliest possible match on that line. START can also be a string, in which case it inserted in the buffer \"*Extract File and Line*\" and parsed there. COMMANDS is an optional list of pattern types, which has the effect of temporarily reducing the list comint-source-location-patterns to only those entries which apply to the given commands. Return NIL if there is no recognizable source location. MSTART and MEND give the limits of the matched source location. If MARKERS is true, return no strings, but rather cons cells of the form (beg-marker . end-marker). "]) (defvar comint-find-source-code-max-lines 100 "\ *Maximum number of lines to search backward for a source location, when using \\[comint-find-source-code\\] with an interactive prefix.") (defvar comint-find-source-file-hook nil "\ *Function to call instead of comint-default-find-source-file when comint-find-source-code parses out a file name and then wants to visit its buffer. The sole argument is the file name. The function must find the file, setting the current buffer, and return the file name. It may also adjust the file name. If you change this variable, make it buffer local.") (defvar comint-goto-source-line-hook nil "\ *Function to call instead of comint-default-goto-source-line after comint-find-source-code finds a file and then wants to go to a line number mentioned in a source location. The sole argument is the line number. The function must return the line number, possibly adjusted. If you change this variable, make it buffer local.") (fset 'comint-find-source-code #[(multi-line) "\n[^yy`)`) \" ĉ)! @ A@ 8 8 8y`)W?b!!ڪ!ݪ\"!᪁&. " [multi-line 0 comint-find-source-code-max-lines beg nil end comint-extract-source-location comint-extract-current-pathname file error "Not sitting on a source location." res 3 4 5 dofind mend mbeg info line comint-find-source-file-hook comint-default-find-source-file comint-goto-source-line-hook comint-default-goto-source-line message "%s%s of %s%s%s" "" substitute-command-keys "Hit \\[comint-find-source-code] for " "current line" format "line %s" file-name-nondirectory ": "] 8 "\ Search backward from point for a source location. If a source location is found in the current line, go to that location. If MULTI-LINE is false (this is the interactive prefix flag), then only look for source locations in the current line. Otherwise, look within comint-find-source-code-max-lines before point. If a source location is found on a previous line, move point to that location, so that another use of \\[comint-find-source-code\\] will go to the indicated place. If no source location is found, then try to extract a filename around the point, using comint-extract-current-pathname. In any case, if the file does not exist, prompt the user for a pathname that does. Sometimes the file's directory needs hand adjustment. This command uses comint-extract-source-location, which is customizable. Also, once a source file and line have been extracted, it uses comint-find-source-file-hook and comint-goto-source-line-hook to interpret them." "P"]) (fset 'comint-default-find-source-file #[(file) " ! ! ! ! " [substitute-in-file-name file file-readable-p comint-fixup-source-file-name find-file-other-window] 2 "\ Action taken by \\[comint-find-source-code] when find-source-file-hook is nil. It calls substitute-in-file-name. If the file does not exist, it prompts for the right pathname, using a similar pathname derived from a nearby buffer as a default. It then calls find-file-other-window and returns the amended file name."]) (fset 'comint-fixup-source-file-name #[(file) "!  @!\n! \n!\n! A_ %= \" -" [nil res bfile nondir ptr dir file-name-nondirectory file buffer-list buffer-file-name file-name-directory read-file-name "Source file: " t expand-file-name] 7]) (fset 'comint-default-goto-source-line #[(line) "~]ed\"\\^ !" [line 0 count-lines 1 push-mark goto-line] 5 "\ Action taken by \\[comint-find-source-code] when goto-source-line-hook is nil. It widens & pushes the mark, then does goto-line in the current buffer. It returns its line argument."]) (defvar comint-load-hook nil "\ This hook is run when comint is loaded in. This is a good place to put keybindings.") (byte-code "!!" [run-hooks comint-load-hook provide comint] 2)