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