sassc 0.0.10 → 0.0.11

data/ext/libsass/ast_factory.hpp

@@ -69,6 +69,7 @@ namespace Sass {
     String_Constant* new_String_Constant(string p, size_t l, const char* beg, const char* end);
     Feature_Query_Condition* new_Feature_Query_Condition(string p, size_t l, String* f, Expression* v);
     Media_Expression* new_Media_Expression(string p, size_t l, String* f, Expression* v);
+    Parent_Selector* new_Parent_Selector(string p, size_t l, Selector* s);
     // parameters and arguments
     Parameter* new_Parameter(string p, size_t l, string n, Expression* def = 0, bool rest = false);
     Parameters* new_Parameters(string p, size_t l);
@@ -76,6 +77,7 @@ namespace Sass {
     Arguments* new_Arguments(string p, size_t l);
     // selectors
     Selector_Schema* new_Selector_Schema(string p, size_t l, String* c);
+    Attribute_Selector* new_Attribute_Selector(string p, size_t l, string n, string m, String* v);
     Simple_Selector* new_Simple_Selector(string p, size_t l, string c);
     Reference_Selector* new_Reference_Selector(string p, size_t l);
     Placeholder_Selector* new_Placeholder_Selector(string p, size_t l, string n);

data/ext/libsass/ast_fwd_decl.hpp

@@ -60,6 +60,7 @@ namespace Sass {
   class Feature_Query_Condition;
   class At_Root_Expression;
   class Null;
+  class Parent_Selector;
   // parameters and arguments
   class Parameter;
   class Parameters;

data/ext/libsass/backtrace.hpp

@@ -41,7 +41,7 @@ namespace Sass {
              << "\t"
              << (++i == 0 ? "on" : "from")
              << " line "
-             << this_point->pstate.line
+             << this_point->pstate.line + 1
              << " of "
              << rel_path;
         } else {
@@ -49,7 +49,7 @@ namespace Sass {
              << "\t"
              << rel_path
              << ":"
-             << this_point->pstate.line
+             << this_point->pstate.line + 1
              << this_point->parent->caller;
         }
 

data/ext/libsass/bind.cpp

@@ -20,7 +20,7 @@ namespace Sass {
       Parameter*  p = (*ps)[i];
       param_map[p->name()] = p;
       // if (p->default_value()) {
-      //   env->current_frame()[p->name()] = p->default_value()->perform(eval->with(env));
+      //   env->local_frame()[p->name()] = p->default_value()->perform(eval->with(env));
       // }
     }
 
@@ -41,12 +41,12 @@ namespace Sass {
       if (p->is_rest_parameter()) {
         if (a->is_rest_argument()) {
           // rest param and rest arg -- just add one to the other
-          if (env->current_frame_has(p->name())) {
-            *static_cast<List*>(env->current_frame()[p->name()])
+          if (env->has_local(p->name())) {
+            *static_cast<List*>(env->local_frame()[p->name()])
             += static_cast<List*>(a->value());
           }
           else {
-            env->current_frame()[p->name()] = a->value();
+            env->local_frame()[p->name()] = a->value();
           }
         } else {
 
@@ -55,7 +55,7 @@ namespace Sass {
                                              0,
                                              List::COMMA,
                                              true);
-          env->current_frame()[p->name()] = arglist;
+          env->local_frame()[p->name()] = arglist;
           while (ia < LA) {
             a = (*as)[ia];
             (*arglist) << new (ctx.mem) Argument(a->pstate(),
@@ -99,7 +99,7 @@ namespace Sass {
             msg << callee << " has no parameter named " << name;
             error(msg.str(), a->pstate());
           }
-          env->current_frame()[name] = argmap->at(key);
+          env->local_frame()[name] = argmap->at(key);
         }
         ++ia;
         continue;
@@ -108,14 +108,14 @@ namespace Sass {
       }
 
       if (a->name().empty()) {
-        if (env->current_frame_has(p->name())) {
+        if (env->has_local(p->name())) {
           stringstream msg;
           msg << "parameter " << p->name()
           << " provided more than once in call to " << callee;
           error(msg.str(), a->pstate());
         }
         // ordinal arg -- bind it to the next param
-        env->current_frame()[p->name()] = a->value();
+        env->local_frame()[p->name()] = a->value();
         ++ip;
       }
       else {
@@ -131,13 +131,13 @@ namespace Sass {
               << "cannot be used as named argument";
           error(msg.str(), a->pstate());
         }
-        if (env->current_frame_has(a->name())) {
+        if (env->has_local(a->name())) {
           stringstream msg;
           msg << "parameter " << p->name()
               << "provided more than once in call to " << callee;
           error(msg.str(), a->pstate());
         }
-        env->current_frame()[a->name()] = a->value();
+        env->local_frame()[a->name()] = a->value();
       }
     }
 
@@ -150,9 +150,9 @@ namespace Sass {
       // cerr << "env for default params:" << endl;
       // env->print();
       // cerr << "********" << endl;
-      if (!env->current_frame_has(leftover->name())) {
+      if (!env->has_local(leftover->name())) {
         if (leftover->is_rest_parameter()) {
-          env->current_frame()[leftover->name()] = new (ctx.mem) List(leftover->pstate(),
+          env->local_frame()[leftover->name()] = new (ctx.mem) List(leftover->pstate(),
                                                                       0,
                                                                       List::COMMA,
                                                                       true);
@@ -161,11 +161,13 @@ namespace Sass {
           // make sure to eval the default value in the env that we've been populating
           Env* old_env = eval->env;
           Backtrace* old_bt = eval->backtrace;
+          Contextualize* old_context = eval->contextualize;
           Expression* dv = leftover->default_value()->perform(eval->with(env, eval->backtrace));
           eval->env = old_env;
           eval->backtrace = old_bt;
+          eval->contextualize = old_context;
           // dv->perform(&to_string);
-          env->current_frame()[leftover->name()] = dv;
+          env->local_frame()[leftover->name()] = dv;
         }
         else {
           // param is unbound and has no default value -- error

data/ext/libsass/configure.ac

@@ -7,15 +7,17 @@ AC_INIT([libsass], m4_esyscmd_s([./version.sh]), [support@moovweb.com])
 AC_CONFIG_SRCDIR([ast.hpp])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_FILES([sass_version.h])
 AC_CONFIG_AUX_DIR([script])
-AM_INIT_AUTOMAKE([foreign parallel-tests])
+# These are flags passed to automake
+# Though they look like gcc flags!
+AM_INIT_AUTOMAKE([foreign parallel-tests -Wall])
 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([no])])
-LT_INIT
 
 # Checks for programs.
 AC_PROG_CXX
-
 AC_LANG([C++])
+LT_INIT([dlopen])
 
 # Checks for header files.
 AC_CHECK_HEADERS([unistd.h])
@@ -31,6 +33,17 @@ AC_CHECK_FUNCS([floor getcwd strtol])
 AC_ARG_ENABLE(tests, AS_HELP_STRING([--enable-tests], [enable testing the build]),
               [enable_tests="$enableval"], [enable_tests=no])
 
+AS_CASE([$host], [*-*-mingw32], [is_mingw32=yes], [is_mingw32=no])
+AM_CONDITIONAL(COMPILER_IS_MINGW32, test "x$is_mingw32" = "xyes")
+
+dnl The dlopen() function is in the C library for *BSD and in
+dnl libdl on GLIBC-based systems
+if test "x$is_mingw32" != "xyes"; then
+  AC_SEARCH_LIBS([dlopen], [dl dld], [], [
+    AC_MSG_ERROR([unable to find the dlopen() function])
+  ])
+fi
+
 if test "x$enable_tests" = "xyes"; then
   AC_PROG_CC
   AC_PROG_AWK
@@ -107,8 +120,7 @@ fi
 
 AM_CONDITIONAL(ENABLE_COVERAGE, test "x$enable_cov" = "xyes")
 
-AS_CASE([$host], [*-*-mingw32], [is_mingw32=yes], [is_mingw32=no])
-AM_CONDITIONAL(COMPILER_IS_MINGW32, test "x$is_mingw32" = "xyes")
+AC_SUBST(PACKAGE_VERSION)
 
 AC_MSG_NOTICE([Building libsass ($VERSION)])
 

data/ext/libsass/constants.cpp

@@ -2,7 +2,17 @@
 
 namespace Sass {
   namespace Constants {
-    extern const int SPECIFICITY_BASE = 1000;
+
+    // https://github.com/sass/libsass/issues/592
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity
+    // https://github.com/sass/sass/issues/1495#issuecomment-61189114
+    extern const unsigned long Specificity_Star = 0;
+    extern const unsigned long Specificity_Universal = 1 << 0;
+    extern const unsigned long Specificity_Type = 1 << 8;
+    extern const unsigned long Specificity_Class = 1 << 16;
+    extern const unsigned long Specificity_Attr = 1 << 16;
+    extern const unsigned long Specificity_Pseudo = 1 << 16;
+    extern const unsigned long Specificity_ID = 1 << 24;
 
     // sass keywords
     extern const char at_root_kwd[]       = "@at-root";
@@ -78,6 +88,9 @@ namespace Sass {
     extern const char webkit_calc_kwd[]  = "-webkit-calc(";
     extern const char ms_calc_kwd[]      = "-ms-calc(";
 
+    // css selector keywords
+    extern const char sel_deep_kwd[] = "/deep/";
+
     // css attribute-matching operators
     extern const char tilde_equal[]  = "~=";
     extern const char pipe_equal[]   = "|=";
@@ -110,7 +123,7 @@ namespace Sass {
     extern const char sign_chars[]      = "-+";
     extern const char hyphen[]          = "-";
     extern const char ellipsis[]        = "...";
-    extern const char url_space_chars[] = " \t\r\n\f";
+    // extern const char url_space_chars[] = " \t\r\n\f";
     extern const char escape_chars[]    = " -~"; // need to include unicode spaces too
     // type names
     extern const char numeric_name[]    = "numeric value";
@@ -124,6 +137,13 @@ namespace Sass {
     extern const char map_name[]        = "map";
     extern const char arglist_name[]    = "arglist";
 
+    // constants for uri parsing (RFC 3986 Appendix A.)
+    extern const char uri_chars[]  = ":;/?!$%&#@[]{}'\"*+-.,_=";
+
+    // some specific constant character classes
+    // they must be static to be useable by lexer
+    extern const char static_ops[]      = "*/%";
+
     // byte order marks
     // (taken from http://en.wikipedia.org/wiki/Byte_order_mark)
     extern const unsigned char utf_8_bom[]      = { 0xEF, 0xBB, 0xBF };

data/ext/libsass/constants.hpp

@@ -3,7 +3,16 @@
 
 namespace Sass {
   namespace Constants {
-    extern const int SPECIFICITY_BASE;
+
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity
+    // The following list of selectors is by increasing specificity:
+    extern const unsigned long Specificity_Star;
+    extern const unsigned long Specificity_Universal;
+    extern const unsigned long Specificity_Type;
+    extern const unsigned long Specificity_Class;
+    extern const unsigned long Specificity_Attr;
+    extern const unsigned long Specificity_Pseudo;
+    extern const unsigned long Specificity_ID;
 
     // sass keywords
     extern const char at_root_kwd[];
@@ -80,6 +89,9 @@ namespace Sass {
     extern const char webkit_calc_kwd[];
     extern const char ms_calc_kwd[];
 
+    // css selector keywords
+    extern const char sel_deep_kwd[];
+
     // css attribute-matching operators
     extern const char tilde_equal[];
     extern const char pipe_equal[];
@@ -112,7 +124,7 @@ namespace Sass {
     extern const char sign_chars[];
     extern const char hyphen[];
     extern const char ellipsis[];
-    extern const char url_space_chars[];
+    // extern const char url_space_chars[];
     extern const char escape_chars[];
 
     // type names
@@ -127,6 +139,13 @@ namespace Sass {
     extern const char map_name[];
     extern const char arglist_name[];
 
+    // constants for uri parsing (RFC 3986 Appendix A.)
+    extern const char uri_chars[];
+
+    // some specific constant character classes
+    // they must be static to be useable by lexer
+    extern const char static_ops[];
+
     // byte order marks
     // (taken from http://en.wikipedia.org/wiki/Byte_order_mark)
     extern const unsigned char utf_8_bom[];

data/ext/libsass/context.cpp

@@ -17,7 +17,9 @@
 #include "expand.hpp"
 #include "eval.hpp"
 #include "contextualize.hpp"
+#include "contextualize_eval.hpp"
 #include "cssize.hpp"
+#include "listize.hpp"
 #include "extend.hpp"
 #include "remove_placeholders.hpp"
 #include "color_names.hpp"
@@ -48,10 +50,15 @@ namespace Sass {
     this->source = source;
   }
 
+  inline bool sort_importers (const Sass_Importer_Entry& i, const Sass_Importer_Entry& j)
+  { return sass_importer_get_priority(i) > sass_importer_get_priority(j); }
 
   Context::Context(Context::Data initializers)
   : // Output(this),
+    head_imports(0),
     mem(Memory_Manager<AST_Node>()),
+    c_options               (initializers.c_options()),
+    c_compiler              (initializers.c_compiler()),
     source_c_str            (initializers.source_c_str()),
     sources                 (vector<const char*>()),
     plugin_paths            (initializers.plugin_paths()),
@@ -59,7 +66,9 @@ namespace Sass {
     queue                   (vector<Sass_Queued>()),
     style_sheets            (map<string, Block*>()),
     emitter (this),
-    c_functions             (vector<Sass_C_Function_Callback>()),
+    c_headers               (vector<Sass_Importer_Entry>()),
+    c_importers             (vector<Sass_Importer_Entry>()),
+    c_functions             (vector<Sass_Function_Entry>()),
     indent                  (initializers.indent()),
     linefeed                (initializers.linefeed()),
     input_path              (make_canonical_path(initializers.input_path())),
@@ -72,7 +81,6 @@ namespace Sass {
     source_map_contents     (initializers.source_map_contents()),
     omit_source_map_url     (initializers.omit_source_map_url()),
     is_indented_syntax_src  (initializers.is_indented_syntax_src()),
-    importer                (initializers.importer()),
     names_to_colors         (map<string, Color*>()),
     colors_to_names         (map<int, string>()),
     precision               (initializers.precision()),
@@ -89,9 +97,9 @@ namespace Sass {
 
     include_paths.push_back(cwd);
     collect_include_paths(initializers.include_paths_c_str());
-    collect_include_paths(initializers.include_paths_array());
+    // collect_include_paths(initializers.include_paths_array());
     collect_plugin_paths(initializers.plugin_paths_c_str());
-    collect_plugin_paths(initializers.plugin_paths_array());
+    // collect_plugin_paths(initializers.plugin_paths_array());
 
     setup_color_map();
 
@@ -102,7 +110,15 @@ namespace Sass {
     for(auto fn : plugins.get_functions()) {
       c_functions.push_back(fn);
     }
+    for(auto fn : plugins.get_headers()) {
+      c_headers.push_back(fn);
+    }
+    for(auto fn : plugins.get_importers()) {
+      c_importers.push_back(fn);
+    }
 
+    sort (c_headers.begin(), c_headers.end(), sort_importers);
+    sort (c_importers.begin(), c_importers.end(), sort_importers);
     string entry_point = initializers.entry_point();
     if (!entry_point.empty()) {
       string result(add_file(entry_point));
@@ -111,15 +127,34 @@ namespace Sass {
       }
     }
 
-    emitter.set_filename(output_path);
+    emitter.set_filename(resolve_relative_path(output_path, source_map_file, cwd));
+
+  }
 
+  void Context::add_c_function(Sass_Function_Entry function)
+  {
+    c_functions.push_back(function);
+  }
+  void Context::add_c_header(Sass_Importer_Entry header)
+  {
+    c_headers.push_back(header);
+    // need to sort the array afterwards (no big deal)
+    sort (c_headers.begin(), c_headers.end(), sort_importers);
+  }
+  void Context::add_c_importer(Sass_Importer_Entry importer)
+  {
+    c_importers.push_back(importer);
+    // need to sort the array afterwards (no big deal)
+    sort (c_importers.begin(), c_importers.end(), sort_importers);
   }
 
   Context::~Context()
   {
     // everything that gets put into sources will be freed by us
-    for (size_t i = 0; i < sources.size(); ++i) delete[] sources[i];
     for (size_t n = 0; n < import_stack.size(); ++n) sass_delete_import(import_stack[n]);
+    // sources are allocated by strdup or malloc (overtaken from C code)
+    for (size_t i = 0; i < sources.size(); ++i) free((void*)sources[i]);
+    // clear inner structures (vectors)
     sources.clear(); import_stack.clear();
   }
 
@@ -221,58 +256,45 @@ namespace Sass {
     include_links.push_back(resolve_relative_path(abs_path, source_map_file, cwd));
   }
 
-  string Context::add_file(string path)
+  // Add a new import file to the context
+  string Context::add_file(const string& file)
   {
     using namespace File;
-    char* contents = 0;
-    string real_path;
-    path = make_canonical_path(path);
-    for (size_t i = 0, S = include_paths.size(); i < S; ++i) {
-      string full_path(join_paths(include_paths[i], path));
-      if (style_sheets.count(full_path)) return full_path;
-      contents = resolve_and_load(full_path, real_path);
-      if (contents) {
-        add_source(full_path, real_path, contents);
-        style_sheets[full_path] = 0;
-        return full_path;
-      }
+    string path(make_canonical_path(file));
+    string resolved(find_file(path, include_paths));
+    if (resolved == "") return resolved;
+    if (char* contents = read_file(resolved)) {
+      add_source(path, resolved, contents);
+      style_sheets[path] = 0;
+      return path;
     }
-    return string();
+    return string("");
   }
 
-  string Context::add_file(string dir, string rel_filepath)
+  // Add a new import file to the context
+  // This has some previous directory context
+  string Context::add_file(const string& base, const string& file)
   {
     using namespace File;
-    char* contents = 0;
-    string real_path;
-    rel_filepath = make_canonical_path(rel_filepath);
-    string full_path(join_paths(dir, rel_filepath));
-    if (style_sheets.count(full_path)) return full_path;
-    contents = resolve_and_load(full_path, real_path);
-    if (contents) {
-      add_source(full_path, real_path, contents);
-      style_sheets[full_path] = 0;
-      return full_path;
-    }
-    for (size_t i = 0, S = include_paths.size(); i < S; ++i) {
-      string full_path(join_paths(include_paths[i], rel_filepath));
-      if (style_sheets.count(full_path)) return full_path;
-      contents = resolve_and_load(full_path, real_path);
-      if (contents) {
-        add_source(full_path, real_path, contents);
-        style_sheets[full_path] = 0;
-        return full_path;
-      }
+    string path(make_canonical_path(file));
+    string base_file(join_paths(base, path));
+    string resolved(resolve_file(base_file));
+    if (style_sheets.count(base_file)) return base_file;
+    if (char* contents = read_file(resolved)) {
+      add_source(base_file, resolved, contents);
+      style_sheets[base_file] = 0;
+      return base_file;
     }
-    return string();
+    // now go the regular code path
+    return add_file(path);
   }
 
   void register_function(Context&, Signature sig, Native_Function f, Env* env);
   void register_function(Context&, Signature sig, Native_Function f, size_t arity, Env* env);
   void register_overload_stub(Context&, string name, Env* env);
   void register_built_in_functions(Context&, Env* env);
-  void register_c_functions(Context&, Env* env, Sass_C_Function_List);
-  void register_c_function(Context&, Env* env, Sass_C_Function_Callback);
+  void register_c_functions(Context&, Env* env, Sass_Function_List);
+  void register_c_function(Context&, Env* env, Sass_Function_Entry);
 
   char* Context::compile_block(Block* root)
   {
@@ -291,13 +313,13 @@ namespace Sass {
   {
     Block* root = 0;
     for (size_t i = 0; i < queue.size(); ++i) {
-      struct Sass_Import* import = sass_make_import(
+      Sass_Import_Entry import = sass_make_import(
         queue[i].load_path.c_str(),
         queue[i].abs_path.c_str(),
         0, 0
       );
       import_stack.push_back(import);
-      Parser p(Parser::from_c_str(queue[i].source, *this, ParserState(queue[i].abs_path, i)));
+      Parser p(Parser::from_c_str(queue[i].source, *this, ParserState(queue[i].abs_path, queue[i].source, i)));
       Block* ast = p.parse();
       sass_delete_import(import_stack.back());
       import_stack.pop_back();
@@ -311,9 +333,11 @@ namespace Sass {
     for (size_t i = 0, S = c_functions.size(); i < S; ++i) {
       register_c_function(*this, &tge, c_functions[i]);
     }
-    Eval eval(*this, &tge, &backtrace);
-    Contextualize contextualize(*this, &eval, &tge, &backtrace);
-    Expand expand(*this, &eval, &contextualize, &tge, &backtrace);
+    Contextualize contextualize(*this, &tge, &backtrace);
+    Listize listize(*this);
+    Eval eval(*this, &contextualize, &listize, &tge, &backtrace);
+    Contextualize_Eval contextualize_eval(*this, &eval, &tge, &backtrace);
+    Expand expand(*this, &eval, &contextualize_eval, &tge, &backtrace);
     Cssize cssize(*this, &tge, &backtrace);
     root = root->perform(&expand)->block();
     root = root->perform(&cssize)->block();
@@ -382,7 +406,9 @@ namespace Sass {
   std::vector<std::string> Context::get_included_files(size_t skip)
   {
       vector<string> includes = included_files;
+      if (includes.size() == 0) return includes;
       std::sort( includes.begin() + skip, includes.end() );
+      includes.erase( includes.begin(), includes.begin() + skip );
       includes.erase( std::unique( includes.begin(), includes.end() ), includes.end() );
       // the skip solution seems more robust, as we may have real files named stdin
       // includes.erase( std::remove( includes.begin(), includes.end(), "stdin" ), includes.end() );
@@ -417,6 +443,7 @@ namespace Sass {
                                             name,
                                             0,
                                             0,
+                                            &ctx,
                                             true);
     (*env)[name + "[f]"] = stub;
   }
@@ -515,21 +542,16 @@ namespace Sass {
     register_function(ctx, unique_id_sig, unique_id, env);
   }
 
-  void register_c_functions(Context& ctx, Env* env, Sass_C_Function_List descrs)
+  void register_c_functions(Context& ctx, Env* env, Sass_Function_List descrs)
   {
     while (descrs && *descrs) {
       register_c_function(ctx, env, *descrs);
       ++descrs;
     }
   }
-  void register_c_function(Context& ctx, Env* env, Sass_C_Function_Callback descr)
+  void register_c_function(Context& ctx, Env* env, Sass_Function_Entry descr)
   {
-    Definition* def = make_c_function(
-      sass_function_get_signature(descr),
-      sass_function_get_function(descr),
-      sass_function_get_cookie(descr),
-      ctx
-    );
+    Definition* def = make_c_function(descr, ctx);
     def->environment(env);
     (*env)[def->name() + "[f]"] = def;
   }