Jack2 1.9.6
|
00001 /* 00002 Based on gslist.c from glib-1.2.9 (LGPL). 00003 00004 Adaption to JACK, Copyright (C) 2002 Kai Vehmanen. 00005 - replaced use of gtypes with normal ANSI C types 00006 - glib's memory allocation routines replaced with 00007 malloc/free calls 00008 00009 This program is free software; you can redistribute it and/or modify 00010 it under the terms of the GNU Lesser General Public License as published by 00011 the Free Software Foundation; either version 2.1 of the License, or 00012 (at your option) any later version. 00013 00014 This program is distributed in the hope that it will be useful, 00015 but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00017 GNU Lesser General Public License for more details. 00018 00019 You should have received a copy of the GNU Lesser General Public License 00020 along with this program; if not, write to the Free Software 00021 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 00022 00023 */ 00024 00025 #ifndef __jack_jslist_h__ 00026 #define __jack_jslist_h__ 00027 00028 #include <stdlib.h> 00029 #include <jack/systemdeps.h> 00030 00031 #ifdef sun 00032 #define __inline__ 00033 #endif 00034 00035 typedef struct _JSList JSList; 00036 00037 typedef int (*JCompareFunc) (void* a, void* b); 00038 struct _JSList 00039 { 00040 void *data; 00041 JSList *next; 00042 }; 00043 00044 static __inline__ 00045 JSList* 00046 jack_slist_alloc (void) 00047 { 00048 JSList *new_list; 00049 00050 new_list = (JSList*)malloc(sizeof(JSList)); 00051 if (new_list) { 00052 new_list->data = NULL; 00053 new_list->next = NULL; 00054 } 00055 00056 return new_list; 00057 } 00058 00059 static __inline__ 00060 JSList* 00061 jack_slist_prepend (JSList* list, void* data) 00062 { 00063 JSList *new_list; 00064 00065 new_list = (JSList*)malloc(sizeof(JSList)); 00066 if (new_list) { 00067 new_list->data = data; 00068 new_list->next = list; 00069 } 00070 00071 return new_list; 00072 } 00073 00074 #define jack_slist_next(slist) ((slist) ? (((JSList *)(slist))->next) : NULL) 00075 static __inline__ 00076 JSList* 00077 jack_slist_last (JSList *list) 00078 { 00079 if (list) { 00080 while (list->next) 00081 list = list->next; 00082 } 00083 00084 return list; 00085 } 00086 00087 static __inline__ 00088 JSList* 00089 jack_slist_remove_link (JSList *list, 00090 JSList *link) 00091 { 00092 JSList *tmp; 00093 JSList *prev; 00094 00095 prev = NULL; 00096 tmp = list; 00097 00098 while (tmp) { 00099 if (tmp == link) { 00100 if (prev) 00101 prev->next = tmp->next; 00102 if (list == tmp) 00103 list = list->next; 00104 00105 tmp->next = NULL; 00106 break; 00107 } 00108 00109 prev = tmp; 00110 tmp = tmp->next; 00111 } 00112 00113 return list; 00114 } 00115 00116 static __inline__ 00117 void 00118 jack_slist_free (JSList *list) 00119 { 00120 while (list) { 00121 JSList *next = list->next; 00122 free(list); 00123 list = next; 00124 } 00125 } 00126 00127 static __inline__ 00128 void 00129 jack_slist_free_1 (JSList *list) 00130 { 00131 if (list) { 00132 free(list); 00133 } 00134 } 00135 00136 static __inline__ 00137 JSList* 00138 jack_slist_remove (JSList *list, 00139 void *data) 00140 { 00141 JSList *tmp; 00142 JSList *prev; 00143 00144 prev = NULL; 00145 tmp = list; 00146 00147 while (tmp) { 00148 if (tmp->data == data) { 00149 if (prev) 00150 prev->next = tmp->next; 00151 if (list == tmp) 00152 list = list->next; 00153 00154 tmp->next = NULL; 00155 jack_slist_free (tmp); 00156 00157 break; 00158 } 00159 00160 prev = tmp; 00161 tmp = tmp->next; 00162 } 00163 00164 return list; 00165 } 00166 00167 static __inline__ 00168 unsigned int 00169 jack_slist_length (JSList *list) 00170 { 00171 unsigned int length; 00172 00173 length = 0; 00174 while (list) { 00175 length++; 00176 list = list->next; 00177 } 00178 00179 return length; 00180 } 00181 00182 static __inline__ 00183 JSList* 00184 jack_slist_find (JSList *list, 00185 void *data) 00186 { 00187 while (list) { 00188 if (list->data == data) 00189 break; 00190 list = list->next; 00191 } 00192 00193 return list; 00194 } 00195 00196 static __inline__ 00197 JSList* 00198 jack_slist_copy (JSList *list) 00199 { 00200 JSList *new_list = NULL; 00201 00202 if (list) { 00203 JSList *last; 00204 00205 new_list = jack_slist_alloc (); 00206 new_list->data = list->data; 00207 last = new_list; 00208 list = list->next; 00209 while (list) { 00210 last->next = jack_slist_alloc (); 00211 last = last->next; 00212 last->data = list->data; 00213 list = list->next; 00214 } 00215 } 00216 00217 return new_list; 00218 } 00219 00220 static __inline__ 00221 JSList* 00222 jack_slist_append (JSList *list, 00223 void *data) 00224 { 00225 JSList *new_list; 00226 JSList *last; 00227 00228 new_list = jack_slist_alloc (); 00229 new_list->data = data; 00230 00231 if (list) { 00232 last = jack_slist_last (list); 00233 last->next = new_list; 00234 00235 return list; 00236 } else 00237 return new_list; 00238 } 00239 00240 static __inline__ 00241 JSList* 00242 jack_slist_sort_merge (JSList *l1, 00243 JSList *l2, 00244 JCompareFunc compare_func) 00245 { 00246 JSList list, *l; 00247 00248 l = &list; 00249 00250 while (l1 && l2) { 00251 if (compare_func(l1->data, l2->data) < 0) { 00252 l = l->next = l1; 00253 l1 = l1->next; 00254 } else { 00255 l = l->next = l2; 00256 l2 = l2->next; 00257 } 00258 } 00259 l->next = l1 ? l1 : l2; 00260 00261 return list.next; 00262 } 00263 00264 static __inline__ 00265 JSList* 00266 jack_slist_sort (JSList *list, 00267 JCompareFunc compare_func) 00268 { 00269 JSList *l1, *l2; 00270 00271 if (!list) 00272 return NULL; 00273 if (!list->next) 00274 return list; 00275 00276 l1 = list; 00277 l2 = list->next; 00278 00279 while ((l2 = l2->next) != NULL) { 00280 if ((l2 = l2->next) == NULL) 00281 break; 00282 l1 = l1->next; 00283 } 00284 l2 = l1->next; 00285 l1->next = NULL; 00286 00287 return jack_slist_sort_merge (jack_slist_sort (list, compare_func), 00288 jack_slist_sort (l2, compare_func), 00289 compare_func); 00290 } 00291 00292 #endif /* __jack_jslist_h__ */ 00293