| // Scilab fragments for primitive types |
| %include <sciprimtypes.swg> |
| |
| %include <scienum.swg> |
| |
| // Scilab object type |
| #define SWIG_Object int |
| |
| #define %append_output(obj) if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, obj))) return SWIG_ERROR |
| #define %set_constant(name, obj) if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, obj))) return SWIG_ERROR // Name is managed by the function name |
| #define %raise(obj, type, desc) SWIG_Scilab_Raise(obj, type, desc) |
| #define %set_output(obj) if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, obj))) return SWIG_ERROR |
| #define %set_varoutput(obj) if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, obj))) return SWIG_ERROR |
| #define %set_argoutput(obj) if (!SWIG_IsOK(SWIG_Scilab_SetOutput(pvApiCtx, obj))) return SWIG_ERROR |
| |
| // Include the unified typemap library |
| %include <typemaps/swigtypemaps.swg> |
| |
| /* ---------------------------------------------------------------------------*/ |
| /* Generic typmemaps */ |
| /* */ |
| /* This typemap is used when Scilab does not store this type directly */ |
| /* For example, a 'float' is stored in Scilab as a 'double' */ |
| /* So we read a 'double' in Scilab and cast it to a 'float' */ |
| /* ---------------------------------------------------------------------------*/ |
| |
| %define %scilab_in_typemap_withcast(TYPEMAPTYPE, FRAGMENTNAME, CTYPE, TEMPTYPE, TEMPINIT) |
| %typemap(TYPEMAPTYPE, fragment="FRAGMENTNAME") CTYPE { |
| TEMPTYPE tempValue = TEMPINIT; |
| if(FRAGMENTNAME(pvApiCtx, $input, &tempValue, SWIG_Scilab_GetFuncName()) != SWIG_OK) { |
| return SWIG_ERROR; |
| } |
| $1 = (CTYPE) tempValue; |
| } |
| %enddef |
| %define %scilab_inptr_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE) |
| %typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE { |
| if (FRAGMENTNAME(pvApiCtx, $input, %as_voidptrptr(&$1), SWIG_Scilab_GetFuncName()) != SWIG_OK) { |
| return SWIG_ERROR; |
| } |
| } |
| %enddef |
| |
| %define %scilab_out_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE) |
| %typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE { |
| if (FRAGMENTNAME(pvApiCtx, $result, $1) != SWIG_OK) { |
| return SWIG_ERROR; |
| } |
| } |
| %enddef |
| |
| %define %scilab_outptr_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE) |
| %typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE { |
| if (FRAGMENTNAME(pvApiCtx, $result, %as_voidptr($1)) != SWIG_OK) { |
| return SWIG_ERROR; |
| } |
| } |
| %enddef |
| |
| %define %scilab_varout_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE) |
| %typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE { |
| if (FRAGMENTNAME(pvApiCtx, $result, $value) != SWIG_OK) { |
| return SWIG_ERROR; |
| } |
| } |
| %enddef |
| |
| %define %scilab_varoutptr_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE) |
| %typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE { |
| if (FRAGMENTNAME(pvApiCtx, $result, %as_voidptr($value)) != SWIG_OK) { |
| return SWIG_ERROR; |
| } |
| } |
| %enddef |
| |
| %define %scilab_in_typemap(TYPEMAPTYPE, FRAGMENTNAME, CTYPE) |
| %typemap(TYPEMAPTYPE, noblock=1, fragment="FRAGMENTNAME") CTYPE { |
| if (FRAGMENTNAME(pvApiCtx, $input, &$1, SWIG_Scilab_GetFuncName()) != SWIG_OK) { |
| return SWIG_ERROR; |
| } |
| } |
| %enddef |
| |
| |
| /* ---------------------------------------------------------------------------*/ |
| /* Array typmemaps */ |
| /* ---------------------------------------------------------------------------*/ |
| |
| %include <sciarray.swg> |
| |
| |
| /* ---------------------------------------------------------------------------*/ |
| /* Enum typemaps */ |
| /* ---------------------------------------------------------------------------*/ |
| |
| %typemap(in, noblock=1, fragment=SWIG_AsVal_frag(Enum)) enum SWIGTYPE (int val) { |
| if (SWIG_AsVal_dec(Enum)($input, &val) != SWIG_OK) { |
| return SWIG_ERROR; |
| } |
| $1 = %static_cast(val, $1_ltype); |
| } |
| |
| %typemap(out, fragment=SWIG_From_frag(Enum)) enum SWIGTYPE { |
| if (SWIG_From_dec(Enum)($1) != SWIG_OK) { |
| return SWIG_ERROR; |
| } |
| } |
| |
| /* ---------------------------------------------------------------------------*/ |
| /* Typecheck typemaps */ |
| /* ---------------------------------------------------------------------------*/ |
| |
| %define %scilab_typecheck_generic(PRECEDENCE, TYPE_CHECK_FUNCTION, TYPE) |
| %typecheck(PRECEDENCE) TYPE { |
| int *piAddrVar = NULL; |
| SciErr sciErr = getVarAddressFromPosition(pvApiCtx, $input, &piAddrVar); |
| if (sciErr.iErr) { |
| printError(&sciErr, 0); |
| return SWIG_ERROR; |
| } |
| $1 = TYPE_CHECK_FUNCTION(pvApiCtx, piAddrVar); |
| } |
| %enddef |
| |
| %fragment("SWIG_Check_SciDoubleOrInt", "header") { |
| SWIGINTERN int |
| SWIG_Check_SciDoubleOrInt(void *pvApiCtx, SwigSciObject iVar, int iIntegerType) { |
| int *piAddrVar = NULL; |
| int ret = 0; |
| SciErr sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddrVar); |
| if (sciErr.iErr) { |
| printError(&sciErr, 0); |
| return 0; |
| } |
| ret = isIntegerType(pvApiCtx, piAddrVar); |
| if (ret == 1) { |
| int iPrec = 0; |
| sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrVar, &iPrec); |
| if (sciErr.iErr) { |
| printError(&sciErr, 0); |
| return 0; |
| } |
| ret = (iPrec == iIntegerType) ? 1 : 0; |
| } |
| else { |
| ret = isDoubleType(pvApiCtx, piAddrVar); |
| } |
| return ret; |
| } |
| } |
| |
| /* Scilab equivalent for C integers can be sci_intXX or sci_matrix */ |
| %define %scilab_typecheck_integer(PRECEDENCE, INTTYPE, TYPE) |
| %typecheck(PRECEDENCE, fragment="SWIG_Check_SciDoubleOrInt") TYPE { |
| $1 = SWIG_Check_SciDoubleOrInt(pvApiCtx, $input, INTTYPE); |
| } |
| %enddef |
| |
| %define %scilab_typecheck_pointer(PRECEDENCE, TYPE) |
| %typecheck(PRECEDENCE) TYPE { |
| $1 = SwigScilabCheckPtr(pvApiCtx, $input, $descriptor, SWIG_Scilab_GetFuncName()); |
| } |
| %enddef |
| |
| |
| // Double (and Float) have priority over before Integer type. |
| |
| // Primitive types |
| %scilab_typecheck_pointer(SWIG_TYPECHECK_VOIDPTR, SWIGTYPE *) |
| %scilab_typecheck_pointer(SWIG_TYPECHECK_POINTER, SWIGTYPE *) |
| %scilab_typecheck_generic(SWIG_TYPECHECK_BOOL, isBooleanType, bool) |
| %scilab_typecheck_generic(16, isDoubleType, double) |
| %scilab_typecheck_generic(17, isDoubleType, float) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_INT8, SCI_INT8, signed char) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_UINT8, SCI_UINT8, unsigned char) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_INT16, SCI_INT16, short) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_UINT16, SCI_UINT16, unsigned short) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_INT32, SCI_INT32, int) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_INT32, SCI_INT32, long) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_UINT32, SCI_UINT32, unsigned int) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_UINT32, SCI_UINT32, unsigned long) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_INT32, SCI_INT32, enum SWIGTYPE) |
| %scilab_typecheck_generic(SWIG_TYPECHECK_CHAR, isStringType, char) |
| |
| // Arrays |
| %scilab_typecheck_generic(SWIG_TYPECHECK_BOOL_ARRAY, isBooleanType, bool) |
| %scilab_typecheck_generic(1016, isDoubleType, double [ANY]) |
| %scilab_typecheck_generic(1017, isDoubleType, float [ANY]) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_INT8_ARRAY, SCI_INT8, signed char [ANY]) |
| %scilab_typecheck_integer(1026, SCI_UINT8, unsigned char [ANY]) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_INT16_ARRAY, SCI_INT16, short [ANY]) |
| %scilab_typecheck_integer(1036, SCI_UINT16, unsigned short [ANY]) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_INT32_ARRAY, SCI_INT32, int [ANY]) |
| %scilab_typecheck_integer(SWIG_TYPECHECK_INT32_ARRAY, SCI_INT32, long [ANY]) |
| %scilab_typecheck_integer(1046, SCI_UINT32, unsigned int [ANY]) |
| %scilab_typecheck_integer(1046, SCI_UINT32, unsigned long [ANY]) |
| %scilab_typecheck_generic(SWIG_TYPECHECK_CHAR_ARRAY, isStringType, char [ANY]) |
| %scilab_typecheck_generic(SWIG_TYPECHECK_STRING_ARRAY, isStringType, char *[ANY]) |
| %scilab_typecheck_generic(SWIG_TYPECHECK_STRING_ARRAY, isStringType, char **) |
| |
| |
| /* ---------------------------------------------------------------------------*/ |
| /* %scilabconstcode() feature typemaps */ |
| /* ---------------------------------------------------------------------------*/ |
| |
| %typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(double)) double |
| %{ |
| if (SWIG_CreateScilabVariable_double(pvApiCtx, "$result", $value) != SWIG_OK) |
| return SWIG_ERROR; |
| %} |
| |
| %typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(int)) int |
| %{ |
| if (SWIG_CreateScilabVariable_int(pvApiCtx, "$result", $value) != SWIG_OK) |
| return SWIG_ERROR; |
| %} |
| |
| %typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(uint)) unsigned int |
| %{ |
| if (SWIG_CreateScilabVariable_uint(pvApiCtx, "$result", $value) != SWIG_OK) |
| return SWIG_ERROR; |
| %} |
| |
| %typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(int)) long |
| %{ |
| if (SWIG_CreateScilabVariable_int(pvApiCtx, "$result", $value) != SWIG_OK) |
| return SWIG_ERROR; |
| %} |
| |
| %typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(uint)) unsigned long |
| %{ |
| if (SWIG_CreateScilabVariable_uint(pvApiCtx, "$result", $value) != SWIG_OK) |
| return SWIG_ERROR; |
| %} |
| |
| %typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(char)) char |
| %{ |
| if (SWIG_CreateScilabVariable_char(pvApiCtx, "$result", $value) != SWIG_OK) |
| return SWIG_ERROR; |
| %} |
| |
| %typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(charptr)) char * |
| %{ |
| if (SWIG_CreateScilabVariable_charptr(pvApiCtx, "$result", $value) != SWIG_OK) |
| return SWIG_ERROR; |
| %} |
| |
| %typemap(scilabconstcode, fragment=SWIG_CreateScilabVariable_frag(double)) enum SWIGTYPE |
| %{ |
| if (SWIG_CreateScilabVariable_double(pvApiCtx, "$result", $value) != SWIG_OK) |
| return SWIG_ERROR; |
| %} |
| |
| |
| /* ---------------------------------------------------------------------------*/ |
| /* Exception typmemaps */ |
| /* ---------------------------------------------------------------------------*/ |
| |
| %include <sciexception.swg> |