void ScilabObjects::createEnvironmentObjectAtPos(int type, int pos, int id, const int envId, void * pvApiCtx)
{
const char ** fields = 0;
int * mlistaddr = 0;
SciErr err;
if (envId < 0)
{
throw ScilabAbstractEnvironmentException("Invalid environment");
}
switch (type)
{
case EXTERNAL_OBJECT:
fields = static_cast<const char **>(_EOBJ);
break;
case EXTERNAL_CLASS:
fields = static_cast<const char **>(_ECLASS);
break;
case EXTERNAL_VOID:
fields = static_cast<const char **>(_EVOID);
break;
default :
fields = static_cast<const char **>(_EOBJ);
break;
}
err = createMList(pvApiCtx, pos, FIELDS_LENGTH, &mlistaddr);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Cannot allocate memory"));
}
err = createMatrixOfStringInList(pvApiCtx, pos, mlistaddr, 1, 1, FIELDS_LENGTH, fields);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Cannot allocate memory"));
}
err = createMatrixOfInteger32InList(pvApiCtx, pos, mlistaddr, EXTERNAL_ENV_ID_POSITION, 1, 1, &envId);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Cannot allocate memory"));
}
err = createMatrixOfInteger32InList(pvApiCtx, pos, mlistaddr, EXTERNAL_OBJ_ID_POSITION, 1, 1, &id);
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Cannot allocate memory"));
}
}
/*--------------------------------------------------------------------------*/
int createXMLObjectAtPosInList(int *list, int stackPos, int type, int pos, int id, void *pvApiCtx)
{
const char **fields = NULL;
int *mlistaddr = NULL;
SciErr err;
err = createMListInList(pvApiCtx, stackPos, list, pos, 2, &mlistaddr);
if (err.iErr)
{
printError(&err, 0);
return 0;
}
switch (type)
{
case XMLDOCUMENT:
fields = _XMLDoc;
break;
case XMLELEMENT:
fields = _XMLElem;
break;
case XMLATTRIBUTE:
fields = _XMLAttr;
break;
case XMLNAMESPACE:
fields = _XMLNs;
break;
case XMLLIST:
fields = _XMLList;
break;
case XMLNOTHANDLED:
fields = _XMLNotHandled;
break;
case XMLSET:
fields = _XMLSet;
break;
case XMLVALID:
fields = _XMLValid;
break;
default:
Scierror(999, _("Unknown tag.\n"));
return 0;
}
err = createMatrixOfStringInList(pvApiCtx, stackPos, mlistaddr, 1, 1, 2, fields);
if (err.iErr)
{
printError(&err, 0);
return 0;
}
err = createMatrixOfInteger32InList(pvApiCtx, stackPos, mlistaddr, 2, 1, 1, &id);
if (err.iErr)
{
printError(&err, 0);
return 0;
}
return 1;
}
int * H5DataConverter::getHypermatrix(void * pvApiCtx, const int position, const int ndims, const hsize_t * dims)
{
static const char * hypermat[3] = {"hm", "dims", "entries"};
int * list = 0;
SciErr err = createMList(pvApiCtx, position, 3, &list);
if (err.iErr)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot create an hypermatrix on the stack"));
}
err = createMatrixOfStringInList(pvApiCtx, position, list, 1, 1, 3, hypermat);
if (err.iErr)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot create an hypermatrix on the stack"));
}
if (sizeof(int) == sizeof(hsize_t))
{
err = createMatrixOfInteger32InList(pvApiCtx, position, list, 2, 1, ndims, (int *)dims);
if (err.iErr)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot create an hypermatrix on the stack"));
}
}
else
{
int * _dims = 0;
err = allocMatrixOfInteger32InList(pvApiCtx, position, list, 2, 1, ndims, &_dims);
if (err.iErr)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot create an hypermatrix on the stack"));
}
for (int i = 0; i < ndims; i++)
{
_dims[i] = (int)dims[i];
}
}
return list;
}
int CreateCellVariable(int iVar, matvar_t *matVariable, int * parent, int item_position)
{
static const char *fieldNames[] = {"ce", "dims","entries"};
int nbFields = 3;
int K = 0;
int prodDims = 0;
int valueIndex = 0, type;
int * cell_addr = NULL;
int * cell_entry_addr = NULL;
matvar_t ** allData = NULL;
SciErr _SciErr;
/* Returned mlist initialization */
if (parent==NULL)
{
_SciErr = createMList(pvApiCtx, iVar, nbFields, &cell_addr); MATIO_ERROR;
}
else
{
_SciErr = createMListInList(pvApiCtx, iVar, parent, item_position, nbFields, &cell_addr); MATIO_ERROR;
}
/* FIRST LIST ENTRY: fieldnames */
_SciErr = createMatrixOfStringInList(pvApiCtx, iVar, cell_addr, 1, 1, nbFields, (char **)fieldNames); MATIO_ERROR;
/* SECOND LIST ENTRY: Dimensions (int32 type) */
if(matVariable->rank==2) /* Two dimensions */
{
_SciErr = createMatrixOfInteger32InList(pvApiCtx, iVar, cell_addr, 2, 1, matVariable->rank, matVariable->dims); MATIO_ERROR;
}
else /* 3 or more dimensions -> Scilab HyperMatrix */
{
type = I_INT32;
CreateHyperMatrixVariable(iVar, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE,
&type, &matVariable->rank, matVariable->dims, matVariable->data,
NULL, cell_addr, 2);
}
/* ALL OTHER ENTRIES: Fields data */
prodDims = 1;
for (K=0; K<matVariable->rank; K++)
{
prodDims *= matVariable->dims[K];
}
allData = (matvar_t**) (matVariable->data);
if (prodDims == 1) /* Scalar cell */
{
/* Create list entry in the stack */
if (!CreateMatlabVariable(iVar, allData[0], cell_addr, 3)) /* Could not Create Variable */
{
sciprint("Do not know how to read a variable of class %d.\n", allData[0]->class_type);
}
}
else
{
_SciErr = createListInList(pvApiCtx, iVar, cell_addr, 3, prodDims, &cell_entry_addr); MATIO_ERROR;
for (valueIndex = 0; valueIndex < prodDims; valueIndex++)
{
/* Create list entry in the stack */
if (!CreateMatlabVariable(iVar, allData[valueIndex], cell_entry_addr, valueIndex+1)) /* Could not Create Variable */
{
sciprint("Do not know how to read a variable of class %d.\n", allData[valueIndex]->class_type);
}
}
}
return TRUE;
}
int CreateIntegerVariable(void *pvApiCtx, int iVar, int integerType, matvar_t *matVariable, int * parent, int item_position)
{
int nbRow, nbCol, i;
SciErr sciErr;
char * tmp_int8 = NULL;
short * tmp_int16 = NULL;
int * tmp_int32 = NULL;
int *piDims = 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
int iSize = 0;
// Matrix dimensions
nbRow = (int)matVariable->dims[0];
nbCol = (int)matVariable->dims[1];
iSize = nbRow * nbCol;
if (iSize == 0)
{
double dblReal = 0;
SciErr sciErr = createMatrixOfDouble(pvApiCtx, iVar, 0, 0, &dblReal);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), "CreateIntegerVariable");
return FALSE;
}
return TRUE;
}
if (matVariable->rank == 2) /* 2-D array */
{
switch (integerType)
{
case SCI_INT8:
{
tmp_int8 = (char *)MALLOC(iSize * sizeof(char));
if (tmp_int8 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateIntegerVariable");
return FALSE;
}
for (i = 0; i < iSize; i++)
{
tmp_int8[i] = ((char *)matVariable->data)[i];
}
if (parent == NULL)
{
sciErr = createMatrixOfInteger8(pvApiCtx, iVar, nbRow, nbCol, tmp_int8);
}
else
{
sciErr = createMatrixOfInteger8InList(pvApiCtx, iVar, parent, item_position, nbRow, nbCol, tmp_int8);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
FREE(tmp_int8);
}
break;
case SCI_INT16:
{
tmp_int16 = (short *)MALLOC(iSize * sizeof(short));
if (tmp_int16 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateIntegerVariable");
return FALSE;
}
for (i = 0; i < iSize; i++)
{
tmp_int16[i] = ((short *)matVariable->data)[i];
}
if (parent == NULL)
{
sciErr = createMatrixOfInteger16(pvApiCtx, iVar, nbRow, nbCol, tmp_int16);
}
else
{
sciErr = createMatrixOfInteger16InList(pvApiCtx, iVar, parent, item_position, nbRow, nbCol, tmp_int16);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
FREE(tmp_int16);
}
break;
case SCI_INT32:
{
tmp_int32 = (int *)MALLOC(iSize * sizeof(int));
if (tmp_int32 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateIntegerVariable");
return FALSE;
}
for (i = 0; i < iSize; i++)
{
tmp_int32[i] = ((int *)matVariable->data)[i];
}
if (parent == NULL)
{
sciErr = createMatrixOfInteger32(pvApiCtx, iVar, nbRow, nbCol, tmp_int32);
}
else
{
sciErr = createMatrixOfInteger32InList(pvApiCtx, iVar, parent, item_position, nbRow, nbCol, tmp_int32);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
FREE(tmp_int32);
}
break;
#ifdef __SCILAB_INT64__
case SCI_INT64:
{
tmp_int64 = (long long *)MALLOC(iSize * sizeof(long long));
if (tmp_int64 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateIntegerVariable");
return FALSE;
}
for (i = 0; i < iSize; i++)
{
tmp_int64[i] = ((long long *)matVariable->data)[i];
}
if (parent == NULL)
{
sciErr = createMatrixOfInteger64(pvApiCtx, iVar, nbRow, nbCol, tmp_int64);
}
else
{
sciErr = createMatrixOfInteger64InList(pvApiCtx, iVar, parent, item_position, nbRow, nbCol, tmp_int64);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
FREE(tmp_int64);
}
break;
#endif
case SCI_UINT8:
{
tmp_uint8 = (unsigned char *)MALLOC(iSize * sizeof(unsigned char));
if (tmp_uint8 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateIntegerVariable");
return FALSE;
}
for (i = 0; i < iSize; i++)
{
tmp_uint8[i] = ((unsigned char *)matVariable->data)[i];
}
if (parent == NULL)
{
sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, iVar, nbRow, nbCol, tmp_uint8);
}
else
{
sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, iVar, parent, item_position, nbRow, nbCol, tmp_uint8);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
FREE(tmp_uint8);
}
break;
case SCI_UINT16:
{
tmp_uint16 = (unsigned short *)MALLOC(iSize * sizeof(unsigned short));
if (tmp_uint16 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateIntegerVariable");
return FALSE;
}
for (i = 0; i < iSize; i++)
{
tmp_uint16[i] = ((unsigned short *)matVariable->data)[i];
}
if (parent == NULL)
{
sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, iVar, nbRow, nbCol, tmp_uint16);
}
else
{
sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, iVar, parent, item_position, nbRow, nbCol, tmp_uint16);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
FREE(tmp_uint16);
}
break;
case SCI_UINT32:
{
tmp_uint32 = (unsigned int *)MALLOC(iSize * sizeof(unsigned int));
if (tmp_uint32 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateIntegerVariable");
return FALSE;
}
for (i = 0; i < iSize; i++)
{
tmp_uint32[i] = ((unsigned int *)matVariable->data)[i];
}
if (parent == NULL)
{
sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, iVar, nbRow, nbCol, tmp_uint32);
}
else
{
sciErr = createMatrixOfUnsignedInteger32InList(pvApiCtx, iVar, parent, item_position, nbRow, nbCol, tmp_uint32);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
FREE(tmp_uint32);
}
break;
#ifdef __SCILAB_INT64__
case SCI_UINT64:
{
tmp_uint64 = (unsigned long long *)MALLOC(iSize * sizeof(unsigned long long));
if (tmp_uint64 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateIntegerVariable");
return FALSE;
}
for (i = 0; i < iSize; i++)
{
tmp_uint64[i] = ((unsigned long long *)matVariable->data)[i];
}
if (parent == NULL)
{
sciErr = createMatrixOfUnsignedInteger64(pvApiCtx, iVar, nbRow, nbCol, tmp_uint64);
}
else
{
sciErr = createMatrixOfUnsignedInteger64InList(pvApiCtx, iVar, parent, item_position, nbRow, nbCol, tmp_uint64);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
FREE(tmp_uint64);
}
break;
#endif
}
}
else /* Multi-dimension array -> Scilab HyperMatrix */
{
piDims = (int*) MALLOC(matVariable->rank * sizeof(int));
if (piDims == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateBooleanVariable");
return FALSE;
}
for (i = 0; i < matVariable->rank; i++)
{
piDims[i] = (int)matVariable->dims[i];
}
CreateHyperMatrixVariable(pvApiCtx, iVar, matVariable->class_type, &integerType, &matVariable->rank,
piDims, matVariable , parent, item_position);
FREE(piDims);
}
return TRUE;
}
int CreateStructVariable(void *pvApiCtx, int iVar, matvar_t *matVariable, int * parent, int item_position)
{
char **fieldNames = NULL;
int nbFields = 0;
int fieldIndex = 0;
int K = 0;
int prodDims = 0;
int valueIndex = 0;
matvar_t *fieldMatVar = NULL;
matvar_t ** allData = NULL;
int * cell_addr = NULL;
int * cell_entry_addr = NULL;
int type;
SciErr sciErr;
int *piDims = NULL;
int i = 0;
/* Fields of the struct */
nbFields = 2; /* "st" "dims" */
nbFields += Mat_VarGetNumberOfFields(matVariable);
fieldNames = (char**) MALLOC(sizeof(char*) * nbFields);
if (fieldNames == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateStructVariable");
return FALSE;
}
fieldNames[0] = strdup("st");
if (fieldNames[0] == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateStructVariable");
return FALSE;
}
fieldNames[1] = strdup("dims");
if (fieldNames[1] == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateStructVariable");
return FALSE;
}
for (fieldIndex = 1; fieldIndex < nbFields - 1; fieldIndex++)
{
fieldMatVar = Mat_VarGetStructField(matVariable, &fieldIndex, MAT_BY_INDEX, 0);
fieldNames[fieldIndex + 1] = strdup(fieldMatVar->name);
if (fieldNames[fieldIndex + 1] == NULL)
{
Scierror(999, _("%s: No more memory.\n"), "CreateStructVariable");
return FALSE;
}
}
/* Returned mlist initialization */
if (parent == NULL)
{
sciErr = createMList(pvApiCtx, iVar, nbFields, &cell_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
}
else
{
sciErr = createMListInList(pvApiCtx, iVar, parent, item_position, nbFields, &cell_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
}
/* FIRST LIST ENTRY: fieldnames */
sciErr = createMatrixOfStringInList(pvApiCtx, iVar, cell_addr, 1, 1, nbFields, fieldNames);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
/* SECOND LIST ENTRY: Dimensions (int32 type) */
if (nbFields == 2) /* Empty struct must have size 0x0 in Scilab */
{
matVariable->dims[0] = 0;
matVariable->dims[1] = 0;
}
piDims = (int *) MALLOC(matVariable->rank * sizeof(int));
for (i = 0 ; i < matVariable->rank ; ++i)
{
piDims[i] = (int)matVariable->dims[i];
}
if (matVariable->rank == 2) /* Two dimensions */
{
sciErr = createMatrixOfInteger32InList(pvApiCtx, iVar, cell_addr, 2, 1, matVariable->rank, piDims);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
}
else /* 3 or more dimensions -> Scilab HyperMatrix */
{
type = I_INT32;
CreateHyperMatrixVariable(pvApiCtx, iVar, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE,
&type, &matVariable->rank, piDims, (double*)matVariable->data,
NULL, cell_addr, 2);
}
FREE(piDims);
/* ALL OTHER ENTRIES: Fields data */
prodDims = 1;
for (K = 0; K < matVariable->rank; K++)
{
prodDims *= (int)matVariable->dims[K];
}
allData = (matvar_t**) (matVariable->data);
if (prodDims == 1) /* Scalar struct */
{
for (fieldIndex = 0; fieldIndex < nbFields - 2; fieldIndex++)
{
/* Create list entry in the stack */
if (!CreateMatlabVariable(pvApiCtx, iVar, allData[fieldIndex], cell_addr, fieldIndex + 3)) /* Could not Create Variable */
{
if (allData[fieldIndex]->class_type != 0) /* class is 0 for not initialized fields */
{
sciprint("Do not know how to read a variable of class %d.\n", allData[fieldIndex]->class_type);
}
}
}
}
else
{
for (fieldIndex = 0; fieldIndex < nbFields - 2; fieldIndex++)
{
sciErr = createListInList(pvApiCtx, iVar, cell_addr, fieldIndex + 3, prodDims, &cell_entry_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
for (valueIndex = 0; valueIndex < prodDims; valueIndex++)
{
/* Create list entry in the stack */
if (!CreateMatlabVariable(pvApiCtx, iVar, allData[(fieldIndex) + (nbFields - 2)*valueIndex], cell_entry_addr, valueIndex + 1)) /* Could not Create Variable */
{
if (allData[(fieldIndex) + (nbFields - 2)*valueIndex]->class_type != 0) /* class is 0 for not initialized fields */
{
sciprint("Do not know how to read a variable of class %d.\n", allData[(fieldIndex) + (nbFields - 2)*valueIndex]->class_type);
}
}
}
}
}
freeArrayOfString(fieldNames, nbFields);
return TRUE;
}