list.c

mgcp协议源代码和测试程序,还有一个编译器

/******************************************************************************
  Copyright(C) 2005,2006 Frank ZHANG

  All Rights Reserved.
    
  This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the Free
  Software Foundation; either version 2 of the License, or (at your option)
  any later version.

  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 
  more details.
    
  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  Place, Suite 330, Boston, MA 02111-1307 USA. 

/******************************************************************************
*      Authors                   :  Frank ZHANG ([e-mail])
*      Description               :  
*
*
*      Date of creation          :  04/03/2005
*
*
*      History                   :
*      2005/04/03 Frank ZHANG    : - Creation
******************************************************************************/
#include <stdlib.h>
#include "list.h"
#include "debg.h"

/***************************************************************************
 * Function          : SListInit
 *
 * Description       : Initialize single-linked list
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     
 * Output parameters : pList - initialized list
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
void SListInit (TSList* pList)
{
  if (pList)
  {
    pList->count = 0;
    pList->cur =   NULL;
    pList->pre =   NULL;
    pList->head =  NULL;
    pList->tail =  NULL;
  }
}
/***************************************************************************
 * Function          : SListReset
 *
 * Description       : Reset the current pointer in single-linked list to be
 *                     the header node pointer and the previous pointer to be
 *                     NULL;
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     
 * Output parameters : pList - current pointer is same as header pointer
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
void SListReset(TSList* pList)
{
  if (pList)
  {
    pList->pre = NULL;
    pList->cur = pList->head;
  }
}

/***************************************************************************
 * Function          : SListNextNode
 *
 * Description       : Return the next node pointer to the current pointer
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     
 * Output parameters : pList - current pointer pointer to the next node
 *
 * Return value      : The next node pointer of current pointer
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
TSListNode* SListNextNode(TSList* pList)
{
  TSListNode *pNode = NULL;

  if (pList && pList->cur)
  {
    pList->pre = pList->cur;
    pNode = pList->cur = pList->cur->next;
  }

  return pNode;
}
/***************************************************************************
 * Function          : SListGetCurData
 *
 * Description       : Get the data pointer of current node
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     
 * Output parameters : None
 *
 * Return value      : The pointer to current node's data
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
void* SListGetCurData(TSList* pList)
{
  if (pList && pList->cur)
    return pList->cur->data;
  else return NULL;
}
/***************************************************************************
 * Function          : SListFreeAll
 *
 * Description       : Free each node and its data in single-linked list
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     
 * Output parameters : pList - all nodes and their data are freed
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
void SListFreeAll (TSList* pList)
{
  if (pList)
  {
    TSListNode *p1;
    TSListNode *p2 = pList->head;
    
    while (p2)
    {
      p1 = p2;
      p2 = p1->next;
      free(p1->data);
      free (p1);
    }
    SListInit (pList);
  }
}
/***************************************************************************
 * Function          : SListDel
 *
 * Description       : Delete all the nodes in single-linked list but don't 
 *                     free the node data
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     
 * Output parameters : pList - all nodes are deleted
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
void SListDel (TSList* pList)
{
  if (pList)
  {
    TSListNode *p1;
    TSListNode *p2 = pList->head;
    
    while (p2)
    {
      p1 = p2;
      p2 = p1->next;
      free (p1);
    }
    SListInit (pList);
  }
}
/***************************************************************************
 * Function          : SListAppend
 *
 * Description       : Insert a node into the head of single-linked list
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     pData - pointer to the data associated with the added
 *                             node
 *
 * Output parameters : pList - new node is added
 *
 * Return value      : The pointer of the new added node
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
TSListNode* SListAdd (TSList* pList, void* pData)
{
  TSListNode* pListNode = (TSListNode*)malloc(sizeof(TSListNode));

  if (pListNode) 
  {
    pListNode->data = pData;
    pListNode->next = pList->head;

    pList->head = pListNode;
    pList->count++;
  }
  
  return pListNode;
}
/***************************************************************************
 * Function          : SListAppend
 *
 * Description       : Add a node into single-linked list
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     pData - pointer to the data associated with the added
 *                             node
 *
 * Output parameters : pList - new node is added
 *
 * Return value      : The pointer of the new added node
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
TSListNode* SListAppend (TSList* pList, void* pData)
{
  TSListNode* pListNode = (TSListNode*)malloc(sizeof(TSListNode));

  if (pListNode) 
  {
    pListNode->data = pData;
    pListNode->next =  NULL;

    if (pList->tail)
    {
      pList->tail->next = pListNode;
    }

    if (!pList->head)
    {
       pList->head = pListNode;
    }

    pList->tail = pListNode;
    pList->count++;
  }
  
  return pListNode;
}
/***************************************************************************
 * Function          : SListFindByPointer
 *
 * Description       : Find the node by its data pointer, and store the target
 *                     node pointer.
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     pData - pointer to the data associated with the target
 *                             node
 *
 * Output parameters : 
 *
 * Return value      : The pointer to the tarfet node
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
TSListNode* SListFindByPointer (TSList* pList, void* pData)
{
  pList->pre = NULL;
  pList->cur = pList->head;

  while (NULL != pList->cur) 
  {
    if (pList->cur->data == pData)
    {
      return pList->cur;
    }
    else
    {
      pList->pre = pList->cur;
      pList->cur = pList->cur->next;
    }
  }
  
  /* Found no target, reset the current and previous node pointer to be NULL */
  pList->pre = pList->cur = NULL;
  
  return NULL;
}

