X-Git-Url: https://git.tokkee.org/?p=sysdb.git;a=blobdiff_plain;f=src%2Fparser%2Fanalyzer.c;h=dea83d7e0c828d8966fbffe9e91a2895c466fdf7;hp=244966b9a651b4ad9c72a67fbedb5375d2ea7352;hb=1ef0d00327e4b5f56b438f44053f48fd8b198baa;hpb=1ea57919cda96d83e7625999019269dffefdb329

diff --git a/src/parser/analyzer.c b/src/parser/analyzer.c
index 244966b..dea83d7 100644
--- a/src/parser/analyzer.c
+++ b/src/parser/analyzer.c
@@ -33,22 +33,374 @@
 #include "utils/strbuf.h"
 
 #include <assert.h>
+#include <stdarg.h>
 
 #define VALID_OBJ_TYPE(t) ((SDB_HOST <= (t)) && ((t) <= SDB_METRIC))
 
+#define FILTER_CONTEXT -1
+#define UNSPEC_CONTEXT -2
+
+static int
+analyze_node(int context, sdb_ast_node_t *node, sdb_strbuf_t *errbuf);
+
 /*
- * private helper functions
+ * error reporting
  */
 
+static void
+op_error(sdb_strbuf_t *errbuf, sdb_ast_op_t *op, const char *reason)
+{
+	sdb_strbuf_sprintf(errbuf, "Invalid operation %s %s %s (%s)",
+			SDB_TYPE_TO_STRING(op->left->data_type),
+			SDB_AST_OP_TO_STRING(op->kind),
+			SDB_TYPE_TO_STRING(op->right->data_type),
+			reason);
+} /* op_error */
+
+static void
+__attribute__((format(printf, 3, 4)))
+iter_error(sdb_strbuf_t *errbuf, sdb_ast_iter_t *iter, const char *reason, ...)
+{
+	char r[1024];
+	va_list ap;
+
+	va_start(ap, reason);
+	vsnprintf(r, sizeof(r), reason, ap);
+	va_end(ap);
+
+	assert((iter->expr->type == SDB_AST_TYPE_OPERATOR)
+			&& (! SDB_AST_OP(iter->expr)->left));
+	sdb_strbuf_sprintf(errbuf, "Invalid iterator %s %s %s %s (%s)",
+			SDB_AST_OP_TO_STRING(iter->kind),
+			SDB_TYPE_TO_STRING(iter->iter->data_type),
+			SDB_AST_OP_TO_STRING(SDB_AST_OP(iter->expr)->kind),
+			SDB_TYPE_TO_STRING(SDB_AST_OP(iter->expr)->right->data_type),
+			r);
+} /* iter_error */
+
+/*
+ * expression nodes
+ */
+
+static int
+analyze_logical(int context, sdb_ast_op_t *op, sdb_strbuf_t *errbuf)
+{
+	switch (op->kind) {
+	case SDB_AST_OR:
+	case SDB_AST_AND:
+		if (! SDB_AST_IS_LOGICAL(op->left)) {
+			sdb_strbuf_sprintf(errbuf, "Invalid left operand (%s) "
+					"in %s expression", SDB_AST_TYPE_TO_STRING(op->left),
+					SDB_AST_OP_TO_STRING(op->kind));
+			return -1;
+		}
+		if (analyze_node(context, op->left, errbuf))
+			return -1;
+		/* fallthrough */
+	case SDB_AST_NOT:
+		if (! SDB_AST_IS_LOGICAL(op->right)) {
+			sdb_strbuf_sprintf(errbuf, "Invalid right operand (%s) "
+					"in %s expression", SDB_AST_TYPE_TO_STRING(op->right),
+					SDB_AST_OP_TO_STRING(op->kind));
+			return -1;
+		}
+		if (analyze_node(context, op->right, errbuf))
+			return -1;
+		break;
+
+	case SDB_AST_LT:
+	case SDB_AST_LE:
+	case SDB_AST_EQ:
+	case SDB_AST_NE:
+	case SDB_AST_GE:
+	case SDB_AST_GT:
+	{
+		if (analyze_node(context, op->left, errbuf))
+			return -1;
+		if (analyze_node(context, op->right, errbuf))
+			return -1;
+
+		if ((op->left->data_type > 0) && (op->right->data_type > 0)) {
+			if (op->left->data_type == op->right->data_type)
+				return 0;
+			op_error(errbuf, op, "type mismatch");
+			return -1;
+		}
+		if ((op->left->data_type > 0) && (op->left->data_type & SDB_TYPE_ARRAY)) {
+			op_error(errbuf, op, "array not allowed");
+			return -1;
+		}
+		if ((op->right->data_type > 0) && (op->right->data_type & SDB_TYPE_ARRAY)) {
+			op_error(errbuf, op, "array not allowed");
+			return -1;
+		}
+		break;
+	}
+
+	case SDB_AST_REGEX:
+	case SDB_AST_NREGEX:
+		if (analyze_node(context, op->left, errbuf))
+			return -1;
+		if (analyze_node(context, op->right, errbuf))
+			return -1;
+
+		/* all types are supported for the left operand
+		 * TODO: introduce a cast operator if it's not a string */
+		if ((op->right->data_type > 0)
+				&& (op->right->data_type != SDB_TYPE_REGEX)
+				&& (op->right->data_type != SDB_TYPE_STRING)) {
+			op_error(errbuf, op, "invalid regex");
+			return -1;
+		}
+		break;
+
+	case SDB_AST_ISNULL:
+	case SDB_AST_ISTRUE:
+	case SDB_AST_ISFALSE:
+		if (analyze_node(context, op->right, errbuf))
+			return -1;
+		break;
+
+	case SDB_AST_IN:
+		if (analyze_node(context, op->left, errbuf))
+			return -1;
+		if (analyze_node(context, op->right, errbuf))
+			return -1;
+
+		if ((op->right->data_type > 0) && (! (op->right->data_type & SDB_TYPE_ARRAY))) {
+			op_error(errbuf, op, "array expected");
+			return -1;
+		}
+		/* the left operand may be a scalar or an array but the element
+		 * type has to match */
+		if ((op->left->data_type > 0) && (op->right->data_type > 0)
+				&& ((op->left->data_type & 0xff) != (op->right->data_type & 0xff))) {
+			op_error(errbuf, op, "type mismatch");
+			return -1;
+		}
+		break;
+
+	default:
+		sdb_strbuf_sprintf(errbuf, "Unknown operand type %d", op->kind);
+		return -1;
+	}
+	return 0;
+} /* analyze_logical */
+
+static int
+analyze_arith(int context, sdb_ast_op_t *op, sdb_strbuf_t *errbuf)
+{
+	if (analyze_node(context, op->left, errbuf))
+		return -1;
+	if (analyze_node(context, op->right, errbuf))
+		return -1;
+	SDB_AST_NODE(op)->data_type = sdb_data_expr_type(SDB_AST_OP_TO_DATA_OP(op->kind),
+			op->left->data_type, op->right->data_type);
+
+	if ((op->left->data_type > 0) && (op->right->data_type > 0)
+			&& (SDB_AST_NODE(op)->data_type <= 0)) {
+		op_error(errbuf, op, "type mismatch");
+		return -1;
+	}
+
+	/* TODO: replace constant arithmetic operations with a constant value */
+	return 0;
+} /* analyze_arith */
+
+static int
+analyze_iter(int context, sdb_ast_iter_t *iter, sdb_strbuf_t *errbuf)
+{
+	sdb_ast_const_t c = SDB_AST_CONST_INIT;
+	int iter_context = context;
+	int status;
+
+	if (iter->iter->type == SDB_AST_TYPE_TYPED)
+		iter_context = SDB_AST_TYPED(iter->iter)->type;
+
+	if (analyze_node(iter_context, iter->iter, errbuf))
+		return -1;
+	/* TODO: support other setups as well */
+	assert((iter->expr->type == SDB_AST_TYPE_OPERATOR)
+			&& (! SDB_AST_OP(iter->expr)->left));
+	/* determine the data-type for better error messages */
+	analyze_node(iter_context, SDB_AST_OP(iter->expr)->right, NULL);
+
+	if (iter->iter->type == SDB_AST_TYPE_TYPED) {
+		int iter_type = SDB_AST_TYPED(iter->iter)->type;
+
+		c.value.type = iter->iter->data_type;
+
+		if (iter_type == SDB_ATTRIBUTE) {
+			/* attributes are always iterable */
+		}
+		else if ((context != SDB_HOST) && (context != SDB_SERVICE)
+				&& (context != SDB_METRIC) && (context != UNSPEC_CONTEXT)) {
+			iter_error(errbuf, iter, "%s not iterable in %s context",
+					SDB_STORE_TYPE_TO_NAME(iter_type),
+					SDB_STORE_TYPE_TO_NAME(context));
+			return -1;
+		}
+
+		if ((context == iter_type)
+				|| ((iter_type != SDB_SERVICE)
+					&& (iter_type != SDB_METRIC)
+					&& (iter_type != SDB_ATTRIBUTE))
+				|| ((context == SDB_SERVICE)
+					&& (iter_type == SDB_METRIC))
+				|| ((context == SDB_METRIC)
+					&& (iter_type == SDB_SERVICE))) {
+			iter_error(errbuf, iter, "%s not iterable in %s context",
+					SDB_STORE_TYPE_TO_NAME(iter_type),
+					SDB_STORE_TYPE_TO_NAME(context));
+			return -1;
+		}
+	}
+	else if (iter->iter->type == SDB_AST_TYPE_VALUE) {
+		int iter_type = SDB_AST_VALUE(iter->iter)->type;
+
+		c.value.type = iter->iter->data_type & 0xff;
+
+		if (iter_type != SDB_FIELD_BACKEND) {
+			iter_error(errbuf, iter, "%s not iterable in %s context",
+					(iter_type == SDB_ATTRIBUTE)
+						? "attribute"
+						: SDB_FIELD_TO_NAME(iter_type),
+					SDB_STORE_TYPE_TO_NAME(context));
+			return -1;
+		}
+	}
+	else if (iter->iter->type == SDB_AST_TYPE_CONST) {
+		c.value.type = iter->iter->data_type & 0xff;
+
+		if (! (SDB_AST_CONST(iter->iter)->value.type & SDB_TYPE_ARRAY)) {
+			iter_error(errbuf, iter, "%s not iterable",
+					SDB_TYPE_TO_STRING(SDB_AST_CONST(iter->iter)->value.type));
+			return -1;
+		}
+	}
+	else {
+		/* TODO: if we know the data-type of iter->iter and it's an array,
+		 * we should support an iterator for it as well */
+		iter_error(errbuf, iter, "%s expression not iterable",
+				SDB_AST_TYPE_TO_STRING(iter->iter));
+		return -1;
+	}
+
+	SDB_AST_OP(iter->expr)->left = SDB_AST_NODE(&c);
+	status = analyze_node(context, iter->expr, errbuf);
+	SDB_AST_OP(iter->expr)->left = NULL;
+	if (status)
+		return -1;
+	return 0;
+} /* analyze_iter */
+
+static int
+analyze_const(int __attribute__((unused)) context, sdb_ast_const_t *c,
+		sdb_strbuf_t __attribute__((unused)) *errbuf)
+{
+	SDB_AST_NODE(c)->data_type = c->value.type;
+	return 0;
+} /* analyze_const */
+
+static int
+analyze_value(int context, sdb_ast_value_t *v, sdb_strbuf_t *errbuf)
+{
+	if (v->type != SDB_ATTRIBUTE)
+		SDB_AST_NODE(v)->data_type = SDB_FIELD_TYPE(v->type);
+
+	if ((v->type != SDB_ATTRIBUTE) && v->name) {
+		sdb_strbuf_sprintf(errbuf, "Invalid expression %s[%s]",
+				SDB_FIELD_TO_NAME(v->type), v->name);
+		return -1;
+	}
+	else if ((v->type == SDB_ATTRIBUTE) && (! v->name)) {
+		sdb_strbuf_sprintf(errbuf, "Invalid expression attribute[] "
+				"(missing name)");
+		return -1;
+	}
+
+	if (context != UNSPEC_CONTEXT) {
+		/* skip these checks if we don't know the context; it's up to the
+		 * caller to check again once the right context information is
+		 * available */
+		if ((context != SDB_ATTRIBUTE) && (v->type == SDB_FIELD_VALUE)) {
+			sdb_strbuf_sprintf(errbuf, "Invalid expression %s.value",
+					SDB_FIELD_TO_NAME(context));
+			return -1;
+		}
+		if ((context != SDB_METRIC) && (v->type == SDB_FIELD_TIMESERIES)) {
+			sdb_strbuf_sprintf(errbuf, "Invalid expression %s.timeseries",
+					SDB_FIELD_TO_NAME(context));
+			return -1;
+		}
+	}
+	return 0;
+} /* analyze_value */
+
+static int
+analyze_typed(int context, sdb_ast_typed_t *t, sdb_strbuf_t *errbuf)
+{
+	if ((t->expr->type != SDB_AST_TYPE_VALUE)
+			&& (t->expr->type != SDB_AST_TYPE_TYPED)) {
+		sdb_strbuf_sprintf(errbuf, "Invalid expression %s.%s",
+				SDB_STORE_TYPE_TO_NAME(t->type),
+				SDB_AST_TYPE_TO_STRING(t->expr));
+		return -1;
+	}
+	if (analyze_node(t->type, t->expr, errbuf))
+		return -1;
+	SDB_AST_NODE(t)->data_type = t->expr->data_type;
+
+	if ((t->type != SDB_ATTRIBUTE) && (! VALID_OBJ_TYPE(t->type))) {
+		sdb_strbuf_sprintf(errbuf, "Invalid expression %#x.%s",
+				t->type, SDB_AST_TYPE_TO_STRING(t->expr));
+		return -1;
+	}
+
+	/* self-references are allowed and services and metrics may reference
+	 * their parent host; everything may reference attributes */
+	if ((context != t->type) && (context > 0)
+			&& (((context != SDB_SERVICE) && (context != SDB_METRIC))
+				|| (t->type != SDB_HOST))
+			&& (t->type != SDB_ATTRIBUTE)) {
+		sdb_strbuf_sprintf(errbuf, "Invalid expression %s.%s in %s context",
+				SDB_STORE_TYPE_TO_NAME(t->type),
+				SDB_AST_TYPE_TO_STRING(t->expr),
+				context == -1 ? "generic" : SDB_STORE_TYPE_TO_NAME(context));
+		return -1;
+	}
+	return 0;
+} /* analyze_typed */
+
 static int
 analyze_node(int context, sdb_ast_node_t *node, sdb_strbuf_t *errbuf)
 {
-	(void)context;
 	if (! node) {
 		sdb_strbuf_sprintf(errbuf, "Empty AST node");
 		return -1;
 	}
-	return 0;
+
+	/* unknown by default */
+	node->data_type = -1;
+
+	if ((node->type == SDB_AST_TYPE_OPERATOR)
+			&& (SDB_AST_IS_LOGICAL(node)))
+		return analyze_logical(context, SDB_AST_OP(node), errbuf);
+	else if ((node->type == SDB_AST_TYPE_OPERATOR)
+			&& (SDB_AST_IS_ARITHMETIC(node)))
+		return analyze_arith(context, SDB_AST_OP(node), errbuf);
+	else if (node->type == SDB_AST_TYPE_ITERATOR)
+		return analyze_iter(context, SDB_AST_ITER(node), errbuf);
+	else if (node->type == SDB_AST_TYPE_CONST)
+		return analyze_const(context, SDB_AST_CONST(node), errbuf);
+	else if (node->type == SDB_AST_TYPE_VALUE)
+		return analyze_value(context, SDB_AST_VALUE(node), errbuf);
+	else if (node->type == SDB_AST_TYPE_TYPED)
+		return analyze_typed(context, SDB_AST_TYPED(node), errbuf);
+
+	sdb_strbuf_sprintf(errbuf, "Invalid expression node "
+			"of type %#x", node->type);
+	return -1;
 } /* analyze_node */
 
 /*
@@ -82,9 +434,9 @@ analyze_fetch(sdb_ast_fetch_t *fetch, sdb_strbuf_t *errbuf)
 	}
 
 	if (fetch->filter)
-		return analyze_node(-1, fetch->filter, errbuf);
+		return analyze_node(FILTER_CONTEXT, fetch->filter, errbuf);
 	return 0;
-}
+} /* analyze_fetch */
 
 static int
 analyze_list(sdb_ast_list_t *list, sdb_strbuf_t *errbuf)
