sassc 0.0.9 → 0.0.10

data/ext/libsass/plugins.hpp

@@ -0,0 +1,56 @@
+#ifndef SASS_PLUGINS_H
+#define SASS_PLUGINS_H
+
+#include <string>
+#include <vector>
+#include "utf8_string.hpp"
+#include "sass_functions.h"
+
+#ifdef _WIN32
+
+  #define LOAD_LIB(var, path) HMODULE var = LoadLibraryW(UTF_8::convert_to_utf16(path).c_str())
+  #define LOAD_LIB_WCHR(var, path_wide_str) HMODULE var = LoadLibraryW(path_wide_str.c_str())
+  #define LOAD_LIB_FN(type, var, name) type var = (type) GetProcAddress(plugin, name)
+  #define CLOSE_LIB(var) FreeLibrary(var)
+
+  #ifndef dlerror
+  #define dlerror() 0
+  #endif
+
+#else
+
+  #define LOAD_LIB(var, path) void* var = dlopen(path.c_str(), RTLD_LAZY)
+  #define LOAD_LIB_FN(type, var, name) type var = (type) dlsym(plugin, name)
+  #define CLOSE_LIB(var) dlclose(var)
+
+#endif
+
+namespace Sass {
+
+  using namespace std;
+
+  class Plugins {
+
+    public: // c-tor
+      Plugins(void);
+      ~Plugins(void);
+
+    public: // methods
+      // load one specific plugin
+      bool load_plugin(const string& path);
+      // load all plugins from a directory
+      size_t load_plugins(const string& path);
+
+    public: // public accessors
+      // const vector<Sass_C_Import_Callback> get_importers(void) { return importers; };
+      const vector<Sass_C_Function_Callback> get_functions(void) { return functions; };
+
+    private: // private vars
+      // vector<Sass_C_Import_Callback> importers;
+      vector<Sass_C_Function_Callback> functions;
+
+  };
+
+}
+
+#endif

data/ext/libsass/position.cpp

@@ -0,0 +1,128 @@
+#include "position.hpp"
+
+namespace Sass {
+
+  using namespace std;
+
+  Offset::Offset(const char* string)
+  : line(0), column(0)
+  {
+    *this = inc(string, string + strlen(string));
+  }
+
+  Offset::Offset(const string& text)
+  : line(0), column(0)
+  {
+    *this = inc(text.c_str(), text.c_str() + text.size());
+  }
+
+  Offset::Offset(const size_t line, const size_t column)
+  : line(line), column(column) { }
+
+  // increase offset by given string (mostly called by lexer)
+  // increase line counter and count columns on the last line
+  Offset Offset::inc(const char* begin, const char* end) const
+  {
+    Offset offset(line, column);
+    while (begin < end && *begin) {
+      if (*begin == '\n') {
+        ++ offset.line;
+        offset.column = 0;
+      } else {
+        ++ offset.column;
+      }
+      ++begin;
+    }
+    return offset;
+  }
+
+  bool Offset::operator== (const Offset &pos) const
+  {
+    return line == pos.line && column == pos.column;
+  }
+
+  bool Offset::operator!= (const Offset &pos) const
+  {
+    return line != pos.line || column != pos.column;
+  }
+
+  void Offset::operator+= (const Offset &off)
+  {
+    *this = Offset(line + off.line, off.line > 0 ? off.column : off.column + column);
+  }
+
+  Offset Offset::operator+ (const Offset &off) const
+  {
+    return Offset(line + off.line, off.line > 0 ? off.column : off.column + column);
+  }
+
+  Position::Position(const size_t file)
+  : Offset(0, 0), file(file) { }
+
+  Position::Position(const size_t file, const Offset& offset)
+  : Offset(offset), file(file) { }
+
+  Position::Position(const size_t line, const size_t column)
+  : Offset(line, column), file(-1) { }
+
+  Position::Position(const size_t file, const size_t line, const size_t column)
+  : Offset(line, column), file(file) { }
+
+
+  ParserState::ParserState(string path)
+  : Position(-1, 0, 0), path(path), offset(0, 0), token() { }
+
+  ParserState::ParserState(string path, const size_t file)
+  : Position(file, 0, 0), path(path), offset(0, 0), token() { }
+
+  ParserState::ParserState(string path, Position position, Offset offset)
+  : Position(position), path(path), offset(offset), token() { }
+
+  ParserState::ParserState(string path, Token token, Position position, Offset offset)
+  : Position(position), path(path), offset(offset), token(token) { }
+
+  Position Position::inc(const char* begin, const char* end) const
+  {
+    Offset offset(line, column);
+    offset = offset.inc(begin, end);
+    return Position(file, offset);
+  }
+
+  bool Position::operator== (const Position &pos) const
+  {
+    return file == pos.file && line == pos.line && column == pos.column;
+  }
+
+  bool Position::operator!= (const Position &pos) const
+  {
+    return file == pos.file || line != pos.line || column != pos.column;
+  }
+
+  void Position::operator+= (const Offset &off)
+  {
+    *this = Position(file, line + off.line, off.line > 0 ? off.column : off.column + column);
+  }
+
+  const Position Position::operator+ (const Offset &off) const
+  {
+    return Position(file, line + off.line, off.line > 0 ? off.column : off.column + column);
+  }
+
+  /* not used anymore - remove?
+  std::ostream& operator<<(std::ostream& strm, const Offset& off)
+  {
+    if (off.line == string::npos) strm << "-1:"; else strm << off.line << ":";
+    if (off.column == string::npos) strm << "-1"; else strm << off.column;
+    return strm;
+  } */
+
+  /* not used anymore - remove?
+  std::ostream& operator<<(std::ostream& strm, const Position& pos)
+  {
+    if (pos.file != string::npos) strm << pos.file << ":";
+    if (pos.line == string::npos) strm << "-1:"; else strm << pos.line << ":";
+    if (pos.column == string::npos) strm << "-1"; else strm << pos.column;
+    return strm;
+  } */
+
+}

