emacs: lisp/progmodes/inf-lisp.el comparison

comparison lisp/progmodes/inf-lisp.el @ 727:540b047ece4d

*** empty log message ***

author	Jim Blandy <jimb@redhat.com>
date	Wed, 24 Jun 1992 05:09:26 +0000
parents	8a533acedb77
children	b7932f859d4e

comparison

equal deleted inserted replaced

-:5f08efa38dd0
+:540b047ece4d
 ;;;
 ;;; Additionally, these commands are added to the key bindings of Lisp mode:
 ;;; c-m-x   lisp-eval-defun         This binding is a gnu convention.
 ;;; c-c c-e lisp-eval-defun 	    Send the current defun to Lisp process.
 ;;; c-x c-e lisp-eval-last-sexp     Send the previous sexp to Lisp process.
-;;; c-c m-e lisp-eval-defun-and-go  After sending the defun, switch-to-lisp.
 ;;; c-c c-r lisp-eval-region        Send the current region to Lisp process.
-;;; c-c m-r lisp-eval-region-and-go After sending the region, switch-to-lisp.
 ;;; c-c c-c lisp-compile-defun      Compile the current defun in Lisp process.
-;;; c-c m-c lisp-compile-defun-and-go After compiling defun, switch-to-lisp.
 ;;; c-c c-z switch-to-lisp          Switch to the Lisp process buffer.
 ;;; c-c c-l lisp-load-file          (See above. In a Lisp file buffer, default
 ;;; c-c c-k lisp-compile-file        is to load/compile the current file.)
 ;;; c-c c-d lisp-describe-sym	    Query Lisp for a symbol's description.
 ;;; c-c c-a lisp-show-arglist	    Query Lisp for function's arglist.
 ;;; c-c c-f lisp-show-function-documentation Query Lisp for a function's doc.
 ;;; c-c c-v lisp-show-variable-documentation Query Lisp for a variable's doc.
 ;;; cmulisp	    	    	    Fires up the Lisp process.
 ;;; lisp-compile-region     	    Compile all forms in the current region.
