(local-variables-section): Adapted comment to outline minor mode.

(skeleton-pair-insert-maybe): Rewritten to support autowrapping.
(mirror-mode): Fixed change of pair-* to skeleton-pair-*.  Also pairs
8 bit characters.

1 files changed, 83 insertions, 82 deletions

diff --git a/lisp/skeleton.el b/lisp/skeleton.el
index 2bb33ee4db6..edea9c4c3e9 100644
--- a/lisp/skeleton.el
+++ b/lisp/skeleton.el
@@ -126,7 +126,7 @@ INTERACTOR and ELEMENT ... are as defined under `skeleton-insert'."
 (defun skeleton-proxy (&optional str arg)
   "Insert skeleton defined by variable of same name (see `skeleton-insert').
 Prefix ARG allows wrapping around words or regions (see `skeleton-insert').
-If no ARG was given, and the region is visible, it defaults to -1 depending
+If no ARG was given, but the region is visible, ARG defaults to -1 depending
 on `skeleton-autowrap'.  An ARG of  M-0  will prevent this just for once.
 This command can also be an abbrev expansion (3rd and 4th columns in
 \\[edit-abbrevs]  buffer: \"\"  command-name).
@@ -158,7 +158,7 @@ ignored."
 			   (and skeleton-autowrap
 				(or (eq last-command 'mouse-drag-region)
 				    (and transient-mark-mode mark-active))
-			       -1)))
+				-1)))
 		       (if (stringp str)
 			   str))
       (and skeleton-abbrev-cleanup
@@ -396,32 +396,32 @@ automatically, and you are prompted to fill in the variable parts.")))
 
 
 ;; Maybe belongs into simple.el or elsewhere
-
-;;;(define-skeleton local-variables-section
-;;;  "Insert a local variables section.  Use current comment syntax if any."
-;;;  (completing-read "Mode: " obarray
-;;;		   (lambda (symbol)
-;;;		     (if (commandp symbol)
-;;;			 (string-match "-mode$" (symbol-name symbol))))
-;;;		   t)
-;;;  '(save-excursion
-;;;     (if (re-search-forward page-delimiter nil t)
-;;;	 (error "Not on last page.")))
-;;;  comment-start "Local Variables:" comment-end \n
-;;;  comment-start "mode: " str
-;;;  & -5 | '(kill-line 0) & -1 | comment-end \n
-;;;  ( (completing-read (format "Variable, %s: " skeleton-subprompt)
-;;;		     obarray
-;;;		     (lambda (symbol)
-;;;		       (or (eq symbol 'eval)
-;;;			   (user-variable-p symbol)))
-;;;		     t)
-;;;    comment-start str ": "
-;;;    (read-from-minibuffer "Expression: " nil read-expression-map nil
-;;;			  'read-expression-history) | _
-;;;    comment-end \n)
-;;;  resume:
-;;;  comment-start "End:" comment-end)
+;; ;###autoload
+;;; (define-skeleton local-variables-section
+;;  "Insert a local variables section.  Use current comment syntax if any."
+;;  (completing-read "Mode: " obarray
+;;		   (lambda (symbol)
+;;		     (if (commandp symbol)
+;;			 (string-match "-mode$" (symbol-name symbol))))
+;;		   t)
+;;  '(save-excursion
+;;     (if (re-search-forward page-delimiter nil t)
+;;	 (error "Not on last page.")))
+;;  comment-start "Local Variables:" comment-end \n
+;;  comment-start "mode: " str
+;;  & -5 | '(kill-line 0) & -1 | comment-end \n
+;;  ( (completing-read (format "Variable, %s: " skeleton-subprompt)
+;;		     obarray
+;;		     (lambda (symbol)
+;;		       (or (eq symbol 'eval)
+;;			   (user-variable-p symbol)))
+;;		     t)
+;;    comment-start str ": "
+;;    (read-from-minibuffer "Expression: " nil read-expression-map nil
+;;			  'read-expression-history) | _
+;;    comment-end \n)
+;;  resume:
+;;  comment-start "End:" comment-end)
 
 ;; Variables and command for automatically inserting pairs like () or "".
 
@@ -452,78 +452,79 @@ Elements might be (?` ?` _ \"''\"), (?\\( ?  _ \" )\") or (?{ \\n > _ \\n ?} >).
 (defun skeleton-pair-insert-maybe (arg)
   "Insert the character you type ARG times.
 
-With no ARG, if `skeleton-pair' is non-nil, and if
-`skeleton-pair-on-word' is non-nil or we are not before or inside a
+With no ARG, if `skeleton-pair' is non-nil, pairing can occur.  If the region
+is visible the pair is wrapped around it depending on `skeleton-autowrap'.
+Else, if `skeleton-pair-on-word' is non-nil or we are not before or inside a
 word, and if `skeleton-pair-filter' returns nil, pairing is performed.
 
 If a match is found in `skeleton-pair-alist', that is inserted, else
 the defaults are used.  These are (), [], {}, <> and `' for the
 symmetrical ones, and the same character twice for the others."
   (interactive "*P")
-  (if (or arg
-	  overwrite-mode
-	  (not skeleton-pair)
-	  (if (not skeleton-pair-on-word) (looking-at "\\w"))
-	  (funcall skeleton-pair-filter))
-      (self-insert-command (prefix-numeric-value arg))
-    (self-insert-command 1)
-    (if skeleton-abbrev-cleanup
-	()
-      ;; (preceding-char) is stripped of any Meta-stuff in last-command-char
-      (if (setq arg (assq (preceding-char) skeleton-pair-alist))
-	  ;; typed char is inserted (car is no real interactor)
-	  (let (skeleton-end-hook)
-	    (skeleton-insert arg))
-	(save-excursion
-	  (insert (or (cdr (assq (preceding-char)
-				 '((?( . ?))
-				   (?[ . ?])
-				   (?{ . ?})
-				   (?< . ?>)
-				   (?` . ?'))))
-		      last-command-char)))))))
+  (let ((mark (and skeleton-autowrap
+		   (or (eq last-command 'mouse-drag-region)
+		       (and transient-mark-mode mark-active))))
+	(skeleton-end-hook))
+    (if (or arg
+	    (not skeleton-pair)
+	    (and (not mark)
+		 (or overwrite-mode
+		     (if (not skeleton-pair-on-word) (looking-at "\\w"))
+		     (funcall skeleton-pair-filter))))
+	(self-insert-command (prefix-numeric-value arg))
+      (setq last-command-char (logand last-command-char 255))
+      (or skeleton-abbrev-cleanup
+	  (skeleton-insert
+	   (cons nil (or (assq last-command-char skeleton-pair-alist)
+			 (assq last-command-char '((?( _ ?))
+						   (?[ _ ?])
+						   (?{ _ ?})
+						   (?< _ ?>)
+						   (?` _ ?')))
+			 `(,last-command-char _ ,last-command-char)))
+	   (if mark -1))))))
 
 
-;;; A more serious example can be found in sh-script.el
-;;;(defun mirror-mode ()
+;; A more serious example can be found in sh-script.el
+;;; (defun mirror-mode ()
 ;;  "This major mode is an amusing little example of paired insertion.
 ;;All printable characters do a paired self insert, while the other commands
 ;;work normally."
 ;;  (interactive)
 ;;  (kill-all-local-variables)
-;;  (make-local-variable 'pair)
-;;  (make-local-variable 'pair-on-word)
-;;  (make-local-variable 'pair-filter)
-;;  (make-local-variable 'pair-alist)
+;;  (make-local-variable 'skeleton-pair)
+;;  (make-local-variable 'skeleton-pair-on-word)
+;;  (make-local-variable 'skeleton-pair-filter)
+;;  (make-local-variable 'skeleton-pair-alist)
 ;;  (setq major-mode 'mirror-mode
 ;;	mode-name "Mirror"
-;;	pair-on-word t
+;;	skeleton-pair-on-word t
 ;;	;; in the middle column insert one or none if odd window-width
-;;	pair-filter (lambda ()
-;;		      (if (>= (current-column)
-;;			      (/ (window-width) 2))
-;;			  ;; insert both on next line
-;;			  (next-line 1)
-;;			;; insert one or both?
-;;			(= (* 2 (1+ (current-column)))
-;;			   (window-width))))
+;;	skeleton-pair-filter (lambda ()
+;;			       (if (>= (current-column)
+;;				       (/ (window-width) 2))
+;;				   ;; insert both on next line
+;;				   (next-line 1)
+;;				 ;; insert one or both?
+;;				 (= (* 2 (1+ (current-column)))
+;;				    (window-width))))
 ;;	;; mirror these the other way round as well
-;;	pair-alist '((?) _ ?()
-;;		     (?] _ ?[)
-;;		     (?} _ ?{)
-;;		     (?> _ ?<)
-;;		     (?/ _ ?\\)
-;;		     (?\\ _ ?/)
-;;		     (?` ?` _ "''")
-;;		     (?' ?' _ "``"))
+;;	skeleton-pair-alist '((?) _ ?()
+;;			      (?] _ ?[)
+;;			      (?} _ ?{)
+;;			      (?> _ ?<)
+;;			      (?/ _ ?\\)
+;;			      (?\\ _ ?/)
+;;			      (?` ?` _ "''")
+;;			      (?' ?' _ "``"))
 ;;	;; in this mode we exceptionally ignore the user, else it's no fun
-;;	pair t)
-;;  (let ((map (make-keymap))
-;;	(i ? ))
-;;    (use-local-map map)
-;;    (setq map (car (cdr map)))
-;;    (while (< i ?\^?)
-;;      (aset map i 'skeleton-pair-insert-maybe)
+;;	skeleton-pair t)
+;;  (let ((map (make-vector 256 'skeleton-pair-insert-maybe))
+;;	(i 0))
+;;    (use-local-map `(keymap ,map))
+;;    (while (< i ? )
+;;      (aset map i nil)
+;;      (aset map (+ i 128) nil)
 ;;      (setq i (1+ i))))
 ;;  (run-hooks 'mirror-mode-hook))