does this compile for anyone?

[cfanatic]

I am getting an error message that I think is a problem with gcc, not the code itself. Thanks.

/usr/lib/gcc/x86_64-linux-gnu/4.6/../../../x86_64-linux-gnu/crt1.o||In function `_start':|
(.text+0x20)||undefined reference to `main'|
||=== Build finished: 1 errors, 0 warnings ===|

#include <stdio.h>
#include <string.h>

#include "list.h"

void list_init(List *list, void (*destroy) (void *data))
{
    // Initialise the list.
    list->size = 0;
    list->destroy = destroy;
    list->head  = NULL;
    list->tail = NULL;

    return ;
}

void list_destroy(List *list)
{
    void *data;

    // remove each element.
    while (list_size(list) > 0)
    {
        if (list_rem_next(list, NULL, (void **)&data) == 0 && list->destroy != NULL)
        {
            // Cal a user-defined function to free dynamically allocated data.
            list->destroy(data);
        }
    }

    // No operations are allowed now, but clear the structure as a precaution.
    memset(list, 0, sizeof(List));

    return ;
}

int lists_ins_next(List *list, ListElmt *element, const void *data)
{
    ListElmt *new_element;

    // Allocate storage for the element.
    if ((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL)
    {
        return -1;
    }

    // insert the element into the list
    new_element->data = (void *)data;

    if(element == NULL)
    {
        // Handle insertion at the head of the list.
        if(list_size(list) == 0)
        {
            list->tail = new_element;
        }
        new_element->next = list->head;
        list->head = new_element;
    }
        else
        {
            // Handle insertion somewhere other than at the head;
            if(element->next == NULL)
            {
                list->tail = new_element;
            }
            new_element->next = element->next;
            element->next = new_element;
        }

        // Adjust the size of the list to account for the inserted element.
        list->size++;

        return 0;
}

int list_rem_next(List *list, ListElmt *element, void **data)
{
    ListElmt *old_element;

    // Do not allow removal from an empty list.
    if(list_size(list) == 0)
    {
        return -1;
    }

    // Remove the element from the list.
    if(element == NULL)
    {
        // Handle removal from the head of the list.
        *data = list->head->data;
        old_element = list->head;
        list->head = list->head->next;

        if(list_size(list) == 1)
        {
            list->tail = NULL;
        }
    }
    else
    {
        // Handle removal from somewhere other than the head.
        if(element->next == NULL)
        {
            return -1;
        }
        *data = element->next->data;
        old_element = element->next;
        element->next = element->next->next;

        if(element->next == NULL)
        {
            list->tail = element;
        }
    }
    free(old_element);

    // Adjust the size of the list to account for the removed element.
    list->size--;

    return 0;
}

list.h

#ifndef LIST_H
#define LIST_H

#include <stdlib.h>

// Define a structure for linked list elements.
typedef struct ListElmt_ {
    void *data;
    struct ListElmt_ *next;
} ListElmt;

// Define a structure for linked lists.
typedef struct List_ {
    int size;
    int (*match)(const void *key1, const void *key2);
    void (*destroy)(void *data);

    ListElmt *head;
    ListElmt *tail;
} List;

void list_init(List *list, void (*destroy)(void *data));
void list_destroy(List *list);
int list_ins_next(List *list, ListElmt *element, const void *data);
int list_rem_next(List *list, ListElmt *element, void **data);

#define list_size(list) ((list)->size)
#define list_head(list) ((list)->head)
#define list_tail(list) ((list)->tail)
#define list_is_head(list, element) ((element) == (list)->head ? 1 : 0)
#define list_is_tail(element) ((element)->next == NULL ? ! : 0)
#define list_data(element) ((element)->data)
#define list_next(element) ((element)->next)

#endif

[laserlight]

You attempted to build the program without the main function. If you only want to compile this source file, then do so accordingly.