lexlib 2.0.1

library with miscellaneous stuff
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

// Copyright 2023 alexevier <alexevier@proton.me>
// licensed under the zlib license <https://www.zlib.net/zlib_license.html>

#include"lexlib/linkedList.h"
#include<stdlib.h>
#include<string.h>

struct LexlibLinkedList lexlibLinkedListNew(void){
	return (struct LexlibLinkedList){
		.head = NULL,
		.count = 0,
	};
}

void lexlibLinkedListDelete(struct LexlibLinkedList* list){
	typeof(list->head) curr = list->head;
	typeof(list->head)* all = calloc(list->count, sizeof(list->head));
	
	for(size_t i = 0; ;i++){
		if(!curr)
			break;
		all[i] = curr;
		curr = curr->next;
	}
	
	for(size_t i = 0; i < list->count; i++){
		free(all[i]);
	}
	
	free(all);
	list->head = NULL;
	list->count = 0;
}

void lexlibLinkedListFree(struct LexlibLinkedList* list){
	LexlibLinkedNode* curr = list->head;
	LexlibLinkedNode* old = list->head;
	
	for(size_t i = 0; ;i++){
		if(!curr)
			break;
		if(curr->data)
			free(curr->data);
		old = curr;
		curr = curr->next;
		free(old);
	}
	
	list->head = NULL;
	list->count = 0;
}

uint8_t lexlibLinkedListAdd(struct LexlibLinkedList* list, void* data){
	struct LexlibLinkedNode* node = malloc(sizeof(struct LexlibLinkedNode));
	if(!node)
		return 1;
	
	node->data = data;
	node->next = NULL;
	
	if(list->head){
		typeof(list->head) newMem = realloc(list->head, (list->count+1) * sizeof(LexlibLinkedNode*));
		if(!newMem)
			return 1;
		list->head = newMem;
	}
	
	if(list->count == 0){
		list->head = node;
	} else {
		struct LexlibLinkedNode* curr = list->head;
		while(1){
			if(curr->next == NULL){
				curr->next = node;
				break;
			}
			curr = curr->next;
		}
	}
		
	list->count++;
	return 0;
}

void* lexlibLinkedListGet(struct LexlibLinkedList* list, size_t index){
	if(index >= list->count)
		return NULL;
	
	typeof(list->head) curr = list->head;
	for(size_t i = 0; i < index; i++)
		curr = curr->next;
	
	return curr->data;
}

uint8_t lexlibLinkedListAddCopy(struct LexlibLinkedList* list, void* data, size_t dataSize){
	void* newData = malloc(dataSize);
	if(!newData)
		return 1;
	
	memcpy(newData, data, dataSize);
	
	return lexlibLinkedListAdd(list, newData);
}