Silence skeleton.el compilation.

* lisp/skeleton.el (skeleton-internal-list, skeleton-internal-1):
Prefix dynamic local variable `skeleton'.

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 2560b7be083bb534a398cc8e13bd7ec6c61f6383..fea67a367190d50970fd3c3e2023731664c71677 100644 (file)
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -53,6 +53,9 @@
        * eshell/em-glob.el (eshell-extended-glob, eshell-glob-entries):
        Prefix dynamic local variable `matches'.
 
+       * skeleton.el (skeleton-internal-list, skeleton-internal-1):
+       Prefix dynamic local variable `skeleton'.
+
 2010-11-10  Katsumi Yamaoka  <yamaoka@jpl.org>
 
        * net/browse-url.el (browse-url-mail): Insert body part of mailto url

diff --git a/lisp/skeleton.el b/lisp/skeleton.el
index 1888b41c8064d2cdd64050b2fa36ac843c1c288e..c98e06fe76ff6a49f2ce3d866ca7c2d3b93dd4b5 100644 (file)
--- a/lisp/skeleton.el
+++ b/lisp/skeleton.el
@@ -108,7 +108,7 @@ The list describes the most recent skeleton insertion, and its elements
 are integer buffer positions in the reverse order of the insertion order.")
 
 ;; reduce the number of compiler warnings
-(defvar skeleton)
+(defvar skeleton-il)
 (defvar skeleton-modified)
 (defvar skeleton-point)
 (defvar skeleton-regions)
@@ -317,25 +317,26 @@ automatically, and you are prompted to fill in the variable parts.")))
       (signal 'quit t)
     prompt))
 
-(defun skeleton-internal-list (skeleton &optional str recursive)
+(defun skeleton-internal-list (skeleton-il &optional str recursive)
   (let* ((start (line-beginning-position))
         (column (current-column))
         (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) (not recursive)
+       (setq str `(setq str
+                        (skeleton-read ',(car skeleton-il) nil ,recursive))))
+    (when (and (eq (cadr skeleton-il) '\n) (not recursive)
               (save-excursion (skip-chars-backward " \t") (bolp)))
-      (setq skeleton (cons nil (cons '> (cddr skeleton)))))
+      (setq skeleton-il (cons nil (cons '> (cddr skeleton-il)))))
     (while (setq skeleton-modified (eq opoint (point))
                 opoint (point)
-                skeleton (cdr skeleton))
+                skeleton-il (cdr skeleton-il))
       (condition-case quit
-         (skeleton-internal-1 (car skeleton) nil recursive)
+         (skeleton-internal-1 (car skeleton-il) nil recursive)
        (quit
         (if (eq (cdr quit) 'recursive)
             (setq recursive 'quit
-                  skeleton (memq 'resume: skeleton))
+                  skeleton-il (memq 'resume: skeleton-il))
           ;; Remove the subskeleton as far as it has been shown
           ;; the subskeleton shouldn't have deleted outside current line.
           (end-of-line)
@@ -343,7 +344,7 @@ automatically, and you are prompted to fill in the variable parts.")))
           (insert line)
           (move-to-column column)
           (if (cdr quit)
-              (setq skeleton ()
+              (setq skeleton-il ()
                     recursive nil)
             (signal 'quit 'recursive)))))))
   ;; maybe continue loop or go on to next outer resume: section
@@ -365,16 +366,16 @@ automatically, and you are prompted to fill in the variable parts.")))
    ((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)))
+       (and (eq element '>) (eq (nth 1 skeleton-il) '\n) (pop skeleton-il)))
     (let ((pos (if (eq element '>) (point))))
       (cond
-       ((and skeleton-regions (eq (nth 1 skeleton) '_))
+       ((and skeleton-regions (eq (nth 1 skeleton-il) '_))
        (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)) (not recursive) (eolp))
+       ((and (null (cdr skeleton-il)) (not recursive) (eolp))
        (if pos (indent-according-to-mode)))
        (skeleton-newline-indent-rigidly
        (let ((pt (point)))
@@ -387,7 +388,7 @@ automatically, and you are prompted to fill in the variable parts.")))
            (newline)
            (indent-according-to-mode))))))
    ((eq element '>)
-    (if (and skeleton-regions (eq (nth 1 skeleton) '_))
+    (if (and skeleton-regions (eq (nth 1 skeleton-il) '_))
        (indent-region (line-beginning-position)
                       (car skeleton-regions) nil)
       (indent-according-to-mode)))
@@ -396,16 +397,16 @@ automatically, and you are prompted to fill in the variable parts.")))
        (progn
          (goto-char (pop skeleton-regions))
          (and (<= (current-column) (current-indentation))
-              (eq (nth 1 skeleton) '\n)
+              (eq (nth 1 skeleton-il) '\n)
               (end-of-line 0)))
       (or skeleton-point
          (setq skeleton-point (point)))))
    ((eq element '-)
     (setq skeleton-point (point)))
    ((eq element '&)
-    (when skeleton-modified (pop skeleton)))
+    (when skeleton-modified (pop skeleton-il)))
    ((eq element '|)
-    (unless skeleton-modified (pop skeleton)))
+    (unless skeleton-modified (pop skeleton-il)))
    ((eq element '@)
     (push (point) skeleton-positions))
    ((eq 'quote (car-safe element))