X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/e91fbe93b995ee8077bbc2097c5407138dc02627..1ed581bbd2ab6950c7edc001bf565a3ebc7c86f0:/Pooling.hpp?ds=sidebyside

diff --git a/Pooling.hpp b/Pooling.hpp
index f4045ab..b67f262 100644
--- a/Pooling.hpp
+++ b/Pooling.hpp
@@ -1,111 +1,331 @@
-/* Cycript - Inlining/Optimizing JavaScript Compiler
- * Copyright (C) 2009  Jay Freeman (saurik)
+/* Cycript - The Truly Universal Scripting Language
+ * Copyright (C) 2009-2016  Jay Freeman (saurik)
 */
 
-/* Modified BSD License {{{ */
+/* GNU Affero General Public License, Version 3 {{{ */
 /*
- *        Redistribution and use in source and binary
- * forms, with or without modification, are permitted
- * provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the
- *    above copyright notice, this list of conditions
- *    and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the
- *    above copyright notice, this list of conditions
- *    and the following disclaimer in the documentation
- *    and/or other materials provided with the
- *    distribution.
- * 3. The name of the author may not be used to endorse
- *    or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
- * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
- * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+**/
 /* }}} */
 
-#ifndef CYPOOLING_HPP
-#define CYPOOLING_HPP
+#ifndef CYCRIPT_POOLING_HPP
+#define CYCRIPT_POOLING_HPP
+
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include <algorithm>
 
-#include <apr_pools.h>
-#include <apr_strings.h>
+#include <stdint.h>
 
 #include "Exception.hpp"
+#include "Local.hpp"
 #include "Standard.hpp"
 
-_finline void *operator new(size_t size, apr_pool_t *pool) {
-    return apr_palloc(pool, size);
-}
+// XXX: std::aligned_storage and alignof
+static const size_t CYAlignment(sizeof(void *));
 
