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 79ccac5..7e920d0 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
@@ -386,7 +386,7 @@
endingColumnNumber = "9223372036854775807"
startingLineNumber = "240"
endingLineNumber = "240"
- landmarkName = "freeSidRaw"
+ landmarkName = "freeS_id"
landmarkType = "9">
@@ -498,7 +498,7 @@
endingColumnNumber = "9223372036854775807"
startingLineNumber = "239"
endingLineNumber = "239"
- landmarkName = "freeSidRaw"
+ landmarkName = "freeS_id"
landmarkType = "9">
@@ -518,38 +518,6 @@
landmarkType = "9">
-
-
-
-
-
-
-
-
-
-
-
-
@@ -598,22 +550,6 @@
landmarkType = "9">
-
-
-
-
+ endingLineNumber = "100">
@@ -866,8 +800,8 @@
endingColumnNumber = "9223372036854775807"
startingLineNumber = "43"
endingLineNumber = "43"
- landmarkName = "standardDataAddBlock"
- landmarkType = "9">
+ landmarkName = "unknown"
+ landmarkType = "0">
-
-
-
-
-
-
-
-
+ endingLineNumber = "99">
+ landmarkName = "unknown"
+ landmarkType = "0">
@@ -1042,7 +942,7 @@
endingColumnNumber = "9223372036854775807"
startingLineNumber = "267"
endingLineNumber = "267"
- landmarkName = "releaseDFile"
+ landmarkName = "releaseSTDBlocks"
landmarkType = "9">
@@ -1058,7 +958,7 @@
endingColumnNumber = "9223372036854775807"
startingLineNumber = "508"
endingLineNumber = "508"
- landmarkName = "releaseNodeForCustom"
+ landmarkName = "copyNode"
landmarkType = "9">
diff --git a/communicate/communicate.c b/communicate/communicate.c
index 81c1593..d451b32 100644
--- a/communicate/communicate.c
+++ b/communicate/communicate.c
@@ -2,7 +2,10 @@
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);
+ if(p_sid != NULL){
+ p_stdb->sid = s_idToASCIIString(p_sid);
+ }
+ else p_stdb->sid = NULL;
p_stdb->if_data = 0;
unsigned int blocks_num = (unsigned int)(data_size/sizeof(char));
p_stdb->blocks_num = blocks_num;
@@ -42,14 +45,14 @@ int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,unsigned int type, void *d
if (p_std->lock) return -1;
STD_BLOCKS *p_stdb = initStandardDBlocks(p_sid, type,data_size);
dataForStandardDBlock(p_stdb, data);
- insertInTail(p_std->pd_blocklst, nodeWithPointer(p_stdb));
+ insertInTail(p_std->pd_blocklst, nodeWithPointer(p_stdb,0));
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));
+ insertInTail(p_std->pd_ctnlst, nodeWithPointer(p_stdb,0));
return 0;
}
@@ -73,7 +76,7 @@ D_FILE *initDataFileForRead(char *route){
}
int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std){
- insertInTail(p_dfile->pf_stdlst, nodeWithPointer(p_std));
+ insertInTail(p_dfile->pf_stdlst, nodeWithPointer(p_std,0));
p_dfile->pf_head->data_num = p_dfile->pf_stdlst->length;
return 0;
}
@@ -83,7 +86,7 @@ int dataFileWriteIn(D_FILE *p_dfile){
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(0);
- insertInTail(er_list, nodeWithPointer(p_dfile->fp));
+ insertInTail(er_list, nodeWithPointer(p_dfile->fp,0));
/*fwrite("STDINFO", sizeof(char), 8, p_dfile->fp);
listThrough(p_dfile->pf_stdlst, _doStandardDataInfoWrite, er_list);*/
/*fwrite("STDLST", sizeof(char), 7, p_dfile->fp);*/
@@ -91,14 +94,23 @@ int dataFileWriteIn(D_FILE *p_dfile){
releaseList(er_list);
return 0;
}
+
List *_doStandardDataInfoWrite(unsigned int type, void *value, List *er_list){
List *p_rtnlst = initList(0);
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);
+ insertInTail(p_rtnlst, nodeWithInt(0,0));
+ int if_sid = 0;
+ if(p_std->s_id != NULL){
+ if_sid = 1;
+ char *string_sid = s_idToASCIIString(p_std->s_id);
+ fwrite(&if_sid, sizeof(int), 1, fp);
+ fwrite(string_sid, sizeof(char), SID_LEN, fp);
+ free(string_sid);
+ }
+ else{
+ fwrite(&if_sid, sizeof(int), 1, fp);
+ }
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);
@@ -108,48 +120,45 @@ List *_doStandardDataInfoWrite(unsigned int type, void *value, List *er_list){
List *_doStandardDataWrite(unsigned int type, void *value, List *er_list){
List *p_rtnlst = initList(0);
FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0));
- insertInTail(p_rtnlst, nodeWithInt(0));
+ insertInTail(p_rtnlst, nodeWithInt(0,0));
STD_DATA *p_std = value;
List *erc_list = initList(0);
- insertInTail(erc_list, nodeWithPointer(fp));
+ insertInTail(erc_list, nodeWithPointer(fp,0));
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(0);
- insertInTail(p_rtnlst, nodeWithInt(0));
+ insertInTail(p_rtnlst, nodeWithInt(0,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);
+ fwrite(p_stdc->f_sid, sizeof(char), SID_LEN, fp);
+ fwrite(p_stdc->s_sid, sizeof(char), SID_LEN, fp);
return p_rtnlst;
}
List *_doStandardDBlockWrite(unsigned int type, void *value, List *er_list){
List *p_rtnlst = initList(0);
- insertInTail(p_rtnlst, nodeWithInt(0));
+ insertInTail(p_rtnlst, nodeWithInt(0,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);
+ unsigned long blocks_num = p_stdb->blocks_num;
+ int if_sid = 0;
+ if(p_stdb->sid != NULL){
+ if_sid = 1;
+ fwrite(&if_sid, sizeof(int), 1, fp);
+ fwrite(p_stdb->sid, sizeof(char), SID_LEN, fp);
+ }
+ else{
+ fwrite(&if_sid, sizeof(int), 1, 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);
@@ -159,8 +168,9 @@ List *_doStandardDBlockWrite(unsigned int type, void *value, List *er_list){
STD_DATA *listToSTD(List *p_list){
STD_DATA *p_std = initStandardData(LIST);
Node *p_node = p_list->head;
- if (p_list->s_id != NULL) p_std->s_id = p_list->s_id;
+ if (p_list->s_id != NULL) p_std->s_id = copyS_id(p_list->s_id);
while (p_node != NULL) {
+ if(p_node->type == HOLE) continue;
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);
@@ -186,26 +196,28 @@ int dataFileReadOut(D_FILE *p_dfile){
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 long long ctn_num = 0, blk_num = 0;
+ int if_sid = 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(&if_sid, sizeof(int), 1, p_dfile->fp);
+ char *string_sid = NULL;
+ if(if_sid){
+ 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);
+ if(string_sid != NULL) 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);
+ char *fstring_sid = (char *)malloc(sizeof(char) * SID_LEN);
+ fread(fstring_sid, sizeof(char), SID_LEN, 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);
@@ -214,9 +226,12 @@ int dataFileReadOut(D_FILE *p_dfile){
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);
+ fread(&if_sid, sizeof(int), 1, p_dfile->fp);
+ char *string_sid = NULL;
+ if(if_sid){
+ 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);
@@ -226,7 +241,7 @@ int dataFileReadOut(D_FILE *p_dfile){
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);
+ if(string_sid != NULL) free(string_sid);
free(content);
}
return 0;
@@ -274,14 +289,14 @@ int releaseDFile(D_FILE *p_dfile){
List *standardDataToList(STD_DATA *p_std){
List *p_list = initList(0);
List *er_list = initList(0);
- insertInTail(er_list, nodeWithPointer(er_list));
+ insertInTail(er_list, nodeWithPointer(er_list,0));
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(0);
- insertInTail(rtn_list, nodeWithInt(0));
+ insertInTail(rtn_list, nodeWithInt(0,0));
List *p_list = getByPointerForNode(findByIndexForNode(er_list, 0));
STD_BLOCKS *p_stdb = value;
Node *p_node = initNode(0);
@@ -293,6 +308,18 @@ List *_doStandardDataToList(unsigned int type, void *value, List *er_list){
return rtn_list;
}
+unsigned long calStandardData(STD_DATA *p_std){
+ unsigned long size = sizeof(unsigned int) + 9;
+ if(p_std->s_id != NULL) size += 32;
+ listThrough(p_std->pd_ctnlst, CALLBACK_CALL(calStandardDataCTN), SEND_ARG("%d", size));
+ return 0;
+}
+
+CALLBACK_DEFINE(calStandardDataCTN){
+
+ return C_RETURN;
+}
+
MSG *createMessage(char *title, void *data, unsigned long data_size){
MSG *p_msg = malloc(sizeof(MSG) + data_size);
p_msg->p_sid = getS_id(MESSAGE, 1);
diff --git a/communicate/communicate.h b/communicate/communicate.h
index cff8f99..cf9e7d7 100644
--- a/communicate/communicate.h
+++ b/communicate/communicate.h
@@ -29,6 +29,8 @@ int releaseSTDBlocks(STD_BLOCKS *p_stdb);
int releaseStandardData(STD_DATA *p_std);
int releaseSTDConnection(STD_CTN *p_stdc);
int releaseDFile(D_FILE *p_file);
+unsigned long calStandardData(STD_DATA *p_std);
+CALLBACK_STATE(calStandardDataCTN);
List *_doStandardDataInfoWrite(unsigned int type, void *value, List *er_list);
List *_doStandardDataWrite(unsigned int type, void *value, List *er_list);
diff --git a/id/id.c b/id/id.c
index 1781ad2..f65ceb6 100644
--- a/id/id.c
+++ b/id/id.c
@@ -30,6 +30,10 @@ SID *initS_id(unsigned int deep_level){
p_sid->sr->value_deeper = NULL;
p_sid->sr->value_deepest = NULL;
p_sid->md5 = NULL;
+ return p_sid;
+}
+
+void getRawS_id(SID *p_sid, unsigned int type, unsigned int deep_level){
if (deep_level > 0) {
p_sid->sr->value = (unsigned int *)malloc(sizeof(unsigned int)*DEEPC_LEN);
if(p_sid->sr->value == NULL){
@@ -48,17 +52,17 @@ SID *initS_id(unsigned int deep_level){
printf("\ninitS_id(): Error in getting the memory of sid.value_deepest.\n");
}
}
- return p_sid;
-}
-
-SID *getS_id(unsigned int type, unsigned int deep_level){
- SID *p_sid = initS_id(deep_level);
p_sid->sr->type = type;
if(deep_level > 0){
for(register int i = 0; i < DEEPC_LEN; i++) p_sid->sr->value[i] = rand()%65535;
if(deep_level > 1) for(register int i = 0; i < DEEPB_LEN; i++) p_sid->sr->value_deeper[i] = rand()%65535;
if (deep_level > 2) for(register int i = 0; i < DEEPA_LEN; i++) p_sid->sr->value_deepest[i] = rand()%65535;
}
+}
+
+SID *getS_id(unsigned int type, unsigned int deep_level){
+ SID *p_sid = initS_id(deep_level);
+ getRawS_id(p_sid, type, deep_level);
s_idToMD5(p_sid);
return p_sid;
}
@@ -69,7 +73,7 @@ int fitS_id(SID * const fs_id, SID * const ss_id){
return strcmp(fs_id->decrypt_str, ss_id->decrypt_str);
}
-int simFitS_id(SID * const fs_id, SID * const ss_id){
+int simFitS_id(SID * fs_id, SID * ss_id){
return !fitS_id(fs_id, ss_id);
}
@@ -87,7 +91,9 @@ char *s_idToASCIIString(SID * const s_id){
free(s_id->md5);
s_id->md5 = NULL;
}
- return s_id->decrypt_str;
+ char *rtn_str = malloc(sizeof(char) * 33);
+ strcpy(rtn_str, s_id->decrypt_str);
+ return rtn_str;
}
char *s_idToASCIIRawString(SID * const s_id){
@@ -287,3 +293,10 @@ char hexToChar(unsigned char n){
}
return '0';
}
+
+SID *copyS_id(SID *f_sid){
+ SID *s_sid = initS_id(f_sid->deep);
+ for(int i = 0; i < 16; i++)
+ s_sid->decrypt_hex[i] = f_sid->decrypt_hex[i];
+ return 0;
+}
diff --git a/id/id.h b/id/id.h
index de5c239..59b9d10 100644
--- a/id/id.h
+++ b/id/id.h
@@ -14,13 +14,15 @@ unsigned long long getId(void);
SID *getS_id(unsigned int type, unsigned int deep_level);
int fitS_id(SID * const fs_id, SID * const ss_id);
-int simFitS_id(SID * const fs_id, SID * const ss_id);
+int simFitS_id(SID * fs_id, SID * ss_id);
char *s_idToASCIIString(SID * const s_id);
SID *asciiStringToS_id(char * const string);
void s_idToMD5(SID *s_id);
char hexToChar(unsigned char);
+SID *copyS_id(SID *f_sid);
+void getRawS_id(SID *s_id, unsigned int type, unsigned int deep_level);
SID *initS_id(unsigned int deep_level);
int freeSidRaw(SID *s_id);
diff --git a/list/list.c b/list/list.c
index 0eda5f6..46accec 100644
--- a/list/list.c
+++ b/list/list.c
@@ -145,6 +145,18 @@ int initMallocValueForNode(Node *p_node, unsigned int type, const void *p_value)
}
int insertInHead(List *p_list, Node *p_node) {
+ if(p_list->p_lq != NULL && p_list->p_lq->if_sort) return -1;
+ if(p_list->p_lq != NULL){
+ if(p_list->head->type == HOLE){
+ Node *t_node = p_list->head;
+ replaceNode(p_list, p_list->head, p_node);
+ p_list->p_lq->fn_node[0] = p_node;
+ releaseNode(t_node);
+ indexChange(p_list, 0, 1);
+ return 0;
+ }
+ indexChange(p_list, 0, 1);
+ }
if (isListEmpty(p_list)) {
p_list->head = p_node;
p_list->tail = p_node;
@@ -172,6 +184,7 @@ inline int s_insertInHead(List *p_list, s_Node *s_p_node){
}
int insertInTail(List *p_list, Node *p_node) {
+ if(p_list->p_lq != NULL && p_list->p_lq->if_sort) return -1;
if (isListEmpty(p_list)) {
p_list->head = p_node;
p_list->tail = p_node;
@@ -182,6 +195,15 @@ int insertInTail(List *p_list, Node *p_node) {
p_node->last = p_list->tail;
p_list->tail = p_node;
}
+
+ if(p_list->p_lq != NULL){
+ p_node->f_number = p_list->p_lq->rlst_len;
+ if(p_list->p_lq->rlst_len >= p_list->p_lq->rlst_len + FN_NODE_SPARE)
+ p_list->p_lq->fn_node = realloc(p_list->p_lq->fn_node, sizeof(Node *) * (p_list->p_lq->rlst_len + FN_NODE_SPARE));
+ p_list->p_lq->fn_node[p_list->p_lq->rlst_len] = p_node;
+ p_list->p_lq->rlst_len++;
+ }
+
p_list->length += 1;
return 0;
}
@@ -213,6 +235,7 @@ int releaseNode(Node *p_node) {
}
p_node->value = NULL;
}
+ p_node->f_number = 0;
p_node->last = NULL;
p_node->next = NULL;
p_node->type = VOID;
@@ -246,6 +269,7 @@ int releaseList(List *p_list) {
p_list->tail = NULL;
p_list->length = 0;
if (p_list->s_id != NULL) freeS_id(p_list->s_id);
+ if(p_list->p_lq != NULL) disableListQuick(p_list);
free(p_list);
return 0;
}
@@ -254,6 +278,7 @@ int releaseListForSingle(List *p_list) {
p_list->head = NULL;
p_list->tail = NULL;
if (p_list->s_id != NULL) freeS_id(p_list->s_id);
+ if(p_list->p_lq != NULL) disableListQuick(p_list);
p_list->length = 0;
free(p_list);
return 0;
@@ -263,7 +288,7 @@ unsigned long long len(List *p_list) {
return p_list->length;
}
-int removeById(List *p_list, const SID *s_id) {
+int removeById(List *p_list, SID *s_id) {
Node *tmp = p_list->head;
if (isListEmpty(p_list))
return -1;
@@ -294,39 +319,56 @@ int removeById(List *p_list, const SID *s_id) {
}
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;
- p_list->length -= 1;
- return 1;//found
+ if(p_node == p_list->head){
+ popFromHead(p_list);
+ return 0;
+ }
+ else if(p_node == p_list->tail){
+ popFromTail(p_list);
+ return 0;
+ }
+ if(p_list->p_lq == NULL){
+ p_node->last->next = p_node->next;
+ p_node->next->last = p_node->last;
+ }
+ else{
+ if(p_node != p_list->head){
+ if(p_node->f_number == 0){
+ Node *fn_node = findFnNode(p_list, p_node);
+ indexChange(p_list, fn_node->f_number, -1);
+ p_node->last->next = p_node->next;
+ p_node->next->last = p_node->last;
+ }
+ else{
+ digHole(p_list, p_node);
+ }
}
- else {
- tmp = tmp->next;
- }
- } while (tmp != NULL);
-
+ p_list->length -= 1;
+ }
return 0;//not find
}
int popFromHead(List *p_list) {
if (isListEmpty(p_list))
return -1;
- else {
+ if(p_list->p_lq != NULL){
+ if(p_list->p_lq->fn_node[0] == p_list->head){
+ digHole(p_list, p_list->head);
+ }
+ }
+ else{
//Node *tmp = p_list->head;
p_list->head->next->last = NULL;
p_list->head = p_list->head->next;
//releaseNode(tmp); not necessary
+ if (isListEmpty(p_list)) {
+ p_list->head = NULL;
+ p_list->tail = NULL;
+ }
p_list->length -= 1;
}
-
- if (isListEmpty(p_list)) {
- p_list->head = NULL;
- p_list->tail = NULL;
- }
return 0;
}
@@ -334,21 +376,25 @@ int popFromTail(List *p_list) {
if (isListEmpty(p_list))
return -1;
else {
+ if(p_list->p_lq != NULL){
+ if(p_list->p_lq->fn_node[p_list->p_lq->rlst_len] == p_list->tail)
+ p_list->p_lq->fn_node = realloc(p_list->p_lq->fn_node, sizeof(p_list->p_lq->rlst_len - 1));
+ }
//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;
}
+ p_list->length -= 1;
return 0;
}
-Node *findByIdForNode(List *p_list, const SID *s_id) {
+Node *findByIdForNode(List *p_list, SID * s_id) {
Node *ph_node = p_list->head;
Node *pt_node = p_list->tail;
int direction = 0;
@@ -460,11 +506,12 @@ Node *copyNode(Node *p_node) {
Node *t_node = NULL;
if (p_node->s_id == NULL) t_node = initNode(0);
else t_node = initNode(p_node->s_id->deep);
- t_node->s_id = p_node->s_id;
+ t_node->s_id = copyS_id(p_node->s_id);
t_node->last = p_node->last;
t_node->next = p_node->next;
t_node->type = p_node->type;
t_node->value = p_node->value;
+ t_node->f_number = p_node->f_number;
return t_node;
}
@@ -477,11 +524,16 @@ List *copyList(List *p_list) {
t_list->head = p_list->head;
t_list->tail = p_list->tail;
t_list->s_id = p_list->s_id;
+ t_list->s_head = p_list->s_head;
+ t_list->length = p_list->length;
+ t_list->s_tail = p_list->s_tail;
+ if(p_list->head != NULL && p_list->tail != NULL){
p_node = p_list->head;
- while (p_node != NULL) {
- t_node = copyNode(p_node);
- insertInTail(t_list, t_node);
- p_node = p_node->next;
+ while (p_node != NULL) {
+ t_node = copyNode(p_node);
+ insertInTail(t_list, t_node);
+ p_node = p_node->next;
+ }
}
return t_list;
}
@@ -538,6 +590,7 @@ int releaseListForCustom(List *p_list, int (*func)(void *)){
p_list->tail = NULL;
p_list->length = 0;
if (p_list->s_id != NULL) freeS_id(p_list->s_id);
+ if(p_list->p_lq != NULL) disableListQuick(p_list);
free(p_list);
return 0;
}
@@ -613,23 +666,101 @@ int replaceNode(List *p_list, Node *pt_node, Node *p_node){
else p_list->head = p_node;
if(p_list->tail != pt_node) pt_node->next->last = p_node;
else p_list->tail = p_node;
+
+ if(p_list->p_lq != NULL){
+ if(pt_node->f_number == 0 && p_list->p_lq->fn_node[0] != pt_node){
+ p_node->f_number = pt_node->f_number;
+ }
+ else{
+ p_list->p_lq->fn_node[pt_node->f_number] = p_node;
+ p_node->f_number = pt_node->f_number;
+ }
+ }
return 0;
}
-int sortListById(List *p_list){
+int exchangeNode(List *p_list, Node *f_node, Node *s_node){
+ Node *fl_node = f_node->last, *fn_node = f_node->next;
+ if(p_list->head != f_node) f_node->last->next = s_node;
+ else p_list->head = s_node;
+ if(p_list->tail != f_node) f_node->next->last = s_node;
+ else p_list->tail = s_node;
+ if(p_list->head != s_node) s_node->last->next = f_node;
+ else p_list->head = f_node;
+ if(p_list->tail != s_node) s_node->next->last = f_node;
+ else p_list->tail = f_node;
+ f_node->next = s_node->next;
+ f_node->last = s_node->last;
+ s_node->next = fn_node;
+ s_node->last = fl_node;
+ if(p_list->p_lq != NULL){
+ p_list->p_lq->fn_node[f_node->f_number] = s_node;
+ p_list->p_lq->fn_node[s_node->f_number] = f_node;
+ unsigned long long temp = f_node->f_number;
+ f_node->f_number = s_node->f_number;
+ s_node->f_number = temp;
+ }
+ return 0;
+}
+
+int sortList(List *p_list, unsigned long long begin, unsigned long long end, int(*func)(Node *f_node, Node *s_node)){
+ unsigned long long target_index = begin;
+ register Node *t_node = findByIndexForNode(p_list, target_index);
+ register Node *i_node = NULL, *j_node = NULL;
+
+ register unsigned long long i = end,j = begin;
+ for(; i >= begin; i--){
+ if(i <= j) break;
+ i_node = findByIndexForNode(p_list, i);
+ if(func(t_node, i_node) < 0){
+ exchangeNode(p_list, t_node, i_node);
+ for(; j <= end; j++){
+ if(j >= i) break;
+ j_node = findByIndexForNode(p_list, j);
+ if(func(t_node, j_node) > 0){
+ exchangeNode(p_list, t_node, j_node);
+ break;
+ }
+ }
+ }
+ }
+ if(end - begin > 3){
+ if(t_node->f_number - begin > 2)
+ sortList(p_list, begin, t_node->f_number, func);
+ if(end - t_node->f_number > 2)
+ sortList(p_list, t_node->f_number, end, func);
+ }
+ return 0;
+}
+
+int sortListByCustom(List *p_list, int(*func)(Node *f_node, Node *s_node)){
+ if(p_list->p_lq != NULL && !p_list->p_lq->if_sort) p_list->p_lq->if_sort = 1;
+ sortList(p_list, 0, p_list->length-1, func);
+ return 0;
}
int enableListQuick(List *p_list){
- if(p_list->length > 1500){
+ if(p_list->length > ENABLE_LIST_QUICK){
p_list->p_lq = malloc(sizeof(struct list_quick));
+ register struct list_quick *p_lq = p_list->p_lq;
+ p_lq->rlst_len = p_list->length;
+ p_lq->fn_node = malloc(sizeof(Node *) * (p_list->length + FN_NODE_SPARE));
+ p_lq->if_sort = 0;
+ refreshFnNode(p_list);
+ //sortListById(p_list, 0, p_list->length);
+ return 0;
+ }
+ return -1;
+}
+
+int refreshFnNode(List *p_list){
+ if(p_list->p_lq != NULL){
+ initIdxcList(p_list);
+ if(p_list->p_lq->fn_node != NULL) free(p_list->p_lq->fn_node);
+ p_list->p_lq->fn_node = malloc(sizeof(Node *) * p_list->length);
register Node *p_node = p_list->head;
unsigned long long i = 0;
- p_list->p_lq->rlst_len = p_list->length;
- p_list->p_lq->fn_node = malloc(sizeof(Node *) * p_list->length);
- p_list->p_lq->p_lindex = 0;
- p_list->p_lq->head_index = 0;
- p_list->p_lq->tail_index = p_list->length - 1;
while (p_node != NULL) {
p_node->f_number = i++;
p_list->p_lq->fn_node[i] = p_node;
@@ -639,3 +770,169 @@ int enableListQuick(List *p_list){
}
return -1;
}
+
+int indexChange(List *p_list, unsigned long long c_index, int move){
+ if(p_list->p_lq != NULL){
+ struct index_change *t_idxc;
+ struct list_quick *p_lq = p_list->p_lq;
+ if(p_lq->idxc_count >= INDEX_CHANGE_MAX){
+ refreshFnNode(p_list);
+ for(int i = 0; i < INDEX_CHANGE_MAX; i++){
+ free(p_lq->idxc_lst[i]);
+ p_lq->idxc_lst[i] = NULL;
+ }
+ return 0;
+ }
+ for(int i = 0; p_lq->idxc_lst[i] != NULL; i++){
+ if(p_lq->idxc_lst[i]->c_index == c_index){
+ p_lq->idxc_lst[i]->f_count += move;
+ return 0;
+ }
+ }
+ if(p_lq->idxc_count == 0) {
+ p_lq->idxc_lst[0] = malloc(sizeof(struct index_change));
+ t_idxc = p_lq->idxc_lst[0];
+ }
+ else {
+ p_lq->idxc_lst[p_lq->idxc_count] = malloc(sizeof(struct index_change));
+ t_idxc = p_lq->idxc_lst[p_lq->idxc_count];
+ }
+ t_idxc->c_index = c_index;
+ t_idxc->f_count = move;
+ p_lq->idxc_count++;
+ }
+ return 0;
+}
+
+int indexTransfromer(List *p_list, unsigned long long m_index){
+ int total_move = 0;
+ struct list_quick *p_lq = p_list->p_lq;
+ struct index_change **p_idxclst = p_lq->idxc_lst;
+ if(p_lq->idxc_lst[0] != NULL){
+ for (int i = 0; p_idxclst[i] != NULL && i < INDEX_CHANGE_MAX; i++) {
+ if(p_idxclst[i]->c_index <= m_index) total_move += p_idxclst[i]->f_count;
+ if(total_move >= 65535){
+ refreshFnNode(p_list);
+ return 0;
+ }
+ }
+ }
+ return total_move;
+}
+
+Node *getNodeByFnNode(List *p_list, unsigned long long index){
+ if(p_list->p_lq != NULL){
+ struct list_quick *p_lq = p_list->p_lq;
+ Node *p_node = p_lq->fn_node[index];
+ if(p_lq->idxc_count > 0){
+ int total_move = indexTransfromer(p_list, index);
+ if(total_move >=0){
+ for(int i = 0; i < ABS(total_move); i++) p_node = p_node->last;
+ }
+ else{
+ for(int i = 0; i < ABS(total_move); i++) p_node = p_node->next;
+ }
+ return p_node;
+ }
+ else{
+ return p_lq->fn_node[index];
+ }
+
+ }
+ return NULL;
+}
+
+int insertAfterNode(List *p_list, Node *t_node, Node *p_node){
+ if(t_node == p_list->tail){
+ insertInTail(p_list, p_node);
+ return 0;
+ }
+ if(p_list->p_lq != NULL){
+ if(t_node->next->type == HOLE){
+ Node *temp_node = t_node->next;
+ replaceNode(p_list, t_node->next, p_node);
+ p_node->f_number = temp_node->f_number;
+ releaseNode(temp_node);
+ p_list->p_lq->fn_node[p_node->f_number] = p_node;
+ indexChange(p_list, p_node->f_number, 1);
+ }
+ }
+ p_node->next = t_node->next;
+ p_node->last = t_node;
+ if(p_list->tail != t_node)
+ t_node->next->last = p_node;
+ else
+ p_list->tail = p_node;
+
+ t_node->next = p_node;
+
+ if(p_list->p_lq != NULL){
+ Node *fn_node = findFnNode(p_list, p_node);
+ while(fn_node->f_number != 0) fn_node = fn_node->next;
+ indexChange(p_list, fn_node->f_number, 1);
+ }
+ p_list->length += 1;
+ return 0;
+}
+
+int insertBeforeNode(List *p_list, Node*t_node, Node *p_node){
+ if(t_node == p_list->head){
+ insertInHead(p_list, p_node);
+ return 0;
+ }
+ if(p_list->p_lq != NULL){
+ if(t_node->last->type == HOLE){
+ Node *temp_node = t_node->last;
+ replaceNode(p_list, t_node->last, p_node);
+ p_node->f_number = temp_node->f_number;
+ releaseNode(temp_node);
+ p_list->p_lq->fn_node[p_node->f_number] = p_node;
+ indexChange(p_list, p_node->f_number, 1);
+ return 0;
+ }
+ }
+ p_node->last = t_node->last;
+ p_node->next = t_node;
+ if(p_list->head != t_node)
+ t_node->last->next = p_node;
+ else
+ p_list->head = p_node;
+ t_node->last = p_node;
+ if(p_list->p_lq != NULL){
+ Node *fn_node = findFnNode(p_list, p_node);
+ indexChange(p_list, fn_node->f_number, 1);
+ }
+ p_list->length += 1;
+ return 0;
+}
+
+Node *findFnNode(List *p_list, Node *p_node){
+ Node *fn_node = p_node;
+ while(fn_node->f_number != 0) fn_node = fn_node->next;
+ return fn_node;
+}
+
+void initIdxcList(List *p_list){
+ struct list_quick *p_lq = p_list->p_lq;
+ for(int i = 0; i < INDEX_CHANGE_MAX; i++){
+ if(p_lq->idxc_lst[i] != NULL) free(p_lq->idxc_lst[i]);
+ p_lq->idxc_lst[i] = NULL;
+ }
+ p_lq->idxc_count = 0;
+}
+
+void digHole(List *p_list, Node *p_node){
+ Node *c_node = copyNode(p_node);
+ freeS_id(c_node->s_id);
+ replaceNode(p_list, p_node, c_node);
+ c_node->value = NULL;
+ c_node->type = HOLE;
+ indexChange(p_list, p_node->f_number, -1);
+}
+
+int disableListQuick(List *p_list){
+ free(p_list->p_lq->fn_node);
+ initIdxcList(p_list);
+ free(p_list->p_lq);
+ return 0;
+}
diff --git a/list/list.h b/list/list.h
index 3dddefa..678e617 100644
--- a/list/list.h
+++ b/list/list.h
@@ -3,6 +3,26 @@
#include "../type/type.h"
#include "../id/id.h"
+#define lni(x) nodeWithInt(x,0)
+#define lnd(x) nodeWithDouble(x,0)
+#define lns(x) nodeWithString(x,0)
+#define lnp(x) nodeWithPointer(x,0)
+
+#define lsni(x) nodeWithInt(x,1)
+#define lsnd(x) nodeWithDouble(x,1)
+#define lsns(x) nodeWithString(x,1)
+#define lsnp(x) nodeWithPointer(x,1)
+
+#define lisrti(list, x) insertInTail(list, lni(x));
+#define lisrtd(list, x) insertInTail(list, lnd(x));
+#define lisrtp(list, x) insertInTail(list, lnp(x));
+#define lisrts(list, x) insertInTail(list, lns(x));
+
+#define lidxp(list, x) getByPointerForNode(findByIndexForNode(list, x))
+#define lidxi(list, x) getByIntForNode(findByIndexForNode(list, x))
+#define lidxd(list, x) getByDoubleForNode(findByIndexForNode(list, x))
+#define lidxs(list, x) getByStringForNode(findByIndexForNode(list, x))
+
int safeModeForNode(int ifon);
int releaseSingleListForsafeModeForNode(List *p_list);
int releaseSingleNodeForsafeModeForNode(List *p_list);
@@ -16,21 +36,24 @@ int initMallocValueForNode(Node *,unsigned int,const void *);
int insertInHead(List *p_list, Node *p_node);
int insertInTail(List *p_list, Node *p_node);
+int insertAfterNode(List *p_list, Node *t_node, Node *p_node);
+int insertBeforeNode(List *p_list, Node*t_node, Node *p_node);
int s_insertInHead(List *p_list, s_Node *s_p_node);
int s_insertInTail(List *p_list, s_Node *s_p_node);
int replaceNode(List *p_list, Node *pt_node, Node *p_node);
+int exchangeNode(List *p_list, Node *f_node, Node *s_node);
Node *copyNode(Node *);
-int removeById(List *p_list, const SID *s_id);
+int removeById(List *p_list, 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 SID *s_id);
+Node *findByIdForNode(List *p_list, 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);
@@ -64,7 +87,32 @@ int showError(Error *);
int showWarning(Notice *);
int enableListQuick(List *p_list);
-int sortListById(List *p_list);
+int refreshFnNode(List *p_list);
+int sortList(List *p_list, unsigned long long begin, unsigned long long end, int(*func)(Node *f_node, Node *s_node));
+int sortListByCustom(List *p_list, int(*func)(Node *f_node, Node *s_node));
+int indexTransfromer(List *p_list, unsigned long long m_index);
+int indexChange(List *p_list, unsigned long long c_index, int move);
+Node *getNodeByFnNode(List *p_list, unsigned long long index);
+Node *findFnNode(List *p_list, Node *p_node);
+void initIdxcList(List *p_list);
+void digHole(List *p_list, Node *p_node);
+int disableListQuick(List *p_list);
+
+Node *findByIndexForNode(List *, unsigned long long);
+Node *findByIntForNode(List *, int);
+Node *findByDoubleForNode(List *, double);
+Node *findByStringForNode(List *, char *);
+Node *findByPointerForNode(List *, void *);
+
+Node *getListTail(List *);
+Node *updateNodeByIndex(List *, void *, unsigned long long);
+
+int getByIntForNode(Node *);
+unsigned int getByUIntForNode(Node *);
+double getByDoubleForNode(Node *);
+char *getByStringForNode(Node *);
+void *getByPointerForNode(Node *);
+unsigned long long getIndexForNode(List *p_list,Node *p_node);
static int if_safeModeForNode;
static List *node_list;
diff --git a/list/list_expand.c b/list/list_expand.c
index 3c42536..169a1de 100644
--- a/list/list_expand.c
+++ b/list/list_expand.c
@@ -4,7 +4,7 @@ Node *nodeWithInt(int m_int, _Bool if_sid) {
Node *p_node;
int *p_int = (int *)malloc(sizeof(int));
if(p_int == NULL){
- showError(pushError(INT, STANDARD, initInfo("nodeWithInt()", "Error in getting the memory of int.")));
+ showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int.")));
return NULL;
}
*p_int = m_int;
@@ -17,7 +17,7 @@ Node *nodeWithUInt(unsigned int m_uint, _Bool if_sid){
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.")));
+ showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int.")));
return NULL;
}
*pu_int = m_uint;
@@ -25,12 +25,25 @@ Node *nodeWithUInt(unsigned int m_uint, _Bool if_sid){
initMallocValueForNode(p_node, INT, (void *)pu_int);
return p_node;
}
+
+Node *nodeWithULLInt(unsigned long long m_ullint, _Bool if_sid) {
+ Node *p_node;
+ unsigned long long *p_ullint = (unsigned long long *)malloc(sizeof(unsigned long long));
+ if(p_ullint == NULL){
+ showError(pushError(INT, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of int.")));
+ return NULL;
+ }
+ *p_ullint = m_ullint;
+ p_node = initNode(if_sid);
+ initMallocValueForNode(p_node, ULLINT, (void *)p_ullint);
+ return p_node;
+}
Node *nodeWithDouble(double m_double, _Bool if_sid) {
Node *p_node;
double *p_double = (double *)malloc(sizeof(double));
if(p_double == NULL){
- showError(pushError(DOUBLE, STANDARD, initInfo("nodeWithDouble()", "Error in getting the memory of double.")));
+ showError(pushError(DOUBLE, STANDARD, initInfo(__FUNCTION__, "Error in getting the memory of double.")));
return NULL;
}
*p_double = m_double;
@@ -68,16 +81,14 @@ Node *nodeWithComplex(void) {
Node *findByIndexForNode(List *p_list, unsigned long long m_index) {
if(p_list->p_lq != NULL){
register struct list_quick *p_lq = p_list->p_lq;
- if(m_index > p_lq->head_index && p_lq->last_index) return p_lq->fn_node[m_index];
- }
- else{
- Node *p_node = p_list->head;
- unsigned long long i;
- for (i = 0; i < m_index; i++) {
- p_node = p_node->next;
- }
- return p_node;
+ if(p_lq->fn_node != NULL) return getNodeByFnNode(p_list, m_index);
}
+ Node *p_node = p_list->head;
+ unsigned long long i;
+ for (i = 0; i < m_index; i++) {
+ p_node = p_node->next;
+ }
+ return p_node;
}
s_Node *s_findByIndexForNode(List *p_list, unsigned long long m_index) {
@@ -91,7 +102,9 @@ s_Node *s_findByIndexForNode(List *p_list, unsigned long long m_index) {
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;
+ List *m_rtnlst = NULL;
+ unsigned long long count = 0;
+ insertInTail(expand_resources, nodeWithULLInt(count, 0));
while (p_node != NULL) {
if (p_node->value != NULL) {
List *m_rtnlst = (*p_func)(p_node->type, p_node->value, expand_resources);
@@ -510,6 +523,7 @@ inline s_Node *s_nodeWithUInt(unsigned int t_uint){
s_p_node->value = pt_uint;
return s_p_node;
}
+
inline s_Node *s_nodeWithDouble(double t_double){
s_Node *s_p_node = s_initNode();
unsigned int *pt_double = malloc(sizeof(double));
@@ -517,6 +531,7 @@ inline s_Node *s_nodeWithDouble(double t_double){
s_p_node->value = pt_double;
return s_p_node;
}
+
inline s_Node *s_nodeWithString(const char *t_string){
s_Node *s_p_node = s_initNode();
char *pt_string = malloc(strlen(t_string) + 1);
@@ -524,8 +539,56 @@ inline s_Node *s_nodeWithString(const char *t_string){
s_p_node->value = pt_string;
return s_p_node;
}
+
inline s_Node *s_nodeWithPointer(const void *t_pointer){
s_Node *s_p_node = s_initNode();
s_p_node->value = (void *) t_pointer;
return s_p_node;
}
+
+
+
+List *newReturn(int if_status ,int status, char *argc, ...){
+ List *p_list = initList(0);
+ if(if_status){
+ lisrti(p_list, status);
+ }
+ if(status != 0){
+ va_list args;
+ va_start(args, argc);
+ char p_ch = argc[0];
+ char t_ch[256];
+ int count = 0, t_count = 0;
+ while(p_ch != '\0'){
+ if(p_ch == '%'){
+ switch (argc[count + 1]) {
+ case 'd':
+ lisrti(p_list, va_arg(args, int));
+ break;
+ case 's':
+ t_count = 0;
+ while ((t_ch[t_count] = va_arg(args, int)) != '\0') t_count++;
+ t_ch[t_count] = '\0';
+ lisrts(p_list, t_ch);
+ break;
+ case 'f':
+ lisrtd(p_list, va_arg(args, double));
+ break;
+ case 'p':
+ lisrtp(p_list, va_arg(args, void *));
+ break;
+ default:
+ break;
+ }
+ count++;
+ }
+ p_ch = argc[++count];
+ }
+ va_end(args);
+ }
+ return p_list;
+}
+
+List *newCReturn(void){
+ return newReturn(1, 0, NULL);
+}
diff --git a/list/list_expand.h b/list/list_expand.h
index ea35fcc..b484f58 100644
--- a/list/list_expand.h
+++ b/list/list_expand.h
@@ -1,13 +1,27 @@
#ifndef LIST_EXPAND_H
#define LIST_EXPAND_H
-#include "list.h"
+#include "list.h"
+
+#define RETURN(argc, args...) newReturn(1, -1, argc , args)
+#define C_RETURN newCReturn()
+#define SEND_ARG(argc, args...) newReturn(0, -1, argc , args)
+#define CALLBACK_STATE(name) List *do_##name(unsigned int, void *, List *)
+#define CALLBACK_DEFINE(name) List *do_##name(unsigned int type, void *value, List *args)
+#define VALUE(c_type) (c_type)value
+#define ARGS(x, type)\
+if(#type == "int") lidxi(args, x);\
+else if if(#type == "double") lidxd(args, x);\
+else if(#type == "string") lidxs(args, x);\
+else lidxi(args, x);
+#define CALLBACK_CALL(name) do_##name
-Node *nodeWithInt(int);
-Node *nodeWithUInt(unsigned int);
-Node *nodeWithDouble(double);
-Node *nodeWithString(const char *);
-Node *nodeWithPointer(const void *);
+Node *nodeWithInt(int, _Bool if_sid);
+Node *nodeWithUInt(unsigned int, _Bool if_sid);
+Node *nodeWithULLInt(unsigned long long, _Bool if_sid);
+Node *nodeWithDouble(double, _Bool if_sid);
+Node *nodeWithString(const char *, _Bool if_sid);
+Node *nodeWithPointer(const void *, _Bool if_sid);
s_Node *s_nodeWithInt(int);
s_Node *s_nodeWithUInt(unsigned int);
@@ -27,12 +41,6 @@ int updateValueWithDoubleForNode(Node *,double);
int updateValueWithStringForNode(Node *,char *);
int updateValueWithPointerForNode(Node *,void *);
-Node *findByIndexForNode(List *, unsigned long long);
-Node *findByIntForNode(List *, int);
-Node *findByDoubleForNode(List *, double);
-Node *findByStringForNode(List *, char *);
-Node *findByPointerForNode(List *, void *);
-
List *mply_findByIntForNode(List*, int);
List *mply_findByDoubleForNode(List*, double);
List *mply_findByStringForNode(List*, char *);
@@ -43,13 +51,9 @@ void printNodeInfo(Node *p_node,int priority);
void printList(List *);
void printNode(Node *p_node);
-int getByIntForNode(Node *);
-unsigned int getByUIntForNode(Node *);
-double getByDoubleForNode(Node *);
-char *getByStringForNode(Node *);
-void *getByPointerForNode(Node *);
-unsigned long long getIndexForNode(List *p_list,Node *p_node);
List *listThrough(List *p_list, List *(*p_func)(unsigned int type, void *value, List *), List *expand_resources);
+List *newReturn(int if_status ,int status, char *argc, ...);
+List *newCReturn(void);
unsigned long long calListMemory(List *);
#endif
diff --git a/test.c b/test.c
index ee234f9..a77ea4e 100644
--- a/test.c
+++ b/test.c
@@ -82,19 +82,9 @@ int stack(void) {
int main(int argc, char **argv) {
- init_rand();
- 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);
+ SID *p_sid = getS_id(VOID, 2);
+ s_idToASCIIString(p_sid);
+ printf("%s",p_sid->decrypt_str);
+ freeS_id(p_sid);
return 0;
}
diff --git a/type/type.h b/type/type.h
index f07ca18..d551fc1 100644
--- a/type/type.h
+++ b/type/type.h
@@ -7,6 +7,7 @@
#include
#include
#include
+#include
/*
#include
@@ -31,6 +32,8 @@
#define STANDARD_DATA 13
#define DATA_FILE 14
#define MESSAGE 15
+#define HOLE 16
+#define ULLINT 17
#define DEEPC 1
#define DEEPB 2
@@ -43,14 +46,20 @@
#define DEEP_LEN 25
#define DEEPER_LEN 65
#define DEEPEST_LEN 225
+#define SID_LEN 32
#define FILE_TSET_LEN 18
#define HEAD_TEST_LEN 9
-
+#define ENABLE_LIST_QUICK 1500
+#define FN_NODE_SPARE 12
+#define INDEX_CHANGE_MAX 500
+#define INDEX_DISTANCE_MAX 120
#define HIGH 0x3
#define STANDARD 0x2
#define LOW 0x1
+#define ABS(x) (x>0)?(x):(-x)
+
typedef struct md5_ctx{
unsigned int count[2];
unsigned int state[4];
@@ -105,12 +114,16 @@ typedef struct List{
SID *s_id;
} List;
+struct index_change{
+ unsigned long long c_index;
+ int f_count;
+};
+
struct list_quick{
Node **fn_node;
- unsigned long long last_index;
- Node *p_lindex;
- unsigned long long head_index;
- unsigned long long tail_index;
+ _Bool if_sort;
+ unsigned int idxc_count;
+ struct index_change *idxc_lst[INDEX_CHANGE_MAX];
unsigned long long rlst_len;
FILE *fp;
List *stdid_lst;