X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=plugins%2Fctf%2Fcommon%2Fmetadata%2Fvisitor-semantic-validator.c;h=0149d615177c1d449285a40709489c07938d16bc;hb=68b66a256a54d32992dfefeaad11eea88b7df234;hp=d94a3bdf4c5947684d638afed3e0d237b942a6a3;hpb=3d9990ac8bcbb870300869ed217b80151b52bf4e;p=babeltrace.git diff --git a/plugins/ctf/common/metadata/visitor-semantic-validator.c b/plugins/ctf/common/metadata/visitor-semantic-validator.c index d94a3bdf..0149d615 100644 --- a/plugins/ctf/common/metadata/visitor-semantic-validator.c +++ b/plugins/ctf/common/metadata/visitor-semantic-validator.c @@ -24,16 +24,18 @@ * SOFTWARE. */ +#define BT_LOG_TAG "PLUGIN-CTF-METADATA-SEMANTIC-VALIDATOR-VISITOR" +#include "logging.h" + #include #include #include #include -#include +#include #include #include #include -#include -#include +#include #include "scanner.h" #include "parser.h" #include "ast.h" @@ -41,13 +43,11 @@ #define _bt_list_first_entry(ptr, type, member) \ bt_list_entry((ptr)->next, type, member) -#define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args) - static -int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node); +int _ctf_visitor_semantic_check(int depth, struct ctf_node *node); static -int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node) +int ctf_visitor_unary_expression(int depth, struct ctf_node *node) { struct ctf_node *iter; int is_ctf_exp = 0, is_ctf_exp_left = 0; @@ -64,8 +64,8 @@ int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node) * We are only allowed to be a string. */ if (node->u.unary_expression.type != UNARY_STRING) { - fprintf(fd, "[error]: semantic error (left child of a ctf expression is only allowed to be a string)\n"); - + _BT_LOGE_LINENO(node->lineno, + "Left child of a CTF expression is only allowed to be a string."); goto errperm; } break; @@ -82,7 +82,8 @@ int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node) case UNARY_STRING: break; default: - fprintf(fd, "[error]: semantic error (children of type declarator and enum can only be unsigned numeric constants or references to fields (a.b.c))\n"); + _BT_LOGE_LINENO(node->lineno, + "Children of field class declarator and `enum` can only be unsigned numeric constants or references to fields (e.g., `a.b.c`)."); goto errperm; } break; /* OK */ @@ -95,7 +96,8 @@ int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node) case UNARY_UNSIGNED_CONSTANT: break; default: - fprintf(fd, "[error]: semantic error (structure alignment attribute can only be unsigned numeric constants)\n"); + _BT_LOGE_LINENO(node->lineno, + "Structure alignment attribute can only be an unsigned numeric constant."); goto errperm; } break; @@ -109,7 +111,8 @@ int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node) * We disallow nested unary expressions and "sbrac" unary * expressions. */ - fprintf(fd, "[error]: semantic error (nested unary expressions not allowed ( () and [] ))\n"); + _BT_LOGE_LINENO(node->lineno, + "Nested unary expressions not allowed (`()` and `[]`)."); goto errperm; case NODE_ROOT: @@ -143,7 +146,8 @@ int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node) &node->parent->u.ctf_expression.right, struct ctf_node, siblings) != node) { - fprintf(fd, "[error]: semantic error (empty link not allowed except on first node of unary expression (need to separate nodes with \".\" or \"->\")\n"); + _BT_LOGE_LINENO(node->lineno, + "Empty link is not allowed except on first node of unary expression (need to separate nodes with `.` or `->`)."); goto errperm; } break; /* OK */ @@ -151,7 +155,8 @@ int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node) case UNARY_ARROWLINK: /* We only allow -> and . links between children of ctf_expression. */ if (node->parent->type != NODE_CTF_EXPRESSION) { - fprintf(fd, "[error]: semantic error (links \".\" and \"->\" are only allowed as children of ctf expression)\n"); + _BT_LOGE_LINENO(node->lineno, + "Links `.` and `->` are only allowed as children of CTF expression."); goto errperm; } /* @@ -159,7 +164,8 @@ int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node) * This includes "", '' and non-quoted identifiers. */ if (node->u.unary_expression.type != UNARY_STRING) { - fprintf(fd, "[error]: semantic error (links \".\" and \"->\" are only allowed to separate strings and identifiers)\n"); + _BT_LOGE_LINENO(node->lineno, + "Links `.` and `->` are only allowed to separate strings and identifiers."); goto errperm; } /* We don't allow link on the first node of the list */ @@ -168,44 +174,50 @@ int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node) &node->parent->u.ctf_expression.right, struct ctf_node, siblings) == node) { - fprintf(fd, "[error]: semantic error (links \".\" and \"->\" are not allowed before first node of the unary expression list)\n"); + _BT_LOGE_LINENO(node->lineno, + "Links `.` and `->` are not allowed before first node of the unary expression list."); goto errperm; } break; case UNARY_DOTDOTDOT: /* We only allow ... link between children of enumerator. */ if (node->parent->type != NODE_ENUMERATOR) { - fprintf(fd, "[error]: semantic error (link \"...\" is only allowed within enumerator)\n"); + _BT_LOGE_LINENO(node->lineno, + "Link `...` is only allowed within enumerator."); goto errperm; } /* We don't allow link on the first node of the list */ if (_bt_list_first_entry(&node->parent->u.enumerator.values, struct ctf_node, siblings) == node) { - fprintf(fd, "[error]: semantic error (link \"...\" is not allowed on the first node of the unary expression list)\n"); + _BT_LOGE_LINENO(node->lineno, + "Link `...` is not allowed on the first node of the unary expression list."); goto errperm; } break; default: - fprintf(fd, "[error] %s: unknown expression link type %d\n", __func__, - (int) node->u.unary_expression.link); + _BT_LOGE_LINENO(node->lineno, + "Unknown expression link type: type=%d", + node->u.unary_expression.link); return -EINVAL; } return 0; errinval: - fprintf(fd, "[error] %s: incoherent parent type %s for node type %s\n", __func__, - node_type(node->parent), node_type(node)); + _BT_LOGE_LINENO(node->lineno, + "Incoherent parent node's type: node-type=%s, parent-node-type=%s", + node_type(node), node_type(node->parent)); return -EINVAL; /* Incoherent structure */ errperm: - fprintf(fd, "[error] %s: semantic error (parent type %s for node type %s)\n", __func__, - node_type(node->parent), node_type(node)); + _BT_LOGE_LINENO(node->lineno, + "Semantic error: node-type=%s, parent-node-type=%s", + node_type(node), node_type(node->parent)); return -EPERM; /* Structure not allowed */ } static -int ctf_visitor_type_specifier_list(FILE *fd, int depth, struct ctf_node *node) +int ctf_visitor_field_class_specifier_list(int depth, struct ctf_node *node) { switch (node->parent->type) { case NODE_CTF_EXPRESSION: @@ -240,13 +252,14 @@ int ctf_visitor_type_specifier_list(FILE *fd, int depth, struct ctf_node *node) } return 0; errinval: - fprintf(fd, "[error] %s: incoherent parent type %s for node type %s\n", __func__, - node_type(node->parent), node_type(node)); + _BT_LOGE_LINENO(node->lineno, + "Incoherent parent node's type: node-type=%s, parent-node-type=%s", + node_type(node), node_type(node->parent)); return -EINVAL; /* Incoherent structure */ } static -int ctf_visitor_type_specifier(FILE *fd, int depth, struct ctf_node *node) +int ctf_visitor_field_class_specifier(int depth, struct ctf_node *node) { switch (node->parent->type) { case NODE_TYPE_SPECIFIER_LIST: @@ -281,13 +294,14 @@ int ctf_visitor_type_specifier(FILE *fd, int depth, struct ctf_node *node) } return 0; errinval: - fprintf(fd, "[error] %s: incoherent parent type %s for node type %s\n", __func__, - node_type(node->parent), node_type(node)); + _BT_LOGE_LINENO(node->lineno, + "Incoherent parent node's type: node-type=%s, parent-node-type=%s", + node_type(node), node_type(node->parent)); return -EINVAL; /* Incoherent structure */ } static -int ctf_visitor_type_declarator(FILE *fd, int depth, struct ctf_node *node) +int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node) { int ret = 0; struct ctf_node *iter; @@ -297,9 +311,10 @@ int ctf_visitor_type_declarator(FILE *fd, int depth, struct ctf_node *node) switch (node->parent->type) { case NODE_TYPE_DECLARATOR: /* - * A nested type declarator is not allowed to contain pointers. + * A nested field class declarator is not allowed to + * contain pointers. */ - if (!bt_list_empty(&node->u.type_declarator.pointers)) + if (!bt_list_empty(&node->u.field_class_declarator.pointers)) goto errperm; break; /* OK */ case NODE_TYPEALIAS_TARGET: @@ -312,30 +327,30 @@ int ctf_visitor_type_declarator(FILE *fd, int depth, struct ctf_node *node) * NOT accepting alias names containing [] (would otherwise * cause semantic clash for later declarations of * arrays/sequences of elements, where elements could be - * arrays/sequences themselves (if allowed in typealias). + * arrays/sequences themselves (if allowed in field class alias). * NOT accepting alias with identifier. The declarator should * be either empty or contain pointer(s). */ - if (node->u.type_declarator.type == TYPEDEC_NESTED) + if (node->u.field_class_declarator.type == TYPEDEC_NESTED) goto errperm; - bt_list_for_each_entry(iter, &node->parent->u.typealias_alias.type_specifier_list->u.type_specifier_list.head, + bt_list_for_each_entry(iter, &node->parent->u.field_class_alias_name.field_class_specifier_list->u.field_class_specifier_list.head, siblings) { - switch (iter->u.type_specifier.type) { + switch (iter->u.field_class_specifier.type) { case TYPESPEC_FLOATING_POINT: case TYPESPEC_INTEGER: case TYPESPEC_STRING: case TYPESPEC_STRUCT: case TYPESPEC_VARIANT: case TYPESPEC_ENUM: - if (bt_list_empty(&node->u.type_declarator.pointers)) + if (bt_list_empty(&node->u.field_class_declarator.pointers)) goto errperm; break; default: break; } } - if (node->u.type_declarator.type == TYPEDEC_ID && - node->u.type_declarator.u.id != NULL) + if (node->u.field_class_declarator.type == TYPEDEC_ID && + node->u.field_class_declarator.u.id != NULL) goto errperm; break; /* OK */ case NODE_TYPEDEF: @@ -365,44 +380,47 @@ int ctf_visitor_type_declarator(FILE *fd, int depth, struct ctf_node *node) goto errinval; } - bt_list_for_each_entry(iter, &node->u.type_declarator.pointers, + bt_list_for_each_entry(iter, &node->u.field_class_declarator.pointers, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } - switch (node->u.type_declarator.type) { + switch (node->u.field_class_declarator.type) { case TYPEDEC_ID: break; case TYPEDEC_NESTED: { - if (node->u.type_declarator.u.nested.type_declarator) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, - node->u.type_declarator.u.nested.type_declarator); + if (node->u.field_class_declarator.u.nested.field_class_declarator) { + ret = _ctf_visitor_semantic_check(depth + 1, + node->u.field_class_declarator.u.nested.field_class_declarator); if (ret) return ret; } - if (!node->u.type_declarator.u.nested.abstract_array) { - bt_list_for_each_entry(iter, &node->u.type_declarator.u.nested.length, + if (!node->u.field_class_declarator.u.nested.abstract_array) { + bt_list_for_each_entry(iter, &node->u.field_class_declarator.u.nested.length, siblings) { if (iter->type != NODE_UNARY_EXPRESSION) { - fprintf(fd, "[error] %s: expecting unary expression as length\n", __func__); + _BT_LOGE_LINENO(node->lineno, + "Expecting unary expression as length: node-type=%s", + node_type(iter)); return -EINVAL; } - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } } else { if (node->parent->type == NODE_TYPEALIAS_TARGET) { - fprintf(fd, "[error] %s: abstract array declarator not permitted as target of typealias\n", __func__); + _BT_LOGE_LINENO(node->lineno, + "Abstract array declarator not permitted as target of field class alias."); return -EINVAL; } } - if (node->u.type_declarator.bitfield_len) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, - node->u.type_declarator.bitfield_len); + if (node->u.field_class_declarator.bitfield_len) { + ret = _ctf_visitor_semantic_check(depth + 1, + node->u.field_class_declarator.bitfield_len); if (ret) return ret; } @@ -410,26 +428,29 @@ int ctf_visitor_type_declarator(FILE *fd, int depth, struct ctf_node *node) } case TYPEDEC_UNKNOWN: default: - fprintf(fd, "[error] %s: unknown type declarator %d\n", __func__, - (int) node->u.type_declarator.type); + _BT_LOGE_LINENO(node->lineno, + "Unknown field class declarator: type=%d", + node->u.field_class_declarator.type); return -EINVAL; } depth--; return 0; errinval: - fprintf(fd, "[error] %s: incoherent parent type %s for node type %s\n", __func__, - node_type(node->parent), node_type(node)); + _BT_LOGE_LINENO(node->lineno, + "Incoherent parent node's type: node-type=%s, parent-node-type=%s", + node_type(node), node_type(node->parent)); return -EINVAL; /* Incoherent structure */ errperm: - fprintf(fd, "[error] %s: semantic error (parent type %s for node type %s)\n", __func__, - node_type(node->parent), node_type(node)); + _BT_LOGE_LINENO(node->lineno, + "Semantic error: node-type=%s, parent-node-type=%s", + node_type(node), node_type(node->parent)); return -EPERM; /* Structure not allowed */ } static -int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) +int _ctf_visitor_semantic_check(int depth, struct ctf_node *node) { int ret = 0; struct ctf_node *iter; @@ -440,22 +461,22 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) switch (node->type) { case NODE_ROOT: bt_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } bt_list_for_each_entry(iter, &node->u.root.trace, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } bt_list_for_each_entry(iter, &node->u.root.stream, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } bt_list_for_each_entry(iter, &node->u.root.event, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -470,7 +491,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -484,7 +505,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -498,7 +519,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -512,7 +533,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -526,7 +547,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -540,7 +561,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -581,19 +602,19 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) depth++; bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } depth--; break; case NODE_UNARY_EXPRESSION: - return ctf_visitor_unary_expression(fd, depth, node); + return ctf_visitor_unary_expression(depth, node); case NODE_TYPEDEF: switch (node->parent->type) { @@ -629,12 +650,12 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } depth++; - ret = _ctf_visitor_semantic_check(fd, depth + 1, - node->u._typedef.type_specifier_list); + ret = _ctf_visitor_semantic_check(depth + 1, + node->u.field_class_def.field_class_specifier_list); if (ret) return ret; - bt_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + bt_list_for_each_entry(iter, &node->u.field_class_def.field_class_declarators, siblings) { + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -652,20 +673,21 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } depth++; - ret = _ctf_visitor_semantic_check(fd, depth + 1, - node->u.typealias_target.type_specifier_list); + ret = _ctf_visitor_semantic_check(depth + 1, + node->u.field_class_alias_target.field_class_specifier_list); if (ret) return ret; nr_declarators = 0; - bt_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + bt_list_for_each_entry(iter, &node->u.field_class_alias_target.field_class_declarators, siblings) { + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; nr_declarators++; } if (nr_declarators > 1) { - fprintf(fd, "[error] %s: Too many declarators in typealias alias (%d, max is 1)\n", __func__, nr_declarators); - + _BT_LOGE_LINENO(node->lineno, + "Too many declarators in field class alias's name (maximum is 1): count=%d", + nr_declarators); return -EINVAL; } depth--; @@ -683,20 +705,21 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } depth++; - ret = _ctf_visitor_semantic_check(fd, depth + 1, - node->u.typealias_alias.type_specifier_list); + ret = _ctf_visitor_semantic_check(depth + 1, + node->u.field_class_alias_name.field_class_specifier_list); if (ret) return ret; nr_declarators = 0; - bt_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + bt_list_for_each_entry(iter, &node->u.field_class_alias_name.field_class_declarators, siblings) { + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; nr_declarators++; } if (nr_declarators > 1) { - fprintf(fd, "[error] %s: Too many declarators in typealias alias (%d, max is 1)\n", __func__, nr_declarators); - + _BT_LOGE_LINENO(node->lineno, + "Too many declarators in field class alias's name (maximum is 1): count=%d", + nr_declarators); return -EINVAL; } depth--; @@ -735,21 +758,21 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) goto errinval; } - ret = _ctf_visitor_semantic_check(fd, depth + 1, node->u.typealias.target); + ret = _ctf_visitor_semantic_check(depth + 1, node->u.field_class_alias.target); if (ret) return ret; - ret = _ctf_visitor_semantic_check(fd, depth + 1, node->u.typealias.alias); + ret = _ctf_visitor_semantic_check(depth + 1, node->u.field_class_alias.alias); if (ret) return ret; break; case NODE_TYPE_SPECIFIER_LIST: - ret = ctf_visitor_type_specifier_list(fd, depth, node); + ret = ctf_visitor_field_class_specifier_list(depth, node); if (ret) return ret; break; case NODE_TYPE_SPECIFIER: - ret = ctf_visitor_type_specifier(fd, depth, node); + ret = ctf_visitor_field_class_specifier(depth, node); if (ret) return ret; break; @@ -762,7 +785,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } break; case NODE_TYPE_DECLARATOR: - ret = ctf_visitor_type_declarator(fd, depth, node); + ret = ctf_visitor_field_class_declarator(depth, node); if (ret) return ret; break; @@ -778,7 +801,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) goto errperm; } bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -793,7 +816,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -810,7 +833,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -837,7 +860,8 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) || (iter->u.unary_expression.type != UNARY_SIGNED_CONSTANT && iter->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) || iter->u.unary_expression.link != UNARY_LINK_UNKNOWN) { - fprintf(fd, "[error]: semantic error (first unary expression of enumerator is unexpected)\n"); + _BT_LOGE_LINENO(iter->lineno, + "First unary expression of enumerator is unexpected."); goto errperm; } break; @@ -845,7 +869,8 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) || (iter->u.unary_expression.type != UNARY_SIGNED_CONSTANT && iter->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) || iter->u.unary_expression.link != UNARY_DOTDOTDOT) { - fprintf(fd, "[error]: semantic error (second unary expression of enumerator is unexpected)\n"); + _BT_LOGE_LINENO(iter->lineno, + "Second unary expression of enumerator is unexpected."); goto errperm; } break; @@ -856,7 +881,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -873,12 +898,12 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) } depth++; - ret = _ctf_visitor_semantic_check(fd, depth + 1, node->u._enum.container_type); + ret = _ctf_visitor_semantic_check(depth + 1, node->u._enum.container_field_class); if (ret) return ret; bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -892,12 +917,12 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) default: goto errinval; } - ret = _ctf_visitor_semantic_check(fd, depth + 1, - node->u.struct_or_variant_declaration.type_specifier_list); + ret = _ctf_visitor_semantic_check(depth + 1, + node->u.struct_or_variant_declaration.field_class_specifier_list); if (ret) return ret; - bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.field_class_declarators, siblings) { + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -913,7 +938,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) goto errperm; } bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -930,7 +955,7 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) goto errperm; } bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) { - ret = _ctf_visitor_semantic_check(fd, depth + 1, iter); + ret = _ctf_visitor_semantic_check(depth + 1, iter); if (ret) return ret; } @@ -938,24 +963,26 @@ int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) case NODE_UNKNOWN: default: - fprintf(fd, "[error] %s: unknown node type %d\n", __func__, - (int) node->type); + _BT_LOGE_LINENO(node->lineno, + "Unknown node type: type=%d", node->type); return -EINVAL; } return ret; errinval: - fprintf(fd, "[error] %s: incoherent parent type %s for node type %s\n", __func__, - node_type(node->parent), node_type(node)); + _BT_LOGE_LINENO(node->lineno, + "Incoherent parent node's type: node-type=%s, parent-node-type=%s", + node_type(node), node_type(node->parent)); return -EINVAL; /* Incoherent structure */ errperm: - fprintf(fd, "[error] %s: semantic error (parent type %s for node type %s)\n", __func__, - node_type(node->parent), node_type(node)); + _BT_LOGE_LINENO(node->lineno, + "Semantic error: node-type=%s, parent-node-type=%s", + node_type(node), node_type(node->parent)); return -EPERM; /* Structure not allowed */ } -int ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) +int ctf_visitor_semantic_check(int depth, struct ctf_node *node) { int ret = 0; @@ -964,15 +991,22 @@ int ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node) * take the safe route and recreate them at each validation, just in * case the structure has changed. */ - printf_verbose("CTF visitor: parent links creation... "); - ret = ctf_visitor_parent_links(fd, depth, node); - if (ret) - return ret; - printf_verbose("done.\n"); - printf_verbose("CTF visitor: semantic check... "); - ret = _ctf_visitor_semantic_check(fd, depth, node); - if (ret) - return ret; - printf_verbose("done.\n"); + ret = ctf_visitor_parent_links(depth, node); + if (ret) { + _BT_LOGE_LINENO(node->lineno, + "Cannot create parent links in metadata's AST: " + "ret=%d", ret); + goto end; + } + + ret = _ctf_visitor_semantic_check(depth, node); + if (ret) { + _BT_LOGE_LINENO(node->lineno, + "Cannot check metadata's AST semantics: " + "ret=%d", ret); + goto end; + } + +end: return ret; }