X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Fecoli_node_int.c;h=daece0112bd17d2aee7bad2fe75775b59466d94c;hb=886aed6cb57bdcd88747c081229315acf1257473;hp=f8ba567c350c47e1571068e418e812081535cad1;hpb=1ceb5917fd1b73c42d2ad535a0a65e645d6b4dbe;p=protos%2Flibecoli.git

diff --git a/lib/ecoli_node_int.c b/lib/ecoli_node_int.c
index f8ba567..daece01 100644
--- a/lib/ecoli_node_int.c
+++ b/lib/ecoli_node_int.c
@@ -1,28 +1,5 @@
-/*
- * Copyright (c) 2016, Olivier MATZ <zer0@droids-corp.org>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the University of California, Berkeley nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright 2016, Olivier MATZ <zer0@droids-corp.org>
  */
 
 #include <stdio.h>
@@ -38,8 +15,9 @@
 #include <ecoli_malloc.h>
 #include <ecoli_strvec.h>
 #include <ecoli_node.h>
-#include <ecoli_parsed.h>
-#include <ecoli_completed.h>
+#include <ecoli_config.h>
+#include <ecoli_parse.h>
+#include <ecoli_complete.h>
 #include <ecoli_node_int.h>
 #include <ecoli_test.h>
 
@@ -66,25 +44,31 @@ static int parse_llint(struct ec_node_int_uint *node, const char *str,
 	int64_t *val)
 {
 	char *endptr;
+	int save_errno = errno;
 
 	errno = 0;
 	*val = strtoll(str, &endptr, node->base);
 
-	if (errno == ERANGE && (*val == LLONG_MAX || *val == LLONG_MIN))
+	if ((errno == ERANGE && (*val == LLONG_MAX || *val == LLONG_MIN)) ||
+			(errno != 0 && *val == 0))
 		return -1;
 
-	if (errno != 0 && *val == 0)
-		return -1;
-
-	if (node->check_min && *val < node->min)
+	if (node->check_min && *val < node->min) {
+		errno = ERANGE;
 		return -1;
+	}
 
-	if (node->check_max && *val > node->max)
+	if (node->check_max && *val > node->max) {
+		errno = ERANGE;
 		return -1;
+	}
 
-	if (*endptr != 0)
+	if (*endptr != 0) {
+		errno = EINVAL;
 		return -1;
+	}
 
+	errno = save_errno;
 	return 0;
 }
 