-_finline void *operator new [](size_t size, apr_pool_t *pool) {
-    return apr_palloc(pool, size);
+template <typename Type_>
+static void CYAlign(Type_ &data, size_t size) {
+    data = reinterpret_cast<Type_>((reinterpret_cast<uintptr_t>(data) + (size - 1)) & ~static_cast<uintptr_t>(size - 1));
 }
 
+class CYPool;
+_finline void *operator new(size_t size, CYPool &pool);
+_finline void *operator new [](size_t size, CYPool &pool);
+
 class CYPool {
   private:
-    apr_pool_t *pool_;
+    uint8_t *data_;
+    size_t size_;
+    size_t next_;
+
+    struct Cleaner {
+        Cleaner *next_;
+        void (*code_)(void *);
+        void *data_;
+
+        Cleaner(Cleaner *next, void (*code)(void *), void *data) :
+            next_(next),
+            code_(code),
+            data_(data)
+        {
+        }
+    } *cleaner_;
+
+    template <typename Type_>
+    static void delete_(void *data) {
+        reinterpret_cast<Type_ *>(data)->~Type_();
+    }
+
+    CYPool(const CYPool &);
 
   public:
-    CYPool() {
-        _aprcall(apr_pool_create(&pool_, NULL));
+    CYPool(size_t next = 64) :
+        data_(NULL),
+        size_(0),
+        next_(next),
+        cleaner_(NULL)
+    {
     }
 
     ~CYPool() {
-        apr_pool_destroy(pool_);
+        for (Cleaner *cleaner(cleaner_); cleaner != NULL; ) {
+            Cleaner *next(cleaner->next_);
+            (*cleaner->code_)(cleaner->data_);
+            cleaner = next;
+        }
+    }
+
+    template <typename Type_>
+    Type_ *malloc(size_t size, size_t alignment = CYAlignment) {
+        uint8_t *end(data_);
+        CYAlign(end, alignment);
+        end += size;
+
+        if (size_t(end - data_) > size_) {
+            size_t need(sizeof(Cleaner));
+            CYAlign(need, alignment);
+            need += size;
+            size_ = std::max<size_t>(next_, need);
+            next_ *= 2;
+            data_ = reinterpret_cast<uint8_t *>(::malloc(size_));
+            atexit(free, data_);
+            _assert(size <= size_);
+        }
+
+        uint8_t *data(data_);
+        CYAlign(data, alignment);
+        end = data + size;
+        size_ -= end - data_;
+        data_ = end;
+        return reinterpret_cast<Type_ *>(data);
+    }
+
+    char *strdup(const char *data) {
+        if (data == NULL)
+            return NULL;
+        return memdup(data, strlen(data) + 1, 1);
     }
 
-    void Clear() {
-        apr_pool_clear(pool_);
+    template <typename Type_>
+    Type_ *memdup(const Type_ *data, size_t size, size_t alignment = CYAlignment) {
+        Type_ *copy(malloc<Type_>(size, alignment));
+        memcpy(copy, data, size);
+        return copy;
     }
 
-    operator apr_pool_t *() const {
-        return pool_;
+    char *strndup(const char *data, size_t size) {
+        return strmemdup(data, strnlen(data, size));
     }
 
-    char *operator ()(const char *data) const {
-        return apr_pstrdup(pool_, data);
+    char *strmemdup(const char *data, size_t size) {
+        char *copy(malloc<char>(size + 1, 1));
+        memcpy(copy, data, size);
+        copy[size] = '\0';
+        return copy;
     }
 
-    char *operator ()(const char *data, size_t size) const {
-        return apr_pstrndup(pool_, data, size);
+    // XXX: this could be made much more efficient
+    __attribute__((__sentinel__))
+    char *strcat(const char *data, ...) {
+        size_t size(strlen(data)); {
+            va_list args;
+            va_start(args, data);
+
+            while (const char *arg = va_arg(args, const char *))
+                size += strlen(arg);
+
+            va_end(args);
+        }
+
+        char *copy(malloc<char>(size + 1, 1)); {
+            va_list args;
+            va_start(args, data);
+
+            size_t offset(strlen(data));
+            memcpy(copy, data, offset);
+
+            while (const char *arg = va_arg(args, const char *)) {
+                size_t size(strlen(arg));
+                memcpy(copy + offset, arg, size);
+                offset += size;
+            }
+
+            va_end(args);
+        }
+
+        copy[size] = '\0';
+        return copy;
+    }
+
+    // XXX: most people using this might should use sprintf
+    char *itoa(long value) {
+        return sprintf(16, "%ld", value);
+    }
+
+    __attribute__((__format__(__printf__, 3, 4)))
+    char *sprintf(size_t size, const char *format, ...) {
+        va_list args;
+        va_start(args, format);
+        char *copy(vsprintf(size, format, args));
+        va_end(args);
+        return copy;
+    }
+
+    char *vsprintf(size_t size, const char *format, va_list args) {
+        va_list copy;
+        va_copy(copy, args);
+        char buffer[size];
+        int writ(vsnprintf(buffer, size, format, copy));
+        va_end(copy);
+        _assert(writ >= 0);
+
+        if (size_t(writ) >= size)
+            return vsprintf(writ + 1, format, args);
+        return strmemdup(buffer, writ);
+    }
+
+    void atexit(void (*code)(void *), void *data = NULL);
+
+    template <typename Type_>
+    Type_ &object() {
+        Type_ *value(new(*this) Type_());
+        atexit(&delete_<Type_>, value);
+        return *value;
     }
 };
 
+_finline void *operator new(size_t size, CYPool &pool) {
+    return pool.malloc<void>(size);
+}
+
+_finline void *operator new [](size_t size, CYPool &pool) {
+    return pool.malloc<void>(size);
+}
+
+_finline void CYPool::atexit(void (*code)(void *), void *data) {
+    cleaner_ = new(*this) Cleaner(cleaner_, code, data);
+}
+
 struct CYData {
-    apr_pool_t *pool_;
+    CYPool *pool_;
+    unsigned count_;
+
+    CYData() :
+        count_(1)
+    {
+    }
+
+    CYData(CYPool &pool) :
+        pool_(&pool),
+        count_(_not(unsigned))
+    {
+    }
 
     virtual ~CYData() {
     }
 
-    static void *operator new(size_t size, apr_pool_t *pool) {
-        void *data(apr_palloc(pool, size));
-        reinterpret_cast<CYData *>(data)->pool_ = pool;
+    static void *operator new(size_t size, CYPool &pool) {
+        void *data(pool.malloc<void>(size));
+        reinterpret_cast<CYData *>(data)->pool_ = &pool;
         return data;
     }
 
     static void *operator new(size_t size) {
-        apr_pool_t *pool;
-        _aprcall(apr_pool_create(&pool, NULL));
-        return operator new(size, pool);
+        return operator new(size, *new CYPool());
     }
 
     static void operator delete(void *data) {
-        apr_pool_destroy(reinterpret_cast<CYData *>(data)->pool_);
+        delete reinterpret_cast<CYData *>(data)->pool_;
+    }
+};
+
+template <typename Type_>
+struct CYPoolAllocator {
+    CYPool *pool_;
+
+    typedef Type_ value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    CYPoolAllocator() :
+        pool_(NULL)
+    {
+    }
+
+    template <typename Right_>
+    CYPoolAllocator(const CYPoolAllocator<Right_> &rhs) :
+        pool_(rhs.pool_)
+    {
+    }
+
+    pointer allocate(size_type size, const void *hint = 0) {
+        return pool_->malloc<value_type>(size);
     }
 
+    void deallocate(pointer data, size_type size) {
+    }
+
+    void construct(pointer address, const Type_ &rhs) {
+        new(address) Type_(rhs);
+    }
+
+    void destroy(pointer address) {
+        address->~Type_();
+    }
+
+    template <typename Right_>
+    inline bool operator==(const CYPoolAllocator<Right_> &rhs) {
+        return pool_ == rhs.pool_;
+    }
+
+    template <typename Right_>
+    inline bool operator!=(const CYPoolAllocator<Right_> &rhs) {
+        return !operator==(rhs);
+    }
+
+    template <typename Right_>
+    struct rebind {
+        typedef CYPoolAllocator<Right_> other;
+    };
 };
 
-#endif/*CYPOOLING_HPP*/
+class CYLocalPool :
+    public CYPool
+{
+  private:
+    CYLocal<CYPool> local_;
+
+  public:
+    CYLocalPool() :
+        CYPool(),
+        local_(this)
+    {
+    }
+};
+
+#define $pool \
+    (*CYLocal<CYPool>::Get())
+
+template <>
+::pthread_key_t CYLocal<CYPool>::key_;
+
+#endif/*CYCRIPT_POOLING_HPP*/