struc Foo params&
{
  ; All stuff goes here
  ...
}

macro Foo params&
{
  local ..a
  ..a Foo params
}    

Special “smacto”

A::B 5,4

Code:

struc Foo params&
{
  ; All stuff goes here
  ...
}

macro Foo params&
{
  local ..a
  ..a Foo params
}    

; Once for any other structure
macro That struct*, params& { local ..a
  ..a struct params }

struc Foo params&
{
  ; All stuff goes here
  ...
}

struc Foo1 par*, arg&
{
  ; All stuff goes here
  ...
}

struc Foo2
{
  ; All stuff goes here
  ...
}

That Foo    arg0, arg1, arg2, "str"
That Foo    arg3, arg1, arg4, "new"
That Foo1   arg5, arg6
That Foo2    

 times 5 That Foo arg0, $, arg1+%     

macomics
And how using this?
And how run Function in struct?

And what mean All stuff goes here?
Please give more concrete info.

The idea is that I sometimes want to have a more readable and flexible way for defining complex data but I definitely don’t want to repeat myself twice, so the “fake” label is a way to go. While the macro is pretty small, it still is boilerplate and gets quite annoying soon.

That Foo arg1
; macro That struct*="Foo arg1", params&="" {
; local ..label
; ..label Foo arg1, }
; struc Foo params&="arg1," { . db arg1, } ;<- incorrect
; struc Foo params&="arg1," { label .
; match any, arg1, \{ db arg1 \} } ; <- correct

; OR

That Foo, arg1
; macro That struct*="Foo", params&="arg1" {
; local ..label
; ..label Foo arg1 }
; struc Foo params&="arg1" { . db arg1 } ;<- correct
; struc Foo params&="arg1" { label .
; match any, arg1 \{ db arg1 \} } ; <- correct

; OR

macro That struct*, params& { local ..label
  match any, params \{ common ..label struct, params \}
  match , params \{ ..label struct \} }    

 struc STRA txt& { . db .Length, txt
  .Length = $ - . - 1
  db 0
  .Bytes = $ - . }

TextBlock STRA "Text text text", 13, 10
That STRA "More text, second string", 13, 10
That STRA "One more string", 13, 10, 0

; TextBlock db 16, "Text text text", 13, 10, 0, 26, "More text, second string", 13, 10, 0, 17, "One more string", 13, 10, 0, 0     

Where did you see function calls in the examples?

And I don't understand yet why we need use macro that(for struct) in your example ?

I often find myself writing something like

Code:

struc Foo params&
{
  ; All stuff goes here
  ...
}

macro Foo params&
{
  local ..a
  ..a Foo params
}        

I propose put functions in struct. Do struct more like a class.
We talk about smacto.

For example struc have pointer procs tab and pointer to texts and data and state flags.

Run first proc from this struc and get New thread.
Thread run automaticly all next procs this struc.

.code
macro smacto arg&
        {
        struc arg
        macro arg
        }
smacto FUN { db 5 }

FUN
forr FUN    

Code:

.code
macro smacto arg&
        {
        struc arg
        macro arg
        }
smacto FUN { db 5 }

FUN
forr FUN    

I was about to say that you can define macros within macros, so DimonSoft doesn't need a FASM "smacto" keyword, he can define one himself.