String to BSTR and back

[jack]

has anyone coded routines to convert a string to BSTR and vice-versa? https://docs.microsoft.com/en-us/previous-versions/windows/desktop/automat/bstr

[Pete]

There, I just did!

Code: QB64: [Select]

1. a$ = "I am a happy BSTR"
2. string_2_bstr$ = "BSTR MyBstr = SysAllocString(L" + CHR$(34) + a$ + CHR$(34) + ");"
3. bstr_2_string$ = MID$(string_2_bstr$, INSTR(string_2_bstr$, CHR$(34)), LEN(string_2_bstr$) - INSTR(string_2_bstr$, CHR$(34)) - 1)
4.  
5. PRINT "string_2_bstr$ = "; string_2_bstr$
6. PRINT "bstr_2_string$ = "; bstr_2_string$
7.  

Well it must be a whole heck of a lot more involved than that, but this is the very first article I've seen about B-Strings. Granted, we do see a lot of G-Strings out here in California, but that's a whole different kind of article, as in article of clothing, or lack thereof. @Cobalt

Anyway, other than instr() template formatting, and probably some data tables for identifying usage, what else
is involved in this conversion process you are seeking?

Pete

Edit: I like where @bplus is heading with forming a TYPE declaration.

[bplus]

A BSTR is a composite data type that consists of a length prefix, a data string, and a terminator. The following table describes these components.

REMARKS
Item   Description
Length prefix   A four-byte integer that contains the number of bytes in the following data string. It appears immediately before the first character of the data string. This value does not include the terminator.
Data string   A string of Unicode characters. May contain multiple embedded null characters.
Terminator   A NULL (0x0000) WCHAR.

Is a 4 byte integer a QB64 Long? ie

Type Bstr
length as long
s as string
t as string * 1 'terminator
End Type

And do you even have to put in anything for terminator ie automatic zero?

[bplus]

Maybe Long should be _Unsigned Long.

[bplus]

OK so Unicode chars are 4 bytes. There's a monkey wrench for me anyway.

[jack]

it's utf16 I think, 2 ubytes
any way, you nedd BSTR string conversion to use oleauto.dll VarDecFromStr and VarBstrFromDec functions
the reason is so that you can use the decimal functions, here's an example but limited to double conversion

Code: QB64: [Select]

1. $NoPrefix
2. Option Explicit
3.  
4. Type DECIMAL
5.     wReserved As Unsigned Integer
6.     scale As Unsigned Byte
7.     sign As Unsigned Byte
8.     Hi32 As Unsigned Long
9.     Lo32 As Unsigned Long
10.     Mid32 As Unsigned Long
11. End Type
12.  
13. Declare Dynamic Library "OleAut32"
14.     Function VarDecFromI4& (ByVal i As Long, result As DECIMAL)
15.     Function VarDecFromI8& (ByVal i&&, result As DECIMAL)
16.     Function VarDecFromR4& (ByVal x As Single, result As DECIMAL)
17.     Function VarDecFromR8& (ByVal x As Double, result As DECIMAL)
18.     Function VarR4FromDec& (x As DECIMAL, result As Single)
19.     Function VarR8FromDec& (x As DECIMAL, result As Double)
20.     Function VarDecAbs& (x As DECIMAL, result As DECIMAL)
21.     Function VarDecFix& (x As DECIMAL, result As DECIMAL)
22.     Function VarDecInt& (x As DECIMAL, result As DECIMAL)
23.     Function VarDecRound& (x As DECIMAL, Byval cDecimals As Long, result As DECIMAL)
24.     Function VarDecNeg& (x As DECIMAL, result As DECIMAL)
25.     Function VarDecCmp& (x As DECIMAL, y As DECIMAL)
26.     Function VarDecCmpR8& (x As DECIMAL, Byval y As Double) '0 x<y, 1 x=y, 2 x>y, 3 Either expression is null
27.     Function VarDecAdd& (x As DECIMAL, y As DECIMAL, result As DECIMAL)
28.     Function VarDecSub& (x As DECIMAL, y As DECIMAL, result As DECIMAL)
29.     Function VarDecMul& (x As DECIMAL, y As DECIMAL, result As DECIMAL)
30.     Function VarDecDiv& (x As DECIMAL, y As DECIMAL, result As DECIMAL)
31. End Declare
32.  
33. Dim As DECIMAL x, y, result
34. Dim As Long flag
35. Dim As Double p1, z
36. p1 = 3.1415926535897932
37.  
38. flag = VarDecFromR8(p1, x)
39. flag = VarDecAdd(x, x, result)
40. flag = VarR8FromDec(result, z)
41. Print "add decimal "; p1; " then print as double "; z
42. flag = VarDecRound&(result, 2, result)
43. flag = VarR8FromDec(result, z)
44. Print "round to 2 decimals "; z
45.  
46. flag = VarDecFromI4(7, x)
47. flag = VarDecFromI4(9, y)
48. flag = VarDecDiv(x, y, result)
49. flag = VarR8FromDec(result, z)
50. Print "divide decima 7 by decimal 9 then print as double "; z
51. flag = VarDecFromI8(777777777777777777&&, x)
52. x.scale = 18
53. flag = VarR8FromDec(x, z)
54. Print "777777777777777777&& to decimal then scale to 18 decimals "; z
55. flag = VarDecSub(result, x, result)
56. flag = VarR8FromDec(result, z)
57. Print "7/9 - .777777777777777777 = "; z
58.  

