X-Git-Url: http://git.droids-corp.org/?p=protos%2Flibecoli.git;a=blobdiff_plain;f=src%2Fecoli_parse.c;fp=src%2Fecoli_parse.c;h=c47c7b4f653d71cf2e83c2a466c1c6321e4900bf;hp=9a6eabc2ecb1bfb398954bfd3bbea8409ba36da7;hb=6e8f52f49af3927da5851d4d497bb61c94e18ad0;hpb=74ce3d6a8a834a003bff84a8cd6344a94dade895

diff --git a/src/ecoli_parse.c b/src/ecoli_parse.c
index 9a6eabc..c47c7b4 100644
--- a/src/ecoli_parse.c
+++ b/src/ecoli_parse.c
@@ -93,29 +93,28 @@ int ec_parse_child(const struct ec_node *node, struct ec_pnode *pstate,
 	return __ec_parse_child(node, pstate, false, strvec);
 }
 
-// XXX what is returned if no match ??
 struct ec_pnode *ec_parse_strvec(const struct ec_node *node,
 				const struct ec_strvec *strvec)
 {
-	struct ec_pnode *parse = ec_pnode(node);
+	struct ec_pnode *pnode = ec_pnode(node);
 	int ret;
 
-	if (parse == NULL)
+	if (pnode == NULL)
 		return NULL;
 
-	ret = __ec_parse_child(node, parse, true, strvec);
+	ret = __ec_parse_child(node, pnode, true, strvec);
 	if (ret < 0) {
-		ec_pnode_free(parse);
+		ec_pnode_free(pnode);
 		return NULL;
 	}
 
-	return parse;
+	return pnode;
 }
 
 struct ec_pnode *ec_parse(const struct ec_node *node, const char *str)
 {
 	struct ec_strvec *strvec = NULL;
-	struct ec_pnode *parse = NULL;
+	struct ec_pnode *pnode = NULL;
 
 	errno = ENOMEM;
 	strvec = ec_strvec();
@@ -125,40 +124,40 @@ struct ec_pnode *ec_parse(const struct ec_node *node, const char *str)
 	if (ec_strvec_add(strvec, str) < 0)
 		goto fail;
 
-	parse = ec_parse_strvec(node, strvec);
-	if (parse == NULL)
+	pnode = ec_parse_strvec(node, strvec);
+	if (pnode == NULL)
 		goto fail;
 
 	ec_strvec_free(strvec);
-	return parse;
+	return pnode;
 
  fail:
 	ec_strvec_free(strvec);
-	ec_pnode_free(parse);
+	ec_pnode_free(pnode);
 	return NULL;
 }
 
 struct ec_pnode *ec_pnode(const struct ec_node *node)
 {
-	struct ec_pnode *parse = NULL;
+	struct ec_pnode *pnode = NULL;
 
-	parse = ec_calloc(1, sizeof(*parse));
-	if (parse == NULL)
+	pnode = ec_calloc(1, sizeof(*pnode));
+	if (pnode == NULL)
 		goto fail;
 
-	TAILQ_INIT(&parse->children);
+	TAILQ_INIT(&pnode->children);
 
-	parse->node = node;
-	parse->attrs = ec_dict();
-	if (parse->attrs == NULL)
+	pnode->node = node;
+	pnode->attrs = ec_dict();
+	if (pnode->attrs == NULL)
 		goto fail;
 
-	return parse;
+	return pnode;
 
  fail:
-	if (parse != NULL)
-		ec_dict_free(parse->attrs);
-	ec_free(parse);
+	if (pnode != NULL)
+		ec_dict_free(pnode->attrs);
+	ec_free(pnode);
 
 	return NULL;
 }
@@ -207,13 +206,13 @@ fail:
 	return NULL;
 }
 
-struct ec_pnode *ec_pnode_dup(const struct ec_pnode *parse)
+struct ec_pnode *ec_pnode_dup(const struct ec_pnode *pnode)
 {
 	const struct ec_pnode *root;
 	struct ec_pnode *dup_root, *dup = NULL;
 
-	root = ec_pnode_get_root(parse);
-	dup_root = __ec_pnode_dup(root, parse, &dup);
+	root = ec_pnode_get_root(pnode);
+	dup_root = __ec_pnode_dup(root, pnode, &dup);
 	if (dup_root == NULL)
 		return NULL;
 	assert(dup != NULL);
@@ -221,167 +220,167 @@ struct ec_pnode *ec_pnode_dup(const struct ec_pnode *parse)
 	return dup;
 }
 
