Add a basic symbol checker

author: Bad Diode <bd@badd10de.dev> 2024-06-21 11:40:31 +0200
committer: Bad Diode <bd@badd10de.dev> 2024-06-21 11:40:31 +0200
commit: 4646adb64119d9bd761447024a2f35cc0c9c2115 (patch)
tree: 116dfd0f2ad27933639188e6d29eec42305124d7 /src/badlib.h
parent: c10fe9d48d40e3fa2a20ee61b79518dfbaeb4db9 (diff)
download: bdl-4646adb64119d9bd761447024a2f35cc0c9c2115.tar.gz
bdl-4646adb64119d9bd761447024a2f35cc0c9c2115.zip
1 files changed, 108 insertions, 110 deletions
diff --git a/src/badlib.h b/src/badlib.h
index ada309a..e6f0df6 100644
--- a/src/badlib.h
+++ b/src/badlib.h
@@ -818,117 +818,116 @@ queue_pop(Queue *l) {
 // Specialiced commonly used hash sets/maps as macro definitions. There is no
 // delete on these ones but are trivial to implement!
-#define SETDEF(STRUCTNAME, FUNCNAME, KEYTYPE, HASHFUNC, EQFUNC) \
+#define SETDEF(STRUCTNAME, FUNCNAME, KEYTYPE, HASHFUNC, EQFUNC)            \
-    typedef struct STRUCTNAME { \
+    typedef struct STRUCTNAME {                                            \
-        struct STRUCTNAME *child[4]; \
+        struct STRUCTNAME *child[4];                                       \
-        KEYTYPE key; \
+        KEYTYPE key;                                                       \
-    } STRUCTNAME; \
+    } STRUCTNAME;                                                          \
-    STRUCTNAME *\
+    STRUCTNAME *FUNCNAME##_lookup(STRUCTNAME **m, KEYTYPE key) {           \
-    FUNCNAME##_lookup(STRUCTNAME **m, KEYTYPE key) {\
+        u64 h = HASHFUNC(key);                                             \
-        u64 h = HASHFUNC(key);\
+        while (*m) {                                                       \
-        while (*m) {\
+            if (EQFUNC(key, (*m)->key)) {                                  \
-            if (EQFUNC(key, (*m)->key)) {\
+                return *m;                                                 \
-                return *m;\
+            }                                                              \
-            }\
+            h = (h << 2) | (h >> 62);                                      \
-            h = (h << 2) | (h >> 62);\
+            m = &(*m)->child[h & 0x3];                                     \
-            m = &(*m)->child[h & 0x3];\
+        }                                                                  \
-        }\
+        return NULL;                                                       \
-        return NULL;\
+    }                                                                      \
-    }\
+    STRUCTNAME *FUNCNAME##_insert(STRUCTNAME **m, KEYTYPE key, Arena *a) { \
-    STRUCTNAME *\
+        u64 h = HASHFUNC(key);                                             \
-    FUNCNAME##_insert(STRUCTNAME **m, KEYTYPE key, Arena *a) {\
+        while (*m) {                                                       \
-        u64 h = HASHFUNC(key);\
+            if (EQFUNC(key, (*m)->key)) {                                  \
-        while (*m) {\
+                return *m;                                                 \
-            if (EQFUNC(key, (*m)->key)) {\
+            }                                                              \
-                return *m;\
+            h = (h << 2) | (h >> 62);                                      \
-            }\
+            m = &(*m)->child[h & 0x3];                                     \
-            h = (h << 2) | (h >> 62);\
+        }                                                                  \
-            m = &(*m)->child[h & 0x3];\
+        *m = arena_calloc(sizeof(STRUCTNAME), a);                          \
-        }\
+        (*m)->key = key;                                                   \
-        *m = arena_calloc(sizeof(STRUCTNAME), a);\
+        return *m;                                                         \
-        (*m)->key = key;\
+    }                                                                      \
-        return *m;\
+    typedef Queue STRUCTNAME##Iter;                                        \
-    }\
+    STRUCTNAME##Iter FUNCNAME##_iterator(STRUCTNAME *map, Arena *a) {      \
-    typedef Queue STRUCTNAME##Iter;\
+        STRUCTNAME##Iter it = {0};                                         \
-    STRUCTNAME##Iter\
+        queue_push(&it, map, a);                                           \
-    FUNCNAME##_iterator(STRUCTNAME *map, Arena *a) {\
+        return it;                                                         \
-        STRUCTNAME##Iter it = {0};\
+    }                                                                      \
-        queue_push(&it, map, a);\
+    STRUCTNAME *FUNCNAME##_next(STRUCTNAME##Iter *it, Arena *a) {          \
-        return it;\
+        assert(it);                                                        \
-    }\
+        assert(a);                                                         \
-    STRUCTNAME *\
+        while (it->head) {                                                 \
-    FUNCNAME##_next(STRUCTNAME##Iter *it, Arena *a) {\
+            STRUCTNAME *item = (STRUCTNAME *)queue_pop(it);                \
-        assert(it);\
+            if (!item) {                                                   \
-        assert(a);\
+                return NULL;                                               \
-        while (it->head) {\
+            }                                                              \
-            STRUCTNAME *item = (STRUCTNAME *)queue_pop(it);\
+            for (sz i = 0; i < 4; i++) {                                   \
-            for (sz i = 0; i < 4; i++) {\
+                STRUCTNAME *child = item->child[i];                        \
-                STRUCTNAME *child = item->child[i];\
+                if (child) {                                               \
-                if (child) {\
+                    queue_push(it, child, a);                              \
-                    queue_push(it, child, a);\
+                }                                                          \
-                }\
+            }                                                              \
-            }\
+            return item;                                                   \
-            return item;\
+        }                                                                  \
-        }\
+        return NULL;                                                       \
-        return NULL;\
    }
