Merge tag 'v2.0' into python

Author: dahlia

Makefile

@@ -1,5 +1,5 @@
 CXX      ?= g++
-CXXFLAGS = -Wall -O2 -fPIC -g
+CXXFLAGS = -Wall -O2 -fPIC
 LDFLAGS  = -fPIC
 
 PREFIX    = /usr/local
@@ -35,7 +35,8 @@ SOURCES = \
 	source_map.cpp \
 	to_c.cpp \
 	to_string.cpp \
-	units.cpp
+	units.cpp \
+	utf8_string.cpp
 
 OBJECTS = $(SOURCES:.cpp=.o)
 

context.cpp

@@ -45,11 +45,11 @@ namespace Sass {
   : mem(Memory_Manager<AST_Node>()),
     source_c_str    (initializers.source_c_str()),
     sources         (vector<const char*>()),
-    c_functions     (vector<Sass_C_Function_Descriptor>()),
     include_paths   (initializers.include_paths()),
     queue           (vector<pair<string, const char*> >()),
     style_sheets    (map<string, Block*>()),
     source_map(File::base_name(initializers.output_path())),
+    c_functions     (vector<Sass_C_Function_Descriptor>()),
     image_path      (initializers.image_path()),
     source_comments (initializers.source_comments()),
     source_maps     (initializers.source_maps()),
@@ -362,6 +362,11 @@ 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);
+    register_function(ctx, str_index_sig, str_index, env);
+    register_function(ctx, str_slice_sig, str_slice, env);
+    register_function(ctx, to_upper_case_sig, to_upper_case, env);
+    register_function(ctx, to_lower_case_sig, to_lower_case, env);
     // Number Functions
     register_function(ctx, percentage_sig, percentage, env);
     register_function(ctx, round_sig, round, env);

expand.cpp

@@ -141,9 +141,13 @@ namespace Sass {
     return 0;
   }
 
-  Statement* Expand::operator()(Import* i)
+  Statement* Expand::operator()(Import* imp)
   {
-    return i; // TODO: eval i->urls()
+    Import* result = new (ctx.mem) Import(imp->path(), imp->position());
+    for ( size_t i = 0, S = imp->urls().size(); i < S; ++i) {
+      result->urls().push_back(imp->urls()[i]->perform(eval->with(env, backtrace)));
+    }
+    return result;
   }
 
   Statement* Expand::operator()(Import_Stub* i)

extend.cpp

@@ -310,4 +310,4 @@ namespace Sass {
     return results;
   }
 
-}
+}

functions.cpp

@@ -7,6 +7,7 @@
 #include "to_string.hpp"
 #include "inspect.hpp"
 #include "eval.hpp"
+#include "utf8_string.hpp"
 
 #include <cmath>
 #include <cctype>
@@ -695,7 +696,6 @@ namespace Sass {
     {
       String_Constant* s = ARG("$string", String_Constant);
       string str = s->value();
-      size_t len = 0;
       size_t length_of_s = str.size();
       size_t i = 0;
 
@@ -704,27 +704,128 @@ namespace Sass {
         --length_of_s;
       }
 
-      while (i < length_of_s) {
-        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 < length_of_s) && ((static_cast<unsigned char>(str[i]) & 0b11000000) == 0b10000000)) {
-            ++i;
-          }
-          // when it's not [aka a new leading bit], increment and move on
-          ++len;
-        }
-      }
+      size_t len = UTF_8::code_point_count(str, i, length_of_s);
+
       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);
+
+    }
+
+    Signature str_index_sig = "str-index($string, $substring)";
+    BUILT_IN(str_index)
+    {
+      String_Constant* s = ARG("$string", String_Constant);
+      String_Constant* t = ARG("$substring", String_Constant);
+      string str = s->value();
+      str = unquote(str);
+      string substr = t->value();
+      substr = unquote(substr);
+
+      size_t c_index = str.find(substr);
+      if(c_index == string::npos) {
+        return new (ctx.mem) Null(path, position);
+      }
+      size_t index = UTF_8::code_point_count(str, 0, c_index + 1);
+
+      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);
+
+    }
+
+    Signature to_upper_case_sig = "to-upper-case($string)";
+    BUILT_IN(to_upper_case)
+    {
+      String_Constant* s = ARG("$string", String_Constant);
+      string str = s->value();
+
+      for (size_t i = 0, L = str.length(); i < L; ++i) {
+        str[i] = std::toupper(str[i]);
+      }
+
+      return new (ctx.mem) String_Constant(path, position, str);
+    }
+
+    Signature to_lower_case_sig = "to-lower-case($string)";
+    BUILT_IN(to_lower_case)
+    {
+      String_Constant* s = ARG("$string", String_Constant);
+      string str = s->value();
+
+      for (size_t i = 0, L = str.length(); i < L; ++i) {
+        str[i] = std::tolower(str[i]);
+      }
+
+      return new (ctx.mem) String_Constant(path, position, str);
+    }
+
     ///////////////////
     // NUMBER FUNCTIONS
     ///////////////////

