Change name of `interaction' mode to be `scheme-interaction'.

diff --git a/v7/src/edwin/intmod.scm b/v7/src/edwin/intmod.scm
index c539ff0a839bfae072ba6125173c663f353afb33..6c7e92c4952ff0e36c58ac2f1d3c408661872c76 100644 (file)
--- a/v7/src/edwin/intmod.scm
+++ b/v7/src/edwin/intmod.scm
@@ -1,6 +1,6 @@
 ;;; -*-Scheme-*-
 ;;;
-;;;    $Header: /Users/cph/tmp/foo/mit-scheme/mit-scheme/v7/src/edwin/intmod.scm,v 1.33 1989/04/23 23:23:00 cph Exp $
+;;;    $Header: /Users/cph/tmp/foo/mit-scheme/mit-scheme/v7/src/edwin/intmod.scm,v 1.34 1989/04/25 02:07:56 cph Exp $
 ;;;
 ;;;    Copyright (c) 1986, 1989 Massachusetts Institute of Technology
 ;;;
@@ -41,119 +41,120 @@
 
 (declare (usual-integrations))
 \f
-(define-command interaction-mode
-  "Make the current mode be Interaction mode."
+(define-command scheme-interaction-mode
+  "Make the current mode be Scheme Interaction mode."
   ()
   (lambda ()
-    (set-current-major-mode! (ref-mode-object interaction))))
+    (set-current-major-mode! (ref-mode-object scheme-interaction))))
 
