lib/ctf-ir/utils.c

   1 /*
   2  * utils.c
   3  *
   4  * Babeltrace CTF IR - Utilities
   5  *
   6  * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   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 #define BT_LOG_TAG "CTF-IR-UTILS"
  30 #include <babeltrace/lib-logging-internal.h>
  31
  32 #include <assert.h>
  33 #include <stdlib.h>
  34 #include <glib.h>
  35 #include <babeltrace/ctf-ir/utils.h>
  36 #include <babeltrace/ctf-ir/field-types.h>
  37 #include <babeltrace/ref.h>
  38
  39 static
  40 const char * const reserved_keywords_str[] = {"align", "callsite",
  41         "const", "char", "clock", "double", "enum", "env", "event",
  42         "floating_point", "float", "integer", "int", "long", "short", "signed",
  43         "stream", "string", "struct", "trace", "typealias", "typedef",
  44         "unsigned", "variant", "void" "_Bool", "_Complex", "_Imaginary"};
  45
  46 static GHashTable *reserved_keywords_set;
  47 static int init_done;
  48
  49 static
  50 void try_init_reserved_keywords(void)
  51 {
  52         size_t i;
  53         const size_t reserved_keywords_count =
  54                 sizeof(reserved_keywords_str) / sizeof(char *);
  55
  56         if (reserved_keywords_set) {
  57                 return;
  58         }
  59
  60         reserved_keywords_set = g_hash_table_new(g_direct_hash, g_direct_equal);
  61         assert(reserved_keywords_set);
  62
  63         for (i = 0; i < reserved_keywords_count; i++) {
  64                 gpointer quark = GINT_TO_POINTER(g_quark_from_string(
  65                         reserved_keywords_str[i]));
  66
  67                 g_hash_table_insert(reserved_keywords_set, quark, quark);
  68         }
  69
  70         init_done = 1;
  71 }
  72
  73 static __attribute__((destructor))
  74 void trace_finalize(void)
  75 {
  76         if (reserved_keywords_set) {
  77                 g_hash_table_destroy(reserved_keywords_set);
  78         }
  79 }
  80
  81 int bt_validate_identifier(const char *input_string)
  82 {
  83         int ret = 0;
  84         char *string = NULL;
  85         char *save_ptr, *token;
  86
  87         if (!input_string) {
  88                 BT_LOGV_STR("Invalid parameter: input string is NULL.");
  89                 ret = -1;
  90                 goto end;
  91         }
  92
  93         try_init_reserved_keywords();
  94
  95         if (input_string[0] == '\0') {
  96                 ret = -1;
  97                 goto end;
  98         }
  99
 100         string = strdup(input_string);
 101         if (!string) {
 102                 BT_LOGE("strdup() failed.");
 103                 ret = -1;
 104                 goto end;
 105         }
 106
 107         token = strtok_r(string, " ", &save_ptr);
 108         while (token) {
 109                 if (g_hash_table_lookup_extended(reserved_keywords_set,
 110                         GINT_TO_POINTER(g_quark_from_string(token)),
 111                         NULL, NULL)) {
 112                         ret = -1;
 113                         goto end;
 114                 }
 115
 116                 token = strtok_r(NULL, " ", &save_ptr);
 117         }
 118 end:
 119         free(string);
 120         return ret;
 121 }
 122
 123 bt_bool bt_identifier_is_valid(const char *identifier)
 124 {
 125         return bt_validate_identifier(identifier) == 0;
 126 }
 127
 128 BT_HIDDEN
 129 int bt_validate_single_clock_class(struct bt_field_type *field_type,
 130                 struct bt_clock_class **expected_clock_class)
 131 {
 132         int ret = 0;
 133         assert(field_type);
 134         assert(expected_clock_class);
 135
 136         switch (bt_field_type_get_type_id(field_type)) {
 137         case BT_FIELD_TYPE_ID_INTEGER:
 138         {
 139                 struct bt_clock_class *mapped_clock_class =
 140                         bt_field_type_integer_get_mapped_clock_class(field_type);
 141
 142                 if (!mapped_clock_class) {
 143                         goto end;
 144                 }
 145
 146                 if (!*expected_clock_class) {
 147                         /* Move reference to output parameter */
 148                         *expected_clock_class = mapped_clock_class;
 149                         mapped_clock_class = NULL;
 150                         BT_LOGV("Setting expected clock class: "
 151                                 "expected-clock-class-addr=%p",
 152                                 *expected_clock_class);
 153                 } else {
 154                         if (mapped_clock_class != *expected_clock_class) {
 155                                 BT_LOGW("Integer field type is not mapped to "
 156                                         "the expected clock class: "
 157                                         "mapped-clock-class-addr=%p, "
 158                                         "expected-clock-class-addr=%p",
 159                                         mapped_clock_class,
 160                                         *expected_clock_class);
 161                                 bt_put(mapped_clock_class);
 162                                 ret = -1;
 163                                 goto end;
 164                         }
 165                 }
 166
 167                 bt_put(mapped_clock_class);
 168                 break;
 169         }
 170         case BT_FIELD_TYPE_ID_ENUM:
 171         case BT_FIELD_TYPE_ID_ARRAY:
 172         case BT_FIELD_TYPE_ID_SEQUENCE:
 173         {
 174                 struct bt_field_type *subtype = NULL;
 175
 176                 switch (bt_field_type_get_type_id(field_type)) {
 177                 case BT_FIELD_TYPE_ID_ENUM:
 178                         subtype = bt_field_type_enumeration_get_container_type(
 179                                 field_type);
 180                         break;
 181                 case BT_FIELD_TYPE_ID_ARRAY:
 182                         subtype = bt_field_type_array_get_element_type(
 183                                 field_type);
 184                         break;
 185                 case BT_FIELD_TYPE_ID_SEQUENCE:
 186                         subtype = bt_field_type_sequence_get_element_type(
 187                                 field_type);
 188                         break;
 189                 default:
 190                         BT_LOGF("Unexpected field type ID: id=%d",
 191                                 bt_field_type_get_type_id(field_type));
 192                         abort();
 193                 }
 194
 195                 assert(subtype);
 196                 ret = bt_validate_single_clock_class(subtype,
 197                         expected_clock_class);
 198                 bt_put(subtype);
 199                 break;
 200         }
 201         case BT_FIELD_TYPE_ID_STRUCT:
 202         {
 203                 uint64_t i;
 204                 int64_t count = bt_field_type_structure_get_field_count(
 205                         field_type);
 206
 207                 for (i = 0; i < count; i++) {
 208                         const char *name;
 209                         struct bt_field_type *member_type;
 210
 211                         ret = bt_field_type_structure_get_field_by_index(
 212                                 field_type, &name, &member_type, i);
 213                         assert(ret == 0);
 214                         ret = bt_validate_single_clock_class(member_type,
 215                                 expected_clock_class);
 216                         bt_put(member_type);
 217                         if (ret) {
 218                                 BT_LOGW("Structure field type's field's type "
 219                                         "is not recursively mapped to the "
 220                                         "expected clock class: "
 221                                         "field-ft-addr=%p, field-name=\"%s\"",
 222                                         member_type, name);
 223                                 goto end;
 224                         }
 225                 }
 226
 227                 break;
 228         }
 229         case BT_FIELD_TYPE_ID_VARIANT:
 230         {
 231                 uint64_t i;
 232                 int64_t count = bt_field_type_variant_get_field_count(
 233                         field_type);
 234
 235                 for (i = 0; i < count; i++) {
 236                         const char *name;
 237                         struct bt_field_type *member_type;
 238
 239                         ret = bt_field_type_variant_get_field_by_index(
 240                                 field_type, &name, &member_type, i);
 241                         assert(ret == 0);
 242                         ret = bt_validate_single_clock_class(member_type,
 243                                 expected_clock_class);
 244                         bt_put(member_type);
 245                         if (ret) {
 246                                 BT_LOGW("Variant field type's field's type "
 247                                         "is not recursively mapped to the "
 248                                         "expected clock class: "
 249                                         "field-ft-addr=%p, field-name=\"%s\"",
 250                                         member_type, name);
 251                                 goto end;
 252                         }
 253                 }
 254
 255                 break;
 256         }
 257         default:
 258                 break;
 259         }
 260
 261 end:
 262         return ret;
 263 }