check finished

2 files changed, 161 insertions, 266 deletions

diff --git a/include/list.h b/include/list.h
index 535dfa9..55377b4 100644
--- a/include/list.h
+++ b/include/list.h
@@ -73,7 +73,7 @@
 /*      Remove the part of iter1 ~ iter2 (include iter1   */
 /*      but not iter2)                                    */
 /*                                                        */
-/*   copy(addr of the list, addr of the iter1, iter2)     */
+/*   cutout(addr of the list, addr of the iter1, iter2)   */
 /*      Create a new list which contain the part of the   */
 /*      iter1 ~ iter2 (include iter1 but not iter2)       */
 /*                                                        */
@@ -128,38 +128,33 @@ int    ctl_list_getSizeX     (ppcvoid l);
 int    ctl_list_getEntrySizeX(ppcvoid l);
 pcvoid ctl_list_getFrontX    (ppcvoid l);
 pcvoid ctl_list_getBackX     (ppcvoid l);
-pvoid  ctl_list_getFirstX    (ppcvoid l);
-pvoid  ctl_list_getLastX     (ppcvoid l);
+pvoid  ctl_list_getBeginX    (ppcvoid l);
+pcvoid ctl_list_getEndX     (ppcvoid l);
 
 int   ctl_list_setSizeX (ppvoid l, uint count);
 pvoid ctl_list_setFrontX(ppvoid l, pcvoid data);
 pvoid ctl_list_setBackX (ppvoid l, pcvoid data);
 
 int ctl_list_addFrontX(ppvoid l, pcvoid data);
-
 int ctl_list_delFrontX(ppvoid l);
 int ctl_list_addBackX (ppvoid l, pcvoid data);
 int ctl_list_delBackX (ppvoid l);
 
-int   ctl_list_rmX  (ppvoid l, ppvoid i1, ppvoid i2);
-pvoid ctl_list_copyX(ppvoid l, ppvoid i1, ppvoid i2, ppvoid out);
-pvoid ctl_list_moveX(ppvoid l, ppvoid i1, ppvoid i2, ppvoid out);
-int   ctl_list_swapX(ppvoid l1, ppvoid i1, ppvoid i2,
-                     ppvoid l2, ppvoid j1, ppvoid j2);
-
-pcvoid ctl_list_iterGetEntryX(ppcvoid i);
-pvoid  ctl_list_iterGetNextX (ppcvoid i);
-pvoid  ctl_list_iterGetPrevX (ppcvoid i);
+int   ctl_list_rmX  (ppvoid li, pvoid i1, pvoid i2);
+pvoid ctl_list_copyX(ppvoid li, pvoid i1, pvoid i2, ppvoid out);
+pvoid ctl_list_moveX(ppvoid li, pvoid i1, pvoid i2, ppvoid out);
+int   ctl_list_swapX(ppvoid li, pvoid i1, pvoid i2,
+                     ppvoid lj, pvoid j1, pvoid j2);
 
-pvoid  ctl_list_iterSetEntryX(ppvoid  i, pcvoid *data);
+pcvoid ctl_list_iterGetEntryX(pcvoid i);
+pvoid  ctl_list_iterGetNextX (pcvoid i);
+pvoid  ctl_list_iterGetPrevX (pcvoid i);
 
-pvoid  ctl_list_iterGoNextX(ppvoid i);
-pvoid  ctl_list_iterGoPrevX(ppvoid i);
-
-pvoid  ctl_list_iterDelX    (ppvoid i);
-pvoid  ctl_list_iterDelPrevX(ppvoid i);
-pvoid  ctl_list_iterDelNextX(ppvoid i);
+pvoid  ctl_list_iterSetEntryX(pvoid  i, pcvoid data);
 
+pvoid  ctl_list_iterDelX    (pvoid i);
+pvoid  ctl_list_iterDelPrevX(pvoid i);
+pvoid  ctl_list_iterDelNextX(pvoid i);
 
 #define ctl_list_init(X,Y,Z) ctl_list_initX(ppVoid(X),Y,Z)
 #define ctl_list_free(X)     ctl_list_freeX(ppVoid(X))
@@ -168,40 +163,32 @@ pvoid  ctl_list_iterDelNextX(ppvoid i);
 #define ctl_list_getEntrySize(X) ctl_list_getEntrySizeX(ppcVoid(X))
 #define ctl_list_getFront(X)     ctl_list_getFrontX    (ppcVoid(X))
 #define ctl_list_getBack(X)      ctl_list_getBackX     (ppcVoid(X))
-#define ctl_list_getFirst(X)     ctl_list_getFirstX    (ppcVoid(X))
-#define ctl_list_getLast(X)      ctl_list_getLastX     (ppcVoid(X))
+#define ctl_list_getBegin(X)     ctl_list_getBeginX    (ppcVoid(X))
+#define ctl_list_getEnd(X)       ctl_list_getEndX      (ppcVoid(X))
 
-#define ctl_list_setSize(X,Y)  ctl_list_setSizeX (ppVoid(l),Y)
+#define ctl_list_setSize(X,Y)  ctl_list_setSizeX (ppVoid(X),Y)
 #define ctl_list_setFront(X,Y) ctl_list_setFrontX(ppVoid(X),pcVoid(Y))
 #define ctl_list_setBack(X,Y)  ctl_list_setBackX (ppVoid(X),pcVoid(Y))
 
-#define ctl_list_addFront(X,Y) ctl_list_addFrontX(ppVoid(l),pcVoid(Y))
-#define ctl_list_delFront(X)   ctl_list_delFrontX(ppVoid(l))
-#define ctl_list_addBack(X,Y)  ctl_list_addBackX (ppVoid(l),pcVoid(Y))
-#define ctl_list_delBack(X)    ctl_list_delBackX (ppVoid(l))
-
+#define ctl_list_addFront(X,Y) ctl_list_addFrontX(ppVoid(X),pcVoid(Y))
+#define ctl_list_delFront(X)   ctl_list_delFrontX(ppVoid(X))
+#define ctl_list_addBack(X,Y)  ctl_list_addBackX (ppVoid(X),pcVoid(Y))
+#define ctl_list_delBack(X)    ctl_list_delBackX (ppVoid(X))
 
-int   ctl_list_rmX  (ppvoid l, ppvoid i1, ppvoid i2);
-pvoid ctl_list_copyX(ppvoid l, ppvoid i1, ppvoid i2, ppvoid out);
-pvoid ctl_list_moveX(ppvoid l, ppvoid i1, ppvoid i2, ppvoid out);
-int   ctl_list_swapX(ppvoid l1, ppvoid i1, ppvoid i2,
-                     ppvoid l2, ppvoid j1, ppvoid j2);
-#define ctl_list_rm(X,Y,Z)         ctl_list_rmX  (ppVoid(X),ppVoid(Y),ppVoid(Z))
-#define ctl_list_copy(X,Y,Z,A)     ctl_list_copyX(ppVoid(X),ppVoid(Y),ppVoid(Z),ppVoid(A))
-#define ctl_list_move(X,Y,Z,A)     ctl_list_moveX(ppVoid(X),ppVoid(Y),ppVoid(Z),ppVoid(A))
-#define ctl_list_swap(X,Y,Z,A,B,C) ctl_list_swapX(ppVoid(X),ppVoid(Y),ppVoid(Z),ppVoid(A),ppVoid(B),ppVoid(C))
 
-#define ctl_list_iterGetEntry(X)  ctl_list_iterGetEntryX(ppcVoid(X))
-#define ctl_list_iterGetNext(X)   ctl_list_iterGetNextX (ppcVoid(X))
-#define ctl_list_iterGetPrev(X)   ctl_list_iterGetPrevX (ppcVoid(X))
+#define ctl_list_rm(X,Y,Z)         ctl_list_rmX  (ppVoid(X),pVoid(Y),pVoid(Z))
+#define ctl_list_copy(X,Y,Z,A)     ctl_list_copyX(ppVoid(X),pVoid(Y),pVoid(Z),ppVoid(A))
+#define ctl_list_move(X,Y,Z,A)     ctl_list_moveX(ppVoid(X),pVoid(Y),pVoid(Z),ppVoid(A))
+#define ctl_list_swap(X,Y,Z,A,B,C) ctl_list_swapX(ppVoid(X),pVoid(Y),pVoid(Z),ppVoid(A),pVoid(B),pVoid(C))
 
-#define ctl_list_iterSetEntry(X,Y) ctl_list_iterSetEntryX(ppVoid(X),pcVoid(Y))
+#define ctl_list_iterGetEntry(X)  ctl_list_iterGetEntryX(pcVoid(X))
+#define ctl_list_iterGetNext(X)   ctl_list_iterGetNextX (pcVoid(X))
+#define ctl_list_iterGetPrev(X)   ctl_list_iterGetPrevX (pcVoid(X))
 
-#define ctl_list_iterGoNext(X) ctl_list_iterGoNextX(ppcVoid(X))
-#define ctl_list_iterGoPrev(X) ctl_list_iterGoPrevX(ppcVoid(X))
+#define ctl_list_iterSetEntry(X,Y) ctl_list_iterSetEntryX(pVoid(X),pcVoid(Y))
 
-#define ctl_list_iterDel(X)     ctl_list_iterDelX    (ppVoid(X))
-#define ctl_list_iterDelPrev(X) ctl_list_iterDelPrevX(ppVoid(X))
-#define ctl_list_iterDelNext(X) ctl_list_iterDelNextX(ppVoid(X))
+#define ctl_list_iterDel(X)     ctl_list_iterDelX    (pVoid(X))
+#define ctl_list_iterDelPrev(X) ctl_list_iterDelPrevX(pVoid(X))
+#define ctl_list_iterDelNext(X) ctl_list_iterDelNextX(pVoid(X))
 
 #endif  /* __list_h__ */
diff --git a/src/list.c b/src/list.c
index 2be8f4a..98d594b 100644
--- a/src/list.c
+++ b/src/list.c
@@ -1,5 +1,7 @@
 #include "list.h"
 
+#include <string.h>
+
 struct ListNodeStruct;
 struct ListHeaderStruct;
 
@@ -19,232 +21,169 @@ struct ListHeaderStruct{
 typedef struct ListNodeStruct   ListNode;
 typedef struct ListHeaderStruct ListHeader;
 
+
 #define getHeader(X)   (*(ListHeader**)(pChar(X)-offsetof(ListNode,buf)))
-#define getNode(X)     ((X)==NULL?NULL:*(ListNode*)(pChar(X)-offsetof(ListNode,buf)))
-#define getNodeSize(X) ((X)->size + sizeof(ListNode))
+#define getNode(X)     ((ListNode*)(pChar(X)-offsetof(ListNode,buf)))
+#define getNodeSize(X) ((X)->size+sizeof(ListNode))
 
 /******************** private functions *******************/
-#define addNode(l) \
-    do{\
-        ListNode *tzzzmp = (ListNode*)ctl_malloc(getNodeSize(l));\
-        tzzzmp->head = (l);\
-        tzzzmp->prev = NULL;\
-        tzzzmp->next = NULL;\
-        (l)->count = 1;\
-        (l)->data.prev = tzzzmp;\
-        (l)->data.next = tzzzmp;\
-    }while(0)
-#define addNodeBack(l) \
-    do{\
-        ListNode *tzzzmp = (ListNode*)ctl_malloc(getNodeSize(l));\
-        tzzzmp->head = (l);\
-        tzzzmp->next = NULL;\
-        tzzzmp->prev = (l)->data.next;\
-        (l)->data.next->next = tzzzmp;\
-        (l)->data.next = tzzzmp;\
-        (l)->count++;\
-    }while(0)
-#define addNodeFront(l) \
+#define nodeConnect(a,b) \
     do{\
-        ListNode *tzzzmp = (ListNode*)ctl_malloc(getNodeSize(l));\
-        tzzzmp->head = (l);\
-        tzzzmp->prev = NULL;\
-        tzzzmp->next = (l)->data.prev;\
-        (l)->data.prev->prev = tzzzmp;\
-        (l)->data.prev = tzzzmp;\
-        (l)->count++;\
+        (a)->next = (b);\
+        (b)->prev = (a);\
     }while(0)
-#define delNode(l) \
+#define addNodeFront(lllll) \
     do{\
-        ListNode*tzzzmp = (l)->data.prev;\
-        free(tzzzmp);\
-        (l)->data.prev = NULL;\
-        (l)->data.next = NULL;\
-        (l)->count = 0;\
+        ListNode *tzzzmp = (ListNode*)ctl_malloc(getNodeSize(lllll));\
+        tzzzmp->head = (lllll);\
+        nodeConnect(tzzzmp, (lllll)->data.next);\
+        nodeConnect(&(lllll)->data, tzzzmp);\
+        (lllll)->count++;\
     }while(0)
-#define delNodeFront(l) \
+#define addNodeBack(lllll) \
     do{\
-        ListNode *tzzzmp = (l)->data.prev;\
-        (l)->data.prev = (l)->data.prev->next;\
-        (l)->data.prev->prev = NULL;\
-        free(tzzzmp);\
-        (l)->count--;\
+        ListNode *tzzzmp = (ListNode*)ctl_malloc(getNodeSize(lllll));\
+        tzzzmp->head = (lllll);\
+        nodeConnect((lllll)->data.prev, tzzzmp);\
+        nodeConnect(tzzzmp, &(lllll)->data);\
+        (lllll)->count++;\
     }while(0)
-#define delNodeBack(l) \
+#define delNodeFront(lllll) \
     do{\
-        ListNode *tzzzmp = (l)->data.next;\
-        (l)->data.next = (l)->data.next->prev;\
-        (l)->data.next->next = NULL;\
-        free(tzzzmp);\
-        (l)->count--;\
+        ListNode *tzzzmp = (lllll)->data.next;\
+        tzzzmp->head = (lllll);\
+        nodeConnect(&(lllll)->data, tzzzmp->next);\
+        ctl_free(tzzzmp);\
+        (lllll)->count--;\
     }while(0)
-#define nodeConnect(a,b) \
+#define delNodeBack(lllll) \
     do{\
-        if((a) != NULL){\
-            (a)->next = (b);\
-        }\
-        if((b) != NULL){\
-            (b)->prev = (a);\
-        }\
+        ListNode *tzzzmp = (lllll)->data.prev;\
+        tzzzmp->head = (lllll);\
+        nodeConnect(tzzzmp->prev, &(lllll)->data);\
+        ctl_free(tzzzmp);\
+        (lllll)->count--;\
     }while(0)
 
 /***************** initalize & destructure ****************/
 pvoid ctl_list_initX(ppvoid l, size_t size, uint count){
     ListHeader *tmp = (ListHeader*)ctl_malloc(sizeof(ListHeader));
-    tmp->size  = size;
-    tmp->count = count;
+    tmp->size      = size;
     tmp->data.head = tmp;
-    tmp->data.prev = NULL;
-    tmp->data.next = NULL;
-    pvoid ret;
-    if(count > 0){
-        addNode(tmp);
-        int i;
-        for(i = 1; i < count; i++){
-            addNodeBack(tmp);
-        }
-        ret = tmp->data.prev->buf;
-    }else{
-        ret = tmp->data.buf;
+    tmp->data.prev = &tmp->data;
+    tmp->data.next = &tmp->data;
+    for(tmp->count = 0; tmp->count < count; tmp->count++){
+        addNodeBack(tmp);
     }
     if(l != NULL){
-        l = ret;
+        *l = tmp->data.buf;
     }
-    return ret;
+    return tmp->data.buf;
 }
 
 pvoid ctl_list_freeX(ppvoid l){
     ListHeader* tmp = getHeader(*l);
-    while(l->data.prev != NULL){
-        ListNode *ntmp = l->data.prev;
-        l->data.prev = l->data.prev->next;
-        free(ntmp);
+    while(tmp->data.next != &tmp->data){
+        ListNode *ntmp = tmp->data.next;
+        tmp->data.next = tmp->data.next->next;
+        ctl_free(ntmp);
     }
-    free(tmp);
+    ctl_free(tmp);
     *l = NULL;
     return NULL;
 }
 
 /**************** about get??? methods ********************/
 int ctl_list_getSizeX(ppcvoid l){
-    return getHeader(*l)->count;
+    return  getHeader(*l)->count;
 }
 int ctl_list_getEntrySizeX(ppcvoid l){
     return getHeader(*l)->size;
 }
 pcvoid ctl_list_getFrontX(ppcvoid l){
-    return getHeader(*l)->data.prev->buf;
+    return getHeader(*l)->data.next->buf;
 }
 pcvoid ctl_list_getBackX(ppcvoid l){
-    return getHeader(*l)->data->next->buf;
-}
-pvoid ctl_list_getFirstX(ppcvoid l){
     return getHeader(*l)->data.prev->buf;
 }
-pvoid ctl_list_getLastX(ppcvoid l){
+pvoid ctl_list_getBeginX(ppcvoid l){
     return getHeader(*l)->data.next->buf;
 }
+pcvoid ctl_list_getEndX(ppcvoid l){
+    return *l;
+}
 
 /**************** about set??? methods ********************/
 int ctl_list_setSizeX(ppvoid l, uint count){
     ListHeader *tmp = getHeader(*l);
-    if(tmp->count > count){ // decrease
-        while(tmp->count > ctl_max(count, 1)){
-            delNodeBack(tmp);
-        }
-        if(count == 0){
-            delNode(tmp);
-        }
-    }else if(tmp->count < count){ // incrase
-        if(tmp->count == 0){
-            addNode(tmp);
-        }
-        while(tmp->count < count){
-            addNodeBack(tmp);
-        }
+    while(tmp->count > count){
+        delNodeBack(tmp);
+    }
+    while(tmp->count < count){
+        addNodeBack(tmp);
     }
     return tmp->count;
 }
 pvoid ctl_list_setFrontX(ppvoid l, pcvoid data){
     ListHeader *tmp = getHeader(*l);
-    memcpy(tmp->data.prev->buf, data, sizeof(tmp->size));
-    return tmp->data.prev->buf;
+    memcpy(tmp->data.next->buf, data, sizeof(tmp->size));
+    return tmp->data.next->buf;
 }
 pvoid ctl_list_setBackX(ppvoid l, pcvoid data){
     ListHeader *tmp = getHeader(*l);
-    memcpy(tmp->data.next->buf, data, sizeof(tmp->size));
-    return tmp->data.next->buf;
+    memcpy(tmp->data.prev->buf, data, sizeof(tmp->size));
+    return tmp->data.prev->buf;
 }
 
 /**************** about add/del front/back ****************/
 int ctl_list_addFrontX(ppvoid l, pcvoid data){
-    ListHeader *tmp = getHeader(*l);
-    if(tmp->count == 0){
-        addNode(tmp);
-    }else{
-        addNodeFront(tmp);
-    }
+    ListHeader* tmp = getHeader(*l);
+    addNodeFront(tmp);
     ctl_list_setFrontX(l, data);
     return tmp->count;
 }
 int ctl_list_delFrontX(ppvoid l){
-    ListHead *tmp = getHeader(*l);
-    if(tmp->count == 1){
-        delNode(tmp);
-    }else{
-        delNodeFront(tmp);
-    }
+    ListHeader *tmp = getHeader(*l);
+    delNodeFront(tmp);
     return tmp->count;
 }
 int ctl_list_addBackX(ppvoid l, pcvoid data){
-    ListHeader *tmp = getHeader(*l);
-    if(tmp->count == 0){
-        addNode(tmp);
-    }else{
-        addNodeBack(tmp);
-    }
+    ListHeader* tmp = getHeader(*l);
+    addNodeBack(tmp);
     ctl_list_setBackX(l, data);
     return tmp->count;
 }
 int ctl_list_delBackX(ppvoid l){
-    ListHead *tmp = getHeader(*l);
-    if(tmp->count == 1){
-        delNode(tmp);
-    }else{
-        delNodeBack(tmp);
-    }
+    ListHeader *tmp = getHeader(*l);
+    delNodeBack(tmp);
     return tmp->count;
 }
 
 /************** about list's special methods **************/
-int ctl_list_rmX(ppvoid l, ppvoid i1, ppvoid i2){
+int ctl_list_rmX(ppvoid l, pvoid i1, pvoid i2){
     ListHeader *tmp = getHeader(*l );
-    ListNode*    n1 = getNode  (*i1);
-    ListNode*    n2 = getNode  (*i2);
+    ListNode*    n1 = getNode  (i1);
+    ListNode*    n2 = getNode  (i2);
     nodeConnect(n1->prev, n2);
-    if(tmp->data.prev == n1){
-        tmp->data.prev = n2;
-    }
-    if(n2 == NULL){
-        tmp->data.next = n1->prev;
-    }
     int ret = 0;
     while(n1 != n2){
         ListNode* ntmp = n1;
         n1 = n1->next;
-        free(ntmp);
+        ctl_free(ntmp);
         ret++;
     }
     tmp->count -= ret;
     return ret;
 }
-pvoid ctl_list_copyX(ppvoid l, ppvoid i1, ppvoid i2, ppvoid out){
+pvoid ctl_list_copyX(ppvoid l, pvoid i1, pvoid i2, ppvoid out){
     ListHeader* tmp  = getHeader(*l);
-    ListHeader* tmp2 = ctl_list_init(NULL, tmp->size, 0);
-    ListNode*     n1 = getNode(*i1);
-    ListNode*     n2 = getNode(*i2);
+    pvoid *p0 = ctl_list_init(NULL, tmp->size, 0);
+    ListHeader* tmp2 = getHeader(p0);
+    ListNode*     n1 = getNode(i1);
+    ListNode*     n2 = getNode(i2);
     while(n1 != n2){
-        ctl_list_addBack(tmp2->data.buf, n1->buf);
+        char *c = tmp2->data.buf;
+        ctl_list_addBack(&c, n1->buf);
         n1 = n1->next;
         tmp2->count++;
     }
@@ -253,108 +192,77 @@ pvoid ctl_list_copyX(ppvoid l, ppvoid i1, ppvoid i2, ppvoid out){
     }
     return tmp2->data.buf;
 }
-pvoid ctl_list_moveX(ppvoid l, ppvoid i1, ppvoid i2, ppvoid out){
+pvoid ctl_list_moveX(ppvoid l, pvoid i1, pvoid i2, ppvoid out){
     ListHeader* tmp  = getHeader(*l);
-    ListHeader* tmp2 = ctl_list_init(NULL, tmp->size, 0);
-    ListNode*     n1 = getNode(*i1);
-    ListNode*     n2 = getNode(*i2);
-    tmp2->data.prev = n1;
-    tmp2->cata.next = (n2 == NULL ? tmp->data.next : n2->prev);
-    nodeConnect(n1->prev, n2);
-    if(tmp->data.prev == n1){
-        tmp->data.prev = n2;
-    }
-    if(n2 == NULL){
-        tmp->data.next = n1->prev;
-    }
-    while(n1 != n2){
-        n1 = n1->next;
-        tmp->count--;
+    pvoid *p0 = ctl_list_init(NULL, tmp->size, 0);
+    ListHeader* tmp2 = getHeader(p0);
+    ListNode*     n1 = getNode(i1);
+    ListNode*     n3 = getNode(i2);
+    ListNode*     n0 = n1->prev;
+    ListNode*     n2 = n3->prev;
+    ListNode*     ni;
+    for(ni = n1; ni != n3; ni = ni->next){
+        tmp ->count--;
         tmp2->count++;
     }
-    if(tmp2->count == 0){
-        tmp2->data.prev = NULL;
-        tmp2->data.next = NULL;
-    }else{
-        tmp2->data.prev->prev = NULL;
-        tmp2->data.next->next = NULL;
-    }
+    nodeConnect(&tmp2->data, n1);
+    nodeConnect(n2, &tmp2->data);
+    nodeConnect(n0, n3);
     if(out != NULL){
-        *out = tm2->data.buf;
+        *out = tmp2->data.buf;
     }
     return tmp2->data.buf;
 }
-int ctl_list_swapX(ppvoid l1, ppvoid i1, ppvoid i2,
-                   ppvoid l2, ppvoid j1, ppvoid j2){
-    ListHeader* h1 = getHeader(*l1);
-    ListHeader* h2 = getHeader(*l2);
-    ListNode* ni1 = getNode(*i1),* ni1p;
-    ListNode* ni2 = getNode(*i2),* ni2p;
-    ListNode* nj1 = getNode(*j1),* nj1p;
-    ListNode* nj2 = getNode(*j2),* nj2p;
-    ni1p = ni1->prev;
-    ni2p = (ni2 == NULL ? getHeader(*l1)->data.next : ni2->prev);
-    nj1p = nj1->prev;
-    nj2p = (nj2 == NULL ? getHeader(*l2)->data.next : nj2->prev);
+int ctl_list_swapX(ppvoid li, pvoid i1, pvoid i2,
+                   ppvoid lj, pvoid j1, pvoid j2){
+    ListHeader* hi  = getHeader(*li),* hj  = getHeader(*lj);
+    ListNode  * ni1 = getNode  ( i1),* nj1 = getNode  ( j1), *i;
+    ListNode  * ni3 = getNode  ( i2),* nj3 = getNode  ( j2), *j;
     int count1 = 0, count2 = 0;
-    if(ni1 == h1->data.prev) h1->data.prev = nj1;
-    if(nj1 == h2->data.prev) h2->data.prev = ni1;
-    if(ni2 == NULL) h1->data.next = nj2p;
-    if(nj2 == NULL) h2->data.next = ni2p;
-    ListNode* nii;
-    for(nii = ni1; nii != ni2; nii = nii->next) count1++;
-    for(nii = nj1; nii != nj2; nii = nii->next) count2++;
-    nodeConnect(ni1p, nj1);
-    nodeConnect(nj1p, ni1);
-    nodeConnect(ni2p, nj2);
-    nodeConnect(nj2p, ni2);
-    h1->size += (count2 - count1);
-    h2->size += (count1 - count2);
+    for(i = ni1; i != ni3; i = i->next){
+        count1++;
+    }
+    for(j = nj1; j != nj3; j = j->next){
+        count2++;
+    }
+    ListNode* ni0 = ni1->prev,* ni2 = ni3->prev;
+    ListNode* nj0 = nj1->prev,* nj2 = nj3->prev;
+    nodeConnect(ni0, nj1);
+    nodeConnect(nj0, ni1);
+    nodeConnect(ni2, nj3);
+    nodeConnect(nj2, ni3);
+    hi->size += (count2 - count1);
+    hj->size += (count1 - count2);
     return count1;
 }
 
 /******************** about iterator **********************/
-pcvoid ctl_list_iterGetEntryX(ppcvoid i){
-    return *i;
-}
-pvoid ctl_list_iterGetNextX(ppcvoid i){
-    return getNode(*i)->next->buf;
+pcvoid ctl_list_iterGetEntryX(pcvoid i){
+    return i;
 }
-pvoid ctl_list_iterGetPrevX(ppcvoid i){
-    return getNode(*i)->prev->buf;
+pvoid ctl_list_iterGetNextX(pcvoid i){
+    return getNode(i)->next->buf;
 }
-
-pvoid ctl_list_iterSetEntryX(ppvoid i, pcvoid *data){
-    memcpy(getNode(*i)->buf, data, getNode(*i)->head->size);
-    return getNode(*i)->buf;
+pvoid ctl_list_iterGetPrevX(pcvoid i){
+    return getNode(i)->prev->buf;
 }
 
-pvoid ctl_list_iterGoNextX(ppvoid i){
-    *i = getNode(*i)->next->buf;
-    return *i;
-}
-pvoid ctl_list_iterGoPrevX(ppvoid i){
-    *i = getNode(*i)->prev->buf;
-    return *i;
+pvoid ctl_list_iterSetEntryX(pvoid i, pcvoid data){
+    memcpy(i, data, getNode(i)->head->size);
+    return i;
 }
 
-pvoid ctl_list_iterDelX(ppvoid i){
-    ListNode *n = getNode(*i);
+pvoid ctl_list_iterDelX(pvoid i){
+    ListNode* n = getNode(i);
     nodeConnect(n->prev, n->next);
-    if(n == n->head->data.prev){
-        n->head->data.prev = n->next;
-    }
-    if(n == n->head->data.next){
-        n->head->data.next = n->prev;
-    }
     n->head->count--;
     return n->next->buf;
 }
-pvoid ctl_list_iterDelPrevX(ppvoid i){
-    ctl_list_iterDelX(getNode(*i)->prev->buf);
-    return *i;
+pvoid ctl_list_iterDelPrevX(pvoid i){
+    ctl_list_iterDelX(ppVoid(getNode(i)->prev->buf));
+    return i;
 }
-pvoid ctl_list_iterDelNextX(ppvoid i){
-    ctl_list_iterDelX(getNode(*i)->next->buf);
-    return *i;
+pvoid ctl_list_iterDelNextX(pvoid i){
+    ctl_list_iterDelX(ppVoid(getNode(i)->next->buf));
+    return i;
 }