Macro used for dynamic setting of font-lock-keywords

Macro used for dynamic setting of font-lock-keywords

[Sebastian Tennant]

Hi all,

This works:

  (defun foo (word)
    (display-buffer (set-buffer (get-buffer-create "*bar*")))
    (insert (format "baz\n"))
    (unless (fboundp 'foo-dynamic-add-keyword) ;only define it once
      (defmacro foo-dynamic-add-keyword ()
        `(font-lock-add-keywords nil '((,word . font-lock-warning-face)) 'set)))
    (foo-dynamic-add-keyword) ;call the macro
    (font-lock-mode 1))

  (foo "baz")

in that the string argument to foo is added to the buffer's
font-lock-keywords and the string is highlighted wherever it occurs,
but it seems like something of a kludge to me.

Just out of interest really, is there a better way of passing the
value of a variable as an argument to the function
font-lock-add-keywords?

Sebastian

Re: Macro used for dynamic setting of font-lock-keywords

[Tim X]

Sebastian Tennant <sebyte@smolny.plus.com> writes:

> Subject: Macro used for dynamic setting of font-lock-keywords
>
> Hi all,
>
> This works:
>
>   (defun foo (word)
>     (display-buffer (set-buffer (get-buffer-create "*bar*")))
>     (insert (format "baz\n"))
>     (unless (fboundp 'foo-dynamic-add-keyword) ;only define it once
>       (defmacro foo-dynamic-add-keyword ()
>         `(font-lock-add-keywords nil '((,word . font-lock-warning-face)) 'set)))
>     (foo-dynamic-add-keyword) ;call the macro
>     (font-lock-mode 1))
>
>   (foo "baz")
>
> in that the string argument to foo is added to the buffer's
> font-lock-keywords and the string is highlighted wherever it occurs,
> but it seems like something of a kludge to me.
>
> Just out of interest really, is there a better way of passing the
> value of a variable as an argument to the function
> font-lock-add-keywords?

I must be missing something - I don't understand why you are using a macro or
what the issue is with passing an argument. Doesn't something like (not tested)

(defun my-add-keyword (word) 
  (font-lock-add-keywords nil ((word . font-lock-warning-face)) 'set))

and use it like

(my-add-keyword "FIXME")

I can't see any reason for the macro.

I often use something like the following in my .emacs

(add-hook xxx-mode-hook 
            (lambda ()
               .... ; various mode specific struff
               (font-lock-add-keywords nil
                  '(("\\<\\(FIXME\\):" 1 font-lock-warning-face prepend)))))

which highlights FIXME: in the warning face. To be honest, I can't see any
benefit in defining a function just to define a simple additional word as you
have done and certainly cannot see any justification for a macro being defined
in that function.

If what you want to do is define a function you can call interactively to add
keywords, then look into the 'interactive' function to see how it can be used
to prompt the user (for lets say the word and the face to use. 

Tim



-- 
tcross (at) rapttech dot com dot au

Re: Macro used for dynamic setting of font-lock-keywords

[Sebastian Tennant]

Quoth Tim X <timx@nospam.dev.null>:
>>   (defun foo (word)
>>     (display-buffer (set-buffer (get-buffer-create "*bar*")))
>>     (insert (format "baz\n"))
>>     (unless (fboundp 'foo-dynamic-add-keyword) ;only define it once
>>       (defmacro foo-dynamic-add-keyword ()
>>         `(font-lock-add-keywords nil '((,word . font-lock-warning-face)) 'set)))
>>     (foo-dynamic-add-keyword) ;call the macro
>>     (font-lock-mode 1))
>>
>>   (foo "baz")
>>
>> in that the string argument to foo is added to the buffer's
>> font-lock-keywords and the string is highlighted wherever it occurs,
>> but it seems like something of a kludge to me.
>>
>> Just out of interest really, is there a better way of passing the
>> value of a variable as an argument to the function
>> font-lock-add-keywords?
>
> I must be missing something - I don't understand why you are using a macro or
> what the issue is with passing an argument. Doesn't something like (not tested)
>
(defun my-add-keyword (word) 
  (font-lock-add-keywords nil '((word . font-lock-warning-face)) 'set))
[C-x C-e]
my-add-keyword

(my-add-keyword "keyword")
[C-x C-e]
(t ((word . font-lock-warning-face)) (word (0 font-lock-warning-face)))
                                        ^
                                        |
 This doesn't do the job ---------------+

As you can see, passing arguments that make it into font-lock-keywords
is not so straightforward as you think.

> (add-hook xxx-mode-hook 
>             (lambda ()
>                .... ; various mode specific struff
>                (font-lock-add-keywords nil
>                   '(("\\<\\(FIXME\\):" 1 font-lock-warning-face prepend)))))

Of course this works.  The pattern you want to match is being added
directly to the list.

Sebastian

Re: Macro used for dynamic setting of font-lock-keywords

[Tim X]

Sebastian Tennant <sebyte@smolny.plus.com> writes:

> Quoth Tim X <timx@nospam.dev.null>:
>>>   (defun foo (word)
>>>     (display-buffer (set-buffer (get-buffer-create "*bar*")))
>>>     (insert (format "baz\n"))
>>>     (unless (fboundp 'foo-dynamic-add-keyword) ;only define it once
>>>       (defmacro foo-dynamic-add-keyword ()
>>>         `(font-lock-add-keywords nil '((,word . font-lock-warning-face)) 'set)))
>>>     (foo-dynamic-add-keyword) ;call the macro
>>>     (font-lock-mode 1))
>>>
>>>   (foo "baz")
>>>
>>> in that the string argument to foo is added to the buffer's
>>> font-lock-keywords and the string is highlighted wherever it occurs,
>>> but it seems like something of a kludge to me.
>>>
>>> Just out of interest really, is there a better way of passing the
>>> value of a variable as an argument to the function
>>> font-lock-add-keywords?
>>
>> I must be missing something - I don't understand why you are using a macro or
>> what the issue is with passing an argument. Doesn't something like (not tested)
>>
> (defun my-add-keyword (word) 
>   (font-lock-add-keywords nil '((word . font-lock-warning-face)) 'set))
> [C-x C-e]
> my-add-keyword
>
> (my-add-keyword "keyword")
> [C-x C-e]
> (t ((word . font-lock-warning-face)) (word (0 font-lock-warning-face)))
>                                         ^
>                                         |
>  This doesn't do the job ---------------+
>
> As you can see, passing arguments that make it into font-lock-keywords
> is not so straightforward as you think.
>
>> (add-hook xxx-mode-hook 
>>             (lambda ()
>>                .... ; various mode specific struff
>>                (font-lock-add-keywords nil
>>                   '(("\\<\\(FIXME\\):" 1 font-lock-warning-face prepend)))))
>
> Of course this works.  The pattern you want to match is being added
> directly to the list.
>

My mistake for not checking the code and documentation closer. 

Your problem is passing the argument, its that the way you have the function
prevents the argument from being evaluated, so what is really happening is the
symbol word is getting added to the list. Try this

(defun my-add-keyword (word) 
    (font-lock-add-keywords nil (cons word font-lock-warning-face)) t))

Though you probably should define the function to take three arguments, the
word (or regexp), the match-group and the facename. You could make the last two
optional with defaults. 

Tim

Re: Macro used for dynamic setting of font-lock-keywords

[Sebastian Tennant]

Quoth Tim X <timx@nospam.dev.null>:
> symbol word is getting added to the list. Try this
>
> (defun my-add-keyword (word) 
>     (font-lock-add-keywords nil (cons word font-lock-warning-face)) t))


Your function (above) needs an extra cons but now it works:

  (defun my-add-keyword (word) 
      (font-lock-add-keywords nil (cons (cons word font-lock-warning-face) '(t))))

Thanks for pointing out the obvious, although I enjoyed cobbling
together my macro kludge.  I can't believe it didn't occur to me to
use cons.  I suppose it's because I'm thinking macros generally at the
moment, and hell... why use a simple cons or two, when you can write a
complicated macro!

Sebastian

Re: Macro used for dynamic setting of font-lock-keywords

[Tim X]

Sebastian Tennant <sebyte@smolny.plus.com> writes:

> Quoth Tim X <timx@nospam.dev.null>:
>> symbol word is getting added to the list. Try this
>>
>> (defun my-add-keyword (word) 
>>     (font-lock-add-keywords nil (cons word font-lock-warning-face)) t))
>
>
> Your function (above) needs an extra cons but now it works:
>
>   (defun my-add-keyword (word) 
>       (font-lock-add-keywords nil (cons (cons word font-lock-warning-face) '(t))))
>
> Thanks for pointing out the obvious, although I enjoyed cobbling
> together my macro kludge.  I can't believe it didn't occur to me to
> use cons.  I suppose it's because I'm thinking macros generally at the
> moment, and hell... why use a simple cons or two, when you can write a
> complicated macro!
>

Its funny, people are often excited about writing a macro - I certainly was
when I first learnt about them. However, while I've done it to prove that I
could, in reality, I've not yet come across anywhere that I needed a macro or
where a macro could do something better than just a plain old function. I
suspect that until you start writing really quite large or complex stuff, you
won't come across many places wehre you really need a macro or where it will
make code more readable etc. 

When working at customizing or updating existing behavior in emacs, one of my
favorite facilities is 'defadvice'. I've used this facility to work around
bugs, stop a mode from reporting pointless/uninteresting messages, temporarily
modify behavior on the fly etc. Its a really handy little feature which doesn't
seem to get used as often as it probably should. I've seen people post 20+
lines of elisp to this list to do something which could be achieved more
reliably with 4 or five lines of defadvice. 

Tim

-- 
tcross (at) rapttech dot com dot au

Re: Macro used for dynamic setting of font-lock-keywords

[Xavier Maillard]

Hi,

   seem to get used as often as it probably should. I've seen people post 20+
   lines of elisp to this list to do something which could be achieved more
   reliably with 4 or five lines of defadvice. 

Advice is considered as *dangerous* and not to be used extensively.

	Xavier
-- 
http://www.gnu.org
http://www.april.org
http://www.lolica.org

Re: Macro used for dynamic setting of font-lock-keywords

[Tim X]

Xavier Maillard <xma@gnu.org> writes:

> Hi,
>
>    seem to get used as often as it probably should. I've seen people post 20+
>    lines of elisp to this list to do something which could be achieved more
>    reliably with 4 or five lines of defadvice. 
>
> Advice is considered as *dangerous* and not to be used extensively.
>

A little extreme don't you think. There are certainly some things to watch out
for and it can make things a bit harder for debugging if you forget etc, but I
don't think it can be called *dangerous* any more than any other feature we
have available. Obviously, just like macros, it can be misused. However,
telling people its dangerous and should be avoided does nothing but create FUD.
As long as people follow the guidelines in the Emacs Lisp Reference, then I
can't see a problem (BTW, it does not say anything about it being *dangerous*
in the manual). 

I've been using a package of over 66k lines with over 1700 bits of advice in it
that has worked extremely well for over 10 years. Innearly all cases, using
defadvice was the only way to achieve the desired outcome. Without this
feature, the package simply would not have been possible. 

Tim
 

-- 
tcross (at) rapttech dot com dot au

Re: Macro used for dynamic setting of font-lock-keywords

[Sebastian Tennant]

Quoth Xavier Maillard <xma@gnu.org>:
> Hi,
>
>    seem to get used as often as it probably should. I've seen people post 20+
>    lines of elisp to this list to do something which could be achieved more
>    reliably with 4 or five lines of defadvice. 
>
> Advice is considered as *dangerous* and not to be used extensively.
>
Indeed this is what I've been lead to believe.  I think RMS' position
on defadvice, which confirms this, is knocking about somewhere.

IMHO macros (at a user-level) are useful whenever you would otherwise
repeat yourself.  For example, I like to keep technical notes in a
~/tech-notes directory and quotes in a ~/quotes directory.  Rather
than write an interactive command for each I wrote a macro which I
called commandir:

  (defmacro commandir (call pmt dir def)
    `(defun ,call ()
       (interactive)
       (let (checked-dir filename)
       ;; checked-dir will always ends with a '/'
       (setq checked-dir (file-name-as-directory ,dir))
       ;;accept user input
       (setq filename (read-file-name ,pmt checked-dir))
       (when (equal filename "") (setq filename ,def))
       ;;read file or create new buffer if file does not exist
       ;;(buffer is automatically selected for editing)
       (find-file (concat checked-dir filename) nil)
       .
       .
       .

I can now 'build' as many functions as I like, each providing quick
access to the contents of my various directories, with simple macro
calls like this one in my ~/.emacs file:

  (commandir tn "Tech note: " "~/tech-notes" "misc")

Then it is a case of simply typing::

  M-x tn <RET>

and I am prompted for a filename (with filename completion based on
the contents of ~/tech-notes").  If I enter the name of an exisitng
file, that file is visited, if I enter a non-existing file name, that
file will be created when the buffer is saved, and if I don't type
anything, ~/tech-notes/misc is visited.

Very handy indeed!

Sebastian

Re: Macro used for dynamic setting of font-lock-keywords

[Kevin Rodgers]

Sebastian Tennant wrote:
> Quoth Tim X <timx@nospam.dev.null>:
>> symbol word is getting added to the list. Try this
>>
>> (defun my-add-keyword (word) 
>>     (font-lock-add-keywords nil (cons word font-lock-warning-face)) t))
> 
> 
> Your function (above) needs an extra cons but now it works:
> 
>   (defun my-add-keyword (word) 
>       (font-lock-add-keywords nil (cons (cons word font-lock-warning-face) '(t))))

You might find this more readable:

(defun my-add-keyword (word)
   (font-lock-add-keywords nil `((,word . ,font-lock-warning-face) t)))

> Thanks for pointing out the obvious, although I enjoyed cobbling
> together my macro kludge.  I can't believe it didn't occur to me to
> use cons.  I suppose it's because I'm thinking macros generally at the
> moment, and hell... why use a simple cons or two, when you can write a
> complicated macro!

Or a simple backquote :-)

-- 
Kevin Rodgers
Denver, Colorado, USA

Re: Macro used for dynamic setting of font-lock-keywords

[Kevin Rodgers]

Sebastian Tennant wrote:
> Quoth Xavier Maillard <xma@gnu.org>:
>> Hi,
>>
>>    seem to get used as often as it probably should. I've seen people post 20+
>>    lines of elisp to this list to do something which could be achieved more
>>    reliably with 4 or five lines of defadvice. 
>>
>> Advice is considered as *dangerous* and not to be used extensively.
>>
> Indeed this is what I've been lead to believe.  I think RMS' position
> on defadvice, which confirms this, is knocking about somewhere.

I think RMS' position is that defadvice should not be used within Emacs
itself.  But the inclusion of defadvice.el in Emacs is tacit
acknowledgement of its usefulness: When there is no variable or hook
function that the user can customize to achieve some new behavior,
defadvice allows you to modify the behavior of a function _without
duplicating its original definition in its entirety_.  Thus you can
write a very small piece of code that is *more* likely to continue
to work over time, even as the implementation of the underlying function
evolves within Emacs, and in conjunction with other customizations of
the function.  That makes it *less* dangerous than the naive approach of
copy-and-paste.

-- 
Kevin Rodgers
Denver, Colorado, USA

Re: Macro used for dynamic setting of font-lock-keywords

[Eli Zaretskii]

> From: Kevin Rodgers <kevin.d.rodgers@gmail.com>
> Date: Fri, 01 Jun 2007 21:41:15 -0600
> 
> >> Advice is considered as *dangerous* and not to be used extensively.
> >>
> > Indeed this is what I've been lead to believe.  I think RMS' position
> > on defadvice, which confirms this, is knocking about somewhere.
> 
> I think RMS' position is that defadvice should not be used within Emacs
> itself.  But the inclusion of defadvice.el in Emacs is tacit
> acknowledgement of its usefulness

You are right on both accounts.  And I see no contradiction between
those two, because RMS never said that defadvice is not useful.  His
position on not using it within Emacs itself is because doing that
obscures how things work, which is bad from the maintainability point
of view.  FWIW, I agree with that.

So the ``considered dangerous'' stuff above is not right, in general,
and certainly not what RMS thinks, AFAIK.

Re: Macro used for dynamic setting of font-lock-keywords

[Sebastian Tennant]

Quoth Kevin Rodgers <kevin.d.rodgers@gmail.com>:
> Sebastian Tennant wrote:
>> Quoth Xavier Maillard <xma@gnu.org>:
>>> Hi,
>>>
>>>    seem to get used as often as it probably should. I've seen people post 20+
>>>    lines of elisp to this list to do something which could be achieved more
>>>    reliably with 4 or five lines of defadvice. 
>>>
>>> Advice is considered as *dangerous* and not to be used extensively.
>>>
>> Indeed this is what I've been lead to believe.  I think RMS' position
>> on defadvice, which confirms this, is knocking about somewhere.
>
> I think RMS' position is that defadvice should not be used within Emacs
> itself.  But the inclusion of defadvice.el in Emacs is tacit
> acknowledgement of its usefulness: When there is no variable or hook
> function that the user can customize to achieve some new behavior,
> defadvice allows you to modify the behavior of a function _without
> duplicating its original definition in its entirety_.  Thus you can
> write a very small piece of code that is *more* likely to continue
> to work over time, even as the implementation of the underlying function
> evolves within Emacs, and in conjunction with other customizations of
> the function.  That makes it *less* dangerous than the naive approach of
> copy-and-paste.

Ah.  Everything is illuminated.

Many thanks.

Sebastian

Re: Macro used for dynamic setting of font-lock-keywords

[Stefan Monnier]

>   (defun foo (word)
[...]
>       (defmacro foo-dynamic-add-keyword ()

Any `defun' or `defmacro' within a `defun' is a pretty sure sign that the
coder is confused.


        Stefan "who only means it for Elisp"