-#define MAPDEF(STRUCTNAME, FUNCNAME, KEYTYPE, VALTYPE, HASHFUNC, EQFUNC) \
+#define MAPDEF(STRUCTNAME, FUNCNAME, KEYTYPE, VALTYPE, HASHFUNC, EQFUNC)    \
-    typedef struct STRUCTNAME { \
+    typedef struct STRUCTNAME {                                             \
-        struct STRUCTNAME *child[4]; \
+        struct STRUCTNAME *child[4];                                        \
-        KEYTYPE key; \
+        KEYTYPE key;                                                        \
-        VALTYPE val; \
+        VALTYPE val;                                                        \
-    } STRUCTNAME;\
+    } STRUCTNAME;                                                           \
-    STRUCTNAME *\
+    STRUCTNAME *FUNCNAME##_insert(STRUCTNAME **m, KEYTYPE key, VALTYPE val, \
-    FUNCNAME##_insert(STRUCTNAME **m, KEYTYPE key, VALTYPE val, Arena *a) {\
+                                  Arena *a) {                               \
-        u64 h = HASHFUNC(key);\
+        u64 h = HASHFUNC(key);                                              \
-        while (*m) {\
+        while (*m) {                                                        \
-            if (EQFUNC(key, (*m)->key)) {\
+            if (EQFUNC(key, (*m)->key)) {                                   \
-                (*m)->val = val;\
+                (*m)->val = val;                                            \
-                return *m;\
+                return *m;                                                  \
-            }\
+            }                                                               \
-            h = (h << 2) | (h >> 62);\
+            h = (h << 2) | (h >> 62);                                       \
-            m = &(*m)->child[h & 0x3];\
+            m = &(*m)->child[h & 0x3];                                      \
-        }\
+        }                                                                   \
-        *m = arena_calloc(sizeof(STRUCTNAME), a);\
+        *m = arena_calloc(sizeof(STRUCTNAME), a);                           \
-        (*m)->key = key;\
+        (*m)->key = key;                                                    \
-        (*m)->val = val;\
+        (*m)->val = val;                                                    \
-        return *m;\
+        return *m;                                                          \
-    }\
+    }                                                                       \
-    STRUCTNAME *\
+    STRUCTNAME *FUNCNAME##_lookup(STRUCTNAME **m, KEYTYPE key) {            \
-    FUNCNAME##_lookup(STRUCTNAME **m, KEYTYPE key) {\
+        u64 h = HASHFUNC(key);                                              \
-        u64 h = HASHFUNC(key);\
+        while (*m) {                                                        \
-        while (*m) {\
+            if (EQFUNC(key, (*m)->key)) {                                   \
-            if (EQFUNC(key, (*m)->key)) {\
+                return *m;                                                  \
-                return *m;\
+            }                                                               \
-            }\
+            h = (h << 2) | (h >> 62);                                       \
-            h = (h << 2) | (h >> 62);\
+            m = &(*m)->child[h & 0x3];                                      \
-            m = &(*m)->child[h & 0x3];\
+        }                                                                   \
-        }\
+        return NULL;                                                        \
-        return NULL;\
+    }                                                                       \
-    }\
+    typedef Queue STRUCTNAME##Iter;                                         \
-    typedef Queue STRUCTNAME##Iter;\
+    STRUCTNAME##Iter FUNCNAME##_iterator(STRUCTNAME *map, Arena *a) {       \
-    STRUCTNAME##Iter\
+        STRUCTNAME##Iter it = {0};                                          \
-    FUNCNAME##_iterator(STRUCTNAME *map, Arena *a) {\
+        queue_push(&it, map, a);                                            \
-        STRUCTNAME##Iter it = {0};\
+        return it;                                                          \
-        queue_push(&it, map, a);\
+    }                                                                       \
-        return it;\
+    STRUCTNAME *FUNCNAME##_next(STRUCTNAME##Iter *it, Arena *a) {           \
-    }\
+        assert(it);                                                         \
-    STRUCTNAME *\
+        assert(a);                                                          \
-    FUNCNAME##_next(STRUCTNAME##Iter *it, Arena *a) {\
+        while (it->head) {                                                  \
-        assert(it);\
+            STRUCTNAME *item = (STRUCTNAME *)queue_pop(it);                 \
-        assert(a);\
+            if (!item) {                                                    \
-        while (it->head) {\
+                return NULL;                                                \
-            STRUCTNAME *item = (STRUCTNAME *)queue_pop(it);\
+            }                                                               \
-            for (sz i = 0; i < 4; i++) {\
+            for (sz i = 0; i < 4; i++) {                                    \
-                STRUCTNAME *child = item->child[i];\
+                STRUCTNAME *child = item->child[i];                         \
-                if (child) {\
+                if (child) {                                                \
-                    queue_push(it, child, a);\
+                    queue_push(it, child, a);                               \
-                }\
+                }                                                           \
-            }\
+            }                                                               \
-            return item;\
+            return item;                                                    \
-        }\
+        }                                                                   \
-        return NULL;\
+        return NULL;                                                        \
    }
 u64
