sassc 0.0.9 → 0.0.10

data/ext/libsass/expand.hpp

@@ -1,27 +1,19 @@
-#define SASS_EXPAND
+#ifndef SASS_EXPAND_H
+#define SASS_EXPAND_H
 
-#include <vector>
 #include <map>
+#include <vector>
 #include <iostream>
 
-#ifndef SASS_AST
 #include "ast.hpp"
-#endif
-
-#ifndef SASS_OPERATION
+#include "eval.hpp"
 #include "operation.hpp"
-#endif
-
-#ifndef SASS_ENVIRONMENT
 #include "environment.hpp"
-#endif
+#include "contextualize.hpp"
 
 namespace Sass {
   using namespace std;
 
-  struct Context;
-  class Eval;
-  class Contextualize;
   typedef Environment<AST_Node*> Env;
   struct Backtrace;
 
@@ -34,6 +26,9 @@ namespace Sass {
     vector<Block*>    block_stack;
     vector<String*>   property_stack;
     vector<Selector*> selector_stack;
+    vector<Selector*> at_root_selector_stack;
+    bool              in_at_root;
+    bool              in_keyframes;
     Backtrace*        backtrace;
 
     Statement* fallback_impl(AST_Node* n);
@@ -49,6 +44,7 @@ namespace Sass {
     Statement* operator()(Propset*);
     Statement* operator()(Media_Block*);
     Statement* operator()(Feature_Block*);
+    Statement* operator()(At_Root_Block*);
     Statement* operator()(At_Rule*);
     Statement* operator()(Declaration*);
     Statement* operator()(Assignment*);
@@ -75,3 +71,5 @@ namespace Sass {
   };
 
 }
+
+#endif

data/ext/libsass/extend.cpp

@@ -5,9 +5,7 @@
 #include "backtrace.hpp"
 #include "paths.hpp"
 #include "parser.hpp"
-#ifndef SASS_AST
 #include "node.hpp"
-#endif
 #include "sass_util.hpp"
 #include "debug.hpp"
 #include <iostream>
@@ -237,14 +235,15 @@ namespace Sass {
     return os;
   }
 #endif
+
   static bool parentSuperselector(Complex_Selector* pOne, Complex_Selector* pTwo, Context& ctx) {
     // TODO: figure out a better way to create a Complex_Selector from scratch
     // TODO: There's got to be a better way. This got ugly quick...
-    Position noPosition;
-    Type_Selector fakeParent("", noPosition, "temp");
-    Compound_Selector fakeHead("", noPosition, 1 /*size*/);
+    Position noPosition(-1, -1, -1);
+    Type_Selector fakeParent(ParserState("[FAKE]"), "temp");
+    Compound_Selector fakeHead(ParserState("[FAKE]"), 1 /*size*/);
     fakeHead.elements().push_back(&fakeParent);
-    Complex_Selector fakeParentContainer("", noPosition, Complex_Selector::ANCESTOR_OF, &fakeHead /*head*/, NULL /*tail*/);
+    Complex_Selector fakeParentContainer(ParserState("[FAKE]"), Complex_Selector::ANCESTOR_OF, &fakeHead /*head*/, NULL /*tail*/);
 
     pOne->set_innermost(&fakeParentContainer, Complex_Selector::ANCESTOR_OF);
     pTwo->set_innermost(&fakeParentContainer, Complex_Selector::ANCESTOR_OF);
@@ -602,11 +601,11 @@ namespace Sass {
   static bool parentSuperselector(const Node& one, const Node& two, Context& ctx) {
     // TODO: figure out a better way to create a Complex_Selector from scratch
     // TODO: There's got to be a better way. This got ugly quick...
-    Position noPosition;
-    Type_Selector fakeParent("", noPosition, "temp");
-    Compound_Selector fakeHead("", noPosition, 1 /*size*/);
+    Position noPosition(-1, -1, -1);
+    Type_Selector fakeParent(ParserState("[FAKE]"), "temp");
+    Compound_Selector fakeHead(ParserState("[FAKE]"), 1 /*size*/);
     fakeHead.elements().push_back(&fakeParent);
-    Complex_Selector fakeParentContainer("", noPosition, Complex_Selector::ANCESTOR_OF, &fakeHead /*head*/, NULL /*tail*/);
+    Complex_Selector fakeParentContainer(ParserState("[FAKE]"), Complex_Selector::ANCESTOR_OF, &fakeHead /*head*/, NULL /*tail*/);
 
     Complex_Selector* pOneWithFakeParent = nodeToComplexSelector(one, ctx);
     pOneWithFakeParent->set_innermost(&fakeParentContainer, Complex_Selector::ANCESTOR_OF);
@@ -1521,7 +1520,7 @@ namespace Sass {
 //      DEBUG_EXEC(EXTEND_COMPOUND, printComplexSelector(&seq, "SEQ: "))
 
 
-      Compound_Selector* pSels = new (ctx.mem) Compound_Selector(pSelector->path(), pSelector->position());
+      Compound_Selector* pSels = new (ctx.mem) Compound_Selector(pSelector->pstate());
       for (vector<ExtensionPair>::iterator groupIter = group.begin(), groupIterEnd = group.end(); groupIter != groupIterEnd; groupIter++) {
         ExtensionPair& pair = *groupIter;
         Compound_Selector* pCompound = pair.second;
@@ -1553,7 +1552,7 @@ namespace Sass {
       Compound_Selector* pUnifiedSelector = NULL;
 
       if (!pInnermostCompoundSelector) {
-        pInnermostCompoundSelector = new (ctx.mem) Compound_Selector(pSelector->path(), pSelector->position());
+        pInnermostCompoundSelector = new (ctx.mem) Compound_Selector(pSelector->pstate());
       }
 
       pUnifiedSelector = pInnermostCompoundSelector->unify_with(pSelectorWithoutExtendSelectors, ctx);
@@ -1579,7 +1578,7 @@ namespace Sass {
       // complex is that Complex_Selector contains a combinator, but in ruby combinators have already been filtered
       // out and aren't operated on.
       Complex_Selector* pNewSelector = pExtComplexSelector->cloneFully(ctx);
-      Complex_Selector* pNewInnerMost = new (ctx.mem) Complex_Selector(pSelector->path(), pSelector->position(), Complex_Selector::ANCESTOR_OF, pUnifiedSelector, NULL);
+      Complex_Selector* pNewInnerMost = new (ctx.mem) Complex_Selector(pSelector->pstate(), Complex_Selector::ANCESTOR_OF, pUnifiedSelector, NULL);
       Complex_Selector::Combinator combinator = pNewSelector->clear_innermost();
       pNewSelector->set_innermost(pNewInnerMost, combinator);
 
@@ -1596,6 +1595,7 @@ namespace Sass {
 #endif
 
 
+      if (pSelector && pSelector->has_line_feed()) pNewSelector->has_line_feed(true);
 
       // Set the sources on our new Complex_Selector to the sources of this simple sequence plus the thing we're extending.
       DEBUG_PRINTLN(EXTEND_COMPOUND, "SOURCES SETTING ON NEW SEQ: " << complexSelectorToNode(pNewSelector, ctx))
@@ -1675,13 +1675,58 @@ namespace Sass {
 
       if (pHead) {
         SubsetMapEntries entries = subsetMap.get_v(pHead->to_str_vec());
+        for (ExtensionPair ext : entries) {
+          // check if both selectors have the same media block parent
+          if (ext.first->media_block() == pComplexSelector->media_block()) continue;
+          To_String to_string(&ctx);
+          if (ext.second->media_block() && ext.second->media_block()->media_queries() &&
+              pComplexSelector->media_block() && pComplexSelector->media_block()->media_queries())
+          {
+            string query_left(ext.second->media_block()->media_queries()->perform(&to_string));
+            string query_right(pComplexSelector->media_block()->media_queries()->perform(&to_string));
+            if (query_left == query_right) continue;
+          }
 
-        hasExtension = entries.size() > 0;
+          // fail if one goes across media block boundaries
+          stringstream err;
+          string cwd(Sass::File::get_cwd());
+          ParserState pstate(ext.second->pstate());
+          string rel_path(Sass::File::resolve_relative_path(pstate.path, cwd, cwd));
+          err << "You may not @extend an outer selector from within @media.\n";
+          err << "You may only @extend selectors within the same directive.\n";
+          err << "From \"@extend " << ext.second->perform(&to_string) << "\"";
+          err << " on line " << pstate.line+1 << " of " << rel_path << "\n";
+          error(err.str(), pComplexSelector->pstate());
+        }
+        if (entries.size() > 0) hasExtension = true;
       }
 
       pIter = pIter->tail();
     }
 
+    if (!hasExtension) {
+      /* ToDo: don't break stuff
+      stringstream err;
+      To_String to_string(&ctx);
+      string cwd(Sass::File::get_cwd());
+      string sel1(pComplexSelector->perform(&to_string));
+      Compound_Selector* pExtendSelector = 0;
+      for (auto i : subsetMap.values()) {
+        if (i.first == pComplexSelector) {
+          pExtendSelector = i.second;
+          break;
+        }
+      }
+      if (!pExtendSelector || !pExtendSelector->is_optional()) {
+        string sel2(pExtendSelector ? pExtendSelector->perform(&to_string) : "[unknown]");
+        err << "\"" << sel1 << "\" failed to @extend \"" << sel2 << "\"\n";
+        err << "The selector \"" << sel2 << "\" was not found.\n";
+        err << "Use \"@extend " << sel2 << " !optional\" if the extend should be able to fail.";
+        error(err.str(), pExtendSelector ? pExtendSelector->pstate() : pComplexSelector->pstate());
+      }
+      */
+    }
+
     return hasExtension;
   }
 
@@ -1703,8 +1748,9 @@ namespace Sass {
     ExtensionSubsetMap& subsetMap,
     set<Compound_Selector> seen) {
 
-    Node complexSelector = complexSelectorToNode(pComplexSelector, ctx);
+    pComplexSelector->tail()->has_line_feed(pComplexSelector->has_line_feed());
 
+    Node complexSelector = complexSelectorToNode(pComplexSelector, ctx);
     DEBUG_PRINTLN(EXTEND_COMPLEX, "EXTEND COMPLEX: " << complexSelector)
 
     Node extendedNotExpanded = Node::createCollection();
@@ -1808,9 +1854,9 @@ namespace Sass {
   */
   static Selector_List* extendSelectorList(Selector_List* pSelectorList, Context& ctx, ExtensionSubsetMap& subsetMap, bool& extendedSomething) {
 
-    To_String to_string;
+    To_String to_string(&ctx);
 
-    Selector_List* pNewSelectors = new (ctx.mem) Selector_List(pSelectorList->path(), pSelectorList->position(), pSelectorList->length());
+    Selector_List* pNewSelectors = new (ctx.mem) Selector_List(pSelectorList->pstate(), pSelectorList->length());
 
     extendedSomething = false;
 
@@ -1883,7 +1929,7 @@ namespace Sass {
   // Extend a ruleset by extending the selectors and updating them on the ruleset. The block's rules don't need to change.
   template <typename ObjectType>
   static void extendObjectWithSelectorAndBlock(ObjectType* pObject, Context& ctx, ExtensionSubsetMap& subsetMap) {
-    To_String to_string;
+    To_String to_string(&ctx);
 
     DEBUG_PRINTLN(EXTEND_OBJECT, "FOUND SELECTOR: " << static_cast<Selector_List*>(pObject->selector())->perform(&to_string))
 
@@ -1904,12 +1950,12 @@ namespace Sass {
       // re-parse in order to restructure expanded placeholder nodes correctly.
       //
       // TODO: I don't know if this is needed, but it was in the original C++ implementation, so I kept it. Try running the tests without re-parsing.
+      // this probably messes up source-maps
       pObject->selector(
         Parser::from_c_str(
           (pNewSelectorList->perform(&to_string) + ";").c_str(),
           ctx,
-          pNewSelectorList->path(),
-          pNewSelectorList->position()
+          pNewSelectorList->pstate()
         ).parse_selector_group()
       );
     } else {

data/ext/libsass/extend.hpp

@@ -1,26 +1,19 @@
-#define SASS_EXTEND
+#ifndef SASS_EXTEND_H
+#define SASS_EXTEND_H
 
-#include <vector>
 #include <map>
 #include <set>
+#include <vector>
 #include <iostream>
 
-#ifndef SASS_AST
 #include "ast.hpp"
-#endif
-
-#ifndef SASS_OPERATION
 #include "operation.hpp"
-#endif
-
-#ifndef SASS_SUBSET_MAP
 #include "subset_map.hpp"
-#endif
 
 namespace Sass {
   using namespace std;
 
-  struct Context;
+  class Context;
 
   typedef Subset_Map<string, pair<Complex_Selector*, Compound_Selector*> > ExtensionSubsetMap;
 
@@ -48,3 +41,5 @@ namespace Sass {
   };
 
 }
+
+#endif

data/ext/libsass/file.cpp

@@ -9,6 +9,7 @@
 #include <iostream>
 #include <fstream>
 #include <cctype>
+#include <vector>
 #include <algorithm>
 #include <sys/stat.h>
 #include "file.hpp"
@@ -202,34 +203,38 @@ namespace Sass {
       // (4) given + extension
       char* contents = 0;
       real_path = path;
-      // if the file isn't found with the given filename ...
+      vector<string> exts(3);
+      exts[0] = ".scss";
+      exts[1] = ".sass";
+      exts[2] = ".css";
+
+      // if the file isn't found with the given filename (1)
       if (!(contents = read_file(real_path))) {
         string dir(dir_name(path));
         string base(base_name(path));
-        string _base("_" + base);
-        real_path = dir + _base;
-        // if the file isn't found with '_' + filename ...
-        if (!(contents = read_file(real_path))) {
-          string _base_scss(_base + ".scss");
-          real_path = dir + _base_scss;
-          // if the file isn't found with '_' + filename + ".scss" ...
-          if (!(contents = read_file(real_path))) {
-            string _base_sass(_base + ".sass");
-            real_path = dir + _base_sass;
-            // if the file isn't found with '_' + filename + ".sass" ...
-            if (!(contents = read_file(real_path))) {
-              string base_scss(base + ".scss");
-              real_path = dir + base_scss;
-              // if the file isn't found with filename + ".scss" ...
-              if (!(contents = read_file(real_path))) {
-                string base_sass(base + ".sass");
-                real_path = dir + base_sass;
-                // if the file isn't found with filename + ".sass" ...
-                if (!(contents = read_file(real_path))) {
-                  // default back to scss version
-                  real_path = dir + base_scss;
-                }
-              }
+        real_path = dir + base;
+        // (2) underscore + given
+        string test_path(dir + "_" + base);
+        if ((contents = read_file(test_path))) {
+          real_path = test_path;
+        }
+        // (3) underscore + given + extension
+        if (!contents) {
+          for(auto ext : exts) {
+            test_path = dir + "_" + base + ext;
+            if ((contents = read_file(test_path))) {
+              real_path = test_path;
+              break;
+            }
+          }
+        }
+        // (4) given + extension
+        if (!contents) {
+          for(auto ext : exts) {
+            test_path = dir + base + ext;
+            if ((contents = read_file(test_path))) {
+              real_path = test_path;
+              break;
             }
           }
         }
@@ -279,7 +284,7 @@ namespace Sass {
       for(size_t i=0; i<extension.size();++i)
         extension[i] = tolower(extension[i]);
       if (extension == ".sass" && contents != 0) {
-        char * converted = sass2scss(contents, SASS2SCSS_PRETTIFY_1);
+        char * converted = sass2scss(contents, SASS2SCSS_PRETTIFY_1 | SASS2SCSS_KEEP_COMMENT);
         delete[] contents; // free the indented contents
         return converted; // should be freed by caller
       } else {

data/ext/libsass/file.hpp

@@ -1,8 +1,11 @@
+#ifndef SASS_FILE_H
+#define SASS_FILE_H
+
 #include <string>
 
 namespace Sass {
   using namespace std;
-  struct Context;
+  class Context;
   namespace File {
     string get_cwd();
     string base_name(string);
@@ -16,3 +19,5 @@ namespace Sass {
     char* read_file(string path);
   }
 }
+
+#endif

data/ext/libsass/functions.cpp

@@ -27,9 +27,9 @@
 #include "wincrypt.h"
 #endif
 
-#define ARG(argname, argtype) get_arg<argtype>(argname, env, sig, path, position, backtrace)
-#define ARGR(argname, argtype, lo, hi) get_arg_r(argname, env, sig, path, position, lo, hi, backtrace)
-#define ARGM(argname, argtype, ctx) get_arg_m(argname, env, sig, path, position, backtrace, ctx)
+#define ARG(argname, argtype) get_arg<argtype>(argname, env, sig, pstate, backtrace)
+#define ARGR(argname, argtype, lo, hi) get_arg_r(argname, env, sig, pstate, lo, hi, backtrace)
+#define ARGM(argname, argtype, ctx) get_arg_m(argname, env, sig, pstate, backtrace, ctx)
 
 namespace Sass {
   using std::stringstream;
@@ -37,12 +37,11 @@ namespace Sass {
 
   Definition* make_native_function(Signature sig, Native_Function f, Context& ctx)
   {
-    Parser sig_parser = Parser::from_c_str(sig, ctx, "[built-in function]");
+    Parser sig_parser = Parser::from_c_str(sig, ctx, ParserState("[built-in function]"));
     sig_parser.lex<Prelexer::identifier>();
     string name(Util::normalize_underscores(sig_parser.lexed));
     Parameters* params = sig_parser.parse_parameters();
-    return new (ctx.mem) Definition("[built-in function]",
-                                    Position(),
+    return new (ctx.mem) Definition(ParserState("[built-in function]"),
                                     sig,
                                     name,
                                     params,
@@ -52,7 +51,7 @@ namespace Sass {
 
   Definition* make_c_function(Signature sig, Sass_C_Function f, void* cookie, Context& ctx)
   {
-    Parser sig_parser = Parser::from_c_str(sig, ctx, "[c function]");
+    Parser sig_parser = Parser::from_c_str(sig, ctx, ParserState("[c function]"));
     // allow to overload generic callback plus @warn, @error and @debug with custom functions
     sig_parser.lex < alternatives < identifier, exactly <'*'>,
                                     exactly < Constants::warn_kwd >,
@@ -61,8 +60,7 @@ namespace Sass {
                    >              >();
     string name(Util::normalize_underscores(sig_parser.lexed));
     Parameters* params = sig_parser.parse_parameters();
-    return new (ctx.mem) Definition("[c function]",
-                                    Position(),
+    return new (ctx.mem) Definition(ParserState("[c function]"),
                                     sig,
                                     name,
                                     params,
@@ -74,7 +72,7 @@ namespace Sass {
   namespace Functions {
 
     template <typename T>
-    T* get_arg(const string& argname, Env& env, Signature sig, const string& path, Position position, Backtrace* backtrace)
+    T* get_arg(const string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace)
     {
       // Minimal error handling -- the expectation is that built-ins will be written correctly!
       T* val = dynamic_cast<T*>(env[argname]);
@@ -85,35 +83,35 @@ namespace Sass {
         msg += sig;
         msg += "` must be a ";
         msg += T::type_name();
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       return val;
     }
 
-    Map* get_arg_m(const string& argname, Env& env, Signature sig, const string& path, Position position, Backtrace* backtrace, Context& ctx)
+    Map* get_arg_m(const string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx)
     {
       // Minimal error handling -- the expectation is that built-ins will be written correctly!
       Map* val = dynamic_cast<Map*>(env[argname]);
       if (val) return val;
 
       List* lval = dynamic_cast<List*>(env[argname]);
-      if (lval && lval->length() == 0) return new (ctx.mem) Map(path, position, 0);
+      if (lval && lval->length() == 0) return new (ctx.mem) Map(pstate, 0);
 
       // fallback on get_arg for error handling
-      val = get_arg<Map>(argname, env, sig, path, position, backtrace);
+      val = get_arg<Map>(argname, env, sig, pstate, backtrace);
       return val;
     }
 
-    Number* get_arg_r(const string& argname, Env& env, Signature sig, const string& path, Position position, double lo, double hi, Backtrace* backtrace)
+    Number* get_arg_r(const string& argname, Env& env, Signature sig, ParserState pstate, double lo, double hi, Backtrace* backtrace)
     {
       // Minimal error handling -- the expectation is that built-ins will be written correctly!
-      Number* val = get_arg<Number>(argname, env, sig, path, position, backtrace);
+      Number* val = get_arg<Number>(argname, env, sig, pstate, backtrace);
       double v = val->value();
       if (!(lo <= v && v <= hi)) {
         stringstream msg;
         msg << "argument `" << argname << "` of `" << sig << "` must be between ";
         msg << lo << " and " << hi;
-        error(msg.str(), path, position, backtrace);
+        error(msg.str(), pstate, backtrace);
       }
       return val;
     }
@@ -144,7 +142,7 @@ namespace Sass {
     // random_device degrades sharply once the entropy pool
     // is exhausted. For practical use, random_device is
     // generally only used to seed a PRNG such as mt19937.
-    static mt19937 rand(GetSeed());
+    static mt19937 rand(static_cast<unsigned int>(GetSeed()));
 
     // features
     static set<string> features;
@@ -153,24 +151,30 @@ namespace Sass {
     // RGB FUNCTIONS
     ////////////////
 
+    inline double color_num(Number* n) {
+      if (n->unit() == "%") {
+        return std::min(std::max(n->value(), 0.0), 1.0) * 255;
+      } else {
+        return std::min(std::max(n->value(), 0.0), 255.0);
+      }
+    }
+
     Signature rgb_sig = "rgb($red, $green, $blue)";
     BUILT_IN(rgb)
     {
-      return new (ctx.mem) Color(path,
-                                 position,
-                                 ARGR("$red",   Number, 0, 255)->value(),
-                                 ARGR("$green", Number, 0, 255)->value(),
-                                 ARGR("$blue",  Number, 0, 255)->value());
+      return new (ctx.mem) Color(pstate,
+                                 color_num(ARGR("$red",   Number, 0, 255)),
+                                 color_num(ARGR("$green", Number, 0, 255)),
+                                 color_num(ARGR("$blue",  Number, 0, 255)));
     }
 
     Signature rgba_4_sig = "rgba($red, $green, $blue, $alpha)";
     BUILT_IN(rgba_4)
     {
-      return new (ctx.mem) Color(path,
-                                 position,
-                                 ARGR("$red",   Number, 0, 255)->value(),
-                                 ARGR("$green", Number, 0, 255)->value(),
-                                 ARGR("$blue",  Number, 0, 255)->value(),
+      return new (ctx.mem) Color(pstate,
+                                 color_num(ARGR("$red",   Number, 0, 255)),
+                                 color_num(ARGR("$green", Number, 0, 255)),
+                                 color_num(ARGR("$blue",  Number, 0, 255)),
                                  ARGR("$alpha", Number, 0, 1)->value());
     }
 
@@ -186,15 +190,15 @@ namespace Sass {
 
     Signature red_sig = "red($color)";
     BUILT_IN(red)
-    { return new (ctx.mem) Number(path, position, ARG("$color", Color)->r()); }
+    { return new (ctx.mem) Number(pstate, ARG("$color", Color)->r()); }
 
     Signature green_sig = "green($color)";
     BUILT_IN(green)
-    { return new (ctx.mem) Number(path, position, ARG("$color", Color)->g()); }
+    { return new (ctx.mem) Number(pstate, ARG("$color", Color)->g()); }
 
     Signature blue_sig = "blue($color)";
     BUILT_IN(blue)
-    { return new (ctx.mem) Number(path, position, ARG("$color", Color)->b()); }
+    { return new (ctx.mem) Number(pstate, ARG("$color", Color)->b()); }
 
     Signature mix_sig = "mix($color-1, $color-2, $weight: 50%)";
     BUILT_IN(mix)
@@ -210,8 +214,7 @@ namespace Sass {
       double w1 = (((w * a == -1) ? w : (w + a)/(1 + w*a)) + 1)/2.0;
       double w2 = 1 - w1;
 
-      return new (ctx.mem) Color(path,
-                                 position,
+      return new (ctx.mem) Color(pstate,
                                  std::floor(w1*color1->r() + w2*color2->r()),
                                  std::floor(w1*color1->g() + w2*color2->g()),
                                  std::floor(w1*color1->b() + w2*color2->b()),
@@ -266,7 +269,7 @@ namespace Sass {
       return m1;
     }
 
-    Color* hsla_impl(double h, double s, double l, double a, Context& ctx, const string& path, Position position)
+    Color* hsla_impl(double h, double s, double l, double a, Context& ctx, ParserState pstate)
     {
       h /= 360.0;
       s /= 100.0;
@@ -282,7 +285,7 @@ namespace Sass {
       double g = (h_to_rgb(m1, m2, h) * 255.0);
       double b = (h_to_rgb(m1, m2, h-1.0/3.0) * 255.0);
 
-      return new (ctx.mem) Color(path, position, r, g, b, a);
+      return new (ctx.mem) Color(pstate, r, g, b, a);
     }
 
     Signature hsl_sig = "hsl($hue, $saturation, $lightness)";
@@ -293,8 +296,7 @@ namespace Sass {
                        ARGR("$lightness", Number, 0, 100)->value(),
                        1.0,
                        ctx,
-                       path,
-                       position);
+                       pstate);
     }
 
     Signature hsla_sig = "hsla($hue, $saturation, $lightness, $alpha)";
@@ -305,8 +307,7 @@ namespace Sass {
                        ARGR("$lightness", Number, 0, 100)->value(),
                        ARGR("$alpha", Number, 0, 1)->value(),
                        ctx,
-                       path,
-                       position);
+                       pstate);
     }
 
     Signature hue_sig = "hue($color)";
@@ -316,7 +317,7 @@ namespace Sass {
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
-      return new (ctx.mem) Number(path, position, hsl_color.h, "deg");
+      return new (ctx.mem) Number(pstate, hsl_color.h, "deg");
     }
 
     Signature saturation_sig = "saturation($color)";
@@ -326,7 +327,7 @@ namespace Sass {
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
-      return new (ctx.mem) Number(path, position, hsl_color.s, "%");
+      return new (ctx.mem) Number(pstate, hsl_color.s, "%");
     }
 
     Signature lightness_sig = "lightness($color)";
@@ -336,7 +337,7 @@ namespace Sass {
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
-      return new (ctx.mem) Number(path, position, hsl_color.l, "%");
+      return new (ctx.mem) Number(pstate, hsl_color.l, "%");
     }
 
     Signature adjust_hue_sig = "adjust-hue($color, $degrees)";
@@ -352,8 +353,7 @@ namespace Sass {
                        hsl_color.l,
                        rgb_color->a(),
                        ctx,
-                       path,
-                       position);
+                       pstate);
     }
 
     Signature lighten_sig = "lighten($color, $amount)";
@@ -375,8 +375,7 @@ namespace Sass {
                        hslcolorL + amount->value(),
                        rgb_color->a(),
                        ctx,
-                       path,
-                       position);
+                       pstate);
     }
 
     Signature darken_sig = "darken($color, $amount)";
@@ -399,8 +398,7 @@ namespace Sass {
                        hslcolorL - amount->value(),
                        rgb_color->a(),
                        ctx,
-                       path,
-                       position);
+                       pstate);
     }
 
     Signature saturate_sig = "saturate($color, $amount: false)";
@@ -410,7 +408,7 @@ namespace Sass {
       Number* amount = dynamic_cast<Number*>(env["$amount"]);
       if (!amount) {
         To_String to_string(&ctx);
-        return new (ctx.mem) String_Constant(path, position, "saturate(" + env["$color"]->perform(&to_string) + ")");
+        return new (ctx.mem) String_Constant(pstate, "saturate(" + env["$color"]->perform(&to_string) + ")");
       }
 
       ARGR("$amount", Number, 0, 100);
@@ -418,20 +416,23 @@ namespace Sass {
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
-      //Check saturation is not negative before saturate it
-      double hslcolorS = hsl_color.s;
+
+      double hslcolorS = hsl_color.s + amount->value();
+
+      // Saturation cannot be below 0 or above 100
       if (hslcolorS < 0) {
         hslcolorS = 0;
       }
-
+      if (hslcolorS > 100) {
+        hslcolorS = 100;
+      }
 
       return hsla_impl(hsl_color.h,
-                       hslcolorS + amount->value(),
+                       hslcolorS,
                        hsl_color.l,
                        rgb_color->a(),
                        ctx,
-                       path,
-                       position);
+                       pstate);
     }
 
     Signature desaturate_sig = "desaturate($color, $amount)";
@@ -442,19 +443,23 @@ namespace Sass {
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
-      //Check saturation is not over 100 before desaturate it
-      double hslcolorS = hsl_color.s;
+
+      double hslcolorS = hsl_color.s - amount->value();
+
+      // Saturation cannot be below 0 or above 100
+      if (hslcolorS <= 0) {
+        hslcolorS = 0;
+      }
       if (hslcolorS > 100) {
         hslcolorS = 100;
       }
 
       return hsla_impl(hsl_color.h,
-                       hslcolorS - amount->value(),
+                       hslcolorS,
                        hsl_color.l,
                        rgb_color->a(),
                        ctx,
-                       path,
-                       position);
+                       pstate);
     }
 
     Signature grayscale_sig = "grayscale($color)";
@@ -464,7 +469,7 @@ namespace Sass {
       Number* amount = dynamic_cast<Number*>(env["$color"]);
       if (amount) {
         To_String to_string(&ctx);
-        return new (ctx.mem) String_Constant(path, position, "grayscale(" + amount->perform(&to_string) + ")");
+        return new (ctx.mem) String_Constant(pstate, "grayscale(" + amount->perform(&to_string) + ")");
       }
 
       Color* rgb_color = ARG("$color", Color);
@@ -476,8 +481,7 @@ namespace Sass {
                        hsl_color.l,
                        rgb_color->a(),
                        ctx,
-                       path,
-                       position);
+                       pstate);
     }
 
     Signature complement_sig = "complement($color)";
@@ -492,8 +496,7 @@ namespace Sass {
                        hsl_color.l,
                        rgb_color->a(),
                        ctx,
-                       path,
-                       position);
+                       pstate);
     }
 
     Signature invert_sig = "invert($color)";
@@ -503,12 +506,11 @@ namespace Sass {
       Number* amount = dynamic_cast<Number*>(env["$color"]);
       if (amount) {
         To_String to_string(&ctx);
-        return new (ctx.mem) String_Constant(path, position, "invert(" + amount->perform(&to_string) + ")");
+        return new (ctx.mem) String_Constant(pstate, "invert(" + amount->perform(&to_string) + ")");
       }
 
       Color* rgb_color = ARG("$color", Color);
-      return new (ctx.mem) Color(path,
-                                 position,
+      return new (ctx.mem) Color(pstate,
                                  255 - rgb_color->r(),
                                  255 - rgb_color->g(),
                                  255 - rgb_color->b(),
@@ -524,17 +526,17 @@ namespace Sass {
     {
       String_Constant* ie_kwd = dynamic_cast<String_Constant*>(env["$color"]);
       if (ie_kwd) {
-        return new (ctx.mem) String_Constant(path, position, "alpha(" + ie_kwd->value() + ")");
+        return new (ctx.mem) String_Constant(pstate, "alpha(" + ie_kwd->value() + ")");
       }
 
       // CSS3 filter function overload: pass literal through directly
       Number* amount = dynamic_cast<Number*>(env["$color"]);
       if (amount) {
         To_String to_string(&ctx);
-        return new (ctx.mem) String_Constant(path, position, "opacity(" + amount->perform(&to_string) + ")");
+        return new (ctx.mem) String_Constant(pstate, "opacity(" + amount->perform(&to_string) + ")");
       }
 
-      return new (ctx.mem) Number(path, position, ARG("$color", Color)->a());
+      return new (ctx.mem) Number(pstate, ARG("$color", Color)->a());
     }
 
     Signature opacify_sig = "opacify($color, $amount)";
@@ -542,13 +544,13 @@ namespace Sass {
     BUILT_IN(opacify)
     {
       Color* color = ARG("$color", Color);
-      double alpha = color->a() + ARGR("$amount", Number, 0, 1)->value();
-      return new (ctx.mem) Color(path,
-                                 position,
+      double amount = ARGR("$amount", Number, 0, 1)->value();
+      double alpha = std::min(color->a() + amount, 1.0);
+      return new (ctx.mem) Color(pstate,
                                  color->r(),
                                  color->g(),
                                  color->b(),
-                                 alpha > 1.0 ? 1.0 : alpha);
+                                 alpha);
     }
 
     Signature transparentize_sig = "transparentize($color, $amount)";
@@ -556,13 +558,13 @@ namespace Sass {
     BUILT_IN(transparentize)
     {
       Color* color = ARG("$color", Color);
-      double alpha = color->a() - ARGR("$amount", Number, 0, 1)->value();
-      return new (ctx.mem) Color(path,
-                                 position,
+      double amount = ARGR("$amount", Number, 0, 1)->value();
+      double alpha = std::max(color->a() - amount, 0.0);
+      return new (ctx.mem) Color(pstate,
                                  color->r(),
                                  color->g(),
                                  color->b(),
-                                 alpha < 0.0 ? 0.0 : alpha);
+                                 alpha);
     }
 
     ////////////////////////
@@ -585,11 +587,10 @@ namespace Sass {
       bool hsl = h || s || l;
 
       if (rgb && hsl) {
-        error("cannot specify both RGB and HSL values for `adjust-color`", path, position);
+        error("cannot specify both RGB and HSL values for `adjust-color`", pstate);
       }
       if (rgb) {
-        return new (ctx.mem) Color(path,
-                                   position,
+        return new (ctx.mem) Color(pstate,
                                    color->r() + (r ? r->value() : 0),
                                    color->g() + (g ? g->value() : 0),
                                    color->b() + (b ? b->value() : 0),
@@ -602,18 +603,16 @@ namespace Sass {
                          hsl_struct.l + (l ? l->value() : 0),
                          color->a() + (a ? a->value() : 0),
                          ctx,
-                         path,
-                         position);
+                         pstate);
       }
       if (a) {
-        return new (ctx.mem) Color(path,
-                                   position,
+        return new (ctx.mem) Color(pstate,
                                    color->r(),
                                    color->g(),
                                    color->b(),
                                    color->a() + (a ? a->value() : 0));
       }
-      error("not enough arguments for `adjust-color`", path, position);
+      error("not enough arguments for `adjust-color`", pstate);
       // unreachable
       return color;
     }
@@ -634,15 +633,14 @@ namespace Sass {
       bool hsl = h || s || l;
 
       if (rgb && hsl) {
-        error("cannot specify both RGB and HSL values for `scale-color`", path, position);
+        error("cannot specify both RGB and HSL values for `scale-color`", pstate);
       }
       if (rgb) {
         double rscale = (r ? ARGR("$red",   Number, -100.0, 100.0)->value() : 0.0) / 100.0;
         double gscale = (g ? ARGR("$green", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
         double bscale = (b ? ARGR("$blue",  Number, -100.0, 100.0)->value() : 0.0) / 100.0;
         double ascale = (a ? ARGR("$alpha", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
-        return new (ctx.mem) Color(path,
-                                   position,
+        return new (ctx.mem) Color(pstate,
                                    color->r() + rscale * (rscale > 0.0 ? 255 - color->r() : color->r()),
                                    color->g() + gscale * (gscale > 0.0 ? 255 - color->g() : color->g()),
                                    color->b() + bscale * (bscale > 0.0 ? 255 - color->b() : color->b()),
@@ -657,19 +655,18 @@ namespace Sass {
         hsl_struct.h += hscale * (hscale > 0.0 ? 360.0 - hsl_struct.h : hsl_struct.h);
         hsl_struct.s += sscale * (sscale > 0.0 ? 100.0 - hsl_struct.s : hsl_struct.s);
         hsl_struct.l += lscale * (lscale > 0.0 ? 100.0 - hsl_struct.l : hsl_struct.l);
-        double alpha = color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->r());
-        return hsla_impl(hsl_struct.h, hsl_struct.s, hsl_struct.l, alpha, ctx, path, position);
+        double alpha = color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a());
+        return hsla_impl(hsl_struct.h, hsl_struct.s, hsl_struct.l, alpha, ctx, pstate);
       }
       if (a) {
         double ascale = (a ? ARGR("$alpha", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
-        return new (ctx.mem) Color(path,
-                                   position,
+        return new (ctx.mem) Color(pstate,
                                    color->r(),
                                    color->g(),
                                    color->b(),
                                    color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));
       }
-      error("not enough arguments for `scale-color`", path, position);
+      error("not enough arguments for `scale-color`", pstate);
       // unreachable
       return color;
     }
@@ -690,11 +687,10 @@ namespace Sass {
       bool hsl = h || s || l;
 
       if (rgb && hsl) {
-        error("cannot specify both RGB and HSL values for `change-color`", path, position);
+        error("cannot specify both RGB and HSL values for `change-color`", pstate);
       }
       if (rgb) {
-        return new (ctx.mem) Color(path,
-                                   position,
+        return new (ctx.mem) Color(pstate,
                                    r ? ARGR("$red",   Number, 0, 255)->value() : color->r(),
                                    g ? ARGR("$green", Number, 0, 255)->value() : color->g(),
                                    b ? ARGR("$blue",  Number, 0, 255)->value() : color->b(),
@@ -706,18 +702,17 @@ namespace Sass {
         if (s) hsl_struct.s = ARGR("$saturation", Number, 0, 100)->value();
         if (l) hsl_struct.l = ARGR("$lightness",  Number, 0, 100)->value();
         double alpha = a ? ARGR("$alpha", Number, 0, 1.0)->value() : color->a();
-        return hsla_impl(hsl_struct.h, hsl_struct.s, hsl_struct.l, alpha, ctx, path, position);
+        return hsla_impl(hsl_struct.h, hsl_struct.s, hsl_struct.l, alpha, ctx, pstate);
       }
       if (a) {
         double alpha = a ? ARGR("$alpha", Number, 0, 1.0)->value() : color->a();
-        return new (ctx.mem) Color(path,
-                                   position,
+        return new (ctx.mem) Color(pstate,
                                    color->r(),
                                    color->g(),
                                    color->b(),
                                    alpha);
       }
-      error("not enough arguments for `change-color`", path, position);
+      error("not enough arguments for `change-color`", pstate);
       // unreachable
       return color;
     }
@@ -749,7 +744,7 @@ namespace Sass {
       for (size_t i = 0, L = result.length(); i < L; ++i) {
         result[i] = std::toupper(result[i]);
       }
-      return new (ctx.mem) String_Constant(path, position, result);
+      return new (ctx.mem) String_Constant(pstate, result);
     }
 
     ///////////////////
@@ -759,24 +754,24 @@ namespace Sass {
     Signature unquote_sig = "unquote($string)";
     BUILT_IN(sass_unquote)
     {
-      To_String to_string;
+      To_String to_string(&ctx);
       AST_Node* arg = env["$string"];
-      string org(arg->perform(&to_string));
-      string str(unquote(org));
-      String_Constant* result = new (ctx.mem) String_Constant(path, position, str);
-      // remember if the string was quoted (color tokens)
-      if (org[0] != str[0]) result->needs_unquoting(true);
-      result->is_delayed(true);
-      return result;
+      if (String_Quoted* string_quoted = dynamic_cast<String_Quoted*>(arg)) {
+        String_Constant* result = new (ctx.mem) String_Constant(pstate, string_quoted->value());
+        // remember if the string was quoted (color tokens)
+        result->sass_fix_1291(string_quoted->quote_mark() != 0);
+        return result;
+      }
+      return new (ctx.mem) String_Constant(pstate, string(arg->perform(&to_string)));
     }
 
     Signature quote_sig = "quote($string)";
     BUILT_IN(sass_quote)
     {
-      To_String to_string;
+      To_String to_string(&ctx);
       AST_Node* arg = env["$string"];
       string str(quote(arg->perform(&to_string), String_Constant::double_quote()));
-      String_Constant* result = new (ctx.mem) String_Constant(path, position, str);
+      String_Constant* result = new (ctx.mem) String_Constant(pstate, str);
       result->is_delayed(true);
       return result;
     }
@@ -788,33 +783,24 @@ namespace Sass {
       size_t len = string::npos;
       try {
         String_Constant* s = ARG("$string", String_Constant);
-        string str = s->value();
-        size_t length_of_s = str.size();
-        size_t i = 0;
-
-        if (s->is_quoted()) {
-          ++i;
-          --length_of_s;
-        }
-
-        len = UTF_8::code_point_count(str, i, length_of_s);
+        len = UTF_8::code_point_count(s->value(), 0, s->value().size());
 
       }
       catch (utf8::invalid_code_point) {
         string msg("utf8::invalid_code_point");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (utf8::not_enough_room) {
         string msg("utf8::not_enough_room");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (utf8::invalid_utf8) {
         string msg("utf8::invalid_utf8");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (...) { throw; }
       // return something even if we had an error (-1)
-      return new (ctx.mem) Number(path, position, len);
+      return new (ctx.mem) Number(pstate, len);
     }
 
     Signature str_insert_sig = "str-insert($string, $insert, $index)";
@@ -824,7 +810,6 @@ namespace Sass {
       try {
         String_Constant* s = ARG("$string", String_Constant);
         str = s->value();
-        char quotemark = s->quote_mark();
         str = unquote(str);
         String_Constant* i = ARG("$insert", String_Constant);
         string ins = i->value();
@@ -835,7 +820,7 @@ namespace Sass {
 
         if (index > 0 && index <= len) {
           // positive and within string length
-          str.insert(UTF_8::offset_at_position(str, index - 1), ins);
+          str.insert(UTF_8::offset_at_position(str, static_cast<size_t>(index) - 1), ins);
         }
         else if (index > len) {
           // positive and past string length
@@ -847,31 +832,31 @@ namespace Sass {
         else if (std::abs(index) <= len) {
           // negative and within string length
           index += len + 1;
-          str.insert(UTF_8::offset_at_position(str, index), ins);
+          str.insert(UTF_8::offset_at_position(str, static_cast<size_t>(index)), ins);
         }
         else {
           // negative and past string length
           str = ins + str;
         }
 
-        if (quotemark) {
-          str = quote(str, String_Constant::double_quote());
+        if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
+          if (ss->quote_mark()) str = quote(str);
         }
       }
       catch (utf8::invalid_code_point) {
         string msg("utf8::invalid_code_point");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (utf8::not_enough_room) {
         string msg("utf8::not_enough_room");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (utf8::invalid_utf8) {
         string msg("utf8::invalid_utf8");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (...) { throw; }
-      return new (ctx.mem) String_Constant(path, position, str);
+      return new (ctx.mem) String_Constant(pstate, str);
     }
 
     Signature str_index_sig = "str-index($string, $substring)";
@@ -888,25 +873,25 @@ namespace Sass {
 
         size_t c_index = str.find(substr);
         if(c_index == string::npos) {
-          return new (ctx.mem) Null(path, position);
+          return new (ctx.mem) Null(pstate);
         }
         index = UTF_8::code_point_count(str, 0, c_index) + 1;
       }
       catch (utf8::invalid_code_point) {
         string msg("utf8::invalid_code_point");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (utf8::not_enough_room) {
         string msg("utf8::not_enough_room");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (utf8::invalid_utf8) {
         string msg("utf8::invalid_utf8");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (...) { throw; }
       // return something even if we had an error (-1)
-      return new (ctx.mem) Number(path, position, index);
+      return new (ctx.mem) Number(pstate, index);
     }
 
     Signature str_slice_sig = "str-slice($string, $start-at, $end-at:-1)";
@@ -918,39 +903,44 @@ namespace Sass {
         Number* n = ARG("$start-at", Number);
         Number* m = ARG("$end-at", Number);
 
-        string str = s->value();
-        char quotemark = s->quote_mark();
-        str = unquote(str);
+        string str = unquote(s->value());
 
         // normalize into 0-based indices
-        size_t start = UTF_8::offset_at_position(str, UTF_8::normalize_index(n->value(), UTF_8::code_point_count(str)));
-        size_t end = UTF_8::offset_at_position(str, UTF_8::normalize_index(m->value(), UTF_8::code_point_count(str)));
+        size_t start = UTF_8::offset_at_position(str, UTF_8::normalize_index(static_cast<int>(n->value()), UTF_8::code_point_count(str)));
+        size_t end = UTF_8::offset_at_position(str, UTF_8::normalize_index(static_cast<int>(m->value()), UTF_8::code_point_count(str)));
 
         // `str-slice` should always return an empty string when $end-at == 0
         // `normalize_index` normalizes 1 -> 0 so we need to check the original value
-        if(start == end && m->value() > 0) {
+        if(m->value() == 0) {
+          if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
+            if(!ss->quote_mark()) return new (ctx.mem) Null(pstate);
+          } else {
+            return new (ctx.mem) Null(pstate);
+          }
+          newstr = "";
+        } else if(start == end && m->value() != 0) {
           newstr = str.substr(start, 1);
         } else if(end > start) {
           newstr = str.substr(start, end - start + UTF_8::code_point_size_at_offset(str, end));
         }
-        if(quotemark) {
-          newstr = quote(newstr, String_Constant::double_quote());
+        if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
+          if(ss->quote_mark()) newstr = quote(newstr);
         }
       }
       catch (utf8::invalid_code_point) {
         string msg("utf8::invalid_code_point");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (utf8::not_enough_room) {
         string msg("utf8::not_enough_room");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (utf8::invalid_utf8) {
         string msg("utf8::invalid_utf8");
-        error(msg, path, position, backtrace);
+        error(msg, pstate, backtrace);
       }
       catch (...) { throw; }
-      return new (ctx.mem) String_Constant(path, position, newstr);
+      return new (ctx.mem) String_Constant(pstate, newstr);
     }
 
     Signature to_upper_case_sig = "to-upper-case($string)";
@@ -965,7 +955,10 @@ namespace Sass {
         }
       }
 
-      return new (ctx.mem) String_Constant(path, position, str);
+      if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
+        str = ss->quote_mark() ? quote(str) : str;
+      }
+      return new (ctx.mem) String_Constant(pstate, str);
     }
 
     Signature to_lower_case_sig = "to-lower-case($string)";
@@ -980,89 +973,90 @@ namespace Sass {
         }
       }
 
-      return new (ctx.mem) String_Constant(path, position, str);
+      if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
+        str = ss->quote_mark() ? quote(str, '"') : str;
+      }
+      return new (ctx.mem) String_Constant(pstate, str);
     }
 
     ///////////////////
     // NUMBER FUNCTIONS
     ///////////////////
 
-    Signature percentage_sig = "percentage($value)";
+    Signature percentage_sig = "percentage($number)";
     BUILT_IN(percentage)
     {
-      Number* n = ARG("$value", Number);
-      if (!n->is_unitless()) error("argument $value of `" + string(sig) + "` must be unitless", path, position);
-      return new (ctx.mem) Number(path, position, n->value() * 100, "%");
+      Number* n = ARG("$number", Number);
+      if (!n->is_unitless()) error("argument $number of `" + string(sig) + "` must be unitless", pstate);
+      return new (ctx.mem) Number(pstate, n->value() * 100, "%");
     }
 
-    Signature round_sig = "round($value)";
+    Signature round_sig = "round($number)";
     BUILT_IN(round)
     {
-      Number* n = ARG("$value", Number);
+      Number* n = ARG("$number", Number);
       Number* r = new (ctx.mem) Number(*n);
-      r->path(path);
-      r->position(position);
+      r->pstate(pstate);
       r->value(std::floor(r->value() + 0.5));
       return r;
     }
 
-    Signature ceil_sig = "ceil($value)";
+    Signature ceil_sig = "ceil($number)";
     BUILT_IN(ceil)
     {
-      Number* n = ARG("$value", Number);
+      Number* n = ARG("$number", Number);
       Number* r = new (ctx.mem) Number(*n);
-      r->path(path);
-      r->position(position);
+      r->pstate(pstate);
       r->value(std::ceil(r->value()));
       return r;
     }
 
-    Signature floor_sig = "floor($value)";
+    Signature floor_sig = "floor($number)";
     BUILT_IN(floor)
     {
-      Number* n = ARG("$value", Number);
+      Number* n = ARG("$number", Number);
       Number* r = new (ctx.mem) Number(*n);
-      r->path(path);
-      r->position(position);
+      r->pstate(pstate);
       r->value(std::floor(r->value()));
       return r;
     }
 
-    Signature abs_sig = "abs($value)";
+    Signature abs_sig = "abs($number)";
     BUILT_IN(abs)
     {
-      Number* n = ARG("$value", Number);
+      Number* n = ARG("$number", Number);
       Number* r = new (ctx.mem) Number(*n);
-      r->path(path);
-      r->position(position);
+      r->pstate(pstate);
       r->value(std::abs(r->value()));
       return r;
     }
 
-    Signature min_sig = "min($x1, $x2...)";
+    Signature min_sig = "min($numbers...)";
     BUILT_IN(min)
     {
-      Number* x1 = ARG("$x1", Number);
-      List* arglist = ARG("$x2", List);
-      Number* least = x1;
+      List* arglist = ARG("$numbers", List);
+      Number* least = 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Number* xi = dynamic_cast<Number*>(arglist->value_at_index(i));
-        if (!xi) error("`" + string(sig) + "` only takes numeric arguments", path, position);
-        if (lt(xi, least, ctx)) least = xi;
+        if (least) {
+          if (!xi) error("`" + string(sig) + "` only takes numeric arguments", pstate);
+          if (lt(xi, least, ctx)) least = xi;
+        } else least = xi;
       }
       return least;
     }
 
-    Signature max_sig = "max($x1, $x2...)";
+    Signature max_sig = "max($numbers...)";
     BUILT_IN(max)
     {
-      Number* x1 = ARG("$x1", Number);
-      List* arglist = ARG("$x2", List);
-      Number* greatest = x1;
+      List* arglist = ARG("$numbers", List);
+      Number* greatest = 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Number* xi = dynamic_cast<Number*>(arglist->value_at_index(i));
-        if (!xi) error("`" + string(sig) + "` only takes numeric arguments", path, position);
-        if (lt(greatest, xi, ctx)) greatest = xi;
+        if (greatest) {
+          if (!xi) error("`" + string(sig) + "` only takes numeric arguments", pstate);
+          if (lt(greatest, xi, ctx)) greatest = xi;
+        } else greatest = xi;
       }
       return greatest;
     }
@@ -1071,16 +1065,16 @@ namespace Sass {
     BUILT_IN(random)
     {
       Number* l = dynamic_cast<Number*>(env["$limit"]);
-      if (l && trunc(l->value()) != l->value()) error("argument $limit of `" + string(sig) + "` must be an integer", path, position);
+      if (l && trunc(l->value()) != l->value()) error("argument $limit of `" + string(sig) + "` must be an integer", pstate);
       if (l) {
         uniform_real_distribution<> distributor(1, l->value() + 1);
-        uint_fast32_t distributed = distributor(rand);
-        return new (ctx.mem) Number(path, position, (double)distributed);
+        uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
+        return new (ctx.mem) Number(pstate, (double)distributed);
       }
       else {
         uniform_real_distribution<> distributor(0, 1);
-        uint_fast32_t distributed = distributor(rand);
-        return new (ctx.mem) Number(path, position, trunc(distributed));
+        uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
+        return new (ctx.mem) Number(pstate, trunc(distributed));
      }
     }
 
@@ -1094,14 +1088,12 @@ namespace Sass {
       Expression* v = ARG("$list", Expression);
       if (v->concrete_type() == Expression::MAP) {
         Map* map = dynamic_cast<Map*>(env["$list"]);
-        return new (ctx.mem) Number(path,
-                                    position,
+        return new (ctx.mem) Number(pstate,
                                     map ? map->length() : 1);
       }
 
       List* list = dynamic_cast<List*>(env["$list"]);
-      return new (ctx.mem) Number(path,
-                                  position,
+      return new (ctx.mem) Number(pstate,
                                   list ? list->length() : 1);
     }
 
@@ -1111,26 +1103,26 @@ namespace Sass {
       Map* m = dynamic_cast<Map*>(env["$list"]);
       List* l = dynamic_cast<List*>(env["$list"]);
       Number* n = ARG("$n", Number);
-      if (n->value() == 0) error("argument `$n` of `" + string(sig) + "` must be non-zero", path, position);
+      if (n->value() == 0) error("argument `$n` of `" + string(sig) + "` must be non-zero", pstate);
       // if the argument isn't a list, then wrap it in a singleton list
       if (!m && !l) {
-        l = new (ctx.mem) List(path, position, 1);
+        l = new (ctx.mem) List(pstate, 1);
         *l << ARG("$list", Expression);
       }
       size_t len = m ? m->length() : l->length();
       bool empty = m ? m->empty() : l->empty();
-      if (empty) error("argument `$list` of `" + string(sig) + "` must not be empty", path, position);
+      if (empty) error("argument `$list` of `" + string(sig) + "` must not be empty", pstate);
       double index = std::floor(n->value() < 0 ? len + n->value() : n->value() - 1);
-      if (index < 0 || index > len - 1) error("index out of bounds for `" + string(sig) + "`", path, position);
+      if (index < 0 || index > len - 1) error("index out of bounds for `" + string(sig) + "`", pstate);
 
       if (m) {
-        l = new (ctx.mem) List(path, position, 1);
-        *l << m->keys()[index];
-        *l << m->at(m->keys()[index]);
+        l = new (ctx.mem) List(pstate, 1);
+        *l << m->keys()[static_cast<unsigned int>(index)];
+        *l << m->at(m->keys()[static_cast<unsigned int>(index)]);
         return l;
       }
       else {
-        return l->value_at_index(index);
+        return l->value_at_index(static_cast<int>(index));
       }
     }
 
@@ -1141,13 +1133,13 @@ namespace Sass {
       Number* n = ARG("$n", Number);
       Expression* v = ARG("$value", Expression);
       if (!l) {
-        l = new (ctx.mem) List(path, position, 1);
+        l = new (ctx.mem) List(pstate, 1);
         *l << ARG("$list", Expression);
       }
-      if (l->empty()) error("argument `$list` of `" + string(sig) + "` must not be empty", path, position);
+      if (l->empty()) error("argument `$list` of `" + string(sig) + "` must not be empty", pstate);
       double index = std::floor(n->value() < 0 ? l->length() + n->value() : n->value() - 1);
-      if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + string(sig) + "`", path, position);
-      List* result = new (ctx.mem) List(path, position, l->length(), l->separator());
+      if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + string(sig) + "`", pstate);
+      List* result = new (ctx.mem) List(pstate, l->length(), l->separator());
       for (size_t i = 0, L = l->length(); i < L; ++i) {
         *result << ((i == index) ? v : (*l)[i]);
       }
@@ -1160,13 +1152,13 @@ namespace Sass {
       List* l = dynamic_cast<List*>(env["$list"]);
       Expression* v = ARG("$value", Expression);
       if (!l) {
-        l = new (ctx.mem) List(path, position, 1);
+        l = new (ctx.mem) List(pstate, 1);
         *l << ARG("$list", Expression);
       }
       for (size_t i = 0, L = l->length(); i < L; ++i) {
-        if (eq(l->value_at_index(i), v, ctx)) return new (ctx.mem) Number(path, position, i+1);
+        if (eq(l->value_at_index(i), v, ctx)) return new (ctx.mem) Number(pstate, i+1);
       }
-      return new (ctx.mem) Null(path, position);
+      return new (ctx.mem) Null(pstate);
     }
 
     Signature join_sig = "join($list1, $list2, $separator: auto)";
@@ -1177,20 +1169,20 @@ namespace Sass {
       String_Constant* sep = ARG("$separator", String_Constant);
       List::Separator sep_val = (l1 ? l1->separator() : List::SPACE);
       if (!l1) {
-        l1 = new (ctx.mem) List(path, position, 1);
+        l1 = new (ctx.mem) List(pstate, 1);
         *l1 << ARG("$list1", Expression);
         sep_val = (l2 ? l2->separator() : List::SPACE);
       }
       if (!l2) {
-        l2 = new (ctx.mem) List(path, position, 1);
+        l2 = new (ctx.mem) List(pstate, 1);
         *l2 << ARG("$list2", Expression);
       }
       size_t len = l1->length() + l2->length();
       string sep_str = unquote(sep->value());
       if (sep_str == "space") sep_val = List::SPACE;
       else if (sep_str == "comma") sep_val = List::COMMA;
-      else if (sep_str != "auto") error("argument `$separator` of `" + string(sig) + "` must be `space`, `comma`, or `auto`", path, position);
-      List* result = new (ctx.mem) List(path, position, len, sep_val);
+      else if (sep_str != "auto") error("argument `$separator` of `" + string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
+      List* result = new (ctx.mem) List(pstate, len, sep_val);
       *result += l1;
       *result += l2;
       return result;
@@ -1203,14 +1195,14 @@ namespace Sass {
       Expression* v = ARG("$val", Expression);
       String_Constant* sep = ARG("$separator", String_Constant);
       if (!l) {
-        l = new (ctx.mem) List(path, position, 1);
+        l = new (ctx.mem) List(pstate, 1);
         *l << ARG("$list", Expression);
       }
-      List* result = new (ctx.mem) List(path, position, l->length() + 1, l->separator());
+      List* result = new (ctx.mem) List(pstate, l->length() + 1, l->separator());
       string sep_str(unquote(sep->value()));
       if (sep_str == "space") result->separator(List::SPACE);
       else if (sep_str == "comma") result->separator(List::COMMA);
-      else if (sep_str != "auto") error("argument `$separator` of `" + string(sig) + "` must be `space`, `comma`, or `auto`", path, position);
+      else if (sep_str != "auto") error("argument `$separator` of `" + string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
       *result += l;
       *result << v;
       return result;
@@ -1224,7 +1216,7 @@ namespace Sass {
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         List* ith = dynamic_cast<List*>(arglist->value_at_index(i));
         if (!ith) {
-          ith = new (ctx.mem) List(path, position, 1);
+          ith = new (ctx.mem) List(pstate, 1);
           *ith << arglist->value_at_index(i);
           if (arglist->is_arglist()) {
             ((Argument*)(*arglist)[i])->value(ith);
@@ -1234,10 +1226,10 @@ namespace Sass {
         }
         shortest = (i ? std::min(shortest, ith->length()) : ith->length());
       }
-      List* zippers = new (ctx.mem) List(path, position, shortest, List::COMMA);
+      List* zippers = new (ctx.mem) List(pstate, shortest, List::COMMA);
       size_t L = arglist->length();
       for (size_t i = 0; i < shortest; ++i) {
-        List* zipper = new (ctx.mem) List(path, position, L);
+        List* zipper = new (ctx.mem) List(pstate, L);
         for (size_t j = 0; j < L; ++j) {
           *zipper << (*static_cast<List*>(arglist->value_at_index(j)))[i];
         }
@@ -1249,25 +1241,8 @@ namespace Sass {
     Signature compact_sig = "compact($values...)";
     BUILT_IN(compact)
     {
-      List* arglist = ARG("$values", List);
-      List::Separator sep = List::COMMA;
-      if (arglist->length() == 1) {
-        Expression* the_arg = arglist->value_at_index(0);
-        arglist = dynamic_cast<List*>(the_arg);
-        if (!arglist) {
-          List* result = new (ctx.mem) List(path, position, 1, List::COMMA);
-          *result << the_arg;
-          return result;
-        }
-        sep = arglist->separator();
-      }
-      List* result = new (ctx.mem) List(path, position, 0, sep);
-      for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Boolean* ith = dynamic_cast<Boolean*>(arglist->value_at_index(i));
-        if (ith && ith->value() == false) continue;
-        *result << arglist->value_at_index(i);
-      }
-      return result;
+      error("`compact` has been removed from libsass because it's not part of the Sass spec", pstate);
+      return 0; // suppress warning, error will exit anyway
     }
 
     Signature list_separator_sig = "list_separator($list)";
@@ -1275,11 +1250,10 @@ namespace Sass {
     {
       List* l = dynamic_cast<List*>(env["$list"]);
       if (!l) {
-        l = new (ctx.mem) List(path, position, 1);
+        l = new (ctx.mem) List(pstate, 1);
         *l << ARG("$list", Expression);
       }
-      return new (ctx.mem) String_Constant(path,
-                                           position,
+      return new (ctx.mem) String_Constant(pstate,
                                            l->separator() == List::COMMA ? "comma" : "space");
     }
 
@@ -1295,7 +1269,7 @@ namespace Sass {
       try {
         return m->at(v);
       } catch (const std::out_of_range&) {
-        return new (ctx.mem) Null(path, position);
+        return new (ctx.mem) Null(pstate);
       }
       catch (...) { throw; }
     }
@@ -1305,14 +1279,14 @@ namespace Sass {
     {
       Map* m = ARGM("$map", Map, ctx);
       Expression* v = ARG("$key", Expression);
-      return new (ctx.mem) Boolean(path, position, m->has(v));
+      return new (ctx.mem) Boolean(pstate, m->has(v));
     }
 
     Signature map_keys_sig = "map-keys($map)";
     BUILT_IN(map_keys)
     {
       Map* m = ARGM("$map", Map, ctx);
-      List* result = new (ctx.mem) List(path, position, m->length(), List::COMMA);
+      List* result = new (ctx.mem) List(pstate, m->length(), List::COMMA);
       for ( auto key : m->keys()) {
         *result << key;
       }
@@ -1323,7 +1297,7 @@ namespace Sass {
     BUILT_IN(map_values)
     {
       Map* m = ARGM("$map", Map, ctx);
-      List* result = new (ctx.mem) List(path, position, m->length(), List::COMMA);
+      List* result = new (ctx.mem) List(pstate, m->length(), List::COMMA);
       for ( auto key : m->keys()) {
         *result << m->at(key);
       }
@@ -1337,7 +1311,7 @@ namespace Sass {
       Map* m2 = ARGM("$map2", Map, ctx);
 
       size_t len = m1->length() + m2->length();
-      Map* result = new (ctx.mem) Map(path, position, len);
+      Map* result = new (ctx.mem) Map(pstate, len);
       *result += m1;
       *result += m2;
       return result;
@@ -1349,7 +1323,7 @@ namespace Sass {
       bool remove;
       Map* m = ARGM("$map", Map, ctx);
       List* arglist = ARG("$keys", List);
-      Map* result = new (ctx.mem) Map(path, position, 1);
+      Map* result = new (ctx.mem) Map(pstate, 1);
       for (auto key : m->keys()) {
         remove = false;
         for (size_t j = 0, K = arglist->length(); j < K && !remove; ++j) {
@@ -1364,14 +1338,14 @@ namespace Sass {
     BUILT_IN(keywords)
     {
       List* arglist = new (ctx.mem) List(*ARG("$args", List));
-      Map* result = new (ctx.mem) Map(path, position, 1);
+      Map* result = new (ctx.mem) Map(pstate, 1);
       // The parser ensures the ordering of arguments so we can assert this
       // isn't keyword argument list the first argument isn't a keyword argument
       if (!(arglist->empty() || ((Argument*)(*arglist)[0])->is_keyword_argument())) return result;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         string name = string(((Argument*)(*arglist)[i])->name());
         string sanitized_name = string(name, 1);
-        *result << make_pair(new (ctx.mem) String_Constant(path, position, sanitized_name),
+        *result << make_pair(new (ctx.mem) String_Constant(pstate, sanitized_name),
                              ((Argument*)(*arglist)[i])->value());
       }
       return result;
@@ -1386,22 +1360,22 @@ namespace Sass {
     {
       Expression* v = ARG("$value", Expression);
       if (v->concrete_type() == Expression::STRING) {
-        To_String to_string;
+        To_String to_string(&ctx);
         string str(v->perform(&to_string));
         if (ctx.names_to_colors.count(str)) {
-          return new (ctx.mem) String_Constant(path, position, "color");
+          return new (ctx.mem) String_Constant(pstate, "color");
         }
       }
-      return new (ctx.mem) String_Constant(path, position, ARG("$value", Expression)->type());
+      return new (ctx.mem) String_Constant(pstate, ARG("$value", Expression)->type());
     }
 
     Signature unit_sig = "unit($number)";
     BUILT_IN(unit)
-    { return new (ctx.mem) String_Constant(path, position, quote(ARG("$number", Number)->unit(), '"')); }
+    { return new (ctx.mem) String_Quoted(pstate, quote(ARG("$number", Number)->unit(), '"')); }
 
     Signature unitless_sig = "unitless($number)";
     BUILT_IN(unitless)
-    { return new (ctx.mem) Boolean(path, position, ARG("$number", Number)->is_unitless()); }
+    { return new (ctx.mem) Boolean(pstate, ARG("$number", Number)->is_unitless()); }
 
     Signature comparable_sig = "comparable($number-1, $number-2)";
     BUILT_IN(comparable)
@@ -1409,62 +1383,62 @@ namespace Sass {
       Number* n1 = ARG("$number-1", Number);
       Number* n2 = ARG("$number-2", Number);
       if (n1->is_unitless() || n2->is_unitless()) {
-        return new (ctx.mem) Boolean(path, position, true);
+        return new (ctx.mem) Boolean(pstate, true);
       }
       Number tmp_n2(*n2);
       tmp_n2.normalize(n1->find_convertible_unit());
-      return new (ctx.mem) Boolean(path, position, n1->unit() == tmp_n2.unit());
+      return new (ctx.mem) Boolean(pstate, n1->unit() == tmp_n2.unit());
     }
 
     Signature variable_exists_sig = "variable-exists($name)";
     BUILT_IN(variable_exists)
     {
-      string s = unquote(ARG("$name", String_Constant)->value());
+      string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has("$"+s)) {
-        return new (ctx.mem) Boolean(path, position, true);
+        return new (ctx.mem) Boolean(pstate, true);
       }
       else {
-        return new (ctx.mem) Boolean(path, position, false);
+        return new (ctx.mem) Boolean(pstate, false);
       }
     }
 
     Signature global_variable_exists_sig = "global-variable-exists($name)";
     BUILT_IN(global_variable_exists)
     {
-      string s = unquote(ARG("$name", String_Constant)->value());
+      string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.global_frame_has("$"+s)) {
-        return new (ctx.mem) Boolean(path, position, true);
+        return new (ctx.mem) Boolean(pstate, true);
       }
       else {
-        return new (ctx.mem) Boolean(path, position, false);
+        return new (ctx.mem) Boolean(pstate, false);
       }
     }
 
     Signature function_exists_sig = "function-exists($name)";
     BUILT_IN(function_exists)
     {
-      string s = unquote(ARG("$name", String_Constant)->value());
+      string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.global_frame_has(s+"[f]")) {
-        return new (ctx.mem) Boolean(path, position, true);
+        return new (ctx.mem) Boolean(pstate, true);
       }
       else {
-        return new (ctx.mem) Boolean(path, position, false);
+        return new (ctx.mem) Boolean(pstate, false);
       }
     }
 
     Signature mixin_exists_sig = "mixin-exists($name)";
     BUILT_IN(mixin_exists)
     {
-      string s = unquote(ARG("$name", String_Constant)->value());
+      string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.global_frame_has(s+"[m]")) {
-        return new (ctx.mem) Boolean(path, position, true);
+        return new (ctx.mem) Boolean(pstate, true);
       }
       else {
-        return new (ctx.mem) Boolean(path, position, false);
+        return new (ctx.mem) Boolean(pstate, false);
       }
     }
 
@@ -1474,25 +1448,25 @@ namespace Sass {
       string s = unquote(ARG("$name", String_Constant)->value());
 
       if(features.find(s) == features.end()) {
-        return new (ctx.mem) Boolean(path, position, false);
+        return new (ctx.mem) Boolean(pstate, false);
       }
       else {
-        return new (ctx.mem) Boolean(path, position, true);
+        return new (ctx.mem) Boolean(pstate, true);
       }
     }
 
     Signature call_sig = "call($name, $args...)";
     BUILT_IN(call)
     {
-      string name = unquote(ARG("$name", String_Constant)->value());
+      string name = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
       List* arglist = new (ctx.mem) List(*ARG("$args", List));
 
-      Arguments* args = new (ctx.mem) Arguments(path, position);
+      Arguments* args = new (ctx.mem) Arguments(pstate);
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Argument* arg = new (ctx.mem) Argument(path, position, arglist->value_at_index(i));
+        Argument* arg = new (ctx.mem) Argument(pstate, arglist->value_at_index(i));
         *args << arg;
       }
-      Function_Call* func = new (ctx.mem) Function_Call(path, position, name, args);
+      Function_Call* func = new (ctx.mem) Function_Call(pstate, name, args);
       Eval eval(ctx, &d_env, backtrace);
       return func->perform(&eval);
 
@@ -1504,7 +1478,7 @@ namespace Sass {
 
     Signature not_sig = "not($value)";
     BUILT_IN(sass_not)
-    { return new (ctx.mem) Boolean(path, position, ARG("$value", Expression)->is_false()); }
+    { return new (ctx.mem) Boolean(pstate, ARG("$value", Expression)->is_false()); }
 
     Signature if_sig = "if($condition, $if-true, $if-false)";
     // BUILT_IN(sass_if)
@@ -1528,11 +1502,8 @@ namespace Sass {
     Signature image_url_sig = "image-url($path, $only-path: false, $cache-buster: false)";
     BUILT_IN(image_url)
     {
-      String_Constant* ipath = ARG("$path", String_Constant);
-      bool only_path = !ARG("$only-path", Expression)->is_false();
-      string full_path(quote(ctx.image_path + "/" + unquote(ipath->value()), '"'));
-      if (!only_path) full_path = "url(" + full_path + ")";
-      return new (ctx.mem) String_Constant(path, position, full_path);
+      error("`image_url` has been removed from libsass because it's not part of the Sass spec", pstate);
+      return 0; // suppress warning, error will exit anyway
     }
 
     //////////////////////////
@@ -1544,11 +1515,23 @@ namespace Sass {
     {
       Expression* v = ARG("$value", Expression);
       if (v->concrete_type() == Expression::NULL_VAL) {
-        return new (ctx.mem) String_Constant(path, position, "null");
+        return new (ctx.mem) String_Constant(pstate, "null");
       } else if (v->concrete_type() == Expression::BOOLEAN && *v == 0) {
-        return new (ctx.mem) String_Constant(path, position, "false");
+        return new (ctx.mem) String_Constant(pstate, "false");
+      } else if (v->concrete_type() == Expression::STRING) {
+        return v;
+      } else {
+        Output_Style old_style;
+        old_style = ctx.output_style;
+        ctx.output_style = NESTED;
+        To_String to_string(&ctx);
+        string inspect = v->perform(&to_string);
+        ctx.output_style = old_style;
+        return new (ctx.mem) String_Constant(pstate, inspect);
+
+
       }
-      return v;
+      // return v;
     }
 
     Signature unique_id_sig = "unique-id()";
@@ -1556,9 +1539,9 @@ namespace Sass {
     {
       std::stringstream ss;
       uniform_real_distribution<> distributor(0, 4294967296); // 16^8
-      uint_fast32_t distributed = distributor(rand);
+      uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
       ss << "u" << setfill('0') << setw(8) << std::hex << distributed;
-      return new (ctx.mem) String_Constant(path, position, ss.str());
+      return new (ctx.mem) String_Constant(pstate, ss.str());
     }
 
   }