SphinxBase 5prealpha
glist.c
1/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
2/* ====================================================================
3 * Copyright (c) 1999-2004 Carnegie Mellon University. All rights
4 * reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 *
18 * This work was supported in part by funding from the Defense Advanced
19 * Research Projects Agency and the National Science Foundation of the
20 * United States of America, and the CMU Sphinx Speech Consortium.
21 *
22 * THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND
23 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
24 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY
26 * NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 *
34 * ====================================================================
35 *
36 */
37/*
38 * glist.h -- Module for maintaining a generic, linear linked-list structure.
39 *
40 * **********************************************
41 * CMU ARPA Speech Project
42 *
43 * Copyright (c) 1999 Carnegie Mellon University.
44 * ALL RIGHTS RESERVED.
45 * **********************************************
46 *
47 * HISTORY
48 * $Log: glist.c,v $
49 * Revision 1.8 2005/06/22 03:02:51 arthchan2003
50 * 1, Fixed doxygen documentation, 2, add keyword.
51 *
52 * Revision 1.3 2005/03/30 01:22:48 archan
53 * Fixed mistakes in last updates. Add
54 *
55 *
56 * 09-Mar-1999 M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
57 * Added glist_chkdup_*().
58 *
59 * 13-Feb-1999 M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University
60 * Created from earlier version.
61 */
62
63
64#include <stdio.h>
65#include <stdlib.h>
66#include <string.h>
67#include <assert.h>
68
69#include "sphinxbase/glist.h"
71
72
75{
76 gnode_t *gn;
77
78 gn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
79 gn->data.ptr = ptr;
80 gn->next = g;
81 return ((glist_t) gn); /* Return the new head of the list */
82}
83
84
87{
88 gnode_t *gn;
89
90 gn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
91 gn->data.i = (long)val;
92 gn->next = g;
93 return ((glist_t) gn); /* Return the new head of the list */
94}
95
96
99{
100 gnode_t *gn;
101
102 gn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
103 gn->data.ui = (unsigned long)val;
104 gn->next = g;
105 return ((glist_t) gn); /* Return the new head of the list */
106}
107
108
111{
112 gnode_t *gn;
113
114 gn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
115 gn->data.fl = (double)val;
116 gn->next = g;
117 return ((glist_t) gn); /* Return the new head of the list */
118}
119
120
123{
124 gnode_t *gn;
125
126 gn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
127 gn->data.fl = (double)val;
128 gn->next = g;
129 return ((glist_t) gn); /* Return the new head of the list */
130}
131
132void
134{
135 gnode_t *gn;
136
137 while (g) {
138 gn = g;
139 g = gn->next;
140 ckd_free((void *) gn);
141 }
142}
143
144int32
146{
147 gnode_t *gn;
148 int32 n;
149
150 for (gn = g, n = 0; gn; gn = gn->next, n++);
151 return n;
152}
153
154
155gnode_t *
157{
158 gnode_t *gn;
159
160 if (!g)
161 return NULL;
162
163 for (gn = g; gn->next; gn = gn->next);
164 return gn;
165}
166
167
170{
171 gnode_t *gn, *nextgn;
172 gnode_t *rev;
173
174 rev = NULL;
175 for (gn = g; gn; gn = nextgn) {
176 nextgn = gn->next;
177
178 gn->next = rev;
179 rev = gn;
180 }
181
182 return rev;
183}
184
185
186gnode_t *
187glist_insert_ptr(gnode_t * gn, void *ptr)
188{
189 gnode_t *newgn;
190
191 newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
192 newgn->data.ptr = ptr;
193 newgn->next = gn->next;
194 gn->next = newgn;
195
196 return newgn;
197}
198
199
200gnode_t *
202{
203 gnode_t *newgn;
204
205 newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
206 newgn->data.i = val;
207 newgn->next = gn->next;
208 gn->next = newgn;
209
210 return newgn;
211}
212
213
214gnode_t *
216{
217 gnode_t *newgn;
218
219 newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
220 newgn->data.ui = val;
221 newgn->next = gn->next;
222
223 gn->next = newgn;
224
225 return newgn;
226}
227
228
229gnode_t *
231{
232 gnode_t *newgn;
233
234 newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
235 newgn->data.fl = (double)val;
236 newgn->next = gn->next;
237 gn->next = newgn;
238
239 return newgn;
240}
241
242
243gnode_t *
245{
246 gnode_t *newgn;
247
248 newgn = (gnode_t *) ckd_calloc(1, sizeof(gnode_t));
249 newgn->data.fl = (double)val;
250 newgn->next = gn->next;
251 gn->next = newgn;
252
253 return newgn;
254}
255
256gnode_t *
258{
259 gnode_t *next;
260
261 next = gn->next;
262 if (pred) {
263 assert(pred->next == gn);
264
265 pred->next = next;
266 }
267
268 ckd_free((char *) gn);
269
270 return next;
271}
Sphinx's memory allocation/deallocation routines.
SPHINXBASE_EXPORT void ckd_free(void *ptr)
Test and free a 1-D array.
Definition: ckd_alloc.c:244
#define ckd_calloc(n, sz)
Macros to simplify the use of above functions.
Definition: ckd_alloc.h:248
Generic linked-lists maintenance.
SPHINXBASE_EXPORT gnode_t * glist_insert_uint32(gnode_t *gn, uint32 val)
Create and insert a new list node containing an unsigned integer.
Definition: glist.c:215
SPHINXBASE_EXPORT glist_t glist_add_int32(glist_t g, int32 val)
Create and prepend a new list node containing an integer.
Definition: glist.c:86
SPHINXBASE_EXPORT gnode_t * glist_insert_ptr(gnode_t *gn, void *ptr)
Create and insert a new list node, with the given user-defined data, after the given generic node gn.
Definition: glist.c:187
SPHINXBASE_EXPORT gnode_t * glist_insert_float32(gnode_t *gn, float32 val)
Create and insert a new list node containing a single-precision float.
Definition: glist.c:230
SPHINXBASE_EXPORT glist_t glist_reverse(glist_t g)
Reverse the order of the given glist.
Definition: glist.c:169
SPHINXBASE_EXPORT void glist_free(glist_t g)
Free the given generic list; user-defined data contained within is not automatically freed.
Definition: glist.c:133
SPHINXBASE_EXPORT gnode_t * glist_insert_float64(gnode_t *gn, float64 val)
Create and insert a new list node containing a double-precision float.
Definition: glist.c:244
SPHINXBASE_EXPORT glist_t glist_add_float32(glist_t g, float32 val)
Create and prepend a new list node containing a single-precision float.
Definition: glist.c:110
SPHINXBASE_EXPORT glist_t glist_add_float64(glist_t g, float64 val)
Create and prepend a new list node containing a double-precision float.
Definition: glist.c:122
SPHINXBASE_EXPORT glist_t glist_add_ptr(glist_t g, void *ptr)
Create and prepend a new list node, with the given user-defined data, at the HEAD of the given generi...
Definition: glist.c:74
SPHINXBASE_EXPORT gnode_t * gnode_free(gnode_t *gn, gnode_t *pred)
Free the given node, gn, of a glist, pred being its predecessor in the list.
Definition: glist.c:257
SPHINXBASE_EXPORT gnode_t * glist_tail(glist_t g)
Return the last node in the given list.
Definition: glist.c:156
SPHINXBASE_EXPORT gnode_t * glist_insert_int32(gnode_t *gn, int32 val)
Create and insert a new list node containing an integer.
Definition: glist.c:201
SPHINXBASE_EXPORT int32 glist_count(glist_t g)
Count the number of element in a given link list.
Definition: glist.c:145
SPHINXBASE_EXPORT glist_t glist_add_uint32(glist_t g, uint32 val)
Create and prepend a new list node containing an unsigned integer.
Definition: glist.c:98
A node in a generic list.
Definition: glist.h:100
struct gnode_s * next
See prim_type.h.
Definition: glist.h:102