You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
183 lines
7.1 KiB
183 lines
7.1 KiB
(require 'slime)
|
|
(require 'slime-repl)
|
|
(require 'cl-lib)
|
|
|
|
(define-slime-contrib slime-editing-commands
|
|
"Editing commands without server interaction."
|
|
(:authors "Thomas F. Burdick <tfb@OCF.Berkeley.EDU>"
|
|
"Luke Gorrie <luke@synap.se>"
|
|
"Bill Clementson <billclem@gmail.com>"
|
|
"Tobias C. Rittweiler <tcr@freebits.de>")
|
|
(:license "GPL")
|
|
(:on-load
|
|
(define-key slime-mode-map "\M-\C-a" 'slime-beginning-of-defun)
|
|
(define-key slime-mode-map "\M-\C-e" 'slime-end-of-defun)
|
|
(define-key slime-mode-map "\C-c\M-q" 'slime-reindent-defun)
|
|
(define-key slime-mode-map "\C-c\C-]" 'slime-close-all-parens-in-sexp)))
|
|
|
|
(defun slime-beginning-of-defun ()
|
|
(interactive)
|
|
(if (and (boundp 'slime-repl-input-start-mark)
|
|
slime-repl-input-start-mark)
|
|
(slime-repl-beginning-of-defun)
|
|
(let ((this-command 'beginning-of-defun)) ; needed for push-mark
|
|
(call-interactively 'beginning-of-defun))))
|
|
|
|
(defun slime-end-of-defun ()
|
|
(interactive)
|
|
(if (eq major-mode 'slime-repl-mode)
|
|
(slime-repl-end-of-defun)
|
|
(end-of-defun)))
|
|
|
|
(defvar slime-comment-start-regexp
|
|
"\\(\\(^\\|[^\n\\\\]\\)\\([\\\\][\\\\]\\)*\\);+[ \t]*"
|
|
"Regexp to match the start of a comment.")
|
|
|
|
(defun slime-beginning-of-comment ()
|
|
"Move point to beginning of comment.
|
|
If point is inside a comment move to beginning of comment and return point.
|
|
Otherwise leave point unchanged and return NIL."
|
|
(let ((boundary (point)))
|
|
(beginning-of-line)
|
|
(cond ((re-search-forward slime-comment-start-regexp boundary t)
|
|
(point))
|
|
(t (goto-char boundary)
|
|
nil))))
|
|
|
|
(defvar slime-close-parens-limit nil
|
|
"Maxmimum parens for `slime-close-all-sexp' to insert. NIL
|
|
means to insert as many parentheses as necessary to correctly
|
|
close the form.")
|
|
|
|
(defun slime-close-all-parens-in-sexp (&optional region)
|
|
"Balance parentheses of open s-expressions at point.
|
|
Insert enough right parentheses to balance unmatched left parentheses.
|
|
Delete extra left parentheses. Reformat trailing parentheses
|
|
Lisp-stylishly.
|
|
|
|
If REGION is true, operate on the region. Otherwise operate on
|
|
the top-level sexp before point."
|
|
(interactive "P")
|
|
(let ((sexp-level 0)
|
|
point)
|
|
(save-excursion
|
|
(save-restriction
|
|
(when region
|
|
(narrow-to-region (region-beginning) (region-end))
|
|
(goto-char (point-max)))
|
|
;; skip over closing parens, but not into comment
|
|
(skip-chars-backward ") \t\n")
|
|
(when (slime-beginning-of-comment)
|
|
(forward-line)
|
|
(skip-chars-forward " \t"))
|
|
(setq point (point))
|
|
;; count sexps until either '(' or comment is found at first column
|
|
(while (and (not (looking-at "^[(;]"))
|
|
(ignore-errors (backward-up-list 1) t))
|
|
(incf sexp-level))))
|
|
(when (> sexp-level 0)
|
|
;; insert correct number of right parens
|
|
(goto-char point)
|
|
(dotimes (i sexp-level) (insert ")"))
|
|
;; delete extra right parens
|
|
(setq point (point))
|
|
(skip-chars-forward " \t\n)")
|
|
(skip-chars-backward " \t\n")
|
|
(let* ((deleted-region (delete-and-extract-region point (point)))
|
|
(deleted-text (substring-no-properties deleted-region))
|
|
(prior-parens-count (cl-count ?\) deleted-text)))
|
|
;; Remember: we always insert as many parentheses as necessary
|
|
;; and only afterwards delete the superfluously-added parens.
|
|
(when slime-close-parens-limit
|
|
(let ((missing-parens (- sexp-level prior-parens-count
|
|
slime-close-parens-limit)))
|
|
(dotimes (i (max 0 missing-parens))
|
|
(delete-char -1))))))))
|
|
|
|
(defun slime-insert-balanced-comments (arg)
|
|
"Insert a set of balanced comments around the s-expression
|
|
containing the point. If this command is invoked repeatedly
|
|
\(without any other command occurring between invocations), the
|
|
comment progressively moves outward over enclosing expressions.
|
|
If invoked with a positive prefix argument, the s-expression arg
|
|
expressions out is enclosed in a set of balanced comments."
|
|
(interactive "*p")
|
|
(save-excursion
|
|
(when (eq last-command this-command)
|
|
(when (search-backward "#|" nil t)
|
|
(save-excursion
|
|
(delete-char 2)
|
|
(while (and (< (point) (point-max)) (not (looking-at " *|#")))
|
|
(forward-sexp))
|
|
(replace-match ""))))
|
|
(while (> arg 0)
|
|
(backward-char 1)
|
|
(cond ((looking-at ")") (incf arg))
|
|
((looking-at "(") (decf arg))))
|
|
(insert "#|")
|
|
(forward-sexp)
|
|
(insert "|#")))
|
|
|
|
(defun slime-remove-balanced-comments ()
|
|
"Remove a set of balanced comments enclosing point."
|
|
(interactive "*")
|
|
(save-excursion
|
|
(when (search-backward "#|" nil t)
|
|
(delete-char 2)
|
|
(while (and (< (point) (point-max)) (not (looking-at " *|#")))
|
|
(forward-sexp))
|
|
(replace-match ""))))
|
|
|
|
|
|
;; SLIME-CLOSE-PARENS-AT-POINT is obsolete:
|
|
|
|
;; It doesn't work correctly on the REPL, because there
|
|
;; BEGINNING-OF-DEFUN-FUNCTION and END-OF-DEFUN-FUNCTION is bound to
|
|
;; SLIME-REPL-MODE-BEGINNING-OF-DEFUN (and
|
|
;; SLIME-REPL-MODE-END-OF-DEFUN respectively) which compromises the
|
|
;; way how they're expect to work (i.e. END-OF-DEFUN does not signal
|
|
;; an UNBOUND-PARENTHESES error.)
|
|
|
|
;; Use SLIME-CLOSE-ALL-PARENS-IN-SEXP instead.
|
|
|
|
;; (defun slime-close-parens-at-point ()
|
|
;; "Close parenthesis at point to complete the top-level-form. Simply
|
|
;; inserts ')' characters at point until `beginning-of-defun' and
|
|
;; `end-of-defun' execute without errors, or `slime-close-parens-limit'
|
|
;; is exceeded."
|
|
;; (interactive)
|
|
;; (loop for i from 1 to slime-close-parens-limit
|
|
;; until (save-excursion
|
|
;; (slime-beginning-of-defun)
|
|
;; (ignore-errors (slime-end-of-defun) t))
|
|
;; do (insert ")")))
|
|
|
|
(defun slime-reindent-defun (&optional force-text-fill)
|
|
"Reindent the current defun, or refill the current paragraph.
|
|
If point is inside a comment block, the text around point will be
|
|
treated as a paragraph and will be filled with `fill-paragraph'.
|
|
Otherwise, it will be treated as Lisp code, and the current defun
|
|
will be reindented. If the current defun has unbalanced parens,
|
|
an attempt will be made to fix it before reindenting.
|
|
|
|
When given a prefix argument, the text around point will always
|
|
be treated as a paragraph. This is useful for filling docstrings."
|
|
(interactive "P")
|
|
(save-excursion
|
|
(if (or force-text-fill (slime-beginning-of-comment))
|
|
(fill-paragraph nil)
|
|
(let ((start (progn (unless (or (and (zerop (current-column))
|
|
(eq ?\( (char-after)))
|
|
(and slime-repl-input-start-mark
|
|
(slime-repl-at-prompt-start-p)))
|
|
(slime-beginning-of-defun))
|
|
(point)))
|
|
(end (ignore-errors (slime-end-of-defun) (point))))
|
|
(unless end
|
|
(forward-paragraph)
|
|
(slime-close-all-parens-in-sexp)
|
|
(slime-end-of-defun)
|
|
(setf end (point)))
|
|
(indent-region start end nil)))))
|
|
|
|
(provide 'slime-editing-commands)
|