sassc 0.0.10 → 0.0.11

data/ext/libsass/parser.hpp

@@ -25,10 +25,12 @@ namespace Sass {
   class Parser : public ParserState {
   private:
     void add_single_file (Import* imp, string import_path);
+    void import_single_file (Import* imp, 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);
 
     Context& ctx;
     vector<Block*> block_stack;
@@ -48,7 +50,7 @@ namespace Sass {
 
     Parser(Context& ctx, const ParserState& pstate)
     : ParserState(pstate), ctx(ctx), block_stack(0), stack(0), last_media_block(0),
-      source(0), position(0), end(0), before_token(pstate), after_token(pstate), pstate("[NULL]"), indentation(0)
+      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]"));
@@ -71,140 +73,119 @@ namespace Sass {
 
     bool peek_newline(const char* start = 0);
 
+    // skip over spaces, tabs and line comments
     template <prelexer mx>
-    const char* peek(const char* start = 0)
+    const char* sneak(const char* start = 0)
     {
-      if (!start) start = position;
-      const char* it_before_token;
-      if (mx == block_comment) {
-        it_before_token = // start;
-          zero_plus< alternatives<spaces, line_comment> >(start);
-      }
-      else if (/*mx == ancestor_of ||*/ mx == no_spaces) {
-        it_before_token = position;
-      }
-      else if (mx == spaces) {
-        it_before_token = mx(start);
-        if (it_before_token) {
-          return it_before_token;
-        }
-        else {
-          return 0;
-        }
-      }
-      else if (mx == optional_spaces) {
-        it_before_token = optional_spaces(start);
-      }
-      else if (mx == line_comment_prefix || mx == block_comment_prefix) {
-        it_before_token = position;
-      }
-      else {
-        it_before_token = optional_spaces_and_comments(start);
-      }
-      const char* it_after_token = mx(it_before_token);
-      if (it_after_token) {
-        return it_after_token;
-      }
-      else {
-        return 0;
+
+      // maybe use optional start position from arguments?
+      const char* it_position = start ? start : position;
+
+      // skip white-space?
+      if (mx == spaces ||
+          mx == no_spaces ||
+          mx == css_comments ||
+          mx == css_whitespace ||
+          mx == optional_spaces ||
+          mx == optional_css_comments ||
+          mx == optional_css_whitespace
+      ) {
+        return it_position;
       }
+
+      // skip over spaces, tabs and sass line comments
+      const char* pos = optional_css_whitespace(it_position);
+      // always return a valid position
+      return pos ? pos : it_position;
+
     }
 
-    // white-space handling is built into the lexer
-    // this way you do not need to parse it yourself
-    // some matchers don't accept certain white-space
+    // peek will only skip over space, tabs and line comment
+    // return the position where the lexer match will occur
     template <prelexer mx>
-    const char* lex()
+    const char* peek(const char* start = 0)
     {
 
-      // remeber interesting position
-      const char* wspace_start = position;
-
-      // advance position for next call
-      before_token = after_token;
+      // sneak up to the actual token we want to lex
+      // this should skip over white-space if desired
+      const char* it_before_token = sneak < mx >(start);
 
-      // after optional whitespace
-      const char* it_before_token;
+      // match the given prelexer
+      return mx(it_before_token);
 
-      if (mx == block_comment) {
-        // a block comment can be preceded by spaces and/or line comments
-        it_before_token = zero_plus< alternatives<spaces, line_comment> >(position);
-      }
-      else if (mx == url || mx == no_spaces) {
-        // parse everything literally
-        it_before_token = position;
-      }
+    }
 
-      else if (mx == spaces) {
-        it_before_token = spaces(position);
-        if (it_before_token) {
-          return position = it_before_token;
-        }
-        else {
-          return 0;
-        }
-      }
+    // white-space handling is built into the lexer
+    // this way you do not need to parse it yourself
+    // some matchers don't accept certain white-space
+    // 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)
+    {
 
-      else if (mx == optional_spaces_and_comments) {
-        it_before_token = position;
-      }
-      else if (mx == spaces_and_comments) {
-        it_before_token = position;
-      }
+      // position considered before lexed token
+      // we can skip whitespace or comments for
+      // lazy developers (but we need control)
+      const char* it_before_token = position;
 
-      else if (mx == optional_spaces) {
-        // ToDo: what are optiona_spaces ???
-        it_before_token = optional_spaces(position);
-      }
-      else {
-        // most can be preceded by spaces and comments
-        it_before_token = optional_spaces_and_comments(position);
-      }
+      // sneak up to the actual token we want to lex
+      // this should skip over white-space if desired
+      if (lazy) it_before_token = sneak < mx >(position);
 
       // 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;
 
-      // add whitespace after previous and before this token
-      while (position < it_before_token && *position) {
-        if (*position == '\n') {
-          ++ before_token.line;
-          before_token.column = 0;
-        } else {
-          ++ before_token.column;
-        }
-        ++position;
-      }
-
-      // copy position
-      after_token = before_token;
+      // create new lexed token object (holds all parse result information)
+      lexed = Token(position, it_before_token, it_after_token);
 
-      Offset size(0, 0);
+      // advance position (add whitespace before current token)
+      before_token = after_token.add(position, it_before_token);
 
-      // increase position to include current token
-      while (position < it_after_token && *position) {
-        if (*position == '\n') {
-          ++ size.line;
-          size.column = 0;
-        } else {
-          ++ size.column;
-        }
-        ++position;
-      }
-
-      after_token = after_token + size;
+      // update after_token position for current token
+      after_token.add(it_before_token, it_after_token);
 
-      // create parsed token string (public member)
-      lexed = Token(wspace_start, it_before_token, it_after_token, optional_spaces_and_comments(it_after_token) ? optional_spaces_and_comments(it_after_token) : it_after_token, before_token);
-      Position pos(before_token.file, before_token.line, before_token.column);
-      pstate = ParserState(path, lexed, pos, size);
+      // ToDo: could probably do this incremetal on original object (API wants offset?)
+      pstate = ParserState(path, source, lexed, before_token, after_token - before_token);
 
       // advance internal char iterator
       return position = it_after_token;
 
     }
 
+    // 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>
+    const char* lex_css()
+    {
+      // copy old token
+      Token prev = lexed;
+      // throw away comments
+      // update srcmap position
+      lex < css_comments >();
+      // now lex a new token
+      const char* pos = lex< mx >();
+      // maybe restore prev token
+      if (pos == 0) lexed = prev;
+      // return match
+      return pos;
+    }
+
+    // all block comments will be skipped and thrown away
+    template <prelexer mx>
+    const char* peek_css(const char* start = 0)
+    {
+      // now peek a token (skip comments first)
+      return peek< mx >(peek < css_comments >(start));
+    }
+
 #ifdef __clang__
 
 #pragma clang diagnostic pop
@@ -212,6 +193,11 @@ namespace Sass {
 #endif
 
     void error(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 read_bom();
 
     Block* parse();
@@ -220,8 +206,8 @@ namespace Sass {
     Parameters* parse_parameters();
     Parameter* parse_parameter();
     Mixin_Call* parse_mixin_call();
-    Arguments* parse_arguments();
-    Argument* parse_argument();
+    Arguments* parse_arguments(bool has_url = false);
+    Argument* parse_argument(bool has_url = false);
     Assignment* parse_assignment();
     // Propset* parse_propset();
     Ruleset* parse_ruleset(Selector_Lookahead lookahead);
@@ -282,6 +268,8 @@ namespace Sass {
     Error* parse_error();
     Debug* parse_debug();
 
+    void parse_block_comments(Block* block);
+
     Selector_Lookahead lookahead_for_selector(const char* start = 0);
     Selector_Lookahead lookahead_for_extension_target(const char* start = 0);
 

data/ext/libsass/plugins.cpp

@@ -45,7 +45,8 @@ namespace Sass {
   {
 
     typedef const char* (*__plugin_version__)(void);
-    typedef Sass_C_Function_List (*__plugin_load_fns__)(void);
+    typedef Sass_Function_List (*__plugin_load_fns__)(void);
+    typedef Sass_Importer_List (*__plugin_load_imps__)(void);
 
     if (LOAD_LIB(plugin, path))
     {
@@ -57,9 +58,21 @@ namespace Sass {
         // try to get import address for "libsass_load_functions"
         if (LOAD_LIB_FN(__plugin_load_fns__, plugin_load_functions, "libsass_load_functions"))
         {
-          Sass_C_Function_List fns = plugin_load_functions();
+          Sass_Function_List fns = plugin_load_functions();
           while (fns && *fns) { functions.push_back(*fns); ++ fns; }
         }
+        // try to get import address for "libsass_load_importers"
+        if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_importers, "libsass_load_importers"))
+        {
+          Sass_Importer_List imps = plugin_load_importers();
+          while (imps && *imps) { importers.push_back(*imps); ++ imps; }
+        }
+        // try to get import address for "libsass_load_headers"
+        if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_headers, "libsass_load_headers"))
+        {
+          Sass_Importer_List imps = plugin_load_headers();
+          while (imps && *imps) { headers.push_back(*imps); ++ imps; }
+        }
         // success
         return true;
       }

data/ext/libsass/plugins.hpp

@@ -42,12 +42,14 @@ namespace Sass {
       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; };
+      const vector<Sass_Importer_Entry> get_headers(void) { return headers; };
+      const vector<Sass_Importer_Entry> get_importers(void) { return importers; };
+      const vector<Sass_Function_Entry> get_functions(void) { return functions; };
 
     private: // private vars
-      // vector<Sass_C_Import_Callback> importers;
-      vector<Sass_C_Function_Callback> functions;
+      vector<Sass_Importer_Entry> headers;
+      vector<Sass_Importer_Entry> importers;
+      vector<Sass_Function_Entry> functions;
 
   };
 

data/ext/libsass/position.cpp

@@ -19,20 +19,42 @@ namespace Sass {
   Offset::Offset(const size_t line, const size_t column)
   : line(line), column(column) { }
 
+  // init/create instance from const char substring
+  Offset Offset::init(const char* beg, const char* end)
+  {
+    Offset offset(0, 0);
+    if (end == 0) {
+      end += strlen(beg);
+    }
+    offset.add(beg, end);
+    return offset;
+  }
+
   // 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
+  // ToDo: make the col count utf8 aware
+  Offset Offset::add(const char* begin, const char* end)
   {
-    Offset offset(line, column);
+    if (end == 0) return *this;
     while (begin < end && *begin) {
       if (*begin == '\n') {
-        ++ offset.line;
-        offset.column = 0;
+        ++ line;
+        // start new line
+        column = 0;
       } else {
-        ++ offset.column;
+        ++ column;
       }
       ++begin;
     }
+    return *this;
+  }
+
+  // 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);
+    offset.add(begin, end);
     return offset;
   }
 
@@ -48,12 +70,17 @@ namespace Sass {
 
   void Offset::operator+= (const Offset &off)
   {
-    *this = Offset(line + off.line, off.line > 0 ? off.column : off.column + column);
+    *this = Offset(line + off.line, off.line > 0 ? off.column : column + off.column);
   }
 
   Offset Offset::operator+ (const Offset &off) const
   {
-    return Offset(line + off.line, off.line > 0 ? off.column : off.column + column);
+    return Offset(line + off.line, off.line > 0 ? off.column : column + off.column);
+  }
+
+  Offset Offset::operator- (const Offset &off) const
+  {
+    return Offset(line - off.line, off.line == line ? column - off.column : column);
   }
 
   Position::Position(const size_t file)
@@ -69,17 +96,20 @@ namespace Sass {
   : Offset(line, column), file(file) { }
 
 
-  ParserState::ParserState(string path)
-  : Position(-1, 0, 0), path(path), offset(0, 0), token() { }
+  ParserState::ParserState(string path, const char* src, const size_t file)
+  : Position(file, 0, 0), path(path), src(src), 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, const char* src, Position position, Offset offset)
+  : Position(position), path(path), src(src), offset(offset), token() { }
 
-  ParserState::ParserState(string path, Position position, Offset offset)
-  : Position(position), path(path), offset(offset), token() { }
+  ParserState::ParserState(string path, const char* src, Token token, Position position, Offset offset)
+  : Position(position), path(path), src(src), offset(offset), token(token) { }
 
-  ParserState::ParserState(string path, Token token, Position position, Offset offset)
-  : Position(position), path(path), offset(offset), token(token) { }
+  Position Position::add(const char* begin, const char* end)
+  {
+    Offset::add(begin, end);
+    return *this;
+  }
 
   Position Position::inc(const char* begin, const char* end) const
   {
@@ -100,12 +130,17 @@ namespace Sass {
 
   void Position::operator+= (const Offset &off)
   {
-    *this = Position(file, line + off.line, off.line > 0 ? off.column : off.column + column);
+    *this = Position(file, line + off.line, off.line > 0 ? off.column : column + off.column);
   }
 
   const Position Position::operator+ (const Offset &off) const
   {
-    return Position(file, line + off.line, off.line > 0 ? off.column : off.column + column);
+    return Position(file, line + off.line, off.line > 0 ? off.column : column + off.column);
+  }
+
+  const Offset Position::operator- (const Offset &off) const
+  {
+    return Offset(line - off.line, off.line == line ? column - off.column : column);
   }
 
   /* not used anymore - remove?

data/ext/libsass/position.hpp

@@ -19,13 +19,18 @@ namespace Sass {
       Offset(const size_t line, const size_t column);
 
       // return new position, incremented by the given string
+      Offset add(const char* begin, const char* end);
       Offset inc(const char* begin, const char* end) const;
 
+      // init/create instance from const char substring
+      static Offset init(const char* beg, const char* end);
+
     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;
+      Offset operator- (const Offset &off) const;
 
     public: // overload output stream operator
       // friend ostream& operator<<(ostream& strm, const Offset& off);
@@ -52,7 +57,9 @@ namespace Sass {
       bool operator== (const Position &pos) const;
       bool operator!= (const Position &pos) const;
       const Position operator+ (const Offset &off) const;
+      const Offset operator- (const Offset &off) const;
       // return new position, incremented by the given string
+      Position add(const char* begin, const char* end);
       Position inc(const char* begin, const char* end) const;
 
     public: // overload output stream operator
@@ -69,25 +76,19 @@ namespace Sass {
     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)) { }
+    : prefix(0), begin(0), end(0) { }
+    Token(const char* b, const char* e)
+    : prefix(b), begin(b), end(e) { }
+    Token(const char* str)
+    : prefix(str), begin(str), end(str + strlen(str)) { }
+    Token(const char* p, const char* b, const char* e)
+    : prefix(p), begin(b), end(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(); }
@@ -98,17 +99,18 @@ namespace Sass {
   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));
+      ParserState(string path, const char* src = 0, const size_t file = string::npos);
+      ParserState(string path, const char* src, Position position, Offset offset = Offset(0, 0));
+      ParserState(string path, const char* src, Token token, Position position, Offset offset = Offset(0, 0));
 
     public: // down casts
       Offset off() { return *this; };
       Position pos() { return *this; };
+      ParserState pstate() { return *this; };
 
     public:
       string path;
+      const char* src;
       Offset offset;
       Token token;