sassc 0.0.9 → 0.0.10

data/ext/libsass/inspect.hpp

@@ -1,48 +1,38 @@
-#ifndef SASS_INSPECT
-#define SASS_INSPECT
+#ifndef SASS_INSPECT_H
+#define SASS_INSPECT_H
 
 #include <string>
 
-#ifndef SASS_OPERATION
+#include "position.hpp"
 #include "operation.hpp"
-#endif
-
-// #ifndef SASS_TO_STRING
-// #include "to_string.hpp"
-// #endif
+#include "emitter.hpp"
 
 namespace Sass {
+  class Context;
   using namespace std;
-  struct Context;
 
-  class Inspect : public Operation_CRTP<void, Inspect> {
+  class Inspect : public Operation_CRTP<void, Inspect>, public Emitter {
+  protected:
     // import all the class-specific methods and override as desired
     using Operation_CRTP<void, Inspect>::operator();
 
-    // To_String* to_string;
-    string buffer;
-    size_t indentation;
-    Context* ctx;
-    void indent();
-
     void fallback_impl(AST_Node* n);
 
-    void append_to_buffer(const string& text);
-
   public:
 
-    Inspect(Context* ctx = 0);
+    Inspect(Emitter emi);
     virtual ~Inspect();
 
-    string get_buffer() { return buffer; }
-
     // statements
     virtual void operator()(Block*);
     virtual void operator()(Ruleset*);
     virtual void operator()(Propset*);
+    virtual void operator()(Bubble*);
     virtual void operator()(Feature_Block*);
     virtual void operator()(Media_Block*);
+    virtual void operator()(At_Root_Block*);
     virtual void operator()(At_Rule*);
+    virtual void operator()(Keyframe_Rule*);
     virtual void operator()(Declaration*);
     virtual void operator()(Assignment*);
     virtual void operator()(Import*);
@@ -74,10 +64,12 @@ namespace Sass {
     virtual void operator()(Boolean*);
     virtual void operator()(String_Schema*);
     virtual void operator()(String_Constant*);
+    virtual void operator()(String_Quoted*);
     virtual void operator()(Feature_Query*);
     virtual void operator()(Feature_Query_Condition*);
     virtual void operator()(Media_Query*);
     virtual void operator()(Media_Query_Expression*);
+    virtual void operator()(At_Root_Expression*);
     virtual void operator()(Null*);
     // parameters and arguments
     virtual void operator()(Parameter*);
@@ -97,12 +89,9 @@ namespace Sass {
     virtual void operator()(Complex_Selector*);
     virtual void operator()(Selector_List*);
 
-    template <typename U>
-    void fallback(U x) { fallback_impl(reinterpret_cast<AST_Node*>(x)); }
+    // template <typename U>
+    // void fallback(U x) { fallback_impl(reinterpret_cast<AST_Node*>(x)); }
   };
 
-  string unquote(const string&);
-  string quote(const string&, char);
-
 }
 #endif

data/ext/libsass/kwd_arg_macros.hpp

@@ -1,3 +1,6 @@
+#ifndef SASS_KWD_ARG_MACROS_H
+#define SASS_KWD_ARG_MACROS_H
+
 // Example usage:
 // KWD_ARG_SET(Args) {
 //   KWD_ARG(Args, string, foo);
@@ -21,3 +24,5 @@ public: \
   } \
   type name() { return name##_; } \
 private:
+
+#endif

data/ext/libsass/mapping.hpp

@@ -1,8 +1,7 @@
-#define SASS_MAPPING
+#ifndef SASS_MAPPING_H
+#define SASS_MAPPING_H
 
-#ifndef SASS_POSITION
 #include "position.hpp"
-#endif
 
 namespace Sass {
 
@@ -15,3 +14,5 @@ namespace Sass {
   };
 
 }
+
+#endif

data/ext/libsass/memory_manager.hpp

@@ -1,10 +1,11 @@
-#define SASS_MEMORY_MANAGER
+#ifndef SASS_MEMORY_MANAGER_H
+#define SASS_MEMORY_MANAGER_H
 
 #include <vector>
 #include <iostream>
-using namespace std;
 
 namespace Sass {
+  using namespace std;
   /////////////////////////////////////////////////////////////////////////////
   // A class for tracking allocations of AST_Node objects. The intended usage
   // is something like: Some_Node* n = new (mem_mgr) Some_Node(...);
@@ -52,3 +53,5 @@ inline void operator delete(void *np, Sass::Memory_Manager<T>& mem_mgr)
   mem_mgr.remove(reinterpret_cast<T*>(np));
   operator delete(np);
 }
+
+#endif

data/ext/libsass/node.cpp

@@ -11,43 +11,41 @@ namespace Sass {
     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(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector* pSelector, NodeDequePtr& pCollection)
+  : got_line_feed(false), mType(type), mCombinator(combinator), mpSelector(pSelector), mpCollection(pCollection)
+  { /* if (pSelector) got_line_feed = pSelector->has_line_feed(); */ }
+
+
   Node Node::clone(Context& ctx) const {
     NodeDequePtr pNewCollection = make_shared<NodeDeque>();
     if (mpCollection) {
@@ -56,14 +54,14 @@ namespace Sass {
         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;
 
@@ -75,18 +73,18 @@ namespace Sass {
 
     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();
@@ -117,20 +115,20 @@ namespace Sass {
       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());
   }
-  
-  
+
+#ifdef DEBUG
   ostream& operator<<(ostream& os, const Node& node) {
 
     if (node.isCombinator()) {
@@ -141,20 +139,20 @@ namespace Sass {
         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 << ", ";
@@ -162,23 +160,24 @@ namespace Sass {
 
 				os << (*iter);
       }
-      
+
       os << "]";
-      
+
     }
-    
+
     return os;
 
   }
-  
-  
+#endif
+
+
   Node complexSelectorToNode(Complex_Selector* pToConvert, Context& ctx) {
     if (pToConvert == NULL) {
       return Node::createNil();
     }
 
-		Node node = Node::createCollection();
-    
+    Node node = Node::createCollection();
+
     while (pToConvert) {
 
       // the first Complex_Selector may contain a dummy head pointer, skip it.
@@ -192,7 +191,7 @@ namespace Sass {
 
       pToConvert = pToConvert->tail();
     }
-    
+
     return node;
   }
 
@@ -206,30 +205,30 @@ namespace Sass {
     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);
+    Position noPosition(-1, -1, -1);
+    Complex_Selector* pFirst = new (ctx.mem) Complex_Selector(ParserState("[NODE]"), 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->tail(new (ctx.mem) Complex_Selector(ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL));
             pCurrent = pCurrent->tail();
           }
         }
@@ -239,11 +238,12 @@ namespace Sass {
     }
 
     // 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);
+    Compound_Selector* fakeHead = new (ctx.mem) Compound_Selector(ParserState("[NODE]"), 1);
+    Selector_Reference* selectorRef = new (ctx.mem) Selector_Reference(ParserState("[NODE]"), NULL);
     fakeHead->elements().push_back(selectorRef);
     pFirst->head(fakeHead);
-    
+    pFirst->has_line_feed(pFirst->has_line_feed() || pFirst->tail()->has_line_feed() || toConvert.got_line_feed);
+
     return pFirst;
   }
 

data/ext/libsass/node.hpp

@@ -1,22 +1,20 @@
-#define SASS_NODE
-
+#ifndef SASS_NODE_H
+#define SASS_NODE_H
 
 #include <deque>
 #include <iostream>
 #include <memory>
 
-#ifndef SASS_AST
 #include "ast.hpp"
-#endif
 
 
 namespace Sass {
 
-  
+
   using namespace std;
 
 
-  struct Context;
+  class Context;
 
   /*
    There are a lot of stumbling blocks when trying to port the ruby extend code to C++. The biggest is the choice of
@@ -29,11 +27,11 @@ namespace Sass {
    the inconsistent nesting levels. The variant nature (while making some of the C++ code uglier) allows the code to
    more closely match the ruby code, which is a huge benefit when attempting to implement an complex algorithm like
    the Extend operator.
-   
+
    Note that the current libsass data model also pairs the combinator with the Complex_Selector that follows it, but
    ruby sass has no such restriction, so we attempt to create a data structure that can handle them split apart.
    */
-  
+
   class Node;
   typedef deque<Node> NodeDeque;
   typedef shared_ptr<NodeDeque> NodeDequePtr;
@@ -52,49 +50,50 @@ namespace Sass {
     bool isSelector() const { return mType == SELECTOR; }
     bool isCollection() const { return mType == COLLECTION; }
     bool isNil() const { return mType == NIL; }
-    
+    bool got_line_feed;
+
     Complex_Selector::Combinator combinator() const { return mCombinator; }
-    
+
     Complex_Selector* selector() { return mpSelector; }
     const Complex_Selector* selector() const { return mpSelector; }
-    
+
     NodeDequePtr collection() { return mpCollection; }
     const NodeDequePtr collection() const { return mpCollection; }
-    
+
     static Node createCombinator(const Complex_Selector::Combinator& combinator);
 
     // This method will clone the selector, stripping off the tail and combinator
     static Node createSelector(Complex_Selector* pSelector, Context& ctx);
-    
+
     static Node createCollection();
     static Node createCollection(const NodeDeque& values);
 
     static Node createNil();
-    
+
     Node clone(Context& ctx) const;
-    
+
     bool operator==(const Node& rhs) const;
     inline bool operator!=(const Node& rhs) const { return !(*this == rhs); }
-    
-    
+
+
     /*
     COLLECTION FUNCTIONS
-    
+
     Most types don't need any helper methods (nil and combinator due to their simplicity and
     selector due to the fact that we leverage the non-node selector code on the Complex_Selector
     whereever possible). The following methods are intended to be called on Node objects whose
     type is COLLECTION only.
     */
-    
+
     // rhs and this must be node collections. Shallow copy the nodes from rhs to the end of this.
     // This function DOES NOT remove the nodes from rhs.
     void plus(Node& rhs);
-    
+
     // potentialChild must be a node collection of selectors/combinators. this must be a collection
     // of collections of nodes/combinators. This method checks if potentialChild is a child of this
     // Node.
     bool contains(const Node& potentialChild, bool simpleSelectorOrderDependent) const;
-    
+
   private:
     // Private constructor; Use the static methods (like createCombinator and createSelector)
     // to instantiate this object. This is more expressive, and it allows us to break apart each
@@ -102,21 +101,21 @@ namespace Sass {
     Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector* pSelector, NodeDequePtr& pCollection);
 
     TYPE mType;
-    
+
     // TODO: can we union these to save on memory?
     Complex_Selector::Combinator mCombinator;
     Complex_Selector* mpSelector; // this is an AST_Node, so it will be handled by the Memory_Manager
     NodeDequePtr mpCollection;
   };
-  
-  
-  ostream& operator<<(ostream& os, const Node& node);
-  
 
+#ifdef DEBUG
+  ostream& operator<<(ostream& os, const Node& node);
+#endif
   Node complexSelectorToNode(Complex_Selector* pToConvert, Context& ctx);
   Complex_Selector* nodeToComplexSelector(const Node& toConvert, Context& ctx);
 
-  
   bool nodesEqual(const Node& one, const Node& two, bool simpleSelectorOrderDependent);
 
 }
+
+#endif