With ICU, we cna have a much more comprehensive implementation for getting the range of a composed character sequence.

Author: rfm

ChangeLog

@@ -1,3 +1,13 @@
+2026-05-11 Richard Frith-Macdonald <rfm@gnu.org>
+
+	* Source/GSPrivate.h: New function to get composed sequence range.
+	* Source/GSString.m: Use new ICU based code if possible.
+	* Source/NSString.m: Use new ICU based code if possible.
+	* Tests/base/NSString/rangeOfComposedCharacter.m:
+	Range of composed character sequence testcases to cover a fairly
+	comprehensive range of cases rather than just the simplistic set
+	handled by the non-ICU code.
+
 2026-05-09 Richard Frith-Macdonald <rfm@gnu.org>
 
 	* Source/GSSocketStream.m:

Source/GSPrivate.h

@@ -464,6 +464,11 @@ void GSPrivateNotifyIdle(NSString *mode) GS_ATTRIB_PRIVATE;
  */
 BOOL GSPrivateNotifyMore(NSString *mode) GS_ATTRIB_PRIVATE;
 
+/* Function to return the range of a composed character sequence.
+ */
+NSRange GSPrivateRangeOfComposed(const unichar *buf, NSUInteger length,
+  NSUInteger index) GS_ATTRIB_PRIVATE;
+
 /* Function to return the function for searching in a string for a range.
  */
 typedef NSRange (*GSRSFunc)(id, id, unsigned, NSRange);

Source/GSString.m

@@ -3217,28 +3217,22 @@ static void GSStrWiden(GSStr s)
 rangeOfSequence_c(GSStr self, unsigned anIndex)
 {
   if (anIndex >= self->_count)
-    [NSException raise: NSRangeException format:@"Invalid location."];
+    [NSException raise: NSRangeException format: @"Invalid location."];
 
   return (NSRange){anIndex, 1};
 }
 
 static inline NSRange
 rangeOfSequence_u(GSStr self, unsigned anIndex)
 {
-  unsigned	start;
-  unsigned	end;
+  NSRange	result;
 
   if (anIndex >= self->_count)
-    [NSException raise: NSRangeException format:@"Invalid location."];
-
-  start = anIndex;
-  while (uni_isnonsp(self->_contents.u[start]) && start > 0)
-    start--;
-  end = start + 1;
-  if (end < self->_count)
-    while ((end < self->_count) && (uni_isnonsp(self->_contents.u[end])))
-      end++;
-  return (NSRange){start, end-start};
+    {
+      [NSException raise: NSRangeException format: @"Invalid location."];
+    }
+  result = GSPrivateRangeOfComposed(self->_contents.u, self->_count, anIndex);
+  return result;
 }
 
 static inline NSRange

Source/NSString.m

@@ -120,6 +120,7 @@
 # include <icu.h>
 #endif
 
+
 /* Create local inline versions of key functions for case-insensitive operations
  */
 #import "Additions/unicode/caseconv.h"
@@ -138,6 +139,101 @@
 
 #import "GNUstepBase/Unicode.h"
 
+NSRange GSPrivateRangeOfComposed(const unichar *buf, NSUInteger length, 
+  NSUInteger anIndex)
+{
+#if GS_USE_ICU  == 1
+  UErrorCode 		status = U_ZERO_ERROR;
+  int32_t		len = (int32_t)length;
+  int32_t		index = (int32_t)anIndex;
+  int32_t 		start;
+  int32_t		end;
+  UBreakIterator 	*bi;
+
+  /* Create a grapheme-cluster (UBRK_CHARACTER) break iterator
+   * over the UTF16 buffer.
+   */
+  bi = ubrk_open(UBRK_CHARACTER, NULL /* default locale */,
+    (const UChar*)buf, len, &status);
+
+  if (U_FAILURE(status) || NULL == bi)
+    {
+      return NSMakeRange(0, NSNotFound);
+    }
+
+  /* Find start, end of the grapheme cluster containing index.
+   *
+   * ubrk_isBoundary(bi, pos) returns true when pos is a cluster boundary
+   * AND leaves the iterator positioned at pos, ready for ubrk_next().
+   *
+   * Case A — index is itself a cluster-start boundary:
+   *   isBoundary returns true and positions the iterator there.
+   *   start = index, end = ubrk_next().
+   *
+   * Case B — index falls inside a cluster (e.g. trail surrogate, combining
+   *   mark, or non-first code unit of an emoji modifier sequence):
+   *   isBoundary returns false. ICU positions the iterator at the next
+   *   boundary strictly after index. We then call ubrk_preceding() to
+   *   step back to the cluster start, and ubrk_next() to return to the end.
+   *
+   * This avoids the pitfall of calling preceding(index+1) when index+1 is
+   * itself in the middle of a surrogate pair, which returns UBRK_DONE.
+   */
+  index = (int32_t)anIndex;
+  if (ubrk_isBoundary(bi, index))
+    {
+      start = index;
+      end   = ubrk_next(bi);
+    }
+  else
+    {
+      int32_t	next;
+
+      end   = ubrk_current(bi);
+      start = ubrk_preceding(bi, end);
+      next = ubrk_next(bi);
+      if (next != UBRK_DONE)
+	{
+	  end = next;
+	}
+    }
+
+  ubrk_close(bi);
+
+  if (UBRK_DONE == start || UBRK_DONE == end)
+    {
+      return NSMakeRange(0, NSNotFound);
+    }
+  return NSMakeRange((NSUInteger)start, (NSUInteger)(end - start));
+#else
+  unsigned	start;
+  unsigned	end;
+  unsigned	length = [self length];
+  unichar	ch;
+  unichar	(*caiImp)(NSString*, SEL, NSUInteger);
+
+  caiImp = (unichar (*)(NSString*,SEL,NSUInteger))
+    [self methodForSelector: caiSel];
+
+  for (start = anIndex; start > 0; start--)
+    {
+      ch = (*caiImp)(self, caiSel, start);
+      if (uni_isnonsp(ch) == NO)
+	break;
+    }
+  for (end = start+1; end < length; end++)
+    {
+      ch = (*caiImp)(self, caiSel, end);
+      if (uni_isnonsp(ch) == NO)
+	break;
+    }
+
+  return NSMakeRange(start, end-start);
+#endif
+}
+
+
+
 @interface	NSScanner (Double)
 + (BOOL) _scanDouble: (double*)value from: (NSString*)str;
 @end
@@ -3047,31 +3143,27 @@ - (NSUInteger) indexOfString: (NSString*)substring
  */
 - (NSRange) rangeOfComposedCharacterSequenceAtIndex: (NSUInteger)anIndex
 {
-  unsigned	start;
-  unsigned	end;
-  unsigned	length = [self length];
-  unichar	ch;
-  unichar	(*caiImp)(NSString*, SEL, NSUInteger);
+  NSUInteger	length = [self length];
 
   if (anIndex >= length)
-    [NSException raise: NSRangeException format:@"Invalid location."];
-  caiImp = (unichar (*)(NSString*,SEL,NSUInteger))
-    [self methodForSelector: caiSel];
-
-  for (start = anIndex; start > 0; start--)
     {
-      ch = (*caiImp)(self, caiSel, start);
-      if (uni_isnonsp(ch) == NO)
-        break;
+      [NSException raise: NSRangeException format: @"Invalid location."];
     }
-  for (end = start+1; end < length; end++)
+
+  if (0 == length)
     {
-      ch = (*caiImp)(self, caiSel, end);
-      if (uni_isnonsp(ch) == NO)
-        break;
+      return NSMakeRange(0, NSNotFound);
     }
+  else
+    {
+      NSRange	result;
+      GS_BEGINITEMBUF(buf, (length * sizeof(unichar)), unichar)
 
-  return NSMakeRange(start, end-start);
+      [self getCharacters: buf];
+      result = GSPrivateRangeOfComposed(buf, length, anIndex);
+      GS_ENDITEMBUF()
+      return result;
+    }
 }
 
 - (NSRange) rangeOfComposedCharacterSequencesForRange: (NSRange)range