postpone {

   section '.idata' import data readable writeable

     library kernel32,'KERNEL32.DLL',\
             user32,'USER32.DLL',\
             gdi32,'GDI32.DLL',\
             advapi32,'ADVAPI32.DLL',\
             comctl32,'COMCTL32.DLL',\
             comdlg32,'COMDLG32.DLL',\
             shell32,'SHELL32.DLL',\
             wsock32,'WSOCK32.DLL'

     include 'api\kernel32.inc'
     include 'api\user32.inc'
     include 'api\gdi32.inc'
     include 'api\advapi32.inc'
     include 'api\comctl32.inc'
     include 'api\comdlg32.inc'
     include 'api\shell32.inc'
     include 'api\wsock32.inc'

}
    

virtual at 0
  __str__character_skips::
  dd 256 dup ?
end virtual

struc str [data] {
 common local ..buffer,size,a,b,c,p,skip,found

  virtual at 0
    ..buffer:: db data
    size = $
  end virtual

  times 256 store dword size at __str__character_skips:(%-1)*4
  repeat size-1
    load a byte from ..buffer:%-1
    store dword size-% at __str__character_skips:a*4
  end repeat

  found = -1
  p = 0
  while p + size <= __str__current & p + size <= __STR__DATA_SIZE
    c = size
    while c > 0
      load a byte from __str__section:__str__data+p+c-1
      load b byte from ..buffer:c-1
      if a<>b
        c = -1
        break
      end if
      c = c - 1
    end while
    if c = 0
      found = p
      break
    else
      load a byte from __str__section:__str__data+p+size-1
      load skip dword from __str__character_skips:a*4
      p = p + skip
    end if
  end while

  if found >= 0
    label . at __str__data + found
  else
    label . at __str__data + __str__current
    __str__current = __str__current + size
    if __str__current <= __STR__DATA_SIZE
      repeat size
        load a byte from ..buffer:%-1
        store byte a at __str__section:.+%-1
      end repeat
    end if
  end if
}

define __str__cnt 0

struc str [data] {
 common
   rept 1 i:__str__cnt+1 \{
     define __str__cnt i
     define __str__\#i . str data
   \}
}

macro __str__previous {}

macro .str {
  __str__section::
  __str__data db __STR__DATA_SIZE dup 0
  __str__current = 0
  restruc str
  rept __str__cnt i \{ match def,__str__\#i \\{ def \\} \}
}

postpone {
  __STR__DATA_SIZE = __str__current
}    

include 'str.inc'

some_message str 'Testing one',0

.str    ; the data of all strings is put here

other_message str 'Doing something...',13,10

        mov     eax,some_message
        mov     ebx,submessage
        mov     ecx,other_message

submessage str 'one',0    

version 1.71.14 (Oct 25, 2013)

[+] Added "postpone" directive to preprocessor.

version 1.71.13 (Sep 09, 2013)

[-] Fixed a bug that caused the expressions containing external symbols
    to overflow from time to time.
    

The ORG directive in my version allows to design code to work correctly when loaded at specified origin, while its placement in file is just determined by the order of source. My assembler, generating the code in flat addressing space, was always outputting the code exactly in the same order, as it was defined in source. Thus came the name for it - flat assembler.

Interesting ... ... but isn't it against the design ?

macro @crc8 s,e
{
        local lbl
    lbl:
        db 0
        postpone
        \{
                store byte (e - s) at lbl
        \}
}

s:
db 'A'
@crc8 s,e
db 'B'
e:    

s:
db 'A'
crc_1:
db 0
db 'B'
e:

@crc8 crc_1,s,e    

macro DoIt
{
        xor eax,eax

        postpone
        \{
                not eax
        \}
}

postpone
{
        procA:

                DoIt

                inc eax

        postpone
        \{
                ret

                procB:

                        DoIt

                        dec eax

                postpone
                \\{
                        ret
                \\}
        \}
}
    

I can't see it being that useful for code unless you go a little crazy with it

postpone
{
        postpone \{ m1 \}
        display '2',13,10
        macro m1 \{ postpone \\{ display '6',13,10 \\} display '4',13,10 \}
}
postpone
{
        postpone \{ m2 \}
        display '3',13,10
        macro m2 \{ postpone \\{ display '7',13,10 \\} display '5',13,10 \}
}
display '1',13,10    

postpone { err }
display 'Hello',13,10    

flat assembler  version 1.71.14  (1572864 kilobytes memory)
Hello
C:\asm.asm [2]:
display 'Hello',13,10
C:\asm.asm [1] postpone [0]:
postpone { err }
error: error directive encountered in source file.    

However, I find reporting of errors occurring within expanded postpone macroblocks a bit misleading (...)

        rep     movs byte [edi],[esi]
      after_macro_operators:
    

This does not tell me much. Can you prepare some artificial sample to reproduce the bug?

Fixed some bugs inadvertently introduced in the previous release.

Using it for code definitely IS crazy.