Fix UTF8 encoding of invalid character

src/CLR/CorLib/corlib_native_System_String.cpp

@@ -585,6 +585,59 @@ HRESULT Library_corlib_native_System_String::ToCharArray(CLR_RT_StackFrame &stac
     NANOCLR_NOCLEANUP();
 }
 
+// Helper function for comparing UTF-8 substrings
+bool MatchString(CLR_RT_UnicodeHelper &inputIter, const char *searchStr, int searchCharLen)
+{
+    // Create copies to preserve original iterator state
+    CLR_RT_UnicodeHelper inputCopy = inputIter;
+    CLR_RT_UnicodeHelper searchIter;
+    searchIter.SetInputUTF8(searchStr);
+
+    for (int i = 0; i < searchCharLen; i++)
+    {
+        CLR_UINT16 bufInput[3] = {0};
+        CLR_UINT16 bufSearch[3] = {0};
+
+        // Set up buffers for character conversion
+        inputCopy.m_outputUTF16 = bufInput;
+        inputCopy.m_outputUTF16_size = MAXSTRLEN(bufInput);
+        searchIter.m_outputUTF16 = bufSearch;
+        searchIter.m_outputUTF16_size = MAXSTRLEN(bufSearch);
+
+        // Convert next character from input
+        if (!inputCopy.ConvertFromUTF8(1, false))
+        {
+            // Input ended prematurely
+            return false;
+        }
+
+        // Convert next character from search string
+        if (!searchIter.ConvertFromUTF8(1, false))
+        {
+            // Shouldn't happen for valid search string
+            return false;
+        }
+
+        // Compare first UTF-16 code unit
+        if (bufInput[0] != bufSearch[0])
+        {
+            return false;
+        }
+
+        // Handle surrogate pairs (4-byte UTF-8 sequences)
+        if (bufInput[0] >= 0xD800 && bufInput[0] <= 0xDBFF)
+        {
+            // High surrogate
+            if (bufInput[1] != bufSearch[1])
+            {
+                // Low surrogate mismatch
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 HRESULT Library_corlib_native_System_String::IndexOf(CLR_RT_StackFrame &stack, int mode)
 {
     NATIVE_PROFILE_CLR_CORE();
@@ -594,8 +647,8 @@ HRESULT Library_corlib_native_System_String::IndexOf(CLR_RT_StackFrame &stack, i
     int startIndex;
     int count;
     int pos;
-    const char *pString;
-    const CLR_UINT16 *pChars;
+    const char *pString = NULL;
+    const CLR_UINT16 *pChars = NULL;
     int iChars = 0;
     CLR_RT_UnicodeHelper inputIterator;
     int inputLen;
@@ -605,8 +658,6 @@ HRESULT Library_corlib_native_System_String::IndexOf(CLR_RT_StackFrame &stack, i
     if (!szText)
         szText = "";
     pos = -1;
-    pString = NULL;
-    pChars = NULL;
 
     if (mode & c_IndexOf__SingleChar)
     {
@@ -617,23 +668,20 @@ HRESULT Library_corlib_native_System_String::IndexOf(CLR_RT_StackFrame &stack, i
     {
         CLR_RT_HeapBlock_Array *array = stack.Arg1().DereferenceArray();
         FAULT_ON_NULL(array);
-
         pChars = (const CLR_UINT16 *)array->GetFirstElement();
         iChars = array->m_numOfElements;
     }
     else if (mode & c_IndexOf__String)
     {
         pString = stack.Arg1().RecoverString();
         FAULT_ON_NULL(pString);
-        // how long is the search string?
         inputIterator.SetInputUTF8(pString);
         searchLen = inputIterator.CountNumberOfCharacters();
     }
 
-    // calculate input string length
+    // Calculate input length
     inputIterator.SetInputUTF8(szText);
     inputLen = inputIterator.CountNumberOfCharacters();
-
     if (0 == inputLen)
     {
         pos = -1;
@@ -647,7 +695,6 @@ HRESULT Library_corlib_native_System_String::IndexOf(CLR_RT_StackFrame &stack, i
     }
     else
     {
-        // for mode LastIndex... we are searching backwards toward the start of the string
         if (mode & c_IndexOf__Last)
         {
             startIndex = inputLen - 1;
@@ -663,49 +710,53 @@ HRESULT Library_corlib_native_System_String::IndexOf(CLR_RT_StackFrame &stack, i
         NANOCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
 
     // for mode LastIndex... with string we move the start index back by the search string length -1
+    // if we search forward
     if ((mode & c_IndexOf__String_Last) == c_IndexOf__String_Last)
     {
         startIndex -= searchLen - 1;
-        // check the start index; if not in range skip the search
+        // check the start index; if not in range, skip the search
         if (startIndex < 0 || startIndex > inputLen)
+        {
             goto Exit;
+        }
     }
 
     // calculate the iteration count
     if (mode & c_IndexOf__Count)
     {
-        // count form parameter
+        // count (from parameter)
         count = stack.Arg3().NumericByRefConst().s4;
     }
     else
     {
         // for mode LastIndex... we are searching from start index backwards toward the start of the string
         if (mode & c_IndexOf__Last)
         {
-            // backward until the start of string
-            // one more time than the startIndex because we should iterate until zero
+            // backwards until the start of the string
+            // one position ahead of the startIndex because we should iterate until position zero
             count = startIndex + 1;
         }
         else
         {
-            // forward until the end of string
+            // move forward until reaching the end of the string
             count = inputLen - startIndex;
         }
     }
 
-    // for mode with string we reduce the count by the search string length -1
-    // if we search foreward
+    // forward search with index of string mode: adjust the count by the search string length -1
     if ((mode & c_IndexOf__String_Last) == c_IndexOf__String)
     {
         count -= searchLen - 1;
     }
 
-    // check the count
+    // validate count
     if (mode & c_IndexOf__Last)
     {
         // check for backward mode; no exception; just exit
         if (count > startIndex + 1)
+        {
             goto Exit;
+        }
     }
     else
     {
@@ -717,132 +768,87 @@ HRESULT Library_corlib_native_System_String::IndexOf(CLR_RT_StackFrame &stack, i
     // First move to the character, then read it.
     if (inputIterator.ConvertFromUTF8(startIndex, true))
     {
-        // string mode?
+        // String search mode
         if (pString)
         {
-            // iterate thru all positions
             while (count-- > 0)
             {
-                CLR_RT_UnicodeHelper inputString;
-                inputString.SetInputUTF8((const char *)inputIterator.m_inputUTF8);
-                CLR_RT_UnicodeHelper searchString;
-                searchString.SetInputUTF8(pString);
-                bool finished = false;
-
-                while (true)
-                {
-                    CLR_UINT16 bufInput[3];
-                    CLR_UINT16 bufSearch[3];
-
-                    inputString.m_outputUTF16 = bufInput;
-                    inputString.m_outputUTF16_size = MAXSTRLEN(bufInput);
-
-                    searchString.m_outputUTF16 = bufSearch;
-                    searchString.m_outputUTF16_size = MAXSTRLEN(bufSearch);
-
-                    // read next char from search string; if no more chars to read (false)
-                    // then we are done and found the search string in the input string
-                    if (searchString.ConvertFromUTF8(1, false) == false)
-                    {
-                        pos = startIndex;
-                        finished = true;
-                        break;
-                    }
-
-                    // read the next char from the input string; if no more chars to read (false)
-                    // we didn't found the search string in the input string; we abort the search now
-                    if (inputString.ConvertFromUTF8(1, false) == false)
-                    {
-                        finished = true;
-                        break;
-                    }
-
-                    // does the char from input not match the char from the search string
-                    if (bufInput[0] != bufSearch[0])
-                    {
-                        // next iteration round but not finished
-                        break;
-                    }
-                }
-
-                // finished (with or without a found) then break
-                if (finished)
+                // Use helper for proper UTF-8 comparison
+                if (MatchString(inputIterator, pString, searchLen))
                 {
+                    pos = startIndex;
                     break;
                 }
 
-                // reading forward or backward
+                // Move to next candidate position (both forward or backward reading)
                 if (mode & c_IndexOf__Last)
                 {
                     startIndex--;
-                    // move one chars backward
-                    if (inputIterator.MoveBackwardInUTF8(szText, 1) == false)
+                    // move backwards one char
+                    if (!inputIterator.MoveBackwardInUTF8(szText, 1))
                     {
                         break;
                     }
                 }
                 else
                 {
                     startIndex++;
-                    // move to the next char
-                    if (inputIterator.ConvertFromUTF8(1, true) == false)
+                    // move forward to the next char
+                    if (!inputIterator.ConvertFromUTF8(1, true))
                     {
                         break;
                     }
                 }
             }
         }
 
-        // char mode?
-        if (pChars)
+        // Character search mode
+        else if (pChars)
         {
-            // iterate thru all positions
+            // iterate through all positions
             while (count-- > 0)
             {
-                CLR_UINT16 buf[3];
+                CLR_UINT16 buf[3] = {0};
 
                 inputIterator.m_outputUTF16 = buf;
                 inputIterator.m_outputUTF16_size = MAXSTRLEN(buf);
 
                 // read the next char from the input string; if no more chars to read (false)
-                // we didn't found the search chars in the input string
-                if (inputIterator.ConvertFromUTF8(1, false) == false)
+                // the search chars weren't found in the input string
+                if (!inputIterator.ConvertFromUTF8(1, false))
                 {
                     break;
                 }
 
-                // test each search char if it's a match
+                // test each search char for a match
                 for (int i = 0; i < iChars; i++)
                 {
-                    // match?
                     if (buf[0] == pChars[i])
                     {
-                        // position found!
+                        // found position for next char
                         pos = startIndex;
                         break;
                     }
                 }
 
-                // found? => break
+                // didn't find any, break
                 if (pos != -1)
                 {
                     break;
                 }
 
-                // for mode LastIndex... we are searching from start index backwards toward the start of the string
+                // for search mode LastIndex: we are searching from start index backwards toward the start of the string
                 if (mode & c_IndexOf__Last)
                 {
-                    // in backward mode
+                    // backwards mode
                     startIndex--;
-                    // move two chars backward, because the current char is already read
-                    if (inputIterator.MoveBackwardInUTF8(szText, 2) == false)
-                    {
+                    // have to move two chars backwards, because the current char is already read
+                    if (!inputIterator.MoveBackwardInUTF8(szText, 2))
                         break;
-                    }
                 }
                 else
                 {
-                    // forward mode; simple advance the start index
+                    // forward mode: just advance the start index
                     startIndex++;
                 }
             }
@@ -851,7 +857,6 @@ HRESULT Library_corlib_native_System_String::IndexOf(CLR_RT_StackFrame &stack, i
 
 Exit:
     stack.SetResult_I4(pos);
-
     NANOCLR_NOCLEANUP();
 }
 
@@ -889,10 +894,11 @@ HRESULT Library_corlib_native_System_String::ChangeCase(CLR_RT_StackFrame &stack
         *ptr++ = c;
     }
 
-    NANOCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance(
-        stack.PushValue(),
-        (CLR_UINT16 *)arrayTmp->GetFirstElement(),
-        arrayTmp->m_numOfElements));
+    NANOCLR_CHECK_HRESULT(
+        CLR_RT_HeapBlock_String::CreateInstance(
+            stack.PushValue(),
+            (CLR_UINT16 *)arrayTmp->GetFirstElement(),
+            arrayTmp->m_numOfElements));
 
     NANOCLR_NOCLEANUP();
 }
@@ -923,10 +929,11 @@ HRESULT Library_corlib_native_System_String::Substring(CLR_RT_StackFrame &stack,
             NANOCLR_SET_AND_LEAVE(CLR_E_OUT_OF_RANGE);
     }
 
-    NANOCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance(
-        stack.PushValue(),
-        (CLR_UINT16 *)arrayTmp->GetElement(startIndex),
-        length));
+    NANOCLR_CHECK_HRESULT(
+        CLR_RT_HeapBlock_String::CreateInstance(
+            stack.PushValue(),
+            (CLR_UINT16 *)arrayTmp->GetElement(startIndex),
+            length));
 
     NANOCLR_NOCLEANUP();
 }
@@ -1102,10 +1109,11 @@ HRESULT Library_corlib_native_System_String::Split(CLR_RT_StackFrame &stack, CLR
                         {
                             CLR_RT_HeapBlock *str = (CLR_RT_HeapBlock *)arrayDst->GetElement(count);
 
-                            NANOCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance(
-                                *str,
-                                pSrcStart,
-                                (CLR_UINT32)(pSrc - pSrcStart)));
+                            NANOCLR_CHECK_HRESULT(
+                                CLR_RT_HeapBlock_String::CreateInstance(
+                                    *str,
+                                    pSrcStart,
+                                    (CLR_UINT32)(pSrc - pSrcStart)));
 
                             pSrcStart = pSrc + 1;
                         }