functions.hpp

@@ -65,6 +65,11 @@ namespace Sass {
     extern Signature unquote_sig;
     extern Signature quote_sig;
     extern Signature str_length_sig;
+    extern Signature str_insert_sig;
+    extern Signature str_index_sig;
+    extern Signature str_slice_sig;
+    extern Signature to_upper_case_sig;
+    extern Signature to_lower_case_sig;
     extern Signature percentage_sig;
     extern Signature round_sig;
     extern Signature ceil_sig;
@@ -117,6 +122,11 @@ namespace Sass {
     BUILT_IN(sass_unquote);
     BUILT_IN(sass_quote);
     BUILT_IN(str_length);
+    BUILT_IN(str_insert);
+    BUILT_IN(str_index);
+    BUILT_IN(str_slice);
+    BUILT_IN(to_upper_case);
+    BUILT_IN(to_lower_case);
     BUILT_IN(percentage);
     BUILT_IN(round);
     BUILT_IN(ceil);

output_compressed.cpp

@@ -2,6 +2,7 @@
 #include "inspect.hpp"
 #include "ast.hpp"
 #include "context.hpp"
+#include "to_string.hpp"
 
 namespace Sass {
   using namespace std;
@@ -183,7 +184,16 @@ namespace Sass {
 
   void Output_Compressed::operator()(Comment* c)
   {
-    return;
+    To_String to_string;
+    string txt = c->text()->perform(&to_string);
+    if(txt[2] != '!') {
+      return;
+    }
+    else {
+      Inspect i(ctx);
+      c->perform(&i);
+      buffer += i.get_buffer();
+    }
   }
 
   void Output_Compressed::operator()(List* list)

parser.cpp

@@ -411,14 +411,26 @@ namespace Sass {
   Compound_Selector* Parser::parse_simple_selector_sequence()
   {
     Compound_Selector* seq = new (ctx.mem) Compound_Selector(path, source_position);
-    // check for backref or type selector, which are only allowed at the front
+    bool sawsomething = false;
     if (lex< exactly<'&'> >()) {
+      // if you see a &
       (*seq) << new (ctx.mem) Selector_Reference(path, source_position);
+      sawsomething = true;
+      // if you see a space after a &, then you're done
+      if(lex< spaces >()) {
+        return seq;
+      }
     }
-    else if (lex< sequence< negate< functional >, alternatives< type_selector, universal, string_constant, dimension, percentage, number > > >()) {
+    if (sawsomething && lex< sequence< negate< functional >, alternatives< hyphens_and_identifier, universal, string_constant, dimension, percentage, number > > >()) {
+      // saw an ampersand, then allow type selectors with arbitrary number of hyphens at the beginning
+      (*seq) << new (ctx.mem) Type_Selector(path, source_position, lexed);
+    } else if (lex< sequence< negate< functional >, alternatives< type_selector, universal, string_constant, dimension, percentage, number > > >()) {
+      // if you see a type selector
       (*seq) << new (ctx.mem) Type_Selector(path, source_position, lexed);
+      sawsomething = true;
     }
-    else {
+    if (!sawsomething) {
+      // don't blindly do this if you saw a & or selector
       (*seq) << parse_simple_selector();
     }
 
@@ -1475,6 +1487,7 @@ namespace Sass {
     bool saw_interpolant = false;
 
     while ((q = peek< identifier >(p))                             ||
+           (q = peek< hyphens_and_identifier >(p))                 ||
            (q = peek< type_selector >(p))                          ||
            (q = peek< id_name >(p))                                ||
            (q = peek< class_name >(p))                             ||

prelexer.cpp

@@ -245,6 +245,9 @@ namespace Sass {
     const char* type_selector(const char* src) {
       return sequence< optional<namespace_prefix>, identifier>(src);
     }
+    const char* hyphens_and_identifier(const char* src) {
+      return sequence< zero_plus< exactly< '-' > >, identifier >(src);
+    }
     const char* universal(const char* src) {
       return sequence< optional<namespace_prefix>, exactly<'*'> >(src);
     }

prelexer.hpp

@@ -369,6 +369,7 @@ namespace Sass {
     // Match CSS type selectors
     const char* namespace_prefix(const char* src);
     const char* type_selector(const char* src);
+    const char* hyphens_and_identifier(const char* src);
     const char* universal(const char* src);
     // Match CSS id names.
     const char* id_name(const char* src);