'From Smalltalk/X, Version:5.3.5 on 12-06-2007 at 16:40:04'                     !

ExternalBytes subclass:#ExternalFunctionCallback

	instanceVariableNames:'returnType argumentTypes action'

	classVariableNames:'CallBackRegistry'

	poolDictionaries:''

	category:'System-Support'

!

!ExternalFunctionCallback primitiveDefinitions!

%{

#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!

%{

#define VERBOSE

void

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

{

    int actionIndex = userdata;

    printf("closure_test_fn(userdata=%d resp*=%x)\n", userdata, resp);

    printf("closure_test_fn(arg[0]=%d)\n", *(int *)(args[0]));

    *(ffi_arg *)resp = 1;

}

void

ExternalFunctionCallback__doCall_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);

}

%}

! !

!ExternalFunctionCallback class methodsFor:'examples'!

examples

"

    |cb|

    cb := ExternalFunctionCallback new.

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

    cb generateClosure.

    cb action:[:arg | Transcript showCR:arg].

    cb address.

"

! !

!ExternalFunctionCallback methodsFor:'accessing'!

action:something

    action := something.

! !

!ExternalFunctionCallback methodsFor:'generation'!

address

    self isValid ifFalse:[

	self generate

    ].

    ^ super address

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

!

generate

    |code|

    code := nil

    "Created: / 11-06-2007 / 14:50:57 / cg"

!

generate0

    |code|

    code := #[

		"/ mov ecx, closureIndex

		16rB9

		    16r00  16r00  16r00  16r01

		"/ mov eax, doClosureC

		16rB8

		    16r00  16r00  16r00  16r02

		"/ call *eax

		16rFF  16rD0

		"/ ret

		16rC3

	    ].

    self allocateBytes:(code size).

    "Created: / 11-06-2007 / 15:29:33 / cg"

! !

!ExternalFunctionCallback methodsFor:'private-accessing'!

returnType:aReturnType argumentTypes:argTypes

    returnType := aReturnType.

    argumentTypes := argTypes.

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

! !

!ExternalFunctionCallback methodsFor:'private-generation'!

generateClosure

    |argTypeSymbols returnTypeSymbol failureCode failureInfo returnValue stClass vtOffset

     virtual async unlimitedStack callTypeNumber returnValueClass argValueClass|

    argTypeSymbols := argumentTypes.

    returnTypeSymbol := returnType.