data/ext/libsass/position.hpp

@@ -1,22 +1,119 @@
-#define SASS_POSITION
+#ifndef SASS_POSITION_H
+#define SASS_POSITION_H
 
+#include <string>
+#include <cstring>
 #include <cstdlib>
+#include <sstream>
+#include <iostream>
 
 namespace Sass {
 
-  struct Position {
-    size_t file;
-    size_t line;
-    size_t column;
+  using namespace std;
 
-    Position()
-    : file(0), line(0), column(0) { }
+  class Offset {
 
-    Position(const size_t file, const size_t line, const size_t column)
-    : file(file), line(line), column(column) { }
+    public: // c-tor
+      Offset(const char* string);
+      Offset(const string& text);
+      Offset(const size_t line, const size_t column);
+
+      // return new position, incremented by the given string
+      Offset inc(const char* begin, const char* end) const;
+
+    public: // overload operators for position
+      void operator+= (const Offset &pos);
+      bool operator== (const Offset &pos) const;
+      bool operator!= (const Offset &pos) const;
+      Offset operator+ (const Offset &off) const;
+
+    public: // overload output stream operator
+      // friend ostream& operator<<(ostream& strm, const Offset& off);
+
+    public:
+      Offset off() { return *this; };
+
+    public:
+      size_t line;
+      size_t column;
+
+  };
+
+  class Position : public Offset {
+
+    public: // c-tor
+      Position(const size_t file); // line(0), column(0)
+      Position(const size_t file, const Offset& offset);
+      Position(const size_t line, const size_t column); // file(-1)
+      Position(const size_t file, const size_t line, const size_t column);
+
+    public: // overload operators for position
+      void operator+= (const Offset &off);
+      bool operator== (const Position &pos) const;
+      bool operator!= (const Position &pos) const;
+      const Position operator+ (const Offset &off) const;
+      // return new position, incremented by the given string
+      Position inc(const char* begin, const char* end) const;
+
+    public: // overload output stream operator
+      // friend ostream& operator<<(ostream& strm, const Position& pos);
+
+    public:
+      size_t file;
+
+  };
+
+  // Token type for representing lexed chunks of text
+  class Token {
+  public:
+    const char* prefix;
+    const char* begin;
+    const char* end;
+    const char* suffix;
+    Position start;
+    Position stop;
+
+    Token()
+    : prefix(0), begin(0), end(0), suffix(0), start(0), stop(0) { }
+    Token(const char* b, const char* e, const Position pos)
+    : prefix(b), begin(b), end(e), suffix(e), start(pos), stop(pos.inc(b, e)) { }
+    Token(const char* s, const Position pos)
+    : prefix(s), begin(s), end(s + strlen(s)), suffix(end), start(pos), stop(pos.inc(s, s + strlen(s))) { }
+    Token(const char* p, const char* b, const char* e, const char* s, const Position pos)
+    : prefix(p), begin(b), end(e), suffix(s), start(pos), stop(pos.inc(b, e)) { }
+
+    size_t length()    const { return end - begin; }
+    string ws_before() const { return string(prefix, begin); }
+    string to_string() const { return string(begin, end); }
+    string ws_after() const { return string(end, suffix); }
+
+    // string unquote() const;
+
+    operator bool()   { return begin && end && begin >= end; }
+    operator string() { return to_string(); }
+
+    bool operator==(Token t)  { return to_string() == t.to_string(); }
+  };
+
+  class ParserState : public Position {
+
+    public: // c-tor
+      ParserState(string path);
+      ParserState(string path, const size_t file);
+      ParserState(string path, Position position, Offset offset = Offset(0, 0));
+      ParserState(string path, Token token, Position position, Offset offset = Offset(0, 0));
+
+    public: // down casts
+      Offset off() { return *this; };
+      Position pos() { return *this; };
+
+    public:
+      string path;
+      Offset offset;
+      Token token;
 
-    Position(const size_t line, const size_t column)
-    : file(0), line(line), column(column) { }
   };
 
 }
+
+#endif

data/ext/libsass/prelexer.cpp

@@ -2,9 +2,10 @@
 #include <cstddef>
 #include <iostream>
 #include <iomanip>
-#include "constants.hpp"
-#include "prelexer.hpp"
 #include "util.hpp"
+#include "position.hpp"
+#include "prelexer.hpp"
+#include "constants.hpp"
 
 
 namespace Sass {
@@ -13,16 +14,20 @@ namespace Sass {
   namespace Prelexer {
     using std::ptrdiff_t;
     // Matches zero characters (always succeeds without consuming input).
+    /* not used anymore - remove?
     const char* epsilon(char *src) {
       return src;
-    }
+    }*/
     // Matches the empty string.
+    /* not used anymore - remove?
     const char* empty(char *src) {
       return *src ? 0 : src;
-    }
+    }*/
 
     // Match any single character.
     const char* any_char(const char* src) { return *src ? src+1 : src; }
+    // Match word boundary (look ahead)
+    const char* word_boundary(const char* src) { return !*src || isspace(*src) || ispunct(*src) || !Sass::Util::isAscii(*src) ? src : 0 ; }
 
     // Match a single character satisfying the ctype predicates.
     const char* space(const char* src) { return std::isspace(*src) ? src+1 : 0; }
@@ -54,9 +59,18 @@ namespace Sass {
     }
     // Match either comment.
     const char* comment(const char* src) {
-      return alternatives<block_comment, line_comment>(src);
+      return line_comment(src);
+    }
+
+    const char* wspaces(const char* src) {
+      return
+      alternatives<
+        exactly<' '>,
+        exactly<'\t'>
+      >(src);
     }
 
+    /* not used anymore - remove?
     const char* newline(const char* src) {
       return
       alternatives<
@@ -65,79 +79,31 @@ namespace Sass {
         exactly<'\r'>,
         exactly<'\f'>
       >(src);
-    }
+    }*/
 
+    /* not used anymore - remove?
     const char* whitespace(const char* src) {
-      return
-      alternatives<
-        newline,
-        exactly<' '>,
-        exactly<'\t'>
-      >(src);
-    }
+      return spaces(src);
+    }*/
 
+    /* not used anymore - remove?
     const char* escape(const char* src) {
       return
       sequence<
         exactly<'\\'>,
         any_char
       >(src);
-    }
-
-    // Match double- and single-quoted strings.
-    const char* double_quoted_string(const char* src) {
-      src = exactly<'"'>(src);
-      if (!src) return 0;
-      const char* p;
-      while (1) {
-        if (!*src) return 0;
-        if((p = escape(src))) {
-          src = p;
-          continue;
-        }
-        else if((p = exactly<'"'>(src))) {
-          return p;
-        }
-        else {
-          ++src;
-        }
-      }
-      return 0;
-    }
-    const char* single_quoted_string(const char* src) {
-      src = exactly<'\''>(src);
-      if (!src) return 0;
-      const char* p;
-      while (1) {
-        if (!*src) return 0;
-        if((p = escape(src))) {
-          src = p;
-          continue;
-        }
-        else if((p = exactly<'\''>(src))) {
-          return p;
-        }
-        else {
-          ++src;
-        }
-      }
-      return 0;
-    }
-    const char* string_constant(const char* src) {
-      return alternatives<double_quoted_string, single_quoted_string>(src);
-    }
-    // Match interpolants.
+    }*/
 
 
-    const char* interpolant(const char* src) {
-      return delimited_by<hash_lbrace, rbrace, false>(src);
-    }
-
     // Whitespace handling.
     const char* optional_spaces(const char* src) { return optional<spaces>(src); }
-    const char* optional_comment(const char* src) { return optional<comment>(src); }
+    // const char* optional_comment(const char* src) { return optional<comment>(src); }
+    const char* optional_spaces_and_comments(const char* src) {
+      return zero_plus< alternatives<spaces, line_comment> >(src);
+    }
     const char* spaces_and_comments(const char* src) {
-      return zero_plus< alternatives<spaces, comment> >(src);
+      return one_plus< alternatives<spaces, line_comment> >(src);
     }
     const char* no_spaces(const char* src) {
       return negate< spaces >(src);
@@ -165,6 +131,7 @@ namespace Sass {
     }
 
     // Match CSS selectors.
+    /* not used anymore - remove?
     const char* sel_ident(const char* src) {
       return sequence< optional< alternatives< exactly<'-'>, exactly<'|'> > >,
                        alternatives< alpha, exactly<'_'>, backslash_something, exactly<'|'> >,
@@ -173,13 +140,25 @@ namespace Sass {
                                                 exactly<'_'>,
                                                 exactly<'|'>,
                                                 backslash_something > > >(src);
-    }
+    }*/
 
     // Match CSS css variables.
     const char* custom_property_name(const char* src) {
       return sequence< exactly<'-'>, exactly<'-'>, identifier >(src);
     }
 
+    // Match number prefix ([\+\-]+)
+    const char* number_prefix(const char* src) {
+      return alternatives <
+        exactly < '+' >,
+        sequence <
+          exactly < '-' >,
+          optional_spaces_and_comments,
+          exactly< '-' >
+        >
+      >(src);
+    }
+
     // Match interpolant schemas
     const char* identifier_schema(const char* src) {
       // follows this pattern: (x*ix*)+ ... well, not quite
@@ -188,17 +167,71 @@ namespace Sass {
                                  zero_plus< alternatives< identifier, number, exactly<'-'> > > > >,
                        negate< exactly<'%'> > >(src);
     }
+
+    // interpolants can be recursive/nested
+    const char* interpolant(const char* src) {
+      return recursive_scopes< exactly<hash_lbrace>, exactly<rbrace> >(src);
+    }
+
+    // $re_squote = /'(?:$re_itplnt|\\.|[^'])*'/
+    const char* single_quoted_string(const char* src) {
+      // match a single quoted string, while skipping interpolants
+      return sequence <
+        exactly <'\''>,
+        zero_plus <
+          alternatives <
+            // skip all escaped chars first
+            backslash_something,
+            // skip interpolants
+            interpolant,
+            // skip non delimiters
+            any_char_except < '\'' >
+          >
+        >,
+        exactly <'\''>
+      >(src);
+    }
+
+    // $re_dquote = /"(?:$re_itp|\\.|[^"])*"/
+    const char* double_quoted_string(const char* src) {
+      // match a single quoted string, while skipping interpolants
+      return sequence <
+        exactly <'"'>,
+        zero_plus <
+          alternatives <
+            // skip all escaped chars first
+            backslash_something,
+            // skip interpolants
+            interpolant,
+            // skip non delimiters
+            any_char_except < '"' >
+          >
+        >,
+        exactly <'"'>
+      >(src);
+    }
+
+    // $re_quoted = /(?:$re_squote|$re_dquote)/
+    const char* quoted_string(const char* src) {
+      // match a quoted string, while skipping interpolants
+      return alternatives<
+        single_quoted_string,
+        double_quoted_string
+      >(src);
+    }
+
     const char* value_schema(const char* src) {
       // follows this pattern: ([xyz]*i[xyz]*)+
-      return one_plus< sequence< zero_plus< alternatives< identifier, percentage, dimension, hex, number, string_constant > >,
+      return one_plus< sequence< zero_plus< alternatives< identifier, percentage, dimension, hex, number, quoted_string > >,
                                  interpolant,
-                                 zero_plus< alternatives< identifier, percentage, dimension, hex, number, string_constant, exactly<'%'> > > > >(src);
+                                 zero_plus< alternatives< identifier, percentage, dimension, hex, number, quoted_string, exactly<'%'> > > > >(src);
     }
+    /* not used anymore - remove?
     const char* filename_schema(const char* src) {
       return one_plus< sequence< zero_plus< alternatives< identifier, number, exactly<'.'>, exactly<'/'> > >,
                                  interpolant,
                                  zero_plus< alternatives< identifier, number, exactly<'.'>, exactly<'/'> > > > >(src);
-    }
+    }*/
 
     const char* filename(const char* src) {
       return one_plus< alternatives< identifier, number, exactly<'.'> > >(src);
@@ -213,6 +246,18 @@ namespace Sass {
       return exactly<import_kwd>(src);
     }
 
+    const char* at_root(const char* src) {
+      return exactly<at_root_kwd>(src);
+    }
+
+    const char* with_directive(const char* src) {
+      return exactly<with_kwd>(src);
+    }
+
+    const char* without_directive(const char* src) {
+      return exactly<without_kwd>(src);
+    }
+
     const char* media(const char* src) {
       return exactly<media_kwd>(src);
     }
@@ -221,17 +266,20 @@ namespace Sass {
       return exactly<supports_kwd>(src);
     }
 
+    /* not used anymore - remove?
     const char* keyframes(const char* src) {
       return sequence< exactly<'@'>, optional< vendor_prefix >, exactly< keyframes_kwd > >(src);
-    }
+    } */
 
+    /* not used anymore - remove?
     const char* vendor_prefix(const char* src) {
       return alternatives< exactly< vendor_opera_kwd >, exactly< vendor_webkit_kwd >, exactly< vendor_mozilla_kwd >, exactly< vendor_ms_kwd >, exactly< vendor_khtml_kwd > >(src);
-    }
+    } */
 
+    /* not used anymore - remove?
     const char* keyf(const char* src) {
       return one_plus< alternatives< to, from, percentage > >(src);
-    }
+    } */
 
     const char* mixin(const char* src) {
       return exactly<mixin_kwd>(src);
@@ -254,7 +302,7 @@ namespace Sass {
     }
 
     const char* extend(const char* src) {
-      return exactly<extend_kwd>(src);
+      return sequence < exactly<extend_kwd>, word_boundary >(src);
     }
 
 
@@ -267,7 +315,7 @@ namespace Sass {
     }
     const char* elseif_directive(const char* src) {
       return sequence< else_directive,
-                       spaces_and_comments,
+                       optional_spaces_and_comments,
                        exactly< if_after_else_kwd > >(src);
     }
 
@@ -318,9 +366,10 @@ namespace Sass {
       return exactly<debug_kwd>(src);
     }
 
+    /* not used anymore - remove?
     const char* directive(const char* src) {
       return sequence< exactly<'@'>, identifier >(src);
-    }
+    } */
 
     const char* null(const char* src) {
       return exactly<null_kwd>(src);
@@ -389,11 +438,12 @@ namespace Sass {
       return sequence< number, exactly<'%'> >(src);
     }
 
+    /* not used anymore - remove?
     const char* em(const char* src) {
       return sequence< number, exactly<em_kwd> >(src);
-    }
+    } */
     const char* dimension(const char* src) {
-      return sequence<number, identifier>(src);
+      return sequence<number, one_plus< alpha > >(src);
     }
     const char* hex(const char* src) {
       const char* p = sequence< exactly<'#'>, one_plus<xdigit> >(src);
@@ -405,54 +455,63 @@ namespace Sass {
       ptrdiff_t len = p - src;
       return (len != 4 && len != 7 && len != 9) ? 0 : p;
     }
+    const char* hex0(const char* src) {
+      const char* p = sequence< exactly<'0'>, exactly<'x'>, one_plus<xdigit> >(src);
+      ptrdiff_t len = p - src;
+      return (len != 5 && len != 8) ? 0 : p;
+    }
 
+    /* no longer used - remove?
     const char* rgb_prefix(const char* src) {
       return exactly<rgb_kwd>(src);
-    }
+    }*/
     // Match CSS uri specifiers.
 
     const char* uri_prefix(const char* src) {
       return exactly<url_kwd>(src);
     }
     // TODO: rename the following two functions
+    /* no longer used - remove?
     const char* uri(const char* src) {
       return sequence< exactly<url_kwd>,
                        optional<spaces>,
-                       string_constant,
+                       quoted_string,
                        optional<spaces>,
                        exactly<')'> >(src);
-    }
+    }*/
+    /* no longer used - remove?
     const char* url_value(const char* src) {
       return sequence< optional< sequence< identifier, exactly<':'> > >, // optional protocol
                        one_plus< sequence< zero_plus< exactly<'/'> >, filename > >, // one or more folders and/or trailing filename
                        optional< exactly<'/'> > >(src);
-    }
+    }*/
+    /* no longer used - remove?
     const char* url_schema(const char* src) {
       return sequence< optional< sequence< identifier, exactly<':'> > >, // optional protocol
                        filename_schema >(src); // optional trailing slash
-    }
+    }*/
     // Match CSS "!important" keyword.
     const char* important(const char* src) {
       return sequence< exactly<'!'>,
-                       spaces_and_comments,
+                       optional_spaces_and_comments,
                        exactly<important_kwd> >(src);
     }
     // Match CSS "!optional" keyword.
     const char* optional(const char* src) {
       return sequence< exactly<'!'>,
-      spaces_and_comments,
+      optional_spaces_and_comments,
       exactly<optional_kwd> >(src);
     }
     // Match Sass "!default" keyword.
     const char* default_flag(const char* src) {
       return sequence< exactly<'!'>,
-                       spaces_and_comments,
+                       optional_spaces_and_comments,
                        exactly<default_kwd> >(src);
     }
     // Match Sass "!global" keyword.
     const char* global_flag(const char* src) {
       return sequence< exactly<'!'>,
-                       spaces_and_comments,
+                       optional_spaces_and_comments,
                        exactly<global_kwd> >(src);
     }
     // Match CSS pseudo-class/element prefixes.
@@ -485,6 +544,7 @@ namespace Sass {
     const char* suffix_match(const char* src) { return exactly<dollar_equal>(src); }
     const char* substring_match(const char* src) { return exactly<star_equal>(src); }
     // Match CSS combinators.
+    /* not used anymore - remove?
     const char* adjacent_to(const char* src) {
       return sequence< optional_spaces, exactly<'+'> >(src);
     }
@@ -496,7 +556,7 @@ namespace Sass {
     }
     const char* ancestor_of(const char* src) {
       return sequence< spaces, negate< exactly<'{'> > >(src);
-    }
+    }*/
 
     // Match SCSS variable names.
     const char* variable(const char* src) {
@@ -550,29 +610,28 @@ namespace Sass {
         > >,
         zero_plus < sequence<
           exactly<'('>,
-          spaces_and_comments,
+          optional_spaces_and_comments,
           optional < sequence<
             alternatives< variable, identifier_schema, identifier >,
-            spaces_and_comments,
+            optional_spaces_and_comments,
             exactly<'='>,
-            spaces_and_comments,
-            alternatives< variable, identifier_schema, identifier, string_constant, number, hexa >,
+            optional_spaces_and_comments,
+            alternatives< variable, identifier_schema, identifier, quoted_string, number, hexa >,
             zero_plus< sequence<
-              spaces_and_comments,
+              optional_spaces_and_comments,
               exactly<','>,
-              spaces_and_comments,
+              optional_spaces_and_comments,
               sequence<
                 alternatives< variable, identifier_schema, identifier >,
-                spaces_and_comments,
+                optional_spaces_and_comments,
                 exactly<'='>,
-                spaces_and_comments,
-                alternatives< variable, identifier_schema, identifier, string_constant, number, hexa >
+                optional_spaces_and_comments,
+                alternatives< variable, identifier_schema, identifier, quoted_string, number, hexa >
               >
             > >
           > >,
-          spaces_and_comments,
-          exactly<')'>,
-          spaces_and_comments
+          optional_spaces_and_comments,
+          exactly<')'>
         > >
       >(src);
     }
@@ -584,22 +643,29 @@ namespace Sass {
     }
 
     // const char* ie_args(const char* src) {
-    //   return sequence< alternatives< ie_keyword_arg, value_schema, string_constant, interpolant, number, identifier, delimited_by< '(', ')', true> >,
-    //                    zero_plus< sequence< spaces_and_comments, exactly<','>, spaces_and_comments, alternatives< ie_keyword_arg, value_schema, string_constant, interpolant, number, identifier, delimited_by<'(', ')', true> > > > >(src);
+    //   return sequence< alternatives< ie_keyword_arg, value_schema, quoted_string, interpolant, number, identifier, delimited_by< '(', ')', true> >,
+    //                    zero_plus< sequence< optional_spaces_and_comments, exactly<','>, optional_spaces_and_comments, alternatives< ie_keyword_arg, value_schema, quoted_string, interpolant, number, identifier, delimited_by<'(', ')', true> > > > >(src);
     // }
 
     const char* ie_keyword_arg(const char* src) {
-      return sequence< alternatives< variable, identifier_schema, identifier >, spaces_and_comments, exactly<'='>, spaces_and_comments, alternatives< variable, identifier_schema, identifier, string_constant, number, hexa > >(src);
+      return sequence<
+        alternatives< variable, identifier_schema, identifier >,
+        optional_spaces_and_comments,
+        exactly<'='>,
+        optional_spaces_and_comments,
+        alternatives< variable, identifier_schema, identifier, quoted_string, number, hexa >
+      >(src);
     }
 
     // Path matching functions.
+    /* not used anymore - remove?
     const char* folder(const char* src) {
       return sequence< zero_plus< any_char_except<'/'> >,
                        exactly<'/'> >(src);
     }
     const char* folders(const char* src) {
       return zero_plus< folder >(src);
-    }
+    }*/
 
     const char* chunk(const char* src) {
       char inside_str = 0;
@@ -629,26 +695,30 @@ namespace Sass {
     }
 
     // follow the CSS spec more closely and see if this helps us scan URLs correctly
+    /* not used anymore - remove?
     const char* NL(const char* src) {
       return alternatives< exactly<'\n'>,
                            sequence< exactly<'\r'>, exactly<'\n'> >,
                            exactly<'\r'>,
                            exactly<'\f'> >(src);
-    }
+    }*/
 
+    /* not used anymore - remove?
     const char* H(const char* src) {
       return std::isxdigit(*src) ? src+1 : 0;
-    }
+    }*/
 
+    /* not used anymore - remove?
     const char* unicode(const char* src) {
       return sequence< exactly<'\\'>,
                        between<H, 1, 6>,
                        optional< class_char<url_space_chars> > >(src);
-    }
+    }*/
 
+    /* not used anymore - remove?
     const char* ESCAPE(const char* src) {
       return alternatives< unicode, class_char<escape_chars> >(src);
-    }
+    }*/
 
     const char* url(const char* src) {
       return chunk(src);
@@ -656,8 +726,8 @@ namespace Sass {
 
     const char* static_string(const char* src) {
       const char* pos = src;
-      const char * s = string_constant(pos);
-      Token t(pos, s);
+      const char * s = quoted_string(pos);
+      Token t(pos, s, Position(0, 0));
       const unsigned int p = count_interval< interpolant >(t.begin, t.end);
       return (p == 0) ? t.end : 0;
     }
@@ -665,6 +735,7 @@ namespace Sass {
     const char* static_component(const char* src) {
       return alternatives< identifier,
                            static_string,
+                           percentage,
                            hex,
                            number,
                            sequence< exactly<'!'>, exactly<important_kwd> >
@@ -675,8 +746,11 @@ namespace Sass {
       return sequence< static_component,
                        zero_plus < sequence<
                                    alternatives<
-                                     sequence< optional_spaces, exactly<'/'>, optional_spaces >,
-                                     sequence< optional_spaces, exactly<','>, optional_spaces >,
+                                     sequence< optional_spaces, alternatives<
+                                       exactly < '/' >,
+                                       exactly < ',' >,
+                                       exactly < ' ' >
+                                     >, optional_spaces >,
                                      spaces
                                    >,
                                    static_component