macro float [a,b]
{
        forward
        a dq b
}    

float length,23.11,width,0.221
float result,0.0    

float length=23.11,width=0.221    

macro float [arg] {
 forward
 match a==b,arg \{
  a dq b
 \}
}    

I expect that using match can give you that functionality:

Code:

macro float [arg] {
 forward
 match a==b,arg \{
  a dq b
 \}
}    

macro verify e {
 if ?s eq 0
  display `e
  'Error: ' e
 end if
}

; define variable of type, name, value

macro !DV type, name, value {
 local l
 l=$
 name type value ; example: msg db 'Hello'
 name#.$=$-l     ; size
}

; define b/w/d/q/t variable

macro !D1 a, b { !DV db, a, b }
macro !D2 a, b { !DV dw, a, b }
macro !D4 a, b { !DV dd, a, b }
macro !D8 a, b { !DV dq, a, b }
macro !DF a, b { !DV dt, a, b }

;;;;;;;;;;;;;; DEFINE HL VARIABLE ;;;;;;;;;;;;;;;;

; define X. syntax: type then any a/a=b
; sequence/s separated with ,s. example:
; NUMBER x, y, w=320, h=240
; variables=0 if there is no initial value

macro !D type, [p] {
 common
  if p eq
   'Name expected'
  end if
 forward
  define ?s 0
  match =0 a==b, ?s p \{ ; a=b
   type a, b
   define ?s 1
  \}
  match =0 a=,, ?s p \{  ; a, (next)
   type a, 0
   define ?s 1
  \}
  match =0 a, ?s p \{    ; a (end)
   type a, 0
   define ?s 1
  \}
  verify variable
}

; HL variable names

macro char [a]   { !D !D1, a }
macro short [a]  { !D !D2, a }
macro int [a]    { !D !D4, a }
macro float [a]  { !D !D4, a }
macro double [a] { !D !D8, a }    

; verify size of block/text/array

macro verify.size n {
 if n eq
  'Size must be specified'
 else if ~ n eqtype 0
  'Size must be numeric'
 else if n eq 0
  'Size cannot be zero'
 end if
}

; define byte array. BLOCK b(size)

macro BLOCK [p] {
 forward
  define ?s 0
  match =0 (size), ?s p \{
   verify.size size
   db size dup(0)
   define ?s 1 
  \}
  match =0 name(size), ?s p \{
   verify.size size
   !DV db, name, size dup(0)
   define ?s 1
  \}
  verify BLOCK
}

; create HL 'text' variable/s. TEXT t='X'.
; note: (n) is the size
 
macro TEXT [p] {
 forward
  local l
  define ?s 0
  ; TEXT t(n)='abc'
  match =0 name(size)==text, ?s p \{
   l=$
   verify.size size
   !DV db, name, <text,0>
   times (size-($-l)) db 0
   define ?s 1
  \}
  ; TEXT t(n)
  match =0 name(size), ?s p \{
   verify.size size
   !DV db, name, size dup(0)
   name\#.$=size
   define ?s 1
  \}
  ; TEXT t='abc'
  match =0 name==text, ?s p \{
   !DV db, name, <text,0> ; name db 't', 0
   define ?s 1
  \}
  ; TEXT t
  match =0 name, ?s p \{
   'Size must be specified:' name
   define ?s 1
  \}
  verify TEXT
}    

I've provided endless macros like this for X86+ARM. Example: This supports standard C declarations: char, short, int, float, double:

Code:

macro verify e {
 if ?s eq 0
  display `e
  'Error: ' e
 end if
}

; define variable of type, name, value

macro !DV type, name, value {
 local l
 l=$
 name type value ; example: msg db 'Hello'
 name#.$=$-l     ; size
}

; define b/w/d/q/t variable

macro !D1 a, b { !DV db, a, b }
macro !D2 a, b { !DV dw, a, b }
macro !D4 a, b { !DV dd, a, b }
macro !D8 a, b { !DV dq, a, b }
macro !DF a, b { !DV dt, a, b }

;;;;;;;;;;;;;; DEFINE HL VARIABLE ;;;;;;;;;;;;;;;;

; define X. syntax: type then any a/a=b
; sequence/s separated with ,s. example:
; NUMBER x, y, w=320, h=240
; variables=0 if there is no initial value

macro !D type, [p] {
 common
  if p eq
   'Name expected'
  end if
 forward
  define ?s 0
  match =0 a==b, ?s p \{ ; a=b
   type a, b
   define ?s 1
  \}
  match =0 a=,, ?s p \{  ; a, (next)
   type a, 0
   define ?s 1
  \}
  match =0 a, ?s p \{    ; a (end)
   type a, 0
   define ?s 1
  \}
  verify variable
}

; HL variable names

macro char [a]   { !D !D1, a }
macro short [a]  { !D !D2, a }
macro int [a]    { !D !D4, a }
macro float [a]  { !D !D4, a }
macro double [a] { !D !D8, a }    

You can also create byte arrays and text variables:

Code:

; verify size of block/text/array

macro verify.size n {
 if n eq
  'Size must be specified'
 else if ~ n eqtype 0
  'Size must be numeric'
 else if n eq 0
  'Size cannot be zero'
 end if
}

; define byte array. BLOCK b(size)

macro BLOCK [p] {
 forward
  define ?s 0
  match =0 (size), ?s p \{
   verify.size size
   db size dup(0)
   define ?s 1 
  \}
  match =0 name(size), ?s p \{
   verify.size size
   !DV db, name, size dup(0)
   define ?s 1
  \}
  verify BLOCK
}

; create HL 'text' variable/s. TEXT t='X'.
; note: (n) is the size
 
macro TEXT [p] {
 forward
  local l
  define ?s 0
  ; TEXT t(n)='abc'
  match =0 name(size)==text, ?s p \{
   l=$
   verify.size size
   !DV db, name, <text,0>
   times (size-($-l)) db 0
   define ?s 1
  \}
  ; TEXT t(n)
  match =0 name(size), ?s p \{
   verify.size size
   !DV db, name, size dup(0)
   name\#.$=size
   define ?s 1
  \}
  ; TEXT t='abc'
  match =0 name==text, ?s p \{
   !DV db, name, <text,0> ; name db 't', 0
   define ?s 1
  \}
  ; TEXT t
  match =0 name, ?s p \{
   'Size must be specified:' name
   define ?s 1
  \}
  verify TEXT
}    

PS: In C, float is dd=32BIT and double is dq=64BIT. Here, Intel 16BIT relative "word" is assumed. Why we're still using 16BIT words and notations like LP ("long pointer") I have no idea. Personally, I think db/dw/dd should be replaced with strict sizes d8/d16/d32.