struc BSTR [data] {
common
local length
        dd      length
label . word
forward
        du      data
common
length = $ - .
        dw      0
}    

        format PE
        include "WIN32WX.INC"

        .code
start:  invoke  GetProcessHeap
        mov     [hBSTRHeap], eax
        stdcall SysAllocString, "Hello, world!"
        ret

proc SysAllocString sz
        mov     eax, [sz]
        test    eax, eax
        jz      .done                   ; got NULL, bail out
        invoke  lstrlen, [sz]
        test    eax, eax
        jz      .done                   ; got zero-length string, bail out
        shl     eax, 1                  ; they're 2-byte
        push    eax                     ; save string size
        add     eax, 4+2                ; length+terminator
        invoke  HeapAlloc, [hBSTRHeap], HEAP_ZERO_MEMORY, eax
        test    eax, eax
        jz      .done                   ; no core, bail out; extra dword at stack will be discarded, believe me 
        add     eax, 4
        push    eax                     ; save BSTR pointer
        invoke  RtlMoveMemory, eax, [sz], dword [esp+4]; it holds string size
        pop     eax                     ; retrieve it back
        pop     dword [eax-4]           ; put string size into it's place
.done:  ret
endp

        .data
hBSTRHeap rd 1

        .end    start    

mov eax, [mystr] 
ret    

mov eax, mystr
ret    

BSTR is a pointer.
What kind of a complete example do you need?
Define static data with BSTR macro (like, mystr BSTR "Hello, world!", 13, 10), return mystr…

Can you show us DLL code and VB code?

format PE GUI 4.0 DLL
entry DllEntryPoint

section '.code' code readable executable

struc BSTR [data]
{
     common
      local length
                dd      length
      label . word
        forward
             du      data
        common
      length = $ - .
              dw      0
}

mystr BSTR "Hello, world!", 13, 10


proc BStr_Generator  
    mov eax, [mystr]
    ret
endp

proc DllEntryPoint, hinstDLL,fdwReason,lpvReserved
       mov     eax,TRUE
    ret
endp

include "idata.inc"

section '.edata' export data readable

  export 'ERRORMSG.DLL',\
  BStr_Generator, 'BStr_Generator'
    

section '.idata' import data readable writeable

  library kernel32,'kernel32.dll',\
          user32,'user32.dll'

  import kernel32,\
         FormatMessage,'FormatMessageA',\
         GetLastError,'GetLastError',\
         LocalFree,'LocalFree'

  import user32,\
         MessageBox,'MessageBoxA'
    

Private Declare Function BStr_Generator _
Lib "Test.dll" _
() As String
Private Sub Form_Load()
    MsgBox (BStr_Generator())
    End
End Sub

    

Alexander,

The problem is the conversion that VB does on the
returned string. If you want the proc BStr_Generator
to return a BSTR you will need to play games so that
the BSTR does not get turned into another BSTR when
the function returns to VB.

See here:

http://vb.mvps.org/tips/vb5dll.asp

and look in section 5: Passing and Returning Strings.

Also, you were right about

mov eax, [mystr] needs to be
mov eax, mystr

Mark

To handle strings that are allocated by one component and freed by another, Automation defines a special set of functions. These functions use the following data type: typedef OLECHAR * BSTR;

These strings are zero-terminated, and in most cases they can be treated just like OLECHAR* strings. However, you can query a BSTR for its length rather than scan it, so it can contain embedded null characters. The length is stored as a 32-bit integer at the memory location preceding the data in the string. Instead of reading this location directly, applications should use the string manipulation functions to access the length of a BSTR.

Windows must be able to control the (de-)allocation of the string. Use the OLE string functions to create/use BSTRs - it is the easiest way to insure it will work.

Quote:

To handle strings that are allocated by one component and freed by another, Automation defines a special set of functions. These functions use the following data type: typedef OLECHAR * BSTR;

These strings are zero-terminated, and in most cases they can be treated just like OLECHAR* strings. However, you can query a BSTR for its length rather than scan it, so it can contain embedded null characters. The length is stored as a 32-bit integer at the memory location preceding the data in the string. Instead of reading this location directly, applications should use the string manipulation functions to access the length of a BSTR.

It's impossible to know if another component will attempt to free the BSTR passed to it.

how will any ole function or api know that the string wasn't manipulated. Isn't there a way in fasm for a solution?