The name is not very important here. More important is that the suggested syntax does not distinguish between the data and the data size. In order to stay readable enough, it must separate the data size from the data values.

dbx 4: 4,5,6    

Before I go to sleep today, I have quickly added the ":"
syntax as an option to the current version, since this was so effortless. It now works like:

Code:

dbx 4: 4,5,6    

dbx 4: 4,5,6 2:0x33    

From all the suggested names I think I liked EMIT the most.

his also possible ?

Code:

dbx 4: 4,5,6 2:0x33    

what about strings with dbx/EMIT ?

When a string of bytes is provided as the value to any of these instructions, the generated data is extended with zero bytes to the length which is the multiple of data unit.

dq "abcdefg"
dq 1*"abcdefg"    

macro dv value
        local length
        if value > 0
                length = bsr (value) shr 3 + 1
                dd length
                emit length: value
        else if value = 0
                dd 0
        else
                err 'negative values not supported'
        end if
end macro    

Perhaps BSR can have a signed equivalent? SSR = signed scan reverse

x = float 1/3

if x < 0
        sign_bit = 1
        x = -x
else
        sign_bit = 0
end if

db sign_bit

if x <> 0

        exponent = bsr x
        mantissa = trunc (x shl (15 - exponent))

        if exponent < -80h | exponent > 7Fh
                err 'exponent out of range'
        end if
        db exponent

        dw mantissa

else

        db 0
        dw 0

end if    

But if more precision is needed, the source code of fasmg allows to modify this limit very easily. The MANTISSA_SEGMENTS constant defined in FLOATS.INC file sets up the length of internally handles mantissa, in 32-bit segments.

Tomasz Grysztar wrote:

But if more precision is needed, the source code of fasmg allows to modify this limit very easily. The MANTISSA_SEGMENTS constant defined in FLOATS.INC file sets up the length of internally handles mantissa, in 32-bit segments.

I would be in favour of having this available to the source code as a directive or setting or something. For code to be posted here it feels wrong to me to have to tell others to modify their assembler in order to assembler the code. These kinds of extra assembly instruction steps can easily be forgotten or lost. And each time someone downloads a new version of fasmg they have to remember to change it accordingly.

; Variant 1
emit {sizevar} 1, 2, 3, 4, 5
dword equ {4}
dd equ emit {4}

; Variant 2
emit <sizevar> 1, 2, 3, 4, 5
dword equ <4>
dd equ emit <4>

; Variant 3
emit ^4 or emit ^(sizevar) 1, 2, 3, 4, 5
dword equ ^4
dd equ emit ^4    

label smth dword at $ - 4
label smth:dword at $ - 4
store smth:dword at addrspace:addr
load smth:dword from addrspace:addr    

label smth {4} at $ - 4
label smth:{4} at $ - 4
store smth:{4} at addrspace:addr
load smth:{4} from addrspace:addr    

RECORD_SIZE := 128
mov dword [eax], RECORD_SIZE * 10 ; mov {4} [eax], RECORD_SIZE * 10
mov [eax], dword RECORD_SIZE * 10 ; mov [eax], {4} RECORD_SIZE * 10
BASE_ADDR := dword 0x325 ; BASE_ADDR := {4} 0x325
mov [eax], BASE_ADDR + 125 ; size is known from the BASE_ADDR, but we can overwrite if we wish    

dword equ {4}
dd equ emit dword

; Example of the dd:
nums dd 1, 2, 3, 4, 5
; will be treated as:
nums emit {4} 1, 2, 3, 4, 5
; which is not hard to parse, it seems    

I understand that it is a bit late and decision has been done, but I have some additional ideas, maybe someone will like them

Unfortunately, this approach will require changing of the current code which generates relocs (in the pe.inc and others). Now it replaces dd and dq (and it seems that "emit 4: label" will not generate a reloc), after this change it will be required to replace emit itself (and "emit {4} label" will generate a reloc).

As long as the instructions that need to generate relocations still used "dd" and not "emit" directly, it would still be enough to redefine "dd" only

And as I recently noted the braces may not be so safe to use for new syntactical purposes.