static types::InternalType* import_int(int dataset)
{
types::InternalType* pOut = nullptr;
int complex = 0;
int dims = 0;
int ret = getDatasetInfo(dataset, &complex, &dims, NULL);
if (ret < 0)
{
closeDataSet(dataset);
return nullptr;
}
std::vector<int> d(dims);
int size = getDatasetInfo(dataset, &complex, &dims, d.data());
if (dims == 0 || size <= 0)
{
closeDataSet(dataset);
return types::Double::Empty();
}
int prec = 0;
ret = getDatasetPrecision(dataset, &prec);
if (ret != 0)
{
closeDataSet(dataset);
return nullptr;
}
switch (prec)
{
case SCI_INT8:
{
types::Int8* pi = new types::Int8(dims, d.data());
ret = readInteger8Matrix(dataset, pi->get());
pOut = pi;
break;
}
case SCI_INT16:
{
types::Int16* pi = new types::Int16(dims, d.data());
ret = readInteger16Matrix(dataset, pi->get());
pOut = pi;
break;
}
case SCI_INT32:
{
types::Int32* pi = new types::Int32(dims, d.data());
ret = readInteger32Matrix(dataset, pi->get());
pOut = pi;
break;
}
case SCI_INT64:
{
types::Int64* pi = new types::Int64(dims, d.data());
ret = readInteger64Matrix(dataset, pi->get());
pOut = pi;
break;
}
case SCI_UINT8:
{
types::UInt8* pi = new types::UInt8(dims, d.data());
ret = readUnsignedInteger8Matrix(dataset, pi->get());
pOut = pi;
break;
}
case SCI_UINT16:
{
types::UInt16* pi = new types::UInt16(dims, d.data());
ret = readUnsignedInteger16Matrix(dataset, pi->get());
pOut = pi;
break;
}
case SCI_UINT32:
{
types::UInt32* pi = new types::UInt32(dims, d.data());
ret = readUnsignedInteger32Matrix(dataset, pi->get());
pOut = pi;
break;
}
case SCI_UINT64:
{
types::UInt64* pi = new types::UInt64(dims, d.data());
ret = readUnsignedInteger64Matrix(dataset, pi->get());
pOut = pi;
break;
}
default:
return nullptr;
break;
}
return pOut;
}
static bool import_integer(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
{
int iRet = 0;
int iDims = 0;
int* piDims = NULL;
int iComplex = 0;
int iSize = 0;
int iPrec = 0;
SciErr sciErr;
iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
if (iRet < 0)
{
return false;
}
piDims = (int*)MALLOC(sizeof(int) * iDims);
iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
iRet = getDatasetPrecision(_iDatasetId, &iPrec);
if (iRet)
{
FREE(piDims);
return false;
}
switch (iPrec)
{
case SCI_INT8:
{
char *pcData = NULL;
pcData = (char *)MALLOC(sizeof(char) * iSize);
iRet = readInteger8Matrix(_iDatasetId, pcData);
if (iRet)
{
FREE(piDims);
return false;
}
if (_piAddress == NULL)
{
sciErr = createNamedMatrixOfInteger8(pvCtx, _pstVarname, piDims[0], piDims[1], pcData);
}
else
{
sciErr = createMatrixOfInteger8InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pcData);
}
FREE(pcData);
}
break;
case SCI_UINT8:
{
unsigned char *pucData = NULL;
pucData = (unsigned char *)MALLOC(sizeof(unsigned char) * iSize);
iRet = readUnsignedInteger8Matrix(_iDatasetId, pucData);
if (iRet)
{
FREE(piDims);
return false;
}
if (_piAddress == NULL)
{
sciErr = createNamedMatrixOfUnsignedInteger8(pvCtx, _pstVarname, piDims[0], piDims[1], pucData);
}
else
{
sciErr = createMatrixOfUnsignedInteger8InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pucData);
}
FREE(pucData);
}
break;
case SCI_INT16:
{
short *psData = NULL;
psData = (short *)MALLOC(sizeof(short) * iSize);
iRet = readInteger16Matrix(_iDatasetId, psData);
if (iRet)
{
FREE(piDims);
return false;
}
if (_piAddress == NULL)
{
sciErr = createNamedMatrixOfInteger16(pvCtx, _pstVarname, piDims[0], piDims[1], psData);
}
else
{
sciErr = createMatrixOfInteger16InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], psData);
}
FREE(psData);
}
break;
case SCI_UINT16:
{
unsigned short *pusData = NULL;
pusData = (unsigned short *)MALLOC(sizeof(unsigned short) * iSize);
iRet = readUnsignedInteger16Matrix(_iDatasetId, pusData);
if (iRet)
{
FREE(piDims);
return false;
}
if (_piAddress == NULL)
{
sciErr = createNamedMatrixOfUnsignedInteger16(pvCtx, _pstVarname, piDims[0], piDims[1], pusData);
}
else
{
sciErr = createMatrixOfUnsignedInteger16InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pusData);
}
FREE(pusData);
}
break;
case SCI_INT32:
{
int *piData = NULL;
piData = (int *)MALLOC(sizeof(int) * iSize);
iRet = readInteger32Matrix(_iDatasetId, piData);
if (iRet)
{
FREE(piDims);
return false;
}
if (_piAddress == NULL)
{
sciErr = createNamedMatrixOfInteger32(pvCtx, _pstVarname, piDims[0], piDims[1], piData);
}
else
{
sciErr = createMatrixOfInteger32InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], piData);
}
FREE(piData);
}
break;
case SCI_UINT32:
{
unsigned int *puiData = NULL;
puiData = (unsigned int *)MALLOC(sizeof(unsigned int) * iSize);
iRet = readUnsignedInteger32Matrix(_iDatasetId, puiData);
if (iRet)
{
FREE(piDims);
return false;
}
if (_piAddress == NULL)
{
sciErr = createNamedMatrixOfUnsignedInteger32(pvCtx, _pstVarname, piDims[0], piDims[1], puiData);
}
else
{
sciErr = createMatrixOfUnsignedInteger32InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], puiData);
}
FREE(puiData);
}
break;
case SCI_INT64:
{
#ifdef __SCILAB_INT64__
long long *pllData = NULL;
pllData = (long long *)MALLOC(sizeof(long long) * iSize);
iRet = readInteger64Matrix(_iDatasetId, pllData);
if (iRet)
{
FREE(piDims);
return false;
}
if (_piAddress == NULL)
{
sciErr = createNamedMatrixOfInteger64(pvCtx, _pstVarname, piDims[0], piDims[1], pllData);
}
else
{
sciErr = createMatrixOfInteger64InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pllData);
}
FREE(pllData);
#else
FREE(piDims);
return false;
#endif
}
break;
case SCI_UINT64:
{
#ifdef __SCILAB_INT64__
unsigned long long *pullData = NULL;
pullData = (unsigned long long *)MALLOC(sizeof(unsigned long long) * iSize);
iRet = readUnsignedInteger64Matrix(_iDatasetId, pullData);
if (iRet)
{
FREE(piDims);
return false;
}
if (_piAddress == NULL)
{
sciErr = createNamedMatrixOfUnsignedInteger64(pvCtx, _pstVarname, piDims[0], piDims[1], pullData);
}
else
{
sciErr = createMatrixOfUnsignedInteger64InNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pullData);
}
FREE(pullData);
#else
FREE(piDims);
return false;
#endif
}
break;
default:
return false;
}
FREE(piDims);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
return true;
}
static types::InternalType* import_macro(int dataset)
{
int complex = 0;
int dims = 0;
int size = 0;
std::vector<int> d(2);
std::list<symbol::Variable*>* inputList = new std::list<symbol::Variable*>();
std::list<symbol::Variable*>* outputList = new std::list<symbol::Variable*>();
ast::Exp* body = nullptr;
symbol::Context* ctx = symbol::Context::getInstance();
//inputs
int inputNode = getDataSetIdFromName(dataset, "inputs");
size = getDatasetInfo(inputNode, &complex, &dims, d.data());
if (size < 0)
{
delete inputList;
delete outputList;
closeList6(dataset);
return nullptr;
}
std::vector<char*> inputNames(size);
if (size != 0)
{
readStringMatrix(inputNode, inputNames.data());
for (auto & input : inputNames)
{
wchar_t* winput = to_wide_string(input);
symbol::Variable* var = ctx->getOrCreate(symbol::Symbol(winput));
FREE(winput);
inputList->push_back(var);
}
freeStringMatrix(inputNode, inputNames.data());
}
else
{
closeDataSet(inputNode);
}
//outputs
int outputNode = getDataSetIdFromName(dataset, "outputs");
size = getDatasetInfo(outputNode, &complex, &dims, d.data());
if (size < 0)
{
delete inputList;
delete outputList;
closeList6(dataset);
return nullptr;
}
std::vector<char*> outputNames(size);
if (size != 0)
{
readStringMatrix(outputNode, outputNames.data());
for (auto & output : outputNames)
{
wchar_t* woutput = to_wide_string(output);
symbol::Variable* var = ctx->getOrCreate(symbol::Symbol(woutput));
FREE(woutput);
outputList->push_back(var);
}
freeStringMatrix(outputNode, outputNames.data());
}
else
{
closeDataSet(outputNode);
}
//body
int bodyNode = getDataSetIdFromName(dataset, "body");
size = getDatasetInfo(bodyNode, &complex, &dims, d.data());
if (size < 0)
{
delete inputList;
delete outputList;
closeList6(dataset);
return nullptr;
}
std::vector<unsigned char> bodybin(size);
readUnsignedInteger8Matrix(bodyNode, bodybin.data());
ast::DeserializeVisitor ds(bodybin.data());
body = ds.deserialize();
//wname+1 is to remove "/" at the start of the var name from HDF5
types::Macro* macro = new types::Macro(L"", *inputList, *outputList, *body->getAs<ast::SeqExp>(), L"script");
delete body;
closeList6(dataset);
return macro;
}