@@ -951,7 +950,6 @@ _int_hash(sz a) {
    return a * UINT64_C(11400714819323198485);
 }
 // Commonly used map/set types.
 SETDEF(StrSet, strset, Str, str_hash, str_eq)
 MAPDEF(StrIntMap, strintmap, Str, sz, str_hash, str_eq)
author	Bad Diode <bd@badd10de.dev>	2024-06-21 11:40:31 +0200
committer	Bad Diode <bd@badd10de.dev>	2024-06-21 11:40:31 +0200
commit	4646adb64119d9bd761447024a2f35cc0c9c2115 (patch)
tree	116dfd0f2ad27933639188e6d29eec42305124d7 /src/badlib.h
parent	c10fe9d48d40e3fa2a20ee61b79518dfbaeb4db9 (diff)
download	bdl-4646adb64119d9bd761447024a2f35cc0c9c2115.tar.gz bdl-4646adb64119d9bd761447024a2f35cc0c9c2115.zip

diff --git a/src/badlib.h b/src/badlib.h index ada309a..e6f0df6 100644 --- a/src/badlib.h +++ b/src/badlib.h
@@ -818,117 +818,116 @@ queue_pop(Queue *l) {
818		818
819	// Specialiced commonly used hash sets/maps as macro definitions. There is no	819	// Specialiced commonly used hash sets/maps as macro definitions. There is no
820	// delete on these ones but are trivial to implement!	820	// delete on these ones but are trivial to implement!
821	#define SETDEF(STRUCTNAME, FUNCNAME, KEYTYPE, HASHFUNC, EQFUNC) \	821	#define SETDEF(STRUCTNAME, FUNCNAME, KEYTYPE, HASHFUNC, EQFUNC) \
822	typedef struct STRUCTNAME { \	822	typedef struct STRUCTNAME { \
823	struct STRUCTNAME *child[4]; \	823	struct STRUCTNAME *child[4]; \
824	KEYTYPE key; \	824	KEYTYPE key; \
825	} STRUCTNAME; \	825	} STRUCTNAME; \
826	STRUCTNAME *\	826	STRUCTNAME FUNCNAME##_lookup(STRUCTNAME *m, KEYTYPE key) { \
827	FUNCNAME##_lookup(STRUCTNAME **m, KEYTYPE key) {\	827	u64 h = HASHFUNC(key); \
828	u64 h = HASHFUNC(key);\	828	while (*m) { \
829	while (*m) {\	829	if (EQFUNC(key, (*m)->key)) { \
830	if (EQFUNC(key, (*m)->key)) {\	830	return *m; \
831	return *m;\	831	} \
832	}\	832	h = (h << 2) \| (h >> 62); \
833	h = (h << 2) \| (h >> 62);\	833	m = &(*m)->child[h & 0x3]; \
834	m = &(*m)->child[h & 0x3];\	834	} \
835	}\	835	return NULL; \
836	return NULL;\	836	} \
837	}\	837	STRUCTNAME FUNCNAME##_insert(STRUCTNAME m, KEYTYPE key, Arena a) { \
838	STRUCTNAME *\	838	u64 h = HASHFUNC(key); \
839	FUNCNAME##_insert(STRUCTNAME *m, KEYTYPE key, Arena a) {\	839	while (*m) { \
840	u64 h = HASHFUNC(key);\	840	if (EQFUNC(key, (*m)->key)) { \
841	while (*m) {\	841	return *m; \
842	if (EQFUNC(key, (*m)->key)) {\	842	} \
843	return *m;\	843	h = (h << 2) \| (h >> 62); \
844	}\	844	m = &(*m)->child[h & 0x3]; \
845	h = (h << 2) \| (h >> 62);\	845	} \
846	m = &(*m)->child[h & 0x3];\	846	*m = arena_calloc(sizeof(STRUCTNAME), a); \
847	}\	847	(*m)->key = key; \
848	*m = arena_calloc(sizeof(STRUCTNAME), a);\	848	return *m; \
849	(*m)->key = key;\	849	} \
850	return *m;\	850	typedef Queue STRUCTNAME##Iter; \
851	}\	851	STRUCTNAME##Iter FUNCNAME##_iterator(STRUCTNAME map, Arena a) { \
852	typedef Queue STRUCTNAME##Iter;\	852	STRUCTNAME##Iter it = {0}; \
853	STRUCTNAME##Iter\	853	queue_push(&it, map, a); \
854	FUNCNAME##_iterator(STRUCTNAME map, Arena a) {\	854	return it; \
855	STRUCTNAME##Iter it = {0};\	855	} \
856	queue_push(&it, map, a);\	856	STRUCTNAME FUNCNAME##_next(STRUCTNAME##Iter it, Arena *a) { \
857	return it;\	857	assert(it); \
858	}\	858	assert(a); \
859	STRUCTNAME *\	859	while (it->head) { \
860	FUNCNAME##_next(STRUCTNAME##Iter it, Arena a) {\	860	STRUCTNAME item = (STRUCTNAME )queue_pop(it); \
861	assert(it);\	861	if (!item) { \
862	assert(a);\	862	return NULL; \
863	while (it->head) {\	863	} \
864	STRUCTNAME item = (STRUCTNAME )queue_pop(it);\	864	for (sz i = 0; i < 4; i++) { \
865	for (sz i = 0; i < 4; i++) {\	865	STRUCTNAME *child = item->child[i]; \
866	STRUCTNAME *child = item->child[i];\	866	if (child) { \
867	if (child) {\	867	queue_push(it, child, a); \
868	queue_push(it, child, a);\	868	} \
869	}\	869	} \
870	}\	870	return item; \
871	return item;\	871	} \
872	}\	872	return NULL; \
873	return NULL;\
874	}	873	}
875		874
876	#define MAPDEF(STRUCTNAME, FUNCNAME, KEYTYPE, VALTYPE, HASHFUNC, EQFUNC) \	875	#define MAPDEF(STRUCTNAME, FUNCNAME, KEYTYPE, VALTYPE, HASHFUNC, EQFUNC) \
877	typedef struct STRUCTNAME { \	876	typedef struct STRUCTNAME { \
878	struct STRUCTNAME *child[4]; \	877	struct STRUCTNAME *child[4]; \
879	KEYTYPE key; \	878	KEYTYPE key; \
880	VALTYPE val; \	879	VALTYPE val; \
881	} STRUCTNAME;\	880	} STRUCTNAME; \
882	STRUCTNAME *\	881	STRUCTNAME FUNCNAME##_insert(STRUCTNAME *m, KEYTYPE key, VALTYPE val, \
883	FUNCNAME##_insert(STRUCTNAME *m, KEYTYPE key, VALTYPE val, Arena a) {\	882	Arena *a) { \
884	u64 h = HASHFUNC(key);\	883	u64 h = HASHFUNC(key); \
885	while (*m) {\	884	while (*m) { \
886	if (EQFUNC(key, (*m)->key)) {\	885	if (EQFUNC(key, (*m)->key)) { \
887	(*m)->val = val;\	886	(*m)->val = val; \
888	return *m;\	887	return *m; \
889	}\	888	} \
890	h = (h << 2) \| (h >> 62);\	889	h = (h << 2) \| (h >> 62); \
891	m = &(*m)->child[h & 0x3];\	890	m = &(*m)->child[h & 0x3]; \
892	}\	891	} \
893	*m = arena_calloc(sizeof(STRUCTNAME), a);\	892	*m = arena_calloc(sizeof(STRUCTNAME), a); \
894	(*m)->key = key;\	893	(*m)->key = key; \
895	(*m)->val = val;\	894	(*m)->val = val; \
896	return *m;\	895	return *m; \
897	}\	896	} \
898	STRUCTNAME *\	897	STRUCTNAME FUNCNAME##_lookup(STRUCTNAME *m, KEYTYPE key) { \
899	FUNCNAME##_lookup(STRUCTNAME **m, KEYTYPE key) {\	898	u64 h = HASHFUNC(key); \
900	u64 h = HASHFUNC(key);\	899	while (*m) { \
901	while (*m) {\	900	if (EQFUNC(key, (*m)->key)) { \
902	if (EQFUNC(key, (*m)->key)) {\	901	return *m; \
903	return *m;\	902	} \
904	}\	903	h = (h << 2) \| (h >> 62); \
905	h = (h << 2) \| (h >> 62);\	904	m = &(*m)->child[h & 0x3]; \
906	m = &(*m)->child[h & 0x3];\	905	} \
907	}\	906	return NULL; \
908	return NULL;\	907	} \
909	}\	908	typedef Queue STRUCTNAME##Iter; \
910	typedef Queue STRUCTNAME##Iter;\	909	STRUCTNAME##Iter FUNCNAME##_iterator(STRUCTNAME map, Arena a) { \
911	STRUCTNAME##Iter\	910	STRUCTNAME##Iter it = {0}; \
912	FUNCNAME##_iterator(STRUCTNAME map, Arena a) {\	911	queue_push(&it, map, a); \
913	STRUCTNAME##Iter it = {0};\	912	return it; \
914	queue_push(&it, map, a);\	913	} \
915	return it;\	914	STRUCTNAME FUNCNAME##_next(STRUCTNAME##Iter it, Arena *a) { \
916	}\	915	assert(it); \
917	STRUCTNAME *\	916	assert(a); \
918	FUNCNAME##_next(STRUCTNAME##Iter it, Arena a) {\	917	while (it->head) { \
919	assert(it);\	918	STRUCTNAME item = (STRUCTNAME )queue_pop(it); \
920	assert(a);\	919	if (!item) { \
921	while (it->head) {\	920	return NULL; \
922	STRUCTNAME item = (STRUCTNAME )queue_pop(it);\	921	} \
923	for (sz i = 0; i < 4; i++) {\	922	for (sz i = 0; i < 4; i++) { \
924	STRUCTNAME *child = item->child[i];\	923	STRUCTNAME *child = item->child[i]; \
925	if (child) {\	924	if (child) { \
926	queue_push(it, child, a);\	925	queue_push(it, child, a); \
927	}\	926	} \
928	}\	927	} \
929	return item;\	928	return item; \
930	}\	929	} \
931	return NULL;\	930	return NULL; \
932	}	931	}
933		932
934	u64	933	u64
@@ -951,7 +950,6 @@ _int_hash(sz a) {
951	return a * UINT64_C(11400714819323198485);	950	return a * UINT64_C(11400714819323198485);
952	}	951	}
953		952
954
955	// Commonly used map/set types.	953	// Commonly used map/set types.
956	SETDEF(StrSet, strset, Str, str_hash, str_eq)	954	SETDEF(StrSet, strset, Str, str_hash, str_eq)
957	MAPDEF(StrIntMap, strintmap, Str, sz, str_hash, str_eq)	955	MAPDEF(StrIntMap, strintmap, Str, sz, str_hash, str_eq)