sassc 0.0.10 → 0.0.11

data/ext/libsass/lexer.cpp

@@ -0,0 +1,133 @@
+#include <cctype>
+#include <cstddef>
+#include <iostream>
+#include <iomanip>
+#include "lexer.hpp"
+#include "constants.hpp"
+
+
+namespace Sass {
+  using namespace Constants;
+
+  namespace Prelexer {
+
+    //####################################
+    // BASIC CHARACTER MATCHERS
+    //####################################
+
+    // Match standard control chars
+    const char* kwd_at(const char* src) { return exactly<'@'>(src); }
+    const char* kwd_dot(const char* src) { return exactly<'.'>(src); }
+    const char* kwd_comma(const char* src) { return exactly<','>(src); };
+    const char* kwd_colon(const char* src) { return exactly<':'>(src); };
+    const char* kwd_star(const char* src) { return exactly<'*'>(src); };
+    const char* kwd_plus(const char* src) { return exactly<'+'>(src); };
+    const char* kwd_minus(const char* src) { return exactly<'-'>(src); };
+    const char* kwd_slash(const char* src) { return exactly<'/'>(src); };
+
+    //####################################
+    // implement some function that do exist in the standard
+    // but those are locale aware which brought some trouble
+    // this even seems to improve performance by quite a bit
+    //####################################
+
+    const bool is_alpha(const char& chr)
+    {
+      return unsigned(chr - 'A') <= 'Z' - 'A' ||
+             unsigned(chr - 'a') <= 'z' - 'a';
+    }
+
+    const bool is_space(const char& chr)
+    {
+      // adapted the technique from is_alpha
+      return chr == ' ' || unsigned(chr - '\t') <= '\r' - '\t';
+    }
+
+    const bool is_digit(const char& chr)
+    {
+      // adapted the technique from is_alpha
+      return unsigned(chr - '0') <= '9' - '0';
+    }
+
+    const bool is_xdigit(const char& chr)
+    {
+      // adapted the technique from is_alpha
+      return unsigned(chr - '0') <= '9' - '0' ||
+             unsigned(chr - 'a') <= 'f' - 'a' ||
+             unsigned(chr - 'A') <= 'F' - 'A';
+    }
+
+    const bool is_punct(const char& chr)
+    {
+      // locale independent
+      return chr == '.';
+    }
+
+    const bool is_alnum(const char& chr)
+    {
+      return is_alpha(chr) || is_digit(chr);
+    }
+
+    // check if char is outside ascii range
+    const bool is_unicode(const char& chr)
+    {
+      // check for unicode range
+      return unsigned(chr) > 127;
+    }
+
+    // Match word character (look ahead)
+    const bool is_character(const char& chr)
+    {
+      // valid alpha, numeric or unicode char (plus hyphen)
+      return is_alnum(chr) || is_unicode(chr) || chr == '-';
+    }
+
+    //####################################
+    // BASIC CLASS MATCHERS
+    //####################################
+
+    // create matchers that advance the position
+    const char* space(const char* src) { return is_space(*src) ? src + 1 : 0; }
+    const char* alpha(const char* src) { return is_alpha(*src) ? src + 1 : 0; }
+    const char* unicode(const char* src) { return is_unicode(*src) ? src + 1 : 0; }
+    const char* digit(const char* src) { return is_digit(*src) ? src + 1 : 0; }
+    const char* xdigit(const char* src) { return is_xdigit(*src) ? src + 1 : 0; }
+    const char* alnum(const char* src) { return is_alnum(*src) ? src + 1 : 0; }
+    const char* punct(const char* src) { return is_punct(*src) ? src + 1 : 0; }
+    const char* character(const char* src) { return is_character(*src) ? src + 1 : 0; }
+
+    // Match multiple ctype characters.
+    const char* spaces(const char* src) { return one_plus<space>(src); }
+    const char* digits(const char* src) { return one_plus<digit>(src); }
+
+    // Whitespace handling.
+    const char* no_spaces(const char* src) { return negate< space >(src); }
+    const char* optional_spaces(const char* src) { return zero_plus< space >(src); }
+
+    // Match any single character.
+    const char* any_char(const char* src) { return *src ? src + 1 : src; }
+
+    // Match word boundary (zero-width lookahead).
+    const char* word_boundary(const char* src) { return is_character(*src) ? 0 : src; }
+
+    // Match linefeed /(?:\n|\r\n?)/
+    const char* re_linebreak(const char* src)
+    {
+      // end of file or unix linefeed return here
+      if (*src == 0 || *src == '\n') return src + 1;
+      // a carriage return may optionally be followed by a linefeed
+      if (*src == '\r') return *(src + 1) == '\n' ? src + 2 : src + 1;
+      // no linefeed
+      return 0;
+    }
+
+    // Assert string boundaries (/\Z|\z|\A/)
+    // This is a zero-width positive lookahead
+    const char* end_of_line(const char* src)
+    {
+      // end of file or unix linefeed return here
+      return *src == 0 || *src == '\n' || *src == '\r' ? src : 0;
+    }
+
+  }
+}

