Fix: Remove test_seek_empty_packet and test_seek_big_trace from SCRIPT_LIST
[babeltrace.git] / types / enum.c
1 /*
2 * enum.c
3 *
4 * BabelTrace - Enumeration Type
5 *
6 * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
7 *
8 * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 * SOFTWARE.
27 */
28
29 #include <babeltrace/compiler.h>
30 #include <babeltrace/format.h>
31 #include <babeltrace/types.h>
32 #include <stdint.h>
33 #include <glib.h>
34
35 #if (__LONG_MAX__ == 2147483647L)
36 #define WORD_SIZE 32
37 #elif (__LONG_MAX__ == 9223372036854775807L)
38 #define WORD_SIZE 64
39 #else
40 #error "Unknown long size."
41 #endif
42
43 static
44 struct bt_definition *_enum_definition_new(struct bt_declaration *declaration,
45 struct definition_scope *parent_scope,
46 GQuark field_name, int index,
47 const char *root_name);
48 static
49 void _enum_definition_free(struct bt_definition *definition);
50
51 static
52 void enum_range_set_free(void *ptr)
53 {
54 g_array_unref(ptr);
55 }
56
57 #if (WORD_SIZE == 32)
58 static inline
59 gpointer get_uint_v(uint64_t *v)
60 {
61 return v;
62 }
63
64 static inline
65 gpointer get_int_v(int64_t *v)
66 {
67 return v;
68 }
69
70 static
71 guint enum_val_hash(gconstpointer key)
72 {
73 int64_t ukey = *(const int64_t *)key;
74
75 return (guint)ukey ^ (guint)(ukey >> 32);
76 }
77
78 static
79 gboolean enum_val_equal(gconstpointer a, gconstpointer b)
80 {
81 int64_t ua = *(const int64_t *)a;
82 int64_t ub = *(const int64_t *)b;
83
84 return ua == ub;
85 }
86
87 static
88 void enum_val_free(void *ptr)
89 {
90 g_free(ptr);
91 }
92 #else /* WORD_SIZE != 32 */
93 static inline
94 gpointer get_uint_v(uint64_t *v)
95 {
96 return (gpointer) *v;
97 }
98
99 static inline
100 gpointer get_int_v(int64_t *v)
101 {
102 return (gpointer) *v;
103 }
104
105 static
106 guint enum_val_hash(gconstpointer key)
107 {
108 return g_direct_hash(key);
109 }
110
111 static
112 gboolean enum_val_equal(gconstpointer a, gconstpointer b)
113 {
114 return g_direct_equal(a, b);
115 }
116
117 static
118 void enum_val_free(void *ptr)
119 {
120 }
121 #endif /* WORD_SIZE != 32 */
122
123 /*
124 * Returns a GArray or NULL.
125 * Caller must release the GArray with g_array_unref().
126 */
127 GArray *bt_enum_uint_to_quark_set(const struct declaration_enum *enum_declaration,
128 uint64_t v)
129 {
130 struct enum_range_to_quark *iter;
131 GArray *qs, *ranges = NULL;
132
133 /* Single values lookup */
134 qs = g_hash_table_lookup(enum_declaration->table.value_to_quark_set,
135 get_uint_v(&v));
136
137 /* Range lookup */
138 bt_list_for_each_entry(iter, &enum_declaration->table.range_to_quark, node) {
139 if (iter->range.start._unsigned > v || iter->range.end._unsigned < v)
140 continue;
141 if (!ranges) {
142 size_t qs_len = 0;
143
144 if (qs)
145 qs_len = qs->len;
146 ranges = g_array_sized_new(FALSE, TRUE,
147 sizeof(GQuark),
148 qs_len + 1);
149 g_array_set_size(ranges, qs_len + 1);
150 if (qs)
151 memcpy(ranges->data, qs->data,
152 sizeof(GQuark) * qs_len);
153 g_array_index(ranges, GQuark, qs_len) = iter->quark;
154 } else {
155 size_t qs_len = ranges->len;
156
157 g_array_set_size(ranges, qs_len + 1);
158 g_array_index(ranges, GQuark, qs_len) = iter->quark;
159 }
160 }
161 if (!ranges) {
162 if (!qs)
163 return NULL;
164 ranges = qs;
165 g_array_ref(ranges);
166 }
167 return ranges;
168 }
169
170 /*
171 * Returns a GArray or NULL.
172 * Caller must release the GArray with g_array_unref().
173 */
174 GArray *bt_enum_int_to_quark_set(const struct declaration_enum *enum_declaration,
175 int64_t v)
176 {
177 struct enum_range_to_quark *iter;
178 GArray *qs, *ranges = NULL;
179
180 /* Single values lookup */
181 qs = g_hash_table_lookup(enum_declaration->table.value_to_quark_set,
182 get_int_v(&v));
183
184 /* Range lookup */
185 bt_list_for_each_entry(iter, &enum_declaration->table.range_to_quark, node) {
186 if (iter->range.start._signed > v || iter->range.end._signed < v)
187 continue;
188 if (!ranges) {
189 size_t qs_len = 0;
190
191 if (qs)
192 qs_len = qs->len;
193 ranges = g_array_sized_new(FALSE, TRUE,
194 sizeof(GQuark),
195 qs_len + 1);
196 g_array_set_size(ranges, qs_len + 1);
197 if (qs)
198 memcpy(ranges->data, qs->data,
199 sizeof(GQuark) * qs_len);
200 g_array_index(ranges, GQuark, qs_len) = iter->quark;
201 } else {
202 size_t qs_len = ranges->len;
203
204 g_array_set_size(ranges, qs_len + 1);
205 g_array_index(ranges, GQuark, qs_len) = iter->quark;
206 }
207 }
208 if (!ranges) {
209 if (!qs)
210 return NULL;
211 ranges = qs;
212 g_array_ref(ranges);
213 }
214 return ranges;
215 }
216
217 static
218 void bt_enum_unsigned_insert_value_to_quark_set(struct declaration_enum *enum_declaration,
219 uint64_t v, GQuark q)
220 {
221 uint64_t *valuep;
222 GArray *array;
223
224 array = g_hash_table_lookup(enum_declaration->table.value_to_quark_set,
225 get_uint_v(&v));
226 if (!array) {
227 array = g_array_sized_new(FALSE, TRUE, sizeof(GQuark), 1);
228 g_array_set_size(array, 1);
229 g_array_index(array, GQuark, array->len - 1) = q;
230 #if (WORD_SIZE == 32)
231 valuep = g_new(uint64_t, 1);
232 *valuep = v;
233 #else /* WORD_SIZE != 32 */
234 valuep = get_uint_v(&v);
235 #endif /* WORD_SIZE != 32 */
236 g_hash_table_insert(enum_declaration->table.value_to_quark_set, valuep, array);
237 } else {
238 g_array_set_size(array, array->len + 1);
239 g_array_index(array, GQuark, array->len - 1) = q;
240 }
241 }
242
243 static
244 void bt_enum_signed_insert_value_to_quark_set(struct declaration_enum *enum_declaration,
245 int64_t v, GQuark q)
246 {
247 int64_t *valuep;
248 GArray *array;
249
250 array = g_hash_table_lookup(enum_declaration->table.value_to_quark_set,
251 get_int_v(&v));
252 if (!array) {
253 array = g_array_sized_new(FALSE, TRUE, sizeof(GQuark), 1);
254 g_array_set_size(array, 1);
255 g_array_index(array, GQuark, array->len - 1) = q;
256 #if (WORD_SIZE == 32)
257 valuep = g_new(int64_t, 1);
258 *valuep = v;
259 #else /* WORD_SIZE != 32 */
260 valuep = get_int_v(&v);
261 #endif /* WORD_SIZE != 32 */
262 g_hash_table_insert(enum_declaration->table.value_to_quark_set, valuep, array);
263 } else {
264 g_array_set_size(array, array->len + 1);
265 g_array_index(array, GQuark, array->len - 1) = q;
266 }
267 }
268
269 GArray *bt_enum_quark_to_range_set(const struct declaration_enum *enum_declaration,
270 GQuark q)
271 {
272 return g_hash_table_lookup(enum_declaration->table.quark_to_range_set,
273 (gconstpointer) (unsigned long) q);
274 }
275
276 static
277 void bt_enum_signed_insert_range_to_quark(struct declaration_enum *enum_declaration,
278 int64_t start, int64_t end, GQuark q)
279 {
280 struct enum_range_to_quark *rtoq;
281
282 rtoq = g_new(struct enum_range_to_quark, 1);
283 bt_list_add(&rtoq->node, &enum_declaration->table.range_to_quark);
284 rtoq->range.start._signed = start;
285 rtoq->range.end._signed = end;
286 rtoq->quark = q;
287 }
288
289 static
290 void bt_enum_unsigned_insert_range_to_quark(struct declaration_enum *enum_declaration,
291 uint64_t start, uint64_t end, GQuark q)
292 {
293 struct enum_range_to_quark *rtoq;
294
295 rtoq = g_new(struct enum_range_to_quark, 1);
296 bt_list_add(&rtoq->node, &enum_declaration->table.range_to_quark);
297 rtoq->range.start._unsigned = start;
298 rtoq->range.end._unsigned = end;
299 rtoq->quark = q;
300 }
301
302 void bt_enum_signed_insert(struct declaration_enum *enum_declaration,
303 int64_t start, int64_t end, GQuark q)
304 {
305 GArray *array;
306 struct enum_range *range;
307
308 if (start == end) {
309 bt_enum_signed_insert_value_to_quark_set(enum_declaration, start, q);
310 } else {
311 if (start > end) {
312 uint64_t tmp;
313
314 tmp = start;
315 start = end;
316 end = tmp;
317 }
318 bt_enum_signed_insert_range_to_quark(enum_declaration, start, end, q);
319 }
320
321 array = g_hash_table_lookup(enum_declaration->table.quark_to_range_set,
322 (gconstpointer) (unsigned long) q);
323 if (!array) {
324 array = g_array_sized_new(FALSE, TRUE,
325 sizeof(struct enum_range), 1);
326 g_hash_table_insert(enum_declaration->table.quark_to_range_set,
327 (gpointer) (unsigned long) q,
328 array);
329 }
330 g_array_set_size(array, array->len + 1);
331 range = &g_array_index(array, struct enum_range, array->len - 1);
332 range->start._signed = start;
333 range->end._signed = end;
334 }
335
336 void bt_enum_unsigned_insert(struct declaration_enum *enum_declaration,
337 uint64_t start, uint64_t end, GQuark q)
338 {
339 GArray *array;
340 struct enum_range *range;
341
342
343 if (start == end) {
344 bt_enum_unsigned_insert_value_to_quark_set(enum_declaration, start, q);
345 } else {
346 if (start > end) {
347 uint64_t tmp;
348
349 tmp = start;
350 start = end;
351 end = tmp;
352 }
353 bt_enum_unsigned_insert_range_to_quark(enum_declaration, start, end, q);
354 }
355
356 array = g_hash_table_lookup(enum_declaration->table.quark_to_range_set,
357 (gconstpointer) (unsigned long) q);
358 if (!array) {
359 array = g_array_sized_new(FALSE, TRUE,
360 sizeof(struct enum_range), 1);
361 g_hash_table_insert(enum_declaration->table.quark_to_range_set,
362 (gpointer) (unsigned long) q,
363 array);
364 }
365 g_array_set_size(array, array->len + 1);
366 range = &g_array_index(array, struct enum_range, array->len - 1);
367 range->start._unsigned = start;
368 range->end._unsigned = end;
369 }
370
371 size_t bt_enum_get_nr_enumerators(struct declaration_enum *enum_declaration)
372 {
373 return g_hash_table_size(enum_declaration->table.quark_to_range_set);
374 }
375
376 static
377 void _enum_declaration_free(struct bt_declaration *declaration)
378 {
379 struct declaration_enum *enum_declaration =
380 container_of(declaration, struct declaration_enum, p);
381 struct enum_range_to_quark *iter, *tmp;
382
383 g_hash_table_destroy(enum_declaration->table.value_to_quark_set);
384 bt_list_for_each_entry_safe(iter, tmp, &enum_declaration->table.range_to_quark, node) {
385 bt_list_del(&iter->node);
386 g_free(iter);
387 }
388 g_hash_table_destroy(enum_declaration->table.quark_to_range_set);
389 bt_declaration_unref(&enum_declaration->integer_declaration->p);
390 g_free(enum_declaration);
391 }
392
393 struct declaration_enum *
394 bt_enum_declaration_new(struct declaration_integer *integer_declaration)
395 {
396 struct declaration_enum *enum_declaration;
397
398 enum_declaration = g_new(struct declaration_enum, 1);
399
400 enum_declaration->table.value_to_quark_set = g_hash_table_new_full(enum_val_hash,
401 enum_val_equal,
402 enum_val_free,
403 enum_range_set_free);
404 BT_INIT_LIST_HEAD(&enum_declaration->table.range_to_quark);
405 enum_declaration->table.quark_to_range_set = g_hash_table_new_full(g_direct_hash,
406 g_direct_equal,
407 NULL, enum_range_set_free);
408 bt_declaration_ref(&integer_declaration->p);
409 enum_declaration->integer_declaration = integer_declaration;
410 enum_declaration->p.id = CTF_TYPE_ENUM;
411 enum_declaration->p.alignment = 1;
412 enum_declaration->p.declaration_free = _enum_declaration_free;
413 enum_declaration->p.definition_new = _enum_definition_new;
414 enum_declaration->p.definition_free = _enum_definition_free;
415 enum_declaration->p.ref = 1;
416 return enum_declaration;
417 }
418
419 static
420 struct bt_definition *
421 _enum_definition_new(struct bt_declaration *declaration,
422 struct definition_scope *parent_scope,
423 GQuark field_name, int index,
424 const char *root_name)
425 {
426 struct declaration_enum *enum_declaration =
427 container_of(declaration, struct declaration_enum, p);
428 struct definition_enum *_enum;
429 struct bt_definition *definition_integer_parent;
430 int ret;
431
432 _enum = g_new(struct definition_enum, 1);
433 bt_declaration_ref(&enum_declaration->p);
434 _enum->p.declaration = declaration;
435 _enum->declaration = enum_declaration;
436 _enum->p.ref = 1;
437 /*
438 * Use INT_MAX order to ensure that all fields of the parent
439 * scope are seen as being prior to this scope.
440 */
441 _enum->p.index = root_name ? INT_MAX : index;
442 _enum->p.name = field_name;
443 _enum->p.path = bt_new_definition_path(parent_scope, field_name, root_name);
444 _enum->p.scope = bt_new_definition_scope(parent_scope, field_name, root_name);
445 _enum->value = NULL;
446 ret = bt_register_field_definition(field_name, &_enum->p,
447 parent_scope);
448 assert(!ret);
449 definition_integer_parent =
450 enum_declaration->integer_declaration->p.definition_new(&enum_declaration->integer_declaration->p,
451 _enum->p.scope,
452 g_quark_from_static_string("container"), 0, NULL);
453 _enum->integer = container_of(definition_integer_parent,
454 struct definition_integer, p);
455 return &_enum->p;
456 }
457
458 static
459 void _enum_definition_free(struct bt_definition *definition)
460 {
461 struct definition_enum *_enum =
462 container_of(definition, struct definition_enum, p);
463
464 bt_definition_unref(&_enum->integer->p);
465 bt_free_definition_scope(_enum->p.scope);
466 bt_declaration_unref(_enum->p.declaration);
467 if (_enum->value)
468 g_array_unref(_enum->value);
469 g_free(_enum);
470 }
This page took 0.059279 seconds and 4 git commands to generate.