"

 COPYRIGHT (c) 2007 by eXept Software AG

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

ExternalFunction subclass:#ExternalFunctionCallback

	instanceVariableNames:'returnType argumentTypes flags action'

	classVariableNames:'CallBackRegistry Verbose'

	poolDictionaries:''

	category:'System-Support'

!

!ExternalFunctionCallback primitiveDefinitions!

%{

#include <stdio.h>

#ifdef HAVE_FFI

# include <ffi.h>

# define MAX_ARGS    128

extern ffi_type *__get_ffi_type_sint();

extern ffi_type *__get_ffi_type_sint8();

extern ffi_type *__get_ffi_type_sint16();

extern ffi_type *__get_ffi_type_sint32();

extern ffi_type *__get_ffi_type_sint64();

extern ffi_type *__get_ffi_type_uint();

extern ffi_type *__get_ffi_type_uint8();

extern ffi_type *__get_ffi_type_uint16();

extern ffi_type *__get_ffi_type_uint32();

extern ffi_type *__get_ffi_type_uint64();

extern ffi_type *__get_ffi_type_float();

extern ffi_type *__get_ffi_type_double();

extern ffi_type *__get_ffi_type_void();

extern ffi_type *__get_ffi_type_pointer();

#endif

%}

! !

!ExternalFunctionCallback primitiveFunctions!

