Move to kernel style SPDX license identifiers
[babeltrace.git] / src / lib / trace-ir / resolve-field-path.c
index 8865a2a5b89586632cc9bbce314e9d13d9c5e259..25a5fb687561901dc747ff6c174fa9de712ebd59 100644 (file)
@@ -1,23 +1,7 @@
 /*
- * Copyright 2018 Philippe Proulx <pproulx@efficios.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
+ * SPDX-License-Identifier: MIT
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * Copyright 2018 Philippe Proulx <pproulx@efficios.com>
  */
 
 #define BT_LOG_TAG "LIB/RESOLVE-FIELD-PATH"
@@ -25,8 +9,9 @@
 
 #include "lib/assert-pre.h"
 #include "common/assert.h"
-#include <babeltrace2/trace-ir/field-path-const.h>
+#include <babeltrace2/trace-ir/field-path.h>
 #include <limits.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include <inttypes.h>
 #include <glib.h>
@@ -46,12 +31,24 @@ bool find_field_class_recursive(struct bt_field_class *fc,
                goto end;
        }
 
-       switch (fc->type) {
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR:
-       {
+       if (bt_field_class_type_is(fc->type, BT_FIELD_CLASS_TYPE_OPTION)) {
+               struct bt_field_class_option *opt_fc = (void *) fc;
+               struct bt_field_path_item item = {
+                       .type = BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT,
+                       .index = UINT64_C(-1),
+               };
+
+               bt_field_path_append_item(field_path, &item);
+               found = find_field_class_recursive(opt_fc->content_fc,
+                       tgt_fc, field_path);
+               if (found) {
+                       goto end;
+               }
+
+               bt_field_path_remove_last_item(field_path);
+       } else if (fc->type == BT_FIELD_CLASS_TYPE_STRUCTURE ||
+                       bt_field_class_type_is(fc->type,
+                               BT_FIELD_CLASS_TYPE_VARIANT)) {
                struct bt_field_class_named_field_class_container *container_fc =
                        (void *) fc;
                uint64_t i;
@@ -73,12 +70,7 @@ bool find_field_class_recursive(struct bt_field_class *fc,
 
                        bt_field_path_remove_last_item(field_path);
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
-       {
+       } else if (bt_field_class_type_is(fc->type, BT_FIELD_CLASS_TYPE_ARRAY)) {
                struct bt_field_class_array *array_fc = (void *) fc;
                struct bt_field_path_item item = {
                        .type = BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT,
@@ -93,10 +85,6 @@ bool find_field_class_recursive(struct bt_field_class *fc,
                }
 
                bt_field_path_remove_last_item(field_path);
-               break;
-       }
-       default:
-               break;
        }
 
 end:
@@ -226,7 +214,7 @@ struct bt_field_class *borrow_root_field_class(
        case BT_FIELD_PATH_SCOPE_EVENT_PAYLOAD:
                return ctx->event_payload;
        default:
-               abort();
+               bt_common_abort();
        }
 
        return NULL;
@@ -240,12 +228,16 @@ struct bt_field_class *borrow_child_field_class(
 {
        struct bt_field_class *child_fc = NULL;
 
-       switch (parent_fc->type) {
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR:
-       {
+       if (bt_field_class_type_is(parent_fc->type,
+                       BT_FIELD_CLASS_TYPE_OPTION)) {
+               struct bt_field_class_option *opt_fc = (void *) parent_fc;
+
+               BT_ASSERT(fp_item->type ==
+                       BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT);
+               child_fc = opt_fc->content_fc;
+       } else if (parent_fc->type == BT_FIELD_CLASS_TYPE_STRUCTURE ||
+                       bt_field_class_type_is(parent_fc->type,
+                               BT_FIELD_CLASS_TYPE_VARIANT)) {
                struct bt_field_class_named_field_class_container *container_fc =
                        (void *) parent_fc;
                struct bt_named_field_class *named_fc;
@@ -253,20 +245,13 @@ struct bt_field_class *borrow_child_field_class(
                BT_ASSERT(fp_item->type == BT_FIELD_PATH_ITEM_TYPE_INDEX);
                named_fc = container_fc->named_fcs->pdata[fp_item->index];
                child_fc = named_fc->fc;
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
-       {
+       } else if (bt_field_class_type_is(parent_fc->type,
+                       BT_FIELD_CLASS_TYPE_ARRAY)) {
                struct bt_field_class_array *array_fc = (void *) parent_fc;
 
                BT_ASSERT(fp_item->type ==
                        BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT);
                child_fc = array_fc->element_fc;
-               break;
-       }
-       default:
-               break;
        }
 
        return child_fc;
@@ -294,11 +279,12 @@ bool target_field_path_in_different_scope_has_struct_fc_only(
                        bt_field_path_borrow_item_by_index_inline(
                                tgt_field_path, i);
 
-               if (fc->type == BT_FIELD_CLASS_TYPE_STATIC_ARRAY ||
-                               fc->type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY ||
-                               fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR ||
-                               fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR ||
-                               fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR) {
+               if (bt_field_class_type_is(fc->type,
+                               BT_FIELD_CLASS_TYPE_ARRAY) ||
+                               bt_field_class_type_is(fc->type,
+                                       BT_FIELD_CLASS_TYPE_OPTION) ||
+                               bt_field_class_type_is(fc->type,
+                                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                        is_valid = false;
                        goto end;
                }
@@ -413,11 +399,12 @@ bool lca_to_target_has_struct_fc_only(struct bt_field_path *src_field_path,
                        bt_field_path_borrow_item_by_index_inline(
                                tgt_field_path, tgt_i);
 
-               if (tgt_fc->type == BT_FIELD_CLASS_TYPE_STATIC_ARRAY ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR ||
-                               tgt_fc->type == BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR) {
+               if (bt_field_class_type_is(tgt_fc->type,
+                               BT_FIELD_CLASS_TYPE_ARRAY) ||
+                               bt_field_class_type_is(tgt_fc->type,
+                                       BT_FIELD_CLASS_TYPE_OPTION) ||
+                               bt_field_class_type_is(tgt_fc->type,
+                                       BT_FIELD_CLASS_TYPE_VARIANT)) {
                        is_valid = false;
                        goto end;
                }
@@ -526,27 +513,32 @@ int bt_resolve_field_paths(struct bt_field_class *fc,
        BT_ASSERT(fc);
 
        /* Resolving part for dynamic array and variant field classes */
-       switch (fc->type) {
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
-       {
+       if (bt_field_class_type_is(fc->type,
+                       BT_FIELD_CLASS_TYPE_OPTION_WITH_SELECTOR_FIELD)) {
+               struct bt_field_class_option_with_selector_field *opt_fc = (void *) fc;
+
+               BT_ASSERT(opt_fc->selector_fc);
+               BT_ASSERT(!opt_fc->selector_field_path);
+               opt_fc->selector_field_path = resolve_field_path(
+                       fc, opt_fc->selector_fc, ctx);
+               if (!opt_fc->selector_field_path) {
+                       ret = -1;
+                       goto end;
+               }
+       } else if (fc->type == BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD) {
                struct bt_field_class_array_dynamic *dyn_array_fc = (void *) fc;
 
-               if (dyn_array_fc->length_fc) {
-                       BT_ASSERT(!dyn_array_fc->length_field_path);
-                       dyn_array_fc->length_field_path = resolve_field_path(
-                               fc, dyn_array_fc->length_fc, ctx);
-                       if (!dyn_array_fc->length_field_path) {
-                               ret = -1;
-                               goto end;
-                       }
+               BT_ASSERT(dyn_array_fc->length_fc);
+               BT_ASSERT(!dyn_array_fc->length_field_path);
+               dyn_array_fc->length_field_path = resolve_field_path(
+                       fc, dyn_array_fc->length_fc, ctx);
+               if (!dyn_array_fc->length_field_path) {
+                       ret = -1;
+                       goto end;
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR:
-       {
-               struct bt_field_class_variant_with_selector *var_fc =
+       } else if (bt_field_class_type_is(fc->type,
+                       BT_FIELD_CLASS_TYPE_VARIANT_WITH_SELECTOR_FIELD)) {
+               struct bt_field_class_variant_with_selector_field *var_fc =
                        (void *) fc;
 
                if (var_fc->selector_fc) {
@@ -560,17 +552,15 @@ int bt_resolve_field_paths(struct bt_field_class *fc,
                        }
                }
        }
-       default:
-               break;
-       }
 
        /* Recursive part */
-       switch (fc->type) {
-       case BT_FIELD_CLASS_TYPE_STRUCTURE:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR:
-       case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR:
-       {
+       if (bt_field_class_type_is(fc->type, BT_FIELD_CLASS_TYPE_OPTION)) {
+               struct bt_field_class_option *opt_fc = (void *) fc;
+
+               ret = bt_resolve_field_paths(opt_fc->content_fc, ctx);
+       } else if (fc->type == BT_FIELD_CLASS_TYPE_STRUCTURE ||
+                       bt_field_class_type_is(fc->type,
+                               BT_FIELD_CLASS_TYPE_VARIANT)) {
                struct bt_field_class_named_field_class_container *container_fc =
                        (void *) fc;
                uint64_t i;
@@ -584,19 +574,11 @@ int bt_resolve_field_paths(struct bt_field_class *fc,
                                goto end;
                        }
                }
-
-               break;
-       }
-       case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
-       case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
-       {
+       } else if (bt_field_class_type_is(fc->type,
+                       BT_FIELD_CLASS_TYPE_ARRAY)) {
                struct bt_field_class_array *array_fc = (void *) fc;
 
                ret = bt_resolve_field_paths(array_fc->element_fc, ctx);
-               break;
-       }
-       default:
-               break;
        }
 
 end:
This page took 0.027083 seconds and 4 git commands to generate.