home *** CD-ROM | disk | FTP | other *** search
Text File | 1993-01-18 | 52.5 KB | 1,272 lines |
-
- This message contains:
- 1. The standard anouncement header
- 2. A shar file for cmushell.el and tea.el
- (The entire package must be split -- otherwise notesfiles sites will not
- be able to handle it.)
- -------------------------------------------------------------------------------
- I am posting release two of the CMU process modes. These are a suite of
- gnu-emacs packages for running various command interpreters in buffers. They
- are all built on top of a single base mode (comint mode) that provides a
- consistent set of base functionality and keybindings.
-
- These modes have the following advantages:
- - Input history is kept in all modes, traversed with M-p and M-n, just
- like on LispM's and various fancy shells.
- - Filename completion and query is available in all modes.
- - Keybindings are cross-compatible among all modes.
- - Keybindings are compatible with Zwei and Hemlock.
- - Directory tracking is more robust in shell mode, and is *only* active in
- shell mode. (Try entering "cd /" to an inferior lisp in the old package:
- Lisp barfs, but the inferior lisp mode goes ahead and changes the
- buffer's directory.)
- - Non-echoed text entry (for entering passwords) is available in all modes.
- - Shell and inferior Lisp modes are backwards compatible with the standard
- gnu modes.
- - A full set of eval/compile-region/defun commands for the inferior Lisp,
- Scheme, and T modes.
- - New modes are easily created for new types of processes.
-
- The comint source has a section giving hints on converting older
- shell.el-based modes to use comint. I am told that the FSF will be
- using comint in the next release of gnumacs.
-
-
- The current set of modes are:
- background.el - run process in background, a la csh.
- cmulisp.el - simple lisp-in-a-buffer mode.
- cmuscheme.el - Scheme-in-a-buffer.
- cmushell.el - shell-in-a-buffer.
- cmutex.el - for TeX and LaTeX editing. Process support for
- running tex and latex, and printing and previewing
- .dvi files.
- comint.el - base mode. Used by everyone else.
- tea.el - T-in-a-buffer
-
- These packages can be used singly or together. They are careful not to
- interfere with other modes. Where possible, I have tried to make them
- compatible with other similar modes, in terms of keybindings, functionality,
- and variable names. Users familiar with Hemlock or the LispM's Zemacs will
- find the commands in cmulisp are bound to similar keys. Cmushell mode pays
- attention to the variables that customise shell.el. And so forth.
-
-
- Also separately available are:
- ilisp.el - Powerful tightly-integrated lisp-in-a-buffer mode.
- comint-ipc.el - Facility for piggy-backing emacs/subprocess
- communications on top of the user's pipe or pty
- communications. Unavoidably somewhat fragile, but
- nontheless useful. Used by ilisp.el.
- These files should be released imminently by Chris McConnell.
-
-
- MAJOR CHANGES FROM RELEASE ONE
- ===============================================================================
- - An extremely hairy Lisp/Scheme interface by Chris Mconnell (ccm@cs.cmu.edu).
- This package, ilisp.el, allows emacs to query the running process for useful
- state. Example commands are:
- lisp-arglist display the arguments taken by the current function.
- lisp-describe call the Common Lisp DESCRIBE function on the symbol
- the cursor is over, and put the results in a window.
- lisp-macroexpand macroexpand the current form and display the results.
- lisp-find-source Edit the file that defines the function the point is on.
- edit-next-caller Edit the next place this function is called.
-
- Ilisp.el allows tight integration with the lisp subprocess by
- sending messages to the subprocess "behind-the-scenes" over the
- user's connection. It does not assume a multithreaded lisp (as in
- Franz Inc.'s Allegro Common Lisp). (However, it could certainly be
- ported to take advantage of a multithreaded lisp, providing greater
- communications robustness without altering the interface functionality
- at all. Anyone interested in doing so should contact Chris.)
-
- Ilisp can be customised for most major dialects of Lisp and Scheme. This
- package is so massive it is being released in a separate post by Chris.
- I've included a dumb, simple inferior-lisp package in this release, as well
- (cmulisp.el).
-
- - A new package, background.el that allows you to run background processes in
- buffers. This was adapted for comint.el from Joe Keane's background.el.
-
- - A very hairy TeX and LaTeX package. This includes buffer validation,
- command entry commands, process interfaces to TeX, LaTeX, dvi printers and
- previewers. Pieces of this have been contributed by many people,
- notably Steve Anderson, Stephen Gildea, Dorab Patel, and Ashwin Ram.
-
- - Lots of tweaks to the basic comint package, many contributed by other
- people.
- + A new input history command comint-previous-similar-input (M-s) taken
- from some LispM interface. This is *quite* useful.
- + The other input history commands have been improved.
- + Filename completion has been improved.
- + By popular demand, return now jumps to the end of line before
- submitting input (this is settable, but defaults to the eol behavior).
- + New hooks for mode hackers.
- + comint-exec no longer dependent on etc/env program.
- + Process communication via pipes supported better.
- + Simple process-query facility available.
- + New procedures for sending input to processes that avoid hanging
- on large text blocks.
-
- - Tweaks to the other packages:
- + Improved directory tracking in cmushell.el. It now handles
- all forms of pushd and popd. New commands dirtrack-toggle and
- dirs toggle the directory tracking machinery off and on, and
- resync the mode's directory stack with the shell's.
- + cmushell and cmulisp modes now reside in separate files
- cmushell.el and cmulisp.el. Not only is this a good idea,
- it's apparently the way it'll be rel 19. N.B.: CMULISP USERS
- MUST CHANGE THEIR .EMACS AUTOLOAD'S ACCORDINGLY.
- + better support for multiple processes in cmulisp, cmuscheme
- and tea modes.
- + cmulisp has some simple query commands, for function and
- variable documentation, describing symbols, and getting
- function arglists. This is a simple facility; Chris McConnell's
- ilisp package is much more featureful. It was based on some code
- contributed by Doug Roberts.
- + cmulisp, cmuscheme, and tea now have a command (c-x c-e) to eval the
- last sexp. The keybinding is compatible with emacs lisp and Hemlock.
- + Filename defaults in Scheme and Lisp modes will use the string
- the cursor is over, if it's an existing filename. This is a
- debatable decision. Feedback appreciated.
-
- GENERAL NOTES
- ===============================================================================
- Directory tracking:
- The new directory tracking code will handle
- pushd [+n | <dir>]
- popd [+n]
- cd [<dir>]
- The emacs command M-x dirs will stuff a "dirs" at the process, wait for
- a line of output, parse it up, and reset the buffer's directory
- stack accordingly. The emacs command M-x dirtrack-toggle will toggle
- the directory tracking machinery on and off. This is useful, for example,
- when you are running ftp, and don't want ftp's "cd" command to throw
- emacs off.
-
- The new code was based on source contributed by Vince Broman, Mike Coffin,
- Jeff Peck, and Barry Warsaw. Its structure should allow zealous shell hackers
- to extend it pretty easily.
-
- The commands that directory tracking looks for are customisable.
- If you define aliases for cd or pushd or popd, you can set the right
- emacs variables and win.
-
- Note that in general, complex directory tracking is a losing game.
- You can't win. If you have a programmable shell, an excellent hack
- is to program the directory-changing commands to type code sequences
- at the terminal, and write a process filter to watch for these sequences.
- A sequence like "ESC D <length> <directory>" where <directory> is <length>
- characters long would do fine. (Using a <length> parameter instead of
- string delimeters prevents emacs from gobbling up unbounded amounts of shell
- output in the event the terminating delimiter gets lost.)
-
-
- Multiple process buffers:
- Many people suggest ways to run multiple shell buffers. This does not require
- extra features. Suppose you want two shell buffers. Simply make a shell
- buffer with M-x cmushell, and then rename it with M-x rename-buffer. Make the
- next shell with M-x cmushell, and now you've got two. Use M-x cmushell to get
- to the newest one, and C-x b <bufname> to get to the other.
-
- Multiple Lisp and Scheme buffers work similarly. Commands that send text
- from a source buffer to the process buffer will always send to the
- buffer with the "official" name unless you explicitly override this
- (see variable lisp/scheme/tea-buffer). I don't see any real good ways to
- extend this. You could associate each source buffer with some process
- buffer, but this gets messy. I've tried to keep it simple. If you find
- yourself switching between multiple process buffers a lot, consider using
- ilisp.el. Or write a little code to soup up cmulisp.el.
-
-
- Documentation:
- There is no manual or info node for any of this stuff. I am not going to
- write one. Feel free to write one if you like, and submit it to me or the FSF.
- It would be a good thing.
-
- The .el files are copiously documented, however. If you want to use any of
- these modes, I strongly suggest that you read the source files. Really. Do
- it. They contain many useful sections of comments. Skip anything you don't
- understand; read the easy parts. You may find some useful commands you didn't
- know about. The top of each file contains a clearly-marked, friendly
- "suggestions for your .emacs file" section that will show you exactly how to
- get set up using the package. Also, pay attention to the DEFVAR'd variables.
- These are typically the means by which you can customise the package for your
- local environment.
-
- The usual on-line documentation on modes, variables and commands
- is also available via c-h m, c-h v, and c-h d.
-
-
- ===============================================================================
- A shar file for the source files follows. This code is available under the
- terms of the Gnu Copyright agreement: you can do whatever you like with it as
- long as you don't charge for it or hold me responsible for anything it does.
- Please send any comments, improvements, bug reports, fixes or suggestions to
- olin.shivers@cs.cmu.edu.
-
- I would like to thank all the people who took the time to send me the code
- that went into this second release.
- -Olin
- June 12, 1990
- ===============================================================================
- #
- # type sh /afs/cs.cmu.edu/user/shivers/lib/emacs/sh2 to unpack this archive.
- #
- echo extracting cmushell.el...
- cat >cmushell.el <<'!E!O!F!'
- ;;; -*-Emacs-Lisp-*- General command interpreter in a window stuff
- ;;; Copyright Olin Shivers (1988).
- ;;; Please imagine a long, tedious, legalistic 5-page gnu-style copyright
- ;;; notice appearing here to the effect that you may use this code any
- ;;; way you like, as long as you don't charge money for it, remove this
- ;;; notice, or hold me liable for its results.
-
- ;;; The changelog is at the end of file.
-
- ;;; Please send me bug reports, bug fixes, and extensions, so that I can
- ;;; merge them into the master source.
- ;;; - Olin Shivers (shivers@cs.cmu.edu)
-
- ;;; This file defines a a shell-in-a-buffer package (cmushell mode) built on
- ;;; top of comint mode. Cmushell mode is similar to, and intended to replace,
- ;;; its counterpart in the standard gnu emacs release. This replacement is
- ;;; more featureful, robust, and uniform than the released version.
-
- ;;; Since this mode is built on top of the general command-interpreter-in-
- ;;; a-buffer mode (comint mode), it shares a common base functionality,
- ;;; and a common set of bindings, with all modes derived from comint mode.
- ;;; This makes these modes easier to use.
-
- ;;; For documentation on the functionality provided by comint mode, and
- ;;; the hooks available for customising it, see the file comint.el.
- ;;; For further information on cmushell mode, see the comments below.
-
- ;;; Needs fixin:
- ;;; When sending text from a source file to a subprocess, the process-mark can
- ;;; move off the window, so you can lose sight of the process interactions.
- ;;; Maybe I should ensure the process mark is in the window when I send
- ;;; text to the process? Switch selectable?
-
- (require 'comint)
- (provide 'cmushell)
-
- ;; YOUR .EMACS FILE
- ;;=============================================================================
- ;; Some suggestions for your .emacs file.
- ;;
- ;; ; If cmushell lives in some non-standard directory, you must tell emacs
- ;; ; where to get it. This may or may not be necessary.
- ;; (setq load-path (cons (expand-file-name "~jones/lib/emacs") load-path))
- ;;
- ;; ; Autoload cmushell from file cmushell.el
- ;; (autoload 'cmushell "cmushell"
- ;; "Run an inferior shell process."
- ;; t)
- ;;
- ;; ; Define C-c C-t to run my favorite command in cmushell mode:
- ;; (setq cmushell-load-hook
- ;; '((lambda ()
- ;; (define-key cmushell-mode-map "\C-c\C-t" 'favorite-cmd))))
-
-
- ;;; Brief Command Documentation:
- ;;;============================================================================
- ;;; Comint Mode Commands: (common to cmushell and all comint-derived modes)
- ;;;
- ;;; m-p comint-previous-input Cycle backwards in input history
- ;;; m-n comint-next-input Cycle forwards
- ;;; c-c r comint-previous-input-matching Search backwards in input history
- ;;; return comint-send-input
- ;;; c-a comint-bol Beginning of line; skip prompt.
- ;;; c-d comint-delchar-or-maybe-eof Delete char unless at end of buff.
- ;;; c-c c-u comint-kill-input ^u
- ;;; c-c c-w backward-kill-word ^w
- ;;; c-c c-c comint-interrupt-subjob ^c
- ;;; c-c c-z comint-stop-subjob ^z
- ;;; c-c c-\ comint-quit-subjob ^\
- ;;; c-c c-o comint-kill-output Delete last batch of process output
- ;;; c-c c-r comint-show-output Show last batch of process output
- ;;; send-invisible Read line w/o echo & send to proc
- ;;; comint-continue-subjob Useful if you accidentally suspend
- ;;; top-level job.
- ;;; comint-mode-hook is the comint mode hook.
-
- ;;; Shell Mode Commands:
- ;;; cmushell Fires up the shell process.
- ;;; m-tab comint-dynamic-complete Complete a partial file name
- ;;; m-? comint-dynamic-list-completions List completions in help buffer
- ;;; dirs Resync the buffer's dir stack.
- ;;; dirtrack-toggle Turn dir tracking on/off.
- ;;;
- ;;; The cmushell mode hook is cmushell-mode-hook
- ;;; The cmushell-load-hook is run after this file is loaded.
- ;;; comint-prompt-regexp is initialised to shell-prompt-pattern, for backwards
- ;;; compatibility.
-
- ;;; Read the rest of this file for more information.
-
- ;;; SHELL.EL COMPATIBILITY
- ;;;============================================================================
- ;;; In brief: this package should have no trouble coexisting with shell.el.
- ;;;
- ;;; Most customising variables -- e.g., explicit-shell-file-name -- are the
- ;;; same, so the users shouldn't have much trouble. Hooks have different
- ;;; names, however, so you can customise shell mode differently from cmushell
- ;;; mode. You basically just have to remember to type M-x cmushell instead of
- ;;; M-x shell.
- ;;;
- ;;; It would be nice if this file was completely plug-compatible with the old
- ;;; shell package -- if you could just name this file shell.el, and have it
- ;;; transparently replace the old one. But you can't. Several other packages
- ;;; (tex-mode, background, dbx, gdb, kermit, monkey, prolog, telnet) are also
- ;;; clients of shell mode. These packages assume detailed knowledge of shell
- ;;; mode internals in ways that are incompatible with cmushell mode (mostly
- ;;; because of cmushell mode's greater functionality). So, unless we are
- ;;; willing to port all of these packages, we can't have this file be a
- ;;; complete replacement for shell.el -- that is, we can't name this file
- ;;; shell.el, and its main entry point (shell), because dbx.el will break
- ;;; when it loads it in and tries to use it.
- ;;;
- ;;; There are two ways to fix this. One: rewrite these other modes to use the
- ;;; new package. This is a win, but can't be assumed. The other, backwards
- ;;; compatible route, is to make this package non-conflict with shell.el, so
- ;;; both files can be loaded in at the same time. And *that* is why some
- ;;; functions and variables have different names: (cmushell),
- ;;; cmushell-mode-map, that sort of thing. All the names have been carefully
- ;;; chosen so that shell.el and cmushell.el won't tromp on each other.
-
- ;;; Customisation and Buffer Variables
- ;;; ===========================================================================
- ;;;
-
- ;In loaddefs.el now.
- ;(defconst shell-prompt-pattern
- ; "^[^#$%>]*[#$%>] *"
- ; "*Regexp used by Newline command to match subshell prompts.
- ;;; Change the doc string for shell-prompt-pattern:
- (put 'shell-prompt-pattern 'variable-documentation
- "Regexp to match prompts in the inferior shell.
- Defaults to \"^[^#$%>]*[#$%>] *\", which works pretty well.
- This variable is used to initialise comint-prompt-regexp in the
- shell buffer.
-
- This is a fine thing to set in your .emacs file.")
-
- (defvar shell-popd-regexp "popd"
- "*Regexp to match subshell commands equivalent to popd.")
-
- (defvar shell-pushd-regexp "pushd"
- "*Regexp to match subshell commands equivalent to pushd.")
-
- (defvar shell-cd-regexp "cd"
- "*Regexp to match subshell commands equivalent to cd.")
-
- (defvar explicit-shell-file-name nil
- "*If non-nil, is file name to use for explicitly requested inferior shell.")
-
- (defvar explicit-csh-args
- (if (eq system-type 'hpux)
- ;; -T persuades HP's csh not to think it is smarter
- ;; than us about what terminal modes to use.
- '("-i" "-T")
- '("-i"))
- "*Args passed to inferior shell by M-x cmushell, if the shell is csh.
- Value is a list of strings, which may be nil.")
-
- ;;; All the above vars aren't prefixed "cmushell-" to make them
- ;;; backwards compatible w/shell.el and old .emacs files.
-
- (defvar cmushell-dirstack nil
- "List of directories saved by pushd in this buffer's shell.")
-
- (defvar cmushell-dirstack-query "dirs"
- "Command used by shell-resync-dirlist to query shell.")
-
- (defvar cmushell-mode-map '())
- (cond ((not cmushell-mode-map)
- (setq cmushell-mode-map (full-copy-sparse-keymap comint-mode-map))
- (define-key cmushell-mode-map "\M-\t" 'comint-dynamic-complete)
- (define-key cmushell-mode-map "\M-?" 'comint-dynamic-list-completions)))
-
- (defvar cmushell-mode-hook '()
- "*Hook for customising cmushell mode")
-
-
- ;;; Basic Procedures
- ;;; ===========================================================================
- ;;;
-
- (defun cmushell-mode ()
- "Major mode for interacting with an inferior shell.
- Return after the end of the process' output sends the text from the
- end of process to the end of the current line.
- Return before end of process output copies rest of line to end (skipping
- the prompt) and sends it.
- M-x send-invisible reads a line of text without echoing it, and sends it to
- the shell.
-
- If you accidentally suspend your process, use \\[comint-continue-subjob]
- to continue it.
-
- cd, pushd and popd commands given to the shell are watched by Emacs to keep
- this buffer's default directory the same as the shell's working directory.
- M-x dirs queries the shell and resyncs Emacs' idea of what the current
- directory stack is.
- M-x dirtrack-toggle turns directory tracking on and off.
-
- \\{cmushell-mode-map}
- Customisation: Entry to this mode runs the hooks on comint-mode-hook and
- cmushell-mode-hook (in that order).
-
- Variables shell-cd-regexp, shell-pushd-regexp and shell-popd-regexp are used
- to match their respective commands."
- (interactive)
- (comint-mode)
- (setq comint-prompt-regexp shell-prompt-pattern)
- (setq major-mode 'cmushell-mode)
- (setq mode-name "CMU shell")
- (use-local-map cmushell-mode-map)
- (make-local-variable 'cmushell-dirstack)
- (setq cmushell-dirstack nil)
- (make-local-variable 'cmushell-dirtrackp)
- (setq cmushell-dirtrackp t)
- (setq comint-input-sentinel 'cmushell-directory-tracker)
- (run-hooks 'cmushell-mode-hook))
-
-
- (defun cmushell ()
- "Run an inferior shell, with I/O through buffer *cmushell*.
- If buffer exists but shell process is not running, make new shell.
- If buffer exists and shell process is running,
- just switch to buffer *cmushell*.
- Program used comes from variable explicit-shell-file-name,
- or (if that is nil) from the ESHELL environment variable,
- or else from SHELL if there is no ESHELL.
- If a file ~/.emacs_SHELLNAME exists, it is given as initial input
- (Note that this may lose due to a timing error if the shell
- discards input when it starts up.)
- The buffer is put in cmushell-mode, giving commands for sending input
- and controlling the subjobs of the shell. See cmushell-mode.
- See also variable shell-prompt-pattern.
-
- The shell file name (sans directories) is used to make a symbol name
- such as `explicit-csh-arguments'. If that symbol is a variable,
- its value is used as a list of arguments when invoking the shell.
- Otherwise, one argument `-i' is passed to the shell.
-
- \(Type \\[describe-mode] in the shell buffer for a list of commands.)"
- (interactive)
- (cond ((not (comint-check-proc "*cmushell*"))
- (let* ((prog (or explicit-shell-file-name
- (getenv "ESHELL")
- (getenv "SHELL")
- "/bin/sh"))
- (name (file-name-nondirectory prog))
- (startfile (concat "~/.emacs_" name))
- (xargs-name (intern-soft (concat "explicit-" name "-args"))))
- (set-buffer (apply 'make-comint "cmushell" prog
- (if (file-exists-p startfile) startfile)
- (if (and xargs-name (boundp xargs-name))
- (symbol-value xargs-name)
- '("-i"))))
- (cmushell-mode))))
- (switch-to-buffer "*cmushell*"))
-
-
- ;;; Directory tracking
- ;;; ===========================================================================
- ;;; This code provides the cmushell mode input sentinel
- ;;; CMUSHELL-DIRECTORY-TRACKER
- ;;; that tracks cd, pushd, and popd commands issued to the shell, and
- ;;; changes the current directory of the shell buffer accordingly.
- ;;;
- ;;; This is basically a fragile hack, although it's more accurate than
- ;;; the released version in shell.el. It has the following failings:
- ;;; 1. It doesn't know about the cdpath shell variable.
- ;;; 2. It only spots the first command in a command sequence. E.g., it will
- ;;; miss the cd in "ls; cd foo"
- ;;; 3. More generally, any complex command (like ";" sequencing) is going to
- ;;; throw it. Otherwise, you'd have to build an entire shell interpreter in
- ;;; emacs lisp. Failing that, there's no way to catch shell commands where
- ;;; cd's are buried inside conditional expressions, aliases, and so forth.
- ;;;
- ;;; The whole approach is a crock. Shell aliases mess it up. File sourcing
- ;;; messes it up. You run other processes under the shell; these each have
- ;;; separate working directories, and some have commands for manipulating
- ;;; their w.d.'s (e.g., the lcd command in ftp). Some of these programs have
- ;;; commands that do *not* effect the current w.d. at all, but look like they
- ;;; do (e.g., the cd command in ftp). In shells that allow you job
- ;;; control, you can switch between jobs, all having different w.d.'s. So
- ;;; simply saying %3 can shift your w.d..
- ;;;
- ;;; The solution is to relax, not stress out about it, and settle for
- ;;; a hack that works pretty well in typical circumstances. Remember
- ;;; that a half-assed solution is more in keeping with the spirit of Unix,
- ;;; anyway. Blech.
- ;;;
- ;;; One good hack not implemented here for users of programmable shells
- ;;; is to program up the shell w.d. manipulation commands to output
- ;;; a coded command sequence to the tty. Something like
- ;;; ESC | <cwd> |
- ;;; where <cwd> is the new current working directory. Then trash the
- ;;; directory tracking machinery currently used in this package, and
- ;;; replace it with a process filter that watches for and strips out
- ;;; these messages.
-
- ;;; REGEXP is a regular expression. STR is a string. START is a fixnum.
- ;;; Returns T if REGEXP matches STR where the match is anchored to start
- ;;; at position START in STR. Sort of like LOOKING-AT for strings.
- (defun cmushell-front-match (regexp str start)
- (eq start (string-match regexp str start)))
-
- (defun cmushell-directory-tracker (str)
- "Tracks cd, pushd and popd commands issued to the shell.
- This function is called on each input passed to the shell.
- It watches for cd, pushd and popd commands and sets the buffer's
- default directory to track these commands.
-
- You may toggle this tracking on and off with M-x dirtrack-toggle.
- If emacs gets confused, you can resync with the shell with M-x dirs.
-
- See variables shell-cd-regexp, shell-pushd-regexp, and shell-popd-regexp."
- (cond (cmushell-dirtrackp
- (string-match "^\\s *" str) ; skip whitespace
- (let ((bos (match-end 0))
- (x nil))
- (cond ((setq x (cmushell-match-cmd-w/optional-arg shell-popd-regexp
- str bos))
- (cmushell-process-popd x))
- ((setq x (cmushell-match-cmd-w/optional-arg shell-pushd-regexp
- str bos))
- (cmushell-process-pushd x))
- ((setq x (cmushell-match-cmd-w/optional-arg shell-cd-regexp
- str bos))
- (cmushell-process-cd x)))))))
-
-
- ;;; Try to match regexp CMD to string, anchored at position START.
- ;;; CMD may be followed by a single argument. If a match, then return
- ;;; the argument, if there is one, or the empty string if not. If
- ;;; no match, return nil.
-
- (defun cmushell-match-cmd-w/optional-arg (cmd str start)
- (and (cmushell-front-match cmd str start)
- (let ((eoc (match-end 0))) ; end of command
- (cond ((cmushell-front-match "\\s *\\(\;\\|$\\)" str eoc)
- "") ; no arg
- ((cmushell-front-match "\\s +\\([^ \t\;]+\\)\\s *\\(\;\\|$\\)"
- str eoc)
- (substring str (match-beginning 1) (match-end 1))) ; arg
- (t nil))))) ; something else.
- ;;; The first regexp is [optional whitespace, (";" or the end of string)].
- ;;; The second regexp is [whitespace, (an arg), optional whitespace,
- ;;; (";" or end of string)].
-
-
- ;;; popd [+n]
- (defun cmushell-process-popd (arg)
- (let ((num (if (zerop (length arg)) 0 ; no arg means +0
- (cmushell-extract-num arg))))
- (if (and num (< num (length cmushell-dirstack)))
- (if (= num 0) ; condition-case because the CD could lose.
- (condition-case nil (progn (cd (car cmushell-dirstack))
- (setq cmushell-dirstack
- (cdr cmushell-dirstack))
- (cmushell-dirstack-message))
- (error (message "Couldn't cd.")))
- (let* ((ds (cons nil cmushell-dirstack))
- (cell (nthcdr (- num 1) ds)))
- (rplacd cell (cdr (cdr cell)))
- (setq cmushell-dirstack (cdr ds))
- (cmushell-dirstack-message)))
- (message "Bad popd."))))
-
-
- ;;; cd [dir]
- (defun cmushell-process-cd (arg)
- (condition-case nil (progn (cd (if (zerop (length arg)) (getenv "HOME")
- arg))
- (cmushell-dirstack-message))
- (error (message "Couldn't cd."))))
-
-
- ;;; pushd [+n | dir]
- (defun cmushell-process-pushd (arg)
- (if (zerop (length arg))
- ;; no arg -- swap pwd and car of shell stack
- (condition-case nil (if cmushell-dirstack
- (let ((old default-directory))
- (cd (car cmushell-dirstack))
- (setq cmushell-dirstack
- (cons old (cdr cmushell-dirstack)))
- (cmushell-dirstack-message))
- (message "Directory stack empty."))
- (message "Couldn't cd."))
-
- (let ((num (cmushell-extract-num arg)))
- (if num ; pushd +n
- (if (> num (length cmushell-dirstack))
- (message "Directory stack not that deep.")
- (let* ((ds (cons default-directory cmushell-dirstack))
- (dslen (length ds))
- (front (nthcdr num ds))
- (back (reverse (nthcdr (- dslen num) (reverse ds))))
- (new-ds (append front back)))
- (condition-case nil
- (progn (cd (car new-ds))
- (setq cmushell-dirstack (cdr new-ds))
- (cmushell-dirstack-message))
- (error (message "Couldn't cd.")))))
-
- ;; pushd <dir>
- (let ((old-wd default-directory))
- (condition-case nil
- (progn (cd arg)
- (setq cmushell-dirstack
- (cons old-wd cmushell-dirstack))
- (cmushell-dirstack-message))
- (error (message "Couldn't cd."))))))))
-
- ;; If STR is of the form +n, for n>0, return n. Otherwise, nil.
- (defun cmushell-extract-num (str)
- (and (string-match "^\\+[1-9][0-9]*$" str)
- (string-to-int str)))
-
-
- (defun cmushell-dirtrack-toggle ()
- "Turn directory tracking on and off in a cmushell buffer."
- (interactive)
- (setq cmushell-dirtrackp (not cmushell-dirtrackp))
- (message "directory tracking %s."
- (if cmushell-dirtrackp "ON" "OFF")))
-
- ;;; For your typing convenience:
- (fset 'dirtrack-toggle 'cmushell-dirtrack-toggle)
-
-
- (defun cmushell-resync-dirs ()
- "Resync the buffer's idea of the current directory stack.
- This command queries the shell with the command bound to
- cmushell-dirstack-query (default \"dirs\"), reads the next
- line output and parses it to form the new directory stack.
- DON'T issue this command unless the buffer is at a shell prompt.
- Also, note that if some other subprocess decides to do output
- immediately after the query, its output will be taken as the
- new directory stack -- you lose. If this happens, just do the
- command again."
- (interactive)
- (let* ((proc (get-buffer-process (current-buffer)))
- (pmark (process-mark proc)))
- (goto-char pmark)
- (insert cmushell-dirstack-query) (insert "\n")
- (sit-for 0) ; force redisplay
- (comint-send-string proc cmushell-dirstack-query)
- (comint-send-string proc "\n")
- (set-marker pmark (point))
- (let ((pt (point))) ; wait for 1 line
- ;; This extra newline prevents the user's pending input from spoofing us.
- (insert "\n") (backward-char 1)
- (while (not (looking-at ".+\n"))
- (accept-process-output proc)
- (goto-char pt)))
- (goto-char pmark) (delete-char 1) ; remove the extra newline
- ;; That's the dirlist. grab it & parse it.
- (let* ((dl (buffer-substring (match-beginning 0) (- (match-end 0) 1)))
- (dl-len (length dl))
- (ds '()) ; new dir stack
- (i 0))
- (while (< i dl-len)
- ;; regexp = optional whitespace, (non-whitespace), optional whitespace
- (string-match "\\s *\\(\\S +\\)\\s *" dl i) ; pick off next dir
- (setq ds (cons (substring dl (match-beginning 1) (match-end 1))
- ds))
- (setq i (match-end 0)))
- (let ((ds (reverse ds)))
- (condition-case nil
- (progn (cd (car ds))
- (setq cmushell-dirstack (cdr ds))
- (cmushell-dirstack-message))
- (error (message "Couldn't cd.")))))))
-
- ;;; For your typing convenience:
- (fset 'dirs 'cmushell-resync-dirs)
-
-
- ;;; Show the current dirstack on the message line.
- ;;; Pretty up dirs a bit by changing "/usr/jqr/foo" to "~/foo".
- ;;; (This isn't necessary if the dirlisting is generated with a simple "dirs".)
- ;;; All the commands that mung the buffer's dirstack finish by calling
- ;;; this guy.
- (defun cmushell-dirstack-message ()
- (let ((msg "")
- (ds (cons default-directory cmushell-dirstack)))
- (while ds
- (let ((dir (car ds)))
- (if (string-match (format "^%s\\(/\\|$\\)" (getenv "HOME")) dir)
- (setq dir (concat "~/" (substring dir (match-end 0)))))
- (if (string-equal dir "~/") (setq dir "~"))
- (setq msg (concat msg dir " "))
- (setq ds (cdr ds))))
- (message msg)))
-
-
-
- ;;; Interfacing to client packages (and converting them)
- ;;;============================================================================
- ;;; Several gnu packages (tex-mode, background, dbx, gdb, kermit, prolog,
- ;;; telnet are some) use the shell package as clients. Most of them would
- ;;; be better off using the comint package directly, but they predate it.
- ;;; The catch is that most of these packages (dbx, gdb, prolog, telnet)
- ;;; assume total knowledge of all the local variables that shell mode
- ;;; functions depend on. So they (kill-all-local-variables), then create
- ;;; the few local variables that shell.el functions depend on. Alas,
- ;;; cmushell.el functions depend on a different set of vars (for example,
- ;;; the input history ring is a local variable in cmushell.el's shell mode,
- ;;; whereas there is no input history ring in shell.el's shell mode).
- ;;; So we have a situation where the greater functionality of cmushell.el
- ;;; is biting us -- you can't just replace shell will cmushell.
- ;;;
- ;;; Altering these packages to use comint mode directly should *greatly*
- ;;; improve their functionality, and is actually pretty easy. It's
- ;;; mostly a matter of renaming a few variable names. See comint.el for more.
- ;;; -Olin
-
-
-
- ;;; Do the user's customisation...
- ;;;===============================
- (defvar cmushell-load-hook nil
- "This hook is run when cmushell is loaded in.
- This is a good place to put keybindings.")
-
- (run-hooks 'cmushell-load-hook)
-
- ;;; Change Log
- ;;; ===========================================================================
- ;;; Olin 8/88
- ;;; Created.
- ;;;
- ;;; Olin 5/26/90
- ;;; - Split cmulisp and cmushell modes into separate files.
- ;;; Not only is this a good idea, it's apparently the way it'll be rel 19.
- ;;; - Souped up the directory tracking; it now can handle pushd, pushd +n,
- ;;; and popd +n.
- ;;; - Added cmushell-dirtrack-toggle command to toggle the directory
- ;;; tracking that cmushell tries to do. This is useful, for example,
- ;;; when you are running ftp -- it prevents the ftp "cd" command from
- ;;; spoofing the tracking machinery. This command is also named
- ;;; dirtrack-toggle, so you need only type M-x dirtrack to run it.
- ;;; - Added cmushell-resync-dirs command. This queries the shell
- ;;; for the current directory stack, and resets the buffer's stack
- ;;; accordingly. This command is also named dirs, so you need only type
- ;;; M-x dirs to run it.
- ;;; - Bits of the new directory tracking code were adapted from source
- ;;; contributed by Vince Broman, Jeff Peck, and Barry Warsaw.
- ;;; - See also the improvements made to comint.el at the same time.
- ;;; - Renamed several variables. Mostly this comprised changing "shell"
- ;;; to "cmushell" in the names. The only variables that are not prefixed
- ;;; with "cmushell-" are the ones that are common with shell.el:
- ;;; explicit-shell-file-name shell-prompt-pattern explicit-csh-args
- ;;; and shell-cd/popd/pushd-regexp
- ;;; The variables and functions that were changed to have "cmushell-"
- ;;; prefixes are:
- ;;; shell-directory-stack (v), shell-directory-tracker (f)
- ;;; This should not affect users, only elisp hackers. Hopefully
- ;;; one day shell.el will just go away, and we can drop all this
- ;;; "cmushell" bullshit.
- ;;; - Upgraded process sends to use comint-send-string instead of
- ;;; process-send-string.
- !E!O!F!
- #
- # type sh /afs/cs.cmu.edu/user/shivers/lib/emacs/sh2 to unpack this archive.
- #
- echo extracting tea.el...
- cat >tea.el <<'!E!O!F!'
- ;;; tea.el -- Teach emacs about T.
- ;;; Copyright Olin Shivers (1988)
- ;;; Please imagine a long, tedious, legalistic 5-page gnu-style copyright
- ;;; notice appearing here to the effect that you may use this code any
- ;;; way you like, as long as you don't charge money for it, remove this
- ;;; notice, or hold me liable for its results.
- ;;;
- ;;; 1. Major mode for editing T source: t-mode
- ;;; This is just a variant of scheme-mode, tweaked for T.
- ;;; 2. Major mode for running T in a buffer: run-tea
- ;;; This is a customisation of comint-mode.
- ;;;
- ;;; Written by Olin Shivers (olin.shivers@cs.cmu.edu). With bits and pieces
- ;;; lifted from scheme.el, shell.el, clisp.el, newclisp.el, cobol.el, et al..
- ;;; 8/88
- ;;; Please send me bug reports, bug fixes, and extensions, so that I can
- ;;; merge them into the master source.
- ;;;
- ;;; Change log at end of file.
-
-
- ;; YOUR .EMACS FILE
- ;;=============================================================================
- ;; Some suggestions for your .emacs file.
- ;;
- ;; ; If tea.el lives in some non-standard directory, you must tell emacs
- ;; ; where to get it. This may or may not be necessary.
- ;; (setq load-path (cons (expand-file-name "~jones/lib/emacs") load-path))
- ;;
- ;; ; Autoload run-tea and t-mode from file tea.el
- ;; (autoload 'run-tea "tea"
- ;; "Run an inferior T process."
- ;; t)
- ;;
- ;; (autoload 't-mode "tea"
- ;; "Major mode for editing T source. Just Scheme mode, tuned a bit."
- ;; t)
- ;;
- ;; ; Files ending in ".t" are T source, so put their buffers in t-mode.
- ;; (setq auto-mode-alist
- ;; (cons '("\\.t$" . t-mode)
- ;; auto-mode-alist))
- ;;
- ;; ; Define C-c C-t to run my favorite command in inferior T mode:
- ;; (setq tea-load-hook
- ;; '((lambda () (define-key inferior-t-mode-map "\C-c\C-t"
- ;; 'favorite-cmd))))
-
- ;; ETAGS
- ;;=============================================================================
- ;; A suggestion for modifying the etags program so that it knows about T.
- ;; You should modify the few lines that allow etags to conclude that
- ;; files that end with ".t" are lisp or scheme source code.
- ;; Find a line that looks like
- ;; /* .scm or .sm or .scheme implies scheme source code */
- ;; and add a
- ;; !strcmp (cp + 1, "t") ||
- ;; suffix check to the following clauses that check filename suffixes.
- ;; This is already done for some versions of etags. Have a look, or try it
- ;; & see.
-
- (setq scheme-mit-dialect nil) ; Give me a break.
- (require 'scheme)
- (require 'cmushell)
-
-
- ;;; T mode stuff
- ;;;============================================================================
-
- ;;; Note: T mode alters the scheme-mode syntax table and indentation
- ;;; hooks slightly. If you were using scheme-mode and t-mode simultaneously
- ;;; this might be a problem, except that the alterations are fairly
- ;;; innocuous.
-
- ;; This adds [] and {} as matching delimiters. So emacs will treat #[Char 0]
- ;; or #{Procedure 1 ADD} as an s-exp with a quote sign in front.
- (modify-syntax-entry ?[ "(]" scheme-mode-syntax-table)
- (modify-syntax-entry ?] ")[" scheme-mode-syntax-table)
- (modify-syntax-entry ?{ "(}" scheme-mode-syntax-table)
- (modify-syntax-entry ?} "){" scheme-mode-syntax-table)
-
- ;; Modify scheme-indent-hook for T.
- (put 'labels 'scheme-indent-hook 1)
- (put 'block 'scheme-indent-hook 0)
- (put 'block0 'scheme-indent-hook 0)
- (put 'object 'scheme-indent-hook 1)
- (put 'lset 'scheme-indent-hook 1)
- (put 'xcase 'scheme-indent-hook 1)
- (put 'select 'scheme-indent-hook 1)
- (put 'xselect 'scheme-indent-hook 1)
- (put 'iterate 'scheme-indent-hook 2)
- (put 'cond 'scheme-indent-hook 0)
- (put 'xcond 'scheme-indent-hook 0)
- (put 'catch 'scheme-indent-hook 1)
- (put 'bind 'scheme-indent-hook 1)
- (put 'define-operation 'scheme-indent-hook 1)
- (put 'operation 'scheme-indent-hook 1)
- (put 'object 'scheme-indent-hook 1)
- (put 'join 'scheme-indent-hook 0)
- (put 'destructure 'scheme-indent-hook 1)
- (put 'destructure* 'scheme-indent-hook 1)
- (put 'define-integrable 'scheme-indent-hook 1)
- (put 'define-constant 'scheme-indent-hook 1)
- (put 'define-syntax 'scheme-indent-hook 1)
- (put 'let-syntax 'scheme-indent-hook 1)
- (put 'define-local-syntax 'scheme-indent-hook 1)
- (put 'macro-expander 'scheme-indent-hook 1)
- (put 'with-open-streams 'scheme-indent-hook 1)
- (put 'with-open-ports 'scheme-indent-hook 1)
- (put 'with-input-from-string 'scheme-indent-hook 1)
- (put 'with-output-to-string 'scheme-indent-hook 1)
- (put 'with-output-width-string 'scheme-indent-hook 1)
- (put 'receive 'scheme-indent-hook 2)
- (put 'receive-values 'scheme-indent-hook 1)
-
- (defvar t-mode-hook nil
- "*Hook for customising T mode")
-
- (defvar t-mode-map (full-copy-sparse-keymap scheme-mode-map))
-
- (defun t-mode ()
- "Major mode for editing T code.
- This is Scheme mode, slightly tuned for T. Editing commands are similar
- to those of Lisp mode.
-
- In addition, if an inferior T process is running, some additional
- commands will be defined, for evaluating expressions and controlling
- the interpreter, and the state of the process will be displayed in the
- modeline of all T buffers. The names of commands that interact
- with the T process start with \"tea-\". For more information
- see the documentation for inferior-t-mode.
-
- Commands:
- Delete converts tabs to spaces as it moves back.
- Blank lines separate paragraphs. Semicolons start comments.
- \\{t-mode-map}
- Customisation: Entry to this mode runs the hooks on t-mode-hook"
- (interactive)
- (kill-all-local-variables)
- (use-local-map t-mode-map)
- (scheme-mode-variables)
- (setq major-mode 't-mode)
- (setq mode-name "T")
- (run-hooks 't-mode-hook))
-
-
- ;;; INFERIOR T MODE STUFF
- ;;;============================================================================
-
- (defvar inferior-t-mode-map nil)
- (cond ((not inferior-t-mode-map)
- (setq inferior-t-mode-map (full-copy-sparse-keymap comint-mode-map))
- (scheme-mode-commands inferior-t-mode-map)
- (define-key inferior-t-mode-map "\M-\C-x" 'tea-send-definition)
- (define-key inferior-t-mode-map "\C-x\C-e" 'tea-send-last-sexp)
- (define-key inferior-t-mode-map "\C-cl" 'tea-load-file)
- (define-key inferior-t-mode-map "\C-ck" 'tea-compile-file) ;"kompile"
- ))
-
- ;; Install the process communication commands in the scheme-mode keymap.
- (define-key t-mode-map "\M-\C-x" 'tea-send-definition) ; gnu convention
- (define-key t-mode-map "\C-x\C-e" 'tea-send-last-sexp) ; gnu convention
- (define-key t-mode-map "\C-ce" 'tea-send-definition)
- (define-key t-mode-map "\C-c\C-e" 'tea-send-definition-and-go)
- (define-key t-mode-map "\C-cr" 'tea-send-region)
- (define-key t-mode-map "\C-c\C-r" 'tea-send-region-and-go)
- (define-key t-mode-map "\C-cc" 'tea-compile-definition)
- (define-key t-mode-map "\C-c\C-c" 'tea-compile-definition-and-go)
- (define-key t-mode-map "\C-cz" 'switch-to-tea)
- (define-key t-mode-map "\C-cl" 'tea-load-file)
- (define-key t-mode-map "\C-ck" 'tea-compile-file)
-
- (defvar inferior-t-mode-hook nil
- "*Hook for customising inferior-T mode")
-
- (defun inferior-t-mode ()
- "Major mode for interacting with an inferior T process.
-
- The following commands are available:
- \\{inferior-t-mode-map}
-
- A T process can be fired up with M-x run-tea.
-
- Customisation: Entry to this mode runs the hooks on comint-mode-hook and
- inferior-t-mode-hook (in that order).
-
- You can send text to the inferior T process from other buffers containing
- T source.
- switch-to-tea switches the current buffer to the T process buffer.
- tea-send-definition sends the current definition to the T process.
- tea-compile-definition compiles the current definition.
- tea-send-region sends the current region to the T process.
- tea-compile-region compiles the current region.
-
- tea-send-definition-and-go, tea-compile-definition-and-go,
- tea-send-region-and-go, and tea-compile-region-and-go
- switch to the T process buffer after sending their text.
- For information on running multiple processes in multiple buffers, see
- documentation for variable tea-buffer.
-
- Commands:
- Return after the end of the process' output sends the text from the
- end of process to point.
- Return before the end of the process' output copies the sexp ending at point
- to the end of the process' output, and sends it.
- Delete converts tabs to spaces as it moves back.
- Tab indents for T; with argument, shifts rest
- of expression rigidly with the current line.
- C-M-q does Tab on each line starting within following expression.
- Paragraphs are separated only by blank lines. Semicolons start comments.
- If you accidentally suspend your process, use \\[comint-continue-subjob]
- to continue it."
- (interactive)
- (comint-mode)
- (setq comint-prompt-regexp "^>+ *") ; Customise in inferior-t-mode-hook
- (scheme-mode-variables)
-
- (setq major-mode 'inferior-t-mode)
- (setq mode-name "Inferior T")
- (setq mode-line-process '(": %s"))
- (use-local-map inferior-t-mode-map)
- (setq comint-input-filter 'tea-input-filter)
- (setq comint-input-sentinel 'ignore)
- (setq comint-get-old-input 'tea-get-old-input)
- (run-hooks 'inferior-t-mode-hook))
-
- (defun tea-input-filter (str)
- "Don't save anything matching tea-filter-regexp"
- (not (string-match tea-filter-regexp str)))
-
- (defvar tea-filter-regexp "\\`\\s *\\S ?\\S ?\\s *\\'"
- "*Input matching this regexp are not saved on the history list.
- Defaults to a regexp ignoring all inputs of 0, 1, or 2 letters.")
-
- (defun tea-get-old-input ()
- "Snarf the sexp ending at point"
- (save-excursion
- (let ((end (point)))
- (backward-sexp)
- (buffer-substring (point) end))))
-
- ;;; This will break if you have an argument with whitespace, as in
- ;;; string = "-ab +c -x 'you lose'".
- (defun tea-args-to-list (string)
- (let ((where (string-match "[ \t]" string)))
- (cond ((null where) (list string))
- ((not (= where 0))
- (cons (substring string 0 where)
- (tea-args-to-list (substring string (+ 1 where)
- (length string)))))
- (t (let ((pos (string-match "[^ \t]" string)))
- (if (null pos)
- nil
- (tea-args-to-list (substring string pos
- (length string)))))))))
-
- (defvar tea-program-name "t"
- "*Program invoked by the run-tea command")
-
- ;;; Obsolete
- (defun tea (&rest foo) (message "Use run-tea"))
-
- (defun run-tea (cmd)
- "Run an inferior T process, input and output via buffer *tea*.
- If there is a process already running in *tea*, just switch to that buffer.
- With argument, allows you to edit the command line (default is value
- of tea-program-name). Runs the hooks from inferior-t-mode-hook (after the
- comint-mode-hook is run).
- \(Type \\[describe-mode] in the process buffer for a list of commands.)"
-
- (interactive (list (if current-prefix-arg
- (read-string "Run T: " tea-program-name)
- tea-program-name)))
- (if (not (comint-check-proc "*tea*"))
- (let ((cmdlist (tea-args-to-list cmd)))
- (set-buffer (apply 'make-comint "tea" (car cmdlist)
- nil (cdr cmdlist)))
- (inferior-t-mode)))
- (setq tea-buffer "*tea*")
- (switch-to-buffer "*tea*"))
-
- (defun tea-send-region (start end)
- "Send the current region to the inferior T process"
- (interactive "r")
- (comint-send-region (tea-proc) start end)
- (comint-send-string (tea-proc) "\n"))
-
- (defun tea-send-definition ()
- "Send the current definition to the inferior T process."
- (interactive)
- (save-excursion
- (end-of-defun)
- (let ((end (point)))
- (beginning-of-defun)
- (tea-send-region (point) end))))
-
- (defun tea-send-last-sexp ()
- "Send the previous sexp to the inferior T process."
- (interactive)
- (tea-send-region (save-excursion (backward-sexp) (point)) (point)))
-
- (defun tea-compile-region (start end)
- "Compile the current region in the inferior T process.
- \(A BLOCK is wrapped around the region: (BLOCK <region>)"
- (interactive "r")
- (comint-send-string (tea-proc) "(orbit '(block ")
- (comint-send-region (tea-proc) start end)
- (comint-send-string (tea-proc) "))\n"))
-
- (defun tea-compile-definition ()
- "Compile the current definition in the inferior T process."
- (interactive)
- (save-excursion
- (end-of-defun)
- (let ((end (point)))
- (beginning-of-defun)
- (tea-compile-region (point) end))))
-
- (defun switch-to-tea (eob-p)
- "Switch to the T process buffer.
- With argument, positions cursor at end of buffer."
- (interactive "P")
- (if (get-buffer tea-buffer)
- (pop-to-buffer tea-buffer)
- (error "No current process buffer. See variable tea-buffer."))
- (cond (eob-p
- (push-mark)
- (goto-char (point-max)))))
-
- (defun tea-send-region-and-go (start end)
- "Send the current region to the inferior T process,
- and switch to the process buffer."
- (interactive "r")
- (tea-send-region start end)
- (switch-to-tea t))
-
- (defun tea-send-definition-and-go ()
- "Send the current definition to the inferior T process,
- and switch to the process buffer."
- (interactive)
- (tea-send-definition)
- (switch-to-tea t))
-
- (defun tea-compile-region-and-go (start end)
- "Compile the current region in the inferior T process,
- and switch to process buffer."
- (interactive "r")
- (tea-compile-region start end)
- (switch-to-tea t))
-
- (defun tea-compile-definition-and-go ()
- "Compile the current definition in the inferior T process,
- and switch to process buffer."
- (interactive)
- (tea-compile-definition)
- (switch-to-tea t))
-
- (defvar tea-source-modes '(t-mode)
- "*Used to determine if a buffer contains T source code.
- If it's loaded into a buffer that is in one of these major modes, it's
- considered a T source file by tea-load-file and tea-compile-file.
- Used by these commands to determine defaults.")
-
- (defvar tea-prev-l/c-dir/file nil
- "Caches the (directory . file) pair used in the last tea-load-file or
- tea-compile-file command. Used for determining the default in the next one.")
-
- (defun tea-load-file (file-name)
- "Load a T file into the inferior T process."
- (interactive (comint-get-source "Load T file: " tea-prev-l/c-dir/file
- tea-source-modes t)) ; T because LOAD needs
- ; an exact name.
- (comint-check-source file-name) ; Check to see if buffer needs saved.
- (setq tea-prev-l/c-dir/file (cons (file-name-directory file-name)
- (file-name-nondirectory file-name)))
- (comint-send-string (tea-proc) (concat "(load \""
- file-name
- "\"\)\n"))
- (switch-to-tea t))
-
- (defun tea-compile-file (file-name)
- "Compile a T file in the inferior T process."
- (interactive (comint-get-source "Compile T file: " tea-prev-l/c-dir/file
- tea-source-modes
- nil)) ; NIL because COMPILE doesn't
- ; need an exact name.
- (comint-check-source file-name) ; Check to see if buffer needs saved.
- (setq tea-prev-l/c-dir/file (cons (file-name-directory file-name)
- (file-name-nondirectory file-name)))
- (comint-send-string (tea-proc) (concat "(compile-file \""
- file-name
- "\"\)\n"))
- (switch-to-tea t))
-
-
- ;;; This helps when you run more than one T process at a time.
-
- ;;; If we're in some inferior T buffer, return its process,
- ;;; even if the buffer's been renamed. If we're elsewhere, assume
- ;;; the standard process named "tea".
- (defun tea-proc ()
- (let ((proc (get-buffer-process (current-buffer))))
- (if (and proc (eq major-mode 'inferior-t-mode)) proc
- (get-process "tea"))))
-
- (defvar tea-buffer nil "*The current T process buffer.
-
- MULTIPLE PROCESS SUPPORT
- ===========================================================================
- Tea.el supports, in a fairly simple fashion, running multiple T
- processes. To run multiple T processes, you start the first up with
- \\[run-tea]. It will be in a buffer named *tea*. Rename this buffer
- with \\[rename-buffer]. You may now start up a new process with another
- \\[run-tea]. It will be in a new buffer, named *tea*. You can
- switch between the different process buffers with \\[switch-to-buffer].
-
- Commands that send text from source buffers to T processes --
- like tea-send-definition or tea-compile-region -- have to choose a
- process to send to, when you have more than one T process around. This
- is determined by the global variable tea-buffer. Suppose you
- have three inferior T's running:
- Buffer Process
- foo tea
- bar tea<2>
- *tea* tea<3>
- If you do a \\[tea-send-definition-and-go] command on some T source code,
- what process do you send it to?
-
- - If you're in a process buffer (foo, bar, or *tea*),
- you send it to that process.
- - If you're in some other buffer (e.g., a source file), you
- send it to the process attached to buffer tea-buffer.
- This process selection is performed by function tea-proc.
-
- Whenever \\[run-tea] fires up a new process, it resets tea-buffer
- to be the new process's buffer. If you only run one process, this will
- do the right thing. If you run multiple processes, you can change
- tea-buffer to another process buffer with \\[set-variable].
-
- More sophisticated approaches are, of course, possible. If you find youself
- needing to switch back and forth between multiple processes frequently,
- you may wish to consider ilisp.el, a larger, more sophisticated package
- for running inferior Lisp and Scheme processes. The approach taken here is
- for a minimal, simple implementation. Feel free to extend it.")
-
- (defun tea-proc ()
- "Returns the current T process. See variable tea-buffer."
- (let ((proc (get-buffer-process (if (eq major-mode 'inferior-t-mode)
- (current-buffer)
- tea-buffer))))
- (or proc
- (error "No current process. See variable tea-buffer"))))
-
-
- ;;; Do the user's customisation...
-
- (defvar tea-load-hook nil
- "This hook is run when tea is loaded in.
- This is a good place to put keybindings.")
-
- (run-hooks 'tea-load-hook)
-
- ;;; CHANGE LOG
- ;;; ===========================================================================
- ;;; 8/88 Olin
- ;;; Created.
- ;;;
- ;;; 2/15/89 Olin
- ;;; Removed -emacs flag from process invocation. It's only useful for
- ;;; cscheme, and makes cscheme assume it's running under xscheme.el,
- ;;; which messes things up royally. A bug.
- ;;;
- ;;; 5/22/90 Olin
- ;;; Upgraded to use comint-send-string and comint-send-region.
- ;;; - run-tea now offers to let you edit the command line if
- ;;; you invoke it with a prefix-arg. M-x tea is redundant, and
- ;;; has been removed.
- ;;; - Explicit references to process "tea" have been replaced with
- ;;; (tea-proc). This allows better handling of multiple process bufs.
- ;;; - Added tea-send-last-sexp, bound to C-x C-e. A gnu convention.
- ;;; - Have not added process query facility a la cmulisp.el's lisp-show-arglist
- ;;; and friends, but interested hackers might find a useful application
- ;;; of this facility.
- !E!O!F!
-
-
-