sassc4 2.4.0

data/ext/libsass/src/json.hpp

@@ -0,0 +1,117 @@
+/*
+  Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com)
+  All rights reserved.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef CCAN_JSON_H
+#define CCAN_JSON_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef enum {
+  JSON_NULL,
+  JSON_BOOL,
+  JSON_STRING,
+  JSON_NUMBER,
+  JSON_ARRAY,
+  JSON_OBJECT,
+} JsonTag;
+
+typedef struct JsonNode JsonNode;
+
+struct JsonNode
+{
+  /* only if parent is an object or array (NULL otherwise) */
+  JsonNode *parent;
+  JsonNode *prev, *next;
+
+  /* only if parent is an object (NULL otherwise) */
+  char *key; /* Must be valid UTF-8. */
+
+  JsonTag tag;
+  union {
+    /* JSON_BOOL */
+    bool bool_;
+
+    /* JSON_STRING */
+    char *string_; /* Must be valid UTF-8. */
+
+    /* JSON_NUMBER */
+    double number_;
+
+    /* JSON_ARRAY */
+    /* JSON_OBJECT */
+    struct {
+      JsonNode *head, *tail;
+    } children;
+  };
+};
+
+/*** Encoding, decoding, and validation ***/
+
+JsonNode   *json_decode         (const char *json);
+char       *json_encode         (const JsonNode *node);
+char       *json_encode_string  (const char *str);
+char       *json_stringify      (const JsonNode *node, const char *space);
+void        json_delete         (JsonNode *node);
+
+bool        json_validate       (const char *json);
+
+/*** Lookup and traversal ***/
+
+JsonNode   *json_find_element   (JsonNode *array, int index);
+JsonNode   *json_find_member    (JsonNode *object, const char *key);
+
+JsonNode   *json_first_child    (const JsonNode *node);
+
+#define json_foreach(i, object_or_array)            \
+  for ((i) = json_first_child(object_or_array);   \
+     (i) != NULL;                               \
+     (i) = (i)->next)
+
+/*** Construction and manipulation ***/
+
+JsonNode *json_mknull(void);
+JsonNode *json_mkbool(bool b);
+JsonNode *json_mkstring(const char *s);
+JsonNode *json_mknumber(double n);
+JsonNode *json_mkarray(void);
+JsonNode *json_mkobject(void);
+
+void json_append_element(JsonNode *array, JsonNode *element);
+void json_prepend_element(JsonNode *array, JsonNode *element);
+void json_append_member(JsonNode *object, const char *key, JsonNode *value);
+void json_prepend_member(JsonNode *object, const char *key, JsonNode *value);
+
+void json_remove_from_parent(JsonNode *node);
+
+/*** Debugging ***/
+
+/*
+ * Look for structure and encoding problems in a JsonNode or its descendents.
+ *
+ * If a problem is detected, return false, writing a description of the problem
+ * to errmsg (unless errmsg is NULL).
+ */
+bool json_check(const JsonNode *node, char errmsg[256]);
+
+#endif

data/ext/libsass/src/kwd_arg_macros.hpp

