(skeleton-transformation): Default to `identity'.

(skeleton-insert): Use `move-after' markers and `insert' rather
than rely on insert-before-markers.
(skeleton-internal-1): Handle `> \n' specially so that the newline
is inserted before the first line is indented.

1 files changed, 79 insertions, 70 deletions

diff --git a/lisp/skeleton.el b/lisp/skeleton.el
index 9c5d7173cd6..2b31194e7f1 100644
--- a/lisp/skeleton.el
+++ b/lisp/skeleton.el
@@ -38,7 +38,7 @@
 ;; page 3:	mirror-mode, an example for setting up paired insertion
 
 
-(defvar skeleton-transformation nil
+(defvar skeleton-transformation 'identity
   "*If non-nil, function applied to literal strings before they are inserted.
 It should take strings and characters and return them transformed, or nil
 which means no transformation.
@@ -301,17 +301,16 @@ When done with skeleton, but before going back to `_'-point call
     (and skeleton-regions
 	 (setq skeleton-regions
 	       (if (> skeleton-regions 0)
-		   (list (point-marker)
+		   (list (copy-marker (point) t)
 			 (save-excursion (forward-word skeleton-regions)
 					 (point-marker)))
 		 (setq skeleton-regions (- skeleton-regions))
 		 ;; copy skeleton-regions - 1 elements from `mark-ring'
 		 (let ((l1 (cons (mark-marker) mark-ring))
-		       (l2 (list (point-marker))))
+		       (l2 (list (copy-marker (point) t))))
 		   (while (and l1 (> skeleton-regions 0))
-		     (setq l2 (cons (car l1) l2)
-			   skeleton-regions (1- skeleton-regions)
-			   l1 (cdr l1)))
+		     (push (copy-marker (pop l1) t) l2)
+		     (setq skeleton-regions (1- skeleton-regions)))
 		   (sort l2 '<))))
 	 (goto-char (car skeleton-regions))
 	 (setq skeleton-regions (cdr skeleton-regions)))
@@ -378,13 +377,12 @@ automatically, and you are prompted to fill in the variable parts.")))
 (defun skeleton-internal-list (skeleton &optional str recursive)
   (let* ((start (save-excursion (beginning-of-line) (point)))
 	 (column (current-column))
-	 (line (buffer-substring start
-				 (save-excursion (end-of-line) (point))))
+	 (line (buffer-substring start (line-end-position)))
 	 opoint)
     (or str
 	(setq str `(setq str (skeleton-read ',(car skeleton) nil ,recursive))))
     (when (and (eq (cadr skeleton) '\n)
-	       (<= (current-column) (current-indentation)))
+	       (save-excursion (skip-chars-backward " \t") (bolp)))
       (setq skeleton (cons nil (cons '> (cddr skeleton)))))
     (while (setq skeleton-modified (eq opoint (point))
 		 opoint (point)
@@ -395,8 +393,8 @@ automatically, and you are prompted to fill in the variable parts.")))
 	 (if (eq (cdr quit) 'recursive)
 	     (setq recursive 'quit
 		   skeleton (memq 'resume: skeleton))
-	   ;; remove the subskeleton as far as it has been shown
-	   ;; the subskeleton shouldn't have deleted outside current line
+	   ;; Remove the subskeleton as far as it has been shown
+	   ;; the subskeleton shouldn't have deleted outside current line.
 	   (end-of-line)
 	   (delete-region start (point))
 	   (insert line)
@@ -410,68 +408,79 @@ automatically, and you are prompted to fill in the variable parts.")))
       (signal 'quit 'recursive)
     recursive))
 
-
 (defun skeleton-internal-1 (element &optional literal)
-  (cond ((char-or-string-p element)
-	 (if (and (integerp element)	; -num
-		  (< element 0))
-	     (if skeleton-untabify
-		 (backward-delete-char-untabify (- element))
-	       (delete-backward-char (- element)))
-	   (insert-before-markers (if (and skeleton-transformation
-					   (not literal))
-				      (funcall skeleton-transformation element)
-				    element))))
-	((eq element '\n)		; actually (eq '\n 'n)
-	 (cond
-	  ((and skeleton-regions (eq (nth 1 skeleton) '_))
-	   (or (eolp) (newline))
-	   (indent-region (line-beginning-position)
-			  (car skeleton-regions) nil))
-	  ;; \n as last element only inserts \n if not at eol.
-	  ((and (null (cdr skeleton)) (eolp)) nil)
-	  (skeleton-newline-indent-rigidly
-	   (indent-to (prog1 (current-indentation) (newline))))
-	  (t (newline) (indent-according-to-mode))))
-	((eq element '>)
-	 (if (and skeleton-regions (eq (nth 1 skeleton) '_))
-	     (indent-region (line-beginning-position)
-			    (car skeleton-regions) nil)
-	   (indent-according-to-mode)))
-	((eq element '_)
-	 (if skeleton-regions
-	     (progn
-	       (goto-char (car skeleton-regions))
-	       (setq skeleton-regions (cdr skeleton-regions))
-	       (and (<= (current-column) (current-indentation))
-		    (eq (nth 1 skeleton) '\n)
-		    (end-of-line 0)))
-	   (or skeleton-point
-	       (setq skeleton-point (point)))))
+  (cond
+   ((char-or-string-p element)
+    (if (and (integerp element)		; -num
+	     (< element 0))
+	(if skeleton-untabify
+	    (backward-delete-char-untabify (- element))
+	  (delete-backward-char (- element)))
+      (insert (if (and skeleton-transformation
+		       (not literal))
+		  (funcall skeleton-transformation element)
+		element))))
+   ((or (eq element '\n)			; actually (eq '\n 'n)
+	;; The sequence `> \n' is handled specially so as to indent the first
+	;; line after inserting the newline (to get the proper indentation).
+	(and (eq element '>) (eq (nth 1 skeleton) '\n) (pop skeleton)))
+    (let ((pos (if (eq element '>) (point))))
+      (cond
+       ((and skeleton-regions (eq (nth 1 skeleton) '_))
+	(or (eolp) (newline))
+	(if pos (save-excursion (goto-char pos) (indent-according-to-mode)))
+	(indent-region (line-beginning-position)
+		       (car skeleton-regions) nil))
+       ;; \n as last element only inserts \n if not at eol.
+       ((and (null (cdr skeleton)) (eolp))
+	(if pos (indent-according-to-mode)))
+       (skeleton-newline-indent-rigidly
+	(let ((pt (point)))
+	  (newline)
+	  (indent-to (save-excursion
+		       (goto-char pt)
+		       (if pos (indent-according-to-mode))
+		       (current-indentation)))))
+       (t (if pos (reindent-then-newline-and-indent)
+	    (newline)
+	    (indent-according-to-mode))))))
+   ((eq element '>)
+    (if (and skeleton-regions (eq (nth 1 skeleton) '_))
+	(indent-region (line-beginning-position)
+		       (car skeleton-regions) nil)
+      (indent-according-to-mode)))
+   ((eq element '_)
+    (if skeleton-regions
+	(progn
+	  (goto-char (pop skeleton-regions))
+	  (and (<= (current-column) (current-indentation))
+	       (eq (nth 1 skeleton) '\n)
+	       (end-of-line 0)))
+      (or skeleton-point
+	  (setq skeleton-point (point)))))
 	((eq element '&)
-	 (when skeleton-modified (pop skeleton)))
-	((eq element '|)
-	 (unless skeleton-modified (pop skeleton)))
-	((eq element '@)
-	 (push (point) skeleton-positions)
-	 (unless skeleton-point (setq skeleton-point (point))))
-	((eq 'quote (car-safe element))
-	 (eval (nth 1 element)))
-	((or (stringp (car-safe element))
-	     (consp (car-safe element)))
-	 (if (symbolp (car-safe (car element)))
-	     (while (skeleton-internal-list element nil t))
-	   (setq literal (car element))
-	   (while literal
-	     (skeleton-internal-list element (car literal))
-	     (setq literal (cdr literal)))))
-	((null element))
-	((skeleton-internal-1 (eval element) t))))
-
-
+    (when skeleton-modified (pop skeleton)))
+   ((eq element '|)
+    (unless skeleton-modified (pop skeleton)))
+   ((eq element '@)
+    (push (point) skeleton-positions)
+    (unless skeleton-point (setq skeleton-point (point))))
+   ((eq 'quote (car-safe element))
+    (eval (nth 1 element)))
+   ((or (stringp (car-safe element))
+	(consp (car-safe element)))
+    (if (symbolp (car-safe (car element)))
+	(while (skeleton-internal-list element nil t))
+      (setq literal (car element))
+      (while literal
+	(skeleton-internal-list element (car literal))
+	(setq literal (cdr literal)))))
+   ((null element))
+   (t (skeleton-internal-1 (eval element) t))))
+
 ;; Maybe belongs into simple.el or elsewhere
-;; ;###autoload
-;;; (define-skeleton local-variables-section
+;; ;;;###autoload
+;; (define-skeleton local-variables-section
 ;;  "Insert a local variables section.  Use current comment syntax if any."
 ;;  (completing-read "Mode: " obarray
 ;;		   (lambda (symbol)