output

Code: [Select]

add decimal  3.141592653589793  then print as double  6.28318530717958
round to 2 decimals  6.28
divide decima 7 by decimal 9 then print as double  .777777777777778
777777777777777777&& to decimal then scale to 18 decimals  .7777777777777778
7/9 - .777777777777777777 =  7.777777778000001D-19


[Pete]

@SpriggsySpriggs Maybe Indy has a API snippet to do the conversion part, via Windows using calls like SysAllocString(), SysAllocStringByteLen, etc.

I have no clue what else may be involved at this point, but some interesting reading...

"Even if one could use a BSTR as a simple way to marshal a byte array (since the BSTR is length-prefixed, so it can store embedded NULs), and so potentially a BSTR could be used also to store non-UTF-16 text, the usual "natural" behavior for a BSTR is to contain a Unicode UTF-16 wchar_t-string.

So, the first problem is to clarify what kind of encoding the std::string uses (for example: Unicode UTF-8? Or some other code page?). Then you have to convert that string to Unicode UTF-16, and create a BSTR containing that UTF-16 string.

To convert from UTF-8 (or some other code page) to UTF-16, you can use the MultiByteToWideChar() function. If the source std::string contains a UTF-8 string, you can use the CP_UTF8 code page value with the aforementioned API.

Once you have the UTF-16 converted string, you can create a BSTR using it, and pass that as the output BSTR* parameter.

The main Win32 API to create a BSTR is SysAllocString(). There are also some variants in which you can specify the string length.

Or, as a more convenient alternative, you can use the ATL's CComBSTR class to wrap a BSTR in safe RAII boundaries, and use its Detach() method to pass the BSTR as an output BSTR* parameter."

More interesting reading: https://ericlippert.com/2003/09/12/erics-complete-guide-to-bstr-semantics/

Pete

[SpriggsySpriggs]

What's up? Why are we needing BSTR? I have functions for ASCII to Unicode / Unicode to ASCII strings (wrappers for MultiByteToWideChar and WideCharToMultiByte). Give me some background info for what you're doing and, when I have some time, I'll try to assist.

The answer you seek lies below.

[SpriggsySpriggs]

I mean, if this is all you are needing, then it's really as simple as:

Code: QB64 $NOPREFIX: [Select]

