sassc 1.7.1 → 1.8.0.pre1

data/ext/libsass/src/context.hpp

@@ -0,0 +1,150 @@
+#ifndef SASS_CONTEXT_H
+#define SASS_CONTEXT_H
+
+#include <string>
+#include <vector>
+#include <map>
+
+#define BUFFERSIZE 255
+#include "b64/encode.h"
+
+#include "ast_fwd_decl.hpp"
+#include "kwd_arg_macros.hpp"
+#include "memory_manager.hpp"
+#include "environment.hpp"
+#include "source_map.hpp"
+#include "subset_map.hpp"
+#include "output.hpp"
+#include "plugins.hpp"
+#include "file.hpp"
+#include "sass.h"
+
+struct Sass_Function;
+
+namespace Sass {
+
+  class Context {
+  public:
+    size_t head_imports;
+    Memory_Manager mem;
+
+    struct Sass_Options* c_options;
+    struct Sass_Compiler* c_compiler;
+    char* source_c_str;
+
+    // c-strs containing Sass file contents
+    // we will overtake ownership of memory
+    std::vector<char*> sources;
+    // strings get freed with context
+    std::vector<char*> strings;
+    // absolute paths to includes
+    std::vector<std::string> included_files;
+    // relative links to includes
+    std::vector<std::string> include_links;
+    // vectors above have same size
+
+    std::vector<std::string> plugin_paths; // relative paths to load plugins
+    std::vector<std::string> include_paths; // lookup paths for includes
+    std::vector<Sass_Queued> queue; // queue of files to be parsed
+    std::map<std::string, Block*> style_sheets; // map of paths to ASTs
+    // SourceMap source_map;
+    Output emitter;
+
+    std::vector<Sass_Importer_Entry> c_headers;
+    std::vector<Sass_Importer_Entry> c_importers;
+    std::vector<Sass_Function_Entry> c_functions;
+
+    void add_c_header(Sass_Importer_Entry header);
+    void add_c_importer(Sass_Importer_Entry importer);
+    void add_c_function(Sass_Function_Entry function);
+
+    std::string       indent; // String to be used for indentation
+    std::string       linefeed; // String to be used for line feeds
+    std::string       input_path; // for relative paths in src-map
+    std::string       output_path; // for relative paths to the output
+    bool         source_comments; // for inline debug comments in css output
+    Output_Style output_style; // output style for the generated css code
+    std::string       source_map_file; // path to source map file (enables feature)
+    std::string       source_map_root; // path for sourceRoot property (pass-through)
+    bool         source_map_embed; // embed in sourceMappingUrl (as data-url)
+    bool         source_map_contents; // insert included contents into source map
+    bool         omit_source_map_url; // disable source map comment in css output
+    bool         is_indented_syntax_src; // treat source string as sass
+
+    // overload import calls
+    std::vector<Sass_Import_Entry> import_stack;
+
+    size_t precision; // precision for outputting fractional numbers
+
+    KWD_ARG_SET(Data) {
+      KWD_ARG(Data, struct Sass_Options*,      c_options)
+      KWD_ARG(Data, struct Sass_Compiler*,     c_compiler)
+      KWD_ARG(Data, char*,                     source_c_str)
+      KWD_ARG(Data, std::string,               entry_point)
+      KWD_ARG(Data, std::string,               input_path)
+      KWD_ARG(Data, std::string,               output_path)
+      KWD_ARG(Data, std::string,               indent)
+      KWD_ARG(Data, std::string,               linefeed)
+      KWD_ARG(Data, const char*,               include_paths_c_str)
+      KWD_ARG(Data, const char*,               plugin_paths_c_str)
+      // KWD_ARG(Data, const char**,              include_paths_array)
+      // KWD_ARG(Data, const char**,              plugin_paths_array)
+      KWD_ARG(Data, std::vector<std::string>,  include_paths)
+      KWD_ARG(Data, std::vector<std::string>,  plugin_paths)
+      KWD_ARG(Data, bool,                      source_comments)
+      KWD_ARG(Data, Output_Style,              output_style)
+      KWD_ARG(Data, std::string,               source_map_file)
+      KWD_ARG(Data, std::string,               source_map_root)
+      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,                      source_map_embed)
+      KWD_ARG(Data, bool,                      source_map_contents)
+    };
+
+    Context(Data);
+    ~Context();
+    static std::string get_cwd();
+
+    Block* parse_file();
+    Block* parse_string();
+    void add_source(std::string, std::string, char*);
+
+    std::string add_file(const std::string& imp_path, bool delay = false);
+    std::string add_file(const std::string& imp_path, const std::string& abs_path, ParserState pstate);
+
+    void process_queue_entry(Sass_Queued& entry, size_t idx);
+
+    // allow to optionally overwrite the input path
+    // default argument for input_path is std::string("stdin")
+    // usefull to influence the source-map generating etc.
+    char* compile_file();
+    char* compile_string();
+    char* compile_block(Block* root);
+    char* generate_source_map();
+
+    std::vector<std::string> get_included_files(bool skip = false, size_t headers = 0);
+
+  private:
+    void collect_plugin_paths(const char* paths_str);
+    void collect_plugin_paths(const char** paths_array);
+    void collect_include_paths(const char* paths_str);
+    void collect_include_paths(const char** paths_array);
+    std::string format_embedded_source_map();
+    std::string format_source_mapping_url(const std::string& out_path);
+
+    std::string cwd;
+    Plugins plugins;
+
+    // void register_built_in_functions(Env* env);
+    // void register_function(Signature sig, Native_Function f, Env* env);
+    // void register_function(Signature sig, Native_Function f, size_t arity, Env* env);
+    // void register_overload_stub(std::string name, Env* env);
+
+  public:
+    Subset_Map<std::string, std::pair<Complex_Selector*, Compound_Selector*> > subset_map;
+  };
+
+}
+
+#endif

