;;; cmuscheme.el --- Scheme process in a buffer. Adapted from tea.el.
-
-;; Copyright (C) 1988 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 1994, 1997 Free Software Foundation, Inc.
;; Author: Olin Shivers <olin.shivers@cs.cmu.edu>
+;; Maintainer: FSF
;; Keywords: processes, lisp
;; This file is part of GNU Emacs.
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
;;; Commentary:
-;;; This is a customisation of comint-mode (see comint.el)
-;;;
-;;; 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.
-;;;
-;;; The changelog is at the end of this file.
-;;;
-;;; NOTE: MIT Cscheme, when invoked with the -emacs flag, has a special user
-;;; interface that communicates process state back to the superior emacs by
-;;; outputting special control sequences. The gnumacs package, xscheme.el, has
-;;; lots and lots of special purpose code to read these control sequences, and
-;;; so is very tightly integrated with the cscheme process. The cscheme
-;;; interrupt handler and debugger read single character commands in cbreak
-;;; mode; when this happens, xscheme.el switches to special keymaps that bind
-;;; the single letter command keys to emacs functions that directly send the
-;;; character to the scheme process. Cmuscheme mode does *not* provide this
-;;; functionality. If you are a cscheme user, you may prefer to use the
-;;; xscheme.el/cscheme -emacs interaction.
-;;;
-;;; Here's a summary of the pros and cons, as I see them.
-;;; xscheme: Tightly integrated with inferior cscheme process! A few commands
-;;; not in cmuscheme. But. Integration is a bit of a hack. Input
-;;; history only keeps the immediately prior input. Bizarre
-;;; keybindings.
-;;;
-;;; cmuscheme: Not tightly integrated with inferior cscheme process. But.
-;;; Carefully integrated functionality with the entire suite of
-;;; comint-derived CMU process modes. Keybindings reminiscent of
-;;; Zwei and Hemlock. Good input history. A few commands not in
-;;; xscheme.
-;;;
-;;; It's a tradeoff. Pay your money; take your choice. If you use a Scheme
-;;; that isn't Cscheme, of course, there isn't a choice. Xscheme.el is *very*
-;;; Cscheme-specific; you must use cmuscheme.el. Interested parties are
-;;; invited to port xscheme functionality on top of comint mode...
-
-;; YOUR .EMACS FILE
-;;=============================================================================
-;; Some suggestions for your .emacs file.
+;; This is a customisation of comint-mode (see comint.el)
;;
-;; ; If cmuscheme 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))
+;; 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
;;
-;; ; Autoload run-scheme from file cmuscheme.el
-;; (autoload 'run-scheme "cmuscheme"
-;; "Run an inferior Scheme process."
-;; t)
+;; Please send me bug reports, bug fixes, and extensions, so that I can
+;; merge them into the master source.
;;
-;; ; Files ending in ".scm" are Scheme source,
-;; ; so put their buffers in scheme-mode.
-;; (setq auto-mode-alist
-;; (cons '("\\.scm$" . scheme-mode)
-;; auto-mode-alist))
+;; The changelog is at the end of this file.
;;
-;; ; Define C-c t to run my favorite command in inferior scheme mode:
-;; (setq cmuscheme-load-hook
-;; '((lambda () (define-key inferior-scheme-mode-map "\C-ct"
-;; 'favorite-cmd))))
-;;;
-;;; Unfortunately, scheme.el defines run-scheme to autoload from xscheme.el.
-;;; This will womp your declaration to autoload run-scheme from cmuscheme.el
-;;; if you haven't loaded cmuscheme in before scheme. Three fixes:
-;;; - Put the autoload on your scheme mode hook and in your .emacs toplevel:
-;;; (setq scheme-mode-hook
-;;; '((lambda () (autoload 'run-scheme "cmuscheme"
-;;; "Run an inferior Scheme" t))))
-;;; (autoload 'run-scheme "cmuscheme" "Run an inferior Scheme" t)
-;;; Now when scheme.el autoloads, it will restore the run-scheme autoload.
-;;; - Load cmuscheme.el in your .emacs: (load-library 'cmuscheme)
-;;; - Change autoload declaration in scheme.el to point to cmuscheme.el:
-;;; (autoload 'run-scheme "cmuscheme" "Run an inferior Scheme" t)
-;;; *or* just delete the autoload declaration from scheme.el altogether,
-;;; which will allow the autoload in your .emacs to have its say.
+;; NOTE: MIT Cscheme, when invoked with the -emacs flag, has a special user
+;; interface that communicates process state back to the superior emacs by
+;; outputting special control sequences. The gnumacs package, xscheme.el, has
+;; lots and lots of special purpose code to read these control sequences, and
+;; so is very tightly integrated with the cscheme process. The cscheme
+;; interrupt handler and debugger read single character commands in cbreak
+;; mode; when this happens, xscheme.el switches to special keymaps that bind
+;; the single letter command keys to emacs functions that directly send the
+;; character to the scheme process. Cmuscheme mode does *not* provide this
+;; functionality. If you are a cscheme user, you may prefer to use the
+;; xscheme.el/cscheme -emacs interaction.
+;;
+;; Here's a summary of the pros and cons, as I see them.
+;; xscheme: Tightly integrated with inferior cscheme process! A few commands
+;; not in cmuscheme. But. Integration is a bit of a hack. Input
+;; history only keeps the immediately prior input. Bizarre
+;; keybindings.
+;;
+;; cmuscheme: Not tightly integrated with inferior cscheme process. But.
+;; Carefully integrated functionality with the entire suite of
+;; comint-derived CMU process modes. Keybindings reminiscent of
+;; Zwei and Hemlock. Good input history. A few commands not in
+;; xscheme.
+;;
+;; It's a tradeoff. Pay your money; take your choice. If you use a Scheme
+;; that isn't Cscheme, of course, there isn't a choice. Xscheme.el is *very*
+;; Cscheme-specific; you must use cmuscheme.el. Interested parties are
+;; invited to port xscheme functionality on top of comint mode...
;;; Code:
(cond ((not inferior-scheme-mode-map)
(setq inferior-scheme-mode-map
- (full-copy-sparse-keymap comint-mode-map))
+ (copy-keymap comint-mode-map))
(define-key inferior-scheme-mode-map "\M-\C-x" ;gnu convention
'scheme-send-definition)
(define-key inferior-scheme-mode-map "\C-x\C-e" 'scheme-send-last-sexp)
(define-key scheme-mode-map "\C-c\C-l" 'scheme-load-file)
(define-key scheme-mode-map "\C-c\C-k" 'scheme-compile-file) ;k for "kompile"
+(let ((map (lookup-key scheme-mode-map [menu-bar scheme])))
+ (define-key map [separator-eval] '("--"))
+ (define-key map [compile-file]
+ '("Compile Scheme File" . scheme-compile-file))
+ (define-key map [load-file]
+ '("Load Scheme File" . scheme-load-file))
+ (define-key map [switch]
+ '("Switch to Scheme" . switch-to-scheme))
+ (define-key map [com-def-go]
+ '("Compile Definitiion & Go" . scheme-compile-definition-and-go))
+ (define-key map [com-def]
+ '("Compile Definitiion" . scheme-compile-definition))
+ (define-key map [send-def-go]
+ '("Evaluate Last Definition & Go" . scheme-send-definition-and-go))
+ (define-key map [send-def]
+ '("Evaluate Last Definition" . scheme-send-definition))
+ (define-key map [send-region-go]
+ '("Evaluate Region & Go" . scheme-send-region-and-go))
+ (define-key map [send-region]
+ '("Evaluate Region" . scheme-send-region))
+ (define-key map [send-sexp]
+ '("Evaluate Last S-expression" . scheme-send-last-sexp))
+)
+
(defvar scheme-buffer)
(defun inferior-scheme-mode ()
(interactive)
(comint-mode)
;; Customise in inferior-scheme-mode-hook
- (setq comint-prompt-regexp "^[^>]*>+ *") ; OK for cscheme, oaklisp, T,...
+ (setq comint-prompt-regexp "^[^>\n]*>+ *") ; OK for cscheme, oaklisp, T,...
(scheme-mode-variables)
(setq major-mode 'inferior-scheme-mode)
(setq mode-name "Inferior Scheme")
- (setq mode-line-process '(": %s"))
+ (setq mode-line-process '(":%s"))
(use-local-map inferior-scheme-mode-map)
(setq comint-input-filter (function scheme-input-filter))
- (setq comint-input-sentinel (function ignore))
(setq comint-get-old-input (function scheme-get-old-input))
(run-hooks 'inferior-scheme-mode-hook))
(defvar scheme-program-name "scheme"
"*Program invoked by the run-scheme command")
-;;; Obsolete
-(defun scheme (&rest foo)
- "Use run-scheme"
- (interactive)
- (message "Use run-scheme")
- (ding))
-
+;;;###autoload
(defun run-scheme (cmd)
"Run an inferior Scheme process, input and output via buffer *scheme*.
-If there is a process already running in *scheme*, just switch to that buffer.
+If there is a process already running in `*scheme*', switch to that buffer.
With argument, allows you to edit the command line (default is value
-of scheme-program-name). Runs the hooks from inferior-scheme-mode-hook
-\(after the comint-mode-hook is run).
+of `scheme-program-name'). Runs the hooks `inferior-scheme-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
(set-buffer (apply 'make-comint "scheme" (car cmdlist)
nil (cdr cmdlist)))
(inferior-scheme-mode)))
+ (setq scheme-program-name cmd)
(setq scheme-buffer "*scheme*")
- (switch-to-buffer "*scheme*"))
-
+ (pop-to-buffer "*scheme*"))
+;;;###autoload (add-hook 'same-window-buffer-names "*scheme*")
(defun scheme-send-region (start end)
"Send the current region to the inferior Scheme process."