elisp/geiser-repl.el

   1 ;;; geiser-repl.el --- Geiser's REPL
   2
   3 ;; Copyright (C) 2009, 2010 Jose Antonio Ortega Ruiz
   4
   5 ;; This program is free software; you can redistribute it and/or
   6 ;; modify it under the terms of the Modified BSD License. You should
   7 ;; have received a copy of the license along with this program. If
   8 ;; not, see <http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5>.
   9
  10 \f
  11
  12 (require 'geiser-company)
  13 (require 'geiser-autodoc)
  14 (require 'geiser-edit)
  15 (require 'geiser-completion)
  16 (require 'geiser-impl)
  17 (require 'geiser-eval)
  18 (require 'geiser-connection)
  19 (require 'geiser-menu)
  20 (require 'geiser-custom)
  21 (require 'geiser-base)
  22
  23 (require 'comint)
  24 (require 'compile)
  25 (require 'scheme)
  26
  27 \f
  28 ;;; Customization:
  29
  30 (defgroup geiser-repl nil
  31   "Interacting with the Geiser REPL."
  32   :group 'geiser)
  33
  34 (geiser-custom--defcustom geiser-repl-use-other-window t
  35   "Whether to Use a window other than the current buffer's when
  36 switching to the Geiser REPL buffer."
  37   :type 'boolean
  38   :group 'geiser-repl)
  39
  40 (geiser-custom--defcustom geiser-repl-window-allow-split t
  41   "Whether to allow window splitting when switching to the Geiser
  42 REPL buffer."
  43   :type 'boolean
  44   :group 'geiser-repl)
  45
  46 (geiser-custom--defcustom geiser-repl-history-filename (expand-file-name "~/.geiser_history")
  47   "File where REPL input history is saved, so that it persists between sessions.
  48 This is actually the base name: the concrete Scheme
  49 implementation name gets appended to it."
  50   :type 'filename
  51   :group 'geiser-repl)
  52
  53 (geiser-custom--defcustom geiser-repl-history-size comint-input-ring-size
  54   "Maximum size of the saved REPL input history."
  55   :type 'integer
  56   :group 'geiser-repl)
  57
  58 (geiser-custom--defcustom geiser-repl-history-no-dups-p t
  59    "Whether to skip duplicates when recording history."
  60    :type 'boolean
  61    :group 'geiser-repl)
  62
  63 (geiser-custom--defcustom geiser-repl-autodoc-p t
  64   "Whether to enable `geiser-autodoc-mode' in the REPL by default."
  65   :type 'boolean
  66   :group 'geiser-repl)
  67
  68 (geiser-custom--defcustom geiser-repl-company-p t
  69   "Whether to use company-mode for completion, if available."
  70   :group 'geiser-mode
  71   :type 'boolean)
  72
  73 (geiser-custom--defcustom geiser-repl-read-only-prompt-p t
  74   "Whether the REPL's prompt should be read-only."
  75   :type 'boolean
  76   :group 'geiser-repl)
  77
  78 (geiser-custom--defcustom geiser-repl-auto-indent-p t
  79   "Whether newlines for incomplete sexps are autoindented."
  80   :type 'boolean
  81   :group 'geiser-repl)
  82
  83 (geiser-custom--defcustom geiser-repl-forget-old-errors-p t
  84   "Whether to forget old errors upon entering a new expression.
  85
  86 When on (the default), every time a new expression is entered in
  87 the REPL old error messages are flushed, and using \\[next-error]
  88 afterwards will jump only to error locations produced by the new
  89 expression, if any."
  90   :type 'boolean
  91   :group 'geiser-repl)
  92
  93 (geiser-custom--defcustom geiser-repl-query-on-exit-p nil
  94   "Whether to prompt for confirmation on \\[geiser-repl-exit]."
  95   :type 'boolean
  96   :group 'geiser-repl)
  97
  98 (geiser-custom--defcustom geiser-repl-default-host "localhost"
  99   "Default host when connecting to remote REPLs."
 100   :type 'string
 101   :group 'geiser-repl)
 102
 103 (geiser-custom--defcustom geiser-repl-default-port 37146
 104   "Default port for connecting to remote REPLs."
 105   :type 'integer
 106   :group 'geiser-repl)
 107
 108 \f
 109 ;;; Implementation-dependent parameters
 110
 111 (geiser-impl--define-caller geiser-repl--binary binary ()
 112   "A variable or function returning the path to the scheme binary
 113 for this implementation.")
 114
 115 (geiser-impl--define-caller geiser-repl--arglist arglist ()
 116   "A function taking no arguments and returning a list of
 117 arguments to be used when invoking the scheme binary.")
 118
 119 (geiser-impl--define-caller geiser-repl--prompt-regexp prompt-regexp ()
 120   "A variable (or thunk returning a value) giving the regular
 121 expression for this implementation's geiser scheme prompt.")
 122
 123 (geiser-impl--define-caller
 124     geiser-repl--debugger-prompt-regexp debugger-prompt-regexp ()
 125   "A variable (or thunk returning a value) giving the regular
 126 expression for this implementation's debugging prompt.")
 127
 128 (geiser-impl--define-caller geiser-repl--startup repl-startup (remote)
 129   "Function taking no parameters that is called after the REPL
 130 has been initialised. All Geiser functionality is available to
 131 you at that point.")
 132
 133 (geiser-impl--define-caller geiser-repl--enter-cmd enter-command (module)
 134   "Function taking a module designator and returning a REPL enter
 135 module command as a string")
 136
 137 (geiser-impl--define-caller geiser-repl--import-cmd import-command (module)
 138   "Function taking a module designator and returning a REPL import
 139 module command as a string")
 140
 141 (geiser-impl--define-caller geiser-repl--exit-cmd exit-command ()
 142   "Function returning the REPL exit command as a string")
 143
 144 \f
 145 ;;; Geiser REPL buffers and processes:
 146
 147 (defvar geiser-repl--repls nil)
 148 (defvar geiser-repl--closed-repls nil)
 149
 150 (make-variable-buffer-local
 151  (defvar geiser-repl--repl nil))
 152
 153 (defsubst geiser-repl--set-this-buffer-repl (r)
 154   (setq geiser-repl--repl r))
 155
 156 (defun geiser-repl--live-p ()
 157   (and geiser-repl--repl
 158        (get-buffer-process geiser-repl--repl)))
 159
 160 (defun geiser-repl--repl/impl (impl &optional repls)
 161   (catch 'repl
 162     (dolist (repl (or repls geiser-repl--repls))
 163       (when (buffer-live-p repl)
 164         (with-current-buffer repl
 165           (when (eq geiser-impl--implementation impl)
 166             (throw 'repl repl)))))))
 167
 168 (defun geiser-repl--set-up-repl (impl)
 169   (or (and (not impl) geiser-repl--repl)
 170       (setq geiser-repl--repl
 171             (let ((impl (or impl
 172                             geiser-impl--implementation
 173                             (geiser-impl--guess))))
 174               (when impl (geiser-repl--repl/impl impl))))))
 175
 176 (defun geiser-repl--active-impls ()
 177   (let ((act))
 178     (dolist (repl geiser-repl--repls act)
 179       (with-current-buffer repl
 180         (add-to-list 'act geiser-impl--implementation)))))
 181
 182 (defsubst geiser-repl--repl-name (impl)
 183   (format "%s REPL" (geiser-impl--impl-str impl)))
 184
 185 (defun geiser-repl--to-repl-buffer (impl)
 186   (unless (and (eq major-mode 'geiser-repl-mode)
 187                (not (get-buffer-process (current-buffer))))
 188     (let* ((old (geiser-repl--repl/impl impl geiser-repl--closed-repls))
 189            (old (and (buffer-live-p old)
 190                      (not (get-buffer-process old))
 191                      old)))
 192       (pop-to-buffer
 193        (or old
 194            (generate-new-buffer (format "* %s *"
 195                                         (geiser-repl--repl-name impl)))))
 196       (unless old
 197         (geiser-repl-mode)
 198         (geiser-impl--set-buffer-implementation impl)))))
 199
 200 (defun geiser-repl--read-impl (prompt &optional active)
 201   (geiser-impl--read-impl prompt (and active (geiser-repl--active-impls))))
 202
 203 (defsubst geiser-repl--only-impl-p ()
 204   (and (null (cdr geiser-active-implementations))
 205        (car geiser-active-implementations)))
 206
 207 (defun geiser-repl--get-impl (prompt)
 208   (or (geiser-repl--only-impl-p)
 209       (and (eq major-mode 'geiser-repl-mode) geiser-impl--implementation)
 210       (geiser-repl--read-impl prompt)))
 211
 212 \f
 213 ;;; REPL connections
 214
 215 (make-variable-buffer-local
 216  (defvar geiser-repl--address nil))
 217
 218 (make-variable-buffer-local
 219  (defvar geiser-repl--connection nil))
 220
 221 (defun geiser-repl--remote-p () geiser-repl--address)
 222
 223 (defsubst geiser-repl--host () (car geiser-repl--address))
 224 (defsubst geiser-repl--port () (cdr geiser-repl--address))
 225
 226 (defun geiser-repl--read-address (&optional host port)
 227   (let ((defhost (or (geiser-repl--host) geiser-repl-default-host))
 228         (defport (or (geiser-repl--port) geiser-repl-default-port)))
 229     (cons (or host
 230               (read-string (format "Host (default %s): " defhost)
 231                            nil nil defhost))
 232           (or port (read-number "Port: " defport)))))
 233
 234 (defun geiser-repl--autodoc-mode (n)
 235   (when (or geiser-repl-autodoc-p (< n 0))
 236     (geiser--save-msg (geiser-autodoc-mode n))))
 237
 238 (defun geiser-repl--save-remote-data (address)
 239   (setq geiser-repl--address address)
 240   (setq header-line-format (and address
 241                                 (format "Host: %s   Port: %s"
 242                                         (geiser-repl--host)
 243                                         (geiser-repl--port)))))
 244
 245 (defun geiser-repl--start-repl (impl address)
 246   (message "Starting Geiser REPL for %s ..." impl)
 247   (geiser-repl--to-repl-buffer impl)
 248   (sit-for 0)
 249   (goto-char (point-max))
 250   (geiser-repl--autodoc-mode -1)
 251   (let* ((prompt-rx (geiser-repl--prompt-regexp impl))
 252          (deb-prompt-rx (geiser-repl--debugger-prompt-regexp impl))
 253          (prompt (geiser-con--combined-prompt prompt-rx deb-prompt-rx)))
 254     (unless prompt-rx
 255       (error "Sorry, I don't know how to start a REPL for %s" impl))
 256     (geiser-repl--save-remote-data address)
 257     (geiser-repl--start-scheme impl address prompt)
 258     (geiser-repl--history-setup)
 259     (add-to-list 'geiser-repl--repls (current-buffer))
 260     (geiser-repl--set-this-buffer-repl (current-buffer))
 261     (setq geiser-repl--connection
 262           (geiser-con--make-connection (get-buffer-process (current-buffer))
 263                                        prompt-rx
 264                                        deb-prompt-rx))
 265     (geiser-repl--startup impl address)
 266     (geiser-repl--autodoc-mode 1)
 267     (message "%s up and running!" (geiser-repl--repl-name impl))))
 268
 269 (defun geiser-repl--start-scheme (impl address prompt)
 270   (setq comint-prompt-regexp prompt)
 271   (let* ((name (geiser-repl--repl-name impl))
 272          (buff (current-buffer))
 273          (args (if address (list address)
 274                  `(,(geiser-repl--binary impl)
 275                    nil
 276                    ,@(geiser-repl--arglist impl)))))
 277     (condition-case err
 278         (apply 'make-comint-in-buffer `(,name ,buff ,@args))
 279       (error (insert "Unable to start REPL:\n"
 280                      (error-message-string err)
 281                      "\n")
 282              (error "Couldn't start Geiser")))
 283     (geiser-repl--wait-for-prompt 10000)))
 284
 285 (defun geiser-repl--wait-for-prompt (timeout)
 286   (let ((p (point)) (seen) (buffer (current-buffer)))
 287     (while (and (not seen)
 288                 (> timeout 0)
 289                 (get-buffer-process buffer))
 290       (sleep-for 0.1)
 291       (setq timeout (- timeout 100))
 292       (goto-char p)
 293       (setq seen (re-search-forward comint-prompt-regexp nil t)))
 294     (goto-char (point-max))
 295
 296     (unless seen (error "%s" "No prompt found!"))))
 297
 298 (defun geiser-repl--is-debugging ()
 299   (let ((dp (geiser-con--connection-debug-prompt geiser-repl--connection)))
 300     (and dp
 301          comint-last-prompt-overlay
 302          (save-excursion
 303            (goto-char (overlay-start comint-last-prompt-overlay))
 304            (re-search-forward dp
 305                               (overlay-end comint-last-prompt-overlay)
 306                               t)))))
 307
 308 (defun geiser-repl--connection ()
 309   (let ((buffer (geiser-repl--set-up-repl geiser-impl--implementation)))
 310     (or (and (buffer-live-p buffer)
 311              (get-buffer-process buffer)
 312              (with-current-buffer buffer geiser-repl--connection))
 313         (error "No Geiser REPL for this buffer (try M-x run-geiser)"))))
 314
 315 (setq geiser-eval--default-connection-function 'geiser-repl--connection)
 316
 317 (defun geiser-repl--prepare-send ()
 318   (geiser-con--connection-deactivate geiser-repl--connection))
 319
 320 (defun geiser-repl--send (cmd)
 321   (when (and cmd (eq major-mode 'geiser-repl-mode))
 322     (geiser-repl--prepare-send)
 323     (goto-char (point-max))
 324     (comint-kill-input)
 325     (insert cmd)
 326     (let ((comint-input-filter (lambda (x) nil)))
 327       (comint-send-input nil t))))
 328
 329 (defun geiser-repl--send-silent (cmd)
 330   (geiser-repl--prepare-send)
 331   (comint-redirect-results-list cmd ".+" 0))
 332
 333 \f
 334 ;;; REPL history and clean-up:
 335
 336 (defsubst geiser-repl--history-file ()
 337   (format "%s.%s" geiser-repl-history-filename geiser-impl--implementation))
 338
 339 (defun geiser-repl--on-quit ()
 340   (comint-write-input-ring)
 341   (let ((cb (current-buffer))
 342         (impl geiser-impl--implementation)
 343         (comint-prompt-read-only nil))
 344     (geiser-con--connection-deactivate geiser-repl--connection)
 345     (geiser-con--connection-close geiser-repl--connection)
 346     (setq geiser-repl--repls (remove cb geiser-repl--repls))
 347     (dolist (buffer (buffer-list))
 348       (when (buffer-live-p buffer)
 349         (with-current-buffer buffer
 350           (when (and (eq geiser-impl--implementation impl)
 351                      (equal cb geiser-repl--repl))
 352             (geiser-repl--set-up-repl geiser-impl--implementation)))))))
 353
 354 (defun geiser-repl--sentinel (proc event)
 355   (let ((pb (process-buffer proc)))
 356     (when (buffer-live-p pb)
 357       (with-current-buffer pb
 358         (let ((comint-prompt-read-only nil)
 359               (comint-input-ring-file-name (geiser-repl--history-file)))
 360           (geiser-repl--on-quit)
 361           (push pb geiser-repl--closed-repls)
 362           (goto-char (point-max))
 363           (comint-kill-region comint-last-input-start (point))
 364           (insert "\nIt's been nice interacting with you!\n")
 365           (insert "Press C-c C-z to bring me back.\n" ))))))
 366
 367 (defun geiser-repl--on-kill ()
 368   (geiser-repl--on-quit)
 369   (setq geiser-repl--closed-repls
 370         (remove (current-buffer) geiser-repl--closed-repls)))
 371
 372 (defun geiser-repl--input-filter (str)
 373   (not (or (geiser-repl--is-debugging)
 374            (string-match "^\\s *$" str)
 375            (string-match "^,quit *$" str))))
 376
 377 (defun geiser-repl--old-input ()
 378   (save-excursion
 379     (let ((end (point)))
 380       (backward-sexp)
 381       (buffer-substring (point) end))))
 382
 383 (defun geiser-repl--history-setup ()
 384   (set (make-local-variable 'comint-input-ring-file-name)
 385        (geiser-repl--history-file))
 386   (set (make-local-variable 'comint-input-ring-size) geiser-repl-history-size)
 387   (set (make-local-variable 'comint-input-filter) 'geiser-repl--input-filter)
 388   (set (make-local-variable 'comint-get-old-input) 'geiser-repl--old-input)
 389   (add-hook 'kill-buffer-hook 'geiser-repl--on-kill nil t)
 390   (comint-read-input-ring t)
 391   (set-process-sentinel (get-buffer-process (current-buffer))
 392                         'geiser-repl--sentinel))
 393
 394 \f
 395 ;;; geiser-repl mode:
 396
 397 (defun geiser-repl--bol ()
 398   (interactive)
 399   (when (= (point) (comint-bol)) (beginning-of-line)))
 400
 401 (defun geiser-repl--beginning-of-defun ()
 402   (save-restriction
 403     (when comint-last-prompt-overlay
 404       (narrow-to-region (overlay-end comint-last-prompt-overlay) (point)))
 405     (let ((beginning-of-defun-function nil))
 406       (beginning-of-defun))))
 407
 408 (defun geiser-repl--module-function (&optional ignore) :f)
 409
 410 (defun geiser-repl--doc-module ()
 411   (interactive)
 412   (let ((geiser-eval--get-module-function
 413          (geiser-impl--method 'find-module geiser-impl--implementation)))
 414     (geiser-doc-module)))
 415
 416 (defun geiser-repl--newline-and-indent ()
 417   (interactive)
 418   (save-restriction
 419     (narrow-to-region comint-last-input-start (point-max))
 420     (insert "\n")
 421     (lisp-indent-line)))
 422
 423 (defun geiser-repl--last-prompt-end ()
 424   (if comint-last-prompt-overlay
 425       (overlay-end comint-last-prompt-overlay)
 426     (save-excursion (geiser-repl--bol) (point))))
 427
 428 (defun geiser-repl--last-prompt-start ()
 429   (if comint-last-prompt-overlay
 430       (overlay-start comint-last-prompt-overlay)
 431     (save-excursion (geiser-repl--bol) (point))))
 432
 433 (defun geiser-repl--nesting-level ()
 434   (save-restriction
 435     (narrow-to-region (geiser-repl--last-prompt-end) (point-max))
 436     (geiser-syntax--nesting-level)))
 437
 438 (defun geiser-repl--send-input ()
 439   (let* ((proc (get-buffer-process (current-buffer)))
 440          (pmark (and proc (process-mark proc)))
 441          (intxt (and pmark (buffer-substring pmark (point)))))
 442     (when intxt
 443       (and geiser-repl-forget-old-errors-p
 444            (not (geiser-repl--is-debugging))
 445            (compilation-forget-errors))
 446       (geiser-repl--prepare-send)
 447       (comint-send-input)
 448       (when (string-match "^\\s-*$" intxt)
 449         (comint-send-string proc (geiser-eval--scheme-str '(:ge no-values)))
 450         (comint-send-string proc "\n")))))
 451
 452 (defun geiser-repl--maybe-send ()
 453   (interactive)
 454   (let ((p (point)))
 455     (cond ((< p (geiser-repl--last-prompt-start))
 456            (ignore-errors (compile-goto-error)))
 457           ((progn (end-of-line) (<= (geiser-repl--nesting-level) 0))
 458            (geiser-repl--send-input))
 459           (t (goto-char p)
 460              (if geiser-repl-auto-indent-p
 461                  (geiser-repl--newline-and-indent)
 462                (insert "\n"))))))
 463
 464 (defun geiser-repl--tab (n)
 465   "If we're after the last prompt, complete symbol or indent (if
 466 there's no symbol at point). Otherwise, go to next error in the REPL
 467 buffer."
 468   (interactive "p")
 469   (if (> (point) (geiser-repl--last-prompt-end))
 470       (geiser-completion--maybe-complete)
 471     (compilation-next-error n)))
 472
 473 (defun geiser-repl--previous-error (n)
 474   "Go to previous error in the REPL buffer."
 475   (interactive "p")
 476   (compilation-next-error (- n)))
 477
 478 (define-derived-mode geiser-repl-mode comint-mode "REPL"
 479   "Major mode for interacting with an inferior scheme repl process.
 480 \\{geiser-repl-mode-map}"
 481   (scheme-mode-variables)
 482   (set (make-local-variable 'mode-line-process) nil)
 483   (set (make-local-variable 'comint-use-prompt-regexp) nil)
 484   (set (make-local-variable 'comint-prompt-read-only)
 485        geiser-repl-read-only-prompt-p)
 486   (set (make-local-variable 'beginning-of-defun-function)
 487        'geiser-repl--beginning-of-defun)
 488   (set (make-local-variable 'comint-input-ignoredups)
 489        geiser-repl-history-no-dups-p)
 490   (setq geiser-eval--get-module-function 'geiser-repl--module-function)
 491   (geiser-company--setup geiser-repl-company-p)
 492   ;; enabling compilation-shell-minor-mode without the annoying highlighter
 493   (compilation-setup t))
 494
 495 (define-key geiser-repl-mode-map "\C-d" 'delete-char)
 496 (define-key geiser-repl-mode-map "\C-m" 'geiser-repl--maybe-send)
 497 (define-key geiser-repl-mode-map [return] 'geiser-repl--maybe-send)
 498 (define-key geiser-repl-mode-map "\C-j" 'geiser-repl--newline-and-indent)
 499 (define-key geiser-repl-mode-map (kbd "TAB") 'geiser-repl--tab)
 500 (define-key geiser-repl-mode-map [backtab] 'geiser-repl--previous-error)
 501
 502 (define-key geiser-repl-mode-map "\C-a" 'geiser-repl--bol)
 503 (define-key geiser-repl-mode-map (kbd "<home>") 'geiser-repl--bol)
 504
 505 (geiser-menu--defmenu repl geiser-repl-mode-map
 506   ("Complete symbol" ((kbd "M-TAB"))
 507    geiser-repl--tab :enable (symbol-at-point))
 508   ("Complete module name" ((kbd "C-.") (kbd "M-`"))
 509    geiser-completion--complete-module :enable (symbol-at-point))
 510   ("Edit symbol" "\M-." geiser-edit-symbol-at-point
 511    :enable (symbol-at-point))
 512   --
 513   ("Switch to module..." "\C-c\C-m" switch-to-geiser-module)
 514   ("Import module..." "\C-c\C-i" geiser-repl-import-module)
 515   --
 516   ("Previous matching input" "\M-p" comint-previous-matching-input-from-input
 517    "Previous input matching current")
 518   ("Next matching input" "\M-n" comint-next-matching-input-from-input
 519    "Next input matching current")
 520   ("Previous input" "\C-c\M-p" comint-previous-input)
 521   ("Next input" "\C-c\M-n" comint-next-input)
 522   --
 523   (mode "Autodoc mode" ("\C-c\C-da" "\C-c\C-d\C-a") geiser-autodoc-mode)
 524   ("Symbol documentation" ("\C-c\C-dd" "\C-c\C-d\C-d")
 525    geiser-doc-symbol-at-point
 526    "Documentation for symbol at point" :enable (symbol-at-point))
 527   ("Module documentation" ("\C-c\C-dm" "\C-c\C-d\C-m") geiser-repl--doc-module
 528    "Documentation for module at point" :enable (symbol-at-point))
 529   --
 530   ("Kill Scheme interpreter" "\C-c\C-q" geiser-repl-exit
 531    :enable (geiser-repl--live-p))
 532   ("Restart" "\C-c\C-z" switch-to-geiser :enable (not (geiser-repl--live-p)))
 533   --
 534   (custom "REPL options" geiser-repl))
 535
 536 (define-key geiser-repl-mode-map [menu-bar completion] 'undefined)
 537
 538 \f
 539 ;;; User commands
 540
 541 (defun run-geiser (impl)
 542   "Start a new Geiser REPL."
 543   (interactive
 544    (list (geiser-repl--get-impl "Start Geiser for scheme implementation: ")))
 545   (geiser-repl--start-repl impl nil))
 546
 547 (defalias 'geiser 'run-geiser)
 548
 549 (defun geiser-connect (impl &optional host port)
 550   "Start a new Geiser REPL connected to a remote Scheme process."
 551   (interactive
 552    (list (geiser-repl--get-impl "Connect to Scheme implementation: ")))
 553   (geiser-repl--start-repl impl
 554                            (geiser-repl--read-address host port)))
 555
 556 (make-variable-buffer-local
 557  (defvar geiser-repl--last-scm-buffer nil))
 558
 559 (defun switch-to-geiser (&optional ask impl buffer)
 560   "Switch to running Geiser REPL.
 561 With prefix argument, ask for which one if more than one is running.
 562 If no REPL is running, execute `run-geiser' to start a fresh one."
 563   (interactive "P")
 564   (let* ((impl (or impl geiser-impl--implementation))
 565          (in-repl (eq major-mode 'geiser-repl-mode))
 566          (in-live-repl (and in-repl (get-buffer-process (current-buffer))))
 567          (repl (cond ((and (not ask)
 568                            (not impl)
 569                            (not in-repl)
 570                            (or geiser-repl--repl (car geiser-repl--repls))))
 571                      ((and (not ask)
 572                            (not in-repl)
 573                            impl
 574                            (geiser-repl--repl/impl impl)))))
 575          (pop-up-windows geiser-repl-window-allow-split))
 576     (cond ((or in-live-repl
 577                (and (eq (current-buffer) repl) (not (eq repl buffer))))
 578            (when (buffer-live-p geiser-repl--last-scm-buffer)
 579              (pop-to-buffer geiser-repl--last-scm-buffer)))
 580           (repl (pop-to-buffer repl))
 581           ((geiser-repl--remote-p) (geiser-connect impl))
 582           (t (run-geiser impl)))
 583     (when (and buffer (eq major-mode 'geiser-repl-mode))
 584       (setq geiser-repl--last-scm-buffer buffer))))
 585
 586 (defun switch-to-geiser-module (&optional module buffer)
 587   "Switch to running Geiser REPL and try to enter a given module."
 588   (interactive)
 589   (let* ((module (or module
 590                      (geiser-completion--read-module
 591                       "Switch to module (default top-level): ")))
 592          (cmd (and module
 593                    (geiser-repl--enter-cmd geiser-impl--implementation
 594                                            module))))
 595     (unless (eq major-mode 'geiser-repl-mode)
 596       (switch-to-geiser nil nil (or buffer (current-buffer))))
 597     (geiser-repl--send cmd)))
 598
 599 (defun geiser-repl-import-module (&optional module)
 600   "Import a given module in the current namespace of the REPL."
 601   (interactive)
 602   (let* ((module (or module
 603                      (geiser-completion--read-module "Import module: ")))
 604          (cmd (and module
 605                    (geiser-repl--import-cmd geiser-impl--implementation
 606                                             module))))
 607     (switch-to-geiser nil nil (current-buffer))
 608     (geiser-repl--send cmd)))
 609
 610 (defun geiser-repl-exit (&optional arg)
 611   "Exit the current REPL.
 612 With a prefix argument, force exit by killing the scheme process."
 613   (interactive "P")
 614   (when (or (not geiser-repl-query-on-exit-p)
 615             (y-or-n-p "Really quit this REPL? "))
 616     (let ((cmd (and (not arg)
 617                     (geiser-repl--exit-cmd geiser-impl--implementation))))
 618       (if cmd
 619           (when (stringp cmd) (geiser-repl--send cmd))
 620         (comint-kill-subjob)))))
 621
 622 \f
 623 ;;; Unload:
 624
 625 (defun geiser-repl--repl-list ()
 626   (let (lst)
 627     (dolist (repl geiser-repl--repls lst)
 628       (when (buffer-live-p repl)
 629         (with-current-buffer repl
 630           (push (cons geiser-impl--implementation
 631                       geiser-repl--address)
 632                 lst))))))
 633
 634 (defun geiser-repl--restore (impls)
 635   (dolist (impl impls)
 636     (when impl
 637       (condition-case err
 638           (geiser-repl--start-repl (car impl) (cdr impl))
 639         (error (message (error-message-string err)))))))
 640
 641 (defun geiser-repl-unload-function ()
 642   (dolist (repl geiser-repl--repls)
 643     (when (buffer-live-p repl)
 644       (with-current-buffer repl
 645         (let ((geiser-repl-query-on-exit-p nil)) (geiser-repl-exit))
 646         (sit-for 0.05)
 647         (kill-buffer)))))
 648
 649 \f
 650 (provide 'geiser-repl)