%{  /* STACK: 100000 */

#if 1

#ifdef HAVE_FFI

    ffi_cif __cif;

    ffi_type *__argTypesIncludingThis[MAX_ARGS+1];

    ffi_type **__argTypes = __argTypesIncludingThis;

    ffi_type *__returnType = NULL;

    void *__returnValuePointer;

    static int null = 0;

    int i;

    ffi_abi __callType = FFI_DEFAULT_ABI;

    int __numArgsWanted;

    ffi_closure *pcl;

#define __FAIL__(fcode) \

    { \

	failureCode = fcode; 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);

    }

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

	__returnType = __get_ffi_type_sint();

    } else if (returnTypeSymbol == @symbol(uint)) {

	__returnType = __get_ffi_type_uint();

    } else if (returnTypeSymbol == @symbol(uint8)) {

	__returnType = __get_ffi_type_uint8();

    } else if (returnTypeSymbol == @symbol(uint16)) {

	__returnType = __get_ffi_type_uint16();

    } else if (returnTypeSymbol == @symbol(uint32)) {

	__returnType = __get_ffi_type_uint32();

    } else if (returnTypeSymbol == @symbol(uint64)) {

	__returnType = __get_ffi_type_uint64();

    } else if (returnTypeSymbol == @symbol(sint)) {

	__returnType = __get_ffi_type_sint();

    } else if (returnTypeSymbol == @symbol(sint8)) {

	__returnType = __get_ffi_type_sint8();

    } else if (returnTypeSymbol == @symbol(sint16)) {

	__returnType = __get_ffi_type_sint16();

    } else if (returnTypeSymbol == @symbol(sint32)) {

	__returnType = __get_ffi_type_sint32();

    } else if (returnTypeSymbol == @symbol(sint64)) {

	__returnType = __get_ffi_type_sint64();

    } else if (returnTypeSymbol == @symbol(long)) {

	if (sizeof(long) == 4) {

	   returnTypeSymbol = @symbol(sint32);

	   __returnType = __get_ffi_type_sint32();

	} else if (sizeof(long) == 8) {

	   returnTypeSymbol = @symbol(sint64);

	   __returnType = __get_ffi_type_sint64();

	} else {

	    __FAIL__(@symbol(UnknownReturnType))

	}

    } else if (returnTypeSymbol == @symbol(ulong)) {

	if (sizeof(long) == 4) {

	   returnTypeSymbol = @symbol(uint32);

	   __returnType = __get_ffi_type_uint32();

	}else if (sizeof(long) == 8) {

	   returnTypeSymbol = @symbol(uint64);

	   __returnType = __get_ffi_type_uint64();

	} else {

	    __FAIL__(@symbol(UnknownReturnType))

	}

    } else if (returnTypeSymbol == @symbol(bool)) {

	__returnType = __get_ffi_type_uint();

    } else if (returnTypeSymbol == @symbol(float)) {

	__returnType = __get_ffi_type_float();

    } else if (returnTypeSymbol == @symbol(double)) {

	__returnType = __get_ffi_type_double();

    } else if (returnTypeSymbol == @symbol(void)) {

	__returnType = __get_ffi_type_void();

    } else if ((returnTypeSymbol == @symbol(pointer))

	       || (returnTypeSymbol == @symbol(handle))

	       || (returnTypeSymbol == @symbol(charPointer))

	       || (returnTypeSymbol == @symbol(bytePointer))

	       || (returnTypeSymbol == @symbol(floatPointer))

	       || (returnTypeSymbol == @symbol(doublePointer))

	       || (returnTypeSymbol == @symbol(intPointer))

	       || (returnTypeSymbol == @symbol(shortPointer))

	       || (returnTypeSymbol == @symbol(wcharPointer))) {

	__returnType = __get_ffi_type_pointer();

    } else {

	if (__isSymbol(returnTypeSymbol)

	 && ((returnValueClass = __GLOBAL_GET(returnTypeSymbol)) != nil)) {

	    if (! __isBehaviorLike(returnValueClass)) {

		__FAIL__(@symbol(NonBehaviorReturnType))

	    }

	    if (! __qIsSubclassOfExternalAddress(returnValueClass)) {

		__FAIL__(@symbol(NonExternalAddressReturnType))

	    }

	    __returnType = __get_ffi_type_pointer();

	    returnTypeSymbol = @symbol(pointer);

	} else {

	    __FAIL__(@symbol(UnknownReturnType))

	}

    }

    /*

     * setup arg-buffers

     */

    for (i=0; i<__numArgsWanted; i++) {

	ffi_type *thisType;

	void *argValuePtr;

	OBJ typeSymbol;

	failureInfo = __mkSmallInteger(i+1);   /* in case there is one */

	typeSymbol = __ArrayInstPtr(argTypeSymbols)->a_element[i];

	if (typeSymbol == @symbol(handle)) {

	    typeSymbol = @symbol(pointer);

	} else if (typeSymbol == @symbol(voidPointer)) {

	    typeSymbol = @symbol(pointer);

	}

	if (typeSymbol == @symbol(long)) {

	    if (sizeof(long) == sizeof(int)) {

		typeSymbol = @symbol(sint);

	    } else {

		if (sizeof(long) == 4) {

		    typeSymbol = @symbol(sint32);

		} else if (sizeof(long) == 8) {

		    typeSymbol = @symbol(sint64);

		}

	    }

	}

	if (typeSymbol == @symbol(ulong)) {

	    if (sizeof(unsigned long) == sizeof(unsigned int)) {

		typeSymbol = @symbol(uint);

	    } else {

		if (sizeof(long) == 4) {

		    typeSymbol = @symbol(uint32);

		} else if (sizeof(long) == 8) {

		    typeSymbol = @symbol(uint64);

		}

	    }

	}

	if (typeSymbol == @symbol(int)) {

	    thisType = __get_ffi_type_sint();

	} else if (typeSymbol == @symbol(uint)) {

	    thisType = __get_ffi_type_uint();

	} else if (typeSymbol == @symbol(uint8)) {

	    thisType = __get_ffi_type_uint8();

	} else if (typeSymbol == @symbol(sint8)) {

	    thisType = __get_ffi_type_sint8();

	} else if (typeSymbol == @symbol(uint16)) {

	    thisType = __get_ffi_type_uint16();

	} else if (typeSymbol == @symbol(sint16)) {

	    thisType = __get_ffi_type_sint16();

	} else if ((typeSymbol == @symbol(uint32)) || (typeSymbol == @symbol(sint32))) {

	    thisType = __get_ffi_type_uint32();

	} else if (typeSymbol == @symbol(float)) {

	    thisType = __get_ffi_type_float();

	} else if (typeSymbol == @symbol(double)) {

	    thisType = __get_ffi_type_double();

	} else if (typeSymbol == @symbol(void)) {

	    thisType = __get_ffi_type_void();

	} else if (typeSymbol == @symbol(charPointer)) {

	    thisType = __get_ffi_type_pointer();

	} else if (typeSymbol == @symbol(floatPointer)) {

	    thisType = __get_ffi_type_pointer();

	} else if (typeSymbol == @symbol(doublePointer)) {

	    thisType = __get_ffi_type_pointer();

	} else if (typeSymbol == @symbol(pointer)) {

commonPointerTypeArg: ;

	    thisType = __get_ffi_type_pointer();

	} else if (typeSymbol == @symbol(bool)) {

	    thisType = __get_ffi_type_uint();

	} else if (__isSymbol(typeSymbol)

	     && ((argValueClass = __GLOBAL_GET(typeSymbol)) != nil)) {

	    if (! __isBehaviorLike(argValueClass)) {

		__FAIL__(@symbol(NonBehaviorArgumentType))

	    }

	    if (! __qIsSubclassOfExternalAddress(argValueClass)) {

		__FAIL__(@symbol(NonExternalAddressArgumentType))

	    }

	    goto commonPointerTypeArg; /* sorry */

	} else {

	    __FAIL__(@symbol(UnknownArgumentType))

	}

	__argTypes[i] = thisType;

    }

    failureInfo = nil;

    __callType = FFI_DEFAULT_ABI;

    if (callTypeNumber != nil) {

#ifdef CALLTYPE_FFI_STDCALL

	if (callTypeNumber == @global(ExternalLibraryFunction:CALLTYPE_API)) {

	    __callType = CALLTYPE_FFI_STDCALL;

	}

#endif

#ifdef CALLTYPE_FFI_V8

	if (callTypeNumber == @global(ExternalLibraryFunction:CALLTYPE_V8)) {

	    __callType = CALLTYPE_FFI_V8;

	}

#endif

#ifdef CALLTYPE_FFI_V9

	if (callTypeNumber == @global(ExternalLibraryFunction:CALLTYPE_V9)) {

	    __callType = CALLTYPE_FFI_V9;

	}

#endif

#ifdef CALLTYPE_FFI_UNIX64

	if (callTypeNumber == @global(ExternalLibraryFunction:CALLTYPE_UNIX64)) {

	    __callType = CALLTYPE_FFI_UNIX64;

	}

#endif

    }

