saturneric/ZE-Standard-Libraries
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed.

Browse Source
This commit is contained in:
Saturneic 2019-01-12 08:54:05 +08:00
parent 52806be374
commit 1116412c0a
15 changed files with 209 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
include/chain/chain.h
View File

@ -2,7 +2,7 @@
#define chain_h #define chain_h
#include <chain/chain_type.h> #include <chain/chain_type.h>
#include <list/list.h> #include <chain/chain.h>
/************************************************ /************************************************
*节点的快速初始化: 为新节点分配内存空间, *节点的快速初始化: 为新节点分配内存空间,
@ -285,4 +285,149 @@ extern CNode *findByStringForNode(Chain *, char *);
extern CNode *findByPointerForNode(Chain *, void *); extern CNode *findByPointerForNode(Chain *, void *);
/************************************************
*节点快速初始化相关宏,提供函数名较为简单的调用方式
************************************************/
/****
*不带ID模块相关宏
*/
/*直接获取一个以整型值初始化的节点不带ID的缩略*/
#define lni(cn) nodeWithInt(cn,0)
/*直接获取一个以无符号整型值初始化的不带ID节点的缩略*/
#define lnu(cn) nodeWithUInt(cn,0)
/*直接获取一个以无符号长整形值初始化的节点的缩略*/
#define lnull(cn) nodeWithULLInt(cn,0)
/*直接获取一个以浮点值初始化的不带ID节点的缩略*/
#define lnd(cn) nodeWithDouble(cn,0)
/*直接获取一个以字符串值初始化的不带ID节点的缩略*/
#define lns(cn) nodeWithString(cn,0)
/*直接获取一个以指针值初始化的不带ID节点的缩略*/
#define lnp(cn) nodeWithPointer(cn,0)
/****
*带ID模块的相关宏
*/
/*直接获取一个以整型值初始化的带ID节点的缩略*/
#define lsni(cn) nodeWithInt(cn,1)
/*直接获取一个以浮点值初始化的带ID节点的缩略*/
#define lsnd(cn) nodeWithDouble(cn,1)
/*直接获取一个以字符串值初始化的带ID节点的缩略*/
#define lsns(cn) nodeWithString(cn,1)
/*直接获取一个以指针值初始化的节点的缩略*/
#define lsnp(cn) nodeWithPointer(cn,1)
/************************************************
*链表快速插入相关宏
************************************************/
/****
*尾部相关
*/
/*在链表尾部直接加入一个已经用整型值初始化的不带ID的节点*/
#define lisrti(chain, cn) insertInTail(chain, lni(cn));
/*在链表尾部直接加入一个已经用浮点值初始化的不带ID的节点*/
#define lisrtd(chain, cn) insertInTail(chain, lnd(cn));
/*在链表尾部直接加入一个已经用无符号整型值初始化的不带ID的节点*/
#define lisrtu(chain, cn) insertInTail(chain, lnu(cn));
/*在链表尾部直接加入一个已经用无符号长整型值初始化的不带ID的节点*/
#define lisrtull(chain, cn) insertInTail(chain, lnull(cn));
/*在链表尾部直接加入一个已经用指针值初始化的不带ID的节点*/
#define lisrtp(chain, cn) insertInTail(chain, lnp(cn));
/*在链表尾部直接加入一个已经用字符串值初始化的不带ID的节点*/
#define lisrts(chain, cn) insertInTail(chain, lns(cn));
/****
*头部相关
*/
/*在链表头部直接加入一个已经用整型值初始化的不带ID的节点*/
#define lisrhi(chain, cn) insertInHead(chain, lni(cn));
/*在链表头部直接加入一个已经用浮点值初始化的不带ID的节点*/
#define lisrhd(chain, cn) insertInHead(chain, lnd(cn));
/*在链表头部直接加入一个已经用无符号整型值初始化的不带ID的节点*/
#define lisrhu(chain, cn) insertInHead(chain, lnu(cn));
/*在链表头部直接加入一个已经用无符号长整型值初始化的不带ID的节点*/
#define lisrhull(chain, cn) insertInHead(chain, lnull(cn));
/*在链表头部直接加入一个已经用指针值初始化的不带ID的节点*/
#define lisrhp(chain, cn) insertInHead(chain, lnp(cn));
/*在链表头部直接加入一个已经用字符串值初始化的不带ID的节点*/
#define lisrhs(chain, cn) insertInHead(chain, lns(cn));
/************************************************
*节点快速获得储存值相关宏
************************************************/
/*快速获得指针类型的节点所储存的值*/
#define lidxp(chain, cn) getByPointerForNode(findByIndexForNode(chain, cn))
/*快速获得整型类型的节点所储存的值*/
#define lidxi(chain, cn) getByIntForNode(findByIndexForNode(chain, cn))
/*快速获得浮点类型的节点所储存的值*/
#define lidxd(chain, cn) getByDoubleForNode(findByIndexForNode(chain, cn))
/*快速获得字符串类型的节点所储存的值*/
#define lidxs(chain, cn) getByStringForNode(findByIndexForNode(chain, cn))
/*快速获得无符号长整型类型的节点所储存的值*/
#define lupdull(chain,cn,value) updateValueWithULLIntForNode(findByIndexForNode(chain, cn),value)
/************************************************
*其他快速操作相关宏
************************************************/
/*通过节点的序号直接得到它的值*/
#define lidxvle(chain,cn) (findByIndexForNode(chain, cn)->value)
/*通过节点序号直接移除节点*/
#define lrmvidx(chain,cn) removeByNode(chain, findByIndexForNode(chain, cn)
/*从列表头移除节点的缩略*/
#define lpoph(chain) popFromHead(chain)
/*从列表尾移除节点的缩略*/
#define lpopt(chain) popFromTail(chain)
/*通过节点的ID直接获得节点的值*/
#define lfndsid(chain,sid) (findByIdForNode(chain,sid)->value)
/*创建一个不带ID的链表的缩略*/
#define lstns() initList(0);
/*创建一个带有ID的链表缩略*/
#define lstn() initList(1);
#endif /* chain_h */ #endif /* chain_h */