-;;; lisp-compile-region-and-go      After compiling region, switch-to-lisp.
 ;;;
 ;;; CMU Lisp Mode Variables:
 ;;; cmulisp-filter-regexp	    Match this => don't get saved on input hist
 ;;; inferior-lisp-program   	    Name of Lisp program run-lisp executes
 ;;; inferior-lisp-load-command	    Customises lisp-load-file
 ;;; These commands augment Lisp mode, so you can process Lisp code in
 ;;; the source files.
 (define-key lisp-mode-map "\M-\C-x"  'lisp-eval-defun)     ; Gnu convention
 (define-key lisp-mode-map "\C-x\C-e" 'lisp-eval-last-sexp) ; Gnu convention
 (define-key lisp-mode-map "\C-c\C-e" 'lisp-eval-defun)
-(define-key lisp-mode-map "\C-c\M-e" 'lisp-eval-defun-and-go)
 (define-key lisp-mode-map "\C-c\C-r" 'lisp-eval-region)
-(define-key lisp-mode-map "\C-c\M-r" 'lisp-eval-region-and-go)
 (define-key lisp-mode-map "\C-c\C-c" 'lisp-compile-defun)
-(define-key lisp-mode-map "\C-c\M-c" 'lisp-compile-defun-and-go)
 (define-key lisp-mode-map "\C-c\C-z" 'switch-to-lisp)
 (define-key lisp-mode-map "\C-c\C-l" 'lisp-load-file)
 (define-key lisp-mode-map "\C-c\C-k" 'lisp-compile-file)  ; "kompile" file
 (define-key lisp-mode-map "\C-c\C-a" 'lisp-show-arglist)
 (define-key lisp-mode-map "\C-c\C-d" 'lisp-describe-sym)
 (define-key lisp-mode-map "\C-c\C-f" 'lisp-show-function-documentation)
 (define-key lisp-mode-map "\C-c\C-v" 'lisp-show-variable-documentation)
+;;; This function exists for backwards compatibility.
+;;; Previous versions of this package bound commands to C-c <letter>
+;;; bindings, which is not allowed by the gnumacs standard.
+(defun cmulisp-install-letter-bindings ()
+"This function binds many cmulisp commands to C-c <letter> bindings,
+where they are more accessible. C-c <letter> bindings are reserved for the
+user, so these bindings are non-standard. If you want them, you should
+have this function called by the cmulisp-load-hook:
+(setq cmulisp-load-hook '(cmulisp-install-letter-bindings))
+You can modify this function to install just the bindings you want."
+(define-key lisp-mode-map "\C-ce" 'lisp-eval-defun-and-go)
+(define-key lisp-mode-map "\C-cr" 'lisp-eval-region-and-go)
+(define-key lisp-mode-map "\C-cc" 'lisp-compile-defun-and-go)
+(define-key lisp-mode-map "\C-cz" 'switch-to-lisp)
+(define-key lisp-mode-map "\C-cl" 'lisp-load-file)
+(define-key lisp-mode-map "\C-ck" 'lisp-compile-file)
+(define-key lisp-mode-map "\C-ca" 'lisp-show-arglist)
+(define-key lisp-mode-map "\C-cd" 'lisp-describe-sym)
+(define-key lisp-mode-map "\C-cf" 'lisp-show-function-documentation)
+(define-key lisp-mode-map "\C-cv" 'lisp-show-variable-documentation)
+(define-key cmulisp-mode-map "\C-cl" 'lisp-load-file)
+(define-key cmulisp-mode-map "\C-ck" 'lisp-compile-file)
+(define-key cmulisp-mode-map "\C-ca" 'lisp-show-arglist)
+(define-key cmulisp-mode-map "\C-cd" 'lisp-describe-sym)
+(define-key cmulisp-mode-map "\C-cf" 'lisp-show-function-documentation)
+(define-key cmulisp-mode-map "\C-cv" 'lisp-show-variable-documentation))
 (defvar inferior-lisp-program "lisp"
 "*Program name for invoking an inferior Lisp with `cmulisp'.")
 lisp-eval-defun sends the current defun to the Lisp process.
 lisp-compile-defun compiles the current defun.
 lisp-eval-region sends the current region to the Lisp process.
 lisp-compile-region compiles the current region.
-lisp-eval-defun-and-go, lisp-compile-defun-and-go,
+Prefixing the lisp-eval/compile-defun/region commands with
-lisp-eval-region-and-go, and lisp-compile-region-and-go
+a \\[universal-argument] causes a switch to the Lisp process buffer after sending
-switch to the Lisp process buffer after sending their text.
+the text.
 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
 (defun lisp-input-filter (str)
 "Don't save anything matching cmulisp-filter-regexp"
 (not (string-match cmulisp-filter-regexp str)))
-(defun cmulisp ()
+(defun cmulisp (cmd)
 "Run an inferior Lisp process, input and output via buffer *cmulisp*.
 If there is a process already running in *cmulisp*, just switch to that buffer.
-Takes the program name from the variable inferior-lisp-program.
+With argument, allows you to edit the command line (default is value
+of inferior-lisp-program).  Runs the hooks from cmulisp-mode-hook (after the
+comint-mode-hook is run).
 \(Type \\[describe-mode] in the process buffer for a list of commands.)"
-(interactive)
+(interactive (list (if current-prefix-arg
-(cond ((not (comint-check-proc "*cmulisp*"))
+			 (read-string "Run lisp: " inferior-lisp-program)
-	 (set-buffer (make-comint "cmulisp" inferior-lisp-program))
+			 inferior-lisp-program)))
+(if (not (comint-check-proc "*cmulisp*"))
+(let ((cmdlist (cmulisp-args-to-list cmd)))
+	 (set-buffer (apply (function make-comint) "cmulisp" (car cmdlist) nil
+			    (cdr cmdlist)))
 	 (cmulisp-mode)))
 (setq cmulisp-buffer "*cmulisp*")
 (switch-to-buffer "*cmulisp*"))
-(defun lisp-eval-region (start end)
+;;; Break a string up into a list of arguments.
-"Send the current region to the inferior Lisp process."
+;;; This will break if you have an argument with whitespace, as in
-(interactive "r")
+;;; string = "-ab +c -x 'you lose'".
+(defun cmulisp-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
+		 (cmulsip-args-to-list (substring string pos
+						  (length string)))))))))
+(defun lisp-eval-region (start end &optional and-go)
+"Send the current region to the inferior Lisp process.
+Prefix argument means switch-to-lisp afterwards."
+(interactive "r\nP")
 (comint-send-region (cmulisp-proc) start end)
-(comint-send-string (cmulisp-proc) "\n"))
+(comint-send-string (cmulisp-proc) "\n")
+(if and-go (switch-to-lisp t)))
-(defun lisp-eval-defun ()
-"Send the current defun to the inferior Lisp process."
+(defun lisp-eval-defun (&optional and-go)
-(interactive)
+"Send the current defun to the inferior Lisp process.
+Prefix argument means switch-to-lisp afterwards."
+(interactive "P")
 (save-excursion
 (end-of-defun)
-(let ((end (point)))
+(skip-chars-backward " \t\n\r\f") ;  Makes allegro happy
-(beginning-of-defun)
+(let ((end (point)))
-(lisp-eval-region (point) end))))
+(beginning-of-defun)
+(lisp-eval-region (point) end)))
-(defun lisp-eval-last-sexp ()
+(if and-go (switch-to-lisp t)))
-"Send the previous sexp to the inferior Lisp process."
-(interactive)
+(defun lisp-eval-last-sexp (&optional and-go)
-(lisp-eval-region (save-excursion (backward-sexp) (point)) (point)))
+"Send the previous sexp to the inferior Lisp process.
+Prefix argument means switch-to-lisp afterwards."
-;;; CommonLisp COMPILE sux.
+(interactive "P")
-(defun lisp-compile-region (start end)
+(lisp-eval-region (save-excursion (backward-sexp) (point)) (point) and-go))
-"Compile the current region in the inferior Lisp process."
-(interactive "r")
+;;; Common Lisp COMPILE sux.
+(defun lisp-compile-region (start end &optional and-go)
+"Compile the current region in the inferior Lisp process.
+Prefix argument means switch-to-lisp afterwards."
+(interactive "r\nP")
 (comint-send-string (cmulisp-proc)
 (format "(funcall (compile nil `(lambda () (progn 'compile %s))))\n"
-	    (buffer-substring start end))))
+	    (buffer-substring start end)))
+(if and-go (switch-to-lisp t)))
-(defun lisp-compile-defun ()
+(defun lisp-compile-defun (&optional and-go)
-"Compile the current defun in the inferior Lisp process."
+"Compile the current defun in the inferior Lisp process.
-(interactive)
+Prefix argument means switch-to-lisp afterwards."
+(interactive "P")
 (save-excursion
 (end-of-defun)
+(skip-chars-backward " \t\n\r\f") ;  Makes allegro happy
 (let ((e (point)))
 (beginning-of-defun)
-(lisp-compile-region (point) e))))
+(lisp-compile-region (point) e)))
+(if and-go (switch-to-lisp t)))
 (defun switch-to-lisp (eob-p)
 "Switch to the inferior Lisp process buffer.
 With argument, positions cursor at end of buffer."
 (interactive "P")
 (error "No current process buffer. See variable cmulisp-buffer."))
 (cond (eob-p
 	 (push-mark)
 	 (goto-char (point-max)))))
+;;; Now that lisp-compile/eval-defun/region takes an optional prefix arg,
+;;; these commands are redundant. But they are kept around for the user
+;;; to bind if he wishes, for backwards functionality, and because it's
+;;; easier to type C-c e than C-u C-c C-e.
 (defun lisp-eval-region-and-go (start end)
 "Send the current region to the inferior Lisp,
 and switch to the process buffer."
 (interactive "r")
-(lisp-eval-region start end)
+(lisp-eval-region start end t))
-(switch-to-lisp t))
 (defun lisp-eval-defun-and-go ()
 "Send the current defun to the inferior Lisp,
 and switch to the process buffer."
 (interactive)
-(lisp-eval-defun)
+(lisp-eval-defun t))
-(switch-to-lisp t))
 (defun lisp-compile-region-and-go (start end)
 "Compile the current region in the inferior Lisp,
 and switch to the process buffer."
 (interactive "r")
-(lisp-compile-region start end)
+(lisp-compile-region start end t))
-(switch-to-lisp t))
 (defun lisp-compile-defun-and-go ()
 "Compile the current defun in the inferior Lisp,
 and switch to the process buffer."
 (interactive)
-(lisp-compile-defun)
+(lisp-compile-defun t))
-(switch-to-lisp t))
 ;;; A version of the form in H. Shevis' soar-mode.el package. Less robust.
 ;(defun lisp-compile-sexp (start end)
 ;  "Compile the s-expression bounded by START and END in the inferior lisp.
 ;If the sexp isn't a DEFUN form, it is evaluated instead."
 ; doesn't need an exact name
 (comint-check-source file-name) ; Check to see if buffer needs saved.
 (setq lisp-prev-l/c-dir/file (cons (file-name-directory    file-name)
 				     (file-name-nondirectory file-name)))
 (comint-send-string (cmulisp-proc)
-		      (format inferior-lisp-load-command file-name)))
+		      (format inferior-lisp-load-command file-name))
+(switch-to-lisp t))
 (defun lisp-compile-file (file-name)
 "Compile a Lisp file in the inferior Lisp process."
 (interactive (comint-get-source "Compile Lisp file: " lisp-prev-l/c-dir/file
 (comint-check-source file-name) ; Check to see if buffer needs saved.
 (setq lisp-prev-l/c-dir/file (cons (file-name-directory    file-name)
 				     (file-name-nondirectory file-name)))
 (comint-send-string (cmulisp-proc) (concat "(compile-file \""
 					     file-name
-					     "\"\)\n")))
+					     "\"\)\n"))
+(switch-to-lisp t))
 ;;; Documentation functions: function doc, var doc, arglist, and
 ;;; describe symbol.
 have three inferior lisps running:
 Buffer	Process
 foo		cmulisp
 bar		cmulisp<2>
 *cmulisp*   cmulisp<3>
-If you do a \\[lisp-eval-defun-and-go] command on some Lisp source code,
+If you do a \\[lisp-eval-defun] command on some Lisp source code,
 what process do you send it to?
 - If you're in a process buffer (foo, bar, or *cmulisp*),
 you send it to that process.
 - If you're in some other buffer (e.g., a source file), you
 ;;; reported by Lennart Staflin.
 ;;;
 ;;; 3/12/90 Olin
 ;;; - lisp-load-file and lisp-compile-file no longer switch-to-lisp.
 ;;;   Tale suggested this.
+;;; - Reversed this decision 7/15/91. You need the visual feedback.
+;;;
+;;; 7/25/91 Olin
+;;; Changed all keybindings of the form C-c <letter>. These are
+;;; supposed to be reserved for the user to bind. This affected
+;;; mainly the compile/eval-defun/region[-and-go] commands.
+;;; This was painful, but necessary to adhere to the gnumacs standard.
+;;; For some backwards compatibility, see the
+;;;     cmulisp-install-letter-bindings
+;;; function.
+;;;
+;;; 8/2/91 Olin
+;;; - The lisp-compile/eval-defun/region commands now take a prefix arg,
+;;;   which means switch-to-lisp after sending the text to the Lisp process.
+;;;   This obsoletes all the -and-go commands. The -and-go commands are
+;;;   kept around for historical reasons, and because the user can bind
+;;;   them to key sequences shorter than C-u C-c C-<letter>.
+;;; - If M-x cmulisp is invoked with a prefix arg, it allows you to
+;;;   edit the command line.
 (provide 'cmulisp)
 ;;; cmulisp.el ends here

Mercurial > emacs

comparison lisp/progmodes/inf-lisp.el @ 727:540b047ece4d