%{

#ifdef HAVE_FFI

#define xxVERBOSE

void

ExternalFunctionCallback__closure_wrapper_fn(ffi_cif* cif, void* resp, void** args, void* userdata)

{

    int actionIndex = (int)userdata;

    int i;

    OBJ st_argVector = nil;

    OBJ st_actionVector, st_callBack = nil, st_result;

    OBJFUNC code;

    ffi_type *retType;

    INT sintResult;

    unsigned INT uintResult;

    float floatResult;

    double doubleResult;

    if (@global(ExternalFunctionCallback:Verbose) == true) {

	fprintf(stderr, "ExternalFunctionCallback(wrapper): actionIndex=%d resp*=%x\n", actionIndex, resp);

	fflush(stderr);

	fprintf(stderr, "ExternalFunctionCallback(wrapper): nargs=%d\n", cif->nargs);

	fflush(stderr);

    }

    st_argVector = __ARRAY_NEW_INT(cif->nargs);

    for (i=0; i<cif->nargs; i++) {

	ffi_type *argType;

	OBJ st_arg = nil;

	__PROTECT__(st_argVector);

	argType = cif->arg_types[i];

	if (argType == __get_ffi_type_sint()) {

	    st_arg = __MKINT( *(int *)(args[i]) );

	} else if (argType == __get_ffi_type_uint()) {

	    st_arg = __MKUINT( *(unsigned int *)(args[i]) );

	} else if (argType == __get_ffi_type_uint8()) {

	    st_arg = __MKSMALLINT( *(unsigned char *)(args[i]) );

	} else if (argType == __get_ffi_type_sint8()) {

	    st_arg = __MKSMALLINT( *(char *)(args[i]) );

	} else if (argType == __get_ffi_type_uint16()) {

	    st_arg = __MKSMALLINT( *(unsigned short *)(args[i]) );

	} else if (argType == __get_ffi_type_sint16()) {

	    st_arg = __MKSMALLINT( *(short *)(args[i]) );

	} else if (argType == __get_ffi_type_uint32()) {

	    st_arg = __MKUINT( *(unsigned int *)(args[i]) );

	} else if (argType == __get_ffi_type_sint32()) {

	    st_arg = __MKINT( *(int *)(args[i]) );

	} else if (argType == __get_ffi_type_float()) {

	    st_arg = __MKSFLOAT( *(float *)(args[i]) );

	} else if (argType == __get_ffi_type_double()) {

	    st_arg = __MKFLOAT( *(double *)(args[i]) );

	} else if (argType == __get_ffi_type_pointer()) {

	    st_arg = __MKEXTERNALADDRESS( *(void **)(args[i]) );

	} else {

	    if (@global(ExternalFunctionCallback:Verbose) == true) {

		fprintf(stderr, "ExternalFunctionCallback(wrapper): invalid argument type %d - arg %d\n", argType, i);

	    }

	}

	__UNPROTECT__(st_argVector);

	if (@global(ExternalFunctionCallback:Verbose) == true) {

	    fprintf(stderr, "ExternalFunctionCallback(wrapper): st-arg for %x is %x\n", *(unsigned int *)(args[i]), st_arg);

	}

	__ArrayInstPtr(st_argVector)->a_element[i] = st_arg; __STORE(st_argVector, st_arg);

    }

    /* the action ... */

    st_actionVector = @global(ExternalFunctionCallback:CallBackRegistry);

    if (st_actionVector != nil) {

	OBJ cls = __Class(st_actionVector);

	if ((cls == Array) || (cls==WeakArray)) {

	    actionIndex += /* nInstVars */ __intVal(__ClassInstPtr(cls)->c_ninstvars);

	    if (__arraySize(st_actionVector) <= actionIndex) {

		st_callBack = __ArrayInstPtr(st_actionVector)->a_element[actionIndex-1];

	    }

	}

    }

    if (st_callBack == nil) {

	if (@global(ExternalFunctionCallback:Verbose) == true) {

	    fprintf(stderr, "ExternalFunctionCallback(wrapper): ignored nil callback\n");

	}

	*(void **)resp = 0;

	return;

    }

    {

	static struct inlineCache value_snd = _DUMMYILC1;

	if (@global(ExternalFunctionCallback:Verbose) == true) {

	    fprintf(stderr, "ExternalFunctionCallback(wrapper): sending value: to %x..\n", st_callBack);

	}

	st_result = _SEND1(st_callBack, @symbol(callFromCWith:), nil, &value_snd, st_argVector);

	if (@global(ExternalFunctionCallback:Verbose) == true) {

	    fprintf(stderr, "ExternalFunctionCallback(wrapper): result is %x\n", st_result);

	}

    }

    retType = cif->rtype;

    if (st_result == true) {

	sintResult = uintResult = 1;

    } else if (st_result == false) {

	sintResult = uintResult = 0;

    } else if (st_result == nil) {

	sintResult = uintResult = 0;

    } else {

	sintResult = __signedLongIntVal(st_result);

	uintResult = __unsignedLongIntVal(st_result);

    }

    if (retType == __get_ffi_type_sint()) {

	*(int *)resp = sintResult;

    } else if (retType == __get_ffi_type_uint()) {

	*(int *)resp = uintResult;

    } else if (retType == __get_ffi_type_uint8()) {

	*(unsigned char *)resp = uintResult;

    } else if (retType == __get_ffi_type_sint8()) {

	*(char *)resp = sintResult;

    } else if (retType == __get_ffi_type_uint16()) {

	*(unsigned short *)resp = uintResult;

    } else if (retType == __get_ffi_type_sint16()) {

	*(short *)resp = sintResult;

    } else if (retType == __get_ffi_type_uint32()) {

	*(int *)resp = uintResult;

    } else if (retType == __get_ffi_type_sint32()) {

	*(int *)resp = sintResult;

    } else if (retType == __get_ffi_type_float()) {

	if (__isFloat(st_result)) {

	    *(float *)resp = (float)__floatVal(st_result);

	} else {

	    if (__isShortFloat(st_result)) {

		*(float *)resp = __shortFloatVal(st_result);

	    } else {

		*(float *)resp = (float)sintResult;

	    }

	}

    } else if (retType == __get_ffi_type_double()) {

	if (__isFloat(st_result)) {

	    *(double *)resp = __floatVal(st_result);

	} else {

	    if (__isShortFloat(st_result)) {

		*(double *)resp = (double)__shortFloatVal(st_result);

	    } else {

		*(double *)resp = (double)sintResult;

	    }

	}

    } else if (retType == __get_ffi_type_pointer()) {

	*(void **)resp = (void *)__externalAddressVal( st_result );

    } else {

	if (@global(ExternalFunctionCallback:Verbose) == true) {

	    fprintf(stderr, "ExternalFunctionCallback(wrapper): invalid result type %d\n", retType, i);

	}

	*(void **)resp = 0;

    }

}

void

ExternalFunctionCallback__test_call_closure(INTFUNC f)

{

    int result = 0;

    printf("doCall_closure: calling closure %x(123)...\n", f);

    result = (*f)(123);

    printf("doCall_closure: back; result is %x...\n", result);

}

#endif /* HAVE_FFI */

%}

