| 1 | ;;; term.el --- general command interpreter in a window stuff |
| 2 | |
| 3 | ;; Copyright (C) 1988, 1990, 1992, 1994, 1995, 2002, 2003, |
| 4 | ;; 2004, 2005, 2006 Free Software Foundation, Inc. |
| 5 | |
| 6 | ;; Author: Per Bothner <per@bothner.com> |
| 7 | ;; Maintainer: Dan Nicolaescu <dann@ics.uci.edu>, Per Bothner <per@bothner.com> |
| 8 | ;; Based on comint mode written by: Olin Shivers <shivers@cs.cmu.edu> |
| 9 | ;; Keywords: processes |
| 10 | |
| 11 | ;; This file is part of GNU Emacs. |
| 12 | |
| 13 | ;; GNU Emacs is free software; you can redistribute it and/or modify |
| 14 | ;; it under the terms of the GNU General Public License as published by |
| 15 | ;; the Free Software Foundation; either version 2, or (at your option) |
| 16 | ;; any later version. |
| 17 | |
| 18 | ;; GNU Emacs is distributed in the hope that it will be useful, |
| 19 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 20 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 21 | ;; GNU General Public License for more details. |
| 22 | |
| 23 | ;; You should have received a copy of the GNU General Public License |
| 24 | ;; along with GNU Emacs; see the file COPYING. If not, write to the |
| 25 | ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| 26 | ;; Boston, MA 02110-1301, USA. |
| 27 | |
| 28 | ;;; Marck 13 2001 |
| 29 | ;;; Fixes for CJK support by Yong Lu <lyongu@yahoo.com>. |
| 30 | |
| 31 | ;;; Dir/Hostname tracking and ANSI colorization by |
| 32 | ;;; Marco Melgazzi <marco@techie.com>. |
| 33 | |
| 34 | ;;; To see what I've modified and where it came from search for '-mm' |
| 35 | |
| 36 | ;;; Commentary: |
| 37 | |
| 38 | ;;; Speed considerations and a few caveats |
| 39 | ;;; -------------------------------------- |
| 40 | ;;; |
| 41 | ;;; While the message passing and the colorization surely introduce some |
| 42 | ;;; overhead this has became so small that IMHO is surely outweighted by |
| 43 | ;;; the benefits you get but, as usual, YMMV |
| 44 | ;;; |
| 45 | ;;; Important caveat, when deciding the cursor/'grey keys' keycodes I had to |
| 46 | ;;; make a choice: on my Linux box this choice allows me to run all the |
| 47 | ;;; ncurses applications without problems but make these keys |
| 48 | ;;; uncomprehensible to all the cursesX programs. Your mileage may vary so |
| 49 | ;;; you may consider changing the default 'emulation'. Just search for this |
| 50 | ;;; piece of code and modify it as you like: |
| 51 | ;;; |
| 52 | ;;; ;; Which would be better: "\e[A" or "\eOA"? readline accepts either. |
| 53 | ;;; ;; For my configuration it's definitely better \eOA but YMMV. -mm |
| 54 | ;;; ;; For example: vi works with \eOA while elm wants \e[A ... |
| 55 | ;;; (defun term-send-up () (interactive) (term-send-raw-string "\eOA")) |
| 56 | ;;; (defun term-send-down () (interactive) (term-send-raw-string "\eOB")) |
| 57 | ;;; (defun term-send-right () (interactive) (term-send-raw-string "\eOC")) |
| 58 | ;;; (defun term-send-left () (interactive) (term-send-raw-string "\eOD")) |
| 59 | ;;; |
| 60 | ;;; |
| 61 | ;;; IMPORTANT: additions & changes |
| 62 | ;;; ------------------------------ |
| 63 | ;;; |
| 64 | ;;; With this enhanced ansi-term.el you will get a reliable mechanism of |
| 65 | ;;; directory/username/host tracking: the only drawback is that you will |
| 66 | ;;; have to modify your shell start-up script. It's worth it, believe me :). |
| 67 | ;;; |
| 68 | ;;; When you rlogin/su/telnet and the account you access has a modified |
| 69 | ;;; startup script, you will be able to access the remote files as usual |
| 70 | ;;; with C-x C-f, if it's needed you will have to enter a password, |
| 71 | ;;; otherwise the file should get loaded straight away. |
| 72 | ;;; |
| 73 | ;;; This is useful even if you work only on one host: it often happens that, |
| 74 | ;;; for maintenance reasons, you have to edit files 'as root': before |
| 75 | ;;; patching term.el, I su-ed in a term.el buffer and used vi :), now I |
| 76 | ;;; simply do a C-x C-f and, via ange-ftp, the file is automatically loaded |
| 77 | ;;; 'as-root'. ( If you don't want to enter the root password every time you |
| 78 | ;;; can put it in your .netrc: note that this is -not- advisable if you're |
| 79 | ;;; connected to the internet or if somebody else works on your workstation!) |
| 80 | ;;; |
| 81 | ;;; If you use wu-ftpd you can use some of its features to avoid root ftp |
| 82 | ;;; access to the rest of the world: just put in /etc/ftphosts something like |
| 83 | ;;; |
| 84 | ;;; # Local access |
| 85 | ;;; allow root 127.0.0.1 |
| 86 | ;;; |
| 87 | ;;; # By default nobody can't do anything |
| 88 | ;;; deny root * |
| 89 | ;;; |
| 90 | ;;; |
| 91 | ;;; ---------------------------------------- |
| 92 | ;;; |
| 93 | ;;; If, instead of 'term', you call 'ansi-term', you get multiple term |
| 94 | ;;; buffers, after every new call ansi-term opens a new *ansi-term*<xx> window, |
| 95 | ;;; where <xx> is, as usual, a number... |
| 96 | ;;; |
| 97 | ;;; ---------------------------------------- |
| 98 | ;;; |
| 99 | ;;; With the term-buffer-maximum-size you can finally decide how many |
| 100 | ;;; scrollback lines to keep: its default is 2048 but you can change it as |
| 101 | ;;; usual. |
| 102 | ;;; |
| 103 | ;;; ---------------------------------------- |
| 104 | ;;; |
| 105 | ;;; |
| 106 | ;;; ANSI colorization should work well, I've decided to limit the interpreter |
| 107 | ;;; to five outstanding commands (like ESC [ 01;04;32;41;07m. |
| 108 | ;;; You shouldn't need more, if you do, tell me and I'll increase it. It's |
| 109 | ;;; so easy you could do it yourself... |
| 110 | ;;; |
| 111 | ;;; Blink, is not supported. Currently it's mapped as bold. |
| 112 | ;;; |
| 113 | ;;; Important caveat: |
| 114 | ;;; ----------------- |
| 115 | ;;; if you want custom colors in term.el redefine term-default-fg-color |
| 116 | ;;; and term-default-bg-color BEFORE loading it. |
| 117 | ;;; |
| 118 | ;;; ---------------------------------------- |
| 119 | ;;; |
| 120 | ;;; If you'd like to check out my complete configuration, you can download |
| 121 | ;;; it from http://www.polito.it/~s64912/things.html, it's ~500k in size and |
| 122 | ;;; contains my .cshrc, .emacs and my whole site-lisp subdirectory. (notice |
| 123 | ;;; that this term.el may be newer/older than the one in there, please |
| 124 | ;;; check!) |
| 125 | ;;; |
| 126 | ;;; This complete configuration contains, among other things, a complete |
| 127 | ;;; rectangular marking solution (based on rect-mark.el and |
| 128 | ;;; pc-bindings.el) and should be a good example of how extensively Emacs |
| 129 | ;;; can be configured on a ppp-connected ws. |
| 130 | ;;; |
| 131 | ;;; ---------------------------------------- |
| 132 | ;;; |
| 133 | ;;; TODO: |
| 134 | ;;; |
| 135 | ;;; - Add hooks to allow raw-mode keys to be configurable |
| 136 | ;;; - Which keys are better ? \eOA or \e[A ? |
| 137 | ;;; |
| 138 | ;;; |
| 139 | ;;; Changes: |
| 140 | ;;; |
| 141 | ;;; V4.0 January 1997 |
| 142 | ;;; |
| 143 | ;;; - Huge reworking of the faces code: now we only have roughly 20-30 |
| 144 | ;;; faces for everything so we're even faster than the old md-term.el ! |
| 145 | ;;; - Finished removing all the J-Shell code. |
| 146 | ;;; |
| 147 | ;;; V3.0 January 1997 |
| 148 | ;;; |
| 149 | ;;; - Now all the supportable ANSI commands work well. |
| 150 | ;;; - Reworked a little the code: much less jsh-inspired stuff |
| 151 | ;;; |
| 152 | ;;; V2.3 November |
| 153 | ;;; |
| 154 | ;;; - Now all the faces are accessed through an array: much cleaner code. |
| 155 | ;;; |
| 156 | ;;; V2.2 November 4 1996 |
| 157 | ;;; |
| 158 | ;;; - Implemented ANSI output colorization ( a bit rough but enough for |
| 159 | ;;; color_ls ) |
| 160 | ;;; |
| 161 | ;;; - Implemented a maximum limit for the scroll buffer (stolen from |
| 162 | ;;; comint.el) |
| 163 | ;;; |
| 164 | ;;; v2.1 October 28 1996, first public release |
| 165 | ;;; |
| 166 | ;;; - Some new keybindings for term-char mode ( notably home/end/...) |
| 167 | ;;; - Directory, hostname and username tracking via ange-ftp |
| 168 | ;;; - Multi-term capability via the ansi-term call |
| 169 | ;;; |
| 170 | ;;; ---------------------------------------------------------------- |
| 171 | ;;; You should/could have something like this in your .emacs to take |
| 172 | ;;; full advantage of this package |
| 173 | ;;; |
| 174 | ;;; (add-hook 'term-mode-hook |
| 175 | ;;; (function |
| 176 | ;;; (lambda () |
| 177 | ;;; (setq term-prompt-regexp "^[^#$%>\n]*[#$%>] *") |
| 178 | ;;; (make-local-variable 'mouse-yank-at-point) |
| 179 | ;;; (make-local-variable 'transient-mark-mode) |
| 180 | ;;; (setq mouse-yank-at-point t) |
| 181 | ;;; (setq transient-mark-mode nil) |
| 182 | ;;; (auto-fill-mode -1) |
| 183 | ;;; (setq tab-width 8 )))) |
| 184 | ;;; |
| 185 | ;;; |
| 186 | ;;; ---------------------------------------- |
| 187 | ;;; |
| 188 | ;;; If you want to use color ls the best setup is to have a different file |
| 189 | ;;; when you use eterm ( see above, mine is named .emacs_dircolors ). This |
| 190 | ;;; is necessary because some terminals, rxvt for example, need non-ansi |
| 191 | ;;; hacks to work ( for example on my rxvt white is wired to fg, and to |
| 192 | ;;; obtain normal white I have to do bold-white :) |
| 193 | ;;; |
| 194 | ;;; ---------------------------------------- |
| 195 | ;;; |
| 196 | ;;; |
| 197 | ;;; # Configuration file for the color ls utility |
| 198 | ;;; # This file goes in the /etc directory, and must be world readable. |
| 199 | ;;; # You can copy this file to .dir_colors in your $HOME directory to |
| 200 | ;;; # override the system defaults. |
| 201 | ;;; |
| 202 | ;;; # COLOR needs one of these arguments: 'tty' colorizes output to ttys, but |
| 203 | ;;; # not pipes. 'all' adds color characters to all output. 'none' shuts |
| 204 | ;;; # colorization off. |
| 205 | ;;; COLOR tty |
| 206 | ;;; OPTIONS -F |
| 207 | ;;; |
| 208 | ;;; # Below, there should be one TERM entry for each termtype that is |
| 209 | ;;; # colorizable |
| 210 | ;;; TERM eterm |
| 211 | ;;; |
| 212 | ;;; # EIGHTBIT, followed by '1' for on, '0' for off. (8-bit output) |
| 213 | ;;; EIGHTBIT 1 |
| 214 | ;;; |
| 215 | ;;; # Below are the color init strings for the basic file types. A color init |
| 216 | ;;; # string consists of one or more of the following numeric codes: |
| 217 | ;;; # Attribute codes: |
| 218 | ;;; # 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed |
| 219 | ;;; # Text color codes: |
| 220 | ;;; # 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white |
| 221 | ;;; # Background color codes: |
| 222 | ;;; # 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white |
| 223 | ;;; NORMAL 00 # global default, although everything should be something. |
| 224 | ;;; FILE 00 # normal file |
| 225 | ;;; DIR 00;37 # directory |
| 226 | ;;; LINK 00;36 # symbolic link |
| 227 | ;;; FIFO 00;37 # pipe |
| 228 | ;;; SOCK 40;35 # socket |
| 229 | ;;; BLK 33;01 # block device driver |
| 230 | ;;; CHR 33;01 # character device driver |
| 231 | ;;; |
| 232 | ;;; # This is for files with execute permission: |
| 233 | ;;; EXEC 00;32 |
| 234 | ;;; |
| 235 | ;;; # List any file extensions like '.gz' or '.tar' that you would like ls |
| 236 | ;;; # to colorize below. Put the extension, a space, and the color init |
| 237 | ;;; # string. (and any comments you want to add after a '#') |
| 238 | ;;; .tar 01;33 # archives or compressed |
| 239 | ;;; .tgz 01;33 |
| 240 | ;;; .arj 01;33 |
| 241 | ;;; .taz 01;33 |
| 242 | ;;; .lzh 01;33 |
| 243 | ;;; .zip 01;33 |
| 244 | ;;; .z 01;33 |
| 245 | ;;; .Z 01;33 |
| 246 | ;;; .gz 01;33 |
| 247 | ;;; .jpg 01;35 # image formats |
| 248 | ;;; .gif 01;35 |
| 249 | ;;; .bmp 01;35 |
| 250 | ;;; .xbm 01;35 |
| 251 | ;;; .xpm 01;35 |
| 252 | ;;; |
| 253 | ;;; |
| 254 | ;;; ---------------------------------------- |
| 255 | ;;; |
| 256 | ;;; Notice: for directory/host/user tracking you need to have something |
| 257 | ;;; like this in your shell startup script ( this is for tcsh but should |
| 258 | ;;; be quite easy to port to other shells ) |
| 259 | ;;; |
| 260 | ;;; ---------------------------------------- |
| 261 | ;;; |
| 262 | ;;; |
| 263 | ;;; set os = `uname` |
| 264 | ;;; set host = `hostname` |
| 265 | ;;; set date = `date` |
| 266 | ;;; |
| 267 | ;;; # su does not change this but I'd like it to |
| 268 | ;;; |
| 269 | ;;; set user = `whoami` |
| 270 | ;;; |
| 271 | ;;; # ... |
| 272 | ;;; |
| 273 | ;;; if ( eterm =~ $TERM ) then |
| 274 | ;;; |
| 275 | ;;; echo -------------------------------------------------------------- |
| 276 | ;;; echo Hello $user |
| 277 | ;;; echo Today is $date |
| 278 | ;;; echo We are on $host running $os under Emacs term mode |
| 279 | ;;; echo -------------------------------------------------------------- |
| 280 | ;;; |
| 281 | ;;; setenv EDITOR emacsclient |
| 282 | ;;; |
| 283 | ;;; # Notice: $host and $user have been set before to 'hostname' and 'whoami' |
| 284 | ;;; # this is necessary because, f.e., certain versions of 'su' do not change |
| 285 | ;;; # $user, YMMV: if you don't want to fiddle with them define a couple |
| 286 | ;;; # of new variables and use these instead. |
| 287 | ;;; # NOTICE that there is a space between "AnSiT?" and $whatever NOTICE |
| 288 | ;;; |
| 289 | ;;; # These are because we want the real cwd in the messages, not the login |
| 290 | ;;; # time one ! |
| 291 | ;;; |
| 292 | ;;; set cwd_hack='$cwd' |
| 293 | ;;; set host_hack='$host' |
| 294 | ;;; set user_hack='$user' |
| 295 | ;;; |
| 296 | ;;; # Notice that the ^[ character is an ESC, not two chars. You can |
| 297 | ;;; # get it in various ways, for example by typing |
| 298 | ;;; # echo -e '\033' > escape.file |
| 299 | ;;; # or by using your favourite editor |
| 300 | ;;; |
| 301 | ;;; foreach temp (cd pushd) |
| 302 | ;;; alias $temp "$temp \!* ; echo '\eAnSiTc' $cwd_hack" |
| 303 | ;;; end |
| 304 | ;;; alias popd 'popd ;echo "\eAnSiTc" $cwd' |
| 305 | ;;; |
| 306 | ;;; # Every command that can modify the user/host/directory should be aliased |
| 307 | ;;; # as follows for the tracking mechanism to work. |
| 308 | ;;; |
| 309 | ;;; foreach temp ( rlogin telnet rsh sh ksh csh tcsh zsh bash tcl su ) |
| 310 | ;;; alias $temp "$temp \!* ; echo '\eAnSiTh' $host_hack ; \ |
| 311 | ;;; echo '\eAnSiTu' $user_hack ;echo '\eAnSiTc' $cwd_hack" |
| 312 | ;;; end |
| 313 | ;;; |
| 314 | ;;; # Start up & use color ls |
| 315 | ;;; |
| 316 | ;;; echo "\eAnSiTh" $host |
| 317 | ;;; echo "\eAnSiTu" $user |
| 318 | ;;; echo "\eAnSiTc" $cwd |
| 319 | ;;; |
| 320 | ;;; # some housekeeping |
| 321 | ;;; |
| 322 | ;;; unset cwd_hack |
| 323 | ;;; unset host_hack |
| 324 | ;;; unset user_hack |
| 325 | ;;; unset temp |
| 326 | ;;; |
| 327 | ;;; eval `/bin/dircolors /home/marco/.emacs_dircolors` |
| 328 | ;;; endif |
| 329 | ;;; |
| 330 | ;;; # ... |
| 331 | ;;; |
| 332 | ;;; # Let's not clutter user space |
| 333 | ;;; |
| 334 | ;;; unset os |
| 335 | ;;; unset date |
| 336 | ;;; |
| 337 | ;;; |
| 338 | |
| 339 | ;;; Original Commentary: |
| 340 | ;;; -------------------- |
| 341 | |
| 342 | ;; The changelog is at the end of this file. |
| 343 | |
| 344 | ;; Please send me bug reports, bug fixes, and extensions, so that I can |
| 345 | ;; merge them into the master source. |
| 346 | ;; - Per Bothner (bothner@cygnus.com) |
| 347 | |
| 348 | ;; This file defines a general command-interpreter-in-a-buffer package |
| 349 | ;; (term mode). The idea is that you can build specific process-in-a-buffer |
| 350 | ;; modes on top of term mode -- e.g., lisp, shell, scheme, T, soar, .... |
| 351 | ;; This way, all these specific packages share a common base functionality, |
| 352 | ;; and a common set of bindings, which makes them easier to use (and |
| 353 | ;; saves code, implementation time, etc., etc.). |
| 354 | |
| 355 | ;; For hints on converting existing process modes (e.g., tex-mode, |
| 356 | ;; background, dbx, gdb, kermit, prolog, telnet) to use term-mode |
| 357 | ;; instead of shell-mode, see the notes at the end of this file. |
| 358 | |
| 359 | \f |
| 360 | ;; Brief Command Documentation: |
| 361 | ;;============================================================================ |
| 362 | ;; Term Mode Commands: (common to all derived modes, like cmushell & cmulisp |
| 363 | ;; mode) |
| 364 | ;; |
| 365 | ;; m-p term-previous-input Cycle backwards in input history |
| 366 | ;; m-n term-next-input Cycle forwards |
| 367 | ;; m-r term-previous-matching-input Previous input matching a regexp |
| 368 | ;; m-s comint-next-matching-input Next input that matches |
| 369 | ;; return term-send-input |
| 370 | ;; c-c c-a term-bol Beginning of line; skip prompt. |
| 371 | ;; c-d term-delchar-or-maybe-eof Delete char unless at end of buff. |
| 372 | ;; c-c c-u term-kill-input ^u |
| 373 | ;; c-c c-w backward-kill-word ^w |
| 374 | ;; c-c c-c term-interrupt-subjob ^c |
| 375 | ;; c-c c-z term-stop-subjob ^z |
| 376 | ;; c-c c-\ term-quit-subjob ^\ |
| 377 | ;; c-c c-o term-kill-output Delete last batch of process output |
| 378 | ;; c-c c-r term-show-output Show last batch of process output |
| 379 | ;; c-c c-h term-dynamic-list-input-ring List input history |
| 380 | ;; |
| 381 | ;; Not bound by default in term-mode |
| 382 | ;; term-send-invisible Read a line w/o echo, and send to proc |
| 383 | ;; (These are bound in shell-mode) |
| 384 | ;; term-dynamic-complete Complete filename at point. |
| 385 | ;; term-dynamic-list-completions List completions in help buffer. |
| 386 | ;; term-replace-by-expanded-filename Expand and complete filename at point; |
| 387 | ;; replace with expanded/completed name. |
| 388 | ;; term-kill-subjob No mercy. |
| 389 | ;; term-show-maximum-output Show as much output as possible. |
| 390 | ;; term-continue-subjob Send CONT signal to buffer's process |
| 391 | ;; group. Useful if you accidentally |
| 392 | ;; suspend your process (with C-c C-z). |
| 393 | |
| 394 | ;; term-mode-hook is the term mode hook. Basically for your keybindings. |
| 395 | ;; term-load-hook is run after loading in this package. |
| 396 | |
| 397 | ;;; Code: |
| 398 | |
| 399 | ;; This is passed to the inferior in the EMACS environment variable, |
| 400 | ;; so it is important to increase it if there are protocol-relevant changes. |
| 401 | (defconst term-protocol-version "0.96") |
| 402 | |
| 403 | (eval-when-compile |
| 404 | (require 'ange-ftp)) |
| 405 | (require 'ring) |
| 406 | (require 'ehelp) |
| 407 | |
| 408 | (defgroup term nil |
| 409 | "General command interpreter in a window." |
| 410 | :group 'processes |
| 411 | :group 'unix) |
| 412 | |
| 413 | \f |
| 414 | ;;; Buffer Local Variables: |
| 415 | ;;;============================================================================ |
| 416 | ;;; Term mode buffer local variables: |
| 417 | ;;; term-prompt-regexp - string term-bol uses to match prompt. |
| 418 | ;;; term-delimiter-argument-list - list For delimiters and arguments |
| 419 | ;;; term-last-input-start - marker Handy if inferior always echoes |
| 420 | ;;; term-last-input-end - marker For term-kill-output command |
| 421 | ;; For the input history mechanism: |
| 422 | (defvar term-input-ring-size 32 "Size of input history ring.") |
| 423 | ;;; term-input-ring-size - integer |
| 424 | ;;; term-input-ring - ring |
| 425 | ;;; term-input-ring-index - number ... |
| 426 | ;;; term-input-autoexpand - symbol ... |
| 427 | ;;; term-input-ignoredups - boolean ... |
| 428 | ;;; term-last-input-match - string ... |
| 429 | ;;; term-dynamic-complete-functions - hook For the completion mechanism |
| 430 | ;;; term-completion-fignore - list ... |
| 431 | ;;; term-get-old-input - function Hooks for specific |
| 432 | ;;; term-input-filter-functions - hook process-in-a-buffer |
| 433 | ;;; term-input-filter - function modes. |
| 434 | ;;; term-input-send - function |
| 435 | ;;; term-scroll-to-bottom-on-output - symbol ... |
| 436 | ;;; term-scroll-show-maximum-output - boolean... |
| 437 | (defvar term-height) ;; Number of lines in window. |
| 438 | (defvar term-width) ;; Number of columns in window. |
| 439 | (defvar term-home-marker) ;; Marks the "home" position for cursor addressing. |
| 440 | (defvar term-saved-home-marker nil) ;; When using alternate sub-buffer, |
| 441 | ;; contains saved term-home-marker from original sub-buffer . |
| 442 | (defvar term-start-line-column 0) ;; (current-column) at start of screen line, |
| 443 | ;; or nil if unknown. |
| 444 | (defvar term-current-column 0) ;; If non-nil, is cache for (current-column). |
| 445 | (defvar term-current-row 0) ;; Current vertical row (relative to home-marker) |
| 446 | ;; or nil if unknown. |
| 447 | (defvar term-insert-mode nil) |
| 448 | (defvar term-vertical-motion) |
| 449 | (defvar term-terminal-state 0) ;; State of the terminal emulator: |
| 450 | ;; state 0: Normal state |
| 451 | ;; state 1: Last character was a graphic in the last column. |
| 452 | ;; If next char is graphic, first move one column right |
| 453 | ;; (and line warp) before displaying it. |
| 454 | ;; This emulates (more or less) the behavior of xterm. |
| 455 | ;; state 2: seen ESC |
| 456 | ;; state 3: seen ESC [ (or ESC [ ?) |
| 457 | ;; state 4: term-terminal-parameter contains pending output. |
| 458 | (defvar term-kill-echo-list nil) ;; A queue of strings whose echo |
| 459 | ;; we want suppressed. |
| 460 | (defvar term-terminal-parameter) |
| 461 | (defvar term-terminal-previous-parameter) |
| 462 | (defvar term-current-face 'default) |
| 463 | (defvar term-scroll-start 0) ;; Top-most line (inclusive) of scrolling region. |
| 464 | (defvar term-scroll-end) ;; Number of line (zero-based) after scrolling region. |
| 465 | (defvar term-pager-count nil) ;; If nil, paging is disabled. |
| 466 | ;; Otherwise, number of lines before we need to page. |
| 467 | (defvar term-saved-cursor nil) |
| 468 | (defvar term-command-hook) |
| 469 | (defvar term-log-buffer nil) |
| 470 | (defvar term-scroll-with-delete nil) ;; term-scroll-with-delete is t if |
| 471 | ;; forward scrolling should be implemented by delete to |
| 472 | ;; top-most line(s); and nil if scrolling should be implemented |
| 473 | ;; by moving term-home-marker. It is set to t iff there is a |
| 474 | ;; (non-default) scroll-region OR the alternate buffer is used. |
| 475 | (defvar term-pending-delete-marker) ;; New user input in line mode needs to |
| 476 | ;; be deleted, because it gets echoed by the inferior. |
| 477 | ;; To reduce flicker, we defer the delete until the next output. |
| 478 | (defvar term-old-mode-map nil) ;; Saves the old keymap when in char mode. |
| 479 | (defvar term-old-mode-line-format) ;; Saves old mode-line-format while paging. |
| 480 | (defvar term-pager-old-local-map nil) ;; Saves old keymap while paging. |
| 481 | (defvar term-pager-old-filter) ;; Saved process-filter while paging. |
| 482 | |
| 483 | (defcustom explicit-shell-file-name nil |
| 484 | "*If non-nil, is file name to use for explicitly requested inferior shell." |
| 485 | :type '(choice (const nil) file) |
| 486 | :group 'term) |
| 487 | |
| 488 | (defvar term-prompt-regexp "^" |
| 489 | "Regexp to recognize prompts in the inferior process. |
| 490 | Defaults to \"^\", the null string at BOL. |
| 491 | |
| 492 | Good choices: |
| 493 | Canonical Lisp: \"^[^> \\n]*>+:? *\" (Lucid, franz, kcl, T, cscheme, oaklisp) |
| 494 | Lucid Common Lisp: \"^\\\\(>\\\\|\\\\(->\\\\)+\\\\) *\" |
| 495 | franz: \"^\\\\(->\\\\|<[0-9]*>:\\\\) *\" |
| 496 | kcl: \"^>+ *\" |
| 497 | shell: \"^[^#$%>\\n]*[#$%>] *\" |
| 498 | T: \"^>+ *\" |
| 499 | |
| 500 | This is a good thing to set in mode hooks.") |
| 501 | |
| 502 | (defvar term-delimiter-argument-list () |
| 503 | "List of characters to recognize as separate arguments in input. |
| 504 | Strings comprising a character in this list will separate the arguments |
| 505 | surrounding them, and also be regarded as arguments in their own right (unlike |
| 506 | whitespace). See `term-arguments'. |
| 507 | Defaults to the empty list. |
| 508 | |
| 509 | For shells, a good value is (?\\| ?& ?< ?> ?\\( ?\\) ?\\;). |
| 510 | |
| 511 | This is a good thing to set in mode hooks.") |
| 512 | |
| 513 | (defcustom term-input-autoexpand nil |
| 514 | "*If non-nil, expand input command history references on completion. |
| 515 | This mirrors the optional behavior of tcsh (its autoexpand and histlit). |
| 516 | |
| 517 | If the value is `input', then the expansion is seen on input. |
| 518 | If the value is `history', then the expansion is only when inserting |
| 519 | into the buffer's input ring. See also `term-magic-space' and |
| 520 | `term-dynamic-complete'. |
| 521 | |
| 522 | This variable is buffer-local." |
| 523 | :type '(choice (const nil) (const t) (const input) (const history)) |
| 524 | :group 'term) |
| 525 | |
| 526 | (defcustom term-input-ignoredups nil |
| 527 | "*If non-nil, don't add input matching the last on the input ring. |
| 528 | This mirrors the optional behavior of bash. |
| 529 | |
| 530 | This variable is buffer-local." |
| 531 | :type 'boolean |
| 532 | :group 'term) |
| 533 | |
| 534 | (defcustom term-input-ring-file-name nil |
| 535 | "*If non-nil, name of the file to read/write input history. |
| 536 | See also `term-read-input-ring' and `term-write-input-ring'. |
| 537 | |
| 538 | This variable is buffer-local, and is a good thing to set in mode hooks." |
| 539 | :type 'boolean |
| 540 | :group 'term) |
| 541 | |
| 542 | (defcustom term-scroll-to-bottom-on-output nil |
| 543 | "*Controls whether interpreter output causes window to scroll. |
| 544 | If nil, then do not scroll. If t or `all', scroll all windows showing buffer. |
| 545 | If `this', scroll only the selected window. |
| 546 | If `others', scroll only those that are not the selected window. |
| 547 | |
| 548 | The default is nil. |
| 549 | |
| 550 | See variable `term-scroll-show-maximum-output'. |
| 551 | This variable is buffer-local." |
| 552 | :type 'boolean |
| 553 | :group 'term) |
| 554 | |
| 555 | (defcustom term-scroll-show-maximum-output nil |
| 556 | "*Controls how interpreter output causes window to scroll. |
| 557 | If non-nil, then show the maximum output when the window is scrolled. |
| 558 | |
| 559 | See variable `term-scroll-to-bottom-on-output'. |
| 560 | This variable is buffer-local." |
| 561 | :type 'boolean |
| 562 | :group 'term) |
| 563 | |
| 564 | ;; Where gud-display-frame should put the debugging arrow. This is |
| 565 | ;; set by the marker-filter, which scans the debugger's output for |
| 566 | ;; indications of the current pc. |
| 567 | (defvar term-pending-frame nil) |
| 568 | |
| 569 | ;;; Here are the per-interpreter hooks. |
| 570 | (defvar term-get-old-input (function term-get-old-input-default) |
| 571 | "Function that submits old text in term mode. |
| 572 | This function is called when return is typed while the point is in old text. |
| 573 | It returns the text to be submitted as process input. The default is |
| 574 | `term-get-old-input-default', which grabs the current line, and strips off |
| 575 | leading text matching `term-prompt-regexp'.") |
| 576 | |
| 577 | (defvar term-dynamic-complete-functions |
| 578 | '(term-replace-by-expanded-history term-dynamic-complete-filename) |
| 579 | "List of functions called to perform completion. |
| 580 | Functions should return non-nil if completion was performed. |
| 581 | See also `term-dynamic-complete'. |
| 582 | |
| 583 | This is a good thing to set in mode hooks.") |
| 584 | |
| 585 | (defvar term-input-filter |
| 586 | (function (lambda (str) (not (string-match "\\`\\s *\\'" str)))) |
| 587 | "Predicate for filtering additions to input history. |
| 588 | Only inputs answering true to this function are saved on the input |
| 589 | history list. Default is to save anything that isn't all whitespace.") |
| 590 | |
| 591 | (defvar term-input-filter-functions '() |
| 592 | "Functions to call before input is sent to the process. |
| 593 | These functions get one argument, a string containing the text to send. |
| 594 | |
| 595 | This variable is buffer-local.") |
| 596 | |
| 597 | (defvar term-input-sender (function term-simple-send) |
| 598 | "Function to actually send to PROCESS the STRING submitted by user. |
| 599 | Usually this is just `term-simple-send', but if your mode needs to |
| 600 | massage the input string, this is your hook. This is called from |
| 601 | the user command `term-send-input'. `term-simple-send' just sends |
| 602 | the string plus a newline.") |
| 603 | |
| 604 | (defcustom term-eol-on-send t |
| 605 | "*Non-nil means go to the end of the line before sending input. |
| 606 | See `term-send-input'." |
| 607 | :type 'boolean |
| 608 | :group 'term) |
| 609 | |
| 610 | (defcustom term-mode-hook '() |
| 611 | "Called upon entry into term mode. |
| 612 | This is run before the process is cranked up." |
| 613 | :type 'hook |
| 614 | :group 'term) |
| 615 | |
| 616 | (defcustom term-exec-hook '() |
| 617 | "Called each time a process is exec'd by `term-exec'. |
| 618 | This is called after the process is cranked up. It is useful for things that |
| 619 | must be done each time a process is executed in a term mode buffer (e.g., |
| 620 | `process-kill-without-query'). In contrast, `term-mode-hook' is only |
| 621 | executed once when the buffer is created." |
| 622 | :type 'hook |
| 623 | :group 'term) |
| 624 | |
| 625 | (defvar term-mode-map nil) |
| 626 | (defvar term-raw-map nil |
| 627 | "Keyboard map for sending characters directly to the inferior process.") |
| 628 | (defvar term-escape-char nil |
| 629 | "Escape character for char sub-mode of term mode. |
| 630 | Do not change it directly; use `term-set-escape-char' instead.") |
| 631 | (defvar term-raw-escape-map nil) |
| 632 | |
| 633 | (defvar term-pager-break-map nil) |
| 634 | |
| 635 | (defvar term-ptyp t |
| 636 | "True if communications via pty; false if by pipe. Buffer local. |
| 637 | This is to work around a bug in Emacs process signaling.") |
| 638 | |
| 639 | (defvar term-last-input-match "" |
| 640 | "Last string searched for by term input history search, for defaulting. |
| 641 | Buffer local variable.") |
| 642 | |
| 643 | (defvar term-input-ring nil) |
| 644 | (defvar term-last-input-start) |
| 645 | (defvar term-last-input-end) |
| 646 | (defvar term-input-ring-index nil |
| 647 | "Index of last matched history element.") |
| 648 | (defvar term-matching-input-from-input-string "" |
| 649 | "Input previously used to match input history.") |
| 650 | ; This argument to set-process-filter disables reading from the process, |
| 651 | ; assuming this is Emacs 19.20 or newer. |
| 652 | (defvar term-pager-filter t) |
| 653 | |
| 654 | (put 'term-replace-by-expanded-history 'menu-enable 'term-input-autoexpand) |
| 655 | (put 'term-input-ring 'permanent-local t) |
| 656 | (put 'term-input-ring-index 'permanent-local t) |
| 657 | (put 'term-input-autoexpand 'permanent-local t) |
| 658 | (put 'term-input-filter-functions 'permanent-local t) |
| 659 | (put 'term-scroll-to-bottom-on-output 'permanent-local t) |
| 660 | (put 'term-scroll-show-maximum-output 'permanent-local t) |
| 661 | (put 'term-ptyp 'permanent-local t) |
| 662 | |
| 663 | (defmacro term-in-char-mode () '(eq (current-local-map) term-raw-map)) |
| 664 | (defmacro term-in-line-mode () '(not (term-in-char-mode))) |
| 665 | ;; True if currently doing PAGER handling. |
| 666 | (defmacro term-pager-enabled () 'term-pager-count) |
| 667 | (defmacro term-handling-pager () 'term-pager-old-local-map) |
| 668 | (defmacro term-using-alternate-sub-buffer () 'term-saved-home-marker) |
| 669 | |
| 670 | (defvar term-signals-menu) |
| 671 | (defvar term-terminal-menu) |
| 672 | |
| 673 | ;;; Let's silence the byte-compiler -mm |
| 674 | (defvar term-ansi-at-host nil) |
| 675 | (defvar term-ansi-at-dir nil) |
| 676 | (defvar term-ansi-at-user nil) |
| 677 | (defvar term-ansi-at-message nil) |
| 678 | (defvar term-ansi-at-save-user nil) |
| 679 | (defvar term-ansi-at-save-pwd nil) |
| 680 | (defvar term-ansi-at-save-anon nil) |
| 681 | (defvar term-ansi-current-bold nil) |
| 682 | (defvar term-ansi-current-color 0) |
| 683 | (defvar term-ansi-face-already-done nil) |
| 684 | (defvar term-ansi-current-bg-color 0) |
| 685 | (defvar term-ansi-current-underline nil) |
| 686 | (defvar term-ansi-current-reverse nil) |
| 687 | (defvar term-ansi-current-invisible nil) |
| 688 | |
| 689 | ;;; Four should be enough, if you want more, just add. -mm |
| 690 | (defvar term-terminal-more-parameters 0) |
| 691 | (defvar term-terminal-previous-parameter-2 -1) |
| 692 | (defvar term-terminal-previous-parameter-3 -1) |
| 693 | (defvar term-terminal-previous-parameter-4 -1) |
| 694 | ;;; |
| 695 | |
| 696 | ;;; faces -mm |
| 697 | |
| 698 | (defcustom term-default-fg-color 'unspecified |
| 699 | "Default color for foreground in `term'." |
| 700 | :group 'term |
| 701 | :type 'string) |
| 702 | |
| 703 | (defcustom term-default-bg-color 'unspecified |
| 704 | "Default color for background in `term'." |
| 705 | :group 'term |
| 706 | :type 'string) |
| 707 | |
| 708 | ;;; Use the same colors that xterm uses, see `xterm-standard-colors'. |
| 709 | (defvar ansi-term-color-vector |
| 710 | [unspecified "black" "red3" "green3" "yellow3" "blue2" |
| 711 | "magenta3" "cyan3" "white"]) |
| 712 | |
| 713 | ;;; Inspiration came from comint.el -mm |
| 714 | (defvar term-buffer-maximum-size 2048 |
| 715 | "*The maximum size in lines for term buffers. |
| 716 | Term buffers are truncated from the top to be no greater than this number. |
| 717 | Notice that a setting of 0 means 'don't truncate anything'. This variable |
| 718 | is buffer-local.") |
| 719 | ;;; |
| 720 | \f |
| 721 | (when (featurep 'xemacs) |
| 722 | (defvar term-terminal-menu |
| 723 | '("Terminal" |
| 724 | [ "Character mode" term-char-mode (term-in-line-mode)] |
| 725 | [ "Line mode" term-line-mode (term-in-char-mode)] |
| 726 | [ "Enable paging" term-pager-toggle (not term-pager-count)] |
| 727 | [ "Disable paging" term-pager-toggle term-pager-count]))) |
| 728 | |
| 729 | (unless term-mode-map |
| 730 | (setq term-mode-map (make-sparse-keymap)) |
| 731 | (define-key term-mode-map "\ep" 'term-previous-input) |
| 732 | (define-key term-mode-map "\en" 'term-next-input) |
| 733 | (define-key term-mode-map "\er" 'term-previous-matching-input) |
| 734 | (define-key term-mode-map "\es" 'term-next-matching-input) |
| 735 | (unless (featurep 'xemacs) |
| 736 | (define-key term-mode-map [?\A-\M-r] |
| 737 | 'term-previous-matching-input-from-input) |
| 738 | (define-key term-mode-map [?\A-\M-s] 'term-next-matching-input-from-input)) |
| 739 | (define-key term-mode-map "\e\C-l" 'term-show-output) |
| 740 | (define-key term-mode-map "\C-m" 'term-send-input) |
| 741 | (define-key term-mode-map "\C-d" 'term-delchar-or-maybe-eof) |
| 742 | (define-key term-mode-map "\C-c\C-a" 'term-bol) |
| 743 | (define-key term-mode-map "\C-c\C-u" 'term-kill-input) |
| 744 | (define-key term-mode-map "\C-c\C-w" 'backward-kill-word) |
| 745 | (define-key term-mode-map "\C-c\C-c" 'term-interrupt-subjob) |
| 746 | (define-key term-mode-map "\C-c\C-z" 'term-stop-subjob) |
| 747 | (define-key term-mode-map "\C-c\C-\\" 'term-quit-subjob) |
| 748 | (define-key term-mode-map "\C-c\C-m" 'term-copy-old-input) |
| 749 | (define-key term-mode-map "\C-c\C-o" 'term-kill-output) |
| 750 | (define-key term-mode-map "\C-c\C-r" 'term-show-output) |
| 751 | (define-key term-mode-map "\C-c\C-e" 'term-show-maximum-output) |
| 752 | (define-key term-mode-map "\C-c\C-l" 'term-dynamic-list-input-ring) |
| 753 | (define-key term-mode-map "\C-c\C-n" 'term-next-prompt) |
| 754 | (define-key term-mode-map "\C-c\C-p" 'term-previous-prompt) |
| 755 | (define-key term-mode-map "\C-c\C-d" 'term-send-eof) |
| 756 | (define-key term-mode-map "\C-c\C-k" 'term-char-mode) |
| 757 | (define-key term-mode-map "\C-c\C-j" 'term-line-mode) |
| 758 | (define-key term-mode-map "\C-c\C-q" 'term-pager-toggle) |
| 759 | |
| 760 | ; ;; completion: |
| 761 | ; (define-key term-mode-map [menu-bar completion] |
| 762 | ; (cons "Complete" (make-sparse-keymap "Complete"))) |
| 763 | ; (define-key term-mode-map [menu-bar completion complete-expand] |
| 764 | ; '("Expand File Name" . term-replace-by-expanded-filename)) |
| 765 | ; (define-key term-mode-map [menu-bar completion complete-listing] |
| 766 | ; '("File Completion Listing" . term-dynamic-list-filename-completions)) |
| 767 | ; (define-key term-mode-map [menu-bar completion complete-file] |
| 768 | ; '("Complete File Name" . term-dynamic-complete-filename)) |
| 769 | ; (define-key term-mode-map [menu-bar completion complete] |
| 770 | ; '("Complete Before Point" . term-dynamic-complete)) |
| 771 | ; ;; Put them in the menu bar: |
| 772 | ; (setq menu-bar-final-items (append '(terminal completion inout signals) |
| 773 | ; menu-bar-final-items)) |
| 774 | ) |
| 775 | |
| 776 | ;; Menu bars: |
| 777 | (unless (featurep 'xemacs) |
| 778 | ;; terminal: |
| 779 | (let (newmap) |
| 780 | (setq newmap (make-sparse-keymap "Terminal")) |
| 781 | (define-key newmap [terminal-pager-enable] |
| 782 | '("Enable paging" . term-fake-pager-enable)) |
| 783 | (define-key newmap [terminal-pager-disable] |
| 784 | '("Disable paging" . term-fake-pager-disable)) |
| 785 | (define-key newmap [terminal-char-mode] |
| 786 | '("Character mode" . term-char-mode)) |
| 787 | (define-key newmap [terminal-line-mode] |
| 788 | '("Line mode" . term-line-mode)) |
| 789 | (setq term-terminal-menu (cons "Terminal" newmap)) |
| 790 | |
| 791 | ;; completion: (line mode only) |
| 792 | (defvar term-completion-menu (make-sparse-keymap "Complete")) |
| 793 | (define-key term-mode-map [menu-bar completion] |
| 794 | (cons "Complete" term-completion-menu)) |
| 795 | (define-key term-completion-menu [complete-expand] |
| 796 | '("Expand File Name" . term-replace-by-expanded-filename)) |
| 797 | (define-key term-completion-menu [complete-listing] |
| 798 | '("File Completion Listing" . term-dynamic-list-filename-completions)) |
| 799 | (define-key term-completion-menu [menu-bar completion complete-file] |
| 800 | '("Complete File Name" . term-dynamic-complete-filename)) |
| 801 | (define-key term-completion-menu [menu-bar completion complete] |
| 802 | '("Complete Before Point" . term-dynamic-complete)) |
| 803 | |
| 804 | ;; Input history: (line mode only) |
| 805 | (defvar term-inout-menu (make-sparse-keymap "In/Out")) |
| 806 | (define-key term-mode-map [menu-bar inout] |
| 807 | (cons "In/Out" term-inout-menu)) |
| 808 | (define-key term-inout-menu [kill-output] |
| 809 | '("Kill Current Output Group" . term-kill-output)) |
| 810 | (define-key term-inout-menu [next-prompt] |
| 811 | '("Forward Output Group" . term-next-prompt)) |
| 812 | (define-key term-inout-menu [previous-prompt] |
| 813 | '("Backward Output Group" . term-previous-prompt)) |
| 814 | (define-key term-inout-menu [show-maximum-output] |
| 815 | '("Show Maximum Output" . term-show-maximum-output)) |
| 816 | (define-key term-inout-menu [show-output] |
| 817 | '("Show Current Output Group" . term-show-output)) |
| 818 | (define-key term-inout-menu [kill-input] |
| 819 | '("Kill Current Input" . term-kill-input)) |
| 820 | (define-key term-inout-menu [copy-input] |
| 821 | '("Copy Old Input" . term-copy-old-input)) |
| 822 | (define-key term-inout-menu [forward-matching-history] |
| 823 | '("Forward Matching Input..." . term-forward-matching-input)) |
| 824 | (define-key term-inout-menu [backward-matching-history] |
| 825 | '("Backward Matching Input..." . term-backward-matching-input)) |
| 826 | (define-key term-inout-menu [next-matching-history] |
| 827 | '("Next Matching Input..." . term-next-matching-input)) |
| 828 | (define-key term-inout-menu [previous-matching-history] |
| 829 | '("Previous Matching Input..." . term-previous-matching-input)) |
| 830 | (define-key term-inout-menu [next-matching-history-from-input] |
| 831 | '("Next Matching Current Input" . term-next-matching-input-from-input)) |
| 832 | (define-key term-inout-menu [previous-matching-history-from-input] |
| 833 | '("Previous Matching Current Input" . |
| 834 | term-previous-matching-input-from-input)) |
| 835 | (define-key term-inout-menu [next-history] |
| 836 | '("Next Input" . term-next-input)) |
| 837 | (define-key term-inout-menu [previous-history] |
| 838 | '("Previous Input" . term-previous-input)) |
| 839 | (define-key term-inout-menu [list-history] |
| 840 | '("List Input History" . term-dynamic-list-input-ring)) |
| 841 | (define-key term-inout-menu [expand-history] |
| 842 | '("Expand History Before Point" . term-replace-by-expanded-history)) |
| 843 | |
| 844 | ;; Signals |
| 845 | (setq newmap (make-sparse-keymap "Signals")) |
| 846 | (define-key newmap [eof] '("EOF" . term-send-eof)) |
| 847 | (define-key newmap [kill] '("KILL" . term-kill-subjob)) |
| 848 | (define-key newmap [quit] '("QUIT" . term-quit-subjob)) |
| 849 | (define-key newmap [cont] '("CONT" . term-continue-subjob)) |
| 850 | (define-key newmap [stop] '("STOP" . term-stop-subjob)) |
| 851 | (define-key newmap [] '("BREAK" . term-interrupt-subjob)) |
| 852 | (define-key term-mode-map [menu-bar signals] |
| 853 | (setq term-signals-menu (cons "Signals" newmap))) |
| 854 | )) |
| 855 | \f |
| 856 | ;; Set up term-raw-map, etc. |
| 857 | |
| 858 | (defun term-set-escape-char (c) |
| 859 | "Change term-escape-char and keymaps that depend on it." |
| 860 | (when term-escape-char |
| 861 | (define-key term-raw-map term-escape-char 'term-send-raw)) |
| 862 | (setq c (make-string 1 c)) |
| 863 | (define-key term-raw-map c term-raw-escape-map) |
| 864 | ;; Define standard bindings in term-raw-escape-map |
| 865 | (define-key term-raw-escape-map "\C-v" |
| 866 | (lookup-key (current-global-map) "\C-v")) |
| 867 | (define-key term-raw-escape-map "\C-u" |
| 868 | (lookup-key (current-global-map) "\C-u")) |
| 869 | (define-key term-raw-escape-map c 'term-send-raw) |
| 870 | (define-key term-raw-escape-map "\C-q" 'term-pager-toggle) |
| 871 | ;; The keybinding for term-char-mode is needed by the menubar code. |
| 872 | (define-key term-raw-escape-map "\C-k" 'term-char-mode) |
| 873 | (define-key term-raw-escape-map "\C-j" 'term-line-mode) |
| 874 | ;; It's convenient to have execute-extended-command here. |
| 875 | (define-key term-raw-escape-map [?\M-x] 'execute-extended-command)) |
| 876 | |
| 877 | (let* ((map (make-keymap)) |
| 878 | (esc-map (make-keymap)) |
| 879 | (i 0)) |
| 880 | (while (< i 128) |
| 881 | (define-key map (make-string 1 i) 'term-send-raw) |
| 882 | ;; Avoid O and [. They are used in escape sequences for various keys. |
| 883 | (unless (or (eq i ?O) (eq i 91)) |
| 884 | (define-key esc-map (make-string 1 i) 'term-send-raw-meta)) |
| 885 | (setq i (1+ i))) |
| 886 | (dolist (elm (generic-character-list)) |
| 887 | (define-key map (vector elm) 'term-send-raw)) |
| 888 | (define-key map "\e" esc-map) |
| 889 | (setq term-raw-map map) |
| 890 | (setq term-raw-escape-map |
| 891 | (copy-keymap (lookup-key (current-global-map) "\C-x"))) |
| 892 | |
| 893 | ;;; Added nearly all the 'grey keys' -mm |
| 894 | |
| 895 | (if (featurep 'xemacs) |
| 896 | (define-key term-raw-map [button2] 'term-mouse-paste) |
| 897 | (define-key term-raw-map [mouse-2] 'term-mouse-paste) |
| 898 | (define-key term-raw-map [menu-bar terminal] term-terminal-menu) |
| 899 | (define-key term-raw-map [menu-bar signals] term-signals-menu)) |
| 900 | (define-key term-raw-map [up] 'term-send-up) |
| 901 | (define-key term-raw-map [down] 'term-send-down) |
| 902 | (define-key term-raw-map [right] 'term-send-right) |
| 903 | (define-key term-raw-map [left] 'term-send-left) |
| 904 | (define-key term-raw-map [delete] 'term-send-del) |
| 905 | (define-key term-raw-map [deletechar] 'term-send-del) |
| 906 | (define-key term-raw-map [backspace] 'term-send-backspace) |
| 907 | (define-key term-raw-map [home] 'term-send-home) |
| 908 | (define-key term-raw-map [end] 'term-send-end) |
| 909 | (define-key term-raw-map [insert] 'term-send-insert) |
| 910 | (define-key term-raw-map [S-prior] 'scroll-down) |
| 911 | (define-key term-raw-map [S-next] 'scroll-up) |
| 912 | (define-key term-raw-map [S-insert] 'term-paste) |
| 913 | (define-key term-raw-map [prior] 'term-send-prior) |
| 914 | (define-key term-raw-map [next] 'term-send-next)) |
| 915 | |
| 916 | (term-set-escape-char ?\C-c) |
| 917 | |
| 918 | (defun term-window-width () |
| 919 | (if (featurep 'xemacs) |
| 920 | (1- (window-width)) |
| 921 | (if (and window-system overflow-newline-into-fringe) |
| 922 | (window-width) |
| 923 | (1- (window-width))))) |
| 924 | |
| 925 | \f |
| 926 | (put 'term-mode 'mode-class 'special) |
| 927 | |
| 928 | |
| 929 | ;;; Use this variable as a display table for `term-mode'. |
| 930 | (defvar term-display-table |
| 931 | (let ((dt (or (copy-sequence standard-display-table) |
| 932 | (make-display-table))) |
| 933 | i) |
| 934 | ;; avoid changing the display table for ^J |
| 935 | (setq i 0) |
| 936 | (while (< i 10) |
| 937 | (aset dt i (vector i)) |
| 938 | (setq i (1+ i))) |
| 939 | (setq i 11) |
| 940 | (while (< i 32) |
| 941 | (aset dt i (vector i)) |
| 942 | (setq i (1+ i))) |
| 943 | (setq i 128) |
| 944 | (while (< i 256) |
| 945 | (aset dt i (vector i)) |
| 946 | (setq i (1+ i))) |
| 947 | dt)) |
| 948 | |
| 949 | (defun term-mode () |
| 950 | "Major mode for interacting with an inferior interpreter. |
| 951 | The interpreter name is same as buffer name, sans the asterisks. |
| 952 | |
| 953 | There are two submodes: line mode and char mode. By default, you are |
| 954 | in char mode. In char sub-mode, each character (except |
| 955 | `term-escape-char') is sent immediately to the subprocess. |
| 956 | The escape character is equivalent to the usual meaning of C-x. |
| 957 | |
| 958 | In line mode, you send a line of input at a time; use |
| 959 | \\[term-send-input] to send. |
| 960 | |
| 961 | In line mode, this maintains an input history of size |
| 962 | `term-input-ring-size', and you can access it with the commands |
| 963 | \\[term-next-input], \\[term-previous-input], and |
| 964 | \\[term-dynamic-list-input-ring]. Input ring history expansion can be |
| 965 | achieved with the commands \\[term-replace-by-expanded-history] or |
| 966 | \\[term-magic-space]. Input ring expansion is controlled by the |
| 967 | variable `term-input-autoexpand', and addition is controlled by the |
| 968 | variable `term-input-ignoredups'. |
| 969 | |
| 970 | Input to, and output from, the subprocess can cause the window to scroll to |
| 971 | the end of the buffer. See variables `term-scroll-to-bottom-on-input', |
| 972 | and `term-scroll-to-bottom-on-output'. |
| 973 | |
| 974 | If you accidentally suspend your process, use \\[term-continue-subjob] |
| 975 | to continue it. |
| 976 | |
| 977 | This mode can be customized to create specific modes for running |
| 978 | particular subprocesses. This can be done by setting the hooks |
| 979 | `term-input-filter-functions', `term-input-filter', |
| 980 | `term-input-sender' and `term-get-old-input' to appropriate functions, |
| 981 | and the variable `term-prompt-regexp' to the appropriate regular |
| 982 | expression. |
| 983 | |
| 984 | Commands in raw mode: |
| 985 | |
| 986 | \\{term-raw-map} |
| 987 | |
| 988 | Commands in line mode: |
| 989 | |
| 990 | \\{term-mode-map} |
| 991 | |
| 992 | Entry to this mode runs the hooks on `term-mode-hook'." |
| 993 | (interactive) |
| 994 | ;; Do not remove this. All major modes must do this. |
| 995 | (kill-all-local-variables) |
| 996 | (setq major-mode 'term-mode) |
| 997 | (setq mode-name "Term") |
| 998 | (use-local-map term-mode-map) |
| 999 | ;; we do not want indent to sneak in any tabs |
| 1000 | (setq indent-tabs-mode nil) |
| 1001 | (setq buffer-display-table term-display-table) |
| 1002 | (make-local-variable 'term-home-marker) |
| 1003 | (setq term-home-marker (copy-marker 0)) |
| 1004 | (make-local-variable 'term-saved-home-marker) |
| 1005 | (make-local-variable 'term-height) |
| 1006 | (make-local-variable 'term-width) |
| 1007 | (setq term-width (term-window-width)) |
| 1008 | (setq term-height (1- (window-height))) |
| 1009 | (make-local-variable 'term-terminal-parameter) |
| 1010 | (make-local-variable 'term-saved-cursor) |
| 1011 | (make-local-variable 'term-last-input-start) |
| 1012 | (setq term-last-input-start (make-marker)) |
| 1013 | (make-local-variable 'term-last-input-end) |
| 1014 | (setq term-last-input-end (make-marker)) |
| 1015 | (make-local-variable 'term-last-input-match) |
| 1016 | (setq term-last-input-match "") |
| 1017 | (make-local-variable 'term-prompt-regexp) ; Don't set; default |
| 1018 | (make-local-variable 'term-input-ring-size) ; ...to global val. |
| 1019 | (make-local-variable 'term-input-ring) |
| 1020 | (make-local-variable 'term-input-ring-file-name) |
| 1021 | (or (and (boundp 'term-input-ring) term-input-ring) |
| 1022 | (setq term-input-ring (make-ring term-input-ring-size))) |
| 1023 | (make-local-variable 'term-input-ring-index) |
| 1024 | (or (and (boundp 'term-input-ring-index) term-input-ring-index) |
| 1025 | (setq term-input-ring-index nil)) |
| 1026 | |
| 1027 | (make-local-variable 'term-command-hook) |
| 1028 | (setq term-command-hook (symbol-function 'term-command-hook)) |
| 1029 | |
| 1030 | ;;; I'm not sure these saves are necessary but, since I |
| 1031 | ;;; haven't tested the whole thing on a net connected machine with |
| 1032 | ;;; a properly configured ange-ftp, I've decided to be conservative |
| 1033 | ;;; and put them in. -mm |
| 1034 | |
| 1035 | (make-local-variable 'term-ansi-at-host) |
| 1036 | (setq term-ansi-at-host (system-name)) |
| 1037 | |
| 1038 | (make-local-variable 'term-ansi-at-dir) |
| 1039 | (setq term-ansi-at-dir default-directory) |
| 1040 | |
| 1041 | (make-local-variable 'term-ansi-at-message) |
| 1042 | (setq term-ansi-at-message nil) |
| 1043 | |
| 1044 | ;;; For user tracking purposes -mm |
| 1045 | (make-local-variable 'ange-ftp-default-user) |
| 1046 | (make-local-variable 'ange-ftp-default-password) |
| 1047 | (make-local-variable 'ange-ftp-generate-anonymous-password) |
| 1048 | |
| 1049 | ;;; You may want to have different scroll-back sizes -mm |
| 1050 | (make-local-variable 'term-buffer-maximum-size) |
| 1051 | |
| 1052 | ;;; Of course these have to be buffer-local -mm |
| 1053 | (make-local-variable 'term-ansi-current-bold) |
| 1054 | (make-local-variable 'term-ansi-current-color) |
| 1055 | (make-local-variable 'term-ansi-face-already-done) |
| 1056 | (make-local-variable 'term-ansi-current-bg-color) |
| 1057 | (make-local-variable 'term-ansi-current-underline) |
| 1058 | (make-local-variable 'term-ansi-current-reverse) |
| 1059 | (make-local-variable 'term-ansi-current-invisible) |
| 1060 | |
| 1061 | (make-local-variable 'term-terminal-parameter) |
| 1062 | (make-local-variable 'term-terminal-previous-parameter) |
| 1063 | (make-local-variable 'term-terminal-previous-parameter-2) |
| 1064 | (make-local-variable 'term-terminal-previous-parameter-3) |
| 1065 | (make-local-variable 'term-terminal-previous-parameter-4) |
| 1066 | (make-local-variable 'term-terminal-more-parameters) |
| 1067 | |
| 1068 | (make-local-variable 'term-terminal-state) |
| 1069 | (make-local-variable 'term-kill-echo-list) |
| 1070 | (make-local-variable 'term-start-line-column) |
| 1071 | (make-local-variable 'term-current-column) |
| 1072 | (make-local-variable 'term-current-row) |
| 1073 | (make-local-variable 'term-log-buffer) |
| 1074 | (make-local-variable 'term-scroll-start) |
| 1075 | (make-local-variable 'term-scroll-end) |
| 1076 | (setq term-scroll-end term-height) |
| 1077 | (make-local-variable 'term-scroll-with-delete) |
| 1078 | (make-local-variable 'term-pager-count) |
| 1079 | (make-local-variable 'term-pager-old-local-map) |
| 1080 | (make-local-variable 'term-old-mode-map) |
| 1081 | (make-local-variable 'term-insert-mode) |
| 1082 | (make-local-variable 'term-dynamic-complete-functions) |
| 1083 | (make-local-variable 'term-completion-fignore) |
| 1084 | (make-local-variable 'term-get-old-input) |
| 1085 | (make-local-variable 'term-matching-input-from-input-string) |
| 1086 | (make-local-variable 'term-input-autoexpand) |
| 1087 | (make-local-variable 'term-input-ignoredups) |
| 1088 | (make-local-variable 'term-delimiter-argument-list) |
| 1089 | (make-local-variable 'term-input-filter-functions) |
| 1090 | (make-local-variable 'term-input-filter) |
| 1091 | (make-local-variable 'term-input-sender) |
| 1092 | (make-local-variable 'term-eol-on-send) |
| 1093 | (make-local-variable 'term-scroll-to-bottom-on-output) |
| 1094 | (make-local-variable 'term-scroll-show-maximum-output) |
| 1095 | (make-local-variable 'term-ptyp) |
| 1096 | (make-local-variable 'term-exec-hook) |
| 1097 | (make-local-variable 'term-vertical-motion) |
| 1098 | (make-local-variable 'term-pending-delete-marker) |
| 1099 | (setq term-pending-delete-marker (make-marker)) |
| 1100 | (make-local-variable 'term-current-face) |
| 1101 | (make-local-variable 'term-pending-frame) |
| 1102 | (setq term-pending-frame nil) |
| 1103 | ;; Cua-mode's keybindings interfere with the term keybindings, disable it. |
| 1104 | (set (make-local-variable 'cua-mode) nil) |
| 1105 | (run-mode-hooks 'term-mode-hook) |
| 1106 | (when (featurep 'xemacs) |
| 1107 | (set-buffer-menubar |
| 1108 | (append current-menubar (list term-terminal-menu)))) |
| 1109 | (or term-input-ring |
| 1110 | (setq term-input-ring (make-ring term-input-ring-size))) |
| 1111 | (term-update-mode-line)) |
| 1112 | \f |
| 1113 | (defun term-reset-size (height width) |
| 1114 | (setq term-height height) |
| 1115 | (setq term-width width) |
| 1116 | (setq term-start-line-column nil) |
| 1117 | (setq term-current-row nil) |
| 1118 | (setq term-current-column nil) |
| 1119 | (term-set-scroll-region 0 height)) |
| 1120 | |
| 1121 | ;; Recursive routine used to check if any string in term-kill-echo-list |
| 1122 | ;; matches part of the buffer before point. |
| 1123 | ;; If so, delete that matched part of the buffer - this suppresses echo. |
| 1124 | ;; Also, remove that string from the term-kill-echo-list. |
| 1125 | ;; We *also* remove any older string on the list, as a sanity measure, |
| 1126 | ;; in case something gets out of sync. (Except for type-ahead, there |
| 1127 | ;; should only be one element in the list.) |
| 1128 | |
| 1129 | (defun term-check-kill-echo-list () |
| 1130 | (let ((cur term-kill-echo-list) (found nil) (save-point (point))) |
| 1131 | (unwind-protect |
| 1132 | (progn |
| 1133 | (end-of-line) |
| 1134 | (while cur |
| 1135 | (let* ((str (car cur)) (len (length str)) (start (- (point) len))) |
| 1136 | (if (and (>= start (point-min)) |
| 1137 | (string= str (buffer-substring start (point)))) |
| 1138 | (progn (delete-backward-char len) |
| 1139 | (setq term-kill-echo-list (cdr cur)) |
| 1140 | (setq term-current-column nil) |
| 1141 | (setq term-current-row nil) |
| 1142 | (setq term-start-line-column nil) |
| 1143 | (setq cur nil found t)) |
| 1144 | (setq cur (cdr cur)))))) |
| 1145 | (when (not found) |
| 1146 | (goto-char save-point))) |
| 1147 | found)) |
| 1148 | |
| 1149 | (defun term-check-size (process) |
| 1150 | (when (or (/= term-height (1- (window-height))) |
| 1151 | (/= term-width (term-window-width))) |
| 1152 | (term-reset-size (1- (window-height)) (term-window-width)) |
| 1153 | (set-process-window-size process term-height term-width))) |
| 1154 | |
| 1155 | (defun term-send-raw-string (chars) |
| 1156 | (let ((proc (get-buffer-process (current-buffer)))) |
| 1157 | (if (not proc) |
| 1158 | (error "Current buffer has no process") |
| 1159 | ;; Note that (term-current-row) must be called *after* |
| 1160 | ;; (point) has been updated to (process-mark proc). |
| 1161 | (goto-char (process-mark proc)) |
| 1162 | (when (term-pager-enabled) |
| 1163 | (setq term-pager-count (term-current-row))) |
| 1164 | (process-send-string proc chars)))) |
| 1165 | |
| 1166 | (defun term-send-raw () |
| 1167 | "Send the last character typed through the terminal-emulator |
| 1168 | without any interpretation." |
| 1169 | (interactive) |
| 1170 | ;; Convert `return' to C-m, etc. |
| 1171 | (when (and (symbolp last-input-char) |
| 1172 | (get last-input-char 'ascii-character)) |
| 1173 | (setq last-input-char (get last-input-char 'ascii-character))) |
| 1174 | (term-send-raw-string (make-string 1 last-input-char))) |
| 1175 | |
| 1176 | (defun term-send-raw-meta () |
| 1177 | (interactive) |
| 1178 | (let ((char last-input-char)) |
| 1179 | (when (symbolp last-input-char) |
| 1180 | ;; Convert `return' to C-m, etc. |
| 1181 | (let ((tmp (get char 'event-symbol-elements))) |
| 1182 | (when tmp |
| 1183 | (setq char (car tmp))) |
| 1184 | (when (symbolp char) |
| 1185 | (setq tmp (get char 'ascii-character)) |
| 1186 | (when tmp |
| 1187 | (setq char tmp))))) |
| 1188 | (setq char (event-basic-type char)) |
| 1189 | (term-send-raw-string (if (and (numberp char) |
| 1190 | (> char 127) |
| 1191 | (< char 256)) |
| 1192 | (make-string 1 char) |
| 1193 | (format "\e%c" char))))) |
| 1194 | |
| 1195 | (defun term-mouse-paste (click arg) |
| 1196 | "Insert the last stretch of killed text at the position clicked on." |
| 1197 | (interactive "e\nP") |
| 1198 | (if (featurep 'xemacs) |
| 1199 | (term-send-raw-string |
| 1200 | (or (condition-case () (x-get-selection) (error ())) |
| 1201 | (x-get-cutbuffer) |
| 1202 | (error "No selection or cut buffer available"))) |
| 1203 | ;; Give temporary modes such as isearch a chance to turn off. |
| 1204 | (run-hooks 'mouse-leave-buffer-hook) |
| 1205 | (setq this-command 'yank) |
| 1206 | (mouse-set-point click) |
| 1207 | (term-send-raw-string (current-kill (cond |
| 1208 | ((listp arg) 0) |
| 1209 | ((eq arg '-) -1) |
| 1210 | (t (1- arg))))))) |
| 1211 | |
| 1212 | (defun term-paste () |
| 1213 | "Insert the last stretch of killed text at point." |
| 1214 | (interactive) |
| 1215 | (term-send-raw-string (current-kill 0))) |
| 1216 | |
| 1217 | ;; Which would be better: "\e[A" or "\eOA"? readline accepts either. |
| 1218 | ;; For my configuration it's definitely better \eOA but YMMV. -mm |
| 1219 | ;; For example: vi works with \eOA while elm wants \e[A ... |
| 1220 | ;;; (terminfo: kcuu1, kcud1, kcuf1, kcub1, khome, kend, kpp, knp, kdch1, kbs) |
| 1221 | (defun term-send-up () (interactive) (term-send-raw-string "\eOA")) |
| 1222 | (defun term-send-down () (interactive) (term-send-raw-string "\eOB")) |
| 1223 | (defun term-send-right () (interactive) (term-send-raw-string "\eOC")) |
| 1224 | (defun term-send-left () (interactive) (term-send-raw-string "\eOD")) |
| 1225 | (defun term-send-home () (interactive) (term-send-raw-string "\e[1~")) |
| 1226 | (defun term-send-insert() (interactive) (term-send-raw-string "\e[2~")) |
| 1227 | (defun term-send-end () (interactive) (term-send-raw-string "\e[4~")) |
| 1228 | (defun term-send-prior () (interactive) (term-send-raw-string "\e[5~")) |
| 1229 | (defun term-send-next () (interactive) (term-send-raw-string "\e[6~")) |
| 1230 | (defun term-send-del () (interactive) (term-send-raw-string "\e[3~")) |
| 1231 | (defun term-send-backspace () (interactive) (term-send-raw-string "\C-?")) |
| 1232 | \f |
| 1233 | (defun term-char-mode () |
| 1234 | "Switch to char (\"raw\") sub-mode of term mode. |
| 1235 | Each character you type is sent directly to the inferior without |
| 1236 | intervention from Emacs, except for the escape character (usually C-c)." |
| 1237 | (interactive) |
| 1238 | ;; FIXME: Emit message? Cfr ilisp-raw-message |
| 1239 | (when (term-in-line-mode) |
| 1240 | (setq term-old-mode-map (current-local-map)) |
| 1241 | (use-local-map term-raw-map) |
| 1242 | |
| 1243 | ;; Send existing partial line to inferior (without newline). |
| 1244 | (let ((pmark (process-mark (get-buffer-process (current-buffer)))) |
| 1245 | (save-input-sender term-input-sender)) |
| 1246 | (when (> (point) pmark) |
| 1247 | (unwind-protect |
| 1248 | (progn |
| 1249 | (setq term-input-sender |
| 1250 | (symbol-function 'term-send-string)) |
| 1251 | (end-of-line) |
| 1252 | (term-send-input)) |
| 1253 | (setq term-input-sender save-input-sender)))) |
| 1254 | (term-update-mode-line))) |
| 1255 | |
| 1256 | (defun term-line-mode () |
| 1257 | "Switch to line (\"cooked\") sub-mode of term mode. |
| 1258 | This means that Emacs editing commands work as normally, until |
| 1259 | you type \\[term-send-input] which sends the current line to the inferior." |
| 1260 | (interactive) |
| 1261 | (when (term-in-char-mode) |
| 1262 | (use-local-map term-old-mode-map) |
| 1263 | (term-update-mode-line))) |
| 1264 | |
| 1265 | (defun term-update-mode-line () |
| 1266 | (setq mode-line-process |
| 1267 | (if (term-in-char-mode) |
| 1268 | (if (term-pager-enabled) '(": char page %s") '(": char %s")) |
| 1269 | (if (term-pager-enabled) '(": line page %s") '(": line %s")))) |
| 1270 | (force-mode-line-update)) |
| 1271 | |
| 1272 | (defun term-check-proc (buffer) |
| 1273 | "True if there is a process associated w/buffer BUFFER, and |
| 1274 | it is alive (status RUN or STOP). BUFFER can be either a buffer or the |
| 1275 | name of one." |
| 1276 | (let ((proc (get-buffer-process buffer))) |
| 1277 | (and proc (memq (process-status proc) '(run stop))))) |
| 1278 | |
| 1279 | ;;;###autoload |
| 1280 | (defun make-term (name program &optional startfile &rest switches) |
| 1281 | "Make a term process NAME in a buffer, running PROGRAM. |
| 1282 | The name of the buffer is made by surrounding NAME with `*'s. |
| 1283 | If there is already a running process in that buffer, it is not restarted. |
| 1284 | Optional third arg STARTFILE is the name of a file to send the contents of to |
| 1285 | the process. Any more args are arguments to PROGRAM." |
| 1286 | (let ((buffer (get-buffer-create (concat "*" name "*")))) |
| 1287 | ;; If no process, or nuked process, crank up a new one and put buffer in |
| 1288 | ;; term mode. Otherwise, leave buffer and existing process alone. |
| 1289 | (cond ((not (term-check-proc buffer)) |
| 1290 | (save-excursion |
| 1291 | (set-buffer buffer) |
| 1292 | (term-mode)) ; Install local vars, mode, keymap, ... |
| 1293 | (term-exec buffer name program startfile switches))) |
| 1294 | buffer)) |
| 1295 | |
| 1296 | ;;;###autoload |
| 1297 | (defun term (program) |
| 1298 | "Start a terminal-emulator in a new buffer. |
| 1299 | The buffer is in Term mode; see `term-mode' for the |
| 1300 | commands to use in that buffer. |
| 1301 | |
| 1302 | \\<term-raw-map>Type \\[switch-to-buffer] to switch to another buffer." |
| 1303 | (interactive (list (read-from-minibuffer "Run program: " |
| 1304 | (or explicit-shell-file-name |
| 1305 | (getenv "ESHELL") |
| 1306 | (getenv "SHELL") |
| 1307 | "/bin/sh")))) |
| 1308 | (set-buffer (make-term "terminal" program)) |
| 1309 | (term-mode) |
| 1310 | (term-char-mode) |
| 1311 | (switch-to-buffer "*terminal*")) |
| 1312 | |
| 1313 | (defun term-exec (buffer name command startfile switches) |
| 1314 | "Start up a process in buffer for term modes. |
| 1315 | Blasts any old process running in the buffer. Doesn't set the buffer mode. |
| 1316 | You can use this to cheaply run a series of processes in the same term |
| 1317 | buffer. The hook term-exec-hook is run after each exec." |
| 1318 | (save-excursion |
| 1319 | (set-buffer buffer) |
| 1320 | (let ((proc (get-buffer-process buffer))) ; Blast any old process. |
| 1321 | (when proc (delete-process proc))) |
| 1322 | ;; Crank up a new process |
| 1323 | (let ((proc (term-exec-1 name buffer command switches))) |
| 1324 | (make-local-variable 'term-ptyp) |
| 1325 | (setq term-ptyp process-connection-type) ; t if pty, nil if pipe. |
| 1326 | ;; Jump to the end, and set the process mark. |
| 1327 | (goto-char (point-max)) |
| 1328 | (set-marker (process-mark proc) (point)) |
| 1329 | (set-process-filter proc 'term-emulate-terminal) |
| 1330 | (set-process-sentinel proc 'term-sentinel) |
| 1331 | ;; Feed it the startfile. |
| 1332 | (cond (startfile |
| 1333 | ;;This is guaranteed to wait long enough |
| 1334 | ;;but has bad results if the term does not prompt at all |
| 1335 | ;; (while (= size (buffer-size)) |
| 1336 | ;; (sleep-for 1)) |
| 1337 | ;;I hope 1 second is enough! |
| 1338 | (sleep-for 1) |
| 1339 | (goto-char (point-max)) |
| 1340 | (insert-file-contents startfile) |
| 1341 | (setq startfile (buffer-substring (point) (point-max))) |
| 1342 | (delete-region (point) (point-max)) |
| 1343 | (term-send-string proc startfile))) |
| 1344 | (run-hooks 'term-exec-hook) |
| 1345 | buffer))) |
| 1346 | |
| 1347 | (defun term-sentinel (proc msg) |
| 1348 | "Sentinel for term buffers. |
| 1349 | The main purpose is to get rid of the local keymap." |
| 1350 | (let ((buffer (process-buffer proc))) |
| 1351 | (when (memq (process-status proc) '(signal exit)) |
| 1352 | (if (null (buffer-name buffer)) |
| 1353 | ;; buffer killed |
| 1354 | (set-process-buffer proc nil) |
| 1355 | (let ((obuf (current-buffer))) |
| 1356 | ;; save-excursion isn't the right thing if |
| 1357 | ;; process-buffer is current-buffer |
| 1358 | (unwind-protect |
| 1359 | (progn |
| 1360 | ;; Write something in the compilation buffer |
| 1361 | ;; and hack its mode line. |
| 1362 | (set-buffer buffer) |
| 1363 | ;; Get rid of local keymap. |
| 1364 | (use-local-map nil) |
| 1365 | (term-handle-exit (process-name proc) |
| 1366 | msg) |
| 1367 | ;; Since the buffer and mode line will show that the |
| 1368 | ;; process is dead, we can delete it now. Otherwise it |
| 1369 | ;; will stay around until M-x list-processes. |
| 1370 | (delete-process proc)) |
| 1371 | (set-buffer obuf))) |
| 1372 | )))) |
| 1373 | |
| 1374 | (defun term-handle-exit (process-name msg) |
| 1375 | "Write process exit (or other change) message MSG in the current buffer." |
| 1376 | (let ((buffer-read-only nil) |
| 1377 | (omax (point-max)) |
| 1378 | (opoint (point))) |
| 1379 | ;; Record where we put the message, so we can ignore it |
| 1380 | ;; later on. |
| 1381 | (goto-char omax) |
| 1382 | (insert ?\n "Process " process-name " " msg) |
| 1383 | ;; Force mode line redisplay soon. |
| 1384 | (force-mode-line-update) |
| 1385 | (when (and opoint (< opoint omax)) |
| 1386 | (goto-char opoint)))) |
| 1387 | |
| 1388 | |
| 1389 | ;;; Name to use for TERM. |
| 1390 | ;;; Using "emacs" loses, because bash disables editing if TERM == emacs. |
| 1391 | (defvar term-term-name "eterm-color") |
| 1392 | ; Format string, usage: |
| 1393 | ; (format term-termcap-string emacs-term-name "TERMCAP=" 24 80) |
| 1394 | (defvar term-termcap-format |
| 1395 | "%s%s:li#%d:co#%d:cl=\\E[H\\E[J:cd=\\E[J:bs:am:xn:cm=\\E[%%i%%d;%%dH\ |
| 1396 | :nd=\\E[C:up=\\E[A:ce=\\E[K:ho=\\E[H:pt\ |
| 1397 | :al=\\E[L:dl=\\E[M:DL=\\E[%%dM:AL=\\E[%%dL:cs=\\E[%%i%%d;%%dr:sf=^J\ |
| 1398 | :dc=\\E[P:DC=\\E[%%dP:IC=\\E[%%d@:im=\\E[4h:ei=\\E[4l:mi:\ |
| 1399 | :so=\\E[7m:se=\\E[m:us=\\E[4m:ue=\\E[m:md=\\E[1m:mr=\\E[7m:me=\\E[m\ |
| 1400 | :UP=\\E[%%dA:DO=\\E[%%dB:LE=\\E[%%dD:RI=\\E[%%dC\ |
| 1401 | :kl=\\EOD:kd=\\EOB:kr=\\EOC:ku=\\EOA:kN=\\E[6~:kP=\\E[5~:@7=\\E[4~:kh=\\E[1~\ |
| 1402 | :mk=\\E[8m:cb=\\E[1K:op=\\E[39;49m:Co#8:pa#64:AB=\\E[4%%dm:AF=\\E[3%%dm:cr=^M\ |
| 1403 | :bl=^G:do=^J:le=^H:ta=^I:se=\\E[27m:ue=\\E24m\ |
| 1404 | :kb=^?:kD=^[[3~:sc=\\E7:rc=\\E8:r1=\\Ec:" |
| 1405 | ;;; : -undefine ic |
| 1406 | ;;; don't define :te=\\E[2J\\E[?47l\\E8:ti=\\E7\\E[?47h\ |
| 1407 | "termcap capabilities supported") |
| 1408 | |
| 1409 | ;;; This auxiliary function cranks up the process for term-exec in |
| 1410 | ;;; the appropriate environment. |
| 1411 | |
| 1412 | (defun term-exec-1 (name buffer command switches) |
| 1413 | ;; We need to do an extra (fork-less) exec to run stty. |
| 1414 | ;; (This would not be needed if we had suitable Emacs primitives.) |
| 1415 | ;; The 'if ...; then shift; fi' hack is because Bourne shell |
| 1416 | ;; loses one arg when called with -c, and newer shells (bash, ksh) don't. |
| 1417 | ;; Thus we add an extra dummy argument "..", and then remove it. |
| 1418 | (let ((process-environment |
| 1419 | (nconc |
| 1420 | (list |
| 1421 | (format "TERM=%s" term-term-name) |
| 1422 | (format "TERMINFO=%s" data-directory) |
| 1423 | (format term-termcap-format "TERMCAP=" |
| 1424 | term-term-name term-height term-width) |
| 1425 | ;; Breaks `./configure' of w3 and url which try to run $EMACS. |
| 1426 | (format "EMACS=%s (term:%s)" emacs-version term-protocol-version) |
| 1427 | (format "LINES=%d" term-height) |
| 1428 | (format "COLUMNS=%d" term-width)) |
| 1429 | process-environment)) |
| 1430 | (process-connection-type t) |
| 1431 | ;; We should suppress conversion of end-of-line format. |
| 1432 | (inhibit-eol-conversion t) |
| 1433 | ;; The process's output contains not just chars but also binary |
| 1434 | ;; escape codes, so we need to see the raw output. We will have to |
| 1435 | ;; do the decoding by hand on the parts that are made of chars. |
| 1436 | (coding-system-for-read 'binary)) |
| 1437 | (apply 'start-process name buffer |
| 1438 | "/bin/sh" "-c" |
| 1439 | (format "stty -nl echo rows %d columns %d sane 2>/dev/null;\ |
| 1440 | if [ $1 = .. ]; then shift; fi; exec \"$@\"" |
| 1441 | term-height term-width) |
| 1442 | ".." |
| 1443 | command switches))) |
| 1444 | |
| 1445 | \f |
| 1446 | ;;; Input history processing in a buffer |
| 1447 | ;;; =========================================================================== |
| 1448 | ;;; Useful input history functions, courtesy of the Ergo group. |
| 1449 | |
| 1450 | ;;; Eleven commands: |
| 1451 | ;;; term-dynamic-list-input-ring List history in help buffer. |
| 1452 | ;;; term-previous-input Previous input... |
| 1453 | ;;; term-previous-matching-input ...matching a string. |
| 1454 | ;;; term-previous-matching-input-from-input ... matching the current input. |
| 1455 | ;;; term-next-input Next input... |
| 1456 | ;;; term-next-matching-input ...matching a string. |
| 1457 | ;;; term-next-matching-input-from-input ... matching the current input. |
| 1458 | ;;; term-backward-matching-input Backwards input... |
| 1459 | ;;; term-forward-matching-input ...matching a string. |
| 1460 | ;;; term-replace-by-expanded-history Expand history at point; |
| 1461 | ;;; replace with expanded history. |
| 1462 | ;;; term-magic-space Expand history and insert space. |
| 1463 | ;;; |
| 1464 | ;;; Three functions: |
| 1465 | ;;; term-read-input-ring Read into term-input-ring... |
| 1466 | ;;; term-write-input-ring Write to term-input-ring-file-name. |
| 1467 | ;;; term-replace-by-expanded-history-before-point Workhorse function. |
| 1468 | |
| 1469 | (defun term-read-input-ring (&optional silent) |
| 1470 | "Sets the buffer's `term-input-ring' from a history file. |
| 1471 | The name of the file is given by the variable `term-input-ring-file-name'. |
| 1472 | The history ring is of size `term-input-ring-size', regardless of file size. |
| 1473 | If `term-input-ring-file-name' is nil this function does nothing. |
| 1474 | |
| 1475 | If the optional argument SILENT is non-nil, we say nothing about a |
| 1476 | failure to read the history file. |
| 1477 | |
| 1478 | This function is useful for major mode commands and mode hooks. |
| 1479 | |
| 1480 | The structure of the history file should be one input command per line, |
| 1481 | with the most recent command last. |
| 1482 | See also `term-input-ignoredups' and `term-write-input-ring'." |
| 1483 | (cond ((or (null term-input-ring-file-name) |
| 1484 | (equal term-input-ring-file-name "")) |
| 1485 | nil) |
| 1486 | ((not (file-readable-p term-input-ring-file-name)) |
| 1487 | (or silent |
| 1488 | (message "Cannot read history file %s" |
| 1489 | term-input-ring-file-name))) |
| 1490 | (t |
| 1491 | (let ((history-buf (get-buffer-create " *temp*")) |
| 1492 | (file term-input-ring-file-name) |
| 1493 | (count 0) |
| 1494 | (ring (make-ring term-input-ring-size))) |
| 1495 | (unwind-protect |
| 1496 | (save-excursion |
| 1497 | (set-buffer history-buf) |
| 1498 | (widen) |
| 1499 | (erase-buffer) |
| 1500 | (insert-file-contents file) |
| 1501 | ;; Save restriction in case file is already visited... |
| 1502 | ;; Watch for those date stamps in history files! |
| 1503 | (goto-char (point-max)) |
| 1504 | (while (and (< count term-input-ring-size) |
| 1505 | (re-search-backward "^[ \t]*\\([^#\n].*\\)[ \t]*$" |
| 1506 | nil t)) |
| 1507 | (let ((history (buffer-substring (match-beginning 1) |
| 1508 | (match-end 1)))) |
| 1509 | (when (or (null term-input-ignoredups) |
| 1510 | (ring-empty-p ring) |
| 1511 | (not (string-equal (ring-ref ring 0) history))) |
| 1512 | (ring-insert-at-beginning ring history))) |
| 1513 | (setq count (1+ count)))) |
| 1514 | (kill-buffer history-buf)) |
| 1515 | (setq term-input-ring ring |
| 1516 | term-input-ring-index nil))))) |
| 1517 | |
| 1518 | (defun term-write-input-ring () |
| 1519 | "Writes the buffer's `term-input-ring' to a history file. |
| 1520 | The name of the file is given by the variable `term-input-ring-file-name'. |
| 1521 | The original contents of the file are lost if `term-input-ring' is not empty. |
| 1522 | If `term-input-ring-file-name' is nil this function does nothing. |
| 1523 | |
| 1524 | Useful within process sentinels. |
| 1525 | |
| 1526 | See also `term-read-input-ring'." |
| 1527 | (cond ((or (null term-input-ring-file-name) |
| 1528 | (equal term-input-ring-file-name "") |
| 1529 | (null term-input-ring) (ring-empty-p term-input-ring)) |
| 1530 | nil) |
| 1531 | ((not (file-writable-p term-input-ring-file-name)) |
| 1532 | (message "Cannot write history file %s" term-input-ring-file-name)) |
| 1533 | (t |
| 1534 | (let* ((history-buf (get-buffer-create " *Temp Input History*")) |
| 1535 | (ring term-input-ring) |
| 1536 | (file term-input-ring-file-name) |
| 1537 | (index (ring-length ring))) |
| 1538 | ;; Write it all out into a buffer first. Much faster, but messier, |
| 1539 | ;; than writing it one line at a time. |
| 1540 | (save-excursion |
| 1541 | (set-buffer history-buf) |
| 1542 | (erase-buffer) |
| 1543 | (while (> index 0) |
| 1544 | (setq index (1- index)) |
| 1545 | (insert (ring-ref ring index) ?\n)) |
| 1546 | (write-region (buffer-string) nil file nil 'no-message) |
| 1547 | (kill-buffer nil)))))) |
| 1548 | |
| 1549 | |
| 1550 | (defun term-dynamic-list-input-ring () |
| 1551 | "List in help buffer the buffer's input history." |
| 1552 | (interactive) |
| 1553 | (if (or (not (ring-p term-input-ring)) |
| 1554 | (ring-empty-p term-input-ring)) |
| 1555 | (message "No history") |
| 1556 | (let ((history nil) |
| 1557 | (history-buffer " *Input History*") |
| 1558 | (index (1- (ring-length term-input-ring))) |
| 1559 | (conf (current-window-configuration))) |
| 1560 | ;; We have to build up a list ourselves from the ring vector. |
| 1561 | (while (>= index 0) |
| 1562 | (setq history (cons (ring-ref term-input-ring index) history) |
| 1563 | index (1- index))) |
| 1564 | ;; Change "completion" to "history reference" |
| 1565 | ;; to make the display accurate. |
| 1566 | (with-output-to-temp-buffer history-buffer |
| 1567 | (display-completion-list history) |
| 1568 | (set-buffer history-buffer) |
| 1569 | (forward-line 3) |
| 1570 | (while (search-backward "completion" nil 'move) |
| 1571 | (replace-match "history reference"))) |
| 1572 | (sit-for 0) |
| 1573 | (message "Hit space to flush") |
| 1574 | (let ((ch (read-event))) |
| 1575 | (if (eq ch ?\s) |
| 1576 | (set-window-configuration conf) |
| 1577 | (setq unread-command-events (list ch))))))) |
| 1578 | |
| 1579 | |
| 1580 | (defun term-regexp-arg (prompt) |
| 1581 | ;; Return list of regexp and prefix arg using PROMPT. |
| 1582 | (let* (;; Don't clobber this. |
| 1583 | (last-command last-command) |
| 1584 | (regexp (read-from-minibuffer prompt nil nil nil |
| 1585 | 'minibuffer-history-search-history))) |
| 1586 | (list (if (string-equal regexp "") |
| 1587 | (setcar minibuffer-history-search-history |
| 1588 | (nth 1 minibuffer-history-search-history)) |
| 1589 | regexp) |
| 1590 | (prefix-numeric-value current-prefix-arg)))) |
| 1591 | |
| 1592 | (defun term-search-arg (arg) |
| 1593 | ;; First make sure there is a ring and that we are after the process mark |
| 1594 | (cond ((not (term-after-pmark-p)) |
| 1595 | (error "Not at command line")) |
| 1596 | ((or (null term-input-ring) |
| 1597 | (ring-empty-p term-input-ring)) |
| 1598 | (error "Empty input ring")) |
| 1599 | ((zerop arg) |
| 1600 | ;; arg of zero resets search from beginning, and uses arg of 1 |
| 1601 | (setq term-input-ring-index nil) |
| 1602 | 1) |
| 1603 | (t |
| 1604 | arg))) |
| 1605 | |
| 1606 | (defun term-search-start (arg) |
| 1607 | ;; Index to start a directional search, starting at term-input-ring-index |
| 1608 | (if term-input-ring-index |
| 1609 | ;; If a search is running, offset by 1 in direction of arg |
| 1610 | (mod (+ term-input-ring-index (if (> arg 0) 1 -1)) |
| 1611 | (ring-length term-input-ring)) |
| 1612 | ;; For a new search, start from beginning or end, as appropriate |
| 1613 | (if (>= arg 0) |
| 1614 | 0 ; First elt for forward search |
| 1615 | (1- (ring-length term-input-ring))))) ; Last elt for backward search |
| 1616 | |
| 1617 | (defun term-previous-input-string (arg) |
| 1618 | "Return the string ARG places along the input ring. |
| 1619 | Moves relative to `term-input-ring-index'." |
| 1620 | (ring-ref term-input-ring (if term-input-ring-index |
| 1621 | (mod (+ arg term-input-ring-index) |
| 1622 | (ring-length term-input-ring)) |
| 1623 | arg))) |
| 1624 | |
| 1625 | (defun term-previous-input (arg) |
| 1626 | "Cycle backwards through input history." |
| 1627 | (interactive "*p") |
| 1628 | (term-previous-matching-input "." arg)) |
| 1629 | |
| 1630 | (defun term-next-input (arg) |
| 1631 | "Cycle forwards through input history." |
| 1632 | (interactive "*p") |
| 1633 | (term-previous-input (- arg))) |
| 1634 | |
| 1635 | (defun term-previous-matching-input-string (regexp arg) |
| 1636 | "Return the string matching REGEXP ARG places along the input ring. |
| 1637 | Moves relative to `term-input-ring-index'." |
| 1638 | (let* ((pos (term-previous-matching-input-string-position regexp arg))) |
| 1639 | (when pos (ring-ref term-input-ring pos)))) |
| 1640 | |
| 1641 | (defun term-previous-matching-input-string-position |
| 1642 | (regexp arg &optional start) |
| 1643 | "Return the index matching REGEXP ARG places along the input ring. |
| 1644 | Moves relative to START, or `term-input-ring-index'." |
| 1645 | (when (or (not (ring-p term-input-ring)) |
| 1646 | (ring-empty-p term-input-ring)) |
| 1647 | (error "No history")) |
| 1648 | (let* ((len (ring-length term-input-ring)) |
| 1649 | (motion (if (> arg 0) 1 -1)) |
| 1650 | (n (mod (- (or start (term-search-start arg)) motion) len)) |
| 1651 | (tried-each-ring-item nil) |
| 1652 | (prev nil)) |
| 1653 | ;; Do the whole search as many times as the argument says. |
| 1654 | (while (and (/= arg 0) (not tried-each-ring-item)) |
| 1655 | ;; Step once. |
| 1656 | (setq prev n |
| 1657 | n (mod (+ n motion) len)) |
| 1658 | ;; If we haven't reached a match, step some more. |
| 1659 | (while (and (< n len) (not tried-each-ring-item) |
| 1660 | (not (string-match regexp (ring-ref term-input-ring n)))) |
| 1661 | (setq n (mod (+ n motion) len) |
| 1662 | ;; If we have gone all the way around in this search. |
| 1663 | tried-each-ring-item (= n prev))) |
| 1664 | (setq arg (if (> arg 0) (1- arg) (1+ arg)))) |
| 1665 | ;; Now that we know which ring element to use, if we found it, return that. |
| 1666 | (when (string-match regexp (ring-ref term-input-ring n)) |
| 1667 | n))) |
| 1668 | |
| 1669 | (defun term-previous-matching-input (regexp arg) |
| 1670 | "Search backwards through input history for match for REGEXP. |
| 1671 | \(Previous history elements are earlier commands.) |
| 1672 | With prefix argument N, search for Nth previous match. |
| 1673 | If N is negative, find the next or Nth next match." |
| 1674 | (interactive (term-regexp-arg "Previous input matching (regexp): ")) |
| 1675 | (setq arg (term-search-arg arg)) |
| 1676 | (let ((pos (term-previous-matching-input-string-position regexp arg))) |
| 1677 | ;; Has a match been found? |
| 1678 | (if (null pos) |
| 1679 | (error "Not found") |
| 1680 | (setq term-input-ring-index pos) |
| 1681 | (message "History item: %d" (1+ pos)) |
| 1682 | (delete-region |
| 1683 | ;; Can't use kill-region as it sets this-command |
| 1684 | (process-mark (get-buffer-process (current-buffer))) (point)) |
| 1685 | (insert (ring-ref term-input-ring pos))))) |
| 1686 | |
| 1687 | (defun term-next-matching-input (regexp arg) |
| 1688 | "Search forwards through input history for match for REGEXP. |
| 1689 | \(Later history elements are more recent commands.) |
| 1690 | With prefix argument N, search for Nth following match. |
| 1691 | If N is negative, find the previous or Nth previous match." |
| 1692 | (interactive (term-regexp-arg "Next input matching (regexp): ")) |
| 1693 | (term-previous-matching-input regexp (- arg))) |
| 1694 | |
| 1695 | (defun term-previous-matching-input-from-input (arg) |
| 1696 | "Search backwards through input history for match for current input. |
| 1697 | \(Previous history elements are earlier commands.) |
| 1698 | With prefix argument N, search for Nth previous match. |
| 1699 | If N is negative, search forwards for the -Nth following match." |
| 1700 | (interactive "p") |
| 1701 | (when (not (memq last-command '(term-previous-matching-input-from-input |
| 1702 | term-next-matching-input-from-input))) |
| 1703 | ;; Starting a new search |
| 1704 | (setq term-matching-input-from-input-string |
| 1705 | (buffer-substring |
| 1706 | (process-mark (get-buffer-process (current-buffer))) |
| 1707 | (point)) |
| 1708 | term-input-ring-index nil)) |
| 1709 | (term-previous-matching-input |
| 1710 | (concat "^" (regexp-quote term-matching-input-from-input-string)) |
| 1711 | arg)) |
| 1712 | |
| 1713 | (defun term-next-matching-input-from-input (arg) |
| 1714 | "Search forwards through input history for match for current input. |
| 1715 | \(Following history elements are more recent commands.) |
| 1716 | With prefix argument N, search for Nth following match. |
| 1717 | If N is negative, search backwards for the -Nth previous match." |
| 1718 | (interactive "p") |
| 1719 | (term-previous-matching-input-from-input (- arg))) |
| 1720 | |
| 1721 | |
| 1722 | (defun term-replace-by-expanded-history (&optional silent) |
| 1723 | "Expand input command history references before point. |
| 1724 | Expansion is dependent on the value of `term-input-autoexpand'. |
| 1725 | |
| 1726 | This function depends on the buffer's idea of the input history, which may not |
| 1727 | match the command interpreter's idea, assuming it has one. |
| 1728 | |
| 1729 | Assumes history syntax is like typical Un*x shells'. However, since Emacs |
| 1730 | cannot know the interpreter's idea of input line numbers, assuming it has one, |
| 1731 | it cannot expand absolute input line number references. |
| 1732 | |
| 1733 | If the optional argument SILENT is non-nil, never complain |
| 1734 | even if history reference seems erroneous. |
| 1735 | |
| 1736 | See `term-magic-space' and `term-replace-by-expanded-history-before-point'. |
| 1737 | |
| 1738 | Returns t if successful." |
| 1739 | (interactive) |
| 1740 | (when (and term-input-autoexpand |
| 1741 | (string-match "[!^]" (funcall term-get-old-input)) |
| 1742 | (save-excursion (beginning-of-line) |
| 1743 | (looking-at term-prompt-regexp))) |
| 1744 | ;; Looks like there might be history references in the command. |
| 1745 | (let ((previous-modified-tick (buffer-modified-tick))) |
| 1746 | (message "Expanding history references...") |
| 1747 | (term-replace-by-expanded-history-before-point silent) |
| 1748 | (/= previous-modified-tick (buffer-modified-tick))))) |
| 1749 | |
| 1750 | |
| 1751 | (defun term-replace-by-expanded-history-before-point (silent) |
| 1752 | "Expand directory stack reference before point. |
| 1753 | See `term-replace-by-expanded-history'. Returns t if successful." |
| 1754 | (save-excursion |
| 1755 | (let ((toend (- (save-excursion (end-of-line nil) (point)) (point))) |
| 1756 | (start (progn (term-bol nil) (point)))) |
| 1757 | (while (progn |
| 1758 | (skip-chars-forward "^!^" |
| 1759 | (save-excursion |
| 1760 | (end-of-line nil) (- (point) toend))) |
| 1761 | (< (point) |
| 1762 | (save-excursion |
| 1763 | (end-of-line nil) (- (point) toend)))) |
| 1764 | ;; This seems a bit complex. We look for references such as !!, !-num, |
| 1765 | ;; !foo, !?foo, !{bar}, !?{bar}, ^oh, ^my^, ^god^it, ^never^ends^. |
| 1766 | ;; If that wasn't enough, the plings can be suffixed with argument |
| 1767 | ;; range specifiers. |
| 1768 | ;; Argument ranges are complex too, so we hive off the input line, |
| 1769 | ;; referenced with plings, with the range string to `term-args'. |
| 1770 | (setq term-input-ring-index nil) |
| 1771 | (cond ((or (= (preceding-char) ?\\) |
| 1772 | (term-within-quotes start (point))) |
| 1773 | ;; The history is quoted, or we're in quotes. |
| 1774 | (goto-char (1+ (point)))) |
| 1775 | ((looking-at "![0-9]+\\($\\|[^-]\\)") |
| 1776 | ;; We cannot know the interpreter's idea of input line numbers. |
| 1777 | (goto-char (match-end 0)) |
| 1778 | (message "Absolute reference cannot be expanded")) |
| 1779 | ((looking-at "!-\\([0-9]+\\)\\(:?[0-9^$*-]+\\)?") |
| 1780 | ;; Just a number of args from `number' lines backward. |
| 1781 | (let ((number (1- (string-to-number |
| 1782 | (buffer-substring (match-beginning 1) |
| 1783 | (match-end 1)))))) |
| 1784 | (if (<= number (ring-length term-input-ring)) |
| 1785 | (progn |
| 1786 | (replace-match |
| 1787 | (term-args (term-previous-input-string number) |
| 1788 | (match-beginning 2) (match-end 2)) |
| 1789 | t t) |
| 1790 | (setq term-input-ring-index number) |
| 1791 | (message "History item: %d" (1+ number))) |
| 1792 | (goto-char (match-end 0)) |
| 1793 | (message "Relative reference exceeds input history size")))) |
| 1794 | ((or (looking-at "!!?:?\\([0-9^$*-]+\\)") (looking-at "!!")) |
| 1795 | ;; Just a number of args from the previous input line. |
| 1796 | (replace-match |
| 1797 | (term-args (term-previous-input-string 0) |
| 1798 | (match-beginning 1) (match-end 1)) |
| 1799 | t t) |
| 1800 | (message "History item: previous")) |
| 1801 | ((looking-at |
| 1802 | "!\\??\\({\\(.+\\)}\\|\\(\\sw+\\)\\)\\(:?[0-9^$*-]+\\)?") |
| 1803 | ;; Most recent input starting with or containing (possibly |
| 1804 | ;; protected) string, maybe just a number of args. Phew. |
| 1805 | (let* ((mb1 (match-beginning 1)) (me1 (match-end 1)) |
| 1806 | (mb2 (match-beginning 2)) (me2 (match-end 2)) |
| 1807 | (exp (buffer-substring (or mb2 mb1) (or me2 me1))) |
| 1808 | (pref (if (save-match-data (looking-at "!\\?")) "" "^")) |
| 1809 | (pos (save-match-data |
| 1810 | (term-previous-matching-input-string-position |
| 1811 | (concat pref (regexp-quote exp)) 1)))) |
| 1812 | (if (null pos) |
| 1813 | (progn |
| 1814 | (goto-char (match-end 0)) |
| 1815 | (or silent |
| 1816 | (progn (message "Not found") |
| 1817 | (ding)))) |
| 1818 | (setq term-input-ring-index pos) |
| 1819 | (replace-match |
| 1820 | (term-args (ring-ref term-input-ring pos) |
| 1821 | (match-beginning 4) (match-end 4)) |
| 1822 | t t) |
| 1823 | (message "History item: %d" (1+ pos))))) |
| 1824 | ((looking-at "\\^\\([^^]+\\)\\^?\\([^^]*\\)\\^?") |
| 1825 | ;; Quick substitution on the previous input line. |
| 1826 | (let ((old (buffer-substring (match-beginning 1) (match-end 1))) |
| 1827 | (new (buffer-substring (match-beginning 2) (match-end 2))) |
| 1828 | (pos nil)) |
| 1829 | (replace-match (term-previous-input-string 0) t t) |
| 1830 | (setq pos (point)) |
| 1831 | (goto-char (match-beginning 0)) |
| 1832 | (if (not (search-forward old pos t)) |
| 1833 | (or silent |
| 1834 | (error "Not found")) |
| 1835 | (replace-match new t t) |
| 1836 | (message "History item: substituted")))) |
| 1837 | (t |
| 1838 | (goto-char (match-end 0)))))))) |
| 1839 | |
| 1840 | |
| 1841 | (defun term-magic-space (arg) |
| 1842 | "Expand input history references before point and insert ARG spaces. |
| 1843 | A useful command to bind to SPC. See `term-replace-by-expanded-history'." |
| 1844 | (interactive "p") |
| 1845 | (term-replace-by-expanded-history) |
| 1846 | (self-insert-command arg)) |
| 1847 | \f |
| 1848 | (defun term-within-quotes (beg end) |
| 1849 | "Return t if the number of quotes between BEG and END is odd. |
| 1850 | Quotes are single and double." |
| 1851 | (let ((countsq (term-how-many-region "\\(^\\|[^\\\\]\\)\'" beg end)) |
| 1852 | (countdq (term-how-many-region "\\(^\\|[^\\\\]\\)\"" beg end))) |
| 1853 | (or (= (mod countsq 2) 1) (= (mod countdq 2) 1)))) |
| 1854 | |
| 1855 | (defun term-how-many-region (regexp beg end) |
| 1856 | "Return number of matches for REGEXP from BEG to END." |
| 1857 | (let ((count 0)) |
| 1858 | (save-excursion |
| 1859 | (save-match-data |
| 1860 | (goto-char beg) |
| 1861 | (while (re-search-forward regexp end t) |
| 1862 | (setq count (1+ count))))) |
| 1863 | count)) |
| 1864 | |
| 1865 | (defun term-args (string begin end) |
| 1866 | ;; From STRING, return the args depending on the range specified in the text |
| 1867 | ;; from BEGIN to END. If BEGIN is nil, assume all args. Ignore leading `:'. |
| 1868 | ;; Range can be x-y, x-, -y, where x/y can be [0-9], *, ^, $. |
| 1869 | (save-match-data |
| 1870 | (if (null begin) |
| 1871 | (term-arguments string 0 nil) |
| 1872 | (let* ((range (buffer-substring |
| 1873 | (if (eq (char-after begin) ?:) (1+ begin) begin) end)) |
| 1874 | (nth (cond ((string-match "^[*^]" range) 1) |
| 1875 | ((string-match "^-" range) 0) |
| 1876 | ((string-equal range "$") nil) |
| 1877 | (t (string-to-number range)))) |
| 1878 | (mth (cond ((string-match "[-*$]$" range) nil) |
| 1879 | ((string-match "-" range) |
| 1880 | (string-to-number (substring range (match-end 0)))) |
| 1881 | (t nth)))) |
| 1882 | (term-arguments string nth mth))))) |
| 1883 | |
| 1884 | ;; Return a list of arguments from ARG. Break it up at the |
| 1885 | ;; delimiters in term-delimiter-argument-list. Returned list is backwards. |
| 1886 | (defun term-delim-arg (arg) |
| 1887 | (if (null term-delimiter-argument-list) |
| 1888 | (list arg) |
| 1889 | (let ((args nil) |
| 1890 | (pos 0) |
| 1891 | (len (length arg))) |
| 1892 | (while (< pos len) |
| 1893 | (let ((char (aref arg pos)) |
| 1894 | (start pos)) |
| 1895 | (if (memq char term-delimiter-argument-list) |
| 1896 | (while (and (< pos len) (eq (aref arg pos) char)) |
| 1897 | (setq pos (1+ pos))) |
| 1898 | (while (and (< pos len) |
| 1899 | (not (memq (aref arg pos) |
| 1900 | term-delimiter-argument-list))) |
| 1901 | (setq pos (1+ pos)))) |
| 1902 | (setq args (cons (substring arg start pos) args)))) |
| 1903 | args))) |
| 1904 | |
| 1905 | (defun term-arguments (string nth mth) |
| 1906 | "Return from STRING the NTH to MTH arguments. |
| 1907 | NTH and/or MTH can be nil, which means the last argument. |
| 1908 | Returned arguments are separated by single spaces. |
| 1909 | We assume whitespace separates arguments, except within quotes. |
| 1910 | Also, a run of one or more of a single character |
| 1911 | in `term-delimiter-argument-list' is a separate argument. |
| 1912 | Argument 0 is the command name." |
| 1913 | (let ((argpart "[^ \n\t\"'`]+\\|\\(\"[^\"]*\"\\|'[^']*'\\|`[^`]*`\\)") |
| 1914 | (args ()) (pos 0) |
| 1915 | (count 0) |
| 1916 | beg str quotes) |
| 1917 | ;; Build a list of all the args until we have as many as we want. |
| 1918 | (while (and (or (null mth) (<= count mth)) |
| 1919 | (string-match argpart string pos)) |
| 1920 | (if (and beg (= pos (match-beginning 0))) |
| 1921 | ;; It's contiguous, part of the same arg. |
| 1922 | (setq pos (match-end 0) |
| 1923 | quotes (or quotes (match-beginning 1))) |
| 1924 | ;; It's a new separate arg. |
| 1925 | (if beg |
| 1926 | ;; Put the previous arg, if there was one, onto ARGS. |
| 1927 | (setq str (substring string beg pos) |
| 1928 | args (if quotes (cons str args) |
| 1929 | (nconc (term-delim-arg str) args)) |
| 1930 | count (1+ count))) |
| 1931 | (setq quotes (match-beginning 1)) |
| 1932 | (setq beg (match-beginning 0)) |
| 1933 | (setq pos (match-end 0)))) |
| 1934 | (if beg |
| 1935 | (setq str (substring string beg pos) |
| 1936 | args (if quotes (cons str args) |
| 1937 | (nconc (term-delim-arg str) args)) |
| 1938 | count (1+ count))) |
| 1939 | (let ((n (or nth (1- count))) |
| 1940 | (m (if mth (1- (- count mth)) 0))) |
| 1941 | (mapconcat |
| 1942 | (function (lambda (a) a)) (nthcdr n (nreverse (nthcdr m args))) " ")))) |
| 1943 | \f |
| 1944 | ;;; |
| 1945 | ;;; Input processing stuff [line mode] |
| 1946 | ;;; |
| 1947 | |
| 1948 | (defun term-send-input () |
| 1949 | "Send input to process. |
| 1950 | After the process output mark, sends all text from the process mark to |
| 1951 | point as input to the process. Before the process output mark, calls value |
| 1952 | of variable term-get-old-input to retrieve old input, copies it to the |
| 1953 | process mark, and sends it. A terminal newline is also inserted into the |
| 1954 | buffer and sent to the process. The list of function names contained in the |
| 1955 | value of `term-input-filter-functions' is called on the input before sending |
| 1956 | it. The input is entered into the input history ring, if the value of variable |
| 1957 | term-input-filter returns non-nil when called on the input. |
| 1958 | |
| 1959 | Any history reference may be expanded depending on the value of the variable |
| 1960 | `term-input-autoexpand'. The list of function names contained in the value |
| 1961 | of `term-input-filter-functions' is called on the input before sending it. |
| 1962 | The input is entered into the input history ring, if the value of variable |
| 1963 | `term-input-filter' returns non-nil when called on the input. |
| 1964 | |
| 1965 | If variable `term-eol-on-send' is non-nil, then point is moved to the |
| 1966 | end of line before sending the input. |
| 1967 | |
| 1968 | The values of `term-get-old-input', `term-input-filter-functions', and |
| 1969 | `term-input-filter' are chosen according to the command interpreter running |
| 1970 | in the buffer. E.g., |
| 1971 | |
| 1972 | If the interpreter is the csh, |
| 1973 | term-get-old-input is the default: take the current line, discard any |
| 1974 | initial string matching regexp term-prompt-regexp. |
| 1975 | term-input-filter-functions monitors input for \"cd\", \"pushd\", and |
| 1976 | \"popd\" commands. When it sees one, it cd's the buffer. |
| 1977 | term-input-filter is the default: returns t if the input isn't all white |
| 1978 | space. |
| 1979 | |
| 1980 | If the term is Lucid Common Lisp, |
| 1981 | term-get-old-input snarfs the sexp ending at point. |
| 1982 | term-input-filter-functions does nothing. |
| 1983 | term-input-filter returns nil if the input matches input-filter-regexp, |
| 1984 | which matches (1) all whitespace (2) :a, :c, etc. |
| 1985 | |
| 1986 | Similarly for Soar, Scheme, etc." |
| 1987 | (interactive) |
| 1988 | ;; Note that the input string does not include its terminal newline. |
| 1989 | (let ((proc (get-buffer-process (current-buffer)))) |
| 1990 | (if (not proc) (error "Current buffer has no process") |
| 1991 | (let* ((pmark (process-mark proc)) |
| 1992 | (pmark-val (marker-position pmark)) |
| 1993 | (input-is-new (>= (point) pmark-val)) |
| 1994 | (intxt (if input-is-new |
| 1995 | (progn (if term-eol-on-send (end-of-line)) |
| 1996 | (buffer-substring pmark (point))) |
| 1997 | (funcall term-get-old-input))) |
| 1998 | (input (if (not (eq term-input-autoexpand 'input)) |
| 1999 | ;; Just whatever's already there |
| 2000 | intxt |
| 2001 | ;; Expand and leave it visible in buffer |
| 2002 | (term-replace-by-expanded-history t) |
| 2003 | (buffer-substring pmark (point)))) |
| 2004 | (history (if (not (eq term-input-autoexpand 'history)) |
| 2005 | input |
| 2006 | ;; This is messy 'cos ultimately the original |
| 2007 | ;; functions used do insertion, rather than return |
| 2008 | ;; strings. We have to expand, then insert back. |
| 2009 | (term-replace-by-expanded-history t) |
| 2010 | (let ((copy (buffer-substring pmark (point)))) |
| 2011 | (delete-region pmark (point)) |
| 2012 | (insert input) |
| 2013 | copy)))) |
| 2014 | (when (term-pager-enabled) |
| 2015 | (save-excursion |
| 2016 | (goto-char (process-mark proc)) |
| 2017 | (setq term-pager-count (term-current-row)))) |
| 2018 | (when (and (funcall term-input-filter history) |
| 2019 | (or (null term-input-ignoredups) |
| 2020 | (not (ring-p term-input-ring)) |
| 2021 | (ring-empty-p term-input-ring) |
| 2022 | (not (string-equal (ring-ref term-input-ring 0) |
| 2023 | history)))) |
| 2024 | (ring-insert term-input-ring history)) |
| 2025 | (let ((functions term-input-filter-functions)) |
| 2026 | (while functions |
| 2027 | (funcall (car functions) (concat input "\n")) |
| 2028 | (setq functions (cdr functions)))) |
| 2029 | (setq term-input-ring-index nil) |
| 2030 | |
| 2031 | ;; Update the markers before we send the input |
| 2032 | ;; in case we get output amidst sending the input. |
| 2033 | (set-marker term-last-input-start pmark) |
| 2034 | (set-marker term-last-input-end (point)) |
| 2035 | (when input-is-new |
| 2036 | ;; Set up to delete, because inferior should echo. |
| 2037 | (when (marker-buffer term-pending-delete-marker) |
| 2038 | (delete-region term-pending-delete-marker pmark)) |
| 2039 | (set-marker term-pending-delete-marker pmark-val) |
| 2040 | (set-marker (process-mark proc) (point))) |
| 2041 | (goto-char pmark) |
| 2042 | (funcall term-input-sender proc input))))) |
| 2043 | |
| 2044 | (defun term-get-old-input-default () |
| 2045 | "Default for term-get-old-input. |
| 2046 | Take the current line, and discard any initial text matching |
| 2047 | term-prompt-regexp." |
| 2048 | (save-excursion |
| 2049 | (beginning-of-line) |
| 2050 | (term-skip-prompt) |
| 2051 | (let ((beg (point))) |
| 2052 | (end-of-line) |
| 2053 | (buffer-substring beg (point))))) |
| 2054 | |
| 2055 | (defun term-copy-old-input () |
| 2056 | "Insert after prompt old input at point as new input to be edited. |
| 2057 | Calls `term-get-old-input' to get old input." |
| 2058 | (interactive) |
| 2059 | (let ((input (funcall term-get-old-input)) |
| 2060 | (process (get-buffer-process (current-buffer)))) |
| 2061 | (if (not process) |
| 2062 | (error "Current buffer has no process") |
| 2063 | (goto-char (process-mark process)) |
| 2064 | (insert input)))) |
| 2065 | |
| 2066 | (defun term-skip-prompt () |
| 2067 | "Skip past the text matching regexp term-prompt-regexp. |
| 2068 | If this takes us past the end of the current line, don't skip at all." |
| 2069 | (let ((eol (save-excursion (end-of-line) (point)))) |
| 2070 | (when (and (looking-at term-prompt-regexp) |
| 2071 | (<= (match-end 0) eol)) |
| 2072 | (goto-char (match-end 0))))) |
| 2073 | |
| 2074 | |
| 2075 | (defun term-after-pmark-p () |
| 2076 | "Is point after the process output marker?" |
| 2077 | ;; Since output could come into the buffer after we looked at the point |
| 2078 | ;; but before we looked at the process marker's value, we explicitly |
| 2079 | ;; serialise. This is just because I don't know whether or not Emacs |
| 2080 | ;; services input during execution of lisp commands. |
| 2081 | (let ((proc-pos (marker-position |
| 2082 | (process-mark (get-buffer-process (current-buffer)))))) |
| 2083 | (<= proc-pos (point)))) |
| 2084 | |
| 2085 | (defun term-simple-send (proc string) |
| 2086 | "Default function for sending to PROC input STRING. |
| 2087 | This just sends STRING plus a newline. To override this, |
| 2088 | set the hook `term-input-sender'." |
| 2089 | (term-send-string proc string) |
| 2090 | (term-send-string proc "\n")) |
| 2091 | |
| 2092 | (defun term-bol (arg) |
| 2093 | "Goes to the beginning of line, then skips past the prompt, if any. |
| 2094 | If a prefix argument is given (\\[universal-argument]), then no prompt skip |
| 2095 | -- go straight to column 0. |
| 2096 | |
| 2097 | The prompt skip is done by skipping text matching the regular expression |
| 2098 | term-prompt-regexp, a buffer local variable." |
| 2099 | (interactive "P") |
| 2100 | (beginning-of-line) |
| 2101 | (when (null arg) (term-skip-prompt))) |
| 2102 | |
| 2103 | ;;; These two functions are for entering text you don't want echoed or |
| 2104 | ;;; saved -- typically passwords to ftp, telnet, or somesuch. |
| 2105 | ;;; Just enter m-x term-send-invisible and type in your line. |
| 2106 | |
| 2107 | (defun term-read-noecho (prompt &optional stars) |
| 2108 | "Read a single line of text from user without echoing, and return it. |
| 2109 | Prompt with argument PROMPT, a string. Optional argument STARS causes |
| 2110 | input to be echoed with '*' characters on the prompt line. Input ends with |
| 2111 | RET, LFD, or ESC. DEL or C-h rubs out. C-u kills line. C-g aborts (if |
| 2112 | `inhibit-quit' is set because e.g. this function was called from a process |
| 2113 | filter and C-g is pressed, this function returns nil rather than a string). |
| 2114 | |
| 2115 | Note that the keystrokes comprising the text can still be recovered |
| 2116 | \(temporarily) with \\[view-lossage]. This may be a security bug for some |
| 2117 | applications." |
| 2118 | (let ((ans "") |
| 2119 | (c 0) |
| 2120 | (echo-keystrokes 0) |
| 2121 | (cursor-in-echo-area t) |
| 2122 | (done nil)) |
| 2123 | (while (not done) |
| 2124 | (if stars |
| 2125 | (message "%s%s" prompt (make-string (length ans) ?*)) |
| 2126 | (message "%s" prompt)) |
| 2127 | (setq c (read-char)) |
| 2128 | (cond ((= c ?\C-g) |
| 2129 | ;; This function may get called from a process filter, where |
| 2130 | ;; inhibit-quit is set. In later versions of Emacs read-char |
| 2131 | ;; may clear quit-flag itself and return C-g. That would make |
| 2132 | ;; it impossible to quit this loop in a simple way, so |
| 2133 | ;; re-enable it here (for backward-compatibility the check for |
| 2134 | ;; quit-flag below would still be necessary, so this seems |
| 2135 | ;; like the simplest way to do things). |
| 2136 | (setq quit-flag t |
| 2137 | done t)) |
| 2138 | ((or (= c ?\r) (= c ?\n) (= c ?\e)) |
| 2139 | (setq done t)) |
| 2140 | ((= c ?\C-u) |
| 2141 | (setq ans "")) |
| 2142 | ((and (/= c ?\b) (/= c ?\177)) |
| 2143 | (setq ans (concat ans (char-to-string c)))) |
| 2144 | ((> (length ans) 0) |
| 2145 | (setq ans (substring ans 0 -1))))) |
| 2146 | (if quit-flag |
| 2147 | ;; Emulate a true quit, except that we have to return a value. |
| 2148 | (prog1 |
| 2149 | (setq quit-flag nil) |
| 2150 | (message "Quit") |
| 2151 | (beep t)) |
| 2152 | (message "") |
| 2153 | ans))) |
| 2154 | |
| 2155 | (defun term-send-invisible (str &optional proc) |
| 2156 | "Read a string without echoing. |
| 2157 | Then send it to the process running in the current buffer. A new-line |
| 2158 | is additionally sent. String is not saved on term input history list. |
| 2159 | Security bug: your string can still be temporarily recovered with |
| 2160 | \\[view-lossage]." |
| 2161 | (interactive "P") ; Defeat snooping via C-x esc |
| 2162 | (when (not (stringp str)) |
| 2163 | (setq str (term-read-noecho "Non-echoed text: " t))) |
| 2164 | (when (not proc) |
| 2165 | (setq proc (get-buffer-process (current-buffer)))) |
| 2166 | (if (not proc) (error "Current buffer has no process") |
| 2167 | (setq term-kill-echo-list (nconc term-kill-echo-list |
| 2168 | (cons str nil))) |
| 2169 | (term-send-string proc str) |
| 2170 | (term-send-string proc "\n"))) |
| 2171 | |
| 2172 | \f |
| 2173 | ;;; Low-level process communication |
| 2174 | |
| 2175 | (defvar term-input-chunk-size 512 |
| 2176 | "*Long inputs send to term processes are broken up into chunks of this size. |
| 2177 | If your process is choking on big inputs, try lowering the value.") |
| 2178 | |
| 2179 | (defun term-send-string (proc str) |
| 2180 | "Send to PROC the contents of STR as input. |
| 2181 | This is equivalent to process-send-string, except that long input strings |
| 2182 | are broken up into chunks of size term-input-chunk-size. Processes |
| 2183 | are given a chance to output between chunks. This can help prevent processes |
| 2184 | from hanging when you send them long inputs on some OS's." |
| 2185 | (let* ((len (length str)) |
| 2186 | (i (min len term-input-chunk-size))) |
| 2187 | (process-send-string proc (substring str 0 i)) |
| 2188 | (while (< i len) |
| 2189 | (let ((next-i (+ i term-input-chunk-size))) |
| 2190 | (accept-process-output) |
| 2191 | (process-send-string proc (substring str i (min len next-i))) |
| 2192 | (setq i next-i))))) |
| 2193 | |
| 2194 | (defun term-send-region (proc start end) |
| 2195 | "Send to PROC the region delimited by START and END. |
| 2196 | This is a replacement for process-send-region that tries to keep |
| 2197 | your process from hanging on long inputs. See `term-send-string'." |
| 2198 | (term-send-string proc (buffer-substring start end))) |
| 2199 | |
| 2200 | \f |
| 2201 | ;;; Random input hackage |
| 2202 | |
| 2203 | (defun term-kill-output () |
| 2204 | "Kill all output from interpreter since last input." |
| 2205 | (interactive) |
| 2206 | (let ((pmark (process-mark (get-buffer-process (current-buffer))))) |
| 2207 | (kill-region term-last-input-end pmark) |
| 2208 | (goto-char pmark) |
| 2209 | (insert "*** output flushed ***\n") |
| 2210 | (set-marker pmark (point)))) |
| 2211 | |
| 2212 | (defun term-show-output () |
| 2213 | "Display start of this batch of interpreter output at top of window. |
| 2214 | Sets mark to the value of point when this command is run." |
| 2215 | (interactive) |
| 2216 | (goto-char term-last-input-end) |
| 2217 | (backward-char) |
| 2218 | (beginning-of-line) |
| 2219 | (set-window-start (selected-window) (point)) |
| 2220 | (end-of-line)) |
| 2221 | |
| 2222 | (defun term-interrupt-subjob () |
| 2223 | "Interrupt the current subjob." |
| 2224 | (interactive) |
| 2225 | (interrupt-process nil term-ptyp)) |
| 2226 | |
| 2227 | (defun term-kill-subjob () |
| 2228 | "Send kill signal to the current subjob." |
| 2229 | (interactive) |
| 2230 | (kill-process nil term-ptyp)) |
| 2231 | |
| 2232 | (defun term-quit-subjob () |
| 2233 | "Send quit signal to the current subjob." |
| 2234 | (interactive) |
| 2235 | (quit-process nil term-ptyp)) |
| 2236 | |
| 2237 | (defun term-stop-subjob () |
| 2238 | "Stop the current subjob. |
| 2239 | WARNING: if there is no current subjob, you can end up suspending |
| 2240 | the top-level process running in the buffer. If you accidentally do |
| 2241 | this, use \\[term-continue-subjob] to resume the process. (This |
| 2242 | is not a problem with most shells, since they ignore this signal.)" |
| 2243 | (interactive) |
| 2244 | (stop-process nil term-ptyp)) |
| 2245 | |
| 2246 | (defun term-continue-subjob () |
| 2247 | "Send CONT signal to process buffer's process group. |
| 2248 | Useful if you accidentally suspend the top-level process." |
| 2249 | (interactive) |
| 2250 | (continue-process nil term-ptyp)) |
| 2251 | |
| 2252 | (defun term-kill-input () |
| 2253 | "Kill all text from last stuff output by interpreter to point." |
| 2254 | (interactive) |
| 2255 | (let* ((pmark (process-mark (get-buffer-process (current-buffer)))) |
| 2256 | (p-pos (marker-position pmark))) |
| 2257 | (when (> (point) p-pos) |
| 2258 | (kill-region pmark (point))))) |
| 2259 | |
| 2260 | (defun term-delchar-or-maybe-eof (arg) |
| 2261 | "Delete ARG characters forward, or send an EOF to process if at end of |
| 2262 | buffer." |
| 2263 | (interactive "p") |
| 2264 | (if (eobp) |
| 2265 | (process-send-eof) |
| 2266 | (delete-char arg))) |
| 2267 | |
| 2268 | (defun term-send-eof () |
| 2269 | "Send an EOF to the current buffer's process." |
| 2270 | (interactive) |
| 2271 | (process-send-eof)) |
| 2272 | |
| 2273 | (defun term-backward-matching-input (regexp arg) |
| 2274 | "Search backward through buffer for match for REGEXP. |
| 2275 | Matches are searched for on lines that match `term-prompt-regexp'. |
| 2276 | With prefix argument N, search for Nth previous match. |
| 2277 | If N is negative, find the next or Nth next match." |
| 2278 | (interactive (term-regexp-arg "Backward input matching (regexp): ")) |
| 2279 | (let* ((re (concat term-prompt-regexp ".*" regexp)) |
| 2280 | (pos (save-excursion (end-of-line (if (> arg 0) 0 1)) |
| 2281 | (when (re-search-backward re nil t arg) |
| 2282 | (point))))) |
| 2283 | (if (null pos) |
| 2284 | (progn (message "Not found") |
| 2285 | (ding)) |
| 2286 | (goto-char pos) |
| 2287 | (term-bol nil)))) |
| 2288 | |
| 2289 | (defun term-forward-matching-input (regexp arg) |
| 2290 | "Search forward through buffer for match for REGEXP. |
| 2291 | Matches are searched for on lines that match `term-prompt-regexp'. |
| 2292 | With prefix argument N, search for Nth following match. |
| 2293 | If N is negative, find the previous or Nth previous match." |
| 2294 | (interactive (term-regexp-arg "Forward input matching (regexp): ")) |
| 2295 | (term-backward-matching-input regexp (- arg))) |
| 2296 | |
| 2297 | |
| 2298 | (defun term-next-prompt (n) |
| 2299 | "Move to end of Nth next prompt in the buffer. |
| 2300 | See `term-prompt-regexp'." |
| 2301 | (interactive "p") |
| 2302 | (let ((paragraph-start term-prompt-regexp)) |
| 2303 | (end-of-line (if (> n 0) 1 0)) |
| 2304 | (forward-paragraph n) |
| 2305 | (term-skip-prompt))) |
| 2306 | |
| 2307 | (defun term-previous-prompt (n) |
| 2308 | "Move to end of Nth previous prompt in the buffer. |
| 2309 | See `term-prompt-regexp'." |
| 2310 | (interactive "p") |
| 2311 | (term-next-prompt (- n))) |
| 2312 | \f |
| 2313 | ;;; Support for source-file processing commands. |
| 2314 | ;;;============================================================================ |
| 2315 | ;;; Many command-interpreters (e.g., Lisp, Scheme, Soar) have |
| 2316 | ;;; commands that process files of source text (e.g. loading or compiling |
| 2317 | ;;; files). So the corresponding process-in-a-buffer modes have commands |
| 2318 | ;;; for doing this (e.g., lisp-load-file). The functions below are useful |
| 2319 | ;;; for defining these commands. |
| 2320 | ;;; |
| 2321 | ;;; Alas, these guys don't do exactly the right thing for Lisp, Scheme |
| 2322 | ;;; and Soar, in that they don't know anything about file extensions. |
| 2323 | ;;; So the compile/load interface gets the wrong default occasionally. |
| 2324 | ;;; The load-file/compile-file default mechanism could be smarter -- it |
| 2325 | ;;; doesn't know about the relationship between filename extensions and |
| 2326 | ;;; whether the file is source or executable. If you compile foo.lisp |
| 2327 | ;;; with compile-file, then the next load-file should use foo.bin for |
| 2328 | ;;; the default, not foo.lisp. This is tricky to do right, particularly |
| 2329 | ;;; because the extension for executable files varies so much (.o, .bin, |
| 2330 | ;;; .lbin, .mo, .vo, .ao, ...). |
| 2331 | |
| 2332 | |
| 2333 | ;;; TERM-SOURCE-DEFAULT -- determines defaults for source-file processing |
| 2334 | ;;; commands. |
| 2335 | ;;; |
| 2336 | ;;; TERM-CHECK-SOURCE -- if FNAME is in a modified buffer, asks you if you |
| 2337 | ;;; want to save the buffer before issuing any process requests to the command |
| 2338 | ;;; interpreter. |
| 2339 | ;;; |
| 2340 | ;;; TERM-GET-SOURCE -- used by the source-file processing commands to prompt |
| 2341 | ;;; for the file to process. |
| 2342 | |
| 2343 | ;;; (TERM-SOURCE-DEFAULT previous-dir/file source-modes) |
| 2344 | ;;;============================================================================ |
| 2345 | ;;; This function computes the defaults for the load-file and compile-file |
| 2346 | ;;; commands for tea, soar, cmulisp, and cmuscheme modes. |
| 2347 | ;;; |
| 2348 | ;;; - PREVIOUS-DIR/FILE is a pair (directory . filename) from the last |
| 2349 | ;;; source-file processing command, or nil if there hasn't been one yet. |
| 2350 | ;;; - SOURCE-MODES is a list used to determine what buffers contain source |
| 2351 | ;;; files: if the major mode of the buffer is in SOURCE-MODES, it's source. |
| 2352 | ;;; Typically, (lisp-mode) or (scheme-mode). |
| 2353 | ;;; |
| 2354 | ;;; If the command is given while the cursor is inside a string, *and* |
| 2355 | ;;; the string is an existing filename, *and* the filename is not a directory, |
| 2356 | ;;; then the string is taken as default. This allows you to just position |
| 2357 | ;;; your cursor over a string that's a filename and have it taken as default. |
| 2358 | ;;; |
| 2359 | ;;; If the command is given in a file buffer whose major mode is in |
| 2360 | ;;; SOURCE-MODES, then the filename is the default file, and the |
| 2361 | ;;; file's directory is the default directory. |
| 2362 | ;;; |
| 2363 | ;;; If the buffer isn't a source file buffer (e.g., it's the process buffer), |
| 2364 | ;;; then the default directory & file are what was used in the last source-file |
| 2365 | ;;; processing command (i.e., PREVIOUS-DIR/FILE). If this is the first time |
| 2366 | ;;; the command has been run (PREVIOUS-DIR/FILE is nil), the default directory |
| 2367 | ;;; is the cwd, with no default file. (\"no default file\" = nil) |
| 2368 | ;;; |
| 2369 | ;;; SOURCE-REGEXP is typically going to be something like (tea-mode) |
| 2370 | ;;; for T programs, (lisp-mode) for Lisp programs, (soar-mode lisp-mode) |
| 2371 | ;;; for Soar programs, etc. |
| 2372 | ;;; |
| 2373 | ;;; The function returns a pair: (default-directory . default-file). |
| 2374 | |
| 2375 | (defun term-source-default (previous-dir/file source-modes) |
| 2376 | (cond ((and buffer-file-name (memq major-mode source-modes)) |
| 2377 | (cons (file-name-directory buffer-file-name) |
| 2378 | (file-name-nondirectory buffer-file-name))) |
| 2379 | (previous-dir/file) |
| 2380 | (t |
| 2381 | (cons default-directory nil)))) |
| 2382 | |
| 2383 | |
| 2384 | ;;; (TERM-CHECK-SOURCE fname) |
| 2385 | ;;;============================================================================ |
| 2386 | ;;; Prior to loading or compiling (or otherwise processing) a file (in the CMU |
| 2387 | ;;; process-in-a-buffer modes), this function can be called on the filename. |
| 2388 | ;;; If the file is loaded into a buffer, and the buffer is modified, the user |
| 2389 | ;;; is queried to see if he wants to save the buffer before proceeding with |
| 2390 | ;;; the load or compile. |
| 2391 | |
| 2392 | (defun term-check-source (fname) |
| 2393 | (let ((buff (get-file-buffer fname))) |
| 2394 | (when (and buff |
| 2395 | (buffer-modified-p buff) |
| 2396 | (y-or-n-p (format "Save buffer %s first? " |
| 2397 | (buffer-name buff)))) |
| 2398 | ;; save BUFF. |
| 2399 | (let ((old-buffer (current-buffer))) |
| 2400 | (set-buffer buff) |
| 2401 | (save-buffer) |
| 2402 | (set-buffer old-buffer))))) |
| 2403 | |
| 2404 | |
| 2405 | ;;; (TERM-GET-SOURCE prompt prev-dir/file source-modes mustmatch-p) |
| 2406 | ;;;============================================================================ |
| 2407 | ;;; TERM-GET-SOURCE is used to prompt for filenames in command-interpreter |
| 2408 | ;;; commands that process source files (like loading or compiling a file). |
| 2409 | ;;; It prompts for the filename, provides a default, if there is one, |
| 2410 | ;;; and returns the result filename. |
| 2411 | ;;; |
| 2412 | ;;; See TERM-SOURCE-DEFAULT for more on determining defaults. |
| 2413 | ;;; |
| 2414 | ;;; PROMPT is the prompt string. PREV-DIR/FILE is the (directory . file) pair |
| 2415 | ;;; from the last source processing command. SOURCE-MODES is a list of major |
| 2416 | ;;; modes used to determine what file buffers contain source files. (These |
| 2417 | ;;; two arguments are used for determining defaults). If MUSTMATCH-P is true, |
| 2418 | ;;; then the filename reader will only accept a file that exists. |
| 2419 | ;;; |
| 2420 | ;;; A typical use: |
| 2421 | ;;; (interactive (term-get-source "Compile file: " prev-lisp-dir/file |
| 2422 | ;;; '(lisp-mode) t)) |
| 2423 | |
| 2424 | ;;; This is pretty stupid about strings. It decides we're in a string |
| 2425 | ;;; if there's a quote on both sides of point on the current line. |
| 2426 | (defun term-extract-string () |
| 2427 | "Return string around `point' that starts the current line or nil." |
| 2428 | (save-excursion |
| 2429 | (let* ((point (point)) |
| 2430 | (bol (progn (beginning-of-line) (point))) |
| 2431 | (eol (progn (end-of-line) (point))) |
| 2432 | (start (progn (goto-char point) |
| 2433 | (and (search-backward "\"" bol t) |
| 2434 | (1+ (point))))) |
| 2435 | (end (progn (goto-char point) |
| 2436 | (and (search-forward "\"" eol t) |
| 2437 | (1- (point)))))) |
| 2438 | (and start end |
| 2439 | (buffer-substring start end))))) |
| 2440 | |
| 2441 | (defun term-get-source (prompt prev-dir/file source-modes mustmatch-p) |
| 2442 | (let* ((def (term-source-default prev-dir/file source-modes)) |
| 2443 | (stringfile (term-extract-string)) |
| 2444 | (sfile-p (and stringfile |
| 2445 | (condition-case () |
| 2446 | (file-exists-p stringfile) |
| 2447 | (error nil)) |
| 2448 | (not (file-directory-p stringfile)))) |
| 2449 | (defdir (if sfile-p (file-name-directory stringfile) |
| 2450 | (car def))) |
| 2451 | (deffile (if sfile-p (file-name-nondirectory stringfile) |
| 2452 | (cdr def))) |
| 2453 | (ans (read-file-name (if deffile (format "%s(default %s) " |
| 2454 | prompt deffile) |
| 2455 | prompt) |
| 2456 | defdir |
| 2457 | (concat defdir deffile) |
| 2458 | mustmatch-p))) |
| 2459 | (list (expand-file-name (substitute-in-file-name ans))))) |
| 2460 | |
| 2461 | ;;; I am somewhat divided on this string-default feature. It seems |
| 2462 | ;;; to violate the principle-of-least-astonishment, in that it makes |
| 2463 | ;;; the default harder to predict, so you actually have to look and see |
| 2464 | ;;; what the default really is before choosing it. This can trip you up. |
| 2465 | ;;; On the other hand, it can be useful, I guess. I would appreciate feedback |
| 2466 | ;;; on this. |
| 2467 | ;;; -Olin |
| 2468 | |
| 2469 | \f |
| 2470 | ;;; Simple process query facility. |
| 2471 | ;;; =========================================================================== |
| 2472 | ;;; This function is for commands that want to send a query to the process |
| 2473 | ;;; and show the response to the user. For example, a command to get the |
| 2474 | ;;; arglist for a Common Lisp function might send a "(arglist 'foo)" query |
| 2475 | ;;; to an inferior Common Lisp process. |
| 2476 | ;;; |
| 2477 | ;;; This simple facility just sends strings to the inferior process and pops |
| 2478 | ;;; up a window for the process buffer so you can see what the process |
| 2479 | ;;; responds with. We don't do anything fancy like try to intercept what the |
| 2480 | ;;; process responds with and put it in a pop-up window or on the message |
| 2481 | ;;; line. We just display the buffer. Low tech. Simple. Works good. |
| 2482 | |
| 2483 | ;;; Send to the inferior process PROC the string STR. Pop-up but do not select |
| 2484 | ;;; a window for the inferior process so that its response can be seen. |
| 2485 | (defun term-proc-query (proc str) |
| 2486 | (let* ((proc-buf (process-buffer proc)) |
| 2487 | (proc-mark (process-mark proc))) |
| 2488 | (display-buffer proc-buf) |
| 2489 | (set-buffer proc-buf) ; but it's not the selected *window* |
| 2490 | (let ((proc-win (get-buffer-window proc-buf)) |
| 2491 | (proc-pt (marker-position proc-mark))) |
| 2492 | (term-send-string proc str) ; send the query |
| 2493 | (accept-process-output proc) ; wait for some output |
| 2494 | ;; Try to position the proc window so you can see the answer. |
| 2495 | ;; This is bogus code. If you delete the (sit-for 0), it breaks. |
| 2496 | ;; I don't know why. Wizards invited to improve it. |
| 2497 | (when (not (pos-visible-in-window-p proc-pt proc-win)) |
| 2498 | (let ((opoint (window-point proc-win))) |
| 2499 | (set-window-point proc-win proc-mark) (sit-for 0) |
| 2500 | (if (not (pos-visible-in-window-p opoint proc-win)) |
| 2501 | (push-mark opoint) |
| 2502 | (set-window-point proc-win opoint))))))) |
| 2503 | \f |
| 2504 | ;;; Returns the current column in the current screen line. |
| 2505 | ;;; Note: (current-column) yields column in buffer line. |
| 2506 | |
| 2507 | (defun term-horizontal-column () |
| 2508 | (- (term-current-column) (term-start-line-column))) |
| 2509 | |
| 2510 | ;; Calls either vertical-motion or term-buffer-vertical-motion |
| 2511 | (defmacro term-vertical-motion (count) |
| 2512 | (list 'funcall 'term-vertical-motion count)) |
| 2513 | |
| 2514 | ;; An emulation of vertical-motion that is independent of having a window. |
| 2515 | ;; Instead, it uses the term-width variable as the logical window width. |
| 2516 | |
| 2517 | (defun term-buffer-vertical-motion (count) |
| 2518 | (cond ((= count 0) |
| 2519 | (move-to-column (* term-width (/ (current-column) term-width))) |
| 2520 | 0) |
| 2521 | ((> count 0) |
| 2522 | (let ((H) |
| 2523 | (todo (+ count (/ (current-column) term-width)))) |
| 2524 | (end-of-line) |
| 2525 | ;; The loop iterates over buffer lines; |
| 2526 | ;; H is the number of screen lines in the current line, i.e. |
| 2527 | ;; the ceiling of dividing the buffer line width by term-width. |
| 2528 | (while (and (<= (setq H (max (/ (+ (current-column) term-width -1) |
| 2529 | term-width) |
| 2530 | 1)) |
| 2531 | todo) |
| 2532 | (not (eobp))) |
| 2533 | (setq todo (- todo H)) |
| 2534 | (forward-char) ;; Move past the ?\n |
| 2535 | (end-of-line)) ;; and on to the end of the next line. |
| 2536 | (if (and (>= todo H) (> todo 0)) |
| 2537 | (+ (- count todo) H -1) ;; Hit end of buffer. |
| 2538 | (move-to-column (* todo term-width)) |
| 2539 | count))) |
| 2540 | (t ;; (< count 0) ;; Similar algorithm, but for upward motion. |
| 2541 | (let ((H) |
| 2542 | (todo (- count))) |
| 2543 | (while (and (<= (setq H (max (/ (+ (current-column) term-width -1) |
| 2544 | term-width) |
| 2545 | 1)) |
| 2546 | todo) |
| 2547 | (progn (beginning-of-line) |
| 2548 | (not (bobp)))) |
| 2549 | (setq todo (- todo H)) |
| 2550 | (backward-char)) ;; Move to end of previous line. |
| 2551 | (if (and (>= todo H) (> todo 0)) |
| 2552 | (+ count todo (- 1 H)) ;; Hit beginning of buffer. |
| 2553 | (move-to-column (* (- H todo 1) term-width)) |
| 2554 | count))))) |
| 2555 | |
| 2556 | ;;; The term-start-line-column variable is used as a cache. |
| 2557 | (defun term-start-line-column () |
| 2558 | (cond (term-start-line-column) |
| 2559 | ((let ((save-pos (point))) |
| 2560 | (term-vertical-motion 0) |
| 2561 | (setq term-start-line-column (current-column)) |
| 2562 | (goto-char save-pos) |
| 2563 | term-start-line-column)))) |
| 2564 | |
| 2565 | ;;; Same as (current-column), but uses term-current-column as a cache. |
| 2566 | (defun term-current-column () |
| 2567 | (cond (term-current-column) |
| 2568 | ((setq term-current-column (current-column))))) |
| 2569 | |
| 2570 | ;;; Move DELTA column right (or left if delta < 0 limiting at column 0). |
| 2571 | |
| 2572 | (defun term-move-columns (delta) |
| 2573 | (setq term-current-column (max 0 (+ (term-current-column) delta))) |
| 2574 | (let (point-at-eol) |
| 2575 | (save-excursion |
| 2576 | (end-of-line) |
| 2577 | (setq point-at-eol (point))) |
| 2578 | (move-to-column term-current-column t) |
| 2579 | ;; If move-to-column extends the current line it will use the face |
| 2580 | ;; from the last character on the line, set the face for the chars |
| 2581 | ;; to default. |
| 2582 | (when (> (point) point-at-eol) |
| 2583 | (put-text-property point-at-eol (point) 'face 'default)))) |
| 2584 | |
| 2585 | ;; Insert COUNT copies of CHAR in the default face. |
| 2586 | (defun term-insert-char (char count) |
| 2587 | (let ((old-point (point))) |
| 2588 | (insert-char char count) |
| 2589 | (put-text-property old-point (point) 'face 'default))) |
| 2590 | |
| 2591 | (defun term-current-row () |
| 2592 | (cond (term-current-row) |
| 2593 | ((setq term-current-row |
| 2594 | (save-restriction |
| 2595 | (save-excursion |
| 2596 | (narrow-to-region term-home-marker (point-max)) |
| 2597 | (- (term-vertical-motion -9999)))))))) |
| 2598 | |
| 2599 | (defun term-adjust-current-row-cache (delta) |
| 2600 | (when term-current-row |
| 2601 | (setq term-current-row |
| 2602 | (max 0 (+ term-current-row delta))))) |
| 2603 | |
| 2604 | (defun term-terminal-pos () |
| 2605 | (save-excursion ; save-restriction |
| 2606 | (let ((save-col (term-current-column)) |
| 2607 | x y) |
| 2608 | (term-vertical-motion 0) |
| 2609 | (setq x (- save-col (current-column))) |
| 2610 | (setq y (term-vertical-motion term-height)) |
| 2611 | (cons x y)))) |
| 2612 | |
| 2613 | ;;;Function that handles term messages: code by rms ( and you can see the |
| 2614 | ;;;difference ;-) -mm |
| 2615 | |
| 2616 | (defun term-handle-ansi-terminal-messages (message) |
| 2617 | ;; Is there a command here? |
| 2618 | (while (string-match "\eAnSiT.+\n" message) |
| 2619 | ;; Extract the command code and the argument. |
| 2620 | (let* ((start (match-beginning 0)) |
| 2621 | (end (match-end 0)) |
| 2622 | (command-code (aref message (+ start 6))) |
| 2623 | (argument |
| 2624 | (save-match-data |
| 2625 | (substring message |
| 2626 | (+ start 8) |
| 2627 | (string-match "\r?\n" message |
| 2628 | (+ start 8))))) |
| 2629 | ignore) |
| 2630 | ;; Delete this command from MESSAGE. |
| 2631 | (setq message (replace-match "" t t message)) |
| 2632 | |
| 2633 | ;; If we recognize the type of command, set the appropriate variable. |
| 2634 | (cond ((= command-code ?c) |
| 2635 | (setq term-ansi-at-dir argument)) |
| 2636 | ((= command-code ?h) |
| 2637 | (setq term-ansi-at-host argument)) |
| 2638 | ((= command-code ?u) |
| 2639 | (setq term-ansi-at-user argument)) |
| 2640 | ;; Otherwise ignore this one. |
| 2641 | (t |
| 2642 | (setq ignore t))) |
| 2643 | |
| 2644 | ;; Update default-directory based on the changes this command made. |
| 2645 | (if ignore |
| 2646 | nil |
| 2647 | (setq default-directory |
| 2648 | (file-name-as-directory |
| 2649 | (if (and (string= term-ansi-at-host (system-name)) |
| 2650 | (string= term-ansi-at-user (user-real-login-name))) |
| 2651 | (expand-file-name term-ansi-at-dir) |
| 2652 | (if (string= term-ansi-at-user (user-real-login-name)) |
| 2653 | (concat "/" term-ansi-at-host ":" term-ansi-at-dir) |
| 2654 | (concat "/" term-ansi-at-user "@" term-ansi-at-host ":" |
| 2655 | term-ansi-at-dir))))) |
| 2656 | |
| 2657 | ;; I'm not sure this is necessary, |
| 2658 | ;; but it's best to be on the safe side. |
| 2659 | (if (string= term-ansi-at-host (system-name)) |
| 2660 | (progn |
| 2661 | (setq ange-ftp-default-user term-ansi-at-save-user) |
| 2662 | (setq ange-ftp-default-password term-ansi-at-save-pwd) |
| 2663 | (setq ange-ftp-generate-anonymous-password term-ansi-at-save-anon)) |
| 2664 | (setq term-ansi-at-save-user ange-ftp-default-user) |
| 2665 | (setq term-ansi-at-save-pwd ange-ftp-default-password) |
| 2666 | (setq term-ansi-at-save-anon ange-ftp-generate-anonymous-password) |
| 2667 | (setq ange-ftp-default-user nil) |
| 2668 | (setq ange-ftp-default-password nil) |
| 2669 | (setq ange-ftp-generate-anonymous-password nil))))) |
| 2670 | message) |
| 2671 | |
| 2672 | |
| 2673 | ;;; Terminal emulation |
| 2674 | ;;; This is the standard process filter for term buffers. |
| 2675 | ;;; It emulates (most of the features of) a VT100/ANSI-style terminal. |
| 2676 | |
| 2677 | (defun term-emulate-terminal (proc str) |
| 2678 | (with-current-buffer (process-buffer proc) |
| 2679 | (let* ((i 0) char funny count save-point save-marker old-point temp win |
| 2680 | (buffer-undo-list t) |
| 2681 | (selected (selected-window)) |
| 2682 | last-win |
| 2683 | handled-ansi-message |
| 2684 | (str-length (length str))) |
| 2685 | (save-selected-window |
| 2686 | |
| 2687 | ;; Let's handle the messages. -mm |
| 2688 | |
| 2689 | (let* ((newstr (term-handle-ansi-terminal-messages str))) |
| 2690 | (when (not (eq str newstr)) |
| 2691 | (setq handled-ansi-message t |
| 2692 | str newstr))) |
| 2693 | (setq str-length (length str)) |
| 2694 | |
| 2695 | (when (marker-buffer term-pending-delete-marker) |
| 2696 | ;; Delete text following term-pending-delete-marker. |
| 2697 | (delete-region term-pending-delete-marker (process-mark proc)) |
| 2698 | (set-marker term-pending-delete-marker nil)) |
| 2699 | |
| 2700 | (if (eq (window-buffer) (current-buffer)) |
| 2701 | (progn |
| 2702 | (setq term-vertical-motion (symbol-function 'vertical-motion)) |
| 2703 | (term-check-size proc)) |
| 2704 | (setq term-vertical-motion |
| 2705 | (symbol-function 'term-buffer-vertical-motion))) |
| 2706 | |
| 2707 | (setq save-marker (copy-marker (process-mark proc))) |
| 2708 | |
| 2709 | (when (/= (point) (process-mark proc)) |
| 2710 | (setq save-point (point-marker)) |
| 2711 | (goto-char (process-mark proc))) |
| 2712 | |
| 2713 | (save-restriction |
| 2714 | ;; If the buffer is in line mode, and there is a partial |
| 2715 | ;; input line, save the line (by narrowing to leave it |
| 2716 | ;; outside the restriction ) until we're done with output. |
| 2717 | (when (and (> (point-max) (process-mark proc)) |
| 2718 | (term-in-line-mode)) |
| 2719 | (narrow-to-region (point-min) (process-mark proc))) |
| 2720 | |
| 2721 | (when term-log-buffer |
| 2722 | (princ str term-log-buffer)) |
| 2723 | (cond ((eq term-terminal-state 4) ;; Have saved pending output. |
| 2724 | (setq str (concat term-terminal-parameter str)) |
| 2725 | (setq term-terminal-parameter nil) |
| 2726 | (setq str-length (length str)) |
| 2727 | (setq term-terminal-state 0))) |
| 2728 | |
| 2729 | (while (< i str-length) |
| 2730 | (setq char (aref str i)) |
| 2731 | (cond ((< term-terminal-state 2) |
| 2732 | ;; Look for prefix of regular chars |
| 2733 | (setq funny |
| 2734 | (string-match "[\r\n\000\007\033\t\b\032\016\017]" |
| 2735 | str i)) |
| 2736 | (when (not funny) (setq funny str-length)) |
| 2737 | (cond ((> funny i) |
| 2738 | (cond ((eq term-terminal-state 1) |
| 2739 | ;; We are in state 1, we need to wrap |
| 2740 | ;; around. Go to the beginning of |
| 2741 | ;; the next line and switch to state |
| 2742 | ;; 0. |
| 2743 | (term-down 1 t) |
| 2744 | (term-move-columns (- (term-current-column))) |
| 2745 | (setq term-terminal-state 0))) |
| 2746 | (setq count (- funny i)) |
| 2747 | (setq temp (- (+ (term-horizontal-column) count) |
| 2748 | term-width)) |
| 2749 | (cond ((<= temp 0)) ;; All count chars fit in line. |
| 2750 | ((> count temp) ;; Some chars fit. |
| 2751 | ;; This iteration, handle only what fits. |
| 2752 | (setq count (- count temp)) |
| 2753 | (setq temp 0) |
| 2754 | (setq funny (+ count i))) |
| 2755 | ((or (not (or term-pager-count |
| 2756 | term-scroll-with-delete)) |
| 2757 | (> (term-handle-scroll 1) 0)) |
| 2758 | (term-adjust-current-row-cache 1) |
| 2759 | (setq count (min count term-width)) |
| 2760 | (setq funny (+ count i)) |
| 2761 | (setq term-start-line-column |
| 2762 | term-current-column)) |
| 2763 | (t ;; Doing PAGER processing. |
| 2764 | (setq count 0 funny i) |
| 2765 | (setq term-current-column nil) |
| 2766 | (setq term-start-line-column nil))) |
| 2767 | (setq old-point (point)) |
| 2768 | |
| 2769 | ;; Insert a string, check how many columns |
| 2770 | ;; we moved, then delete that many columns |
| 2771 | ;; following point if not eob nor insert-mode. |
| 2772 | (let ((old-column (current-column)) |
| 2773 | columns pos) |
| 2774 | (insert (decode-coding-string (substring str i funny) locale-coding-system)) |
| 2775 | (setq term-current-column (current-column) |
| 2776 | columns (- term-current-column old-column)) |
| 2777 | (when (not (or (eobp) term-insert-mode)) |
| 2778 | (setq pos (point)) |
| 2779 | (term-move-columns columns) |
| 2780 | (delete-region pos (point))) |
| 2781 | ;; In insert mode if the current line |
| 2782 | ;; has become too long it needs to be |
| 2783 | ;; chopped off. |
| 2784 | (when term-insert-mode |
| 2785 | (setq pos (point)) |
| 2786 | (end-of-line) |
| 2787 | (when (> (current-column) term-width) |
| 2788 | (delete-region (- (point) (- (current-column) term-width)) |
| 2789 | (point))) |
| 2790 | (goto-char pos))) |
| 2791 | (setq term-current-column nil) |
| 2792 | |
| 2793 | (put-text-property old-point (point) |
| 2794 | 'face term-current-face) |
| 2795 | ;; If the last char was written in last column, |
| 2796 | ;; back up one column, but remember we did so. |
| 2797 | ;; Thus we emulate xterm/vt100-style line-wrapping. |
| 2798 | (cond ((eq temp 0) |
| 2799 | (term-move-columns -1) |
| 2800 | (setq term-terminal-state 1))) |
| 2801 | (setq i (1- funny))) |
| 2802 | ((and (setq term-terminal-state 0) |
| 2803 | (eq char ?\^I)) ; TAB (terminfo: ht) |
| 2804 | (setq count (term-current-column)) |
| 2805 | ;; The line cannot exceed term-width. TAB at |
| 2806 | ;; the end of a line should not cause wrapping. |
| 2807 | (setq count (min term-width |
| 2808 | (+ count 8 (- (mod count 8))))) |
| 2809 | (if (> term-width count) |
| 2810 | (progn |
| 2811 | (term-move-columns |
| 2812 | (- count (term-current-column))) |
| 2813 | (setq term-current-column count)) |
| 2814 | (when (> term-width (term-current-column)) |
| 2815 | (term-move-columns |
| 2816 | (1- (- term-width (term-current-column))))) |
| 2817 | (when (= term-width (term-current-column)) |
| 2818 | (term-move-columns -1)))) |
| 2819 | ((eq char ?\r) ;; (terminfo: cr) |
| 2820 | (term-vertical-motion 0) |
| 2821 | (setq term-current-column term-start-line-column)) |
| 2822 | ((eq char ?\n) ;; (terminfo: cud1, ind) |
| 2823 | (unless (and term-kill-echo-list |
| 2824 | (term-check-kill-echo-list)) |
| 2825 | (term-down 1 t))) |
| 2826 | ((eq char ?\b) ;; (terminfo: cub1) |
| 2827 | (term-move-columns -1)) |
| 2828 | ((eq char ?\033) ; Escape |
| 2829 | (setq term-terminal-state 2)) |
| 2830 | ((eq char 0)) ; NUL: Do nothing |
| 2831 | ((eq char ?\016)) ; Shift Out - ignored |
| 2832 | ((eq char ?\017)) ; Shift In - ignored |
| 2833 | ((eq char ?\^G) ;; (terminfo: bel) |
| 2834 | (beep t)) |
| 2835 | ((and (eq char ?\032) |
| 2836 | (not handled-ansi-message)) |
| 2837 | (let ((end (string-match "\r?$" str i))) |
| 2838 | (if end |
| 2839 | (funcall term-command-hook |
| 2840 | (prog1 (substring str (1+ i) end) |
| 2841 | (setq i (match-end 0)))) |
| 2842 | (setq term-terminal-parameter (substring str i)) |
| 2843 | (setq term-terminal-state 4) |
| 2844 | (setq i str-length)))) |
| 2845 | (t ; insert char FIXME: Should never happen |
| 2846 | (term-move-columns 1) |
| 2847 | (backward-delete-char 1) |
| 2848 | (insert char)))) |
| 2849 | ((eq term-terminal-state 2) ; Seen Esc |
| 2850 | (cond ((eq char ?\133) ;; ?\133 = ?[ |
| 2851 | |
| 2852 | ;;; Some modifications to cope with multiple settings like ^[[01;32;43m -mm |
| 2853 | ;;; Note that now the init value of term-terminal-previous-parameter has |
| 2854 | ;;; been changed to -1 |
| 2855 | |
| 2856 | (setq term-terminal-parameter 0) |
| 2857 | (setq term-terminal-previous-parameter -1) |
| 2858 | (setq term-terminal-previous-parameter-2 -1) |
| 2859 | (setq term-terminal-previous-parameter-3 -1) |
| 2860 | (setq term-terminal-previous-parameter-4 -1) |
| 2861 | (setq term-terminal-more-parameters 0) |
| 2862 | (setq term-terminal-state 3)) |
| 2863 | ((eq char ?D) ;; scroll forward |
| 2864 | (term-handle-deferred-scroll) |
| 2865 | (term-down 1 t) |
| 2866 | (setq term-terminal-state 0)) |
| 2867 | ;; ((eq char ?E) ;; (terminfo: nw), not used for |
| 2868 | ;; ;; now, but this is a working |
| 2869 | ;; ;; implementation |
| 2870 | ;; (term-down 1) |
| 2871 | ;; (term-goto term-current-row 0) |
| 2872 | ;; (setq term-terminal-state 0)) |
| 2873 | ((eq char ?M) ;; scroll reversed (terminfo: ri) |
| 2874 | (if (or (< (term-current-row) term-scroll-start) |
| 2875 | (>= (1- (term-current-row)) |
| 2876 | term-scroll-start)) |
| 2877 | ;; Scrolling up will not move outside |
| 2878 | ;; the scroll region. |
| 2879 | (term-down -1) |
| 2880 | ;; Scrolling the scroll region is needed. |
| 2881 | (term-down -1 t)) |
| 2882 | (setq term-terminal-state 0)) |
| 2883 | ((eq char ?7) ;; Save cursor (terminfo: sc) |
| 2884 | (term-handle-deferred-scroll) |
| 2885 | (setq term-saved-cursor |
| 2886 | (list (term-current-row) |
| 2887 | (term-horizontal-column) |
| 2888 | term-ansi-current-bg-color |
| 2889 | term-ansi-current-bold |
| 2890 | term-ansi-current-color |
| 2891 | term-ansi-current-invisible |
| 2892 | term-ansi-current-reverse |
| 2893 | term-ansi-current-underline |
| 2894 | term-current-face) |
| 2895 | ) |
| 2896 | (setq term-terminal-state 0)) |
| 2897 | ((eq char ?8) ;; Restore cursor (terminfo: rc) |
| 2898 | (when term-saved-cursor |
| 2899 | (term-goto (nth 0 term-saved-cursor) |
| 2900 | (nth 1 term-saved-cursor)) |
| 2901 | (setq term-ansi-current-bg-color |
| 2902 | (nth 2 term-saved-cursor) |
| 2903 | term-ansi-current-bold |
| 2904 | (nth 3 term-saved-cursor) |
| 2905 | term-ansi-current-color |
| 2906 | (nth 4 term-saved-cursor) |
| 2907 | term-ansi-current-invisible |
| 2908 | (nth 5 term-saved-cursor) |
| 2909 | term-ansi-current-reverse |
| 2910 | (nth 6 term-saved-cursor) |
| 2911 | term-ansi-current-underline |
| 2912 | (nth 7 term-saved-cursor) |
| 2913 | term-current-face |
| 2914 | (nth 8 term-saved-cursor))) |
| 2915 | (setq term-terminal-state 0)) |
| 2916 | ((eq char ?c) ;; \Ec - Reset (terminfo: rs1) |
| 2917 | ;; This is used by the "clear" program. |
| 2918 | (setq term-terminal-state 0) |
| 2919 | (term-reset-terminal)) |
| 2920 | ;; The \E#8 reset sequence for xterm. We |
| 2921 | ;; probably don't need to handle it, but this |
| 2922 | ;; is the code to parse it. |
| 2923 | ;; ((eq char ?#) |
| 2924 | ;; (when (eq (aref str (1+ i)) ?8) |
| 2925 | ;; (setq i (1+ i)) |
| 2926 | ;; (setq term-scroll-start 0) |
| 2927 | ;; (setq term-scroll-end term-height) |
| 2928 | ;; (setq term-terminal-state 0))) |
| 2929 | ((setq term-terminal-state 0)))) |
| 2930 | ((eq term-terminal-state 3) ; Seen Esc [ |
| 2931 | (cond ((and (>= char ?0) (<= char ?9)) |
| 2932 | (setq term-terminal-parameter |
| 2933 | (+ (* 10 term-terminal-parameter) (- char ?0)))) |
| 2934 | ((eq char ?\;) |
| 2935 | ;;; Some modifications to cope with multiple settings like ^[[01;32;43m -mm |
| 2936 | (setq term-terminal-more-parameters 1) |
| 2937 | (setq term-terminal-previous-parameter-4 |
| 2938 | term-terminal-previous-parameter-3) |
| 2939 | (setq term-terminal-previous-parameter-3 |
| 2940 | term-terminal-previous-parameter-2) |
| 2941 | (setq term-terminal-previous-parameter-2 |
| 2942 | term-terminal-previous-parameter) |
| 2943 | (setq term-terminal-previous-parameter |
| 2944 | term-terminal-parameter) |
| 2945 | (setq term-terminal-parameter 0)) |
| 2946 | ((eq char ??)) ; Ignore ? |
| 2947 | (t |
| 2948 | (term-handle-ansi-escape proc char) |
| 2949 | (setq term-terminal-more-parameters 0) |
| 2950 | (setq term-terminal-previous-parameter-4 -1) |
| 2951 | (setq term-terminal-previous-parameter-3 -1) |
| 2952 | (setq term-terminal-previous-parameter-2 -1) |
| 2953 | (setq term-terminal-previous-parameter -1) |
| 2954 | (setq term-terminal-state 0))))) |
| 2955 | (when (term-handling-pager) |
| 2956 | ;; Finish stuff to get ready to handle PAGER. |
| 2957 | (if (> (% (current-column) term-width) 0) |
| 2958 | (setq term-terminal-parameter |
| 2959 | (substring str i)) |
| 2960 | ;; We're at column 0. Goto end of buffer; to compensate, |
| 2961 | ;; prepend a ?\r for later. This looks more consistent. |
| 2962 | (if (zerop i) |
| 2963 | (setq term-terminal-parameter |
| 2964 | (concat "\r" (substring str i))) |
| 2965 | (setq term-terminal-parameter (substring str (1- i))) |
| 2966 | (aset term-terminal-parameter 0 ?\r)) |
| 2967 | (goto-char (point-max))) |
| 2968 | (setq term-terminal-state 4) |
| 2969 | (make-local-variable 'term-pager-old-filter) |
| 2970 | (setq term-pager-old-filter (process-filter proc)) |
| 2971 | (set-process-filter proc term-pager-filter) |
| 2972 | (setq i str-length)) |
| 2973 | (setq i (1+ i)))) |
| 2974 | |
| 2975 | (when (>= (term-current-row) term-height) |
| 2976 | (term-handle-deferred-scroll)) |
| 2977 | |
| 2978 | (set-marker (process-mark proc) (point)) |
| 2979 | (when save-point |
| 2980 | (goto-char save-point) |
| 2981 | (set-marker save-point nil)) |
| 2982 | |
| 2983 | ;; Check for a pending filename-and-line number to display. |
| 2984 | ;; We do this before scrolling, because we might create a new window. |
| 2985 | (when (and term-pending-frame |
| 2986 | (eq (window-buffer selected) (current-buffer))) |
| 2987 | (term-display-line (car term-pending-frame) |
| 2988 | (cdr term-pending-frame)) |
| 2989 | (setq term-pending-frame nil) |
| 2990 | ;; We have created a new window, so check the window size. |
| 2991 | (term-check-size proc)) |
| 2992 | |
| 2993 | ;; Scroll each window displaying the buffer but (by default) |
| 2994 | ;; only if the point matches the process-mark we started with. |
| 2995 | (setq win selected) |
| 2996 | ;; Avoid infinite loop in strange case where minibuffer window |
| 2997 | ;; is selected but not active. |
| 2998 | (while (window-minibuffer-p win) |
| 2999 | (setq win (next-window win nil t))) |
| 3000 | (setq last-win win) |
| 3001 | (while (progn |
| 3002 | (setq win (next-window win nil t)) |
| 3003 | (when (eq (window-buffer win) (process-buffer proc)) |
| 3004 | (let ((scroll term-scroll-to-bottom-on-output)) |
| 3005 | (select-window win) |
| 3006 | (when (or (= (point) save-marker) |
| 3007 | (eq scroll t) (eq scroll 'all) |
| 3008 | ;; Maybe user wants point to jump to the end. |
| 3009 | (and (eq selected win) |
| 3010 | (or (eq scroll 'this) (not save-point))) |
| 3011 | (and (eq scroll 'others) |
| 3012 | (not (eq selected win)))) |
| 3013 | (goto-char term-home-marker) |
| 3014 | (recenter 0) |
| 3015 | (goto-char (process-mark proc)) |
| 3016 | (if (not (pos-visible-in-window-p (point) win)) |
| 3017 | (recenter -1))) |
| 3018 | ;; Optionally scroll so that the text |
| 3019 | ;; ends at the bottom of the window. |
| 3020 | (when (and term-scroll-show-maximum-output |
| 3021 | (>= (point) (process-mark proc))) |
| 3022 | (save-excursion |
| 3023 | (goto-char (point-max)) |
| 3024 | (recenter -1))))) |
| 3025 | (not (eq win last-win)))) |
| 3026 | |
| 3027 | ;;; Stolen from comint.el and adapted -mm |
| 3028 | (when (> term-buffer-maximum-size 0) |
| 3029 | (save-excursion |
| 3030 | (goto-char (process-mark (get-buffer-process (current-buffer)))) |
| 3031 | (forward-line (- term-buffer-maximum-size)) |
| 3032 | (beginning-of-line) |
| 3033 | (delete-region (point-min) (point)))) |
| 3034 | (set-marker save-marker nil))))) |
| 3035 | |
| 3036 | (defun term-handle-deferred-scroll () |
| 3037 | (let ((count (- (term-current-row) term-height))) |
| 3038 | (when (>= count 0) |
| 3039 | (save-excursion |
| 3040 | (goto-char term-home-marker) |
| 3041 | (term-vertical-motion (1+ count)) |
| 3042 | (set-marker term-home-marker (point)) |
| 3043 | (setq term-current-row (1- term-height)))))) |
| 3044 | |
| 3045 | ;;; Reset the terminal, delete all the content and set the face to the |
| 3046 | ;;; default one. |
| 3047 | (defun term-reset-terminal () |
| 3048 | (erase-buffer) |
| 3049 | (setq term-current-row 0) |
| 3050 | (setq term-current-column 1) |
| 3051 | (setq term-scroll-start 0) |
| 3052 | (setq term-scroll-end term-height) |
| 3053 | (setq term-insert-mode nil) |
| 3054 | (setq term-current-face nil) |
| 3055 | (setq term-ansi-current-underline nil) |
| 3056 | (setq term-ansi-current-bold nil) |
| 3057 | (setq term-ansi-current-reverse nil) |
| 3058 | (setq term-ansi-current-color 0) |
| 3059 | (setq term-ansi-current-invisible nil) |
| 3060 | (setq term-ansi-face-already-done nil) |
| 3061 | (setq term-ansi-current-bg-color 0)) |
| 3062 | |
| 3063 | ;;; New function to deal with ansi colorized output, as you can see you can |
| 3064 | ;;; have any bold/underline/fg/bg/reverse combination. -mm |
| 3065 | |
| 3066 | (defun term-handle-colors-array (parameter) |
| 3067 | (cond |
| 3068 | |
| 3069 | ;;; Bold (terminfo: bold) |
| 3070 | ((eq parameter 1) |
| 3071 | (setq term-ansi-current-bold t)) |
| 3072 | |
| 3073 | ;;; Underline |
| 3074 | ((eq parameter 4) |
| 3075 | (setq term-ansi-current-underline t)) |
| 3076 | |
| 3077 | ;;; Blink (unsupported by Emacs), will be translated to bold. |
| 3078 | ;;; This may change in the future though. |
| 3079 | ((eq parameter 5) |
| 3080 | (setq term-ansi-current-bold t)) |
| 3081 | |
| 3082 | ;;; Reverse (terminfo: smso) |
| 3083 | ((eq parameter 7) |
| 3084 | (setq term-ansi-current-reverse t)) |
| 3085 | |
| 3086 | ;;; Invisible |
| 3087 | ((eq parameter 8) |
| 3088 | (setq term-ansi-current-invisible t)) |
| 3089 | |
| 3090 | ;;; Reset underline (terminfo: rmul) |
| 3091 | ((eq parameter 24) |
| 3092 | (setq term-ansi-current-underline nil)) |
| 3093 | |
| 3094 | ;;; Reset reverse (terminfo: rmso) |
| 3095 | ((eq parameter 27) |
| 3096 | (setq term-ansi-current-reverse nil)) |
| 3097 | |
| 3098 | ;;; Foreground |
| 3099 | ((and (>= parameter 30) (<= parameter 37)) |
| 3100 | (setq term-ansi-current-color (- parameter 29))) |
| 3101 | |
| 3102 | ;;; Reset foreground |
| 3103 | ((eq parameter 39) |
| 3104 | (setq term-ansi-current-color 0)) |
| 3105 | |
| 3106 | ;;; Background |
| 3107 | ((and (>= parameter 40) (<= parameter 47)) |
| 3108 | (setq term-ansi-current-bg-color (- parameter 39))) |
| 3109 | |
| 3110 | ;;; Reset background |
| 3111 | ((eq parameter 49) |
| 3112 | (setq term-ansi-current-bg-color 0)) |
| 3113 | |
| 3114 | ;;; 0 (Reset) or unknown (reset anyway) |
| 3115 | (t |
| 3116 | (setq term-current-face nil) |
| 3117 | (setq term-ansi-current-underline nil) |
| 3118 | (setq term-ansi-current-bold nil) |
| 3119 | (setq term-ansi-current-reverse nil) |
| 3120 | (setq term-ansi-current-color 0) |
| 3121 | (setq term-ansi-current-invisible nil) |
| 3122 | (setq term-ansi-face-already-done t) |
| 3123 | (setq term-ansi-current-bg-color 0))) |
| 3124 | |
| 3125 | ; (message "Debug: U-%d R-%d B-%d I-%d D-%d F-%d B-%d" |
| 3126 | ; term-ansi-current-underline |
| 3127 | ; term-ansi-current-reverse |
| 3128 | ; term-ansi-current-bold |
| 3129 | ; term-ansi-current-invisible |
| 3130 | ; term-ansi-face-already-done |
| 3131 | ; term-ansi-current-color |
| 3132 | ; term-ansi-current-bg-color) |
| 3133 | |
| 3134 | |
| 3135 | (unless term-ansi-face-already-done |
| 3136 | (if term-ansi-current-reverse |
| 3137 | (if term-ansi-current-invisible |
| 3138 | (setq term-current-face |
| 3139 | (if (= term-ansi-current-color 0) |
| 3140 | (list :background |
| 3141 | term-default-fg-color |
| 3142 | :foreground |
| 3143 | term-default-fg-color) |
| 3144 | (list :background |
| 3145 | (elt ansi-term-color-vector term-ansi-current-color) |
| 3146 | :foreground |
| 3147 | (elt ansi-term-color-vector term-ansi-current-color))) |
| 3148 | ;; No need to bother with anything else if it's invisible |
| 3149 | ) |
| 3150 | (setq term-current-face |
| 3151 | (list :background |
| 3152 | (if (= term-ansi-current-color 0) |
| 3153 | (face-foreground 'default) |
| 3154 | (elt ansi-term-color-vector term-ansi-current-color)) |
| 3155 | :foreground |
| 3156 | (if (= term-ansi-current-bg-color 0) |
| 3157 | (face-background 'default) |
| 3158 | (elt ansi-term-color-vector term-ansi-current-bg-color)))) |
| 3159 | (when term-ansi-current-bold |
| 3160 | (setq term-current-face |
| 3161 | (append '(:weight bold) term-current-face))) |
| 3162 | (when term-ansi-current-underline |
| 3163 | (setq term-current-face |
| 3164 | (append '(:underline t) term-current-face)))) |
| 3165 | (if term-ansi-current-invisible |
| 3166 | (setq term-current-face |
| 3167 | (if (= term-ansi-current-bg-color 0) |
| 3168 | (list :background |
| 3169 | term-default-bg-color |
| 3170 | :foreground |
| 3171 | term-default-bg-color) |
| 3172 | (list :foreground |
| 3173 | (elt ansi-term-color-vector term-ansi-current-bg-color) |
| 3174 | :background |
| 3175 | (elt ansi-term-color-vector term-ansi-current-bg-color))) |
| 3176 | ;; No need to bother with anything else if it's invisible |
| 3177 | ) |
| 3178 | (setq term-current-face |
| 3179 | (list :foreground |
| 3180 | (elt ansi-term-color-vector term-ansi-current-color) |
| 3181 | :background |
| 3182 | (elt ansi-term-color-vector term-ansi-current-bg-color))) |
| 3183 | (when term-ansi-current-bold |
| 3184 | (setq term-current-face |
| 3185 | (append '(:weight bold) term-current-face))) |
| 3186 | (when term-ansi-current-underline |
| 3187 | (setq term-current-face |
| 3188 | (append '(:underline t) term-current-face)))))) |
| 3189 | |
| 3190 | ;;; (message "Debug %S" term-current-face) |
| 3191 | (setq term-ansi-face-already-done nil)) |
| 3192 | |
| 3193 | |
| 3194 | ;;; Handle a character assuming (eq terminal-state 2) - |
| 3195 | ;;; i.e. we have previously seen Escape followed by ?[. |
| 3196 | |
| 3197 | (defun term-handle-ansi-escape (proc char) |
| 3198 | (cond |
| 3199 | ((or (eq char ?H) ;; cursor motion (terminfo: cup,home) |
| 3200 | ;; (eq char ?f) ;; xterm seems to handle this sequence too, not |
| 3201 | ;; needed for now |
| 3202 | ) |
| 3203 | (when (<= term-terminal-parameter 0) |
| 3204 | (setq term-terminal-parameter 1)) |
| 3205 | (when (<= term-terminal-previous-parameter 0) |
| 3206 | (setq term-terminal-previous-parameter 1)) |
| 3207 | (when (> term-terminal-previous-parameter term-height) |
| 3208 | (setq term-terminal-previous-parameter term-height)) |
| 3209 | (when (> term-terminal-parameter term-width) |
| 3210 | (setq term-terminal-parameter term-width)) |
| 3211 | (term-goto |
| 3212 | (1- term-terminal-previous-parameter) |
| 3213 | (1- term-terminal-parameter))) |
| 3214 | ;; \E[A - cursor up (terminfo: cuu, cuu1) |
| 3215 | ((eq char ?A) |
| 3216 | (term-handle-deferred-scroll) |
| 3217 | (let ((tcr (term-current-row))) |
| 3218 | (term-down |
| 3219 | (if (< (- tcr term-terminal-parameter) term-scroll-start) |
| 3220 | ;; If the amount to move is before scroll start, move |
| 3221 | ;; to scroll start. |
| 3222 | (- term-scroll-start tcr) |
| 3223 | (if (>= term-terminal-parameter tcr) |
| 3224 | (- tcr) |
| 3225 | (- (max 1 term-terminal-parameter)))) t))) |
| 3226 | ;; \E[B - cursor down (terminfo: cud) |
| 3227 | ((eq char ?B) |
| 3228 | (let ((tcr (term-current-row))) |
| 3229 | (unless (= tcr (1- term-scroll-end)) |
| 3230 | (term-down |
| 3231 | (if (> (+ tcr term-terminal-parameter) term-scroll-end) |
| 3232 | (- term-scroll-end 1 tcr) |
| 3233 | (max 1 term-terminal-parameter)) t)))) |
| 3234 | ;; \E[C - cursor right (terminfo: cuf, cuf1) |
| 3235 | ((eq char ?C) |
| 3236 | (term-move-columns |
| 3237 | (max 1 |
| 3238 | (if (>= (+ term-terminal-parameter (term-current-column)) term-width) |
| 3239 | (- term-width (term-current-column) 1) |
| 3240 | term-terminal-parameter)))) |
| 3241 | ;; \E[D - cursor left (terminfo: cub) |
| 3242 | ((eq char ?D) |
| 3243 | (term-move-columns (- (max 1 term-terminal-parameter)))) |
| 3244 | ;; \E[J - clear to end of screen (terminfo: ed, clear) |
| 3245 | ((eq char ?J) |
| 3246 | (term-erase-in-display term-terminal-parameter)) |
| 3247 | ;; \E[K - clear to end of line (terminfo: el, el1) |
| 3248 | ((eq char ?K) |
| 3249 | (term-erase-in-line term-terminal-parameter)) |
| 3250 | ;; \E[L - insert lines (terminfo: il, il1) |
| 3251 | ((eq char ?L) |
| 3252 | (term-insert-lines (max 1 term-terminal-parameter))) |
| 3253 | ;; \E[M - delete lines (terminfo: dl, dl1) |
| 3254 | ((eq char ?M) |
| 3255 | (term-delete-lines (max 1 term-terminal-parameter))) |
| 3256 | ;; \E[P - delete chars (terminfo: dch, dch1) |
| 3257 | ((eq char ?P) |
| 3258 | (term-delete-chars (max 1 term-terminal-parameter))) |
| 3259 | ;; \E[@ - insert spaces (terminfo: ich) |
| 3260 | ((eq char ?@) |
| 3261 | (term-insert-spaces (max 1 term-terminal-parameter))) |
| 3262 | ;; \E[?h - DEC Private Mode Set |
| 3263 | ((eq char ?h) |
| 3264 | (cond ((eq term-terminal-parameter 4) ;; (terminfo: smir) |
| 3265 | (setq term-insert-mode t)) |
| 3266 | ;; ((eq term-terminal-parameter 47) ;; (terminfo: smcup) |
| 3267 | ;; (term-switch-to-alternate-sub-buffer t)) |
| 3268 | )) |
| 3269 | ;; \E[?l - DEC Private Mode Reset |
| 3270 | ((eq char ?l) |
| 3271 | (cond ((eq term-terminal-parameter 4) ;; (terminfo: rmir) |
| 3272 | (setq term-insert-mode nil)) |
| 3273 | ;; ((eq term-terminal-parameter 47) ;; (terminfo: rmcup) |
| 3274 | ;; (term-switch-to-alternate-sub-buffer nil)) |
| 3275 | )) |
| 3276 | |
| 3277 | ;;; Modified to allow ansi coloring -mm |
| 3278 | ;; \E[m - Set/reset modes, set bg/fg |
| 3279 | ;;(terminfo: smso,rmso,smul,rmul,rev,bold,sgr0,invis,op,setab,setaf) |
| 3280 | ((eq char ?m) |
| 3281 | (when (= term-terminal-more-parameters 1) |
| 3282 | (when (>= term-terminal-previous-parameter-4 0) |
| 3283 | (term-handle-colors-array term-terminal-previous-parameter-4)) |
| 3284 | (when (>= term-terminal-previous-parameter-3 0) |
| 3285 | (term-handle-colors-array term-terminal-previous-parameter-3)) |
| 3286 | (when (>= term-terminal-previous-parameter-2 0) |
| 3287 | (term-handle-colors-array term-terminal-previous-parameter-2)) |
| 3288 | (term-handle-colors-array term-terminal-previous-parameter)) |
| 3289 | (term-handle-colors-array term-terminal-parameter)) |
| 3290 | |
| 3291 | ;; \E[6n - Report cursor position |
| 3292 | ((eq char ?n) |
| 3293 | (term-handle-deferred-scroll) |
| 3294 | (process-send-string proc |
| 3295 | (format "\e[%s;%sR" |
| 3296 | (1+ (term-current-row)) |
| 3297 | (1+ (term-horizontal-column))))) |
| 3298 | ;; \E[r - Set scrolling region (terminfo: csr) |
| 3299 | ((eq char ?r) |
| 3300 | (term-set-scroll-region |
| 3301 | (1- term-terminal-previous-parameter) |
| 3302 | (1- term-terminal-parameter))) |
| 3303 | (t))) |
| 3304 | |
| 3305 | (defun term-set-scroll-region (top bottom) |
| 3306 | "Set scrolling region. |
| 3307 | TOP is the top-most line (inclusive) of the new scrolling region, |
| 3308 | while BOTTOM is the line following the new scrolling region (e.g. exclusive). |
| 3309 | The top-most line is line 0." |
| 3310 | (setq term-scroll-start |
| 3311 | (if (or (< top 0) (>= top term-height)) |
| 3312 | 0 |
| 3313 | top)) |
| 3314 | (setq term-scroll-end |
| 3315 | (if (or (<= bottom term-scroll-start) (> bottom term-height)) |
| 3316 | term-height |
| 3317 | bottom)) |
| 3318 | (setq term-scroll-with-delete |
| 3319 | (or (term-using-alternate-sub-buffer) |
| 3320 | (not (and (= term-scroll-start 0) |
| 3321 | (= term-scroll-end term-height))))) |
| 3322 | (term-move-columns (- (term-current-column))) |
| 3323 | (term-goto 0 0)) |
| 3324 | |
| 3325 | ;; (defun term-switch-to-alternate-sub-buffer (set) |
| 3326 | ;; ;; If asked to switch to (from) the alternate sub-buffer, and already (not) |
| 3327 | ;; ;; using it, do nothing. This test is needed for some programs (including |
| 3328 | ;; ;; Emacs) that emit the ti termcap string twice, for unknown reason. |
| 3329 | ;; (term-handle-deferred-scroll) |
| 3330 | ;; (if (eq set (not (term-using-alternate-sub-buffer))) |
| 3331 | ;; (let ((row (term-current-row)) |
| 3332 | ;; (col (term-horizontal-column))) |
| 3333 | ;; (cond (set |
| 3334 | ;; (goto-char (point-max)) |
| 3335 | ;; (if (not (eq (preceding-char) ?\n)) |
| 3336 | ;; (term-insert-char ?\n 1)) |
| 3337 | ;; (setq term-scroll-with-delete t) |
| 3338 | ;; (setq term-saved-home-marker (copy-marker term-home-marker)) |
| 3339 | ;; (set-marker term-home-marker (point))) |
| 3340 | ;; (t |
| 3341 | ;; (setq term-scroll-with-delete |
| 3342 | ;; (not (and (= term-scroll-start 0) |
| 3343 | ;; (= term-scroll-end term-height)))) |
| 3344 | ;; (set-marker term-home-marker term-saved-home-marker) |
| 3345 | ;; (set-marker term-saved-home-marker nil) |
| 3346 | ;; (setq term-saved-home-marker nil) |
| 3347 | ;; (goto-char term-home-marker))) |
| 3348 | ;; (setq term-current-column nil) |
| 3349 | ;; (setq term-current-row 0) |
| 3350 | ;; (term-goto row col)))) |
| 3351 | |
| 3352 | ;; Default value for the symbol term-command-hook. |
| 3353 | |
| 3354 | (defun term-command-hook (string) |
| 3355 | (cond ((equal string "") |
| 3356 | t) |
| 3357 | ((= (aref string 0) ?\032) |
| 3358 | ;; gdb (when invoked with -fullname) prints: |
| 3359 | ;; \032\032FULLFILENAME:LINENUMBER:CHARPOS:BEG_OR_MIDDLE:PC\n |
| 3360 | (let* ((first-colon (string-match ":" string 1)) |
| 3361 | (second-colon |
| 3362 | (string-match ":" string (1+ first-colon))) |
| 3363 | (filename (substring string 1 first-colon)) |
| 3364 | (fileline (string-to-number |
| 3365 | (substring string (1+ first-colon) second-colon)))) |
| 3366 | (setq term-pending-frame (cons filename fileline)))) |
| 3367 | ((= (aref string 0) ?/) |
| 3368 | (cd (substring string 1))) |
| 3369 | ;; Allowing the inferior to call functions in Emacs is |
| 3370 | ;; probably too big a security hole. |
| 3371 | ;; ((= (aref string 0) ?!) |
| 3372 | ;; (eval (car (read-from-string string 1)))) |
| 3373 | (t)));; Otherwise ignore it |
| 3374 | |
| 3375 | ;; Make sure the file named TRUE-FILE is in a buffer that appears on the screen |
| 3376 | ;; and that its line LINE is visible. |
| 3377 | ;; Put the overlay-arrow on the line LINE in that buffer. |
| 3378 | ;; This is mainly used by gdb. |
| 3379 | |
| 3380 | (defun term-display-line (true-file line) |
| 3381 | (term-display-buffer-line (find-file-noselect true-file) line)) |
| 3382 | |
| 3383 | (defun term-display-buffer-line (buffer line) |
| 3384 | (let* ((window (display-buffer buffer t)) |
| 3385 | (pos)) |
| 3386 | (save-excursion |
| 3387 | (set-buffer buffer) |
| 3388 | (save-restriction |
| 3389 | (widen) |
| 3390 | (goto-line line) |
| 3391 | (setq pos (point)) |
| 3392 | (setq overlay-arrow-string "=>") |
| 3393 | (or overlay-arrow-position |
| 3394 | (setq overlay-arrow-position (make-marker))) |
| 3395 | (set-marker overlay-arrow-position (point) (current-buffer))) |
| 3396 | (cond ((or (< pos (point-min)) (> pos (point-max))) |
| 3397 | (widen) |
| 3398 | (goto-char pos)))) |
| 3399 | (set-window-point window overlay-arrow-position))) |
| 3400 | |
| 3401 | ;;; The buffer-local marker term-home-marker defines the "home position" |
| 3402 | ;;; (in terms of cursor motion). However, we move the term-home-marker |
| 3403 | ;;; "down" as needed so that is no more that a window-full above (point-max). |
| 3404 | |
| 3405 | (defun term-goto-home () |
| 3406 | (term-handle-deferred-scroll) |
| 3407 | (goto-char term-home-marker) |
| 3408 | (setq term-current-row 0) |
| 3409 | (setq term-current-column (current-column)) |
| 3410 | (setq term-start-line-column term-current-column)) |
| 3411 | |
| 3412 | (defun term-goto (row col) |
| 3413 | (term-handle-deferred-scroll) |
| 3414 | (cond ((and term-current-row (>= row term-current-row)) |
| 3415 | ;; I assume this is a worthwhile optimization. |
| 3416 | (term-vertical-motion 0) |
| 3417 | (setq term-current-column term-start-line-column) |
| 3418 | (setq row (- row term-current-row))) |
| 3419 | (t |
| 3420 | (term-goto-home))) |
| 3421 | (term-down row) |
| 3422 | (term-move-columns col)) |
| 3423 | |
| 3424 | ; The page is full, so enter "pager" mode, and wait for input. |
| 3425 | |
| 3426 | (defun term-process-pager () |
| 3427 | (when (not term-pager-break-map) |
| 3428 | (let* ((map (make-keymap)) |
| 3429 | (i 0) tmp) |
| 3430 | ; (while (< i 128) |
| 3431 | ; (define-key map (make-string 1 i) 'term-send-raw) |
| 3432 | ; (setq i (1+ i))) |
| 3433 | (define-key map "\e" |
| 3434 | (lookup-key (current-global-map) "\e")) |
| 3435 | (define-key map "\C-x" |
| 3436 | (lookup-key (current-global-map) "\C-x")) |
| 3437 | (define-key map "\C-u" |
| 3438 | (lookup-key (current-global-map) "\C-u")) |
| 3439 | (define-key map " " 'term-pager-page) |
| 3440 | (define-key map "\r" 'term-pager-line) |
| 3441 | (define-key map "?" 'term-pager-help) |
| 3442 | (define-key map "h" 'term-pager-help) |
| 3443 | (define-key map "b" 'term-pager-back-page) |
| 3444 | (define-key map "\177" 'term-pager-back-line) |
| 3445 | (define-key map "q" 'term-pager-discard) |
| 3446 | (define-key map "D" 'term-pager-disable) |
| 3447 | (define-key map "<" 'term-pager-bob) |
| 3448 | (define-key map ">" 'term-pager-eob) |
| 3449 | |
| 3450 | ;; Add menu bar. |
| 3451 | (unless (featurep 'xemacs) |
| 3452 | (define-key map [menu-bar terminal] term-terminal-menu) |
| 3453 | (define-key map [menu-bar signals] term-signals-menu) |
| 3454 | (setq tmp (make-sparse-keymap "More pages?")) |
| 3455 | (define-key tmp [help] '("Help" . term-pager-help)) |
| 3456 | (define-key tmp [disable] |
| 3457 | '("Disable paging" . term-fake-pager-disable)) |
| 3458 | (define-key tmp [discard] |
| 3459 | '("Discard remaining output" . term-pager-discard)) |
| 3460 | (define-key tmp [eob] '("Goto to end" . term-pager-eob)) |
| 3461 | (define-key tmp [bob] '("Goto to beginning" . term-pager-bob)) |
| 3462 | (define-key tmp [line] '("1 line forwards" . term-pager-line)) |
| 3463 | (define-key tmp [bline] '("1 line backwards" . term-pager-back-line)) |
| 3464 | (define-key tmp [back] '("1 page backwards" . term-pager-back-page)) |
| 3465 | (define-key tmp [page] '("1 page forwards" . term-pager-page)) |
| 3466 | (define-key map [menu-bar page] (cons "More pages?" tmp)) |
| 3467 | ) |
| 3468 | |
| 3469 | (setq term-pager-break-map map))) |
| 3470 | ; (let ((process (get-buffer-process (current-buffer)))) |
| 3471 | ; (stop-process process)) |
| 3472 | (setq term-pager-old-local-map (current-local-map)) |
| 3473 | (use-local-map term-pager-break-map) |
| 3474 | (make-local-variable 'term-old-mode-line-format) |
| 3475 | (setq term-old-mode-line-format mode-line-format) |
| 3476 | (setq mode-line-format |
| 3477 | (list "-- **MORE** " |
| 3478 | mode-line-buffer-identification |
| 3479 | " [Type ? for help] " |
| 3480 | "%-")) |
| 3481 | (force-mode-line-update)) |
| 3482 | |
| 3483 | (defun term-pager-line (lines) |
| 3484 | (interactive "p") |
| 3485 | (let* ((moved (vertical-motion (1+ lines))) |
| 3486 | (deficit (- lines moved))) |
| 3487 | (when (> moved lines) |
| 3488 | (backward-char)) |
| 3489 | (cond ((<= deficit 0) ;; OK, had enough in the buffer for request. |
| 3490 | (recenter (1- term-height))) |
| 3491 | ((term-pager-continue deficit))))) |
| 3492 | |
| 3493 | (defun term-pager-page (arg) |
| 3494 | "Proceed past the **MORE** break, allowing the next page of output to appear" |
| 3495 | (interactive "p") |
| 3496 | (term-pager-line (* arg term-height))) |
| 3497 | |
| 3498 | ; Pager mode command to go to beginning of buffer |
| 3499 | (defun term-pager-bob () |
| 3500 | (interactive) |
| 3501 | (goto-char (point-min)) |
| 3502 | (when (= (vertical-motion term-height) term-height) |
| 3503 | (backward-char)) |
| 3504 | (recenter (1- term-height))) |
| 3505 | |
| 3506 | ; pager mode command to go to end of buffer |
| 3507 | (defun term-pager-eob () |
| 3508 | (interactive) |
| 3509 | (goto-char term-home-marker) |
| 3510 | (recenter 0) |
| 3511 | (goto-char (process-mark (get-buffer-process (current-buffer))))) |
| 3512 | |
| 3513 | (defun term-pager-back-line (lines) |
| 3514 | (interactive "p") |
| 3515 | (vertical-motion (- 1 lines)) |
| 3516 | (if (not (bobp)) |
| 3517 | (backward-char) |
| 3518 | (beep) |
| 3519 | ;; Move cursor to end of window. |
| 3520 | (vertical-motion term-height) |
| 3521 | (backward-char)) |
| 3522 | (recenter (1- term-height))) |
| 3523 | |
| 3524 | (defun term-pager-back-page (arg) |
| 3525 | (interactive "p") |
| 3526 | (term-pager-back-line (* arg term-height))) |
| 3527 | |
| 3528 | (defun term-pager-discard () |
| 3529 | (interactive) |
| 3530 | (setq term-terminal-parameter "") |
| 3531 | (interrupt-process nil t) |
| 3532 | (term-pager-continue term-height)) |
| 3533 | |
| 3534 | ; Disable pager processing. |
| 3535 | ; Only callable while in pager mode. (Contrast term-disable-pager.) |
| 3536 | (defun term-pager-disable () |
| 3537 | (interactive) |
| 3538 | (if (term-handling-pager) |
| 3539 | (term-pager-continue nil) |
| 3540 | (setq term-pager-count nil)) |
| 3541 | (term-update-mode-line)) |
| 3542 | |
| 3543 | ; Enable pager processing. |
| 3544 | (defun term-pager-enable () |
| 3545 | (interactive) |
| 3546 | (or (term-pager-enabled) |
| 3547 | (setq term-pager-count 0)) ;; Or maybe set to (term-current-row) ?? |
| 3548 | (term-update-mode-line)) |
| 3549 | |
| 3550 | (defun term-pager-toggle () |
| 3551 | (interactive) |
| 3552 | (if (term-pager-enabled) (term-pager-disable) (term-pager-enable))) |
| 3553 | |
| 3554 | (unless (featurep 'xemacs) |
| 3555 | (defalias 'term-fake-pager-enable 'term-pager-toggle) |
| 3556 | (defalias 'term-fake-pager-disable 'term-pager-toggle) |
| 3557 | (put 'term-char-mode 'menu-enable '(term-in-line-mode)) |
| 3558 | (put 'term-line-mode 'menu-enable '(term-in-char-mode)) |
| 3559 | (put 'term-fake-pager-enable 'menu-enable '(not term-pager-count)) |
| 3560 | (put 'term-fake-pager-disable 'menu-enable 'term-pager-count)) |
| 3561 | |
| 3562 | (defun term-pager-help () |
| 3563 | "Provide help on commands available in a terminal-emulator **MORE** break" |
| 3564 | (interactive) |
| 3565 | (message "Terminal-emulator pager break help...") |
| 3566 | (sit-for 0) |
| 3567 | (with-electric-help |
| 3568 | (function (lambda () |
| 3569 | (princ (substitute-command-keys |
| 3570 | "\\<term-pager-break-map>\ |
| 3571 | Terminal-emulator MORE break.\n\ |
| 3572 | Type one of the following keys:\n\n\ |
| 3573 | \\[term-pager-page]\t\tMove forward one page.\n\ |
| 3574 | \\[term-pager-line]\t\tMove forward one line.\n\ |
| 3575 | \\[universal-argument] N \\[term-pager-page]\tMove N pages forward.\n\ |
| 3576 | \\[universal-argument] N \\[term-pager-line]\tMove N lines forward.\n\ |
| 3577 | \\[universal-argument] N \\[term-pager-back-line]\tMove N lines back.\n\ |
| 3578 | \\[universal-argument] N \\[term-pager-back-page]\t\tMove N pages back.\n\ |
| 3579 | \\[term-pager-bob]\t\tMove to the beginning of the buffer.\n\ |
| 3580 | \\[term-pager-eob]\t\tMove to the end of the buffer.\n\ |
| 3581 | \\[term-pager-discard]\t\tKill pending output and kill process.\n\ |
| 3582 | \\[term-pager-disable]\t\tDisable PAGER handling.\n\n\ |
| 3583 | \\{term-pager-break-map}\n\ |
| 3584 | Any other key is passed through to the program |
| 3585 | running under the terminal emulator and disables pager processing until |
| 3586 | all pending output has been dealt with.")) |
| 3587 | nil)))) |
| 3588 | |
| 3589 | (defun term-pager-continue (new-count) |
| 3590 | (let ((process (get-buffer-process (current-buffer)))) |
| 3591 | (use-local-map term-pager-old-local-map) |
| 3592 | (setq term-pager-old-local-map nil) |
| 3593 | (setq mode-line-format term-old-mode-line-format) |
| 3594 | (force-mode-line-update) |
| 3595 | (setq term-pager-count new-count) |
| 3596 | (set-process-filter process term-pager-old-filter) |
| 3597 | (funcall term-pager-old-filter process "") |
| 3598 | (continue-process process))) |
| 3599 | |
| 3600 | ;; Make sure there are DOWN blank lines below the current one. |
| 3601 | ;; Return 0 if we're unable (because of PAGER handling), else return DOWN. |
| 3602 | |
| 3603 | (defun term-handle-scroll (down) |
| 3604 | (let ((scroll-needed |
| 3605 | (- (+ (term-current-row) down) |
| 3606 | (if (< down 0) term-scroll-start term-scroll-end)))) |
| 3607 | (when (or (and (< down 0) (< scroll-needed 0)) |
| 3608 | (and (> down 0) (> scroll-needed 0))) |
| 3609 | (let ((save-point (copy-marker (point))) (save-top)) |
| 3610 | (goto-char term-home-marker) |
| 3611 | (cond (term-scroll-with-delete |
| 3612 | (if (< down 0) |
| 3613 | (progn |
| 3614 | ;; Delete scroll-needed lines at term-scroll-end, |
| 3615 | ;; then insert scroll-needed lines. |
| 3616 | (term-vertical-motion term-scroll-end) |
| 3617 | (end-of-line) |
| 3618 | (setq save-top (point)) |
| 3619 | (term-vertical-motion scroll-needed) |
| 3620 | (end-of-line) |
| 3621 | (delete-region save-top (point)) |
| 3622 | (goto-char save-point) |
| 3623 | (setq down (- scroll-needed down)) |
| 3624 | (term-vertical-motion down)) |
| 3625 | ;; Delete scroll-needed lines at term-scroll-start. |
| 3626 | (term-vertical-motion term-scroll-start) |
| 3627 | (setq save-top (point)) |
| 3628 | (term-vertical-motion scroll-needed) |
| 3629 | (delete-region save-top (point)) |
| 3630 | (goto-char save-point) |
| 3631 | (term-vertical-motion down) |
| 3632 | (term-adjust-current-row-cache (- scroll-needed))) |
| 3633 | (setq term-current-column nil) |
| 3634 | (term-insert-char ?\n (abs scroll-needed))) |
| 3635 | ((and (numberp term-pager-count) |
| 3636 | (< (setq term-pager-count (- term-pager-count down)) |
| 3637 | 0)) |
| 3638 | (setq down 0) |
| 3639 | (term-process-pager)) |
| 3640 | (t |
| 3641 | (term-adjust-current-row-cache (- scroll-needed)) |
| 3642 | (term-vertical-motion scroll-needed) |
| 3643 | (set-marker term-home-marker (point)))) |
| 3644 | (goto-char save-point) |
| 3645 | (set-marker save-point nil)))) |
| 3646 | down) |
| 3647 | |
| 3648 | (defun term-down (down &optional check-for-scroll) |
| 3649 | "Move down DOWN screen lines vertically." |
| 3650 | (let ((start-column (term-horizontal-column))) |
| 3651 | (when (and check-for-scroll (or term-scroll-with-delete term-pager-count)) |
| 3652 | (setq down (term-handle-scroll down))) |
| 3653 | (unless (and (= term-current-row 0) (< down 0)) |
| 3654 | (term-adjust-current-row-cache down) |
| 3655 | (when (or (/= (point) (point-max)) (< down 0)) |
| 3656 | (setq down (- down (term-vertical-motion down))))) |
| 3657 | (cond ((>= down 0) |
| 3658 | ;; Extend buffer with extra blank lines if needed. |
| 3659 | (term-insert-char ?\n down) |
| 3660 | (setq term-current-column 0) |
| 3661 | (setq term-start-line-column 0)) |
| 3662 | (t |
| 3663 | (when (= term-current-row 0) |
| 3664 | ;; Insert lines if at the beginning. |
| 3665 | (save-excursion (term-insert-char ?\n (- down))) |
| 3666 | (save-excursion |
| 3667 | (let (p) |
| 3668 | ;; Delete lines from the end. |
| 3669 | (forward-line term-height) |
| 3670 | (setq p (point)) |
| 3671 | (forward-line (- down)) |
| 3672 | (delete-region p (point))))) |
| 3673 | (setq term-current-column 0) |
| 3674 | (setq term-start-line-column (current-column)))) |
| 3675 | (when start-column |
| 3676 | (term-move-columns start-column)))) |
| 3677 | |
| 3678 | ;; Assuming point is at the beginning of a screen line, |
| 3679 | ;; if the line above point wraps around, add a ?\n to undo the wrapping. |
| 3680 | ;; FIXME: Probably should be called more than it is. |
| 3681 | (defun term-unwrap-line () |
| 3682 | (when (not (bolp)) (insert-before-markers ?\n))) |
| 3683 | |
| 3684 | (defun term-erase-in-line (kind) |
| 3685 | (when (= kind 1) ;; erase left of point |
| 3686 | (let ((cols (term-horizontal-column)) (saved-point (point))) |
| 3687 | (term-vertical-motion 0) |
| 3688 | (delete-region (point) saved-point) |
| 3689 | (term-insert-char ? cols))) |
| 3690 | (when (not (eq kind 1)) ;; erase right of point |
| 3691 | (let ((saved-point (point)) |
| 3692 | (wrapped (and (zerop (term-horizontal-column)) |
| 3693 | (not (zerop (term-current-column)))))) |
| 3694 | (term-vertical-motion 1) |
| 3695 | (delete-region saved-point (point)) |
| 3696 | ;; wrapped is true if we're at the beginning of screen line, |
| 3697 | ;; but not a buffer line. If we delete the current screen line |
| 3698 | ;; that will make the previous line no longer wrap, and (because |
| 3699 | ;; of the way Emacs display works) point will be at the end of |
| 3700 | ;; the previous screen line rather then the beginning of the |
| 3701 | ;; current one. To avoid that, we make sure that current line |
| 3702 | ;; contain a space, to force the previous line to continue to wrap. |
| 3703 | ;; We could do this always, but it seems preferable to not add the |
| 3704 | ;; extra space when wrapped is false. |
| 3705 | (when wrapped |
| 3706 | (insert ? )) |
| 3707 | (insert ?\n) |
| 3708 | (put-text-property saved-point (point) 'face 'default) |
| 3709 | (goto-char saved-point)))) |
| 3710 | |
| 3711 | (defun term-erase-in-display (kind) |
| 3712 | "Erases (that is blanks out) part of the window. |
| 3713 | If KIND is 0, erase from (point) to (point-max); |
| 3714 | if KIND is 1, erase from home to point; else erase from home to point-max. |
| 3715 | Should only be called when point is at the start of a screen line." |
| 3716 | (term-handle-deferred-scroll) |
| 3717 | (cond ((eq term-terminal-parameter 0) |
| 3718 | (delete-region (point) (point-max)) |
| 3719 | (term-unwrap-line)) |
| 3720 | ((let ((row (term-current-row)) |
| 3721 | (col (term-horizontal-column)) |
| 3722 | (start-region term-home-marker) |
| 3723 | (end-region (if (eq kind 1) (point) (point-max)))) |
| 3724 | (delete-region start-region end-region) |
| 3725 | (term-unwrap-line) |
| 3726 | (when (eq kind 1) |
| 3727 | (term-insert-char ?\n row)) |
| 3728 | (setq term-current-column nil) |
| 3729 | (setq term-current-row nil) |
| 3730 | (term-goto row col))))) |
| 3731 | |
| 3732 | (defun term-delete-chars (count) |
| 3733 | (let ((save-point (point))) |
| 3734 | (term-vertical-motion 1) |
| 3735 | (term-unwrap-line) |
| 3736 | (goto-char save-point) |
| 3737 | (move-to-column (+ (term-current-column) count) t) |
| 3738 | (delete-region save-point (point)))) |
| 3739 | |
| 3740 | ;;; Insert COUNT spaces after point, but do not change any of |
| 3741 | ;;; following screen lines. Hence we may have to delete characters |
| 3742 | ;;; at the end of this screen line to make room. |
| 3743 | |
| 3744 | (defun term-insert-spaces (count) |
| 3745 | (let ((save-point (point)) (save-eol) (pnt-at-eol)) |
| 3746 | (term-vertical-motion 1) |
| 3747 | (when (bolp) |
| 3748 | (backward-char)) |
| 3749 | (setq save-eol (point)) |
| 3750 | (save-excursion |
| 3751 | (end-of-line) |
| 3752 | (setq pnt-at-eol (point))) |
| 3753 | (move-to-column (+ (term-start-line-column) (- term-width count)) t) |
| 3754 | ;; If move-to-column extends the current line it will use the face |
| 3755 | ;; from the last character on the line, set the face for the chars |
| 3756 | ;; to default. |
| 3757 | (when (>= (point) pnt-at-eol) |
| 3758 | (put-text-property pnt-at-eol (point) 'face 'default)) |
| 3759 | (when (> save-eol (point)) |
| 3760 | (delete-region (point) save-eol)) |
| 3761 | (goto-char save-point) |
| 3762 | (term-insert-char ? count) |
| 3763 | (goto-char save-point))) |
| 3764 | |
| 3765 | (defun term-delete-lines (lines) |
| 3766 | (let ((start (point)) |
| 3767 | (save-current-column term-current-column) |
| 3768 | (save-start-line-column term-start-line-column) |
| 3769 | (save-current-row (term-current-row))) |
| 3770 | ;; The number of inserted lines shouldn't exceed the scroll region end. |
| 3771 | ;; The `term-scroll-end' line is part of the scrolling region, so |
| 3772 | ;; we need to go one line past it in order to ensure correct |
| 3773 | ;; scrolling. |
| 3774 | (when (> (+ save-current-row lines) (1+ term-scroll-end)) |
| 3775 | (setq lines (- lines (- (+ save-current-row lines) (1+ term-scroll-end))))) |
| 3776 | (term-down lines) |
| 3777 | (delete-region start (point)) |
| 3778 | (term-down (- (1+ term-scroll-end) save-current-row lines)) |
| 3779 | (term-insert-char ?\n lines) |
| 3780 | (setq term-current-column save-current-column) |
| 3781 | (setq term-start-line-column save-start-line-column) |
| 3782 | (setq term-current-row save-current-row) |
| 3783 | (goto-char start))) |
| 3784 | |
| 3785 | (defun term-insert-lines (lines) |
| 3786 | (let ((start (point)) |
| 3787 | (start-deleted) |
| 3788 | (save-current-column term-current-column) |
| 3789 | (save-start-line-column term-start-line-column) |
| 3790 | (save-current-row (term-current-row))) |
| 3791 | ;; Inserting lines should take into account the scroll region. |
| 3792 | ;; The `term-scroll-end' line is part of the scrolling region, so |
| 3793 | ;; we need to go one line past it in order to ensure correct |
| 3794 | ;; scrolling. |
| 3795 | (if (< save-current-row term-scroll-start) |
| 3796 | ;; If point is before scroll start, |
| 3797 | (progn |
| 3798 | (setq lines (- lines (- term-scroll-start save-current-row))) |
| 3799 | (term-down (- term-scroll-start save-current-row)) |
| 3800 | (setq start (point))) |
| 3801 | ;; The number of inserted lines shouldn't exceed the scroll region end. |
| 3802 | (when (> (+ save-current-row lines) (1+ term-scroll-end)) |
| 3803 | (setq lines (- lines (- (+ save-current-row lines)(1+ term-scroll-end))))) |
| 3804 | (term-down (- (1+ term-scroll-end) save-current-row lines))) |
| 3805 | (setq start-deleted (point)) |
| 3806 | (term-down lines) |
| 3807 | (delete-region start-deleted (point)) |
| 3808 | (goto-char start) |
| 3809 | (setq term-current-column save-current-column) |
| 3810 | (setq term-start-line-column save-start-line-column) |
| 3811 | (setq term-current-row save-current-row) |
| 3812 | (term-insert-char ?\n lines) |
| 3813 | (goto-char start))) |
| 3814 | \f |
| 3815 | (defun term-start-output-log (name) |
| 3816 | "Record raw inferior process output in a buffer." |
| 3817 | (interactive (list (if term-log-buffer |
| 3818 | nil |
| 3819 | (read-buffer "Record output in buffer: " |
| 3820 | (format "%s output-log" |
| 3821 | (buffer-name (current-buffer))) |
| 3822 | nil)))) |
| 3823 | (if (or (null name) (equal name "")) |
| 3824 | (progn (setq term-log-buffer nil) |
| 3825 | (message "Output logging off.")) |
| 3826 | (if (get-buffer name) |
| 3827 | nil |
| 3828 | (save-excursion |
| 3829 | (set-buffer (get-buffer-create name)) |
| 3830 | (fundamental-mode) |
| 3831 | (buffer-disable-undo (current-buffer)) |
| 3832 | (erase-buffer))) |
| 3833 | (setq term-log-buffer (get-buffer name)) |
| 3834 | (message "Recording terminal emulator output into buffer \"%s\"" |
| 3835 | (buffer-name term-log-buffer)))) |
| 3836 | |
| 3837 | (defun term-stop-output-log () |
| 3838 | "Discontinue raw inferior process logging." |
| 3839 | (interactive) |
| 3840 | (term-start-output-log nil)) |
| 3841 | |
| 3842 | (defun term-show-maximum-output () |
| 3843 | "Put the end of the buffer at the bottom of the window." |
| 3844 | (interactive) |
| 3845 | (goto-char (point-max)) |
| 3846 | (recenter -1)) |
| 3847 | \f |
| 3848 | ;;; Do the user's customisation... |
| 3849 | |
| 3850 | (defvar term-load-hook nil |
| 3851 | "This hook is run when term is loaded in. |
| 3852 | This is a good place to put keybindings.") |
| 3853 | |
| 3854 | (run-hooks 'term-load-hook) |
| 3855 | |
| 3856 | \f |
| 3857 | ;;; Filename/command/history completion in a buffer |
| 3858 | ;;; =========================================================================== |
| 3859 | ;;; Useful completion functions, courtesy of the Ergo group. |
| 3860 | |
| 3861 | ;;; Six commands: |
| 3862 | ;;; term-dynamic-complete Complete or expand command, filename, |
| 3863 | ;;; history at point. |
| 3864 | ;;; term-dynamic-complete-filename Complete filename at point. |
| 3865 | ;;; term-dynamic-list-filename-completions List completions in help buffer. |
| 3866 | ;;; term-replace-by-expanded-filename Expand and complete filename at point; |
| 3867 | ;;; replace with expanded/completed name. |
| 3868 | ;;; term-dynamic-simple-complete Complete stub given candidates. |
| 3869 | |
| 3870 | ;;; These are not installed in the term-mode keymap. But they are |
| 3871 | ;;; available for people who want them. Shell-mode installs them: |
| 3872 | ;;; (define-key shell-mode-map "\t" 'term-dynamic-complete) |
| 3873 | ;;; (define-key shell-mode-map "\M-?" |
| 3874 | ;;; 'term-dynamic-list-filename-completions))) |
| 3875 | ;;; |
| 3876 | ;;; Commands like this are fine things to put in load hooks if you |
| 3877 | ;;; want them present in specific modes. |
| 3878 | |
| 3879 | (defvar term-completion-autolist nil |
| 3880 | "*If non-nil, automatically list possibilities on partial completion. |
| 3881 | This mirrors the optional behavior of tcsh.") |
| 3882 | |
| 3883 | (defvar term-completion-addsuffix t |
| 3884 | "*If non-nil, add a `/' to completed directories, ` ' to file names. |
| 3885 | If a cons pair, it should be of the form (DIRSUFFIX . FILESUFFIX) where |
| 3886 | DIRSUFFIX and FILESUFFIX are strings added on unambiguous or exact |
| 3887 | completion. This mirrors the optional behavior of tcsh.") |
| 3888 | |
| 3889 | (defvar term-completion-recexact nil |
| 3890 | "*If non-nil, use shortest completion if characters cannot be added. |
| 3891 | This mirrors the optional behavior of tcsh. |
| 3892 | |
| 3893 | A non-nil value is useful if `term-completion-autolist' is non-nil too.") |
| 3894 | |
| 3895 | (defvar term-completion-fignore nil |
| 3896 | "*List of suffixes to be disregarded during file completion. |
| 3897 | This mirrors the optional behavior of bash and tcsh. |
| 3898 | |
| 3899 | Note that this applies to `term-dynamic-complete-filename' only.") |
| 3900 | |
| 3901 | (defvar term-file-name-prefix "" |
| 3902 | "Prefix prepended to absolute file names taken from process input. |
| 3903 | This is used by term's and shell's completion functions, and by shell's |
| 3904 | directory tracking functions.") |
| 3905 | |
| 3906 | |
| 3907 | (defun term-directory (directory) |
| 3908 | ;; Return expanded DIRECTORY, with `term-file-name-prefix' if absolute. |
| 3909 | (expand-file-name (if (file-name-absolute-p directory) |
| 3910 | (concat term-file-name-prefix directory) |
| 3911 | directory))) |
| 3912 | |
| 3913 | |
| 3914 | (defun term-word (word-chars) |
| 3915 | "Return the word of WORD-CHARS at point, or nil if none is found. |
| 3916 | Word constituents are considered to be those in WORD-CHARS, which is like the |
| 3917 | inside of a \"[...]\" (see `skip-chars-forward')." |
| 3918 | (save-excursion |
| 3919 | (let ((limit (point)) |
| 3920 | (word (concat "[" word-chars "]")) |
| 3921 | (non-word (concat "[^" word-chars "]"))) |
| 3922 | (when (re-search-backward non-word nil 'move) |
| 3923 | (forward-char 1)) |
| 3924 | ;; Anchor the search forwards. |
| 3925 | (if (or (eolp) (looking-at non-word)) |
| 3926 | nil |
| 3927 | (re-search-forward (concat word "+") limit) |
| 3928 | (buffer-substring (match-beginning 0) (match-end 0)))))) |
| 3929 | |
| 3930 | |
| 3931 | (defun term-match-partial-filename () |
| 3932 | "Return the filename at point, or nil if none is found. |
| 3933 | Environment variables are substituted. See `term-word'." |
| 3934 | (let ((filename (term-word "~/A-Za-z0-9+@:_.$#,={}-"))) |
| 3935 | (and filename (substitute-in-file-name filename)))) |
| 3936 | |
| 3937 | |
| 3938 | (defun term-dynamic-complete () |
| 3939 | "Dynamically perform completion at point. |
| 3940 | Calls the functions in `term-dynamic-complete-functions' to perform |
| 3941 | completion until a function returns non-nil, at which point completion is |
| 3942 | assumed to have occurred." |
| 3943 | (interactive) |
| 3944 | (let ((functions term-dynamic-complete-functions)) |
| 3945 | (while (and functions (null (funcall (car functions)))) |
| 3946 | (setq functions (cdr functions))))) |
| 3947 | |
| 3948 | |
| 3949 | (defun term-dynamic-complete-filename () |
| 3950 | "Dynamically complete the filename at point. |
| 3951 | Completes if after a filename. See `term-match-partial-filename' and |
| 3952 | `term-dynamic-complete-as-filename'. |
| 3953 | This function is similar to `term-replace-by-expanded-filename', except that |
| 3954 | it won't change parts of the filename already entered in the buffer; it just |
| 3955 | adds completion characters to the end of the filename. A completions listing |
| 3956 | may be shown in a help buffer if completion is ambiguous. |
| 3957 | |
| 3958 | Completion is dependent on the value of `term-completion-addsuffix', |
| 3959 | `term-completion-recexact' and `term-completion-fignore', and the timing of |
| 3960 | completions listing is dependent on the value of `term-completion-autolist'. |
| 3961 | |
| 3962 | Returns t if successful." |
| 3963 | (interactive) |
| 3964 | (when (term-match-partial-filename) |
| 3965 | (prog2 (or (eq (selected-window) (minibuffer-window)) |
| 3966 | (message "Completing file name...")) |
| 3967 | (term-dynamic-complete-as-filename)))) |
| 3968 | |
| 3969 | (defun term-dynamic-complete-as-filename () |
| 3970 | "Dynamically complete at point as a filename. |
| 3971 | See `term-dynamic-complete-filename'. Returns t if successful." |
| 3972 | (let* ((completion-ignore-case nil) |
| 3973 | (completion-ignored-extensions term-completion-fignore) |
| 3974 | (success t) |
| 3975 | (dirsuffix (cond ((not term-completion-addsuffix) "") |
| 3976 | ((not (consp term-completion-addsuffix)) "/") |
| 3977 | (t (car term-completion-addsuffix)))) |
| 3978 | (filesuffix (cond ((not term-completion-addsuffix) "") |
| 3979 | ((not (consp term-completion-addsuffix)) " ") |
| 3980 | (t (cdr term-completion-addsuffix)))) |
| 3981 | (filename (or (term-match-partial-filename) "")) |
| 3982 | (pathdir (file-name-directory filename)) |
| 3983 | (pathnondir (file-name-nondirectory filename)) |
| 3984 | (directory (if pathdir (term-directory pathdir) default-directory)) |
| 3985 | (completion (file-name-completion pathnondir directory)) |
| 3986 | (mini-flag (eq (selected-window) (minibuffer-window)))) |
| 3987 | (cond ((null completion) |
| 3988 | (message "No completions of %s" filename) |
| 3989 | (setq success nil)) |
| 3990 | ((eq completion t) ; Means already completed "file". |
| 3991 | (when term-completion-addsuffix (insert " ")) |
| 3992 | (or mini-flag (message "Sole completion"))) |
| 3993 | ((string-equal completion "") ; Means completion on "directory/". |
| 3994 | (term-dynamic-list-filename-completions)) |
| 3995 | (t ; Completion string returned. |
| 3996 | (let ((file (concat (file-name-as-directory directory) completion))) |
| 3997 | (insert (substring (directory-file-name completion) |
| 3998 | (length pathnondir))) |
| 3999 | (cond ((symbolp (file-name-completion completion directory)) |
| 4000 | ;; We inserted a unique completion. |
| 4001 | (insert (if (file-directory-p file) dirsuffix filesuffix)) |
| 4002 | (or mini-flag (message "Completed"))) |
| 4003 | ((and term-completion-recexact term-completion-addsuffix |
| 4004 | (string-equal pathnondir completion) |
| 4005 | (file-exists-p file)) |
| 4006 | ;; It's not unique, but user wants shortest match. |
| 4007 | (insert (if (file-directory-p file) dirsuffix filesuffix)) |
| 4008 | (or mini-flag (message "Completed shortest"))) |
| 4009 | ((or term-completion-autolist |
| 4010 | (string-equal pathnondir completion)) |
| 4011 | ;; It's not unique, list possible completions. |
| 4012 | (term-dynamic-list-filename-completions)) |
| 4013 | (t |
| 4014 | (or mini-flag (message "Partially completed"))))))) |
| 4015 | success)) |
| 4016 | |
| 4017 | |
| 4018 | (defun term-replace-by-expanded-filename () |
| 4019 | "Dynamically expand and complete the filename at point. |
| 4020 | Replace the filename with an expanded, canonicalized and completed replacement. |
| 4021 | \"Expanded\" means environment variables (e.g., $HOME) and `~'s are replaced |
| 4022 | with the corresponding directories. \"Canonicalized\" means `..' and `.' are |
| 4023 | removed, and the filename is made absolute instead of relative. For expansion |
| 4024 | see `expand-file-name' and `substitute-in-file-name'. For completion see |
| 4025 | `term-dynamic-complete-filename'." |
| 4026 | (interactive) |
| 4027 | (replace-match (expand-file-name (term-match-partial-filename)) t t) |
| 4028 | (term-dynamic-complete-filename)) |
| 4029 | |
| 4030 | |
| 4031 | (defun term-dynamic-simple-complete (stub candidates) |
| 4032 | "Dynamically complete STUB from CANDIDATES list. |
| 4033 | This function inserts completion characters at point by completing STUB from |
| 4034 | the strings in CANDIDATES. A completions listing may be shown in a help buffer |
| 4035 | if completion is ambiguous. |
| 4036 | |
| 4037 | Returns nil if no completion was inserted. |
| 4038 | Returns `sole' if completed with the only completion match. |
| 4039 | Returns `shortest' if completed with the shortest of the completion matches. |
| 4040 | Returns `partial' if completed as far as possible with the completion matches. |
| 4041 | Returns `listed' if a completion listing was shown. |
| 4042 | |
| 4043 | See also `term-dynamic-complete-filename'." |
| 4044 | (let* ((completion-ignore-case nil) |
| 4045 | (candidates (mapcar (function (lambda (x) (list x))) candidates)) |
| 4046 | (completions (all-completions stub candidates))) |
| 4047 | (cond ((null completions) |
| 4048 | (message "No completions of %s" stub) |
| 4049 | nil) |
| 4050 | ((= 1 (length completions)) ; Gotcha! |
| 4051 | (let ((completion (car completions))) |
| 4052 | (if (string-equal completion stub) |
| 4053 | (message "Sole completion") |
| 4054 | (insert (substring completion (length stub))) |
| 4055 | (message "Completed")) |
| 4056 | (when term-completion-addsuffix (insert " ")) |
| 4057 | 'sole)) |
| 4058 | (t ; There's no unique completion. |
| 4059 | (let ((completion (try-completion stub candidates))) |
| 4060 | ;; Insert the longest substring. |
| 4061 | (insert (substring completion (length stub))) |
| 4062 | (cond ((and term-completion-recexact term-completion-addsuffix |
| 4063 | (string-equal stub completion) |
| 4064 | (member completion completions)) |
| 4065 | ;; It's not unique, but user wants shortest match. |
| 4066 | (insert " ") |
| 4067 | (message "Completed shortest") |
| 4068 | 'shortest) |
| 4069 | ((or term-completion-autolist |
| 4070 | (string-equal stub completion)) |
| 4071 | ;; It's not unique, list possible completions. |
| 4072 | (term-dynamic-list-completions completions) |
| 4073 | 'listed) |
| 4074 | (t |
| 4075 | (message "Partially completed") |
| 4076 | 'partial))))))) |
| 4077 | |
| 4078 | |
| 4079 | (defun term-dynamic-list-filename-completions () |
| 4080 | "List in help buffer possible completions of the filename at point." |
| 4081 | (interactive) |
| 4082 | (let* ((completion-ignore-case nil) |
| 4083 | (filename (or (term-match-partial-filename) "")) |
| 4084 | (pathdir (file-name-directory filename)) |
| 4085 | (pathnondir (file-name-nondirectory filename)) |
| 4086 | (directory (if pathdir (term-directory pathdir) default-directory)) |
| 4087 | (completions (file-name-all-completions pathnondir directory))) |
| 4088 | (if completions |
| 4089 | (term-dynamic-list-completions completions) |
| 4090 | (message "No completions of %s" filename)))) |
| 4091 | |
| 4092 | |
| 4093 | (defun term-dynamic-list-completions (completions) |
| 4094 | "List in help buffer sorted COMPLETIONS. |
| 4095 | Typing SPC flushes the help buffer." |
| 4096 | (let ((conf (current-window-configuration))) |
| 4097 | (with-output-to-temp-buffer "*Completions*" |
| 4098 | (display-completion-list (sort completions 'string-lessp))) |
| 4099 | (message "Hit space to flush") |
| 4100 | (let (key first) |
| 4101 | (if (save-excursion |
| 4102 | (set-buffer (get-buffer "*Completions*")) |
| 4103 | (setq key (read-key-sequence nil) |
| 4104 | first (aref key 0)) |
| 4105 | (and (consp first) |
| 4106 | (eq (window-buffer (posn-window (event-start first))) |
| 4107 | (get-buffer "*Completions*")) |
| 4108 | (eq (key-binding key) 'mouse-choose-completion))) |
| 4109 | ;; If the user does mouse-choose-completion with the mouse, |
| 4110 | ;; execute the command, then delete the completion window. |
| 4111 | (progn |
| 4112 | (mouse-choose-completion first) |
| 4113 | (set-window-configuration conf)) |
| 4114 | (if (eq first ?\s) |
| 4115 | (set-window-configuration conf) |
| 4116 | (setq unread-command-events (listify-key-sequence key))))))) |
| 4117 | |
| 4118 | ;;; I need a make-term that doesn't surround with *s -mm |
| 4119 | (defun term-ansi-make-term (name program &optional startfile &rest switches) |
| 4120 | "Make a term process NAME in a buffer, running PROGRAM. |
| 4121 | The name of the buffer is NAME. |
| 4122 | If there is already a running process in that buffer, it is not restarted. |
| 4123 | Optional third arg STARTFILE is the name of a file to send the contents of to |
| 4124 | the process. Any more args are arguments to PROGRAM." |
| 4125 | (let ((buffer (get-buffer-create name ))) |
| 4126 | ;; If no process, or nuked process, crank up a new one and put buffer in |
| 4127 | ;; term mode. Otherwise, leave buffer and existing process alone. |
| 4128 | (cond ((not (term-check-proc buffer)) |
| 4129 | (save-excursion |
| 4130 | (set-buffer buffer) |
| 4131 | (term-mode)) ; Install local vars, mode, keymap, ... |
| 4132 | (term-exec buffer name program startfile switches))) |
| 4133 | buffer)) |
| 4134 | |
| 4135 | (defvar term-ansi-buffer-name nil) |
| 4136 | (defvar term-ansi-default-program nil) |
| 4137 | (defvar term-ansi-buffer-base-name nil) |
| 4138 | |
| 4139 | ;;;###autoload |
| 4140 | (defun ansi-term (program &optional new-buffer-name) |
| 4141 | "Start a terminal-emulator in a new buffer." |
| 4142 | (interactive (list (read-from-minibuffer "Run program: " |
| 4143 | (or explicit-shell-file-name |
| 4144 | (getenv "ESHELL") |
| 4145 | (getenv "SHELL") |
| 4146 | "/bin/sh")))) |
| 4147 | |
| 4148 | ;; Pick the name of the new buffer. |
| 4149 | (setq term-ansi-buffer-name |
| 4150 | (if new-buffer-name |
| 4151 | new-buffer-name |
| 4152 | (if term-ansi-buffer-base-name |
| 4153 | (if (eq term-ansi-buffer-base-name t) |
| 4154 | (file-name-nondirectory program) |
| 4155 | term-ansi-buffer-base-name) |
| 4156 | "ansi-term"))) |
| 4157 | |
| 4158 | (setq term-ansi-buffer-name (concat "*" term-ansi-buffer-name "*")) |
| 4159 | |
| 4160 | ;; In order to have more than one term active at a time |
| 4161 | ;; I'd like to have the term names have the *term-ansi-term<?>* form, |
| 4162 | ;; for now they have the *term-ansi-term*<?> form but we'll see... |
| 4163 | |
| 4164 | (setq term-ansi-buffer-name (generate-new-buffer-name term-ansi-buffer-name)) |
| 4165 | (setq term-ansi-buffer-name (term-ansi-make-term term-ansi-buffer-name program)) |
| 4166 | |
| 4167 | (set-buffer term-ansi-buffer-name) |
| 4168 | (term-mode) |
| 4169 | (term-char-mode) |
| 4170 | |
| 4171 | ;; I wanna have find-file on C-x C-f -mm |
| 4172 | ;; your mileage may definitely vary, maybe it's better to put this in your |
| 4173 | ;; .emacs ... |
| 4174 | |
| 4175 | (term-set-escape-char ?\C-x) |
| 4176 | |
| 4177 | (switch-to-buffer term-ansi-buffer-name)) |
| 4178 | |
| 4179 | \f |
| 4180 | ;;; Converting process modes to use term mode |
| 4181 | ;;; =========================================================================== |
| 4182 | ;;; Renaming variables |
| 4183 | ;;; Most of the work is renaming variables and functions. These are the common |
| 4184 | ;;; ones: |
| 4185 | ;;; Local variables: |
| 4186 | ;;; last-input-start term-last-input-start |
| 4187 | ;;; last-input-end term-last-input-end |
| 4188 | ;;; shell-prompt-pattern term-prompt-regexp |
| 4189 | ;;; shell-set-directory-error-hook <no equivalent> |
| 4190 | ;;; Miscellaneous: |
| 4191 | ;;; shell-set-directory <unnecessary> |
| 4192 | ;;; shell-mode-map term-mode-map |
| 4193 | ;;; Commands: |
| 4194 | ;;; shell-send-input term-send-input |
| 4195 | ;;; shell-send-eof term-delchar-or-maybe-eof |
| 4196 | ;;; kill-shell-input term-kill-input |
| 4197 | ;;; interrupt-shell-subjob term-interrupt-subjob |
| 4198 | ;;; stop-shell-subjob term-stop-subjob |
| 4199 | ;;; quit-shell-subjob term-quit-subjob |
| 4200 | ;;; kill-shell-subjob term-kill-subjob |
| 4201 | ;;; kill-output-from-shell term-kill-output |
| 4202 | ;;; show-output-from-shell term-show-output |
| 4203 | ;;; copy-last-shell-input Use term-previous-input/term-next-input |
| 4204 | ;;; |
| 4205 | ;;; SHELL-SET-DIRECTORY is gone, its functionality taken over by |
| 4206 | ;;; SHELL-DIRECTORY-TRACKER, the shell mode's term-input-filter-functions. |
| 4207 | ;;; Term mode does not provide functionality equivalent to |
| 4208 | ;;; shell-set-directory-error-hook; it is gone. |
| 4209 | ;;; |
| 4210 | ;;; term-last-input-start is provided for modes which want to munge |
| 4211 | ;;; the buffer after input is sent, perhaps because the inferior |
| 4212 | ;;; insists on echoing the input. The LAST-INPUT-START variable in |
| 4213 | ;;; the old shell package was used to implement a history mechanism, |
| 4214 | ;;; but you should think twice before using term-last-input-start |
| 4215 | ;;; for this; the input history ring often does the job better. |
| 4216 | ;;; |
| 4217 | ;;; If you are implementing some process-in-a-buffer mode, called foo-mode, do |
| 4218 | ;;; *not* create the term-mode local variables in your foo-mode function. |
| 4219 | ;;; This is not modular. Instead, call term-mode, and let *it* create the |
| 4220 | ;;; necessary term-specific local variables. Then create the |
| 4221 | ;;; foo-mode-specific local variables in foo-mode. Set the buffer's keymap to |
| 4222 | ;;; be foo-mode-map, and its mode to be foo-mode. Set the term-mode hooks |
| 4223 | ;;; (term-{prompt-regexp, input-filter, input-filter-functions, |
| 4224 | ;;; get-old-input) that need to be different from the defaults. Call |
| 4225 | ;;; foo-mode-hook, and you're done. Don't run the term-mode hook yourself; |
| 4226 | ;;; term-mode will take care of it. The following example, from shell.el, |
| 4227 | ;;; is typical: |
| 4228 | ;;; |
| 4229 | ;;; (defvar shell-mode-map '()) |
| 4230 | ;;; (cond ((not shell-mode-map) |
| 4231 | ;;; (setq shell-mode-map (copy-keymap term-mode-map)) |
| 4232 | ;;; (define-key shell-mode-map "\C-c\C-f" 'shell-forward-command) |
| 4233 | ;;; (define-key shell-mode-map "\C-c\C-b" 'shell-backward-command) |
| 4234 | ;;; (define-key shell-mode-map "\t" 'term-dynamic-complete) |
| 4235 | ;;; (define-key shell-mode-map "\M-?" |
| 4236 | ;;; 'term-dynamic-list-filename-completions))) |
| 4237 | ;;; |
| 4238 | ;;; (defun shell-mode () |
| 4239 | ;;; (interactive) |
| 4240 | ;;; (term-mode) |
| 4241 | ;;; (setq term-prompt-regexp shell-prompt-pattern) |
| 4242 | ;;; (setq major-mode 'shell-mode) |
| 4243 | ;;; (setq mode-name "Shell") |
| 4244 | ;;; (use-local-map shell-mode-map) |
| 4245 | ;;; (make-local-variable 'shell-directory-stack) |
| 4246 | ;;; (setq shell-directory-stack nil) |
| 4247 | ;;; (add-hook 'term-input-filter-functions 'shell-directory-tracker) |
| 4248 | ;;; (run-mode-hooks 'shell-mode-hook)) |
| 4249 | ;;; |
| 4250 | ;;; |
| 4251 | ;;; Completion for term-mode users |
| 4252 | ;;; |
| 4253 | ;;; For modes that use term-mode, term-dynamic-complete-functions is the |
| 4254 | ;;; hook to add completion functions to. Functions on this list should return |
| 4255 | ;;; non-nil if completion occurs (i.e., further completion should not occur). |
| 4256 | ;;; You could use term-dynamic-simple-complete to do the bulk of the |
| 4257 | ;;; completion job. |
| 4258 | \f |
| 4259 | (provide 'term) |
| 4260 | |
| 4261 | ;;; arch-tag: eee16bc8-2cd7-4147-9534-a5694752f716 |
| 4262 | ;;; term.el ends here |