sassc 1.7.1 → 1.8.0.pre1

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

@@ -195,10 +195,16 @@ namespace Sass {
     const char* identifier(const char* src);
     const char* identifier_alpha(const char* src);
     const char* identifier_alnum(const char* src);
-    const char* identifier_alnums(const char* src);
-    // Match selector names.
-    // const char* sel_ident(const char* src);
-    const char* kwd_sel_deep(const char* src);
+    const char* strict_identifier(const char* src);
+    const char* strict_identifier_alpha(const char* src);
+    const char* strict_identifier_alnum(const char* src);
+    // Match a CSS unit identifier.
+    const char* unit_identifier(const char* src);
+    // const char* strict_identifier_alnums(const char* src);
+    // Match reference selector.
+    const char* re_reference_combinator(const char* src);
+    const char* static_reference_combinator(const char* src);
+    const char* schema_reference_combinator(const char* src);
 
     // Match interpolant schemas
     const char* identifier_schema(const char* src);
@@ -215,16 +221,19 @@ namespace Sass {
     const char* kwd_with_directive(const char* src);
     const char* kwd_without_directive(const char* src);
     const char* kwd_media(const char* src);
-    const char* kwd_supports(const char* src);
+    const char* kwd_supports_directive(const char* src);
     // const char* keyframes(const char* src);
     // const char* keyf(const char* src);
     const char* kwd_mixin(const char* src);
     const char* kwd_function(const char* src);
     const char* kwd_return_directive(const char* src);
-    const char* kwd_include(const char* src);
-    const char* kwd_content(const char* src);
+    const char* kwd_include_directive(const char* src);
+    const char* kwd_content_directive(const char* src);
+    const char* kwd_charset_directive(const char* src);
     const char* kwd_extend(const char* src);
 
+    const char* unicode_seq(const char* src);
+
     const char* kwd_if_directive(const char* src);
     const char* kwd_else_directive(const char* src);
     const char* elseif_directive(const char* src);
@@ -239,13 +248,25 @@ namespace Sass {
 
     const char* kwd_while_directive(const char* src);
 
+    const char* re_nothing(const char* src);
+    const char* re_type_selector2(const char* src);
+
+
     const char* kwd_warn(const char* src);
     const char* kwd_err(const char* src);
     const char* kwd_dbg(const char* src);
 
     const char* kwd_null(const char* src);
 
+    const char* re_type_selector(const char* src);
+    const char* re_static_expression(const char* src);
+
+    // identifier that can start with hyphens
+    const char* css_identifier(const char* src);
+    const char* css_ip_identifier(const char* src);
+
     // Match CSS type selectors
+    const char* namespace_schema(const char* src);
     const char* namespace_prefix(const char* src);
     const char* type_selector(const char* src);
     const char* hyphens_and_identifier(const char* src);
@@ -276,16 +297,17 @@ namespace Sass {
     const char* uri_prefix(const char* src);
     const char* uri_value(const char* src);
     // Match CSS "!important" keyword.
-    const char* important(const char* src);
+    const char* kwd_important(const char* src);
     // Match CSS "!optional" keyword.
-    const char* optional(const char* src);
+    const char* kwd_optional(const char* src);
     // Match Sass "!default" keyword.
     const char* default_flag(const char* src);
     const char* global_flag(const char* src);
     // Match CSS pseudo-class/element prefixes
     const char* pseudo_prefix(const char* src);
     // Match CSS function call openers.
-    const char* functional(const char* src);
+    const char* re_functional(const char* src);
+    const char* re_pseudo_selector(const char* src);
     const char* functional_schema(const char* src);
     const char* pseudo_not(const char* src);
     // Match CSS 'odd' and 'even' keywords for functional pseudo-classes.
@@ -318,6 +340,17 @@ namespace Sass {
     // match urls
     const char* url(const char* src);
 
+    // match url()
+    const char* H(const char* src);
+    const char* W(const char* src);
+    // `UNICODE` makes VS sad
+    const char* UUNICODE(const char* src);
+    const char* NONASCII(const char* src);
+    const char* ESCAPE(const char* src);
+    const char* real_uri_suffix(const char* src);
+    // const char* real_uri_prefix(const char* src);
+    const char* real_uri_value(const char* src);
+
     // Path matching functions.
     // const char* folder(const char* src);
     // const char* folders(const char* src);
@@ -325,6 +358,7 @@ namespace Sass {
 
     const char* static_string(const char* src);
     const char* static_component(const char* src);
+    const char* static_property(const char* src);
     const char* static_value(const char* src);
 
     // Utility functions for finding and counting characters in a string.
@@ -372,6 +406,12 @@ namespace Sass {
       return counter;
     }
 
+    template <size_t size, prelexer mx, prelexer pad>
+    const char* padded_token(const char* src);
+
+    template <size_t min, size_t max, prelexer mx>
+    const char* minmax_range(const char* src);
+
   }
 }
 

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

@@ -10,17 +10,21 @@ namespace Sass {
     : ctx(ctx)
     { }
 
-    template<typename T>
-    void Remove_Placeholders::clean_selector_list(T r) {
+    void Remove_Placeholders::operator()(Block* b) {
+        for (size_t i = 0, L = b->length(); i < L; ++i) {
+            (*b)[i]->perform(this);
+        }
+    }
 
+    void Remove_Placeholders::operator()(Ruleset* r) {
         // Create a new selector group without placeholders
         Selector_List* sl = static_cast<Selector_List*>(r->selector());
 
         if (sl) {
-            Selector_List* new_sl = new (ctx.mem) Selector_List(sl->pstate());
+            Selector_List* new_sl = SASS_MEMORY_NEW(ctx.mem, Selector_List, sl->pstate());
 
             for (size_t i = 0, L = sl->length(); i < L; ++i) {
-                if (!(*sl)[i]->has_placeholder()) {
+                if (!(*sl)[i]->contains_placeholder()) {
                     *new_sl << (*sl)[i];
                 }
             }
@@ -33,25 +37,17 @@ namespace Sass {
         Block* b = r->block();
 
         for (size_t i = 0, L = b->length(); i < L; ++i) {
-            Statement* stm = (*b)[i];
-            stm->perform(this);
+            if ((*b)[i]) (*b)[i]->perform(this);
         }
     }
 
-    void Remove_Placeholders::operator()(Block* b) {
+    void Remove_Placeholders::operator()(Media_Block* m) {
+        Block* b = m->block();
         for (size_t i = 0, L = b->length(); i < L; ++i) {
-            (*b)[i]->perform(this);
+            if ((*b)[i]) (*b)[i]->perform(this);
         }
     }
 
-    void Remove_Placeholders::operator()(Ruleset* r) {
-        clean_selector_list(r);
-    }
-
-    void Remove_Placeholders::operator()(Media_Block* m) {
-        clean_selector_list(m);
-    }
-
     void Remove_Placeholders::operator()(At_Rule* a) {
         if (a->block()) a->block()->perform(this);
     }

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

@@ -3,14 +3,11 @@
 
 #pragma once
 
-#include <iostream>
-
 #include "ast.hpp"
 #include "operation.hpp"
 
 namespace Sass {
 
-    using namespace std;
 
     class Context;
 
@@ -18,7 +15,7 @@ namespace Sass {
 
         Context&          ctx;
 
-        void fallback_impl(AST_Node* n) {};
+        void fallback_impl(AST_Node* n) {}
 
     public:
         Remove_Placeholders(Context&);
@@ -31,9 +28,6 @@ namespace Sass {
         void operator()(Media_Block*);
         void operator()(At_Rule*);
 
-        template <typename T>
-        void clean_selector_list(T r);
-
         template <typename U>
         void fallback(U x) { return fallback_impl(x); }
     };

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

@@ -8,21 +8,19 @@
 #include "util.hpp"
 
 extern "C" {
-  using namespace std;
   using namespace Sass;
-  using namespace File;
 
   // caller must free the returned memory
   char* ADDCALL sass_string_quote (const char *str, const char quote_mark)
   {
-    string quoted = quote(str, quote_mark);
+    std::string quoted = quote(str, quote_mark);
     return sass_strdup(quoted.c_str());
   }
 
   // caller must free the returned memory
   char* ADDCALL sass_string_unquote (const char *str)
   {
-    string unquoted = unquote(str);
+    std::string unquoted = unquote(str);
     return sass_strdup(unquoted.c_str());
   }
 
@@ -30,7 +28,7 @@ extern "C" {
   // Incs array has to be null terminated!
   char* ADDCALL sass_resolve_file (const char* file, const char* paths[])
   {
-    string resolved(find_file(file, paths));
+    std::string resolved(File::find_file(file, paths));
     return sass_strdup(resolved.c_str());
   }
 

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

@@ -1,3 +1,8 @@
+#ifdef _MSC_VER
+#define _CRT_SECURE_NO_WARNINGS
+#define _CRT_NONSTDC_NO_DEPRECATE
+#endif
+
 // include library
 #include <stack>
 #include <string>
@@ -22,7 +27,6 @@
 #include "sass2scss.h"
 
 // using std::string
-using namespace std;
 
 // add namespace for c++
 namespace Sass
@@ -45,7 +49,7 @@ namespace Sass
 	#define IS_CSS_COMMENT(converter) (converter.comment == "/*" || (converter.comment == "//" && CONVERT_COMMENT(converter)))
 
 	// pretty printer helper function
-	static string closer (const converter& converter)
+	static std::string closer (const converter& converter)
 	{
 		return PRETTIFY(converter) == 0 ? " }" :
 		     PRETTIFY(converter) <= 1 ? " }" :
@@ -53,7 +57,7 @@ namespace Sass
 	}
 
 	// pretty printer helper function
-	static string opener (const converter& converter)
+	static std::string opener (const converter& converter)
 	{
 		return PRETTIFY(converter) == 0 ? " { " :
 		     PRETTIFY(converter) <= 2 ? " {" :
@@ -62,13 +66,13 @@ namespace Sass
 
 	// check if the given string is a pseudo selector
 	// needed to differentiate from sass property syntax
-	static bool isPseudoSelector (string& sel)
+	static bool isPseudoSelector (std::string& sel)
 	{
 
 		size_t len = sel.length();
 		if (len < 1) return false;
 		size_t pos = sel.find_first_not_of("abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ", 1);
-		if (pos != string::npos) sel.erase(pos, string::npos);
+		if (pos != std::string::npos) sel.erase(pos, std::string::npos);
 		size_t i = sel.length();
 		while (i -- > 0) { sel.at(i) = tolower(sel.at(i)); }
 
@@ -148,7 +152,7 @@ namespace Sass
 
 	// check if there is some char data
 	// will ignore everything in comments
-	static bool hasCharData (string& sass)
+	static bool hasCharData (std::string& sass)
 	{
 
 		size_t col_pos = 0;
@@ -160,7 +164,7 @@ namespace Sass
 			col_pos = sass.find_first_not_of(" \t\n\v\f\r", col_pos);
 
 			// there was no meaningfull char found
-			if (col_pos == string::npos) return false;
+			if (col_pos == std::string::npos) return false;
 
 			// found a multiline comment opener
 			if (sass.substr(col_pos, 2) == "/*")
@@ -168,7 +172,7 @@ namespace Sass
 				// find the multiline comment closer
 				col_pos = sass.find("*/", col_pos);
 				// maybe we did not find the closer here
-				if (col_pos == string::npos) return false;
+				if (col_pos == std::string::npos) return false;
 				// skip closer
 				col_pos += 2;
 			}
@@ -184,7 +188,7 @@ namespace Sass
 
 	// find src comment opener
 	// correctly skips quoted strings
-	static size_t findCommentOpener (string& sass)
+	static size_t findCommentOpener (std::string& sass)
 	{
 
 		size_t col_pos = 0;
@@ -193,14 +197,14 @@ namespace Sass
 		bool comment = false;
 		size_t brackets = 0;
 
-		while (col_pos != string::npos)
+		while (col_pos != std::string::npos)
 		{
 
 			// process all interesting chars
 			col_pos = sass.find_first_of("\"\'/\\*()", col_pos);
 
 			// assertion for valid result
-			if (col_pos != string::npos)
+			if (col_pos != std::string::npos)
 			{
 				char character = sass.at(col_pos);
 
@@ -266,10 +270,10 @@ namespace Sass
 
 	// remove multiline comments from sass string
 	// correctly skips quoted strings
-	static string removeMultilineComment (string &sass)
+	static std::string removeMultilineComment (std::string &sass)
 	{
 
-		string clean = "";
+		std::string clean = "";
 		size_t col_pos = 0;
 		size_t open_pos = 0;
 		size_t close_pos = 0;
@@ -278,14 +282,14 @@ namespace Sass
 		bool comment = false;
 
 		// process sass til string end
-		while (col_pos != string::npos)
+		while (col_pos != std::string::npos)
 		{
 
 			// process all interesting chars
 			col_pos = sass.find_first_of("\"\'/\\*", col_pos);
 
 			// assertion for valid result
-			if (col_pos != string::npos)
+			if (col_pos != std::string::npos)
 			{
 				char character = sass.at(col_pos);
 
@@ -342,11 +346,11 @@ namespace Sass
 	// EO removeMultilineComment
 
 	// right trim a given string
-	string rtrim(const string &sass)
+	std::string rtrim(const std::string &sass)
 	{
-		string trimmed = sass;
+		std::string trimmed = sass;
 		size_t pos_ws = trimmed.find_last_not_of(" \t\n\v\f\r");
-		if (pos_ws != string::npos)
+		if (pos_ws != std::string::npos)
 		{ trimmed.erase(pos_ws + 1); }
 		else { trimmed.clear(); }
 		return trimmed;
@@ -355,11 +359,11 @@ namespace Sass
 
 	// flush whitespace and print additional text, but
 	// only print additional chars and buffer whitespace
-	string flush (string& sass, converter& converter)
+	std::string flush (std::string& sass, converter& converter)
 	{
 
 		// return flushed
-		string scss = "";
+		std::string scss = "";
 
 		// print whitespace buffer
 		scss += PRETTIFY(converter) > 0 ?
@@ -369,16 +373,16 @@ namespace Sass
 
 		// remove possible newlines from string
 		size_t pos_right = sass.find_last_not_of("\n\r");
-		if (pos_right == string::npos) return scss;
+		if (pos_right == std::string::npos) return scss;
 
 		// get the linefeeds from the string
-		string lfs = sass.substr(pos_right + 1);
+		std::string lfs = sass.substr(pos_right + 1);
 		sass = sass.substr(0, pos_right + 1);
 
 		// find some source comment opener
 		size_t comment_pos = findCommentOpener(sass);
 		// check if there was a source comment
-		if (comment_pos != string::npos)
+		if (comment_pos != std::string::npos)
 		{
 			// convert comment (but only outside other coments)
 			if (CONVERT_COMMENT(converter) && !IS_COMMENT(converter))
@@ -393,7 +397,7 @@ namespace Sass
 			{
 				// also include whitespace before the actual comment opener
 				size_t ws_pos = sass.find_last_not_of(SASS2SCSS_FIND_WHITESPACE, comment_pos - 1);
-				comment_pos = ws_pos == string::npos ? 0 : ws_pos + 1;
+				comment_pos = ws_pos == std::string::npos ? 0 : ws_pos + 1;
 			}
 			if (!STRIP_COMMENT(converter))
 			{
@@ -416,7 +420,7 @@ namespace Sass
 		{
 			// remove leading whitespace and update string
 			size_t pos_left = sass.find_first_not_of(SASS2SCSS_FIND_WHITESPACE);
-			if (pos_left != string::npos) sass = sass.substr(pos_left);
+			if (pos_left != std::string::npos) sass = sass.substr(pos_left);
 		}
 
 		// add flushed data
@@ -429,11 +433,11 @@ namespace Sass
 	// EO flush
 
 	// process a line of the sass text
-	string process (string& sass, converter& converter)
+	std::string process (std::string& sass, converter& converter)
 	{
 
 		// resulting string
-		string scss = "";
+		std::string scss = "";
 
 		// strip multi line comments
 		if (STRIP_COMMENT(converter))
@@ -451,7 +455,7 @@ namespace Sass
 		if (converter.end_of_file) pos_left = 0;
 
 		// maybe has only whitespace
-		if (pos_left == string::npos)
+		if (pos_left == std::string::npos)
 		{
 			// just add complete whitespace
 			converter.whitespace += sass + "\n";
@@ -461,10 +465,10 @@ namespace Sass
 		{
 
 			// extract and store indentation string
-			string indent = sass.substr(0, pos_left);
+			std::string indent = sass.substr(0, pos_left);
 
 			// check if current line starts a comment
-			string open = sass.substr(pos_left, 2);
+			std::string open = sass.substr(pos_left, 2);
 
 			// line has less or same indentation
 			// finalize previous open parser context
@@ -530,15 +534,15 @@ namespace Sass
 				// get postion of first whitespace char
 				size_t pos_wspace = sass.find_first_of(SASS2SCSS_FIND_WHITESPACE, pos_left);
 				// assertion check for valid result
-				if (pos_wspace != string::npos)
+				if (pos_wspace != std::string::npos)
 				{
 					// get the possible pseudo selector
-					string pseudo = sass.substr(pos_left, pos_wspace - pos_left);
+					std::string pseudo = sass.substr(pos_left, pos_wspace - pos_left);
 					// get position of the first real property value char
 					// pseudo selectors get this far, but have no actual value
 					size_t pos_value =  sass.find_first_not_of(SASS2SCSS_FIND_WHITESPACE, pos_wspace);
 					// assertion check for valid result
-					if (pos_value != string::npos)
+					if (pos_value != std::string::npos)
 					{
 						// only process if not (fallowed by a semicolon or is a pseudo selector)
 						if (!(sass.at(pos_value) == ':' || isPseudoSelector(pseudo)))
@@ -548,12 +552,12 @@ namespace Sass
 							// try to find a colon in the current line, but only ...
 							size_t pos_colon = sass.find_first_not_of(":", pos_left);
 							// assertion for valid result
-							if (pos_colon != string::npos)
+							if (pos_colon != std::string::npos)
 							{
 								// ... after the first word (skip begining colons)
 								pos_colon = sass.find_first_of(":", pos_colon);
 								// it is a selector if there was no colon found
-								converter.selector = pos_colon == string::npos;
+								converter.selector = pos_colon == std::string::npos;
 							}
 						}
 					}
@@ -589,7 +593,7 @@ namespace Sass
 						// get position of the last char on the line
 						size_t pos_end = sass.find_last_not_of(SASS2SCSS_FIND_WHITESPACE);
 						// assertion check for valid result
-						if (pos_end != string::npos)
+						if (pos_end != std::string::npos)
 						{
 							// add quotes around the full line after the import statement
 							sass = sass.substr(0, pos_quote) + "\"" + sass.substr(pos_quote, pos_end - pos_quote + 1) + "\"";
@@ -601,18 +605,19 @@ namespace Sass
 			else if (
 				sass.substr(pos_left, 7) != "@return" &&
 				sass.substr(pos_left, 7) != "@extend" &&
+				sass.substr(pos_left, 8) != "@include" &&
 				sass.substr(pos_left, 8) != "@content"
 			) {
 
 				// try to find a colon in the current line, but only ...
 				size_t pos_colon = sass.find_first_not_of(":", pos_left);
 				// assertion for valid result
-				if (pos_colon != string::npos)
+				if (pos_colon != std::string::npos)
 				{
 					// ... after the first word (skip begining colons)
 					pos_colon = sass.find_first_of(":", pos_colon);
 					// it is a selector if there was no colon found
-					converter.selector = pos_colon == string::npos;
+					converter.selector = pos_colon == std::string::npos;
 				}
 
 			}
@@ -702,11 +707,11 @@ namespace Sass
 			size_t pos_right = sass.find_last_not_of(SASS2SCSS_FIND_WHITESPACE);
 
 			// check for invalid result
-			if (pos_right != string::npos)
+			if (pos_right != std::string::npos)
 			{
 
 				// get the last meaningfull char
-				string close = sass.substr(pos_right, 1);
+				std::string close = sass.substr(pos_right, 1);
 
 				// check if next line should be concatenated (list mode)
 				converter.comma = IS_PARSING(converter) && close == ",";
@@ -718,7 +723,7 @@ namespace Sass
 				{
 
 					// get the last two chars from string
-					string close = sass.substr(pos_right - 1, 2);
+					std::string close = sass.substr(pos_right - 1, 2);
 					// update parser status for expicitly closed comment
 					if (close == "*/") converter.comment = "";
 
@@ -772,13 +777,13 @@ namespace Sass
 	}
 
 	// the main converter function for c++
-	char* sass2scss (const string sass, const int options)
+	char* sass2scss (const std::string& sass, const int options)
 	{
 
 		// local variables
-		string line;
-		string scss = "";
-		stringstream stream(sass);
+		std::string line;
+		std::string scss = "";
+		std::stringstream stream(sass);
 
 		// create converter variable
 		converter converter;
@@ -798,7 +803,7 @@ namespace Sass
 		{ scss += process(line, converter); }
 
 		// create mutable string
-		string closer = "";
+		std::string closer = "";
 		// set the end of file flag
 		converter.end_of_file = true;
 		// process to close all open blocks