Hi. Any update / progress there ?

match name/. tail, source, /    

match name:. tail, source, :    

fossil open https://flatassembler.net/fossil/repo/fasmg
fossil checkout calm4    

match label:name tail, line, :    

iterate modifier, \
    \ ; equ matches stuff with symbolic value (the symbolic value can be empty)
    equ, \
    expression, \
    macro, \
    \ ; a valid name. does not have to have been defined or anything.
    name, \
    \ ; a "raw" number token [0-9]+
    number, \
    priorequ, \
    priormacro, \
    priorstruc, \
    \ ; "raw" quoted string token
    quoted, \
    struc

    calminstruction match_#modifier? arg
            local arg_str, tmp
            arrange arg_str, arg
            stringify arg_str
            match tmp:modifier, arg, :
            jyes yes
        ; no:
            display arg_str bappend ' <> ' bappend `modifier bappend 13 bappend 10
            exit
        yes:
            display arg_str bappend ' =  ' bappend `modifier bappend 13 bappend 10
    end calminstruction
end iterate

calminstruction test arg
    call match_equ, arg
    call match_expression, arg
    call match_macro, arg
    call match_name, arg
    call match_number, arg
    call match_priorequ, arg
    call match_priormacro, arg
    call match_priorstruc, arg
    call match_quoted, arg
    call match_struc, arg
end calminstruction

define a 5
b := 5
define c
element d
define e 5b
define f
define g "test"
define h a
define i h

iterate case,  a,b,5,c,d,e,f,hello,g,'test',h,i,&
    test case
    display 13, 10
end iterate    

calm4 fasm_macro_tests/calm4/test.asm 
flat assembler  version g.kt77
a =  equ
a =  expression
a =  macro
a =  name
a <> number
a =  priorequ
a =  priormacro
a =  priorstruc
a <> quoted
a =  struc

b <> equ
b =  expression
b =  macro
b =  name
b <> number
b <> priorequ
b =  priormacro
b =  priorstruc
b <> quoted
b =  struc

5 <> equ
5 =  expression
5 <> macro
5 <> name
5 =  number
5 <> priorequ
5 <> priormacro
5 <> priorstruc
5 <> quoted
5 <> struc

c =  equ
c <> expression
c =  macro
c =  name
c <> number
c =  priorequ
c =  priormacro
c =  priorstruc
c <> quoted
c =  struc

d <> equ
d =  expression
d =  macro
d =  name
d <> number
d <> priorequ
d =  priormacro
d =  priorstruc
d <> quoted
d =  struc

e =  equ
e =  expression
e =  macro
e =  name
e <> number
e =  priorequ
e =  priormacro
e =  priorstruc
e <> quoted
e =  struc

f =  equ
f <> expression
f =  macro
f =  name
f <> number
f =  priorequ
f =  priormacro
f =  priorstruc
f <> quoted
f =  struc

hello <> equ
hello =  expression
hello <> macro
hello =  name
hello <> number
hello <> priorequ
hello <> priormacro
hello <> priorstruc
hello <> quoted
hello <> struc

g =  equ
g =  expression
g =  macro
g =  name
g <> number
g =  priorequ
g =  priormacro
g =  priorstruc
g <> quoted
g =  struc

'test' <> equ
'test' =  expression
'test' <> macro
'test' <> name
'test' <> number
'test' <> priorequ
'test' <> priormacro
'test' <> priorstruc
'test' =  quoted
'test' <> struc

h =  equ
h =  expression
h =  macro
h =  name
h <> number
h =  priorequ
h =  priormacro
h =  priorstruc
h <> quoted
h =  struc

i =  equ
i =  expression
i =  macro
i =  name
i <> number
i =  priorequ
i =  priormacro
i =  priorstruc
i <> quoted
i =  struc

& <> equ
& <> expression
& <> macro
& <> name
& <> number
& <> priorequ
& <> priormacro
& <> priorstruc
& <> quoted
& <> struc


