Is there a way to break out of "rept", "irp" or "irps"? Pls, i need it in a complex expression macro (parses expressions). I found a overkill way, that is, use a boolean symbolic constant to signal if it should process or not, but that is not very good as the ENTIRE list gets processed anyway (even if 90% of elements are not used). So, it would be helpful to know how to break out of these directives (and i must use preprocessor here, not assembler).

if there's no such directive, is it hard to add one. if so, pls tell me some reasons. I'm sorry if there's a strong reason behind it, but I'm confused.

thanks

Any such directive would have to be a macro special directive like the "local" one, and thus it would get processed unconditionally just when met. Consider this example:

Since "local" is not escaped, it is recognized by the "rept" macro and thus processed unconditionally. And if it was escaped, it would be the directive for inner "match" macro, not "rept".

Thus the problem lies here in the philosophy of fasm's macros - each one just generates some new source "text" which is processed later, and there are no conditional mechanism for inner macro workings (the "match" directive is just another kind of macro). See the part about macros in my unfinished Understanding fasm arcticle - I hope it is able to make some things more clear. The language of fasm's preprocessor is really different from many of the other interpreted languages (including the fasm's assembler's language, which is quite standard with its IF/WHILE/etc. constructions); it may have something common with LISP, philosophicaly speaking, but this similarity is not really straightforward.

This is how I do it (just an example, assume loop? is empty upon entry):



this works, but it still iterates even after '+' was found.
how does rept actually work? something like:



translates to (after rept):

or does it process each one completely, and only then repeats?
is it difficult to make rept evaluate the "inner" macros as it processes through it's parameters (i.e on the first step, it sees the "match" is false, so it won't write anything, then it goes to second step, etc... in this way, the "break" could have been done)

sorry if I sound dumb.
have you any ideas how I could make my "irps" better?
thanks for reply, now i understand preprocessor even more

It doesn't really matter how is it done internally - in both those cases the result would be in fact the same. This is the key to understanding what's going on here. The macro produces some lines, and each of those lines may also produce some new lines if it is a macro. But given the definition of a macro and the line that invokes it, there are no other factors that could affect what are the result lines produced by a macro. So the outer macro will generate the same lines no matter whether we expand each of them just when it's generated, or whether we wait till the outer macro finished, and then expand all newly-made lines. Think about - I know it may not be simple, but when you get it, you'll get the essence of fasm's preprocessor understanding.

Note that we have mentioned two different possible implementations of fasm's macro processor, that would still give the same results. I don't officialy state which of those implementations is used - I describe the language, not its implementation. The important point here is that the problems we are discussing are not the result of some possible faults in fasm's implementation of this language, they emerge from the language design itself.


The "match" is something that is generated by macro here, not the thing that would affect the processing of macro itself. Only the operators like "forward", "local" or "#" affect processing of the macro, and their operation is not affected in any way by what has already been generated by given macro, as it was said above.

Okay, i get it, then macros can have only fixed number of arguments/etc. (in fact they don't rely on what's inside). thx

anyway, any chance what could make my method better?

I figured that, if I stop only at a given symbol:


I can use this trick: I know, I should've included "match any +, ..." and "match + blabla, ..." and "match +, ..." too (since '+' can be anywhere), but the idea is there.

what's sad is that with 2 or more symbols (like '+' and '-'), it simply won't work. any other ideas, or should I stick to my original method?