sassc4 2.4.0

data/ext/libsass/src/parser.hpp

@@ -0,0 +1,395 @@
+#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>
+#include <vector>
+
+#include "ast.hpp"
+#include "position.hpp"
+#include "context.hpp"
+#include "position.hpp"
+#include "prelexer.hpp"
+#include "source.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 {
+
+  class Parser : public SourceSpan {
+  public:
+
+    enum Scope { Root, Mixin, Function, Media, Control, Properties, Rules, AtRoot };
+
+    Context& ctx;
+    sass::vector<Block_Obj> block_stack;
+    sass::vector<Scope> stack;
+    SourceDataObj source;
+    const char* begin;
+    const char* position;
+    const char* end;
+    Offset before_token;
+    Offset after_token;
+    SourceSpan pstate;
+    Backtraces traces;
+    size_t indentation;
+    size_t nestings;
+    bool allow_parent;
+    Token lexed;
+
+    Parser(SourceData* source, Context& ctx, Backtraces, bool allow_parent = true);
+
+    // special static parsers to convert strings into certain selectors
+    static SelectorListObj parse_selector(SourceData* source, Context& ctx, Backtraces, bool allow_parent = true);
+
+#ifdef __clang__
+
+    // lex and peak uses the template parameter to branch on the action, which
+    // triggers clangs tautological comparison on the single-comparison
+    // branches. This is not a bug, just a merging of behaviour into
+    // one function
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+#endif
+
+
+    // skip current token and next whitespace
+    // moves SourceSpan right before next token
+    void advanceToNextToken();
+
+    bool peek_newline(const char* start = 0);
+
+    // skip over spaces, tabs and line comments
+    template <Prelexer::prelexer mx>
+    const char* sneak(const char* start = 0)
+    {
+      using namespace Prelexer;
+
+      // maybe use optional start position from arguments?
+      const char* it_position = start ? start : position;
+
+      // skip white-space?
+      if (mx == spaces ||
+          mx == no_spaces ||
+          mx == css_comments ||
+          mx == css_whitespace ||
+          mx == optional_spaces ||
+          mx == optional_css_comments ||
+          mx == optional_css_whitespace
+      ) {
+        return it_position;
+      }
+
+      // skip over spaces, tabs and sass line comments
+      const char* pos = optional_css_whitespace(it_position);
+      // always return a valid position
+      return pos ? pos : it_position;
+
+    }
+
+    // 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)
+    {
+      // 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>
+    const char* peek(const char* start = 0)
+    {
+
+      // sneak up to the actual token we want to lex
+      // this should skip over white-space if desired
+      const char* it_before_token = sneak < mx >(start);
+
+      // match the given prelexer
+      const char* match = mx(it_before_token);
+
+      // check if match is in valid range
+      return match <= end ? match : 0;
+
+    }
+
+    // white-space handling is built into the lexer
+    // this way you do not need to parse it yourself
+    // some matchers don't accept certain white-space
+    // we do not support start arg, since we manipulate
+    // sourcemap offset and we modify the position pointer!
+    // lex will only skip over space, tabs and line comment
+    template <Prelexer::prelexer mx>
+    const char* lex(bool lazy = true, bool force = false)
+    {
+
+      if (*position == 0) return 0;
+
+      // position considered before lexed token
+      // we can skip whitespace or comments for
+      // lazy developers (but we need control)
+      const char* it_before_token = position;
+
+      // sneak up to the actual token we want to lex
+      // this should skip over white-space if desired
+      if (lazy) it_before_token = sneak < mx >(position);
+
+      // now call matcher to get position after token
+      const char* it_after_token = mx(it_before_token);
+
+      // check if match is in valid range
+      if (it_after_token > end) return 0;
+
+      // maybe we want to update the parser state anyway?
+      if (force == false) {
+        // assertion that we got a valid match
+        if (it_after_token == 0) return 0;
+        // assertion that we actually lexed something
+        if (it_after_token == it_before_token) return 0;
+      }
+
+      // create new lexed token object (holds the parse results)
+      lexed = Token(position, it_before_token, it_after_token);
+
+      // advance position (add whitespace before current token)
+      before_token = after_token.add(position, it_before_token);
+
+      // update after_token position for current token
+      after_token.add(it_before_token, it_after_token);
+
+      // ToDo: could probably do this incremental on original object (API wants offset?)
+      pstate = SourceSpan(source, before_token, after_token - before_token);
+
+      // advance internal char iterator
+      return position = it_after_token;
+
+    }
+
+    // lex_css skips over space, tabs, line and block comment
+    // all block comments will be consumed and thrown away
+    // source-map position will point to token after the comment
+    template <Prelexer::prelexer mx>
+    const char* lex_css()
+    {
+      // copy old token
+      Token prev = lexed;
+      // store previous pointer
+      const char* oldpos = position;
+      Offset bt = before_token;
+      Offset at = after_token;
+      SourceSpan op = pstate;
+      // throw away comments
+      // update srcmap position
+      lex < Prelexer::css_comments >();
+      // now lex a new token
+      const char* pos = lex< mx >();
+      // maybe restore prev state
+      if (pos == 0) {
+        pstate = op;
+        lexed = prev;
+        position = oldpos;
+        after_token = at;
+        before_token = bt;
+      }
+      // return match
+      return pos;
+    }
+
+    // all block comments will be skipped and thrown away
+    template <Prelexer::prelexer mx>
+    const char* peek_css(const char* start = 0)
+    {
+      // now peek a token (skip comments first)
+      return peek< mx >(peek < Prelexer::css_comments >(start));
+    }
+
+#ifdef __clang__
+
+#pragma clang diagnostic pop
+
+#endif
+
+    void error(sass::string msg);
+    // generate message with given and expected sample
+    // text before and in the middle are configurable
+    void css_error(const sass::string& msg,
+                   const sass::string& prefix = " after ",
+                   const sass::string& middle = ", was: ",
+                   const bool trim = true);
+    void read_bom();
+
+    Block_Obj parse();
+    Import_Obj parse_import();
+    Definition_Obj parse_definition(Definition::Type which_type);
+    Parameters_Obj parse_parameters();
+    Parameter_Obj parse_parameter();
+    Mixin_Call_Obj parse_include_directive();
+    Arguments_Obj parse_arguments();
+    Arguments_Obj parse_color_arguments();
+    Argument_Obj parse_argument();
+    Assignment_Obj parse_assignment();
+    StyleRuleObj parse_ruleset(Lookahead lookahead);
+    SelectorListObj parseSelectorList(bool chroot);
+    ComplexSelectorObj parseComplexSelector(bool chroot);
+    Selector_Schema_Obj parse_selector_schema(const char* end_of_selector, bool chroot);
+    CompoundSelectorObj parseCompoundSelector();
+    SimpleSelectorObj parse_simple_selector();
+    PseudoSelectorObj parse_negated_selector2();
+    Expression* parse_binominal();
+    SimpleSelectorObj parse_pseudo_selector();
+    AttributeSelectorObj 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);
+
+    Declaration_Obj parse_declaration();
+    ExpressionObj parse_map();
+    ExpressionObj parse_bracket_list();
+    ExpressionObj parse_list(bool delayed = false);
+    ExpressionObj parse_comma_list(bool delayed = false);
+    ExpressionObj parse_space_list();
+    ExpressionObj parse_disjunction();
+    ExpressionObj parse_conjunction();
+    ExpressionObj parse_relation();
+    ExpressionObj parse_expression();
+    ExpressionObj parse_operators();
+    ExpressionObj parse_factor();
+    ExpressionObj parse_value();
+    Function_Call_Obj parse_calc_function();
+    Function_Call_Obj parse_function_call();
+    Function_Call_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, bool css = true);
+    String_Obj parse_string();
+    ValueObj parse_static_value();
+    String_Schema_Obj parse_css_variable_value();
+    String_Obj parse_ie_property();
+    String_Obj parse_ie_keyword_arg();
+    String_Schema_Obj parse_value_schema(const char* stop);
+    String_Obj parse_identifier_schema();
+    If_Obj parse_if_directive(bool else_if = false);
+    ForRuleObj parse_for_directive();
+    EachRuleObj parse_each_directive();
+    WhileRuleObj parse_while_directive();
+    MediaRule_Obj parseMediaRule();
+    sass::vector<CssMediaQuery_Obj> parseCssMediaQueries();
+    sass::string parseIdentifier();
+    CssMediaQuery_Obj parseCssMediaQuery();
+    Return_Obj parse_return_directive();
+    Content_Obj parse_content_directive();
+    void parse_charset_directive();
+    List_Obj parse_media_queries();
+    Media_Query_Obj parse_media_query();
+    Media_Query_ExpressionObj parse_media_expression();
+    SupportsRuleObj parse_supports_directive();
+    SupportsConditionObj parse_supports_condition(bool top_level);
+    SupportsConditionObj parse_supports_negation();
+    SupportsConditionObj parse_supports_operator(bool top_level);
+    SupportsConditionObj parse_supports_interpolation();
+    SupportsConditionObj parse_supports_declaration();
+    SupportsConditionObj parse_supports_condition_in_parens(bool parens_required);
+    AtRootRuleObj parse_at_root_block();
+    At_Root_Query_Obj parse_at_root_query();
+    String_Schema_Obj parse_almost_any_value();
+    AtRuleObj parse_directive();
+    WarningRuleObj parse_warning();
+    ErrorRuleObj parse_error();
+    DebugRuleObj parse_debug();
+
+    Value* color_or_string(const sass::string& lexed) const;
+
+    // be more like ruby sass
+    ExpressionObj lex_almost_any_value_token();
+    ExpressionObj lex_almost_any_value_chars();
+    ExpressionObj lex_interp_string();
+    ExpressionObj lex_interp_uri();
+    ExpressionObj lex_interpolation();
+
+    // these will throw errors
+    Token lex_variable();
+    Token lex_identifier();
+
+    void parse_block_comments(bool store = true);
+
+    Lookahead lookahead_for_value(const char* start = 0);
+    Lookahead lookahead_for_selector(const char* start = 0);
+    Lookahead lookahead_for_include(const char* start = 0);
+
+    ExpressionObj fold_operands(ExpressionObj base, sass::vector<ExpressionObj>& operands, Operand op);
+    ExpressionObj fold_operands(ExpressionObj base, sass::vector<ExpressionObj>& operands, sass::vector<Operand>& ops, size_t i = 0);
+
+    void throw_syntax_error(sass::string message, size_t ln = 0);
+    void throw_read_error(sass::string message, size_t ln = 0);
+
+
+    template <Prelexer::prelexer open, Prelexer::prelexer close>
+    ExpressionObj lex_interp()
+    {
+      if (lex < open >(false)) {
+        String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);
+        // std::cerr << "LEX [[" << sass::string(lexed) << "]]\n";
+        schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
+        if (position[0] == '#' && position[1] == '{') {
+          ExpressionObj itpl = lex_interpolation();
+          if (!itpl.isNull()) schema->append(itpl);
+          while (lex < close >(false)) {
+            // std::cerr << "LEX [[" << sass::string(lexed) << "]]\n";
+            schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
+            if (position[0] == '#' && position[1] == '{') {
+              ExpressionObj itpl = lex_interpolation();
+              if (!itpl.isNull()) schema->append(itpl);
+            } else {
+              return schema;
+            }
+          }
+        } else {
+          return SASS_MEMORY_NEW(String_Constant, pstate, lexed);
+        }
+      }
+      return {};
+    }
+
+  public:
+    static Number* lexed_number(const SourceSpan& pstate, const sass::string& parsed);
+    static Number* lexed_dimension(const SourceSpan& pstate, const sass::string& parsed);
+    static Number* lexed_percentage(const SourceSpan& pstate, const sass::string& parsed);
+    static Value* lexed_hex_color(const SourceSpan& pstate, const sass::string& parsed);
+  private:
+    Number* lexed_number(const sass::string& parsed) { return lexed_number(pstate, parsed); };
+    Number* lexed_dimension(const sass::string& parsed) { return lexed_dimension(pstate, parsed); };
+    Number* lexed_percentage(const sass::string& parsed) { return lexed_percentage(pstate, parsed); };
+    Value* lexed_hex_color(const sass::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);
+}
+
+#endif

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
+        SourceSpan state(pstate);
+        sass::string found("&");
+        if (lex < identifier >()) {
+          found += sass::string(lexed);
+        }
+        sass::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.");
+      }
+      // 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(TypeSelector, 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;
+  }
+
+
+}