%define htons(x) (((x & 0xFF) << 8) | (x >> 8))
;then
mov eax, htons(1)
;is equivalent to
mov eax, 0x100
    

db `Hello World!\0`
;same as
db 'Hello World', 0
    

macro htons reg,value {
   ;macro code here
}
macro cstring [string] {
   forward
   ;macro code here
}

htons eax,1
cstring 'Hello World!\0'    

mov dword [rax + 12], htons(0x806) | (htons(1) << 16)
mov dword [rax + 16], htons(0x800) | ((6 | (4 << 8)) << 16)
    

but FASM seems to be missing some useful features.

invoke function,<'abc',9,'123',0>    

For the first case, consider this:

Code:

mov dword [rax + 12], htons(0x806) | (htons(1) << 16)
mov dword [rax + 16], htons(0x800) | ((6 | (4 << 8)) << 16)
    

How would I make a generic "htons" macroinstruction which can deal with cases like these too?

struc htons x { . = ((x and 0xFF) shl 8) or (x shr 8) }

LO htons 0x806
HI htons 1
mov dword [rax+12],LO or (HI shl 16)    

For the second case, I don't know how to make a macro to replace escape sequences in the string (my knowledge of FASM macros is still somewhat limited), can you provide a quick example?

macro cstring [string] {
  common local src,len,a,esc,val
    virtual at 0
      src:: db string
      len = $
    end virtual
    esc = 0
    repeat len
      load a byte from src:%-1
      if esc>0
        if a>='0' & a<='9'
          esc = esc + 1
          val = val*10 + a-'0'
        else
          db val
          esc = 0
        end if
      else if a<>'\'
        db a
      end if
      if a='\'
        esc = 1
        val = 0
      end if
    end repeat
    if esc>1
      db val
    end if
}

cstring 'Hello World!\13\10\0'    

...

macro str [string] {
common local src, len, a, esc, val
virtual at 0
    src:: db string
    len = $
end virtual
    esc = 0
    repeat len
        load a byte from src:%-1
        if a >= '0' & a <= '7'
            if esc > 0
                esc = esc + 1
                val = val * 8 + a - '0'
            else
                db a
            end if
        else
            if a = '\'
                if esc > 0
                    db '\'
                    esc = 0
                else
                    esc = 1
                    val = 0
                end if
            else
                if esc > 0
                    esc = 0
                    db val
                end if
                db a
            end if
        end if
    end repeat

    if esc > 1
      db val
    end if
}
    

str "\0123"    

"\x1223420522545feda45" ;how many characters are generated?    

What does the following give?

Code:

str "\0123"    

And the C spec doesn't have a limit for hex values at all:

Code:

"\x1223420522545feda45" ;how many characters are generated?    

macro str [string] {
common local src, len, a, esc, val
virtual at 0
    src:: db string
    len = $
end virtual
    esc = 0
    repeat len
        load a byte from src:%-1
        if a >= '0' & a <= '7'
            if esc > 0
                if esc < 4
                    esc = esc + 1
                    val = val * 8 + a - '0'
                else
                    esc = 0
                    db val
                    db a
                end if
            else
                db a
            end if
        else
            if a = '\'
                if esc > 0
                    db '\'
                    esc = 0
                else
                    esc = 1
                    val = 0
                end if
            else
                if esc > 0
                    esc = 0
                    db val
                end if
                db a
            end if
        end if
    end repeat

    if esc > 1
      db val
    end if
}    

str8c
One remark about addressing space labels. If you use an addressing space label in a virtual addressing space, then the addressing space data becomes persistent across a compilation pass and this way more memory is used during the compilation. If you don't put an addressing space label into a virtual addressing space, then the memory is freed on closing the address space. This is an empirical discovery, thus I hope Tomasz Grysztar will confirm that.

For that reason I'd rather suggest to put an addressing space label outside of the virtual block and to store the converted data from inside of it to the outside addressing space. That's what I normally do to prevent wasting memory.

I don't know how one closes an address space?

Also, are you meaning that the converted data should overwrite the original data?

Plus, I've never seen any method or function in fasm to "free" memory

If you don't put an addressing space label into a virtual addressing space, then the memory is freed on closing the address space. This is an empirical discovery, thus I hope Tomasz Grysztar will confirm that.

For that reason I'd rather suggest to put an addressing space label outside of the virtual block and to store the converted data from inside of it to the outside addressing space. That's what I normally do to prevent wasting memory.

P.S. And you should always start label names (including addressing space labels) used in macros with a double dot. Otherwise you'll have to confront undesired effects.

l_inc wrote:

P.S. And you should always start label names (including addressing space labels) used in macros with a double dot. Otherwise you'll have to confront undesired effects.

I realized this, is there any reason FASM doesn't do this automatically for local labels?

Yes, it's true. The details are a bit more complex

But you have to be using them extensively in order to notice the difference.

Can you provide an example of how you would do this

macro str [string]
{
    common local ..asDst, ..dst, pos, len, a, esc, val
        ..asDst:: ..dst rb len
        virtual at 0
            db string
            pos = 0
            esc = 0
            repeat $
                load a byte from %-1
                if a >= '0' & a <= '7'
                    if esc > 0
                        if esc < 4
                            esc = esc + 1
                            val = val * 8 + a - '0'
                        else
                            esc = 0
                            store byte val at ..asDst:..dst+pos
                            store byte a at ..asDst:..dst+pos+1
                            pos = pos + 2
                        end if
                    else
                        store byte a at ..asDst:..dst+pos
                        pos = pos + 1
                    end if
                else
                    if a = '\'
                        if esc > 0
                            store byte '\' at ..asDst:..dst+pos
                            pos = pos + 1
                            esc = 0
                        else
                            esc = 1
                            val = 0
                        end if
                    else
                        if esc > 0
                            esc = 0
                            store byte val at ..asDst:..dst+pos
                            pos = pos + 1
                        end if
                        store byte a at ..asDst:..dst+pos
                        pos = pos + 1
                    end if
                end if
            end repeat
            if esc > 1
              store byte val at ..asDst:..dst+pos
              pos = pos + 1
            end if
            len = pos
        end virtual
}    

I realized this, is there any reason FASM doesn't do this automatically for local labels?