Send Beginners mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
http://www.haskell.org/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. How do I marshall a pointer over SendMessage LPARAM or
WPARAM? (Simon Peter Nicholls)
2. Re: How do I marshall a pointer over SendMessage LPARAM or
WPARAM? (Brent Yorgey)
3. Re: How do I marshall a pointer over SendMessage LPARAM or
WPARAM? (Sylvain HENRY)
4. Re: How do I marshall a pointer over SendMessage LPARAM or
WPARAM? (Simon Peter Nicholls)
5. Re: How do I marshall a pointer over SendMessage LPARAM or
WPARAM? (Sylvain HENRY)
6. Re: How do I marshall a pointer over SendMessage LPARAM or
WPARAM? (Simon Peter Nicholls)
----------------------------------------------------------------------
Message: 1
Date: Wed, 18 Jul 2012 15:14:46 +0200
From: Simon Peter Nicholls <[email protected]>
Subject: [Haskell-beginners] How do I marshall a pointer over
SendMessage LPARAM or WPARAM?
To: [email protected]
Message-ID:
<caeacojkqwr69jueswg5te4fq1p2nszo2cqrtdqbbyevye7p...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
I'm new to Haskell, and have had some good success with FFI so far,
but using Win32's sendMessage to send a pointer in LPARAM or WPARAM is
resulting in access violations at the other end.
Is there some issue with my pointer conversions? Am I hitting some
restriction, or missing some compiler options?
It's driving me pretty crazy, after a very nice start to using Haskell.
Some "sending" code:
Foreign.C.String.withCWString "frustrator" $ \s -> do
let wParam = System.Win32.Types.castPtrToUINT s ::
System.Win32.Types.WPARAM
Graphics.Win32.sendMessage wnd Graphics.Win32.wM_APP wParam 0
wndProc "receiving" code:
| wmsg == Graphics.Win32.wM_APP = do
s <- peekCWString $ System.Win32.Types.castUINTToPtr wParam
putStrLn s
return 0
The string will not be seen.
Some extra notes:
I can get wndProc messages and integral data generally.
The pointer values match textually at both ends when "shown" to stdout.
At the sending side I can pass the CWString to a regular FFI function
call just fine, and castUINTToPtr will give me back a functioning Ptr
for that call.
I have also tried sending to & receiving from a working C++ program,
without success. Access violations are reported when receiving, though
again the address matches up. Silence from Haskell as before, when C++
is sending.
I found someone else having an issue here:
http://osdir.com/ml/[email protected]/2009-11/msg00731.html but
no solution unfortunately.
------------------------------
Message: 2
Date: Wed, 18 Jul 2012 11:47:40 -0400
From: Brent Yorgey <[email protected]>
Subject: Re: [Haskell-beginners] How do I marshall a pointer over
SendMessage LPARAM or WPARAM?
To: [email protected]
Message-ID: <[email protected]>
Content-Type: text/plain; charset=us-ascii
Hi,
Just a meta-comment: this doesn't seem like a beginner question to
me. =) Perhaps someone on this list will know the answer (and there's
nothing wrong with asking), but for such a specific question you may
have better luck posting to haskell-cafe or StackOverflow.
-Brent
On Wed, Jul 18, 2012 at 03:14:46PM +0200, Simon Peter Nicholls wrote:
> I'm new to Haskell, and have had some good success with FFI so far,
> but using Win32's sendMessage to send a pointer in LPARAM or WPARAM is
> resulting in access violations at the other end.
>
> Is there some issue with my pointer conversions? Am I hitting some
> restriction, or missing some compiler options?
>
>
> It's driving me pretty crazy, after a very nice start to using Haskell.
>
> Some "sending" code:
>
> Foreign.C.String.withCWString "frustrator" $ \s -> do
> let wParam = System.Win32.Types.castPtrToUINT s ::
> System.Win32.Types.WPARAM
> Graphics.Win32.sendMessage wnd Graphics.Win32.wM_APP wParam 0
>
> wndProc "receiving" code:
>
> | wmsg == Graphics.Win32.wM_APP = do
> s <- peekCWString $ System.Win32.Types.castUINTToPtr wParam
> putStrLn s
> return 0
>
> The string will not be seen.
>
> Some extra notes:
>
> I can get wndProc messages and integral data generally.
> The pointer values match textually at both ends when "shown" to stdout.
> At the sending side I can pass the CWString to a regular FFI function
> call just fine, and castUINTToPtr will give me back a functioning Ptr
> for that call.
>
> I have also tried sending to & receiving from a working C++ program,
> without success. Access violations are reported when receiving, though
> again the address matches up. Silence from Haskell as before, when C++
> is sending.
>
> I found someone else having an issue here:
> http://osdir.com/ml/[email protected]/2009-11/msg00731.html but
> no solution unfortunately.
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
------------------------------
Message: 3
Date: Wed, 18 Jul 2012 17:56:43 +0200
From: Sylvain HENRY <[email protected]>
Subject: Re: [Haskell-beginners] How do I marshall a pointer over
SendMessage LPARAM or WPARAM?
To: [email protected]
Message-ID: <[email protected]>
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Hi,
[As I've just registered to the list, I don't have the original message.
That's why I answer to Brent insted of Simon]
By using "withCWString", your CWString may be freed before the message
is sent. Use "newCWString" instead and "free" in your receiving code.
Cheers
Sylvain
Le 18/07/2012 17:47, Brent Yorgey a ?crit :
> Hi,
>
> Just a meta-comment: this doesn't seem like a beginner question to
> me. =) Perhaps someone on this list will know the answer (and there's
> nothing wrong with asking), but for such a specific question you may
> have better luck posting to haskell-cafe or StackOverflow.
>
> -Brent
>
> On Wed, Jul 18, 2012 at 03:14:46PM +0200, Simon Peter Nicholls wrote:
>> I'm new to Haskell, and have had some good success with FFI so far,
>> but using Win32's sendMessage to send a pointer in LPARAM or WPARAM is
>> resulting in access violations at the other end.
>>
>> Is there some issue with my pointer conversions? Am I hitting some
>> restriction, or missing some compiler options?
>>
>>
>> It's driving me pretty crazy, after a very nice start to using Haskell.
>>
>> Some "sending" code:
>>
>> Foreign.C.String.withCWString "frustrator" $ \s -> do
>> let wParam = System.Win32.Types.castPtrToUINT s ::
>> System.Win32.Types.WPARAM
>> Graphics.Win32.sendMessage wnd Graphics.Win32.wM_APP wParam >> 0
>>
>> wndProc "receiving" code:
>>
>> | wmsg == Graphics.Win32.wM_APP = do
>> s <- peekCWString $ System.Win32.Types.castUINTToPtr wParam
>> putStrLn s
>> return 0
>>
>> The string will not be seen.
>>
>> Some extra notes:
>>
>> I can get wndProc messages and integral data generally.
>> The pointer values match textually at both ends when "shown" to stdout.
>> At the sending side I can pass the CWString to a regular FFI function
>> call just fine, and castUINTToPtr will give me back a functioning Ptr
>> for that call.
>>
>> I have also tried sending to & receiving from a working C++ program,
>> without success. Access violations are reported when receiving, though
>> again the address matches up. Silence from Haskell as before, when C++
>> is sending.
>>
>> I found someone else having an issue here:
>> http://osdir.com/ml/[email protected]/2009-11/msg00731.html but
>> no solution unfortunately.
>>
>> _______________________________________________
>> Beginners mailing list
>> [email protected]
>> http://www.haskell.org/mailman/listinfo/beginners
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
------------------------------
Message: 4
Date: Wed, 18 Jul 2012 18:28:52 +0200
From: Simon Peter Nicholls <[email protected]>
Subject: Re: [Haskell-beginners] How do I marshall a pointer over
SendMessage LPARAM or WPARAM?
To: [email protected]
Message-ID:
<caeacojj+mu8afpqzpnoe8fphabur6hwhyb6x6qsp+bgeqpw...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
I've tried that without joy. Have reposted over at Haskell cafe, as
per Brent's advice. Thanks to both of you.
On Wed, Jul 18, 2012 at 5:56 PM, Sylvain HENRY <[email protected]> wrote:
> Hi,
>
> [As I've just registered to the list, I don't have the original message.
> That's why I answer to Brent insted of Simon]
>
> By using "withCWString", your CWString may be freed before the message is
> sent. Use "newCWString" instead and "free" in your receiving code.
>
> Cheers
> Sylvain
>
> Le 18/07/2012 17:47, Brent Yorgey a ?crit :
>
>> Hi,
>>
>> Just a meta-comment: this doesn't seem like a beginner question to
>> me. =) Perhaps someone on this list will know the answer (and there's
>> nothing wrong with asking), but for such a specific question you may
>> have better luck posting to haskell-cafe or StackOverflow.
>>
>> -Brent
>>
>> On Wed, Jul 18, 2012 at 03:14:46PM +0200, Simon Peter Nicholls wrote:
>>>
>>> I'm new to Haskell, and have had some good success with FFI so far,
>>> but using Win32's sendMessage to send a pointer in LPARAM or WPARAM is
>>> resulting in access violations at the other end.
>>>
>>> Is there some issue with my pointer conversions? Am I hitting some
>>> restriction, or missing some compiler options?
>>>
>>>
>>> It's driving me pretty crazy, after a very nice start to using Haskell.
>>>
>>> Some "sending" code:
>>>
>>> Foreign.C.String.withCWString "frustrator" $ \s -> do
>>> let wParam = System.Win32.Types.castPtrToUINT s ::
>>> System.Win32.Types.WPARAM
>>> Graphics.Win32.sendMessage wnd Graphics.Win32.wM_APP
>>> wParam 0
>>>
>>> wndProc "receiving" code:
>>>
>>> | wmsg == Graphics.Win32.wM_APP = do
>>> s <- peekCWString $ System.Win32.Types.castUINTToPtr wParam
>>> putStrLn s
>>> return 0
>>>
>>> The string will not be seen.
>>>
>>> Some extra notes:
>>>
>>> I can get wndProc messages and integral data generally.
>>> The pointer values match textually at both ends when "shown" to stdout.
>>> At the sending side I can pass the CWString to a regular FFI function
>>> call just fine, and castUINTToPtr will give me back a functioning Ptr
>>> for that call.
>>>
>>> I have also tried sending to & receiving from a working C++ program,
>>> without success. Access violations are reported when receiving, though
>>> again the address matches up. Silence from Haskell as before, when C++
>>> is sending.
>>>
>>> I found someone else having an issue here:
>>> http://osdir.com/ml/[email protected]/2009-11/msg00731.html but
>>> no solution unfortunately.
>>>
>>> _______________________________________________
>>> Beginners mailing list
>>> [email protected]
>>> http://www.haskell.org/mailman/listinfo/beginners
>>
>> _______________________________________________
>> Beginners mailing list
>> [email protected]
>> http://www.haskell.org/mailman/listinfo/beginners
>
>
>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
------------------------------
Message: 5
Date: Wed, 18 Jul 2012 18:33:58 +0200
From: Sylvain HENRY <[email protected]>
Subject: Re: [Haskell-beginners] How do I marshall a pointer over
SendMessage LPARAM or WPARAM?
To: [email protected]
Message-ID: <[email protected]>
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Are you sending the message to a window of the same process?
-Sylvain
Le 18/07/2012 18:28, Simon Peter Nicholls a ?crit :
> I've tried that without joy. Have reposted over at Haskell cafe, as
> per Brent's advice. Thanks to both of you.
>
> On Wed, Jul 18, 2012 at 5:56 PM, Sylvain HENRY <[email protected]> wrote:
>> Hi,
>>
>> [As I've just registered to the list, I don't have the original message.
>> That's why I answer to Brent insted of Simon]
>>
>> By using "withCWString", your CWString may be freed before the message is
>> sent. Use "newCWString" instead and "free" in your receiving code.
>>
>> Cheers
>> Sylvain
>>
>> Le 18/07/2012 17:47, Brent Yorgey a ?crit :
>>
>>> Hi,
>>>
>>> Just a meta-comment: this doesn't seem like a beginner question to
>>> me. =) Perhaps someone on this list will know the answer (and there's
>>> nothing wrong with asking), but for such a specific question you may
>>> have better luck posting to haskell-cafe or StackOverflow.
>>>
>>> -Brent
>>>
>>> On Wed, Jul 18, 2012 at 03:14:46PM +0200, Simon Peter Nicholls wrote:
>>>> I'm new to Haskell, and have had some good success with FFI so far,
>>>> but using Win32's sendMessage to send a pointer in LPARAM or WPARAM is
>>>> resulting in access violations at the other end.
>>>>
>>>> Is there some issue with my pointer conversions? Am I hitting some
>>>> restriction, or missing some compiler options?
>>>>
>>>>
>>>> It's driving me pretty crazy, after a very nice start to using Haskell.
>>>>
>>>> Some "sending" code:
>>>>
>>>> Foreign.C.String.withCWString "frustrator" $ \s -> do
>>>> let wParam = System.Win32.Types.castPtrToUINT s ::
>>>> System.Win32.Types.WPARAM
>>>> Graphics.Win32.sendMessage wnd Graphics.Win32.wM_APP
>>>> wParam 0
>>>>
>>>> wndProc "receiving" code:
>>>>
>>>> | wmsg == Graphics.Win32.wM_APP = do
>>>> s <- peekCWString $ System.Win32.Types.castUINTToPtr wParam
>>>> putStrLn s
>>>> return 0
>>>>
>>>> The string will not be seen.
>>>>
>>>> Some extra notes:
>>>>
>>>> I can get wndProc messages and integral data generally.
>>>> The pointer values match textually at both ends when "shown" to stdout.
>>>> At the sending side I can pass the CWString to a regular FFI function
>>>> call just fine, and castUINTToPtr will give me back a functioning Ptr
>>>> for that call.
>>>>
>>>> I have also tried sending to & receiving from a working C++ program,
>>>> without success. Access violations are reported when receiving, though
>>>> again the address matches up. Silence from Haskell as before, when C++
>>>> is sending.
>>>>
>>>> I found someone else having an issue here:
>>>> http://osdir.com/ml/[email protected]/2009-11/msg00731.html but
>>>> no solution unfortunately.
>>>>
>>>> _______________________________________________
>>>> Beginners mailing list
>>>> [email protected]
>>>> http://www.haskell.org/mailman/listinfo/beginners
>>> _______________________________________________
>>> Beginners mailing list
>>> [email protected]
>>> http://www.haskell.org/mailman/listinfo/beginners
>>
>>
>>
>> _______________________________________________
>> Beginners mailing list
>> [email protected]
>> http://www.haskell.org/mailman/listinfo/beginners
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
------------------------------
Message: 6
Date: Wed, 18 Jul 2012 19:02:36 +0200
From: Simon Peter Nicholls <[email protected]>
Subject: Re: [Haskell-beginners] How do I marshall a pointer over
SendMessage LPARAM or WPARAM?
To: [email protected]
Message-ID:
<caeacojk0vhqur7fy2ynnnjjpl2ff6z_rajhtgmdt6ftf8lf...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
It's inter-process by design.
I have a small "single instance " C++ program that I'm porting to
Haskell. Once the first instance launched is up and running,
subsequent launches send their command line params through to the
single instance (file names). Similar to when a media player queues
files in a play list.
The most recent extra clue I have is that if I wrap the SendMessage
function with my own C FFI version, my C function can both re-cast and
output the CWString I have sent, and can successfully invoke the real
SendMessage by overriding the CWString with a newly created L"blah"
string. It's just a shame it can't use the original!
My next session will involve poking around at the two strings to learn
why they are treated differently.
On Wed, Jul 18, 2012 at 6:33 PM, Sylvain HENRY <[email protected]> wrote:
> Are you sending the message to a window of the same process?
>
> -Sylvain
>
> Le 18/07/2012 18:28, Simon Peter Nicholls a ?crit :
>
>> I've tried that without joy. Have reposted over at Haskell cafe, as
>> per Brent's advice. Thanks to both of you.
>>
>> On Wed, Jul 18, 2012 at 5:56 PM, Sylvain HENRY <[email protected]> wrote:
>>>
>>> Hi,
>>>
>>> [As I've just registered to the list, I don't have the original message.
>>> That's why I answer to Brent insted of Simon]
>>>
>>> By using "withCWString", your CWString may be freed before the message is
>>> sent. Use "newCWString" instead and "free" in your receiving code.
>>>
>>> Cheers
>>> Sylvain
>>>
>>> Le 18/07/2012 17:47, Brent Yorgey a ?crit :
>>>
>>>> Hi,
>>>>
>>>> Just a meta-comment: this doesn't seem like a beginner question to
>>>> me. =) Perhaps someone on this list will know the answer (and there's
>>>> nothing wrong with asking), but for such a specific question you may
>>>> have better luck posting to haskell-cafe or StackOverflow.
>>>>
>>>> -Brent
>>>>
>>>> On Wed, Jul 18, 2012 at 03:14:46PM +0200, Simon Peter Nicholls wrote:
>>>>>
>>>>> I'm new to Haskell, and have had some good success with FFI so far,
>>>>> but using Win32's sendMessage to send a pointer in LPARAM or WPARAM is
>>>>> resulting in access violations at the other end.
>>>>>
>>>>> Is there some issue with my pointer conversions? Am I hitting some
>>>>> restriction, or missing some compiler options?
>>>>>
>>>>>
>>>>> It's driving me pretty crazy, after a very nice start to using
>>>>> Haskell.
>>>>>
>>>>> Some "sending" code:
>>>>>
>>>>> Foreign.C.String.withCWString "frustrator" $ \s -> do
>>>>> let wParam = System.Win32.Types.castPtrToUINT s ::
>>>>> System.Win32.Types.WPARAM
>>>>> Graphics.Win32.sendMessage wnd Graphics.Win32.wM_APP
>>>>> wParam 0
>>>>>
>>>>> wndProc "receiving" code:
>>>>>
>>>>> | wmsg == Graphics.Win32.wM_APP = do
>>>>> s <- peekCWString $ System.Win32.Types.castUINTToPtr wParam
>>>>> putStrLn s
>>>>> return 0
>>>>>
>>>>> The string will not be seen.
>>>>>
>>>>> Some extra notes:
>>>>>
>>>>> I can get wndProc messages and integral data generally.
>>>>> The pointer values match textually at both ends when "shown" to stdout.
>>>>> At the sending side I can pass the CWString to a regular FFI function
>>>>> call just fine, and castUINTToPtr will give me back a functioning Ptr
>>>>> for that call.
>>>>>
>>>>> I have also tried sending to & receiving from a working C++ program,
>>>>> without success. Access violations are reported when receiving, though
>>>>> again the address matches up. Silence from Haskell as before, when C++
>>>>> is sending.
>>>>>
>>>>> I found someone else having an issue here:
>>>>> http://osdir.com/ml/[email protected]/2009-11/msg00731.html but
>>>>> no solution unfortunately.
>>>>>
>>>>> _______________________________________________
>>>>> Beginners mailing list
>>>>> [email protected]
>>>>> http://www.haskell.org/mailman/listinfo/beginners
>>>>
>>>> _______________________________________________
>>>> Beginners mailing list
>>>> [email protected]
>>>> http://www.haskell.org/mailman/listinfo/beginners
>>>
>>>
>>>
>>>
>>> _______________________________________________
>>> Beginners mailing list
>>> [email protected]
>>> http://www.haskell.org/mailman/listinfo/beginners
>>
>> _______________________________________________
>> Beginners mailing list
>> [email protected]
>> http://www.haskell.org/mailman/listinfo/beginners
>
>
>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
------------------------------
_______________________________________________
Beginners mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 49, Issue 20
*****************************************