# ifdef VERBOSE

    printf("prep_cif cif-ptr=%x\n", &__cif);

# endif

    if (ffi_prep_cif(&__cif, __callType, __numArgsWanted, __returnType, __argTypesIncludingThis) != FFI_OK) {

	__FAIL__(@symbol(FFIPrepareFailed))

    }

    pcl = (ffi_closure *) malloc(sizeof(ffi_closure));

# ifdef VERBOSE

    printf("closure is 0x%x (%d bytes)\n", pcl, sizeof(ffi_closure));

# endif

    if (ffi_prep_closure(pcl, &__cif, ExternalFunctionCallback__closure_test_fn, (void *) 3 /* userdata */) != FFI_OK) {

	__FAIL__(@symbol(FFIPrepareClosureFailed))

    }

# ifdef VERBOSE

    printf("pcl->cif is 0x%x\n", pcl->cif);

    printf("pcl->fun is 0x%x\n", pcl->fun);

    printf("pcl code is %02x %02x %02x %02x\n", ((char *)pcl)[0],((char *)pcl)[1],((char *)pcl)[2],((char *)pcl)[3]);

    printf("            %02x %02x %02x %02x\n", ((char *)pcl)[4],((char *)pcl)[5],((char *)pcl)[6],((char *)pcl)[7]);

    printf("            %02x %02x %02x %02x\n", ((char *)pcl)[8],((char *)pcl)[9],((char *)pcl)[10],((char *)pcl)[11]);

    printf("            %02x %02x %02x %02x\n", ((char *)pcl)[12],((char *)pcl)[13],((char *)pcl)[14],((char *)pcl)[15]);

#endif

    ExternalFunctionCallback__doCall_closure((INTFUNC)pcl);

    free(pcl);

#else /* no FFI support */

    __FAIL__(@symbol(FFINotSupported));

#endif /* HAVE_FFI */

#endif /* 0 */

getOutOfHere: ;

%}.

    failureCode notNil ifTrue:[

	self primitiveFailed:(failureCode->failureInfo).   "see failureCode and failureInfo for details"

	^ nil

    ].

    "Created: / 11-06-2007 / 21:53:02 / cg"

! !