elisp/geiser-repl.el

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