;
section '.NaVM' code executable readable
 virtual at $$
  sym:: ; define a module's parent
 end virtual
;
 virtual sym ; tell which module
; here, without sym. before .test, fasm barks below
  macro sym.test arg { align arg } ; whatever you want in body
 end virtual
;
; now, without sym. in the above macro name, fasm barks error: illegal instruction
 sym.test 2
;
    

struc GDTR offset, length { local .temp
 . dp .temp and 0x00FFFFFF
 virtual at .
  .length dw length - 1
  .offset dd offset, 0
  load .temp qword from .
 end virtual }

newGDTR GDTR GDT, GDT_end - GDT
GDT: ... ; descriptors
GDT_end:

mov cx, [newGDTR.length]
mov esi, [newGDTT.offset]
lgdt [newGDTR]    

 ; main.asm
define ALLMYMACRO used
define MYMACRO0 unused
define MYMACRO1 used
match =used ALLMYMACRO { include "allmymacro.inc" }    

; allmymacro.inc
match =used,MYMACRO0 { include "mymacro0.inc" } ; excluded
match =used,MYMACRO1 { include "mymacro1.inc" } ; included    

 ; mymacro0.inc
macro mymacro0 ...    

 ; mymacro1.inc
macro mymacro1 ...    

 ; allmymacro.inc
match =used,MYMACRO0 { macro mymacro0 ... }
macth =used,MYMACRO1 { macro mymacro1 ... }    

unused macros will be excluded.

What I wrote above: 1. declare a module in some wanted (arbitrary) environment; 2. append (arbitrary) things to the module if wanted/needed, maybe .inc files or your own addition. 3. use from the named module what you want.

format binary

Test1:

macro .Point X*, Y*, Z* { dq X, Y, Z }
macro Test1.Point X, Y { dd X, Y }

Test1.Point 0, 0
.Point 1, 2, 3
;flat assembler  version 1.73.29  (16384 kilobytes memory)
;1 passes, 0.3 seconds, 32 bytes.    

virtual at 0
 db 1
 macro foo {
  db 2
  end virtual
}
end virtual

virtual at 0
foo    

macro foo is defined in pass 1 and has no effect on the first virtual block in pass 2.

But the macro name appears to have its own rules (other than rules for labels).

If the below can be made more fasm-like I'd love to see suggestions for modular organization.

Code:

;
section '.NaVM' code executable readable
 virtual at $$
  sym:: ; define a module's parent
 end virtual
;
 virtual sym ; tell which module
; here, without sym. before .test, fasm barks below
  macro sym.test arg { align arg } ; whatever you want in body
 end virtual
;
; now, without sym. in the above macro name, fasm barks error: illegal instruction
 sym.test 2
;
    

section '.NaVM' code executable readable

 sym: ; define a module's parent

 namespace sym ; tell which module to enter
   macro test arg
     align arg
   end macro
 end namespace

 sym.test 2    

macro module name { define __MODULE__ name }
macro mmacro decl& { local d
                     define d decl
                     match module, __MODULE__ \{ match name rest, d \\{
                                                 macro name args& \\\{ module\#.\\#name args \\\}
                                                 macro module\#.\\#name rest \\} \} }


module sym

   mmacro test arg { align arg }

sym.test 2    

revolution wrote:

macro foo is defined in pass 1 and has no effect on the first virtual block in pass 2.

And he also wants the names of macros to be connected with special labels defining different address spaces ( sym:: ).

Try (in my example) without the sym. in the virtual sym thing. So the talk can be about that thing

This is related to the two passes.

namespaces are supposed to solve