6
include/chain/chain_print.h
View File

@ -1,5 +1,5 @@
#ifndef list_print_h #ifndef chain_print_h
#define list_print_h #define chain_print_h
#include <chain/chain.h> #include <chain/chain.h>
#include <event/event.h> #include <event/event.h>
@ -39,4 +39,4 @@ __CALLBACK_STATE(printListForCustom);
void printNode(CNode *p_node); void printNode(CNode *p_node);
#endif /* list_print_h */ #endif /* chain_h */

4
include/chain/chain_type.h
View File

@ -3,12 +3,12 @@
#include <list/list_type.h> #include <list/list_type.h>
/* /**
*节点的管理及操作的结构 *节点的管理及操作的结构
*/ */
typedef struct Node CNode; typedef struct Node CNode;
/* /**
*链表的管理及操作的结构 *链表的管理及操作的结构
*/ */
typedef struct List Chain; typedef struct List Chain;

153
include/event/event.h
View File

@ -1,155 +1,8 @@
#ifndef list_expand_1_h #ifndef event_h
#define list_expand_1_h #define event_h
#include <chain/chain.h> #include <chain/chain.h>
/************************************************
*节点快速初始化相关宏,提供函数名较为简单的调用方式
************************************************/
/****
*不带ID模块相关宏
*/
/*直接获取一个以整型值初始化的节点不带ID的缩略*/
#define lni(x) nodeWithInt(x,0)
/*直接获取一个以无符号整型值初始化的不带ID节点的缩略*/
#define lnu(x) nodeWithUInt(x,0)
/*直接获取一个以无符号长整形值初始化的节点的缩略*/
#define lnull(x) nodeWithULLInt(x,0)
/*直接获取一个以浮点值初始化的不带ID节点的缩略*/
#define lnd(x) nodeWithDouble(x,0)
/*直接获取一个以字符串值初始化的不带ID节点的缩略*/
#define lns(x) nodeWithString(x,0)
/*直接获取一个以指针值初始化的不带ID节点的缩略*/
#define lnp(x) nodeWithPointer(x,0)
/****
*带ID模块的相关宏
*/
/*直接获取一个以整型值初始化的带ID节点的缩略*/
#define lsni(x) nodeWithInt(x,1)
/*直接获取一个以浮点值初始化的带ID节点的缩略*/
#define lsnd(x) nodeWithDouble(x,1)
/*直接获取一个以字符串值初始化的带ID节点的缩略*/
#define lsns(x) nodeWithString(x,1)
/*直接获取一个以指针值初始化的节点的缩略*/
#define lsnp(x) nodeWithPointer(x,1)
/************************************************
*链表快速插入相关宏
************************************************/
/****
*尾部相关
*/
/*在链表尾部直接加入一个已经用整型值初始化的不带ID的节点*/
#define lisrti(list, x) insertInTail(list, lni(x));
/*在链表尾部直接加入一个已经用浮点值初始化的不带ID的节点*/
#define lisrtd(list, x) insertInTail(list, lnd(x));
/*在链表尾部直接加入一个已经用无符号整型值初始化的不带ID的节点*/
#define lisrtu(list, x) insertInTail(list, lnu(x));
/*在链表尾部直接加入一个已经用无符号长整型值初始化的不带ID的节点*/
#define lisrtull(list, x) insertInTail(list, lnull(x));
/*在链表尾部直接加入一个已经用指针值初始化的不带ID的节点*/
#define lisrtp(list, x) insertInTail(list, lnp(x));
/*在链表尾部直接加入一个已经用字符串值初始化的不带ID的节点*/
#define lisrts(list, x) insertInTail(list, lns(x));
/****
*头部相关
*/
/*在链表头部直接加入一个已经用整型值初始化的不带ID的节点*/
#define lisrhi(list, x) insertInHead(list, lni(x));
/*在链表头部直接加入一个已经用浮点值初始化的不带ID的节点*/
#define lisrhd(list, x) insertInHead(list, lnd(x));
/*在链表头部直接加入一个已经用无符号整型值初始化的不带ID的节点*/
#define lisrhu(list, x) insertInHead(list, lnu(x));
/*在链表头部直接加入一个已经用无符号长整型值初始化的不带ID的节点*/
#define lisrhull(list, x) insertInHead(list, lnull(x));
/*在链表头部直接加入一个已经用指针值初始化的不带ID的节点*/
#define lisrhp(list, x) insertInHead(list, lnp(x));
/*在链表头部直接加入一个已经用字符串值初始化的不带ID的节点*/
#define lisrhs(list, x) insertInHead(list, lns(x));
/************************************************
*节点快速获得储存值相关宏
************************************************/
/*快速获得指针类型的节点所储存的值*/
#define lidxp(list, x) getByPointerForNode(findByIndexForNode(list, x))
/*快速获得整型类型的节点所储存的值*/
#define lidxi(list, x) getByIntForNode(findByIndexForNode(list, x))
/*快速获得浮点类型的节点所储存的值*/
#define lidxd(list, x) getByDoubleForNode(findByIndexForNode(list, x))
/*快速获得字符串类型的节点所储存的值*/
#define lidxs(list, x) getByStringForNode(findByIndexForNode(list, x))
/*快速获得无符号长整型类型的节点所储存的值*/
#define lupdull(list,x,value) updateValueWithULLIntForNode(findByIndexForNode(list, x),value)
/************************************************
*其他快速操作相关宏
************************************************/
/*通过节点的序号直接得到它的值*/
#define lidxvle(list,x) (findByIndexForNode(list, x)->value)
/*通过节点序号直接移除节点*/
#define lrmvidx(list,x) removeByNode(list, findByIndexForNode(list, x)
/*从列表头移除节点的缩略*/
#define lpoph(list) popFromHead(list)
/*从列表尾移除节点的缩略*/
#define lpopt(list) popFromTail(list)
/*通过节点的ID直接获得节点的值*/
#define lfndsid(list,sid) (findByIdForNode(list,sid)->value)
/*创建一个不带ID的链表的缩略*/
#define lstns() initList(0);
/*创建一个带有ID的链表缩略*/
#define lstn() initList(1);
#endif /* list_expand_1_h */
/************************************************ /************************************************
*回调函数的便捷操作相关宏 *回调函数的便捷操作相关宏
************************************************/ ************************************************/
@ -226,3 +79,5 @@
*若继续遍历则使用该宏 *若继续遍历则使用该宏
*/ */
#define __CRETURN__ newCReturn() #define __CRETURN__ newCReturn()
#endif /* event_h */