@@ -95,9 +447,9 @@ analyze_list(sdb_ast_list_t *list, sdb_strbuf_t *errbuf)
 		return -1;
 	}
 	if (list->filter)
-		return analyze_node(-1, list->filter, errbuf);
+		return analyze_node(FILTER_CONTEXT, list->filter, errbuf);
 	return 0;
-}
+} /* analyze_list */
 
 static int
 analyze_lookup(sdb_ast_lookup_t *lookup, sdb_strbuf_t *errbuf)
@@ -111,9 +463,9 @@ analyze_lookup(sdb_ast_lookup_t *lookup, sdb_strbuf_t *errbuf)
 		if (analyze_node(lookup->obj_type, lookup->matcher, errbuf))
 			return -1;
 	if (lookup->filter)
-		return analyze_node(-1, lookup->filter, errbuf);
+		return analyze_node(FILTER_CONTEXT, lookup->filter, errbuf);
 	return 0;
-}
+} /* analyze_lookup */
 
 static int
 analyze_store(sdb_ast_store_t *st, sdb_strbuf_t *errbuf)
@@ -201,7 +553,7 @@ analyze_store(sdb_ast_store_t *st, sdb_strbuf_t *errbuf)
 		return -1;
 	}
 	return 0;
-}
+} /* analyze_store */
 
 static int
 analyze_timeseries(sdb_ast_timeseries_t *ts, sdb_strbuf_t *errbuf)