@@ -92,6 +76,7 @@ static int parse_ullint(struct ec_node_int_uint *node, const char *str,
 			uint64_t *val)
 {
 	char *endptr;
+	int save_errno = errno;
 
 	/* since a negative input is silently converted to a positive
 	 * one by strtoull(), first check that it is positive */
@@ -101,10 +86,8 @@ static int parse_ullint(struct ec_node_int_uint *node, const char *str,
 	errno = 0;
 	*val = strtoull(str, &endptr, node->base);
 
-	if (errno == ERANGE && *val == ULLONG_MAX)
-		return -1;
-
-	if (errno != 0 && *val == 0)
+	if ((errno == ERANGE && *val == ULLONG_MAX) ||
+			(errno != 0 && *val == 0))
 		return -1;
 
 	if (node->check_min && *val < node->umin)
@@ -116,26 +99,32 @@ static int parse_ullint(struct ec_node_int_uint *node, const char *str,
 	if (*endptr != 0)
 		return -1;
 
+	errno = save_errno;
 	return 0;
 }
 
 static int ec_node_int_uint_parse(const struct ec_node *gen_node,
-			struct ec_parsed *state,
+			struct ec_parse *state,
 			const struct ec_strvec *strvec)
 {
 	struct ec_node_int_uint *node = (struct ec_node_int_uint *)gen_node;
 	const char *str;
-	int64_t val;
+	uint64_t u64;
+	int64_t i64;
 
 	(void)state;
 
 	if (ec_strvec_len(strvec) == 0)
-		return EC_PARSED_NOMATCH;
+		return EC_PARSE_NOMATCH;
 
 	str = ec_strvec_val(strvec, 0);
-	if (parse_llint(node, str, &val) < 0)
-		return EC_PARSED_NOMATCH;
-
+	if (node->is_signed) {
+		if (parse_llint(node, str, &i64) < 0)
+			return EC_PARSE_NOMATCH;
+	} else {
+		if (parse_ullint(node, str, &u64) < 0)
+			return EC_PARSE_NOMATCH;
+	}
 	return 1;
 }
 
@@ -149,170 +138,225 @@ ec_node_uint_init_priv(struct ec_node *gen_node)
 	return 0;
 }
 
-static struct ec_node_type ec_node_int_type = {
-	.name = "int",
-	.parse = ec_node_int_uint_parse,
-	.complete = ec_node_default_complete,
-	.size = sizeof(struct ec_node_int_uint),
-	.init_priv = ec_node_uint_init_priv,
+static const struct ec_config_schema ec_node_int_schema[] = {
+	{
+		.key = "min",
+		.desc = "The minimum valid value (included).",
+		.type = EC_CONFIG_TYPE_INT64,
+	},
+	{
+		.key = "max",
+		.desc = "The maximum valid value (included).",
+		.type = EC_CONFIG_TYPE_INT64,
+	},
+	{
+		.key = "base",
+		.desc = "The base to use. If unset or 0, try to guess.",
+		.type = EC_CONFIG_TYPE_UINT64,
+	},
 };
 
-EC_NODE_TYPE_REGISTER(ec_node_int_type);
-
-struct ec_node *ec_node_int(const char *id, int64_t min,
-	int64_t max, unsigned int base)
+static int ec_node_int_set_config(struct ec_node *gen_node,
+				const struct ec_config *config)
 {
-	struct ec_node *gen_node = NULL;
+	struct ec_node_int_uint *node = (struct ec_node_int_uint *)gen_node;
+	const struct ec_config *min_value = NULL;
+	const struct ec_config *max_value = NULL;
+	const struct ec_config *base_value = NULL;
+	char *s = NULL;
 
-	gen_node = __ec_node(&ec_node_int_type, id);
-	if (gen_node == NULL)
-		return NULL;
+	min_value = ec_config_dict_get(config, "min");
+	max_value = ec_config_dict_get(config, "max");
+	base_value = ec_config_dict_get(config, "base");
 
-	if (ec_node_int_set_limits(gen_node, min, max) < 0)
-		goto fail;
-	if (ec_node_int_set_base(gen_node, base) < 0)
+	if (min_value && max_value && min_value->i64 > max_value->i64) {
+		errno = EINVAL;
 		goto fail;
+	}
 
-	return gen_node;
+	if (min_value != NULL) {
+		node->check_min = true;
+		node->min = min_value->i64;
+	} else {
+		node->check_min = false;
+	}
+	if (max_value != NULL) {
+		node->check_max = true;
+		node->max = max_value->i64;
+	} else {
+		node->check_min = false;
+	}
+	if (base_value != NULL)
+		node->base = base_value->u64;
+	else
+		node->base = 0;
+
+	return 0;
 
 fail:
-	ec_node_free(gen_node);
-	return NULL;
+	ec_free(s);
+	return -1;
 }
 
-static struct ec_node_type ec_node_uint_type = {
-	.name = "uint",
+static struct ec_node_type ec_node_int_type = {
+	.name = "int",
+	.schema = ec_node_int_schema,
+	.schema_len = EC_COUNT_OF(ec_node_int_schema),
+	.set_config = ec_node_int_set_config,
 	.parse = ec_node_int_uint_parse,
-	.complete = ec_node_default_complete,
+	.complete = ec_node_complete_unknown,
 	.size = sizeof(struct ec_node_int_uint),
+	.init_priv = ec_node_uint_init_priv,
 };
 
-EC_NODE_TYPE_REGISTER(ec_node_uint_type);
+EC_NODE_TYPE_REGISTER(ec_node_int_type);
 
-struct ec_node *ec_node_uint(const char *id, uint64_t min,
-	uint64_t max, unsigned int base)
+struct ec_node *ec_node_int(const char *id, int64_t min,
+	int64_t max, unsigned int base)
 {
+	struct ec_config *config = NULL;
 	struct ec_node *gen_node = NULL;
+	int ret;
 
-	gen_node = __ec_node(&ec_node_uint_type, id);
+	gen_node = __ec_node(&ec_node_int_type, id);
 	if (gen_node == NULL)
 		return NULL;
 
-	if (ec_node_uint_set_limits(gen_node, min, max) < 0)
+	config = ec_config_dict();
+	if (config == NULL)
+		goto fail;
+
+	ret = ec_config_dict_set(config, "min", ec_config_i64(min));
+	if (ret < 0)
 		goto fail;
-	if (ec_node_uint_set_base(gen_node, base) < 0)
+	ret = ec_config_dict_set(config, "max", ec_config_i64(max));
+	if (ret < 0)
+		goto fail;
+	ret = ec_config_dict_set(config, "base", ec_config_u64(base));
+	if (ret < 0)
+		goto fail;
+
+	ret = ec_node_set_config(gen_node, config);
+	config = NULL;
+	if (ret < 0)
 		goto fail;
 
 	return gen_node;
 
 fail:
+	ec_config_free(config);
 	ec_node_free(gen_node);
 	return NULL;
 }
 
-int ec_node_int_disable_limits(struct ec_node *gen_node)
-{
-	struct ec_node_int_uint *node = (struct ec_node_int_uint *)gen_node;
-	int ret;
-
-	ret = ec_node_check_type(gen_node, &ec_node_int_type);
-	if (ret < 0)
-		return ret;
-
-	node->check_min = false;
-	node->check_max = false;
-
-	return 0;
-}
+static const struct ec_config_schema ec_node_uint_schema[] = {
+	{
+		.key = "min",
+		.desc = "The minimum valid value (included).",
+		.type = EC_CONFIG_TYPE_UINT64,
+	},
+	{
+		.key = "max",
+		.desc = "The maximum valid value (included).",
+		.type = EC_CONFIG_TYPE_UINT64,
+	},
+	{
+		.key = "base",
+		.desc = "The base to use. If unset or 0, try to guess.",
+		.type = EC_CONFIG_TYPE_UINT64,
+	},
+};
 
-int ec_node_int_set_limits(struct ec_node *gen_node, int64_t min,
-			int64_t max)
+static int ec_node_uint_set_config(struct ec_node *gen_node,
+				const struct ec_config *config)
 {
 	struct ec_node_int_uint *node = (struct ec_node_int_uint *)gen_node;
-	int ret;
+	const struct ec_config *min_value = NULL;
+	const struct ec_config *max_value = NULL;
+	const struct ec_config *base_value = NULL;
+	char *s = NULL;
 
-	ret = ec_node_check_type(gen_node, &ec_node_int_type);
-	if (ret < 0)
-		return ret;
+	min_value = ec_config_dict_get(config, "min");
+	max_value = ec_config_dict_get(config, "max");
+	base_value = ec_config_dict_get(config, "base");
 
-	if (min > max) {
+	if (min_value && max_value && min_value->u64 > max_value->u64) {
 		errno = EINVAL;
-		return -1;
+		goto fail;
 	}
 
-	node->check_min = true;
-	node->min = min;
-	node->check_max = true;
-	node->max = max;
-
-	return 0;
-}
-
-int ec_node_int_set_base(struct ec_node *gen_node, unsigned int base)
-{
-	struct ec_node_int_uint *node = (struct ec_node_int_uint *)gen_node;
-	int ret;
-
-	ret = ec_node_check_type(gen_node, &ec_node_int_type);
-	if (ret < 0)
-		return ret;
-
-	node->base = base;
+	if (min_value != NULL) {
+		node->check_min = true;
+		node->min = min_value->u64;
+	} else {
+		node->check_min = false;
+	}
+	if (max_value != NULL) {
+		node->check_max = true;
+		node->max = max_value->u64;
+	} else {
+		node->check_min = false;
+	}
+	if (base_value != NULL)
+		node->base = base_value->u64;
+	else
+		node->base = 0;
 
 	return 0;
 
+fail:
+	ec_free(s);
+	return -1;
 }
 
-int ec_node_uint_disable_limits(struct ec_node *gen_node)
-{
-	struct ec_node_int_uint *node = (struct ec_node_int_uint *)gen_node;
-	int ret;
-
-	ret = ec_node_check_type(gen_node, &ec_node_uint_type);
-	if (ret < 0)
-		return ret;
-
-	node->check_min = false;
-	node->check_max = false;
+static struct ec_node_type ec_node_uint_type = {
+	.name = "uint",
+	.schema = ec_node_uint_schema,
+	.schema_len = EC_COUNT_OF(ec_node_uint_schema),
+	.set_config = ec_node_uint_set_config,
+	.parse = ec_node_int_uint_parse,
+	.complete = ec_node_complete_unknown,
+	.size = sizeof(struct ec_node_int_uint),
+};
 
-	return 0;
-}
+EC_NODE_TYPE_REGISTER(ec_node_uint_type);
 
-int ec_node_uint_set_limits(struct ec_node *gen_node, uint64_t min,
-			uint64_t max)
+struct ec_node *ec_node_uint(const char *id, uint64_t min,
+	uint64_t max, unsigned int base)
 {
-	struct ec_node_int_uint *node = (struct ec_node_int_uint *)gen_node;
+	struct ec_config *config = NULL;
+	struct ec_node *gen_node = NULL;
 	int ret;
 
-	ret = ec_node_check_type(gen_node, &ec_node_uint_type);
-	if (ret < 0)
-		return ret;
-
-	if (min > max) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	node->check_min = true;
-	node->min = min;
-	node->check_max = true;
-	node->max = max;
+	gen_node = __ec_node(&ec_node_uint_type, id);
+	if (gen_node == NULL)
+		return NULL;
 
-	return 0;
-}
+	config = ec_config_dict();
+	if (config == NULL)
+		goto fail;
 
-int ec_node_uint_set_base(struct ec_node *gen_node, unsigned int base)
-{
-	struct ec_node_int_uint *node = (struct ec_node_int_uint *)gen_node;
-	int ret;
+	ret = ec_config_dict_set(config, "min", ec_config_u64(min));
+	if (ret < 0)
+		goto fail;
+	ret = ec_config_dict_set(config, "max", ec_config_u64(max));
+	if (ret < 0)
+		goto fail;
+	ret = ec_config_dict_set(config, "base", ec_config_u64(base));
+	if (ret < 0)
+		goto fail;
 
-	ret = ec_node_check_type(gen_node, &ec_node_uint_type);
+	ret = ec_node_set_config(gen_node, config);
+	config = NULL;
 	if (ret < 0)
-		return ret;
+		goto fail;
 
-	node->base = base;
+	return gen_node;
 
-	return 0;
+fail:
+	ec_config_free(config);
+	ec_node_free(gen_node);
+	return NULL;
 }
 
 int ec_node_int_getval(const struct ec_node *gen_node, const char *str,
@@ -350,38 +394,43 @@ int ec_node_uint_getval(const struct ec_node *gen_node, const char *str,
 /* LCOV_EXCL_START */
 static int ec_node_int_testcase(void)
 {
-	struct ec_parsed *p;
+	struct ec_parse *p;
 	struct ec_node *node;
 	const char *s;
-	int ret = 0;
+	int testres = 0;
 	uint64_t u64;
 	int64_t i64;
 
-	node = ec_node_uint(EC_NO_ID, 0, 256, 0);
+	node = ec_node_uint(EC_NO_ID, 1, 256, 0);
 	if (node == NULL) {
 		EC_LOG(EC_LOG_ERR, "cannot create node\n");
 		return -1;
 	}
-	ret |= EC_TEST_CHECK_PARSE(node, 1, "0");
-	ret |= EC_TEST_CHECK_PARSE(node, 1, "256", "foo");
-	ret |= EC_TEST_CHECK_PARSE(node, 1, "0x100");
-	ret |= EC_TEST_CHECK_PARSE(node, 1, " 1");
-	ret |= EC_TEST_CHECK_PARSE(node, -1, "-1");
-	ret |= EC_TEST_CHECK_PARSE(node, -1, "0x101");
-
-	p = ec_node_parse(node, "0");
-	s = ec_strvec_val(ec_parsed_strvec(p), 0);
-	EC_TEST_ASSERT(s != NULL &&
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "0");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, "1");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, "256", "foo");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, "0x100");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, " 1");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "-1");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "0x101");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "zzz");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "0x100000000000000000");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "4r");
+
+	p = ec_node_parse(node, "1");
+	s = ec_strvec_val(ec_parse_strvec(p), 0);
+	testres |= EC_TEST_CHECK(s != NULL &&
 		ec_node_uint_getval(node, s, &u64) == 0 &&
-		u64 == 0);
-	ec_parsed_free(p);
+		u64 == 1, "bad integer value");
+	ec_parse_free(p);
 
 	p = ec_node_parse(node, "10");
