char szText[] = "Hello World";

int GetText(char* szBuff, int* nBuffSize)
{
      int nTextLength = strlen(szText);
   if(*nBuffSize < nTextLength)
     {
              *nBuffSize = nTextLength;
           return -1;
  } else
 {
              memset(szBuff,0,*nBuffSize);
                strcpy(szBuff,szText);
              return nTextLength;
 }
}    

HMODULE hLib =LoadLibrary("fasm_code.dll");
typedef int (__stdcall *GetText)(char * pBuff, int * cbSize) = (int (__stdcall*)(char*,int*) ) GetProcAddress(hLib,"GetText");
int length = 12356;
char * myBuffer = (char*)malloc(length);

length = GetText(myBuffer, &length);

    

format pe gui 4.0 dll

include 'win32a.inc'

entry DllMain

section '.code' code readable executable

proc DllMain
     mov        eax, 1
     ret
endp

;
; __stdcall memset
;
        memset:
            push ebp
            mov  ebp, esp
                cld
                mov     ecx, dword [ebp+16]
                mov     esi, dword [ebp+8]
                mov     eax, dword [ebp+12]
                rep     stosb

            leave
        ret 4 * 3

;
; __stdcall strlen
;
      strlen:; (str)
             push ebp
             mov  ebp, esp
                cld
                mov al,  0    ; Scan for null byte
                mov eax, -1   ; Make the loop infinite until we hit the null byte
                mov edi, dword[ebp+8]
                repne scasb
                mov eax, -2   ; If first byte is null ECX will be -2
                sub eax, ecx
             leave
      ret 4

;
; __stdcall strcpy. Quick and dirty. Not good for production
;
      strcpy:;(str1,str2)
            push ebp
            mov  ebp, esp

               push dword[ebp+12] ; str2
               call strlen
                                 ; check for errors here
               mov  ecx, eax
               cld
               mov  esi, dword[ebp+12]
               mov  edi, dword[ebp+8]
               rep  movsb
            leave
      ret   4 * 2

;
; __stdcall GetText (pBuff, length)
;
        GetText:
             push ebp
             mov  ebp, esp
             push ebx

             mov ebx, theLength
             mov eax, dword[ebp+12]  ; pointer on stack
             cmp ebx, dword[eax]     ; what's on that pointer
             jg  @Z

             push   dword[eax]
             push   0
             push   dword[ebp+8]
             call   memset           ; can also be transformed into a macro

             push   theString
             push   dword[ebp+8]
             call   strcpy
             mov    ebx,  eax
           @Z:
             pop ebx
             leave
        ret  4 * 2

section '.data' data readable writeable

theString   db 'Rush Rush Rush !. Oh no!',0
theLength   = $ - theString

section '.export' export data readable

export 'stringz.dll',\
        GetText,'GetText'

section '.reloc' data fixups discardable
    

PUBLIC   ?GetText@@YAHPADPAH@Z           ; GetText
; Function compile flags: /Ogty
;   COMDAT ?GetText@@YAHPADPAH@Z
_TEXT   SEGMENT
_szBuff$ = 8                                         ; size = 4
_nBuffSize$ = 12                                  ; size = 4
?GetText@@YAHPADPAH@Z PROC NEAR           ; GetText, COMDAT
   push    esi
 push    OFFSET FLAT:?szText@@3PADA  ; szText
    call    DWORD PTR __imp__lstrlenA@4
 mov     esi, eax
    mov     eax, DWORD PTR _nBuffSize$[esp]
     mov     ecx, DWORD PTR [eax]
        cmp     ecx, esi
    
    jge     SHORT $L180702

  mov     DWORD PTR [eax], esi
        or      eax, -1
     pop     esi
 ret     0
   
$L180702:

       mov     edx, DWORD PTR _szBuff$[esp]
        push    ebx
 mov     ebx, ecx
    push    edi
 shr     ecx, 2
      xor     eax, eax
    mov     edi, edx
    rep stosd
   mov     ecx, ebx

        push    OFFSET FLAT:?szText@@3PADA  ; szText
    and     ecx, 3
      push    edx
 rep stosb
   call    DWORD PTR __imp__lstrcpyA@8
 pop     edi
 pop     ebx

     mov     eax, esi
    pop     esi


 ret     0
?GetText@@YAHPADPAH@Z ENDP                 ; GetText
_TEXT      ENDS    

;;;;;;;;;;;;;;;; MEMORY COPY, SET ;;;;;;;;;;;;;;;;

function memory.copy, a, b, n
push esi edi
let edi=[a],\
 esi=[b], ecx=[n]
test edi, esi      ; address=0?
jz .e
cmp ecx, 4         ; if n<4
jb @f
push ecx
shr ecx, 2         ; n/4
rep movsd          ; copy dwords
pop ecx
and ecx, 3         ; modulo 4
jz .e              ; remainder?
@@:
rep movsb          ; copy bytes
.e:
pop edi esi
endf

