From c64f6ad4bf34b58662d0b4eb36847da36dc97c54 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Wed, 7 Feb 2018 18:11:26 +0800 Subject: [PATCH 01/55] Add new files. --- list/list.c | 0 list/list.h | 0 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 list/list.c create mode 100644 list/list.h diff --git a/list/list.c b/list/list.c new file mode 100644 index 0000000..e69de29 diff --git a/list/list.h b/list/list.h new file mode 100644 index 0000000..e69de29 From 8f6da2622fc81fdeeca20f704c0ce5847c1a1b10 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Wed, 7 Feb 2018 20:09:44 +0800 Subject: [PATCH 02/55] Built the basement of the list. --- list/list.c | 14 ++++++++++++++ list/list.h | 24 ++++++++++++++++++++++++ 2 files changed, 38 insertions(+) diff --git a/list/list.c b/list/list.c index e69de29..f964bb4 100644 --- a/list/list.c +++ b/list/list.c @@ -0,0 +1,14 @@ +/* ******************************************************** + * This file is used to test the header file(list.h). + * When the project is finished, this file will be deleted. + * This file create by saturneric at 20:04 on Feb 7th. + * *******************************************************/ + +#include +#include +#include "list.h" + +int main(int argc, char **argv){ + + return 0; +} diff --git a/list/list.h b/list/list.h index e69de29..ae912f5 100644 --- a/list/list.h +++ b/list/list.h @@ -0,0 +1,24 @@ +typedef struct Node{ + unsigned long int id; + void *value; + struct Node *next; + struct Node *front; +} Node; + +typedef struct List{ + Node *head; + Node *tail; + unsigned long int length; +} List; + +List *init_list(); +Node *init_node(); +int insertInHead(List *p_list, Node *p_node); +int insertInTail(List*p_list, Node *p_node); +int removeById(List *p_list, unsigned long id); +int removeByNode(List *p_list, Node *p_node); +int popFromHead(List *p_list); +int popFromTail(List *p_list); +unsigned long int len(List *p_list); +Node *findById(List *p_list, unsigned long int id); +Node *findByValue(List *p_list, char type[], void *value); From f0f65761feeb142eb0cd4220775b66b4c9017adb Mon Sep 17 00:00:00 2001 From: MapleSign <347495867@qq.com> Date: Wed, 7 Feb 2018 23:28:28 +0800 Subject: [PATCH 03/55] Defined two functions. --- list/list.h | 27 +++++++++++++++++++++------ 1 file changed, 21 insertions(+), 6 deletions(-) diff --git a/list/list.h b/list/list.h index ae912f5..38c9203 100644 --- a/list/list.h +++ b/list/list.h @@ -1,20 +1,20 @@ typedef struct Node{ - unsigned long int id; + unsigned long int id;//what's this? void *value; - struct Node *next; - struct Node *front; -} Node; + Node *next; + Node *last; +}; typedef struct List{ Node *head; Node *tail; unsigned long int length; -} List; +}; List *init_list(); Node *init_node(); int insertInHead(List *p_list, Node *p_node); -int insertInTail(List*p_list, Node *p_node); +int insertInTail(List *p_list, Node *p_node); int removeById(List *p_list, unsigned long id); int removeByNode(List *p_list, Node *p_node); int popFromHead(List *p_list); @@ -22,3 +22,18 @@ int popFromTail(List *p_list); unsigned long int len(List *p_list); Node *findById(List *p_list, unsigned long int id); Node *findByValue(List *p_list, char type[], void *value); + + +int insertInHead(List *p_list, Node *p_node){ + p_list->head->last = p_node; + //p_node->last = NULL; + p_node->next = p_list->head; + p_list->head = p_node; +} + +int insertInTail(List *p_list, Node *p_node){ + p_list->tail->next = p_node; + //p_node->next = NULL; + p_node->last = p_list->tail; + p_list->tail = p_node; +} From 656658a0ef54e84df8123640ba7e2e591d903bd2 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Thu, 8 Feb 2018 10:37:44 +0800 Subject: [PATCH 04/55] Fix some faults. --- list/list.h | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/list/list.h b/list/list.h index 38c9203..9b069db 100644 --- a/list/list.h +++ b/list/list.h @@ -1,15 +1,15 @@ typedef struct Node{ - unsigned long int id;//what's this? + unsigned long int id; void *value; - Node *next; - Node *last; -}; + struct Node *next; + struct Node *last; +}Node; typedef struct List{ Node *head; Node *tail; unsigned long int length; -}; +}List; List *init_list(); Node *init_node(); @@ -29,6 +29,7 @@ int insertInHead(List *p_list, Node *p_node){ //p_node->last = NULL; p_node->next = p_list->head; p_list->head = p_node; + return 0; } int insertInTail(List *p_list, Node *p_node){ @@ -36,4 +37,5 @@ int insertInTail(List *p_list, Node *p_node){ //p_node->next = NULL; p_node->last = p_list->tail; p_list->tail = p_node; + return 0; } From afd8cc01a5d5e6b3b11e2db12d3b1fb39c252cf3 Mon Sep 17 00:00:00 2001 From: MapleSign <347495867@qq.com> Date: Thu, 8 Feb 2018 11:23:06 +0800 Subject: [PATCH 05/55] =?UTF-8?q?=E6=90=9E=E5=AE=9A=E4=BA=86remove?= =?UTF-8?q?=E5=92=8Cpop=EF=BC=8C=E4=BD=86=E6=98=AF=E4=BC=9A=E5=87=BA?= =?UTF-8?q?=E7=8E=B0=E5=86=85=E5=AD=98=E6=B3=84=E6=BC=8F=E7=9A=84=E6=83=85?= =?UTF-8?q?=E5=86=B5=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list.h | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/list/list.h b/list/list.h index 9b069db..f8b35a8 100644 --- a/list/list.h +++ b/list/list.h @@ -39,3 +39,69 @@ int insertInTail(List *p_list, Node *p_node){ p_list->tail = p_node; return 0; } + +int removeById(List *p_list, unsigned long id){ + Node *tmp = p_list->head; + if(tmp == NULL) + return -1;//这说明p_list指向空列表 + + do{ + if( *(tmp->value) == id ){ + tmp->last->next = tmp->next; + tmp->next->last = tmp->last; + return 1;//找到了 + } + else + tmp = tmp->next; + }while(tmp != NULL) + + return 0;//没找到 +} + +int removeByNode(List *p_list, Node *p_node){ + Node *tmp = p_list->head; + if(tmp == NULL) + return -1;//这说明p_list指向空列表 + + do{ + if(tmp == p_node){ + tmp->last->next = tmp->next; + tmp->next->last = tmp->last; + return 1;//找到了 + } + else + tmp = tmp->next; + }while(tmp != NULL) + + return 0;//没找到 +} + +int popFromHead(List *p_list){ + if(p_list->head == NULL) + return -1; + + if(p_list->head->next == NULL){ + p_list->head = NULL; + p_list->tail = NULL; + } + else{ + p_list->head->next->last = NULL; + p_list->head = p_list->head->next; + } + return 0; +} + +int popFromTail(List *p_list){ + if(p_list->head == NULL) + return -1; + + if(p_list->head->next == NULL){ + p_list->head = NULL; + p_list->tail = NULL; + } + else{ + p_list->tail->last->next = NULL; + p_list->tail = p_list->tail->last; + } + return 0; +} From 2cf9f97d2a25c360e5e5d3b4c53001ea5b09cdf2 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Thu, 8 Feb 2018 12:06:30 +0800 Subject: [PATCH 06/55] Added and defined some functions --- list/list.h | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/list/list.h b/list/list.h index 9b069db..691d796 100644 --- a/list/list.h +++ b/list/list.h @@ -22,11 +22,12 @@ int popFromTail(List *p_list); unsigned long int len(List *p_list); Node *findById(List *p_list, unsigned long int id); Node *findByValue(List *p_list, char type[], void *value); - +int releaseList(List *p_list); +int releaseNode(Node *p_node); int insertInHead(List *p_list, Node *p_node){ p_list->head->last = p_node; - //p_node->last = NULL; + p_node->last = NULL; p_node->next = p_list->head; p_list->head = p_node; return 0; @@ -34,8 +35,26 @@ int insertInHead(List *p_list, Node *p_node){ int insertInTail(List *p_list, Node *p_node){ p_list->tail->next = p_node; - //p_node->next = NULL; + p_node->next = NULL; p_node->last = p_list->tail; p_list->tail = p_node; return 0; } + +int releaseNode(Node *p_node){ + free(p_node->value); + free(p_node); + return 0; +} + +int releaseList(List *p_list){ + Node *p_node, *pl_node; + p_node = p_list->head; + while (p_node != NULL){ + pl_node = p_node; + p_node = p_node->next; + releaseNode(pl_node); + } + free(p_list); + return 0; +} From 6b01c5fa6b37835f1a54e6bd6504c433a43fe203 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Thu, 8 Feb 2018 17:10:32 +0800 Subject: [PATCH 07/55] Definded finding functions. --- list/list.h | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-) diff --git a/list/list.h b/list/list.h index 702154c..3c42725 100644 --- a/list/list.h +++ b/list/list.h @@ -20,8 +20,8 @@ int removeByNode(List *p_list, Node *p_node); int popFromHead(List *p_list); int popFromTail(List *p_list); unsigned long int len(List *p_list); -Node *findById(List *p_list, unsigned long int id); -Node *findByValue(List *p_list, char type[], void *value); +Node *findById(List *p_list, const unsigned long int id); +Node *findByValue(List *p_list, const char *type, const void *value); int releaseList(List *p_list); int releaseNode(Node *p_node); @@ -124,3 +124,59 @@ int popFromTail(List *p_list){ } return 0; } + +/*The method in this function won't be better than going through the list + * node by node.The worst situation happens when the matched node is in + * the middle of the list.*/ +Node *findById(List *p_list, const unsigned long int id){ + Node *ph_node = p_list->head; + Node *pt_node = p_list->tail; + int direction = 0; + while(ph_node != pt_node){ + if (direction == 0){ + if (ph_node->id == id){ + return ph_node; + } + else{ + ph_node = ph_node->next; + } + direction = 1; + } + else{ + if (pt_node->id == id){ + return pt_node; + } + else{ + pt_node = pt_node->last; + } + } + } + return NULL; +} + +Node *findByValue(List *p_list, const char *type, const void *value){ + Node *p_node = p_list->head; + while(p_node != NULL){ + if(!strcmp(type,"int")){ + if(*((int *)p_node) == *((int *)value)){ + return p_node; + } + } + else if(!strcmp(type,"double")){ + if(*((double *)p_node) == *((double *)value)){ + return p_node; + } + } + else if(!strcmp (type,"string")){ + if(!strcmp((char *)p_node->value,(char *)value)) + { + return p_node; + } + } + else{ + return NULL; + } + + } + return NULL; +} From ef8e7bd5ba322c06c94859bcdd1ab78816bdb213 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Thu, 8 Feb 2018 17:35:30 +0800 Subject: [PATCH 08/55] Defined initList function and added something about safe mode. --- list/list.h | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/list/list.h b/list/list.h index 3c42725..e320f5b 100644 --- a/list/list.h +++ b/list/list.h @@ -11,8 +11,10 @@ typedef struct List{ unsigned long int length; }List; +int safeMode(int ifon);//Safe mode is used to make sure that all malloced will be freed. List *init_list(); Node *init_node(); +unsigned long int *getId(); int insertInHead(List *p_list, Node *p_node); int insertInTail(List *p_list, Node *p_node); int removeById(List *p_list, unsigned long id); @@ -25,6 +27,21 @@ Node *findByValue(List *p_list, const char *type, const void *value); int releaseList(List *p_list); int releaseNode(Node *p_node); +/*Something about safe mode*/ +int if_safeMode = 0; +List *node_list; //Store nodes which haven't been freed. +List *list_list; //Store lists which haven't been freed. + +List *init_list(){ + List *p_list = malloc(sizeof(List)); + p_list->head = NULL; + p_list->tail = NULL; + Node *p_node = init_node(); + p_node->value = (void *)p_list; + if(if_safeMode) insertInHead(list_list,p_node); + return p_list; +} + int insertInHead(List *p_list, Node *p_node){ p_list->head->last = p_node; p_node->last = NULL; From a1e8e897c9620eb52b2906fb10bba1e1bc452db9 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Fri, 9 Feb 2018 11:20:04 +0800 Subject: [PATCH 09/55] Redefined some functions and add somne functions; --- list/list.h | 43 ++++++++++++++++++++++++++++++++----------- 1 file changed, 32 insertions(+), 11 deletions(-) diff --git a/list/list.h b/list/list.h index e320f5b..0eb6d0b 100644 --- a/list/list.h +++ b/list/list.h @@ -1,6 +1,7 @@ typedef struct Node{ - unsigned long int id; + unsigned long long id; void *value; + int if_setvalue; struct Node *next; struct Node *last; }Node; @@ -8,21 +9,22 @@ typedef struct Node{ typedef struct List{ Node *head; Node *tail; - unsigned long int length; + unsigned long long length; }List; int safeMode(int ifon);//Safe mode is used to make sure that all malloced will be freed. -List *init_list(); -Node *init_node(); -unsigned long int *getId(); +List *init_list(void); +Node *init_node(void); +int init_value(Node *,void *); +unsigned long long getId(void); int insertInHead(List *p_list, Node *p_node); int insertInTail(List *p_list, Node *p_node); int removeById(List *p_list, unsigned long id); int removeByNode(List *p_list, Node *p_node); int popFromHead(List *p_list); int popFromTail(List *p_list); -unsigned long int len(List *p_list); -Node *findById(List *p_list, const unsigned long int id); +unsigned long long len(List *p_list); +Node *findById(List *p_list, const unsigned long long id); Node *findByValue(List *p_list, const char *type, const void *value); int releaseList(List *p_list); int releaseNode(Node *p_node); @@ -32,16 +34,35 @@ int if_safeMode = 0; List *node_list; //Store nodes which haven't been freed. List *list_list; //Store lists which haven't been freed. -List *init_list(){ - List *p_list = malloc(sizeof(List)); +Node *init_node(void){ + Node *p_node = (Node *) malloc(sizeof(Node)); + p_node->id = getId(); + p_node->if_setvalue = 0; + if(if_safeMode) insertInTail(node_list,p_node); + return p_node; +} + +List *init_list(void){ + List *p_list = (List *) malloc(sizeof(List)); p_list->head = NULL; p_list->tail = NULL; Node *p_node = init_node(); - p_node->value = (void *)p_list; + init_value(p_node,(void *)p_list); if(if_safeMode) insertInHead(list_list,p_node); return p_list; } +unsigned long long getId(void){ + unsigned long long id = 0; + srand(time(0)); + id = ((random()%9)+1)*10; + for(int i = 0; i < 18; i++){ + id = random()%10; + id *= 10; + } + return id; +} + int insertInHead(List *p_list, Node *p_node){ p_list->head->last = p_node; p_node->last = NULL; @@ -145,7 +166,7 @@ int popFromTail(List *p_list){ /*The method in this function won't be better than going through the list * node by node.The worst situation happens when the matched node is in * the middle of the list.*/ -Node *findById(List *p_list, const unsigned long int id){ +Node *findById(List *p_list, const unsigned long long id){ Node *ph_node = p_list->head; Node *pt_node = p_list->tail; int direction = 0; From 126fd5dbcb0ea4fb4cc28b32f0b64e70be962c3f Mon Sep 17 00:00:00 2001 From: MapleSign <347495867@qq.com> Date: Fri, 9 Feb 2018 17:51:15 +0800 Subject: [PATCH 10/55] Define function "isListEmpty". Change the way "pop" and "remove" work in. May have solved memory leak problem. --- list/list.h | 94 ++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 64 insertions(+), 30 deletions(-) diff --git a/list/list.h b/list/list.h index 0eb6d0b..c73e0f7 100644 --- a/list/list.h +++ b/list/list.h @@ -12,23 +12,33 @@ typedef struct List{ unsigned long long length; }List; -int safeMode(int ifon);//Safe mode is used to make sure that all malloced will be freed. +int safeMode(int ifon);//Safe mode is used to make sure that all malloced will be freed. + List *init_list(void); Node *init_node(void); int init_value(Node *,void *); + unsigned long long getId(void); + int insertInHead(List *p_list, Node *p_node); int insertInTail(List *p_list, Node *p_node); + int removeById(List *p_list, unsigned long id); int removeByNode(List *p_list, Node *p_node); + int popFromHead(List *p_list); int popFromTail(List *p_list); + unsigned long long len(List *p_list); + Node *findById(List *p_list, const unsigned long long id); Node *findByValue(List *p_list, const char *type, const void *value); + int releaseList(List *p_list); int releaseNode(Node *p_node); +int isListEmpty(List *p_list); + /*Something about safe mode*/ int if_safeMode = 0; List *node_list; //Store nodes which haven't been freed. @@ -64,18 +74,30 @@ unsigned long long getId(void){ } int insertInHead(List *p_list, Node *p_node){ - p_list->head->last = p_node; - p_node->last = NULL; - p_node->next = p_list->head; - p_list->head = p_node; + if( isListEmpty(p_list) ){ + p_list->head = p_node; + p_list->tail = p_node; + } + else{ + p_list->head->last = p_node; + p_node->last = NULL; + p_node->next = p_list->head; + p_list->head = p_node; + } return 0; } int insertInTail(List *p_list, Node *p_node){ - p_list->tail->next = p_node; - p_node->next = NULL; - p_node->last = p_list->tail; - p_list->tail = p_node; + if( isListEmpty(p_list) ){ + p_list->head = p_node; + p_list->tail = p_node; + } + else{ + p_list->tail->next = p_node; + p_node->next = NULL; + p_node->last = p_list->tail; + p_list->tail = p_node; + } return 0; } @@ -99,66 +121,72 @@ int releaseList(List *p_list){ int removeById(List *p_list, unsigned long id){ Node *tmp = p_list->head; - if(tmp == NULL) return -1;//这说明p_list指向空列表 + if( isListEmpty(p_list) ) + return -1; do{ if(tmp->id == id) { tmp->last->next = tmp->next; tmp->next->last = tmp->last; - return 1;//找到了 + realeaseNode(tmp); + return 1;//found } else{ tmp = tmp->next; } - } while(tmp != NULL); + }while(tmp != NULL); - return 0;//没找到 + return 0;//not find } int removeByNode(List *p_list, Node *p_node){ Node *tmp = p_list->head; - if(tmp == NULL) - return -1;//这说明p_list指向空列表 - + if( isListEmpty(p_list) ) + return -1; do{ if(tmp == p_node){ tmp->last->next = tmp->next; tmp->next->last = tmp->last; - return 1;//找到了 + releaseNode(tmp); + return 1;//found } else{ tmp = tmp->next; } }while(tmp != NULL); - return 0;//没找到 + return 0;//not find } int popFromHead(List *p_list){ - if(p_list->head == NULL) + if( isListEmpty(p_list) ) return -1; - - if(p_list->head->next == NULL){ - p_list->head = NULL; - p_list->tail = NULL; - } else{ + Node *tmp = p_list->head; p_list->head->next->last = NULL; p_list->head = p_list->head->next; + releaseNode(tmp); + } + + if( isListEmpty(p_list) ){ + p_list->head = NULL; + p_list->tail = NULL; } return 0; } int popFromTail(List *p_list){ - if(p_list->head == NULL) + if( isListEmpty(p_list) ) return -1; - - if(p_list->head->next == NULL){ - p_list->head = NULL; - p_list->tail = NULL; - } else{ + Node *tmp = p_list->tail; p_list->tail->last->next = NULL; p_list->tail = p_list->tail->last; + releaseNode(tmp); + } + + if( isListEmpty(p_list) ){ + p_list->head = NULL; + p_list->tail = NULL; } return 0; } @@ -218,3 +246,9 @@ Node *findByValue(List *p_list, const char *type, const void *value){ } return NULL; } + +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. + return 1; // But we should ensure that both of them are NULL when we + return 0; // want to make a list empty. +} From 24cce47af4c0561bfe18e18b757222cc80d408c4 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Sat, 10 Feb 2018 15:38:56 +0800 Subject: [PATCH 11/55] Defind some functions about safemod. Modified original structures and functions in order to satisfy the safe mode requirements. --- list/list.h | 56 ++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 49 insertions(+), 7 deletions(-) diff --git a/list/list.h b/list/list.h index 0eb6d0b..304f297 100644 --- a/list/list.h +++ b/list/list.h @@ -12,7 +12,8 @@ typedef struct List{ unsigned long long length; }List; -int safeMode(int ifon);//Safe mode is used to make sure that all malloced will be freed. +int safeMode(int ifon);//Safe mode is used to make sure that all malloced will be freed. +int releaseAll(void); List *init_list(void); Node *init_node(void); int init_value(Node *,void *); @@ -31,8 +32,32 @@ int releaseNode(Node *p_node); /*Something about safe mode*/ int if_safeMode = 0; -List *node_list; //Store nodes which haven't been freed. -List *list_list; //Store lists which haven't been freed. +List *node_list = NULL; //Store nodes which haven't been freed. +List *list_list = NULL; //Store lists which haven't been freed. + +int safeMode(int ifon){ + if(ifon == 1){ + if (node_list == NULL && list_list == NULL){ + node_list = (List *)malloc(sizeof(List)); + list_list = (List *)malloc(sizeof(List)); + if_safeMode = 1; + } + else{ + return -1; + } + } + + return ifon; +} + +int releaseAll(void){ + if(if_safeMode == 1){ + if_safeMode = 0; + releaseList(node_list); + releaseList(list_list); + } + return 0; +} Node *init_node(void){ Node *p_node = (Node *) malloc(sizeof(Node)); @@ -46,12 +71,20 @@ List *init_list(void){ List *p_list = (List *) malloc(sizeof(List)); p_list->head = NULL; p_list->tail = NULL; - Node *p_node = init_node(); - init_value(p_node,(void *)p_list); - if(if_safeMode) insertInHead(list_list,p_node); + if(if_safeMode){ + Node *p_node = init_node(); + init_value(p_node,(void *)p_list); + insertInTail(list_list,p_node); + } return p_list; } +int init_value(Node *p_node,void * p_value){ + p_node->if_setvalue = 1; + p_node->value = p_value; + return 0; +} + unsigned long long getId(void){ unsigned long long id = 0; srand(time(0)); @@ -80,7 +113,12 @@ int insertInTail(List *p_list, Node *p_node){ } int releaseNode(Node *p_node){ - free(p_node->value); + if(if_safeMode == 1){ + removeByNode(node_list,p_node); + } + if(p_node->if_setvalue == 1){ + free(p_node->value); + } free(p_node); return 0; } @@ -88,6 +126,10 @@ int releaseNode(Node *p_node){ int releaseList(List *p_list){ Node *p_node, *pl_node; p_node = p_list->head; + if(if_safeMode == 1){ + Node *tar_list = findByValue(list_list,"int",(void *)p_list); + removeByNode(list_list,tar_list); + } while (p_node != NULL){ pl_node = p_node; p_node = p_node->next; From 6cb730d79360b5e5efa7b2b08b7c53e6eb54ebc4 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Sat, 10 Feb 2018 22:00:08 +0800 Subject: [PATCH 12/55] Debug. insertInTail() and findByValue() has been tested and modified. It seems that both of them work fine now. --- list/list.c | 20 ++++++++++++++++---- list/list.h | 28 +++++++++++++++++++--------- 2 files changed, 35 insertions(+), 13 deletions(-) diff --git a/list/list.c b/list/list.c index f964bb4..6ec8597 100644 --- a/list/list.c +++ b/list/list.c @@ -3,12 +3,24 @@ * When the project is finished, this file will be deleted. * This file create by saturneric at 20:04 on Feb 7th. * *******************************************************/ - -#include -#include + #include "list.h" -int main(int argc, char **argv){ +int main(int argc, char **argv){ + rand_init(); + List *t_list = init_list(); + for(int i = 0; i < 9; i++){ + Node *t_node = init_node(); + int *t_i = (int *)malloc(sizeof(int)); + *t_i = i; + init_value(t_node,(void *)t_i); + insertInTail(t_list,t_node); + } + int *f_i = (int *)malloc(sizeof(int)); + *f_i = 3; + Node *f_node = findByValue(t_list,"int",(void *)f_i); + releaseList(t_list); + return 0; } diff --git a/list/list.h b/list/list.h index 85063dc..1eb98bb 100644 --- a/list/list.h +++ b/list/list.h @@ -1,3 +1,8 @@ +#include +#include +#include +#include + typedef struct Node{ unsigned long long id; void *value; @@ -17,6 +22,7 @@ int releaseAll(void); List *init_list(void); Node *init_node(void); int init_value(Node *,void *); +void init_rand(void); unsigned long long getId(void); @@ -94,13 +100,16 @@ int init_value(Node *p_node,void * p_value){ return 0; } +void rand_init(void){ + srand((unsigned)time(NULL)); +} + unsigned long long getId(void){ unsigned long long id = 0; - srand(time(0)); - id = ((random()%9)+1)*10; - for(int i = 0; i < 18; i++){ - id = random()%10; + id = ((random()%9)+1); + for(int i = 0; i < 15; i++){ id *= 10; + id += random()%10; } return id; } @@ -116,6 +125,7 @@ int insertInHead(List *p_list, Node *p_node){ p_node->next = p_list->head; p_list->head = p_node; } + p_list->length += 1; return 0; } @@ -130,6 +140,7 @@ int insertInTail(List *p_list, Node *p_node){ p_node->last = p_list->tail; p_list->tail = p_node; } + p_list->length += 1; return 0; } @@ -265,12 +276,12 @@ Node *findByValue(List *p_list, const char *type, const void *value){ Node *p_node = p_list->head; while(p_node != NULL){ if(!strcmp(type,"int")){ - if(*((int *)p_node) == *((int *)value)){ + if(*((int *)p_node->value) == *((int *)value)){ return p_node; } } else if(!strcmp(type,"double")){ - if(*((double *)p_node) == *((double *)value)){ + if(*((double *)p_node->value) == *((double *)value)){ return p_node; } } @@ -280,9 +291,8 @@ Node *findByValue(List *p_list, const char *type, const void *value){ return p_node; } } - else{ - return NULL; - } + + p_node = p_node->next; } return NULL; From 305f6955c92730d14dbd1e01945c1341d86fc11d Mon Sep 17 00:00:00 2001 From: Saturneric Date: Sun, 11 Feb 2018 09:20:19 +0800 Subject: [PATCH 13/55] Debug. Modified some functions. --- list/list.c | 13 ++++++++++--- list/list.h | 44 ++++++++++++++++++++++++++++++++++---------- 2 files changed, 44 insertions(+), 13 deletions(-) diff --git a/list/list.c b/list/list.c index 6ec8597..7a7a4c4 100644 --- a/list/list.c +++ b/list/list.c @@ -8,19 +8,26 @@ int main(int argc, char **argv){ rand_init(); + safeMode(1); List *t_list = init_list(); for(int i = 0; i < 9; i++){ Node *t_node = init_node(); int *t_i = (int *)malloc(sizeof(int)); *t_i = i; - init_value(t_node,(void *)t_i); + init_value(t_node,"int",(void *)t_i); insertInTail(t_list,t_node); } + + /*Node *t_node = init_node(); + insertInTail(t_list,t_node); + init_value(t_node,(void *)"there");*/ + int *f_i = (int *)malloc(sizeof(int)); *f_i = 3; + char *f_s = "there"; Node *f_node = findByValue(t_list,"int",(void *)f_i); - releaseList(t_list); - + releaseAll(); + return 0; } diff --git a/list/list.h b/list/list.h index 1eb98bb..43b7d5e 100644 --- a/list/list.h +++ b/list/list.h @@ -7,6 +7,7 @@ typedef struct Node{ unsigned long long id; void *value; int if_setvalue; + const char *type; struct Node *next; struct Node *last; }Node; @@ -21,7 +22,7 @@ int safeMode(int ifon);//Safe mode is used to make sure that all malloced will b int releaseAll(void); List *init_list(void); Node *init_node(void); -int init_value(Node *,void *); +int init_value(Node *,const char *,void *); void init_rand(void); unsigned long long getId(void); @@ -88,14 +89,15 @@ List *init_list(void){ p_list->tail = NULL; if(if_safeMode){ Node *p_node = init_node(); - init_value(p_node,(void *)p_list); + init_value(p_node,"pointer",(void *)p_list); insertInTail(list_list,p_node); } return p_list; } -int init_value(Node *p_node,void * p_value){ +int init_value(Node *p_node,const char *type,void * p_value){ p_node->if_setvalue = 1; + p_node->type = type; p_node->value = p_value; return 0; } @@ -150,7 +152,10 @@ int releaseNode(Node *p_node){ } if(p_node->if_setvalue == 1){ free(p_node->value); + p_node->value = NULL; } + p_node->last = NULL; + p_node->next = NULL; free(p_node); return 0; } @@ -159,18 +164,27 @@ int releaseList(List *p_list){ Node *p_node, *pl_node; p_node = p_list->head; if(if_safeMode == 1){ - Node *tar_list = findByValue(list_list,"int",(void *)p_list); + Node *tar_list = findByValue(list_list,"pointer",(void *)p_list);//turn pointer in to int to compare. removeByNode(list_list,tar_list); } while (p_node != NULL){ pl_node = p_node; p_node = p_node->next; + pl_node->next = NULL; + pl_node->last = NULL; releaseNode(pl_node); } + p_list->head = NULL; + p_list->tail = NULL; + p_list->length = 0; free(p_list); return 0; } +unsigned long long len(List *p_list){ + return p_list->length; +} + int removeById(List *p_list, unsigned long id){ Node *tmp = p_list->head; if( isListEmpty(p_list) ) @@ -179,7 +193,8 @@ int removeById(List *p_list, unsigned long id){ if(tmp->id == id) { tmp->last->next = tmp->next; tmp->next->last = tmp->last; - releaseNode(tmp); + //releaseNode(tmp); not necessary + p_list->length -= 1; return 1;//found } else{ @@ -198,7 +213,8 @@ int removeByNode(List *p_list, Node *p_node){ if(tmp == p_node){ tmp->last->next = tmp->next; tmp->next->last = tmp->last; - releaseNode(tmp); + //releaseNode(tmp); not necessary + p_list->length -= 1; return 1;//found } else{ @@ -213,10 +229,11 @@ int popFromHead(List *p_list){ if( isListEmpty(p_list) ) return -1; else{ - Node *tmp = p_list->head; + //Node *tmp = p_list->head; p_list->head->next->last = NULL; p_list->head = p_list->head->next; - releaseNode(tmp); + //releaseNode(tmp); not necessary + p_list->length -= 1; } if( isListEmpty(p_list) ){ @@ -230,10 +247,11 @@ int popFromTail(List *p_list){ if( isListEmpty(p_list) ) return -1; else{ - Node *tmp = p_list->tail; + //Node *tmp = p_list->tail; p_list->tail->last->next = NULL; p_list->tail = p_list->tail->last; - releaseNode(tmp); + //releaseNode(tmp); not necessary + p_list->length -= 1; } if( isListEmpty(p_list) ){ @@ -275,6 +293,7 @@ Node *findById(List *p_list, const unsigned long long id){ Node *findByValue(List *p_list, const char *type, const void *value){ Node *p_node = p_list->head; while(p_node != NULL){ + if(strcmp(p_node->type,type)) continue;//continue when type is not the same. if(!strcmp(type,"int")){ if(*((int *)p_node->value) == *((int *)value)){ return p_node; @@ -291,6 +310,11 @@ Node *findByValue(List *p_list, const char *type, const void *value){ return p_node; } } + else if(!strcmp(type,"pointer")){ + if(p_node->value == value){ + return p_node; + } + } p_node = p_node->next; From 598c360c8bad0cd1507cd502f0606364aee521cf Mon Sep 17 00:00:00 2001 From: Saturneric Date: Mon, 12 Feb 2018 08:30:03 +0800 Subject: [PATCH 14/55] Add and Modified. --- list/list.h | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ list/list_easy.h | 14 ++++++++++++++ 2 files changed, 62 insertions(+) create mode 100644 list/list_easy.h diff --git a/list/list.h b/list/list.h index 43b7d5e..66b3f9f 100644 --- a/list/list.h +++ b/list/list.h @@ -3,6 +3,9 @@ #include #include +#ifndef LIST_H +#define LIST_H + typedef struct Node{ unsigned long long id; void *value; @@ -12,6 +15,7 @@ typedef struct Node{ struct Node *last; }Node; + typedef struct List{ Node *head; Node *tail; @@ -40,6 +44,7 @@ unsigned long long len(List *p_list); Node *findById(List *p_list, const unsigned long long id); Node *findByValue(List *p_list, const char *type, const void *value); +List *mply_findByValue(List *p_list, const char *type, const void *value); int releaseList(List *p_list); int releaseNode(Node *p_node); @@ -322,8 +327,51 @@ Node *findByValue(List *p_list, const char *type, const void *value){ return NULL; } +List *mply_findByValue(List *p_list, const char *type, const void *value){ + List *f_list = init_list(); + Node *p_node = p_list->head; + while(p_node != NULL){ + if(strcmp(p_node->type,type)) continue; + if(!strcmp(type,"int")){ + if(*((int *)p_node->value) == *((int *)value)){ + Node *f_node = init_node(); + init_value(f_node,"pointer",(void *)p_node); + insertInTail(f_list,f_node); + } + } + else if(!strcmp(type,"double")){ + if(*((double *)p_node->value) == *((double *)value)){ + Node *f_node = init_node(); + init_value(f_node,"pointer",(void *)p_node); + insertInTail(f_list,f_node); + } + } + else if(!strcmp (type,"string")){ + if(!strcmp((char *)p_node->value,(char *)value)) + { + Node *f_node = init_node(); + init_value(f_node,"pointer",(void *)p_node); + insertInTail(f_list,f_node); + } + } + else if(!strcmp(type,"pointer")){ + if(p_node->value == value){ + Node *f_node = init_node(); + init_value(f_node,"pointer",(void *)p_node); + insertInTail(f_list,f_node); + } + } + + p_node = p_node->next; + + } + return f_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. return 1; // But we should ensure that both of them are NULL when we return 0; // want to make a list empty. } + +#endif diff --git a/list/list_easy.h b/list/list_easy.h new file mode 100644 index 0000000..5df9833 --- /dev/null +++ b/list/list_easy.h @@ -0,0 +1,14 @@ +#include "list.h" + +#ifndef LIST_EASY_H +#define LIST_EASY_H + +Node *new_nodeWithInt(int); +Node *new_nodeWithFloat(int); +Node *new_nodeWithString(int); +Node *new_nodeWithPointer(void *); +Node *find_nodeByInt(int); +Node *find_nodesByInt(int); +int list_through(List *p_list,void *p_func(void *));//Go through the list.Call p_func every time. + +#endif From d87e7e1f1b13629489839354f7a6f787494fab41 Mon Sep 17 00:00:00 2001 From: MapleSign <347495867@qq.com> Date: Mon, 12 Feb 2018 18:07:28 +0800 Subject: [PATCH 15/55] Replace 'srand' with 'srandom' in order to match 'random'. --- list/list.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/list/list.h b/list/list.h index 66b3f9f..7209033 100644 --- a/list/list.h +++ b/list/list.h @@ -108,7 +108,7 @@ int init_value(Node *p_node,const char *type,void * p_value){ } void rand_init(void){ - srand((unsigned)time(NULL)); + srandom((unsigned)time(NULL)); } unsigned long long getId(void){ From 04718f312d7058243b70938e8c439a1974ee1f43 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Sun, 18 Feb 2018 11:39:45 +0800 Subject: [PATCH 16/55] Define some functions in list_east.h --- list/list_easy.h | 66 ++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 61 insertions(+), 5 deletions(-) diff --git a/list/list_easy.h b/list/list_easy.h index 5df9833..fe3d50d 100644 --- a/list/list_easy.h +++ b/list/list_easy.h @@ -4,11 +4,67 @@ #define LIST_EASY_H Node *new_nodeWithInt(int); -Node *new_nodeWithFloat(int); -Node *new_nodeWithString(int); +Node *new_nodeWithDouble(double); +Node *new_nodeWithString(const char *); Node *new_nodeWithPointer(void *); -Node *find_nodeByInt(int); -Node *find_nodesByInt(int); -int list_through(List *p_list,void *p_func(void *));//Go through the list.Call p_func every time. +Node *find_nodeByIndex(List *, unsigned long long); +int list_through(List *p_list, int (*p_func)(void *, const char *));//Go through the list.Call p_func every time. + +Node *new_nodeWithInt(int m_int){ + int *p_int = (int *)malloc(sizeof(int)); + *p_int = m_int; + Node *p_node = init_node(); + init_value(p_node,"int",(void *)p_int); + return p_node; +} + +Node *new_nodeWithDouble(double m_double){ + double *p_double = (double *)malloc(sizeof(double)); + *p_double = m_double; + Node *p_node = init_node(); + init_value(p_node,"double",(void *)p_double); + return p_node; +} + +Node *new_nodeWithString(const char *m_string){ + char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string)+1)); + strcpy(p_string,m_string); + Node *p_node = init_node(); + init_value(p_node,"string",(void *)p_string); + return p_node; +} + +Node *new_nodeWithPointer(void *m_pointer){ + Node *p_node = init_node(); + init_value(p_node,"pointer",(void *)m_pointer); + return p_node; +} + +Node *find_nodeByIndex(List *p_list, unsigned long long m_index){ + Node *p_node = p_list->head; + for(unsigned long long i= 0; i < m_index; i++){ + p_node = p_node->next; + } + return p_node; +} + +int list_through(List *p_list, int (*p_func)(void *, const char *)){ + Node *p_node = p_list->head; + while(p_node != NULL){ + if(p_node->if_setvalue == 1){ + int m_return = (*p_func)(p_node->value, p_node->type); + if (m_return == -1) break; + else if (m_return == 1){ + p_node = p_node->last; + continue; + } + else{ + + } + } + p_node = p_node->next; + } + return 0; +} #endif From ef34fa2d84199e82db8fa182956d08edf28cf0b7 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Sun, 18 Feb 2018 14:32:58 +0800 Subject: [PATCH 17/55] Modefied and added Modefied list_easy.h and add error.h and error.c. --- error/error.c | 6 ++++++ error/error.h | 42 ++++++++++++++++++++++++++++++++++++++++++ list/list_easy.h | 2 ++ 3 files changed, 50 insertions(+) create mode 100644 error/error.c create mode 100644 error/error.h diff --git a/error/error.c b/error/error.c new file mode 100644 index 0000000..424eb23 --- /dev/null +++ b/error/error.c @@ -0,0 +1,6 @@ +#include "error.h" + +int main(int argc, char **argv){ + + return 0; +} diff --git a/error/error.h b/error/error.h new file mode 100644 index 0000000..7267fb3 --- /dev/null +++ b/error/error.h @@ -0,0 +1,42 @@ +#include "../list/list_easy.h" +#include + +#ifndef ERROR_H +#define ERROR_H + +#define HIGH 0x3 +#define STANDARD 0x2 +#define LOW 0x1 + +typedef struct Info{ + char *head; + char *body; + char *tail; +}Info; + +typedef struct Error{ + unsigned int type; + int pri; + Info info; + time_t time; +}Error; + +typedef struct Notice{ + unsigned int type; + Info info; + time_t time; +}Notice; + +typedef struct Log{ + FILE *fp; + int if_enable; + unsigned long int id; + unsigned int type; +}Log; + +List *error_list; +List *log_list; + + + +#endif diff --git a/list/list_easy.h b/list/list_easy.h index fe3d50d..e35c68e 100644 --- a/list/list_easy.h +++ b/list/list_easy.h @@ -67,4 +67,6 @@ int list_through(List *p_list, int (*p_func)(void *, const char *)){ } return 0; } + + #endif From 7fca55bf3e569b870a34d4a1e28f4fd5c535000a Mon Sep 17 00:00:00 2001 From: Saturneric Date: Sun, 18 Feb 2018 19:22:12 +0800 Subject: [PATCH 18/55] Defined and added. --- error/error.h | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/error/error.h b/error/error.h index 7267fb3..e9499a1 100644 --- a/error/error.h +++ b/error/error.h @@ -23,7 +23,7 @@ typedef struct Error{ typedef struct Notice{ unsigned int type; - Info info; + Info *info; time_t time; }Notice; @@ -34,9 +34,26 @@ typedef struct Log{ unsigned int type; }Log; -List *error_list; -List *log_list; +List *error_list = NULL; +List *log_list = NULL; +int if_error = 0; +int error_init(int if_enable); +int set_logDirectory(char *); +int push_error(unsigned int type, int pri, Info *p_info); +int push_notice(unsigned int type, Info *p_info); +int save_error(Error *p_error); +int save_notice(Notice *p_notice); +Info *init_Info(char *m_info); +int error_init(int if_enable){ + if(if_enable == 1){ + error_list = init_list(); + log_list = init_list(); + if_error = 1; + return 1; + } + return 0; +} #endif From 66b3ab551f289b166afc8c4890c7f2ef42ca346d Mon Sep 17 00:00:00 2001 From: Saturneic Date: Sat, 9 Jun 2018 15:57:19 +0800 Subject: [PATCH 19/55] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E6=BC=8F=E6=B4=9E?= =?UTF-8?q?=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- {list => ZE-Standard-Libraries/list}/list.c | 3 +- {list => ZE-Standard-Libraries/list}/list.h | 112 +++++++++++++++--- .../list}/list_easy.h | 0 3 files changed, 94 insertions(+), 21 deletions(-) rename {list => ZE-Standard-Libraries/list}/list.c (90%) rename {list => ZE-Standard-Libraries/list}/list.h (72%) rename {list => ZE-Standard-Libraries/list}/list_easy.h (100%) diff --git a/list/list.c b/ZE-Standard-Libraries/list/list.c similarity index 90% rename from list/list.c rename to ZE-Standard-Libraries/list/list.c index 7a7a4c4..582fd0c 100644 --- a/list/list.c +++ b/ZE-Standard-Libraries/list/list.c @@ -25,8 +25,7 @@ int main(int argc, char **argv){ int *f_i = (int *)malloc(sizeof(int)); *f_i = 3; - char *f_s = "there"; - Node *f_node = findByValue(t_list,"int",(void *)f_i); + //releaseMalloc(); releaseAll(); return 0; diff --git a/list/list.h b/ZE-Standard-Libraries/list/list.h similarity index 72% rename from list/list.h rename to ZE-Standard-Libraries/list/list.h index 7209033..d4ed1f7 100644 --- a/list/list.h +++ b/ZE-Standard-Libraries/list/list.h @@ -7,23 +7,28 @@ #define LIST_H typedef struct Node{ - unsigned long long id; + unsigned long long id;//唯一标识符 void *value; - int if_setvalue; - const char *type; + int if_setvalue;//记录是否已经初始化值 + const char *type;//记录值的类型 struct Node *next; struct Node *last; }Node; typedef struct List{ + unsigned long long id;//唯一标识符 Node *head; Node *tail; - unsigned long long length; + unsigned long long length;//链表长度 }List; -int safeMode(int ifon);//Safe mode is used to make sure that all malloced will be freed. -int releaseAll(void); +int safeMode(int ifon);//安全模式确保显式声明过的内存都会被释放 +int releaseMalloc(void);//释放所有声明过的内存 +int releaseSingleList(List *p_list); +int releaseSingleNode(List *p_list); +int releaseAll(void);//安全模式最后调用的函数 + List *init_list(void); Node *init_node(void); int init_value(Node *,const char *,void *); @@ -44,23 +49,32 @@ unsigned long long len(List *p_list); Node *findById(List *p_list, const unsigned long long id); Node *findByValue(List *p_list, const char *type, const void *value); -List *mply_findByValue(List *p_list, const char *type, const void *value); +List *mply_findByValue(List *p_list, const char *type, const void *value);//寻找多个值匹配的节点 int releaseList(List *p_list); int releaseNode(Node *p_node); int isListEmpty(List *p_list); -/*Something about safe mode*/ +/*有关安全模式的变量*/ int if_safeMode = 0; -List *node_list = NULL; //Store nodes which haven't been freed. -List *list_list = NULL; //Store lists which haven't been freed. +List *node_list = NULL; //储存声明过的节点. +List *list_list = NULL; //储存声明过的链表. int safeMode(int ifon){ if(ifon == 1){ if (node_list == NULL && list_list == NULL){ node_list = (List *)malloc(sizeof(List)); list_list = (List *)malloc(sizeof(List)); + + list_list->head = NULL; + list_list->length = 0; + list_list->tail = NULL; + + node_list->head = NULL; + node_list->length = 0; + node_list->tail = NULL; + if_safeMode = 1; } else{ @@ -71,11 +85,53 @@ int safeMode(int ifon){ return ifon; } +int releaseSingleList(List *p_list){ + Node *p_node = p_list->head; + List *plv_node = NULL; + while(p_node != NULL){ + plv_node = (List *)p_node->value; + plv_node->id = 0; + plv_node->head = NULL; + plv_node->length = 0; + plv_node->tail = NULL; + free(plv_node); + p_node = p_node->next; + } + p_list->head = NULL; + p_list->length = 0; + p_list->tail = NULL; + p_list->id = 0; + free(p_list); + return 0; +} + +int releaseSingleNode(List *p_list){ + Node *p_node = p_list->head; + Node *pnv_node = NULL; + while(p_node != NULL){ + pnv_node = (Node *)p_node->value; + pnv_node->id = 0; + pnv_node->if_setvalue = 0; + pnv_node->last = NULL; + pnv_node->next = NULL; + pnv_node->type = NULL; + pnv_node->value = NULL; + free(pnv_node); + p_node = p_node->next; + } + p_list->id = 0; + p_list->head = NULL; + p_list->length = 0; + p_list->tail = NULL; + free(p_list); + return 0; +} + int releaseAll(void){ if(if_safeMode == 1){ if_safeMode = 0; releaseList(node_list); - releaseList(list_list); + releaseSingleList(list_list); } return 0; } @@ -84,23 +140,35 @@ Node *init_node(void){ Node *p_node = (Node *) malloc(sizeof(Node)); p_node->id = getId(); p_node->if_setvalue = 0; - if(if_safeMode) insertInTail(node_list,p_node); + p_node->next = NULL; + p_node->last = NULL; + if(if_safeMode) { + if_safeMode = 0; + Node *prec_node = init_node(); + if_safeMode = 1; + init_value(prec_node, "pointer", (void *)p_node); + insertInTail(node_list,prec_node); + } return p_node; } List *init_list(void){ List *p_list = (List *) malloc(sizeof(List)); + p_list->id = getId(); p_list->head = NULL; p_list->tail = NULL; + p_list->length = 0; if(if_safeMode){ + if_safeMode = 0; Node *p_node = init_node(); - init_value(p_node,"pointer",(void *)p_list); + if_safeMode = 1; + init_value(p_node,"pointer",(void *)p_list); insertInTail(list_list,p_node); } return p_list; } -int init_value(Node *p_node,const char *type,void * p_value){ +int init_value(Node *p_node,const char *type,void *p_value){ p_node->if_setvalue = 1; p_node->type = type; p_node->value = p_value; @@ -161,10 +229,16 @@ int releaseNode(Node *p_node){ } p_node->last = NULL; p_node->next = NULL; + p_node->type = NULL; + p_node->value = NULL; + p_node->id = 0; + p_node->if_setvalue = 0; free(p_node); return 0; } + + int releaseList(List *p_list){ Node *p_node, *pl_node; p_node = p_list->head; @@ -182,6 +256,7 @@ int releaseList(List *p_list){ p_list->head = NULL; p_list->tail = NULL; p_list->length = 0; + p_list->id = 0; free(p_list); return 0; } @@ -198,7 +273,7 @@ int removeById(List *p_list, unsigned long id){ if(tmp->id == id) { tmp->last->next = tmp->next; tmp->next->last = tmp->last; - //releaseNode(tmp); not necessary + //releaseNode(tmp); 在安全模式下不必要 p_list->length -= 1; return 1;//found } @@ -218,7 +293,7 @@ int removeByNode(List *p_list, Node *p_node){ if(tmp == p_node){ tmp->last->next = tmp->next; tmp->next->last = tmp->last; - //releaseNode(tmp); not necessary + //releaseNode(tmp); 在安全模式下不必要 p_list->length -= 1; return 1;//found } @@ -266,9 +341,7 @@ int popFromTail(List *p_list){ return 0; } -/*The method in this function won't be better than going through the list - * node by node.The worst situation happens when the matched node is in - * the middle of the list.*/ +/*该函数算法需要改进*/ Node *findById(List *p_list, const unsigned long long id){ Node *ph_node = p_list->head; Node *pt_node = p_list->tail; @@ -295,6 +368,7 @@ Node *findById(List *p_list, const unsigned long long id){ return NULL; } + Node *findByValue(List *p_list, const char *type, const void *value){ Node *p_node = p_list->head; while(p_node != NULL){ diff --git a/list/list_easy.h b/ZE-Standard-Libraries/list/list_easy.h similarity index 100% rename from list/list_easy.h rename to ZE-Standard-Libraries/list/list_easy.h From f17d9f8f1eed5c25da9fc617461612de0d1d063f Mon Sep 17 00:00:00 2001 From: Saturneic Date: Sat, 9 Jun 2018 16:09:21 +0800 Subject: [PATCH 20/55] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E4=BA=86=E7=9B=AE?= =?UTF-8?q?=E5=BD=95=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list.c | 32 ++++ list/list.h | 451 +++++++++++++++++++++++++++++++++++++++++++++++ list/list_easy.h | 72 ++++++++ 3 files changed, 555 insertions(+) create mode 100644 list/list.c create mode 100644 list/list.h create mode 100644 list/list_easy.h diff --git a/list/list.c b/list/list.c new file mode 100644 index 0000000..582fd0c --- /dev/null +++ b/list/list.c @@ -0,0 +1,32 @@ +/* ******************************************************** + * This file is used to test the header file(list.h). + * When the project is finished, this file will be deleted. + * This file create by saturneric at 20:04 on Feb 7th. + * *******************************************************/ + +#include "list.h" + +int main(int argc, char **argv){ + rand_init(); + safeMode(1); + List *t_list = init_list(); + + for(int i = 0; i < 9; i++){ + Node *t_node = init_node(); + int *t_i = (int *)malloc(sizeof(int)); + *t_i = i; + init_value(t_node,"int",(void *)t_i); + insertInTail(t_list,t_node); + } + + /*Node *t_node = init_node(); + insertInTail(t_list,t_node); + init_value(t_node,(void *)"there");*/ + + int *f_i = (int *)malloc(sizeof(int)); + *f_i = 3; + //releaseMalloc(); + releaseAll(); + + return 0; +} diff --git a/list/list.h b/list/list.h new file mode 100644 index 0000000..d4ed1f7 --- /dev/null +++ b/list/list.h @@ -0,0 +1,451 @@ +#include +#include +#include +#include + +#ifndef LIST_H +#define LIST_H + +typedef struct Node{ + unsigned long long id;//唯一标识符 + void *value; + int if_setvalue;//记录是否已经初始化值 + const char *type;//记录值的类型 + struct Node *next; + struct Node *last; +}Node; + + +typedef struct List{ + unsigned long long id;//唯一标识符 + Node *head; + Node *tail; + unsigned long long length;//链表长度 +}List; + +int safeMode(int ifon);//安全模式确保显式声明过的内存都会被释放 +int releaseMalloc(void);//释放所有声明过的内存 +int releaseSingleList(List *p_list); +int releaseSingleNode(List *p_list); +int releaseAll(void);//安全模式最后调用的函数 + +List *init_list(void); +Node *init_node(void); +int init_value(Node *,const char *,void *); +void init_rand(void); + +unsigned long long getId(void); + +int insertInHead(List *p_list, Node *p_node); +int insertInTail(List *p_list, Node *p_node); + +int removeById(List *p_list, unsigned long id); +int removeByNode(List *p_list, Node *p_node); + +int popFromHead(List *p_list); +int popFromTail(List *p_list); + +unsigned long long len(List *p_list); + +Node *findById(List *p_list, const unsigned long long id); +Node *findByValue(List *p_list, const char *type, const void *value); +List *mply_findByValue(List *p_list, const char *type, const void *value);//寻找多个值匹配的节点 + +int releaseList(List *p_list); +int releaseNode(Node *p_node); + +int isListEmpty(List *p_list); + +/*有关安全模式的变量*/ +int if_safeMode = 0; +List *node_list = NULL; //储存声明过的节点. +List *list_list = NULL; //储存声明过的链表. + +int safeMode(int ifon){ + if(ifon == 1){ + if (node_list == NULL && list_list == NULL){ + node_list = (List *)malloc(sizeof(List)); + list_list = (List *)malloc(sizeof(List)); + + list_list->head = NULL; + list_list->length = 0; + list_list->tail = NULL; + + node_list->head = NULL; + node_list->length = 0; + node_list->tail = NULL; + + if_safeMode = 1; + } + else{ + return -1; + } + } + + return ifon; +} + +int releaseSingleList(List *p_list){ + Node *p_node = p_list->head; + List *plv_node = NULL; + while(p_node != NULL){ + plv_node = (List *)p_node->value; + plv_node->id = 0; + plv_node->head = NULL; + plv_node->length = 0; + plv_node->tail = NULL; + free(plv_node); + p_node = p_node->next; + } + p_list->head = NULL; + p_list->length = 0; + p_list->tail = NULL; + p_list->id = 0; + free(p_list); + return 0; +} + +int releaseSingleNode(List *p_list){ + Node *p_node = p_list->head; + Node *pnv_node = NULL; + while(p_node != NULL){ + pnv_node = (Node *)p_node->value; + pnv_node->id = 0; + pnv_node->if_setvalue = 0; + pnv_node->last = NULL; + pnv_node->next = NULL; + pnv_node->type = NULL; + pnv_node->value = NULL; + free(pnv_node); + p_node = p_node->next; + } + p_list->id = 0; + p_list->head = NULL; + p_list->length = 0; + p_list->tail = NULL; + free(p_list); + return 0; +} + +int releaseAll(void){ + if(if_safeMode == 1){ + if_safeMode = 0; + releaseList(node_list); + releaseSingleList(list_list); + } + return 0; +} + +Node *init_node(void){ + Node *p_node = (Node *) malloc(sizeof(Node)); + p_node->id = getId(); + p_node->if_setvalue = 0; + p_node->next = NULL; + p_node->last = NULL; + if(if_safeMode) { + if_safeMode = 0; + Node *prec_node = init_node(); + if_safeMode = 1; + init_value(prec_node, "pointer", (void *)p_node); + insertInTail(node_list,prec_node); + } + return p_node; +} + +List *init_list(void){ + List *p_list = (List *) malloc(sizeof(List)); + p_list->id = getId(); + p_list->head = NULL; + p_list->tail = NULL; + p_list->length = 0; + if(if_safeMode){ + if_safeMode = 0; + Node *p_node = init_node(); + if_safeMode = 1; + init_value(p_node,"pointer",(void *)p_list); + insertInTail(list_list,p_node); + } + return p_list; +} + +int init_value(Node *p_node,const char *type,void *p_value){ + p_node->if_setvalue = 1; + p_node->type = type; + p_node->value = p_value; + return 0; +} + +void rand_init(void){ + srandom((unsigned)time(NULL)); +} + +unsigned long long getId(void){ + unsigned long long id = 0; + id = ((random()%9)+1); + for(int i = 0; i < 15; i++){ + id *= 10; + id += random()%10; + } + return id; +} + +int insertInHead(List *p_list, Node *p_node){ + if( isListEmpty(p_list) ){ + p_list->head = p_node; + p_list->tail = p_node; + } + else{ + p_list->head->last = p_node; + p_node->last = NULL; + p_node->next = p_list->head; + p_list->head = p_node; + } + p_list->length += 1; + return 0; +} + +int insertInTail(List *p_list, Node *p_node){ + if( isListEmpty(p_list) ){ + p_list->head = p_node; + p_list->tail = p_node; + } + else{ + p_list->tail->next = p_node; + p_node->next = NULL; + p_node->last = p_list->tail; + p_list->tail = p_node; + } + p_list->length += 1; + return 0; +} + +int releaseNode(Node *p_node){ + if(if_safeMode == 1){ + removeByNode(node_list,p_node); + } + if(p_node->if_setvalue == 1){ + free(p_node->value); + p_node->value = NULL; + } + p_node->last = NULL; + p_node->next = NULL; + p_node->type = NULL; + p_node->value = NULL; + p_node->id = 0; + p_node->if_setvalue = 0; + free(p_node); + return 0; +} + + + +int releaseList(List *p_list){ + Node *p_node, *pl_node; + p_node = p_list->head; + if(if_safeMode == 1){ + Node *tar_list = findByValue(list_list,"pointer",(void *)p_list);//turn pointer in to int to compare. + removeByNode(list_list,tar_list); + } + while (p_node != NULL){ + pl_node = p_node; + p_node = p_node->next; + pl_node->next = NULL; + pl_node->last = NULL; + releaseNode(pl_node); + } + p_list->head = NULL; + p_list->tail = NULL; + p_list->length = 0; + p_list->id = 0; + free(p_list); + return 0; +} + +unsigned long long len(List *p_list){ + return p_list->length; +} + +int removeById(List *p_list, unsigned long id){ + Node *tmp = p_list->head; + if( isListEmpty(p_list) ) + return -1; + do{ + if(tmp->id == id) { + tmp->last->next = tmp->next; + tmp->next->last = tmp->last; + //releaseNode(tmp); 在安全模式下不必要 + p_list->length -= 1; + return 1;//found + } + else{ + tmp = tmp->next; + } + }while(tmp != NULL); + + return 0;//not find +} + +int removeByNode(List *p_list, Node *p_node){ + Node *tmp = p_list->head; + if( isListEmpty(p_list) ) + return -1; + do{ + if(tmp == p_node){ + tmp->last->next = tmp->next; + tmp->next->last = tmp->last; + //releaseNode(tmp); 在安全模式下不必要 + p_list->length -= 1; + return 1;//found + } + else{ + tmp = tmp->next; + } + }while(tmp != NULL); + + return 0;//not find +} + +int popFromHead(List *p_list){ + if( isListEmpty(p_list) ) + return -1; + else{ + //Node *tmp = p_list->head; + p_list->head->next->last = NULL; + p_list->head = p_list->head->next; + //releaseNode(tmp); not necessary + p_list->length -= 1; + } + + if( isListEmpty(p_list) ){ + p_list->head = NULL; + p_list->tail = NULL; + } + return 0; +} + +int popFromTail(List *p_list){ + if( isListEmpty(p_list) ) + return -1; + else{ + //Node *tmp = p_list->tail; + p_list->tail->last->next = NULL; + p_list->tail = p_list->tail->last; + //releaseNode(tmp); not necessary + p_list->length -= 1; + } + + if( isListEmpty(p_list) ){ + p_list->head = NULL; + p_list->tail = NULL; + } + return 0; +} + +/*该函数算法需要改进*/ +Node *findById(List *p_list, const unsigned long long id){ + Node *ph_node = p_list->head; + Node *pt_node = p_list->tail; + int direction = 0; + while(ph_node != pt_node){ + if (direction == 0){ + if (ph_node->id == id){ + return ph_node; + } + else{ + ph_node = ph_node->next; + } + direction = 1; + } + else{ + if (pt_node->id == id){ + return pt_node; + } + else{ + pt_node = pt_node->last; + } + } + } + return NULL; +} + + +Node *findByValue(List *p_list, const char *type, const void *value){ + Node *p_node = p_list->head; + while(p_node != NULL){ + if(strcmp(p_node->type,type)) continue;//continue when type is not the same. + if(!strcmp(type,"int")){ + if(*((int *)p_node->value) == *((int *)value)){ + return p_node; + } + } + else if(!strcmp(type,"double")){ + if(*((double *)p_node->value) == *((double *)value)){ + return p_node; + } + } + else if(!strcmp (type,"string")){ + if(!strcmp((char *)p_node->value,(char *)value)) + { + return p_node; + } + } + else if(!strcmp(type,"pointer")){ + if(p_node->value == value){ + return p_node; + } + } + + p_node = p_node->next; + + } + return NULL; +} + +List *mply_findByValue(List *p_list, const char *type, const void *value){ + List *f_list = init_list(); + Node *p_node = p_list->head; + while(p_node != NULL){ + if(strcmp(p_node->type,type)) continue; + if(!strcmp(type,"int")){ + if(*((int *)p_node->value) == *((int *)value)){ + Node *f_node = init_node(); + init_value(f_node,"pointer",(void *)p_node); + insertInTail(f_list,f_node); + } + } + else if(!strcmp(type,"double")){ + if(*((double *)p_node->value) == *((double *)value)){ + Node *f_node = init_node(); + init_value(f_node,"pointer",(void *)p_node); + insertInTail(f_list,f_node); + } + } + else if(!strcmp (type,"string")){ + if(!strcmp((char *)p_node->value,(char *)value)) + { + Node *f_node = init_node(); + init_value(f_node,"pointer",(void *)p_node); + insertInTail(f_list,f_node); + } + } + else if(!strcmp(type,"pointer")){ + if(p_node->value == value){ + Node *f_node = init_node(); + init_value(f_node,"pointer",(void *)p_node); + insertInTail(f_list,f_node); + } + } + + p_node = p_node->next; + + } + return f_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. + return 1; // But we should ensure that both of them are NULL when we + return 0; // want to make a list empty. +} + +#endif diff --git a/list/list_easy.h b/list/list_easy.h new file mode 100644 index 0000000..e35c68e --- /dev/null +++ b/list/list_easy.h @@ -0,0 +1,72 @@ +#include "list.h" + +#ifndef LIST_EASY_H +#define LIST_EASY_H + +Node *new_nodeWithInt(int); +Node *new_nodeWithDouble(double); +Node *new_nodeWithString(const char *); +Node *new_nodeWithPointer(void *); +Node *find_nodeByIndex(List *, unsigned long long); +int list_through(List *p_list, int (*p_func)(void *, const char *));//Go through the list.Call p_func every time. + + +Node *new_nodeWithInt(int m_int){ + int *p_int = (int *)malloc(sizeof(int)); + *p_int = m_int; + Node *p_node = init_node(); + init_value(p_node,"int",(void *)p_int); + return p_node; +} + +Node *new_nodeWithDouble(double m_double){ + double *p_double = (double *)malloc(sizeof(double)); + *p_double = m_double; + Node *p_node = init_node(); + init_value(p_node,"double",(void *)p_double); + return p_node; +} + +Node *new_nodeWithString(const char *m_string){ + char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string)+1)); + strcpy(p_string,m_string); + Node *p_node = init_node(); + init_value(p_node,"string",(void *)p_string); + return p_node; +} + +Node *new_nodeWithPointer(void *m_pointer){ + Node *p_node = init_node(); + init_value(p_node,"pointer",(void *)m_pointer); + return p_node; +} + +Node *find_nodeByIndex(List *p_list, unsigned long long m_index){ + Node *p_node = p_list->head; + for(unsigned long long i= 0; i < m_index; i++){ + p_node = p_node->next; + } + return p_node; +} + +int list_through(List *p_list, int (*p_func)(void *, const char *)){ + Node *p_node = p_list->head; + while(p_node != NULL){ + if(p_node->if_setvalue == 1){ + int m_return = (*p_func)(p_node->value, p_node->type); + if (m_return == -1) break; + else if (m_return == 1){ + p_node = p_node->last; + continue; + } + else{ + + } + } + p_node = p_node->next; + } + return 0; +} + + +#endif From efc7bfe9b22d09b6fa87c80923e17034afe3098f Mon Sep 17 00:00:00 2001 From: Saturneic Date: Sat, 9 Jun 2018 16:25:07 +0800 Subject: [PATCH 21/55] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E4=BA=86=E7=9B=AE?= =?UTF-8?q?=E5=BD=95=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ZE-Standard-Libraries/list/list.c | 32 -- ZE-Standard-Libraries/list/list.h | 451 ------------------------- ZE-Standard-Libraries/list/list_easy.h | 72 ---- 3 files changed, 555 deletions(-) delete mode 100644 ZE-Standard-Libraries/list/list.c delete mode 100644 ZE-Standard-Libraries/list/list.h delete mode 100644 ZE-Standard-Libraries/list/list_easy.h diff --git a/ZE-Standard-Libraries/list/list.c b/ZE-Standard-Libraries/list/list.c deleted file mode 100644 index 582fd0c..0000000 --- a/ZE-Standard-Libraries/list/list.c +++ /dev/null @@ -1,32 +0,0 @@ -/* ******************************************************** - * This file is used to test the header file(list.h). - * When the project is finished, this file will be deleted. - * This file create by saturneric at 20:04 on Feb 7th. - * *******************************************************/ - -#include "list.h" - -int main(int argc, char **argv){ - rand_init(); - safeMode(1); - List *t_list = init_list(); - - for(int i = 0; i < 9; i++){ - Node *t_node = init_node(); - int *t_i = (int *)malloc(sizeof(int)); - *t_i = i; - init_value(t_node,"int",(void *)t_i); - insertInTail(t_list,t_node); - } - - /*Node *t_node = init_node(); - insertInTail(t_list,t_node); - init_value(t_node,(void *)"there");*/ - - int *f_i = (int *)malloc(sizeof(int)); - *f_i = 3; - //releaseMalloc(); - releaseAll(); - - return 0; -} diff --git a/ZE-Standard-Libraries/list/list.h b/ZE-Standard-Libraries/list/list.h deleted file mode 100644 index d4ed1f7..0000000 --- a/ZE-Standard-Libraries/list/list.h +++ /dev/null @@ -1,451 +0,0 @@ -#include -#include -#include -#include - -#ifndef LIST_H -#define LIST_H - -typedef struct Node{ - unsigned long long id;//唯一标识符 - void *value; - int if_setvalue;//记录是否已经初始化值 - const char *type;//记录值的类型 - struct Node *next; - struct Node *last; -}Node; - - -typedef struct List{ - unsigned long long id;//唯一标识符 - Node *head; - Node *tail; - unsigned long long length;//链表长度 -}List; - -int safeMode(int ifon);//安全模式确保显式声明过的内存都会被释放 -int releaseMalloc(void);//释放所有声明过的内存 -int releaseSingleList(List *p_list); -int releaseSingleNode(List *p_list); -int releaseAll(void);//安全模式最后调用的函数 - -List *init_list(void); -Node *init_node(void); -int init_value(Node *,const char *,void *); -void init_rand(void); - -unsigned long long getId(void); - -int insertInHead(List *p_list, Node *p_node); -int insertInTail(List *p_list, Node *p_node); - -int removeById(List *p_list, unsigned long id); -int removeByNode(List *p_list, Node *p_node); - -int popFromHead(List *p_list); -int popFromTail(List *p_list); - -unsigned long long len(List *p_list); - -Node *findById(List *p_list, const unsigned long long id); -Node *findByValue(List *p_list, const char *type, const void *value); -List *mply_findByValue(List *p_list, const char *type, const void *value);//寻找多个值匹配的节点 - -int releaseList(List *p_list); -int releaseNode(Node *p_node); - -int isListEmpty(List *p_list); - -/*有关安全模式的变量*/ -int if_safeMode = 0; -List *node_list = NULL; //储存声明过的节点. -List *list_list = NULL; //储存声明过的链表. - -int safeMode(int ifon){ - if(ifon == 1){ - if (node_list == NULL && list_list == NULL){ - node_list = (List *)malloc(sizeof(List)); - list_list = (List *)malloc(sizeof(List)); - - list_list->head = NULL; - list_list->length = 0; - list_list->tail = NULL; - - node_list->head = NULL; - node_list->length = 0; - node_list->tail = NULL; - - if_safeMode = 1; - } - else{ - return -1; - } - } - - return ifon; -} - -int releaseSingleList(List *p_list){ - Node *p_node = p_list->head; - List *plv_node = NULL; - while(p_node != NULL){ - plv_node = (List *)p_node->value; - plv_node->id = 0; - plv_node->head = NULL; - plv_node->length = 0; - plv_node->tail = NULL; - free(plv_node); - p_node = p_node->next; - } - p_list->head = NULL; - p_list->length = 0; - p_list->tail = NULL; - p_list->id = 0; - free(p_list); - return 0; -} - -int releaseSingleNode(List *p_list){ - Node *p_node = p_list->head; - Node *pnv_node = NULL; - while(p_node != NULL){ - pnv_node = (Node *)p_node->value; - pnv_node->id = 0; - pnv_node->if_setvalue = 0; - pnv_node->last = NULL; - pnv_node->next = NULL; - pnv_node->type = NULL; - pnv_node->value = NULL; - free(pnv_node); - p_node = p_node->next; - } - p_list->id = 0; - p_list->head = NULL; - p_list->length = 0; - p_list->tail = NULL; - free(p_list); - return 0; -} - -int releaseAll(void){ - if(if_safeMode == 1){ - if_safeMode = 0; - releaseList(node_list); - releaseSingleList(list_list); - } - return 0; -} - -Node *init_node(void){ - Node *p_node = (Node *) malloc(sizeof(Node)); - p_node->id = getId(); - p_node->if_setvalue = 0; - p_node->next = NULL; - p_node->last = NULL; - if(if_safeMode) { - if_safeMode = 0; - Node *prec_node = init_node(); - if_safeMode = 1; - init_value(prec_node, "pointer", (void *)p_node); - insertInTail(node_list,prec_node); - } - return p_node; -} - -List *init_list(void){ - List *p_list = (List *) malloc(sizeof(List)); - p_list->id = getId(); - p_list->head = NULL; - p_list->tail = NULL; - p_list->length = 0; - if(if_safeMode){ - if_safeMode = 0; - Node *p_node = init_node(); - if_safeMode = 1; - init_value(p_node,"pointer",(void *)p_list); - insertInTail(list_list,p_node); - } - return p_list; -} - -int init_value(Node *p_node,const char *type,void *p_value){ - p_node->if_setvalue = 1; - p_node->type = type; - p_node->value = p_value; - return 0; -} - -void rand_init(void){ - srandom((unsigned)time(NULL)); -} - -unsigned long long getId(void){ - unsigned long long id = 0; - id = ((random()%9)+1); - for(int i = 0; i < 15; i++){ - id *= 10; - id += random()%10; - } - return id; -} - -int insertInHead(List *p_list, Node *p_node){ - if( isListEmpty(p_list) ){ - p_list->head = p_node; - p_list->tail = p_node; - } - else{ - p_list->head->last = p_node; - p_node->last = NULL; - p_node->next = p_list->head; - p_list->head = p_node; - } - p_list->length += 1; - return 0; -} - -int insertInTail(List *p_list, Node *p_node){ - if( isListEmpty(p_list) ){ - p_list->head = p_node; - p_list->tail = p_node; - } - else{ - p_list->tail->next = p_node; - p_node->next = NULL; - p_node->last = p_list->tail; - p_list->tail = p_node; - } - p_list->length += 1; - return 0; -} - -int releaseNode(Node *p_node){ - if(if_safeMode == 1){ - removeByNode(node_list,p_node); - } - if(p_node->if_setvalue == 1){ - free(p_node->value); - p_node->value = NULL; - } - p_node->last = NULL; - p_node->next = NULL; - p_node->type = NULL; - p_node->value = NULL; - p_node->id = 0; - p_node->if_setvalue = 0; - free(p_node); - return 0; -} - - - -int releaseList(List *p_list){ - Node *p_node, *pl_node; - p_node = p_list->head; - if(if_safeMode == 1){ - Node *tar_list = findByValue(list_list,"pointer",(void *)p_list);//turn pointer in to int to compare. - removeByNode(list_list,tar_list); - } - while (p_node != NULL){ - pl_node = p_node; - p_node = p_node->next; - pl_node->next = NULL; - pl_node->last = NULL; - releaseNode(pl_node); - } - p_list->head = NULL; - p_list->tail = NULL; - p_list->length = 0; - p_list->id = 0; - free(p_list); - return 0; -} - -unsigned long long len(List *p_list){ - return p_list->length; -} - -int removeById(List *p_list, unsigned long id){ - Node *tmp = p_list->head; - if( isListEmpty(p_list) ) - return -1; - do{ - if(tmp->id == id) { - tmp->last->next = tmp->next; - tmp->next->last = tmp->last; - //releaseNode(tmp); 在安全模式下不必要 - p_list->length -= 1; - return 1;//found - } - else{ - tmp = tmp->next; - } - }while(tmp != NULL); - - return 0;//not find -} - -int removeByNode(List *p_list, Node *p_node){ - Node *tmp = p_list->head; - if( isListEmpty(p_list) ) - return -1; - do{ - if(tmp == p_node){ - tmp->last->next = tmp->next; - tmp->next->last = tmp->last; - //releaseNode(tmp); 在安全模式下不必要 - p_list->length -= 1; - return 1;//found - } - else{ - tmp = tmp->next; - } - }while(tmp != NULL); - - return 0;//not find -} - -int popFromHead(List *p_list){ - if( isListEmpty(p_list) ) - return -1; - else{ - //Node *tmp = p_list->head; - p_list->head->next->last = NULL; - p_list->head = p_list->head->next; - //releaseNode(tmp); not necessary - p_list->length -= 1; - } - - if( isListEmpty(p_list) ){ - p_list->head = NULL; - p_list->tail = NULL; - } - return 0; -} - -int popFromTail(List *p_list){ - if( isListEmpty(p_list) ) - return -1; - else{ - //Node *tmp = p_list->tail; - p_list->tail->last->next = NULL; - p_list->tail = p_list->tail->last; - //releaseNode(tmp); not necessary - p_list->length -= 1; - } - - if( isListEmpty(p_list) ){ - p_list->head = NULL; - p_list->tail = NULL; - } - return 0; -} - -/*该函数算法需要改进*/ -Node *findById(List *p_list, const unsigned long long id){ - Node *ph_node = p_list->head; - Node *pt_node = p_list->tail; - int direction = 0; - while(ph_node != pt_node){ - if (direction == 0){ - if (ph_node->id == id){ - return ph_node; - } - else{ - ph_node = ph_node->next; - } - direction = 1; - } - else{ - if (pt_node->id == id){ - return pt_node; - } - else{ - pt_node = pt_node->last; - } - } - } - return NULL; -} - - -Node *findByValue(List *p_list, const char *type, const void *value){ - Node *p_node = p_list->head; - while(p_node != NULL){ - if(strcmp(p_node->type,type)) continue;//continue when type is not the same. - if(!strcmp(type,"int")){ - if(*((int *)p_node->value) == *((int *)value)){ - return p_node; - } - } - else if(!strcmp(type,"double")){ - if(*((double *)p_node->value) == *((double *)value)){ - return p_node; - } - } - else if(!strcmp (type,"string")){ - if(!strcmp((char *)p_node->value,(char *)value)) - { - return p_node; - } - } - else if(!strcmp(type,"pointer")){ - if(p_node->value == value){ - return p_node; - } - } - - p_node = p_node->next; - - } - return NULL; -} - -List *mply_findByValue(List *p_list, const char *type, const void *value){ - List *f_list = init_list(); - Node *p_node = p_list->head; - while(p_node != NULL){ - if(strcmp(p_node->type,type)) continue; - if(!strcmp(type,"int")){ - if(*((int *)p_node->value) == *((int *)value)){ - Node *f_node = init_node(); - init_value(f_node,"pointer",(void *)p_node); - insertInTail(f_list,f_node); - } - } - else if(!strcmp(type,"double")){ - if(*((double *)p_node->value) == *((double *)value)){ - Node *f_node = init_node(); - init_value(f_node,"pointer",(void *)p_node); - insertInTail(f_list,f_node); - } - } - else if(!strcmp (type,"string")){ - if(!strcmp((char *)p_node->value,(char *)value)) - { - Node *f_node = init_node(); - init_value(f_node,"pointer",(void *)p_node); - insertInTail(f_list,f_node); - } - } - else if(!strcmp(type,"pointer")){ - if(p_node->value == value){ - Node *f_node = init_node(); - init_value(f_node,"pointer",(void *)p_node); - insertInTail(f_list,f_node); - } - } - - p_node = p_node->next; - - } - return f_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. - return 1; // But we should ensure that both of them are NULL when we - return 0; // want to make a list empty. -} - -#endif diff --git a/ZE-Standard-Libraries/list/list_easy.h b/ZE-Standard-Libraries/list/list_easy.h deleted file mode 100644 index e35c68e..0000000 --- a/ZE-Standard-Libraries/list/list_easy.h +++ /dev/null @@ -1,72 +0,0 @@ -#include "list.h" - -#ifndef LIST_EASY_H -#define LIST_EASY_H - -Node *new_nodeWithInt(int); -Node *new_nodeWithDouble(double); -Node *new_nodeWithString(const char *); -Node *new_nodeWithPointer(void *); -Node *find_nodeByIndex(List *, unsigned long long); -int list_through(List *p_list, int (*p_func)(void *, const char *));//Go through the list.Call p_func every time. - - -Node *new_nodeWithInt(int m_int){ - int *p_int = (int *)malloc(sizeof(int)); - *p_int = m_int; - Node *p_node = init_node(); - init_value(p_node,"int",(void *)p_int); - return p_node; -} - -Node *new_nodeWithDouble(double m_double){ - double *p_double = (double *)malloc(sizeof(double)); - *p_double = m_double; - Node *p_node = init_node(); - init_value(p_node,"double",(void *)p_double); - return p_node; -} - -Node *new_nodeWithString(const char *m_string){ - char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string)+1)); - strcpy(p_string,m_string); - Node *p_node = init_node(); - init_value(p_node,"string",(void *)p_string); - return p_node; -} - -Node *new_nodeWithPointer(void *m_pointer){ - Node *p_node = init_node(); - init_value(p_node,"pointer",(void *)m_pointer); - return p_node; -} - -Node *find_nodeByIndex(List *p_list, unsigned long long m_index){ - Node *p_node = p_list->head; - for(unsigned long long i= 0; i < m_index; i++){ - p_node = p_node->next; - } - return p_node; -} - -int list_through(List *p_list, int (*p_func)(void *, const char *)){ - Node *p_node = p_list->head; - while(p_node != NULL){ - if(p_node->if_setvalue == 1){ - int m_return = (*p_func)(p_node->value, p_node->type); - if (m_return == -1) break; - else if (m_return == 1){ - p_node = p_node->last; - continue; - } - else{ - - } - } - p_node = p_node->next; - } - return 0; -} - - -#endif From 684a842b7e2c5dfc91d952f4e73b6dbe5594041f Mon Sep 17 00:00:00 2001 From: Saturneic Date: Sun, 10 Jun 2018 17:21:11 +0800 Subject: [PATCH 22/55] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=BA=86=E4=B8=80?= =?UTF-8?q?=E4=BA=9B=E7=AE=80=E4=BE=BF=E3=80=82=E5=B9=B6=E4=B8=94=E6=B7=BB?= =?UTF-8?q?=E5=8A=A0=E4=BA=86=E7=AC=A6=E5=90=88=E5=80=BC=E8=8A=82=E7=82=B9?= =?UTF-8?q?=E7=9A=84=E5=AE=9A=E4=B9=89=E5=8F=8A=E4=B8=80=E4=BA=9B=E5=8A=9F?= =?UTF-8?q?=E8=83=BD=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list.c | 32 +++-- list/list.h | 89 ++++++++------ list/list_easy.h | 72 ----------- list/list_expand.h | 298 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 374 insertions(+), 117 deletions(-) delete mode 100644 list/list_easy.h create mode 100644 list/list_expand.h diff --git a/list/list.c b/list/list.c index 582fd0c..9bcf50f 100644 --- a/list/list.c +++ b/list/list.c @@ -5,28 +5,40 @@ * *******************************************************/ #include "list.h" +#include "list_expand.h" int main(int argc, char **argv){ rand_init(); - safeMode(1); List *t_list = init_list(); - for(int i = 0; i < 9; i++){ + /*for(int i = 0; i < 9; i++){ Node *t_node = init_node(); int *t_i = (int *)malloc(sizeof(int)); *t_i = i; - init_value(t_node,"int",(void *)t_i); + initMallocValue(t_node,"int",(void *)t_i); insertInTail(t_list,t_node); - } + }*/ /*Node *t_node = init_node(); insertInTail(t_list,t_node); - init_value(t_node,(void *)"there");*/ - - int *f_i = (int *)malloc(sizeof(int)); - *f_i = 3; - //releaseMalloc(); - releaseAll(); + initMalllocValue(t_node,(void *)"there");*/ + + for(int i = 0; i < 12; i++){ + insertInHead(t_list, nodeWithInt(i)); + } + + + Node *t_node = nodeWithComplex(); + addIntForComplex(t_node, 32); + addIntForComplex(t_node, 64); + insertInTail(t_list, t_node); + insertInTail(t_list, nodeWithDouble(32.5)); + insertInTail(t_list, nodeWithString("There")); + printNodeInfo(findByString(t_list, "There"), 0); + printListInfo(t_list,0); + printList(t_list); + printf("\n"); + releaseList(t_list); return 0; } diff --git a/list/list.h b/list/list.h index d4ed1f7..9c74c6d 100644 --- a/list/list.h +++ b/list/list.h @@ -9,7 +9,7 @@ typedef struct Node{ unsigned long long id;//唯一标识符 void *value; - int if_setvalue;//记录是否已经初始化值 + int if_malloc;//记录是否已经初始化值 const char *type;//记录值的类型 struct Node *next; struct Node *last; @@ -24,37 +24,40 @@ typedef struct List{ }List; int safeMode(int ifon);//安全模式确保显式声明过的内存都会被释放 -int releaseMalloc(void);//释放所有声明过的内存 -int releaseSingleList(List *p_list); -int releaseSingleNode(List *p_list); +int releaseSingleListForSafeMode(List *p_list);//释放list_list +int releaseSingleNodeForSafeMode(List *p_list);//释放node_list int releaseAll(void);//安全模式最后调用的函数 List *init_list(void); Node *init_node(void); -int init_value(Node *,const char *,void *); -void init_rand(void); +int initMallocValue(Node *,const char *,void *);//赋予已分配内存的值，并标明类型 + +/*有关id的函数*/ +void init_rand(void); unsigned long long getId(void); +/*插入函数*/ int insertInHead(List *p_list, Node *p_node); int insertInTail(List *p_list, Node *p_node); +/*移除函数*/ int removeById(List *p_list, unsigned long id); int removeByNode(List *p_list, Node *p_node); - int popFromHead(List *p_list); int popFromTail(List *p_list); -unsigned long long len(List *p_list); +unsigned long long len(List *p_list);//查看链表的长度 -Node *findById(List *p_list, const unsigned long long id); -Node *findByValue(List *p_list, const char *type, const void *value); +Node *findById(List *p_list, const unsigned long long id);//通过id查找目标链表中的匹配节点 +Node *findByValue(List *p_list, const char *type, const void *value);//通过值来查找目标链表中的匹配节点 List *mply_findByValue(List *p_list, const char *type, const void *value);//寻找多个值匹配的节点 -int releaseList(List *p_list); -int releaseNode(Node *p_node); +int releaseList(List *p_list);//释放List并可选择是否释放中所有的其中的Node +int releaseListForSingle(List *p_list);//单独释放List +int releaseNode(Node *p_node);//释放Node -int isListEmpty(List *p_list); +int isListEmpty(List *p_list);//判断List是否为空 /*有关安全模式的变量*/ int if_safeMode = 0; @@ -85,7 +88,7 @@ int safeMode(int ifon){ return ifon; } -int releaseSingleList(List *p_list){ +int releaseSingleListForSafeMode(List *p_list){ Node *p_node = p_list->head; List *plv_node = NULL; while(p_node != NULL){ @@ -105,13 +108,13 @@ int releaseSingleList(List *p_list){ return 0; } -int releaseSingleNode(List *p_list){ +int releaseSingleNodeForSafeMode(List *p_list){ Node *p_node = p_list->head; Node *pnv_node = NULL; while(p_node != NULL){ pnv_node = (Node *)p_node->value; pnv_node->id = 0; - pnv_node->if_setvalue = 0; + pnv_node->if_malloc = 0; pnv_node->last = NULL; pnv_node->next = NULL; pnv_node->type = NULL; @@ -130,8 +133,8 @@ int releaseSingleNode(List *p_list){ int releaseAll(void){ if(if_safeMode == 1){ if_safeMode = 0; - releaseList(node_list); - releaseSingleList(list_list); + releaseSingleNodeForSafeMode(node_list); + releaseSingleListForSafeMode(list_list); } return 0; } @@ -139,14 +142,14 @@ int releaseAll(void){ Node *init_node(void){ Node *p_node = (Node *) malloc(sizeof(Node)); p_node->id = getId(); - p_node->if_setvalue = 0; + p_node->if_malloc = 0; p_node->next = NULL; p_node->last = NULL; if(if_safeMode) { if_safeMode = 0; Node *prec_node = init_node(); if_safeMode = 1; - init_value(prec_node, "pointer", (void *)p_node); + initMallocValue(prec_node, "pointer", (void *)p_node); insertInTail(node_list,prec_node); } return p_node; @@ -162,14 +165,14 @@ List *init_list(void){ if_safeMode = 0; Node *p_node = init_node(); if_safeMode = 1; - init_value(p_node,"pointer",(void *)p_list); + initMallocValue(p_node,"pointer",(void *)p_list); insertInTail(list_list,p_node); } return p_list; } -int init_value(Node *p_node,const char *type,void *p_value){ - p_node->if_setvalue = 1; +int initMallocValue(Node *p_node,const char *type,void *p_value){ + p_node->if_malloc = 1; p_node->type = type; p_node->value = p_value; return 0; @@ -223,22 +226,28 @@ int releaseNode(Node *p_node){ if(if_safeMode == 1){ removeByNode(node_list,p_node); } - if(p_node->if_setvalue == 1){ - free(p_node->value); - p_node->value = NULL; + if(p_node->if_malloc == 1){ + if(strcmp(p_node->type,"pointer")) { + if(!strcmp(p_node->type, "list")){ + releaseList((List *)p_node->value); + } + else{ + free(p_node->value); + } + } + p_node->value = NULL; } p_node->last = NULL; p_node->next = NULL; p_node->type = NULL; p_node->value = NULL; p_node->id = 0; - p_node->if_setvalue = 0; + p_node->if_malloc = 0; free(p_node); return 0; } - int releaseList(List *p_list){ Node *p_node, *pl_node; p_node = p_list->head; @@ -261,6 +270,15 @@ int releaseList(List *p_list){ return 0; } +int releaseListForSingle(List *p_list){ + p_list->head = NULL; + p_list->tail = NULL; + p_list->id = 0; + p_list->length = 0; + free(p_list); + return 0; +} + unsigned long long len(List *p_list){ return p_list->length; } @@ -273,7 +291,6 @@ int removeById(List *p_list, unsigned long id){ if(tmp->id == id) { tmp->last->next = tmp->next; tmp->next->last = tmp->last; - //releaseNode(tmp); 在安全模式下不必要 p_list->length -= 1; return 1;//found } @@ -293,7 +310,6 @@ int removeByNode(List *p_list, Node *p_node){ if(tmp == p_node){ tmp->last->next = tmp->next; tmp->next->last = tmp->last; - //releaseNode(tmp); 在安全模式下不必要 p_list->length -= 1; return 1;//found } @@ -372,7 +388,10 @@ Node *findById(List *p_list, const unsigned long long id){ Node *findByValue(List *p_list, const char *type, const void *value){ Node *p_node = p_list->head; while(p_node != NULL){ - if(strcmp(p_node->type,type)) continue;//continue when type is not the same. + if(strcmp(p_node->type,type)){ + p_node = p_node->next; + continue;//跳过不合类型的节点 + } if(!strcmp(type,"int")){ if(*((int *)p_node->value) == *((int *)value)){ return p_node; @@ -409,14 +428,14 @@ List *mply_findByValue(List *p_list, const char *type, const void *value){ if(!strcmp(type,"int")){ if(*((int *)p_node->value) == *((int *)value)){ Node *f_node = init_node(); - init_value(f_node,"pointer",(void *)p_node); + initMallocValue(f_node,"pointer",(void *)p_node); insertInTail(f_list,f_node); } } else if(!strcmp(type,"double")){ if(*((double *)p_node->value) == *((double *)value)){ Node *f_node = init_node(); - init_value(f_node,"pointer",(void *)p_node); + initMallocValue(f_node,"pointer",(void *)p_node); insertInTail(f_list,f_node); } } @@ -424,14 +443,14 @@ List *mply_findByValue(List *p_list, const char *type, const void *value){ if(!strcmp((char *)p_node->value,(char *)value)) { Node *f_node = init_node(); - init_value(f_node,"pointer",(void *)p_node); + initMallocValue(f_node,"pointer",(void *)p_node); insertInTail(f_list,f_node); } } else if(!strcmp(type,"pointer")){ if(p_node->value == value){ Node *f_node = init_node(); - init_value(f_node,"pointer",(void *)p_node); + initMallocValue(f_node,"pointer",(void *)p_node); insertInTail(f_list,f_node); } } diff --git a/list/list_easy.h b/list/list_easy.h deleted file mode 100644 index e35c68e..0000000 --- a/list/list_easy.h +++ /dev/null @@ -1,72 +0,0 @@ -#include "list.h" - -#ifndef LIST_EASY_H -#define LIST_EASY_H - -Node *new_nodeWithInt(int); -Node *new_nodeWithDouble(double); -Node *new_nodeWithString(const char *); -Node *new_nodeWithPointer(void *); -Node *find_nodeByIndex(List *, unsigned long long); -int list_through(List *p_list, int (*p_func)(void *, const char *));//Go through the list.Call p_func every time. - - -Node *new_nodeWithInt(int m_int){ - int *p_int = (int *)malloc(sizeof(int)); - *p_int = m_int; - Node *p_node = init_node(); - init_value(p_node,"int",(void *)p_int); - return p_node; -} - -Node *new_nodeWithDouble(double m_double){ - double *p_double = (double *)malloc(sizeof(double)); - *p_double = m_double; - Node *p_node = init_node(); - init_value(p_node,"double",(void *)p_double); - return p_node; -} - -Node *new_nodeWithString(const char *m_string){ - char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string)+1)); - strcpy(p_string,m_string); - Node *p_node = init_node(); - init_value(p_node,"string",(void *)p_string); - return p_node; -} - -Node *new_nodeWithPointer(void *m_pointer){ - Node *p_node = init_node(); - init_value(p_node,"pointer",(void *)m_pointer); - return p_node; -} - -Node *find_nodeByIndex(List *p_list, unsigned long long m_index){ - Node *p_node = p_list->head; - for(unsigned long long i= 0; i < m_index; i++){ - p_node = p_node->next; - } - return p_node; -} - -int list_through(List *p_list, int (*p_func)(void *, const char *)){ - Node *p_node = p_list->head; - while(p_node != NULL){ - if(p_node->if_setvalue == 1){ - int m_return = (*p_func)(p_node->value, p_node->type); - if (m_return == -1) break; - else if (m_return == 1){ - p_node = p_node->last; - continue; - } - else{ - - } - } - p_node = p_node->next; - } - return 0; -} - - -#endif diff --git a/list/list_expand.h b/list/list_expand.h new file mode 100644 index 0000000..d75c22d --- /dev/null +++ b/list/list_expand.h @@ -0,0 +1,298 @@ +#include "list.h" +#include + +#ifndef LIST_EASY_H +#define LIST_EASY_H + +Node *nodeWithInt(int);//快速初始化一个单一值节点并赋值 +Node *nodeWithDouble(double);//快速初始化一个节单一值点并赋值 +Node *nodeWithString(const char *);//快速初始化一个单一值节点并赋值 +Node *nodeWithPointer(void *);//快速初始化一个单一值节点并赋值 + +Node *nodeWithComplex(void);//快速初始化一个复合值节点并赋值 +int addValueForComplex(Node *, char *type, void *value);//为复合节点添加值 +int addIntForComplex(Node *, int);//为复合节点添加一个特定类型的值 +int addDoubleForComplex(Node *, double);//为复合节点添加一个特定类型的值 +int addStringForComplex(Node *, char *);//为复合节点添加一个特定类型的值 +int addPointerForComplex(Node *, void *);//为复合节点添加一个特定类型的值 + +Node *findByIndex(List *, unsigned long long);//根据位置查找一个节点 +Node *findByInt(List *, int);//依照特定类型查找一个节点 +Node *findByDouble(List *, double);//依照特定类型查找一个节点 +Node *findByString(List *, char *);//依照特定类型查找一个节点 +Node *findByPointer(List *, void *);//依照特定类型查找一个节点 + +void printListInfo(List *p_list,int priority);//打印列表的详细信息 +void printNodeInfo(Node *p_node,int priority);//打印节点的详细信息 +void printList(List *);//打印列表 +void printNode(Node *p_node);//打印节点 + +int getByInt(Node *);//直接得到节点的值 +double getByDouble(Node *);//直接得到节点的值 +char *getByString(Node *);//直接得到节点的值 +void *getByPointer(Node *);//直接得到节点的值 +int listThrough(List *p_list, int (*p_func)(void *, const char *));//遍历链表并不断调用目标函数。目标函数将接受节点储存值的指针及其类型。 + + +Node *nodeWithInt(int m_int){ + int *p_int = (int *)malloc(sizeof(int)); + *p_int = m_int; + Node *p_node = init_node(); + initMallocValue(p_node,"int",(void *)p_int); + return p_node; +} + +Node *nodeWithDouble(double m_double){ + double *p_double = (double *)malloc(sizeof(double)); + *p_double = m_double; + Node *p_node = init_node(); + initMallocValue(p_node,"double",(void *)p_double); + return p_node; +} + +Node *nodeWithString(const char *m_string){ + char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string)+1)); + strcpy(p_string,m_string); + Node *p_node = init_node(); + initMallocValue(p_node,"string",(void *)p_string); + return p_node; +} + +Node *nodeWithPointer(void *m_pointer){ + Node *p_node = init_node(); + initMallocValue(p_node,"pointer",m_pointer); + return p_node; +} + +Node *nodeWithComplex(void){ + Node *p_node = init_node(); + p_node->type = "list"; + p_node->value = init_list(); + p_node->if_malloc = 1; + return p_node; +} + +Node *findByIndex(List *p_list, unsigned long long m_index){ + Node *p_node = p_list->head; + for(unsigned long long i= 0; i < m_index; i++){ + p_node = p_node->next; + } + return p_node; +} + +int listThrough(List *p_list, int (*p_func)(void *, const char *)){ + Node *p_node = p_list->head; + while(p_node != NULL){ + if(p_node->if_malloc == 1){ + int m_return = (*p_func)(p_node->value, p_node->type); + if (m_return == -1) break; + else if (m_return == 1){ + p_node = p_node->last; + continue; + } + else{ + + } + } + p_node = p_node->next; + } + return 0; +} + +int getByInt(Node *p_node){ + if (strcmp(p_node->type, "int")) return *(int *)(p_node->value); + else return -1; +} + +char *getByString(Node *p_node){ + if (strcmp(p_node->type, "string")) return (char *)(p_node->value); + else return NULL; +} + +double getByDouble(Node *p_node){ + if (strcmp(p_node->type, "double")) return *(double *)(p_node->value); + else return -1; +} + +void *getByPointer(Node *p_node){ + if (strcmp(p_node->type, "pointer")) return (void *)(p_node->value); + else return NULL; +} + +void printListInfo(List *p_list,int priority){ + for(int i = 0; i < priority; i++) printf(" "); + printf("###LIST(location:%p, id:%llu){\n",p_list,p_list->id); + for(int i = 0; i < priority+1; i++) printf(" "); + printf("HEAD->%p / Tail->%p / Length:%llu\n",p_list->head,p_list->tail,p_list->length); + Node *p_node = p_list->head; + int i = 0; + while (p_node != NULL){ + for(int i = 0; i < priority+1; i++) printf(" "); + printf("%d.... \n",i); + printNodeInfo(p_node, priority+1); + p_node = p_node->next; + i++; + } + for(int i = 0; i < priority; i++) printf(" "); + printf("}\n"); + +} + +void printNodeInfo(Node *p_node,int priority){ + for(int i = 0; i < priority; i++) printf(" "); + printf("#NODE(location:%p, id:%llu){\n",p_node,p_node->id); + for(int i = 0; i < priority+1; i++) printf(" "); + printf("NEXT->%p / LAST->%p / MALLOC:%d\n",p_node->next,p_node->last,p_node->if_malloc); + if(!strcmp(p_node->type, "int")){ + for(int i = 0; i < priority+1; i++) printf(" "); + printf("VALUE(Int):%d\n",*(int *)(p_node->value)); + } + else if(!strcmp(p_node->type, "double")){ + for(int i = 0; i < priority+1; i++) printf(" "); + printf("VALUE(Double):%a\n",*(double *)(p_node->value)); + } + else if(!strcmp(p_node->type, "string")){ + for(int i = 0; i < priority+1; i++) printf(" "); + printf("VALUE(String):%s\n",(char *)(p_node->value)); + } + else if(!strcmp(p_node->type, "pointer")){ + for(int i = 0; i < priority+1; i++) printf(" "); + printf("VALUE(Pointer):%s\n",(char *)(p_node->value)); + } + else if(!strcmp(p_node->type, "list")){ + for(int i = 0; i < priority+1; i++) printf(" "); + printf("VALUE(List):\n"); + printListInfo((List *)p_node->value,priority+2); + } + for(int i = 0; i < priority; i++) printf(" "); + printf("}\n"); +} + +void printNode(Node *p_node){ + printf("#NODE(location:%p, id:%llu){\n",p_node,p_node->id); + printf(" "); + printf("NEXT->%p / LAST->%p / MALLOC:%d\n",p_node->next,p_node->last,p_node->if_malloc); + printf(" "); + if(!strcmp(p_node->type, "int")){ + printf("%d",*(int *)(p_node->value)); + } + else if(!strcmp(p_node->type, "double")){ + printf("%a\n",*(double *)(p_node->value)); + } + else if(!strcmp(p_node->type, "string")){ + printf("%s\n",(char *)(p_node->value)); + } + else if(!strcmp(p_node->type, "pointer")){ + printf("%s\n",(char *)(p_node->value)); + } + else if(!strcmp(p_node->type, "list")){ + printList((List *)p_node->value); + } + printf("}\n"); +} + +void printList(List *p_list){ + Node *p_node = p_list->head; + printf("["); + int if_nearLast = 0; + while (p_node != NULL) { + if(!if_nearLast && p_node->next == NULL) if_nearLast = 1; + if(!strcmp(p_node->type, "int")){ + printf("%d",*(int *)(p_node->value)); + } + else if(!strcmp(p_node->type, "double")){ + printf("%a",*(double *)(p_node->value)); + } + else if(!strcmp(p_node->type, "string")){ + printf("%s",(char *)(p_node->value)); + } + else if(!strcmp(p_node->type, "pointer")){ + printf("%s",(char *)(p_node->value)); + } + else if(!strcmp(p_node->type, "list")){ + printList((List *)p_node->value); + } + if(!if_nearLast){ + printf(", "); + } + p_node = p_node->next; + } + printf("]"); +} + +Node *findByInt(List *p_list, int target){ + int *p_target = (int *)malloc(sizeof(int)); + *p_target = target; + Node *t_node = findByValue(p_list, "int", p_target); + free(p_target); + return t_node; +} + +Node *findByDouble(List *p_list, double target){ + double *p_target = (double *)malloc(sizeof(double)); + *p_target = target; + Node *t_node = findByValue(p_list, "double", p_target); + free(p_target); + return t_node; +} + +Node *findByString(List *p_list, char *target){ + Node *t_node = findByValue(p_list, "string", target); + return t_node; +} + +Node *findByPointer(List *p_list, void *target){ + Node *t_node = findByValue(p_list, "pointer", target); + return t_node; +} + +int addValueForComplex(Node * p_node, char *type, void *value){ + if(!strcmp(p_node->type ,"list")){ + List *c_list = (List *)p_node->value; + Node *c_node = init_node(); + initMallocValue(c_node, type, value); + insertInTail(c_list, c_node); + return 0; + } + return -1; +} + +int addIntForComplex(Node *p_node, int temp){ + if(!strcmp(p_node->type, "list")){ + int *p_temp = (int *)malloc(sizeof(int)); + *p_temp = temp; + addValueForComplex(p_node, "int", p_temp); + return 0; + } + return -1; +} + +int addDoubleForComplex(Node *p_node, double temp){ + if(!strcmp(p_node->type, "list")){ + double *p_temp = (double *)malloc(sizeof(double)); + *p_temp = temp; + addValueForComplex(p_node, "double", p_temp); + return 0; + } + return -1; +} + +int addStringForComplex(Node *p_node, char *temp){ + if(!strcmp(p_node->type, "list")){ + char *p_temp = (char *)malloc(sizeof(strlen(temp)+1)); + strcpy(p_temp, temp); + addValueForComplex(p_node, "string", p_temp); + return 0; + } + return -1; +} + +int addPointerForComplex(Node *p_node, void *temp){ + if(!strcmp(p_node->type, "list")){ + addValueForComplex(p_node, "pointer", temp); + return 0; + } + return -1; +} + +#endif From d3550aa26b97d78e693e8474027ad3cfb8d8cc7a Mon Sep 17 00:00:00 2001 From: Saturneic Date: Sun, 10 Jun 2018 17:47:57 +0800 Subject: [PATCH 23/55] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=BA=86=E4=B8=80?= =?UTF-8?q?=E4=BA=9B=E5=8A=9F=E8=83=BD=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list.h | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/list/list.h b/list/list.h index 9c74c6d..180081a 100644 --- a/list/list.h +++ b/list/list.h @@ -41,6 +41,9 @@ unsigned long long getId(void); int insertInHead(List *p_list, Node *p_node); int insertInTail(List *p_list, Node *p_node); +/*交换函数*/ +int exchangeLocation(Node *p_node,Node *t_node); + /*移除函数*/ int removeById(List *p_list, unsigned long id); int removeByNode(List *p_list, Node *p_node); @@ -467,4 +470,18 @@ int isListEmpty(List *p_list){ return 0; // want to make a list empty. } +int exchangeLocation(Node *p_node,Node *t_node){ + Node *temp_next = p_node->next; + Node *temp_last = p_node->last; + p_node->last->next = t_node; + p_node->next->last = t_node; + t_node->last->next = p_node; + t_node->next->last = p_node; + p_node->next = t_node->next; + p_node->last = t_node->last; + t_node->next = temp_next; + t_node->last = temp_last; + return 0; +} + #endif From 510b191de5fd63f320c62d078a802bab75c9250e Mon Sep 17 00:00:00 2001 From: Saturneic Date: Mon, 11 Jun 2018 15:00:08 +0800 Subject: [PATCH 24/55] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=B9=B6=E4=BF=AE?= =?UTF-8?q?=E6=94=B9=E4=BA=86=E4=B8=80=E4=BA=9B=E5=87=BD=E6=95=B0=EF=BC=8C?= =?UTF-8?q?=E5=BC=80=E5=A7=8B=E5=86=99=E6=A0=88=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list.c | 16 ++++++------- list/list.h | 60 +++++++++++++++++++++++++++++++++------------- list/list_expand.h | 39 +++++++++++++++++++++++++++++- stack/stack.c | 14 +++++++++++ stack/stack.h | 37 ++++++++++++++++++++++++++++ 5 files changed, 141 insertions(+), 25 deletions(-) create mode 100644 stack/stack.c create mode 100644 stack/stack.h diff --git a/list/list.c b/list/list.c index 9bcf50f..91bb75c 100644 --- a/list/list.c +++ b/list/list.c @@ -9,6 +9,7 @@ int main(int argc, char **argv){ rand_init(); + safeMode(1); List *t_list = init_list(); /*for(int i = 0; i < 9; i++){ @@ -25,20 +26,19 @@ int main(int argc, char **argv){ for(int i = 0; i < 12; i++){ insertInHead(t_list, nodeWithInt(i)); + insertInTail(t_list, nodeWithInt(i)); } - Node *t_node = nodeWithComplex(); - addIntForComplex(t_node, 32); - addIntForComplex(t_node, 64); - insertInTail(t_list, t_node); - insertInTail(t_list, nodeWithDouble(32.5)); - insertInTail(t_list, nodeWithString("There")); - printNodeInfo(findByString(t_list, "There"), 0); + printListInfo(t_list,0); printList(t_list); + List *m_list; + m_list = m_findByInt(t_list, 5); + printList(m_list); printf("\n"); - releaseList(t_list); + + releaseAll(); return 0; } diff --git a/list/list.h b/list/list.h index 180081a..3081af7 100644 --- a/list/list.h +++ b/list/list.h @@ -44,6 +44,9 @@ int insertInTail(List *p_list, Node *p_node); /*交换函数*/ int exchangeLocation(Node *p_node,Node *t_node); +/*复制函数*/ +Node *copyNode(Node *); + /*移除函数*/ int removeById(List *p_list, unsigned long id); int removeByNode(List *p_list, Node *p_node); @@ -61,6 +64,7 @@ int releaseListForSingle(List *p_list);//单独释放List int releaseNode(Node *p_node);//释放Node int isListEmpty(List *p_list);//判断List是否为空 +List *copyList(List *p_list);//复制链表 /*有关安全模式的变量*/ int if_safeMode = 0; @@ -397,23 +401,23 @@ Node *findByValue(List *p_list, const char *type, const void *value){ } if(!strcmp(type,"int")){ if(*((int *)p_node->value) == *((int *)value)){ - return p_node; + return copyNode(p_node); } } else if(!strcmp(type,"double")){ if(*((double *)p_node->value) == *((double *)value)){ - return p_node; + return copyNode(p_node); } } else if(!strcmp (type,"string")){ if(!strcmp((char *)p_node->value,(char *)value)) { - return p_node; + return copyNode(p_node); } } else if(!strcmp(type,"pointer")){ if(p_node->value == value){ - return p_node; + return copyNode(p_node); } } @@ -427,34 +431,33 @@ List *mply_findByValue(List *p_list, const char *type, const void *value){ List *f_list = init_list(); Node *p_node = p_list->head; while(p_node != NULL){ - if(strcmp(p_node->type,type)) continue; + if(strcmp(p_node->type,type)){ + p_node = p_node->next; + continue; + } if(!strcmp(type,"int")){ if(*((int *)p_node->value) == *((int *)value)){ - Node *f_node = init_node(); - initMallocValue(f_node,"pointer",(void *)p_node); + Node *f_node = copyNode(p_node); insertInTail(f_list,f_node); } } else if(!strcmp(type,"double")){ if(*((double *)p_node->value) == *((double *)value)){ - Node *f_node = init_node(); - initMallocValue(f_node,"pointer",(void *)p_node); - insertInTail(f_list,f_node); + Node *f_node = copyNode(p_node); + insertInTail(f_list,f_node); } } else if(!strcmp (type,"string")){ if(!strcmp((char *)p_node->value,(char *)value)) { - Node *f_node = init_node(); - initMallocValue(f_node,"pointer",(void *)p_node); - insertInTail(f_list,f_node); + Node *f_node = copyNode(p_node); + insertInTail(f_list,f_node); } } else if(!strcmp(type,"pointer")){ if(p_node->value == value){ - Node *f_node = init_node(); - initMallocValue(f_node,"pointer",(void *)p_node); - insertInTail(f_list,f_node); + Node *f_node = copyNode(p_node); + insertInTail(f_list,f_node); } } @@ -484,4 +487,29 @@ int exchangeLocation(Node *p_node,Node *t_node){ return 0; } +Node *copyNode(Node *p_node){ + Node *t_node = init_node(); + t_node->id = p_node->id; + t_node->last = p_node->last; + t_node->next = p_node->next; + t_node->if_malloc = p_node->if_malloc; + t_node->type = p_node->type; + t_node->value = p_node->value; + return t_node; +} + +List *copyList(List *p_list){ + List *t_list = init_list(); + t_list->head = p_list->head; + t_list->tail = p_list->tail; + t_list->id = p_list->id; + Node *p_node = p_list->head; + while(p_node != NULL){ + Node *t_node = copyNode(p_node); + insertInTail(t_list, t_node); + p_node = p_node->next; + } + return t_list; +} + #endif diff --git a/list/list_expand.h b/list/list_expand.h index d75c22d..388756d 100644 --- a/list/list_expand.h +++ b/list/list_expand.h @@ -22,6 +22,11 @@ Node *findByDouble(List *, double);//依照特定类型查找一个节点 Node *findByString(List *, char *);//依照特定类型查找一个节点 Node *findByPointer(List *, void *);//依照特定类型查找一个节点 +List *m_findByInt(List*, int);//根据位置查找所有匹配的节点 +List *m_findByDouble(List*, double);//根据位置查找所有匹配的节点 +List *m_findByString(List*, char *);//根据位置查找所有匹配的节点 +List *m_findByPointer(List*, void *);//根据位置查找所有匹配的节点 + void printListInfo(List *p_list,int priority);//打印列表的详细信息 void printNodeInfo(Node *p_node,int priority);//打印节点的详细信息 void printList(List *);//打印列表 @@ -237,7 +242,10 @@ Node *findByDouble(List *p_list, double target){ } Node *findByString(List *p_list, char *target){ - Node *t_node = findByValue(p_list, "string", target); + char *p_temp = (char *)malloc(sizeof(char)*(strlen(target)+1)); + strcpy(p_temp, target); + Node *t_node = findByValue(p_list, "string", p_temp); + free(p_temp); return t_node; } @@ -295,4 +303,33 @@ int addPointerForComplex(Node *p_node, void *temp){ return -1; } +List *m_findByInt(List* p_list, int temp){ + int *p_temp = (int *)malloc(sizeof(int)); + *p_temp = temp; + List *t_list = mply_findByValue(p_list, "int", (void *)p_temp); + free(p_temp); + return t_list; +} + +List *m_findByDouble(List* p_list, double temp){ + double *p_temp = (double *)malloc(sizeof(double)); + *p_temp = temp; + List *t_list = mply_findByValue(p_list, "double", (void *)p_temp); + free(p_temp); + return t_list; +} + +List *m_findByString(List* p_list, char *temp){ + char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp)+1)); + strcpy(p_temp, temp); + List *t_list = mply_findByValue(p_list, "string", (void *)p_temp); + free(p_temp); + return t_list; +} + +List *m_findByPointer(List* p_list, void *temp){ + List *t_list = mply_findByValue(p_list, "double", (void *)temp); + return t_list; +} + #endif diff --git a/stack/stack.c b/stack/stack.c new file mode 100644 index 0000000..347880c --- /dev/null +++ b/stack/stack.c @@ -0,0 +1,14 @@ +// +// stack.c +// ZE-Standard-Libraries +// +// Created by 胡一兵 on 2018/6/11. +// Copyright © 2018年 ZE. All rights reserved. +// + +#include "stack.h" + +int main(int argc, char **argv){ + + return 0; +} diff --git a/stack/stack.h b/stack/stack.h new file mode 100644 index 0000000..83b4e4e --- /dev/null +++ b/stack/stack.h @@ -0,0 +1,37 @@ +// +// stack.h +// ZE-Standard-Libraries +// +// Created by 胡一兵 on 2018/6/11. +// Copyright © 2018年 ZE. All rights reserved. +// + +#ifndef stack_h +#define stack_h + +#include "list.h" + +typedef struct stack_node{ + unsigned long long id; + int if_malloc; + void *value; + struct stack_node *next; +} SNode; + +typedef struct stack{ + unsigned long long id; + unsigned long long length; + SNode *top; +} Stack; + +Stack *initStack(void); +SNode *initSNode(void); + +SNode *popStack(Stack *p_stack); +int pushStack(Stack *p_stack, SNode *p_snode); + +int releaseStack(Stack *p_stack); +int releaseSNode(SNode *p_snode); + + +#endif /* stack_h */ From bda6e3fea7a42af2115daff18e75d18cfbbd514d Mon Sep 17 00:00:00 2001 From: Saturneic Date: Mon, 11 Jun 2018 15:28:34 +0800 Subject: [PATCH 25/55] =?UTF-8?q?Stack=E4=B8=BB=E4=BD=93=E5=AE=8C=E6=88=90?= =?UTF-8?q?=E3=80=82=E5=85=B6=E4=BB=96=E7=A8=8D=E4=BD=9C=E4=BF=AE=E6=94=B9?= =?UTF-8?q?=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list.h | 8 +++--- list/list_expand.h | 18 ++++++------ stack/stack.h | 68 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 81 insertions(+), 13 deletions(-) diff --git a/list/list.h b/list/list.h index 3081af7..96a94d1 100644 --- a/list/list.h +++ b/list/list.h @@ -31,7 +31,7 @@ int releaseAll(void);//安全模式最后调用的函数 List *init_list(void); Node *init_node(void); -int initMallocValue(Node *,const char *,void *);//赋予已分配内存的值，并标明类型 +int initMalllocValueForNode(Node *,const char *,void *);//赋予已分配内存的值，并标明类型 /*有关id的函数*/ void init_rand(void); @@ -156,7 +156,7 @@ Node *init_node(void){ if_safeMode = 0; Node *prec_node = init_node(); if_safeMode = 1; - initMallocValue(prec_node, "pointer", (void *)p_node); + initMalllocValueForNode(prec_node, "pointer", (void *)p_node); insertInTail(node_list,prec_node); } return p_node; @@ -172,13 +172,13 @@ List *init_list(void){ if_safeMode = 0; Node *p_node = init_node(); if_safeMode = 1; - initMallocValue(p_node,"pointer",(void *)p_list); + initMalllocValueForNode(p_node,"pointer",(void *)p_list); insertInTail(list_list,p_node); } return p_list; } -int initMallocValue(Node *p_node,const char *type,void *p_value){ +int initMalllocValueForNode(Node *p_node,const char *type,void *p_value){ p_node->if_malloc = 1; p_node->type = type; p_node->value = p_value; diff --git a/list/list_expand.h b/list/list_expand.h index 388756d..39d7390 100644 --- a/list/list_expand.h +++ b/list/list_expand.h @@ -43,7 +43,7 @@ Node *nodeWithInt(int m_int){ int *p_int = (int *)malloc(sizeof(int)); *p_int = m_int; Node *p_node = init_node(); - initMallocValue(p_node,"int",(void *)p_int); + initMalllocValueForNode(p_node,"int",(void *)p_int); return p_node; } @@ -51,7 +51,7 @@ Node *nodeWithDouble(double m_double){ double *p_double = (double *)malloc(sizeof(double)); *p_double = m_double; Node *p_node = init_node(); - initMallocValue(p_node,"double",(void *)p_double); + initMalllocValueForNode(p_node,"double",(void *)p_double); return p_node; } @@ -59,13 +59,13 @@ Node *nodeWithString(const char *m_string){ char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string)+1)); strcpy(p_string,m_string); Node *p_node = init_node(); - initMallocValue(p_node,"string",(void *)p_string); + initMalllocValueForNode(p_node,"string",(void *)p_string); return p_node; } Node *nodeWithPointer(void *m_pointer){ Node *p_node = init_node(); - initMallocValue(p_node,"pointer",m_pointer); + initMalllocValueForNode(p_node,"pointer",m_pointer); return p_node; } @@ -105,22 +105,22 @@ int listThrough(List *p_list, int (*p_func)(void *, const char *)){ } int getByInt(Node *p_node){ - if (strcmp(p_node->type, "int")) return *(int *)(p_node->value); + if (!strcmp(p_node->type, "int")) return *(int *)(p_node->value); else return -1; } char *getByString(Node *p_node){ - if (strcmp(p_node->type, "string")) return (char *)(p_node->value); + if (!strcmp(p_node->type, "string")) return (char *)(p_node->value); else return NULL; } double getByDouble(Node *p_node){ - if (strcmp(p_node->type, "double")) return *(double *)(p_node->value); + if (!strcmp(p_node->type, "double")) return *(double *)(p_node->value); else return -1; } void *getByPointer(Node *p_node){ - if (strcmp(p_node->type, "pointer")) return (void *)(p_node->value); + if (!strcmp(p_node->type, "pointer")) return (void *)(p_node->value); else return NULL; } @@ -258,7 +258,7 @@ int addValueForComplex(Node * p_node, char *type, void *value){ if(!strcmp(p_node->type ,"list")){ List *c_list = (List *)p_node->value; Node *c_node = init_node(); - initMallocValue(c_node, type, value); + initMalllocValueForNode(c_node, type, value); insertInTail(c_list, c_node); return 0; } diff --git a/stack/stack.h b/stack/stack.h index 83b4e4e..d2d64ea 100644 --- a/stack/stack.h +++ b/stack/stack.h @@ -14,6 +14,7 @@ typedef struct stack_node{ unsigned long long id; int if_malloc; + const char *type; void *value; struct stack_node *next; } SNode; @@ -26,6 +27,7 @@ typedef struct stack{ Stack *initStack(void); SNode *initSNode(void); +int initMallocValueForSNode(SNode *p_snode, const char *type, void *value); SNode *popStack(Stack *p_stack); int pushStack(Stack *p_stack, SNode *p_snode); @@ -33,5 +35,71 @@ int pushStack(Stack *p_stack, SNode *p_snode); int releaseStack(Stack *p_stack); int releaseSNode(SNode *p_snode); +Stack *initStack(void){ + Stack *p_stack = (Stack *)malloc(sizeof(Stack)); + p_stack->id = getId(); + p_stack->length = 0; + p_stack->top = NULL; + return p_stack; +} + +SNode *initSNode(void){ + SNode *p_snode = (SNode *)malloc(sizeof(SNode)); + p_snode->id = getId(); + p_snode->if_malloc = 0; + p_snode->next = NULL; + p_snode->value = NULL; + return p_snode; +} + +SNode *popStack(Stack *p_stack){ + if(p_stack->top != NULL){ + SNode *p_snode = p_stack->top; + p_stack->top = p_snode->next; + p_snode->next = NULL; + p_stack->length -= 1; + return p_snode; + } + else return NULL; +} + +int pushStack(Stack *p_stack, SNode *p_snode){ + SNode *pn_snode = p_stack->top; + p_stack->top = p_snode; + p_snode->next = pn_snode; + p_stack->length -= 1; + return 0; +} + +int releaseStack(Stack *p_stack){ + SNode *p_sndoe = p_stack->top; + while(p_sndoe != NULL){ + SNode *pl_snode = p_sndoe; + p_sndoe = p_sndoe->next; + releaseSNode(pl_snode); + } + p_stack->id = 0; + p_stack->top = NULL; + p_stack->length = 0; + free(p_stack); + return 0; +} + +int releaseSNode(SNode *p_snode){ + p_snode->id = 0; + free(p_snode->value); + p_snode->if_malloc = 0; + p_snode->value = NULL; + p_snode->type = NULL; + free(p_snode); + return 0; +} + +int initMallocValueForSNode(SNode *p_snode, const char *type, void *value){ + p_snode->if_malloc = 1; + p_snode->type = type; + p_snode->value = value; + return 0; +} #endif /* stack_h */ From a8525b639bba80332c59f785269f289efb3f7995 Mon Sep 17 00:00:00 2001 From: Saturneic Date: Mon, 11 Jun 2018 15:57:25 +0800 Subject: [PATCH 26/55] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=B7=BB=E5=8A=A0?= =?UTF-8?q?=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list_expand.h | 44 +++++++++++++------------- stack/stack.c | 2 +- stack/stack_expand.h | 74 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 97 insertions(+), 23 deletions(-) create mode 100644 stack/stack_expand.h diff --git a/list/list_expand.h b/list/list_expand.h index 39d7390..b0cf0be 100644 --- a/list/list_expand.h +++ b/list/list_expand.h @@ -16,26 +16,26 @@ int addDoubleForComplex(Node *, double);//为复合节点添加一个特定类 int addStringForComplex(Node *, char *);//为复合节点添加一个特定类型的值 int addPointerForComplex(Node *, void *);//为复合节点添加一个特定类型的值 -Node *findByIndex(List *, unsigned long long);//根据位置查找一个节点 -Node *findByInt(List *, int);//依照特定类型查找一个节点 -Node *findByDouble(List *, double);//依照特定类型查找一个节点 -Node *findByString(List *, char *);//依照特定类型查找一个节点 -Node *findByPointer(List *, void *);//依照特定类型查找一个节点 +Node *findByIndexForNode(List *, unsigned long long);//根据位置查找一个节点 +Node *findByIntForNode(List *, int);//依照特定类型查找一个节点 +Node *findByDoubleForNode(List *, double);//依照特定类型查找一个节点 +Node *findByStringForNode(List *, char *);//依照特定类型查找一个节点 +Node *findByPointerForNode(List *, void *);//依照特定类型查找一个节点 -List *m_findByInt(List*, int);//根据位置查找所有匹配的节点 -List *m_findByDouble(List*, double);//根据位置查找所有匹配的节点 -List *m_findByString(List*, char *);//根据位置查找所有匹配的节点 -List *m_findByPointer(List*, void *);//根据位置查找所有匹配的节点 +List *m_findByIntForNode(List*, int);//根据位置查找所有匹配的节点 +List *m_findByDoubleForNode(List*, double);//根据位置查找所有匹配的节点 +List *m_findByStringForNode(List*, char *);//根据位置查找所有匹配的节点 +List *m_findByPointerForNode(List*, void *);//根据位置查找所有匹配的节点 void printListInfo(List *p_list,int priority);//打印列表的详细信息 void printNodeInfo(Node *p_node,int priority);//打印节点的详细信息 void printList(List *);//打印列表 void printNode(Node *p_node);//打印节点 -int getByInt(Node *);//直接得到节点的值 -double getByDouble(Node *);//直接得到节点的值 -char *getByString(Node *);//直接得到节点的值 -void *getByPointer(Node *);//直接得到节点的值 +int getByIntForNode(Node *);//直接得到节点的值 +double getByDoubleForNode(Node *);//直接得到节点的值 +char *getByStringForNode(Node *);//直接得到节点的值 +void *getByPointerForNode(Node *);//直接得到节点的值 int listThrough(List *p_list, int (*p_func)(void *, const char *));//遍历链表并不断调用目标函数。目标函数将接受节点储存值的指针及其类型。 @@ -77,7 +77,7 @@ Node *nodeWithComplex(void){ return p_node; } -Node *findByIndex(List *p_list, unsigned long long m_index){ +Node *findByIndexForNode(List *p_list, unsigned long long m_index){ Node *p_node = p_list->head; for(unsigned long long i= 0; i < m_index; i++){ p_node = p_node->next; @@ -104,22 +104,22 @@ int listThrough(List *p_list, int (*p_func)(void *, const char *)){ return 0; } -int getByInt(Node *p_node){ +int getByIntForNode(Node *p_node){ if (!strcmp(p_node->type, "int")) return *(int *)(p_node->value); else return -1; } -char *getByString(Node *p_node){ +char *getByStringForNode(Node *p_node){ if (!strcmp(p_node->type, "string")) return (char *)(p_node->value); else return NULL; } -double getByDouble(Node *p_node){ +double getByDoubleForNode(Node *p_node){ if (!strcmp(p_node->type, "double")) return *(double *)(p_node->value); else return -1; } -void *getByPointer(Node *p_node){ +void *getByPointerForNode(Node *p_node){ if (!strcmp(p_node->type, "pointer")) return (void *)(p_node->value); else return NULL; } @@ -225,7 +225,7 @@ void printList(List *p_list){ printf("]"); } -Node *findByInt(List *p_list, int target){ +Node *findByIntForNode(List *p_list, int target){ int *p_target = (int *)malloc(sizeof(int)); *p_target = target; Node *t_node = findByValue(p_list, "int", p_target); @@ -233,7 +233,7 @@ Node *findByInt(List *p_list, int target){ return t_node; } -Node *findByDouble(List *p_list, double target){ +Node *findByDoubleForNode(List *p_list, double target){ double *p_target = (double *)malloc(sizeof(double)); *p_target = target; Node *t_node = findByValue(p_list, "double", p_target); @@ -241,7 +241,7 @@ Node *findByDouble(List *p_list, double target){ return t_node; } -Node *findByString(List *p_list, char *target){ +Node *findByStringForNode(List *p_list, char *target){ char *p_temp = (char *)malloc(sizeof(char)*(strlen(target)+1)); strcpy(p_temp, target); Node *t_node = findByValue(p_list, "string", p_temp); @@ -249,7 +249,7 @@ Node *findByString(List *p_list, char *target){ return t_node; } -Node *findByPointer(List *p_list, void *target){ +Node *findByPointerForNode(List *p_list, void *target){ Node *t_node = findByValue(p_list, "pointer", target); return t_node; } diff --git a/stack/stack.c b/stack/stack.c index 347880c..02f8e00 100644 --- a/stack/stack.c +++ b/stack/stack.c @@ -6,7 +6,7 @@ // Copyright © 2018年 ZE. All rights reserved. // -#include "stack.h" +#include "stack_expand.h" int main(int argc, char **argv){ diff --git a/stack/stack_expand.h b/stack/stack_expand.h new file mode 100644 index 0000000..5db29eb --- /dev/null +++ b/stack/stack_expand.h @@ -0,0 +1,74 @@ +// +// stack_expand.h +// ZE-Standard-Libraries +// +// Created by 胡一兵 on 2018/6/11. +// Copyright © 2018年 ZE. All rights reserved. +// + +#ifndef stack_expand_h +#define stack_expand_h + +#include "stack.h" + +SNode *snodeWithInt(int); +SNode *snodeWithDouble(double); +SNode *snodeWithString(char *); +SNode *snodeWithPointer(void *); + +int getValueByIntForSNode(SNode *); +double getValueByDoubleForSNode(SNode *); +char *getValueByStringForSNode(SNode *); +void *getValueByPointerForSNode(SNode *); + +SNode *snodeWithInt(int temp){ + SNode *p_snode = initSNode(); + int *p_temp = (int *)malloc(sizeof(int)); + *p_temp = temp; + initMallocValueForSNode(p_snode, "int", p_temp); + return p_snode; +} + +SNode *snodeWithDouble(double temp){ + SNode *p_snode = initSNode(); + double *p_temp = (double *)malloc(sizeof(double)); + *p_temp = temp; + initMallocValueForSNode(p_snode, "double", p_temp); + return p_snode; +} + +SNode *snodeWithString(char *temp){ + SNode *p_snode = initSNode(); + char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp)+1)); + strcpy(p_temp, temp); + initMallocValueForSNode(p_snode, "string", p_temp); + return p_snode; +} + +SNode *snodeWithPointer(void *temp){ + SNode *p_snode = initSNode(); + initMallocValueForSNode(p_snode, "pointer", temp); + return p_snode; +} + +int getValueByIntForSNode(SNode *p_snode){ + if(!strcmp(p_snode->type, "int")) return *(int *)p_snode->value; + else return -1; +} + +double getValueByDoubleForSNode(SNode *p_snode){ + if(!strcmp(p_snode->type, "double")) return *(double *)p_snode->value; + else return -1; +} + +char *getValueByStringForSNode(SNode *p_snode){ + if(!strcmp(p_snode->type, "int")) return (char *)p_snode->value; + else return NULL; +} + +void *getValueByPointerForSNode(SNode *p_snode){ + if(!strcmp(p_snode->type, "int")) return (void *)p_snode->value; + else return NULL; +} + +#endif /* stack_expand_h */ From 785a6236faafb2c0a4c1f6e47da355c3a934a16b Mon Sep 17 00:00:00 2001 From: Saturneic Date: Mon, 11 Jun 2018 16:00:48 +0800 Subject: [PATCH 27/55] =?UTF-8?q?=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- stack/stack.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/stack/stack.c b/stack/stack.c index 02f8e00..7d22fd2 100644 --- a/stack/stack.c +++ b/stack/stack.c @@ -9,6 +9,13 @@ #include "stack_expand.h" int main(int argc, char **argv){ - + Stack *t_stack = initStack(); + for(int i = 0; i < 10; i++){ + pushStack(t_stack, snodeWithInt(i)); + } + for(int i = 0; i < 10; i++){ + printf("%d",getValueByIntForSNode(popStack(t_stack))); + } + releaseStack(t_stack); return 0; } From 768eee06df2927a1a6eb89c9ba12f31dd705d508 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Tue, 12 Jun 2018 13:46:59 +0800 Subject: [PATCH 28/55] =?UTF-8?q?=E5=87=BA=E7=8E=B0=E4=BA=86=E6=84=8F?= =?UTF-8?q?=E5=A4=96=E9=87=8D=E6=96=B0=E6=95=B4=E7=90=86=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c79cf27 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +################################################################################ +# 此 .gitignore 文件已由 Microsoft(R) Visual Studio 自动创建。 +################################################################################ + +/Debug From c1568c3a5f4008f34ea2270660fcbcfde3b411db Mon Sep 17 00:00:00 2001 From: Saturneric Date: Tue, 12 Jun 2018 13:51:42 +0800 Subject: [PATCH 29/55] =?UTF-8?q?=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 3 +++ list/list.c | Bin 1075 -> 2172 bytes list/list.h | Bin 11910 -> 23946 bytes list/list_expand.h | Bin 10906 -> 21118 bytes main.c | 10 ++++++++++ stack/stack.c | Bin 460 -> 588 bytes stack/stack.h | Bin 2250 -> 4426 bytes stack/stack_expand.h | Bin 1918 -> 3760 bytes tree/tree.c | 1 + tree/tree.h | 2 ++ 10 files changed, 16 insertions(+) create mode 100644 main.c create mode 100644 tree/tree.c create mode 100644 tree/tree.h diff --git a/.gitignore b/.gitignore index c79cf27..486a215 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,6 @@ ################################################################################ /Debug +/.vs/ZE-Standard-Libraries/v15 +/ZE-Standard-Libraries +/ZE-Standard-Libraries.sln diff --git a/list/list.c b/list/list.c index 91bb75cefcfb734b9c48c0be533005c5deb79dca..2750dedebd3de9369e2a986d85a6b0c5823b4aba 100644 GIT binary patch literal 2172 zcmcgt+iKfD5S>>Q`VWixB0HvbN=oVNp?xR~G<^!qOTi?Lj8z;tICih(*VCReqtULE z1X2P)NZQL>&YYQ@{d+Z*p#;1S`#hFM>NUurETobP%;xwnrNqeQTdbCHiup!X`Yo}t z(a}QX_&tV1DQm2{egP}Au#u;*J-|15JHkpSbzHK)R4es-Q=BvSW(1U`gjZb3{~QpBc(qU1~B;&tDNO3L8HL_>n6(q`o`iMo(`bT`Y2?#mC582G_8_`(4Mybg1m(; zQP65!kM**RbrUE9g>x0xYx=zb(uEXZ^Bs{!?b+IF1535PK{8jdz26%*bLt%E`4zuIqMn`jNW_ z*8N%1SGqkb-LX!>72ay>l<#pn5Fy!3dlPS_=XXMw+V3Nb5wSbu@)e$}=2FhmF{_d{ b-Lan7ciL&v9z|L9YTku*n^|Y%y5;I0owO|* literal 1075 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 diff --git a/list/list_expand.h b/list/list_expand.h index b0cf0be4530c1bc0aff2226ddfbfe0273ba5e843..022e003ac94164e3e775cb19cd382249d9242c54 100644 GIT binary patch literal 21118 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 literal 10906 zcmcIqZEqXL5&kUxiVXz@N1C$Zev~2sYNQ|n7$<-nw?$GAjCd3eC65GoOsyIQ6t}h| z+e(VOxk#GE0h-2W5l02u)T(Re$3#b3|DrQHv%7c4CeI)~9HMeTlL}_F5a(R7q^H=59GV?ItxOQkPbEyST z1sDGQ!tv@Gu4g%}mtVSY!T<3eC%a$ydtdtB-u3T&cKmqv`0?NUgHPd&zx%)EcWw-B z9Qj8-JpcDy_!xm%YxUl3*j82kHxdjmG+qMOrq^-YZELILc0I9GuXIFVB&5bmmha6L zC~0@B_gYSM8nlSIue6%&hJ97SjTY^%2mT-TVoV33h)T73rPAoxueLf0j2u&BjlG?= zT@)nmdpHyKIez?KU!sz>{r^1i?>sjlZYDWk<&V8`n<;%&vz-s{VXu19I#tfTORh5~QOj6h+VN zI@_*Y6^)j=E&rgo`wx!#2ak@Q9t@s7>VNf3fBzZTgj^RvMYn}8mCv4iIk@?4&^=?I zw7)`V0cTALs2vpo40vf$K;xkhV!%CV5Hn=_W?A_qWI=EW8*tbQ{r%nkpZEQHM<+KA zAlBI(VYp!{0-`bEbfCkQ1W;qh=|E$w38==HX;CwBNgIgQLsM+HwHC*ByWD_*B0LcA zxYcpI9U0#HANvP~{@(rPUq3`Me*d?@lUv6>e%*in`v4ZYSYqKDQD~Q4_gp5f37jk7dKvFCw zKg+e@I7qRUyeZd4+?`@E`VAd;x!!5@w(DW1VwMOC+*0egTY0XI5R}2ni#9oV|G@v? z*2%}uz}e6O96vtjfA-z;!`}}+c{upuQUAeh|Mt`Vr-wi7-Uxp54{xC*KfF(7^lv=$ zzxxwd5?tKBcl+d{J^#Zy{>>k#?7-SgCQ@d>KiHgzW*PqGuVv=&14xViEerXmkZ)ER zjnjGfCE6PD&u^M<24H#W{awM zko)7Rj_vh2uAoUvnd?#UDM+{}0wtJ0u4M$gIGR9Ceg_Jvv4~E*j@8oB72s)=Bfy}3 zykQCzDV9U6TC?1h{Tup=qQ1=|=riWKu+wlbU$9_Z!*(qVaPDFrb%x=s_73=haEto+ zX%#2DpyD)=#jzDp!z0FjsZ zU8#b3YORhn+=K~dS-i9)9PzS3f)D4;A>16P2x2Q;UHhsBNY~?RjdXK53WY5r{)lMs z+qwhCCzk4kWpU}PQb`Kx)Od7ZC17nZw|puIu~}xLLwac{S9(bw7PXq_Z4B?ZIj1Hd z)6~jkv2Zaj-tE|x-^izSqic)k6y9^#c#TRIjR!BN9G>I$Z21X{IX8z$*W@$&gG2al zy!~I2go>t*FV%zqR=|KnNnb#oXtuSv=l~_DJD(ST-9pHxVNX0u&F^ z^#`c1uz*EMBqfyzm1sKp8 zA4s56AREi6vacKBc6@{{C;>G0x>PAa0Vy|r#_z@dWW9Z?rpHi{IkiKE2S#CisjuF<{fVy=S59nIL2 z$g6A88OXayCxFFV7v&vM>?RS`REjf@_D$~HXD2Rpi`hIkCo_%N5+LUn4ejWt#s`uc z)fI`#dg=f*Q~oSu_JmwY&3;3~7ruTWhpEh)pOUiFdeB!ft{OTMI#S?){n9g(TAZt5 zvSO=I$VWPwkQXLr7QMsS5`y05Ec1Bgn+#>2+yN8BicOA?FO)P~+C#xDA@C1gLg6l) z;lUy=`wo1jPNzCUp`UzP#jb2WYh~B2bV^VaWh0ua5J(d#%p5S%c;hWkpK%6F%1ckT+}p-qh>W#o!I7^CMgg98dCwXi*iR@ z59#}Olv-t({4z&)l@1(!Sscl!?J|wQZcMV_YekrZ7lU_f03z<{-mjZ;`C0^_R#LK{+!dbn3Z-}9+GsCNvj$YVjt%}G71C{3M( zu7orTb*Tl6SC?*8*mgv1Gz12>C^aky=EcaL7I2|ZUpfx|!hl>cqCSWs-4O@d zTFTNbnJMTs`kW87o@9UY4{5rkj_0ATVDLGe?M>fAM0( zB5^=Vxe znT?B#DPw%B#4~(lA~v9XobqAa*W_Un;#YmEKz>vB%u6WG^qwgQ;vPW2E9dASL`#Oq$zJ9U3G`cVPvSA|#&ZCJGY6a`ARyqMOPtNumdsFsv`< zaYA?#IR$<(BI&9CtcZy^oYxa2tBGinsI;M{*b#m*w!=SHiS01d-8T`$`09gF%Pu3V z7^QDSx8bCnG80dwr%uNisY7VB3bYm&TPE8^XIg3(>y(?3>YRTO-G{O+ YwR}Uak%U79N4FU|;^u9)>eMp-2g)P6Jpcdz diff --git a/main.c b/main.c new file mode 100644 index 0000000..613e751 --- /dev/null +++ b/main.c @@ -0,0 +1,10 @@ +#include + +int stack(void); +int list(void); + +int main(int argc, char **argv) { + stack(); + getchar(); + return 0; +} \ No newline at end of file diff --git a/stack/stack.c b/stack/stack.c index 7d22fd2a7a697900a31452eaeefe1c9cdd41b9ff..15364d1a423506b693b8038df98cc5b42fcada4b 100644 GIT binary patch literal 588 zcmb`FO>4qH6h-e=q5mO7grthvwRY1*p&K`XE=4qHf?`TCmKNz>Z+m8p`PjH}F_3w= z_r3FO^7q?Qs-w0#=%k$@dGa;VScQx>)c0Cb{n7`wBZ`p{6c6e;pFv+M1AQu^zEep3 z>{J~ss!pCBd0saho}N)!f|NJ4GN8k>^vCqfQ3ch+l$-TU&{(&p8Rx0G4>V{Ibf7;m zHEB&~lMLxlz>&EWR*omp8x`XwhYg~iyOQPQUNLig^_lO>(!7(q(URQlw~6$k?~>=$ vC9=@Gqz%|F<23VYZ)fT2M6digT@RcMn@2a@*Kc7R2AZ5)F8SL(;nMFPz|C0; literal 460 zcmb7u9nmVqf3eR%I4SFhAL`l>whrG1)qh%p$xin qw0FFy@nYp@S0#;Z9XzbcYHw(?KZUSBZg9V4w-lkRNxOa6n*9M6u8Zpc diff --git a/stack/stack.h b/stack/stack.h index d2d64ea0d27e5d4177e247c78589221aec9e4704..d06f43e50f5ad31c0ee554f10ad609ef76ae2b3c 100644 GIT binary patch literal 4426 zcmd5=$!-%t5Un#3|1c;QJ0dJ+76~CC5a5d;*T~p$Y+>w?Jq}BhUkBdncF|ou)8ny~ z1F|B|QtNxQwDafpiOgjwV_C>nCUPl-JeQ4BxL)AR7kMNzc`5hhp8KQp6!MguLUt&h z`t z#B$}lOz>m@xh3x7t2s2E89hct56t31zR3uB)Ep;rV`q&~6?iv;+!|M>xc6~etJjdG zFG^fHn_J{&W%g%CZDRHVUcBxtEDmJ=>%_@FI|RKOll!rlb<P2%Q!#1B1_Dhq0z#>GUn5iAjutc|Pz)H|z z7AjrWXN0N$I7_w9IMv4*?6U$!@N^kjZ}+5@a#jL+UE{HN(QdwSY6`h{L*{e&h3r?DEwOB0G*6vg*7_OdtDhe9as>;OyhF$LI_Sk+R|xf=B;8l{Rk>>N z(gXP{AMmjqOExQ1%^LU>yBb$4v~$URy;1|>fjh1CzNCn&OsGNaBp)47jAiyAuCh7A z)%u}`TfKC1wBa6W>TGXA-p&)o8RkQqUK3;LyPdH^XN%>Kd$gBS2&2{-d*EtPt1PVm z?FY-U#lUBst74y<+R^WvbZkq}VYJFjo3$qSHb(NX*q%Le2t7?YP__5-s*<;6*K-VJ}ZJ-B8Q&M^*c@tbGO&E$9eMiR*viJg+VrsMJ?M1w7Pw~D$}I5 zzmLg5d`1}{6P~M?n~f{o*S5Fn*oEz_%-Xo)YSGC^7Hl`>b!>$-ZTYF|bDs;@R*z{W z$JSxMD(&F7Q_}gata+TtP#&o?gSbD#4ovfD@^I{a4qkkHwXqXNr@sl?v~t;{`E=z+ z&sqP&uNFIdx-*jQyt<}ER`2YDsB5J>hI^}Nu?{EaFqKa*9XNA%$|>YAey!R6P0VnA Jiszi*e*tWWm}LL} literal 2250 zcmbtW!EVz)5WV{=hW6rEP26xmNKqppR3xO*O9h8sBG+EWtD3d7-V_R|goOAIj@&_l zE8jvTK7*Z|S;uxADnt&6Ju^G=-n&{rbE6G5;qbCrplkgSSe-`+?i+It(I(sGjt*ehjYX2o6*nCn{58NEpj zhpH+Q?*p)(jcVjtS+HfL*7PN_g>y+|K<2C0Nm*7YnbJx%2GSzY5Mg4nUR5%K=qf2U zY-r4&7DP(CHH+W|&Q5LV#W<{c5siQ?g<6|}aJbwSSXH}9D3`5dbxJQGl1dtP86w=t zBH(CeM^N7GXxrcyj`u5M^{mn^I^;9;s=*E(z_1?&(CLM(;fvH&O|=<}O@OFu1Ximz zO)=&^pl(6L^)MmEYf*}%5o1Rt4qc>_bsrASSiP+E^ySG3IkYevt$a=^W!uJqRty+Pwmouy$ub0t z)(&80Z+8G@m!JI}X7b@U_dv5m)1_O3o@>ho&vyCj8Ve#O^RVqJ_UHjMX+mCXdtX^w zv>Q*&?5RVYZlTgnVg!DA<{km|;?PW&EaUVD=GzKGig@D2O@=5NVF%VJN)lT+|7qxn zuBWPK^+vgN*;4>DobmURt2q&IXiwf@$I$J}GH$P%YA|5~E1p6tWbk zu8Y_$Y}sXtvD=pW!%lQ`O_zN=JR%G kUa29{4eJ zY!B&IJRZ_#51;T7ukjvzyumjd@U)Lzp5B$dy`|(LIb3HiF?#fHTISqkCe!ltm6;dJ zdXK*p$Xp!-I(X_LUH8;3y)5ya{TT7tT%DSF=&9~y?9BuNb~8b@aSjKJDxD~p!<<>1 zxpQuONC&)4f-&t1d|@1!;s~#BURM8>PtH}RGWA_&r0cBrr~A^>tFFB+N8PEWK6NkZ zeA?bM^?GwWC2l$=m~pBX4p|B3BOi;f88IHQncz7sWNw1dXqm0B5xj)ib{V0+ishdV znD!GqadSWBq=&@Hf}Vd71E=I&uRj%2qFODit_I|8hKX9mGr<O&g%A{A?%HIQQ zF70(JsFp;j!&8q_3~vkn8>;M{Xa`mM_>2$yRFT#0&D2h_9b|ca)nm#k=Vm*#<#t|9 izRSDe6XMEmFaIXl=f6M6{{eL>=dPRZ-!84>j{X+}L{?=0 literal 1918 zcmbtV!HN?>5WUY=l*wggOftrU2#bQcD=frC2&=G{Fv(Ohjgy|CrxT1KEQlZC(fbN| z^;=xEfh2)buk}Np~Q| zDpmqZ^04!T!dPPh;}!h*{Pp*b%j+-SA(!y*LH}{|DC+ln7M2$)C1$CHU*Fhw{qqVg zPI~Yx%YYpvC@fJeF)=SZuPvrB!D)@qDD~Q86B2Km2`(quB0*?z1--Q8dBd}u3}Gqh z>#fk~snouZIyl<$9OsL1hJM0d4gR54LeBh28Y>7J{I7G0i^^Z-B4L0>zhQ>@O`I+8 z`HC{X%oX$T9V?1r)7^ks8VyLBxQb`_GypAu3h0P6Ah&uz98GsX= z;Ry&Sw5@{Z8-#ff79;b9-26Ta=5dzg6TcK6FrRYA9lAoA2kQtzzv2hns|{0^v;!^5 z(dvLr;sPnu3nj_M#E!gA+rzGnbibn9Tq?Fs7&O^>X%-m#S9LbV0R`4Hx!2IFnyRTe zS=Vbb#vt@dtumB8$G_iSmrB-2vGQ$*j_vNQGobbO}Y&dQ~#c6*1Vu*u~@rL^{PN8>mZ=3$5Ia6?rcy?b2%&x%t~D2 zpxbA;JB?OUj`?PMs T?tI!P6ETG-y!Gb=VdVV Date: Tue, 12 Jun 2018 17:03:31 +0800 Subject: [PATCH 30/55] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=92=8C=E4=BF=AE?= =?UTF-8?q?=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list.c | Bin 2172 -> 2166 bytes list/list.h | Bin 23946 -> 24428 bytes list/list_expand.h | Bin 21118 -> 22982 bytes main.c | 4 +- tree/tree.c | 6 +- tree/tree.h | 322 +++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 330 insertions(+), 2 deletions(-) diff --git a/list/list.c b/list/list.c index 2750dedebd3de9369e2a986d85a6b0c5823b4aba..c3b79f45cb66f0a11e1d0d032ee24ef4597381b6 100644 GIT binary patch delta 27 hcmew(@J(QY3^Sw8WO?RBM!(IAnNt~o6gO)jGXQ_S2l)U1 delta 33 kcmew+@JC>S3^Q{)L(XJb=0+f$w|PEuDkGS|%38<_0JAO$Z~y=R diff --git a/list/list.h b/list/list.h index 1de859a1637c99ec5846549e671e7ba31e0b881f..adc3808f6fc848355fea0904ee9f8fc24a2ad301 100644 GIT binary patch delta 246 zcmeC$&G=>?;|3m9MxV+2th$VTo9$UovQI8E7Gw2i$YaQv>>r`N`4i7Pes({Ge1;T; z)X5)JL^rRKImXE7H+gM@vARIM$qV!ZCYu-w ROn&7qG&#&zVRBWh0022XO>O`H delta 164 zcmaE}kFjev;|3m9=6Hsj$-Jz(Kss-;HS0N>bm-6x= fnaQ9zSuk9Fa)B(@W{pS{Ca@ac=whbHG4TQb!fh}D diff --git a/list/list_expand.h b/list/list_expand.h index 022e003ac94164e3e775cb19cd382249d9242c54..0b234a4ca9c71cea19b88402309369ae491e641e 100644 GIT binary patch delta 682 zcmZ`%&ubGw6n+z%GzpXKCe4pcRl1?6ByE%mrBtLFq}qyEcAI*TLaB(UxH+U)R_PB) z`w#T=^&p-q^bZgQJPH=ki!`1~5sxAsJqcB3H_3!NJh{$Hv71~D1RZLSizhsF@jpC1ZxN^IQ<2wx47clxoUwk+ zFP6oAE-c>McpYj-kux$lveRA&=FFt{cKh8wVR2+H2F?Uy=UNXAvja>A%cQVmBv8oc zI8GIM8&s2u*6@31khvJlU&Y?Ax-CZ_Tbq(gCztL^87qF?Wiq_+P*M6cbRs<6soAN|wRI?yj~IWYRV(cGHw(b1{A zM2&PHnzI#Hb~NaH799(A5fgC@`?k{cGH1Qi*%soxIeeK@V3b=Lcr}fi^P1o3aXE=e MQ^i45MQwiI4_r{SivR!s delta 257 zcmX@MnepEe#tnQtlY5M%COh%OvHLOPGo&!2Zr;vg&&V9lkT-chfAD56z7jBJ^M3y0 zjGQG5MGQF%sX)1Y!AO{z$u>gw;Oso%LtwU{NF|WY*}PgLl}Qk4GJ^tx7K0`bR!^SD zuR8gHsKVq);+rNLsPQrCOg<id = getId(); + p_tnode->child_num = 0; + p_tnode->father = NULL; + p_tnode->if_malloc = 0; + p_tnode->value = NULL; + p_tnode->type = NULL; + p_tnode->home = initList(); + p_tnode->room = NULL; + return p_tnode; +} + +Tree *initTree(void) { + Tree *p_tree = (Tree *)malloc(sizeof(Tree)); + p_tree->id = getId(); + p_tree->root = NULL; + return p_tree; +} + +int *initMallocValueForTNode(TNode *p_tnode, char *type, void *value) { + p_tnode->type = type; + p_tnode->value = value; + p_tnode->if_malloc = 1; + return 0; +} + +int addChildInLeft(TNode *f_tnode, TNode *c_tnode) { + Node *p_node = initNode(); + initMalllocValueForNode(p_node, "pointer", c_tnode); + insertInHead(f_tnode->home, p_node); + c_tnode->father = f_tnode; + f_tnode->child_num++; + return 0; +} + +int addChildInRight(TNode *f_tnode, TNode *c_tnode) { + Node *p_node = initNode(); + initMalllocValueForNode(p_node, "pointer", c_tnode); + insertInTail(f_tnode->home, p_node); + c_tnode->father = f_tnode; + f_tnode->child_num++; + return 0; +} + +TNode *getBrotherInLeft(TNode *p_tnode) { + List *p_home = p_tnode->father->home; + Node *p_node =p_home->head; + int index = getIndexByNode(p_home, p_node); + if (index > 0) return findByIndexForNode(p_home, index -1); + return NULL; +} + +TNode *getBrotherInRight(TNode *p_tnode) { + List *p_home = p_tnode->father->home; + Node *p_node = p_home->head; + int index = getIndexByNode(p_home, p_node); + if (index < p_home->length-1) return findByIndexForNode(p_home, index + 1); + return NULL; +} + +int removeChildInLeft(TNode *p_tnode) { + TNode *c_tnode = p_tnode->home->head; + c_tnode->father = NULL; + releaseOnlyNode(c_tnode->room); + c_tnode->room = NULL; + p_tnode->child_num--; + popFromHead(p_tnode->home); +} + +int removeChildInRight(TNode *p_tnode) { + TNode *c_tnode = p_tnode->home->tail; + c_tnode->father = NULL; + releaseOnlyNode(c_tnode->room); + c_tnode->room = NULL; + p_tnode->child_num--; + popFromTail(p_tnode->home); +} + +unsigned long long target_id = 0; +TNode *target_value_id = NULL; +TNode*_dogetChildById(char *type, void *value); + +TNode *getChildById(TNode *p_tnode, unsigned long long id) { + List *p_home = p_tnode->home; + target_id = 0; + target_value_id = NULL; + listThrough(p_home, _dogetChildById); + if (target_value_id != NULL) { + return target_value_id; + } + return NULL; +} + +TNode*_dogetChildById(char *type, void *value) { + if (!strcmp(type, "pointer")) { + TNode *p_tode = (TNode *)value; + if (p_tode->id == target_id) { + target_value_id = p_tode; + return -1; + } + } + return 0; +} + +char *target_type = NULL; +void *target_value = NULL; +TNode *target_value_value = NULL; +TNode*_dogetChildByValue(char *type, void *value); + +TNode *getChildByValue(TNode *p_tnode, char *type, void *value) { + List *p_home = p_tnode->home; + target_value = value; + target_type = type; + target_value_value = NULL; + listThrough(p_home, _dogetChildByValue); + if (target_value_value != NULL) { + return target_value_value; + } + return NULL; +} + +TNode*_dogetChildByValue(char *type, void *value) { + if (!strcmp(type, target_type)) { + TNode *p_tode = (TNode *)value; + if (!strcmp(target_value, "int")) { + if (*(int *)p_tode->value == *(int *)target_value) + { + target_value_value = p_tode; + return -1; + } + } + else if (!strcmp(target_value, "double")) + { + if (*(double *)p_tode->value == *(double *)target_value) + { + target_value_value = p_tode; + return -1; + } + } + else if (!strcmp(target_value, "string")) + { + if (!strcmp((char *)p_tode->value,(char *)target_value)) + { + target_value_value = p_tode; + return -1; + } + } + else if (!strcmp(target_value, "pointer")) + { + if (p_tode->value == target_value) + { + target_value_value = p_tode; + return -1; + } + } + + } + return 0; +} + +int removeChildById(TNode *p_tnode, unsigned long long id) { + TNode *t_tnode = getChildById(p_tnode, id); + if (t_tnode != NULL) { + TNode *p_fnode = t_tnode->father; + p_fnode->child_num--; + removeById(p_fnode->home, t_tnode->room->id); + releaseOnlyNode(t_tnode->room); + t_tnode->room = NULL; + return 0; + } + return -1; +} + +int removeChildByValue(TNode *p_tnode, char *type, void *value) { + TNode *t_tnode = getChildByValue(p_tnode, type, value); + if (t_tnode != NULL) { + TNode *p_fnode = t_tnode->father; + p_fnode->child_num--; + removeById(p_fnode->home, t_tnode->room->id); + releaseOnlyNode(t_tnode->room); + t_tnode->room = NULL; + return 0; + } + return -1; +} + +TNode *getChildByIndex(TNode *p_tnode, unsigned long long index) { + List *p_home = p_tnode->home; + Node *p_node = p_home->head; + int m_index = 0; + if (index < p_tnode->child_num-1) + { + while (p_node != NULL) { + m_index++; + p_node = p_node->next; + } + return (TNode *)p_node->value; + } + return NULL; +} + +unsigned long long getIndexByChild(TNode *f_tnode, TNode *c_tnode) { + List *p_home = f_tnode->home; + Node *p_node = p_home->head; + int m_index = 0; + while (p_node != NULL) { + TNode *p_tnode = (TNode *)p_node->value; + if (p_tnode->id == c_tnode->id) { + return m_index; + } + m_index++; + p_node = p_node->next; + } + return NULL; +} + +int removeChildByIndex(TNode *p_tnode, unsigned long long index){ + TNode *t_tnode = getChildByIndex(p_tnode, index); + if (t_tnode != NULL) { + TNode *p_fnode = t_tnode->father; + p_fnode->child_num--; + removeById(p_fnode->home, t_tnode->room->id); + releaseOnlyNode(t_tnode->room); + t_tnode->room = NULL; + return 0; + } + return -1; +} + +int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { + TNode *p_tnode = p_tree->root; + if (p_tnode != NULL) { + func(p_tnode, 0); + if (p_tnode->child_num > 0) { + for (int i = 0; i < p_tnode->child_num; i++) { + if (_doTreeThroughDown(getChildByIndex(p_tnode, i), 1, func) == -1) { + break; + } + } + } + } + return 0; +} + +int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) { + if (p_tnode->child_num > 0) { + for (int i = 0; i < p_tnode->child_num; i++) { + if (_doTreeThroughDown(getChildByIndex(p_tnode, i), height + 1, func)) return -1; + } + } + int func_back = func(p_tnode, height); + if (func_back == -1)return -1; + return 0; +} + +int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { + TNode *p_tnode = p_tree->root; + if (p_tree->root != NULL) { + if (p_tree->root->child_num > 0) { + func(p_tnode, 0); + for (int i = 0; i < p_tnode->child_num; i++) { + if (_doTreeThroughDown(getChildByIndex(p_tnode, i), 1, func) == -1) { + break; + } + } + } + } + return 0; +} + +int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) { + int func_back = func(p_tnode, height); + if (p_tnode->child_num > 0) { + for (int i = 0; i < p_tnode->child_num; i++) { + if (_doTreeThroughDown(getChildByIndex(p_tnode, i), height + 1, func)) return -1; + } + } + if (func_back == -1)return -1; + return 0; +} + From 71eb84f190a376496d4b58a6f518aa2b71982f40 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Tue, 12 Jun 2018 17:57:23 +0800 Subject: [PATCH 31/55] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=8E=E6=B7=BB?= =?UTF-8?q?=E5=8A=A0=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list.h | Bin 24428 -> 24778 bytes tree/tree.c | 2 +- tree/tree.h | 167 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 168 insertions(+), 1 deletion(-) diff --git a/list/list.h b/list/list.h index adc3808f6fc848355fea0904ee9f8fc24a2ad301..1e9faf6c9cc8545f3fb365f16e11ff94b73971a8 100644 GIT binary patch delta 534 zcmaE}kMYz&#tj9`>~0MC3`GonlQWsC#fupd8PXV18GM0aDL@(~r!THNS%4*gfIQda zX)H#(P(2V6HXmovW`$d!FRnOw9hbmn87?&zxZp!+(a8aP8$?m`!EE0Aldl=!#8RRC zc$`qWd6RGnGcE<2^~GaZP#rh9TiOurj6?(3$qxK1le2_`;9?J@9YwJQ$>e@**~urA zcqadnmYSR+!-qpvyrJyoc{1x5;Rd?OnZwy2e;<(Ln7lxOWAeHfp2^GPB4BcxzsoIW z;zkOP$qxgiCkyznOnxJW>^jNG_Y~t`nkIjj3!i+>muvGhr7Ik8L7=xbH)y|r2lwVg VgLVP9EHpwU%W&yzwsX{z0{~Kki);V@ delta 309 zcmX?gknznv#tj9`lMDDoCQo8c;0$I+WJqI3W$>N+kVA3u2TqR3Ml4=fME9_mZDQ48 zo$SIXH95h_W^*6cFXqV=@_dt*@NL*!z+b~WnL~kZGKcUgG`$x>I40M`a7?z7;G5jQ z%QbmHtj=aTkrHNNlu5i`o?N6RGP#GJYjTf{(BvJ4Vv{%UvrO)h5dv8~NttExJ{b)p zlm5#1Bk?vGNpG%`UB}3*$)GUVQCE6$fHFv5(`F8Z1x%B-Dd|BBNdme&VDkaxdmJDO WHXqV?!LoUWVS@n3tD6&?vg82LN@KSG diff --git a/tree/tree.c b/tree/tree.c index ca3e084..479d186 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -1,5 +1,5 @@ #include"tree.h" int tree(void) { - + return 0; } \ No newline at end of file diff --git a/tree/tree.h b/tree/tree.h index a46e524..6ceca66 100644 --- a/tree/tree.h +++ b/tree/tree.h @@ -20,6 +20,12 @@ typedef struct tree TNode *root; }Tree; +List *tree_list = NULL; +List *tnode_list = NULL; +int if_safeModeForTree = 0; +int safeModeForTree(int ifon); +int releaseAllForTree(void); + TNode *initTNode(void); Tree *initTree(void); int *initMallocValueForTNode(TNode *p_tnode, char *type, void *value); @@ -39,6 +45,36 @@ int removeChildByIndex(TNode *p_tnode, unsigned long long index); int removeChildByValue(TNode *p_tnode, char *type, void *value); int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); +int TreeTravel(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); + +int releaseTree(Tree *p_tree); +int releaseOnlyTree(Tree *p_tree); +int releaseTNode(TNode *p_tnode); +int releaseOnlyTNode(Tree *p_tree); + +int safeModeForTree(int ifon) { + if (ifon == 1) { + if (tnode_list == NULL && tree_list == NULL) { + tnode_list = (List *)malloc(sizeof(List)); + tree_list = (List *)malloc(sizeof(List)); + + tree_list->head = NULL; + tree_list->length = 0; + tree_list->tail = NULL; + + tnode_list->head = NULL; + tnode_list->length = 0; + tnode_list->tail = NULL; + + if_safeModeForTree = 1; + } + else { + return -1; + } + } + + return ifon; +} TNode *initTNode(void) { TNode *p_tnode = (TNode *)malloc(sizeof(TNode)); @@ -50,6 +86,21 @@ TNode *initTNode(void) { p_tnode->type = NULL; p_tnode->home = initList(); p_tnode->room = NULL; + if (if_safeModeForTree) { + if (if_safeModeForNode) { + if_safeModeForNode = 0; + Node *s_node = initNode(); + initMallocValueForTNode(s_node, "pointer", (void *)p_tnode); + insertInTail(tnode_list, s_node); + if_safeModeForNode = 1; + } + else + { + Node *s_node = initNode(); + initMallocValueForTNode(s_node, "pointer", (void *)p_tnode); + insertInTail(tnode_list, s_node); + } + } return p_tnode; } @@ -57,6 +108,21 @@ Tree *initTree(void) { Tree *p_tree = (Tree *)malloc(sizeof(Tree)); p_tree->id = getId(); p_tree->root = NULL; + if (if_safeModeForTree) { + if (if_safeModeForNode) { + if_safeModeForNode = 0; + Node *s_node = initNode(); + initMallocValueForTNode(s_node, "pointer", (void *)p_tree); + if_safeModeForNode = 1; + insertInTail(tree_list, s_node); + } + else + { + Node *s_node = initNode(); + initMallocValueForTNode(s_node, "pointer", (void *)p_tree); + insertInTail(tree_list, s_node); + } + } return p_tree; } @@ -322,3 +388,104 @@ int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned return 0; } +int TreeTravel(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { + TNode *p_tnode = p_tree->root; + unsigned long long height = 0; + if (p_tnode != NULL) { + int func_back = func(p_tnode, height); + while (func_back > -2) { + if (func_back > -1) { + p_tnode = getChildByIndex(func_back,func_back); + func(p_tnode, height + 1); + } + else + { + p_tnode = p_tnode->father; + func(p_tnode, height - 1); + + } + } + } + return 0; +} +int releaseTNode(TNode *p_tnode) { + if(p_tnode->child_num == 0){ + releaseList(p_tnode->home); + if (p_tnode->father != NULL) { + removeChildById(p_tnode->father, p_tnode->id); + } + if (strcmp(p_tnode->type, "pointer")) { + if (!strcmp(p_tnode->type, "list")) { + releaseList((List *)p_tnode->value); + } + else { + free(p_tnode->value); + } + } + p_tnode->value = NULL; + p_tnode->type = NULL; + p_tnode->id = 0; + p_tnode->if_malloc = 0; + free(p_tnode); + } + return 0; +} + +int _doreleaseTree(TNode *p_tnode, int height); + +int releaseTree(Tree *p_tree) { + TreeThroughUp(p_tree, _doreleaseTree); + p_tree->root = NULL; + p_tree->id = 0; + free(p_tree); +} + +int _doreleaseTree(TNode *p_tnode, int height) { + releaseTNode(p_tnode); + return 0; +} + + +int releaseOnlyTree(Tree *p_tree) { + p_tree->id = 0; + p_tree->root = NULL; + free(p_tree); + return 0; +} + +int releaseOnlyTNode(TNode *p_tnode) { + releaseList(p_tnode->home); + if (strcmp(p_tnode->type, "pointer")) { + if (!strcmp(p_tnode->type, "list")) { + releaseList((List *)p_tnode->value); + } + else { + free(p_tnode->value); + } + } + p_tnode->value = NULL; + p_tnode->type = NULL; + p_tnode->id = 0; + p_tnode->if_malloc = 0; + free(p_tnode); + return 0; +} + +int releaseAllForTree(void) { + if (if_safeModeForTree) { + if_safeModeForTree = 0; + Node *p_node = tnode_list->head; + while (p_node != NULL) { + TNode *p_tnode = (TNode *)p_node->value; + releaseOnlyTNode(p_tnode); + } + Node *p_node = tree_list->head; + while (p_node != NULL) { + Tree *p_tree = (Tree *)p_node->value; + releaseOnlyTree(p_tree); + } + releaseList(tnode_list); + releaseList(tree_list); + } + return 0; +} \ No newline at end of file From 6dbd74f199546ecd05c32c89a4572121b8b5abde Mon Sep 17 00:00:00 2001 From: Saturneric Date: Tue, 12 Jun 2018 19:07:12 +0800 Subject: [PATCH 32/55] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list.c | Bin 2166 -> 20414 bytes list/list.h | Bin 24778 -> 3888 bytes list/list_expand.c | 328 +++++++++++++++++++++++++++++++ list/list_expand.h | Bin 22982 -> 3374 bytes main.c | 12 -- stack/stack.c | Bin 588 -> 2886 bytes stack/stack.h | Bin 4426 -> 1276 bytes stack/stack_expand.c | 51 +++++ stack/stack_expand.h | Bin 3760 -> 838 bytes test.c | 63 ++++++ test.h | 15 ++ tree/tree.c | 439 ++++++++++++++++++++++++++++++++++++++++- tree/tree.h | 458 ++----------------------------------------- 13 files changed, 911 insertions(+), 455 deletions(-) create mode 100644 list/list_expand.c delete mode 100644 main.c create mode 100644 stack/stack_expand.c create mode 100644 test.c create mode 100644 test.h diff --git a/list/list.c b/list/list.c index c3b79f45cb66f0a11e1d0d032ee24ef4597381b6..e434c5a7b85155ae381b82bd6411fdc32bc6d9ba 100644 GIT binary patch literal 20414 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 literal 2166 zcmcgt+iKfD5S>>Q`VWixB0HvbN=oVNp?xR~G<^!qOTi?Lj8z;tICih(*VCReqtULE z1QH5CNZQL>&YYQ@{d+Z*p#;1S`#hFM>NUurETobP%;xwnrNqeQTdbCHiup!X`Yo}t z(a}QX_&tV1DQm2{egP}Au#u;*J-|15JHkpSbzHK)R4es-Q=BvSW(1U`gjZb3{~QpBc(qU1~B;&tDNO3L8HL_>n6(q`o`iMo(`bT`Y2?#mC582G_8_`(4Mybg1m(; zQP8SOMeB}$XJ!t|YuI(n6*Q?m0TS8>@&@nAX0{_c8Uq>1@O*A?@#GOf-Of`4E|nt4 zT92mbej}10Je`4~C7u;BQ6SbzeuIS-P`lh9;UjBMxUH(krg0jXIY_L3(eYL}P9qs1 zuf|P|(-SkvhzA;T)j>d6p7%BO_Ax$$UG{@QWxXOs9kx8{nOwrE)nJ+<=kNY3{~sD^ zvx1x_%fszV_1Vdx%f7?zkSj|booB*2n$7N3iM!|?R+(unx;_8*ve=JuaxIeUx?P=q z`v_x1>z>+1rs&^ literal 24778 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 Kd&sP)cK-!hHOkun diff --git a/list/list_expand.c b/list/list_expand.c new file mode 100644 index 0000000..a5f8fb3 --- /dev/null +++ b/list/list_expand.c @@ -0,0 +1,328 @@ +#include "list_expand.h" + +Node *nodeWithInt(int m_int) { + int *p_int = (int *)malloc(sizeof(int)); + *p_int = m_int; + Node *p_node = initNode(); + initMallocValueForNode(p_node, "int", (void *)p_int); + return p_node; +} + +Node *nodeWithDouble(double m_double) { + double *p_double = (double *)malloc(sizeof(double)); + *p_double = m_double; + Node *p_node = initNode(); + initMallocValueForNode(p_node, "double", (void *)p_double); + return p_node; +} + +Node *nodeWithString(const char *m_string) { + char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string) + 1)); + strcpy_s(p_string, sizeof(p_string), m_string); + Node *p_node = initNode(); + initMallocValueForNode(p_node, "string", (void *)p_string); + return p_node; +} + +Node *nodeWithPointer(void *m_pointer) { + Node *p_node = initNode(); + initMallocValueForNode(p_node, "pointer", m_pointer); + return p_node; +} + +Node *nodeWithComplex(void) { + Node *p_node = initNode(); + p_node->type = "list"; + p_node->value = initList(); + p_node->if_malloc = 1; + return p_node; +} + +Node *findByIndexForNode(List *p_list, unsigned long long m_index) { + Node *p_node = p_list->head; + for (unsigned long long i = 0; i < m_index; i++) { + p_node = p_node->next; + } + return p_node; +} + +int listThrough(List *p_list, int(*p_func)(const char *, void *)) { + Node *p_node = p_list->head; + while (p_node != NULL) { + if (p_node->if_malloc == 1) { + int m_return = (*p_func)(p_node->type, p_node->value); + if (m_return == -1) break; + else if (m_return == 1) { + p_node = p_node->last; + continue; + } + else { + + } + } + p_node = p_node->next; + } + return 0; +} + +int getByIntForNode(Node *p_node) { + if (!strcmp(p_node->type, "int")) return *(int *)(p_node->value); + else return -1; +} + +char *getByStringForNode(Node *p_node) { + if (!strcmp(p_node->type, "string")) return (char *)(p_node->value); + else return NULL; +} + +double getByDoubleForNode(Node *p_node) { + if (!strcmp(p_node->type, "double")) return *(double *)(p_node->value); + else return -1; +} + +void *getByPointerForNode(Node *p_node) { + if (!strcmp(p_node->type, "pointer")) return (void *)(p_node->value); + else return NULL; +} + +void printListInfo(List *p_list, int priority) { + for (int i = 0; i < priority; i++) printf(" "); + printf("###LIST(location:%p, id:%llu){\n", p_list, p_list->id); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("HEAD->%p / Tail->%p / Length:%llu\n", p_list->head, p_list->tail, p_list->length); + Node *p_node = p_list->head; + int i = 0; + while (p_node != NULL) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("%d.... \n", i); + printNodeInfo(p_node, priority + 1); + p_node = p_node->next; + i++; + } + for (int i = 0; i < priority; i++) printf(" "); + printf("}\n"); + +} + +void printList(List *p_list) { + Node *p_node = p_list->head; + printf("["); + int if_nearLast = 0; + while (p_node != NULL) { + if (!if_nearLast && p_node->next == NULL) if_nearLast = 1; + if (!strcmp(p_node->type, "int")) { + printf("%d", *(int *)(p_node->value)); + } + else if (!strcmp(p_node->type, "double")) { + printf("%a", *(double *)(p_node->value)); + } + else if (!strcmp(p_node->type, "string")) { + printf("%s", (char *)(p_node->value)); + } + else if (!strcmp(p_node->type, "pointer")) { + printf("%s", (char *)(p_node->value)); + } + else if (!strcmp(p_node->type, "list")) { + printList((List *)p_node->value); + } + if (!if_nearLast) { + printf(", "); + } + p_node = p_node->next; + } + printf("]"); +} + +void printNodeInfo(Node *p_node, int priority) { + for (int i = 0; i < priority; i++) printf(" "); + printf("#NODE(location:%p, id:%llu){\n", p_node, p_node->id); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("NEXT->%p / LAST->%p / MALLOC:%d\n", p_node->next, p_node->last, p_node->if_malloc); + if (!strcmp(p_node->type, "int")) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("VALUE(Int):%d\n", *(int *)(p_node->value)); + } + else if (!strcmp(p_node->type, "double")) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("VALUE(Double):%a\n", *(double *)(p_node->value)); + } + else if (!strcmp(p_node->type, "string")) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("VALUE(String):%s\n", (char *)(p_node->value)); + } + else if (!strcmp(p_node->type, "pointer")) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("VALUE(Pointer):%s\n", (char *)(p_node->value)); + } + else if (!strcmp(p_node->type, "list")) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("VALUE(List):\n"); + printListInfo((List *)p_node->value, priority + 2); + } + for (int i = 0; i < priority; i++) printf(" "); + printf("}\n"); +} + +void printNode(Node *p_node) { + printf("#NODE(location:%p, id:%llu){\n", p_node, p_node->id); + printf(" "); + printf("NEXT->%p / LAST->%p / MALLOC:%d\n", p_node->next, p_node->last, p_node->if_malloc); + printf(" "); + if (!strcmp(p_node->type, "int")) { + printf("%d", *(int *)(p_node->value)); + } + else if (!strcmp(p_node->type, "double")) { + printf("%a\n", *(double *)(p_node->value)); + } + else if (!strcmp(p_node->type, "string")) { + printf("%s\n", (char *)(p_node->value)); + } + else if (!strcmp(p_node->type, "pointer")) { + printf("%s\n", (char *)(p_node->value)); + } + else if (!strcmp(p_node->type, "list")) { + printList((List *)p_node->value); + } + printf("}\n"); +} + + +Node *findByIntForNode(List *p_list, int target) { + int *p_target = (int *)malloc(sizeof(int)); + *p_target = target; + Node *t_node = findByValue(p_list, "int", p_target); + free(p_target); + return t_node; +} + +Node *findByDoubleForNode(List *p_list, double target) { + double *p_target = (double *)malloc(sizeof(double)); + *p_target = target; + Node *t_node = findByValue(p_list, "double", p_target); + free(p_target); + return t_node; +} + +Node *findByStringForNode(List *p_list, char *target) { + char *p_temp = (char *)malloc(sizeof(char)*(strlen(target) + 1)); + strcpy_s(p_temp, sizeof(p_temp), target); + Node *t_node = findByValue(p_list, "string", p_temp); + free(p_temp); + return t_node; +} + +Node *findByPointerForNode(List *p_list, void *target) { + Node *t_node = findByValue(p_list, "pointer", target); + return t_node; +} + +int addValueForComplex(Node * p_node, char *type, void *value) { + if (!strcmp(p_node->type, "list")) { + List *c_list = (List *)p_node->value; + Node *c_node = initNode(); + initMallocValueForNode(c_node, type, value); + insertInTail(c_list, c_node); + return 0; + } + return -1; +} + +int addIntForComplex(Node *p_node, int temp) { + if (!strcmp(p_node->type, "list")) { + int *p_temp = (int *)malloc(sizeof(int)); + *p_temp = temp; + addValueForComplex(p_node, "int", p_temp); + return 0; + } + return -1; +} + +int addDoubleForComplex(Node *p_node, double temp) { + if (!strcmp(p_node->type, "list")) { + double *p_temp = (double *)malloc(sizeof(double)); + *p_temp = temp; + addValueForComplex(p_node, "double", p_temp); + return 0; + } + return -1; +} + +int addStringForComplex(Node *p_node, char *temp) { + if (!strcmp(p_node->type, "list")) { + char *p_temp = (char *)malloc(sizeof(strlen(temp) + 1)); + strcpy_s(p_temp, sizeof(p_temp), temp); + addValueForComplex(p_node, "string", p_temp); + return 0; + } + return -1; +} + +int addPointerForComplex(Node *p_node, void *temp) { + if (!strcmp(p_node->type, "list")) { + addValueForComplex(p_node, "pointer", temp); + return 0; + } + return -1; +} + +List *m_findByInt(List* p_list, int temp) { + int *p_temp = (int *)malloc(sizeof(int)); + *p_temp = temp; + List *t_list = mply_findByValue(p_list, "int", (void *)p_temp); + free(p_temp); + return t_list; +} + +List *m_findByDouble(List* p_list, double temp) { + double *p_temp = (double *)malloc(sizeof(double)); + *p_temp = temp; + List *t_list = mply_findByValue(p_list, "double", (void *)p_temp); + free(p_temp); + return t_list; +} + +List *m_findByString(List* p_list, char *temp) { + char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1)); + strcpy_s(p_temp, sizeof(p_temp), temp); + List *t_list = mply_findByValue(p_list, "string", (void *)p_temp); + free(p_temp); + return t_list; +} + +List *m_findByPointer(List* p_list, void *temp) { + List *t_list = mply_findByValue(p_list, "double", (void *)temp); + return t_list; +} + +unsigned long long getIndexByNode(List *p_list, Node *p_node) { + Node *t_node = p_list->head; + unsigned long long index = 0; + while (t_node != NULL) { + if (p_node->id == t_node->id) return index; + index++; + t_node = t_node->next; + } + return 0; +} + +List *m_findByIntForNode(List* p_list, int temp) { + int *p_temp = (int *)malloc(sizeof(int)); + *p_temp = temp; + return mply_findByValue(p_list, "int", (void *)p_temp); +} + +List *m_findByDoubleForNode(List* p_list, double temp) { + double *p_temp = (double *)malloc(sizeof(double)); + *p_temp = temp; + return mply_findByValue(p_list, "double", (void *)p_temp); +} + +List *m_findByStringForNode(List* p_list, char *temp) { + char *p_temp = (char *)malloc(sizeof(char) * (strlen(temp) + 1)); + strcpy_s(p_temp, sizeof(p_temp), temp); + return mply_findByValue(p_list, "string", (void *)p_temp); +} + +List *m_findByPointerForNode(List* p_list, void *temp) { + return mply_findByValue(p_list, "pointer", (void *)temp); +} diff --git a/list/list_expand.h b/list/list_expand.h index 0b234a4ca9c71cea19b88402309369ae491e641e..e2f32e93f8cb09789ef0ab4230bd9d77b18a929c 100644 GIT binary patch delta 20 ccmX@MnQ@)ehDAJ+7YT?>Uc-|%d0V6a0A1e*UjP6A literal 22982 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 - -int stack(void); -int list(void); -int tree(void); - -int main(int argc, char **argv) { - list(); - tree(); - getchar(); - return 0; -} \ No newline at end of file diff --git a/stack/stack.c b/stack/stack.c index 15364d1a423506b693b8038df98cc5b42fcada4b..32742ca3a3c9f2e20eb15cc713ab17597f1e3489 100644 GIT binary patch literal 2886 zcmbVO%We}v5bUdw_y+?Q8xaI&1V`7E@69xsMWUWZU|!{)Hg%k9Ia5`gg*(6Ol`?@wRGq0-n30u4wM<~yVj3vRsTVQK zxzyRFU9?5~YpB||%V$oC<}>(=G2pq%?Yc1Gc!SfpO0z4@?2(cwVlvDhbEcJ~e(YGy zHO^3qG$*3XFJi2A8fh6AIu+?LBz04Cn2ejixFO+dk2vve-@$PcsxakQg!|~N9b}R5 zn3FxvbE5C7_sTK99I?ew@j5fo{I=()gtB9F@5bEZh?SLiMY~irHS4r9lmUyq4jQ~D zCY;s!znx<^4qH6h-e=q5mO7grthvwRY1*p&K`XE=4qHf?`TCmKNz>Z+m8p`PjH}F_3w= z_r3FO^7q?Qs-w0#=%k$@dGa;VScQx>)c0Cb{n7`wBZ`p{6c6e;pFv+M1AQu^zEep3 z>{J~ss!pCBd0saho}N)!f|NJ4GN8k>^vCqfQ3ch+l$-TU&{(&p8Rx0G4>V{Ibf7;m zHEB&~lMLxlz>&EWR*omp8x`XwhYg~iyOQPQUNLig^_lO>(!7(q(URQlw~6$k?~>=$ vC9=@Gqz%|F<23VYZ)fT2M6digT@RcMn@2a@*Kc7R2AZ5)F8SL(;nMFPz|C0; diff --git a/stack/stack.h b/stack/stack.h index d06f43e50f5ad31c0ee554f10ad609ef76ae2b3c..08b406f5d5717b50af8ac96ec3c3b7674251bd31 100644 GIT binary patch delta 11 ScmX@5^oMi91(wNjf;s>n=>%i| literal 4426 zcmd5=$!-%t5Un#3|1c;QJ0dJ+76~CC5a5d;*T~p$Y+>w?Jq}BhUkBdncF|ou)8ny~ z1F|B|QtNxQwDafpiOgjwV_C>nCUPl-JeQ4BxL)AR7kMNzc`5hhp8KQp6!MguLUt&h z`t z#B$}lOz>m@xh3x7t2s2E89hct56t31zR3uB)Ep;rV`q&~6?iv;+!|M>xc6~etJjdG zFG^fHn_J{&W%g%CZDRHVUcBxtEDmJ=>%_@FI|RKOll!rlb<P2%Q!#1B1_Dhq0z#>GUn5iAjutc|Pz)H|z z7AjrWXN0N$I7_w9IMv4*?6U$!@N^kjZ}+5@a#jL+UE{HN(QdwSY6`h{L*{e&h3r?DEwOB0G*6vg*7_OdtDhe9as>;OyhF$LI_Sk+R|xf=B;8l{Rk>>N z(gXP{AMmjqOExQ1%^LU>yBb$4v~$URy;1|>fjh1CzNCn&OsGNaBp)47jAiyAuCh7A z)%u}`TfKC1wBa6W>TGXA-p&)o8RkQqUK3;LyPdH^XN%>Kd$gBS2&2{-d*EtPt1PVm z?FY-U#lUBst74y<+R^WvbZkq}VYJFjo3$qSHb(NX*q%Le2t7?YP__5-s*<;6*K-VJ}ZJ-B8Q&M^*c@tbGO&E$9eMiR*viJg+VrsMJ?M1w7Pw~D$}I5 zzmLg5d`1}{6P~M?n~f{o*S5Fn*oEz_%-Xo)YSGC^7Hl`>b!>$-ZTYF|bDs;@R*z{W z$JSxMD(&F7Q_}gata+TtP#&o?gSbD#4ovfD@^I{a4qkkHwXqXNr@sl?v~t;{`E=z+ z&sqP&uNFIdx-*jQyt<}ER`2YDsB5J>hI^}Nu?{EaFqKa*9XNA%$|>YAey!R6P0VnA Jiszi*e*tWWm}LL} diff --git a/stack/stack_expand.c b/stack/stack_expand.c new file mode 100644 index 0000000..faea8b1 --- /dev/null +++ b/stack/stack_expand.c @@ -0,0 +1,51 @@ +#include "stack_expand.h" + +SNode *snodeWithInt(int temp) { + SNode *p_snode = initSNode(); + int *p_temp = (int *)malloc(sizeof(int)); + *p_temp = temp; + initMallocValueForSNode(p_snode, "int", p_temp); + return p_snode; +} + +SNode *snodeWithDouble(double temp) { + SNode *p_snode = initSNode(); + double *p_temp = (double *)malloc(sizeof(double)); + *p_temp = temp; + initMallocValueForSNode(p_snode, "double", p_temp); + return p_snode; +} + +SNode *snodeWithString(char *temp) { + SNode *p_snode = initSNode(); + char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1)); + strcpy_s(p_temp, strlen(p_temp), temp); + initMallocValueForSNode(p_snode, "string", p_temp); + return p_snode; +} + +SNode *snodeWithPointer(void *temp) { + SNode *p_snode = initSNode(); + initMallocValueForSNode(p_snode, "pointer", temp); + return p_snode; +} + +int getValueByIntForSNode(SNode *p_snode) { + if (!strcmp(p_snode->type, "int")) return *(int *)p_snode->value; + else return -1; +} + +double getValueByDoubleForSNode(SNode *p_snode) { + if (!strcmp(p_snode->type, "double")) return *(double *)p_snode->value; + else return -1; +} + +char *getValueByStringForSNode(SNode *p_snode) { + if (!strcmp(p_snode->type, "int")) return (char *)p_snode->value; + else return NULL; +} + +void *getValueByPointerForSNode(SNode *p_snode) { + if (!strcmp(p_snode->type, "int")) return (void *)p_snode->value; + else return NULL; +} \ No newline at end of file diff --git a/stack/stack_expand.h b/stack/stack_expand.h index fe14aa2a308bec03fba7bd35e52a8e355c9664d1..300b68efb06b1eb147a2e3b461a5e23cdbe412f2 100644 GIT binary patch delta 11 ScmdlWdyH)Z5A){4eJ zY!B&IJRZ_#51;T7ukjvzyumjd@U)Lzp5B$dy`|(LIb3HiF?#fHTISqkCe!ltm6;dJ zdXK*p$Xp!-I(X_LUH8;3y)5ya{TT7tT%DSF=&9~y?9BuNb~8b@aSjKJDxD~p!<<>1 zxpQuONC&)4f-&t1d|@1!;s~#BURM8>PtH}RGWA_&r0cBrr~A^>tFFB+N8PEWK6NkZ zeA?bM^?GwWC2l$=m~pBX4p|B3BOi;f88IHQncz7sWNw1dXqm0B5xj)ib{V0+ishdV znD!GqadSWBq=&@Hf}Vd71E=I&uRj%2qFODit_I|8hKX9mGr<O&g%A{A?%HIQQ zF70(JsFp;j!&8q_3~vkn8>;M{Xa`mM_>2$yRFT#0&D2h_9b|ca)nm#k=Vm*#<#t|9 izRSDe6XMEmFaIXl=f6M6{{eL>=dPRZ-!84>j{X+}L{?=0 diff --git a/test.c b/test.c new file mode 100644 index 0000000..c21a0f5 --- /dev/null +++ b/test.c @@ -0,0 +1,63 @@ +#include "test.h" + +int list(void) { + init_rand(); + safeModeForNode(1); + List *t_list = initList(); + + /*for(int i = 0; i < 9; i++){ + Node *t_node = initNode(); + int *t_i = (int *)malloc(sizeof(int)); + *t_i = i; + initMallocValue(t_node,"int",(void *)t_i); + insertInTail(t_list,t_node); + }*/ + + /*Node *t_node = initNode(); + insertInTail(t_list,t_node); + initMalllocValue(t_node,(void *)"there");*/ + + for (int i = 0; i < 12; i++) { + insertInHead(t_list, nodeWithInt(i)); + insertInTail(t_list, nodeWithInt(i)); + } + + + + printListInfo(t_list, 0); + printList(t_list); + List *m_list; + m_list = m_findByIntForNode(t_list, 5); + printList(m_list); + printf("\n"); + + releaseAllForNode(); + + return 0; +} + +int tree(void) { + safeModeForTree(1); + Tree *t_tree = initTree(); + releaseAllForTree(); + return 0; +} + +int stack(void) { + Stack *t_stack = initStack(); + for (int i = 0; i < 10; i++) { + pushStack(t_stack, snodeWithInt(i)); + } + for (int i = 0; i < 10; i++) { + printf("%d", getValueByIntForSNode(popStack(t_stack))); + } + releaseStack(t_stack); + return 0; +} + + +int main(int argc, char **argv) { + tree(); + getchar(); + return 0; +} \ No newline at end of file diff --git a/test.h b/test.h new file mode 100644 index 0000000..cba9876 --- /dev/null +++ b/test.h @@ -0,0 +1,15 @@ +#ifndef TEST_H +#define TEST_H + +#include + +#include "list/list_expand.h" +#include "stack/stack_expand.h" +#include "tree/tree.h" + +int stack(void); +int list(void); +int tree(void); + +#endif // TEST_H + diff --git a/tree/tree.c b/tree/tree.c index 479d186..8d981e8 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -1,5 +1,438 @@ #include"tree.h" -int tree(void) { - + +int safeModeForTree(int ifon) { + if (ifon == 1) { + if (tnode_list == NULL && tree_list == NULL) { + tnode_list = (List *)malloc(sizeof(List)); + tree_list = (List *)malloc(sizeof(List)); + + tree_list->head = NULL; + tree_list->length = 0; + tree_list->tail = NULL; + + tnode_list->head = NULL; + tnode_list->length = 0; + tnode_list->tail = NULL; + + if_safeModeForTree = 1; + } + else { + return -1; + } + } + + return ifon; +} + +TNode *initTNode(void) { + TNode *p_tnode = (TNode *)malloc(sizeof(TNode)); + p_tnode->id = getId(); + p_tnode->child_num = 0; + p_tnode->father = NULL; + p_tnode->if_malloc = 0; + p_tnode->value = NULL; + p_tnode->type = NULL; + p_tnode->home = initList(); + p_tnode->room = NULL; + if (if_safeModeForTree) { + if (if_safeModeForNode) { + if_safeModeForNode = 0; + Node *s_node = initNode(); + initMallocValueForNode(s_node, "pointer", (void *)p_tnode); + insertInTail(tnode_list, s_node); + if_safeModeForNode = 1; + } + else + { + Node *s_node = initNode(); + initMallocValueForNode(s_node, "pointer", (void *)p_tnode); + insertInTail(tnode_list, s_node); + } + } + return p_tnode; +} + +Tree *initTree(void) { + Tree *p_tree = (Tree *)malloc(sizeof(Tree)); + p_tree->id = getId(); + p_tree->root = NULL; + if (if_safeModeForTree) { + if (if_safeModeForNode) { + if_safeModeForNode = 0; + Node *s_node = initNode(); + initMallocValueForNode(s_node, "pointer", (void *)p_tree); + if_safeModeForNode = 1; + insertInTail(tree_list, s_node); + } + else + { + Node *s_node = initNode(); + initMallocValueForNode(s_node, "pointer", (void *)p_tree); + insertInTail(tree_list, s_node); + } + } + return p_tree; +} + +int *initMallocValueForTNode(TNode *p_tnode, char *type, void *value) { + p_tnode->type = type; + p_tnode->value = value; + p_tnode->if_malloc = 1; return 0; -} \ No newline at end of file +} + +int addChildInLeft(TNode *f_tnode, TNode *c_tnode) { + Node *p_node = initNode(); + initMallocValueForNode(p_node, "pointer", c_tnode); + insertInHead(f_tnode->home, p_node); + c_tnode->father = f_tnode; + f_tnode->child_num++; + return 0; +} + +int addChildInRight(TNode *f_tnode, TNode *c_tnode) { + Node *p_node = initNode(); + initMallocValueForNode(p_node, "pointer", c_tnode); + insertInTail(f_tnode->home, p_node); + c_tnode->father = f_tnode; + f_tnode->child_num++; + return 0; +} + +TNode *getBrotherInLeft(TNode *p_tnode) { + List *p_home = p_tnode->father->home; + Node *p_node = p_home->head; + unsigned long long index = getIndexByNode(p_home, p_node); + if (index > 0) return (TNode *)(findByIndexForNode(p_home, index - 1)->value); + return NULL; +} + +TNode *getBrotherInRight(TNode *p_tnode) { + List *p_home = p_tnode->father->home; + Node *p_node = p_home->head; + unsigned long long index = getIndexByNode(p_home, p_node); + if (index < p_home->length - 1) return (TNode *)(findByIndexForNode(p_home, index + 1)->value); + return NULL; +} + +int removeChildInLeft(TNode *p_tnode) { + TNode *c_tnode = (TNode *)p_tnode->home->head->value; + c_tnode->father = NULL; + releaseOnlyNode(c_tnode->room); + c_tnode->room = NULL; + p_tnode->child_num--; + popFromHead(p_tnode->home); + return 0; +} + +int removeChildInRight(TNode *p_tnode) { + TNode *c_tnode = (TNode *)p_tnode->home->tail->value; + c_tnode->father = NULL; + releaseOnlyNode(c_tnode->room); + c_tnode->room = NULL; + p_tnode->child_num--; + popFromTail(p_tnode->home); + return 0; +} + + +TNode *getChildById(TNode *p_tnode, unsigned long long id) { + List *p_home = p_tnode->home; + target_id = 0; + target_value_id = NULL; + listThrough(p_home, _dogetChildById); + if (target_value_id != NULL) { + return target_value_id; + } + return NULL; +} + +int _dogetChildById(const char *type, void *value) { + if (!strcmp(type, "pointer")) { + TNode *p_tode = (TNode *)value; + if (p_tode->id == target_id) { + target_value_id = p_tode; + return -1; + } + } + return 0; +} + +char *target_type = NULL; +void *target_value = NULL; +TNode *target_value_value = NULL; +int _dogetChildByValue(const char *type, void *value); + +TNode *getChildByValue(TNode *p_tnode, char *type, void *value) { + List *p_home = p_tnode->home; + target_value = value; + target_type = type; + target_value_value = NULL; + listThrough(p_home, _dogetChildByValue); + if (target_value_value != NULL) { + return target_value_value; + } + return NULL; +} + +int _dogetChildByValue(const char *type, void *value) { + if (!strcmp(type, target_type)) { + TNode *p_tode = (TNode *)value; + if (!strcmp(target_value, "int")) { + if (*(int *)p_tode->value == *(int *)target_value) + { + target_value_value = p_tode; + return -1; + } + } + else if (!strcmp(target_value, "double")) + { + if (*(double *)p_tode->value == *(double *)target_value) + { + target_value_value = p_tode; + return -1; + } + } + else if (!strcmp(target_value, "string")) + { + if (!strcmp((char *)p_tode->value, (char *)target_value)) + { + target_value_value = p_tode; + return -1; + } + } + else if (!strcmp(target_value, "pointer")) + { + if (p_tode->value == target_value) + { + target_value_value = p_tode; + return -1; + } + } + + } + return 0; +} + +int removeChildById(TNode *p_tnode, unsigned long long id) { + TNode *t_tnode = getChildById(p_tnode, id); + if (t_tnode != NULL) { + TNode *p_fnode = t_tnode->father; + p_fnode->child_num--; + removeById(p_fnode->home, t_tnode->room->id); + releaseOnlyNode(t_tnode->room); + t_tnode->room = NULL; + return 0; + } + return -1; +} + +int removeChildByValue(TNode *p_tnode, char *type, void *value) { + TNode *t_tnode = getChildByValue(p_tnode, type, value); + if (t_tnode != NULL) { + TNode *p_fnode = t_tnode->father; + p_fnode->child_num--; + removeById(p_fnode->home, t_tnode->room->id); + releaseOnlyNode(t_tnode->room); + t_tnode->room = NULL; + return 0; + } + return -1; +} + +TNode *getChildByIndex(TNode *p_tnode, unsigned long long index) { + List *p_home = p_tnode->home; + Node *p_node = p_home->head; + int m_index = 0; + if (index < p_tnode->child_num - 1) + { + while (p_node != NULL) { + m_index++; + p_node = p_node->next; + } + return (TNode *)p_node->value; + } + return NULL; +} + +unsigned long long getIndexByChild(TNode *f_tnode, TNode *c_tnode) { + List *p_home = f_tnode->home; + Node *p_node = p_home->head; + int m_index = 0; + while (p_node != NULL) { + TNode *p_tnode = (TNode *)p_node->value; + if (p_tnode->id == c_tnode->id) { + return m_index; + } + m_index++; + p_node = p_node->next; + } + return -1; +} + +int removeChildByIndex(TNode *p_tnode, unsigned long long index) { + TNode *t_tnode = getChildByIndex(p_tnode, index); + if (t_tnode != NULL) { + TNode *p_fnode = t_tnode->father; + p_fnode->child_num--; + removeById(p_fnode->home, t_tnode->room->id); + releaseOnlyNode(t_tnode->room); + t_tnode->room = NULL; + return 0; + } + return -1; +} + + +int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { + TNode *p_tnode = p_tree->root; + if (p_tnode != NULL) { + func(p_tnode, 0); + if (p_tnode->child_num > 0) { + for (int i = 0; i < p_tnode->child_num; i++) { + if (_doTreeThroughUp(getChildByIndex(p_tnode, i), 1, func) == -1) { + break; + } + } + } + } + return 0; +} + +int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) { + if (p_tnode->child_num > 0) { + for (int i = 0; i < p_tnode->child_num; i++) { + if (_doTreeThroughUp(getChildByIndex(p_tnode, i), height + 1, func)) return -1; + } + } + int func_back = func(p_tnode, height); + if (func_back == -1)return -1; + return 0; +} + + +int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { + TNode *p_tnode = p_tree->root; + if (p_tree->root != NULL) { + if (p_tree->root->child_num > 0) { + func(p_tnode, 0); + for (int i = 0; i < p_tnode->child_num; i++) { + if (_doTreeThroughDown(getChildByIndex(p_tnode, i), 1, func) == -1) { + break; + } + } + } + } + return 0; +} + +int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) { + int func_back = func(p_tnode, height); + if (p_tnode->child_num > 0) { + for (int i = 0; i < p_tnode->child_num; i++) { + if (_doTreeThroughDown(getChildByIndex(p_tnode, i), height + 1, func)) return -1; + } + } + if (func_back == -1)return -1; + return 0; +} + +int TreeTravel(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { + TNode *p_tnode = p_tree->root; + unsigned long long height = 0; + if (p_tnode != NULL) { + int func_back = func(p_tnode, height); + while (func_back > -2) { + if (func_back > -1) { + p_tnode = getChildByIndex(p_tnode, func_back); + func(p_tnode, height + 1); + } + else + { + p_tnode = p_tnode->father; + func(p_tnode, height - 1); + + } + } + } + return 0; +} +int releaseTNode(TNode *p_tnode) { + if (p_tnode->child_num == 0) { + releaseList(p_tnode->home); + if (p_tnode->father != NULL) { + removeChildById(p_tnode->father, p_tnode->id); + } + if (strcmp(p_tnode->type, "pointer")) { + if (!strcmp(p_tnode->type, "list")) { + releaseList((List *)p_tnode->value); + } + else { + free(p_tnode->value); + } + } + p_tnode->value = NULL; + p_tnode->type = NULL; + p_tnode->id = 0; + p_tnode->if_malloc = 0; + free(p_tnode); + } + return 0; +} + +int releaseTree(Tree *p_tree) { + TreeThroughUp(p_tree, _doreleaseTree); + p_tree->root = NULL; + p_tree->id = 0; + free(p_tree); + return 0; +} + +int _doreleaseTree(TNode *p_tnode, unsigned long long height) { + releaseTNode(p_tnode); + return 0; +} + +int releaseOnlyTree(Tree *p_tree) { + p_tree->id = 0; + p_tree->root = NULL; + free(p_tree); + return 0; +} + +int releaseOnlyTNode(TNode *p_tnode) { + releaseList(p_tnode->home); + if (strcmp(p_tnode->type, "pointer")) { + if (!strcmp(p_tnode->type, "list")) { + releaseList((List *)p_tnode->value); + } + else { + free(p_tnode->value); + } + } + p_tnode->value = NULL; + p_tnode->type = NULL; + p_tnode->id = 0; + p_tnode->if_malloc = 0; + free(p_tnode); + return 0; +} + +int releaseAllForTree(void) { + if (if_safeModeForTree) { + if_safeModeForTree = 0; + Node *p_node = tnode_list->head; + while (p_node != NULL) { + TNode *p_tnode = (TNode *)p_node->value; + releaseOnlyTNode(p_tnode); + } + p_node = tree_list->head; + while (p_node != NULL) { + Tree *p_tree = (Tree *)p_node->value; + releaseOnlyTree(p_tree); + } + releaseList(tnode_list); + releaseList(tree_list); + } + return 0; +} diff --git a/tree/tree.h b/tree/tree.h index 6ceca66..3f5a7ae 100644 --- a/tree/tree.h +++ b/tree/tree.h @@ -1,6 +1,6 @@ -#pragma once - #include "../list/list_expand.h" +#ifndef TREE_H +#define TREE_H typedef struct tree_node { @@ -20,9 +20,9 @@ typedef struct tree TNode *root; }Tree; -List *tree_list = NULL; -List *tnode_list = NULL; -int if_safeModeForTree = 0; +List *tree_list; +List *tnode_list; +int if_safeModeForTree; int safeModeForTree(int ifon); int releaseAllForTree(void); @@ -47,445 +47,23 @@ int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height) int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); int TreeTravel(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); +int _dogetChildById(const char *type, void *value); +int _dogetChildByValue(const char *type, void *value); +int _doreleaseTree(TNode *p_tnode, unsigned long long height); +int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)); +int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)); + int releaseTree(Tree *p_tree); int releaseOnlyTree(Tree *p_tree); int releaseTNode(TNode *p_tnode); -int releaseOnlyTNode(Tree *p_tree); +int releaseOnlyTNode(TNode *p_tnode); -int safeModeForTree(int ifon) { - if (ifon == 1) { - if (tnode_list == NULL && tree_list == NULL) { - tnode_list = (List *)malloc(sizeof(List)); - tree_list = (List *)malloc(sizeof(List)); +char *target_type; +void *target_value; +TNode *target_value_value; - tree_list->head = NULL; - tree_list->length = 0; - tree_list->tail = NULL; - - tnode_list->head = NULL; - tnode_list->length = 0; - tnode_list->tail = NULL; - - if_safeModeForTree = 1; - } - else { - return -1; - } - } - - return ifon; -} - -TNode *initTNode(void) { - TNode *p_tnode = (TNode *)malloc(sizeof(TNode)); - p_tnode->id = getId(); - p_tnode->child_num = 0; - p_tnode->father = NULL; - p_tnode->if_malloc = 0; - p_tnode->value = NULL; - p_tnode->type = NULL; - p_tnode->home = initList(); - p_tnode->room = NULL; - if (if_safeModeForTree) { - if (if_safeModeForNode) { - if_safeModeForNode = 0; - Node *s_node = initNode(); - initMallocValueForTNode(s_node, "pointer", (void *)p_tnode); - insertInTail(tnode_list, s_node); - if_safeModeForNode = 1; - } - else - { - Node *s_node = initNode(); - initMallocValueForTNode(s_node, "pointer", (void *)p_tnode); - insertInTail(tnode_list, s_node); - } - } - return p_tnode; -} - -Tree *initTree(void) { - Tree *p_tree = (Tree *)malloc(sizeof(Tree)); - p_tree->id = getId(); - p_tree->root = NULL; - if (if_safeModeForTree) { - if (if_safeModeForNode) { - if_safeModeForNode = 0; - Node *s_node = initNode(); - initMallocValueForTNode(s_node, "pointer", (void *)p_tree); - if_safeModeForNode = 1; - insertInTail(tree_list, s_node); - } - else - { - Node *s_node = initNode(); - initMallocValueForTNode(s_node, "pointer", (void *)p_tree); - insertInTail(tree_list, s_node); - } - } - return p_tree; -} - -int *initMallocValueForTNode(TNode *p_tnode, char *type, void *value) { - p_tnode->type = type; - p_tnode->value = value; - p_tnode->if_malloc = 1; - return 0; -} - -int addChildInLeft(TNode *f_tnode, TNode *c_tnode) { - Node *p_node = initNode(); - initMalllocValueForNode(p_node, "pointer", c_tnode); - insertInHead(f_tnode->home, p_node); - c_tnode->father = f_tnode; - f_tnode->child_num++; - return 0; -} - -int addChildInRight(TNode *f_tnode, TNode *c_tnode) { - Node *p_node = initNode(); - initMalllocValueForNode(p_node, "pointer", c_tnode); - insertInTail(f_tnode->home, p_node); - c_tnode->father = f_tnode; - f_tnode->child_num++; - return 0; -} - -TNode *getBrotherInLeft(TNode *p_tnode) { - List *p_home = p_tnode->father->home; - Node *p_node =p_home->head; - int index = getIndexByNode(p_home, p_node); - if (index > 0) return findByIndexForNode(p_home, index -1); - return NULL; -} - -TNode *getBrotherInRight(TNode *p_tnode) { - List *p_home = p_tnode->father->home; - Node *p_node = p_home->head; - int index = getIndexByNode(p_home, p_node); - if (index < p_home->length-1) return findByIndexForNode(p_home, index + 1); - return NULL; -} - -int removeChildInLeft(TNode *p_tnode) { - TNode *c_tnode = p_tnode->home->head; - c_tnode->father = NULL; - releaseOnlyNode(c_tnode->room); - c_tnode->room = NULL; - p_tnode->child_num--; - popFromHead(p_tnode->home); -} - -int removeChildInRight(TNode *p_tnode) { - TNode *c_tnode = p_tnode->home->tail; - c_tnode->father = NULL; - releaseOnlyNode(c_tnode->room); - c_tnode->room = NULL; - p_tnode->child_num--; - popFromTail(p_tnode->home); -} - -unsigned long long target_id = 0; -TNode *target_value_id = NULL; -TNode*_dogetChildById(char *type, void *value); - -TNode *getChildById(TNode *p_tnode, unsigned long long id) { - List *p_home = p_tnode->home; - target_id = 0; - target_value_id = NULL; - listThrough(p_home, _dogetChildById); - if (target_value_id != NULL) { - return target_value_id; - } - return NULL; -} - -TNode*_dogetChildById(char *type, void *value) { - if (!strcmp(type, "pointer")) { - TNode *p_tode = (TNode *)value; - if (p_tode->id == target_id) { - target_value_id = p_tode; - return -1; - } - } - return 0; -} - -char *target_type = NULL; -void *target_value = NULL; -TNode *target_value_value = NULL; -TNode*_dogetChildByValue(char *type, void *value); - -TNode *getChildByValue(TNode *p_tnode, char *type, void *value) { - List *p_home = p_tnode->home; - target_value = value; - target_type = type; - target_value_value = NULL; - listThrough(p_home, _dogetChildByValue); - if (target_value_value != NULL) { - return target_value_value; - } - return NULL; -} - -TNode*_dogetChildByValue(char *type, void *value) { - if (!strcmp(type, target_type)) { - TNode *p_tode = (TNode *)value; - if (!strcmp(target_value, "int")) { - if (*(int *)p_tode->value == *(int *)target_value) - { - target_value_value = p_tode; - return -1; - } - } - else if (!strcmp(target_value, "double")) - { - if (*(double *)p_tode->value == *(double *)target_value) - { - target_value_value = p_tode; - return -1; - } - } - else if (!strcmp(target_value, "string")) - { - if (!strcmp((char *)p_tode->value,(char *)target_value)) - { - target_value_value = p_tode; - return -1; - } - } - else if (!strcmp(target_value, "pointer")) - { - if (p_tode->value == target_value) - { - target_value_value = p_tode; - return -1; - } - } - - } - return 0; -} - -int removeChildById(TNode *p_tnode, unsigned long long id) { - TNode *t_tnode = getChildById(p_tnode, id); - if (t_tnode != NULL) { - TNode *p_fnode = t_tnode->father; - p_fnode->child_num--; - removeById(p_fnode->home, t_tnode->room->id); - releaseOnlyNode(t_tnode->room); - t_tnode->room = NULL; - return 0; - } - return -1; -} - -int removeChildByValue(TNode *p_tnode, char *type, void *value) { - TNode *t_tnode = getChildByValue(p_tnode, type, value); - if (t_tnode != NULL) { - TNode *p_fnode = t_tnode->father; - p_fnode->child_num--; - removeById(p_fnode->home, t_tnode->room->id); - releaseOnlyNode(t_tnode->room); - t_tnode->room = NULL; - return 0; - } - return -1; -} - -TNode *getChildByIndex(TNode *p_tnode, unsigned long long index) { - List *p_home = p_tnode->home; - Node *p_node = p_home->head; - int m_index = 0; - if (index < p_tnode->child_num-1) - { - while (p_node != NULL) { - m_index++; - p_node = p_node->next; - } - return (TNode *)p_node->value; - } - return NULL; -} - -unsigned long long getIndexByChild(TNode *f_tnode, TNode *c_tnode) { - List *p_home = f_tnode->home; - Node *p_node = p_home->head; - int m_index = 0; - while (p_node != NULL) { - TNode *p_tnode = (TNode *)p_node->value; - if (p_tnode->id == c_tnode->id) { - return m_index; - } - m_index++; - p_node = p_node->next; - } - return NULL; -} - -int removeChildByIndex(TNode *p_tnode, unsigned long long index){ - TNode *t_tnode = getChildByIndex(p_tnode, index); - if (t_tnode != NULL) { - TNode *p_fnode = t_tnode->father; - p_fnode->child_num--; - removeById(p_fnode->home, t_tnode->room->id); - releaseOnlyNode(t_tnode->room); - t_tnode->room = NULL; - return 0; - } - return -1; -} - -int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { - TNode *p_tnode = p_tree->root; - if (p_tnode != NULL) { - func(p_tnode, 0); - if (p_tnode->child_num > 0) { - for (int i = 0; i < p_tnode->child_num; i++) { - if (_doTreeThroughDown(getChildByIndex(p_tnode, i), 1, func) == -1) { - break; - } - } - } - } - return 0; -} - -int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) { - if (p_tnode->child_num > 0) { - for (int i = 0; i < p_tnode->child_num; i++) { - if (_doTreeThroughDown(getChildByIndex(p_tnode, i), height + 1, func)) return -1; - } - } - int func_back = func(p_tnode, height); - if (func_back == -1)return -1; - return 0; -} - -int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { - TNode *p_tnode = p_tree->root; - if (p_tree->root != NULL) { - if (p_tree->root->child_num > 0) { - func(p_tnode, 0); - for (int i = 0; i < p_tnode->child_num; i++) { - if (_doTreeThroughDown(getChildByIndex(p_tnode, i), 1, func) == -1) { - break; - } - } - } - } - return 0; -} - -int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) { - int func_back = func(p_tnode, height); - if (p_tnode->child_num > 0) { - for (int i = 0; i < p_tnode->child_num; i++) { - if (_doTreeThroughDown(getChildByIndex(p_tnode, i), height + 1, func)) return -1; - } - } - if (func_back == -1)return -1; - return 0; -} - -int TreeTravel(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { - TNode *p_tnode = p_tree->root; - unsigned long long height = 0; - if (p_tnode != NULL) { - int func_back = func(p_tnode, height); - while (func_back > -2) { - if (func_back > -1) { - p_tnode = getChildByIndex(func_back,func_back); - func(p_tnode, height + 1); - } - else - { - p_tnode = p_tnode->father; - func(p_tnode, height - 1); - - } - } - } - return 0; -} -int releaseTNode(TNode *p_tnode) { - if(p_tnode->child_num == 0){ - releaseList(p_tnode->home); - if (p_tnode->father != NULL) { - removeChildById(p_tnode->father, p_tnode->id); - } - if (strcmp(p_tnode->type, "pointer")) { - if (!strcmp(p_tnode->type, "list")) { - releaseList((List *)p_tnode->value); - } - else { - free(p_tnode->value); - } - } - p_tnode->value = NULL; - p_tnode->type = NULL; - p_tnode->id = 0; - p_tnode->if_malloc = 0; - free(p_tnode); - } - return 0; -} - -int _doreleaseTree(TNode *p_tnode, int height); - -int releaseTree(Tree *p_tree) { - TreeThroughUp(p_tree, _doreleaseTree); - p_tree->root = NULL; - p_tree->id = 0; - free(p_tree); -} - -int _doreleaseTree(TNode *p_tnode, int height) { - releaseTNode(p_tnode); - return 0; -} +unsigned long long target_id; +TNode *target_value_id; -int releaseOnlyTree(Tree *p_tree) { - p_tree->id = 0; - p_tree->root = NULL; - free(p_tree); - return 0; -} - -int releaseOnlyTNode(TNode *p_tnode) { - releaseList(p_tnode->home); - if (strcmp(p_tnode->type, "pointer")) { - if (!strcmp(p_tnode->type, "list")) { - releaseList((List *)p_tnode->value); - } - else { - free(p_tnode->value); - } - } - p_tnode->value = NULL; - p_tnode->type = NULL; - p_tnode->id = 0; - p_tnode->if_malloc = 0; - free(p_tnode); - return 0; -} - -int releaseAllForTree(void) { - if (if_safeModeForTree) { - if_safeModeForTree = 0; - Node *p_node = tnode_list->head; - while (p_node != NULL) { - TNode *p_tnode = (TNode *)p_node->value; - releaseOnlyTNode(p_tnode); - } - Node *p_node = tree_list->head; - while (p_node != NULL) { - Tree *p_tree = (Tree *)p_node->value; - releaseOnlyTree(p_tree); - } - releaseList(tnode_list); - releaseList(tree_list); - } - return 0; -} \ No newline at end of file +#endif \ No newline at end of file From 42fb87bacdbafc8b0144c0e5d668b16dd2aea10d Mon Sep 17 00:00:00 2001 From: Saturneric Date: Wed, 13 Jun 2018 16:04:51 +0800 Subject: [PATCH 33/55] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=B8=8E=E4=BF=AE?= =?UTF-8?q?=E6=94=B9=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- list/list.c | Bin 20414 -> 20250 bytes list/list_expand.c | 2 +- test.c | 10 +++ test.h | 1 + tree/tree.c | 31 +++++-- tree/tree.h | 9 ++- tree/tree_expand.c | 197 +++++++++++++++++++++++++++++++++++++++++++++ tree/tree_expand.h | 21 +++++ 8 files changed, 260 insertions(+), 11 deletions(-) create mode 100644 tree/tree_expand.c create mode 100644 tree/tree_expand.h diff --git a/list/list.c b/list/list.c index e434c5a7b85155ae381b82bd6411fdc32bc6d9ba..5807c185967f5e568911ee5e02c9692e55d3834a 100644 GIT binary patch delta 201 zcmdltpK;baMyCJ&CI>N@O-^9d5;kD4X5eMuV(?+eWGH4RVNhVun(WUkIXQ=$OI?9M z9|%_jL_~jx;7dE+-%{4pw6j1DL%l4s_~a~Z9&t?d|E6Sg=xr`%dd)joM?qln138Y# z4*p`3SMcg=?h{~=n4DnAFS6`CBT?KF9vsoLZlx?+<9 YB-ti!(U1f3c{b0`j$_u(hMN=74 zfcz4Md@z{`6e$6-GQjFUWFk;SDnk)a6sBJTXbQ-L5(Yh>*_uESY8_BbI8Y>&ArERs zJ;<^GpyqsrETC{Q*l>hn^1#M`G^8--K(!!bAxy+0Co&WrUa}D*=j5v ztp{3J1XP#^Rt_?v5@iyFjxVx36Px+_J diff --git a/list/list_expand.c b/list/list_expand.c index a5f8fb3..3a756bc 100644 --- a/list/list_expand.c +++ b/list/list_expand.c @@ -120,7 +120,7 @@ void printList(List *p_list) { printf("%s", (char *)(p_node->value)); } else if (!strcmp(p_node->type, "pointer")) { - printf("%s", (char *)(p_node->value)); + printf("%p", (char *)(p_node->value)); } else if (!strcmp(p_node->type, "list")) { printList((List *)p_node->value); diff --git a/test.c b/test.c index c21a0f5..14423f9 100644 --- a/test.c +++ b/test.c @@ -1,5 +1,6 @@ #include "test.h" + int list(void) { init_rand(); safeModeForNode(1); @@ -39,6 +40,15 @@ int list(void) { int tree(void) { safeModeForTree(1); Tree *t_tree = initTree(); + TNode *t_tnode = tnodeWithInt(1), *cr_tnode = tnodeWithInt(3),*cl_tnode = tnodeWithInt(2); + addChildInRight(t_tnode, cl_tnode); + addChildInRight(t_tnode, cr_tnode); + addChildInRight(cl_tnode, tnodeWithInt(4)); + addChildInRight(cl_tnode, tnodeWithInt(5)); + addChildInRight(cr_tnode, tnodeWithInt(6)); + addChildInRight(cr_tnode, tnodeWithInt(7)); + printTNodeWithFamily(t_tnode, 0); + //removeChildByIndex(t_tnode, 0); releaseAllForTree(); return 0; } diff --git a/test.h b/test.h index cba9876..3e171ce 100644 --- a/test.h +++ b/test.h @@ -6,6 +6,7 @@ #include "list/list_expand.h" #include "stack/stack_expand.h" #include "tree/tree.h" +#include "tree/tree_expand.h" int stack(void); int list(void); diff --git a/tree/tree.c b/tree/tree.c index 8d981e8..0d42a14 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -1,5 +1,9 @@ #include"tree.h" +unsigned long long target_id = 0; +TNode *target_value_id = NULL; +int if_safeModeForTree = 0; + int safeModeForTree(int ifon) { if (ifon == 1) { if (tnode_list == NULL && tree_list == NULL) { @@ -86,6 +90,7 @@ int addChildInLeft(TNode *f_tnode, TNode *c_tnode) { initMallocValueForNode(p_node, "pointer", c_tnode); insertInHead(f_tnode->home, p_node); c_tnode->father = f_tnode; + c_tnode->room = p_node; f_tnode->child_num++; return 0; } @@ -95,6 +100,7 @@ int addChildInRight(TNode *f_tnode, TNode *c_tnode) { initMallocValueForNode(p_node, "pointer", c_tnode); insertInTail(f_tnode->home, p_node); c_tnode->father = f_tnode; + c_tnode->room = p_node; f_tnode->child_num++; return 0; } @@ -246,7 +252,7 @@ TNode *getChildByIndex(TNode *p_tnode, unsigned long long index) { int m_index = 0; if (index < p_tnode->child_num - 1) { - while (p_node != NULL) { + while (p_node != NULL && m_index < index) { m_index++; p_node = p_node->next; } @@ -273,7 +279,7 @@ unsigned long long getIndexByChild(TNode *f_tnode, TNode *c_tnode) { int removeChildByIndex(TNode *p_tnode, unsigned long long index) { TNode *t_tnode = getChildByIndex(p_tnode, index); if (t_tnode != NULL) { - TNode *p_fnode = t_tnode->father; + TNode *p_fnode = t_tnode->father; p_fnode->child_num--; removeById(p_fnode->home, t_tnode->room->id); releaseOnlyNode(t_tnode->room); @@ -402,12 +408,14 @@ int releaseOnlyTree(Tree *p_tree) { int releaseOnlyTNode(TNode *p_tnode) { releaseList(p_tnode->home); - if (strcmp(p_tnode->type, "pointer")) { - if (!strcmp(p_tnode->type, "list")) { - releaseList((List *)p_tnode->value); - } - else { - free(p_tnode->value); + if (p_tnode->if_malloc) { + if (strcmp(p_tnode->type, "pointer")) { + if (!strcmp(p_tnode->type, "list")) { + releaseList((List *)p_tnode->value); + } + else { + free(p_tnode->value); + } } } p_tnode->value = NULL; @@ -425,14 +433,21 @@ int releaseAllForTree(void) { while (p_node != NULL) { TNode *p_tnode = (TNode *)p_node->value; releaseOnlyTNode(p_tnode); + p_node = p_node->next; } p_node = tree_list->head; while (p_node != NULL) { Tree *p_tree = (Tree *)p_node->value; releaseOnlyTree(p_tree); + p_node = p_node->next; } releaseList(tnode_list); releaseList(tree_list); } return 0; } + +int setRoot(Tree *p_tree, TNode *p_tnode) { + p_tree->root = p_tnode; + return 0; +} diff --git a/tree/tree.h b/tree/tree.h index 3f5a7ae..ac06ac7 100644 --- a/tree/tree.h +++ b/tree/tree.h @@ -20,8 +20,7 @@ typedef struct tree TNode *root; }Tree; -List *tree_list; -List *tnode_list; + int if_safeModeForTree; int safeModeForTree(int ifon); int releaseAllForTree(void); @@ -58,6 +57,8 @@ int releaseOnlyTree(Tree *p_tree); int releaseTNode(TNode *p_tnode); int releaseOnlyTNode(TNode *p_tnode); +int setRoot(Tree *p_tree, TNode *p_tnode); + char *target_type; void *target_value; TNode *target_value_value; @@ -65,5 +66,9 @@ TNode *target_value_value; unsigned long long target_id; TNode *target_value_id; +List *tree_list; +List *tnode_list; +int if_safeModeForTree; + #endif \ No newline at end of file diff --git a/tree/tree_expand.c b/tree/tree_expand.c new file mode 100644 index 0000000..478929a --- /dev/null +++ b/tree/tree_expand.c @@ -0,0 +1,197 @@ +#include "tree_expand.h" + +TNode *tnodeWithInt(int temp) { + TNode *p_tnode = initTNode(); + int *p_temp = (int *)malloc(sizeof(int)); + *p_temp = temp; + initMallocValueForTNode(p_tnode, "int", p_temp); + return p_tnode; +} + +TNode *tnodeWithDouble(double temp) { + TNode *p_tnode = initTNode(); + double *p_temp = (double *)malloc(sizeof(double)); + *p_temp = temp; + initMallocValueForTNode(p_tnode, "double", p_temp); + return p_tnode; +} +TNode *tnodeWithString(char *temp) { + TNode *p_tnode = initTNode(); + char *p_temp = (char *)malloc(sizeof(temp)); + strcpy_s(p_temp, sizeof(p_temp), temp); + initMallocValueForTNode(p_tnode, "double", p_temp); + return p_tnode; +} + +TNode *tnodeWithPointer(void *temp) { + TNode *p_tnode = initTNode(); + initMallocValueForTNode(p_tnode, "pointer", temp); + return p_tnode; +} + +int getValueByIntForTree(TNode *p_tnode) { + if (!strcmp(p_tnode->type, "int")) { + return *(int *)p_tnode->value; + } + return -1; +} + +double getValueByDoubleForTree(TNode *p_tnode) { + if (!strcmp(p_tnode->type, "double")) { + return *(double *)p_tnode->value; + } + return -1; +} + +char *getValueByStringForTree(TNode *p_tnode) { + if (!strcmp(p_tnode->type, "string")) { + return (char *)p_tnode->value; + } + return NULL; +} + +void *getValueByPointerForTree(TNode *p_tnode) { + if (!strcmp(p_tnode->type, "pointer")) { + return p_tnode->value; + } + return NULL; +} + +int printTNode(TNode *p_tnode, int priority) { + for (int i = 0; i < priority; i++) printf(" "); + if (priority == 0) printf("###"); + else printf("#"); + printf("TNode(id: %llu)\n", p_tnode->id); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("ifMalloc: "); + if (p_tnode->if_malloc) { + printf("YES\n"); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Value(type: %s): ", p_tnode->type); + if (!strcmp(p_tnode->type, "int")) { + printf("%d\n", *(int *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "double")) { + printf("%a\n", *(double *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "string")) { + printf("%s\n", (char *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "pointer")) { + printf("%p\n", (char *)(p_tnode->value)); + } + } + else printf("NO\n"); + + if (p_tnode->child_num > 0) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Child number: %llu\n", p_tnode->child_num); + } + return 0; +} + +int printTNodeWithHome(TNode *p_tnode,int priority) { + if (priority == 0) printf("###"); + else printf("#"); + printf("TNode(id: %llu)\n", p_tnode->id); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("ifMalloc: "); + if (p_tnode->if_malloc) { + printf("YES\n"); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Value(type: %s): ", p_tnode->type); + if (!strcmp(p_tnode->type, "int")) { + printf("%d\n", *(int *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "double")) { + printf("%a\n", *(double *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "string")) { + printf("%s\n", (char *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "pointer")) { + printf("%p\n", (char *)(p_tnode->value)); + } + } + else printf("NO\n"); + + if (p_tnode->father != NULL) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Father id: %llu\n", p_tnode->father->id); + } + else + { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Father: NO\n"); + } + + if (p_tnode->child_num > 0) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Child(number: %llu):\n", p_tnode->child_num); + } + + List *p_home = p_tnode->home; + Node *p_node = p_home->head; + while (p_node != NULL) { + printTNode((TNode *)p_node->value,priority+2); + p_node = p_node->next; + } + return 0; +} + +int printTNodeWithFamily(TNode *p_tnode, int priority) { + for (int i = 0; i < priority ; i++) printf(" "); + if (priority == 0) printf("###"); + else printf("#"); + printf("TNode(id: %llu)\n", p_tnode->id); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("ifMalloc: "); + if (p_tnode->if_malloc) { + printf("YES\n"); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Value(type: %s): ", p_tnode->type); + if (!strcmp(p_tnode->type, "int")) { + printf("%d\n", *(int *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "double")) { + printf("%a\n", *(double *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "string")) { + printf("%s\n", (char *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "pointer")) { + printf("%p\n", (char *)(p_tnode->value)); + } + } + else printf("NO\n"); + + if (p_tnode->father != NULL) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Father id: %llu\n", p_tnode->father->id); + } + else + { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Father: NO\n"); + } + + if (p_tnode->child_num > 0) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Child(number: %llu):\n", p_tnode->child_num); + } + + List *p_home = p_tnode->home; + Node *p_node = p_home->head; + while (p_node != NULL) { + printTNodeWithFamily((TNode *)p_node->value, priority + 2); + p_node = p_node->next; + } + return 0; +} + +int printTree(Tree *p_tree) { + printf("###"); + printf("Tree(id: %llu)",p_tree->id); + printTNodeWithFamily(p_tree->root,0); + return 0; +} \ No newline at end of file diff --git a/tree/tree_expand.h b/tree/tree_expand.h new file mode 100644 index 0000000..d8d882a --- /dev/null +++ b/tree/tree_expand.h @@ -0,0 +1,21 @@ +#ifndef TREE_EXPAND_H +#define TREE_EXPAND_H + +#include "tree.h" + +TNode *tnodeWithInt(int); +TNode *tnodeWithDouble(double); +TNode *tnodeWithString(char *); +TNode *tnodeWithPointer(void *); + +int getValueByIntForTree(TNode *); +double getValueByDoubleForTree(TNode *); +char *getValueByStringForTree(TNode *); +void *getValueByPointerForTree(TNode *); + +int printTree(Tree *p_tree); +int printTNodeWithHome(TNode *p_tnode, int priority); +int printTNodeWithFamily(TNode *p_tnode, int priority); +int printTNode(TNode *p_tnode, int priority); + +#endif From 896e454c4076c0d9cbe9c7fe20ff2258536f4f2f Mon Sep 17 00:00:00 2001 From: Saturneric Date: Wed, 13 Jun 2018 16:15:25 +0800 Subject: [PATCH 34/55] debug --- list/list.c | Bin 20250 -> 20432 bytes list/list_expand.c | 48 ++++++++++++++++++++++++++------------------- test.c | 3 ++- tree/tree.c | 2 +- 4 files changed, 31 insertions(+), 22 deletions(-) diff --git a/list/list.c b/list/list.c index 5807c185967f5e568911ee5e02c9692e55d3834a..005cfa229c63b3a436d4f8b9f8cfb1de9a9d8e3b 100644 GIT binary patch delta 55 zcmbO=kMY8M#tnKJllNF~O!iQho17rcF*#3NX7WERi^)84DwDVA$xW8fmIJbRHtT4s LF>dbB>{A5*BVH0K delta 23 fcmcaGpK;ba#tnKJn^$SaF;3=D6WAQ2Ri_F7Zy^Xi diff --git a/list/list_expand.c b/list/list_expand.c index 3a756bc..32c20d7 100644 --- a/list/list_expand.c +++ b/list/list_expand.c @@ -140,19 +140,19 @@ void printNodeInfo(Node *p_node, int priority) { printf("NEXT->%p / LAST->%p / MALLOC:%d\n", p_node->next, p_node->last, p_node->if_malloc); if (!strcmp(p_node->type, "int")) { for (int i = 0; i < priority + 1; i++) printf(" "); - printf("VALUE(Int):%d\n", *(int *)(p_node->value)); + printf("VALUE(int):%d\n", *(int *)(p_node->value)); } else if (!strcmp(p_node->type, "double")) { for (int i = 0; i < priority + 1; i++) printf(" "); - printf("VALUE(Double):%a\n", *(double *)(p_node->value)); + printf("VALUE(double):%a\n", *(double *)(p_node->value)); } else if (!strcmp(p_node->type, "string")) { for (int i = 0; i < priority + 1; i++) printf(" "); - printf("VALUE(String):%s\n", (char *)(p_node->value)); + printf("VALUE(string):%s\n", (char *)(p_node->value)); } else if (!strcmp(p_node->type, "pointer")) { for (int i = 0; i < priority + 1; i++) printf(" "); - printf("VALUE(Pointer):%s\n", (char *)(p_node->value)); + printf("VALUE(pointer):%s\n", (char *)(p_node->value)); } else if (!strcmp(p_node->type, "list")) { for (int i = 0; i < priority + 1; i++) printf(" "); @@ -166,23 +166,31 @@ void printNodeInfo(Node *p_node, int priority) { void printNode(Node *p_node) { printf("#NODE(location:%p, id:%llu){\n", p_node, p_node->id); printf(" "); - printf("NEXT->%p / LAST->%p / MALLOC:%d\n", p_node->next, p_node->last, p_node->if_malloc); - printf(" "); - if (!strcmp(p_node->type, "int")) { - printf("%d", *(int *)(p_node->value)); - } - else if (!strcmp(p_node->type, "double")) { - printf("%a\n", *(double *)(p_node->value)); - } - else if (!strcmp(p_node->type, "string")) { - printf("%s\n", (char *)(p_node->value)); - } - else if (!strcmp(p_node->type, "pointer")) { - printf("%s\n", (char *)(p_node->value)); - } - else if (!strcmp(p_node->type, "list")) { - printList((List *)p_node->value); + printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last, p_node->if_malloc); + for (int i = 0; i < 1; i++) printf(" "); + printf("ifMalloc: "); + if (p_node->if_malloc) { + printf("YES\n"); + for (int i = 0; i < 1; i++) printf(" "); + printf("Value(type: %s): ", p_node->type); + if (!strcmp(p_node->type, "int")) { + printf("%d", *(int *)(p_node->value)); + } + else if (!strcmp(p_node->type, "double")) { + printf("%a\n", *(double *)(p_node->value)); + } + else if (!strcmp(p_node->type, "string")) { + printf("%s\n", (char *)(p_node->value)); + } + else if (!strcmp(p_node->type, "pointer")) { + printf("%s\n", (char *)(p_node->value)); + } + else if (!strcmp(p_node->type, "list")) { + printList((List *)p_node->value); + } } + else printf("NO\n"); + printf("}\n"); } diff --git a/test.c b/test.c index 14423f9..89b0134 100644 --- a/test.c +++ b/test.c @@ -47,8 +47,9 @@ int tree(void) { addChildInRight(cl_tnode, tnodeWithInt(5)); addChildInRight(cr_tnode, tnodeWithInt(6)); addChildInRight(cr_tnode, tnodeWithInt(7)); + + removeChildByIndex(cr_tnode, 1); printTNodeWithFamily(t_tnode, 0); - //removeChildByIndex(t_tnode, 0); releaseAllForTree(); return 0; } diff --git a/tree/tree.c b/tree/tree.c index 0d42a14..9c0c123 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -250,7 +250,7 @@ TNode *getChildByIndex(TNode *p_tnode, unsigned long long index) { List *p_home = p_tnode->home; Node *p_node = p_home->head; int m_index = 0; - if (index < p_tnode->child_num - 1) + if (index < p_tnode->child_num) { while (p_node != NULL && m_index < index) { m_index++; From 880fa14d10539cc0214c3cee782198c37bea1810 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Wed, 13 Jun 2018 16:32:39 +0800 Subject: [PATCH 35/55] =?UTF-8?q?=E6=B5=8B=E8=AF=95=E4=B8=8Edebug=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test.c | 16 +++- tree/tree.c | 6 +- tree/tree_expand.c | 226 +++++++++++++++++++++++---------------------- 3 files changed, 133 insertions(+), 115 deletions(-) diff --git a/test.c b/test.c index 89b0134..4eaf628 100644 --- a/test.c +++ b/test.c @@ -37,6 +37,12 @@ int list(void) { return 0; } +int _useTreeThroughDown(TNode *p_tnode, unsigned long long height) { + printTNode(p_tnode,0); + return 0; +} + + int tree(void) { safeModeForTree(1); Tree *t_tree = initTree(); @@ -44,12 +50,14 @@ int tree(void) { addChildInRight(t_tnode, cl_tnode); addChildInRight(t_tnode, cr_tnode); addChildInRight(cl_tnode, tnodeWithInt(4)); - addChildInRight(cl_tnode, tnodeWithInt(5)); + TNode *gs_tnode = tnodeWithInt(5); + addChildInRight(cl_tnode,gs_tnode); addChildInRight(cr_tnode, tnodeWithInt(6)); addChildInRight(cr_tnode, tnodeWithInt(7)); - - removeChildByIndex(cr_tnode, 1); - printTNodeWithFamily(t_tnode, 0); + addChildInRight(gs_tnode, tnodeWithInt(8)); + setRoot(t_tree, t_tnode); + TreeThroughUp(t_tree, _useTreeThroughDown); + //printTNodeWithFamily(t_tnode, 0); releaseAllForTree(); return 0; } diff --git a/tree/tree.c b/tree/tree.c index 9c0c123..1bd035e 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -107,7 +107,7 @@ int addChildInRight(TNode *f_tnode, TNode *c_tnode) { TNode *getBrotherInLeft(TNode *p_tnode) { List *p_home = p_tnode->father->home; - Node *p_node = p_home->head; + Node *p_node = p_tnode->room; unsigned long long index = getIndexByNode(p_home, p_node); if (index > 0) return (TNode *)(findByIndexForNode(p_home, index - 1)->value); return NULL; @@ -293,7 +293,6 @@ int removeChildByIndex(TNode *p_tnode, unsigned long long index) { int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { TNode *p_tnode = p_tree->root; if (p_tnode != NULL) { - func(p_tnode, 0); if (p_tnode->child_num > 0) { for (int i = 0; i < p_tnode->child_num; i++) { if (_doTreeThroughUp(getChildByIndex(p_tnode, i), 1, func) == -1) { @@ -301,6 +300,7 @@ int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) } } } + func(p_tnode, 0); } return 0; } @@ -320,8 +320,8 @@ int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned lo int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { TNode *p_tnode = p_tree->root; if (p_tree->root != NULL) { + func(p_tnode, 0); if (p_tree->root->child_num > 0) { - func(p_tnode, 0); for (int i = 0; i < p_tnode->child_num; i++) { if (_doTreeThroughDown(getChildByIndex(p_tnode, i), 1, func) == -1) { break; diff --git a/tree/tree_expand.c b/tree/tree_expand.c index 478929a..062934d 100644 --- a/tree/tree_expand.c +++ b/tree/tree_expand.c @@ -58,135 +58,145 @@ void *getValueByPointerForTree(TNode *p_tnode) { } int printTNode(TNode *p_tnode, int priority) { - for (int i = 0; i < priority; i++) printf(" "); - if (priority == 0) printf("###"); - else printf("#"); - printf("TNode(id: %llu)\n", p_tnode->id); - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("ifMalloc: "); - if (p_tnode->if_malloc) { - printf("YES\n"); + if (p_tnode != NULL) { + for (int i = 0; i < priority; i++) printf(" "); + if (priority == 0) printf("###"); + else printf("#"); + + printf("TNode(id: %llu)\n", p_tnode->id); for (int i = 0; i < priority + 1; i++) printf(" "); - printf("Value(type: %s): ", p_tnode->type); - if (!strcmp(p_tnode->type, "int")) { - printf("%d\n", *(int *)(p_tnode->value)); + printf("ifMalloc: "); + if (p_tnode->if_malloc) { + printf("YES\n"); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Value(type: %s): ", p_tnode->type); + if (!strcmp(p_tnode->type, "int")) { + printf("%d\n", *(int *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "double")) { + printf("%a\n", *(double *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "string")) { + printf("%s\n", (char *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "pointer")) { + printf("%p\n", (char *)(p_tnode->value)); + } } - else if (!strcmp(p_tnode->type, "double")) { - printf("%a\n", *(double *)(p_tnode->value)); - } - else if (!strcmp(p_tnode->type, "string")) { - printf("%s\n", (char *)(p_tnode->value)); - } - else if (!strcmp(p_tnode->type, "pointer")) { - printf("%p\n", (char *)(p_tnode->value)); + else printf("NO\n"); + + if (p_tnode->child_num > 0) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Child number: %llu\n", p_tnode->child_num); } + return 0; } - else printf("NO\n"); - - if (p_tnode->child_num > 0) { - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("Child number: %llu\n", p_tnode->child_num); - } - return 0; + return -1; } int printTNodeWithHome(TNode *p_tnode,int priority) { - if (priority == 0) printf("###"); - else printf("#"); - printf("TNode(id: %llu)\n", p_tnode->id); - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("ifMalloc: "); - if (p_tnode->if_malloc) { - printf("YES\n"); + if (p_tnode != NULL) { + if (priority == 0) printf("###"); + else printf("#"); + printf("TNode(id: %llu)\n", p_tnode->id); for (int i = 0; i < priority + 1; i++) printf(" "); - printf("Value(type: %s): ", p_tnode->type); - if (!strcmp(p_tnode->type, "int")) { - printf("%d\n", *(int *)(p_tnode->value)); + printf("ifMalloc: "); + if (p_tnode->if_malloc) { + printf("YES\n"); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Value(type: %s): ", p_tnode->type); + if (!strcmp(p_tnode->type, "int")) { + printf("%d\n", *(int *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "double")) { + printf("%a\n", *(double *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "string")) { + printf("%s\n", (char *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "pointer")) { + printf("%p\n", (char *)(p_tnode->value)); + } } - else if (!strcmp(p_tnode->type, "double")) { - printf("%a\n", *(double *)(p_tnode->value)); - } - else if (!strcmp(p_tnode->type, "string")) { - printf("%s\n", (char *)(p_tnode->value)); - } - else if (!strcmp(p_tnode->type, "pointer")) { - printf("%p\n", (char *)(p_tnode->value)); - } - } - else printf("NO\n"); + else printf("NO\n"); - if (p_tnode->father != NULL) { - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("Father id: %llu\n", p_tnode->father->id); - } - else - { - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("Father: NO\n"); - } - - if (p_tnode->child_num > 0) { - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("Child(number: %llu):\n", p_tnode->child_num); - } + if (p_tnode->father != NULL) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Father id: %llu\n", p_tnode->father->id); + } + else + { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Father: NO\n"); + } - List *p_home = p_tnode->home; - Node *p_node = p_home->head; - while (p_node != NULL) { - printTNode((TNode *)p_node->value,priority+2); - p_node = p_node->next; + if (p_tnode->child_num > 0) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Child(number: %llu):\n", p_tnode->child_num); + } + + List *p_home = p_tnode->home; + Node *p_node = p_home->head; + while (p_node != NULL) { + printTNode((TNode *)p_node->value, priority + 2); + p_node = p_node->next; + } + return 0; } - return 0; + return -1; } int printTNodeWithFamily(TNode *p_tnode, int priority) { - for (int i = 0; i < priority ; i++) printf(" "); - if (priority == 0) printf("###"); - else printf("#"); - printf("TNode(id: %llu)\n", p_tnode->id); - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("ifMalloc: "); - if (p_tnode->if_malloc) { - printf("YES\n"); + if (p_tnode != NULL) { + for (int i = 0; i < priority; i++) printf(" "); + if (priority == 0) printf("###"); + else printf("#"); + printf("TNode(id: %llu)\n", p_tnode->id); for (int i = 0; i < priority + 1; i++) printf(" "); - printf("Value(type: %s): ", p_tnode->type); - if (!strcmp(p_tnode->type, "int")) { - printf("%d\n", *(int *)(p_tnode->value)); + printf("ifMalloc: "); + if (p_tnode->if_malloc) { + printf("YES\n"); + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Value(type: %s): ", p_tnode->type); + if (!strcmp(p_tnode->type, "int")) { + printf("%d\n", *(int *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "double")) { + printf("%a\n", *(double *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "string")) { + printf("%s\n", (char *)(p_tnode->value)); + } + else if (!strcmp(p_tnode->type, "pointer")) { + printf("%p\n", (char *)(p_tnode->value)); + } } - else if (!strcmp(p_tnode->type, "double")) { - printf("%a\n", *(double *)(p_tnode->value)); - } - else if (!strcmp(p_tnode->type, "string")) { - printf("%s\n", (char *)(p_tnode->value)); - } - else if (!strcmp(p_tnode->type, "pointer")) { - printf("%p\n", (char *)(p_tnode->value)); - } - } - else printf("NO\n"); + else printf("NO\n"); - if (p_tnode->father != NULL) { - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("Father id: %llu\n", p_tnode->father->id); - } - else - { - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("Father: NO\n"); - } + if (p_tnode->father != NULL) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Father id: %llu\n", p_tnode->father->id); + } + else + { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Father: NO\n"); + } - if (p_tnode->child_num > 0) { - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("Child(number: %llu):\n", p_tnode->child_num); - } + if (p_tnode->child_num > 0) { + for (int i = 0; i < priority + 1; i++) printf(" "); + printf("Child(number: %llu):\n", p_tnode->child_num); + } - List *p_home = p_tnode->home; - Node *p_node = p_home->head; - while (p_node != NULL) { - printTNodeWithFamily((TNode *)p_node->value, priority + 2); - p_node = p_node->next; + List *p_home = p_tnode->home; + Node *p_node = p_home->head; + while (p_node != NULL) { + printTNodeWithFamily((TNode *)p_node->value, priority + 2); + p_node = p_node->next; + } + return 0; } - return 0; + return -1; } int printTree(Tree *p_tree) { From 79b529a84147bf5633bb489d62c52bda75d644a4 Mon Sep 17 00:00:00 2001 From: Saturneric Date: Wed, 18 Jul 2018 11:53:09 +0800 Subject: [PATCH 36/55] Change code to meet the need of the tools which not support C99. --- list/list.c | Bin 20432 -> 20522 bytes list/list.h | Bin 3888 -> 3892 bytes list/list_expand.c | 75 +++++++++++++++++++++++++++------------------ test.c | 24 ++++++++++----- tree/tree.c | 39 ++++++++++++++--------- tree/tree_expand.c | 45 +++++++++++++++------------ 6 files changed, 111 insertions(+), 72 deletions(-) diff --git a/list/list.c b/list/list.c index 005cfa229c63b3a436d4f8b9f8cfb1de9a9d8e3b..1d99126d208d1cb974a160368e83e7badac35619 100644 GIT binary patch delta 127 zcmcaGpK;X!#tmwGlPfs*CQslOn;appwb_BsiE(ou|2)RYI>vmH1z5Qz&y(VqtfU~Z z*+npqadMTC(B=z55zO3~40#MC3jr<(X{6C$ae)e;ecG62UfzNP-~Ghead; - for (unsigned long long i = 0; i < m_index; i++) { + unsigned long long i; + for (i = 0; i < m_index; i++) { p_node = p_node->next; } return p_node; @@ -86,28 +90,29 @@ void *getByPointerForNode(Node *p_node) { } void printListInfo(List *p_list, int priority) { - for (int i = 0; i < priority; i++) printf(" "); - printf("###LIST(location:%p, id:%llu){\n", p_list, p_list->id); - for (int i = 0; i < priority + 1; i++) printf(" "); - printf("HEAD->%p / Tail->%p / Length:%llu\n", p_list->head, p_list->tail, p_list->length); - Node *p_node = p_list->head; int i = 0; + Node *p_node; + for (i = 0; i < priority; i++) printf(" "); + printf("###LIST(location:%p, id:%llu){\n", p_list, p_list->id); + for (i = 0; i < priority + 1; i++) printf(" "); + printf("HEAD->%p / Tail->%p / Length:%llu\n", p_list->head, p_list->tail, p_list->length); + p_node = p_list->head; while (p_node != NULL) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("%d.... \n", i); printNodeInfo(p_node, priority + 1); p_node = p_node->next; i++; } - for (int i = 0; i < priority; i++) printf(" "); + for (i = 0; i < priority; i++) printf(" "); printf("}\n"); } void printList(List *p_list) { + int if_nearLast = 0; Node *p_node = p_list->head; printf("["); - int if_nearLast = 0; while (p_node != NULL) { if (!if_nearLast && p_node->next == NULL) if_nearLast = 1; if (!strcmp(p_node->type, "int")) { @@ -134,44 +139,46 @@ void printList(List *p_list) { } void printNodeInfo(Node *p_node, int priority) { - for (int i = 0; i < priority; i++) printf(" "); + int i; + for (i = 0; i < priority; i++) printf(" "); printf("#NODE(location:%p, id:%llu){\n", p_node, p_node->id); - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("NEXT->%p / LAST->%p / MALLOC:%d\n", p_node->next, p_node->last, p_node->if_malloc); if (!strcmp(p_node->type, "int")) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("VALUE(int):%d\n", *(int *)(p_node->value)); } else if (!strcmp(p_node->type, "double")) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("VALUE(double):%a\n", *(double *)(p_node->value)); } else if (!strcmp(p_node->type, "string")) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("VALUE(string):%s\n", (char *)(p_node->value)); } else if (!strcmp(p_node->type, "pointer")) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("VALUE(pointer):%s\n", (char *)(p_node->value)); } else if (!strcmp(p_node->type, "list")) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("VALUE(List):\n"); printListInfo((List *)p_node->value, priority + 2); } - for (int i = 0; i < priority; i++) printf(" "); + for (i = 0; i < priority; i++) printf(" "); printf("}\n"); } void printNode(Node *p_node) { + int i; printf("#NODE(location:%p, id:%llu){\n", p_node, p_node->id); printf(" "); printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last, p_node->if_malloc); - for (int i = 0; i < 1; i++) printf(" "); + for (i = 0; i < 1; i++) printf(" "); printf("ifMalloc: "); if (p_node->if_malloc) { printf("YES\n"); - for (int i = 0; i < 1; i++) printf(" "); + for (i = 0; i < 1; i++) printf(" "); printf("Value(type: %s): ", p_node->type); if (!strcmp(p_node->type, "int")) { printf("%d", *(int *)(p_node->value)); @@ -196,25 +203,28 @@ void printNode(Node *p_node) { Node *findByIntForNode(List *p_list, int target) { + Node *t_node; int *p_target = (int *)malloc(sizeof(int)); *p_target = target; - Node *t_node = findByValue(p_list, "int", p_target); + t_node = findByValue(p_list, "int", p_target); free(p_target); return t_node; } Node *findByDoubleForNode(List *p_list, double target) { + Node *t_node; double *p_target = (double *)malloc(sizeof(double)); *p_target = target; - Node *t_node = findByValue(p_list, "double", p_target); + t_node = findByValue(p_list, "double", p_target); free(p_target); return t_node; } Node *findByStringForNode(List *p_list, char *target) { + Node *t_node; char *p_temp = (char *)malloc(sizeof(char)*(strlen(target) + 1)); strcpy_s(p_temp, sizeof(p_temp), target); - Node *t_node = findByValue(p_list, "string", p_temp); + t_node = findByValue(p_list, "string", p_temp); free(p_temp); return t_node; } @@ -225,9 +235,11 @@ Node *findByPointerForNode(List *p_list, void *target) { } int addValueForComplex(Node * p_node, char *type, void *value) { + List *c_list; + Node *c_node; if (!strcmp(p_node->type, "list")) { - List *c_list = (List *)p_node->value; - Node *c_node = initNode(); + c_list = (List *)p_node->value; + c_node = initNode(); initMallocValueForNode(c_node, type, value); insertInTail(c_list, c_node); return 0; @@ -275,24 +287,27 @@ int addPointerForComplex(Node *p_node, void *temp) { List *m_findByInt(List* p_list, int temp) { int *p_temp = (int *)malloc(sizeof(int)); + List *t_list; *p_temp = temp; - List *t_list = mply_findByValue(p_list, "int", (void *)p_temp); + t_list = mply_findByValue(p_list, "int", (void *)p_temp); free(p_temp); return t_list; } List *m_findByDouble(List* p_list, double temp) { + List *t_list; double *p_temp = (double *)malloc(sizeof(double)); *p_temp = temp; - List *t_list = mply_findByValue(p_list, "double", (void *)p_temp); + t_list = mply_findByValue(p_list, "double", (void *)p_temp); free(p_temp); return t_list; } List *m_findByString(List* p_list, char *temp) { + List *t_list; char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1)); strcpy_s(p_temp, sizeof(p_temp), temp); - List *t_list = mply_findByValue(p_list, "string", (void *)p_temp); + t_list = mply_findByValue(p_list, "string", (void *)p_temp); free(p_temp); return t_list; } diff --git a/test.c b/test.c index 4eaf628..5347f93 100644 --- a/test.c +++ b/test.c @@ -2,9 +2,11 @@ int list(void) { + int i; + List *t_list, *m_list;; init_rand(); safeModeForNode(1); - List *t_list = initList(); + t_list = initList(); /*for(int i = 0; i < 9; i++){ Node *t_node = initNode(); @@ -18,7 +20,7 @@ int list(void) { insertInTail(t_list,t_node); initMalllocValue(t_node,(void *)"there");*/ - for (int i = 0; i < 12; i++) { + for (i = 0; i < 12; i++) { insertInHead(t_list, nodeWithInt(i)); insertInTail(t_list, nodeWithInt(i)); } @@ -27,7 +29,7 @@ int list(void) { printListInfo(t_list, 0); printList(t_list); - List *m_list; + m_list = m_findByIntForNode(t_list, 5); printList(m_list); printf("\n"); @@ -44,13 +46,18 @@ int _useTreeThroughDown(TNode *p_tnode, unsigned long long height) { int tree(void) { + TNode *t_tnode, *cr_tnode, *cl_tnode; + Tree *t_tree; + TNode *gs_tnode; safeModeForTree(1); - Tree *t_tree = initTree(); - TNode *t_tnode = tnodeWithInt(1), *cr_tnode = tnodeWithInt(3),*cl_tnode = tnodeWithInt(2); + t_tree = initTree(); + t_tnode = tnodeWithInt(1); + cr_tnode = tnodeWithInt(3); + cl_tnode = tnodeWithInt(2); addChildInRight(t_tnode, cl_tnode); addChildInRight(t_tnode, cr_tnode); addChildInRight(cl_tnode, tnodeWithInt(4)); - TNode *gs_tnode = tnodeWithInt(5); + gs_tnode = tnodeWithInt(5); addChildInRight(cl_tnode,gs_tnode); addChildInRight(cr_tnode, tnodeWithInt(6)); addChildInRight(cr_tnode, tnodeWithInt(7)); @@ -63,11 +70,12 @@ int tree(void) { } int stack(void) { + int i; Stack *t_stack = initStack(); - for (int i = 0; i < 10; i++) { + for (i = 0; i < 10; i++) { pushStack(t_stack, snodeWithInt(i)); } - for (int i = 0; i < 10; i++) { + for (i = 0; i < 10; i++) { printf("%d", getValueByIntForSNode(popStack(t_stack))); } releaseStack(t_stack); diff --git a/tree/tree.c b/tree/tree.c index 1bd035e..6b15c5a 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -29,6 +29,7 @@ int safeModeForTree(int ifon) { } TNode *initTNode(void) { + Node *s_node; TNode *p_tnode = (TNode *)malloc(sizeof(TNode)); p_tnode->id = getId(); p_tnode->child_num = 0; @@ -41,14 +42,14 @@ TNode *initTNode(void) { if (if_safeModeForTree) { if (if_safeModeForNode) { if_safeModeForNode = 0; - Node *s_node = initNode(); + s_node = initNode(); initMallocValueForNode(s_node, "pointer", (void *)p_tnode); insertInTail(tnode_list, s_node); if_safeModeForNode = 1; } else { - Node *s_node = initNode(); + s_node = initNode(); initMallocValueForNode(s_node, "pointer", (void *)p_tnode); insertInTail(tnode_list, s_node); } @@ -57,20 +58,21 @@ TNode *initTNode(void) { } Tree *initTree(void) { + Node *s_node; Tree *p_tree = (Tree *)malloc(sizeof(Tree)); p_tree->id = getId(); p_tree->root = NULL; if (if_safeModeForTree) { if (if_safeModeForNode) { if_safeModeForNode = 0; - Node *s_node = initNode(); + s_node = initNode(); initMallocValueForNode(s_node, "pointer", (void *)p_tree); if_safeModeForNode = 1; insertInTail(tree_list, s_node); } else { - Node *s_node = initNode(); + s_node = initNode(); initMallocValueForNode(s_node, "pointer", (void *)p_tree); insertInTail(tree_list, s_node); } @@ -184,14 +186,14 @@ TNode *getChildByValue(TNode *p_tnode, char *type, void *value) { int _dogetChildByValue(const char *type, void *value) { if (!strcmp(type, target_type)) { TNode *p_tode = (TNode *)value; - if (!strcmp(target_value, "int")) { + if (!strcmp((char *)target_value, "int")) { if (*(int *)p_tode->value == *(int *)target_value) { target_value_value = p_tode; return -1; } } - else if (!strcmp(target_value, "double")) + else if (!strcmp((char *)target_value, "double")) { if (*(double *)p_tode->value == *(double *)target_value) { @@ -199,7 +201,7 @@ int _dogetChildByValue(const char *type, void *value) { return -1; } } - else if (!strcmp(target_value, "string")) + else if (!strcmp((char *)target_value, "string")) { if (!strcmp((char *)p_tode->value, (char *)target_value)) { @@ -207,7 +209,7 @@ int _dogetChildByValue(const char *type, void *value) { return -1; } } - else if (!strcmp(target_value, "pointer")) + else if (!strcmp((char *)target_value, "pointer")) { if (p_tode->value == target_value) { @@ -291,10 +293,11 @@ int removeChildByIndex(TNode *p_tnode, unsigned long long index) { int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { + int i; TNode *p_tnode = p_tree->root; if (p_tnode != NULL) { if (p_tnode->child_num > 0) { - for (int i = 0; i < p_tnode->child_num; i++) { + for (i = 0; i < p_tnode->child_num; i++) { if (_doTreeThroughUp(getChildByIndex(p_tnode, i), 1, func) == -1) { break; } @@ -306,23 +309,26 @@ int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) } int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) { + int i, func_back; + if (p_tnode->child_num > 0) { - for (int i = 0; i < p_tnode->child_num; i++) { + for (i = 0; i < p_tnode->child_num; i++) { if (_doTreeThroughUp(getChildByIndex(p_tnode, i), height + 1, func)) return -1; } } - int func_back = func(p_tnode, height); + func_back = func(p_tnode, height); if (func_back == -1)return -1; return 0; } int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height)) { + int i; TNode *p_tnode = p_tree->root; if (p_tree->root != NULL) { func(p_tnode, 0); if (p_tree->root->child_num > 0) { - for (int i = 0; i < p_tnode->child_num; i++) { + for (i = 0; i < p_tnode->child_num; i++) { if (_doTreeThroughDown(getChildByIndex(p_tnode, i), 1, func) == -1) { break; } @@ -333,9 +339,10 @@ int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height) } int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)) { + int i; int func_back = func(p_tnode, height); if (p_tnode->child_num > 0) { - for (int i = 0; i < p_tnode->child_num; i++) { + for (i = 0; i < p_tnode->child_num; i++) { if (_doTreeThroughDown(getChildByIndex(p_tnode, i), height + 1, func)) return -1; } } @@ -427,9 +434,11 @@ int releaseOnlyTNode(TNode *p_tnode) { } int releaseAllForTree(void) { + Node *p_node; + Tree *p_tree; if (if_safeModeForTree) { if_safeModeForTree = 0; - Node *p_node = tnode_list->head; + p_node = tnode_list->head; while (p_node != NULL) { TNode *p_tnode = (TNode *)p_node->value; releaseOnlyTNode(p_tnode); @@ -437,7 +446,7 @@ int releaseAllForTree(void) { } p_node = tree_list->head; while (p_node != NULL) { - Tree *p_tree = (Tree *)p_node->value; + p_tree = (Tree *)p_node->value; releaseOnlyTree(p_tree); p_node = p_node->next; } diff --git a/tree/tree_expand.c b/tree/tree_expand.c index 062934d..353526a 100644 --- a/tree/tree_expand.c +++ b/tree/tree_expand.c @@ -58,17 +58,18 @@ void *getValueByPointerForTree(TNode *p_tnode) { } int printTNode(TNode *p_tnode, int priority) { + int i; if (p_tnode != NULL) { - for (int i = 0; i < priority; i++) printf(" "); + for (i = 0; i < priority; i++) printf(" "); if (priority == 0) printf("###"); else printf("#"); printf("TNode(id: %llu)\n", p_tnode->id); - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("ifMalloc: "); if (p_tnode->if_malloc) { printf("YES\n"); - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("Value(type: %s): ", p_tnode->type); if (!strcmp(p_tnode->type, "int")) { printf("%d\n", *(int *)(p_tnode->value)); @@ -86,7 +87,7 @@ int printTNode(TNode *p_tnode, int priority) { else printf("NO\n"); if (p_tnode->child_num > 0) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("Child number: %llu\n", p_tnode->child_num); } return 0; @@ -95,15 +96,18 @@ int printTNode(TNode *p_tnode, int priority) { } int printTNodeWithHome(TNode *p_tnode,int priority) { + int i; + List *p_home; + Node *p_node; if (p_tnode != NULL) { if (priority == 0) printf("###"); else printf("#"); printf("TNode(id: %llu)\n", p_tnode->id); - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("ifMalloc: "); if (p_tnode->if_malloc) { printf("YES\n"); - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("Value(type: %s): ", p_tnode->type); if (!strcmp(p_tnode->type, "int")) { printf("%d\n", *(int *)(p_tnode->value)); @@ -121,22 +125,22 @@ int printTNodeWithHome(TNode *p_tnode,int priority) { else printf("NO\n"); if (p_tnode->father != NULL) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("Father id: %llu\n", p_tnode->father->id); } else { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("Father: NO\n"); } if (p_tnode->child_num > 0) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("Child(number: %llu):\n", p_tnode->child_num); } - List *p_home = p_tnode->home; - Node *p_node = p_home->head; + p_home = p_tnode->home; + p_node = p_home->head; while (p_node != NULL) { printTNode((TNode *)p_node->value, priority + 2); p_node = p_node->next; @@ -147,16 +151,19 @@ int printTNodeWithHome(TNode *p_tnode,int priority) { } int printTNodeWithFamily(TNode *p_tnode, int priority) { + int i; + List *p_home; + Node *p_node; if (p_tnode != NULL) { - for (int i = 0; i < priority; i++) printf(" "); + for (i = 0; i < priority; i++) printf(" "); if (priority == 0) printf("###"); else printf("#"); printf("TNode(id: %llu)\n", p_tnode->id); - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("ifMalloc: "); if (p_tnode->if_malloc) { printf("YES\n"); - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("Value(type: %s): ", p_tnode->type); if (!strcmp(p_tnode->type, "int")) { printf("%d\n", *(int *)(p_tnode->value)); @@ -174,22 +181,22 @@ int printTNodeWithFamily(TNode *p_tnode, int priority) { else printf("NO\n"); if (p_tnode->father != NULL) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("Father id: %llu\n", p_tnode->father->id); } else { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("Father: NO\n"); } if (p_tnode->child_num > 0) { - for (int i = 0; i < priority + 1; i++) printf(" "); + for (i = 0; i < priority + 1; i++) printf(" "); printf("Child(number: %llu):\n", p_tnode->child_num); } - List *p_home = p_tnode->home; - Node *p_node = p_home->head; + p_home = p_tnode->home; + p_node = p_home->head; while (p_node != NULL) { printTNodeWithFamily((TNode *)p_node->value, priority + 2); p_node = p_node->next; From a3f202d1c4dd864e50a92af012d3b430354361ed Mon Sep 17 00:00:00 2001 From: Saturneric Date: Wed, 18 Jul 2018 11:59:55 +0800 Subject: [PATCH 37/55] Fix. --- list/list.c | Bin 20522 -> 20542 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/list/list.c b/list/list.c index 1d99126d208d1cb974a160368e83e7badac35619..89448fed414f7ed84d016ce8dc180dc901b2ac83 100644 GIT binary patch delta 33 pcmZ3rfN|df#tlI}lR3O3Cg%u>Y>xBsVq`3tyx!S*^9NrmCIHoi3?l#l delta 39 vcmdnDfN|9V#tlI}n~QwH7$=)4@=Z?g;hL=A#WwkXv)1H0!cv>%{1lh~DX Date: Wed, 18 Jul 2018 12:44:13 +0800 Subject: [PATCH 38/55] Fixed. --- graph/graph.c | 1 + graph/graph.h | 24 ++++++++++++++++++++++++ list/list.c | Bin 20542 -> 20546 bytes list/list.h | Bin 3892 -> 3934 bytes tree/tree.h | 29 ++++++++++++++--------------- 5 files changed, 39 insertions(+), 15 deletions(-) create mode 100644 graph/graph.c create mode 100644 graph/graph.h diff --git a/graph/graph.c b/graph/graph.c new file mode 100644 index 0000000..e43cd57 --- /dev/null +++ b/graph/graph.c @@ -0,0 +1 @@ +#include "graph.h" \ No newline at end of file diff --git a/graph/graph.h b/graph/graph.h new file mode 100644 index 0000000..6a092c6 --- /dev/null +++ b/graph/graph.h @@ -0,0 +1,24 @@ +#ifndef GRAPH_H +#define GRAPH_H + +#include "../list/list_expand.h" + +typedef struct GNode{ + unsigned long long id; + void *value; + List *routes; + int if_setValue; +}GNode; + +typedef struct route{ + unsigned long long id; + double distance; + int if_setValue; + GNode from, to; +}Route; + +GNode *initGNode(void); +Route *initRoute(void); + + +#endif \ No newline at end of file diff --git a/list/list.c b/list/list.c index 89448fed414f7ed84d016ce8dc180dc901b2ac83..96a722a730d176cd9a70b8874d2419ba5730f28f 100644 GIT binary patch delta 13 VcmdnDfbq}*#tn7>lOIU3001j+1(5&% delta 9 QcmX@KfN|df#tn7>02WpR0RR91 diff --git a/list/list.h b/list/list.h index bc8f2f670b9b4de6453bd63f72ab0553bfe6a732..6c0e250de764b32d1c2c9f5f3c26bee99c66b12a 100644 GIT binary patch delta 61 pcmdlYcTa9Z86R&kLkUA75N9$ZGbl_h Date: Sat, 21 Jul 2018 18:39:09 +0800 Subject: [PATCH 39/55] Add. --- tree/tree.c | 9 +++++++++ tree/tree.h | 14 ++++++++++++++ 2 files changed, 23 insertions(+) create mode 100644 tree/tree.c create mode 100644 tree/tree.h diff --git a/tree/tree.c b/tree/tree.c new file mode 100644 index 0000000..28b903e --- /dev/null +++ b/tree/tree.c @@ -0,0 +1,9 @@ +// +// tree.c +// ZE-Standard-Libraries +// +// Created by 胡一兵 on 2018/6/11. +// Copyright © 2018年 ZE. All rights reserved. +// + +#include "tree.h" diff --git a/tree/tree.h b/tree/tree.h new file mode 100644 index 0000000..f1f866b --- /dev/null +++ b/tree/tree.h @@ -0,0 +1,14 @@ +// +// tree.h +// ZE-Standard-Libraries +// +// Created by 胡一兵 on 2018/6/11. +// Copyright © 2018年 ZE. All rights reserved. +// + +#ifndef tree_h +#define tree_h + +#include + +#endif /* tree_h */ From 6aa9b8d7084dd51f3f308c31c3db78242063432c Mon Sep 17 00:00:00 2001 From: Saturneic Date: Mon, 23 Jul 2018 12:59:16 +0800 Subject: [PATCH 40/55] Fix type type. --- graph/graph.h | 2 +- list/list.c | Bin 20546 -> 11900 bytes list/list.h | Bin 3934 -> 2325 bytes list/list_expand.c | 110 +++++++++++++++++++++---------------------- list/list_expand.h | Bin 3374 -> 2366 bytes stack/stack.c | Bin 2886 -> 1531 bytes stack/stack.h | Bin 1276 -> 624 bytes stack/stack_expand.c | 20 ++++---- stack/stack_expand.h | Bin 838 -> 401 bytes test.c | 5 +- test.h | 3 +- tree/tree.c | 61 ++++++++++++------------ tree/tree.h | 39 ++++++--------- tree/tree_expand.c | 50 ++++++++++---------- type/type.h | 21 +++++++++ 15 files changed, 159 insertions(+), 152 deletions(-) create mode 100644 type/type.h diff --git a/graph/graph.h b/graph/graph.h index 6a092c6..c1db03d 100644 --- a/graph/graph.h +++ b/graph/graph.h @@ -21,4 +21,4 @@ GNode *initGNode(void); Route *initRoute(void); -#endif \ No newline at end of file +#endif diff --git a/list/list.c b/list/list.c index 96a722a730d176cd9a70b8874d2419ba5730f28f..4afc44ddc7724056f9864a0058b01ed0a9d5fa7c 100644 GIT binary patch literal 11900 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 diff --git a/list/list.h b/list/list.h index 6c0e250de764b32d1c2c9f5f3c26bee99c66b12a..defec7f3c1a35e30cc958ec588c36079031c4a59 100644 GIT binary patch literal 2325 zcmbVNQEwVY5PrX3af)9Ygy08IRcfV1vE;N5iTaAJ+yW~ddx$$*K~*K>6oZ2uqSlV6 zYqxcZ9n!|eZB^IC*#0x@9rx6~(3zb(!~v?(`T^h0?#wsy?KiVaJTFX^*H>2_KgmAS zmf)KU7A>_UE^^kI$@C8#*W`Ap_+i{+@h@g=6)p;Ko6AcqX1SM2rQK?osh?Ewo~Gdn z({S9%TF%u!wN3V=ro-QwaCkv5Q@3nUpdW5#(rLNdA6?eGpBm%-rvL6lon5!NsVCMA zYmH@;feTmX`E1FsEIS8Iv#XUEt`k(O-pXSlC|N)1(TVah7EuJ zYyY=v`9n*cm`YJk2=>$^teDv{958>S>d0tw<*jnZ{qN-=DSD#F43iLP?Hb&o^#ZCa zCJJs5Y6-r*9Ut|Ay*oKLfxIvQ$P4*#j68b;kssI<47g03+2THue6}U)J+F5phi(7p zY;M6i%hOKq>}E9FAHV)JXgv3JZ&l<9vzXzq$Djv`AtFG` zqM=z&l(QE6M?`YRl`_r8!5rT^j)22+aXzxFs8$rrY@OagO}>0FK7Z!#_OQIhjkkBM zX_P1z+{LeD^3>=G(5ko#ttx9YK2pN_90eIcl1CC)PLf;^fBa`_G-!e%WpgvA?+~R3 zUK{>B+?H1tpmQKR6rq+*cn5GXe{ge>U?Q!laEO|%7{ZJ)Tp)@9b5|z&7_9w`tRGXM z5Jw3>IIQBXh=(AyWh$NSD5)fkH-_Ba&%{nY0V)3bX+Rqdy57#~7#e$;D;lD}R_&bO za$77DNraK4g&P4v2-)3{&5KD0I*_x=Rs0H_AvHMZzqt;+>rPH$X%$wo*V)Hapden@ z0;W(Mp#;fE0mR)1J;q1bEwkX+(j%PFtg|X;LRtQoI__s@WA5h}=6oelI+#q*S)5St{~>fXeR)quk-=u6q|2emD)^_JcgnqEMZw^f4{MY`%2#2dpQ<0;~f&X?8 z4n*ua+?w}NJxa>KPNazydr*L#b|+}GVdgk4G=5I$1>WnKM~f(NNFm@Ir0$ f;Psh)kLVs#aUTmj)kCn@htf=G+7c5c&ujkxibn9T literal 3934 zcmc&%QEMYr6h0tWqHg!ihk_8PEVXpEZ^F8vsNkZwO_Qe8ma+{^GMPlCvms5#?N%!+ zBUGwv3+gWr5k&CSKj4BsEcmo9KJJ4cD*L+ZuHQE|Cv%g|B#{*)gqhrX?svZPopaB< zdHiTvno<{EYU1FTl`HbLlw?K9@|K*DXJooN(}azaFmG%)TNO`sBkQc>WJfx9Z^|{f zAPrgQVx`%6u&j(>*@m4j?g+~cthT{6_Dq%?*^?GVHBvHcgK-tltmMIzGy4(K490!L z(1b6>U4w-O3;MR-nwYsH^ZcwzexmWy(Yby4%18if&Sqs6?^}^J4s6XVqo7x6Uj|ps z6TjL;`{8J{JYPSza{ua`gBO;6S%1EiE0~qlhy}T4Vco#WcH~2&Giyo1-JH~e%c*-r^(t|h78q1I1S5-43^u(`nNmlv_q9)3IWSa#FKToQ+GGRmwM6?xU z#>8&VbuiO})*9`2emx*E_Z?sxg&%#qUB_YaI%4ro zWkC0;#;3}QJGt`IXEVED@UYm5lxB>!I#jp`Wpr$&x9^EXYmJv$sqX>K zyTiND`))!NDJK2Qp);_On6v&aG1ucqJB|09&kytWuRguJc*5EWgIwXc$HC@AW3sOO zgS_UkBIE89+0~39vl!!y>c@U&^eCgkxA0z*(=m>><6Okp!C91qplp7vIz?tidCE&s#vge?atstx3@79%OG7WtNk+P#a8M?;wb-q$fiithi^n31U z2a)i!*g}LnV|{o}<3HCo(@BU-eVW!d&^BeJ4eI6-x+-=AuvNDuaEU)e~i9Xr%E zkODm40Gi3K?w+Kqj8`qJN#&5{D`q~-pIRvwA8gsR2hm%R9+y#L*AUU@3LCzDbPefx zDmEiZ14mdrl;MB#^bHIB)6&K+qd}p zo_kRFGni&~;NBz> zzj{~Dn^YLwE!{cMbDH-Ob8=O&|Fp8qf1%-bQ*)>4U#~35-0ybl_%3(}9+;zV3u_yC ggJxY{htype = "list"; + p_node->type = LIST; p_node->value = initList(); p_node->if_malloc = 1; return p_node; @@ -50,7 +50,7 @@ Node *findByIndexForNode(List *p_list, unsigned long long m_index) { return p_node; } -int listThrough(List *p_list, int(*p_func)(const char *, void *)) { +int listThrough(List *p_list, int(*p_func)(int, void *)) { Node *p_node = p_list->head; while (p_node != NULL) { if (p_node->if_malloc == 1) { @@ -70,22 +70,22 @@ int listThrough(List *p_list, int(*p_func)(const char *, void *)) { } int getByIntForNode(Node *p_node) { - if (!strcmp(p_node->type, "int")) return *(int *)(p_node->value); + if (p_node->type == INT) return *(int *)(p_node->value); else return -1; } char *getByStringForNode(Node *p_node) { - if (!strcmp(p_node->type, "string")) return (char *)(p_node->value); + if (p_node->type == STRING) return (char *)(p_node->value); else return NULL; } double getByDoubleForNode(Node *p_node) { - if (!strcmp(p_node->type, "double")) return *(double *)(p_node->value); + if (p_node->type == DOUBLE) return *(double *)(p_node->value); else return -1; } void *getByPointerForNode(Node *p_node) { - if (!strcmp(p_node->type, "pointer")) return (void *)(p_node->value); + if (p_node->type == POINTER) return (void *)(p_node->value); else return NULL; } @@ -115,19 +115,19 @@ void printList(List *p_list) { printf("["); while (p_node != NULL) { if (!if_nearLast && p_node->next == NULL) if_nearLast = 1; - if (!strcmp(p_node->type, "int")) { + if (p_node->type == INT) { printf("%d", *(int *)(p_node->value)); } - else if (!strcmp(p_node->type, "double")) { + else if (p_node->type == DOUBLE) { printf("%a", *(double *)(p_node->value)); } - else if (!strcmp(p_node->type, "string")) { + else if (p_node->type == STRING) { printf("%s", (char *)(p_node->value)); } - else if (!strcmp(p_node->type, "pointer")) { + else if (p_node->type == POINTER) { printf("%p", (char *)(p_node->value)); } - else if (!strcmp(p_node->type, "list")) { + else if (p_node->type == LIST) { printList((List *)p_node->value); } if (!if_nearLast) { @@ -144,23 +144,23 @@ void printNodeInfo(Node *p_node, int priority) { printf("#NODE(location:%p, id:%llu){\n", p_node, p_node->id); for (i = 0; i < priority + 1; i++) printf(" "); printf("NEXT->%p / LAST->%p / MALLOC:%d\n", p_node->next, p_node->last, p_node->if_malloc); - if (!strcmp(p_node->type, "int")) { + if (p_node->type == INT) { for (i = 0; i < priority + 1; i++) printf(" "); printf("VALUE(int):%d\n", *(int *)(p_node->value)); } - else if (!strcmp(p_node->type, "double")) { + else if (p_node->type == DOUBLE) { for (i = 0; i < priority + 1; i++) printf(" "); printf("VALUE(double):%a\n", *(double *)(p_node->value)); } - else if (!strcmp(p_node->type, "string")) { + else if (p_node->type == STRING) { for (i = 0; i < priority + 1; i++) printf(" "); printf("VALUE(string):%s\n", (char *)(p_node->value)); } - else if (!strcmp(p_node->type, "pointer")) { + else if (p_node->type == POINTER) { for (i = 0; i < priority + 1; i++) printf(" "); printf("VALUE(pointer):%s\n", (char *)(p_node->value)); } - else if (!strcmp(p_node->type, "list")) { + else if (p_node->type == LIST) { for (i = 0; i < priority + 1; i++) printf(" "); printf("VALUE(List):\n"); printListInfo((List *)p_node->value, priority + 2); @@ -173,26 +173,26 @@ void printNode(Node *p_node) { int i; printf("#NODE(location:%p, id:%llu){\n", p_node, p_node->id); printf(" "); - printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last, p_node->if_malloc); + printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last); for (i = 0; i < 1; i++) printf(" "); printf("ifMalloc: "); if (p_node->if_malloc) { printf("YES\n"); for (i = 0; i < 1; i++) printf(" "); - printf("Value(type: %s): ", p_node->type); - if (!strcmp(p_node->type, "int")) { + printf("Value(type: %d): ", p_node->type); + if (p_node->type == INT) { printf("%d", *(int *)(p_node->value)); } - else if (!strcmp(p_node->type, "double")) { + else if (p_node->type == DOUBLE) { printf("%a\n", *(double *)(p_node->value)); } - else if (!strcmp(p_node->type, "string")) { + else if (p_node->type == STRING) { printf("%s\n", (char *)(p_node->value)); } - else if (!strcmp(p_node->type, "pointer")) { - printf("%s\n", (char *)(p_node->value)); + else if (p_node->type == POINTER) { + printf("%p\n", (char *)(p_node->value)); } - else if (!strcmp(p_node->type, "list")) { + else if (p_node->type == LIST) { printList((List *)p_node->value); } } @@ -206,7 +206,7 @@ Node *findByIntForNode(List *p_list, int target) { Node *t_node; int *p_target = (int *)malloc(sizeof(int)); *p_target = target; - t_node = findByValue(p_list, "int", p_target); + t_node = findByValue(p_list, INT, p_target); free(p_target); return t_node; } @@ -215,7 +215,7 @@ Node *findByDoubleForNode(List *p_list, double target) { Node *t_node; double *p_target = (double *)malloc(sizeof(double)); *p_target = target; - t_node = findByValue(p_list, "double", p_target); + t_node = findByValue(p_list, DOUBLE, p_target); free(p_target); return t_node; } @@ -223,21 +223,21 @@ Node *findByDoubleForNode(List *p_list, double target) { Node *findByStringForNode(List *p_list, char *target) { Node *t_node; char *p_temp = (char *)malloc(sizeof(char)*(strlen(target) + 1)); - strcpy_s(p_temp, sizeof(p_temp), target); - t_node = findByValue(p_list, "string", p_temp); + strcpy(p_temp, target); + t_node = findByValue(p_list, STRING, p_temp); free(p_temp); return t_node; } Node *findByPointerForNode(List *p_list, void *target) { - Node *t_node = findByValue(p_list, "pointer", target); + Node *t_node = findByValue(p_list, POINTER, target); return t_node; } -int addValueForComplex(Node * p_node, char *type, void *value) { +int addValueForComplex(Node * p_node, int type, void *value) { List *c_list; Node *c_node; - if (!strcmp(p_node->type, "list")) { + if (p_node->type == LIST) { c_list = (List *)p_node->value; c_node = initNode(); initMallocValueForNode(c_node, type, value); @@ -248,38 +248,38 @@ int addValueForComplex(Node * p_node, char *type, void *value) { } int addIntForComplex(Node *p_node, int temp) { - if (!strcmp(p_node->type, "list")) { + if (p_node->type == LIST) { int *p_temp = (int *)malloc(sizeof(int)); *p_temp = temp; - addValueForComplex(p_node, "int", p_temp); + addValueForComplex(p_node, INT, p_temp); return 0; } return -1; } int addDoubleForComplex(Node *p_node, double temp) { - if (!strcmp(p_node->type, "list")) { + if (p_node->type == LIST) { double *p_temp = (double *)malloc(sizeof(double)); *p_temp = temp; - addValueForComplex(p_node, "double", p_temp); + addValueForComplex(p_node, DOUBLE, p_temp); return 0; } return -1; } int addStringForComplex(Node *p_node, char *temp) { - if (!strcmp(p_node->type, "list")) { + if (p_node->type == LIST) { char *p_temp = (char *)malloc(sizeof(strlen(temp) + 1)); - strcpy_s(p_temp, sizeof(p_temp), temp); - addValueForComplex(p_node, "string", p_temp); + strcpy(p_temp, temp); + addValueForComplex(p_node, STRING, p_temp); return 0; } return -1; } int addPointerForComplex(Node *p_node, void *temp) { - if (!strcmp(p_node->type, "list")) { - addValueForComplex(p_node, "pointer", temp); + if (p_node->type == LIST) { + addValueForComplex(p_node, POINTER, temp); return 0; } return -1; @@ -289,7 +289,7 @@ List *m_findByInt(List* p_list, int temp) { int *p_temp = (int *)malloc(sizeof(int)); List *t_list; *p_temp = temp; - t_list = mply_findByValue(p_list, "int", (void *)p_temp); + t_list = mply_findByValue(p_list, INT, (void *)p_temp); free(p_temp); return t_list; } @@ -298,7 +298,7 @@ List *m_findByDouble(List* p_list, double temp) { List *t_list; double *p_temp = (double *)malloc(sizeof(double)); *p_temp = temp; - t_list = mply_findByValue(p_list, "double", (void *)p_temp); + t_list = mply_findByValue(p_list, DOUBLE, (void *)p_temp); free(p_temp); return t_list; } @@ -306,14 +306,14 @@ List *m_findByDouble(List* p_list, double temp) { List *m_findByString(List* p_list, char *temp) { List *t_list; char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1)); - strcpy_s(p_temp, sizeof(p_temp), temp); - t_list = mply_findByValue(p_list, "string", (void *)p_temp); + strcpy(p_temp, temp); + t_list = mply_findByValue(p_list, STRING, (void *)p_temp); free(p_temp); return t_list; } List *m_findByPointer(List* p_list, void *temp) { - List *t_list = mply_findByValue(p_list, "double", (void *)temp); + List *t_list = mply_findByValue(p_list, DOUBLE, (void *)temp); return t_list; } @@ -331,21 +331,21 @@ unsigned long long getIndexByNode(List *p_list, Node *p_node) { List *m_findByIntForNode(List* p_list, int temp) { int *p_temp = (int *)malloc(sizeof(int)); *p_temp = temp; - return mply_findByValue(p_list, "int", (void *)p_temp); + return mply_findByValue(p_list, INT, (void *)p_temp); } List *m_findByDoubleForNode(List* p_list, double temp) { double *p_temp = (double *)malloc(sizeof(double)); *p_temp = temp; - return mply_findByValue(p_list, "double", (void *)p_temp); + return mply_findByValue(p_list, DOUBLE, (void *)p_temp); } List *m_findByStringForNode(List* p_list, char *temp) { char *p_temp = (char *)malloc(sizeof(char) * (strlen(temp) + 1)); - strcpy_s(p_temp, sizeof(p_temp), temp); - return mply_findByValue(p_list, "string", (void *)p_temp); + strcpy(p_temp, temp); + return mply_findByValue(p_list, STRING, (void *)p_temp); } List *m_findByPointerForNode(List* p_list, void *temp) { - return mply_findByValue(p_list, "pointer", (void *)temp); + return mply_findByValue(p_list, POINTER, (void *)temp); } diff --git a/list/list_expand.h b/list/list_expand.h index e2f32e93f8cb09789ef0ab4230bd9d77b18a929c..a9d210f4e06f12ac35656ff86326c057b5e8acb8 100644 GIT binary patch literal 2366 zcmbW3T~FFj7=Z7a^glFuQwfg6&I1kB5*hDo7uj7$3)X-<#PJoIl1F zn|N!#Udh%g->|U<2RQq;v5~WKRb0Jp{Mv-mPR^8;eyz%)M0Y)D0I`Ah(dP7|f?{Gs zLn&Q|#21o6peNG?_Q`NogLTSDaY<98p>Ul`exfZVRC$>KduR8>!0+;Y^@D7L1xb3b zpr++#TCz=JdV&JEtY;E(P+$o!k^9Ir^~xVip=`b8?;E^vN{zILA*B2BdPXzVR-uYZ zht`i9{CU$leCtLsyFOIMw{Kc~!A!Id*pWUQxMkai?D&5mx$PgGG-)yug6D7<@Whum z4Ud-)2nuPGQesG!1XV*Zx*;_;PphU;s^1#cZOJ@2Hw!gZ7bdV1OXPW=pp}}d9b2mx zZb|)EwlxpVrR>2(TbGCEa`j-M_`Ng4>rb4 z1h}jv6+J^cy|9aoGR_|~&Wfa#S6{80wffzexpL)(5!Dn%4un7=j9}jb#(dlZBbl|b z>P(??PSHJ|b8}lc&yn@SWSuTQ)lqM30z zueT!x31(htaEJIoqPt&MWD)e;Hkly+uWyEAzQ!h4y+|X>$CFw*7WdvvKVc%+jiym# zjQnK?b{mp%HdhS1z1G~VL9@VrMZIE}`SIx3l`>v;Xv+$;af=G>>ayhbGK o954eoSHzbeK>~D$xwYPWpT|2Jc=ein#vqpb@{GzzQldQfAE1nizyJUM literal 3374 zcmb`KOKTHR6vq!0tP0ucN*v544Mnr9X5piXK{J_VqHU=(n#p7)(4;XYLxWNw1PN53 zLO~D&Hw8C-0Kb3>{Q$0A=tgkmPOP3YcW!bgoyRpuNavAz&;LAr=ib{t2T7(;|x<`G>tQ01G?@!1sA=^!{>^Ir{`;1* ze)D-&i?g|i8eOQMHzr!H3QxiI`+cS$YhOoC+pfnJ+BeXC(~VledmHZKZwjRUQ!E-< zXSp%aZVDXtx%!U^aT&XcRvXZAGqxqD1m`QUdaN{A59XtS(O2V%|E?Lr+Yg_hPip$R_vdf=Zqc7rz>Bii``tA32vQIUm@}VB17tul;K6(c_)v zffJ-8GAE}O#HBx?cvX=^IaM*!)5hv&QchQ_q`dAVw>7sHs&EAvq1w{Aw&gL#nM&a* z$5tWgLZYba_GcX|yqY*iK{lypE#Z#)v|u-le4+W|tF>LB{1aVqUUXtT@U!*0U_Ib8 z$?6>DD?HvHvZm2IOjo#O5LeS^2C)^c8bno;DpgXXqk((hBvawlWHk9}De`iua@<Ty?=FR zVg31;W!~Fo72JJjcc*=e&M3XnPOev4`l+Hl95~;0K5Ty}Y~Bk~<;0Fv`5Ri3NVSRf zY4ws*C7$9{Ic@$J`O3z`z-|3>_Klb2 zOp!&%c2<#h(P~u3$l4Z}9{U^B6S9`a^reMNL{l$oTV@C2nIh)czDSke3VtU1-19M$ zY*LNH`tnXG;VHL`{B|);JF=sc5gRFw`crg5WSQ1KWyy!H=;1YZ#6~(PUo{ZhilmOr?NI&?BSu}GX{?w8q64+ST;rAbZH#~;UTAm Zaz26wf9{ofL(s@gP4v;Y;lduTf`7E@69xsMWUWZU|!{)Hg%k9Ia5`gg*(6Ol`?@wRGq0-n30u4wM<~yVj3vRsTVQK zxzyRFU9?5~YpB||%V$oC<}>(=G2pq%?Yc1Gc!SfpO0z4@?2(cwVlvDhbEcJ~e(YGy zHO^3qG$*3XFJi2A8fh6AIu+?LBz04Cn2ejixFO+dk2vve-@$PcsxakQg!|~N9b}R5 zn3FxvbE5C7_sTK99I?ew@j5fo{I=()gtB9F@5bEZh?SLiMY~irHS4r9lmUyq4jQ~D zCY;s!znx<^6{SrPx;Oq#Na1#?I;lQ-|Z znG{I9nUscWAC$q@a=a0uz=4z=pn1N%duZ=P5d$QBiI<{HSyl#pNL#DVt|L{B8zI7n z)6C$*aq2@ny8f*ttMsRUxF+&=Ag#byI?NlYIz1r;z@dHbjIsSC#e{QovZz3wIy2?O z9}SSC&!HAy&^$%Sdfm>yPF74BO@}bfJ`y*`U|mw;4x>`TCrBg=>AGdRSGCCKlxI^* zKD8UckE!1m?rLw33BAoVuJt^*9Wa*Xu!A2nh};Xgvu@VRCSoDGi3qNAlONZfck`4$ kW*sJE{81a-dA(MW85czA=eJoVDKse@ppyCfN062H1_^r2^Z)<= literal 1276 zcmbVMT}#725S(Yh{}AX)Euud_5kwF{^d;hJiRnjzu?_hsO7X9&Gj}~N*HEoeN-uk} zvopKfe0~g&V}TR}T1+rSgmctrcrJMJgcD@Az#$IISLhk>Le7Yd@qkNQ;TB`uY!LQN ztYYgU#MR&pCGQ=NDppjG@;5T|6P};Ry1>$))`mUetv)T|HMPu5l?fvSaSJ|oPdPKs zf;_2G1-TgG1qt(%nQq}y!zNV`?=s>lo<@AOxV}iG3{dU)7w|iz--}!y7YEBWq-rBNyg_9type, "int")) return *(int *)p_snode->value; + if (p_snode->type == INT) return *(int *)p_snode->value; else return -1; } double getValueByDoubleForSNode(SNode *p_snode) { - if (!strcmp(p_snode->type, "double")) return *(double *)p_snode->value; + if (p_snode->type == DOUBLE) return *(double *)p_snode->value; else return -1; } char *getValueByStringForSNode(SNode *p_snode) { - if (!strcmp(p_snode->type, "int")) return (char *)p_snode->value; + if (p_snode->type == STRING) return (char *)p_snode->value; else return NULL; } void *getValueByPointerForSNode(SNode *p_snode) { - if (!strcmp(p_snode->type, "int")) return (void *)p_snode->value; + if (p_snode->type == POINTER) return (void *)p_snode->value; else return NULL; -} \ No newline at end of file +} diff --git a/stack/stack_expand.h b/stack/stack_expand.h index 300b68efb06b1eb147a2e3b461a5e23cdbe412f2..ba739f79634f43b2fb56b830143985bf0aec42da 100644 GIT binary patch literal 401 zcmZvYK?=e!6h!wqMKGJ#MLmEbs8tl96e{Yj)aKU&%a63F=VDnR(0%VX8&} zHO&u;)xKDtvqhQ|Tf(fS5PoIC6jn_yfX+J8D!j&WK4_!Pl+`VkBSP|2TPW(#o|7_i zhlVROF0G7w!c7-1YEEmMx6}ex_|MwEUr!Z~(DydIfVVn;w=g+q}`O+rvMr tY>Kb@!u*T?>5GRvzb63t0R#9M79a@&6so3^h`Jvu;CU}m6p}_0@&;<>h1dW9 literal 838 zcma))!AiqW5Jk^g@E=0m#4hXyD1ur=5u^}NccGfJ6{Sji75#bj&P#+T4fO3Y;m(~q z=gsfW9?vX!;*}K@H5o^I5NP86IR`8_W|ti{m4m39s{1AC22uB~oypf6XYwq#<%Bb? zDLLnXiK-jMsxCY4R%ux*!#2ImDCF?gWgaTYva9ZuJSg>*{si*4M_`}BIB8qgSS~9b z#iLel<*HPN!qLmcX2Dc6Glt0-CYov_f-*Ep@fquC&BF+^nvA)0fjiBySFAbZyW9Rk zosA=vyKkS!@7eF?xum-K-TN|nQmLMvMW5$7yHwZqW@|C8MAa^Kr1#3)eV5|;#k&}r Mrqrt%zfruYKZPxbvH$=8 diff --git a/test.c b/test.c index 5347f93..210d23f 100644 --- a/test.c +++ b/test.c @@ -2,7 +2,6 @@ int list(void) { - int i; List *t_list, *m_list;; init_rand(); safeModeForNode(1); @@ -20,7 +19,7 @@ int list(void) { insertInTail(t_list,t_node); initMalllocValue(t_node,(void *)"there");*/ - for (i = 0; i < 12; i++) { + for (int i = 0; i < 12; i++) { insertInHead(t_list, nodeWithInt(i)); insertInTail(t_list, nodeWithInt(i)); } @@ -87,4 +86,4 @@ int main(int argc, char **argv) { tree(); getchar(); return 0; -} \ No newline at end of file +} diff --git a/test.h b/test.h index 3e171ce..eed9bbc 100644 --- a/test.h +++ b/test.h @@ -12,5 +12,4 @@ int stack(void); int list(void); int tree(void); -#endif // TEST_H - +#endif // TEST_H diff --git a/tree/tree.c b/tree/tree.c index bab8420..5171631 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -1,8 +1,8 @@ #include"tree.h" -unsigned long long target_id = 0; -TNode *target_value_id = NULL; -int if_safeModeForTree = 0; +static unsigned long long target_id = 0; +static TNode *target_value_id = NULL; +static int if_safeModeForTree = 0; int safeModeForTree(int ifon) { if (ifon == 1) { @@ -36,21 +36,21 @@ TNode *initTNode(void) { p_tnode->father = NULL; p_tnode->if_malloc = 0; p_tnode->value = NULL; - p_tnode->type = NULL; + p_tnode->type = VOID; p_tnode->home = initList(); p_tnode->room = NULL; if (if_safeModeForTree) { if (if_safeModeForNode) { if_safeModeForNode = 0; s_node = initNode(); - initMallocValueForNode(s_node, "pointer", (void *)p_tnode); + initMallocValueForNode(s_node, POINTER, (void *)p_tnode); insertInTail(tnode_list, s_node); if_safeModeForNode = 1; } else { s_node = initNode(); - initMallocValueForNode(s_node, "pointer", (void *)p_tnode); + initMallocValueForNode(s_node, POINTER, (void *)p_tnode); insertInTail(tnode_list, s_node); } } @@ -66,21 +66,21 @@ Tree *initTree(void) { if (if_safeModeForNode) { if_safeModeForNode = 0; s_node = initNode(); - initMallocValueForNode(s_node, "pointer", (void *)p_tree); + initMallocValueForNode(s_node, POINTER, (void *)p_tree); if_safeModeForNode = 1; insertInTail(tree_list, s_node); } else { s_node = initNode(); - initMallocValueForNode(s_node, "pointer", (void *)p_tree); + initMallocValueForNode(s_node, POINTER, (void *)p_tree); insertInTail(tree_list, s_node); } } return p_tree; } -int *initMallocValueForTNode(TNode *p_tnode, char *type, void *value) { +int *initMallocValueForTNode(TNode *p_tnode, int type, void *value) { p_tnode->type = type; p_tnode->value = value; p_tnode->if_malloc = 1; @@ -89,7 +89,7 @@ int *initMallocValueForTNode(TNode *p_tnode, char *type, void *value) { int addChildInLeft(TNode *f_tnode, TNode *c_tnode) { Node *p_node = initNode(); - initMallocValueForNode(p_node, "pointer", c_tnode); + initMallocValueForNode(p_node, POINTER, c_tnode); insertInHead(f_tnode->home, p_node); c_tnode->father = f_tnode; c_tnode->room = p_node; @@ -99,7 +99,7 @@ int addChildInLeft(TNode *f_tnode, TNode *c_tnode) { int addChildInRight(TNode *f_tnode, TNode *c_tnode) { Node *p_node = initNode(); - initMallocValueForNode(p_node, "pointer", c_tnode); + initMallocValueForNode(p_node, POINTER, c_tnode); insertInTail(f_tnode->home, p_node); c_tnode->father = f_tnode; c_tnode->room = p_node; @@ -155,8 +155,8 @@ TNode *getChildById(TNode *p_tnode, unsigned long long id) { return NULL; } -int _dogetChildById(const char *type, void *value) { - if (!strcmp(type, "pointer")) { +int _dogetChildById(int type, void *value) { + if (type == POINTER) { TNode *p_tode = (TNode *)value; if (p_tode->id == target_id) { target_value_id = p_tode; @@ -166,12 +166,11 @@ int _dogetChildById(const char *type, void *value) { return 0; } -char *target_type = NULL; -void *target_value = NULL; -TNode *target_value_value = NULL; -int _dogetChildByValue(const char *type, void *value); +static int target_type = VOID; +static void *target_value = NULL; +static TNode *target_value_value = NULL; -TNode *getChildByValue(TNode *p_tnode, char *type, void *value) { +TNode *getChildByValue(TNode *p_tnode, int type, void *value) { List *p_home = p_tnode->home; target_value = value; target_type = type; @@ -183,17 +182,17 @@ TNode *getChildByValue(TNode *p_tnode, char *type, void *value) { return NULL; } -int _dogetChildByValue(const char *type, void *value) { - if (!strcmp(type, target_type)) { +int _dogetChildByValue(int type, void *value) { + if (type == target_type) { TNode *p_tode = (TNode *)value; - if (!strcmp((char *)target_value, "int")) { + if (target_type == INT) { if (*(int *)p_tode->value == *(int *)target_value) { target_value_value = p_tode; return -1; } } - else if (!strcmp((char *)target_value, "double")) + else if (target_type == DOUBLE) { if (*(double *)p_tode->value == *(double *)target_value) { @@ -201,7 +200,7 @@ int _dogetChildByValue(const char *type, void *value) { return -1; } } - else if (!strcmp((char *)target_value, "string")) + else if (target_type == STRING) { if (!strcmp((char *)p_tode->value, (char *)target_value)) { @@ -209,7 +208,7 @@ int _dogetChildByValue(const char *type, void *value) { return -1; } } - else if (!strcmp((char *)target_value, "pointer")) + else if (target_type == POINTER) { if (p_tode->value == target_value) { @@ -235,7 +234,7 @@ int removeChildById(TNode *p_tnode, unsigned long long id) { return -1; } -int removeChildByValue(TNode *p_tnode, char *type, void *value) { +int removeChildByValue(TNode *p_tnode, int type, void *value) { TNode *t_tnode = getChildByValue(p_tnode, type, value); if (t_tnode != NULL) { TNode *p_fnode = t_tnode->father; @@ -376,8 +375,8 @@ int releaseTNode(TNode *p_tnode) { if (p_tnode->father != NULL) { removeChildById(p_tnode->father, p_tnode->id); } - if (strcmp(p_tnode->type, "pointer")) { - if (!strcmp(p_tnode->type, "list")) { + if (p_tnode->type != POINTER) { + if (p_tnode->type == LIST) { releaseList((List *)p_tnode->value); } else { @@ -385,7 +384,7 @@ int releaseTNode(TNode *p_tnode) { } } p_tnode->value = NULL; - p_tnode->type = NULL; + p_tnode->type = VOID; p_tnode->id = 0; p_tnode->if_malloc = 0; free(p_tnode); @@ -416,8 +415,8 @@ int releaseOnlyTree(Tree *p_tree) { int releaseOnlyTNode(TNode *p_tnode) { releaseList(p_tnode->home); if (p_tnode->if_malloc) { - if (strcmp(p_tnode->type, "pointer")) { - if (!strcmp(p_tnode->type, "list")) { + if (p_tnode->type != STRING) { + if (p_tnode->type == LIST) { releaseList((List *)p_tnode->value); } else { @@ -426,7 +425,7 @@ int releaseOnlyTNode(TNode *p_tnode) { } } p_tnode->value = NULL; - p_tnode->type = NULL; + p_tnode->type = VOID; p_tnode->id = 0; p_tnode->if_malloc = 0; free(p_tnode); diff --git a/tree/tree.h b/tree/tree.h index c978da4..c2d950f 100644 --- a/tree/tree.h +++ b/tree/tree.h @@ -1,18 +1,8 @@ -<<<<<<< HEAD -// -// tree.h -// ZE-Standard-Libraries -// -// Created by 胡一兵 on 2018/6/11. -// Copyright © 2018年 ZE. All rights reserved. -// +#ifndef TREE_H +#define TREE_H -#ifndef tree_h -#define tree_h #include #include "../list/list_expand.h" -#ifndef TREE_H -#define TREE_H typedef struct tree_node { @@ -21,7 +11,7 @@ typedef struct tree_node struct tree_node *father; Node *room; unsigned long long child_num; - char *type; + int type; void *value; int if_malloc; }TNode; @@ -38,7 +28,7 @@ int releaseAllForTree(void); TNode *initTNode(void); Tree *initTree(void); -int *initMallocValueForTNode(TNode *p_tnode, char *type, void *value); +int *initMallocValueForTNode(TNode *p_tnode, int type, void *value); int addChildInLeft(TNode *f_tnode, TNode *c_tnode); int addChildInRight(TNode *f_tnode, TNode *c_tnode); @@ -47,30 +37,30 @@ TNode *getBrotherInRight(TNode *p_node); int removeChildInLeft(TNode *p_tnode); int removeChildInRight(TNode *p_tnode); TNode *getChildById(TNode *p_tnode, unsigned long long id); -TNode *getChildByValue(TNode *p_tnode, char *type, void *value); +TNode *getChildByValue(TNode *p_tnode, int type, void *value); TNode *getChildByIndex(TNode *p_tnode, unsigned long long index); unsigned long long getIndexByChild(TNode *f_tnode, TNode *c_tnode); int removeChildById(TNode *p_tnode, unsigned long long id); int removeChildByIndex(TNode *p_tnode, unsigned long long index); -int removeChildByValue(TNode *p_tnode, char *type, void *value); +int removeChildByValue(TNode *p_tnode, int type, void *value); int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); int TreeTravel(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); -static int _dogetChildById(const char *type, void *value); -static int _dogetChildByValue(const char *type, void *value); -static int _doreleaseTree(TNode *p_tnode, unsigned long long height); -static int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)); -static int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)); +int _dogetChildById(int type, void *value); +int _dogetChildByValue(int type, void *value); +int _doreleaseTree(TNode *p_tnode, unsigned long long height); +int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)); +int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)); int releaseTree(Tree *p_tree); int releaseOnlyTree(Tree *p_tree); -int releaseTNode(TNode *p_tnode); -static int releaseOnlyTNode(TNode *p_tnode); +int releaseTNode(TNode *p_tnode); +int releaseOnlyTNode(TNode *p_tnode); int setRoot(Tree *p_tree, TNode *p_tnode); -static char *target_type; +static int target_type; static void *target_value; static TNode *target_value_value; @@ -83,4 +73,3 @@ static int if_safeModeForTree; #endif ->>>>>>> 30b15314d8173f7cdfb24ab7f9250435ae2db90c diff --git a/tree/tree_expand.c b/tree/tree_expand.c index 353526a..0ef44a2 100644 --- a/tree/tree_expand.c +++ b/tree/tree_expand.c @@ -4,7 +4,7 @@ TNode *tnodeWithInt(int temp) { TNode *p_tnode = initTNode(); int *p_temp = (int *)malloc(sizeof(int)); *p_temp = temp; - initMallocValueForTNode(p_tnode, "int", p_temp); + initMallocValueForTNode(p_tnode, INT, p_temp); return p_tnode; } @@ -12,46 +12,46 @@ TNode *tnodeWithDouble(double temp) { TNode *p_tnode = initTNode(); double *p_temp = (double *)malloc(sizeof(double)); *p_temp = temp; - initMallocValueForTNode(p_tnode, "double", p_temp); + initMallocValueForTNode(p_tnode, DOUBLE, p_temp); return p_tnode; } TNode *tnodeWithString(char *temp) { TNode *p_tnode = initTNode(); char *p_temp = (char *)malloc(sizeof(temp)); - strcpy_s(p_temp, sizeof(p_temp), temp); - initMallocValueForTNode(p_tnode, "double", p_temp); + strcpy(p_temp, temp); + initMallocValueForTNode(p_tnode, STRING, p_temp); return p_tnode; } TNode *tnodeWithPointer(void *temp) { TNode *p_tnode = initTNode(); - initMallocValueForTNode(p_tnode, "pointer", temp); + initMallocValueForTNode(p_tnode, POINTER, temp); return p_tnode; } int getValueByIntForTree(TNode *p_tnode) { - if (!strcmp(p_tnode->type, "int")) { + if (p_tnode->type == INT) { return *(int *)p_tnode->value; } return -1; } double getValueByDoubleForTree(TNode *p_tnode) { - if (!strcmp(p_tnode->type, "double")) { + if (p_tnode->type == DOUBLE) { return *(double *)p_tnode->value; } return -1; } char *getValueByStringForTree(TNode *p_tnode) { - if (!strcmp(p_tnode->type, "string")) { + if (p_tnode->type == STRING) { return (char *)p_tnode->value; } return NULL; } void *getValueByPointerForTree(TNode *p_tnode) { - if (!strcmp(p_tnode->type, "pointer")) { + if (p_tnode->type == POINTER) { return p_tnode->value; } return NULL; @@ -70,17 +70,17 @@ int printTNode(TNode *p_tnode, int priority) { if (p_tnode->if_malloc) { printf("YES\n"); for (i = 0; i < priority + 1; i++) printf(" "); - printf("Value(type: %s): ", p_tnode->type); - if (!strcmp(p_tnode->type, "int")) { + printf("Value(type: %d): ", p_tnode->type); + if (p_tnode->type == INT) { printf("%d\n", *(int *)(p_tnode->value)); } - else if (!strcmp(p_tnode->type, "double")) { + else if (p_tnode->type == DOUBLE) { printf("%a\n", *(double *)(p_tnode->value)); } - else if (!strcmp(p_tnode->type, "string")) { + else if (p_tnode->type == STRING) { printf("%s\n", (char *)(p_tnode->value)); } - else if (!strcmp(p_tnode->type, "pointer")) { + else if (p_tnode->type == POINTER) { printf("%p\n", (char *)(p_tnode->value)); } } @@ -108,17 +108,17 @@ int printTNodeWithHome(TNode *p_tnode,int priority) { if (p_tnode->if_malloc) { printf("YES\n"); for (i = 0; i < priority + 1; i++) printf(" "); - printf("Value(type: %s): ", p_tnode->type); - if (!strcmp(p_tnode->type, "int")) { + printf("Value(type: %d): ", p_tnode->type); + if (p_tnode->type == INT) { printf("%d\n", *(int *)(p_tnode->value)); } - else if (!strcmp(p_tnode->type, "double")) { + else if (p_tnode->type == DOUBLE) { printf("%a\n", *(double *)(p_tnode->value)); } - else if (!strcmp(p_tnode->type, "string")) { + else if (p_tnode->type == STRING) { printf("%s\n", (char *)(p_tnode->value)); } - else if (!strcmp(p_tnode->type, "pointer")) { + else if (p_tnode->type == POINTER) { printf("%p\n", (char *)(p_tnode->value)); } } @@ -164,17 +164,17 @@ int printTNodeWithFamily(TNode *p_tnode, int priority) { if (p_tnode->if_malloc) { printf("YES\n"); for (i = 0; i < priority + 1; i++) printf(" "); - printf("Value(type: %s): ", p_tnode->type); - if (!strcmp(p_tnode->type, "int")) { + printf("Value(type: %d): ", p_tnode->type); + if (p_tnode->type == INT) { printf("%d\n", *(int *)(p_tnode->value)); } - else if (!strcmp(p_tnode->type, "double")) { + else if (p_tnode->type == DOUBLE) { printf("%a\n", *(double *)(p_tnode->value)); } - else if (!strcmp(p_tnode->type, "string")) { + else if (p_tnode->type == STRING) { printf("%s\n", (char *)(p_tnode->value)); } - else if (!strcmp(p_tnode->type, "pointer")) { + else if (p_tnode->type == POINTER) { printf("%p\n", (char *)(p_tnode->value)); } } @@ -211,4 +211,4 @@ int printTree(Tree *p_tree) { printf("Tree(id: %llu)",p_tree->id); printTNodeWithFamily(p_tree->root,0); return 0; -} \ No newline at end of file +} diff --git a/type/type.h b/type/type.h new file mode 100644 index 0000000..199e088 --- /dev/null +++ b/type/type.h @@ -0,0 +1,21 @@ +// +// type.h +// ZE-Standard-Libraries +// +// Created by 胡一兵 on 2018/7/23. +// Copyright © 2018年 ZE. All rights reserved. +// + +#ifndef type_h +#define type_h + +#define VOID 0 +#define INT 1 +#define DOUBLE 2 +#define STRING 3 +#define POINTER 4 +#define LIST 5 + + + +#endif /* type_h */ From fbb2a97ce57017eb831cbfe1f595642d773c76e4 Mon Sep 17 00:00:00 2001 From: Saturneic Date: Mon, 23 Jul 2018 13:47:31 +0800 Subject: [PATCH 41/55] Fix and add. --- .../xcdebugger/Breakpoints_v2.xcbkptlist | 32 +++++++++++++++++++ list/list_expand.c | 11 +++++++ list/list_expand.h | 2 ++ tree/tree_expand.c | 15 ++++++++- tree/tree_expand.h | 3 ++ 5 files changed, 62 insertions(+), 1 deletion(-) diff --git a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist index d16736f..f56e272 100644 --- a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist +++ b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist @@ -147,5 +147,37 @@ landmarkType = "9"> + + + + + + + + diff --git a/list/list_expand.c b/list/list_expand.c index 33f21b5..287658a 100644 --- a/list/list_expand.c +++ b/list/list_expand.c @@ -348,4 +348,15 @@ List *m_findByStringForNode(List* p_list, char *temp) { List *m_findByPointerForNode(List* p_list, void *temp) { return mply_findByValue(p_list, POINTER, (void *)temp); +} + +unsigned long long calListMemory(List * p_list){ + Node *p_node = p_list->head; + unsigned long long nodes_size = 0LL; + unsigned long long list_size = sizeof(p_list); + while(p_node != NULL){ + nodes_size += sizeof(p_node) + sizeof(*p_node->value); + p_node = p_node->next; + } + return list_size + nodes_size; } diff --git a/list/list_expand.h b/list/list_expand.h index a9d210f..18ba83e 100644 --- a/list/list_expand.h +++ b/list/list_expand.h @@ -36,5 +36,7 @@ char *getByStringForNode(Node *);//直接得到节点的值 void *getByPointerForNode(Node *);//直接得到节点的值 unsigned long long getIndexByNode(List *p_list,Node *p_node); int listThrough(List *p_list, int (*p_func)(int , void *));//遍历链表并不断调用目标函数。目标函数将接受节点储存值的指针及其类型。 + +unsigned long long calListMemory(List *); #endif diff --git a/tree/tree_expand.c b/tree/tree_expand.c index 0ef44a2..1f30a1f 100644 --- a/tree/tree_expand.c +++ b/tree/tree_expand.c @@ -211,4 +211,17 @@ int printTree(Tree *p_tree) { printf("Tree(id: %llu)",p_tree->id); printTNodeWithFamily(p_tree->root,0); return 0; -} +} + +static unsigned long long tnodes_size = 0LL; + +unsigned long long calTreeMemory(Tree *p_tree){ + tnodes_size = 0LL; + TreeThroughDown(p_tree, _doCalTreeMemory); + return sizeof(p_tree) + tnodes_size; +} + +int _doCalTreeMemory(TNode *p_tnode, unsigned long long height){ + tnodes_size += sizeof(p_tnode) + sizeof(*p_tnode->value); + return 0; +} diff --git a/tree/tree_expand.h b/tree/tree_expand.h index d8d882a..a4236a2 100644 --- a/tree/tree_expand.h +++ b/tree/tree_expand.h @@ -17,5 +17,8 @@ int printTree(Tree *p_tree); int printTNodeWithHome(TNode *p_tnode, int priority); int printTNodeWithFamily(TNode *p_tnode, int priority); int printTNode(TNode *p_tnode, int priority); + +unsigned long long calTreeMemory(Tree *); +int _doCalTreeMemory(TNode *p_tnode, unsigned long long height); #endif From 5ae6717bfc1788568d8e500ae54e4ea6565a9841 Mon Sep 17 00:00:00 2001 From: Saturneic Date: Wed, 25 Jul 2018 22:10:09 +0800 Subject: [PATCH 42/55] Fixed --- id/id.c | 30 ++++++++++++++++++++++++++++++ id/id.h | 22 ++++++++++++++++++++++ list/list.c | 15 --------------- list/list.h | 5 +---- tree/tree_expand.h | 3 +++ type/type.h | 2 ++ 6 files changed, 58 insertions(+), 19 deletions(-) create mode 100644 id/id.c create mode 100644 id/id.h diff --git a/id/id.c b/id/id.c new file mode 100644 index 0000000..d2c860c --- /dev/null +++ b/id/id.c @@ -0,0 +1,30 @@ +// +// id.c +// ZE-Standard-Libraries +// +// Created by 胡一兵 on 2018/7/25. +// Copyright © 2018年 ZE. All rights reserved. +// + +#include "id.h" + +void init_rand(void) { + srand((unsigned)time(NULL)); +} + +unsigned long long getId(void) { + int i; + unsigned long long id = 0; + id = ((rand() % 9) + 1); + for (i = 0; i < 15; i++) { + id *= 10; + id += rand() % 10; + } + return id; +} + +char *getS_id(void){ + + return NULL; +} + diff --git a/id/id.h b/id/id.h new file mode 100644 index 0000000..fe9981a --- /dev/null +++ b/id/id.h @@ -0,0 +1,22 @@ +// +// id.h +// ZE-Standard-Libraries +// +// Created by 胡一兵 on 2018/7/25. +// Copyright © 2018年 ZE. All rights reserved. +// + +#ifndef id_h +#define id_h + +#include +#include + +/*有关id的函数*/ +void init_rand(void); +unsigned long long getId(void); + +/*有关s_id函数*/ +char *getS_id(void); + +#endif /* id_h */ diff --git a/list/list.c b/list/list.c index 4afc44d..a4a2a08 100644 --- a/list/list.c +++ b/list/list.c @@ -121,21 +121,6 @@ int initMallocValueForNode(Node *p_node, int type, void *p_value) { return 0; } -void init_rand(void) { - srand((unsigned)time(NULL)); -} - -unsigned long long getId(void) { - int i; - unsigned long long id = 0; - id = ((rand() % 9) + 1); - for (i = 0; i < 15; i++) { - id *= 10; - id += rand() % 10; - } - return id; -} - int insertInHead(List *p_list, Node *p_node) { if (isListEmpty(p_list)) { p_list->head = p_node; diff --git a/list/list.h b/list/list.h index defec7f..f9496de 100644 --- a/list/list.h +++ b/list/list.h @@ -6,6 +6,7 @@ #include #include #include "../type/type.h" +#include "../id/id.h" typedef struct Node{ unsigned long long id;//唯一标识符 @@ -34,10 +35,6 @@ Node *initNode(void); int initMallocValueForNode(Node *,int,void *);//赋予已分配内存的值，并标明类型 -/*有关id的函数*/ -void init_rand(void); -unsigned long long getId(void); - /*插入函数*/ int insertInHead(List *p_list, Node *p_node); int insertInTail(List *p_list, Node *p_node); diff --git a/tree/tree_expand.h b/tree/tree_expand.h index a4236a2..bec0086 100644 --- a/tree/tree_expand.h +++ b/tree/tree_expand.h @@ -20,5 +20,8 @@ int printTNode(TNode *p_tnode, int priority); unsigned long long calTreeMemory(Tree *); int _doCalTreeMemory(TNode *p_tnode, unsigned long long height); + +List *treeToList(Tree *p_tree); + #endif diff --git a/type/type.h b/type/type.h index 199e088..cd7a83c 100644 --- a/type/type.h +++ b/type/type.h @@ -15,6 +15,8 @@ #define STRING 3 #define POINTER 4 #define LIST 5 +#define STACK 6 +#define TREE 7 From 667e48801d4ec21a3012753331e662ad4a4aa817 Mon Sep 17 00:00:00 2001 From: Saturneic Date: Mon, 30 Jul 2018 17:45:33 +0800 Subject: [PATCH 43/55] Add and Fixed. --- communicate/communicate.c | 9 ++ communicate/communicate.h | 14 +++ graph/graph.c | 2 +- graph/graph.h | 4 +- id/id.c | 209 +++++++++++++++++++++++++++++++++++++- id/id.h | 21 +++- list/list.c | 18 ++-- list/list.h | 17 ++-- list/list_expand.c | 2 +- list/list_expand.h | 2 +- stack/stack.c | 4 +- stack/stack.h | 10 +- test.c | 8 +- tree/tree.c | 46 +++++---- tree/tree.h | 30 +++--- type/type.h | 13 +++ 16 files changed, 344 insertions(+), 65 deletions(-) create mode 100644 communicate/communicate.c create mode 100644 communicate/communicate.h diff --git a/communicate/communicate.c b/communicate/communicate.c new file mode 100644 index 0000000..97e91a1 --- /dev/null +++ b/communicate/communicate.c @@ -0,0 +1,9 @@ +// +// communicate.c +// ZE-Standard-Libraries +// +// Created by 胡一兵 on 2018/7/25. +// Copyright © 2018年 ZE. All rights reserved. +// + +#include "communicate.h" diff --git a/communicate/communicate.h b/communicate/communicate.h new file mode 100644 index 0000000..4dde066 --- /dev/null +++ b/communicate/communicate.h @@ -0,0 +1,14 @@ +// +// communicate.h +// ZE-Standard-Libraries +// +// Created by 胡一兵 on 2018/7/25. +// Copyright © 2018年 ZE. All rights reserved. +// + +#ifndef communicate_h +#define communicate_h + + + +#endif /* communicate_h */ diff --git a/graph/graph.c b/graph/graph.c index e43cd57..e8b6b5e 100644 --- a/graph/graph.c +++ b/graph/graph.c @@ -1 +1 @@ -#include "graph.h" \ No newline at end of file +#include "graph.h" diff --git a/graph/graph.h b/graph/graph.h index c1db03d..702dc11 100644 --- a/graph/graph.h +++ b/graph/graph.h @@ -4,14 +4,14 @@ #include "../list/list_expand.h" typedef struct GNode{ - unsigned long long id; + SID *s_id; void *value; List *routes; int if_setValue; }GNode; typedef struct route{ - unsigned long long id; + SID *s_id; double distance; int if_setValue; GNode from, to; diff --git a/id/id.c b/id/id.c index d2c860c..e8a756d 100644 --- a/id/id.c +++ b/id/id.c @@ -23,8 +23,211 @@ unsigned long long getId(void) { return id; } -char *getS_id(void){ - - return NULL; +SID *initS_id(unsigned int deep_level){ + SID *p_sid = (SID *)malloc(sizeof(SID)); + p_sid->type = VOID; + p_sid->deep = deep_level; + p_sid->value = NULL; + p_sid->value_deeper = NULL; + p_sid->value_deepest = NULL; + if (deep_level > 0) p_sid->value = (unsigned int (*)[DEEPC_LEN])malloc(sizeof(unsigned int)*DEEPC_LEN); + if (deep_level > 1) p_sid->value_deeper = (unsigned int (*)[DEEPB_LEN])malloc(sizeof(unsigned int)*DEEPB_LEN); + if (deep_level > 2) p_sid->value_deepest = (unsigned int (*)[DEEPA_LEN])malloc(sizeof(unsigned int)*DEEPA_LEN); + return p_sid; } +SID *getS_id(unsigned int type, unsigned int deep_level){ + SID *p_sid = (SID *)malloc(sizeof(SID)); + p_sid->type = type; + p_sid->deep = deep_level; + p_sid->value = NULL; + p_sid->value_deeper = NULL; + p_sid->value_deepest = NULL; + if(deep_level > 0){ + p_sid->value = (unsigned int (*)[DEEPC_LEN])malloc(sizeof(unsigned int)*DEEPC_LEN); + for(int i = 0; i < DEEPC_LEN; i++) (*p_sid->value)[i] = rand()%65535; + if(deep_level > 1){ + p_sid->value_deeper = (unsigned int (*)[DEEPB_LEN])malloc(sizeof(unsigned int)*DEEPB_LEN); + for(int i = 0; i < DEEPB_LEN; i++) (*p_sid->value_deeper)[i] = rand()%65535; + } + if (deep_level > 2) { + p_sid->value_deepest = (unsigned int (*)[DEEPA_LEN])malloc(sizeof(unsigned int)*DEEPA_LEN); + for(int i = 0; i < DEEPA_LEN; i++) (*p_sid->value_deepest)[i] = rand()%65535; + } + } + + return p_sid; +} + +int fitS_id(const SID *fs_id, const SID *ss_id){ + if(fs_id->type == ss_id->type){ + if(fs_id->deep == ss_id->deep){ + if (fs_id->deep > 0) + for(int i = 0; i < DEEPC_LEN; i++){ + if((*fs_id->value)[i] == (*ss_id->value)[i]) continue; + else if((*fs_id->value)[i] > (*ss_id->value)[i]) return 1; + else return -1; + } + if (fs_id->deep > 1) + for(int i = 0; i < DEEPB_LEN; i++){ + if((*fs_id->value_deeper)[i] == (*ss_id->value_deeper)[i]) continue; + else if((*fs_id->value_deeper)[i] > (*ss_id->value_deeper)[i]) return 1; + else return -1; + } + if (fs_id->deep > 2) + for(int i = 0; i < DEEPA_LEN; i++){ + if((*fs_id->value_deepest)[i] == (*ss_id->value_deepest)[i]) continue; + else if((*fs_id->value_deepest)[i] > (*ss_id->value_deepest)[i]) return 1; + else return -1; + } + } + else{ + if(fs_id->deep > ss_id->deep) return 1; + else return -1; + } + } + else{ + if (fs_id->type > ss_id->type) return 1; + else return -1; + } + return 0; +} + +int simFitS_id(const SID *fs_id, const SID *ss_id){ + return !fitS_id(fs_id, ss_id); +} + +char *s_idToASCIIString(const SID *s_id){ + char *string = NULL; + int deep_len = 0, temp, buff_count, string_count; + unsigned int buff[DATA_BIT]; + if(s_id->deep > 0){ + if (s_id->deep == DEEPC){ + string = (char *) malloc(sizeof(char) * (DEEPC_LEN + 1) * DATA_BIT + 1); + deep_len = DEEPC_LEN + 1; + deep_len *= DATA_BIT; + } + else if (s_id->deep == DEEPB){ + string = (char *) malloc(sizeof(char) * (DEEPC_LEN + DEEPB_LEN + 1) * DATA_BIT + 1); + deep_len = DEEPC_LEN + DEEPB_LEN + 1; + deep_len *= DATA_BIT; + } + else{ + string = (char *)malloc(sizeof(char) * (DEEPC_LEN + DEEPB_LEN + DEEPA_LEN + 1) * DATA_BIT + 1); + deep_len = DEEPC_LEN + DEEPB_LEN + DEEPA_LEN + 1; + deep_len *= DATA_BIT; + } + string[deep_len] = '\0'; + temp = s_id->type; + buff_count = DATA_BIT - 1; + for (int i = 0; i < DATA_BIT; i++) buff[i] = 0; + while(buff_count >= 0){ + buff[buff_count] = temp % 10; + string[buff_count] = buff[buff_count] + 48; + temp /= 10; + buff_count--; + } + deep_len -= DATA_BIT; + for(int i = 0; i < DEEPC_LEN; i++){ + temp = (*s_id->value)[i]; + for (int i = 0; i < DATA_BIT; i++) buff[i] = 0; + string_count = TYPE_LEN + (i) * 5; + buff_count = DATA_BIT - 1; + while (buff_count >= 0) { + buff[buff_count] = temp % 10; + temp /= 10; + buff_count--; + } + for(int i = DATA_BIT - 1; i >= 0; i--) string[string_count + i] = buff[i] + 48; + } + deep_len -= DEEPC_LEN * DATA_BIT; + if(deep_len > 0) + for(int i = 0; i < DEEPB_LEN; i++){ + temp = (*s_id->value_deeper)[i]; + for (int i = 0; i < DATA_BIT; i++) buff[i] = 0; + string_count = TYPE_LEN + DEEPC_LEN * DATA_BIT + (i) * DATA_BIT; + buff_count = DATA_BIT - 1; + while (buff_count >= 0) { + buff[buff_count] = temp % 10; + temp /= 10; + buff_count--; + } + for(int i = DATA_BIT - 1; i >= 0; i--) string[string_count + i] = buff[i] + 48; + } + + deep_len -= DEEPB_LEN * DATA_BIT; + if(deep_len > 0) + for(int i = 0; i < DEEPA_LEN; i++){ + temp = (*s_id->value_deepest)[i]; + for (int i = 0; i < DATA_BIT; i++) buff[i] = 0; + string_count = TYPE_LEN + (DEEPC_LEN + DEEPB_LEN) * DATA_BIT + (i) * DATA_BIT; + buff_count = DATA_BIT - 1; + while (buff_count >= 0) { + buff[buff_count] = temp % 10; + string[string_count] = buff[buff_count] + 48; + temp /= 10; + buff_count--; + } + for(int i = DATA_BIT - 1; i >= 0; i--) string[string_count + i] = buff[i] + 48; + } + printf("%s",string); + return string; + } + else{ + return NULL; + } + +} +SID *asciiStringToS_id(const char *string){ + SID *s_id = NULL; + unsigned long long string_len = strlen(string); + unsigned int buff[string_len - 1]; + for(int i = 0; i < string_len; i++){ + buff[i] = string[i] - 48; + } + if (string_len == 25) s_id = initS_id(1); + else if (string_len == 65) s_id = initS_id(2); + else if (string_len == 225) s_id = initS_id(3); + else return NULL; + + + + for (int i = 0; i < 5; i++){ + s_id->type += buff[i] ; + s_id->type *= 10; + } + s_id->type /= 10; + + if (string_len >= 25){ + for(int i = 0; i < DEEPC_LEN; i++){ + (*s_id->value)[i] = 0; + for (int j = 0; j < 5; j++){ + (*s_id->value)[i] += (int)buff[5 + i * 5 + j]; + (*s_id->value)[i] *= 10; + } + (*s_id->value)[i] /= 10; + } + } + + if (string_len >= 65){ + for(int i = 0; i < DEEPB_LEN; i++){ + (*s_id->value_deeper)[i] = 0; + for (int j = 0; j < 5; j++){ + (*s_id->value_deeper)[i] += buff[25 + i * 5 + j]; + (*s_id->value_deeper)[i] *= 10; + } + (*s_id->value_deeper)[i] /= 10; + } + } + if (string_len >= 225){ + for(int i = 0; i < DEEPA_LEN; i++){ + (*s_id->value_deepest)[i] = 0; + for (int j = 0; j < 5; j++){ + (*s_id->value_deepest)[i] += buff[65 + i * 5 + j]; + (*s_id->value_deepest)[i] *= 10; + } + (*s_id->value_deepest)[i] /= 10; + } + } + return s_id; +} diff --git a/id/id.h b/id/id.h index fe9981a..894cd3c 100644 --- a/id/id.h +++ b/id/id.h @@ -9,14 +9,33 @@ #ifndef id_h #define id_h +#include #include +#include #include +#include "../type/type.h" + +typedef struct s_id{ + unsigned int type; + unsigned int (*value)[DEEPC_LEN];//4 + unsigned int (*value_deeper)[DEEPB_LEN];//8 + unsigned int (*value_deepest)[DEEPA_LEN];//32 + unsigned int deep; +}SID; /*有关id的函数*/ void init_rand(void); unsigned long long getId(void); /*有关s_id函数*/ -char *getS_id(void); +SID *getS_id(unsigned int type ,unsigned int deep_level); + +int fitS_id(const SID *fs_id, const SID *ss_id); +int simFitS_id(const SID *fs_id, const SID *ss_id); + +char *s_idToASCIIString(const SID *s_id); +SID *asciiStringToS_id(const char *string); + +SID *initS_id(unsigned int deep_level); #endif /* id_h */ diff --git a/list/list.c b/list/list.c index a4a2a08..96b45ac 100644 --- a/list/list.c +++ b/list/list.c @@ -83,6 +83,7 @@ Node *initNode(void) { Node *p_node = (Node *)malloc(sizeof(Node)); Node *prec_node = NULL; p_node->id = getId(); + p_node->s_id = getS_id(LIST_NODE, 2); p_node->if_malloc = 0; p_node->next = NULL; p_node->last = NULL; @@ -101,6 +102,7 @@ List *initList(void) { Node *p_node; List *p_list = (List *)malloc(sizeof(List)); p_list->id = getId(); + p_list->s_id = getS_id(LIST, 1); p_list->head = NULL; p_list->tail = NULL; p_list->length = 0; @@ -114,7 +116,7 @@ List *initList(void) { return p_list; } -int initMallocValueForNode(Node *p_node, int type, void *p_value) { +int initMallocValueForNode(Node *p_node, unsigned int type, void *p_value) { p_node->if_malloc = 1; p_node->type = type; p_node->value = p_value; @@ -212,12 +214,12 @@ unsigned long long len(List *p_list) { return p_list->length; } -int removeById(List *p_list, unsigned long long id) { +int removeById(List *p_list, const SID *s_id) { Node *tmp = p_list->head; if (isListEmpty(p_list)) return -1; do { - if (tmp->id == id) { + if (simFitS_id(tmp->s_id, s_id)) { if (tmp != p_list->head) { tmp->last->next = tmp->next; } @@ -298,13 +300,13 @@ int popFromTail(List *p_list) { } /*该函数算法需要改进*/ -Node *findByIdForNode(List *p_list, const unsigned long long id) { +Node *findByIdForNode(List *p_list, const SID *s_id) { Node *ph_node = p_list->head; Node *pt_node = p_list->tail; int direction = 0; while (ph_node != pt_node) { if (direction == 0) { - if (ph_node->id == id) { + if (simFitS_id(ph_node->s_id, s_id)) { return ph_node; } else { @@ -313,7 +315,7 @@ Node *findByIdForNode(List *p_list, const unsigned long long id) { direction = 1; } else { - if (pt_node->id == id) { + if (simFitS_id(pt_node->s_id, s_id)) { return pt_node; } else { @@ -325,7 +327,7 @@ Node *findByIdForNode(List *p_list, const unsigned long long id) { } -Node *findByValue(List *p_list, int type, const void *value) { +Node *findByValue(List *p_list, unsigned int type, const void *value) { Node *p_node = p_list->head; while (p_node != NULL) { if (p_node->type != type) { @@ -360,7 +362,7 @@ Node *findByValue(List *p_list, int type, const void *value) { return NULL; } -List *mply_findByValue(List *p_list, int type, const void *value) { +List *mply_findByValue(List *p_list, unsigned int type, const void *value) { List *f_list = initList(); Node *p_node = p_list->head; while (p_node != NULL) { diff --git a/list/list.h b/list/list.h index f9496de..cef010e 100644 --- a/list/list.h +++ b/list/list.h @@ -10,9 +10,11 @@ typedef struct Node{ unsigned long long id;//唯一标识符 + SID *s_id; void *value; - int if_malloc;//记录是否已经初始化值 - int type;//记录值的类型 + _Bool if_malloc;//记录是否已经初始化值 + _Bool if_sid; + unsigned int type;//记录值的类型 struct Node *next; struct Node *last; } Node; @@ -20,6 +22,7 @@ typedef struct Node{ typedef struct List{ unsigned long long id;//唯一标识符 + SID *s_id; Node *head; Node *tail; unsigned long long length;//链表长度 @@ -33,7 +36,7 @@ int releaseAllForNode(void);//安全模式最后调用的函数 List *initList(void); Node *initNode(void); -int initMallocValueForNode(Node *,int,void *);//赋予已分配内存的值，并标明类型 +int initMallocValueForNode(Node *,unsigned int,void *);//赋予已分配内存的值，并标明类型 /*插入函数*/ int insertInHead(List *p_list, Node *p_node); @@ -46,16 +49,16 @@ int exchangeLocation(Node *p_node,Node *t_node); Node *copyNode(Node *); /*移除函数*/ -int removeById(List *p_list, unsigned long long id); +int removeById(List *p_list, const SID *s_id); int removeByNode(List *p_list, Node *p_node); int popFromHead(List *p_list); int popFromTail(List *p_list); unsigned long long len(List *p_list);//查看链表的长度 -Node *findByIdForNode(List *p_list, const unsigned long long id);//通过id查找目标链表中的匹配节点 -Node *findByValue(List *p_list, int type, const void *value);//通过值来查找目标链表中的匹配节点 -List *mply_findByValue(List *p_list, int type, const void *value);//寻找多个值匹配的节点 +Node *findByIdForNode(List *p_list, const SID *s_id);//通过id查找目标链表中的匹配节点 +Node *findByValue(List *p_list, unsigned int type, const void *value);//通过值来查找目标链表中的匹配节点 +List *mply_findByValue(List *p_list, unsigned int type, const void *value);//寻找多个值匹配的节点 int releaseList(List *p_list);//释放List并可选择是否释放中所有的其中的Node int releaseListForSingle(List *p_list);//单独释放List diff --git a/list/list_expand.c b/list/list_expand.c index 287658a..d4b647a 100644 --- a/list/list_expand.c +++ b/list/list_expand.c @@ -50,7 +50,7 @@ Node *findByIndexForNode(List *p_list, unsigned long long m_index) { return p_node; } -int listThrough(List *p_list, int(*p_func)(int, void *)) { +int listThrough(List *p_list, int(*p_func)(unsigned int, void *)) { Node *p_node = p_list->head; while (p_node != NULL) { if (p_node->if_malloc == 1) { diff --git a/list/list_expand.h b/list/list_expand.h index 18ba83e..4abcd23 100644 --- a/list/list_expand.h +++ b/list/list_expand.h @@ -35,7 +35,7 @@ double getByDoubleForNode(Node *);//直接得到节点的值 char *getByStringForNode(Node *);//直接得到节点的值 void *getByPointerForNode(Node *);//直接得到节点的值 unsigned long long getIndexByNode(List *p_list,Node *p_node); -int listThrough(List *p_list, int (*p_func)(int , void *));//遍历链表并不断调用目标函数。目标函数将接受节点储存值的指针及其类型。 +int listThrough(List *p_list, int (*p_func)(unsigned int type, void *value));//遍历链表并不断调用目标函数。目标函数将接受节点储存值的指针及其类型。 unsigned long long calListMemory(List *); diff --git a/stack/stack.c b/stack/stack.c index 5682201..9689f86 100644 --- a/stack/stack.c +++ b/stack/stack.c @@ -3,6 +3,7 @@ Stack *initStack(void) { Stack *p_stack = (Stack *)malloc(sizeof(Stack)); p_stack->id = getId(); + p_stack->s_id = getS_id(STACK, 1); p_stack->length = 0; p_stack->top = NULL; return p_stack; @@ -11,6 +12,7 @@ Stack *initStack(void) { SNode *initSNode(void) { SNode *p_snode = (SNode *)malloc(sizeof(SNode)); p_snode->id = getId(); + p_snode->s_id = getS_id(STACK_NODE, 2); p_snode->if_malloc = 0; p_snode->next = NULL; p_snode->value = NULL; @@ -60,7 +62,7 @@ int releaseSNode(SNode *p_snode) { return 0; } -int initMallocValueForSNode(SNode *p_snode, int type, void *value) { +int initMallocValueForSNode(SNode *p_snode, unsigned int type, void *value) { p_snode->if_malloc = 1; p_snode->type = type; p_snode->value = value; diff --git a/stack/stack.h b/stack/stack.h index 4dfd7a6..9581f5b 100644 --- a/stack/stack.h +++ b/stack/stack.h @@ -6,21 +6,25 @@ typedef struct stack_node{ unsigned long long id; - int if_malloc; - int type; + SID *s_id; + _Bool if_malloc; + _Bool if_sid; + unsigned int type; void *value; struct stack_node *next; } SNode; typedef struct stack{ unsigned long long id; + SID *s_id; unsigned long long length; SNode *top; + _Bool if_sid; } Stack; Stack *initStack(void); SNode *initSNode(void); -int initMallocValueForSNode(SNode *p_snode, int type, void *value); +int initMallocValueForSNode(SNode *p_snode, unsigned int type, void *value); SNode *popStack(Stack *p_stack); int pushStack(Stack *p_stack, SNode *p_snode); diff --git a/test.c b/test.c index 210d23f..c7a718b 100644 --- a/test.c +++ b/test.c @@ -3,7 +3,6 @@ int list(void) { List *t_list, *m_list;; - init_rand(); safeModeForNode(1); t_list = initList(); @@ -83,7 +82,12 @@ int stack(void) { int main(int argc, char **argv) { - tree(); + //tree(); + init_rand(); + SID *p_sid = getS_id(LIST_NODE, 3); + char *string = s_idToASCIIString(p_sid); + SID *t_sid = asciiStringToS_id(string); + int if_same = simFitS_id(p_sid, t_sid); getchar(); return 0; } diff --git a/tree/tree.c b/tree/tree.c index 5171631..519df76 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -1,7 +1,7 @@ #include"tree.h" -static unsigned long long target_id = 0; -static TNode *target_value_id = NULL; +static SID *target_sid = NULL; +static TNode *target_value_sid = NULL; static int if_safeModeForTree = 0; int safeModeForTree(int ifon) { @@ -31,7 +31,8 @@ int safeModeForTree(int ifon) { TNode *initTNode(void) { Node *s_node; TNode *p_tnode = (TNode *)malloc(sizeof(TNode)); - p_tnode->id = getId(); + p_tnode->id = getId(); + p_tnode->s_id = getS_id(TREE_NODE, 2); p_tnode->child_num = 0; p_tnode->father = NULL; p_tnode->if_malloc = 0; @@ -60,7 +61,8 @@ TNode *initTNode(void) { Tree *initTree(void) { Node *s_node; Tree *p_tree = (Tree *)malloc(sizeof(Tree)); - p_tree->id = getId(); + p_tree->id = getId(); + p_tree->s_id = getS_id(TREE, 1); p_tree->root = NULL; if (if_safeModeForTree) { if (if_safeModeForNode) { @@ -80,7 +82,7 @@ Tree *initTree(void) { return p_tree; } -int *initMallocValueForTNode(TNode *p_tnode, int type, void *value) { +int *initMallocValueForTNode(TNode *p_tnode, unsigned int type, void *value) { p_tnode->type = type; p_tnode->value = value; p_tnode->if_malloc = 1; @@ -144,22 +146,22 @@ int removeChildInRight(TNode *p_tnode) { } -TNode *getChildById(TNode *p_tnode, unsigned long long id) { +TNode *getChildById(TNode *p_tnode, const SID *s_id) { List *p_home = p_tnode->home; - target_id = 0; - target_value_id = NULL; + target_sid = NULL; + target_value_sid = NULL; listThrough(p_home, _dogetChildById); - if (target_value_id != NULL) { - return target_value_id; + if (target_value_sid != NULL) { + return target_value_sid; } return NULL; } -int _dogetChildById(int type, void *value) { +int _dogetChildById(unsigned int type, void *value) { if (type == POINTER) { TNode *p_tode = (TNode *)value; - if (p_tode->id == target_id) { - target_value_id = p_tode; + if (simFitS_id(p_tode->s_id, target_sid)) { + target_value_sid = p_tode; return -1; } } @@ -170,7 +172,7 @@ static int target_type = VOID; static void *target_value = NULL; static TNode *target_value_value = NULL; -TNode *getChildByValue(TNode *p_tnode, int type, void *value) { +TNode *getChildByValue(TNode *p_tnode, unsigned int type, void *value) { List *p_home = p_tnode->home; target_value = value; target_type = type; @@ -182,7 +184,7 @@ TNode *getChildByValue(TNode *p_tnode, int type, void *value) { return NULL; } -int _dogetChildByValue(int type, void *value) { +int _dogetChildByValue(unsigned int type, void *value) { if (type == target_type) { TNode *p_tode = (TNode *)value; if (target_type == INT) { @@ -221,12 +223,12 @@ int _dogetChildByValue(int type, void *value) { return 0; } -int removeChildById(TNode *p_tnode, unsigned long long id) { - TNode *t_tnode = getChildById(p_tnode, id); +int removeChildById(TNode *p_tnode, const SID *s_id) { + TNode *t_tnode = getChildById(p_tnode, s_id); if (t_tnode != NULL) { TNode *p_fnode = t_tnode->father; p_fnode->child_num--; - removeById(p_fnode->home, t_tnode->room->id); + removeById(p_fnode->home, t_tnode->room->s_id); releaseOnlyNode(t_tnode->room); t_tnode->room = NULL; return 0; @@ -234,12 +236,12 @@ int removeChildById(TNode *p_tnode, unsigned long long id) { return -1; } -int removeChildByValue(TNode *p_tnode, int type, void *value) { +int removeChildByValue(TNode *p_tnode, unsigned int type, void *value) { TNode *t_tnode = getChildByValue(p_tnode, type, value); if (t_tnode != NULL) { TNode *p_fnode = t_tnode->father; p_fnode->child_num--; - removeById(p_fnode->home, t_tnode->room->id); + removeById(p_fnode->home, t_tnode->room->s_id); releaseOnlyNode(t_tnode->room); t_tnode->room = NULL; return 0; @@ -282,7 +284,7 @@ int removeChildByIndex(TNode *p_tnode, unsigned long long index) { if (t_tnode != NULL) { TNode *p_fnode = t_tnode->father; p_fnode->child_num--; - removeById(p_fnode->home, t_tnode->room->id); + removeById(p_fnode->home, t_tnode->room->s_id); releaseOnlyNode(t_tnode->room); t_tnode->room = NULL; return 0; @@ -373,7 +375,7 @@ int releaseTNode(TNode *p_tnode) { if (p_tnode->child_num == 0) { releaseList(p_tnode->home); if (p_tnode->father != NULL) { - removeChildById(p_tnode->father, p_tnode->id); + removeChildById(p_tnode->father, p_tnode->s_id); } if (p_tnode->type != POINTER) { if (p_tnode->type == LIST) { diff --git a/tree/tree.h b/tree/tree.h index c2d950f..75afa5d 100644 --- a/tree/tree.h +++ b/tree/tree.h @@ -6,19 +6,23 @@ typedef struct tree_node { - unsigned long long id; + unsigned long long id; + SID *s_id; List *home; struct tree_node *father; Node *room; unsigned long long child_num; - int type; + unsigned int type; void *value; - int if_malloc; + _Bool if_malloc; + _Bool if_sid; }TNode; typedef struct tree { - unsigned long long id; + unsigned long long id; + SID *s_id; + _Bool if_sid; TNode *root; }Tree; @@ -28,7 +32,7 @@ int releaseAllForTree(void); TNode *initTNode(void); Tree *initTree(void); -int *initMallocValueForTNode(TNode *p_tnode, int type, void *value); +int *initMallocValueForTNode(TNode *p_tnode, unsigned int type, void *value); int addChildInLeft(TNode *f_tnode, TNode *c_tnode); int addChildInRight(TNode *f_tnode, TNode *c_tnode); @@ -36,19 +40,19 @@ TNode *getBrotherInLeft(TNode *p_tnode); TNode *getBrotherInRight(TNode *p_node); int removeChildInLeft(TNode *p_tnode); int removeChildInRight(TNode *p_tnode); -TNode *getChildById(TNode *p_tnode, unsigned long long id); -TNode *getChildByValue(TNode *p_tnode, int type, void *value); +TNode *getChildById(TNode *p_tnode, const SID *s_id); +TNode *getChildByValue(TNode *p_tnode, unsigned int type, void *value); TNode *getChildByIndex(TNode *p_tnode, unsigned long long index); unsigned long long getIndexByChild(TNode *f_tnode, TNode *c_tnode); -int removeChildById(TNode *p_tnode, unsigned long long id); +int removeChildById(TNode *p_tnode, const SID *s_id); int removeChildByIndex(TNode *p_tnode, unsigned long long index); -int removeChildByValue(TNode *p_tnode, int type, void *value); +int removeChildByValue(TNode *p_tnode, unsigned int type, void *value); int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); int TreeTravel(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); -int _dogetChildById(int type, void *value); -int _dogetChildByValue(int type, void *value); +int _dogetChildById(unsigned int type, void *value); +int _dogetChildByValue(unsigned int type, void *value); int _doreleaseTree(TNode *p_tnode, unsigned long long height); int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)); int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)); @@ -64,8 +68,8 @@ static int target_type; static void *target_value; static TNode *target_value_value; -static unsigned long long target_id; -static TNode *target_value_id; +static SID *target_sid; +static TNode *target_value_sid; static List *tree_list; static List *tnode_list; diff --git a/type/type.h b/type/type.h index cd7a83c..3dbb795 100644 --- a/type/type.h +++ b/type/type.h @@ -17,7 +17,20 @@ #define LIST 5 #define STACK 6 #define TREE 7 +#define LIST_NODE 8 +#define TREE_NODE 9 +#define STACK_NODE 10 +#define TYPE_LEN 5 +#define DEEPC 1 +#define DEEPB 2 +#define DEEPA 3 + +#define DEEPC_LEN 4 +#define DEEPB_LEN 8 +#define DEEPA_LEN 32 + +#define DATA_BIT 5 #endif /* type_h */ From 235e53d9b669342c65527c85c3870ef22fc92cc3 Mon Sep 17 00:00:00 2001 From: Saturneic Date: Mon, 30 Jul 2018 18:07:24 +0800 Subject: [PATCH 44/55] Fixed --- id/id.c | 17 +++++++++++++++++ id/id.h | 1 + list/list.c | 12 +++++------- list/list.h | 6 ++---- stack/stack.c | 6 ++---- stack/stack.h | 2 -- tree/tree.c | 16 +++++++--------- tree/tree.h | 6 ++---- 8 files changed, 36 insertions(+), 30 deletions(-) diff --git a/id/id.c b/id/id.c index e8a756d..0aa14fe 100644 --- a/id/id.c +++ b/id/id.c @@ -231,3 +231,20 @@ SID *asciiStringToS_id(const char *string){ } return s_id; } + +int freeS_id(SID *s_id){ + if(s_id->value != NULL){ + free(s_id->value); + s_id->value = NULL; + } + if(s_id->value_deeper != NULL){ + free(s_id->value_deeper); + s_id->value_deeper = NULL; + } + if(s_id->value_deepest != NULL){ + free(s_id->value_deepest); + s_id->value_deepest = NULL; + } + free(s_id); + return 0; +} diff --git a/id/id.h b/id/id.h index 894cd3c..57c8655 100644 --- a/id/id.h +++ b/id/id.h @@ -37,5 +37,6 @@ char *s_idToASCIIString(const SID *s_id); SID *asciiStringToS_id(const char *string); SID *initS_id(unsigned int deep_level); +int freeS_id(SID *s_id); #endif /* id_h */ diff --git a/list/list.c b/list/list.c index 96b45ac..7d2a6d4 100644 --- a/list/list.c +++ b/list/list.c @@ -82,7 +82,6 @@ int releaseAllForNode(void) { Node *initNode(void) { Node *p_node = (Node *)malloc(sizeof(Node)); Node *prec_node = NULL; - p_node->id = getId(); p_node->s_id = getS_id(LIST_NODE, 2); p_node->if_malloc = 0; p_node->next = NULL; @@ -101,7 +100,6 @@ Node *initNode(void) { List *initList(void) { Node *p_node; List *p_list = (List *)malloc(sizeof(List)); - p_list->id = getId(); p_list->s_id = getS_id(LIST, 1); p_list->head = NULL; p_list->tail = NULL; @@ -172,7 +170,7 @@ int releaseNode(Node *p_node) { p_node->next = NULL; p_node->type = VOID; p_node->value = NULL; - p_node->id = 0; + freeS_id(p_node->s_id); p_node->if_malloc = 0; free(p_node); return 0; @@ -196,7 +194,7 @@ int releaseList(List *p_list) { p_list->head = NULL; p_list->tail = NULL; p_list->length = 0; - p_list->id = 0; + freeS_id(p_list->s_id) free(p_list); return 0; } @@ -204,7 +202,7 @@ int releaseList(List *p_list) { int releaseListForSingle(List *p_list) { p_list->head = NULL; p_list->tail = NULL; - p_list->id = 0; + freeS_id(p_list->s_id); p_list->length = 0; free(p_list); return 0; @@ -424,7 +422,7 @@ int exchangeLocation(Node *p_node, Node *t_node) { Node *copyNode(Node *p_node) { Node *t_node = initNode(); - t_node->id = p_node->id; + t_node->s_id = p_node->s_id; t_node->last = p_node->last; t_node->next = p_node->next; t_node->if_malloc = p_node->if_malloc; @@ -450,7 +448,7 @@ List *copyList(List *p_list) { } int releaseOnlyNode(Node *p_node) { - p_node->id = 0; + freeS_id(p_node->s_id); p_node->if_malloc = 0; p_node->last = NULL; p_node->next = NULL; diff --git a/list/list.h b/list/list.h index cef010e..152ec2f 100644 --- a/list/list.h +++ b/list/list.h @@ -9,8 +9,7 @@ #include "../id/id.h" typedef struct Node{ - unsigned long long id;//唯一标识符 - SID *s_id; + SID *s_id;//唯一标识符 void *value; _Bool if_malloc;//记录是否已经初始化值 _Bool if_sid; @@ -21,8 +20,7 @@ typedef struct Node{ typedef struct List{ - unsigned long long id;//唯一标识符 - SID *s_id; + SID *s_id;//唯一标识符 Node *head; Node *tail; unsigned long long length;//链表长度 diff --git a/stack/stack.c b/stack/stack.c index 9689f86..66580bd 100644 --- a/stack/stack.c +++ b/stack/stack.c @@ -2,7 +2,6 @@ Stack *initStack(void) { Stack *p_stack = (Stack *)malloc(sizeof(Stack)); - p_stack->id = getId(); p_stack->s_id = getS_id(STACK, 1); p_stack->length = 0; p_stack->top = NULL; @@ -11,7 +10,6 @@ Stack *initStack(void) { SNode *initSNode(void) { SNode *p_snode = (SNode *)malloc(sizeof(SNode)); - p_snode->id = getId(); p_snode->s_id = getS_id(STACK_NODE, 2); p_snode->if_malloc = 0; p_snode->next = NULL; @@ -45,7 +43,7 @@ int releaseStack(Stack *p_stack) { p_sndoe = p_sndoe->next; releaseSNode(pl_snode); } - p_stack->id = 0; + freeS_id(p_stack->s_id); p_stack->top = NULL; p_stack->length = 0; free(p_stack); @@ -53,7 +51,7 @@ int releaseStack(Stack *p_stack) { } int releaseSNode(SNode *p_snode) { - p_snode->id = 0; + freeS_id(p_snode->s_id); free(p_snode->value); p_snode->if_malloc = 0; p_snode->value = NULL; diff --git a/stack/stack.h b/stack/stack.h index 9581f5b..7990edf 100644 --- a/stack/stack.h +++ b/stack/stack.h @@ -5,7 +5,6 @@ #include "../list/list_expand.h" typedef struct stack_node{ - unsigned long long id; SID *s_id; _Bool if_malloc; _Bool if_sid; @@ -15,7 +14,6 @@ typedef struct stack_node{ } SNode; typedef struct stack{ - unsigned long long id; SID *s_id; unsigned long long length; SNode *top; diff --git a/tree/tree.c b/tree/tree.c index 519df76..e9b4c87 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -30,8 +30,7 @@ int safeModeForTree(int ifon) { TNode *initTNode(void) { Node *s_node; - TNode *p_tnode = (TNode *)malloc(sizeof(TNode)); - p_tnode->id = getId(); + TNode *p_tnode = (TNode *)malloc(sizeof(TNode)); p_tnode->s_id = getS_id(TREE_NODE, 2); p_tnode->child_num = 0; p_tnode->father = NULL; @@ -60,8 +59,7 @@ TNode *initTNode(void) { Tree *initTree(void) { Node *s_node; - Tree *p_tree = (Tree *)malloc(sizeof(Tree)); - p_tree->id = getId(); + Tree *p_tree = (Tree *)malloc(sizeof(Tree)); p_tree->s_id = getS_id(TREE, 1); p_tree->root = NULL; if (if_safeModeForTree) { @@ -270,7 +268,7 @@ unsigned long long getIndexByChild(TNode *f_tnode, TNode *c_tnode) { int m_index = 0; while (p_node != NULL) { TNode *p_tnode = (TNode *)p_node->value; - if (p_tnode->id == c_tnode->id) { + if (p_tnode->s_id == c_tnode->s_id) { return m_index; } m_index++; @@ -387,7 +385,7 @@ int releaseTNode(TNode *p_tnode) { } p_tnode->value = NULL; p_tnode->type = VOID; - p_tnode->id = 0; + freeS_id(p_tnode->s_id); p_tnode->if_malloc = 0; free(p_tnode); } @@ -397,7 +395,7 @@ int releaseTNode(TNode *p_tnode) { int releaseTree(Tree *p_tree) { TreeThroughUp(p_tree, _doreleaseTree); p_tree->root = NULL; - p_tree->id = 0; + freeS_id(p_tree->s_id); free(p_tree); return 0; } @@ -408,7 +406,7 @@ int _doreleaseTree(TNode *p_tnode, unsigned long long height) { } int releaseOnlyTree(Tree *p_tree) { - p_tree->id = 0; + freeS_id(p_tree->s_id); p_tree->root = NULL; free(p_tree); return 0; @@ -428,7 +426,7 @@ int releaseOnlyTNode(TNode *p_tnode) { } p_tnode->value = NULL; p_tnode->type = VOID; - p_tnode->id = 0; + freeS_id(p_tnode->s_id); p_tnode->if_malloc = 0; free(p_tnode); return 0; diff --git a/tree/tree.h b/tree/tree.h index 75afa5d..f230b57 100644 --- a/tree/tree.h +++ b/tree/tree.h @@ -5,8 +5,7 @@ #include "../list/list_expand.h" typedef struct tree_node -{ - unsigned long long id; +{ SID *s_id; List *home; struct tree_node *father; @@ -19,8 +18,7 @@ typedef struct tree_node }TNode; typedef struct tree -{ - unsigned long long id; +{ SID *s_id; _Bool if_sid; TNode *root; From 56f677a22ba8e5c4f8072df1f18cf4984a0b36df Mon Sep 17 00:00:00 2001 From: Saturneic Date: Mon, 30 Jul 2018 18:18:58 +0800 Subject: [PATCH 45/55] Fixed --- list/list.c | 12 ++++++------ list/list_expand.c | 8 ++++---- tree/tree_expand.c | 12 ++++++------ 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/list/list.c b/list/list.c index 7d2a6d4..2734d38 100644 --- a/list/list.c +++ b/list/list.c @@ -33,7 +33,7 @@ int releaseSingleListForsafeModeForNode(List *p_list) { List *plv_node = NULL; while (p_node != NULL) { plv_node = (List *)p_node->value; - plv_node->id = 0; + freeS_id(plv_node->s_id); plv_node->head = NULL; plv_node->length = 0; plv_node->tail = NULL; @@ -43,7 +43,7 @@ int releaseSingleListForsafeModeForNode(List *p_list) { p_list->head = NULL; p_list->length = 0; p_list->tail = NULL; - p_list->id = 0; + freeS_id(p_list->s_id); free(p_list); return 0; } @@ -53,7 +53,7 @@ int releaseSingleNodeForsafeModeForNode(List *p_list) { Node *pnv_node = NULL; while (p_node != NULL) { pnv_node = (Node *)p_node->value; - pnv_node->id = 0; + freeS_id(pnv_node->s_id); pnv_node->if_malloc = 0; pnv_node->last = NULL; pnv_node->next = NULL; @@ -62,7 +62,7 @@ int releaseSingleNodeForsafeModeForNode(List *p_list) { free(pnv_node); p_node = p_node->next; } - p_list->id = 0; + free(p_list->s_id); p_list->head = NULL; p_list->length = 0; p_list->tail = NULL; @@ -194,7 +194,7 @@ int releaseList(List *p_list) { p_list->head = NULL; p_list->tail = NULL; p_list->length = 0; - freeS_id(p_list->s_id) + freeS_id(p_list->s_id); free(p_list); return 0; } @@ -437,7 +437,7 @@ List *copyList(List *p_list) { List *t_list = initList(); t_list->head = p_list->head; t_list->tail = p_list->tail; - t_list->id = p_list->id; + t_list->s_id = p_list->s_id; p_node = p_list->head; while (p_node != NULL) { t_node = copyNode(p_node); diff --git a/list/list_expand.c b/list/list_expand.c index d4b647a..84b8157 100644 --- a/list/list_expand.c +++ b/list/list_expand.c @@ -93,7 +93,7 @@ void printListInfo(List *p_list, int priority) { int i = 0; Node *p_node; for (i = 0; i < priority; i++) printf(" "); - printf("###LIST(location:%p, id:%llu){\n", p_list, p_list->id); + printf("###LIST(location:%p, id:%s){\n", p_list, s_idToASCIIString(p_list->s_id)); for (i = 0; i < priority + 1; i++) printf(" "); printf("HEAD->%p / Tail->%p / Length:%llu\n", p_list->head, p_list->tail, p_list->length); p_node = p_list->head; @@ -141,7 +141,7 @@ void printList(List *p_list) { void printNodeInfo(Node *p_node, int priority) { int i; for (i = 0; i < priority; i++) printf(" "); - printf("#NODE(location:%p, id:%llu){\n", p_node, p_node->id); + printf("#NODE(location:%p, id:%s){\n", p_node, s_idToASCIIString(p_node->s_id)); for (i = 0; i < priority + 1; i++) printf(" "); printf("NEXT->%p / LAST->%p / MALLOC:%d\n", p_node->next, p_node->last, p_node->if_malloc); if (p_node->type == INT) { @@ -171,7 +171,7 @@ void printNodeInfo(Node *p_node, int priority) { void printNode(Node *p_node) { int i; - printf("#NODE(location:%p, id:%llu){\n", p_node, p_node->id); + printf("#NODE(location:%p, id:%s){\n", p_node, s_idToASCIIString(p_node->s_id)); printf(" "); printf("NEXT->%p / LAST->%p\n", p_node->next, p_node->last); for (i = 0; i < 1; i++) printf(" "); @@ -321,7 +321,7 @@ unsigned long long getIndexByNode(List *p_list, Node *p_node) { Node *t_node = p_list->head; unsigned long long index = 0; while (t_node != NULL) { - if (p_node->id == t_node->id) return index; + if (p_node->s_id == t_node->s_id) return index; index++; t_node = t_node->next; } diff --git a/tree/tree_expand.c b/tree/tree_expand.c index 1f30a1f..48e891a 100644 --- a/tree/tree_expand.c +++ b/tree/tree_expand.c @@ -64,7 +64,7 @@ int printTNode(TNode *p_tnode, int priority) { if (priority == 0) printf("###"); else printf("#"); - printf("TNode(id: %llu)\n", p_tnode->id); + printf("TNode(id: %s)\n", s_idToASCIIString(p_tnode->s_id)); for (i = 0; i < priority + 1; i++) printf(" "); printf("ifMalloc: "); if (p_tnode->if_malloc) { @@ -102,7 +102,7 @@ int printTNodeWithHome(TNode *p_tnode,int priority) { if (p_tnode != NULL) { if (priority == 0) printf("###"); else printf("#"); - printf("TNode(id: %llu)\n", p_tnode->id); + printf("TNode(id: %s)\n", s_idToASCIIString(p_tnode->s_id)); for (i = 0; i < priority + 1; i++) printf(" "); printf("ifMalloc: "); if (p_tnode->if_malloc) { @@ -126,7 +126,7 @@ int printTNodeWithHome(TNode *p_tnode,int priority) { if (p_tnode->father != NULL) { for (i = 0; i < priority + 1; i++) printf(" "); - printf("Father id: %llu\n", p_tnode->father->id); + printf("Father id: %s\n", s_idToASCIIString(p_tnode->father->s_id)); } else { @@ -158,7 +158,7 @@ int printTNodeWithFamily(TNode *p_tnode, int priority) { for (i = 0; i < priority; i++) printf(" "); if (priority == 0) printf("###"); else printf("#"); - printf("TNode(id: %llu)\n", p_tnode->id); + printf("TNode(id: %s)\n", s_idToASCIIString(p_tnode->s_id)); for (i = 0; i < priority + 1; i++) printf(" "); printf("ifMalloc: "); if (p_tnode->if_malloc) { @@ -182,7 +182,7 @@ int printTNodeWithFamily(TNode *p_tnode, int priority) { if (p_tnode->father != NULL) { for (i = 0; i < priority + 1; i++) printf(" "); - printf("Father id: %llu\n", p_tnode->father->id); + printf("Father id: %s\n", s_idToASCIIString(p_tnode->father->s_id)); } else { @@ -208,7 +208,7 @@ int printTNodeWithFamily(TNode *p_tnode, int priority) { int printTree(Tree *p_tree) { printf("###"); - printf("Tree(id: %llu)",p_tree->id); + printf("Tree(id: %s)",s_idToASCIIString(p_tree->s_id)); printTNodeWithFamily(p_tree->root,0); return 0; } From 52202af67c6c82c2fd42fcf2bf1070d6332dc339 Mon Sep 17 00:00:00 2001 From: MapleSign <347495867@qq.com> Date: Thu, 2 Aug 2018 20:59:06 +0800 Subject: [PATCH 46/55] error nearly completed --- .gitignore | 1 + error/error.c | 102 +++++++++++++++++++++++++++++++++++++++++++-- error/error.h | 46 ++++++++++---------- list/list_expand.h | 2 +- 4 files changed, 122 insertions(+), 29 deletions(-) diff --git a/.gitignore b/.gitignore index 486a215..9db3cb7 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,4 @@ /.vs/ZE-Standard-Libraries/v15 /ZE-Standard-Libraries /ZE-Standard-Libraries.sln +/.vs diff --git a/error/error.c b/error/error.c index 424eb23..d3b8e66 100644 --- a/error/error.c +++ b/error/error.c @@ -1,6 +1,102 @@ #include "error.h" -int main(int argc, char **argv){ - - return 0; +int initErrorSystem(void) { + error_list = initList(); + notice_list = initList(); + if_error = 1; + return 1; } + +int setLogDirectory(const char *path) { + logfile.id = getId(); + int memory_space = strlen(path) + 256; + char *file_path = (char *)malloc(sizeof(char)*memory_space); + + //ļ· + strcat(file_path, path); + strcat(file_path, "log"); + sprintf(file_path, "%d", logfile.id); + + //ļ,ʧ,0 + if ((logfile.fp = fopen(file_path, "w")) == NULL) { + printf("Cannot set logfile!"); + return 0; + } + logfile.if_enable = 1; + + free(file_path); + return 1; +} + +int closeLogDirectory(void) { + Node *p = error_list->head; + while (p != NULL) { + saveError(p->value); + p = p->next; + } + + p = notice_list->head; + while (p != NULL) { + saveNotice(p->value); + p = p->next; + } + + releaseList(error_list); + releaseList(notice_list); + if_error = 0; + fclose(logfile.fp); + logfile.if_enable = 0; +} + +int loadFromFile(FILE *fp,char* number) { + + return 1; +} + +int pushInfo(Info *p_info, const char *head, const char *body) { + p_info->head = (char *)malloc(sizeof(char) * strlen(head)); + p_info->body = (char *)malloc(sizeof(char) * strlen(body)); + strcpy(p_info->head, head); + strcpy(p_info->body, body); +} + +int pushError(unsigned int type, int pri, Info *p_info) { + Error error; + error.type = type; + error.priority = pri; + error.p_info = p_info; + error.time = time(NULL); +} + +int pushNotice(unsigned int type, Info *p_info) { + Notice notice; + notice.type = type; + notice.p_info = p_info; + notice.time = time(NULL); +} + +static int saveError(Error *p_error) { + fprintf(logfile.fp, + "--------------------\n\ + ERROR\n\ + Type : %ud\n\ + Priority : %d\n\ + Time : %s\n\ + Info : \n\ + %s\n\ + %s\n\ + ---------------------\n", + p_error->type, p_error->priority, ctime( &(p_error->time) ), p_error->p_info->head, p_error->p_info->body); +} +static int saveNotice(Notice *p_notice) { + fprintf(logfile.fp, + "--------------------\n\ + NOTICE\n\ + Type : %ud\n\ + Time : %s\n\ + Info : \n\ + %s\n\ + %s\n\ + ----------------------\n", + p_notice->type, ctime( &(p_notice->time) ), p_notice->p_info->head, p_notice->p_info->body); +} \ No newline at end of file diff --git a/error/error.h b/error/error.h index e9499a1..fb342e7 100644 --- a/error/error.h +++ b/error/error.h @@ -1,4 +1,5 @@ -#include "../list/list_easy.h" +#include "../list/list_expand.h" +#include #include #ifndef ERROR_H @@ -6,24 +7,23 @@ #define HIGH 0x3 #define STANDARD 0x2 -#define LOW 0x1 +#define LOW 0x1 typedef struct Info{ char *head; char *body; - char *tail; }Info; typedef struct Error{ unsigned int type; - int pri; - Info info; + int priority; + Info *p_info; time_t time; }Error; typedef struct Notice{ unsigned int type; - Info *info; + Info *p_info; time_t time; }Notice; @@ -31,29 +31,25 @@ typedef struct Log{ FILE *fp; int if_enable; unsigned long int id; - unsigned int type; }Log; +Log logfile; List *error_list = NULL; -List *log_list = NULL; +List *notice_list = NULL; int if_error = 0; -int error_init(int if_enable); -int set_logDirectory(char *); -int push_error(unsigned int type, int pri, Info *p_info); -int push_notice(unsigned int type, Info *p_info); -int save_error(Error *p_error); -int save_notice(Notice *p_notice); -Info *init_Info(char *m_info); +int initErrorSystem(void); -int error_init(int if_enable){ - if(if_enable == 1){ - error_list = init_list(); - log_list = init_list(); - if_error = 1; - return 1; - } - return 0; -} +int setLogDirectory(const char *path); +int closeLogDirectory(void); +int loadFromFile(FILE *fp,char* number); -#endif +int pushInfo(Info *p_info, const char *head,const char *body); +int pushError(unsigned int type, int pri, Info *p_info); +int pushNotice(unsigned int type, Info *p_info); + +//Ϊ֤Чк +static int saveError(Error *p_error); +static int saveNotice(Notice *p_notice); + +#endif \ No newline at end of file diff --git a/list/list_expand.h b/list/list_expand.h index 4abcd23..cc60f4a 100644 --- a/list/list_expand.h +++ b/list/list_expand.h @@ -1,6 +1,6 @@ #ifndef LIST_EXPAND_H #define LIST_EXPAND_H -#include "list.h" +#include "list.c" Node *nodeWithInt(int);//快速初始化一个单一值节点并赋值 Node *nodeWithDouble(double);//快速初始化一个节单一值点并赋值 From db733887f649ff576b32bcaeab049a719a029209 Mon Sep 17 00:00:00 2001 From: Saturneic Date: Fri, 3 Aug 2018 11:15:27 +0800 Subject: [PATCH 47/55] Test. --- .../project.pbxproj | 48 +++++++++++++++++++ .../xcdebugger/Breakpoints_v2.xcbkptlist | 4 +- test.c | 2 +- 3 files changed, 51 insertions(+), 3 deletions(-) diff --git a/ZE-Standard-Libraries.xcodeproj/project.pbxproj b/ZE-Standard-Libraries.xcodeproj/project.pbxproj index 0d05af7..8cfb00e 100644 --- a/ZE-Standard-Libraries.xcodeproj/project.pbxproj +++ b/ZE-Standard-Libraries.xcodeproj/project.pbxproj @@ -8,6 +8,13 @@ /* Begin PBXBuildFile section */ 9246995F20CE655900B4E894 /* tree.c in Sources */ = {isa = PBXBuildFile; fileRef = 9246995E20CE655900B4E894 /* tree.c */; }; + 9269D4E8210F1B3D00161557 /* stack_expand.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4E7210F1B3D00161557 /* stack_expand.c */; }; + 9269D4EA210F1B4B00161557 /* list_expand.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4E9210F1B4B00161557 /* list_expand.c */; }; + 9269D4ED210F1B5E00161557 /* test.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4EB210F1B5E00161557 /* test.c */; }; + 9269D4F4210F1BB000161557 /* id.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4F2210F1BB000161557 /* id.c */; }; + 9269D4F5210F1BCE00161557 /* list.c in Sources */ = {isa = PBXBuildFile; fileRef = 9246994F20CD000300B4E894 /* list.c */; }; + 9269D4F6210F1CD900161557 /* stack.c in Sources */ = {isa = PBXBuildFile; fileRef = 9246995920CE52A700B4E894 /* stack.c */; }; + 9269D4F8210F1D0B00161557 /* tree_expand.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4F7210F1D0B00161557 /* tree_expand.c */; }; /* End PBXBuildFile section */ /* Begin PBXCopyFilesBuildPhase section */ @@ -31,6 +38,15 @@ 9246995B20CE5C8900B4E894 /* stack_expand.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = stack_expand.h; sourceTree = ""; }; 9246995D20CE655900B4E894 /* tree.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = tree.h; sourceTree = ""; }; 9246995E20CE655900B4E894 /* tree.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = tree.c; sourceTree = ""; }; + 9269D4E7210F1B3D00161557 /* stack_expand.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = stack_expand.c; sourceTree = ""; }; + 9269D4E9210F1B4B00161557 /* list_expand.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = list_expand.c; sourceTree = ""; }; + 9269D4EB210F1B5E00161557 /* test.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = test.c; sourceTree = ""; }; + 9269D4EC210F1B5E00161557 /* test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = test.h; sourceTree = ""; }; + 9269D4F0210F1B8000161557 /* type.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = type.h; path = type/type.h; sourceTree = ""; }; + 9269D4F2210F1BB000161557 /* id.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = id.c; path = id/id.c; sourceTree = ""; }; + 9269D4F3210F1BB000161557 /* id.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = id.h; path = id/id.h; sourceTree = ""; }; + 9269D4F7210F1D0B00161557 /* tree_expand.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = tree_expand.c; sourceTree = ""; }; + 9269D4F9210F1D0F00161557 /* tree_expand.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = tree_expand.h; sourceTree = ""; }; 927993BD20CB87D6008CE3A9 /* ZE-Standard-Libraries */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "ZE-Standard-Libraries"; sourceTree = BUILT_PRODUCTS_DIR; }; /* End PBXFileReference section */ @@ -50,6 +66,7 @@ children = ( 9246994F20CD000300B4E894 /* list.c */, 9246995020CD000300B4E894 /* list_expand.h */, + 9269D4E9210F1B4B00161557 /* list_expand.c */, 9246995120CD000300B4E894 /* list.h */, ); path = list; @@ -60,6 +77,7 @@ children = ( 9246995820CE52A700B4E894 /* stack.h */, 9246995920CE52A700B4E894 /* stack.c */, + 9269D4E7210F1B3D00161557 /* stack_expand.c */, 9246995B20CE5C8900B4E894 /* stack_expand.h */, ); path = stack; @@ -70,16 +88,39 @@ children = ( 9246995D20CE655900B4E894 /* tree.h */, 9246995E20CE655900B4E894 /* tree.c */, + 9269D4F9210F1D0F00161557 /* tree_expand.h */, + 9269D4F7210F1D0B00161557 /* tree_expand.c */, ); path = tree; sourceTree = ""; }; + 9269D4EF210F1B7800161557 /* type */ = { + isa = PBXGroup; + children = ( + 9269D4F0210F1B8000161557 /* type.h */, + ); + name = type; + sourceTree = ""; + }; + 9269D4F1210F1B9E00161557 /* id */ = { + isa = PBXGroup; + children = ( + 9269D4F2210F1BB000161557 /* id.c */, + 9269D4F3210F1BB000161557 /* id.h */, + ); + name = id; + sourceTree = ""; + }; 927993B420CB87D6008CE3A9 = { isa = PBXGroup; children = ( + 9269D4F1210F1B9E00161557 /* id */, + 9269D4EF210F1B7800161557 /* type */, 9246995C20CE654600B4E894 /* tree */, 9246995720CE507900B4E894 /* stack */, 9246994E20CD000300B4E894 /* list */, + 9269D4EB210F1B5E00161557 /* test.c */, + 9269D4EC210F1B5E00161557 /* test.h */, 927993BE20CB87D6008CE3A9 /* Products */, ); sourceTree = ""; @@ -148,7 +189,14 @@ isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( + 9269D4F6210F1CD900161557 /* stack.c in Sources */, + 9269D4F5210F1BCE00161557 /* list.c in Sources */, + 9269D4E8210F1B3D00161557 /* stack_expand.c in Sources */, + 9269D4EA210F1B4B00161557 /* list_expand.c in Sources */, + 9269D4F4210F1BB000161557 /* id.c in Sources */, + 9269D4F8210F1D0B00161557 /* tree_expand.c in Sources */, 9246995F20CE655900B4E894 /* tree.c in Sources */, + 9269D4ED210F1B5E00161557 /* test.c in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; diff --git a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist index f56e272..1818a6b 100644 --- a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist +++ b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist @@ -154,7 +154,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "test.c" - timestampString = "554017478.314317" + timestampString = "554639003.5850461" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "64" @@ -170,7 +170,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "tree/tree_expand.c" - timestampString = "554017478.3148969" + timestampString = "554638722.806551" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "60" diff --git a/test.c b/test.c index c7a718b..8ce8cfe 100644 --- a/test.c +++ b/test.c @@ -84,7 +84,7 @@ int stack(void) { int main(int argc, char **argv) { //tree(); init_rand(); - SID *p_sid = getS_id(LIST_NODE, 3); + SID *p_sid = getS_id(LIST_NODE, 1); char *string = s_idToASCIIString(p_sid); SID *t_sid = asciiStringToS_id(string); int if_same = simFitS_id(p_sid, t_sid); From 5a96a5ab9eea706a64e4d928981761907dd8dd7d Mon Sep 17 00:00:00 2001 From: Saturneic Date: Fri, 3 Aug 2018 11:38:19 +0800 Subject: [PATCH 48/55] Fixed. --- .../project.pbxproj | 30 +++++++++- .../xcdebugger/Breakpoints_v2.xcbkptlist | 2 +- communicate/communicate.c | 8 --- communicate/communicate.h | 8 --- error/error.c | 14 +++-- id/id.c | 11 +--- id/id.h | 2 - list/list.c | 4 +- list/list.h | 49 +++++++-------- list/list_expand.h | 59 +++++++++---------- type/type.h | 8 --- 11 files changed, 94 insertions(+), 101 deletions(-) diff --git a/ZE-Standard-Libraries.xcodeproj/project.pbxproj b/ZE-Standard-Libraries.xcodeproj/project.pbxproj index 8cfb00e..f464100 100644 --- a/ZE-Standard-Libraries.xcodeproj/project.pbxproj +++ b/ZE-Standard-Libraries.xcodeproj/project.pbxproj @@ -15,6 +15,8 @@ 9269D4F5210F1BCE00161557 /* list.c in Sources */ = {isa = PBXBuildFile; fileRef = 9246994F20CD000300B4E894 /* list.c */; }; 9269D4F6210F1CD900161557 /* stack.c in Sources */ = {isa = PBXBuildFile; fileRef = 9246995920CE52A700B4E894 /* stack.c */; }; 9269D4F8210F1D0B00161557 /* tree_expand.c in Sources */ = {isa = PBXBuildFile; fileRef = 9269D4F7210F1D0B00161557 /* tree_expand.c */; }; + 9286EB7A211400C900752977 /* error.c in Sources */ = {isa = PBXBuildFile; fileRef = 9286EB79211400C900752977 /* error.c */; }; + 9286EB7E2114022A00752977 /* communicate.c in Sources */ = {isa = PBXBuildFile; fileRef = 9286EB7D2114022A00752977 /* communicate.c */; }; /* End PBXBuildFile section */ /* Begin PBXCopyFilesBuildPhase section */ @@ -48,6 +50,10 @@ 9269D4F7210F1D0B00161557 /* tree_expand.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = tree_expand.c; sourceTree = ""; }; 9269D4F9210F1D0F00161557 /* tree_expand.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = tree_expand.h; sourceTree = ""; }; 927993BD20CB87D6008CE3A9 /* ZE-Standard-Libraries */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "ZE-Standard-Libraries"; sourceTree = BUILT_PRODUCTS_DIR; }; + 9286EB79211400C900752977 /* error.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = error.c; path = error/error.c; sourceTree = ""; }; + 9286EB7B211400D000752977 /* error.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = error.h; path = error/error.h; sourceTree = ""; }; + 9286EB7D2114022A00752977 /* communicate.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = communicate.c; path = communicate/communicate.c; sourceTree = ""; }; + 9286EB7F2114022F00752977 /* communicate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = communicate.h; path = communicate/communicate.h; sourceTree = ""; }; /* End PBXFileReference section */ /* Begin PBXFrameworksBuildPhase section */ @@ -114,6 +120,8 @@ 927993B420CB87D6008CE3A9 = { isa = PBXGroup; children = ( + 9286EB7C2114021E00752977 /* communicate */, + 9286EB78211400BD00752977 /* error */, 9269D4F1210F1B9E00161557 /* id */, 9269D4EF210F1B7800161557 /* type */, 9246995C20CE654600B4E894 /* tree */, @@ -133,6 +141,24 @@ name = Products; sourceTree = ""; }; + 9286EB78211400BD00752977 /* error */ = { + isa = PBXGroup; + children = ( + 9286EB79211400C900752977 /* error.c */, + 9286EB7B211400D000752977 /* error.h */, + ); + name = error; + sourceTree = ""; + }; + 9286EB7C2114021E00752977 /* communicate */ = { + isa = PBXGroup; + children = ( + 9286EB7F2114022F00752977 /* communicate.h */, + 9286EB7D2114022A00752977 /* communicate.c */, + ); + name = communicate; + sourceTree = ""; + }; /* End PBXGroup section */ /* Begin PBXNativeTarget section */ @@ -190,13 +216,15 @@ buildActionMask = 2147483647; files = ( 9269D4F6210F1CD900161557 /* stack.c in Sources */, - 9269D4F5210F1BCE00161557 /* list.c in Sources */, + 9286EB7A211400C900752977 /* error.c in Sources */, 9269D4E8210F1B3D00161557 /* stack_expand.c in Sources */, + 9286EB7E2114022A00752977 /* communicate.c in Sources */, 9269D4EA210F1B4B00161557 /* list_expand.c in Sources */, 9269D4F4210F1BB000161557 /* id.c in Sources */, 9269D4F8210F1D0B00161557 /* tree_expand.c in Sources */, 9246995F20CE655900B4E894 /* tree.c in Sources */, 9269D4ED210F1B5E00161557 /* test.c in Sources */, + 9269D4F5210F1BCE00161557 /* list.c in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; diff --git a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist index 1818a6b..c5081b3 100644 --- a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist +++ b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist @@ -154,7 +154,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "test.c" - timestampString = "554639003.5850461" + timestampString = "554959944.593868" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "64" diff --git a/communicate/communicate.c b/communicate/communicate.c index 97e91a1..32dc9ac 100644 --- a/communicate/communicate.c +++ b/communicate/communicate.c @@ -1,9 +1 @@ -// -// communicate.c -// ZE-Standard-Libraries -// -// Created by 胡一兵 on 2018/7/25. -// Copyright © 2018年 ZE. All rights reserved. -// - #include "communicate.h" diff --git a/communicate/communicate.h b/communicate/communicate.h index 4dde066..4798a3f 100644 --- a/communicate/communicate.h +++ b/communicate/communicate.h @@ -1,11 +1,3 @@ -// -// communicate.h -// ZE-Standard-Libraries -// -// Created by 胡一兵 on 2018/7/25. -// Copyright © 2018年 ZE. All rights reserved. -// - #ifndef communicate_h #define communicate_h diff --git a/error/error.c b/error/error.c index d3b8e66..f11f8b5 100644 --- a/error/error.c +++ b/error/error.c @@ -9,15 +9,13 @@ int initErrorSystem(void) { int setLogDirectory(const char *path) { logfile.id = getId(); - int memory_space = strlen(path) + 256; + unsigned long memory_space = strlen(path) + 256; char *file_path = (char *)malloc(sizeof(char)*memory_space); - //ļ· strcat(file_path, path); strcat(file_path, "log"); - sprintf(file_path, "%d", logfile.id); + sprintf(file_path, "%lu", logfile.id); - //ļ,ʧ,0 if ((logfile.fp = fopen(file_path, "w")) == NULL) { printf("Cannot set logfile!"); return 0; @@ -46,6 +44,7 @@ int closeLogDirectory(void) { if_error = 0; fclose(logfile.fp); logfile.if_enable = 0; + return 0; } int loadFromFile(FILE *fp,char* number) { @@ -58,6 +57,7 @@ int pushInfo(Info *p_info, const char *head, const char *body) { p_info->body = (char *)malloc(sizeof(char) * strlen(body)); strcpy(p_info->head, head); strcpy(p_info->body, body); + return 0; } int pushError(unsigned int type, int pri, Info *p_info) { @@ -66,6 +66,7 @@ int pushError(unsigned int type, int pri, Info *p_info) { error.priority = pri; error.p_info = p_info; error.time = time(NULL); + return 0; } int pushNotice(unsigned int type, Info *p_info) { @@ -73,6 +74,7 @@ int pushNotice(unsigned int type, Info *p_info) { notice.type = type; notice.p_info = p_info; notice.time = time(NULL); + return 0; } static int saveError(Error *p_error) { @@ -87,6 +89,7 @@ static int saveError(Error *p_error) { %s\n\ ---------------------\n", p_error->type, p_error->priority, ctime( &(p_error->time) ), p_error->p_info->head, p_error->p_info->body); + return 0; } static int saveNotice(Notice *p_notice) { fprintf(logfile.fp, @@ -99,4 +102,5 @@ static int saveNotice(Notice *p_notice) { %s\n\ ----------------------\n", p_notice->type, ctime( &(p_notice->time) ), p_notice->p_info->head, p_notice->p_info->body); -} \ No newline at end of file + return 0; +} diff --git a/id/id.c b/id/id.c index 0aa14fe..a9ebb3f 100644 --- a/id/id.c +++ b/id/id.c @@ -1,11 +1,3 @@ -// -// id.c -// ZE-Standard-Libraries -// -// Created by 胡一兵 on 2018/7/25. -// Copyright © 2018年 ZE. All rights reserved. -// - #include "id.h" void init_rand(void) { @@ -181,7 +173,7 @@ char *s_idToASCIIString(const SID *s_id){ SID *asciiStringToS_id(const char *string){ SID *s_id = NULL; unsigned long long string_len = strlen(string); - unsigned int buff[string_len - 1]; + unsigned int *buff = (unsigned int *) malloc(sizeof(string_len - 1)); for(int i = 0; i < string_len; i++){ buff[i] = string[i] - 48; } @@ -229,6 +221,7 @@ SID *asciiStringToS_id(const char *string){ (*s_id->value_deepest)[i] /= 10; } } + free(buff); return s_id; } diff --git a/id/id.h b/id/id.h index 57c8655..9c8a038 100644 --- a/id/id.h +++ b/id/id.h @@ -23,11 +23,9 @@ typedef struct s_id{ unsigned int deep; }SID; -/*有关id的函数*/ void init_rand(void); unsigned long long getId(void); -/*有关s_id函数*/ SID *getS_id(unsigned int type ,unsigned int deep_level); int fitS_id(const SID *fs_id, const SID *ss_id); diff --git a/list/list.c b/list/list.c index 2734d38..c392166 100644 --- a/list/list.c +++ b/list/list.c @@ -1,8 +1,8 @@ #include "list.h" static int if_safeModeForNode = 0; -static List *node_list = NULL; //储存声明过的节点. -static List *list_list = NULL; //储存声明过的链表. +static List *node_list = NULL; +static List *list_list = NULL; int safeModeForNode(int ifon) { if (ifon == 1) { diff --git a/list/list.h b/list/list.h index 152ec2f..f43248f 100644 --- a/list/list.h +++ b/list/list.h @@ -9,66 +9,61 @@ #include "../id/id.h" typedef struct Node{ - SID *s_id;//唯一标识符 + SID *s_id; void *value; - _Bool if_malloc;//记录是否已经初始化值 + _Bool if_malloc; _Bool if_sid; - unsigned int type;//记录值的类型 + unsigned int type; struct Node *next; struct Node *last; } Node; typedef struct List{ - SID *s_id;//唯一标识符 + SID *s_id; Node *head; Node *tail; - unsigned long long length;//链表长度 + unsigned long long length; } List; -int safeModeForNode(int ifon);//安全模式确保显式声明过的内存都会被释放 -int releaseSingleListForsafeModeForNode(List *p_list);//释放list_list -int releaseSingleNodeForsafeModeForNode(List *p_list);//释放node_list -int releaseAllForNode(void);//安全模式最后调用的函数 +int safeModeForNode(int ifon); +int releaseSingleListForsafeModeForNode(List *p_list); +int releaseSingleNodeForsafeModeForNode(List *p_list); +int releaseAllForNode(void); List *initList(void); Node *initNode(void); -int initMallocValueForNode(Node *,unsigned int,void *);//赋予已分配内存的值，并标明类型 +int initMallocValueForNode(Node *,unsigned int,void *); -/*插入函数*/ int insertInHead(List *p_list, Node *p_node); int insertInTail(List *p_list, Node *p_node); -/*交换函数*/ int exchangeLocation(Node *p_node,Node *t_node); -/*复制函数*/ Node *copyNode(Node *); -/*移除函数*/ int removeById(List *p_list, const SID *s_id); int removeByNode(List *p_list, Node *p_node); int popFromHead(List *p_list); int popFromTail(List *p_list); -unsigned long long len(List *p_list);//查看链表的长度 +unsigned long long len(List *p_list); -Node *findByIdForNode(List *p_list, const SID *s_id);//通过id查找目标链表中的匹配节点 -Node *findByValue(List *p_list, unsigned int type, const void *value);//通过值来查找目标链表中的匹配节点 -List *mply_findByValue(List *p_list, unsigned int type, const void *value);//寻找多个值匹配的节点 +Node *findByIdForNode(List *p_list, const SID *s_id); +Node *findByValue(List *p_list, unsigned int type, const void *value); +List *mply_findByValue(List *p_list, unsigned int type, const void *value); -int releaseList(List *p_list);//释放List并可选择是否释放中所有的其中的Node -int releaseListForSingle(List *p_list);//单独释放List -int releaseNode(Node *p_node);//释放Node -int releaseOnlyNode(Node *p_node);//释放Node +int releaseList(List *p_list); +int releaseListForSingle(List *p_list); +int releaseNode(Node *p_node); +int releaseOnlyNode(Node *p_node); -int isListEmpty(List *p_list);//判断List是否为空 -List *copyList(List *p_list);//复制链表 +int isListEmpty(List *p_list); +List *copyList(List *p_list); -/*有关安全模式的变量*/ static int if_safeModeForNode; -static List *node_list; //储存声明过的节点. -static List *list_list; //储存声明过的链表. +static List *node_list; +static List *list_list; #endif diff --git a/list/list_expand.h b/list/list_expand.h index cc60f4a..63bb773 100644 --- a/list/list_expand.h +++ b/list/list_expand.h @@ -1,42 +1,41 @@ #ifndef LIST_EXPAND_H #define LIST_EXPAND_H -#include "list.c" +#include "list.h" -Node *nodeWithInt(int);//快速初始化一个单一值节点并赋值 -Node *nodeWithDouble(double);//快速初始化一个节单一值点并赋值 -Node *nodeWithString(const char *);//快速初始化一个单一值节点并赋值 -Node *nodeWithPointer(void *);//快速初始化一个单一值节点并赋值 +Node *nodeWithInt(int); +Node *nodeWithDouble(double); +Node *nodeWithString(const char *); +Node *nodeWithPointer(void *); -Node *nodeWithComplex(void);//快速初始化一个复合值节点并赋值 -int addValueForComplex(Node *, int type, void *value);//为复合节点添加值 -int addIntForComplex(Node *, int);//为复合节点添加一个特定类型的值 -int addDoubleForComplex(Node *, double);//为复合节点添加一个特定类型的值 -int addStringForComplex(Node *, char *);//为复合节点添加一个特定类型的值 -int addPointerForComplex(Node *, void *);//为复合节点添加一个特定类型的值 +Node *nodeWithComplex(void); +int addValueForComplex(Node *, int type, void *value); +int addIntForComplex(Node *, int); +int addDoubleForComplex(Node *, double); +int addStringForComplex(Node *, char *); +int addPointerForComplex(Node *, void *); -Node *findByIndexForNode(List *, unsigned long long);//根据位置查找一个节点 -Node *findByIntForNode(List *, int);//依照特定类型查找一个节点 -Node *findByDoubleForNode(List *, double);//依照特定类型查找一个节点 -Node *findByStringForNode(List *, char *);//依照特定类型查找一个节点 -Node *findByPointerForNode(List *, void *);//依照特定类型查找一个节点 +Node *findByIndexForNode(List *, unsigned long long); +Node *findByIntForNode(List *, int); +Node *findByDoubleForNode(List *, double); +Node *findByStringForNode(List *, char *); +Node *findByPointerForNode(List *, void *); -List *m_findByIntForNode(List*, int);//根据位置查找所有匹配的节点 -List *m_findByDoubleForNode(List*, double);//根据位置查找所有匹配的节点 -List *m_findByStringForNode(List*, char *);//根据位置查找所有匹配的节点 -List *m_findByPointerForNode(List*, void *);//根据位置查找所有匹配的节点 +List *m_findByIntForNode(List*, int); +List *m_findByDoubleForNode(List*, double); +List *m_findByStringForNode(List*, char *); +List *m_findByPointerForNode(List*, void *); -void printListInfo(List *p_list,int priority);//打印列表的详细信息 -void printNodeInfo(Node *p_node,int priority);//打印节点的详细信息 -void printList(List *);//打印列表 -void printNode(Node *p_node);//打印节点 +void printListInfo(List *p_list,int priority); +void printNodeInfo(Node *p_node,int priority); +void printList(List *); +void printNode(Node *p_node); -int getByIntForNode(Node *);//直接得到节点的值 -double getByDoubleForNode(Node *);//直接得到节点的值 -char *getByStringForNode(Node *);//直接得到节点的值 -void *getByPointerForNode(Node *);//直接得到节点的值 +int getByIntForNode(Node *); +double getByDoubleForNode(Node *); +char *getByStringForNode(Node *); +void *getByPointerForNode(Node *); unsigned long long getIndexByNode(List *p_list,Node *p_node); -int listThrough(List *p_list, int (*p_func)(unsigned int type, void *value));//遍历链表并不断调用目标函数。目标函数将接受节点储存值的指针及其类型。 - +int listThrough(List *p_list, int (*p_func)(unsigned int type, void *value)); unsigned long long calListMemory(List *); #endif diff --git a/type/type.h b/type/type.h index 3dbb795..af3ee92 100644 --- a/type/type.h +++ b/type/type.h @@ -1,11 +1,3 @@ -// -// type.h -// ZE-Standard-Libraries -// -// Created by 胡一兵 on 2018/7/23. -// Copyright © 2018年 ZE. All rights reserved. -// - #ifndef type_h #define type_h From 498d988a5ed82bdba81596a4da8e195b193092ec Mon Sep 17 00:00:00 2001 From: Saturneic Date: Fri, 3 Aug 2018 18:32:20 +0800 Subject: [PATCH 49/55] Added some functions and fixed. --- .../project.pbxproj | 8 + .../xcdebugger/Expressions.xcexplist | 46 ++- .../xcdebugger/Breakpoints_v2.xcbkptlist | 341 +++++++++++++++++- error/error.c | 33 +- error/error.h | 45 +-- id/id.c | 88 ++--- id/id.h | 18 +- list/list.c | 97 ++++- list/list.h | 35 +- list/list_expand.h | 3 +- stack/stack.h | 2 - stack/stack_expand.h | 1 - test.c | 7 +- test.h | 4 +- tree/tree.c | 6 +- tree/tree.h | 21 -- type/type.h | 86 ++++- 17 files changed, 638 insertions(+), 203 deletions(-) diff --git a/ZE-Standard-Libraries.xcodeproj/project.pbxproj b/ZE-Standard-Libraries.xcodeproj/project.pbxproj index f464100..2186f17 100644 --- a/ZE-Standard-Libraries.xcodeproj/project.pbxproj +++ b/ZE-Standard-Libraries.xcodeproj/project.pbxproj @@ -120,6 +120,7 @@ 927993B420CB87D6008CE3A9 = { isa = PBXGroup; children = ( + 92A15CFC211442C700826FB8 /* graph */, 9286EB7C2114021E00752977 /* communicate */, 9286EB78211400BD00752977 /* error */, 9269D4F1210F1B9E00161557 /* id */, @@ -159,6 +160,13 @@ name = communicate; sourceTree = ""; }; + 92A15CFC211442C700826FB8 /* graph */ = { + isa = PBXGroup; + children = ( + ); + name = graph; + sourceTree = ""; + }; /* End PBXGroup section */ /* Begin PBXNativeTarget section */ diff --git a/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist b/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist index 12f5903..d8ca57a 100644 --- a/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist +++ b/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist @@ -3,10 +3,33 @@ version = "1.0"> + contextName = "freeS_id:id.c"> + + + value = "buff[string_len-1]"> + + + + + + + + + + + + + + @@ -27,8 +50,27 @@ + + + + + + + + + + + + + + diff --git a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist index c5081b3..2c76f28 100644 --- a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist +++ b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist @@ -154,7 +154,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "test.c" - timestampString = "554959944.593868" + timestampString = "554985107.001519" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "64" @@ -179,5 +179,344 @@ landmarkType = "9"> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/error/error.c b/error/error.c index f11f8b5..0b34a2f 100644 --- a/error/error.c +++ b/error/error.c @@ -52,32 +52,7 @@ int loadFromFile(FILE *fp,char* number) { return 1; } -int pushInfo(Info *p_info, const char *head, const char *body) { - p_info->head = (char *)malloc(sizeof(char) * strlen(head)); - p_info->body = (char *)malloc(sizeof(char) * strlen(body)); - strcpy(p_info->head, head); - strcpy(p_info->body, body); - return 0; -} - -int pushError(unsigned int type, int pri, Info *p_info) { - Error error; - error.type = type; - error.priority = pri; - error.p_info = p_info; - error.time = time(NULL); - return 0; -} - -int pushNotice(unsigned int type, Info *p_info) { - Notice notice; - notice.type = type; - notice.p_info = p_info; - notice.time = time(NULL); - return 0; -} - -static int saveError(Error *p_error) { +int saveError(Error *p_error) { fprintf(logfile.fp, "--------------------\n\ ERROR\n\ @@ -88,10 +63,10 @@ static int saveError(Error *p_error) { %s\n\ %s\n\ ---------------------\n", - p_error->type, p_error->priority, ctime( &(p_error->time) ), p_error->p_info->head, p_error->p_info->body); + p_error->type, p_error->priority, ctime( &(p_error->time) ), p_error->info.head, p_error->info.body); return 0; } -static int saveNotice(Notice *p_notice) { +int saveNotice(Notice *p_notice) { fprintf(logfile.fp, "--------------------\n\ NOTICE\n\ @@ -101,6 +76,6 @@ static int saveNotice(Notice *p_notice) { %s\n\ %s\n\ ----------------------\n", - p_notice->type, ctime( &(p_notice->time) ), p_notice->p_info->head, p_notice->p_info->body); + p_notice->type, ctime( &(p_notice->time) ), p_notice->info.head, p_notice->info.body); return 0; } diff --git a/error/error.h b/error/error.h index fb342e7..f1e8d41 100644 --- a/error/error.h +++ b/error/error.h @@ -1,37 +1,8 @@ -#include "../list/list_expand.h" -#include -#include - #ifndef ERROR_H #define ERROR_H -#define HIGH 0x3 -#define STANDARD 0x2 -#define LOW 0x1 - -typedef struct Info{ - char *head; - char *body; -}Info; - -typedef struct Error{ - unsigned int type; - int priority; - Info *p_info; - time_t time; -}Error; - -typedef struct Notice{ - unsigned int type; - Info *p_info; - time_t time; -}Notice; - -typedef struct Log{ - FILE *fp; - int if_enable; - unsigned long int id; -}Log; +#include "../type/type.h" +#include "../list/list_expand.h" Log logfile; List *error_list = NULL; @@ -42,14 +13,10 @@ int initErrorSystem(void); int setLogDirectory(const char *path); int closeLogDirectory(void); + int loadFromFile(FILE *fp,char* number); -int pushInfo(Info *p_info, const char *head,const char *body); -int pushError(unsigned int type, int pri, Info *p_info); -int pushNotice(unsigned int type, Info *p_info); +int saveError(Error *p_error); +int saveNotice(Notice *p_notice); -//Ϊ֤Чк -static int saveError(Error *p_error); -static int saveNotice(Notice *p_notice); - -#endif \ No newline at end of file +#endif diff --git a/id/id.c b/id/id.c index a9ebb3f..22960d3 100644 --- a/id/id.c +++ b/id/id.c @@ -16,36 +16,25 @@ unsigned long long getId(void) { } SID *initS_id(unsigned int deep_level){ - SID *p_sid = (SID *)malloc(sizeof(SID)); + SID *p_sid = (SID *) malloc(sizeof(SID)); p_sid->type = VOID; p_sid->deep = deep_level; p_sid->value = NULL; p_sid->value_deeper = NULL; p_sid->value_deepest = NULL; - if (deep_level > 0) p_sid->value = (unsigned int (*)[DEEPC_LEN])malloc(sizeof(unsigned int)*DEEPC_LEN); - if (deep_level > 1) p_sid->value_deeper = (unsigned int (*)[DEEPB_LEN])malloc(sizeof(unsigned int)*DEEPB_LEN); - if (deep_level > 2) p_sid->value_deepest = (unsigned int (*)[DEEPA_LEN])malloc(sizeof(unsigned int)*DEEPA_LEN); + if (deep_level > 0) p_sid->value = (unsigned int *)malloc(sizeof(unsigned int)*DEEPC_LEN); + if (deep_level > 1) p_sid->value_deeper = (unsigned int *)malloc(sizeof(unsigned int)*DEEPB_LEN); + if (deep_level > 2) p_sid->value_deepest = (unsigned int *)malloc(sizeof(unsigned int)*DEEPA_LEN); return p_sid; } SID *getS_id(unsigned int type, unsigned int deep_level){ - SID *p_sid = (SID *)malloc(sizeof(SID)); + SID *p_sid = initS_id(deep_level); p_sid->type = type; - p_sid->deep = deep_level; - p_sid->value = NULL; - p_sid->value_deeper = NULL; - p_sid->value_deepest = NULL; if(deep_level > 0){ - p_sid->value = (unsigned int (*)[DEEPC_LEN])malloc(sizeof(unsigned int)*DEEPC_LEN); - for(int i = 0; i < DEEPC_LEN; i++) (*p_sid->value)[i] = rand()%65535; - if(deep_level > 1){ - p_sid->value_deeper = (unsigned int (*)[DEEPB_LEN])malloc(sizeof(unsigned int)*DEEPB_LEN); - for(int i = 0; i < DEEPB_LEN; i++) (*p_sid->value_deeper)[i] = rand()%65535; - } - if (deep_level > 2) { - p_sid->value_deepest = (unsigned int (*)[DEEPA_LEN])malloc(sizeof(unsigned int)*DEEPA_LEN); - for(int i = 0; i < DEEPA_LEN; i++) (*p_sid->value_deepest)[i] = rand()%65535; - } + for(int i = 0; i < DEEPC_LEN; i++) p_sid->value[i] = rand()%65535; + if(deep_level > 1) for(int i = 0; i < DEEPB_LEN; i++) p_sid->value_deeper[i] = rand()%65535; + if (deep_level > 2) for(int i = 0; i < DEEPA_LEN; i++) p_sid->value_deepest[i] = rand()%65535; } return p_sid; @@ -56,20 +45,20 @@ int fitS_id(const SID *fs_id, const SID *ss_id){ if(fs_id->deep == ss_id->deep){ if (fs_id->deep > 0) for(int i = 0; i < DEEPC_LEN; i++){ - if((*fs_id->value)[i] == (*ss_id->value)[i]) continue; - else if((*fs_id->value)[i] > (*ss_id->value)[i]) return 1; + if(fs_id->value[i] == ss_id->value[i]) continue; + else if(fs_id->value[i] > ss_id->value[i]) return 1; else return -1; } if (fs_id->deep > 1) for(int i = 0; i < DEEPB_LEN; i++){ - if((*fs_id->value_deeper)[i] == (*ss_id->value_deeper)[i]) continue; - else if((*fs_id->value_deeper)[i] > (*ss_id->value_deeper)[i]) return 1; + if(fs_id->value_deeper[i] == ss_id->value_deeper[i]) continue; + else if(fs_id->value_deeper[i] > ss_id->value_deeper[i]) return 1; else return -1; } if (fs_id->deep > 2) for(int i = 0; i < DEEPA_LEN; i++){ - if((*fs_id->value_deepest)[i] == (*ss_id->value_deepest)[i]) continue; - else if((*fs_id->value_deepest)[i] > (*ss_id->value_deepest)[i]) return 1; + if(fs_id->value_deepest[i] == ss_id->value_deepest[i]) continue; + else if(fs_id->value_deepest[i] > ss_id->value_deepest[i]) return 1; else return -1; } } @@ -95,17 +84,17 @@ char *s_idToASCIIString(const SID *s_id){ unsigned int buff[DATA_BIT]; if(s_id->deep > 0){ if (s_id->deep == DEEPC){ - string = (char *) malloc(sizeof(char) * (DEEPC_LEN + 1) * DATA_BIT + 1); + string = (char *) malloc(sizeof(char) * (DEEPC_LEN + 1) * DATA_BIT); deep_len = DEEPC_LEN + 1; deep_len *= DATA_BIT; } else if (s_id->deep == DEEPB){ - string = (char *) malloc(sizeof(char) * (DEEPC_LEN + DEEPB_LEN + 1) * DATA_BIT + 1); + string = (char *) malloc(sizeof(char) * (DEEPC_LEN + DEEPB_LEN + 1) * DATA_BIT); deep_len = DEEPC_LEN + DEEPB_LEN + 1; deep_len *= DATA_BIT; } else{ - string = (char *)malloc(sizeof(char) * (DEEPC_LEN + DEEPB_LEN + DEEPA_LEN + 1) * DATA_BIT + 1); + string = (char *)malloc(sizeof(char) * (DEEPC_LEN + DEEPB_LEN + DEEPA_LEN + 1) * DATA_BIT); deep_len = DEEPC_LEN + DEEPB_LEN + DEEPA_LEN + 1; deep_len *= DATA_BIT; } @@ -121,7 +110,7 @@ char *s_idToASCIIString(const SID *s_id){ } deep_len -= DATA_BIT; for(int i = 0; i < DEEPC_LEN; i++){ - temp = (*s_id->value)[i]; + temp = s_id->value[i]; for (int i = 0; i < DATA_BIT; i++) buff[i] = 0; string_count = TYPE_LEN + (i) * 5; buff_count = DATA_BIT - 1; @@ -135,7 +124,7 @@ char *s_idToASCIIString(const SID *s_id){ deep_len -= DEEPC_LEN * DATA_BIT; if(deep_len > 0) for(int i = 0; i < DEEPB_LEN; i++){ - temp = (*s_id->value_deeper)[i]; + temp = s_id->value_deeper[i]; for (int i = 0; i < DATA_BIT; i++) buff[i] = 0; string_count = TYPE_LEN + DEEPC_LEN * DATA_BIT + (i) * DATA_BIT; buff_count = DATA_BIT - 1; @@ -150,7 +139,7 @@ char *s_idToASCIIString(const SID *s_id){ deep_len -= DEEPB_LEN * DATA_BIT; if(deep_len > 0) for(int i = 0; i < DEEPA_LEN; i++){ - temp = (*s_id->value_deepest)[i]; + temp = s_id->value_deepest[i]; for (int i = 0; i < DATA_BIT; i++) buff[i] = 0; string_count = TYPE_LEN + (DEEPC_LEN + DEEPB_LEN) * DATA_BIT + (i) * DATA_BIT; buff_count = DATA_BIT - 1; @@ -162,7 +151,6 @@ char *s_idToASCIIString(const SID *s_id){ } for(int i = DATA_BIT - 1; i >= 0; i--) string[string_count + i] = buff[i] + 48; } - printf("%s",string); return string; } else{ @@ -173,52 +161,52 @@ char *s_idToASCIIString(const SID *s_id){ SID *asciiStringToS_id(const char *string){ SID *s_id = NULL; unsigned long long string_len = strlen(string); - unsigned int *buff = (unsigned int *) malloc(sizeof(string_len - 1)); - for(int i = 0; i < string_len; i++){ - buff[i] = string[i] - 48; - } + if (string_len == 25) s_id = initS_id(1); else if (string_len == 65) s_id = initS_id(2); else if (string_len == 225) s_id = initS_id(3); else return NULL; + unsigned int *buff = (unsigned int *) malloc(sizeof(unsigned int) * (string_len)); + for(int i = 0; i < string_len; i++){ + buff[i] = (unsigned int)string[i] - 48; + } + printf("%s\n",string); + s_id->type = 0; for (int i = 0; i < 5; i++){ s_id->type += buff[i] ; - s_id->type *= 10; + s_id->type *= 10u; } - s_id->type /= 10; + s_id->type /= 10u; if (string_len >= 25){ for(int i = 0; i < DEEPC_LEN; i++){ - (*s_id->value)[i] = 0; + s_id->value[i] = 0; for (int j = 0; j < 5; j++){ - (*s_id->value)[i] += (int)buff[5 + i * 5 + j]; - (*s_id->value)[i] *= 10; + s_id->value[i] += (unsigned int)buff[5 + i * 5 + j]; + if(j < 4) s_id->value[i] *= 10; } - (*s_id->value)[i] /= 10; } } if (string_len >= 65){ for(int i = 0; i < DEEPB_LEN; i++){ - (*s_id->value_deeper)[i] = 0; + s_id->value_deeper[i] = 0; for (int j = 0; j < 5; j++){ - (*s_id->value_deeper)[i] += buff[25 + i * 5 + j]; - (*s_id->value_deeper)[i] *= 10; + s_id->value_deeper[i] += buff[25 + i * 5 + j]; + if(j < 4) s_id->value_deeper[i] *= 10; } - (*s_id->value_deeper)[i] /= 10; } } if (string_len >= 225){ for(int i = 0; i < DEEPA_LEN; i++){ - (*s_id->value_deepest)[i] = 0; + s_id->value_deepest[i] = 0; for (int j = 0; j < 5; j++){ - (*s_id->value_deepest)[i] += buff[65 + i * 5 + j]; - (*s_id->value_deepest)[i] *= 10; + s_id->value_deepest[i] += buff[65 + i * 5 + j]; + if(j < 4) s_id->value_deepest[i] *= 10; } - (*s_id->value_deepest)[i] /= 10; } } free(buff); diff --git a/id/id.h b/id/id.h index 9c8a038..abe4499 100644 --- a/id/id.h +++ b/id/id.h @@ -1,11 +1,3 @@ -// -// id.h -// ZE-Standard-Libraries -// -// Created by 胡一兵 on 2018/7/25. -// Copyright © 2018年 ZE. All rights reserved. -// - #ifndef id_h #define id_h @@ -15,18 +7,10 @@ #include #include "../type/type.h" -typedef struct s_id{ - unsigned int type; - unsigned int (*value)[DEEPC_LEN];//4 - unsigned int (*value_deeper)[DEEPB_LEN];//8 - unsigned int (*value_deepest)[DEEPA_LEN];//32 - unsigned int deep; -}SID; - void init_rand(void); unsigned long long getId(void); -SID *getS_id(unsigned int type ,unsigned int deep_level); +SID *getS_id(unsigned int type, unsigned int deep_level); int fitS_id(const SID *fs_id, const SID *ss_id); int simFitS_id(const SID *fs_id, const SID *ss_id); diff --git a/list/list.c b/list/list.c index c392166..ff7ba19 100644 --- a/list/list.c +++ b/list/list.c @@ -83,6 +83,7 @@ Node *initNode(void) { Node *p_node = (Node *)malloc(sizeof(Node)); Node *prec_node = NULL; p_node->s_id = getS_id(LIST_NODE, 2); + p_node->if_sid = 1; p_node->if_malloc = 0; p_node->next = NULL; p_node->last = NULL; @@ -101,6 +102,7 @@ List *initList(void) { Node *p_node; List *p_list = (List *)malloc(sizeof(List)); p_list->s_id = getS_id(LIST, 1); + p_list->if_sid = 1; p_list->head = NULL; p_list->tail = NULL; p_list->length = 0; @@ -297,7 +299,6 @@ int popFromTail(List *p_list) { return 0; } -/*该函数算法需要改进*/ Node *findByIdForNode(List *p_list, const SID *s_id) { Node *ph_node = p_list->head; Node *pt_node = p_list->tail; @@ -330,7 +331,7 @@ Node *findByValue(List *p_list, unsigned int type, const void *value) { while (p_node != NULL) { if (p_node->type != type) { p_node = p_node->next; - continue;//跳过不合类型的节点 + continue; } if (type == INT) { if (*((int *)p_node->value) == *((int *)value)) { @@ -457,3 +458,95 @@ int releaseOnlyNode(Node *p_node) { free(p_node); return 0; } + +int releaseNodeForCustom(Node *p_node, int (*func)(void *)){ + if (if_safeModeForNode == 1) { + removeByNode(node_list, p_node); + } + if (p_node->if_malloc == 1) { + if (!func(p_node->value)) + showError(pushError(LIST_NODE, STANDARD, initInfo("releaseNodeForCustom()", "Error in using custom freeing value function."))); + p_node->value = NULL; + } + p_node->last = NULL; + p_node->next = NULL; + p_node->type = VOID; + p_node->value = NULL; + freeS_id(p_node->s_id); + p_node->if_malloc = 0; + free(p_node); + return 0; +} + +int releaseListForCustom(List *p_list, int (*func)(void *)){ + Node *p_node, *pl_node; + p_node = p_list->head; + if (if_safeModeForNode == 1) { + Node *tar_list = findByValue(list_list, POINTER, (void *)p_list); + removeByNode(list_list, tar_list); + } + while (p_node != NULL) { + pl_node = p_node; + p_node = p_node->next; + pl_node->next = NULL; + pl_node->last = NULL; + releaseNodeForCustom(pl_node,func); + } + p_list->head = NULL; + p_list->tail = NULL; + p_list->length = 0; + freeS_id(p_list->s_id); + free(p_list); + return 0; +} + +int pushInfo(Info *p_info, const char *head, const char *body) { + strcpy(p_info->head, head); + strcpy(p_info->body, body); + return 0; +} + +Error *pushError(unsigned int type, int pri, Info *p_info) { + Error *p_error = (Error *)malloc(sizeof(Error)); + p_error->type = type; + p_error->priority = pri; + p_error->info = *p_info; + p_error->time = time(NULL); + free(p_info); + return p_error; +} + +Notice *pushNotice(unsigned int type, Info *p_info) { + Notice *p_notice = (Notice *)malloc(sizeof(Notice)); + p_notice->type = type; + p_notice->info = *p_info; + p_notice->time = time(NULL); + free(p_info); + return p_notice; +} + +Info *initInfo(const char *head, const char *body){ + Info *p_info = (Info *)malloc(sizeof(Info)); + pushInfo(p_info, head, body); + return p_info; +} + +int showError(Error *p_error){ + printf("\n"); + for (int i = 0; i < p_error->priority; i++) { + printf("!"); + } + + printf("(Error) %s\n",asctime(localtime(&p_error->time))); + printf("%s: %s.\n",p_error->info.head,p_error->info.body); + free(p_error); + return 0; +} + +int showWarning(Notice *p_notice){ + printf("\n@"); + printf("(Warning) %s\n",asctime(localtime(&p_notice->time))); + printf("%s: %s.\n",p_notice->info.head,p_notice->info.body); + free(p_notice); + return 0; +} diff --git a/list/list.h b/list/list.h index f43248f..349b525 100644 --- a/list/list.h +++ b/list/list.h @@ -1,31 +1,8 @@ #ifndef LIST_H #define LIST_H - -#include -#include -#include -#include #include "../type/type.h" #include "../id/id.h" -typedef struct Node{ - SID *s_id; - void *value; - _Bool if_malloc; - _Bool if_sid; - unsigned int type; - struct Node *next; - struct Node *last; -} Node; - - -typedef struct List{ - SID *s_id; - Node *head; - Node *tail; - unsigned long long length; -} List; - int safeModeForNode(int ifon); int releaseSingleListForsafeModeForNode(List *p_list); int releaseSingleNodeForsafeModeForNode(List *p_list); @@ -55,13 +32,25 @@ Node *findByValue(List *p_list, unsigned int type, const void *value); List *mply_findByValue(List *p_list, unsigned int type, const void *value); int releaseList(List *p_list); +int releaseListForCustom(List *p_list, int (*func)(void *)); int releaseListForSingle(List *p_list); int releaseNode(Node *p_node); +int releaseNodeForCustom(Node *p_node, int (*func)(void *)); int releaseOnlyNode(Node *p_node); int isListEmpty(List *p_list); List *copyList(List *p_list); +int pushInfo(Info *p_info, const char *head,const char *body); +Error *pushError(unsigned int type, int pri, Info *p_info); +Notice *pushNotice(unsigned int type, Info *p_info); + +Info *initInfo(const char *head, const char *body); +Error *createError(Info *info,unsigned int type,int pri); +Notice *createWarning(Info *info, unsigned int type, int pri); +int showError(Error *); +int showWarning(Notice *); + static int if_safeModeForNode; static List *node_list; static List *list_list; diff --git a/list/list_expand.h b/list/list_expand.h index 63bb773..1d8d97e 100644 --- a/list/list_expand.h +++ b/list/list_expand.h @@ -1,5 +1,6 @@ #ifndef LIST_EXPAND_H -#define LIST_EXPAND_H +#define LIST_EXPAND_H + #include "list.h" Node *nodeWithInt(int); diff --git a/stack/stack.h b/stack/stack.h index 7990edf..d20f752 100644 --- a/stack/stack.h +++ b/stack/stack.h @@ -1,5 +1,3 @@ -#include - #ifndef STACK_H #define STACK_H #include "../list/list_expand.h" diff --git a/stack/stack_expand.h b/stack/stack_expand.h index ba739f7..95978c1 100644 --- a/stack/stack_expand.h +++ b/stack/stack_expand.h @@ -1,7 +1,6 @@ #ifndef STACK_EXPAND_H #define STACK_EXPAND_H -#include #include "stack.h" SNode *snodeWithInt(int); diff --git a/test.c b/test.c index 8ce8cfe..bd9d494 100644 --- a/test.c +++ b/test.c @@ -83,11 +83,6 @@ int stack(void) { int main(int argc, char **argv) { //tree(); - init_rand(); - SID *p_sid = getS_id(LIST_NODE, 1); - char *string = s_idToASCIIString(p_sid); - SID *t_sid = asciiStringToS_id(string); - int if_same = simFitS_id(p_sid, t_sid); - getchar(); + init_rand(); return 0; } diff --git a/test.h b/test.h index eed9bbc..dfa8642 100644 --- a/test.h +++ b/test.h @@ -1,11 +1,9 @@ #ifndef TEST_H #define TEST_H -#include - +#include "type/type.h" #include "list/list_expand.h" #include "stack/stack_expand.h" -#include "tree/tree.h" #include "tree/tree_expand.h" int stack(void); diff --git a/tree/tree.c b/tree/tree.c index e9b4c87..bf5efd4 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -31,7 +31,8 @@ int safeModeForTree(int ifon) { TNode *initTNode(void) { Node *s_node; TNode *p_tnode = (TNode *)malloc(sizeof(TNode)); - p_tnode->s_id = getS_id(TREE_NODE, 2); + p_tnode->s_id = getS_id(TREE_NODE, 2); + p_tnode->if_sid = 1; p_tnode->child_num = 0; p_tnode->father = NULL; p_tnode->if_malloc = 0; @@ -60,7 +61,8 @@ TNode *initTNode(void) { Tree *initTree(void) { Node *s_node; Tree *p_tree = (Tree *)malloc(sizeof(Tree)); - p_tree->s_id = getS_id(TREE, 1); + p_tree->s_id = getS_id(TREE, 1); + p_tree->if_sid = 1; p_tree->root = NULL; if (if_safeModeForTree) { if (if_safeModeForNode) { diff --git a/tree/tree.h b/tree/tree.h index f230b57..2504c6f 100644 --- a/tree/tree.h +++ b/tree/tree.h @@ -4,27 +4,6 @@ #include #include "../list/list_expand.h" -typedef struct tree_node -{ - SID *s_id; - List *home; - struct tree_node *father; - Node *room; - unsigned long long child_num; - unsigned int type; - void *value; - _Bool if_malloc; - _Bool if_sid; -}TNode; - -typedef struct tree -{ - SID *s_id; - _Bool if_sid; - TNode *root; -}Tree; - - int safeModeForTree(int ifon); int releaseAllForTree(void); diff --git a/type/type.h b/type/type.h index af3ee92..4be9d31 100644 --- a/type/type.h +++ b/type/type.h @@ -1,6 +1,11 @@ #ifndef type_h #define type_h +#include +#include +#include +#include + #define VOID 0 #define INT 1 #define DOUBLE 2 @@ -13,16 +18,89 @@ #define TREE_NODE 9 #define STACK_NODE 10 -#define TYPE_LEN 5 - #define DEEPC 1 #define DEEPB 2 #define DEEPA 3 - +#define TYPE_LEN 5 #define DEEPC_LEN 4 #define DEEPB_LEN 8 #define DEEPA_LEN 32 - #define DATA_BIT 5 +#define HIGH 0x3 +#define STANDARD 0x2 +#define LOW 0x1 + +typedef struct s_id{ + unsigned int type; + unsigned int *value;//4 + unsigned int *value_deeper;//8 + unsigned int *value_deepest;//32 + unsigned int deep; +}SID; + +typedef struct Node{ + SID *s_id; + void *value; + _Bool if_malloc; + _Bool if_sid; + unsigned int type; + struct Node *next; + struct Node *last; +} Node; + + +typedef struct List{ + SID *s_id; + Node *head; + Node *tail; + _Bool if_sid; + unsigned long long length; +} List; + +typedef struct Info{ + char head[64]; + char body[256]; +}Info; + +typedef struct Error{ + unsigned int type; + int priority; + Info info; + time_t time; +}Error; + +typedef struct Notice{ + unsigned int type; + Info info; + time_t time; +}Notice; + +typedef struct Log{ + FILE *fp; + int if_enable; + unsigned long int id; +}Log; + +typedef struct tree_node +{ + SID *s_id; + List *home; + struct tree_node *father; + Node *room; + unsigned long long child_num; + unsigned int type; + void *value; + _Bool if_malloc; + _Bool if_sid; +}TNode; + +typedef struct tree +{ + SID *s_id; + _Bool if_sid; + TNode *root; +}Tree; + + #endif /* type_h */ From ac54c07010b76b476be6a93d59b818343900a6be Mon Sep 17 00:00:00 2001 From: Saturneic Date: Fri, 3 Aug 2018 18:35:10 +0800 Subject: [PATCH 50/55] Fixed --- list/list_expand.c | 2 +- tree/tree_expand.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/list/list_expand.c b/list/list_expand.c index 84b8157..e0cf001 100644 --- a/list/list_expand.c +++ b/list/list_expand.c @@ -355,7 +355,7 @@ unsigned long long calListMemory(List * p_list){ unsigned long long nodes_size = 0LL; unsigned long long list_size = sizeof(p_list); while(p_node != NULL){ - nodes_size += sizeof(p_node) + sizeof(*p_node->value); + nodes_size += sizeof(p_node); p_node = p_node->next; } return list_size + nodes_size; diff --git a/tree/tree_expand.c b/tree/tree_expand.c index 48e891a..e188663 100644 --- a/tree/tree_expand.c +++ b/tree/tree_expand.c @@ -222,6 +222,6 @@ unsigned long long calTreeMemory(Tree *p_tree){ } int _doCalTreeMemory(TNode *p_tnode, unsigned long long height){ - tnodes_size += sizeof(p_tnode) + sizeof(*p_tnode->value); + tnodes_size += sizeof(p_tnode); return 0; } From c4315326d3dece36ce3de10f5b6865c5700cf5bb Mon Sep 17 00:00:00 2001 From: Saturneic Date: Fri, 3 Aug 2018 18:58:49 +0800 Subject: [PATCH 51/55] Fixed --- .../xcdebugger/Breakpoints_v2.xcbkptlist | 464 +++++++++--------- id/id.c | 32 +- list/list.c | 19 +- stack/stack.c | 8 + tree/tree.c | 19 +- type/type.h | 1 + 6 files changed, 302 insertions(+), 241 deletions(-) diff --git a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist index 2c76f28..e74a180 100644 --- a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist +++ b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist @@ -154,7 +154,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "test.c" - timestampString = "554985107.001519" + timestampString = "554986718.90595" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "64" @@ -170,7 +170,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "tree/tree_expand.c" - timestampString = "554638722.806551" + timestampString = "554986718.906049" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "60" @@ -186,7 +186,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "id/id.c" - timestampString = "554985107.0016969" + timestampString = "554986718.906109" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "19" @@ -202,12 +202,12 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "id/id.c" - timestampString = "554985107.001803" + timestampString = "554986718.906213" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" - startingLineNumber = "81" - endingLineNumber = "81" - landmarkName = "s_idToASCIIString" + startingLineNumber = "99" + endingLineNumber = "99" + landmarkName = "simFitS_id" landmarkType = "9"> @@ -218,13 +218,13 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "id/id.c" - timestampString = "554985107.001882" + timestampString = "554986718.906307" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" - startingLineNumber = "84" - endingLineNumber = "84" - landmarkName = "s_idToASCIIString" - landmarkType = "9"> + startingLineNumber = "102" + endingLineNumber = "102" + landmarkName = "unknown" + landmarkType = "0"> - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -381,27 +493,11 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "id/id.c" - timestampString = "554985107.002624" + timestampString = "554986718.9079241" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" - startingLineNumber = "218" - endingLineNumber = "218" - landmarkName = "freeS_id" - landmarkType = "9"> - - - - @@ -413,107 +509,11 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "id/id.c" - timestampString = "554985107.002749" - startingColumnNumber = "9223372036854775807" - endingColumnNumber = "9223372036854775807" - startingLineNumber = "20" - endingLineNumber = "20" - landmarkName = "initS_id" - landmarkType = "9"> - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/id/id.c b/id/id.c index 22960d3..2c862da 100644 --- a/id/id.c +++ b/id/id.c @@ -17,14 +17,32 @@ unsigned long long getId(void) { SID *initS_id(unsigned int deep_level){ SID *p_sid = (SID *) malloc(sizeof(SID)); + if(p_sid == NULL){ + printf("\ninitS_id(): Error in getting the memory of sid.\n"); + } p_sid->type = VOID; p_sid->deep = deep_level; p_sid->value = NULL; p_sid->value_deeper = NULL; p_sid->value_deepest = NULL; - if (deep_level > 0) p_sid->value = (unsigned int *)malloc(sizeof(unsigned int)*DEEPC_LEN); - if (deep_level > 1) p_sid->value_deeper = (unsigned int *)malloc(sizeof(unsigned int)*DEEPB_LEN); - if (deep_level > 2) p_sid->value_deepest = (unsigned int *)malloc(sizeof(unsigned int)*DEEPA_LEN); + if (deep_level > 0) { + p_sid->value = (unsigned int *)malloc(sizeof(unsigned int)*DEEPC_LEN); + if(p_sid->value == NULL){ + printf("\ninitS_id(): Error in getting the memory of sid.value.\n"); + } + } + if (deep_level > 1){ + p_sid->value_deeper = (unsigned int *)malloc(sizeof(unsigned int)*DEEPB_LEN); + if(p_sid->value_deeper == NULL){ + printf("\ninitS_id(): Error in getting the memory of sid.value_deeper.\n"); + } + } + if (deep_level > 2){ + p_sid->value_deepest = (unsigned int *)malloc(sizeof(unsigned int)*DEEPA_LEN); + if(p_sid->value_deepest == NULL){ + printf("\ninitS_id(): Error in getting the memory of sid.value_deepest.\n"); + } + } return p_sid; } @@ -98,6 +116,9 @@ char *s_idToASCIIString(const SID *s_id){ deep_len = DEEPC_LEN + DEEPB_LEN + DEEPA_LEN + 1; deep_len *= DATA_BIT; } + if(string == NULL){ + printf("\ns_idToASCIIString(): Error in getting the memory of string.\n"); + } string[deep_len] = '\0'; temp = s_id->type; buff_count = DATA_BIT - 1; @@ -168,12 +189,13 @@ SID *asciiStringToS_id(const char *string){ else return NULL; unsigned int *buff = (unsigned int *) malloc(sizeof(unsigned int) * (string_len)); + if(buff == NULL){ + printf("\ns_idToASCIIString(): Error in getting the memory of string.\n"); + } for(int i = 0; i < string_len; i++){ buff[i] = (unsigned int)string[i] - 48; } - printf("%s\n",string); - s_id->type = 0; for (int i = 0; i < 5; i++){ s_id->type += buff[i] ; diff --git a/list/list.c b/list/list.c index ff7ba19..b4c3abd 100644 --- a/list/list.c +++ b/list/list.c @@ -8,8 +8,15 @@ int safeModeForNode(int ifon) { if (ifon == 1) { if (node_list == NULL && list_list == NULL) { node_list = (List *)malloc(sizeof(List)); + if(node_list == NULL){ + showError(pushError(LIST, HIGH, initInfo("safeModeForNode()", "Error in get the memory of node_list."))); + return -1; + } list_list = (List *)malloc(sizeof(List)); - + if(list_list == NULL){ + showError(pushError(LIST, HIGH, initInfo("safeModeForNode()", "Error in get the memory of list_list."))); + return -1; + } list_list->head = NULL; list_list->length = 0; list_list->tail = NULL; @@ -81,6 +88,10 @@ int releaseAllForNode(void) { Node *initNode(void) { Node *p_node = (Node *)malloc(sizeof(Node)); + if(p_node == NULL){ + showError(pushError(LIST_NODE, STANDARD, initInfo("initNode()", "Error in get the memory of node."))); + return NULL; + } Node *prec_node = NULL; p_node->s_id = getS_id(LIST_NODE, 2); p_node->if_sid = 1; @@ -99,8 +110,12 @@ Node *initNode(void) { } List *initList(void) { - Node *p_node; + Node *p_node = NULL; List *p_list = (List *)malloc(sizeof(List)); + if(p_list == NULL){ + showError(pushError(LIST_NODE, STANDARD, initInfo("initList()", "Error in get the memory of list."))); + return NULL; + } p_list->s_id = getS_id(LIST, 1); p_list->if_sid = 1; p_list->head = NULL; diff --git a/stack/stack.c b/stack/stack.c index 66580bd..acaee3f 100644 --- a/stack/stack.c +++ b/stack/stack.c @@ -2,6 +2,10 @@ Stack *initStack(void) { Stack *p_stack = (Stack *)malloc(sizeof(Stack)); + if(p_stack == NULL){ + showError(pushError(STACK, STANDARD, initInfo("initStack()", "Error in get the memory of stack."))); + return NULL; + } p_stack->s_id = getS_id(STACK, 1); p_stack->length = 0; p_stack->top = NULL; @@ -10,6 +14,10 @@ Stack *initStack(void) { SNode *initSNode(void) { SNode *p_snode = (SNode *)malloc(sizeof(SNode)); + if(p_snode == NULL){ + showError(pushError(STACK_NODE, STANDARD, initInfo("initSNode()", "Error in get the memory of snode."))); + return NULL; + } p_snode->s_id = getS_id(STACK_NODE, 2); p_snode->if_malloc = 0; p_snode->next = NULL; diff --git a/tree/tree.c b/tree/tree.c index bf5efd4..276304d 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -7,9 +7,16 @@ static int if_safeModeForTree = 0; int safeModeForTree(int ifon) { if (ifon == 1) { if (tnode_list == NULL && tree_list == NULL) { - tnode_list = (List *)malloc(sizeof(List)); + tnode_list = (List *)malloc(sizeof(List)); + if(tnode_list == NULL){ + showError(pushError(TREE_NODE, HIGH, initInfo("safeModeForTree()", "Error in get the memory of tnode_list."))); + return -1; + } tree_list = (List *)malloc(sizeof(List)); - + if(tree_list == NULL){ + showError(pushError(TREE_NODE, HIGH, initInfo("safeModeForTree()", "Error in get the memory of tree_list."))); + return -1; + } tree_list->head = NULL; tree_list->length = 0; tree_list->tail = NULL; @@ -31,6 +38,10 @@ int safeModeForTree(int ifon) { TNode *initTNode(void) { Node *s_node; TNode *p_tnode = (TNode *)malloc(sizeof(TNode)); + if(p_tnode == NULL){ + showError(pushError(TREE_NODE, STANDARD, initInfo("initTNode()", "Error in get the memory of tnode."))); + return NULL; + } p_tnode->s_id = getS_id(TREE_NODE, 2); p_tnode->if_sid = 1; p_tnode->child_num = 0; @@ -61,6 +72,10 @@ TNode *initTNode(void) { Tree *initTree(void) { Node *s_node; Tree *p_tree = (Tree *)malloc(sizeof(Tree)); + if(p_tree == NULL){ + showError(pushError(TREE, STANDARD, initInfo("initTree()", "Error in get the memory of tree."))); + return NULL; + } p_tree->s_id = getS_id(TREE, 1); p_tree->if_sid = 1; p_tree->root = NULL; diff --git a/type/type.h b/type/type.h index 4be9d31..47f5cca 100644 --- a/type/type.h +++ b/type/type.h @@ -17,6 +17,7 @@ #define LIST_NODE 8 #define TREE_NODE 9 #define STACK_NODE 10 +#define T_SID 11 #define DEEPC 1 #define DEEPB 2 From d8cac27242204e6e6577b4cfe688e6984744f3dc Mon Sep 17 00:00:00 2001 From: Saturneic Date: Tue, 7 Aug 2018 12:10:55 +0800 Subject: [PATCH 52/55] Add and Fixed. --- .../xcdebugger/Expressions.xcexplist | 136 +++- .../xcdebugger/Breakpoints_v2.xcbkptlist | 706 +++++++++++++++++- communicate/communicate.c | 265 +++++++ communicate/communicate.h | 71 ++ list/list.c | 14 +- list/list.h | 2 +- list/list_expand.c | 155 +++- list/list_expand.h | 18 +- stack/stack.c | 4 +- stack/stack.h | 17 +- stack/stack_expand.c | 18 +- test.c | 23 +- test.h | 3 +- tree/tree.c | 93 ++- tree/tree.h | 4 +- tree/tree_expand.c | 18 +- type/type.h | 26 + 17 files changed, 1399 insertions(+), 174 deletions(-) diff --git a/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist b/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist index d8ca57a..1d0c1c5 100644 --- a/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist +++ b/ZE-Standard-Libraries.xcodeproj/project.xcworkspace/xcuserdata/huyibing.xcuserdatad/xcdebugger/Expressions.xcexplist @@ -3,7 +3,62 @@ version = "1.0"> + contextName = "init_node:list.h"> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -22,6 +77,45 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -33,44 +127,22 @@ - - - - - - - - - - - - - - - - - - - - - - + + + + + + diff --git a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist index e74a180..c3ec7ec 100644 --- a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist +++ b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist @@ -154,7 +154,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "test.c" - timestampString = "554986718.90595" + timestampString = "555307651.589517" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "64" @@ -186,7 +186,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "id/id.c" - timestampString = "554986718.906109" + timestampString = "555307651.589684" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "19" @@ -202,12 +202,12 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "id/id.c" - timestampString = "554986718.906213" + timestampString = "555307651.589751" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "99" endingLineNumber = "99" - landmarkName = "simFitS_id" + landmarkName = "s_idToASCIIString" landmarkType = "9"> @@ -218,13 +218,13 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "id/id.c" - timestampString = "554986718.906307" + timestampString = "555307651.589806" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "102" endingLineNumber = "102" - landmarkName = "unknown" - landmarkType = "0"> + landmarkName = "s_idToASCIIString" + landmarkType = "9"> + + + + @@ -397,23 +413,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "id/id.c" - timestampString = "554986718.90746" - startingColumnNumber = "9223372036854775807" - endingColumnNumber = "9223372036854775807" - startingLineNumber = "184" - endingLineNumber = "184" - landmarkName = "s_idToASCIIString" - landmarkType = "9"> - - - - @@ -509,7 +509,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "id/id.c" - timestampString = "554986718.908048" + timestampString = "555307651.590819" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "217" @@ -518,5 +518,629 @@ landmarkType = "9"> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/communicate/communicate.c b/communicate/communicate.c index 32dc9ac..73a86a5 100644 --- a/communicate/communicate.c +++ b/communicate/communicate.c @@ -1 +1,266 @@ #include "communicate.h" + +STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned long long data_size){ + STD_BLOCKS *p_stdb = (STD_BLOCKS *)malloc(sizeof(STD_BLOCKS)); + p_stdb->sid = s_idToASCIIString(p_sid); + p_stdb->if_data = 0; + unsigned int blocks_num = (unsigned int)(data_size/sizeof(char)); + p_stdb->blocks_num = blocks_num; + p_stdb->buff = (char *)malloc(sizeof(char) * blocks_num); + return p_stdb; +} + +int dataForStandardDBlock(STD_BLOCKS *p_stdb,void *data){ + char *t_data = (char *)data; + /*unsigned int data_size = sizeof(data);*/ + + for(int i = 0; i < p_stdb->blocks_num; i++){ + p_stdb->buff[i] = t_data[i]; + } + p_stdb->if_data = 1; + return 0; +} + +STD_CTN *initStandardDConnection(SID *f_sid, SID *s_sid){ + STD_CTN *p_stdc = (STD_CTN *)malloc(sizeof(STD_CTN)); + p_stdc->f_sid = s_idToASCIIString(f_sid); + p_stdc->s_sid = s_idToASCIIString(s_sid); + return p_stdc; +} + +STD_DATA *initStandardData(unsigned int type){ + STD_DATA *p_std = (STD_DATA *)malloc(sizeof(STD_DATA)); + p_std->pd_blocklst = initList(); + p_std->pd_ctnlst = initList(); + p_std->lock = 0; + p_std->type = type; + p_std->s_id = getS_id(STANDARD_DATA, 2); + return p_std; +} + +int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,void *data, unsigned long long data_size){ + if (p_std->lock) return -1; + STD_BLOCKS *p_stdb = initStandardDBlocks(p_sid, data_size); + dataForStandardDBlock(p_stdb, data); + insertInTail(p_std->pd_blocklst, nodeWithPointer(p_stdb)); + return 0; +} + +int standardDataAddConnection(STD_DATA *p_std, SID *f_sid, SID *s_sid){ + if (p_std->lock) return -1; + STD_CTN *p_stdb = initStandardDConnection(f_sid, s_sid); + insertInTail(p_std->pd_ctnlst, nodeWithPointer(p_stdb)); + return 0; +} + +D_FILE *initDataFileForWrite(char *route){ + D_FILE *p_dfile = (D_FILE *)malloc(sizeof(D_FILE)); + p_dfile->fp = fopen(route, "wb"); + p_dfile->pf_head = (F_HEAD *)malloc(sizeof(F_HEAD)); + strcpy(p_dfile->pf_head->head_test,"ZESTDLIB_STDDFILE"); + p_dfile->pf_head->data_num = 0; + p_dfile->pf_stdlst = initList(); + return p_dfile; +} + +D_FILE *initDataFileForRead(char *route){ + D_FILE *p_dfile = (D_FILE *)malloc(sizeof(D_FILE)); + p_dfile->fp = fopen(route, "rb"); + p_dfile->pf_head = (F_HEAD *)malloc(sizeof(F_HEAD)); + p_dfile->pf_head->data_num = 0; + p_dfile->pf_stdlst = initList(); + return p_dfile; +} + +int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std){ + insertInTail(p_dfile->pf_stdlst, nodeWithPointer(p_std)); + p_dfile->pf_head->data_num = p_dfile->pf_stdlst->length; + return 0; +} + +int dataFileWriteIn(D_FILE *p_dfile){ + fwrite(p_dfile->pf_head->head_test, sizeof(char), 18, p_dfile->fp); + fwrite(&p_dfile->pf_head->data_num, sizeof(unsigned long long), 1, p_dfile->fp); + fwrite("HEAD_END", sizeof(char), 9, p_dfile->fp); + List *er_list = initList(); + insertInTail(er_list, nodeWithPointer(p_dfile->fp)); + /*fwrite("STDINFO", sizeof(char), 8, p_dfile->fp); + listThrough(p_dfile->pf_stdlst, _doStandardDataInfoWrite, er_list);*/ + /*fwrite("STDLST", sizeof(char), 7, p_dfile->fp);*/ + listThrough(p_dfile->pf_stdlst, _doStandardDataWrite, er_list); + releaseList(er_list); + return 0; +} +List *_doStandardDataInfoWrite(unsigned int type, void *value, List *er_list){ + List *p_rtnlst = initList(); + FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0)); + STD_DATA *p_std = value; + insertInTail(p_rtnlst, nodeWithInt(0)); + char *string_sid = s_idToASCIIString(p_std->s_id); + fwrite(string_sid, sizeof(char), DEEPER_LEN, fp); + free(string_sid); + fwrite(&p_std->type, sizeof(unsigned long), 1, fp); + fwrite(&p_std->pd_ctnlst->length, sizeof(unsigned long long), 1, fp); + fwrite(&p_std->pd_blocklst->length, sizeof(unsigned long long), 1, fp); + return p_rtnlst; +} + +List *_doStandardDataWrite(unsigned int type, void *value, List *er_list){ + List *p_rtnlst = initList(); + FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0)); + insertInTail(p_rtnlst, nodeWithInt(0)); + STD_DATA *p_std = value; + List *erc_list = initList(); + insertInTail(erc_list, nodeWithPointer(fp)); + fwrite("STD", sizeof(char), 4, fp); + char *string_sid = s_idToASCIIString(p_std->s_id); + unsigned long sid_len = strlen(string_sid) + 1; + fwrite(&sid_len, sizeof(unsigned long), 1, fp); + char *sid_w = s_idToASCIIString(p_std->s_id); + fwrite(sid_w, sizeof(char), sid_len, fp); + fwrite(&p_std->type, sizeof(unsigned int), 1, fp); + fwrite(&p_std->pd_ctnlst->length, sizeof(unsigned long long), 1, fp); + fwrite(&p_std->pd_blocklst->length, sizeof(unsigned long long), 1, fp); + listThrough(p_std->pd_ctnlst, _doStandardDConnectionWrite, erc_list); + listThrough(p_std->pd_blocklst, _doStandardDBlockWrite, erc_list); + releaseList(erc_list); + free(sid_w); + free(string_sid); + return p_rtnlst; +} + +List *_doStandardDConnectionWrite(unsigned int type, void *value, List *er_list){ + List *p_rtnlst = initList(); + insertInTail(p_rtnlst, nodeWithInt(0)); + FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0)); + STD_CTN *p_stdc = value; + unsigned long fsid_len = strlen(p_stdc->f_sid) + 1, ssid_len = strlen(p_stdc->s_sid)+1; + fwrite(&fsid_len, sizeof(unsigned long), 1, fp); + fwrite(p_stdc->f_sid, sizeof(char), fsid_len, fp); + fwrite(&ssid_len, sizeof(unsigned long), 1, fp); + fwrite(p_stdc->s_sid, sizeof(char), ssid_len, fp); + return p_rtnlst; +} + +List *_doStandardDBlockWrite(unsigned int type, void *value, List *er_list){ + List *p_rtnlst = initList(); + insertInTail(p_rtnlst, nodeWithInt(0)); + STD_BLOCKS *p_stdb = value; + FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0)); + unsigned long sid_len = strlen(p_stdb->sid)+1, blocks_num = p_stdb->blocks_num; + fwrite(&sid_len, sizeof(unsigned long), 1, fp); + fwrite(p_stdb->sid, sizeof(char), sid_len, fp); + fwrite(&blocks_num, sizeof(unsigned long), 1, fp); + fwrite(p_stdb->buff, sizeof(char), p_stdb->blocks_num, fp); + return p_rtnlst; +} + +STD_DATA *listToSTD(List *p_list){ + STD_DATA *p_std = initStandardData(LIST); + Node *p_node = p_list->head; + while (p_node != NULL) { + unsigned long long data_size = 0; + if(p_node->type == INT) data_size = sizeof(int); + else if (p_node->type == DOUBLE) data_size = sizeof(double); + else if (p_node->type == STRING) data_size = strlen((char *)p_node->value) + 1; + else data_size = sizeof(void *); + standardDataAddBlock(p_std, p_node->s_id, p_node->value, data_size); + p_node = p_node->next; + } + return p_std; +} + +int dataFileReadOut(D_FILE *p_dfile){ + char test_info[FILE_TSET_LEN],head_test_info[HEAD_TEST_LEN]; + fread(test_info, sizeof(char), FILE_TSET_LEN, p_dfile->fp); + strcpy(p_dfile->pf_head->head_test, test_info); + if(!strcmp(test_info, "ZESTDLIB_STDDFILE")){ + unsigned long long std_num = 0; + fread(&std_num, sizeof(unsigned long long), 1, p_dfile->fp); + p_dfile->pf_head->data_num = std_num; + fread(head_test_info, sizeof(char), 9, p_dfile->fp); + if (!strcmp(head_test_info, "HEAD_END")) { + for(int i = 0; i < std_num; i++){ + char std_test_info[4]; + fread(std_test_info, sizeof(char), 4, p_dfile->fp); + if(!strcmp(std_test_info, "STD")){ + unsigned long long sid_len = 0, ctn_num = 0, blk_num = 0; + unsigned int type = 0; + fread(&sid_len, sizeof(unsigned long), 1, p_dfile->fp); + char *string_sid = (char *)malloc(sizeof(char) * sid_len); + fread(string_sid, sizeof(char), sid_len, p_dfile->fp); + fread(&type, sizeof(unsigned int), 1, p_dfile->fp); + STD_DATA *p_std = initStandardData(type); + freeS_id(p_std->s_id); + p_std->s_id = asciiStringToS_id(string_sid); + dataFileAddStandardData(p_dfile, p_std); + free(string_sid); + fread(&ctn_num, sizeof(unsigned long long), 1, p_dfile->fp); + fread(&blk_num, sizeof(unsigned long long), 1, p_dfile->fp); + for(int j = 0; j < ctn_num; j++){ + fread(&sid_len, sizeof(unsigned long), 1, p_dfile->fp); + char *fstring_sid = (char *)malloc(sizeof(char) * sid_len); + fread(fstring_sid, sizeof(char), sid_len, p_dfile->fp); + fread(&sid_len, sizeof(unsigned long), 1, p_dfile->fp); + char *sstring_sid = (char *)malloc(sizeof(char) * sid_len); + fread(sstring_sid, sizeof(char), sid_len, p_dfile->fp); + SID *fs_id = asciiStringToS_id(fstring_sid), *ss_id = asciiStringToS_id(sstring_sid); + standardDataAddConnection(p_std, fs_id,ss_id); + freeS_id(fs_id); + freeS_id(ss_id); + free(fstring_sid); + free(sstring_sid); + } + for(int k = 0; k < blk_num; k++){ + fread(&sid_len, sizeof(unsigned long), 1, p_dfile->fp); + char *string_sid = (char *)malloc(sizeof(char) * sid_len); + fread(string_sid, sizeof(char), sid_len, p_dfile->fp); + unsigned long blk_len = 0; + fread(&blk_len, sizeof(unsigned long), 1, p_dfile->fp); + char *content = (char *)malloc(sizeof(char) * blk_len); + fread(content, sizeof(char), blk_len, p_dfile->fp); + SID *s_id = asciiStringToS_id(string_sid); + standardDataAddBlock(p_std, s_id, content, blk_len); + freeS_id(s_id); + free(string_sid); + free(content); + } + return 0; + } + else break; + } + } + } + showError(pushError(DATA_FILE, STANDARD, initInfo("dataFileReadOut()", "Datafile not complete."))); + return -1; +} + +int releaseSTDConnection(STD_CTN *p_stdc){ + free(p_stdc->f_sid); + free(p_stdc->s_sid); + free(p_stdc); + return 0; +} + +int releaseSTDBlocks(STD_BLOCKS *p_stdb){ + free(p_stdb->sid); + free(p_stdb->buff); + free(p_stdb); + return 0; +} + +int releaseStandardData(STD_DATA *p_std){ + freeS_id(p_std->s_id); + releaseListForCustom(p_std->pd_blocklst, (int (*)(void *))releaseSTDBlocks); + releaseListForCustom(p_std->pd_ctnlst, (int (*)(void *))releaseSTDConnection); + free(p_std); + return 0; +} + +int releaseDFile(D_FILE *p_dfile){ + releaseListForCustom(p_dfile->pf_stdlst, (int (*)(void *))releaseStandardData); + fclose(p_dfile->fp); + free(p_dfile->pf_head); + free(p_dfile); + return 0; +} diff --git a/communicate/communicate.h b/communicate/communicate.h index 4798a3f..bb15f73 100644 --- a/communicate/communicate.h +++ b/communicate/communicate.h @@ -1,6 +1,77 @@ #ifndef communicate_h #define communicate_h +#include "../type/type.h" +#include "../list/list_expand.h" +typedef struct message{ + SID *p_sid; + char titile[16]; + char content[0]; +}MSG; + +typedef struct file_head{ + char head_test[18]; + unsigned long long data_num; +}F_HEAD; + +typedef struct data_file{ + FILE *fp; + F_HEAD *pf_head; + List *pf_stdlst; +}D_FILE; + +typedef struct standard_data_blocks{ + unsigned int type; + char *sid; + _Bool if_data; + unsigned int blocks_num; + char *buff; +}STD_BLOCKS; + +typedef struct standard_data_connection{ + char *f_sid; + char *s_sid; +}STD_CTN; + +typedef struct standard_data_head{ + unsigned long long data_blk_num; + unsigned long long data_ctn_num; +}STD_HEAD; + +typedef struct standard_data{ + SID *s_id; + unsigned int type; + _Bool lock; + List *pd_blocklst; + List *pd_ctnlst; +}STD_DATA; + +D_FILE *initDataFileForWrite(char *route); +D_FILE *initDataFileForRead(char *route); +STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned long long data_size); +STD_CTN *initStandardDConnection(SID *f_sid, SID *s_sid); +STD_DATA *initStandardData(unsigned int type); + +int dataForStandardDBlock(STD_BLOCKS *p_stdb,void *data); +int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std); +int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,void *data, unsigned long long data_size); +int standardDataAddConnection(STD_DATA *p_std, SID *f_sid, SID *s_sid); +int dataFileWriteIn(D_FILE *p_dfile); +int dataFileReadOut(D_FILE *p_dfile); + +int releaseSTDBlocks(STD_BLOCKS *p_stdb); +int releaseStandardData(STD_DATA *p_std); +int releaseSTDConnection(STD_CTN *p_stdc); +int releaseDFile(D_FILE *p_file); + +List *_doStandardDataInfoWrite(unsigned int type, void *value, List *er_list); +List *_doStandardDataWrite(unsigned int type, void *value, List *er_list); +List *_doStandardDConnectionWrite(unsigned int type, void *value, List *er_list); +List *_doStandardDBlockWrite(unsigned int type, void *value, List *er_list); + +STD_DATA *listToSTD(List *); +STD_DATA *stackToSTD(Stack *); +STD_DATA *treeToSTD(Tree *); #endif /* communicate_h */ diff --git a/list/list.c b/list/list.c index b4c3abd..2c86746 100644 --- a/list/list.c +++ b/list/list.c @@ -9,12 +9,12 @@ int safeModeForNode(int ifon) { if (node_list == NULL && list_list == NULL) { node_list = (List *)malloc(sizeof(List)); if(node_list == NULL){ - showError(pushError(LIST, HIGH, initInfo("safeModeForNode()", "Error in get the memory of node_list."))); + showError(pushError(LIST, HIGH, initInfo("safeModeForNode()", "Error in getting the memory of node_list."))); return -1; } list_list = (List *)malloc(sizeof(List)); if(list_list == NULL){ - showError(pushError(LIST, HIGH, initInfo("safeModeForNode()", "Error in get the memory of list_list."))); + showError(pushError(LIST, HIGH, initInfo("safeModeForNode()", "Error in getting the memory of list_list."))); return -1; } list_list->head = NULL; @@ -89,7 +89,7 @@ int releaseAllForNode(void) { Node *initNode(void) { Node *p_node = (Node *)malloc(sizeof(Node)); if(p_node == NULL){ - showError(pushError(LIST_NODE, STANDARD, initInfo("initNode()", "Error in get the memory of node."))); + showError(pushError(LIST_NODE, STANDARD, initInfo("initNode()", "Error in getting the memory of node."))); return NULL; } Node *prec_node = NULL; @@ -113,7 +113,7 @@ List *initList(void) { Node *p_node = NULL; List *p_list = (List *)malloc(sizeof(List)); if(p_list == NULL){ - showError(pushError(LIST_NODE, STANDARD, initInfo("initList()", "Error in get the memory of list."))); + showError(pushError(LIST_NODE, STANDARD, initInfo("initList()", "Error in getting the memory of list."))); return NULL; } p_list->s_id = getS_id(LIST, 1); @@ -131,10 +131,10 @@ List *initList(void) { return p_list; } -int initMallocValueForNode(Node *p_node, unsigned int type, void *p_value) { +int initMallocValueForNode(Node *p_node, unsigned int type, const void *p_value) { p_node->if_malloc = 1; p_node->type = type; - p_node->value = p_value; + p_node->value = (void *)p_value; return 0; } @@ -479,7 +479,7 @@ int releaseNodeForCustom(Node *p_node, int (*func)(void *)){ removeByNode(node_list, p_node); } if (p_node->if_malloc == 1) { - if (!func(p_node->value)) + if (func(p_node->value)) showError(pushError(LIST_NODE, STANDARD, initInfo("releaseNodeForCustom()", "Error in using custom freeing value function."))); p_node->value = NULL; } diff --git a/list/list.h b/list/list.h index 349b525..9124f4b 100644 --- a/list/list.h +++ b/list/list.h @@ -11,7 +11,7 @@ int releaseAllForNode(void); List *initList(void); Node *initNode(void); -int initMallocValueForNode(Node *,unsigned int,void *); +int initMallocValueForNode(Node *,unsigned int,const void *); int insertInHead(List *p_list, Node *p_node); int insertInTail(List *p_list, Node *p_node); diff --git a/list/list_expand.c b/list/list_expand.c index e0cf001..411163d 100644 --- a/list/list_expand.c +++ b/list/list_expand.c @@ -2,16 +2,37 @@ Node *nodeWithInt(int m_int) { Node *p_node; - int *p_int = (int *)malloc(sizeof(int)); + int *p_int = (int *)malloc(sizeof(int)); + if(p_int == NULL){ + showError(pushError(INT, STANDARD, initInfo("nodeWithInt()", "Error in getting the memory of int."))); + return NULL; + } *p_int = m_int; p_node = initNode(); initMallocValueForNode(p_node, INT, (void *)p_int); return p_node; +} + +Node *nodeWithUInt(unsigned int m_uint){ + Node *p_node; + unsigned int *pu_int = (unsigned int *)malloc(sizeof(unsigned int)); + if(pu_int == NULL){ + showError(pushError(INT, STANDARD, initInfo("nodeWithUInt()", "Error in getting the memory of int."))); + return NULL; + } + *pu_int = m_uint; + p_node = initNode(); + initMallocValueForNode(p_node, INT, (void *)pu_int); + return p_node; } Node *nodeWithDouble(double m_double) { Node *p_node; - double *p_double = (double *)malloc(sizeof(double)); + double *p_double = (double *)malloc(sizeof(double)); + if(p_double == NULL){ + showError(pushError(DOUBLE, STANDARD, initInfo("nodeWithDouble()", "Error in getting the memory of double."))); + return NULL; + } *p_double = m_double; p_node = initNode(); initMallocValueForNode(p_node, DOUBLE, (void *)p_double); @@ -20,14 +41,18 @@ Node *nodeWithDouble(double m_double) { Node *nodeWithString(const char *m_string) { Node *p_node; - char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string) + 1)); + char *p_string = (char *)malloc(sizeof(char)*(strlen(m_string) + 1)); + if(p_string == NULL){ + showError(pushError(STRING, STANDARD, initInfo("initWithString()", "Error in getting the memory of string."))); + return NULL; + } strcpy(p_string, m_string); p_node = initNode(); initMallocValueForNode(p_node, STRING, (void *)p_string); return p_node; } -Node *nodeWithPointer(void *m_pointer) { +Node *nodeWithPointer(const void *m_pointer) { Node *p_node = initNode(); initMallocValueForNode(p_node, POINTER, m_pointer); return p_node; @@ -50,28 +75,38 @@ Node *findByIndexForNode(List *p_list, unsigned long long m_index) { return p_node; } -int listThrough(List *p_list, int(*p_func)(unsigned int, void *)) { - Node *p_node = p_list->head; +List *listThrough(List *p_list, List *(*p_func)(unsigned int, void *, List *), List *expand_resources) { + Node *p_node = p_list->head; + List *m_rtnlst = NULL; while (p_node != NULL) { if (p_node->if_malloc == 1) { - int m_return = (*p_func)(p_node->type, p_node->value); - if (m_return == -1) break; - else if (m_return == 1) { - p_node = p_node->last; + List *m_rtnlst = (*p_func)(p_node->type, p_node->value, expand_resources); + int status = getByIntForNode(findByIndexForNode(m_rtnlst, 0)); + if (status == -1) break; + else if (status == 1) { + p_node = p_node->last; + releaseList(m_rtnlst); + m_rtnlst = NULL; continue; } else { - + releaseList(m_rtnlst); + m_rtnlst = NULL; } } p_node = p_node->next; } - return 0; + return m_rtnlst; } int getByIntForNode(Node *p_node) { if (p_node->type == INT) return *(int *)(p_node->value); else return -1; +} + +unsigned int getByUIntForNode(Node *p_node){ + if (p_node->type == UINT) return *(unsigned int *)(p_node->value); + else return -1; } char *getByStringForNode(Node *p_node) { @@ -249,7 +284,11 @@ int addValueForComplex(Node * p_node, int type, void *value) { int addIntForComplex(Node *p_node, int temp) { if (p_node->type == LIST) { - int *p_temp = (int *)malloc(sizeof(int)); + int *p_temp = (int *)malloc(sizeof(int)); + if(p_temp == NULL){ + showError(pushError(INT, STANDARD, initInfo("addIntForComplex()", "Error in getting the memory of int."))); + return -1; + } *p_temp = temp; addValueForComplex(p_node, INT, p_temp); return 0; @@ -259,7 +298,11 @@ int addIntForComplex(Node *p_node, int temp) { int addDoubleForComplex(Node *p_node, double temp) { if (p_node->type == LIST) { - double *p_temp = (double *)malloc(sizeof(double)); + double *p_temp = (double *)malloc(sizeof(double)); + if(p_temp == NULL){ + showError(pushError(DOUBLE, STANDARD, initInfo("addDoubleForComplex()", "Error in getting the memory of double."))); + return -1; + } *p_temp = temp; addValueForComplex(p_node, DOUBLE, p_temp); return 0; @@ -269,7 +312,11 @@ int addDoubleForComplex(Node *p_node, double temp) { int addStringForComplex(Node *p_node, char *temp) { if (p_node->type == LIST) { - char *p_temp = (char *)malloc(sizeof(strlen(temp) + 1)); + char *p_temp = (char *)malloc(sizeof(strlen(temp) + 1)); + if(p_temp == NULL){ + showError(pushError(STRING, STANDARD, initInfo("addStringForComplex()", "Error in getting the memory of string."))); + return -1; + } strcpy(p_temp, temp); addValueForComplex(p_node, STRING, p_temp); return 0; @@ -286,7 +333,11 @@ int addPointerForComplex(Node *p_node, void *temp) { } List *m_findByInt(List* p_list, int temp) { - int *p_temp = (int *)malloc(sizeof(int)); + int *p_temp = (int *)malloc(sizeof(int)); + if(p_temp == NULL){ + showError(pushError(INT, STANDARD, initInfo("m_findByInt()", "Error in getting the memory of int."))); + return NULL; + } List *t_list; *p_temp = temp; t_list = mply_findByValue(p_list, INT, (void *)p_temp); @@ -296,7 +347,11 @@ List *m_findByInt(List* p_list, int temp) { List *m_findByDouble(List* p_list, double temp) { List *t_list; - double *p_temp = (double *)malloc(sizeof(double)); + double *p_temp = (double *)malloc(sizeof(double)); + if(p_temp == NULL){ + showError(pushError(DOUBLE, STANDARD, initInfo("m_findByDouble()", "Error in getting the memory of double."))); + return NULL; + } *p_temp = temp; t_list = mply_findByValue(p_list, DOUBLE, (void *)p_temp); free(p_temp); @@ -305,7 +360,11 @@ List *m_findByDouble(List* p_list, double temp) { List *m_findByString(List* p_list, char *temp) { List *t_list; - char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1)); + char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1)); + if(p_temp == NULL){ + showError(pushError(STRING, STANDARD, initInfo("m_findByString()", "Error in getting the memory of string."))); + return NULL; + } strcpy(p_temp, temp); t_list = mply_findByValue(p_list, STRING, (void *)p_temp); free(p_temp); @@ -329,19 +388,31 @@ unsigned long long getIndexByNode(List *p_list, Node *p_node) { } List *m_findByIntForNode(List* p_list, int temp) { - int *p_temp = (int *)malloc(sizeof(int)); + int *p_temp = (int *)malloc(sizeof(int)); + if(p_temp == NULL){ + showError(pushError(INT, STANDARD, initInfo("m_findByIntForNode()", "Error in getting the memory of int."))); + return NULL; + } *p_temp = temp; return mply_findByValue(p_list, INT, (void *)p_temp); } List *m_findByDoubleForNode(List* p_list, double temp) { - double *p_temp = (double *)malloc(sizeof(double)); + double *p_temp = (double *)malloc(sizeof(double)); + if(p_temp == NULL){ + showError(pushError(DOUBLE, STANDARD, initInfo("m_findByDoubleForNode()", "Error in getting the memory of double."))); + return NULL; + } *p_temp = temp; return mply_findByValue(p_list, DOUBLE, (void *)p_temp); } List *m_findByStringForNode(List* p_list, char *temp) { - char *p_temp = (char *)malloc(sizeof(char) * (strlen(temp) + 1)); + char *p_temp = (char *)malloc(sizeof(char) * (strlen(temp) + 1)); + if(p_temp == NULL){ + showError(pushError(STRING, STANDARD, initInfo("m_findByStringForNode()", "Error in getting the memory of string."))); + return NULL; + } strcpy(p_temp, temp); return mply_findByValue(p_list, STRING, (void *)p_temp); } @@ -359,4 +430,46 @@ unsigned long long calListMemory(List * p_list){ p_node = p_node->next; } return list_size + nodes_size; +} + +int updateValueWithInt(Node *p_node,int value){ + int *p_value = (int *)malloc(sizeof(int)); + if(p_value == NULL){ + showError(pushError(INT, STANDARD, initInfo("updateValueWithInt()", "Error in getting the memory of int."))); + return -1; + } + *p_value = value; + free(p_node->value); + p_node->value = p_value; + return 0; } + +int updateValueWithDouble(Node *p_node, double value){ + double *p_value = (double *)malloc(sizeof(double)); + if(p_value == NULL){ + showError(pushError(DOUBLE, STANDARD, initInfo("updateValueWithDouble()", "Error in getting the memory of double."))); + return -1; + } + *p_value = value; + free(p_node->value); + p_node->value = p_value; + return 0; +} + +int updateValueWithString(Node *p_node, char *string){ + char *p_value = (char *)malloc(sizeof(strlen(string)) + 1); + if(p_value == NULL){ + showError(pushError(STRING, STANDARD, initInfo("updateValueWithString()", "Error in getting the memory of string."))); + return -1; + } + strcpy(p_value, string); + free(p_node->value); + p_node->value = p_value; + return 0; +} + +int updateValueWithPointer(Node *p_node, void *pointer){ + free(p_node->value); + p_node->value = pointer; + return 0; +} diff --git a/list/list_expand.h b/list/list_expand.h index 1d8d97e..dff20b7 100644 --- a/list/list_expand.h +++ b/list/list_expand.h @@ -3,17 +3,24 @@ #include "list.h" -Node *nodeWithInt(int); +Node *nodeWithInt(int); +Node *nodeWithUInt(unsigned int); Node *nodeWithDouble(double); Node *nodeWithString(const char *); -Node *nodeWithPointer(void *); +Node *nodeWithPointer(const void *); Node *nodeWithComplex(void); int addValueForComplex(Node *, int type, void *value); int addIntForComplex(Node *, int); int addDoubleForComplex(Node *, double); int addStringForComplex(Node *, char *); -int addPointerForComplex(Node *, void *); +int addPointerForComplex(Node *, void *); + +int updateValueWithInt(Node *,int); +int updateValueWithDouble(Node *,double); +int updateValueWithString(Node *,char *); +int updateValueWithPointer(Node *,void *); + Node *findByIndexForNode(List *, unsigned long long); Node *findByIntForNode(List *, int); @@ -31,12 +38,13 @@ void printNodeInfo(Node *p_node,int priority); void printList(List *); void printNode(Node *p_node); -int getByIntForNode(Node *); +int getByIntForNode(Node *); +unsigned int getByUIntForNode(Node *); double getByDoubleForNode(Node *); char *getByStringForNode(Node *); void *getByPointerForNode(Node *); unsigned long long getIndexByNode(List *p_list,Node *p_node); -int listThrough(List *p_list, int (*p_func)(unsigned int type, void *value)); +List *listThrough(List *p_list, List *(*p_func)(unsigned int type, void *value, List *), List *expand_resources); unsigned long long calListMemory(List *); #endif diff --git a/stack/stack.c b/stack/stack.c index acaee3f..f4b8ae1 100644 --- a/stack/stack.c +++ b/stack/stack.c @@ -3,7 +3,7 @@ Stack *initStack(void) { Stack *p_stack = (Stack *)malloc(sizeof(Stack)); if(p_stack == NULL){ - showError(pushError(STACK, STANDARD, initInfo("initStack()", "Error in get the memory of stack."))); + showError(pushError(STACK, STANDARD, initInfo("initStack()", "Error in getting the memory of stack."))); return NULL; } p_stack->s_id = getS_id(STACK, 1); @@ -15,7 +15,7 @@ Stack *initStack(void) { SNode *initSNode(void) { SNode *p_snode = (SNode *)malloc(sizeof(SNode)); if(p_snode == NULL){ - showError(pushError(STACK_NODE, STANDARD, initInfo("initSNode()", "Error in get the memory of snode."))); + showError(pushError(STACK_NODE, STANDARD, initInfo("initSNode()", "Error in getting the memory of snode."))); return NULL; } p_snode->s_id = getS_id(STACK_NODE, 2); diff --git a/stack/stack.h b/stack/stack.h index d20f752..ef36892 100644 --- a/stack/stack.h +++ b/stack/stack.h @@ -1,23 +1,8 @@ #ifndef STACK_H #define STACK_H +#include "../type/type.h" #include "../list/list_expand.h" -typedef struct stack_node{ - SID *s_id; - _Bool if_malloc; - _Bool if_sid; - unsigned int type; - void *value; - struct stack_node *next; -} SNode; - -typedef struct stack{ - SID *s_id; - unsigned long long length; - SNode *top; - _Bool if_sid; -} Stack; - Stack *initStack(void); SNode *initSNode(void); int initMallocValueForSNode(SNode *p_snode, unsigned int type, void *value); diff --git a/stack/stack_expand.c b/stack/stack_expand.c index f48ad09..b0b3aa1 100644 --- a/stack/stack_expand.c +++ b/stack/stack_expand.c @@ -2,7 +2,11 @@ SNode *snodeWithInt(int temp) { SNode *p_snode = initSNode(); - int *p_temp = (int *)malloc(sizeof(int)); + int *p_temp = (int *)malloc(sizeof(int)); + if(p_temp == NULL){ + showError(pushError(INT, STANDARD, initInfo("snodeWithInt()", "Error in getting the memory of int."))); + return NULL; + } *p_temp = temp; initMallocValueForSNode(p_snode, INT, p_temp); return p_snode; @@ -10,7 +14,11 @@ SNode *snodeWithInt(int temp) { SNode *snodeWithDouble(double temp) { SNode *p_snode = initSNode(); - double *p_temp = (double *)malloc(sizeof(double)); + double *p_temp = (double *)malloc(sizeof(double)); + if(p_temp == NULL){ + showError(pushError(DOUBLE, STANDARD, initInfo("snodeWithDouble()", "Error in getting the memory of double."))); + return NULL; + } *p_temp = temp; initMallocValueForSNode(p_snode, DOUBLE, p_temp); return p_snode; @@ -18,7 +26,11 @@ SNode *snodeWithDouble(double temp) { SNode *snodeWithString(char *temp) { SNode *p_snode = initSNode(); - char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1)); + char *p_temp = (char *)malloc(sizeof(char)*(strlen(temp) + 1)); + if(p_temp == NULL){ + showError(pushError(STRING, STANDARD, initInfo("snodeWithString()", "Error in getting the memory of string."))); + return NULL; + } strcpy(p_temp, temp); initMallocValueForSNode(p_snode, STRING, p_temp); return p_snode; diff --git a/test.c b/test.c index bd9d494..7de1db3 100644 --- a/test.c +++ b/test.c @@ -81,8 +81,25 @@ int stack(void) { } -int main(int argc, char **argv) { - //tree(); - init_rand(); +int main(int argc, char **argv) { + init_rand(); + for (int j = 0; j < 65535; j++) { + List *t_list = initList(); + for (int i = 0; i < 12; i++) { + insertInHead(t_list, nodeWithInt(i)); + } + STD_DATA *p_std = listToSTD(t_list); + D_FILE *p_dfilew = initDataFileForWrite("data.df"); + dataFileAddStandardData(p_dfilew, p_std); + dataFileWriteIn(p_dfilew); + releaseDFile(p_dfilew); + D_FILE *p_dfiler = initDataFileForRead("data.df"); + dataFileReadOut(p_dfiler); + releaseDFile(p_dfiler); + releaseList(t_list); + + printf("%d\n",j); + usleep(2000); + } return 0; } diff --git a/test.h b/test.h index dfa8642..6dcdf20 100644 --- a/test.h +++ b/test.h @@ -4,7 +4,8 @@ #include "type/type.h" #include "list/list_expand.h" #include "stack/stack_expand.h" -#include "tree/tree_expand.h" +#include "tree/tree_expand.h" +#include "communicate/communicate.h" int stack(void); int list(void); diff --git a/tree/tree.c b/tree/tree.c index 276304d..af965d8 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -1,7 +1,5 @@ #include"tree.h" -static SID *target_sid = NULL; -static TNode *target_value_sid = NULL; static int if_safeModeForTree = 0; int safeModeForTree(int ifon) { @@ -39,7 +37,7 @@ TNode *initTNode(void) { Node *s_node; TNode *p_tnode = (TNode *)malloc(sizeof(TNode)); if(p_tnode == NULL){ - showError(pushError(TREE_NODE, STANDARD, initInfo("initTNode()", "Error in get the memory of tnode."))); + showError(pushError(TREE_NODE, STANDARD, initInfo("initTNode()", "Error in getting the memory of tnode."))); return NULL; } p_tnode->s_id = getS_id(TREE_NODE, 2); @@ -73,7 +71,7 @@ Tree *initTree(void) { Node *s_node; Tree *p_tree = (Tree *)malloc(sizeof(Tree)); if(p_tree == NULL){ - showError(pushError(TREE, STANDARD, initInfo("initTree()", "Error in get the memory of tree."))); + showError(pushError(TREE, STANDARD, initInfo("initTree()", "Error in getting the memory of tree."))); return NULL; } p_tree->s_id = getS_id(TREE, 1); @@ -163,79 +161,100 @@ int removeChildInRight(TNode *p_tnode) { TNode *getChildById(TNode *p_tnode, const SID *s_id) { List *p_home = p_tnode->home; - target_sid = NULL; - target_value_sid = NULL; - listThrough(p_home, _dogetChildById); - if (target_value_sid != NULL) { - return target_value_sid; + target_value_sid = NULL; + List *er_list = initList(); + insertInTail(er_list, nodeWithPointer(s_id)); + List *rtnc_list = listThrough(p_home, _dogetChildById, er_list); + free(er_list); + Node *p_node= findByIndexForNode(rtnc_list, 1); + if (p_node != NULL) { + TNode *p_tnode = getByPointerForNode(p_node); + free(rtnc_list); + return p_tnode; } return NULL; } -int _dogetChildById(unsigned int type, void *value) { +List *_dogetChildById(unsigned int type, void *value, List *er_list) { + SID *target_sid = getByPointerForNode(findByIndexForNode(er_list, 0)); + List *rtn_list = initList(); if (type == POINTER) { TNode *p_tode = (TNode *)value; if (simFitS_id(p_tode->s_id, target_sid)) { - target_value_sid = p_tode; - return -1; + target_value_sid = p_tode; + insertInTail(rtn_list, nodeWithInt(-1)); + insertInTail(rtn_list, nodeWithPointer(target_value_sid)); + return rtn_list; } - } - return 0; + } + insertInTail(rtn_list, nodeWithInt(0)); + return rtn_list; } -static int target_type = VOID; -static void *target_value = NULL; -static TNode *target_value_value = NULL; - TNode *getChildByValue(TNode *p_tnode, unsigned int type, void *value) { List *p_home = p_tnode->home; target_value = value; target_type = type; - target_value_value = NULL; - listThrough(p_home, _dogetChildByValue); - if (target_value_value != NULL) { - return target_value_value; + target_value_value = NULL; + List *er_list = initList(); + insertInTail(er_list, nodeWithUInt(type)); + insertInTail(er_list, nodeWithPointer(value)); + List *rtnc_list = listThrough(p_home, _dogetChildByValue,er_list); + free(er_list); + Node *p_node = NULL; + if ((p_node = findByIndexForNode(rtnc_list, 1)) != NULL) { + TNode *p_tnode = getByPointerForNode(p_node); + free(rtnc_list); + return p_tnode; } return NULL; } -int _dogetChildByValue(unsigned int type, void *value) { +List *_dogetChildByValue(unsigned int type, void *value, List *er_list) { + List *rtn_list = initList(); + unsigned int target_type = getByUIntForNode(findByIndexForNode(rtn_list, 0)); + void *target_value = getByPointerForNode(findByIndexForNode(rtn_list, 1)); if (type == target_type) { TNode *p_tode = (TNode *)value; if (target_type == INT) { if (*(int *)p_tode->value == *(int *)target_value) - { - target_value_value = p_tode; - return -1; + { + insertInTail(rtn_list, nodeWithInt(-1)); + insertInTail(rtn_list, nodeWithPointer(p_tode)); + return rtn_list; } } else if (target_type == DOUBLE) { if (*(double *)p_tode->value == *(double *)target_value) - { - target_value_value = p_tode; - return -1; + { + insertInTail(rtn_list, nodeWithInt(-1)); + insertInTail(rtn_list, nodeWithPointer(p_tode)); + return rtn_list; } } else if (target_type == STRING) { if (!strcmp((char *)p_tode->value, (char *)target_value)) - { - target_value_value = p_tode; - return -1; + { + insertInTail(rtn_list, nodeWithInt(-1)); + insertInTail(rtn_list, nodeWithPointer(p_tode)); + return rtn_list; } } else if (target_type == POINTER) { if (p_tode->value == target_value) - { - target_value_value = p_tode; - return -1; + { + insertInTail(rtn_list, nodeWithInt(-1)); + insertInTail(rtn_list, nodeWithPointer(p_tode)); + return rtn_list; } } - } - return 0; + } + insertInTail(rtn_list, nodeWithInt(0)); + return rtn_list; } int removeChildById(TNode *p_tnode, const SID *s_id) { diff --git a/tree/tree.h b/tree/tree.h index 2504c6f..d4b8a3d 100644 --- a/tree/tree.h +++ b/tree/tree.h @@ -28,8 +28,8 @@ int TreeThroughDown(Tree *p_tree, int(*func)(TNode *, unsigned long long height) int TreeThroughUp(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); int TreeTravel(Tree *p_tree, int(*func)(TNode *, unsigned long long height)); -int _dogetChildById(unsigned int type, void *value); -int _dogetChildByValue(unsigned int type, void *value); +List *_dogetChildById(unsigned int type, void *value, List *er_list); +List *_dogetChildByValue(unsigned int type, void *value, List *er_list); int _doreleaseTree(TNode *p_tnode, unsigned long long height); int _doTreeThroughDown(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)); int _doTreeThroughUp(TNode *p_tnode, int height, int(*func)(TNode *, unsigned long long height)); diff --git a/tree/tree_expand.c b/tree/tree_expand.c index e188663..5d9992d 100644 --- a/tree/tree_expand.c +++ b/tree/tree_expand.c @@ -2,7 +2,11 @@ TNode *tnodeWithInt(int temp) { TNode *p_tnode = initTNode(); - int *p_temp = (int *)malloc(sizeof(int)); + int *p_temp = (int *)malloc(sizeof(int)); + if(p_temp == NULL){ + showError(pushError(INT, STANDARD, initInfo("tnodeWithInt()", "Error in getting the memory of int."))); + return NULL; + } *p_temp = temp; initMallocValueForTNode(p_tnode, INT, p_temp); return p_tnode; @@ -10,14 +14,22 @@ TNode *tnodeWithInt(int temp) { TNode *tnodeWithDouble(double temp) { TNode *p_tnode = initTNode(); - double *p_temp = (double *)malloc(sizeof(double)); + double *p_temp = (double *)malloc(sizeof(double)); + if(p_temp == NULL){ + showError(pushError(DOUBLE, STANDARD, initInfo("tnodeWithDouble()", "Error in getting the memory of double."))); + return NULL; + } *p_temp = temp; initMallocValueForTNode(p_tnode, DOUBLE, p_temp); return p_tnode; } TNode *tnodeWithString(char *temp) { TNode *p_tnode = initTNode(); - char *p_temp = (char *)malloc(sizeof(temp)); + char *p_temp = (char *)malloc(sizeof(temp)); + if(p_temp == NULL){ + showError(pushError(STRING, STANDARD, initInfo("tnodeWithString()", "Error in getting the memory of string."))); + return NULL; + } strcpy(p_temp, temp); initMallocValueForTNode(p_tnode, STRING, p_temp); return p_tnode; diff --git a/type/type.h b/type/type.h index 47f5cca..b93035b 100644 --- a/type/type.h +++ b/type/type.h @@ -5,6 +5,7 @@ #include #include #include +#include #define VOID 0 #define INT 1 @@ -18,6 +19,9 @@ #define TREE_NODE 9 #define STACK_NODE 10 #define T_SID 11 +#define UINT 12 +#define STANDARD_DATA 13 +#define DATA_FILE 14 #define DEEPC 1 #define DEEPB 2 @@ -27,6 +31,12 @@ #define DEEPB_LEN 8 #define DEEPA_LEN 32 #define DATA_BIT 5 +#define DEEP_LEN 25 +#define DEEPER_LEN 65 +#define DEEPEST_LEN 225 +#define FILE_TSET_LEN 18 +#define HEAD_TEST_LEN 9 + #define HIGH 0x3 #define STANDARD 0x2 @@ -83,6 +93,22 @@ typedef struct Log{ unsigned long int id; }Log; +typedef struct stack_node{ + SID *s_id; + _Bool if_malloc; + _Bool if_sid; + unsigned int type; + void *value; + struct stack_node *next; +} SNode; + +typedef struct stack{ + SID *s_id; + unsigned long long length; + SNode *top; + _Bool if_sid; +} Stack; + typedef struct tree_node { SID *s_id; From 3ce69ae8e555b09e325d8d0da8710f4bfb6edcc8 Mon Sep 17 00:00:00 2001 From: Saturneic Date: Tue, 7 Aug 2018 12:55:59 +0800 Subject: [PATCH 53/55] Add and Fixed. --- .../xcdebugger/Breakpoints_v2.xcbkptlist | 182 +++++++----------- communicate/communicate.c | 41 +++- communicate/communicate.h | 48 +---- list/list.c | 2 +- stack/stack.c | 2 +- test.c | 29 ++- tree/tree.c | 2 +- type/type.h | 37 ++++ 8 files changed, 159 insertions(+), 184 deletions(-) diff --git a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist index c3ec7ec..abe8217 100644 --- a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist +++ b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist @@ -154,7 +154,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "test.c" - timestampString = "555307651.589517" + timestampString = "555310052.789754" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "64" @@ -175,7 +175,7 @@ endingColumnNumber = "9223372036854775807" startingLineNumber = "60" endingLineNumber = "60" - landmarkName = "printTNode" + landmarkName = "getValueByStringForTree" landmarkType = "9"> @@ -525,11 +525,11 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "test.c" - timestampString = "555307651.590879" + timestampString = "555310052.790392" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" - startingLineNumber = "89" - endingLineNumber = "89" + startingLineNumber = "88" + endingLineNumber = "88" landmarkName = "main" landmarkType = "9"> @@ -541,11 +541,11 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "test.c" - timestampString = "555307651.5910259" + timestampString = "555310052.790665" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" - startingLineNumber = "91" - endingLineNumber = "91" + startingLineNumber = "90" + endingLineNumber = "90" landmarkName = "main" landmarkType = "9"> @@ -557,7 +557,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "list/list_expand.c" - timestampString = "555307651.591181" + timestampString = "555309906.510792" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "83" @@ -573,11 +573,11 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "test.c" - timestampString = "555307651.591266" + timestampString = "555310052.790953" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" - startingLineNumber = "93" - endingLineNumber = "93" + startingLineNumber = "92" + endingLineNumber = "92" landmarkName = "main" landmarkType = "9"> @@ -589,7 +589,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.591457" + timestampString = "555310052.791223" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "102" @@ -605,7 +605,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.592109" + timestampString = "555310052.791289" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "137" @@ -621,7 +621,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.592618" + timestampString = "555310052.791344" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "124" @@ -630,22 +630,6 @@ landmarkType = "9"> - - - - + startingLineNumber = "100" + endingLineNumber = "100"> @@ -749,7 +731,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.595166" + timestampString = "555310052.792271" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "231" @@ -765,7 +747,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.595765" + timestampString = "555310052.792323" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "186" @@ -781,7 +763,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.596207" + timestampString = "555310052.7923729" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "38" @@ -797,7 +779,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.596637" + timestampString = "555310052.792423" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "120" @@ -813,7 +795,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.597056" + timestampString = "555310052.792475" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "194" @@ -829,7 +811,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.597474" + timestampString = "555310052.792524" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "217" @@ -861,7 +843,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.597941" + timestampString = "555310052.792592" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "224" @@ -877,7 +859,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.598327" + timestampString = "555310052.792645" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "17" @@ -893,7 +875,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.598729" + timestampString = "555310052.792713" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "7" @@ -909,7 +891,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.599126" + timestampString = "555310052.7927589" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "43" @@ -925,7 +907,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.599665" + timestampString = "555310052.792803" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "170" @@ -941,7 +923,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.6000921" + timestampString = "555310052.7928669" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "221" @@ -957,7 +939,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.600467" + timestampString = "555310052.792913" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "223" @@ -973,7 +955,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.600853" + timestampString = "555310052.792958" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "151" @@ -989,7 +971,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.601244" + timestampString = "555310052.7930011" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "153" @@ -1005,7 +987,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "communicate/communicate.c" - timestampString = "555307651.601626" + timestampString = "555310052.793045" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "226" @@ -1021,7 +1003,7 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "list/list_expand.c" - timestampString = "555307651.602327" + timestampString = "555309906.512913" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" startingLineNumber = "103" @@ -1037,13 +1019,11 @@ ignoreCount = "0" continueAfterRunningActions = "No" filePath = "test.c" - timestampString = "555307651.6025029" + timestampString = "555310052.793105" startingColumnNumber = "9223372036854775807" endingColumnNumber = "9223372036854775807" - startingLineNumber = "104" - endingLineNumber = "104" - landmarkName = "main" - landmarkType = "9"> + startingLineNumber = "99" + endingLineNumber = "99"> + + + + - - - - - - - - - - - - diff --git a/communicate/communicate.c b/communicate/communicate.c index 73a86a5..c3cf45f 100644 --- a/communicate/communicate.c +++ b/communicate/communicate.c @@ -1,11 +1,12 @@ #include "communicate.h" -STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned long long data_size){ +STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned int type, unsigned long long data_size){ STD_BLOCKS *p_stdb = (STD_BLOCKS *)malloc(sizeof(STD_BLOCKS)); p_stdb->sid = s_idToASCIIString(p_sid); p_stdb->if_data = 0; unsigned int blocks_num = (unsigned int)(data_size/sizeof(char)); p_stdb->blocks_num = blocks_num; + p_stdb->type = type; p_stdb->buff = (char *)malloc(sizeof(char) * blocks_num); return p_stdb; } @@ -34,13 +35,13 @@ STD_DATA *initStandardData(unsigned int type){ p_std->pd_ctnlst = initList(); p_std->lock = 0; p_std->type = type; - p_std->s_id = getS_id(STANDARD_DATA, 2); + p_std->s_id = getS_id(STANDARD_DATA, 1); return p_std; } -int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,void *data, unsigned long long data_size){ +int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,unsigned int type, void *data, unsigned long long data_size){ if (p_std->lock) return -1; - STD_BLOCKS *p_stdb = initStandardDBlocks(p_sid, data_size); + STD_BLOCKS *p_stdb = initStandardDBlocks(p_sid, type,data_size); dataForStandardDBlock(p_stdb, data); insertInTail(p_std->pd_blocklst, nodeWithPointer(p_stdb)); return 0; @@ -150,6 +151,7 @@ List *_doStandardDBlockWrite(unsigned int type, void *value, List *er_list){ unsigned long sid_len = strlen(p_stdb->sid)+1, blocks_num = p_stdb->blocks_num; fwrite(&sid_len, sizeof(unsigned long), 1, fp); fwrite(p_stdb->sid, sizeof(char), sid_len, fp); + fwrite(&p_stdb->type, sizeof(unsigned int), 1, fp); fwrite(&blocks_num, sizeof(unsigned long), 1, fp); fwrite(p_stdb->buff, sizeof(char), p_stdb->blocks_num, fp); return p_rtnlst; @@ -164,7 +166,7 @@ STD_DATA *listToSTD(List *p_list){ else if (p_node->type == DOUBLE) data_size = sizeof(double); else if (p_node->type == STRING) data_size = strlen((char *)p_node->value) + 1; else data_size = sizeof(void *); - standardDataAddBlock(p_std, p_node->s_id, p_node->value, data_size); + standardDataAddBlock(p_std, p_node->s_id, p_node->type, p_node->value, data_size); p_node = p_node->next; } return p_std; @@ -220,7 +222,9 @@ int dataFileReadOut(D_FILE *p_dfile){ char *content = (char *)malloc(sizeof(char) * blk_len); fread(content, sizeof(char), blk_len, p_dfile->fp); SID *s_id = asciiStringToS_id(string_sid); - standardDataAddBlock(p_std, s_id, content, blk_len); + unsigned int type = VOID; + fread(&type, sizeof(unsigned int), 1, p_dfile->fp); + standardDataAddBlock(p_std, s_id, type, content, blk_len); freeS_id(s_id); free(string_sid); free(content); @@ -230,6 +234,9 @@ int dataFileReadOut(D_FILE *p_dfile){ else break; } } + else{ + + } } showError(pushError(DATA_FILE, STANDARD, initInfo("dataFileReadOut()", "Datafile not complete."))); return -1; @@ -264,3 +271,25 @@ int releaseDFile(D_FILE *p_dfile){ free(p_dfile); return 0; } + +List *standardDataToList(STD_DATA *p_std){ + List *p_list = initList(); + List *er_list = initList(); + insertInTail(er_list, nodeWithPointer(er_list)); + listThrough(p_std->pd_blocklst, _doStandardDataToList, er_list); + return p_list; +} + +List *_doStandardDataToList(unsigned int type, void *value, List *er_list){ + List *rtn_list = initList(); + insertInTail(rtn_list, nodeWithInt(0)); + List *p_list = getByPointerForNode(findByIndexForNode(er_list, 0)); + STD_BLOCKS *p_stdb = value; + Node *p_node = initNode(); + p_node->s_id = asciiStringToS_id(p_stdb->sid); + p_node->type = p_stdb->type; + p_node->value = malloc(sizeof(p_stdb->blocks_num)); + memcpy(p_node->value, p_stdb->buff, sizeof(p_stdb->blocks_num)); + insertInTail(p_list, p_node); + return rtn_list; +} diff --git a/communicate/communicate.h b/communicate/communicate.h index bb15f73..f73ea90 100644 --- a/communicate/communicate.h +++ b/communicate/communicate.h @@ -7,55 +7,19 @@ typedef struct message{ SID *p_sid; char titile[16]; + unsigned long size; char content[0]; }MSG; -typedef struct file_head{ - char head_test[18]; - unsigned long long data_num; -}F_HEAD; - -typedef struct data_file{ - FILE *fp; - F_HEAD *pf_head; - List *pf_stdlst; -}D_FILE; - -typedef struct standard_data_blocks{ - unsigned int type; - char *sid; - _Bool if_data; - unsigned int blocks_num; - char *buff; -}STD_BLOCKS; - -typedef struct standard_data_connection{ - char *f_sid; - char *s_sid; -}STD_CTN; - -typedef struct standard_data_head{ - unsigned long long data_blk_num; - unsigned long long data_ctn_num; -}STD_HEAD; - -typedef struct standard_data{ - SID *s_id; - unsigned int type; - _Bool lock; - List *pd_blocklst; - List *pd_ctnlst; -}STD_DATA; - D_FILE *initDataFileForWrite(char *route); D_FILE *initDataFileForRead(char *route); -STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned long long data_size); +STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned int type, unsigned long long data_size); STD_CTN *initStandardDConnection(SID *f_sid, SID *s_sid); STD_DATA *initStandardData(unsigned int type); int dataForStandardDBlock(STD_BLOCKS *p_stdb,void *data); int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std); -int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,void *data, unsigned long long data_size); +int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,unsigned int type, void *data, unsigned long long data_size); int standardDataAddConnection(STD_DATA *p_std, SID *f_sid, SID *s_sid); int dataFileWriteIn(D_FILE *p_dfile); int dataFileReadOut(D_FILE *p_dfile); @@ -71,7 +35,9 @@ List *_doStandardDConnectionWrite(unsigned int type, void *value, List *er_list) List *_doStandardDBlockWrite(unsigned int type, void *value, List *er_list); STD_DATA *listToSTD(List *); -STD_DATA *stackToSTD(Stack *); -STD_DATA *treeToSTD(Tree *); +List *standardDataToList(STD_DATA *); +List *_doStandardDataToList(unsigned int type, void *value, List *er_list); +//STD_DATA *stackToSTD(Stack *); +//STD_DATA *treeToSTD(Tree *); #endif /* communicate_h */ diff --git a/list/list.c b/list/list.c index 2c86746..67dcc73 100644 --- a/list/list.c +++ b/list/list.c @@ -93,7 +93,7 @@ Node *initNode(void) { return NULL; } Node *prec_node = NULL; - p_node->s_id = getS_id(LIST_NODE, 2); + p_node->s_id = getS_id(LIST_NODE, 1); p_node->if_sid = 1; p_node->if_malloc = 0; p_node->next = NULL; diff --git a/stack/stack.c b/stack/stack.c index f4b8ae1..7981445 100644 --- a/stack/stack.c +++ b/stack/stack.c @@ -18,7 +18,7 @@ SNode *initSNode(void) { showError(pushError(STACK_NODE, STANDARD, initInfo("initSNode()", "Error in getting the memory of snode."))); return NULL; } - p_snode->s_id = getS_id(STACK_NODE, 2); + p_snode->s_id = getS_id(STACK_NODE, 1); p_snode->if_malloc = 0; p_snode->next = NULL; p_snode->value = NULL; diff --git a/test.c b/test.c index 7de1db3..ee234f9 100644 --- a/test.c +++ b/test.c @@ -83,23 +83,18 @@ int stack(void) { int main(int argc, char **argv) { init_rand(); - for (int j = 0; j < 65535; j++) { - List *t_list = initList(); - for (int i = 0; i < 12; i++) { - insertInHead(t_list, nodeWithInt(i)); - } - STD_DATA *p_std = listToSTD(t_list); - D_FILE *p_dfilew = initDataFileForWrite("data.df"); - dataFileAddStandardData(p_dfilew, p_std); - dataFileWriteIn(p_dfilew); - releaseDFile(p_dfilew); - D_FILE *p_dfiler = initDataFileForRead("data.df"); - dataFileReadOut(p_dfiler); - releaseDFile(p_dfiler); - releaseList(t_list); - - printf("%d\n",j); - usleep(2000); + List *t_list = initList(); + for (int i = 0; i < 100; i++) { + insertInHead(t_list, nodeWithInt(i)); } + STD_DATA *p_std = listToSTD(t_list); + D_FILE *p_dfilew = initDataFileForWrite("data.df"); + dataFileAddStandardData(p_dfilew, p_std); + dataFileWriteIn(p_dfilew); + releaseDFile(p_dfilew); + D_FILE *p_dfiler = initDataFileForRead("data.df"); + dataFileReadOut(p_dfiler); + releaseDFile(p_dfiler); + releaseList(t_list); return 0; } diff --git a/tree/tree.c b/tree/tree.c index af965d8..87794fa 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -40,7 +40,7 @@ TNode *initTNode(void) { showError(pushError(TREE_NODE, STANDARD, initInfo("initTNode()", "Error in getting the memory of tnode."))); return NULL; } - p_tnode->s_id = getS_id(TREE_NODE, 2); + p_tnode->s_id = getS_id(TREE_NODE, 1); p_tnode->if_sid = 1; p_tnode->child_num = 0; p_tnode->father = NULL; diff --git a/type/type.h b/type/type.h index b93035b..2cc99a5 100644 --- a/type/type.h +++ b/type/type.h @@ -6,6 +6,7 @@ #include #include #include +#include #define VOID 0 #define INT 1 @@ -129,5 +130,41 @@ typedef struct tree TNode *root; }Tree; +typedef struct file_head{ + char head_test[18]; + unsigned long long data_num; +}F_HEAD; + +typedef struct data_file{ + FILE *fp; + F_HEAD *pf_head; + List *pf_stdlst; +}D_FILE; + +typedef struct standard_data_blocks{ + unsigned int type; + char *sid; + _Bool if_data; + unsigned int blocks_num; + char *buff; +}STD_BLOCKS; + +typedef struct standard_data_connection{ + char *f_sid; + char *s_sid; +}STD_CTN; + +typedef struct standard_data_head{ + unsigned long long data_blk_num; + unsigned long long data_ctn_num; +}STD_HEAD; + +typedef struct standard_data{ + SID *s_id; + unsigned int type; + _Bool lock; + List *pd_blocklst; + List *pd_ctnlst; +}STD_DATA; #endif /* type_h */ From b9b36653a3d42c9e7454568f3e23df5f6faf1dab Mon Sep 17 00:00:00 2001 From: Saturneic Date: Tue, 7 Aug 2018 17:43:42 +0800 Subject: [PATCH 54/55] Fixed --- .../xcdebugger/Breakpoints_v2.xcbkptlist | 10 +++-- communicate/communicate.c | 43 +++++++++++++++++++ communicate/communicate.h | 4 ++ type/type.h | 8 ++++ 4 files changed, 62 insertions(+), 3 deletions(-) diff --git a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist index abe8217..ee2d7ff 100644 --- a/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist +++ b/ZE-Standard-Libraries.xcodeproj/xcuserdata/huyibing.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist @@ -633,7 +633,7 @@ + endingLineNumber = "100" + landmarkName = "main" + landmarkType = "9"> + endingLineNumber = "99" + landmarkName = "main" + landmarkType = "9"> p_sid = getS_id(MESSAGE, 1); + p_msg->time = time(NULL); + return p_msg; +} + +/*int sendMessageIPv4(MSG *p_msg, char *ip, unsigned int port){ + int client_sockfd; + struct sockaddr_in remote_addr; + char buf[BUFSIZ]; + memcpy(buf, "ZEMSG", 5); + memset(&remote_addr,0,sizeof(remote_addr)); + remote_addr.sin_family=AF_INET; + remote_addr.sin_addr.s_addr=inet_addr(ip); + remote_addr.sin_port=htons(port); + client_sockfd=socket(PF_INET,SOCK_STREAM,0); + connect(client_sockfd,(struct sockaddr *)&remote_addr,sizeof(struct sockaddr)); + send(client_sockfd,buf,strlen(buf),0); + unsigned long bkmsg_len = 0; + bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0); + buf[bkmsg_len] = '\0'; + if(!strcmp(buf, "TITLE_REV_READY")){ + memcpy(buf, p_msg->titile, strlen(p_msg->titile)); + bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0); + buf[bkmsg_len] = '\0'; + if(!strcmp(buf, "CONTENT_LEN_REV_READY")){ + memcpy(buf, (char *)p_msg->size, sizeof(unsigned int)); + send(client_sockfd,buf,sizeof(unsigned int),0); + bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0); + buf[bkmsg_len] = '\0'; + if(!strcmp(buf, "CONTENT_REV_READY")){ + memcpy(buf, p_msg->content, p_msg->size); + send(client_sockfd,buf,p_msg->size,0); + close(client_sockfd); + return 0; + } + } + } + close(client_sockfd); + return -1; +}*/ diff --git a/communicate/communicate.h b/communicate/communicate.h index f73ea90..cff8f99 100644 --- a/communicate/communicate.h +++ b/communicate/communicate.h @@ -6,6 +6,7 @@ typedef struct message{ SID *p_sid; + time_t time; char titile[16]; unsigned long size; char content[0]; @@ -37,6 +38,9 @@ List *_doStandardDBlockWrite(unsigned int type, void *value, List *er_list); STD_DATA *listToSTD(List *); List *standardDataToList(STD_DATA *); List *_doStandardDataToList(unsigned int type, void *value, List *er_list); + +MSG *createMessage(char *title, void *data, unsigned long data_size); +int sendMessageIPv4(MSG *p_msg, char *ip, unsigned int port); //STD_DATA *stackToSTD(Stack *); //STD_DATA *treeToSTD(Tree *); diff --git a/type/type.h b/type/type.h index 2cc99a5..a1dbaa1 100644 --- a/type/type.h +++ b/type/type.h @@ -8,6 +8,13 @@ #include #include +/* +#include +#include +#include +#include +*/ + #define VOID 0 #define INT 1 #define DOUBLE 2 @@ -23,6 +30,7 @@ #define UINT 12 #define STANDARD_DATA 13 #define DATA_FILE 14 +#define MESSAGE 15 #define DEEPC 1 #define DEEPB 2 From e4c123fff8a202aa3809715f9f78474985d3be7d Mon Sep 17 00:00:00 2001 From: Saturn&Eric Date: Tue, 7 Aug 2018 18:13:35 +0800 Subject: [PATCH 55/55] Update README.md Add. --- README.md | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index a119f9d..720dd88 100644 --- a/README.md +++ b/README.md @@ -1 +1,22 @@ -# ZE-Standard-Libraries \ No newline at end of file +# ZE-Standard-Libraries +### --我们需要更快更方便的基于C语言的软件工程 + +## 简介 +该函数库用于提供一些基础的数据结构的操作、运算、储存的函数，旨在加快基于C语言的软件工程的构建速度。运用该函数库提供的操作函数，可以省去工程中遇到的大量繁复的的高级数据结构的建构操作以及内存储存管理操作。 + +## 特性 +- 函数库提供高级数据结构实体以及配套的多样的操作函数，开发者得以主要注意力集中在主要的功能实现上。 +- 函数库提供相关函数，可以对高级数据结构快速进行基于文件的储存和基于网络的传输等工作。 +- 函数库中构建的高级数据结构有唯一的识别码，很方便可以进行查找，替换操作。 +- 函数库还提供工程的错误管理功能，使得开发者可以及时定位错误，或者让程序自动储存错误或者警告消息至文件。 + +## 分类 +该函数库主要提供以下基本数据结构操作、运算和储存函数： +- 链表 list +- 词典 dict +- 树 tree +- 图 graph +- 栈 stack +- 信息 message +## 代码风格 +本函数库秉承着可视性、稳定性与扩展性优先的原则，将在基本框架不变的情况下不断进行的优化。