sassc 1.7.1 → 1.8.0.pre1

data/ext/libsass/{inspect.hpp → src/inspect.hpp}

@@ -1,15 +1,12 @@
 #ifndef SASS_INSPECT_H
 #define SASS_INSPECT_H
 
-#include <string>
-
 #include "position.hpp"
 #include "operation.hpp"
 #include "emitter.hpp"
 
 namespace Sass {
   class Context;
-  using namespace std;
 
   class Inspect : public Operation_CRTP<void, Inspect>, public Emitter {
   protected:
@@ -28,7 +25,7 @@ namespace Sass {
     virtual void operator()(Ruleset*);
     virtual void operator()(Propset*);
     virtual void operator()(Bubble*);
-    virtual void operator()(Feature_Block*);
+    virtual void operator()(Supports_Block*);
     virtual void operator()(Media_Block*);
     virtual void operator()(At_Root_Block*);
     virtual void operator()(At_Rule*);
@@ -57,6 +54,8 @@ namespace Sass {
     virtual void operator()(Unary_Expression*);
     virtual void operator()(Function_Call*);
     virtual void operator()(Function_Call_Schema*);
+    // virtual void operator()(Custom_Warning*);
+    // virtual void operator()(Custom_Error*);
     virtual void operator()(Variable*);
     virtual void operator()(Textual*);
     virtual void operator()(Number*);
@@ -65,8 +64,10 @@ namespace Sass {
     virtual void operator()(String_Schema*);
     virtual void operator()(String_Constant*);
     virtual void operator()(String_Quoted*);
-    virtual void operator()(Feature_Query*);
-    virtual void operator()(Feature_Query_Condition*);
+    virtual void operator()(Supports_Operator*);
+    virtual void operator()(Supports_Negation*);
+    virtual void operator()(Supports_Declaration*);
+    virtual void operator()(Supports_Interpolation*);
     virtual void operator()(Media_Query*);
     virtual void operator()(Media_Query_Expression*);
     virtual void operator()(At_Root_Expression*);
@@ -79,7 +80,6 @@ namespace Sass {
     virtual void operator()(Arguments*);
     // selectors
     virtual void operator()(Selector_Schema*);
-    virtual void operator()(Selector_Reference*);
     virtual void operator()(Selector_Placeholder*);
     virtual void operator()(Type_Selector*);
     virtual void operator()(Selector_Qualifier*);

data/ext/libsass/{json.cpp → src/json.cpp}

@@ -21,6 +21,11 @@
   THE SOFTWARE.
 */
 
+#ifdef _MSC_VER
+#define _CRT_SECURE_NO_WARNINGS
+#define _CRT_NONSTDC_NO_DEPRECATE
+#endif
+
 #include "json.hpp"
 
 #include <assert.h>
@@ -29,35 +34,13 @@
 #include <stdlib.h>
 #include <string.h>
 
-#ifdef _MSC_VER
-
+#if defined(_MSC_VER) && _MSC_VER < 1900
 #include <stdarg.h>
-#define snprintf c99_snprintf
-
-inline int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap)
-{
-    int count = -1;
-
-    if (size != 0)
-        count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
-    if (count == -1)
-        count = _vscprintf(format, ap);
-
-    return count;
-}
-
-inline int c99_snprintf(char* str, size_t size, const char* format, ...)
-{
-    int count;
-    va_list ap;
-
-    va_start(ap, format);
-    count = c99_vsnprintf(str, size, format, ap);
-    va_end(ap);
-
-    return count;
-}
-#endif // _MSC_VER
+#ifdef snprintf
+#undef snprintf
+#endif
+extern "C" int snprintf(char *, size_t, const char *, ...);
+#endif
 
 #define out_of_memory() do {                    \
     fprintf(stderr, "Out of memory.\n");    \
@@ -129,7 +112,7 @@ static void sb_put(SB *sb, const char *bytes, int count)
 
 static void sb_puts(SB *sb, const char *str)
 {
-  sb_put(sb, str, strlen(str));
+  sb_put(sb, str, (int)strlen(str));
 }
 
 static char *sb_finish(SB *sb)
@@ -352,9 +335,8 @@ static void to_surrogate_pair(uint32_t unicode, uint16_t *uc, uint16_t *lc)
   *lc = (n & 0x3FF) | 0xDC00;
 }
 
-#define is_space(c) ((c) == '\t' || (c) == '\n' || (c) == '\r' || (c) == ' ')
-#define is_digit(c) ((c) >= '0' && (c) <= '9')
-
+static bool is_space        (const char *c);
+static bool is_digit        (const char *c);
 static bool parse_value     (const char **sp, JsonNode        **out);
 static bool parse_string    (const char **sp, char            **out);
 static bool parse_number    (const char **sp, double           *out);
@@ -680,7 +662,7 @@ static bool parse_value(const char **sp, JsonNode **out)
       return false;
 
     case '"': {
-      char *str;
+      char *str = NULL;
       if (parse_string(&s, out ? &str : NULL)) {
         if (out)
           *out = mkstring(str);
@@ -721,7 +703,7 @@ static bool parse_array(const char **sp, JsonNode **out)
 {
   const char *s = *sp;
   JsonNode *ret = out ? json_mkarray() : NULL;
-  JsonNode *element;
+  JsonNode *element = NULL;
 
   if (*s++ != '[')
     goto failure;
@@ -765,8 +747,8 @@ static bool parse_object(const char **sp, JsonNode **out)
 {
   const char *s = *sp;
   JsonNode *ret = out ? json_mkobject() : NULL;
-  char *key;
-  JsonNode *value;
+  char *key = NULL;
+  JsonNode *value = NULL;
 
   if (*s++ != '{')
     goto failure;
@@ -932,6 +914,14 @@ failed:
   return false;
 }
 
+bool is_space(const char *c) {
+  return ((*c) == '\t' || (*c) == '\n' || (*c) == '\r' || (*c) == ' ');
+}
+
+bool is_digit(const char *c){
+  return ((*c) >= '0' && (*c) <= '9');
+}
+
 /*
  * The JSON spec says that a number shall follow this precise pattern
  * (spaces and quotes added for readability):
@@ -954,21 +944,21 @@ bool parse_number(const char **sp, double *out)
   if (*s == '0') {
     s++;
   } else {
-    if (!is_digit(*s))
+    if (!is_digit(s))
       return false;
     do {
       s++;
-    } while (is_digit(*s));
+    } while (is_digit(s));
   }
 
   /* ('.' [0-9]+)? */
   if (*s == '.') {
     s++;
-    if (!is_digit(*s))
+    if (!is_digit(s))
       return false;
     do {
       s++;
-    } while (is_digit(*s));
+    } while (is_digit(s));
   }
 
   /* ([Ee] [+-]? [0-9]+)? */
@@ -976,11 +966,11 @@ bool parse_number(const char **sp, double *out)
     s++;
     if (*s == '+' || *s == '-')
       s++;
-    if (!is_digit(*s))
+    if (!is_digit(s))
       return false;
     do {
       s++;
-    } while (is_digit(*s));
+    } while (is_digit(s));
   }
 
   if (out)
@@ -993,7 +983,7 @@ bool parse_number(const char **sp, double *out)
 static void skip_space(const char **sp)
 {
   const char *s = *sp;
-  while (is_space(*s))
+  while (is_space(s))
     s++;
   *sp = s;
 }

data/ext/libsass/{json.hpp → src/json.hpp}

@@ -114,4 +114,4 @@ void json_remove_from_parent(JsonNode *node);
  */
 bool json_check(const JsonNode *node, char errmsg[256]);
 
-#endif
+#endif

data/ext/libsass/{lexer.cpp → src/lexer.cpp}

@@ -75,6 +75,24 @@ namespace Sass {
       return unsigned(chr) > 127;
     }
 
+    // check if char is outside ascii range
+    // but with specific ranges (copied from Ruby Sass)
+    bool is_nonascii(const char& chr)
+    {
+      return (
+        (unsigned(chr) > 127 && unsigned(chr) < 55296) ||
+        (unsigned(chr) > 57343 && unsigned(chr) < 65534) ||
+        (unsigned(chr) > 65535 && unsigned(chr) < 1114111)
+      );
+    }
+
+    // check if char is within a reduced ascii range
+    // valid in a uri (copied from Ruby Sass)
+    bool is_uri_character(const char& chr)
+    {
+      return unsigned(chr) > 41 && unsigned(chr) < 127;
+    }
+
     // Match word character (look ahead)
     bool is_character(const char& chr)
     {
@@ -90,11 +108,13 @@ namespace Sass {
     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* nonascii(const char* src) { return is_nonascii(*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; }
+    const char* uri_character(const char* src) { return is_uri_character(*src) ? src + 1 : 0; }
 
     // Match multiple ctype characters.
     const char* spaces(const char* src) { return one_plus<space>(src); }
@@ -129,5 +149,13 @@ namespace Sass {
       return *src == 0 || *src == '\n' || *src == '\r' ? 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/{lexer.hpp → src/lexer.hpp}

@@ -32,7 +32,9 @@ namespace Sass {
     bool is_alnum(const char& src);
     bool is_xdigit(const char& src);
     bool is_unicode(const char& src);
+    bool is_nonascii(const char& src);
     bool is_character(const char& src);
+    bool is_uri_character(const char& src);
 
     // Match a single ctype predicate.
     const char* space(const char* src);
@@ -42,7 +44,9 @@ namespace Sass {
     const char* alnum(const char* src);
     const char* punct(const char* src);
     const char* unicode(const char* src);
+    const char* nonascii(const char* src);
     const char* character(const char* src);
+    const char* uri_character(const char* src);
 
     // Match multiple ctype characters.
     const char* spaces(const char* src);
@@ -65,7 +69,9 @@ namespace Sass {
     // 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);
+
+    // 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
@@ -107,7 +113,7 @@ namespace Sass {
     }
 
     // Match for members of char class.
-    // Regex equivalent: /[axy]/
+    // Regex equivalent: /[axy]+/
     template <const char* char_class>
     const char* class_chars(const char* src) {
       const char* p = src;
@@ -142,26 +148,35 @@ namespace Sass {
     // Tries supplied matchers in order.
     // Succeeds if one of them succeeds.
     // Regex equivalent: /(?:FOO|BAR)/
-    template <prelexer... mxs>
+    template <const prelexer mx>
     const char* alternatives(const char* src) {
       const char* rslt;
-      for (prelexer mx : { mxs... }) {
-        if ((rslt = mx(src))) return 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 <prelexer... mxs>
+    template <const prelexer mx1>
     const char* sequence(const char* src) {
       const char* rslt = src;
-      for (prelexer mx : { mxs... }) {
-        if (!(rslt = mx(rslt))) return 0;
-      }
+      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)?/

data/ext/libsass/{listize.cpp → src/listize.cpp}

@@ -1,5 +1,6 @@
 #include <iostream>
 #include <typeinfo>
+#include <string>
 
 #include "listize.hpp"
 #include "to_string.hpp"
@@ -15,8 +16,9 @@ namespace Sass {
 
   Expression* Listize::operator()(Selector_List* sel)
   {
-    List* l = new (ctx.mem) List(sel->pstate(), sel->length(), List::COMMA);
+    List* l = SASS_MEMORY_NEW(ctx.mem, List, sel->pstate(), sel->length(), SASS_COMMA);
     for (size_t i = 0, L = sel->length(); i < L; ++i) {
+      if (!(*sel)[i]) continue;
       *l << (*sel)[i]->perform(this);
     }
     return l;
@@ -25,17 +27,17 @@ namespace Sass {
   Expression* Listize::operator()(Compound_Selector* sel)
   {
     To_String to_string;
-    string str;
+    std::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);
+    return SASS_MEMORY_NEW(ctx.mem, String_Quoted, sel->pstate(), str);
   }
 
   Expression* Listize::operator()(Complex_Selector* sel)
   {
-    List* l = new (ctx.mem) List(sel->pstate(), 2);
+    List* l = SASS_MEMORY_NEW(ctx.mem, List, sel->pstate(), 2);
 
     Compound_Selector* head = sel->head();
     if (head && !head->is_empty_reference())
@@ -44,16 +46,22 @@ namespace Sass {
       if (hh) *l << hh;
     }
 
+    To_String to_string;
+    std::string reference = ! sel->reference() ? ""
+      : sel->reference()->perform(&to_string);
     switch(sel->combinator())
     {
       case Complex_Selector::PARENT_OF:
-        *l << new (ctx.mem) String_Constant(sel->pstate(), ">");
+        *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, sel->pstate(), ">");
       break;
       case Complex_Selector::ADJACENT_TO:
-        *l << new (ctx.mem) String_Constant(sel->pstate(), "+");
+        *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, sel->pstate(), "+");
+      break;
+      case Complex_Selector::REFERENCE:
+        *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, sel->pstate(), "/" + reference + "/");
       break;
       case Complex_Selector::PRECEDES:
-        *l << new (ctx.mem) String_Constant(sel->pstate(), "~");
+        *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, sel->pstate(), "~");
       break;
       case Complex_Selector::ANCESTOR_OF:
       break;
@@ -71,13 +79,9 @@ namespace Sass {
     return l;
   }
 
-  Expression* Listize::operator()(Selector_Reference* sel)
-  {
-    return 0;
-  }
-
   Expression* Listize::fallback_impl(AST_Node* n)
   {
-    return static_cast<Expression*>(n);
+    return dynamic_cast<Expression*>(n);
   }
+
 }

data/ext/libsass/{listize.hpp → src/listize.hpp}

@@ -10,7 +10,6 @@
 #include "environment.hpp"
 
 namespace Sass {
-  using namespace std;
 
   typedef Environment<AST_Node*> Env;
   struct Backtrace;
@@ -30,7 +29,6 @@ namespace Sass {
     Expression* operator()(Selector_List*);
     Expression* operator()(Complex_Selector*);
     Expression* operator()(Compound_Selector*);
-    Expression* operator()(Selector_Reference*);
 
     template <typename U>
     Expression* fallback(U x) { return fallback_impl(x); }