Expand chaining hashtable. Errors on code.[UPDATED-New question] - c

Question

Expanding a hashtable with linked lists there are some errors and warnings. I wanna make sure that the following code is right (expand function) and find out what happens that raise these warnings/errors
EDIT:Thanks to #nos who noticed that my prototype was missing the warnings+errors I refered to gone. Unfortunately now there is this one: " In function expand': undefined reference toadd' collect2: ld returned 1 exit status
EDIT2: I noticed that add function returns back a List* which on expand function there is none variable to "get" it. I put a value there...but error remains :/
EDIT3: Segmentation Fault :( Running with gdb: * glibc detected corrupted double-linked list: 0x0804c6b0 ** CORRECTED. NEW ADD FUNCTION ADDED.
EDIT: Segmentation Fault on strcmp on lookup function. Running with gdb:
(gdb) bt full
0 0x080487b9 in lookup (hashtable=0x804b008, hashval=27,
number=0xbffff3f2 "6900101001") at pro.c:80
list = 0xffffffff
1 0x0804883b in add (hashtable=0x804b008,
number=0xbffff3f2 "6900101001", name=0x804b6e0 "Irgaedggfs",
time=6943)
at pro.c:96
new_elem = 0xffffffff
hashval = 27
2 0x08048bc1 in main (argc=1, argv=0xbffff4b4) at pro.c:234
number = "6900101001"
name = 0x804b6e0 "Irgaedggfs"
time = 6943
typedef struct
{
int length;
struct List *head;
} HashTable;
//resolving collisions using linked lists - chaining
typedef struct
{
char *number;
char *name;
int time;
struct List *next;
}List;
HashTable* expand( HashTable* h )
{
HashTable* new;
int n;
List *node,*next;
PrimesIndex++;
int new_size= primes[PrimesIndex]; /* double the size,odd length */
if (!(new=malloc((sizeof( List*))*new_size))) return NULL;
for(n=0; n< h->length; ++n) {
for(node=h[n].head; node; node=next) {
add (new, node->number, node->name,node->time);
next=node->next;
free(node);
}
}
free(h);
return new;
}
int add ( HashTable* hashtable,char number[10],char* name,int time)
{
List *new_elem;
int hashval=hash (hashtable,number);
new_elem=hashtable[hashval].head;
if(hashtable[hashval].length>0)
{
if ((lookup (hashtable,hashval,number))!=NULL) {return 0;}
}
if (!(new_elem=malloc(sizeof(struct List)))){ return -1;}
//insert values for the new elem
new_elem->number=strdup(number);
new_elem->name=strdup(name);
new_elem->time=time;
hashtable[hashval].head=new_elem;
new_elem->next=NULL;
hashtable[hashval].length++;
/* rehash existing entries if necessary */
if( TableSize(hashtable)>= 2*size])
{
hashtable = expand(hashtable);
if (hashtable ==NULL){
return 0;
}
}
return 1;
}
List *lookup ( HashTable *h ,int hashval,char number[10])
{
List *list=h[hashval].head;
for(list; list!=NULL; list=list->next){
if (strcmp(number,list->number)==0) //**SEGMENTATION**!!!!
return list;
}
return NULL;
}

Answer 1

You need to declare functions before you call them. Otherwise C will, among other things, assume your expand function returns an int.
Simply, place a prototype like this one at the top of your file, after your struct declarations, before your function definitions.
HashTable* expand( HashTable* h ,char number[10],char* name,int time);

Answer 2

declare the function "add" before you define "expand", in which you use "add".
List* add ( HashTable* hashtable,char number[10],char* name,int time);
define expand here..
define add here...

Answer 3

(I don't know how to change lines in the computer; so I have to post an new answer rather than follow your comment. sorry)
Pls try:
int add ( HashTable** phashtable,char number[10],char* name,int time){
...
if(hashTableSize( *phashtable)== 2*(primes[PrimesIndex])){
*phashtable = expand( *phashtable);
}
}
you may need to modify "add" and the invoke of "add" accordingly.
I'm not sure whether this would help. At least this is one of the bugs.
The bug is that if Hashtable is expanded in an add call, after the add call returns, the value of the variable "hashtable" won't change.