Here are the few notes on how the "match" directive can help in working with such lists (I plan to put those notes also in the updated manual for the next release).

Imagine you've got defined the list of items as a value of symbolic constant, like:

And you'd like to pass those values to some macro, which would process each of items separately. The macro would be for example:

Unfortunately it won't work this way:

because the symbolic constants are replaced with their values after macroinstruction has been processed, and this time the name of constant has already became the quoted string (on the other hand it would work if constant was defined with "fix" directive, but this one is not as flexible as "equ"). The "match" directive can help, because it replaces the symbolic constants in the matched value before it checks it for the match. So the solution looks like:

The "match" directive first replaces the "list" with its value and then it performs the match - the whole list is matched to the "items" name and then passed to the macro (the "match" directive is processed like macroinstruction, what means that the matched names are processed like macro arguments, so the line "disp items" becomes "disp 1,2,3" before any actual preprocessing). Also, if the list is empty, there won't be match (since every name in the match expression needs to match at least one symbol), and the block won't be processed at all.

The other place where "match" can help with operating on such list is adding the items to them. Let's start with an empty list:

The following macroinstruction can be used to add items to it:

First match occurs only when the list is not empty, in such case the new item is attached after the comma. The second match is processed for the case of empty list, then just the value of item is assigned to the list.
This would also attach the value to list:

but there is some difference: the "any" becomes the value of "list" symbolic constant, and then inside this value (all the items from the list) the symbolic constants are replaced again, as "equ" does usually. Look at the sample:

The first match becomes just:

while the second match becomes:

Thanks for the description - it helped me a lot.
I was trying to write a helper macros for importing functions from DLLs. You can specify just a name of a dll file (like kernel32 or user32), and macro will include INC file with equates, and list of import functions. Only files with needed equates would be included.
Here are the macros:


Sample program with my macro should look like this:

It is almost working... only there's a problem with equate files - when I try to compile source, FASM reaports "incomplete macro" error, pointing on first STRUCT definition in source file. What's wrong?

Great thanks, you have found the bug in include processing that went unnoticed through all the earlier versions of fasm.
Please download the new release, it has it fixed. However your sample still won't work, since you are including the equates twice (and the "struct" cannot define the same structure twice, since it defines some global labels), but I guess you will fix this yourself.

Thanks
I forgot to write that win32a.inc has to be changed, I wasn't trying to include equates twice of course.

Something is wrong again with my first macro, if I try to use relative path FASM can't find the file...

The include happens when macro is invoked, that is when you are in the main file - so the path is relative to the path of main file. The similar problem I had to solve in WIN32AXP, you might take a look at it.

Probably the best is just to require the INCLUDE variable etc.

I tried this:




Unfortunatelly FASM doesn't allow to use # operator anywhere but inside macroinstructions, which makes this solution not fully useful.

Why not fully useful? You can just define the macros for including the files with given prefix.

And you can also do it with standard symbolic constant: