1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#include "list.h"
struct ListNodeStruct;
struct ListHeaderStruct;
struct ListNodeStruct{
struct ListHeaderStruct *head;
struct ListNodeStruct *prev;
struct ListNodeStruct *next;
char buf[];
};
struct ListHeaderStruct{
size_t size;
uint count;
struct ListNodeStruct data;
};
typedef struct ListNodeStruct ListNode;
typedef struct ListHeaderStruct ListHeader;
#define getHeader(X) (*(ListHeader**)(pChar(X)-offsetof(ListNode,buf)))
#define getNodeSize(X) ((X)->size + sizeof(ListNode))
/******************** static functions ********************/
static void addNode0(ListHeader *l){
ListNode *tmp = (ListNode*)ctl_malloc(getNodeSize(l));
tmp->head = l;
tmp->prev = NULL;
tmp->next = NULL;
l->count = 1;
l->data.prev = tmp;
l->data.next = tmp;
}
static void addNodeBack(ListHeader *l){
ListNode *tmp = (ListNode*)ctl_malloc(getNodeSize(l));
tmp->head = l;
tmp->next = NULL;
tmp->prev = l->data.next;
l->data.next->next = tmp;
l->data.next = tmp;
l->count++;
}
static void addNodeFront(ListHeader *l){
ListNode *tmp = (ListNode*)ctl_malloc(getNodeSize(l));
tmp->head = l;
tmp->prev = NULL;
tmp->next = l->data.prev;
l->data.prev->prev = tmp;
l->data.prev = tmp;
l->count++;
}
/***************** 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->data.head = tmp;
tmp->data.prev = NULL;
tmp->data.next = NULL;
if(count > 0){
addNode0(tmp);
int i;
for(i = 1; i < count; i++)
addNodeBack(tmp);
if(l != NULL){
l = tmp->data.prev->buf;
}
return tmp->data.prev->buf;
}else{
if(l != NULL){
l = tmp->data.buf;
}
return tmp->data.buf;
}
}
pvoid ctl_list_freeX(ppvoid l){
ListHead* tmp = getHeader(*l);
while(l->data.prev != NULL){
ListNode *ntmp = l->data.prev;
l->data.prev = l->data.prev->next;
free(ntmp);
}
free(tmp);
*l = NULL;
return NULL;
}
/**************** about get??? methods ********************/
int ctl_list_getSizeX(ppcvoid l){
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;
}
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){
return getHeader(*l)->data.next->buf;
}
/**************** about set??? methods ********************/
int ctl_list_setSizeX (ppvoid l, uint count){
ListHeader *tmp = getHeader(*l);
if(tmp->count > count){
int i, ii = tmp->count - ctl_max(count, 1);
for(i = 0; i < ii; i++){
}
}
}
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, pcvoid data);
int ctl_list_addBackX (ppvoid l, pcvoid data);
int ctl_list_delBackX (ppvoid l, pcvoid data);
int ctl_list_catX (ppvoid l, ppcvoid l2);
pvoid ctl_list_copyX (ppvoid l, ppcvoid l2);
int ctl_list_replaceX(ppvoid i1, uint ct1, ppcvoid j1, int ct2);
void ctl_list_swapX (ppvoid i1, ppvoid i2, ppvoid j1, ppvoid j2);
pcvoid ctl_list_iterGetEntryX(ppcvoid i);
pvoid ctl_list_iterGetNextX (ppcvoid i);
pvoid ctl_list_iterGetPrevX (ppcvoid i);
pvoid ctl_list_iterSetEntryX(ppvoid i, pcvoid *data);
pvoid ctl_list_iterGoNextX(ppcvoid i);
pvoid ctl_list_iterGoPrevX(ppcvoid i);
pvoid ctl_list_iterDelX (ppvoid i);
pvoid ctl_list_iterDelPrevX(ppvoid i);
pvoid ctl_list_iterDelNextX(ppvoid i);
|
