sassc 2.2.1 → 2.3.0

data/ext/libsass/src/parser.hpp

@@ -1,6 +1,8 @@
 #ifndef SASS_PARSER_H
 #define SASS_PARSER_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
 #include <string>
@@ -40,7 +42,6 @@ namespace Sass {
     Context& ctx;
     std::vector<Block_Obj> block_stack;
     std::vector<Scope> stack;
-    Media_Block* last_media_block;
     const char* source;
     const char* position;
     const char* end;
@@ -55,7 +56,7 @@ namespace Sass {
     Token lexed;
 
     Parser(Context& ctx, const ParserState& pstate, Backtraces traces, bool allow_parent = true)
-    : ParserState(pstate), ctx(ctx), block_stack(), stack(0), last_media_block(),
+    : ParserState(pstate), ctx(ctx), block_stack(), stack(0),
       source(0), position(0), end(0), before_token(pstate), after_token(pstate),
       pstate(pstate), traces(traces), indentation(0), nestings(0), allow_parent(allow_parent)
     {
@@ -67,7 +68,7 @@ namespace Sass {
     static Parser from_c_str(const char* beg, const char* end, Context& ctx, Backtraces, ParserState pstate = ParserState("[CSTRING]"), const char* source = nullptr, bool allow_parent = true);
     static Parser from_token(Token t, Context& ctx, Backtraces, ParserState pstate = ParserState("[TOKEN]"), const char* source = nullptr);
     // special static parsers to convert strings into certain selectors
-    static Selector_List_Obj parse_selector(const char* src, Context& ctx, Backtraces, ParserState pstate = ParserState("[SELECTOR]"), const char* source = nullptr, bool allow_parent = true);
+    static SelectorListObj parse_selector(const char* src, Context& ctx, Backtraces, ParserState pstate = ParserState("[SELECTOR]"), const char* source = nullptr, bool allow_parent = true);
 
 #ifdef __clang__
 
@@ -187,7 +188,7 @@ namespace Sass {
       // update after_token position for current token
       after_token.add(it_before_token, it_after_token);
 
-      // ToDo: could probably do this incremetal on original object (API wants offset?)
+      // ToDo: could probably do this incremental on original object (API wants offset?)
       pstate = ParserState(path, source, lexed, before_token, after_token - before_token);
 
       // advance internal char iterator
@@ -259,20 +260,20 @@ namespace Sass {
     Argument_Obj parse_argument();
     Assignment_Obj parse_assignment();
     Ruleset_Obj parse_ruleset(Lookahead lookahead);
-    Selector_List_Obj parse_selector_list(bool chroot);
-    Complex_Selector_Obj parse_complex_selector(bool chroot);
+    SelectorListObj parseSelectorList(bool chroot);
+    ComplexSelectorObj parseComplexSelector(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();
-    Simple_Selector_Obj parse_pseudo_selector();
+    CompoundSelectorObj parseCompoundSelector();
+    SimpleSelectorObj parse_simple_selector();
+    Pseudo_Selector_Obj parse_negated_selector2();
+    Expression* parse_binominal();
+    SimpleSelectorObj parse_pseudo_selector();
     Attribute_Selector_Obj parse_attribute_selector();
     Block_Obj parse_block(bool is_root = false);
     Block_Obj parse_css_block(bool is_root = false);
     bool parse_block_nodes(bool is_root = false);
     bool parse_block_node(bool is_root = false);
 
-    bool parse_number_prefix();
     Declaration_Obj parse_declaration();
     Expression_Obj parse_map();
     Expression_Obj parse_bracket_list();
@@ -303,10 +304,13 @@ namespace Sass {
     For_Obj parse_for_directive();
     Each_Obj parse_each_directive();
     While_Obj parse_while_directive();
+    MediaRule_Obj parseMediaRule();
+    std::vector<CssMediaQuery_Obj> parseCssMediaQueries();
+    std::string parseIdentifier();
+    CssMediaQuery_Obj parseCssMediaQuery();
     Return_Obj parse_return_directive();
     Content_Obj parse_content_directive();
     void parse_charset_directive();
-    Media_Block_Obj parse_media_block();
     List_Obj parse_media_queries();
     Media_Query_Obj parse_media_query();
     Media_Query_Expression_Obj parse_media_expression();
@@ -320,8 +324,6 @@ namespace Sass {
     At_Root_Block_Obj parse_at_root_block();
     At_Root_Query_Obj parse_at_root_query();
     String_Schema_Obj parse_almost_any_value();
-    Directive_Obj parse_special_directive();
-    Directive_Obj parse_prefixed_directive();
     Directive_Obj parse_directive();
     Warning_Obj parse_warning();
     Error_Obj parse_error();
@@ -340,7 +342,7 @@ namespace Sass {
     Token lex_variable();
     Token lex_identifier();
 
-    void parse_block_comments();
+    void parse_block_comments(bool store = true);
 
     Lookahead lookahead_for_value(const char* start = 0);
     Lookahead lookahead_for_selector(const char* start = 0);

data/ext/libsass/src/parser_selectors.cpp

@@ -0,0 +1,189 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "parser.hpp"
+
+namespace Sass {
+
+  using namespace Prelexer;
+  using namespace Constants;
+
+  ComplexSelectorObj Parser::parseComplexSelector(bool chroot)
+  {
+
+    NESTING_GUARD(nestings);
+
+    lex < block_comment >();
+    advanceToNextToken();
+
+    ComplexSelectorObj sel = SASS_MEMORY_NEW(ComplexSelector, pstate);
+
+    if (peek < end_of_file >()) return sel;
+
+    while (true) {
+
+      lex < block_comment >();
+      advanceToNextToken();
+
+      // check for child (+) combinator
+      if (lex < exactly < selector_combinator_child > >()) {
+        sel->append(SASS_MEMORY_NEW(SelectorCombinator, pstate, SelectorCombinator::CHILD, peek_newline()));
+      }
+      // check for general sibling (~) combinator
+      else if (lex < exactly < selector_combinator_general > >()) {
+        sel->append(SASS_MEMORY_NEW(SelectorCombinator, pstate, SelectorCombinator::GENERAL, peek_newline()));
+      }
+      // check for adjecant sibling (+) combinator
+      else if (lex < exactly < selector_combinator_adjacent > >()) {
+        sel->append(SASS_MEMORY_NEW(SelectorCombinator, pstate, SelectorCombinator::ADJACENT, peek_newline()));
+      }
+      // check if we can parse a compound selector
+      else if (CompoundSelectorObj compound = parseCompoundSelector()) {
+        sel->append(compound);
+      }
+      else {
+        break;
+      }
+    }
+
+    if (sel->empty()) return {};
+
+    // check if we parsed any parent references
+    sel->chroots(sel->has_real_parent_ref() || chroot);
+
+    sel->update_pstate(pstate);
+
+    return sel;
+
+  }
+
+  SelectorListObj Parser::parseSelectorList(bool chroot)
+  {
+
+    bool reloop;
+    bool had_linefeed = false;
+    NESTING_GUARD(nestings);
+    SelectorListObj list = SASS_MEMORY_NEW(SelectorList, pstate);
+
+    if (peek_css< alternatives < end_of_file, exactly <'{'>, exactly <','> > >()) {
+      css_error("Invalid CSS", " after ", ": expected selector, was ");
+    }
+
+    do {
+      reloop = false;
+
+      had_linefeed = had_linefeed || peek_newline();
+
+      if (peek_css< alternatives < class_char < selector_list_delims > > >())
+        break; // in case there are superfluous commas at the end
+
+      // now parse the complex selector
+      ComplexSelectorObj complex = parseComplexSelector(chroot);
+      if (complex.isNull()) return list.detach();
+      complex->hasPreLineFeed(had_linefeed);
+
+      had_linefeed = false;
+
+      while (peek_css< exactly<','> >())
+      {
+        lex< css_comments >(false);
+        // consume everything up and including the comma separator
+        reloop = lex< exactly<','> >() != 0;
+        // remember line break (also between some commas)
+        had_linefeed = had_linefeed || peek_newline();
+        // remember line break (also between some commas)
+      }
+      list->append(complex);
+
+    } while (reloop);
+
+    while (lex_css< kwd_optional >()) {
+      list->is_optional(true);
+    }
+
+    // update for end position
+    list->update_pstate(pstate);
+
+    return list.detach();
+  }
+
+  // parse one compound selector, which is basically
+  // a list of simple selectors (directly adjacent)
+  // lex them exactly (without skipping white-space)
+  CompoundSelectorObj Parser::parseCompoundSelector()
+  {
+    // init an empty compound selector wrapper
+    CompoundSelectorObj seq = SASS_MEMORY_NEW(CompoundSelector, pstate);
+
+    // skip initial white-space
+    lex < block_comment >();
+    advanceToNextToken();
+
+    if (lex< exactly<'&'> >(false))
+    {
+      // ToDo: check the conditions and try to simplify flag passing
+      if (!allow_parent) error("Parent selectors aren't allowed here.");
+      // Create and append a new parent selector object
+      seq->hasRealParent(true);
+    }
+
+    // parse list
+    while (true)
+    {
+      // remove all block comments
+      // leaves trailing white-space
+      lex < block_comment >();
+      // parse parent selector
+      if (lex< exactly<'&'> >(false))
+      {
+        // parent selector only allowed at start
+        // upcoming Sass may allow also trailing
+        ParserState state(pstate);
+        std::string found("&");
+        if (lex < identifier >()) {
+          found += std::string(lexed);
+        }
+        std::string sel(seq->hasRealParent() ? "&" : "");
+        if (!seq->empty()) { sel = seq->last()->to_string({ NESTED, 5 }); }
+        // ToDo: parser should throw parser exceptions
+        error("Invalid CSS after \"" + sel + "\": expected \"{\", was \"" + found + "\"\n\n"
+          "\"" + found + "\" may only be used at the beginning of a compound selector.", state);
+      }
+      // parse functional
+      else if (match < re_functional >())
+        {
+          seq->append(parse_simple_selector());
+        }
+
+      // parse type selector
+      else if (lex< re_type_selector >(false))
+      {
+        seq->append(SASS_MEMORY_NEW(Type_Selector, pstate, lexed));
+      }
+      // peek for abort conditions
+      else if (peek< spaces >()) break;
+      else if (peek< end_of_file >()) { break; }
+      else if (peek_css < class_char < selector_combinator_ops > >()) break;
+      else if (peek_css < class_char < complex_selector_delims > >()) break;
+      // otherwise parse another simple selector
+      else {
+        SimpleSelectorObj sel = parse_simple_selector();
+        if (!sel) return {};
+        seq->append(sel);
+      }
+    }
+    // EO while true
+
+    if (seq && !peek_css<alternatives<end_of_file,exactly<'{'>>>()) {
+      seq->hasPostLineBreak(peek_newline());
+    }
+
+    // We may have set hasRealParent
+    if (seq && seq->empty() && !seq->hasRealParent()) return {};
+
+    return seq;
+  }
+
+
+}

data/ext/libsass/src/permutate.hpp

@@ -0,0 +1,140 @@
+#ifndef SASS_PATHS_H
+#define SASS_PATHS_H
+
+#include <vector>
+
+namespace Sass {
+
+  // Returns a list of all possible paths through the given lists.
+  //
+  // For example, given `[[1, 2], [3, 4], [5]]`, this returns:
+  //
+  // ```
+  // [[1, 3, 5],
+  //  [2, 3, 5],
+  //  [1, 4, 5],
+  //  [2, 4, 5]]
+  // ```
+  // 
+  // Note: called `paths` in dart-sass
+  template <class T>
+  std::vector<std::vector<T>> permutate(
+    const std::vector<std::vector<T>>& in)
+  {
+
+    size_t L = in.size(), n = 0;
+
+    // Exit early if any entry is empty
+    for (size_t i = 0; i < L; i += 1) {
+      if (in[i].size() == 0) return {};
+    }
+
+    size_t* state = new size_t[L + 1];
+    std::vector<std::vector<T>> out;
+
+    // First initialize all states for every permutation group
+    for (size_t i = 0; i < L; i += 1) {
+      state[i] = in[i].size() - 1;
+    }
+    while (true) {
+      std::vector<T> perm;
+      // Create one permutation for state
+      for (size_t i = 0; i < L; i += 1) {
+        perm.push_back(in.at(i).at(in[i].size() - state[i] - 1));
+      }
+      // Current group finished
+      if (state[n] == 0) {
+        // Find position of next decrement
+        while (n < L && state[++n] == 0) {}
+
+        if (n == L) {
+          out.push_back(perm);
+          break;
+        }
+
+        state[n] -= 1;
+
+        for (size_t p = 0; p < n; p += 1) {
+          state[p] = in[p].size() - 1;
+        }
+
+        // Restart from front
+        n = 0;
+
+      }
+      else {
+        state[n] -= 1;
+      }
+      out.push_back(perm);
+    }
+
+    delete[] state;
+    return out;
+  }
+  // EO permutate
+
+  // ToDo: this variant is used in resolve_parent_refs
+  template <class T>
+  std::vector<std::vector<T>>
+    permutateAlt(const std::vector<std::vector<T>>& in) {
+
+    size_t L = in.size();
+    size_t n = in.size() - 1;
+    size_t* state = new size_t[L];
+    std::vector< std::vector<T>> out;
+
+    // First initialize all states for every permutation group
+    for (size_t i = 0; i < L; i += 1) {
+      if (in[i].size() == 0) return {};
+      state[i] = in[i].size() - 1;
+    }
+
+    while (true) {
+      /*
+      // std::cerr << "PERM: ";
+      for (size_t p = 0; p < L; p++)
+      { // std::cerr << state[p] << " "; }
+      // std::cerr << "\n";
+      */
+      std::vector<T> perm;
+      // Create one permutation for state
+      for (size_t i = 0; i < L; i += 1) {
+        perm.push_back(in.at(i).at(in[i].size() - state[i] - 1));
+      }
+      // Current group finished
+      if (state[n] == 0) {
+        // Find position of next decrement
+        while (n > 0 && state[--n] == 0)
+        {
+
+        }
+        // Check for end condition
+        if (state[n] != 0) {
+          // Decrease next on the left side
+          state[n] -= 1;
+          // Reset all counters to the right
+          for (size_t p = n + 1; p < L; p += 1) {
+            state[p] = in[p].size() - 1;
+          }
+          // Restart from end
+          n = L - 1;
+        }
+        else {
+          out.push_back(perm);
+          break;
+        }
+      }
+      else {
+        state[n] -= 1;
+      }
+      out.push_back(perm);
+    }
+
+    delete[] state;
+    return out;
+  }
+  // EO permutateAlt
+
+}
+
+#endif

data/ext/libsass/src/position.hpp

@@ -86,7 +86,7 @@ namespace Sass {
 
     size_t length()    const { return end - begin; }
     std::string ws_before() const { return std::string(prefix, begin); }
-    const std::string to_string() const { return std::string(begin, end); }
+    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

@@ -2,10 +2,10 @@
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
-#include <cctype>
 #include <iostream>
 #include <iomanip>
 #include "util.hpp"
+#include "util_string.hpp"
 #include "position.hpp"
 #include "prelexer.hpp"
 #include "constants.hpp"
@@ -336,7 +336,7 @@ namespace Sass {
       return alternatives<
                unicode_seq,
                alpha,
-               unicode,
+               nonascii,
                exactly<'-'>,
                exactly<'_'>,
                NONASCII,
@@ -351,7 +351,7 @@ namespace Sass {
       return alternatives<
                unicode_seq,
                alnum,
-               unicode,
+               nonascii,
                exactly<'-'>,
                exactly<'_'>,
                NONASCII,
@@ -385,7 +385,7 @@ namespace Sass {
     {
       return alternatives <
                alpha,
-               unicode,
+               nonascii,
                escape_seq,
                exactly<'_'>
              >(src);
@@ -395,7 +395,7 @@ namespace Sass {
     {
       return alternatives <
                alnum,
-               unicode,
+               nonascii,
                escape_seq,
                exactly<'_'>
              >(src);
@@ -1400,7 +1400,7 @@ namespace Sass {
     }*/
 
     const char* H(const char* src) {
-      return std::isxdigit(static_cast<unsigned char>(*src)) ? src+1 : 0;
+      return Util::ascii_isxdigit(static_cast<unsigned char>(*src)) ? src+1 : 0;
     }
 
     const char* W(const char* src) {