1. Option Explicit
2. $Console:Only
3. $NoPrefix
4.  
5. Declare Dynamic Library "OleAut32"
6.     Function SysAllocString%& (OLECHAR As String)
7.     Sub SysFreeString (ByVal bstrString As Offset)
8. End Declare
9.  
10. Dim As Offset bstr: bstr = SysAllocString(ANSIToUnicode("This is a test"))
11.  
12. Print bstr
13.  
14. Print wCharPtrToString(bstr)
15.  
16. SysFreeString bstr
17.  
18. Function wCharPtrToString$ (wchar As _Offset)
19.     Declare CustomType Library
20.         Function wcslen%& (ByVal str As _Offset)
21.     End Declare
22.  
23.     Dim As _Offset wlen: wlen = wcslen(wchar) * 2 'The length does not account for the 2-byte nature of Unicode so we multiply by 2
24.     Dim As _MEM pChar: pChar = _Mem(wchar, wlen) 'Declaring a new _MEM block and setting it to grab the number of bytes referenced by wlen at pointer wchar
25.     Dim As String char: char = Space$(wlen) 'Declaring a new string large enough to hold the unicode string
26.     _MemGet pChar, pChar.OFFSET, char 'Storing the data in the string
27.     _MemFree pChar 'Freeing the _MEM block
28.     wCharPtrToString = UnicodeToANSI(char) 'Returning the converted Unicode string
29. End Function
30.  
31. Declare CustomType Library
32.     Function WideCharToMultiByte& (ByVal CodePage As _Unsigned Long, Byval dwFlags As Long, Byval lpWideCharStr As _Offset, Byval cchWideChar As Integer, Byval lpMultiByteStr As _Offset, Byval cbMultiByte As Integer, Byval lpDefaultChar As _Offset, Byval lpUsedDefaultChar As _Offset)
33.     Function MultiByteToWideChar& (ByVal CodePage As _Unsigned Long, Byval dwFlags As Long, Byval lpMultiByteStr As _Offset, Byval cbMultiByte As Integer, Byval lpWideCharStr As _Offset, Byval cchWideChar As Integer)
34. End Declare
35.  
36. Function UnicodeToANSI$ (buffer As String)
37.     Dim As String ansibuffer: ansibuffer = Space$(Len(buffer))
38.     Dim As Long a: a = WideCharToMultiByte(437, 0, _Offset(buffer), Len(buffer), _Offset(ansibuffer), Len(ansibuffer), 0, 0)
39.     UnicodeToANSI = Mid$(ansibuffer, 1, InStr(ansibuffer, Chr$(0)) - 1)
40. End Function
41.  
42. Sub UnicodeToANSI (buffer As String, __dest As String)
43.     Dim As String ansibuffer: ansibuffer = Space$(Len(buffer))
44.     Dim As Long a: a = WideCharToMultiByte(437, 0, _Offset(buffer), Len(buffer), _Offset(ansibuffer), Len(ansibuffer), 0, 0)
45.     __dest = Mid$(ansibuffer, 1, InStr(ansibuffer, Chr$(0)) - 1)
46. End Sub
47.  
48. Function ANSIToUnicode$ (buffer As String)
49.     Dim As String unicodebuffer: unicodebuffer = Space$(Len(buffer) * 2)
50.     Dim As Long a: a = MultiByteToWideChar(65001, 0, _Offset(buffer), Len(buffer), _Offset(unicodebuffer), Len(unicodebuffer))
51.     ANSIToUnicode = unicodebuffer
52. End Function
53.  
54. Sub ANSIToUnicode (buffer As String, __dest As String)
55.     Dim As String unicodebuffer: unicodebuffer = Space$(Len(buffer) * 2)
56.     Dim As Long a: a = MultiByteToWideChar(65001, 0, _Offset(buffer), Len(buffer), _Offset(unicodebuffer), Len(unicodebuffer))
57.     __dest = unicodebuffer
58. End Sub

A BSTR is really just a pointer to a wide-char string. It expects a wide-char string as an input so I use my ANSIToUnicode function to pass my string in. SysAllocString returns the pointer. If I want the string back as an ANSI type then I can just use my function wrapper called wCharPtrToString.

[jack]

thanks a million SpriggsySpriggs :-)
[edit]
it doesn't work if I do something like this, your code omitted for brevity

Code: QB64: [Select]

1. Type DECIMAL
2.     wReserved As Unsigned Integer
3.     scale As Unsigned Byte
4.     sign As Unsigned Byte
5.     Hi32 As Unsigned Long
6.     Lo32 As Unsigned Long
7.     Mid32 As Unsigned Long
8. End Type
9.  
10. Declare CustomType Library
11.     Function WideCharToMultiByte& (ByVal CodePage As _Unsigned Long, Byval dwFlags As Long, Byval lpWideCharStr As _Offset, Byval cchWideChar As Integer, Byval lpMultiByteStr As _Offset, Byval cbMultiByte As Integer, Byval lpDefaultChar As _Offset, Byval lpUsedDefaultChar As _Offset)
12.     Function MultiByteToWideChar& (ByVal CodePage As _Unsigned Long, Byval dwFlags As Long, Byval lpMultiByteStr As _Offset, Byval cbMultiByte As Integer, Byval lpWideCharStr As _Offset, Byval cchWideChar As Integer)
13. End Declare
14.  
15. Declare Dynamic Library "OleAut32"
16.     Function VarDecFromStr& (st As Offset, Byval lcid As Unsigned Long, Byval flags As Unsigned Long, result As DECIMAL)
17.     Function SysAllocString%& (OLECHAR As String)
18.     Sub SysFreeString (ByVal bstrString As Offset)
19. End Declare
20.  
21. Dim As DECIMAL x, y, result
22. Dim As Unsigned Long lcid
23. Dim As Double p, z
24. Dim As String s
25. Dim As Offset b
26. Dim As Long flag
27.  
28. s = "3.1415926535897932384626433832795" + Chr$(0)
29. b = SysAllocString(ANSIToUnicode(s))
30. flag = VarDecFromStr(b, lcid, 0, x)
31.  

flag = -2147352571 or DISP_E_TYPEMISMATCH

[SpriggsySpriggs]

Don't forget byval in your VarDecFromStr function

[jack]

yes that indeed works, thanks again :-)

[SpriggsySpriggs]

@jack Glad it works! Good luck with your project. Tag me if you need me again.