sassc 2.0.1 → 2.1.0.pre1

data/ext/libsass/src/inspect.hpp

@@ -13,90 +13,86 @@ namespace Sass {
     // import all the class-specific methods and override as desired
     using Operation_CRTP<void, Inspect>::operator();
 
-    void fallback_impl(AST_Node_Ptr n);
-
   public:
 
     Inspect(const Emitter& emi);
     virtual ~Inspect();
 
     // statements
-    virtual void operator()(Block_Ptr);
-    virtual void operator()(Ruleset_Ptr);
-    virtual void operator()(Bubble_Ptr);
-    virtual void operator()(Supports_Block_Ptr);
-    virtual void operator()(Media_Block_Ptr);
-    virtual void operator()(At_Root_Block_Ptr);
-    virtual void operator()(Directive_Ptr);
-    virtual void operator()(Keyframe_Rule_Ptr);
-    virtual void operator()(Declaration_Ptr);
-    virtual void operator()(Assignment_Ptr);
-    virtual void operator()(Import_Ptr);
-    virtual void operator()(Import_Stub_Ptr);
-    virtual void operator()(Warning_Ptr);
-    virtual void operator()(Error_Ptr);
-    virtual void operator()(Debug_Ptr);
-    virtual void operator()(Comment_Ptr);
-    virtual void operator()(If_Ptr);
-    virtual void operator()(For_Ptr);
-    virtual void operator()(Each_Ptr);
-    virtual void operator()(While_Ptr);
-    virtual void operator()(Return_Ptr);
-    virtual void operator()(Extension_Ptr);
-    virtual void operator()(Definition_Ptr);
-    virtual void operator()(Mixin_Call_Ptr);
-    virtual void operator()(Content_Ptr);
+    virtual void operator()(Block*);
+    virtual void operator()(Ruleset*);
+    virtual void operator()(Bubble*);
+    virtual void operator()(Supports_Block*);
+    virtual void operator()(Media_Block*);
+    virtual void operator()(At_Root_Block*);
+    virtual void operator()(Directive*);
+    virtual void operator()(Keyframe_Rule*);
+    virtual void operator()(Declaration*);
+    virtual void operator()(Assignment*);
+    virtual void operator()(Import*);
+    virtual void operator()(Import_Stub*);
+    virtual void operator()(Warning*);
+    virtual void operator()(Error*);
+    virtual void operator()(Debug*);
+    virtual void operator()(Comment*);
+    virtual void operator()(If*);
+    virtual void operator()(For*);
+    virtual void operator()(Each*);
+    virtual void operator()(While*);
+    virtual void operator()(Return*);
+    virtual void operator()(Extension*);
+    virtual void operator()(Definition*);
+    virtual void operator()(Mixin_Call*);
+    virtual void operator()(Content*);
     // expressions
-    virtual void operator()(Map_Ptr);
-    virtual void operator()(Function_Ptr);
-    virtual void operator()(List_Ptr);
-    virtual void operator()(Binary_Expression_Ptr);
-    virtual void operator()(Unary_Expression_Ptr);
-    virtual void operator()(Function_Call_Ptr);
-    virtual void operator()(Function_Call_Schema_Ptr);
-    // virtual void operator()(Custom_Warning_Ptr);
-    // virtual void operator()(Custom_Error_Ptr);
-    virtual void operator()(Variable_Ptr);
-    virtual void operator()(Number_Ptr);
-    virtual void operator()(Color_Ptr);
-    virtual void operator()(Boolean_Ptr);
-    virtual void operator()(String_Schema_Ptr);
-    virtual void operator()(String_Constant_Ptr);
-    virtual void operator()(String_Quoted_Ptr);
-    virtual void operator()(Custom_Error_Ptr);
-    virtual void operator()(Custom_Warning_Ptr);
-    virtual void operator()(Supports_Operator_Ptr);
-    virtual void operator()(Supports_Negation_Ptr);
-    virtual void operator()(Supports_Declaration_Ptr);
-    virtual void operator()(Supports_Interpolation_Ptr);
-    virtual void operator()(Media_Query_Ptr);
-    virtual void operator()(Media_Query_Expression_Ptr);
-    virtual void operator()(At_Root_Query_Ptr);
-    virtual void operator()(Null_Ptr);
-    virtual void operator()(Parent_Selector_Ptr p);
+    virtual void operator()(Map*);
+    virtual void operator()(Function*);
+    virtual void operator()(List*);
+    virtual void operator()(Binary_Expression*);
+    virtual void operator()(Unary_Expression*);
+    virtual void operator()(Function_Call*);
+    // virtual void operator()(Custom_Warning*);
+    // virtual void operator()(Custom_Error*);
+    virtual void operator()(Variable*);
+    virtual void operator()(Number*);
+    virtual void operator()(Color_RGBA*);
+    virtual void operator()(Color_HSLA*);
+    virtual void operator()(Boolean*);
+    virtual void operator()(String_Schema*);
+    virtual void operator()(String_Constant*);
+    virtual void operator()(String_Quoted*);
+    virtual void operator()(Custom_Error*);
+    virtual void operator()(Custom_Warning*);
+    virtual void operator()(Supports_Operator*);
+    virtual void operator()(Supports_Negation*);
+    virtual void operator()(Supports_Declaration*);
+    virtual void operator()(Supports_Interpolation*);
+    virtual void operator()(Media_Query*);
+    virtual void operator()(Media_Query_Expression*);
+    virtual void operator()(At_Root_Query*);
+    virtual void operator()(Null*);
+    virtual void operator()(Parent_Selector* p);
     // parameters and arguments
-    virtual void operator()(Parameter_Ptr);
-    virtual void operator()(Parameters_Ptr);
-    virtual void operator()(Argument_Ptr);
-    virtual void operator()(Arguments_Ptr);
+    virtual void operator()(Parameter*);
+    virtual void operator()(Parameters*);
+    virtual void operator()(Argument*);
+    virtual void operator()(Arguments*);
     // selectors
-    virtual void operator()(Selector_Schema_Ptr);
-    virtual void operator()(Placeholder_Selector_Ptr);
-    virtual void operator()(Element_Selector_Ptr);
-    virtual void operator()(Class_Selector_Ptr);
-    virtual void operator()(Id_Selector_Ptr);
-    virtual void operator()(Attribute_Selector_Ptr);
-    virtual void operator()(Pseudo_Selector_Ptr);
-    virtual void operator()(Wrapped_Selector_Ptr);
-    virtual void operator()(Compound_Selector_Ptr);
-    virtual void operator()(Complex_Selector_Ptr);
-    virtual void operator()(Selector_List_Ptr);
+    virtual void operator()(Selector_Schema*);
+    virtual void operator()(Placeholder_Selector*);
+    virtual void operator()(Type_Selector*);
+    virtual void operator()(Class_Selector*);
+    virtual void operator()(Id_Selector*);
+    virtual void operator()(Attribute_Selector*);
+    virtual void operator()(Pseudo_Selector*);
+    virtual void operator()(Wrapped_Selector*);
+    virtual void operator()(Compound_Selector*);
+    virtual void operator()(Complex_Selector*);
+    virtual void operator()(Selector_List*);
 
-    virtual std::string lbracket(List_Ptr);
-    virtual std::string rbracket(List_Ptr);
+    virtual std::string lbracket(List*);
+    virtual std::string rbracket(List*);
 
-    // template <typename U>
-    // void fallback(U x) { fallback_impl(reinterpret_cast<AST_Node_Ptr>(x)); }
   };
 
 }

