sassc 1.7.1 → 1.8.0.pre1

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

@@ -11,15 +11,14 @@
 #include "source_map.hpp"
 
 namespace Sass {
-  using std::ptrdiff_t;
   SourceMap::SourceMap() : current_position(0, 0, 0), file("stdin") { }
-  SourceMap::SourceMap(const string& file) : current_position(0, 0, 0), file(file) { }
+  SourceMap::SourceMap(const std::string& file) : current_position(0, 0, 0), file(file) { }
 
-  string SourceMap::generate_source_map(Context &ctx) {
+  std::string SourceMap::generate_source_map(Context &ctx) {
 
     const bool include_sources = ctx.source_map_contents;
-    const vector<string> includes = ctx.include_links;
-    const vector<const char*> sources = ctx.sources;
+    const std::vector<std::string> includes = ctx.include_links;
+    const std::vector<char*> sources = ctx.sources;
 
     JsonNode* json_srcmap = json_mkobject();
 
@@ -43,17 +42,18 @@ namespace Sass {
     }
     json_append_member(json_srcmap, "sources", json_includes);
 
-    JsonNode *json_contents = json_mkarray();
     if (include_sources) {
+      JsonNode *json_contents = json_mkarray();
       for (size_t i = 0; i < source_index.size(); ++i) {
         const char *content = sources[source_index[i]];
         JsonNode *json_content = json_mkstring(content);
         json_append_element(json_contents, json_content);
       }
+      if (json_contents->children.head)
+        json_append_member(json_srcmap, "sourcesContent", json_contents);
     }
-    json_append_member(json_srcmap, "sourcesContent", json_contents);
 
-    string mappings = serialize_mappings();
+    std::string mappings = serialize_mappings();
     JsonNode *json_mappings = json_mkstring(mappings.c_str());
     json_append_member(json_srcmap, "mappings", json_mappings);
 
@@ -63,14 +63,14 @@ namespace Sass {
     json_append_member(json_srcmap, "names", json_names);
 
     char *str = json_stringify(json_srcmap, "\t");
-    string result = string(str);
+    std::string result = std::string(str);
     free(str);
     json_delete(json_srcmap);
     return result;
   }
 
-  string SourceMap::serialize_mappings() {
-    string result = "";
+  std::string SourceMap::serialize_mappings() {
+    std::string result = "";
 
     size_t previous_generated_line = 0;
     size_t previous_generated_column = 0;
@@ -117,11 +117,11 @@ namespace Sass {
     Offset size(out.smap.current_position);
     for (Mapping mapping : out.smap.mappings) {
       if (mapping.generated_position.line > size.line) {
-        throw(runtime_error("prepend sourcemap has illegal line"));
+        throw(std::runtime_error("prepend sourcemap has illegal line"));
       }
       if (mapping.generated_position.line == size.line) {
         if (mapping.generated_position.column > size.column) {
-          throw(runtime_error("prepend sourcemap has illegal column"));
+          throw(std::runtime_error("prepend sourcemap has illegal column"));
         }
       }
     }

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

@@ -1,6 +1,7 @@
 #ifndef SASS_SOURCE_MAP_H
 #define SASS_SOURCE_MAP_H
 
+#include <string>
 #include <vector>
 
 #include "ast_fwd_decl.hpp"
@@ -12,7 +13,6 @@
 #define VECTOR_UNSHIFT(vec, ins) vec.insert(vec.begin(), ins.begin(), ins.end())
 
 namespace Sass {
-  using std::vector;
 
   class Context;
   class OutputBuffer;
@@ -20,11 +20,11 @@ namespace Sass {
   class SourceMap {
 
   public:
-    vector<size_t> source_index;
+    std::vector<size_t> source_index;
     SourceMap();
-    SourceMap(const string& file);
+    SourceMap(const std::string& file);
 
-    void setFile(const string& str) {
+    void setFile(const std::string& str) {
       file = str;
     }
     void append(const Offset& offset);
@@ -34,17 +34,17 @@ namespace Sass {
     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);
 
   private:
 
-    string serialize_mappings();
+    std::string serialize_mappings();
 
-    vector<Mapping> mappings;
+    std::vector<Mapping> mappings;
     Position current_position;
 public:
-    string file;
+    std::string file;
 private:
     Base64VLQ base64vlq;
   };
@@ -56,7 +56,7 @@ private:
         smap()
       { }
     public:
-      string buffer;
+      std::string buffer;
       SourceMap smap;
   };
 

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

@@ -6,15 +6,14 @@
 #include <vector>
 #include <algorithm>
 #include <iterator>
-#include <iostream>
-#include <sstream>
 
-// using namespace std;
 
+// #include <iostream>
+// #include <sstream>
 // template<typename T>
-// string vector_to_string(vector<T> v)
+// std::string vector_to_string(std::vector<T> v)
 // {
-//   stringstream buffer;
+//   std::stringstream buffer;
 //   buffer << "[";
 
 //   if (!v.empty())
@@ -34,11 +33,11 @@
 // }
 
 // template<typename T>
-// string set_to_string(set<T> v)
+// std::string set_to_string(set<T> v)
 // {
-//   stringstream buffer;
+//   std::stringstream buffer;
 //   buffer << "[";
-//   typename set<T>::iterator i = v.begin();
+//   typename std::set<T>::iterator i = v.begin();
 //   if (!v.empty())
 //   {  buffer << *i; }
 //   else
@@ -56,7 +55,6 @@
 // }
 
 namespace Sass {
-  using namespace std;
 
   template<typename F, typename S, typename T>
   struct triple {
@@ -74,24 +72,24 @@ namespace Sass {
   template<typename K, typename V>
   class Subset_Map {
   private:
-    vector<V> values_;
-    map<K, vector<triple<vector<K>, set<K>, size_t> > > hash_;
+    std::vector<V> values_;
+    std::map<K, std::vector<triple<std::vector<K>, std::set<K>, size_t> > > hash_;
   public:
-    void put(const vector<K>& s, const V& value);
-    vector<pair<V, vector<K> > > get_kv(const vector<K>& s);
-    vector<V> get_v(const vector<K>& s);
+    void put(const std::vector<K>& s, const V& value);
+    std::vector<std::pair<V, std::vector<K> > > get_kv(const std::vector<K>& s);
+    std::vector<V> get_v(const std::vector<K>& s);
     bool empty() { return values_.empty(); }
     void clear() { values_.clear(); hash_.clear(); }
-    const vector<V> values(void) { return values_; }
+    const std::vector<V> values(void) { return values_; }
   };
 
   template<typename K, typename V>
-  void Subset_Map<K, V>::put(const vector<K>& s, const V& value)
+  void Subset_Map<K, V>::put(const std::vector<K>& s, const V& value)
   {
     if (s.empty()) throw "internal error: subset map keys may not be empty";
     size_t index = values_.size();
     values_.push_back(value);
-    set<K> ss;
+    std::set<K> ss;
     for (size_t i = 0, S = s.size(); i < S; ++i)
     { ss.insert(s[i]); }
     for (size_t i = 0, S = s.size(); i < S; ++i)
@@ -102,42 +100,42 @@ namespace Sass {
   }
 
   template<typename K, typename V>
-  vector<pair<V, vector<K> > > Subset_Map<K, V>::get_kv(const vector<K>& s)
+  std::vector<std::pair<V, std::vector<K> > > Subset_Map<K, V>::get_kv(const std::vector<K>& s)
   {
-    vector<K> sorted = s;
+    std::vector<K> sorted = s;
     sort(sorted.begin(), sorted.end());
-    vector<pair<size_t, vector<K> > > indices;
+    std::vector<std::pair<size_t, std::vector<K> > > indices;
     for (size_t i = 0, S = s.size(); i < S; ++i) {
       if (!hash_.count(s[i])) {
         continue;
       }
-      vector<triple<vector<K>, set<K>, size_t> > subsets = hash_[s[i]];
-      // cerr << "length of subsets: " << subsets.size() << endl;
+      std::vector<triple<std::vector<K>, std::set<K>, size_t> > subsets = hash_[s[i]];
+      // std::cerr << "length of subsets: " << subsets.size() << std::endl;
       for (size_t j = 0, T = subsets.size(); j < T; ++j) {
         if (!includes(sorted.begin(), sorted.end(), subsets[j].second.begin(), subsets[j].second.end())) {
-          // cout << vector_to_string(s) << " doesn't include " << set_to_string(subsets[j].second) << endl;
+          // std::cout << vector_to_string(s) << " doesn't include " << set_to_string(subsets[j].second) << std::endl;
           continue;
         }
-        indices.push_back(make_pair(subsets[j].third, subsets[j].first));
-        // cerr << "pushed " << subsets[j].third << " and " << vector_to_string(subsets[j].first) << " onto indices" << endl;
+        indices.push_back(std::make_pair(subsets[j].third, subsets[j].first));
+        // std::cerr << "pushed " << subsets[j].third << " and " << vector_to_string(subsets[j].first) << " onto indices" << std::endl;
       }
     }
     sort(indices.begin(), indices.end());
-    typename vector<pair<size_t, vector<K> > >::iterator indices_end = unique(indices.begin(), indices.end());
+    typename std::vector<std::pair<size_t, std::vector<K> > >::iterator indices_end = unique(indices.begin(), indices.end());
     indices.resize(distance(indices.begin(), indices_end));
 
-    vector<pair<V, vector<K> > > results;
+    std::vector<std::pair<V, std::vector<K> > > results;
     for (size_t i = 0, S = indices.size(); i < S; ++i) {
-      results.push_back(make_pair(values_[indices[i].first], indices[i].second));
+      results.push_back(std::make_pair(values_[indices[i].first], indices[i].second));
     }
     return results;
   }
 
   template<typename K, typename V>
-  vector<V> Subset_Map<K, V>::get_v(const vector<K>& s)
+  std::vector<V> Subset_Map<K, V>::get_v(const std::vector<K>& s)
   {
-    vector<pair<V, vector<K> > > kvs = get_kv(s);
-    vector<V> results;
+    std::vector<std::pair<V, std::vector<K> > > kvs = get_kv(s);
+    std::vector<V> results;
     for (size_t i = 0, S = kvs.size(); i < S; ++i) results.push_back(kvs[i].first);
     return results;
   }

data/ext/libsass/src/to_c.cpp

@@ -0,0 +1,73 @@
+#include "to_c.hpp"
+#include "ast.hpp"
+
+namespace Sass {
+
+  union Sass_Value* To_C::fallback_impl(AST_Node* n)
+  { return sass_make_error("unknown type for C-API"); }
+
+  union Sass_Value* To_C::operator()(Boolean* b)
+  { return sass_make_boolean(b->value()); }
+
+  union Sass_Value* To_C::operator()(Number* n)
+  { return sass_make_number(n->value(), n->unit().c_str()); }
+
+  union Sass_Value* To_C::operator()(Custom_Warning* w)
+  { return sass_make_warning(w->message().c_str()); }
+
+  union Sass_Value* To_C::operator()(Custom_Error* e)
+  { return sass_make_error(e->message().c_str()); }
+
+  union Sass_Value* To_C::operator()(Color* c)
+  { return sass_make_color(c->r(), c->g(), c->b(), c->a()); }
+
+  union Sass_Value* To_C::operator()(String_Constant* s)
+  {
+    if (s->quote_mark()) {
+      return sass_make_qstring(s->value().c_str());
+    } else {
+      return sass_make_string(s->value().c_str());
+    }
+  }
+
+  union Sass_Value* To_C::operator()(String_Quoted* s)
+  { return sass_make_qstring(s->value().c_str()); }
+
+  union Sass_Value* To_C::operator()(List* l)
+  {
+    union Sass_Value* v = sass_make_list(l->length(), l->separator());
+    for (size_t i = 0, L = l->length(); i < L; ++i) {
+      sass_list_set_value(v, i, (*l)[i]->perform(this));
+    }
+    return v;
+  }
+
+  union Sass_Value* To_C::operator()(Map* m)
+  {
+    union Sass_Value* v = sass_make_map(m->length());
+    int i = 0;
+    for (auto key : m->keys()) {
+      sass_map_set_key(v, i, key->perform(this));
+      sass_map_set_value(v, i, m->at(key)->perform(this));
+      i++;
+    }
+    return v;
+  }
+
+  union Sass_Value* To_C::operator()(Arguments* a)
+  {
+    union Sass_Value* v = sass_make_list(a->length(), SASS_COMMA);
+    for (size_t i = 0, L = a->length(); i < L; ++i) {
+      sass_list_set_value(v, i, (*a)[i]->perform(this));
+    }
+    return v;
+  }
+
+  union Sass_Value* To_C::operator()(Argument* a)
+  { return a->value()->perform(this); }
+
+  // not strictly necessary because of the fallback
+  union Sass_Value* To_C::operator()(Null* n)
+  { return sass_make_null(); }
+
+};

data/ext/libsass/src/to_c.hpp

@@ -0,0 +1,41 @@
+#ifndef SASS_TO_C_H
+#define SASS_TO_C_H
+
+#include "ast_fwd_decl.hpp"
+#include "operation.hpp"
+#include "sass/values.h"
+
+namespace Sass {
+
+  class To_C : public Operation_CRTP<union Sass_Value*, To_C> {
+    // import all the class-specific methods and override as desired
+    using Operation<union Sass_Value*>::operator();
+    // override this to define a catch-all
+    union Sass_Value* fallback_impl(AST_Node* n);
+
+  public:
+
+    To_C() { }
+    virtual ~To_C() { }
+
+    union Sass_Value* operator()(Boolean*);
+    union Sass_Value* operator()(Number*);
+    union Sass_Value* operator()(Color*);
+    union Sass_Value* operator()(String_Constant*);
+    union Sass_Value* operator()(String_Quoted*);
+    union Sass_Value* operator()(Custom_Warning*);
+    union Sass_Value* operator()(Custom_Error*);
+    union Sass_Value* operator()(List*);
+    union Sass_Value* operator()(Map*);
+    union Sass_Value* operator()(Null*);
+    union Sass_Value* operator()(Arguments*);
+    union Sass_Value* operator()(Argument*);
+
+    // dispatch to fallback implementation
+    union Sass_Value* fallback(AST_Node* x)
+    { return fallback_impl(x); }
+  };
+
+}
+
+#endif

data/ext/libsass/src/to_string.cpp

@@ -0,0 +1,47 @@
+#include <cmath>
+#include <sstream>
+#include <iomanip>
+#include <iostream>
+
+#include "ast.hpp"
+#include "inspect.hpp"
+#include "context.hpp"
+#include "to_string.hpp"
+
+namespace Sass {
+
+  To_String::To_String(Context* ctx, bool in_declaration)
+  : ctx(ctx), in_declaration(in_declaration) { }
+  To_String::~To_String() { }
+
+  inline std::string To_String::fallback_impl(AST_Node* n)
+  {
+    Emitter emitter(ctx);
+    Inspect i(emitter);
+    i.in_declaration = in_declaration;
+    if (n) n->perform(&i);
+    return i.get_buffer();
+  }
+
+  inline std::string To_String::operator()(String_Schema* s)
+  {
+    std::string acc("");
+    for (size_t i = 0, L = s->length(); i < L; ++i) {
+      acc += s->elements()[i]->perform(this);
+    }
+    return acc;
+  }
+
+  inline std::string To_String::operator()(String_Quoted* s)
+  {
+    return s->value();
+  }
+
+  inline std::string To_String::operator()(String_Constant* s)
+  {
+    return s->value();
+  }
+
+  inline std::string To_String::operator()(Null* n)
+  { return ""; }
+}

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

@@ -6,29 +6,31 @@
 #include "operation.hpp"
 
 namespace Sass {
-  using namespace std;
 
   class Context;
   class Null;
 
-  class To_String : public Operation_CRTP<string, To_String> {
+  class To_String : public Operation_CRTP<std::string, To_String> {
     // import all the class-specific methods and override as desired
-    using Operation<string>::operator();
+    using Operation<std::string>::operator();
     // override this to define a catch-all
-    string fallback_impl(AST_Node* n);
+    std::string fallback_impl(AST_Node* n);
 
     Context* ctx;
     bool in_declaration;
 
   public:
+
     To_String(Context* ctx = 0, bool in_declaration = true);
     virtual ~To_String();
 
-    string operator()(Null* n);
-    string operator()(String_Constant*);
+    std::string operator()(Null* n);
+    std::string operator()(String_Schema*);
+    std::string operator()(String_Quoted*);
+    std::string operator()(String_Constant*);
 
     template <typename U>
-    string fallback(U n) { return fallback_impl(n); }
+    std::string fallback(U n) { return fallback_impl(n); }
   };
 }