sassc 1.7.1 → 1.8.0.pre1

data/ext/libsass/src/util.hpp

@@ -0,0 +1,59 @@
+#ifndef SASS_UTIL_H
+#define SASS_UTIL_H
+
+#include <vector>
+#include <string>
+#include <assert.h>
+#include "ast_fwd_decl.hpp"
+
+#define SASS_ASSERT(cond, msg) assert(cond && msg)
+
+namespace Sass {
+
+  char* sass_strdup(const char* str);
+  double sass_atof(const char* str);
+  const char* safe_str(const char *);
+  void free_string_array(char **);
+  char **copy_strings(const std::vector<std::string>&, char ***, int = 0);
+  std::string string_escape(const std::string& str);
+  std::string string_unescape(const std::string& str);
+  std::string string_eval_escapes(const std::string& str);
+  std::string read_css_string(const std::string& str);
+  std::string evacuate_quotes(const std::string& str);
+  std::string evacuate_escapes(const std::string& str);
+  std::string string_to_output(const std::string& str);
+  std::string comment_to_string(const std::string& text);
+  std::string normalize_wspace(const std::string& str);
+
+  std::string quote(const std::string&, char q = 0, bool keep_linefeed_whitespace = false);
+  std::string unquote(const std::string&, char* q = 0, bool keep_utf8_sequences = false);
+  char detect_best_quotemark(const char* s, char qm = '"');
+
+  bool is_hex_doublet(double n);
+  bool is_color_doublet(double r, double g, double b);
+
+  bool peek_linefeed(const char* start);
+
+  namespace Util {
+
+    std::string rtrim(const std::string& str);
+
+    std::string normalize_underscores(const std::string& str);
+    std::string normalize_decimals(const std::string& str);
+    std::string normalize_sixtuplet(const std::string& col);
+
+    std::string vecJoin(const std::vector<std::string>& vec, const std::string& sep);
+    bool containsAnyPrintableStatements(Block* b);
+
+    bool isPrintable(Ruleset* r, Output_Style style = NESTED);
+    bool isPrintable(Supports_Block* r, Output_Style style = NESTED);
+    bool isPrintable(Media_Block* r, Output_Style style = NESTED);
+    bool isPrintable(Block* b, Output_Style style = NESTED);
+    bool isPrintable(String_Constant* s, Output_Style style = NESTED);
+    bool isPrintable(String_Quoted* s, Output_Style style = NESTED);
+    bool isPrintable(Declaration* d, Output_Style style = NESTED);
+    bool isAscii(const char chr);
+
+  }
+}
+#endif

data/ext/libsass/src/values.cpp

