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;; }