ruxml 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3312e4cba85d6ff2f87e2b93666d238b847a7ae5e2b3bc4c7f35d5c1ec4e032d
+  data.tar.gz: 779aceed144556171266de69e7c25da243e4aceb2ef420e9403364c202b19df9
+SHA512:
+  metadata.gz: 0c43d9ca1e0ccfdb9572eda68b44a5a64200e414c310180ae23540b7322c5fa12ccee400b54ceb421e2ab1631bc27b824292d287a4081bc8c38dcfaaa2b42ba7
+  data.tar.gz: dd53724faed49fb93ff1caaa643575f4cc438b76d4bdf0366578abbe974a110681bb22dd5ad3dcb24927291f5b2911d151bafb6b778239a945dbf916d9f8b409

data/ext/ruxml/array.cpp

@@ -0,0 +1,71 @@
+#include <cassert>
+#include <cstring>
+
+#include "array.hpp"
+
+void aclear(void* array) {
+   if (array) ahdr((array))->len = 0;
+}
+
+void *ainit_(void *array, Allocator *allocator) {
+   if (array) {
+      ahdr(array)->allocator = allocator;
+      return array;
+   } else {
+      auto hdr = allocate_type(allocator, ArrayHeader);
+      hdr->allocator = allocator;
+      hdr->len = 0;
+      hdr->cap = 0;
+      return &hdr->buffer;
+   }
+}
+
+void afree_(void *array) {
+   if (array) allocate_free(ahdr(array)->allocator, ahdr(array));
+}
+
+void *asetcap_(void *array, uint32_t new_cap, uint32_t element_size) {
+   auto hdr = array ? ahdr(array) : nullptr;
+
+   uint32_t new_len = hdr ? (hdr->len < new_cap ? hdr->len : new_cap) : 0;
+   uint32_t mem_size = sizeof(ArrayHeader) + new_cap * element_size;
+
+   if (array) {
+      auto old_hdr = hdr;
+      hdr = (ArrayHeader *) allocate_size(old_hdr->allocator, mem_size);
+      hdr->allocator = old_hdr->allocator;
+      hdr->len = new_len;
+      hdr->cap = new_cap;
+      memcpy(&hdr->buffer, array, new_len * element_size);
+      allocate_free(hdr->allocator, old_hdr);
+   } else {
+      hdr = (ArrayHeader *) allocate_size(nullptr, sizeof(ArrayHeader) + new_cap * element_size);
+      hdr->allocator = nullptr;
+      hdr->len = new_len;
+      hdr->cap = new_cap;
+   }
+
+   return &hdr->buffer;
+}
+
+void *afit_(void *array, uint32_t count, uint32_t element_size) {
+   uint32_t capacity = acap(array);
+   if (count <= capacity) return array;
+
+   uint32_t new_capacity = capacity >= 6 ? (capacity + (capacity >> 1U)) : 8;
+   if (new_capacity < count) new_capacity = count;
+
+   return asetcap_(array, new_capacity, element_size);
+}
+
+void *acat_(void *array, void *other, uint32_t element_size) {
+   if (!other) return array;
+   if (!array) return other;
+
+   auto len = ahdr(array)->len;
+   auto other_len = ahdr(other)->len;
+   array = afit_(array, len + other_len, element_size);
+   memcpy((char *) array + len * element_size, other, other_len * element_size);
+   ahdr(array)->len += other_len;
+   return array;
+}