data/ext/libsass/src/json.cpp

@@ -402,7 +402,7 @@ char *json_encode_string(const char *str)
   try {
     emit_string(&sb, str);
   }
-  catch (std::exception) {
+  catch (std::exception&) {
     sb_free(&sb);
     throw;
   }
@@ -421,7 +421,7 @@ char *json_stringify(const JsonNode *node, const char *space)
     else
       emit_value(&sb, node);
   }
-  catch (std::exception) {
+  catch (std::exception&) {
     sb_free(&sb);
     throw;
   }

data/ext/libsass/src/lexer.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <cctype>
 #include <iostream>
 #include <iomanip>
@@ -150,11 +153,11 @@ namespace Sass {
     // Match word boundary (zero-width lookahead).
     const char* word_boundary(const char* src) { return is_character(*src) || *src == '#' ? 0 : src; }
 
-    // Match linefeed /(?:\n|\r\n?)/
+    // Match linefeed /(?:\n|\r\n?|\f)/
     const char* re_linebreak(const char* src)
     {
       // end of file or unix linefeed return here
-      if (*src == 0 || *src == '\n') return src + 1;
+      if (*src == 0 || *src == '\n' || *src == '\f') return src + 1;
       // a carriage return may optionally be followed by a linefeed
       if (*src == '\r') return *(src + 1) == '\n' ? src + 2 : src + 1;
       // no linefeed
@@ -166,7 +169,7 @@ namespace Sass {
     const char* end_of_line(const char* src)
     {
       // end of file or unix linefeed return here
-      return *src == 0 || *src == '\n' || *src == '\r' ? src : 0;
+      return *src == 0 || *src == '\n' || *src == '\r' || *src == '\f' ? src : 0;
     }
 
     // Assert end_of_file boundary (/\z/)

data/ext/libsass/src/listize.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include <iostream>
 #include <typeinfo>
 #include <string>
@@ -13,7 +16,7 @@ namespace Sass {
   Listize::Listize()
   {  }
 
-  Expression_Ptr Listize::operator()(Selector_List_Ptr sel)
+  Expression* Listize::operator()(Selector_List* sel)
   {
     List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
     l->from_selector(true);
@@ -25,24 +28,24 @@ namespace Sass {
     return SASS_MEMORY_NEW(Null, l->pstate());
   }
 
-  Expression_Ptr Listize::operator()(Compound_Selector_Ptr sel)
+  Expression* Listize::operator()(Compound_Selector* sel)
   {
     std::string str;
     for (size_t i = 0, L = sel->length(); i < L; ++i) {
-      Expression_Ptr e = (*sel)[i]->perform(this);
+      Expression* e = (*sel)[i]->perform(this);
       if (e) str += e->to_string();
     }
     return SASS_MEMORY_NEW(String_Quoted, sel->pstate(), str);
   }
 
-  Expression_Ptr Listize::operator()(Complex_Selector_Ptr sel)
+  Expression* Listize::operator()(Complex_Selector* sel)
   {
     List_Obj l = SASS_MEMORY_NEW(List, sel->pstate(), 2);
     l->from_selector(true);
     Compound_Selector_Obj head = sel->head();
     if (head && !head->is_empty_reference())
     {
-      Expression_Ptr hh = head->perform(this);
+      Expression* hh = head->perform(this);
       if (hh) l->append(hh);
     }
 
@@ -71,16 +74,11 @@ namespace Sass {
     if (tail)
     {
       Expression_Obj tt = tail->perform(this);
-      if (List_Ptr ls = Cast<List>(tt))
+      if (List* ls = Cast<List>(tt))
       { l->concat(ls); }
     }
     if (l->length() == 0) return 0;
     return l.detach();
   }
 
-  Expression_Ptr Listize::fallback_impl(AST_Node_Ptr n)
-  {
-    return Cast<Expression>(n);
-  }
-
 }

data/ext/libsass/src/listize.hpp

@@ -1,6 +1,10 @@
 #ifndef SASS_LISTIZE_H
 #define SASS_LISTIZE_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
 #include <vector>
 #include <iostream>
 
@@ -13,20 +17,20 @@ namespace Sass {
 
   struct Backtrace;
 
-  class Listize : public Operation_CRTP<Expression_Ptr, Listize> {
-
-    Expression_Ptr fallback_impl(AST_Node_Ptr n);
+  class Listize : public Operation_CRTP<Expression*, Listize> {
 
   public:
     Listize();
     ~Listize() { }
 
-    Expression_Ptr operator()(Selector_List_Ptr);
-    Expression_Ptr operator()(Complex_Selector_Ptr);
-    Expression_Ptr operator()(Compound_Selector_Ptr);
+    Expression* operator()(Selector_List*);
+    Expression* operator()(Complex_Selector*);
+    Expression* operator()(Compound_Selector*);
 
+    // generic fallback
     template <typename U>
-    Expression_Ptr fallback(U x) { return fallback_impl(x); }
+    Expression* fallback(U x)
+    { return Cast<Expression>(x); }
   };
 
 }

data/ext/libsass/src/memory/SharedPtr.cpp

@@ -18,7 +18,7 @@ namespace Sass {
       std::cerr << "# REPORTING MISSING DEALLOCATIONS #\n";
       std::cerr << "###################################\n";
       for (SharedObj* var : all) {
-        if (AST_Node_Ptr ast = dynamic_cast<AST_Node*>(var)) {
+        if (AST_Node* ast = dynamic_cast<AST_Node*>(var)) {
           debug_ast(ast);
         } else {
           std::cerr << "LEAKED " << var << "\n";
@@ -30,85 +30,4 @@ namespace Sass {
   #endif
 
   bool SharedObj::taint = false;
-
-  SharedObj::SharedObj()
-  : detached(false)
-    #ifdef DEBUG_SHARED_PTR
-    , dbg(false)
-    #endif
-  {
-    refcounter = 0;
-    #ifdef DEBUG_SHARED_PTR
-      if (taint) all.push_back(this);
-    #endif
-  };
-
-  SharedObj::~SharedObj() {
-    #ifdef DEBUG_SHARED_PTR
-      if (dbg) std::cerr << "Destruct " << this << "\n";
-      if(!all.empty()) { // check needed for MSVC (no clue why?)
-        all.erase(std::remove(all.begin(), all.end(), this), all.end());
-      }
-    #endif
-  };
-
-  void SharedPtr::decRefCount() {
-    if (node) {
-      -- node->refcounter;
-      #ifdef DEBUG_SHARED_PTR
-        if (node->dbg)  std::cerr << "- " << node << " X " << node->refcounter << " (" << this << ") " << "\n";
-      #endif
-      if (node->refcounter == 0) {
-        #ifdef DEBUG_SHARED_PTR
-          // AST_Node_Ptr ast = dynamic_cast<AST_Node*>(node);
-          if (node->dbg) std::cerr << "DELETE NODE " << node << "\n";
-        #endif
-        if (!node->detached) {
-          delete(node);
-        }
-      }
-    }
-  }
-
-  void SharedPtr::incRefCount() {
-    if (node) {
-      ++ node->refcounter;
-      node->detached = false;
-      #ifdef DEBUG_SHARED_PTR
-        if (node->dbg) {
-          std::cerr << "+ " << node << " X " << node->refcounter << " (" << this << ") " << "\n";
-        }
-      #endif
-    }
-  }
-
-  SharedPtr::~SharedPtr() {
-    decRefCount();
-  }
-
-
-  // the create constructor
-  SharedPtr::SharedPtr(SharedObj* ptr)
-  : node(ptr) {
-    incRefCount();
-  }
-  // copy assignment operator
-  SharedPtr& SharedPtr::operator=(const SharedPtr& rhs) {
-    void* cur_ptr = (void*) node;
-    void* rhs_ptr = (void*) rhs.node;
-    if (cur_ptr == rhs_ptr) {
-      return *this;
-    }
-    decRefCount();
-    node = rhs.node;
-    incRefCount();
-    return *this;
-  }
-
-  // the copy constructor
-  SharedPtr::SharedPtr(const SharedPtr& obj)
-  : node(obj.node) {
-    incRefCount();
-  }
-
-}
+}

data/ext/libsass/src/memory/SharedPtr.hpp

@@ -3,6 +3,8 @@
 
 #include "sass/base.h"
 
+#include <iostream>
+#include <string>
 #include <vector>
 
 namespace Sass {
@@ -39,168 +41,150 @@ namespace Sass {
   #endif
 
   class SharedObj {
-  protected:
-  friend class SharedPtr;
-  friend class Memory_Manager;
+   public:
+    SharedObj() : refcount(0), detached(false) {
+      #ifdef DEBUG_SHARED_PTR
+      if (taint) all.push_back(this);
+      #endif
+    }
+    virtual ~SharedObj() {
+      #ifdef DEBUG_SHARED_PTR
+      all.clear();
+      #endif
+    }
+
     #ifdef DEBUG_SHARED_PTR
-      static std::vector<SharedObj*> all;
-      std::string file;
-      size_t line;
+    static void dumpMemLeaks();
+    SharedObj* trace(std::string file, size_t line) {
+      this->file = file;
+      this->line = line;
+      return this;
+    }
+    std::string getDbgFile() { return file; }
+    size_t getDbgLine() { return line; }
+    void setDbg(bool dbg) { this->dbg = dbg; }
+    size_t getRefCount() const { return refcount; }
     #endif
-    static bool taint;
-    long refcounter;
-    // long refcount;
+
+    static void setTaint(bool val) { taint = val; }
+
+    virtual const std::string to_string() const = 0;
+   protected:
+    friend class SharedPtr;
+    friend class Memory_Manager;
+    size_t refcount;
     bool detached;
+    static bool taint;
     #ifdef DEBUG_SHARED_PTR
-      bool dbg;
-    #endif
-  public:
-    #ifdef DEBUG_SHARED_PTR
-      static void dumpMemLeaks();
-      SharedObj* trace(std::string file, size_t line) {
-        this->file = file;
-        this->line = line;
-        return this;
-      }
-    #endif
-    SharedObj();
-    #ifdef DEBUG_SHARED_PTR
-      std::string getDbgFile() {
-        return file;
-      }
-      size_t getDbgLine() {
-        return line;
-      }
-      void setDbg(bool dbg) {
-        this->dbg = dbg;
-      }
+    std::string file;
+    size_t line;
+    bool dbg = false;
+    static std::vector<SharedObj*> all;
     #endif
-    static void setTaint(bool val) {
-      taint = val;
-    }
-    virtual ~SharedObj();
-    long getRefCount() {
-      return refcounter;
-    }
   };
 
-
   class SharedPtr {
-  protected:
-    SharedObj* node;
-  protected:
-    void decRefCount();
-    void incRefCount();
-  public:
-    // the empty constructor
-    SharedPtr()
-    : node(NULL) {};
-    // the create constructor
-    SharedPtr(SharedObj* ptr);
-    // the copy constructor
-    SharedPtr(const SharedPtr& obj);
-    // the move constructor
-    SharedPtr(SharedPtr&& obj);
-    // copy assignment operator
-    SharedPtr& operator=(const SharedPtr& obj);
-    // move assignment operator
-    SharedPtr& operator=(SharedPtr&& obj);
-    // pure virtual destructor
-    virtual ~SharedPtr() = 0;
-  public:
-    SharedObj* obj () const {
-      return node;
-    };
-    SharedObj* operator-> () const {
-      return node;
-    };
-    bool isNull () {
-      return node == NULL;
-    };
-    bool isNull () const {
-      return node == NULL;
-    };
-    SharedObj* detach() const {
-      if (node) {
-        node->detached = true;
+   public:
+    SharedPtr() : node(nullptr) {}
+    SharedPtr(SharedObj* ptr) : node(ptr) {
+      incRefCount();
+    }
+    SharedPtr(const SharedPtr& obj) : SharedPtr(obj.node) {}
+    ~SharedPtr() {
+      decRefCount();
+    }
+
+    SharedPtr& operator=(SharedObj* other_node) {
+      if (node != other_node) {
+        decRefCount();
+        node = other_node;
+        incRefCount();
+      } else if (node != nullptr) {
+        node->detached = false;
       }
-      return node;
-    };
-    operator bool() const {
-      return node != NULL;
-    };
+      return *this;
+    }
 
-  };
+    SharedPtr& operator=(const SharedPtr& obj) {
+      return *this = obj.node;
+    }
 
-  template < class T >
-  class SharedImpl : private SharedPtr {
-  public:
-    SharedImpl()
-    : SharedPtr(NULL) {};
-    SharedImpl(T* node)
-    : SharedPtr(node) {};
-    template < class U >
-    SharedImpl(SharedImpl<U> obj)
-    : SharedPtr(static_cast<T*>(obj.ptr())) {}
-    SharedImpl(T&& node)
-    : SharedPtr(node) {};
-    SharedImpl(const T& node)
-    : SharedPtr(node) {};
-    // the copy constructor
-    SharedImpl(const SharedImpl<T>& impl)
-    : SharedPtr(impl.node) {};
-    // the move constructor
-    SharedImpl(SharedImpl<T>&& impl)
-    : SharedPtr(impl.node) {};
-    // copy assignment operator
-    SharedImpl<T>& operator=(const SharedImpl<T>& rhs) {
-      if (node) decRefCount();
-      node = rhs.node;
-      incRefCount();
-      return *this;
+    // Prevents all SharedPtrs from freeing this node until it is assigned to another SharedPtr.
+    SharedObj* detach() {
+      if (node != nullptr) node->detached = true;
+      return node;
     }
-    // move assignment operator
-    SharedImpl<T>& operator=(SharedImpl<T>&& rhs) {
-      // don't move our self
-      if (this != &rhs) {
-        if (node) decRefCount();
-        node = std::move(rhs.node);
-        rhs.node = NULL;
+
+    SharedObj* obj() const { return node; }
+    SharedObj* operator->() const { return node; }
+    bool isNull() const { return node == nullptr; }
+    operator bool() const { return node != nullptr; }
+
+   protected:
+    SharedObj* node;
+    void decRefCount() {
+      if (node == nullptr) return;
+      --node->refcount;
+      #ifdef DEBUG_SHARED_PTR
+      if (node->dbg) std::cerr << "- " << node << " X " << node->refcount << " (" << this << ") " << "\n";
+      #endif
+      if (node->refcount == 0 && !node->detached) {
+        #ifdef DEBUG_SHARED_PTR
+        if (node->dbg) std::cerr << "DELETE NODE " << node << "\n";
+        #endif
+        delete node;
       }
-      return *this;
     }
-    ~SharedImpl() {};
-  public:
-    operator T*() const {
-      return static_cast<T*>(this->obj());
+    void incRefCount() {
+      if (node == nullptr) return;
+      node->detached = false;
+      ++node->refcount;
+      #ifdef DEBUG_SHARED_PTR
+      if (node->dbg) std::cerr << "+ " << node << " X " << node->refcount << " (" << this << ") " << "\n";
+      #endif
     }
-    operator T&() const {
-      return *static_cast<T*>(this->obj());
+  };
+
+  template <class T>
+  class SharedImpl : private SharedPtr {
+   public:
+    SharedImpl() : SharedPtr(nullptr) {}
+
+    template <class U>
+    SharedImpl(U* node) :
+      SharedPtr(static_cast<T*>(node)) {}
+
+    template <class U>
+    SharedImpl(const SharedImpl<U>& impl) :
+      SharedImpl(impl.ptr()) {}
+
+    template <class U>
+    SharedImpl<T>& operator=(U *rhs) {
+      return static_cast<SharedImpl<T>&>(
+        SharedPtr::operator=(static_cast<T*>(rhs)));
     }
-    T& operator* () const {
-      return *static_cast<T*>(this->obj());
-    };
-    T* operator-> () const {
-      return static_cast<T*>(this->obj());
-    };
-    T* ptr () const {
-      return static_cast<T*>(this->obj());
-    };
-    T* detach() const {
-      if (this->obj() == NULL) return NULL;
-      return static_cast<T*>(SharedPtr::detach());
+
+    template <class U>
+    SharedImpl<T>& operator=(const SharedImpl<U>& rhs) {
+      return static_cast<SharedImpl<T>&>(
+        SharedPtr::operator=(static_cast<const SharedImpl<T>&>(rhs)));
     }
-    bool isNull() const {
-      return this->obj() == NULL;
+
+    operator const std::string() const {
+      if (node) return node->to_string();
+      return "[nullptr]";
     }
-    bool operator<(const T& rhs) const {
-      return *this->ptr() < rhs;
-    };
-    operator bool() const {
-      return this->obj() != NULL;
-    };
+
+    using SharedPtr::isNull;
+    using SharedPtr::operator bool;
+    operator T*() const { return static_cast<T*>(this->obj()); }
+    operator T&() const { return *static_cast<T*>(this->obj()); }
+    T& operator* () const { return *static_cast<T*>(this->obj()); };
+    T* operator-> () const { return static_cast<T*>(this->obj()); };
+    T* ptr () const { return static_cast<T*>(this->obj()); };
+    T* detach() { return static_cast<T*>(SharedPtr::detach()); }
   };
 
 }
 
-#endif
+#endif