string slice function

Author: wonja

context.cpp

@@ -364,6 +364,7 @@ namespace Sass {
     register_function(ctx, str_length_sig, str_length, env);
     register_function(ctx, str_insert_sig, str_insert, env);
     register_function(ctx, str_index_sig, str_index, env);
+    register_function(ctx, str_slice_sig, str_slice, env);
     // Number Functions
     register_function(ctx, percentage_sig, percentage, env);
     register_function(ctx, round_sig, round, env);

functions.cpp

@@ -771,6 +771,35 @@ namespace Sass {
       return new (ctx.mem) Number(path, position, index);
     }
 
+    Signature str_slice_sig = "str-slice($string, $start-at, $end-at:-1)";
+    BUILT_IN(str_slice)
+    {
+      String_Constant* s = ARG("$string", String_Constant);
+      Number* n = ARG("$start-at", Number);
+      Number* m = ARG("$end-at", Number);
+
+      string str = s->value();
+      char quotemark = s->quote_mark();
+      str = unquote(str);
+
+      // normalize into 0-based indices
+      size_t start = UTF_8::code_point_offset_to_byte_offset(str, UTF_8::normalize_index(n->value(), UTF_8::code_point_count(str)));
+      size_t end = UTF_8::code_point_offset_to_byte_offset(str, UTF_8::normalize_index(m->value(), UTF_8::code_point_count(str)));
+
+      string newstr;
+      if(start - end == 0) {
+        newstr = str.substr(start, end - start);
+      } else {
+        newstr = str.substr(start, end - start + UTF_8::length_of_code_point_at(str, end));
+      }
+      if(quotemark) {
+        newstr = quote(newstr, quotemark);
+      }
+
+      return new (ctx.mem) String_Constant(path, position, newstr);
+
+    }
+
     ///////////////////
     // NUMBER FUNCTIONS
     ///////////////////

functions.hpp

@@ -67,6 +67,7 @@ namespace Sass {
     extern Signature str_length_sig;
     extern Signature str_insert_sig;
     extern Signature str_index_sig;
+    extern Signature str_slice_sig;
     extern Signature percentage_sig;
     extern Signature round_sig;
     extern Signature ceil_sig;
@@ -121,6 +122,7 @@ namespace Sass {
     BUILT_IN(str_length);
     BUILT_IN(str_insert);
     BUILT_IN(str_index);
+    BUILT_IN(str_slice);
     BUILT_IN(percentage);
     BUILT_IN(round);
     BUILT_IN(ceil);

utf8_string.cpp

@@ -73,6 +73,50 @@ namespace Sass {
       return i;
     }
 
+    // function that returns number of bytes in a character in a string
+    size_t length_of_code_point_at(const string& str, size_t pos) {
+      unsigned char c = static_cast<unsigned char>(str[pos]);
+      size_t i = 0;
+      if(c < 128) {
+        return 1;
+      } else {
+        ++i; // go to the next byte
+        ++pos;
+        // see if it's still part of the sequence
+        while ((i < str.length()) && ((static_cast<unsigned char>(str[pos]) & 0b11000000) == 0b10000000)) {
+          ++i;
+          ++pos;
+        }
+      }
+      return i;
+    }
+
+    // function that will return a normalized index, given a crazy one
+    size_t normalize_index(int index, size_t len) {
+      int signed_len = len;
+      // assuming the index is 1-based
+      // we are returning a 0-based index
+      if (index > 0 && index <= signed_len) {
+        // positive and within string length
+        return index-1;
+      } 
+      else if (index > signed_len) {
+        // positive and past string length
+        return len;
+      }
+      else if (index == 0) {
+        return 0;
+      }
+      else if (std::abs(index) <= signed_len) {
+        // negative and within string length
+        return index + signed_len;
+      }
+      else {
+        // negative and past string length
+        return 0;
+      }
+    }
+
   }
 }
 

utf8_string.hpp

@@ -20,8 +20,15 @@ namespace Sass {
     size_t code_point_count(const string& str, size_t start, size_t end);
     size_t code_point_count(const string& str);
 
+    // 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);
 
+    // function that returns number of bytes in a character in a string
+    size_t length_of_code_point_at(const string& str, size_t pos);
+
+    // function that will return a normalized index, given a crazy one
+    size_t normalize_index(int index, size_t len);
+
   }
 }