I've just blindly rewritten your last macro without considering any meaning behind the code (it's been a long hard day):

The purpose of preprocessor's "local" is to generate a unique name for each invocation of macro, but this name may still need to be a global label from the later assembly point of view, or a unique dot-local name. This should be a conscious choice - the undesired effects that l_inc mentioned may as well be a desired ones, depending on the purpose of macro. It is all left to the programmer.

Thanks for that, although I am still a bit confused on how you can use the value of 'len' before it has been set (it seems to be treated like a label, while the other variables are not).

Tomasz Grysztar wrote:

The purpose of preprocessor's "local" is to generate a unique name for each invocation of macro, but this name may still need to be a global label from the later assembly point of view, or a unique dot-local name. This should be a conscious choice - the undesired effects that l_inc mentioned may as well be a desired ones, depending on the purpose of macro. It is all left to the programmer.

The possible uses of global-local labels seem very limited to me (resetting the current dot-namespace?), while unique dot-local names are almost always used. It would simplifying writing if local names were dot-local by default, with a special symbol to make them global. Double dots are ugly.

macro .local [name]
 { local .name
   define name .name }

macro str [string]
{ 
    common .local asDst,dst
            local pos, len, a, esc, val
        asDst:: dst rb len
        virtual at 0 
            db string 
            pos = 0 
            esc = 0 
            repeat $ 
                load a byte from %-1 
                if a >= '0' & a <= '7' 
                    if esc > 0 
                        if esc < 4 
                            esc = esc + 1 
                            val = val * 8 + a - '0' 
                        else 
                            esc = 0 
                            store byte val at asDst:dst+pos
                            store byte a at asDst:dst+pos+1
                            pos = pos + 2 
                        end if 
                    else 
                        store byte a at asDst:dst+pos
                        pos = pos + 1 
                    end if 
                else 
                    if a = '\' 
                        if esc > 0 
                            store byte '\' at asDst:dst+pos
                            pos = pos + 1 
                            esc = 0 
                        else 
                            esc = 1 
                            val = 0 
                        end if 
                    else 
                        if esc > 0 
                            esc = 0 
                            store byte val at asDst:dst+pos
                            pos = pos + 1 
                        end if 
                        store byte a at asDst:dst+pos
                        pos = pos + 1 
                    end if 
                end if 
            end repeat 
            if esc > 1 
              store byte val at asDst:dst+pos
              pos = pos + 1 
            end if 
            len = pos 
        end virtual 
}    

The macro itself may contain the complete "ecosystem" of labels. For instance, you can take some piece of code (containing both global and local labels) and wrap it up in a macro. To make it re-usable you then need only to insert a "local" directive with the names of global labels to make them unique every time the macro is called.

Code:

macro .local [name]
 { local .name
   define name .name }    

local asDst, dst
.local asDst, dst    

Tomasz Grysztar wrote:

Code:

macro .local [name]
 { local .name
   define name .name }    

I like this, but is there a nice way to prevent it from contaminating the name space? I can only think of something like this, which isn't very nice (something with fixes maybe?):

Code:

local asDst, dst
.local asDst, dst    

macro .with [name]
{ common
   irpv previous,.with
   \{ restore previous
      restore .with \}
  forward
   local .name
   match any,name
   \{ define name .name
      define .with name \} }

macro str [string] 
{  
    common local pos, len, a, esc, val
    .with asDst,dst
        asDst:: dst rb len 
        virtual at 0  
            db string  
            pos = 0  
            esc = 0  
            repeat $  
                load a byte from %-1  
                if a >= '0' & a <= '7'  
                    if esc > 0  
                        if esc < 4  
                            esc = esc + 1  
                            val = val * 8 + a - '0'  
                        else  
                            esc = 0  
                            store byte val at asDst:dst+pos 
                            store byte a at asDst:dst+pos+1 
                            pos = pos + 2  
                        end if  
                    else  
                        store byte a at asDst:dst+pos 
                        pos = pos + 1  
                    end if  
                else  
                    if a = '\'  
                        if esc > 0  
                            store byte '\' at asDst:dst+pos 
                            pos = pos + 1  
                            esc = 0  
                        else  
                            esc = 1  
                            val = 0  
                        end if  
                    else  
                        if esc > 0  
                            esc = 0  
                            store byte val at asDst:dst+pos 
                            pos = pos + 1  
                        end if  
                        store byte a at asDst:dst+pos 
                        pos = pos + 1  
                    end if  
                end if  
            end repeat  
            if esc > 1  
              store byte val at asDst:dst+pos 
              pos = pos + 1  
            end if  
            len = pos  
        end virtual
    .with
}    

One extra function that I occasionally find missing (and perhaps inline macros could provide) is string manipulation for label names. For example: stripping a leading character is something I've never been able to do. Perhaps my knowledge is just lacking but it appears that it can't be done. We have the concatenate operator (#) but no equivalent extractor operator.

... would probably require some very cryptic syntax (even for fasm's standards).

macro log2(a) {
  local result=-1
  while a
    result=result+1
    a = a shr 1
  end while
  return result
}

and then use it like

 mov  eax,dword[index]
 shl  rax,log2(sizeof.MYSTRUCT) ; assume sizeof.MYSTRUCT is a power of 2
 add  rax,qword[ArrayOfStructs]    

@! shl edx,! @log2 (1000) !    

struc @imm8 [x]
{
        local c
        local y
 common
        c = 0
 forward
        c = c + 1
 common
        c = 8 / c
        y = 0
 forward
        y = (y shl c) or x
 common
        . equ y
}

@! pshuflw xmm4,xmm2,! @imm8 2,0,1,3 !    

Much more useful would be some extended variant of MATCH (MATCHX?) that would be able to cut through the tokens

define 2 3
define 1 2
define y 1
define x y

rept x n : x { display '0'+n,13,10 }

define 3 2define 4 3define 6 4define 5 6define y 4define x yrept x n : x { display '0'+n,13,10 }    

I'm sure, I've already came across this inconsistency when this topic appeared, but I failed to reproduce the problem afterwards.

(...) each value used in such expression must either be a directly specified number, or a symbolic constant with value also being an expression that can be calculated by preprocessor (...)

The output "3 6 4 7" makes me think that the redefinitions affect not only the way the initial value of n is calculated, but also the very incrementation process.

define 3 2
define 4 3
define 6 4
define 5 6
define y 4
define x y

rept x n : x { display `n,' evaluates to ','0'+n,13,10 }