sassc 2.0.1 → 2.1.0.pre1

data/ext/libsass/src/fn_strings.hpp

@@ -0,0 +1,34 @@
+#ifndef SASS_FN_STRINGS_H
+#define SASS_FN_STRINGS_H
+
+#include "fn_utils.hpp"
+
+namespace Sass {
+
+  namespace Functions {
+
+    extern Signature unquote_sig;
+    extern Signature quote_sig;
+    extern Signature str_length_sig;
+    extern Signature str_insert_sig;
+    extern Signature str_index_sig;
+    extern Signature str_slice_sig;
+    extern Signature to_upper_case_sig;
+    extern Signature to_lower_case_sig;
+    extern Signature length_sig;
+
+    BUILT_IN(sass_unquote);
+    BUILT_IN(sass_quote);
+    BUILT_IN(str_length);
+    BUILT_IN(str_insert);
+    BUILT_IN(str_index);
+    BUILT_IN(str_slice);
+    BUILT_IN(to_upper_case);
+    BUILT_IN(to_lower_case);
+    BUILT_IN(length);
+
+  }
+
+}
+
+#endif

data/ext/libsass/src/fn_utils.cpp

@@ -0,0 +1,156 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "parser.hpp"
+#include "fn_utils.hpp"
+#include "util_string.hpp"
+
+namespace Sass {
+
+  Definition* make_native_function(Signature sig, Native_Function func, Context& ctx)
+  {
+    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();
+    return SASS_MEMORY_NEW(Definition,
+                          ParserState("[built-in function]"),
+                          sig,
+                          name,
+                          params,
+                          func,
+                          false);
+  }
+
+  Definition* make_c_function(Sass_Function_Entry c_func, Context& ctx)
+  {
+    using namespace Prelexer;
+
+    const char* sig = sass_function_get_signature(c_func);
+    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 >,
+                                    exactly < Constants::error_kwd >,
+                                    exactly < Constants::debug_kwd >
+                  >              >();
+    std::string name(Util::normalize_underscores(sig_parser.lexed));
+    Parameters_Obj params = sig_parser.parse_parameters();
+    return SASS_MEMORY_NEW(Definition,
+                          ParserState("[c function]"),
+                          sig,
+                          name,
+                          params,
+                          c_func);
+  }
+
+  namespace Functions {
+
+    std::string function_name(Signature sig)
+    {
+      std::string str(sig);
+      return str.substr(0, str.find('('));
+    }
+
+    Map* get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      AST_Node* value = env[argname];
+      if (Map* map = Cast<Map>(value)) return map;
+      List* list = Cast<List>(value);
+      if (list && list->length() == 0) {
+        return SASS_MEMORY_NEW(Map, pstate, 0);
+      }
+      return get_arg<Map>(argname, env, sig, pstate, traces);
+    }
+
+    double get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, double lo, double hi)
+    {
+      Number* 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, traces);
+      }
+      return v;
+    }
+
+    Number* get_arg_n(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      Number* val = get_arg<Number>(argname, env, sig, pstate, traces);
+      val = SASS_MEMORY_COPY(val);
+      val->reduce();
+      return val;
+    }
+
+    double get_arg_val(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      Number* 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* 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);
+      }
+    }
+
+    double alpha_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces) {
+      Number* 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);
+      }
+    }
+
+    Selector_List_Obj get_arg_sels(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(), exp->pstate(), traces);
+      }
+      if (String_Constant* 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, traces, exp->pstate(), pstate.src, /*allow_parent=*/false);
+    }
+
+    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(), exp->pstate(), traces);
+      }
+      if (String_Constant* 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, traces, exp->pstate(), pstate.src, /*allow_parent=*/false);
+      if (sel_list->length() == 0) return {};
+      Complex_Selector_Obj first = sel_list->first();
+      if (!first->tail()) return first->head();
+      return first->tail()->head();
+    }
+
+  }
+
+}

data/ext/libsass/src/fn_utils.hpp

