X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/dd69dcbc6f823022b43ce6425156db98ad7286d8..50443272bb7bb1d0e3f1ba891822dd145babce1e:/lisp/cmuscheme.el

diff --git a/lisp/cmuscheme.el b/lisp/cmuscheme.el
index cc09c81b23..a3e1ab5d9f 100644
--- a/lisp/cmuscheme.el
+++ b/lisp/cmuscheme.el
@@ -1,6 +1,6 @@
 ;;; cmuscheme.el --- Scheme process in a buffer. Adapted from tea.el.
 
-;; Copyright (C) 1988, 1994 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 1994, 1997 Free Software Foundation, Inc.
 
 ;; Author: Olin Shivers <olin.shivers@cs.cmu.edu>
 ;; Maintainer: FSF
@@ -19,90 +19,96 @@
 ;; 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)
+;;
+;; 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.
 ;;
-;; ; 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))))
+;; 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...
+
+;;; 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.
 ;;;
-;;; 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.
+;;; 5/22/90 Olin
+;;; - Upgraded to use comint-send-string and comint-send-region.
+;;; - run-scheme now offers to let you edit the command line if
+;;;   you invoke it with a prefix-arg. M-x scheme is redundant, and
+;;;   has been removed.
+;;; - Explicit references to process "scheme" have been replaced with
+;;;   (scheme-proc). This allows better handling of multiple process bufs.
+;;; - Added scheme-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.
+;;;
+;;; 3/12/90 Olin
+;;; - scheme-load-file and scheme-compile-file no longer switch-to-scheme.
+;;;   Tale suggested this.
 
 ;;; Code:
 
 (require 'scheme)
 (require 'comint)
 
+
+(defgroup cmuscheme nil
+  "Run a scheme process in a buffer."
+  :group 'lisp)
+
 ;;; INFERIOR SCHEME MODE STUFF
 ;;;============================================================================
 
-(defvar inferior-scheme-mode-hook nil
-  "*Hook for customising inferior-scheme mode.")
+(defcustom inferior-scheme-mode-hook nil
+  "*Hook for customising inferior-scheme mode."
+  :type 'hook
+  :group 'cmuscheme)
+
 (defvar inferior-scheme-mode-map nil)
 
 (cond ((not inferior-scheme-mode-map)
@@ -128,6 +134,30 @@
 (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 ()
@@ -180,9 +210,11 @@ to continue it."
   (setq comint-get-old-input (function scheme-get-old-input))
   (run-hooks 'inferior-scheme-mode-hook))
 
-(defvar inferior-scheme-filter-regexp "\\`\\s *\\S ?\\S ?\\s *\\'"
+(defcustom inferior-scheme-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.")
+Defaults to a regexp ignoring all inputs of 0, 1, or 2 letters."
+  :type 'regexp
+  :group 'cmuscheme)
 
 (defun scheme-input-filter (str)
   "Don't save anything matching inferior-scheme-filter-regexp"
@@ -208,22 +240,18 @@ Defaults to a regexp ignoring all inputs of 0, 1, or 2 letters.")
 		 (scheme-args-to-list (substring string pos
 						 (length string)))))))))
 
-(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))
+(defcustom scheme-program-name "scheme"
+  "*Program invoked by the run-scheme command"
+  :type 'string
+  :group 'cmuscheme)
 
+;;;###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
@@ -234,9 +262,10 @@ of scheme-program-name).  Runs the hooks from inferior-scheme-mode-hook
 	(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."
@@ -258,8 +287,10 @@ of scheme-program-name).  Runs the hooks from inferior-scheme-mode-hook
   (interactive)
   (scheme-send-region (save-excursion (backward-sexp) (point)) (point)))
 
-(defvar scheme-compile-exp-command "(compile '%s)"
-  "*Template for issuing commands to compile arbitrary Scheme expressions.")
+(defcustom scheme-compile-exp-command "(compile '%s)"
+  "*Template for issuing commands to compile arbitrary Scheme expressions."
+  :type 'string
+  :group 'cmuscheme)
 
 (defun scheme-compile-region (start end)
   "Compile the current region in the inferior Scheme process.
@@ -318,11 +349,13 @@ Then switch to the process buffer."
   (scheme-compile-region start end)
   (switch-to-scheme t))
 
-(defvar scheme-source-modes '(scheme-mode)
+(defcustom scheme-source-modes '(scheme-mode)
   "*Used to determine if a buffer contains Scheme source code.
 If it's loaded into a buffer that is in one of these major modes, it's
 considered a scheme source file by scheme-load-file and scheme-compile-file.
-Used by these commands to determine defaults.")
+Used by these commands to determine defaults."
+  :type '(repeat function)
+  :group 'cmuscheme)
 
 (defvar scheme-prev-l/c-dir/file nil
   "Caches the last (directory . file) pair.
@@ -408,39 +441,14 @@ for a minimal, simple implementation. Feel free to extend it.")
 
 ;;; Do the user's customisation...
 
-(defvar cmuscheme-load-hook nil
+(defcustom cmuscheme-load-hook nil
   "This hook is run when cmuscheme is loaded in.
-This is a good place to put keybindings.")
+This is a good place to put keybindings."
+  :type 'hook
+  :group 'cmuscheme)
 	
 (run-hooks 'cmuscheme-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-scheme now offers to let you edit the command line if
-;;;   you invoke it with a prefix-arg. M-x scheme is redundant, and
-;;;   has been removed.
-;;; - Explicit references to process "scheme" have been replaced with
-;;;   (scheme-proc). This allows better handling of multiple process bufs.
-;;; - Added scheme-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.
-;;;
-;;; 3/12/90 Olin
-;;; - scheme-load-file and scheme-compile-file no longer switch-to-scheme.
-;;;   Tale suggested this.
-
 (provide 'cmuscheme)
 
 ;;; cmuscheme.el ends here