"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

ExternalLibraryFunction subclass:#SimpleExternalLibraryFunction

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'System-Support'

!

!SimpleExternalLibraryFunction class methodsFor:'documentation'!

documentation

"

    instances of me are used for very simple functions, with all integer or

    equivalent arguments.

    These avoid the realively expensive ffi- arg setup, and jump directly to the

    target function.

    Can be used for a subset of all external functions and only on some machines.

    Only for tuning; the superclass must provide a fallback for all calls

"

! !

!SimpleExternalLibraryFunction methodsFor:'private invoking'!

invokeFFIwithArguments:argumentsOrNil forCPPInstance:aReceiverOrNil

    "the caller must have already checked, if instances of me are appropriate.

     May only be used for up to 10 args, with INT-sized non-float, non-struct arguments,

     and int-sized, non-float, non-struct return value.

     Now, all I do is convert the arguments and transfer directly; without the expensive ffi..."

    |argTypeSymbols returnTypeSymbol failureCode failureArgNr failureInfo returnValue stClass vtOffset

     virtual objectiveC async unlimitedStack callTypeNumber returnValueClass argValueClass

     oldReturnType oldArgumentTypes|

    virtual := self isVirtualCPP.

    objectiveC := self isObjectiveC.

    (virtual "or:[self isNonVirtualCPP]") ifTrue:[

	aReceiverOrNil isNil ifTrue:[

	    "/ must have a c++ object instance

	    self primitiveFailed.

	].

	"/ and it must be a kind of ExternalStructure !!

	(aReceiverOrNil isExternalStructure) ifFalse:[

	    self primitiveFailed.

	].

	virtual ifTrue:[

	    vtOffset := name.

	].

    ] ifFalse:[

	objectiveC ifTrue:[

	    aReceiverOrNil isNil ifTrue:[

		"/ must have an objective-c object instance

		self primitiveFailed.

	    ].

	    (aReceiverOrNil isObjectiveCObject) ifFalse:[

		self primitiveFailed

	    ]

	] ifFalse:[

	    aReceiverOrNil notNil ifTrue:[

		"/ must NOT have a c++/objectiveC object instance

		self primitiveFailed.

	    ]

	].

    ].

%{  /* STACK: 100000 */

#define VERBOSE

#define MAX_ARGS 10

    int __numArgs, __numArgsIncludingThis;

    static INT null = 0;

    INT __args[MAX_ARGS+1];

    INT retVal;

    int i = -1;

    int argIdx = 0;

    INTLFUNC codeAddress = (voidFUNC)__INST(code_);

    int __numArgsWanted;

#   define __FAIL__(fcode) \

    { \

	failureCode = fcode; failureArgNr = __mkSmallInteger(i+1); goto getOutOfHere; \

    }

    if (argumentsOrNil == nil) {

	__numArgs = 0;

    } else if (__isArrayLike(argumentsOrNil)) {

	__numArgs = __arraySize(argumentsOrNil);

    } else {

	__FAIL__(@symbol(BadArgumentVector))

    }

    if (__numArgs != __numArgsWanted) {

	__FAIL__(@symbol(ArgumentCountMismatch))

    }

    if (__numArgs > MAX_ARGS) {

	__FAIL__(@symbol(TooManyArguments))

    }

    /*

     * validate the c++ object

     */

    if (aReceiverOrNil != nil) {

	struct cPlusPlusInstance {

	    void **vTable;

	};

	struct cPlusPlusInstance *inst;

	if (__isExternalAddressLike(aReceiverOrNil)) {

	    inst = (void *)(__externalAddressVal(aReceiverOrNil));

	} else if (__isExternalBytesLike(aReceiverOrNil)) {

	    inst = (void *)(__externalBytesVal(aReceiverOrNil));

	} else {

	    __FAIL__(@symbol(InvalidInstance))

	}

	__args[0] = (INT)inst;

	__numArgsIncludingThis = __numArgs + 1;

	argIdx = 1;

	if (virtual == true) {

	    if (! __isSmallInteger(vtOffset)) {

		__FAIL__(@symbol(InvalidVTableIndex))

	    }

	    codeAddress = inst->vTable[__intVal(vtOffset)];

# ifdef VERBOSE

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

		printf("virtual %d codeAddress: %"_lx_"\n", __intVal(vtOffset), (INT)codeAddress);

	    }

# endif

	}

    } else {

	__numArgsIncludingThis = __numArgs;

# ifdef VERBOSE

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

	    printf("codeAddress: %"_lx_"\n", (INT)codeAddress);

	}