79
include/list/list_simple.h
View File

@ -1,79 +0,0 @@
#ifndef list_simple_h
#define list_simple_h
#include <list/list_type.h>
/************************************************
*单向节点的快速初始化: 为新节点分配内存空间,
* 并使用输入值对其进行初始化.
************************************************/
/*
*为新单向节点获取内存空间, 并使用整型值初始化新单向节点
*返回: 若成功则返回指向新单向节点的指针,若失败函数返回NULL.*/
extern s_Node *s_nodeWithInt(int);
/*
*为新单向节点获取内存空间, 并使用无符号整型值初始化新单向节点
*返回: 若成功则返回指向新单向节点的指针,若失败函数返回NULL.*/
extern s_Node *s_nodeWithUInt(unsigned int);
/*
*为新单向节点获取内存空间, 并使用浮点值初始化新单向节点
*返回: 若成功则返回指向新单向节点的指针,若失败函数返回NULL.*/
extern s_Node *s_nodeWithDouble(double);
/*
*为新单向节点获取内存空间, 并使用字符串值初始化新单向节点
*返回: 若成功则返回指向新单向节点的指针,若失败函数返回NULL.*/
extern s_Node *s_nodeWithString(const char *);
/*
*为新单向节点获取内存空间, 并使用指针值初始化新单向节点
*返回: 若成功则返回指向新单向节点的指针,若失败函数返回NULL.*/
extern s_Node *s_nodeWithPointer(const void *);
/*
*初始化单向链表节点,该种类节点可以与普通储存在List结构中.
*单向链表的引入主要在于对于简单问题提供更小开销的解决方案.但相应的操作函数较少,不如一般链表方便.
*返回: 如果成功返回指向该节点的指针,如果失败则返回NULL.*/
extern s_Node *s_initNode(void);
/*在单项链表的头部插入一个节点
*返回: 若成功函数返回0,若失败函数返回-1.*/
extern int s_insertInHead(List *p_list, s_Node *s_p_node);
/*
*在单项链表的尾部插入一个节点
*返回: 若成功函数返回0,若失败函数返回-1.*/
extern int s_insertInTail(List *p_list, s_Node *s_p_node);
/*
*释放单向节点所占的内存空间
*返回: 如果成功返回0, 失败则返回-1.*/
extern int s_releaseNode(s_Node *s_p_node);
/*
*释放单向链表所占的内存空间
*返回: 如果成功返回0, 失败则返回-1.*/
extern int s_releaseList(List *p_list);
/*
*自定义释放单向链表所占的内存空间
*参数: func是一个函数指针,它指向的函数现在每次释放节点时调用,
* 接收储存在节点中的值的指针,释放用户自定义的结构体的所占用内存.
* 回调函数返回0代表释放成功,返回-1代表释放失败.
*返回: 如果成功返回0, 失败则返回-1.*/
extern int s_releaseListForCustom(List *p_list, int (*func)(void *));
/*
*自定义释放单向节点所占的内存空间
*参数: func是一个函数指针,它指向的函数现在每次释放单项节点时调用,
* 接收储存在单项节点中的值得指针,释放用户自定义的结构体的所占用内存.
* 回调函数返回0代表释放成功,返回-1代表释放失败.
*返回: 如果成功返回0, 失败则返回-1.*/
extern int s_releaseNodeForCustom(s_Node *s_p_node, int (*func)(void *));
#endif /* list_simple_h */