@@ -0,0 +1,56 @@
+#ifndef SASS_FN_UTILS_H
+#define SASS_FN_UTILS_H
+#include "units.hpp"
+#include "backtrace.hpp"
+#include "environment.hpp"
+#include "ast_fwd_decl.hpp"
+#include "error_handling.hpp"
+
+namespace Sass {
+
+  #define FN_PROTOTYPE \
+    Env& env, \
+    Env& d_env, \
+    Context& ctx, \
+    Signature sig, \
+    ParserState pstate, \
+    Backtraces& traces, \
+    SelectorStack& selector_stack
+
+  typedef const char* Signature;
+  typedef PreValue* (*Native_Function)(FN_PROTOTYPE);
+  #define BUILT_IN(name) PreValue* name(FN_PROTOTYPE)
+
+  #define ARG(argname, argtype) get_arg<argtype>(argname, env, sig, pstate, traces)
+  // special function for weird hsla percent (10px == 10% == 10 != 0.1)
+  #define ARGVAL(argname) get_arg_val(argname, env, sig, pstate, traces) // double
+
+  Definition* make_native_function(Signature, Native_Function, Context& ctx);
+  Definition* make_c_function(Sass_Function_Entry c_func, Context& ctx);
+
+  namespace Functions {
+
+    template <typename T>
+    T* get_arg(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces)
+    {
+      T* val = Cast<T>(env[argname]);
+      if (!val) {
+        error("argument `" + argname + "` of `" + sig + "` must be a " + T::type_name(), pstate, traces);
+      }
+      return val;
+    }
+
+    Map* get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces); // maps only
+    Number* get_arg_n(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces); // numbers only
+    double alpha_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces); // colors only
+    double color_num(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces); // colors only
+    double get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, double lo, double hi); // colors only
+    double get_arg_val(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces); // shared
+    Selector_List_Obj get_arg_sels(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx); // selectors only
+    Compound_Selector_Obj get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtraces traces, Context& ctx); // selectors only
+
+  }
+
+}
+
+#endif

data/ext/libsass/src/inspect.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <cmath>
 #include <string>
 #include <iostream>
@@ -21,7 +24,7 @@ namespace Sass {
   Inspect::~Inspect() { }
 
   // statements
-  void Inspect::operator()(Block_Ptr block)
+  void Inspect::operator()(Block* block)
   {
     if (!block->is_root()) {
       add_open_mapping(block);
@@ -39,25 +42,23 @@ namespace Sass {
 
   }
 
-  void Inspect::operator()(Ruleset_Ptr ruleset)
+  void Inspect::operator()(Ruleset* ruleset)
   {
     if (ruleset->selector()) {
-      opt.in_selector = true;
       ruleset->selector()->perform(this);
-      opt.in_selector = false;
     }
     if (ruleset->block()) {
       ruleset->block()->perform(this);
     }
   }
 
-  void Inspect::operator()(Keyframe_Rule_Ptr rule)
+  void Inspect::operator()(Keyframe_Rule* rule)
   {
     if (rule->name()) rule->name()->perform(this);
     if (rule->block()) rule->block()->perform(this);
   }
 
-  void Inspect::operator()(Bubble_Ptr bubble)
+  void Inspect::operator()(Bubble* bubble)
   {
     append_indentation();
     append_token("::BUBBLE", bubble);
@@ -66,7 +67,7 @@ namespace Sass {
     append_scope_closer();
   }
 
-  void Inspect::operator()(Media_Block_Ptr media_block)
+  void Inspect::operator()(Media_Block* media_block)
   {
     append_indentation();
     append_token("@media", media_block);
@@ -77,7 +78,7 @@ namespace Sass {
     media_block->block()->perform(this);
   }
 
-  void Inspect::operator()(Supports_Block_Ptr feature_block)
+  void Inspect::operator()(Supports_Block* feature_block)
   {
     append_indentation();
     append_token("@supports", feature_block);
@@ -86,7 +87,7 @@ namespace Sass {
     feature_block->block()->perform(this);
   }
 
-  void Inspect::operator()(At_Root_Block_Ptr at_root_block)
+  void Inspect::operator()(At_Root_Block* at_root_block)
   {
     append_indentation();
     append_token("@at-root ", at_root_block);
@@ -95,7 +96,7 @@ namespace Sass {
     if(at_root_block->block()) at_root_block->block()->perform(this);
   }
 
-  void Inspect::operator()(Directive_Ptr at_rule)
+  void Inspect::operator()(Directive* at_rule)
   {
     append_indentation();
     append_token(at_rule->keyword(), at_rule);
@@ -118,7 +119,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Declaration_Ptr dec)
+  void Inspect::operator()(Declaration* dec)
   {
     if (dec->value()->concrete_type() == Expression::NULL_VAL) return;
     bool was_decl = in_declaration;
@@ -150,7 +151,7 @@ namespace Sass {
     in_declaration = was_decl;
   }
 
-  void Inspect::operator()(Assignment_Ptr assn)
+  void Inspect::operator()(Assignment* assn)
   {
     append_token(assn->variable(), assn);
     append_colon_separator();
@@ -162,7 +163,7 @@ namespace Sass {
     append_delimiter();
   }
 
-  void Inspect::operator()(Import_Ptr import)
+  void Inspect::operator()(Import* import)
   {
     if (!import->urls().empty()) {
       append_token("@import", import);
@@ -193,7 +194,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Import_Stub_Ptr import)
+  void Inspect::operator()(Import_Stub* import)
   {
     append_indentation();
     append_token("@import", import);
@@ -202,7 +203,7 @@ namespace Sass {
     append_delimiter();
   }
 
-  void Inspect::operator()(Warning_Ptr warning)
+  void Inspect::operator()(Warning* warning)
   {
     append_indentation();
     append_token("@warn", warning);
@@ -211,7 +212,7 @@ namespace Sass {
     append_delimiter();
   }
 
-  void Inspect::operator()(Error_Ptr error)
+  void Inspect::operator()(Error* error)
   {
     append_indentation();
     append_token("@error", error);
@@ -220,7 +221,7 @@ namespace Sass {
     append_delimiter();
   }
 
-  void Inspect::operator()(Debug_Ptr debug)
+  void Inspect::operator()(Debug* debug)
   {
     append_indentation();
     append_token("@debug", debug);
@@ -229,14 +230,14 @@ namespace Sass {
     append_delimiter();
   }
 
-  void Inspect::operator()(Comment_Ptr comment)
+  void Inspect::operator()(Comment* comment)
   {
     in_comment = true;
     comment->text()->perform(this);
     in_comment = false;
   }
 
-  void Inspect::operator()(If_Ptr cond)
+  void Inspect::operator()(If* cond)
   {
     append_indentation();
     append_token("@if", cond);
@@ -251,7 +252,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(For_Ptr loop)
+  void Inspect::operator()(For* loop)
   {
     append_indentation();
     append_token("@for", loop);
@@ -264,7 +265,7 @@ namespace Sass {
     loop->block()->perform(this);
   }
 
-  void Inspect::operator()(Each_Ptr loop)
+  void Inspect::operator()(Each* loop)
   {
     append_indentation();
     append_token("@each", loop);
@@ -279,7 +280,7 @@ namespace Sass {
     loop->block()->perform(this);
   }
 
-  void Inspect::operator()(While_Ptr loop)
+  void Inspect::operator()(While* loop)
   {
     append_indentation();
     append_token("@while", loop);
@@ -288,7 +289,7 @@ namespace Sass {
     loop->block()->perform(this);
   }
 
-  void Inspect::operator()(Return_Ptr ret)
+  void Inspect::operator()(Return* ret)
   {
     append_indentation();
     append_token("@return", ret);
@@ -297,7 +298,7 @@ namespace Sass {
     append_delimiter();
   }
 
-  void Inspect::operator()(Extension_Ptr extend)
+  void Inspect::operator()(Extension* extend)
   {
     append_indentation();
     append_token("@extend", extend);
@@ -306,7 +307,7 @@ namespace Sass {
     append_delimiter();
   }
 
-  void Inspect::operator()(Definition_Ptr def)
+  void Inspect::operator()(Definition* def)
   {
     append_indentation();
     if (def->type() == Definition::MIXIN) {
@@ -321,7 +322,7 @@ namespace Sass {
     def->block()->perform(this);
   }
 
-  void Inspect::operator()(Mixin_Call_Ptr call)
+  void Inspect::operator()(Mixin_Call* call)
   {
     append_indentation();
     append_token("@include", call);
@@ -337,14 +338,14 @@ namespace Sass {
     if (!call->block()) append_delimiter();
   }
 
-  void Inspect::operator()(Content_Ptr content)
+  void Inspect::operator()(Content* content)
   {
     append_indentation();
     append_token("@content", content);
     append_delimiter();
   }
 
-  void Inspect::operator()(Map_Ptr map)
+  void Inspect::operator()(Map* map)
   {
     if (output_style() == TO_SASS && map->empty()) {
       append_string("()");
@@ -366,15 +367,15 @@ namespace Sass {
     append_string(")");
   }
 
-  std::string Inspect::lbracket(List_Ptr list) {
+  std::string Inspect::lbracket(List* list) {
     return list->is_bracketed() ? "[" : "(";
   }
 
-  std::string Inspect::rbracket(List_Ptr list) {
+  std::string Inspect::rbracket(List* list) {
     return list->is_bracketed() ? "]" : ")";
   }
 
-  void Inspect::operator()(List_Ptr list)
+  void Inspect::operator()(List* list)
   {
     if (list->empty() && (output_style() == TO_SASS || list->is_bracketed())) {
       append_string(lbracket(list));
@@ -462,7 +463,7 @@ namespace Sass {
 
   }
 
-  void Inspect::operator()(Binary_Expression_Ptr expr)
+  void Inspect::operator()(Binary_Expression* expr)
   {
     expr->left()->perform(this);
     if ( in_media_block ||
@@ -499,7 +500,7 @@ namespace Sass {
     expr->right()->perform(this);
   }
 
-  void Inspect::operator()(Unary_Expression_Ptr expr)
+  void Inspect::operator()(Unary_Expression* expr)
   {
     if (expr->optype() == Unary_Expression::PLUS)       append_string("+");
     else if (expr->optype() == Unary_Expression::SLASH) append_string("/");
@@ -507,91 +508,42 @@ namespace Sass {
     expr->operand()->perform(this);
   }
 
-  void Inspect::operator()(Function_Call_Ptr call)
+  void Inspect::operator()(Function_Call* call)
   {
     append_token(call->name(), call);
     call->arguments()->perform(this);
   }
 
-  void Inspect::operator()(Function_Call_Schema_Ptr call)
-  {
-    call->name()->perform(this);
-    call->arguments()->perform(this);
-  }
-
-  void Inspect::operator()(Variable_Ptr var)
+  void Inspect::operator()(Variable* var)
   {
     append_token(var->name(), var);
   }
 
-  void Inspect::operator()(Number_Ptr n)
+  void Inspect::operator()(Number* n)
   {
 
-    std::string res;
-
     // reduce units
     n->reduce();
 
-    // check if the fractional part of the value equals to zero
-    // neat trick from http://stackoverflow.com/a/1521682/1550314
-    // double int_part; bool is_int = modf(value, &int_part) == 0.0;
-
-    // this all cannot be done with one run only, since fixed
-    // output differs from normal output and regular output
-    // can contain scientific notation which we do not want!
-
-    // first sample
     std::stringstream ss;
-    ss.precision(12);
-    ss << n->value();
-
-    // check if we got scientific notation in result
-    if (ss.str().find_first_of("e") != std::string::npos) {
-      ss.clear(); ss.str(std::string());
-      ss.precision(std::max(12, opt.precision));
-      ss << std::fixed << n->value();
-    }
-
-    std::string tmp = ss.str();
-    size_t pos_point = tmp.find_first_of(".,");
-    size_t pos_fract = tmp.find_last_not_of("0");
-    bool is_int = pos_point == pos_fract ||
-                  pos_point == std::string::npos;
+    ss.precision(opt.precision);
+    ss << std::fixed << n->value();
 
-    // reset stream for another run
-    ss.clear(); ss.str(std::string());
+    std::string res = ss.str();
+    int s = res.length();
 
-    // take a shortcut for integers
-    if (is_int)
+    // delete trailing zeros
+    for(s = s - 1; s > 0; --s)
     {
-      ss.precision(0);
-      ss << std::fixed << n->value();
-      res = std::string(ss.str());
-    }
-    // process floats
-    else
-    {
-      // do we have have too much precision?
-      if (pos_fract < opt.precision + pos_point)
-      { ss.precision((int)(pos_fract - pos_point)); }
-      else { ss.precision(opt.precision); }
-      // round value again
-      ss << std::fixed << n->value();
-      res = std::string(ss.str());
-      // maybe we truncated up to decimal point
-      size_t pos = res.find_last_not_of("0");
-      // handle case where we have a "0"
-      if (pos == std::string::npos) {
-        res = "0.0";
-      } else {
-        bool at_dec_point = res[pos] == '.' ||
-                            res[pos] == ',';
-        // don't leave a blank point
-        if (at_dec_point) ++ pos;
-        res.resize (pos + 1);
-      }
+        if(res[s] == '0') {
+          res.erase(s, 1);
+        }
+        else break;
     }
 
+    // delete trailing decimal separator
+    if(res[s] == '.') res.erase(s, 1);
+
     // some final cosmetics
     if (res == "0.0") res = "0";
     else if (res == "") res = "0";
@@ -599,10 +551,12 @@ namespace Sass {
     else if (res == "-0.0") res = "0";
     else if (opt.output_style == COMPRESSED)
     {
-      // check if handling negative nr
-      size_t off = res[0] == '-' ? 1 : 0;
-      // remove leading zero from floating point in compressed mode
-      if (n->zero() && res[off] == '0' && res[off+1] == '.') res.erase(off, 1);
+      if (n->zero()) {
+        // check if handling negative nr
+        size_t off = res[0] == '-' ? 1 : 0;
+        // remove leading zero from floating point in compressed mode
+        if (res[off] == '0' && res[off+1] == '.') res.erase(off, 1);
+      }
     }
 
     // add unit now
@@ -620,7 +574,7 @@ namespace Sass {
     else                return c;
   }
 
-  void Inspect::operator()(Color_Ptr c)
+  void Inspect::operator()(Color_RGBA* c)
   {
     // output the final token
     std::stringstream ss;
@@ -629,11 +583,6 @@ namespace Sass {
     // maybe an unknown token
     std::string name = c->disp();
 
-    if (opt.in_selector && name != "") {
-      append_token(name, c);
-      return;
-    }
-
     // resolved color
     std::string res_name = name;
 
@@ -644,7 +593,7 @@ namespace Sass {
 
     // get color from given name (if one was given at all)
     if (name != "" && name_to_color(name)) {
-      Color_Ptr_Const n = name_to_color(name);
+      const Color_RGBA* n = name_to_color(name);
       r = Sass::round(cap_channel<0xff>(n->r()), opt.precision);
       g = Sass::round(cap_channel<0xff>(n->g()), opt.precision);
       b = Sass::round(cap_channel<0xff>(n->b()), opt.precision);
@@ -658,6 +607,9 @@ namespace Sass {
     }
 
     std::stringstream hexlet;
+    // dart sass compressed all colors in regular css always
+    // ruby sass and libsass does it only when not delayed
+    // since color math is going to be removed, this can go too
     bool compressed = opt.output_style == COMPRESSED;
     hexlet << '#' << std::setw(1) << std::setfill('0');
     // create a short color hexlet if there is any need for it
@@ -681,9 +633,6 @@ namespace Sass {
     if (name != "") {
       ss << name;
     }
-    else if (r == 0 && g == 0 && b == 0 && a == 0) {
-      ss << "transparent";
-    }
     else if (a >= 1) {
       if (res_name != "") {
         if (compressed && hexlet.str().size() < res_name.size()) {
@@ -711,13 +660,19 @@ namespace Sass {
 
   }
 
-  void Inspect::operator()(Boolean_Ptr b)
+  void Inspect::operator()(Color_HSLA* c)
+  {
+    Color_RGBA_Obj rgba = c->toRGBA();
+    operator()(rgba);
+  }
+
+  void Inspect::operator()(Boolean* b)
   {
     // output the final token
     append_token(b->value() ? "true" : "false", b);
   }
 
-  void Inspect::operator()(String_Schema_Ptr ss)
+  void Inspect::operator()(String_Schema* ss)
   {
     // Evaluation should turn these into String_Constants,
     // so this method is only for inspection purposes.
@@ -728,12 +683,12 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(String_Constant_Ptr s)
+  void Inspect::operator()(String_Constant* s)
   {
     append_token(s->value(), s);
   }
 
-  void Inspect::operator()(String_Quoted_Ptr s)
+  void Inspect::operator()(String_Quoted* s)
   {
     if (const char q = s->quote_mark()) {
       append_token(quote(s->value(), q), s);
@@ -742,17 +697,17 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Custom_Error_Ptr e)
+  void Inspect::operator()(Custom_Error* e)
   {
     append_token(e->message(), e);
   }
 
-  void Inspect::operator()(Custom_Warning_Ptr w)
+  void Inspect::operator()(Custom_Warning* w)
   {
     append_token(w->message(), w);
   }
 
-  void Inspect::operator()(Supports_Operator_Ptr so)
+  void Inspect::operator()(Supports_Operator* so)
   {
 
     if (so->needs_parens(so->left())) append_string("(");
@@ -774,7 +729,7 @@ namespace Sass {
     if (so->needs_parens(so->right())) append_string(")");
   }
 
-  void Inspect::operator()(Supports_Negation_Ptr sn)
+  void Inspect::operator()(Supports_Negation* sn)
   {
     append_token("not", sn);
     append_mandatory_space();
@@ -783,7 +738,7 @@ namespace Sass {
     if (sn->needs_parens(sn->condition())) append_string(")");
   }
 
-  void Inspect::operator()(Supports_Declaration_Ptr sd)
+  void Inspect::operator()(Supports_Declaration* sd)
   {
     append_string("(");
     sd->feature()->perform(this);
@@ -792,12 +747,12 @@ namespace Sass {
     append_string(")");
   }
 
-  void Inspect::operator()(Supports_Interpolation_Ptr sd)
+  void Inspect::operator()(Supports_Interpolation* sd)
   {
     sd->value()->perform(this);
   }
 
-  void Inspect::operator()(Media_Query_Ptr mq)
+  void Inspect::operator()(Media_Query* mq)
   {
     size_t i = 0;
     if (mq->media_type()) {
@@ -814,7 +769,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Media_Query_Expression_Ptr mqe)
+  void Inspect::operator()(Media_Query_Expression* mqe)
   {
     if (mqe->is_interpolated()) {
       mqe->feature()->perform(this);
@@ -830,7 +785,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(At_Root_Query_Ptr ae)
+  void Inspect::operator()(At_Root_Query* ae)
   {
     if (ae->feature()) {
       append_string("(");
@@ -843,7 +798,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Function_Ptr f)
+  void Inspect::operator()(Function* f)
   {
     append_token("get-function", f);
     append_string("(");
@@ -851,14 +806,14 @@ namespace Sass {
     append_string(")");
   }
 
-  void Inspect::operator()(Null_Ptr n)
+  void Inspect::operator()(Null* n)
   {
     // output the final token
     append_token("null", n);
   }
 
   // parameters and arguments
-  void Inspect::operator()(Parameter_Ptr p)
+  void Inspect::operator()(Parameter* p)
   {
     append_token(p->name(), p);
     if (p->default_value()) {
@@ -870,7 +825,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Parameters_Ptr p)
+  void Inspect::operator()(Parameters* p)
   {
     append_string("(");
     if (!p->empty()) {
@@ -883,7 +838,7 @@ namespace Sass {
     append_string(")");
   }
 
-  void Inspect::operator()(Argument_Ptr a)
+  void Inspect::operator()(Argument* a)
   {
     if (!a->name().empty()) {
       append_token(a->name(), a);
@@ -895,7 +850,7 @@ namespace Sass {
       return;
     }
     if (a->value()->concrete_type() == Expression::STRING) {
-      String_Constant_Ptr s = Cast<String_Constant>(a->value());
+      String_Constant* s = Cast<String_Constant>(a->value());
       if (s) s->perform(this);
     } else {
       a->value()->perform(this);
@@ -905,7 +860,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Arguments_Ptr a)
+  void Inspect::operator()(Arguments* a)
   {
     append_string("(");
     if (!a->empty()) {
@@ -919,19 +874,17 @@ namespace Sass {
     append_string(")");
   }
 
-  void Inspect::operator()(Selector_Schema_Ptr s)
+  void Inspect::operator()(Selector_Schema* s)
   {
-    opt.in_selector = true;
     s->contents()->perform(this);
-    opt.in_selector = false;
   }
 
-  void Inspect::operator()(Parent_Selector_Ptr p)
+  void Inspect::operator()(Parent_Selector* p)
   {
-    if (p->is_real_parent_ref()) append_string("&");
+    if (p->real()) append_string("&");
   }
 
-  void Inspect::operator()(Placeholder_Selector_Ptr s)
+  void Inspect::operator()(Placeholder_Selector* s)
   {
     append_token(s->name(), s);
     if (s->has_line_break()) append_optional_linefeed();
@@ -939,26 +892,26 @@ namespace Sass {
 
   }
 
-  void Inspect::operator()(Element_Selector_Ptr s)
+  void Inspect::operator()(Type_Selector* s)
   {
     append_token(s->ns_name(), s);
   }
 
-  void Inspect::operator()(Class_Selector_Ptr s)
+  void Inspect::operator()(Class_Selector* s)
   {
     append_token(s->ns_name(), s);
     if (s->has_line_break()) append_optional_linefeed();
     if (s->has_line_break()) append_indentation();
   }
 
-  void Inspect::operator()(Id_Selector_Ptr s)
+  void Inspect::operator()(Id_Selector* s)
   {
     append_token(s->ns_name(), s);
     if (s->has_line_break()) append_optional_linefeed();
     if (s->has_line_break()) append_indentation();
   }
 
-  void Inspect::operator()(Attribute_Selector_Ptr s)
+  void Inspect::operator()(Attribute_Selector* s)
   {
     append_string("[");
     add_open_mapping(s);
@@ -977,7 +930,7 @@ namespace Sass {
     append_string("]");
   }
 
-  void Inspect::operator()(Pseudo_Selector_Ptr s)
+  void Inspect::operator()(Pseudo_Selector* s)
   {
     append_token(s->ns_name(), s);
     if (s->expression()) {
@@ -987,7 +940,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Wrapped_Selector_Ptr s)
+  void Inspect::operator()(Wrapped_Selector* s)
   {
     if (s->name() == " ") {
       append_string("");
@@ -1005,7 +958,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Compound_Selector_Ptr s)
+  void Inspect::operator()(Compound_Selector* s)
   {
     for (size_t i = 0, L = s->length(); i < L; ++i) {
       (*s)[i]->perform(this);
@@ -1017,7 +970,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Complex_Selector_Ptr c)
+  void Inspect::operator()(Complex_Selector* c)
   {
     Compound_Selector_Obj      head = c->head();
     Complex_Selector_Obj            tail = c->tail();
@@ -1057,7 +1010,7 @@ namespace Sass {
       case Complex_Selector::REFERENCE:
         append_mandatory_space();
         append_string("/");
-        c->reference()->perform(this);
+        if (c->reference()) c->reference()->perform(this);
         append_string("/");
         append_mandatory_space();
       break;
@@ -1081,7 +1034,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Selector_List_Ptr g)
+  void Inspect::operator()(Selector_List* g)
   {
 
     if (g->empty()) {
@@ -1131,8 +1084,4 @@ namespace Sass {
 
   }
 
-  void Inspect::fallback_impl(AST_Node_Ptr n)
-  {
-  }
-
 }