sassc 1.8.3 → 1.8.4

data/ext/libsass/src/parser.hpp

@@ -23,11 +23,11 @@ namespace Sass {
   class Parser : public ParserState {
   public:
 
-    enum Syntactic_Context { nothing, mixin_def, function_def };
+    enum Scope { Root, Mixin, Function, Media, Control, Properties, Rules };
 
     Context& ctx;
     std::vector<Block*> block_stack;
-    std::vector<Syntactic_Context> stack;
+    std::vector<Scope> stack;
     Media_Block* last_media_block;
     const char* source;
     const char* position;
@@ -44,14 +44,14 @@ namespace Sass {
     Parser(Context& ctx, const ParserState& pstate)
     : ParserState(pstate), ctx(ctx), block_stack(0), stack(0), last_media_block(0),
       source(0), position(0), end(0), before_token(pstate), after_token(pstate), pstate(pstate), indentation(0)
-    { in_at_root = false; stack.push_back(nothing); }
+    { in_at_root = false; stack.push_back(Scope::Root); }
 
     // static Parser from_string(const std::string& src, Context& ctx, ParserState pstate = ParserState("[STRING]"));
-    static Parser from_c_str(const char* src, Context& ctx, ParserState pstate = ParserState("[CSTRING]"));
-    static Parser from_c_str(const char* beg, const char* end, Context& ctx, ParserState pstate = ParserState("[CSTRING]"));
-    static Parser from_token(Token t, Context& ctx, ParserState pstate = ParserState("[TOKEN]"));
+    static Parser from_c_str(const char* src, Context& ctx, ParserState pstate = ParserState("[CSTRING]"), const char* source = 0);
+    static Parser from_c_str(const char* beg, const char* end, Context& ctx, ParserState pstate = ParserState("[CSTRING]"), const char* source = 0);
+    static Parser from_token(Token t, Context& ctx, ParserState pstate = ParserState("[TOKEN]"), const char* source = 0);
     // special static parsers to convert strings into certain selectors
-    static Selector_List* parse_selector(const char* src, Context& ctx, ParserState pstate = ParserState("[SELECTOR]"));
+    static Selector_List* parse_selector(const char* src, Context& ctx, ParserState pstate = ParserState("[SELECTOR]"), const char* source = 0);
 
 #ifdef __clang__
 
@@ -96,6 +96,15 @@ namespace Sass {
 
     }
 
+    // peek will only skip over space, tabs and line comment
+    // return the position where the lexer match will occur
+    template <Prelexer::prelexer mx>
+    const char* match(const char* start = 0)
+    {
+      // match the given prelexer
+      return mx(position);
+    }
+
     // peek will only skip over space, tabs and line comment
     // return the position where the lexer match will occur
     template <Prelexer::prelexer mx>
@@ -253,6 +262,7 @@ namespace Sass {
     Function_Call* parse_function_call();
     Function_Call_Schema* parse_function_call_schema();
     String* parse_url_function_string();
+    String* parse_url_function_argument();
     String* parse_interpolated_chunk(Token, bool constant = false);
     String* parse_string();
     String_Constant* parse_static_expression();
@@ -298,8 +308,8 @@ namespace Sass {
     Lookahead lookahead_for_selector(const char* start = 0);
     Lookahead lookahead_for_include(const char* start = 0);
 
-    Expression* fold_operands(Expression* base, std::vector<Expression*>& operands, Sass_OP op);
-    Expression* fold_operands(Expression* base, std::vector<Expression*>& operands, std::vector<Sass_OP>& ops);
+    Expression* fold_operands(Expression* base, std::vector<Expression*>& operands, Operand op);
+    Expression* fold_operands(Expression* base, std::vector<Expression*>& operands, std::vector<Operand>& ops, size_t i = 0);
 
     void throw_syntax_error(std::string message, size_t ln = 0);
     void throw_read_error(std::string message, size_t ln = 0);

data/ext/libsass/src/plugins.cpp

@@ -7,6 +7,7 @@
 #include <dlfcn.h>
 #endif
 
+#include "sass.hpp"
 #include <iostream>
 #include "output.hpp"
 #include "plugins.hpp"

data/ext/libsass/src/position.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include "position.hpp"
 
 namespace Sass {

data/ext/libsass/src/prelexer.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include <cctype>
 #include <cstddef>
 #include <iostream>
@@ -153,8 +154,8 @@ namespace Sass {
              >(src);
     }
 
-    // Match CSS unit identifier.
-    const char* unit_identifier(const char* src)
+    // Match a single CSS unit
+    const char* one_unit(const char* src)
     {
       return sequence <
                optional < exactly <'-'> >,
@@ -169,6 +170,34 @@ namespace Sass {
              >(src);
     }
 
+    // Match numerator/denominator CSS units
+    const char* multiple_units(const char* src)
+    {
+      return
+        sequence <
+          one_unit,
+          zero_plus <
+            sequence <
+              exactly <'*'>,
+              one_unit
+            >
+          >
+        >(src);
+    }
+
+    // Match complex CSS unit identifiers
+    const char* unit_identifier(const char* src)
+    {
+      return sequence <
+        multiple_units,
+        optional <
+          sequence <
+          exactly <'/'>,
+          multiple_units
+        > >
+      >(src);
+    }
+
     const char* identifier_alnums(const char* src)
     {
       return one_plus< identifier_alnum >(src);
@@ -194,7 +223,12 @@ namespace Sass {
                  sequence <
                    zero_plus <
                      alternatives <
-                       identifier,
+                       sequence <
+                         optional <
+                           exactly <'$'>
+                         >,
+                         identifier
+                       >,
                        exactly <'-'>
                      >
                    >,
@@ -202,9 +236,13 @@ namespace Sass {
                    zero_plus <
                      alternatives <
                        digits,
-                       identifier,
+                       sequence <
+                         optional <
+                           exactly <'$'>
+                         >,
+                         identifier
+                       >,
                        quoted_string,
-                       exactly<'+'>,
                        exactly<'-'>
                      >
                    >
@@ -278,18 +316,54 @@ namespace Sass {
       >(src);
     }
 
-    const char* value_schema(const char* src) {
-      // follows this pattern: ([xyz]*i[xyz]*)+
-      return one_plus< sequence< zero_plus< alternatives< identifier, percentage, dimension, hex, number, quoted_string > >,
-                                 interpolant,
-                                 zero_plus< alternatives< identifier, percentage, dimension, hex, number, quoted_string, exactly<'%'> > > > >(src);
+    const char* sass_value(const char* src) {
+      return alternatives <
+        quoted_string,
+        identifier,
+        percentage,
+        hex,
+        dimension,
+        number
+      >(src);
     }
 
-    /* not used anymore - remove?
-    const char* filename(const char* src) {
-      return one_plus< alternatives< identifier, number, exactly<'.'> > >(src);
+    // this is basically `one_plus < sass_value >`
+    // takes care to not parse invalid combinations
+    const char* value_combinations(const char* src) {
+      // `2px-2px` is invalid combo
+      bool was_number = false;
+      const char* pos = src;
+      while (src) {
+        if ((pos = alternatives < quoted_string, identifier, percentage, hex >(src))) {
+          was_number = false;
+          src = pos;
+        } else if (!was_number && !exactly<'+'>(src) && (pos = alternatives < dimension, number >(src))) {
+          was_number = true;
+          src = pos;
+        } else {
+          break;
+        }
+      }
+      return src;
+    }
+
+    // must be at least one interpolant
+    // can be surrounded by sass values
+    // make sure to never parse (dim)(dim)
+    // since this wrongly consumes `2px-1px`
+    // `2px1px` is valid number (unit `px1px`)
+    const char* value_schema(const char* src)
+    {
+      return sequence <
+        one_plus <
+          sequence <
+            optional < value_combinations >,
+            interpolant,
+            optional < value_combinations >
+          >
+        >
+      >(src);
     }
-    */
 
     // Match CSS '@' keywords.
     const char* at_keyword(const char* src) {
@@ -539,6 +613,9 @@ namespace Sass {
     }
     // Match CSS numeric constants.
 
+    const char* op(const char* src) {
+      return class_char<op_chars>(src);
+    }
     const char* sign(const char* src) {
       return class_char<sign_chars>(src);
     }
@@ -603,23 +680,19 @@ namespace Sass {
     // Match CSS uri specifiers.
 
     const char* uri_prefix(const char* src) {
-      return exactly<url_kwd>(src);
-    }
-    const char* uri_value(const char* src)
-    {
-      return
-      sequence <
-        negate <
-          exactly < '$' >
+      return sequence <
+        exactly <
+          url_kwd
         >,
         zero_plus <
-          alternatives <
-            alnum,
-            interpolant,
-            exactly <'/'>,
-            class_char < uri_chars >
+          sequence <
+            exactly <'-'>,
+            one_plus <
+              alpha
+            >
           >
-        >
+        >,
+        exactly <'('>
       >(src);
     }
 
@@ -1107,34 +1180,39 @@ namespace Sass {
       return sequence< number, optional_spaces, exactly<'/'>, optional_spaces, number >(src);
     }
 
-    template <size_t size, prelexer mx, prelexer pad>
-    const char* padded_token(const char* src)
-    {
-      size_t got = 0;
-      const char* pos = src;
-      while (got < size) {
-        if (!mx(pos)) break;
-        ++ pos; ++ got;
-      }
-      while (got < size) {
-        if (!pad(pos)) break;
-        ++ pos; ++ got;
-      }
-      return got ? pos : 0;
-    }
-
-    template <size_t min, size_t max, prelexer mx>
-    const char* minmax_range(const char* src)
-    {
-      size_t got = 0;
-      const char* pos = src;
-      while (got < max) {
-        if (!mx(pos)) break;
-        ++ pos; ++ got;
-      }
-      if (got < min) return 0;
-      if (got > max) return 0;
-      return pos;
+    // lexer special_fn: these functions cannot be overloaded
+    // (/((-[\w-]+-)?(calc|element)|expression|progid:[a-z\.]*)\(/i)
+    const char* re_special_fun(const char* src) {
+      return sequence <
+        optional <
+          sequence <
+            exactly <'-'>,
+            one_plus <
+              alternatives <
+                alpha,
+                exactly <'+'>,
+                exactly <'-'>
+              >
+            >
+          >
+        >,
+        alternatives <
+          exactly < calc_fn_kwd >,
+          exactly < expression_kwd >,
+          sequence <
+            sequence <
+              exactly < progid_kwd >,
+              exactly <':'>
+            >,
+            zero_plus <
+              alternatives <
+                char_range <'a', 'z'>,
+                exactly <'.'>
+              >
+            >
+          >
+        >
+      >(src);
     }
 
   }

data/ext/libsass/src/prelexer.hpp

@@ -200,6 +200,8 @@ namespace Sass {
     const char* strict_identifier_alpha(const char* src);
     const char* strict_identifier_alnum(const char* src);
     // Match a CSS unit identifier.
+    const char* one_unit(const char* src);
+    const char* multiple_units(const char* src);
     const char* unit_identifier(const char* src);
     // const char* strict_identifier_alnums(const char* src);
     // Match reference selector.
@@ -210,6 +212,7 @@ namespace Sass {
     // Match interpolant schemas
     const char* identifier_schema(const char* src);
     const char* value_schema(const char* src);
+    const char* sass_value(const char* src);
     // const char* filename(const char* src);
     // const char* filename_schema(const char* src);
     // const char* url_schema(const char* src);
@@ -252,6 +255,7 @@ namespace Sass {
     const char* re_nothing(const char* src);
     const char* re_type_selector2(const char* src);
 
+    const char* re_special_fun(const char* src);
 
     const char* kwd_warn(const char* src);
     const char* kwd_err(const char* src);
@@ -282,6 +286,7 @@ namespace Sass {
     // Match placeholder selectors.
     const char* placeholder(const char* src);
     // Match CSS numeric constants.
+    const char* op(const char* src);
     const char* sign(const char* src);
     const char* unsigned_number(const char* src);
     const char* number(const char* src);
@@ -296,7 +301,6 @@ namespace Sass {
     // const char* rgb_prefix(const char* src);
     // Match CSS uri specifiers.
     const char* uri_prefix(const char* src);
-    const char* uri_value(const char* src);
     // Match CSS "!important" keyword.
     const char* kwd_important(const char* src);
     // Match CSS "!optional" keyword.
@@ -381,6 +385,18 @@ namespace Sass {
       }
       return 0;
     }
+    template<prelexer mx, prelexer skip>
+    const char* find_first_in_interval(const char* beg, const char* end) {
+      bool esc = false;
+      while ((beg < end) && *beg) {
+        if (esc) esc = false;
+        else if (*beg == '\\') esc = true;
+        else if (const char* pos = skip(beg)) beg = pos;
+        else if (mx(beg)) return beg;
+        ++beg;
+      }
+      return 0;
+    }
     template <prelexer mx>
     unsigned int count_interval(const char* beg, const char* end) {
       unsigned int counter = 0;
@@ -405,10 +421,42 @@ namespace Sass {
     }
 
     template <size_t size, prelexer mx, prelexer pad>
-    const char* padded_token(const char* src);
+    const char* padded_token(const char* src)
+    {
+      size_t got = 0;
+      const char* pos = src;
+      while (got < size) {
+        if (!mx(pos)) break;
+        ++ pos; ++ got;
+      }
+      while (got < size) {
+        if (!pad(pos)) break;
+        ++ pos; ++ got;
+      }
+      return got ? pos : 0;
+    }
 
     template <size_t min, size_t max, prelexer mx>
-    const char* minmax_range(const char* src);
+    const char* minmax_range(const char* src)
+    {
+      size_t got = 0;
+      const char* pos = src;
+      while (got < max) {
+        if (!mx(pos)) break;
+        ++ pos; ++ got;
+      }
+      if (got < min) return 0;
+      if (got > max) return 0;
+      return pos;
+    }
+
+    template <char min, char max>
+    const char* char_range(const char* src)
+    {
+      if (*src < min) return 0;
+      if (*src > max) return 0;
+      return src + 1;
+    }
 
   }
 }

data/ext/libsass/src/remove_placeholders.cpp

@@ -1,7 +1,7 @@
+#include "sass.hpp"
 #include "remove_placeholders.hpp"
 #include "context.hpp"
 #include "inspect.hpp"
-#include "to_string.hpp"
 #include <iostream>
 
 namespace Sass {
@@ -16,21 +16,47 @@ namespace Sass {
         }
     }
 
+    Selector_List* Remove_Placeholders::remove_placeholders(Selector_List* sl)
+    {
+      Selector_List* new_sl = SASS_MEMORY_NEW(ctx.mem, Selector_List, sl->pstate());
+
+      for (size_t i = 0, L = sl->length(); i < L; ++i) {
+          if (!(*sl)[i]->contains_placeholder()) {
+              *new_sl << (*sl)[i];
+          }
+      }
+
+      return new_sl;
+
+    }
+
+
     void Remove_Placeholders::operator()(Ruleset* r) {
         // Create a new selector group without placeholders
         Selector_List* sl = static_cast<Selector_List*>(r->selector());
 
         if (sl) {
-            Selector_List* new_sl = SASS_MEMORY_NEW(ctx.mem, Selector_List, sl->pstate());
-
-            for (size_t i = 0, L = sl->length(); i < L; ++i) {
-                if (!(*sl)[i]->contains_placeholder()) {
-                    *new_sl << (*sl)[i];
+          // Set the new placeholder selector list
+          r->selector(remove_placeholders(sl));
+          // Remove placeholders in wrapped selectors
+          for (Complex_Selector* cs : *sl) {
+            while (cs) {
+              if (cs->head()) {
+                for (Simple_Selector* ss : *cs->head()) {
+                  if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(ss)) {
+                    if (Selector_List* sl = dynamic_cast<Selector_List*>(ws->selector())) {
+                      Selector_List* clean = remove_placeholders(sl);
+                      // also clean superflous parent selectors
+                      // probably not really the correct place
+                      clean->remove_parent_selectors();
+                      ws->selector(clean);
+                    }
+                  }
                 }
+              }
+              cs = cs->tail();
             }
-
-            // Set the new placeholder selector list
-            r->selector(new_sl);
+          }
         }
 
         // Iterate into child blocks