data/ext/libsass/lexer.hpp

@@ -0,0 +1,239 @@
+#ifndef SASS_LEXER_H
+#define SASS_LEXER_H
+
+#include <cstring>
+
+namespace Sass {
+  namespace Prelexer {
+
+    //####################################
+    // BASIC CHARACTER MATCHERS
+    //####################################
+
+    // Match standard control chars
+    const char* kwd_at(const char* src);
+    const char* kwd_dot(const char* src);
+    const char* kwd_comma(const char* src);
+    const char* kwd_colon(const char* src);
+    const char* kwd_star(const char* src);
+    const char* kwd_plus(const char* src);
+    const char* kwd_minus(const char* src);
+    const char* kwd_slash(const char* src);
+
+    //####################################
+    // BASIC CLASS MATCHERS
+    //####################################
+
+    // These are locale independant
+    const bool is_space(const char& src);
+    const bool is_alpha(const char& src);
+    const bool is_punct(const char& src);
+    const bool is_digit(const char& src);
+    const bool is_alnum(const char& src);
+    const bool is_xdigit(const char& src);
+    const bool is_unicode(const char& src);
+    const bool is_character(const char& src);
+
+    // Match a single ctype predicate.
+    const char* space(const char* src);
+    const char* alpha(const char* src);
+    const char* digit(const char* src);
+    const char* xdigit(const char* src);
+    const char* alnum(const char* src);
+    const char* punct(const char* src);
+    const char* unicode(const char* src);
+    const char* character(const char* src);
+
+    // Match multiple ctype characters.
+    const char* spaces(const char* src);
+    const char* digits(const char* src);
+
+    // Whitespace handling.
+    const char* no_spaces(const char* src);
+    const char* optional_spaces(const char* src);
+
+    // Match any single character (/./).
+    const char* any_char(const char* src);
+
+    // Assert word boundary (/\b/)
+    // Is a zero-width positive lookaheads
+    const char* word_boundary(const char* src);
+
+    // Match a single linebreak (/(?:\n|\r\n?)/).
+    const char* re_linebreak(const char* src);
+
+    // Assert string boundaries (/\Z|\z|\A/)
+    // There are zero-width positive lookaheads
+    const char* end_of_line(const char* src);
+    // const char* end_of_string(const char* src);
+    // const char* start_of_string(const char* src);
+
+    // Type definition for prelexer functions
+    typedef const char* (*prelexer)(const char*);
+
+    //####################################
+    // BASIC "REGEX" CONSTRUCTORS
+    //####################################
+
+    // Match a single character literal.
+    // Regex equivalent: /(?:literal)/
+    template <char chr>
+    const char* exactly(const char* src) {
+      return *src == chr ? src + 1 : 0;
+    }
+
+    // Match a string constant.
+    // Regex equivalent: /[axy]/
+    template <const char* str>
+    const char* exactly(const char* src) {
+      if (str == 0) return 0;
+      const char* pre = str;
+      if (src == 0) return 0;
+      // there is a small chance that the search string
+      // is longer than the rest of the string to look at
+      while (*pre && *src == *pre) {
+        ++src, ++pre;
+      }
+      return *pre ? 0 : src;
+    }
+
+    // Match for members of char class.
+    // Regex equivalent: /[axy]/
+    template <const char* char_class>
+    const char* class_char(const char* src) {
+      const char* cc = char_class;
+      while (*cc && *src != *cc) ++cc;
+      return *cc ? src + 1 : 0;
+    }
+
+    // Match for members of char class.
+    // Regex equivalent: /[axy]/
+    template <const char* char_class>
+    const char* class_chars(const char* src) {
+      const char* p = src;
+      while (class_char<char_class>(p)) ++p;
+      return p == src ? 0 : p;
+    }
+
+    // Match all except the supplied one.
+    // Regex equivalent: /[^x]/
+    template <const char chr>
+    const char* any_char_but(const char* src) {
+      return (*src && *src != chr) ? src + 1 : 0;
+    }
+
+    // Succeeds if the matcher fails.
+    // Aka. zero-width negative lookahead.
+    // Regex equivalent: /(?!literal)/
+    template <prelexer mx>
+    const char* negate(const char* src) {
+      return mx(src) ? 0 : src;
+    }
+
+    // Succeeds if the matcher succeeds.
+    // Aka. zero-width positive lookahead.
+    // Regex equivalent: /(?=literal)/
+    // just hangs around until we need it
+    template <prelexer mx>
+    const char* lookahead(const char* src) {
+      return mx(src) ? src : 0;
+    }
+
+    // Tries supplied matchers in order.
+    // Succeeds if one of them succeeds.
+    // Regex equivalent: /(?:FOO|BAR)/
+    template <prelexer... mxs>
+    const char* alternatives(const char* src) {
+      const char* rslt;
+      for (prelexer mx : { mxs... }) {
+        if ((rslt = mx(src))) return rslt;
+      }
+      return 0;
+    }
+
+    // Tries supplied matchers in order.
+    // Succeeds if all of them succeeds.
+    // Regex equivalent: /(?:FOO)(?:BAR)/
+    template <prelexer... mxs>
+    const char* sequence(const char* src) {
+      const char* rslt = src;
+      for (prelexer mx : { mxs... }) {
+        if (!(rslt = mx(rslt))) return 0;
+      }
+      return rslt;
+    }
+
+    // Match a pattern or not. Always succeeds.
+    // Regex equivalent: /(?:literal)?/
+    template <prelexer mx>
+    const char* optional(const char* src) {
+      const char* p = mx(src);
+      return p ? p : src;
+    }
+
+    // Match zero or more of the patterns.
+    // Regex equivalent: /(?:literal)*/
+    template <prelexer mx>
+    const char* zero_plus(const char* src) {
+      const char* p = mx(src);
+      while (p) src = p, p = mx(src);
+      return src;
+    }
+
+    // Match one or more of the patterns.
+    // Regex equivalent: /(?:literal)+/
+    template <prelexer mx>
+    const char* one_plus(const char* src) {
+      const char* p = mx(src);
+      if (!p) return 0;
+      while (p) src = p, p = mx(src);
+      return src;
+    }
+
+    // Match mx non-greedy until delimiter.
+    // Other prelexers are greedy by default.
+    // Regex equivalent: /(?:$mx)*?(?=$delim)\b/
+    template <prelexer mx, prelexer delim>
+    const char* non_greedy(const char* src) {
+      while (!delim(src)) {
+        const char* p = mx(src);
+        if (p == src) return 0;
+        if (p == 0) return 0;
+        src = p;
+      }
+      return src;
+    }
+
+    //####################################
+    // ADVANCED "REGEX" CONSTRUCTORS
+    //####################################
+
+    // Match with word boundary rule.
+    // Regex equivalent: /(?:$mx)\b/
+    template <const char* str>
+    const char* word(const char* src) {
+      return sequence <
+               exactly < str >,
+               word_boundary
+             >(src);
+    }
+
+    template <char chr>
+    const char* loosely(const char* src) {
+      return sequence <
+               optional_spaces,
+               exactly < chr >
+             >(src);
+    }
+    template <const char* str>
+    const char* loosely(const char* src) {
+      return sequence <
+               optional_spaces,
+               exactly < str >
+             >(src);
+    }
+
+  }
+}
+
+#endif

