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