-	s = ec_strvec_val(ec_parsed_strvec(p), 0);
-	EC_TEST_ASSERT(s != NULL &&
+	s = ec_strvec_val(ec_parse_strvec(p), 0);
+	testres |= EC_TEST_CHECK(s != NULL &&
 		ec_node_uint_getval(node, s, &u64) == 0 &&
-		u64 == 10);
-	ec_parsed_free(p);
+		u64 == 10, "bad integer value");
+	ec_parse_free(p);
 	ec_node_free(node);
 
 	node = ec_node_int(EC_NO_ID, -1, LLONG_MAX, 16);
@@ -389,18 +438,21 @@ static int ec_node_int_testcase(void)
 		EC_LOG(EC_LOG_ERR, "cannot create node\n");
 		return -1;
 	}
-	ret |= EC_TEST_CHECK_PARSE(node, 1, "0");
-	ret |= EC_TEST_CHECK_PARSE(node, 1, "-1");
-	ret |= EC_TEST_CHECK_PARSE(node, 1, "7fffffffffffffff");
-	ret |= EC_TEST_CHECK_PARSE(node, 1, "0x7fffffffffffffff");
-	ret |= EC_TEST_CHECK_PARSE(node, -1, "-2");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, "0");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, "-1");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, "7fffffffffffffff");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, "0x7fffffffffffffff");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "0x8000000000000000");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "-2");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "zzz");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "4r");
 
 	p = ec_node_parse(node, "10");
