sassc 1.11.4 → 1.12.0

data/ext/libsass/src/parser.hpp

@@ -10,12 +10,22 @@
 #include "position.hpp"
 #include "prelexer.hpp"
 
+#ifndef MAX_NESTING
+// Note that this limit is not an exact science
+// it depends on various factors, which some are
+// not under our control (compile time or even OS
+// dependent settings on the available stack size)
+// It should fix most common segfault cases though.
+#define MAX_NESTING 512
+#endif
+
 struct Lookahead {
   const char* found;
   const char* error;
   const char* position;
   bool parsable;
   bool has_interpolants;
+  bool is_custom_property;
 };
 
 namespace Sass {
@@ -23,7 +33,7 @@ namespace Sass {
   class Parser : public ParserState {
   public:
 
-    enum Scope { Root, Mixin, Function, Media, Control, Properties, Rules };
+    enum Scope { Root, Mixin, Function, Media, Control, Properties, Rules, AtRoot };
 
     Context& ctx;
     std::vector<Block_Obj> block_stack;
@@ -35,23 +45,26 @@ namespace Sass {
     Position before_token;
     Position after_token;
     ParserState pstate;
-    int indentation;
-
+    Backtraces traces;
+    size_t indentation;
+    size_t nestings;
 
     Token lexed;
-    bool in_at_root;
 
-    Parser(Context& ctx, const ParserState& pstate)
+    Parser(Context& ctx, const ParserState& pstate, Backtraces traces)
     : ParserState(pstate), ctx(ctx), block_stack(), stack(0), last_media_block(),
-      source(0), position(0), end(0), before_token(pstate), after_token(pstate), pstate(pstate), indentation(0)
-    { in_at_root = false; stack.push_back(Scope::Root); }
+      source(0), position(0), end(0), before_token(pstate), after_token(pstate),
+      pstate(pstate), traces(traces), indentation(0), nestings(0)
+    { 
+      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]"), 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);
+    static Parser from_c_str(const char* src, Context& ctx, Backtraces, ParserState pstate = ParserState("[CSTRING]"), const char* source = 0);
+    static Parser from_c_str(const char* beg, const char* end, Context& ctx, Backtraces, ParserState pstate = ParserState("[CSTRING]"), const char* source = 0);
+    static Parser from_token(Token t, Context& ctx, Backtraces, ParserState pstate = ParserState("[TOKEN]"), const char* source = 0);
     // special static parsers to convert strings into certain selectors
-    static Selector_List_Obj parse_selector(const char* src, Context& ctx, ParserState pstate = ParserState("[SELECTOR]"), const char* source = 0);
+    static Selector_List_Obj parse_selector(const char* src, Context& ctx, Backtraces, ParserState pstate = ParserState("[SELECTOR]"), const char* source = 0);
 
 #ifdef __clang__
 
@@ -100,7 +113,7 @@ namespace Sass {
 
     }
 
-    // peek will only skip over space, tabs and line comment
+    // match will not 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)
@@ -223,12 +236,14 @@ namespace Sass {
 
 #endif
 
+    void error(std::string msg);
     void error(std::string msg, Position pos);
     // generate message with given and expected sample
     // text before and in the middle are configurable
     void css_error(const std::string& msg,
                    const std::string& prefix = " after ",
-                   const std::string& middle = ", was: ");
+                   const std::string& middle = ", was: ",
+                   const bool trim = true);
     void read_bom();
 
     Block_Obj parse();
@@ -240,10 +255,10 @@ namespace Sass {
     Arguments_Obj parse_arguments();
     Argument_Obj parse_argument();
     Assignment_Obj parse_assignment();
-    Ruleset_Obj parse_ruleset(Lookahead lookahead, bool is_root = false);
-    Selector_Schema_Obj parse_selector_schema(const char* end_of_selector);
-    Selector_List_Obj parse_selector_list(bool at_root = false);
-    Complex_Selector_Obj parse_complex_selector(bool in_root = true);
+    Ruleset_Obj parse_ruleset(Lookahead lookahead);
+    Selector_List_Obj parse_selector_list(bool chroot);
+    Complex_Selector_Obj parse_complex_selector(bool chroot);
+    Selector_Schema_Obj parse_selector_schema(const char* end_of_selector, bool chroot);
     Compound_Selector_Obj parse_compound_selector();
     Simple_Selector_Obj parse_simple_selector();
     Wrapped_Selector_Obj parse_negated_selector();
@@ -257,6 +272,7 @@ namespace Sass {
     bool parse_number_prefix();
     Declaration_Obj parse_declaration();
     Expression_Obj parse_map();
+    Expression_Obj parse_bracket_list();
     Expression_Obj parse_list(bool delayed = false);
     Expression_Obj parse_comma_list(bool delayed = false);
     Expression_Obj parse_space_list();
@@ -272,9 +288,11 @@ namespace Sass {
     Function_Call_Schema_Obj parse_function_call_schema();
     String_Obj parse_url_function_string();
     String_Obj parse_url_function_argument();
-    String_Obj parse_interpolated_chunk(Token, bool constant = false);
+    String_Obj parse_interpolated_chunk(Token, bool constant = false, bool css = true);
     String_Obj parse_string();
-    String_Constant_Obj parse_static_value();
+    Value_Obj parse_static_value();
+    String_Schema_Obj parse_css_variable_value(bool top_level = true);
+    String_Schema_Obj parse_css_variable_value_token(bool top_level = true);
     String_Obj parse_ie_property();
     String_Obj parse_ie_keyword_arg();
     String_Schema_Obj parse_value_schema(const char* stop);
@@ -307,6 +325,8 @@ namespace Sass {
     Error_Obj parse_error();
     Debug_Obj parse_debug();
 
+    Value_Ptr color_or_string(const std::string& lexed) const;
+
     // be more like ruby sass
     Expression_Obj lex_almost_any_value_token();
     Expression_Obj lex_almost_any_value_chars();
@@ -340,15 +360,15 @@ namespace Sass {
         schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
         if (position[0] == '#' && position[1] == '{') {
           Expression_Obj itpl = lex_interpolation();
-          if (&itpl) schema->append(&itpl);
+          if (!itpl.isNull()) schema->append(itpl);
           while (lex < close >(false)) {
             // std::cerr << "LEX [[" << std::string(lexed) << "]]\n";
             schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
             if (position[0] == '#' && position[1] == '{') {
               Expression_Obj itpl = lex_interpolation();
-              if (&itpl) schema->append(&itpl);
+              if (!itpl.isNull()) schema->append(itpl);
             } else {
-              return &schema;
+              return schema;
             }
           }
         } else {
@@ -357,6 +377,21 @@ namespace Sass {
       }
       return 0;
     }
+
+  public:
+    static Number_Ptr lexed_number(const ParserState& pstate, const std::string& parsed);
+    static Number_Ptr lexed_dimension(const ParserState& pstate, const std::string& parsed);
+    static Number_Ptr lexed_percentage(const ParserState& pstate, const std::string& parsed);
+    static Value_Ptr lexed_hex_color(const ParserState& pstate, const std::string& parsed);
+  private:
+    Number_Ptr lexed_number(const std::string& parsed) { return lexed_number(pstate, parsed); };
+    Number_Ptr lexed_dimension(const std::string& parsed) { return lexed_dimension(pstate, parsed); };
+    Number_Ptr lexed_percentage(const std::string& parsed) { return lexed_percentage(pstate, parsed); };
+    Value_Ptr lexed_hex_color(const std::string& parsed) { return lexed_hex_color(pstate, parsed); };
+
+    static const char* re_attr_sensitive_close(const char* src);
+    static const char* re_attr_insensitive_close(const char* src);
+
   };
 
   size_t check_bom_chars(const char* src, const char *end, const unsigned char* bom, size_t len);

data/ext/libsass/src/plugins.cpp

@@ -1,3 +1,8 @@
+#include "sass.hpp"
+#include <iostream>
+#include "output.hpp"
+#include "plugins.hpp"
+
 #ifdef _WIN32
 #include <windows.h>
 #else
@@ -7,15 +12,21 @@
 #include <dlfcn.h>
 #endif
 
-#include "sass.hpp"
-#include <iostream>
-#include "output.hpp"
-#include "plugins.hpp"
-
 namespace Sass {
 
   Plugins::Plugins(void) { }
-  Plugins::~Plugins(void) { }
+  Plugins::~Plugins(void)
+  {
+    for (auto function : functions) {
+      sass_delete_function(function);
+    }
+    for (auto importer : importers) {
+      sass_delete_importer(importer);
+    }
+    for (auto header : headers) {
+      sass_delete_importer(header);
+    }
+  }
 
   // check if plugin is compatible with this version
   // plugins may be linked static against libsass
@@ -57,20 +68,23 @@ namespace Sass {
         // try to get import address for "libsass_load_functions"
         if (LOAD_LIB_FN(__plugin_load_fns__, plugin_load_functions, "libsass_load_functions"))
         {
-          Sass_Function_List fns = plugin_load_functions();
+          Sass_Function_List fns = plugin_load_functions(), _p = fns;
           while (fns && *fns) { functions.push_back(*fns); ++ fns; }
+          sass_free_memory(_p); // only delete the container, items not yet
         }
         // try to get import address for "libsass_load_importers"
         if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_importers, "libsass_load_importers"))
         {
-          Sass_Importer_List imps = plugin_load_importers();
+          Sass_Importer_List imps = plugin_load_importers(), _p = imps;
           while (imps && *imps) { importers.push_back(*imps); ++ imps; }
+          sass_free_memory(_p); // only delete the container, items not yet
         }
         // try to get import address for "libsass_load_headers"
         if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_headers, "libsass_load_headers"))
         {
-          Sass_Importer_List imps = plugin_load_headers();
+          Sass_Importer_List imps = plugin_load_headers(), _p = imps;
           while (imps && *imps) { headers.push_back(*imps); ++ imps; }
+          sass_free_memory(_p); // only delete the container, items not yet
         }
         // success
         return true;
@@ -153,7 +167,11 @@ namespace Sass {
       struct dirent *dirp;
       if((dp  = opendir(path.c_str())) == NULL) return -1;
       while ((dirp = readdir(dp)) != NULL) {
-        if (!ends_with(dirp->d_name, ".so")) continue;
+        #if __APPLE__
+          if (!ends_with(dirp->d_name, ".dylib")) continue;
+        #else
+          if (!ends_with(dirp->d_name, ".so")) continue;
+        #endif
         if (load_plugin(path + dirp->d_name)) ++ loaded;
       }
       closedir(dp);

data/ext/libsass/src/position.cpp

@@ -4,6 +4,11 @@
 namespace Sass {
 
 
+  Offset::Offset(const char chr)
+  : line(chr == '\n' ? 1 : 0),
+    column(chr == '\n' ? 0 : 1)
+  {}
+
   Offset::Offset(const char* string)
   : line(0), column(0)
   {
@@ -32,7 +37,6 @@ namespace Sass {
 
   // increase offset by given string (mostly called by lexer)
   // increase line counter and count columns on the last line
-  // ToDo: make the col count utf8 aware
   Offset Offset::add(const char* begin, const char* end)
   {
     if (end == 0) return *this;
@@ -42,9 +46,23 @@ namespace Sass {
         // start new line
         column = 0;
       } else {
-        ++ column;
+        // do not count any utf8 continuation bytes
+        // https://stackoverflow.com/a/9356203/1550314
+        // https://en.wikipedia.org/wiki/UTF-8#Description
+        unsigned char chr = *begin;
+        // skip over 10xxxxxx
+        // is 1st bit not set
+        if ((chr & 128) == 0) {
+          // regular ascii char
+          column += 1;
+        }
+        // is 2nd bit not set
+        else if ((chr & 64) == 0) {
+          // first utf8 byte
+          column += 1;
+        }
       }
-      ++begin;
+      ++ begin;
     }
     return *this;
   }

data/ext/libsass/src/position.hpp

@@ -11,6 +11,7 @@ namespace Sass {
   class Offset {
 
     public: // c-tor
+      Offset(const char chr);
       Offset(const char* string);
       Offset(const std::string& text);
       Offset(const size_t line, const size_t column);
@@ -85,7 +86,7 @@ namespace Sass {
 
     size_t length()    const { return end - begin; }
     std::string ws_before() const { return std::string(prefix, begin); }
-    std::string to_string() const { return std::string(begin, end); }
+    const std::string to_string() const { return std::string(begin, end); }
     std::string time_wspace() const {
       std::string str(to_string());
       std::string whitespaces(" \t\f\v\n\r");

data/ext/libsass/src/prelexer.cpp

@@ -1,6 +1,5 @@
 #include "sass.hpp"
 #include <cctype>
-#include <cstddef>
 #include <iostream>
 #include <iomanip>
 #include "util.hpp"
@@ -438,6 +437,10 @@ namespace Sass {
         optional <
           sequence <
           exactly <'/'>,
+          negate < sequence <
+            exactly < calc_fn_kwd >,
+            exactly < '(' >
+          > >,
           multiple_units
         > >
       >(src);
@@ -577,7 +580,7 @@ namespace Sass {
     const char* value_combinations(const char* src) {
       // `2px-2px` is invalid combo
       bool was_number = false;
-      const char* pos = src;
+      const char* pos;
       while (src) {
         if ((pos = alternatives < quoted_string, identifier, percentage, hex >(src))) {
           was_number = false;
@@ -643,10 +646,7 @@ namespace Sass {
             >,
             sequence <
               negate <
-                sequence <
-                  exactly < url_kwd >,
-                  exactly <'('>
-                >
+                uri_prefix
               >,
               neg_class_char <
                 almost_any_value_class
@@ -998,7 +998,17 @@ namespace Sass {
                           digits>(src);
     }
     const char* number(const char* src) {
-      return sequence< optional<sign>, unsigned_number>(src);
+      return sequence<
+          optional<sign>,
+          unsigned_number,
+          optional<
+            sequence<
+              exactly<'e'>,
+              optional<sign>,
+              unsigned_number
+            >
+          >
+        >(src);
     }
     const char* coefficient(const char* src) {
       return alternatives< sequence< optional<sign>, digits >,
@@ -1037,7 +1047,7 @@ namespace Sass {
     const char* hexa(const char* src) {
       const char* p = sequence< exactly<'#'>, one_plus<xdigit> >(src);
       ptrdiff_t len = p - src;
-      return (len != 4 && len != 7 && len != 9) ? 0 : p;
+      return (len != 5 && len != 9) ? 0 : p;
     }
     const char* hex0(const char* src) {
       const char* p = sequence< exactly<'0'>, exactly<'x'>, one_plus<xdigit> >(src);
@@ -1047,7 +1057,7 @@ namespace Sass {
 
     /* no longer used - remove?
     const char* rgb_prefix(const char* src) {
-      return word<rgb_kwd>(src);
+      return word<rgb_fn_kwd>(src);
     }*/
     // Match CSS uri specifiers.
 
@@ -1161,7 +1171,7 @@ namespace Sass {
     }
     // Match the CSS negation pseudo-class.
     const char* pseudo_not(const char* src) {
-      return word< pseudo_not_kwd >(src);
+      return word< pseudo_not_fn_kwd >(src);
     }
     // Match CSS 'odd' and 'even' keywords for functional pseudo-classes.
     const char* even(const char* src) {
@@ -1269,7 +1279,7 @@ namespace Sass {
             optional_css_whitespace,
             exactly<'='>,
             optional_css_whitespace,
-            alternatives< variable, identifier_schema, identifier, quoted_string, number, hexa >,
+            alternatives< variable, identifier_schema, identifier, quoted_string, number, hex, hexa >,
             zero_plus< sequence<
               optional_css_whitespace,
               exactly<','>,
@@ -1279,7 +1289,7 @@ namespace Sass {
                 optional_css_whitespace,
                 exactly<'='>,
                 optional_css_whitespace,
-                alternatives< variable, identifier_schema, identifier, quoted_string, number, hexa >
+                alternatives< variable, identifier_schema, identifier, quoted_string, number, hex, hexa >
               >
             > >
           > >,
@@ -1314,6 +1324,7 @@ namespace Sass {
           identifier,
           quoted_string,
           number,
+          hex,
           hexa,
           sequence <
             exactly < '(' >,
@@ -1420,6 +1431,28 @@ namespace Sass {
       >(src);
     }
 
+    const char* list_terminator(const char* src) {
+      return alternatives <
+        exactly<';'>,
+        exactly<'}'>,
+        exactly<'{'>,
+        exactly<')'>,
+        exactly<']'>,
+        exactly<':'>,
+        end_of_file,
+        exactly<ellipsis>,
+        default_flag,
+        global_flag
+      >(src);
+    };
+
+    const char* space_list_terminator(const char* src) {
+      return alternatives <
+        exactly<','>,
+        list_terminator
+      >(src);
+    };
+
 
     // const char* real_uri_prefix(const char* src) {
     //   return alternatives<
@@ -1428,6 +1461,16 @@ namespace Sass {
     //   >(src);
     // }
 
+    const char* real_uri(const char* src) {
+      return sequence<
+        exactly< url_kwd >,
+        exactly< '(' >,
+        W,
+        real_uri_value,
+        exactly< ')' >
+      >(src);
+    }
+
     const char* real_uri_suffix(const char* src) {
       return sequence< W, exactly< ')' > >(src);
     }
@@ -1478,6 +1521,7 @@ namespace Sass {
                            static_string,
                            percentage,
                            hex,
+                           hexa,
                            exactly<'|'>,
                            // exactly<'+'>,
                            sequence < number, unit_identifier >,
@@ -1545,6 +1589,40 @@ namespace Sass {
                       >(src);
     }
 
+    extern const char css_variable_url_negates[] = "()[]{}\"'#/";
+    const char* css_variable_value(const char* src) {
+      return sequence<
+        alternatives<
+          sequence<
+            negate< exactly< url_fn_kwd > >,
+            one_plus< neg_class_char< css_variable_url_negates > >
+          >,
+          sequence< exactly<'#'>, negate< exactly<'{'> > >,
+          sequence< exactly<'/'>, negate< exactly<'*'> > >,
+          static_string,
+          real_uri,
+          block_comment
+        >
+      >(src);
+    }
+
+    extern const char css_variable_url_top_level_negates[] = "()[]{}\"'#/;";
+    const char* css_variable_top_level_value(const char* src) {
+      return sequence<
+        alternatives<
+          sequence<
+            negate< exactly< url_fn_kwd > >,
+            one_plus< neg_class_char< css_variable_url_top_level_negates > >
+          >,
+          sequence< exactly<'#'>, negate< exactly<'{'> > >,
+          sequence< exactly<'/'>, negate< exactly<'*'> > >,
+          static_string,
+          real_uri,
+          block_comment
+        >
+      >(src);
+    }
+
     const char* parenthese_scope(const char* src) {
       return sequence <
         exactly < '(' >,
@@ -1578,7 +1656,7 @@ namespace Sass {
             class_char < selector_lookahead_ops >,
             // match selector combinators /[>+~]/
             class_char < selector_combinator_ops >,
-            // match attribute compare operators
+            // match pseudo selectors
             sequence <
               exactly <'('>,
               optional_spaces,
@@ -1586,6 +1664,7 @@ namespace Sass {
               optional_spaces,
               exactly <')'>
             >,
+            // match attribute compare operators
             alternatives <
               exact_match, class_match, dash_match,
               prefix_match, suffix_match, substring_match
@@ -1604,12 +1683,21 @@ namespace Sass {
                 // class match
                 exactly <'.'>,
                 // single or double colon
-                optional < pseudo_prefix >
+                sequence <
+                  optional < pseudo_prefix >,
+                  // fix libsass issue 2376
+                  negate < uri_prefix >
+                >
               >,
               // accept hypens in token
               one_plus < sequence <
                 // can start with hyphens
-                zero_plus < exactly<'-'> >,
+                zero_plus <
+                  sequence <
+                    exactly <'-'>,
+                    optional_spaces
+                  >
+                >,
                 // now the main token
                 alternatives <
                   kwd_optional,
@@ -1636,10 +1724,7 @@ namespace Sass {
       return sequence< optional<namespace_schema>, identifier>(src);
     }
     const char* re_type_selector(const char* src) {
-      return alternatives< type_selector, universal, quoted_string, dimension, percentage, number, identifier_alnums >(src);
-    }
-    const char* re_type_selector2(const char* src) {
-      return alternatives< type_selector, universal, quoted_string, dimension, percentage, number, identifier_alnums >(src);
+      return alternatives< type_selector, universal, dimension, percentage, number, identifier_alnums >(src);
     }
     const char* re_static_expression(const char* src) {
       return sequence< number, optional_spaces, exactly<'/'>, optional_spaces, number >(src);