Understanding macros and the compilation flow

Understanding macros and the compilation flow

[LanX]

Hi

I've put the following code into *scratch* and did M-x eval-buffer and
got a for me suprising result:

-------------------
(defmacro mac () '(insert "		; => before "))

(defun func () (mac))

(func)		; => before

(defmacro mac () '(insert "		; => after"))

(func)		; => after
-----------------

Seems like I didn't understand the compilation process, for my
understanding the redefinition of the macro "mac" after defining the
function "func" should not effect the expansion anymore...

Please, what am I missing here?

Re: Understanding macros and the compilation flow

[Helmut Eller]

* LanX [2010-06-03 17:03+0200] writes:

> Hi
>
> I've put the following code into *scratch* and did M-x eval-buffer and
> got a for me suprising result:
>
> -------------------
> (defmacro mac () '(insert "		; => before "))
>
> (defun func () (mac))
>
> (func)		; => before
>
> (defmacro mac () '(insert "		; => after"))
>
> (func)		; => after
> -----------------
>
> Seems like I didn't understand the compilation process, for my
> understanding the redefinition of the macro "mac" after defining the
> function "func" should not effect the expansion anymore...
>
> Please, what am I missing here?

func is evaluated not compiled.  The evaluator expands macros every time
when func is called.

Helmut

Re: Understanding macros and the compilation flow

[LanX]

ahh thanks, sorry ... Perl doesn't know this destinction.

There each eval will compile the source to byte-code before execution.

Anyway Perl5 doesn't have macros...

Thanks again! :)

Re: Understanding macros and the compilation flow

[LanX]

Hi

> What you're missing is that the time (and number of times) the macro is
> expanded depends on various factors.  The Elisp interpreter by default
> only expands macro during execution (and throws away the result).
> But don't rely on it, because the byte-compiler does it differently, and
> the evaluator could also be changed to do it differently.

Sorry thats somehow irritating for me and sorry if it's trivial for
you.

So there are differences between executing a
a) compilation,
b) interpretation and
c) evaluation?

(I hope at least not between b and c)

And does this mean that an .el file executes differently from the
corresponding .elc ???
(of course compiled with the same emacs version)


And which case has the "default behaviour" I should rely on?

Re: Understanding macros and the compilation flow

[Andreas Politz]

LanX <lanx.perl@googlemail.com> writes:

> Hi
>
>> What you're missing is that the time (and number of times) the macro is
>> expanded depends on various factors.  The Elisp interpreter by default
>> only expands macro during execution (and throws away the result).
>> But don't rely on it, because the byte-compiler does it differently, and
>> the evaluator could also be changed to do it differently.
>
> Sorry thats somehow irritating for me and sorry if it's trivial for
> you.
>
> So there are differences between executing a
> a) compilation,
> b) interpretation and
> c) evaluation?
>
> (I hope at least not between b and c)
>
> And does this mean that an .el file executes differently from the
> corresponding .elc ???
> (of course compiled with the same emacs version)
>
>
> And which case has the "default behaviour" I should rely on?

There are certain pitfalls when writing macros and if you fall in one of
them, compiled code could behave differently compared to evaled
code. You should read about it here
(info "(elisp) Problems with Macros")
.


-ap