data/ext/libsass/{cssize.cpp → src/cssize.cpp}

@@ -1,5 +1,6 @@
 #include <iostream>
 #include <typeinfo>
+#include <vector>
 
 #include "cssize.hpp"
 #include "to_string.hpp"
@@ -8,11 +9,10 @@
 
 namespace Sass {
 
-  Cssize::Cssize(Context& ctx, Env* env, Backtrace* bt)
+  Cssize::Cssize(Context& ctx, Backtrace* bt)
   : ctx(ctx),
-    env(env),
-    block_stack(vector<Block*>()),
-    p_stack(vector<Statement*>()),
+    block_stack(std::vector<Block*>()),
+    p_stack(std::vector<Statement*>()),
     backtrace(bt)
   {  }
 
@@ -23,15 +23,11 @@ namespace Sass {
 
   Statement* Cssize::operator()(Block* b)
   {
-    Env new_env;
-    new_env.link(*env);
-    env = &new_env;
-    Block* bb = new (ctx.mem) Block(b->pstate(), b->length(), b->is_root());
+    Block* bb = SASS_MEMORY_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();
-    env = env->parent();
     return bb;
   }
 
@@ -41,14 +37,15 @@ namespace Sass {
 
     if (parent()->statement_type() == Statement::RULESET)
     {
-      return (r->is_keyframes()) ? new (ctx.mem) Bubble(r->pstate(), r) : bubble(r);
+      return (r->is_keyframes()) ? SASS_MEMORY_NEW(ctx.mem, Bubble, r->pstate(), r) : bubble(r);
     }
 
     p_stack.push_back(r);
-    At_Rule* rr = new (ctx.mem) At_Rule(r->pstate(),
-                                        r->keyword(),
-                                        r->selector(),
-                                        r->block() ? r->block()->perform(this)->block() : 0);
+    At_Rule* rr = SASS_MEMORY_NEW(ctx.mem, At_Rule,
+                                  r->pstate(),
+                                  r->keyword(),
+                                  r->selector(),
+                                  r->block() ? r->block()->perform(this)->block() : 0);
     if (r->value()) rr->value(r->value());
     p_stack.pop_back();
 
@@ -65,15 +62,15 @@ namespace Sass {
 
     }
 
-    Block* result = new (ctx.mem) Block(rr->pstate());
+    Block* result = SASS_MEMORY_NEW(ctx.mem, Block, rr->pstate());
     if (!(directive_exists || rr->is_keyframes()))
     {
       At_Rule* empty_node = static_cast<At_Rule*>(rr);
-      empty_node->block(new (ctx.mem) Block(rr->block() ? rr->block()->pstate() : rr->pstate()));
+      empty_node->block(SASS_MEMORY_NEW(ctx.mem, Block, rr->block() ? rr->block()->pstate() : rr->pstate()));
       *result << empty_node;
     }
 
-    Statement* ss = debubble(rr->block() ? rr->block() : new (ctx.mem) Block(rr->pstate()), rr);
+    Statement* ss = debubble(rr->block() ? rr->block() : SASS_MEMORY_NEW(ctx.mem, Block, rr->pstate()), rr);
     for (size_t i = 0, L = ss->block()->length(); i < L; ++i) {
       *result << (*ss->block())[i];
     }
@@ -85,8 +82,9 @@ namespace Sass {
   {
     if (!r->block() || !r->block()->length()) return r;
 
-    Keyframe_Rule* rr = new (ctx.mem) Keyframe_Rule(r->pstate(),
-                                                    r->block()->perform(this)->block());
+    Keyframe_Rule* rr = SASS_MEMORY_NEW(ctx.mem, Keyframe_Rule,
+                                        r->pstate(),
+                                        r->block()->perform(this)->block());
     if (r->selector()) rr->selector(r->selector());
 
     return debubble(rr->block(), rr)->block();
@@ -95,14 +93,15 @@ namespace Sass {
   Statement* Cssize::operator()(Ruleset* r)
   {
     p_stack.push_back(r);
-    Ruleset* rr = new (ctx.mem) Ruleset(r->pstate(),
-                                        r->selector(),
-                                        r->block()->perform(this)->block());
+    Ruleset* rr = SASS_MEMORY_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 (ctx.mem) Block(rr->block()->pstate());
-    Block* rules = new (ctx.mem) Block(rr->block()->pstate());
+    Block* props = SASS_MEMORY_NEW(ctx.mem, Block, rr->block()->pstate());
+    Block* rules = SASS_MEMORY_NEW(ctx.mem, Block, rr->block()->pstate());
     for (size_t i = 0, L = rr->block()->length(); i < L; i++)
     {
       Statement* s = (*rr->block())[i];
@@ -112,7 +111,7 @@ namespace Sass {
 
     if (props->length())
     {
-      Block* bb = new (ctx.mem) Block(rr->block()->pstate());
+      Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, rr->block()->pstate());
       *bb += props;
       rr->block(bb);
 
@@ -136,19 +135,25 @@ namespace Sass {
     return rules;
   }
 
+  Statement* Cssize::operator()(Null* m)
+  {
+    return 0;
+  }
+
   Statement* Cssize::operator()(Media_Block* m)
   {
     if (parent()->statement_type() == Statement::RULESET)
     { return bubble(m); }
 
     if (parent()->statement_type() == Statement::MEDIA)
-    { return new (ctx.mem) Bubble(m->pstate(), m); }
+    { return SASS_MEMORY_NEW(ctx.mem, Bubble, m->pstate(), m); }
 
     p_stack.push_back(m);
 
-    Media_Block* mm = new (ctx.mem) Media_Block(m->pstate(),
-                                                m->media_queries(),
-                                                m->block()->perform(this)->block());
+    Media_Block* mm = SASS_MEMORY_NEW(ctx.mem, Media_Block,
+                                      m->pstate(),
+                                      m->media_queries(),
+                                      m->block()->perform(this)->block());
     mm->tabs(m->tabs());
 
     p_stack.pop_back();
@@ -156,7 +161,7 @@ namespace Sass {
     return debubble(mm->block(), mm)->block();
   }
 
-  Statement* Cssize::operator()(Feature_Block* m)
+  Statement* Cssize::operator()(Supports_Block* m)
   {
     if (!m->block()->length())
     { return m; }
@@ -166,9 +171,10 @@ namespace Sass {
 
     p_stack.push_back(m);
 
-    Feature_Block* mm = new (ctx.mem) Feature_Block(m->pstate(),
-                                                    m->feature_queries(),
-                                                    m->block()->perform(this)->block());
+    Supports_Block* mm = SASS_MEMORY_NEW(ctx.mem, Supports_Block,
+                                       m->pstate(),
+                                       m->condition(),
+                                       m->block()->perform(this)->block());
     mm->tabs(m->tabs());
 
     p_stack.pop_back();
@@ -197,7 +203,7 @@ namespace Sass {
 
     if (m->exclude_node(parent()))
     {
-      return new (ctx.mem) Bubble(m->pstate(), m);
+      return SASS_MEMORY_NEW(ctx.mem, Bubble, m->pstate(), m);
     }
 
     return bubble(m);
@@ -205,7 +211,7 @@ namespace Sass {
 
   Statement* Cssize::bubble(At_Rule* m)
   {
-    Block* bb = new (ctx.mem) Block(this->parent()->pstate());
+    Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, this->parent()->pstate());
     Has_Block* new_rule = static_cast<Has_Block*>(shallow_copy(this->parent()));
     new_rule->block(bb);
     new_rule->tabs(this->parent()->tabs());
@@ -215,21 +221,22 @@ namespace Sass {
       *new_rule->block() << (*m->block())[i];
     }
 
-    Block* wrapper_block = new (ctx.mem) Block(m->block() ? m->block()->pstate() : m->pstate());
+    Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block() ? m->block()->pstate() : m->pstate());
     *wrapper_block << new_rule;
-    At_Rule* mm = new (ctx.mem) At_Rule(m->pstate(),
-                                        m->keyword(),
-                                        m->selector(),
-                                        wrapper_block);
+    At_Rule* mm = SASS_MEMORY_NEW(ctx.mem, At_Rule,
+                                  m->pstate(),
+                                  m->keyword(),
+                                  m->selector(),
+                                  wrapper_block);
     if (m->value()) mm->value(m->value());
 
-    Bubble* bubble = new (ctx.mem) Bubble(mm->pstate(), mm);
+    Bubble* bubble = SASS_MEMORY_NEW(ctx.mem, Bubble, mm->pstate(), mm);
     return bubble;
   }
 
   Statement* Cssize::bubble(At_Root_Block* m)
   {
-    Block* bb = new (ctx.mem) Block(this->parent()->pstate());
+    Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, this->parent()->pstate());
     Has_Block* new_rule = static_cast<Has_Block*>(shallow_copy(this->parent()));
     new_rule->block(bb);
     new_rule->tabs(this->parent()->tabs());
@@ -238,39 +245,41 @@ namespace Sass {
       *new_rule->block() << (*m->block())[i];
     }
 
-    Block* wrapper_block = new (ctx.mem) Block(m->block()->pstate());
+    Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block()->pstate());
     *wrapper_block << new_rule;
-    At_Root_Block* mm = new (ctx.mem) At_Root_Block(m->pstate(),
-                                                    wrapper_block,
-                                                    m->expression());
-
-    Bubble* bubble = new (ctx.mem) Bubble(mm->pstate(), mm);
+    At_Root_Block* mm = SASS_MEMORY_NEW(ctx.mem, At_Root_Block,
+                                        m->pstate(),
+                                        wrapper_block,
+                                        m->expression());
+    Bubble* bubble = SASS_MEMORY_NEW(ctx.mem, Bubble, mm->pstate(), mm);
     return bubble;
   }
 
-  Statement* Cssize::bubble(Feature_Block* m)
+  Statement* Cssize::bubble(Supports_Block* m)
   {
     Ruleset* parent = static_cast<Ruleset*>(shallow_copy(this->parent()));
 
-    Block* bb = new (ctx.mem) Block(parent->block()->pstate());
-    Ruleset* new_rule = new (ctx.mem) Ruleset(parent->pstate(),
-                                              parent->selector(),
-                                              bb);
+    Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, parent->block()->pstate());
+    Ruleset* new_rule = SASS_MEMORY_NEW(ctx.mem, Ruleset,
+                                        parent->pstate(),
+                                        parent->selector(),
+                                        bb);
     new_rule->tabs(parent->tabs());
 
     for (size_t i = 0, L = m->block()->length(); i < L; ++i) {
       *new_rule->block() << (*m->block())[i];
     }
 
-    Block* wrapper_block = new (ctx.mem) Block(m->block()->pstate());
+    Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block()->pstate());
     *wrapper_block << new_rule;
-    Feature_Block* mm = new (ctx.mem) Feature_Block(m->pstate(),
-                                                    m->feature_queries(),
-                                                    wrapper_block);
+    Supports_Block* mm = SASS_MEMORY_NEW(ctx.mem, Supports_Block,
+                                       m->pstate(),
+                                       m->condition(),
+                                       wrapper_block);
 
     mm->tabs(m->tabs());
 
-    Bubble* bubble = new (ctx.mem) Bubble(mm->pstate(), mm);
+    Bubble* bubble = SASS_MEMORY_NEW(ctx.mem, Bubble, mm->pstate(), mm);
     return bubble;
   }
 
@@ -278,26 +287,28 @@ namespace Sass {
   {
     Ruleset* parent = static_cast<Ruleset*>(shallow_copy(this->parent()));
 
-    Block* bb = new (ctx.mem) Block(parent->block()->pstate());
-    Ruleset* new_rule = new (ctx.mem) Ruleset(parent->pstate(),
-                                              parent->selector(),
-                                              bb);
+    Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, parent->block()->pstate());
+    Ruleset* new_rule = SASS_MEMORY_NEW(ctx.mem, Ruleset,
+                                        parent->pstate(),
+                                        parent->selector(),
+                                        bb);
     new_rule->tabs(parent->tabs());
 
     for (size_t i = 0, L = m->block()->length(); i < L; ++i) {
       *new_rule->block() << (*m->block())[i];
     }
 
-    Block* wrapper_block = new (ctx.mem) Block(m->block()->pstate());
+    Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block()->pstate());
     *wrapper_block << new_rule;
-    Media_Block* mm = new (ctx.mem) Media_Block(m->pstate(),
-                                                m->media_queries(),
-                                                wrapper_block,
-                                                m->selector());
+    Media_Block* mm = SASS_MEMORY_NEW(ctx.mem, Media_Block,
+                                      m->pstate(),
+                                      m->media_queries(),
+                                      wrapper_block,
+                                      0);
 
     mm->tabs(m->tabs());
 
-    Bubble* bubble = new (ctx.mem) Bubble(mm->pstate(), mm);
+    Bubble* bubble = SASS_MEMORY_NEW(ctx.mem, Bubble, mm->pstate(), mm);
 
     return bubble;
   }
@@ -310,7 +321,7 @@ namespace Sass {
   Statement* Cssize::flatten(Statement* s)
   {
     Block* bb = s->block();
-    Block* result = new (ctx.mem) Block(bb->pstate(), 0, bb->is_root());
+    Block* result = SASS_MEMORY_NEW(ctx.mem, Block, bb->pstate(), 0, bb->is_root());
     for (size_t i = 0, L = bb->length(); i < L; ++i) {
       Statement* ss = (*bb)[i];
       if (ss->block()) {
@@ -326,9 +337,9 @@ namespace Sass {
     return result;
   }
 
-  vector<pair<bool, Block*>> Cssize::slice_by_bubble(Statement* b)
+  std::vector<std::pair<bool, Block*>> Cssize::slice_by_bubble(Statement* b)
   {
-    vector<pair<bool, Block*>> results;
+    std::vector<std::pair<bool, Block*>> results;
     for (size_t i = 0, L = b->block()->length(); i < L; ++i) {
       Statement* value = (*b->block())[i];
       bool key = value->statement_type() == Statement::BUBBLE;
@@ -340,9 +351,9 @@ namespace Sass {
       }
       else
       {
-        Block* wrapper_block = new (ctx.mem) Block(value->pstate());
+        Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, value->pstate());
         *wrapper_block << value;
-        results.push_back(make_pair(key, wrapper_block));
+        results.push_back(std::make_pair(key, wrapper_block));
       }
     }
     return results;
@@ -353,32 +364,32 @@ namespace Sass {
     switch (s->statement_type())
     {
       case Statement::RULESET:
-        return new (ctx.mem) Ruleset(*static_cast<Ruleset*>(s));
+        return SASS_MEMORY_NEW(ctx.mem, Ruleset, *static_cast<Ruleset*>(s));
       case Statement::MEDIA:
-        return new (ctx.mem) Media_Block(*static_cast<Media_Block*>(s));
+        return SASS_MEMORY_NEW(ctx.mem, Media_Block, *static_cast<Media_Block*>(s));
       case Statement::BUBBLE:
-        return new (ctx.mem) Bubble(*static_cast<Bubble*>(s));
+        return SASS_MEMORY_NEW(ctx.mem, Bubble, *static_cast<Bubble*>(s));
       case Statement::DIRECTIVE:
-        return new (ctx.mem) At_Rule(*static_cast<At_Rule*>(s));
-      case Statement::FEATURE:
-        return new (ctx.mem) Feature_Block(*static_cast<Feature_Block*>(s));
+        return SASS_MEMORY_NEW(ctx.mem, At_Rule, *static_cast<At_Rule*>(s));
+      case Statement::SUPPORTS:
+        return SASS_MEMORY_NEW(ctx.mem, Supports_Block, *static_cast<Supports_Block*>(s));
       case Statement::ATROOT:
-        return new (ctx.mem) At_Root_Block(*static_cast<At_Root_Block*>(s));
+        return SASS_MEMORY_NEW(ctx.mem, At_Root_Block, *static_cast<At_Root_Block*>(s));
       case Statement::KEYFRAMERULE:
-        return new (ctx.mem) Keyframe_Rule(*static_cast<Keyframe_Rule*>(s));
+        return SASS_MEMORY_NEW(ctx.mem, Keyframe_Rule, *static_cast<Keyframe_Rule*>(s));
       case Statement::NONE:
       default:
         error("unknown internal error; please contact the LibSass maintainers", s->pstate(), backtrace);
-        String_Constant* msg = new (ctx.mem) String_Constant(ParserState("[WARN]"), string("`CSSize` can't clone ") + typeid(*s).name());
-        return new (ctx.mem) Warning(ParserState("[WARN]"), msg);
+        String_Quoted* msg = SASS_MEMORY_NEW(ctx.mem, String_Quoted, ParserState("[WARN]"), std::string("`CSSize` can't clone ") + typeid(*s).name());
+        return SASS_MEMORY_NEW(ctx.mem, Warning, ParserState("[WARN]"), msg);
     }
   }
 
   Statement* Cssize::debubble(Block* children, Statement* parent)
   {
     Has_Block* previous_parent = 0;
-    vector<pair<bool, Block*>> baz = slice_by_bubble(children);
-    Block* result = new (ctx.mem) Block(children->pstate());
+    std::vector<std::pair<bool, Block*>> baz = slice_by_bubble(children);
+    Block* result = SASS_MEMORY_NEW(ctx.mem, Block, children->pstate());
 
     for (size_t i = 0, L = baz.size(); i < L; ++i) {
       bool is_bubble = baz[i].first;
@@ -404,9 +415,10 @@ namespace Sass {
         continue;
       }
 
-      Block* wrapper_block = new (ctx.mem) Block(children->block()->pstate(),
-                                                 children->block()->length(),
-                                                 children->block()->is_root());
+      Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block,
+                                             children->block()->pstate(),
+                                             children->block()->length(),
+                                             children->block()->is_root());
 
       for (size_t j = 0, K = slice->length(); j < K; ++j)
       {
@@ -423,10 +435,9 @@ namespace Sass {
         else
         {
           List* mq = merge_media_queries(static_cast<Media_Block*>(b->node()), static_cast<Media_Block*>(parent));
-          if (mq->length()) {
-            static_cast<Media_Block*>(b->node())->media_queries(mq);
-            ss = b->node();
-          }
+          if (!mq->length()) continue;
+          static_cast<Media_Block*>(b->node())->media_queries(mq);
+          ss = b->node();
         }
 
         if (!ss) continue;
@@ -436,9 +447,10 @@ namespace Sass {
 
         if (!ss) continue;
 
-        Block* bb = new (ctx.mem) Block(children->block()->pstate(),
-                                        children->block()->length(),
-                                        children->block()->is_root());
+        Block* bb = SASS_MEMORY_NEW(ctx.mem, Block,
+                                    children->block()->pstate(),
+                                    children->block()->length(),
+                                    children->block()->is_root());
         *bb << ss->perform(this);
         Statement* wrapper = flatten(bb);
         *wrapper_block << wrapper;
@@ -480,9 +492,10 @@ namespace Sass {
 
   List* Cssize::merge_media_queries(Media_Block* m1, Media_Block* m2)
   {
-    List* qq = new (ctx.mem) List(m1->media_queries()->pstate(),
-                                  m1->media_queries()->length(),
-                                  List::COMMA);
+    List* qq = SASS_MEMORY_NEW(ctx.mem, List,
+                               m1->media_queries()->pstate(),
+                               m1->media_queries()->length(),
+                               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++) {
@@ -502,13 +515,13 @@ namespace Sass {
   {
     To_String to_string(&ctx);
 
-    string type;
-    string mod;
+    std::string type;
+    std::string mod;
 
-    string m1 = string(mq1->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
-    string t1 = mq1->media_type() ? mq1->media_type()->perform(&to_string) : "";
-    string m2 = string(mq2->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
-    string t2 = mq2->media_type() ? mq2->media_type()->perform(&to_string) : "";
+    std::string m1 = std::string(mq1->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
+    std::string t1 = mq1->media_type() ? mq1->media_type()->perform(&to_string) : "";
+    std::string m2 = std::string(mq2->is_restricted() ? "only" : mq1->is_negated() ? "not" : "");
+    std::string t2 = mq2->media_type() ? mq2->media_type()->perform(&to_string) : "";
 
 
     if (t1.empty()) t1 = t2;
@@ -535,13 +548,14 @@ namespace Sass {
       mod = m1.empty() ? m2 : m1;
     }
 
-    Media_Query* mm = new (ctx.mem) Media_Query(
-      mq1->pstate(), 0,
-      mq1->length() + mq2->length(), mod == "not", mod == "only"
-    );
+    Media_Query* mm = SASS_MEMORY_NEW(ctx.mem, Media_Query,
+
+mq1->pstate(), 0,
+mq1->length() + mq2->length(), mod == "not", mod == "only"
+);
 
     if (!type.empty()) {
-      mm->media_type(new (ctx.mem) String_Constant(mq1->pstate(), type));
+      mm->media_type(SASS_MEMORY_NEW(ctx.mem, String_Quoted, mq1->pstate(), type));
     }
 
     *mm += mq2;