Are they some extremely simple tutorials on bindings and
wrappers? Something with lots of code examples.
I don't think it's a subject that warrants a tutorial. There's
not that much to it. Consider:
####
// capi.h
void do_something( const char *str );
// capi.d -- this is a binding
extern( C ) void do_something( const( char )* str );
// capiwrapper.d -- this is a wrapper
void doSomething( string str )
{
import std.string : toStringz;
do_something( str.toStringz() );
}
####
That's all there is to it. The binding allows you to call C
functions from D. The wrapper adds a more convenient D interface
on top of the C function.
Of course, there are numerous details to consider when
implementing a binding (some of which you can see at [1]), but
you generally don't need to worry about them as a user. There are
exceptions, though, when you need to be aware of what's going on.
One of those is when implementing callbacks. All you really need
to understand is that the calling convention of the C functions
may not be the same as that of D functions. That's why the C
function above is decorated with extern( C ) -- it uses the cdecl
calling convention (see [2] for an explanation of different x86
calling conventions). So any callbacks you pass into the API need
to be of the same calling convention, because they are actually
being called on the C side, not the D side.
[1] http://dlang.org/interfaceToC.html
[2] http://en.wikipedia.org/wiki/X86_calling_conventions
