00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064 #include <stdio.h>
00065 #include <stdlib.h>
00066 #include <string.h>
00067 #include <assert.h>
00068
00069 #include "glist.h"
00070 #include "ckd_alloc.h"
00071
00072
00073 glist_t
00074 glist_add_ptr(glist_t g, void *ptr)
00075 {
00076 gnode_t *gn;
00077
00078 gn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
00079 gn->data.ptr = ptr;
00080 gn->next = g;
00081 return ((glist_t) gn);
00082 }
00083
00084
00085 glist_t
00086 glist_add_int32(glist_t g, int32 val)
00087 {
00088 gnode_t *gn;
00089
00090 gn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
00091 gn->data.i = (long)val;
00092 gn->next = g;
00093 return ((glist_t) gn);
00094 }
00095
00096
00097 glist_t
00098 glist_add_uint32(glist_t g, uint32 val)
00099 {
00100 gnode_t *gn;
00101
00102 gn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
00103 gn->data.ui = (unsigned long)val;
00104 gn->next = g;
00105 return ((glist_t) gn);
00106 }
00107
00108
00109 glist_t
00110 glist_add_float32(glist_t g, float32 val)
00111 {
00112 gnode_t *gn;
00113
00114 gn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
00115 gn->data.fl = (double)val;
00116 gn->next = g;
00117 return ((glist_t) gn);
00118 }
00119
00120
00121 glist_t
00122 glist_add_float64(glist_t g, float64 val)
00123 {
00124 gnode_t *gn;
00125
00126 gn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
00127 gn->data.fl = (double)val;
00128 gn->next = g;
00129 return ((glist_t) gn);
00130 }
00131
00132 void
00133 glist_free(glist_t g)
00134 {
00135 gnode_t *gn;
00136
00137 while (g) {
00138 gn = g;
00139 g = gn->next;
00140 ckd_free((void *) gn);
00141 }
00142 }
00143
00144 int32
00145 glist_count(glist_t g)
00146 {
00147 gnode_t *gn;
00148 int32 n;
00149
00150 for (gn = g, n = 0; gn; gn = gn->next, n++);
00151 return n;
00152 }
00153
00154
00155 gnode_t *
00156 glist_tail(glist_t g)
00157 {
00158 gnode_t *gn;
00159
00160 if (!g)
00161 return NULL;
00162
00163 for (gn = g; gn->next; gn = gn->next);
00164 return gn;
00165 }
00166
00167
00168 glist_t
00169 glist_reverse(glist_t g)
00170 {
00171 gnode_t *gn, *nextgn;
00172 gnode_t *rev;
00173
00174 rev = NULL;
00175 for (gn = g; gn; gn = nextgn) {
00176 nextgn = gn->next;
00177
00178 gn->next = rev;
00179 rev = gn;
00180 }
00181
00182 return rev;
00183 }
00184
00185
00186 gnode_t *
00187 glist_insert_ptr(gnode_t * gn, void *ptr)
00188 {
00189 gnode_t *newgn;
00190
00191 newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
00192 newgn->data.ptr = ptr;
00193 newgn->next = gn->next;
00194 gn->next = newgn;
00195
00196 return newgn;
00197 }
00198
00199
00200 gnode_t *
00201 glist_insert_int32(gnode_t * gn, int32 val)
00202 {
00203 gnode_t *newgn;
00204
00205 newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
00206 newgn->data.i = val;
00207 newgn->next = gn->next;
00208 gn->next = newgn;
00209
00210 return newgn;
00211 }
00212
00213
00214 gnode_t *
00215 glist_insert_uint32(gnode_t * gn, uint32 val)
00216 {
00217 gnode_t *newgn;
00218
00219 newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
00220 newgn->data.ui = val;
00221 newgn->next = gn->next;
00222
00223 gn->next = newgn;
00224
00225 return newgn;
00226 }
00227
00228
00229 gnode_t *
00230 glist_insert_float32(gnode_t * gn, float32 val)
00231 {
00232 gnode_t *newgn;
00233
00234 newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
00235 newgn->data.fl = (double)val;
00236 newgn->next = gn->next;
00237 gn->next = newgn;
00238
00239 return newgn;
00240 }
00241
00242
00243 gnode_t *
00244 glist_insert_float64(gnode_t * gn, float64 val)
00245 {
00246 gnode_t *newgn;
00247
00248 newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
00249 newgn->data.fl = (double)val;
00250 newgn->next = gn->next;
00251 gn->next = newgn;
00252
00253 return newgn;
00254 }
00255
00256 gnode_t *
00257 gnode_free(gnode_t * gn, gnode_t * pred)
00258 {
00259 gnode_t *next;
00260
00261 next = gn->next;
00262 if (pred) {
00263 assert(pred->next == gn);
00264
00265 pred->next = next;
00266 }
00267
00268 ckd_free((char *) gn);
00269
00270 return next;
00271 }