Fix: Confusion between stream and stream class IDs
[babeltrace.git] / formats / ctf / writer / writer.c
CommitLineData
273b65be
JG
1/*
2 * writer.c
3 *
4 * Babeltrace CTF Writer
5 *
6 * Copyright 2013 EfficiOS Inc.
7 *
8 * Author: Jérémie Galarneau <jeremie.galarneau@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/ctf-writer/writer.h>
30#include <babeltrace/ctf-writer/clock.h>
31#include <babeltrace/ctf-writer/clock-internal.h>
32#include <babeltrace/ctf-writer/writer-internal.h>
33#include <babeltrace/ctf-writer/event-types-internal.h>
34#include <babeltrace/ctf-writer/event-fields-internal.h>
35#include <babeltrace/ctf-writer/functor-internal.h>
36#include <babeltrace/ctf-writer/stream-internal.h>
37#include <babeltrace/ctf-writer/stream.h>
38#include <babeltrace/compiler.h>
f6afb94e 39#include <babeltrace/endian.h>
273b65be
JG
40#include <stdio.h>
41#include <stdlib.h>
42#include <sys/stat.h>
43#include <errno.h>
44#include <unistd.h>
45#include <fcntl.h>
46#include <inttypes.h>
47
48#define DEFAULT_IDENTIFIER_SIZE 128
49#define DEFAULT_METADATA_STRING_SIZE 4096
50
51static
52void environment_variable_destroy(struct environment_variable *var);
53static
54void bt_ctf_writer_destroy(struct bt_ctf_ref *ref);
55static
56int init_trace_packet_header(struct bt_ctf_writer *writer);
57static
58int create_stream_file(struct bt_ctf_writer *writer,
59 struct bt_ctf_stream *stream);
60static
61void stream_flush_cb(struct bt_ctf_stream *stream,
62 struct bt_ctf_writer *writer);
63
64static
65const char * const reserved_keywords_str[] = {"align", "callsite",
66 "const", "char", "clock", "double", "enum", "env", "event",
67 "floating_point", "float", "integer", "int", "long", "short", "signed",
68 "stream", "string", "struct", "trace", "typealias", "typedef",
69 "unsigned", "variant", "void" "_Bool", "_Complex", "_Imaginary"};
70
71static
72const unsigned int field_type_aliases_alignments[] = {
73 [FIELD_TYPE_ALIAS_UINT5_T] = 1,
74 [FIELD_TYPE_ALIAS_UINT8_T ... FIELD_TYPE_ALIAS_UINT16_T] = 8,
75 [FIELD_TYPE_ALIAS_UINT27_T] = 1,
76 [FIELD_TYPE_ALIAS_UINT32_T ... FIELD_TYPE_ALIAS_UINT64_T] = 8,
77};
78
79static
80const unsigned int field_type_aliases_sizes[] = {
81 [FIELD_TYPE_ALIAS_UINT5_T] = 5,
82 [FIELD_TYPE_ALIAS_UINT8_T] = 8,
83 [FIELD_TYPE_ALIAS_UINT16_T] = 16,
84 [FIELD_TYPE_ALIAS_UINT27_T] = 27,
85 [FIELD_TYPE_ALIAS_UINT32_T] = 32,
86 [FIELD_TYPE_ALIAS_UINT64_T] = 64,
87};
88
89static GHashTable *reserved_keywords_set;
90static int init_done;
91static int global_data_refcount;
92
93struct bt_ctf_writer *bt_ctf_writer_create(const char *path)
94{
95 struct bt_ctf_writer *writer = NULL;
96
97 if (!path) {
98 goto error;
99 }
100
101 writer = g_new0(struct bt_ctf_writer, 1);
102 if (!writer) {
103 goto error;
104 }
105
106 bt_ctf_writer_set_byte_order(writer, BT_CTF_BYTE_ORDER_NATIVE);
107 bt_ctf_ref_init(&writer->ref_count);
108 writer->path = g_string_new(path);
109 if (!writer->path) {
110 goto error_destroy;
111 }
112
113 /* Create trace directory if necessary and open a metadata file */
114 if (g_mkdir_with_parents(path, S_IRWXU | S_IRWXG)) {
115 perror("g_mkdir_with_parents");
116 goto error_destroy;
117 }
118
1b8180b9 119 writer->trace_dir_fd = open(path, O_RDONLY, S_IRWXU | S_IRWXG);
273b65be
JG
120 if (writer->trace_dir_fd < 0) {
121 perror("open");
122 goto error_destroy;
123 }
124
125 writer->metadata_fd = openat(writer->trace_dir_fd, "metadata",
126 O_WRONLY | O_CREAT | O_TRUNC,
127 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
128 writer->environment = g_ptr_array_new_with_free_func(
129 (GDestroyNotify)environment_variable_destroy);
130 writer->clocks = g_ptr_array_new_with_free_func(
131 (GDestroyNotify)bt_ctf_clock_put);
132 writer->streams = g_ptr_array_new_with_free_func(
133 (GDestroyNotify)bt_ctf_stream_put);
134 writer->stream_classes = g_ptr_array_new_with_free_func(
135 (GDestroyNotify)bt_ctf_stream_class_put);
136 if (!writer->environment || !writer->clocks ||
137 !writer->stream_classes || !writer->streams) {
138 goto error_destroy;
139 }
140
141 /* Generate a trace UUID */
142 uuid_generate(writer->uuid);
143 if (init_trace_packet_header(writer)) {
144 goto error_destroy;
145 }
146
147 return writer;
148error_destroy:
149 unlinkat(writer->trace_dir_fd, "metadata", 0);
150 bt_ctf_writer_destroy(&writer->ref_count);
151 writer = NULL;
152error:
153 return writer;
154}
155
156void bt_ctf_writer_destroy(struct bt_ctf_ref *ref)
157{
158 struct bt_ctf_writer *writer;
159
160 if (!ref) {
161 return;
162 }
163
164 writer = container_of(ref, struct bt_ctf_writer, ref_count);
165 bt_ctf_writer_flush_metadata(writer);
166 if (writer->path) {
167 g_string_free(writer->path, TRUE);
168 }
169
170 if (writer->trace_dir_fd > 0) {
9bb7e58b
MD
171 if (close(writer->trace_dir_fd)) {
172 perror("close");
173 abort();
174 }
273b65be
JG
175 }
176
177 if (writer->metadata_fd > 0) {
9bb7e58b
MD
178 if (close(writer->metadata_fd)) {
179 perror("close");
180 abort();
181 }
273b65be
JG
182 }
183
184 if (writer->environment) {
185 g_ptr_array_free(writer->environment, TRUE);
186 }
187
188 if (writer->clocks) {
189 g_ptr_array_free(writer->clocks, TRUE);
190 }
191
192 if (writer->streams) {
193 g_ptr_array_free(writer->streams, TRUE);
194 }
195
196 if (writer->stream_classes) {
197 g_ptr_array_free(writer->stream_classes, TRUE);
198 }
199
200 bt_ctf_field_type_put(writer->trace_packet_header_type);
201 bt_ctf_field_put(writer->trace_packet_header);
202 g_free(writer);
203}
204
205struct bt_ctf_stream *bt_ctf_writer_create_stream(struct bt_ctf_writer *writer,
206 struct bt_ctf_stream_class *stream_class)
207{
208 int ret;
209 int stream_class_found = 0;
210 size_t i;
211 int stream_fd;
212 struct bt_ctf_stream *stream = NULL;
213
214 if (!writer || !stream_class) {
215 goto error;
216 }
217
218 stream = bt_ctf_stream_create(stream_class);
219 if (!stream) {
220 goto error;
221 }
222
223 stream_fd = create_stream_file(writer, stream);
224 if (stream_fd < 0 || bt_ctf_stream_set_fd(stream, stream_fd)) {
225 goto error;
226 }
227
228 bt_ctf_stream_set_flush_callback(stream, (flush_func)stream_flush_cb,
229 writer);
230 ret = bt_ctf_stream_class_set_byte_order(stream->stream_class,
231 writer->byte_order == LITTLE_ENDIAN ?
232 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN : BT_CTF_BYTE_ORDER_BIG_ENDIAN);
233 if (ret) {
234 goto error;
235 }
236
237 for (i = 0; i < writer->stream_classes->len; i++) {
238 if (writer->stream_classes->pdata[i] == stream->stream_class) {
239 stream_class_found = 1;
240 }
241 }
242
243 if (!stream_class_found) {
244 if (bt_ctf_stream_class_set_id(stream->stream_class,
245 writer->next_stream_id++)) {
246 goto error;
247 }
248
249 bt_ctf_stream_class_get(stream->stream_class);
250 g_ptr_array_add(writer->stream_classes, stream->stream_class);
251 }
252
253 bt_ctf_stream_get(stream);
254 g_ptr_array_add(writer->streams, stream);
255 writer->frozen = 1;
256 return stream;
257error:
258 bt_ctf_stream_put(stream);
259 return NULL;
260}
261
262int bt_ctf_writer_add_environment_field(struct bt_ctf_writer *writer,
263 const char *name,
264 const char *value)
265{
266 struct environment_variable *var = NULL;
267 char *escaped_value = NULL;
268 int ret = 0;
269
270 if (!writer || !name || !value || validate_identifier(name)) {
271 ret = -1;
272 goto error;
273 }
274
275 if (strchr(name, ' ')) {
276 ret = -1;
277 goto error;
278 }
279
280 var = g_new0(struct environment_variable, 1);
281 if (!var) {
282 ret = -1;
283 goto error;
284 }
285
286 escaped_value = g_strescape(value, NULL);
287 if (!escaped_value) {
288 ret = -1;
289 goto error;
290 }
291
292 var->name = g_string_new(name);
293 var->value = g_string_new(escaped_value);
294 g_free(escaped_value);
295 if (!var->name || !var->value) {
296 ret = -1;
297 goto error;
298 }
299
300 g_ptr_array_add(writer->environment, var);
301 return ret;
302
303error:
304 if (var && var->name) {
305 g_string_free(var->name, TRUE);
306 }
307
308 if (var && var->value) {
309 g_string_free(var->value, TRUE);
310 }
311
312 g_free(var);
313 return ret;
314}
315
316int bt_ctf_writer_add_clock(struct bt_ctf_writer *writer,
317 struct bt_ctf_clock *clock)
318{
319 int ret = 0;
320 struct search_query query = { .value = clock, .found = 0 };
321
322 if (!writer || !clock) {
323 ret = -1;
324 goto end;
325 }
326
327 /* Check for duplicate clocks */
328 g_ptr_array_foreach(writer->clocks, value_exists, &query);
329 if (query.found) {
330 ret = -1;
331 goto end;
332 }
333
334 bt_ctf_clock_get(clock);
335 g_ptr_array_add(writer->clocks, clock);
336end:
337 return ret;
338}
339
340BT_HIDDEN
341const char *get_byte_order_string(int byte_order)
342{
343 const char *string;
344
345 switch (byte_order) {
346 case LITTLE_ENDIAN:
347 string = "le";
348 break;
349 case BIG_ENDIAN:
350 string = "be";
351 break;
352 default:
353 string = "unknown";
354 break;
355 }
356
357 return string;
358}
359
360static
12af6048 361int append_trace_metadata(struct bt_ctf_writer *writer,
273b65be
JG
362 struct metadata_context *context)
363{
e32ff703 364 unsigned char *uuid = writer->uuid;
c4e511df 365 int ret;
e32ff703 366
273b65be
JG
367 g_string_append(context->string, "trace {\n");
368
369 g_string_append(context->string, "\tmajor = 1;\n");
370 g_string_append(context->string, "\tminor = 8;\n");
371
273b65be
JG
372 g_string_append_printf(context->string,
373 "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
374 uuid[0], uuid[1], uuid[2], uuid[3],
375 uuid[4], uuid[5], uuid[6], uuid[7],
376 uuid[8], uuid[9], uuid[10], uuid[11],
377 uuid[12], uuid[13], uuid[14], uuid[15]);
378 g_string_append_printf(context->string, "\tbyte_order = %s;\n",
379 get_byte_order_string(writer->byte_order));
380
381 g_string_append(context->string, "\tpacket.header := ");
382 context->current_indentation_level++;
383 g_string_assign(context->field_name, "");
c4e511df
MD
384 ret = bt_ctf_field_type_serialize(writer->trace_packet_header_type,
385 context);
12af6048
JG
386 if (ret) {
387 goto end;
388 }
273b65be
JG
389 context->current_indentation_level--;
390
391 g_string_append(context->string, ";\n};\n\n");
12af6048
JG
392end:
393 return ret;
273b65be
JG
394}
395
396static
397void append_env_field_metadata(struct environment_variable *var,
398 struct metadata_context *context)
399{
400 g_string_append_printf(context->string, "\t%s = \"%s\";\n",
401 var->name->str, var->value->str);
402}
403
404static
405void append_env_metadata(struct bt_ctf_writer *writer,
406 struct metadata_context *context)
407{
408 if (writer->environment->len == 0) {
409 return;
410 }
411
412 g_string_append(context->string, "env {\n");
413 g_ptr_array_foreach(writer->environment,
414 (GFunc)append_env_field_metadata, context);
415 g_string_append(context->string, "};\n\n");
416}
417
418char *bt_ctf_writer_get_metadata_string(struct bt_ctf_writer *writer)
419{
420 char *metadata = NULL;
421 struct metadata_context *context = NULL;
422 int err = 0;
423 size_t i;
424
425 if (!writer) {
426 goto end;
427 }
428
429 context = g_new0(struct metadata_context, 1);
430 if (!context) {
431 goto end;
432 }
433
434 context->field_name = g_string_sized_new(DEFAULT_IDENTIFIER_SIZE);
435 context->string = g_string_sized_new(DEFAULT_METADATA_STRING_SIZE);
436 g_string_append(context->string, "/* CTF 1.8 */\n\n");
12af6048
JG
437 if (append_trace_metadata(writer, context)) {
438 goto error;
439 }
273b65be
JG
440 append_env_metadata(writer, context);
441 g_ptr_array_foreach(writer->clocks,
442 (GFunc)bt_ctf_clock_serialize, context);
443
444 for (i = 0; i < writer->stream_classes->len; i++) {
445 err = bt_ctf_stream_class_serialize(
446 writer->stream_classes->pdata[i], context);
447 if (err) {
448 goto error;
449 }
450 }
451
452 metadata = context->string->str;
453error:
454 g_string_free(context->string, err ? TRUE : FALSE);
455 g_string_free(context->field_name, TRUE);
456 g_free(context);
457end:
458 return metadata;
459}
460
461void bt_ctf_writer_flush_metadata(struct bt_ctf_writer *writer)
462{
463 int ret;
464 char *metadata_string = NULL;
465
466 if (!writer) {
467 goto end;
468 }
469
470 metadata_string = bt_ctf_writer_get_metadata_string(writer);
471 if (!metadata_string) {
472 goto end;
473 }
474
475 if (lseek(writer->metadata_fd, 0, SEEK_SET) == (off_t)-1) {
476 perror("lseek");
477 goto end;
478 }
479
480 if (ftruncate(writer->metadata_fd, 0)) {
481 perror("ftruncate");
482 goto end;
483 }
484
485 ret = write(writer->metadata_fd, metadata_string,
486 strlen(metadata_string));
487 if (ret < 0) {
488 perror("write");
489 goto end;
490 }
491end:
492 g_free(metadata_string);
493}
494
495int bt_ctf_writer_set_byte_order(struct bt_ctf_writer *writer,
496 enum bt_ctf_byte_order byte_order)
497{
498 int ret = 0;
499 int internal_byte_order;
500
501 if (!writer || writer->frozen) {
502 ret = -1;
503 goto end;
504 }
505
506 switch (byte_order) {
507 case BT_CTF_BYTE_ORDER_NATIVE:
508 internal_byte_order = (G_BYTE_ORDER == G_LITTLE_ENDIAN) ?
509 LITTLE_ENDIAN : BIG_ENDIAN;
510 break;
511 case BT_CTF_BYTE_ORDER_LITTLE_ENDIAN:
512 internal_byte_order = LITTLE_ENDIAN;
513 break;
514 case BT_CTF_BYTE_ORDER_BIG_ENDIAN:
515 case BT_CTF_BYTE_ORDER_NETWORK:
516 internal_byte_order = BIG_ENDIAN;
517 break;
518 default:
519 ret = -1;
520 goto end;
521 }
522
523 writer->byte_order = internal_byte_order;
524 if (writer->trace_packet_header_type ||
525 writer->trace_packet_header) {
526 init_trace_packet_header(writer);
527 }
528end:
529 return ret;
530}
531
532void bt_ctf_writer_get(struct bt_ctf_writer *writer)
533{
534 if (!writer) {
535 return;
536 }
537
538 bt_ctf_ref_get(&writer->ref_count);
539}
540
541void bt_ctf_writer_put(struct bt_ctf_writer *writer)
542{
543 if (!writer) {
544 return;
545 }
546
547 bt_ctf_ref_put(&writer->ref_count, bt_ctf_writer_destroy);
548}
549
550BT_HIDDEN
551int validate_identifier(const char *input_string)
552{
553 int ret = 0;
554 char *string = NULL;
555 char *save_ptr, *token;
556
557 if (!input_string || input_string[0] == '\0') {
558 ret = -1;
559 goto end;
560 }
561
562 string = strdup(input_string);
563 if (!string) {
564 ret = -1;
565 goto end;
566 }
567
568 token = strtok_r(string, " ", &save_ptr);
569 while (token) {
fe0fe95c
JG
570 if (g_hash_table_lookup_extended(reserved_keywords_set,
571 GINT_TO_POINTER(g_quark_from_string(token)),
572 NULL, NULL)) {
273b65be
JG
573 ret = -1;
574 goto end;
575 }
576
577 token = strtok_r(NULL, " ", &save_ptr);
578 }
579end:
580 free(string);
581 return ret;
582}
583
584BT_HIDDEN
585struct bt_ctf_field_type *get_field_type(enum field_type_alias alias)
586{
587 unsigned int alignment, size;
588 struct bt_ctf_field_type *field_type;
589
590 if (alias >= NR_FIELD_TYPE_ALIAS) {
591 return NULL;
592 }
593
594 alignment = field_type_aliases_alignments[alias];
595 size = field_type_aliases_sizes[alias];
596 field_type = bt_ctf_field_type_integer_create(size);
597 bt_ctf_field_type_set_alignment(field_type, alignment);
598 return field_type;
599}
600
601static
602int init_trace_packet_header(struct bt_ctf_writer *writer)
603{
604 size_t i;
605 int ret = 0;
606 struct bt_ctf_field *trace_packet_header = NULL,
607 *magic = NULL, *uuid_array = NULL;
608 struct bt_ctf_field_type *_uint32_t =
609 get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
610 struct bt_ctf_field_type *_uint8_t =
611 get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
612 struct bt_ctf_field_type *trace_packet_header_type =
613 bt_ctf_field_type_structure_create();
614 struct bt_ctf_field_type *uuid_array_type =
615 bt_ctf_field_type_array_create(_uint8_t, 16);
616
617 if (!trace_packet_header_type || !uuid_array_type) {
618 ret = -1;
619 goto end;
620 }
621
622 ret = bt_ctf_field_type_set_byte_order(_uint32_t,
623 (writer->byte_order == LITTLE_ENDIAN ?
624 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN :
625 BT_CTF_BYTE_ORDER_BIG_ENDIAN));
626 if (ret) {
627 goto end;
628 }
629
630 ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
631 _uint32_t, "magic");
632 if (ret) {
633 goto end;
634 }
635
636 ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
637 uuid_array_type, "uuid");
638 if (ret) {
639 goto end;
640 }
641
642 ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
643 _uint32_t, "stream_id");
644 if (ret) {
645 goto end;
646 }
647
648 trace_packet_header = bt_ctf_field_create(trace_packet_header_type);
649 if (!trace_packet_header) {
650 ret = -1;
651 goto end;
652 }
653
654 magic = bt_ctf_field_structure_get_field(trace_packet_header, "magic");
655 ret = bt_ctf_field_unsigned_integer_set_value(magic, 0xC1FC1FC1);
656 if (ret) {
657 goto end;
658 }
659
660 uuid_array = bt_ctf_field_structure_get_field(trace_packet_header,
661 "uuid");
662 for (i = 0; i < 16; i++) {
663 struct bt_ctf_field *uuid_element =
664 bt_ctf_field_array_get_field(uuid_array, i);
665 ret = bt_ctf_field_unsigned_integer_set_value(uuid_element,
666 writer->uuid[i]);
667 bt_ctf_field_put(uuid_element);
668 if (ret) {
669 goto end;
670 }
671 }
672
673 bt_ctf_field_type_put(writer->trace_packet_header_type);
674 bt_ctf_field_put(writer->trace_packet_header);
675 writer->trace_packet_header_type = trace_packet_header_type;
676 writer->trace_packet_header = trace_packet_header;
677end:
678 bt_ctf_field_type_put(uuid_array_type);
679 bt_ctf_field_type_put(_uint32_t);
680 bt_ctf_field_type_put(_uint8_t);
681 bt_ctf_field_put(magic);
682 bt_ctf_field_put(uuid_array);
683 if (ret) {
684 bt_ctf_field_type_put(trace_packet_header_type);
685 bt_ctf_field_put(trace_packet_header);
686 }
687
688 return ret;
689}
690
691static
692void environment_variable_destroy(struct environment_variable *var)
693{
694 g_string_free(var->name, TRUE);
695 g_string_free(var->value, TRUE);
696 g_free(var);
697}
698
699static
700int create_stream_file(struct bt_ctf_writer *writer,
701 struct bt_ctf_stream *stream)
702{
703 int fd;
704 GString *filename = g_string_new(stream->stream_class->name->str);
705
706 g_string_append_printf(filename, "_%" PRIu32, stream->id);
707 fd = openat(writer->trace_dir_fd, filename->str,
708 O_RDWR | O_CREAT | O_TRUNC,
709 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
710 g_string_free(filename, TRUE);
711 return fd;
712}
713
714static
715void stream_flush_cb(struct bt_ctf_stream *stream, struct bt_ctf_writer *writer)
716{
717 struct bt_ctf_field *stream_id;
718
719 /* Start a new packet in the stream */
720 if (stream->flushed_packet_count) {
721 /* ctf_init_pos has already initialized the first packet */
722 ctf_packet_seek(&stream->pos.parent, 0, SEEK_CUR);
723 }
724
725 stream_id = bt_ctf_field_structure_get_field(
726 writer->trace_packet_header, "stream_id");
66a12737
JG
727 bt_ctf_field_unsigned_integer_set_value(stream_id,
728 stream->stream_class->id);
273b65be
JG
729 bt_ctf_field_put(stream_id);
730
731 /* Write the trace_packet_header */
732 bt_ctf_field_serialize(writer->trace_packet_header, &stream->pos);
733}
734
735static __attribute__((constructor))
736void writer_init(void)
737{
738 size_t i;
739 const size_t reserved_keywords_count =
740 sizeof(reserved_keywords_str) / sizeof(char *);
741
742 global_data_refcount++;
743 if (init_done) {
744 return;
745 }
746
747 reserved_keywords_set = g_hash_table_new(g_direct_hash, g_direct_equal);
748 for (i = 0; i < reserved_keywords_count; i++) {
fe0fe95c
JG
749 gpointer quark = GINT_TO_POINTER(g_quark_from_string(
750 reserved_keywords_str[i]));
751
752 g_hash_table_insert(reserved_keywords_set, quark, quark);
273b65be
JG
753 }
754
755 init_done = 1;
756}
757
758static __attribute__((destructor))
759void writer_finalize(void)
760{
761 if (--global_data_refcount == 0) {
762 g_hash_table_destroy(reserved_keywords_set);
763 }
764}
This page took 0.051036 seconds and 4 git commands to generate.