function memory.set, p, v, n
push edi
let edi=[p],\
 ecx=[n]
test edi, edi      ; address=0?
jz .e
cmp ecx, 4         ; n<4?
jb @f
push ecx
shr ecx, 2
rep stosd          ; copy dwords
pop ecx
and ecx, 3         ; modulo 4
jz .e              ; remainder?
@@:
rep stosb          ; copy bytes
.e:
pop edi
endf

;;;;;;;;;;;;;;;; GET/SET/ZERO BIT ;;;;;;;;;;;;;;;;

; 76543210. warning: eax/ecx/edx cannot be used
; as parameters. 'v' should be m, 'i' can be mi

macro get.bit v, i {  ; (v>>i)&1
let eax=v, ecx=i, eax>>cl, eax&1
}

macro set.bit v, i {  ; v|=(1<<i)
let eax=1, ecx=i, eax<<cl, v|eax
}

macro zero.bit v, i { ; v&=~(1<<i)
let eax=1, ecx=i, eax<<cl
not eax
and v, eax
}

; 1111.0000

macro get.nibble v, i { ; (v>>(i*4))&1111b
let eax=v, ecx=i, ecx<<2, eax>>cl, eax&1111b
}

macro set.nibble v, i, n { ; v|=(n<<(i*4))
let eax=v, ecx=i, edx=n, ecx<<2, edx<<cl,\
eax|edx, v=eax
}

; 33.22.11.00

macro get.couple v, i { ; (v>>(i*2))&11b
let eax=v, ecx=i, ecx<<1, eax>>cl, eax&11b
}

macro set.couple v, i, n { ; v|=(n<<(i*2))
let eax=v, ecx=i, edx=n, ecx<<1, edx<<cl,\
eax|edx, v=eax
}

; enable/disable flag

macro enable.f v, n { let eax=n, v|eax }

macro disable.f v, n {
let eax=n
not eax
and v, eax
}

macro toggle n { xor n, 1 } ; invert 1/0

; create AA.BBB.CCCb/AA.BB.CC.DDb BIT structures

function triplet, a, b, c
let eax=[a], eax<<6,\
ecx=[b], ecx<<3, eax|ecx, eax|[c]
endf

function quadruplet, a, b, c, d
let eax=[a], eax<<6, ecx=[b], ecx<<4,\
edx=[c], edx<<2, eax|ecx, eax|edx, eax|[d]
endf

; expand byte AAh to AA.AA.AA.AAh

function convert.8.32, b
push ebx
let eax=[b],\
ecx=eax, edx=eax, ebx=eax,\
ecx<<8, edx<<16, ebx<<24,\
eax|ecx, eax|edx, eax|ebx
pop ebx
endf

;;;;;;;;;;;;;;;;;; POWERS OF 2 ;;;;;;;;;;;;;;;;;;;

; an unsigned number is a power of 2 if only
; 1 BIT is set: if !(n&n-1). subtracting 1
; inverts all BITs. if n=10000000b (80h/128),
; n&01111111b=0

; to find out which power of 2, search n
; for 1st 0 BIT from right to left

; is n power of 2? example: power.2 128
; returns 7

function power.2, n
locals i
let eax=[n]
.if eax<2
  jmp .r0
.end
let ecx=eax, ecx-1, eax&ecx
.if eax
  jmp .r0 ; not power of 2
.end

; which power of 2?
; n--
; loop i=1, n&1<<i, i++

let [n]--, [i]=1
@@:
let eax=1, ecx=[i],\
eax<<cl, [i]++
test [n], eax
jnz @b
let eax=[i], eax--
jmp @f
.r0: let eax=0
@@:
endf

;;;;;;;;;;;;;;;;;;;;; ALIGN ;;;;;;;;;;;;;;;;;;;;;;

; versatile align n/umber by power of 2

; return n aligned to p in eax. in ecx,
; return the quantity to add to make n
; divisible by p. algorithm:

; n+(((p-1)-(n+p-1))&(p-1))

function align.n, n, p
let ecx=[p], ecx-1, edx=[n], edx+ecx, eax=ecx,\
eax-edx, eax&ecx, ecx=eax, edx=[n], eax+edx
endf    

Do you like HLL or not?

!text.n $t
byte *p=t
while *t, t++, then return t-p
end

!text.copy $a, $b
while *b, *a++=*b++, then *a=0
end

!text.attach $a, $b
a+=text.n(a), text.copy a, b
end

!text.equal $a, $b
if text.case, while *a=*b and *a|*b, a++, b++
else, while IT[*a]=IT[*b] and *a|*b, a++, b++
return (*a|*b)
end

!text.compare $a, $b
while *a=*b and *a|*b, a++, b++, then return *a-*b
end

!text.find $t, c
while *t, t++, if *t=c, return t
return 0
end