label alpha byte
times 3 db 'abcd',0
db ?
times 7 db '-'    

alpha db 3 dup ('abcd',0), ?, 7 dup '-'    

Hi Privalov
What do you think about Nickolay's idea of putting assembly file's name to the taskbar?

And BTW what does the 'dup' acronym mean?
www.acronymfinder.com gave me "Data User Part" but that is only somewhat logical

I use a primary fasm compiler for my prog and I have more problem with:
proc bla, var1:byte,var2:float,var3:dword,...

macro proc name,[arg]
 { common
    if used name
    name:
    virtual at ebp+8
    if ~ arg eq
   forward
     label arg
     dd ?
   common
     end if
     ..ret = $ - (ebp+8)
    end virtual
    local ..data,..size
    if defined ..size
     virtual at ebp - ..size
    else
     if ..ret
      push ebp
      mov ebp,esp
     end if
    end if
    ..data:
    macro enter size,level
     \{ if size eq & level eq
         rb (4 - ($-..data) and 11b) and 11b
         if defined ..size
          ..size = $ - ..data
          end virtual
         else
          ..size = $ - ..data
         end if
         if ..ret | defined ..size
          push ebp
          mov ebp,esp
          if ..size
           sub esp,..size
          end if
         end if
        else
         enter size,level
        end if \}
    macro return
     \{ if ..ret | defined ..size
          leave
        end if
        if ..ret
         retn ..ret
        else
         retn
        end if \} }

macro endp
 { purge return
   purge enter
   end if }    

proc foo, arg1:byte, arg2:dword
        mov     al,[arg1]
        mov     ebx,[arg2]
        return
endp    

Version 1.61.9 brings a small suprise: I have implemented the DUP operator - one more thing to make conversion from TASM/MASM easier (and also in some cases DUP is much more handy than NASM-style TIMES):

Of course, there shouldn't be any problems. Macros and symbolic constants can override any keyword.

match +,+
{
 ; this will be preprocessed
}

match +,-
{
 ; there's no match, this won't be preprocessed
}    

match alpha, 1+1 { } ; match
match =alpha, 1+1 { } ; mismatch
match =alpha, alpha { } ; match    

match alpha+beta*gamma,1+2*3
 { db alpha,beta,gamma } ; becomes db 1,2,3    

match any,
 { } ; mismatch    

match any other, 1+2*3
 {
   db any   ; db 1
   db other ; db +2*3
 }    

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

freeform eax -> ebx     ; mov ebx,eax

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

Code:

match any other, 1+2*3 
 { 
   db any   ; db 1 
   db other ; db +2*3 
 }    

macro if_def name { match =defined,name \{ }

macro if_ndef name { match ~ =defined,name \{ }
    

check for the comma in the pattern by preceding comma with =,

macro .if [val] {
  common
    local __endif
    match a == b,val \{
      cmp a,b
      jne __endif
    \}
    macro .endif \{
      __endif:
    \}
}    

.if eax = 834
; code goes here
.endif    

match replaced, arg { some_macro replaced }    

macro .if [val] {
  common
    local __endif
    match  a ==== b,val \{
      cmp a,b
      jne __endif
    \}
    match a !== b,val \{
       cmp a,b
      je  __endif
    \}
    macro .endif \{
      __endif:
    \}
}



        mov     eax,1

        .if eax == 1
                nop
        .endif