V fix {

     macro some
     V          ; begins macro

V fix }         ; Even though we are defining macro now,
                ; the FIX has precedence over all other preprocessing,
                ; so V gets redefined now
                ; and this line doesn't become actually part of macro.

     V          ; ends macro    

I don't use fix often, but I see nothing wrong with breaking backwards-compatibility if the end result is cleaner than the original.

macro freeform [arg]
 { common
     DONE equ NO
     match src->dst, arg
     \{
        mov dst,src
        DONE equ YES
     \}
     match =NO dst<-src, DONE arg
     \{
        mov dst,src
        DONE equ YES
     \}
     match =NO, DONE
     \{
        unrecognized syntax
     \}
 }

freeform eax -> ebx     ; mov ebx,eax

freeform al <- [esi+1]  ; mov al,[esi+1]    

end_ifdef fix }
macro ifdef name { match =defined, name { }
macro ifndef name { match =name, name { }    

all@args equ arg    

match all,all@args \{ restore all \}    

macro try _name
{
 @name fix _name
}

macro close
{
 @name#_lab:
}

try Asd

close

try Zxc

close             

macro try _name
{
 @name equ _name
}

macro close
{
 match name,@name \{ name\#_lab: \}
 restore @name
}    

     \}
     match =NO, DONE
     \{
        unrecognized syntax
     \}
    

macro .if [arg]
{
  common
  __IF equ
  local ..endif
  __ENDIF equ ..endif
  local ..else
  __ELSE equ ..else
  JCOND __ELSE,arg
}

macro .else
{
  jmp __ENDIF
  __ELSE:
  restore __IF
  __IF equ ,
}

macro .elseif [arg]
{
  common
  jmp __ENDIF
  __ELSE:
  restore __ELSE
  local ..else
  __ELSE equ ..else
  JCOND __ELSE,arg
}

macro .endif
{
  if __IF eq
   __ELSE:
  end if
  __ENDIF:
  restore __ELSE
  restore __ENDIF
  restore __IF
}

macro .while [arg]
{
  common
  local ..while
  __WHILE equ ..while
  local ..endw
  __ENDW equ ..endw
  __WHILE:
  JCOND __ENDW,arg
}

macro .endw
{
  jmp __WHILE
  __ENDW:
  restore __ENDW
  restore __WHILE
}

macro .repeat
{
  local ..repeat
  __REPEAT equ ..repeat
  __REPEAT:
}

macro .until [arg]
{
  common
  JCOND __REPEAT,arg
  restore __REPEAT
}

macro JCOND label,[cond]
{
 common
 match =COND v1>==v2, COND cond
 \{
   cmp v1,v2
   jb label
   COND equ
 \}
 match =COND v1<==v2, COND cond
 \{
   cmp v1,v2
   ja label
   COND equ
 \}
 match =COND v1==v2, COND cond
 \{
   cmp v1,v2
   jne label
   COND equ
 \}
 match =COND v1<>v2, COND cond
 \{
   cmp v1,v2
   je label
   COND equ
 \}
 match =COND v1>v2, COND cond
 \{
   cmp v1,v2
   jbe label
   COND equ
 \}
 match =COND v1<v2, COND cond
 \{
   cmp v1,v2
   jae label
   COND equ
 \}
 match =COND v1=,c=,v2, COND cond
 \{
   cmp v1,v2
   jn\#c label
   COND equ
 \}
 match =COND v, COND cond
 \{
   cmp v,0
   je label
   COND equ
 \}
 restore COND
}

jnne equ je
jnna equ ja
jnnb equ jb
jnng equ jg
jnnl equ jl
jnnae equ jae
jnnbe equ jbe
jnnge equ jge
jnnle equ jle    

.if eax = 4

.elseif ebx > ecx

.elseif ecx, le, 2

.elseif edx

.else

.endif    

macro declare 
{ 
 @data fix
}

macro _data Name,Type,Value
{
 @data fix @data,Name,Type,Value
}

macro insert_data space,[Name,Type,Value]
{
 forward
  Name Type Value
}

macro close
{
 insert_data @data
}

declare

 _data  a , dd , 100
 _data  b , db , 200

close    

macro declare
{
 @data equ
}

macro _data Name,Type,Value
{
 @data equ @data,Name,Type,Value
}

macro insert_data space,[Name,Type,Value]
{
 forward
  Name Type Value
}

macro close
{
 match data,@data \{ insert_data data \}
}    

include 'win32ax.inc'

macro AddAPI param { match (name),param \{ macro name [params] \\{ \\common match (args),params \\\{ invoke name,args \\\} match =dd any,params \\\{ name dd any \\\} \\} \} }

.code

  start:

        AddAPI(MessageBox);
        AddAPI(ExitProcess);

        MessageBox(HWND_DESKTOP,"Hi! I'm the example program!","Win32 Assembly",MB_OK);

        ExitProcess(0);

.end start    

macro iglobal {
  IncludeIGlobals fix IncludeIGlobals,
  macro __IGlobalBlock {
}

macro uglobal {
  IncludeUGlobals fix IncludeUGlobals,
  macro __UGlobalBlock {
}

endg fix }      

macro __IncludeIGlobals dummy,[n]
{
  forward
   __IGlobalBlock
   purge __IGlobalBlock
}

macro __IncludeUGlobals dummy,[n]
{
  common
    local begin, size
    begin = $
    virtual at $
  forward
      __UGlobalBlock
      purge __UGlobalBlock
  common
      size = $ - begin
    end virtual
    rb size
}

macro IncludeAllGlobals {
  IncludeIGlobals
  IncludeUGlobals
}

IncludeIGlobals fix __IncludeIGlobals
IncludeUGlobals fix __IncludeUGlobals    

macro iglobal {
  IncludeIGlobals equ IncludeIGlobals,
  macro __IGlobalBlock {
}

macro uglobal {
  IncludeUGlobals equ IncludeUGlobals,
  macro __UGlobalBlock {
}

endg fix }

macro __IncludeIGlobals dummy,[n]
{
  forward
   __IGlobalBlock
   purge __IGlobalBlock
}

macro __IncludeUGlobals dummy,[n]
{
  common
    local begin, size
    begin = $
    virtual at $
  forward
      __UGlobalBlock
      purge __UGlobalBlock
  common
      size = $ - begin
    end virtual
    rb size
}

macro IncludeAllGlobals {
 match I:U, IncludeIGlobals:IncludeUGlobals
 \{
    I
    U
 \}
}

IncludeIGlobals equ __IncludeIGlobals
IncludeUGlobals equ __IncludeUGlobals