sassc 1.7.1 → 1.8.0.pre1

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

@@ -5,7 +5,6 @@
 #include "utf8_string.hpp"
 
 namespace Sass {
-  using namespace std;
 
   Emitter::Emitter(Context* ctx)
   : wbuf(),
@@ -23,7 +22,7 @@ namespace Sass {
   { }
 
   // return buffer as string
-  string Emitter::get_buffer(void)
+  std::string Emitter::get_buffer(void)
   {
     return wbuf.buffer;
   }
@@ -38,10 +37,10 @@ namespace Sass {
   void Emitter::add_source_index(size_t idx)
   { wbuf.smap.source_index.push_back(idx); }
 
-  string Emitter::generate_source_map(Context &ctx)
+  std::string Emitter::generate_source_map(Context &ctx)
   { return wbuf.smap.generate_source_map(ctx); }
 
-  void Emitter::set_filename(const string& str)
+  void Emitter::set_filename(const std::string& str)
   { wbuf.smap.file = str; }
 
   void Emitter::add_open_mapping(AST_Node* node)
@@ -67,7 +66,7 @@ namespace Sass {
   {
     // check the schedule
     if (scheduled_linefeed) {
-      string linefeeds = "";
+      std::string linefeeds = "";
 
       for (size_t i = 0; i < scheduled_linefeed; i++)
         linefeeds += ctx ? ctx->linefeed : "\n";
@@ -76,7 +75,7 @@ namespace Sass {
       append_string(linefeeds);
 
     } else if (scheduled_space) {
-      string spaces(scheduled_space, ' ');
+      std::string spaces(scheduled_space, ' ');
       scheduled_space = 0;
       append_string(spaces);
     }
@@ -94,21 +93,21 @@ namespace Sass {
   }
 
   // prepend some text or token to the buffer
-  void Emitter::prepend_string(const string& text)
+  void Emitter::prepend_string(const std::string& text)
   {
     wbuf.smap.prepend(Offset(text));
     wbuf.buffer = text + wbuf.buffer;
   }
 
   // append some text or token to the buffer
-  void Emitter::append_string(const string& text)
+  void Emitter::append_string(const std::string& text)
   {
     // write space/lf
     flush_schedules();
 
     if (in_comment && output_style() == COMPACT) {
       // unescape comment nodes
-      string out = comment_to_string(text);
+      std::string out = comment_to_string(text);
       // add to buffer
       wbuf.buffer += out;
       // account for data in source-maps
@@ -122,7 +121,7 @@ namespace Sass {
   }
 
   // append some white-space only text
-  void Emitter::append_wspace(const string& text)
+  void Emitter::append_wspace(const std::string& text)
   {
     if (text.empty()) return;
     if (peek_linefeed(text.c_str())) {
@@ -133,7 +132,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 string& text, AST_Node* node)
+  void Emitter::append_token(const std::string& text, AST_Node* node)
   {
     flush_schedules();
     add_open_mapping(node);
@@ -149,7 +148,7 @@ namespace Sass {
     if (output_style() == COMPACT) return;
     if (scheduled_linefeed && indentation)
       scheduled_linefeed = 1;
-    string indent = "";
+    std::string indent = "";
     for (size_t i = 0; i < indentation; i++)
       indent += ctx ? ctx->indent : "  ";
     append_string(indent);
@@ -171,7 +170,7 @@ namespace Sass {
 
   void Emitter::append_comma_separator()
   {
-    scheduled_space = 0;
+    // scheduled_space = 0;
     append_string(",");
     append_optional_space();
   }
@@ -227,6 +226,7 @@ namespace Sass {
 
   void Emitter::append_scope_opener(AST_Node* node)
   {
+    scheduled_linefeed = 0;
     append_optional_space();
     flush_schedules();
     if (node) add_open_mapping(node);

data/ext/libsass/{emitter.hpp → src/emitter.hpp}

@@ -7,26 +7,25 @@
 
 namespace Sass {
   class Context;
-  using namespace std;
 
   class Emitter {
 
     public:
       Emitter(Context* ctx);
-      virtual ~Emitter() { };
+      virtual ~Emitter() { }
 
     protected:
       OutputBuffer wbuf;
     public:
-      const string buffer(void) { return wbuf.buffer; }
+      const std::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 string& str);
+      void set_filename(const std::string& str);
       void add_open_mapping(AST_Node* node);
       void add_close_mapping(AST_Node* node);
-      string generate_source_map(Context &ctx);
+      std::string generate_source_map(Context &ctx);
       ParserState remap(const ParserState& pstate);
 
     public:
@@ -50,8 +49,8 @@ namespace Sass {
       bool in_comma_array;
 
     public:
-      // return buffer as string
-      string get_buffer(void);
+      // return buffer as std::string
+      std::string get_buffer(void);
       // flush scheduled space/linefeed
       Output_Style output_style(void);
       // add outstanding linefeed
@@ -59,15 +58,15 @@ namespace Sass {
       // flush scheduled space/linefeed
       void flush_schedules(void);
       // prepend some text or token to the buffer
-      void prepend_string(const string& text);
+      void prepend_string(const std::string& text);
       void prepend_output(const OutputBuffer& out);
       // append some text or token to the buffer
-      void append_string(const string& text);
+      void append_string(const std::string& text);
       // append some white-space only text
-      void append_wspace(const string& text);
+      void append_wspace(const std::string& text);
       // append some text or token to the buffer
       // this adds source-mappings for node start and end
-      void append_token(const string& text, AST_Node* node);
+      void append_token(const std::string& text, AST_Node* node);
 
     public: // syntax sugar
       void append_indentation();

data/ext/libsass/src/environment.cpp

@@ -0,0 +1,184 @@
+#include "ast.hpp"
+#include "environment.hpp"
+
+namespace Sass {
+
+  template <typename T>
+  Environment<T>::Environment() : local_frame_(std::map<std::string, T>()), parent_(0) { }
+  template <typename T>
+  Environment<T>::Environment(Environment<T>* env) : local_frame_(std::map<std::string, T>()), parent_(env) { }
+  template <typename T>
+  Environment<T>::Environment(Environment<T>& env) : local_frame_(std::map<std::string, T>()), parent_(&env) { }
+
+  // link parent to create a stack
+  template <typename T>
+  void Environment<T>::link(Environment& env) { parent_ = &env; }
+  template <typename T>
+  void Environment<T>::link(Environment* env) { parent_ = env; }
+
+  // this is used to find the global frame
+  // which is the second last on the stack
+  template <typename T>
+  bool Environment<T>::is_lexical() const
+  {
+    return !! parent_ && parent_->parent_;
+  }
+
+  // only match the real root scope
+  // there is still a parent around
+  // not sure what it is actually use for
+  // I guess we store functions etc. there
+  template <typename T>
+  bool Environment<T>::is_global() const
+  {
+    return parent_ && ! parent_->parent_;
+  }
+
+  template <typename T>
+  std::map<std::string, T>& Environment<T>::local_frame() {
+    return local_frame_;
+  }
+
+  template <typename T>
+  bool Environment<T>::has_local(const std::string& key) const
+  { return local_frame_.find(key) != local_frame_.end(); }
+
+  template <typename T>
+  T& Environment<T>::get_local(const std::string& key)
+  { return local_frame_[key]; }
+
+  template <typename T>
+  void Environment<T>::set_local(const std::string& key, T val)
+  {
+    local_frame_[key] = val;
+  }
+
+  template <typename T>
+  void Environment<T>::del_local(const std::string& key)
+  { local_frame_.erase(key); }
+
+  template <typename T>
+  Environment<T>* Environment<T>::global_env()
+  {
+    Environment* cur = this;
+    while (cur->is_lexical()) {
+      cur = cur->parent_;
+    }
+    return cur;
+  }
+
+  template <typename T>
+  bool Environment<T>::has_global(const std::string& key)
+  { return global_env()->has(key); }
+
+  template <typename T>
+  T& Environment<T>::get_global(const std::string& key)
+  { return (*global_env())[key]; }
+
+  template <typename T>
+  void Environment<T>::set_global(const std::string& key, T val)
+  {
+    global_env()->local_frame_[key] = val;
+  }
+
+  template <typename T>
+  void Environment<T>::del_global(const std::string& key)
+  { global_env()->local_frame_.erase(key); }
+
+  template <typename T>
+  Environment<T>* Environment<T>::lexical_env(const std::string& key)
+  {
+    Environment* cur = this;
+    while (cur) {
+      if (cur->has_local(key)) {
+        return cur;
+      }
+      cur = cur->parent_;
+    }
+    return this;
+  }
+
+  // see if we have a lexical variable
+  // 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
+  {
+    auto cur = this;
+    while (cur->is_lexical()) {
+      if (cur->has_local(key)) return true;
+      cur = cur->parent_;
+    }
+    return false;
+  }
+
+  // see if we have a lexical we could update
+  // 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, T val)
+  {
+    auto cur = this;
+    while (cur->is_lexical()) {
+      if (cur->has_local(key)) {
+        cur->set_local(key, val);
+        return;
+      }
+      cur = cur->parent_;
+    }
+    set_local(key, val);
+  }
+
+  // look on the full stack for key
+  // include all scopes available
+  template <typename T>
+  bool Environment<T>::has(const std::string& key) const
+  {
+    auto cur = this;
+    while (cur) {
+      if (cur->has_local(key)) {
+        return true;
+      }
+      cur = cur->parent_;
+    }
+    return false;
+  }
+
+  // use array access for getter and setter functions
+  template <typename T>
+  T& Environment<T>::operator[](const std::string& key)
+  {
+    auto cur = this;
+    while (cur) {
+      if (cur->has_local(key)) {
+        return cur->get_local(key);
+      }
+      cur = cur->parent_;
+    }
+    return get_local(key);
+  }
+
+  #ifdef DEBUG
+  template <typename T>
+  size_t Environment<T>::print(std::string prefix)
+  {
+    size_t indent = 0;
+    if (parent_) indent = parent_->print(prefix) + 1;
+    std::cerr << prefix << std::string(indent, ' ') << "== " << this << std::endl;
+    for (typename std::map<std::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* val = dynamic_cast<Value*>(i->second))
+        { std::cerr << " : " << val->to_string(true, 5); }
+        std::cerr << std::endl;
+      }
+    }
+    return indent ;
+  }
+  #endif
+
+  // compile implementation for AST_Node
+  template class Environment<AST_Node*>;
+
+}
+

data/ext/libsass/src/environment.hpp

@@ -0,0 +1,92 @@
+#ifndef SASS_ENVIRONMENT_H
+#define SASS_ENVIRONMENT_H
+
+#include <string>
+#include <map>
+
+#include "ast_fwd_decl.hpp"
+#include "ast_def_macros.hpp"
+#include "memory_manager.hpp"
+
+namespace Sass {
+
+  template <typename T>
+  class Environment {
+    // TODO: test with map
+    std::map<std::string, T> local_frame_;
+    ADD_PROPERTY(Environment*, parent)
+
+  public:
+    Memory_Manager mem;
+    Environment();
+    Environment(Environment* env);
+    Environment(Environment& env);
+
+    // link parent to create a stack
+    void link(Environment& env);
+    void link(Environment* env);
+
+    // this is used to find the global frame
+    // which is the second last on the stack
+    bool is_lexical() const;
+
+    // only match the real root scope
+    // there is still a parent around
+    // not sure what it is actually use for
+    // I guess we store functions etc. there
+    bool is_global() const;
+
+    // scope operates on the current frame
+
+    std::map<std::string, T>& local_frame();
+
+    bool has_local(const std::string& key) const;
+
+    T& get_local(const std::string& key);
+
+    // set variable on the current frame
+    void set_local(const std::string& key, T val);
+
+    void del_local(const std::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);
+
+    bool has_global(const std::string& key);
+
+    T& get_global(const std::string& key);
+
+    // set a variable on the global frame
+    void set_global(const std::string& key, T val);
+
+    void del_global(const std::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;
+
+    // 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);
+
+    // look on the full stack for key
+    // include all scopes available
+    bool has(const std::string& key) const;
+
+    // use array access for getter and setter functions
+    T& operator[](const std::string& key);
+
+    #ifdef DEBUG
+    size_t print(std::string prefix = "");
+    #endif
+
+  };
+}
+
+#endif