elisp: Replacing dots in strings (. -> \.)

[Jeronimo Pellegrini]

Hi.

I'm using Emacs 22.1, and while working on my .emacs file I found
a problem.

I have written functions to add a face to font-lock, and then let me
add words to be highlighted with a different color.

;; The new special face:
;;
(defface special-face
  '((t (:foreground "red" :background "black")))
  "Special face used to dynamically add words to be highlighted.")
(set-face-foreground 'special-face "red")

;; Adds one symbol to be highlighted as special-face.
;;
(defun add-special-at-point ()
  "Adds the symbol at point to the list of symbols to be highlighted
   with special-face."
  (interactive)
  (let ((name (symbol-name (symbol-at-point))))
    (message name) 
    (let ((newname (replace-regexp-in-string "\\." "\\\\." name t t)))
      (font-lock-add-keywords nil `((,name . 'special-face))))))

;; f9 will add the symbol at point:
;;
(global-set-key [f9] 'add-special-at-point)


This doesn't work really well, because when I write a symbol that starts
with a dot:

.my_special_var

And put it in the list, then Emacs will treat the leading dot as
in a regexp, and here:

(my_special_var ...)

the opening parenthesis would be highlighted also.

This seems to be because replace-regexp-in-string is ignoring
the :literal argument (I'm guessing).

I have tried passing "t" for the "literal" argument in
replace-regexp-in-string, and tried several different amounts of
backslashes in the replacement string and found something funny:

(replace-regexp-in-string "\\." "\." "aaa . bbb" t t)
      ==> "aaa . bbb"
(replace-regexp-in-string "\\." "\\." "aaa . bbb" t t)
      ==> "aaa \\. bbb"
(replace-regexp-in-string "\\." "\\\." "aaa . bbb" t t)
      ==> "aaa \\. bbb"
(replace-regexp-in-string "\\." "\\\\." "aaa . bbb" t t)
      ==> "aaa \\\\. bbb"

Now, that confuses me since I was explicitly asking the replacement to
be treated literally. What I am doing wrong?

Or, is there an easier way to replace the dots in a string so that
function will work properly?

Thanks a lot,
J.