sassc 1.11.4 → 1.12.0

data/ext/libsass/src/extend.hpp

@@ -5,35 +5,70 @@
 #include <set>
 
 #include "ast.hpp"
+#include "node.hpp"
+#include "eval.hpp"
 #include "operation.hpp"
 #include "subset_map.hpp"
+#include "ast_fwd_decl.hpp"
 
 namespace Sass {
 
-  class Context;
-  class Node;
+  Node subweave(Node& one, Node& two);
 
   class Extend : public Operation_CRTP<void, Extend> {
 
-    Context&            ctx;
     Subset_Map& subset_map;
+    Eval* eval;
 
     void fallback_impl(AST_Node_Ptr n) { }
 
+  private:
+
+    std::unordered_map<
+      Selector_List_Obj, // key
+      Selector_List_Obj, // value
+      HashNodes, // hasher
+      CompareNodes // compare
+    > memoizeList;
+
+    std::unordered_map<
+      Complex_Selector_Obj, // key
+      Node, // value
+      HashNodes, // hasher
+      CompareNodes // compare
+    > memoizeComplex;
+
+    /* this turned out to be too much overhead
+       re-evaluate once we store an ast selector
+    std::unordered_map<
+      Compound_Selector_Obj, // key
+      Node, // value
+      HashNodes, // hasher
+      CompareNodes // compare
+    > memoizeCompound;
+    */
+
+    void extendObjectWithSelectorAndBlock(Ruleset_Ptr pObject);
+    Node extendComplexSelector(Complex_Selector_Ptr sel, CompoundSelectorSet& seen, bool isReplace, bool isOriginal);
+    Node extendCompoundSelector(Compound_Selector_Ptr sel, CompoundSelectorSet& seen, bool isReplace);
+    bool complexSelectorHasExtension(Complex_Selector_Ptr selector, CompoundSelectorSet& seen);
+    Node trim(Node& seqses, bool isReplace);
+    Node weave(Node& path);
+
   public:
-    static Node subweave(Node& one, Node& two, Context& ctx);
-    static Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, Context& ctx, Subset_Map& subset_map, bool isReplace, bool& extendedSomething, std::set<Compound_Selector>& seen);
-    static Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, Context& ctx, Subset_Map& subset_map, bool isReplace, bool& extendedSomething);
-    static Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, Context& ctx, Subset_Map& subset_map, bool isReplace = false) {
+    void setEval(Eval& eval);
+    Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, bool isReplace, bool& extendedSomething, CompoundSelectorSet& seen);
+    Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, bool isReplace = false) {
       bool extendedSomething = false;
-      return extendSelectorList(pSelectorList, ctx, subset_map, isReplace, extendedSomething);
+      CompoundSelectorSet seen;
+      return extendSelectorList(pSelectorList, isReplace, extendedSomething, seen);
     }
-    static Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, Context& ctx, Subset_Map& subset_map, std::set<Compound_Selector>& seen) {
+    Selector_List_Ptr extendSelectorList(Selector_List_Obj pSelectorList, CompoundSelectorSet& seen) {
       bool isReplace = false;
       bool extendedSomething = false;
-      return extendSelectorList(pSelectorList, ctx, subset_map, isReplace, extendedSomething, seen);
+      return extendSelectorList(pSelectorList, isReplace, extendedSomething, seen);
     }
-    Extend(Context&, Subset_Map&);
+    Extend(Subset_Map&);
     ~Extend() { }
 
     void operator()(Block_Ptr);

data/ext/libsass/src/file.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #ifdef _WIN32
 # ifdef __MINGW32__
 #  ifndef off64_t
@@ -9,7 +10,6 @@
 #else
 # include <unistd.h>
 #endif
-#include "sass.hpp"
 #include <iostream>
 #include <fstream>
 #include <cctype>
@@ -20,6 +20,7 @@
 #include "context.hpp"
 #include "prelexer.hpp"
 #include "utf8_string.hpp"
+#include "sass_functions.hpp"
 #include "sass2scss.h"
 
 #ifdef _WIN32
@@ -48,15 +49,22 @@ namespace Sass {
 
     // return the current directory
     // always with forward slashes
+    // always with trailing slash
     std::string get_cwd()
     {
-      const size_t wd_len = 1024;
+      const size_t wd_len = 4096;
       #ifndef _WIN32
         char wd[wd_len];
-        std::string cwd = getcwd(wd, wd_len);
+        char* pwd = getcwd(wd, wd_len);
+        // we should check error for more detailed info (e.g. ENOENT)
+        // http://man7.org/linux/man-pages/man2/getcwd.2.html#ERRORS
+        if (pwd == NULL) throw Exception::OperationError("cwd gone missing");
+        std::string cwd = pwd;
       #else
         wchar_t wd[wd_len];
-        std::string cwd = wstring_to_string(_wgetcwd(wd, wd_len));
+        wchar_t* pwd = _wgetcwd(wd, wd_len);
+        if (pwd == NULL) throw Exception::OperationError("cwd gone missing");
+        std::string cwd = wstring_to_string(pwd);
         //convert backslashes to forward slashes
         replace(cwd.begin(), cwd.end(), '\\', '/');
       #endif
@@ -68,8 +76,15 @@ namespace Sass {
     bool file_exists(const std::string& path)
     {
       #ifdef _WIN32
-        std::wstring wpath = UTF_8::convert_to_utf16(path);
-        DWORD dwAttrib = GetFileAttributesW(wpath.c_str());
+        wchar_t resolved[32768];
+        // windows unicode filepaths are encoded in utf16
+        std::string abspath(join_paths(get_cwd(), path));
+        std::wstring wpath(UTF_8::convert_to_utf16("\\\\?\\" + abspath));
+        std::replace(wpath.begin(), wpath.end(), '/', '\\');
+        DWORD rv = GetFullPathNameW(wpath.c_str(), 32767, resolved, NULL);
+        if (rv > 32767) throw Exception::OperationError("Path is too long");
+        if (rv == 0) throw Exception::OperationError("Path could not be resolved");
+        DWORD dwAttrib = GetFileAttributesW(resolved);
         return (dwAttrib != INVALID_FILE_ATTRIBUTES &&
                (!(dwAttrib & FILE_ATTRIBUTE_DIRECTORY)));
       #else
@@ -99,7 +114,7 @@ namespace Sass {
     // helper function to find the last directory seperator
     inline size_t find_last_folder_separator(const std::string& path, size_t limit = std::string::npos)
     {
-      size_t pos = std::string::npos;
+      size_t pos;
       size_t pos_p = path.find_last_of('/', limit);
       #ifdef _WIN32
         size_t pos_w = path.find_last_of('\\', limit);
@@ -150,7 +165,7 @@ namespace Sass {
       pos = 0; // remove all self references inside the path string
       while((pos = path.find("/./", pos)) != std::string::npos) path.erase(pos, 2);
 
-      pos = 0; // remove all leading and trailing self references
+      // remove all leading and trailing self references
       while(path.length() > 1 && path.substr(0, 2) == "./") path.erase(0, 2);
       while((pos = path.length()) > 1 && path.substr(pos - 2) == "/.") path.erase(pos - 2);
 
@@ -191,6 +206,13 @@ namespace Sass {
       if (is_absolute_path(r)) return r;
       if (l[l.length()-1] != '/') l += '/';
 
+      // this does a logical cleanup of the right hand path
+      // Note that this does collapse x/../y sections into y.
+      // This is by design. If /foo on your system is a symlink
+      // to /bar/baz, then /foo/../cd is actually /bar/cd,
+      // not /cd as a naive ../ removal would give you.
+      // will only work on leading double dot dirs on rhs
+      // therefore it is safe if lhs is already resolved cwd
       while ((r.length() > 3) && ((r.substr(0, 3) == "../") || (r.substr(0, 3)) == "..\\")) {
         size_t L = l.length(), pos = find_last_folder_separator(l, L - 2);
         bool is_slash = pos + 2 == L && (l[pos+1] == '/' || l[pos+1] == '\\');
@@ -301,13 +323,9 @@ namespace Sass {
     // (2) underscore + given
     // (3) underscore + given + extension
     // (4) given + extension
-    std::vector<Include> resolve_includes(const std::string& root, const std::string& file)
+    std::vector<Include> resolve_includes(const std::string& root, const std::string& file, const std::vector<std::string>& exts)
     {
       std::string filename = join_paths(root, file);
-      // supported extensions
-      const std::vector<std::string> exts = {
-        ".scss", ".sass", ".css"
-      };
       // split the filename
       std::string base(dir_name(file));
       std::string name(base_name(file));
@@ -324,20 +342,53 @@ namespace Sass {
       for(auto ext : exts) {
         rel_path = join_paths(base, "_" + name + ext);
         abs_path = join_paths(root, rel_path);
-        if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
+        if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path, ext == ".css" });
       }
       // next test plain name with exts
       for(auto ext : exts) {
         rel_path = join_paths(base, name + ext);
         abs_path = join_paths(root, rel_path);
-        if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
+        if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path, ext == ".css" });
       }
       // nothing found
       return includes;
     }
 
-    // helper function to resolve a filename
+    std::vector<std::string> find_files(const std::string& file, const std::vector<std::string> paths)
+    {
+      std::vector<std::string> includes;
+      for (std::string path : paths) {
+        std::string abs_path(join_paths(path, file));
+        if (file_exists(abs_path)) includes.push_back(abs_path);
+      }
+      return includes;
+    }
+
+    std::vector<std::string> find_files(const std::string& file, struct Sass_Compiler* compiler)
+    {
+      // get the last import entry to get current base directory
+      // struct Sass_Options* options = sass_compiler_get_options(compiler);
+      Sass_Import_Entry import = sass_compiler_get_last_import(compiler);
+      const std::vector<std::string>& incs = compiler->cpp_ctx->include_paths;
+      // create the vector with paths to lookup
+      std::vector<std::string> paths(1 + incs.size());
+      paths.push_back(dir_name(import->abs_path));
+      paths.insert(paths.end(), incs.begin(), incs.end());
+      // dispatch to find files in paths
+      return find_files(file, paths);
+    }
+
+    // helper function to search one file in all include paths
+    // this is normally not used internally by libsass (C-API sugar)
     std::string find_file(const std::string& file, const std::vector<std::string> paths)
+    {
+      if (file.empty()) return file;
+      auto res = find_files(file, paths);
+      return res.empty() ? "" : res.front();
+    }
+
+    // helper function to resolve a filename
+    std::string find_include(const std::string& file, const std::vector<std::string> paths)
     {
       // search in every include path for a match
       for (size_t i = 0, S = paths.size(); i < S; ++i)
@@ -349,20 +400,6 @@ namespace Sass {
       return std::string("");
     }
 
-    // inc paths can be directly passed from C code
-    std::string find_file(const std::string& file, const char* paths[])
-    {
-      if (paths == 0) return std::string("");
-      std::vector<std::string> includes(0);
-      // includes.push_back(".");
-      const char** it = paths;
-      while (it && *it) {
-        includes.push_back(*it);
-        ++it;
-      }
-      return find_file(file, includes);
-    }
-
     // try to load the given filename
     // returned memory must be freed
     // will auto convert .sass files
@@ -371,16 +408,24 @@ namespace Sass {
       #ifdef _WIN32
         BYTE* pBuffer;
         DWORD dwBytes;
+        wchar_t resolved[32768];
         // windows unicode filepaths are encoded in utf16
-        std::wstring wpath = UTF_8::convert_to_utf16(path);
-        HANDLE hFile = CreateFileW(wpath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
+        std::string abspath(join_paths(get_cwd(), path));
+        std::wstring wpath(UTF_8::convert_to_utf16("\\\\?\\" + abspath));
+        std::replace(wpath.begin(), wpath.end(), '/', '\\');
+        DWORD rv = GetFullPathNameW(wpath.c_str(), 32767, resolved, NULL);
+        if (rv > 32767) throw Exception::OperationError("Path is too long");
+        if (rv == 0) throw Exception::OperationError("Path could not be resolved");
+        HANDLE hFile = CreateFileW(resolved, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
         if (hFile == INVALID_HANDLE_VALUE) return 0;
         DWORD dwFileLength = GetFileSize(hFile, NULL);
         if (dwFileLength == INVALID_FILE_SIZE) return 0;
         // allocate an extra byte for the null char
-        pBuffer = (BYTE*)malloc((dwFileLength+1)*sizeof(BYTE));
+        // and another one for edge-cases in lexer
+        pBuffer = (BYTE*)malloc((dwFileLength+2)*sizeof(BYTE));
         ReadFile(hFile, pBuffer, dwFileLength, &dwBytes, NULL);
-        pBuffer[dwFileLength] = '\0';
+        pBuffer[dwFileLength+0] = '\0';
+        pBuffer[dwFileLength+1] = '\0';
         CloseHandle(hFile);
         // just convert from unsigned char*
         char* contents = (char*) pBuffer;
@@ -392,10 +437,12 @@ namespace Sass {
         if (file.is_open()) {
           size_t size = file.tellg();
           // allocate an extra byte for the null char
-          contents = (char*) malloc((size+1)*sizeof(char));
+          // and another one for edge-cases in lexer
+          contents = (char*) malloc((size+2)*sizeof(char));
           file.seekg(0, std::ios::beg);
           file.read(contents, size);
-          contents[size] = '\0';
+          contents[size+0] = '\0';
+          contents[size+1] = '\0';
           file.close();
         }
       #endif
@@ -414,5 +461,25 @@ namespace Sass {
       }
     }
 
+    // split a path string delimited by semicolons or colons (OS dependent)
+    std::vector<std::string> split_path_list(const char* str)
+    {
+      std::vector<std::string> paths;
+      if (str == NULL) return paths;
+      // find delimiter via prelexer (return zero at end)
+      const char* end = Prelexer::find_first<PATH_SEP>(str);
+      // search until null delimiter
+      while (end) {
+        // add path from current position to delimiter
+        paths.push_back(std::string(str, end - str));
+        str = end + 1; // skip delimiter
+        end = Prelexer::find_first<PATH_SEP>(str);
+      }
+      // add path from current position to end
+      paths.push_back(std::string(str));
+      // return back
+      return paths;
+    }
+
   }
 }

data/ext/libsass/src/file.hpp

@@ -4,6 +4,7 @@
 #include <string>
 #include <vector>
 
+#include "sass/context.h"
 #include "ast_fwd_decl.hpp"
 
 namespace Sass {
@@ -47,9 +48,16 @@ namespace Sass {
     std::string abs2rel(const std::string& path, const std::string& base = ".", const std::string& cwd = get_cwd());
 
     // helper function to resolve a filename
+    // searching without variations in all paths
+    std::string find_file(const std::string& file, struct Sass_Compiler* options);
     std::string find_file(const std::string& file, const std::vector<std::string> paths);
-    // inc paths can be directly passed from C code
-    std::string find_file(const std::string& file, const char** paths);
+
+    // helper function to resolve a include filename
+    // this has the original resolve logic for sass include
+    std::string find_include(const std::string& file, const std::vector<std::string> paths);
+
+    // split a path string delimited by semicolons or colons (OS dependent)
+    std::vector<std::string> split_path_list(const char* paths);
 
     // try to load the given filename
     // returned memory must be freed
@@ -81,9 +89,14 @@ namespace Sass {
     public:
       // resolved absolute path
       std::string abs_path;
+      // is a deprecated file type
+      bool deprecated;
     public:
+      Include(const Importer& imp, std::string abs_path, bool deprecated)
+      : Importer(imp), abs_path(abs_path), deprecated(deprecated)
+      { }
       Include(const Importer& imp, std::string abs_path)
-      : Importer(imp), abs_path(abs_path)
+      : Importer(imp), abs_path(abs_path), deprecated(false)
       { }
   };
 
@@ -113,7 +126,11 @@ namespace Sass {
 
   namespace File {
 
-    std::vector<Include> resolve_includes(const std::string& root, const std::string& file);
+    static std::vector<std::string> defaultExtensions = { ".scss", ".sass" };
+
+    std::vector<Include> resolve_includes(const std::string& root, const std::string& file,
+      const std::vector<std::string>& exts = defaultExtensions);
+
 
   }
 

data/ext/libsass/src/functions.cpp

@@ -10,6 +10,7 @@
 #include "eval.hpp"
 #include "util.hpp"
 #include "expand.hpp"
+#include "operators.hpp"
 #include "utf8_string.hpp"
 #include "sass/base.h"
 #include "utf8.h"
@@ -30,9 +31,26 @@
 #include "wincrypt.h"
 #endif
 
-#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)
+#define ARG(argname, argtype) get_arg<argtype>(argname, env, sig, pstate, traces)
+#define ARGM(argname, argtype, ctx) get_arg_m(argname, env, sig, pstate, traces, ctx)
+
+// return a number object (copied since we want to have reduced units)
+#define ARGN(argname) get_arg_n(argname, env, sig, pstate, traces) // Number copy
+
+// special function for weird hsla percent (10px == 10% == 10 != 0.1)
+#define ARGVAL(argname) get_arg_val(argname, env, sig, pstate, traces) // double
+
+// macros for common ranges (u mean unsigned or upper, r for full range)
+#define DARG_U_FACT(argname) get_arg_r(argname, env, sig, pstate, traces, - 0.0, 1.0) // double
+#define DARG_R_FACT(argname) get_arg_r(argname, env, sig, pstate, traces, - 1.0, 1.0) // double
+#define DARG_U_BYTE(argname) get_arg_r(argname, env, sig, pstate, traces, - 0.0, 255.0) // double
+#define DARG_R_BYTE(argname) get_arg_r(argname, env, sig, pstate, traces, - 255.0, 255.0) // double
+#define DARG_U_PRCT(argname) get_arg_r(argname, env, sig, pstate, traces, - 0.0, 100.0) // double
+#define DARG_R_PRCT(argname) get_arg_r(argname, env, sig, pstate, traces, - 100.0, 100.0) // double
+
+// macros for color related inputs (rbg and alpha/opacity values)
+#define COLOR_NUM(argname) color_num(argname, env, sig, pstate, traces) // double
+#define ALPHA_NUM(argname) alpha_num(argname, env, sig, pstate, traces) // double
 
 namespace Sass {
   using std::stringstream;
@@ -40,7 +58,7 @@ namespace Sass {
 
   Definition_Ptr make_native_function(Signature sig, Native_Function func, Context& ctx)
   {
-    Parser sig_parser = Parser::from_c_str(sig, ctx, ParserState("[built-in function]"));
+    Parser sig_parser = Parser::from_c_str(sig, ctx, ctx.traces, ParserState("[built-in function]"));
     sig_parser.lex<Prelexer::identifier>();
     std::string name(Util::normalize_underscores(sig_parser.lexed));
     Parameters_Obj params = sig_parser.parse_parameters();
@@ -58,7 +76,7 @@ namespace Sass {
     using namespace Prelexer;
 
     const char* sig = sass_function_get_signature(c_func);
-    Parser sig_parser = Parser::from_c_str(sig, ctx, ParserState("[c function]"));
+    Parser sig_parser = Parser::from_c_str(sig, ctx, ctx.traces, 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 >,
@@ -84,31 +102,31 @@ namespace Sass {
 
   namespace Functions {
 
-    inline void handle_utf8_error (const ParserState& pstate, Backtrace* backtrace)
+    inline void handle_utf8_error (const ParserState& pstate, Backtraces traces)
     {
       try {
        throw;
       }
       catch (utf8::invalid_code_point) {
         std::string msg("utf8::invalid_code_point");
-        error(msg, pstate, backtrace);
+        error(msg, pstate, traces);
       }
       catch (utf8::not_enough_room) {
         std::string msg("utf8::not_enough_room");
-        error(msg, pstate, backtrace);
+        error(msg, pstate, traces);
       }
       catch (utf8::invalid_utf8) {
         std::string msg("utf8::invalid_utf8");
-        error(msg, pstate, backtrace);
+        error(msg, pstate, traces);
       }
       catch (...) { throw; }
     }
 
     template <typename T>
-    T* get_arg(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace)
+    T* get_arg(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
     {
       // Minimal error handling -- the expectation is that built-ins will be written correctly!
-      T* val = dynamic_cast<T*>(&env[argname]);
+      T* val = Cast<T>(env[argname]);
       if (!val) {
         std::string msg("argument `");
         msg += argname;
@@ -116,74 +134,138 @@ namespace Sass {
         msg += sig;
         msg += "` must be a ";
         msg += T::type_name();
-        error(msg, pstate, backtrace);
+        error(msg, pstate, traces);
       }
       return val;
     }
 
-    Map_Ptr get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx)
+    Map_Ptr get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx)
     {
       // Minimal error handling -- the expectation is that built-ins will be written correctly!
-      Map_Ptr val = SASS_MEMORY_CAST(Map, env[argname]);
+      Map_Ptr val = Cast<Map>(env[argname]);
       if (val) return val;
 
-      List_Ptr lval = SASS_MEMORY_CAST(List, env[argname]);
+      List_Ptr lval = Cast<List>(env[argname]);
       if (lval && lval->length() == 0) return SASS_MEMORY_NEW(Map, pstate, 0);
 
       // fallback on get_arg for error handling
-      val = get_arg<Map>(argname, env, sig, pstate, backtrace);
+      val = get_arg<Map>(argname, env, sig, pstate, traces);
       return val;
     }
 
-    Number_Ptr get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, double lo, double hi, Backtrace* backtrace)
+    double get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, double lo, double hi)
     {
       // Minimal error handling -- the expectation is that built-ins will be written correctly!
-      Number_Ptr val = get_arg<Number>(argname, env, sig, pstate, backtrace);
-      double v = val->value();
+      Number_Ptr val = get_arg<Number>(argname, env, sig, pstate, traces);
+      Number tmpnr(val);
+      tmpnr.reduce();
+      double v = tmpnr.value();
       if (!(lo <= v && v <= hi)) {
         std::stringstream msg;
         msg << "argument `" << argname << "` of `" << sig << "` must be between ";
         msg << lo << " and " << hi;
-        error(msg.str(), pstate, backtrace);
+        error(msg.str(), pstate, traces);
       }
+      return v;
+    }
+
+    Number_Ptr get_arg_n(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      // Minimal error handling -- the expectation is that built-ins will be written correctly!
+      Number_Ptr val = get_arg<Number>(argname, env, sig, pstate, traces);
+      val = SASS_MEMORY_COPY(val);
+      val->reduce();
       return val;
     }
 
-    #define ARGSEL(argname, seltype, contextualize) get_arg_sel<seltype>(argname, env, sig, pstate, backtrace, ctx)
+    double get_arg_v(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      // Minimal error handling -- the expectation is that built-ins will be written correctly!
+      Number_Ptr val = get_arg<Number>(argname, env, sig, pstate, traces);
+      Number tmpnr(val);
+      tmpnr.reduce();
+      /*
+      if (tmpnr.unit() == "%") {
+        tmpnr.value(tmpnr.value() / 100);
+        tmpnr.numerators.clear();
+      } else {
+        if (!tmpnr.is_unitless()) error("argument " + argname + " of `" + std::string(sig) + "` must be unitless", pstate);
+      }
+      */
+      return tmpnr.value();
+    }
+
+    double get_arg_val(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      // Minimal error handling -- the expectation is that built-ins will be written correctly!
+      Number_Ptr val = get_arg<Number>(argname, env, sig, pstate, traces);
+      Number tmpnr(val);
+      tmpnr.reduce();
+      return tmpnr.value();
+    }
+
+    double color_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      Number_Ptr val = get_arg<Number>(argname, env, sig, pstate, traces);
+      Number tmpnr(val);
+      tmpnr.reduce();
+      if (tmpnr.unit() == "%") {
+        return std::min(std::max(tmpnr.value() * 255 / 100.0, 0.0), 255.0);
+      } else {
+        return std::min(std::max(tmpnr.value(), 0.0), 255.0);
+      }
+    }
+
+
+    inline double alpha_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces) {
+      Number_Ptr val = get_arg<Number>(argname, env, sig, pstate, traces);
+      Number tmpnr(val);
+      tmpnr.reduce();
+      if (tmpnr.unit() == "%") {
+        return std::min(std::max(tmpnr.value(), 0.0), 100.0);
+      } else {
+        return std::min(std::max(tmpnr.value(), 0.0), 1.0);
+      }
+    }
+
+    #define ARGSEL(argname, seltype, contextualize) get_arg_sel<seltype>(argname, env, sig, pstate, traces, ctx)
 
     template <typename T>
-    T get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx);
+    T get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx);
 
     template <>
-    Selector_List_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
+    Selector_List_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx) {
       Expression_Obj exp = ARG(argname, Expression);
       if (exp->concrete_type() == Expression::NULL_VAL) {
         std::stringstream msg;
         msg << argname << ": null is not a valid selector: it must be a string,\n";
         msg << "a list of strings, or a list of lists of strings for `" << function_name(sig) << "'";
-        error(msg.str(), pstate);
+        error(msg.str(), pstate, traces);
       }
-      if (String_Constant_Ptr str = SASS_MEMORY_CAST(String_Constant, exp)) {
+      if (String_Constant_Ptr str = Cast<String_Constant>(exp)) {
         str->quote_mark(0);
       }
-      std::string exp_src = exp->to_string(ctx.c_options) + "{";
-      return Parser::parse_selector(exp_src.c_str(), ctx);
+      std::string exp_src = exp->to_string(ctx.c_options);
+      return Parser::parse_selector(exp_src.c_str(), ctx, traces);
     }
 
     template <>
-    Compound_Selector_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
+    Compound_Selector_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx) {
       Expression_Obj exp = ARG(argname, Expression);
       if (exp->concrete_type() == Expression::NULL_VAL) {
         std::stringstream msg;
         msg << argname << ": null is not a string for `" << function_name(sig) << "'";
-        error(msg.str(), pstate);
+        error(msg.str(), pstate, traces);
       }
-      if (String_Constant_Ptr str = SASS_MEMORY_CAST(String_Constant, exp)) {
+      if (String_Constant_Ptr str = Cast<String_Constant>(exp)) {
         str->quote_mark(0);
       }
-      std::string exp_src = exp->to_string(ctx.c_options) + "{";
-      Selector_List_Obj sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
-      return (sel_list->length() > 0) ? &sel_list->first()->tail()->head() : 0;
+      std::string exp_src = exp->to_string(ctx.c_options);
+      Selector_List_Obj sel_list = Parser::parse_selector(exp_src.c_str(), ctx, traces);
+      if (sel_list->length() == 0) return NULL;
+      Complex_Selector_Obj first = sel_list->first();
+      if (!first->tail()) return first->head();
+      return first->tail()->head();
     }
 
     #ifdef __MINGW32__
@@ -219,56 +301,110 @@ namespace Sass {
       "global-variable-shadowing",
       "extend-selector-pseudoclass",
       "at-error",
-      "units-level-3"
+      "units-level-3",
+      "custom-property"
     };
 
     ////////////////
     // RGB FUNCTIONS
     ////////////////
 
-    inline double color_num(Number_Ptr n) {
-      if (n->unit() == "%") {
-        return std::min(std::max(n->value() * 255 / 100.0, 0.0), 255.0);
-      } else {
-        return std::min(std::max(n->value(), 0.0), 255.0);
-      }
-    }
-
-    inline double alpha_num(Number_Ptr n) {
-      if (n->unit() == "%") {
-        return std::min(std::max(n->value(), 0.0), 100.0);
-      } else {
-        return std::min(std::max(n->value(), 0.0), 1.0);
+    inline bool special_number(String_Constant_Ptr s) {
+      if (s) {
+        std::string calc("calc(");
+        std::string var("var(");
+        std::string ss(s->value());
+        return std::equal(calc.begin(), calc.end(), ss.begin()) ||
+               std::equal(var.begin(), var.end(), ss.begin());
       }
+      return false;
     }
 
     Signature rgb_sig = "rgb($red, $green, $blue)";
     BUILT_IN(rgb)
     {
+      if (
+        special_number(Cast<String_Constant>(env["$red"])) ||
+        special_number(Cast<String_Constant>(env["$green"])) ||
+        special_number(Cast<String_Constant>(env["$blue"]))
+      ) {
+        return SASS_MEMORY_NEW(String_Constant, pstate, "rgb("
+                                                        + env["$red"]->to_string()
+                                                        + ", "
+                                                        + env["$green"]->to_string()
+                                                        + ", "
+                                                        + env["$blue"]->to_string()
+                                                        + ")"
+        );
+      }
+
       return SASS_MEMORY_NEW(Color,
                              pstate,
-                             color_num(ARG("$red",   Number)),
-                             color_num(ARG("$green", Number)),
-                             color_num(ARG("$blue",  Number)));
+                             COLOR_NUM("$red"),
+                             COLOR_NUM("$green"),
+                             COLOR_NUM("$blue"));
     }
 
     Signature rgba_4_sig = "rgba($red, $green, $blue, $alpha)";
     BUILT_IN(rgba_4)
     {
+      if (
+        special_number(Cast<String_Constant>(env["$red"])) ||
+        special_number(Cast<String_Constant>(env["$green"])) ||
+        special_number(Cast<String_Constant>(env["$blue"])) ||
+        special_number(Cast<String_Constant>(env["$alpha"]))
+      ) {
+        return SASS_MEMORY_NEW(String_Constant, pstate, "rgba("
+                                                        + env["$red"]->to_string()
+                                                        + ", "
+                                                        + env["$green"]->to_string()
+                                                        + ", "
+                                                        + env["$blue"]->to_string()
+                                                        + ", "
+                                                        + env["$alpha"]->to_string()
+                                                        + ")"
+        );
+      }
+
       return SASS_MEMORY_NEW(Color,
                              pstate,
-                             color_num(ARG("$red",   Number)),
-                             color_num(ARG("$green", Number)),
-                             color_num(ARG("$blue",  Number)),
-                             alpha_num(ARG("$alpha", Number)));
+                             COLOR_NUM("$red"),
+                             COLOR_NUM("$green"),
+                             COLOR_NUM("$blue"),
+                             ALPHA_NUM("$alpha"));
     }
 
     Signature rgba_2_sig = "rgba($color, $alpha)";
     BUILT_IN(rgba_2)
     {
+      if (
+        special_number(Cast<String_Constant>(env["$color"]))
+      ) {
+        return SASS_MEMORY_NEW(String_Constant, pstate, "rgba("
+                                                        + env["$color"]->to_string()
+                                                        + ", "
+                                                        + env["$alpha"]->to_string()
+                                                        + ")"
+        );
+      }
+
       Color_Ptr c_arg = ARG("$color", Color);
+
+      if (
+        special_number(Cast<String_Constant>(env["$alpha"]))
+      ) {
+        std::stringstream strm;
+        strm << "rgba("
+                 << (int)c_arg->r() << ", "
+                 << (int)c_arg->g() << ", "
+                 << (int)c_arg->b() << ", "
+                 << env["$alpha"]->to_string()
+             << ")";
+        return SASS_MEMORY_NEW(String_Constant, pstate, strm.str());
+      }
+
       Color_Ptr new_c = SASS_MEMORY_COPY(c_arg);
-      new_c->a(alpha_num(ARG("$alpha", Number)));
+      new_c->a(ALPHA_NUM("$alpha"));
       new_c->disp("");
       return new_c;
     }
@@ -285,14 +421,8 @@ namespace Sass {
     BUILT_IN(blue)
     { return SASS_MEMORY_NEW(Number, pstate, ARG("$color", Color)->b()); }
 
-    Signature mix_sig = "mix($color-1, $color-2, $weight: 50%)";
-    BUILT_IN(mix)
-    {
-      Color_Ptr  color1 = ARG("$color-1", Color);
-      Color_Ptr  color2 = ARG("$color-2", Color);
-      Number_Ptr weight = ARGR("$weight", Number, 0, 100);
-
-      double p = weight->value()/100;
+    Color* colormix(Context& ctx, ParserState& pstate, Color* color1, Color* color2, double weight) {
+      double p = weight/100;
       double w = 2*p - 1;
       double a = color1->a() - color2->a();
 
@@ -307,6 +437,16 @@ namespace Sass {
                              color1->a()*p + color2->a()*(1-p));
     }
 
+    Signature mix_sig = "mix($color-1, $color-2, $weight: 50%)";
+    BUILT_IN(mix)
+    {
+      Color_Obj  color1 = ARG("$color-1", Color);
+      Color_Obj  color2 = ARG("$color-2", Color);
+      double weight = DARG_U_PRCT("$weight");
+      return colormix(ctx, pstate, color1, color2, weight);
+
+    }
+
     ////////////////
     // HSL FUNCTIONS
     ////////////////
@@ -323,9 +463,11 @@ namespace Sass {
       double min = std::min(r, std::min(g, b));
       double delta = max - min;
 
-      double h = 0, s = 0, l = (max + min) / 2.0;
+      double h = 0;
+      double s;
+      double l = (max + min) / 2.0;
 
-      if (max == min) {
+      if (NEAR_EQUAL(max, min)) {
         h = s = 0; // achromatic
       }
       else {
@@ -390,9 +532,24 @@ namespace Sass {
     Signature hsl_sig = "hsl($hue, $saturation, $lightness)";
     BUILT_IN(hsl)
     {
-      return hsla_impl(ARG("$hue", Number)->value(),
-                       ARG("$saturation", Number)->value(),
-                       ARG("$lightness",  Number)->value(),
+      if (
+        special_number(Cast<String_Constant>(env["$hue"])) ||
+        special_number(Cast<String_Constant>(env["$saturation"])) ||
+        special_number(Cast<String_Constant>(env["$lightness"]))
+      ) {
+        return SASS_MEMORY_NEW(String_Constant, pstate, "hsl("
+                                                        + env["$hue"]->to_string()
+                                                        + ", "
+                                                        + env["$saturation"]->to_string()
+                                                        + ", "
+                                                        + env["$lightness"]->to_string()
+                                                        + ")"
+        );
+      }
+
+      return hsla_impl(ARGVAL("$hue"),
+                       ARGVAL("$saturation"),
+                       ARGVAL("$lightness"),
                        1.0,
                        ctx,
                        pstate);
@@ -401,10 +558,28 @@ namespace Sass {
     Signature hsla_sig = "hsla($hue, $saturation, $lightness, $alpha)";
     BUILT_IN(hsla)
     {
-      return hsla_impl(ARG("$hue", Number)->value(),
-                       ARG("$saturation", Number)->value(),
-                       ARG("$lightness",  Number)->value(),
-                       ARG("$alpha",  Number)->value(),
+      if (
+        special_number(Cast<String_Constant>(env["$hue"])) ||
+        special_number(Cast<String_Constant>(env["$saturation"])) ||
+        special_number(Cast<String_Constant>(env["$lightness"])) ||
+        special_number(Cast<String_Constant>(env["$alpha"]))
+      ) {
+        return SASS_MEMORY_NEW(String_Constant, pstate, "hsla("
+                                                        + env["$hue"]->to_string()
+                                                        + ", "
+                                                        + env["$saturation"]->to_string()
+                                                        + ", "
+                                                        + env["$lightness"]->to_string()
+                                                        + ", "
+                                                        + env["$alpha"]->to_string()
+                                                        + ")"
+        );
+      }
+
+      return hsla_impl(ARGVAL("$hue"),
+                       ARGVAL("$saturation"),
+                       ARGVAL("$lightness"),
+                       ARGVAL("$alpha"),
                        ctx,
                        pstate);
     }
@@ -443,11 +618,11 @@ namespace Sass {
     BUILT_IN(adjust_hue)
     {
       Color_Ptr rgb_color = ARG("$color", Color);
-      Number_Ptr degrees = ARG("$degrees", Number);
+      double degrees = ARGVAL("$degrees");
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
-      return hsla_impl(hsl_color.h + degrees->value(),
+      return hsla_impl(hsl_color.h + degrees,
                        hsl_color.s,
                        hsl_color.l,
                        rgb_color->a(),
@@ -459,7 +634,7 @@ namespace Sass {
     BUILT_IN(lighten)
     {
       Color_Ptr rgb_color = ARG("$color", Color);
-      Number_Ptr amount = ARGR("$amount", Number, 0, 100);
+      double amount = DARG_U_PRCT("$amount");
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
@@ -471,7 +646,7 @@ namespace Sass {
 
       return hsla_impl(hsl_color.h,
                        hsl_color.s,
-                       hslcolorL + amount->value(),
+                       hslcolorL + amount,
                        rgb_color->a(),
                        ctx,
                        pstate);
@@ -481,7 +656,7 @@ namespace Sass {
     BUILT_IN(darken)
     {
       Color_Ptr rgb_color = ARG("$color", Color);
-      Number_Ptr amount = ARGR("$amount", Number, 0, 100);
+      double amount = DARG_U_PRCT("$amount");
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
@@ -494,7 +669,7 @@ namespace Sass {
 
       return hsla_impl(hsl_color.h,
                        hsl_color.s,
-                       hslcolorL - amount->value(),
+                       hslcolorL - amount,
                        rgb_color->a(),
                        ctx,
                        pstate);
@@ -504,18 +679,17 @@ namespace Sass {
     BUILT_IN(saturate)
     {
       // CSS3 filter function overload: pass literal through directly
-      Number_Ptr amount = SASS_MEMORY_CAST(Number, env["$amount"]);
-      if (!amount) {
+      if (!Cast<Number>(env["$amount"])) {
         return SASS_MEMORY_NEW(String_Quoted, pstate, "saturate(" + env["$color"]->to_string(ctx.c_options) + ")");
       }
 
-      ARGR("$amount", Number, 0, 100);
+      double amount = DARG_U_PRCT("$amount");
       Color_Ptr rgb_color = ARG("$color", Color);
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
 
-      double hslcolorS = hsl_color.s + amount->value();
+      double hslcolorS = hsl_color.s + amount;
 
       // Saturation cannot be below 0 or above 100
       if (hslcolorS < 0) {
@@ -537,12 +711,12 @@ namespace Sass {
     BUILT_IN(desaturate)
     {
       Color_Ptr rgb_color = ARG("$color", Color);
-      Number_Ptr amount = ARGR("$amount", Number, 0, 100);
+      double amount = DARG_U_PRCT("$amount");
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
 
-      double hslcolorS = hsl_color.s - amount->value();
+      double hslcolorS = hsl_color.s - amount;
 
       // Saturation cannot be below 0 or above 100
       if (hslcolorS <= 0) {
@@ -564,7 +738,7 @@ namespace Sass {
     BUILT_IN(grayscale)
     {
       // CSS3 filter function overload: pass literal through directly
-      Number_Ptr amount = SASS_MEMORY_CAST(Number, env["$color"]);
+      Number_Ptr amount = Cast<Number>(env["$color"]);
       if (amount) {
         return SASS_MEMORY_NEW(String_Quoted, pstate, "grayscale(" + amount->to_string(ctx.c_options) + ")");
       }
@@ -596,22 +770,24 @@ namespace Sass {
                        pstate);
     }
 
-    Signature invert_sig = "invert($color)";
+    Signature invert_sig = "invert($color, $weight: 100%)";
     BUILT_IN(invert)
     {
       // CSS3 filter function overload: pass literal through directly
-      Number_Ptr amount = SASS_MEMORY_CAST(Number, env["$color"]);
+      Number_Ptr amount = Cast<Number>(env["$color"]);
       if (amount) {
         return SASS_MEMORY_NEW(String_Quoted, pstate, "invert(" + amount->to_string(ctx.c_options) + ")");
       }
 
+      double weight = DARG_U_PRCT("$weight");
       Color_Ptr rgb_color = ARG("$color", Color);
-      return SASS_MEMORY_NEW(Color,
+      Color_Obj inv = SASS_MEMORY_NEW(Color,
                              pstate,
                              255 - rgb_color->r(),
                              255 - rgb_color->g(),
                              255 - rgb_color->b(),
                              rgb_color->a());
+      return colormix(ctx, pstate, inv, rgb_color, weight);
     }
 
     ////////////////////
@@ -621,13 +797,13 @@ namespace Sass {
     Signature opacity_sig = "opacity($color)";
     BUILT_IN(alpha)
     {
-      String_Constant_Ptr ie_kwd = SASS_MEMORY_CAST(String_Constant, env["$color"]);
+      String_Constant_Ptr ie_kwd = Cast<String_Constant>(env["$color"]);
       if (ie_kwd) {
         return SASS_MEMORY_NEW(String_Quoted, pstate, "alpha(" + ie_kwd->value() + ")");
       }
 
       // CSS3 filter function overload: pass literal through directly
-      Number_Ptr amount = SASS_MEMORY_CAST(Number, env["$color"]);
+      Number_Ptr amount = Cast<Number>(env["$color"]);
       if (amount) {
         return SASS_MEMORY_NEW(String_Quoted, pstate, "opacity(" + amount->to_string(ctx.c_options) + ")");
       }
@@ -640,7 +816,7 @@ namespace Sass {
     BUILT_IN(opacify)
     {
       Color_Ptr color = ARG("$color", Color);
-      double amount = ARGR("$amount", Number, 0, 1)->value();
+      double amount = DARG_U_FACT("$amount");
       double alpha = std::min(color->a() + amount, 1.0);
       return SASS_MEMORY_NEW(Color,
                              pstate,
@@ -655,7 +831,7 @@ namespace Sass {
     BUILT_IN(transparentize)
     {
       Color_Ptr color = ARG("$color", Color);
-      double amount = ARGR("$amount", Number, 0, 1)->value();
+      double amount = DARG_U_FACT("$amount");
       double alpha = std::max(color->a() - amount, 0.0);
       return SASS_MEMORY_NEW(Color,
                              pstate,
@@ -673,25 +849,25 @@ namespace Sass {
     BUILT_IN(adjust_color)
     {
       Color_Ptr color = ARG("$color", Color);
-      Number_Ptr r = SASS_MEMORY_CAST(Number, env["$red"]);
-      Number_Ptr g = SASS_MEMORY_CAST(Number, env["$green"]);
-      Number_Ptr b = SASS_MEMORY_CAST(Number, env["$blue"]);
-      Number_Ptr h = SASS_MEMORY_CAST(Number, env["$hue"]);
-      Number_Ptr s = SASS_MEMORY_CAST(Number, env["$saturation"]);
-      Number_Ptr l = SASS_MEMORY_CAST(Number, env["$lightness"]);
-      Number_Ptr a = SASS_MEMORY_CAST(Number, env["$alpha"]);
+      Number_Ptr r = Cast<Number>(env["$red"]);
+      Number_Ptr g = Cast<Number>(env["$green"]);
+      Number_Ptr b = Cast<Number>(env["$blue"]);
+      Number_Ptr h = Cast<Number>(env["$hue"]);
+      Number_Ptr s = Cast<Number>(env["$saturation"]);
+      Number_Ptr l = Cast<Number>(env["$lightness"]);
+      Number_Ptr a = Cast<Number>(env["$alpha"]);
 
       bool rgb = r || g || b;
       bool hsl = h || s || l;
 
       if (rgb && hsl) {
-        error("Cannot specify HSL and RGB values for a color at the same time for `adjust-color'", pstate);
+        error("Cannot specify HSL and RGB values for a color at the same time for `adjust-color'", pstate, traces);
       }
       if (rgb) {
-        double rr = r ? ARGR("$red",   Number, -255, 255)->value() : 0;
-        double gg = g ? ARGR("$green", Number, -255, 255)->value() : 0;
-        double bb = b ? ARGR("$blue",  Number, -255, 255)->value() : 0;
-        double aa = a ? ARGR("$alpha", Number, -1, 1)->value() : 0;
+        double rr = r ? DARG_R_BYTE("$red") : 0;
+        double gg = g ? DARG_R_BYTE("$green") : 0;
+        double bb = b ? DARG_R_BYTE("$blue") : 0;
+        double aa = a ? DARG_R_FACT("$alpha") : 0;
         return SASS_MEMORY_NEW(Color,
                                pstate,
                                color->r() + rr,
@@ -701,9 +877,9 @@ namespace Sass {
       }
       if (hsl) {
         HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());
-        double ss = s ? ARGR("$saturation", Number, -100, 100)->value() : 0;
-        double ll = l ? ARGR("$lightness",  Number, -100, 100)->value() : 0;
-        double aa = a ? ARGR("$alpha",      Number, -1, 1)->value() : 0;
+        double ss = s ? DARG_R_PRCT("$saturation") : 0;
+        double ll = l ? DARG_R_PRCT("$lightness") : 0;
+        double aa = a ? DARG_R_FACT("$alpha") : 0;
         return hsla_impl(hsl_struct.h + (h ? h->value() : 0),
                          hsl_struct.s + ss,
                          hsl_struct.l + ll,
@@ -719,7 +895,7 @@ namespace Sass {
                                color->b(),
                                color->a() + (a ? a->value() : 0));
       }
-      error("not enough arguments for `adjust-color'", pstate);
+      error("not enough arguments for `adjust-color'", pstate, traces);
       // unreachable
       return color;
     }
@@ -728,25 +904,25 @@ namespace Sass {
     BUILT_IN(scale_color)
     {
       Color_Ptr color = ARG("$color", Color);
-      Number_Ptr r = SASS_MEMORY_CAST(Number, env["$red"]);
-      Number_Ptr g = SASS_MEMORY_CAST(Number, env["$green"]);
-      Number_Ptr b = SASS_MEMORY_CAST(Number, env["$blue"]);
-      Number_Ptr h = SASS_MEMORY_CAST(Number, env["$hue"]);
-      Number_Ptr s = SASS_MEMORY_CAST(Number, env["$saturation"]);
-      Number_Ptr l = SASS_MEMORY_CAST(Number, env["$lightness"]);
-      Number_Ptr a = SASS_MEMORY_CAST(Number, env["$alpha"]);
+      Number_Ptr r = Cast<Number>(env["$red"]);
+      Number_Ptr g = Cast<Number>(env["$green"]);
+      Number_Ptr b = Cast<Number>(env["$blue"]);
+      Number_Ptr h = Cast<Number>(env["$hue"]);
+      Number_Ptr s = Cast<Number>(env["$saturation"]);
+      Number_Ptr l = Cast<Number>(env["$lightness"]);
+      Number_Ptr a = Cast<Number>(env["$alpha"]);
 
       bool rgb = r || g || b;
       bool hsl = h || s || l;
 
       if (rgb && hsl) {
-        error("Cannot specify HSL and RGB values for a color at the same time for `scale-color'", pstate);
+        error("Cannot specify HSL and RGB values for a color at the same time for `scale-color'", pstate, traces);
       }
       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;
+        double rscale = (r ? DARG_R_PRCT("$red") : 0.0) / 100.0;
+        double gscale = (g ? DARG_R_PRCT("$green") : 0.0) / 100.0;
+        double bscale = (b ? DARG_R_PRCT("$blue") : 0.0) / 100.0;
+        double ascale = (a ? DARG_R_PRCT("$alpha") : 0.0) / 100.0;
         return SASS_MEMORY_NEW(Color,
                                pstate,
                                color->r() + rscale * (rscale > 0.0 ? 255 - color->r() : color->r()),
@@ -755,10 +931,10 @@ namespace Sass {
                                color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));
       }
       if (hsl) {
-        double hscale = (h ? ARGR("$hue",        Number, -100.0, 100.0)->value() : 0.0) / 100.0;
-        double sscale = (s ? ARGR("$saturation", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
-        double lscale = (l ? ARGR("$lightness",  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;
+        double hscale = (h ? DARG_R_PRCT("$hue") : 0.0) / 100.0;
+        double sscale = (s ? DARG_R_PRCT("$saturation") : 0.0) / 100.0;
+        double lscale = (l ? DARG_R_PRCT("$lightness") : 0.0) / 100.0;
+        double ascale = (a ? DARG_R_PRCT("$alpha") : 0.0) / 100.0;
         HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());
         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);
@@ -767,7 +943,7 @@ namespace Sass {
         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;
+        double ascale = (DARG_R_PRCT("$alpha")) / 100.0;
         return SASS_MEMORY_NEW(Color,
                                pstate,
                                color->r(),
@@ -775,7 +951,7 @@ namespace Sass {
                                color->b(),
                                color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));
       }
-      error("not enough arguments for `scale-color'", pstate);
+      error("not enough arguments for `scale-color'", pstate, traces);
       // unreachable
       return color;
     }
@@ -784,38 +960,38 @@ namespace Sass {
     BUILT_IN(change_color)
     {
       Color_Ptr color = ARG("$color", Color);
-      Number_Ptr r = SASS_MEMORY_CAST(Number, env["$red"]);
-      Number_Ptr g = SASS_MEMORY_CAST(Number, env["$green"]);
-      Number_Ptr b = SASS_MEMORY_CAST(Number, env["$blue"]);
-      Number_Ptr h = SASS_MEMORY_CAST(Number, env["$hue"]);
-      Number_Ptr s = SASS_MEMORY_CAST(Number, env["$saturation"]);
-      Number_Ptr l = SASS_MEMORY_CAST(Number, env["$lightness"]);
-      Number_Ptr a = SASS_MEMORY_CAST(Number, env["$alpha"]);
+      Number_Ptr r = Cast<Number>(env["$red"]);
+      Number_Ptr g = Cast<Number>(env["$green"]);
+      Number_Ptr b = Cast<Number>(env["$blue"]);
+      Number_Ptr h = Cast<Number>(env["$hue"]);
+      Number_Ptr s = Cast<Number>(env["$saturation"]);
+      Number_Ptr l = Cast<Number>(env["$lightness"]);
+      Number_Ptr a = Cast<Number>(env["$alpha"]);
 
       bool rgb = r || g || b;
       bool hsl = h || s || l;
 
       if (rgb && hsl) {
-        error("Cannot specify HSL and RGB values for a color at the same time for `change-color'", pstate);
+        error("Cannot specify HSL and RGB values for a color at the same time for `change-color'", pstate, traces);
       }
       if (rgb) {
         return SASS_MEMORY_NEW(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(),
-                               a ? ARGR("$alpha", Number, 0, 255)->value() : color->a());
+                               r ? DARG_U_BYTE("$red") : color->r(),
+                               g ? DARG_U_BYTE("$green") : color->g(),
+                               b ? DARG_U_BYTE("$blue") : color->b(),
+                               a ? DARG_U_BYTE("$alpha") : color->a());
       }
       if (hsl) {
         HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());
         if (h) hsl_struct.h = std::fmod(h->value(), 360.0);
-        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();
+        if (s) hsl_struct.s = DARG_U_PRCT("$saturation");
+        if (l) hsl_struct.l = DARG_U_PRCT("$lightness");
+        double alpha = a ? DARG_U_FACT("$alpha") : color->a();
         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();
+        double alpha = DARG_U_FACT("$alpha");
         return SASS_MEMORY_NEW(Color,
                                pstate,
                                color->r(),
@@ -823,7 +999,7 @@ namespace Sass {
                                color->b(),
                                alpha);
       }
-      error("not enough arguments for `change-color'", pstate);
+      error("not enough arguments for `change-color'", pstate, traces);
       // unreachable
       return color;
     }
@@ -866,25 +1042,26 @@ namespace Sass {
     BUILT_IN(sass_unquote)
     {
       AST_Node_Obj arg = env["$string"];
-      if (String_Quoted_Ptr string_quoted = SASS_MEMORY_CAST(String_Quoted, arg)) {
+      if (String_Quoted_Ptr string_quoted = Cast<String_Quoted>(arg)) {
         String_Constant_Ptr result = SASS_MEMORY_NEW(String_Constant, pstate, string_quoted->value());
         // remember if the string was quoted (color tokens)
         result->is_delayed(true); // delay colors
         return result;
       }
-      else if (SASS_MEMORY_CAST(String_Constant, arg)) {
-        return (Expression_Ptr) &arg;
+      else if (String_Constant_Ptr str = Cast<String_Constant>(arg)) {
+        return str;
       }
-      else {
+      else if (Expression_Ptr ex = Cast<Expression>(arg)) {
         Sass_Output_Style oldstyle = ctx.c_options.output_style;
         ctx.c_options.output_style = SASS_STYLE_NESTED;
         std::string val(arg->to_string(ctx.c_options));
-        val = SASS_MEMORY_CAST(Null, arg) ? "null" : val;
+        val = Cast<Null>(arg) ? "null" : val;
         ctx.c_options.output_style = oldstyle;
 
         deprecated_function("Passing " + val + ", a non-string value, to unquote()", pstate);
-        return (Expression_Ptr) &arg;
+        return ex;
       }
+      throw std::runtime_error("Invalid Data Type for unquote");
     }
 
     Signature quote_sig = "quote($string)";
@@ -892,7 +1069,7 @@ namespace Sass {
     {
       AST_Node_Obj arg = env["$string"];
       // only set quote mark to true if already a string
-      if (String_Quoted_Ptr qstr = SASS_MEMORY_CAST(String_Quoted, arg)) {
+      if (String_Quoted_Ptr qstr = Cast<String_Quoted>(arg)) {
         qstr->quote_mark('*');
         return qstr;
       }
@@ -915,7 +1092,7 @@ namespace Sass {
       }
       // handle any invalid utf8 errors
       // other errors will be re-thrown
-      catch (...) { handle_utf8_error(pstate, backtrace); }
+      catch (...) { handle_utf8_error(pstate, traces); }
       // return something even if we had an error (-1)
       return SASS_MEMORY_NEW(Number, pstate, (double)len);
     }
@@ -931,8 +1108,7 @@ namespace Sass {
         String_Constant_Ptr i = ARG("$insert", String_Constant);
         std::string ins = i->value();
         ins = unquote(ins);
-        Number_Ptr ind = ARG("$index", Number);
-        double index = ind->value();
+        double index = ARGVAL("$index");
         size_t len = UTF_8::code_point_count(str, 0, str.size());
 
         if (index > 0 && index <= len) {
@@ -956,13 +1132,13 @@ namespace Sass {
           str = ins + str;
         }
 
-        if (String_Quoted_Ptr ss = SASS_MEMORY_CAST_PTR(String_Quoted, s)) {
+        if (String_Quoted_Ptr ss = Cast<String_Quoted>(s)) {
           if (ss->quote_mark()) str = quote(str);
         }
       }
       // handle any invalid utf8 errors
       // other errors will be re-thrown
-      catch (...) { handle_utf8_error(pstate, backtrace); }
+      catch (...) { handle_utf8_error(pstate, traces); }
       return SASS_MEMORY_NEW(String_Quoted, pstate, str);
     }
 
@@ -986,7 +1162,7 @@ namespace Sass {
       }
       // handle any invalid utf8 errors
       // other errors will be re-thrown
-      catch (...) { handle_utf8_error(pstate, backtrace); }
+      catch (...) { handle_utf8_error(pstate, traces); }
       // return something even if we had an error (-1)
       return SASS_MEMORY_NEW(Number, pstate, (double)index);
     }
@@ -997,15 +1173,15 @@ namespace Sass {
       std::string newstr;
       try {
         String_Constant_Ptr s = ARG("$string", String_Constant);
-        double start_at = ARG("$start-at", Number)->value();
-        double end_at = ARG("$end-at", Number)->value();
-        String_Quoted_Ptr ss = SASS_MEMORY_CAST_PTR(String_Quoted, s);
+        double start_at = ARGVAL("$start-at");
+        double end_at = ARGVAL("$end-at");
+        String_Quoted_Ptr ss = Cast<String_Quoted>(s);
 
         std::string str = unquote(s->value());
 
         size_t size = utf8::distance(str.begin(), str.end());
 
-        if (!SASS_MEMORY_CAST(Number, env["$end-at"])) {
+        if (!Cast<Number>(env["$end-at"])) {
           end_at = -1;
         }
 
@@ -1039,7 +1215,7 @@ namespace Sass {
       }
       // handle any invalid utf8 errors
       // other errors will be re-thrown
-      catch (...) { handle_utf8_error(pstate, backtrace); }
+      catch (...) { handle_utf8_error(pstate, traces); }
       return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);
     }
 
@@ -1055,7 +1231,7 @@ namespace Sass {
         }
       }
 
-      if (String_Quoted_Ptr ss = SASS_MEMORY_CAST_PTR(String_Quoted, s)) {
+      if (String_Quoted_Ptr ss = Cast<String_Quoted>(s)) {
         String_Quoted_Ptr cpy = SASS_MEMORY_COPY(ss);
         cpy->value(str);
         return cpy;
@@ -1076,7 +1252,7 @@ namespace Sass {
         }
       }
 
-      if (String_Quoted_Ptr ss = SASS_MEMORY_CAST_PTR(String_Quoted, s)) {
+      if (String_Quoted_Ptr ss = Cast<String_Quoted>(s)) {
         String_Quoted_Ptr cpy = SASS_MEMORY_COPY(ss);
         cpy->value(str);
         return cpy;
@@ -1092,49 +1268,45 @@ namespace Sass {
     Signature percentage_sig = "percentage($number)";
     BUILT_IN(percentage)
     {
-      Number_Ptr n = ARG("$number", Number);
-      if (!n->is_unitless()) error("argument $number of `" + std::string(sig) + "` must be unitless", pstate);
+      Number_Obj n = ARGN("$number");
+      if (!n->is_unitless()) error("argument $number of `" + std::string(sig) + "` must be unitless", pstate, traces);
       return SASS_MEMORY_NEW(Number, pstate, n->value() * 100, "%");
     }
 
     Signature round_sig = "round($number)";
     BUILT_IN(round)
     {
-      Number_Ptr n = ARG("$number", Number);
-      Number_Ptr r = SASS_MEMORY_COPY(n);
-      r->pstate(pstate);
+      Number_Obj r = ARGN("$number");
       r->value(Sass::round(r->value(), ctx.c_options.precision));
-      return r;
+      r->pstate(pstate);
+      return r.detach();
     }
 
     Signature ceil_sig = "ceil($number)";
     BUILT_IN(ceil)
     {
-      Number_Ptr n = ARG("$number", Number);
-      Number_Ptr r = SASS_MEMORY_COPY(n);
-      r->pstate(pstate);
+      Number_Obj r = ARGN("$number");
       r->value(std::ceil(r->value()));
-      return r;
+      r->pstate(pstate);
+      return r.detach();
     }
 
     Signature floor_sig = "floor($number)";
     BUILT_IN(floor)
     {
-      Number_Ptr n = ARG("$number", Number);
-      Number_Ptr r = SASS_MEMORY_COPY(n);
-      r->pstate(pstate);
+      Number_Obj r = ARGN("$number");
       r->value(std::floor(r->value()));
-      return r;
+      r->pstate(pstate);
+      return r.detach();
     }
 
     Signature abs_sig = "abs($number)";
     BUILT_IN(abs)
     {
-      Number_Ptr n = ARG("$number", Number);
-      Number_Ptr r = SASS_MEMORY_COPY(n);
-      r->pstate(pstate);
+      Number_Obj r = ARGN("$number");
       r->value(std::abs(r->value()));
-      return r;
+      r->pstate(pstate);
+      return r.detach();
     }
 
     Signature min_sig = "min($numbers...)";
@@ -1144,9 +1316,9 @@ namespace Sass {
       Number_Obj least = NULL;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Expression_Obj val = arglist->value_at_index(i);
-        Number_Obj xi = SASS_MEMORY_CAST(Number, val);
+        Number_Obj xi = Cast<Number>(val);
         if (!xi) {
-          error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `min'", pstate);
+          error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `min'", pstate, traces);
         }
         if (least) {
           if (*xi < *least) least = xi;
@@ -1162,9 +1334,9 @@ namespace Sass {
       Number_Obj greatest = NULL;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Expression_Obj val = arglist->value_at_index(i);
-        Number_Obj xi = SASS_MEMORY_CAST(Number, val);
+        Number_Obj xi = Cast<Number>(val);
         if (!xi) {
-          error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `max'", pstate);
+          error("\"" + val->to_string(ctx.c_options) + "\" is not a number for `max'", pstate, traces);
         }
         if (greatest) {
           if (*greatest < *xi) greatest = xi;
@@ -1177,23 +1349,23 @@ namespace Sass {
     BUILT_IN(random)
     {
       AST_Node_Obj arg = env["$limit"];
-      Value_Ptr v = SASS_MEMORY_CAST(Value, arg);
-      Number_Ptr l = SASS_MEMORY_CAST(Number, arg);
-      Boolean_Ptr b = SASS_MEMORY_CAST(Boolean, arg);
+      Value_Ptr v = Cast<Value>(arg);
+      Number_Ptr l = Cast<Number>(arg);
+      Boolean_Ptr b = Cast<Boolean>(arg);
       if (l) {
-        double v = l->value();
-        if (v < 1) {
+        double lv = l->value();
+        if (lv < 1) {
           stringstream err;
-          err << "$limit " << v << " must be greater than or equal to 1 for `random'";
-          error(err.str(), pstate);
+          err << "$limit " << lv << " must be greater than or equal to 1 for `random'";
+          error(err.str(), pstate, traces);
         }
-        bool eq_int = std::fabs(trunc(v) - v) < NUMBER_EPSILON;
+        bool eq_int = std::fabs(trunc(lv) - lv) < NUMBER_EPSILON;
         if (!eq_int) {
           stringstream err;
-          err << "Expected $limit to be an integer but got " << v << " for `random'";
-          error(err.str(), pstate);
+          err << "Expected $limit to be an integer but got " << lv << " for `random'";
+          error(err.str(), pstate, traces);
         }
-        std::uniform_real_distribution<> distributor(1, v + 1);
+        std::uniform_real_distribution<> distributor(1, lv + 1);
         uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
         return SASS_MEMORY_NEW(Number, pstate, (double)distributed);
       }
@@ -1202,11 +1374,12 @@ namespace Sass {
         double distributed = static_cast<double>(distributor(rand));
         return SASS_MEMORY_NEW(Number, pstate, distributed);
       } else if (v) {
-        throw Exception::InvalidArgumentType(pstate, "random", "$limit", "number", v);
+        traces.push_back(Backtrace(pstate));
+        throw Exception::InvalidArgumentType(pstate, traces, "random", "$limit", "number", v);
       } else {
-        throw Exception::InvalidArgumentType(pstate, "random", "$limit", "number");
+        traces.push_back(Backtrace(pstate));
+        throw Exception::InvalidArgumentType(pstate, traces, "random", "$limit", "number");
       }
-      return 0;
     }
 
     /////////////////
@@ -1216,25 +1389,25 @@ namespace Sass {
     Signature length_sig = "length($list)";
     BUILT_IN(length)
     {
-      if (Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, env["$list"])) {
+      if (Selector_List_Ptr sl = Cast<Selector_List>(env["$list"])) {
         return SASS_MEMORY_NEW(Number, pstate, (double)sl->length());
       }
       Expression_Ptr v = ARG("$list", Expression);
       if (v->concrete_type() == Expression::MAP) {
-        Map_Ptr map = SASS_MEMORY_CAST(Map, env["$list"]);
+        Map_Ptr map = Cast<Map>(env["$list"]);
         return SASS_MEMORY_NEW(Number, pstate, (double)(map ? map->length() : 1));
       }
       if (v->concrete_type() == Expression::SELECTOR) {
-        if (Compound_Selector_Ptr h = dynamic_cast<Compound_Selector_Ptr>(v)) {
+        if (Compound_Selector_Ptr h = Cast<Compound_Selector>(v)) {
           return SASS_MEMORY_NEW(Number, pstate, (double)h->length());
-        } else if (Selector_List_Ptr ls = SASS_MEMORY_CAST_PTR(Selector_List, v)) {
+        } else if (Selector_List_Ptr ls = Cast<Selector_List>(v)) {
           return SASS_MEMORY_NEW(Number, pstate, (double)ls->length());
         } else {
           return SASS_MEMORY_NEW(Number, pstate, 1);
         }
       }
 
-      List_Ptr list = SASS_MEMORY_CAST(List, env["$list"]);
+      List_Ptr list = Cast<List>(env["$list"]);
       return SASS_MEMORY_NEW(Number,
                              pstate,
                              (double)(list ? list->size() : 1));
@@ -1243,20 +1416,20 @@ namespace Sass {
     Signature nth_sig = "nth($list, $n)";
     BUILT_IN(nth)
     {
-      Number_Ptr n = ARG("$n", Number);
-      Map_Ptr m = SASS_MEMORY_CAST(Map, env["$list"]);
-      if (Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, env["$list"])) {
+      double nr = ARGVAL("$n");
+      Map_Ptr m = Cast<Map>(env["$list"]);
+      if (Selector_List_Ptr sl = Cast<Selector_List>(env["$list"])) {
         size_t len = m ? m->length() : sl->length();
         bool empty = m ? m->empty() : sl->empty();
-        if (empty) error("argument `$list` of `" + std::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 `" + std::string(sig) + "`", pstate);
+        if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate, traces);
+        double index = std::floor(nr < 0 ? len + nr : nr - 1);
+        if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate, traces);
         // return (*sl)[static_cast<int>(index)];
         Listize listize;
         return (*sl)[static_cast<int>(index)]->perform(&listize);
       }
-      List_Obj l = SASS_MEMORY_CAST(List, env["$list"]);
-      if (n->value() == 0) error("argument `$n` of `" + std::string(sig) + "` must be non-zero", pstate);
+      List_Obj l = Cast<List>(env["$list"]);
+      if (nr == 0) error("argument `$n` of `" + std::string(sig) + "` must be non-zero", pstate, traces);
       // if the argument isn't a list, then wrap it in a singleton list
       if (!m && !l) {
         l = SASS_MEMORY_NEW(List, pstate, 1);
@@ -1264,9 +1437,9 @@ namespace Sass {
       }
       size_t len = m ? m->length() : l->length();
       bool empty = m ? m->empty() : l->empty();
-      if (empty) error("argument `$list` of `" + std::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 `" + std::string(sig) + "`", pstate);
+      if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate, traces);
+      double index = std::floor(nr < 0 ? len + nr : nr - 1);
+      if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate, traces);
 
       if (m) {
         l = SASS_MEMORY_NEW(List, pstate, 1);
@@ -1284,8 +1457,8 @@ namespace Sass {
     Signature set_nth_sig = "set-nth($list, $n, $value)";
     BUILT_IN(set_nth)
     {
-      Map_Obj m = SASS_MEMORY_CAST(Map, env["$list"]);
-      List_Obj l = SASS_MEMORY_CAST(List, env["$list"]);
+      Map_Obj m = Cast<Map>(env["$list"]);
+      List_Obj l = Cast<List>(env["$list"]);
       Number_Obj n = ARG("$n", Number);
       Expression_Obj v = ARG("$value", Expression);
       if (!l) {
@@ -1293,12 +1466,12 @@ namespace Sass {
         l->append(ARG("$list", Expression));
       }
       if (m) {
-        l = m->to_list(ctx, pstate);
+        l = m->to_list(pstate);
       }
-      if (l->empty()) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate);
+      if (l->empty()) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate, traces);
       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 `" + std::string(sig) + "`", pstate);
-      List_Ptr result = SASS_MEMORY_NEW(List, pstate, l->length(), l->separator());
+      if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate, traces);
+      List_Ptr result = SASS_MEMORY_NEW(List, pstate, l->length(), l->separator(), false, l->is_bracketed());
       for (size_t i = 0, L = l->length(); i < L; ++i) {
         result->append(((i == index) ? v : (*l)[i]));
       }
@@ -1308,67 +1481,75 @@ namespace Sass {
     Signature index_sig = "index($list, $value)";
     BUILT_IN(index)
     {
-      Map_Obj m = SASS_MEMORY_CAST(Map, env["$list"]);
-      List_Obj l = SASS_MEMORY_CAST(List, env["$list"]);
+      Map_Obj m = Cast<Map>(env["$list"]);
+      List_Obj l = Cast<List>(env["$list"]);
       Expression_Obj v = ARG("$value", Expression);
       if (!l) {
         l = SASS_MEMORY_NEW(List, pstate, 1);
         l->append(ARG("$list", Expression));
       }
       if (m) {
-        l = m->to_list(ctx, pstate);
+        l = m->to_list(pstate);
       }
       for (size_t i = 0, L = l->length(); i < L; ++i) {
-        if (Eval::eq(l->value_at_index(i), v)) return SASS_MEMORY_NEW(Number, pstate, (double)(i+1));
+        if (Operators::eq(l->value_at_index(i), v)) return SASS_MEMORY_NEW(Number, pstate, (double)(i+1));
       }
       return SASS_MEMORY_NEW(Null, pstate);
     }
 
-    Signature join_sig = "join($list1, $list2, $separator: auto)";
+    Signature join_sig = "join($list1, $list2, $separator: auto, $bracketed: auto)";
     BUILT_IN(join)
     {
-      Map_Obj m1 = SASS_MEMORY_CAST(Map, env["$list1"]);
-      Map_Obj m2 = SASS_MEMORY_CAST(Map, env["$list2"]);
-      List_Obj l1 = SASS_MEMORY_CAST(List, env["$list1"]);
-      List_Obj l2 = SASS_MEMORY_CAST(List, env["$list2"]);
+      Map_Obj m1 = Cast<Map>(env["$list1"]);
+      Map_Obj m2 = Cast<Map>(env["$list2"]);
+      List_Obj l1 = Cast<List>(env["$list1"]);
+      List_Obj l2 = Cast<List>(env["$list2"]);
       String_Constant_Obj sep = ARG("$separator", String_Constant);
       enum Sass_Separator sep_val = (l1 ? l1->separator() : SASS_SPACE);
+      Value* bracketed = ARG("$bracketed", Value);
+      bool is_bracketed = (l1 ? l1->is_bracketed() : false);
       if (!l1) {
         l1 = SASS_MEMORY_NEW(List, pstate, 1);
         l1->append(ARG("$list1", Expression));
         sep_val = (l2 ? l2->separator() : SASS_SPACE);
+        is_bracketed = (l2 ? l2->is_bracketed() : false);
       }
       if (!l2) {
         l2 = SASS_MEMORY_NEW(List, pstate, 1);
         l2->append(ARG("$list2", Expression));
       }
       if (m1) {
-        l1 = m1->to_list(ctx, pstate);
+        l1 = m1->to_list(pstate);
         sep_val = SASS_COMMA;
       }
       if (m2) {
-        l2 = m2->to_list(ctx, pstate);
+        l2 = m2->to_list(pstate);
       }
       size_t len = l1->length() + l2->length();
       std::string sep_str = unquote(sep->value());
       if (sep_str == "space") sep_val = SASS_SPACE;
       else if (sep_str == "comma") sep_val = SASS_COMMA;
-      else if (sep_str != "auto") error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
-      List_Obj result = SASS_MEMORY_NEW(List, pstate, len, sep_val);
-      result->concat(&l1);
-      result->concat(&l2);
+      else if (sep_str != "auto") error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate, traces);
+      String_Constant_Obj bracketed_as_str = Cast<String_Constant>(bracketed);
+      bool bracketed_is_auto = bracketed_as_str && unquote(bracketed_as_str->value()) == "auto";
+      if (!bracketed_is_auto) {
+        is_bracketed = !bracketed->is_false();
+      }
+      List_Obj result = SASS_MEMORY_NEW(List, pstate, len, sep_val, false, is_bracketed);
+      result->concat(l1);
+      result->concat(l2);
       return result.detach();
     }
 
     Signature append_sig = "append($list, $val, $separator: auto)";
     BUILT_IN(append)
     {
-      Map_Obj m = SASS_MEMORY_CAST(Map, env["$list"]);
-      List_Obj l = SASS_MEMORY_CAST(List, env["$list"]);
+      Map_Obj m = Cast<Map>(env["$list"]);
+      List_Obj l = Cast<List>(env["$list"]);
       Expression_Obj v = ARG("$val", Expression);
-      if (Selector_List_Ptr sl = SASS_MEMORY_CAST(Selector_List, env["$list"])) {
+      if (Selector_List_Ptr sl = Cast<Selector_List>(env["$list"])) {
         Listize listize;
-        l = SASS_MEMORY_CAST_PTR(List, sl->perform(&listize));
+        l = Cast<List>(sl->perform(&listize));
       }
       String_Constant_Obj sep = ARG("$separator", String_Constant);
       if (!l) {
@@ -1376,14 +1557,14 @@ namespace Sass {
         l->append(ARG("$list", Expression));
       }
       if (m) {
-        l = m->to_list(ctx, pstate);
+        l = m->to_list(pstate);
       }
       List_Ptr result = SASS_MEMORY_COPY(l);
       std::string sep_str(unquote(sep->value()));
       if (sep_str != "auto") { // check default first
         if (sep_str == "space") result->separator(SASS_SPACE);
         else if (sep_str == "comma") result->separator(SASS_COMMA);
-        else error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
+        else error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate, traces);
       }
       if (l->is_arglist()) {
         result->append(SASS_MEMORY_NEW(Argument,
@@ -1405,20 +1586,20 @@ namespace Sass {
       List_Obj arglist = SASS_MEMORY_COPY(ARG("$lists", List));
       size_t shortest = 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        List_Obj ith = SASS_MEMORY_CAST(List, arglist->value_at_index(i));
-        Map_Obj mith = SASS_MEMORY_CAST(Map, arglist->value_at_index(i));
+        List_Obj ith = Cast<List>(arglist->value_at_index(i));
+        Map_Obj mith = Cast<Map>(arglist->value_at_index(i));
         if (!ith) {
           if (mith) {
-            ith = mith->to_list(ctx, pstate);
+            ith = mith->to_list(pstate);
           } else {
             ith = SASS_MEMORY_NEW(List, pstate, 1);
             ith->append(arglist->value_at_index(i));
           }
           if (arglist->is_arglist()) {
-            Argument_Obj arg = (Argument_Ptr)(&arglist->at(i));
-            arg->value(&ith);
+            Argument_Obj arg = (Argument_Ptr)(arglist->at(i).ptr()); // XXX
+            arg->value(ith);
           } else {
-            (*arglist)[i] = &ith;
+            (*arglist)[i] = ith;
           }
         }
         shortest = (i ? std::min(shortest, ith->length()) : ith->length());
@@ -1428,7 +1609,7 @@ namespace Sass {
       for (size_t i = 0; i < shortest; ++i) {
         List_Ptr zipper = SASS_MEMORY_NEW(List, pstate, L);
         for (size_t j = 0; j < L; ++j) {
-          zipper->append(SASS_MEMORY_CAST(List, arglist->value_at_index(j))->at(i));
+          zipper->append(Cast<List>(arglist->value_at_index(j))->at(i));
         }
         zippers->append(zipper);
       }
@@ -1438,7 +1619,7 @@ namespace Sass {
     Signature list_separator_sig = "list_separator($list)";
     BUILT_IN(list_separator)
     {
-      List_Obj l = SASS_MEMORY_CAST(List, env["$list"]);
+      List_Obj l = Cast<List>(env["$list"]);
       if (!l) {
         l = SASS_MEMORY_NEW(List, pstate, 1);
         l->append(ARG("$list", Expression));
@@ -1460,8 +1641,10 @@ namespace Sass {
       Map_Obj m = ARGM("$map", Map, ctx);
       Expression_Obj v = ARG("$key", Expression);
       try {
-        Expression_Obj val = m->at(v); // XXX
-        return val ? val.detach() : SASS_MEMORY_NEW(Null, pstate);
+        Expression_Obj val = m->at(v);
+        if (!val) return SASS_MEMORY_NEW(Null, pstate);
+        val->set_delayed(false);
+        return val.detach();
       } catch (const std::out_of_range&) {
         return SASS_MEMORY_NEW(Null, pstate);
       }
@@ -1507,8 +1690,8 @@ namespace Sass {
       size_t len = m1->length() + m2->length();
       Map_Ptr result = SASS_MEMORY_NEW(Map, pstate, len);
       // concat not implemented for maps
-      *result += &m1;
-      *result += &m2;
+      *result += m1;
+      *result += m2;
       return result;
     }
 
@@ -1522,7 +1705,7 @@ namespace Sass {
       for (auto key : m->keys()) {
         remove = false;
         for (size_t j = 0, K = arglist->length(); j < K && !remove; ++j) {
-          remove = Eval::eq(key, arglist->value_at_index(j));
+          remove = Operators::eq(key, arglist->value_at_index(j));
         }
         if (!remove) *result << std::make_pair(key, m->at(key));
       }
@@ -1536,7 +1719,7 @@ namespace Sass {
       Map_Obj result = SASS_MEMORY_NEW(Map, pstate, 1);
       for (size_t i = arglist->size(), L = arglist->length(); i < L; ++i) {
         Expression_Obj obj = arglist->at(i);
-        Argument_Obj arg = (Argument_Ptr)&obj;
+        Argument_Obj arg = (Argument_Ptr) obj.ptr(); // XXX
         std::string name = std::string(arg->name());
         name = name.erase(0, 1); // sanitize name (remove dollar sign)
         *result << std::make_pair(SASS_MEMORY_NEW(String_Quoted,
@@ -1559,23 +1742,33 @@ namespace Sass {
 
     Signature unit_sig = "unit($number)";
     BUILT_IN(unit)
-    { return SASS_MEMORY_NEW(String_Quoted, pstate, quote(ARG("$number", Number)->unit(), '"')); }
+    {
+      Number_Obj arg = ARGN("$number");
+      std::string str(quote(arg->unit(), '"'));
+      return SASS_MEMORY_NEW(String_Quoted, pstate, str);
+    }
 
     Signature unitless_sig = "unitless($number)";
     BUILT_IN(unitless)
-    { return SASS_MEMORY_NEW(Boolean, pstate, ARG("$number", Number)->is_unitless()); }
+    {
+      Number_Obj arg = ARGN("$number");
+      bool unitless = arg->is_unitless();
+      return SASS_MEMORY_NEW(Boolean, pstate, unitless);
+    }
 
     Signature comparable_sig = "comparable($number-1, $number-2)";
     BUILT_IN(comparable)
     {
-      Number_Ptr n1 = ARG("$number-1", Number);
-      Number_Ptr n2 = ARG("$number-2", Number);
+      Number_Obj n1 = ARGN("$number-1");
+      Number_Obj n2 = ARGN("$number-2");
       if (n1->is_unitless() || n2->is_unitless()) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
       }
-      Number tmp_n2(n2); // copy
-      tmp_n2.normalize(n1->find_convertible_unit());
-      return SASS_MEMORY_NEW(Boolean, pstate, n1->unit() == tmp_n2.unit());
+      // normalize into main units
+      n1->normalize(); n2->normalize();
+      Units &lhs_unit = *n1, &rhs_unit = *n2;
+      bool is_comparable = (lhs_unit == rhs_unit);
+      return SASS_MEMORY_NEW(Boolean, pstate, is_comparable);
     }
 
     Signature variable_exists_sig = "variable-exists($name)";
@@ -1607,9 +1800,14 @@ namespace Sass {
     Signature function_exists_sig = "function-exists($name)";
     BUILT_IN(function_exists)
     {
-      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      String_Constant_Ptr ss = Cast<String_Constant>(env["$name"]);
+      if (!ss) {
+        error("$name: " + (env["$name"]->to_string()) + " is not a string for `function-exists'", pstate, traces);
+      }
+
+      std::string name = Util::normalize_underscores(unquote(ss->value()));
 
-      if(d_env.has_global(s+"[f]")) {
+      if(d_env.has_global(name+"[f]")) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
       }
       else {
@@ -1646,24 +1844,37 @@ namespace Sass {
     Signature call_sig = "call($name, $args...)";
     BUILT_IN(call)
     {
-      std::string name = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      std::string name;
+      Function_Ptr ff = Cast<Function>(env["$name"]);
+      String_Constant_Ptr ss = Cast<String_Constant>(env["$name"]);
+
+      if (ss) {
+        name = Util::normalize_underscores(unquote(ss->value()));
+        std::cerr << "DEPRECATION WARNING: ";
+        std::cerr << "Passing a string to call() is deprecated and will be illegal" << std::endl;
+        std::cerr << "in Sass 4.0. Use call(get-function(" + quote(name) + ")) instead." << std::endl;
+        std::cerr << std::endl;
+      } else if (ff) {
+        name = ff->name();
+      }
+
       List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List));
 
       Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);
       // std::string full_name(name + "[f]");
-      // Definition_Ptr def = d_env.has(full_name) ? static_cast<Definition_Ptr>((d_env)[full_name]) : 0;
+      // Definition_Ptr def = d_env.has(full_name) ? Cast<Definition>((d_env)[full_name]) : 0;
       // Parameters_Ptr params = def ? def->parameters() : 0;
       // size_t param_size = params ? params->length() : 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Expression_Obj expr = arglist->value_at_index(i);
         // if (params && params->has_rest_parameter()) {
         //   Parameter_Obj p = param_size > i ? (*params)[i] : 0;
-        //   List_Ptr list = SASS_MEMORY_CAST(List, expr);
+        //   List_Ptr list = Cast<List>(expr);
         //   if (list && p && !p->is_rest_parameter()) expr = (*list)[0];
         // }
         if (arglist->is_arglist()) {
           Expression_Obj obj = arglist->at(i);
-          Argument_Obj arg = (Argument_Ptr)&obj;
+          Argument_Obj arg = (Argument_Ptr) obj.ptr(); // XXX
           args->append(SASS_MEMORY_NEW(Argument,
                                        pstate,
                                        expr,
@@ -1674,11 +1885,11 @@ namespace Sass {
           args->append(SASS_MEMORY_NEW(Argument, pstate, expr));
         }
       }
-      Function_Call_Obj func = SASS_MEMORY_NEW(Function_Call, pstate, name, &args);
-      Expand expand(ctx, &d_env, backtrace, &selector_stack);
+      Function_Call_Obj func = SASS_MEMORY_NEW(Function_Call, pstate, name, args);
+      Expand expand(ctx, &d_env, &selector_stack);
       func->via_call(true); // calc invoke is allowed
+      if (ff) func->func(ff);
       return func->perform(&expand.eval);
-
     }
 
     ////////////////////
@@ -1696,24 +1907,13 @@ namespace Sass {
     // { return ARG("$condition", Expression)->is_false() ? ARG("$if-false", Expression) : ARG("$if-true", Expression); }
     BUILT_IN(sass_if)
     {
-      Expand expand(ctx, &d_env, backtrace, &selector_stack);
+      Expand expand(ctx, &d_env, &selector_stack);
       Expression_Obj cond = ARG("$condition", Expression)->perform(&expand.eval);
       bool is_true = !cond->is_false();
-      Expression_Ptr res = ARG(is_true ? "$if-true" : "$if-false", Expression);
+      Expression_Obj res = ARG(is_true ? "$if-true" : "$if-false", Expression);
       res = res->perform(&expand.eval);
       res->set_delayed(false); // clone?
-      return res;
-    }
-
-    ////////////////
-    // URL FUNCTIONS
-    ////////////////
-
-    Signature image_url_sig = "image-url($path, $only-path: false, $cache-buster: false)";
-    BUILT_IN(image_url)
-    {
-      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
+      return res.detach();
     }
 
     //////////////////////////
@@ -1754,24 +1954,24 @@ namespace Sass {
 
       // Not enough parameters
       if( arglist->length() == 0 )
-        error("$selectors: At least one selector must be passed for `selector-nest'", pstate);
+        error("$selectors: At least one selector must be passed for `selector-nest'", pstate, traces);
 
       // Parse args into vector of selectors
       std::vector<Selector_List_Obj> parsedSelectors;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Expression_Obj exp = SASS_MEMORY_CAST(Expression, arglist->value_at_index(i));
+        Expression_Obj exp = Cast<Expression>(arglist->value_at_index(i));
         if (exp->concrete_type() == Expression::NULL_VAL) {
           std::stringstream msg;
           msg << "$selectors: null is not a valid selector: it must be a string,\n";
           msg << "a list of strings, or a list of lists of strings for 'selector-nest'";
-          error(msg.str(), pstate);
+          error(msg.str(), pstate, traces);
         }
-        if (String_Constant_Obj str = SASS_MEMORY_CAST(String_Constant, exp)) {
+        if (String_Constant_Obj str = Cast<String_Constant>(exp)) {
           str->quote_mark(0);
         }
-        std::string exp_src = exp->to_string(ctx.c_options) + "{";
-        Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx);
-        parsedSelectors.push_back(&sel);
+        std::string exp_src = exp->to_string(ctx.c_options);
+        Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces);
+        parsedSelectors.push_back(sel);
       }
 
       // Nothing to do
@@ -1787,8 +1987,8 @@ namespace Sass {
       for(;itr != parsedSelectors.end(); ++itr) {
         Selector_List_Obj child = *itr;
         std::vector<Complex_Selector_Obj> exploded;
-        selector_stack.push_back(&result);
-        Selector_List_Obj rv = child->resolve_parent_refs(ctx, selector_stack);
+        selector_stack.push_back(result);
+        Selector_List_Obj rv = child->resolve_parent_refs(selector_stack, traces);
         selector_stack.pop_back();
         for (size_t m = 0, mLen = rv->length(); m < mLen; ++m) {
           exploded.push_back((*rv)[m]);
@@ -1807,24 +2007,24 @@ namespace Sass {
 
       // Not enough parameters
       if( arglist->length() == 0 )
-        error("$selectors: At least one selector must be passed for `selector-append'", pstate);
+        error("$selectors: At least one selector must be passed for `selector-append'", pstate, traces);
 
       // Parse args into vector of selectors
       std::vector<Selector_List_Obj> parsedSelectors;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Expression_Obj exp = SASS_MEMORY_CAST(Expression, arglist->value_at_index(i));
+        Expression_Obj exp = Cast<Expression>(arglist->value_at_index(i));
         if (exp->concrete_type() == Expression::NULL_VAL) {
           std::stringstream msg;
           msg << "$selectors: null is not a valid selector: it must be a string,\n";
           msg << "a list of strings, or a list of lists of strings for 'selector-append'";
-          error(msg.str(), pstate);
+          error(msg.str(), pstate, traces);
         }
-        if (String_Constant_Ptr str = SASS_MEMORY_CAST(String_Constant, exp)) {
+        if (String_Constant_Ptr str = Cast<String_Constant>(exp)) {
           str->quote_mark(0);
         }
-        std::string exp_src = exp->to_string() + "{";
-        Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx);
-        parsedSelectors.push_back(&sel);
+        std::string exp_src = exp->to_string();
+        Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces);
+        parsedSelectors.push_back(sel);
       }
 
       // Nothing to do
@@ -1861,29 +2061,29 @@ namespace Sass {
               msg += "\" to \"";
               msg += parentSeqClone->to_string();
               msg += "\" for `selector-append'";
-              error(msg, pstate, backtrace);
+              error(msg, pstate, traces);
             }
 
             // Cannot be a Universal selector
-            Element_Selector_Obj pType = SASS_MEMORY_CAST(Element_Selector, childSeq->head()->first());
+            Element_Selector_Obj pType = Cast<Element_Selector>(childSeq->head()->first());
             if(pType && pType->name() == "*") {
               std::string msg("Can't append \"");
               msg += childSeq->to_string();
               msg += "\" to \"";
               msg += parentSeqClone->to_string();
               msg += "\" for `selector-append'";
-              error(msg, pstate, backtrace);
+              error(msg, pstate, traces);
             }
 
             // TODO: Add check for namespace stuff
 
             // append any selectors in childSeq's head
-            parentSeqClone->innermost()->head()->concat(&base->head());
+            parentSeqClone->innermost()->head()->concat(base->head());
 
             // Set parentSeqClone new tail
             parentSeqClone->innermost()->tail( base->tail() );
 
-            newElements.push_back(&parentSeqClone);
+            newElements.push_back(parentSeqClone);
           }
         }
 
@@ -1900,7 +2100,7 @@ namespace Sass {
       Selector_List_Obj selector1 = ARGSEL("$selector1", Selector_List_Obj, p_contextualize);
       Selector_List_Obj selector2 = ARGSEL("$selector2", Selector_List_Obj, p_contextualize);
 
-      Selector_List_Obj result = selector1->unify_with(&selector2, ctx);
+      Selector_List_Obj result = selector1->unify_with(selector2);
       Listize listize;
       return result->perform(&listize);
     }
@@ -1930,9 +2130,10 @@ namespace Sass {
       Selector_List_Obj  extender = ARGSEL("$extender", Selector_List_Obj, p_contextualize);
 
       Subset_Map subset_map;
-      extender->populate_extends(extendee, ctx, subset_map);
+      extender->populate_extends(extendee, subset_map);
+      Extend extend(subset_map);
 
-      Selector_List_Obj result = Extend::extendSelectorList(selector, ctx, subset_map, false);
+      Selector_List_Obj result = extend.extendSelectorList(selector, false);
 
       Listize listize;
       return result->perform(&listize);
@@ -1945,9 +2146,10 @@ namespace Sass {
       Selector_List_Obj original = ARGSEL("$original", Selector_List_Obj, p_contextualize);
       Selector_List_Obj replacement = ARGSEL("$replacement", Selector_List_Obj, p_contextualize);
       Subset_Map subset_map;
-      replacement->populate_extends(original, ctx, subset_map);
+      replacement->populate_extends(original, subset_map);
+      Extend extend(subset_map);
 
-      Selector_List_Obj result = Extend::extendSelectorList(selector, ctx, subset_map, true);
+      Selector_List_Obj result = extend.extendSelectorList(selector, true);
 
       Listize listize;
       return result->perform(&listize);
@@ -1981,5 +2183,52 @@ namespace Sass {
       return SASS_MEMORY_NEW(String_Quoted, pstate, ss.str());
     }
 
+    Signature is_bracketed_sig = "is-bracketed($list)";
+    BUILT_IN(is_bracketed)
+    {
+      Value_Obj value = ARG("$list", Value);
+      List_Obj list = Cast<List>(value);
+      return SASS_MEMORY_NEW(Boolean, pstate, list && list->is_bracketed());
+    }
+
+    Signature content_exists_sig = "content-exists()";
+    BUILT_IN(content_exists)
+    {
+      if (!d_env.has_global("is_in_mixin")) {
+        error("Cannot call content-exists() except within a mixin.", pstate, traces);
+      }
+      return SASS_MEMORY_NEW(Boolean, pstate, d_env.has_lexical("@content[m]"));
+    }
+
+    Signature get_function_sig = "get-function($name, $css: false)";
+    BUILT_IN(get_function)
+    {
+      String_Constant_Ptr ss = Cast<String_Constant>(env["$name"]);
+      if (!ss) {
+        error("$name: " + (env["$name"]->to_string()) + " is not a string for `get-function'", pstate, traces);
+      }
+
+      std::string name = Util::normalize_underscores(unquote(ss->value()));
+      std::string full_name = name + "[f]";
+
+      Boolean_Obj css = ARG("$css", Boolean);
+      if (!css->is_false()) {
+        Definition_Ptr def = SASS_MEMORY_NEW(Definition,
+                                         pstate,
+                                         name,
+                                         SASS_MEMORY_NEW(Parameters, pstate),
+                                         SASS_MEMORY_NEW(Block, pstate, 0, false),
+                                         Definition::FUNCTION);
+        return SASS_MEMORY_NEW(Function, pstate, def, true);
+      }
+
+
+      if (!d_env.has_global(full_name)) {
+        error("Function not found: " + name, pstate, traces);
+      }
+
+      Definition_Ptr def = Cast<Definition>(d_env[full_name]);
+      return SASS_MEMORY_NEW(Function, pstate, def, false);
+    }
   }
 }