/***************************************************************************
 * Function          : SListFind
 *
 * Description       : Find the node by its data, and store the target
 *                     node pointer into current node pointer.
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     pData - pointer to the data associated with the target
 *                             node
 *                     CompFunc - Compare function, it return 0 if find the
 *                             target node.
 *
 * Output parameters : 
 *
 * Return value      : The pointer to the tarfet node
 *
 * Comments          : 
 *
 * History           :
 *  2005/09/13       : Creation
 *
 * Date              : Sep 13 2005, Frank Zhang
 **************************************************************************/
TSListNode* SListFind (TSList* pList, void* pData, CompareEqualFunc CompFunc)
{
  pList->pre = NULL;
  pList->cur = pList->head;

  while (NULL != pList->cur)
  {
    if (CompFunc(pList->cur->data, pData) == 0)
    {
      return pList->cur;
    }
    else
    {
      pList->pre = pList->cur;
      pList->cur = pList->cur->next;
    }
  }

  /* Found no target, reset the current and previous node pointer to be NULL */
  pList->pre = pList->cur = NULL;
  
  return NULL;
}
/***************************************************************************
 * Function          : SListDelCurNode
 *
 * Description       : Delete current node, but don't free the data associate
 *                     with the node
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     
 * Output parameters : pList - current node is deleted and current node point
 *                             to the previous node of original curren node
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
void SListDelCurNode (TSList* pList)
{  
  Assert(pList->cur);
  if (pList->cur != NULL)
  {
    if (pList->pre == NULL)
    {
      /* The current node is the head node */
      Assert(pList->head == pList->cur);

      if (pList->head == pList->tail)
      {
        /* List only contain one element */
        free(pList->cur);
        SListInit(pList);
        return;
      }
      
      pList->head = pList->cur->next;
      free(pList->cur);
      pList->cur = pList->head;
    }
    else
    {
      /* Check if the deleted node is tail */
      if (pList->tail == pList->cur)
        pList->tail = pList->pre;

      pList->pre->next = pList->cur->next;
      free(pList->cur);
      pList->cur = pList->pre->next;
    }

    pList->count--;
  }
 }
/******************************************************************************
 * Function          : SListDelNodeByData
 *
 * Description       : Find the node by its associated date and delete it, but
 *                     donn't free the data
 *                     
 * Input parameters  : pList - pointer to single-linked list
 *                     pData - ponter to the data the target node associated
 *
 * Output parameters : pList - target node is deleted if found
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 ******************************************************************************/
void SListDelNodeByData (TSList* pList, void* pData)
{
  TSListNode* pNode = pList->head;
  TSListNode* pPrev = NULL;
 
  while (NULL != pNode)
  {
    if (pNode->data == pData)
      break;
    else
    {
       pPrev = pNode;
       pNode = pNode->next;
    }
  }
 
  if (NULL != pNode)
  {
    if (NULL == pPrev)
    {
      /* head node */
      pList->head = pNode->next;
    }
    else 
    {
      pPrev->next = pNode->next;
    }

    if (pList->tail == pNode)
    {
      pList->tail = pPrev;
    }

    pList->count--;
    free(pNode);
  }
 }
/***************************************************************************
 * Function          : SListMerger
 *
 * Description       : Merger the source list into the destination list and
                       reset the source list 
 *                     
 * Input parameters  : pDesList - pointer to destination single-linked list
 *                     pSrcList - ponter to source single-linked list
 *
 * Output parameters : pDesList - Source list data node is appended
 *
 * Return value      : None
 *
 * Comments          : 
 *
 * History           :
 *  2005/04/03       : Creation
 *
 * Date              : April 03 2005, Frank Zhang
 **************************************************************************/
 void SListMerger(TSList* pDesList, TSList* pSrcList)
{
  Assert(pDesList);
  Assert(pSrcList);

  if (pSrcList->count > 0)
  {
    if (pDesList->count == 0)
    {
      pDesList->head = pSrcList->head;
      pDesList->tail = pSrcList->tail;
    }
    else
    {
      pDesList->tail->next = pSrcList->head;
      pDesList->tail = pSrcList->tail;
    }

    pDesList->count += pSrcList->count;
    SListInit(pSrcList);
  }
}