ossp-pkg/cfg/cfg_node.c
1.27
/*
** OSSP cfg - Configuration Parsing
** Copyright (c) 2002-2006 Ralf S. Engelschall <rse@engelschall.com>
** Copyright (c) 2002-2006 The OSSP Project (http://www.ossp.org/)
**
** This file is part of OSSP cfg, a configuration parsing
** library which can be found at http://www.ossp.org/pkg/lib/cfg/.
**
** Permission to use, copy, modify, and distribute this software for
** any purpose with or without fee is hereby granted, provided that
** the above copyright notice and this permission notice appear in all
** copies.
**
** THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 AUTHORS AND COPYRIGHT HOLDERS AND THEIR
** 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.
**
** cfg_node.c: configuration nodes
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <limits.h>
#include "cfg_main.h"
#include "cfg_node.h"
#include "cfg_fmt.h"
#include "cfg_global.h"
/* create a configuration node */
cfg_rc_t
cfg_node_create(
cfg_t *cfg,
cfg_node_t **node)
{
cfg_node_t *n;
cfg_rc_t rc;
/* argument sanity checking */
if (node == NULL)
return CFG_ERR_ARG;
/* allocate memory */
if ((rc = cfg_grid_alloc(cfg->grid_nodes, (void **)(void *)&n)) != CFG_OK)
return rc;
/* initialize node attributes */
n->owner = 0;
n->parent = NULL;
n->rbroth = NULL;
n->child1 = NULL;
n->type = CFG_NODE_TYPE_ARG;
n->token = NULL;
cfg_data_init(&n->data);
n->srcname = NULL;
n->srcpos = 0;
*node = n;
return CFG_OK;
}
/* destroy a configuration node */
cfg_rc_t
cfg_node_destroy(
cfg_t *cfg,
cfg_node_t *node)
{
/* argument sanity checking */
if (node == NULL)
return CFG_ERR_ARG;
/* destroy memory */
if ((node->owner & CFG_NODE_ATTR_TOKEN) && node->token != NULL)
free(node->token);
if ((node->owner & CFG_NODE_ATTR_SRCNAME) && node->srcname != NULL)
free(node->srcname);
cfg_data_kill(&node->data);
cfg_grid_free(cfg->grid_nodes, node);
return CFG_OK;
}
/* clone a node */
cfg_rc_t
cfg_node_clone(
cfg_t *cfg,
cfg_node_t *node,
cfg_node_t **node2)
{
cfg_node_t *n;
cfg_rc_t rc;
/* argument sanity checking */
if (node == NULL || node2 == NULL)
return CFG_ERR_ARG;
/* allocate memory for new node */
if ((rc = cfg_grid_alloc(cfg->grid_nodes, (void **)(void *)&n)) != CFG_OK)
return rc;
/* clone node attributes */
n->owner = node->owner;
n->parent = node->parent;
n->rbroth = node->rbroth;
n->child1 = node->child1;
n->type = node->type;
n->srcpos = node->srcpos;
if (node->owner & CFG_NODE_ATTR_TOKEN)
n->token = (node->token != NULL ? strdup(node->token) : NULL);
else
n->token = node->token;
if (node->owner & CFG_NODE_ATTR_SRCNAME)
n->srcname = (node->srcname != NULL ? strdup(node->srcname) : NULL);
else
n->srcname = node->srcname;
cfg_data_copy(&node->data, &n->data);
/* store result */
*node2 = n;
return CFG_OK;
}
/* set a node attribute */
cfg_rc_t
cfg_node_set(
cfg_t *cfg,
cfg_node_t *node,
cfg_node_attr_t attr,
...)
{
va_list ap;
/* argument sanity checking */
if (node == NULL)
return CFG_ERR_ARG;
/* dispatch into individual attribute handling */
va_start(ap, attr);
switch (attr & ~(CFG_ATTR_LOAN|CFG_ATTR_GIFT|CFG_ATTR_COPY)) {
case CFG_NODE_ATTR_PARENT: {
node->parent = (cfg_node_t *)va_arg(ap, cfg_node_t *);
break;
}
case CFG_NODE_ATTR_LBROTH: {
return CFG_ERR_USE; /* cannot be set, only get */
}
case CFG_NODE_ATTR_RBROTH: {
node->rbroth = (cfg_node_t *)va_arg(ap, cfg_node_t *);
break;
}
case CFG_NODE_ATTR_CHILD1: {
node->child1 = (cfg_node_t *)va_arg(ap, cfg_node_t *);
break;
}
case CFG_NODE_ATTR_CHILDL: {
return CFG_ERR_USE; /* cannot be set, only get */
}
case CFG_NODE_ATTR_CHILDS: {
return CFG_ERR_USE; /* cannot be set, only get */
}
case CFG_NODE_ATTR_NODES: {
return CFG_ERR_USE; /* cannot be set, only get */
}
case CFG_NODE_ATTR_DEPTH: {
return CFG_ERR_USE; /* cannot be set, only get */
}
case CFG_NODE_ATTR_TYPE: {
node->type = (cfg_node_type_t)va_arg(ap, cfg_node_type_t);
break;
}
case CFG_NODE_ATTR_TOKEN: {
char *value = (char *)va_arg(ap, char *);
if (attr & CFG_ATTR_COPY)
value = strdup(value);
if (node->owner & CFG_NODE_ATTR_TOKEN && node->token != NULL)
free(node->token);
node->token = value;
if (attr & (CFG_ATTR_COPY|CFG_ATTR_GIFT))
node->owner |= CFG_NODE_ATTR_TOKEN;
break;
}
case CFG_NODE_ATTR_DATA: {
return CFG_ERR_USE;
}
case CFG_NODE_ATTR_SRCNAME: {
char *value = (char *)va_arg(ap, char *);
if (attr & CFG_ATTR_COPY)
value = strdup(value);
if (node->owner & CFG_NODE_ATTR_SRCNAME && node->srcname != NULL)
free(node->srcname);
node->srcname = value;
if (attr & (CFG_ATTR_COPY|CFG_ATTR_GIFT))
node->owner |= CFG_NODE_ATTR_SRCNAME;
break;
}
case CFG_NODE_ATTR_SRCPOS: {
node->srcpos = (int)va_arg(ap, int);
break;
}
default:
return CFG_ERR_ARG;
}
va_end(ap);
return CFG_OK;
}
/* INTERNAL: calculate number of nodes */
static int
cfg_node_get_nodes(
cfg_node_t *node)
{
int n;
n = 0;
if (node != NULL) {
n++;
if ((node = node->child1) != NULL) {
n += cfg_node_get_nodes(node);
if ((node = node->rbroth) != NULL)
n += cfg_node_get_nodes(node);
}
}
return n;
}
/* get a node attribute */
cfg_rc_t
cfg_node_get(
cfg_t *cfg,
cfg_node_t *node,
cfg_node_attr_t attr,
...)
{
va_list ap;
/* argument sanity checking */
if (node == NULL)
return CFG_ERR_ARG;
/* dispatch into individual attribute handling */
va_start(ap, attr);
switch (attr & ~(CFG_ATTR_LOAN|CFG_ATTR_GIFT|CFG_ATTR_COPY)) {
case CFG_NODE_ATTR_PARENT: {
cfg_node_t **n = (cfg_node_t **)va_arg(ap, void *);
if (n == NULL)
return CFG_ERR_ARG;
*n = node->parent;
break;
}
case CFG_NODE_ATTR_LBROTH: {
cfg_node_t **np = (cfg_node_t **)va_arg(ap, void *);
cfg_node_t *n;
if (np == NULL)
return CFG_ERR_ARG;
*np = NULL;
if ((n = node->parent) != NULL) {
if ((n = n->child1) != NULL) {
while (n->rbroth != node && n->rbroth != NULL)
n = n->rbroth;
if (n->rbroth == node)
*np = n;
}
}
break;
}
case CFG_NODE_ATTR_RBROTH: {
cfg_node_t **n = (cfg_node_t **)va_arg(ap, void *);
if (n == NULL)
return CFG_ERR_ARG;
*n = node->rbroth;
break;
}
case CFG_NODE_ATTR_CHILD1: {
cfg_node_t **n = (cfg_node_t **)va_arg(ap, void *);
if (n == NULL)
return CFG_ERR_ARG;
*n = node->child1;
break;
}
case CFG_NODE_ATTR_CHILDL: {
cfg_node_t **n = (cfg_node_t **)va_arg(ap, void *);
if (n == NULL)
return CFG_ERR_ARG;
if ((*n = node->child1) != NULL)
while ((*n)->rbroth != NULL)
*n = (*n)->rbroth;
break;
}
case CFG_NODE_ATTR_CHILDS: {
int *c = (int *)va_arg(ap, int *);
cfg_node_t *n;
if (c == NULL)
return CFG_ERR_ARG;
*c = 0;
if ((n = node->child1) != NULL) {
(*c)++;
while (n->rbroth != NULL) {
n = n->rbroth;
(*c)++;
}
}
break;
}
case CFG_NODE_ATTR_NODES: {
int *k = (int *)va_arg(ap, int *);
if (k == NULL)
return CFG_ERR_ARG;
*k = cfg_node_get_nodes(node);
break;
}
case CFG_NODE_ATTR_DEPTH: {
int *k = (int *)va_arg(ap, int *);
cfg_node_t *n;
if (k == NULL)
return CFG_ERR_ARG;
*k = 0;
n = node;
while ((n = n->parent) != NULL)
(*k)++;
break;
}
case CFG_NODE_ATTR_TYPE: {
cfg_node_type_t *type = (cfg_node_type_t *)va_arg(ap, void *);
if (type == NULL)
return CFG_ERR_ARG;
*type = node->type;
break;
}
case CFG_NODE_ATTR_TOKEN: {
char **token = (char **)va_arg(ap, char **);
if (token == NULL)
return CFG_ERR_ARG;
*token = node->token;
if (attr & CFG_ATTR_COPY)
*token = strdup(*token);
if (attr & CFG_ATTR_GIFT)
node->token = NULL;
break;
}
case CFG_NODE_ATTR_DATA: {
cfg_data_t **data = (cfg_data_t **)va_arg(ap, void *);
if (data == NULL)
return CFG_ERR_ARG;
*data = &(node->data);
break;
}
case CFG_NODE_ATTR_SRCNAME: {
char **name = (char **)va_arg(ap, char **);
if (name == NULL)
return CFG_ERR_ARG;
*name = node->srcname;
if (attr & CFG_ATTR_COPY)
*name = strdup(*name);
if (attr & CFG_ATTR_GIFT)
node->srcname = NULL;
break;
}
case CFG_NODE_ATTR_SRCPOS: {
int *pos = (int *)va_arg(ap, int *);
if (pos == NULL)
return CFG_ERR_ARG;
*pos = node->srcpos;
break;
}
default:
return CFG_ERR_ARG;
}
va_end(ap);
return CFG_OK;
}
/* get and/or set root node */
cfg_rc_t
cfg_node_root(
cfg_t *cfg,
cfg_node_t *node,
cfg_node_t **node_old)
{
/* argument sanity checking */
if (cfg == NULL || (node == NULL && node_old == NULL))
return CFG_ERR_ARG;
/* optionally get old root node pointer */
if (node_old != NULL)
*node_old = cfg->root;
/* optionally set new root node pointer */
if (node != NULL)
cfg->root = node;
return CFG_OK;
}
/* forward declarations for internal stepping functions */
static cfg_rc_t
cfg_node_select_step1(
cfg_t *, cfg_node_t *, cfg_node_t ***, long *, const char *);
static cfg_rc_t
cfg_node_select_step2(
cfg_t *, cfg_node_t *, cfg_node_t ***, long *, const char *, const char *, size_t, long, long, long *);
/* INTERNAL: selection stepping function (part 3, matching node processing) */
static cfg_rc_t
cfg_node_select_step3(
cfg_t *cfg,
cfg_node_t *node,
cfg_node_t ***result_vec, long *result_len,
const char *spec,
const char *cpSel, size_t nSel,
long nFilMin, long nFilMax,
long *nFound)
{
cfg_rc_t rc;
#if 0
fprintf(stderr, " step3: (1) cpSel=\"%s\", nSel=%d, spec=\"%s\", nFilMin=%ld, nFilMax=%ld, nFound=%ld\n",
cpSel, nSel, spec, nFilMin, nFilMax, *nFound);
#endif
if (spec[0] == '\0') {
/* end of selection, node found */
(*nFound)++;
#if 0
fprintf(stderr, " step3: (2) found node!!\n");
fprintf(stderr, " step3: current node=0x%lx type=%s token=\"%s\"\n",
(unsigned long)node,
(node != NULL ? (node->type == CFG_NODE_TYPE_SEQ ? "SEQ" : (node->type == CFG_NODE_TYPE_DIR ? "DIR" : "ARG")) : "<NULL>/.."),
(node != NULL ? (node->token != NULL ? node->token : "<NULL>") : "<NULL>/.."));
#endif
if (nFilMin <= *nFound && *nFound <= nFilMax) {
if (result_len != NULL) {
(*result_len)++;
if (result_vec != NULL) {
if ((*result_vec = (cfg_node_t **)realloc(*result_vec, sizeof(cfg_node_t *)*((*result_len)+1))) == NULL)
return CFG_ERR_SYS;
(*result_vec)[(*result_len)-1] = node;
(*result_vec)[(*result_len)] = NULL;
}
}
}
rc = CFG_OK;
}
else {
/* start over with next step */
rc = cfg_node_select_step1(cfg, node, result_vec, result_len, spec);
}
return rc;
}
/* INTERNAL: selection stepping function (part 2, node matching) */
static cfg_rc_t
cfg_node_select_step2(
cfg_t *cfg,
cfg_node_t *node,
cfg_node_t ***result_vec, long *result_len,
const char *spec,
const char *cpSel, size_t nSel,
long nFilMin, long nFilMax,
long *nFound)
{
cfg_rc_t rc;
char *token;
cfg_node_t *node2;
cfg_node_type_t type;
#if 0
fprintf(stderr, " step2: (1) cpSel=\"%.*s\", nSel=%d, spec=\"%s\", nFilMin=%ld, nFilMax=%ld, nFound=%ld\n",
nSel, cpSel, nSel, spec, nFilMin, nFilMax, *nFound);
fprintf(stderr, " step2: current node=0x%lx type=%s token=\"%s\"\n",
(unsigned long)node,
(node != NULL ? (node->type == CFG_NODE_TYPE_SEQ ? "SEQ" : (node->type == CFG_NODE_TYPE_DIR ? "DIR" : "ARG")) : "<NULL>/.."),
(node != NULL ? (node->token != NULL ? node->token : "<NULL>") : "<NULL>/.."));
#endif
rc = CFG_OK;
if (nSel == 1 && strncmp(cpSel, ".", nSel) == 0) {
/* current node (no-op) */
#if 0
fprintf(stderr, " step2: search current node, starting at node 0x%lx\n", (unsigned long)node);
#endif
rc = cfg_node_select_step3(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, nFound);
}
else if (nSel == 2 && strncmp(cpSel, "..", nSel) == 0) {
/* parent node */
#if 0
fprintf(stderr, " step2: search parent node, starting at node 0x%lx\n", (unsigned long)node);
#endif
if (cfg_node_get(cfg, node, CFG_NODE_ATTR_PARENT, &node) == CFG_OK && node != NULL)
rc = cfg_node_select_step3(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, nFound);
}
else if (nSel == 4 && strncmp(cpSel, "....", nSel) == 0) {
/* anchestor nodes */
#if 0
fprintf(stderr, " step2: search ancestor nodes, starting at node 0x%lx\n", (unsigned long)node);
#endif
while (cfg_node_get(cfg, node, CFG_NODE_ATTR_PARENT, &node) == CFG_OK && node != NULL)
if ((rc = cfg_node_select_step3(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, nFound)) != CFG_OK)
break;
}
else if (nSel == 1 && strncmp(cpSel, "-", nSel) == 0) {
/* previous sibling node */
#if 0
fprintf(stderr, " step2: search previous sibling node, starting at node 0x%lx\n", (unsigned long)node);
#endif
if ((rc = cfg_node_get(cfg, node, CFG_NODE_ATTR_LBROTH, &node)) == CFG_OK && node != NULL)
rc = cfg_node_select_step3(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, nFound);
}
else if (nSel == 2 && strncmp(cpSel, "--", nSel) == 0) {
/* preceeding sibling nodes */
#if 0
fprintf(stderr, " step2: search preceeding sibling nodes, starting at node 0x%lx\n", (unsigned long)node);
#endif
while (cfg_node_get(cfg, node, CFG_NODE_ATTR_LBROTH, &node) == CFG_OK && node != NULL)
if ((rc = cfg_node_select_step3(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, nFound)) != CFG_OK)
break;
}
else if (nSel == 1 && strncmp(cpSel, "+", nSel) == 0) {
/* next sibling node */
#if 0
fprintf(stderr, " step2: search next sibling node, starting at node 0x%lx\n", (unsigned long)node);
#endif
if ((rc = cfg_node_get(cfg, node, CFG_NODE_ATTR_RBROTH, &node)) == CFG_OK && node != NULL)
rc = cfg_node_select_step3(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, nFound);
}
else if (nSel == 2 && strncmp(cpSel, "++", nSel) == 0) {
/* following sibling nodes */
#if 0
fprintf(stderr, " step2: search following sibling nodes, starting at node 0x%lx\n", (unsigned long)node);
#endif
while (cfg_node_get(cfg, node, CFG_NODE_ATTR_RBROTH, &node) == CFG_OK && node != NULL)
if ((rc = cfg_node_select_step3(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, nFound)) != CFG_OK)
break;
}
else if (nSel == 0 /* "//" */) {
/* descendant nodes */
#if 0
fprintf(stderr, " step2: search descendant nodes, starting at node 0x%lx\n", (unsigned long)node);
#endif
#if 0 /* FIXME */
if ((rc = cfg_node_apply(cfg, node, NULL, NULL, cfg_node_select_step2_descendant, &descendant_ctx)
cfg_rc_t cfg_node_select_step2_descendant(cfg_t *cfg, cfg_node_t *node, void *_ctx));
#endif
if ((rc = cfg_node_get(cfg, node, CFG_NODE_ATTR_CHILD1, &node)) == CFG_OK && node != NULL) {
do {
if ((rc = cfg_node_select_step3(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, nFound)) != CFG_OK)
return rc;
if ((rc = cfg_node_select_step2(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, nFound)) != CFG_OK)
return rc;
} while ((rc = cfg_node_get(cfg, node, CFG_NODE_ATTR_RBROTH, &node)) == CFG_OK && node != NULL);
}
return CFG_OK;
}
else {
/* child node */
#if 0
fprintf(stderr, " step2: search child nodes, starting at node 0x%lx\n", (unsigned long)node);
#endif
if ((rc = cfg_node_get(cfg, node, CFG_NODE_ATTR_CHILD1, &node)) == CFG_OK && node != NULL) {
do {
if ((rc = cfg_node_get(cfg, node, CFG_NODE_ATTR_TOKEN, &token)) != CFG_OK)
continue;
if ((rc = cfg_node_get(cfg, node, CFG_NODE_ATTR_TYPE, &type)) == CFG_OK && type == CFG_NODE_TYPE_DIR) {
if ((rc = cfg_node_get(cfg, node, CFG_NODE_ATTR_CHILD1, &node2)) != CFG_OK || node2 == NULL)
continue;
if ((rc = cfg_node_get(cfg, node2, CFG_NODE_ATTR_TOKEN, &token)) != CFG_OK)
continue;
}
if (token != NULL) {
size_t l = strlen(token);
#if 0
fprintf(stderr, " step2: compare child node: token \"%s\"\n", token);
#endif
if ( (l == 1 && nSel == 1 && token[0] == '*')
|| (l == nSel && strncmp(token, cpSel, nSel) == 0)) {
if ((rc = cfg_node_select_step3(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, nFound)) != CFG_OK)
return rc;
}
}
} while ((rc = cfg_node_get(cfg, node, CFG_NODE_ATTR_RBROTH, &node)) == CFG_OK && node != NULL);
}
return CFG_OK;
}
return rc;
}
/* INTERNAL: selection stepping function (part 1, selection parsing) */
static cfg_rc_t
cfg_node_select_step1(
cfg_t *cfg,
cfg_node_t *node,
cfg_node_t ***result_vec, long *result_len,
const char *spec)
{
const char *cpSel; size_t nSel;
long nFilMin, nFilMax;
long n;
const char *cp;
char *cp2;
cfg_rc_t rc;
long nFound;
#if 0
fprintf(stderr, " step1: (0) spec=\"%s\"\n", spec);
#endif
/* stop processing if spec is empty */
if (spec[0] == '\0')
return CFG_OK;
/* determine selection step information */
cpSel = spec;
nSel = strcspn(cpSel, "[/");
cp = cpSel+nSel;
nFilMin = 1;
nFilMax = LONG_MAX;
if (*cp == '[') {
cp++;
n = strtol(cp, &cp2, 10);
if (cp2 > cp && n != 0)
nFilMin = n;
cp = cp2;
if (*cp == ',') {
cp++;
n = strtol(cp, &cp2, 10);
if (cp2 > cp && n != 0)
nFilMax = n;
cp = cp2;
}
else
nFilMax = nFilMin;
if (*cp != ']') {
cfg_error_info(cfg, CFG_ERR_ARG, "invalid selection specification filter range");
return CFG_ERR_ARG;
}
cp++;
}
if (*cp == '/')
cp++;
spec = cp;
#if 0
fprintf(stderr, " step1: (1) cpSel=\"%s\", nSel=%d, spec=\"%s\", nFilMin=%ld, nFilMax=%ld\n",
cpSel, nSel, spec, nFilMin, nFilMax);
#endif
/* perform pre-selection if filter range is relative to last element */
if (nFilMin < 0 || nFilMax < 0) {
nFound = 0;
#if 0
fprintf(stderr, " step1: pre-selection start\n");
#endif
if ((rc = cfg_node_select_step2(cfg, node, NULL, NULL, spec, cpSel, nSel, 1, LONG_MAX, &nFound)) != CFG_OK)
return rc;
#if 0
fprintf(stderr, " step1: (1b) cpSel=\"%s\", nSel=%d, spec=\"%s\", nFilMin=%ld, nFilMax=%ld nFound=%ld\n",
cpSel, nSel, spec, nFilMin, nFilMax, nFound);
fprintf(stderr, " step1: pre-selection end\n");
#endif
if (nFound == 0)
return CFG_OK;
if (nFilMin < 0) {
nFilMin = nFound + (nFilMin+1);
if (nFilMin < 1)
nFilMin = 1;
}
if (nFilMax < 0) {
nFilMax = nFound + (nFilMax+1);
if (nFilMax < 1)
nFilMax = 1;
}
}
#if 0
fprintf(stderr, " step1: (2) cpSel=\"%s\", nSel=%d, spec=\"%s\", nFilMin=%ld, nFilMax=%ld\n",
cpSel, nSel, spec, nFilMin, nFilMax);
#endif
/* perform real selection */
nFound = 0;
if ((rc = cfg_node_select_step2(cfg, node, result_vec, result_len, spec, cpSel, nSel, nFilMin, nFilMax, &nFound)) != CFG_OK)
return rc;
#if 0
fprintf(stderr, " step1: (3) cpSel=\"%s\", nSel=%d, spec=\"%s\", nFilMin=%ld, nFilMax=%ld nFound=%ld\n",
cpSel, nSel, spec, nFilMin, nFilMax, nFound);
#endif
return CFG_OK;
}
/* select a node */
cfg_rc_t
cfg_node_select(
cfg_t *cfg,
cfg_node_t *node,
cfg_node_t ***result_vec,
const char *fmt,
...)
{
cfg_rc_t rc;
va_list ap;
char *spec;
char *cp;
long result_len;
/* argument sanity checking */
if (cfg == NULL || result_vec == NULL || fmt == NULL)
return CFG_ERR_ARG;
/* on-the-fly create or just take over specification string */
va_start(ap, fmt);
spec = cfg_fmt_vasprintf(fmt, ap);
va_end(ap);
if (spec == NULL)
return CFG_ERR_FMT;
#if 0
fprintf(stderr, "select: (1) spec=\"%s\"\n", spec);
#endif
/* special cases for absolute (start from root-node) selection */
cp = spec;
if (cp[0] == '/') {
/* <any,"/x"> is same as <root,"x"> */
if (node != NULL)
return CFG_ERR_USE;
node = cfg->root;
cp++;
}
else if (node == NULL) {
/* <NULL, "..."> is same as <root, "..."> */
node = cfg->root;
}
#if 0
fprintf(stderr, "select: (2) spec=\"%s\"\n", cp);
#endif
/* initialize result node array */
result_len = 0;
if ((*result_vec = (cfg_node_t **)malloc(sizeof(cfg_node_t *)*(result_len+1))) == NULL)
return CFG_ERR_SYS;
(*result_vec)[result_len] = NULL;
/* perform the selection stepping */
if ((rc = cfg_node_select_step1(cfg, node, result_vec, &result_len, cp)) != CFG_OK) {
free(*result_vec);
return rc;
}
#if 0
fprintf(stderr, "select: (3) result_len=%ld\n", result_len);
#endif
return CFG_OK;
}
/* return next matching node (iteration) */
cfg_rc_t
cfg_node_find(
cfg_t *cfg,
cfg_node_t *node,
cfg_rc_t (*cb_fct_cmp)(cfg_t *, cfg_node_t *, void *),
void *cb_ctx_cmp,
cfg_node_t **cont)
{
/* FIXME */
return CFG_ERR_INT;
}
/* apply for each matching node (recursion) */
cfg_rc_t
cfg_node_apply(
cfg_t *cfg,
cfg_node_t *node,
cfg_rc_t (*cb_fct_cmp)(cfg_t *, cfg_node_t *, void *),
void *cb_ctx_cmp,
cfg_rc_t (*cb_fct_cb)(cfg_t *, cfg_node_t *, void *),
void *cb_ctx_cb)
{
cfg_rc_t rc;
cfg_node_t *child1;
cfg_node_t *rbroth;
/* argument sanity checking */
if (cfg == NULL)
return CFG_ERR_ARG;
/* short-circuit processing */
if (node == NULL)
return CFG_OK;
/* remember traversing informations from child and brother
(important in case the callbacks destroy it) */
child1 = node->child1;
rbroth = node->rbroth;
/* check whether the node matches */
if (cb_fct_cmp != NULL)
rc = cb_fct_cmp(cfg, node, cb_ctx_cmp);
else
rc = CFG_OK;
/* if node matched, apply optional callback on node */
if (rc == CFG_OK && cb_fct_cb != NULL)
if ((rc = cb_fct_cb(cfg, node, cb_ctx_cb)) != CFG_OK)
return rc;
/* recursively apply on child and brother nodes */
if (child1 != NULL)
if ((rc = cfg_node_apply(cfg, child1,
cb_fct_cmp, cb_ctx_cmp,
cb_fct_cb, cb_ctx_cb)) != CFG_OK)
return rc;
if (rbroth != NULL)
if ((rc = cfg_node_apply(cfg, rbroth,
cb_fct_cmp, cb_ctx_cmp,
cb_fct_cb, cb_ctx_cb)) != CFG_OK)
return rc;
return CFG_OK;
}
/* compare two nodes */
cfg_rc_t
cfg_node_cmp(
cfg_t *cfg,
cfg_node_t *node,
void *token)
{
/* argument sanity checking */
if (cfg == NULL || node == NULL || token == NULL)
return CFG_ERR_NDE;
if (node->token == NULL && token == NULL)
return CFG_OK;
if (node->token == NULL || token == NULL)
return CFG_ERR_NDE;
if (strcmp(node->token, (char *)token) == 0)
return CFG_OK;
return CFG_ERR_NDE;
}
/* link to nodes together */
cfg_rc_t
cfg_node_link(
cfg_t *cfg,
cfg_node_t *node,
cfg_node_attr_t attr,
cfg_node_t *node2)
{
cfg_node_t *n;
/* argument sanity checking */
if (node == NULL || node2 == NULL)
return CFG_ERR_ARG;
if (attr == CFG_NODE_ATTR_RBROTH) {
/* make node a rbroth */
n = node2;
n->parent = node->parent;
while (n->rbroth != NULL) {
n->parent = node->parent;
n = n->rbroth;
}
n->rbroth = node->rbroth;
node->rbroth = node2;
}
else if (attr == CFG_NODE_ATTR_CHILD1) {
/* make node a child1 */
n = node2;
n->parent = node;
while (n->rbroth != NULL) {
n->parent = node;
n = n->rbroth;
}
n->rbroth = node->child1;
node->child1 = node2;
}
/* FIXME more linkage possibilities */
else
return CFG_ERR_ARG;
return CFG_OK;
}
/* unlink a node from others */
cfg_rc_t
cfg_node_unlink(
cfg_t *cfg,
cfg_node_t *node)
{
cfg_node_t *n;
/* argument sanity checking */
if (node == NULL)
return CFG_ERR_ARG;
if (node->parent == NULL)
return CFG_OK;
if (node->parent->child1 == node) {
/* node was a child1 */
node->parent->child1 = node->rbroth;
}
else {
/* node was a rbroth */
n = node->parent->child1;
while (n->rbroth != node)
n = n->rbroth;
n->rbroth = node->rbroth;
}
return CFG_OK;
}
