上传文件至 ''

zf_assert.c

@@ -0,0 +1,34 @@
+/**
+  *****************************************************************************
+  * @file    zf_assert.c
+  * @author  Zorb
+  * @version V1.0.0
+  * @date    2018-06-28
+  * @brief   断言的实现
+  *****************************************************************************
+  * @history
+  *
+  * 1. Date:2018-06-28
+  *    Author:Zorb
+  *    Modification:建立文件
+  *
+  *****************************************************************************
+  */
+
+#include "zf_assert.h"
+#include "zf_debug.h"
+
+/******************************************************************************
+ * 描述  ：断言产生时的处理
+ * 参数  ：(in)-pFileName 文件名
+ *         (in)-line 行数
+ * 返回  ：无
+******************************************************************************/
+void ZF_assertHandle(uint8_t *pFileName, int line)
+{
+    ZF_DEBUG(LOG_E, "file:%s line:%d:asserted\r\n", pFileName, line);
+    
+    while (1);
+}
+
+/******************************** END OF FILE ********************************/

zf_buffer.c

@@ -0,0 +1,341 @@
+/**
+  *****************************************************************************
+  * @file    zf_buffer.c
+  * @author  Zorb
+  * @version V1.0.0
+  * @date    2018-06-28
+  * @brief   环形缓冲器的实现
+  *****************************************************************************
+  * @history
+  *
+  * 1. Date:2018-06-28
+  *    Author:Zorb
+  *    Modification:建立文件
+  *
+  *****************************************************************************
+  */
+
+#include "zf_buffer.h"
+#include "zf_assert.h"
+#include "zf_malloc.h"
+#include "zf_debug.h"
+
+/******************************************************************************
+ * 描述  ：创建环形缓冲器(内部分配空间，size=0表示使用外部数据)
+ * 参数  ：(out)-ppRb  环形缓冲器结构体指针的指针
+ *         (in)-size   缓冲器大小
+ *         (out)-ppBuf 缓冲器空间指针的指针
+ * 返回  ：无
+******************************************************************************/
+bool RB_create(RingBuffer **ppRb, uint32_t size)
+{
+    RingBuffer *pRb;
+    uint8_t *pBuf;
+    
+    ZF_ASSERT(ppRb != (RingBuffer **)0)
+    
+    pRb = (RingBuffer *)ZF_MALLOC(sizeof(RingBuffer));
+    if (pRb == NULL)
+    {
+        ZF_DEBUG(LOG_E, "malloc ringbuffer space error\r\n");
+        return false;
+    }
+    
+    pRb->Head = (uint32_t)0;
+    pRb->Trail = (uint32_t)0;
+    pRb->Count = 0;
+    
+    if (size > 0)
+    {
+        pBuf = (void *)ZF_MALLOC(size);
+        if (pBuf == NULL)
+        {
+            ZF_DEBUG(LOG_E, "malloc ringbuffer buffer space error\r\n");
+            return false;
+        }
+        
+        pRb->pBuf = pBuf;
+        pRb->Size = size;
+        pRb->IsExternBuffer = false;
+    }
+    else
+    {
+        pRb->pBuf = NULL;
+        pRb->Size = 0;
+        pRb->IsExternBuffer = true;
+    }
+    
+    /* 初始化方法 */
+    pRb->IsFull = RB_isFull;
+    pRb->IsEmpty = RB_isEmpty;
+    pRb->SaveByte = RB_saveByte;
+    pRb->SaveRange = RB_saveRange;
+    pRb->GetByte = RB_getByte;
+    pRb->GetCount = RB_getCount;
+    pRb->ReadBytes = RB_readBytes;
+    pRb->DropBytes = RB_dropBytes;
+    pRb->Clear = RB_clear;
+    pRb->Dispose = RB_dispose;
+    
+    /* 输出 */
+    *ppRb = pRb;
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：缓冲器是否已满
+ * 参数  ：(in)-pRb 环形缓冲器结构体指针
+ * 返回  ：-true    已满
+ *         -false   未满
+******************************************************************************/
+bool RB_isFull(RingBuffer * const pRb)
+{
+    bool res = false;
+    
+    ZF_ASSERT(pRb != (RingBuffer *)0)
+    
+    if (pRb->Size == pRb->Count)
+    {
+        res = true;
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：缓冲器是否空
+ * 参数  ：(in)-pRb 环形缓冲器结构体指针
+ * 返回  ：-true    空
+ *         -false   未空
+******************************************************************************/
+bool RB_isEmpty(RingBuffer * const pRb)
+{
+    bool res = false;
+    
+    ZF_ASSERT(pRb != (RingBuffer *)0)
+    
+    if (pRb->Count == 0)
+    {
+        res = true;
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：压入一个字节
+ * 参数  ：(in)-pRb  环形缓冲器结构体指针
+ *         (in)-byte 要压入的字节
+ * 返回  ：-true     成功
+ *         -false    失败
+******************************************************************************/
+bool RB_saveByte(RingBuffer * const pRb, uint8_t byte)
+{
+    bool res = false;
+    
+    ZF_ASSERT(pRb != (RingBuffer *)0)
+    ZF_ASSERT(pRb->pBuf != (uint8_t *)0)
+    
+    if (!RB_isFull(pRb))
+    {
+        pRb->pBuf[pRb->Trail++] = byte;
+        pRb->Trail %= pRb->Size;
+        pRb->Count++;
+        
+        res = true;
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：压入n个字节的数据
+ * 参数  ：(in)-pRb    环形缓冲器结构体指针
+ *         (in)-pData  要压入的数据的指针
+ *         (in)-len    要压入的数据的长度
+ * 返回  ：压入的数量
+******************************************************************************/
+uint32_t RB_saveRange(RingBuffer * const pRb, uint8_t *pArray, uint32_t n)
+{
+    uint32_t res = 0;
+    
+    if (pArray == 0)
+    {
+        return res;
+    }
+    
+    ZF_ASSERT(pRb != (RingBuffer *)0)
+    ZF_ASSERT(pRb->pBuf != (uint8_t *)0)
+    ZF_ASSERT(pArray != (uint8_t *)0)
+    
+    uint32_t i;
+    
+    for (i = 0; i < n; i++)
+    {
+        pRb->pBuf[pRb->Trail++] = *(pArray + i);
+        pRb->Trail %= pRb->Size;
+        pRb->Count++;
+        
+        res++;
+        
+        if (pRb->Count >= pRb->Size)
+        {
+            break;
+        }
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：取出一个字节
+ * 参数  ：(in)-pRb    环形缓冲器结构体指针
+ *         (out)-pByte 存放取出字节的地址
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool RB_getByte(RingBuffer * const pRb, uint8_t *pByte)
+{
+    bool res = false;
+    
+    ZF_ASSERT(pRb != (RingBuffer *)0)
+    ZF_ASSERT(pRb->pBuf != (uint8_t *)0)
+    ZF_ASSERT(pByte != (uint8_t *)0)
+    
+    if (!RB_isEmpty(pRb))
+    {
+        *pByte = pRb->pBuf[pRb->Head++];
+        pRb->Head %= pRb->Size;
+        pRb->Count--;
+        
+        res = true;
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：读取缓冲器已使用字节个数
+ * 参数  ：(in)-pRb  环形缓冲器结构体指针
+ * 返回  ：已使用字节个数
+******************************************************************************/
+uint32_t RB_getCount(RingBuffer * const pRb)
+{
+    ZF_ASSERT(pRb != (RingBuffer *)0)
+    
+    return pRb->Count;
+}
+
+/******************************************************************************
+ * 描述  ：读取n个字节(n超过最大数据数时全部读出)
+ * 参数  ：(in)-pRb     环形缓冲器结构体指针
+ *         (out)-pArray 存放取出字节的地址
+ *         (in)-n       要读取的字节个数
+ * 返回  ：实际读取的字节个数
+******************************************************************************/
+uint32_t RB_readBytes(RingBuffer * const pRb, uint8_t *pArray, uint32_t n)
+{
+    uint32_t len;
+    uint32_t i, index;
+    
+    ZF_ASSERT(pRb != (RingBuffer *)0)
+    ZF_ASSERT(pRb->pBuf != (uint8_t *)0)
+    ZF_ASSERT(pArray != (uint8_t *)0)
+    
+    if (!RB_isEmpty(pRb))
+    {
+        len = RB_getCount(pRb);
+        
+        if (len > n)
+        {
+            len = n;
+        }
+        
+        for(i = 0; i < len; i++) 
+        {
+            index = (pRb->Head + i) % pRb->Size;
+            *(pArray + i) = pRb->pBuf[index];
+        }
+        
+        return len;
+    }
+    
+    return 0;
+}
+
+/******************************************************************************
+ * 描述  ：丢弃n个字节(n超过最大数据数时全部丢弃)
+ * 参数  ：(in)-pRb     环形缓冲器结构体指针
+ *         (in)-n       要丢弃的字节个数
+ * 返回  ：实际丢弃的字节个数
+******************************************************************************/
+uint32_t RB_dropBytes(RingBuffer * const pRb, uint32_t n)
+{
+    uint32_t len;
+    
+    ZF_ASSERT(pRb != (RingBuffer *)0)
+    ZF_ASSERT(pRb->pBuf != (uint8_t *)0)
+    
+    if (!RB_isEmpty(pRb))
+    {
+        len = RB_getCount(pRb);
+        
+        if (len > n)
+        {
+            len = n;
+        }
+        
+        pRb->Head += len;
+        pRb->Head %= pRb->Size;
+        pRb->Count -= len;
+        
+        return len;
+    }
+    
+    return 0;
+}
+
+/******************************************************************************
+ * 描述  ：清空缓冲器
+ * 参数  ：(in)-pRb     环形缓冲器结构体指针
+ * 返回  ：-true        成功
+ *         -false       失败
+******************************************************************************/
+bool RB_clear(RingBuffer * const pRb)
+{
+    bool res = false;
+    
+    ZF_ASSERT(pRb != (RingBuffer *)0)
+    
+    pRb->Head = (uint32_t)0;
+    pRb->Trail = (uint32_t)0;
+    pRb->Count = 0;
+    
+    res = true;
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：释放缓冲器(不释放外部创建的缓冲区)
+ * 参数  ：(in)-pRb     环形缓冲器结构体指针
+ * 返回  ：-true     成功
+ *         -false    失败
+******************************************************************************/
+bool RB_dispose(RingBuffer * const pRb)
+{
+    ZF_ASSERT(pRb != (RingBuffer *)0)
+    
+    /* 外部创建的缓冲区不释放 */
+    if (!pRb->IsExternBuffer)
+    {
+        ZF_FREE(pRb->pBuf);
+    }
+    
+    ZF_FREE(pRb);
+    
+    return true;
+}
+
+/******************************** END OF FILE ********************************/

zf_event.c

@@ -0,0 +1,440 @@
+/**
+  *****************************************************************************
+  * @file    zf_event.c
+  * @author  Zorb
+  * @version V1.0.0
+  * @date    2018-06-28
+  * @brief   事件和事件处理器的实现
+  *****************************************************************************
+  * @history
+  *
+  * 1. Date:2018-06-28
+  *    Author:Zorb
+  *    Modification:建立文件
+  *
+  *****************************************************************************
+  */
+
+#include "zf_event.h"
+#include "zf_assert.h"
+#include "zf_debug.h"
+#include "zf_malloc.h"
+#include "zf_critical.h"
+
+/******************************************************************************
+ * 描述  ：创建事件
+ * 参数  ：(out)-ppEvent  事件指针的指针
+ * 返回  ：-true          成功
+ *         -false         失败
+******************************************************************************/
+bool Event_create(Event **ppEvent)
+{
+    Event *pEvent;
+    
+    ZF_ASSERT(ppEvent != (Event **)0)
+    
+    /* 分配空间 */
+    pEvent = ZF_MALLOC(sizeof(Event));
+    if (pEvent == NULL)
+    {
+        ZF_DEBUG(LOG_E, "malloc event space error\r\n");
+        return false;
+    }
+    
+    /* 初始化成员 */
+    pEvent->Priority = EVENT_LOWEST_PRIORITY;
+    pEvent->EventProcess = NULL;
+    pEvent->pArgList = NULL;
+    
+    /* 初始化方法 */
+    pEvent->AddArg = Event_addArg;
+    pEvent->Dispose = Event_Dispose;
+    
+    /* 输出 */
+    *ppEvent = pEvent;
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：增加事件参数(深拷贝，按先后顺序入队列)
+ * 参数  ：(in)-pEvent  事件指针
+ *         (in)-pArg    要增加的参数
+ *         (in)-size    要增加的大小
+ * 返回  ：-true        成功
+ *         -false       失败
+******************************************************************************/
+bool Event_addArg(Event * const pEvent, void *pArg, uint32_t size)
+{
+    ListNode *pNode;
+    void *pData;
+    
+    ZF_ASSERT(pEvent != (Event *)0)
+    ZF_ASSERT(pArg != (void *)0)
+    ZF_ASSERT(size > 0)
+    
+    /* 创建参数列表 */
+    if (pEvent->pArgList == NULL)
+    {
+        List_create(&pEvent->pArgList);
+        
+        if (pEvent->pArgList == NULL)
+        {
+            ZF_DEBUG(LOG_E, "malloc event arg list space error\r\n");
+            
+            return false;
+        }
+    }
+    
+    /* 创建参数节点 */
+    if (!List_mallocNode(&pNode, &pData, size))
+    {
+        ZF_DEBUG(LOG_E, "malloc event arg node space error\r\n");
+        
+        return false;
+    }
+    
+    /* 深拷贝参数数据 */
+    ZF_MEMCPY(pData, pArg, size);
+    
+    /* 添加到参数列表 */
+    if (!pEvent->pArgList->Add(pEvent->pArgList, pNode))
+    {
+        ZF_DEBUG(LOG_E, "add event arg node into event arg list error\r\n");
+        
+        return false;
+    }
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：销毁事件(程序参数也同步销毁)
+ * 参数  ：(in)-pEvent  事件指针
+ * 返回  ：-true        成功
+ *         -false       失败
+******************************************************************************/
+bool Event_Dispose(Event * const pEvent)
+{
+    ZF_ASSERT(pEvent != (Event *)0)
+    
+    /* 销毁参数列表 */
+    if (pEvent->pArgList != NULL)
+    {
+        pEvent->pArgList->Dispose(pEvent->pArgList);
+    }
+    
+    ZF_FREE(pEvent);
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：创建事件处理器
+ * 参数  ：(out)-ppEventHandler  事件处理器指针的指针
+ * 返回  ：-true                 成功
+ *         -false                失败
+******************************************************************************/
+bool EventHandler_create(EventHandler **ppEventHandler)
+{
+    EventHandler *pEventHandler;
+    
+    ZF_ASSERT(ppEventHandler != (EventHandler **)0)
+    
+    /* 分配空间 */
+    pEventHandler = ZF_MALLOC(sizeof(EventHandler));
+    if (pEventHandler == NULL)
+    {
+        ZF_DEBUG(LOG_E, "malloc event handler space error\r\n");
+        return false;
+    }
+    
+    /* 初始化成员 */
+    pEventHandler->pEventList = NULL;
+    pEventHandler->IsRunning = true;
+    
+    /* 初始化方法 */
+    pEventHandler->GetEventCount = EventHandler_getEventCount;
+    pEventHandler->Add = EventHandler_add;
+    pEventHandler->Delete = EventHandler_delete;
+    pEventHandler->Clear = EventHandler_clear;
+    pEventHandler->Dispose = EventHandler_dispose;
+    pEventHandler->Execute = EventHandler_execute;
+    
+    /* 输出 */
+    *ppEventHandler = pEventHandler;
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：获取事件数
+ * 参数  ：(in)-pEventHandler  事件处理器指针
+ * 返回  ：事件数
+******************************************************************************/
+uint32_t EventHandler_getEventCount(EventHandler * const pEventHandler)
+{
+    ZF_ASSERT(pEventHandler != (EventHandler *)0)
+    
+    if (pEventHandler->pEventList == NULL)
+    {
+        return 0;
+    }
+    else
+    {
+        return pEventHandler->pEventList->Count;
+    }
+}
+
+/******************************************************************************
+ * 描述  ：增加事件(按优先级排序)
+ * 参数  ：(in)-pEventHandler  事件处理器指针
+ *         (in)-pEvent         事件指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool EventHandler_add(EventHandler * const pEventHandler, Event *pEvent)
+{
+    /* SR变量 */
+    ZF_SR_VAL();
+    
+    ListNode *pNode;
+    uint32_t i;
+    uint32_t index; /* 插入事件位置索引 */
+    
+    ZF_ASSERT(pEventHandler != (EventHandler *)0)
+    ZF_ASSERT(pEvent != (Event *)0)
+    
+    /* 创建事件列表 */
+    if (pEventHandler->pEventList == NULL)
+    {
+        List_create(&pEventHandler->pEventList);
+        
+        if (pEventHandler->pEventList == NULL)
+        {
+            ZF_DEBUG(LOG_E, "malloc event list space error\r\n");
+            
+            return false;
+        }
+    }
+    
+    /* 创建事件节点 */
+    if (!List_mallocNode(&pNode, NULL, 0))
+    {
+        ZF_DEBUG(LOG_E, "malloc event node space error\r\n");
+        
+        return false;
+    }
+    
+    pNode->pData = (void *)pEvent;
+    pNode->Size = sizeof(Event);
+    
+    /* 按优先级排序 */
+    index = pEventHandler->pEventList->Count;
+    
+    for (i = 0; i < pEventHandler->pEventList->Count; i++)
+    {
+        if (pEvent->Priority < ((Event *)pEventHandler->pEventList
+            ->GetElementDataAt(pEventHandler->pEventList, i))->Priority)
+        {
+            index = i;
+            break;
+        }
+    }
+    
+    /* 进入临界区 */
+    ZF_CRITICAL_ENTER();
+    
+    /* 添加到事件列表 */
+    if (!pEventHandler->pEventList
+        ->AddElementAt(pEventHandler->pEventList, index, pNode))
+    {
+        ZF_DEBUG(LOG_E, "add event node into event list error\r\n");
+        
+        /* 退出临界区 */
+        ZF_CRITICAL_EXIT();
+        
+        return false;
+    }
+    
+    /* 退出临界区 */
+    ZF_CRITICAL_EXIT();
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：删除事件(释放空间)
+ * 参数  ：(in)-pEventHandler  事件处理器指针
+ *         (in)-pEvent         事件指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool EventHandler_delete(EventHandler * const pEventHandler, Event *pEvent)
+{
+    /* SR变量 */
+    ZF_SR_VAL();
+    
+    ListNode *pNode;
+    
+    ZF_ASSERT(pEventHandler != (EventHandler *)0)
+    ZF_ASSERT(pEvent != (Event *)0)
+    
+    if (pEventHandler->pEventList == NULL ||
+        pEventHandler->pEventList->Count == 0)
+    {
+        return false;
+    }
+    
+    /* 进入临界区 */
+    ZF_CRITICAL_ENTER();
+    
+    /* 移除事件 */
+    while(pEventHandler->pEventList
+        ->GetElementByData(pEventHandler->pEventList, pEvent, &pNode))
+    {
+        if (pNode == NULL)
+        {
+            break;
+        }
+        
+        if (!pEventHandler->pEventList->Delete(pEventHandler->pEventList, pNode))
+        {
+            ZF_DEBUG(LOG_E, "delete event node from list error\r\n");
+            
+            break;
+        }
+    }
+    
+    /* 退出临界区 */
+    ZF_CRITICAL_EXIT();
+    
+    pEvent->Dispose(pEvent);
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：清空事件列表(释放空间)
+ * 参数  ：(in)-pEventHandler  事件处理器指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool EventHandler_clear(EventHandler * const pEventHandler)
+{
+    /* SR变量 */
+    ZF_SR_VAL();
+    
+    /* 返回结果 */
+    bool res = true;
+    
+    uint32_t i;
+    Event *pEvent;
+    
+    ZF_ASSERT(pEventHandler != (EventHandler *)0)
+    
+    if (pEventHandler->pEventList == NULL ||
+        pEventHandler->pEventList->Count == 0)
+    {
+        return true;
+    }
+    
+    /* 进入临界区 */
+    ZF_CRITICAL_ENTER();
+    
+    for (i = 0; i < pEventHandler->pEventList->Count; i++)
+    {
+        /* 释放所有事件 */
+        pEvent = (Event *)pEventHandler->pEventList
+            ->GetElementDataAt(pEventHandler->pEventList, i);
+        
+        pEvent->Dispose(pEvent);
+    }
+    
+    res = pEventHandler->pEventList->Clear(pEventHandler->pEventList);
+    
+    /* 退出临界区 */
+    ZF_CRITICAL_EXIT();
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：销毁事件处理器(释放空间)
+ * 参数  ：(in)-pEventHandler  事件处理器指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool EventHandler_dispose(EventHandler * const pEventHandler)
+{
+    /* SR变量 */
+    ZF_SR_VAL();
+    
+    ZF_ASSERT(pEventHandler != (EventHandler *)0)
+    
+    /* 进入临界区 */
+    ZF_CRITICAL_ENTER();
+    
+    /* 清空事件列表(释放空间) */
+    EventHandler_clear(pEventHandler);
+    
+    pEventHandler->pEventList->Dispose(pEventHandler->pEventList);
+    
+    pEventHandler->pEventList = NULL;
+    
+    /* 退出临界区 */
+    ZF_CRITICAL_EXIT();
+    
+    ZF_FREE(pEventHandler);
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：执行事件(按列表位置)
+ * 参数  ：(in)-pEventHandler  事件处理器指针
+ * 返回  ：无
+******************************************************************************/
+void EventHandler_execute(EventHandler * const pEventHandler)
+{
+    /* SR变量 */
+    ZF_SR_VAL();
+    
+    Event *pEvent;
+    
+    ZF_ASSERT(pEventHandler != (EventHandler *)0)
+    
+    /* 没有运行则退出 */
+    if (!pEventHandler->IsRunning)
+    {
+        return;
+    }
+    
+    /* 没有事件则退出 */
+    if (pEventHandler->pEventList == NULL 
+        || pEventHandler->pEventList->Count == 0)
+    {
+        return;
+    }
+    
+    /* 进入临界区 */
+    ZF_CRITICAL_ENTER();
+    
+    pEvent = (Event *)pEventHandler->pEventList
+        ->GetElementDataAt(pEventHandler->pEventList, 0);
+    
+    /* 退出临界区 */
+    ZF_CRITICAL_EXIT();
+    
+    if (pEvent == NULL || pEvent->EventProcess == NULL)
+    {
+        ZF_DEBUG(LOG_E, "event handler execute error:event is null\r\n");
+        while(1);
+    }
+    
+    pEvent->EventProcess(pEvent->pArgList);
+    
+    EventHandler_delete(pEventHandler, pEvent);
+}
+
+/******************************** END OF FILE ********************************/

zf_fsm.c

@@ -0,0 +1,414 @@
+/**
+  *****************************************************************************
+  * @file    zf_fsm.c
+  * @author  Zorb
+  * @version V1.0.0
+  * @date    2018-06-28
+  * @brief   有限状态机的实现
+  *****************************************************************************
+  * @history
+  *
+  * 1. Date:2018-06-28
+  *    Author:Zorb
+  *    Modification:建立文件
+  *
+  *****************************************************************************
+  */
+
+#include "zf_fsm.h"
+#include "zf_assert.h"
+#include "zf_debug.h"
+#include "zf_malloc.h"
+
+/******************************************************************************
+ * 描述  ：创建状态机(内部分配空间)
+ * 参数  ：(out)-ppFsm   状态机指针的指针
+ * 返回  ：-true         成功
+ *         -false        失败
+******************************************************************************/
+bool Fsm_create(Fsm ** ppFsm)
+{
+    Fsm *pFsm;
+    
+    ZF_ASSERT(ppFsm != (Fsm **)0)
+    
+    /* 分配空间 */
+    pFsm = ZF_MALLOC(sizeof(Fsm));
+    if (pFsm == NULL)
+    {
+        ZF_DEBUG(LOG_E, "malloc fsm space error\r\n");
+        return false;
+    }
+    
+    /* 初始化成员 */
+    pFsm->Level = 1;
+    pFsm->ChildList = NULL;
+    pFsm->Owner = NULL;
+    pFsm->OwnerTriggerState = NULL;
+    pFsm->CurrentState = NULL;
+    pFsm->IsRunning = false;
+    
+    /* 初始化方法 */
+    pFsm->SetInitialState = Fsm_setInitialState;
+    pFsm->Run = Fsm_run;
+    pFsm->RunAll = Fsm_runAll;
+    pFsm->Stop = Fsm_stop;
+    pFsm->StopAll = Fsm_stopAll;
+    pFsm->Dispose = Fsm_dispose;
+    pFsm->DisposeAll = Fsm_disposeAll;
+    pFsm->AddChild = Fsm_addChild;
+    pFsm->RemoveChild = Fsm_removeChild;
+    pFsm->Dispatch = Fsm_dispatch;
+    pFsm->Transfer = Fsm_transfer;
+    pFsm->TransferWithEvent = Fsm_transferWithEvent;
+    
+    /* 输出 */
+    *ppFsm = pFsm;
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：设置状态机初始状态
+ * 参数  ：(in)-pFsm           状态机指针
+ *         (in)-initialState   状态机初始状态
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+void Fsm_setInitialState(Fsm * const pFsm, IFsmState initialState)
+{
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    ZF_ASSERT(initialState != (IFsmState)0)
+    
+    pFsm->CurrentState = initialState;
+}
+
+/******************************************************************************
+ * 描述  ：运行当前状态机
+ * 参数  ：(in)-pFsm           状态机指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool Fsm_run(Fsm * const pFsm)
+{
+    /* 返回结果 */
+    bool res = false;
+    
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    
+    if (!pFsm->IsRunning)
+    {
+        pFsm->IsRunning = true;
+        
+        res = true;
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：运行当前状态机和子状态机
+ * 参数  ：(in)-pFsm           状态机指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool Fsm_runAll(Fsm * const pFsm)
+{
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    
+    Fsm_run(pFsm);
+    
+    if (pFsm->ChildList != NULL && pFsm->ChildList->Count > 0)
+    {
+        uint32_t i;
+        Fsm * pChildFsm;
+        
+        for (i = 0; i < pFsm->ChildList->Count; i++)
+        {
+            pChildFsm = (Fsm *)pFsm->ChildList
+                ->GetElementDataAt(pFsm->ChildList, i);
+            
+            if (pChildFsm != NULL)
+            {
+                Fsm_runAll(pChildFsm);
+            }
+        }
+    }
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：停止当前状态机
+ * 参数  ：(in)-pFsm           状态机指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool Fsm_stop(Fsm * const pFsm)
+{
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    
+    pFsm->IsRunning = false;
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：停止当前状态机和子状态机
+ * 参数  ：(in)-pFsm           状态机指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool Fsm_stopAll(Fsm * const pFsm)
+{
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    
+    Fsm_stop(pFsm);
+    
+    if (pFsm->ChildList != NULL && pFsm->ChildList->Count > 0)
+    {
+        uint32_t i;
+        Fsm * pChildFsm;
+        
+        for (i = 0; i < pFsm->ChildList->Count; i++)
+        {
+            pChildFsm = (Fsm *)pFsm->ChildList
+                ->GetElementDataAt(pFsm->ChildList, i);
+            
+            if (pChildFsm != NULL)
+            {
+                Fsm_stopAll(pChildFsm);
+            }
+        }
+    }
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：释放当前状态机
+ * 参数  ：(in)-pFsm           状态机指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool Fsm_dispose(Fsm * const pFsm)
+{
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    
+    if (pFsm->ChildList != NULL)
+    {
+        pFsm->ChildList->Dispose(pFsm->ChildList);
+    }
+    
+    ZF_FREE(pFsm);
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：释放当前状态机和子状态机
+ * 参数  ：(in)-pFsm           状态机指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool Fsm_disposeAll(Fsm * const pFsm)
+{
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    
+    if (pFsm->ChildList != NULL && pFsm->ChildList->Count > 0)
+    {
+        uint32_t i;
+        Fsm * pChildFsm;
+        
+        for (i = 0; i < pFsm->ChildList->Count; i++)
+        {
+            pChildFsm = (Fsm *)pFsm->ChildList
+                ->GetElementDataAt(pFsm->ChildList, i);
+            
+            if (pChildFsm != NULL)
+            {
+                Fsm_disposeAll(pChildFsm);
+            }
+        }
+    }
+    
+    Fsm_dispose(pFsm);
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：添加子状态机
+ * 参数  ：(in)-pFsm           状态机指针
+ *         (in)-pChildFsm      子状态机指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool Fsm_addChild(Fsm * const pFsm, Fsm * const pChildFsm)
+{
+    /* 返回结果 */
+    bool res = false;
+    
+    List *pList;
+    ListNode *pNode;
+    
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    ZF_ASSERT(pChildFsm != (Fsm *)0)
+    
+    if (pFsm->ChildList == NULL)
+    {
+        List_create(&pList);
+        pFsm->ChildList = pList;
+    }
+    
+    pList = pFsm->ChildList;
+    
+    if (pList != NULL)
+    {
+        List_mallocNode(&pNode, NULL, 0);
+        if (pNode != NULL)
+        {
+            pNode->pData = (void *)pChildFsm;
+            pNode->Size = sizeof(Fsm);
+            
+            pList->Add(pList, pNode);
+            
+            pChildFsm->Owner = pFsm;
+            pChildFsm->Level = pFsm->Level + 1;
+            
+            res = true;
+        }
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：移除子状态机(不释放空间)
+ * 参数  ：(in)-pFsm           状态机指针
+ *         (in)-pChildFsm      子状态机指针
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool Fsm_removeChild(Fsm * const pFsm, Fsm * const pChildFsm)
+{
+    /* 返回结果 */
+    bool res = false;
+    
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    ZF_ASSERT(pChildFsm != (Fsm *)0)
+    
+    if (pFsm->ChildList != NULL && pFsm->ChildList->Count > 0)
+    {
+        ListNode *pNode;
+        
+        /* 移除状态机 */
+        while(pFsm->ChildList
+            ->GetElementByData(pFsm->ChildList, pChildFsm, &pNode))
+        {
+            if (pNode == NULL)
+            {
+                break;
+            }
+            
+            if (!pFsm->ChildList->Delete(pFsm->ChildList, pNode))
+            {
+                ZF_DEBUG(LOG_E, "delete fsm node from list error\r\n");
+                
+                break;
+            }
+            
+            res = true;
+        }
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：调度状态机
+ * 参数  ：(in)-pFsm           状态机指针
+ *         (in)-signal         调度信号
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+bool Fsm_dispatch(Fsm * const pFsm, FsmSignal const signal)
+{
+    /* 返回结果 */
+    bool res = false;
+    
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    
+    if (pFsm->IsRunning)
+    {
+        if (pFsm->ChildList != NULL && pFsm->ChildList->Count > 0)
+        {
+            uint32_t i;
+            Fsm * pChildFsm;
+            
+            for (i = 0; i < pFsm->ChildList->Count; i++)
+            {
+                pChildFsm = (Fsm *)pFsm->ChildList
+                    ->GetElementDataAt(pFsm->ChildList, i);
+                
+                if (pChildFsm != NULL)
+                {
+                    Fsm_dispatch(pChildFsm, signal);
+                }
+            }
+        }
+        
+        if (pFsm->CurrentState != NULL)
+        {
+            /* 1:根状态机时调度
+               2:没设置触发状态时调度
+               3:正在触发状态时调度
+             */
+            if (pFsm->Owner == NULL || pFsm->OwnerTriggerState == NULL
+                || pFsm->OwnerTriggerState == pFsm->Owner->CurrentState)
+            {
+                pFsm->CurrentState(pFsm, signal);
+                
+                res = true;
+            }
+        }
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：状态转移
+ * 参数  ：(in)-pFsm           状态机指针
+ *         (in)-nextState      转移后状态
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+void Fsm_transfer(Fsm * const pFsm, IFsmState nextState)
+{
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    ZF_ASSERT(nextState != (IFsmState)0)
+    
+    pFsm->CurrentState = (IFsmState)nextState;
+}
+
+/******************************************************************************
+ * 描述  ：状态转移(触发转出和转入事件)
+ * 参数  ：(in)-pFsm           状态机指针
+ *         (in)-nextState      转移后状态
+ * 返回  ：-true               成功
+ *         -false              失败
+******************************************************************************/
+void Fsm_transferWithEvent(Fsm * const pFsm, IFsmState nextState)
+{
+    ZF_ASSERT(pFsm != (Fsm *)0)
+    ZF_ASSERT(nextState != (IFsmState)0)
+    
+    Fsm_dispatch(pFsm, FSM_EXIT_SIG);
+    
+    Fsm_transfer(pFsm, nextState);
+    
+    Fsm_dispatch(pFsm, FSM_ENTER_SIG);
+}
+
+/******************************** END OF FILE ********************************/

zf_list.c

@@ -0,0 +1,543 @@
+/**
+  *****************************************************************************
+  * @file    zf_list.c
+  * @author  Zorb
+  * @version V1.0.0
+  * @date    2018-06-28
+  * @brief   简单列表的实现
+  *****************************************************************************
+  * @history
+  *
+  * 1. Date:2018-06-28
+  *    Author:Zorb
+  *    Modification:建立文件
+  *
+  *****************************************************************************
+  */
+
+#include "zf_list.h"
+#include "zf_assert.h"
+#include "zf_debug.h"
+#include "zf_malloc.h"
+
+/******************************************************************************
+ * 描述  ：创建列表(内部分配空间)
+ * 参数  ：(out)-ppList 列表指针的指针
+ * 返回  ：无
+******************************************************************************/
+bool List_create(List **ppList)
+{
+    List *pList;
+    
+    ZF_ASSERT(ppList != (List **)0)
+    
+    /* 分配空间 */
+    pList = ZF_MALLOC(sizeof(List));
+    if (pList == NULL)
+    {
+        ZF_DEBUG(LOG_E, "malloc list space error\r\n");
+        return false;
+    }
+    
+    /* 初始化成员 */
+    pList->pRootNode = NULL;
+    pList->Count = 0;
+    
+    /* 初始化方法 */
+    pList->Add = List_add;
+    pList->Delete = List_delete;
+    pList->Remove = List_remove;
+    pList->GetElementAt = List_getElementAt;
+    pList->GetElementByData = List_getElementByData;
+    pList->GetElementDataAt = List_getElementDataAt;
+    pList->GetElementIndex = List_getElementIndex;
+    pList->AddElementAt = List_addElementAt;
+    pList->DeleteElementAt = List_deleteElementAt;
+    pList->RemoveElementAt = List_removeElementAt;
+    pList->Clear = List_clear;
+    pList->Dispose = List_dispose;
+    
+    /* 输出 */
+    *ppList = pList;
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：在尾端增加节点
+ * 参数  ：(in)-pList  列表结构体指针
+ *         (in)-pNode  要增加的节点
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool List_add(List * const pList, ListNode *pNode)
+{
+    ZF_ASSERT(pList != (List *)0)
+    ZF_ASSERT(pNode != (ListNode *)0)
+    
+    return List_addElementAt(pList, pList->Count, pNode);
+}
+
+/******************************************************************************
+ * 描述  ：删除节点(内部释放空间)
+ * 参数  ：(in)-pList  列表结构体指针
+ *         (in)-pNode  要删除的节点
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool List_delete(List * const pList, ListNode *pNode)
+{
+    /* 返回结果 */
+    bool res = false;
+    
+    /* 要删除节点的前一个节点 */
+    ListNode *pPreviousNode;
+    
+    ZF_ASSERT(pList != (List *)0)
+    ZF_ASSERT(pNode != (ListNode *)0)
+    
+    /* 要删除的是根节点 */
+    if (pNode == pList->pRootNode)
+    {
+        pList->pRootNode = pNode->Next;
+        pList->Count--;
+        
+        /* 释放空间 */
+        List_freeNode(pNode);
+        
+        res = true;
+    }
+    /* 要删除的不是根节点 */
+    else
+    {
+        pPreviousNode = pList->pRootNode;
+        while (pPreviousNode->Next != pNode)
+        {
+            pPreviousNode = pPreviousNode->Next;
+        }
+        
+        /* 找到要删除的节点 */
+        if(pPreviousNode != NULL || pPreviousNode->Next == pNode)
+        {
+            pPreviousNode->Next = pNode->Next;
+            pList->Count--;
+            
+            /* 释放空间 */
+            List_freeNode(pNode);
+            
+            res = true;
+        }
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：移除节点(内部不释放空间)
+ * 参数  ：(in)-pList  列表结构体指针
+ *         (in)-pNode  要删除的节点
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool List_remove(List * const pList, ListNode *pNode)
+{
+    /* 返回结果 */
+    bool res = false;
+    
+    /* 要移除节点的前一个节点 */
+    ListNode *pPreviousNode;
+    
+    ZF_ASSERT(pList != (List *)0)
+    ZF_ASSERT(pNode != (ListNode *)0)
+    
+    /* 要移除的是根节点 */
+    if (pNode == pList->pRootNode)
+    {
+        pList->pRootNode = pNode->Next;
+        pList->Count--;
+        
+        res = true;
+    }
+    /* 要移除的不是根节点 */
+    else
+    {
+        pPreviousNode = pList->pRootNode;
+        while (pPreviousNode->Next != pNode)
+        {
+            pPreviousNode = pPreviousNode->Next;
+        }
+        
+        /* 找到要移除的节点 */
+        if(pPreviousNode != NULL || pPreviousNode->Next == pNode)
+        {
+            pPreviousNode->Next = pNode->Next;
+            pList->Count--;
+            
+            res = true;
+        }
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：返回指定索引处的节点的指针
+ * 参数  ：(in)-pList   列表结构体指针
+ *         (in)-index   索引
+ *         (out)-ppNode 指定索引处的节点指针的指针
+ * 返回  ：-true        成功
+ *         -false       失败
+******************************************************************************/
+bool List_getElementAt(List * const pList, uint32_t index,
+    ListNode **ppNode)
+{
+    /* 返回结果 */
+    bool res = true;
+    
+    ListNode *pNode;
+    uint32_t i;
+    
+    ZF_ASSERT(pList != (List *)0)
+    ZF_ASSERT(index < pList->Count)
+    
+    pNode = pList->pRootNode;
+    for (i = 0; i < index; i++)
+    {
+        if (pNode->Next == NULL)
+        {
+            res = false;
+            break;
+        }
+        pNode = pNode->Next;
+    }
+    
+    if(res == true)
+    {
+        *ppNode = pNode;
+    }
+    else
+    {
+        *ppNode = NULL;
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：返回数据区指向data的节点的指针
+ * 参数  ：(in)-pList   列表结构体指针
+ *         (in)-pdata   数据缓冲区指针
+ *         (out)-ppNode 节点指针的地址
+ * 返回  ：-true        成功
+ *         -false       失败
+******************************************************************************/
+bool List_getElementByData(List * const pList, void *pdata, ListNode **ppNode)
+{
+    ListNode *pNode;
+    
+    ZF_ASSERT(pList != (List *)0)
+    ZF_ASSERT(pdata != (void *)0)
+    
+    pNode = pList->pRootNode;
+    while (pNode != NULL)
+    {
+        if (pNode->pData == pdata)
+        {
+            /* 输出 */
+            *ppNode = pNode;
+            
+            return true;
+        }
+        
+        pNode = pNode->Next;
+    }
+    
+    /* 输出 */
+    *ppNode = NULL;
+    
+    return false;
+}
+
+/******************************************************************************
+ * 描述  ：返回指定索引处的节点的数据缓冲区的指针
+ * 参数  ：(in)-pList   列表结构体指针
+ *         (in)-index   索引
+ * 返回  ：-成功        数据缓冲区的指针
+ *         -失败        NULL
+******************************************************************************/
+void *List_getElementDataAt(List * const pList, uint32_t index)
+{
+    ListNode *pNode;
+    
+    List_getElementAt(pList, index, &pNode);
+    
+    if (pNode != NULL)
+    {
+        return (void*)pNode->pData;
+    }
+    
+    return NULL;
+}
+
+/******************************************************************************
+ * 描述  ：返回节点的索引
+ * 参数  ：(in)-pList   列表结构体指针
+ *         (in)-pNode   节点
+ *         (out)-pIndex 节点的索引的指针
+ * 返回  ：-true        成功
+ *         -false       失败
+******************************************************************************/
+bool List_getElementIndex(List * const pList, ListNode *pNode,
+    uint32_t *pIndex)
+{
+    /* 返回结果 */
+    bool res = true;
+    
+    uint32_t index = 0;
+    
+    ListNode *pFindNode;
+    
+    ZF_ASSERT(pList != (List *)0)
+    ZF_ASSERT(pNode != (ListNode *)0)
+    
+    pFindNode = pList->pRootNode;
+    while (pFindNode != pNode && pFindNode != NULL)
+    {
+        pFindNode = pFindNode->Next;
+        index++;
+    }
+    
+    /* 没找到节点 */
+    if (pFindNode != pNode)
+    {
+        res = false;
+        index = 0;
+    }
+    
+    /* 输出索引 */
+    *pIndex = index;
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：在指定索引处增加节点(索引超过最大值，则在尾端增加)
+ * 参数  ：(in)-pList  列表结构体指针
+ *         (in)-index  索引
+ *         (in)-pNode  要增加的节点
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool List_addElementAt(List * const pList, uint32_t index,
+    ListNode *pNode)
+{
+    /* 返回结果 */
+    bool res = false;
+    
+    /* 要增加位置的前一个节点 */
+    ListNode *pPreviousNode;
+    
+    ZF_ASSERT(pList != (List *)0)
+    ZF_ASSERT(pNode != (ListNode *)0)
+    
+    if (index > pList->Count)
+    {
+        index = pList->Count;
+    }
+    
+    /* 根节点 */
+    if (index == 0)
+    {
+        /* 插入节点 */
+        pNode->Next = pList->pRootNode;
+        pList->pRootNode = pNode;
+        
+        /* 数量加1 */
+        pList->Count++;
+        
+        res = true;
+    }
+    else
+    {
+        /* 找要增加位置的前一个节点 */
+        if (List_getElementAt(pList, index - 1, &pPreviousNode))
+        {
+            /* 插入节点 */
+            pNode->Next = pPreviousNode->Next;
+            pPreviousNode->Next = pNode;
+            
+            /* 数量加1 */
+            pList->Count++;
+            
+            res = true;
+        }
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：在指定索引处删除节点(内部释放空间)
+ * 参数  ：(in)-pList  列表结构体指针
+ *         (in)-index  索引
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool List_deleteElementAt(List * const pList, uint32_t index)
+{
+    /* 要删除的节点 */
+    ListNode *pDeleteNode = NULL;
+    
+    ZF_ASSERT(pList != (List *)0)
+    ZF_ASSERT(index < pList->Count)
+    
+    if (!List_getElementAt(pList, index, &pDeleteNode))
+    {
+        return false;
+    }
+    
+    return List_delete(pList, pDeleteNode);
+}
+
+/******************************************************************************
+ * 描述  ：在指定索引处移除节点(内部不释放空间)
+ * 参数  ：(in)-pList  列表结构体指针
+ *         (in)-index  索引
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool List_removeElementAt(List * const pList, uint32_t index)
+{
+    /* 要移除的节点 */
+    ListNode *pDeleteNode = NULL;
+    
+    ZF_ASSERT(pList != (List *)0)
+    ZF_ASSERT(index < pList->Count)
+    
+    if (!List_getElementAt(pList, index, &pDeleteNode))
+    {
+        return false;
+    }
+    
+    return List_remove(pList, pDeleteNode);
+}
+
+/******************************************************************************
+ * 描述  ：清空列表(内部释放空间)
+ * 参数  ：(in)-pList  列表结构体指针
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool List_clear(List * const pList)
+{
+    /* 返回结果 */
+    bool res = true;
+    
+    ZF_ASSERT(pList != (List *)0)
+    
+    while (pList->Count)
+    {
+        res &= List_deleteElementAt(pList, 0);
+    }
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：释放列表(内部释放空间)
+ * 参数  ：(in)-pList  列表结构体指针
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool List_dispose(List * const pList)
+{
+    /* 返回结果 */
+    bool res = true;
+    
+    ZF_ASSERT(pList != (List *)0)
+    
+    res = List_clear(pList);
+    
+    ZF_FREE(pList);
+    
+    return res;
+}
+
+/******************************************************************************
+ * 描述  ：创建节点(内部分配空间，size=0表示使用外部数据)
+ * 参数  ：(out)-ppNode  节点指针的指针
+ *         (out)-ppData  存放的数据结构指针的指针
+ *         (in)-size    存放的数据结构大小(输入0则表示不内部分配数据空间)
+ * 返回  ：-true        成功
+ *         -false       失败
+******************************************************************************/
+bool List_mallocNode(ListNode **ppNode, void **ppData,
+    uint32_t size)
+{
+    ListNode *pNode;
+    void *pData;
+    
+    ZF_ASSERT(ppNode != (ListNode **)0)
+    
+    pNode = (ListNode *)ZF_MALLOC(sizeof(ListNode));
+    if (pNode == NULL)
+    {
+        ZF_DEBUG(LOG_E, "malloc list node space error\r\n");
+        return false;
+    }
+    
+    pNode->Next = NULL;
+    
+    if (size > 0)
+    {
+        ZF_ASSERT(ppData != (void **)0)
+        
+        pData = (void *)ZF_MALLOC(size);
+        if (pData == NULL)
+        {
+            ZF_DEBUG(LOG_E, "malloc list node data space error\r\n");
+            return false;
+        }
+        
+        pNode->pData = pData;
+        pNode->Size = size;
+        pNode->IsExternData = false;
+        
+        /* 输出 */
+        *ppData = pData;
+    }
+    else
+    {
+        pNode->pData = NULL;
+        pNode->Size = 0;
+        pNode->IsExternData = true;
+    }
+    
+    /* 输出 */
+    *ppNode = pNode;
+    
+    return true;
+}
+
+/******************************************************************************
+ * 描述  ：释放节点(不释放外部创建的数据)
+ * 参数  ：(in)-pNode  要释放的节点
+ * 返回  ：-true       成功
+ *         -false      失败
+******************************************************************************/
+bool List_freeNode(ListNode *pNode)
+{
+    ZF_ASSERT(pNode != (ListNode *)0)
+    
+    /* 外部创建的数据不释放 */
+    if (!pNode->IsExternData)
+    {
+        ZF_FREE(pNode->pData);
+    }
+    
+    ZF_FREE(pNode);
+    
+    return true;
+}
+
+/******************************** END OF FILE ********************************/