@@ -0,0 +1,137 @@
+#include "sass.h"
+#include "values.hpp"
+
+#include <stdint.h>
+
+namespace Sass {
+
+  // convert value from C++ side to C-API
+  union Sass_Value* ast_node_to_sass_value (const Expression* val)
+  {
+    if (val->concrete_type() == Expression::NUMBER)
+    {
+      const Number* res = dynamic_cast<const Number*>(val);
+      return sass_make_number(res->value(), res->unit().c_str());
+    }
+    else if (val->concrete_type() == Expression::COLOR)
+    {
+      const Color* col = dynamic_cast<const Color*>(val);
+      return sass_make_color(col->r(), col->g(), col->b(), col->a());
+    }
+    else if (val->concrete_type() == Expression::LIST)
+    {
+      const List* l = dynamic_cast<const List*>(val);
+      union Sass_Value* list = sass_make_list(l->size(), l->separator());
+      for (size_t i = 0, L = l->length(); i < L; ++i) {
+        auto val = ast_node_to_sass_value((*l)[i]);
+        sass_list_set_value(list, i, val);
+      }
+      return list;
+    }
+    else if (val->concrete_type() == Expression::MAP)
+    {
+      const Map* m = dynamic_cast<const Map*>(val);
+      union Sass_Value* map = sass_make_map(m->length());
+      size_t i = 0; for (auto key : m->keys()) {
+        sass_map_set_key(map, i, ast_node_to_sass_value(key));
+        sass_map_set_value(map, i, ast_node_to_sass_value(m->at(key)));
+        ++ i;
+      }
+      return map;
+    }
+    else if (val->concrete_type() == Expression::NULL_VAL)
+    {
+      return sass_make_null();
+    }
+    else if (val->concrete_type() == Expression::BOOLEAN)
+    {
+      const Boolean* res = dynamic_cast<const Boolean*>(val);
+      return sass_make_boolean(res->value());
+    }
+    else if (val->concrete_type() == Expression::STRING)
+    {
+      if (const String_Quoted* qstr = dynamic_cast<const String_Quoted*>(val))
+      {
+        return sass_make_qstring(qstr->value().c_str());
+      }
+      else if (const String_Constant* cstr = dynamic_cast<const String_Constant*>(val))
+      {
+        return sass_make_string(cstr->value().c_str());
+      }
+    }
+    return sass_make_error("unknown sass value type");
+  }
+
+  // convert value from C-API to C++ side
+  Value* sass_value_to_ast_node (Memory_Manager& mem, const union Sass_Value* val)
+  {
+    switch (sass_value_get_tag(val)) {
+      case SASS_NUMBER:
+        return SASS_MEMORY_NEW(mem, Number,
+                               ParserState("[C-VALUE]"),
+                               sass_number_get_value(val),
+                               sass_number_get_unit(val));
+      break;
+      case SASS_BOOLEAN:
+        return SASS_MEMORY_NEW(mem, Boolean,
+                               ParserState("[C-VALUE]"),
+                               sass_boolean_get_value(val));
+      break;
+      case SASS_COLOR:
+        return SASS_MEMORY_NEW(mem, Color,
+                               ParserState("[C-VALUE]"),
+                               sass_color_get_r(val),
+                               sass_color_get_g(val),
+                               sass_color_get_b(val),
+                               sass_color_get_a(val));
+      break;
+      case SASS_STRING:
+        if (sass_string_is_quoted(val)) {
+          return SASS_MEMORY_NEW(mem, String_Quoted,
+                                 ParserState("[C-VALUE]"),
+                                 sass_string_get_value(val));
+        } else {
+          return SASS_MEMORY_NEW(mem, String_Constant,
+                                 ParserState("[C-VALUE]"),
+                                 sass_string_get_value(val));
+        }
+      break;
+      case SASS_LIST: {
+        List* l = SASS_MEMORY_NEW(mem, List,
+                                  ParserState("[C-VALUE]"),
+                                  sass_list_get_length(val),
+                                  sass_list_get_separator(val));
+        for (size_t i = 0, L = sass_list_get_length(val); i < L; ++i) {
+          *l << sass_value_to_ast_node(mem, sass_list_get_value(val, i));
+        }
+        return l;
+      }
+      break;
+      case SASS_MAP: {
+        Map* m = SASS_MEMORY_NEW(mem, Map, ParserState("[C-VALUE]"));
+        for (size_t i = 0, L = sass_map_get_length(val); i < L; ++i) {
+          *m << std::make_pair(
+            sass_value_to_ast_node(mem, sass_map_get_key(val, i)),
+            sass_value_to_ast_node(mem, sass_map_get_value(val, i)));
+        }
+        return m;
+      }
+      break;
+      case SASS_NULL:
+        return SASS_MEMORY_NEW(mem, Null, ParserState("[C-VALUE]"));
+      break;
+      case SASS_ERROR:
+        return SASS_MEMORY_NEW(mem, Custom_Error,
+                               ParserState("[C-VALUE]"),
+                               sass_error_get_message(val));
+      break;
+      case SASS_WARNING:
+        return SASS_MEMORY_NEW(mem, Custom_Warning,
+                               ParserState("[C-VALUE]"),
+                               sass_warning_get_message(val));
+      break;
+    }
+    return 0;
+  }
+
+}

data/ext/libsass/src/values.hpp

@@ -0,0 +1,12 @@
+#ifndef SASS_VALUES_H
+#define SASS_VALUES_H
+
+#include "ast.hpp"
+
+namespace Sass {
+
+  union Sass_Value* ast_node_to_sass_value (const Expression* val);
+  Value* sass_value_to_ast_node (Memory_Manager& mem, const union Sass_Value* val);
+
+}
+#endif

data/ext/libsass/test/test_node.cpp