12
include/list/list_type.h
View File

@ -6,24 +6,24 @@
#endif #endif
/* /*
*节点的管理及操作的结构 *链式结构节点的管理及操作的结构
*/ */
typedef struct Node{ typedef struct Node{
unsigned int type;//类型 unsigned int type;//类型
void *value;//值指针 void *value;//值指针
struct Node *next;//指向下一个节点 struct Node *next;//指向下一个链式结构节点
struct Node *last;//指向上一个节点 struct Node *last;//指向上一个链式结构节点
#ifdef id_enable #ifdef id_enable
SID *s_id; SID *s_id;
#endif #endif
} Node; } Node;
/* /*
*链表的管理及操作的结构 *链式结构的管理及操作的结构
*/ */
typedef struct List{ typedef struct List{
Node *head;//指向第一个节点 Node *head;//指向第一个链式结构节点
Node *tail;//指向最后一个节点 Node *tail;//指向最后一个链式结构节点
uint64_t length; uint64_t length;
#ifdef id_enable #ifdef id_enable
SID *s_id; SID *s_id;

2
src/datastruct/chain/chain_calculate.c
View File

@ -9,7 +9,7 @@
@return 以字节为单位返回链表及链表内包含的节点所占的内存空间 @return 以字节为单位返回链表及链表内包含的节点所占的内存空间
*/ */
uint64_t calListMemory(Chain * p_list){ uint64_t calListMemory(Chain * p_list){
Node *p_node = p_list->head; CNode *p_node = p_list->head;
uint64_t nodes_size = 0LL; uint64_t nodes_size = 0LL;
uint64_t list_size = sizeof(p_list); uint64_t list_size = sizeof(p_list);
while(p_node != NULL){ while(p_node != NULL){

10
src/event/event_callback.c
View File

@ -105,13 +105,9 @@ Chain *newReturn(int if_status ,int status, char *argc, ...){
lisrtull(p_list, va_arg(args, unsigned long long)); lisrtull(p_list, va_arg(args, unsigned long long));
count += 2; count += 2;
} }
else{ else count++;
count++;
}
}
else{
lisrtu(p_list, va_arg(args, unsigned int));
} }
else lisrtu(p_list, va_arg(args, unsigned int));
break; break;
default: default:
break; break;
@ -130,6 +126,6 @@ Chain *newReturn(int if_status ,int status, char *argc, ...){
@return 指向构造的参数列表的指针 @return 指向构造的参数列表的指针
*/ */
Chain *newCReturn(void){ inline Chain *newCReturn(void){
return newReturn(1, 0, NULL); return newReturn(1, 0, NULL);
} }

12
src/memory/list/list_copy.c
View File

@ -3,10 +3,10 @@
/** /**
以一个已存在的节点为模板创建一个相同的新的节点 以一个已存在的链式结构节点为模板创建一个相同的新的链式结构节点
@param p_node 指向作为模板的节点的指针 @param p_node 指向作为模板的链式结构节点的指针
@return 返回指向新的节点的指针 @return 返回指向新的链式结构节点的指针
*/ */
Node *copyNode(Node *p_node) { Node *copyNode(Node *p_node) {
Node *t_node = NULL; Node *t_node = NULL;
@ -25,10 +25,10 @@ Node *copyNode(Node *p_node) {
/** /**
根据已存在的链表创建一个相同的新的链表 根据已存在的链式结构创建一个相同的新的链式结构
@param p_list 指向作为模板的链表的指针 @param p_list 指向作为模板的链式结构的指针
@return 返回指向新链表的指针 @return 返回指向新链式结构的指针
*/ */
List *copyList(List *p_list) { List *copyList(List *p_list) {
Node *p_node; Node *p_node;

18
src/memory/list/list_find.c
View File

@ -4,11 +4,11 @@
//如果ID模块可能启用则编译以下代码 //如果ID模块可能启用则编译以下代码
#ifdef id_enable #ifdef id_enable
/** /**
通过ID查找链表中符合条件的第一个节点 通过ID查找链式结构中符合条件的第一个链式结构节点
@param p_list 指向目标链表的指针 @param p_list 指向目标链式结构的指针
@param s_id ID值 @param s_id ID值
@return 成功返回指向符合条件的节点的指针，不成功则返回NULL @return 成功返回指向符合条件的链式结构节点的指针，不成功则返回NULL
*/ */
Node *findByIdForNode(List *p_list, SID * s_id) { Node *findByIdForNode(List *p_list, SID * s_id) {
Node *ph_node = p_list->head; Node *ph_node = p_list->head;
@ -39,12 +39,12 @@ Node *findByIdForNode(List *p_list, SID * s_id) {
/** /**
通过值来查找链表中符合条件的第一个节点 通过值来查找链式结构中符合条件的第一个链式结构节点
@param p_list 指向目标链表的指针 @param p_list 指向目标链式结构的指针
@param type 值的类型 @param type 值的类型
@param value 值 @param value 值
@return 成功返回指向符合条件的节点的指针，不成功则返回NULL @return 成功返回指向符合条件的链式结构节点的指针，不成功则返回NULL
*/ */
Node *findByValue(List *p_list, uint type, const void *value) { Node *findByValue(List *p_list, uint type, const void *value) {
Node *p_node = p_list->head; Node *p_node = p_list->head;
@ -82,12 +82,12 @@ Node *findByValue(List *p_list, uint type, const void *value) {
} }
/** /**
通过值来查找链表中符合条件的所有节点 通过值来查找链式结构中符合条件的所有链式结构节点
@param p_list 指向目标链表的指针 @param p_list 指向目标链式结构的指针
@param type 值的类型 @param type 值的类型
@param value 值 @param value 值
@return 返回含有所有符合条件的节点的重组链表 @return 返回含有所有符合条件的链式结构节点的重组链式结构
*/ */
List *mply_findByValue(List *p_list, unsigned int type, const void *value) { List *mply_findByValue(List *p_list, unsigned int type, const void *value) {
List *f_list = initList(0); List *f_list = initList(0);

12
src/memory/list/list_info.c
View File

@ -3,20 +3,20 @@
/** /**
返回链表的长度 返回链式结构的长度
@param p_list 指向目标链表的指针 @param p_list 指向目标链式结构的指针
@return 返回目标链表的长度 @return 返回目标链式结构的长度
*/ */
uint64_t len(List *p_list) { uint64_t len(List *p_list) {
return p_list->length; return p_list->length;
} }
/** /**
检查链表是否为空 检查链式结构是否为空
@param p_list 指向目标链表的指针 @param p_list 指向目标链式结构的指针
@return 目标链表为空返回1，不为空返回0 @return 目标链式结构为空返回1，不为空返回0
*/ */
int isListEmpty(List *p_list) { int isListEmpty(List *p_list) {
if (p_list->head == NULL || p_list->tail == NULL)// If its head or tail is NULL,it would be thought as empty. if (p_list->head == NULL || p_list->tail == NULL)// If its head or tail is NULL,it would be thought as empty.

18
src/memory/list/list_init.c
View File

@ -3,10 +3,10 @@
/** /**
创建一个新的节点，并为其分配内存空间 创建一个新的链式结构节点，并为其分配内存空间
@param if_sid 新的节点是否带ID @param if_sid 新的链式结构节点是否带ID
@return 返回指向新的节点的内存地址指针 @return 返回指向新的链式结构节点的内存地址指针
*/ */
#ifdef id_enable #ifdef id_enable
Node *initNode(_Bool if_sid) Node *initNode(_Bool if_sid)
@ -27,7 +27,7 @@ Node *initNode(void)
p_node->next = NULL; p_node->next = NULL;
p_node->last = NULL; p_node->last = NULL;
p_node->type = VOID; p_node->type = VOID;
// 链表内存安全模式相关操作 // 链式结构内存安全模式相关操作
if (if_safeModeForNode) { if (if_safeModeForNode) {
if_safeModeForNode = 0; if_safeModeForNode = 0;
prec_node = initNode(0); prec_node = initNode(0);
@ -39,10 +39,10 @@ Node *initNode(void)
} }
/** /**
创建一个新的链表，并为其分配内存空间 创建一个新的链式结构，并为其分配内存空间
@param if_sid 新的链表是否带ID @param if_sid 新的链式结构是否带ID
@return 返回指向新的链表的内存地址指针 @return 返回指向新的链式结构的内存地址指针
*/ */
#ifdef id_enable #ifdef id_enable
List *initList(_Bool if_sid) List *initList(_Bool if_sid)
@ -73,9 +73,9 @@ List *initList(void)
} }
/** /**
为新的节点设定初始值 为新的链式结构节点设定初始值
@param p_node 指向目标节点的指针 @param p_node 指向目标链式结构节点的指针
@param type 值得类型 @param type 值得类型
@param p_value 指向目标值的内存空间的指针 @param p_value 指向目标值的内存空间的指针
@return 执行成功则返回0 @return 执行成功则返回0

18
src/memory/list/list_insert.c
View File

@ -2,10 +2,10 @@
#include <list/list.h> #include <list/list.h>
/** /**
在链表的头部插入节点 在链式结构的头部插入链式结构节点
@param p_list 指向目标链表的指针 @param p_list 指向目标链式结构的指针
@param p_node 指向目标节点的指针 @param p_node 指向目标链式结构节点的指针
@return 函数执行成功返回0 @return 函数执行成功返回0
*/ */
int insertInHead(List *p_list, Node *p_node) { int insertInHead(List *p_list, Node *p_node) {
@ -24,19 +24,13 @@ int insertInHead(List *p_list, Node *p_node) {
} }
/** /**
在链表的尾部插入节点 在链式结构的尾部插入链式结构节点
@param p_list 指向目标链表的指针 @param p_list 指向目标链式结构的指针
@param p_node 指向目标节点的指针 @param p_node 指向目标链式结构节点的指针
@return 函数执行成功返回0 @return 函数执行成功返回0
*/ */
int insertInTail(List *p_list, Node *p_node) { int insertInTail(List *p_list, Node *p_node) {
// 如果可能需要使用长链表模块则编译以下代码
/*
#ifdef list_quick_enable
if(p_list->p_lq != NULL && p_list->p_lq->if_sort) return -1;
#endif
*/
if (isListEmpty(p_list)) { if (isListEmpty(p_list)) {
p_list->head = p_node; p_list->head = p_node;
p_list->tail = p_node; p_list->tail = p_node;

1
src/memory/list/safe_mode.c
View File

@ -1,6 +1,5 @@
#include <type.h> #include <type.h>
#include <list/list.h> #include <list/list.h>
#include <chain/chain_quick.h>
static int if_safeModeForNode = 0; static int if_safeModeForNode = 0;
static List *node_list = NULL; static List *node_list = NULL;