Fix: Remove test_seek_empty_packet and test_seek_big_trace from SCRIPT_LIST
[babeltrace.git] / types / variant.c
1 /*
2 * variant.c
3 *
4 * BabelTrace - Variant Type Converter
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 <errno.h>
33
34 static
35 struct bt_definition *_variant_definition_new(struct bt_declaration *declaration,
36 struct definition_scope *parent_scope,
37 GQuark field_name, int index,
38 const char *root_name);
39 static
40 void _variant_definition_free(struct bt_definition *definition);
41
42 int bt_variant_rw(struct bt_stream_pos *ppos, struct bt_definition *definition)
43 {
44 struct definition_variant *variant_definition =
45 container_of(definition, struct definition_variant, p);
46 struct bt_definition *field;
47
48 field = bt_variant_get_current_field(variant_definition);
49 if (!field) {
50 return -EINVAL;
51 }
52 return generic_rw(ppos, field);
53 }
54
55 static
56 void _untagged_variant_declaration_free(struct bt_declaration *declaration)
57 {
58 struct declaration_untagged_variant *untagged_variant_declaration =
59 container_of(declaration, struct declaration_untagged_variant, p);
60 unsigned long i;
61
62 bt_free_declaration_scope(untagged_variant_declaration->scope);
63 g_hash_table_destroy(untagged_variant_declaration->fields_by_tag);
64
65 for (i = 0; i < untagged_variant_declaration->fields->len; i++) {
66 struct declaration_field *declaration_field =
67 &g_array_index(untagged_variant_declaration->fields,
68 struct declaration_field, i);
69 bt_declaration_unref(declaration_field->declaration);
70 }
71 g_array_free(untagged_variant_declaration->fields, true);
72 g_free(untagged_variant_declaration);
73 }
74
75 struct declaration_untagged_variant *bt_untagged_bt_variant_declaration_new(
76 struct declaration_scope *parent_scope)
77 {
78 struct declaration_untagged_variant *untagged_variant_declaration;
79 struct bt_declaration *declaration;
80
81 untagged_variant_declaration = g_new(struct declaration_untagged_variant, 1);
82 declaration = &untagged_variant_declaration->p;
83 untagged_variant_declaration->fields_by_tag = g_hash_table_new(g_direct_hash,
84 g_direct_equal);
85 untagged_variant_declaration->fields = g_array_sized_new(FALSE, TRUE,
86 sizeof(struct declaration_field),
87 DEFAULT_NR_STRUCT_FIELDS);
88 untagged_variant_declaration->scope = bt_new_declaration_scope(parent_scope);
89 declaration->id = CTF_TYPE_UNTAGGED_VARIANT;
90 declaration->alignment = 1;
91 declaration->declaration_free = _untagged_variant_declaration_free;
92 declaration->definition_new = NULL;
93 declaration->definition_free = NULL;
94 declaration->ref = 1;
95 return untagged_variant_declaration;
96 }
97
98 static
99 void _variant_declaration_free(struct bt_declaration *declaration)
100 {
101 struct declaration_variant *variant_declaration =
102 container_of(declaration, struct declaration_variant, p);
103
104 bt_declaration_unref(&variant_declaration->untagged_variant->p);
105 g_array_free(variant_declaration->tag_name, TRUE);
106 g_free(variant_declaration);
107 }
108
109 struct declaration_variant *
110 bt_variant_declaration_new(struct declaration_untagged_variant *untagged_variant, const char *tag)
111 {
112 struct declaration_variant *variant_declaration;
113 struct bt_declaration *declaration;
114
115 variant_declaration = g_new(struct declaration_variant, 1);
116 declaration = &variant_declaration->p;
117 variant_declaration->untagged_variant = untagged_variant;
118 bt_declaration_ref(&untagged_variant->p);
119 variant_declaration->tag_name = g_array_new(FALSE, TRUE, sizeof(GQuark));
120 bt_append_scope_path(tag, variant_declaration->tag_name);
121 declaration->id = CTF_TYPE_VARIANT;
122 declaration->alignment = 1;
123 declaration->declaration_free = _variant_declaration_free;
124 declaration->definition_new = _variant_definition_new;
125 declaration->definition_free = _variant_definition_free;
126 declaration->ref = 1;
127 return variant_declaration;
128 }
129
130 static
131 struct bt_definition *
132 _variant_definition_new(struct bt_declaration *declaration,
133 struct definition_scope *parent_scope,
134 GQuark field_name, int index,
135 const char *root_name)
136 {
137 struct declaration_variant *variant_declaration =
138 container_of(declaration, struct declaration_variant, p);
139 struct definition_variant *variant;
140 unsigned long i;
141 int ret;
142
143 variant = g_new(struct definition_variant, 1);
144 bt_declaration_ref(&variant_declaration->p);
145 variant->p.declaration = declaration;
146 variant->declaration = variant_declaration;
147 variant->p.ref = 1;
148 /*
149 * Use INT_MAX order to ensure that all fields of the parent
150 * scope are seen as being prior to this scope.
151 */
152 variant->p.index = root_name ? INT_MAX : index;
153 variant->p.name = field_name;
154 variant->p.path = bt_new_definition_path(parent_scope, field_name, root_name);
155 variant->p.scope = bt_new_definition_scope(parent_scope, field_name, root_name);
156
157 ret = bt_register_field_definition(field_name, &variant->p,
158 parent_scope);
159 assert(!ret);
160
161 variant->enum_tag = bt_lookup_path_definition(variant->p.scope->scope_path,
162 variant_declaration->tag_name,
163 parent_scope);
164
165 if (!variant->enum_tag)
166 goto error;
167 bt_definition_ref(variant->enum_tag);
168 variant->fields = g_ptr_array_sized_new(variant_declaration->untagged_variant->fields->len);
169 g_ptr_array_set_size(variant->fields, variant_declaration->untagged_variant->fields->len);
170 for (i = 0; i < variant_declaration->untagged_variant->fields->len; i++) {
171 struct declaration_field *declaration_field =
172 &g_array_index(variant_declaration->untagged_variant->fields,
173 struct declaration_field, i);
174 struct bt_definition **field =
175 (struct bt_definition **) &g_ptr_array_index(variant->fields, i);
176
177 /*
178 * All child definition are at index 0, because they are
179 * various choices of the same field.
180 */
181 *field = declaration_field->declaration->definition_new(declaration_field->declaration,
182 variant->p.scope,
183 declaration_field->name, 0, NULL);
184 if (!*field)
185 goto error;
186 }
187 variant->current_field = NULL;
188 return &variant->p;
189 error:
190 bt_free_definition_scope(variant->p.scope);
191 bt_declaration_unref(&variant_declaration->p);
192 g_free(variant);
193 return NULL;
194 }
195
196 static
197 void _variant_definition_free(struct bt_definition *definition)
198 {
199 struct definition_variant *variant =
200 container_of(definition, struct definition_variant, p);
201 unsigned long i;
202
203 assert(variant->fields->len == variant->declaration->untagged_variant->fields->len);
204 for (i = 0; i < variant->fields->len; i++) {
205 struct bt_definition *field = g_ptr_array_index(variant->fields, i);
206 bt_definition_unref(field);
207 }
208 bt_definition_unref(variant->enum_tag);
209 bt_free_definition_scope(variant->p.scope);
210 bt_declaration_unref(variant->p.declaration);
211 g_ptr_array_free(variant->fields, TRUE);
212 g_free(variant);
213 }
214
215 void bt_untagged_variant_declaration_add_field(struct declaration_untagged_variant *untagged_variant_declaration,
216 const char *field_name,
217 struct bt_declaration *field_declaration)
218 {
219 struct declaration_field *field;
220 unsigned long index;
221
222 g_array_set_size(untagged_variant_declaration->fields, untagged_variant_declaration->fields->len + 1);
223 index = untagged_variant_declaration->fields->len - 1; /* last field (new) */
224 field = &g_array_index(untagged_variant_declaration->fields, struct declaration_field, index);
225 field->name = g_quark_from_string(field_name);
226 bt_declaration_ref(field_declaration);
227 field->declaration = field_declaration;
228 /* Keep index in hash rather than pointer, because array can relocate */
229 g_hash_table_insert(untagged_variant_declaration->fields_by_tag,
230 (gpointer) (unsigned long) field->name,
231 (gpointer) index);
232 /*
233 * Alignment of variant is based on the alignment of its currently
234 * selected choice, so we leave variant alignment as-is (statically
235 * speaking).
236 */
237 }
238
239 struct declaration_field *
240 bt_untagged_variant_declaration_get_field_from_tag(struct declaration_untagged_variant *untagged_variant_declaration, GQuark tag)
241 {
242 gpointer index;
243 gboolean found;
244
245 found = g_hash_table_lookup_extended(
246 untagged_variant_declaration->fields_by_tag,
247 (gconstpointer) (unsigned long) tag, NULL, &index);
248
249 if (!found) {
250 return NULL;
251 }
252
253 return &g_array_index(untagged_variant_declaration->fields, struct declaration_field, (unsigned long)index);
254 }
255
256 /*
257 * field returned only valid as long as the field structure is not appended to.
258 */
259 struct bt_definition *bt_variant_get_current_field(struct definition_variant *variant)
260 {
261 struct definition_enum *_enum =
262 container_of(variant->enum_tag, struct definition_enum, p);
263 struct declaration_variant *variant_declaration = variant->declaration;
264 unsigned long index;
265 GArray *tag_array;
266 GQuark tag;
267 gpointer orig_key, value;
268
269 tag_array = _enum->value;
270 if (!tag_array) {
271 /* Enumeration has unknown tag. */
272 fprintf(stderr, "[error] Enumeration used for variant has unknown tag.\n");
273 return NULL;
274 }
275 /*
276 * The 1 to 1 mapping from enumeration to value should have been already
277 * checked. (see TODO above)
278 */
279 assert(tag_array->len == 1);
280 tag = g_array_index(tag_array, GQuark, 0);
281 if (!g_hash_table_lookup_extended(variant_declaration->untagged_variant->fields_by_tag,
282 (gconstpointer) (unsigned long) tag,
283 &orig_key,
284 &value)) {
285 /* Cannot find matching field. */
286 fprintf(stderr, "[error] Cannot find matching field for enum field \"%s\" in variant.\n",
287 g_quark_to_string(tag));
288 return NULL;
289 }
290 index = (unsigned long) value;
291 variant->current_field = g_ptr_array_index(variant->fields, index);
292 return variant->current_field;
293 }
This page took 0.052248 seconds and 4 git commands to generate.