int ScilabGateway::unwrapremove(char * fname, const int envId, void * pvApiCtx)
{
SciErr err;
int * addr = 0;
int row = 0, col = 0;
int * id = 0;
if (Rhs == 0)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong number of arguments : more than 1 argument expected"));
}
CheckOutputArgument(pvApiCtx, Rhs, Rhs);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
for (int i = 1; i <= Rhs; i++)
{
err = getVarAddressFromPosition(pvApiCtx, i, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!ScilabObjects::isExternalObj(addr, pvApiCtx))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An External Object expected."), i);
}
err = getMatrixOfInteger32InList(pvApiCtx, addr, EXTERNAL_OBJ_ID_POSITION, &row, &col, &id);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!ScilabObjects::unwrap(*id, Rhs + i, envId, pvApiCtx))
{
try
{
ScilabObjects::createEnvironmentObjectAtPos(EXTERNAL_OBJECT, Rhs + i, *id, envId, pvApiCtx);
}
catch (ScilabAbstractEnvironmentException & /*e*/)
{
}
}
LhsVar(i) = Rhs + i;
env.removeobject(*id);
}
PutLhsVar();
return 0;
}
int ScilabGateway::exists(char * fname, const int envId, void * pvApiCtx)
{
SciErr err;
int * addr = 0;
int * id = 0;
int row = 0;
int col = 0;
bool exists = false;
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 1, 1);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper::setCopyOccured(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
err = getVarAddressFromPosition(pvApiCtx, 1, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!ScilabObjects::isExternalObjOrClass(addr, pvApiCtx))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: An External Object expected."), 1);
return 0;
}
err = getMatrixOfInteger32InList(pvApiCtx, addr, EXTERNAL_OBJ_ID_POSITION, &row, &col, &id);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
try
{
exists = env.isvalidobject(*id);
}
catch (std::exception & e)
{
throw;
}
createScalarBoolean(pvApiCtx, 1, exists ? 1 : 0);
LhsVar(1) = 1;
PutLhsVar();
return 0;
}
int ScilabObjects::getExternalId(int * addr, void * pvApiCtx)
{
SciErr err;
int row = 0, col = 0;
int * id = 0;
err = getMatrixOfInteger32InList(pvApiCtx, addr, EXTERNAL_OBJ_ID_POSITION, &row, &col, &id);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
return *id;
}
/*--------------------------------------------------------------------------*/
int getXMLObjectId(int *mlist, void *pvApiCtx)
{
int *id = NULL;
int row, col;
SciErr err = getMatrixOfInteger32InList(pvApiCtx, mlist, 2, &row, &col, &id);
if (err.iErr)
{
printError(&err, 0);
return -1;
}
return *id;
}
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;
}
int ScilabGateway::cast(char * fname, const int envId, void * pvApiCtx)
{
SciErr err;
int tmpvar[2] = {0, 0};
int * addr = 0;
int idObj = 0;
int row = 0, col = 0;
int * id = 0;
char * objName = 0;
int ret = 0;
CheckInputArgument(pvApiCtx, 2, 2);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
err = getVarAddressFromPosition(pvApiCtx, 1, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
idObj = ScilabObjects::getArgumentId(addr, tmpvar, false, false, envId, pvApiCtx);
err = getVarAddressFromPosition(pvApiCtx, 2, &addr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (ScilabObjects::isExternalClass(addr, pvApiCtx))
{
if (ScilabObjects::getEnvironmentId(addr, pvApiCtx) != envId)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Incompatible External Objects"));
}
err = getMatrixOfInteger32InList(pvApiCtx, addr, EXTERNAL_OBJ_ID_POSITION, &row, &col, &id);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
try
{
ret = env.castwithid(idObj, *id);
}
catch (std::exception & /*e*/)
{
ScilabObjects::removeTemporaryVars(envId, tmpvar);
throw;
}
}
else
{
try
{
objName = ScilabObjects::getSingleString(2, pvApiCtx);
}
catch (ScilabAbstractEnvironmentException & /*e*/)
{
ScilabObjects::removeTemporaryVars(envId, tmpvar);
throw;
}
try
{
ret = env.cast(idObj, objName);
}
catch (std::exception & /*e*/)
{
freeAllocatedSingleString(objName);
ScilabObjects::removeTemporaryVars(envId, tmpvar);
throw;
}
freeAllocatedSingleString(objName);
}
ScilabObjects::removeTemporaryVars(envId, tmpvar);
try
{
ScilabObjects::createEnvironmentObjectAtPos(EXTERNAL_OBJECT, Rhs + 1, ret, envId, pvApiCtx);
}
catch (ScilabAbstractEnvironmentException & /*e*/)
{
env.removeobject(ret);
throw;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
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 ?"));
}
}
}
void ScilabObjects::removeVar(int * addr, void * pvApiCtx)
{
SciErr err;
int type, row, col, * id;
err = getVarType(pvApiCtx, addr, &type);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (type == sci_mlist && (isExternalObjOrClass(addr, pvApiCtx)))
{
err = getMatrixOfInteger32InList(pvApiCtx, addr, EXTERNAL_OBJ_ID_POSITION, &row, &col, &id);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
int envId = getEnvironmentId(addr, pvApiCtx);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
env.removeobject(*id);
}
else if (type == sci_strings)
{
char * varName = 0;
if (getAllocatedSingleString(pvApiCtx, addr, &varName))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
err = getVarAddressFromName(pvApiCtx, varName, &addr);
if (err.iErr)
{
freeAllocatedSingleString(varName);
return;
}
err = getVarType(pvApiCtx, addr, &type);
if (err.iErr)
{
freeAllocatedSingleString(varName);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (type == sci_mlist && isExternalObjOrClass(addr, pvApiCtx))
{
err = getMatrixOfInteger32InList(pvApiCtx, addr, EXTERNAL_OBJ_ID_POSITION, &row, &col, &id);
if (err.iErr)
{
freeAllocatedSingleString(varName);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
int envId = getEnvironmentId(addr, pvApiCtx);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
env.removeobject(*id);
deleteNamedVariable(pvApiCtx, varName);
freeAllocatedSingleString(varName);
}
}
}
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;;
}