# endif

    }

    /*

     * validate all arg types, map each to an ffi_type, and setup arg-buffers

     */

    for (i=0; i<__numArgs; i++, argIdx++) {

	OBJ arg;

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

	arg = __ArrayInstPtr(argumentsOrNil)->a_element[i];

	if (__isSmallInteger(arg)) {

	    __args[argIdx] = __intVal(arg);

	} else {

	   INT iv = __signedLongIntVal(arg);

	   if (iv != 0) {

		__args[argIdx]  = iv;

	    } else {

		unsigned INT iv = __unsignedLongIntVal(arg);

		if (iv != 0) {

		    __args[argIdx] = iv;

		} else {

		    if (__isStringLike(arg)) {

			__args[argIdx] = (INT)(__stringVal(arg));

		    } else {

			if (__isBytes(arg)) {

			    __args[argIdx] = (INT)(__byteArrayVal(arg));

			    if (arg == NULL) {

				__args[argIdx] = (INT)0;

			    } else {

				if (__isExternalAddressLike(arg)) {

				    __args[argIdx] = (INT)(__externalAddressVal(arg));

				} else {

				    if (__isExternalBytesLike(arg)) {

					__args[argIdx] = (INT)(__externalBytesVal(arg));

				    } else {

					__FAIL__(@symbol(InvalidArgument))

				    }

				}

			    }

			}

		    }

		}

	    }

	}

    }

    failureInfo = nil;

    retVal = (*codeAddress)(__args[0], __args[1], __args[2], __args[3], __args[4], __args[5], __args[6],

			    __args[7], __args[8], __args[9], __args[10]);

# ifdef VERBOSE

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

	printf("retval is %"_ld_" (0x%"_lx_")\n", retVal, retVal);

    }

# endif

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

     || (returnTypeSymbol == @symbol(sint))

     || (returnTypeSymbol == @symbol(sint8))

     || (returnTypeSymbol == @symbol(sint16))

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

# ifdef VERBOSE

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

	    printf("return int: %x\n", retVal);

	}

# endif

	RETURN ( __MKINT(retVal) );

    }

    if ((returnTypeSymbol == @symbol(uint))

     || (returnTypeSymbol == @symbol(uint8))

     || (returnTypeSymbol == @symbol(uint16))

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

# ifdef VERBOSE

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

	    printf("return uint: %x\n", retVal);

	}

# endif

	RETURN ( __MKUINT(retVal) );

    }

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

	RETURN ( retVal ? true : false );

    }

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

	RETURN ( nil );

    }

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

	RETURN ( __MKCHARACTER(retVal & 0xFF) );

    }

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

	RETURN ( __MKUCHARACTER(retVal & 0xFFFF) );

    }

# ifdef VERBOSE

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

	printf("return pointer: %"_lx_"\n", (INT)(retVal));

    }

# endif

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

	returnValue = __MKEXTERNALADDRESS(retVal);

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

	returnValue = __MKEXTERNALBYTES(retVal);

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

	returnValue = __MKEXTERNALBYTES(retVal);

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

	returnValue = __MKSTRING(retVal);

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

	returnValue = __MKU16STRING(retVal);

    } else {

	__FAIL__(@symbol(UnknownReturnType2))

    }

getOutOfHere: ;

%}.

    failureCode notNil ifTrue:[

	(failureCode == #UnknownReturnType or:[ failureCode == #UnknownArgumentType ]) ifTrue:[

	    oldReturnType := returnType.

	    oldArgumentTypes := argumentTypes.

	    self adjustTypes.

	    ((oldReturnType ~= returnType) or:[oldArgumentTypes ~= argumentTypes]) ifTrue:[

		thisContext restart

	    ].

	].

	(failureCode == #BadArgForAsyncCall) ifTrue:[

	    ^ self tryAgainWithAsyncSafeArguments:argumentsOrNil forCPPInstance:aReceiverOrNil

	].

	(failureCode == #FFINotSupported) ifTrue:[

	    self primitiveFailed:'FFI support missing in this build'.

	].

	self primitiveFailed.   "see failureCode and failureInfo for details"

	^ nil

    ].

    returnType isSymbol ifTrue:[

	returnValueClass notNil ifTrue:[

	    self isConstReturnValue ifTrue:[

		returnValue changeClassTo:returnValueClass.

		^ returnValue

	    ].

	    ^ returnValueClass fromExternalAddress:returnValue.

	].

    ] ifFalse:[

	returnType isCPointer ifTrue:[

	    returnType baseType isCStruct ifTrue:[

		stClass := Smalltalk classNamed:returnType baseType name.

		stClass notNil ifTrue:[

		    self isConstReturnValue ifTrue:[

			returnValue changeClassTo:returnValueClass.

			^ returnValue

		    ].

		    ^ stClass fromExternalAddress:returnValue.

		].

	    ].

	    returnType baseType isCChar ifTrue:[

		^ returnValue stringAt:1

	    ].

	].

    ].

    ^ returnValue

    "Created: / 01-08-2006 / 13:56:23 / cg"

    "Modified: / 31-03-2016 / 00:03:03 / cg"

! !

!SimpleExternalLibraryFunction class methodsFor:'documentation'!

version

    ^ '$Header$'

!

version_CVS

    ^ '$Header$'

! !