Preparation for interpolate/output refactor

Makefile

@@ -107,6 +107,7 @@ SOURCES = \
 	inspect.cpp \
 	node.cpp \
 	json.cpp \
+	output.cpp \
 	output_compressed.cpp \
 	output_nested.cpp \
 	parser.cpp \

Makefile.am

@@ -60,6 +60,7 @@ libsass_la_SOURCES = \
 	inspect.cpp inspect.hpp \
 	node.cpp node.hpp \
 	json.cpp json.hpp \
+	output.cpp output.hpp \
 	output_compressed.cpp output_compressed.hpp \
 	output_nested.cpp output_nested.hpp \
 	parser.cpp parser.hpp \

ast.cpp

@@ -89,7 +89,7 @@ namespace Sass {
 
   Compound_Selector* Simple_Selector::unify_with(Compound_Selector* rhs, Context& ctx)
   {
-    To_String to_string;
+    To_String to_string(&ctx);
     for (size_t i = 0, L = rhs->length(); i < L; ++i)
     { if (perform(&to_string) == (*rhs)[i]->perform(&to_string)) return rhs; }
 
@@ -451,7 +451,7 @@ namespace Sass {
   {
     Complex_Selector* cpy = new (ctx.mem) Complex_Selector(*this);
 
-		if (head()) {
+    if (head()) {
     	cpy->head(head()->clone(ctx));
     }
 
@@ -533,7 +533,7 @@ namespace Sass {
 
   Compound_Selector* Compound_Selector::minus(Compound_Selector* rhs, Context& ctx)
   {
-    To_String to_string;
+    To_String to_string(&ctx);
     Compound_Selector* result = new (ctx.mem) Compound_Selector(pstate());
 
     // not very efficient because it needs to preserve order

ast.hpp

@@ -31,7 +31,7 @@
 #endif
 
 #include "units.hpp"
-#include "token.hpp"
+#include "position.hpp"
 #include "constants.hpp"
 #include "operation.hpp"
 #include "position.hpp"
@@ -40,7 +40,7 @@
 #include "environment.hpp"
 #include "error_handling.hpp"
 #include "ast_def_macros.hpp"
- #include "to_string.hpp"
+#include "to_string.hpp"
 
 #include "sass.h"
 #include "sass_values.h"
@@ -59,7 +59,9 @@ namespace Sass {
   class AST_Node {
     ADD_PROPERTY(ParserState, pstate);
   public:
-    AST_Node(ParserState pstate) : pstate_(pstate) { }
+    AST_Node(ParserState pstate)
+    : pstate_(pstate)
+    { }
     virtual ~AST_Node() = 0;
     // virtual Block* block() { return 0; }
   public:
@@ -98,7 +100,10 @@ namespace Sass {
     Expression(ParserState pstate,
                bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)
     : AST_Node(pstate),
-      is_delayed_(d), is_expanded_(d), is_interpolant_(i), concrete_type_(ct)
+      is_delayed_(d),
+      is_expanded_(d),
+      is_interpolant_(i),
+      concrete_type_(ct)
     { }
     virtual operator bool() { return true; }
     virtual ~Expression() { };
@@ -184,7 +189,7 @@ namespace Sass {
   inline Vectorized<T>::~Vectorized() { }
 
   /////////////////////////////////////////////////////////////////////////////
-  // Mixin class for AST nodes that should behave like ahash table. Uses an
+  // Mixin class for AST nodes that should behave like a hash table. Uses an
   // extra <vector> internally to maintain insertion order for interation.
   /////////////////////////////////////////////////////////////////////////////
   class Hashed {
@@ -471,7 +476,7 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////////
   class Import : public Statement {
     vector<string>         files_;
-    vector<Expression*> urls_;
+    vector<Expression*>    urls_;
   public:
     Import(ParserState pstate)
     : Statement(pstate),
@@ -1326,10 +1331,10 @@ namespace Sass {
   // "flat" strings.
   ////////////////////////////////////////////////////////////////////////
   class String : public Expression {
-    ADD_PROPERTY(bool, needs_unquoting);
+    ADD_PROPERTY(bool, sass_fix_1291);
   public:
-    String(ParserState pstate, bool unq = false, bool delayed = false)
-    : Expression(pstate, delayed), needs_unquoting_(unq)
+    String(ParserState pstate, bool delayed = false, bool sass_fix_1291 = false)
+    : Expression(pstate, delayed), sass_fix_1291_(sass_fix_1291)
     { concrete_type(STRING); }
     static string type_name() { return "string"; }
     virtual ~String() = 0;
@@ -1342,12 +1347,11 @@ namespace Sass {
   // evaluation phase.
   ///////////////////////////////////////////////////////////////////////
   class String_Schema : public String, public Vectorized<Expression*> {
-    ADD_PROPERTY(char, quote_mark);
     ADD_PROPERTY(bool, has_interpolants);
     size_t hash_;
   public:
-    String_Schema(ParserState pstate, size_t size = 0, bool unq = false, char qm = '\0', bool i = false)
-    : String(pstate, unq), Vectorized<Expression*>(size), quote_mark_(qm), has_interpolants_(i), hash_(0)
+    String_Schema(ParserState pstate, size_t size = 0, bool has_interpolants = false)
+    : String(pstate), Vectorized<Expression*>(size), has_interpolants_(has_interpolants), hash_(0)
     { }
     string type() { return "string"; }
     static string type_name() { return "string"; }
@@ -1386,22 +1390,23 @@ namespace Sass {
   // Flat strings -- the lowest level of raw textual data.
   ////////////////////////////////////////////////////////
   class String_Constant : public String {
+    ADD_PROPERTY(char, quote_mark);
     ADD_PROPERTY(string, value);
     string unquoted_;
     size_t hash_;
   public:
-    String_Constant(ParserState pstate, string val, bool unq = false)
-    : String(pstate, unq, true), value_(val), hash_(0)
-    { unquoted_ = unquote(value_); }
-    String_Constant(ParserState pstate, const char* beg, bool unq = false)
-    : String(pstate, unq, true), value_(string(beg)), hash_(0)
-    { unquoted_ = unquote(value_); }
-    String_Constant(ParserState pstate, const char* beg, const char* end, bool unq = false)
-    : String(pstate, unq, true), value_(string(beg, end-beg)), hash_(0)
-    { unquoted_ = unquote(value_); }
-    String_Constant(ParserState pstate, const Token& tok, bool unq = false)
-    : String(pstate, unq, true), value_(string(tok.begin, tok.end)), hash_(0)
-    { unquoted_ = unquote(value_); }
+    String_Constant(ParserState pstate, string val)
+    : String(pstate), quote_mark_(0), value_(val), hash_(0)
+    { unquoted_ = unquote(value_, &quote_mark_); }
+    String_Constant(ParserState pstate, const char* beg)
+    : String(pstate), quote_mark_(0), value_(string(beg)), hash_(0)
+    { unquoted_ = unquote(value_, &quote_mark_); }
+    String_Constant(ParserState pstate, const char* beg, const char* end)
+    : String(pstate), quote_mark_(0), value_(string(beg, end-beg)), hash_(0)
+    { unquoted_ = unquote(value_, &quote_mark_); }
+    String_Constant(ParserState pstate, const Token& tok)
+    : String(pstate), quote_mark_(0), value_(string(tok.begin, tok.end)), hash_(0)
+    { unquoted_ = unquote(value_, &quote_mark_); }
     string type() { return "string"; }
     static string type_name() { return "string"; }
 
@@ -1425,11 +1430,23 @@ namespace Sass {
       return hash_;
     }
 
-    static char single_quote() { return '\''; }
+    // static char auto_quote() { return '*'; }
     static char double_quote() { return '"'; }
+    static char single_quote() { return '\''; }
 
-    bool is_quoted() { return value_.length() && (value_[0] == '"' || value_[0] == '\''); }
-    char quote_mark() { return is_quoted() ? value_[0] : '\0'; }
+    ATTACH_OPERATIONS();
+  };
+
+  ////////////////////////////////////////////////////////
+  // Possibly quoted string (unquote on instantiation)
+  ////////////////////////////////////////////////////////
+  class String_Quoted : public String_Constant {
+  public:
+    String_Quoted(ParserState pstate, string val)
+    : String_Constant(pstate, val)
+    {
+      // value_ = unquote(value_, &quote_mark_);
+    }
     ATTACH_OPERATIONS();
   };
 
@@ -1690,7 +1707,9 @@ namespace Sass {
     ADD_PROPERTY(bool, has_placeholder);
   public:
     Selector(ParserState pstate, bool r = false, bool h = false)
-    : AST_Node(pstate), has_reference_(r), has_placeholder_(h)
+    : AST_Node(pstate),
+      has_reference_(r),
+      has_placeholder_(h)
     { }
     virtual ~Selector() = 0;
     virtual Selector_Placeholder* find_placeholder();
@@ -2029,8 +2048,7 @@ namespace Sass {
   ///////////////////////////////////
   // Comma-separated selector groups.
   ///////////////////////////////////
-  class Selector_List
-      : public Selector, public Vectorized<Complex_Selector*> {
+  class Selector_List : public Selector, public Vectorized<Complex_Selector*> {
 #ifdef DEBUG
     ADD_PROPERTY(string, mCachedSelector);
 #endif

ast_fwd_decl.hpp

@@ -6,6 +6,8 @@
 /////////////////////////////////////////////
 namespace Sass {
 
+  enum Output_Style { NESTED, EXPANDED, COMPACT, COMPRESSED, FORMATTED };
+
   class AST_Node;
   // statements
   class Statement;
@@ -51,6 +53,7 @@ namespace Sass {
   class String_Schema;
   class String;
   class String_Constant;
+  class String_Quoted;
   class Media_Query;
   class Media_Query_Expression;
   class Feature_Query;

bind.cpp

@@ -145,7 +145,7 @@ namespace Sass {
     // That's only okay if they have default values, or were already bound by
     // named arguments, or if it's a single rest-param.
     for (size_t i = ip; i < LP; ++i) {
-      To_String to_string;
+      To_String to_string(&ctx);
       Parameter* leftover = (*ps)[i];
       // cerr << "env for default params:" << endl;
       // env->print();

context.cpp

@@ -68,7 +68,6 @@ namespace Sass {
     names_to_colors         (map<string, Color*>()),
     colors_to_names         (map<int, string>()),
     precision               (initializers.precision()),
-    _skip_source_map_update (initializers._skip_source_map_update()),
     subset_map              (Subset_Map<string, pair<Complex_Selector*, Compound_Selector*> >())
   {
     cwd = get_cwd();
@@ -277,9 +276,6 @@ namespace Sass {
     Contextualize contextualize(*this, &eval, &tge, &backtrace);
     Expand expand(*this, &eval, &contextualize, &tge, &backtrace);
     Cssize cssize(*this, &tge, &backtrace);
-    // Inspect inspect(this);
-    // Output_Nested output_nested(*this);
-
     root = root->perform(&expand)->block();
     root = root->perform(&cssize)->block();
     if (!subset_map.empty()) {

context.hpp

@@ -29,8 +29,6 @@ namespace Sass {
   // typedef Environment<AST_Node*> Env;
   // typedef Expression* (*Native_Function)(Env&, Context&, Signature, string, size_t);
 
-  enum Output_Style { NESTED, EXPANDED, COMPACT, COMPRESSED, FORMATTED };
-
   struct Sass_Queued {
     string abs_path;
     string load_path;
@@ -79,7 +77,6 @@ namespace Sass {
     map<int, string>    colors_to_names;
 
     size_t precision; // precision for outputting fractional numbers
-    bool _skip_source_map_update; // status flag to skip source map updates
 
     KWD_ARG_SET(Data) {
       KWD_ARG(Data, const char*,     source_c_str);
@@ -97,7 +94,6 @@ namespace Sass {
       KWD_ARG(Data, bool,            omit_source_map_url);
       KWD_ARG(Data, bool,            is_indented_syntax_src);
       KWD_ARG(Data, size_t,          precision);
-      KWD_ARG(Data, bool,            _skip_source_map_update);
       KWD_ARG(Data, bool,            source_map_embed);
       KWD_ARG(Data, bool,            source_map_contents);
       KWD_ARG(Data, Sass_C_Import_Callback, importer);

contextualize.cpp

@@ -28,7 +28,7 @@ namespace Sass {
 
   Selector* Contextualize::operator()(Selector_Schema* s)
   {
-    To_String to_string;
+    To_String to_string(&ctx);
     string result_str(s->contents()->perform(eval->with(env, backtrace))->perform(&to_string));
     result_str += '{'; // the parser looks for a brace to end the selector
     Selector* result_sel = Parser::from_c_str(result_str.c_str(), ctx, s->pstate()).parse_selector_group();
@@ -61,7 +61,7 @@ namespace Sass {
 
   Selector* Contextualize::operator()(Complex_Selector* s)
   {
-    To_String to_string;
+    To_String to_string(&ctx);
     Complex_Selector* ss = new (ctx.mem) Complex_Selector(*s);
     Compound_Selector* new_head = 0;
     Complex_Selector* new_tail = 0;
@@ -89,7 +89,7 @@ namespace Sass {
 
   Selector* Contextualize::operator()(Compound_Selector* s)
   {
-    To_String to_string;
+    To_String to_string(&ctx);
     if (placeholder && extender && s->perform(&to_string) == placeholder->perform(&to_string)) {
       return extender;
     }
@@ -135,7 +135,7 @@ namespace Sass {
 
   Selector* Contextualize::operator()(Selector_Placeholder* p)
   {
-    To_String to_string;
+    To_String to_string(&ctx);
     if (placeholder && extender && p->perform(&to_string) == placeholder->perform(&to_string)) {
       return extender;
     }

cssize.cpp

@@ -27,6 +27,7 @@ namespace Sass {
     new_env.link(*env);
     env = &new_env;
     Block* bb = new (ctx.mem) Block(b->pstate(), b->length(), b->is_root());
+    // bb->tabs(b->tabs());
     block_stack.push_back(bb);
     append_block(b);
     block_stack.pop_back();
@@ -97,6 +98,7 @@ namespace Sass {
     Ruleset* rr = new (ctx.mem) Ruleset(r->pstate(),
                                         r->selector(),
                                         r->block()->perform(this)->block());
+    // rr->tabs(r->block()->tabs());
     p_stack.pop_back();
 
     Block* props = new Block(rr->block()->pstate());
@@ -191,6 +193,7 @@ namespace Sass {
     {
       Block* bb = m->block()->perform(this)->block();
       for (size_t i = 0, L = bb->length(); i < L; ++i) {
+        (bb->elements())[i]->tabs(m->tabs());
         if (bubblable((*bb)[i])) (*bb)[i]->tabs((*bb)[i]->tabs() + m->tabs());
       }
       if (bb->length() && bubblable(bb->last())) bb->last()->group_end(m->group_end());
@@ -295,6 +298,8 @@ namespace Sass {
                                                 wrapper_block,
                                                 m->selector());
 
+    mm->tabs(m->tabs());
+
     Bubble* bubble = new (ctx.mem) Bubble(mm->pstate(), mm);
 
     return bubble;
@@ -496,7 +501,7 @@ namespace Sass {
 
   Media_Query* Cssize::merge_media_query(Media_Query* mq1, Media_Query* mq2)
   {
-    To_String to_string;
+    To_String to_string(&ctx);
 
     string type;
     string mod;