From 72c6552c2d591fcb49cef2efb70f718df86458e6 Mon Sep 17 00:00:00 2001 From: Simon Marchetto Date: Mon, 16 Jun 2014 12:03:49 +0200 Subject: [PATCH] scilab: unsigned ints typemaps behave same as signed ints (1st commit: scalar) --- .../test-suite/scilab/primitive_ref_runme.sci | 8 +- .../scilab/primitive_types_runme.sci | 20 ++--- Lib/scilab/sciunsignedchar.swg | 80 +++++++++++++------ Lib/scilab/sciunsignedint.swg | 80 +++++++++++++------ Lib/scilab/sciunsignedshort.swg | 78 ++++++++++++------ 5 files changed, 175 insertions(+), 91 deletions(-) diff --git a/Examples/test-suite/scilab/primitive_ref_runme.sci b/Examples/test-suite/scilab/primitive_ref_runme.sci index 87d97d468..9ff400ea5 100644 --- a/Examples/test-suite/scilab/primitive_ref_runme.sci +++ b/Examples/test-suite/scilab/primitive_ref_runme.sci @@ -1,16 +1,16 @@ exec("swigtest.start", -1); checkequal(ref_int(3), 3, "ref_int() test fails."); -checkequal(ref_uint(uint32(3)), uint32(3), "ref_uint() test fails."); +checkequal(ref_uint(uint32(3)), 3, "ref_uint() test fails."); checkequal(ref_short(3), 3, "ref_short() test fails."); -checkequal(ref_ushort(uint16(3)), uint16(3), "ref_ushort() test fails."); +checkequal(ref_ushort(uint16(3)), 3, "ref_ushort() test fails."); checkequal(ref_long(3), 3, "ref_long() test fails."); -checkequal(ref_ulong(uint32(3)), uint32(3), "ref_ulong() test fails."); +checkequal(ref_ulong(uint32(3)), 3, "ref_ulong() test fails."); checkequal(ref_schar(3), 3, "ref_schar() test fails."); -checkequal(ref_uchar(uint8(3)), uint8(3), "ref_uchar() test fails."); +checkequal(ref_uchar(uint8(3)), 3, "ref_uchar() test fails."); checkequal(ref_float(3), 3, "ref_float() test fails."); checkequal(ref_double(3), 3, "ref_double() test fails."); diff --git a/Examples/test-suite/scilab/primitive_types_runme.sci b/Examples/test-suite/scilab/primitive_types_runme.sci index 66c6257d2..423ee44ae 100644 --- a/Examples/test-suite/scilab/primitive_types_runme.sci +++ b/Examples/test-suite/scilab/primitive_types_runme.sci @@ -8,50 +8,50 @@ checkequal(val_float(42), 42, "val_float() test fails."); checkequal(val_char('a'), 'a', "val_char() test fails."); checkequal(val_schar(42), 42, "val_schar() test fails."); checkequal(val_schar(int8(42)), 42, "val_schar() test fails."); -checkequal(val_uchar(uint8(42)), uint8(42), "val_uchar() test fails."); +checkequal(val_uchar(uint8(42)), 42, "val_uchar() test fails."); checkequal(val_short(42), 42, "val_short() test fails."); checkequal(val_short(int16(42)), 42, "val_short() test fails."); -checkequal(val_ushort(uint16(42)), uint16(42), "val_ushort() test fails."); +checkequal(val_ushort(uint16(42)), 42, "val_ushort() test fails."); checkequal(val_int(42), 42, "val_int() test fails."); checkequal(val_int(int32(42)), 42, "val_int() test fails."); -checkequal(val_uint(uint32(42)), uint32(42), "val_uint() test fails."); +checkequal(val_uint(uint32(42)), 42, "val_uint() test fails."); checkequal(val_long(42), 42, "val_long() test fails."); checkequal(val_long(int32(42)), 42, "val_long() test fails."); -checkequal(val_ulong(uint32(42)), uint32(42), "val_long() test fails."); +checkequal(val_ulong(uint32(42)), 42, "val_long() test fails."); checkequal(val_bool(%t), %t, "val_bool() test fails."); // longlong is not supported in Scilab 5.x //checkequal(val_llong(42), 42, "val_llong() test fails."); //checkequal(val_llong(int64(42)), 42, "val_llong() test fails."); -//checkequal(val_ullong(uint64(42)), uint64(42), "val_ullong() test fails."); +//checkequal(val_ullong(uint64(42)), 42, "val_ullong() test fails."); // Check passing by reference checkequal(ref_char('a'), 'a', "ref_char() test fails."); checkequal(ref_schar(42), 42, "ref_schar() test fails."); checkequal(ref_schar(int8(42)), 42, "ref_schar() test fails."); -checkequal(ref_uchar(uint8(42)), uint8(42), "ref_uchar() test fails."); +checkequal(ref_uchar(uint8(42)), 42, "ref_uchar() test fails."); checkequal(ref_short(42), 42, "ref_short() test fails.") checkequal(ref_short(int16(42)), 42, "ref_short() test fails.") -checkequal(ref_ushort(uint16(42)), uint16(42), "ref_ushort() test fails.") +checkequal(ref_ushort(uint16(42)), 42, "ref_ushort() test fails.") checkequal(ref_int(42), 42, "ref_int() test fails."); checkequal(ref_int(int32(42)), 42, "ref_int() test fails."); -checkequal(ref_uint(uint32(42)), uint32(42), "ref_uint() test fails."); +checkequal(ref_uint(uint32(42)), 42, "ref_uint() test fails."); checkequal(ref_long(42), 42, "ref_long() test fails."); checkequal(ref_long(int32(42)), 42, "ref_long() test fails."); -checkequal(ref_ulong(uint32(42)), uint32(42), "ref_ulong() test fails."); +checkequal(ref_ulong(uint32(42)), 42, "ref_ulong() test fails."); checkequal(ref_bool(%t), %t, "ref_bool() test fails."); // long long is not supported in Scilab 5.x //checkequal(ref_llong(42), 42, "ref_llong() test fails."); //checkequal(ref_llong(int64(42)), 42, "ref_llong() test fails."); -//checkequal(ref_ullong(uint64(42)), uint64(42), "ref_ullong() test fails."); +//checkequal(ref_ullong(uint64(42)), 42, "ref_ullong() test fails."); exec("swigtest.quit", -1); diff --git a/Lib/scilab/sciunsignedchar.swg b/Lib/scilab/sciunsignedchar.swg index ad6bbc31c..b538efc83 100644 --- a/Lib/scilab/sciunsignedchar.swg +++ b/Lib/scilab/sciunsignedchar.swg @@ -1,8 +1,8 @@ /* * C-type: unsigned char - * Scilab type: uint8 scalar + * Scilab type: double or uint8 scalar */ -%fragment(SWIG_AsVal_frag(unsigned char), "header", fragment="SWIG_SciUint8_AsUnsignedChar") { +%fragment(SWIG_AsVal_frag(unsigned char), "header", fragment="SWIG_SciUint8_AsUnsignedChar", fragment="") { #define SWIG_AsVal_unsigned_SS_char(scilabValue, valuePointer) SWIG_SciUint8_AsUnsignedChar(pvApiCtx, scilabValue, valuePointer, fname) } %fragment("SWIG_SciUint8_AsUnsignedChar", "header") { @@ -27,32 +27,60 @@ SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int _iVar, unsigned char *_pucValu printError(&sciErr, 0); return SWIG_ERROR; } - if (iType != sci_ints) { - Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer expected.\n"), _fname, _iVar); - return SWIG_ERROR; - } - sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec); - if (sciErr.iErr) { - printError(&sciErr, 0); - return SWIG_ERROR; - } - if (iPrec != SCI_UINT8) { - Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer expected.\n"), _fname, _iVar); - return SWIG_ERROR; - } + if (iType == sci_ints) { + if (_pucValue) { + sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + if (iPrec != SCI_UINT8) { + Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), _fname, _iVar); + return SWIG_ERROR; + } - sciErr = getMatrixOfUnsignedInteger8(_pvApiCtx, piAddrVar, &iRows, &iCols, &pucData); - if (sciErr.iErr) { - printError(&sciErr, 0); + sciErr = getMatrixOfUnsignedInteger8(_pvApiCtx, piAddrVar, &iRows, &iCols, &pucData); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + if (iRows * iCols != 1) { + Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), _fname, _iVar); + return SWIG_ERROR; + } + *_pucValue = *pucData; + } + } + else if (iType == sci_matrix) { + if (_pucValue) { + double *pdData = NULL; + double dValue = 0.0f; + sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + if (iRows * iCols != 1) { + Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), _fname, _iVar); + return SWIG_TypeError; + } + dValue = *pdData; + if (dValue != floor(dValue)) { + Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 8-bit unsigned integer.\n"), _fname, _iVar); + return SWIG_ValueError; + } + if ((dValue < 0) || (dValue > UCHAR_MAX)) { + Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 8-bit unsigned integer.\n"), _fname, _iVar); + return SWIG_OverflowError; + } + *_pucValue = (unsigned char) dValue; + } + } + else { + Scierror(999, _("%s: Wrong type for input argument #%d: A 8-bit unsigned integer or a double expected.\n"), _fname, _iVar); return SWIG_ERROR; } - if (iRows * iCols != 1) { - Scierror(999, _("%s: Wrong size for input argument #%d: A 8-bit unsigned integer expected.\n"), _fname, _iVar); - return SWIG_ERROR; - } - - *_pucValue = *pucData; return SWIG_OK; } @@ -64,8 +92,8 @@ SWIG_SciUint8_AsUnsignedChar(void *_pvApiCtx, int _iVar, unsigned char *_pucValu %fragment("SWIG_SciUint8_FromUnsignedChar", "header") { SWIGINTERN int SWIG_SciUint8_FromUnsignedChar(void *_pvApiCtx, int _iVarOut, unsigned char _ucValue) { - if (createScalarUnsignedInteger8(pvApiCtx, - SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _ucValue)) + if (createScalarDouble(pvApiCtx, + SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, (double) _ucValue)) return SWIG_ERROR; return SWIG_OK; } diff --git a/Lib/scilab/sciunsignedint.swg b/Lib/scilab/sciunsignedint.swg index 2d57cd753..b72e752cb 100644 --- a/Lib/scilab/sciunsignedint.swg +++ b/Lib/scilab/sciunsignedint.swg @@ -1,8 +1,8 @@ /* * C-type: unsigned int - * Scilab type: uint32 scalar + * Scilab type: double or uint32 scalar */ -%fragment(SWIG_AsVal_frag(unsigned int), "header", fragment="SWIG_SciUint32_AsUnsignedInt") { +%fragment(SWIG_AsVal_frag(unsigned int), "header", fragment="SWIG_SciUint32_AsUnsignedInt", fragment="") { %#define SWIG_AsVal_unsigned_SS_int(scilabValue, valuePointer) SWIG_SciUint32_AsUnsignedInt(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFname()) } %fragment("SWIG_SciUint32_AsUnsignedInt", "header") { @@ -27,32 +27,60 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int _iVar, unsigned int *_puiValue printError(&sciErr, 0); return SWIG_ERROR; } - if (iType != sci_ints) { - Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer expected.\n"), _fname, _iVar); - return SWIG_ERROR; - } - sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec); - if (sciErr.iErr) { - printError(&sciErr, 0); - return SWIG_ERROR; - } - if (iPrec != SCI_UINT32) { - Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer expected.\n"), _fname, _iVar); - return SWIG_ERROR; - } + if (iType == sci_ints) { + if (_puiValue) { + sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + if (iPrec != SCI_UINT32) { + Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer expected.\n"), _fname, _iVar); + return SWIG_ERROR; + } - sciErr = getMatrixOfUnsignedInteger32(_pvApiCtx, piAddrVar, &iRows, &iCols, &puiData); - if (sciErr.iErr) { - printError(&sciErr, 0); + sciErr = getMatrixOfUnsignedInteger32(_pvApiCtx, piAddrVar, &iRows, &iCols, &puiData); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + if (iRows * iCols != 1) { + Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit unsigned integer expected.\n"), _fname, _iVar); + return SWIG_ERROR; + } + *_puiValue = *puiData; + } + } + else if (iType == sci_matrix) { + if (_puiValue) { + double *pdData = NULL; + double dValue = 0.0f; + sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + if (iRows * iCols != 1) { + Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), _fname, _iVar); + return SWIG_TypeError; + } + dValue = *pdData; + if (dValue != floor(dValue)) { + Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 32-bit unsigned integer.\n"), _fname, _iVar); + return SWIG_ValueError; + } + if ((dValue < 0) || (dValue > UINT_MAX)) { + Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 32-bit unsigned integer.\n"), _fname, _iVar); + return SWIG_OverflowError; + } + *_puiValue = (unsigned int) dValue; + } + } + else { + Scierror(999, _("%s: Wrong type for input argument #%d: A 32-bit unsigned integer or a double expected.\n"), _fname, _iVar); return SWIG_ERROR; } - if (iRows * iCols != 1) { - Scierror(999, _("%s: Wrong size for input argument #%d: A 32-bit unsigned integer expected.\n"), _fname, _iVar); - return SWIG_ERROR; - } - - *_puiValue = *puiData; return SWIG_OK; } @@ -64,8 +92,8 @@ SWIG_SciUint32_AsUnsignedInt(void *_pvApiCtx, int _iVar, unsigned int *_puiValue %fragment("SWIG_SciUint32_FromUnsignedInt", "header") { SWIGINTERN int SWIG_SciUint32_FromUnsignedInt(void *_pvApiCtx, int _iVarOut, unsigned int _uiValue, char *_fname) { - if (createScalarUnsignedInteger32(_pvApiCtx, - SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, _uiValue)) + if (createScalarDouble(_pvApiCtx, + SWIG_NbInputArgument(_pvApiCtx) + _iVarOut, (double) _uiValue)) return SWIG_ERROR; return SWIG_OK; } diff --git a/Lib/scilab/sciunsignedshort.swg b/Lib/scilab/sciunsignedshort.swg index 8c381b0df..3536bb176 100644 --- a/Lib/scilab/sciunsignedshort.swg +++ b/Lib/scilab/sciunsignedshort.swg @@ -1,8 +1,8 @@ /* * C-type: unsigned short - * Scilab type: uint16 scalar + * Scilab type: double or uint16 scalar */ -%fragment(SWIG_AsVal_frag(unsigned short), "header", fragment="SWIG_SciUint16_AsUnsignedShort") { +%fragment(SWIG_AsVal_frag(unsigned short), "header", fragment="SWIG_SciUint16_AsUnsignedShort", fragment="") { %#define SWIG_AsVal_unsigned_SS_short(scilabValue, valuePointer) SWIG_SciUint16_AsUnsignedShort(pvApiCtx, scilabValue, valuePointer, SWIG_Scilab_GetFname()) } %fragment("SWIG_SciUint16_AsUnsignedShort", "header") { @@ -27,32 +27,60 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int _iVar, unsigned short *_pusV printError(&sciErr, 0); return SWIG_ERROR; } - if (iType != sci_ints) { - Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer expected.\n"), _fname, _iVar); - return SWIG_ERROR; - } - sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec); - if (sciErr.iErr) { - printError(&sciErr, 0); - return SWIG_ERROR; - } - if (iPrec != SCI_UINT16) { - Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer expected.\n"), _fname, _iVar); - return SWIG_ERROR; - } + if (iType == sci_ints) { + if (_pusValue) { + sciErr = getMatrixOfIntegerPrecision(_pvApiCtx, piAddrVar, &iPrec); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + if (iPrec != SCI_UINT16) { + Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer expected.\n"), _fname, _iVar); + return SWIG_ERROR; + } - sciErr = getMatrixOfUnsignedInteger16(_pvApiCtx, piAddrVar, &iRows, &iCols, &pusData); - if (sciErr.iErr) { - printError(&sciErr, 0); + sciErr = getMatrixOfUnsignedInteger16(_pvApiCtx, piAddrVar, &iRows, &iCols, &pusData); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + if (iRows * iCols != 1) { + Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit unsigned integer expected.\n"), _fname, _iVar); + return SWIG_ERROR; + } + *_pusValue = *pusData; + } + } + else if (iType == sci_matrix) { + if (_pusValue) { + double *pdData = NULL; + double dValue = 0.0f; + sciErr = getMatrixOfDouble(_pvApiCtx, piAddrVar, &iRows, &iCols, &pdData); + if (sciErr.iErr) { + printError(&sciErr, 0); + return SWIG_ERROR; + } + if (iRows * iCols != 1) { + Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), _fname, _iVar); + return SWIG_TypeError; + } + dValue = *pdData; + if (dValue != floor(dValue)) { + Scierror(999, _("%s: Incorrect value for input argument #%d: The double value cannot be converted to a 16-bit unsigned integer.\n"), _fname, _iVar); + return SWIG_ValueError; + } + if ((dValue < 0) || (dValue > USHRT_MAX)) { + Scierror(999, _("%s: Overflow error for input argument #%d: The double value cannot be converted to a 16-bit unsigned integer.\n"), _fname, _iVar); + return SWIG_OverflowError; + } + *_pusValue = (unsigned short) dValue; + } + } + else { + Scierror(999, _("%s: Wrong type for input argument #%d: A 16-bit unsigned integer or a double expected.\n"), _fname, _iVar); return SWIG_ERROR; } - if (iRows * iCols != 1) { - Scierror(999, _("%s: Wrong size for input argument #%d: A 16-bit unsigned integer expected.\n"), _fname, _iVar); - return SWIG_ERROR; - } - - *_pusValue = *pusData; return SWIG_OK; } @@ -65,7 +93,7 @@ SWIG_SciUint16_AsUnsignedShort(void *_pvApiCtx, int _iVar, unsigned short *_pusV SWIGINTERN int SWIG_SciUint16_FromUnsignedShort(void *_pvApiCtx, int _iVarOut, unsigned short _usValue, char *_fname) { int iVarOut = SWIG_NbInputArgument(_pvApiCtx) + _iVarOut; - if (createScalarUnsignedInteger16(_pvApiCtx, iVarOut, _usValue)) + if (createScalarDouble(_pvApiCtx, iVarOut, (double) _usValue)) return SWIG_ERROR; return SWIG_OK; }