data/ext/ruxml/array.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <cstdint>
+#include <cstdlib>
+#include <cstddef>
+
+#include "memory.hpp"
+
+struct ArrayHeader {
+   Allocator *allocator;
+   uint32_t len;
+   uint32_t cap;
+   char *buffer[1];
+};
+
+#define ahdr(array) ((ArrayHeader *)((char *)(array) - offsetof(ArrayHeader, buffer)))
+#define alen(array) ((array) ? ahdr((array))->len : 0)
+#define acap(array) ((array) ? ahdr((array))->cap : 0)
+
+void aclear(void *array);
+void *ainit_(void *array, Allocator *allocator = nullptr);
+void afree_(void *array);
+void *afit_(void *array, uint32_t count, uint32_t element_size);
+void *asetcap_(void *array, uint32_t new_cap, uint32_t element_size);
+void *acat_(void *array, void *other, uint32_t element_size);
+
+#define ainit(array, ...) ((array) = (decltype(array))ainit_(array, __VA_ARGS__))
+#define afree(array) (afree_((array)), (array) = nullptr)
+#define asetcap(array, new_cap) ((array) = (decltype(array))asetcap_((array), (new_cap), sizeof(*(array))))
+#define ashrink(array) ((array) = (decltype(array))asetcap_((array), alen((array)), sizeof(*(array))))
+#define asetlen(array, new_len) ((array) = (decltype(array))afit_((array), new_len, sizeof(*array)), ahdr(array)->len = new_len)
+#define aempty(array) (ahdr(array)->len = 0)
+#define apush(array, item) ((array) = (decltype(array))afit_((array), alen(array) + 1, sizeof(*array)), array[ahdr(array)->len++] = (item))
+#define adel(array, index) ((array)[(index)] = (array)[--ahdr((array))->len])
+#define acat(array, other) ((array) = (decltype(array))acat_((array), (other), sizeof(*array)))

data/ext/ruxml/extconf.rb

@@ -0,0 +1,5 @@
+require "mkmf"
+
+have_library 'stdc++'
+
+create_makefile 'ruxml/ruxml'

data/ext/ruxml/memory.cpp

