1: #include <string.h>
2: #include "linked_list.h"
3:
4: void InitList(list_info* list_pointers)
5: {
6: (*list_pointers).head = NULL;
7: (*list_pointers).cur = NULL;
8: (*list_pointers).tail = NULL;
9: }
10:
11: void FreeList(list_info* list_pointers)
12: {
13: ToFirst(list_pointers);
14: while (!ListIsEmpty(list_pointers))
15: Delete(list_pointers);
16: }
17:
18: bool ListIsEmpty(list_info* list_pointers)
19: {
20: return ((*list_pointers).head == NULL ? TRUE : FALSE);
21: }
22:
23: int Length(list_info* list_pointers)
24: {
25: list_info temp;
26: int count = 0;
27:
28: memcpy(&temp, list_pointers, sizeof(list_info));
29: while(RetrieveNextNode(&temp).cur)
30: {
31: count++;
32: Advance(&temp);
33: }
34:
35: return count;
36: }
37:
38: bool ListIsFull()
39: {
40: return FALSE;
41: /*
42: struct linked_list* temp =
43: (struct linked_list*)malloc(sizeof(struct linked_list));
44:
45: if(temp)*/ /*if there is memory, return false*/
46: /*{
47: free(temp);
48: return FALSE;
49: }
50: return TRUE;*/
51: }
52:
53: bool CurIsEmpty(list_info* list_pointers)
54: {
55: return ((*list_pointers).cur == NULL ? TRUE : FALSE);
56: }
57:
58: struct linked_list* ToFirst(list_info* list_pointers)
59: {
60: (*list_pointers).cur = (*list_pointers).head;
61:
62: return (*list_pointers).head;
63: }
64:
65: struct linked_list* ToEnd(list_info* list_pointers)
66: {
67: (*list_pointers).cur = (*list_pointers).tail;
68:
69: return (*list_pointers).tail;
70: }
71:
72: bool AtFirst(list_info* list_pointers)
73: {
74: return ((*list_pointers).head == (*list_pointers).cur ? TRUE : FALSE);
75: }
76:
77: bool AtEnd(list_info* list_pointers)
78: {
79: return ((*list_pointers).tail == (*list_pointers).cur ? TRUE : FALSE);
80: }
81:
82: void Advance(list_info* list_pointers)
83: {
84: if (CurIsEmpty(list_pointers))
85: NodeReferenceError();
86: else
87: (*list_pointers).cur = (*list_pointers).cur->next;
88: }
89:
90: void Retreat(list_info* list_pointers)
91: {
92: if(CurIsEmpty(list_pointers))
93: NodeReferenceError();
94: else
95: (*list_pointers).cur = (*list_pointers).cur->prev;
96: }
97:
98: void InsertAfter(el_t e, list_info* list_pointers)
99: {
100: node_pointer target = MakeNode(e);
101:
102: if (ListIsEmpty(list_pointers))
103: {
104: (*list_pointers).head = target;
105: (*list_pointers).cur = target;
106: (*list_pointers).tail = target;
107: }
108: else if (CurIsEmpty(list_pointers))
109: NodeReferenceError();
110: else if (AtEnd(list_pointers))
111: {
112: target->prev = (*list_pointers).cur;
113: (*list_pointers).cur->next = target;
114: (*list_pointers).tail = target; //set new tail
115: }
116: else
117: {
118: target->next = (*list_pointers).cur->next;
119: target->prev = (*list_pointers).cur;
120: (*list_pointers).cur->next->prev = target;
121: (*list_pointers).cur->next = target;
122: }
123: }
124:
125: void Insert(el_t e, list_info* list_pointers)
126: {
127: node_pointer target = MakeNode(e);
128:
129: if (ListIsEmpty(list_pointers)) // create one-element list
130: {
131: (*list_pointers).head = target;
132: (*list_pointers).cur = target;
133: (*list_pointers).tail = target;
134: }
135: else if (CurIsEmpty(list_pointers)) // empty cur, nonempty list
136: NodeReferenceError();
137: else if(AtFirst(list_pointers)) // new head node
138: {
139: target->next = (*list_pointers).cur;
140: (*list_pointers).cur->prev = target;
141: (*list_pointers).head = target;
142: }
143: else // insert between two nodes
144: {
145: target->next = (*list_pointers).cur;
146: target->prev = (*list_pointers).cur->prev;
147: (*list_pointers).cur->prev->next = target;
148: (*list_pointers).cur->prev = target;
149: }
150: }
151:
152: void Delete(list_info* list_pointers)
153: {
154: node_pointer tmp;
155:
156: if (CurIsEmpty(list_pointers)) /* empty list*/
157: NodeReferenceError();
158: else if (AtFirst(list_pointers) && AtEnd(list_pointers)) /*one node exists*/
159: {
160: DestroyNode((*list_pointers).cur);
161: /*set the pointers to null*/
162: memset(list_pointers, 0, sizeof(list_info));
163: }
164: else if (AtFirst(list_pointers)) /* delete head node*/
165: {
166: tmp = (*list_pointers).cur;
167: (*list_pointers).cur = (*list_pointers).cur->next;
168: (*list_pointers).cur->prev = NULL;
169: (*list_pointers).head = (*list_pointers).cur;
170: DestroyNode(tmp);
171: }
172: else if (AtEnd(list_pointers)) // delete end node
173: {
174: tmp = (*list_pointers).cur;
175: (*list_pointers).cur = (*list_pointers).cur->prev;
176: (*list_pointers).cur->next = NULL;
177: (*list_pointers).tail = (*list_pointers).cur;
178: DestroyNode(tmp);
179: }
180: else // delete middle node
181: {
182: tmp = (*list_pointers).cur;
183: (*list_pointers).cur->prev->next = (*list_pointers).cur->next;
184: (*list_pointers).cur->next->prev = (*list_pointers).cur->prev;
185: (*list_pointers).cur = (*list_pointers).cur->next;
186: DestroyNode(tmp);
187: }
188: }
189:
190: void StoreInfo(el_t e, list_info* list_pointers)
191: {
192: if(CurIsEmpty(list_pointers))
193: NodeReferenceError();
194: else
195: /*There had better be enough room...*/
196: memcpy(&(((*list_pointers).cur)->data), &e, sizeof(void*));
197: }
198:
199: el_t RetrieveInfo(list_info* list_pointers)
200: {
201: if(CurIsEmpty(list_pointers))
202: NodeReferenceError();
203:
204: return (((*list_pointers).cur)->data);
205: }
206:
207: el_t RetrievePrevInfo(list_info* list_pointers)
208: {
209: if (CurIsEmpty(list_pointers))
210: NodeReferenceError();
211: if(AtFirst(list_pointers))
212: NodeReferenceError();
213:
214: return (((*list_pointers).cur)->prev->data);
215: }
216:
217: list_info RetrievePrevNode(list_info* list_pointers)
218: {
219: list_info temp;
220: memcpy(&temp, list_pointers, sizeof(list_info));
221:
222: if (CurIsEmpty(list_pointers))
223: NodeReferenceError();
224:
225: temp.cur = ((*list_pointers).cur)->prev;
226:
227: return temp;
228: }
229:
230:
231: el_t RetrieveNextInfo(list_info* list_pointers)
232: {
233: if (CurIsEmpty(list_pointers))
234: NodeReferenceError();
235: if(AtEnd(list_pointers))
236: NodeReferenceError();
237:
238: return (((*list_pointers).cur)->next->data);
239: }
240:
241: list_info RetrieveNextNode(list_info* list_pointers)
242: {
243: list_info temp;
244: memcpy(&temp, list_pointers, sizeof(list_info));
245:
246: if (CurIsEmpty(list_pointers))
247: NodeReferenceError();
248:
249: temp.cur = ((*list_pointers).cur)->next;
250:
251: return temp;
252: }
253:
254: node_pointer MakeNode(el_t e)
255: {
256: node_pointer p;
257:
258: if(ListIsFull())
259: {
260: printf("List is Full. Exiting.\n");
261: exit(1);
262: }
263:
264:
265:
266: #ifdef __cplusplus
267: p = new struct linked_list;
268: #else
269: p = (struct linked_list*) malloc(sizeof(struct linked_list));
270: #endif
271:
272: if (!p)
273: {
274: printf("Error making node\n");
275: exit(1);
276: }
277: else
278: {
279: memcpy(&(p->data), &e, sizeof(el_t));
280: p->next = NULL;
281: p->prev = NULL;
282: }
283:
284: return p;
285: }
286:
287: void DestroyNode(node_pointer p)
288: {
289: #ifdef __cplusplus
290: delete p;
291: #else
292: free(p);
293: #endif
294: }
295:
296: void NodeReferenceError()
297: {
298: int *temp = NULL;
299: printf("ERROR: No current node or an improper node\n");
300: printf("%d\n", *temp);
301: exit(1);
302: }
303:
304:
305: