sassc 1.7.1 → 1.8.0.pre1

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

@@ -1,9 +1,8 @@
 #ifndef SASS_PARSER_H
 #define SASS_PARSER_H
 
-#include <map>
+#include <string>
 #include <vector>
-#include <iostream>
 
 #include "ast.hpp"
 #include "position.hpp"
@@ -11,30 +10,28 @@
 #include "position.hpp"
 #include "prelexer.hpp"
 
-struct Selector_Lookahead {
+struct Lookahead {
   const char* found;
+  const char* error;
+  const char* position;
+  bool parsable;
   bool has_interpolants;
 };
 
 namespace Sass {
-  using std::string;
-  using std::vector;
-  using std::map;
-  using namespace Prelexer;
 
   class Parser : public ParserState {
   private:
-    void add_single_file (Import* imp, string import_path);
-    void import_single_file (Import* imp, string import_path);
+    void add_single_file (Import* imp, std::string import_path);
+    void import_single_file (Import* imp, std::string import_path);
   public:
-    class AST_Node;
 
     enum Syntactic_Context { nothing, mixin_def, function_def };
-    bool do_import(const string& import_path, Import* imp, vector<Sass_Importer_Entry> importers, bool only_one = true);
+    bool do_import(const std::string& import_path, Import* imp, std::vector<Sass_Importer_Entry> importers, bool only_one = true);
 
     Context& ctx;
-    vector<Block*> block_stack;
-    vector<Syntactic_Context> stack;
+    std::vector<Block*> block_stack;
+    std::vector<Syntactic_Context> stack;
     Media_Block* last_media_block;
     const char* source;
     const char* position;
@@ -53,7 +50,7 @@ namespace Sass {
       source(0), position(0), end(0), before_token(pstate), after_token(pstate), pstate(pstate), indentation(0)
     { in_at_root = false; stack.push_back(nothing); }
 
-    // static Parser from_string(const string& src, Context& ctx, ParserState pstate = ParserState("[STRING]"));
+    // static Parser from_string(const std::string& src, Context& ctx, ParserState pstate = ParserState("[STRING]"));
     static Parser from_c_str(const char* src, Context& ctx, ParserState pstate = ParserState("[CSTRING]"));
     static Parser from_c_str(const char* beg, const char* end, Context& ctx, ParserState pstate = ParserState("[CSTRING]"));
     static Parser from_token(Token t, Context& ctx, ParserState pstate = ParserState("[TOKEN]"));
@@ -76,9 +73,10 @@ namespace Sass {
     bool peek_newline(const char* start = 0);
 
     // skip over spaces, tabs and line comments
-    template <prelexer mx>
+    template <Prelexer::prelexer mx>
     const char* sneak(const char* start = 0)
     {
+      using namespace Prelexer;
 
       // maybe use optional start position from arguments?
       const char* it_position = start ? start : position;
@@ -104,7 +102,7 @@ namespace Sass {
 
     // peek will only skip over space, tabs and line comment
     // return the position where the lexer match will occur
-    template <prelexer mx>
+    template <Prelexer::prelexer mx>
     const char* peek(const char* start = 0)
     {
 
@@ -123,8 +121,8 @@ namespace Sass {
     // we do not support start arg, since we manipulate
     // sourcemap offset and we modify the position pointer!
     // lex will only skip over space, tabs and line comment
-    template <prelexer mx>
-    const char* lex(bool lazy = true)
+    template <Prelexer::prelexer mx>
+    const char* lex(bool lazy = true, bool force = false)
     {
 
       // position considered before lexed token
@@ -139,12 +137,15 @@ namespace Sass {
       // now call matcher to get position after token
       const char* it_after_token = mx(it_before_token);
 
-      // assertion that we got a valid match
-      if (it_after_token == 0) return 0;
-      // assertion that we actually lexed something
-      if (it_after_token == it_before_token) return 0;
+      // maybe we want to update the parser state anyway?
+      if (force == false) {
+        // assertion that we got a valid match
+        if (it_after_token == 0) return 0;
+        // assertion that we actually lexed something
+        if (it_after_token == it_before_token) return 0;
+      }
 
-      // create new lexed token object (holds all parse result information)
+      // create new lexed token object (holds the parse results)
       lexed = Token(position, it_before_token, it_after_token);
 
       // advance position (add whitespace before current token)
@@ -164,28 +165,39 @@ namespace Sass {
     // lex_css skips over space, tabs, line and block comment
     // all block comments will be consumed and thrown away
     // source-map position will point to token after the comment
-    template <prelexer mx>
+    template <Prelexer::prelexer mx>
     const char* lex_css()
     {
       // copy old token
       Token prev = lexed;
+      // store previous pointer
+      const char* oldpos = position;
+      Position bt = before_token;
+      Position at = after_token;
+      ParserState op = pstate;
       // throw away comments
       // update srcmap position
-      lex < css_comments >();
+      lex < Prelexer::css_comments >();
       // now lex a new token
       const char* pos = lex< mx >();
-      // maybe restore prev token
-      if (pos == 0) lexed = prev;
+      // maybe restore prev state
+      if (pos == 0) {
+        pstate = op;
+        lexed = prev;
+        position = oldpos;
+        after_token = at;
+        before_token = bt;
+      }
       // return match
       return pos;
     }
 
     // all block comments will be skipped and thrown away
-    template <prelexer mx>
+    template <Prelexer::prelexer mx>
     const char* peek_css(const char* start = 0)
     {
       // now peek a token (skip comments first)
-      return peek< mx >(peek < css_comments >(start));
+      return peek< mx >(peek < Prelexer::css_comments >(start));
     }
 
 #ifdef __clang__
@@ -194,34 +206,38 @@ namespace Sass {
 
 #endif
 
-    void error(string msg, Position pos);
+    void error(std::string msg, Position pos);
     // generate message with given and expected sample
     // text before and in the middle are configurable
-    void css_error(const string& msg,
-                   const string& prefix = " after ",
-                   const string& middle = ", was: ");
+    void css_error(const std::string& msg,
+                   const std::string& prefix = " after ",
+                   const std::string& middle = ", was: ");
     void read_bom();
 
     Block* parse();
     Import* parse_import();
-    Definition* parse_definition();
+    Definition* parse_definition(Definition::Type which_type);
     Parameters* parse_parameters();
     Parameter* parse_parameter();
-    Mixin_Call* parse_mixin_call();
-    Arguments* parse_arguments(bool has_url = false);
-    Argument* parse_argument(bool has_url = false);
+    Mixin_Call* parse_include_directive();
+    Arguments* parse_arguments();
+    Argument* parse_argument();
     Assignment* parse_assignment();
     // Propset* parse_propset();
-    Ruleset* parse_ruleset(Selector_Lookahead lookahead);
+    Ruleset* parse_ruleset(Lookahead lookahead, bool is_root = false);
     Selector_Schema* parse_selector_schema(const char* end_of_selector);
-    Selector_List* parse_selector_group();
-    Complex_Selector* parse_selector_combination();
-    Compound_Selector* parse_simple_selector_sequence();
+    Selector_List* parse_selector_list(bool at_root = false);
+    Complex_Selector* parse_complex_selector(bool in_root = true);
+    Compound_Selector* parse_compound_selector();
     Simple_Selector* parse_simple_selector();
     Wrapped_Selector* parse_negated_selector();
     Simple_Selector* parse_pseudo_selector();
     Attribute_Selector* parse_attribute_selector();
-    Block* parse_block();
+    Block* parse_block(bool is_root = false);
+    Block* parse_css_block(bool is_root = false);
+    bool parse_block_nodes(bool is_root = false);
+    bool parse_block_node(bool is_root = false);
+
     bool parse_number_prefix();
     Declaration* parse_declaration();
     Expression* parse_map_value();
@@ -233,38 +249,42 @@ namespace Sass {
     Expression* parse_conjunction();
     Expression* parse_relation();
     Expression* parse_expression();
-    Expression* parse_term();
+    Expression* parse_operators();
     Expression* parse_factor();
+    Expression* parse_value2();
     Expression* parse_value();
     Function_Call* parse_calc_function();
     Function_Call* parse_function_call();
     Function_Call_Schema* parse_function_call_schema();
+    String* parse_url_function_string();
     String* parse_interpolated_chunk(Token, bool constant = false);
     String* parse_string();
     String_Constant* parse_static_expression();
+    // String_Constant* parse_static_property();
     String_Constant* parse_static_value();
     String* parse_ie_property();
     String* parse_ie_keyword_arg();
     String_Schema* parse_value_schema(const char* stop);
-    Expression* parse_operators(Expression* factor);
     String* parse_identifier_schema();
     // String_Schema* parse_url_schema();
     If* parse_if_directive(bool else_if = false);
     For* parse_for_directive();
     Each* parse_each_directive();
     While* parse_while_directive();
+    Return* parse_return_directive();
+    Content* parse_content_directive();
+    void parse_charset_directive();
     Media_Block* parse_media_block();
     List* parse_media_queries();
     Media_Query* parse_media_query();
     Media_Query_Expression* parse_media_expression();
-    Feature_Block* parse_feature_block();
-    Feature_Query* parse_feature_queries();
-    Feature_Query_Condition* parse_feature_query();
-    Feature_Query_Condition* parse_feature_query_in_parens();
-    Feature_Query_Condition* parse_supports_negation();
-    Feature_Query_Condition* parse_supports_conjunction();
-    Feature_Query_Condition* parse_supports_disjunction();
-    Feature_Query_Condition* parse_supports_declaration();
+    Supports_Block* parse_supports_directive();
+    Supports_Condition* parse_supports_condition();
+    Supports_Condition* parse_supports_negation();
+    Supports_Condition* parse_supports_operator();
+    Supports_Condition* parse_supports_interpolation();
+    Supports_Condition* parse_supports_declaration();
+    Supports_Condition* parse_supports_condition_in_parens();
     At_Root_Block* parse_at_root_block();
     At_Root_Expression* parse_at_root_expression();
     At_Rule* parse_at_rule();
@@ -272,17 +292,21 @@ namespace Sass {
     Error* parse_error();
     Debug* parse_debug();
 
-    void parse_block_comments(Block* block);
+    // these will throw errors
+    Token lex_variable();
+    Token lex_identifier();
+
+    void parse_block_comments();
 
-    Selector_Lookahead lookahead_for_value(const char* start = 0);
-    Selector_Lookahead lookahead_for_selector(const char* start = 0);
-    Selector_Lookahead lookahead_for_extension_target(const char* start = 0);
+    Lookahead lookahead_for_value(const char* start = 0);
+    Lookahead lookahead_for_selector(const char* start = 0);
+    Lookahead lookahead_for_include(const char* start = 0);
 
-    Expression* fold_operands(Expression* base, vector<Expression*>& operands, Binary_Expression::Type op);
-    Expression* fold_operands(Expression* base, vector<Expression*>& operands, vector<Binary_Expression::Type>& ops);
+    Expression* fold_operands(Expression* base, std::vector<Expression*>& operands, Sass_OP op);
+    Expression* fold_operands(Expression* base, std::vector<Expression*>& operands, std::vector<Sass_OP>& ops);
 
-    void throw_syntax_error(string message, size_t ln = 0);
-    void throw_read_error(string message, size_t ln = 0);
+    void throw_syntax_error(std::string message, size_t ln = 0);
+    void throw_read_error(std::string message, size_t ln = 0);
   };
 
   size_t check_bom_chars(const char* src, const char *end, const unsigned char* bom, size_t len);

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

@@ -4,14 +4,12 @@
 #include <string>
 #include <vector>
 #include <sstream>
-#include <iostream>
 
-using namespace std;
 
 template<typename T>
-string vector_to_string(vector<T> v)
+std::string vector_to_string(std::vector<T> v)
 {
-  stringstream buffer;
+  std::stringstream buffer;
   buffer << "[";
 
   if (!v.empty())
@@ -32,35 +30,34 @@ string vector_to_string(vector<T> v)
 
 namespace Sass {
 
-  using namespace std;
 
   template<typename T>
-  vector<vector<T> > paths(vector<vector<T> > strata, size_t from_end = 0)
+  std::vector<std::vector<T> > paths(std::vector<std::vector<T> > strata, size_t from_end = 0)
   {
     if (strata.empty()) {
-      return vector<vector<T> >();
+      return std::vector<std::vector<T> >();
     }
 
     size_t end = strata.size() - from_end;
     if (end <= 1) {
-      vector<vector<T> > starting_points;
+      std::vector<std::vector<T> > starting_points;
       starting_points.reserve(strata[0].size());
       for (size_t i = 0, S = strata[0].size(); i < S; ++i) {
-        vector<T> starting_point;
+        std::vector<T> starting_point;
         starting_point.push_back(strata[0][i]);
         starting_points.push_back(starting_point);
       }
       return starting_points;
     }
 
-    vector<vector<T> > up_to_here = paths(strata, from_end + 1);
-    vector<T>          here       = strata[end-1];
+    std::vector<std::vector<T> > up_to_here = paths(strata, from_end + 1);
+    std::vector<T>          here       = strata[end-1];
 
-    vector<vector<T> > branches;
+    std::vector<std::vector<T> > branches;
     branches.reserve(up_to_here.size() * here.size());
     for (size_t i = 0, S1 = up_to_here.size(); i < S1; ++i) {
       for (size_t j = 0, S2 = here.size(); j < S2; ++j) {
-        vector<T> branch = up_to_here[i];
+        std::vector<T> branch = up_to_here[i];
         branch.push_back(here[j]);
         branches.push_back(branch);
       }

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

@@ -11,8 +11,6 @@
 #include "output.hpp"
 #include "plugins.hpp"
 
-#define npos string::npos
-
 namespace Sass {
 
   Plugins::Plugins(void) { }
@@ -30,18 +28,18 @@ namespace Sass {
     if (!strcmp(our_version, "[na]")) return false;
 
     // find the position of the second dot
-    size_t pos = string(our_version).find('.', 0);
-    if (pos != npos) pos = string(our_version).find('.', pos + 1);
+    size_t pos = std::string(our_version).find('.', 0);
+    if (pos != std::string::npos) pos = std::string(our_version).find('.', pos + 1);
 
     // if we do not have two dots we fallback to compare complete string
-    if (pos == npos) { return strcmp(their_version, our_version) ? 0 : 1; }
+    if (pos == std::string::npos) { return strcmp(their_version, our_version) ? 0 : 1; }
     // otherwise only compare up to the second dot (major versions)
     else { return strncmp(their_version, our_version, pos) ? 0 : 1; }
 
   }
 
   // load one specific plugin
-  bool Plugins::load_plugin (const string& path)
+  bool Plugins::load_plugin (const std::string& path)
   {
 
     typedef const char* (*__plugin_version__)(void);
@@ -79,23 +77,23 @@ namespace Sass {
       else
       {
         // print debug message to stderr (should not happen)
-        cerr << "failed loading 'libsass_support' in <" << path << ">" << endl;
-        if (const char* dlsym_error = dlerror()) cerr << dlsym_error << endl;
+        std::cerr << "failed loading 'libsass_support' in <" << path << ">" << std::endl;
+        if (const char* dlsym_error = dlerror()) std::cerr << dlsym_error << std::endl;
         CLOSE_LIB(plugin);
       }
     }
     else
     {
       // print debug message to stderr (should not happen)
-      cerr << "failed loading plugin <" << path << ">" << endl;
-      if (const char* dlopen_error = dlerror()) cerr << dlopen_error << endl;
+      std::cerr << "failed loading plugin <" << path << ">" << std::endl;
+      if (const char* dlopen_error = dlerror()) std::cerr << dlopen_error << std::endl;
     }
 
     return false;
 
   }
 
-  size_t Plugins::load_plugins(const string& path)
+  size_t Plugins::load_plugins(const std::string& path)
   {
 
     // count plugins
@@ -109,9 +107,9 @@ namespace Sass {
         // use wchar (utf16)
         WIN32_FIND_DATAW data;
         // trailing slash is guaranteed
-        string globsrch(path + "*.dll");
+        std::string globsrch(path + "*.dll");
         // convert to wide chars (utf16) for system call
-        wstring wglobsrch(UTF_8::convert_to_utf16(globsrch));
+        std::wstring wglobsrch(UTF_8::convert_to_utf16(globsrch));
         HANDLE hFile = FindFirstFileW(wglobsrch.c_str(), &data);
         // check if system called returned a result
         // ToDo: maybe we should print a debug message
@@ -123,7 +121,7 @@ namespace Sass {
           try
           {
             // the system will report the filenames with wide chars (utf16)
-            string entry = UTF_8::convert_from_utf16(data.cFileName);
+            std::string entry = UTF_8::convert_from_utf16(data.cFileName);
             // check if file ending matches exactly
             if (!ends_with(entry, ".dll")) continue;
             // load the plugin and increase counter
@@ -137,7 +135,7 @@ namespace Sass {
           {
             // report the error to the console (should not happen)
             // seems like we got strange data from the system call?
-            cerr << "filename in plugin path has invalid utf8?" << endl;
+            std::cerr << "filename in plugin path has invalid utf8?" << std::endl;
           }
         }
       }
@@ -145,7 +143,7 @@ namespace Sass {
       {
         // report the error to the console (should not happen)
         // implementors should make sure to provide valid utf8
-        cerr << "plugin path contains invalid utf8" << endl;
+        std::cerr << "plugin path contains invalid utf8" << std::endl;
       }
 
     #else
@@ -165,4 +163,3 @@ namespace Sass {
   }
 
 }
-