sassc 0.0.9 → 0.0.10

data/ext/libsass/parser.hpp

@@ -1,29 +1,15 @@
-#define SASS_PARSER
+#ifndef SASS_PARSER_H
+#define SASS_PARSER_H
 
-#include <vector>
 #include <map>
+#include <vector>
+#include <iostream>
 
-#ifndef SASS_PRELEXER
-#include "prelexer.hpp"
-#endif
-
-#ifndef SASS_TOKEN
-#include "token.hpp"
-#endif
-
-#ifndef SASS_CONTEXT
-#include "context.hpp"
-#endif
-
-#ifndef SASS_AST
 #include "ast.hpp"
-#endif
-
-#ifndef SASS_POSITION
 #include "position.hpp"
-#endif
-
-#include <iostream>
+#include "context.hpp"
+#include "position.hpp"
+#include "prelexer.hpp"
 
 struct Selector_Lookahead {
   const char* found;
@@ -36,7 +22,7 @@ namespace Sass {
   using std::map;
   using namespace Prelexer;
 
-  class Parser {
+  class Parser : public ParserState {
   private:
     void add_single_file (Import* imp, string import_path);
   public:
@@ -45,26 +31,30 @@ namespace Sass {
     enum Syntactic_Context { nothing, mixin_def, function_def };
 
     Context& ctx;
+    vector<Block*> block_stack;
     vector<Syntactic_Context> stack;
+    Media_Block* last_media_block;
     const char* source;
     const char* position;
     const char* end;
-    string path;
-    size_t column;
-    Position source_position;
+    Position before_token;
+    Position after_token;
+    ParserState pstate;
+    int indentation;
 
 
     Token lexed;
-    bool dequote;
+    bool in_at_root;
 
-    Parser(Context& ctx, string path, Position source_position)
-    : ctx(ctx), stack(vector<Syntactic_Context>()),
-      source(0), position(0), end(0), path(path), column(1), source_position(source_position)
-    { dequote = false; stack.push_back(nothing); }
+    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)
+    { in_at_root = false; stack.push_back(nothing); }
 
-    static Parser from_string(string src, Context& ctx, string path = "", Position source_position = Position());
-    static Parser from_c_str(const char* src, Context& ctx, string path = "", Position source_position = Position());
-    static Parser from_token(Token t, Context& ctx, string path = "", Position source_position = Position());
+    // static Parser from_string(const 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]"));
 
 #ifdef __clang__
 
@@ -78,102 +68,141 @@ namespace Sass {
 
 #endif
 
+
+    bool peek_newline(const char* start = 0);
+
     template <prelexer mx>
     const char* peek(const char* start = 0)
     {
       if (!start) start = position;
-      const char* after_whitespace;
+      const char* it_before_token;
       if (mx == block_comment) {
-        after_whitespace = // start;
+        it_before_token = // start;
           zero_plus< alternatives<spaces, line_comment> >(start);
       }
       else if (/*mx == ancestor_of ||*/ mx == no_spaces) {
-        after_whitespace = position;
+        it_before_token = position;
       }
-      else if (mx == spaces || mx == ancestor_of) {
-        after_whitespace = mx(start);
-        if (after_whitespace) {
-          return after_whitespace;
+      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) {
-        after_whitespace = optional_spaces(start);
+        it_before_token = optional_spaces(start);
       }
       else if (mx == line_comment_prefix || mx == block_comment_prefix) {
-        after_whitespace = position;
+        it_before_token = position;
       }
       else {
-        after_whitespace = spaces_and_comments(start);
+        it_before_token = optional_spaces_and_comments(start);
       }
-      const char* after_token = mx(after_whitespace);
-      if (after_token) {
-        return after_token;
+      const char* it_after_token = mx(it_before_token);
+      if (it_after_token) {
+        return it_after_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
     template <prelexer mx>
     const char* lex()
     {
-      const char* after_whitespace;
+
+      // remeber interesting position
+      const char* wspace_start = position;
+
+      // advance position for next call
+      before_token = after_token;
+
+      // after optional whitespace
+      const char* it_before_token;
+
       if (mx == block_comment) {
-        after_whitespace = // position;
-          zero_plus< alternatives<spaces, line_comment> >(position);
+        // 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) {
-        after_whitespace = position;
-      }
-      else if (mx == ancestor_of || mx == no_spaces) {
-        after_whitespace = position;
+      else if (mx == url || mx == no_spaces) {
+        // parse everything literally
+        it_before_token = position;
       }
+
       else if (mx == spaces) {
-        after_whitespace = spaces(position);
-        if (after_whitespace) {
-          source_position.line += count_interval<'\n'>(position, after_whitespace);
-          lexed = Token(position, after_whitespace);
-          return position = after_whitespace;
+        it_before_token = spaces(position);
+        if (it_before_token) {
+          return position = it_before_token;
         }
         else {
           return 0;
         }
       }
+
+      else if (mx == optional_spaces_and_comments) {
+        it_before_token = position;
+      }
+      else if (mx == spaces_and_comments) {
+        it_before_token = position;
+      }
+
       else if (mx == optional_spaces) {
-        after_whitespace = optional_spaces(position);
+        // ToDo: what are optiona_spaces ???
+        it_before_token = optional_spaces(position);
       }
       else {
-        after_whitespace = spaces_and_comments(position);
+        // most can be preceded by spaces and comments
+        it_before_token = optional_spaces_and_comments(position);
       }
-      const char* after_token = mx(after_whitespace);
-      if (after_token) {
-        size_t previous_line = source_position.line;
-        source_position.line += count_interval<'\n'>(position, after_token);
-
-        size_t whitespace = 0;
-        const char* ptr = after_whitespace - 1;
-        while (ptr >= position) {
-          if (*ptr == '\n')
-            break;
-          whitespace++;
-          ptr--;
-        }
-        if (previous_line != source_position.line) {
-          column = 1;
+
+      // 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;
+
+      // 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;
+      }
 
-        source_position.column = column + whitespace;
-        column += after_token - after_whitespace + whitespace;
-        lexed = Token(after_whitespace, after_token);
+      // copy position
+      after_token = before_token;
 
-        return position = after_token;
-      }
-      else {
-        return 0;
+      Offset size(0, 0);
+
+      // 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;
+
+      // 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);
+
+      // advance internal char iterator
+      return position = it_after_token;
+
     }
 
 #ifdef __clang__
@@ -182,7 +211,7 @@ namespace Sass {
 
 #endif
 
-    void error(string msg, Position pos = Position());
+    void error(string msg, Position pos);
     void read_bom();
 
     Block* parse();
@@ -194,7 +223,7 @@ namespace Sass {
     Arguments* parse_arguments();
     Argument* parse_argument();
     Assignment* parse_assignment();
-    Propset* parse_propset();
+    // Propset* parse_propset();
     Ruleset* parse_ruleset(Selector_Lookahead lookahead);
     Selector_Schema* parse_selector_schema(const char* end_of_selector);
     Selector_List* parse_selector_group();
@@ -205,6 +234,7 @@ namespace Sass {
     Simple_Selector* parse_pseudo_selector();
     Attribute_Selector* parse_attribute_selector();
     Block* parse_block();
+    bool parse_number_prefix();
     Declaration* parse_declaration();
     Expression* parse_map_value();
     Expression* parse_map();
@@ -221,14 +251,14 @@ namespace Sass {
     Function_Call* parse_calc_function();
     Function_Call* parse_function_call();
     Function_Call_Schema* parse_function_call_schema();
-    String* parse_interpolated_chunk(Token);
+    String* parse_interpolated_chunk(Token, bool constant = false);
     String* parse_string();
     String_Constant* parse_static_value();
     String* parse_ie_property();
     String* parse_ie_keyword_arg();
-    String_Schema* parse_value_schema();
+    String_Schema* parse_value_schema(const char* stop);
     String* parse_identifier_schema();
-    String_Schema* parse_url_schema();
+    // String_Schema* parse_url_schema();
     If* parse_if_directive(bool else_if = false);
     For* parse_for_directive();
     Each* parse_each_directive();
@@ -245,6 +275,8 @@ namespace Sass {
     Feature_Query_Condition* parse_supports_conjunction();
     Feature_Query_Condition* parse_supports_disjunction();
     Feature_Query_Condition* parse_supports_declaration();
+    At_Root_Block* parse_at_root_block();
+    At_Root_Expression* parse_at_root_expression();
     At_Rule* parse_at_rule();
     Warning* parse_warning();
     Error* parse_error();
@@ -262,3 +294,5 @@ namespace Sass {
 
   size_t check_bom_chars(const char* src, const char *end, const unsigned char* bom, size_t len);
 }
+
+#endif

data/ext/libsass/paths.hpp

@@ -1,7 +1,10 @@
-#include <vector>
-#include <iostream>
+#ifndef SASS_PATHS_H
+#define SASS_PATHS_H
+
 #include <string>
+#include <vector>
 #include <sstream>
+#include <iostream>
 
 using namespace std;
 
@@ -67,3 +70,5 @@ namespace Sass {
   }
 
 }
+
+#endif

data/ext/libsass/plugins.cpp

@@ -0,0 +1,155 @@
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/types.h>
+#include <dirent.h>
+#include <errno.h>
+#include <dlfcn.h>
+#endif
+
+#include <iostream>
+#include "output.hpp"
+#include "plugins.hpp"
+
+#define npos string::npos
+
+namespace Sass {
+
+  Plugins::Plugins(void) { }
+  Plugins::~Plugins(void) { }
+
+  // check if plugin is compatible with this version
+  // plugins may be linked static against libsass
+  // we try to be compatible between major versions
+  inline bool compatibility(const char* their_version)
+  {
+// const char* their_version = "3.1.2";
+    // first check if anyone has an unknown version
+    const char* our_version = libsass_version();
+    if (!strcmp(their_version, "[na]")) return false;
+    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);
+
+    // if we do not have two dots we fallback to compare complete string
+    if (pos == 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)
+  {
+
+    typedef const char* (*__plugin_version__)(void);
+    typedef Sass_C_Function_List (*__plugin_load_fns__)(void);
+
+    if (LOAD_LIB(plugin, path))
+    {
+      // try to load initial function to query libsass version suppor
+      if (LOAD_LIB_FN(__plugin_version__, plugin_version, "libsass_get_version"))
+      {
+        // get the libsass version of the plugin
+        if (!compatibility(plugin_version())) return false;
+        // 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();
+          while (fns && *fns) { functions.push_back(*fns); ++ fns; }
+        }
+        // success
+        return true;
+      }
+      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;
+        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;
+    }
+
+    return false;
+
+  }
+
+  size_t Plugins::load_plugins(const string& path)
+  {
+
+    // count plugins
+    size_t loaded = 0;
+
+    #ifdef _WIN32
+
+      try
+      {
+
+        // use wchar (utf16)
+        WIN32_FIND_DATAW data;
+        // trailing slash is guaranteed
+        string globsrch(path + "*.dll");
+        // convert to wide chars (utf16) for system call
+        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
+        if (hFile == INVALID_HANDLE_VALUE) return -1;
+
+        // read directory
+        while (true)
+        {
+          try
+          {
+            // the system will report the filenames with wide chars (utf16)
+            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
+            if (load_plugin(path + entry)) ++ loaded;
+            // check if there should be more entries
+            if (GetLastError() == ERROR_NO_MORE_FILES) break;
+            // load next entry (check for return type)
+            if (!FindNextFileW(hFile, &data)) break;
+          }
+          catch (...)
+          {
+            // 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;
+          }
+        }
+      }
+      catch (utf8::invalid_utf8)
+      {
+        // report the error to the console (should not happen)
+        // implementors should make sure to provide valid utf8
+        cerr << "plugin path contains invalid utf8" << endl;
+      }
+
+    #else
+
+      DIR *dp;
+      struct dirent *dirp;
+      if((dp  = opendir(path.c_str())) == NULL) return -1;
+      while ((dirp = readdir(dp)) != NULL) {
+        if (!ends_with(dirp->d_name, ".so")) continue;
+        if (load_plugin(path + dirp->d_name)) ++ loaded;
+      }
+      closedir(dp);
+
+    #endif
+    return loaded;
+
+  }
+
+}
+