sassc 2.0.0 → 2.4.0

data/ext/libsass/src/emitter.cpp

@@ -1,9 +1,9 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-#include "util.hpp"
-#include "context.hpp"
-#include "output.hpp"
 #include "emitter.hpp"
-#include "utf8_string.hpp"
+#include "util_string.hpp"
+#include "util.hpp"
 
 namespace Sass {
 
@@ -26,7 +26,7 @@ namespace Sass {
   { }
 
   // return buffer as string
-  std::string Emitter::get_buffer(void)
+  sass::string Emitter::get_buffer(void)
   {
     return wbuf.buffer;
   }
@@ -41,19 +41,19 @@ namespace Sass {
   void Emitter::add_source_index(size_t idx)
   { wbuf.smap.source_index.push_back(idx); }
 
-  std::string Emitter::render_srcmap(Context &ctx)
+  sass::string Emitter::render_srcmap(Context &ctx)
   { return wbuf.smap.render_srcmap(ctx); }
 
-  void Emitter::set_filename(const std::string& str)
+  void Emitter::set_filename(const sass::string& str)
   { wbuf.smap.file = str; }
 
-  void Emitter::schedule_mapping(const AST_Node_Ptr node)
+  void Emitter::schedule_mapping(const AST_Node* node)
   { scheduled_mapping = node; }
-  void Emitter::add_open_mapping(const AST_Node_Ptr node)
+  void Emitter::add_open_mapping(const AST_Node* node)
   { wbuf.smap.add_open_mapping(node); }
-  void Emitter::add_close_mapping(const AST_Node_Ptr node)
+  void Emitter::add_close_mapping(const AST_Node* node)
   { wbuf.smap.add_close_mapping(node); }
-  ParserState Emitter::remap(const ParserState& pstate)
+  SourceSpan Emitter::remap(const SourceSpan& pstate)
   { return wbuf.smap.remap(pstate); }
 
   // MAIN BUFFER MANIPULATION
@@ -74,7 +74,7 @@ namespace Sass {
   {
     // check the schedule
     if (scheduled_linefeed) {
-      std::string linefeeds = "";
+      sass::string linefeeds = "";
 
       for (size_t i = 0; i < scheduled_linefeed; i++)
         linefeeds += opt.linefeed;
@@ -83,7 +83,7 @@ namespace Sass {
       append_string(linefeeds);
 
     } else if (scheduled_space) {
-      std::string spaces(scheduled_space, ' ');
+      sass::string spaces(scheduled_space, ' ');
       scheduled_space = 0;
       append_string(spaces);
     }
@@ -101,7 +101,7 @@ namespace Sass {
   }
 
   // prepend some text or token to the buffer
-  void Emitter::prepend_string(const std::string& text)
+  void Emitter::prepend_string(const sass::string& text)
   {
     // do not adjust mappings for utf8 bom
     // seems they are not counted in any UA
@@ -128,19 +128,19 @@ namespace Sass {
   }
 
   // append some text or token to the buffer
-  void Emitter::append_string(const std::string& text)
+  void Emitter::append_string(const sass::string& text)
   {
 
     // write space/lf
     flush_schedules();
 
-    if (in_comment && output_style() == COMPACT) {
-      // unescape comment nodes
-      std::string out = comment_to_string(text);
-      // add to buffer
-      wbuf.buffer += out;
-      // account for data in source-maps
+    if (in_comment) {
+      sass::string out = Util::normalize_newlines(text);
+      if (output_style() == COMPACT) {
+        out = comment_to_compact_string(out);
+      }
       wbuf.smap.append(Offset(out));
+      wbuf.buffer += std::move(out);
     } else {
       // add to buffer
       wbuf.buffer += text;
@@ -150,7 +150,7 @@ namespace Sass {
   }
 
   // append some white-space only text
-  void Emitter::append_wspace(const std::string& text)
+  void Emitter::append_wspace(const sass::string& text)
   {
     if (text.empty()) return;
     if (peek_linefeed(text.c_str())) {
@@ -161,7 +161,7 @@ namespace Sass {
 
   // append some text or token to the buffer
   // this adds source-mappings for node start and end
-  void Emitter::append_token(const std::string& text, const AST_Node_Ptr node)
+  void Emitter::append_token(const sass::string& text, const AST_Node* node)
   {
     flush_schedules();
     add_open_mapping(node);
@@ -184,7 +184,7 @@ namespace Sass {
     if (in_declaration && in_comma_array) return;
     if (scheduled_linefeed && indentation)
       scheduled_linefeed = 1;
-    std::string indent = "";
+    sass::string indent = "";
     for (size_t i = 0; i < indentation; i++)
       indent += opt.indent;
     append_string(indent);
@@ -263,7 +263,7 @@ namespace Sass {
     }
   }
 
-  void Emitter::append_scope_opener(AST_Node_Ptr node)
+  void Emitter::append_scope_opener(AST_Node* node)
   {
     scheduled_linefeed = 0;
     append_optional_space();
@@ -274,7 +274,7 @@ namespace Sass {
     // append_optional_space();
     ++ indentation;
   }
-  void Emitter::append_scope_closer(AST_Node_Ptr node)
+  void Emitter::append_scope_closer(AST_Node* node)
   {
     -- indentation;
     scheduled_linefeed = 0;

data/ext/libsass/src/emitter.hpp

@@ -1,8 +1,10 @@
 #ifndef SASS_EMITTER_H
 #define SASS_EMITTER_H
 
-#include <string>
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "sass/base.h"
 #include "source_map.hpp"
 #include "ast_fwd_decl.hpp"
@@ -19,17 +21,17 @@ namespace Sass {
     protected:
       OutputBuffer wbuf;
     public:
-      const std::string& buffer(void) { return wbuf.buffer; }
+      const sass::string& buffer(void) { return wbuf.buffer; }
       const SourceMap smap(void) { return wbuf.smap; }
       const OutputBuffer output(void) { return wbuf; }
       // proxy methods for source maps
       void add_source_index(size_t idx);
-      void set_filename(const std::string& str);
-      void add_open_mapping(const AST_Node_Ptr node);
-      void add_close_mapping(const AST_Node_Ptr node);
-      void schedule_mapping(const AST_Node_Ptr node);
-      std::string render_srcmap(Context &ctx);
-      ParserState remap(const ParserState& pstate);
+      void set_filename(const sass::string& str);
+      void add_open_mapping(const AST_Node* node);
+      void add_close_mapping(const AST_Node* node);
+      void schedule_mapping(const AST_Node* node);
+      sass::string render_srcmap(Context &ctx);
+      SourceSpan remap(const SourceSpan& pstate);
 
     public:
       struct Sass_Output_Options& opt;
@@ -37,8 +39,8 @@ namespace Sass {
       size_t scheduled_space;
       size_t scheduled_linefeed;
       bool scheduled_delimiter;
-      AST_Node_Ptr scheduled_crutch;
-      AST_Node_Ptr scheduled_mapping;
+      const AST_Node* scheduled_crutch;
+      const AST_Node* scheduled_mapping;
 
     public:
       // output strings different in custom css properties
@@ -56,8 +58,8 @@ namespace Sass {
       bool in_comma_array;
 
     public:
-      // return buffer as std::string
-      std::string get_buffer(void);
+      // return buffer as sass::string
+      sass::string get_buffer(void);
       // flush scheduled space/linefeed
       Sass_Output_Style output_style(void) const;
       // add outstanding linefeed
@@ -65,17 +67,17 @@ namespace Sass {
       // flush scheduled space/linefeed
       void flush_schedules(void);
       // prepend some text or token to the buffer
-      void prepend_string(const std::string& text);
+      void prepend_string(const sass::string& text);
       void prepend_output(const OutputBuffer& out);
       // append some text or token to the buffer
-      void append_string(const std::string& text);
+      void append_string(const sass::string& text);
       // append a single character to buffer
       void append_char(const char chr);
       // append some white-space only text
-      void append_wspace(const std::string& text);
+      void append_wspace(const sass::string& text);
       // append some text or token to the buffer
       // this adds source-mappings for node start and end
-      void append_token(const std::string& text, const AST_Node_Ptr node);
+      void append_token(const sass::string& text, const AST_Node* node);
       // query last appended character
       char last_char();
 
@@ -86,8 +88,8 @@ namespace Sass {
       void append_special_linefeed(void);
       void append_optional_linefeed(void);
       void append_mandatory_linefeed(void);
-      void append_scope_opener(AST_Node_Ptr node = 0);
-      void append_scope_closer(AST_Node_Ptr node = 0);
+      void append_scope_opener(AST_Node* node = 0);
+      void append_scope_closer(AST_Node* node = 0);
       void append_comma_separator(void);
       void append_colon_separator(void);
       void append_delimiter(void);

data/ext/libsass/src/environment.cpp

@@ -6,17 +6,17 @@ namespace Sass {
 
   template <typename T>
   Environment<T>::Environment(bool is_shadow)
-  : local_frame_(environment_map<std::string, T>()),
+  : local_frame_(environment_map<sass::string, T>()),
     parent_(0), is_shadow_(false)
   { }
   template <typename T>
   Environment<T>::Environment(Environment<T>* env, bool is_shadow)
-  : local_frame_(environment_map<std::string, T>()),
+  : local_frame_(environment_map<sass::string, T>()),
     parent_(env), is_shadow_(is_shadow)
   { }
   template <typename T>
   Environment<T>::Environment(Environment<T>& env, bool is_shadow)
-  : local_frame_(environment_map<std::string, T>()),
+  : local_frame_(environment_map<sass::string, T>()),
     parent_(&env), is_shadow_(is_shadow)
   { }
 
@@ -45,16 +45,16 @@ namespace Sass {
   }
 
   template <typename T>
-  environment_map<std::string, T>& Environment<T>::local_frame() {
+  environment_map<sass::string, T>& Environment<T>::local_frame() {
     return local_frame_;
   }
 
   template <typename T>
-  bool Environment<T>::has_local(const std::string& key) const
+  bool Environment<T>::has_local(const sass::string& key) const
   { return local_frame_.find(key) != local_frame_.end(); }
 
   template <typename T> EnvResult
-  Environment<T>::find_local(const std::string& key)
+  Environment<T>::find_local(const sass::string& key)
   {
     auto end = local_frame_.end();
     auto it = local_frame_.find(key);
@@ -62,22 +62,22 @@ namespace Sass {
   }
 
   template <typename T>
-  T& Environment<T>::get_local(const std::string& key)
+  T& Environment<T>::get_local(const sass::string& key)
   { return local_frame_[key]; }
 
   template <typename T>
-  void Environment<T>::set_local(const std::string& key, const T& val)
+  void Environment<T>::set_local(const sass::string& key, const T& val)
   {
     local_frame_[key] = val;
   }
   template <typename T>
-  void Environment<T>::set_local(const std::string& key, T&& val)
+  void Environment<T>::set_local(const sass::string& key, T&& val)
   {
     local_frame_[key] = val;
   }
 
   template <typename T>
-  void Environment<T>::del_local(const std::string& key)
+  void Environment<T>::del_local(const sass::string& key)
   { local_frame_.erase(key); }
 
   template <typename T>
@@ -91,30 +91,30 @@ namespace Sass {
   }
 
   template <typename T>
-  bool Environment<T>::has_global(const std::string& key)
+  bool Environment<T>::has_global(const sass::string& key)
   { return global_env()->has(key); }
 
   template <typename T>
-  T& Environment<T>::get_global(const std::string& key)
+  T& Environment<T>::get_global(const sass::string& key)
   { return (*global_env())[key]; }
 
   template <typename T>
-  void Environment<T>::set_global(const std::string& key, const T& val)
+  void Environment<T>::set_global(const sass::string& key, const T& val)
   {
     global_env()->local_frame_[key] = val;
   }
   template <typename T>
-  void Environment<T>::set_global(const std::string& key, T&& val)
+  void Environment<T>::set_global(const sass::string& key, T&& val)
   {
     global_env()->local_frame_[key] = val;
   }
 
   template <typename T>
-  void Environment<T>::del_global(const std::string& key)
+  void Environment<T>::del_global(const sass::string& key)
   { global_env()->local_frame_.erase(key); }
 
   template <typename T>
-  Environment<T>* Environment<T>::lexical_env(const std::string& key)
+  Environment<T>* Environment<T>::lexical_env(const sass::string& key)
   {
     Environment* cur = this;
     while (cur) {
@@ -130,7 +130,7 @@ namespace Sass {
   // move down the stack but stop before we
   // reach the global frame (is not included)
   template <typename T>
-  bool Environment<T>::has_lexical(const std::string& key) const
+  bool Environment<T>::has_lexical(const sass::string& key) const
   {
     auto cur = this;
     while (cur->is_lexical()) {
@@ -144,7 +144,7 @@ namespace Sass {
   // either update already existing lexical value
   // or if flag is set, we create one if no lexical found
   template <typename T>
-  void Environment<T>::set_lexical(const std::string& key, const T& val)
+  void Environment<T>::set_lexical(const sass::string& key, const T& val)
   {
     Environment<T>* cur = this;
     bool shadow = false;
@@ -161,7 +161,7 @@ namespace Sass {
   }
   // this one moves the value
   template <typename T>
-  void Environment<T>::set_lexical(const std::string& key, T&& val)
+  void Environment<T>::set_lexical(const sass::string& key, T&& val)
   {
     Environment<T>* cur = this;
     bool shadow = false;
@@ -180,7 +180,7 @@ namespace Sass {
   // look on the full stack for key
   // include all scopes available
   template <typename T>
-  bool Environment<T>::has(const std::string& key) const
+  bool Environment<T>::has(const sass::string& key) const
   {
     auto cur = this;
     while (cur) {
@@ -195,7 +195,7 @@ namespace Sass {
   // look on the full stack for key
   // include all scopes available
   template <typename T> EnvResult
-  Environment<T>::find(const std::string& key)
+  Environment<T>::find(const sass::string& key)
   {
     auto cur = this;
     while (true) {
@@ -208,7 +208,21 @@ namespace Sass {
 
   // use array access for getter and setter functions
   template <typename T>
-  T& Environment<T>::operator[](const std::string& key)
+  T& Environment<T>::get(const sass::string& key)
+  {
+    auto cur = this;
+    while (cur) {
+      if (cur->has_local(key)) {
+        return cur->get_local(key);
+      }
+      cur = cur->parent_;
+    }
+    return get_local(key);
+  }
+
+  // use array access for getter and setter functions
+  template <typename T>
+  T& Environment<T>::operator[](const sass::string& key)
   {
     auto cur = this;
     while (cur) {
@@ -222,15 +236,15 @@ namespace Sass {
 /*
   #ifdef DEBUG
   template <typename T>
-  size_t Environment<T>::print(std::string prefix)
+  size_t Environment<T>::print(sass::string prefix)
   {
     size_t indent = 0;
     if (parent_) indent = parent_->print(prefix) + 1;
-    std::cerr << prefix << std::string(indent, ' ') << "== " << this << std::endl;
-    for (typename environment_map<std::string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
+    std::cerr << prefix << sass::string(indent, ' ') << "== " << this << std::endl;
+    for (typename environment_map<sass::string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
       if (!ends_with(i->first, "[f]") && !ends_with(i->first, "[f]4") && !ends_with(i->first, "[f]2")) {
-        std::cerr << prefix << std::string(indent, ' ') << i->first << " " << i->second;
-        if (Value_Ptr val = Cast<Value>(i->second))
+        std::cerr << prefix << sass::string(indent, ' ') << i->first << " " << i->second;
+        if (Value* val = Cast<Value>(i->second))
         { std::cerr << " : " << val->to_string(); }
         std::cerr << std::endl;
       }

data/ext/libsass/src/environment.hpp

@@ -1,13 +1,19 @@
 #ifndef SASS_ENVIRONMENT_H
 #define SASS_ENVIRONMENT_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <map>
 #include <string>
 #include "ast_fwd_decl.hpp"
 #include "ast_def_macros.hpp"
 
 namespace Sass {
 
-  typedef environment_map<std::string, AST_Node_Obj>::iterator EnvIter;
+  // this defeats the whole purpose of environment being templatable!!
+  typedef environment_map<sass::string, AST_Node_Obj>::iterator EnvIter;
 
   class EnvResult {
     public:
@@ -21,7 +27,7 @@ namespace Sass {
   template <typename T>
   class Environment {
     // TODO: test with map
-    environment_map<std::string, T> local_frame_;
+    environment_map<sass::string, T> local_frame_;
     ADD_PROPERTY(Environment*, parent)
     ADD_PROPERTY(bool, is_shadow)
 
@@ -46,67 +52,72 @@ namespace Sass {
 
     // scope operates on the current frame
 
-    environment_map<std::string, T>& local_frame();
+    environment_map<sass::string, T>& local_frame();
 
-    bool has_local(const std::string& key) const;
+    bool has_local(const sass::string& key) const;
 
-    EnvResult find_local(const std::string& key);
+    EnvResult find_local(const sass::string& key);
 
-    T& get_local(const std::string& key);
+    T& get_local(const sass::string& key);
 
     // set variable on the current frame
-    void set_local(const std::string& key, const T& val);
-    void set_local(const std::string& key, T&& val);
+    void set_local(const sass::string& key, const T& val);
+    void set_local(const sass::string& key, T&& val);
 
-    void del_local(const std::string& key);
+    void del_local(const sass::string& key);
 
     // global operates on the global frame
     // which is the second last on the stack
     Environment* global_env();
     // get the env where the variable already exists
     // if it does not yet exist, we return current env
-    Environment* lexical_env(const std::string& key);
+    Environment* lexical_env(const sass::string& key);
 
-    bool has_global(const std::string& key);
+    bool has_global(const sass::string& key);
 
-    T& get_global(const std::string& key);
+    T& get_global(const sass::string& key);
 
     // set a variable on the global frame
-    void set_global(const std::string& key, const T& val);
-    void set_global(const std::string& key, T&& val);
+    void set_global(const sass::string& key, const T& val);
+    void set_global(const sass::string& key, T&& val);
 
-    void del_global(const std::string& key);
+    void del_global(const sass::string& key);
 
     // see if we have a lexical variable
     // move down the stack but stop before we
     // reach the global frame (is not included)
-    bool has_lexical(const std::string& key) const;
+    bool has_lexical(const sass::string& key) const;
 
     // see if we have a lexical we could update
     // either update already existing lexical value
     // or we create a new one on the current frame
-    void set_lexical(const std::string& key, T&& val);
-    void set_lexical(const std::string& key, const T& val);
+    void set_lexical(const sass::string& key, T&& val);
+    void set_lexical(const sass::string& key, const T& val);
+
+    // look on the full stack for key
+    // include all scopes available
+    bool has(const sass::string& key) const;
 
     // look on the full stack for key
     // include all scopes available
-    bool has(const std::string& key) const;
+    T& get(const sass::string& key);
 
     // look on the full stack for key
     // include all scopes available
-    EnvResult find(const std::string& key);
+    EnvResult find(const sass::string& key);
 
     // use array access for getter and setter functions
-    T& operator[](const std::string& key);
+    T& operator[](const sass::string& key);
 
     #ifdef DEBUG
-    size_t print(std::string prefix = "");
+    size_t print(sass::string prefix = "");
     #endif
 
   };
 
   // define typedef for our use case
   typedef Environment<AST_Node_Obj> Env;
+  typedef sass::vector<Env*> EnvStack;
 
 }