Avoid naming functors without symbols as just "1".

[cycript.git] / Stack.hpp

diff --git a/Stack.hpp b/Stack.hpp
index 4a3fc6e63bd08c4cdeffe9bb898010071b727ed1..f249109cf7c1a760344a3185e3870ac532166c65 100644 (file)
--- a/Stack.hpp
+++ b/Stack.hpp
@@ -1,5 +1,5 @@
-/* Cycript - Optimizing JavaScript Compiler/Runtime
- * Copyright (C) 2009-2015  Jay Freeman (saurik)
+/* Cycript - The Truly Universal Scripting Language
+ * Copyright (C) 2009-2016  Jay Freeman (saurik)

 */
 
 /* GNU Affero General Public License, Version 3 {{{ */
 */
 
 /* GNU Affero General Public License, Version 3 {{{ */


@@ -24,68 +24,131 @@
 
 namespace cy {
 
 
 namespace cy {
 

+#if 0
+template <class Type_>
+class stack {
+  public:
+    typedef std::vector<Type_> Data_;
+    typedef typename Data_::const_reverse_iterator const_iterator;
+
+  private:
+    Data_ data_;
+
+  public:
+    stack() {
+        data_.reserve(200);
+    }
+
+    _finline Type_ &operator [](size_t i) {
+        return data_[data_.size() - 1 - i];
+    }
+
+    _finline const Type_ &operator [](size_t i) const {
+        return data_[data_.size() - 1 - i];
+    }
+
+    _finline void push(Type_ &t) {
+        data_.push_back(t);
+    }
+
+    _finline void pop() {
+        data_.pop_back();
+    }
+
+    _finline void pop(unsigned int size) {
+        for (; size != 0; --size)
+            pop();
+    }
+
+    void clear() {
+        data_.clear();
+    }
+
+    _finline size_t size() const {
+        return data_.size();
+    }
+
+    _finline const_iterator begin() const {
+        return data_.rbegin();
+    }
+
+    _finline const_iterator end() const {
+        return data_.rend();
+    }
+
+  private:
+    stack(const stack &);
+    stack &operator =(const stack &);
+};
+#else

 template <class Type_>
 class stack {
   public:
     typedef std::reverse_iterator<Type_ *> const_iterator;
 
   private:
 template <class Type_>
 class stack {
   public:
     typedef std::reverse_iterator<Type_ *> const_iterator;
 
   private:

-    Type_ *data_;
-    size_t size_;
-    size_t capacity_;
+    Type_ *begin_;
+    Type_ *end_;
+    Type_ *capacity_;

 
     void destroy() {
 
     void destroy() {

-        data_ -= size_;
-        for (size_t i(0); i != size_; ++i)
-            data_[i].~Type_();
+        for (Type_ *i(begin_); i != end_; ++i)
+            i->~Type_();

     }
 
     }
 

-    void reserve(size_t capacity) {
-        capacity_ = capacity;
-        Type_ *data(static_cast<Type_ *>(::operator new(sizeof(Type_) * capacity_)));
+    void reserve() {
+        size_t capacity(capacity_ - begin_);
+        if (capacity == 0)
+            capacity = 200;
+        else
+            capacity *= 2;

 
 

-        data_ -= size_;
-        for (size_t i(0); i != size_; ++i) {
-            Type_ &old(data_[i]);
+        Type_ *data(static_cast<Type_ *>(::operator new(sizeof(Type_) * capacity)));
+
+        size_t size(end_ - begin_);
+        for (size_t i(0); i != size; ++i) {
+            Type_ &old(begin_[i]);

             new (data + i) Type_(old);
             old.~Type_();
         }
 
             new (data + i) Type_(old);
             old.~Type_();
         }
 

-        ::operator delete(data_);
-        data_ = data + size_;
+        ::operator delete(begin_);
+
+        begin_ = data;
+        end_ = data + size;
+        capacity_ = data + capacity;

     }
 
   public:
     stack() :
     }
 
   public:
     stack() :

-        data_(NULL),
-        size_(0)
+        begin_(NULL),
+        end_(NULL),
+        capacity_(NULL)

     {
     {

-        reserve(200);
+        reserve();

     }
 
     ~stack() {
         destroy();
     }
 
     ~stack() {
         destroy();

-        ::operator delete(data_);
+        ::operator delete(begin_);

     }
 
     _finline Type_ &operator [](size_t i) {
     }
 
     _finline Type_ &operator [](size_t i) {

-        return data_[-1 - i];
+        return end_[-1 - i];

     }
 
     _finline const Type_ &operator [](size_t i) const {
     }
 
     _finline const Type_ &operator [](size_t i) const {

-        return data_[-1 - i];
+        return end_[-1 - i];

     }
 
     _finline void push(Type_ &t) {
     }
 
     _finline void push(Type_ &t) {

-        if (size_ == capacity_)
-            reserve(capacity_ * 2);
-        new (data_++) Type_(t);
-        ++size_;
+        if (end_ == capacity_)
+            reserve();
+        new (end_++) Type_(t);

     }
 
     _finline void pop() {
     }
 
     _finline void pop() {

-        (--data_)->~Type_();
-        --size_;
+        (--end_)->~Type_();

     }
 
     _finline void pop(unsigned int size) {
     }
 
     _finline void pop(unsigned int size) {


@@ -95,25 +158,26 @@ class stack {
 
     void clear() {
         destroy();
 
     void clear() {
         destroy();

-        size_ = 0;
+        end_ = begin_;

     }
 
     _finline size_t size() const {
     }
 
     _finline size_t size() const {

-        return size_;
+        return end_ - begin_;

     }
 
     _finline const_iterator begin() const {
     }
 
     _finline const_iterator begin() const {

-        return const_iterator(data_);
+        return const_iterator(end_);

     }
 
     _finline const_iterator end() const {
     }
 
     _finline const_iterator end() const {

-        return const_iterator(data_ - size_);
+        return const_iterator(begin_);

     }
 
   private:
     stack(const stack &);
     stack &operator =(const stack &);
 };
     }
 
   private:
     stack(const stack &);
     stack &operator =(const stack &);
 };

+#endif

 
 template <class Type_, class Stack_ = stack<Type_> >
 class slice {
 
 template <class Type_, class Stack_ = stack<Type_> >
 class slice {