@@ -0,0 +1,222 @@
+#include <cstring>
+#include <cstdarg>
+#include <cstdio>
+
+#include "memory.hpp"
+#include "str.hpp"
+
+Allocator* temp_allocator = nullptr;
+
+void *allocate_size_(void *data, size_t size) {
+   if (data) {
+      return ((Allocator *) data)->alloc(data, size);
+   } else {
+      return raw_allocate_size(size);
+   }
+}
+
+void allocate_free_(void *data, void *ptr) {
+   if (data) {
+      ((Allocator *) data)->free(data, ptr);
+   } else {
+      raw_free(ptr);
+   }
+}
+
+#ifdef MEMORY_DEBUG2
+void *alloc_size_(void *data, size_t size, const char *file, int line) {
+   printf("%s:%i ALLOC  : %li\n", file, line, size);
+   alloc_size_(data, size);
+}
+
+void alloc_free_(void *data, void *ptr, const char *file, int line) {
+   printf("%s:%i FREE\n", file, line);
+   alloc_free_(data, ptr);
+}
+#endif
+
+void arena_init(MemoryArena *arena, const char *name, Allocator *allocator) {
+#ifdef MEMORY_DEBUG
+   arena->name = name;
+   printf("Arena init: %s\n", name);
+#endif
+
+   arena->allocator.alloc = allocator_arena_alloc;
+   arena->allocator.free = allocator_noop_free;
+   arena->base_allocator = allocator;
+   arena->min_block_size = 8 * 1024 * 1024;
+   arena->block_first = nullptr;
+   arena->block_last = nullptr;
+   arena->free = nullptr;
+}
+
+void arena_clear(MemoryArena *arena) {
+#ifdef MEMORY_INFO
+   arena->memory_allocated = 0;
+#endif
+
+   if (arena->block_first) {
+      assert(arena->block_last);
+      arena->block_last->next = arena->free;
+      arena->free = arena->block_first;
+      arena->block_first = nullptr;
+      arena->block_last = nullptr;
+   }
+}
+
+void arena_destroy(MemoryArena *arena) {
+#ifdef MEMORY_DEBUG
+   printf("Arena destroy: %s\n", arena->name);
+#endif
+   while (arena->block_first) {
+      void *mem = arena->block_first;
+      arena->block_first = arena->block_first->next;
+      allocate_free(arena->base_allocator, mem);
+   }
+
+   while (arena->free) {
+      void *mem = arena->free;
+      arena->free = arena->free->next;
+      allocate_free(arena->base_allocator, mem);
+   }
+
+   arena->block_last = nullptr;
+}
+
+void arena_stats(MemoryArena *arena, uint64_t *allocated_ptr, uint64_t *used_ptr) {
+   uint64_t allocated = 0;
+   uint64_t used = 0;
+
+   auto block = arena->block_first;
+   while (block) {
+      allocated += block->size;
+      used += block->used;
+      block = block->next;
+   }
+
+   *allocated_ptr = allocated;
+   *used_ptr = used;
+}
+
+TempSection begin_temp_section(MemoryArena *arena) {
+   TempSection section = {};
+
+   if (!arena->block_first) {
+      arena_alloc_block(arena, 0);
+   }
+
+   auto block = arena->block_first;
+   block->temp_count++;
+
+   section.arena = arena;
+   section.block = block;
+   section.mark = block->used;
+   return section;
+}
+
+void end_temp_section(TempSection section) {
+   MemoryArena *arena = section.arena;
+
+   while (arena->block_first != section.block) {
+      assert(arena->block_first);
+      assert(arena->block_first->temp_count == 1);
+      void *mem = arena->block_first;
+      arena->block_first = arena->block_first->next;
+      free(mem);
+   }
+   assert(arena->block_first == section.block);
+
+   arena->block_first->used = section.mark;
+   arena->block_first->temp_count--;
+}
+
+void arena_alloc_block(MemoryArena *arena, size_t size) {
+   auto cur_block = arena->free;
+   MemoryArenaBlock *prev_block = nullptr;
+   while (cur_block) {
+      if (cur_block->size >= size) {
+         if (arena->free == cur_block) arena->free = cur_block->next;
+         if (prev_block) prev_block->next = cur_block->next;
+         cur_block->next = arena->block_first;
+         cur_block->used = 0;
+         if (arena->block_first) {
+            cur_block->temp_count = arena->block_first->temp_count;
+         } else {
+            arena->block_last = cur_block;
+         }
+
+         arena->block_first = cur_block;
+         return;
+      }
+      prev_block = cur_block;
+      cur_block = cur_block->next;
+   }
+
+   size_t required_size = arena->min_block_size > size ? arena->min_block_size : size;
+
+   size_t size_with_header = sizeof(MemoryArenaBlock) + required_size;
+   auto mem = (uint8_t *) raw_allocate_size_zero(size_with_header);
+   auto header = (MemoryArenaBlock *) mem;
+   header->data = mem + sizeof(MemoryArenaBlock);
+   header->size = required_size;
+
+   if (arena->block_first) {
+      header->temp_count = arena->block_first->temp_count;
+   }
+
+   header->next = arena->block_first;
+   arena->block_first = header;
+   if (!arena->block_last) arena->block_last = arena->block_first;
+}
+
+void *arena_alloc(MemoryArena *arena, size_t size) {
+#ifdef MEMORY_INFO
+   arena->memory_allocated += size;
+#endif
+
+   if (!arena->block_first || (arena->block_first->used + size > arena->block_first->size)) {
+      arena_alloc_block(arena, size);
+   }
+   assert(arena->block_first);
+   assert(arena->block_last);
+   assert(arena->block_first->used + size <= arena->block_first->size);
+
+   auto mem = arena->block_first->data + arena->block_first->used;
+   arena->block_first->used += size;
+
+   return mem;
+}
+
+char *zstr_dup(Allocator *allocator, const char *str, int64_t size) {
+   auto *buffer = (char *) allocate_size(allocator, size + 1);
+   memcpy(buffer, str, sizeof(char) * size);
+   return buffer;
+}
+
+char *zstr_dup(Allocator *allocator, const char *str) {
+   return zstr_dup(allocator, str, zstr_length(str));
+}
+
+char *zstr_print(Allocator *allocator, const char *fmt, ...) {
+   char buffer[1024];
+   const size_t buffer_size = array_size(buffer);
+
+   va_list v;
+   va_start(v, fmt);
+   auto res = vsnprintf(buffer, buffer_size, fmt, v);
+   va_end(v);
+   assert(res >= 0);
+   if (res < buffer_size) {
+      buffer[res] = 0;
+      return zstr_dup(allocator, buffer, res + 1);
+   }
+
+   auto long_size = static_cast<size_t>(res + 1);
+   auto long_buffer = (char *) allocate_size(allocator, long_size);
+   va_start(v, fmt);
+   vsnprintf(long_buffer, long_size, fmt, v);
+   va_end(v);
+
+   long_buffer[res] = 0;
+   return long_buffer;
+}

