sassc 1.8.3 → 1.8.4

data/ext/libsass/src/base64vlq.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include "base64vlq.hpp"
 
 namespace Sass {

data/ext/libsass/src/bind.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include "bind.hpp"
 #include "ast.hpp"
 #include "context.hpp"
@@ -5,14 +6,14 @@
 #include <map>
 #include <iostream>
 #include <sstream>
-#include "to_string.hpp"
 
 namespace Sass {
 
   void bind(std::string type, std::string name, Parameters* ps, Arguments* as, Context* ctx, Env* env, Eval* eval)
   {
     std::string callee(type + " " + name);
-    Listize listize(*ctx);
+
+    Listize listize(ctx->mem);
     std::map<std::string, Parameter*> param_map;
 
     for (size_t i = 0, L = as->length(); i < L; ++i) {
@@ -60,18 +61,9 @@ namespace Sass {
       if (p->is_rest_parameter()) {
         // The next argument by coincidence provides a rest argument
         if (a->is_rest_argument()) {
+
           // We should always get a list for rest arguments
           if (List* rest = dynamic_cast<List*>(a->value())) {
-            // arg contains a list
-            List* args = rest;
-            // make sure it's an arglist
-            if (rest->is_arglist()) {
-              // can pass it through as it was
-              env->local_frame()[p->name()] = args;
-            }
-            // create a new list and wrap each item as an argument
-            // otherwise we will not be able to fetch it again
-            else {
               // create a new list object for wrapped items
               List* arglist = SASS_MEMORY_NEW(ctx->mem, List,
                                               p->pstate(),
@@ -80,17 +72,20 @@ namespace Sass {
                                               true);
               // wrap each item from list as an argument
               for (Expression* item : rest->elements()) {
-                (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
-                                              item->pstate(),
-                                              item,
-                                              "",
-                                              false,
-                                              false);
+                if (Argument* arg = dynamic_cast<Argument*>(item)) {
+                  (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument, *arg);
+                } else {
+                  (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
+                                                item->pstate(),
+                                                item,
+                                                "",
+                                                false,
+                                                false);
+                }
               }
               // assign new arglist to environment
               env->local_frame()[p->name()] = arglist;
             }
-          }
           // invalid state
           else {
             throw std::runtime_error("invalid state");
@@ -127,27 +122,27 @@ namespace Sass {
             List* ls = dynamic_cast<List*>(a->value());
             // skip any list completely if empty
             if (ls && ls->empty() && a->is_rest_argument()) continue;
-            // flatten all nested arglists
-            if (ls && ls->is_arglist()) {
-              for (size_t i = 0, L = ls->size(); i < L; ++i) {
-                // already have a wrapped argument
-                if (Argument* arg = dynamic_cast<Argument*>((*ls)[i])) {
-                  (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument, *arg);
-                }
-                // wrap all other value types into Argument
-                else {
+
+            if (Argument* arg = dynamic_cast<Argument*>(a->value())) {
+              (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument, *arg);
+            }
+            // check if we have rest argument
+            else if (a->is_rest_argument()) {
+              // preserve the list separator from rest args
+              if (List* rest = dynamic_cast<List*>(a->value())) {
+                arglist->separator(rest->separator());
+
+                for (size_t i = 0, L = rest->size(); i < L; ++i) {
                   (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
-                                                (*ls)[i]->pstate(),
-                                                (*ls)[i],
+                                                (*rest)[i]->pstate(),
+                                                (*rest)[i],
                                                 "",
                                                 false,
                                                 false);
                 }
               }
-            }
-            // already have a wrapped argument
-            else if (Argument* arg = dynamic_cast<Argument*>(a->value())) {
-              (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument, *arg);
+              // no more arguments
+              break;
             }
             // wrap all other value types into Argument
             else {
@@ -158,15 +153,6 @@ namespace Sass {
                                             false,
                                             false);
             }
-            // check if we have rest argument
-            if (a->is_rest_argument()) {
-              // preserve the list separator from rest args
-              if (List* rest = dynamic_cast<List*>(a->value())) {
-                arglist->separator(rest->separator());
-              }
-              // no more arguments
-              break;
-            }
           }
           // assign new arglist to environment
           env->local_frame()[p->name()] = arglist;
@@ -185,7 +171,7 @@ namespace Sass {
         if (!arglist->length()) {
           break;
         } else {
-          if (arglist->length() + ia > LP && !ps->has_rest_parameter()) {
+          if (arglist->length() > LP - ip && !ps->has_rest_parameter()) {
             int arg_count = (arglist->length() + LA - 1);
             std::stringstream msg;
             msg << callee << " takes " << LP;
@@ -193,6 +179,10 @@ namespace Sass {
             msg << " but " << arg_count;
             msg << (arg_count == 1 ? " was passed" : " were passed.");
             deprecated_bind(msg.str(), as->pstate());
+
+            while (arglist->length() > LP - ip) {
+              arglist->elements().erase(arglist->elements().end() - 1);
+            }
           }
         }
         // otherwise move one of the rest args into the param, converting to argument if necessary
@@ -209,6 +199,7 @@ namespace Sass {
         if (!arglist->length() || (!arglist->is_arglist() && ip + 1 == LP)) {
           ++ia;
         }
+
       } else if (a->is_keyword_argument()) {
         Map* argmap = static_cast<Map*>(a->value());
 
@@ -267,7 +258,6 @@ namespace Sass {
     // That's only okay if they have default values, or were already bound by
     // named arguments, or if it's a single rest-param.
     for (size_t i = ip; i < LP; ++i) {
-      To_String to_string(ctx);
       Parameter* leftover = (*ps)[i];
       // cerr << "env for default params:" << endl;
       // env->print();

data/ext/libsass/src/bind.hpp

@@ -2,6 +2,7 @@
 #define SASS_BIND_H
 
 #include <string>
+#include "listize.hpp"
 #include "environment.hpp"
 
 namespace Sass {

data/ext/libsass/src/color_maps.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include "ast.hpp"
 #include "color_maps.hpp"
 

data/ext/libsass/src/constants.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include "constants.hpp"
 
 namespace Sass {
@@ -78,7 +79,7 @@ namespace Sass {
     extern const char keyframes_kwd[]    = "keyframes";
     extern const char only_kwd[]         = "only";
     extern const char rgb_kwd[]          = "rgb(";
-    extern const char url_kwd[]          = "url(";
+    extern const char url_kwd[]          = "url";
     // extern const char url_prefix_kwd[]   = "url-prefix(";
     extern const char important_kwd[]    = "important";
     extern const char pseudo_not_kwd[]   = ":not(";
@@ -86,6 +87,7 @@ namespace Sass {
     extern const char odd_kwd[]          = "odd";
     extern const char progid_kwd[]       = "progid";
     extern const char expression_kwd[]   = "expression";
+    extern const char calc_fn_kwd[]      = "calc";
     extern const char calc_kwd[]         = "calc(";
     extern const char moz_calc_kwd[]     = "-moz-calc(";
     extern const char webkit_calc_kwd[]  = "-webkit-calc(";
@@ -124,6 +126,7 @@ namespace Sass {
     extern const char rbrace[]          = "}";
     extern const char rparen[]          = ")";
     extern const char sign_chars[]      = "-+";
+    extern const char op_chars[]        = "-+";
     extern const char hyphen[]          = "-";
     extern const char ellipsis[]        = "...";
     // extern const char url_space_chars[] = " \t\r\n\f";

data/ext/libsass/src/constants.hpp

@@ -81,7 +81,6 @@ namespace Sass {
     extern const char rgb_kwd[];
     extern const char url_kwd[];
     // extern const char url_prefix_kwd[];
-    extern const char image_url_kwd[];
     extern const char important_kwd[];
     extern const char pseudo_not_kwd[];
     extern const char even_kwd[];
@@ -89,6 +88,7 @@ namespace Sass {
     extern const char progid_kwd[];
     extern const char expression_kwd[];
     extern const char calc_kwd[];
+    extern const char calc_fn_kwd[];
     extern const char moz_calc_kwd[];
     extern const char webkit_calc_kwd[];
     extern const char ms_calc_kwd[];
@@ -126,6 +126,7 @@ namespace Sass {
     extern const char rbrace[];
     extern const char rparen[];
     extern const char sign_chars[];
+    extern const char op_chars[];
     extern const char hyphen[];
     extern const char ellipsis[];
     // extern const char url_space_chars[];

data/ext/libsass/src/context.cpp

@@ -1,9 +1,4 @@
-#ifdef _WIN32
-#define PATH_SEP ';'
-#else
-#define PATH_SEP ':'
-#endif
-
+#include "sass.hpp"
 #include <string>
 #include <cstdlib>
 #include <cstring>
@@ -28,6 +23,7 @@
 #include "extend.hpp"
 #include "remove_placeholders.hpp"
 #include "functions.hpp"
+#include "sass_functions.hpp"
 #include "backtrace.hpp"
 #include "sass2scss.h"
 #include "prelexer.hpp"
@@ -62,13 +58,14 @@ namespace Sass {
     return safe_path == "" ? "stdout" : safe_path;
   }
 
-  Context::Context(struct Sass_Context* c_ctx)
+  Context::Context(struct Sass_Context& c_ctx)
   : CWD(File::get_cwd()),
+    c_options(c_ctx),
     entry_path(""),
     head_imports(0),
     mem(Memory_Manager()),
     plugins(),
-    emitter(this),
+    emitter(c_options),
 
     strings(),
     resources(),
@@ -76,19 +73,17 @@ namespace Sass {
     subset_map(),
     import_stack(),
 
-    c_options               (c_ctx),
-
     c_headers               (std::vector<Sass_Importer_Entry>()),
     c_importers             (std::vector<Sass_Importer_Entry>()),
     c_functions             (std::vector<Sass_Function_Entry>()),
 
-    indent                  (safe_str(c_options->indent, "  ")),
-    linefeed                (safe_str(c_options->linefeed, "\n")),
+    indent                  (safe_str(c_options.indent, "  ")),
+    linefeed                (safe_str(c_options.linefeed, "\n")),
 
-    input_path              (make_canonical_path(safe_input(c_options->input_path))),
-    output_path             (make_canonical_path(safe_output(c_options->output_path, input_path))),
-    source_map_file         (make_canonical_path(safe_str(c_options->source_map_file, ""))),
-    source_map_root         (make_canonical_path(safe_str(c_options->source_map_root, "")))
+    input_path              (make_canonical_path(safe_input(c_options.input_path))),
+    output_path             (make_canonical_path(safe_output(c_options.output_path, input_path))),
+    source_map_file         (make_canonical_path(safe_str(c_options.source_map_file, ""))),
+    source_map_root         (make_canonical_path(safe_str(c_options.source_map_root, "")))
 
   {
 
@@ -96,10 +91,10 @@ namespace Sass {
     include_paths.push_back(CWD);
 
     // collect more paths from different options
-    collect_include_paths(sass_option_get_include_path(c_options));
-    // collect_include_paths(initializers.include_paths_array());
-    collect_plugin_paths(sass_option_get_plugin_path(c_options));
-    // collect_plugin_paths(initializers.plugin_paths_array());
+    collect_include_paths(c_options.include_path);
+    // collect_include_paths(c_options.include_paths);
+    collect_plugin_paths(c_options.plugin_path);
+    // collect_plugin_paths(c_options.plugin_paths);
 
     // load plugins and register custom behaviors
     for(auto plug : plugin_paths) plugins.load_plugins(plug);
@@ -254,7 +249,7 @@ namespace Sass {
 
   // register include with resolved path and its content
   // memory of the resources will be freed by us on exit
-  void Context::register_resource(const Include& inc, const Resource& res)
+  void Context::register_resource(const Include& inc, const Resource& res, ParserState* prstate)
   {
 
     // do not parse same resource twice
@@ -297,6 +292,24 @@ namespace Sass {
     strings.push_back(sass_strdup(inc.abs_path.c_str()));
     // create the initial parser state from resource
     ParserState pstate(strings.back(), contents, idx);
+
+    // check existing import stack for possible recursion
+    for (size_t i = 0; i < import_stack.size() - 2; ++i) {
+      auto parent = import_stack[i];
+      if (std::strcmp(parent->abs_path, import->abs_path) == 0) {
+        std::string stack("An @import loop has been found:");
+        for (size_t n = 1; n < i + 2; ++n) {
+          stack += "\n    " + std::string(import_stack[n]->imp_path) +
+            " imports " + std::string(import_stack[n+1]->imp_path);
+        }
+        // implement error throw directly until we
+        // decided how to handle full stack traces
+        ParserState state = prstate ? *prstate : pstate;
+        throw Exception::InvalidSyntax(state, stack, &import_stack);
+        // error(stack, prstate ? *prstate : pstate, import_stack);
+      }
+    }
+
     // create a parser instance from the given c_str buffer
     Parser p(Parser::from_c_str(contents, *this, pstate));
     // do not yet dispose these buffers
@@ -344,7 +357,7 @@ namespace Sass {
       // the memory buffer returned must be freed by us!
       if (char* contents = read_file(resolved[0].abs_path)) {
         // register the newly resolved file resource
-        register_resource(resolved[0], { contents, 0 });
+        register_resource(resolved[0], { contents, 0 }, &pstate);
         // return resolved entry
         return resolved[0];
       }
@@ -365,10 +378,7 @@ namespace Sass {
     if (const char* proto = sequence< identifier, exactly<':'>, exactly<'/'>, exactly<'/'> >(imp_path.c_str())) {
 
       protocol = std::string(imp_path.c_str(), proto - 3);
-      // std::cerr << "==================== " << protocol << "\n";
-      if (protocol.compare("file") && true) {
-
-      }
+      // if (protocol.compare("file") && true) { }
     }
 
     // add urls (protocol other than file) and urls without procotol to `urls` member
@@ -433,7 +443,7 @@ namespace Sass {
           // handle error message passed back from custom importer
           // it may (or may not) override the line and column info
           if (const char* err_message = sass_import_get_error_message(include)) {
-            if (source || srcmap) register_resource({ importer, uniq_path }, { source, srcmap });
+            if (source || srcmap) register_resource({ importer, uniq_path }, { source, srcmap }, &pstate);
             if (line == std::string::npos && column == std::string::npos) error(err_message, pstate);
             else error(err_message, ParserState(ctx_path, source, Position(line, column)));
           }
@@ -447,7 +457,7 @@ namespace Sass {
             // attach information to AST node
             imp->incs().push_back(include);
             // register the resource buffers
-            register_resource(include, { source, srcmap });
+            register_resource(include, { source, srcmap }, &pstate);
           }
           // only a path was retuned
           // try to load it like normal
@@ -494,9 +504,9 @@ namespace Sass {
     // get the resulting buffer from stream
     OutputBuffer emitted = emitter.get_buffer();
     // should we append a source map url?
-    if (!c_options->omit_source_map_url) {
+    if (!c_options.omit_source_map_url) {
       // generate an embeded source map
-      if (c_options->source_map_embed) {
+      if (c_options.source_map_embed) {
         emitted.buffer += linefeed;
         emitted.buffer += format_embedded_source_map();
       }
@@ -581,7 +591,7 @@ namespace Sass {
     if (!source_c_str) return 0;
 
     // convert indented sass syntax
-    if(c_options->is_indented_syntax_src) {
+    if(c_options.is_indented_syntax_src) {
       // call sass2scss to convert the string
       char * converted = sass2scss(source_c_str,
         // preserve the structure as much as possible

data/ext/libsass/src/context.hpp

@@ -38,6 +38,7 @@ namespace Sass {
 
   public:
     const std::string CWD;
+    struct Sass_Options& c_options;
     std::string entry_path;
     size_t head_imports;
     Memory_Manager mem;
@@ -53,7 +54,6 @@ namespace Sass {
     std::vector<Sass_Import_Entry> import_stack;
 
     struct Sass_Compiler* c_compiler;
-    struct Sass_Options* c_options;
 
     // absolute paths to includes
     std::vector<std::string> included_files;
@@ -86,17 +86,17 @@ namespace Sass {
     const std::string source_map_root; // path for sourceRoot property (pass-through)
 
     virtual ~Context();
-    Context(struct Sass_Context*);
+    Context(struct Sass_Context&);
     virtual Block* parse() = 0;
     virtual Block* compile();
     virtual char* render(Block* root);
     virtual char* render_srcmap();
 
-    void register_resource(const Include&, const Resource&);
+    void register_resource(const Include&, const Resource&, ParserState* = 0);
     std::vector<Include> find_includes(const Importer& import);
     Include load_import(const Importer&, ParserState pstate);
 
-    Sass_Output_Style output_style() { return c_options->output_style; };
+    Sass_Output_Style output_style() { return c_options.output_style; };
     std::vector<std::string> get_included_files(bool skip = false, size_t headers = 0);
 
   private:
@@ -119,7 +119,7 @@ namespace Sass {
 
   class File_Context : public Context {
   public:
-    File_Context(struct Sass_File_Context* ctx)
+    File_Context(struct Sass_File_Context& ctx)
     : Context(ctx)
     { }
     virtual ~File_Context();
@@ -130,13 +130,13 @@ namespace Sass {
   public:
     char* source_c_str;
     char* srcmap_c_str;
-    Data_Context(struct Sass_Data_Context* ctx)
+    Data_Context(struct Sass_Data_Context& ctx)
     : Context(ctx)
     {
-      source_c_str       = ctx->source_string;
-      srcmap_c_str       = ctx->srcmap_string;
-      ctx->source_string = 0; // passed away
-      ctx->srcmap_string = 0; // passed away
+      source_c_str       = ctx.source_string;
+      srcmap_c_str       = ctx.srcmap_string;
+      ctx.source_string = 0; // passed away
+      ctx.srcmap_string = 0; // passed away
     }
     virtual ~Data_Context();
     virtual Block* parse();