www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - C callback receives bad pointer argument

reply Marco Cosentino <cosentino.ma gmail.com> writes:
Hi,
I'm approaching to D2 with writing a wrapper for the popular JACK2 
client library.

I managed the following troubles:
Translated correctly the C callback style into D delegates types with alias.
Managed some segment faluts happened when not using toStringz() with 
some "strings"
Managed the multithreaded model of jack using __gsharde for global 
variables needed in a callback

Now I'm in trouble again but this time I can't find a solution without 
some help.

Have a look at this code:

// jack.di
alias int function(jack_nframes_t nframes, void *arg) JackProcessCallback;
int jack_set_process_callback (jack_client_t *client, 
JackProcessCallback process_callback, void *arg);

//simple_client.d
int
process (jack_nframes_t nframes, void *arg)
{
     stderr.writeln("process() - data:", arg);
     [...]
}

int main()
{
[...]

     paTestData * data_ptr = &data;
     stderr.writeln("main() - data:",data_ptr);
     jack_set_process_callback (client, &process, data_ptr);

[...]
}

Execution gives:
main() - data:6B6AE0
process() - data:80

of course when trying to access the real data casting to its original 
type I get a segmentation fault.

I think that part of the problem is that the process() callback runs 
into a separate thread. What should I try?

Thanks,
Marco.
Jun 30 2011
next sibling parent bearophile <bearophileHUGS lycos.com> writes:
Marco Cosentino:


 Translated correctly the C callback style into D delegates types with alias.



D has function pointers too.



 Managed some segment faluts happened when not using toStringz() with 
 some "strings"



For this kind of bugs I suggest to use the D type system in a smarter way. With
extern you allowed to give what type you want to the C char* arguments, so you
are free to use another type. An example:


import std.stdio: writeln;
import std.string: toStringz;

typedef const char* ccharPtr;

// example of C function, with smarter string type
extern(C) size_t strlen(ccharPtr str);

ccharPtr toStringz2(string s) {
    return cast(ccharPtr)toStringz(s);
}

void main() {
    string s1 = "this is ";
    string s2 = s1 ~ "just a string";
    writeln(s2.length);
    auto cs = toStringz2(s2);
    writeln(strlen(cs));
}


Now that typedef is deprecated what solution do you suggest instead?

Bye,
bearophile
Jun 30 2011
prev sibling next sibling parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
Try this:

int
process (jack_nframes_t nframes, void *arg)

->

extern(C) int
process (jack_nframes_t nframes, void *arg)
Jun 30 2011
prev sibling next sibling parent reply Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
Try this:

int
process (jack_nframes_t nframes, void *arg)

->

extern(C) int
process (jack_nframes_t nframes, void *arg)
Jun 30 2011
parent reply Marco Cosentino <cosentino.ma gmail.com> writes:
On 01/07/2011 00:30, Andrej Mitrovic wrote:

 Try this:

 int
 process (jack_nframes_t nframes, void *arg)

 ->

 extern(C) int
 process (jack_nframes_t nframes, void *arg)



Thank you Andrej, that solved the problem!

Please can you biefly explain me what happens in the stack when calling 
that function with and without the "extern(C)" declaration?

I think that the D language would benefit from a deep, complete and open 
guide on how to _practically_ interface with C, accounting some popular 
designs cases not just a bunch of trivial cases like using 'printf' and 
a translation table of base types.

Marco
Jul 01 2011
parent Jacob Carlborg <doob me.com> writes:
On 2011-07-01 11:13, Marco Cosentino wrote:

 On 01/07/2011 00:30, Andrej Mitrovic wrote:

 Try this:

 int
 process (jack_nframes_t nframes, void *arg)

 ->

 extern(C) int
 process (jack_nframes_t nframes, void *arg)



 Thank you Andrej, that solved the problem!

 Please can you biefly explain me what happens in the stack when calling
 that function with and without the "extern(C)" declaration?

 I think that the D language would benefit from a deep, complete and open
 guide on how to _practically_ interface with C, accounting some popular
 designs cases not just a bunch of trivial cases like using 'printf' and
 a translation table of base types.

 Marco



What happens without "extern(C)" is that the function will use the D 
calling convention, with it, it will use the C calling convention. The C 
code your interfacing with excepts functions and function pointers with 
the C calling convention.

See:
http://www.digitalmars.com/d/2.0/interfaceToC.html
http://www.digitalmars.com/d/2.0/htomodule.html

-- 
/Jacob Carlborg
Jul 01 2011
prev sibling parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
On 7/1/11, Marco Cosentino <cosentino.ma gmail.com> wrote:

 On 01/07/2011 00:30, Andrej Mitrovic wrote:

 Try this:

 int
 process (jack_nframes_t nframes, void *arg)

 ->

 extern(C) int
 process (jack_nframes_t nframes, void *arg)



 Thank you Andrej, that solved the problem!

 Please can you biefly explain me what happens in the stack when calling
 that function with and without the "extern(C)" declaration?

 I think that the D language would benefit from a deep, complete and open
 guide on how to _practically_ interface with C, accounting some popular
 designs cases not just a bunch of trivial cases like using 'printf' and
 a translation table of base types.

 Marco



This is a good start:
http://en.wikipedia.org/wiki/Calling_convention
Jul 01 2011