sassc 0.0.1

data/ext/libsass/json.hpp

@@ -0,0 +1,117 @@
+/*
+  Copyright (C) 2011 Joseph A. Adams (joeyadams3.14159@gmail.com)
+  All rights reserved.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef CCAN_JSON_H
+#define CCAN_JSON_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef enum {
+  JSON_NULL,
+  JSON_BOOL,
+  JSON_STRING,
+  JSON_NUMBER,
+  JSON_ARRAY,
+  JSON_OBJECT,
+} JsonTag;
+
+typedef struct JsonNode JsonNode;
+
+struct JsonNode
+{
+  /* only if parent is an object or array (NULL otherwise) */
+  JsonNode *parent;
+  JsonNode *prev, *next;
+  
+  /* only if parent is an object (NULL otherwise) */
+  char *key; /* Must be valid UTF-8. */
+  
+  JsonTag tag;
+  union {
+    /* JSON_BOOL */
+    bool bool_;
+    
+    /* JSON_STRING */
+    char *string_; /* Must be valid UTF-8. */
+    
+    /* JSON_NUMBER */
+    double number_;
+    
+    /* JSON_ARRAY */
+    /* JSON_OBJECT */
+    struct {
+      JsonNode *head, *tail;
+    } children;
+  };
+};
+
+/*** Encoding, decoding, and validation ***/
+
+JsonNode   *json_decode         (const char *json);
+char       *json_encode         (const JsonNode *node);
+char       *json_encode_string  (const char *str);
+char       *json_stringify      (const JsonNode *node, const char *space);
+void        json_delete         (JsonNode *node);
+
+bool        json_validate       (const char *json);
+
+/*** Lookup and traversal ***/
+
+JsonNode   *json_find_element   (JsonNode *array, int index);
+JsonNode   *json_find_member    (JsonNode *object, const char *key);
+
+JsonNode   *json_first_child    (const JsonNode *node);
+
+#define json_foreach(i, object_or_array)            \
+  for ((i) = json_first_child(object_or_array);   \
+     (i) != NULL;                               \
+     (i) = (i)->next)
+
+/*** Construction and manipulation ***/
+
+JsonNode *json_mknull(void);
+JsonNode *json_mkbool(bool b);
+JsonNode *json_mkstring(const char *s);
+JsonNode *json_mknumber(double n);
+JsonNode *json_mkarray(void);
+JsonNode *json_mkobject(void);
+
+void json_append_element(JsonNode *array, JsonNode *element);
+void json_prepend_element(JsonNode *array, JsonNode *element);
+void json_append_member(JsonNode *object, const char *key, JsonNode *value);
+void json_prepend_member(JsonNode *object, const char *key, JsonNode *value);
+
+void json_remove_from_parent(JsonNode *node);
+
+/*** Debugging ***/
+
+/*
+ * Look for structure and encoding problems in a JsonNode or its descendents.
+ *
+ * If a problem is detected, return false, writing a description of the problem
+ * to errmsg (unless errmsg is NULL).
+ */
+bool json_check(const JsonNode *node, char errmsg[256]);
+
+#endif

data/ext/libsass/kwd_arg_macros.hpp