-(define-major-mode interaction scheme "Interaction"
+(define-major-mode scheme-interaction scheme "Scheme Interaction"
   "Major mode for evaluating Scheme expressions interactively.
 Same as Scheme mode, except for
 
-\\[interaction-eval-previous-sexp] evaluates the current expression.
-\\[interaction-eval-definition] evaluates the current definition.
-\\[interaction-eval-region] evaluates the region.
-\\[interaction-yank] yanks the most recently evaluated expression.
-\\[interaction-yank-pop] yanks an earlier expression, replacing a yank."
-  (local-set-variable! interaction-kill-ring (make-ring 32))
+\\[scheme-interaction-eval-previous-sexp] evaluates the current expression.
+\\[scheme-interaction-eval-definition] evaluates the current definition.
+\\[scheme-interaction-eval-region] evaluates the region.
+\\[scheme-interaction-yank] yanks the most recently evaluated expression.
+\\[scheme-interaction-yank-pop] yanks an earlier expression, replacing a yank."
+  (local-set-variable! scheme-interaction-kill-ring (make-ring 32))
   (local-set-variable! scheme-environment (ref-variable scheme-environment))
   (local-set-variable! scheme-syntax-table (ref-variable scheme-syntax-table)))
 
-(define-prefix-key 'interaction #\C-x 'prefix-char)
-(define-prefix-key 'interaction #\C-c 'prefix-char)
-(define-key 'interaction '(#\C-x #\C-e) 'interaction-eval-previous-sexp)
-(define-key 'interaction #\M-return 'interaction-eval-previous-sexp)
-(define-key 'interaction #\M-z 'interaction-eval-definition)
-(define-key 'interaction #\C-M-z 'interaction-eval-region)
-(define-key 'interaction '(#\C-c #\C-y) 'interaction-yank)
-(define-key 'interaction '(#\C-c #\C-r) 'interaction-yank-pop)
+(define-prefix-key 'scheme-interaction #\C-x 'prefix-char)
+(define-prefix-key 'scheme-interaction #\C-c 'prefix-char)
+(define-key 'scheme-interaction '(#\C-x #\C-e)
+  'scheme-interaction-eval-previous-sexp)
+(define-key 'scheme-interaction #\M-return
+  'scheme-interaction-eval-previous-sexp)
+(define-key 'scheme-interaction #\M-z 'scheme-interaction-eval-definition)
+(define-key 'scheme-interaction #\C-M-z 'scheme-interaction-eval-region)
+(define-key 'scheme-interaction '(#\C-c #\C-y) 'scheme-interaction-yank)
+(define-key 'scheme-interaction '(#\C-c #\C-r) 'scheme-interaction-yank-pop)
 
-(define-variable interaction-kill-ring
+(define-variable scheme-interaction-kill-ring
   "Kill ring used by Interaction mode evaluation commands.")
 
-(define (interaction-eval-region region argument)
+(define (scheme-interaction-eval-region region argument)
   (set-current-point! (region-end region))
   (let ((string (region->string region)))
-    (ring-push! (ref-variable interaction-kill-ring) string)
+    (ring-push! (ref-variable scheme-interaction-kill-ring) string)
     (let ((expression (with-input-from-string string read)))
       (let ((value
             (with-output-to-current-point
              (lambda ()
                (intercept-^G-interrupts
                 (lambda ()
-                  (interaction-guarantee-newlines 1)
+                  (guarantee-newline)
                   (insert-string "Abort!")
                   (insert-newlines 2)
                   (^G-signal))
                 (lambda ()
                   (eval-with-history expression
                                      (evaluation-environment argument))))))))
-       (interaction-guarantee-newlines 1)
+       (guarantee-newline)
        (if (undefined-value? value)
            (insert-string ";No value")
            (begin
              (insert-string ";Value: ")
-             (insert-string (interaction-object->string value))))
-       (interaction-guarantee-newlines 2)))))
+             (insert-string (scheme-interaction-object->string value))))
+       (guarantee-newlines 2)))))
 
-(define (interaction-guarantee-newlines n)
-  (insert-newlines (if (line-start? (current-point)) (-1+ n) n)))
-
-(define (interaction-object->string object)
-  (fluid-let ((*unparser-list-depth-limit* 2)
-             (*unparser-list-breadth-limit* 5))
+(define (scheme-interaction-object->string object)
+  (fluid-let ((*unparser-list-depth-limit* 5)
+             (*unparser-list-breadth-limit* 10))
     (write-to-string object)))
 \f
-(define-command interaction-eval-previous-sexp
+(define-command scheme-interaction-eval-previous-sexp
   "Evaluate the expression to the left of point."
   "P"
   (lambda (argument)
     (let ((point (current-point)))
-      (interaction-eval-region (make-region (backward-one-sexp point) point)
-                              argument))))
+      (scheme-interaction-eval-region
+       (make-region (backward-one-sexp point) point)
+       argument))))
 
-(define-command interaction-eval-definition
+(define-command scheme-interaction-eval-definition
   "Evaluate the definition at point.
 Moves point to the definition's end.
 Output and the result are written at that point.
 With an argument, prompts for the evaluation environment."
   "P"
   (lambda (argument)
-    (interaction-eval-region
+    (scheme-interaction-eval-region
      (let ((start (current-definition-start)))
        (make-region start (forward-one-definition-end start)))
      argument)))
 
-(define-command interaction-eval-region
+(define-command scheme-interaction-eval-region
   "Evaluate the definition at point.
 Moves point to the definition's end.
 Output and the result are written at that point.
 With an argument, prompts for the evaluation environment."
   "r\nP"
-  interaction-eval-region)
+  scheme-interaction-eval-region)
 
-(define interaction-mode:yank-command-message
+(define scheme-interaction-mode:yank-command-message
   "Yank")
 
-(define-command interaction-yank
+(define-command scheme-interaction-yank
   "Yank the last input expression."
   ()
   (lambda ()
     (push-current-mark! (mark-right-inserting (current-point)))
-    (insert-string (ring-ref (ref-variable interaction-kill-ring) 0))
-    (set-command-message! interaction-mode:yank-command-message)))
+    (insert-string (ring-ref (ref-variable scheme-interaction-kill-ring) 0))
+    (set-command-message! scheme-interaction-mode:yank-command-message)))
 
-(define-command interaction-yank-pop
+(define-command scheme-interaction-yank-pop
   "Yank the last input expression."
   ()
   (lambda ()
-    (command-message-receive interaction-mode:yank-command-message
+    (command-message-receive scheme-interaction-mode:yank-command-message
       (lambda ()
        (delete-string (pop-current-mark!) (current-point))
        (push-current-mark! (mark-right-inserting (current-point)))
-       (ring-pop! (ref-variable interaction-kill-ring))
-       (insert-string (ring-ref (ref-variable interaction-kill-ring) 0))
-       (set-command-message! interaction-mode:yank-command-message))
+       (ring-pop! (ref-variable scheme-interaction-kill-ring))
+       (insert-string
+        (ring-ref (ref-variable scheme-interaction-kill-ring) 0))
+       (set-command-message! scheme-interaction-mode:yank-command-message))
       (lambda ()
        (editor-error "No previous yank to replace")))))
\ No newline at end of file