! !

!ExternalFunctionCallback class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 2007 by eXept Software AG

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    an ExternalFunctionCallback wraps a block into a C-callable function;

    i.e. it creates a closure, which as seen from C-code looks like an ordinary

    function pointer, but when invoked evaluates a smalltalk block.

    A callback is created with:

       cb := ExternalFunctionCallback new.

    the arguments (as passed from the C-caller into ST)

    and the returnValue (from ST to the C-caller) are specified with:

       cb returnType:#bool argumentTypes:#(uint).

    Then, the code is generated with:

       cb generateClosure.

    After that, the callBack-functions address can be aquired with:

       cb address.  'can be passed to C'.

    and handed out to C. (you can also hand out the callBack directly - as it is a subclass of

    ExternalBytes.

    The actual action of the callback can be changed (at any time later) with:

	cb action:[:args | Transcript showCR:args. true].

    Eventually, the callback should be released:

	cb release.

    [author:]

	Claus Gittinger

"

!

examples

"

    |cb|

    cb := ExternalFunctionCallback new.

    cb returnType:#bool argumentTypes:#(uint).

    cb beCallTypeWINAPI.

    cb generateClosure.

    cb action:[:args | Transcript showCR:args. true].

    cb code.  'can be passed to C'.

    ExternalFunctionCallback testCall:cb withArgument:123.

    cb action:[:args | Transcript show:'hello '; showCR:args. true].

    ExternalFunctionCallback testCall:cb withArgument:123.

    cb release

"

! !

!ExternalFunctionCallback class methodsFor:'constants'!

callTypeAPI

    ^ ExternalLibraryFunction callTypeAPI

!

callTypeC

    ^ ExternalLibraryFunction callTypeC

!

callTypeCDecl

    ^ ExternalLibraryFunction callTypeCDecl

!

callTypeMASK

    ^ ExternalLibraryFunction callTypeMASK

!

callTypeOLE

    ^ ExternalLibraryFunction callTypeOLE

! !

!ExternalFunctionCallback class methodsFor:'helpers'!

closureIndexFor:aCallBack

    CallBackRegistry isNil ifTrue:[

	CallBackRegistry := WeakArray with:aCallBack.

    ] ifFalse:[

	CallBackRegistry := CallBackRegistry copyWith:aCallBack.

    ].

    ^ CallBackRegistry size.

!

testCall:aCallback withArgument:arg

    "a simple test, if I can be called"

%{

    INTFUNC f = __externalAddressVal(aCallback);

    INT result;

    void *c_arg = 0;

    if (__isSmallInteger(arg)) {

	c_arg = (void *)(__intVal(arg));

    } else {

	if (arg == true) {

	    c_arg = (void *)1;

	} else {

	   if (__isString(arg)) {

		c_arg = (void *)__stringVal(arg);

	   }

	}

    }

    fprintf(stderr, "ExternalFunctionCallback: calling callBack %x(%x)\n", f, c_arg);

    result = (*f)(c_arg);

    fprintf(stderr, "ExternalFunctionCallback: result from callBack is %x\n", result);

%}

! !

!ExternalFunctionCallback methodsFor:'accessing'!

action:aBlock

    "set the action-block, to be evaluated when C calls me.

     The C-arguments will be passed as arguments to the block.

     The value returned by the block will be returned to the C-caller."

    action := aBlock.

!

beCallTypeAPI

    flags := (flags ? 0) bitOr: (self class callTypeAPI).

    "Created: / 01-08-2006 / 15:12:40 / cg"

!

beCallTypeC

    flags := (flags ? 0) bitOr: (self class callTypeC).

    "Created: / 01-08-2006 / 15:12:40 / cg"

!

beCallTypeOLE

    flags := (flags ? 0) bitOr: (self class callTypeOLE).

    "Created: / 01-08-2006 / 15:12:40 / cg"

!

beCallTypeWINAPI

    self beCallTypeAPI

    "Modified: / 01-08-2006 / 15:14:02 / cg"

!

callTypeNumber

    ^ (flags ? 0) bitAnd: (self class callTypeMASK)

    "Created: / 01-08-2006 / 15:12:10 / cg"

!

isCallTypeAPI

    ^ ((flags ? 0) bitAnd: (self class callTypeMASK)) == (self class callTypeAPI)

    "Created: / 01-08-2006 / 15:21:16 / cg"

!

isCallTypeC

    ^ ((flags ? 0) bitAnd: (self class callTypeMASK)) == (self class callTypeC)

!

isCallTypeOLE

    ^ ((flags ? 0) bitAnd: (self class callTypeMASK)) == (self class callTypeOLE)

! !

!ExternalFunctionCallback methodsFor:'callback'!

callFromCWith:argList

    "invoked by the C-code, to which we have given out the code-ptr.

     Because this is evaluated from C, we probably should not block or abort or do

     any other things which confuse C

     (its probably a good idea to write something into a queue here)"

    action notNil ifTrue:[

	^ action valueWithArguments:argList

    ].

    ^ nil

! !

!ExternalFunctionCallback methodsFor:'generation'!

code

    self hasCode ifFalse:[

	self generate

    ].

    ^ super code

    "Created: / 11-06-2007 / 15:53:00 / cg"

! !

!ExternalFunctionCallback methodsFor:'private-accessing'!

returnType:aReturnType argumentTypes:argTypes

    "see generateClosure for valid return types"

    returnType := aReturnType.

    argumentTypes := argTypes.

    "Created: / 11-06-2007 / 15:52:01 / cg"

    "Modified: / 19-09-2007 / 18:14:59 / cg"

! !

!ExternalFunctionCallback methodsFor:'private-generation'!

generateClosure

    |argTypeSymbols returnTypeSymbol failureCode failureInfo

     callTypeNumber returnValueClass argValueClass callBackIndex|

    argTypeSymbols := argumentTypes.

    returnTypeSymbol := returnType.

    callBackIndex := self class closureIndexFor:self.

    callTypeNumber := self callTypeNumber.

%{

#ifdef HAVE_FFI

    ffi_cif *pcif;

    ffi_type *__returnType = NULL;

    static int null = 0;

    int i;

    ffi_abi __callType = FFI_DEFAULT_ABI;

    int __numArgsWanted;

    struct closurePlusCIF {

	ffi_closure closure;

	ffi_cif cif;

	ffi_type *argTypes[MAX_ARGS];

    } *closurePlusCIFp;

    ffi_closure *pcl;

    ffi_cif *cif;

    ffi_type **argTypePtrs;

    closurePlusCIFp = (struct closurePlusCIF *) malloc(sizeof(struct closurePlusCIF));

    cif = &(closurePlusCIFp->cif);

    argTypePtrs = closurePlusCIFp->argTypes;

    pcl = &(closurePlusCIFp->closure);

#define __FAIL__(fcode) \

    { \

	failureCode = fcode; free(closurePlusCIFp); goto getOutOfHere; \

    }

    if (argTypeSymbols == nil) {

	__numArgsWanted = 0;

    } else if (__isArray(argTypeSymbols)) {

	__numArgsWanted = __arraySize(argTypeSymbols);

    } else {

	__FAIL__(@symbol(BadArgumentTypeVector))

    }

    if (__numArgsWanted > MAX_ARGS) {

	__FAIL__(@symbol(TooManyArguments))

    }

    /*

     * validate the return type

     */

    if (returnTypeSymbol == @symbol(voidPointer)) {

	returnTypeSymbol = @symbol(handle);

    }