@@ -223,7 +575,7 @@ analyze_timeseries(sdb_ast_timeseries_t *ts, sdb_strbuf_t *errbuf)
 		return -1;
 	}
 	return 0;
-}
+} /* analyze_timeseries */
 
 /*
  * public API
@@ -237,6 +589,9 @@ sdb_parser_analyze(sdb_ast_node_t *node, sdb_strbuf_t *errbuf)
 		return -1;
 	}
 
+	/* top-level nodes don't have a type */
+	node->data_type = -1;
+
 	if (node->type == SDB_AST_TYPE_FETCH)
 		return analyze_fetch(SDB_AST_FETCH(node), errbuf);
 	else if (node->type == SDB_AST_TYPE_LIST)
@@ -251,7 +606,37 @@ sdb_parser_analyze(sdb_ast_node_t *node, sdb_strbuf_t *errbuf)
 	sdb_strbuf_sprintf(errbuf, "Invalid top-level AST node "
 			"of type %#x", node->type);
 	return -1;
-} /* sdb_fe_analyze */
+} /* sdb_parser_analyze */
+
+int
+sdb_parser_analyze_conditional(sdb_ast_node_t *node, sdb_strbuf_t *errbuf)
+{
+	if (! node) {
+		sdb_strbuf_sprintf(errbuf, "Empty conditional node");
+		return -1;
+	}
+	if (! SDB_AST_IS_LOGICAL(node)) {
+		sdb_strbuf_sprintf(errbuf, "Not a conditional node (got %s)",
+				SDB_AST_TYPE_TO_STRING(node));
+		return -1;
+	}
+	return analyze_node(UNSPEC_CONTEXT, node, errbuf);
+} /* sdb_parser_analyze_conditional */
+
+int
+sdb_parser_analyze_arith(sdb_ast_node_t *node, sdb_strbuf_t *errbuf)
+{
+	if (! node) {
+		sdb_strbuf_sprintf(errbuf, "Empty arithmetic node");
+		return -1;
+	}
+	if (! SDB_AST_IS_ARITHMETIC(node)) {
+		sdb_strbuf_sprintf(errbuf, "Not an arithmetic node (got %s)",
+				SDB_AST_TYPE_TO_STRING(node));
+		return -1;
+	}
+	return analyze_node(UNSPEC_CONTEXT, node, errbuf);
+} /* sdb_parser_analyze_arith */
 
 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */