Merge pull request #1346 from mgreter/feature/code-clean-ups

Code clean ups from preparation branch

Author: mgreter

Makefile

@@ -159,18 +159,20 @@ SOURCES = \
 	constants.cpp \
 	context.cpp \
 	cssize.cpp \
-	listize.cpp \
+	emitter.cpp \
+	environment.cpp \
 	error_handling.cpp \
 	eval.cpp \
 	expand.cpp \
 	extend.cpp \
 	file.cpp \
 	functions.cpp \
 	inspect.cpp \
+	json.cpp \
 	lexer.cpp \
+	listize.cpp \
+	memory_manager.cpp \
 	node.cpp \
-	json.cpp \
-	emitter.cpp \
 	output.cpp \
 	parser.cpp \
 	plugins.cpp \
@@ -308,4 +310,4 @@ lib-opts-shared:
         install install-static install-shared \
         lib-opts lib-opts-shared lib-opts-static \
         lib-file lib-file-shared lib-file-static
-.DELETE_ON_ERROR:
+.DELETE_ON_ERROR:

Makefile.am

@@ -31,13 +31,13 @@ lib_LTLIBRARIES = libsass.la
 
 libsass_la_SOURCES = \
 	ast_fwd_decl.hpp ast_def_macros.hpp \
-	kwd_arg_macros.hpp memory_manager.hpp \
+	kwd_arg_macros.hpp \
 	position.cpp position.hpp \
 	operation.hpp \
 	subset_map.hpp mapping.hpp \
 	color_names.hpp backtrace.hpp \
 	cencode.c b64/cencode.h b64/encode.h \
-	token.hpp environment.hpp \
+	token.hpp \
 	paths.hpp debug.hpp \
 	utf8.h utf8/core.h \
 	utf8/checked.h utf8/unchecked.h \
@@ -46,6 +46,7 @@ libsass_la_SOURCES = \
 	bind.cpp bind.hpp \
 	constants.cpp constants.hpp \
 	context.cpp context.hpp \
+	environment.cpp environment.hpp \
 	error_handling.cpp error_handling.hpp \
 	eval.cpp eval.hpp \
 	expand.cpp expand.hpp \
@@ -56,6 +57,7 @@ libsass_la_SOURCES = \
 	functions.cpp functions.hpp \
 	inspect.cpp inspect.hpp \
 	lexer.cpp lexer.hpp \
+	memory_manager.cpp memory_manager.hpp \
 	node.cpp node.hpp \
 	json.cpp json.hpp \
 	emitter.cpp emitter.hpp \

ast.hpp

@@ -48,6 +48,7 @@
 
 #include "sass.h"
 #include "sass_values.h"
+#include "sass_context.h"
 #include "sass_functions.h"
 
 namespace Sass {
@@ -122,7 +123,7 @@ namespace Sass {
     virtual operator bool() { return true; }
     virtual ~Expression() { }
     virtual string type() { return ""; /* TODO: raise an error? */ }
-    virtual bool is_invisible() { return false; }
+    virtual bool is_invisible() const { return false; }
     static string type_name() { return ""; }
     virtual bool is_false() { return false; }
     virtual bool operator==( Expression& rhs) const { return false; }
@@ -177,7 +178,7 @@ namespace Sass {
     size_t length() const   { return elements_.size(); }
     bool empty() const      { return elements_.empty(); }
     T last()                { return elements_.back(); }
-    T first()                { return elements_.front(); }
+    T first()               { return elements_.front(); }
     T& operator[](size_t i) { return elements_[i]; }
     const T& operator[](size_t i) const { return elements_[i]; }
     Vectorized& operator<<(T element)
@@ -259,6 +260,12 @@ namespace Sass {
     }
     const unordered_map<Expression*, Expression*>& pairs() const { return elements_; }
     const vector<Expression*>& keys() const { return list_; }
+
+    unordered_map<Expression*, Expression*>::iterator end() { return elements_.end(); }
+    unordered_map<Expression*, Expression*>::iterator begin() { return elements_.begin(); }
+    unordered_map<Expression*, Expression*>::const_iterator end() const { return elements_.end(); }
+    unordered_map<Expression*, Expression*>::const_iterator begin() const { return elements_.begin(); }
+
   };
   inline Hashed::~Hashed() { }
 
@@ -292,7 +299,7 @@ namespace Sass {
     virtual ~Statement() = 0;
     // needed for rearranging nested rulesets during CSS emission
     virtual bool   is_hoistable() { return false; }
-    virtual bool   is_invisible() { return false; }
+    virtual bool   is_invisible() const { return false; }
     virtual bool   bubbles() { return false; }
     virtual Block* block()  { return 0; }
   };
@@ -347,7 +354,7 @@ namespace Sass {
     Ruleset(ParserState pstate, Selector* s = 0, Block* b = 0)
     : Has_Block(pstate, b), selector_(s), at_root_(false)
     { statement_type(RULESET); }
-    bool is_invisible();
+    bool is_invisible() const;
     // nested rulesets need to be hoisted out of their enclosing blocks
     bool is_hoistable() { return true; }
     ATTACH_OPERATIONS()
@@ -393,7 +400,7 @@ namespace Sass {
     { statement_type(MEDIA); }
     bool bubbles() { return true; }
     bool is_hoistable() { return true; }
-    bool is_invisible() {
+    bool is_invisible() const {
       bool is_invisible = true;
       for (size_t i = 0, L = block()->length(); i < L && is_invisible; i++)
         is_invisible &= (*block())[i]->is_invisible();
@@ -571,13 +578,12 @@ namespace Sass {
   ////////////////////////////////////
   // The Sass `@if` control directive.
   ////////////////////////////////////
-  class If : public Statement {
+  class If : public Has_Block {
     ADD_PROPERTY(Expression*, predicate)
-    ADD_PROPERTY(Block*, consequent)
     ADD_PROPERTY(Block*, alternative)
   public:
     If(ParserState pstate, Expression* pred, Block* con, Block* alt = 0)
-    : Statement(pstate), predicate_(pred), consequent_(con), alternative_(alt)
+    : Has_Block(pstate, con), predicate_(pred), alternative_(alt)
     { }
     ATTACH_OPERATIONS()
   };
@@ -752,21 +758,19 @@ namespace Sass {
   ///////////////////////////////////////////////////////////////////////
   class List : public Expression, public Vectorized<Expression*> {
     void adjust_after_pushing(Expression* e) { is_expanded(false); }
-  public:
-    enum Separator { SPACE, COMMA };
   private:
-    ADD_PROPERTY(Separator, separator)
+    ADD_PROPERTY(enum Sass_Separator, separator)
     ADD_PROPERTY(bool, is_arglist)
   public:
     List(ParserState pstate,
-         size_t size = 0, Separator sep = SPACE, bool argl = false)
+         size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false)
     : Expression(pstate),
       Vectorized<Expression*>(size),
       separator_(sep), is_arglist_(argl)
     { concrete_type(LIST); }
     string type() { return is_arglist_ ? "arglist" : "list"; }
     static string type_name() { return "list"; }
-    bool is_invisible() { return !length(); }
+    bool is_invisible() const { return empty(); }
     Expression* value_at_index(size_t i);
 
     virtual size_t size() const;
@@ -777,7 +781,7 @@ namespace Sass {
     {
       if (hash_ > 0) return hash_;
 
-      hash_ = std::hash<string>()(separator() == COMMA ? "comma" : "space");
+      hash_ = std::hash<string>()(separator() == SASS_COMMA ? "comma" : "space");
       for (size_t i = 0, L = length(); i < L; ++i)
         hash_combine(hash_, (elements()[i])->hash());
 
@@ -807,7 +811,7 @@ namespace Sass {
     { concrete_type(MAP); }
     string type() { return "map"; }
     static string type_name() { return "map"; }
-    bool is_invisible() { return !length(); }
+    bool is_invisible() const { return empty(); }
 
     virtual bool operator==(Expression& rhs) const
     {
@@ -847,21 +851,14 @@ namespace Sass {
   // subclassing.
   //////////////////////////////////////////////////////////////////////////
   class Binary_Expression : public Expression {
-  public:
-    enum Type {
-      AND, OR,                   // logical connectives
-      EQ, NEQ, GT, GTE, LT, LTE, // arithmetic relations
-      ADD, SUB, MUL, DIV, MOD,   // arithmetic functions
-      NUM_OPS                    // so we know how big to make the op table
-    };
   private:
-    ADD_PROPERTY(Type, type)
+    ADD_PROPERTY(enum Sass_OP, type)
     ADD_PROPERTY(Expression*, left)
     ADD_PROPERTY(Expression*, right)
     size_t hash_;
   public:
     Binary_Expression(ParserState pstate,
-                      Type t, Expression* lhs, Expression* rhs)
+                      enum Sass_OP t, Expression* lhs, Expression* rhs)
     : Expression(pstate), type_(t), left_(lhs), right_(rhs), hash_(0)
     { }
     const string type_name() {
@@ -1553,7 +1550,7 @@ namespace Sass {
     Null(ParserState pstate) : Expression(pstate) { concrete_type(NULL_VAL); }
     string type() { return "null"; }
     static string type_name() { return "null"; }
-    bool is_invisible() { return true; }
+    bool is_invisible() const { return true; }
     operator bool() { return false; }
     bool is_false() { return true; }
 
@@ -2133,7 +2130,7 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
-  inline bool Ruleset::is_invisible() {
+  inline bool Ruleset::is_invisible() const {
     bool is_invisible = true;
     Selector_List* sl = static_cast<Selector_List*>(selector());
     for (size_t i = 0, L = sl->length(); i < L && is_invisible; ++i)

ast_def_macros.hpp

@@ -33,7 +33,7 @@ virtual Statement* perform(Operation<Statement*>* op) { return (*op)(this); }\
 virtual Expression* perform(Operation<Expression*>* op) { return (*op)(this); }\
 virtual Selector* perform(Operation<Selector*>* op) { return (*op)(this); }\
 virtual string perform(Operation<string>* op) { return (*op)(this); }\
-virtual Sass_Value* perform(Operation<Sass_Value*>* op) { return (*op)(this); }
+virtual union Sass_Value* perform(Operation<union Sass_Value*>* op) { return (*op)(this); }
 
 #define ADD_PROPERTY(type, name)\
 protected:\

ast_factory.hpp

@@ -37,7 +37,7 @@ namespace Sass {
     Definition<FUNCTION>* new_Function_Definition(string p, size_t l, string n, Parameters* params, Block* b);
     Mixin_Call* new_Mixin_Call(string p, size_t l, string n, Arguments* args, Block* b = 0);
     // expressions
-    List* new_List(string p, size_t l, size_t size = 0, List::Separator sep = List::space, bool argl = false);
+    List* new_List(string p, size_t l, size_t size = 0, enum Sass_Separator sep = List::space, bool argl = false);
     Map* new_Map(string p, size_t l, size_t size = 0);
     Binary_Expression<AND>* new_And(string p, size_t l, Expression* lhs, Expression* rhs);
     Binary_Expression<OR>* new_Or(string p, size_t l, Expression* lhs, Expression* rhs);

bind.cpp

@@ -98,7 +98,7 @@ namespace Sass {
         } else if (a->is_keyword_argument()) {
 
           // expand keyword arguments into their parameters
-          List* arglist = new (ctx.mem) List(p->pstate(), 0, List::COMMA, true);
+          List* arglist = new (ctx.mem) List(p->pstate(), 0, SASS_COMMA, true);
           env->local_frame()[p->name()] = arglist;
           Map* argmap = static_cast<Map*>(a->value());
           for (auto key : argmap->keys()) {
@@ -115,7 +115,7 @@ namespace Sass {
           // create a new list object for wrapped items
           List* arglist = new (ctx.mem) List(p->pstate(),
                                              0,
-                                             List::COMMA,
+                                             SASS_COMMA,
                                              true);
           // consume the next args
           while (ia < LA) {
@@ -238,7 +238,7 @@ namespace Sass {
         if (leftover->is_rest_parameter()) {
           env->local_frame()[leftover->name()] = new (ctx.mem) List(leftover->pstate(),
                                                                       0,
-                                                                      List::COMMA,
+                                                                      SASS_COMMA,
                                                                       true);
         }
         else if (leftover->default_value()) {

cssize.cpp

@@ -480,7 +480,7 @@ namespace Sass {
   {
     List* qq = new (ctx.mem) List(m1->media_queries()->pstate(),
                                   m1->media_queries()->length(),
-                                  List::COMMA);
+                                  SASS_COMMA);
 
     for (size_t i = 0, L = m1->media_queries()->length(); i < L; i++) {
       for (size_t j = 0, K = m2->media_queries()->length(); j < K; j++) {

debugger.hpp

@@ -283,7 +283,7 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " " << block->tabs() << endl;
     debug_ast(block->predicate(), ind + " = ");
-    debug_ast(block->consequent(), ind + " <>");
+    debug_ast(block->block(), ind + " <>");
     debug_ast(block->alternative(), ind + " ><");
   } else if (dynamic_cast<Return*>(node)) {
     Return* block = dynamic_cast<Return*>(node);
@@ -480,7 +480,7 @@ inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
     cerr << ind << "List " << expression;
     cerr << " (" << pstate_source_position(node) << ")";
     cerr << " (" << expression->length() << ") " <<
-      (expression->separator() == Sass::List::Separator::COMMA ? "Comma " : "Space ") <<
+      (expression->separator() == SASS_COMMA ? "Comma " : "Space ") <<
       " [delayed: " << expression->is_delayed() << "] " <<
       " [interpolant: " << expression->is_interpolant() << "] " <<
       " [arglist: " << expression->is_arglist() << "] " <<