1 pass, 0 bytes.    

hello =  expression    

This line puzzles me. Is it correct? And I don't understand what struc and macro should match, known macros and known strucs?

dosmancer wrote:

This line puzzles me. Is it correct? And I don't understand what struc and macro should match, known macros and known strucs?

I'm soon going to commit the updates to the manual, they should answer your questions. Also, "macro"/"struc" modifiers are currently buggy, the fix is in the works.

The "expression" modifier makes the wildcard match a complete computable expression. It ensures that the expression is correctly structured, but does not attempt computing it. An additional "defined" check may determine if it also contains no undefined values

calminstruction push? args&
        local   op, size
        arrange size,
    loop:
        match   op.expression args?, args, .
        jno     other
        match   size.name, op, .
        jno     plain
        transform size, x86
        jno     plain
        match   :size, size
        jno     plain
        match   op.expression args?, args, .
        jno     other
    plain:
        arrange op, =push size op
        assemble op
        match   , args
        jno     loop
        exit
    other:
        match   [op], args
        jyes    memory
        stringify args
        err     args bappend ' is not a valid operand' bappend 0A0Dh
        exit
    memory:
        arrange op, =push size [op]
        match   , args
        jno     loop
end calminstruction    

; Assembles just like fasm 1:
; (not that this is a good idea, it's a horrible syntax)
push 1 2        ; two pushes,
push 1 +2       ; a single push.    

if_true equ if 1
if_false equ if 0

calminstruction ifdef? sym*
        match   sym.name, sym, .
        jno     error
        match   sym.equ, sym, .
        jyes    true
        check   defined sym
        jno     false
    true:
        assemble if_true
        exit
    error:
        err     'not a name'
    false:
        assemble if_false
end calminstruction

calminstruction ifdefprior? sym*
        match   sym.name, sym, .
        jno     error
        match   sym.priorequ, sym, .
        jyes    true
        match   sym.equ, sym, .
        jyes    false
        check   definite sym
        jno     false
    true:
        assemble if_true
        exit
    error:
        err     'not a name'
    false:
        assemble if_false
end calminstruction

ifdef a
        display 'Yes'
else
        display 'No'
end if

ifdefprior a
        display 'Yes'
else
        display 'No'
end if

a equ 8    

        calminstruction (output) compute? text
                match   text/expression, text, /
                jyes    inspect
                err     'malformed expression'
                exit
            inspect:
                check   defined text
                jyes    evaluate
                err     'expression with unknown quantities'
            evaluate:
                compute output, text
        end calminstruction
    

1/ are special characters '=' and '?' allowed as modifier special symbol ?
-> doesn't that mix up the recognition of litteral token / case insensitivity ?

calminstruction test arg
        match any=name, arg, =
        stringify any
        display any
end calminstruction    

... i wonder if the last line (compute output, text), shouldn't rather be sthg like
compute text, text
publish output, text
... to make it more useful ?

3/ another picky one...
... the updated doc reads
'(...) it instead chooses the symbol that may be used to modify wildcards (...)'
... i find sthg like the below sounds clearer / neater (... u judge ofc)
'(...) it instead chooses a symbol that may be used to modify the interpretation of wildcards (...)'

4/ how far do u think is the fix for macro"/"struc" modifiers ?

calminstruction test2
        local tmp
        arrange tmp, =d6.=w
        match tmp:name, tmp, :
        jyes yes
    ; no:
        display 'no' bappend 13 bappend 10
        exit
    yes:
        display 'yes' bappend 13 bappend 10
end calminstruction

test2    

The "name" modifier makes the wildcard match a complete symbol identifier:    

Usually in the manual "name" means a sequence of tokens not broken by special characters, if I recall correctly, so maybe `identifier` would be a better name for the modifier?

The manual uses "name" loosely in many different meanings, but is precise when using the "name token" phrase, which refers to a single alphanumeric-like token that is not a number and is most likely what you had in mind here.