Jack2 1.9.6

jslist.h

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