sassc 1.7.1 → 1.8.0.pre1

data/ext/libsass/src/ast_def_macros.hpp

@@ -0,0 +1,47 @@
+#ifndef SASS_AST_DEF_MACROS_H
+#define SASS_AST_DEF_MACROS_H
+
+// Helper class to switch a flag and revert once we go out of scope
+template <class T>
+class LocalOption {
+  private:
+    T* var; // pointer to original variable
+    T orig; // copy of the original option
+  public:
+    LocalOption(T& var)
+    {
+      this->var = &var;
+      this->orig = var;
+    }
+    LocalOption(T& var, T orig)
+    {
+      this->var = &var;
+      this->orig = var;
+      *(this->var) = orig;
+    }
+    ~LocalOption() {
+      *(this->var) = this->orig;
+    }
+};
+
+#define LOCAL_FLAG(name,opt) LocalOption<bool> flag_##name(name, opt)
+
+#define ATTACH_OPERATIONS()\
+virtual void perform(Operation<void>* op) { (*op)(this); }\
+virtual AST_Node* perform(Operation<AST_Node*>* op) { return (*op)(this); }\
+virtual Statement* perform(Operation<Statement*>* op) { return (*op)(this); }\
+virtual Expression* perform(Operation<Expression*>* op) { return (*op)(this); }\
+virtual Selector* perform(Operation<Selector*>* op) { return (*op)(this); }\
+virtual std::string perform(Operation<std::string>* op) { return (*op)(this); }\
+virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) { return (*op)(this); }\
+virtual Value* perform(Operation<Value*>* op) { return (*op)(this); }
+
+#define ADD_PROPERTY(type, name)\
+protected:\
+  type name##_;\
+public:\
+  type name() const        { return name##_; }\
+  type name(type name##__) { return name##_ = name##__; }\
+private:
+
+#endif

data/ext/libsass/src/ast_factory.hpp

@@ -0,0 +1,93 @@
+#ifndef SASS_AST_FACTORY_H
+#define SASS_AST_FACTORY_H
+
+#include <vector>
+
+#include "ast.hpp"
+
+namespace Sass {
+
+  class AST_Factory {
+    std::vector<AST_Node*> nodes;
+  public:
+    // statements
+    Block* new_Block(std::string p, size_t l, size_t s = 0, bool r = false);
+    Ruleset* new_Ruleset(std::string p, size_t l, Selector* s, Block* b);
+    Propset* new_Propset(std::string p, size_t l, String* pf, Block* b);
+    Supports_Query* new_Supports_Query(std::string p, size_t l, Supports_Query* f, Block* b);
+    Media_Query* new_Media_Query(std::string p, size_t l, List* q, Block* b);
+    At_Root_Block* new_At_Root_Block(std::string p, size_t l, Selector* sel, Block* b);
+    At_Rule* new_At_Rule(std::string p, size_t l, std::string kwd, Selector* sel, Block* b);
+    Keyframe_Rule* new_Keyframe_Rule(std::string p, size_t l, Block* b);
+    Declaration* new_Declaration(std::string p, size_t l, String* prop, List* vals);
+    Assignment* new_Assignment(std::string p, size_t l, std::string var, Expression* val, bool guarded = false);
+    Import<Function_Call*>* new_CSS_Import(std::string p, size_t l, Function_Call* loc);
+    Import<String*>* new_SASS_Import(std::string p, size_t l, String* loc);
+    Custom_Warning* new_Custom_Warning(std::string msg, size_t l, std::string msg);
+    Custom_Error* new_Custom_Error(std::string p, size_t l, std::string msg);
+    Warning* new_Warning(std::string p, size_t l, Expression* msg);
+    Error* new_Error(std::string p, size_t l, Expression* msg);
+    Debug* new_Debug(std::string p, size_t l, Expression* val);
+    Comment* new_Comment(std::string p, size_t l, String* txt);
+    If* new_If(std::string p, size_t l, Expression* pred, Block* con, Block* alt = 0);
+    For* new_For(std::string p, size_t l, std::string var, Expression* lo, Expression* hi, Block* b, bool inc);
+    Each* new_Each(std::string p, size_t l, std::vector<std::string> vars, Expression* lst, Block* b);
+    While* new_While(std::string p, size_t l, Expression* pred, Block* b);
+    Extension* new_Extension(std::string p, size_t l, Selector* s);
+    Definition<MIXIN>* new_Mixin_Definition(std::string p, size_t l, std::string n, Parameters* params, Block* b);
+    Definition<FUNCTION>* new_Function_Definition(std::string p, size_t l, std::string n, Parameters* params, Block* b);
+    Mixin_Call* new_Mixin_Call(std::string p, size_t l, std::string n, Arguments* args, Block* b = 0);
+    // expressions
+    List* new_List(std::string p, size_t l, size_t size = 0, enum Sass_Separator sep = List::space, bool argl = false);
+    Map* new_Map(std::string p, size_t l, size_t size = 0);
+    Binary_Expression<AND>* new_And(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<OR>* new_Or(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<EQ>* new_Eq(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<NEQ>* new_Neq(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<GT>* new_Gt(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<GTE>* new_Gte(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<LT>* new_Lt(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<LTE>* new_Lte(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<ADD>* new_Add(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<SUB>* new_Sub(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<MUL>* new_Mul(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Binary_Expression<DIV>* new_Div(std::string p, size_t l, Expression* lhs, Expression* rhs);
+    Negation* new_Negation(std::string p, size_t l, Expression* o);
+    Function_Call* new_Function_Call(std::string p, size_t l, String* n, Arguments* args);
+    Variable* new_Variable(std::string p, size_t l, std::string n);
+    Textual<NUMBER>* new_Textual_Number(std::string p, size_t l, std::string val);
+    Textual<PERCENTAGE>* new_Textual_Percentage(std::string p, size_t l, std::string val);
+    Textual<DIMENSION>* new_Textual_Dimension(std::string p, size_t l, std::string val);
+    Textual<HEX>* new_Textual_Hex(std::string p, size_t l, std::string val);
+    Number* new_Number(std::string p, size_t l, double val);
+    Percentage* new_Percentage(std::string p, size_t l, double val);
+    Dimension* new_Dimension(std::string p, size_t l, double val, std::string unit);
+    Color* new_Color(std::string p, size_t l, double r, double g, double b, double a = 1, std::string disp = "");
+    Boolean* new_Boolean(std::string p, size_t l, bool val);
+    String_Schema* new_String_Schema(std::string p, size_t l, size_t size = 0);
+    String_Constant* new_String_Constant(std::string p, size_t l, std::string val);
+    String_Constant* new_String_Constant(std::string p, size_t l, const char* beg);
+    String_Constant* new_String_Constant(std::string p, size_t l, const char* beg, const char* end);
+    Supports_Condition* new_Supports_Condition(std::string p, size_t l, String* f, Expression* v);
+    Media_Expression* new_Media_Expression(std::string p, size_t l, String* f, Expression* v);
+    Parent_Selector* new_Parent_Selector(std::string p, size_t l, Selector* s);
+    // parameters and arguments
+    Parameter* new_Parameter(std::string p, size_t l, std::string n, Expression* def = 0, bool rest = false);
+    Parameters* new_Parameters(std::string p, size_t l);
+    Argument* new_Argument(std::string p, size_t l, Expression* val, std::string n = "", bool rest = false);
+    Arguments* new_Arguments(std::string p, size_t l);
+    // selectors
+    Selector_Schema* new_Selector_Schema(std::string p, size_t l, String* c);
+    Attribute_Selector* new_Attribute_Selector(std::string p, size_t l, std::string n, std::string m, String* v);
+    Simple_Selector* new_Simple_Selector(std::string p, size_t l, std::string c);
+    Reference_Selector* new_Reference_Selector(std::string p, size_t l);
+    Placeholder_Selector* new_Placeholder_Selector(std::string p, size_t l, std::string n);
+    Pseudo_Selector* new_Pseudo_Selector(std::string p, size_t l, std::string n, Expression* expr = 0);
+    Wrapped_Selector* new_Wrapped_Selector(std::string p, size_t l, std::string n, Simple_Base* sel);
+    Compound_Selector* new_Compound_Selector(std::string p, size_t l, size_t s = 0);
+    Complex_Selector* new_Complex_Selector(std::string p, size_t l, Complex_Selector::Combinator c, Complex_Selector* ctx, Compound_Selector* sel);
+    Selector_List* new_Selector_List(std::string p, size_t l, size_t s = 0);
+  };
+}
+
+#endif

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

@@ -16,7 +16,7 @@ namespace Sass {
   class Propset;
   class Bubble;
   class Media_Block;
-  class Feature_Block;
+  class Supports_Block;
   class At_Rule;
   class Keyframe_Rule;
   class At_Root_Block;
@@ -38,6 +38,7 @@ namespace Sass {
   class Definition;
   class Mixin_Call;
   // expressions
+  class Value;
   class Expression;
   class List;
   class Map;
@@ -45,6 +46,8 @@ namespace Sass {
   class Unary_Expression;
   class Function_Call;
   class Function_Call_Schema;
+  class Custom_Warning;
+  class Custom_Error;
   class Variable;
   class Textual;
   class Number;
@@ -56,8 +59,11 @@ namespace Sass {
   class String_Quoted;
   class Media_Query;
   class Media_Query_Expression;
-  class Feature_Query;
-  class Feature_Query_Condition;
+  class Supports_Condition;
+  class Supports_Operator;
+  class Supports_Negation;
+  class Supports_Declaration;
+  class Supports_Interpolation;
   class At_Root_Expression;
   class Null;
   class Parent_Selector;
@@ -69,7 +75,6 @@ namespace Sass {
   // selectors
   class Selector;
   class Selector_Schema;
-  class Selector_Reference;
   class Selector_Placeholder;
   class Type_Selector;
   class Selector_Qualifier;

data/ext/libsass/{b64 → src/b64}/cencode.h

@@ -10,7 +10,7 @@ For details, see http://sourceforge.net/projects/libb64
 
 typedef enum
 {
-	step_A, step_B, step_C
+  step_A, step_B, step_C
 } base64_encodestep;
 
 typedef struct

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

@@ -8,36 +8,35 @@
 
 namespace Sass {
 
-  using namespace std;
 
   struct Backtrace {
 
     Backtrace*  parent;
     ParserState pstate;
-    string      caller;
+    std::string      caller;
 
-    Backtrace(Backtrace* prn, ParserState pstate, string c)
+    Backtrace(Backtrace* prn, ParserState pstate, std::string c)
     : parent(prn),
       pstate(pstate),
       caller(c)
     { }
 
-    string to_string(bool warning = false)
+    std::string to_string(bool warning = false)
     {
       size_t i = -1;
-      stringstream ss;
-      string cwd(Sass::File::get_cwd());
+      std::stringstream ss;
+      std::string cwd(Sass::File::get_cwd());
       Backtrace* this_point = this;
 
-      if (!warning) ss << endl << "Backtrace:";
+      if (!warning) ss << std::endl << "Backtrace:";
       // the first tracepoint (which is parent-less) is an empty placeholder
       while (this_point->parent) {
 
         // make path relative to the current directory
-        string rel_path(Sass::File::resolve_relative_path(this_point->pstate.path, cwd, cwd));
+        std::string rel_path(Sass::File::resolve_relative_path(this_point->pstate.path, cwd, cwd));
 
         if (warning) {
-          ss << endl
+          ss << std::endl
              << "\t"
              << (++i == 0 ? "on" : "from")
              << " line "
@@ -45,7 +44,7 @@ namespace Sass {
              << " of "
              << rel_path;
         } else {
-          ss << endl
+          ss << std::endl
              << "\t"
              << rel_path
              << ":"

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

@@ -2,9 +2,9 @@
 
 namespace Sass {
 
-  string Base64VLQ::encode(const int number) const
+  std::string Base64VLQ::encode(const int number) const
   {
-    string encoded = "";
+    std::string encoded = "";
 
     int vlq = to_vlq_signed(number);
 

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

@@ -4,13 +4,12 @@
 #include <string>
 
 namespace Sass {
-  using std::string;
 
   class Base64VLQ {
 
   public:
 
-    string encode(const int number) const;
+    std::string encode(const int number) const;
 
   private:
 

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

@@ -8,11 +8,21 @@
 #include "to_string.hpp"
 
 namespace Sass {
-  using namespace std;
 
-  void bind(string callee, Parameters* ps, Arguments* as, Context& ctx, Env* env, Eval* eval)
+  void bind(std::string callee, Parameters* ps, Arguments* as, Context& ctx, Env* env, Eval* eval)
   {
-    map<string, Parameter*> param_map;
+    Listize listize(ctx);
+    std::map<std::string, Parameter*> param_map;
+
+    for (size_t i = 0, L = as->length(); i < L; ++i) {
+      if (auto str = dynamic_cast<String_Quoted*>((*as)[i]->value())) {
+        // force optional quotes (only if needed)
+        if (str->quote_mark()) {
+          str->quote_mark('*');
+          str->is_delayed(true);
+        }
+      }
+    }
 
     // Set up a map to ensure named arguments refer to actual parameters. Also
     // eval each default value left-to-right, wrt env, populating env as we go.
@@ -29,6 +39,8 @@ namespace Sass {
     size_t ia = 0, LA = as->length();
     while (ia < LA) {
       Argument* a = (*as)[ia];
+      // this is only needed for selectors
+      a->value(a->value()->perform(&listize));
       if (ip >= LP) {
         // skip empty rest arguments
         if (a->is_rest_argument()) {
@@ -38,7 +50,7 @@ namespace Sass {
             }
           }
         }
-        stringstream msg;
+        std::stringstream msg;
         msg << callee << " only takes " << LP << " arguments; "
             << "given " << LA;
         error(msg.str(), as->pstate());
@@ -62,17 +74,19 @@ namespace Sass {
             // otherwise we will not be able to fetch it again
             else {
               // create a new list object for wrapped items
-              List* arglist = new (ctx.mem) List(p->pstate(),
-                                                 0,
-                                                 rest->separator(),
-                                                 true);
+              List* arglist = SASS_MEMORY_NEW(ctx.mem, List,
+                                              p->pstate(),
+                                              0,
+                                              rest->separator(),
+                                              true);
               // wrap each item from list as an argument
               for (Expression* item : rest->elements()) {
-                (*arglist) << new (ctx.mem) Argument(item->pstate(),
-                                                     item,
-                                                     "",
-                                                     false,
-                                                     false);
+                (*arglist) << SASS_MEMORY_NEW(ctx.mem, Argument,
+                                              item->pstate(),
+                                              item,
+                                              "",
+                                              false,
+                                              false);
               }
               // assign new arglist to environment
               env->local_frame()[p->name()] = arglist;
@@ -80,40 +94,71 @@ namespace Sass {
           }
           // invalid state
           else {
-            throw runtime_error("invalid state");
+            throw std::runtime_error("invalid state");
           }
         } else if (a->is_keyword_argument()) {
 
           // expand keyword arguments into their parameters
-          List* arglist = new (ctx.mem) List(p->pstate(), 0, List::COMMA, true);
+          List* arglist = SASS_MEMORY_NEW(ctx.mem, List, p->pstate(), 0, SASS_COMMA, true);
           env->local_frame()[p->name()] = arglist;
           Map* argmap = static_cast<Map*>(a->value());
           for (auto key : argmap->keys()) {
-            string name = unquote(static_cast<String_Constant*>(key)->value());
-            (*arglist) << new (ctx.mem) Argument(key->pstate(),
-                                                 argmap->at(key),
-                                                 name,
-                                                 false,
-                                                 false);
+            std::string name = unquote(static_cast<String_Constant*>(key)->value());
+            (*arglist) << SASS_MEMORY_NEW(ctx.mem, Argument,
+                                          key->pstate(),
+                                          argmap->at(key),
+                                          "$" + name,
+                                          false,
+                                          false);
           }
 
         } else {
 
           // create a new list object for wrapped items
-          List* arglist = new (ctx.mem) List(p->pstate(),
-                                             0,
-                                             List::COMMA,
-                                             true);
+          List* arglist = SASS_MEMORY_NEW(ctx.mem, List,
+                                          p->pstate(),
+                                          0,
+                                          SASS_COMMA,
+                                          true);
           // consume the next args
           while (ia < LA) {
             // get and post inc
             a = (*as)[ia++];
-            // wrap current argument into new object
-            (*arglist) << new (ctx.mem) Argument(a->pstate(),
-                                                 a->value(),
-                                                 a->name(),
-                                                 false,
-                                                 false);
+            // maybe we have another list as argument
+            List* ls = dynamic_cast<List*>(a->value());
+            // skip any list completely if empty
+            if (ls && ls->empty()) 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 {
+                  (*arglist) << SASS_MEMORY_NEW(ctx.mem, Argument,
+                                                (*ls)[i]->pstate(),
+                                                (*ls)[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);
+            }
+            // wrap all other value types into Argument
+            else {
+              (*arglist) << SASS_MEMORY_NEW(ctx.mem, Argument,
+                                            a->pstate(),
+                                            a->value(),
+                                            a->name(),
+                                            false,
+                                            false);
+            }
             // check if we have rest argument
             if (a->is_rest_argument()) {
               // preserve the list separator from rest args
@@ -142,15 +187,14 @@ namespace Sass {
           break;
         }
         // otherwise move one of the rest args into the param, converting to argument if necessary
-        if (arglist->is_arglist()) {
-          a = static_cast<Argument*>((*arglist)[0]);
-        } else {
+        if (!(a = dynamic_cast<Argument*>((*arglist)[0]))) {
           Expression* a_to_convert = (*arglist)[0];
-          a = new (ctx.mem) Argument(a_to_convert->pstate(),
-                                     a_to_convert,
-                                     "",
-                                     false,
-                                     false);
+          a = SASS_MEMORY_NEW(ctx.mem, Argument,
+                              a_to_convert->pstate(),
+                              a_to_convert,
+                              "",
+                              false,
+                              false);
         }
         arglist->elements().erase(arglist->elements().begin());
         if (!arglist->length() || (!arglist->is_arglist() && ip + 1 == LP)) {
@@ -160,10 +204,10 @@ namespace Sass {
         Map* argmap = static_cast<Map*>(a->value());
 
         for (auto key : argmap->keys()) {
-          string name = "$" + unquote(static_cast<String_Constant*>(key)->value());
+          std::string name = "$" + unquote(static_cast<String_Constant*>(key)->value());
 
           if (!param_map.count(name)) {
-            stringstream msg;
+            std::stringstream msg;
             msg << callee << " has no parameter named " << name;
             error(msg.str(), a->pstate());
           }
@@ -177,7 +221,7 @@ namespace Sass {
 
       if (a->name().empty()) {
         if (env->has_local(p->name())) {
-          stringstream msg;
+          std::stringstream msg;
           msg << "parameter " << p->name()
           << " provided more than once in call to " << callee;
           error(msg.str(), a->pstate());
@@ -189,18 +233,18 @@ namespace Sass {
       else {
         // named arg -- bind it to the appropriately named param
         if (!param_map.count(a->name())) {
-          stringstream msg;
+          std::stringstream msg;
           msg << callee << " has no parameter named " << a->name();
           error(msg.str(), a->pstate());
         }
         if (param_map[a->name()]->is_rest_parameter()) {
-          stringstream msg;
+          std::stringstream msg;
           msg << "argument " << a->name() << " of " << callee
               << "cannot be used as named argument";
           error(msg.str(), a->pstate());
         }
         if (env->has_local(a->name())) {
-          stringstream msg;
+          std::stringstream msg;
           msg << "parameter " << p->name()
               << "provided more than once in call to " << callee;
           error(msg.str(), a->pstate());
@@ -221,26 +265,19 @@ namespace Sass {
       // cerr << "********" << endl;
       if (!env->has_local(leftover->name())) {
         if (leftover->is_rest_parameter()) {
-          env->local_frame()[leftover->name()] = new (ctx.mem) List(leftover->pstate(),
-                                                                      0,
-                                                                      List::COMMA,
-                                                                      true);
+          env->local_frame()[leftover->name()] = SASS_MEMORY_NEW(ctx.mem, List,
+                                                                   leftover->pstate(),
+                                                                   0,
+                                                                   SASS_COMMA,
+                                                                   true);
         }
         else if (leftover->default_value()) {
-          // 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);
+          Expression* dv = leftover->default_value()->perform(eval);
           env->local_frame()[leftover->name()] = dv;
         }
         else {
           // param is unbound and has no default value -- error
-          stringstream msg;
+          std::stringstream msg;
           msg << "required parameter " << leftover->name()
               << " is missing in call to " << callee;
           error(msg.str(), as->pstate());