data/ext/ruxml/memory.hpp

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <cstdlib>
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+
+#define array_size(_arr) ((int)(sizeof(_arr)/sizeof(*(_arr))))
+
+#define raw_allocate_size(size) (malloc(size))
+#define raw_allocate_size_zero(size) (calloc(1, size))
+#define raw_allocate_type(type) ((type *) malloc(sizeof(type)))
+#define raw_allocate_type_zero(type) ((type *) calloc(1, sizeof(type)))
+#define raw_allocate_array(type, size) ((type *) malloc(sizeof(type) * size))
+#define raw_allocate_string(size) ((char *) malloc(sizeof(char)*size))
+#define raw_allocate_string_zt(size) ((char *) calloc(1, sizeof(char)*(size+1)))
+#define raw_free(ptr) (free(ptr))
+
+/// ALLOCATOR
+
+using AllocatorAllocFunc = void *(*)(void *data, size_t size);
+using AllocatorFreeFunc = void (*)(void *data, void *ptr);
+
+struct Allocator {
+   AllocatorAllocFunc alloc;
+   AllocatorFreeFunc free;
+};
+
+inline void *allocator_raw_alloc(void *data, size_t size) {
+   return raw_allocate_size(size);
+}
+
+inline void allocator_raw_free(void *data, void *ptr) {
+   raw_free(ptr);
+}
+
+inline void allocator_noop_free(void *data, void *ptr) {
+}
+
+static Allocator raw_allocator = {allocator_raw_alloc, allocator_raw_free};
+
+inline Allocator *make_raw_allocator() { return &raw_allocator; }
+
+void *allocate_size_(void *data, size_t size);
+void allocate_free_(void *data, void *ptr);
+
+#define allocate_size(allocator, size) (allocate_size_(allocator, size))
+#define allocate_type(allocator, type) ((type*)allocate_size_(allocator, sizeof(type)))
+#define allocate_array(allocator, type, count) ((type*)allocate_size_(allocator, sizeof(type) * (count)))
+#define allocate_string(allocator, size) ((char *)allocate_size_(allocator, size))
+#define allocate_zstring(allocator, size) ((char *)allocate_size_(allocator, size + 1))
+#define allocate_free(allocator, ptr) (allocate_free_(allocator, ptr))
+
+/// ARENA
+
+struct MemoryArenaBlock {
+   size_t used;
+   size_t size;
+   MemoryArenaBlock *next;
+
+   uint8_t temp_count;
+   uint8_t *data;
+};
+
+struct MemoryArena {
+   Allocator allocator;
+   Allocator *base_allocator;
+   size_t min_block_size;
+   MemoryArenaBlock *block_first;
+   MemoryArenaBlock *block_last;
+   MemoryArenaBlock *free;
+
+#ifdef MEMORY_INFO
+   size_t memory_allocated;
+#endif
+
+#ifdef MEMORY_DEBUG
+   const char *name;
+#endif
+};
+
+struct TempSection {
+   MemoryArena *arena;
+   MemoryArenaBlock *block;
+   size_t mark;
+};
+
+void arena_init(MemoryArena *arena, const char *name, Allocator *allocator = make_raw_allocator());
+void arena_clear(MemoryArena *arena);
+void arena_destroy(MemoryArena *arena);
+void arena_stats(MemoryArena *arena, uint64_t *allocated_ptr, uint64_t *used_ptr);
+void arena_alloc_block(MemoryArena *arena, size_t size);
+void *arena_alloc(MemoryArena *arena, size_t size);
+
+#define arena_alloc_type(allocator, type) ((type*)arena_alloc(allocator, sizeof(type)))
+
+inline Allocator *arena_allocator(MemoryArena *arena) { return (Allocator *) (void *) arena; }
+
+TempSection begin_temp_section(MemoryArena *arena);
+void end_temp_section(TempSection section);
+
+inline void *allocator_arena_alloc(void *data, size_t size) {
+   return arena_alloc((MemoryArena *) data, size);
+}
+
+extern Allocator* temp_allocator;
+
+/// STRING
+
+char *zstr_dup(Allocator *allocator, const char *str, int64_t size);
+char *zstr_dup(Allocator *allocator, const char *str);
+char *zstr_print(Allocator *allocator, const char *fmt, ...);