[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] Changes to emacs/lisp/term.el [gnus-5_10-branch]
From: |
Miles Bader |
Subject: |
[Emacs-diffs] Changes to emacs/lisp/term.el [gnus-5_10-branch] |
Date: |
Sat, 04 Sep 2004 08:26:41 -0400 |
Index: emacs/lisp/term.el
diff -c /dev/null emacs/lisp/term.el:1.54.2.1
*** /dev/null Sat Sep 4 12:02:23 2004
--- emacs/lisp/term.el Sat Sep 4 12:01:08 2004
***************
*** 0 ****
--- 1,4078 ----
+ ;;; term.el --- general command interpreter in a window stuff
+
+ ;;; Copyright (C) 1988, 1990, 1992, 1994, 1995 Free Software Foundation, Inc.
+
+ ;; Author: Per Bothner <address@hidden>
+ ;; Based on comint mode written by: Olin Shivers <address@hidden>
+ ;; Keywords: processes
+
+ ;; This file is part of GNU Emacs.
+
+ ;; GNU Emacs is free software; you can redistribute it and/or modify
+ ;; it under the terms of the GNU General Public License as published by
+ ;; the Free Software Foundation; either version 2, or (at your option)
+ ;; any later version.
+
+ ;; GNU Emacs is distributed in the hope that it will be useful,
+ ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ;; GNU General Public License for more details.
+
+ ;; You should have received a copy of the GNU General Public License
+ ;; along with GNU Emacs; see the file COPYING. If not, write to the
+ ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ ;; Boston, MA 02111-1307, USA.
+
+ ;;; Marck 13 2001
+ ;;; Fixes for CJK support by Yong Lu <address@hidden>.
+
+ ;;; Dir/Hostname tracking and ANSI colorization by
+ ;;; Marco Melgazzi <address@hidden>.
+
+ ;;; To see what I've modified and where it came from search for '-mm'
+
+ ;;; Commentary:
+
+ ;;; Speed considerations and a few caveats
+ ;;; --------------------------------------
+ ;;;
+ ;;; While the message passing and the colorization surely introduce some
+ ;;; overhead this has became so small that IMHO is surely outweighted by
+ ;;; the benefits you get but, as usual, YMMV
+ ;;;
+ ;;; Important caveat, when deciding the cursor/'grey keys' keycodes I had to
+ ;;; make a choice: on my Linux box this choice allows me to run all the
+ ;;; ncurses applications without problems but make these keys
+ ;;; uncomprehensible to all the cursesX programs. Your mileage may vary so
+ ;;; you may consider changing the default 'emulation'. Just search for this
+ ;;; piece of code and modify it as you like:
+ ;;;
+ ;;; ;; Which would be better: "\e[A" or "\eOA"? readline accepts either.
+ ;;; ;; For my configuration it's definitely better \eOA but YMMV. -mm
+ ;;; ;; For example: vi works with \eOA while elm wants \e[A ...
+ ;;; (defun term-send-up () (interactive) (term-send-raw-string "\eOA"))
+ ;;; (defun term-send-down () (interactive) (term-send-raw-string "\eOB"))
+ ;;; (defun term-send-right () (interactive) (term-send-raw-string "\eOC"))
+ ;;; (defun term-send-left () (interactive) (term-send-raw-string "\eOD"))
+ ;;;
+ ;;;
+ ;;; IMPORTANT: additions & changes
+ ;;; ------------------------------
+ ;;;
+ ;;; With this enhanced ansi-term.el you will get a reliable mechanism of
+ ;;; directory/username/host tracking: the only drawback is that you will
+ ;;; have to modify your shell start-up script. It's worth it, believe me :).
+ ;;;
+ ;;; When you rlogin/su/telnet and the account you access has a modified
+ ;;; startup script, you will be able to access the remote files as usual
+ ;;; with C-x C-f, if it's needed you will have to enter a password,
+ ;;; otherwise the file should get loaded straight away.
+ ;;;
+ ;;; This is useful even if you work only on one host: it often happens that,
+ ;;; for maintenance reasons, you have to edit files 'as root': before
+ ;;; patching term.el, I su-ed in a term.el buffer and used vi :), now I
+ ;;; simply do a C-x C-f and, via ange-ftp, the file is automatically loaded
+ ;;; 'as-root'. ( If you don't want to enter the root password every time you
+ ;;; can put it in your .netrc: note that this is -not- advisable if you're
+ ;;; connected to the internet or if somebody else works on your workstation!)
+ ;;;
+ ;;; If you use wu-ftpd you can use some of its features to avoid root ftp
+ ;;; access to the rest of the world: just put in /etc/ftphosts something like
+ ;;;
+ ;;; # Local access
+ ;;; allow root 127.0.0.1
+ ;;;
+ ;;; # By default nobody can't do anything
+ ;;; deny root *
+ ;;;
+ ;;;
+ ;;; ----------------------------------------
+ ;;;
+ ;;; If, instead of 'term', you call 'ansi-term', you get multiple term
+ ;;; buffers, after every new call ansi-term opens a new *ansi-term*<xx>
window,
+ ;;; where <xx> is, as usual, a number...
+ ;;;
+ ;;; ----------------------------------------
+ ;;;
+ ;;; With the term-buffer-maximum-size you can finally decide how many
+ ;;; scrollback lines to keep: its default is 2048 but you can change it as
+ ;;; usual.
+ ;;;
+ ;;; ----------------------------------------
+ ;;;
+ ;;;
+ ;;; ANSI colorization should work well, I've decided to limit the interpreter
+ ;;; to five outstanding commands (like ESC [ 01;04;32;41;07m.
+ ;;; You shouldn't need more, if you do, tell me and I'll increase it. It's
+ ;;; so easy you could do it yourself...
+ ;;;
+ ;;; Blink, is not supported. Currently it's mapped as bold.
+ ;;;
+ ;;; Important caveat:
+ ;;; -----------------
+ ;;; if you want custom colors in term.el redefine term-default-fg-color
+ ;;; and term-default-bg-color BEFORE loading it.
+ ;;;
+ ;;; ----------------------------------------
+ ;;;
+ ;;; If you'd like to check out my complete configuration, you can download
+ ;;; it from http://www.polito.it/~s64912/things.html, it's ~500k in size and
+ ;;; contains my .cshrc, .emacs and my whole site-lisp subdirectory. (notice
+ ;;; that this term.el may be newer/older than the one in there, please
+ ;;; check!)
+ ;;;
+ ;;; This complete configuration contains, among other things, a complete
+ ;;; rectangular marking solution (based on rect-mark.el and
+ ;;; pc-bindings.el) and should be a good example of how extensively Emacs
+ ;;; can be configured on a ppp-connected ws.
+ ;;;
+ ;;; ----------------------------------------
+ ;;;
+ ;;; TODO:
+ ;;;
+ ;;; - Add hooks to allow raw-mode keys to be configurable
+ ;;; - Which keys are better ? \eOA or \e[A ?
+ ;;;
+ ;;;
+ ;;; Changes:
+ ;;;
+ ;;; V4.0 January 1997
+ ;;;
+ ;;; - Huge reworking of the faces code: now we only have roughly 20-30
+ ;;; faces for everything so we're even faster than the old md-term.el !
+ ;;; - Finished removing all the J-Shell code.
+ ;;;
+ ;;; V3.0 January 1997
+ ;;;
+ ;;; - Now all the supportable ANSI commands work well.
+ ;;; - Reworked a little the code: much less jsh-inspired stuff
+ ;;;
+ ;;; V2.3 November
+ ;;;
+ ;;; - Now all the faces are accessed through an array: much cleaner code.
+ ;;;
+ ;;; V2.2 November 4 1996
+ ;;;
+ ;;; - Implemented ANSI output colorization ( a bit rough but enough for
+ ;;; color_ls )
+ ;;;
+ ;;; - Implemented a maximum limit for the scroll buffer (stolen from
+ ;;; comint.el)
+ ;;;
+ ;;; v2.1 October 28 1996, first public release
+ ;;;
+ ;;; - Some new keybindings for term-char mode ( notably home/end/...)
+ ;;; - Directory, hostname and username tracking via ange-ftp
+ ;;; - Multi-term capability via the ansi-term call
+ ;;;
+ ;;; ----------------------------------------------------------------
+ ;;; You should/could have something like this in your .emacs to take
+ ;;; full advantage of this package
+ ;;;
+ ;;; (add-hook 'term-mode-hook
+ ;;; (function
+ ;;; (lambda ()
+ ;;; (setq term-prompt-regexp "^[^#$%>\n]*[#$%>] *")
+ ;;; (make-local-variable 'mouse-yank-at-point)
+ ;;; (make-local-variable 'transient-mark-mode)
+ ;;; (setq mouse-yank-at-point t)
+ ;;; (setq transient-mark-mode nil)
+ ;;; (auto-fill-mode -1)
+ ;;; (setq tab-width 8 ))))
+ ;;;
+ ;;;
+ ;;; ----------------------------------------
+ ;;;
+ ;;; If you want to use color ls the best setup is to have a different file
+ ;;; when you use eterm ( see above, mine is named .emacs_dircolors ). This
+ ;;; is necessary because some terminals, rxvt for example, need non-ansi
+ ;;; hacks to work ( for example on my rxvt white is wired to fg, and to
+ ;;; obtain normal white I have to do bold-white :)
+ ;;;
+ ;;; ----------------------------------------
+ ;;;
+ ;;;
+ ;;; # Configuration file for the color ls utility
+ ;;; # This file goes in the /etc directory, and must be world readable.
+ ;;; # You can copy this file to .dir_colors in your $HOME directory to
+ ;;; # override the system defaults.
+ ;;;
+ ;;; # COLOR needs one of these arguments: 'tty' colorizes output to ttys, but
+ ;;; # not pipes. 'all' adds color characters to all output. 'none' shuts
+ ;;; # colorization off.
+ ;;; COLOR tty
+ ;;; OPTIONS -F
+ ;;;
+ ;;; # Below, there should be one TERM entry for each termtype that is
+ ;;; # colorizable
+ ;;; TERM eterm
+ ;;;
+ ;;; # EIGHTBIT, followed by '1' for on, '0' for off. (8-bit output)
+ ;;; EIGHTBIT 1
+ ;;;
+ ;;; # Below are the color init strings for the basic file types. A color
init
+ ;;; # string consists of one or more of the following numeric codes:
+ ;;; # Attribute codes:
+ ;;; # 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed
+ ;;; # Text color codes:
+ ;;; # 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white
+ ;;; # Background color codes:
+ ;;; # 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
+ ;;; NORMAL 00 # global default, although everything should be
something.
+ ;;; FILE 00 # normal file
+ ;;; DIR 00;37 # directory
+ ;;; LINK 00;36 # symbolic link
+ ;;; FIFO 00;37 # pipe
+ ;;; SOCK 40;35 # socket
+ ;;; BLK 33;01 # block device driver
+ ;;; CHR 33;01 # character device driver
+ ;;;
+ ;;; # This is for files with execute permission:
+ ;;; EXEC 00;32
+ ;;;
+ ;;; # List any file extensions like '.gz' or '.tar' that you would like ls
+ ;;; # to colorize below. Put the extension, a space, and the color init
+ ;;; # string. (and any comments you want to add after a '#')
+ ;;; .tar 01;33 # archives or compressed
+ ;;; .tgz 01;33
+ ;;; .arj 01;33
+ ;;; .taz 01;33
+ ;;; .lzh 01;33
+ ;;; .zip 01;33
+ ;;; .z 01;33
+ ;;; .Z 01;33
+ ;;; .gz 01;33
+ ;;; .jpg 01;35 # image formats
+ ;;; .gif 01;35
+ ;;; .bmp 01;35
+ ;;; .xbm 01;35
+ ;;; .xpm 01;35
+ ;;;
+ ;;;
+ ;;; ----------------------------------------
+ ;;;
+ ;;; Notice: for directory/host/user tracking you need to have something
+ ;;; like this in your shell startup script ( this is for tcsh but should
+ ;;; be quite easy to port to other shells )
+ ;;;
+ ;;; ----------------------------------------
+ ;;;
+ ;;;
+ ;;; set os = `uname`
+ ;;; set host = `hostname`
+ ;;; set date = `date`
+ ;;;
+ ;;; # su does not change this but I'd like it to
+ ;;;
+ ;;; set user = `whoami`
+ ;;;
+ ;;; # ...
+ ;;;
+ ;;; if ( eterm =~ $TERM ) then
+ ;;;
+ ;;; echo
--------------------------------------------------------------
+ ;;; echo Hello $user
+ ;;; echo Today is $date
+ ;;; echo We are on $host running $os under Emacs term mode
+ ;;; echo
--------------------------------------------------------------
+ ;;;
+ ;;; setenv EDITOR emacsclient
+ ;;;
+ ;;; # Notice: $host and $user have been set before to 'hostname' and
'whoami'
+ ;;; # this is necessary because, f.e., certain versions of 'su' do not
change
+ ;;; # $user, YMMV: if you don't want to fiddle with them define a couple
+ ;;; # of new variables and use these instead.
+ ;;; # NOTICE that there is a space between "AnSiT?" and $whatever NOTICE
+ ;;;
+ ;;; # These are because we want the real cwd in the messages, not the login
+ ;;; # time one !
+ ;;;
+ ;;; set cwd_hack='$cwd'
+ ;;; set host_hack='$host'
+ ;;; set user_hack='$user'
+ ;;;
+ ;;; # Notice that the ^[ character is an ESC, not two chars. You can
+ ;;; # get it in various ways, for example by typing
+ ;;; # echo -e '\033' > escape.file
+ ;;; # or by using your favourite editor
+ ;;;
+ ;;; foreach temp (cd pushd)
+ ;;; alias $temp "$temp \!* ; echo 'AnSiTc' $cwd_hack"
+ ;;; end
+ ;;; alias popd 'popd ;echo "AnSiTc" $cwd'
+ ;;;
+ ;;; # Every command that can modify the user/host/directory should be
aliased
+ ;;; # as follows for the tracking mechanism to work.
+ ;;;
+ ;;; foreach temp ( rlogin telnet rsh sh ksh csh tcsh zsh bash tcl
su )
+ ;;; alias $temp "$temp \!* ; echo 'AnSiTh' $host_hack ; \
+ ;;; echo 'AnSiTu' $user_hack ;echo
'AnSiTc' $cwd_hack"
+ ;;; end
+ ;;;
+ ;;; # Start up & use color ls
+ ;;;
+ ;;; echo "AnSiTh" $host
+ ;;; echo "AnSiTu" $user
+ ;;; echo "AnSiTc" $cwd
+ ;;;
+ ;;; # some housekeeping
+ ;;;
+ ;;; unset cwd_hack
+ ;;; unset host_hack
+ ;;; unset user_hack
+ ;;; unset temp
+ ;;;
+ ;;; eval `/bin/dircolors /home/marco/.emacs_dircolors`
+ ;;; endif
+ ;;;
+ ;;; # ...
+ ;;;
+ ;;; # Let's not clutter user space
+ ;;;
+ ;;; unset os
+ ;;; unset date
+ ;;;
+ ;;;
+
+ ;;; Original Commentary:
+ ;;; --------------------
+
+ ;; The changelog is at the end of this file.
+
+ ;; Please send me bug reports, bug fixes, and extensions, so that I can
+ ;; merge them into the master source.
+ ;; - Per Bothner (address@hidden)
+
+ ;; This file defines a general command-interpreter-in-a-buffer package
+ ;; (term mode). The idea is that you can build specific process-in-a-buffer
+ ;; modes on top of term mode -- e.g., lisp, shell, scheme, T, soar, ....
+ ;; This way, all these specific packages share a common base functionality,
+ ;; and a common set of bindings, which makes them easier to use (and
+ ;; saves code, implementation time, etc., etc.).
+
+ ;; For hints on converting existing process modes (e.g., tex-mode,
+ ;; background, dbx, gdb, kermit, prolog, telnet) to use term-mode
+ ;; instead of shell-mode, see the notes at the end of this file.
+
+
+ ;; Brief Command Documentation:
+ ;;============================================================================
+ ;; Term Mode Commands: (common to all derived modes, like cmushell & cmulisp
+ ;; mode)
+ ;;
+ ;; m-p term-previous-input Cycle backwards in input
history
+ ;; m-n term-next-input Cycle forwards
+ ;; m-r term-previous-matching-input Previous input matching a regexp
+ ;; m-s comint-next-matching-input Next input that matches
+ ;; return term-send-input
+ ;; c-c c-a term-bol Beginning of line; skip prompt.
+ ;; c-d term-delchar-or-maybe-eof Delete char unless at end of
buff.
+ ;; c-c c-u term-kill-input ^u
+ ;; c-c c-w backward-kill-word ^w
+ ;; c-c c-c term-interrupt-subjob ^c
+ ;; c-c c-z term-stop-subjob ^z
+ ;; c-c c-\ term-quit-subjob ^\
+ ;; c-c c-o term-kill-output Delete last batch of process output
+ ;; c-c c-r term-show-output Show last batch of process output
+ ;; c-c c-h term-dynamic-list-input-ring List input history
+ ;;
+ ;; Not bound by default in term-mode
+ ;; term-send-invisible Read a line w/o echo, and send
to proc
+ ;; (These are bound in shell-mode)
+ ;; term-dynamic-complete Complete filename at point.
+ ;; term-dynamic-list-completions List completions in help buffer.
+ ;; term-replace-by-expanded-filename Expand and complete filename at point;
+ ;; replace with expanded/completed name.
+ ;; term-kill-subjob No mercy.
+ ;; term-show-maximum-output Show as much output as possible.
+ ;; term-continue-subjob Send CONT signal to buffer's process
+ ;; group. Useful if you accidentally
+ ;; suspend your process (with C-c C-z).
+
+ ;; term-mode-hook is the term mode hook. Basically for your keybindings.
+ ;; term-load-hook is run after loading in this package.
+
+ ;;; Code:
+
+ ;; This is passed to the inferior in the EMACS environment variable,
+ ;; so it is important to increase it if there are protocol-relevant changes.
+ (defconst term-protocol-version "0.95")
+
+ (eval-when-compile
+ (require 'ange-ftp))
+ (require 'ring)
+ (require 'ehelp)
+
+ (defgroup term nil
+ "General command interpreter in a window"
+ :group 'processes
+ :group 'unix)
+
+
+ ;;; Buffer Local Variables:
+
;;;============================================================================
+ ;;; Term mode buffer local variables:
+ ;;; term-prompt-regexp - string term-bol uses to match prompt.
+ ;;; term-delimiter-argument-list - list For delimiters and arguments
+ ;;; term-last-input-start - marker Handy if inferior always echoes
+ ;;; term-last-input-end - marker For term-kill-output command
+ ;; For the input history mechanism:
+ (defvar term-input-ring-size 32 "Size of input history ring.")
+ ;;; term-input-ring-size - integer
+ ;;; term-input-ring - ring
+ ;;; term-input-ring-index - number ...
+ ;;; term-input-autoexpand - symbol ...
+ ;;; term-input-ignoredups - boolean ...
+ ;;; term-last-input-match - string ...
+ ;;; term-dynamic-complete-functions - hook For the completion mechanism
+ ;;; term-completion-fignore - list ...
+ ;;; term-get-old-input - function Hooks for specific
+ ;;; term-input-filter-functions - hook process-in-a-buffer
+ ;;; term-input-filter - function modes.
+ ;;; term-input-send - function
+ ;;; term-scroll-to-bottom-on-output - symbol ...
+ ;;; term-scroll-show-maximum-output - boolean...
+ (defvar term-height) ;; Number of lines in window.
+ (defvar term-width) ;; Number of columns in window.
+ (defvar term-home-marker) ;; Marks the "home" position for cursor addressing.
+ (defvar term-saved-home-marker nil) ;; When using alternate sub-buffer,
+ ;; contains saved term-home-marker from original sub-buffer .
+ (defvar term-start-line-column 0) ;; (current-column) at start of screen line,
+ ;; or nil if unknown.
+ (defvar term-current-column 0) ;; If non-nil, is cache for (current-column).
+ (defvar term-current-row 0) ;; Current vertical row (relative to home-marker)
+ ;; or nil if unknown.
+ (defvar term-insert-mode nil)
+ (defvar term-vertical-motion)
+ (defvar term-terminal-state 0) ;; State of the terminal emulator:
+ ;; state 0: Normal state
+ ;; state 1: Last character was a graphic in the last column.
+ ;; If next char is graphic, first move one column right
+ ;; (and line warp) before displaying it.
+ ;; This emulates (more or less) the behavior of xterm.
+ ;; state 2: seen ESC
+ ;; state 3: seen ESC [ (or ESC [ ?)
+ ;; state 4: term-terminal-parameter contains pending output.
+ (defvar term-kill-echo-list nil) ;; A queue of strings whose echo
+ ;; we want suppressed.
+ (defvar term-terminal-parameter)
+ (defvar term-terminal-previous-parameter)
+ (defvar term-current-face 'term-default)
+ (defvar term-scroll-start 0) ;; Top-most line (inclusive) of scrolling region.
+ (defvar term-scroll-end) ;; Number of line (zero-based) after scrolling
region.
+ (defvar term-pager-count nil) ;; If nil, paging is disabled.
+ ;; Otherwise, number of lines before we need to page.
+ (defvar term-saved-cursor nil)
+ (defvar term-command-hook)
+ (defvar term-log-buffer nil)
+ (defvar term-scroll-with-delete nil) ;; term-scroll-with-delete is t if
+ ;; forward scrolling should be implemented by delete to
+ ;; top-most line(s); and nil if scrolling should be implemented
+ ;; by moving term-home-marker. It is set to t iff there is a
+ ;; (non-default) scroll-region OR the alternate buffer is used.
+ (defvar term-pending-delete-marker) ;; New user input in line mode needs to
+ ;; be deleted, because it gets echoed by the inferior.
+ ;; To reduce flicker, we defer the delete until the next output.
+ (defvar term-old-mode-map nil) ;; Saves the old keymap when in char mode.
+ (defvar term-old-mode-line-format) ;; Saves old mode-line-format while paging.
+ (defvar term-pager-old-local-map nil) ;; Saves old keymap while paging.
+ (defvar term-pager-old-filter) ;; Saved process-filter while paging.
+
+ (defcustom explicit-shell-file-name nil
+ "*If non-nil, is file name to use for explicitly requested inferior shell."
+ :type '(choice (const nil) file)
+ :group 'term)
+
+ (defvar term-prompt-regexp "^"
+ "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 term-delimiter-argument-list ()
+ "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 `term-arguments'.
+ Defaults to the empty list.
+
+ For shells, a good value is (?\\| ?& ?< ?> ?\\( ?\\) ?\\;).
+
+ This is a good thing to set in mode hooks.")
+
+ (defcustom term-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 `term-magic-space' and
+ `term-dynamic-complete'.
+
+ This variable is buffer-local."
+ :type '(choice (const nil) (const t) (const input) (const history))
+ :group 'term)
+
+ (defcustom term-input-ignoredups nil
+ "*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."
+ :type 'boolean
+ :group 'term)
+
+ (defcustom term-input-ring-file-name nil
+ "*If non-nil, name of the file to read/write input history.
+ See also `term-read-input-ring' and `term-write-input-ring'.
+
+ This variable is buffer-local, and is a good thing to set in mode hooks."
+ :type 'boolean
+ :group 'term)
+
+ (defcustom term-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 `term-scroll-show-maximum-output'.
+ This variable is buffer-local."
+ :type 'boolean
+ :group 'term)
+
+ (defcustom term-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 `term-scroll-to-bottom-on-output'.
+ This variable is buffer-local."
+ :type 'boolean
+ :group 'term)
+
+ ;; Where gud-display-frame should put the debugging arrow. This is
+ ;; set by the marker-filter, which scans the debugger's output for
+ ;; indications of the current pc.
+ (defvar term-pending-frame nil)
+
+ ;;; Here are the per-interpreter hooks.
+ (defvar term-get-old-input (function term-get-old-input-default)
+ "Function that submits old text in term 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
+ term-get-old-input-default, which grabs the current line, and strips off
+ leading text matching term-prompt-regexp")
+
+ (defvar term-dynamic-complete-functions
+ '(term-replace-by-expanded-history term-dynamic-complete-filename)
+ "List of functions called to perform completion.
+ Functions should return non-nil if completion was performed.
+ See also `term-dynamic-complete'.
+
+ This is a good thing to set in mode hooks.")
+
+ (defvar term-input-filter
+ (function (lambda (str) (not (string-match "\\`\\s *\\'" str))))
+ "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 that isn't all whitespace")
+
+ (defvar term-input-filter-functions '()
+ "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 term-input-sender (function term-simple-send)
+ "Function to actually send to PROCESS the STRING submitted by user.
+ Usually this is just 'term-simple-send, but if your mode needs to
+ massage the input string, this is your hook. This is called from
+ the user command term-send-input. term-simple-send just sends
+ the string plus a newline.")
+
+ (defcustom term-eol-on-send t
+ "*Non-nil means go to the end of the line before sending input.
+ See `term-send-input'."
+ :type 'boolean
+ :group 'term)
+
+ (defcustom term-mode-hook '()
+ "Called upon entry into term-mode
+ This is run before the process is cranked up."
+ :type 'hook
+ :group 'term)
+
+ (defcustom term-exec-hook '()
+ "Called each time a process is exec'd by term-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 term-mode buffer (e.g.,
+ \(process-kill-without-query)). In contrast, the term-mode-hook is only
+ executed once when the buffer is created."
+ :type 'hook
+ :group 'term)
+
+ (defvar term-mode-map nil)
+ (defvar term-raw-map nil
+ "Keyboard map for sending characters directly to the inferior process.")
+ (defvar term-escape-char nil
+ "Escape character for char-sub-mode of term mode.
+ Do not change it directly; use term-set-escape-char instead.")
+ (defvar term-raw-escape-map nil)
+
+ (defvar term-pager-break-map nil)
+
+ (defvar term-ptyp t
+ "True if communications via pty; false if by pipe. Buffer local.
+ This is to work around a bug in Emacs process signaling.")
+
+ (defvar term-last-input-match ""
+ "Last string searched for by term input history search, for defaulting.
+ Buffer local variable.")
+
+ (defvar term-input-ring nil)
+ (defvar term-last-input-start)
+ (defvar term-last-input-end)
+ (defvar term-input-ring-index nil
+ "Index of last matched history element.")
+ (defvar term-matching-input-from-input-string ""
+ "Input previously used to match input history.")
+ ; This argument to set-process-filter disables reading from the process,
+ ; assuming this is Emacs 19.20 or newer.
+ (defvar term-pager-filter t)
+
+ (put 'term-replace-by-expanded-history 'menu-enable 'term-input-autoexpand)
+ (put 'term-input-ring 'permanent-local t)
+ (put 'term-input-ring-index 'permanent-local t)
+ (put 'term-input-autoexpand 'permanent-local t)
+ (put 'term-input-filter-functions 'permanent-local t)
+ (put 'term-scroll-to-bottom-on-output 'permanent-local t)
+ (put 'term-scroll-show-maximum-output 'permanent-local t)
+ (put 'term-ptyp 'permanent-local t)
+
+ ;; Do FORM if running under XEmacs (previously Lucid Emacs).
+ (defmacro term-if-xemacs (&rest forms)
+ (if (featurep 'xemacs) (cons 'progn forms)))
+ ;; Do FORM if NOT running under XEmacs (previously Lucid Emacs).
+ (defmacro term-ifnot-xemacs (&rest forms)
+ (if (not (featurep 'xemacs)) (cons 'progn forms)))
+
+ (defmacro term-in-char-mode () '(eq (current-local-map) term-raw-map))
+ (defmacro term-in-line-mode () '(not (term-in-char-mode)))
+ ;; True if currently doing PAGER handling.
+ (defmacro term-pager-enabled () 'term-pager-count)
+ (defmacro term-handling-pager () 'term-pager-old-local-map)
+ (defmacro term-using-alternate-sub-buffer () 'term-saved-home-marker)
+
+ (defvar term-signals-menu)
+ (defvar term-terminal-menu)
+
+ ;;; Let's silence the byte-compiler -mm
+ (defvar term-ansi-at-eval-string nil)
+ (defvar term-ansi-at-host nil)
+ (defvar term-ansi-at-dir nil)
+ (defvar term-ansi-at-user nil)
+ (defvar term-ansi-at-message nil)
+ (defvar term-ansi-at-save-user nil)
+ (defvar term-ansi-at-save-pwd nil)
+ (defvar term-ansi-at-save-anon nil)
+ (defvar term-ansi-current-bold 0)
+ (defvar term-ansi-current-color 0)
+ (defvar term-ansi-face-already-done 0)
+ (defvar term-ansi-current-bg-color 0)
+ (defvar term-ansi-current-underline 0)
+ (defvar term-ansi-current-highlight 0)
+ (defvar term-ansi-current-reverse 0)
+ (defvar term-ansi-current-invisible 0)
+ (defvar term-ansi-default-fg 0)
+ (defvar term-ansi-default-bg 0)
+ (defvar term-ansi-current-temp 0)
+
+ ;;; Four should be enough, if you want more, just add. -mm
+ (defvar term-terminal-more-parameters 0)
+ (defvar term-terminal-previous-parameter-2 -1)
+ (defvar term-terminal-previous-parameter-3 -1)
+ (defvar term-terminal-previous-parameter-4 -1)
+ ;;;
+
+ ;;; faces -mm
+
+ (defcustom term-default-fg-color 'unspecified
+ "Default color for foreground in `term'."
+ :group 'term
+ :type 'string)
+
+ (defcustom term-default-bg-color 'unspecified
+ "Default color for background in `term'."
+ :group 'term
+ :type 'string)
+
+ (defvar ansi-term-color-vector
+ [unspecified "black" "red" "green" "yellow" "blue"
+ "magenta" "cyan" "white"])
+
+ ;;; Inspiration came from comint.el -mm
+ (defvar term-buffer-maximum-size 2048
+ "*The maximum size in lines for term buffers.
+ Term buffers are truncated from the top to be no greater than this number.
+ Notice that a setting of 0 means 'don't truncate anything'. This variable
+ is buffer-local.")
+ ;;;
+
+ (term-if-xemacs
+ (defvar term-terminal-menu
+ '("Terminal"
+ [ "Character mode" term-char-mode (term-in-line-mode)]
+ [ "Line mode" term-line-mode (term-in-char-mode)]
+ [ "Enable paging" term-pager-toggle (not term-pager-count)]
+ [ "Disable paging" term-pager-toggle term-pager-count])))
+
+ (if term-mode-map
+ nil
+ (setq term-mode-map (make-sparse-keymap))
+ (define-key term-mode-map "\ep" 'term-previous-input)
+ (define-key term-mode-map "\en" 'term-next-input)
+ (define-key term-mode-map "\er" 'term-previous-matching-input)
+ (define-key term-mode-map "\es" 'term-next-matching-input)
+ (term-ifnot-xemacs
+ (define-key term-mode-map [?\A-\M-r]
+ 'term-previous-matching-input-from-input)
+ (define-key term-mode-map [?\A-\M-s] 'term-next-matching-input-from-input))
+ (define-key term-mode-map "\e\C-l" 'term-show-output)
+ (define-key term-mode-map "\C-m" 'term-send-input)
+ (define-key term-mode-map "\C-d" 'term-delchar-or-maybe-eof)
+ (define-key term-mode-map "\C-c\C-a" 'term-bol)
+ (define-key term-mode-map "\C-c\C-u" 'term-kill-input)
+ (define-key term-mode-map "\C-c\C-w" 'backward-kill-word)
+ (define-key term-mode-map "\C-c\C-c" 'term-interrupt-subjob)
+ (define-key term-mode-map "\C-c\C-z" 'term-stop-subjob)
+ (define-key term-mode-map "\C-c\C-\\" 'term-quit-subjob)
+ (define-key term-mode-map "\C-c\C-m" 'term-copy-old-input)
+ (define-key term-mode-map "\C-c\C-o" 'term-kill-output)
+ (define-key term-mode-map "\C-c\C-r" 'term-show-output)
+ (define-key term-mode-map "\C-c\C-e" 'term-show-maximum-output)
+ (define-key term-mode-map "\C-c\C-l" 'term-dynamic-list-input-ring)
+ (define-key term-mode-map "\C-c\C-n" 'term-next-prompt)
+ (define-key term-mode-map "\C-c\C-p" 'term-previous-prompt)
+ (define-key term-mode-map "\C-c\C-d" 'term-send-eof)
+ (define-key term-mode-map "\C-c\C-k" 'term-char-mode)
+ (define-key term-mode-map "\C-c\C-j" 'term-line-mode)
+ (define-key term-mode-map "\C-c\C-q" 'term-pager-toggle)
+
+ ; ;; completion:
+ ; (define-key term-mode-map [menu-bar completion]
+ ; (cons "Complete" (make-sparse-keymap "Complete")))
+ ; (define-key term-mode-map [menu-bar completion complete-expand]
+ ; '("Expand File Name" . term-replace-by-expanded-filename))
+ ; (define-key term-mode-map [menu-bar completion complete-listing]
+ ; '("File Completion Listing" . term-dynamic-list-filename-completions))
+ ; (define-key term-mode-map [menu-bar completion complete-file]
+ ; '("Complete File Name" . term-dynamic-complete-filename))
+ ; (define-key term-mode-map [menu-bar completion complete]
+ ; '("Complete Before Point" . term-dynamic-complete))
+ ; ;; Put them in the menu bar:
+ ; (setq menu-bar-final-items (append '(terminal completion inout signals)
+ ; menu-bar-final-items))
+ )
+
+ ;; Menu bars:
+ (term-ifnot-xemacs
+ (progn
+
+ ;; terminal:
+ (let (newmap)
+ (setq newmap (make-sparse-keymap "Terminal"))
+ (define-key newmap [terminal-pager-enable]
+ '("Enable paging" . term-fake-pager-enable))
+ (define-key newmap [terminal-pager-disable]
+ '("Disable paging" . term-fake-pager-disable))
+ (define-key newmap [terminal-char-mode]
+ '("Character mode" . term-char-mode))
+ (define-key newmap [terminal-line-mode]
+ '("Line mode" . term-line-mode))
+ (setq term-terminal-menu (cons "Terminal" newmap))
+
+ ;; completion: (line mode only)
+ (defvar term-completion-menu (make-sparse-keymap "Complete"))
+ (define-key term-mode-map [menu-bar completion]
+ (cons "Complete" term-completion-menu))
+ (define-key term-completion-menu [complete-expand]
+ '("Expand File Name" . term-replace-by-expanded-filename))
+ (define-key term-completion-menu [complete-listing]
+ '("File Completion Listing" . term-dynamic-list-filename-completions))
+ (define-key term-completion-menu [menu-bar completion complete-file]
+ '("Complete File Name" . term-dynamic-complete-filename))
+ (define-key term-completion-menu [menu-bar completion complete]
+ '("Complete Before Point" . term-dynamic-complete))
+
+ ;; Input history: (line mode only)
+ (defvar term-inout-menu (make-sparse-keymap "In/Out"))
+ (define-key term-mode-map [menu-bar inout]
+ (cons "In/Out" term-inout-menu))
+ (define-key term-inout-menu [kill-output]
+ '("Kill Current Output Group" . term-kill-output))
+ (define-key term-inout-menu [next-prompt]
+ '("Forward Output Group" . term-next-prompt))
+ (define-key term-inout-menu [previous-prompt]
+ '("Backward Output Group" . term-previous-prompt))
+ (define-key term-inout-menu [show-maximum-output]
+ '("Show Maximum Output" . term-show-maximum-output))
+ (define-key term-inout-menu [show-output]
+ '("Show Current Output Group" . term-show-output))
+ (define-key term-inout-menu [kill-input]
+ '("Kill Current Input" . term-kill-input))
+ (define-key term-inout-menu [copy-input]
+ '("Copy Old Input" . term-copy-old-input))
+ (define-key term-inout-menu [forward-matching-history]
+ '("Forward Matching Input..." . term-forward-matching-input))
+ (define-key term-inout-menu [backward-matching-history]
+ '("Backward Matching Input..." . term-backward-matching-input))
+ (define-key term-inout-menu [next-matching-history]
+ '("Next Matching Input..." . term-next-matching-input))
+ (define-key term-inout-menu [previous-matching-history]
+ '("Previous Matching Input..." . term-previous-matching-input))
+ (define-key term-inout-menu [next-matching-history-from-input]
+ '("Next Matching Current Input" . term-next-matching-input-from-input))
+ (define-key term-inout-menu [previous-matching-history-from-input]
+ '("Previous Matching Current Input" .
+ term-previous-matching-input-from-input))
+ (define-key term-inout-menu [next-history]
+ '("Next Input" . term-next-input))
+ (define-key term-inout-menu [previous-history]
+ '("Previous Input" . term-previous-input))
+ (define-key term-inout-menu [list-history]
+ '("List Input History" . term-dynamic-list-input-ring))
+ (define-key term-inout-menu [expand-history]
+ '("Expand History Before Point" . term-replace-by-expanded-history))
+
+ ;; Signals
+ (setq newmap (make-sparse-keymap "Signals"))
+ (define-key newmap [eof] '("EOF" . term-send-eof))
+ (define-key newmap [kill] '("KILL" . term-kill-subjob))
+ (define-key newmap [quit] '("QUIT" . term-quit-subjob))
+ (define-key newmap [cont] '("CONT" . term-continue-subjob))
+ (define-key newmap [stop] '("STOP" . term-stop-subjob))
+ (define-key newmap [] '("BREAK" . term-interrupt-subjob))
+ (define-key term-mode-map [menu-bar signals]
+ (setq term-signals-menu (cons "Signals" newmap)))
+ )))
+
+ ;; Set up term-raw-map, etc.
+
+ (defun term-set-escape-char (c)
+ "Change term-escape-char and keymaps that depend on it."
+ (if term-escape-char
+ (define-key term-raw-map term-escape-char 'term-send-raw))
+ (setq c (make-string 1 c))
+ (define-key term-raw-map c term-raw-escape-map)
+ ;; Define standard bindings in term-raw-escape-map
+ (define-key term-raw-escape-map "\C-v"
+ (lookup-key (current-global-map) "\C-v"))
+ (define-key term-raw-escape-map "\C-u"
+ (lookup-key (current-global-map) "\C-u"))
+ (define-key term-raw-escape-map c 'term-send-raw)
+ (define-key term-raw-escape-map "\C-q" 'term-pager-toggle)
+ ;; The keybinding for term-char-mode is needed by the menubar code.
+ (define-key term-raw-escape-map "\C-k" 'term-char-mode)
+ (define-key term-raw-escape-map "\C-j" 'term-line-mode)
+ ;; It's convenient to have execute-extended-command here.
+ (define-key term-raw-escape-map [?\M-x] 'execute-extended-command))
+
+ (let* ((map (make-keymap))
+ (esc-map (make-keymap))
+ (i 0))
+ (while (< i 128)
+ (define-key map (make-string 1 i) 'term-send-raw)
+ (define-key esc-map (make-string 1 i) 'term-send-raw-meta)
+ (setq i (1+ i)))
+ (dolist (elm (generic-character-list))
+ (define-key map (vector elm) 'term-send-raw))
+ (define-key map "\e" esc-map)
+ (setq term-raw-map map)
+ (setq term-raw-escape-map
+ (copy-keymap (lookup-key (current-global-map) "\C-x")))
+
+ ;;; Added nearly all the 'grey keys' -mm
+
+ (progn
+ (term-if-xemacs
+ (define-key term-raw-map [button2] 'term-mouse-paste))
+ (term-ifnot-xemacs
+ (define-key term-raw-map [mouse-2] 'term-mouse-paste)
+ (define-key term-raw-map [menu-bar terminal] term-terminal-menu)
+ (define-key term-raw-map [menu-bar signals] term-signals-menu))
+ (define-key term-raw-map [up] 'term-send-up)
+ (define-key term-raw-map [down] 'term-send-down)
+ (define-key term-raw-map [right] 'term-send-right)
+ (define-key term-raw-map [left] 'term-send-left)
+ (define-key term-raw-map [delete] 'term-send-del)
+ (define-key term-raw-map [backspace] 'term-send-backspace)
+ (define-key term-raw-map [home] 'term-send-home)
+ (define-key term-raw-map [end] 'term-send-end)
+ (define-key term-raw-map [prior] 'term-send-prior)
+ (define-key term-raw-map [next] 'term-send-next)))
+
+ (term-set-escape-char ?\C-c)
+
+ (defun term-window-width ()
+ (if (featurep 'xemacs)
+ (1- (window-width))
+ (if window-system
+ (window-width)
+ (1- (window-width)))))
+
+
+ (put 'term-mode 'mode-class 'special)
+
+ (defun term-mode ()
+ "Major mode for interacting with an inferior interpreter.
+ The interpreter name is same as buffer name, sans the asterisks.
+
+ There are two submodes: line mode and char mode. By default, you are
+ in char mode. In char sub-mode, each character (except
+ `term-escape-char') is set immediately.
+
+ In line mode, you send a line of input at a time; use
+ \\[term-send-input] to send.
+
+ In line mode, this maintains an input history of size
+ `term-input-ring-size', and you can access it with the commands
+ \\[term-next-input], \\[term-previous-input], and
+ \\[term-dynamic-list-input-ring]. Input ring history expansion can be
+ achieved with the commands \\[term-replace-by-expanded-history] or
+ \\[term-magic-space]. Input ring expansion is controlled by the
+ variable `term-input-autoexpand', and addition is controlled by the
+ variable `term-input-ignoredups'.
+
+ Input to, and output from, the subprocess can cause the window to scroll to
+ the end of the buffer. See variables `term-scroll-to-bottom-on-input',
+ and `term-scroll-to-bottom-on-output'.
+
+ If you accidentally suspend your process, use \\[term-continue-subjob]
+ to continue it.
+
+ This mode can be customised to create specific modes for running
+ particular subprocesses. This can be done by setting the hooks
+ `term-input-filter-functions', `term-input-filter',
+ `term-input-sender' and `term-get-old-input' to appropriate functions,
+ and the variable `term-prompt-regexp' to the appropriate regular
+ expression.
+
+ Commands in raw mode:
+
+ \\{term-raw-map}
+
+ Commands in line mode:
+
+ \\{term-mode-map}
+
+ Entry to this mode runs the hooks on `term-mode-hook'."
+ (interactive)
+ ;; Do not remove this. All major modes must do this.
+ (kill-all-local-variables)
+ (setq major-mode 'term-mode)
+ (setq mode-name "Term")
+ (use-local-map term-mode-map)
+ (make-local-variable 'term-home-marker)
+ (setq term-home-marker (copy-marker 0))
+ (make-local-variable 'term-saved-home-marker)
+ (make-local-variable 'term-height)
+ (make-local-variable 'term-width)
+ (setq term-width (term-window-width))
+ (setq term-height (1- (window-height)))
+ (term-ifnot-xemacs
+ (set (make-local-variable 'overflow-newline-into-fringe) nil))
+ (make-local-variable 'term-terminal-parameter)
+ (make-local-variable 'term-saved-cursor)
+ (make-local-variable 'term-last-input-start)
+ (setq term-last-input-start (make-marker))
+ (make-local-variable 'term-last-input-end)
+ (setq term-last-input-end (make-marker))
+ (make-local-variable 'term-last-input-match)
+ (setq term-last-input-match "")
+ (make-local-variable 'term-prompt-regexp) ; Don't set; default
+ (make-local-variable 'term-input-ring-size) ; ...to global val.
+ (make-local-variable 'term-input-ring)
+ (make-local-variable 'term-input-ring-file-name)
+ (or (and (boundp 'term-input-ring) term-input-ring)
+ (setq term-input-ring (make-ring term-input-ring-size)))
+ (make-local-variable 'term-input-ring-index)
+ (or (and (boundp 'term-input-ring-index) term-input-ring-index)
+ (setq term-input-ring-index nil))
+
+ (make-local-variable 'term-command-hook)
+ (setq term-command-hook (symbol-function 'term-command-hook))
+
+ ;;; I'm not sure these saves are necessary but, since I
+ ;;; haven't tested the whole thing on a net connected machine with
+ ;;; a properly configured ange-ftp, I've decided to be conservative
+ ;;; and put them in. -mm
+
+ (make-local-variable 'term-ansi-at-host)
+ (setq term-ansi-at-host (system-name))
+
+ (make-local-variable 'term-ansi-at-dir)
+ (setq term-ansi-at-dir default-directory)
+
+ (make-local-variable 'term-ansi-at-message)
+ (setq term-ansi-at-message nil)
+
+ ;;; For user tracking purposes -mm
+ (make-local-variable 'ange-ftp-default-user)
+ (make-local-variable 'ange-ftp-default-password)
+ (make-local-variable 'ange-ftp-generate-anonymous-password)
+
+ ;;; You may want to have different scroll-back sizes -mm
+ (make-local-variable 'term-buffer-maximum-size)
+
+ ;;; Of course these have to be buffer-local -mm
+ (make-local-variable 'term-ansi-current-bold)
+ (make-local-variable 'term-ansi-current-color)
+ (make-local-variable 'term-ansi-face-already-done)
+ (make-local-variable 'term-ansi-current-bg-color)
+ (make-local-variable 'term-ansi-current-underline)
+ (make-local-variable 'term-ansi-current-highlight)
+ (make-local-variable 'term-ansi-current-reverse)
+ (make-local-variable 'term-ansi-current-invisible)
+
+ (make-local-variable 'term-terminal-state)
+ (make-local-variable 'term-kill-echo-list)
+ (make-local-variable 'term-start-line-column)
+ (make-local-variable 'term-current-column)
+ (make-local-variable 'term-current-row)
+ (make-local-variable 'term-log-buffer)
+ (make-local-variable 'term-scroll-start)
+ (make-local-variable 'term-scroll-end)
+ (setq term-scroll-end term-height)
+ (make-local-variable 'term-scroll-with-delete)
+ (make-local-variable 'term-pager-count)
+ (make-local-variable 'term-pager-old-local-map)
+ (make-local-variable 'term-old-mode-map)
+ (make-local-variable 'term-insert-mode)
+ (make-local-variable 'term-dynamic-complete-functions)
+ (make-local-variable 'term-completion-fignore)
+ (make-local-variable 'term-get-old-input)
+ (make-local-variable 'term-matching-input-from-input-string)
+ (make-local-variable 'term-input-autoexpand)
+ (make-local-variable 'term-input-ignoredups)
+ (make-local-variable 'term-delimiter-argument-list)
+ (make-local-variable 'term-input-filter-functions)
+ (make-local-variable 'term-input-filter)
+ (make-local-variable 'term-input-sender)
+ (make-local-variable 'term-eol-on-send)
+ (make-local-variable 'term-scroll-to-bottom-on-output)
+ (make-local-variable 'term-scroll-show-maximum-output)
+ (make-local-variable 'term-ptyp)
+ (make-local-variable 'term-exec-hook)
+ (make-local-variable 'term-vertical-motion)
+ (make-local-variable 'term-pending-delete-marker)
+ (setq term-pending-delete-marker (make-marker))
+ (make-local-variable 'term-current-face)
+ (make-local-variable 'term-pending-frame)
+ (setq term-pending-frame nil)
+ (run-hooks 'term-mode-hook)
+ (term-if-xemacs
+ (set-buffer-menubar
+ (append current-menubar (list term-terminal-menu))))
+ (or term-input-ring
+ (setq term-input-ring (make-ring term-input-ring-size)))
+ (term-update-mode-line))
+
+ (defun term-reset-size (height width)
+ (setq term-height height)
+ (setq term-width width)
+ (setq term-start-line-column nil)
+ (setq term-current-row nil)
+ (setq term-current-column nil)
+ (term-scroll-region 0 height))
+
+ ;; Recursive routine used to check if any string in term-kill-echo-list
+ ;; matches part of the buffer before point.
+ ;; If so, delete that matched part of the buffer - this suppresses echo.
+ ;; Also, remove that string from the term-kill-echo-list.
+ ;; We *also* remove any older string on the list, as a sanity measure,
+ ;; in case something gets out of sync. (Except for type-ahead, there
+ ;; should only be one element in the list.)
+
+ (defun term-check-kill-echo-list ()
+ (let ((cur term-kill-echo-list) (found nil) (save-point (point)))
+ (unwind-protect
+ (progn
+ (end-of-line)
+ (while cur
+ (let* ((str (car cur)) (len (length str)) (start (- (point) len)))
+ (if (and (>= start (point-min))
+ (string= str (buffer-substring start (point))))
+ (progn (delete-backward-char len)
+ (setq term-kill-echo-list (cdr cur))
+ (setq term-current-column nil)
+ (setq term-current-row nil)
+ (setq term-start-line-column nil)
+ (setq cur nil found t))
+ (setq cur (cdr cur))))))
+ (if (not found)
+ (goto-char save-point)))
+ found))
+
+ (defun term-check-size (process)
+ (if (or (/= term-height (1- (window-height)))
+ (/= term-width (term-window-width)))
+ (progn
+ (term-reset-size (1- (window-height)) (term-window-width))
+ (set-process-window-size process term-height term-width))))
+
+ (defun term-send-raw-string (chars)
+ (let ((proc (get-buffer-process (current-buffer))))
+ (if (not proc)
+ (error "Current buffer has no process")
+ ;; Note that (term-current-row) must be called *after*
+ ;; (point) has been updated to (process-mark proc).
+ (goto-char (process-mark proc))
+ (if (term-pager-enabled)
+ (setq term-pager-count (term-current-row)))
+ (process-send-string proc chars))))
+
+ (defun term-send-raw ()
+ "Send the last character typed through the terminal-emulator
+ without any interpretation."
+ (interactive)
+ ;; Convert `return' to C-m, etc.
+ (if (and (symbolp last-input-char)
+ (get last-input-char 'ascii-character))
+ (setq last-input-char (get last-input-char 'ascii-character)))
+ (term-send-raw-string (make-string 1 last-input-char)))
+
+ (defun term-send-raw-meta ()
+ (interactive)
+ (let ((char last-input-char))
+ (when (symbolp last-input-char)
+ ;; Convert `return' to C-m, etc.
+ (let ((tmp (get char 'event-symbol-elements)))
+ (when tmp
+ (setq char (car tmp)))
+ (when (symbolp char)
+ (setq tmp (get char 'ascii-character))
+ (when tmp
+ (setq char tmp)))))
+ (setq char (event-basic-type char))
+ (term-send-raw-string (if (and (numberp char)
+ (> char 127)
+ (< char 256))
+ (make-string 1 char)
+ (format "\e%c" char)))))
+
+ (defun term-mouse-paste (click arg)
+ "Insert the last stretch of killed text at the position clicked on."
+ (interactive "e\nP")
+ (term-if-xemacs
+ (term-send-raw-string (or (condition-case () (x-get-selection) (error ()))
+ (x-get-cutbuffer)
+ (error "No selection or cut buffer available"))))
+ (term-ifnot-xemacs
+ ;; Give temporary modes such as isearch a chance to turn off.
+ (run-hooks 'mouse-leave-buffer-hook)
+ (setq this-command 'yank)
+ (mouse-set-point click)
+ (term-send-raw-string (current-kill (cond
+ ((listp arg) 0)
+ ((eq arg '-) -1)
+ (t (1- arg)))))))
+
+ ;; Which would be better: "\e[A" or "\eOA"? readline accepts either.
+ ;; For my configuration it's definitely better \eOA but YMMV. -mm
+ ;; For example: vi works with \eOA while elm wants \e[A ...
+ (defun term-send-up () (interactive) (term-send-raw-string "\eOA"))
+ (defun term-send-down () (interactive) (term-send-raw-string "\eOB"))
+ (defun term-send-right () (interactive) (term-send-raw-string "\eOC"))
+ (defun term-send-left () (interactive) (term-send-raw-string "\eOD"))
+ (defun term-send-home () (interactive) (term-send-raw-string "\e[1~"))
+ (defun term-send-end () (interactive) (term-send-raw-string "\e[4~"))
+ (defun term-send-prior () (interactive) (term-send-raw-string "\e[5~"))
+ (defun term-send-next () (interactive) (term-send-raw-string "\e[6~"))
+ (defun term-send-del () (interactive) (term-send-raw-string "\C-?"))
+ (defun term-send-backspace () (interactive) (term-send-raw-string "\C-H"))
+
+ (defun term-char-mode ()
+ "Switch to char (\"raw\") sub-mode of term mode.
+ Each character you type is sent directly to the inferior without
+ intervention from Emacs, except for the escape character (usually C-c)."
+ (interactive)
+ ;; FIXME: Emit message? Cfr ilisp-raw-message
+ (if (term-in-line-mode)
+ (progn
+ (setq term-old-mode-map (current-local-map))
+ (use-local-map term-raw-map)
+
+ ;; Send existing partial line to inferior (without newline).
+ (let ((pmark (process-mark (get-buffer-process (current-buffer))))
+ (save-input-sender term-input-sender))
+ (if (> (point) pmark)
+ (unwind-protect
+ (progn
+ (setq term-input-sender
+ (symbol-function 'term-send-string))
+ (end-of-line)
+ (term-send-input))
+ (setq term-input-sender save-input-sender))))
+ (term-update-mode-line))))
+
+ (defun term-line-mode ()
+ "Switch to line (\"cooked\") sub-mode of term mode.
+ This means that Emacs editing commands work as normally, until
+ you type \\[term-send-input] which sends the current line to the inferior."
+ (interactive)
+ (if (term-in-char-mode)
+ (progn
+ (use-local-map term-old-mode-map)
+ (term-update-mode-line))))
+
+ (defun term-update-mode-line ()
+ (setq mode-line-process
+ (if (term-in-char-mode)
+ (if (term-pager-enabled) '(": char page %s") '(": char %s"))
+ (if (term-pager-enabled) '(": line page %s") '(": line %s"))))
+ (force-mode-line-update))
+
+ (defun term-check-proc (buffer)
+ "True if there is a process associated w/buffer BUFFER, and
+ it is alive (status RUN or STOP). BUFFER can be either a buffer or the
+ name of one"
+ (let ((proc (get-buffer-process buffer)))
+ (and proc (memq (process-status proc) '(run stop)))))
+
+ ;;;###autoload
+ (defun make-term (name program &optional startfile &rest switches)
+ "Make a term 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."
+ (let ((buffer (get-buffer-create (concat "*" name "*"))))
+ ;; If no process, or nuked process, crank up a new one and put buffer in
+ ;; term mode. Otherwise, leave buffer and existing process alone.
+ (cond ((not (term-check-proc buffer))
+ (save-excursion
+ (set-buffer buffer)
+ (term-mode)) ; Install local vars, mode, keymap, ...
+ (term-exec buffer name program startfile switches)))
+ buffer))
+
+ ;;;###autoload
+ (defun term (program)
+ "Start a terminal-emulator in a new buffer.
+ The buffer is in Term mode; see `term-mode' for the
+ commands to use in that buffer.
+
+ \\<term-raw-map>Type \\[switch-to-buffer] to switch to another buffer."
+ (interactive (list (read-from-minibuffer "Run program: "
+ (or explicit-shell-file-name
+ (getenv "ESHELL")
+ (getenv "SHELL")
+ "/bin/sh"))))
+ (set-buffer (make-term "terminal" program))
+ (term-mode)
+ (term-char-mode)
+ (switch-to-buffer "*terminal*"))
+
+ (defun term-exec (buffer name command startfile switches)
+ "Start up a process in buffer for term 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 term
+ buffer. The hook term-exec-hook is run after each exec."
+ (save-excursion
+ (set-buffer buffer)
+ (let ((proc (get-buffer-process buffer))) ; Blast any old process.
+ (if proc (delete-process proc)))
+ ;; Crank up a new process
+ (let ((proc (term-exec-1 name buffer command switches)))
+ (make-local-variable 'term-ptyp)
+ (setq term-ptyp process-connection-type) ; t if pty, nil if pipe.
+ ;; Jump to the end, and set the process mark.
+ (goto-char (point-max))
+ (set-marker (process-mark proc) (point))
+ (set-process-filter proc 'term-emulate-terminal)
+ (set-process-sentinel proc 'term-sentinel)
+ ;; Feed it the startfile.
+ (cond (startfile
+ ;;This is guaranteed to wait long enough
+ ;;but has bad results if the term does not prompt at all
+ ;; (while (= size (buffer-size))
+ ;; (sleep-for 1))
+ ;;I hope 1 second is enough!
+ (sleep-for 1)
+ (goto-char (point-max))
+ (insert-file-contents startfile)
+ (setq startfile (buffer-substring (point) (point-max)))
+ (delete-region (point) (point-max))
+ (term-send-string proc startfile)))
+ (run-hooks 'term-exec-hook)
+ buffer)))
+
+ (defun term-sentinel (proc msg)
+ "Sentinel for term buffers.
+ The main purpose is to get rid of the local keymap."
+ (let ((buffer (process-buffer proc)))
+ (if (memq (process-status proc) '(signal exit))
+ (progn
+ (if (null (buffer-name buffer))
+ ;; buffer killed
+ (set-process-buffer proc nil)
+ (let ((obuf (current-buffer)))
+ ;; save-excursion isn't the right thing if
+ ;; process-buffer is current-buffer
+ (unwind-protect
+ (progn
+ ;; Write something in the compilation buffer
+ ;; and hack its mode line.
+ (set-buffer buffer)
+ ;; Get rid of local keymap.
+ (use-local-map nil)
+ (term-handle-exit (process-name proc)
+ msg)
+ ;; Since the buffer and mode line will show that the
+ ;; process is dead, we can delete it now. Otherwise it
+ ;; will stay around until M-x list-processes.
+ (delete-process proc))
+ (set-buffer obuf))))
+ ))))
+
+ (defun term-handle-exit (process-name msg)
+ "Write process exit (or other change) message MSG in the current buffer."
+ (let ((buffer-read-only nil)
+ (omax (point-max))
+ (opoint (point)))
+ ;; Record where we put the message, so we can ignore it
+ ;; later on.
+ (goto-char omax)
+ (insert ?\n "Process " process-name " " msg)
+ ;; Force mode line redisplay soon.
+ (force-mode-line-update)
+ (if (and opoint (< opoint omax))
+ (goto-char opoint))))
+
+
+ ;;; Name to use for TERM.
+ ;;; Using "emacs" loses, because bash disables editing if TERM == emacs.
+ (defvar term-term-name "eterm")
+ ; Format string, usage:
+ ; (format term-termcap-string emacs-term-name "TERMCAP=" 24 80)
+ (defvar term-termcap-format
+ "%s%s:li#%d:co#%d:cl=\\E[H\\E[J:cd=\\E[J:bs:am:xn:cm=\\E[%%i%%d;%%dH\
+ :nd=\\E[C:up=\\E[A:ce=\\E[K:ho=\\E[H:pt\
+ :al=\\E[L:dl=\\E[M:DL=\\E[%%dM:AL=\\E[%%dL:cs=\\E[%%i%%d;%%dr:sf=\\n\
+ :te=\\E[2J\\E[?47l\\E8:ti=\\E7\\E[?47h\
+ :dc=\\E[P:DC=\\E[%%dP:IC=\\E[%%d@:im=\\E[4h:ei=\\E[4l:mi:\
+ :so=\\E[7m:se=\\E[m:us=\\E[4m:ue=\\E[m:md=\\E[1m:mr=\\E[7m:me=\\E[m\
+ :UP=\\E[%%dA:DO=\\E[%%dB:LE=\\E[%%dD:RI=\\E[%%dC"
+ ;;; : -undefine ic
+ "termcap capabilities supported")
+
+ ;;; This auxiliary function cranks up the process for term-exec in
+ ;;; the appropriate environment.
+
+ (defun term-exec-1 (name buffer command switches)
+ ;; We need to do an extra (fork-less) exec to run stty.
+ ;; (This would not be needed if we had suitable Emacs primitives.)
+ ;; The 'if ...; then shift; fi' hack is because Bourne shell
+ ;; loses one arg when called with -c, and newer shells (bash, ksh) don't.
+ ;; Thus we add an extra dummy argument "..", and then remove it.
+ (let ((process-environment
+ (nconc
+ (list
+ (format "TERM=%s" term-term-name)
+ (if (and (boundp 'system-uses-terminfo) system-uses-terminfo)
+ (format "TERMINFO=%s" data-directory)
+ (format term-termcap-format "TERMCAP="
+ term-term-name term-height term-width))
+ ;; Breaks `./configure' of w3 and url which try to run $EMACS.
+ (format "EMACS=%s (term:%s)" emacs-version term-protocol-version)
+ (format "LINES=%d" term-height)
+ (format "COLUMNS=%d" term-width))
+ process-environment))
+ (process-connection-type t)
+ ;; We should suppress conversion of end-of-line format.
+ (inhibit-eol-conversion t)
+ ;; inhibit-eol-conversion doesn't seem to do the job, but this does.
+ (coding-system-for-read 'unknown-unix)
+ )
+ (apply 'start-process name buffer
+ "/bin/sh" "-c"
+ (format "stty -nl echo rows %d columns %d sane 2>/dev/null;\
+ if [ $1 = .. ]; then shift; fi; exec \"address@hidden""
+ term-height term-width)
+ ".."
+ command switches)))
+
+ ;;; This should be in Emacs, but it isn't.
+ (defun term-mem (item list &optional elt=)
+ "Test to see if ITEM is equal to an item in LIST.
+ Option comparison function ELT= defaults to equal."
+ (let ((elt= (or elt= (function equal)))
+ (done nil))
+ (while (and list (not done))
+ (if (funcall elt= item (car list))
+ (setq done list)
+ (setq list (cdr list))))
+ done))
+
+
+ ;;; Input history processing in a buffer
+ ;;;
===========================================================================
+ ;;; Useful input history functions, courtesy of the Ergo group.
+
+ ;;; Eleven commands:
+ ;;; term-dynamic-list-input-ring List history in help buffer.
+ ;;; term-previous-input Previous input...
+ ;;; term-previous-matching-input ...matching a string.
+ ;;; term-previous-matching-input-from-input ... matching the current input.
+ ;;; term-next-input Next input...
+ ;;; term-next-matching-input ...matching a string.
+ ;;; term-next-matching-input-from-input ... matching the current input.
+ ;;; term-backward-matching-input Backwards input...
+ ;;; term-forward-matching-input ...matching a string.
+ ;;; term-replace-by-expanded-history Expand history at point;
+ ;;; replace with expanded history.
+ ;;; term-magic-space Expand history and insert space.
+ ;;;
+ ;;; Three functions:
+ ;;; term-read-input-ring Read into term-input-ring...
+ ;;; term-write-input-ring Write to term-input-ring-file-name.
+ ;;; term-replace-by-expanded-history-before-point Workhorse function.
+
+ (defun term-read-input-ring (&optional silent)
+ "Sets the buffer's `term-input-ring' from a history file.
+ The name of the file is given by the variable `term-input-ring-file-name'.
+ The history ring is of size `term-input-ring-size', regardless of file size.
+ If `term-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 `term-input-ignoredups' and `term-write-input-ring'."
+ (cond ((or (null term-input-ring-file-name)
+ (equal term-input-ring-file-name ""))
+ nil)
+ ((not (file-readable-p term-input-ring-file-name))
+ (or silent
+ (message "Cannot read history file %s"
+ term-input-ring-file-name)))
+ (t
+ (let ((history-buf (get-buffer-create " *temp*"))
+ (file term-input-ring-file-name)
+ (count 0)
+ (ring (make-ring term-input-ring-size)))
+ (unwind-protect
+ (save-excursion
+ (set-buffer history-buf)
+ (widen)
+ (erase-buffer)
+ (insert-file-contents file)
+ ;; Save restriction in case file is already visited...
+ ;; Watch for those date stamps in history files!
+ (goto-char (point-max))
+ (while (and (< count term-input-ring-size)
+ (re-search-backward "^[ \t]*\\([^#\n].*\\)[ \t]*$"
+ nil t))
+ (let ((history (buffer-substring (match-beginning 1)
+ (match-end 1))))
+ (if (or (null term-input-ignoredups)
+ (ring-empty-p ring)
+ (not (string-equal (ring-ref ring 0) history)))
+ (ring-insert-at-beginning ring history)))
+ (setq count (1+ count))))
+ (kill-buffer history-buf))
+ (setq term-input-ring ring
+ term-input-ring-index nil)))))
+
+ (defun term-write-input-ring ()
+ "Writes the buffer's `term-input-ring' to a history file.
+ The name of the file is given by the variable `term-input-ring-file-name'.
+ The original contents of the file are lost if `term-input-ring' is not empty.
+ If `term-input-ring-file-name' is nil this function does nothing.
+
+ Useful within process sentinels.
+
+ See also `term-read-input-ring'."
+ (cond ((or (null term-input-ring-file-name)
+ (equal term-input-ring-file-name "")
+ (null term-input-ring) (ring-empty-p term-input-ring))
+ nil)
+ ((not (file-writable-p term-input-ring-file-name))
+ (message "Cannot write history file %s" term-input-ring-file-name))
+ (t
+ (let* ((history-buf (get-buffer-create " *Temp Input History*"))
+ (ring term-input-ring)
+ (file term-input-ring-file-name)
+ (index (ring-length ring)))
+ ;; Write it all out into a buffer first. Much faster, but messier,
+ ;; than writing it one line at a time.
+ (save-excursion
+ (set-buffer history-buf)
+ (erase-buffer)
+ (while (> index 0)
+ (setq index (1- index))
+ (insert (ring-ref ring index) ?\n))
+ (write-region (buffer-string) nil file nil 'no-message)
+ (kill-buffer nil))))))
+
+
+ (defun term-dynamic-list-input-ring ()
+ "List in help buffer the buffer's input history."
+ (interactive)
+ (if (or (not (ring-p term-input-ring))
+ (ring-empty-p term-input-ring))
+ (message "No history")
+ (let ((history nil)
+ (history-buffer " *Input History*")
+ (index (1- (ring-length term-input-ring)))
+ (conf (current-window-configuration)))
+ ;; We have to build up a list ourselves from the ring vector.
+ (while (>= index 0)
+ (setq history (cons (ring-ref term-input-ring index) history)
+ index (1- index)))
+ ;; Change "completion" to "history reference"
+ ;; to make the display accurate.
+ (with-output-to-temp-buffer history-buffer
+ (display-completion-list history)
+ (set-buffer history-buffer)
+ (forward-line 3)
+ (while (search-backward "completion" nil 'move)
+ (replace-match "history reference")))
+ (sit-for 0)
+ (message "Hit space to flush")
+ (let ((ch (read-event)))
+ (if (eq ch ?\ )
+ (set-window-configuration conf)
+ (setq unread-command-events (list ch)))))))
+
+
+ (defun term-regexp-arg (prompt)
+ ;; Return list of regexp and prefix arg using PROMPT.
+ (let* (;; Don't clobber this.
+ (last-command last-command)
+ (regexp (read-from-minibuffer prompt nil nil nil
+ 'minibuffer-history-search-history)))
+ (list (if (string-equal regexp "")
+ (setcar minibuffer-history-search-history
+ (nth 1 minibuffer-history-search-history))
+ regexp)
+ (prefix-numeric-value current-prefix-arg))))
+
+ (defun term-search-arg (arg)
+ ;; First make sure there is a ring and that we are after the process mark
+ (cond ((not (term-after-pmark-p))
+ (error "Not at command line"))
+ ((or (null term-input-ring)
+ (ring-empty-p term-input-ring))
+ (error "Empty input ring"))
+ ((zerop arg)
+ ;; arg of zero resets search from beginning, and uses arg of 1
+ (setq term-input-ring-index nil)
+ 1)
+ (t
+ arg)))
+
+ (defun term-search-start (arg)
+ ;; Index to start a directional search, starting at term-input-ring-index
+ (if term-input-ring-index
+ ;; If a search is running, offset by 1 in direction of arg
+ (mod (+ term-input-ring-index (if (> arg 0) 1 -1))
+ (ring-length term-input-ring))
+ ;; For a new search, start from beginning or end, as appropriate
+ (if (>= arg 0)
+ 0 ; First elt for forward search
+ (1- (ring-length term-input-ring))))) ; Last elt for backward search
+
+ (defun term-previous-input-string (arg)
+ "Return the string ARG places along the input ring.
+ Moves relative to `term-input-ring-index'."
+ (ring-ref term-input-ring (if term-input-ring-index
+ (mod (+ arg term-input-ring-index)
+ (ring-length term-input-ring))
+ arg)))
+
+ (defun term-previous-input (arg)
+ "Cycle backwards through input history."
+ (interactive "*p")
+ (term-previous-matching-input "." arg))
+
+ (defun term-next-input (arg)
+ "Cycle forwards through input history."
+ (interactive "*p")
+ (term-previous-input (- arg)))
+
+ (defun term-previous-matching-input-string (regexp arg)
+ "Return the string matching REGEXP ARG places along the input ring.
+ Moves relative to `term-input-ring-index'."
+ (let* ((pos (term-previous-matching-input-string-position regexp arg)))
+ (if pos (ring-ref term-input-ring pos))))
+
+ (defun term-previous-matching-input-string-position
+ (regexp arg &optional start)
+ "Return the index matching REGEXP ARG places along the input ring.
+ Moves relative to START, or `term-input-ring-index'."
+ (if (or (not (ring-p term-input-ring))
+ (ring-empty-p term-input-ring))
+ (error "No history"))
+ (let* ((len (ring-length term-input-ring))
+ (motion (if (> arg 0) 1 -1))
+ (n (mod (- (or start (term-search-start arg)) motion) len))
+ (tried-each-ring-item nil)
+ (prev nil))
+ ;; Do the whole search as many times as the argument says.
+ (while (and (/= arg 0) (not tried-each-ring-item))
+ ;; Step once.
+ (setq prev n
+ n (mod (+ n motion) len))
+ ;; If we haven't reached a match, step some more.
+ (while (and (< n len) (not tried-each-ring-item)
+ (not (string-match regexp (ring-ref term-input-ring n))))
+ (setq n (mod (+ n motion) len)
+ ;; If we have gone all the way around in this search.
+ tried-each-ring-item (= n prev)))
+ (setq arg (if (> arg 0) (1- arg) (1+ arg))))
+ ;; Now that we know which ring element to use, if we found it, return
that.
+ (if (string-match regexp (ring-ref term-input-ring n))
+ n)))
+
+ (defun term-previous-matching-input (regexp arg)
+ "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."
+ (interactive (term-regexp-arg "Previous input matching (regexp): "))
+ (setq arg (term-search-arg arg))
+ (let ((pos (term-previous-matching-input-string-position regexp arg)))
+ ;; Has a match been found?
+ (if (null pos)
+ (error "Not found")
+ (setq term-input-ring-index pos)
+ (message "History item: %d" (1+ pos))
+ (delete-region
+ ;; Can't use kill-region as it sets this-command
+ (process-mark (get-buffer-process (current-buffer))) (point))
+ (insert (ring-ref term-input-ring pos)))))
+
+ (defun term-next-matching-input (regexp arg)
+ "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."
+ (interactive (term-regexp-arg "Next input matching (regexp): "))
+ (term-previous-matching-input regexp (- arg)))
+
+ (defun term-previous-matching-input-from-input (arg)
+ "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."
+ (interactive "p")
+ (if (not (memq last-command '(term-previous-matching-input-from-input
+ term-next-matching-input-from-input)))
+ ;; Starting a new search
+ (setq term-matching-input-from-input-string
+ (buffer-substring
+ (process-mark (get-buffer-process (current-buffer)))
+ (point))
+ term-input-ring-index nil))
+ (term-previous-matching-input
+ (concat "^" (regexp-quote term-matching-input-from-input-string))
+ arg))
+
+ (defun term-next-matching-input-from-input (arg)
+ "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."
+ (interactive "p")
+ (term-previous-matching-input-from-input (- arg)))
+
+
+ (defun term-replace-by-expanded-history (&optional silent)
+ "Expand input command history references before point.
+ Expansion is dependent on the value of `term-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.
+
+ See `term-magic-space' and `term-replace-by-expanded-history-before-point'.
+
+ Returns t if successful."
+ (interactive)
+ (if (and term-input-autoexpand
+ (string-match "[!^]" (funcall term-get-old-input))
+ (save-excursion (beginning-of-line)
+ (looking-at term-prompt-regexp)))
+ ;; Looks like there might be history references in the command.
+ (let ((previous-modified-tick (buffer-modified-tick)))
+ (message "Expanding history references...")
+ (term-replace-by-expanded-history-before-point silent)
+ (/= previous-modified-tick (buffer-modified-tick)))))
+
+
+ (defun term-replace-by-expanded-history-before-point (silent)
+ "Expand directory stack reference before point.
+ See `term-replace-by-expanded-history'. Returns t if successful."
+ (save-excursion
+ (let ((toend (- (save-excursion (end-of-line nil) (point)) (point)))
+ (start (progn (term-bol nil) (point))))
+ (while (progn
+ (skip-chars-forward "^!^"
+ (save-excursion
+ (end-of-line nil) (- (point) toend)))
+ (< (point)
+ (save-excursion
+ (end-of-line nil) (- (point) toend))))
+ ;; This seems a bit complex. We look for references such as !!, !-num,
+ ;; !foo, !?foo, !{bar}, !?{bar}, ^oh, ^my^, ^god^it, ^never^ends^.
+ ;; If that wasn't enough, the plings can be suffixed with argument
+ ;; range specifiers.
+ ;; Argument ranges are complex too, so we hive off the input line,
+ ;; referenced with plings, with the range string to `term-args'.
+ (setq term-input-ring-index nil)
+ (cond ((or (= (preceding-char) ?\\)
+ (term-within-quotes start (point)))
+ ;; The history is quoted, or we're in quotes.
+ (goto-char (1+ (point))))
+ ((looking-at "![0-9]+\\($\\|[^-]\\)")
+ ;; We cannot know the interpreter's idea of input line numbers.
+ (goto-char (match-end 0))
+ (message "Absolute reference cannot be expanded"))
+ ((looking-at "!-\\([0-9]+\\)\\(:?[0-9^$*-]+\\)?")
+ ;; Just a number of args from `number' lines backward.
+ (let ((number (1- (string-to-number
+ (buffer-substring (match-beginning 1)
+ (match-end 1))))))
+ (if (<= number (ring-length term-input-ring))
+ (progn
+ (replace-match
+ (term-args (term-previous-input-string number)
+ (match-beginning 2) (match-end 2))
+ t t)
+ (setq term-input-ring-index number)
+ (message "History item: %d" (1+ number)))
+ (goto-char (match-end 0))
+ (message "Relative reference exceeds input history size"))))
+ ((or (looking-at "!!?:?\\([0-9^$*-]+\\)") (looking-at "!!"))
+ ;; Just a number of args from the previous input line.
+ (replace-match
+ (term-args (term-previous-input-string 0)
+ (match-beginning 1) (match-end 1))
+ t t)
+ (message "History item: previous"))
+ ((looking-at
+ "!\\??\\({\\(.+\\)}\\|\\(\\sw+\\)\\)\\(:?[0-9^$*-]+\\)?")
+ ;; Most recent input starting with or containing (possibly
+ ;; protected) string, maybe just a number of args. Phew.
+ (let* ((mb1 (match-beginning 1)) (me1 (match-end 1))
+ (mb2 (match-beginning 2)) (me2 (match-end 2))
+ (exp (buffer-substring (or mb2 mb1) (or me2 me1)))
+ (pref (if (save-match-data (looking-at "!\\?")) "" "^"))
+ (pos (save-match-data
+ (term-previous-matching-input-string-position
+ (concat pref (regexp-quote exp)) 1))))
+ (if (null pos)
+ (progn
+ (goto-char (match-end 0))
+ (or silent
+ (progn (message "Not found")
+ (ding))))
+ (setq term-input-ring-index pos)
+ (replace-match
+ (term-args (ring-ref term-input-ring pos)
+ (match-beginning 4) (match-end 4))
+ t t)
+ (message "History item: %d" (1+ pos)))))
+ ((looking-at "\\^\\([^^]+\\)\\^?\\([^^]*\\)\\^?")
+ ;; Quick substitution on the previous input line.
+ (let ((old (buffer-substring (match-beginning 1) (match-end 1)))
+ (new (buffer-substring (match-beginning 2) (match-end 2)))
+ (pos nil))
+ (replace-match (term-previous-input-string 0) t t)
+ (setq pos (point))
+ (goto-char (match-beginning 0))
+ (if (not (search-forward old pos t))
+ (or silent
+ (error "Not found"))
+ (replace-match new t t)
+ (message "History item: substituted"))))
+ (t
+ (goto-char (match-end 0))))))))
+
+
+ (defun term-magic-space (arg)
+ "Expand input history references before point and insert ARG spaces.
+ A useful command to bind to SPC. See `term-replace-by-expanded-history'."
+ (interactive "p")
+ (term-replace-by-expanded-history)
+ (self-insert-command arg))
+
+ (defun term-within-quotes (beg end)
+ "Return t if the number of quotes between BEG and END is odd.
+ Quotes are single and double."
+ (let ((countsq (term-how-many-region "\\(^\\|[^\\\\]\\)\'" beg end))
+ (countdq (term-how-many-region "\\(^\\|[^\\\\]\\)\"" beg end)))
+ (or (= (mod countsq 2) 1) (= (mod countdq 2) 1))))
+
+ (defun term-how-many-region (regexp beg end)
+ "Return number of matches for REGEXP from BEG to END."
+ (let ((count 0))
+ (save-excursion
+ (save-match-data
+ (goto-char beg)
+ (while (re-search-forward regexp end t)
+ (setq count (1+ count)))))
+ count))
+
+ (defun term-args (string begin end)
+ ;; From STRING, return the args depending on the range specified in the text
+ ;; from BEGIN to END. If BEGIN is nil, assume all args. Ignore leading
`:'.
+ ;; Range can be x-y, x-, -y, where x/y can be [0-9], *, ^, $.
+ (save-match-data
+ (if (null begin)
+ (term-arguments string 0 nil)
+ (let* ((range (buffer-substring
+ (if (eq (char-after begin) ?:) (1+ begin) begin) end))
+ (nth (cond ((string-match "^[*^]" range) 1)
+ ((string-match "^-" range) 0)
+ ((string-equal range "$") nil)
+ (t (string-to-number range))))
+ (mth (cond ((string-match "[-*$]$" range) nil)
+ ((string-match "-" range)
+ (string-to-number (substring range (match-end 0))))
+ (t nth))))
+ (term-arguments string nth mth)))))
+
+ ;; Return a list of arguments from ARG. Break it up at the
+ ;; delimiters in term-delimiter-argument-list. Returned list is backwards.
+ (defun term-delim-arg (arg)
+ (if (null term-delimiter-argument-list)
+ (list arg)
+ (let ((args nil)
+ (pos 0)
+ (len (length arg)))
+ (while (< pos len)
+ (let ((char (aref arg pos))
+ (start pos))
+ (if (memq char term-delimiter-argument-list)
+ (while (and (< pos len) (eq (aref arg pos) char))
+ (setq pos (1+ pos)))
+ (while (and (< pos len)
+ (not (memq (aref arg pos)
+ term-delimiter-argument-list)))
+ (setq pos (1+ pos))))
+ (setq args (cons (substring arg start pos) args))))
+ args)))
+
+ (defun term-arguments (string nth mth)
+ "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 `term-delimiter-argument-list' is a separate argument.
+ Argument 0 is the command name."
+ (let ((argpart "[^ \n\t\"'`]+\\|\\(\"[^\"]*\"\\|'[^']*'\\|`[^`]*`\\)")
+ (args ()) (pos 0)
+ (count 0)
+ beg str quotes)
+ ;; Build a list of all the args until we have as many as we want.
+ (while (and (or (null mth) (<= count mth))
+ (string-match argpart string pos))
+ (if (and beg (= pos (match-beginning 0)))
+ ;; It's contiguous, part of the same arg.
+ (setq pos (match-end 0)
+ quotes (or quotes (match-beginning 1)))
+ ;; It's a new separate arg.
+ (if beg
+ ;; Put the previous arg, if there was one, onto ARGS.
+ (setq str (substring string beg pos)
+ args (if quotes (cons str args)
+ (nconc (term-delim-arg str) args))
+ count (1+ count)))
+ (setq quotes (match-beginning 1))
+ (setq beg (match-beginning 0))
+ (setq pos (match-end 0))))
+ (if beg
+ (setq str (substring string beg pos)
+ args (if quotes (cons str args)
+ (nconc (term-delim-arg str) args))
+ count (1+ count)))
+ (let ((n (or nth (1- count)))
+ (m (if mth (1- (- count mth)) 0)))
+ (mapconcat
+ (function (lambda (a) a)) (nthcdr n (nreverse (nthcdr m args))) " "))))
+
+ ;;;
+ ;;; Input processing stuff [line mode]
+ ;;;
+
+ (defun term-send-input ()
+ "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 term-get-old-input to retrieve old input, copies it to the
+ process mark, and sends it. A terminal newline is also inserted into the
+ buffer and sent to the process. The list of function names contained in the
+ value of `term-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
+ term-input-filter returns non-nil when called on the input.
+
+ Any history reference may be expanded depending on the value of the variable
+ `term-input-autoexpand'. The list of function names contained in the value
+ of `term-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
+ `term-input-filter' returns non-nil when called on the input.
+
+ If variable `term-eol-on-send' is non-nil, then point is moved to the
+ end of line before sending the input.
+
+ The values of `term-get-old-input', `term-input-filter-functions', and
+ `term-input-filter' are chosen according to the command interpreter running
+ in the buffer. E.g.,
+
+ If the interpreter is the csh,
+ term-get-old-input is the default: take the current line, discard any
+ initial string matching regexp term-prompt-regexp.
+ term-input-filter-functions monitors input for \"cd\", \"pushd\", and
+ \"popd\" commands. When it sees one, it cd's the buffer.
+ term-input-filter is the default: returns t if the input isn't all white
+ space.
+
+ If the term is Lucid Common Lisp,
+ term-get-old-input snarfs the sexp ending at point.
+ term-input-filter-functions does nothing.
+ term-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."
+ (interactive)
+ ;; Note that the input string does not include its terminal newline.
+ (let ((proc (get-buffer-process (current-buffer))))
+ (if (not proc) (error "Current buffer has no process")
+ (let* ((pmark (process-mark proc))
+ (pmark-val (marker-position pmark))
+ (input-is-new (>= (point) pmark-val))
+ (intxt (if input-is-new
+ (progn (if term-eol-on-send (end-of-line))
+ (buffer-substring pmark (point)))
+ (funcall term-get-old-input)))
+ (input (if (not (eq term-input-autoexpand 'input))
+ ;; Just whatever's already there
+ intxt
+ ;; Expand and leave it visible in buffer
+ (term-replace-by-expanded-history t)
+ (buffer-substring pmark (point))))
+ (history (if (not (eq term-input-autoexpand 'history))
+ input
+ ;; This is messy 'cos ultimately the original
+ ;; functions used do insertion, rather than return
+ ;; strings. We have to expand, then insert back.
+ (term-replace-by-expanded-history t)
+ (let ((copy (buffer-substring pmark (point))))
+ (delete-region pmark (point))
+ (insert input)
+ copy))))
+ (if (term-pager-enabled)
+ (save-excursion
+ (goto-char (process-mark proc))
+ (setq term-pager-count (term-current-row))))
+ (if (and (funcall term-input-filter history)
+ (or (null term-input-ignoredups)
+ (not (ring-p term-input-ring))
+ (ring-empty-p term-input-ring)
+ (not (string-equal (ring-ref term-input-ring 0)
+ history))))
+ (ring-insert term-input-ring history))
+ (let ((functions term-input-filter-functions))
+ (while functions
+ (funcall (car functions) (concat input "\n"))
+ (setq functions (cdr functions))))
+ (setq term-input-ring-index nil)
+
+ ;; Update the markers before we send the input
+ ;; in case we get output amidst sending the input.
+ (set-marker term-last-input-start pmark)
+ (set-marker term-last-input-end (point))
+ (if input-is-new
+ (progn
+ ;; Set up to delete, because inferior should echo.
+ (if (marker-buffer term-pending-delete-marker)
+ (delete-region term-pending-delete-marker pmark))
+ (set-marker term-pending-delete-marker pmark-val)
+ (set-marker (process-mark proc) (point))))
+ (goto-char pmark)
+ (funcall term-input-sender proc input)))))
+
+ (defun term-get-old-input-default ()
+ "Default for term-get-old-input.
+ Take the current line, and discard any initial text matching
+ term-prompt-regexp."
+ (save-excursion
+ (beginning-of-line)
+ (term-skip-prompt)
+ (let ((beg (point)))
+ (end-of-line)
+ (buffer-substring beg (point)))))
+
+ (defun term-copy-old-input ()
+ "Insert after prompt old input at point as new input to be edited.
+ Calls `term-get-old-input' to get old input."
+ (interactive)
+ (let ((input (funcall term-get-old-input))
+ (process (get-buffer-process (current-buffer))))
+ (if (not process)
+ (error "Current buffer has no process")
+ (goto-char (process-mark process))
+ (insert input))))
+
+ (defun term-skip-prompt ()
+ "Skip past the text matching regexp term-prompt-regexp.
+ If this takes us past the end of the current line, don't skip at all."
+ (let ((eol (save-excursion (end-of-line) (point))))
+ (if (and (looking-at term-prompt-regexp)
+ (<= (match-end 0) eol))
+ (goto-char (match-end 0)))))
+
+
+ (defun term-after-pmark-p ()
+ "Is point after the process output marker?"
+ ;; Since output could come into the buffer after we looked at the point
+ ;; but before we looked at the process marker's value, we explicitly
+ ;; serialise. This is just because I don't know whether or not Emacs
+ ;; services input during execution of lisp commands.
+ (let ((proc-pos (marker-position
+ (process-mark (get-buffer-process (current-buffer))))))
+ (<= proc-pos (point))))
+
+ (defun term-simple-send (proc string)
+ "Default function for sending to PROC input STRING.
+ This just sends STRING plus a newline. To override this,
+ set the hook TERM-INPUT-SENDER."
+ (term-send-string proc string)
+ (term-send-string proc "\n"))
+
+ (defun term-bol (arg)
+ "Goes to the beginning of line, then skips past the prompt, if any.
+ If a prefix argument is given (\\[universal-argument]), then no prompt skip
+ -- go straight to column 0.
+
+ The prompt skip is done by skipping text matching the regular expression
+ term-prompt-regexp, a buffer local variable."
+ (interactive "P")
+ (beginning-of-line)
+ (if (null arg) (term-skip-prompt)))
+
+ ;;; These two functions are for entering text you don't want echoed or
+ ;;; saved -- typically passwords to ftp, telnet, or somesuch.
+ ;;; Just enter m-x term-send-invisible and type in your line.
+
+ (defun term-read-noecho (prompt &optional stars)
+ "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]. This may be a security bug for some
+ applications."
+ (let ((ans "")
+ (c 0)
+ (echo-keystrokes 0)
+ (cursor-in-echo-area t)
+ (done nil))
+ (while (not done)
+ (if stars
+ (message "%s%s" prompt (make-string (length ans) ?*))
+ (message "%s" prompt))
+ (setq c (read-char))
+ (cond ((= c ?\C-g)
+ ;; This function may get called from a process filter, where
+ ;; inhibit-quit is set. In later versions of Emacs read-char
+ ;; may clear quit-flag itself and return C-g. That would make
+ ;; it impossible to quit this loop in a simple way, so
+ ;; re-enable it here (for backward-compatibility the check for
+ ;; quit-flag below would still be necessary, so this seems
+ ;; like the simplest way to do things).
+ (setq quit-flag t
+ done t))
+ ((or (= c ?\r) (= c ?\n) (= c ?\e))
+ (setq done t))
+ ((= c ?\C-u)
+ (setq ans ""))
+ ((and (/= c ?\b) (/= c ?\177))
+ (setq ans (concat ans (char-to-string c))))
+ ((> (length ans) 0)
+ (setq ans (substring ans 0 -1)))))
+ (if quit-flag
+ ;; Emulate a true quit, except that we have to return a value.
+ (prog1
+ (setq quit-flag nil)
+ (message "Quit")
+ (beep t))
+ (message "")
+ ans)))
+
+ (defun term-send-invisible (str &optional proc)
+ "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 term input history list.
+ Security bug: your string can still be temporarily recovered with
+ \\[view-lossage]."
+ (interactive "P") ; Defeat snooping via C-x esc
+ (if (not (stringp str))
+ (setq str (term-read-noecho "Non-echoed text: " t)))
+ (if (not proc)
+ (setq proc (get-buffer-process (current-buffer))))
+ (if (not proc) (error "Current buffer has no process")
+ (setq term-kill-echo-list (nconc term-kill-echo-list
+ (cons str nil)))
+ (term-send-string proc str)
+ (term-send-string proc "\n")))
+
+
+ ;;; Low-level process communication
+
+ (defvar term-input-chunk-size 512
+ "*Long inputs send to term processes are broken up into chunks of this size.
+ If your process is choking on big inputs, try lowering the value.")
+
+ (defun term-send-string (proc str)
+ "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 term-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."
+ (let* ((len (length str))
+ (i (min len term-input-chunk-size)))
+ (process-send-string proc (substring str 0 i))
+ (while (< i len)
+ (let ((next-i (+ i term-input-chunk-size)))
+ (accept-process-output)
+ (process-send-string proc (substring str i (min len next-i)))
+ (setq i next-i)))))
+
+ (defun term-send-region (proc start end)
+ "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 term-send-string."
+ (term-send-string proc (buffer-substring start end)))
+
+
+ ;;; Random input hackage
+
+ (defun term-kill-output ()
+ "Kill all output from interpreter since last input."
+ (interactive)
+ (let ((pmark (process-mark (get-buffer-process (current-buffer)))))
+ (kill-region term-last-input-end pmark)
+ (goto-char pmark)
+ (insert "*** output flushed ***\n")
+ (set-marker pmark (point))))
+
+ (defun term-show-output ()
+ "Display start of this batch of interpreter output at top of window.
+ Sets mark to the value of point when this command is run."
+ (interactive)
+ (goto-char term-last-input-end)
+ (backward-char)
+ (beginning-of-line)
+ (set-window-start (selected-window) (point))
+ (end-of-line))
+
+ (defun term-interrupt-subjob ()
+ "Interrupt the current subjob."
+ (interactive)
+ (interrupt-process nil term-ptyp))
+
+ (defun term-kill-subjob ()
+ "Send kill signal to the current subjob."
+ (interactive)
+ (kill-process nil term-ptyp))
+
+ (defun term-quit-subjob ()
+ "Send quit signal to the current subjob."
+ (interactive)
+ (quit-process nil term-ptyp))
+
+ (defun term-stop-subjob ()
+ "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 \\[term-continue-subjob] to resume the process. (This
+ is not a problem with most shells, since they ignore this signal.)"
+ (interactive)
+ (stop-process nil term-ptyp))
+
+ (defun term-continue-subjob ()
+ "Send CONT signal to process buffer's process group.
+ Useful if you accidentally suspend the top-level process."
+ (interactive)
+ (continue-process nil term-ptyp))
+
+ (defun term-kill-input ()
+ "Kill all text from last stuff output by interpreter to point."
+ (interactive)
+ (let* ((pmark (process-mark (get-buffer-process (current-buffer))))
+ (p-pos (marker-position pmark)))
+ (if (> (point) p-pos)
+ (kill-region pmark (point)))))
+
+ (defun term-delchar-or-maybe-eof (arg)
+ "Delete ARG characters forward, or send an EOF to process if at end of
+ buffer."
+ (interactive "p")
+ (if (eobp)
+ (process-send-eof)
+ (delete-char arg)))
+
+ (defun term-send-eof ()
+ "Send an EOF to the current buffer's process."
+ (interactive)
+ (process-send-eof))
+
+ (defun term-backward-matching-input (regexp arg)
+ "Search backward through buffer for match for REGEXP.
+ Matches are searched for on lines that match `term-prompt-regexp'.
+ With prefix argument N, search for Nth previous match.
+ If N is negative, find the next or Nth next match."
+ (interactive (term-regexp-arg "Backward input matching (regexp): "))
+ (let* ((re (concat term-prompt-regexp ".*" regexp))
+ (pos (save-excursion (end-of-line (if (> arg 0) 0 1))
+ (if (re-search-backward re nil t arg)
+ (point)))))
+ (if (null pos)
+ (progn (message "Not found")
+ (ding))
+ (goto-char pos)
+ (term-bol nil))))
+
+ (defun term-forward-matching-input (regexp arg)
+ "Search forward through buffer for match for REGEXP.
+ Matches are searched for on lines that match `term-prompt-regexp'.
+ With prefix argument N, search for Nth following match.
+ If N is negative, find the previous or Nth previous match."
+ (interactive (term-regexp-arg "Forward input matching (regexp): "))
+ (term-backward-matching-input regexp (- arg)))
+
+
+ (defun term-next-prompt (n)
+ "Move to end of Nth next prompt in the buffer.
+ See `term-prompt-regexp'."
+ (interactive "p")
+ (let ((paragraph-start term-prompt-regexp))
+ (end-of-line (if (> n 0) 1 0))
+ (forward-paragraph n)
+ (term-skip-prompt)))
+
+ (defun term-previous-prompt (n)
+ "Move to end of Nth previous prompt in the buffer.
+ See `term-prompt-regexp'."
+ (interactive "p")
+ (term-next-prompt (- n)))
+
+ ;;; Support for source-file processing commands.
+
;;;============================================================================
+ ;;; Many command-interpreters (e.g., Lisp, Scheme, Soar) have
+ ;;; commands that process files of source text (e.g. loading or compiling
+ ;;; files). So the corresponding process-in-a-buffer modes have commands
+ ;;; for doing this (e.g., lisp-load-file). The functions below are useful
+ ;;; for defining these commands.
+ ;;;
+ ;;; Alas, these guys don't do exactly the right thing for Lisp, Scheme
+ ;;; and Soar, in that they don't know anything about file extensions.
+ ;;; So the compile/load interface gets the wrong default occasionally.
+ ;;; The load-file/compile-file default mechanism could be smarter -- it
+ ;;; doesn't know about the relationship between filename extensions and
+ ;;; whether the file is source or executable. If you compile foo.lisp
+ ;;; with compile-file, then the next load-file should use foo.bin for
+ ;;; the default, not foo.lisp. This is tricky to do right, particularly
+ ;;; because the extension for executable files varies so much (.o, .bin,
+ ;;; .lbin, .mo, .vo, .ao, ...).
+
+
+ ;;; TERM-SOURCE-DEFAULT -- determines defaults for source-file processing
+ ;;; commands.
+ ;;;
+ ;;; TERM-CHECK-SOURCE -- if FNAME is in a modified buffer, asks you if you
+ ;;; want to save the buffer before issuing any process requests to the command
+ ;;; interpreter.
+ ;;;
+ ;;; TERM-GET-SOURCE -- used by the source-file processing commands to prompt
+ ;;; for the file to process.
+
+ ;;; (TERM-SOURCE-DEFAULT previous-dir/file source-modes)
+
;;;============================================================================
+ ;;; This function computes the defaults for the load-file and compile-file
+ ;;; commands for tea, soar, cmulisp, and cmuscheme modes.
+ ;;;
+ ;;; - PREVIOUS-DIR/FILE is a pair (directory . filename) from the last
+ ;;; source-file processing command, or nil if there hasn't been one yet.
+ ;;; - SOURCE-MODES is a list used to determine what buffers contain source
+ ;;; files: if the major mode of the buffer is in SOURCE-MODES, it's source.
+ ;;; Typically, (lisp-mode) or (scheme-mode).
+ ;;;
+ ;;; If the command is given while the cursor is inside a string, *and*
+ ;;; the string is an existing filename, *and* the filename is not a directory,
+ ;;; then the string is taken as default. This allows you to just position
+ ;;; your cursor over a string that's a filename and have it taken as default.
+ ;;;
+ ;;; If the command is given in a file buffer whose major mode is in
+ ;;; SOURCE-MODES, then the filename is the default file, and the
+ ;;; file's directory is the default directory.
+ ;;;
+ ;;; If the buffer isn't a source file buffer (e.g., it's the process buffer),
+ ;;; then the default directory & file are what was used in the last
source-file
+ ;;; processing command (i.e., PREVIOUS-DIR/FILE). If this is the first time
+ ;;; the command has been run (PREVIOUS-DIR/FILE is nil), the default directory
+ ;;; is the cwd, with no default file. (\"no default file\" = nil)
+ ;;;
+ ;;; SOURCE-REGEXP is typically going to be something like (tea-mode)
+ ;;; for T programs, (lisp-mode) for Lisp programs, (soar-mode lisp-mode)
+ ;;; for Soar programs, etc.
+ ;;;
+ ;;; The function returns a pair: (default-directory . default-file).
+
+ (defun term-source-default (previous-dir/file source-modes)
+ (cond ((and buffer-file-name (memq major-mode source-modes))
+ (cons (file-name-directory buffer-file-name)
+ (file-name-nondirectory buffer-file-name)))
+ (previous-dir/file)
+ (t
+ (cons default-directory nil))))
+
+
+ ;;; (TERM-CHECK-SOURCE fname)
+
;;;============================================================================
+ ;;; Prior to loading or compiling (or otherwise processing) a file (in the CMU
+ ;;; process-in-a-buffer modes), this function can be called on the filename.
+ ;;; If the file is loaded into a buffer, and the buffer is modified, the user
+ ;;; is queried to see if he wants to save the buffer before proceeding with
+ ;;; the load or compile.
+
+ (defun term-check-source (fname)
+ (let ((buff (get-file-buffer fname)))
+ (if (and buff
+ (buffer-modified-p buff)
+ (y-or-n-p (format "Save buffer %s first? "
+ (buffer-name buff))))
+ ;; save BUFF.
+ (let ((old-buffer (current-buffer)))
+ (set-buffer buff)
+ (save-buffer)
+ (set-buffer old-buffer)))))
+
+
+ ;;; (TERM-GET-SOURCE prompt prev-dir/file source-modes mustmatch-p)
+
;;;============================================================================
+ ;;; TERM-GET-SOURCE is used to prompt for filenames in command-interpreter
+ ;;; commands that process source files (like loading or compiling a file).
+ ;;; It prompts for the filename, provides a default, if there is one,
+ ;;; and returns the result filename.
+ ;;;
+ ;;; See TERM-SOURCE-DEFAULT for more on determining defaults.
+ ;;;
+ ;;; PROMPT is the prompt string. PREV-DIR/FILE is the (directory . file) pair
+ ;;; from the last source processing command. SOURCE-MODES is a list of major
+ ;;; modes used to determine what file buffers contain source files. (These
+ ;;; two arguments are used for determining defaults). If MUSTMATCH-P is true,
+ ;;; then the filename reader will only accept a file that exists.
+ ;;;
+ ;;; A typical use:
+ ;;; (interactive (term-get-source "Compile file: " prev-lisp-dir/file
+ ;;; '(lisp-mode) t))
+
+ ;;; This is pretty stupid about strings. It decides we're in a string
+ ;;; if there's a quote on both sides of point on the current line.
+ (defun term-extract-string ()
+ "Returns string around POINT that starts the current line or nil."
+ (save-excursion
+ (let* ((point (point))
+ (bol (progn (beginning-of-line) (point)))
+ (eol (progn (end-of-line) (point)))
+ (start (progn (goto-char point)
+ (and (search-backward "\"" bol t)
+ (1+ (point)))))
+ (end (progn (goto-char point)
+ (and (search-forward "\"" eol t)
+ (1- (point))))))
+ (and start end
+ (buffer-substring start end)))))
+
+ (defun term-get-source (prompt prev-dir/file source-modes mustmatch-p)
+ (let* ((def (term-source-default prev-dir/file source-modes))
+ (stringfile (term-extract-string))
+ (sfile-p (and stringfile
+ (condition-case ()
+ (file-exists-p stringfile)
+ (error nil))
+ (not (file-directory-p stringfile))))
+ (defdir (if sfile-p (file-name-directory stringfile)
+ (car def)))
+ (deffile (if sfile-p (file-name-nondirectory stringfile)
+ (cdr def)))
+ (ans (read-file-name (if deffile (format "%s(default %s) "
+ prompt deffile)
+ prompt)
+ defdir
+ (concat defdir deffile)
+ mustmatch-p)))
+ (list (expand-file-name (substitute-in-file-name ans)))))
+
+ ;;; I am somewhat divided on this string-default feature. It seems
+ ;;; to violate the principle-of-least-astonishment, in that it makes
+ ;;; the default harder to predict, so you actually have to look and see
+ ;;; what the default really is before choosing it. This can trip you up.
+ ;;; On the other hand, it can be useful, I guess. I would appreciate feedback
+ ;;; on this.
+ ;;; -Olin
+
+
+ ;;; Simple process query facility.
+ ;;;
===========================================================================
+ ;;; This function is for commands that want to send a query to the process
+ ;;; and show the response to the user. For example, a command to get the
+ ;;; arglist for a Common Lisp function might send a "(arglist 'foo)" query
+ ;;; to an inferior Common Lisp process.
+ ;;;
+ ;;; This simple facility just sends strings to the inferior process and pops
+ ;;; up a window for the process buffer so you can see what the process
+ ;;; responds with. We don't do anything fancy like try to intercept what the
+ ;;; process responds with and put it in a pop-up window or on the message
+ ;;; line. We just display the buffer. Low tech. Simple. Works good.
+
+ ;;; Send to the inferior process PROC the string STR. Pop-up but do not
select
+ ;;; a window for the inferior process so that its response can be seen.
+ (defun term-proc-query (proc str)
+ (let* ((proc-buf (process-buffer proc))
+ (proc-mark (process-mark proc)))
+ (display-buffer proc-buf)
+ (set-buffer proc-buf) ; but it's not the selected *window*
+ (let ((proc-win (get-buffer-window proc-buf))
+ (proc-pt (marker-position proc-mark)))
+ (term-send-string proc str) ; send the query
+ (accept-process-output proc) ; wait for some output
+ ;; Try to position the proc window so you can see the answer.
+ ;; This is bogus code. If you delete the (sit-for 0), it breaks.
+ ;; I don't know why. Wizards invited to improve it.
+ (if (not (pos-visible-in-window-p proc-pt proc-win))
+ (let ((opoint (window-point proc-win)))
+ (set-window-point proc-win proc-mark) (sit-for 0)
+ (if (not (pos-visible-in-window-p opoint proc-win))
+ (push-mark opoint)
+ (set-window-point proc-win opoint)))))))
+
+ ;;; Returns the current column in the current screen line.
+ ;;; Note: (current-column) yields column in buffer line.
+
+ (defun term-horizontal-column ()
+ (- (term-current-column) (term-start-line-column)))
+
+ ;; Calls either vertical-motion or buffer-vertical-motion
+ (defmacro term-vertical-motion (count)
+ (list 'funcall 'term-vertical-motion count))
+
+ ;; An emulation of vertical-motion that is independent of having a window.
+ ;; Instead, it uses the term-width variable as the logical window width.
+
+ (defun buffer-vertical-motion (count)
+ (cond ((= count 0)
+ (move-to-column (* term-width (/ (current-column) term-width)))
+ 0)
+ ((> count 0)
+ (let ((H)
+ (todo (+ count (/ (current-column) term-width))))
+ (end-of-line)
+ ;; The loop iterates over buffer lines;
+ ;; H is the number of screen lines in the current line, i.e.
+ ;; the ceiling of dividing the buffer line width by term-width.
+ (while (and (<= (setq H (max (/ (+ (current-column) term-width -1)
+ term-width)
+ 1))
+ todo)
+ (not (eobp)))
+ (setq todo (- todo H))
+ (forward-char) ;; Move past the ?\n
+ (end-of-line)) ;; and on to the end of the next line.
+ (if (and (>= todo H) (> todo 0))
+ (+ (- count todo) H -1) ;; Hit end of buffer.
+ (move-to-column (* todo term-width))
+ count)))
+ (t ;; (< count 0) ;; Similar algorithm, but for upward motion.
+ (let ((H)
+ (todo (- count)))
+ (while (and (<= (setq H (max (/ (+ (current-column) term-width -1)
+ term-width)
+ 1))
+ todo)
+ (progn (beginning-of-line)
+ (not (bobp))))
+ (setq todo (- todo H))
+ (backward-char)) ;; Move to end of previous line.
+ (if (and (>= todo H) (> todo 0))
+ (+ count todo (- 1 H)) ;; Hit beginning of buffer.
+ (move-to-column (* (- H todo 1) term-width))
+ count)))))
+
+ ;;; The term-start-line-column variable is used as a cache.
+ (defun term-start-line-column ()
+ (cond (term-start-line-column)
+ ((let ((save-pos (point)))
+ (term-vertical-motion 0)
+ (setq term-start-line-column (current-column))
+ (goto-char save-pos)
+ term-start-line-column))))
+
+ ;;; Same as (current-column), but uses term-current-column as a cache.
+ (defun term-current-column ()
+ (cond (term-current-column)
+ ((setq term-current-column (current-column)))))
+
+ ;;; Move DELTA column right (or left if delta < 0 limiting at column 0).
+
+ (defun term-move-columns (delta)
+ (setq term-current-column (max 0 (+ (term-current-column) delta)))
+ (move-to-column term-current-column t))
+
+ ;; Insert COUNT copies of CHAR in the default face.
+ (defun term-insert-char (char count)
+ (let ((old-point (point)))
+ (insert-char char count)
+ (put-text-property old-point (point) 'face 'default)))
+
+ (defun term-current-row ()
+ (cond (term-current-row)
+ ((setq term-current-row
+ (save-restriction
+ (save-excursion
+ (narrow-to-region term-home-marker (point-max))
+ (- (term-vertical-motion -9999))))))))
+
+ (defun term-adjust-current-row-cache (delta)
+ (if term-current-row
+ (setq term-current-row (+ term-current-row delta))))
+
+ (defun term-terminal-pos ()
+ (save-excursion ; save-restriction
+ (let ((save-col (term-current-column))
+ x y)
+ (term-vertical-motion 0)
+ (setq x (- save-col (current-column)))
+ (setq y (term-vertical-motion term-height))
+ (cons x y))))
+
+ ;;;Function that handles term messages: code by rms ( and you can see the
+ ;;;difference ;-) -mm
+
+ (defun term-handle-ansi-terminal-messages (message)
+ ;; Is there a command here?
+ (while (string-match "\eAnSiT.+\n" message)
+ ;; Extract the command code and the argument.
+ (let* ((start (match-beginning 0))
+ (end (match-end 0))
+ (command-code (aref message (+ start 6)))
+ (argument
+ (save-match-data
+ (substring message
+ (+ start 8)
+ (string-match "\r?\n" message
+ (+ start 8)))))
+ ignore)
+ ;; Delete this command from MESSAGE.
+ (setq message (replace-match "" t t message))
+
+ ;; If we recognize the type of command, set the appropriate variable.
+ (cond ((= command-code ?c)
+ (setq term-ansi-at-dir argument))
+ ((= command-code ?h)
+ (setq term-ansi-at-host argument))
+ ((= command-code ?u)
+ (setq term-ansi-at-user argument))
+ ;; Otherwise ignore this one.
+ (t
+ (setq ignore t)))
+
+ ;; Update default-directory based on the changes this command made.
+ (if ignore
+ nil
+ (setq default-directory
+ (file-name-as-directory
+ (if (and (string= term-ansi-at-host (system-name))
+ (string= term-ansi-at-user
(user-real-login-name)))
+ (expand-file-name term-ansi-at-dir)
+ (if (string= term-ansi-at-user (user-real-login-name))
+ (concat "/" term-ansi-at-host ":" term-ansi-at-dir)
+ (concat "/" term-ansi-at-user "@" term-ansi-at-host ":"
+ term-ansi-at-dir)))))
+
+ ;; I'm not sure this is necessary,
+ ;; but it's best to be on the safe side.
+ (if (string= term-ansi-at-host (system-name))
+ (progn
+ (setq ange-ftp-default-user term-ansi-at-save-user)
+ (setq ange-ftp-default-password term-ansi-at-save-pwd)
+ (setq ange-ftp-generate-anonymous-password
term-ansi-at-save-anon))
+ (setq term-ansi-at-save-user ange-ftp-default-user)
+ (setq term-ansi-at-save-pwd ange-ftp-default-password)
+ (setq term-ansi-at-save-anon ange-ftp-generate-anonymous-password)
+ (setq ange-ftp-default-user nil)
+ (setq ange-ftp-default-password nil)
+ (setq ange-ftp-generate-anonymous-password nil)))))
+ message)
+
+
+ ;;; Terminal emulation
+ ;;; This is the standard process filter for term buffers.
+ ;;; It emulates (most of the features of) a VT100/ANSI-style terminal.
+
+ (defun term-emulate-terminal (proc str)
+ (let* ((previous-buffer (current-buffer))
+ (i 0) char funny count save-point save-marker old-point temp win
+ (selected (selected-window))
+ last-win
+ (str-length (length str)))
+ (unwind-protect
+ (progn
+ (set-buffer (process-buffer proc))
+
+ ;;; Let's handle the messages. -mm
+
+ (setq str (term-handle-ansi-terminal-messages str))
+ (setq str-length (length str))
+
+ (if (marker-buffer term-pending-delete-marker)
+ (progn
+ ;; Delete text following term-pending-delete-marker.
+ (delete-region term-pending-delete-marker (process-mark proc))
+ (set-marker term-pending-delete-marker nil)))
+
+ (if (eq (window-buffer) (current-buffer))
+ (progn
+ (setq term-vertical-motion (symbol-function 'vertical-motion))
+ (term-check-size proc))
+ (setq term-vertical-motion
+ (symbol-function 'buffer-vertical-motion)))
+
+ (setq save-marker (copy-marker (process-mark proc)))
+
+ (if (/= (point) (process-mark proc))
+ (progn (setq save-point (point-marker))
+ (goto-char (process-mark proc))))
+
+ (save-restriction
+ ;; If the buffer is in line mode, and there is a partial
+ ;; input line, save the line (by narrowing to leave it
+ ;; outside the restriction ) until we're done with output.
+ (if (and (> (point-max) (process-mark proc))
+ (term-in-line-mode))
+ (narrow-to-region (point-min) (process-mark proc)))
+
+ (if term-log-buffer
+ (princ str term-log-buffer))
+ (cond ((eq term-terminal-state 4) ;; Have saved pending output.
+ (setq str (concat term-terminal-parameter str))
+ (setq term-terminal-parameter nil)
+ (setq str-length (length str))
+ (setq term-terminal-state 0)))
+
+ (while (< i str-length)
+ (setq char (aref str i))
+ (cond ((< term-terminal-state 2)
+ ;; Look for prefix of regular chars
+ (setq funny
+ (string-match "[\r\n\000\007\033\t\b\032\016\017]"
+ str i))
+ (if (not funny) (setq funny str-length))
+ (cond ((> funny i)
+ (cond ((eq term-terminal-state 1)
+ (term-move-columns 1)
+ (setq term-terminal-state 0)))
+ (setq count (- funny i))
+ (setq temp (- (+ (term-horizontal-column) count)
+ term-width))
+ (cond ((<= temp 0)) ;; All count chars fit in line.
+ ((> count temp) ;; Some chars fit.
+ ;; This iteration, handle only what fits.
+ (setq count (- count temp))
+ (setq funny (+ count i)))
+ ((or (not (or term-pager-count
+ term-scroll-with-delete))
+ (> (term-handle-scroll 1) 0))
+ (term-adjust-current-row-cache 1)
+ (setq count (min count term-width))
+ (setq funny (+ count i))
+ (setq term-start-line-column
+ term-current-column))
+ (t ;; Doing PAGER processing.
+ (setq count 0 funny i)
+ (setq term-current-column nil)
+ (setq term-start-line-column nil)))
+ (setq old-point (point))
+
+ ;; Insert a string, check how many columns
+ ;; we moved, then delete that many columns
+ ;; following point if not eob nor insert-mode.
+ (let ((old-column (current-column))
+ columns pos)
+ (insert (substring str i funny))
+ (setq term-current-column (current-column)
+ columns (- term-current-column old-column))
+ (when (not (or (eobp) term-insert-mode))
+ (setq pos (point))
+ (term-move-columns columns)
+ (delete-region pos (point))))
+ (setq term-current-column nil)
+
+ (put-text-property old-point (point)
+ 'face term-current-face)
+ ;; If the last char was written in last column,
+ ;; back up one column, but remember we did so.
+ ;; Thus we emulate xterm/vt100-style line-wrapping.
+ (cond ((eq temp 0)
+ (term-move-columns -1)
+ (setq term-terminal-state 1)))
+ (setq i (1- funny)))
+ ((and (setq term-terminal-state 0)
+ (eq char ?\^I)) ; TAB
+ ;; FIXME: Does not handle line wrap!
+ (setq count (term-current-column))
+ (setq count (+ count 8 (- (mod count 8))))
+ (if (< (move-to-column count nil) count)
+ (term-insert-char char 1))
+ (setq term-current-column count))
+ ((eq char ?\r)
+ ;; Optimize CRLF at end of buffer:
+ (cond ((and (< (setq temp (1+ i)) str-length)
+ (eq (aref str temp) ?\n)
+ (= (point) (point-max))
+ (not (or term-pager-count
+ term-kill-echo-list
+ term-scroll-with-delete)))
+ (insert ?\n)
+ (term-adjust-current-row-cache 1)
+ (setq term-start-line-column 0)
+ (setq term-current-column 0)
+ (setq i temp))
+ (t ;; Not followed by LF or can't optimize:
+ (term-vertical-motion 0)
+ (setq term-current-column
term-start-line-column))))
+ ((eq char ?\n)
+ (if (not (and term-kill-echo-list
+ (term-check-kill-echo-list)))
+ (term-down 1 t)))
+ ((eq char ?\b)
+ (term-move-columns -1))
+ ((eq char ?\033) ; Escape
+ (setq term-terminal-state 2))
+ ((eq char 0)) ; NUL: Do nothing
+ ((eq char ?\016)) ; Shift Out - ignored
+ ((eq char ?\017)) ; Shift In - ignored
+ ((eq char ?\^G)
+ (beep t)) ; Bell
+ ((eq char ?\032)
+ (let ((end (string-match "\r?$" str i)))
+ (if end
+ (funcall term-command-hook
+ (prog1 (substring str (1+ i) end)
+ (setq i (match-end 0))))
+ (setq term-terminal-parameter
+ (substring str i))
+ (setq term-terminal-state 4)
+ (setq i str-length))))
+ (t ; insert char FIXME: Should never happen
+ (term-move-columns 1)
+ (backward-delete-char 1)
+ (insert char))))
+ ((eq term-terminal-state 2) ; Seen Esc
+ (cond ((eq char ?\133) ;; ?\133 = ?[
+
+ ;;; Some modifications to cope with multiple settings like ^[[01;32;43m -mm
+ ;;; Note that now the init value of term-terminal-previous-parameter has
+ ;;; been changed to -1
+
+ (make-local-variable 'term-terminal-parameter)
+ (make-local-variable
'term-terminal-previous-parameter)
+ (make-local-variable
'term-terminal-previous-parameter-2)
+ (make-local-variable
'term-terminal-previous-parameter-3)
+ (make-local-variable
'term-terminal-previous-parameter-4)
+ (make-local-variable 'term-terminal-more-parameters)
+ (setq term-terminal-parameter 0)
+ (setq term-terminal-previous-parameter -1)
+ (setq term-terminal-previous-parameter-2 -1)
+ (setq term-terminal-previous-parameter-3 -1)
+ (setq term-terminal-previous-parameter-4 -1)
+ (setq term-terminal-more-parameters 0)
+ (setq term-terminal-state 3))
+ ((eq char ?D) ;; scroll forward
+ (term-handle-deferred-scroll)
+ (term-down 1 t)
+ (setq term-terminal-state 0))
+ ((eq char ?M) ;; scroll reversed
+ (term-insert-lines 1)
+ (setq term-terminal-state 0))
+ ((eq char ?7) ;; Save cursor
+ (term-handle-deferred-scroll)
+ (setq term-saved-cursor
+ (cons (term-current-row)
+ (term-horizontal-column)))
+ (setq term-terminal-state 0))
+ ((eq char ?8) ;; Restore cursor
+ (if term-saved-cursor
+ (term-goto (car term-saved-cursor)
+ (cdr term-saved-cursor)))
+ (setq term-terminal-state 0))
+ ((setq term-terminal-state 0))))
+ ((eq term-terminal-state 3) ; Seen Esc [
+ (cond ((and (>= char ?0) (<= char ?9))
+ (setq term-terminal-parameter
+ (+ (* 10 term-terminal-parameter) (- char
?0))))
+ ((eq char ?\;)
+ ;;; Some modifications to cope with multiple settings like ^[[01;32;43m -mm
+ (setq term-terminal-more-parameters 1)
+ (setq term-terminal-previous-parameter-4
+ term-terminal-previous-parameter-3)
+ (setq term-terminal-previous-parameter-3
+ term-terminal-previous-parameter-2)
+ (setq term-terminal-previous-parameter-2
+ term-terminal-previous-parameter)
+ (setq term-terminal-previous-parameter
+ term-terminal-parameter)
+ (setq term-terminal-parameter 0))
+ ((eq char ??)) ; Ignore ?
+ (t
+ (term-handle-ansi-escape proc char)
+ (setq term-terminal-more-parameters 0)
+ (setq term-terminal-previous-parameter-4 -1)
+ (setq term-terminal-previous-parameter-3 -1)
+ (setq term-terminal-previous-parameter-2 -1)
+ (setq term-terminal-previous-parameter -1)
+ (setq term-terminal-state 0)))))
+ (if (term-handling-pager)
+ ;; Finish stuff to get ready to handle PAGER.
+ (progn
+ (if (> (% (current-column) term-width) 0)
+ (setq term-terminal-parameter
+ (substring str i))
+ ;; We're at column 0. Goto end of buffer; to compensate,
+ ;; prepend a ?\r for later. This looks more consistent.
+ (if (zerop i)
+ (setq term-terminal-parameter
+ (concat "\r" (substring str i)))
+ (setq term-terminal-parameter (substring str (1- i)))
+ (aset term-terminal-parameter 0 ?\r))
+ (goto-char (point-max)))
+ (setq term-terminal-state 4)
+ (make-local-variable 'term-pager-old-filter)
+ (setq term-pager-old-filter (process-filter proc))
+ (set-process-filter proc term-pager-filter)
+ (setq i str-length)))
+ (setq i (1+ i))))
+
+ (if (>= (term-current-row) term-height)
+ (term-handle-deferred-scroll))
+
+ (set-marker (process-mark proc) (point))
+ (if save-point
+ (progn (goto-char save-point)
+ (set-marker save-point nil)))
+
+ ;; Check for a pending filename-and-line number to display.
+ ;; We do this before scrolling, because we might create a new window.
+ (if (and term-pending-frame
+ (eq (window-buffer selected) (current-buffer)))
+ (progn (term-display-line (car term-pending-frame)
+ (cdr term-pending-frame))
+ (setq term-pending-frame nil)
+ ;; We have created a new window, so check the window size.
+ (term-check-size proc)))
+
+ ;; Scroll each window displaying the buffer but (by default)
+ ;; only if the point matches the process-mark we started with.
+ (setq win selected)
+ ;; Avoid infinite loop in strange case where minibuffer window
+ ;; is selected but not active.
+ (while (window-minibuffer-p win)
+ (setq win (next-window win nil t)))
+ (setq last-win win)
+ (while (progn
+ (setq win (next-window win nil t))
+ (if (eq (window-buffer win) (process-buffer proc))
+ (let ((scroll term-scroll-to-bottom-on-output))
+ (select-window win)
+ (if (or (= (point) save-marker)
+ (eq scroll t) (eq scroll 'all)
+ ;; Maybe user wants point to jump to the end.
+ (and (eq selected win)
+ (or (eq scroll 'this) (not save-point)))
+ (and (eq scroll 'others)
+ (not (eq selected win))))
+ (progn
+ (goto-char term-home-marker)
+ (recenter 0)
+ (goto-char (process-mark proc))
+ (if (not (pos-visible-in-window-p (point) win))
+ (recenter -1))))
+ ;; Optionally scroll so that the text
+ ;; ends at the bottom of the window.
+ (if (and term-scroll-show-maximum-output
+ (>= (point) (process-mark proc)))
+ (save-excursion
+ (goto-char (point-max))
+ (recenter -1)))))
+ (not (eq win last-win))))
+
+ ;;; Stolen from comint.el and adapted -mm
+ (if (> term-buffer-maximum-size 0)
+ (save-excursion
+ (goto-char (process-mark (get-buffer-process
(current-buffer))))
+ (forward-line (- term-buffer-maximum-size))
+ (beginning-of-line)
+ (delete-region (point-min) (point))))
+ ;;;
+
+ (set-marker save-marker nil))
+ ;; unwind-protect cleanup-forms follow:
+ (set-buffer previous-buffer)
+ (select-window selected))))
+
+ (defun term-handle-deferred-scroll ()
+ (let ((count (- (term-current-row) term-height)))
+ (if (>= count 0)
+ (save-excursion
+ (goto-char term-home-marker)
+ (term-vertical-motion (1+ count))
+ (set-marker term-home-marker (point))
+ (setq term-current-row (1- term-height))))))
+
+ ;;; New function to deal with ansi colorized output, as you can see you can
+ ;;; have any bold/underline/fg/bg/reverse combination. -mm
+
+ (defun term-handle-colors-array (parameter)
+ (cond
+
+ ;;; Bold
+ ((eq parameter 1)
+ (setq term-ansi-current-bold 1))
+
+ ;;; Underline
+ ((eq parameter 4)
+ (setq term-ansi-current-underline 1))
+
+ ;;; Blink (unsupported by Emacs), will be translated to bold.
+ ;;; This may change in the future though.
+ ((eq parameter 5)
+ (setq term-ansi-current-bold 1))
+
+ ;;; Reverse
+ ((eq parameter 7)
+ (setq term-ansi-current-reverse 1))
+
+ ;;; Invisible
+ ((eq parameter 8)
+ (setq term-ansi-current-invisible 1))
+
+ ;;; Foreground
+ ((and (>= parameter 30) (<= parameter 37))
+ (setq term-ansi-current-color (- parameter 29)))
+
+ ;;; Reset foreground
+ ((eq parameter 39)
+ (setq term-ansi-current-color 0))
+
+ ;;; Background
+ ((and (>= parameter 40) (<= parameter 47))
+ (setq term-ansi-current-bg-color (- parameter 39)))
+
+ ;;; Reset background
+ ((eq parameter 49)
+ (setq term-ansi-current-bg-color 0))
+
+ ;;; 0 (Reset) or unknown (reset anyway)
+ (t
+ (setq term-current-face nil)
+ (setq term-ansi-current-underline 0)
+ (setq term-ansi-current-bold 0)
+ (setq term-ansi-current-reverse 0)
+ (setq term-ansi-current-color 0)
+ (setq term-ansi-current-invisible 0)
+ (setq term-ansi-face-already-done 1)
+ (setq term-ansi-current-bg-color 0)))
+
+ ; (message "Debug: U-%d R-%d B-%d I-%d D-%d F-%d B-%d"
+ ; term-ansi-current-underline
+ ; term-ansi-current-reverse
+ ; term-ansi-current-bold
+ ; term-ansi-current-invisible
+ ; term-ansi-face-already-done
+ ; term-ansi-current-color
+ ; term-ansi-current-bg-color)
+
+
+ (if (= term-ansi-face-already-done 0)
+ (if (= term-ansi-current-reverse 1)
+ (if (= term-ansi-current-invisible 1)
+ (setq term-current-face
+ (if (= term-ansi-current-color 0)
+ (list :background
+ term-default-fg-color
+ :foreground
+ term-default-fg-color)
+ (list :background
+ (elt ansi-term-color-vector term-ansi-current-color)
+ :foreground
+ (elt ansi-term-color-vector
term-ansi-current-color)))
+ ;; No need to bother with anything else if it's invisible
+ )
+ (setq term-current-face
+ (list :background
+ (elt ansi-term-color-vector term-ansi-current-color)
+ :foreground
+ (elt ansi-term-color-vector
term-ansi-current-bg-color)))
+ (if (= term-ansi-current-bold 1)
+ (setq term-current-face
+ (append '(:weight bold) term-current-face)))
+ (if (= term-ansi-current-underline 1)
+ (setq term-current-face
+ (append '(:underline t) term-current-face))))
+ (if (= term-ansi-current-invisible 1)
+ (setq term-current-face
+ (if (= term-ansi-current-bg-color 0)
+ (list :background
+ term-default-bg-color
+ :foreground
+ term-default-bg-color)
+ (list :foreground
+ (elt ansi-term-color-vector
term-ansi-current-bg-color)
+ :background
+ (elt ansi-term-color-vector
term-ansi-current-bg-color)))
+ ;; No need to bother with anything else if it's invisible
+ )
+ (setq term-current-face
+ (list :foreground
+ (elt ansi-term-color-vector term-ansi-current-color)
+ :background
+ (elt ansi-term-color-vector term-ansi-current-bg-color)))
+ (if (= term-ansi-current-bold 1)
+ (setq term-current-face
+ (append '(:weight bold) term-current-face)))
+ (if (= term-ansi-current-underline 1)
+ (setq term-current-face
+ (append '(:underline t) term-current-face))))))
+
+ ;;; (message "Debug %S" term-current-face)
+ (setq term-ansi-face-already-done 0))
+
+
+ ;;; Handle a character assuming (eq terminal-state 2) -
+ ;;; i.e. we have previously seen Escape followed by ?[.
+
+ (defun term-handle-ansi-escape (proc char)
+ (cond
+ ((eq char ?H) ; cursor motion
+ (if (<= term-terminal-parameter 0)
+ (setq term-terminal-parameter 1))
+ (if (<= term-terminal-previous-parameter 0)
+ (setq term-terminal-previous-parameter 1))
+ (if (> term-terminal-previous-parameter term-height)
+ (setq term-terminal-previous-parameter term-height))
+ (if (> term-terminal-parameter term-width)
+ (setq term-terminal-parameter term-width))
+ (term-goto
+ (1- term-terminal-previous-parameter)
+ (1- term-terminal-parameter)))
+ ;; \E[A - cursor up
+ ((eq char ?A)
+ (term-handle-deferred-scroll)
+ (term-down (- (max 1 term-terminal-parameter)) t))
+ ;; \E[B - cursor down
+ ((eq char ?B)
+ (term-down (max 1 term-terminal-parameter) t))
+ ;; \E[C - cursor right
+ ((eq char ?C)
+ (term-move-columns (max 1 term-terminal-parameter)))
+ ;; \E[D - cursor left
+ ((eq char ?D)
+ (term-move-columns (- (max 1 term-terminal-parameter))))
+ ;; \E[J - clear to end of screen
+ ((eq char ?J)
+ (term-erase-in-display term-terminal-parameter))
+ ;; \E[K - clear to end of line
+ ((eq char ?K)
+ (term-erase-in-line term-terminal-parameter))
+ ;; \E[L - insert lines
+ ((eq char ?L)
+ (term-insert-lines (max 1 term-terminal-parameter)))
+ ;; \E[M - delete lines
+ ((eq char ?M)
+ (term-delete-lines (max 1 term-terminal-parameter)))
+ ;; \E[P - delete chars
+ ((eq char ?P)
+ (term-delete-chars (max 1 term-terminal-parameter)))
+ ;; \E[@ - insert spaces
+ ((eq char ?@)
+ (term-insert-spaces (max 1 term-terminal-parameter)))
+ ;; \E[?h - DEC Private Mode Set
+ ((eq char ?h)
+ (cond ((eq term-terminal-parameter 4)
+ (setq term-insert-mode t))
+ ((eq term-terminal-parameter 47)
+ (term-switch-to-alternate-sub-buffer t))))
+ ;; \E[?l - DEC Private Mode Reset
+ ((eq char ?l)
+ (cond ((eq term-terminal-parameter 4)
+ (setq term-insert-mode nil))
+ ((eq term-terminal-parameter 47)
+ (term-switch-to-alternate-sub-buffer nil))))
+
+ ;;; Modified to allow ansi coloring -mm
+ ;; \E[m - Set/reset standard mode
+ ((eq char ?m)
+ (when (= term-terminal-more-parameters 1)
+ (if (>= term-terminal-previous-parameter-4 0)
+ (term-handle-colors-array term-terminal-previous-parameter-4))
+ (if (>= term-terminal-previous-parameter-3 0)
+ (term-handle-colors-array term-terminal-previous-parameter-3))
+ (if (>= term-terminal-previous-parameter-2 0)
+ (term-handle-colors-array term-terminal-previous-parameter-2))
+ (term-handle-colors-array term-terminal-previous-parameter))
+ (term-handle-colors-array term-terminal-parameter))
+
+ ;; \E[6n - Report cursor position
+ ((eq char ?n)
+ (term-handle-deferred-scroll)
+ (process-send-string proc
+ (format "\e[%s;%sR"
+ (1+ (term-current-row))
+ (1+ (term-horizontal-column)))))
+ ;; \E[r - Set scrolling region
+ ((eq char ?r)
+ (term-scroll-region
+ (1- term-terminal-previous-parameter)
+ term-terminal-parameter))
+ (t)))
+
+ (defun term-scroll-region (top bottom)
+ "Set scrolling region.
+ TOP is the top-most line (inclusive) of the new scrolling region,
+ while BOTTOM is the line following the new scrolling region (e.g. exclusive).
+ The top-most line is line 0."
+ (setq term-scroll-start
+ (if (or (< top 0) (>= top term-height))
+ 0
+ top))
+ (setq term-scroll-end
+ (if (or (<= bottom term-scroll-start) (> bottom term-height))
+ term-height
+ bottom))
+ (setq term-scroll-with-delete
+ (or (term-using-alternate-sub-buffer)
+ (not (and (= term-scroll-start 0)
+ (= term-scroll-end term-height))))))
+
+ (defun term-switch-to-alternate-sub-buffer (set)
+ ;; If asked to switch to (from) the alternate sub-buffer, and already (not)
+ ;; using it, do nothing. This test is needed for some programs (including
+ ;; Emacs) that emit the ti termcap string twice, for unknown reason.
+ (term-handle-deferred-scroll)
+ (if (eq set (not (term-using-alternate-sub-buffer)))
+ (let ((row (term-current-row))
+ (col (term-horizontal-column)))
+ (cond (set
+ (goto-char (point-max))
+ (if (not (eq (preceding-char) ?\n))
+ (term-insert-char ?\n 1))
+ (setq term-scroll-with-delete t)
+ (setq term-saved-home-marker (copy-marker term-home-marker))
+ (set-marker term-home-marker (point)))
+ (t
+ (setq term-scroll-with-delete
+ (not (and (= term-scroll-start 0)
+ (= term-scroll-end term-height))))
+ (set-marker term-home-marker term-saved-home-marker)
+ (set-marker term-saved-home-marker nil)
+ (setq term-saved-home-marker nil)
+ (goto-char term-home-marker)))
+ (setq term-current-column nil)
+ (setq term-current-row 0)
+ (term-goto row col))))
+
+ ;; Default value for the symbol term-command-hook.
+
+ (defun term-command-hook (string)
+ (cond ((equal string "")
+ t)
+ ((= (aref string 0) ?\032)
+ ;; gdb (when invoked with -fullname) prints:
+ ;; \032\032FULLFILENAME:LINENUMBER:CHARPOS:BEG_OR_MIDDLE:PC\n
+ (let* ((first-colon (string-match ":" string 1))
+ (second-colon
+ (string-match ":" string (1+ first-colon)))
+ (filename (substring string 1 first-colon))
+ (fileline (string-to-int
+ (substring string (1+ first-colon) second-colon))))
+ (setq term-pending-frame (cons filename fileline))))
+ ((= (aref string 0) ?/)
+ (cd (substring string 1)))
+ ;; Allowing the inferior to call functions in Emacs is
+ ;; probably too big a security hole.
+ ;; ((= (aref string 0) ?!)
+ ;; (eval (car (read-from-string string 1))))
+ (t)));; Otherwise ignore it
+
+ ;; Make sure the file named TRUE-FILE is in a buffer that appears on the
screen
+ ;; and that its line LINE is visible.
+ ;; Put the overlay-arrow on the line LINE in that buffer.
+ ;; This is mainly used by gdb.
+
+ (defun term-display-line (true-file line)
+ (term-display-buffer-line (find-file-noselect true-file) line))
+
+ (defun term-display-buffer-line (buffer line)
+ (let* ((window (display-buffer buffer t))
+ (pos))
+ (save-excursion
+ (set-buffer buffer)
+ (save-restriction
+ (widen)
+ (goto-line line)
+ (setq pos (point))
+ (setq overlay-arrow-string "=>")
+ (or overlay-arrow-position
+ (setq overlay-arrow-position (make-marker)))
+ (set-marker overlay-arrow-position (point) (current-buffer)))
+ (cond ((or (< pos (point-min)) (> pos (point-max)))
+ (widen)
+ (goto-char pos))))
+ (set-window-point window overlay-arrow-position)))
+
+ ;;; The buffer-local marker term-home-marker defines the "home position"
+ ;;; (in terms of cursor motion). However, we move the term-home-marker
+ ;;; "down" as needed so that is no more that a window-full above (point-max).
+
+ (defun term-goto-home ()
+ (term-handle-deferred-scroll)
+ (goto-char term-home-marker)
+ (setq term-current-row 0)
+ (setq term-current-column (current-column))
+ (setq term-start-line-column term-current-column))
+
+ (defun term-goto (row col)
+ (term-handle-deferred-scroll)
+ (cond ((and term-current-row (>= row term-current-row))
+ ;; I assume this is a worthwhile optimization.
+ (term-vertical-motion 0)
+ (setq term-current-column term-start-line-column)
+ (setq row (- row term-current-row)))
+ (t
+ (term-goto-home)))
+ (term-down row)
+ (term-move-columns col))
+
+ ; The page is full, so enter "pager" mode, and wait for input.
+
+ (defun term-process-pager ()
+ (if (not term-pager-break-map)
+ (let* ((map (make-keymap))
+ (i 0) tmp)
+ ; (while (< i 128)
+ ; (define-key map (make-string 1 i) 'term-send-raw)
+ ; (setq i (1+ i)))
+ (define-key map "\e"
+ (lookup-key (current-global-map) "\e"))
+ (define-key map "\C-x"
+ (lookup-key (current-global-map) "\C-x"))
+ (define-key map "\C-u"
+ (lookup-key (current-global-map) "\C-u"))
+ (define-key map " " 'term-pager-page)
+ (define-key map "\r" 'term-pager-line)
+ (define-key map "?" 'term-pager-help)
+ (define-key map "h" 'term-pager-help)
+ (define-key map "b" 'term-pager-back-page)
+ (define-key map "\177" 'term-pager-back-line)
+ (define-key map "q" 'term-pager-discard)
+ (define-key map "D" 'term-pager-disable)
+ (define-key map "<" 'term-pager-bob)
+ (define-key map ">" 'term-pager-eob)
+
+ ;; Add menu bar.
+ (progn
+ (term-ifnot-xemacs
+ (define-key map [menu-bar terminal] term-terminal-menu)
+ (define-key map [menu-bar signals] term-signals-menu)
+ (setq tmp (make-sparse-keymap "More pages?"))
+ (define-key tmp [help] '("Help" . term-pager-help))
+ (define-key tmp [disable]
+ '("Disable paging" . term-fake-pager-disable))
+ (define-key tmp [discard]
+ '("Discard remaining output" . term-pager-discard))
+ (define-key tmp [eob] '("Goto to end" . term-pager-eob))
+ (define-key tmp [bob] '("Goto to beginning" . term-pager-bob))
+ (define-key tmp [line] '("1 line forwards" . term-pager-line))
+ (define-key tmp [bline] '("1 line backwards" . term-pager-back-line))
+ (define-key tmp [back] '("1 page backwards" . term-pager-back-page))
+ (define-key tmp [page] '("1 page forwards" . term-pager-page))
+ (define-key map [menu-bar page] (cons "More pages?" tmp))
+ ))
+
+ (setq term-pager-break-map map)))
+ ; (let ((process (get-buffer-process (current-buffer))))
+ ; (stop-process process))
+ (setq term-pager-old-local-map (current-local-map))
+ (use-local-map term-pager-break-map)
+ (make-local-variable 'term-old-mode-line-format)
+ (setq term-old-mode-line-format mode-line-format)
+ (setq mode-line-format
+ (list "-- **MORE** "
+ mode-line-buffer-identification
+ " [Type ? for help] "
+ "%-"))
+ (force-mode-line-update))
+
+ (defun term-pager-line (lines)
+ (interactive "p")
+ (let* ((moved (vertical-motion (1+ lines)))
+ (deficit (- lines moved)))
+ (if (> moved lines)
+ (backward-char))
+ (cond ((<= deficit 0) ;; OK, had enough in the buffer for request.
+ (recenter (1- term-height)))
+ ((term-pager-continue deficit)))))
+
+ (defun term-pager-page (arg)
+ "Proceed past the **MORE** break, allowing the next page of output to
appear"
+ (interactive "p")
+ (term-pager-line (* arg term-height)))
+
+ ; Pager mode command to go to beginning of buffer
+ (defun term-pager-bob ()
+ (interactive)
+ (goto-char (point-min))
+ (if (= (vertical-motion term-height) term-height)
+ (backward-char))
+ (recenter (1- term-height)))
+
+ ; pager mode command to go to end of buffer
+ (defun term-pager-eob ()
+ (interactive)
+ (goto-char term-home-marker)
+ (recenter 0)
+ (goto-char (process-mark (get-buffer-process (current-buffer)))))
+
+ (defun term-pager-back-line (lines)
+ (interactive "p")
+ (vertical-motion (- 1 lines))
+ (if (not (bobp))
+ (backward-char)
+ (beep)
+ ;; Move cursor to end of window.
+ (vertical-motion term-height)
+ (backward-char))
+ (recenter (1- term-height)))
+
+ (defun term-pager-back-page (arg)
+ (interactive "p")
+ (term-pager-back-line (* arg term-height)))
+
+ (defun term-pager-discard ()
+ (interactive)
+ (setq term-terminal-parameter "")
+ (interrupt-process nil t)
+ (term-pager-continue term-height))
+
+ ; Disable pager processing.
+ ; Only callable while in pager mode. (Contrast term-disable-pager.)
+ (defun term-pager-disable ()
+ (interactive)
+ (if (term-handling-pager)
+ (term-pager-continue nil)
+ (setq term-pager-count nil))
+ (term-update-mode-line))
+
+ ; Enable pager processing.
+ (defun term-pager-enable ()
+ (interactive)
+ (or (term-pager-enabled)
+ (setq term-pager-count 0)) ;; Or maybe set to (term-current-row) ??
+ (term-update-mode-line))
+
+ (defun term-pager-toggle ()
+ (interactive)
+ (if (term-pager-enabled) (term-pager-disable) (term-pager-enable)))
+
+ (term-ifnot-xemacs
+ (defalias 'term-fake-pager-enable 'term-pager-toggle)
+ (defalias 'term-fake-pager-disable 'term-pager-toggle)
+ (put 'term-char-mode 'menu-enable '(term-in-line-mode))
+ (put 'term-line-mode 'menu-enable '(term-in-char-mode))
+ (put 'term-fake-pager-enable 'menu-enable '(not term-pager-count))
+ (put 'term-fake-pager-disable 'menu-enable 'term-pager-count))
+
+ (defun term-pager-help ()
+ "Provide help on commands available in a terminal-emulator **MORE** break"
+ (interactive)
+ (message "Terminal-emulator pager break help...")
+ (sit-for 0)
+ (with-electric-help
+ (function (lambda ()
+ (princ (substitute-command-keys
+ "\\<term-pager-break-map>\
+ Terminal-emulator MORE break.\n\
+ Type one of the following keys:\n\n\
+ \\[term-pager-page]\t\tMove forward one page.\n\
+ \\[term-pager-line]\t\tMove forward one line.\n\
+ \\[universal-argument] N \\[term-pager-page]\tMove N pages forward.\n\
+ \\[universal-argument] N \\[term-pager-line]\tMove N lines forward.\n\
+ \\[universal-argument] N \\[term-pager-back-line]\tMove N lines back.\n\
+ \\[universal-argument] N \\[term-pager-back-page]\t\tMove N pages back.\n\
+ \\[term-pager-bob]\t\tMove to the beginning of the buffer.\n\
+ \\[term-pager-eob]\t\tMove to the end of the buffer.\n\
+ \\[term-pager-discard]\t\tKill pending output and kill process.\n\
+ \\[term-pager-disable]\t\tDisable PAGER handling.\n\n\
+ \\{term-pager-break-map}\n\
+ Any other key is passed through to the program
+ running under the terminal emulator and disables pager processing until
+ all pending output has been dealt with."))
+ nil))))
+
+ (defun term-pager-continue (new-count)
+ (let ((process (get-buffer-process (current-buffer))))
+ (use-local-map term-pager-old-local-map)
+ (setq term-pager-old-local-map nil)
+ (setq mode-line-format term-old-mode-line-format)
+ (force-mode-line-update)
+ (setq term-pager-count new-count)
+ (set-process-filter process term-pager-old-filter)
+ (funcall term-pager-old-filter process "")
+ (continue-process process)))
+
+ ;; Make sure there are DOWN blank lines below the current one.
+ ;; Return 0 if we're unable (because of PAGER handling), else return DOWN.
+
+ (defun term-handle-scroll (down)
+ (let ((scroll-needed
+ (- (+ (term-current-row) down 1) term-scroll-end)))
+ (if (> scroll-needed 0)
+ (let ((save-point (copy-marker (point))) (save-top))
+ (goto-char term-home-marker)
+ (cond (term-scroll-with-delete
+ ;; delete scroll-needed lines at term-scroll-start
+ (term-vertical-motion term-scroll-start)
+ (setq save-top (point))
+ (term-vertical-motion scroll-needed)
+ (delete-region save-top (point))
+ (goto-char save-point)
+ (term-vertical-motion down)
+ (term-adjust-current-row-cache (- scroll-needed))
+ (setq term-current-column nil)
+ (term-insert-char ?\n scroll-needed))
+ ((and (numberp term-pager-count)
+ (< (setq term-pager-count (- term-pager-count down))
+ 0))
+ (setq down 0)
+ (term-process-pager))
+ (t
+ (term-adjust-current-row-cache (- scroll-needed))
+ (term-vertical-motion scroll-needed)
+ (set-marker term-home-marker (point))))
+ (goto-char save-point)
+ (set-marker save-point nil))))
+ down)
+
+ (defun term-down (down &optional check-for-scroll)
+ "Move down DOWN screen lines vertically."
+ (let ((start-column (term-horizontal-column)))
+ (if (and check-for-scroll (or term-scroll-with-delete term-pager-count))
+ (setq down (term-handle-scroll down)))
+ (term-adjust-current-row-cache down)
+ (if (/= (point) (point-max))
+ (setq down (- down (term-vertical-motion down))))
+ ;; Extend buffer with extra blank lines if needed.
+ (cond ((> down 0)
+ (term-insert-char ?\n down)
+ (setq term-current-column 0)
+ (setq term-start-line-column 0))
+ (t
+ (setq term-current-column nil)
+ (setq term-start-line-column (current-column))))
+ (if start-column
+ (term-move-columns start-column))))
+
+ ;; Assuming point is at the beginning of a screen line,
+ ;; if the line above point wraps around, add a ?\n to undo the wrapping.
+ ;; FIXME: Probably should be called more than it is.
+ (defun term-unwrap-line ()
+ (if (not (bolp)) (insert-before-markers ?\n)))
+
+ (defun term-erase-in-line (kind)
+ (if (> kind 1) ;; erase left of point
+ (let ((cols (term-horizontal-column)) (saved-point (point)))
+ (term-vertical-motion 0)
+ (delete-region (point) saved-point)
+ (term-insert-char ?\n cols)))
+ (if (not (eq kind 1)) ;; erase right of point
+ (let ((saved-point (point))
+ (wrapped (and (zerop (term-horizontal-column))
+ (not (zerop (term-current-column))))))
+ (term-vertical-motion 1)
+ (delete-region saved-point (point))
+ ;; wrapped is true if we're at the beginning of screen line,
+ ;; but not a buffer line. If we delete the current screen line
+ ;; that will make the previous line no longer wrap, and (because
+ ;; of the way Emacs display works) point will be at the end of
+ ;; the previous screen line rather then the beginning of the
+ ;; current one. To avoid that, we make sure that current line
+ ;; contain a space, to force the previous line to continue to wrap.
+ ;; We could do this always, but it seems preferable to not add the
+ ;; extra space when wrapped is false.
+ (if wrapped
+ (insert ? ))
+ (insert ?\n)
+ (put-text-property saved-point (point) 'face 'default)
+ (goto-char saved-point))))
+
+ (defun term-erase-in-display (kind)
+ "Erases (that is blanks out) part of the window.
+ If KIND is 0, erase from (point) to (point-max);
+ if KIND is 1, erase from home to point; else erase from home to point-max.
+ Should only be called when point is at the start of a screen line."
+ (term-handle-deferred-scroll)
+ (cond ((eq term-terminal-parameter 0)
+ (delete-region (point) (point-max))
+ (term-unwrap-line))
+ ((let ((row (term-current-row))
+ (col (term-horizontal-column))
+ (start-region term-home-marker)
+ (end-region (if (eq kind 1) (point) (point-max))))
+ (delete-region start-region end-region)
+ (term-unwrap-line)
+ (if (eq kind 1)
+ (term-insert-char ?\n row))
+ (setq term-current-column nil)
+ (setq term-current-row nil)
+ (term-goto row col)))))
+
+ (defun term-delete-chars (count)
+ (let ((save-point (point)))
+ (term-vertical-motion 1)
+ (term-unwrap-line)
+ (goto-char save-point)
+ (move-to-column (+ (term-current-column) count) t)
+ (delete-region save-point (point))))
+
+ ;;; Insert COUNT spaces after point, but do not change any of
+ ;;; following screen lines. Hence we may have to delete characters
+ ;;; at teh end of this screen line to make room.
+
+ (defun term-insert-spaces (count)
+ (let ((save-point (point)) (save-eol))
+ (term-vertical-motion 1)
+ (if (bolp)
+ (backward-char))
+ (setq save-eol (point))
+ (move-to-column (+ (term-start-line-column) (- term-width count)) t)
+ (if (> save-eol (point))
+ (delete-region (point) save-eol))
+ (goto-char save-point)
+ (term-insert-char ? count)
+ (goto-char save-point)))
+
+ (defun term-delete-lines (lines)
+ (let ((start (point))
+ (save-current-column term-current-column)
+ (save-start-line-column term-start-line-column)
+ (save-current-row (term-current-row)))
+ (term-down lines)
+ (delete-region start (point))
+ (term-down (- term-scroll-end save-current-row lines))
+ (term-insert-char ?\n lines)
+ (setq term-current-column save-current-column)
+ (setq term-start-line-column save-start-line-column)
+ (setq term-current-row save-current-row)
+ (goto-char start)))
+
+ (defun term-insert-lines (lines)
+ (let ((start (point))
+ (start-deleted)
+ (save-current-column term-current-column)
+ (save-start-line-column term-start-line-column)
+ (save-current-row (term-current-row)))
+ (term-down (- term-scroll-end save-current-row lines))
+ (setq start-deleted (point))
+ (term-down lines)
+ (delete-region start-deleted (point))
+ (goto-char start)
+ (setq term-current-column save-current-column)
+ (setq term-start-line-column save-start-line-column)
+ (setq term-current-row save-current-row)
+ (term-insert-char ?\n lines)
+ (goto-char start)))
+
+ (defun term-set-output-log (name)
+ "Record raw inferior process output in a buffer."
+ (interactive (list (if term-log-buffer
+ nil
+ (read-buffer "Record output in buffer: "
+ (format "%s output-log"
+ (buffer-name (current-buffer)))
+ nil))))
+ (if (or (null name) (equal name ""))
+ (progn (setq term-log-buffer nil)
+ (message "Output logging off."))
+ (if (get-buffer name)
+ nil
+ (save-excursion
+ (set-buffer (get-buffer-create name))
+ (fundamental-mode)
+ (buffer-disable-undo (current-buffer))
+ (erase-buffer)))
+ (setq term-log-buffer (get-buffer name))
+ (message "Recording terminal emulator output into buffer \"%s\""
+ (buffer-name term-log-buffer))))
+
+ (defun term-stop-photo ()
+ "Discontinue raw inferior process logging."
+ (interactive)
+ (term-set-output-log nil))
+
+ (defun term-show-maximum-output ()
+ "Put the end of the buffer at the bottom of the window."
+ (interactive)
+ (goto-char (point-max))
+ (recenter -1))
+
+ ;;; Do the user's customisation...
+
+ (defvar term-load-hook nil
+ "This hook is run when term is loaded in.
+ This is a good place to put keybindings.")
+
+ (run-hooks 'term-load-hook)
+
+
+ ;;; Filename/command/history completion in a buffer
+ ;;;
===========================================================================
+ ;;; Useful completion functions, courtesy of the Ergo group.
+
+ ;;; Six commands:
+ ;;; term-dynamic-complete Complete or expand command, filename,
+ ;;; history at point.
+ ;;; term-dynamic-complete-filename Complete filename at point.
+ ;;; term-dynamic-list-filename-completions List completions in help buffer.
+ ;;; term-replace-by-expanded-filename Expand and complete filename at point;
+ ;;; replace with expanded/completed name.
+ ;;; term-dynamic-simple-complete Complete stub given candidates.
+
+ ;;; These are not installed in the term-mode keymap. But they are
+ ;;; available for people who want them. Shell-mode installs them:
+ ;;; (define-key shell-mode-map "\t" 'term-dynamic-complete)
+ ;;; (define-key shell-mode-map "\M-?"
+ ;;; 'term-dynamic-list-filename-completions)))
+ ;;;
+ ;;; Commands like this are fine things to put in load hooks if you
+ ;;; want them present in specific modes.
+
+ (defvar term-completion-autolist nil
+ "*If non-nil, automatically list possibilities on partial completion.
+ This mirrors the optional behavior of tcsh.")
+
+ (defvar term-completion-addsuffix t
+ "*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.")
+
+ (defvar term-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 `term-completion-autolist' is non-nil too.")
+
+ (defvar term-completion-fignore nil
+ "*List of suffixes to be disregarded during file completion.
+ This mirrors the optional behavior of bash and tcsh.
+
+ Note that this applies to `term-dynamic-complete-filename' only.")
+
+ (defvar term-file-name-prefix ""
+ "Prefix prepended to absolute file names taken from process input.
+ This is used by term's and shell's completion functions, and by shell's
+ directory tracking functions.")
+
+
+ (defun term-directory (directory)
+ ;; Return expanded DIRECTORY, with `term-file-name-prefix' if absolute.
+ (expand-file-name (if (file-name-absolute-p directory)
+ (concat term-file-name-prefix directory)
+ directory)))
+
+
+ (defun term-word (word-chars)
+ "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')."
+ (save-excursion
+ (let ((limit (point))
+ (word (concat "[" word-chars "]"))
+ (non-word (concat "[^" word-chars "]")))
+ (if (re-search-backward non-word nil 'move)
+ (forward-char 1))
+ ;; Anchor the search forwards.
+ (if (or (eolp) (looking-at non-word))
+ nil
+ (re-search-forward (concat word "+") limit)
+ (buffer-substring (match-beginning 0) (match-end 0))))))
+
+
+ (defun term-match-partial-filename ()
+ "Return the filename at point, or nil if non is found.
+ Environment variables are substituted. See `term-word'."
+ (let ((filename (term-word "~/A-Za-z0-9+@:_.$#,={}-")))
+ (and filename (substitute-in-file-name filename))))
+
+
+ (defun term-dynamic-complete ()
+ "Dynamically perform completion at point.
+ Calls the functions in `term-dynamic-complete-functions' to perform
+ completion until a function returns non-nil, at which point completion is
+ assumed to have occurred."
+ (interactive)
+ (let ((functions term-dynamic-complete-functions))
+ (while (and functions (null (funcall (car functions))))
+ (setq functions (cdr functions)))))
+
+
+ (defun term-dynamic-complete-filename ()
+ "Dynamically complete the filename at point.
+ Completes if after a filename. See `term-match-partial-filename' and
+ `term-dynamic-complete-as-filename'.
+ This function is similar to `term-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 `term-completion-addsuffix',
+ `term-completion-recexact' and `term-completion-fignore', and the timing of
+ completions listing is dependent on the value of `term-completion-autolist'.
+
+ Returns t if successful."
+ (interactive)
+ (if (term-match-partial-filename)
+ (prog2 (or (eq (selected-window) (minibuffer-window))
+ (message "Completing file name..."))
+ (term-dynamic-complete-as-filename))))
+
+ (defun term-dynamic-complete-as-filename ()
+ "Dynamically complete at point as a filename.
+ See `term-dynamic-complete-filename'. Returns t if successful."
+ (let* ((completion-ignore-case nil)
+ (completion-ignored-extensions term-completion-fignore)
+ (success t)
+ (dirsuffix (cond ((not term-completion-addsuffix) "")
+ ((not (consp term-completion-addsuffix)) "/")
+ (t (car term-completion-addsuffix))))
+ (filesuffix (cond ((not term-completion-addsuffix) "")
+ ((not (consp term-completion-addsuffix)) " ")
+ (t (cdr term-completion-addsuffix))))
+ (filename (or (term-match-partial-filename) ""))
+ (pathdir (file-name-directory filename))
+ (pathnondir (file-name-nondirectory filename))
+ (directory (if pathdir (term-directory pathdir) default-directory))
+ (completion (file-name-completion pathnondir directory))
+ (mini-flag (eq (selected-window) (minibuffer-window))))
+ (cond ((null completion)
+ (message "No completions of %s" filename)
+ (setq success nil))
+ ((eq completion t) ; Means already completed "file".
+ (if term-completion-addsuffix (insert " "))
+ (or mini-flag (message "Sole completion")))
+ ((string-equal completion "") ; Means completion on "directory/".
+ (term-dynamic-list-filename-completions))
+ (t ; Completion string returned.
+ (let ((file (concat (file-name-as-directory directory)
completion)))
+ (insert (substring (directory-file-name completion)
+ (length pathnondir)))
+ (cond ((symbolp (file-name-completion completion directory))
+ ;; We inserted a unique completion.
+ (insert (if (file-directory-p file) dirsuffix filesuffix))
+ (or mini-flag (message "Completed")))
+ ((and term-completion-recexact term-completion-addsuffix
+ (string-equal pathnondir completion)
+ (file-exists-p file))
+ ;; It's not unique, but user wants shortest match.
+ (insert (if (file-directory-p file) dirsuffix filesuffix))
+ (or mini-flag (message "Completed shortest")))
+ ((or term-completion-autolist
+ (string-equal pathnondir completion))
+ ;; It's not unique, list possible completions.
+ (term-dynamic-list-filename-completions))
+ (t
+ (or mini-flag (message "Partially completed")))))))
+ success))
+
+
+ (defun term-replace-by-expanded-filename ()
+ "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
+ `term-dynamic-complete-filename'."
+ (interactive)
+ (replace-match (expand-file-name (term-match-partial-filename)) t t)
+ (term-dynamic-complete-filename))
+
+
+ (defun term-dynamic-simple-complete (stub candidates)
+ "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 `term-dynamic-complete-filename'."
+ (let* ((completion-ignore-case nil)
+ (candidates (mapcar (function (lambda (x) (list x))) candidates))
+ (completions (all-completions stub candidates)))
+ (cond ((null completions)
+ (message "No completions of %s" stub)
+ nil)
+ ((= 1 (length completions)) ; Gotcha!
+ (let ((completion (car completions)))
+ (if (string-equal completion stub)
+ (message "Sole completion")
+ (insert (substring completion (length stub)))
+ (message "Completed"))
+ (if term-completion-addsuffix (insert " "))
+ 'sole))
+ (t ; There's no unique completion.
+ (let ((completion (try-completion stub candidates)))
+ ;; Insert the longest substring.
+ (insert (substring completion (length stub)))
+ (cond ((and term-completion-recexact term-completion-addsuffix
+ (string-equal stub completion)
+ (member completion completions))
+ ;; It's not unique, but user wants shortest match.
+ (insert " ")
+ (message "Completed shortest")
+ 'shortest)
+ ((or term-completion-autolist
+ (string-equal stub completion))
+ ;; It's not unique, list possible completions.
+ (term-dynamic-list-completions completions)
+ 'listed)
+ (t
+ (message "Partially completed")
+ 'partial)))))))
+
+
+ (defun term-dynamic-list-filename-completions ()
+ "List in help buffer possible completions of the filename at point."
+ (interactive)
+ (let* ((completion-ignore-case nil)
+ (filename (or (term-match-partial-filename) ""))
+ (pathdir (file-name-directory filename))
+ (pathnondir (file-name-nondirectory filename))
+ (directory (if pathdir (term-directory pathdir) default-directory))
+ (completions (file-name-all-completions pathnondir directory)))
+ (if completions
+ (term-dynamic-list-completions completions)
+ (message "No completions of %s" filename))))
+
+
+ (defun term-dynamic-list-completions (completions)
+ "List in help buffer sorted COMPLETIONS.
+ Typing SPC flushes the help buffer."
+ (let ((conf (current-window-configuration)))
+ (with-output-to-temp-buffer "*Completions*"
+ (display-completion-list (sort completions 'string-lessp)))
+ (message "Hit space to flush")
+ (let (key first)
+ (if (save-excursion
+ (set-buffer (get-buffer "*Completions*"))
+ (setq key (read-key-sequence nil)
+ first (aref key 0))
+ (and (consp first)
+ (eq (window-buffer (posn-window (event-start first)))
+ (get-buffer "*Completions*"))
+ (eq (key-binding key) 'mouse-choose-completion)))
+ ;; If the user does mouse-choose-completion with the mouse,
+ ;; execute the command, then delete the completion window.
+ (progn
+ (mouse-choose-completion first)
+ (set-window-configuration conf))
+ (if (eq first ?\ )
+ (set-window-configuration conf)
+ (setq unread-command-events (listify-key-sequence key)))))))
+
+ ;;; I need a make-term that doesn't surround with *s -mm
+ (defun term-ansi-make-term (name program &optional startfile &rest switches)
+ "Make a term process NAME in a buffer, running PROGRAM.
+ The name of the buffer is NAME.
+ 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."
+ (let ((buffer (get-buffer-create name )))
+ ;; If no process, or nuked process, crank up a new one and put buffer in
+ ;; term mode. Otherwise, leave buffer and existing process alone.
+ (cond ((not (term-check-proc buffer))
+ (save-excursion
+ (set-buffer buffer)
+ (term-mode)) ; Install local vars, mode, keymap, ...
+ (term-exec buffer name program startfile switches)))
+ buffer))
+
+ (defvar term-ansi-buffer-name nil)
+ (defvar term-ansi-default-program nil)
+ (defvar term-ansi-buffer-base-name nil)
+
+ ;;;###autoload
+ (defun ansi-term (program &optional new-buffer-name)
+ "Start a terminal-emulator in a new buffer."
+ (interactive (list (read-from-minibuffer "Run program: "
+ (or explicit-shell-file-name
+ (getenv "ESHELL")
+ (getenv "SHELL")
+ "/bin/sh"))))
+
+ ;; Pick the name of the new buffer.
+ (setq term-ansi-buffer-name
+ (if new-buffer-name
+ new-buffer-name
+ (if term-ansi-buffer-base-name
+ (if (eq term-ansi-buffer-base-name t)
+ (file-name-nondirectory program)
+ term-ansi-buffer-base-name)
+ "ansi-term")))
+
+ (setq term-ansi-buffer-name (concat "*" term-ansi-buffer-name "*"))
+
+ ;; In order to have more than one term active at a time
+ ;; I'd like to have the term names have the *term-ansi-term<?>* form,
+ ;; for now they have the *term-ansi-term*<?> form but we'll see...
+
+ (setq term-ansi-buffer-name (generate-new-buffer-name
term-ansi-buffer-name))
+ (setq term-ansi-buffer-name (term-ansi-make-term term-ansi-buffer-name
program))
+
+ (set-buffer term-ansi-buffer-name)
+ (term-mode)
+ (term-char-mode)
+
+ ;; I wanna have find-file on C-x C-f -mm
+ ;; your mileage may definitely vary, maybe it's better to put this in your
+ ;; .emacs ...
+
+ (term-set-escape-char ?\C-x)
+
+ (switch-to-buffer term-ansi-buffer-name))
+
+
+ ;;; Converting process modes to use term mode
+ ;;;
===========================================================================
+ ;;; Renaming variables
+ ;;; Most of the work is renaming variables and functions. These are the
common
+ ;;; ones:
+ ;;; Local variables:
+ ;;; last-input-start term-last-input-start
+ ;;; last-input-end term-last-input-end
+ ;;; shell-prompt-pattern term-prompt-regexp
+ ;;; shell-set-directory-error-hook <no equivalent>
+ ;;; Miscellaneous:
+ ;;; shell-set-directory <unnecessary>
+ ;;; shell-mode-map term-mode-map
+ ;;; Commands:
+ ;;; shell-send-input term-send-input
+ ;;; shell-send-eof term-delchar-or-maybe-eof
+ ;;; kill-shell-input term-kill-input
+ ;;; interrupt-shell-subjob term-interrupt-subjob
+ ;;; stop-shell-subjob term-stop-subjob
+ ;;; quit-shell-subjob term-quit-subjob
+ ;;; kill-shell-subjob term-kill-subjob
+ ;;; kill-output-from-shell term-kill-output
+ ;;; show-output-from-shell term-show-output
+ ;;; copy-last-shell-input Use term-previous-input/term-next-input
+ ;;;
+ ;;; SHELL-SET-DIRECTORY is gone, its functionality taken over by
+ ;;; SHELL-DIRECTORY-TRACKER, the shell mode's term-input-filter-functions.
+ ;;; Term mode does not provide functionality equivalent to
+ ;;; shell-set-directory-error-hook; it is gone.
+ ;;;
+ ;;; term-last-input-start is provided for modes which want to munge
+ ;;; the buffer after input is sent, perhaps because the inferior
+ ;;; insists on echoing the input. The LAST-INPUT-START variable in
+ ;;; the old shell package was used to implement a history mechanism,
+ ;;; but you should think twice before using term-last-input-start
+ ;;; for this; the input history ring often does the job better.
+ ;;;
+ ;;; If you are implementing some process-in-a-buffer mode, called foo-mode, do
+ ;;; *not* create the term-mode local variables in your foo-mode function.
+ ;;; This is not modular. Instead, call term-mode, and let *it* create the
+ ;;; necessary term-specific local variables. Then create the
+ ;;; foo-mode-specific local variables in foo-mode. Set the buffer's keymap to
+ ;;; be foo-mode-map, and its mode to be foo-mode. Set the term-mode hooks
+ ;;; (term-{prompt-regexp, input-filter, input-filter-functions,
+ ;;; get-old-input) that need to be different from the defaults. Call
+ ;;; foo-mode-hook, and you're done. Don't run the term-mode hook yourself;
+ ;;; term-mode will take care of it. The following example, from shell.el,
+ ;;; is typical:
+ ;;;
+ ;;; (defvar shell-mode-map '())
+ ;;; (cond ((not shell-mode-map)
+ ;;; (setq shell-mode-map (copy-keymap term-mode-map))
+ ;;; (define-key shell-mode-map "\C-c\C-f" 'shell-forward-command)
+ ;;; (define-key shell-mode-map "\C-c\C-b" 'shell-backward-command)
+ ;;; (define-key shell-mode-map "\t" 'term-dynamic-complete)
+ ;;; (define-key shell-mode-map "\M-?"
+ ;;; 'term-dynamic-list-filename-completions)))
+ ;;;
+ ;;; (defun shell-mode ()
+ ;;; (interactive)
+ ;;; (term-mode)
+ ;;; (setq term-prompt-regexp shell-prompt-pattern)
+ ;;; (setq major-mode 'shell-mode)
+ ;;; (setq mode-name "Shell")
+ ;;; (use-local-map shell-mode-map)
+ ;;; (make-local-variable 'shell-directory-stack)
+ ;;; (setq shell-directory-stack nil)
+ ;;; (add-hook 'term-input-filter-functions 'shell-directory-tracker)
+ ;;; (run-hooks 'shell-mode-hook))
+ ;;;
+ ;;;
+ ;;; Completion for term-mode users
+ ;;;
+ ;;; For modes that use term-mode, term-dynamic-complete-functions is the
+ ;;; hook to add completion functions to. Functions on this list should return
+ ;;; non-nil if completion occurs (i.e., further completion should not occur).
+ ;;; You could use term-dynamic-simple-complete to do the bulk of the
+ ;;; completion job.
+
+ (provide 'term)
+
+ ;;; arch-tag: eee16bc8-2cd7-4147-9534-a5694752f716
+ ;;; term.el ends here
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] Changes to emacs/lisp/term.el [gnus-5_10-branch],
Miles Bader <=