X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/a075a2c5a6e2a9807fdfb3f146d8578da70ea9ef..a35287ea23112e3e6dc73de6066f31fbe1cb269c:/lisp/electric.el diff --git a/lisp/electric.el b/lisp/electric.el index 50c9010a74..9a89587ff9 100644 --- a/lisp/electric.el +++ b/lisp/electric.el @@ -1,6 +1,7 @@ ;;; electric.el --- window maker and Command loop for `electric' modes -;; Copyright (C) 1985-1986, 1995, 2001-2012 Free Software Foundation, Inc. +;; Copyright (C) 1985-1986, 1995, 2001-2013 Free Software Foundation, +;; Inc. ;; Author: K. Shane Hartman ;; Maintainer: FSF @@ -38,8 +39,6 @@ ;;; Code: -(eval-when-compile (require 'cl)) - ;; This loop is the guts for non-standard modes which retain control ;; until some event occurs. It is a `do-forever', the only way out is ;; to throw. It assumes that you have set up the keymap, window, and @@ -79,8 +78,6 @@ (setq last-command-event (aref cmd (1- (length cmd))) this-command (key-binding cmd t) cmd this-command) - ;; This makes universal-argument-other-key work. - (setq universal-argument-num-events 0) (if (or (prog1 quit-flag (setq quit-flag nil)) (eq last-input-event ?\C-g)) (progn (setq unread-command-events nil @@ -190,7 +187,7 @@ Returns nil when we can't find this char." (eq (char-before) last-command-event))))) pos))) -;; Electric indentation. +;;; Electric indentation. ;; Autoloading variables is generally undesirable, but major modes ;; should usually set this variable by adding elements to the default @@ -205,6 +202,20 @@ Each function is called with one argument (the inserted char), with point right after that char, and it should return t to cause indentation, `no-indent' to prevent indentation or nil to let other functions decide.") +(defvar-local electric-indent-inhibit nil + "If non-nil, reindentation is not appropriate for this buffer. +This should be set by major modes such as `python-mode' since +Python does not lend itself to fully automatic indentation.") + +(defvar electric-indent-functions-without-reindent + '(indent-relative indent-to-left-margin indent-relative-maybe + py-indent-line coffee-indent-line org-indent-line + haskell-indentation-indent-line haskell-indent-cycle haskell-simple-indent) + "List of indent functions that can't reindent. +If `line-indent-function' is one of those, then `electric-indent-mode' will +not try to reindent lines. It is normally better to make the major +mode set `electric-indent-inhibit', but this can be used as a workaround.") + (defun electric-indent-post-self-insert-function () ;; FIXME: This reindents the current line, but what we really want instead is ;; to reindent the whole affected text. That's the current line for simple @@ -215,6 +226,7 @@ point right after that char, and it should return t to cause indentation, ;; it looks challenging. (let (pos) (when (and + electric-indent-mode ;; Don't reindent while inserting spaces at beginning of line. (or (not (memq last-command-event '(?\s ?\t))) (save-excursion (skip-chars-backward " \t") (not (bolp)))) @@ -231,12 +243,12 @@ point right after that char, and it should return t to cause indentation, (unless (eq act 'do-indent) (nth 8 (syntax-ppss)))))))) ;; For newline, we want to reindent both lines and basically behave like ;; reindent-then-newline-and-indent (whose code we hence copied). - (when (< (1- pos) (line-beginning-position)) + (when (<= pos (line-beginning-position)) (let ((before (copy-marker (1- pos) t))) (save-excursion - (unless (memq indent-line-function - '(indent-relative indent-to-left-margin - indent-relative-maybe)) + (unless (or (memq indent-line-function + electric-indent-functions-without-reindent) + electric-indent-inhibit) ;; Don't reindent the previous line if the indentation function ;; is not a real one. (goto-char before) @@ -247,10 +259,12 @@ point right after that char, and it should return t to cause indentation, ;; whereas we need `move after insertion', so we do the ;; save/restore by hand. (goto-char before) - ;; Remove the trailing whitespace after indentation because - ;; indentation may (re)introduce the whitespace. - (delete-horizontal-space t)))) - (unless (memq indent-line-function '(indent-to-left-margin)) + (when (eolp) + ;; Remove the trailing whitespace after indentation because + ;; indentation may (re)introduce the whitespace. + (delete-horizontal-space t))))) + (unless (and electric-indent-inhibit + (> pos (line-beginning-position))) (indent-according-to-mode))))) ;;;###autoload @@ -264,7 +278,6 @@ This is a global minor mode. When enabled, it reindents whenever the hook `electric-indent-functions' returns non-nil, or you insert a character from `electric-indent-chars'." :global t - :group 'electricity (if (not electric-indent-mode) (remove-hook 'post-self-insert-hook #'electric-indent-post-self-insert-function) @@ -283,12 +296,24 @@ insert a character from `electric-indent-chars'." (delq #'electric-indent-post-self-insert-function (cdr bp)))))))) -;; Electric pairing. +;;;###autoload +(define-minor-mode electric-indent-local-mode + "Toggle `electric-indent-mode' only in this buffer." + :variable (buffer-local-value 'electric-indent-mode (current-buffer)) + (cond + ((eq electric-indent-mode (default-value 'electric-indent-mode)) + (kill-local-variable 'electric-indent-mode)) + ((not (default-value 'electric-indent-mode)) + ;; Locally enabled, but globally disabled. + (electric-indent-mode 1) ; Setup the hooks. + (setq-default electric-indent-mode nil) ; But keep it globally disabled. + ))) + +;;; Electric pairing. (defcustom electric-pair-pairs '((?\" . ?\")) "Alist of pairs that should be used regardless of major mode." - :group 'electricity :version "24.1" :type '(repeat (cons character character))) @@ -298,47 +323,83 @@ When inserting a closing paren character right before the same character, just skip that character instead, so that hitting ( followed by ) results in \"()\" rather than \"())\". This can be convenient for people who find it easier to hit ) than C-f." - :group 'electricity :version "24.1" :type 'boolean) +(defcustom electric-pair-inhibit-predicate + #'electric-pair-default-inhibit + "Predicate to prevent insertion of a matching pair. +The function is called with a single char (the opening char just inserted). +If it returns non-nil, then `electric-pair-mode' will not insert a matching +closer." + :version "24.4" + :type '(choice + (const :tag "Default" electric-pair-default-inhibit) + (const :tag "Always pair" ignore) + function)) + +(defun electric-pair-default-inhibit (char) + (or + ;; I find it more often preferable not to pair when the + ;; same char is next. + (eq char (char-after)) + ;; Don't pair up when we insert the second of "" or of ((. + (and (eq char (char-before)) + (eq char (char-before (1- (point))))) + ;; I also find it often preferable not to pair next to a word. + (eq (char-syntax (following-char)) ?w))) + +(defun electric-pair-syntax (command-event) + (let ((x (assq command-event electric-pair-pairs))) + (cond + (x (if (eq (car x) (cdr x)) ?\" ?\()) + ((rassq command-event electric-pair-pairs) ?\)) + ((nth 8 (syntax-ppss)) + (with-syntax-table text-mode-syntax-table (char-syntax command-event))) + (t (char-syntax command-event))))) + +(defun electric-pair--insert (char) + (let ((last-command-event char) + (blink-matching-paren nil) + (electric-pair-mode nil)) + (self-insert-command 1))) + (defun electric-pair-post-self-insert-function () - (let* ((syntax (and (eq (char-before) last-command-event) ; Sanity check. - electric-pair-mode - (let ((x (assq last-command-event electric-pair-pairs))) - (cond - (x (if (eq (car x) (cdr x)) ?\" ?\()) - ((rassq last-command-event electric-pair-pairs) ?\)) - (t (char-syntax last-command-event)))))) - ;; FIXME: when inserting the closer, we should maybe use - ;; self-insert-command, although it may prove tricky running - ;; post-self-insert-hook recursively, and we wouldn't want to trigger - ;; blink-matching-open. + (let* ((pos (and electric-pair-mode (electric--after-char-pos))) + (syntax (and pos (electric-pair-syntax last-command-event))) (closer (if (eq syntax ?\() (cdr (or (assq last-command-event electric-pair-pairs) (aref (syntax-table) last-command-event))) last-command-event))) (cond + ((null pos) nil) ;; Wrap a pair around the active region. ((and (memq syntax '(?\( ?\" ?\$)) (use-region-p)) - (if (> (mark) (point)) - (goto-char (mark)) - ;; We already inserted the open-paren but at the end of the region, - ;; so we have to remove it and start over. - (delete-char -1) - (save-excursion + ;; FIXME: To do this right, we'd need a post-self-insert-function + ;; so we could add-function around it and insert the closer after + ;; all the rest of the hook has run. + (if (>= (mark) (point)) + (goto-char (mark)) + ;; We already inserted the open-paren but at the end of the + ;; region, so we have to remove it and start over. + (delete-region (1- pos) (point)) + (save-excursion (goto-char (mark)) - (insert last-command-event))) + (electric-pair--insert last-command-event))) + ;; Since we're right after the closer now, we could tell the rest of + ;; post-self-insert-hook that we inserted `closer', but then we'd get + ;; blink-paren to kick in, which is annoying. + ;;(setq last-command-event closer) (insert closer)) ;; Backslash-escaped: no pairing, no skipping. ((save-excursion - (goto-char (1- (point))) + (goto-char (1- pos)) (not (zerop (% (skip-syntax-backward "\\") 2)))) nil) ;; Skip self. ((and (memq syntax '(?\) ?\" ?\$)) electric-pair-skip-self - (eq (char-after) last-command-event)) + (eq (char-after pos) last-command-event)) ;; This is too late: rather than insert&delete we'd want to only skip (or ;; insert in overwrite mode). The difference is in what goes in the ;; undo-log and in the intermediate state which might be visible to other @@ -347,13 +408,12 @@ This can be convenient for people who find it easier to hit ) than C-f." ;; Insert matching pair. ((not (or (not (memq syntax `(?\( ?\" ?\$))) overwrite-mode - ;; I find it more often preferable not to pair when the - ;; same char is next. - (eq last-command-event (char-after)) - (eq last-command-event (char-before (1- (point)))) - ;; I also find it often preferable not to pair next to a word. - (eq (char-syntax (following-char)) ?w))) - (save-excursion (insert closer)))))) + (funcall electric-pair-inhibit-predicate last-command-event))) + (save-excursion (electric-pair--insert closer)))))) + +(defun electric-pair-will-use-region () + (and (use-region-p) + (memq (electric-pair-syntax last-command-event) '(?\( ?\" ?\$)))) ;;;###autoload (define-minor-mode electric-pair-mode @@ -368,14 +428,18 @@ closing parenthesis. \(Likewise for brackets, etc.) See options `electric-pair-pairs' and `electric-pair-skip-self'." :global t - :group 'electricity (if electric-pair-mode - (add-hook 'post-self-insert-hook - #'electric-pair-post-self-insert-function) + (progn + (add-hook 'post-self-insert-hook + #'electric-pair-post-self-insert-function) + (add-hook 'self-insert-uses-region-functions + #'electric-pair-will-use-region)) (remove-hook 'post-self-insert-hook - #'electric-pair-post-self-insert-function))) + #'electric-pair-post-self-insert-function) + (remove-hook 'self-insert-uses-region-functions + #'electric-pair-will-use-region))) -;; Automatically add newlines after/before/around some chars. +;;; Electric newlines after/before/around some chars. (defvar electric-layout-rules '() "List of rules saying where to automatically insert newlines. @@ -393,16 +457,16 @@ arguments that returns one of those symbols.") (not (nth 8 (save-excursion (syntax-ppss pos))))) (let ((end (copy-marker (point) t))) (goto-char pos) - (case (if (functionp rule) (funcall rule) rule) + (pcase (if (functionp rule) (funcall rule) rule) ;; FIXME: we used `newline' down here which called ;; self-insert-command and ran post-self-insert-hook recursively. ;; It happened to make electric-indent-mode work automatically with ;; electric-layout-mode (at the cost of re-indenting lines ;; multiple times), but I'm not sure it's what we want. - (before (goto-char (1- pos)) (skip-chars-backward " \t") + (`before (goto-char (1- pos)) (skip-chars-backward " \t") (unless (bolp) (insert "\n"))) - (after (insert "\n")) ; FIXME: check eolp before inserting \n? - (around (save-excursion + (`after (insert "\n")) ; FIXME: check eolp before inserting \n? + (`around (save-excursion (goto-char (1- pos)) (skip-chars-backward " \t") (unless (bolp) (insert "\n"))) (insert "\n"))) ; FIXME: check eolp before inserting \n? @@ -416,7 +480,6 @@ positive, and disable it otherwise. If called from Lisp, enable the mode if ARG is omitted or nil. The variable `electric-layout-rules' says when and how to insert newlines." :global t - :group 'electricity (if electric-layout-mode (add-hook 'post-self-insert-hook #'electric-layout-post-self-insert-function)