MacroName#declared    

macro red_macro [param] {
   ... here I have to take the name of some used macro form first position in Param
   ... but there is not comma in use after the name, I trying to:
   c=0
   nextParam=
   irps arg , <Param> \{
      c=c+1
      if c=1
         MacroName=_name
         arg#defined=TRUE
      else
         nextParam=`nextParam+','+arg
      end if
   \} 
   macro MacroName [nextParam] \{
      ... this is my macros can I declare the body just right here or not?
   \}
}
macro fix red_macro
...
purge macro
    

macro proc [args]
 { common
    match name params, args>
    \{ define@proc name,<params \} }
    

How this works in includes?

Code:

macro proc [args]
 { common
    match name params, args>
    \{ define@proc name,<params \} }
    

Can you explain this code please?

macro macro2 [param] {
   macro param \{ ??? \}
}
macro fix macro2

macro Ret {
   ret 0      ;How to move this body to redesigned (fake)macro2 directive?
}
    

macro a {nop} ; okay
macro b {int3} ; okay
macro a {hlt} ; does nothing because 'a' is already declared above    

 
macro a {if used nop  else ret end if}
a    ;translated as ret
a    ;translated as nop    

macro macro2 [param] {
        ;get name as first in Param
        ;stick it with some key as name@defined
        if defined name@defined
           purge name
           nop
        else 
           define name@defined
           <<<Is any chance to declare the 'macro a' here as it is?>>>
        end if
         }
macro fix macro2

macro a {ret}

a    ; ret
a    ; nop

    

macro a {
        nop
}
macro a {
        ret
        purge a ;purges nop above
}
a       ;ret
a       ;ret
purge a ;purges ret
a       ;error    

; Magic macro setup

macro define_macro Params&
{
  match name rest , Params
  \{
    macro_list equ name
    macro_defined@ \# name equ 1
    rept 0 \\{
  \}
  match name , Params
  \{
    macro_list equ name
    macro_defined@ \# name equ 1
  \}
  macro Params
}

macro fix define_macro



; Put any other macro definitions here
; NOTE! The { character should be on a separate line!

macro test1
{ db 42 }

macro test2
{ db 44 }

; Macros may be invoked as usual

test2
test1



; Get the list of macros defined at this point

display 'List of defined macros:', 13, 10
irpv item , macro_list
{
  display `item, 13, 10
}

; Check if particular macro has been defined

match =1 , macro_defined@test1 { display '`test1` macro has been defined.', 13, 10 }
match =1 , macro_defined@test2 { display '`test2` macro has been defined.', 13, 10 }    

macro some
{
  .data once
    <<adds global data once>>
  .data ifexist
    <<adds additional global data if macro was used before>>

... same way for all directives

  .code
    call some_proc
    local ..next
    jmp ..next
  .code once
    proc some_proc
      .data once
      .code once
      .data once
      .code once
    endp
  .idata once
  .code
    ..next:
  .code ifexist
    ...
}
    

This is exactly what I need. Did you try match ={, in your case? Did you try as Tomasz said? Did you try fix it?

I need to check if macros used for my updated .multisection trick. Now it works in proc and macros just fine but I want to add much extended support for macros as:

Code:

macro some
{
  .data once
    <<adds global data once>>
  .data ifexist
    <<adds additional global data if macro was used before>>

... same way for all directives

  .code
    call some_proc
    local ..next
    jmp ..next
  .code once
    proc some_proc
      .data once
      .code once
      .data once
      .code once
    endp
  .idata once
  .code
    ..next:
  .code ifexist
    ...
}
    

code
{
  ...
}

data
{
  ...
}

...    

.data FIX } macro _data { _data
.code FIX } macro _code { _code
.end FIX } _data

macro _data { _code }   ; put all code pieces before the data
macro _code {           ; start with _code macro open

; example follows (here a simple 16-bit DOS program):

        org     100h

.data
        hello   db 'Hello!',13,10,36

.code
    show:
        mov     ah,9
        mov     dx,hello
        int     21h

.data
        counter db 3

.code
        dec     [counter]
        jnz     show
        int     20h
.end    

With FIX directive you can easily hide the braces.

Tomasz Grysztar wrote:

With FIX directive you can easily hide the braces.

Yeah, but that suffers from the problem of instructions that use the braces {}, they need to be escaped.

macro define_macro Args&
{
  Params equ Args
  match name rest , Params
  \{
    macro_list equ name
    macro_defined@ \# name equ 1
    rept 0 \\{
  \}
  match name , Params
  \{
    macro_list equ name
    macro_defined@ \# name equ 1
  \}
  macro Args
}

macro fix define_macro