Mercurial > emacs
view lisp/time-stamp.el @ 73331:f21883dcffa9
Merge from upstream, upto version 5.22.
After 5.0:
`cperl-add-tags-recurse-noxs-fullpath': new function (for -batch mode)
After 5.1:
;; Major edit. Summary of most visible changes:
;; a) Multiple <<HERE per line allowed.
;; b) Handles multiline subroutine declaration headers (with comments).
;; (The exception is `cperl-etags' - but it is not used in the rest
;; of the mode.)
;; c) Fontifies multiline my/our declarations (even with comments,
;; and with legacy `font-lock').
;; d) Major speedup of syntaxification, both immediate and postponed
;; (3.5x to 15x [for different CPUs and versions of Emacs] on the
;; huge real-life document I tested).
;; e) New bindings, edits to imenu.
;; f) "_" is made into word-char during fontification/syntaxification;
;; some attempts to recognize non-word "_" during other operations too.
;; g) Detect bug in Emacs with `looking-at' inside `narrow' and bulk out.
;; h) autoload some more perldoc-related stuff
;; i) Some new convenience features: ISpell POD/HEREDOCs, narrow-to-HEREDOC
;; j) Attempt to incorporate XEmacs edits which reached me
Fine-grained changelog:
`cperl-hook-after-change': New configuration variable
`cperl-vc-sccs-header': Likewise.
`cperl-vc-sccs-header': Likewise.
`cperl-vc-header-alist': Default via two preceding variables
`cperl-invalid-face': Remove double quoting under XEmacs
(still needed under 21.2)
`cperl-tips': Update URLs for resources
`cperl-problems': Likewise.
`cperl-praise': Mention new features
New C-c key bindings: for `cperl-find-bad-style',
`cperl-pod-spell', `cperl-here-doc-spell', `cperl-narrow-to-here-doc',
`cperl-perdoc', `cperl-perldoc-at-point'
CPerl Mode menu changes: "Fix style by spaces", "Imenu on Perl Info"
moved, new submenu of Tools with Ispell entries and narrowing.
`cperl-after-sub-regexp': New defsubst
`cperl-imenu--function-name-regexp-perl': Use `cperl-after-sub-regexp',
Allows heads up to head4
Allow "package;"
`defun-prompt-regexp': Use `cperl-after-sub-regexp',
`paren-backwards-message': ??? Something for XEmacs???
`cperl-mode': Never auto-switch abbrev-mode off
Try to allow '_' be non-word char
Do not use `font-lock-unfontify-region-function' on XEmacs
Reset syntax cache on mode start
Support multiline facification (even
on legacy `font-lock')
`cperl-facemenu-add-face-function': ??? Some contributed code ???
`cperl-after-change-function': Since `font-lock' and `lazy-lock'
refuse to inform us whether the fontification is due to lazy
calling or due to edit to a buffer, install our own hook
(controlled by `cperl-hook-after-change')
`cperl-electric-pod': =cut may have been recognized as start
`cperl-block-p': Moved, updated for attributes
`cperl-calculate-indent': Try to allow '_' be non-word char
Support subs with attributes
`cperl-where-am-i': Queit (?) a warning
`cperl-cached-syntax-table' New function
`cperl-forward-re': Use `cperl-cached-syntax-table'
`cperl-unwind-to-safe': Recognize `syntax-type' property
changing in a middle of line
`cperl-find-sub-attrs': New function
`cperl-find-pods-heres': Allow many <<EOP per line
Allow subs with attributes
Major speedups (3.5x..15x on a real-life
test file nph-proxy.pl)
Recognize "extproc " (OS/2)
case-folded and only at start
/x on s///x with empty replacement was
not recognized
Better comments
`cperl-after-block-p': Remarks on diff with `cperl-block-p'
Allow subs with attributes, labels
Do not confuse "else::foo" with "else"
Minor optimizations...
`cperl-after-expr-p': Try to allow '_' be non-word char
`cperl-fill-paragraph': Try to detect a major bug in Emacs
with `looking-at' inside `narrow' and bulk out if found
`cperl-imenu--create-perl-index': Updates for new
`cperl-imenu--function-name-regexp-perl'
`cperl-outline-level': Likewise.
`cperl-init-faces': Allow multiline subroutine headers
and my/our declarations, and ones with comments
Allow subroutine attributes
`cperl-imenu-on-info': Better docstring.
`cperl-etags' Rudimentary support for attributes
Support for packages and "package;"
`cperl-add-tags-recurse-noxs': Better (?) docstring
`cperl-add-tags-recurse-noxs-fullpath': Likewise.
`cperl-tags-hier-init': Misprint for `fboundp' fixed
`cperl-not-bad-style-regexp': Try to allow '_' be non-word char
`cperl-perldoc': Add autoload
`cperl-perldoc-at-point': Likewise.
`cperl-here-doc-spell': New function
`cperl-pod-spell': Likewise.
`cperl-map-pods-heres': Likewise.
`cperl-get-here-doc-region': Likewise.
`cperl-font-lock-fontify-region-function': Likewise (backward compatibility
for legacy `font-lock')
`cperl-font-lock-unfontify-region-function': Fix style
`cperl-fontify-syntaxically': Recognize and optimize away
deferred calls with no-change. Governed by `cperl-hook-after-change'
`cperl-fontify-update': Recognize that syntaxification region
can be larger than fontification one.
XXXX we leave `cperl-postpone' property, so this is quadratic...
`cperl-fontify-update-bad': Temporary placeholder until
it is clear how to implement `cperl-fontify-update'.
`cperl-time-fontification': New function
`attrib-group': New text attribute
`multiline': New value: `syntax-type' text attribute
After 5.2:
`cperl-emulate-lazy-lock': New function
`cperl-fontify-syntaxically': Would skip large regions
Add `cperl-time-fontification', `cperl-emulate-lazy-lock' to menu
Some globals were declared, but uninitialized
After 5.3, 5.4:
`cperl-facemenu-add-face-function': Add docs, fix U<>
Copyright message updated.
`cperl-init-faces': Work around a bug in `font-lock'. May slow
facification down a bit.
Misprint for my|our|local for old `font-lock'
"our" was not fontified same as "my|local"
Highlight variables after "my" etc even in
a middle of an expression
Do not facify multiple variables after my etc
unless parentheses are present
After 5.5, 5.6
`cperl-fontify-syntaxically': after-change hook could reset
`cperl-syntax-done-to' to a middle of line; unwind to BOL.
After 5.7:
`cperl-init-faces': Allow highlighting of local ($/)
`cperl-problems-old-emaxen': New variable (for the purpose of DOCSTRING).
`cperl-problems': Remove fixed problems.
`cperl-find-pods-heres': Recognize #-comments in m##x too
Recognize charclasses (unless delimiter is \).
`cperl-fontify-syntaxically': Unwinding to safe was done in wrong order
`cperl-regexp-scan': Update docs
`cperl-beautify-regexp-piece': use information got from regexp scan
After 5.8:
Major user visible changes:
Recognition and fontification of character classes in RExen.
Variable indentation of RExen according to groups
`cperl-find-pods-heres': Recognize POSIX classes in REx charclasses
Fontify REx charclasses in variable-name face
Fontify POSIX charclasses in "type" face
Fontify unmatched "]" in function-name face
Mark first-char of HERE-doc as `front-sticky'
Reset `front-sticky' property when needed
`cperl-calculate-indent': Indents //x -RExen accordning to parens level
`cperl-to-comment-or-eol': Recognize ends of `syntax-type' constructs
`cperl-backward-to-noncomment': Recognize stringy `syntax-type' constructs
Support `narrow'ed buffers.
`cperl-praise': Remove a reservation
`cperl-make-indent': New function
`cperl-indent-for-comment': Use `cperl-make-indent'
`cperl-indent-line': Likewise.
`cperl-lineup': Likewise.
`cperl-beautify-regexp-piece': Likewise.
`cperl-contract-level': Likewise.
`cperl-toggle-set-debug-unwind': New function
New menu entry for this
`fill-paragraph-function': Use when `boundp'
`cperl-calculate-indent': Take into account groups when indenting RExen
`cperl-to-comment-or-eol': Recognize # which end a string
`cperl-modify-syntax-type': Make only syntax-table property non-sticky
`cperl-fill-paragraph': Return t: needed for `fill-paragraph-function'
`cperl-fontify-syntaxically': More clear debugging message
`cperl-pod2man-build-command': XEmacs portability: check `Man-filter-list'
`cperl-init-faces': More complicated highlight even on XEmacs (new)
Merge cosmetic changes from XEmacs
After 5.9:
`cperl-1+': Moved to before the first use
`cperl-1-': Likewise.
After 5.10:
This code may lock Emacs hard!!! Use on your own risk!
`cperl-font-locking': New internal variable
`cperl-beginning-of-property': New function
`cperl-calculate-indent': Use `cperl-beginning-of-property'
instead of `previous-single-property-change'
`cperl-unwind-to-safe': Likewise.
`cperl-after-expr-p': Likewise.
`cperl-get-here-doc-region': Likewise.
`cperl-font-lock-fontify-region-function': Likewise.
`cperl-to-comment-or-eol': Do not call `cperl-update-syntaxification'
recursively
Bound `next-single-property-change'
via `point-max'
`cperl-unwind-to-safe': Bound likewise
`cperl-font-lock-fontify-region-function': Likewise.
`cperl-find-pods-heres': Mark as recursive for `cperl-to-comment-or-eol'
Initialization of
`cperl-font-lock-multiline-start' could be missed if the "main"
fontification did not run due to the keyword being already fontified.
`cperl-pod-spell': Return t from do-one-chunk function
`cperl-map-pods-heres': Stop when the worker returns nil
Call `cperl-update-syntaxification'
`cperl-get-here-doc-region': Call `cperl-update-syntaxification'
`cperl-get-here-doc-delim': Remove unused function
After 5.11:
The possible lockup of Emacs (introduced in 5.10) fixed
`cperl-unwind-to-safe': `cperl-beginning-of-property' won't return nil
`cperl-syntaxify-for-menu': New customization variable
`cperl-select-this-pod-or-here-doc': New function
`cperl-get-here-doc-region': Extra argument
Do not adjust pos by 1
New menu entries (Perl/Tools): Selection of current POD or HERE-DOC section
(Debugging CPerl:) backtrace on fontification
After 5.12:
`cperl-cached-syntax-table': use `car-safe'
`cperl-forward-re': Remove spurious argument SET-ST
Add documentation
`cperl-forward-group-in-re': New function
`cperl-find-pods-heres': Find and highlight (?{}) blocks in RExen
(XXXX Temporary (?) hack is to syntax-mark them as comment)
After 5.13:
`cperl-string-syntax-table': Make { and } not-grouping
(Sometimes they ARE grouping in RExen, but matching them would only
confuse in many situations when they are not)
`beginning-of-buffer': Replaced two occurences with goto-char...
`cperl-calculate-indent': `char-after' could be nil...
`cperl-find-pods-heres': REx can start after "[" too
Hightlight (??{}) in RExen too
`cperl-maybe-white-and-comment-rex': New constant
`cperl-white-and-comment-rex': Likewise.
XXXX Not very efficient, but hard to make
better while keeping 1 group
After 5.13:
`cperl-find-pods-heres': $foo << identifier() is not a HERE-DOC
Likewise for 1 << identifier
After 5.14:
`cperl-find-pods-heres': Different logic for $foo .= <<EOF etc
Error-less condition-case could fail
`cperl-font-lock-fontify-region-function': Likewise.
`cperl-init-faces': Likewise.
After 5.15:
`cperl-find-pods-heres': Support property REx-part2
`cperl-calculate-indent': Likewise.
Don't special-case REx with non-empty 1st line
`cperl-find-pods-heres': In RExen, highlight non-literal backslashes
Invert highlighting of charclasses:
now the envelop is highlighted
Highlight many others 0-length builtins
`cperl-praise': Mention indenting and highlight in RExen
After 5.15:
`cperl-find-pods-heres': Highlight capturing parens in REx
After 5.16:
`cperl-find-pods-heres': Highlight '|' for alternation
Initialize `font-lock-warning-face' if not present
`cperl-find-pods-heres': Use `font-lock-warning-face' instead of
`font-lock-function-name-face'
`cperl-look-at-leading-count': Likewise.
`cperl-find-pods-heres': localize `font-lock-variable-name-face'
`font-lock-keyword-face' (needed for
batch processing) etc
Use `font-lock-builtin-face' for builtin in REx
Now `font-lock-variable-name-face'
is used for interpolated variables
Use "talking aliases" for faces inside REx
Highlight parts of REx (except in charclasses)
according to the syntax and/or semantic
Syntax-mark a {}-part of (?{}) as "comment"
(it was the ()-part)
Better logic to distinguish what is what in REx
`cperl-tips-faces': Document REx highlighting
`cperl-praise': Mention REx syntax highlight etc.
After 5.17:
`cperl-find-sub-attrs': Would not always manage to print error message
`cperl-find-pods-heres': localize `font-lock-constant-face'
After 5.18:
`cperl-find-pods-heres': Misprint in REx for parsing REx
Very minor optimization
`my-cperl-REx-modifiers-face' got quoted
Recognize "print $foo <<END" as HERE-doc
Put `REx-interpolated' text attribute if needed
`cperl-invert-if-unless-modifiers': New function
`cperl-backward-to-start-of-expr': Likewise.
`cperl-forward-to-end-of-expr': Likewise.
`cperl-invert-if-unless': Works in "the opposite way" too
Cursor position on return is on the switch-word
Indents comments better
`REx-interpolated': New text attribute
`cperl-next-interpolated-REx': New function
`cperl-next-interpolated-REx-0': Likewise.
`cperl-next-interpolated-REx-1': Likewise.
"\C-c\C-x", "\C-c\C-y", "\C-c\C-v": New keybinding for these functions
Perl/Regexp menu: 3 new entries for `cperl-next-interpolated-REx'
`cperl-praise': Mention finded interpolated RExen
After 5.19:
`cperl-init-faces': Highlight %$foo, @$foo too
`cperl-short-docs': Better docs for system, exec
`cperl-find-pods-heres': Better detect << after print {FH} <<EOF etc.
Would not find HERE-doc ended by EOF without NL
`cperl-short-docs': Correct not-doubled \-escapes
start block: Put some `defvar' for stuff gone from XEmacs
After 5.20:
initial comment: Extend copyright, fix email address
`cperl-indent-comment-at-column-0': New customization variable
`cperl-comment-indent': Indentation after $#a would increasy by 1
`cperl-mode': Make `defun-prompt-regexp' grok BEGIN/END etc
`cperl-find-pods-heres': Mark CODE of s///e as `syntax-type' `multiline'
`cperl-at-end-of-expr': Would fail if @BAR=12 follows after ";"
`cperl-init-faces': If `cperl-highlight-variables-indiscriminately'
highlight $ in $foo too (UNTESTED)
`cperl-set-style': Docstring missed some available styles
toplevel: Menubar/Perl/Indent-Styles had FSF, now K&R
Change "Current" to "Memorize Current"
`cperl-indent-wrt-brace': New customization variable; the default is
as for pre-5.2 version
`cperl-styles-entries': Keep `cperl-extra-newline-before-brace-multiline'
`cperl-style-alist': Likewise.
`cperl-fix-line-spacing': Support `cperl-merge-trailing-else' being nil,
and `cperl-extra-newline-before-brace' etc
being t
`cperl-indent-exp': Plans B and C to find continuation blocks even
if `cperl-extra-newline-before-brace' is t
After 5.21:
Improve some docstrings concerning indentation.
`cperl-indent-rules-alist': New variable
`cperl-sniff-for-indent': New function name
(separated from `cperl-calculate-indent')
`cperl-calculate-indent': Separated the sniffer and the indenter;
uses `cperl-sniff-for-indent' now
`cperl-comment-indent': Test for `cperl-indent-comment-at-column-0'
was inverted;
Support `comment-column' = 0
author | Stefan Monnier <monnier@iro.umontreal.ca> |
---|---|
date | Wed, 11 Oct 2006 06:47:35 +0000 |
parents | d84cbfb84b06 |
children | f1bc46cb2d2d 2ecafc6d5db7 |
line wrap: on
line source
;;; time-stamp.el --- Maintain last change time stamps in files edited by Emacs ;; Copyright (C) 1989, 1993, 1994, 1995, 1997, 2000, 2001, 2002, 2003, ;; 2004, 2005, 2006 Free Software Foundation, Inc. ;; This file is part of GNU Emacs. ;; Maintainer's Time-stamp: <2006-04-12 20:30:56 rms> ;; Maintainer: Stephen Gildea <gildea@stop.mail-abuse.org> ;; Keywords: tools ;; 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 2, 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: ;; A template in a file can be updated with a new time stamp when ;; you save the file. For example: ;; static char *ts = "sdmain.c Time-stamp: <2001-08-13 10:20:51 gildea>"; ;; See the top of `time-stamp.el' for another example. ;; To use time-stamping, add this line to your .emacs file: ;; (add-hook 'before-save-hook 'time-stamp) ;; Now any time-stamp templates in your files will be updated automatically. ;; See the documentation for the functions `time-stamp' ;; and `time-stamp-toggle-active' for details. ;;; Code: (defgroup time-stamp nil "Maintain last change time stamps in files edited by Emacs." :group 'data :group 'extensions) (defcustom time-stamp-format "%:y-%02m-%02d %02H:%02M:%02S %u" "*Format of the string inserted by \\[time-stamp]. The value may be a string or a list. Lists are supported only for backward compatibility; see variable `time-stamp-old-format-warn'. A string is used verbatim except for character sequences beginning with %, as follows. The values of non-numeric formatted items depend on the locale setting recorded in `system-time-locale' and `locale-coding-system'. The examples here are for the default \(`C') locale. %:a weekday name: `Monday'. %#A gives uppercase: `MONDAY' %3a abbreviated weekday: `Mon'. %3A gives uppercase: `MON' %:b month name: `January'. %#B gives uppercase: `JANUARY' %3b abbreviated month: `Jan'. %3B gives uppercase: `JAN' %02d day of month %02H 24-hour clock hour %02I 12-hour clock hour %02m month number %02M minute %#p `am' or `pm'. %P gives uppercase: `AM' or `PM' %02S seconds %w day number of week, Sunday is 0 %02y 2-digit year: `03' %:y 4-digit year: `2003' %z time zone name: `est'. %Z gives uppercase: `EST' Non-date items: %% a literal percent character: `%' %f file name without directory %F gives absolute pathname %s system name %u user's login name %U user's full name %h mail host name Decimal digits between the % and the type character specify the field width. Strings are truncated on the right; years on the left. A leading zero in the field width zero-fills a number. For example, to get the format used by the `date' command, use \"%3a %3b %2d %02H:%02M:%02S %Z %:y\". In the future these formats will be aligned more with `format-time-string'. Because of this transition, the default padding for numeric formats will change in a future version. Therefore either a padding width should be specified, or the : modifier should be used to explicitly request the historical default." :type 'string :group 'time-stamp :version "20.1") ;;;###autoload(put 'time-stamp-format 'safe-local-variable 'stringp) (defcustom time-stamp-active t "*Non-nil to enable time-stamping of buffers by \\[time-stamp]. Can be toggled by \\[time-stamp-toggle-active]. See also the variable `time-stamp-warn-inactive'." :type 'boolean :group 'time-stamp) (defcustom time-stamp-warn-inactive t "Have \\[time-stamp] warn if a buffer did not get time-stamped. If non-nil, a warning is displayed if `time-stamp-active' has deactivated time stamping and the buffer contains a template that otherwise would have been updated." :type 'boolean :group 'time-stamp :version "19.29") (defcustom time-stamp-old-format-warn 'ask "Action if `time-stamp-format' is an old-style list. If `error', the format is not used. If `ask', the user is queried about using the time-stamp-format. If `warn', a warning is displayed. If nil, no notification is given." :type '(choice (const :tag "Don't use the format" error) (const ask) (const warn) (const :tag "No notification" nil)) :group 'time-stamp) (defcustom time-stamp-time-zone nil "If non-nil, a string naming the timezone to be used by \\[time-stamp]. Format is the same as that used by the environment variable TZ on your system." :type '(choice (const nil) string) :group 'time-stamp :version "20.1") ;;; Do not change time-stamp-line-limit, time-stamp-start, ;;; time-stamp-end, time-stamp-pattern, time-stamp-inserts-lines, ;;; or time-stamp-count in your .emacs or you will be incompatible ;;; with other people's files! If you must change them, do so only ;;; in the local variables section of the file itself. (defvar time-stamp-line-limit 8 ;Do not change! "Lines of a file searched; positive counts from start, negative from end. The patterns `time-stamp-start' and `time-stamp-end' must be found in the first (last) `time-stamp-line-limit' lines of the file for the file to be time-stamped by \\[time-stamp]. A value of 0 searches the entire buffer (use with care). This value can also be set with the variable `time-stamp-pattern'. Do not change `time-stamp-line-limit', `time-stamp-start', `time-stamp-end', or `time-stamp-pattern' for yourself or you will be incompatible with other people's files! If you must change them for some application, do so in the local variables section of the time-stamped file itself.") ;;;###autoload(put 'time-stamp-line-limit 'safe-local-variable 'integerp) (defvar time-stamp-start "Time-stamp:[ \t]+\\\\?[\"<]+" ;Do not change! "Regexp after which the time stamp is written by \\[time-stamp]. See also the variables `time-stamp-end' and `time-stamp-line-limit'. This value can also be set with the variable `time-stamp-pattern'. Do not change `time-stamp-line-limit', `time-stamp-start', `time-stamp-end', or `time-stamp-pattern' for yourself or you will be incompatible with other people's files! If you must change them for some application, do so in the local variables section of the time-stamped file itself.") ;;;###autoload(put 'time-stamp-start 'safe-local-variable 'stringp) (defvar time-stamp-end "\\\\?[\">]" ;Do not change! "Regexp marking the text after the time stamp. \\[time-stamp] deletes the text between the first match of `time-stamp-start' and the following match of `time-stamp-end', then writes the time stamp specified by `time-stamp-format' between them. This value can also be set with the variable `time-stamp-pattern'. The end text normally starts on the same line as the start text ends, but if there are any newlines in `time-stamp-format', the same number of newlines must separate the start and end. \\[time-stamp] tries to not change the number of lines in the buffer. `time-stamp-inserts-lines' controls this behavior. Do not change `time-stamp-start', `time-stamp-end', `time-stamp-pattern', or `time-stamp-inserts-lines' for yourself or you will be incompatible with other people's files! If you must change them for some application, do so in the local variables section of the time-stamped file itself.") ;;;###autoload(put 'time-stamp-end 'safe-local-variable 'stringp) (defvar time-stamp-inserts-lines nil ;Do not change! "Whether \\[time-stamp] can change the number of lines in a file. If nil, \\[time-stamp] skips as many lines as there are newlines in `time-stamp-format' before looking for the `time-stamp-end' pattern, thus it tries not to change the number of lines in the buffer. If non-nil, \\[time-stamp] starts looking for the end pattern immediately after the start pattern. This behavior can cause unexpected changes in the buffer if used carelessly, but it is useful for generating repeated time stamps. Do not change `time-stamp-end' or `time-stamp-inserts-lines' for yourself or you will be incompatible with other people's files! If you must change them for some application, do so in the local variables section of the time-stamped file itself.") ;;;###autoload(put 'time-stamp-inserts-lines 'safe-local-variable 'symbolp) (defvar time-stamp-count 1 ;Do not change! "How many templates \\[time-stamp] will look for in a buffer. The same time stamp will be written in each case. Do not change `time-stamp-count' for yourself or you will be incompatible with other people's files! If you must change it for some application, do so in the local variables section of the time-stamped file itself.") ;;;###autoload(put 'time-stamp-count 'safe-local-variable 'integerp) (defvar time-stamp-pattern nil ;Do not change! "Convenience variable setting all `time-stamp' location and format values. This string has four parts, each of which is optional. These four parts set `time-stamp-line-limit', `time-stamp-start', `time-stamp-format', and `time-stamp-end'. See the documentation for each of these variables for details. The first part is a number followed by a slash; the number sets the number of lines at the beginning (negative counts from end) of the file searched for the time stamp. The number and the slash may be omitted to use the normal value. The second part is a regexp identifying the pattern preceding the time stamp. This part may be omitted to use the normal pattern. The third part specifies the format of the time stamp inserted. See the documentation for `time-stamp-format' for details. Specify this part as \"%%\" to use the normal format. The fourth part is a regexp identifying the pattern following the time stamp. This part may be omitted to use the normal pattern. Examples: \"-10/\" \"-9/^Last modified: %%$\" \"@set Time-stamp: %:b %:d, %:y$\" \"newcommand{\\\\\\\\timestamp}{%%}\" Do not change `time-stamp-pattern' `time-stamp-line-limit', `time-stamp-start', or `time-stamp-end' for yourself or you will be incompatible with other people's files! If you must change them for some application, do so only in the local variables section of the time-stamped file itself.") ;;;###autoload(put 'time-stamp-pattern 'safe-local-variable 'stringp) ;;;###autoload (defun time-stamp () "Update the time stamp string(s) in the buffer. A template in a file can be automatically updated with a new time stamp every time you save the file. Add this line to your .emacs file: (add-hook 'before-save-hook 'time-stamp) or customize `before-save-hook' through Custom. Normally the template must appear in the first 8 lines of a file and look like one of the following: Time-stamp: <> Time-stamp: \" \" The time stamp is written between the brackets or quotes: Time-stamp: <2001-02-18 10:20:51 gildea> The time stamp is updated only if the variable `time-stamp-active' is non-nil. The format of the time stamp is set by the variable `time-stamp-pattern' or `time-stamp-format'. The variables `time-stamp-pattern', `time-stamp-line-limit', `time-stamp-start', `time-stamp-end', `time-stamp-count', and `time-stamp-inserts-lines' control finding the template." (interactive) (let ((line-limit time-stamp-line-limit) (ts-start time-stamp-start) (ts-format time-stamp-format) (ts-end time-stamp-end) (ts-count time-stamp-count) (format-lines 0) (end-lines 1) (start nil) search-limit) (if (stringp time-stamp-pattern) (progn (string-match "\\`\\(\\(-?[0-9]+\\)/\\)?\\([^%]+\\)?\\(\\(%[-.,:@+_ #^()0-9]*[A-Za-z%][^%]*\\)*%[-.,:@+_ #^()0-9]*[A-Za-z%]\\)?\\([^%]+\\)?\\'" time-stamp-pattern) (and (match-beginning 2) (setq line-limit (string-to-number (match-string 2 time-stamp-pattern)))) (and (match-beginning 3) (setq ts-start (match-string 3 time-stamp-pattern))) (and (match-beginning 4) (not (string-equal (match-string 4 time-stamp-pattern) "%%")) (setq ts-format (match-string 4 time-stamp-pattern))) (and (match-beginning 6) (setq ts-end (match-string 6 time-stamp-pattern))))) (cond ((not (integerp line-limit)) (setq line-limit 8) (message "time-stamp-line-limit is not an integer") (sit-for 1))) (cond ((not (integerp ts-count)) (setq ts-count 1) (message "time-stamp-count is not an integer") (sit-for 1)) ((< ts-count 1) ;; We need to call time-stamp-once at least once ;; to output any warnings about time-stamp not being active. (setq ts-count 1))) ;; Figure out what lines the end should be on. (if (stringp ts-format) (let ((nl-start 0)) (while (string-match "\n" ts-format nl-start) (setq format-lines (1+ format-lines) nl-start (match-end 0))))) (let ((nl-start 0)) (while (string-match "\n" ts-end nl-start) (setq end-lines (1+ end-lines) nl-start (match-end 0)))) ;; Find overall what lines to look at (save-excursion (save-restriction (widen) (cond ((> line-limit 0) (goto-char (setq start (point-min))) (forward-line line-limit) (setq search-limit (point))) ((< line-limit 0) (goto-char (setq search-limit (point-max))) (forward-line line-limit) (setq start (point))) (t ;0 => no limit (use with care!) (setq start (point-min)) (setq search-limit (point-max)))))) (while (and start (< start search-limit) (> ts-count 0)) (setq start (time-stamp-once start search-limit ts-start ts-end ts-format format-lines end-lines)) (setq ts-count (1- ts-count)))) nil) (defun time-stamp-once (start search-limit ts-start ts-end ts-format format-lines end-lines) "Update one time stamp. Internal routine called by \\[time-stamp]. Returns the end point, which is where `time-stamp' begins the next search." (let ((case-fold-search nil) (end nil) end-search-start (end-length nil)) (save-excursion (save-restriction (widen) ;; Find the location of the time stamp. (while (and (< (goto-char start) search-limit) (not end) (re-search-forward ts-start search-limit 'move)) (setq start (point)) (if (not time-stamp-inserts-lines) (forward-line format-lines)) (setq end-search-start (max start (point))) (if (= (forward-line end-lines) 0) (progn (and (bolp) (backward-char)) (let ((line-end (min (point) search-limit))) (if (>= line-end end-search-start) (progn (goto-char end-search-start) (if (re-search-forward ts-end line-end t) (progn (setq end (match-beginning 0)) (setq end-length (- (match-end 0) end)))))))))))) (if end (progn ;; do all warnings outside save-excursion (cond ((not time-stamp-active) (if time-stamp-warn-inactive ;; don't signal an error in a write-file-hook (progn (message "Warning: time-stamp-active is off; did not time-stamp buffer.") (sit-for 1)))) ((not (and (stringp ts-start) (stringp ts-end))) (message "time-stamp-start or time-stamp-end is not a string") (sit-for 1)) (t (let ((new-time-stamp (time-stamp-string ts-format))) (if (and (stringp new-time-stamp) (not (string-equal (buffer-substring start end) new-time-stamp))) (save-excursion (save-restriction (widen) (delete-region start end) (goto-char start) (insert-and-inherit new-time-stamp) (setq end (point)) ;; remove any tabs used to format time stamp (if (search-backward "\t" start t) (progn (untabify start end) (setq end (point)))))))))))) ;; return the location after this time stamp, if there was one (and end end-length (+ end end-length)))) ;;;###autoload (defun time-stamp-toggle-active (&optional arg) "Toggle `time-stamp-active', setting whether \\[time-stamp] updates a buffer. With ARG, turn time stamping on if and only if arg is positive." (interactive "P") (setq time-stamp-active (if (null arg) (not time-stamp-active) (> (prefix-numeric-value arg) 0))) (message "time-stamp is now %s." (if time-stamp-active "active" "off"))) (defun time-stamp-string (&optional ts-format) "Generate the new string to be inserted by \\[time-stamp]. Optionally use format TS-FORMAT instead of `time-stamp-format' to format the string." (or ts-format (setq ts-format time-stamp-format)) (if (stringp ts-format) (if (stringp time-stamp-time-zone) (let ((ts-real-time-zone (getenv "TZ"))) (unwind-protect (progn (set-time-zone-rule time-stamp-time-zone) (format-time-string (time-stamp-string-preprocess ts-format))) (set-time-zone-rule ts-real-time-zone))) (format-time-string (time-stamp-string-preprocess ts-format))) ;; handle version 1 compatibility (cond ((or (eq time-stamp-old-format-warn 'error) (and (eq time-stamp-old-format-warn 'ask) (not (y-or-n-p "Use non-string time-stamp-format? ")))) (message "Warning: no time-stamp: time-stamp-format not a string") (sit-for 1) nil) (t (cond ((eq time-stamp-old-format-warn 'warn) (message "Obsolescent time-stamp-format type; should be string") (sit-for 1))) (time-stamp-fconcat ts-format " "))))) (defconst time-stamp-no-file "(no file)" "String to use when the buffer is not associated with a file.") ;;; time-stamp is transitioning to using the new, expanded capabilities ;;; of format-time-string. During the process, this function implements ;;; intermediate, compatible formats and complains about old, soon to ;;; be unsupported, formats. This function will get a lot (a LOT) shorter ;;; when the transition is complete and we can just pass most things ;;; straight through to format-time-string. ;;; At all times, all the formats recommended in the doc string ;;; of time-stamp-format will work not only in the current version of ;;; Emacs, but in all versions that have been released within the past ;;; two years. ;;; The : modifier is a temporary conversion feature used to resolve ;;; ambiguous formats--formats that are changing (over time) incompatibly. (defun time-stamp-string-preprocess (format &optional time) "Use a FORMAT to format date, time, file, and user information. Optional second argument TIME is only for testing. Implements non-time extensions to `format-time-string' and all `time-stamp-format' compatibility." (let ((fmt-len (length format)) (ind 0) cur-char (prev-char nil) (result "") field-width field-result alt-form change-case require-padding (paren-level 0)) (while (< ind fmt-len) (setq cur-char (aref format ind)) (setq result (concat result (cond ((eq cur-char ?%) ;; eat any additional args to allow for future expansion (setq alt-form nil change-case nil require-padding nil field-width "") (while (progn (setq ind (1+ ind)) (setq cur-char (if (< ind fmt-len) (aref format ind) ?\0)) (or (eq ?. cur-char) (eq ?, cur-char) (eq ?: cur-char) (eq ?@ cur-char) (eq ?- cur-char) (eq ?+ cur-char) (eq ?_ cur-char) (eq ?\ cur-char) (eq ?# cur-char) (eq ?^ cur-char) (and (eq ?\( cur-char) (not (eq prev-char ?\\)) (setq paren-level (1+ paren-level))) (if (and (eq ?\) cur-char) (not (eq prev-char ?\\)) (> paren-level 0)) (setq paren-level (1- paren-level)) (and (> paren-level 0) (< ind fmt-len))) (if (and (<= ?0 cur-char) (>= ?9 cur-char)) ;; get format width (let ((field-index ind)) (while (progn (setq ind (1+ ind)) (setq cur-char (if (< ind fmt-len) (aref format ind) ?\0)) (and (<= ?0 cur-char) (>= ?9 cur-char)))) (setq field-width (substring format field-index ind)) (setq ind (1- ind)) t)))) (setq prev-char cur-char) ;; some characters we actually use (cond ((eq cur-char ?:) (setq alt-form t)) ((eq cur-char ?#) (setq change-case t)))) (setq field-result (cond ((eq cur-char ?%) "%%") ((eq cur-char ?a) ;day of week (if change-case (format-time-string "%#a" time) (or alt-form (not (string-equal field-width "")) (time-stamp-conv-warn "%a" "%:a")) (if (and alt-form (not (string-equal field-width ""))) "" ;discourage "%:3a" (format-time-string "%A" time)))) ((eq cur-char ?A) (if alt-form (format-time-string "%A" time) (or change-case (not (string-equal field-width "")) (time-stamp-conv-warn "%A" "%#A")) (format-time-string "%#A" time))) ((eq cur-char ?b) ;month name (if change-case (format-time-string "%#b" time) (or alt-form (not (string-equal field-width "")) (time-stamp-conv-warn "%b" "%:b")) (if (and alt-form (not (string-equal field-width ""))) "" ;discourage "%:3b" (format-time-string "%B" time)))) ((eq cur-char ?B) (if alt-form (format-time-string "%B" time) (or change-case (not (string-equal field-width "")) (time-stamp-conv-warn "%B" "%#B")) (format-time-string "%#B" time))) ((eq cur-char ?d) ;day of month, 1-31 (time-stamp-do-number cur-char alt-form field-width time)) ((eq cur-char ?H) ;hour, 0-23 (time-stamp-do-number cur-char alt-form field-width time)) ((eq cur-char ?I) ;hour, 1-12 (time-stamp-do-number cur-char alt-form field-width time)) ((eq cur-char ?m) ;month number, 1-12 (time-stamp-do-number cur-char alt-form field-width time)) ((eq cur-char ?M) ;minute, 0-59 (time-stamp-do-number cur-char alt-form field-width time)) ((eq cur-char ?p) ;am or pm (or change-case (time-stamp-conv-warn "%p" "%#p")) (format-time-string "%#p" time)) ((eq cur-char ?P) ;AM or PM (format-time-string "%p" time)) ((eq cur-char ?S) ;seconds, 00-60 (time-stamp-do-number cur-char alt-form field-width time)) ((eq cur-char ?w) ;weekday number, Sunday is 0 (format-time-string "%w" time)) ((eq cur-char ?y) ;year (or alt-form (not (string-equal field-width "")) (time-stamp-conv-warn "%y" "%:y")) (string-to-number (format-time-string "%Y" time))) ((eq cur-char ?Y) ;4-digit year, new style (string-to-number (format-time-string "%Y" time))) ((eq cur-char ?z) ;time zone lower case (if change-case "" ;discourage %z variations (format-time-string "%#Z" time))) ((eq cur-char ?Z) (if change-case (format-time-string "%#Z" time) (format-time-string "%Z" time))) ((eq cur-char ?f) ;buffer-file-name, base name only (if buffer-file-name (file-name-nondirectory buffer-file-name) time-stamp-no-file)) ((eq cur-char ?F) ;buffer-file-name, full path (or buffer-file-name time-stamp-no-file)) ((eq cur-char ?s) ;system name (system-name)) ((eq cur-char ?u) ;user name (user-login-name)) ((eq cur-char ?U) ;user full name (user-full-name)) ((eq cur-char ?l) ;logname (undocumented user name alt) (user-login-name)) ((eq cur-char ?L) ;(undocumented alt user full name) (user-full-name)) ((eq cur-char ?h) ;mail host name (time-stamp-mail-host-name)) ((eq cur-char ?q) ;(undocumented unqual hostname) (let ((qualname (system-name))) (if (string-match "\\." qualname) (substring qualname 0 (match-beginning 0)) qualname))) ((eq cur-char ?Q) ;(undocumented fully-qualified host) (system-name)) )) (let ((padded-result (format (format "%%%s%c" field-width (if (numberp field-result) ?d ?s)) (or field-result "")))) (let* ((initial-length (length padded-result)) (desired-length (if (string-equal field-width "") initial-length (string-to-number field-width)))) (if (> initial-length desired-length) ;; truncate strings on right, years on left (if (stringp field-result) (substring padded-result 0 desired-length) (if (eq cur-char ?y) (substring padded-result (- desired-length)) padded-result)) ;non-year numbers don't truncate padded-result)))) (t (char-to-string cur-char))))) (setq ind (1+ ind))) result)) (defun time-stamp-do-number (format-char alt-form field-width time) "Handle compatible FORMAT-CHAR where only default width/padding will change. ALT-FORM is whether `#' specified. FIELD-WIDTH is the string width specification or \"\". TIME is the time to convert." (let ((format-string (concat "%" (char-to-string format-char)))) (and (not alt-form) (string-equal field-width "") (time-stamp-conv-warn format-string (format "%%:%c" format-char))) (if (and alt-form (not (string-equal field-width ""))) "" ;discourage "%:2d" and the like (string-to-number (format-time-string format-string time))))) (defvar time-stamp-conversion-warn t "Warn about soon-to-be-unsupported forms in `time-stamp-format'. If nil, these warnings are disabled, which would be a bad idea! You really need to update your files instead. The new formats will work with old versions of Emacs. New formats are being recommended now to allow `time-stamp-format' to change in the future to be compatible with `format-time-string'. The new forms being recommended now will continue to work then.") (defun time-stamp-conv-warn (old-form new-form) "Display a warning about a soon-to-be-obsolete format. Suggests replacing OLD-FORM with NEW-FORM." (cond (time-stamp-conversion-warn (save-excursion (set-buffer (get-buffer-create "*Time-stamp-compatibility*")) (goto-char (point-max)) (if (bobp) (progn (insert "The formats recognized in time-stamp-format will change in a future release\n" "to be compatible with the new, expanded format-time-string function.\n\n" "The following obsolescent time-stamp-format construct(s) were found:\n\n"))) (insert "\"" old-form "\" -- use " new-form "\n")) (display-buffer "*Time-stamp-compatibility*")))) (defun time-stamp-mail-host-name () "Return the name of the host where the user receives mail. This is the value of `mail-host-address' if bound and a string, otherwise the value of the function `system-name'." (or (and (boundp 'mail-host-address) (stringp mail-host-address) mail-host-address) (system-name))) ;;; the rest of this file is for version 1 compatibility (defun time-stamp-fconcat (list sep) "Similar to (mapconcat 'funcall LIST SEP) but LIST allows literals. If an element of LIST is a symbol, it is funcalled to get the string to use; the separator SEP is used between two strings obtained by funcalling a symbol. Otherwise the element itself is inserted; no separator is used around literals." (let ((return-string "") (insert-sep-p nil)) (while list (cond ((symbolp (car list)) (if insert-sep-p (setq return-string (concat return-string sep))) (setq return-string (concat return-string (funcall (car list)))) (setq insert-sep-p t)) (t (setq return-string (concat return-string (car list))) (setq insert-sep-p nil))) (setq list (cdr list))) return-string)) ;;; Some functions used in time-stamp-format ;;; These functions have been obsolete since 1995 ;;; and will be removed in Emacs 22. ;;; Meanwhile, discourage other packages from using them. (let ((obsolete-functions '(time-stamp-month-dd-yyyy time-stamp-dd/mm/yyyy time-stamp-mon-dd-yyyy time-stamp-dd-mon-yy time-stamp-yy/mm/dd time-stamp-yyyy/mm/dd time-stamp-yyyy-mm-dd time-stamp-yymmdd time-stamp-hh:mm:ss time-stamp-hhmm))) (while obsolete-functions (make-obsolete (car obsolete-functions) "use time-stamp-string or format-time-string instead." "20.1") (setq obsolete-functions (cdr obsolete-functions)))) ;;; pretty form, suitable for a title page (defun time-stamp-month-dd-yyyy () "Return the current date as a string in \"Month DD, YYYY\" form." (format-time-string "%B %e, %Y")) (defun time-stamp-dd/mm/yyyy () "Return the current date as a string in \"DD/MM/YYYY\" form." (format-time-string "%d/%m/%Y")) ;;; same as __DATE__ in ANSI C (defun time-stamp-mon-dd-yyyy () "Return the current date as a string in \"Mon DD YYYY\" form. The first character of DD is space if the value is less than 10." (format-time-string "%b %d %Y")) ;;; RFC 822 date (defun time-stamp-dd-mon-yy () "Return the current date as a string in \"DD Mon YY\" form." (format-time-string "%d %b %y")) ;;; RCS 3 date (defun time-stamp-yy/mm/dd () "Return the current date as a string in \"YY/MM/DD\" form." (format-time-string "%y/%m/%d")) ;;; RCS 5 date (defun time-stamp-yyyy/mm/dd () "Return the current date as a string in \"YYYY/MM/DD\" form." (format-time-string "%Y/%m/%d")) ;;; ISO 8601 date (defun time-stamp-yyyy-mm-dd () "Return the current date as a string in \"YYYY-MM-DD\" form." (format-time-string "%Y-%m-%d")) (defun time-stamp-yymmdd () "Return the current date as a string in \"YYMMDD\" form." (format-time-string "%y%m%d")) (defun time-stamp-hh:mm:ss () "Return the current time as a string in \"HH:MM:SS\" form." (format-time-string "%T")) (defun time-stamp-hhmm () "Return the current time as a string in \"HHMM\" form." (format-time-string "%H%M")) (provide 'time-stamp) ;;; arch-tag: 8a12c5c3-25d6-4a71-adc5-24b0e025a1e7 ;;; time-stamp.el ends here