Hey guys, can you help me again please?
I've been working on this for two weeks and it's due in on Friday.
I've tried to compile this code but am using gcc in wondows and its
not working properly on my laptop.

Im just finishing the hardest parts
wordADT.c
BStreeADT.c and
the main c page(wordCount where I do testing)
This is my code for wordADT, it is a linked list and the type
definition for this ADT is.....

Code:
struct wordCDT
{
    char data;
    wordADT next;
};
these are the functions, all of which must be coded
recursively(except buildWord)

Code:
#include <stdio.h>
#include "boole.h"
#include "wordADT.h"
#include "listADT.h"


/*---------------------------------------Functions----------------------------------------*/

wordADT createWord()
/*desc: returns a new, empty list*/
{
    return NULL; /*empty list is pointer to NULL*/
}


wordADT reverseWord(wordADT word)
/*desc: returns a word with the chars in reverse order*/
{
    wordADT rWord=createWord();                             /*create temp list*/
 /* rWord=malloc(sizeof(wordADT))    */                       /*allocate storage space?????do I need this line?*/
    while (!isEmptyList(word))                              /*while list is not empty*/
    {  
        rWord=consList(headList(word),rWord);               /*tempList is constructed with head of word at the
                                                                                 end of templist(i hope)*/
        reverseWord(tailList(word));                            /*move to next node?????*/
    }
    return rWord;
}


wordADT buildWord(char str[])  
/*desc: converts a C string (array of char) into the
        corresponding word (list of characters)*/
{
    wordADT newWord=createWord();                           /*create empty word*/                                  
    int count=1;                                            /*declare integer count*/
    while (str[count]!='\0')                                /*stopping condition-while string not empty*/
    {
        newWord=consList(str[count],newWord);               /*word is constructed by adding string item to wordADT*/
        count++;                                            /*increment count so it is closer to stopping condition*/
    }
    return reverseWord(newWord);                           /*recursion will cause string to be entered into wordADT
                                                                  backwards so I return reverse of this word*/
}

void displayWord(wordADT word) 
/*desc: displays a word*/ 
{
    while(!isEmptyList(word))                               /*Stopping condition-is this the right stopping condition??*/
    {
       printf("%c",headList(word));
       displayWord(tailList(word));     
    }

}


int countChars(wordADT word) 
/*desc: counts the number of characters in a word*/
{
    if(isEmptyList(word)==TRUE)
    {
        return 0;                                  /*basically a length function, but would I */
    }                                              /*be better using headList/tailList????????*/
    else 
    {
        return(1+countChars(tailList(word)));
    }
}


boolean wordLess(wordADT word1, wordADT word2) 
/*desc: returns TRUE if the word in word1 is alphabetically
        before that in word2*/
{
    if (isEmptyList(word2)==FALSE)
    {
        if(headList(word1)<headList(word2))
        {
            return TRUE;
        }
        else if (headList(word1)==headList(word2))
        {
            return wordLess(tailList(word1),tailList(word2));
        }
    }
    else
    {
        return FALSE;             /*do I need error messages*/
    }
}


boolean wordEqual(wordADT word1, wordADT word2) 
/*desc: returns TRUE if the word in word1 is equal to that
        in word2*/
{
    if (isEmptyList(word1)||isEmptyList(word2))               
    {
        return TRUE;
    }
    else if (isEmptyList(word1)||isEmptyList(word2))
    {
        return FALSE;
    }
    else if (isEmptyList(word1)||isEmptyList(word2))
    {
        if(headList(word1)==headList(word2))
        {
            return wordLess(tailList(word1),tailList(word2));
        }
        else
        {
            return FALSE;
        }
    }
}

/* OR SHOULD I USE this function which seems more elegant!
if (wordLess(word1, word2)==TRUE)||(wordLess(word2, word1)==TRUE)
{
    return TRUE;
}
else 
{
    return FALSE; 
}
*/
I've already had help with wordLess and wordEqual, do you think they
should be implemented with nested if's????
Eek any help on where you think I could be going wrong would be greatly
appreciated!!!!