-	s = ec_strvec_val(ec_parsed_strvec(p), 0);
-	EC_TEST_ASSERT(s != NULL &&
+	s = ec_strvec_val(ec_parse_strvec(p), 0);
+	testres |= EC_TEST_CHECK(s != NULL &&
 		ec_node_int_getval(node, s, &i64) == 0 &&
-		i64 == 16);
-	ec_parsed_free(p);
+		i64 == 16, "bad integer value");
+	ec_parse_free(p);
 	ec_node_free(node);
 
 	node = ec_node_int(EC_NO_ID, LLONG_MIN, 0, 10);
@@ -408,11 +460,11 @@ static int ec_node_int_testcase(void)
 		EC_LOG(EC_LOG_ERR, "cannot create node\n");
 		return -1;
 	}
-	ret |= EC_TEST_CHECK_PARSE(node, 1, "0");
-	ret |= EC_TEST_CHECK_PARSE(node, 1, "-1");
-	ret |= EC_TEST_CHECK_PARSE(node, 1, "-9223372036854775808");
-	ret |= EC_TEST_CHECK_PARSE(node, -1, "0x0");
-	ret |= EC_TEST_CHECK_PARSE(node, -1, "1");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, "0");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, "-1");
+	testres |= EC_TEST_CHECK_PARSE(node, 1, "-9223372036854775808");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "0x0");
+	testres |= EC_TEST_CHECK_PARSE(node, -1, "1");
 	ec_node_free(node);
 
 	/* test completion */
@@ -421,18 +473,18 @@ static int ec_node_int_testcase(void)
 		EC_LOG(EC_LOG_ERR, "cannot create node\n");
 		return -1;
 	}
-	ret |= EC_TEST_CHECK_COMPLETE(node,
+	testres |= EC_TEST_CHECK_COMPLETE(node,
 		"", EC_NODE_ENDLIST,
 		EC_NODE_ENDLIST);
-	ret |= EC_TEST_CHECK_COMPLETE(node,
+	testres |= EC_TEST_CHECK_COMPLETE(node,
 		"x", EC_NODE_ENDLIST,
 		EC_NODE_ENDLIST);
-	ret |= EC_TEST_CHECK_COMPLETE(node,
+	testres |= EC_TEST_CHECK_COMPLETE(node,
 		"1", EC_NODE_ENDLIST,
 		EC_NODE_ENDLIST);
 	ec_node_free(node);
 
-	return ret;
+	return testres;
 }
 /* LCOV_EXCL_STOP */