struc affaf [x] { x dd 0 }
struct frettt
       life affaf x,y,z
ends
jumpii frettt  

;in code error
mov [jumpii.life.x],1 ;undefined jumpii.life.x
mov [jumpii.life.y],2
mov [jumpii.life.z],3
    

struc affaf [x] { .x dd 0 }
struct frettt
       life affaf x,y,z ;fasm error alredy defined frettt.life.x
ends
jumpii frettt 
    

struc affaf x { irp r,x \{
;display r
r dd 0
\} }
struct frettt
       life affaf <.x,.y,.z>
ends
jumpii frettt  

mov [jumpii.life.x],1 ;undefined jumpii.life.x
mov [jumpii.life.y],2 ;undefined jumpii.life.y
    

struc affaf pp { irp r,pp \{
;display pp
r dd 0
\} }
struc frettt   {
         .x affaf <.life.x,.life.y,.life.z>
}
jumpii frettt  

;in code
mov [jumpii.life.x],1  
mov [jumpii.life.y],2
mov [jumpii.life.z],3

mov [jumpii.x],3 ;= mov [jumpii.life.x],3
    

macro zero@Struct ss { local up
                       mov eax,ss#.bgn
                  up:  if ss#.Type = 1
                       mov dword [eax],0
                       add eax,4
                       end if
                       if ss#.Type = 0                 ;byte
                       mov byte [eax],0
                       inc eax
                       end if
                       if ss#.Type = 2
                       mov dword [eax],1.0
                       add eax,4
                       end if
                       cmp eax,ss#.end
                       jnz up
}

macro cs@. v,n { if v#.Type = 1
               mov dword [v],n
               end if
               if v#.Type = 0
               mov byte [v],n
               end if
               if v#.Type = 2
               mov dword [v],n#f
               end if
}
struc csafint pp { irp r,pp \{
;display pp
r dd 0
r\#\.Type equ 1
\} }

struc csafbyte pp { irp r,pp \{
r db 0
r\#\.Type equ 0
\} }

struc csaflt pp { irp r,pp \{
;display pp
r dd 0
r\#\.Type equ 2
\} }
macro mmm@cs4  v,e {
         v#.bgn csaflt <v#.x,v#.y,v#.z,v#.w>
         v#.end:
         v#.Type equ e
}
struc complexStructF   {
         .life.bgn csafint <.life.x,.life.y>
         .life.end:
         .life.Type equ 1  ;int
         .pos.bgn csaflt <.pos.x,.pos.y,.pos.z>
         .pos.end:
         .pos.Type equ 2  ;float
         mmm@cs4 .quat,2
}
jumpii complexStructF

        mov eax,jumpii.life.x.Type
        mov eax,jumpii.pos.x.Type
        cs@. jumpii.life.x , 2
        cs@. jumpii.pos.z , 2
        

        zero@Struct  jumpii.life
        zero@Struct  jumpii.pos
    

struc A [x] { .#\.#x dd 0 }
struc B { .life A x,y,z }
C B
mov dword [C.life.x], eax
mov [C.life.y], eax
mov [C.life.z], eax
    

struc cssA [x] { .#\.#x dd 0
.#\.#x#\.Type equ 2
}
struc cssB { 
      .life.bgn:
      .life cssA x,y,z,w,d,g
      .life.end:
      .life.Type equ 2
      }
;in code
new cssB
    

macro m@cs obj {  ;display  obj
match a,obj \{  a 
\}
}  
macro mInc {inc dword [eax] }
struc cssB { 
      .life.bgn:
      .life cssA x,y,z,w,d,g
      .life.end:
      .life.Type equ 2
      .life.macro equ mInc
      }

;in code i do
jj cssB
m@cs jj.life.macro ;i want get inc dword [eax]. but get fasm error
    

struc cssA [x] { .#\.#x dd 0
 .#\.#x#\.#Type equ 2
;^  ^ ^  ^ ^- Type
;|  | |  +- \. = '.'
;|  | +- 'x' or 'y' or 'z' or 'w' or 'd' or 'g'
;|  +- \. = '.'
;+- jj.life
; jj.life.x.Type
}
macro m@cs obj {  ;display  obj
match a,obj \{  a 
\}
}  
macro mInc {inc dword [eax] }
struc cssB { 
      .life.bgn:
      .life cssA x,y,z,w,d,g
      .life.end:
      .life.Type equ 2
      .life.macro equ mInc
      }

;in code i do
jj cssB
m@cs jj.life.macro    

Code:

$ fasm fasm_RomanStrucFields.asm
flat assembler  version 1.73.34  (16384 kilobytes memory, x64)
1 passes, 28 bytes.

$ hexdump -C fasm_RomanStrucFields.bin
00000000  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000010  00 00 00 00 00 00 00 00  67 66 ff 00              |........gf..|    

inc dword [eax] ; 67 66 ff 00    

Code:

$ cat fasm_RomanStrucFields.asm
struc cssA [x] { .#\.#x dd 0
.#\.#x#\.#Type equ 3
}
macro m@cs obj {  ;display  obj
match a,obj \{  a 
\}
}  
macro mInc {inc dword [eax] }
struc cssB { 
      .life.bgn:
      .life cssA x,y,z,w,d,g
      .life.end:
      .life.Type equ 1
      .life.macro equ mInc
      }

;in code i do
jj cssB
m@cs jj.life.macro ;i want get inc dword [eax]. but get fasm error
display 'jj.life.Type = ', '0' + jj.life.Type, 0xa
display 'jj.life.x.Type = ', '0' + jj.life.x.Type, 0xa
$ fasm fasm_RomanStrucFields.asm
flat assembler  version 1.73.34  (16384 kilobytes memory, x64)
jj.life.Type = 1
jj.life.x.Type = 3
1 passes, 28 bytes.
$ hexdump -C fasm_RomanStrucFields.bin
00000000  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000010  00 00 00 00 00 00 00 00  67 66 ff 00              |........gf..|