-void ec_pnode_free_children(struct ec_pnode *parse)
+void ec_pnode_free_children(struct ec_pnode *pnode)
 {
 	struct ec_pnode *child;
 
-	if (parse == NULL)
+	if (pnode == NULL)
 		return;
 
-	while (!TAILQ_EMPTY(&parse->children)) {
-		child = TAILQ_FIRST(&parse->children);
-		TAILQ_REMOVE(&parse->children, child, next);
+	while (!TAILQ_EMPTY(&pnode->children)) {
+		child = TAILQ_FIRST(&pnode->children);
+		TAILQ_REMOVE(&pnode->children, child, next);
 		child->parent = NULL;
 		ec_pnode_free(child);
 	}
 }
 
-void ec_pnode_free(struct ec_pnode *parse)
+void ec_pnode_free(struct ec_pnode *pnode)
 {
-	if (parse == NULL)
+	if (pnode == NULL)
 		return;
 
-	ec_assert_print(parse->parent == NULL,
+	ec_assert_print(pnode->parent == NULL,
 			"parent not NULL in ec_pnode_free()");
 
-	ec_pnode_free_children(parse);
-	ec_strvec_free(parse->strvec);
-	ec_dict_free(parse->attrs);
-	ec_free(parse);
+	ec_pnode_free_children(pnode);
+	ec_strvec_free(pnode->strvec);
+	ec_dict_free(pnode->attrs);
+	ec_free(pnode);
 }
 
 static void __ec_pnode_dump(FILE *out,
-	const struct ec_pnode *parse, size_t indent)
+	const struct ec_pnode *pnode, size_t indent)
 {
 	struct ec_pnode *child;
 	const struct ec_strvec *vec;
 	const char *id = "none", *typename = "none";
 
 	/* node can be null when parsing is incomplete */
-	if (parse->node != NULL) {
-		id = ec_node_id(parse->node);
-		typename = ec_node_type(parse->node)->name;
+	if (pnode->node != NULL) {
+		id = ec_node_id(pnode->node);
+		typename = ec_node_type(pnode->node)->name;
 	}
 
 	fprintf(out, "%*s" "type=%s id=%s vec=",
 		(int)indent * 4, "", typename, id);
-	vec = ec_pnode_strvec(parse);
+	vec = ec_pnode_get_strvec(pnode);
 	ec_strvec_dump(out, vec);
 
-	TAILQ_FOREACH(child, &parse->children, next)
+	TAILQ_FOREACH(child, &pnode->children, next)
 		__ec_pnode_dump(out, child, indent + 1);
 }
 
-void ec_pnode_dump(FILE *out, const struct ec_pnode *parse)
+void ec_pnode_dump(FILE *out, const struct ec_pnode *pnode)
 {
 	fprintf(out, "------------------- parse dump:\n");
 
-	if (parse == NULL) {
-		fprintf(out, "parse is NULL\n");
+	if (pnode == NULL) {
+		fprintf(out, "pnode is NULL\n");
 		return;
 	}
 
-	/* only exist if it does not match (strvec == NULL) and if it
-	 * does not have children: an incomplete parse, like those
-	 * generated by complete() don't match but have children that
-	 * may match. */
-	if (!ec_pnode_matches(parse) && TAILQ_EMPTY(&parse->children)) {
+	/* Do not dump if it does not match (strvec == NULL) and if it
+	 * does not have children. Note that an incomplete parsing tree,
+	 * like those generated by complete(), don't match but have
+	 * children that may match, and we want to dump them. */
+	if (!ec_pnode_matches(pnode) && TAILQ_EMPTY(&pnode->children)) {
 		fprintf(out, "no match\n");
 		return;
 	}
 
-	__ec_pnode_dump(out, parse, 0);
+	__ec_pnode_dump(out, pnode, 0);
 }
 
-void ec_pnode_link_child(struct ec_pnode *parse,
+void ec_pnode_link_child(struct ec_pnode *pnode,
 	struct ec_pnode *child)
 {
-	TAILQ_INSERT_TAIL(&parse->children, child, next);
-	child->parent = parse;
+	TAILQ_INSERT_TAIL(&pnode->children, child, next);
+	child->parent = pnode;
 }
 
-void ec_pnode_unlink_child(struct ec_pnode *parse,
+void ec_pnode_unlink_child(struct ec_pnode *pnode,
 	struct ec_pnode *child)
 {
-	TAILQ_REMOVE(&parse->children, child, next);
+	TAILQ_REMOVE(&pnode->children, child, next);
 	child->parent = NULL;
 }
 
 struct ec_pnode *
-ec_pnode_get_first_child(const struct ec_pnode *parse)
+ec_pnode_get_first_child(const struct ec_pnode *pnode)
 {
-	return TAILQ_FIRST(&parse->children);
+	return TAILQ_FIRST(&pnode->children);
 }
 
 struct ec_pnode *
-ec_pnode_get_last_child(const struct ec_pnode *parse)
+ec_pnode_get_last_child(const struct ec_pnode *pnode)
 {
-	return TAILQ_LAST(&parse->children, ec_pnode_list);
+	return TAILQ_LAST(&pnode->children, ec_pnode_list);
 }
 
-struct ec_pnode *ec_pnode_next(const struct ec_pnode *parse)
+struct ec_pnode *ec_pnode_next(const struct ec_pnode *pnode)
 {
-	return TAILQ_NEXT(parse, next);
+	return TAILQ_NEXT(pnode, next);
 }
 
-bool ec_pnode_has_child(const struct ec_pnode *parse)
+bool ec_pnode_has_child(const struct ec_pnode *pnode)
 {
-	return !TAILQ_EMPTY(&parse->children);
+	return !TAILQ_EMPTY(&pnode->children);
 }
 
-const struct ec_node *ec_pnode_get_node(const struct ec_pnode *parse)
+const struct ec_node *ec_pnode_get_node(const struct ec_pnode *pnode)
 {
-	if (parse == NULL)
+	if (pnode == NULL)
 		return NULL;
 
-	return parse->node;
+	return pnode->node;
 }
 
-void ec_pnode_del_last_child(struct ec_pnode *parse)
+void ec_pnode_del_last_child(struct ec_pnode *pnode)
 {
 	struct ec_pnode *child;
 
-	child = ec_pnode_get_last_child(parse);
-	ec_pnode_unlink_child(parse, child);
+	child = ec_pnode_get_last_child(pnode);
+	ec_pnode_unlink_child(pnode, child);
 	ec_pnode_free(child);
 }
 
-struct ec_pnode *__ec_pnode_get_root(struct ec_pnode *parse)
+struct ec_pnode *__ec_pnode_get_root(struct ec_pnode *pnode)
 {
-	if (parse == NULL)
+	if (pnode == NULL)
 		return NULL;
 
-	while (parse->parent != NULL)
-		parse = parse->parent;
+	while (pnode->parent != NULL)
+		pnode = pnode->parent;
 
-	return parse;
+	return pnode;
 }
 
-struct ec_pnode *ec_pnode_get_parent(const struct ec_pnode *parse)
+struct ec_pnode *ec_pnode_get_parent(const struct ec_pnode *pnode)
 {
-	if (parse == NULL)
+	if (pnode == NULL)
 		return NULL;
 
-	return parse->parent;
+	return pnode->parent;
 }
 
 struct ec_pnode *__ec_pnode_iter_next(const struct ec_pnode *root,
-				struct ec_pnode *parse, bool iter_children)
+				struct ec_pnode *pnode, bool iter_children)
 {
 	struct ec_pnode *child, *parent, *next;
 
 	if (iter_children) {
-		child = TAILQ_FIRST(&parse->children);
+		child = TAILQ_FIRST(&pnode->children);
 		if (child != NULL)
 			return child;
 	}
-	parent = parse->parent;
-	while (parent != NULL && parse != root) {
-		next = TAILQ_NEXT(parse, next);
+	parent = pnode->parent;
+	while (parent != NULL && pnode != root) {
+		next = TAILQ_NEXT(pnode, next);
 		if (next != NULL)
 			return next;
-		parse = parent;
-		parent = parse->parent;
+		pnode = parent;
+		parent = pnode->parent;
 	}
 	return NULL;
 }
@@ -409,44 +408,44 @@ ec_pnode_find_next(struct ec_pnode *root, struct ec_pnode *start,
 	return NULL;
 }
 
-struct ec_pnode *ec_pnode_find(struct ec_pnode *parse,
+struct ec_pnode *ec_pnode_find(struct ec_pnode *pnode,
 	const char *id)
 {
-	return ec_pnode_find_next(parse, NULL, id, 1);
+	return ec_pnode_find_next(pnode, NULL, id, 1);
 }
 
 struct ec_dict *
-ec_pnode_get_attrs(struct ec_pnode *parse)
+ec_pnode_get_attrs(struct ec_pnode *pnode)
 {
-	if (parse == NULL)
+	if (pnode == NULL)
 		return NULL;
 
-	return parse->attrs;
+	return pnode->attrs;
 }
 
-const struct ec_strvec *ec_pnode_strvec(const struct ec_pnode *parse)
+const struct ec_strvec *ec_pnode_get_strvec(const struct ec_pnode *pnode)
 {
-	if (parse == NULL || parse->strvec == NULL)
+	if (pnode == NULL)
 		return NULL;
 
-	return parse->strvec;
+	return pnode->strvec;
 }
 
-/* number of strings in the parse vector */
-size_t ec_pnode_len(const struct ec_pnode *parse)
+/* number of strings in the parsed string vector */
+size_t ec_pnode_len(const struct ec_pnode *pnode)
 {
-	if (parse == NULL || parse->strvec == NULL)
+	if (pnode == NULL || pnode->strvec == NULL)
 		return 0;
 
-	return ec_strvec_len(parse->strvec);
+	return ec_strvec_len(pnode->strvec);
 }
 
-size_t ec_pnode_matches(const struct ec_pnode *parse)
+size_t ec_pnode_matches(const struct ec_pnode *pnode)
 {
-	if (parse == NULL)
+	if (pnode == NULL)
 		return 0;
 
-	if (parse->strvec == NULL)
+	if (pnode->strvec == NULL)
 		return 0;
 
 	return 1;