Simplify the symtable implementation

Now it is only dedicated to address storage !
If needed the code to free an allocated pointer is commented.

shell_sym.c

 #include "shell_sym.h"
 
 
-int asmsh_symtable_init(asmsh_symtable_t *table, short freeval)
+int asmsh_symtable_init(asmsh_symtable_t *table)
 {
 	int err;
-	table->freeval = freeval?1:0;
+	//table->freeval = freeval?1:0;
 	table->alloc = ASMSH_SYMALLOC;
 	table->syms = malloc(table->alloc*sizeof(*table->syms));
 	if(!table->syms)
 
 void asmsh_symtable_clean(asmsh_symtable_t *table)
 {
+	/*
 	if(table->freeval)
 	{
 		for(int i=0; i<table->syms_sz; i++)
 			free(table->syms[i].val);
 		}
 	}
+	*/
 	free(table->syms);
 	bzero(table, sizeof(*table));
 }
 
 
-int asmsh_symtable_add(asmsh_symtable_t *table, const char *name, void *val)
+int asmsh_symtable_add(asmsh_symtable_t *table, const char *name, unsigned long val)
 {
 	int i;
 	if(strlen(name)>ASMSH_VARNAME_MAX)
 		if(cmp == 0)
 		{
 			//update value
+			/*
 			if(table->freeval)
 			{
 				free(table->syms[i].val);
 			}
-			table->syms[i].val = val;
+			*/
+			table->syms[i].addr = val;
 			return 0;
 		}
 		else if(cmp > 0)
 
 	strncpy(table->syms[i].name, name, ASMSH_VARNAME_MAX);
 	table->syms[i].name[ASMSH_VARNAME_MAX] = '\0';
-	table->syms[i].val = val;
+	table->syms[i].addr = val;
 	table->syms_sz++;
 	return 0;
 }
 	{
 		return 0; // not found
 	}
-	if(table->freeval) { free(table->syms[i].val); }
+	//if(table->freeval) { free(table->syms[i].val); }
 	if(table->syms_sz > i+1)
 	{
 		memmove(&table->syms[i], &table->syms[i+1],

shell_sym.h

 #include <stdlib.h>
 #include <string.h>
 
-#define ASMSH_VARNAME_MAX 31
+#define ASMSH_VARNAME_MAX 256
 #define ASMSH_SYMALLOC 64
 
 typedef struct asmsh_sym_s asmsh_sym_t;
 struct asmsh_sym_s
 {
 	char name[ASMSH_VARNAME_MAX + 1];
-	void *val;
+	unsigned long addr;
 };
 
+/** Stores the list of symbols associated with their address/value
+ *
+ * @note Symboles are ordered by name, ascending
+ */
 struct asmsh_symtable_s
 {
-	short freeval;
 	asmsh_sym_t *syms;
 	size_t syms_sz;
 	size_t alloc;
 };
 
 /** if freeval value given to add are freed on clean */
-int asmsh_symtable_init(asmsh_symtable_t *table, short freeval);
+int asmsh_symtable_init(asmsh_symtable_t *table);
 void asmsh_symtable_clean(asmsh_symtable_t *table);
 
-int asmsh_symtable_add(asmsh_symtable_t *table, const char *name, void *val);
+int asmsh_symtable_add(asmsh_symtable_t *table, const char *name, unsigned long val);
 int asmsh_symtable_del(asmsh_symtable_t *table, const char *name);
 const asmsh_sym_t *asmsh_symtable_get(asmsh_symtable_t *table, const char *name);
 

tests/tests_shell_sym.c

 START_TEST(init)
 {
 	asmsh_symtable_t st;
-	ck_assert_int_eq(asmsh_symtable_init(&st,0), 0);
+	ck_assert_int_eq(asmsh_symtable_init(&st), 0);
 	asmsh_symtable_clean(&st);
 }
 END_TEST
 START_TEST(add)
 {
 	asmsh_symtable_t st;
-	ck_assert_int_eq(asmsh_symtable_init(&st,0), 0);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "b", NULL), 0);
+	ck_assert_int_eq(asmsh_symtable_init(&st), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "b", 0), 0);
 	ck_assert_int_eq(st.syms_sz, 1);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "a", NULL), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 0);
 	ck_assert_int_eq(st.syms_sz, 2);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "a", NULL), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 0);
 	ck_assert_int_eq(st.syms_sz, 2);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "ab", NULL), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "ab", 0), 0);
 	ck_assert_int_eq(st.syms_sz, 3);
 	asmsh_symtable_clean(&st);
 }
 {
 
 	asmsh_symtable_t st;
-	ck_assert_int_eq(asmsh_symtable_init(&st,0), 0);
+	ck_assert_int_eq(asmsh_symtable_init(&st), 0);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 0);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "a", NULL), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 0);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 1);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 0);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "a", NULL), 0);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "b", NULL), 0);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "c", NULL), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "b", 0), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "c", 0), 0);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "d"), 0);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "b"), 1);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "b"), 0);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "b", NULL), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "b", 0), 0);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 1);
 	ck_assert_int_eq(asmsh_symtable_del(&st, "a"), 0);
 	asmsh_symtable_clean(&st);
 {
 	asmsh_symtable_t st;
 	const asmsh_sym_t *s;
-	ck_assert_int_eq(asmsh_symtable_init(&st,0), 0);
+	ck_assert_int_eq(asmsh_symtable_init(&st), 0);
 	ck_assert_ptr_null(asmsh_symtable_get(&st, "a"));
-	ck_assert_int_eq(asmsh_symtable_add(&st, "a", NULL), 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 0), 0);
 	s = asmsh_symtable_get(&st, "a");
 	ck_assert_ptr_nonnull(s);
-	ck_assert_ptr_null(s->val);
-	ck_assert_int_eq(asmsh_symtable_add(&st, "a", (void*)42), 0);
+	ck_assert_int_eq(s->addr, 0);
+	ck_assert_int_eq(asmsh_symtable_add(&st, "a", 42), 0);
 	s = asmsh_symtable_get(&st, "a");
 	ck_assert_ptr_nonnull(s);
-	ck_assert_ptr_eq(s->val, (void*)42);
+	ck_assert_int_eq(s->addr, 42);
 	asmsh_symtable_clean(&st);
 }
 END_TEST
 START_TEST(_realloc)
 {
 	asmsh_symtable_t st;
-	ck_assert_int_eq(asmsh_symtable_init(&st,0), 0);
+	ck_assert_int_eq(asmsh_symtable_init(&st), 0);
 	for(int i=0; i<ASMSH_SYMALLOC*3; i++)
 	{
 		char buf[16];
 		snprintf(buf, 15, "a%d", i);
-		ck_assert_int_eq(asmsh_symtable_add(&st, buf, NULL), 0);
+		ck_assert_int_eq(asmsh_symtable_add(&st, buf, 0), 0);
 	}
 	for(int i=0; i<ASMSH_SYMALLOC*3; i++)
 	{