@@ -10,16 +10,16 @@
 
 
 namespace Sass {
-  
+
   Context ctx = Context::Data();
-  
+
   To_String to_string;
-  
-  
+
+
   const char* const ROUNDTRIP_TESTS[] = {
     NULL,
-  	"~",
-		"CMPD",
+    "~",
+    "CMPD",
     "~ CMPD",
     "CMPD >",
     "> > CMPD",
@@ -29,15 +29,15 @@ namespace Sass {
     "+ CMPD1 CMPD2 ~ CMPD3 + CMPD4 > CMPD5 > ~"
   };
 
-  
-  
-  static Complex_Selector* createComplexSelector(string src) {
-    string temp(src);
+
+
+  static Complex_Selector* createComplexSelector(std::string src) {
+    std::string temp(src);
     temp += ";";
-    return (*Parser::from_c_str(temp.c_str(), ctx, "", Position()).parse_selector_group())[0];
+    return (*Parser::from_c_str(temp.c_str(), ctx, "", Position()).parse_selector_list())[0];
   }
-  
-  
+
+
   void roundtripTest(const char* toTest) {
 
     // Create the initial selector
@@ -46,53 +46,53 @@ namespace Sass {
     if (toTest) {
       pOrigSelector = createComplexSelector(toTest);
     }
-    
-    string expected(pOrigSelector ? pOrigSelector->perform(&to_string) : "NULL");
-  
-    
+
+    std::string expected(pOrigSelector ? pOrigSelector->perform(&to_string) : "NULL");
+
+
     // Roundtrip the selector into a node and back
-    
+
     Node node = complexSelectorToNode(pOrigSelector, ctx);
-    
-    stringstream nodeStringStream;
+
+    std::stringstream nodeStringStream;
     nodeStringStream << node;
-    string nodeString = nodeStringStream.str();
+    std::string nodeString = nodeStringStream.str();
     cout << "ASNODE: " << node << endl;
-    
+
     Complex_Selector* pNewSelector = nodeToComplexSelector(node, ctx);
-    
+
     // Show the result
 
-    string result(pNewSelector ? pNewSelector->perform(&to_string) : "NULL");
-    
+    std::string result(pNewSelector ? pNewSelector->perform(&to_string) : "NULL");
+
     cout << "SELECTOR: " << expected << endl;
     cout << "NEW SELECTOR:   " << result << endl;
 
-    
+
     // Test that they are equal using the equality operator
-    
+
     assert( (!pOrigSelector && !pNewSelector ) || (pOrigSelector && pNewSelector) );
     if (pOrigSelector) {
-	    assert( *pOrigSelector == *pNewSelector );
+      assert( *pOrigSelector == *pNewSelector );
     }
 
-    
+
     // Test that they are equal by comparing the string versions of the selectors
 
     assert(expected == result);
-    
+
   }
 
 
-	int main() {
+  int main() {
     for (int index = 0; index < STATIC_ARRAY_SIZE(ROUNDTRIP_TESTS); index++) {
       const char* const toTest = ROUNDTRIP_TESTS[index];
       cout << "\nINPUT STRING: " << (toTest ? toTest : "NULL") << endl;
       roundtripTest(toTest);
     }
-    
+
     cout << "\nTesting Done.\n";
   }
 
 
-}
+}

data/ext/libsass/test/test_paths.cpp

@@ -1,11 +1,10 @@
 #include <iostream>
 #include "../paths.hpp"
 
-using namespace std;
 using namespace Sass;
 
 template<typename T>
-vector<T>& operator<<(vector<T>& v, const T& e)
+std::vector<T>& operator<<(std::vector<T>& v, const T& e)
 {
   v.push_back(e);
   return v;
@@ -13,17 +12,17 @@ vector<T>& operator<<(vector<T>& v, const T& e)
 
 int main()
 {
-  vector<int> v1, v2, v3;
+  std::vector<int> v1, v2, v3;
   v1 << 1 << 2;
   v2 << 3;
   v3 << 4 << 5 << 6;
 
-  vector<vector<int> > ss;
+  std::vector<std::vector<int> > ss;
   ss << v1 << v2 << v3;
 
-  vector<vector<int> > ps = paths(ss);
+  std::vector<std::vector<int> > ps = paths(ss);
   for (size_t i = 0, S = ps.size(); i < S; ++i) {
-    cout << vector_to_string(ps[i]) << endl;
+    std::cout << vector_to_string(ps[i]) << std::endl;
   }
   return 0;
 }

data/ext/libsass/test/test_selector_difference.cpp

@@ -5,18 +5,17 @@
 #include <string>
 #include <iostream>
 
-using namespace std;
 using namespace Sass;
 
 Context ctx = Context::Data();
 To_String to_string;
 
-Compound_Selector* selector(string src)
-{ return Parser::from_c_str(src.c_str(), ctx, "", Position()).parse_simple_selector_sequence(); }
+Compound_Selector* selector(std::string src)
+{ return Parser::from_c_str(src.c_str(), ctx, "", Position()).parse_compound_selector(); }
 
-void diff(string s, string t)
+void diff(std::string s, std::string t)
 {
-  cout << s << " - " << t << " = " << selector(s + ";")->minus(selector(t + ";"), ctx)->perform(&to_string) << endl;
+  std::cout << s << " - " << t << " = " << selector(s + ";")->minus(selector(t + ";"), ctx)->perform(&to_string) << std::endl;
 }
 
 int main()

data/ext/libsass/test/test_specificity.cpp

@@ -5,17 +5,16 @@
 #include <string>
 #include <iostream>
 
-using namespace std;
 using namespace Sass;
 
 Context ctx = Context::Data();
 To_String to_string;
 
-Selector* selector(string src)
-{ return Parser::from_c_str(src.c_str(), ctx, "", Position()).parse_selector_group(); }
+Selector* selector(std::string src)
+{ return Parser::from_c_str(src.c_str(), ctx, "", Position()).parse_selector_list(); }
 
-void spec(string sel)
-{ cout << sel << "\t::\t" << selector(sel + ";")->specificity() << endl; }
+void spec(std::string sel)
+{ std::cout << sel << "\t::\t" << selector(sel + ";")->specificity() << std::endl; }
 
 int main()
 {

data/ext/libsass/test/test_subset_map.cpp

@@ -3,171 +3,171 @@
 #include <assert.h>
 #include "../subset_map.hpp"
 
-Subset_Map<string, string> ssm;
+Subset_Map<std::string, std::string> ssm;
 
-string toString(vector<string> v);
-string toString(vector<pair<string, vector<string>>> v);
-void assertEqual(string sExpected, string sResult);
+string toString(std::vector<std::string> v);
+string toString(std::vector<std::pair<std::string, std::vector<std::string>>> v);
+void assertEqual(string std::sExpected, std::string sResult);
 
 void setup() {
   ssm.clear();
   
   //@ssm[Set[1, 2]] = "Foo"
-  vector<string> s1;
+  std::vector<std::string> s1;
   s1.push_back("1");
   s1.push_back("2");
   ssm.put(s1, "Foo");
   
   //@ssm[Set["fizz", "fazz"]] = "Bar"
-  vector<string> s2;
+  std::vector<std::string> s2;
   s2.push_back("fizz");
   s2.push_back("fazz");
   ssm.put(s2, "Bar");
   
   //@ssm[Set[:foo, :bar]] = "Baz"
-  vector<string> s3;
+  std::vector<std::string> s3;
   s3.push_back(":foo");
   s3.push_back(":bar");
   ssm.put(s3, "Baz");
   
   //@ssm[Set[:foo, :bar, :baz]] = "Bang"
-  vector<string> s4;
+  std::vector<std::string> s4;
   s4.push_back(":foo");
   s4.push_back(":bar");
   s4.push_back(":baz");
   ssm.put(s4, "Bang");
   
   //@ssm[Set[:bip, :bop, :blip]] = "Qux"
-  vector<string> s5;
+  std::vector<std::string> s5;
   s5.push_back(":bip");
   s5.push_back(":bop");
   s5.push_back(":blip");
   ssm.put(s5, "Qux");
   
   //@ssm[Set[:bip, :bop]] = "Thram"
-  vector<string> s6;
+  std::vector<std::string> s6;
   s6.push_back(":bip");
   s6.push_back(":bop");
   ssm.put(s6, "Thram");
 }
 
 void testEqualKeys() {
-  cout << "testEqualKeys" << endl;
+  std::cout << "testEqualKeys" << std::endl;
   
   //assert_equal [["Foo", Set[1, 2]]], @ssm.get(Set[1, 2])
-  vector<string> k1;
+  std::vector<std::string> k1;
   k1.push_back("1");
   k1.push_back("2");
   assertEqual("[[Foo, Set[1, 2]]]", toString(ssm.get_kv(k1)));
   
   //assert_equal [["Bar", Set["fizz", "fazz"]]], @ssm.get(Set["fizz", "fazz"])
-  vector<string> k2;
+  std::vector<std::string> k2;
   k2.push_back("fizz");
   k2.push_back("fazz");
   assertEqual("[[Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k2)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 
 void testSubsetKeys() {
-  cout << "testSubsetKeys" << endl;
+  std::cout << "testSubsetKeys" << std::endl;
   
   //assert_equal [["Foo", Set[1, 2]]], @ssm.get(Set[1, 2, "fuzz"])
-  vector<string> k1;
+  std::vector<std::string> k1;
   k1.push_back("1");
   k1.push_back("2");
   k1.push_back("fuzz");
   assertEqual("[[Foo, Set[1, 2]]]", toString(ssm.get_kv(k1)));
   
   //assert_equal [["Bar", Set["fizz", "fazz"]]], @ssm.get(Set["fizz", "fazz", 3])
-  vector<string> k2;
+  std::vector<std::string> k2;
   k2.push_back("fizz");
   k2.push_back("fazz");
   k2.push_back("3");
   assertEqual("[[Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k2)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 
 void testSupersetKeys() {
-  cout << "testSupersetKeys" << endl;
+  std::cout << "testSupersetKeys" << std::endl;
   
   //assert_equal [], @ssm.get(Set[1])
-  vector<string> k1;
+  std::vector<std::string> k1;
   k1.push_back("1");
   assertEqual("[]", toString(ssm.get_kv(k1)));
   
   //assert_equal [], @ssm.get(Set[2])
-  vector<string> k2;
+  std::vector<std::string> k2;
   k2.push_back("2");
   assertEqual("[]", toString(ssm.get_kv(k2)));
   
   //assert_equal [], @ssm.get(Set["fizz"])
-  vector<string> k3;
+  std::vector<std::string> k3;
   k3.push_back("fizz");
   assertEqual("[]", toString(ssm.get_kv(k3)));
   
   //assert_equal [], @ssm.get(Set["fazz"])
-  vector<string> k4;
+  std::vector<std::string> k4;
   k4.push_back("fazz");
   assertEqual("[]", toString(ssm.get_kv(k4)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 
 void testDisjointKeys() {
-  cout << "testDisjointKeys" << endl;
+  std::cout << "testDisjointKeys" << std::endl;
   
   //assert_equal [], @ssm.get(Set[3, 4])
-  vector<string> k1;
+  std::vector<std::string> k1;
   k1.push_back("3");
   k1.push_back("4");
   assertEqual("[]", toString(ssm.get_kv(k1)));
   
   //assert_equal [], @ssm.get(Set["fuzz", "frizz"])
-  vector<string> k2;
+  std::vector<std::string> k2;
   k2.push_back("fuzz");
   k2.push_back("frizz");
   assertEqual("[]", toString(ssm.get_kv(k2)));
   
   //assert_equal [], @ssm.get(Set["gran", 15])
-  vector<string> k3;
+  std::vector<std::string> k3;
   k3.push_back("gran");
   k3.push_back("15");
   assertEqual("[]", toString(ssm.get_kv(k3)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 
 void testSemiDisjointKeys() {
-  cout << "testSemiDisjointKeys" << endl;
+  std::cout << "testSemiDisjointKeys" << std::endl;
   
   //assert_equal [], @ssm.get(Set[2, 3])
-  vector<string> k1;
+  std::vector<std::string> k1;
   k1.push_back("2");
   k1.push_back("3");
   assertEqual("[]", toString(ssm.get_kv(k1)));
   
   //assert_equal [], @ssm.get(Set["fizz", "fuzz"])
-  vector<string> k2;
+  std::vector<std::string> k2;
   k2.push_back("fizz");
   k2.push_back("fuzz");
   assertEqual("[]", toString(ssm.get_kv(k2)));
   
   //assert_equal [], @ssm.get(Set[1, "fazz"])
-  vector<string> k3;
+  std::vector<std::string> k3;
   k3.push_back("1");
   k3.push_back("fazz");
   assertEqual("[]", toString(ssm.get_kv(k3)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 
 void testEmptyKeySet() {
-  cout << "testEmptyKeySet" << endl;
+  std::cout << "testEmptyKeySet" << std::endl;
   
   //assert_raises(ArgumentError) {@ssm[Set[]] = "Fail"}
-  vector<string> s1;
+  std::vector<std::string> s1;
   try {
     ssm.put(s1, "Fail");
   }
@@ -177,19 +177,19 @@ void testEmptyKeySet() {
 }
 
 void testEmptyKeyGet() {
-  cout << "testEmptyKeyGet" << endl;
+  std::cout << "testEmptyKeyGet" << std::endl;
   
   //assert_equal [], @ssm.get(Set[])
-  vector<string> k1;
+  std::vector<std::string> k1;
   assertEqual("[]", toString(ssm.get_kv(k1)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 void testMultipleSubsets() {
-  cout << "testMultipleSubsets" << endl;
+  std::cout << "testMultipleSubsets" << std::endl;
   
   //assert_equal [["Foo", Set[1, 2]], ["Bar", Set["fizz", "fazz"]]], @ssm.get(Set[1, 2, "fizz", "fazz"])
-  vector<string> k1;
+  std::vector<std::string> k1;
   k1.push_back("1");
   k1.push_back("2");
   k1.push_back("fizz");
@@ -197,7 +197,7 @@ void testMultipleSubsets() {
   assertEqual("[[Foo, Set[1, 2]], [Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k1)));
   
   //assert_equal [["Foo", Set[1, 2]], ["Bar", Set["fizz", "fazz"]]], @ssm.get(Set[1, 2, 3, "fizz", "fazz", "fuzz"])
-  vector<string> k2;
+  std::vector<std::string> k2;
   k2.push_back("1");
   k2.push_back("2");
   k2.push_back("3");
@@ -207,80 +207,80 @@ void testMultipleSubsets() {
   assertEqual("[[Foo, Set[1, 2]], [Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k2)));
   
   //assert_equal [["Baz", Set[:foo, :bar]]], @ssm.get(Set[:foo, :bar])
-  vector<string> k3;
+  std::vector<std::string> k3;
   k3.push_back(":foo");
   k3.push_back(":bar");
   assertEqual("[[Baz, Set[:foo, :bar]]]", toString(ssm.get_kv(k3)));
   
   //assert_equal [["Baz", Set[:foo, :bar]], ["Bang", Set[:foo, :bar, :baz]]], @ssm.get(Set[:foo, :bar, :baz])
-  vector<string> k4;
+  std::vector<std::string> k4;
   k4.push_back(":foo");
   k4.push_back(":bar");
   k4.push_back(":baz");
   assertEqual("[[Baz, Set[:foo, :bar]], [Bang, Set[:foo, :bar, :baz]]]", toString(ssm.get_kv(k4)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 void testBracketBracket() {
-  cout << "testBracketBracket" << endl;
+  std::cout << "testBracketBracket" << std::endl;
   
   //assert_equal ["Foo"], @ssm[Set[1, 2, "fuzz"]]
-  vector<string> k1;
+  std::vector<std::string> k1;
   k1.push_back("1");
   k1.push_back("2");
   k1.push_back("fuzz");
   assertEqual("[Foo]", toString(ssm.get_v(k1)));
   
   //assert_equal ["Baz", "Bang"], @ssm[Set[:foo, :bar, :baz]]
-  vector<string> k2;
+  std::vector<std::string> k2;
   k2.push_back(":foo");
   k2.push_back(":bar");
   k2.push_back(":baz");
   assertEqual("[Baz, Bang]", toString(ssm.get_v(k2)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 
 void testKeyOrder() {
-  cout << "testEqualKeys" << endl;
+  std::cout << "testEqualKeys" << std::endl;
   
   //assert_equal [["Foo", Set[1, 2]]], @ssm.get(Set[2, 1])
-  vector<string> k1;
+  std::vector<std::string> k1;
   k1.push_back("2");
   k1.push_back("1");
   assertEqual("[[Foo, Set[1, 2]]]", toString(ssm.get_kv(k1)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 
 void testOrderPreserved() {
-  cout << "testOrderPreserved" << endl;
+  std::cout << "testOrderPreserved" << std::endl;
   //@ssm[Set[10, 11, 12]] = 1
-  vector<string> s1;
+  std::vector<std::string> s1;
   s1.push_back("10");
   s1.push_back("11");
   s1.push_back("12");
   ssm.put(s1, "1");
   
   //@ssm[Set[10, 11]] = 2
-  vector<string> s2;
+  std::vector<std::string> s2;
   s2.push_back("10");
   s2.push_back("11");
   ssm.put(s2, "2");
   
   //@ssm[Set[11]] = 3
-  vector<string> s3;
+  std::vector<std::string> s3;
   s3.push_back("11");
   ssm.put(s3, "3");
   
   //@ssm[Set[11, 12]] = 4
-  vector<string> s4;
+  std::vector<std::string> s4;
   s4.push_back("11");
   s4.push_back("12");
   ssm.put(s4, "4");
   
   //@ssm[Set[9, 10, 11, 12, 13]] = 5
-  vector<string> s5;
+  std::vector<std::string> s5;
   s5.push_back("9");
   s5.push_back("10");
   s5.push_back("11");
@@ -289,13 +289,13 @@ void testOrderPreserved() {
   ssm.put(s5, "5");
   
   //@ssm[Set[10, 13]] = 6
-  vector<string> s6;
+  std::vector<std::string> s6;
   s6.push_back("10");
   s6.push_back("13");
   ssm.put(s6, "6");
   
   //assert_equal([[1, Set[10, 11, 12]], [2, Set[10, 11]], [3, Set[11]], [4, Set[11, 12]], [5, Set[9, 10, 11, 12, 13]], [6, Set[10, 13]]], @ssm.get(Set[9, 10, 11, 12, 13]))
-  vector<string> k1;
+  std::vector<std::string> k1;
   k1.push_back("9");
   k1.push_back("10");
   k1.push_back("11");
@@ -303,36 +303,36 @@ void testOrderPreserved() {
   k1.push_back("13");
   assertEqual("[[1, Set[10, 11, 12]], [2, Set[10, 11]], [3, Set[11]], [4, Set[11, 12]], [5, Set[9, 10, 11, 12, 13]], [6, Set[10, 13]]]", toString(ssm.get_kv(k1)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 void testMultipleEqualValues() {
-  cout << "testMultipleEqualValues" << endl;
+  std::cout << "testMultipleEqualValues" << std::endl;
   //@ssm[Set[11, 12]] = 1
-  vector<string> s1;
+  std::vector<std::string> s1;
   s1.push_back("11");
   s1.push_back("12");
   ssm.put(s1, "1");
   
   //@ssm[Set[12, 13]] = 2
-  vector<string> s2;
+  std::vector<std::string> s2;
   s2.push_back("12");
   s2.push_back("13");
   ssm.put(s2, "2");
   
   //@ssm[Set[13, 14]] = 1
-  vector<string> s3;
+  std::vector<std::string> s3;
   s3.push_back("13");
   s3.push_back("14");
   ssm.put(s3, "1");
   
   //@ssm[Set[14, 15]] = 1
-  vector<string> s4;
+  std::vector<std::string> s4;
   s4.push_back("14");
   s4.push_back("15");
   ssm.put(s4, "1");
   
   //assert_equal([[1, Set[11, 12]], [2, Set[12, 13]], [1, Set[13, 14]], [1, Set[14, 15]]], @ssm.get(Set[11, 12, 13, 14, 15]))
-  vector<string> k1;
+  std::vector<std::string> k1;
   k1.push_back("11");
   k1.push_back("12");
   k1.push_back("13");
@@ -340,20 +340,20 @@ void testMultipleEqualValues() {
   k1.push_back("15");
   assertEqual("[[1, Set[11, 12]], [2, Set[12, 13]], [1, Set[13, 14]], [1, Set[14, 15]]]", toString(ssm.get_kv(k1)));
   
-  cout << endl;
+  std::cout << std::endl;
 }
 
 int main()
 {
-  vector<string> s1;
+  std::vector<std::string> s1;
   s1.push_back("1");
   s1.push_back("2");
   
-  vector<string> s2;
+  std::vector<std::string> s2;
   s2.push_back("2");
   s2.push_back("3");
   
-  vector<string> s3;
+  std::vector<std::string> s3;
   s3.push_back("3");
   s3.push_back("4");
   
@@ -361,16 +361,16 @@ int main()
   ssm.put(s2, "value2");
   ssm.put(s3, "value3");
   
-  vector<string> s4;
+  std::vector<std::string> s4;
   s4.push_back("1");
   s4.push_back("2");
   s4.push_back("3");
   
-  vector<pair<string, vector<string> > > fetched(ssm.get_kv(s4));
+  std::vector<std::pair<string, std::vector<std::string> > > fetched(ssm.get_kv(s4));
   
-  cout << "PRINTING RESULTS:" << endl;
+  std::cout << "PRINTING RESULTS:" << std::endl;
   for (size_t i = 0, S = fetched.size(); i < S; ++i) {
-    cout << fetched[i].first << endl;
+    std::cout << fetched[i].first << std::endl;
   }
   
   Subset_Map<string, string> ssm2;
@@ -378,33 +378,33 @@ int main()
   ssm2.put(s2, "bar");
   ssm2.put(s4, "hux");
   
-  vector<pair<string, vector<string> > > fetched2(ssm2.get_kv(s4));
+  std::vector<std::pair<string, std::vector<std::string> > > fetched2(ssm2.get_kv(s4));
   
-  cout << endl << "PRINTING RESULTS:" << endl;
+  std::cout << std::endl << "PRINTING RESULTS:" << std::endl;
   for (size_t i = 0, S = fetched2.size(); i < S; ++i) {
-    cout << fetched2[i].first << endl;
+    std::cout << fetched2[i].first << std::endl;
   }
   
-  cout << "TRYING ON A SELECTOR-LIKE OBJECT" << endl;
+  std::cout << "TRYING ON A SELECTOR-LIKE OBJECT" << std::endl;
   
   Subset_Map<string, string> sel_ssm;
-  vector<string> target;
+  std::vector<std::string> target;
   target.push_back("desk");
   target.push_back(".wood");
   
-  vector<string> actual;
+  std::vector<std::string> actual;
   actual.push_back("desk");
   actual.push_back(".wood");
   actual.push_back(".mine");
   
   sel_ssm.put(target, "has-aquarium");
-  vector<pair<string, vector<string> > > fetched3(sel_ssm.get_kv(actual));
-  cout << "RESULTS:" << endl;
+  std::vector<std::pair<string, std::vector<std::string> > > fetched3(sel_ssm.get_kv(actual));
+  std::cout << "RESULTS:" << std::endl;
   for (size_t i = 0, S = fetched3.size(); i < S; ++i) {
-    cout << fetched3[i].first << endl;
+    std::cout << fetched3[i].first << std::endl;
   }
   
-  cout << endl;
+  std::cout << std::endl;
   
   // BEGIN PORTED RUBY TESTS FROM /test/sass/util/subset_map_test.rb
   
@@ -429,9 +429,9 @@ int main()
   return 0;
 }
 
-string toString(vector<pair<string, vector<string>>> v)
+string toString(std::vector<std::pair<string, std::vector<std::string>>> v)
 {
-  stringstream buffer;
+  std::stringstream buffer;
   buffer << "[";
   for (size_t i = 0, S = v.size(); i < S; ++i) {
     buffer << "[" << v[i].first;
@@ -451,9 +451,9 @@ string toString(vector<pair<string, vector<string>>> v)
   return buffer.str();
 }
 
-string toString(vector<string> v)
+string toString(std::vector<std::string> v)
 {
-  stringstream buffer;
+  std::stringstream buffer;
   buffer << "[";
   for (size_t i = 0, S = v.size(); i < S; ++i) {
     buffer << v[i];
@@ -466,7 +466,7 @@ string toString(vector<string> v)
 }
 
 void assertEqual(string sExpected, string sResult) {
-  cout << "Expected: " << sExpected << endl;
-  cout << "Result:   " << sResult << endl;
+  std::cout << "Expected: " << sExpected << std::endl;
+  std::cout << "Result:   " << sResult << std::endl;
   assert(sExpected == sResult);
 }