From 00bd026d740f913ac2b8f967657a3574b77726c5 Mon Sep 17 00:00:00 2001 From: victor Date: Tue, 8 Apr 2025 01:15:51 +0200 Subject: [PATCH] started lang --- lang/.asm-lsp.toml | 9 + lang/Makefile | 9 + lang/asem.s | 49 +++++ lang/debug | Bin 0 -> 9712 bytes lang/obj/asem.o | Bin 0 -> 2528 bytes lang/out | Bin 0 -> 16208 bytes lang/test.c | 5 + memory/allocator/allocator.h | 204 +++++++++++++++++++ memory/allocator/inc/arena.h | 152 ++++++++++++++ memory/arena/arena.h | 144 +++++++++++++ memory/{ => lst_memory}/Makefile | 0 memory/{ => lst_memory}/ft_free.c | 0 memory/{ => lst_memory}/list.c | 0 memory/{ => lst_memory}/list.h | 0 memory/{memory.c => lst_memory/lst_memory.c} | 2 +- memory/{memory.h => lst_memory/lst_memory.h} | 0 strings/strings.h | 35 ++++ 17 files changed, 608 insertions(+), 1 deletion(-) create mode 100644 lang/.asm-lsp.toml create mode 100644 lang/Makefile create mode 100644 lang/asem.s create mode 100755 lang/debug create mode 100644 lang/obj/asem.o create mode 100755 lang/out create mode 100644 lang/test.c create mode 100644 memory/allocator/allocator.h create mode 100644 memory/allocator/inc/arena.h create mode 100644 memory/arena/arena.h rename memory/{ => lst_memory}/Makefile (100%) rename memory/{ => lst_memory}/ft_free.c (100%) rename memory/{ => lst_memory}/list.c (100%) rename memory/{ => lst_memory}/list.h (100%) rename memory/{memory.c => lst_memory/lst_memory.c} (95%) rename memory/{memory.h => lst_memory/lst_memory.h} (100%) create mode 100644 strings/strings.h diff --git a/lang/.asm-lsp.toml b/lang/.asm-lsp.toml new file mode 100644 index 0000000..154d02c --- /dev/null +++ b/lang/.asm-lsp.toml @@ -0,0 +1,9 @@ +[[project]] +path = "./" +version = "0.10.0" +assembler = "nasm" +instruction_set = "x86-64" + +[project.opts] +diagnostics = true +default_diagnostics = true diff --git a/lang/Makefile b/lang/Makefile new file mode 100644 index 0000000..8b4ffd8 --- /dev/null +++ b/lang/Makefile @@ -0,0 +1,9 @@ +SRC := asem.s + + +OBJDIR := obj +OBJ := $(OBJDIR)/$(SRC:.s=.o) + +all: + nasm -felf64 -g $(SRC) -o $(OBJ) + ld -o debug $(OBJ) -nostdlib -static diff --git a/lang/asem.s b/lang/asem.s new file mode 100644 index 0000000..3834db9 --- /dev/null +++ b/lang/asem.s @@ -0,0 +1,49 @@ +%define DEF_BUFFER_LEN 4096 +%define INPUT_LENGTH 64 + +; rax -- syscall + +; type widths + +section .data + message: db "Hello World!", 0xA, 0 ; hello + message_length: equ $-message + +section .bss + arr: resb DEF_BUFFER_LEN + +section .text + global _start + +print_string: + push rbp + push rdx + mov rbp, rsp ; set up stack frame + + mov rax, 1 ; sys_write + + pop rdx + pop rbp + +exit: + mov rax, 60 + syscall + +strlen: + push rcx + xor rcx, rcx +.loop: + cmp byte [rdi + rcx], 0 + jz .done + inc rcx + jmp .loop +.done: + mov rax, rcx + pop rcx + ret + +_start: + mov rdi, message ; prepare first arg -> string addr to rdi + call strlen + mov rdi, rax + call exit diff --git a/lang/debug b/lang/debug new file mode 100755 index 0000000000000000000000000000000000000000..583635e26b5f4ca7c6b83f5b5d14dc47506bc941 GIT binary patch literal 9712 zcmeHNOKa3n6h6sx%CzbwznB=^^{osyi7$BPo zbs+DO)nE{p0JS;h3hV}ypaG{~oW+g|yU=O~kLv^BNevbUXpS{v!tbFpd-Zd6LE*XB;l$%1yTV3O@(&RlfKNubf#M z{SuEiiZA!_OFrU37WUi>yp5z6dRyHWd6IfjH}}v;;>?SKe&oT@t)~y|EAIStw{{hb z9a9ce%w7;ZvUtY6|0!!f?rkPz2m3-rP)3!)H&ZpC3g$~PcLQ`k(q{k)ass3HiryE&kZ z{X)5Ml59%5lk`Jqwc1&R2|=1eE9?Y$fU4gCaI;svJZPiNQ?56pm519oxGdJiY&666 z%cvEkxCO()?e^D`qO09b!!7B>U7YwIv>68QjNWfJt{`QZ*7vm9t7OtQjJ|kSj8xE-zEvL#8n~HSn|!HcW77+w;zdwF?7fA k5YJIKCqfCA+zW`QwOQ`PM?tjJ`6m%OF8{O05B`$>3!}!N$^ZZW literal 0 HcmV?d00001 diff --git a/lang/obj/asem.o b/lang/obj/asem.o new file mode 100644 index 0000000000000000000000000000000000000000..a4b0676797683a4c368d92b995b7aba5bbf410d7 GIT binary patch literal 2528 zcmbVN&1(};5TDJOnu@k*D=4VgSVR=rq>7%}5D%5bk3!WVtw_7uZqvXf8+Ny)f?%&b zco#38JbSb^D<1qfNdE!Bi%{@l51u^4nfI~TOxKGO_Pu$(`OTYo^FH!y>dwuaVSp9` zs?Z&26rk2sm0p8k7)YW2r&28XOy<6GNCG^9f)n;()C%}<|6NTiCRCwlSffW#q4<3o zP`&oAGMr6^HIV*{2F1KYD$KxZTS7a}iCk*Te^Bvgtt2O92iLIYbCRj8{1q+fIClyy z93!&!Ur9Wr!nrdDXXXE0#oti=l)v69f^_~a>U>VJFRBeWLxYrXZX0bJBl@QDpHBIb z%DGPw%gTRO`RhC>|0DSE`ajQ@6CwDe{7FxX_Se`;RCrEg`(kr^o8k)D`_}1n z?5&S`U$FJt3>$q6DL<`~jov*Hp5Ji^ zC%9hsX@%1~>SzdLmhsgv>5L)#4I9Nivv8_#zA%C{%2_aE)KoIJkZA(la>MvDa12}V zXM|}Px)x%t{$!Enuu&>i=SyRASQH1=w4GM7hRfJ-VeUzdUbtYs&5z;dGq ztk~O#5%Ao#`hpW;X*~o(&v!T`DeX14yy3KO>66fP zF+pA4E+jNlyr8`x-7+JU59LiF@6UdR|Noywn~{34G=EHZ9ejx@3fJdd46&jAOEpP ks}9~qBL>vbt~$#Pg0|L|13X8_b;4LixTpeA9kO=sFRMht?*IS* literal 0 HcmV?d00001 diff --git a/lang/out b/lang/out new file mode 100755 index 0000000000000000000000000000000000000000..75736712384abb133cb529002ba2b40b1b2fe2cf GIT binary patch literal 16208 zcmeHOZ)_Y#6`wuF$)&CT#7&Bugk%#OFVrTpHH0c zth;sUM3w3)1u3dpwE`jWg??!zgg{CqBqESnM-CBGd`N^;BEDb{krJSgs0F1IWqEJs z{m$!&-6DjLKs(XRZ{C~tdo%lHc0HS&d2aCF{+MMcq#E_OVkyD$#pQVmMcUy z@l|O6i27=KHj^pYL0-iRA_Bua?#kIVZE&_{InKniJlCWVJXSMrUU>7u11jMG5l@Z@ z|Ar-=CfZcT$qsU*Oy0EcOl%Q*Ah*GZk$PBj#&!O3S$Kp>G$vb8=rpzbFkg3J-e7^S#<1&*kvg|16}(qk%0ih4i== zSbrs?=Q)bB7}77hUsBp)9f3R|K#4GlKoo%}0#O8_2t*NxA`nI3e=q{?H*EWR`t+aT z=@)CyCzVQnZQhIdm(r&%#213A@w?t3wZH2Zls9ZoQHkYAuDibI`#$qK-Wxh|`RVkT z-=$Cg{>JdgV8?vN&(kmU{F-e1O;3{f2NQ{g?JorWNdG2j(l6D1kKy54-X?1LaV}HS z>;1)s?Q?9nAV~Jl2lid37#_HtK64{|{?EPX^S5f!*2VPY+ulZUP$v%J{^CT#_JJin z_iwJJhpN@g?&ImxJ%310F@5H$SC@XVr=IlwrYoenHcl6Fv34UVtgkFA^><-nsm#~U z{;uc9_Bi=C$34Av{kHE1CE~quju+=|bC!M!?*KopBe9`&;oM_{Pc+m9#&1(uJx$U= z;4>J5YSg(dN>K!&2t*NxA`nF&ia->BC<0Lgq6kD0h$0Y0;6E1u{?27>sd>~Um;8Na z>kZ!@A$*LGUst0iJ=R~hc9eHDGkb&hM`YO$I$O9Vn>@e zg9Lx~i452#1-x5+Atb>ND=^#<49EdJ?Ba3EtG=ruNw*Gm0|BEuir`EO%&|G3d` zH#WG69{WwxZlO@Jzg#L8vODfN(BJ=v-Ab?C57-@hXajDC-PzvR)!y0uIrR|n^cd+# z56e8;ZL|Y%j0$>;;}&dB3x{no6?ZC8QOU{Dl$$(}ANNY-WG?R|sZc6Zl7&n$msE%Q zjvcb88{LWa-O8Ga!4Vo!)&~05WHqj>iEoMTir-6v5lg5IR*GlI0R3vzrzy9rkLv3v z56(Z(2wG@9aJ0Vaw`PMiI{MlZ$=}S}J-=`IxR2qF|F6YT_p66eS_AtB1F=q-A!!$VArxy?b&1|H^sHW~pO28< zQk#@HpZWtojcSb@6sp;msASPyiu)NA1u8T_2;mtj+aVdni-Epb#Z%B|e1l*mKR+UU zBgJ!9O4}iSiwaG#`s(u#`U_NGd(;1A(%Uc!;Ubkc#F`cE7gW8+dPSpYYYp!Ee~{Qn z2hh>EqfXd*dui;;kmPv2a!vZOFO+YS$Oy-Rv6=8F?0lrv*vW%mRm zIw<2BGx^^Wc|F8y2&_ABE(vHGZn3_Ans=9l`O~tX0k*(U5YGpw`=~&-V72|#&c(r= zZNrJr^Zbq09O(a9X&;F79Q{QMlG*=bq~$dl_?Lta{H~@c{zJ-bgOByplcZw`_*fSL zu?{4YAesFiCoQk3z{ffYST8*EA9lcLs^>KtWUSMG`tP7VV;AnfxK+f%u`9%+lH0>b+e;|B}-x}})Tc|#qz=Q55 zRNzYlztz??z-P5s%`tvZ{FDme`~P)Y*8oM-O3Kale@Qx?<8s?o-_vjo(QFSg@HfQe zwIuj>k2}{!N=mTP(vl4QAE|=p9{5=2;XEn=gZT*_=D`QV<@iT8KGu!bgl|`wx&R)KR_4q2SkJ}VwLLHU!wEd-;>2ei`j7S0F5$; +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2025/04/05 17:04:18 by victor #+# #+# */ +/* Updated: 2025/04/06 16:30:24 by victor ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef ALLOCATOR_H +# define ALLOCATOR_H + + +# include "inc/arena.h" + +typedef struct s_alloc { + void *mem; + size_t size; +} t_alloc; + +typedef t_arena t_vector ; + +typedef struct s_allocator { + void *mem; + t_vector allocs; + size_t cap; + t_vector free; // this will be used as Array of t_alloc +} t_allocator; + +//global allocator that will be used by this lib +static t_allocator *allocator_get(void) { + static t_allocator a = { 0 }; + return &a; +} + +void allocator_init(size_t base_mem); +void *alloc(uint64_t size); +void *zalloc(uint32_t size); +void dealloc(void *ptr); +void allocator_shutdown(void); + +#ifdef ALLOCATOR_IMPLEMENTATION + +#include +#include +#include +#include "allocator.h" +#include + +void allocator_init(size_t base_mem) { + t_allocator *allocator = allocator_get(); + + allocator->free = arena_create_growing(sizeof(t_alloc) * 1000); + allocator->mem = calloc(base_mem, sizeof((char)0)); + allocator->allocs = arena_create_growing(sizeof(t_alloc) * 1000); + allocator->cap = base_mem; +} + +void vector_push(t_vector *vec, void *mem, size_t memsize) { + assert(memsize < (vec->cap - vec->used)); + void *ptr = arena_alloc(vec, memsize); + assert(ptr); + memmove(ptr, mem, memsize); +} + +void vector_pop(t_vector *vec, size_t memsize) { + assert(memsize <= vec->used); + memset(&((uint8_t *)vec->mem)[vec->used - memsize], 0, memsize); +} + +// offset is used to know where to dereference the memory to find the value to be sorted by +void vector_insert_sorted(t_vector *vec, void *mem, uint32_t memsize, uint32_t offset) { + uint32_t low_pos = 0; + uint32_t high_pos = vec->count - (vec->count > 0); + int32_t position = 0; + t_alloc *cursor = &((t_alloc *)vec->mem)[high_pos]; + uint32_t new_alloc_size = *((uint8_t *)mem + offset); + + if (new_alloc_size > cursor->size || vec->count == 0) { + vector_push(vec, mem, memsize); + } else { + while (low_pos < high_pos) { + position = low_pos + (high_pos - low_pos) / 2; + cursor = &((t_alloc *)vec->mem)[position]; + assert((uint8_t *)cursor - (uint8_t *)vec->mem >= 0); + assert((uint8_t *)vec->mem + vec->used - (uint8_t *)cursor >= 0); + if (cursor->size < new_alloc_size) { + low_pos = position + 1; + } else if (cursor->size > new_alloc_size) { + high_pos = position - 1; + } else { + break ; + } + } + void *ptr = arena_alloc(vec, memsize); + memmove(ptr, &cursor, sizeof(*cursor) * (vec->count - low_pos)); + memmove(&cursor, mem, memsize); + } +} + +void vector_remove(t_vector *vec, uint32_t index, size_t memsize) { + assert(index <= vec->count); + void *item = (void *)&((uint8_t *)vec->mem)[index * memsize]; + memmove(item, (uint8_t *)item + memsize, (vec->count - index) * memsize); + vec->count--; + vec->used -= memsize; +} + +void *alloc(uint64_t size) { + void *ptr = NULL; + t_allocator *allocator = allocator_get(); + + if (size > 0) { + t_alloc *tail = &((t_alloc *)allocator->free.mem)[allocator->free.count - (allocator->free.count > 0)]; + if (allocator->free.count > 0 && tail->size >= size) { + assert(tail->mem); + uint32_t position = allocator->free.count / 2; + t_alloc *candidate = NULL; + uint32_t range = size / 20; + uint32_t last_pos = position; + while (1) { + t_alloc *cursor = &((t_alloc *)allocator->free.mem)[position]; + if (cursor->size > size + range) { + if (cursor->size < candidate->size) { + candidate = cursor; + } + position <<= 1; + } else if (cursor->size < size) { + position += position >> 1; + } else if ((cursor->size >= size && cursor->size <= size + range) || position == last_pos) { + ptr = cursor->mem; + t_alloc new = { ptr, size }; + t_alloc old = { (uint8_t *)ptr + size, cursor->size - size }; + vector_insert_sorted(&allocator->allocs, &new, sizeof(new), offsetof(t_alloc, size)); + vector_insert_sorted(&allocator->allocs, &old, sizeof(old), offsetof(t_alloc, size)); + vector_insert_sorted(&allocator->free, &old, sizeof(old), offsetof(t_alloc, size)); + vector_remove(&allocator->free, position, sizeof(*cursor)); + break ; + } + } + } else { + t_alloc *tail = &((t_alloc *)allocator->allocs.mem)[allocator->allocs.count - (allocator->allocs.count > 0)]; + if (tail->mem == NULL) { + ptr = allocator->mem; + } else { + ptr = (uint8_t *)tail->mem + tail->size; + } + t_alloc new = (t_alloc){ ptr, size }; + vector_push(&allocator->allocs, &new, sizeof(new)); + } + } + return ptr; +} + +void *zalloc(uint32_t size) { + uint8_t *ptr = NULL; + + ptr = alloc(size); + for (uint i = 0; i < size; ++i) { + ptr[i] = 0; + } + return ptr; +} + +void dealloc(void *ptr) { + t_allocator *allocator = allocator_get(); + for (uint32_t i = 0; i < allocator->allocs.count; ++i) { + if (((t_alloc *)allocator->allocs.mem)[i].mem == ptr) { + t_alloc move = ((t_alloc *)allocator->allocs.mem)[i]; + memset(move.mem, 'X', move.size); + vector_remove(&allocator->allocs, i, sizeof(move)); + vector_insert_sorted(&allocator->free, &move, sizeof(move), offsetof(t_alloc, size)); + break ; + } + } +} + +void allocator_print(void) { + t_allocator *allocator = allocator_get(); + printf( "---- Allocator ----\n" + "capacity: %lu\n", allocator->cap); + printf("currently used mem: \n"); + arena_print(&allocator->allocs); + printf("currently freed mem: \n"); + arena_print(&allocator->free); + printf("alloc mem start: %p\n", allocator->mem); + + print_memory(allocator->mem, 0, allocator->cap); +} + +void allocator_shutdown() { + t_allocator *allocator = allocator_get(); + + arena_destroy(&allocator->free); + arena_destroy(&allocator->allocs); + free(allocator->mem); + memset(allocator, 0, sizeof(*allocator)); +} + +#endif // ALLOCATOR_IMPLEMENTATION +#endif // !ALLOCATOR_H diff --git a/memory/allocator/inc/arena.h b/memory/allocator/inc/arena.h new file mode 100644 index 0000000..c10572c --- /dev/null +++ b/memory/allocator/inc/arena.h @@ -0,0 +1,152 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* arena.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: victor +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2025/04/05 12:45:17 by victor #+# #+# */ +/* Updated: 2025/04/06 16:05:54 by victor ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef ARENA_H +# define ARENA_H + +# include +# include +# include +# include +# include +# include +# include + +# define BYTE_WIDTH 8 +# define DISPLAY_WIDTH sizeof((void *)0) * 2 + +typedef struct s_arena { + void *mem; + size_t cap; + size_t used; + bool grow; + uint32_t count; +} t_arena; + +t_arena arena_create(size_t size); +t_arena arena_create_growing(size_t size); +void *arena_alloc(t_arena *arena, size_t size); +void arena_destroy(t_arena *arena); +void arena_clear(t_arena *arena); +void arena_reset(t_arena *arena); +void arena_grow(t_arena *arena, size_t size); +void arena_print(t_arena *arena); +void print_memory(void *mem, size_t memstart, size_t memend); + +#define ARENA_IMPLEMENTATION + +# ifdef ARENA_IMPLEMENTATION + + +t_arena arena_create_growing(size_t size) { + t_arena arena = {0}; + + arena.cap = size; + arena.used = 0; + arena.mem = calloc(1, size); + arena.grow = true; + if (!arena.mem) { + return (t_arena){0}; + } + return (arena); +} + +t_arena arena_create(size_t size) { + t_arena arena = {0}; + + arena.cap = size; + arena.used = 0; + arena.mem = calloc(1, size); + arena.grow = false; + if (!arena.mem) { + return (t_arena){0}; + } + return (arena); +} + +void arena_grow(t_arena *arena, size_t size) { + void *new_mem; + uint new_size; + + new_size = arena->cap * (size / arena->cap + 1); + + new_mem = realloc(arena->mem, new_size); + arena->mem = new_mem; + assert(new_mem != NULL); + arena->cap = new_size; + + // size = 58, cap = 8 +} + +void *arena_alloc(t_arena *arena, size_t size) { + void *ptr = NULL; + + if (arena->used + size > arena->cap) { + if (arena->grow == true) { + arena_grow(arena, size); + } else { + assert(false && "Arena overflow detected"); + } + } + + ptr = (uint8_t *)arena->mem + arena->used; + arena->used += size; + arena->count++; + return ptr; +} + +void arena_clear(t_arena *arena) { + arena->used = 0; + arena->count = 0; +} + +void arena_reset(t_arena *arena) { + arena_clear(arena); + memset(arena->mem, 0, arena->cap); +} + +void arena_destroy(t_arena *arena) { + free(arena->mem); + memset(arena, 0, sizeof(*arena)); +} + +void print_memory(void *mem, size_t memstart, size_t memend) { + printf("---- Memory Section Start ----\n"); + for (uint32_t i = memstart; i < memend; i += DISPLAY_WIDTH) { + printf("%p:", &((uint8_t *)mem)[i]); + for (uint32_t j = 0; j < DISPLAY_WIDTH / 2; ++j) { + uint16_t val = ((uint16_t *)&(((uint8_t *)mem)[i]))[j]; + printf(" %04x", val); + } + printf(" "); + printf("|"); + for (uint32_t j = 0; j < DISPLAY_WIDTH; ++j) { + uint8_t value = ((uint8_t *)mem)[i + j]; + if (isalnum(value)) { + printf("%c", value); + } + else{ + printf("."); + } + } + printf("|"); + printf("\n"); + } + printf("---- Memory Section End ----\n"); +} + +void arena_print(t_arena *arena) { + print_memory(arena->mem, 0, arena->cap); +} + +# endif // !ARENA_IMPLEMENTATION +#endif // !ARENA_H diff --git a/memory/arena/arena.h b/memory/arena/arena.h new file mode 100644 index 0000000..993ca96 --- /dev/null +++ b/memory/arena/arena.h @@ -0,0 +1,144 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* arena.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: victor +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2025/04/05 12:45:17 by victor #+# #+# */ +/* Updated: 2025/04/05 17:07:03 by victor ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef ARENA_H +# define ARENA_H + +# include +# include +# include +# include +# include +# include +# include + +# define BYTE_WIDTH 8 +# define DISPLAY_WIDTH sizeof((void *)0) * 2 + +typedef struct s_alloc { + void *ptr; + size_t size; +} t_alloc; + +typedef struct s_arena { + void *mem; + size_t cap; + size_t used; + bool grow; +} t_arena; + +t_arena arena_create(size_t size); +t_arena arena_create_growing(size_t size); +void *arena_alloc(t_arena *arena, size_t size); +void arena_destroy(t_arena *arena); +void arena_clear(t_arena *arena); +void arena_reset(t_arena *arena); +void arena_grow(t_arena *arena, size_t size); +void arena_print(t_arena *arena); + +# ifdef ARENA_IMPLEMENTATION + +t_arena arena_create_growing(size_t size) { + t_arena arena; + + arena.cap = size; + arena.used = 0; + arena.mem = calloc(1, size); + arena.grow = true; + if (!arena.mem) { + return (t_arena){0}; + } + return (arena); +} + +t_arena arena_create(size_t size) { + t_arena arena = {0}; + + arena.cap = size; + arena.used = 0; + arena.mem = calloc(1, size); + arena.grow = false; + if (!arena.mem) { + return (t_arena){0}; + } + return (arena); +} + +void arena_grow(t_arena *arena, size_t size) { + void *new_mem; + uint new_size; + + new_size = arena->cap * (size / arena->cap + 1); + + new_mem = realloc(arena->mem, new_size); + arena->mem = new_mem; + assert(new_mem != NULL); + arena->cap = new_size; + + // size = 58, cap = 8 +} + +void *arena_alloc(t_arena *arena, size_t size) { + void *ptr = NULL; + + if (arena->used + size > arena->cap) { + if (arena->grow == true) { + arena_grow(arena, size); + } else { + assert(false && "Arena overflow detected"); + } + } + + ptr = arena->mem + arena->used; + arena->used += size; + return ptr; +} + +void arena_clear(t_arena *arena) { + arena->used = 0; +} + +void arena_reset(t_arena *arena) { + arena_clear(arena); + memset(arena->mem, 0, arena->cap); +} + +void arena_destroy(t_arena *arena) { + free(arena->mem); + memset(arena, 0, sizeof(*arena)); +} + +void arena_print(t_arena *arena) { + printf("---- Arena Start ----\n"); + for (uint i = 0; i < arena->cap; i += DISPLAY_WIDTH) { + printf("%p\t", arena->mem + i); + for (uint j = 0; j < DISPLAY_WIDTH; ++j) { + printf("%02x ", *(char *)(arena->mem + i + j)); + } + printf("\t"); + printf("|"); + for (uint j = 0; j < DISPLAY_WIDTH; ++j) { + uint8_t value = *(char *)(arena->mem + i + j); + if (isalnum(value)) { + printf("%c", value); + } else { + printf("."); + } + } + printf("|"); + printf("\n"); + } + printf("---- Arena End ----\n"); +} + +# endif // !ARENA_IMPLEMENTATION +#endif // !ARENA_H diff --git a/memory/Makefile b/memory/lst_memory/Makefile similarity index 100% rename from memory/Makefile rename to memory/lst_memory/Makefile diff --git a/memory/ft_free.c b/memory/lst_memory/ft_free.c similarity index 100% rename from memory/ft_free.c rename to memory/lst_memory/ft_free.c diff --git a/memory/list.c b/memory/lst_memory/list.c similarity index 100% rename from memory/list.c rename to memory/lst_memory/list.c diff --git a/memory/list.h b/memory/lst_memory/list.h similarity index 100% rename from memory/list.h rename to memory/lst_memory/list.h diff --git a/memory/memory.c b/memory/lst_memory/lst_memory.c similarity index 95% rename from memory/memory.c rename to memory/lst_memory/lst_memory.c index 7bf9ede..b03f5f5 100644 --- a/memory/memory.c +++ b/memory/lst_memory/lst_memory.c @@ -1,7 +1,7 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* memory.c :+: :+: :+: */ +/* lst_memory.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: vvobis +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ diff --git a/memory/memory.h b/memory/lst_memory/lst_memory.h similarity index 100% rename from memory/memory.h rename to memory/lst_memory/lst_memory.h diff --git a/strings/strings.h b/strings/strings.h new file mode 100644 index 0000000..1a2c865 --- /dev/null +++ b/strings/strings.h @@ -0,0 +1,35 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* strings.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: victor +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2025/04/05 12:40:51 by victor #+# #+# */ +/* Updated: 2025/04/05 13:11:53 by victor ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef STRINGS_H +# define STRINGS_H + +#include +#include +#include + +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; +typedef int8_t i8; +typedef int16_t i16; +typedef int32_t i32; +typedef int64_t i64; + +typedef struct s_string { + char *str; + u64 len; + u64 capacity; +} t_string; + +#endif