string insert function using code point offset to byte offset function

Author: wonja

Makefile

@@ -1,5 +1,5 @@
 CXX      ?= g++
-CXXFLAGS = -Wall -O2 -fPIC -g
+CXXFLAGS = -Wall -fPIC -g
 LDFLAGS  = -fPIC
 
 PREFIX    = /usr/local

context.cpp

@@ -362,6 +362,7 @@ namespace Sass {
     register_function(ctx, unquote_sig, sass_unquote, env);
     register_function(ctx, quote_sig, sass_quote, env);
     register_function(ctx, str_length_sig, str_length, env);
+    register_function(ctx, str_insert_sig, str_insert, env);
     // Number Functions
     register_function(ctx, percentage_sig, percentage, env);
     register_function(ctx, round_sig, round, env);

functions.cpp

@@ -709,6 +709,49 @@ namespace Sass {
       return new (ctx.mem) Number(path, position, len);
     }
 
+    Signature str_insert_sig = "str-insert($string, $insert, $index)";
+    BUILT_IN(str_insert)
+    {
+      String_Constant* s = ARG("$string", String_Constant);
+      string str = s->value();
+      char quotemark = s->quote_mark();
+      str = unquote(str);
+      String_Constant* i = ARG("$insert", String_Constant);
+      string ins = i->value();
+      ins = unquote(ins);
+      Number* ind = ARG("$index", Number);
+      double index = ind->value();
+      size_t len = UTF_8::code_point_count(str, 0, str.size());
+
+      if (index > 0 && index <= len) {
+        // positive and within string length
+        str.insert(UTF_8::code_point_offset_to_byte_offset(str, index-1), ins);
+      } 
+      else if (index > len) {
+        // positive and past string length
+        str += ins;
+      }
+      else if (index == 0) {
+        str = ins + str;
+      }
+      else if (std::abs(index) <= len) {
+        // negative and within string length
+        index += len + 1;
+        str.insert(UTF_8::code_point_offset_to_byte_offset(str, index), ins);
+      }
+      else {
+        // negative and past string length
+        str = ins + str;
+      }
+
+      if (quotemark) {
+        str = quote(str, quotemark);
+      }
+
+      return new (ctx.mem) String_Constant(path, position, str);
+
+    }
+
     ///////////////////
     // NUMBER FUNCTIONS
     ///////////////////

functions.hpp

@@ -65,6 +65,7 @@ namespace Sass {
     extern Signature unquote_sig;
     extern Signature quote_sig;
     extern Signature str_length_sig;
+    extern Signature str_insert_sig;
     extern Signature percentage_sig;
     extern Signature round_sig;
     extern Signature ceil_sig;
@@ -117,6 +118,7 @@ namespace Sass {
     BUILT_IN(sass_unquote);
     BUILT_IN(sass_quote);
     BUILT_IN(str_length);
+    BUILT_IN(str_insert);
     BUILT_IN(percentage);
     BUILT_IN(round);
     BUILT_IN(ceil);

utf8_string.cpp

@@ -47,6 +47,32 @@ namespace Sass {
       return code_point_count(str, 0, str.length());
     }
 
+    // function that will return the byte offset of a code point in a
+    size_t code_point_offset_to_byte_offset(const string& str, size_t offset) {
+      size_t i = 0;
+      size_t len = 0;
+
+      while (len < offset) {
+        unsigned char c = static_cast<unsigned char>(str[i]);
+        if (c < 128) {
+          // it's a single-byte character
+          ++len;
+          ++i;
+        }
+        // it's a multi bit sequence and presumably it's a leading bit
+        else {
+          ++i; // go to the next byte
+          // see if it's still part of the sequence
+          while ((i < str.length()) && ((static_cast<unsigned char>(str[i]) & 0b11000000) == 0b10000000)) {
+            ++i;
+          }
+          // when it's not [aka a new leading bit], increment and move on
+          ++len;
+        }
+      }
+      return i;
+    }
+
   }
 }
 

utf8_string.hpp

@@ -20,6 +20,8 @@ namespace Sass {
     size_t code_point_count(const string& str, size_t start, size_t end);
     size_t code_point_count(const string& str);
 
+    size_t code_point_offset_to_byte_offset(const string& str, size_t offset);
+
   }
 }