hg/stx-libbasic: comparison ExternalLibraryFunction.st

equal deleted inserted replaced

-:58ad30334e84
+:290463096ff5
 extern ffi_type *__get_ffi_type_double();
 extern ffi_type *__get_ffi_type_void();
 extern ffi_type *__get_ffi_type_pointer();
 #else
-#error "HAVE_FFI not defined!"
+# error "HAVE_FFI not defined!"
 #endif
 %}
 ! !
 documentation
 "
 instances of me are used to interface to external library functions (as found in a dll/shared object).
 Inside a method, when a special external-call pragma such as:
-<api: bool MessageBeep(uint)>
+	<api: bool MessageBeep(uint)>
 is encountered by the parser, the compiler generates a call via
-<correspondingExternalLibraryFunctionObject> invokeWithArguments: argumentArray.
+	<correspondingExternalLibraryFunctionObject> invokeWithArguments: argumentArray.
 In the invoke method, the library is checked to be loaded (and loaded if not already),
 the arguments are converted to C and pushed onto the C-stack, the function is called,
 and finally, the return value is converted back from C to a smalltalk object.
 The parser supports the call-syntax of various other smalltalk dialects:
-Squeak / ST-X:
+	Squeak / ST-X:
-<cdecl:   [async] [virtual|nonVirtual][const] returnType functionNameStringOrIndex ( argType1..argTypeN ) module: moduleName >
+	    <cdecl:   [async] [virtual|nonVirtual][const] returnType functionNameStringOrIndex ( argType1..argTypeN ) module: moduleName >
-<apicall: [async] [virtual|nonVirtual][const] returnType functionNameStringOrIndex ( argType1..argTypeN ) module: moduleName >
+	    <apicall: [async] [virtual|nonVirtual][const] returnType functionNameStringOrIndex ( argType1..argTypeN ) module: moduleName >
-Dolphin:
+	Dolphin:
-<stdcall: [virtual|nonVirtual][const] returnType functionNameStringOrIndex argType1..argTypeN>
+	    <stdcall: [virtual|nonVirtual][const] returnType functionNameStringOrIndex argType1..argTypeN>
-<cdecl:   [virtual|nonVirtual][const] returnType functionNameStringOrIndex argType1..argTypeN>
+	    <cdecl:   [virtual|nonVirtual][const] returnType functionNameStringOrIndex argType1..argTypeN>
-ST/V:
+	ST/V:
-<api: functionName argType1 .. argTypeN returnType>
+	    <api: functionName argType1 .. argTypeN returnType>
-<ccall: functionName argType1 .. argTypeN returnType>
+	    <ccall: functionName argType1 .. argTypeN returnType>
-<ole: vFunctionIndex argType1 .. argTypeN returnType>
+	    <ole: vFunctionIndex argType1 .. argTypeN returnType>
-VisualWorks:
+	VisualWorks:
-<c: ...>
+	    <c: ...>
-<c: #define NAME value>
+	    <c: #define NAME value>
 "
 !
 example
 "
-[exBegin]
+								[exBegin]
-|f|
+	|f|
-f := ExternalLibraryFunction new.
+	f := ExternalLibraryFunction new.
-f beCallTypeWINAPI.
+	f beCallTypeWINAPI.
-f name:'MessageBeep'
+	f name:'MessageBeep'
-module:'user32.dll'
+	  module:'user32.dll'
-returnType:#boolean
+	  returnType:#boolean
-argumentTypes:#(uint).
+	  argumentTypes:#(uint).
-f invokeWith:1.
+	f invokeWith:1.
-[exEnd]
+								[exEnd]
 Synchronous vs. Asynchronous calls:
 by default, foreign function calls are synchronous, effectively blocking the whole ST/X system
 (that is by purpose,�because most C-code is not prepared for being interrupted, and also, normal
 code is not prepared for a garbage collector to move objects around, while another C thread might
 access the data...).
 Therefore, the following will block all ST/X activity for 10 seconds
 (try interacting with the launcher while the Sleep is performing):
-[exBegin]
+								[exBegin]
-|f|
+	|f|
-f := ExternalLibraryFunction new.
+	f := ExternalLibraryFunction new.
-f beCallTypeWINAPI.
+	f beCallTypeWINAPI.
-f name:'Sleep'
+	f name:'Sleep'
-module:'kernel32.dll'
+	  module:'kernel32.dll'
-returnType:#void
+	  returnType:#void
-argumentTypes:#(uint).
+	  argumentTypes:#(uint).
-f invokeWith:10000.
+	f invokeWith:10000.
-[exEnd]
+								[exEnd]
 if you know what you do and you do not pass any possibly moving objects (such as strings) as argument,
 the call can be made asynchronous. In that case, ONLY the calling thread will be blocked; all other smalltalk
 threads wil continue to execute.
 (try interacting now with the launcher while the Sleep is performing):
-[exBegin]
+								[exBegin]
-|f|
+	|f|
-f := ExternalLibraryFunction new.
+	f := ExternalLibraryFunction new.
-f beCallTypeWINAPI.
+	f beCallTypeWINAPI.
-f beAsync.
+	f beAsync.
-f name:'Sleep'
+	f name:'Sleep'
-module:'kernel32.dll'
+	  module:'kernel32.dll'
-returnType:#void
+	  returnType:#void
-argumentTypes:#(uint).
+	  argumentTypes:#(uint).
-f invokeWith:10000.
+	f invokeWith:10000.
-[exEnd]
+								[exEnd]
 "
 ! !
 !ExternalLibraryFunction class methodsFor:'instance creation'!
 !
 dllMapping
 "allows for dll's to be replaced,
 for example, if you want to use the mozilla sqlite dll
-C:\Program Files\Mozilla Firefox\mozsqlite3.dll
+	C:\Program Files\Mozilla Firefox\mozsqlite3.dll
 for the sqlite3, execute:
-ExternalLibraryFunction
+	ExternalLibraryFunction
-dllMapping at:'sqlite3'
+	    dllMapping at:'sqlite3'
-put: 'C:\Program Files\Mozilla Firefox\mozsqlite3.dll'
+	    put: 'C:\Program Files\Mozilla Firefox\mozsqlite3.dll'
 "
 DllMapping isNil ifTrue:[
-DllMapping := Dictionary new.
+	DllMapping := Dictionary new.
 ].
 ^ DllMapping
 "Created: / 10-04-2012 / 12:21:45 / cg"
 !
 initialize
 "using inline access to corresponding c--defines to avoid duplicate places of knowledge"
 DLLPATH isNil ifTrue:[
-DLLPATH := #('.').
+	DLLPATH := #('.').
-FLAG_VIRTUAL := %{ __MKSMALLINT(__EXTL_FLAG_VIRTUAL) %}.                "/ a virtual c++ call
+	FLAG_VIRTUAL := %{ __MKSMALLINT(__EXTL_FLAG_VIRTUAL) %}.                "/ a virtual c++ call
-FLAG_NONVIRTUAL := %{ __MKSMALLINT(__EXTL_FLAG_NONVIRTUAL) %}.          "/ a non-virtual c++ call
+	FLAG_NONVIRTUAL := %{ __MKSMALLINT(__EXTL_FLAG_NONVIRTUAL) %}.          "/ a non-virtual c++ call
-FLAG_UNLIMITEDSTACK := %{ __MKSMALLINT(__EXTL_FLAG_UNLIMITEDSTACK) %}.  "/ unlimitedstack under unix
+	FLAG_UNLIMITEDSTACK := %{ __MKSMALLINT(__EXTL_FLAG_UNLIMITEDSTACK) %}.  "/ unlimitedstack under unix
-FLAG_ASYNC := %{ __MKSMALLINT(__EXTL_FLAG_ASYNC) %}.                    "/ async under win32
+	FLAG_ASYNC := %{ __MKSMALLINT(__EXTL_FLAG_ASYNC) %}.                    "/ async under win32
-FLAG_RETVAL_IS_CONST := %{ __MKSMALLINT(__EXTL_FLAG_RETVAL_IS_CONST) %}."/ return value is not to be registered for finalization
+	FLAG_RETVAL_IS_CONST := %{ __MKSMALLINT(__EXTL_FLAG_RETVAL_IS_CONST) %}."/ return value is not to be registered for finalization
-CALLTYPE_API := %{ __MKSMALLINT(__EXTL_CALLTYPE_API) %}.                "/ WINAPI-call (win32 only)
+	CALLTYPE_API := %{ __MKSMALLINT(__EXTL_CALLTYPE_API) %}.                "/ WINAPI-call (win32 only)
-CALLTYPE_C := %{ __MKSMALLINT(__EXTL_CALLTYPE_C) %}.                    "/ regular C-call (the default)
+	CALLTYPE_C := %{ __MKSMALLINT(__EXTL_CALLTYPE_C) %}.                    "/ regular C-call (the default)
-CALLTYPE_V8 := %{ __MKSMALLINT(__EXTL_CALLTYPE_V8) %}.                  "/ v8 call (sparc only)
+	CALLTYPE_V8 := %{ __MKSMALLINT(__EXTL_CALLTYPE_V8) %}.                  "/ v8 call (sparc only)
-CALLTYPE_V9 := %{ __MKSMALLINT(__EXTL_CALLTYPE_V9) %}.                  "/ v9 call (sparc only)
+	CALLTYPE_V9 := %{ __MKSMALLINT(__EXTL_CALLTYPE_V9) %}.                  "/ v9 call (sparc only)
-CALLTYPE_UNIX64 := %{ __MKSMALLINT(__EXTL_CALLTYPE_UNIX64) %}.          "/ unix64 call (alpha only)
+	CALLTYPE_UNIX64 := %{ __MKSMALLINT(__EXTL_CALLTYPE_UNIX64) %}.          "/ unix64 call (alpha only)
-CALLTYPE_MASK := %{ __MKSMALLINT(__EXTL_CALLTYPE_MASK) %}.
+	CALLTYPE_MASK := %{ __MKSMALLINT(__EXTL_CALLTYPE_MASK) %}.
 ].
 "
 self initialize
 "
 !ExternalLibraryFunction methodsFor:'printing'!
 printOn:aStream
 aStream nextPutAll:'<'.
 self isCallTypeAPI ifTrue:[
-'API:' printOn:aStream.
+	'API:' printOn:aStream.
 ] ifFalse:[
-self isCallTypeOLE ifTrue:[
+	self isCallTypeOLE ifTrue:[
-'OLE:' printOn:aStream.
+	    'OLE:' printOn:aStream.
-] ifFalse:[
+	] ifFalse:[
-self isCallTypeC ifTrue:[
+	    self isCallTypeC ifTrue:[
-'C:' printOn:aStream.
+		'C:' printOn:aStream.
-] ifFalse:[
+	    ] ifFalse:[
-self error.
+		self error.
-].
+	    ].
-].
+	].
 ].
 aStream nextPutAll:' '.
 name printOn:aStream.
 moduleName notNil ifTrue:[
-aStream nextPutAll:' module:'.
+	aStream nextPutAll:' module:'.
-moduleName printOn:aStream.
+	moduleName printOn:aStream.
 ].
 aStream nextPutAll:'>'.
 "Modified: / 25-09-2012 / 12:06:14 / cg"
 ! !
 I.e. retrieve the module handle and the code pointer."
 |handle moduleNameUsed functionName|
 name isNumber ifTrue:[
-self isCPPFunction ifTrue:[
+	self isCPPFunction ifTrue:[
-"/ no need to load a dll.
+	    "/ no need to load a dll.
-^ self
+	    ^ self
-]
+	]
 ].
 "/ in some other smalltalks, there is no moduleName in the ffi-spec;
 "/ instead, the class provides the libraryName...
 (moduleNameUsed := moduleName) isNil ifTrue:[
-owningClass isNil ifTrue:[
+	owningClass isNil ifTrue:[
-self error:'Missing moduleName'.
+	    self error:'Missing moduleName'.
-].
+	].
-moduleNameUsed := owningClass theNonMetaclass libraryName asSymbol.
+	moduleNameUsed := owningClass theNonMetaclass libraryName asSymbol.
 ].
 moduleHandle isNil ifTrue:[
-handle := self loadLibrary:moduleNameUsed.
+	handle := self loadLibrary:moduleNameUsed.
-handle isNil ifTrue:[
+	handle isNil ifTrue:[
-self error:('Cannot find or load dll/module: "%1"' bindWith: moduleNameUsed).
+	    self error:('Cannot find or load dll/module: "%1"' bindWith: moduleNameUsed).
-].
+	].
-moduleHandle := handle.
+	moduleHandle := handle.
 ].
 name isNumber ifFalse:[
-functionName := name.
+	functionName := name.
-(moduleHandle getFunctionAddress:functionName into:self) isNil ifTrue:[
+	(moduleHandle getFunctionAddress:functionName into:self) isNil ifTrue:[
-functionName := ('_', functionName) asSymbol.
+	    functionName := ('_', functionName) asSymbol.
-(moduleHandle getFunctionAddress:functionName into:self) isNil ifTrue:[
+	    (moduleHandle getFunctionAddress:functionName into:self) isNil ifTrue:[
-moduleHandle := nil.
+		moduleHandle := nil.
-self error:'Missing function: ', name, ' in module: ', moduleNameUsed.
+		self error:'Missing function: ', name, ' in module: ', moduleNameUsed.
-].
+	    ].
-].
+	].
 ].
 "Modified: / 10-04-2012 / 12:12:44 / cg"
 !
 loadLibrary:dllName
 |handle nameString filename|
 filename := dllName.
 DllMapping notNil ifTrue:[
-filename := DllMapping at:filename ifAbsent:[ filename ]
+	filename := DllMapping at:filename ifAbsent:[ filename ]
 ].
 filename := filename asFilename.
 nameString := filename name.
 "try to load, maybe the system knows where to find the dll"
 handle := ObjectFileLoader loadDynamicObject:filename.
 handle notNil ifTrue:[^ handle ].
 filename isAbsolute ifFalse:[
-"First ask the class defining the ExternalFunction for the location of the dlls ..."
+	"First ask the class defining the ExternalFunction for the location of the dlls ..."
-owningClass notNil ifTrue:[
+	owningClass notNil ifTrue:[
-owningClass dllPath do:[:eachDirectory |
+	    owningClass dllPath do:[:eachDirectory |
-handle := ObjectFileLoader
+		handle := ObjectFileLoader
-loadDynamicObject:(eachDirectory asFilename construct:nameString) pathName.
+			    loadDynamicObject:(eachDirectory asFilename construct:nameString) pathName.
-handle notNil ifTrue:[^ handle ].
+		handle notNil ifTrue:[^ handle ].
-].
+	    ].
-].
+	].
-".. then ask the system"
+	".. then ask the system"
-self class dllPath do:[:eachDirectory |
+	self class dllPath do:[:eachDirectory |
-handle := ObjectFileLoader
+	    handle := ObjectFileLoader
-loadDynamicObject:(eachDirectory asFilename construct:nameString) pathName.
+			loadDynamicObject:(eachDirectory asFilename construct:nameString) pathName.
-handle notNil ifTrue:[^ handle ].
+	    handle notNil ifTrue:[^ handle ].
-].
+	].
 ].
 filename suffix isEmpty ifTrue:[
-"/ try again with the OS-specific dll-extension
+	"/ try again with the OS-specific dll-extension
-^ self loadLibrary:(filename withSuffix:ObjectFileLoader sharedLibrarySuffix)
+	^ self loadLibrary:(filename withSuffix:ObjectFileLoader sharedLibrarySuffix)
 ].
 ^ nil
 "Modified: / 10-04-2012 / 12:21:06 / cg"
 !ExternalLibraryFunction methodsFor:'private-accessing'!
 ffiTypeSymbolForType:aType
 "map type to one of the ffi-supported ones:
-sint8, sint16, sint32, sint64
+	sint8, sint16, sint32, sint64
-uint8, uint16, uint32, uint64
+	uint8, uint16, uint32, uint64
-bool void pointer handle
+	bool void pointer handle
 "
 aType == #sint8           ifTrue:[^ aType ].
 aType == #sint16          ifTrue:[^ aType ].
 aType == #sint32          ifTrue:[^ aType ].
 aType == #structIn        ifTrue:[^ #pointer ].
 aType == #structOut       ifTrue:[^ #pointer ].
 aType == #unsigned        ifTrue:[^ #uint ].
 (aType isString or:[aType isSymbol]) ifFalse:[
-CType isNil ifTrue:[
+	CType isNil ifTrue:[
-self error:'unknown type'.
+	    self error:'unknown type'.
-].
+	].
-^ aType typeSymbol.
+	^ aType typeSymbol.
 ].
 (aType endsWith:'*') ifTrue:[
-^ #pointer.
+	^ #pointer.
 ].
 (aType endsWith:'Pointer') ifTrue:[
-^ #pointer.
+	^ #pointer.
 ].
 ^ aType
 "Modified: / 14-06-2007 / 17:21:42 / cg"
 !
 argTypeSymbols := argumentTypes.
 returnTypeSymbol := returnType.
 virtual := self isVirtualCPP.
 (virtual "or:[self isNonVirtualCPP]") ifTrue:[
-aCPlusPlusObjectOrNil isNil ifTrue:[
+	aCPlusPlusObjectOrNil isNil ifTrue:[
-"/ must have a c++ object instance
+	    "/ must have a c++ object instance
-self primitiveFailed.
+	    self primitiveFailed.
-].
+	].
-"/ and it must be a kind of ExternalStructure !!
+	"/ and it must be a kind of ExternalStructure !!
-(aCPlusPlusObjectOrNil isKindOf:ExternalStructure) ifFalse:[
+	(aCPlusPlusObjectOrNil isKindOf:ExternalStructure) ifFalse:[
-self primitiveFailed.
+	    self primitiveFailed.
-].
+	].
-virtual ifTrue:[
+	virtual ifTrue:[
-vtOffset := name.
+	    vtOffset := name.
-(vtOffset between:0 and:10000) ifFalse:[
+	    (vtOffset between:0 and:10000) ifFalse:[
-self primitiveFailed.
+		self primitiveFailed.
-]
+	    ]
-].
+	].
 ] ifFalse:[
-aCPlusPlusObjectOrNil notNil ifTrue:[
+	aCPlusPlusObjectOrNil notNil ifTrue:[
-"/ must NOT have a c++ object instance
+	    "/ must NOT have a c++ object instance
-self primitiveFailed.
+	    self primitiveFailed.
-].
+	].
 ].
 async := self isAsync.
 unlimitedStack := self isUnlimitedStack.
 callTypeNumber := self callTypeNumber.
 "/ Transcript show:name; show:' async:'; showCR:async.
 ffi_type *__argTypesIncludingThis[MAX_ARGS+1];
 ffi_type **__argTypes = __argTypesIncludingThis;
 ffi_type *__returnType = NULL;
 union u {
-int iVal;
+	int iVal;
-float fVal;
+	float fVal;
-double dVal;
+	double dVal;
-void *pointerVal;
+	void *pointerVal;
 # if defined(HAS_LONGLONG)
-long long longLongVal;
+	long long longLongVal;
 # else
 #  ifdef HAS_INT64
-__int64__ longLongVal;
+	__int64__ longLongVal;
 #  else
-struct ll { long low; long hi; } longLongVal;
+	struct ll { long low; long hi; } longLongVal;
 #  endif
 # endif
 };
 union u __argValuesIncludingThis[MAX_ARGS+1];
 union u *__argValues = __argValuesIncludingThis;
 VOIDFUNC codeAddress = (VOIDFUNC)__INST(code_);
 int __numArgsWanted;
 #   define __FAIL__(fcode) \
 { \
-failureCode = fcode; goto getOutOfHere; \
+	failureCode = fcode; goto getOutOfHere; \
 }
 if (argumentsOrNil == nil) {
-__numArgs = 0;
+	__numArgs = 0;
 } else if (__isArray(argumentsOrNil)) {
-__numArgs = __arraySize(argumentsOrNil);
+	__numArgs = __arraySize(argumentsOrNil);
 } else {
-__FAIL__(@symbol(BadArgumentVector))
+	__FAIL__(@symbol(BadArgumentVector))
 }
 if (argTypeSymbols == nil) {
-__numArgsWanted = 0;
+	__numArgsWanted = 0;
 } else if (__isArray(argTypeSymbols)) {
-__numArgsWanted = __arraySize(argTypeSymbols);
+	__numArgsWanted = __arraySize(argTypeSymbols);
 } else {
-__FAIL__(@symbol(BadArgumentTypeVector))
+	__FAIL__(@symbol(BadArgumentTypeVector))
 }
 if (__numArgs != __numArgsWanted) {
-__FAIL__(@symbol(ArgumentCountMismatch))
+	__FAIL__(@symbol(ArgumentCountMismatch))
 }
 if (__numArgs > MAX_ARGS) {
-__FAIL__(@symbol(TooManyArguments))
+	__FAIL__(@symbol(TooManyArguments))
 }
 /*
 * validate the return type
 */
 __returnValuePointer = &__returnValue;
 if (returnTypeSymbol == @symbol(voidPointer)) {
-returnTypeSymbol = @symbol(handle);
+	returnTypeSymbol = @symbol(handle);
 }
 if (returnTypeSymbol == @symbol(int)) {
-__returnType = __get_ffi_type_sint();
+	__returnType = __get_ffi_type_sint();
 } else if (returnTypeSymbol == @symbol(uint)) {
-__returnType = __get_ffi_type_uint();
+	__returnType = __get_ffi_type_uint();
 } else if (returnTypeSymbol == @symbol(uint8)) {
-__returnType = __get_ffi_type_uint8();
+	__returnType = __get_ffi_type_uint8();
 } else if (returnTypeSymbol == @symbol(uint16)) {
-__returnType = __get_ffi_type_uint16();
+	__returnType = __get_ffi_type_uint16();
 } else if (returnTypeSymbol == @symbol(uint32)) {
-__returnType = __get_ffi_type_uint32();
+	__returnType = __get_ffi_type_uint32();
 } else if (returnTypeSymbol == @symbol(uint64)) {
-__returnType = __get_ffi_type_uint64();
+	__returnType = __get_ffi_type_uint64();
 } else if (returnTypeSymbol == @symbol(sint)) {
-__returnType = __get_ffi_type_sint();
+	__returnType = __get_ffi_type_sint();
 } else if (returnTypeSymbol == @symbol(sint8)) {
-__returnType = __get_ffi_type_sint8();
+	__returnType = __get_ffi_type_sint8();
 } else if (returnTypeSymbol == @symbol(sint16)) {
-__returnType = __get_ffi_type_sint16();
+	__returnType = __get_ffi_type_sint16();
 } else if (returnTypeSymbol == @symbol(sint32)) {
-__returnType = __get_ffi_type_sint32();
+	__returnType = __get_ffi_type_sint32();
 } else if (returnTypeSymbol == @symbol(sint64)) {
-__returnType = __get_ffi_type_sint64();
+	__returnType = __get_ffi_type_sint64();
 } else if (returnTypeSymbol == @symbol(long)) {
-if (sizeof(long) == 4) {
+	if (sizeof(long) == 4) {
-returnTypeSymbol = @symbol(sint32);
+	   returnTypeSymbol = @symbol(sint32);
-__returnType = __get_ffi_type_sint32();
+	   __returnType = __get_ffi_type_sint32();
-} else if (sizeof(long) == 8) {
+	} else if (sizeof(long) == 8) {
-returnTypeSymbol = @symbol(sint64);
+	   returnTypeSymbol = @symbol(sint64);
-__returnType = __get_ffi_type_sint64();
+	   __returnType = __get_ffi_type_sint64();
-} else {
+	} else {
-__FAIL__(@symbol(UnknownReturnType))
+	    __FAIL__(@symbol(UnknownReturnType))
-}
+	}
 } else if (returnTypeSymbol == @symbol(ulong)) {
-if (sizeof(long) == 4) {
+	if (sizeof(long) == 4) {
-returnTypeSymbol = @symbol(uint32);
+	   returnTypeSymbol = @symbol(uint32);
-__returnType = __get_ffi_type_uint32();
+	   __returnType = __get_ffi_type_uint32();
-}else if (sizeof(long) == 8) {
+	}else if (sizeof(long) == 8) {
-returnTypeSymbol = @symbol(uint64);
+	   returnTypeSymbol = @symbol(uint64);
-__returnType = __get_ffi_type_uint64();
+	   __returnType = __get_ffi_type_uint64();
-} else {
+	} else {
-__FAIL__(@symbol(UnknownReturnType))
+	    __FAIL__(@symbol(UnknownReturnType))
-}
+	}
 } else if (returnTypeSymbol == @symbol(bool)) {
-__returnType = __get_ffi_type_uint();
+	__returnType = __get_ffi_type_uint();
 } else if (returnTypeSymbol == @symbol(float)) {
-__returnType = __get_ffi_type_float();
+	__returnType = __get_ffi_type_float();
 } else if (returnTypeSymbol == @symbol(double)) {
-__returnType = __get_ffi_type_double();
+	__returnType = __get_ffi_type_double();
 } else if (returnTypeSymbol == @symbol(void)) {
-__returnType = __get_ffi_type_void();
+	__returnType = __get_ffi_type_void();
-__returnValuePointer = NULL;
+	__returnValuePointer = NULL;
 } else if ((returnTypeSymbol == @symbol(pointer))
-|| (returnTypeSymbol == @symbol(handle))
+	       || (returnTypeSymbol == @symbol(handle))
-|| (returnTypeSymbol == @symbol(charPointer))
+	       || (returnTypeSymbol == @symbol(charPointer))
-|| (returnTypeSymbol == @symbol(bytePointer))
+	       || (returnTypeSymbol == @symbol(bytePointer))
-|| (returnTypeSymbol == @symbol(floatPointer))
+	       || (returnTypeSymbol == @symbol(floatPointer))
-|| (returnTypeSymbol == @symbol(doublePointer))
+	       || (returnTypeSymbol == @symbol(doublePointer))
-|| (returnTypeSymbol == @symbol(intPointer))
+	       || (returnTypeSymbol == @symbol(intPointer))
-|| (returnTypeSymbol == @symbol(shortPointer))
+	       || (returnTypeSymbol == @symbol(shortPointer))
-|| (returnTypeSymbol == @symbol(wcharPointer))) {
+	       || (returnTypeSymbol == @symbol(wcharPointer))) {
-__returnType = __get_ffi_type_pointer();
+	__returnType = __get_ffi_type_pointer();
 } else {
-if (__isSymbol(returnTypeSymbol)
+	if (__isSymbol(returnTypeSymbol)
-&& ((returnValueClass = __GLOBAL_GET(returnTypeSymbol)) != nil)) {
+	 && ((returnValueClass = __GLOBAL_GET(returnTypeSymbol)) != nil)) {
-if (! __isBehaviorLike(returnValueClass)) {
+	    if (! __isBehaviorLike(returnValueClass)) {
-__FAIL__(@symbol(NonBehaviorReturnType))
+		__FAIL__(@symbol(NonBehaviorReturnType))
-}
+	    }
-if (! __qIsSubclassOfExternalAddress(returnValueClass)) {
+	    if (! __qIsSubclassOfExternalAddress(returnValueClass)) {
-__FAIL__(@symbol(NonExternalAddressReturnType))
+		__FAIL__(@symbol(NonExternalAddressReturnType))
-}
+	    }
-__returnType = __get_ffi_type_pointer();
+	    __returnType = __get_ffi_type_pointer();
-returnTypeSymbol = @symbol(pointer);
+	    returnTypeSymbol = @symbol(pointer);
-} else {
+	} else {
-__FAIL__(@symbol(UnknownReturnType))
+	    __FAIL__(@symbol(UnknownReturnType))
-}
+	}
 }
 /*
 * validate the c++ object
 */
 if (aCPlusPlusObjectOrNil != nil) {
-struct cPlusPlusInstance {
+	struct cPlusPlusInstance {
-void **vTable;
+	    void **vTable;
-};
+	};
-struct cPlusPlusInstance *inst;
+	struct cPlusPlusInstance *inst;
-if (__isExternalAddressLike(aCPlusPlusObjectOrNil)) {
+	if (__isExternalAddressLike(aCPlusPlusObjectOrNil)) {
-inst = (void *)(__externalAddressVal(aCPlusPlusObjectOrNil));
+	    inst = (void *)(__externalAddressVal(aCPlusPlusObjectOrNil));
-} else if (__isExternalBytesLike(aCPlusPlusObjectOrNil)) {
+	} else if (__isExternalBytesLike(aCPlusPlusObjectOrNil)) {
-inst = (void *)(__externalBytesVal(aCPlusPlusObjectOrNil));
+	    inst = (void *)(__externalBytesVal(aCPlusPlusObjectOrNil));
-} else {
+	} else {
-__FAIL__(@symbol(InvalidInstance))
+	    __FAIL__(@symbol(InvalidInstance))
-}
+	}
-__argValues[0].pointerVal = inst;
+	__argValues[0].pointerVal = inst;
-__argValuePointersIncludingThis[0] = &(__argValues[0]);
+	__argValuePointersIncludingThis[0] = &(__argValues[0]);
-__argTypes[0] = __get_ffi_type_pointer();
+	__argTypes[0] = __get_ffi_type_pointer();
-__argValuePointers = &__argValuePointersIncludingThis[1];
+	__argValuePointers = &__argValuePointersIncludingThis[1];
-__argTypes = &__argTypesIncludingThis[1];
+	__argTypes = &__argTypesIncludingThis[1];
-__argValues = &__argValuesIncludingThis[1];
+	__argValues = &__argValuesIncludingThis[1];
-__numArgsIncludingThis = __numArgs + 1;
+	__numArgsIncludingThis = __numArgs + 1;
-if (virtual == true) {
+	if (virtual == true) {
-if (! __isSmallInteger(vtOffset)) {
+	    if (! __isSmallInteger(vtOffset)) {
-__FAIL__(@symbol(InvalidVTableIndex))
+		__FAIL__(@symbol(InvalidVTableIndex))
-}
+	    }
-codeAddress = inst->vTable[__intVal(vtOffset)];
+	    codeAddress = inst->vTable[__intVal(vtOffset)];
 # ifdef VERBOSE
-printf("virtual codeAddress: %x\n", codeAddress);
+	    printf("virtual codeAddress: %x\n", codeAddress);
 # endif
-}
+	}
 } else {
-__numArgsIncludingThis = __numArgs;
+	__numArgsIncludingThis = __numArgs;
 # ifdef VERBOSE
-printf("codeAddress: %x\n", codeAddress);
+	printf("codeAddress: %x\n", codeAddress);
 # endif
 }
 /*
 * validate all arg types and setup arg-buffers
 */
 for (i=0; i<__numArgs; i++) {
-ffi_type *thisType;
+	ffi_type *thisType;
-void *argValuePtr;
+	void *argValuePtr;
-OBJ typeSymbol;
+	OBJ typeSymbol;
-OBJ arg;
+	OBJ arg;
-failureInfo = __mkSmallInteger(i+1);   /* in case there is one */
+	failureInfo = __mkSmallInteger(i+1);   /* in case there is one */
-typeSymbol = __ArrayInstPtr(argTypeSymbols)->a_element[i];
+	typeSymbol = __ArrayInstPtr(argTypeSymbols)->a_element[i];
-arg = __ArrayInstPtr(argumentsOrNil)->a_element[i];
+	arg = __ArrayInstPtr(argumentsOrNil)->a_element[i];
-if (typeSymbol == @symbol(handle)) {
+	if (typeSymbol == @symbol(handle)) {
-typeSymbol = @symbol(pointer);
+	    typeSymbol = @symbol(pointer);
-} else if (typeSymbol == @symbol(voidPointer)) {
+	} else if (typeSymbol == @symbol(voidPointer)) {
-typeSymbol = @symbol(pointer);
+	    typeSymbol = @symbol(pointer);
-}
+	}
-if (typeSymbol == @symbol(long)) {
+	if (typeSymbol == @symbol(long)) {
-if (sizeof(long) == sizeof(int)) {
+	    if (sizeof(long) == sizeof(int)) {
-typeSymbol = @symbol(sint);
+		typeSymbol = @symbol(sint);
-} else {
+	    } else {
-if (sizeof(long) == 4) {
+		if (sizeof(long) == 4) {
-typeSymbol = @symbol(sint32);
+		    typeSymbol = @symbol(sint32);
-} else if (sizeof(long) == 8) {
+		} else if (sizeof(long) == 8) {
-typeSymbol = @symbol(sint64);
+		    typeSymbol = @symbol(sint64);
-}
+		}
-}
+	    }
-}
+	}
-if (typeSymbol == @symbol(ulong)) {
+	if (typeSymbol == @symbol(ulong)) {
-if (sizeof(unsigned long) == sizeof(unsigned int)) {
+	    if (sizeof(unsigned long) == sizeof(unsigned int)) {
-typeSymbol = @symbol(uint);
+		typeSymbol = @symbol(uint);
-} else {
+	    } else {
-if (sizeof(long) == 4) {
+		if (sizeof(long) == 4) {
-typeSymbol = @symbol(uint32);
+		    typeSymbol = @symbol(uint32);
-} else if (sizeof(long) == 8) {
+		} else if (sizeof(long) == 8) {
-typeSymbol = @symbol(uint64);
+		    typeSymbol = @symbol(uint64);
-}
+		}
-}
+	    }
-}
+	}
-if (typeSymbol == @symbol(int) || typeSymbol == @symbol(sint)) {
+	if (typeSymbol == @symbol(int) || typeSymbol == @symbol(sint)) {
-thisType = __get_ffi_type_sint();
+	    thisType = __get_ffi_type_sint();
-if (__isSmallInteger(arg)) {
+	    if (__isSmallInteger(arg)) {
-__argValues[i].iVal = __intVal(arg);
+		__argValues[i].iVal = __intVal(arg);
-} else {
+	    } else {
-__argValues[i].iVal = __signedLongIntVal(arg);
+		__argValues[i].iVal = __signedLongIntVal(arg);
-if (__argValues[i].iVal == 0) {
+		if (__argValues[i].iVal == 0) {
-__FAIL__(@symbol(InvalidArgument))
+		    __FAIL__(@symbol(InvalidArgument))
-}
+		}
-}
+	    }
-argValuePtr = &(__argValues[i].iVal);
+	    argValuePtr = &(__argValues[i].iVal);
-} else if (typeSymbol == @symbol(uint)) {
+	} else if (typeSymbol == @symbol(uint)) {
-thisType = __get_ffi_type_uint();
+	    thisType = __get_ffi_type_uint();
-if (__isSmallInteger(arg)) {
+	    if (__isSmallInteger(arg)) {
-__argValues[i].iVal = __intVal(arg);
+		__argValues[i].iVal = __intVal(arg);
-} else {
+	    } else {
-__argValues[i].iVal = __unsignedLongIntVal(arg);
+		__argValues[i].iVal = __unsignedLongIntVal(arg);
-if (__argValues[i].iVal == 0) {
+		if (__argValues[i].iVal == 0) {
-__FAIL__(@symbol(InvalidArgument))
+		    __FAIL__(@symbol(InvalidArgument))
-}
+		}
-}
+	    }
-argValuePtr = &(__argValues[i].iVal);
+	    argValuePtr = &(__argValues[i].iVal);
-} else if (typeSymbol == @symbol(uint8)) {
+	} else if (typeSymbol == @symbol(uint8)) {
-thisType = __get_ffi_type_uint8();
+	    thisType = __get_ffi_type_uint8();
-if (! __isSmallInteger(arg)) {
+	    if (! __isSmallInteger(arg)) {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-__argValues[i].iVal = __intVal(arg);
+	    __argValues[i].iVal = __intVal(arg);
-if (((unsigned)(__argValues[i].iVal)) > 0xFF) {
+	    if (((unsigned)(__argValues[i].iVal)) > 0xFF) {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-argValuePtr = &(__argValues[i].iVal);
+	    argValuePtr = &(__argValues[i].iVal);
-} else if (typeSymbol == @symbol(sint8)) {
+	} else if (typeSymbol == @symbol(sint8)) {
-thisType = __get_ffi_type_sint8();
+	    thisType = __get_ffi_type_sint8();
-if (! __isSmallInteger(arg)) {
+	    if (! __isSmallInteger(arg)) {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-__argValues[i].iVal = __intVal(arg);
+	    __argValues[i].iVal = __intVal(arg);
-if (((__argValues[i].iVal) < -0x80) || ((__argValues[i].iVal) > 0x7F))  {
+	    if (((__argValues[i].iVal) < -0x80) || ((__argValues[i].iVal) > 0x7F))  {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-argValuePtr = &(__argValues[i].iVal);
+	    argValuePtr = &(__argValues[i].iVal);
-} else if (typeSymbol == @symbol(uint16)) {
+	} else if (typeSymbol == @symbol(uint16)) {
-thisType = __get_ffi_type_uint16();
+	    thisType = __get_ffi_type_uint16();
-if (! __isSmallInteger(arg)) {
+	    if (! __isSmallInteger(arg)) {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-__argValues[i].iVal = __intVal(arg);
+	    __argValues[i].iVal = __intVal(arg);
-if (((unsigned)(__argValues[i].iVal)) > 0xFFFF) {
+	    if (((unsigned)(__argValues[i].iVal)) > 0xFFFF) {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-argValuePtr = &(__argValues[i].iVal);
+	    argValuePtr = &(__argValues[i].iVal);
-} else if (typeSymbol == @symbol(sint16)) {
+	} else if (typeSymbol == @symbol(sint16)) {
-thisType = __get_ffi_type_sint16();
+	    thisType = __get_ffi_type_sint16();
-if (! __isSmallInteger(arg)) {
+	    if (! __isSmallInteger(arg)) {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-__argValues[i].iVal = __intVal(arg);
+	    __argValues[i].iVal = __intVal(arg);
-if (((__argValues[i].iVal) < -0x8000) || ((__argValues[i].iVal) > 0x7FFF))  {
+	    if (((__argValues[i].iVal) < -0x8000) || ((__argValues[i].iVal) > 0x7FFF))  {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-argValuePtr = &(__argValues[i].iVal);
+	    argValuePtr = &(__argValues[i].iVal);
-} else if ((typeSymbol == @symbol(uint32)) || (typeSymbol == @symbol(sint32))) {
+	} else if ((typeSymbol == @symbol(uint32)) || (typeSymbol == @symbol(sint32))) {
-thisType = __get_ffi_type_uint32();
+	    thisType = __get_ffi_type_uint32();
-if (__isSmallInteger(arg)) {
+	    if (__isSmallInteger(arg)) {
-__argValues[i].iVal = __intVal(arg);
+		__argValues[i].iVal = __intVal(arg);
-} else {
+	    } else {
-__argValues[i].iVal = __unsignedLongIntVal(arg);
+		__argValues[i].iVal = __unsignedLongIntVal(arg);
-if (__argValues[i].iVal == 0) {
+		if (__argValues[i].iVal == 0) {
-__FAIL__(@symbol(InvalidArgument))
+		    __FAIL__(@symbol(InvalidArgument))
-}
+		}
-}
+	    }
-argValuePtr = &(__argValues[i].iVal);
+	    argValuePtr = &(__argValues[i].iVal);
-} else if (typeSymbol == @symbol(float)) {
+	} else if (typeSymbol == @symbol(float)) {
-thisType = __get_ffi_type_float();
+	    thisType = __get_ffi_type_float();
-if (__isSmallInteger(arg)) {
+	    if (__isSmallInteger(arg)) {
-__argValues[i].fVal = (float)(__intVal(arg));
+		__argValues[i].fVal = (float)(__intVal(arg));
-} else if (__isFloat(arg)) {
+	    } else if (__isFloat(arg)) {
-__argValues[i].fVal = (float)(__floatVal(arg));
+		__argValues[i].fVal = (float)(__floatVal(arg));
-} else if (__isShortFloat(arg)) {
+	    } else if (__isShortFloat(arg)) {
-__argValues[i].fVal = (float)(__shortFloatVal(arg));
+		__argValues[i].fVal = (float)(__shortFloatVal(arg));
-} else {
+	    } else {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-argValuePtr = &(__argValues[i].fVal);
+	    argValuePtr = &(__argValues[i].fVal);
-} else if (typeSymbol == @symbol(double)) {
+	} else if (typeSymbol == @symbol(double)) {
-thisType = __get_ffi_type_double();
+	    thisType = __get_ffi_type_double();
-if (__isSmallInteger(arg)) {
+	    if (__isSmallInteger(arg)) {
-__argValues[i].dVal = (double)(__intVal(arg));
+		__argValues[i].dVal = (double)(__intVal(arg));
-} else if (__isFloat(arg)) {
+	    } else if (__isFloat(arg)) {
-__argValues[i].dVal = (double)(__floatVal(arg));
+		__argValues[i].dVal = (double)(__floatVal(arg));
-} else if (__isShortFloat(arg)) {
+	    } else if (__isShortFloat(arg)) {
-__argValues[i].dVal = (double)(__shortFloatVal(arg));
+		__argValues[i].dVal = (double)(__shortFloatVal(arg));
-} else {
+	    } else {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-argValuePtr = &(__argValues[i].dVal);
+	    argValuePtr = &(__argValues[i].dVal);
-} else if (typeSymbol == @symbol(void)) {
+	} else if (typeSymbol == @symbol(void)) {
-thisType = __get_ffi_type_void();
+	    thisType = __get_ffi_type_void();
-argValuePtr = &null;
+	    argValuePtr = &null;
-} else if (typeSymbol == @symbol(charPointer)) {
+	} else if (typeSymbol == @symbol(charPointer)) {
-thisType = __get_ffi_type_pointer();
+	    thisType = __get_ffi_type_pointer();
-if (__isStringLike(arg)) {
+	    if (__isStringLike(arg)) {
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-__argValues[i].pointerVal = (void *)(__stringVal(arg));
+		__argValues[i].pointerVal = (void *)(__stringVal(arg));
-} else if (__isBytes(arg)) {
+	    } else if (__isBytes(arg)) {
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-__argValues[i].pointerVal = (void *)(__byteArrayVal(arg));
+		__argValues[i].pointerVal = (void *)(__byteArrayVal(arg));
-} else if (__isExternalAddressLike(arg)) {
+	    } else if (__isExternalAddressLike(arg)) {
-__argValues[i].pointerVal = (void *)(__externalAddressVal(arg));
+		__argValues[i].pointerVal = (void *)(__externalAddressVal(arg));
-} else if (__isExternalBytesLike(arg)) {
+	    } else if (__isExternalBytesLike(arg)) {
-__argValues[i].pointerVal = (void *)(__externalBytesVal(arg));
+		__argValues[i].pointerVal = (void *)(__externalBytesVal(arg));
-} else {
+	    } else {
-if (arg == nil) {
+		if (arg == nil) {
-__argValues[i].pointerVal = (void *)0;
+		    __argValues[i].pointerVal = (void *)0;
-} else {
+		} else {
-__FAIL__(@symbol(InvalidArgument))
+		    __FAIL__(@symbol(InvalidArgument))
-}
+		}
-}
+	    }
-argValuePtr = &(__argValues[i].pointerVal);;
+	    argValuePtr = &(__argValues[i].pointerVal);;
-} else if (typeSymbol == @symbol(wcharPointer)) {
+	} else if (typeSymbol == @symbol(wcharPointer)) {
-thisType = __get_ffi_type_pointer();
+	    thisType = __get_ffi_type_pointer();
-if (__isUnicode16String(arg)) {
+	    if (__isUnicode16String(arg)) {
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-__argValues[i].pointerVal = (void *)(__unicode16StringVal(arg));
+		__argValues[i].pointerVal = (void *)(__unicode16StringVal(arg));
-} else if (__isBytes(arg)) {
+	    } else if (__isBytes(arg)) {
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-__argValues[i].pointerVal = (void *)(__byteArrayVal(arg));
+		__argValues[i].pointerVal = (void *)(__byteArrayVal(arg));
-} else if (__isExternalAddressLike(arg)) {
+	    } else if (__isExternalAddressLike(arg)) {
-__argValues[i].pointerVal = (void *)(__externalAddressVal(arg));
+		__argValues[i].pointerVal = (void *)(__externalAddressVal(arg));
-} else if (__isExternalBytesLike(arg)) {
+	    } else if (__isExternalBytesLike(arg)) {
-__argValues[i].pointerVal = (void *)(__externalBytesVal(arg));
+		__argValues[i].pointerVal = (void *)(__externalBytesVal(arg));
-} else {
+	    } else {
-if (arg == nil) {
+		if (arg == nil) {
-__argValues[i].pointerVal = (void *)0;
+		    __argValues[i].pointerVal = (void *)0;
-} else {
+		} else {
-__FAIL__(@symbol(InvalidArgument))
+		    __FAIL__(@symbol(InvalidArgument))
-}
+		}
-}
+	    }
-argValuePtr = &(__argValues[i].pointerVal);;
+	    argValuePtr = &(__argValues[i].pointerVal);;
-} else if (typeSymbol == @symbol(floatPointer)) {
+	} else if (typeSymbol == @symbol(floatPointer)) {
-thisType = __get_ffi_type_pointer();
+	    thisType = __get_ffi_type_pointer();
-if (__isBytes(arg)) {
+	    if (__isBytes(arg)) {
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-__argValues[i].pointerVal = (void *)(__byteArrayVal(arg));
+		__argValues[i].pointerVal = (void *)(__byteArrayVal(arg));
-} else if (__isExternalAddressLike(arg)) {
+	    } else if (__isExternalAddressLike(arg)) {
-__argValues[i].pointerVal = (void *)(__externalAddressVal(arg));
+		__argValues[i].pointerVal = (void *)(__externalAddressVal(arg));
-} else if (__isExternalBytesLike(arg)) {
+	    } else if (__isExternalBytesLike(arg)) {
-__argValues[i].pointerVal = (void *)(__externalBytesVal(arg));
+		__argValues[i].pointerVal = (void *)(__externalBytesVal(arg));
-} else if (__isFloats(arg)) {
+	    } else if (__isFloats(arg)) {
-char *p = (char *)(__FloatArrayInstPtr(arg)->f_element);
+		char *p = (char *)(__FloatArrayInstPtr(arg)->f_element);
-int nInstBytes;
+		int nInstBytes;
-OBJ cls;
+		OBJ cls;
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-cls = __qClass(arg);
+		cls = __qClass(arg);
-nInstBytes = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+		nInstBytes = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-p = p + nInstBytes;
+		p = p + nInstBytes;
-__argValues[i].pointerVal = p;
+		__argValues[i].pointerVal = p;
-} else {
+	    } else {
-if (arg == nil) {
+		if (arg == nil) {
-__argValues[i].pointerVal = (void *)0;
+		    __argValues[i].pointerVal = (void *)0;
-} else {
+		} else {
-__FAIL__(@symbol(InvalidArgument))
+		    __FAIL__(@symbol(InvalidArgument))
-}
+		}
-}
+	    }
-argValuePtr = &(__argValues[i].pointerVal);;
+	    argValuePtr = &(__argValues[i].pointerVal);;
-} else if (typeSymbol == @symbol(doublePointer)) {
+	} else if (typeSymbol == @symbol(doublePointer)) {
-thisType = __get_ffi_type_pointer();
+	    thisType = __get_ffi_type_pointer();
-if (__isBytes(arg)) {
+	    if (__isBytes(arg)) {
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-__argValues[i].pointerVal = (void *)(__byteArrayVal(arg));
+		__argValues[i].pointerVal = (void *)(__byteArrayVal(arg));
-} else if (__isExternalAddressLike(arg)) {
+	    } else if (__isExternalAddressLike(arg)) {
-__argValues[i].pointerVal = (void *)(__externalAddressVal(arg));
+		__argValues[i].pointerVal = (void *)(__externalAddressVal(arg));
-} else if (__isExternalBytesLike(arg)) {
+	    } else if (__isExternalBytesLike(arg)) {
-__argValues[i].pointerVal = (void *)(__externalBytesVal(arg));
+		__argValues[i].pointerVal = (void *)(__externalBytesVal(arg));
-} else if (__isDoubles(arg)) {
+	    } else if (__isDoubles(arg)) {
-char *p = (char *)(__DoubleArrayInstPtr(arg)->d_element);
+		char *p = (char *)(__DoubleArrayInstPtr(arg)->d_element);
-int nInstBytes;
+		int nInstBytes;
-OBJ cls;
+		OBJ cls;
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-cls = __qClass(arg);
+		cls = __qClass(arg);
-nInstBytes = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+		nInstBytes = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-p = p + nInstBytes;
+		p = p + nInstBytes;
 # ifdef __NEED_DOUBLE_ALIGN
-if ((INT)pFirst & (__DOUBLE_ALIGN-1)) {
+		if ((INT)(__DoubleArrayInstPtr(arg)->d_element) & (__DOUBLE_ALIGN-1)) {
-int delta = __DOUBLE_ALIGN - ((INT)p & (__DOUBLE_ALIGN-1));
+		    int delta = __DOUBLE_ALIGN - ((INT)p & (__DOUBLE_ALIGN-1));
-p += delta;
+		    p += delta;
-}
+		}
 # endif
-__argValues[i].pointerVal = p;
+		__argValues[i].pointerVal = p;
-} else {
+	    } else {
-if (arg == nil) {
+		if (arg == nil) {
-__argValues[i].pointerVal = (void *)0;
+		    __argValues[i].pointerVal = (void *)0;
-} else {
+		} else {
-__FAIL__(@symbol(InvalidArgument))
+		    __FAIL__(@symbol(InvalidArgument))
-}
+		}
-}
+	    }
-argValuePtr = &(__argValues[i].pointerVal);;
+	    argValuePtr = &(__argValues[i].pointerVal);;
-} else if (typeSymbol == @symbol(pointer)) {
+	} else if (typeSymbol == @symbol(pointer)) {
 commonPointerTypeArg: ;
-thisType = __get_ffi_type_pointer();
+	    thisType = __get_ffi_type_pointer();
-if (arg == nil) {
+	    if (arg == nil) {
-__argValues[i].pointerVal = NULL;
+		__argValues[i].pointerVal = NULL;
-} else if (__isExternalAddressLike(arg)) {
+	    } else if (__isExternalAddressLike(arg)) {
-__argValues[i].pointerVal = (void *)(__externalAddressVal(arg));
+		__argValues[i].pointerVal = (void *)(__externalAddressVal(arg));
-} else if (__isExternalBytesLike(arg)) {
+	    } else if (__isExternalBytesLike(arg)) {
-__argValues[i].pointerVal = (void *)(__externalBytesVal(arg));
+		__argValues[i].pointerVal = (void *)(__externalBytesVal(arg));
-} else if (__isByteArrayLike(arg)) {
+	    } else if (__isByteArrayLike(arg)) {
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-__argValues[i].pointerVal = (void *)(__byteArrayVal(arg));
+		__argValues[i].pointerVal = (void *)(__byteArrayVal(arg));
-} else if (__isWordArray(arg) || __isSignedWordArray(arg)
+	    } else if (__isWordArray(arg) || __isSignedWordArray(arg)
-|| __isIntegerArray(arg) || __isSignedIntegerArray(arg)) {
+		    || __isIntegerArray(arg) || __isSignedIntegerArray(arg)) {
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-__argValues[i].pointerVal = (void *)(__integerArrayVal(arg));
+		__argValues[i].pointerVal = (void *)(__integerArrayVal(arg));
-} else if (__isFloatArray(arg)) {
+	    } else if (__isFloatArray(arg)) {
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-__argValues[i].pointerVal = (void *)(__FloatArrayInstPtr(arg)->f_element);
+		__argValues[i].pointerVal = (void *)(__FloatArrayInstPtr(arg)->f_element);
-} else if (__isDoubleArray(arg)) {
+	    } else if (__isDoubleArray(arg)) {
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-__argValues[i].pointerVal = (void *)(__DoubleArrayInstPtr(arg)->d_element);
+		__argValues[i].pointerVal = (void *)(__DoubleArrayInstPtr(arg)->d_element);
-} else if (__isStringLike(arg)) {
+	    } else if (__isStringLike(arg)) {
-if (async == true) {
+		if (async == true) {
 badArgForAsyncCall: ;
-__FAIL__(@symbol(BadArgForAsyncCall))
+		    __FAIL__(@symbol(BadArgForAsyncCall))
-}
+		}
-__argValues[i].pointerVal = (void *)(__stringVal(arg));
+		__argValues[i].pointerVal = (void *)(__stringVal(arg));
-} else if (__isBytes(arg) || __isWords(arg) || __isLongs(arg)) {
+	    } else if (__isBytes(arg) || __isWords(arg) || __isLongs(arg)) {
-char *p = (char *)(__byteArrayVal(arg));
+		char *p = (char *)(__byteArrayVal(arg));
-int nInstBytes;
+		int nInstBytes;
-OBJ cls;
+		OBJ cls;
-if (async == true) goto badArgForAsyncCall;
+		if (async == true) goto badArgForAsyncCall;
-cls = __qClass(arg);
+		cls = __qClass(arg);
-nInstBytes = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
+		nInstBytes = __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
-__argValues[i].pointerVal = p + nInstBytes;
+		__argValues[i].pointerVal = p + nInstBytes;
-} else {
+	    } else {
-__FAIL__(@symbol(InvalidArgument))
+		__FAIL__(@symbol(InvalidArgument))
-}
+	    }
-argValuePtr = &(__argValues[i].pointerVal);;
+	    argValuePtr = &(__argValues[i].pointerVal);;
-} else if (typeSymbol == @symbol(bool)) {
+	} else if (typeSymbol == @symbol(bool)) {
-thisType = __get_ffi_type_uint();
+	    thisType = __get_ffi_type_uint();
-if (arg == true) {
+	    if (arg == true) {
-__argValues[i].iVal = 1;
+		__argValues[i].iVal = 1;
-} else if (arg == false) {
+	    } else if (arg == false) {
-__argValues[i].iVal = 0;
+		__argValues[i].iVal = 0;
-} else if (__isSmallInteger(arg)) {
+	    } else if (__isSmallInteger(arg)) {
-__argValues[i].iVal = __intVal(arg);
+		__argValues[i].iVal = __intVal(arg);
-} else {
+	    } else {
-__argValues[i].iVal = __unsignedLongIntVal(arg);
+		__argValues[i].iVal = __unsignedLongIntVal(arg);
-if (__argValues[i].iVal == 0) {
+		if (__argValues[i].iVal == 0) {
-__FAIL__(@symbol(InvalidArgument))
+		    __FAIL__(@symbol(InvalidArgument))
-}
+		}
-}
+	    }
-argValuePtr = &(__argValues[i].iVal);
+	    argValuePtr = &(__argValues[i].iVal);
-} else {
+	} else {
-if (__isSymbol(typeSymbol)
+	    if (__isSymbol(typeSymbol)
-&& ((argValueClass = __GLOBAL_GET(typeSymbol)) != nil)) {
+	     && ((argValueClass = __GLOBAL_GET(typeSymbol)) != nil)) {
-if (! __isBehaviorLike(argValueClass)) {
+		if (! __isBehaviorLike(argValueClass)) {
-__FAIL__(@symbol(NonBehaviorArgumentType))
+		    __FAIL__(@symbol(NonBehaviorArgumentType))
-}
+		}
-if (! __qIsSubclassOfExternalAddress(argValueClass)) {
+		if (! __qIsSubclassOfExternalAddress(argValueClass)) {
-__FAIL__(@symbol(NonExternalAddressArgumentType))
+		    __FAIL__(@symbol(NonExternalAddressArgumentType))
-}
+		}
-goto commonPointerTypeArg; /* sorry */
+		goto commonPointerTypeArg; /* sorry */
-} else {
+	    } else {
-__FAIL__(@symbol(UnknownArgumentType))
+		__FAIL__(@symbol(UnknownArgumentType))
-}
+	    }
-}
+	}
-__argTypes[i] = thisType;
+	__argTypes[i] = thisType;
-__argValuePointers[i] = argValuePtr;
+	__argValuePointers[i] = argValuePtr;
 # ifdef VERBOSE
-printf("arg%d: %x\n", i, __argValues[i].iVal);
+	printf("arg%d: %x\n", i, __argValues[i].iVal);
 # endif
 }
 failureInfo = nil;
 __callType = FFI_DEFAULT_ABI;
 # ifdef CALLTYPE_FFI_STDCALL
 if (callTypeNumber == @global(CALLTYPE_API)) {
-__callType = CALLTYPE_FFI_STDCALL;
+	__callType = CALLTYPE_FFI_STDCALL;
 }
 # endif
 # ifdef CALLTYPE_FFI_V8
 if (callTypeNumber == @global(CALLTYPE_V8)) {
-__callType = CALLTYPE_FFI_V8;
+	__callType = CALLTYPE_FFI_V8;
 }
 # endif
 # ifdef CALLTYPE_FFI_V9
 if (callTypeNumber == @global(CALLTYPE_V9)) {
-__callType = CALLTYPE_FFI_V9;
+	__callType = CALLTYPE_FFI_V9;
 }
 # endif
 # ifdef CALLTYPE_FFI_UNIX64
 if (callTypeNumber == @global(CALLTYPE_UNIX64)) {
-__callType = CALLTYPE_FFI_UNIX64;
+	__callType = CALLTYPE_FFI_UNIX64;
 }
 # endif
 if (ffi_prep_cif(&__cif, __callType, __numArgsIncludingThis, __returnType, __argTypesIncludingThis) != FFI_OK) {
-__FAIL__(@symbol(FFIPrepareFailed))
+	__FAIL__(@symbol(FFIPrepareFailed))
 }
 if (async == true) {
 # ifdef VERBOSE
-printf("async call 0x%x\n", codeAddress);
+	printf("async call 0x%x\n", codeAddress);
 # endif
 # ifdef WIN32
-__STX_C_CALL4( "ffi_call", ffi_call, &__cif, codeAddress, __returnValuePointer, __argValuePointersIncludingThis);
+	__STX_C_CALL4( "ffi_call", ffi_call, &__cif, codeAddress, __returnValuePointer, __argValuePointersIncludingThis);
 # else
-__BEGIN_INTERRUPTABLE__
+	__BEGIN_INTERRUPTABLE__
-ffi_call(&__cif, codeAddress, __returnValuePointer, __argValuePointersIncludingThis);
+	ffi_call(&__cif, codeAddress, __returnValuePointer, __argValuePointersIncludingThis);
-__END_INTERRUPTABLE__
+	__END_INTERRUPTABLE__
 # endif
 } else {
-if (unlimitedStack == true) {
+	if (unlimitedStack == true) {
 # ifdef VERBOSE
-printf("UNLIMITEDSTACKCALL call 0x%x\n", codeAddress);
+	    printf("UNLIMITEDSTACKCALL call 0x%x\n", codeAddress);
 # endif
 # if 0
-__UNLIMITEDSTACKCALL__(ffi_call, &__cif, codeAddress, __returnValuePointer, __argValuePointersIncludingThis);
+	    __UNLIMITEDSTACKCALL__(ffi_call, &__cif, codeAddress, __returnValuePointer, __argValuePointersIncludingThis);
 # endif
-} else {
+	} else {
 # ifdef VERBOSE
-printf("call 0x%x\n", codeAddress);
+	    printf("call 0x%x\n", codeAddress);
 # endif
-ffi_call(&__cif, codeAddress, __returnValuePointer, __argValuePointersIncludingThis);
+	    ffi_call(&__cif, codeAddress, __returnValuePointer, __argValuePointersIncludingThis);
-}
+	}
 }
 # ifdef VERBOSE
 printf("retval is %d (0x%x)\n", __returnValue.iVal, __returnValue.iVal);
 # endif
 if ((returnTypeSymbol == @symbol(int))
 || (returnTypeSymbol == @symbol(sint))
 || (returnTypeSymbol == @symbol(sint8))
 || (returnTypeSymbol == @symbol(sint16))
 || (returnTypeSymbol == @symbol(sint32))) {
-RETURN ( __MKINT(__returnValue.iVal) );
+	RETURN ( __MKINT(__returnValue.iVal) );
 }
 if ((returnTypeSymbol == @symbol(uint))
 || (returnTypeSymbol == @symbol(uint8))
 || (returnTypeSymbol == @symbol(uint16))
 || (returnTypeSymbol == @symbol(uint32))) {
-RETURN ( __MKUINT(__returnValue.iVal) );
+	RETURN ( __MKUINT(__returnValue.iVal) );
 }
 if (returnTypeSymbol == @symbol(bool)) {
-RETURN ( __returnValue.iVal ? true : false );
+	RETURN ( __returnValue.iVal ? true : false );
 }
 if (returnTypeSymbol == @symbol(float)) {
-RETURN ( __MKFLOAT(__returnValue.fVal ));
+	RETURN ( __MKFLOAT(__returnValue.fVal ));
 }
 if (returnTypeSymbol == @symbol(double)) {
-RETURN ( __MKFLOAT(__returnValue.dVal ));
+	RETURN ( __MKFLOAT(__returnValue.dVal ));
 }
 if (returnTypeSymbol == @symbol(void)) {
-RETURN ( nil );
+	RETURN ( nil );
 }
 if (returnTypeSymbol == @symbol(char)) {
-RETURN ( __MKCHARACTER(__returnValue.iVal & 0xFF) );
+	RETURN ( __MKCHARACTER(__returnValue.iVal & 0xFF) );
 }
 if (returnTypeSymbol == @symbol(wchar)) {
-RETURN ( __MKUCHARACTER(__returnValue.iVal & 0xFFFF) );
+	RETURN ( __MKUCHARACTER(__returnValue.iVal & 0xFFFF) );
 }
 if (returnTypeSymbol == @symbol(sint64)) {
-RETURN ( __MKINT64(&__returnValue.longLongVal) );
+	RETURN ( __MKINT64(&__returnValue.longLongVal) );
 }
 if (returnTypeSymbol == @symbol(uint64)) {
-RETURN ( __MKUINT64(&__returnValue.longLongVal) );
+	RETURN ( __MKUINT64(&__returnValue.longLongVal) );
 }
 # ifdef VERBOSE
 printf("%x\n", __returnValue.pointerVal);
 # endif
 if (returnTypeSymbol == @symbol(handle)) {
-returnValue = __MKEXTERNALADDRESS(__returnValue.pointerVal);
+	returnValue = __MKEXTERNALADDRESS(__returnValue.pointerVal);
 } else if (returnTypeSymbol == @symbol(pointer)) {
-returnValue = __MKEXTERNALBYTES(__returnValue.pointerVal);
+	returnValue = __MKEXTERNALBYTES(__returnValue.pointerVal);
 } else if (returnTypeSymbol == @symbol(bytePointer)) {
-returnValue = __MKEXTERNALBYTES(__returnValue.pointerVal);
+	returnValue = __MKEXTERNALBYTES(__returnValue.pointerVal);
 } else if (returnTypeSymbol == @symbol(charPointer)) {
-returnValue = __MKSTRING(__returnValue.pointerVal);
+	returnValue = __MKSTRING(__returnValue.pointerVal);
 } else if (returnTypeSymbol == @symbol(wcharPointer)) {
-returnValue = __MKU16STRING(__returnValue.pointerVal);
+	returnValue = __MKU16STRING(__returnValue.pointerVal);
 } else {
-__FAIL__(@symbol(UnknownReturnType2))
+	__FAIL__(@symbol(UnknownReturnType2))
 }
 #else /* no FFI support */
 failureCode = @symbol(FFINotSupported);
 #endif /* HAVE_FFI */
 getOutOfHere: ;
 %}.
 failureCode notNil ifTrue:[
-(failureCode == #UnknownReturnType or:[ failureCode == #UnknownArgumentType ]) ifTrue:[
+	(failureCode == #UnknownReturnType or:[ failureCode == #UnknownArgumentType ]) ifTrue:[
-oldReturnType := returnType.
+	    oldReturnType := returnType.
-oldArgumentTypes := argumentTypes.
+	    oldArgumentTypes := argumentTypes.
-self adjustTypes.
+	    self adjustTypes.
-((oldReturnType ~= returnType) or:[oldArgumentTypes ~= argumentTypes]) ifTrue:[
+	    ((oldReturnType ~= returnType) or:[oldArgumentTypes ~= argumentTypes]) ifTrue:[
-thisContext restart
+		thisContext restart
-].
+	    ].
-].
+	].
-(failureCode == #BadArgForAsyncCall) ifTrue:[
+	(failureCode == #BadArgForAsyncCall) ifTrue:[
-^ self tryAgainWithAsyncSafeArguments:argumentsOrNil forCPPInstance:aCPlusPlusObjectOrNil
+	    ^ self tryAgainWithAsyncSafeArguments:argumentsOrNil forCPPInstance:aCPlusPlusObjectOrNil
-].
+	].
-self primitiveFailed.   "see failureCode and failureInfo for details"
+	self primitiveFailed.   "see failureCode and failureInfo for details"
-^ nil
+	^ nil
 ].
 returnType isSymbol ifTrue:[
-returnValueClass notNil ifTrue:[
+	returnValueClass notNil ifTrue:[
-self isConstReturnValue ifTrue:[
+	    self isConstReturnValue ifTrue:[
-returnValue changeClassTo:returnValueClass.
+		returnValue changeClassTo:returnValueClass.
-^ returnValue
+		^ returnValue
-].
+	    ].
-^ returnValueClass fromExternalAddress:returnValue.
+	    ^ returnValueClass fromExternalAddress:returnValue.
-].
+	].
 ] ifFalse:[
-returnType isCPointer ifTrue:[
+	returnType isCPointer ifTrue:[
-returnType baseType isCStruct ifTrue:[
+	    returnType baseType isCStruct ifTrue:[
-stClass := Smalltalk classNamed:returnType baseType name.
+		stClass := Smalltalk classNamed:returnType baseType name.
-stClass notNil ifTrue:[
+		stClass notNil ifTrue:[
-self isConstReturnValue ifTrue:[
+		    self isConstReturnValue ifTrue:[
-returnValue changeClassTo:returnValueClass.
+			returnValue changeClassTo:returnValueClass.
-^ returnValue
+			^ returnValue
-].
+		    ].
-^ stClass fromExternalAddress:returnValue.
+		    ^ stClass fromExternalAddress:returnValue.
-].
+		].
-].
+	    ].
-returnType baseType isCChar ifTrue:[
+	    returnType baseType isCChar ifTrue:[
-^ returnValue stringAt:1
+		^ returnValue stringAt:1
-].
+	    ].
-].
+	].
 ].
 ^ returnValue
 "Created: / 01-08-2006 / 13:56:23 / cg"
 then try the call again, copy changed values back, and release the memeory."
 |saveArguments anyBadArg result originalToSaveArgMapping|
 argumentsOrNil isNil ifTrue:[
-^ self primitiveFailed
+	^ self primitiveFailed
 ].
 thisContext isRecursive ifTrue: [^self primitiveFailed].
 anyBadArg := false.
 originalToSaveArgMapping := IdentityDictionary new.
 saveArguments := argumentsOrNil
-collect:[:eachArg |
+			collect:[:eachArg |
-|saveArg|
+			    |saveArg|
-(originalToSaveArgMapping includesKey:eachArg) ifTrue:[
+			    (originalToSaveArgMapping includesKey:eachArg) ifTrue:[
-saveArg := originalToSaveArgMapping at:eachArg
+				saveArg := originalToSaveArgMapping at:eachArg
-] ifFalse:[
+			    ] ifFalse:[
-eachArg isString ifTrue:[
+				eachArg isString ifTrue:[
-saveArg := (ExternalBytes fromString:eachArg) register.
+				    saveArg := (ExternalBytes fromString:eachArg) register.
-anyBadArg := true.
+				    anyBadArg := true.
-originalToSaveArgMapping at:eachArg put:saveArg.
+				    originalToSaveArgMapping at:eachArg put:saveArg.
-] ifFalse:[
+				] ifFalse:[
-eachArg isByteCollection ifTrue:[
+				    eachArg isByteCollection ifTrue:[
-saveArg := (ExternalBytes from:eachArg) register.
+					saveArg := (ExternalBytes from:eachArg) register.
-originalToSaveArgMapping at:eachArg put:saveArg.
+					originalToSaveArgMapping at:eachArg put:saveArg.
-anyBadArg := true.
+					anyBadArg := true.
-] ifFalse:[
+				    ] ifFalse:[
-saveArg := eachArg
+					saveArg := eachArg
-]
+				    ]
-].
+				].
-].
+			    ].
-saveArg
+			    saveArg
-].
+			].
 anyBadArg ifFalse:[
-"avoid recursion..."
+	"avoid recursion..."
-^ self primitiveFailed
+	^ self primitiveFailed
 ].
 result := self invokeFFIwithArguments:saveArguments forCPPInstance:aCPlusPlusObjectOrNil.
 "/ copy back !!
 originalToSaveArgMapping keysAndValuesDo:[:arg :saveArg |
-arg isSymbol ifFalse:[
+	arg isSymbol ifFalse:[
-arg replaceFrom:1 to:(arg size) with:saveArg startingAt:1.
+	    arg replaceFrom:1 to:(arg size) with:saveArg startingAt:1.
-].
+	].
-saveArg free.
+	saveArg free.
 ].
 ^ result.
 "Modified (format): / 06-11-2012 / 10:52:41 / anwild"
 ! !
 ! !
 !ExternalLibraryFunction class methodsFor:'documentation'!
 version_CVS
-^ '$Header: /cvs/stx/stx/libbasic/ExternalLibraryFunction.st,v 1.90 2012-11-16 09:27:00 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/ExternalLibraryFunction.st,v 1.91 2013-01-02 12:45:06 cg Exp $'
 !
 version_SVN
 ^ '� Id: ExternalLibraryFunction.st 10643 2011-06-08 21:53:07Z vranyj1  �'
 ! !

changeset 14625	290463096ff5
parent 14516	359e4d2234af
child 14632	6fe0dc1d5377