/*-----------------------------------------------------------------------------------*/
static int GREP_NEW(GREPRESULTS * results, char **Inputs_param_one, int mn_one, char **Inputs_param_two, int mn_two)
{
int x = 0, y = 0;
char *save = NULL;
pcre_error_code answer = PCRE_FINISHED_OK;
for (x = 0; x < mn_one; x++)
{
results->sizeArraysMax = results->sizeArraysMax + (int)strlen(Inputs_param_one[x]);
}
results->values = (int *)MALLOC(sizeof(int) * (3 * results->sizeArraysMax + 1));
results->positions = (int *)MALLOC(sizeof(int) * (3 * results->sizeArraysMax + 1));
if ((results->values == NULL) || (results->positions == NULL))
{
if (results->values)
{
FREE(results->values);
results->values = NULL;
}
if (results->positions)
{
FREE(results->positions);
results->positions = NULL;
}
return MEMORY_ALLOC_ERROR;
}
results->currentLength = 0;
for (y = 0; y < mn_one; ++y)
{
for (x = 0; x < mn_two; ++x)
{
int Output_Start = 0;
int Output_End = 0;
save = strdup(Inputs_param_two[x]);
answer = pcre_private(Inputs_param_one[y], save, &Output_Start, &Output_End, NULL, NULL);
if (answer == PCRE_FINISHED_OK)
{
if (results->currentLength < results->sizeArraysMax)
{
results->values[results->currentLength] = y + 1;
results->positions[results->currentLength] = x + 1;
results->currentLength++;
}
}
else
{
pcre_error("grep", answer);
}
if (save)
{
FREE(save);
save = NULL;
}
}
}
if (results->currentLength > results->sizeArraysMax)
{
results->currentLength = results->sizeArraysMax;
}
return GREP_OK;
}
/*-------------------------------------------------------------------------------*/
pcre_error_code wide_pcre_private(wchar_t* _pwstInput, wchar_t* _pwstPattern, int* _piStart, int* _piEnd, wchar_t*** _pstCapturedString, int* _piCapturedStringCount)
{
pcre_error_code iPcreStatus = PCRE_FINISHED_OK;
int i = 0;
int iStart = 0;
int iEnd = 0;
char* pstInput = wide_string_to_UTF8(_pwstInput);
char* pstPattern = wide_string_to_UTF8(_pwstPattern);
char** pstCaptured = NULL;//(char**)MALLOC(sizeof(char*) * (strlen(pstInput) + 1));
iPcreStatus = pcre_private(pstInput, pstPattern, &iStart, &iEnd, &pstCaptured, _piCapturedStringCount);
if (iPcreStatus == PCRE_FINISHED_OK && iStart != iEnd)
{
char* pstTempStart = NULL;
char* pstTempEnd = NULL;
wchar_t* pwstTempStart = NULL;
wchar_t* pwstTempEnd = NULL;
pstTempStart = os_strdup(pstInput);
pstTempEnd = os_strdup(pstInput);
pstTempEnd[iEnd] = 0;
pstTempStart[iStart] = 0;
pwstTempStart = to_wide_string(pstTempStart);
pwstTempEnd = to_wide_string(pstTempEnd);
*_piStart = (int)wcslen(pwstTempStart);
*_piEnd = (int)wcslen(pwstTempEnd);
if (_piCapturedStringCount && *_piCapturedStringCount > 0)
{
/*convert captured field in wide char*/
*_pstCapturedString = (wchar_t**)MALLOC(sizeof(wchar_t*) * *_piCapturedStringCount);
for (i = 0 ; i < *_piCapturedStringCount ; i++)
{
(*_pstCapturedString)[i] = to_wide_string(pstCaptured[i]);
}
freeArrayOfString(pstCaptured, *_piCapturedStringCount);
}
FREE(pstTempStart);
FREE(pstTempEnd);
FREE(pwstTempStart);
FREE(pwstTempEnd);
}
else
{
*_piStart = iStart;
*_piEnd = iEnd;
if (_piCapturedStringCount && *_piCapturedStringCount > 0)
{
/*free unused captured field*/
freeArrayOfString(pstCaptured, *_piCapturedStringCount);
}
}
FREE(pstInput);
FREE(pstPattern);
return iPcreStatus;
}
/*-------------------------------------------------------------------------------------*/
char *strsub(const char* input_string, const char* string_to_search, const char* replacement_string)
{
const char *occurrence_str = NULL;
char* result_str = NULL;
char *replacedString = NULL;
int count = 0, len = 0;
if (input_string == NULL)
{
return NULL;
}
if (string_to_search == NULL || replacement_string == NULL)
{
return os_strdup(input_string);
}
occurrence_str = strstr (input_string, string_to_search);
if (occurrence_str == NULL)
{
return os_strdup(input_string);
}
if (strlen (replacement_string) > strlen (string_to_search))
{
count = 0;
len = (int)strlen (string_to_search);
if (len)
{
occurrence_str = input_string;
while (occurrence_str != NULL && *occurrence_str != '\0')
{
occurrence_str = strstr (occurrence_str, string_to_search);
if (occurrence_str != NULL)
{
occurrence_str += len;
count++;
}
}
}
len = count * ((int)strlen(replacement_string) - (int)strlen(string_to_search)) + (int)strlen(input_string);
}
else
{
len = (int)strlen(input_string);
}
replacedString = (char*)MALLOC (sizeof(char) * (len + 1));
if (replacedString == NULL)
{
return NULL;
}
occurrence_str = input_string;
result_str = replacedString;
len = (int)strlen (string_to_search);
while (*occurrence_str != '\0')
{
if (*occurrence_str == string_to_search[0] && strncmp (occurrence_str, string_to_search, len) == 0)
{
const char *N = NULL;
N = replacement_string;
while (*N != '\0')
{
*result_str++ = *N++;
}
occurrence_str += len;
}
else
{
*result_str++ = *occurrence_str++;
}
}
*result_str = '\0';
return replacedString;
}/*-------------------------------------------------------------------------------------*/
char *strsub_reg(const char* input_string, const char* string_to_search, const char* replacement_string, int *ierr)
{
pcre_error_code w = PCRE_FINISHED_OK;
int Output_Start = 0;
int Output_End = 0;
char *replacedString = NULL;
wchar_t *wcreplacedString = NULL;
wchar_t *wcreplacement_string = NULL;
wchar_t *wcinput_string = NULL;
int len = 0;
*ierr = (int)PCRE_FINISHED_OK;
if (input_string == NULL)
{
return NULL;
}
if (string_to_search == NULL || replacement_string == NULL)
{
return os_strdup(input_string);
}
w = pcre_private((char*)input_string, (char*)string_to_search, &Output_Start, &Output_End, NULL, NULL);
if (w != PCRE_FINISHED_OK)
{
*ierr = (int)w;
return os_strdup(input_string);
}
wcreplacement_string = to_wide_string((char*)replacement_string);
wcinput_string = to_wide_string((char*)input_string);
if (wcreplacement_string == NULL)
{
FREE(wcinput_string);
*ierr = (int)NOT_ENOUGH_MEMORY_FOR_VECTOR;
return os_strdup(input_string);
}
len = (int)wcslen(wcreplacement_string) + (int)wcslen(wcinput_string);
wcreplacedString = (wchar_t*)MALLOC (sizeof(wchar_t) * (len + 1));
if (wcreplacedString == NULL)
{
FREE(replacement_string);
FREE(wcinput_string);
return NULL;
}
{
/* converts to wide characters */
wchar_t *wctail = NULL;
int wcOutput_Start = 0;
int wcOutput_End = 0;
char * strOutput_Start = os_strdup(input_string);
char * strOutput_End = os_strdup(input_string);
wchar_t *wcstrOutput_Start = NULL;
wchar_t *wcstrOutput_End = NULL;
/* calculates positions with wide characters */
strOutput_Start[Output_Start] = '\0';
strOutput_End[Output_End] = '\0';
wcstrOutput_Start = to_wide_string(strOutput_Start);
wcstrOutput_End = to_wide_string(strOutput_End);
FREE(strOutput_Start);
FREE(strOutput_End);
if (wcstrOutput_Start)
{
wcOutput_Start = (int)wcslen(wcstrOutput_Start);
FREE(wcstrOutput_Start);
}
else
{
wcOutput_Start = 0;
}
if (wcstrOutput_End)
{
wcOutput_End = (int)wcslen(wcstrOutput_End);
FREE(wcstrOutput_End);
}
else
{
wcOutput_End = 0;
}
wcsncpy(wcreplacedString, wcinput_string, wcOutput_Start);
wcreplacedString[wcOutput_Start] = L'\0';
wcscat(wcreplacedString, wcreplacement_string);
wctail = wcinput_string + wcOutput_End;
wcscat(wcreplacedString, wctail);
replacedString = wide_string_to_UTF8(wcreplacedString);
FREE(wcreplacedString);
}
FREE(wcinput_string);
FREE(wcreplacement_string);
return replacedString;
}
/*------------------------------------------------------------------------*/
int sci_regexp(char *fname,unsigned long fname_len)
{
char typ = CHAR_S;
char **Str = NULL;
char **Str2 = NULL;
int i = 0; /* loop indice */
int mn = 0; /* dimension parameter 1 m*n */
int mn2 = 0; /* m2*n2 */
int outIndex = 0;
int numRow = 1;
int *values_start = NULL;
int *values_end = NULL;
int *wcvalues_start = NULL;
int *wcvalues_end = NULL;
int nbValues_start = 0;
int nbValues_end=0;
int nbposition = 0;
CheckRhs(2,3);
CheckLhs(1,3);
if (VarType(1) == sci_strings)
{
int m1 = 0;
int n1 = 0;
GetRhsVar(1,MATRIX_OF_STRING_DATATYPE,&m1,&n1,&Str);
mn = m1*n1;
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Single string expected.\n"), fname,1);
return 0;
}
if (mn != 1)
{
freeArrayOfString(Str,mn);
Scierror(36, _("%s: Wrong size for input argument #%d: Single string expected.\n"), fname,1);
return 0;
}
if (VarType(2) == sci_strings)
{
int m2 = 0,n2 = 0;
GetRhsVar(2,MATRIX_OF_STRING_DATATYPE,&m2,&n2,&Str2);
mn2 = m2*n2;
}
else
{
freeArrayOfString(Str,mn);
Scierror(36, _("%s: Wrong type for input argument #%d: Single string expected.\n"), fname,2);
return 0;
}
if (mn2 != 1)
{
freeArrayOfString(Str2,mn2);
Scierror(36, _("%s: Wrong size for input argument #%d: Single string expected.\n"), fname,2);
return 0;
}
if ( (int)strlen(Str[0]) == 0 )
{
values_start = (int *)MALLOC(sizeof(int));
values_end = (int *)MALLOC(sizeof(int));
wcvalues_start = (int *)MALLOC(sizeof(int));
wcvalues_end = (int *)MALLOC(sizeof(int));
}
else
{
values_start = (int *)MALLOC( sizeof(int) * ( strlen(Str[0]) ) );
values_end = (int *)MALLOC( sizeof(int) * ( strlen(Str[0]) ) );
wcvalues_start = (int *)MALLOC( sizeof(int) * ( strlen(Str[0]) ) );
wcvalues_end = (int *)MALLOC( sizeof(int) * ( strlen(Str[0]) ) );
}
if (Rhs == 2 )
{
typ = CHAR_S;
}
else /* Rhs == 3 */
{
int m3 = 0, n3 = 0, l3 = 0;
GetRhsVar(3,STRING_DATATYPE,&m3,&n3,&l3);
if ( m3*n3 != 0) typ = cstk(l3)[0];
if (typ != STR_ONCE)
{
freeArrayOfString(Str,mn);
freeArrayOfString(Str2,mn2);
Scierror(999,_("%s: Wrong type for input argument #%d: '%s' expected.\n"),fname,3,"o");
return 0;
}
}
{
int x = 0;
pcre_error_code answer = PCRE_FINISHED_OK;
int start_point = 0;
int Output_Start = 0;
int Output_End = 0;
int wcOutput_Start = 0;
int wcstart_point = 0;
int wcOutput_End = 0;
for (x = 0; x < mn2; ++x)
{
char *save = strdup(Str2[x]);
if (save)
{
char *pointer = Str[0];
start_point = 0;
wcstart_point = 0;
do
{
strcpy(save,Str2[x]);
Output_Start = 0;
Output_End = 0;
answer = pcre_private(pointer,save,&Output_Start,&Output_End);
if ( answer == PCRE_FINISHED_OK )
{
/* Start = End means that we matched a position and 0 characters.
* Matching 0 characters, for us, means no match.
*/
if (Output_Start != Output_End)
{
char * strOutput_Start = strdup(pointer);
char * strOutput_End = strdup(pointer);
wchar_t *wcstrOutput_Start = NULL;
wchar_t *wcstrOutput_End = NULL;
/* calculates positions with wide characters */
strOutput_Start[Output_Start] = '\0';
strOutput_End[Output_End] = '\0';
wcstrOutput_Start = to_wide_string(strOutput_Start);
wcstrOutput_End = to_wide_string(strOutput_End);
if (wcstrOutput_Start)
{
wcOutput_Start = (int)wcslen(wcstrOutput_Start);
FREE(wcstrOutput_Start);wcstrOutput_Start = NULL;
}
else
{
wcOutput_Start = 0;
}
if (wcstrOutput_End)
{
wcOutput_End = (int)wcslen(wcstrOutput_End);
FREE(wcstrOutput_End);wcstrOutput_End = NULL;
}
else
{
wcOutput_End = 0;
}
if (strOutput_Start) {FREE(strOutput_Start); strOutput_Start = NULL;}
if (strOutput_End) {FREE(strOutput_End); strOutput_End = NULL;}
/*adding the answer into the outputmatrix*/
values_start[nbValues_start] = Output_Start + start_point + 1;
values_end[nbValues_end] = Output_End + start_point;
wcvalues_start[nbValues_start] = wcOutput_Start + wcstart_point + 1;
wcvalues_end[nbValues_end] = wcOutput_End + wcstart_point;
nbValues_start++;
nbValues_end++;
/*The number according to the str2 matrix*/
nbposition++;
}
else if(Output_End == 0 && *pointer != '\0')
{
/* Avoid an infinite loop */
pointer++;
}
pointer = &pointer[Output_End];
start_point = start_point + Output_End ;
wcstart_point = wcstart_point + wcOutput_End ;
}
else
{
if (answer != NO_MATCH)
{
pcre_error(fname,answer);
freeArrayOfString(Str,mn);
freeArrayOfString(Str2,mn2);
return 0;
}
}
}
while( (answer == PCRE_FINISHED_OK) && (*pointer != '\0') && (typ != STR_ONCE) );
if (save) {FREE(save);save=NULL;}
}
else
{
freeArrayOfString(Str,mn);
freeArrayOfString(Str2,mn2);
Scierror(999, _("%s: No more memory.\n"),fname);
return 0;
}
}
}
numRow = 1; /* Output values[] */
outIndex = 0;
CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,&numRow,&nbValues_start,&outIndex);
for ( i = 0 ; i < nbValues_start ; i++ )
{
stk(outIndex)[i] = (double)wcvalues_start[i] ;
}
LhsVar(1) = Rhs+1 ;
if (Lhs >= 2)
{
numRow = 1;
outIndex = 0;
CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&numRow,&nbValues_end,&outIndex);
for ( i = 0 ; i < nbposition ; i++ )
{
stk(outIndex)[i] = (double)wcvalues_end[i] ;
}
LhsVar(2) = Rhs+2;
}
if (Lhs == 3)
{
if (nbValues_start != 0)
{
char **match = (char**)MALLOC(sizeof(char*)*(nbValues_start));
if (match == NULL)
{
freeArrayOfString(Str, mn);
freeArrayOfString(Str2, mn2);
Scierror(999, _("%s: No more memory.\n"),fname);
return 0;
}
for( i = 0; i < nbValues_start; i++)
{
int len = values_end[i] - values_start[i] + 1;
match[i] = (char*)MALLOC(sizeof(char)*(len + 1));
strncpy(match[i], Str[0] + values_start[i] - 1, len);
/* A char* always finished by \0 */
match[i][len] = '\0';
}
numRow = nbValues_start;
outIndex = 1 ;
CreateVarFromPtr(Rhs + 3,MATRIX_OF_STRING_DATATYPE, &numRow, &outIndex, match );
LhsVar(3) = Rhs + 3 ;
freeArrayOfString(match,nbValues_start);
}
else
{
int m3 = 0, n3 = 0, l3 = 0;
CreateVar(Rhs+3,STRING_DATATYPE, &m3, &n3, &l3);
LhsVar(3) = Rhs + 3 ;
}
}
freeArrayOfString(Str, mn);
freeArrayOfString(Str2, mn2);
if (values_start) {FREE(values_start); values_start = NULL;}
if (values_end) {FREE(values_end); values_end = NULL;}
if (wcvalues_start) {FREE(wcvalues_start); wcvalues_start = NULL;}
if (wcvalues_end) {FREE(wcvalues_end); wcvalues_end = NULL;}
PutLhsVar();
return 0;
}
/*------------------------------------------------------------------------*/
int sci_strindex(char *fname, unsigned long fname_len)
{
BOOL bStrindex_with_pattern = FALSE;
int outIndex = 0;
int numRow = 1;
int *next = NULL;
CheckRhs(2, 3);
CheckLhs(1, 2);
if (Rhs == 3)
{
int m3 = 0;
int n3 = 0;
char **Strings_Input3 = NULL;
int m3n3 = 0; /* m3 * n3 */
if (VarType(3) != sci_strings)
{
Scierror(999, _("%s: Wrong type for input argument #%d: Character expected.\n"), fname, 3);
return 0;
}
GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &m3, &n3, &Strings_Input3);
m3n3 = m3 * n3;
if (m3n3 != 1)
{
freeArrayOfString(Strings_Input3, m3n3);
Scierror(999, _("%s: Wrong type for input argument #%d: Character expected.\n"), fname, 3);
return 0;
}
if ( (strcmp(Strings_Input3[0], CHAR_R) == 0) || (strcmp(Strings_Input3[0], CHAR_S) == 0) )
{
if (strcmp(Strings_Input3[0], CHAR_R) == 0)
{
bStrindex_with_pattern = TRUE;
}
else
{
bStrindex_with_pattern = FALSE;
}
freeArrayOfString(Strings_Input3, m3n3);
}
else
{
freeArrayOfString(Strings_Input3, m3n3);
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 3, CHAR_S, CHAR_R);
return 0;
}
}
if (VarType(1) == sci_matrix)
{
int m1 = 0;
int n1 = 0;
int l1 = 0;
GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
if ((m1 == 0) && (n1 == 0))
{
CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
LhsVar(1) = Rhs + 1 ;
PutLhsVar();
return 0;
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings or empty matrix expected.\n"), fname, 1);
return 0;
}
}
if ( (VarType(1) == sci_strings) && (VarType(2) == sci_strings) )
{
int m1 = 0, n1 = 0;
char **Strings_Input1 = NULL;
wchar_t *wStrings_Input1 = NULL;
int m1n1 = 0; /* m1 * n1 */
int m2 = 0, n2 = 0;
char **Strings_Input2 = NULL;
wchar_t **wStrings_Input2 = NULL;
int m2n2 = 0; /* m2 * n2 */
In *values = NULL;
int nbValues = 0;
int nbposition = 0;
int i = 0;
GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, &Strings_Input1);
m1n1 = m1 * n1;
if (m1n1 != 1)
{
freeArrayOfString(Strings_Input1, m1n1);
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
wStrings_Input1 = to_wide_string(Strings_Input1[0]);
if (wStrings_Input1 == NULL)
{
/* string conversion fails */
freeArrayOfString(Strings_Input1, m1n1);
freeArrayOfString(Strings_Input2, m2n2);
Scierror(999, _("%s: Wrong value for input argument #%d: A valid string expected (UTF-8 Encoding problem).\n"), fname, 1);
return 0;
}
GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &m2, &n2, &Strings_Input2);
m2n2 = m2 * n2;
if ( (m2 != 1) && (n2 != 1) )
{
freeArrayOfString(Strings_Input1, m1n1);
freeArrayOfString(Strings_Input2, m2n2);
Scierror(999, _("%s: Wrong type for input argument #%d: Row vector of strings or column vector of strings expected.\n"), fname, 2);
return 0;
}
wStrings_Input2 = (wchar_t**)MALLOC(m2n2 * sizeof(wchar_t*));
for (i = 0 ; i < m2n2 ; i++)
{
wStrings_Input2[i] = to_wide_string(Strings_Input2[i]);
}
if ( (int)wcslen(wStrings_Input1) == 0 )
{
values = (In*)MALLOC(sizeof(In));
}
else
{
values = (In *)MALLOC( sizeof(In) * ( wcslen(wStrings_Input1) ) * m2n2);
}
if (bStrindex_with_pattern)
{
int x = 0;
pcre_error_code answer = PCRE_FINISHED_OK;
int Output_Start = 0;
int Output_End = 0;
int wcOutput_Start = 0;
int wcstart_point = 0;
int wcOutput_End = 0;
for (x = 0; x < m2n2; ++x)
{
char *save = strdup(Strings_Input2[x]);
if (save)
{
char *pointer = Strings_Input1[0];
wcstart_point = 0;
do
{
strcpy(save, Strings_Input2[x]);
Output_Start = 0;
Output_End = 0;
answer = pcre_private(pointer, save, &Output_Start, &Output_End, NULL, NULL);
if ( answer == PCRE_FINISHED_OK )
{
/* Start = End means that we matched a position and 0 characters.
* Matching 0 characters, for us, means no match.
*/
if (Output_Start != Output_End)
{
char * strOutput_Start = strdup(pointer);
char * strOutput_End = strdup(pointer);
wchar_t *wcstrOutput_Start = NULL;
wchar_t *wcstrOutput_End = NULL;
/* calculates positions with wide characters */
strOutput_Start[Output_Start] = '\0';
strOutput_End[Output_End] = '\0';
wcstrOutput_Start = to_wide_string(strOutput_Start);
wcstrOutput_End = to_wide_string(strOutput_End);
if (wcstrOutput_Start)
{
wcOutput_Start = (int)wcslen(wcstrOutput_Start);
FREE(wcstrOutput_Start);
}
else
{
wcOutput_Start = 0;
}
if (wcstrOutput_End)
{
wcOutput_End = (int)wcslen(wcstrOutput_End);
FREE(wcstrOutput_End);
}
else
{
wcOutput_End = 0;
}
FREE(strOutput_Start);
FREE(strOutput_End);
/*adding the answer into the outputmatrix*/
values[nbValues].data = wcOutput_Start + wcstart_point + 1;
values[nbValues].position = x + 1;
nbValues++;
}
else if (Output_End == 0 && *pointer != '\0')
{
/* Avoid an infinite loop */
pointer++;
}
pointer = &pointer[Output_End];
wcstart_point = wcstart_point + wcOutput_End;
}
else
{
if (answer != NO_MATCH)
{
pcre_error(fname, answer);
freeArrayOfString(Strings_Input1, m1n1);
freeArrayOfString(Strings_Input2, m2n2);
return 0;
}
}
}
while ( (answer == PCRE_FINISHED_OK) && (*pointer != '\0'));
if (save)
{
FREE(save);
save = NULL;
}
}
else
{
freeArrayOfString(Strings_Input1, m1n1);
freeArrayOfString(Strings_Input2, m2n2);
Scierror(999, _("%s: No more memory.\n"), fname);
return 0;
}
}
sort_inert(values, values + nbValues, cmp);
}
else
{
/* We don't use pcre library */
int x = 0;
for (x = 0; x < m2n2 ; ++x)
{
if ( wcslen(wStrings_Input2[x]) == 0 )
{
freeArrayOfWideString(wStrings_Input2, m2n2);
freeArrayOfString(Strings_Input2, m2n2);
freeArrayOfString(Strings_Input1, m1n1);
if (next)
{
FREE(next);
next = NULL;
}
if (values)
{
FREE(values);
values = NULL;
}
Scierror(999, _("%s: Wrong size for input argument #%d: Non-empty string expected.\n"), fname, 2);
return 0;
}
if (Strings_Input2)
{
wchar_t *pCur = wStrings_Input1;
do
{
pCur = wcsstr(pCur, wStrings_Input2[x]);
if (pCur != NULL)
{
pCur++;
values[nbValues++].data = (int)(pCur - wStrings_Input1);
values[nbposition++].position = x + 1;
}
}
while (pCur != NULL && *pCur != 0); //Plus tard
/* values are sorted */
sort_inert(values, values + nbValues, cmp);
}
}
}
FREE(wStrings_Input1);
freeArrayOfWideString(wStrings_Input2, m2n2);
freeArrayOfString(Strings_Input1, m1n1);
freeArrayOfString(Strings_Input2, m2n2);
numRow = 1;
outIndex = 0;
CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &numRow, &nbValues, &outIndex);
for ( i = 0 ; i < nbValues ; i++ )
{
stk(outIndex)[i] = (double)values[i].data ;
}
LhsVar(1) = Rhs + 1 ;
if (Lhs == 2)
{
numRow = 1;
outIndex = 0;
CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &numRow, &nbValues, &outIndex);
for ( i = 0 ; i < nbValues ; i++ )
{
stk(outIndex)[i] = (double)values[i].position ;
}
LhsVar(2) = Rhs + 2;
}
if (values)
{
FREE(values);
values = NULL;
}
PutLhsVar();
}
else
{
if (VarType(1) != sci_strings)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: Row vector of strings or column vector of strings expected.\n"), fname, 2);
}
return 0;
}
return 0;
}
/*------------------------------------------------------------------------*/
int sci_strindex(char *fname,unsigned long fname_len)
{
BOOL bStrindex_with_pattern = FALSE;
int outIndex = 0;
int numRow = 1;
int *next = NULL;
CheckRhs(2,3);
CheckLhs(1,2);
if (Rhs == 3)
{
int m3 = 0;
int n3 = 0;
char **Strings_Input3 = NULL;
int m3n3 = 0; /* m3 * n3 */
if (VarType(3) != sci_strings)
{
Scierror(999,_("%s: Wrong type for input argument #%d: Character expected.\n"),fname,3);
return 0;
}
GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &m3, &n3, &Strings_Input3);
m3n3 = m3 * n3;
if (m3n3 != 1)
{
freeArrayOfString(Strings_Input3, m3n3);
Scierror(999,_("%s: Wrong type for input argument #%d: Character expected.\n"), fname, 3);
return 0;
}
if ( (strcmp(Strings_Input3[0],CHAR_R) == 0) || (strcmp(Strings_Input3[0],CHAR_S) == 0) )
{
if (strcmp(Strings_Input3[0],CHAR_R) == 0)
{
bStrindex_with_pattern = TRUE;
}
else
{
bStrindex_with_pattern = FALSE;
}
freeArrayOfString(Strings_Input3, m3n3);
}
else
{
freeArrayOfString(Strings_Input3, m3n3);
Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"),fname,3,CHAR_S,CHAR_R);
return 0;
}
}
if (VarType(1) == sci_matrix)
{
int m1 = 0;
int n1 = 0;
int l1 = 0;
GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
if ((m1 == 0) && (n1 == 0))
{
CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
LhsVar(1) = Rhs+1 ;
PutLhsVar();
return 0;
}
else
{
Scierror(999,_("%s: Wrong type for input argument #%d: Matrix of strings or empty matrix expected.\n"),fname,3);
return 0;
}
}
if ( (VarType(1) == sci_strings) && (VarType(2) == sci_strings) )
{
int m1 = 0, n1 = 0;
char **Strings_Input1 = NULL;
wchar_t *wStrings_Input1 = NULL;
int m1n1 = 0; /* m1 * n1 */
int m2 = 0, n2 = 0;
char **Strings_Input2 = NULL;
wchar_t **wStrings_Input2 = NULL;
int m2n2 = 0; /* m2 * n2 */
struct In *values=NULL;
int nbValues = 0;
int nbposition = 0;
int i = 0;
GetRhsVar(1,MATRIX_OF_STRING_DATATYPE,&m1,&n1,&Strings_Input1);
m1n1 = m1*n1;
if (m1n1 != 1)
{
freeArrayOfString(Strings_Input1,m1n1);
Scierror(999,_("%s: Wrong size for input argument #%d: A string expected.\n"),fname,1);
return 0;
}
wStrings_Input1 = to_wide_string(Strings_Input1[0]);
if (wStrings_Input1 == NULL)
{
/* string conversion fails */
freeArrayOfString(Strings_Input1,m1n1);
freeArrayOfString(Strings_Input2,m2n2);
Scierror(999,_("%s: Wrong value for input argument #%d: A valid string expected (UTF-8 Encoding problem).\n"),fname,1);
return 0;
}
GetRhsVar(2,MATRIX_OF_STRING_DATATYPE,&m2,&n2,&Strings_Input2);
m2n2 = m2*n2;
if ( (m2 != 1) && (n2 != 1) )
{
freeArrayOfString(Strings_Input1,m1n1);
freeArrayOfString(Strings_Input2,m2n2);
Scierror(999,_("%s: Wrong type for input argument #%d: Row vector of strings or column vector of strings expected.\n"),fname,2);
return 0;
}
wStrings_Input2 = (wchar_t**)MALLOC(m2n2 * sizeof(wchar_t*));
for(i = 0 ; i < m2n2 ; i++)
{
wStrings_Input2[i] = to_wide_string(Strings_Input2[i]);
}
if ( (int)wcslen(wStrings_Input1) == 0 )
{
values= (struct In*)MALLOC(sizeof(struct In));
}
else
{
values = (struct In *)MALLOC( sizeof(struct In) * ( wcslen(wStrings_Input1) ) * m2n2);
}
if (bStrindex_with_pattern)
{
int x = 0;
pcre_error_code w = PCRE_FINISHED_OK;
int Output_Start = 0;
int Output_End = 0;
/* We use pcre library */
for (x = 0; x < m2n2; ++x)
{
w = pcre_private(Strings_Input1[0],Strings_Input2[x],&Output_Start,&Output_End);
if ( w == PCRE_FINISHED_OK)
{
char *partStr = strdup(Strings_Input1[0]);
wchar_t *wcpartStr = NULL;
partStr[Output_Start] = '\0';
wcpartStr = to_wide_string(partStr);
values[nbValues++].data = (int)wcslen(wcpartStr) + 1; /* adding the answer into the outputmatrix */
values[nbposition++].position = x+1; /* The number according to the str2 matrix */
if (partStr) {FREE(partStr); partStr = NULL;}
if (wcpartStr) {FREE(wcpartStr); wcpartStr = NULL;}
}
else
{
if (w != NO_MATCH)
{
freeArrayOfString(Strings_Input1,m1n1);
freeArrayOfString(Strings_Input2,m2n2);
pcre_error(fname,w);
return 0;
}
break;
}
}
qsort(values,nbValues,sizeof(values[0]),cmp);
}
else
{
/* We don't use pcre library */
int x = 0;
for (x=0; x < m2n2 ;++x)
{
if ( wcslen(wStrings_Input2[x]) == 0 )
{
freeArrayOfString(Strings_Input2,m2n2);
freeArrayOfString(Strings_Input1,m1n1);
if (next) {FREE(next); next = NULL;}
if (values) {FREE(values); values = NULL;}
Scierror(999, _("%s: Wrong size for input argument #%d: Non-empty string expected.\n"), fname,2);
return 0;
}
if (Strings_Input2)
{
wchar_t *pCur = wStrings_Input1;
do
{
pCur = wcsstr(pCur, wStrings_Input2[x]);
if (pCur != NULL)
{
pCur++;
values[nbValues++].data = (int)(pCur - wStrings_Input1);
values[nbposition++].position = x+1;
}
}
while(pCur != NULL && *pCur != 0);//Plus tard
/* values are sorted */
qsort(values,nbValues,sizeof(values[0]),cmp);
}
}
}
FREE(wStrings_Input1);
freeArrayOfWideString(wStrings_Input2, m2n2);
freeArrayOfString(Strings_Input1,m1n1);
freeArrayOfString(Strings_Input2,m2n2);
numRow = 1;
outIndex = 0;
CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,&numRow,&nbValues,&outIndex);
for ( i = 0 ; i < nbValues ; i++ )
{
stk(outIndex)[i] = (double)values[i].data ;
}
LhsVar(1) = Rhs+1 ;
if (Lhs == 2)
{
numRow = 1;
outIndex = 0;
CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&numRow,&nbposition,&outIndex);
for ( i = 0 ; i < nbposition ; i++ )
{
stk(outIndex)[i] = (double)values[i].position ;
}
LhsVar(2) = Rhs+2;
}
if (values) {FREE(values); values = NULL;}
PutLhsVar();
}
else
{
if(VarType(1) != sci_strings)
{
Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"),fname,1);
}
else
{
Scierror(999,_("%s: Wrong type for input argument #%d: Row vector of strings or column vector of strings expected.\n"),fname,2);
}
return 0;
}
return 0;
}
