... but WHY? What use is defining an equ replacement name as a label yet retaining the original equ name in the struc definitions?

the symbolic constants are usually only replaced in the lines, where no preprocessor directives nor macroinstructions has been found

[code][/code]    

Ah, but there IS no "a:", only "zz:"

Section 2.3.7's "usually only" is unfortunately ambiguous

as in the case of a struc label it is not ignored

The preprocesor has a lot of code to make the EQU'd label in a struc act line a label, but to what advantage? Does anyone know of any current code that depends on that?

I can see enforcing the no-EQU replacement in a directive rule for struc

replacing the struc label with the EQU value (creating zz.a in the example)

either would be consistent, but not what it does now

the feature appears useless and even highly bug-prone as the presence of the label cannot be seen unless you examine the tokens

Here's ws one problem with the way it is now

struc s a { .: match l,. \{ l\#\.a db a \} }    

struc s a
{
    define . .
    .: .a db a
    restore .
}    

Section 2.3.7's "usually only" is unfortunately ambiguous as in the case of a struc label it is not ignored. The preprocesor has a lot of code to make the EQU'd label in a struc act line a label, but to what advantage? Does anyone know of any current code that depends on that?

struc QQQ a {.a db a }    

struc QQQ a {.: .a db a}    

struc QQQ a {.: .a db a}
a QQQ 3    

macro QQQ .,a {.: .#.a db a}
QQQ a,3    

without knowing the internal details, I would agree that the actual result is unexpected

This label will be also attached at the beginning of every name starting with dot in the contents of macroinstruction.

macroinstructions are replaced with corresponding code even before the symbolic constants are replaced with their values.

Put an equ name as a struc label and that label suddenly takes on two meanings, one before and one after equ replacement.

This, as the preprocessor code shows, is a unique "special case" in fasm

This brings back "what you see is what you get" always a good feature in any programming language.

The example I've used only uses the latest (or only) definition.

In the case of an equ name in the label field of a struc, the generated equ-name label serves what purpose?

times 5 virtual
    db 'I''m inside a strange construct',13,10
times 5 end virtual    

;Allows to assign new value to a symbol without congesting it's stack
;usage: mysym equ 1
;       mysym reequ mysym,2
struc reequ [val]
{
    common
        tmp equ val
            restore .
            . equ tmp
        restore tmp
}

;Allows calculations with preprocessor
;usage: result equcalc 15/2 mod result
struc equcalc expr
{
    rept 1 res:expr
    \{
        restore .
        . equ res
    \}
}

;Finds the maximum value
;usage: max equmax 10,-15
struc equmax val1*, val2*
{
    rept 1 diff : ((val1)-(val2))
    \{
        restore .
        . equ val1
        match - any,diff
        \\{
            restore .
            . equ val2          
        \\}
    \}
}

;Allows to replicate the specified symbol a number of times
;with an optional delimiter
;usage: replication equdup 'hello',10,<#',',>
;       display replication
struc equdup val*, count*, delim
{
    tmp equ
    tmp equmax 1,count
    
    restore .
    . equ
    rept tmp-1 \{ . reequ . val delim \}
    rept 1 i:count \{ match =i,tmp \\{ . reequ . val \\} \}
    
    restore tmp
}    

At the very least (given that fasm has a good bit of code in the preprocessor to deal with this situation) this "feature" should be documented more precisely.

The standard preprocessing that comes after, on each line begins with recognition of the first symbol. It starts with checking for the preprocessor directives, and when none of them is detected, preprocessor checks whether the first symbol is macroinstruction. If no macroinstruction is found, it moves to the second symbol of line, and again begins with checking for directives, which in this case is only the equ directive, as this is the only one that occurs as the second symbol in line. If there is no directive, the second symbol is checked for the case of structure macroinstruction and when none of those checks gives the positive result, the symbolic constants are replaced with their values and such line is passed to the assembler.

When the macroinstruction generates the new lines from its definition block, in every line it first scans for macroinstruction directives, and interpretes them accordingly. All the other content in the definition block is used to brew the new lines, replacing the parameters with their values and then processing the symbol escaping and # and ` operators. The conversion operator has the higher priority than concatenation and if any of them operates on the escaped symbol, the escaping is cancelled before finishing the operation. After this is completed, the newly generated line goes through the standard preprocessing, as described above.

Since it appears no one has come up with a good use for the way it works now, why not change it?