/*--------------------------------------------------------------------------*/
int sci_getcallbackobject(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int* piAddrpObjUID = NULL;
int nbRow = 0;
int nbCol = 0;
double ObjUID = 0;
unsigned long graphicHandle = 0;
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 0, 1);
if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrpObjUID);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 1.
if (getScalarDouble(pvApiCtx, piAddrpObjUID, &ObjUID))
{
Scierror(202, _("%s: Wrong type for argument #%d: Real expected.\n"), fname, 1);
return 1;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
return FALSE;
}
graphicHandle = getHandle((int)ObjUID);
/* Create return variable */
if (graphicHandle == 0) /* Non-existing object --> return [] */
{
if (createEmptyMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1))
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
else /* Return the handle */
{
if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, graphicHandle))
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return TRUE;
}
/*--------------------------------------------------------------------------*/
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 C2F(sci_lasterror)(char *fname,unsigned long fname_len)
{
SciErr sciErr;
BOOL bClearLastError = TRUE;
int NbLines = 0;
const char **errorMessage = NULL;
Rhs = Max(0, Rhs);
CheckRhs(0,1);
CheckLhs(1,4);
if (Rhs == 1)
{
int *piAddressVarOne = NULL;
/* get Address of inputs */
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 (isBooleanType(pvApiCtx, piAddressVarOne))
{
if (isScalar(pvApiCtx, piAddressVarOne))
{
getScalarBoolean(pvApiCtx, piAddressVarOne, &bClearLastError);
}
else
{
Scierror(999,_("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 1);
}
}
else
{
Scierror(999,_("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 1);
}
}
errorMessage = getLastErrorMessage(&NbLines);
if ((NbLines <= 0) || (errorMessage == NULL))
{
createEmptyMatrix(pvApiCtx, Rhs + 1);
}
else
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, NbLines, 1, (char**)errorMessage);
if(sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999,_("%s: Memory allocation error.\n"), fname);
return 0;
}
}
LhsVar(1) = Rhs + 1;
if (Lhs >= 2)
{
double dLastErrorValue = (double) getLastErrorValue();
createScalarDouble(pvApiCtx, Rhs + 2, dLastErrorValue);
LhsVar(2) = Rhs + 2;
}
if (Lhs >= 3)
{
double dLinePosition = (double) getLastErrorLinePosition();
createScalarDouble(pvApiCtx, Rhs + 3, dLinePosition);
LhsVar(3) = Rhs + 3;
}
if (Lhs == 4)
{
createSingleString(pvApiCtx, Rhs + 4, (char*)getLastErrorFunctionName());
LhsVar(4) = Rhs + 4;
}
if (bClearLastError)
{
clearLastError();
}
PutLhsVar();
return 0;
}
/* ==================================================================== */
int sci_csvRead(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int iErr = 0;
int iErrEmpty = 0;
char *filename = NULL;
char *separator = NULL;
char *decimal = NULL;
char *conversion = NULL;
int *iRange = NULL;
int haveRange = 0;
int header = 0;
char **toreplace = NULL;
int nbElementsToReplace = 0;
char *regexp = NULL;
int haveRegexp = 0;
csvResult *result = NULL;
double *dRealValues = NULL;
sciErr.iErr = 0;
CheckRhs(1, 8);
CheckLhs(1, 2);
if (Rhs == 8)
{
header = (int) csv_getArgumentAsScalarDouble(pvApiCtx, 8, fname, &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
return 0;
}
}
if (Rhs == 7)
{
int m7 = 0, n7 = 0;
iRange = csv_getArgumentAsMatrixofIntFromDouble(pvApiCtx, 7, fname, &m7, &n7, &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
return 0;
}
if ((m7 * n7 != SIZE_RANGE_SUPPORTED) )
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
Scierror(999, _("%s: Wrong size for input argument #%d: Four entries expected.\n"), fname, 7);
return 0;
}
if ((m7 != 1) && (n7 != 1))
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
Scierror(999, _("%s: Wrong size for input argument #%d: A column or row vector expected.\n"), fname, 7);
return 0;
}
if (isValidRange(iRange, m7 * n7))
{
haveRange = 1;
}
else
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
Scierror(999, _("%s: Wrong value for input argument #%d: Inconsistent range.\n"), fname, 7);
return 0;
}
}
if (Rhs >= 6)
{
regexp = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 6, fname, getCsvDefaultCommentsRegExp(), &iErr);
if (regexp)
{
if (strcmp(regexp, "") == 0)
{
FREE(regexp);
regexp = NULL;
}
else
{
haveRegexp = 1;
}
}
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, 0, ®exp);
return 0;
}
}
else
{
regexp = strdup(getCsvDefaultCommentsRegExp());
if (regexp)
{
if (strcmp(regexp, "") == 0)
{
FREE(regexp);
regexp = NULL;
}
}
}
if (Rhs >= 5)
{
if (csv_isEmpty(pvApiCtx, 5))
{
toreplace = NULL;
nbElementsToReplace = 0;
}
else
{
int m5 = 0, n5 = 0;
toreplace = csv_getArgumentAsMatrixOfString(pvApiCtx, 5, fname, &m5, &n5, &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, m5 * n5, ®exp);
return 0;
}
if (n5 != 2)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, m5 * n5, ®exp);
Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, 5);
return 0;
}
nbElementsToReplace = m5;
}
}
else
{
toreplace = NULL;
nbElementsToReplace = 0;
}
if (Rhs >= 4)
{
int iErr = 0;
conversion = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 4, fname, getCsvDefaultConversion(), &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
if (!((strcmp(conversion, CONVTOSTR) == 0) || (strcmp(conversion, CONVTODOUBLE) == 0)))
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' string expected.\n"), fname, 4, "double", "string");
return 0;
}
}
else
{
/* read_csv is using a 'string' conversion while csvRead is doing
a 'double' conversion */
if (strcmp(fname, "read_csv") == 0)
{
conversion = (char*)MALLOC((strlen("string") + 1) * sizeof(char));
strcpy(conversion, "string");
}
else
{
conversion = strdup(getCsvDefaultConversion());
}
}
if (Rhs >= 3)
{
int iErr = 0;
decimal = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 3, fname, getCsvDefaultDecimal(), &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
}
else
{
decimal = strdup(getCsvDefaultDecimal());
}
if (Rhs >= 2)
{
int iErr = 0;
separator = csv_getArgumentAsStringWithEmptyManagement(pvApiCtx, 2, fname, getCsvDefaultSeparator(), &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
}
else
{
separator = strdup(getCsvDefaultSeparator());
}
if (strcmp(separator, "\\t") == 0)
{
/* In Scilab, if the user is providing \t as separator, transform it to a real
tab. Example: read_csv(filename,"\t");
*/
strcpy(separator, "\t");
}
filename = csv_getArgumentAsString(pvApiCtx, 1, fname, &iErr);
if (iErr)
{
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
result = csvRead(filename, separator, decimal, (const char**)toreplace, nbElementsToReplace * 2, regexp, header);
freeVar(NULL, &separator, &decimal, NULL, NULL, &toreplace, nbElementsToReplace, ®exp);
if (result)
{
switch (result->err)
{
case CSV_READ_REGEXP_ERROR:
{
Scierror(999, _("%s: Wrong value for input argument #%d.\n"), fname, 6);
}
break;
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
{
if ((newM == 0) || (newN == 0))
{
Scierror(999, _("%s: Range row or/and column left indice(s) out of bounds.\n"), fname);
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
}
else
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, result->m, result->n, result->pstrValues);
}
}
else /* to double */
{
stringToComplexError ierr = STRINGTOCOMPLEX_ERROR;
complexArray *ptrComplexArray = stringsToComplexArray((const char**)result->pstrValues, result->m * result->n, decimal, TRUE, &ierr);
if (ptrComplexArray == NULL)
{
freeCsvResult(result);
if (ierr == STRINGTOCOMPLEX_ERROR)
{
Scierror(999, _("%s: can not convert data.\n"), fname);
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
switch (ierr)
{
case STRINGTOCOMPLEX_NOT_A_NUMBER:
case STRINGTOCOMPLEX_NO_ERROR:
{
if (haveRange)
{
int newM = 0;
int newN = 0;
complexArray *complexRange = getRangeAsComplexArray(ptrComplexArray, result->m, result->n, iRange, &newM, &newN);
if (complexRange)
{
if (complexRange->isComplex)
{
sciErr = createComplexMatrixOfDouble(pvApiCtx, Rhs + 1, newM, newN, ptrComplexArray->realPart, ptrComplexArray->imagPart);
}
else
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, newM, newN, complexRange->realPart);
}
freeComplexArray(complexRange);
complexRange = NULL;
}
else
{
if ((newM == 0) || (newN == 0))
{
Scierror(999, _("%s: Range row or/and column left indice(s) out of bounds.\n"), fname);
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
}
else
{
if (ptrComplexArray->isComplex)
{
sciErr = createComplexMatrixOfDouble(pvApiCtx, Rhs + 1, result->m, result->n, ptrComplexArray->realPart, ptrComplexArray->imagPart);
}
else
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, result->m, result->n, ptrComplexArray->realPart);
}
freeComplexArray(ptrComplexArray);
ptrComplexArray = NULL;
}
}
break;
case STRINGTOCOMPLEX_MEMORY_ALLOCATION:
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
default:
case STRINGTOCOMPLEX_ERROR:
{
Scierror(999, _("%s: can not convert data.\n"), fname);
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
}
}
if (sciErr.iErr)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
else
{
LhsVar(1) = Rhs + 1;
if (Lhs == 2)
{
if (haveRegexp == 0)
{
char **emptyStringMatrix = NULL;
emptyStringMatrix = (char**) malloc(sizeof(char*));
emptyStringMatrix[0] = "";
sciErr = createMatrixOfString(pvApiCtx, Rhs + 2, 1, 1, emptyStringMatrix);
free(emptyStringMatrix);
}
else
{
if (result->nbComments > 0)
{
sciErr = createMatrixOfString(pvApiCtx, Rhs + 2, result->nbComments, 1, result->pstrComments);
}
else
{
iErrEmpty = createEmptyMatrix(pvApiCtx, Rhs+2);
sciErr.iErr = iErrEmpty;
}
}
if (sciErr.iErr)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
return 0;
}
LhsVar(2) = Rhs + 2;
}
PutLhsVar();
}
}
break;
case CSV_READ_FILE_NOT_EXIST:
{
Scierror(999, _("%s: %s does not exist.\n"), fname, filename);
}
break;
case CSV_READ_MOPEN_ERROR:
{
Scierror(999, _("%s: can not open file %s.\n"), fname, filename);
}
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 file %s: Error in the column structure\n"), fname, filename);
}
break;
case CSV_READ_READLINES_ERROR:
case CSV_READ_ERROR:
{
Scierror(999, _("%s: can not read file %s.\n"), fname, filename);
}
break;
}
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
}
freeCsvResult(result);
freeVar(&filename, &separator, &decimal, &conversion, &iRange, &toreplace, nbElementsToReplace, ®exp);
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;
}
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_hdf5_load_v1(char *fn, int* pvApiCtx)
{
SciErr sciErr;
int* piAddr = NULL;
char* pstFilename = NULL;
char* pstExpandedFilename = NULL;
bool bImport = true;
const int nbIn = Rhs;
int iSelectedVar = Rhs - 1;
CheckInputArgumentAtLeast(pvApiCtx, 1);
CheckOutputArgument(pvApiCtx, 1, 1);
iCloseList = 0;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFilename))
{
if (pstFilename)
{
FREE(pstFilename);
}
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), 2);
return 1;
}
//open hdf5 file
pstExpandedFilename = expandPathVariable(pstFilename);
int iFile = openHDF5File(pstExpandedFilename, 0);
if (iFile < 0)
{
FREE(pstExpandedFilename);
Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), pstFilename);
FREE(pstFilename);
return 1;
}
FREE(pstExpandedFilename);
FREE(pstFilename);
std::vector<wchar_t*> varList;
if (iSelectedVar)
{
//selected variable
char* pstVarName = NULL;
for (int i = 0 ; i < iSelectedVar ; i++)
{
sciErr = getVarAddressFromPosition(pvApiCtx, i + 2, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))
{
if (pstVarName)
{
FREE(pstVarName);
}
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), i + 1);
return 1;
}
if (import_variable_v1(pvApiCtx, iFile, pstVarName) == false)
{
FREE(pstVarName);
bImport = false;
break;
}
varList.push_back(to_wide_string(pstVarName));
FREE(pstVarName);
pstVarName = NULL;
}
}
else
{
//all variables
int iNbItem = 0;
iNbItem = getVariableNames_v1(iFile, NULL);
if (iNbItem != 0)
{
char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
iNbItem = getVariableNames_v1(iFile, pstVarNameList);
//import all data
for (int i = 0; i < iNbItem; i++)
{
if (import_variable_v1(pvApiCtx, iFile, pstVarNameList[i]) == false)
{
bImport = false;
break;
}
varList.push_back(to_wide_string(pstVarNameList[i]));
}
freeArrayOfString(pstVarNameList, iNbItem);
}
}
//close the file
closeHDF5File(iFile);
if (bImport == true && varList.size() != 0)
{
createMatrixOfWideString(pvApiCtx, nbIn + 1, 1, static_cast<int>(varList.size()), varList.data());
}
else
{
createEmptyMatrix(pvApiCtx, nbIn + 1);
}
for (auto & i : varList)
{
FREE(i);
}
AssignOutputVariable(pvApiCtx, 1) = nbIn + 1;
ReturnArguments(pvApiCtx);
// printf("End gateway !!!\n");
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_archive_compress(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
char *pStVarOne = NULL;
char *pStVarOneExpanded = NULL;
int *piAddressVarTwo = NULL;
char **pStVarTwo = NULL;
int m1 = 0;
int n1 = 0;
int i = 0;
int *piAddressVarThree = NULL;
char *pStVarThree = NULL;
char **file_list = NULL;
/* Check Input & Output parameters */
CheckRhs(3, 3);
CheckLhs(1, 2);
int result = 0;
int *error = 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) == 0 || isScalar(pvApiCtx, piAddressVarOne) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A 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, 1);
return 0;
}
if (isDoubleType(pvApiCtx, piAddressVarTwo))
{
if (isEmptyMatrix(pvApiCtx, piAddressVarTwo))
{
if (createEmptyMatrix(pvApiCtx, Rhs + 2))
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: String array expected.\n"), fname, 1);
return 0;
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
if (isStringType(pvApiCtx, piAddressVarTwo) == 0)
{
Scierror(999, _("%s: Wrong type for input argument #%d: String array expected.\n"), fname, 2);
return 0;
}
if (getAllocatedMatrixOfString(pvApiCtx, piAddressVarTwo, &m1, &n1, &pStVarTwo))
{
freeAllocatedMatrixOfString(m1, n1, pStVarTwo);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 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: A string expected.\n"), fname, 3);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &pStVarOne))
{
if (pStVarOne)
{
freeAllocatedSingleWideString(pStVarOne);
}
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
if (getAllocatedSingleString(pvApiCtx, piAddressVarThree, &pStVarThree))
{
if (pStVarThree)
{
freeAllocatedSingleWideString(pStVarThree);
}
freeAllocatedSingleString(pStVarOne);
freeAllocatedSingleString(pStVarTwo);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
int size = 0;
while(i < (m1*n1))
{
size++;
if(file_list!=NULL)
{
file_list = (char**)REALLOC(file_list,sizeof(char*)*(size));
}
else
{
file_list = (char**)MALLOC(sizeof(char*)*(size));
}
file_list[size-1] = (char*)MALLOC(sizeof(char)*512);
strcpy(file_list[size-1],expandPathVariable(pStVarTwo[i]));
i++;
}
i = 0;
if(strlen(pStVarThree)>2)
{
Scierror(999, _("%s: Sorry unrecognised format type.\n"), fname);
return 0;
}
while(i<strlen(pStVarThree))
{
if(pStVarThree[i]!='Z' && pStVarThree[i]!='j' && pStVarThree[i]!='y' && pStVarThree[i]!='z')
{
Scierror(999, _("%s: Sorry unrecognised format type.\n"), fname);
return 0;
}
i++;
}
result = archive_compress(pStVarOne,file_list,size,pStVarThree,&error);
if(error == 1)
{
Scierror(999, _("%s: Sorry the file could not be opened.\n"), fname);
return 0;
}
if(error == 2)
{
Scierror(999, _("%s: Sorry the file header could not be read\n"), fname);
return 0;
}
if(error == 3)
{
Scierror(999, _("%s: Sorry the file header could not be written.\n"), fname);
return 0;
}
freeAllocatedSingleString(pStVarOne);
freeAllocatedSingleString(pStVarTwo);
createScalarInteger32(pvApiCtx, Rhs + 1, result);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_getdate(char *fname, unsigned long fname_len)
{
SciErr sciErr;
Rhs = Max(Rhs, 0);
CheckRhs(0, 1) ;
CheckLhs(0, 1) ;
if (Rhs == 0)
{
int iErr = 0;
double *dDate = getCurrentDateAsDoubleVector(&iErr);
if (iErr)
{
Scierror(999, _("%s: An error occurred.\n"), fname);
if (dDate)
{
FREE(dDate);
dDate = NULL;
}
return 0;
}
if (dDate)
{
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, 1, NB_ELEMNT_ARRAY_GETDATE, dDate);
FREE(dDate);
dDate = NULL;
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else /* Rhs == 1 */
{
int *piAddressVarOne = NULL;
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))
{
if (isScalar(pvApiCtx, piAddressVarOne))
{
double dTime = 0.;
char *pStr = NULL;
if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &pStr) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
if (strcmp(pStr, "s") != 0)
{
freeAllocatedSingleString(pStr);
pStr = NULL;
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' expected.\n"), fname, 1, "s");
return 0;
}
freeAllocatedSingleString(pStr);
pStr = NULL;
dTime = getCurrentDateAsUnixTimeConvention();
if (createScalarDouble(pvApiCtx, Rhs + 1, dTime) != 0)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
}
else if (isDoubleType(pvApiCtx, piAddressVarOne))
{
if (isEmptyMatrix(pvApiCtx, piAddressVarOne))
{
if (createEmptyMatrix(pvApiCtx, Rhs + 1) != 0)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else if (!isVarComplex(pvApiCtx, piAddressVarOne))
{
int iErr = 0;
double *dValues = NULL;
double *dResults = NULL;
int m = 0, n = 0;
int nbElements = 0;
int i = 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;
}
nbElements = m * n;
for (i = 0; i < nbElements; i++)
{
if (dValues[i] < 0.)
{
Scierror(999, _("%s: Wrong value for input argument #%d: Must be > %d.\n"), fname, 1, 0);
return 0;
}
}
dResults = getConvertedDateAsMatrixOfDouble(dValues, nbElements, &iErr);
if (iErr == 2)
{
FREE(dResults);
Scierror(999, _("%s: An error occurred.\n"), fname);
return 0;
}
if (dResults == NULL)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
sciErr = createMatrixOfDouble(pvApiCtx, Rhs + 1, nbElements, NB_ELEMNT_ARRAY_GETDATE, dResults);
FREE(dResults);
dResults = NULL;
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: A real expected.\n"), fname, 1);
return 0;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Integer or '%s' expected.\n"), fname, 1, "s");
return 0;
}
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_get(char *fname, void *pvApiCtx)
{
SciErr sciErr;
int* piAddrl1 = NULL;
long long* l1 = NULL;
int* piAddrl2 = NULL;
char* l2 = NULL;
int m1 = 0, n1 = 0;
long hdl = 0;
int lw = 0;
int iObjUID = 0;
int status = SET_PROPERTY_ERROR;
CheckInputArgument(pvApiCtx, 1, 2);
CheckOutputArgument(pvApiCtx, 0, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (isMListType(pvApiCtx, piAddrl1) || isTListType(pvApiCtx, piAddrl1))
{
OverLoad(1);
return 0;
}
/*
* The first input argument can be an ID or a marker (in this case, get returns the value of the current object */
switch (getInputArgumentType(pvApiCtx, 1))
{
case sci_matrix: //console handle
{
double dbll1 = 0;
if (isScalar(pvApiCtx, piAddrl1) == 0)
{
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
return 1;
}
// Retrieve a matrix of double at position 1.
if (getScalarDouble(pvApiCtx, piAddrl1, &dbll1))
{
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
return 1;
}
if ((int)dbll1 == 0) /* Console property */
{
int* piAddrstkAdr = NULL;
char *stkAdr = NULL;
if (nbInputArgument(pvApiCtx) == 1)
{
if (sciReturnHandle(getHandle(getConsoleIdentifier())) != 0) /* Get Console handle */
{
ReturnArguments(pvApiCtx);
return 0;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
CheckInputArgument(pvApiCtx, 2, 2);
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrstkAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of string at position 2.
if (getAllocatedSingleString(pvApiCtx, piAddrstkAdr, &stkAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2);
return 1;
}
if (GetScreenProperty(pvApiCtx, stkAdr) != SET_PROPERTY_SUCCEED)
{
Scierror(999, _("%s: Could not read property '%s' for console object.\n"), "get", stkAdr[0]);
freeAllocatedSingleString(stkAdr);
return 1;
}
freeAllocatedSingleString(stkAdr);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
}
return 0;
break;
}
case sci_handles: /* scalar argument (hdl + string) */
CheckInputArgument(pvApiCtx, 1, 2);
// Retrieve a matrix of handle at position 1.
sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &m1, &n1, &l1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for input argument #%d: Handle matrix expected.\n"), fname, 1);
return 1;
}
if (m1 != 1 || n1 != 1)
{
//lw = 1 + nbArgumentOnStack(pvApiCtx) - nbInputArgument(pvApiCtx);
OverLoad(1);
return 0;
}
if (nbInputArgument(pvApiCtx) == 1)
{
//get path from handle
int uic = getObjectFromHandle((long) * l1);
char* path = get_path(uic);
if (path[0] == '\0')
{
Scierror(999, _("%s: Unable to get useful path from this handle.\n"), fname);
return 1;
}
createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, path);
FREE(path);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (isScalar(pvApiCtx, piAddrl2) == 0 || isStringType(pvApiCtx, piAddrl2) == 0)
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2);
return 1;
}
// Retrieve a matrix of double at position 2.
if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2);
return 1;
}
hdl = (long) * l1; /* on recupere le pointeur d'objet par le handle */
break;
case sci_strings: /* string argument (string) */
{
char* pstFirst = NULL;
CheckInputArgument(pvApiCtx, 1, 2);
if (isScalar(pvApiCtx, piAddrl1) == 0)
{
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
return 1;
}
// Retrieve a matrix of double at position 1.
if (getAllocatedSingleString(pvApiCtx, piAddrl1, &pstFirst))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
return 1;
}
if (strcmp(pstFirst, "default_figure") == 0 ||
strcmp(pstFirst, "default_axes") == 0 ||
strcmp(pstFirst, "current_figure") == 0 ||
strcmp(pstFirst, "current_axes") == 0 ||
strcmp(pstFirst, "current_entity") == 0 ||
strcmp(pstFirst, "hdl") == 0 ||
strcmp(pstFirst, "figures_id") == 0)
{
hdl = 0;
l2 = pstFirst;
}
else
{
int uid = search_path(pstFirst);
if (uid != 0)
{
freeAllocatedSingleString(pstFirst);
hdl = getHandle(uid);
if (nbInputArgument(pvApiCtx) == 1)
{
createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, hdl);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (isScalar(pvApiCtx, piAddrl2) == 0 || isStringType(pvApiCtx, piAddrl2) == 0)
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))
{
Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2);
return 1;
}
}
else
{
createEmptyMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1);
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
}
break;
}
default:
//lw = 1 + nbArgumentOnStack(pvApiCtx) - nbInputArgument(pvApiCtx);
OverLoad(1);
return 0;
break;
}
/* (l2) est la commande, l3 l'indice sur les parametres de la commande */
CheckOutputArgument(pvApiCtx, 0, 1);
if (hdl == 0)
{
/* No handle specified */
if (callGetProperty(pvApiCtx, 0, (l2)) != 0)
{
/* An error has occurred */
freeAllocatedSingleString(l2);
ReturnArguments(pvApiCtx);
return 0;
}
}
else
{
iObjUID = getObjectFromHandle(hdl);
if (iObjUID != 0)
{
if (callGetProperty(pvApiCtx, iObjUID, (l2)) != 0)
{
/* An error has occurred */
freeAllocatedSingleString(l2);
ReturnArguments(pvApiCtx);
return 0;
}
}
else
{
Scierror(999, _("%s: The handle is not or no more valid.\n"), fname);
freeAllocatedSingleString(l2);
return 0;
}
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
freeAllocatedSingleString(l2);
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_dec2base(char *fname, void* pvApiCtx)
{
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;
CheckInputArgument(pvApiCtx, 2, 3);
CheckOutputArgument(pvApiCtx, 1, 1);
if (nbInputArgument(pvApiCtx) == 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 1;
}
if (!isDoubleType(pvApiCtx, piAddressVarThree))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A scalar integer value expected.\n"), fname, 3);
return 1;
}
if (!isScalar(pvApiCtx, piAddressVarThree))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A scalar integer value expected.\n"), fname, 3);
return 1;
}
if (getScalarDouble(pvApiCtx, piAddressVarThree, &dParamThree) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
}
iParamThree = (unsigned int)dParamThree;
if (dParamThree != (double)iParamThree)
{
Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), fname, 3);
return 1;
}
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 1;
}
if (!isDoubleType(pvApiCtx, piAddressVarTwo))
{
Scierror(999, _("%s: Wrong type for input argument #%d: An integer value expected.\n"), fname, 2);
return 1;
}
if (!isScalar(pvApiCtx, piAddressVarTwo))
{
Scierror(999, _("%s: Wrong size for input argument #%d.\n"), fname, 2);
return 1;
}
if (getScalarDouble(pvApiCtx, piAddressVarTwo, &dBaseUsed) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
}
iBaseUsed = (unsigned int)dBaseUsed;
if (dBaseUsed != (double)iBaseUsed)
{
Scierror(999, _("%s: Wrong value for input argument #%d: An integer value expected.\n"), fname, 2);
return 1;
}
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 1;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 1;
}
if (isEmptyMatrix(pvApiCtx, piAddressVarOne))
{
if (createEmptyMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1) != 0)
{
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
}
else
{
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
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 1;
}
if (isVarComplex(pvApiCtx, piAddressVarOne))
{
Scierror(999, _("%s: Wrong type for input argument #%d: A matrix of integer value expected.\n"), fname, 1);
return 1;
}
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 1;
}
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(s) for input argument #%d: A matrix of positive integer values expected.\n"), fname, 1);
return 1;
case ERROR_CONVERTBASE_NOT_IN_INTERVAL:
Scierror(999, _("%s: Wrong value for input argument #%d: Must be between 0 and 2^52.\n"), fname, 1);
return 1;
case ERROR_CONVERTBASE_ALLOCATION:
Scierror(999, _("%s: No more memory.\n"), fname);
return 1;
case ERROR_CONVERTBASE_NOK:
default:
Scierror(999, _("%s: Wrong value for input argument #%d: cannot convert value(s).\n"), fname, 1);
return 1;
}
}
sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m, n, (char const * const*) convertedValues);
freeArrayOfString(convertedValues, m * n);
convertedValues = NULL;
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
ReturnArguments(pvApiCtx);
return 0;
}
int sci_matfile_varreadnext(char *fname, unsigned long fname_len)
{
mat_t *matfile = NULL;
matvar_t *matvar = NULL;
int fileIndex = 0;
int returnedClass = 0, var_type;
int * fd_addr = NULL;
double tmp_dbl;
SciErr sciErr;
CheckRhs(1, 1);
CheckLhs(1, 3);
/* Input argument is the index of the file to read */
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &fd_addr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarType(pvApiCtx, fd_addr, &var_type);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if (var_type == sci_matrix)
{
getScalarDouble(pvApiCtx, fd_addr, &tmp_dbl);
if (!isScalar(pvApiCtx, fd_addr))
{
Scierror(999, _("%s: Wrong size for first input argument: Single double expected.\n"), fname);
return FALSE;
}
fileIndex = (int)tmp_dbl;
}
else
{
Scierror(999, _("%s: Wrong type for first input argument: Double expected.\n"), fname);
return FALSE;
}
/* Gets the corresponding matfile */
matfile_manager(MATFILEMANAGER_GETFILE, &fileIndex, &matfile);
if (matfile == NULL)
{
Scierror(999, _("%s: Invalid file identifier.\n"), fname);
return FALSE;
}
matvar = Mat_VarReadNext(matfile);
if ((matvar == NULL) || (matvar->name == NULL))
{
/* Return empty name */
createSingleString(pvApiCtx, Rhs + 1, "\0");
LhsVar(1) = Rhs + 1;
if (Lhs >= 2)
{
/* Return empty value */
createEmptyMatrix(pvApiCtx, Rhs + 2);
LhsVar(2) = Rhs + 2;
}
if (Lhs == 3)
{
/* Return error flag instead of variable class */
createScalarDouble(pvApiCtx, Rhs + 3, NO_MORE_VARIABLES);
LhsVar(3) = Rhs + 3;
}
PutLhsVar();
return TRUE;
}
/* To be sure isComplex is 0 or 1 */
matvar->isComplex = matvar->isComplex != 0;
/* Return the variable name */
createSingleString(pvApiCtx, Rhs + 1, matvar->name);
LhsVar(1) = Rhs + 1;
returnedClass = matvar->class_type;
if (Lhs >= 2)
{
/* Return the values */
if (!CreateMatlabVariable(pvApiCtx, Rhs + 2, matvar, NULL, -1)) /* Could not Create Variable */
{
sciprint("Do not know how to read a variable of class %d.\n", matvar->class_type);
returnedClass = UNKNOWN_VARIABLE_TYPE;
}
LhsVar(2) = Rhs + 2;
}
if (Lhs == 3)
{
/* Create class return value */
createScalarDouble(pvApiCtx, Rhs + 3, returnedClass);
LhsVar(3) = Rhs + 3;
}
Mat_VarFree(matvar);
PutLhsVar();
return TRUE;
}
int sci_hdf5_load_v2(char *fn, int* pvApiCtx)
{
SciErr sciErr;
int* piAddr = NULL;
char* pstFilename = NULL;
char* pstExpandedFilename = NULL;
bool bImport = true;
const int nbIn = nbInputArgument(pvApiCtx);
int iSelectedVar = nbIn - 1;
CheckInputArgumentAtLeast(pvApiCtx , 1);
CheckOutputArgument(pvApiCtx, 1, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFilename))
{
if (pstFilename)
{
freeAllocatedSingleString(pstFilename);
}
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname.data(), 2);
return 1;
}
//open hdf5 file
pstExpandedFilename = expandPathVariable(pstFilename);
int iFile = openHDF5File(pstExpandedFilename, 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), pstFilename);
FREE(pstExpandedFilename);
FREE(pstFilename);
return 1;
}
FREE(pstExpandedFilename);
FREE(pstFilename);
//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 !
Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname.data(), SOD_FILE_VERSION, iVersion);
return 1;
}
else
{
//call older import functions and exit or ... EXIT !
if (iVersion == 1 || iVersion == -1)
{
return sci_hdf5_load_v1(fn, pvApiCtx);
}
}
}
std::vector<wchar_t*> varList;
if (iSelectedVar)
{
//selected variable
char* pstVarName = NULL;
for (int i = 0 ; i < iSelectedVar ; i++)
{
sciErr = getVarAddressFromPosition(pvApiCtx, i + 2, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstVarName))
{
if (pstVarName)
{
freeAllocatedSingleString(pstVarName);
}
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname.data(), i + 1);
return 1;
}
if (import_variable(pvApiCtx, iFile, pstVarName) == false)
{
FREE(pstVarName);
bImport = false;
break;
}
varList.push_back(to_wide_string(pstVarName));
FREE(pstVarName);
pstVarName = NULL;
}
}
else
{
//all variables
int iNbItem = 0;
iNbItem = getVariableNames(iFile, NULL);
if (iNbItem != 0)
{
char **pstVarNameList = (char **)MALLOC(sizeof(char *) * iNbItem);
iNbItem = getVariableNames(iFile, pstVarNameList);
//import all data
for (int i = 0; i < iNbItem; i++)
{
if (import_variable(pvApiCtx, iFile, pstVarNameList[i]) == false)
{
bImport = false;
break;
}
varList.push_back(to_wide_string(pstVarNameList[i]));
}
freeArrayOfString(pstVarNameList, iNbItem);
}
}
//close the file
closeHDF5File(iFile);
if (bImport == true && varList.size() != 0)
{
createMatrixOfWideString(pvApiCtx, nbIn + 1, 1, static_cast<int>(varList.size()), varList.data());
}
else
{
createEmptyMatrix(pvApiCtx, nbIn + 1);
}
for (auto & i : varList)
{
FREE(i);
}
AssignOutputVariable(pvApiCtx, 1) = nbIn + 1;
ReturnArguments(pvApiCtx);
// printf("End gateway !!!\n");
return 0;
}
/*----------------------------------------------------------------------------*/
int sci_isdigit(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int *piAddressVarOne = NULL;
CheckRhs(1, 1);
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);
return 0;
}
if (!isScalar(pvApiCtx, piAddressVarOne))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
if (!isStringType(pvApiCtx, piAddressVarOne))
{
Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
}
else
{
wchar_t *pStVarOne = NULL;
if (getAllocatedSingleWideString(pvApiCtx, piAddressVarOne, &pStVarOne) != 0)
{
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
else
{
int valuesSize = 0;
BOOL *values = IsDigitW(pStVarOne, &valuesSize);
freeAllocatedSingleWideString(pStVarOne);
pStVarOne = NULL;
if (values)
{
int m1 = 1;
int n1 = valuesSize;
sciErr = createMatrixOfBoolean(pvApiCtx, Rhs + 1, m1, n1,
(const int *)values);
FREE(values);
values = NULL;
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 0;
}
}
else
{
createEmptyMatrix(pvApiCtx, Rhs + 1);
}
LhsVar(1) = Rhs + 1;
PutLhsVar();
}
}
return 0;
}
int sci_name2rgb(char *fname, void* pvApiCtx)
{
SciErr sciErr;
int* piAddr = NULL;
char* pstColor = NULL;
double color[3];
int i;
int nRows;
int nCols;
int nRowsCols;
char** pstColorMatrix = NULL;
double* pColor = NULL;
CheckInputArgument(pvApiCtx, 1, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (isStringType(pvApiCtx, piAddr) == FALSE)
{
Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
return 1;
}
if (isScalar(pvApiCtx, piAddr) == TRUE)
{
getAllocatedSingleString(pvApiCtx, piAddr, &pstColor);
name2rgb(pstColor, color);
freeAllocatedSingleString(pstColor);
if (color[0] == -1 || color[1] == -1 || color[2] == -1)
{
createEmptyMatrix(pvApiCtx, 2);
}
else
{
createMatrixOfDouble(pvApiCtx, 2, 1, 3, color);
}
}
else
{
getAllocatedMatrixOfString(pvApiCtx, piAddr, &nRows, &nCols, &pstColorMatrix);
nRowsCols = nRows * nCols;
pColor = (double*)MALLOC(3 * nRowsCols * sizeof(double));
for (i = 0; i < nRowsCols; ++i)
{
name2rgb(pstColorMatrix[i], color);
if (color[0] == -1 || color[1] == -1 || color[2] == -1)
{
break;
}
pColor[i] = color[0];
pColor[i + nRowsCols] = color[1];
pColor[i + 2 * nRowsCols] = color[2];
}
freeAllocatedMatrixOfString(nRows, nCols, pstColorMatrix);
if (color[0] == -1 || color[1] == -1 || color[2] == -1)
{
createEmptyMatrix(pvApiCtx, 2);
FREE(pColor);
}
else
{
createMatrixOfDouble(pvApiCtx, 2, nRowsCols, 3, pColor);
FREE(pColor);
}
}
AssignOutputVariable(pvApiCtx, 1) = 2;
ReturnArguments(pvApiCtx);
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;
}
bool ScilabObjects::unwrap(int idObj, int pos, const int envId, void * pvApiCtx)
{
if (idObj == 0)
{
if (createEmptyMatrix(pvApiCtx, pos))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create data"));
}
return true;
}
VariableType type = Nothing;
ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId);
const ScilabAbstractEnvironmentWrapper & wrapper = env.getWrapper();
type = env.isunwrappable(idObj);
switch (type)
{
case Nothing:
return false;
case Null:
if (createEmptyMatrix(pvApiCtx, pos))
{
throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot create data"));
}
case SingleDouble:
wrapper.unwrapdouble(idObj, ScilabDoubleStackAllocator(pvApiCtx, pos));
break;
case RowDouble:
wrapper.unwraprowdouble(idObj, ScilabDoubleStackAllocator(pvApiCtx, pos));
break;
case MatDouble:
wrapper.unwrapmatdouble(idObj, ScilabDoubleStackAllocator(pvApiCtx, pos));
break;
case SingleString:
wrapper.unwrapstring(idObj, ScilabStringStackAllocator(pvApiCtx, pos));
break;
case RowString:
wrapper.unwraprowstring(idObj, ScilabStringStackAllocator(pvApiCtx, pos));
break;
case MatString:
wrapper.unwrapmatstring(idObj, ScilabStringStackAllocator(pvApiCtx, pos));
break;
case SingleBoolean:
wrapper.unwrapboolean(idObj, ScilabBooleanStackAllocator(pvApiCtx, pos));
break;
case RowBoolean:
wrapper.unwraprowboolean(idObj, ScilabBooleanStackAllocator(pvApiCtx, pos));
break;
case MatBoolean:
wrapper.unwrapmatboolean(idObj, ScilabBooleanStackAllocator(pvApiCtx, pos));
break;
case SingleChar:
wrapper.unwrapchar(idObj, ScilabCharStackAllocator(pvApiCtx, pos));
break;
case RowChar:
wrapper.unwraprowchar(idObj, ScilabCharStackAllocator(pvApiCtx, pos));
break;
case MatChar:
wrapper.unwrapmatchar(idObj, ScilabCharStackAllocator(pvApiCtx, pos));
break;
case SingleUChar:
wrapper.unwrapuchar(idObj, ScilabUCharStackAllocator(pvApiCtx, pos));
break;
case RowUChar:
wrapper.unwraprowuchar(idObj, ScilabUCharStackAllocator(pvApiCtx, pos));
break;
case MatUChar:
wrapper.unwrapmatuchar(idObj, ScilabUCharStackAllocator(pvApiCtx, pos));
break;
case SingleShort:
wrapper.unwrapshort(idObj, ScilabShortStackAllocator(pvApiCtx, pos));
break;
case RowShort:
wrapper.unwraprowshort(idObj, ScilabShortStackAllocator(pvApiCtx, pos));
break;
case MatShort:
wrapper.unwrapmatshort(idObj, ScilabShortStackAllocator(pvApiCtx, pos));
break;
case SingleUShort:
wrapper.unwrapushort(idObj, ScilabUShortStackAllocator(pvApiCtx, pos));
break;
case RowUShort:
wrapper.unwraprowushort(idObj, ScilabUShortStackAllocator(pvApiCtx, pos));
break;
case MatUShort:
wrapper.unwrapmatushort(idObj, ScilabUShortStackAllocator(pvApiCtx, pos));
break;
case SingleInt:
wrapper.unwrapint(idObj, ScilabIntStackAllocator(pvApiCtx, pos));
break;
case RowInt:
wrapper.unwraprowint(idObj, ScilabIntStackAllocator(pvApiCtx, pos));
break;
case MatInt:
wrapper.unwrapmatint(idObj, ScilabIntStackAllocator(pvApiCtx, pos));
break;
case SingleUInt:
wrapper.unwrapuint(idObj, ScilabUIntStackAllocator(pvApiCtx, pos));
break;
case RowUInt:
wrapper.unwraprowuint(idObj, ScilabUIntStackAllocator(pvApiCtx, pos));
break;
case MatUInt:
wrapper.unwrapmatuint(idObj, ScilabUIntStackAllocator(pvApiCtx, pos));
break;
case SingleLong:
wrapper.unwraplong(idObj, ScilabLongStackAllocator(pvApiCtx, pos));
break;
case RowLong:
wrapper.unwraprowlong(idObj, ScilabLongStackAllocator(pvApiCtx, pos));
break;
case MatLong:
wrapper.unwrapmatlong(idObj, ScilabLongStackAllocator(pvApiCtx, pos));
break;
case SingleULong:
wrapper.unwrapulong(idObj, ScilabULongStackAllocator(pvApiCtx, pos));
break;
case RowULong:
wrapper.unwraprowulong(idObj, ScilabULongStackAllocator(pvApiCtx, pos));
break;
case MatULong:
wrapper.unwrapmatulong(idObj, ScilabULongStackAllocator(pvApiCtx, pos));
break;
case SingleFloat:
wrapper.unwrapfloat(idObj, ScilabFloatStackAllocator(pvApiCtx, pos));
break;
case RowFloat:
wrapper.unwraprowfloat(idObj, ScilabFloatStackAllocator(pvApiCtx, pos));
break;
case MatFloat:
wrapper.unwrapmatfloat(idObj, ScilabFloatStackAllocator(pvApiCtx, pos));
break;
case SingleComplex:
wrapper.unwrapcomplex(idObj, ScilabComplexStackAllocator(pvApiCtx, pos));
break;
case RowComplex:
wrapper.unwraprowcomplex(idObj, ScilabComplexStackAllocator(pvApiCtx, pos));
break;
case MatComplex:
wrapper.unwrapmatcomplex(idObj, ScilabComplexStackAllocator(pvApiCtx, pos));
break;
default:
return false;
}
return true;
}
// =============================================================================
static int sci_csvDefault_one_rhs(char *fname, void* pvApiCtx)
{
int iErr = 0;
char *fieldname = NULL;
char *fieldvalue = NULL;
fieldname = csv_getArgumentAsString(pvApiCtx, 1, fname, &iErr);
if (iErr)
{
freeVar(&fieldname, &fieldvalue);
return 0;
}
if (strcmp(fieldname, SEPARATOR_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultSeparator());
}
else if (strcmp(fieldname, DECIMAL_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultDecimal());
}
else if (strcmp(fieldname, CONVERSION_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultConversion());
}
else if (strcmp(fieldname, PRECISION_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultPrecision());
}
else if (strcmp(fieldname, COMMENTSREGEXP_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultCommentsRegExp());
}
else if (strcmp(fieldname, EOL_FIELDNAME) == 0)
{
const char *currentEol = getCsvDefaultEOL();
if (currentEol)
{
if (strcmp(currentEol, MACOS9_EOL) == 0)
{
fieldvalue = os_strdup(MACOS9_EOL_STRING);
}
else if (strcmp(currentEol, WINDOWS_EOL) == 0)
{
fieldvalue = os_strdup(WINDOWS_EOL_STRING);
}
else if (strcmp(currentEol, LINUX_EOL) == 0)
{
fieldvalue = os_strdup(LINUX_EOL_STRING);
}
else
{
fieldvalue = os_strdup("ERROR");
}
}
else
{
fieldvalue = os_strdup("ERROR");
}
}
else if (strcmp(fieldname, ENCODING_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultEncoding());
}
else if (strcmp(fieldname, BLANK_FIELDNAME) == 0)
{
fieldvalue = os_strdup(getCsvDefaultCsvIgnoreBlankLine());
}
else if (strcmp(fieldname, RESET_PARAMATERS) == 0)
{
freeVar(&fieldname, &fieldvalue);
setCsvDefaultReset();
createEmptyMatrix(pvApiCtx, Rhs + 1);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d: '%s', '%s', '%s', '%s', '%s' or '%s' expected.\n"), fname, 1, SEPARATOR_FIELDNAME, DECIMAL_FIELDNAME, CONVERSION_FIELDNAME, COMMENTSREGEXP_FIELDNAME, EOL_FIELDNAME, BLANK_FIELDNAME);
freeVar(&fieldname, &fieldvalue);
return 0;
}
createSingleString(pvApiCtx, Rhs + 1, fieldvalue);
freeVar(&fieldname, &fieldvalue);
LhsVar(1) = Rhs + 1;
PutLhsVar();
return 0;
}
int hypermatExample(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int* piAddr = NULL;
int iType = 0;
int iRet = 0;
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 0, 1);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
if (isEmptyMatrix(pvApiCtx, piAddr))
{
iRet = createEmptyMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1);
if (iRet)
{
return iRet;
}
AssignOutputVariable(pvApiCtx, 1) = 0;
}
else if (isHypermatType(pvApiCtx, piAddr))
{
int * dims = NULL;
int ndims;
double* pdblReal = NULL;
double* pdblImg = NULL;
if (isHypermatComplex(pvApiCtx, piAddr))
{
sciErr = getComplexHypermatOfDouble(pvApiCtx, piAddr, &dims, &ndims, &pdblReal, &pdblImg);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return sciErr.iErr;
}
sciErr = createComplexHypermatOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dims, ndims, pdblReal, pdblImg);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return sciErr.iErr;
}
}
else
{
sciErr = getHypermatOfDouble(pvApiCtx, piAddr, &dims, &ndims, &pdblReal);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return sciErr.iErr;
}
sciErr = createHypermatOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dims, ndims, pdblReal);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return sciErr.iErr;
}
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
return 0;
}