@@ -0,0 +1,28 @@
+#ifndef SASS_KWD_ARG_MACROS_H
+#define SASS_KWD_ARG_MACROS_H
+
+// Example usage:
+// KWD_ARG_SET(Args) {
+//   KWD_ARG(Args, string, foo);
+//   KWD_ARG(Args, int, bar);
+//   ...
+// };
+//
+// ... and later ...
+//
+// something(Args().foo("hey").bar(3));
+
+#define KWD_ARG_SET(set_name) class set_name
+
+#define KWD_ARG(set_name, type, name) \
+private: \
+  type name##_; \
+public: \
+  set_name& name(type name##__) { \
+    name##_ = name##__; \
+    return *this; \
+  } \
+  type name() { return name##_; } \
+private:
+
+#endif

data/ext/libsass/src/lexer.cpp

@@ -0,0 +1,122 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <iostream>
+#include <iomanip>
+#include "lexer.hpp"
+#include "constants.hpp"
+#include "util_string.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); };
+
+    bool is_number(char chr) {
+      return Util::ascii_isdigit(static_cast<unsigned char>(chr)) ||
+        chr == '-' || chr == '+';
+    }
+
+    // check if char is within a reduced ascii range
+    // valid in a uri (copied from Ruby Sass)
+    bool is_uri_character(char chr)
+    {
+      unsigned int cmp = unsigned(chr);
+      return (cmp > 41 && cmp < 127) ||
+             cmp == ':' || cmp == '/' || cmp == '|';
+    }
+
+    // check if char is within a reduced ascii range
+    // valid for escaping (copied from Ruby Sass)
+    bool is_escapable_character(char chr)
+    {
+      unsigned int cmp = unsigned(chr);
+      return cmp > 31 && cmp < 127;
+    }
+
+    // Match word character (look ahead)
+    bool is_character(char chr)
+    {
+      // valid alpha, numeric or unicode char (plus hyphen)
+      return Util::ascii_isalnum(static_cast<unsigned char>(chr)) ||
+        !Util::ascii_isascii(static_cast<unsigned char>(chr)) ||
+        chr == '-';
+    }
+
+    //####################################
+    // BASIC CLASS MATCHERS
+    //####################################
+
+    // create matchers that advance the position
+    const char* space(const char* src) { return Util::ascii_isspace(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* alpha(const char* src) { return Util::ascii_isalpha(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* nonascii(const char* src) { return Util::ascii_isascii(static_cast<unsigned char>(*src)) ? nullptr : src + 1; }
+    const char* digit(const char* src) { return Util::ascii_isdigit(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* xdigit(const char* src) { return Util::ascii_isxdigit(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* alnum(const char* src) { return Util::ascii_isalnum(static_cast<unsigned char>(*src)) ? src + 1 : nullptr; }
+    const char* hyphen(const char* src) { return *src == '-' ? src + 1 : 0; }
+    const char* uri_character(const char* src) { return is_uri_character(*src) ? src + 1 : 0; }
+    const char* escapable_character(const char* src) { return is_escapable_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); }
+    const char* hyphens(const char* src) { return one_plus<hyphen>(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) || *src == '#' ? 0 : src; }
+
+    // Match linefeed /(?:\n|\r\n?|\f)/
+    const char* re_linebreak(const char* src)
+    {
+      // end of file or unix linefeed return here
+      if (*src == 0) return src;
+      // end of file or unix linefeed return here
+      if (*src == '\n' || *src == '\f') 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 == '\f' ? src : 0;
+    }
+
+    // Assert end_of_file boundary (/\z/)
+    // This is a zero-width positive lookahead
+    const char* end_of_file(const char* src)
+    {
+      // end of file or unix linefeed return here
+      return *src == 0 ? src : 0;
+    }
+
+  }
+}

data/ext/libsass/src/lexer.hpp

@@ -0,0 +1,304 @@
+#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
+    //####################################
+
+    // Matches ASCII digits, +, and -.
+    bool is_number(char src);
+
+    bool is_uri_character(char src);
+    bool escapable_character(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* hyphen(const char* src);
+    const char* nonascii(const char* src);
+    const char* uri_character(const char* src);
+    const char* escapable_character(const char* src);
+
+    // Match multiple ctype characters.
+    const char* spaces(const char* src);
+    const char* digits(const char* src);
+    const char* hyphens(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);
+
+    // Assert end_of_file boundary (/\z/)
+    const char* end_of_file(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: /(?:x)/
+    template <char chr>
+    const char* exactly(const char* src) {
+      return *src == chr ? src + 1 : 0;
+    }
+
+    // Match the full string literal.
+    // Regex equivalent: /(?:literal)/
+    template <const char* str>
+    const char* exactly(const char* src) {
+      if (str == NULL) return 0;
+      const char* pre = str;
+      if (src == NULL) 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;
+      }
+      // did the matcher finish?
+      return *pre == 0 ? src : 0;
+    }
+
+
+    // Match a single character literal.
+    // Regex equivalent: /(?:x)/i
+    // only define lower case alpha chars
+    template <char chr>
+    const char* insensitive(const char* src) {
+      return *src == chr || *src+32 == chr ? src + 1 : 0;
+    }
+
+    // Match the full string literal.
+    // Regex equivalent: /(?:literal)/i
+    // only define lower case alpha chars
+    template <const char* str>
+    const char* insensitive(const char* src) {
+      if (str == NULL) return 0;
+      const char* pre = str;
+      if (src == NULL) 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+32 == *pre)) {
+        ++src, ++pre;
+      }
+      // did the matcher finish?
+      return *pre == 0 ? src : 0;
+    }
+
+    // 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 for members of char class.
+    // Regex equivalent: /[^axy]/
+    template <const char* neg_char_class>
+    const char* neg_class_char(const char* src) {
+      if (*src == 0) return 0;
+      const char* cc = neg_char_class;
+      while (*cc && *src != *cc) ++cc;
+      return *cc ? 0 : src + 1;
+    }
+
+    // Match for members of char class.
+    // Regex equivalent: /[^axy]+/
+    template <const char* neg_char_class>
+    const char* neg_class_chars(const char* src) {
+      const char* p = src;
+      while (neg_class_char<neg_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 <const prelexer mx>
+    const char* alternatives(const char* src) {
+      const char* rslt;
+      if ((rslt = mx(src))) return rslt;
+      return 0;
+    }
+    template <const prelexer mx1, const prelexer mx2, const prelexer... mxs>
+    const char* alternatives(const char* src) {
+      const char* rslt;
+      if ((rslt = mx1(src))) return rslt;
+      return alternatives<mx2, mxs...>(src);
+    }
+
+    // Tries supplied matchers in order.
+    // Succeeds if all of them succeeds.
+    // Regex equivalent: /(?:FOO)(?:BAR)/
+    template <const prelexer mx1>
+    const char* sequence(const char* src) {
+      const char* rslt = src;
+      if (!(rslt = mx1(rslt))) return 0;
+      return rslt;
+    }
+    template <const prelexer mx1, const prelexer mx2, const prelexer... mxs>
+    const char* sequence(const char* src) {
+      const char* rslt = src;
+      if (!(rslt = mx1(rslt))) return 0;
+      return sequence<mx2, mxs...>(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/i
+    template <const char* str>
+    const char* keyword(const char* src) {
+      return sequence <
+               insensitive < str >,
+               word_boundary
+             >(src);
+    }
+
+    // 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/src/listize.cpp

@@ -0,0 +1,70 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <iostream>
+#include <typeinfo>
+#include <string>
+
+#include "listize.hpp"
+#include "context.hpp"
+#include "backtrace.hpp"
+#include "error_handling.hpp"
+
+namespace Sass {
+
+  Listize::Listize()
+  {  }
+
+  Expression* Listize::perform(AST_Node* node)
+  {
+    Listize listize;
+    return node->perform(&listize);
+  }
+
+  Expression* Listize::operator()(SelectorList* sel)
+  {
+    List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
+    l->from_selector(true);
+    for (size_t i = 0, L = sel->length(); i < L; ++i) {
+      if (!sel->at(i)) continue;
+      l->append(sel->at(i)->perform(this));
+    }
+    if (l->length()) return l.detach();
+    return SASS_MEMORY_NEW(Null, l->pstate());
+  }
+
+  Expression* Listize::operator()(CompoundSelector* sel)
+  {
+    sass::string str;
+    for (size_t i = 0, L = sel->length(); i < L; ++i) {
+      Expression* e = (*sel)[i]->perform(this);
+      if (e) str += e->to_string();
+    }
+    return SASS_MEMORY_NEW(String_Quoted, sel->pstate(), str);
+  }
+
+  Expression* Listize::operator()(ComplexSelector* sel)
+  {
+    List_Obj l = SASS_MEMORY_NEW(List, sel->pstate());
+    // ToDo: investigate what this does
+    // Note: seems reated to parent ref
+    l->from_selector(true);
+
+    for (auto component : sel->elements()) {
+      if (CompoundSelectorObj compound = Cast<CompoundSelector>(component)) {
+        if (!compound->empty()) {
+          ExpressionObj hh = compound->perform(this);
+          if (hh) l->append(hh);
+        }
+      }
+      else if (component) {
+        l->append(SASS_MEMORY_NEW(String_Quoted, component->pstate(), component->to_string()));
+      }
+    }
+
+    if (l->length() == 0) return 0;
+    return l.detach();
+  }
+
+}

data/ext/libsass/src/listize.hpp

@@ -0,0 +1,37 @@
+#ifndef SASS_LISTIZE_H
+#define SASS_LISTIZE_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast_fwd_decl.hpp"
+#include "operation.hpp"
+
+namespace Sass {
+
+  struct Backtrace;
+
+  class Listize : public Operation_CRTP<Expression*, Listize> {
+
+  public:
+
+    static Expression* perform(AST_Node* node);
+
+  public:
+    Listize();
+    ~Listize() { }
+
+    Expression* operator()(SelectorList*);
+    Expression* operator()(ComplexSelector*);
+    Expression* operator()(CompoundSelector*);
+
+    // generic fallback
+    template <typename U>
+    Expression* fallback(U x)
+    { return Cast<Expression>(x); }
+  };
+
+}
+
+#endif

data/ext/libsass/src/mapping.hpp

@@ -0,0 +1,19 @@
+#ifndef SASS_MAPPING_H
+#define SASS_MAPPING_H
+
+#include "position.hpp"
+#include "backtrace.hpp"
+
+namespace Sass {
+
+  struct Mapping {
+    Position original_position;
+    Position generated_position;
+
+    Mapping(const Position& original_position, const Position& generated_position)
+    : original_position(original_position), generated_position(generated_position) { }
+  };
+
+}
+
+#endif