/* linked list by John Cui*/
#include "linkedlist.h"

   static int
CNode_Alloc_and_Init (CLinkedNode **node,
                      const char* elem)
{
   int error = 0;

   *node = malloc (sizeof **node);
   if ( NULL == *node ) {
      error = C_ERR_NO_MEMORY;
      goto TERMINATE;
   }

   if ( elem != NULL) {
      size_t s_size = strlen (elem) + 1;
      (*node)->elem = malloc (s_size);

      if (NULL == (*node)->elem) {
         error = C_ERR_NO_MEMORY;
         goto TERMINATE;
      }
      else {
         memcpy ((*node)->elem, elem, s_size);
      }
   }
   else {
      (*node)->elem = NULL;
   }

   (*node)->next = NULL;
   (*node)->prev = NULL;

TERMINATE:
   if ( (        *node != NULL) &&
        ((*node)->elem == NULL)    ) {
      free (*node);
      *node = NULL;
   }
   return error;

   *list = malloc (sizeof **list);
   if ( NULL == *list ) {
      error = C_ERR_NO_MEMORY;
      goto TERMINATE;
   }

   (*list)->first = NULL;
   (*list)->last  = NULL;

TERMINATE:

   return error;

   while ( (*list)->first != NULL ) {
      CLinkedNode* oldp = (*list)->first;
      (*list)->first = (*list)->first->next;
      free (oldp->elem);
      free (oldp);
   }
   (*list)->first = (*list)->last = NULL;
   free (*list);
   *list = NULL;

TERMINATE:

   return error;

   int error = CNode_Alloc_and_Init (&new_node, elem);
   if ( error )  goto TERMINATE;

   if ( list->first == NULL &&
        list->last  == NULL    ) {
      list->last = list->first = new_node;
   }
   else {
      new_node->prev = list->last;
      list->last->next = new_node;
      list->last = new_node;
   }

TERMINATE:

   return error;

   if ( list->first != NULL &&
        list->last  != NULL   ) {
      p = list->first;
      while ( p != NULL) {
         printf ("%s %s ", p->elem, sp);
         p = p->next;
      }
      printf ("\n");
      printf ("Have %d elements in this list\n\n", CLinkedList_Length
(list));
   }
   else {
      printf ("This is an empty list now\n\n");
   }

   return 0;

   if ( flag == C_STACK ) {
      if ( list->first != NULL) {
         p = list->first;

         // If more than one elememt
         if ( list->first->next != NULL) {
            list->first = list->first->next;
            list->first->prev = NULL;
         }
         // If only one element
         else {
            list->first = NULL;
            list->last = NULL;
         }
      }
      else {
         error = C_ERR_EMPTY_LIST;
         goto TERMINATE;
      }
   }
   else if ( flag == C_QUEUE ) {
      if ( list->last != NULL) {
         p = list->last;

         if ( list->last->prev != NULL ) {
            list->last = list->last->prev;
            list->last->next = NULL;
         }
         else {
            list->first = NULL;
            list->last = NULL;
         }
      }
      else {
         error = C_ERR_EMPTY_LIST;
         goto TERMINATE;
      }
   }
   else {
      error = C_ERR_NOT_STACK_AND_QUEUE;
      goto TERMINATE;
   }

   printf ("%s was deleted\n", p->elem);

   free (p->elem);
   p->elem = NULL;

   free (p);
   p = NULL;

TERMINATE:

   return error;

   while ( p != NULL) {
      ++length;
      p = p->next;
   }

   return length;

Thanks,

  strncpy ((*node)->elem, elem, strlen (elem) + 1);

but it has to do more work than is needed (it must test for a null
that comes only when the counter runs out and it must test the counter
that runs out only at the null) and getting used to using it is a bug
waiting to happen.

I have been programming in C for nearly 30 years and I last used
strncpy about 29 years ago when it was exactly what was needed to copy
Unix file names into directory entries because these were not
null-terminated unless they were < 14 characters long (in which case
you had to pack the space with nulls).  I think it was invented
because of this format, and I have never used it since (except in an
embarrassingly erroneous posting here a few years ago).  It is almost
never the best function for the job: strcpy does what you want
and is simpler; memcpy does it better if you have the length already.

<snip>

My real point was this: allocate both or neither.  You had a situation
where you allocate the node and then return an error because the
string could not be allocated.  This is (depending on exactly how you
use the result) a memory leak.

<snip>

if (NULL == (*node)->elem) {
   error = C_ERR_NO_MEMORY;
   free(*node);
   *node = NULL;

What you prefer is, I think,
static int
CNode_Alloc_and_Init (CLinkedNode **node)
to let elem NULL and alloc/init in list functions?

1. include files:
file struct{
   C.h
   constant.h
   errormap.h

#define C_ERR_NO_MEMORY  10001
#define C_ERR_NOTVALID_INDEX 10002

#define C_ERR_NOT_FOUND    60001
#define C_ERR_EMPTY_LIST   60002
#define C_ERR_NOT_STACK_AND_QUEUE 60003

#define C_TYPE int
#define C_STACK 1
#define C_QUEUE 0

#endif
--------end--------
--------errormap.h--------
#ifndef H_ERRORMAP
#define H_ERRORMAP
typedef struct {
   int        error;
   const char *str;

2. sort (only select sort and bubble sort in this version)
file struct {
   sort.h
   sort.c

   void
CSelect_Sort(C_TYPE *a,
      int len)
{
   int i, j, min;
   C_TYPE t;

   for (i = 0; i < len; ++i) {
      min = i;
      for (j = i + 1; j < len; ++j) {
         if (a[j] < a[min]) {
            min = j;
         }
      }

      if ( i != min ) {
         t = a[i];
         a[i] = a[min];
         a[min] = t;
      }
   }

   for (i = 0; i < len; ++i) {
      for (j = i + 1; j < len; ++j) {
         if (a[j] < a[i]) {
            t = a[i];
            a[i] = a[j];
            a[j] = t;
         }
      }
   }

3. seqlist
file struct{
   seqlist.c
   seqlist.h
   Makefile
   main.c

--------seqlist.h--------
#ifndef H_SEQLIST
#define H_SEQLIST
#include "../include/C.h"
typedef struct {
   C_TYPE *elem_p;     /* The basic address of list */
   int  length;        /* The length of list */
   int  capacity;      /* The capacity of list*/

--------seqlist.c--------
/* sequence list by John Cui*/
#include "seqlist.h"
#include "../sort/sort.h"

   int
CSeqList_Init (CSeqList **list)
{
   int error = 0;

   *list = malloc(sizeof **list);

   (*list)->elem_p = (C_TYPE*) malloc(C_LIST_INIT_SIZE * sizeof
(C_TYPE));
   if ( (*list)->elem_p == NULL ) {
      error = C_ERR_NO_MEMORY;
      goto TERMINATE;
   }
   (*list)->length = 0;
   (*list)->capacity = C_LIST_INIT_SIZE;

TERMINATE:

   return error;

   if ( (*list)->elem_p != NULL) {
      while ((*list)->length != 0) {
         error = CSeqList_Delete(*list, 0, &temp);
         if ( error )  goto TERMINATE;
      }
      free((*list)->elem_p);
      (*list)->elem_p = NULL;
      (*list)->capacity = 0;
   }
   free(*list);
   *list = NULL;

TERMINATE:

   return error;

   while (list->length != 0) {
      error = CSeqList_Delete(list, 0, &temp);
      if ( error )  goto TERMINATE;
   }

TERMINATE:

   return error;

   C_TYPE *p = NULL;
   C_TYPE *q = NULL;

   //check index
   if ( index < 0            ||
         index > list->length   ) {
      error = C_ERR_NOTVALID_INDEX;
      goto TERMINATE;
   }

   //extend capacity if length >= capacity in realloc
   if ( list-> length == list->capacity) {
      list->elem_p =
         (C_TYPE*) realloc (list->elem_p,
               sizeof (C_TYPE) * (list->capacity + C_LISTINCREMENT));
      if ( list->elem_p == NULL ) {
         error = C_ERR_NO_MEMORY;
         goto TERMINATE;
      }
      list->capacity += C_LISTINCREMENT;
   }

   //move elements which is after list[index] to next
   p = &(list->elem_p[index]);
   for (q = &(list->elem_p[list->length - 1]); q >= p; --q) {
      *(q+1) = *q;
   }

   //insert elem and increase the length of list
   *p = elem;
   ++list->length;

TERMINATE:

   return error;

   C_TYPE *p = NULL;
   C_TYPE *q = NULL;

   //check index
   if ( index < 0            ||
         index > list->length   ) {
      error = C_ERR_NOTVALID_INDEX;
      goto TERMINATE;
   }

   //keep the deleted element
   e = &(list->elem_p[index]);

   //move the element which after list[list] to previous
   p = &list->elem_p[index];
   for (q = p; q <= &(list->elem_p[list->length-1]); ++q) {
      *q = *(q+1);
   }
   --list->length;

TERMINATE:

   return error;

   printf ("list->length = %d\n", list->length);
   printf ("list->capacity = %d\n", list->capacity);
   printf ("elements:\n");

   if ( list->length != 0 ) {
      for (i = 0; i < list->length; ++i) {
         printf ("%d ", list->elem_p[i]);
      }
   }
   else {
      printf("This is a NULL list!");
   }
   printf ("\n\n");

   return 0;

   if (length > list->length) {
      length = list->length;
   }
   CSelect_Sort(list->elem_p, length);
   //CBubble_Sort(list, list->length);

   return error;

   *index = -1;

   // Search algrithm can be extended here
   for (i = 0; i < list->length; ++i) {
      if ( list->elem_p[i] == elem ) {
         *index = i;
      }
   }

   if ( *index == -1) {
      error = C_ERR_NOT_FOUND;
   }

TERMINATE:
   return error;

--------main.c--------
#include "seqlist.h"

int main(void)
{
   int i;
   int error = 0;
   int ind;
   C_TYPE e;
   CSeqList* mylist = NULL;

   error = CSeqList_Init (&mylist);
   if ( error )  goto TERMINATE;

   error = CSeqList_Insert (mylist, 0, 1);
   if ( error )  goto TERMINATE;
   error = CSeqList_Insert (mylist, 1, 10);
   if ( error )  goto TERMINATE;
   error = CSeqList_Insert (mylist, 2, 0);
   if ( error )  goto TERMINATE;
   error = CSeqList_Insert (mylist, 3, 5);
   if ( error )  goto TERMINATE;

   error = CSeqList_Find (mylist, 5, &ind);
   if ( error )  goto TERMINATE;
   printf ("index of element is %d\n", ind);

   CSeqList_Output (mylist);
   CSeqList_Sort (mylist, mylist->length);
   CSeqList_Output (mylist);

   error = CSeqList_Insert (mylist, 1, 8);
   if ( error )  goto TERMINATE;

   CSeqList_Sort (mylist, mylist->length);
   CSeqList_Output (mylist);

   error = CSeqList_Insert (mylist, 0, 100);
   if ( error )  goto TERMINATE;
   error = CSeqList_Insert (mylist, 2, 1000);
   if ( error )  goto TERMINATE;

   CSeqList_Sort(mylist, mylist->length);
   CSeqList_Output (mylist);

   error = CSeqList_Delete (mylist, 3, &e);
   if ( error )  goto TERMINATE;

   CSeqList_Output (mylist);
   CSeqList_Sort (mylist, mylist->length);
   error = CSeqList_Clear (mylist);

   CSeqList_Output (mylist);
   error = CSeqList_Insert (mylist, 0, 100);
   if ( error )  goto TERMINATE;
   error = CSeqList_Insert (mylist, 1, 1000);
   CSeqList_Output (mylist);
   if ( error )  goto TERMINATE;

   error = CSeqList_Free (&mylist);
   if ( error )  goto TERMINATE;

   if ( mylist == NULL )  printf("sqlist free successfully!");
TERMINATE:
   if ( error ) {
      int nErrors = sizeof (errorMap) / sizeof (errorMap[0]);

      for (i = 0; i < nErrors; ++i) {
         if ( errorMap[i].error == error ) {
            printf ("C Error: %s\n", errorMap[i].str);
         }
      }
      CSeqList_Free (&mylist);
   }

   return 0;

4.  linkedlist
file struct:
likedlist{
   linkedlist.c
   linkedlist.h
   main.c
   Makefile

--------linkedlist.h--------
#ifndef H_LINKEDLIST
#define H_LINKEDLIST
#include "../include/C.h"
struct CLinkedNode {
   char         *elem;
   struct CLinkedNode *next;
   struct CLinkedNode *prev;

--
Nick Keighley

So, I think we can _forget_ convert the return value of malloc for any
type pointer like:
ANY_TYPE_POINTER p = malloc(...);

------------------------------------------------
int
readfile(const char * filename)
{
   int error = 0;
   FILE *fp = NULL;
   char line[256];

   fp = fopen (filename, "r");
   CLinkedList* mylist = NULL;
   error = CLinkedList_Init (&mylist);
   if ( error )  goto TERMINATE;

   while (fgets (line, 256, fp) != NULL) {
      if ( strstr (line, "malloc") != NULL ||
           strstr (line, "malloc") != NULL   ) {
         error = CLinkedList_Append (mylist, line);
         if ( error )  goto TERMINATE;
      }
   }

   fclose (fp);
   CLinkedList_Output (mylist, NULL);
   CLinkedList_Free (&mylist);

TERMINATE:

   return error;