utf: module string 2 58/18658/1
Antoine ELIAS [Wed, 13 Jan 2016 08:02:46 +0000 (09:02 +0100)]
Change-Id: I745ce61fa47f0d4290263ed547b5adb2578b57a4

42 files changed:
scilab/modules/string/Makefile.am
scilab/modules/string/includes/StringConvert.h
scilab/modules/string/includes/pcre_private.h
scilab/modules/string/includes/stringToComplex.h
scilab/modules/string/includes/stringToDouble.h
scilab/modules/string/includes/strsubst.h
scilab/modules/string/sci_gateway/cpp/sci_ascii.cpp
scilab/modules/string/sci_gateway/cpp/sci_grep.cpp
scilab/modules/string/sci_gateway/cpp/sci_isascii.cpp
scilab/modules/string/sci_gateway/cpp/sci_length.cpp
scilab/modules/string/sci_gateway/cpp/sci_regexp.cpp
scilab/modules/string/sci_gateway/cpp/sci_strcat.cpp
scilab/modules/string/sci_gateway/cpp/sci_strchr.cpp
scilab/modules/string/sci_gateway/cpp/sci_strindex.cpp
scilab/modules/string/sci_gateway/cpp/sci_strncpy.cpp
scilab/modules/string/sci_gateway/cpp/sci_strrchr.cpp
scilab/modules/string/sci_gateway/cpp/sci_strspn.cpp
scilab/modules/string/sci_gateway/cpp/sci_tokens.cpp
scilab/modules/string/src/c/StringConvert.c
scilab/modules/string/src/c/convstr.c [deleted file]
scilab/modules/string/src/c/convstr.h [deleted file]
scilab/modules/string/src/c/isalphanum.c
scilab/modules/string/src/c/isascii.c
scilab/modules/string/src/c/isascii.h
scilab/modules/string/src/c/isdigit.c
scilab/modules/string/src/c/isletter.c
scilab/modules/string/src/c/isletter.h
scilab/modules/string/src/c/isnum.c
scilab/modules/string/src/c/isnum.h
scilab/modules/string/src/c/partfunction.c
scilab/modules/string/src/c/partfunction.h
scilab/modules/string/src/c/pcre_private.c
scilab/modules/string/src/c/string.vcxproj
scilab/modules/string/src/c/string.vcxproj.filters
scilab/modules/string/src/c/stringToComplex.c
scilab/modules/string/src/c/stringToDouble.c
scilab/modules/string/src/c/stringsstrrev.c
scilab/modules/string/src/c/stringsstrrev.h
scilab/modules/string/src/c/strsplit.c
scilab/modules/string/src/c/strsubst.c
scilab/modules/string/src/c/tokens.c
scilab/modules/string/src/c/tokens.h

index 180f6cd..c35272a 100644 (file)
@@ -9,7 +9,6 @@ STRING_CPP_SOURCES = \
     src/cpp/os_wtoi.cpp
 
 STRING_C_SOURCES = \
-    src/c/convstr.c \
     src/c/men_Sutils.c \
     src/c/tokens.c \
     src/c/strsplit.c \
@@ -150,7 +149,6 @@ libscistring_la_sci_gateway_DATA = sci_gateway/string_gateway.xml
 libscistring_la_includedir=$(pkgincludedir)
 libscistring_la_include_HEADERS = \
 includes/complex_array.h \
-includes/convstr.h \
 includes/cvstr.h \
 includes/dynlib_string_gw.h \
 includes/dynlib_string.h \
index 2d7268e..86ccf4d 100644 (file)
@@ -22,6 +22,5 @@
 * @return number of \n found
 */
 STRING_IMPEXP int StringConvert(char *str);
-STRING_IMPEXP int StringConvertW(wchar_t *str);
 
 #endif /* __STRINGCONVERT_H__ */
index c9b9875..dddd7fa 100644 (file)
@@ -36,8 +36,7 @@ typedef enum
 } pcre_error_code;
 
 
-STRING_IMPEXP pcre_error_code pcre_private(char *INPUT_LINE, char *INPUT_PAT, int *Output_Start, int *Output_End, char*** _pstCapturedString, int* _piCapturedStringCount);
-STRING_IMPEXP pcre_error_code wide_pcre_private(wchar_t *INPUT_LINE, wchar_t *INPUT_PAT, int *Output_Start, int *Output_End, wchar_t*** _pstCapturedString, int* _piCapturedStringCount);
+STRING_IMPEXP pcre_error_code pcre_private(const char *INPUT_LINE, const char *INPUT_PAT, int *Output_Start, int *Output_End, char*** _pstCapturedString, int* _piCapturedStringCount);
 
 #endif /* __PCRE_PRIVATE_H__ */
 /*------------------------------------------------------------------------*/
index ad1435f..7246ffe 100644 (file)
@@ -39,11 +39,6 @@ extern "C" {
                                   BOOL bConvertByNAN,
                                   stringToComplexError *ierr);
 
-    doublecomplex stringToComplexW(const wchar_t *pSTR,
-                                   const wchar_t *decimal,
-                                   BOOL bConvertByNAN,
-                                   stringToComplexError *ierr);
-
     STRING_IMPEXP  complexArray *stringsToComplexArray(const char **pSTRs, int nbElements,
             const char *decimal,
             BOOL bConvertByNAN,
index 1eb6cf7..c61ef73 100644 (file)
 #include <wchar.h>
 
 #define NanString "Nan"
-#define NanStringW L"Nan"
 #define InfString "Inf"
-#define InfStringW L"Inf"
 #define NegInfString "-Inf"
-#define NegInfStringW L"-Inf"
 #define PosInfString "+Inf"
-#define PosInfStringW L"+Inf"
 #define NegNanString "-Nan" /* no sense but used by some users */
-#define NegNanStringW L"-Nan" /* no sense but used by some users */
 #define PosNanString "+Nan" /* no sense but used by some users */
-#define PosNanStringW L"+Nan" /* no sense but used by some users */
 #define ScilabNanString "%nan"
-#define ScilabNanStringW L"%nan"
 #define ScilabInfString "%inf"
-#define ScilabInfStringW L"%inf"
 #define ScilabNegInfString "-%inf"
-#define ScilabNegInfStringW L"-%inf"
 #define ScilabPosInfString "+%inf"
-#define ScilabPosInfStringW L"+%inf"
 #define ScilabNegNanString "-%nan" /* no sense but used by some users */
-#define ScilabNegNanStringW L"-%nan" /* no sense but used by some users */
 #define ScilabPosNanString "+%nan" /* no sense but used by some users */
-#define ScilabPosNanStringW L"+%nan" /* no sense but used by some users */
 #define ScilabPiString "%pi"
-#define ScilabPiStringW L"%pi"
 #define ScilabNegPiString "-%pi"
-#define ScilabNegPiStringW L"-%pi"
 #define ScilabPosPiString "+%pi"
-#define ScilabPosPiStringW L"+%pi"
 #define ScilabEString "%e"
-#define ScilabEStringW L"%e"
 #define ScilabPosEString "+%e"
-#define ScilabPosEStringW L"+%e"
 #define ScilabNegEString "-%e"
-#define ScilabNegEStringW L"-%e"
 #define ScilabEpsString "%eps"
-#define ScilabEpsStringW L"%eps"
 #define ScilabPosEpsString "+%eps"
-#define ScilabPosEpsStringW L"+%eps"
 #define ScilabNegEpsString "-%eps"
-#define ScilabNegEpsStringW L"-%eps"
 
 #ifdef __cplusplus
 extern "C" {
@@ -82,7 +61,6 @@ extern "C" {
      * @return <ReturnValue>
      */
     STRING_IMPEXP double stringToDouble(const char *pSTR, BOOL bConvertByNAN, stringToDoubleError *ierr);
-    STRING_IMPEXP double stringToDoubleW(const wchar_t *pSTR, BOOL bConvertByNAN, stringToDoubleError *ierr);
 
 #ifdef __cplusplus
 }
index 779ae33..4e20d14 100644 (file)
@@ -40,11 +40,4 @@ STRING_IMPEXP char **strsubst_reg(const char **strings_input, int strings_dim, c
 STRING_IMPEXP char *strsub(const char* input_string, const char* string_to_search, const char* replacement_string);
 STRING_IMPEXP char *strsub_reg(const char* input_string, const char* string_to_search, const char* replacement_string, int *ierr);
 
-
-STRING_IMPEXP wchar_t **wcssubst(const wchar_t** _pwstInput, int _iInputSize, const wchar_t* _pwstSearch, const wchar_t* _pwstReplace);
-STRING_IMPEXP wchar_t **wcssubst_reg(const wchar_t** _pwstInput, int _iInputSize, const wchar_t* _pwstSearch, const wchar_t* _pwstReplace, int* _piErr);
-
-STRING_IMPEXP wchar_t *wcssub(const wchar_t* _pwstInput, const wchar_t* _pwstSearch, const wchar_t* _pwstReplace);
-STRING_IMPEXP wchar_t *wcssub_reg(const wchar_t* _pwstInput, const wchar_t* _pwstSearch, const wchar_t* _pwstReplace, int* _piErr);
-
 #endif /* __STRSUBST_H__ */
index 40c78c6..1f46b6c 100644 (file)
@@ -151,26 +151,16 @@ types::Double* StringToDouble(types::String* _pst)
     int iTotalLen = 0;
     int iSize = _pst->getSize();
 
-    char** pst = new char*[iSize];
+    char** pst = _pst->get();
     int* pstLen = new int[iSize];
     for (int i = 0 ; i < iSize ; i++)
     {
-        pst[i] = os_strdup(_pst->get(i));
         pstLen[i] = (int)strlen(pst[i]);
         iTotalLen += pstLen[i];
     }
 
     if (iTotalLen == 0)
     {
-        for (int i = 0; i < iSize; ++i)
-        {
-            if (pst[i])
-            {
-                FREE(pst[i]);
-            }
-        }
-
-        delete[] pst;
         delete[] pstLen;
         return types::Double::Empty();
     }
@@ -188,11 +178,9 @@ types::Double* StringToDouble(types::String* _pst)
             //transform character value as double.
             pdbl[index] = (unsigned char)pst[i][j];
         }
-        FREE(pst[i]);
     }
 
     delete[] pstLen;
-    delete[] pst;
     return pOut;
 }
 /*--------------------------------------------------------------------------*/
index 347fdff..b2d32de 100644 (file)
@@ -121,38 +121,14 @@ types::Function::ReturnValue sci_grep(types::typed_list &in, int _iRetCount, typ
     grepresults.positions = NULL;
     grepresults.values = NULL;
 
-    char** pStr1 = (char**)MALLOC(sizeof(char*) * pS1->getSize());
-    for (int i = 0 ; i < pS1->getSize() ; i++)
-    {
-        pStr1[i] = os_strdup(pS1->get(i));
-    }
-
-    char** pStr2 = (char**)MALLOC(sizeof(char*) * pS2->getSize());
-    for (int i = 0 ; i < pS2->getSize() ; i++)
-    {
-        pStr2[i] = os_strdup(pS2->get(i));
-    }
-
     if (bRegularExpression)
     {
-        code_error_grep = GREP_NEW(&grepresults, pStr1, pS1->getSize(), pStr2, pS2->getSize());
+        code_error_grep = GREP_NEW(&grepresults, pS1->get(), pS1->getSize(), pS2->get(), pS2->getSize());
     }
     else
     {
-        code_error_grep = GREP_OLD(&grepresults, pStr1, pS1->getSize(), pStr2, pS2->getSize());
-    }
-
-    for (int i = 0; i < pS1->getSize(); i++)
-    {
-        FREE(pStr1[i]);
-    }
-    FREE(pStr1);
-
-    for (int i = 0; i < pS2->getSize(); i++)
-    {
-        FREE(pStr2[i]);
+        code_error_grep = GREP_OLD(&grepresults, pS1->get(), pS1->getSize(), pS2->get(), pS2->getSize());
     }
-    FREE(pStr2);
 
     switch (code_error_grep)
     {
@@ -289,7 +265,6 @@ types::Function::ReturnValue sci_grep(types::typed_list &in, int _iRetCount, typ
 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;
     int iRet = GREP_OK;
     pcre_error_code answer = PCRE_FINISHED_OK;
     for (x = 0; x <  mn_one ; x++)
@@ -322,8 +297,7 @@ static int GREP_NEW(GREPRESULTS *results, char **Inputs_param_one, int mn_one, c
         {
             int Output_Start = 0;
             int Output_End = 0;
-            save = os_strdup(Inputs_param_two[x]);
-            answer = pcre_private(Inputs_param_one[y], save, &Output_Start, &Output_End, NULL, NULL);
+            answer = pcre_private(Inputs_param_one[y], Inputs_param_two[x], &Output_Start, &Output_End, NULL, NULL);
 
             if ( answer == PCRE_FINISHED_OK )
             {
@@ -339,12 +313,6 @@ static int GREP_NEW(GREPRESULTS *results, char **Inputs_param_one, int mn_one, c
                 pcre_error("grep", answer);
                 iRet = GREP_ERROR;
             }
-
-            if (save)
-            {
-                FREE(save);
-                save = NULL;
-            }
         }
     }
 
index 6420f75..3144dad 100644 (file)
@@ -57,7 +57,7 @@ types::Function::ReturnValue sci_isascii(types::typed_list &in, int _iRetCount,
         }
 
         int iResultSize = 0;
-        int* pbResult = (int*)isasciiStringW((wchar_t*)s.c_str(), &iResultSize);
+        int* pbResult = (int*)isasciiString(s.c_str(), &iResultSize);
         if (pbResult == NULL)
         {
             out.push_back(types::Double::Empty());
index c65ca22..ae87fdc 100644 (file)
@@ -112,7 +112,7 @@ static types::Double* lengthStrings(types::String* _pS)
 
     for (int i = 0 ; i < _pS->getSize() ; i++)
     {
-        pdbl[i] = static_cast<double>(strlen(pst[i]));
+        pdbl[i] = static_cast<double>(get_codepoint_count(pst[i]));
     }
     return pD;
 }
index 5107339..7bd0f23 100644 (file)
@@ -46,6 +46,7 @@ types::Function::ReturnValue sci_regexp(types::typed_list &in, int _iRetCount, t
     int iPcreStatus = 0;
     int iStart = 0;
     int iStep = 0;
+    int iwStep = 0;
     int iEnd = 0;
     int* piStart = NULL;
     int* piEnd = NULL;
@@ -133,9 +134,28 @@ types::Function::ReturnValue sci_regexp(types::typed_list &in, int _iRetCount, t
         {
             if (iEnd != iStart)
             {
-                piStart[iOccurs]    = iStart + iStep;
-                piEnd[iOccurs++]    = iEnd + iStep;
-                iStep               += iEnd;
+                //convert strat and end to codepoint value
+                char* pstTempStart = NULL;
+                char* pstTempEnd = NULL;
+                wchar_t* pwstTempStart = NULL;
+                wchar_t* pwstTempEnd = NULL;
+
+                pstTempStart = os_strdup(pstInput + iStep);
+                pstTempEnd = os_strdup(pstInput + iStep);
+                pstTempEnd[iEnd] = 0;
+                pstTempStart[iStart] = 0;
+
+
+                pwstTempStart = to_wide_string(pstTempStart);
+                pwstTempEnd = to_wide_string(pstTempEnd);
+
+                int iwStart = (int)wcslen(pwstTempStart);
+                int iwEnd = (int)wcslen(pwstTempEnd);
+
+                piStart[iOccurs] = iwStart + iwStep;
+                piEnd[iOccurs++] = iwEnd + iwStep;
+                iStep += iEnd;
+                iwStep += iwEnd;
             }
             else if (iEnd == 0 && pstInput[iStep] != '\0')
             {
@@ -220,11 +240,15 @@ types::Function::ReturnValue sci_regexp(types::typed_list &in, int _iRetCount, t
             pS = new types::String(iOccurs, 1);
             for (int i = 0 ; i < iOccurs ; i++)
             {
-                char* pstTemp = new char[piEnd[i] - piStart[i] + 1];
-                strncpy(pstTemp, pstInput + piStart[i], piEnd[i] - piStart[i]);
-                pstTemp[piEnd[i] - piStart[i]] = 0;
+                wchar_t* pwstTemp = new wchar_t[piEnd[i] - piStart[i] + 1];
+                wchar_t* pwstInput = to_wide_string(pstInput);
+                wcsncpy(pwstTemp, pwstInput + piStart[i], piEnd[i] - piStart[i]);
+                pwstTemp[piEnd[i] - piStart[i]] = 0;
+                char* pstTemp = wide_string_to_UTF8(pwstTemp);
                 pS->set(i, 0, pstTemp);
                 delete[] pstTemp;
+                delete[] pwstInput;
+                delete[] pwstTemp;
             }
         }
         out.push_back(pS);
index a699796..2628ec0 100644 (file)
@@ -80,13 +80,13 @@ types::Function::ReturnValue sci_strcat(types::typed_list &in, int _iRetCount, t
 
     if (in.size() == 3)
     {
-        wchar_t wcMode = in[2]->getAs<types::String>()->get(0)[0];
-        switch (wcMode)
+        char mode = in[2]->getAs<types::String>()->get(0)[0];
+        switch (mode)
         {
-            case L'r' :
+            case 'r' :
                 iMode = 1;
                 break;
-            case L'c' :
+            case 'c' :
                 iMode = 2;
                 break;
             default :
index 3309be0..6602df8 100644 (file)
@@ -84,43 +84,40 @@ types::Function::ReturnValue sci_strchr(types::typed_list &in, int _iRetCount, t
         {
             j = i; /* Input parameter One & two have same dimension */
         }
-        int iLen = (int)strlen(pCharSample->get(j));
+
+        wchar_t* s = to_wide_string(pCharSample->get()[j]);
+        int iLen = (int)wcslen(s);
         if (iLen != 1)
         {
+            FREE(s);
             Scierror(999, _("%s: Wrong type for input argument #%d: Char(s) expected.\n"), "strchr", 2);
             delete pOutString;
             return types::Function::Error;
         }
 
-        if (strlen(pString->get(i)) < strlen(pCharSample->get(j)))
+
+        wchar_t* w = to_wide_string(pString->get()[i]);
+        if (wcslen(w) < wcslen(s))
         {
             pOutString->set(i, "");
         }
         else
         {
-            char* ptrstrstr = strchr(pString->get(i), pCharSample->get(j)[0]);
-            if (ptrstrstr)
+            wchar_t* sc = wcschr(w, s[0]);
+            if (sc)
             {
-                pOutString->set(i, ptrstrstr);
-                if (pOutString->get(i) == NULL)
-                {
-                    delete pOutString;
-                    FREE(ptrstrstr);
-                    Scierror(999, _("%s: No more memory.\n"), "strchr");
-                    return types::Function::Error;
-                }
+                char* output = wide_string_to_UTF8(sc);
+                pOutString->set(i, output);
+                FREE(output);
             }
             else
             {
                 pOutString->set(i, "");
-                if (pOutString->get(i) == NULL)
-                {
-                    delete pOutString;
-                    Scierror(999, _("%s: No more memory.\n"), "strchr");
-                    return types::Function::Error;
-                }
             }
         }
+
+        FREE(w);
+        FREE(s);
     }
 
     out.push_back(pOutString);
index fb67ce9..9791320 100644 (file)
@@ -125,20 +125,40 @@ types::Function::ReturnValue sci_strindex(types::typed_list &in, int _iRetCount,
     {
         //pcre
         pcre_error_code iPcreStatus = PCRE_FINISHED_OK;
-        for (int i = 0 ; i < pS->getSize() ; i++)
+        for (int i = 0; i < pS->getSize(); i++)
         {
-            int iStart      = 0;
-            int iEnd        = 0;
-            int iStep       = 0;
+            int iStart = 0;
+            int iEnd = 0;
+            int iStep = 0;
+            int iwStep = 0;
 
             do
             {
                 iPcreStatus = pcre_private(pstData + iStep, pstSearch[i], &iStart, &iEnd, NULL, NULL);
                 if (iPcreStatus == PCRE_FINISHED_OK)
                 {
-                    pstrResult[iValues].data        = iStart + iStep + 1;
-                    pstrResult[iValues].position    = i + 1;
-                    iStep                           += iEnd;
+                    //convert strat and end to codepoint value
+                    char* pstTempStart = NULL;
+                    char* pstTempEnd = NULL;
+                    wchar_t* pwstTempStart = NULL;
+                    wchar_t* pwstTempEnd = NULL;
+
+                    pstTempStart = os_strdup(pstData + iStep);
+                    pstTempEnd = os_strdup(pstData + iStep);
+                    pstTempEnd[iEnd] = 0;
+                    pstTempStart[iStart] = 0;
+
+
+                    pwstTempStart = to_wide_string(pstTempStart);
+                    pwstTempEnd = to_wide_string(pstTempEnd);
+
+                    int iwStart = (int)wcslen(pwstTempStart);
+                    int iwEnd = (int)wcslen(pwstTempEnd);
+
+                    pstrResult[iValues].data = iwStart + iwStep + 1;
+                    pstrResult[iValues].position = i + 1;
+                    iStep += iEnd;
+                    iwStep += iwEnd;
                     iValues++;
                 }
                 else
@@ -151,27 +171,30 @@ types::Function::ReturnValue sci_strindex(types::typed_list &in, int _iRetCount,
                     }
                     break;
                 }
-            }
-            while (iPcreStatus == PCRE_FINISHED_OK && iStart != iEnd);
+            } while (iPcreStatus == PCRE_FINISHED_OK && iStart != iEnd);
         }
     }
     else
     {
         for (int i = 0 ; i < pS->getSize() ; i++)
         {
-            char* pCur = pstData;
+            wchar_t* pwstData = to_wide_string(pstData);
+            wchar_t* pCur = pwstData;
+            wchar_t* pwstSearch = to_wide_string(pstSearch[i]);
             do
             {
-                pCur = strstr(pCur, pstSearch[i]);
+                pCur = wcsstr(pCur, pwstSearch);
                 if (pCur != NULL)
                 {
-                    pstrResult[iValues].data      = (int)(pCur - pstData + 1);
+                    pstrResult[iValues].data      = (int)(pCur - pwstData + 1);
                     pstrResult[iValues].position  = i + 1;
                     pCur++;
                     iValues++;
                 }
-            }
-            while (pCur != NULL && pCur[0] != L'\0');
+            } while (pCur != NULL && pCur[0] != L'\0');
+
+            FREE(pwstSearch);
+            FREE(pwstData);
         }
     }
 
index dcf6d83..d5ff868 100644 (file)
@@ -76,7 +76,8 @@ types::Function::ReturnValue sci_strncpy(types::typed_list &in, int _iRetCount,
     int j = 0; /* Input parameter two is dimension one */
     for (int i = 0 ; i < pString->getSize() ; i++)
     {
-        char* output   = NULL;
+        wchar_t* input = to_wide_string(pString->get(i));
+        wchar_t* output   = NULL;
         int sizeOfCopy      = 0;
 
         if (pDouble->isScalar() == false)
@@ -84,7 +85,7 @@ types::Function::ReturnValue sci_strncpy(types::typed_list &in, int _iRetCount,
             j = i; /* Input parameter One & two have same dimension */
         }
 
-        if (pDouble->get(j) < strlen(pString->get(i)))
+        if (pDouble->get(j) < wcslen(input))
         {
             int iLen = (int)pDouble->get(j);
             if (iLen < 0)
@@ -92,27 +93,31 @@ types::Function::ReturnValue sci_strncpy(types::typed_list &in, int _iRetCount,
                 iLen = 0;
             }
 
-            output = (char*)MALLOC(sizeof(char) * (iLen + 1));
+            output = (wchar_t*)MALLOC(sizeof(wchar_t) * (iLen + 1));
             sizeOfCopy = iLen;
         }
         else
         {
-            int iLen = (int)strlen(pString->get(i));
-            output = (char*)MALLOC(sizeof(char) * (iLen + 1));
+            int iLen = (int)wcslen(input);
+            output = (wchar_t*)MALLOC(sizeof(wchar_t) * (iLen + 1));
             sizeOfCopy = iLen;
         }
 
         if (output)
         {
-            strncpy(output, pString->get(i), sizeOfCopy);
+            wcsncpy(output, input, sizeOfCopy);
             output[sizeOfCopy] = '\0';
 
-            pOutString->set(i, output);
+            char* o = wide_string_to_UTF8(output);
+            pOutString->set(i, o);
+            FREE(input);
+            FREE(o);
             FREE(output);
             output = NULL;
         }
         else
         {
+            FREE(input);
             delete pOutString;
             Scierror(999, _("%s: No more memory.\n"), "strncpy");
             return types::Function::Error;
index b376a05..ee8368c 100644 (file)
@@ -87,43 +87,40 @@ types::Function::ReturnValue sci_strrchr(types::typed_list &in, int _iRetCount,
         {
             j = i; /* Input parameter One & two have same dimension */
         }
-        int iLen = (int)strlen(pCharSample->get(j));
+
+        wchar_t* s = to_wide_string(pCharSample->get()[j]);
+        int iLen = (int)wcslen(s);
         if (iLen != 1)
         {
+            FREE(s);
             Scierror(999, _("%s: Wrong type for input argument #%d: Char(s) expected.\n"), "strrchr", 2);
             delete pOutString;
             return types::Function::Error;
         }
 
-        if (strlen(pString->get(i)) < strlen(pCharSample->get(j)))
+        wchar_t* w = to_wide_string(pString->get()[i]);
+        if (wcslen(w) < wcslen(s))
         {
             pOutString->set(i, "");
         }
         else
         {
+            wchar_t* sc = wcsrchr(w, s[0]);
             char* ptrstrstr = strrchr(pString->get(i), pCharSample->get(j)[0]);
-            if (ptrstrstr)
+            if (sc)
             {
-                pOutString->set(i, ptrstrstr);
-                if (pOutString->get(i) == NULL)
-                {
-                    delete pOutString;
-                    FREE(ptrstrstr);
-                    Scierror(999, _("%s: No more memory.\n"), "strrchr");
-                    return types::Function::Error;
-                }
+                char* output = wide_string_to_UTF8(sc);
+                pOutString->set(i, output);
+                FREE(output);
             }
             else
             {
                 pOutString->set(i, "");
-                if (pOutString->get(i) == NULL)
-                {
-                    delete pOutString;
-                    Scierror(999, _("%s: No more memory.\n"), "strrchr");
-                    return types::Function::Error;
-                }
             }
         }
+
+        FREE(w);
+        FREE(s);
     }
 
     out.push_back(pOutString);
index 85f426f..7a10a78 100644 (file)
@@ -71,7 +71,12 @@ types::Function::ReturnValue sci_strspn(types::typed_list &in, int _iRetCount, t
             j = i;
         }
 
-        pOutDouble->set(i, (double)strspn( pString->get(i), pStrSample->get(j)));
+        wchar_t* w = to_wide_string(pString->get()[i]);
+        wchar_t* s = to_wide_string(pStrSample->get()[j]);
+
+        pOutDouble->set(i, (double)wcsspn(w, s));
+        FREE(s);
+        FREE(w);
     }
 
     out.push_back(pOutDouble);
index 877278b..105c634 100644 (file)
@@ -26,6 +26,7 @@ extern "C"
 #include "core_math.h"
 #include "localization.h"
 #include "Scierror.h"
+#include "charEncoding.h"
 }
 
 #include <sciprint.h>
@@ -35,8 +36,9 @@ types::Function::ReturnValue sci_tokens(types::typed_list &in, int _iRetCount, t
     types::String* pOutString   = NULL;
     types::String* pString      = NULL;
     types::String* pCharSample  = NULL;
-    char* seps                  = NULL;
-    int sizeSeps                = 0;
+    wchar_t* seps = NULL;
+    wchar_t* input = NULL;
+    int sizeSeps = 0;
 
     if (in.size() > 2 || in.size() == 0)
     {
@@ -84,25 +86,30 @@ types::Function::ReturnValue sci_tokens(types::typed_list &in, int _iRetCount, t
             return types::Function::Error;
         }
         sizeSeps = pCharSample->getSize();
-        seps = (char*)MALLOC((sizeSeps + 1) * sizeof(char));
+        seps = (wchar_t*)MALLOC((sizeSeps + 1) * sizeof(wchar_t));
         for (int i = 0; i < sizeSeps ; i++)
         {
-            int iLen = (int)strlen(pCharSample->get(i));
+            wchar_t* t = to_wide_string(pCharSample->get()[i]);
+            int iLen = (int)wcslen(t);
             if (iLen > 1 || iLen < 0)
             {
+                FREE(t);
+                FREE(seps);
                 Scierror(999, _("%s: Wrong type for input argument #%d: Char(s) expected.\n"), "tokens", 2);
                 delete pOutString;
                 return types::Function::Error;
             }
-            seps[i] = pCharSample->get(i)[0];
+
+            seps[i] = t[0];
+            FREE(t);
         }
     }
     else // default delimiters are ' ' and Tabulation
     {
         sizeSeps = 2;
-        seps = (char*)MALLOC((sizeSeps + 1) * sizeof(char));
-        seps[0] = ' ';
-        seps[1] = '\t';
+        seps = (wchar_t*)MALLOC((sizeSeps + 1) * sizeof(wchar_t));
+        seps[0] = L' ';
+        seps[1] = L'\t';
     }
 
     seps[sizeSeps] = '\0';
@@ -111,7 +118,8 @@ types::Function::ReturnValue sci_tokens(types::typed_list &in, int _iRetCount, t
     int dimsArray[2] = {0, 1};
     int dims = 2;
 
-    char** Output_Strings = stringTokens(pString->get(0), seps, &dimsArray[0]);
+    input = to_wide_string(pString->get()[0]);
+    wchar_t** Output_Strings = stringTokens(input, seps, &dimsArray[0]);
     FREE(seps);
     if (Output_Strings == NULL)
     {
@@ -122,11 +130,12 @@ types::Function::ReturnValue sci_tokens(types::typed_list &in, int _iRetCount, t
     else
     {
         pOutString  = new types::String(dims, dimsArray);
-        pOutString->set(Output_Strings);
-
         for (int i = 0 ; i < dimsArray[0] ; i++)
         {
+            char* c = wide_string_to_UTF8(Output_Strings[i]);
+            pOutString->set(i, c);
             FREE(Output_Strings[i]);
+            FREE(c);
         }
         FREE(Output_Strings);
     }
index 8037014..d9ac379 100644 (file)
@@ -59,50 +59,3 @@ int StringConvert(char *str)
     return count;
 }
 /*--------------------------------------------------------------------------*/
-int StringConvertW(wchar_t *str)
-/* changes `\``n` --> `\n` idem for \t and \r */
-{
-    wchar_t *str1;
-    int count = 0;
-    str1 = str;
-
-    while ( *str != 0)
-    {
-        if ( *str == L'\\' )
-        {
-            switch ( *(str + 1))
-            {
-                case L'n' :
-                    *str1 = L'\n' ;
-                    str1++;
-                    str += 2;
-                    count++;
-                    break;
-                case L't' :
-                    *str1 = L'\t' ;
-                    str1++;
-                    str += 2;
-                    break;
-                case L'r' :
-                    *str1 = L'\r' ;
-                    str1++;
-                    str += 2;
-                    break;
-                default :
-                    *str1 = *str;
-                    str1++;
-                    str++;
-                    break;
-            }
-        }
-        else
-        {
-            *str1 = *str;
-            str1++;
-            str++;
-        }
-    }
-    *str1 = L'\0';
-    return count;
-}
-/*--------------------------------------------------------------------------*/
diff --git a/scilab/modules/string/src/c/convstr.c b/scilab/modules/string/src/c/convstr.c
deleted file mode 100644 (file)
index 07be68a..0000000
+++ /dev/null
@@ -1,47 +0,0 @@
-
-/*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) INRIA - Cong WU
- * Copyright (C) INRIA - Allan CORNET
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
- *
- */
-
-/*--------------------------------------------------------------------------*/
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <wchar.h>
-#include <wctype.h>
-#include "convstr.h"
-/*--------------------------------------------------------------------------*/
-void convstr(wchar_t **Input_Matrix, wchar_t **Output_Matrix, char typ, int mn)
-{
-    int x = 0;
-    for (x = 0 ; x < mn; x++)
-    {
-        int y = 0;
-        size_t len_Input_Matrix = wcslen(Input_Matrix[x]);
-        for (y = 0; y < len_Input_Matrix; y++)
-        {
-            /*To traverse every string in the string matrix */
-            if ( (typ == UPPER) || (typ == UPPER_B) )
-            {
-                /*converts the matrix of strings  str-matrix into upper case */
-                Output_Matrix[x][y] = (wchar_t) towupper(Input_Matrix[x][y]);
-            }
-            else if ( (typ == LOW) || (typ == LOW_B) )
-            {
-                /*converts the matrix of strings  str-matrix  into lower case */
-                Output_Matrix[x][y] = (wchar_t) towlower(Input_Matrix[x][y]);
-            }
-        }
-        Output_Matrix[x][y] = 0;
-    }
-}
-/*--------------------------------------------------------------------------*/
diff --git a/scilab/modules/string/src/c/convstr.h b/scilab/modules/string/src/c/convstr.h
deleted file mode 100644 (file)
index 5fec504..0000000
+++ /dev/null
@@ -1,36 +0,0 @@
-
-/*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) INRIA - Allan CORNET
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
- *
- */
-
-/*--------------------------------------------------------------------------*/
-#ifndef __CONVSTR_H__
-#define __CONVSTR_H__
-
-#include "dynlib_string.h"
-
-#define LOW 'l'
-#define LOW_B 'L'
-#define UPPER 'u'
-#define UPPER_B 'U'
-
-/**
-* convstr case conversion
-* param[in] Input_Matrix Input string matrix
-* param[out] Output_Matrix
-* param[in] typ  'l' or 'u'  means low or upper
-* param[in] Number_Input   the number of input string matrix
-*/
-STRING_IMPEXP void convstr(wchar_t **Input_Matrix, wchar_t **Output_Matrix, char typ, int Number_Input);
-
-#endif /* __CONVSTR_H__ */
-/*--------------------------------------------------------------------------*/
-
index 1cee546..fdab941 100644 (file)
@@ -16,6 +16,8 @@
 #include <ctype.h>
 #include "isalphanum.h"
 #include "sci_malloc.h"
+#include "charEncoding.h"
+
 /*--------------------------------------------------------------------------*/
 BOOL *isalphanum(const char* input_string, int *returnedSize)
 {
@@ -25,7 +27,8 @@ BOOL *isalphanum(const char* input_string, int *returnedSize)
     if (input_string)
     {
         int i = 0;
-        int length_input_string = (int)strlen(input_string);
+        wchar_t* in = to_wide_string(input_string);
+        int length_input_string = (int)wcslen(in);
         *returnedSize = length_input_string;
 
         if (length_input_string > 0)
@@ -35,7 +38,7 @@ BOOL *isalphanum(const char* input_string, int *returnedSize)
             {
                 for (i = 0; i < length_input_string; i++)
                 {
-                    if (isalnum(input_string[i]))
+                    if (iswalnum(in[i]))
                     {
                         returnedValues[i] = TRUE;
                     }
@@ -46,6 +49,8 @@ BOOL *isalphanum(const char* input_string, int *returnedSize)
                 }
             }
         }
+
+        FREE(in);
     }
     return returnedValues;
 }
index 3962e73..db80045 100644 (file)
 #include <string.h>
 #include "isascii.h"
 #include "sci_malloc.h"
+#include "charEncoding.h"
+
+#ifdef _MSC_VER
+#include <ctype.h>
+#define isascii __isascii
+#endif
 /*--------------------------------------------------------------------------*/
-BOOL* isasciiStringW(wchar_t* input_string, int* returnedSize)
+BOOL* isasciiStringW(const wchar_t* input_string, int* returnedSize)
 {
     BOOL *returnedValues = NULL;
     *returnedSize = 0;
@@ -34,7 +40,7 @@ BOOL* isasciiStringW(wchar_t* input_string, int* returnedSize)
             {
                 for (i = 0; i < length_input_string; i++)
                 {
-                    if ( iswascii(input_string[i]) )
+                    if (iswascii(input_string[i]))
                     {
                         returnedValues[i] = TRUE;
                     }
@@ -48,6 +54,14 @@ BOOL* isasciiStringW(wchar_t* input_string, int* returnedSize)
     }
     return returnedValues;
 }
+/*--------------------------------------------------------------------------*/
+BOOL* isasciiString(const char* input_string, int* returnedSize)
+{
+    wchar_t* ws = to_wide_string(input_string);
+    BOOL* ret = isasciiStringW(ws, returnedSize);
+    FREE(ws);
+    return ret;
+}
 
 BOOL* isasciiMatrix(double* inputValues, int inputSize)
 {
index a9aa254..35f5ae0 100644 (file)
@@ -23,7 +23,7 @@
 
 #include "dynlib_string.h"
 
-STRING_IMPEXP BOOL* isasciiStringW(wchar_t* input_string, int* returnedSize);
+STRING_IMPEXP BOOL* isasciiString(const char* input_string, int* returnedSize);
 STRING_IMPEXP BOOL* isasciiMatrix(double* input_string, int matrixSize);
 
 #endif /* __ISASCII_H__ */
index 29732f2..a1f0774 100644 (file)
@@ -16,6 +16,8 @@
 #include "isletter.h"
 #include "sci_malloc.h"
 #include "isdigit.h"
+#include "charEncoding.h"
+
 /*--------------------------------------------------------------------------*/
 BOOL *IsDigit(const char* input_string, int *returnedSizeArray)
 {
@@ -25,7 +27,9 @@ BOOL *IsDigit(const char* input_string, int *returnedSizeArray)
     if (input_string)
     {
         int i = 0;
-        int length_input_string = (int)strlen(input_string);
+        wchar_t* in = to_wide_string(input_string);
+        int length_input_string = (int)wcslen(in);
+
         *returnedSizeArray = length_input_string;
 
         if (length_input_string > 0)
@@ -35,7 +39,7 @@ BOOL *IsDigit(const char* input_string, int *returnedSizeArray)
             {
                 for (i = 0; i < length_input_string; i++)
                 {
-                    if (isdigit(input_string[i]))
+                    if (iswdigit(in[i]))
                     {
                         returnedValues[i] = TRUE;
                     }
@@ -46,6 +50,8 @@ BOOL *IsDigit(const char* input_string, int *returnedSizeArray)
                 }
             }
         }
+
+        FREE(in);
     }
     return returnedValues;
 }
index 6b1dba8..44ccd68 100644 (file)
@@ -17,6 +17,7 @@
 #include <wctype.h> /* iswalpha */
 #include "isletter.h"
 #include "sci_malloc.h"
+#include "charEncoding.h"
 
 /*--------------------------------------------------------------------------*/
 BOOL *isletter(char *input_string, int *sizeArray)
@@ -25,49 +26,19 @@ BOOL *isletter(char *input_string, int *sizeArray)
     if (input_string)
     {
         int i = 0;
-        int length_input_string = (int)strlen(input_string);
-        *sizeArray = length_input_string;
+        wchar_t* in = to_wide_string(input_string);
+        int len = (int)wcslen(in);
 
-        if (length_input_string > 0)
-        {
-            returnedValues = (BOOL*)MALLOC(sizeof(BOOL) * length_input_string);
-            if (returnedValues)
-            {
-                for (i = 0; i < length_input_string; i++)
-                {
-                    if ( isalpha(input_string[i]) )
-                    {
-                        returnedValues[i] = TRUE;
-                    }
-                    else
-                    {
-                        returnedValues[i] = FALSE;
-                    }
-                }
-            }
-        }
-    }
-    return returnedValues;
-}
-/*--------------------------------------------------------------------------*/
-BOOL *isletterW(wchar_t *wcInput_string, int *sizeArray)
-{
-    BOOL *returnedValues = NULL;
-    if (wcInput_string)
-    {
-        int i = 0;
-        int length_input_string = (int)wcslen(wcInput_string);
-
-        *sizeArray = length_input_string;
+        *sizeArray = len;
 
-        if (length_input_string > 0)
+        if (len > 0)
         {
-            returnedValues = (BOOL*)MALLOC(sizeof(BOOL) * length_input_string);
+            returnedValues = (BOOL*)MALLOC(sizeof(BOOL) * len);
             if (returnedValues)
             {
-                for (i = 0; i < length_input_string; i++)
+                for (i = 0; i < len; i++)
                 {
-                    if ( iswalpha(wcInput_string[i]) )
+                    if (iswalpha(in[i]))
                     {
                         returnedValues[i] = TRUE;
                     }
@@ -78,6 +49,8 @@ BOOL *isletterW(wchar_t *wcInput_string, int *sizeArray)
                 }
             }
         }
+
+        FREE(in);
     }
     return returnedValues;
 }
index 08d44ae..f7a84d8 100644 (file)
 */
 STRING_IMPEXP BOOL *isletter(char *input_string, int *sizeArray);
 
-/**
-* array elements that are alphabetic letters
-* @param[in] a string
-* @return BOOL array
-*/
-STRING_IMPEXP BOOL *isletterW(wchar_t *wcInput_string, int *sizeArray);
-
 #endif /* __ISLETTER_H__ */
 /*--------------------------------------------------------------------------*/
index d04bbdd..a27ac52 100644 (file)
@@ -42,34 +42,5 @@ BOOL *isNumMatrix(const char **pStrs, int nbRows, int nbCols)
     return pResults;
 }
 // =============================================================================
-BOOL isNumW(const wchar_t* pStr)
-{
-    if (pStr)
-    {
-        stringToComplexError ierr = STRINGTOCOMPLEX_NO_ERROR;
-        stringToComplexW(pStr, L".", FALSE, &ierr);
-        return (BOOL)(ierr == STRINGTOCOMPLEX_NO_ERROR);
-    }
-    return FALSE;
-}
-// =============================================================================
-BOOL *isNumMatrixW(const wchar_t** pStrs, int nbRows, int nbCols)
-{
-    BOOL *pResults = NULL;
-    if (pStrs)
-    {
-        pResults = (BOOL*)MALLOC(sizeof(BOOL) * (nbCols * nbRows));
-        if (pResults)
-        {
-            int i = 0;
-            for (i = 0; i < nbRows * nbCols; i++)
-            {
-                pResults[i] = isNumW(pStrs[i]);
-            }
-        }
-    }
-    return pResults;
-}
-// =============================================================================
 
 
index 2831c0c..a69db44 100644 (file)
@@ -23,11 +23,6 @@ extern "C" {
     STRING_IMPEXP BOOL isNum(const char *pStr);
 
     STRING_IMPEXP BOOL *isNumMatrix(const char **pStrs, int nbRows, int nbCols);
-
-    STRING_IMPEXP BOOL isNumW(const wchar_t *pStr);
-
-    STRING_IMPEXP BOOL *isNumMatrixW(const wchar_t **pStrs, int nbRows, int nbCols);
-
 #ifdef __cplusplus
 }
 #endif
index d43320c..d31eddf 100644 (file)
@@ -70,31 +70,3 @@ char **partfunction(const char** stringInput, int m, int n, int *vectInput, int
     return parts;
 }
 /*--------------------------------------------------------------------------*/
-wchar_t **partfunctionW(wchar_t** _pwstStringInput, int _iRows, int _iCols, int *_piVectInput, int _iVectSize)
-{
-    int i, j;
-    wchar_t **pwstParts = NULL;
-    int iSize = _iRows * _iCols;
-
-    pwstParts = (wchar_t**)MALLOC(sizeof(wchar_t*) * (iSize));
-
-    for (i = 0 ; i < iSize ; i++)
-    {
-        pwstParts[i] = (wchar_t*)MALLOC(sizeof(wchar_t) * (_iVectSize + 1));
-
-        for (j = 0 ; j < _iVectSize ; j++)
-        {
-            if (_piVectInput[j] > wcslen(_pwstStringInput[i]))
-            {
-                pwstParts[i][j] = L' ';
-            }
-            else
-            {
-                pwstParts[i][j] = _pwstStringInput[i][_piVectInput[j] - 1];
-            }
-        }
-        pwstParts[i][j] = '\0';
-    }
-    return pwstParts;
-}
-/*--------------------------------------------------------------------------*/
index b0143ac..2375b1e 100644 (file)
@@ -25,7 +25,5 @@
 */
 STRING_IMPEXP char **partfunction(const char** stringInput, int m, int n, int *vectInput, int row);
 
-STRING_IMPEXP wchar_t **partfunctionW(wchar_t** _pwstStringInput, int _iRows, int _iCols, int *_piVectInput, int _iVectSize);
-
 #endif /* __PARTFUNCTION_H__ */
 /*---------------------------------------------------------------------------*/
index 08ba827..d2f0609 100644 (file)
@@ -173,7 +173,7 @@ static int check_match_limit(pcre *re, pcre_extra *extra, char *bptr, int len,
 consist of a regular expression, in delimiters and optionally followed by
 options, followed by a set of test data, terminated by an empty line. */
 
-pcre_error_code pcre_private(char *INPUT_LINE, char *INPUT_PAT, int *Output_Start, int *Output_End, char*** _pstCapturedString, int* _piCapturedStringCount)
+pcre_error_code pcre_private(const char *INPUT_LINE, const char *INPUT_PAT, int *Output_Start, int *Output_End, char*** _pstCapturedString, int* _piCapturedStringCount)
 {
     /* ALL strings are managed as UTF-8 by default */
     int options = PCRE_UTF8;
@@ -1148,66 +1148,3 @@ SKIP_DATA:
     return PCRE_EXIT;
 }
 /*-------------------------------------------------------------------------------*/
-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;
-}
-/*-------------------------------------------------------------------------------*/
index 7b2e30e..47a10c5 100644 (file)
   <ItemGroup>
     <ClCompile Include="..\cpp\os_wtoi.cpp" />
     <ClCompile Include="..\cpp\sort_inter.cpp" />
-    <ClCompile Include="convstr.c" />
     <ClCompile Include="cvstr.c" />
     <ClCompile Include="DllMainString.c" />
     <ClCompile Include="getfastcode.c" />
     <ClInclude Include="..\..\includes\complex_array.h" />
     <ClInclude Include="..\cpp\sort_inter.h" />
     <ClInclude Include="config.h" />
-    <ClInclude Include="convstr.h" />
     <ClInclude Include="CreateEmptystr.h" />
     <ClInclude Include="isalphanum.h" />
     <ClInclude Include="isascii.h" />
index 7974e8b..e5f9f67 100644 (file)
@@ -23,9 +23,6 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="convstr.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="cvstr.c">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClInclude Include="config.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="convstr.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="CreateEmptystr.h">
       <Filter>Header Files</Filter>
     </ClInclude>
index 32d3f71..ce8f204 100644 (file)
 #include "strsubst.h"
 /* ========================================================================== */
 #define PlusChar '+'
-#define PlusCharW L'+'
 #define LessChar '-'
-#define LessCharW L'-'
 #define ComplexCharI 'i'
-#define ComplexCharIW L'i'
 #define ComplexCharJ 'j'
-#define ComplexCharJW L'j'
 #define ComplexScilab "%i"
-#define ComplexScilabW L"%i"
 #define ComplexI "i"
-#define ComplexIW L"i"
 /* ========================================================================== */
 #ifndef _MSC_VER
 #ifndef strnicmp
 #endif
 /* ========================================================================== */
 static int ParseNumber(const char* tx);
-static int ParseNumberW(const wchar_t* tx);
 static stringToComplexError ParseComplexValue(const char *tx, BOOL bConvertByNAN, double *real, double *imag);
-static stringToComplexError ParseComplexValueW(const wchar_t *tx, BOOL bConvertByNAN, double *real, double *imag);
 static char* midstring(const char *tx, size_t pos, int nb);
-static wchar_t* midstringW(const wchar_t *tx, size_t pos, int nb);
 static char *leftstring(const char *tx, size_t pos);
-static wchar_t* leftstringW(const wchar_t* tx, size_t pos);
 static BOOL is_unit_imaginary (const char *src, double *im);
-static BOOL is_unit_imaginaryW (const wchar_t* src, double *im);
 static double returnNAN(void);
 /* ========================================================================== */
 complexArray *stringsToComplexArray(const char **pSTRs, int nbElements,
@@ -175,76 +164,6 @@ doublecomplex stringToComplex(const char *pSTR, const char *decimal, BOOL bConve
     return dComplexValue;
 }
 /* ========================================================================== */
-doublecomplex stringToComplexW(const wchar_t *pSTR, const wchar_t *decimal, BOOL bConvertByNAN, stringToComplexError *ierr)
-{
-    doublecomplex dComplexValue;
-    *ierr = STRINGTOCOMPLEX_ERROR;
-
-    dComplexValue.r = 0.;
-    dComplexValue.i = 0.;
-
-    if (pSTR)
-    {
-        double real = 0.;
-        double imag = 0.;
-        wchar_t *pStrTemp = wcssub(pSTR, L" ", L"");
-
-        if (pStrTemp)
-        {
-            wchar_t *pStrFormatted = wcssub(pStrTemp, decimal, L".");
-            FREE(pStrTemp);
-
-            if (pStrFormatted)
-            {
-                int lenStrFormatted = (int) wcslen(pStrFormatted);
-
-                /* case .4 replaced by 0.4 */
-                if (pStrFormatted[0] == '.')
-                {
-                    /* case .4 replaced by 0.4 */
-                    wchar_t *pstStrTemp = (wchar_t*)MALLOC(sizeof(wchar_t) * (lenStrFormatted + wcslen(L"0") + 1));
-                    wcscpy(pstStrTemp, L"0");
-                    wcscat(pstStrTemp, pStrFormatted);
-                    FREE(pStrFormatted);
-                    pStrFormatted = pstStrTemp;
-                }
-
-                if (lenStrFormatted > 1)
-                {
-                    if (((pStrFormatted[0] == '+') || (pStrFormatted[0] == '-')) &&
-                            (pStrFormatted[1] == '.'))
-                    {
-                        /* case +.4 replaced by +0.4 */
-                        wchar_t *pstStrTemp = wcssub(pStrFormatted, L"+.", L"+0.");
-                        FREE(pStrFormatted);
-
-                        /* case -.4 replaced by -0.4 */
-                        pStrFormatted = wcssub(pstStrTemp, L"-.", L"-0.");
-                        FREE(pstStrTemp);
-                    }
-                }
-
-                /* Case: "i", "+i", "-i", and with "j"  */
-                if (is_unit_imaginaryW(pStrFormatted, &imag))
-                {
-                    *ierr = STRINGTOCOMPLEX_NO_ERROR;
-                    dComplexValue.r = 0.;
-                    dComplexValue.i = imag;
-                }
-                else
-                {
-                    *ierr = ParseComplexValueW(pStrFormatted, bConvertByNAN, &real, &imag);
-                }
-                FREE(pStrFormatted);
-            }
-        }
-        dComplexValue.r = real;
-        dComplexValue.i = imag;
-    }
-    return dComplexValue;
-}
-/* ========================================================================== */
-
 static int ParseNumber(const char* tx)
 {
     int lookahead = 0;
@@ -323,63 +242,6 @@ static int ParseNumber(const char* tx)
     return lookahead;
 }
 /* ========================================================================== */
-static int ParseNumberW(const wchar_t* tx)
-{
-    int lookahead = 0;
-    int len = 0;
-
-    if (tx[len] == NULL)
-    {
-        return lookahead;
-    }
-    if (tx[len] < 0)
-    {
-        return lookahead;
-    }
-
-    if ((tx[len] == L'+') || (tx[len] == L'-'))
-    {
-        len++;
-    }
-
-    while (iswdigit(tx[len]))
-    {
-        len++;
-    }
-    lookahead = len;
-
-    if (tx[lookahead] == L'.')
-    {
-        lookahead++;
-        len = 0;
-        while (iswdigit(tx[len + lookahead]))
-        {
-            len++;
-        }
-        lookahead += len;
-    }
-
-    if ((tx[lookahead] == L'E') || (tx[lookahead] == L'e') ||
-            (tx[lookahead] == L'D') || (tx[lookahead] == L'd'))
-    {
-
-        lookahead++;
-        if ((tx[lookahead] == L'+') || (tx[lookahead] == L'-'))
-        {
-            lookahead++;
-        }
-
-        len = 0;
-        while (iswdigit(tx[len + lookahead]))
-        {
-            len++;
-        }
-
-        lookahead += len;
-    }
-    return lookahead;
-}
-/* ========================================================================== */
 static stringToComplexError ParseComplexValue(const char *tx, BOOL bConvertByNAN, double *real, double *imag)
 {
     stringToDoubleError ierrDouble = STRINGTODOUBLE_NO_ERROR;
@@ -567,239 +429,6 @@ static stringToComplexError ParseComplexValue(const char *tx, BOOL bConvertByNAN
     return ierr;
 }
 /* ========================================================================== */
-static stringToComplexError ParseComplexValueW(const wchar_t *tx, BOOL bConvertByNAN, double *real, double *imag)
-{
-    stringToDoubleError ierrDouble = STRINGTODOUBLE_NO_ERROR;
-    stringToComplexError ierr = STRINGTOCOMPLEX_NO_ERROR;
-    wchar_t *rnum_string = NULL;
-    wchar_t *inum_string = NULL;
-    size_t lnum = 0;
-    BOOL haveImagI = FALSE;
-    wchar_t *modifiedTxt = NULL;
-
-    *real = stringToDoubleW(tx, FALSE, &ierrDouble);
-    *imag = 0;
-
-    /* test on strlen(tx) > 1 to remove case 'e' */
-    if ((int)wcslen(tx) < 2)
-    {
-        if (ierrDouble == STRINGTODOUBLE_NO_ERROR)
-        {
-            ierr = (stringToComplexError) ierrDouble;
-        }
-        else
-        {
-            if (bConvertByNAN)
-            {
-                ierrDouble = STRINGTODOUBLE_NOT_A_NUMBER;
-                *real = returnNAN();
-                *imag = 0;
-            }
-            else
-            {
-                *real = 0;
-                *imag = 0;
-                ierr = (stringToComplexError) ierrDouble;
-            }
-        }
-    }
-    else if (ierrDouble != STRINGTODOUBLE_NO_ERROR)
-    {
-        modifiedTxt = wcssub(tx, ComplexScilabW, ComplexIW);
-        lnum = ParseNumberW(modifiedTxt);
-        if (lnum <= 1)
-        {
-            /* manages special cases nan + nani, ... */
-            if (wcsnicmp(modifiedTxt, NanStringW, wcslen(NanStringW)) == 0)
-            {
-                lnum = wcslen(NanStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, InfStringW, wcslen(InfStringW)) == 0)
-            {
-                lnum = wcslen(InfStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, NegInfStringW, wcslen(NegInfStringW)) == 0)
-            {
-                lnum = wcslen(NegInfStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, PosInfStringW, wcslen(PosInfStringW)) == 0)
-            {
-                lnum = wcslen(PosInfStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, NegNanStringW, wcslen(NegNanStringW)) == 0)
-            {
-                lnum = wcslen(NegNanStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, PosNanStringW, wcslen(PosNanStringW)) == 0)
-            {
-                lnum = wcslen(PosNanStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, ScilabEpsStringW, wcslen(ScilabEpsStringW)) == 0)
-            {
-                lnum = wcslen(ScilabEpsStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, ScilabPosEpsStringW, wcslen(ScilabPosEpsStringW)) == 0)
-            {
-                lnum = wcslen(ScilabPosEpsStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, ScilabNegEpsStringW, wcslen(ScilabNegEpsStringW)) == 0)
-            {
-                lnum = wcslen(ScilabNegEpsStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, ScilabPiStringW, wcslen(ScilabPiStringW)) == 0)
-            {
-                lnum = wcslen(ScilabPiStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, ScilabNegPiStringW, wcslen(ScilabNegPiStringW)) == 0)
-            {
-                lnum = wcslen(ScilabNegPiStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, ScilabPosPiStringW, wcslen(ScilabPosPiStringW)) == 0)
-            {
-                lnum = wcslen(ScilabPosPiStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, ScilabEStringW, wcslen(ScilabEStringW)) == 0)
-            {
-                lnum = wcslen(ScilabEStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, ScilabPosEStringW, wcslen(ScilabPosEStringW)) == 0)
-            {
-                lnum = wcslen(ScilabPosEStringW);
-            }
-            else if (wcsnicmp(modifiedTxt, ScilabNegEStringW, wcslen(ScilabNegEStringW)) == 0)
-            {
-                lnum = wcslen(ScilabNegEStringW);
-            }
-        }
-        inum_string = midstringW(modifiedTxt, lnum, -1);
-
-        if ((inum_string[wcslen(inum_string) - 1] == L'i') ||
-                (inum_string[wcslen(inum_string) - 1] == L'j'))
-        {
-            inum_string[wcslen(inum_string) - 1] = 0;
-            if (inum_string[wcslen(inum_string) - 1] == L'*')
-            {
-                inum_string[wcslen(inum_string) - 1] = 0;
-            }
-
-            if (wcscmp(inum_string, L"+") == 0)
-            {
-                FREE(inum_string);
-                inum_string = os_wcsdup(L"+1");
-            }
-
-            if (wcscmp(inum_string, L"-") == 0)
-            {
-                FREE(inum_string);
-                inum_string = os_wcsdup(L"-1");
-            }
-            haveImagI = TRUE;
-        }
-        else if ((inum_string[1] == L'i') ||
-                 (inum_string[1] == L'j'))
-        {
-            if (inum_string[2] == L'*')
-            {
-                int i = 0;
-                for (i = 1; (i + 2) < wcslen(inum_string); i++)
-                {
-                    inum_string[i] = inum_string[i + 2];
-                }
-                inum_string[wcslen(inum_string) - 1] = 0;
-                inum_string[wcslen(inum_string) - 1] = 0;
-            }
-
-            if (wcscmp(inum_string, L"+") == 0)
-            {
-                FREE(inum_string);
-                inum_string = os_wcsdup(L"+1");
-            }
-
-            if (wcscmp(inum_string, L"-") == 0)
-            {
-                FREE(inum_string);
-                inum_string = os_wcsdup(L"-1");
-            }
-            haveImagI = TRUE;
-        }
-        else
-        {
-            haveImagI = FALSE;
-        }
-        rnum_string = leftstringW(modifiedTxt, lnum);
-
-        if (wcscmp(inum_string, L"") == 0)
-        {
-            *imag = stringToDoubleW(rnum_string, bConvertByNAN, &ierrDouble);
-            ierr = (stringToComplexError)(ierrDouble);
-            *real = 0.;
-        }
-        else
-        {
-            double dReal = 0.;
-            double dImag = 0.;
-
-            stringToDoubleError ierrReal = STRINGTODOUBLE_NO_ERROR;
-            stringToDoubleError ierrImag = STRINGTODOUBLE_NO_ERROR;
-            dReal = stringToDoubleW(rnum_string, FALSE, &ierrReal);
-            dImag = stringToDoubleW(inum_string, FALSE, &ierrImag);
-
-            if ((ierrReal == STRINGTODOUBLE_NO_ERROR) && (ierrImag == STRINGTODOUBLE_NO_ERROR))
-            {
-                if (!haveImagI)
-                {
-                    if (bConvertByNAN)
-                    {
-                        ierr = STRINGTOCOMPLEX_NO_ERROR;
-                        *real = returnNAN();
-                        *imag = 0.;
-                    }
-                    else
-                    {
-                        ierr = STRINGTOCOMPLEX_ERROR;
-                    }
-                }
-                else
-                {
-                    ierr = STRINGTOCOMPLEX_NO_ERROR;
-                    *real = dReal;
-                    *imag = dImag;
-                }
-            }
-            else
-            {
-                if (bConvertByNAN)
-                {
-                    ierr = STRINGTOCOMPLEX_NO_ERROR;
-                    *real = returnNAN();
-                    *imag = 0.;
-                }
-                else
-                {
-                    ierr = STRINGTOCOMPLEX_ERROR;
-                }
-            }
-        }
-
-        if (rnum_string)
-        {
-            FREE(rnum_string);
-            rnum_string = NULL;
-        }
-        if (inum_string)
-        {
-            FREE(inum_string);
-            inum_string = NULL;
-        }
-        if (modifiedTxt)
-        {
-            FREE(modifiedTxt);
-            modifiedTxt = NULL;
-        }
-    }
-    return ierr;
-}
-/* ========================================================================== */
 static char *midstring(const char *tx, size_t pos, int nb)
 {
     char *returnString = NULL;
@@ -828,34 +457,6 @@ static char *midstring(const char *tx, size_t pos, int nb)
     return returnString;
 }
 /* ========================================================================== */
-static wchar_t* midstringW(const wchar_t* tx, size_t pos, int nb)
-{
-    wchar_t *returnString = NULL;
-    if (tx)
-    {
-        int lenTx = (int) wcslen(tx);
-        int posEnd = 0;
-        int newLen = 0;
-
-        if (nb < 0)
-        {
-            posEnd = lenTx;
-        }
-        else
-        {
-            posEnd = nb;
-        }
-        newLen = posEnd + 1;
-        if (newLen > 0)
-        {
-            returnString = (wchar_t*)MALLOC(sizeof(wchar_t) * newLen);
-            wcsncpy(returnString, &tx[pos], posEnd);
-            returnString[posEnd] = 0;
-        }
-    }
-    return returnString;
-}
-/* ========================================================================== */
 static char *leftstring(const char *tx, size_t pos)
 {
     char *returnString = NULL;
@@ -875,25 +476,6 @@ static char *leftstring(const char *tx, size_t pos)
     return returnString;
 }
 /* ========================================================================== */
-static wchar_t *leftstringW(const wchar_t *tx, size_t pos)
-{
-    wchar_t *returnString = NULL;
-    if (tx)
-    {
-        int lenTx = (int) wcslen(tx);
-        returnString = os_wcsdup(tx);
-        if (pos > lenTx)
-        {
-            return returnString;
-        }
-        else
-        {
-            returnString[pos] = 0;
-        }
-    }
-    return returnString;
-}
-/* ========================================================================== */
 static BOOL is_unit_imaginary (const char *src, double *im)
 {
     char *modifiedSrc = strsub((char*)src, ComplexScilab, ComplexI);
@@ -939,51 +521,6 @@ static BOOL is_unit_imaginary (const char *src, double *im)
     return isUnitImag;
 }
 /* ========================================================================== */
-static BOOL is_unit_imaginaryW(const wchar_t *src, double *im)
-{
-    wchar_t *modifiedSrc = wcssub(src, ComplexScilabW, ComplexIW);
-    wchar_t *nextChar = NULL;
-    BOOL isUnitImag = FALSE;
-
-    if (modifiedSrc == NULL)
-    {
-        return isUnitImag;
-    }
-
-    if (modifiedSrc[0] == LessChar)
-    {
-        *im = -1.0;
-        nextChar = modifiedSrc + 1;
-    }
-    else
-    {
-        *im = +1.0;
-        if (modifiedSrc[0] == PlusChar)
-        {
-            nextChar = modifiedSrc + 1;
-        }
-        else
-        {
-            nextChar = modifiedSrc;
-        }
-    }
-
-    if (nextChar)
-    {
-        if ((nextChar[0] == ComplexCharI || nextChar[0] == ComplexCharJ) && nextChar[1] == 0)
-        {
-            isUnitImag = TRUE;
-        }
-    }
-
-    if (modifiedSrc)
-    {
-        FREE(modifiedSrc);
-        modifiedSrc = NULL;
-    }
-    return isUnitImag;
-}
-/* ========================================================================== */
 static double returnNAN(void)
 {
     static int first = 1;
index 43329e4..ebc33ed 100644 (file)
@@ -65,35 +65,6 @@ static char* replace_D_By_E(const char* _pst)
     return pstReturn;
 }
 
-static wchar_t* replace_D_By_EW(const wchar_t* _pst)
-{
-    //find and replace d and D by E for compatibility with strtod Linux/Mac
-    wchar_t* pstReturn = os_wcsdup(_pst);
-    wchar_t* pstFind = pstReturn;
-    do
-    {
-        pstFind = wcschr(pstFind, L'D');
-        if (pstFind)
-        {
-            pstFind[0] = L'E';
-        }
-    }
-    while (pstFind);
-
-    pstFind = pstReturn;
-    do
-    {
-        pstFind = wcschr(pstFind, L'd');
-        if (pstFind)
-        {
-            pstFind[0] = L'e';
-        }
-    }
-    while (pstFind);
-
-    return pstReturn;
-}
-
 double stringToDouble(const char *pSTR, BOOL bConvertByNAN, stringToDoubleError *ierr)
 {
     double dValue = 0.0;
@@ -189,101 +160,6 @@ double stringToDouble(const char *pSTR, BOOL bConvertByNAN, stringToDoubleError
     return dValue;
 }
 // =============================================================================
-double stringToDoubleW(const wchar_t *pSTR, BOOL bConvertByNAN, stringToDoubleError *ierr)
-{
-    double dValue = 0.0;
-    *ierr = STRINGTODOUBLE_ERROR;
-    if (pSTR)
-    {
-        if ((wcsicmp(pSTR, NanStringW) == 0) || (wcsicmp(pSTR, NegNanStringW) == 0) ||
-                (wcsicmp(pSTR, PosNanStringW) == 0) || (wcsicmp(pSTR, ScilabPosNanStringW) == 0) ||
-                (wcsicmp(pSTR, ScilabNanStringW) == 0) || (wcsicmp(pSTR, ScilabNegNanStringW) == 0))
-        {
-            dValue = returnNAN();
-        }
-        else if ((wcsicmp(pSTR, InfStringW) == 0) || (wcsicmp(pSTR, PosInfStringW) == 0) ||
-                 (wcsicmp(pSTR, ScilabInfStringW) == 0) || (wcsicmp(pSTR, ScilabPosInfStringW) == 0))
-        {
-            dValue = returnINF(TRUE);
-        }
-        else if ((wcsicmp(pSTR, NegInfStringW) == 0) || (wcsicmp(pSTR, ScilabNegInfStringW) == 0))
-        {
-            dValue = returnINF(FALSE);
-        }
-        else if ((wcsicmp(pSTR, ScilabPiStringW) == 0) || (wcsicmp(pSTR, ScilabPosPiStringW) == 0))
-        {
-            dValue = M_PI;
-        }
-        else if (wcsicmp(pSTR, ScilabNegPiStringW) == 0)
-        {
-            dValue = -M_PI;
-        }
-        else if ((wcsicmp(pSTR, ScilabPosEStringW) == 0) || (wcsicmp(pSTR, ScilabEStringW) == 0))
-        {
-            dValue = exp(1);
-        }
-        else if (wcsicmp(pSTR, ScilabNegEStringW) == 0)
-        {
-            dValue = -exp(1);
-        }
-        else if ((wcsicmp(pSTR, ScilabEpsStringW) == 0) || (wcsicmp(pSTR, ScilabPosEpsStringW) == 0))
-        {
-            dValue = EPSILON;
-        }
-        else if (wcsicmp(pSTR, ScilabNegEpsStringW) == 0)
-        {
-            dValue = -EPSILON;
-        }
-        else
-        {
-            wchar_t* pstReplaced = replace_D_By_EW(pSTR);
-            wchar_t *pEnd = NULL;
-            double v = wcstod(pstReplaced, &pEnd);
-            if ((v == 0) && (pEnd == pstReplaced))
-            {
-                if (bConvertByNAN)
-                {
-                    dValue = returnNAN();
-                }
-                else
-                {
-                    *ierr = STRINGTODOUBLE_NOT_A_NUMBER;
-                    FREE(pstReplaced);
-                    return (dValue = 0.0);
-                }
-            }
-            else
-            {
-                if (wcscmp(pEnd, L"") == 0)
-                {
-                    dValue = v;
-                }
-                else
-                {
-                    if (bConvertByNAN)
-                    {
-                        dValue = returnNAN();
-                    }
-                    else
-                    {
-                        *ierr = STRINGTODOUBLE_NOT_A_NUMBER;
-                        FREE(pstReplaced);
-                        return (dValue = 0.0);
-                    }
-                }
-            }
-
-            FREE(pstReplaced);
-        }
-        *ierr = STRINGTODOUBLE_NO_ERROR;
-    }
-    else
-    {
-        *ierr = STRINGTODOUBLE_MEMORY_ALLOCATION;
-    }
-    return dValue;
-}
-// =============================================================================
 static double returnINF(BOOL bPositive)
 {
     double dbl1 = 1.0;
index 6f938ff..7b0c239 100644 (file)
@@ -18,6 +18,7 @@
 #include "freeArrayOfString.h"
 #include "sci_malloc.h"
 #include "os_string.h"
+#include "charEncoding.h"
 /*----------------------------------------------------------------------------*/
 char** strings_strrev(char **Input_strings, int Dim_Input_strings)
 {
@@ -30,31 +31,36 @@ char** strings_strrev(char **Input_strings, int Dim_Input_strings)
             int i = 0;
             for (i = 0; i < Dim_Input_strings; i++)
             {
-                Output_strings[i] = scistrrev(Input_strings[i]);
-                if (Output_strings[i] == NULL)
+                wchar_t* w = to_wide_string(Input_strings[i]);
+                wchar_t* o = scistrrev(w);
+                if (o == NULL)
                 {
                     freeArrayOfString(Output_strings, i);
                     return NULL;
                 }
+
+                Output_strings[i] = wide_string_to_UTF8(o);
+                FREE(o);
+                FREE(w);
             }
         }
     }
     return Output_strings;
 }
 /*----------------------------------------------------------------------------*/
-char* scistrrev(char* str)
+wchar_t* scistrrev(wchar_t* str)
 {
-    char *revstr = NULL;
+    wchar_t *revstr = NULL;
     if (str)
     {
 #ifdef _MSC_VER
-        revstr = _strrev(str);
+        revstr = _wcsrev(os_wcsdup(str));
 #else
         int iLen = 0;
         int j = 0;
 
-        iLen = (int)strlen(str);
-        revstr = (char*)MALLOC((iLen + 1) * sizeof(char));
+        iLen = (int)wcslen(str);
+        revstr = (wchar_t*)MALLOC((iLen + 1) * sizeof(wchar_t));
         /* copy character by character to reverse string */
         for (j = 0 ; j < iLen ; j++)
         {
index 2d17b71..a9afc33 100644 (file)
@@ -19,7 +19,7 @@
 #include "dynlib_string.h"
 
 STRING_IMPEXP char** strings_strrev(char** Input_strings, int Dim_Input_strings);
-char* scistrrev(char* str);
+wchar_t* scistrrev(wchar_t* str);
 
 #endif /* __STRINGSSTRREV_H__ */
 /*----------------------------------------------------------------------------*/
index e83f83d..9daf5ca 100644 (file)
 #include "strsplit.h"
 #include "sci_malloc.h"
 #include "freeArrayOfString.h"
+#include "charEncoding.h"
 /*----------------------------------------------------------------------------*/
-char** strsplit(const char* stringToSplit, double *indices, int sizeIndices, strsplit_error *ierr)
+wchar_t **wide_strsplit(wchar_t * wcstringToSplit, double *indices, int sizeIndices, strsplit_error *ierr)
 {
-    char** splitted = NULL;
+    wchar_t **splitted = NULL;
     *ierr = STRSPLIT_NO_ERROR;
 
-    if (stringToSplit)
+    if (wcstringToSplit)
     {
         int lengthToCopy = 0;
-        int lenString = (int)strlen(stringToSplit);
+        int lenString = (int)wcslen(wcstringToSplit);
         int i = 0, j = 0;
-        char* strDest = NULL;
-        const char* strSrc = NULL;
+        wchar_t* wcStrDest = NULL;
+        wchar_t* wcStrSrc = NULL;
 
         for (i = 0; i < sizeIndices; i++)
         {
             /* Check 2nd input matrix position */
-            if ( ((int)indices[i] <= 0) || ((int)indices[i] >= lenString) )
+            if (((int)indices[i] <= 0) || ((int)indices[i] >= lenString))
             {
                 *ierr = STRSPLIT_INCORRECT_VALUE_ERROR;
                 return NULL;
@@ -40,9 +41,9 @@ char** strsplit(const char* stringToSplit, double *indices, int sizeIndices, str
             /* check 2nd input order */
             if (sizeIndices > 1)
             {
-                if ( i < (sizeIndices - 1) )
+                if (i < (sizeIndices - 1))
                 {
-                    if ((int)indices[i] > (int)indices[i + 1])
+                    if ((int)indices[i] >(int)indices[i + 1])
                     {
                         *ierr = STRSPLIT_INCORRECT_ORDER_ERROR;
                         return NULL;
@@ -51,7 +52,7 @@ char** strsplit(const char* stringToSplit, double *indices, int sizeIndices, str
             }
         }
 
-        splitted = (char**)MALLOC(sizeof(char*) * (sizeIndices + 1));
+        splitted = (wchar_t**)MALLOC(sizeof(wchar_t*) * (sizeIndices + 1));
         if (splitted == NULL)
         {
             *ierr = STRSPLIT_MEMORY_ALLOCATION_ERROR;
@@ -70,38 +71,56 @@ char** strsplit(const char* stringToSplit, double *indices, int sizeIndices, str
                 lengthToCopy = (int)indices[i] - (int)indices[i - 1];
             }
 
-            splitted[i] = (char*)MALLOC(sizeof(char) * (lengthToCopy + 1));
-            strDest = splitted[i];
+            splitted[i] = (wchar_t*)MALLOC(sizeof(wchar_t) * (lengthToCopy + 1));
+            wcStrDest = splitted[i];
 
             if (splitted[i] == NULL)
             {
-                freeArrayOfString(splitted, sizeIndices);
+                freeArrayOfWideString(splitted, sizeIndices);
                 *ierr = STRSPLIT_MEMORY_ALLOCATION_ERROR;
                 return NULL;
             }
-            
-            strSrc = &stringToSplit[j];
-            memcpy(strDest, strSrc, lengthToCopy * sizeof(char));
-            strDest[lengthToCopy] = 0;
+            wcStrSrc = &wcstringToSplit[j];
+            memcpy(wcStrDest, wcStrSrc, lengthToCopy * sizeof(wchar_t));
+            wcStrDest[lengthToCopy] = 0;
 
             j = (int)indices[i];
         }
 
         lengthToCopy = lenString - (int)indices[sizeIndices - 1];
-        splitted[sizeIndices] = (char*)MALLOC(sizeof(char) * (lengthToCopy + 1));
-        strDest = splitted[sizeIndices];
+        splitted[sizeIndices] = (wchar_t*)MALLOC(sizeof(wchar_t) * (lengthToCopy + 1));
+        wcStrDest = splitted[sizeIndices];
 
         if (splitted[sizeIndices] == NULL)
         {
-            freeArrayOfString(splitted, sizeIndices + 1);
+            freeArrayOfWideString(splitted, sizeIndices + 1);
             *ierr = STRSPLIT_MEMORY_ALLOCATION_ERROR;
             return NULL;
         }
 
-        strSrc = &stringToSplit[j];
-        memcpy(strDest, strSrc, lengthToCopy * sizeof(char));
-        strDest[lengthToCopy] = 0;
+        wcStrSrc = &wcstringToSplit[j];
+        memcpy(wcStrDest, wcStrSrc, lengthToCopy * sizeof(wchar_t));
+        wcStrDest[lengthToCopy] = 0;
     }
     return splitted;
 }
+
+char** strsplit(const char* stringToSplit, double *indices, int sizeIndices, strsplit_error *ierr)
+{
+    wchar_t* w = to_wide_string(stringToSplit);
+    wchar_t** o = wide_strsplit(w, indices, sizeIndices, ierr);
+    if (*ierr == STRSPLIT_NO_ERROR)
+    {
+        char** output = (char**)MALLOC(sizeof(char*) * (sizeIndices + 1));
+        for (int i = 0; i < sizeIndices + 1; ++i)
+        {
+            output[i] = wide_string_to_UTF8(o[i]);
+        }
+
+        freeArrayOfWideString(o, sizeIndices + 1);
+        return output;
+    }
+
+    return NULL;
+}
 /*----------------------------------------------------------------------------*/
index f644677..bfae544 100644 (file)
@@ -26,14 +26,14 @@ char **strsubst(const char **strings_input, int strings_dim, const char *string_
 {
     char **replacedStrings = NULL;
 
-    if ( (strings_input) && (string_to_search) && (replacement_string) )
+    if ((strings_input) && (string_to_search) && (replacement_string))
     {
         int i = 0;
         replacedStrings = (char**)MALLOC(sizeof(char*) * strings_dim);
         for (i = 0; i < strings_dim; i++)
         {
             const char *str = strings_input[i];
-            replacedStrings[i] = strsub (str, string_to_search, replacement_string);
+            replacedStrings[i] = strsub(str, string_to_search, replacement_string);
         }
     }
     return replacedStrings;
@@ -43,7 +43,7 @@ char **strsubst_reg(const char **strings_input, int strings_dim, const char *str
 {
     char **replacedStrings = NULL;
 
-    if ( (strings_input) && (string_to_search) && (replacement_string) )
+    if ((strings_input) && (string_to_search) && (replacement_string))
     {
         int i = 0;
         replacedStrings = (char**)MALLOC(sizeof(char*) * strings_dim);
@@ -73,22 +73,22 @@ char *strsub(const char* input_string, const char* string_to_search, const char*
         return os_strdup(input_string);
     }
 
-    occurrence_str = strstr (input_string, string_to_search);
+    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))
+    if (strlen(replacement_string) > strlen(string_to_search))
     {
         count = 0;
-        len = (int)strlen (string_to_search);
+        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);
+                occurrence_str = strstr(occurrence_str, string_to_search);
                 if (occurrence_str != NULL)
                 {
                     occurrence_str += len;
@@ -103,7 +103,7 @@ char *strsub(const char* input_string, const char* string_to_search, const char*
         len = (int)strlen(input_string);
     }
 
-    replacedString = (char*)MALLOC (sizeof(char) * (len + 1));
+    replacedString = (char*)MALLOC(sizeof(char) * (len + 1));
     if (replacedString == NULL)
     {
         return NULL;
@@ -111,10 +111,10 @@ char *strsub(const char* input_string, const char* string_to_search, const char*
 
     occurrence_str = input_string;
     result_str = replacedString;
-    len = (int)strlen (string_to_search);
+    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)
+        if (*occurrence_str == string_to_search[0] && strncmp(occurrence_str, string_to_search, len) == 0)
         {
             const char *N = NULL;
             N = replacement_string;
@@ -179,7 +179,7 @@ char *strsub_reg(const char* input_string, const char* string_to_search, const c
 
     len = (int)wcslen(wcreplacement_string) + (int)wcslen(wcinput_string);
 
-    wcreplacedString = (wchar_t*)MALLOC (sizeof(wchar_t) * (len + 1));
+    wcreplacedString = (wchar_t*)MALLOC(sizeof(wchar_t) * (len + 1));
     if (wcreplacedString == NULL)
     {
         FREE(replacement_string);
@@ -196,7 +196,7 @@ char *strsub_reg(const char* input_string, const char* string_to_search, const c
         int wcOutput_End = 0;
 
         char * strOutput_Start = os_strdup(input_string);
-        char *  strOutput_End =  os_strdup(input_string);
+        char *  strOutput_End = os_strdup(input_string);
 
         wchar_t *wcstrOutput_Start = NULL;
         wchar_t *wcstrOutput_End = NULL;
@@ -247,163 +247,3 @@ char *strsub_reg(const char* input_string, const char* string_to_search, const c
     return replacedString;
 }
 /*-------------------------------------------------------------------------------------*/
-wchar_t *wcssub_reg(const wchar_t* _pwstInput, const wchar_t* _pwstSearch, const wchar_t* _pwstReplace, int* _piErr)
-{
-    pcre_error_code iPcreStatus = PCRE_FINISHED_OK;
-    int iStart = 0;
-    int iEnd = 0;
-    int iLen = 0;
-
-    wchar_t* pwstOutput = NULL;
-
-    if (_pwstInput == NULL)
-    {
-        return NULL;
-    }
-
-    if (_pwstSearch == NULL || _pwstReplace == NULL)
-    {
-        return os_wcsdup(_pwstInput);
-    }
-
-    iPcreStatus = wide_pcre_private((wchar_t*)_pwstInput, (wchar_t*)_pwstSearch, &iStart, &iEnd, NULL, NULL);
-    if (iPcreStatus != PCRE_FINISHED_OK)
-    {
-        *_piErr = iPcreStatus;
-        return os_wcsdup(_pwstInput);
-    }
-
-    //compute new size of output string
-    iLen += (int)wcslen(_pwstReplace) - (iEnd - iStart);
-
-    pwstOutput = (wchar_t*)MALLOC(sizeof(wchar_t) * (wcslen(_pwstInput) + iLen + 1));
-    memset(pwstOutput, 0x00, sizeof(wchar_t) * (wcslen(_pwstInput) + iLen + 1));
-
-    //copy start of original string
-    wcsncpy(pwstOutput, _pwstInput, iStart);
-    //copy replace string
-    wcscpy(pwstOutput + wcslen(pwstOutput), _pwstReplace);
-    //copy end of original string
-    wcscpy(pwstOutput + wcslen(pwstOutput), _pwstInput + iEnd);
-
-    *_piErr = iPcreStatus;
-    return pwstOutput;
-}
-/*-------------------------------------------------------------------------------------*/
-wchar_t **wcssubst_reg(const wchar_t** _pwstInput, int _iInputSize, const wchar_t* _pwstSearch, const wchar_t* _pwstReplace, int* _piErr)
-{
-    wchar_t** pwstOutput = NULL;
-
-    if (_pwstInput != NULL && _pwstSearch != NULL && _pwstReplace != NULL)
-    {
-        int i = 0;
-        pwstOutput = (wchar_t**)MALLOC(sizeof(wchar_t*) * _iInputSize);
-        for (i = 0 ; i < _iInputSize ; i++)
-        {
-            const wchar_t* pwst = _pwstInput[i];
-            pwstOutput[i] = wcssub_reg(pwst, _pwstSearch, _pwstReplace, _piErr);
-        }
-    }
-    return pwstOutput;
-}
-/*-------------------------------------------------------------------------------------*/
-wchar_t **wcssubst(const wchar_t** _pwstInput, int _iInputSize, const wchar_t* _pwstSearch, const wchar_t* _pwstReplace)
-{
-    wchar_t** pwstOutput = NULL;
-
-    if (_pwstInput != NULL && _pwstSearch != NULL && _pwstReplace != NULL)
-    {
-        int i = 0;
-        pwstOutput = (wchar_t**)MALLOC(sizeof(wchar_t*) * _iInputSize);
-        for (i = 0 ; i < _iInputSize ; i++)
-        {
-            const wchar_t* pwst = _pwstInput[i];
-            if (wcslen(pwst) == 0)
-            {
-                pwstOutput[i] = os_wcsdup(L"");
-            }
-            else
-            {
-                pwstOutput[i] = wcssub(pwst, _pwstSearch, _pwstReplace);
-            }
-        }
-    }
-    return pwstOutput;
-}
-/*-------------------------------------------------------------------------------------*/
-wchar_t *wcssub(const wchar_t* _pwstInput, const wchar_t* _pwstSearch, const wchar_t* _pwstReplace)
-{
-    int i               = 0;
-    int iOccurs         = 0;
-    size_t iReplace     = 0;
-    size_t iSearch      = 0;
-    size_t iOffset      = 0;
-
-    size_t* piStart     = NULL;
-
-    const wchar_t* pwstPos  = NULL;
-    wchar_t* pwstOutput     = NULL;
-
-    if (_pwstInput == NULL)
-    {
-        return NULL;
-    }
-
-    if (_pwstInput[0] == L'\0')
-    {
-        return os_wcsdup(L"");
-    }
-
-    if (_pwstSearch == NULL || _pwstReplace == NULL)
-    {
-        return os_wcsdup(_pwstInput);
-    }
-
-    iSearch     = wcslen(_pwstSearch);
-    iReplace    = wcslen(_pwstReplace);
-    piStart     = (size_t*)MALLOC(sizeof(size_t) * wcslen(_pwstInput));
-    pwstPos     = _pwstInput;
-
-    while (pwstPos)
-    {
-        pwstPos = wcsstr(pwstPos, _pwstSearch);
-        if (pwstPos)
-        {
-            piStart[iOccurs++]  = pwstPos - _pwstInput;
-            iOffset             += iReplace - iSearch;
-            pwstPos++;
-        }
-    }
-
-    pwstOutput = (wchar_t*)MALLOC(sizeof(wchar_t) * (wcslen(_pwstInput) + iOffset + 1));
-    memset(pwstOutput, 0x00, sizeof(wchar_t) * (wcslen(_pwstInput) + iOffset + 1));
-
-    if (iOccurs == 0)
-    {
-        wcscpy(pwstOutput, _pwstInput);
-    }
-    else
-    {
-        for (i = 0 ; i < iOccurs ; i++)
-        {
-            if (i == 0)
-            {
-                //copy start of original string
-                wcsncpy(pwstOutput, _pwstInput, piStart[i]);
-            }
-            else
-            {
-                //copy start of original string
-                wcsncpy(pwstOutput + wcslen(pwstOutput), _pwstInput + piStart[i - 1] + iSearch, piStart[i] - (iSearch + piStart[i - 1]));
-            }
-            //copy replace string
-            wcscpy(pwstOutput + wcslen(pwstOutput), _pwstReplace);
-        }
-        //copy end of original string
-        wcscpy(pwstOutput + wcslen(pwstOutput), _pwstInput + piStart[iOccurs - 1] + iSearch);
-    }
-
-    FREE(piStart);
-    return pwstOutput;
-}
-/*-------------------------------------------------------------------------------------*/
index 041eb12..391f53a 100644 (file)
 
 
 /*------------------------------------------------------------------------*/
-char** stringTokens(const char* str, const char* delim, int* sizeoutputs)
+wchar_t** stringTokens(wchar_t* str, wchar_t* delim, int* sizeOutputs)
 {
-    char **outputs = NULL;
-    *sizeoutputs = 0;
+    wchar_t **Outputs = NULL;
+    *sizeOutputs = 0;
     if (str)
     {
         if (delim)
         {
             int i = 0;
-            char *pstToken = NULL;
-            char *pstWork = os_strdup(str);
-            char *pstState = NULL;
+            wchar_t *pwstToken = NULL;
+            wchar_t *pwstWork = os_wcsdup(str);
+            wchar_t *pwstState = NULL;
 
             //compute size of outputs array
-            for (pstToken = os_strtok(pstWork, delim, &pstState);
-                    pstToken != NULL;
-                    pstToken = os_strtok(NULL, delim, &pstState), (*sizeoutputs)++)
+            for (pwstToken = os_wcstok(pwstWork, delim, &pwstState);
+                pwstToken != NULL;
+                pwstToken = os_wcstok(NULL, delim, &pwstState), (*sizeOutputs)++)
             {
                 ;
             }
 
-            if (*sizeoutputs == 0)
+            if (*sizeOutputs == 0)
             {
-                FREE(pstWork);
+                FREE(pwstWork);
                 return NULL;
             }
 
             //alloc output array
-            outputs = (char**)MALLOC(sizeof(char*) * *sizeoutputs);
+            Outputs = (wchar_t**)MALLOC(sizeof(wchar_t*) * *sizeOutputs);
 
-            FREE(pstWork);
-            pstWork = os_strdup(str);
-            for (pstToken = os_strtok(pstWork, delim, &pstState);
-                    pstToken != NULL;
-                    pstToken = os_strtok(NULL, delim, &pstState), i++)
+            FREE(pwstWork);
+            pwstWork = os_wcsdup(str);
+            for (pwstToken = os_wcstok(pwstWork, delim, &pwstState);
+                pwstToken != NULL;
+                pwstToken = os_wcstok(NULL, delim, &pwstState), i++)
             {
-                outputs[i] = os_strdup(pstToken);
+                Outputs[i] = os_wcsdup(pwstToken);
             }
 
-            FREE(pstWork);
+            FREE(pwstWork);
         }
     }
-    return outputs;
+    return Outputs;
 }
 /*--------------------------------------------------------------------------*/
index fed6f9a..31e9737 100644 (file)
@@ -27,7 +27,7 @@
 #include <wchar.h>
 #include "dynlib_string.h"
 
-STRING_IMPEXP char** stringTokens(const char* str, const char* delim, int* sizeOutputs);
+STRING_IMPEXP wchar_t** stringTokens(wchar_t* str, wchar_t* delim, int* sizeOutputs);
 
 #endif /* __TOKENS_H__ */
 /*------------------------------------------------------------------------*/