replace-regexp-in-string with lookahead/behind

Question

I'd like to replace all occurrences of \w \w with \w\\\w in a string, where the \w parts stay the same before and after the replacement, e.g.

[.A foobar] [.B baz]

should result in

[.A\\foobar] [.B\\baz]

it should also work with

[.A' foobar] [.B -baz]

=>

[.A'\\foobar] [.B\\-baz]

From jlf @ #emacs

(while (string-match "\(.*\w\) \(\w\)" str)
  (setq str (concat (match-string 1 str) "\\" (match-string 2 str))))

If your edit answers your question you should post it as an answer and accept it if no one posts a better solution. — Randy Morris
– Randy Morris, Commented Oct 10, 2012 at 1:04

Andreas Röhler · Accepted Answer · 2012-10-13 07:54:30Z

2

(replace-regexp-in-string " \\_<\\w+\\_>" (lambda (x) (concat "\\\\s" (substring x 1))) mystring)

edited Oct 13, 2012 at 7:54

answered Oct 12, 2012 at 6:39

Andreas Röhler

4,83216 silver badges20 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Reactormonk Over a year ago

Nice try, but (replace-regexp-in-string "\_<\w+\_>" (lambda (x) (concat "\\" x)) "[.CP foo]") => "[.CP foo]".

Reactormonk Over a year ago

Oh, escape hell. Works almost as expected. "[.CP \\foo]" is the result, but "[.CP\\foo]" would be better.

Andreas Röhler Over a year ago

regexp starts with a whitespace now

Reactormonk Over a year ago

Would you know how to include - as possible part of the word?

Andreas Röhler Over a year ago

not sure what you are asking for, maybe open a new question giving the example

score 1 · Accepted Answer · 2012-10-10 21:04:37Z

This may be a little bit more versatile:

(defun replace-between-words (input replacement &optional preserve)
  "Replaces white space between two words with REPLACEMENT
if REPLACEMENT is a character, and PRESERVE is not NIL, then
that character is duplicated as many times as there are white spaces
between words. If PRESERVE is NIL, then only one character is
inserted.
If REPLACEMENT is a string and PRESERVE is not NIL, then it is rolled
into the available white space, otherwise the entire replacement string
is insterted."
  (with-output-to-string
    (let ((match "*") (replaced t)
          (white-count 0)
          seen-start seen-end current whites)
      (dotimes (i (length input))
        (setf current (aref input i)
              (aref match 0) current)
        (cond
         ((string-match "\\w" match)
          (if seen-end
              (progn
                (if (stringp replacement)
                    (if preserve
                        (dotimes (j white-count)
                          (write-char
                           (aref replacement
                                 (mod j (length replacement )))))
                      (princ replacement))
                  (if preserve
                      (dotimes (j white-count)
                        (write-char replacement))
                    (write-char replacement)))
                (setq seen-end nil))
            (setq seen-start t))
          (setq whites nil white-count 0)
          (write-char current))
         ((member current '(?\ ?\t ?\n ?\r))
          (if seen-start
              (if seen-end
                  (progn
                    (setq whites (cons current whites))
                    (incf white-count))
                (setq seen-end t white-count 1 whites (list ?\ )))
            (write-char current)))
         (t (when (> white-count 0)
              (princ (coerce whites 'string))
              (setq white-count 0 whites nil))
             (write-char current)
            (setq seen-end nil seen-start nil)))))))

(replace-between-words "[.A foobar]    [.B   baz]" ?\/)
"[.A/foobar]    [.B/baz]"

(replace-between-words "[.A foobar]    [.B   baz]" "-=*=-" t)
"[.A-foobar]    [.B-=*baz]"

(replace-between-words "[.A foobar]    [.B   baz]" "-=*=-")
"[.A-=*=-foobar]    [.B-=*=-baz]"

(replace-between-words "[.A foobar]    [.B   baz]" ?\/ t)
"[.A/foobar]    [.B///baz]"

(replace-between-words "[.CP [.TP [.NP" ?\/ t)
"[.CP [.TP [.NP"

And may be eventually even faster :)

This does not preserve other whitespace - [.CP [.TP [.NP is converted to [.CP[.TP[.NP.
There's a c floating around - I replaced it with white-count.

Collectives™ on Stack Overflow

replace-regexp-in-string with lookahead/behind

2 Answers 2

5 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

5 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related