Question

Some time ago @Oleg Pavliv explained in https://unix.stackexchange.com/questions/47615/emacs-simple-arithmetics-in-query-replace how to do simple arithmetics in query replace (interactively) in emacs.

Now I want to use the same method for a small elisp program but it doesn’t work. Consider for example the following minimal example of elisp code:

(defun Nshift ()
(interactive)
(query-replace-regexp "\\([0-9]+\\)\\.Number" "\\,((+ 3 \\#1)).Number")
)

Now suppose I run Nshift in a buffer which contains for example the string 4.Number then I get the following error message.

match-substitute-replacement: Invalid use of `\' in replacement text

How would a correct elisp implementation of Nshift look like?

Edit:

I don’t see how Seans answer generalizes with easy and readable syntax to more complicated replacements (which I need in my application), so for example what would be the correct (and easy to read) equivalent to

(query-replace-regexp "\\([0-9]+\\)\\.Number.\\([0-9]+\\)" "\\,((+ 3 \\#1)).Number.\\,((+ 8 \\#2))")

Answer 1

Like this:

(defun Nshift ()
  (interactive)
  (while (search-forward-regexp "\\([0-9]+\\)\\.Number" nil t)
    (replace-match (format "%s.Number" (+ 3 (string-to-number (match-string 1)))))))

EDITED TO ADD:

Your expanded example could be implemented in this way:

(defun Nshift ()
  (interactive)
  (while (search-forward-regexp "\\([0-9]+\\)\\.Number\\.\\([0-9]+\\)" nil t)
    (replace-match
     (number-to-string (+ 3 (string-to-number (match-string 1))))
     nil nil nil 1)
    (replace-match
     (number-to-string (+ 8 (string-to-number (match-string 2))))
     nil nil nil 2)))

It’s actually even easier than my original solution, because I forgot that replace-match has an optional fifth argument that causes it to replace just a single subexpression, and saves you from having to duplicate the fixed text (“.Number.”) in the replacement text.

There’s some refactoring that could be done here:

(defun increment-match-string (match-index increment)
  (replace-match
   (number-to-string (+ increment (string-to-number (match-string match-index))))
   nil nil nil match-index))

Then Nshift could be implemented like so:

(defun Nshift ()
  (interactive)
  (while (search-forward-regexp "\\([0-9]+\\)\\.Number\\.\\([0-9]+\\)" nil t)
    (increment-match-string 1 3)
    (increment-match-string 2 8)))