Hello, everybody!
I have written some macroses, but it doesn't work as I expected.
Maybe you can help me?

So, macroses:

macro M0_
{
display 'Hello from macro M0_',13,10
}

macro M1_
{
display 'Hello from macro M1_',13,10
}

macro M2_
{
display 'Hello from macro M2_',13,10
enable_callmacroses
callmacroses M0
purge callmacroses
}

macro enable_callmacroses
{
macro callmacroses [_macro]
\{
\forward
_macro#_ ; <- it doesn't work here
\}
}

macro callmacroses [_macro]
{
forward
_macro#_ ; <- but here it works
}

callmacroses M1,M2

after compiling I get this message:

illegal instuction _macro_

Somebody,please, explain me why it is so.
Thanks.

The # symbol is processed when defining the "enable_callmacroses" macro, so inside the "callmacroses" macro you get the:

line, instead of

which is what you want. In order to get the correct line in definition of "callmacroses" macro, put this line in the "enable_callmacroses":

Thank you very much, Privaliv. And excuse me, please, for not paying enough attention to your FASM programmers manual (by the time I read your answer I had already found explanation in manual). I want to use this trick in creating macroses for OOP with multiple inheritance. To tell the truth, I has already written such macroses but in another way, and it takes a lot of time for compilation. Especially it is when I declare classes with 3 or 4 levels of inheritance or with multiply inheritance. I think that when I rewrite my macroses with useng this trick, they will be compiled faster, but I have suggestion: in the source code of FASM I found that such function as VirtualAlloc is used for memory allocation (I speak about FASM fo Win32), and this function is very slow. Is it possible to replace this function with faster one (HeapAlloc or LocalAlloc),of course,if it isn't hard for you,Privalov?
Thanks again for your explanation.

Doesn't FASM do it's memory allocation once, grabbing a whole big block of memory and then managing that block itself? In that case, VirtualAlloc is plenty fast, and preferable to the other memory allocation methods.

Yes, it does a single one allocation.
The explanation could be a massive text substitution due to deep nested macros.