calminstruction calminstruction?.nested?
    

calminstruction calminstruction?._poc_1?
    arrange     invoke, =calminstruction =calminstruction?.=_poc_2?
    assemble    invoke
    arrange     invoke, =end =calminstruction
    assemble    invoke
    ; and you call it as-well
    ;arrange     invoke, =_poc_2
    ;assemble    invoke
end calminstruction
    

  _macro reequ   macro
_display reequ display
    _end reequ     end
match macro display end, _macro _display _end
    namespace calminstruction?
        macro #display line?&
            display line
        end macro
    end namespace
end match
    

because the instruction calminstruction is not defined inside the namespace calminstruction?.

It may end up calling some macro, if you have "calminstruction.display" defined, but after all such macros get unrolled, the assembler needs to have only compilable CALM statements. Just like when a macro is defined, normal directives are not recognized and processed at that time.

calminstruction calminstruction?._exec_once? command?*&
    ; ...
end calminstruction
holder = $00
calminstruction poc_1?
    _exec_once { compute holder, $01 }
end calminstruction
display holder+"0", $0A ; display 1 without execution poc_1
    

debug? := $01
macro calminstruction?._asmcmd? invoke?*, command?*&
    local       invoke
    arrange     invoke, command
    assemble    invoke
end macro
retaincomments
calminstruction poc_1?
    _exec_once {\
            check (debug)                                                   ;\
            jyes   next                                                     ;\
            exit                                                            ;\
        next:                                                               ;\
            _amcmd invoke, =_asmcmd =invoke, ===display "DEBUG ON", $0A     ;\
    }
end calminstruction
removecomments
poc_1
    

Yes I agree. But what I want is not to declare calm inside another declaration. In fact, I wanted to create nested calm instruction on the fly, for executing code at "assembly time". So the calm that defined such nested calm is already defined. (...)

define _global

calminstruction calminstruction?._exec_once? command?*&
        take _global._exec_once, command
end calminstruction

calminstruction calminstruction.end? instruction
        local command, buffer
        arrange command, =end instruction
        assemble command
        arrange command, =calminstruction =__tmp
        assemble command
    reverse:
        take buffer, _global._exec_once
        jyes reverse
    exec:
        take command, buffer
        jno done
        assemble command
        jump exec
    done:
        arrange command, =end =calminstruction
        assemble command
        arrange command, =__tmp
        assemble command
end calminstruction



holder = $00
calminstruction poc_1?
  _exec_once  compute holder, $01
end calminstruction


display holder+"0", $0A ; display 1 without execution poc_1    

calminstruction abc?
    arrange     A, =I, =J, =K
    compute     B, $02
    publish     A, B
end calminstruction
    

But I've not seen this in the man. Do you think that I can reliably use this feature?

debug = $00
calminstruction calminstruction?._initsym? target?*, value?&
    publish     target, value
end calminstruction

calminstruction calminstruction?._incdebg?
    compute      debug, debug + $01
end calminstruction

calminstruction calminstruction?._ensure?
    local       target, holder, A
    _initsym    _A, A
    arrange     A, =INT3
    arrange     holder, =_execonce =arrange _A, ===compute ===variable, $01
    assemble    holder
    assemble    A
end calminstruction

calminstruction poc?
    _incdebg
    _initsym    random, $00
    _ensure
end calminstruction
    

calminstruction calminstruction? prefix?*, arguments?&
    ; ...
    ; create calminstruction ?! line?&
    ; if end calminstruction encounter
    ; create calminstruction prefix with all line collected
    ; purge of ?
    ; exit
    ; calminstruction sandbox?
    ;   line
    ; end calminstruction
    ; purge of sandbox?
end calminstruction
    

calminstruction calminstruction?._execonce? command?*&
    _asmcmd invoke, =end =calminstruction
    _asmcmd invoke, =calminstruction =calminstruction?.=__tmp?
    _asmcmd invoke, command
    _asmcmd invoke, =end =calminstruction
    _asmcmd invoke, =calminstruction ; current calminstruction name
    _asmcmd invoke, =__tmp
end calminstruction
    

calminstruction calminstruction?._poc_1?
    local A
    init build, _execonce arrange A, =compute =B, $01
    init A, ERROR
    assemble build
    assemble A ; Here ERROR (but I want to "compute" to be executed)
end calminstruction
calminstruction _poc_2?
    _poc_1
end calminstruction
    

arrange     holder, =_execonce =arrange _A, ===compute ===variable, $01    

calminstruction test?
    _xcalm_init ~ [symbl] A, B ; declare a symbol A that point to B (like init in calm package)
    _xcalm_init ~ [symbl] B, C
    _xcalm_init ~ [symbl] C, D
    ; so now we are a chain like this A -> B -> C -> D
    ; I want to transform A so that A -> D (so 2 time transform)
    _xcalm_exec ~ [rpeat:2] { transform A }
    ; This is why I need execonce because I don't want generate code here
    _xcalm_init ~ [symbl|const] E, [expnd] A ; E = D ([expnd] expand behave like arrange does)
end calminstruction
    

calminstruction calminstruction?.duptop_5? target?*
    arrange     duplicate, target
    transform   duplicate
    _xcalm_exec { _xcalm_exec ~ [rpeat:5] { publish :target, duplicate } }
    ; exec without ~ is the normal exec that generate an "assemble" statement
end calminstruction
    

debug_v1 = $00
debug_v2 = $01
retaincomments
calminstruction abc?
    local buffer
    _exec_xcalm ~ {\
            check   (debug_v1)  ;\
            jyes    next_1      ;\
            exit                ;\
        next_1:                 ;\
            _exec_xcalm { display "DEBUG V1 ON } ;\
    }
    arrange     buffer, =display "MIDDLE"
    assemble    buffer
    _exec_xcalm ~ {\
            check   (debug_v2)  ;\
            jyes    next_2      ;\
            exit                ;\
        next_2:                 ;\
            _exec_xcalm { display "DEBUG V2 ON } ;\
    }
    arrange     buffer, =display "END"
    assemble    buffer
end calminstruction
removecomments