[bpt/emacs.git] / lisp / saveplace.el

;;; saveplace.el --- automatically save place in files

;; Copyright (C) 1993, 1994, 2001, 2002, 2003, 2004,
;;   2005, 2006, 2007 Free Software Foundation, Inc.

;; Author: Karl Fogel <kfogel@red-bean.com>
;; Maintainer: FSF
;; Created: July, 1993
;; Keywords: bookmarks, placeholders

;; This file is part of GNU Emacs.

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.

;;; Commentary:

;; Automatically save place in files, so that visiting them later
;; (even during a different Emacs session) automatically moves point
;; to the saved position, when the file is first found.  Uses the
;; value of buffer-local variable save-place to determine whether to
;; save position or not.
;;
;; Thanks to Stefan Schoef, who sent a patch with the
;; `save-place-version-control' stuff in it.

;;; Code:

;; this is what I was using during testing:
;; (define-key ctl-x-map "p" 'toggle-save-place)

(defgroup save-place nil
  "Automatically save place in files."
  :group 'data)


(defvar save-place-alist nil
  "Alist of saved places to go back to when revisiting files.
Each element looks like (FILENAME . POSITION);
visiting file FILENAME goes automatically to position POSITION
rather than the beginning of the buffer.
This alist is saved between Emacs sessions.")

(defcustom save-place nil
  "*Non-nil means automatically save place in each file.
This means when you visit a file, point goes to the last place
where it was when you previously visited the same file.
This variable is automatically buffer-local.

If you wish your place in any file to always be automatically saved,
simply put this in your `~/.emacs' file:

\(setq-default save-place t)
\(require 'saveplace)

or else use the Custom facility to set this option."
  :type 'boolean
  :require 'saveplace
  :group 'save-place)

(make-variable-buffer-local 'save-place)

(defcustom save-place-file (convert-standard-filename "~/.emacs-places")
  "*Name of the file that records `save-place-alist' value."
  :type 'file
  :group 'save-place)

(defcustom save-place-version-control nil
  "*Controls whether to make numbered backups of master save-place file.
It can have four values: t, nil, `never', and `nospecial'.  The first
three have the same meaning that they do for the variable
`version-control', and the final value `nospecial' means just use the
value of `version-control'."
  :type '(radio (const :tag "Unconditionally" t)
		(const :tag "For VC Files" nil)
		(const never)
		(const :tag "Use value of `version-control'" nospecial))
  :group 'save-place)

(defvar save-place-loaded nil
  "Non-nil means that the `save-place-file' has been loaded.")

(defcustom save-place-limit nil
  "Maximum number of entries to retain in the list; nil means no limit."
  :type '(choice (integer :tag "Entries" :value 1)
		 (const :tag "No Limit" nil))
  :group 'save-place)

(defcustom save-place-forget-unreadable-files t
  "Non-nil means forget place in unreadable files.

The filenames in `save-place-alist' that do not match
`save-place-skip-check-regexp' are filtered through
`file-readable-p'. if nil, their alist entries are removed.

You may do this anytime by calling the complementary function,
`save-place-forget-unreadable-files'.  When this option is turned on,
this happens automatically before saving `save-place-alist' to
`save-place-file'."
  :type 'boolean :group 'save-place)

(defcustom save-place-save-skipped t
  "If non-nil, remember files matching `save-place-skip-check-regexp'.

When filtering `save-place-alist' for unreadable files, some will not
be checked, based on said regexp, and instead saved or forgotten based
on this flag."
  :type 'boolean :group 'save-place)

(defcustom save-place-quiet nil
  "If non-nil, suppress messages about loading and saving `save-place-alist'."
  :type 'boolean :group 'save-place)

(defcustom save-place-skip-check-regexp
  ;; thanks to ange-ftp-name-format
  "\\`/\\(?:cdrom\\|floppy\\|mnt\\|\\(?:[^@/:]*@\\)?[^@/:]*[^@/:.]:\\)"
  "Regexp whose file names shall not be checked for readability.

When forgetting unreadable files, file names matching this regular
expression shall not be checked for readability, but instead be
subject to `save-place-save-skipped'.

Files for which such a check may be inconvenient include those on
removable and network volumes."
  :type 'regexp :group 'save-place)

(defun toggle-save-place (&optional parg)
  "Toggle whether to save your place in this file between sessions.
If this mode is enabled, point is recorded when you kill the buffer
or exit Emacs.  Visiting this file again will go to that position,
even in a later Emacs session.

If called with a prefix arg, the mode is enabled if and only if
the argument is positive.

To save places automatically in all files, put this in your `.emacs' file:

\(setq-default save-place t\)"
  (interactive "P")
  (if (not buffer-file-name)
      (message "Buffer `%s' not visiting a file" (buffer-name))
    (if (and save-place (or (not parg) (<= parg 0)))
	(progn
	  (message "No place will be saved in this file")
	  (setq save-place nil))
      (message "Place will be saved")
      (setq save-place t))))

(defun save-place-to-alist ()
  ;; put filename and point in a cons box and then cons that onto the
  ;; front of the save-place-alist, if save-place is non-nil.
  ;; Otherwise, just delete that file from the alist.
  ;; first check to make sure alist has been loaded in from the master
  ;; file.  If not, do so, then feel free to modify the alist.  It
  ;; will be saved again when Emacs is killed.
  (or save-place-loaded (load-save-place-alist-from-file))
  (if buffer-file-name
      (progn
        (let ((cell (assoc buffer-file-name save-place-alist))
	      (position (if (not (eq major-mode 'hexl-mode))
			    (point)
			  (with-no-warnings
			    (1+ (hexl-current-address))))))
          (if cell
              (setq save-place-alist (delq cell save-place-alist)))
	  (if (and save-place
		   (not (= position 1)))  ;; Optimize out the degenerate case.
	      (setq save-place-alist
		    (cons (cons buffer-file-name position)
			  save-place-alist)))))))

(defun save-place-forget-unreadable-files ()
  "Remove unreadable files from `save-place-alist'.
For each entry in the alist, if `file-readable-p' returns nil for the
filename, remove the entry.  Save the new alist \(as the first pair
may have changed\) back to `save-place-alist'."
  (interactive)
  ;; the following was adapted from an in-place filtering function,
  ;; `filter-mod', used in the original.
  (unless (null save-place-alist)	;says it better than `when'
    ;; first, check all except first
    (let ((fmprev save-place-alist) (fmcur (cdr save-place-alist)))
      (while fmcur			;not null
	;; a value is only saved when it becomes FMPREV.
	(if (if (string-match save-place-skip-check-regexp (caar fmcur))
		save-place-save-skipped
	      (file-readable-p (caar fmcur)))
	    (setq fmprev fmcur)
	  (setcdr fmprev (cdr fmcur)))
	(setq fmcur (cdr fmcur))))
    ;; test first pair, keep it if OK, otherwise 2nd element, which
    ;; may be '()
    (unless (if (string-match save-place-skip-check-regexp
			      (caar save-place-alist))
		save-place-save-skipped
	      (file-readable-p (caar save-place-alist)))
      (setq save-place-alist (cdr save-place-alist)))))

(defun save-place-alist-to-file ()
  (let ((file (expand-file-name save-place-file))
        (coding-system-for-write 'utf-8))
    (save-excursion
      (unless save-place-quiet
        (message "Saving places to %s..." file))
      (set-buffer (get-buffer-create " *Saved Places*"))
      (delete-region (point-min) (point-max))
      (when save-place-forget-unreadable-files
	(save-place-forget-unreadable-files))
      (insert (format ";;; -*- coding: %s -*-\n"
                      (symbol-name coding-system-for-write)))
      (let ((print-length nil)
            (print-level nil))
        (print save-place-alist (current-buffer)))
      (let ((version-control
             (cond
              ((null save-place-version-control) nil)
              ((eq 'never save-place-version-control) 'never)
              ((eq 'nospecial save-place-version-control) version-control)
              (t
               t))))
	(condition-case nil
	    ;; Don't use write-file; we don't want this buffer to visit it.
            (write-region (point-min) (point-max) file)
	  (file-error (message "Can't write %s" file)))
        (kill-buffer (current-buffer))
        (unless save-place-quiet
          (message "Saving places to %s...done" file))))))

(defun load-save-place-alist-from-file ()
  (if (not save-place-loaded)
      (progn
        (setq save-place-loaded t)
        (let ((file (expand-file-name save-place-file)))
          ;; make sure that the alist does not get overwritten, and then
          ;; load it if it exists:
          (if (file-readable-p file)
              (save-excursion
                (unless save-place-quiet
                  (message "Loading places from %s..." file))
                ;; don't want to use find-file because we have been
                ;; adding hooks to it.
                (set-buffer (get-buffer-create " *Saved Places*"))
                (delete-region (point-min) (point-max))
                (insert-file-contents file)
                (goto-char (point-min))
                (setq save-place-alist
                      (car (read-from-string
                            (buffer-substring (point-min) (point-max)))))

                ;; If there is a limit, and we're over it, then we'll
                ;; have to truncate the end of the list:
                (if save-place-limit
                    (if (<= save-place-limit 0)
                        ;; Zero gets special cased.  I'm not thrilled
                        ;; with this, but the loop for >= 1 is tight.
                        (setq save-place-alist nil)
                      ;; Else the limit is >= 1, so enforce it by
                      ;; counting and then `setcdr'ing.
                      (let ((s save-place-alist)
                            (count 1))
                        (while s
                          (if (>= count save-place-limit)
                              (setcdr s nil)
                            (setq count (1+ count)))
                          (setq s (cdr s))))))

                (kill-buffer (current-buffer))
                (unless save-place-quiet
                  (message "Loading places from %s...done" file))))
          nil))))

(defun save-places-to-alist ()
  ;; go through buffer-list, saving places to alist if save-place is
  ;; non-nil, deleting them from alist if it is nil.
  (let ((buf-list (buffer-list)))
    (while buf-list
      ;; put this into a save-excursion in case someone is counting on
      ;; another function in kill-emacs-hook to act on the last buffer
      ;; they were in:
      (save-excursion
	(set-buffer (car buf-list))
	;; save-place checks buffer-file-name too, but we can avoid
	;; overhead of function call by checking here too.
	(and buffer-file-name (save-place-to-alist))
	(setq buf-list (cdr buf-list))))))

(defun save-place-find-file-hook ()
  (or save-place-loaded (load-save-place-alist-from-file))
  (let ((cell (assoc buffer-file-name save-place-alist)))
    (if cell
	(progn
	  (or after-find-file-from-revert-buffer
	      (goto-char (cdr cell)))
          ;; and make sure it will be saved again for later
          (setq save-place t)))))

(defun save-place-kill-emacs-hook ()
  ;; First update the alist.  This loads the old save-place-file if nec.
  (save-places-to-alist)
  ;; Now save the alist in the file, if we have ever loaded the file
  ;; (including just now).
  (if save-place-loaded
      (save-place-alist-to-file)))

(add-hook 'find-file-hook 'save-place-find-file-hook t)

(add-hook 'kill-emacs-hook 'save-place-kill-emacs-hook)

(add-hook 'kill-buffer-hook 'save-place-to-alist)

(provide 'saveplace) ; why not...

;;; arch-tag: 3c2ef47b-0a22-4558-b116-118c9ef454a0
;;; saveplace.el ends here
Commit	Line	Data
55535639	1	;;; saveplace.el --- automatically save place in files
722074ef	2
0d30b337	3	;; Copyright (C) 1993, 1994, 2001, 2002, 2003, 2004,
d7a0267c	4	;; 2005, 2006, 2007 Free Software Foundation, Inc.
722074ef	5
19a448e3	6	;; Author: Karl Fogel <kfogel@red-bean.com>
722074ef RS	7	;; Maintainer: FSF
722074ef RS	8	;; Created: July, 1993
722074ef RS	9	;; Keywords: bookmarks, placeholders
	10
	11	;; This file is part of GNU Emacs.
	12
	13	;; GNU Emacs is free software; you can redistribute it and/or modify
	14	;; it under the terms of the GNU General Public License as published by
b4aa6026	15	;; the Free Software Foundation; either version 3, or (at your option)
722074ef RS	16	;; any later version.
	17
	18	;; GNU Emacs is distributed in the hope that it will be useful,
	19	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	20	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	21	;; GNU General Public License for more details.
	22
	23	;; You should have received a copy of the GNU General Public License
b578f267	24	;; along with GNU Emacs; see the file COPYING. If not, write to the
086add15 LK	25	;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
086add15 LK	26	;; Boston, MA 02110-1301, USA.
b578f267	27
6f96f4c9 RS	28	;;; Commentary:
6f96f4c9 RS	29
722074ef RS	30	;; Automatically save place in files, so that visiting them later
	31	;; (even during a different Emacs session) automatically moves point
	32	;; to the saved position, when the file is first found. Uses the
	33	;; value of buffer-local variable save-place to determine whether to
	34	;; save position or not.
	35	;;
e7dc77f6 RS	36	;; Thanks to Stefan Schoef, who sent a patch with the
e7dc77f6 RS	37	;; `save-place-version-control' stuff in it.
722074ef	38
6f96f4c9 RS	39	;;; Code:
6f96f4c9 RS	40
722074ef RS	41	;; this is what I was using during testing:
	42	;; (define-key ctl-x-map "p" 'toggle-save-place)
	43
20606f3d RS	44	(defgroup save-place nil
	45	"Automatically save place in files."
	46	:group 'data)
	47
	48
722074ef RS	49	(defvar save-place-alist nil
	50	"Alist of saved places to go back to when revisiting files.
	51	Each element looks like (FILENAME . POSITION);
	52	visiting file FILENAME goes automatically to position POSITION
	53	rather than the beginning of the buffer.
	54	This alist is saved between Emacs sessions.")
	55
20606f3d	56	(defcustom save-place nil
722074ef RS	57	"*Non-nil means automatically save place in each file.
	58	This means when you visit a file, point goes to the last place
	59	where it was when you previously visited the same file.
	60	This variable is automatically buffer-local.
	61
	62	If you wish your place in any file to always be automatically saved,
	63	simply put this in your `~/.emacs' file:
	64
c73dca25 RS	65	\(setq-default save-place t)
	66	\(require 'saveplace)
	67
	68	or else use the Custom facility to set this option."
20606f3d	69	:type 'boolean
d749f559	70	:require 'saveplace
20606f3d	71	:group 'save-place)
722074ef RS	72
	73	(make-variable-buffer-local 'save-place)
	74
20606f3d RS	75	(defcustom save-place-file (convert-standard-filename "~/.emacs-places")
	76	"*Name of the file that records `save-place-alist' value."
	77	:type 'file
	78	:group 'save-place)
722074ef	79
a4ce5ede	80	(defcustom save-place-version-control nil
e7dc77f6 RS	81	"*Controls whether to make numbered backups of master save-place file.
	82	It can have four values: t, nil, `never', and `nospecial'. The first
	83	three have the same meaning that they do for the variable
	84	`version-control', and the final value `nospecial' means just use the
20606f3d RS	85	value of `version-control'."
	86	:type '(radio (const :tag "Unconditionally" t)
	87	(const :tag "For VC Files" nil)
	88	(const never)
a4ce5ede	89	(const :tag "Use value of `version-control'" nospecial))
20606f3d	90	:group 'save-place)
e7dc77f6	91
722074ef RS	92	(defvar save-place-loaded nil
	93	"Non-nil means that the `save-place-file' has been loaded.")
	94
20606f3d RS	95	(defcustom save-place-limit nil
	96	"Maximum number of entries to retain in the list; nil means no limit."
	97	:type '(choice (integer :tag "Entries" :value 1)
	98	(const :tag "No Limit" nil))
	99	:group 'save-place)
6cf02570	100
467997b7 EZ	101	(defcustom save-place-forget-unreadable-files t
	102	"Non-nil means forget place in unreadable files.
	103
	104	The filenames in `save-place-alist' that do not match
	105	`save-place-skip-check-regexp' are filtered through
	106	`file-readable-p'. if nil, their alist entries are removed.
	107
	108	You may do this anytime by calling the complementary function,
	109	`save-place-forget-unreadable-files'. When this option is turned on,
	110	this happens automatically before saving `save-place-alist' to
	111	`save-place-file'."
	112	:type 'boolean :group 'save-place)
	113
	114	(defcustom save-place-save-skipped t
	115	"If non-nil, remember files matching `save-place-skip-check-regexp'.
	116
	117	When filtering `save-place-alist' for unreadable files, some will not
	118	be checked, based on said regexp, and instead saved or forgotten based
	119	on this flag."
	120	:type 'boolean :group 'save-place)
	121
dad93563 KF	122	(defcustom save-place-quiet nil
	123	"If non-nil, suppress messages about loading and saving `save-place-alist'."
	124	:type 'boolean :group 'save-place)
	125
467997b7 EZ	126	(defcustom save-place-skip-check-regexp
	127	;; thanks to ange-ftp-name-format
	128	"\\`/\\(?:cdrom\\\|floppy\\\|mnt\\\|\\(?:[^@/:]@\\)?[^@/:][^@/:.]:\\)"
	129	"Regexp whose file names shall not be checked for readability.
	130
	131	When forgetting unreadable files, file names matching this regular
	132	expression shall not be checked for readability, but instead be
	133	subject to `save-place-save-skipped'.
	134
	135	Files for which such a check may be inconvenient include those on
	136	removable and network volumes."
	137	:type 'regexp :group 'save-place)
	138
722074ef RS	139	(defun toggle-save-place (&optional parg)
	140	"Toggle whether to save your place in this file between sessions.
	141	If this mode is enabled, point is recorded when you kill the buffer
	142	or exit Emacs. Visiting this file again will go to that position,
	143	even in a later Emacs session.
	144
	145	If called with a prefix arg, the mode is enabled if and only if
	146	the argument is positive.
	147
	148	To save places automatically in all files, put this in your `.emacs' file:
	149
	150	\(setq-default save-place t\)"
	151	(interactive "P")
	152	(if (not buffer-file-name)
44a75d48	153	(message "Buffer `%s' not visiting a file" (buffer-name))
722074ef RS	154	(if (and save-place (or (not parg) (<= parg 0)))
722074ef RS	155	(progn
44a75d48	156	(message "No place will be saved in this file")
722074ef	157	(setq save-place nil))
44a75d48	158	(message "Place will be saved")
722074ef RS	159	(setq save-place t))))
	160
	161	(defun save-place-to-alist ()
	162	;; put filename and point in a cons box and then cons that onto the
	163	;; front of the save-place-alist, if save-place is non-nil.
	164	;; Otherwise, just delete that file from the alist.
	165	;; first check to make sure alist has been loaded in from the master
	166	;; file. If not, do so, then feel free to modify the alist. It
	167	;; will be saved again when Emacs is killed.
	168	(or save-place-loaded (load-save-place-alist-from-file))
	169	(if buffer-file-name
	170	(progn
a59f6ba3 KH	171	(let ((cell (assoc buffer-file-name save-place-alist))
	172	(position (if (not (eq major-mode 'hexl-mode))
	173	(point)
06e24ef7 RS	174	(with-no-warnings
06e24ef7 RS	175	(1+ (hexl-current-address))))))
722074ef	176	(if cell
a59f6ba3 KH	177	(setq save-place-alist (delq cell save-place-alist)))
	178	(if (and save-place
	179	(not (= position 1))) ;; Optimize out the degenerate case.
	180	(setq save-place-alist
	181	(cons (cons buffer-file-name position)
	182	save-place-alist)))))))
722074ef	183
467997b7 EZ	184	(defun save-place-forget-unreadable-files ()
	185	"Remove unreadable files from `save-place-alist'.
	186	For each entry in the alist, if `file-readable-p' returns nil for the
	187	filename, remove the entry. Save the new alist \(as the first pair
	188	may have changed\) back to `save-place-alist'."
	189	(interactive)
	190	;; the following was adapted from an in-place filtering function,
	191	;; `filter-mod', used in the original.
	192	(unless (null save-place-alist) ;says it better than `when'
	193	;; first, check all except first
	194	(let ((fmprev save-place-alist) (fmcur (cdr save-place-alist)))
	195	(while fmcur ;not null
	196	;; a value is only saved when it becomes FMPREV.
	197	(if (if (string-match save-place-skip-check-regexp (caar fmcur))
	198	save-place-save-skipped
	199	(file-readable-p (caar fmcur)))
	200	(setq fmprev fmcur)
	201	(setcdr fmprev (cdr fmcur)))
	202	(setq fmcur (cdr fmcur))))
	203	;; test first pair, keep it if OK, otherwise 2nd element, which
	204	;; may be '()
	205	(unless (if (string-match save-place-skip-check-regexp
	206	(caar save-place-alist))
	207	save-place-save-skipped
	208	(file-readable-p (caar save-place-alist)))
	209	(setq save-place-alist (cdr save-place-alist)))))
	210
722074ef	211	(defun save-place-alist-to-file ()
e1970249 KF	212	(let ((file (expand-file-name save-place-file))
e1970249 KF	213	(coding-system-for-write 'utf-8))
722074ef	214	(save-excursion
dad93563 KF	215	(unless save-place-quiet
dad93563 KF	216	(message "Saving places to %s..." file))
722074ef RS	217	(set-buffer (get-buffer-create " Saved Places"))
722074ef RS	218	(delete-region (point-min) (point-max))
467997b7 EZ	219	(when save-place-forget-unreadable-files
467997b7 EZ	220	(save-place-forget-unreadable-files))
e1970249 KF	221	(insert (format ";;; -- coding: %s --\n"
e1970249 KF	222	(symbol-name coding-system-for-write)))
5f29a6c8 KF	223	(let ((print-length nil)
	224	(print-level nil))
	225	(print save-place-alist (current-buffer)))
e7dc77f6 RS	226	(let ((version-control
	227	(cond
	228	((null save-place-version-control) nil)
	229	((eq 'never save-place-version-control) 'never)
	230	((eq 'nospecial save-place-version-control) version-control)
	231	(t
	232	t))))
6b98170f	233	(condition-case nil
cfde584f	234	;; Don't use write-file; we don't want this buffer to visit it.
e1970249	235	(write-region (point-min) (point-max) file)
6b98170f	236	(file-error (message "Can't write %s" file)))
e7dc77f6	237	(kill-buffer (current-buffer))
dad93563 KF	238	(unless save-place-quiet
dad93563 KF	239	(message "Saving places to %s...done" file))))))
722074ef RS	240
	241	(defun load-save-place-alist-from-file ()
	242	(if (not save-place-loaded)
	243	(progn
	244	(setq save-place-loaded t)
	245	(let ((file (expand-file-name save-place-file)))
	246	;; make sure that the alist does not get overwritten, and then
	247	;; load it if it exists:
	248	(if (file-readable-p file)
	249	(save-excursion
dad93563 KF	250	(unless save-place-quiet
dad93563 KF	251	(message "Loading places from %s..." file))
722074ef RS	252	;; don't want to use find-file because we have been
	253	;; adding hooks to it.
	254	(set-buffer (get-buffer-create " Saved Places"))
	255	(delete-region (point-min) (point-max))
	256	(insert-file-contents file)
	257	(goto-char (point-min))
f1180544	258	(setq save-place-alist
722074ef RS	259	(car (read-from-string
722074ef RS	260	(buffer-substring (point-min) (point-max)))))
6cf02570 RS	261
	262	;; If there is a limit, and we're over it, then we'll
	263	;; have to truncate the end of the list:
	264	(if save-place-limit
	265	(if (<= save-place-limit 0)
	266	;; Zero gets special cased. I'm not thrilled
	267	;; with this, but the loop for >= 1 is tight.
	268	(setq save-place-alist nil)
	269	;; Else the limit is >= 1, so enforce it by
	270	;; counting and then `setcdr'ing.
	271	(let ((s save-place-alist)
	272	(count 1))
	273	(while s
	274	(if (>= count save-place-limit)
	275	(setcdr s nil)
	276	(setq count (1+ count)))
	277	(setq s (cdr s))))))
f1180544	278
722074ef	279	(kill-buffer (current-buffer))
dad93563 KF	280	(unless save-place-quiet
dad93563 KF	281	(message "Loading places from %s...done" file))))
722074ef RS	282	nil))))
	283
	284	(defun save-places-to-alist ()
	285	;; go through buffer-list, saving places to alist if save-place is
	286	;; non-nil, deleting them from alist if it is nil.
	287	(let ((buf-list (buffer-list)))
	288	(while buf-list
	289	;; put this into a save-excursion in case someone is counting on
	290	;; another function in kill-emacs-hook to act on the last buffer
	291	;; they were in:
	292	(save-excursion
	293	(set-buffer (car buf-list))
	294	;; save-place checks buffer-file-name too, but we can avoid
	295	;; overhead of function call by checking here too.
	296	(and buffer-file-name (save-place-to-alist))
	297	(setq buf-list (cdr buf-list))))))
b6ace927 RS	298
	299	(defun save-place-find-file-hook ()
	300	(or save-place-loaded (load-save-place-alist-from-file))
	301	(let ((cell (assoc buffer-file-name save-place-alist)))
	302	(if cell
6f96f4c9 RS	303	(progn
	304	(or after-find-file-from-revert-buffer
	305	(goto-char (cdr cell)))
b6ace927 RS	306	;; and make sure it will be saved again for later
	307	(setq save-place t)))))
	308
4d2c9a10	309	(defun save-place-kill-emacs-hook ()
18b1fecd RS	310	;; First update the alist. This loads the old save-place-file if nec.
	311	(save-places-to-alist)
	312	;; Now save the alist in the file, if we have ever loaded the file
	313	;; (including just now).
52b9a931	314	(if save-place-loaded
18b1fecd	315	(save-place-alist-to-file)))
b6ace927	316
1a4914f3	317	(add-hook 'find-file-hook 'save-place-find-file-hook t)
b6ace927 RS	318
b6ace927 RS	319	(add-hook 'kill-emacs-hook 'save-place-kill-emacs-hook)
722074ef RS	320
	321	(add-hook 'kill-buffer-hook 'save-place-to-alist)
	322
	323	(provide 'saveplace) ; why not...
	324
ab5796a9	325	;;; arch-tag: 3c2ef47b-0a22-4558-b116-118c9ef454a0
722074ef	326	;;; saveplace.el ends here