int read_integer(char *fname, void* pvApiCtx)
{
SciErr sciErr;
//output variable info
int iRows8 = 0;
int iCols8 = 0;
int iRows16 = 0;
int iCols16 = 0;
int iRows32 = 0;
int iCols32 = 0;
int iRowsu8 = 0;
int iColsu8 = 0;
int iRowsu16 = 0;
int iColsu16 = 0;
int iRowsu32 = 0;
int iColsu32 = 0;
int iPrec = 0;
int* piAddr8 = NULL;
int* piAddr16 = NULL;
int* piAddr32 = NULL;
int* piAddru8 = NULL;
int* piAddru16 = NULL;
int* piAddru32 = NULL;
char* pcData = NULL;
short* psData = NULL;
int* piData = NULL;
unsigned char* pucData = NULL;
unsigned short* pusData = NULL;
unsigned int* puiData = NULL;
char* pcDataOut = NULL;
short* psDataOut = NULL;
int* piDataOut = NULL;
unsigned char* pucDataOut = NULL;
unsigned short* pusDataOut = NULL;
unsigned int* puiDataOut = NULL;
//check input/output arguments count
CheckInputArgument(pvApiCtx, 6, 6);
CheckOutputArgument(pvApiCtx, 6, 6);
//get variable address
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr8);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddru8);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr16);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddru16);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr32);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddru32);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//check variable precision
sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr8, &iPrec);
if (sciErr.iErr || iPrec != SCI_INT8)
{
printError(&sciErr, 0);
return 0;
}
//check variable precision
sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru8, &iPrec);
if (sciErr.iErr || iPrec != SCI_UINT8)
{
printError(&sciErr, 0);
return 0;
}
//check variable precision
sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr16, &iPrec);
if (sciErr.iErr || iPrec != SCI_INT16)
{
printError(&sciErr, 0);
return 0;
}
//check variable precision
sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru16, &iPrec);
if (sciErr.iErr || iPrec != SCI_UINT16)
{
printError(&sciErr, 0);
return 0;
}
//check variable precision
sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr32, &iPrec);
if (sciErr.iErr || iPrec != SCI_INT32)
{
printError(&sciErr, 0);
return 0;
}
//check variable precision
sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru32, &iPrec);
if (sciErr.iErr || iPrec != SCI_UINT32)
{
printError(&sciErr, 0);
return 0;
}
//retrieve dimensions and data
sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//retrieve dimensions and data
sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddru8, &iRowsu8, &iColsu8, &pucData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//retrieve dimensions and data
sciErr = getMatrixOfInteger16(pvApiCtx, piAddr16, &iRows16, &iCols16, &psData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//retrieve dimensions and data
sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddru16, &iRowsu16, &iColsu16, &pusData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//retrieve dimensions and data
sciErr = getMatrixOfInteger32(pvApiCtx, piAddr32, &iRows32, &iCols32, &piData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//retrieve dimensions and data
sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddru32, &iRowsu32, &iColsu32, &puiData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//alloc and fill new variable
pcDataOut = (char*)create_output(2, 1, iRows8, iCols8, (void*)pcData);
pucDataOut = (unsigned char*)create_output(4, 1, iRowsu8, iColsu8, (void*)pucData);
psDataOut = (short*)create_output(8, 2, iRows16, iCols16, (void*)psData);
pusDataOut = (unsigned short*)create_output(16, 2, iRowsu16, iColsu16, (void*)pusData);
piDataOut = (int*)create_output(32, 4, iRows32, iCols32, (void*)piData);
puiDataOut = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData);
//create new variable
sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows8, iCols8, pcDataOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//create new variable
sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 2, iRowsu8, iColsu8, pucDataOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//create new variable
sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 3, iRows16, iCols16, psDataOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//create new variable
sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 4, iRowsu16, iColsu16, pusDataOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//create new variable
sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 5, iRows32, iCols32, piDataOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//create new variable
sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 6, iRowsu32, iColsu32, puiDataOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
FREE(pcDataOut);
FREE(pucDataOut);
FREE(psDataOut);
FREE(pusDataOut);
FREE(piDataOut);
FREE(puiDataOut);
//assign allocated variables to Lhs position
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
return 0;
}
matvar_t *GetIntegerVariable(void *pvApiCtx, int iVar, const char *name, int * parent, int item_position)
{
int rank = 0;
size_t *pszDims = NULL;
int *piDims = NULL;
matvar_t *createdVar = NULL;
int * var_addr = NULL;
int i;
int var_type;
int integerType;
SciErr sciErr;
char * tmp_int8 = NULL;
short * tmp_int16 = NULL;
int * tmp_int32 = NULL;
int * item_addr = NULL;
unsigned char * tmp_uint8 = NULL;
unsigned short * tmp_uint16 = NULL;
unsigned int * tmp_uint32 = NULL;
#ifdef __SCILAB_INT64__
long long * tmp_int64 = NULL;
unsigned long long * tmp_uint64 = NULL;
#endif
if (parent == NULL)
{
sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &var_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarType(pvApiCtx, var_addr, &var_type);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
}
else
{
sciErr = getListItemAddress(pvApiCtx, parent, item_position, &item_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarType(pvApiCtx, item_addr, &var_type);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
}
if (var_type == sci_ints) /* 2-D array */
{
rank = 2;
if ((pszDims = (size_t*)MALLOC(sizeof(size_t) * rank)) == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "GetIntegerVariable");
return NULL;
}
if ((piDims = (int*)MALLOC(sizeof(int) * rank)) == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "GetIntegerVariable");
return NULL;
}
if (parent == NULL)
{
sciErr = getMatrixOfIntegerPrecision(pvApiCtx, var_addr, &integerType);
}
else
{
sciErr = getMatrixOfIntegerPrecision(pvApiCtx, item_addr, &integerType);
}
switch (integerType)
{
case SCI_INT8: /* INT8 */
if (parent == NULL)
{
sciErr = getMatrixOfInteger8(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_int8);
}
else
{
sciErr = getMatrixOfInteger8InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_int8);
}
for (i = 0; i < rank; i++)
{
pszDims[i] = piDims[i];
}
createdVar = Mat_VarCreate(name, MAT_C_INT8, MAT_T_INT8, rank, pszDims, tmp_int8, 0);
break;
case SCI_INT16: /* INT16 */
if (parent == NULL)
{
sciErr = getMatrixOfInteger16(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_int16);
}
else
{
sciErr = getMatrixOfInteger16InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_int16);
}
for (i = 0; i < rank; i++)
{
pszDims[i] = piDims[i];
}
createdVar = Mat_VarCreate(name, MAT_C_INT16, MAT_T_INT16, rank, pszDims, tmp_int16, 0);
break;
case SCI_INT32: /* INT32 */
if (parent == NULL)
{
sciErr = getMatrixOfInteger32(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_int32);
}
else
{
sciErr = getMatrixOfInteger32InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_int32);
}
for (i = 0; i < rank; i++)
{
pszDims[i] = piDims[i];
}
createdVar = Mat_VarCreate(name, MAT_C_INT32, MAT_T_INT32, rank, pszDims, tmp_int32, 0);
break;
case SCI_UINT8: /* UINT8 */
if (parent == NULL)
{
sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_uint8);
}
else
{
sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_uint8);
}
for (i = 0; i < rank; i++)
{
pszDims[i] = piDims[i];
}
createdVar = Mat_VarCreate(name, MAT_C_UINT8, MAT_T_UINT8, rank, pszDims, tmp_uint8, 0);
break;
case SCI_UINT16: /* UINT16 */
if (parent == NULL)
{
sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_uint16);
}
else
{
sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_uint16);
}
for (i = 0; i < rank; i++)
{
pszDims[i] = piDims[i];
}
createdVar = Mat_VarCreate(name, MAT_C_UINT16, MAT_T_UINT16, rank, pszDims, tmp_uint16, 0);
break;
case SCI_UINT32: /* UINT32 */
if (parent == NULL)
{
sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_uint32);
}
else
{
sciErr = getMatrixOfUnsignedInteger32InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_uint32);
}
for (i = 0; i < rank; i++)
{
pszDims[i] = piDims[i];
}
createdVar = Mat_VarCreate(name, MAT_C_UINT32, MAT_T_UINT32, rank, pszDims, tmp_uint32, 0);
break;
default:
createdVar = NULL;
break;
}
}
else
{
Scierror(999, _("%s: Wrong type for first input argument: Integer matrix expected.\n"), "GetIntegerVariable");
}
FREE(pszDims);
FREE(piDims);
return createdVar;
}
static int serialize_int(void *_pvCtx, int *_piAddr, int **_piBuffer, int *_piBufferSize)
{
SciErr sciErr;
int iPrecision = 0;
int iRows = 0;
int iCols = 0;
int iItemSize = 0;
void *p = NULL;
void *pvData = NULL;
int *piOut = NULL;
int iOutLen = 0;
sciErr = getVarDimension(_pvCtx, _piAddr, &iRows, &iCols);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddr, &iPrecision);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (iPrecision == SCI_INT8 || iPrecision == SCI_UINT8)
{
iItemSize = sizeof(char);
}
else if (iPrecision == SCI_INT16 || iPrecision == SCI_UINT16)
{
iItemSize = sizeof(short);
}
else if (iPrecision == SCI_INT32 || iPrecision == SCI_UINT32)
{
iItemSize = sizeof(int);
}
/*
else if(iPrecision == SCI_INT64 || iPrecision == SCI_UINT64)
{
iItemSize = sizeof(long long);
}
*/
//check and adjust alignement on integer
iOutLen = iRows * iCols;
if ((iOutLen * iItemSize) % sizeof(int))
{
iOutLen = (iOutLen * iItemSize) / sizeof(int) + 1;
}
else
{
iOutLen = (iOutLen * iItemSize) / (sizeof(int));
}
iOutLen += 4;
piOut = (int *)MALLOC(iOutLen * sizeof(int *));
if (piOut == NULL)
{
return 1;
}
piOut[0] = sci_ints;
piOut[1] = iRows;
piOut[2] = iCols;
piOut[3] = iPrecision; //precision
switch (iPrecision)
{
case SCI_INT8:
{
sciErr = getMatrixOfInteger8(_pvCtx, _piAddr, &iRows, &iCols, (char **)&pvData);
break;
}
case SCI_UINT8:
{
sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _piAddr, &iRows, &iCols, (unsigned char **)&pvData);
break;
}
case SCI_INT16:
{
sciErr = getMatrixOfInteger16(_pvCtx, _piAddr, &iRows, &iCols, (short **)&pvData);
break;
}
case SCI_UINT16:
{
sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _piAddr, &iRows, &iCols, (unsigned short **)&pvData);
break;
}
case SCI_INT32:
{
sciErr = getMatrixOfInteger32(_pvCtx, _piAddr, &iRows, &iCols, (int **)&pvData);
break;
}
case SCI_UINT32:
{
sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _piAddr, &iRows, &iCols, (unsigned int **)&pvData);
break;
}
/*
case SCI_INT64 :
{
sciErr = getMatrixOfInteger64(_pvCtx, _piAddr, &iRows, &iCols, (long long**)&pvData);
break;
}
case SCI_UINT64 :
{
sciErr = getMatrixOfUnsignedInteger64(_pvCtx, _piAddr, &iRows, &iCols, (unsigned long long**)&pvData);
break;
}
*/ default:
FREE(piOut);
return 1;
}
if (sciErr.iErr)
{
FREE(piOut);
printError(&sciErr, 0);
return 1;
}
p = piOut + 4;
memcpy(p, pvData, iRows * iCols * iItemSize);
*_piBuffer = piOut;
*_piBufferSize = iOutLen;
return 0;
}
int ScilabGateway::invoke_lu(char * fname, const int envId, void * pvApiCtx)
{
SciErr err;
int typ = 0;
int * addr = 0;
int * listaddr = 0;
int len = 0;
int * tmpvar = 0;
int idObj = 0;
int * args = 0;
int * child = 0;
char * methName = 0;
int * eId;
int row, col;
int * ret = 0;
int nbArgs = 0;
std::vector<int> torem;
CheckInputArgument(pvApiCtx, 4, 4);
err = getVarAddressFromPosition(pvApiCtx, 4, &listaddr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
err = getVarType(pvApiCtx, listaddr, &typ);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (typ != sci_list)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A List expected."), 4);
}
err = getListItemNumber(pvApiCtx, listaddr, &len);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
// Get the environment id
err = getVarAddressFromPosition(pvApiCtx, 2, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
err = getVarType(pvApiCtx, addr, &typ);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (typ != sci_ints)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An Integer32 expected."), 2);
}
else
{
int prec;
err = getMatrixOfIntegerPrecision(pvApiCtx, addr, &prec);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (prec != SCI_INT32)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An Integer32 expected."), 2);
}
err = getMatrixOfInteger32(pvApiCtx, addr, &row, &col, &eId);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(*eId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
// Get the object id
err = getVarAddressFromPosition(pvApiCtx, 1, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
err = getVarType(pvApiCtx, addr, &typ);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (typ != sci_ints)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An Integer32 expected."), 1);
}
else
{
int prec;
int * id;
err = getMatrixOfIntegerPrecision(pvApiCtx, addr, &prec);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (prec != SCI_INT32)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An Integer32 expected."), 1);
}
err = getMatrixOfInteger32(pvApiCtx, addr, &row, &col, &id);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
idObj = *id;
}
if (idObj == 0)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Cannot invoke on null object."), __FILE__, __LINE__);
}
tmpvar = new int[len + 1];
*tmpvar = 0;
args = new int[len];
nbArgs = len;
for (int i = 0; i < len; i++)
{
err = getListItemAddress(pvApiCtx, listaddr, i + 1, &child);
if (err.iErr)
{
delete[] args;
ScilabObjects::removeTemporaryVars(*eId, tmpvar);
delete[] tmpvar;
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
try
{
args[i] = ScilabObjects::getArgumentId(child, tmpvar, false, false, *eId, pvApiCtx);
}
catch (ScilabAbstractEnvironmentException & e)
{
delete[] args;
delete[] tmpvar;
throw;
}
if (args[i] == VOID_OBJECT)
{
nbArgs = 0;
}
}
try
{
methName = ScilabObjects::getSingleString(3, pvApiCtx);
}
catch (ScilabAbstractEnvironmentException & e)
{
delete[] args;
ScilabObjects::removeTemporaryVars(*eId, tmpvar);
delete[] tmpvar;
throw;
}
try
{
ret = env.invoke(idObj, methName, args, nbArgs);
}
catch (std::exception & e)
{
delete[] args;
ScilabObjects::removeTemporaryVars(*eId, tmpvar);
delete[] tmpvar;
freeAllocatedSingleString(methName);
throw;
}
delete[] args;
ScilabObjects::removeTemporaryVars(*eId, tmpvar);
delete[] tmpvar;
freeAllocatedSingleString(methName);
if (!ret || *ret <= 0 || (*ret == 1 && ret[1] == VOID_OBJECT))
{
if (ret)
{
delete[] ret;
}
PutLhsVar();
return 0;
}
torem.reserve(*ret);
for (int i = 1; i <= *ret; i++)
{
if (!ScilabObjects::unwrap(ret[i], Rhs + i, *eId, pvApiCtx))
{
try
{
ScilabObjects::createEnvironmentObjectAtPos(EXTERNAL_OBJECT, Rhs + i, ret[i], *eId, pvApiCtx);
}
catch (ScilabAbstractEnvironmentException & e)
{
if (!torem.empty())
{
env.removeobject(&(torem[0]), torem.size());
}
env.removeobject(ret + 1, *ret);
delete[] ret;
throw;
}
}
else
{
torem.push_back(ret[i]);
}
LhsVar(i) = Rhs + i;
}
if (!torem.empty())
{
env.removeobject(&(torem[0]), torem.size());
}
delete[] ret;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
SciErr getDimFromVar(void *_pvCtx, int *_piAddress, int *_piVal)
{
SciErr sciErr;
sciErr.iErr = 0;
sciErr.iMsgCount = 0;
int iType = 0;
int iRows = 0;
int iCols = 0;
double *pdblReal = NULL;
sciErr = getVarType(_pvCtx, _piAddress, &iType);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument type"), "getDimFromVar");
return sciErr;
}
if (iType == sci_matrix)
{
if (isVarComplex(_pvCtx, _piAddress))
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for argument %d: Real matrix expected.\n"), "getDimFromVar",
getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
sciErr = getMatrixOfDouble(_pvCtx, _piAddress, &iRows, &iCols, &pdblReal);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = (int)Max(pdblReal[0], 0);
}
else if (iType == sci_ints)
{
int iPrec = 0;
sciErr = getVarDimension(_pvCtx, _piAddress, &iRows, &iCols);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument dimension"), "getDimFromVar");
return sciErr;
}
if (iRows != 1 || iCols != 1)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong size for argument %d: (%d,%d) expected.\n"), "getProcessMode",
getRhsFromAddress(_pvCtx, _piAddress), 1, 1);
return sciErr;
}
sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddress, &iPrec);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument precision"), "getDimFromVar");
return sciErr;
}
switch (iPrec)
{
case SCI_INT8:
{
char *pcData = NULL;
sciErr = getMatrixOfInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pcData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = pcData[0];
}
break;
case SCI_UINT8:
{
unsigned char *pucData = NULL;
sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _piAddress, &iRows, &iCols, &pucData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = pucData[0];
}
break;
case SCI_INT16:
{
short *psData = NULL;
sciErr = getMatrixOfInteger16(_pvCtx, _piAddress, &iRows, &iCols, &psData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = psData[0];
}
break;
case SCI_UINT16:
{
unsigned short *pusData = NULL;
sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _piAddress, &iRows, &iCols, &pusData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = pusData[0];
}
break;
case SCI_INT32:
{
int *piData = NULL;
sciErr = getMatrixOfInteger32(_pvCtx, _piAddress, &iRows, &iCols, &piData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = piData[0];
}
break;
case SCI_UINT32:
{
unsigned int *puiData = NULL;
sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _piAddress, &iRows, &iCols, &puiData);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Unable to get argument data"), "getDimFromVar");
return sciErr;
}
*_piVal = puiData[0];
}
break;
}
}
else
{
addErrorMessage(&sciErr, API_ERROR_GET_DIMFROMVAR, _("%s: Wrong type for input argument #%d: A real scalar or an integer scalar expected.\n"),
"getDimFromVar", getRhsFromAddress(_pvCtx, _piAddress));
return sciErr;
}
return sciErr;
}
/*--------------------------------------------------------------------------*/
int sci_fftw_flags(char *fname, unsigned long fname_len)
{
/* declaration of variables to store scilab parameters address */
static int m1 = 0, n1 = 0;
char **Str1 = NULL;
char **Str3 = NULL;
unsigned int uiVar1 = 0;
int* piDataOut = NULL;
int* piAddr1 = NULL;
int* piLen = NULL;
int iType = 0;
/* please update me ! */
static int nb_flag = 22;
static char *Str[] =
{
/* documented flags */
"FFTW_MEASURE",
"FFTW_DESTROY_INPUT",
"FFTW_UNALIGNED",
"FFTW_CONSERVE_MEMORY",
"FFTW_EXHAUSTIVE",
"FFTW_PRESERVE_INPUT",
"FFTW_PATIENT",
"FFTW_ESTIMATE",
/* undocumented beyond-guru flags */
"FFTW_ESTIMATE_PATIENT",
"FFTW_BELIEVE_PCOST",
"FFTW_NO_DFT_R2HC",
"FFTW_NO_NONTHREADED",
"FFTW_NO_BUFFERING",
"FFTW_NO_INDIRECT_OP",
"FFTW_ALLOW_LARGE_GENERIC",
"FFTW_NO_RANK_SPLITS",
"FFTW_NO_VRANK_SPLITS",
"FFTW_NO_VRECURSE",
"FFTW_NO_SIMD",
"FFTW_NO_SLOW",
"FFTW_NO_FIXED_RADIX_LARGE_N",
"FFTW_ALLOW_PRUNING"
};
static unsigned flagt[] =
{
/* documented flags */
FFTW_MEASURE,
FFTW_DESTROY_INPUT,
FFTW_UNALIGNED,
FFTW_CONSERVE_MEMORY,
FFTW_EXHAUSTIVE,
FFTW_PRESERVE_INPUT,
FFTW_PATIENT,
FFTW_ESTIMATE,
/* undocumented beyond-guru flags */
FFTW_ESTIMATE_PATIENT,
FFTW_BELIEVE_PCOST,
FFTW_NO_DFT_R2HC,
FFTW_NO_NONTHREADED,
FFTW_NO_BUFFERING,
FFTW_NO_INDIRECT_OP,
FFTW_ALLOW_LARGE_GENERIC,
FFTW_NO_RANK_SPLITS,
FFTW_NO_VRANK_SPLITS,
FFTW_NO_VRECURSE,
FFTW_NO_SIMD,
FFTW_NO_SLOW,
FFTW_NO_FIXED_RADIX_LARGE_N,
FFTW_ALLOW_PRUNING
};
unsigned flagv = 0;
int i = 0, j = 0;
SciErr sciErr;
CheckInputArgument(pvApiCtx, 0, 1);
if (nbInputArgument(pvApiCtx) == 0)
{
// nothing
}
else
{
//get variable address of the input argument
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
getVarType(pvApiCtx, piAddr1, &iType);
switch (iType)
{
case sci_ints:
{
/* int */
int iPrecision = 0;
int* pi32Data = NULL;
unsigned int* pui32Data = NULL;
getMatrixOfIntegerPrecision(pvApiCtx, piAddr1, &iPrecision);
if (iPrecision != SCI_INT32 && iPrecision != SCI_UINT32)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A int32 expected.\n"), fname, 1);
return 1;
}
if (iPrecision == SCI_INT32)
{
sciErr = getMatrixOfInteger32(pvApiCtx, piAddr1, &m1, &n1, pi32Data);
uiVar1 = (unsigned int)pi32Data[0];
}
else
{
sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddr1, &m1, &n1, pui32Data);
uiVar1 = pui32Data[0];
}
if (sciErr.iErr)
{
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
printError(&sciErr, 0);
return 1;
}
break;
}
case sci_matrix:
{
/* double */
double* pdblData = NULL;
sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &pdblData);
if (sciErr.iErr)
{
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
printError(&sciErr, 0);
return 1;
}
uiVar1 = (unsigned int)pdblData[0];
break;
}
case sci_strings:
{
/* string */
//fisrt call to retrieve dimensions
sciErr = getMatrixOfString(pvApiCtx, piAddr1, &m1, &n1, NULL, NULL);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
piLen = (int*)malloc(sizeof(int) * m1 * n1);
//second call to retrieve length of each string
sciErr = getMatrixOfString(pvApiCtx, piAddr1, &m1, &n1, piLen, NULL);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
Str1 = (char**)malloc(sizeof(char*) * m1 * n1);
for (i = 0 ; i < m1 * n1 ; i++)
{
Str1[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
}
//third call to retrieve data
sciErr = getMatrixOfString(pvApiCtx, piAddr1, &m1, &n1, piLen, Str1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
for (j = 0; j < m1 * n1; j++)
{
for (i = 0; i < nb_flag; i++)
{
if (strcmp(Str1[j], Str[i]) == 0)
{
break;
}
}
if (i == nb_flag)
{
freeArrayOfString(Str1, m1 * n1);
Scierror(999, _("%s: Wrong values for input argument #%d: FFTW flag expected.\n"), fname, 1);
return 0;
}
else
{
if (i > 0)
{
flagv = ( flagv | (1U << (i - 1)) );
}
}
}
uiVar1 = (unsigned int)flagv;
freeArrayOfString(Str1, m1 * n1);
m1 = 1;
n1 = 1;
break;
}
default:
Scierror(53, _("%s: Wrong type for input argument #%d.\n"), fname, 1);
return 1;
}
CheckDims(1, m1, n1, 1, 1);
setCurrentFftwFlags(uiVar1);
}
/* return value of Sci_Plan.flags in position 2 */
sciErr = allocMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 1, 1, &piDataOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
}
piDataOut[0] = (int) getCurrentFftwFlags();
/*Test for only FFTW_MEASURE*/
if (getCurrentFftwFlags() == 0)
{
j = 1;
if ((Str3 = (char **)MALLOC(sizeof(char *))) == NULL)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
}
Str3[0] = strdup(Str[0]);
if (Str3[0] == NULL)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
}
}
else
{
j = 0;
for (i = 1; i < nb_flag; i++)
{
if ((getCurrentFftwFlags() & flagt[i]) == flagt[i])
{
j++;
if (Str3)
{
Str3 = (char **)REALLOC(Str3, sizeof(char *) * j);
}
else
{
Str3 = (char **)MALLOC(sizeof(char *) * j);
}
if ( Str3 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
}
Str3[j - 1] = strdup(Str[i]);
if (Str3[j - 1] == NULL)
{
freeArrayOfString(Str3, j);
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
}
}
}
}
/* Create the string matrix as return of the function */
sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 3, j, 1, Str3);
freeArrayOfString(Str3, j); // Data have been copied into Scilab memory
if (sciErr.iErr)
{
freeArrayOfString(Str3, j); // Make sure everything is cleanup in case of error
printError(&sciErr, 0);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 2;
AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 3;
ReturnArguments(pvApiCtx);
return 0;
}
SciErr getHypermatOfIntegerPrecision(void *_pvCtx, int *_piAddress, int *_piPrecision)
{
return getMatrixOfIntegerPrecision(_pvCtx, _piAddress, _piPrecision);
}
static bool export_ints(int _iH5File, int *_piVar, char* _pstName)
{
int iRet = 0;
void *piData = NULL;
int iPrec = 0;
int piDims[2];
SciErr sciErr = getMatrixOfIntegerPrecision(pvApiCtx, _piVar, &iPrec);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
switch (iPrec)
{
case SCI_INT8 :
sciErr = getMatrixOfInteger8(pvApiCtx, _piVar, &piDims[0], &piDims[1], (char**)&piData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
iRet = writeInteger8Matrix(_iH5File, _pstName, 2, piDims, (char*)piData);
break;
case SCI_UINT8 :
sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, _piVar, &piDims[0], &piDims[1], (unsigned char**)&piData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
iRet = writeUnsignedInteger8Matrix(_iH5File, _pstName, 2, piDims, (unsigned char*)piData);
break;
case SCI_INT16 :
sciErr = getMatrixOfInteger16(pvApiCtx, _piVar, &piDims[0], &piDims[1], (short**)&piData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
iRet = writeInteger16Matrix(_iH5File, _pstName, 2, piDims, (short*)piData);
break;
case SCI_UINT16 :
sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, _piVar, &piDims[0], &piDims[1], (unsigned short**)&piData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
iRet = writeUnsignedInteger16Matrix(_iH5File, _pstName, 2, piDims, (unsigned short*)piData);
break;
case SCI_INT32 :
sciErr = getMatrixOfInteger32(pvApiCtx, _piVar, &piDims[0], &piDims[1], (int**)&piData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
iRet = writeInteger32Matrix(_iH5File, _pstName, 2, piDims, (int*)piData);
break;
case SCI_UINT32 :
sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, _piVar, &piDims[0], &piDims[1], (unsigned int**)&piData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
iRet = writeUnsignedInteger32Matrix(_iH5File, _pstName, 2, piDims, (unsigned int*)piData);
break;
case SCI_INT64 :
//sciErr = getMatrixOfInteger64(_piVar, &piDims[0], &piDims[1], (long long**)&piData);
//if(sciErr.iErr)
//{
// printError(&sciErr, 0);
// return false;
//}
//iRet = writeInteger64Matrix(_iH5File, _pstName, 2, piDims, (long long*)piData);
//break;
case SCI_UINT64 :
//sciErr = getMatrixOfUnsignedInteger64(_piVar, &piDims[0], &piDims[1], (unsigned long long**)&piData);
//if(sciErr.iErr)
//{
// printError(&sciErr, 0);
// return false;
//}
//iRet = writeUnsignedInteger64Matrix(_iH5File, _pstName, 2, piDims, (unsigned long long*)piData);
//break;
default :
return 1;
break;
}
if (iRet)
{
return false;
}
char pstMsg[512];
sprintf(pstMsg, "int%d (%d x %d)", 8 * iPrec, piDims[0], piDims[1]);
print_type(pstMsg);
return true;
}
int ScilabObjects::isPositiveIntegerAtAddress(int * addr, void * pvApiCtx)
{
SciErr err;
int typ = 0, row, col, prec;
err = getVarDimension(pvApiCtx, addr, &row, &col);
if (err.iErr)
{
return -1;
}
if (row != 1 || col != 1)
{
return -1;
}
err = getVarType(pvApiCtx, addr, &typ);
if (err.iErr)
{
return -1;
}
if (typ == sci_ints)
{
err = getMatrixOfIntegerPrecision(pvApiCtx, addr, &prec);
if (err.iErr)
{
return -1;
}
switch (prec)
{
case SCI_INT8:
{
char * cvalue = 0;
err = getMatrixOfInteger8(pvApiCtx, addr, &row, &col, &cvalue);
if (err.iErr)
{
return -1;
}
return (int)(*cvalue);
}
break;
case SCI_UINT8:
{
unsigned char * ucvalue = 0;
err = getMatrixOfUnsignedInteger8(pvApiCtx, addr, &row, &col, &ucvalue);
if (err.iErr)
{
return -1;
}
return (int)(*ucvalue);
}
break;
case SCI_INT16:
{
short * svalue = 0;
err = getMatrixOfInteger16(pvApiCtx, addr, &row, &col, &svalue);
if (err.iErr)
{
return -1;
}
return (int)(*svalue);
}
break;
case SCI_UINT16:
{
unsigned short * usvalue = 0;
err = getMatrixOfUnsignedInteger16(pvApiCtx, addr, &row, &col, &usvalue);
if (err.iErr)
{
return -1;
}
return (int)(*usvalue);
}
break;
case SCI_INT32:
{
int * ivalue = 0;
err = getMatrixOfInteger32(pvApiCtx, addr, &row, &col, &ivalue);
if (err.iErr)
{
return -1;
}
return (int)(*ivalue);
}
break;
case SCI_UINT32:
{
unsigned int * uivalue = 0;
err = getMatrixOfUnsignedInteger32(pvApiCtx, addr, &row, &col, &uivalue);
if (err.iErr)
{
return -1;
}
return (int)(*uivalue);
}
break;
#ifdef __SCILAB_INT64__
case SCI_INT64:
{
long long * llvalue = 0;
err = getMatrixOfInteger64(pvApiCtx, addr, &row, &col, &llvalue);
if (err.iErr)
{
return -1;
}
return (int)(*llvalue);
}
break;
case SCI_UINT64:
{
unsigned long long * ullvalue = 0;
err = getMatrixOfUnsignedInteger64(pvApiCtx, addr, &row, &col, &ullvalue);
if (err.iErr)
{
return -1;
}
return (int)(*ullvalue);
}
break;
#endif
default:
return -1;
}
}
else if (typ == sci_matrix)
{
double * dvalue = 0;
if (isVarComplex(pvApiCtx, addr))
{
return -1;
}
err = getMatrixOfDouble(pvApiCtx, addr, &row, &col, &dvalue);
if (err.iErr)
{
return -1;
}
if (*dvalue - (double)(int)(*dvalue) == 0.0)
{
return (int)(*dvalue);
}
}
return -1;
}
int ScilabObjects::getArgumentId(int * addr, int * tmpvars, const bool isRef, const bool isClass, const int envId, void * pvApiCtx)
{
SciErr err;
int typ, row = 0, col = 0, returnId;
const ScilabAbstractEnvironmentWrapper & wrapper = ScilabEnvironments::getEnvironment(envId).getWrapper();
err = getVarType(pvApiCtx, addr, &typ);
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (isClass && typ != sci_mlist)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("External Class expected"));
}
switch (typ)
{
case sci_matrix :
{
double * mat = 0;
if (isVarComplex(pvApiCtx, addr))
{
double * imag = 0;
err = getComplexMatrixOfDouble(pvApiCtx, addr, &row, &col, &mat, &imag);
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap(row, col, mat, imag, wrapper, isRef);
}
else
{
err = getMatrixOfDouble(pvApiCtx, addr, &row, &col, &mat);
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap<double>(row, col, mat, wrapper, isRef);
}
tmpvars[++tmpvars[0]] = returnId;
return returnId;
}
case sci_ints :
{
int prec = 0;
void * ints = 0;
err = getMatrixOfIntegerPrecision(pvApiCtx, addr, &prec);
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
switch (prec)
{
case SCI_INT8 :
err = getMatrixOfInteger8(pvApiCtx, addr, &row, &col, (char**)(&ints));
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap<char>(row, col, static_cast<char *>(ints), wrapper, isRef);
tmpvars[++tmpvars[0]] = returnId;
return returnId;
case SCI_UINT8 :
err = getMatrixOfUnsignedInteger8(pvApiCtx, addr, &row, &col, (unsigned char**)(&ints));
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap<unsigned char>(row, col, static_cast<unsigned char *>(ints), wrapper, isRef);
tmpvars[++tmpvars[0]] = returnId;
return returnId;
case SCI_INT16 :
err = getMatrixOfInteger16(pvApiCtx, addr, &row, &col, (short**)(&ints));
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap<short>(row, col, static_cast<short *>(ints), wrapper, isRef);
tmpvars[++tmpvars[0]] = returnId;
return returnId;
case SCI_UINT16 :
err = getMatrixOfUnsignedInteger16(pvApiCtx, addr, &row, &col, (unsigned short**)(&ints));
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap<unsigned short>(row, col, static_cast<unsigned short *>(ints), wrapper, isRef);
tmpvars[++tmpvars[0]] = returnId;
return returnId;
case SCI_INT32 :
err = getMatrixOfInteger32(pvApiCtx, addr, &row, &col, (int**)(&ints));
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap<int>(row, col, static_cast<int *>(ints), wrapper, isRef);
tmpvars[++tmpvars[0]] = returnId;
return returnId;
case SCI_UINT32 :
err = getMatrixOfUnsignedInteger32(pvApiCtx, addr, &row, &col, (unsigned int**)(&ints));
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap<unsigned int>(row, col, static_cast<unsigned int *>(ints), wrapper, isRef);
tmpvars[++tmpvars[0]] = returnId;
return returnId;
#ifdef __SCILAB_INT64__
case SCI_INT64 :
err = getMatrixOfInteger64(pvApiCtx, addr, &row, &col, (long long**)(&ints));
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap<long long>(row, col, static_cast<long long *>(ints), wrapper, isRef);
tmpvars[++tmpvars[0]] = returnId;
return returnId;
case SCI_UINT64 :
err = getMatrixOfUnsignedInteger64(pvApiCtx, addr, &row, &col, (unsigned long long**)(&ints));
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap<unsigned long long>(row, col, static_cast<unsigned long long *>(ints), wrapper, isRef);
tmpvars[++tmpvars[0]] = returnId;
return returnId;
#endif
}
}
case sci_strings :
{
char ** matS = NULL;
if (getAllocatedMatrixOfString(pvApiCtx, addr, &row, &col, &matS))
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrap<char *>(row, col, matS, wrapper, isRef);
freeAllocatedMatrixOfString(row, col, matS);
tmpvars[++tmpvars[0]] = returnId;
return returnId;
}
case sci_boolean :
{
int * matB;
err = getMatrixOfBoolean(pvApiCtx, addr, &row, &col, &matB);
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
returnId = wrapBool(row, col, matB, wrapper, isRef);
tmpvars[++tmpvars[0]] = returnId;
return returnId;
}
case sci_mlist :
{
int * id = 0;
int type = getMListType(addr, pvApiCtx);
int eId = getEnvironmentId(addr, pvApiCtx);
if (eId != envId)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Incompatible External Objects"));
}
if (isClass)
{
if (type == EXTERNAL_CLASS)
{
err = getMatrixOfInteger32InList(pvApiCtx, addr, EXTERNAL_OBJ_ID_POSITION, &row, &col, &id);
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
return *id;
}
else
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("External Class expected"));
}
}
if (type == EXTERNAL_OBJECT || type == EXTERNAL_CLASS)
{
err = getMatrixOfInteger32InList(pvApiCtx, addr, EXTERNAL_OBJ_ID_POSITION, &row, &col, &id);
if (err.iErr)
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
return *id;
}
else if (type == EXTERNAL_VOID)
{
return -1;
}
else
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("External object expected"));
}
break;
}
default :
{
removeTemporaryVars(envId, tmpvars);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Unable to wrap. Unmanaged datatype ?"));
}
}
}
int get_integer_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
SciErr sciErr;
int iPrec = 0;
int iRows = 0;
int iCols = 0;
char* pcData = NULL;
short* psData = NULL;
int* piData = NULL;
unsigned char* pucData = NULL;
unsigned short* pusData = NULL;
unsigned int* puiData = NULL;
if (_iItemPos == 0)
{
//Not in list
sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddr, &iPrec);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
switch (iPrec)
{
case SCI_INT8 :
sciErr = getMatrixOfInteger8(_pvCtx, _piAddr, &iRows, &iCols, &pcData);
break;
case SCI_INT16 :
sciErr = getMatrixOfInteger16(_pvCtx, _piAddr, &iRows, &iCols, &psData);
break;
case SCI_INT32 :
sciErr = getMatrixOfInteger32(_pvCtx, _piAddr, &iRows, &iCols, &piData);
break;
case SCI_UINT8 :
sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _piAddr, &iRows, &iCols, &pucData);
break;
case SCI_UINT16 :
sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _piAddr, &iRows, &iCols, &pusData);
break;
case SCI_UINT32 :
sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _piAddr, &iRows, &iCols, &puiData);
break;
default :
return 1;
}
}
else
{
sciErr = getMatrixOfIntegerPrecision(_pvCtx, _piAddr, &iPrec);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
switch (iPrec)
{
case SCI_INT8 :
sciErr = getMatrixOfInteger8InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &pcData);
break;
case SCI_INT16 :
sciErr = getMatrixOfInteger16InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &psData);
break;
case SCI_INT32 :
sciErr = getMatrixOfInteger32InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &piData);
break;
case SCI_UINT8 :
sciErr = getMatrixOfUnsignedInteger8InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &pucData);
break;
case SCI_UINT16 :
sciErr = getMatrixOfUnsignedInteger16InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &pusData);
break;
case SCI_UINT32 :
sciErr = getMatrixOfUnsignedInteger32InList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, &puiData);
break;
default :
return 1;
}
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
insert_indent();
if (iPrec > 10)
{
sciprint("Unsigned ");
}
sciprint("Integer %d bits (%d x %d)\n", (iPrec % 10) * 8, iRows, iCols);
return 0;;
}