data/ext/libsass/listize.cpp

@@ -0,0 +1,83 @@
+#include <iostream>
+#include <typeinfo>
+
+#include "listize.hpp"
+#include "to_string.hpp"
+#include "context.hpp"
+#include "backtrace.hpp"
+#include "error_handling.hpp"
+
+namespace Sass {
+
+  Listize::Listize(Context& ctx)
+  : ctx(ctx)
+  {  }
+
+  Expression* Listize::operator()(Selector_List* sel)
+  {
+    List* l = new (ctx.mem) List(sel->pstate(), sel->length(), List::COMMA);
+    for (size_t i = 0, L = sel->length(); i < L; ++i) {
+      *l << (*sel)[i]->perform(this);
+    }
+    return l;
+  }
+
+  Expression* Listize::operator()(Compound_Selector* sel)
+  {
+    To_String to_string;
+    string str;
+    for (size_t i = 0, L = sel->length(); i < L; ++i) {
+      Expression* e = (*sel)[i]->perform(this);
+      if (e) str += e->perform(&to_string);
+    }
+    return new (ctx.mem) String_Constant(sel->pstate(), str);
+  }
+
+  Expression* Listize::operator()(Complex_Selector* sel)
+  {
+    List* l = new (ctx.mem) List(sel->pstate(), 2);
+
+    Compound_Selector* head = sel->head();
+    if (head && !head->is_empty_reference())
+    {
+      Expression* hh = head->perform(this);
+      if (hh) *l << hh;
+    }
+
+    switch(sel->combinator())
+    {
+      case Complex_Selector::PARENT_OF:
+        *l << new (ctx.mem) String_Constant(sel->pstate(), ">");
+      break;
+      case Complex_Selector::ADJACENT_TO:
+        *l << new (ctx.mem) String_Constant(sel->pstate(), "+");
+      break;
+      case Complex_Selector::PRECEDES:
+        *l << new (ctx.mem) String_Constant(sel->pstate(), "~");
+      break;
+      case Complex_Selector::ANCESTOR_OF:
+      break;
+    }
+
+    Complex_Selector* tail = sel->tail();
+    if (tail)
+    {
+      Expression* tt = tail->perform(this);
+      if (tt && tt->concrete_type() == Expression::LIST)
+      { *l += static_cast<List*>(tt); }
+      else if (tt) *l << static_cast<List*>(tt);
+    }
+    if (l->length() == 0) return 0;
+    return l;
+  }
+
+  Expression* Listize::operator()(Selector_Reference* sel)
+  {
+    return 0;
+  }
+
+  Expression* Listize::fallback_impl(AST_Node* n)
+  {
+    return static_cast<Expression*>(n);
+  }
+}