sassc 2.3.0 → 2.4.0

data/ext/libsass/src/backtrace.cpp

@@ -2,20 +2,20 @@
 
 namespace Sass {
 
-  const std::string traces_to_string(Backtraces traces, std::string indent) {
+  const sass::string traces_to_string(Backtraces traces, sass::string indent) {
 
-    std::stringstream ss;
-    std::string cwd(File::get_cwd());
+    sass::ostream ss;
+    sass::string cwd(File::get_cwd());
 
     bool first = true;
     size_t i_beg = traces.size() - 1;
-    size_t i_end = std::string::npos;
+    size_t i_end = sass::string::npos;
     for (size_t i = i_beg; i != i_end; i --) {
 
       const Backtrace& trace = traces[i];
 
       // make path relative to the current directory
-      std::string rel_path(File::abs2rel(trace.pstate.path, cwd, cwd));
+      sass::string rel_path(File::abs2rel(trace.pstate.getPath(), cwd, cwd));
 
       // skip functions on error cases (unsure why ruby sass does this)
       // if (trace.caller.substr(0, 6) == ", in f") continue;
@@ -23,9 +23,9 @@ namespace Sass {
       if (first) {
         ss << indent;
         ss << "on line ";
-        ss << trace.pstate.line + 1;
+        ss << trace.pstate.getLine();
         ss << ":";
-        ss << trace.pstate.column + 1;
+        ss << trace.pstate.getColumn();
         ss << " of " << rel_path;
         // ss << trace.caller;
         first = false;
@@ -34,9 +34,9 @@ namespace Sass {
         ss << std::endl;
         ss << indent;
         ss << "from line ";
-        ss << trace.pstate.line + 1;
+        ss << trace.pstate.getLine();
         ss << ":";
-        ss << trace.pstate.column + 1;
+        ss << trace.pstate.getColumn();
         ss << " of " << rel_path;
       }
 

data/ext/libsass/src/backtrace.hpp

@@ -10,19 +10,19 @@ namespace Sass {
 
   struct Backtrace {
 
-    ParserState pstate;
-    std::string caller;
+    SourceSpan pstate;
+    sass::string caller;
 
-    Backtrace(ParserState pstate, std::string c = "")
+    Backtrace(SourceSpan pstate, sass::string c = "")
     : pstate(pstate),
       caller(c)
     { }
 
   };
 
-  typedef std::vector<Backtrace> Backtraces;
+  typedef sass::vector<Backtrace> Backtraces;
 
-  const std::string traces_to_string(Backtraces traces, std::string indent = "\t");
+  const sass::string traces_to_string(Backtraces traces, sass::string indent = "\t");
 
 }
 

data/ext/libsass/src/base64vlq.cpp

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

data/ext/libsass/src/base64vlq.hpp

@@ -9,7 +9,7 @@ namespace Sass {
 
   public:
 
-    std::string encode(const int number) const;
+    sass::string encode(const int number) const;
 
   private:
 

data/ext/libsass/src/bind.cpp

@@ -11,11 +11,11 @@
 
 namespace Sass {
 
-  void bind(std::string type, std::string name, Parameters_Obj ps, Arguments_Obj as, Env* env, Eval* eval, Backtraces& traces)
+  void bind(sass::string type, sass::string name, Parameters_Obj ps, Arguments_Obj as, Env* env, Eval* eval, Backtraces& traces)
   {
-    std::string callee(type + " " + name);
+    sass::string callee(type + " " + name);
 
-    std::map<std::string, Parameter_Obj> param_map;
+    std::map<sass::string, Parameter_Obj> param_map;
     List_Obj varargs = SASS_MEMORY_NEW(List, as->pstate());
     varargs->is_arglist(true); // enable keyword size handling
 
@@ -52,7 +52,7 @@ namespace Sass {
             }
           }
         }
-        std::stringstream msg;
+        sass::ostream msg;
         msg << "wrong number of arguments (" << LA << " for " << LP << ")";
         msg << " for `" << name << "'";
         return error(msg.str(), as->pstate(), traces);
@@ -73,7 +73,7 @@ namespace Sass {
                                               rest->separator(),
                                               true);
               // wrap each item from list as an argument
-              for (Expression_Obj item : rest->elements()) {
+              for (ExpressionObj item : rest->elements()) {
                 if (Argument_Obj arg = Cast<Argument>(item)) {
                   arglist->append(SASS_MEMORY_COPY(arg)); // copy
                 } else {
@@ -100,7 +100,7 @@ namespace Sass {
           Map_Obj argmap = Cast<Map>(a->value());
           for (auto key : argmap->keys()) {
             if (String_Constant_Obj str = Cast<String_Constant>(key)) {
-              std::string param = unquote(str->value());
+              sass::string param = unquote(str->value());
               arglist->append(SASS_MEMORY_NEW(Argument,
                                               key->pstate(),
                                               argmap->at(key),
@@ -130,7 +130,7 @@ namespace Sass {
             // skip any list completely if empty
             if (ls && ls->empty() && a->is_rest_argument()) continue;
 
-            Expression_Obj value = a->value();
+            ExpressionObj value = a->value();
             if (Argument_Obj arg = Cast<Argument>(value)) {
               arglist->append(arg);
             }
@@ -141,7 +141,7 @@ namespace Sass {
                 arglist->separator(rest->separator());
 
                 for (size_t i = 0, L = rest->length(); i < L; ++i) {
-                  Expression_Obj obj = rest->value_at_index(i);
+                  ExpressionObj obj = rest->value_at_index(i);
                   arglist->append(SASS_MEMORY_NEW(Argument,
                                                 obj->pstate(),
                                                 obj,
@@ -177,7 +177,7 @@ namespace Sass {
         // normal param and rest arg
         List_Obj arglist = Cast<List>(a->value());
         if (!arglist) {
-          if (Expression_Obj arg = Cast<Expression>(a->value())) {
+          if (ExpressionObj arg = Cast<Expression>(a->value())) {
             arglist = SASS_MEMORY_NEW(List, a->pstate(), 1);
             arglist->append(arg);
           }
@@ -189,7 +189,7 @@ namespace Sass {
         } else {
           if (arglist->length() > LP - ip && !ps->has_rest_parameter()) {
             size_t arg_count = (arglist->length() + LA - 1);
-            std::stringstream msg;
+            sass::ostream msg;
             msg << callee << " takes " << LP;
             msg << (LP == 1 ? " argument" : " arguments");
             msg << " but " << arg_count;
@@ -202,7 +202,7 @@ namespace Sass {
           }
         }
         // otherwise move one of the rest args into the param, converting to argument if necessary
-        Expression_Obj obj = arglist->at(0);
+        ExpressionObj obj = arglist->at(0);
         if (!(a = Cast<Argument>(obj))) {
           Expression* a_to_convert = obj;
           a = SASS_MEMORY_NEW(Argument,
@@ -226,10 +226,10 @@ namespace Sass {
             traces.push_back(Backtrace(key->pstate()));
             throw Exception::InvalidVarKwdType(key->pstate(), traces, key->inspect(), a);
           }
-          std::string param = "$" + unquote(val->value());
+          sass::string param = "$" + unquote(val->value());
 
           if (!param_map.count(param)) {
-            std::stringstream msg;
+            sass::ostream msg;
             msg << callee << " has no parameter named " << param;
             error(msg.str(), a->pstate(), traces);
           }
@@ -243,7 +243,7 @@ namespace Sass {
 
       if (a->name().empty()) {
         if (env->has_local(p->name())) {
-          std::stringstream msg;
+          sass::ostream msg;
           msg << "parameter " << p->name()
           << " provided more than once in call to " << callee;
           error(msg.str(), a->pstate(), traces);
@@ -258,21 +258,21 @@ namespace Sass {
           if (ps->has_rest_parameter()) {
             varargs->append(a);
           } else {
-            std::stringstream msg;
+            sass::ostream msg;
             msg << callee << " has no parameter named " << a->name();
             error(msg.str(), a->pstate(), traces);
           }
         }
         if (param_map[a->name()]) {
           if (param_map[a->name()]->is_rest_parameter()) {
-            std::stringstream msg;
+            sass::ostream msg;
             msg << "argument " << a->name() << " of " << callee
                 << "cannot be used as named argument";
             error(msg.str(), a->pstate(), traces);
           }
         }
         if (env->has_local(a->name())) {
-          std::stringstream msg;
+          sass::ostream msg;
           msg << "parameter " << p->name()
               << "provided more than once in call to " << callee;
           error(msg.str(), a->pstate(), traces);

data/ext/libsass/src/bind.hpp

@@ -8,7 +8,7 @@
 
 namespace Sass {
 
-  void bind(std::string type, std::string name, Parameters_Obj, Arguments_Obj, Env*, Eval*, Backtraces& traces);
+  void bind(sass::string type, sass::string name, Parameters_Obj, Arguments_Obj, Env*, Eval*, Backtraces& traces);
 
 }
 

data/ext/libsass/src/c2ast.cpp

@@ -8,7 +8,7 @@
 
 namespace Sass {
 
-  Value* c2ast(union Sass_Value* v, Backtraces traces, ParserState pstate)
+  Value* c2ast(union Sass_Value* v, Backtraces traces, SourceSpan pstate)
   {
     using std::strlen;
     using std::strcpy;
@@ -51,10 +51,10 @@ namespace Sass {
         e = SASS_MEMORY_NEW(Null, pstate);
       } break;
       case SASS_ERROR: {
-        error("Error in C function: " + std::string(sass_error_get_message(v)), pstate, traces);
+        error("Error in C function: " + sass::string(sass_error_get_message(v)), pstate, traces);
       } break;
       case SASS_WARNING: {
-        error("Warning in C function: " + std::string(sass_warning_get_message(v)), pstate, traces);
+        error("Warning in C function: " + sass::string(sass_warning_get_message(v)), pstate, traces);
       } break;
       default: break;
     }

data/ext/libsass/src/c2ast.hpp

@@ -7,7 +7,7 @@
 
 namespace Sass {
 
-  Value* c2ast(union Sass_Value* v, Backtraces traces, ParserState pstate);
+  Value* c2ast(union Sass_Value* v, Backtraces traces, SourceSpan pstate);
 
 }
 

data/ext/libsass/src/check_nesting.cpp

@@ -7,12 +7,12 @@
 namespace Sass {
 
   CheckNesting::CheckNesting()
-  : parents(std::vector<Statement*>()),
-    traces(std::vector<Backtrace>()),
+  : parents(sass::vector<Statement*>()),
+    traces(sass::vector<Backtrace>()),
     parent(0), current_mixin_definition(0)
   { }
 
-  void error(AST_Node* node, Backtraces traces, std::string msg) {
+  void error(AST_Node* node, Backtraces traces, sass::string msg) {
     traces.push_back(Backtrace(node->pstate()));
     throw Exception::InvalidSass(node->pstate(), traces, msg);
   }
@@ -21,9 +21,9 @@ namespace Sass {
   {
     Statement* old_parent = this->parent;
 
-    if (At_Root_Block* root = Cast<At_Root_Block>(parent)) {
-      std::vector<Statement*> old_parents = this->parents;
-      std::vector<Statement*> new_parents;
+    if (AtRootRule* root = Cast<AtRootRule>(parent)) {
+      sass::vector<Statement*> old_parents = this->parents;
+      sass::vector<Statement*> new_parents;
 
       for (size_t i = 0, L = this->parents.size(); i < L; i++) {
         Statement* p = this->parents.at(i);
@@ -45,7 +45,7 @@ namespace Sass {
         }
       }
 
-      At_Root_Block* ar = Cast<At_Root_Block>(parent);
+      AtRootRule* ar = Cast<AtRootRule>(parent);
       Block* ret = ar->block();
 
       if (ret != NULL) {
@@ -75,7 +75,7 @@ namespace Sass {
     }
 
     if (!b) {
-      if (Has_Block* bb = Cast<Has_Block>(parent)) {
+      if (ParentStatement* bb = Cast<ParentStatement>(parent)) {
         b = bb->block();
       }
     }
@@ -192,7 +192,7 @@ namespace Sass {
   void CheckNesting::invalid_extend_parent(Statement* parent, AST_Node* node)
   {
     if (!(
-        Cast<Ruleset>(parent) ||
+        Cast<StyleRule>(parent) ||
         Cast<Mixin_Call>(parent) ||
         is_mixin(parent)
     )) {
@@ -204,10 +204,10 @@ namespace Sass {
   // {
   //   for (auto pp : this->parents) {
   //     if (
-  //         Cast<Each>(pp) ||
-  //         Cast<For>(pp) ||
+  //         Cast<EachRule>(pp) ||
+  //         Cast<ForRule>(pp) ||
   //         Cast<If>(pp) ||
-  //         Cast<While>(pp) ||
+  //         Cast<WhileRule>(pp) ||
   //         Cast<Trace>(pp) ||
   //         Cast<Mixin_Call>(pp) ||
   //         is_mixin(pp)
@@ -229,10 +229,10 @@ namespace Sass {
   {
     for (Statement* pp : this->parents) {
       if (
-          Cast<Each>(pp) ||
-          Cast<For>(pp) ||
+          Cast<EachRule>(pp) ||
+          Cast<ForRule>(pp) ||
           Cast<If>(pp) ||
-          Cast<While>(pp) ||
+          Cast<WhileRule>(pp) ||
           Cast<Trace>(pp) ||
           Cast<Mixin_Call>(pp) ||
           is_mixin(pp)
@@ -246,10 +246,10 @@ namespace Sass {
   {
     for (Statement* pp : this->parents) {
       if (
-          Cast<Each>(pp) ||
-          Cast<For>(pp) ||
+          Cast<EachRule>(pp) ||
+          Cast<ForRule>(pp) ||
           Cast<If>(pp) ||
-          Cast<While>(pp) ||
+          Cast<WhileRule>(pp) ||
           Cast<Trace>(pp) ||
           Cast<Mixin_Call>(pp) ||
           is_mixin(pp)
@@ -262,19 +262,19 @@ namespace Sass {
   void CheckNesting::invalid_function_child(Statement* child)
   {
     if (!(
-        Cast<Each>(child) ||
-        Cast<For>(child) ||
+        Cast<EachRule>(child) ||
+        Cast<ForRule>(child) ||
         Cast<If>(child) ||
-        Cast<While>(child) ||
+        Cast<WhileRule>(child) ||
         Cast<Trace>(child) ||
         Cast<Comment>(child) ||
-        Cast<Debug>(child) ||
+        Cast<DebugRule>(child) ||
         Cast<Return>(child) ||
         Cast<Variable>(child) ||
         // Ruby Sass doesn't distinguish variables and assignments
         Cast<Assignment>(child) ||
-        Cast<Warning>(child) ||
-        Cast<Error>(child)
+        Cast<WarningRule>(child) ||
+        Cast<ErrorRule>(child)
     )) {
       error(child, traces, "Functions can only contain variable declarations and control directives.");
     }
@@ -283,10 +283,10 @@ namespace Sass {
   void CheckNesting::invalid_prop_child(Statement* child)
   {
     if (!(
-        Cast<Each>(child) ||
-        Cast<For>(child) ||
+        Cast<EachRule>(child) ||
+        Cast<ForRule>(child) ||
         Cast<If>(child) ||
-        Cast<While>(child) ||
+        Cast<WhileRule>(child) ||
         Cast<Trace>(child) ||
         Cast<Comment>(child) ||
         Cast<Declaration>(child) ||
@@ -301,7 +301,7 @@ namespace Sass {
     if (!(
         is_mixin(parent) ||
         is_directive_node(parent) ||
-        Cast<Ruleset>(parent) ||
+        Cast<StyleRule>(parent) ||
         Cast<Keyframe_Rule>(parent) ||
         Cast<Declaration>(parent) ||
         Cast<Mixin_Call>(parent)
@@ -343,17 +343,17 @@ namespace Sass {
                              !is_at_root_node(grandparent);
 
     return Cast<Import>(parent) ||
-           Cast<Each>(parent) ||
-           Cast<For>(parent) ||
+           Cast<EachRule>(parent) ||
+           Cast<ForRule>(parent) ||
            Cast<If>(parent) ||
-           Cast<While>(parent) ||
+           Cast<WhileRule>(parent) ||
            Cast<Trace>(parent) ||
            valid_bubble_node;
   }
 
   bool CheckNesting::is_charset(Statement* n)
   {
-    Directive* d = Cast<Directive>(n);
+    AtRule* d = Cast<AtRule>(n);
     return d && d->keyword() == "charset";
   }
 
@@ -371,7 +371,7 @@ namespace Sass {
 
   bool CheckNesting::is_root_node(Statement* n)
   {
-    if (Cast<Ruleset>(n)) return false;
+    if (Cast<StyleRule>(n)) return false;
 
     Block* b = Cast<Block>(n);
     return b && b->is_root();
@@ -379,15 +379,15 @@ namespace Sass {
 
   bool CheckNesting::is_at_root_node(Statement* n)
   {
-    return Cast<At_Root_Block>(n) != NULL;
+    return Cast<AtRootRule>(n) != NULL;
   }
 
   bool CheckNesting::is_directive_node(Statement* n)
   {
-    return Cast<Directive>(n) ||
+    return Cast<AtRule>(n) ||
            Cast<Import>(n) ||
       Cast<MediaRule>(n) ||
       Cast<CssMediaRule>(n) ||
-      Cast<Supports_Block>(n);
+      Cast<SupportsRule>(n);
   }
 }