/* Cycript - Optimizing JavaScript Compiler/Runtime
- * Copyright (C) 2009-2013 Jay Freeman (saurik)
+ * Copyright (C) 2009-2015 Jay Freeman (saurik)
*/
-/* GNU General Public License, Version 3 {{{ */
+/* GNU Affero General Public License, Version 3 {{{ */
/*
- * Cycript is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published
- * by the Free Software Foundation, either version 3 of the License,
- * or (at your option) any later version.
- *
- * Cycript is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Cycript. If not, see <http://www.gnu.org/licenses/>.
+ * 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/>.
**/
/* }}} */
#define CYCRIPT_POOLING_HPP
#include <cstdarg>
+#include <cstdio>
#include <cstdlib>
+#include <cstring>
-#include <apr_pools.h>
-#include <apr_strings.h>
+#include <algorithm>
+
+#include <stdint.h>
#include "Exception.hpp"
#include "Local.hpp"
#include "Standard.hpp"
+// XXX: std::aligned_storage and alignof
+static const size_t CYAlignment(sizeof(void *));
+
+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_;
}
} *cleaner_;
+ template <typename Type_>
+ static void delete_(void *data) {
+ reinterpret_cast<Type_ *>(data)->~Type_();
+ }
+
+ CYPool(const CYPool &);
+
public:
- CYPool() :
+ CYPool(size_t next = 64) :
+ data_(NULL),
+ size_(0),
+ next_(next),
cleaner_(NULL)
{
- _aprcall(apr_pool_create(&pool_, NULL));
}
~CYPool() {
- for (Cleaner *cleaner(cleaner_); cleaner_ != NULL; cleaner_ = cleaner_->next_)
+ for (Cleaner *cleaner(cleaner_); cleaner != NULL; ) {
+ Cleaner *next(cleaner->next_);
(*cleaner->code_)(cleaner->data_);
- apr_pool_destroy(pool_);
+ cleaner = next;
+ }
}
- void Clear() {
- apr_pool_clear(pool_);
+ 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);
}
- operator apr_pool_t *() const {
- return pool_;
+ char *strdup(const char *data) {
+ if (data == NULL)
+ return NULL;
+ return memdup(data, strlen(data) + 1, 1);
}
- void *operator()(size_t size) const {
- return apr_palloc(pool_, size);
+ 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;
}
- char *strdup(const char *data) const {
- return apr_pstrdup(pool_, data);
+ char *strndup(const char *data, size_t size) {
+ return strmemdup(data, strnlen(data, size));
}
- char *strndup(const char *data, size_t size) const {
- return apr_pstrndup(pool_, data, size);
+ 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 *strmemdup(const char *data, size_t size) const {
- return apr_pstrmemdup(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);
}
- char *sprintf(const char *format, ...) const {
+ __attribute__((__format__(__printf__, 3, 4)))
+ char *sprintf(size_t size, const char *format, ...) {
va_list args;
va_start(args, format);
- char *data(vsprintf(format, args));
+ char *copy(vsprintf(size, format, args));
va_end(args);
- return data;
+ return copy;
}
- char *vsprintf(const char *format, va_list args) const {
- return apr_pvsprintf(pool_, format, args);
+ 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(size);
+ return pool.malloc<void>(size);
}
_finline void *operator new [](size_t size, CYPool &pool) {
- return pool(size);
+ return pool.malloc<void>(size);
}
_finline void CYPool::atexit(void (*code)(void *), void *data) {
}
static void *operator new(size_t size, CYPool &pool) {
- void *data(pool(size));
+ void *data(pool.malloc<void>(size));
reinterpret_cast<CYData *>(data)->pool_ = &pool;
return data;
}
}
pointer allocate(size_type size, const void *hint = 0) {
- return reinterpret_cast<pointer>((*pool_)(size));
+ return pool_->malloc<value_type>(size);
}
void deallocate(pointer data, size_type size) {
#define $pool \
(*CYLocal<CYPool>::Get())
+template <>
+::pthread_key_t CYLocal<CYPool>::key_;
+
#endif/*CYCRIPT_POOLING_HPP*/
projects / cycript.git / blobdiff