Enable clojure.string-test.reverse

compiler+runtime/CMakeLists.txt

@@ -517,6 +517,7 @@ add_library(
   src/cpp/jtl/panic.cpp
   src/cpp/jtl/assert.cpp
   src/cpp/jtl/string_builder.cpp
+  src/cpp/jtl/utf8.cpp
   src/cpp/jank/c_api.cpp
   src/cpp/jank/hash.cpp
   src/cpp/jank/util/cli.cpp

compiler+runtime/include/cpp/jtl/utf8.hpp

@@ -0,0 +1,30 @@
+#include <jtl/immutable_string.hpp>
+
+namespace jtl
+{
+  struct utf8_iterator
+  {
+    using iterator_category = std::bidirectional_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+    using value_type = immutable_string;
+    using reference = value_type const &;
+
+    utf8_iterator() = default;
+    utf8_iterator(immutable_string const &s);
+    utf8_iterator(immutable_string const &s, value_type::size_type const position);
+
+    value_type operator*() const;
+    utf8_iterator &operator++();
+    utf8_iterator operator++(int);
+    utf8_iterator &operator--();
+    utf8_iterator operator--(int);
+    bool operator==(utf8_iterator const &it) const;
+
+    utf8_iterator begin() const;
+    utf8_iterator end() const;
+
+    value_type data;
+    value_type::size_type i{};
+    value_type::size_type n{};
+  };
+}

compiler+runtime/src/cpp/clojure/string_native.cpp

@@ -1,3 +1,7 @@
+#include <ranges>
+
+#include <jtl/utf8.hpp>
+
 #include <clojure/string_native.hpp>
 #include <jank/runtime/core.hpp>
 #include <jank/runtime/core/call.hpp>
@@ -26,7 +30,12 @@ namespace clojure::string_native
 
   jtl::immutable_string reverse(jtl::immutable_string const &s)
   {
-    return { s.rbegin(), s.rend() };
+    jtl::string_builder buff{ s.size() };
+    for(auto const &c : jtl::utf8_iterator(s) | std::views::reverse)
+    {
+      buff(c);
+    }
+    return buff.release();
   }
 
   jtl::immutable_string lower_case(jtl::immutable_string const &s)

compiler+runtime/src/cpp/jtl/utf8.cpp

@@ -0,0 +1,159 @@
+#include <jtl/utf8.hpp>
+
+namespace jtl
+{
+  using value_type = utf8_iterator::value_type;
+  using size_type = value_type::size_type;
+
+  static size_type next_char_size(immutable_string const &s, size_type const i)
+  {
+    auto const c(s[i]);
+    if(c <= 0x7f)
+    {
+      return 1;
+    }
+    else if((c & 0xE0) == 0xC0)
+    {
+      return 2;
+    }
+    else if((c & 0xF0) == 0xE0)
+    {
+      return 3;
+    }
+    else if((c & 0xF8) == 0xF0)
+    {
+      return 4;
+    }
+    else
+    {
+      throw std::runtime_error{ "Invalid UTF-8 string." };
+    }
+  }
+
+  static bool is_continuation_byte(immutable_string const &s, size_type const i)
+  {
+    if(i == immutable_string::npos)
+    {
+      throw std::runtime_error{ "Invalid UTF-8 string." };
+    }
+
+    return (s[i] & 0xC0) == 0x80;
+  }
+
+  static size_type prev_char_size(immutable_string const &data, size_type const i)
+  {
+    if(!is_continuation_byte(data, i - 1))
+    {
+      return 1;
+    }
+    else if(!is_continuation_byte(data, i - 2))
+    {
+      return 2;
+    }
+    else if(!is_continuation_byte(data, i - 3))
+    {
+      return 3;
+    }
+    else if(!is_continuation_byte(data, i - 4))
+    {
+      return 4;
+    }
+    else
+    {
+      throw std::runtime_error{ "Invalid UTF-8 string." };
+    }
+  }
+
+  utf8_iterator::utf8_iterator(immutable_string const &s)
+    : data{ s }
+    , i{ s.empty() ? value_type::npos : 0 }
+    , n{ i == value_type::npos ? 0 : next_char_size(s, i) }
+  {
+  }
+
+  utf8_iterator::utf8_iterator(immutable_string const &s, value_type::size_type const position)
+    : data{ s }
+    , i{ s.empty() ? value_type::npos : position }
+    , n{ i == value_type::npos ? 0 : next_char_size(s, i) }
+  {
+  }
+
+  value_type utf8_iterator::operator*() const
+  {
+    return data.substr(i, n);
+  }
+
+  utf8_iterator &utf8_iterator::operator++()
+  {
+    if(i == value_type::npos)
+    {
+      i = 0;
+      n = next_char_size(data, i);
+    }
+    else
+    {
+      i += n;
+      if(i >= data.size())
+      {
+        i = value_type::npos;
+        n = 0;
+      }
+      else
+      {
+        n = next_char_size(data, i);
+      }
+    }
+
+    return *this;
+  }
+
+  utf8_iterator utf8_iterator::operator++(int)
+  {
+    auto tmp{ *this };
+    ++*this;
+    return tmp;
+  }
+
+  utf8_iterator &utf8_iterator::operator--()
+  {
+    if(i == 0)
+    {
+      i = value_type::npos;
+      n = 0;
+    }
+    else if(i == value_type::npos)
+    {
+      auto const size(data.size());
+      n = prev_char_size(data, size);
+      i = size - n;
+    }
+    else
+    {
+      n = prev_char_size(data, i);
+      i -= n;
+    }
+    return *this;
+  }
+
+  utf8_iterator utf8_iterator::operator--(int)
+  {
+    auto tmp{ *this };
+    --*this;
+    return tmp;
+  }
+
+  bool utf8_iterator::operator==(utf8_iterator const &it) const
+  {
+    return i == it.i && (data.data() == it.data.data() || data == it.data);
+  }
+
+  utf8_iterator utf8_iterator::begin() const
+  {
+    return { data, 0 };
+  }
+
+  utf8_iterator utf8_iterator::end() const
+  {
+    return { data, value_type::npos };
+  }
+}

compiler+runtime/test/bash/clojure-test-suite/src/jank_test/run_clojure_test_suite.cljc

@@ -233,7 +233,7 @@
     clojure.string-test.ends-with-qmark
     ; clojure.string-test.escape ; Uncaught exception: Can't convert character to integer.
     clojure.string-test.lower-case
-    ; clojure.string-test.reverse ; issues with unicode
+    clojure.string-test.reverse
     clojure.string-test.starts-with-qmark
     clojure.string-test.upper-case
   ])