/*------------------------------------------------------------------------*/
static char *ASCIItime(const struct tm *timeptr)
{
char **wday_name = getDays();
char **mon_name = getMonths();
char *result = NULL;
if ((wday_name) && (mon_name))
{
#define FORMAT_TIME "%s %s%3d %.2d:%.2d:%.2d %d"
int len_result = (int)strlen(wday_name[timeptr->tm_wday]) + (int)strlen(mon_name[timeptr->tm_mon]) + (int)strlen(FORMAT_TIME);
result = (char *)MALLOC(sizeof(char) * (len_result + 1));
if (result)
{
sprintf(result, FORMAT_TIME,
wday_name[timeptr->tm_wday],
mon_name[timeptr->tm_mon], timeptr->tm_mday, timeptr->tm_hour, timeptr->tm_min, timeptr->tm_sec, 1900 + timeptr->tm_year);
}
}
else
{
strcpy(result, "");
}
/* free pointers */
freeArrayOfString(wday_name, MAX_wday);
freeArrayOfString(mon_name, MAX_mon);
return result;
}
/*--------------------------------------------------------------------------*/
int checkPList(void* _pvCtx, int * _piAddress)
{
int nb_param = 0, i = 0, var_type = 0;
int m_label = 0, n_label = 0;
int * len_label = NULL;
char ** label_list = NULL;
int result = 0;
SciErr _SciErr;
_SciErr.iErr = 0;
_SciErr.iMsgCount = 0;
_SciErr = getVarType(_pvCtx, _piAddress, &var_type);
if (var_type != sci_mlist)
{
return 0;
}
_SciErr = getListItemNumber(_pvCtx, _piAddress, &nb_param);
if (nb_param != 0)
{
_SciErr = getMatrixOfStringInList(_pvCtx, _piAddress, 1, &m_label, &n_label, NULL, NULL);
len_label = (int *)MALLOC(m_label * n_label * sizeof(int));
_SciErr = getMatrixOfStringInList(_pvCtx, _piAddress, 1, &m_label, &n_label, len_label, NULL);
label_list = (char **)MALLOC(m_label * n_label * sizeof(char *));
for (i = 0; i < n_label * m_label; i++)
{
label_list[i] = (char *)MALLOC((len_label[i] + 1) * sizeof(char));
}
_SciErr = getMatrixOfStringInList(_pvCtx, _piAddress, 1, &m_label, &n_label, len_label, label_list);
if (strcmp(label_list[0], "plist") != 0)
{
if (len_label)
{
FREE(len_label);
len_label = NULL;
}
freeArrayOfString(label_list, m_label * n_label);
return 0;
}
if (len_label)
{
FREE(len_label);
len_label = NULL;
}
freeArrayOfString(label_list, m_label * n_label);
}
result = 1;
return result;
}
// =============================================================================
static void freeVar(char** separator, char** decimal, char** filename, char** precisionFormat, char*** pHeadersLines, int sizeHeader)
{
if (separator && *separator)
{
FREE(*separator);
*separator = NULL;
}
if (decimal && *decimal)
{
FREE(*decimal);
*decimal = NULL;
}
if (filename && *filename)
{
FREE(*filename);
*filename = NULL;
}
if (precisionFormat && *precisionFormat)
{
FREE(*precisionFormat);
*precisionFormat = NULL;
}
if (pHeadersLines && *pHeadersLines)
{
freeArrayOfString(*pHeadersLines, sizeHeader);
*pHeadersLines = NULL;
}
}
/*--------------------------------------------------------------------------*/
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_librarieslist(char *fname, unsigned long fname_len)
{
char **libraries = NULL;
int sizelibraries = 0;
CheckRhs(0, 0);
CheckLhs(0, 1);
libraries = getlibrarieslist(&sizelibraries);
if (libraries)
{
int m = 0, n = 0;
m = sizelibraries;
n = 1;
CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &m, &n, libraries);
}
else
{
int m = 0, n = 0, l = 0;
CreateVarFromPtr(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &n, &m, &l);
}
LhsVar(1) = Rhs + 1;
freeArrayOfString(libraries, sizelibraries);
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
static int OneLhs(struct VariableStruct* Vstruct,int lenStructArray,BOOL Sorted)
{
int i=0;
int m=0;
int n=0;
char **LocalTab = NULL;
if (Sorted) SortVarsStructByStrings(Vstruct,lenStructArray);
LocalTab=(char **)MALLOC(sizeof(char*)*(lenStructArray));
for (i=0;i<lenStructArray;i++)
{
if (strlen(Vstruct[i].NameVariable)>0)
{
LocalTab[i] = strdup(Vstruct[i].NameVariable);
}
}
m=lenStructArray;
n=1;
CreateVarFromPtr(Rhs+1,MATRIX_OF_STRING_DATATYPE, &m, &n,LocalTab);
LhsVar(1)=Rhs+1;
freeArrayOfString(LocalTab, lenStructArray);
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
static int TwoLhs(struct VariableStruct* Vstruct,int lenStructArray,BOOL Sorted)
{
char **Tab=NULL;
int *Size=NULL;
int i=0;
int m=0;
int n=0;
if (Sorted) SortVarsStructByStrings(Vstruct,lenStructArray);
Tab=(char **)MALLOC(sizeof(char*)*lenStructArray);
Size=(int *)MALLOC(sizeof(int)*lenStructArray);
for (i=0;i<lenStructArray;i++)
{
Tab[i] = strdup(Vstruct[i].NameVariable);
Size[i]=Vstruct[i].SizeVariable;
}
m=lenStructArray;
n=1;
CreateVarFromPtr(Rhs+1,MATRIX_OF_STRING_DATATYPE, &m, &n, Tab);
LhsVar(1) = Rhs+1;
CreateVarFromPtr(Rhs+2,MATRIX_OF_INTEGER_DATATYPE, &m, &n, &Size);
LhsVar(2) = Rhs+2;
freeArrayOfString(Tab, lenStructArray);
if (Size) {FREE(Size);Size=NULL;}
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
void freeFscanfMatResult(fscanfMatResult *resultStruct)
{
if (resultStruct)
{
if (resultStruct->text)
{
freeArrayOfString(resultStruct->text, resultStruct->sizeText);
resultStruct->text = NULL;
}
if (resultStruct->values)
{
FREE(resultStruct->values);
resultStruct->values = NULL;
}
resultStruct->err = FSCANFMAT_ERROR;
resultStruct->m = 0;
resultStruct->n = 0;
resultStruct->sizeText = 0;
FREE(resultStruct);
resultStruct = NULL;
}
}
/*--------------------------------------------------------------------------*/
int scitokenize(char * legend, char *** Strptr, int *n)
{
int arobaseIndex = 0;
int i = 0;
int count = 1;
int prevIndex = 0;
int stringLength = 0, j = 0;
char **Str = NULL;
int lenlegend = (int)strlen(legend);
/* first get the number of tokens */
for (i = 0; i < lenlegend; i++)
{
if (legend[i] == '@')
{
count++;
}
}
*Strptr = (char **)MALLOC(count * sizeof(char *));
Str = *Strptr;
if (Str == NULL)
{
return 1; /* not enough memory */
}
for (i = 0; i < count; i++)
{
Str[i] = NULL;
}
for (i = 0; i < count; i++)
{
while (legend[arobaseIndex] != '@' && legend[arobaseIndex] != 0)
{
arobaseIndex++;
}
/* we found a token */
stringLength = arobaseIndex - prevIndex;
Str[i] = (char *)MALLOC((stringLength + 1) * sizeof(char)); /* +1 for null terminating character*/
if (Str[i] == NULL)
{
freeArrayOfString(Str, i - 1);
return 1;
}
for (j = 0; j < stringLength; j++)
{
Str[i][j] = legend[prevIndex + j];
}
Str[i][stringLength] = 0;
/* skip the @*/
arobaseIndex++;
prevIndex = arobaseIndex;
}
*n = count;
return 0;
}
/*--------------------------------------------------------------------------*/
static BOOL CleanBuffers(char *bufCommands, char **LOCALJOBS, int numberjobs)
{
if (bufCommands)
{
FREE(bufCommands);
bufCommands = NULL;
}
freeArrayOfString(LOCALJOBS, numberjobs);
return TRUE;
}
/*--------------------------------------------------------------------------*/
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;
}
/*--------------------------------------------------------------------------*/
BOOL isTypeNameAlreadyExist(char *name)
{
int sizeArray = 0;
char **TypeNames = getAllTypesName(&sizeArray);
int i = 0;
if (TypeNames)
{
for (i = 0; i < sizeArray; i++)
{
if (strcmp(name, TypeNames[i]) == 0)
{
freeArrayOfString(TypeNames, sizeArray);
return TRUE;
}
}
freeArrayOfString(TypeNames, sizeArray);
}
return FALSE;
}
/*--------------------------------------------------------------------------*/
static int IsACommand(char *primitive)
{
int sizecommandwords = 0;
char **commandwords = getcommandkeywords(&sizecommandwords);
int bOK = FALSE;
int i = 0;
for (i = 0; i < sizecommandwords ; i++)
{
if (strcmp(commandwords[i], primitive) == 0)
{
freeArrayOfString(commandwords, sizecommandwords);
return TRUE;
}
}
freeArrayOfString(commandwords, sizecommandwords);
return bOK;
}
/*------------------------------------------------------------------------*/
int getSizeAllLinesOfScilabHistory(void)
{
int nbElements = 0;
char **lines = NULL;
if (ScilabHistory)
lines = ScilabHistory->getAllLines(&nbElements);
freeArrayOfString(lines, nbElements);
return nbElements;
}
// =============================================================================
void freeCsvResult(csvResult *result)
{
if (result)
{
if (result->pstrValues)
{
freeArrayOfString(result->pstrValues, result->m * result->n);
result->pstrValues = NULL;
}
result->m = 0;
result->n = 0;
if (result->pstrComments)
{
freeArrayOfString(result->pstrComments, result->nbComments);
result->pstrComments = NULL;
}
result->err = CSV_READ_ERROR;
FREE(result);
result = NULL;
}
}
/*----------------------------------------------------------------------------*/
int sci_strrev(char *fname,unsigned long fname_len)
{
CheckRhs(1,1);
CheckLhs(0,1);
if (GetType(1) == sci_strings)
{
int m1 = 0; int n1 = 0;
char **InputStrings = NULL;
int m1n1 = 0; /* m1 * n1 */
char **OutputStrings = NULL;
GetRhsVar(1,MATRIX_OF_STRING_DATATYPE,&m1,&n1,&InputStrings);
m1n1 = m1 * n1;
OutputStrings = strings_strrev(InputStrings,m1n1);
if (OutputStrings)
{
CreateVarFromPtr(Rhs+1,MATRIX_OF_STRING_DATATYPE,&m1,&n1,OutputStrings);
freeArrayOfString(InputStrings,m1n1);
freeArrayOfString(OutputStrings,m1n1);
LhsVar(1) = Rhs+1 ;
PutLhsVar();
}
else
{
freeArrayOfString(InputStrings,m1n1);
Scierror(999,_("%s: No more memory.\n"),fname);
return 0;
}
}
else
{
Scierror(999,_("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"),fname,1);
}
return 0;
}
/*--------------------------------------------------------------------------*/
int C2F(sci_what)(char *fname, unsigned long fname_len)
{
int sizecommandwords = 0;
char **commandwords = getcommandkeywords(&sizecommandwords);
Rhs = Max(0, Rhs);
CheckRhs(0, 0);
CheckLhs(1, 2);
CreateLocalFunctionsTab();
qsort( LocalFunctionsTab , SizeLocalFunctionsTab , sizeof (char *) , cmpfunctionnames);
if (Lhs == 1)
{
DispInternalFunctions();
DispCommands();
LhsVar(1) = 0;
}
else /* Lhs == 2 */
{
int ncol = 1;
int nrowFunctions = SizeLocalFunctionsTab;
int nrowCommands = sizecommandwords;
CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &nrowFunctions, &ncol, LocalFunctionsTab);
LhsVar(1) = Rhs + 1;
CreateVarFromPtr(Rhs + 2, MATRIX_OF_STRING_DATATYPE, &nrowCommands, &ncol, commandwords);
LhsVar(2) = Rhs + 2;
freeArrayOfString(LocalFunctionsTab, nrowFunctions);
freeArrayOfString(commandwords, nrowCommands);
}
PutLhsVar();
return 0;
}
/*--------------------------------------------------------------------------*/
static int CreateLocalFunctionsTab(void)
{
char **LocalFunctionsTabTmp = NULL;
int i = 0;
int j = 0;
int SizeTab = 0;
int MaxSizeWithoutCommands = 0;
LocalFunctionsTabTmp = GetFunctionsList(&SizeTab);
if (LocalFunctionsTabTmp)
{
for (i = 0; i < SizeTab; i++)
{
if ( !IsACommand(LocalFunctionsTabTmp[i]) )
{
MaxSizeWithoutCommands++;
}
}
LocalFunctionsTab = (char **)MALLOC(sizeof(char**) * MaxSizeWithoutCommands);
if (LocalFunctionsTab == NULL)
{
SizeLocalFunctionsTab = 0;
return FALSE;
}
j = 0;
for (i = 0; i < SizeTab; i++)
{
if ( !IsACommand(LocalFunctionsTabTmp[i]) )
{
LocalFunctionsTab[j] = strdup(LocalFunctionsTabTmp[i]);
j++;
}
}
freeArrayOfString(LocalFunctionsTabTmp, SizeTab);
}
else
{
SizeLocalFunctionsTab = 0;
return FALSE;
}
SizeLocalFunctionsTab = MaxSizeWithoutCommands;
return TRUE;
}
static bool export_strings(int _iH5File, int *_piVar, char* _pstName)
{
int iRet = 0;
int* piLen = NULL;
char** pstData = NULL;
int piDims[2];
SciErr sciErr = getMatrixOfString(pvApiCtx, _piVar, &piDims[0], &piDims[1], NULL, NULL);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
piLen = (int*)MALLOC(piDims[0] * piDims[1] * sizeof(int));
sciErr = getMatrixOfString(pvApiCtx, _piVar, &piDims[0], &piDims[1], piLen, NULL);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
pstData = (char**)MALLOC(sizeof(char*) * piDims[0] * piDims[1]);
for (int i = 0 ; i < piDims[0] * piDims[1] ; i++)
{
pstData[i] = (char*)MALLOC(sizeof(char) * (piLen[i] + 1));// for null termination
}
sciErr = getMatrixOfString(pvApiCtx, _piVar, &piDims[0], &piDims[1], piLen, pstData);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
iRet = writeStringMatrix(_iH5File, _pstName, 2, piDims, pstData);
if (iRet)
{
return false;
}
char pstMsg[512];
sprintf(pstMsg, "string (%d x %d)", piDims[0], piDims[1]);
print_type(pstMsg);
freeArrayOfString(pstData, piDims[0] * piDims[1]);
return true;
}
/*--------------------------------------------------------------------------*/
int setInternalLastErrorMessage(char** strErrorMessage, int iNbLines)
{
int i = 0;
if (strLastErrorMessage)
{
freeArrayOfString(strLastErrorMessage, iLastErrorMessageNbLines);
}
allocLastErrorMessage();
for (i = 0; i < iNbLines; i++)
{
appendStringToInternalLastErrorMessage(strErrorMessage[i]);
}
return 0;
}
/*------------------------------------------------------------------------*/
errorLoadHistoryCode HistoryFile::loadFromFile(std::string filename)
{
errorLoadHistoryCode returnedError = ERROR_HISTORY_NOT_LOADED;
int fd = 0;
int f_swap = 0;
double res = 0.0;
int errMOPEN = MOPEN_INVALID_STATUS;
double dErrClose = 0.;
C2F(mopen)(&fd, (char*)filename.c_str(), "rt", &f_swap, &res, &errMOPEN);
if (errMOPEN == MOPEN_NO_ERROR)
{
int errMGETL = MGETL_ERROR;
int nblines = 0;
char **lines = mgetl(fd, -1, &nblines, &errMGETL);
C2F(mclose)(&fd, &dErrClose);
if (errMGETL == MGETL_NO_ERROR)
{
if (lines)
{
int iStart = 0;
int iEnd = 0;
if (nblines > getDefaultMaxNbLines())
{
iStart = nblines - getDefaultMaxNbLines();
returnedError = HISTORY_TRUNCATED;
}
else
{
iStart = 0;
returnedError = NO_ERROR_HISTORY_LOADED;
}
iEnd = nblines;
for (int i = iStart; i < iEnd; i++)
{
CommandLine Line(lines[i]);
this->Commands.push_back(Line);
}
freeArrayOfString(lines, nblines);
lines = NULL;
}
}
}
return returnedError;
}
/*--------------------------------------------------------------------------*/
int C2F(msgstore)(char *str, int *n)
{
int iRes = 0;
char **multilines = NULL;
int nbLines = 0;
int i = 0;
char *msg = NULL;
char *msgTmp = NULL;
if (str == NULL) return 1;
msg = strdup(str);
if (msg)
{
msg[*n] = 0;
}
// remove duplicate percent bug 9571
msgTmp = strsub(msg, "%%", "%");
if (msgTmp)
{
FREE(msg);
msg = msgTmp;
}
multilines = splitErrorMessage(msg, &nbLines);
if (multilines)
{
for (i = 0; i < nbLines; i++)
{
iRes = appendStringToInternalLastErrorMessage(multilines[i]);
if (iRes) break;
}
freeArrayOfString(multilines, nbLines);
multilines = NULL;
}
else
{
iRes = appendStringToInternalLastErrorMessage(msg);
}
if (msg)
{
FREE(msg);
msg = NULL;
}
return iRes;
}
static void doCompletion(char *wk_buf, unsigned int *cursor, unsigned int *cursor_max)
{
char *LineBeforeCaret = getLineBeforeCaret(wk_buf, cursor);
char *LineAfterCaret = getLineAfterCaret(wk_buf, cursor, cursor_max);
char *fileSearchedPattern = getFilePartLevel(LineBeforeCaret);
char *SearchedPattern = getPartLevel(LineBeforeCaret);
char **completionDictionaryFiles = NULL;
int sizecompletionDictionaryFiles = 0;
completionDictionaryFiles = completionOnFiles(fileSearchedPattern, &sizecompletionDictionaryFiles);
if (completionDictionaryFiles)
{
TermCompletionOnFiles(completionDictionaryFiles, sizecompletionDictionaryFiles,
LineBeforeCaret, LineAfterCaret, fileSearchedPattern, SearchedPattern, wk_buf, cursor, cursor_max);
freeArrayOfString(completionDictionaryFiles, sizecompletionDictionaryFiles);
}
else
{
TermCompletionOnAll(LineBeforeCaret, LineAfterCaret, SearchedPattern, wk_buf, cursor, cursor_max);
}
if (LineBeforeCaret)
{
FREE(LineBeforeCaret);
LineBeforeCaret = NULL;
}
if (LineAfterCaret)
{
FREE(LineAfterCaret);
LineAfterCaret = NULL;
}
if (fileSearchedPattern)
{
FREE(fileSearchedPattern);
fileSearchedPattern = NULL;
}
if (SearchedPattern)
{
FREE(SearchedPattern);
SearchedPattern = NULL;
}
}
/*--------------------------------------------------------------------------*/
BOOL isScilabMacro(const char * functionName)
{
if (functionName)
{
char **librariesResult = NULL;
int librariesResultSize = 0;
librariesResult = searchmacroinlibraries((char*)functionName, &librariesResultSize);
freeArrayOfString(librariesResult, librariesResultSize);
if (librariesResultSize > 0)
{
return TRUE;
}
}
return FALSE;
}
/*--------------------------------------------------------------------------*/
int sci_getfilepartlevel(char *fname, unsigned long fname_len)
{
CheckRhs(1, 1);
CheckLhs(1, 1);
if (GetType(1) == sci_strings)
{
int m = 0, n = 0;
char **InputString = NULL;
GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &m, &n, &InputString);
if ( (m == 1) && (n == 1) )
{
char *result = NULL;
result = getFilePartLevel(InputString[0]);
if (result == NULL)
{
int l = 0;
m = 0, n = 0;
CreateVar(Rhs + 1, STRING_DATATYPE, &m, &n, &l);
}
else
{
n = 1;
CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, (m = (int)strlen(result), &m), &n, &result);
if (result)
{
FREE(result);
result = NULL;
}
}
LhsVar(1) = Rhs + 1;
}
else
{
freeArrayOfString(InputString, m * n);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
}
return 0;
}
/*--------------------------------------------------------------------------*/
void TermCompletion(void)
{
char *LineBeforeCaret = getLineBeforeCaret();
char *LineAfterCaret = getLineAfterCaret();
char *fileSearchedPattern = getFilePartLevel(LineBeforeCaret);
char *SearchedPattern = getPartLevel(LineBeforeCaret);
char **completionDictionaryFiles = NULL;
int sizecompletionDictionaryFiles = 0;
completionDictionaryFiles = completionOnFiles(fileSearchedPattern, &sizecompletionDictionaryFiles);
if (completionDictionaryFiles)
{
TermCompletionOnFiles(completionDictionaryFiles, sizecompletionDictionaryFiles,
LineBeforeCaret, LineAfterCaret, fileSearchedPattern, SearchedPattern);
freeArrayOfString(completionDictionaryFiles, sizecompletionDictionaryFiles);
}
else
{
TermCompletionOnAll(LineBeforeCaret, LineAfterCaret, SearchedPattern);
}
if (LineBeforeCaret)
{
FREE(LineBeforeCaret);
LineBeforeCaret = NULL;
}
if (LineAfterCaret)
{
FREE(LineAfterCaret);
LineAfterCaret = NULL;
}
if (fileSearchedPattern)
{
FREE(fileSearchedPattern);
fileSearchedPattern = NULL;
}
if (SearchedPattern)
{
FREE(SearchedPattern);
SearchedPattern = NULL;
}
}
/*--------------------------------------------------------------------------*/
static BOOL Load_primitives_from_gateway_xml_file(char *modulename)
{
BOOL bOK = FALSE;
if (modulename)
{
struct gateway_struct *currentGateway = NULL;
currentGateway = readGateway(modulename);
if (currentGateway)
{
int i = 0;
for (i = 0; i < currentGateway->dimLists; i++)
{
if (currentGateway->primitivesList[i])
{
int GATEWAY_ID = currentGateway->gatewayIdList[i];
int PRIMITIVE_ID = currentGateway->primiviteIdList[i];
Add_a_Scilab_primitive_in_hashtable(currentGateway->primitivesList[i],
&GATEWAY_ID,
&PRIMITIVE_ID);
}
}
/* FREE struct currentGateway */
freeArrayOfString(currentGateway->primitivesList,currentGateway->dimLists);
if (currentGateway->primiviteIdList)
{
FREE(currentGateway->primiviteIdList);
currentGateway->primiviteIdList = NULL;
}
if (currentGateway->gatewayIdList)
{
FREE(currentGateway->gatewayIdList);
currentGateway->gatewayIdList = NULL;
}
FREE(currentGateway);
currentGateway = NULL;
bOK = TRUE;
}
}
return bOK;
}
/*--------------------------------------------------------------------------*/
static void DispCommands(void)
{
int i=0;
int sizecommandwords = 0;
char **commandwords = getcommandkeywords(&sizecommandwords);
sciprint("\n");
sciprint(_("Commands:\n"));
sciprint("\n");
for (i=0;i <sizecommandwords;i++)
{
sciprint("%+24s ",commandwords[i]);
if ((i+1)%4==0) sciprint("\n");
}
sciprint("\n");
freeArrayOfString(commandwords, sizecommandwords);
}
/* ==================================================================== */
static void freeVar(char** filename, char** separator, char** decimal, char** conversion, int** iRange, char*** toreplace, int sizeReplace, char** regexp)
{
if (filename && *filename)
{
FREE(*filename);
*filename = NULL;
}
if (separator && *separator)
{
FREE(*separator);
*separator = NULL;
}
if (decimal && *decimal)
{
FREE(*decimal);
*decimal = NULL;
}
if (conversion && *conversion)
{
FREE(*conversion);
*conversion = NULL;
}
if (iRange && *iRange)
{
FREE(*iRange);
*iRange = NULL;
}
if (toreplace && *toreplace)
{
freeArrayOfString(*toreplace, sizeReplace);
*toreplace = NULL;
}
if (regexp && *regexp)
{
FREE(*regexp);
*regexp = NULL;
}
}
/* ==================================================================== */
int getProxyValues(char **proxyHost, long *proxyPort, char **proxyUserPwd)
{
const char * attrs[] = {"enabled", "host", "port", "user", "password"};
const unsigned int N = sizeof(attrs) / sizeof(char*);
char ** values = getPrefAttributesValues("//web/body/proxy", attrs, N);
if (!values)
{
return 0;
}
if (stricmp(values[0]/*enabled*/, "true") == 0)
{
const unsigned int ulen = (const unsigned int)strlen(values[3]);
const unsigned int plen = (const unsigned int)strlen(values[4]);
*proxyHost = values[1]; //host;
*proxyPort = strtol(values[2], NULL, 10); //port;
FREE(values[2]);
if (plen == 0)
{
*proxyUserPwd = values[3]; //user
}
else
{
*proxyUserPwd = (char *)MALLOC((ulen + 1 + plen + 1) * sizeof(char *));
sprintf(*proxyUserPwd, "%s:%s", values[3]/*user*/, values[4]/*password*/);
(*proxyUserPwd)[ulen + 1 + plen] = '\0';
FREE(values[3]);
}
FREE(values[4]);
FREE(values[0]);
FREE(values);
}
else
{
freeArrayOfString(values, N);
return 0;
}
return 1;
}