@@ -0,0 +1,23 @@
+// Example usage:
+// KWD_ARG_SET(Args) {
+//   KWD_ARG(Args, string, foo);
+//   KWD_ARG(Args, int, bar);
+//   ...
+// };
+//
+// ... and later ...
+//
+// something(Args().foo("hey").bar(3));
+
+#define KWD_ARG_SET(set_name) class set_name
+
+#define KWD_ARG(set_name, type, name) \
+private: \
+  type name##_; \
+public: \
+  set_name& name(type name##__) { \
+    name##_ = name##__; \
+    return *this; \
+  } \
+  type name() { return name##_; } \
+private:

data/ext/libsass/mapping.hpp

@@ -0,0 +1,17 @@
+#define SASS_MAPPING
+
+#ifndef SASS_POSITION
+#include "position.hpp"
+#endif
+
+namespace Sass {
+
+  struct Mapping {
+    Position original_position;
+    Position generated_position;
+
+    Mapping(const Position& original_position, const Position& generated_position)
+    : original_position(original_position), generated_position(generated_position) { }
+  };
+
+}

data/ext/libsass/memory_manager.hpp

@@ -0,0 +1,54 @@
+#define SASS_MEMORY_MANAGER
+
+#include <vector>
+#include <iostream>
+using namespace std;
+
+namespace Sass {
+  /////////////////////////////////////////////////////////////////////////////
+  // A class for tracking allocations of AST_Node objects. The intended usage
+  // is something like: Some_Node* n = new (mem_mgr) Some_Node(...);
+  // Then, at the end of the program, the memory manager will delete all of the
+  // allocated nodes that have been passed to it.
+  // In the future, this class may implement a custom allocator.
+  /////////////////////////////////////////////////////////////////////////////
+  template <typename T>
+  class Memory_Manager {
+    vector<T*> nodes;
+
+  public:
+    Memory_Manager(size_t size = 0) : nodes(vector<T*>())
+    { nodes.reserve(size); }
+
+    ~Memory_Manager()
+    {
+      for (size_t i = 0, S = nodes.size(); i < S; ++i) {
+        // cout << "deleting " << typeid(*nodes[i]).name() << endl;
+        delete nodes[i];
+      }
+    }
+
+    T* operator()(T* np)
+    {
+      nodes.push_back(np);
+      // cout << "registering " << typeid(*np).name() << endl;
+      return np;
+    }
+
+    void remove(T* np)
+    {
+      nodes.erase(find(nodes.begin(), nodes.end(), np));
+    }
+  };
+}
+
+template <typename T>
+inline void* operator new(size_t size, Sass::Memory_Manager<T>& mem_mgr)
+{ return mem_mgr(static_cast<T*>(operator new(size))); }
+
+template <typename T>
+inline void operator delete(void *np, Sass::Memory_Manager<T>& mem_mgr)
+{
+  mem_mgr.remove(reinterpret_cast<T*>(np));
+  operator delete(np);
+}

data/ext/libsass/node.cpp

@@ -0,0 +1,251 @@
+#include "node.hpp"
+#include "to_string.hpp"
+#include "context.hpp"
+#include "parser.hpp"
+
+namespace Sass {
+
+
+  Node Node::createCombinator(const Complex_Selector::Combinator& combinator) {
+    NodeDequePtr null;
+    return Node(COMBINATOR, combinator, NULL /*pSelector*/, null /*pCollection*/);
+  }
+
+    
+  Node Node::createSelector(Complex_Selector* pSelector, Context& ctx) {
+    NodeDequePtr null;
+
+    Complex_Selector* pStripped = pSelector->clone(ctx);
+    pStripped->tail(NULL);
+    pStripped->combinator(Complex_Selector::ANCESTOR_OF);
+    
+    return Node(SELECTOR, Complex_Selector::ANCESTOR_OF, pStripped, null /*pCollection*/);
+  }
+
+    
+  Node Node::createCollection() {
+    NodeDequePtr pEmptyCollection = make_shared<NodeDeque>();
+    return Node(COLLECTION, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pEmptyCollection);
+  }
+
+    
+  Node Node::createCollection(const NodeDeque& values) {
+    NodeDequePtr pShallowCopiedCollection = make_shared<NodeDeque>(values);
+    return Node(COLLECTION, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pShallowCopiedCollection);
+  }
+
+    
+  Node Node::createNil() {
+    NodeDequePtr null;
+    return Node(NIL, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, null /*pCollection*/);
+  }
+
+  
+  Node::Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector* pSelector, NodeDequePtr& pCollection) :
+  	mType(type),
+    mCombinator(combinator),
+    mpSelector(pSelector),
+    mpCollection(pCollection) {}
+
+  
+  Node Node::clone(Context& ctx) const {
+    NodeDequePtr pNewCollection = make_shared<NodeDeque>();
+    if (mpCollection) {
+      for (NodeDeque::iterator iter = mpCollection->begin(), iterEnd = mpCollection->end(); iter != iterEnd; iter++) {
+        Node& toClone = *iter;
+        pNewCollection->push_back(toClone.clone(ctx));
+      }
+    }
+    
+    return Node(mType, mCombinator, mpSelector ? mpSelector->clone(ctx) : NULL, pNewCollection);
+  }
+  
+  
+  bool Node::contains(const Node& potentialChild, bool simpleSelectorOrderDependent) const {
+  	bool found = false;
+    
+    for (NodeDeque::iterator iter = mpCollection->begin(), iterEnd = mpCollection->end(); iter != iterEnd; iter++) {
+      Node& toTest = *iter;
+
+      if (nodesEqual(toTest, potentialChild, simpleSelectorOrderDependent)) {
+        found = true;
+        break;
+      }
+    }
+
+    return found;
+  }
+  
+
+  bool Node::operator==(const Node& rhs) const {
+  	return nodesEqual(*this, rhs, true /*simpleSelectorOrderDependent*/);
+  }
+  
+
+  bool nodesEqual(const Node& lhs, const Node& rhs, bool simpleSelectorOrderDependent) {
+    if (lhs.type() != rhs.type()) {
+      return false;
+    }
+    
+    if (lhs.isCombinator()) {
+
+    	return lhs.combinator() == rhs.combinator();
+
+    } else if (lhs.isNil()) {
+
+      return true; // no state to check
+
+    } else if (lhs.isSelector()){
+
+      return selectors_equal(*lhs.selector(), *rhs.selector(), simpleSelectorOrderDependent);
+
+    } else if (lhs.isCollection()) {
+
+      if (lhs.collection()->size() != rhs.collection()->size()) {
+        return false;
+      }
+
+      for (NodeDeque::iterator lhsIter = lhs.collection()->begin(), lhsIterEnd = lhs.collection()->end(),
+           rhsIter = rhs.collection()->begin(); lhsIter != lhsIterEnd; lhsIter++, rhsIter++) {
+
+        if (!nodesEqual(*lhsIter, *rhsIter, simpleSelectorOrderDependent)) {
+          return false;
+        }
+
+      }
+
+      return true;
+
+    }
+    
+    // We shouldn't get here.
+    throw "Comparing unknown node types. A new type was probably added and this method wasn't implemented for it.";
+  }
+  
+  
+  void Node::plus(Node& rhs) {
+  	if (!this->isCollection() || !rhs.isCollection()) {
+    	throw "Both the current node and rhs must be collections.";
+    }
+  	this->collection()->insert(this->collection()->end(), rhs.collection()->begin(), rhs.collection()->end());
+  }
+  
+  
+  ostream& operator<<(ostream& os, const Node& node) {
+
+    if (node.isCombinator()) {
+
+      switch (node.combinator()) {
+        case Complex_Selector::ANCESTOR_OF: os << "\" \""; break;
+        case Complex_Selector::PARENT_OF:   os << "\">\""; break;
+        case Complex_Selector::PRECEDES:    os << "\"~\""; break;
+        case Complex_Selector::ADJACENT_TO: os << "\"+\""; break;
+      }
+      
+    } else if (node.isNil()) {
+      
+      os << "nil";
+      
+    } else if (node.isSelector()){
+      
+      To_String to_string;
+      os << node.selector()->head()->perform(&to_string);
+      
+    } else if (node.isCollection()) {
+      
+			os << "[";
+      
+      for (NodeDeque::iterator iter = node.collection()->begin(), iterBegin = node.collection()->begin(), iterEnd = node.collection()->end(); iter != iterEnd; iter++) {
+        if (iter != iterBegin) {
+          os << ", ";
+        }
+
+				os << (*iter);
+      }
+      
+      os << "]";
+      
+    }
+    
+    return os;
+
+  }
+  
+  
+  Node complexSelectorToNode(Complex_Selector* pToConvert, Context& ctx) {
+    if (pToConvert == NULL) {
+      return Node::createNil();
+    }
+
+		Node node = Node::createCollection();
+    
+    while (pToConvert) {
+
+      // the first Complex_Selector may contain a dummy head pointer, skip it.
+      if (pToConvert->head() != NULL && !pToConvert->head()->is_empty_reference()) {
+        node.collection()->push_back(Node::createSelector(pToConvert, ctx));
+      }
+
+      if (pToConvert->combinator() != Complex_Selector::ANCESTOR_OF) {
+        node.collection()->push_back(Node::createCombinator(pToConvert->combinator()));
+      }
+
+      pToConvert = pToConvert->tail();
+    }
+    
+    return node;
+  }
+
+
+  Complex_Selector* nodeToComplexSelector(const Node& toConvert, Context& ctx) {
+    if (toConvert.isNil()) {
+      return NULL;
+    }
+
+
+    if (!toConvert.isCollection()) {
+      throw "The node to convert to a Complex_Selector* must be a collection type or nil.";
+    }
+    
+
+    NodeDeque& childNodes = *toConvert.collection();
+    
+    string noPath("");
+    Position noPosition;
+    Complex_Selector* pFirst = new (ctx.mem) Complex_Selector(noPath, noPosition, Complex_Selector::ANCESTOR_OF, NULL, NULL);
+    Complex_Selector* pCurrent = pFirst;
+    
+    for (NodeDeque::iterator childIter = childNodes.begin(), childIterEnd = childNodes.end(); childIter != childIterEnd; childIter++) {
+
+      Node& child = *childIter;
+      
+      if (child.isSelector()) {
+        pCurrent->tail(child.selector()->clone(ctx));   // JMA - need to clone the selector, because they can end up getting shared across Node collections, and can result in an infinite loop during the call to parentSuperselector()
+        pCurrent = pCurrent->tail();
+      } else if (child.isCombinator()) {
+        pCurrent->combinator(child.combinator());
+        
+        // if the next node is also a combinator, create another Complex_Selector to hold it so it doesn't replace the current combinator
+        if (childIter+1 != childIterEnd) {
+          Node& nextNode = *(childIter+1);
+          if (nextNode.isCombinator()) {
+            pCurrent->tail(new (ctx.mem) Complex_Selector(noPath, noPosition, Complex_Selector::ANCESTOR_OF, NULL, NULL));
+            pCurrent = pCurrent->tail();
+          }
+        }
+      } else {
+        throw "The node to convert's children must be only combinators or selectors.";
+      }
+    }
+
+    // Put the dummy Compound_Selector in the first position, for consistency with the rest of libsass
+    Compound_Selector* fakeHead = new (ctx.mem) Compound_Selector(noPath, noPosition, 1);
+    Selector_Reference* selectorRef = new (ctx.mem) Selector_Reference(noPath, noPosition, NULL);
+    fakeHead->elements().push_back(selectorRef);
+    pFirst->head(fakeHead);
+    
+    return pFirst;
+  }
+
+
+}