From 9e705206aca6f21f5b507af174cb12655dfa6b6b Mon Sep 17 00:00:00 2001 From: Stephen Gildea Date: Sat, 29 May 2021 22:54:30 -0700 Subject: time-stamp: improve unit-test coverage * test/lisp/time-stamp-tests.el (time-stamp-format-year-4digit, time-stamp-format-ignored-modifiers): Improve coverage with more cases. (time-stamp-format-multiple-conversions): New test. --- test/lisp/time-stamp-tests.el | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) (limited to 'test/lisp/time-stamp-tests.el') diff --git a/test/lisp/time-stamp-tests.el b/test/lisp/time-stamp-tests.el index 4ae3c1917dd..c0213536303 100644 --- a/test/lisp/time-stamp-tests.el +++ b/test/lisp/time-stamp-tests.el @@ -486,7 +486,10 @@ "Test time-stamp format %Y." (with-time-stamp-test-env ;; implemented since 1997, documented since 2019 - (should (equal (time-stamp-string "%Y" ref-time1) "2006")))) + (should (equal (time-stamp-string "%Y" ref-time1) "2006")) + ;; numbers do not truncate + (should (equal (time-stamp-string "%2Y" ref-time1) "2006")) + (should (equal (time-stamp-string "%02Y" ref-time1) "2006")))) (ert-deftest time-stamp-format-am-pm () "Test time-stamp formats for AM and PM strings." @@ -586,6 +589,9 @@ (should (equal (time-stamp-string "%(st(u)ff)B" ref-time3) May)) ;; escaped parens do not change the nesting level (should (equal (time-stamp-string "%(st\\)u\\(ff)B" ref-time3) May)) + ;; incorrectly nested parens do not crash us + (should-not (equal (time-stamp-string "%(stuffB" ref-time3) May)) + (should-not (equal (time-stamp-string "%)B" ref-time3) May)) ;; not all punctuation is allowed (should-not (equal (time-stamp-string "%&B" ref-time3) May))))) @@ -594,6 +600,33 @@ (with-time-stamp-test-env (should (equal (time-stamp-string "No percent" ref-time1) "No percent")))) +(ert-deftest time-stamp-format-multiple-conversions () + "Tests that multiple %-conversions are independent." + (with-time-stamp-test-env + (let ((Mon (format-time-string "%a" ref-time1 t)) + (MON (format-time-string "%^a" ref-time1 t)) + (Monday (format-time-string "%A" ref-time1 t))) + ;; change-case flag is independent + (should (equal (time-stamp-string "%a.%#a.%a" ref-time1) + (concat Mon "." MON "." Mon))) + ;; up-case flag is independent + (should (equal (time-stamp-string "%a.%^a.%a" ref-time1) + (concat Mon "." MON "." Mon))) + ;; underscore flag is independent + (should (equal (time-stamp-string "%_d.%d.%_d" ref-time1) " 2.02. 2")) + ;; minus flag is independendent + (should (equal (time-stamp-string "%d.%-d.%d" ref-time1) "02.2.02")) + ;; 0 flag is independendent + (should (equal (time-stamp-string "%2d.%02d.%2d" ref-time1) " 2.02. 2")) + ;; field width is independent + (should (equal + (time-stamp-string "%6Y.%Y.%6Y" ref-time1) " 2006.2006. 2006")) + ;; colon modifier is independent + (should (equal (time-stamp-string "%a.%:a.%a" ref-time1) + (concat Mon "." Monday "." Mon))) + ;; format letter is independent + (should (equal (time-stamp-string "%H:%M" ref-time1) "15:04"))))) + (ert-deftest time-stamp-format-string-width () "Test time-stamp string width modifiers." (with-time-stamp-test-env -- cgit v1.2.3 From a5b57fc6af7ec87c59d00a7631576f9f4bf99841 Mon Sep 17 00:00:00 2001 From: Stephen Gildea Date: Sun, 30 May 2021 11:05:42 -0700 Subject: time-stamp: fix minor bug when parsing option combos * lisp/time-stamp.el (time-stamp-string-preprocess): Handle digit options correctly to avoid overcounting colon options. * test/lisp/time-stamp-tests.el (time-stamp-format-time-zone-offset): Add a new test case that would have caught the option-parsing error. --- lisp/time-stamp.el | 4 +++- test/lisp/time-stamp-tests.el | 3 ++- 2 files changed, 5 insertions(+), 2 deletions(-) (limited to 'test/lisp/time-stamp-tests.el') diff --git a/lisp/time-stamp.el b/lisp/time-stamp.el index 42455ddfe33..0cc566f0d8c 100644 --- a/lisp/time-stamp.el +++ b/lisp/time-stamp.el @@ -499,7 +499,8 @@ and all `time-stamp-format' compatibility." (< ind fmt-len))) (if (and (<= ?0 cur-char) (>= ?9 cur-char)) ;; get format width - (let ((field-index ind)) + (let ((field-index ind) + (first-digit cur-char)) (while (progn (setq ind (1+ ind)) (setq cur-char (if (< ind fmt-len) @@ -510,6 +511,7 @@ and all `time-stamp-format' compatibility." (setq field-width (substring format field-index ind)) (setq ind (1- ind)) + (setq cur-char first-digit) t)))) (setq prev-char cur-char) ;; some characters we actually use diff --git a/test/lisp/time-stamp-tests.el b/test/lisp/time-stamp-tests.el index c0213536303..b42271e4e51 100644 --- a/test/lisp/time-stamp-tests.el +++ b/test/lisp/time-stamp-tests.el @@ -525,7 +525,7 @@ (should (equal (time-stamp-string "%#Z" ref-time1) utc-abbr))))) (ert-deftest time-stamp-format-time-zone-offset () - "Test time-stamp format %z." + "Tests time-stamp legacy format %z and new offset format %5z." (with-time-stamp-test-env (let ((utc-abbr (format-time-string "%#Z" ref-time1 t))) ;; documented 1995-2019, warned since 2019, will change @@ -544,6 +544,7 @@ (should (equal (time-stamp-string "%_z" ref-time1) "+0000")) (should (equal (time-stamp-string "%:z" ref-time1) "+00:00")) (should (equal (time-stamp-string "%::z" ref-time1) "+00:00:00")) + (should (equal (time-stamp-string "%9::z" ref-time1) "+00:00:00")) (should (equal (time-stamp-string "%:::z" ref-time1) "+00")))) (ert-deftest time-stamp-format-non-date-conversions () -- cgit v1.2.3 From 64dd2b1a2a0a65a571c2bef5a004fd59cd61bb1e Mon Sep 17 00:00:00 2001 From: Stephen Gildea Date: Mon, 21 Jun 2021 21:28:20 -0700 Subject: time-stamp: add principled, expressive %z * lisp/time-stamp.el (time-stamp-formatz-from-parsed-options): New function for time zone offset formatting ("%z" variants). * test/lisp/time-stamp-tests.el (formatz*): New unit tests to cover the new implementation of %5z. --- lisp/time-stamp.el | 241 +++++++++++++++++++++--- test/lisp/time-stamp-tests.el | 414 +++++++++++++++++++++++++++++++++++++++++- 2 files changed, 624 insertions(+), 31 deletions(-) (limited to 'test/lisp/time-stamp-tests.el') diff --git a/lisp/time-stamp.el b/lisp/time-stamp.el index 0cc566f0d8c..ae911717151 100644 --- a/lisp/time-stamp.el +++ b/lisp/time-stamp.el @@ -25,7 +25,7 @@ ;; 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>"; +;; static char *ts = "sdmain.c Time-stamp: <2020-04-18 14:10:21 gildea>"; ;; To use time-stamping, add this line to your init file: ;; (add-hook 'before-save-hook 'time-stamp) @@ -278,7 +278,7 @@ 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> + Time-stamp: <2020-08-07 17:10:21 gildea> The time stamp is updated only if the variable `time-stamp-active' is non-nil. @@ -422,7 +422,7 @@ Returns the end point, which is where `time-stamp' begins the next search." ;;;###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." +With ARG, turn time stamping on if and only if ARG is positive." (interactive "P") (setq time-stamp-active (if (null arg) @@ -457,7 +457,7 @@ normally the current time is used." (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' +Implements extensions to `format-time-string' and all `time-stamp-format' compatibility." (let ((fmt-len (length format)) (ind 0) @@ -477,6 +477,9 @@ and all `time-stamp-format' compatibility." (alt-form 0) (change-case nil) (upcase nil) + (flag-pad-with-spaces nil) + (flag-pad-with-zeros nil) + (flag-minimize nil) (paren-level 0)) ;; eat any additional args to allow for future expansion (while (progn @@ -521,10 +524,12 @@ and all `time-stamp-format' compatibility." (setq change-case t)) ((eq cur-char ?^) (setq upcase t)) + ((eq cur-char ?0) + (setq flag-pad-with-zeros t)) ((eq cur-char ?-) - (setq field-width "1")) + (setq field-width "1" flag-minimize t)) ((eq cur-char ?_) - (setq field-width "2")))) + (setq field-width "2" flag-pad-with-spaces t)))) (setq field-result (cond ((eq cur-char ?%) @@ -586,26 +591,37 @@ and all `time-stamp-format' compatibility." ((eq cur-char ?Y) ;4-digit year (string-to-number (time-stamp--format "%Y" time))) ((eq cur-char ?z) ;time zone offset - (if change-case - "" ;discourage %z variations - (cond ((= alt-form 0) - (if (string-equal field-width "") - (progn - (time-stamp-conv-warn "%z" "%#Z") - (time-stamp--format "%#Z" time)) - (cond ((string-equal field-width "1") - (setq field-width "3")) ;%-z -> "+00" - ((string-equal field-width "2") - (setq field-width "5")) ;%_z -> "+0000" - ((string-equal field-width "4") - (setq field-width "0"))) ;discourage %4z - (time-stamp--format "%z" time))) - ((= alt-form 1) - (time-stamp--format "%:z" time)) - ((= alt-form 2) - (time-stamp--format "%::z" time)) - ((= alt-form 3) - (time-stamp--format "%:::z" time))))) + (let ((field-width-num (string-to-number field-width)) + ;; Handle numeric time zone ourselves, because + ;; current-time-zone cannot handle offsets + ;; greater than 24 hours. + (offset-secs + (cond ((numberp time-stamp-time-zone) + time-stamp-time-zone) + ((and (consp time-stamp-time-zone) + (numberp (car time-stamp-time-zone))) + (car time-stamp-time-zone)) + ;; interpret text time zone + (t (car (current-time-zone + time time-stamp-time-zone)))))) + ;; we do our own padding; do not let it be updated further + (setq field-width "") + (cond (change-case + "") ;discourage %z variations + ((and (= alt-form 0) + (not flag-minimize) + (not flag-pad-with-spaces) + (not flag-pad-with-zeros) + (= field-width-num 0)) + (time-stamp-conv-warn "%z" "%#Z") + (time-stamp--format "%#Z" time)) + (t (time-stamp-formatz-from-parsed-options + flag-minimize + flag-pad-with-spaces + flag-pad-with-zeros + alt-form + field-width-num + offset-secs))))) ((eq cur-char ?Z) ;time zone name (if change-case (time-stamp--format "%#Z" time) @@ -653,7 +669,8 @@ and all `time-stamp-format' compatibility." (string-to-number field-width)))) (if (> initial-length desired-length) ;; truncate strings on right - (if (stringp field-result) + (if (and (stringp field-result) + (not (eq cur-char ?z))) ;offset does not truncate (substring padded-result 0 desired-length) padded-result) ;numbers don't truncate padded-result))))) @@ -698,6 +715,176 @@ Suggests replacing OLD-FORM with NEW-FORM." (insert "\"" old-form "\" -- use " new-form "\n")) (display-buffer "*Time-stamp-compatibility*")))) +;;; A principled, expressive implementation of time zone offset +;;; formatting ("%z" and variants). + +;;; * Overarching principle for %z + +;; The output should be clear and complete. +;; +;; That is, +;; a) it should be unambiguous what offset is represented, and +;; b) it should be possible to exactly recreate the offset. + +;;; * Principles for %z + +;; - The numeric fields are HHMMSS. +;; - The fixed point is at the left. The first 2 digits are always +;; hours, the next 2 (if they exist) minutes, and next 2 (if they +;; exist) seconds. "+11" is 11 hours (not 11 minutes, not 11 seconds). +;; "+1015" is 10 hours 15 minutes (not 10 minutes 15 seconds). +;; - Each of the three numeric fields is two digits. +;; "+1" and "+100" are illegal. (Is that 1 hour? 10 hours? 100 hours?) +;; - The MMSS fields may be omitted only if both are 00. Thus, the width +;; of the field depends on the data. (This is similar to how +;; %B is always long enough to spell the entire month name.) +;; - The SS field may be omitted only if it is 00. +;; - Colons between the numeric fields are an option, unless the hours +;; field is greater than 99, when colons are needed to prevent ambiguity. +;; - If padding with zeros, we must pad on the right, because the +;; fixed point is at the left. (This is similar to how %N, +;; fractional seconds, must add its zeros on the right.) +;; - After zero-padding has filled out minutes and seconds with zeros, +;; further padding can be blanks only. +;; Any additional zeros would be confusing. + +;;; * Padding for %z + +;; Padding is under-specified, so we had to make choices. +;; +;; Principles guiding our choices: +;; +;; - The syntax should be easy to remember and the effect predictable. +;; - It should be possible to produces as many useful effects as possible. +;; +;; Padding choices: +;; +;; - By default, pad with spaces, as other formats with non-digits do. +;; The "0" flag pads first with zeros, until seconds are filled out. +;; - If padding with spaces, pad on the right. This is consistent with +;; how zero-padding works. Padding on the right also keeps the fixed +;; point in the same place, as other formats do for any given width. +;; - The %_z format always outputs seconds, allowing all added padding +;; to be spaces. Without this rule, there would be no way to +;; request seconds that worked for both 2- and 3-digit hours. +;; - Conflicting options are rejected, lest users depend +;; on incidental behavior. +;; +;; Padding combos that make no sense and are thus disallowed: +;; +;; %-:z - minus minimizes to hours, : expands to minutes +;; %-::z - minus minimizes to hours, :: expands to seconds +;; %_:z - underscore requires seconds, : displays minutes +;; %_:::z - underscore requires seconds, ::: minimizes to hours +;; +;; Example padding effects (with offsets of 99 and 100 hours): +;; +;; %-7z "+99 " "+100:00" +;; %7z "+9900 " "+100:00" +;; %07z "+990000" "+100:00" +;; %_7z "+990000" "+100:00:00" +;; +;; %7:::z "+99 " "+100:00" +;; %7:z "+99:00 " "+100:00" +;; %07:z "+99:00:00" "+100:00" +;; %7::z "+99:00:00" "+100:00:00" + +;;; * BNF syntax of the offset string produced by %z + +;; ::= [[]] | +;; [[]] | +;; [] +;; ::= "+"|"-" +;; ::= <2digits> +;; ::= <2digits> +;; ::= <2digits> +;; ::= ":" +;; ::= ":" +;; <2digits> ::= +;; ::= "0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9" +;; ::= *<2digits> +;; ::= " "* + +(defun time-stamp-formatz-from-parsed-options (flag-minimize + flag-pad-spaces-only + flag-pad-zeros-first + colon-count + field-width + offset-secs) + "Formats a time offset according to a %z variation. +The caller of this function must have already parsed the %z format +string; this function accepts just the parts of the format. + +With no flags, the output includes hours and minutes: +-HHMM +unless there is a non-zero seconds part, in which case the seconds +are included: +-HHMMSS + +FLAG-MINIMIZE is whether \"-\" was specified. If non-nil, the +output may be limited to hours if minutes and seconds are zero. + +FLAG-PAD-SPACES-ONLY is whether \"_\" was specified. If non-nil, +seconds must be output, so that any padding can be spaces only. + +FLAG-PAD-ZEROS-FIRST is whether \"0\" was specified. If non-nil, +padding to the requested FIELD-WIDTH (if any) is done by adding +00 seconds before padding with spaces. + +COLON-COUNT is the number of colons preceding the \"z\" (0-3). One or +two colons put that many colons in the output (+-HH:MM or +-HH:MM:SS). +Three colons outputs only hours if minutes and seconds are zero and +includes colon separators if minutes and seconds are output. + +FIELD-WIDTH is a whole number giving the minimum number of characters +in the output; 0 specifies no minimum. Additional characters will be +added on the right if necessary. The added characters will be spaces +unless FLAG-PAD-ZEROS-FIRST is non-nil. + +OFFSET-SECS is the time zone offset (in seconds east of UTC) to be +formatted according to the preceding parameters." + (let ((hrs (/ (abs offset-secs) 3600)) + (mins (/ (% (abs offset-secs) 3600) 60)) + (secs (% (abs offset-secs) 60)) + (result "")) + ;; valid option combo? + (cond + ((not (or (and flag-minimize (> colon-count 0)) + (and flag-pad-spaces-only (> colon-count 0)) + (and flag-pad-spaces-only flag-minimize) + (and flag-pad-spaces-only flag-pad-zeros-first) + (and flag-pad-zeros-first flag-minimize))) + (setq result (concat result (if (>= offset-secs 0) "+" "-"))) + (setq result (concat result (format "%02d" hrs))) + ;; Need minutes? + (cond + ((or (> hrs 99) + (> mins 0) + (> secs 0) + (not (or flag-minimize (= colon-count 3))) + (and (> field-width (length result)) + flag-pad-zeros-first)) + ;; Need colon before minutes? + (if (or (> colon-count 0) + (> hrs 99)) + (setq result (concat result ":"))) + (setq result (concat result (format "%02d" mins))) + ;; Need seconds, too? + (cond + ((or (> secs 0) + (= colon-count 2) + flag-pad-spaces-only + (and (> field-width (length result)) + flag-pad-zeros-first)) + ;; Need colon before seconds? + (if (or (> colon-count 0) + (> hrs 99)) + (setq result (concat result ":"))) + (setq result (concat result (format "%02d" secs))))))) + ;; Need padding? + (let ((needed-padding (- field-width (length result)))) + (if (> needed-padding 0) + (setq result (concat result (make-string needed-padding ?\s))))))) + result)) + (provide 'time-stamp) ;;; time-stamp.el ends here diff --git a/test/lisp/time-stamp-tests.el b/test/lisp/time-stamp-tests.el index b42271e4e51..e42a58a1685 100644 --- a/test/lisp/time-stamp-tests.el +++ b/test/lisp/time-stamp-tests.el @@ -525,7 +525,7 @@ (should (equal (time-stamp-string "%#Z" ref-time1) utc-abbr))))) (ert-deftest time-stamp-format-time-zone-offset () - "Tests time-stamp legacy format %z and new offset format %5z." + "Tests time-stamp legacy format %z and spot tests of new offset format %5z." (with-time-stamp-test-env (let ((utc-abbr (format-time-string "%#Z" ref-time1 t))) ;; documented 1995-2019, warned since 2019, will change @@ -540,8 +540,9 @@ (let ((time-stamp-time-zone "CET-1")) (should (equal (time-stamp-string "%5z" ref-time1) "+0100"))) ;; implemented since 2019, verify that these don't warn + ;; See also the "formatz" tests below, which since 2021 test more + ;; variants with more offsets. (should (equal (time-stamp-string "%-z" ref-time1) "+00")) - (should (equal (time-stamp-string "%_z" ref-time1) "+0000")) (should (equal (time-stamp-string "%:z" ref-time1) "+00:00")) (should (equal (time-stamp-string "%::z" ref-time1) "+00:00:00")) (should (equal (time-stamp-string "%9::z" ref-time1) "+00:00:00")) @@ -615,16 +616,24 @@ (concat Mon "." MON "." Mon))) ;; underscore flag is independent (should (equal (time-stamp-string "%_d.%d.%_d" ref-time1) " 2.02. 2")) - ;; minus flag is independendent + (should (equal (time-stamp-string "%_7z.%7z.%_7z" ref-time1) + "+000000.+0000 .+000000")) + ;; minus flag is independent (should (equal (time-stamp-string "%d.%-d.%d" ref-time1) "02.2.02")) - ;; 0 flag is independendent + (should (equal (time-stamp-string "%3z.%-3z.%3z" ref-time1) + "+0000.+00.+0000")) + ;; 0 flag is independent (should (equal (time-stamp-string "%2d.%02d.%2d" ref-time1) " 2.02. 2")) + (should (equal (time-stamp-string "%6:::z.%06:::z.%6:::z" ref-time1) + "+00 .+00:00.+00 ")) ;; field width is independent (should (equal (time-stamp-string "%6Y.%Y.%6Y" ref-time1) " 2006.2006. 2006")) ;; colon modifier is independent (should (equal (time-stamp-string "%a.%:a.%a" ref-time1) (concat Mon "." Monday "." Mon))) + (should (equal (time-stamp-string "%5z.%5::z.%5z" ref-time1) + "+0000.+00:00:00.+0000")) ;; format letter is independent (should (equal (time-stamp-string "%H:%M" ref-time1) "15:04"))))) @@ -691,4 +700,401 @@ (should (safe-local-variable-p 'time-stamp-pattern "a string")) (should-not (safe-local-variable-p 'time-stamp-pattern 17))) +;;;; Setup for tests of time offset formatting with %z + +(defun formatz (format zone) + "Uses time FORMAT string to format the offset of ZONE, returning the result. +FORMAT is \"%z\" or a variation. +ZONE is as the ZONE argument of the `format-time-string' function." + (with-time-stamp-test-env + (let ((time-stamp-time-zone zone)) + ;; Call your favorite time formatter here. + ;; For narrower-scope unit testing, + ;; instead of calling time-stamp-string here, + ;; we could directly call (format-time-offset format zone) + (time-stamp-string format) + ))) + +(defun format-time-offset (format offset-secs) + "Uses FORMAT to format the time zone represented by OFFSET-SECS. +FORMAT must be \"%z\", possibly with a flag and padding. +This function is a wrapper around `time-stamp-formatz-from-parsed-options' +and is used for testing." + ;; This wrapper adds a simple regexp-based parser that handles only + ;; %z and variants. In normal use, time-stamp-formatz-from-parsed-options + ;; is called from a parser that handles all time string formats. + (string-match + "\\`\\([^%]*\\)%\\([-_]?\\)\\(0?\\)\\([1-9][0-9]*\\)?\\([EO]?\\)\\(:*\\)\\([^a-zA-Z]+\\)?z\\(.*\\)" + format) + (let ((leading-string (match-string 1 format)) + (flag-minimize (seq-find (lambda (x) (eq x ?-)) + (match-string 2 format))) + (flag-pad-with-spaces (seq-find (lambda (x) (eq x ?_)) + (match-string 2 format))) + (flag-pad-with-zeros (equal (match-string 3 format) "0")) + (field-width (string-to-number (or (match-string 4 format) ""))) + (colon-count (length (match-string 6 format))) + (garbage (match-string 7 format)) + (trailing-string (match-string 8 format))) + (concat leading-string + (if garbage + "" + (time-stamp-formatz-from-parsed-options flag-minimize + flag-pad-with-spaces + flag-pad-with-zeros + colon-count + field-width + offset-secs)) + trailing-string))) + +(defun fz-make+zone (h &optional m s) + "Creates a non-negative offset." + (let ((m (or m 0)) + (s (or s 0))) + (+ (* 3600 h) (* 60 m) s))) + +(defun fz-make-zone (h &optional m s) + "Creates a negative offset. The arguments are all non-negative." + (- (fz-make+zone h m s))) + +(defmacro formatz-should-equal (zone expect) + "Formats ZONE and compares it to EXPECT. +Uses the free variables `form-string' and `pattern-mod'. +The functions in `pattern-mod' are composed left to right." + `(let ((result ,expect)) + (dolist (fn pattern-mod) + (setq result (funcall fn result))) + (should (equal (formatz form-string ,zone) result)))) + +;; These test cases have zeros in all places (first, last, none, both) +;; for hours, minutes, and seconds. + +(defun formatz-hours-exact-helper (form-string pattern-mod) + "Tests format %z with whole hours." + (formatz-should-equal (fz-make+zone 0) "+00") ;0 sign always +, both digits + (formatz-should-equal (fz-make+zone 10) "+10") + (formatz-should-equal (fz-make-zone 10) "-10") + (formatz-should-equal (fz-make+zone 2) "+02") + (formatz-should-equal (fz-make-zone 2) "-02") + (formatz-should-equal (fz-make+zone 13) "+13") + (formatz-should-equal (fz-make-zone 13) "-13") + ) + +(defun formatz-nonzero-minutes-helper (form-string pattern-mod) + "Tests format %z with whole minutes." + (formatz-should-equal (fz-make+zone 0 30) "+00:30") ;has hours even though 0 + (formatz-should-equal (fz-make-zone 0 30) "-00:30") + (formatz-should-equal (fz-make+zone 0 4) "+00:04") + (formatz-should-equal (fz-make-zone 0 4) "-00:04") + (formatz-should-equal (fz-make+zone 8 40) "+08:40") + (formatz-should-equal (fz-make-zone 8 40) "-08:40") + (formatz-should-equal (fz-make+zone 0 15) "+00:15") + (formatz-should-equal (fz-make-zone 0 15) "-00:15") + (formatz-should-equal (fz-make+zone 11 30) "+11:30") + (formatz-should-equal (fz-make-zone 11 30) "-11:30") + (formatz-should-equal (fz-make+zone 3 17) "+03:17") + (formatz-should-equal (fz-make-zone 3 17) "-03:17") + (formatz-should-equal (fz-make+zone 12 45) "+12:45") + (formatz-should-equal (fz-make-zone 12 45) "-12:45") + ) + +(defun formatz-nonzero-seconds-helper (form-string pattern-mod) + "Tests format %z with non-0 seconds." + ;; non-0 seconds are always included + (formatz-should-equal (fz-make+zone 0 0 50) "+00:00:50") + (formatz-should-equal (fz-make-zone 0 0 50) "-00:00:50") + (formatz-should-equal (fz-make+zone 0 0 06) "+00:00:06") + (formatz-should-equal (fz-make-zone 0 0 06) "-00:00:06") + (formatz-should-equal (fz-make+zone 0 7 50) "+00:07:50") + (formatz-should-equal (fz-make-zone 0 7 50) "-00:07:50") + (formatz-should-equal (fz-make+zone 0 0 16) "+00:00:16") + (formatz-should-equal (fz-make-zone 0 0 16) "-00:00:16") + (formatz-should-equal (fz-make+zone 0 12 36) "+00:12:36") + (formatz-should-equal (fz-make-zone 0 12 36) "-00:12:36") + (formatz-should-equal (fz-make+zone 0 3 45) "+00:03:45") + (formatz-should-equal (fz-make-zone 0 3 45) "-00:03:45") + (formatz-should-equal (fz-make+zone 8 45 30) "+08:45:30") + (formatz-should-equal (fz-make-zone 8 45 30) "-08:45:30") + (formatz-should-equal (fz-make+zone 0 11 45) "+00:11:45") + (formatz-should-equal (fz-make-zone 0 11 45) "-00:11:45") + (formatz-should-equal (fz-make+zone 3 20 15) "+03:20:15") + (formatz-should-equal (fz-make-zone 3 20 15) "-03:20:15") + (formatz-should-equal (fz-make+zone 11 14 30) "+11:14:30") + (formatz-should-equal (fz-make-zone 11 14 30) "-11:14:30") + (formatz-should-equal (fz-make+zone 12 30 49) "+12:30:49") + (formatz-should-equal (fz-make-zone 12 30 49) "-12:30:49") + (formatz-should-equal (fz-make+zone 12 0 34) "+12:00:34") + (formatz-should-equal (fz-make-zone 12 0 34) "-12:00:34") + ) + +(defun formatz-hours-big-helper (form-string pattern-mod) + "Tests format %z with hours that don't fit in two digits." + (formatz-should-equal (fz-make+zone 101) "+101:00") + (formatz-should-equal (fz-make+zone 123 10) "+123:10") + (formatz-should-equal (fz-make-zone 123 10) "-123:10") + (formatz-should-equal (fz-make+zone 123 2) "+123:02") + (formatz-should-equal (fz-make-zone 123 2) "-123:02") + ) + +(defun formatz-seconds-big-helper (form-string pattern-mod) + "Tests format %z with hours greater than 99 and non-zero seconds." + (formatz-should-equal (fz-make+zone 123 0 30) "+123:00:30") + (formatz-should-equal (fz-make-zone 123 0 30) "-123:00:30") + (formatz-should-equal (fz-make+zone 120 0 4) "+120:00:04") + (formatz-should-equal (fz-make-zone 120 0 4) "-120:00:04") + ) + +;; Functions that modify the expected output string, so that we can +;; use the above test cases for multiple formats. + +(defun formatz-mod-del-colons (string) + "Returns STRING with any colons removed." + (replace-regexp-in-string ":" "" string)) + +(defun formatz-mod-add-00 (string) + "Returns STRING with \"00\" appended." + (concat string "00")) + +(defun formatz-mod-add-colon00 (string) + "Returns STRING with \":00\" appended." + (concat string ":00")) + +(defun formatz-mod-pad-r10 (string) + "Returns STRING padded on the right to 10 characters." + (concat string (make-string (- 10 (length string)) ?\s))) + +(defun formatz-mod-pad-r12 (string) + "Returns STRING padded on the right to 12 characters." + (concat string (make-string (- 12 (length string)) ?\s))) + +;; Convenience macro for generating groups of test cases. + +(defmacro formatz-generate-tests + (form-strings hour-mod mins-mod secs-mod big-mod secbig-mod) + "Defines ert-deftest tests for time formats FORM-STRINGS. +FORM-STRINGS is a list of formats, each \"%z\" or some variation thereof. + +Each of the remaining arguments is an unquoted list of the form +(SAMPLE-OUTPUT . MODIFIERS). SAMPLE-OUTPUT is the result of the +FORM-STRINGS for a particular offset, detailed below for each argument. +The remaining elements of the list, the MODIFIERS, are the names of +functions to modify the expected results for sets of tests. +The MODIFIERS do not modify the SAMPLE-OUTPUT. + +The one, literal sample output is given in the call to this macro +to provide a visual check at the call site that the format +behaves as expected. + +HOUR-MOD is the result for offset 0 and modifiers for the other +expected results for whole hours. +MINS-MOD is the result for offset +30 minutes and modifiers for the +other expected results for whole minutes. +SECS-MOD is the result for offset +30 seconds and modifiers for the +other expected results for offsets with non-zero seconds. +BIG-MOD is the result for offset +100 hours and modifiers for the other +expected results for hours greater than 99 with a whole number of minutes. +SECBIG-MOD is the result for offset +100 hours 30 seconds and modifiers for +the other expected results for hours greater than 99 with non-zero seconds." + (declare (indent 1)) + ;; Generate a form to create a list of tests to define. When this + ;; macro is called, the form is evaluated, thus defining the tests. + (let ((ert-test-list '(list))) + (dolist (form-string form-strings ert-test-list) + (nconc + ert-test-list + (list + `(ert-deftest ,(intern (concat "formatz-" form-string "-hhmm")) () + (should (equal (formatz ,form-string (fz-make+zone 0)) + ,(car hour-mod))) + (formatz-hours-exact-helper ,form-string ',(cdr hour-mod)) + (should (equal (formatz ,form-string (fz-make+zone 0 30)) + ,(car mins-mod))) + (formatz-nonzero-minutes-helper ,form-string ',(cdr mins-mod))) + `(ert-deftest ,(intern (concat "formatz-" form-string "-secs")) () + (should (equal (formatz ,form-string (fz-make+zone 0 0 30)) + ,(car secs-mod))) + (formatz-nonzero-seconds-helper ,form-string ',(cdr secs-mod))) + `(ert-deftest ,(intern (concat "formatz-" form-string "-big")) () + (should (equal (formatz ,form-string (fz-make+zone 100)) + ,(car big-mod))) + (formatz-hours-big-helper ,form-string ',(cdr big-mod)) + (should (equal (formatz ,form-string (fz-make+zone 100 0 30)) + ,(car secbig-mod))) + (formatz-seconds-big-helper ,form-string ',(cdr secbig-mod))) + ))))) + +;;;; The actual test cases for %z + +;;; %z formats without colons. + +;; Option character "-" (minus) minimizes; it removes "00" minutes. +(formatz-generate-tests ("%-z" "%-3z") + ("+00") + ("+0030" formatz-mod-del-colons) + ("+000030" formatz-mod-del-colons) + ("+100:00") + ("+100:00:30")) +;; Tests that minus with padding pads with spaces. +(formatz-generate-tests ("%-12z") + ("+00 " formatz-mod-pad-r12) + ("+0030 " formatz-mod-del-colons formatz-mod-pad-r12) + ("+000030 " formatz-mod-del-colons formatz-mod-pad-r12) + ("+100:00 " formatz-mod-pad-r12) + ("+100:00:30 " formatz-mod-pad-r12)) +;; Tests that 0 after other digits becomes padding of ten, not zero flag. +(formatz-generate-tests ("%-10z") + ("+00 " formatz-mod-pad-r10) + ("+0030 " formatz-mod-del-colons formatz-mod-pad-r10) + ("+000030 " formatz-mod-del-colons formatz-mod-pad-r10) + ("+100:00 " formatz-mod-pad-r10) + ("+100:00:30")) + +;; Although time-stamp doesn't call us for %z, we do want to spot-check +;; it here, to verify the implementation we will eventually use. +;; The legacy exception for %z in time-stamp will need to remain +;; through at least 2024 and Emacs 28. +(ert-deftest formatz-%z-spotcheck () + (should (equal (format-time-offset "%z" (fz-make+zone 0)) "+0000")) + (should (equal (format-time-offset "%z" (fz-make+zone 0 30)) "+0030")) + (should (equal (format-time-offset "%z" (fz-make+zone 0 0 30)) "+000030")) + (should (equal (format-time-offset "%z" (fz-make+zone 100)) "+100:00")) + (should (equal (format-time-offset "%z" (fz-make+zone 100 0 30)) "+100:00:30")) + ) + +;; Basic %z outputs 4 digits. +;; Small padding values do not extend the result. +(formatz-generate-tests (;; We don't check %z here because time-stamp + ;; has a legacy behavior for it. + ;;"%z" + "%5z" "%0z" "%05z") + ("+0000" formatz-mod-add-00) + ("+0030" formatz-mod-del-colons) + ("+000030" formatz-mod-del-colons) + ("+100:00") + ("+100:00:30")) + +;; Tests that padding adds spaces. +(formatz-generate-tests ("%12z") + ("+0000 " formatz-mod-add-00 formatz-mod-pad-r12) + ("+0030 " formatz-mod-del-colons formatz-mod-pad-r12) + ("+000030 " formatz-mod-del-colons formatz-mod-pad-r12) + ("+100:00 " formatz-mod-pad-r12) + ("+100:00:30 " formatz-mod-pad-r12)) + +;; Requiring 0-padding to 6 adds seconds (only) as needed. +(formatz-generate-tests ("%06z") + ("+000000" formatz-mod-add-00 formatz-mod-add-00) + ("+003000" formatz-mod-del-colons formatz-mod-add-00) + ("+000030" formatz-mod-del-colons) + ("+100:00") + ("+100:00:30")) + +;; Option character "_" always adds seconds. +(formatz-generate-tests ("%_z" "%_7z") + ("+000000" formatz-mod-add-00 formatz-mod-add-00) + ("+003000" formatz-mod-del-colons formatz-mod-add-00) + ("+000030" formatz-mod-del-colons) + ("+100:00:00" formatz-mod-add-colon00) + ("+100:00:30")) + +;; Enough 0-padding adds seconds, then adds spaces. +(formatz-generate-tests ("%012z" "%_12z") + ("+000000 " formatz-mod-add-00 formatz-mod-add-00 formatz-mod-pad-r12) + ("+003000 " formatz-mod-del-colons formatz-mod-add-00 formatz-mod-pad-r12) + ("+000030 " formatz-mod-del-colons formatz-mod-pad-r12) + ("+100:00:00 " formatz-mod-add-colon00 formatz-mod-pad-r12) + ("+100:00:30 " formatz-mod-pad-r12)) + +;;; %z formats with colons + +;; Three colons can output hours only, +;; like %-z, but uses colons with non-zero minutes and seconds. +(formatz-generate-tests ("%:::z" "%0:::z" + "%3:::z" "%03:::z") + ("+00") + ("+00:30") + ("+00:00:30") + ("+100:00") + ("+100:00:30")) + +;; Padding with three colons adds spaces +(formatz-generate-tests ("%12:::z") + ("+00 " formatz-mod-pad-r12) + ("+00:30 " formatz-mod-pad-r12) + ("+00:00:30 " formatz-mod-pad-r12) + ("+100:00 " formatz-mod-pad-r12) + ("+100:00:30 " formatz-mod-pad-r12)) +;; Tests that 0 after other digits becomes padding of ten, not zero flag. +(formatz-generate-tests ("%10:::z") + ("+00 " formatz-mod-pad-r10) + ("+00:30 " formatz-mod-pad-r10) + ("+00:00:30 " formatz-mod-pad-r10) + ("+100:00 " formatz-mod-pad-r10) + ("+100:00:30")) + +;; One colon outputs minutes, like %z but with colon. +(formatz-generate-tests ("%:z" "%6:z" "%0:z" "%06:z" "%06:::z") + ("+00:00" formatz-mod-add-colon00) + ("+00:30") + ("+00:00:30") + ("+100:00") + ("+100:00:30")) + +;; Padding with one colon adds spaces +(formatz-generate-tests ("%12:z") + ("+00:00 " formatz-mod-add-colon00 formatz-mod-pad-r12) + ("+00:30 " formatz-mod-pad-r12) + ("+00:00:30 " formatz-mod-pad-r12) + ("+100:00 " formatz-mod-pad-r12) + ("+100:00:30 " formatz-mod-pad-r12)) + +;; Requiring 0-padding to 7 adds seconds (only) as needed. +(formatz-generate-tests ("%07:z" "%07:::z") + ("+00:00:00" formatz-mod-add-colon00 formatz-mod-add-colon00) + ("+00:30:00" formatz-mod-add-colon00) + ("+00:00:30") + ("+100:00") + ("+100:00:30")) + +;; Two colons outputs HH:MM:SS, like %_z but with colons. +(formatz-generate-tests ("%::z" "%9::z" "%0::z" "%09::z") + ("+00:00:00" formatz-mod-add-colon00 formatz-mod-add-colon00) + ("+00:30:00" formatz-mod-add-colon00) + ("+00:00:30") + ("+100:00:00" formatz-mod-add-colon00) + ("+100:00:30")) + +;; Enough padding adds minutes and seconds, then adds spaces. +(formatz-generate-tests ("%012:z" "%012::z" "%12::z" "%012:::z") + ("+00:00:00 " formatz-mod-add-colon00 formatz-mod-add-colon00 + formatz-mod-pad-r12) + ("+00:30:00 " formatz-mod-add-colon00 formatz-mod-pad-r12) + ("+00:00:30 " formatz-mod-pad-r12) + ("+100:00:00 " formatz-mod-add-colon00 formatz-mod-pad-r12) + ("+100:00:30 " formatz-mod-pad-r12)) + +;;; Illegal %z formats + +(ert-deftest formatz-illegal-options () + "Tests that illegal/nonsensical/ambiguous %z formats don't produce output." + ;; multiple options + (should (equal "" (formatz "%_-z" 0))) + (should (equal "" (formatz "%-_z" 0))) + (should (equal "" (formatz "%_0z" 0))) + (should (equal "" (formatz "%0_z" 0))) + (should (equal "" (formatz "%0-z" 0))) + (should (equal "" (formatz "%-0z" 0))) + ;; inconsistent to both minimize and require mins or secs + (should (equal "" (formatz "%-:z" 0))) + (should (equal "" (formatz "%-::z" 0))) + ;; consistent, but redundant + (should (equal "" (formatz "%-:::z" 0))) + (should (equal "" (formatz "%_::z" 0))) + ;; inconsistent to both pre-expand and default to hours or mins + (should (equal "" (formatz "%_:::z" 0))) + (should (equal "" (formatz "%_:z" 0))) + ;; options that don't make sense with %z + (should (equal "" (formatz "%#z" 0))) + ) + ;;; time-stamp-tests.el ends here -- cgit v1.2.3 From 87a432455d7ddc466da55df1ade5a647511740b6 Mon Sep 17 00:00:00 2001 From: Stephen Gildea Date: Sun, 18 Jul 2021 08:38:37 -0700 Subject: Add doc string to time-stamp-tests that didn't have one * test/lisp/time-stamp-tests.el (formatz-generate-tests, formatz-%z-spotcheck): Add doc strings to tests. --- test/lisp/time-stamp-tests.el | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) (limited to 'test/lisp/time-stamp-tests.el') diff --git a/test/lisp/time-stamp-tests.el b/test/lisp/time-stamp-tests.el index e42a58a1685..0d64320496d 100644 --- a/test/lisp/time-stamp-tests.el +++ b/test/lisp/time-stamp-tests.el @@ -904,17 +904,23 @@ the other expected results for hours greater than 99 with non-zero seconds." ert-test-list (list `(ert-deftest ,(intern (concat "formatz-" form-string "-hhmm")) () + ,(concat "Tests time-stamp format " form-string + " with whole hours or minutes.") (should (equal (formatz ,form-string (fz-make+zone 0)) ,(car hour-mod))) (formatz-hours-exact-helper ,form-string ',(cdr hour-mod)) (should (equal (formatz ,form-string (fz-make+zone 0 30)) ,(car mins-mod))) (formatz-nonzero-minutes-helper ,form-string ',(cdr mins-mod))) - `(ert-deftest ,(intern (concat "formatz-" form-string "-secs")) () + `(ert-deftest ,(intern (concat "formatz-" form-string "-seconds")) () + ,(concat "Tests time-stamp format " form-string + " with offsets that have non-zero seconds.") (should (equal (formatz ,form-string (fz-make+zone 0 0 30)) ,(car secs-mod))) (formatz-nonzero-seconds-helper ,form-string ',(cdr secs-mod))) - `(ert-deftest ,(intern (concat "formatz-" form-string "-big")) () + `(ert-deftest ,(intern (concat "formatz-" form-string "-threedigit")) () + ,(concat "Tests time-stamp format " form-string + " with offsets that are 100 hours or greater.") (should (equal (formatz ,form-string (fz-make+zone 100)) ,(car big-mod))) (formatz-hours-big-helper ,form-string ',(cdr big-mod)) @@ -954,6 +960,7 @@ the other expected results for hours greater than 99 with non-zero seconds." ;; The legacy exception for %z in time-stamp will need to remain ;; through at least 2024 and Emacs 28. (ert-deftest formatz-%z-spotcheck () + "Spot-checks internal implementation of time-stamp format %z." (should (equal (format-time-offset "%z" (fz-make+zone 0)) "+0000")) (should (equal (format-time-offset "%z" (fz-make+zone 0 30)) "+0030")) (should (equal (format-time-offset "%z" (fz-make+zone 0 0 30)) "+000030")) -- cgit v1.2.3 From 051434fdefd6418bf1f0cd28c087b31cb3921f48 Mon Sep 17 00:00:00 2001 From: Mattias Engdegård Date: Sun, 8 Aug 2021 18:58:46 +0200 Subject: Use string-replace instead of replace-regexp-in-string `string-replace` is easier to understand, less error-prone, much faster, and results in shorter Lisp and byte code. Use it where applicable and obviously safe (erring on the conservative side). * admin/authors.el (authors-scan-change-log): * lisp/autoinsert.el (auto-insert-alist): * lisp/calc/calc-prog.el (calc-edit-macro-combine-alg-ent) (calc-edit-macro-combine-ext-command) (calc-edit-macro-combine-var-name): * lisp/calc/calc-units.el (math-make-unit-string): * lisp/calendar/cal-html.el (cal-html-comment): * lisp/calendar/cal-tex.el (cal-tex-comment): * lisp/calendar/icalendar.el (icalendar--convert-string-for-export) (icalendar--convert-string-for-import): * lisp/calendar/iso8601.el (iso8601--concat-regexps) (iso8601--full-time-match, iso8601--combined-match): * lisp/calendar/time-date.el (format-seconds): * lisp/calendar/todo-mode.el (todo-filter-items-filename): * lisp/cedet/cedet-files.el (cedet-directory-name-to-file-name) (cedet-file-name-to-directory-name): * lisp/comint.el (comint-watch-for-password-prompt): * lisp/dired-aux.el (dired-do-chmod): * lisp/dired-x.el (dired-man): * lisp/dired.el (dired-insert-directory, dired-goto-file-1): * lisp/emacs-lisp/comp.el (comp-c-func-name): * lisp/emacs-lisp/re-builder.el (reb-copy): * lisp/erc/erc-dcc.el (erc-dcc-unquote-filename): * lisp/erc/erc.el (erc-quit-reason-zippy, erc-part-reason-zippy) (erc-update-mode-line-buffer, erc-message-english-PART): * lisp/files.el (make-backup-file-name-1, files--transform-file-name) (read-file-modes): * lisp/fringe.el (fringe-mode): * lisp/gnus/gnus-art.el (gnus-button-handle-info-url): * lisp/gnus/gnus-group.el (gnus-group-completing-read): * lisp/gnus/gnus-icalendar.el (gnus-icalendar-event-from-ical): * lisp/gnus/gnus-mlspl.el (gnus-group-split-fancy): * lisp/gnus/gnus-search.el (gnus-search-query-parse-date) (gnus-search-transform-expression, gnus-search-run-search): * lisp/gnus/gnus-start.el (gnus-dribble-enter): * lisp/gnus/gnus-sum.el (gnus-summary-refer-article): * lisp/gnus/gnus-util.el (gnus-mode-string-quote): * lisp/gnus/message.el (message-put-addresses-in-ecomplete) (message-parse-mailto-url, message-mailto-1): * lisp/gnus/mml-sec.el (mml-secure-epg-sign): * lisp/gnus/mml-smime.el (mml-smime-epg-verify): * lisp/gnus/mml2015.el (mml2015-epg-verify): * lisp/gnus/nnmaildir.el (nnmaildir--system-name) (nnmaildir-request-list, nnmaildir-retrieve-groups) (nnmaildir-request-group, nnmaildir-retrieve-headers): * lisp/gnus/nnrss.el (nnrss-node-text): * lisp/gnus/spam-report.el (spam-report-gmane-internal) (spam-report-user-mail-address): * lisp/ibuffer.el (name): * lisp/image-dired.el (image-dired-pngnq-thumb) (image-dired-pngcrush-thumb, image-dired-optipng-thumb) (image-dired-create-thumb-1): * lisp/info.el (Info-set-mode-line): * lisp/international/mule-cmds.el (describe-language-environment): * lisp/mail/rfc2231.el (rfc2231-parse-string): * lisp/mail/rfc2368.el (rfc2368-parse-mailto-url): * lisp/mail/rmail.el (rmail-insert-inbox-text) (rmail-simplified-subject-regexp): * lisp/mail/rmailout.el (rmail-output-body-to-file): * lisp/mail/undigest.el (rmail-digest-rfc1153): * lisp/man.el (Man-default-man-entry): * lisp/mouse.el (minor-mode-menu-from-indicator): * lisp/mpc.el (mpc--debug): * lisp/net/browse-url.el (browse-url-mail): * lisp/net/eww.el (eww-update-header-line-format): * lisp/net/newst-backend.el (newsticker-save-item): * lisp/net/rcirc.el (rcirc-sentinel): * lisp/net/soap-client.el (soap-decode-date-time): * lisp/nxml/rng-cmpct.el (rng-c-literal-2-re): * lisp/nxml/xmltok.el (let*): * lisp/obsolete/nnir.el (nnir-run-swish-e, nnir-run-hyrex) (nnir-run-find-grep): * lisp/play/dunnet.el (dun-doassign): * lisp/play/handwrite.el (handwrite): * lisp/proced.el (proced-format-args): * lisp/profiler.el (profiler-report-header-line-format): * lisp/progmodes/gdb-mi.el (gdb-mi-quote): * lisp/progmodes/make-mode.el (makefile-bsdmake-rule-action-regex) (makefile-make-font-lock-keywords): * lisp/progmodes/prolog.el (prolog-guess-fill-prefix): * lisp/progmodes/ruby-mode.el (ruby-toggle-string-quotes): * lisp/progmodes/sql.el (sql-remove-tabs-filter, sql-str-literal): * lisp/progmodes/which-func.el (which-func-current): * lisp/replace.el (query-replace-read-from) (occur-engine, replace-quote): * lisp/select.el (xselect--encode-string): * lisp/ses.el (ses-export-tab): * lisp/subr.el (shell-quote-argument): * lisp/term/pc-win.el (msdos-show-help): * lisp/term/w32-win.el (w32--set-selection): * lisp/term/xterm.el (gui-backend-set-selection): * lisp/textmodes/picture.el (picture-tab-search): * lisp/thumbs.el (thumbs-call-setroot-command): * lisp/tooltip.el (tooltip-show-help-non-mode): * lisp/transient.el (transient-format-key): * lisp/url/url-mailto.el (url-mailto): * lisp/vc/log-edit.el (log-edit-changelog-ours-p): * lisp/vc/vc-bzr.el (vc-bzr-status): * lisp/vc/vc-hg.el (vc-hg--glob-to-pcre): * lisp/vc/vc-svn.el (vc-svn-after-dir-status): * lisp/xdg.el (xdg-desktop-strings): * test/lisp/electric-tests.el (defun): * test/lisp/term-tests.el (term-simple-lines): * test/lisp/time-stamp-tests.el (formatz-mod-del-colons): * test/lisp/wdired-tests.el (wdired-test-bug32173-01) (wdired-test-unfinished-edit-01): * test/src/json-tests.el (json-parse-with-custom-null-and-false-objects): Use `string-replace` instead of `replace-regexp-in-string`. --- admin/authors.el | 2 +- lisp/autoinsert.el | 4 ++-- lisp/calc/calc-prog.el | 8 ++++---- lisp/calc/calc-units.el | 2 +- lisp/calendar/cal-html.el | 2 +- lisp/calendar/cal-tex.el | 2 +- lisp/calendar/icalendar.el | 12 ++++++------ lisp/calendar/iso8601.el | 6 +++--- lisp/calendar/time-date.el | 2 +- lisp/calendar/todo-mode.el | 2 +- lisp/cedet/cedet-files.el | 4 ++-- lisp/comint.el | 2 +- lisp/dired-aux.el | 2 +- lisp/dired-x.el | 2 +- lisp/dired.el | 14 +++++++------- lisp/emacs-lisp/comp.el | 2 +- lisp/emacs-lisp/re-builder.el | 2 +- lisp/erc/erc-dcc.el | 4 ++-- lisp/erc/erc.el | 8 ++++---- lisp/files.el | 6 +++--- lisp/fringe.el | 2 +- lisp/gnus/gnus-art.el | 2 +- lisp/gnus/gnus-group.el | 2 +- lisp/gnus/gnus-icalendar.el | 8 ++++---- lisp/gnus/gnus-mlspl.el | 2 +- lisp/gnus/gnus-search.el | 10 +++++----- lisp/gnus/gnus-start.el | 2 +- lisp/gnus/gnus-sum.el | 2 +- lisp/gnus/gnus-util.el | 2 +- lisp/gnus/message.el | 8 ++++---- lisp/gnus/mml-sec.el | 2 +- lisp/gnus/mml-smime.el | 2 +- lisp/gnus/mml2015.el | 2 +- lisp/gnus/nnmaildir.el | 18 ++++++++---------- lisp/gnus/nnrss.el | 2 +- lisp/gnus/spam-report.el | 4 ++-- lisp/ibuffer.el | 2 +- lisp/image-dired.el | 8 ++++---- lisp/info.el | 4 ++-- lisp/international/mule-cmds.el | 2 +- lisp/mail/rfc2231.el | 2 +- lisp/mail/rfc2368.el | 2 +- lisp/mail/rmail.el | 4 ++-- lisp/mail/rmailout.el | 4 ++-- lisp/mail/undigest.el | 2 +- lisp/man.el | 2 +- lisp/mouse.el | 2 +- lisp/mpc.el | 4 ++-- lisp/net/browse-url.el | 2 +- lisp/net/eww.el | 2 +- lisp/net/newst-backend.el | 2 +- lisp/net/rcirc.el | 2 +- lisp/net/soap-client.el | 2 +- lisp/nxml/rng-cmpct.el | 2 +- lisp/nxml/xmltok.el | 2 +- lisp/obsolete/nnir.el | 12 ++++++------ lisp/play/dunnet.el | 2 +- lisp/play/handwrite.el | 2 +- lisp/proced.el | 2 +- lisp/profiler.el | 2 +- lisp/progmodes/gdb-mi.el | 2 +- lisp/progmodes/make-mode.el | 7 +++---- lisp/progmodes/prolog.el | 2 +- lisp/progmodes/ruby-mode.el | 4 ++-- lisp/progmodes/sql.el | 4 ++-- lisp/progmodes/which-func.el | 2 +- lisp/replace.el | 14 ++++++-------- lisp/select.el | 2 +- lisp/ses.el | 2 +- lisp/subr.el | 2 +- lisp/term/pc-win.el | 2 +- lisp/term/w32-win.el | 2 +- lisp/term/xterm.el | 5 ++--- lisp/textmodes/picture.el | 4 ++-- lisp/thumbs.el | 6 +++--- lisp/tooltip.el | 2 +- lisp/transient.el | 12 ++++++------ lisp/url/url-mailto.el | 2 +- lisp/vc/log-edit.el | 4 ++-- lisp/vc/vc-bzr.el | 2 +- lisp/vc/vc-hg.el | 4 ++-- lisp/vc/vc-svn.el | 2 +- lisp/xdg.el | 4 ++-- test/lisp/electric-tests.el | 2 +- test/lisp/term-tests.el | 2 +- test/lisp/time-stamp-tests.el | 2 +- test/lisp/wdired-tests.el | 4 ++-- test/src/json-tests.el | 2 +- 88 files changed, 164 insertions(+), 170 deletions(-) (limited to 'test/lisp/time-stamp-tests.el') diff --git a/admin/authors.el b/admin/authors.el index 6c81c7872fc..a400b1327af 100644 --- a/admin/authors.el +++ b/admin/authors.el @@ -1475,7 +1475,7 @@ Suggested\\|Trivial\\|Version\\|Originally\\|From:\\|Patch[ \t]+[Bb]y\\)"))) (when (string-match ":" line) (setq line (substring line 0 (match-beginning 0))) (setq line (replace-regexp-in-string "[[(<{].*$" "" line)) - (setq line (replace-regexp-in-string "," "" line)) + (setq line (string-replace "," "" line)) (dolist (file (split-string line)) (when (setq file (authors-canonical-file-name file log-file pos (car authors))) (dolist (author authors) diff --git a/lisp/autoinsert.el b/lisp/autoinsert.el index 0392903c332..995d9e2e0fe 100644 --- a/lisp/autoinsert.el +++ b/lisp/autoinsert.el @@ -93,8 +93,8 @@ If this contains a %s, that will be replaced by the matching rule." '((("\\.\\([Hh]\\|hh\\|hpp\\|hxx\\|h\\+\\+\\)\\'" . "C / C++ header") (replace-regexp-in-string "[^A-Z0-9]" "_" - (replace-regexp-in-string - "\\+" "P" + (string-replace + "+" "P" (upcase (file-name-nondirectory buffer-file-name)))) "#ifndef " str \n "#define " str "\n\n" diff --git a/lisp/calc/calc-prog.el b/lisp/calc/calc-prog.el index 4e27d7671e2..6f1e5c782df 100644 --- a/lisp/calc/calc-prog.el +++ b/lisp/calc/calc-prog.el @@ -802,8 +802,8 @@ (when match (kill-line 1) (setq line (concat line (substring curline 0 match)))) - (setq line (replace-regexp-in-string "SPC" " SPC " - (replace-regexp-in-string " " "" line))) + (setq line (string-replace "SPC" " SPC " + (string-replace " " "" line))) (insert line "\t\t\t") (if (> (current-column) 24) (delete-char -1)) @@ -830,7 +830,7 @@ (when match (kill-line 1) (setq line (concat line (substring curline 0 match)))) - (setq line (replace-regexp-in-string " " "" line)) + (setq line (string-replace " " "" line)) (insert cmdbeg " " line "\t\t\t") (if (> (current-column) 24) (delete-char -1)) @@ -857,7 +857,7 @@ (when match (kill-line 1) (setq line (concat line (substring curline 0 match)))) - (setq line (replace-regexp-in-string " " "" line)) + (setq line (string-replace " " "" line)) (insert line "\t\t\t") (if (> (current-column) 24) (delete-char -1)) diff --git a/lisp/calc/calc-units.el b/lisp/calc/calc-units.el index c3adc3db02a..8b6f0637035 100644 --- a/lisp/calc/calc-units.el +++ b/lisp/calc/calc-units.el @@ -406,7 +406,7 @@ Entries are (SYMBOL EXPR DOC-STRING TEMP-TYPE BASE-UNITS).") If EXPR is nil, return nil." (if expr (let ((cexpr (math-compose-expr expr 0))) - (replace-regexp-in-string + (string-replace " / " "/" (if (stringp cexpr) cexpr diff --git a/lisp/calendar/cal-html.el b/lisp/calendar/cal-html.el index e5810c3f027..58a5a0f83a5 100644 --- a/lisp/calendar/cal-html.el +++ b/lisp/calendar/cal-html.el @@ -151,7 +151,7 @@ (defun cal-html-comment (string) "Return STRING as html comment." (format "\n" - (replace-regexp-in-string "--" "++" string))) + (string-replace "--" "++" string))) (defun cal-html-href (link string) "Return a hyperlink to url LINK with text STRING." diff --git a/lisp/calendar/cal-tex.el b/lisp/calendar/cal-tex.el index f5932014dd9..3830024ef3d 100644 --- a/lisp/calendar/cal-tex.el +++ b/lisp/calendar/cal-tex.el @@ -1755,7 +1755,7 @@ current contents." COMMENT may contain newlines, which are prefixed by \"% \" in the output." (insert (format "%% %s\n" (if comment - (replace-regexp-in-string "\n" "\n% " comment) + (string-replace "\n" "\n% " comment) "")))) (defun cal-tex-banner (comment) diff --git a/lisp/calendar/icalendar.el b/lisp/calendar/icalendar.el index d18ec5e798f..cf37331394c 100644 --- a/lisp/calendar/icalendar.el +++ b/lisp/calendar/icalendar.el @@ -998,15 +998,15 @@ TIMESTRING and has the same result as \"9:00\"." (defun icalendar--convert-string-for-export (string) "Escape comma and other critical characters in STRING." - (replace-regexp-in-string "," "\\\\," string)) + (string-replace "," "\\," string)) (defun icalendar--convert-string-for-import (string) "Remove escape chars for comma, semicolon etc. from STRING." - (replace-regexp-in-string - "\\\\n" "\n " (replace-regexp-in-string - "\\\\\"" "\"" (replace-regexp-in-string - "\\\\;" ";" (replace-regexp-in-string - "\\\\," "," string))))) + (string-replace + "\\n" "\n " (string-replace + "\\\"" "\"" (string-replace + "\\;" ";" (string-replace + "\\," "," string))))) ;; ====================================================================== ;; Export -- convert emacs-diary to iCalendar diff --git a/lisp/calendar/iso8601.el b/lisp/calendar/iso8601.el index f22f060e205..1de1796a054 100644 --- a/lisp/calendar/iso8601.el +++ b/lisp/calendar/iso8601.el @@ -57,7 +57,7 @@ (defun iso8601--concat-regexps (regexps) (mapconcat (lambda (regexp) (concat "\\(?:" - (replace-regexp-in-string "(" "(?:" regexp) + (string-replace "(" "(?:" regexp) "\\)")) regexps "\\|")) @@ -92,13 +92,13 @@ "\\(Z\\|\\([+-]\\)\\([0-9][0-9]\\):?\\([0-9][0-9]\\)?\\)") (defconst iso8601--full-time-match - (concat "\\(" (replace-regexp-in-string "(" "(?:" iso8601--time-match) "\\)" + (concat "\\(" (string-replace "(" "(?:" iso8601--time-match) "\\)" "\\(" iso8601--zone-match "\\)?")) (defconst iso8601--combined-match (concat "\\(" iso8601--date-match "\\)" "\\(?:T\\(" - (replace-regexp-in-string "(" "(?:" iso8601--time-match) + (string-replace "(" "(?:" iso8601--time-match) "\\)" "\\(" iso8601--zone-match "\\)?\\)?")) diff --git a/lisp/calendar/time-date.el b/lisp/calendar/time-date.el index 1c169b78fd6..0aa38166bc1 100644 --- a/lisp/calendar/time-date.el +++ b/lisp/calendar/time-date.el @@ -357,7 +357,7 @@ is output until the first non-zero unit is encountered." (format " %s%s" name (if (= num 1) "" "s")))) t t string)))))) - (replace-regexp-in-string "%%" "%" string)) + (string-replace "%%" "%" string)) (defvar seconds-to-string (list (list 1 "ms" 0.001) diff --git a/lisp/calendar/todo-mode.el b/lisp/calendar/todo-mode.el index 680beb85aff..371d10631c5 100644 --- a/lisp/calendar/todo-mode.el +++ b/lisp/calendar/todo-mode.el @@ -4546,7 +4546,7 @@ its priority has changed, and `same' otherwise." (let ((bufname (buffer-name))) (string-match "\"\\([^\"]+\\)\"" bufname) (let* ((filename-str (substring bufname (match-beginning 1) (match-end 1))) - (filename-base (replace-regexp-in-string ", " "-" filename-str)) + (filename-base (string-replace ", " "-" filename-str)) (top-priorities (string-match "top priorities" bufname)) (diary-items (string-match "diary items" bufname)) (regexp-items (string-match "regexp items" bufname))) diff --git a/lisp/cedet/cedet-files.el b/lisp/cedet/cedet-files.el index c9d557f5974..f540fb5540f 100644 --- a/lisp/cedet/cedet-files.el +++ b/lisp/cedet/cedet-files.el @@ -59,7 +59,7 @@ to the file's truename, and dodging platform tricks." ;; doubling `!'s in the original name... (setq file (subst-char-in-string ?/ ?! - (replace-regexp-in-string "!" "!!" file))) + (string-replace "!" "!!" file))) file)) (defun cedet-file-name-to-directory-name (referencefile &optional testmode) @@ -71,7 +71,7 @@ specific conversions during tests." ;; Replace the ! with / (setq file (subst-char-in-string ?! ?/ file)) ;; Occurrences of // meant there was once a single !. - (setq file (replace-regexp-in-string "//" "!" file)) + (setq file (string-replace "//" "!" file)) ;; Handle Windows special cases (when (or (memq system-type '(windows-nt ms-dos)) testmode) diff --git a/lisp/comint.el b/lisp/comint.el index 40f58f2da7b..7af8e8fd2a5 100644 --- a/lisp/comint.el +++ b/lisp/comint.el @@ -2439,7 +2439,7 @@ carriage returns (\\r) in STRING. This function could be in the list `comint-output-filter-functions'." (when (let ((case-fold-search t)) (string-match comint-password-prompt-regexp - (replace-regexp-in-string "\r" "" string))) + (string-replace "\r" "" string))) (let ((comint--prompt-recursion-depth (1+ comint--prompt-recursion-depth))) (if (> comint--prompt-recursion-depth 10) (message "Password prompt recursion too deep") diff --git a/lisp/dired-aux.el b/lisp/dired-aux.el index 060f3a84111..72969dd96e2 100644 --- a/lisp/dired-aux.el +++ b/lisp/dired-aux.el @@ -508,7 +508,7 @@ has no effect on MS-Windows." (default (and (stringp modestr) (string-match "^.\\(...\\)\\(...\\)\\(...\\)$" modestr) - (replace-regexp-in-string + (string-replace "-" "" (format "u=%s,g=%s,o=%s" (match-string 1 modestr) diff --git a/lisp/dired-x.el b/lisp/dired-x.el index a7bfae759ed..a990bd3fec3 100644 --- a/lisp/dired-x.el +++ b/lisp/dired-x.el @@ -1193,7 +1193,7 @@ NOSELECT the files are merely found but not selected." (interactive) (require 'man) (let* ((file (dired-get-filename)) - (manual-program (replace-regexp-in-string "\\*" "%s" + (manual-program (string-replace "*" "%s" (dired-guess-shell-command "Man command: " (list file))))) (Man-getpage-in-background file))) diff --git a/lisp/dired.el b/lisp/dired.el index 28448be06ce..e577df510ad 100644 --- a/lisp/dired.el +++ b/lisp/dired.el @@ -1587,8 +1587,8 @@ see `dired-use-ls-dired' for more details.") ;; because newlines in dirnames are uncommon, and people may ;; have gotten used to seeing unescaped "\" in the headers. ;; Note: adjust dired-build-subdir-alist if you change this. - (setq dir (replace-regexp-in-string "\\\\" "\\\\" dir nil t) - dir (replace-regexp-in-string "\n" "\\n" dir nil t))) + (setq dir (string-replace "\\" "\\\\" dir) + dir (string-replace "\n" "\\n" dir))) ;; If we used --dired and it worked, the lines are already indented. ;; Otherwise, indent them. (unless (save-excursion @@ -3167,15 +3167,15 @@ the quoted forms of those characters. FULL-NAME specifies the actual file name the listing must have, as returned by `dired-get-filename'. LIMIT is the search limit." (let (str) - (setq str (replace-regexp-in-string "\^m" "\\^m" file nil t)) - (setq str (replace-regexp-in-string "\\\\" "\\\\" str nil t)) + (setq str (string-replace "\^m" "\\^m" file)) + (setq str (string-replace "\\" "\\\\" str)) (and (dired-switches-escape-p dired-actual-switches) (string-match-p "[ \t\n]" str) ;; FIXME: to fix this for embedded control characters etc, we ;; should escape everything that `ls -b' does. - (setq str (replace-regexp-in-string " " "\\ " str nil t) - str (replace-regexp-in-string "\t" "\\t" str nil t) - str (replace-regexp-in-string "\n" "\\n" str nil t))) + (setq str (string-replace " " "\\ " str) + str (string-replace "\t" "\\t" str) + str (string-replace "\n" "\\n" str))) (let ((found nil) ;; filenames are preceded by SPC, this makes the search faster ;; (e.g. for the filename "-"). diff --git a/lisp/emacs-lisp/comp.el b/lisp/emacs-lisp/comp.el index a04413b6f00..ed75bf2bfa9 100644 --- a/lisp/emacs-lisp/comp.el +++ b/lisp/emacs-lisp/comp.el @@ -1171,7 +1171,7 @@ clashes." do (aset str j (aref byte 0)) (aset str (1+ j) (aref byte 1)) finally return str)) - (human-readable (replace-regexp-in-string + (human-readable (string-replace "-" "_" orig-name)) (human-readable (replace-regexp-in-string (rx (not (any "0-9a-z_"))) "" human-readable))) diff --git a/lisp/emacs-lisp/re-builder.el b/lisp/emacs-lisp/re-builder.el index 396949d59a2..aec438ed994 100644 --- a/lisp/emacs-lisp/re-builder.el +++ b/lisp/emacs-lisp/re-builder.el @@ -436,7 +436,7 @@ provided in the Commentary section of this library." (let ((re (with-output-to-string (print (reb-target-binding reb-regexp))))) (setq re (substring re 1 (1- (length re)))) - (setq re (replace-regexp-in-string "\n" "\\n" re nil t)) + (setq re (string-replace "\n" "\\n" re)) (kill-new re) (message "Copied regexp `%s' to kill-ring" re))) diff --git a/lisp/erc/erc-dcc.el b/lisp/erc/erc-dcc.el index 219af3741fa..fcdb8df2032 100644 --- a/lisp/erc/erc-dcc.el +++ b/lisp/erc/erc-dcc.el @@ -630,8 +630,8 @@ that subcommand." (define-inline erc-dcc-unquote-filename (filename) (inline-quote - (replace-regexp-in-string "\\\\\\\\" "\\" - (replace-regexp-in-string "\\\\\"" "\"" ,filename t t) t t))) + (string-replace "\\\\" "\\" + (string-replace "\\\"" "\"" ,filename)))) (defun erc-dcc-handle-ctcp-send (proc query nick login host to) "This is called if a CTCP DCC SEND subcommand is sent to the client. diff --git a/lisp/erc/erc.el b/lisp/erc/erc.el index 026c6f84164..c66b03d2e4e 100644 --- a/lisp/erc/erc.el +++ b/lisp/erc/erc.el @@ -3597,7 +3597,7 @@ If S is non-nil, it will be used as the quit reason." If S is non-nil, it will be used as the quit reason." (or s (if (fboundp 'yow) - (replace-regexp-in-string "\n" "" (yow)) + (string-replace "\n" "" (yow)) (erc-quit/part-reason-default)))) (make-obsolete 'erc-quit-reason-zippy "it will be removed." "24.4") @@ -3624,7 +3624,7 @@ If S is non-nil, it will be used as the part reason." If S is non-nil, it will be used as the quit reason." (or s (if (fboundp 'yow) - (replace-regexp-in-string "\n" "" (yow)) + (string-replace "\n" "" (yow)) (erc-quit/part-reason-default)))) (make-obsolete 'erc-part-reason-zippy "it will be removed." "24.4") @@ -6528,7 +6528,7 @@ if `erc-away' is non-nil." (fill-region (point-min) (point-max)) (buffer-string)))) (setq header-line-format - (replace-regexp-in-string + (string-replace "%" "%%" (if face @@ -6804,7 +6804,7 @@ functions." nick user host channel (if (not (string= reason "")) (format ": %s" - (replace-regexp-in-string "%" "%%" reason)) + (string-replace "%" "%%" reason)) ""))))) diff --git a/lisp/files.el b/lisp/files.el index 89ee13eb686..54d0b919e1d 100644 --- a/lisp/files.el +++ b/lisp/files.el @@ -5201,7 +5201,7 @@ The function `find-backup-file-name' also uses this." (expand-file-name (subst-char-in-string ?/ ?! - (replace-regexp-in-string "!" "!!" file)) + (string-replace "!" "!!" file)) backup-directory)) (expand-file-name (file-name-nondirectory file) (file-name-as-directory abs-backup-directory)))))) @@ -6876,7 +6876,7 @@ the resulting file name, and SUFFIX is appended." (file-name-directory result) (subst-char-in-string ?/ ?! - (replace-regexp-in-string + (string-replace "!" "!!" filename)))) (t result)))) (setq result @@ -7989,7 +7989,7 @@ based on existing mode bits, as in \"og+rX-w\"." (default (and (stringp modestr) (string-match "^.\\(...\\)\\(...\\)\\(...\\)$" modestr) - (replace-regexp-in-string + (string-replace "-" "" (format "u=%s,g=%s,o=%s" (match-string 1 modestr) diff --git a/lisp/fringe.el b/lisp/fringe.el index d73aae0459e..82cfacc6b6f 100644 --- a/lisp/fringe.el +++ b/lisp/fringe.el @@ -189,7 +189,7 @@ fringes." :type `(choice ,@ (mapcar (lambda (style) (let ((name - (replace-regexp-in-string "-" " " (car style)))) + (string-replace "-" " " (car style)))) `(const :tag ,(concat (capitalize (substring name 0 1)) (substring name 1)) diff --git a/lisp/gnus/gnus-art.el b/lisp/gnus/gnus-art.el index fb0295d0703..d65e75e44c2 100644 --- a/lisp/gnus/gnus-art.el +++ b/lisp/gnus/gnus-art.el @@ -8288,7 +8288,7 @@ url is put as the `gnus-button-url' overlay property on the button." ")" (gnus-url-unhex-string (match-string 2 url))))) ((string-match "([^)\"]+)[^\"]+" url) (setq url - (replace-regexp-in-string + (string-replace "\"" "" (replace-regexp-in-string "[\n\t ]+" " " url))) (gnus-info-find-node url)) (t (error "Can't parse %s" url)))) diff --git a/lisp/gnus/gnus-group.el b/lisp/gnus/gnus-group.el index 6202567344f..b1134397e55 100644 --- a/lisp/gnus/gnus-group.el +++ b/lisp/gnus/gnus-group.el @@ -2186,7 +2186,7 @@ handle COLLECTION as a list, hash table, or vector." require-match initial-input (or hist 'gnus-group-history) def))) - (replace-regexp-in-string "\n" "" group))) + (string-replace "\n" "" group))) ;;;###autoload (defun gnus-fetch-group (group &optional articles) diff --git a/lisp/gnus/gnus-icalendar.el b/lisp/gnus/gnus-icalendar.el index 1b2743c1484..56f4fdf6d33 100644 --- a/lisp/gnus/gnus-icalendar.el +++ b/lisp/gnus/gnus-icalendar.el @@ -252,10 +252,10 @@ ;; ugly, but cannot get ;;replace-regexp-in-string work with "\\" as ;;REP, plus we should also handle "\\;" - (replace-regexp-in-string - "\\\\," "," - (replace-regexp-in-string - "\\\\n" "\n" (substring-no-properties value)))))) + (string-replace + "\\," "," + (string-replace + "\\n" "\n" (substring-no-properties value)))))) (accumulate-args (mapping) (cl-destructuring-bind (slot . ical-property) mapping diff --git a/lisp/gnus/gnus-mlspl.el b/lisp/gnus/gnus-mlspl.el index d42f0971259..664027f0164 100644 --- a/lisp/gnus/gnus-mlspl.el +++ b/lisp/gnus/gnus-mlspl.el @@ -209,7 +209,7 @@ Calling (gnus-group-split-fancy nil nil \"mail.others\") returns: "\\)")) ;; Now create the new SPLIT (let ((split-regexp-with-list-ids - (replace-regexp-in-string "@" "[@.]" split-regexp t t)) + (string-replace "@" "[@.]" split-regexp)) (exclude ;; Generate RESTRICTs for SPLIT-EXCLUDEs. (if (listp split-exclude) diff --git a/lisp/gnus/gnus-search.el b/lisp/gnus/gnus-search.el index 8182630dfed..59b8efaa3ac 100644 --- a/lisp/gnus/gnus-search.el +++ b/lisp/gnus/gnus-search.el @@ -572,7 +572,7 @@ nil. If VALUE is a relative time, interpret it as relative to REL-DATE, or (current-time) if REL-DATE is nil." ;; Time parsing doesn't seem to work with slashes. - (let ((value (replace-regexp-in-string "/" "-" value)) + (let ((value (string-replace "/" "-" value)) (now (append '(0 0 0) (seq-subseq (decode-time (or rel-date (current-time))) @@ -1669,7 +1669,7 @@ cross our fingers for the rest of it." Mairix negation requires a \"~\" preceding string search terms, and \"-\" before marks." (let ((next (gnus-search-transform-expression engine (cadr expr)))) - (replace-regexp-in-string + (string-replace ":" (if (eql (caadr expr) 'mark) ":-" @@ -1863,9 +1863,9 @@ Assume \"size\" key is equal to \"larger\"." group (if (file-directory-p (setq group - (replace-regexp-in-string - "\\." "/" - group nil t))) + (string-replace + "." "/" + group))) group)))))) (unless group (signal 'gnus-search-config-error diff --git a/lisp/gnus/gnus-start.el b/lisp/gnus/gnus-start.el index 44e97d54846..02bbe19e7fe 100644 --- a/lisp/gnus/gnus-start.el +++ b/lisp/gnus/gnus-start.el @@ -854,7 +854,7 @@ If REGEXP is given, lines that match it will be deleted." (goto-char (point-max)) ;; Make sure that each dribble entry is a single line, so that ;; the "remove" code above works. - (insert (replace-regexp-in-string "\n" "\\\\n" string) "\n") + (insert (string-replace "\n" "\\n" string) "\n") (bury-buffer gnus-dribble-buffer) (with-current-buffer gnus-group-buffer (gnus-group-set-mode-line))))) diff --git a/lisp/gnus/gnus-sum.el b/lisp/gnus/gnus-sum.el index 4bdc2023eb4..dc004927b67 100644 --- a/lisp/gnus/gnus-sum.el +++ b/lisp/gnus/gnus-sum.el @@ -9191,7 +9191,7 @@ specified by the `gnus-refer-thread-limit' variable." (interactive "sMessage-ID: " gnus-summary-mode) (when (and (stringp message-id) (not (zerop (length message-id)))) - (setq message-id (replace-regexp-in-string " " "" message-id)) + (setq message-id (string-replace " " "" message-id)) ;; Construct the correct Message-ID if necessary. ;; Suggested by tale@pawl.rpi.edu. (unless (string-match "^<" message-id) diff --git a/lisp/gnus/gnus-util.el b/lisp/gnus/gnus-util.el index be0284515dc..7a5e00c5ec9 100644 --- a/lisp/gnus/gnus-util.el +++ b/lisp/gnus/gnus-util.el @@ -408,7 +408,7 @@ Cache the result as a text property stored in DATE." (defun gnus-mode-string-quote (string) "Quote all \"%\"'s in STRING." - (replace-regexp-in-string "%" "%%" string)) + (string-replace "%" "%%" string)) (defsubst gnus-make-hashtable (&optional size) "Make a hash table of SIZE, testing on `equal'." diff --git a/lisp/gnus/message.el b/lisp/gnus/message.el index bcbf7476715..a3ffaec3ff3 100644 --- a/lisp/gnus/message.el +++ b/lisp/gnus/message.el @@ -8599,7 +8599,7 @@ From headers in the original article." (let ((value (message-field-value header))) (dolist (string (mail-header-parse-addresses value 'raw)) (setq string - (replace-regexp-in-string + (string-replace "\n" "" (replace-regexp-in-string "^ +\\| +$" "" string))) (ecomplete-add-item 'mail (car (mail-header-parse-address string)) @@ -8889,7 +8889,7 @@ used to take the screenshot." (defun message-parse-mailto-url (url) "Parse a mailto: url." - (setq url (replace-regexp-in-string "\n" " " url)) + (setq url (string-replace "\n" " " url)) (when (string-match "mailto:/*\\(.*\\)" url) (setq url (substring url (match-beginning 1) nil))) (setq url (if (string-match "^\\?" url) @@ -8931,9 +8931,9 @@ will then start up Emacs ready to compose mail. For emacsclient use (dolist (arg args) (unless (equal (car arg) "body") (message-position-on-field (capitalize (car arg))) - (insert (replace-regexp-in-string + (insert (string-replace "\r\n" "\n" - (mapconcat #'identity (reverse (cdr arg)) ", ") nil t)))) + (mapconcat #'identity (reverse (cdr arg)) ", "))))) (when (assoc "body" args) (message-goto-body) (dolist (body (cdr (assoc "body" args))) diff --git a/lisp/gnus/mml-sec.el b/lisp/gnus/mml-sec.el index 15157e6fbc8..b49793509fc 100644 --- a/lisp/gnus/mml-sec.el +++ b/lisp/gnus/mml-sec.el @@ -1022,7 +1022,7 @@ Returns non-nil if the user has chosen to use SENDER." (if (eq 'OpenPGP protocol) (epg-sign-string context (buffer-string) mode) (epg-sign-string context - (replace-regexp-in-string + (string-replace "\n" "\r\n" (buffer-string)) t)) mml-secure-secret-key-id-list nil) diff --git a/lisp/gnus/mml-smime.el b/lisp/gnus/mml-smime.el index 5c133e680af..959de0902e2 100644 --- a/lisp/gnus/mml-smime.el +++ b/lisp/gnus/mml-smime.el @@ -404,7 +404,7 @@ Content-Disposition: attachment; filename=smime.p7m nil t))))) (mm-sec-error 'gnus-info "Corrupted") (throw 'error handle)) - (setq part (replace-regexp-in-string "\n" "\r\n" part) + (setq part (string-replace "\n" "\r\n" part) context (epg-make-context 'CMS)) (condition-case error ;; (setq plain diff --git a/lisp/gnus/mml2015.el b/lisp/gnus/mml2015.el index 1af7d10d055..8c40fc79f00 100644 --- a/lisp/gnus/mml2015.el +++ b/lisp/gnus/mml2015.el @@ -863,7 +863,7 @@ If set, it overrides the setting of `mml2015-sign-with-sender'." nil t)))) (mm-sec-error 'gnus-info "Corrupted") (throw 'error handle)) - (setq part (replace-regexp-in-string "\n" "\r\n" part) + (setq part (string-replace "\n" "\r\n" part) signature (mm-get-part signature) context (epg-make-context)) (condition-case error diff --git a/lisp/gnus/nnmaildir.el b/lisp/gnus/nnmaildir.el index 4867455393a..372df64e2e5 100644 --- a/lisp/gnus/nnmaildir.el +++ b/lisp/gnus/nnmaildir.el @@ -637,13 +637,11 @@ This variable is set by `nnmaildir-request-article'.") (funcall func (cdr entry))))))) (defun nnmaildir--system-name () - (replace-regexp-in-string + (string-replace ":" "\\072" - (replace-regexp-in-string + (string-replace "/" "\\057" - (replace-regexp-in-string "\\\\" "\\134" (system-name) nil 'literal) - nil 'literal) - nil 'literal)) + (string-replace "\\" "\\134" (system-name))))) (defun nnmaildir-request-type (_group &optional _article) 'mail) @@ -937,9 +935,9 @@ This variable is set by `nnmaildir-request-article'.") (setq pgname (nnmaildir--pgname nnmaildir--cur-server gname) ro (nnmaildir--param pgname 'read-only)) - (insert (replace-regexp-in-string + (insert (string-replace " " "\\ " - (nnmaildir--grp-name group) nil t) + (nnmaildir--grp-name group)) " ") (princ (nnmaildir--group-maxnum nnmaildir--cur-server group) nntp-server-buffer) @@ -968,7 +966,7 @@ This variable is set by `nnmaildir-request-article'.") (princ (nnmaildir--group-maxnum nnmaildir--cur-server group) nntp-server-buffer) (insert " " - (replace-regexp-in-string " " "\\ " gname nil t) + (string-replace " " "\\ " gname) "\n"))))) 'group) @@ -1098,7 +1096,7 @@ This variable is set by `nnmaildir-request-article'.") (insert " ") (princ (nnmaildir--group-maxnum nnmaildir--cur-server group) nntp-server-buffer) - (insert " " (replace-regexp-in-string " " "\\ " gname nil t) "\n") + (insert " " (string-replace " " "\\ " gname) "\n") t)))) (defun nnmaildir-request-create-group (gname &optional server _args) @@ -1262,7 +1260,7 @@ This variable is set by `nnmaildir-request-article'.") (insert "\t" (nnmaildir--nov-get-beg nov) "\t" (nnmaildir--art-msgid article) "\t" (nnmaildir--nov-get-mid nov) "\tXref: nnmaildir " - (replace-regexp-in-string " " "\\ " gname nil t) ":") + (string-replace " " "\\ " gname) ":") (princ num nntp-server-buffer) (insert "\t" (nnmaildir--nov-get-end nov) "\n")))) (catch 'return diff --git a/lisp/gnus/nnrss.el b/lisp/gnus/nnrss.el index a40fa88631f..8cd8cbe84f1 100644 --- a/lisp/gnus/nnrss.el +++ b/lisp/gnus/nnrss.el @@ -785,7 +785,7 @@ It is useful when `(setq nnrss-use-local t)'." (nnrss-node-just-text node) node)) (cleaned-text (if text - (replace-regexp-in-string + (string-replace "\r\n" "\n" (replace-regexp-in-string "^[\000-\037\177]+\\|^ +\\| +$" "" diff --git a/lisp/gnus/spam-report.el b/lisp/gnus/spam-report.el index a4234f84001..5fa280ea058 100644 --- a/lisp/gnus/spam-report.el +++ b/lisp/gnus/spam-report.el @@ -159,7 +159,7 @@ submitted at once. Internal variable.") rpt-host (concat "/" - (replace-regexp-in-string + (string-replace "/" ":" (replace-regexp-in-string "^.*article.gmane.org/" "" @@ -224,7 +224,7 @@ the function specified by `spam-report-url-ping-function'." (defcustom spam-report-user-mail-address (and (stringp user-mail-address) - (replace-regexp-in-string "@" "" user-mail-address)) + (string-replace "@" "" user-mail-address)) "Mail address of this user used for spam reports to Gmane. This is initialized based on `user-mail-address'." :type '(choice string diff --git a/lisp/ibuffer.el b/lisp/ibuffer.el index 9088f31053b..6c0180590b9 100644 --- a/lisp/ibuffer.el +++ b/lisp/ibuffer.el @@ -1719,7 +1719,7 @@ If point is on a group name, this function operates on that group." (ibuffer-buffer-name-face buffer mark)))) (if (not (seq-position string ?\n)) string - (replace-regexp-in-string + (string-replace "\n" (propertize "^J" 'font-lock-face 'escape-glyph) string)))) (define-ibuffer-column size diff --git a/lisp/image-dired.el b/lisp/image-dired.el index 2509ecf8f82..74985b9e56d 100644 --- a/lisp/image-dired.el +++ b/lisp/image-dired.el @@ -704,7 +704,7 @@ Increase at own risk.") (thumb (cdr (assq ?t spec)))) (rename-file nq8 thumb t))) (message "command %S %s" (process-command process) - (replace-regexp-in-string "\n" "" status))))) + (string-replace "\n" "" status))))) process)) (defun image-dired-pngcrush-thumb (spec) @@ -726,7 +726,7 @@ Increase at own risk.") (unless (and (eq (process-status process) 'exit) (zerop (process-exit-status process))) (message "command %S %s" (process-command process) - (replace-regexp-in-string "\n" "" status))) + (string-replace "\n" "" status))) (when (memq (process-status process) '(exit signal)) (let ((temp (cdr (assq ?q spec)))) (delete-file temp))))) @@ -744,7 +744,7 @@ Increase at own risk.") (unless (and (eq (process-status process) 'exit) (zerop (process-exit-status process))) (message "command %S %s" (process-command process) - (replace-regexp-in-string "\n" "" status))))) + (string-replace "\n" "" status))))) process)) (defun image-dired-create-thumb-1 (original-file thumbnail-file) @@ -794,7 +794,7 @@ Increase at own risk.") (zerop (process-exit-status process)))) (message "Thumb could not be created for %s: %s" (abbreviate-file-name original-file) - (replace-regexp-in-string "\n" "" status)) + (string-replace "\n" "" status)) (set-file-modes thumbnail-file #o600) (clear-image-cache thumbnail-file) ;; PNG thumbnail has been created since we are diff --git a/lisp/info.el b/lisp/info.el index b65728ba41b..1c477a7082f 100644 --- a/lisp/info.el +++ b/lisp/info.el @@ -1732,14 +1732,14 @@ escaped (\\\",\\\\)." (concat " (" (if (stringp Info-current-file) - (replace-regexp-in-string + (string-replace "%" "%%" (file-name-sans-extension (file-name-nondirectory Info-current-file))) (format "*%S*" Info-current-file)) ") " (if Info-current-node - (propertize (replace-regexp-in-string + (propertize (string-replace "%" "%%" Info-current-node) 'face 'mode-line-buffer-id 'help-echo diff --git a/lisp/international/mule-cmds.el b/lisp/international/mule-cmds.el index 55accf5beee..71e2653ffe9 100644 --- a/lisp/international/mule-cmds.el +++ b/lisp/international/mule-cmds.el @@ -2166,7 +2166,7 @@ See `set-language-info-alist' for use in programs." (let ((str (eval (get-language-info language-name 'sample-text)))) (if (stringp str) (insert "Sample text:\n " - (replace-regexp-in-string "\n" "\n " str) + (string-replace "\n" "\n " str) "\n\n"))) (error nil)) (let ((input-method (get-language-info language-name 'input-method)) diff --git a/lisp/mail/rfc2231.el b/lisp/mail/rfc2231.el index 6fb4502b23b..db34fd2cb9e 100644 --- a/lisp/mail/rfc2231.el +++ b/lisp/mail/rfc2231.el @@ -63,7 +63,7 @@ must never cause a Lisp error." (let (mod) (when (and (string-match "\\\\\"" string) (not (string-match "\\`\"\\|[^\\]\"" string))) - (setq string (replace-regexp-in-string "\\\\\"" "\"" string) + (setq string (string-replace "\\\"" "\"" string) mod t)) (when (and (string-match "\\\\(" string) (string-match "\\\\)" string) diff --git a/lisp/mail/rfc2368.el b/lisp/mail/rfc2368.el index 553f3cc3a54..b96f15d3e68 100644 --- a/lisp/mail/rfc2368.el +++ b/lisp/mail/rfc2368.el @@ -91,7 +91,7 @@ Note: make sure MAILTO-URL has been \"unhtmlized\" (e.g., & -> &), before calling this function." (let ((case-fold-search t) prequery query headers-alist) - (setq mailto-url (replace-regexp-in-string "\n" " " mailto-url)) + (setq mailto-url (string-replace "\n" " " mailto-url)) (if (string-match rfc2368-mailto-regexp mailto-url) (progn (setq prequery diff --git a/lisp/mail/rmail.el b/lisp/mail/rmail.el index e479a8e9b4a..8a38337773e 100644 --- a/lisp/mail/rmail.el +++ b/lisp/mail/rmail.el @@ -1960,7 +1960,7 @@ Value is the size of the newly read mail after conversion." (file-name-nondirectory (if (memq system-type '(windows-nt cygwin ms-dos)) ;; cannot have colons in file name - (replace-regexp-in-string ":" "-" file) + (string-replace ":" "-" file) file))) ;; Use the directory of this rmail file ;; because it's a nuisance to use the homedir @@ -3374,7 +3374,7 @@ The idea is to match it against simplified subjects of other messages." ;; Hide commas so it will work ok if parsed as a comma-separated list ;; of regexps. (setq subject - (replace-regexp-in-string "," "\054" subject t t)) + (string-replace "," "\054" subject)) (concat "\\`" subject "\\'"))) (defun rmail-next-same-subject (n) diff --git a/lisp/mail/rmailout.el b/lisp/mail/rmailout.el index eb8590f1f73..4c23686909c 100644 --- a/lisp/mail/rmailout.el +++ b/lisp/mail/rmailout.el @@ -678,9 +678,9 @@ than appending to it. Deletes the message after writing if (or (mail-fetch-field "Subject") rmail-default-body-file))) (setq default-file - (replace-regexp-in-string ":" "-" default-file)) + (string-replace ":" "-" default-file)) (setq default-file - (replace-regexp-in-string " " "-" default-file)) + (string-replace " " "-" default-file)) (list (setq rmail-default-body-file (read-file-name "Output message body to file: " diff --git a/lisp/mail/undigest.el b/lisp/mail/undigest.el index bf57ed6fa6f..0760a477296 100644 --- a/lisp/mail/undigest.el +++ b/lisp/mail/undigest.el @@ -125,7 +125,7 @@ See rmail-digest-methods." ;; Undo masking of separators inside digestified messages (goto-char (point-min)) (while (search-forward - (replace-regexp-in-string "\n-" "\n " separator) nil t) + (string-replace "\n-" "\n " separator) nil t) (replace-match separator)) ;; Return the list of marker pairs (nreverse result)))))) diff --git a/lisp/man.el b/lisp/man.el index 9b941a2b3d2..54b6ffe9836 100644 --- a/lisp/man.el +++ b/lisp/man.el @@ -802,7 +802,7 @@ POS defaults to `point'." ;; added by troff, and remove it. (or (not (eq (string-to-char (substring 1st-part -1)) ?-)) (string-match-p "-" (substring 1st-part 0 -1)) - (setq word (replace-regexp-in-string "-" "" word)))) + (setq word (string-replace "-" "" word)))) ;; Make sure the section number gets included by the code below. (goto-char (match-end 1))) (when (string-match "[-._‐]+$" word) diff --git a/lisp/mouse.el b/lisp/mouse.el index 89e5d7c48a3..cf7c17be28f 100644 --- a/lisp/mouse.el +++ b/lisp/mouse.el @@ -180,7 +180,7 @@ items `Turn Off' and `Help'." `(keymap ,(format "%s - %s" indicator (capitalize - (replace-regexp-in-string + (string-replace "-" " " (format "%S" minor-mode)))) (turn-off menu-item "Turn off minor mode" ,mm-fun) (help menu-item "Help for minor mode" diff --git a/lisp/mpc.el b/lisp/mpc.el index ab572aa539a..e04ffa49747 100644 --- a/lisp/mpc.el +++ b/lisp/mpc.el @@ -214,8 +214,8 @@ defaults to 6600 and HOST defaults to localhost." (with-current-buffer "*MPC-debug*" (goto-char (point-max)) (insert-before-markers ;So it scrolls. - (replace-regexp-in-string "\n" "\n " - (apply #'format-message format args)) + (string-replace "\n" "\n " + (apply #'format-message format args)) "\n")))) (defun mpc--proc-filter (proc string) diff --git a/lisp/net/browse-url.el b/lisp/net/browse-url.el index 6d64100be17..f739cd72cc3 100644 --- a/lisp/net/browse-url.el +++ b/lisp/net/browse-url.el @@ -1644,7 +1644,7 @@ used instead of `browse-url-new-window-flag'." (insert "\n")) (goto-char (prog1 (point) - (insert (replace-regexp-in-string "\r\n" "\n" body)) + (insert (string-replace "\r\n" "\n" body)) (unless (bolp) (insert "\n")))))))) diff --git a/lisp/net/eww.el b/lisp/net/eww.el index eec3ec7ba8b..2a81d2e0c8c 100644 --- a/lisp/net/eww.el +++ b/lisp/net/eww.el @@ -779,7 +779,7 @@ Currently this means either text/html or application/xhtml+xml." (propertize "...: " 'face 'variable-pitch)))) (propertize "..." 'face 'variable-pitch))))))) - (replace-regexp-in-string + (string-replace "%" "%%" (format-spec eww-header-line-format diff --git a/lisp/net/newst-backend.el b/lisp/net/newst-backend.el index e623dab26df..dc541943587 100644 --- a/lisp/net/newst-backend.el +++ b/lisp/net/newst-backend.el @@ -610,7 +610,7 @@ This does NOT start the retrieval timers." (interactive) (let ((filename (read-string "Filename: " (concat feed ":_" - (replace-regexp-in-string + (string-replace " " "_" (newsticker--title item)) ".html")))) (with-temp-buffer diff --git a/lisp/net/rcirc.el b/lisp/net/rcirc.el index f11f36e8096..e7aec505b0b 100644 --- a/lisp/net/rcirc.el +++ b/lisp/net/rcirc.el @@ -800,7 +800,7 @@ When 0, do not auto-reconnect." (defun rcirc-sentinel (process sentinel) "Called when PROCESS receives SENTINEL." - (let ((sentinel (replace-regexp-in-string "\n" "" sentinel))) + (let ((sentinel (string-replace "\n" "" sentinel))) (rcirc-debug process (format "SENTINEL: %S %S\n" process sentinel)) (with-rcirc-process-buffer process (dolist (buffer (cons nil (mapcar 'cdr rcirc-buffer-alist))) diff --git a/lisp/net/soap-client.el b/lisp/net/soap-client.el index 821ef4af8e0..f5480afb698 100644 --- a/lisp/net/soap-client.el +++ b/lisp/net/soap-client.el @@ -659,7 +659,7 @@ representing leap seconds." (if second (if second-fraction (let* ((second-fraction-significand - (replace-regexp-in-string "\\." "" second-fraction)) + (string-replace "." "" second-fraction)) (hertz (expt 10 (length second-fraction-significand))) (ticks (+ (* hertz (string-to-number second)) diff --git a/lisp/nxml/rng-cmpct.el b/lisp/nxml/rng-cmpct.el index 1314ade9e31..d820d1b99b5 100644 --- a/lisp/nxml/rng-cmpct.el +++ b/lisp/nxml/rng-cmpct.el @@ -100,7 +100,7 @@ Return a pattern." "Regular expression to match a single-quoted literal.") (defconst rng-c-literal-2-re - (replace-regexp-in-string "'" "\"" rng-c-literal-1-re) + (string-replace "'" "\"" rng-c-literal-1-re) "Regular expression to match a double-quoted literal.") (defconst rng-c-ncname-re "\\w+") diff --git a/lisp/nxml/xmltok.el b/lisp/nxml/xmltok.el index 9824eebbd8b..38bc2e141e6 100644 --- a/lisp/nxml/xmltok.el +++ b/lisp/nxml/xmltok.el @@ -479,7 +479,7 @@ and VALUE-END, otherwise a STRING giving the value." "[^<'&\r\n\t]*" (xmltok-g complex1 "[&\r\n\t][^<']*") opt "'")) - (lit2 (cons (replace-regexp-in-string "'" "\"" (car lit1)) + (lit2 (cons (string-replace "'" "\"" (car lit1)) '(complex2))) (literal (xmltok-g literal lit1 or lit2)) (name (xmltok+ open (xmltok-g xmlns "xmlns") or ncname close diff --git a/lisp/obsolete/nnir.el b/lisp/obsolete/nnir.el index 40a8ec57b98..caeca988810 100644 --- a/lisp/obsolete/nnir.el +++ b/lisp/obsolete/nnir.el @@ -920,10 +920,10 @@ Tested with swish-e-2.0.1 on Windows NT 4.0." ;; eliminate all ".", "/", "\" from beginning. Always matches. (string-match "^[./\\]*\\(.*\\)$" dirnam) ;; "/" -> "." - (setq group (replace-regexp-in-string + (setq group (string-replace "/" "." (match-string 1 dirnam))) ;; Windows "\\" -> "." - (setq group (replace-regexp-in-string "\\\\" "." group)) + (setq group (string-replace "\\" "." group)) (push (vector (gnus-group-full-name group server) (string-to-number artno) @@ -996,7 +996,7 @@ Tested with swish-e-2.0.1 on Windows NT 4.0." (when (string-match prefix dirnam) (setq dirnam (replace-match "" t t dirnam))) (push (vector (gnus-group-full-name - (replace-regexp-in-string "/" "." dirnam) server) + (string-replace "/" "." dirnam) server) (string-to-number artno) (string-to-number score)) artlist)) @@ -1205,9 +1205,9 @@ construct path: search terms (see the variable group (if (file-directory-p (setq group - (replace-regexp-in-string - "\\." "/" - group nil t))) + (string-replace + "." "/" + group))) group)))))) (unless group (error "Cannot locate directory for group")) diff --git a/lisp/play/dunnet.el b/lisp/play/dunnet.el index c3be029a658..3bb8bf0c82b 100644 --- a/lisp/play/dunnet.el +++ b/lisp/play/dunnet.el @@ -2373,7 +2373,7 @@ Also prints current score to let user know he has scored." (dun-mprincl "Incorrect."))) (let (varname epoint afterq i value) - (setq varname (replace-regexp-in-string " " "" (substring line 0 esign))) + (setq varname (string-replace " " "" (substring line 0 esign))) (if (or (= (length varname) 0) (< (- (length line) esign) 2)) (progn diff --git a/lisp/play/handwrite.el b/lisp/play/handwrite.el index cc058230751..2aec408e11b 100644 --- a/lisp/play/handwrite.el +++ b/lisp/play/handwrite.el @@ -200,7 +200,7 @@ Variables: `handwrite-linespace' (default 12) (concat "\\\\" (cdr trans)) line))) (switch-to-buffer ps-buf-name) - (insert (replace-regexp-in-string "\n" "" line)) + (insert (string-replace "\n" "" line)) (message "write write write...") (setq ps-ypos (+ ps-ypos handwrite-linespace)) (end-of-line) diff --git a/lisp/proced.el b/lisp/proced.el index d1a243df8e0..2fafdcc58e5 100644 --- a/lisp/proced.el +++ b/lisp/proced.el @@ -1389,7 +1389,7 @@ The return string is always 6 characters wide." (defun proced-format-args (args) "Format attribute ARGS. Replace newline characters by \"^J\" (two characters)." - (replace-regexp-in-string "\n" "^J" args)) + (string-replace "\n" "^J" args)) (defun proced-format (process-alist format) "Display PROCESS-ALIST using FORMAT." diff --git a/lisp/profiler.el b/lisp/profiler.el index 8145e51d75d..4c427692cb8 100644 --- a/lisp/profiler.el +++ b/lisp/profiler.el @@ -499,7 +499,7 @@ RET: expand or collapse")) (defun profiler-report-header-line-format (fmt &rest args) (let* ((header (apply #'profiler-format fmt args)) - (escaped (replace-regexp-in-string "%" "%%" header))) + (escaped (string-replace "%" "%%" header))) (concat (propertize " " 'display '(space :align-to 0) diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el index b9c8305bed0..97596d0d278 100644 --- a/lisp/progmodes/gdb-mi.el +++ b/lisp/progmodes/gdb-mi.el @@ -1963,7 +1963,7 @@ commands to be prefixed by \"-interpreter-exec console\".") The string is enclosed in double quotes. All embedded quotes, newlines, and backslashes are preceded with a backslash." (setq string (replace-regexp-in-string "\\([\"\\]\\)" "\\\\\\&" string)) - (setq string (replace-regexp-in-string "\n" "\\n" string t t)) + (setq string (string-replace "\n" "\\n" string)) (concat "\"" string "\"")) (defun gdb-input (command handler-function &optional trigger-name) diff --git a/lisp/progmodes/make-mode.el b/lisp/progmodes/make-mode.el index 4d277755aeb..df17b87c013 100644 --- a/lisp/progmodes/make-mode.el +++ b/lisp/progmodes/make-mode.el @@ -257,7 +257,7 @@ not be enclosed in { } or ( )." "Regex used to highlight makepp rule action lines in font lock mode.") (defconst makefile-bsdmake-rule-action-regex - (replace-regexp-in-string "-@" "-+@" makefile-rule-action-regex) + (string-replace "-@" "-+@" makefile-rule-action-regex) "Regex used to highlight BSD rule action lines in font lock mode.") ;; Note that the first and second subexpression is used by font lock. Note @@ -358,11 +358,10 @@ not be enclosed in { } or ( )." ,@(if keywords ;; Fontify conditionals and includes. `((,(concat "^\\(?: [ \t]*\\)?" - (replace-regexp-in-string + (string-replace " " "[ \t]+" (if (eq (car keywords) t) - (replace-regexp-in-string "-" "[_-]" - (regexp-opt (cdr keywords) t)) + (string-replace "-" "[_-]" (regexp-opt (cdr keywords) t)) (regexp-opt keywords t))) "\\>[ \t]*\\([^: \t\n#]*\\)") (1 font-lock-keyword-face) (2 font-lock-variable-name-face)))) diff --git a/lisp/progmodes/prolog.el b/lisp/progmodes/prolog.el index 0b520e39074..2e23c2e2cab 100644 --- a/lisp/progmodes/prolog.el +++ b/lisp/progmodes/prolog.el @@ -2277,7 +2277,7 @@ between them)." ;(goto-char beg) (if (search-forward-regexp "^[ \t]*\\(%+\\|\\*+\\|/\\*+\\)[ \t]*" end t) - (replace-regexp-in-string "/" " " (buffer-substring beg (point))) + (string-replace "/" " " (buffer-substring beg (point))) (beginning-of-line) (when (search-forward-regexp "^[ \t]+" end t) (buffer-substring beg (point))))))))) diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el index 01fb044161b..74b48ca4bde 100644 --- a/lisp/progmodes/ruby-mode.el +++ b/lisp/progmodes/ruby-mode.el @@ -1788,8 +1788,8 @@ If the result is do-end block, it will always be multiline." (buffer-substring-no-properties (1+ min) (1- max)))) (setq content (if (equal string-quote "'") - (replace-regexp-in-string "\\\\\"" "\"" (replace-regexp-in-string "\\(\\`\\|[^\\]\\)'" "\\1\\\\'" content)) - (replace-regexp-in-string "\\\\'" "'" (replace-regexp-in-string "\\(\\`\\|[^\\]\\)\"" "\\1\\\\\"" content)))) + (string-replace "\\\"" "\"" (replace-regexp-in-string "\\(\\`\\|[^\\]\\)'" "\\1\\\\'" content)) + (string-replace "\\'" "'" (replace-regexp-in-string "\\(\\`\\|[^\\]\\)\"" "\\1\\\\\"" content)))) (let ((orig-point (point))) (delete-region min max) (insert diff --git a/lisp/progmodes/sql.el b/lisp/progmodes/sql.el index f144549cf6d..b9012166a52 100644 --- a/lisp/progmodes/sql.el +++ b/lisp/progmodes/sql.el @@ -3843,7 +3843,7 @@ to avoid deleting non-prompt output." (defun sql-remove-tabs-filter (str) "Replace tab characters with spaces." - (replace-regexp-in-string "\t" " " str nil t)) + (string-replace "\t" " " str)) (defun sql-toggle-pop-to-buffer-after-send-region (&optional value) "Toggle `sql-pop-to-buffer-after-send-region'. @@ -3864,7 +3864,7 @@ If given the optional parameter VALUE, sets "If non-nil, display messages related to the use of redirection.") (defun sql-str-literal (s) - (concat "'" (replace-regexp-in-string "[']" "''" s) "'")) + (concat "'" (string-replace "[']" "''" s) "'")) (defun sql-redirect (sqlbuf command &optional outbuf save-prior) "Execute the SQL command and send output to OUTBUF. diff --git a/lisp/progmodes/which-func.el b/lisp/progmodes/which-func.el index 02a8d72758c..eb170baa5d8 100644 --- a/lisp/progmodes/which-func.el +++ b/lisp/progmodes/which-func.el @@ -175,7 +175,7 @@ and you want to simplify them for the mode line (defvar which-func-table (make-hash-table :test 'eq :weakness 'key)) (defconst which-func-current - '(:eval (replace-regexp-in-string + '(:eval (string-replace "%" "%%" (or (gethash (selected-window) which-func-table) which-func-unknown)))) diff --git a/lisp/replace.el b/lisp/replace.el index ee46286a75f..c67877efd5d 100644 --- a/lisp/replace.el +++ b/lisp/replace.el @@ -213,7 +213,7 @@ wants to replace FROM with TO." (when query-replace-from-to-separator ;; Check if the first non-whitespace char is displayable (if (char-displayable-p - (string-to-char (replace-regexp-in-string + (string-to-char (string-replace " " "" query-replace-from-to-separator))) query-replace-from-to-separator " -> "))) @@ -2101,7 +2101,7 @@ See also `multi-occur'." ;; Add non-numeric prefix to all non-first lines ;; of multi-line matches. (concat - (replace-regexp-in-string + (string-replace "\n" (if prefix-face (propertize @@ -2506,12 +2506,10 @@ a string, it is first passed through `prin1-to-string' with the `noescape' argument set. `match-data' is preserved across the call." - (save-match-data - (replace-regexp-in-string "\\\\" "\\\\" - (if (stringp replacement) - replacement - (prin1-to-string replacement t)) - t t))) + (string-replace "\\" "\\\\" + (if (stringp replacement) + replacement + (prin1-to-string replacement t)))) (defun replace-loop-through-replacements (data count) ;; DATA is a vector containing the following values: diff --git a/lisp/select.el b/lisp/select.el index eaa74cebd80..15e171c13f9 100644 --- a/lisp/select.el +++ b/lisp/select.el @@ -496,7 +496,7 @@ two markers or an overlay. Otherwise, it is nil." (error "Unknown selection type: %S" type))))) ;; Most programs are unable to handle NUL bytes in strings. - (setq str (replace-regexp-in-string "\0" "\\0" str t t)) + (setq str (string-replace "\0" "\\0" str)) (setq next-selection-coding-system nil) (cons type str)))) diff --git a/lisp/ses.el b/lisp/ses.el index ca515f829dc..81c27144a54 100644 --- a/lisp/ses.el +++ b/lisp/ses.el @@ -3357,7 +3357,7 @@ is non-nil. Newlines and tabs in the export text are escaped." (push "'" result) (setq item (cadr item))) (setq item (ses-prin1 item)) - (setq item (replace-regexp-in-string "\t" "\\\\t" item)) + (setq item (string-replace "\t" "\\t" item)) (push item result) (cond ((< col maxcol) diff --git a/lisp/subr.el b/lisp/subr.el index b8286600664..87298b5cfde 100644 --- a/lisp/subr.el +++ b/lisp/subr.el @@ -3681,7 +3681,7 @@ See Info node `(elisp)Security Considerations'." "''" ;; Quote everything except POSIX filename characters. ;; This should be safe enough even for really weird shells. - (replace-regexp-in-string + (string-replace "\n" "'\n'" (replace-regexp-in-string "[^-0-9a-zA-Z_./\n]" "\\\\\\&" argument)))) )) diff --git a/lisp/term/pc-win.el b/lisp/term/pc-win.el index 8cff2ceaeec..9e7b360b9c6 100644 --- a/lisp/term/pc-win.el +++ b/lisp/term/pc-win.el @@ -290,7 +290,7 @@ This is used by `msdos-show-help'.") (not cursor-in-echo-area)) ;Don't overwrite a prompt. (cond ((stringp help) - (setq help (replace-regexp-in-string "\n" ", " help)) + (setq help (string-replace "\n" ", " help)) (unless (or msdos-previous-message (string-equal help (current-message)) (and (stringp msdos-last-help-message) diff --git a/lisp/term/w32-win.el b/lisp/term/w32-win.el index 6b849164aec..80afcb36040 100644 --- a/lisp/term/w32-win.el +++ b/lisp/term/w32-win.el @@ -410,7 +410,7 @@ See the documentation of `create-fontset-from-fontset-spec' for the format.") ;;; Fix interface to (X-specific) mouse.el (defun w32--set-selection (type value) (if (eq type 'CLIPBOARD) - (w32-set-clipboard-data (replace-regexp-in-string "\0" "\\0" value t t)) + (w32-set-clipboard-data (string-replace "\0" "\\0" value)) (put 'x-selections (or type 'PRIMARY) value))) (defun w32--get-selection (&optional type data-type) diff --git a/lisp/term/xterm.el b/lisp/term/xterm.el index 8bcae37afe4..868b33ea9c5 100644 --- a/lisp/term/xterm.el +++ b/lisp/term/xterm.el @@ -1015,10 +1015,9 @@ hitting screen's max DCS length." 'terminal-init-screen)) (bytes (encode-coding-string data 'utf-8-unix)) (base-64 (if screen - (replace-regexp-in-string + (string-replace "\n" "\e\\\eP" - (base64-encode-string bytes) - :fixedcase :literal) + (base64-encode-string bytes)) (base64-encode-string bytes :no-line-break))) (length (length base-64))) (if (> length xterm-max-cut-length) diff --git a/lisp/textmodes/picture.el b/lisp/textmodes/picture.el index 1368af01bac..1d5d1caeabc 100644 --- a/lisp/textmodes/picture.el +++ b/lisp/textmodes/picture.el @@ -449,8 +449,8 @@ If no such character is found, move to beginning of line." (progn (beginning-of-line) (skip-chars-backward - (concat "^" (replace-regexp-in-string - "\\\\" "\\\\" picture-tab-chars nil t)) + (concat "^" (string-replace + "\\" "\\\\" picture-tab-chars)) (point-min)) (not (bobp)))) (move-to-column target)) diff --git a/lisp/thumbs.el b/lisp/thumbs.el index 5710b8c353b..4c863883ba4 100644 --- a/lisp/thumbs.el +++ b/lisp/thumbs.el @@ -434,10 +434,10 @@ Open another window." (defun thumbs-call-setroot-command (img) "Call the setroot program for IMG." (run-hooks 'thumbs-before-setroot-hook) - (shell-command (replace-regexp-in-string - "\\*" + (shell-command (string-replace + "*" (shell-quote-argument (expand-file-name img)) - thumbs-setroot-command nil t)) + thumbs-setroot-command)) (run-hooks 'thumbs-after-setroot-hook)) (defun thumbs-set-image-at-point-to-root-window () diff --git a/lisp/tooltip.el b/lisp/tooltip.el index 03d9f54ea6c..23b67ee2cab 100644 --- a/lisp/tooltip.el +++ b/lisp/tooltip.el @@ -346,7 +346,7 @@ It is also called if Tooltip mode is on, for text-only displays." (not cursor-in-echo-area)) ;Don't overwrite a prompt. (cond ((stringp help) - (setq help (replace-regexp-in-string "\n" ", " help)) + (setq help (string-replace "\n" ", " help)) (unless (or tooltip-previous-message (equal-including-properties help (current-message)) (and (stringp tooltip-help-message) diff --git a/lisp/transient.el b/lisp/transient.el index 5f66a13094b..4087a0c68a6 100644 --- a/lisp/transient.el +++ b/lisp/transient.el @@ -3064,18 +3064,18 @@ Optional support for popup buttons is also implemented here." ((equal (seq-take seq len) transient--redisplay-key) (let ((pre (key-description (vconcat (seq-take seq len)))) (suf (key-description (vconcat (seq-drop seq len))))) - (setq pre (replace-regexp-in-string "RET" "C-m" pre t)) - (setq pre (replace-regexp-in-string "TAB" "C-i" pre t)) - (setq suf (replace-regexp-in-string "RET" "C-m" suf t)) - (setq suf (replace-regexp-in-string "TAB" "C-i" suf t)) + (setq pre (string-replace "RET" "C-m" pre)) + (setq pre (string-replace "TAB" "C-i" pre)) + (setq suf (string-replace "RET" "C-m" suf)) + (setq suf (string-replace "TAB" "C-i" suf)) ;; We use e.g. "-k" instead of the more correct "- k", ;; because the former is prettier. If we did that in ;; the definition, then we want to drop the space that ;; is reinserted above. False-positives are possible ;; for silly bindings like "-C-c C-c". (unless (string-match-p " " key) - (setq pre (replace-regexp-in-string " " "" pre)) - (setq suf (replace-regexp-in-string " " "" suf))) + (setq pre (string-replace " " "" pre)) + (setq suf (string-replace " " "" suf))) (concat (propertize pre 'face 'default) (and (string-prefix-p (concat pre " ") key) " ") (transient--colorize-key suf cmd) diff --git a/lisp/url/url-mailto.el b/lisp/url/url-mailto.el index 29c2780121a..4fd631d2955 100644 --- a/lisp/url/url-mailto.el +++ b/lisp/url/url-mailto.el @@ -105,7 +105,7 @@ (goto-char (point-max))) (insert (mapconcat (lambda (string) - (replace-regexp-in-string "\r\n" "\n" string)) + (string-replace "\r\n" "\n" string)) (cdar args) "\n"))) (url-mail-goto-field (caar args)) ;; (setq func (intern-soft (concat "mail-" (caar args)))) diff --git a/lisp/vc/log-edit.el b/lisp/vc/log-edit.el index 4a44787bb03..46e9c97eb0a 100644 --- a/lisp/vc/log-edit.el +++ b/lisp/vc/log-edit.el @@ -974,8 +974,8 @@ Return non-nil if it is." (not (looking-at (format ".+ .+ <%s>" (regexp-quote mail)))) (looking-at ".+ \\(.+ <.+>\\) *\\((tiny change)\\)?")) - (let ((author (replace-regexp-in-string " " " " - (match-string 1)))) + (let ((author (string-replace " " " " + (match-string 1)))) (unless (and log-edit-author (string-match (regexp-quote author) (car log-edit-author))) diff --git a/lisp/vc/vc-bzr.el b/lisp/vc/vc-bzr.el index de5a90dc602..5144b5d0bbb 100644 --- a/lisp/vc/vc-bzr.el +++ b/lisp/vc/vc-bzr.el @@ -467,7 +467,7 @@ in the branch repository (or whose status not be determined)." ;; Erase the status text that matched. (delete-region (match-beginning 0) (match-end 0)) (setq status - (intern (replace-regexp-in-string " " "" statusword))))) + (intern (string-replace " " "" statusword))))) (when status (goto-char (point-min)) (skip-chars-forward " \n\t") ;Throw away spaces. diff --git a/lisp/vc/vc-hg.el b/lisp/vc/vc-hg.el index c9c1e91d483..4a64caa36b8 100644 --- a/lisp/vc/vc-hg.el +++ b/lisp/vc/vc-hg.el @@ -851,8 +851,8 @@ if we don't understand a construct, we signal (push "\\[" parts)) (t (let ((x (substring glob i j))) - (setf x (replace-regexp-in-string - "\\\\" "\\\\" x t t)) + (setf x (string-replace + "\\" "\\\\" x)) (setf i (1+ j)) (cond ((eq (aref x 0) ?!) (setf (aref x 0) ?^)) diff --git a/lisp/vc/vc-svn.el b/lisp/vc/vc-svn.el index c30920dd157..544a6c769fc 100644 --- a/lisp/vc/vc-svn.el +++ b/lisp/vc/vc-svn.el @@ -192,7 +192,7 @@ switches." (let ((state (cdr (assq (aref (match-string 1) 0) state-map))) (propstat (cdr (assq (aref (match-string 2) 0) state-map))) (filename (if (memq system-type '(windows-nt ms-dos)) - (replace-regexp-in-string "\\\\" "/" (match-string 4)) + (string-replace "\\" "/" (match-string 4)) (match-string 4)))) (and (memq propstat '(conflict edited)) (not (eq state 'conflict)) ; conflict always wins diff --git a/lisp/xdg.el b/lisp/xdg.el index 0bdfd114c48..e5165bbd86a 100644 --- a/lisp/xdg.el +++ b/lisp/xdg.el @@ -208,8 +208,8 @@ Optional argument GROUP defaults to the string \"Desktop Entry\"." "Partition VALUE into elements delimited by unescaped semicolons." (let (res) (setq value (string-trim-left value)) - (dolist (x (split-string (replace-regexp-in-string "\\\\;" "\0" value) ";")) - (push (replace-regexp-in-string "\0" ";" x) res)) + (dolist (x (split-string (string-replace "\\;" "\0" value) ";")) + (push (string-replace "\0" ";" x) res)) (when (null (string-match-p "[^[:blank:]]" (car res))) (pop res)) (nreverse res))) diff --git a/test/lisp/electric-tests.el b/test/lisp/electric-tests.el index 235c02f8e8b..ea856ab311c 100644 --- a/test/lisp/electric-tests.el +++ b/test/lisp/electric-tests.el @@ -146,7 +146,7 @@ The buffer's contents should %s: "") char (if (string= fixture expected-string) "stay" "become") - (replace-regexp-in-string "\n" "\\\\n" expected-string) + (string-replace "\n" "\\n" expected-string) expected-point))) `(ert-deftest ,(intern (format "electric-pair-%s-at-point-%s-in-%s%s" name diff --git a/test/lisp/term-tests.el b/test/lisp/term-tests.el index 503cb5d7aab..50ac370b5b5 100644 --- a/test/lisp/term-tests.el +++ b/test/lisp/term-tests.el @@ -56,7 +56,7 @@ first line\r next line\r\n")) (should (equal (term-test-screen-from-input 40 12 str) - (replace-regexp-in-string "\r" "" str))))) + (string-replace "\r" "" str))))) (ert-deftest term-carriage-return () (skip-unless (not (memq system-type '(windows-nt ms-dos)))) diff --git a/test/lisp/time-stamp-tests.el b/test/lisp/time-stamp-tests.el index 0d64320496d..4e6fbbba923 100644 --- a/test/lisp/time-stamp-tests.el +++ b/test/lisp/time-stamp-tests.el @@ -849,7 +849,7 @@ The functions in `pattern-mod' are composed left to right." (defun formatz-mod-del-colons (string) "Returns STRING with any colons removed." - (replace-regexp-in-string ":" "" string)) + (string-replace ":" "" string)) (defun formatz-mod-add-00 (string) "Returns STRING with \"00\" appended." diff --git a/test/lisp/wdired-tests.el b/test/lisp/wdired-tests.el index ba276e24d96..96a01fc2c7b 100644 --- a/test/lisp/wdired-tests.el +++ b/test/lisp/wdired-tests.el @@ -31,7 +31,7 @@ Partially modifying a file name should succeed." (let* ((test-dir (make-temp-file "test-dir-" t)) (test-file (concat (file-name-as-directory test-dir) "foo.c")) (replace "bar") - (new-file (replace-regexp-in-string "foo" replace test-file)) + (new-file (string-replace "foo" replace test-file)) (wdired-use-interactive-rename t)) (write-region "" nil test-file nil 'silent) (advice-add 'dired-query ; Don't ask confirmation to overwrite a file. @@ -109,7 +109,7 @@ wdired-mode." (let* ((test-dir (make-temp-file "test-dir-" t)) (test-file (concat (file-name-as-directory test-dir) "foo.c")) (replace "bar") - (new-file (replace-regexp-in-string "foo" replace test-file))) + (new-file (string-replace "foo" replace test-file))) (write-region "" nil test-file nil 'silent) (let ((buf (find-file-noselect test-dir))) (unwind-protect diff --git a/test/src/json-tests.el b/test/src/json-tests.el index 908945fcb08..8dc0a744aa0 100644 --- a/test/src/json-tests.el +++ b/test/src/json-tests.el @@ -252,7 +252,7 @@ Test with both unibyte and multibyte strings." (let* ((input "{ \"abc\" : [9, false] , \"def\" : null }") (output - (replace-regexp-in-string " " "" input))) + (string-replace " " "" input))) (should (equal (json-parse-string input :object-type 'plist :null-object :json-null -- cgit v1.2.3