void H5SoftLink::getAccessibleAttribute(const std::string & _name, const int pos, void * pvApiCtx) const
{
SciErr err;
std::string lower(_name);
std::transform(_name.begin(), _name.end(), lower.begin(), tolower);
if (lower == "type")
{
const std::string linkType = getLinkType();
const char * _type = linkType.c_str();
err = createMatrixOfString(pvApiCtx, pos, 1, 1, &_type);
if (err.iErr)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot create a string on the stack."));
}
return;
}
else if (lower == "target")
{
const std::string linkValue = getLinkValue();
const char * _target = linkValue.c_str();
err = createMatrixOfString(pvApiCtx, pos, 1, 1, &_target);
if (err.iErr)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot create a string on the stack."));
}
return;
}
H5Object::getAccessibleAttribute(_name, pos, pvApiCtx);
}
/*--------------------------------------------------------------------------*/
int sci_getdebuginfo(char *fname, void* pvApiCtx)
{
SciErr sciErr;
char **outputDynamicList = NULL;
char **outputStaticList = NULL;
static int n1 = 1, m1 = 0;
static int n2 = 1, m2 = 0;
CheckRhs(0, 0);
CheckLhs(0, 2);
#ifdef _MSC_VER
outputDynamicList = getDynamicDebugInfo_Windows(&m1);
outputStaticList = getStaticDebugInfo_Windows(&m2);
#else
outputDynamicList = getDynamicDebugInfo(&m1, pvApiCtx);
outputStaticList = getStaticDebugInfo(&m2);
#endif
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m1, n1, (char const * const*) outputDynamicList);
if (sciErr.iErr)
{
printError(&sciErr, 0);
freeArrayOfString(outputDynamicList, m1);
freeArrayOfString(outputStaticList, m2);
return 0;
}
LhsVar(1) = Rhs + 1;
if (Lhs == 2)
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 2, m2, n2, (char const * const*) outputStaticList);
if (sciErr.iErr)
{
printError(&sciErr, 0);
freeArrayOfString(outputDynamicList, m1);
freeArrayOfString(outputStaticList, m2);
return 0;
}
LhsVar(2) = Rhs + 2;
}
freeArrayOfString(outputDynamicList, m1);
freeArrayOfString(outputStaticList, m2);
PutLhsVar();
return 0;
}
/**
* The gateway function for soap_servers()
* @param[in] fname the name of the file for the error messages
* @return 0 if successful, a negative value otherwise
*/
int sci_empty_test(char *fname)
{
SciErr sciErr;
// allocate memory for values
double dOut = 0;
char *cOut = "zero";
// this function does not take input arguments
CheckInputArgument(pvApiCtx, 0, 0);
// the number of output arguments must be 2
CheckOutputArgument(pvApiCtx, 2, 2);
// create results on stack
sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 0, 0, &dOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 0, 0, &cOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
return 0;
}
/*--------------------------------------------------------------------------*/
SciErr createMatrixOfWideString(void* _pvCtx, int _iVar, int _iRows, int _iCols, const wchar_t* const* _pstwStrings)
{
char **pStrings = NULL;
//return empty matrix
if (_iRows == 0 && _iCols == 0)
{
double dblReal = 0;
SciErr sciErr = createMatrixOfDouble(_pvCtx, _iVar, 0, 0, &dblReal);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_EMPTY_MATRIX, _("%s: Unable to create variable in Scilab memory"), "createEmptyMatrix");
}
return sciErr;
}
pStrings = (char**)MALLOC( sizeof(char*) * (_iRows * _iCols) );
for (int i = 0; i < (_iRows * _iCols) ; i++)
{
pStrings[i] = wide_string_to_UTF8(_pstwStrings[i]);
}
SciErr sciErr = createMatrixOfString(_pvCtx, _iVar, _iRows, _iCols, pStrings);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_WIDE_STRING, _("%s: Unable to create variable in Scilab memory"), "createMatrixOfWideString");
}
freeArrayOfString(pStrings, _iRows * _iCols);
return sciErr;
}
/*--------------------------------------------------------------------------*/
int sci_typename_no_rhs(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int numberOfTypes = 0;
int *TypesNumbers = NULL;
int m_out1 = 0, n_out1 = 0;
TypesNumbers = getAllTypesNumber(&numberOfTypes);
m_out1 = numberOfTypes;
n_out1 = 1;
sciErr = createMatrixOfInteger32(pvApiCtx, Rhs + 1, m_out1, n_out1, TypesNumbers);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if (TypesNumbers)
{
FREE(TypesNumbers);
TypesNumbers = NULL;
}
LhsVar(1) = Rhs + 1;
if (Lhs > 1)
{
int m_out2 = 0, n_out2 = 0;
char **TypesNames = NULL;
TypesNames = getAllTypesName(&numberOfTypes);
m_out2 = numberOfTypes;
n_out2 = 1;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 2, m_out2, n_out2,
(const char *const *)TypesNames);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if (TypesNames)
{
freeArrayOfString(TypesNames, numberOfTypes);
}
LhsVar(2) = Rhs + 2;
}
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int createSingleString(void* _pvCtx, int _iVar, const char* _pstStrings)
{
SciErr sciErr = createMatrixOfString(_pvCtx, _iVar, 1, 1, &_pstStrings);
if (sciErr.iErr)
{
addErrorMessage(&sciErr, API_ERROR_CREATE_SINGLE_STRING, _("%s: Unable to get argument data"), "createSingleString");
printError(&sciErr, 0);
return sciErr.iErr;
}
return 0;
}
int ScilabGateway::getEnvironmentName(char * fname, const int envId, void * pvApiCtx)
{
SciErr err;
int * addr = 0;
int eId = 0;
std::string envName;
char * str;
CheckInputArgument(pvApiCtx, 1, 1);
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);
}
eId = ScilabObjects::getEnvironmentId(addr, pvApiCtx);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(eId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
envName = env.getEnvironmentName();
str = strdup(envName.c_str());
err = createMatrixOfString(pvApiCtx, Rhs + 1, 1, 1, (const char * const *)&str);
free(str);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
static int xlfont_no_rhs(char * fname)
{
SciErr sciErr;
int m1 = 0, n1 = 0;
int nbElements = 0;
char **fontsname = getInstalledFontsName(&nbElements);
m1 = 1;
n1 = nbElements;
sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, (const char * const*)fontsname);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
freeArrayOfString(fontsname, nbElements);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_uigetfont(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int* piAddrfontNameAdr = NULL;
int* piAddrfontSizeAdr = NULL;
int* piAddrboldAdr = NULL;
int* boldAdr = NULL;
int* piAddritalicAdr = NULL;
int* italicAdr = NULL;
double* fontSizeAdr = NULL;
int fontChooserID = 0;
int nbRow = 0;
int nbCol = 0;
char **fontNameAdr = NULL;
int fontNameSize = 0;
char *selectedFontName = NULL;
int selectedFontSize = 0;
BOOL selectedBold = FALSE;
BOOL selectedItalic = FALSE;
CheckInputArgument(pvApiCtx, 0, 4);
CheckOutputArgument(pvApiCtx, 1, 4);
/* Default font name */
if (nbInputArgument(pvApiCtx) >= 1)
{
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfontNameAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getAllocatedMatrixOfString(pvApiCtx, piAddrfontNameAdr, &nbRow, &nbCol, &fontNameAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
return 1;
}
fontNameSize = nbRow * nbCol;
if (fontNameSize != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 1);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
return FALSE;
}
}
/* Default font size */
if (nbInputArgument(pvApiCtx) >= 2)
{
if ((checkInputArgumentType(pvApiCtx, 2, sci_matrix)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrfontSizeAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 2.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrfontSizeAdr, &nbRow, &nbCol, &fontSizeAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
return 1;
}
if (nbRow * nbCol != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 2);
return FALSE;
}
}
else
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 2);
return FALSE;
}
}
/* Is the default font bold ? */
if (nbInputArgument(pvApiCtx) >= 3)
{
if ((checkInputArgumentType(pvApiCtx, 3, sci_boolean)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrboldAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of boolean at position 3.
sciErr = getMatrixOfBoolean(pvApiCtx, piAddrboldAdr, &nbRow, &nbCol, &boldAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: Boolean matrix expected.\n"), fname, 3);
return 1;
}
if (nbRow * nbCol != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 3);
return FALSE;
}
}
else
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3);
return FALSE;
}
}
/* Is the default font italic ? */
if (nbInputArgument(pvApiCtx) >= 4)
{
if ((checkInputArgumentType(pvApiCtx, 4, sci_boolean)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddritalicAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of boolean at position 4.
sciErr = getMatrixOfBoolean(pvApiCtx, piAddritalicAdr, &nbRow, &nbCol, &italicAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: Boolean matrix expected.\n"), fname, 4);
return 1;
}
if (nbRow * nbCol != 1)
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 4);
return FALSE;
}
}
else
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 4);
return FALSE;
}
}
/* Create the Java Object */
fontChooserID = createFontChooser();
/* Default font */
if (fontNameAdr != NULL)
{
setFontChooserFontName(fontChooserID, fontNameAdr[0]);
}
/* Default size */
if (fontSizeAdr != 0)
{
setFontChooserFontSize(fontChooserID, (int)fontSizeAdr[0]);
}
/* Default bold */
if (boldAdr != 0)
{
setFontChooserBold(fontChooserID, booltoBOOL(boldAdr[0]));
}
/* Default italic */
if (italicAdr != 0)
{
setFontChooserItalic(fontChooserID, booltoBOOL(italicAdr[0]));
}
/* Display it and wait for a user input */
fontChooserDisplayAndWait(fontChooserID);
/* Return the selected font */
/* Read the user answer */
selectedFontName = getFontChooserFontName(fontChooserID);
if (strcmp(selectedFontName, "")) /* The user selected a font */
{
selectedFontSize = getFontChooserFontSize(fontChooserID);
selectedBold = getFontChooserBold(fontChooserID);
selectedItalic = getFontChooserItalic(fontChooserID);
nbRow = 1;
nbCol = 1;
if (nbOutputArgument(pvApiCtx) >= 1)
{
sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, (const char * const*) &selectedFontName);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
if (selectedFontName)
{
freeAllocatedSingleString(selectedFontName);
}
if (nbOutputArgument(pvApiCtx) >= 2)
{
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &fontSizeAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
*fontSizeAdr = selectedFontSize;
}
if (nbOutputArgument(pvApiCtx) >= 3)
{
sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &boldAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
*boldAdr = selectedBold;
}
if (nbOutputArgument(pvApiCtx) >= 4)
{
sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 4, nbRow, nbCol, &italicAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
*italicAdr = selectedItalic;
}
}
else /* The user canceled */
{
if (selectedFontName)
{
freeAllocatedSingleString(selectedFontName);
}
nbRow = 0;
nbCol = 0;
if (nbOutputArgument(pvApiCtx) >= 1)
{
/* Return "" as font name */
char* fontNameEmpty = NULL;
if (allocSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow * nbCol, (const char**) &fontNameEmpty))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
if (nbOutputArgument(pvApiCtx) >= 2)
{
/* Return [] as font size */
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &fontSizeAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
if (nbOutputArgument(pvApiCtx) >= 3)
{
/* Return [] as bold value */
sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &boldAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
if (nbOutputArgument(pvApiCtx) >= 4)
{
/* Return [] as italic value */
sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 4, nbRow, nbCol, &italicAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
if (fontNameSize)
{
freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
}
ReturnArguments(pvApiCtx);
return TRUE;
}
/*--------------------------------------------------------------------------*/
int sci_mgetl(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
int numberOfLinesToRead = -1;
Rhs = Max(0, Rhs);
CheckRhs(1, 2);
CheckLhs(1, 1);
if (Rhs == 2)
{
int *piAddressVarTwo = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if ( isDoubleType(pvApiCtx, piAddressVarTwo) )
{
double dValue = 0.;
if (!isScalar(pvApiCtx, piAddressVarTwo))
{
Scierror(999, _("%s: Wrong size for input argument #%d: Integer expected.\n"), fname, 2);
return 0;
}
if ( getScalarDouble(pvApiCtx, piAddressVarTwo, &dValue) == 0)
{
numberOfLinesToRead = (int)dValue;
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Integer expected.\n"), fname, 2);
return 0;
}
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if ( isStringType(pvApiCtx, piAddressVarOne) || isDoubleType(pvApiCtx, piAddressVarOne) )
{
char **wcReadedStrings = NULL;
int numberOfLinesReaded = 0;
int fileDescriptor = -1;
int iErrorMgetl = 0;
BOOL bCloseFile = FALSE;
if (!isScalar(pvApiCtx, piAddressVarOne))
{
Scierror(999, _("%s: Wrong size for input argument #%d: String or logical unit expected.\n"), fname, 1);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarOne))
{
char *fileName = NULL;
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &fileName) == 0)
{
char *expandedFileName = expandPathVariable(fileName);
freeAllocatedSingleString(fileName);
fileName = NULL;
if (IsAlreadyOpenedInScilab(expandedFileName))
{
int fd = GetIdFromFilename(expandedFileName);
fileDescriptor = fd;
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
bCloseFile = FALSE;
}
else
{
#define READ_ONLY_TEXT_MODE "rt"
int fd = 0;
int f_swap = 0;
double res = 0.0;
int ierr = 0;
C2F(mopen)(&fd, expandedFileName, READ_ONLY_TEXT_MODE, &f_swap, &res, &ierr);
bCloseFile = TRUE;
switch (ierr)
{
case MOPEN_NO_ERROR:
fileDescriptor = fd;
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
break;
case MOPEN_NO_MORE_LOGICAL_UNIT:
{
Scierror(66, _("%s: Too many files opened!\n"), fname);
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
return 0;
}
break;
case MOPEN_CAN_NOT_OPEN_FILE:
{
Scierror(999, _("%s: Cannot open file %s.\n"), fname, expandedFileName);
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
return 0;
}
break;
case MOPEN_NO_MORE_MEMORY:
{
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
break;
case MOPEN_INVALID_FILENAME:
{
Scierror(999, _("%s: invalid filename %s.\n"), fname, expandedFileName);
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
return 0;
}
break;
case MOPEN_INVALID_STATUS:
default:
{
if (expandedFileName)
{
FREE(expandedFileName);
expandedFileName = NULL;
}
Scierror(999, _("%s: invalid status.\n"), fname);
return 0;
}
break;
}
}
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else /* double */
{
double dValue = 0.;
if ( !getScalarDouble(pvApiCtx, piAddressVarOne, &dValue) )
{
FILE *fd = NULL;
fileDescriptor = (int)dValue;
if ((fileDescriptor == STDIN_ID) || (fileDescriptor == STDOUT_ID))
{
SciError(244);
return 0;
}
fd = GetFileOpenedInScilab(fileDescriptor);
if (fd == NULL)
{
Scierror(245, _("%s: No input file associated to logical unit %d.\n"), fname, fileDescriptor);
return 0;
}
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
wcReadedStrings = mgetl(fileDescriptor, numberOfLinesToRead, &numberOfLinesReaded, &iErrorMgetl);
if (bCloseFile)
{
double dErrClose = 0.;
C2F(mclose)(&fileDescriptor, &dErrClose);
}
switch (iErrorMgetl)
{
case MGETL_NO_ERROR:
{
if (numberOfLinesReaded == 0)
{
if (createEmptyMatrix(pvApiCtx, Rhs + 1) != 0)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
int m = numberOfLinesReaded;
int n = 1;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m, n, wcReadedStrings);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(17, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
freeArrayOfString(wcReadedStrings, numberOfLinesReaded);
wcReadedStrings = NULL;
}
break;
case MGETL_EOF:
{
if (numberOfLinesReaded == 0)
{
if (createEmptyMatrix(pvApiCtx, Rhs + 1) != 0)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
int m = numberOfLinesReaded;
int n = 1;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m, n, wcReadedStrings);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(17, _("%s: Memory allocation error.\n"), fname);
return 0;
}
freeArrayOfString(wcReadedStrings, numberOfLinesReaded);
wcReadedStrings = NULL;
}
}
break;
case MGETL_MEMORY_ALLOCATION_ERROR:
{
if (wcReadedStrings)
{
freeArrayOfString(wcReadedStrings, numberOfLinesReaded);
wcReadedStrings = NULL;
}
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
break;
case MGETL_ERROR:
{
if (wcReadedStrings)
{
freeArrayOfString(wcReadedStrings, numberOfLinesReaded);
wcReadedStrings = NULL;
}
Scierror(999, _("%s: error.\n"), fname);
return 0;
}
break;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: String or logical unit expected.\n"), fname, 1);
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_libraryinfo(char *fname,unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
CheckRhs(1,1);
CheckLhs(1,2);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarOne))
{
char *libraryname = NULL;
if (!isScalar(pvApiCtx, piAddressVarOne))
{
Scierror(999,_("%s: Wrong size for input argument #%d: String expected.\n"), fname, 1);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &libraryname) == 0)
{
if (libraryname)
{
char *pathlibrary = getlibrarypath(libraryname);
if (pathlibrary)
{
int sizemacrosarray = 0;
char **macros = getlistmacrosfromlibrary(libraryname, &sizemacrosarray);
if (macros)
{
int m = sizemacrosarray;
int n = 1;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m, n, macros);
if(sciErr.iErr)
{
freeArrayOfString(macros, sizemacrosarray);
if (pathlibrary)
{
FREE(pathlibrary);
pathlibrary = NULL;
}
if (libraryname)
{
freeAllocatedSingleString(libraryname);
libraryname = NULL;
}
printError(&sciErr, 0);
Scierror(999,_("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
createEmptyMatrix(pvApiCtx, Rhs + 1);
}
LhsVar(1) = Rhs+1;
freeArrayOfString(macros, sizemacrosarray);
if (Lhs == 2)
{
createSingleString(pvApiCtx, Rhs + 2, pathlibrary);
LhsVar(2) = Rhs+2;
}
if (pathlibrary) {FREE(pathlibrary);pathlibrary=NULL;}
PutLhsVar();
}
else
{
Scierror(999,_("%s: Invalid library %s.\n"),fname, libraryname);
}
if (libraryname)
{
freeAllocatedSingleString(libraryname);
libraryname = NULL;
}
}
else
{
Scierror(999,_("%s: Memory allocation error.\n"), fname);
}
}
else
{
Scierror(999,_("%s: Memory allocation error.\n"), fname);
}
}
else
{
Scierror(999,_("%s: Wrong type of input argument #%d: String expected.\n"),fname,1);
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_dgettext(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
int *piAddressVarTwo = NULL;
CheckRhs(2, 2);
CheckLhs(1, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
}
if (isStringType(pvApiCtx, piAddressVarOne) && isStringType(pvApiCtx, piAddressVarTwo))
{
char *domain = NULL;
if (!isScalar(pvApiCtx, piAddressVarOne))
{
Scierror(999, "%s: Wrong size for input argument #%d: A string expected.\n", fname, 1);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &domain) == 0)
{
char **stringsToTranslate = NULL;
char **TranslatedStrings = NULL;
int m = 0, n = 0;
int i = 0;
if (getAllocatedMatrixOfString(pvApiCtx, piAddressVarTwo, &m, &n, &stringsToTranslate) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
TranslatedStrings = (char **)MALLOC(sizeof(char*) * (m * n));
if (TranslatedStrings == NULL)
{
freeAllocatedMatrixOfString(m, n, stringsToTranslate);
stringsToTranslate = NULL;
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
for (i = 0; i < m * n; i++)
{
if (strcmp(stringsToTranslate[i], "") == 0)
{
TranslatedStrings[i] = strdup("");
}
else
{
TranslatedStrings[i] = convertString_dgettext(domain, stringsToTranslate[i]);
}
}
freeAllocatedMatrixOfString(m, n, stringsToTranslate);
stringsToTranslate = NULL;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m, n,
(const char *const *)TranslatedStrings);
freeArrayOfString(TranslatedStrings, m * n);
TranslatedStrings = NULL;
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
else
{
if (isStringType(pvApiCtx, piAddressVarOne))
{
Scierror(999, "%s: Wrong type for input argument #%d: String expected.\n", fname, 2);
}
else
{
Scierror(999, "%s: Wrong type for input argument #%d: String expected.\n", fname, 1);
}
}
return 0;
}
int sci_hdf5_listvar_v2(char *fname, int* pvApiCtx)
{
SciErr sciErr;
int *piAddr = NULL;
char* pstFile = NULL;
int iFile = 0;
int iNbItem = 0;
VarInfo* pInfo = NULL;
const int nbIn = nbInputArgument(pvApiCtx);
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 1, 4);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFile))
{
if (pstFile)
{
FREE(pstFile);
}
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return 1;
}
char* pstFileName = expandPathVariable(pstFile);
iFile = openHDF5File(pstFileName, 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFile);
FREE(pstFileName);
FREE(pstFile);
return 1;
}
FREE(pstFileName);
FREE(pstFile);
//manage version information
int iVersion = getSODFormatAttribute(iFile);
if (iVersion != SOD_FILE_VERSION)
{
if (iVersion > SOD_FILE_VERSION)
{
//can't read file with version newer that me !
closeHDF5File(iFile);
Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
return 1;
}
else
{
//call older import functions and exit or ... EXIT !
if (iVersion == 1 || iVersion == -1)
{
//sciprint("old sci_listvar_in_hdf5_v1\n");
return sci_listvar_in_hdf5_v1(fname, pvApiCtx);
}
}
}
iNbItem = getVariableNames(iFile, NULL);
if (iNbItem != 0)
{
char** pstVarNameList = (char**)MALLOC(sizeof(char*) * iNbItem);
pInfo = (VarInfo*)MALLOC(iNbItem * sizeof(VarInfo));
int b;
if (Lhs == 1)
{
sciprint("Name Type Size Bytes\n");
sciprint("---------------------------------------------------------------\n");
}
iNbItem = getVariableNames(iFile, pstVarNameList);
for (int i = 0; i < iNbItem; i++)
{
int iDataSetId = getDataSetIdFromName(iFile, pstVarNameList[i]);
if (iDataSetId == 0)
{
break;
}
strncpy(pInfo[i].varName, pstVarNameList[i], sizeof(pInfo[i].varName) - 1);
pInfo[i].iSize = 0;
b = read_data(iDataSetId, 0, NULL, &pInfo[i]) == false;
if (b)
{
break;
}
if (Lhs == 1)
{
sciprint("%s\n", pInfo[i].pstInfo);
}
}
freeArrayOfString(pstVarNameList, iNbItem);
}
else
{
//no variable returms [] for each Lhs
for (int i = 0 ; i < Lhs ; i++)
{
createEmptyMatrix(pvApiCtx, nbIn + i + 1);
AssignOutputVariable(pvApiCtx, i + 1) = nbIn + i + 1;
}
ReturnArguments(pvApiCtx);
return 0;
}
closeHDF5File(iFile);
//1st Lhs
char** pstVarName = (char**)MALLOC(sizeof(char*) * iNbItem);
for (int i = 0 ; i < iNbItem ; i++)
{
pstVarName[i] = pInfo[i].varName;
}
sciErr = createMatrixOfString(pvApiCtx, nbIn + 1, iNbItem, 1, pstVarName);
FREE(pstVarName);
if (sciErr.iErr)
{
FREE(pInfo);
printError(&sciErr, 0);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbIn + 1;
if (Lhs > 1)
{
//2nd Lhs
double* pdblType;
sciErr = allocMatrixOfDouble(pvApiCtx, nbIn + 2, iNbItem, 1, &pdblType);
if (sciErr.iErr)
{
printError(&sciErr, 0);
FREE(pInfo);
return 1;
}
for (int i = 0 ; i < iNbItem ; i++)
{
pdblType[i] = pInfo[i].iType;
}
AssignOutputVariable(pvApiCtx, 2) = nbIn + 2;
if (Lhs > 2)
{
//3rd Lhs
int* pList = NULL;
sciErr = createList(pvApiCtx, nbIn + 3, iNbItem, &pList);
for (int i = 0 ; i < iNbItem ; i++)
{
double* pdblDims = NULL;
allocMatrixOfDoubleInList(pvApiCtx, nbIn + 3, pList, i + 1, 1, pInfo[i].iDims, &pdblDims);
for (int j = 0 ; j < pInfo[i].iDims ; j++)
{
pdblDims[j] = pInfo[i].piDims[j];
}
}
AssignOutputVariable(pvApiCtx, 3) = nbIn + 3;
}
if (Lhs > 3)
{
//4th Lhs
double* pdblSize = NULL;
sciErr = allocMatrixOfDouble(pvApiCtx, nbIn + 4, iNbItem, 1, &pdblSize);
for (int i = 0 ; i < iNbItem ; i++)
{
pdblSize[i] = pInfo[i].iSize;
}
AssignOutputVariable(pvApiCtx, 4) = nbIn + 4;
}
}
FREE(pInfo);
ReturnArguments(pvApiCtx);
return 0;
}
int read_string(char *fname,unsigned long fname_len)
{
SciErr sciErr;
int i,j;
int iLen = 0;
//variable info
int iRows = 0;
int iCols = 0;
int* piAddr = NULL;
int* piLen = NULL;
char** pstData = NULL;
//output variable
int iRowsOut = 1;
int iColsOut = 1;
char* pstOut = NULL;
//check input and output arguments
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 1, 1);
//get variable address
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//fisrt call to retrieve dimensions
sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
piLen = (int*)malloc(sizeof(int) * iRows * iCols);
//second call to retrieve length of each string
sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
pstData = (char**)malloc(sizeof(char*) * iRows * iCols);
for(i = 0 ; i < iRows * iCols ; i++)
{
pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
}
//third call to retrieve data
sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//computer length of all strings
for(i = 0 ; i < iRows * iCols ; i++)
{
iLen += piLen[i];
}
//alloc output variable
pstOut = (char*)malloc(sizeof(char) * (iLen + iRows * iCols));
//initialize string to 0x00
memset(pstOut, 0x00, sizeof(char) * (iLen + iRows * iCols));
//concat input strings in output string
for(i = 0 ; i < iRows ; i++)
{
for(j = 0 ; j < iCols ; j++)
{
int iCurLen = strlen(pstOut);
if(iCurLen)
{
strcat(pstOut, " ");
}
strcpy(pstOut + strlen(pstOut), pstData[j * iRows + i]);
}
}
//create new variable
sciErr = createMatrixOfString(pvApiCtx, InputArgument + 1, iRowsOut, iColsOut, &pstOut);
if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
//free memory
free(piLen);
for(i = 0 ; i < iRows * iCols ; i++)
{
free(pstData[i]);
}
free(pstData);
free(pstOut);
AssignOutputVariable(1) = InputArgument + 1;
return 0;
}
int ScilabGateway::deff(char * fname, const int envId, void * pvApiCtx)
{
static int ONE = 1;
static int TWO = 2;
static int THREE = 3;
SciErr err;
char ** names[] = {0, 0, 0};
int ret = 0;
std::ostringstream os;
char * str;
int * addr[] = {0, 0, 0};
int rows[] = {0, 0, 0};
int cols[] = {0, 0, 0};
int error = 0;
char * cwd = 0;
CheckInputArgument(pvApiCtx, 3, 3);
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
ScilabGatewayOptions & options = env.getGatewayOptions();
OptionsHelper & helper = env.getOptionsHelper();
OptionsHelper::setCopyOccurred(false);
ScilabObjects::initialization(env, pvApiCtx);
options.setIsNew(false);
for (int i = 0; i < 3; i++)
{
err = getVarAddressFromPosition(pvApiCtx, i + 1, &(addr[i]));
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
if (!isStringType(pvApiCtx, addr[i]))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for input argument #%d: A String expected."), 1);
}
err = getVarDimension(pvApiCtx, addr[i], &(rows[i]), &(cols[i]));
if (err.iErr)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
if (rows[0] != 1 || cols[0] != 1)
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimensions for input argument #%d: A single string expected."), 1);
}
if (rows[1] != rows[2] || cols[1] != cols[2])
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid dimensions: arguments #2 and #3 must have the same."));
}
for (int i = 0; i < 3; i++)
{
if (getAllocatedMatrixOfString(pvApiCtx, addr[i], &(rows[i]), &(cols[i]), &(names[i])))
{
for (int j = 0; j < i; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data"));
}
}
cwd = scigetcwd(&error);
if (error)
{
FREE(cwd);
cwd = 0;
}
try
{
ret = env.loadclass(names[0][0], cwd, false, helper.getAllowReload());
}
catch (std::exception & e)
{
FREE(cwd);
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
throw;
}
FREE(cwd);
for (int i = 0; i < rows[1] * cols[1]; i++)
{
err = createMatrixOfString(pvApiCtx, ONE, 1, 1, (const char * const *) & (names[2][i]));
if (err.iErr)
{
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
env.removeobject(ret);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
os.str("");
os << "y=" << names[2][i] << "(varargin)" << std::flush;
str = strdup(os.str().c_str());
err = createMatrixOfString(pvApiCtx, TWO, 1, 1, (const char * const *)&str);
free(str);
if (err.iErr)
{
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
env.removeobject(ret);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
os.str("");
os << "y=invoke_lu(int32(" << ret << "),int32(" << envId << "),\"" << names[1][i] << "\",varargin)" << std::flush;
str = strdup(os.str().c_str());
err = createMatrixOfString(pvApiCtx, THREE, 1, 1, (const char * const *)&str);
free(str);
if (err.iErr)
{
for (int j = 0; j < 3; j++)
{
freeAllocatedMatrixOfString(rows[j], cols[j], names[j]);
}
env.removeobject(ret);
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create the data"));
}
SciString(&ONE, const_cast<char *>("!_deff_wrapper"), &ONE, &THREE);
}
for (int i = 0; i < 3; i++)
{
freeAllocatedMatrixOfString(rows[0], cols[0], names[i]);
}
LhsVar(1) = 0;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_buildDoc(char *fname, void* pvApiCtx)
{
std::string exportFormat;
std::string SciPath = getSCI(); /* Scilab path */
std::string masterXML; /* Which file contains all the doc stuff */
std::string masterXMLTMP;
std::string outputDirectory; /* Working directory */
std::string outputDirectoryTMP;
std::string language;
std::string styleSheet; /* the CSS */
char * fileToExec = NULL;
SciErr sciErr;
int *piAddr = NULL;
int iRet = 0;
CheckRhs(0, 4);
CheckLhs(1, 1);
styleSheet = SciPath + PATHTOCSS;
if (Rhs < 1)
{
exportFormat = DEFAULTEXPORT;
}
else
{
char* pstData = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (!isStringType(pvApiCtx, piAddr))
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
return 0;
// Wrong type string
}
iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
if (iRet)
{
freeAllocatedSingleString(pstData);
return iRet;
}
exportFormat = std::string(pstData);
freeAllocatedSingleString(pstData);
}
if (Rhs < 3) /* Language not provided */
{
wchar_t* l = getlanguage();
language = wide_string_to_UTF8(l);
free(l);
}
else
{
char* pstData = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
if (!isStringType(pvApiCtx, piAddr))
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 3);
return 0;
// Wrong type string
}
if (!isScalar(pvApiCtx, piAddr))
{
wchar_t* pwstLang = getlanguage();
language = wide_string_to_UTF8(pwstLang);
free(pwstLang);
}
else
{
iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
if (iRet)
{
freeAllocatedSingleString(pstData);
return iRet;
}
language = std::string(pstData);
freeAllocatedSingleString(pstData);
}
}
if (Rhs < 2)
{
/* Update the path with the localization */
masterXMLTMP = std::string("/modules/helptools/master_") + language + std::string("_help.xml");
masterXML = SciPath + masterXMLTMP;
}
else
{
char* pstData = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if (!isStringType(pvApiCtx, piAddr))
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2);
return 0;
// Wrong type string
}
iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
if (iRet)
{
freeAllocatedSingleString(pstData);
return iRet;
}
masterXML = std::string(pstData);
freeAllocatedSingleString(pstData);
}
if (Rhs == 4)
{
char* pstData = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 4);
return 0;
}
if (!isStringType(pvApiCtx, piAddr))
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 4);
return 0;
// Wrong type string
}
iRet = getAllocatedSingleString(pvApiCtx, piAddr, &pstData);
if (iRet)
{
freeAllocatedSingleString(pstData);
return iRet;
}
outputDirectory = std::string(pstData) + std::string("/scilab_") + language + std::string("_help/");
freeAllocatedSingleString(pstData);
}
else /* Scilab help */
{
/* Update the path with the localization */
if (exportFormat != "jar-only")
{
outputDirectoryTMP =
std::string("/modules/helptools/") + std::string(exportFormat) + std::string("/scilab_") + language + std::string("_help/");
}
else
{
outputDirectoryTMP =
std::string("/modules/helptools/") + std::string("javaHelp") + std::string("/scilab_") + language + std::string("_help/");
}
outputDirectory = SciPath + outputDirectoryTMP;
}
#ifdef _MSC_VER
__slashToAntislash(&outputDirectory);
__slashToAntislash(&styleSheet);
__slashToAntislash(&masterXML);
#endif
try
{
org_scilab_modules_helptools::SciDocMain * doc = new org_scilab_modules_helptools::SciDocMain(getScilabJavaVM());
if (doc->setOutputDirectory((char *)outputDirectory.c_str()))
{
doc->setWorkingLanguage((char *)language.c_str());
doc->setExportFormat((char *)exportFormat.c_str());
doc->setIsToolbox(Rhs == 4);
fileToExec = doc->process((char *)masterXML.c_str(), (char *)styleSheet.c_str());
}
else
{
Scierror(999, _("%s: Could find or create the working directory %s.\n"), fname, outputDirectory.c_str());
return FALSE;
}
if (doc != NULL)
{
delete doc;
}
}
catch (GiwsException::JniException ex)
{
Scierror(999, _("%s: Error while building documentation: %s.\n"), fname, ex.getJavaDescription().c_str());
Scierror(999, _("%s: Execution Java stack: %s.\n"), fname, ex.getJavaStackTrace().c_str());
Scierror(999,
_
("If Scilab is started in a chroot, you might want to try to set the two environment variables: SCI_DISABLE_TK=1 SCI_JAVA_ENABLE_HEADLESS=1\n"));
return FALSE;
}
if (fileToExec)
{
createMatrixOfString(pvApiCtx, Rhs + 1, 1, 1, &fileToExec);
delete [] fileToExec;
}
else
{
createEmptyMatrix(pvApiCtx, Rhs + 1);
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
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;
}
/*--------------------------------------------------------------------------*/
static int xlfont_one_rhs(char * fname)
{
SciErr sciErr;
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
int* piAddrl1 = NULL;
int* l1 = NULL;
char* strl1 = NULL;
int m1 = 0, n1 = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
if (getAllocatedSingleString(pvApiCtx, piAddrl1, &strl1))
{
Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
return 1;
}
if (strcmp(strl1, "AVAILABLE_FONTS") == 0)
{
int nbElements = 0;
char **fontsname = getAvailableFontsName(&nbElements);
m1 = nbElements;
n1 = 1;
sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, (const char * const*)fontsname);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
freeArrayOfString(fontsname, nbElements);
freeAllocatedSingleString(strl1);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
else if (strcmp(strl1, "reset") == 0)
{
resetFontManager();
freeAllocatedSingleString(strl1);
AssignOutputVariable(pvApiCtx, 1) = 0;
ReturnArguments(pvApiCtx);
return 0;
}
else
{
if (isAvailableFontsName(strl1))
{
int fontID = addFont(strl1);
m1 = 1;
n1 = 1;
sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
l1[0] = fontID;
freeAllocatedSingleString(strl1);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
else if (FileExist(strl1))
{
int fontID = addFontFromFilename(strl1);
m1 = 1;
n1 = 1;
sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
l1[0] = fontID;
freeAllocatedSingleString(strl1);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: A valid fontname expected.\n"), fname, 1);
}
}
freeAllocatedSingleString(strl1);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_dec2base(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
int *piAddressVarTwo = NULL;
int m = 0, n = 0;
double *dValues = NULL;
char **convertedValues = NULL;
unsigned int iBaseUsed = 0;
double dBaseUsed = 0.;
unsigned int nbDigits = 0;
error_convertbase err = ERROR_CONVERTBASE_NOK;
CheckRhs(2, 3);
CheckLhs(1, 1);
if (Rhs == 3)
{
double dParamThree = 0.;
unsigned int iParamThree = 0;
int *piAddressVarThree = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
if (!isDoubleType(pvApiCtx, piAddressVarThree))
{
Scierror(999,_("%s: Wrong type for input argument #%d: A scalar integer value expected.\n"), fname, 3);
return 0;
}
if (!isScalar(pvApiCtx, piAddressVarThree))
{
Scierror(999,_("%s: Wrong size for input argument #%d: A scalar integer value expected.\n"), fname, 3);
return 0;
}
if (getScalarDouble(pvApiCtx, piAddressVarThree, &dParamThree) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
iParamThree = (unsigned int)dParamThree;
if (dParamThree != (double)iParamThree)
{
Scierror(999,_("%s: Wrong value for input argument #%d: A integer value expected.\n"), fname, 3);
return 0;
}
nbDigits = iParamThree;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if (!isDoubleType(pvApiCtx, piAddressVarTwo))
{
Scierror(999,_("%s: Wrong type for input argument #%d: A integer value expected.\n"), fname, 2);
return 0;
}
if (!isScalar(pvApiCtx, piAddressVarTwo))
{
Scierror(999,_("%s: Wrong size for input argument #%d.\n"), fname, 2);
return 0;
}
if (getScalarDouble(pvApiCtx, piAddressVarTwo, &dBaseUsed) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
iBaseUsed = (unsigned int)dBaseUsed;
if (dBaseUsed != (double)iBaseUsed)
{
Scierror(999, _("%s: Wrong value for input argument #%d: A integer value expected.\n"), fname, 2);
return 0;
}
if ((iBaseUsed < 2) && (iBaseUsed > 36))
{
Scierror(999, _("%s: Wrong value for input argument #%d: Must be between %d and %d."), fname, 2, 2, 36);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (isEmptyMatrix(pvApiCtx, piAddressVarOne))
{
if (createEmptyMatrix(pvApiCtx, Rhs + 1) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
else
{
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
}
if (!isDoubleType(pvApiCtx, piAddressVarOne))
{
Scierror(999,_("%s: Wrong type for input argument #%d: A matrix of integer value expected.\n"), fname, 1);
return 0;
}
if (isVarComplex(pvApiCtx, piAddressVarOne))
{
Scierror(999,_("%s: Wrong type for input argument #%d: A matrix of integer value expected.\n"), fname, 1);
return 0;
}
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m, &n , &dValues);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
convertedValues = (char **)MALLOC(sizeof(char*) * (m *n));
if (convertedValues == NULL)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
convertedValues = convertMatrixOfDec2Base(dValues, m * n, iBaseUsed, nbDigits, &err);
if ((err != ERROR_CONVERTBASE_OK) || (convertedValues == NULL))
{
freeArrayOfString(convertedValues, m * n);
convertedValues = NULL;
switch (err)
{
case ERROR_CONVERTBASE_NOT_INTEGER_VALUE:
Scierror(999, _("%s: Wrong value for input argument #%d: Must be between 0 and 2^52.\n"), fname, 1);
return 0;
case ERROR_CONVERTBASE_NOT_IN_INTERVAL:
Scierror(999,_("%s: Wrong value(s) for input argument #%d: A matrix of positive integer values expected.\n"), fname, 1);
return 0;
case ERROR_CONVERTBASE_ALLOCATION:
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
case ERROR_CONVERTBASE_NOK: default:
Scierror(999, _("%s: Wrong value for input argument #%d: cannot convert value(s).\n"), fname, 1);
return 0;
}
}
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m, n, convertedValues);
freeArrayOfString(convertedValues, m * n);
convertedValues = NULL;
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999,_("%s: Memory allocation error.\n"), fname);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_fscanfMat(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
int m1 = 0, n1 = 0;
int iType1 = 0;
char *filename = NULL;
char *expandedFilename = NULL;
char *Format = NULL;
char *separator = NULL;
BOOL bIsDefaultSeparator = TRUE;
fscanfMatResult *results = NULL;
CheckRhs(1, 3);
CheckLhs(1, 2);
if (Rhs == 3)
{
int *piAddressVarThree = NULL;
int m3 = 0, n3 = 0;
int iType3 = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarThree) == 0 || isScalar(pvApiCtx, piAddressVarThree) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 3);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarThree, &separator))
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
bIsDefaultSeparator = FALSE;
}
if (Rhs >= 2)
{
int *piAddressVarTwo = NULL;
int m2 = 0, n2 = 0;
int iType2 = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if (sciErr.iErr)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iType2);
if (sciErr.iErr)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarTwo) == 0 || isScalar(pvApiCtx, piAddressVarTwo) == 0)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 2);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarTwo, &Format))
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
Format = os_strdup(DEFAULT_FSCANFMAT_FORMAT);
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (isStringType(pvApiCtx, piAddressVarOne) == 0 || isScalar(pvApiCtx, piAddressVarOne) == 0)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &filename))
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
expandedFilename = expandPathVariable(filename);
if (bIsDefaultSeparator)
{
#define NB_DEFAULT_SUPPORTED_SEPARATORS 2
/* bug 8148 */
/* default separator can be a space or a tabulation */
char *supportedSeparators[NB_DEFAULT_SUPPORTED_SEPARATORS] = {DEFAULT_FSCANFMAT_SEPARATOR, "\t"};
int i = 0;
for (i = 0; i < NB_DEFAULT_SUPPORTED_SEPARATORS; i++)
{
results = fscanfMat(expandedFilename, Format, supportedSeparators[i]);
if (results && results->err == FSCANFMAT_NO_ERROR)
{
break;
}
freeFscanfMatResult(results);
}
}
else
{
results = fscanfMat(expandedFilename, Format, separator);
}
if (results == NULL)
{
freeVar(&filename, &expandedFilename, &Format, &separator);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
freeVar(NULL, &expandedFilename, &Format, &separator);
switch (results->err)
{
case FSCANFMAT_NO_ERROR:
{
if ( (results->values) && (results->m > 0) && (results->n > 0))
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, results->m, results->n, results->values);
if (sciErr.iErr)
{
FREE(filename);
freeFscanfMatResult(results);
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
if (createEmptyMatrix(pvApiCtx, Rhs + 1))
{
FREE(filename);
freeFscanfMatResult(results);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
LhsVar(1) = Rhs + 1;
if (Lhs == 2)
{
if (results->text)
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 2, results->sizeText, 1, (char const * const*) results->text);
if (sciErr.iErr)
{
FREE(filename);
freeFscanfMatResult(results);
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
if (createSingleString(pvApiCtx, Rhs + 2, ""))
{
FREE(filename);
freeFscanfMatResult(results);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
LhsVar(2) = Rhs + 2;
}
freeFscanfMatResult(results);
FREE(filename);
PutLhsVar();
return 0;
}
case FSCANFMAT_MOPEN_ERROR:
{
Scierror(999, _("%s: can not open file %s.\n"), fname, filename);
FREE(filename);
return 0;
}
case FSCANFMAT_READLINES_ERROR:
{
Scierror(999, _("%s: can not read file %s.\n"), fname, filename);
FREE(filename);
return 0;
}
case FSCANFMAT_FORMAT_ERROR:
{
Scierror(999, _("%s: Invalid format.\n"), fname);
FREE(filename);
return 0;
}
case FSCANFMAT_MEMORY_ALLOCATION:
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
FREE(filename);
return 0;
}
default:
case FSCANFMAT_ERROR:
{
Scierror(999, _("%s: error.\n"), fname);
FREE(filename);
return 0;
}
}
FREE(filename);
freeFscanfMatResult(results);
return 0;
}
// =============================================================================
static int sci_csvDefault_no_rhs(char *fname, void* pvApiCtx)
{
int sizeArray = NUMBER_FIELD * 2;
char **arrayOut = (char**)MALLOC(sizeof(char*) * sizeArray);
if (arrayOut)
{
SciErr sciErr;
int nbRows = NUMBER_FIELD;
int nbCols = 2;
const char *currentEol = getCsvDefaultEOL();
arrayOut[0] = os_strdup(SEPARATOR_FIELDNAME);
arrayOut[1] = os_strdup(DECIMAL_FIELDNAME);
arrayOut[2] = os_strdup(CONVERSION_FIELDNAME);
arrayOut[3] = os_strdup(PRECISION_FIELDNAME);
arrayOut[4] = os_strdup(COMMENTSREGEXP_FIELDNAME);
arrayOut[5] = os_strdup(EOL_FIELDNAME);
arrayOut[6] = os_strdup(ENCODING_FIELDNAME);
arrayOut[7] = os_strdup(BLANK_FIELDNAME);
arrayOut[8] = os_strdup(getCsvDefaultSeparator());
arrayOut[9] = os_strdup(getCsvDefaultDecimal());
arrayOut[10] = os_strdup(getCsvDefaultConversion());
arrayOut[11] = os_strdup(getCsvDefaultPrecision());
arrayOut[12] = os_strdup(getCsvDefaultCommentsRegExp());
if (currentEol)
{
if (strcmp(currentEol, MACOS9_EOL) == 0)
{
arrayOut[13] = os_strdup(MACOS9_EOL_STRING);
}
else if (strcmp(currentEol, WINDOWS_EOL) == 0)
{
arrayOut[13] = os_strdup(WINDOWS_EOL_STRING);
}
else if (strcmp(currentEol, LINUX_EOL) == 0)
{
arrayOut[13] = os_strdup(LINUX_EOL_STRING);
}
else
{
arrayOut[13] = os_strdup("ERROR");
}
}
else
{
arrayOut[13] = os_strdup("ERROR");
}
arrayOut[14] = os_strdup(getCsvDefaultEncoding());
arrayOut[15] = os_strdup(getCsvDefaultCsvIgnoreBlankLine());
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, nbRows, nbCols, arrayOut);
freeArrayOfString(arrayOut, sizeArray);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
return 0;
}
int sci_listvar_in_hdf5_v1(char *fname, int* pvCtx)
{
SciErr sciErr;
int *piAddr = NULL;
char* pstFile = NULL;
int iFile = 0;
int iNbItem = 0;
VarInfo_v1* pInfo = NULL;
CheckInputArgument(pvCtx, 1, 1);
CheckOutputArgument(pvCtx, 1, 4);
sciErr = getVarAddressFromPosition(pvCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvCtx, piAddr, &pstFile))
{
if (pstFile)
{
FREE(pstFile);
}
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 1);
return 1;
}
char* pstFileName = expandPathVariable(pstFile);
iFile = openHDF5File(pstFileName, 0);
if (iFile < 0)
{
FREE(pstFileName);
Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFile);
FREE(pstFile);
return 1;
}
FREE(pstFileName);
FREE(pstFile);
iNbItem = getVariableNames_v1(iFile, NULL);
if (iNbItem != 0)
{
char** pstVarNameList = (char**)MALLOC(sizeof(char*) * iNbItem);
bool b;
pInfo = (VarInfo_v1*)MALLOC(iNbItem * sizeof(VarInfo_v1));
if (nbOutputArgument(pvCtx) == 1)
{
sciprint("Name Type Size Bytes\n");
sciprint("---------------------------------------------------------------\n");
}
iNbItem = getVariableNames_v1(iFile, pstVarNameList);
for (int i = 0; i < iNbItem; i++)
{
int iDataSetId = getDataSetIdFromName_v1(iFile, pstVarNameList[i]);
if (iDataSetId == 0)
{
break;
}
strncpy(pInfo[i].varName, pstVarNameList[i], sizeof(pInfo[i].varName));
b = read_data_v1(pvCtx, iDataSetId, 0, NULL, &pInfo[i]) == false;
closeDataSet_v1(iDataSetId);
if (b)
{
break;
}
if (nbOutputArgument(pvCtx) == 1)
{
sciprint("%s\n", pInfo[i].pstInfo);
}
}
freeArrayOfString(pstVarNameList, iNbItem);
}
else
{
//no variable returms [] for each Lhs
for (int i = 0 ; i < nbOutputArgument(pvCtx) ; i++)
{
createEmptyMatrix(pvCtx, nbInputArgument(pvCtx) + i + 1);
AssignOutputVariable(pvCtx, i + 1) = nbInputArgument(pvCtx) + i + 1;
}
ReturnArguments(pvCtx);
return 0;
}
closeHDF5File(iFile);
//1st Lhs
char** pstVarName = (char**)MALLOC(sizeof(char*) * iNbItem);
for (int i = 0 ; i < iNbItem ; i++)
{
pstVarName[i] = pInfo[i].varName;
}
sciErr = createMatrixOfString(pvCtx, nbInputArgument(pvCtx) + 1, iNbItem, 1, pstVarName);
FREE(pstVarName);
if (sciErr.iErr)
{
FREE(pInfo);
printError(&sciErr, 0);
return 1;
}
AssignOutputVariable(pvCtx, 1) = nbInputArgument(pvCtx) + 1;
if (nbOutputArgument(pvCtx) > 1)
{
//2nd Lhs
double* pdblType;
sciErr = allocMatrixOfDouble(pvCtx, nbInputArgument(pvCtx) + 2, iNbItem, 1, &pdblType);
if (sciErr.iErr)
{
FREE(pInfo);
printError(&sciErr, 0);
return 1;
}
for (int i = 0 ; i < iNbItem ; i++)
{
pdblType[i] = pInfo[i].iType;
}
AssignOutputVariable(pvCtx, 2) = nbInputArgument(pvCtx) + 2;
if (nbOutputArgument(pvCtx) > 2)
{
//3rd Lhs
int* pList = NULL;
sciErr = createList(pvCtx, nbInputArgument(pvCtx) + 3, iNbItem, &pList);
for (int i = 0 ; i < iNbItem ; i++)
{
double* pdblDims = NULL;
allocMatrixOfDoubleInList(pvCtx, nbInputArgument(pvCtx) + 3, pList, i + 1, 1, pInfo[i].iDims, &pdblDims);
for (int j = 0 ; j < pInfo[i].iDims ; j++)
{
pdblDims[j] = pInfo[i].piDims[j];
}
}
AssignOutputVariable(pvCtx, 3) = nbInputArgument(pvCtx) + 3;
}
if (nbOutputArgument(pvCtx) > 3)
{
//4th Lhs
double* pdblSize;
sciErr = allocMatrixOfDouble(pvCtx, nbInputArgument(pvCtx) + 4, iNbItem, 1, &pdblSize);
for (int i = 0 ; i < iNbItem ; i++)
{
pdblSize[i] = pInfo[i].iSize;
}
AssignOutputVariable(pvCtx, 4) = nbInputArgument(pvCtx) + 4;
}
}
FREE(pInfo);
ReturnArguments(pvCtx);
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_winqueryreg(char *fname, unsigned long l)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
int *piAddressVarTwo = NULL;
int *piAddressVarThree = NULL;
char *pStrParamOne = NULL;
char *pStrParamTwo = NULL;
char *pStrParamThree = NULL;
char *pStrOutput = NULL;
int iOutput = 0;
Rhs = Max(0, Rhs);
CheckRhs(2, 3);
CheckLhs(0, 1);
if (Rhs == 3)
{
sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
return 0;
}
if (!isStringType(pvApiCtx, piAddressVarThree))
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 3);
return 0;
}
if (!isScalar(pvApiCtx, piAddressVarThree))
{
Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname, 3);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarThree, &pStrParamThree) != 0)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (!isStringType(pvApiCtx, piAddressVarOne))
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
return 0;
}
if (!isScalar(pvApiCtx, piAddressVarOne))
{
Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname, 1);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if (!isStringType(pvApiCtx, piAddressVarTwo))
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 2);
return 0;
}
if (!isScalar(pvApiCtx, piAddressVarTwo))
{
Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname, 2);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarTwo, &pStrParamTwo) != 0)
{
if (pStrParamThree)
{
freeAllocatedSingleString(pStrParamThree);
pStrParamThree = NULL;
}
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &pStrParamOne) != 0)
{
if (pStrParamThree)
{
freeAllocatedSingleString(pStrParamThree);
pStrParamThree = NULL;
}
if (pStrParamTwo)
{
freeAllocatedSingleString(pStrParamTwo);
pStrParamTwo = NULL;
}
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if (Rhs == 3)
{
BOOL bKey = strcmp(pStrParamOne, "key") == 0;
BOOL bValue = strcmp(pStrParamOne, "name") == 0;
if (bValue || bKey)
{
int NumbersElm = 0;
if (bValue)
{
WindowsQueryRegistryNumberOfValuesInList(pStrParamTwo, pStrParamThree, &NumbersElm);
}
else
{
WindowsQueryRegistryNumberOfKeysInList(pStrParamTwo, pStrParamThree, &NumbersElm);
}
if (NumbersElm)
{
BOOL bResult = FALSE;
#define MAX_ELMT_REGLIST 255
char **ListKeysName = NULL;
int i = 0;
if (NumbersElm > MAX_ELMT_REGLIST)
{
NumbersElm = MAX_ELMT_REGLIST;
}
ListKeysName = (char **)MALLOC(sizeof(char*) * NumbersElm);
for (i = 0; i < NumbersElm; i++)
{
ListKeysName[i] = NULL;
}
if (bValue)
{
bResult = WindowsQueryRegistryValuesList(pStrParamTwo, pStrParamThree, NumbersElm, ListKeysName);
}
else
{
bResult = WindowsQueryRegistryKeysList(pStrParamTwo, pStrParamThree, NumbersElm, ListKeysName);
}
if (bResult)
{
int nOne = 1;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, NumbersElm, nOne, ListKeysName);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
else
{
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
}
else
{
Scierror(999, _("%s: Cannot open Windows registry.\n"), fname);
}
freeArrayOfString(ListKeysName, NumbersElm);
}
else
{
createEmptyMatrix(pvApiCtx, Rhs + 1);
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
if (pStrParamThree)
{
freeAllocatedSingleString(pStrParamThree);
pStrParamThree = NULL;
}
if (pStrParamTwo)
{
freeAllocatedSingleString(pStrParamTwo);
pStrParamTwo = NULL;
}
if (pStrParamOne)
{
freeAllocatedSingleString(pStrParamOne);
pStrParamOne = NULL;
}
return 0;
}
}
pStrOutput = (char*)MALLOC(PATH_MAX * sizeof(char));
if (pStrOutput)
{
BOOL OuputIsREG_SZ = FALSE;
BOOL TestWinQuery = WindowsQueryRegistry(pStrParamOne, pStrParamTwo, pStrParamThree, pStrOutput, &iOutput, &OuputIsREG_SZ);
if ( TestWinQuery )
{
if (OuputIsREG_SZ)
{
createSingleString(pvApiCtx, Rhs + 1, pStrOutput);
}
else
{
createScalarDouble(pvApiCtx, Rhs + 1, (double)iOutput);
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else
{
Scierror(999, _("%s: Cannot query value of this type.\n"), fname);
}
FREE( pStrOutput);
pStrOutput = NULL;
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
if (pStrParamThree)
{
freeAllocatedSingleString(pStrParamThree);
pStrParamThree = NULL;
}
if (pStrParamTwo)
{
freeAllocatedSingleString(pStrParamTwo);
pStrParamTwo = NULL;
}
if (pStrParamOne)
{
freeAllocatedSingleString(pStrParamOne);
pStrParamOne = NULL;
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_msprintf(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int iType = 0;
int *piAddressVarOne = NULL;
char *ptrFormat = NULL;
int K = 0;
int i = 0;
int lenghtFormat = 0;
int NumberPercent = 0;
int NumberCols = 0;
int nmax = 0;
int cat_to_last = 0;
int ll = 0;
char **pStrs = NULL;
char **pOutputStrings = NULL;
char *pStrTmp = NULL;
char *pStrTmp1 = NULL;
int lcount = 0;
int rval = 0;
int blk = 200;
int k = 0;
int mOut = 0;
int nOut = 0;
int lenghtSplitChar = (int)strlen(SPLIT_ON_CR_IN_FORMAT);
Nbvars = 0;
CheckRhs(1, 1000);
CheckLhs(0, 1);
for (K = 2; K <= Rhs; K++)
{
int iTypeK = 0;
int *piAddressVarK = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, K, &piAddressVarK);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarK, &iTypeK);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if ( (iTypeK != sci_matrix) && (iTypeK != sci_strings) )
{
OverLoad(K);
return 0;
}
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (checkVarDimension(pvApiCtx, piAddressVarOne, 1, 1) != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &ptrFormat))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if (ptrFormat == NULL)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
else
{
char *ptrFormatTmp = strsub(ptrFormat, CR_IN_FORMAT, SPLIT_ON_CR_IN_FORMAT);
if (ptrFormatTmp)
{
freeAllocatedSingleString(ptrFormat);
ptrFormat = ptrFormatTmp;
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
lenghtFormat = (int)strlen(ptrFormat);
for (i = 0; i < lenghtFormat; i++)
{
if (ptrFormat[i] == PERCENT_CHAR)
{
NumberPercent++;
if ( (i + 1 < lenghtFormat) && (ptrFormat[i + 1] == PERCENT_CHAR))
{
NumberPercent--;
i++;
}
}
}
if ( (Rhs - 1) > NumberPercent )
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: Wrong number of input arguments: at most %d expected.\n"), fname, NumberPercent);
return 0;
}
if ( Rhs > 1 )
{
for ( i = 2 ; i <= Rhs ; i++ )
{
int iRows = 0;
int iCols = 0;
int *piAddressVarI = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddressVarI);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i);
return 0;
}
sciErr = getVarDimension(pvApiCtx, piAddressVarI, &iRows, &iCols);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i);
return 0;
}
NumberCols += iCols;
}
}
if ( NumberCols != NumberPercent )
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: Wrong number of input arguments: data doesn't fit with format.\n"), fname);
return 0;
}
mOut = 0; /* output line counter */
nmax = 0;
pOutputStrings = NULL;
lcount = 1;
cat_to_last = 0;
while (1)
{
if ((rval = do_xxprintf("msprintf", (FILE *) 0, ptrFormat, Rhs, 1, lcount, (char **) &pStrs)) < 0)
{
break;
}
lcount++;
pStrTmp = (char *)pStrs;
if (pStrTmp == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: Wrong value of input argument #%d: data doesn't fit with format.\n"), fname, 1);
return 0;
}
pStrTmp1 = pStrTmp;
while (*pStrTmp != '\0')
{
if (strncmp(pStrTmp, SPLIT_ON_CR_IN_FORMAT, lenghtSplitChar) == 0)
{
k = (int)(pStrTmp - pStrTmp1);
if (!cat_to_last)
{
/*add a new line */
if (mOut == nmax)
{
nmax += blk;
if (pOutputStrings)
{
pOutputStrings = (char **) REALLOC(pOutputStrings, nmax * sizeof(char **));
}
else
{
pOutputStrings = (char **) MALLOC(nmax * sizeof(char **));
}
if (pOutputStrings == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
pOutputStrings[mOut] = (char*)MALLOC((k + 1) * sizeof(char));
if (pOutputStrings[mOut] == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
strncpy(pOutputStrings[mOut], pStrTmp1, k);
pOutputStrings[mOut][k] = EMPTY_CHAR;
mOut++;
}
else
{
/* cat to previous line */
ll = (int)strlen(pOutputStrings[mOut - 1]);
pOutputStrings[mOut - 1] = (char*)REALLOC(pOutputStrings[mOut - 1], (k + 1 + ll) * sizeof(char));
if (pOutputStrings[mOut - 1] == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
strncpy(&(pOutputStrings[mOut - 1][ll]), pStrTmp1, k);
pOutputStrings[mOut - 1][k + ll] = EMPTY_CHAR;
}
k = 0;
pStrTmp += lenghtSplitChar;
pStrTmp1 = pStrTmp;
cat_to_last = 0;
}
else
{
pStrTmp++;
}
}
k = (int)(pStrTmp - pStrTmp1);
if (k > 0)
{
if ((!cat_to_last) || (mOut == 0))
{
/*add a new line */
if (mOut == nmax)
{
nmax += blk;
if (pOutputStrings)
{
pOutputStrings = (char **) REALLOC(pOutputStrings, nmax * sizeof(char **));
if (pOutputStrings == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
else
{
pOutputStrings = (char **) MALLOC(nmax * sizeof(char **));
if (pOutputStrings == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
}
pOutputStrings[mOut] = (char*) MALLOC((k + 1) * sizeof(char));
if (pOutputStrings[mOut] == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
strncpy(pOutputStrings[mOut], pStrTmp1, k);
pOutputStrings[mOut][k] = EMPTY_CHAR;
mOut++;
}
else
{
/* cat to previous line */
ll = (int)strlen(pOutputStrings[mOut - 1]);
pOutputStrings[mOut - 1] = (char*)REALLOC(pOutputStrings[mOut - 1], (k + 1 + ll) * sizeof(char));
if (pOutputStrings[mOut - 1] == NULL)
{
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
strncpy(&(pOutputStrings[mOut - 1][ll]), pStrTmp1, k);
pOutputStrings[mOut - 1][k + ll] = EMPTY_CHAR;
}
}
if (strncmp(pStrTmp - lenghtSplitChar, SPLIT_ON_CR_IN_FORMAT, lenghtSplitChar) != 0)
{
cat_to_last = 1;
}
if (Rhs == 1) break;
}
if (ptrFormat)
{
FREE(ptrFormat);
ptrFormat = NULL;
}
if (rval == RET_BUG) return 0;
/* Create a Scilab String */
nOut = 1;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1 , mOut, nOut, pOutputStrings);
/* lstr must not be freed */
freeArrayOfString(pOutputStrings, mOut * nOut);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
else
{
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
return 0;
}
/* Return text of fftw wisdom
*
* Scilab Calling sequence :
* -->tt=get_fftw_wisdom();
*
* Input : Nothing
*
* Output : a scilab string matrix
*
*/
int sci_get_fftw_wisdom(char *fname, void* pvApiCtx)
{
int n1 = 0, i = 0, j = 0;
char *Str = NULL;
char **Str1 = NULL;
CheckInputArgument(pvApiCtx, 0, 0);
CheckOutputArgument(pvApiCtx, 0, 1);
if ((Str = call_fftw_export_wisdom_to_string()) == NULL)
{
Scierror(999, _("%s: MKL fftw library does not implement wisdom functions yet.\n"), fname);
return 1;
}
n1 = 0;
j = 0;
if (Str)
{
int lenStr = (int)strlen(Str);
for (i = 0; i < lenStr; i++)
{
if (Str[i] == '\n')
{
int len = 0;
int k = 0;
n1++;
if (Str1)
{
Str1 = (char **)REALLOC(Str1, sizeof(char *) * n1);
}
else
{
Str1 = (char **)MALLOC(sizeof(char *) * n1);
}
if (Str1 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), fname);
if (Str)
{
// According to the FFTW documentation we should free Str
// string but doing makes Scilab crash!?
//free(Str);
}
return 1;
}
len = i - j;
if ((Str1[n1 - 1] = (char *)MALLOC(sizeof(char) * (len + 1))) == NULL)
{
freeArrayOfString(Str1, n1 - 1);
if (Str)
{
// According to the FFTW documentation we should free Str
// string but doing makes Scilab crash!?
//free(Str);
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
}
for (k = 0; k < len; k++)
{
Str1[n1 - 1][k] = Str[k + j];
}
Str1[n1 - 1][len] = '\0';
j = i + 1;
}
}
}
n1++;
if (Str1)
{
Str1 = (char **)REALLOC(Str1, sizeof(char *) * n1);
}
else
{
Str1 = (char **)MALLOC(sizeof(char *) * n1);
}
if (Str1 == NULL)
{
Scierror(999, _("%s: No more memory.\n"), fname);
if (Str)
{
// According to the FFTW documentation we should free Str
// string but doing makes Scilab crash!?
//free(Str);
}
return 1;
}
if ((Str1[n1 - 1] = (char *)MALLOC(sizeof(char))) == NULL)
{
freeArrayOfString(Str1, n1 - 1);
if (Str)
{
// According to the FFTW documentation we should free Str
// string but doing makes Scilab crash!?
//free(Str);
}
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
}
Str1[n1 - 1][0] = '\0';
createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, n1, 1, Str1);
freeArrayOfString(Str1, n1);
if (Str)
{
// According to the FFTW documentation we should free Str
// string but doing makes Scilab crash!?
//free(Str);
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
void H5Group::getAccessibleAttribute(const std::string & _name, const int pos, void * pvApiCtx) const
{
SciErr err;
std::string lower(_name);
std::transform(_name.begin(), _name.end(), lower.begin(), tolower);
if (lower == "attributes")
{
std::vector<std::string> names;
getNames(*this, names, ATTRIBUTE);
H5BasicData<char>::putStringVectorOnStack(names, (int)names.size(), 1, pos, pvApiCtx);
return;
}
else if (lower == "groups")
{
std::vector<std::string> names;
getNames(*this, names, GROUP);
H5BasicData<char>::putStringVectorOnStack(names, (int)names.size(), 1, pos, pvApiCtx);
return;
}
else if (lower == "datasets")
{
std::vector<std::string> names;
getNames(*this, names, DATASET);
H5BasicData<char>::putStringVectorOnStack(names, (int)names.size(), 1, pos, pvApiCtx);
return;
}
else if (lower == "types")
{
std::vector<std::string> names;
getNames(*this, names, TYPE);
H5BasicData<char>::putStringVectorOnStack(names, (int)names.size(), 1, pos, pvApiCtx);
return;
}
else if (lower == "externals")
{
std::vector<std::string> names;
getNames(*this, names, EXTERNAL);
H5BasicData<char>::putStringVectorOnStack(names, (int)names.size(), 1, pos, pvApiCtx);
return;
}
else if (lower == "softs")
{
std::vector<std::string> names;
getNames(*this, names, SOFT);
H5BasicData<char>::putStringVectorOnStack(names, (int)names.size(), 1, pos, pvApiCtx);
return;
}
else if (lower == "danglings")
{
std::vector<std::string> names;
getNames(*this, names, DANGLING);
H5BasicData<char>::putStringVectorOnStack(names, (int)names.size(), 1, pos, pvApiCtx);
return;
}
else if (lower == "hards")
{
std::vector<std::string> names;
getNames(*this, names, HARD);
H5BasicData<char>::putStringVectorOnStack(names, (int)names.size(), 1, pos, pvApiCtx);
return;
}
else if (lower == "links")
{
std::vector<std::string> names;
std::vector<std::string> types;
std::vector<std::string> linkstype;
std::vector<const char *> _str;
H5Object::getLinksInfo(*this, names, types, linkstype);
_str.reserve(names.size() * 3);
for (unsigned int i = 0; i < names.size(); i++)
{
_str.push_back(names[i].c_str());
}
for (unsigned int i = 0; i < names.size(); i++)
{
_str.push_back(linkstype[i].c_str());
}
for (unsigned int i = 0; i < names.size(); i++)
{
_str.push_back(types[i].c_str());
}
err = createMatrixOfString(pvApiCtx, pos, (int)names.size(), 3, &(_str[0]));
if (err.iErr)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot create a column of strings on the stack."));
}
return;
}
else
{
try
{
H5Object & obj = H5Object::getObject(*const_cast<H5Group *>(this), _name);
obj.createOnScilabStack(pos, pvApiCtx);
return;
}
catch (const H5Exception & /*e*/) { }
}
H5Object::getAccessibleAttribute(_name, pos, pvApiCtx);
}
/*--------------------------------------------------------------------------*/
int C2F(sci_predef)(char *fname,unsigned long fname_len)
{
int previous_n_var_protected = 0;
Rhs = Max(0, Rhs);
CheckRhs(0,1);
CheckLhs(0,1);
previous_n_var_protected = getNumberPredefVariablesProtected();
if (Rhs == 0)
{
int one = 1 ,l = 0;
CreateVar(Rhs+1, MATRIX_OF_INTEGER_DATATYPE, &one, &one,&l);
*istk(l) = (int) previous_n_var_protected;
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
else /* Rhs == 1 */
{
int *out_values = NULL;
int nout = 0 , mout = 0;
int new_n_var_protected = 0;
if ( VarType(1) == sci_matrix )
{
int m1 = 0, n1 = 0, l1 = 0;
GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
if ( (m1 == n1) && (n1 == 1) )
{
double dn_var = *stk(l1);
int n_var = (int) dn_var;
if (dn_var != (double)n_var)
{
Scierror(999,_("%s: Wrong value for input argument #%d: A int expected.\n"),fname,1);
return 0;
}
setNumberPredefVariablesProtected(n_var);
}
else
{
Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname,1);
return 0;
}
}
else if ( VarType(1) == sci_strings )
{
int m1 = 0, n1 = 0, l1 = 0;
char *protectMode = NULL;
GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
protectMode = cstk(l1);
if (protectMode)
{
if ( ((strlen(protectMode) == 1 ) && (protectMode[0] == 'c')) ||
(strcmp(protectMode,"clear") == 0) )
{
clearPredef();
}
else if ( ((strlen(protectMode) == 1 ) && (protectMode[0] == 'a')) ||
(strcmp(protectMode,"all") == 0) )
{
predefAll();
}
else if (strcmp(protectMode,"names") == 0)
{
int nbElements = 0;
char **variablesPredef = getPredefinedVariablesName(&nbElements);
if (variablesPredef && (nbElements > 0))
{
SciErr sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, nbElements, 1, variablesPredef);
freeArrayOfString(variablesPredef, nbElements);
variablesPredef = NULL;
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999,_("%s: Memory allocation error.\n"), fname);
}
else
{
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
return 0;
}
else
{
createEmptyMatrix(pvApiCtx, Rhs + 1);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
}
else
{
Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"),fname,1,"clear","all");
return 0;
}
}
}
else
{
Scierror(999,_("%s: Wrong type for input argument #%d: A scalar or a string expected.\n"),fname,1);
return 0;
}
new_n_var_protected = getNumberPredefVariablesProtected();
out_values = (int*)MALLOC(sizeof(int)*2);
out_values[0] = previous_n_var_protected;
out_values[1] = new_n_var_protected;
nout = 1 ; mout = 2;
CreateVarFromPtr(Rhs+1,MATRIX_OF_INTEGER_DATATYPE, &nout, &mout, &out_values);
if (out_values) {FREE(out_values); out_values = NULL;}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_gettext(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
char* pstDomain = NULL;
char **TranslatedStrings = NULL;
int m = 0;
int n = 0;
char **StringsToTranslate = NULL;
int i = 0;
int iCurrentRhs = 1;
int iRhs = nbInputArgument(pvApiCtx);
int iLhs = nbOutputArgument(pvApiCtx);
CheckInputArgument(pvApiCtx, 1, 2);
CheckOutputArgument(pvApiCtx, 0, 1);
if (iRhs == 2)
{
//get domain name
sciErr = getVarAddressFromPosition(pvApiCtx, iCurrentRhs, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iCurrentRhs);
}
if (isStringType(pvApiCtx, piAddressVarOne) == 0 || isScalar(pvApiCtx, piAddressVarOne) == 0)
{
Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname, iCurrentRhs);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &pstDomain))
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
iCurrentRhs++;
}
sciErr = getVarAddressFromPosition(pvApiCtx, iCurrentRhs, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, iCurrentRhs);
}
if (isStringType(pvApiCtx, piAddressVarOne) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
freeAllocatedSingleString(pstDomain);
return 0;
}
if (getAllocatedMatrixOfString(pvApiCtx, piAddressVarOne, &m, &n, &StringsToTranslate) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
freeAllocatedSingleString(pstDomain);
return 0;
}
TranslatedStrings = (char **)MALLOC(sizeof(char*) * (m * n));
if (TranslatedStrings == NULL)
{
Scierror(999, _("%s: No more memory.\n"), fname);
freeAllocatedSingleString(pstDomain);
freeAllocatedMatrixOfString(m, n, StringsToTranslate);
StringsToTranslate = NULL;
return 0;
}
for (i = 0; i < m * n; i++)
{
if (strcmp(StringsToTranslate[i], "") == 0)
{
TranslatedStrings[i] = strdup("");
}
else
{
//if pstDomain is NULL, default domain will be use
TranslatedStrings[i] = convertString_dgettext(pstDomain, StringsToTranslate[i]);
}
}
freeAllocatedSingleString(pstDomain);
freeAllocatedMatrixOfString(m, n, StringsToTranslate);
StringsToTranslate = NULL;
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, m, n, TranslatedStrings);
freeArrayOfString(TranslatedStrings, m * n);
TranslatedStrings = NULL;
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_getinstalledlookandfeels(char *fname, unsigned long fname_len)
{
SciErr sciErr;
CheckInputArgument(pvApiCtx, 0, 0);
CheckOutputArgument(pvApiCtx, 1, 1);
org_scilab_modules_gui_utils::LookAndFeelManager * lnf = 0;
try
{
lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
}
catch (const GiwsException::JniException & e)
{
Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
return 1;
}
if (lnf)
{
char **lookandfeels = NULL;
int nbElems = 0;
int nbCol = 0;
lookandfeels = lnf->getInstalledLookAndFeels();
nbElems = lnf->numbersOfInstalledLookAndFeels();
nbCol = 1;
sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbElems, nbCol, lookandfeels);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
if (lookandfeels)
{
int i = 0;
for (i = 0; i < nbElems; i++)
{
if (lookandfeels[i])
{
delete[]lookandfeels[i];
}
}
delete[]lookandfeels;
lookandfeels = NULL;
}
delete lnf;
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
returnArguments(pvApiCtx);
}
else
{
Scierror(999, _("%s: No more memory.\n"), fname);
}
return 0;
}
// =============================================================================
int sci_csvTextScan(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int iErr = 0;
int i = 0;
int *piAddressVarOne = NULL;
int m1 = 0, n1 = 0;
int iType1 = 0;
char **text = NULL;
int *lengthText = NULL;
int nbLines = 0;
char *separator = NULL;
char *decimal = NULL;
char *conversion = NULL;
double * dRealValues = NULL;
int *iRange = NULL;
int haveRange = 0;
csvResult *result = NULL;
CheckRhs(1, 5);
CheckLhs(1, 1);
if (Rhs == 5)
{
int m5 = 0, n5 = 0;
iRange = csv_getArgumentAsMatrixofIntFromDouble(pvApiCtx, 5, fname, &m5, &n5, &iErr);
if (iErr)
{
return 0;
}
if ((m5 * n5 != SIZE_RANGE_SUPPORTED) )
{
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
Scierror(999, _("%s: Wrong size for input argument #%d: Four entries expected.\n"), fname, 5);
return 0;
}
if ((m5 != 1) && (n5 != 1))
{
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
Scierror(999, _("%s: Wrong size for input argument #%d: A column or row vector expected.\n"), fname, 5);
return 0;
}
if (isValidRange(iRange, m5 * n5))
{
haveRange = 1;
}
else
{
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
Scierror(999, _("%s: Wrong value for input argument #%d: Inconsistent range.\n"), fname, 5);
return 0;
}
}
if (Rhs >= 4)
{
conversion = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 4, fname, getCsvDefaultConversion(), &iErr);
if (iErr)
{
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
return 0;
}
if (!((strcmp(conversion, CONVTOSTR) == 0) || (strcmp(conversion, CONVTODOUBLE) == 0)))
{
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
if (conversion)
{
FREE(conversion);
conversion = NULL;
}
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' string expected.\n"), fname, 4, "double", "string");
return 0;
}
}
else
{
conversion = strdup(getCsvDefaultConversion());
}
if (Rhs >= 3)
{
decimal = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 3, fname, getCsvDefaultDecimal(), &iErr);
if (iErr)
{
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
if (conversion)
{
FREE(conversion);
conversion = NULL;
}
return 0;
}
if (decimal[0] != '.' && decimal[0] != ',')
{
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
if (conversion)
{
FREE(conversion);
conversion = NULL;
}
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' string expected.\n"), fname, 3, ",", ".");
return 0;
}
}
else
{
decimal = strdup(getCsvDefaultDecimal());
}
if (Rhs >= 2)
{
separator = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 2, fname, getCsvDefaultSeparator(), &iErr);
if (iErr)
{
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
if (decimal)
{
FREE(decimal);
decimal = NULL;
}
if (conversion)
{
FREE(conversion);
conversion = NULL;
}
return 0;
}
}
else
{
separator = strdup(getCsvDefaultSeparator());
}
if (!csv_isRowVector(pvApiCtx, 1) &&
!csv_isColumnVector(pvApiCtx, 1) &&
!csv_isScalar(pvApiCtx, 1))
{
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
if (separator)
{
FREE(separator);
separator = NULL;
}
if (decimal)
{
FREE(decimal);
decimal = NULL;
}
if (conversion)
{
FREE(conversion);
conversion = NULL;
}
Scierror(999, _("%s: Wrong size for input argument #%d: Vector string expected.\n"), fname, 1);
return 0;
}
text = csv_getArgumentAsMatrixOfString(pvApiCtx, 1, fname, &m1, &n1, &iErr);
if (iErr)
{
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
if (separator)
{
FREE(separator);
separator = NULL;
}
if (decimal)
{
FREE(decimal);
decimal = NULL;
}
if (conversion)
{
FREE(conversion);
conversion = NULL;
}
return 0;
}
nbLines = m1 * n1;
result = csvTextScan((const char**)text, nbLines, separator, decimal);
if (text)
{
if (separator)
{
FREE(separator);
separator = NULL;
}
freeArrayOfString(text, nbLines);
text = NULL;
}
if (separator)
{
FREE(separator);
separator = NULL;
}
if (result)
{
switch (result->err)
{
case CSV_READ_SEPARATOR_DECIMAL_EQUAL:
{
Scierror(999, _("%s: separator and decimal must have different values.\n"), fname);
}
break;
case CSV_READ_NO_ERROR:
{
if (strcmp(conversion, CONVTOSTR) == 0)
{
if (haveRange)
{
int newM = 0;
int newN = 0;
char **pStrRange = getRangeAsString((const char**)result->pstrValues, result->m, result->n, iRange, &newM, &newN);
if (pStrRange)
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, newM, newN, pStrRange);
freeArrayOfString(pStrRange, newM * newN);
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
}
else
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, result->m, result->n, result->pstrValues);
}
}
else /* to double */
{
stringToComplexError ierr = STRINGTOCOMPLEX_ERROR;
csv_complexArray *ptrCsvComplexArray = stringsToCsvComplexArray((const char**)result->pstrValues, result->m * result->n, decimal, TRUE, &ierr);
if (ptrCsvComplexArray == NULL)
{
freeCsvResult(result);
if (decimal)
{
FREE(decimal);
decimal = NULL;
}
if (conversion)
{
FREE(conversion);
conversion = NULL;
}
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
if (ierr == STRINGTOCOMPLEX_ERROR)
{
Scierror(999, _("%s: can not convert data.\n"), fname);
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
return 0;
}
switch (ierr)
{
case STRINGTOCOMPLEX_NOT_A_NUMBER:
case STRINGTOCOMPLEX_NO_ERROR:
{
if (haveRange)
{
int newM = 0;
int newN = 0;
csv_complexArray *csvComplexRange = getRangeAsCsvComplexArray(ptrCsvComplexArray, result->m, result->n, iRange, &newM, &newN);
if (csvComplexRange)
{
if (csvComplexRange->isComplex)
{
sciErr = createComplexMatrixOfDouble(pvApiCtx, Rhs + 1, newM, newN, ptrCsvComplexArray->realPart, ptrCsvComplexArray->imagPart);
}
else
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, newM, newN, csvComplexRange->realPart);
}
freeCsvComplexArray(csvComplexRange);
csvComplexRange = NULL;
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
}
else
{
if (ptrCsvComplexArray->isComplex)
{
sciErr = createComplexMatrixOfDouble(pvApiCtx, Rhs + 1, result->m, result->n, ptrCsvComplexArray->realPart, ptrCsvComplexArray->imagPart);
}
else
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, result->m, result->n, ptrCsvComplexArray->realPart);
}
}
freeCsvComplexArray(ptrCsvComplexArray);
ptrCsvComplexArray = NULL;
}
break;
case STRINGTOCOMPLEX_MEMORY_ALLOCATION:
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
default:
case STRINGTOCOMPLEX_ERROR:
{
Scierror(999, _("%s: can not convert data.\n"), fname);
}
}
}
if (sciErr.iErr)
{
freeCsvResult(result);
if (decimal)
{
FREE(decimal);
decimal = NULL;
}
if (conversion)
{
FREE(conversion);
conversion = NULL;
}
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
printError(&sciErr, 0);
Scierror(17, _("%s: Memory allocation error.\n"), fname);
return 0;
}
else
{
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
}
break;
case CSV_READ_MEMORY_ALLOCATION:
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
break;
case CSV_READ_COLUMNS_ERROR:
{
Scierror(999, _("%s: can not read text: Error in the column structure\n"), fname);
}
break;
case CSV_READ_READLINES_ERROR:
case CSV_READ_ERROR:
{
Scierror(999, _("%s: can not read text.\n"), fname);
}
break;
}
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeCsvResult(result);
if (decimal)
{
FREE(decimal);
decimal = NULL;
}
if (conversion)
{
FREE(conversion);
conversion = NULL;
}
if (iRange)
{
FREE(iRange);
iRange = NULL;
}
return 0;
}
