In release "k9u0" I have added a new feature that allows better access to one of the fundamental mechanics of fasmg's engine.

Normally, when executing an instruction, fasmg adds a context information to the text of each argument, ensuring that symbols in this text are going to refer to the same entities that the caller of the macro saw. This is very handy under normal circumstances, as it allows to use the values passed in the arguments without worrying that switching namespaces may have changed their meaning. There are, however, situations when it may be necessary to reinterpret the same text in the new context.

This is what the new feature provides. By prefixing the parameter name with "&" character you can tell the assembler to not add context information to the text of the argument, allowing it to be interpreted in whichever context is present at the time of evaluation. An example I added in the manual demonstrates it on one of the simplest cases: Both the arguments have the same text, but one carries additional context, while the other one is kept raw and therefore becomes reinterpreted in the context of the "other" namespace.

While this allows macros to interpret some expressions in a special way, it also opens the way to have fully transparent line interceptors, which may pass the text of the intercepted line further without tainting it with unwanted context: This is likely to become a new preferred idiom.

Another approach would be to strip the context from the text when needed (this could always be done with help of RMATCH, or even by converting the text into raw bytes with backtick operator or STRINGIFY and then tokenizing it again with EVAL), but the effect is not exactly the same. While &-prepended parameters do not add any context information, they also do not remove any. The argument to the macro may contain pieces of text that already have some context carried from elsewhere, and this information is going to remain there, while it would be removed by RMATCH. This example: still produces "BX" output, because symbol "i" keeps it original context when being passed around (and this context is recorded at the time when "i" is packed up for the value of "addend").

Seem very promising. This feature would save me from some headache .

Combining it with another relatively recent addition, "??" interceptor, I made what I believe is the simplest and cleanest macro builder yet: It can be used to build any definitions, like macros, CALM instructions, or structures, where control directives like IF or REPEAT would not be allowed during the definition, but we can use them to prepare all the lines first, and then feed them to the assembler all at once. Here an example with STRUCT macro: The lines starting with ">" are collected, and the line starting with ">>" launches the execution of the entire generated block.

Also by adding a couple of commands after the "assemble line" it's possible to view what definition is generated: With the above sample it shows: The process is simple and transparent. Because there is no context information added to the generated lines, there should be no hidden traps.

Hi Tomasz. nice indeed !
Wouldn't that be good to include in the standard FASMG distribution package ? What do u think ?

Yes, something like this (especially when I get a good feedback) deserves at least inclusion in the utility package, and perhaps it could also go as an example in auxiliary documentation if I decide to write a section about the new tricks.

Another door this new feature opens: it allows to make custom directives to define symbolic variables carrying contextless text. Playing with this, I have another example, this time implementing a fasm-like FIX directive, making a global replacement of a symbol with some other text (in a non-interfering way thanks to the new "&line&" idiom):

thumbs up !

One more thing: this also makes it easier to emulate some of the fasm 1 syntax more closely. This specific snippet used to be quite problematic in fasmg, because context was fixed for the entire line: A simple macro that splits the context evaluation is now sufficient to properly simulate fasm's behavior: I should update fasm 2 macros to use this for better compatibility.