ln_ctx
ln_initCtx(void)
{
ln_ctx ctx;
if((ctx = calloc(1, sizeof(struct ln_ctx_s))) == NULL)
goto done;
ctx->objID = LN_ObjID_CTX;
ctx->dbgCB = NULL;
/* we add an root for the empty word, this simplifies parse
* tree handling.
*/
if((ctx->ptree = ln_newPTree(ctx, NULL)) == NULL) {
free(ctx);
ctx = NULL;
goto done;
}
/* same for annotation set */
if((ctx->pas = ln_newAnnotSet(ctx)) == NULL) {
ln_deletePTree(ctx->ptree);
free(ctx);
ctx = NULL;
goto done;
}
done:
return ctx;
}
/**
* Split the provided tree (node) into two at the provided index into its
* common prefix. This function exists to support splitting nodes when
* a mismatch in the common prefix requires that. This function more or less
* keeps the tree as it is, just changes the structure. No new node is added.
* Usually, it is desired to add a new node. This must be made afterwards.
* Note that we need to create a new tree *in front of* the current one, as
* the current one contains field etc. subtree pointers.
* @param[in] tree tree to split
* @param[in] offs offset into common prefix (must be less than prefix length!)
*/
static inline struct ln_ptree*
splitTree(struct ln_ptree *tree, unsigned short offs)
{
unsigned char *c;
struct ln_ptree *r;
unsigned short newlen;
ln_ptree **newparentptr; /**< pointer in parent that needs to be updated */
assert(offs < tree->lenPrefix);
if((r = ln_newPTree(tree->ctx, tree->parentptr)) == NULL)
goto done;
ln_dbgprintf(tree->ctx, "splitTree %p at offs %u", tree, offs);
/* note: the overall prefix is reduced by one char, which is now taken
* care of inside the "branch table".
*/
c = prefixBase(tree);
//ln_dbgprintf(tree->ctx, "splitTree new bb, *(c+offs): '%s'", c);
if(setPrefix(r, c, offs, 0) != 0) {
ln_deletePTree(r);
r = NULL;
goto done; /* fail! */
}
ln_dbgprintf(tree->ctx, "splitTree new tree %p lenPrefix=%u, char '%c'", r, r->lenPrefix, r->prefix.data[0]);
/* add the proper branch table entry for the new node. must be done
* here, because the next step will destroy the required index char!
*/
newparentptr = &(r->subtree[c[offs]]);
r->subtree[c[offs]] = tree;
/* finally fix existing common prefix */
newlen = tree->lenPrefix - offs - 1;
if(tree->lenPrefix > sizeof(tree->prefix) && (newlen <= sizeof(tree->prefix))) {
/* note: c is a different pointer; the original
* pointer is overwritten by memcpy! */
ln_dbgprintf(tree->ctx, "splitTree new case one bb, offs %u, lenPrefix %u, newlen %u", offs, tree->lenPrefix, newlen);
//ln_dbgprintf(tree->ctx, "splitTree new case one bb, *(c+offs): '%s'", c);
memcpy(tree->prefix.data, c+offs+1, newlen);
free(c);
} else {
ln_dbgprintf(tree->ctx, "splitTree new case two bb, offs=%u, newlen %u", offs, newlen);
memmove(c, c+offs+1, newlen);
}
tree->lenPrefix = tree->lenPrefix - offs - 1;
if(tree->parentptr == 0)
tree->ctx->ptree = r; /* root does not have a parent! */
else
*(tree->parentptr) = r;
tree->parentptr = newparentptr;
done: return r;
}
ln_ctx
ln_v1_inherittedCtx(ln_ctx parent)
{
ln_ctx child = ln_initCtx();
if (child != NULL) {
child->allowRegex = parent->allowRegex;
child->dbgCB = parent->dbgCB;
child->dbgCookie = parent->dbgCookie;
child->version = parent->version;
child->ptree = ln_newPTree(child, NULL);
}
return child;
}
int
ln_addFDescrToPTree(struct ln_ptree **tree, ln_fieldList_t *node)
{
int r;
ln_fieldList_t *curr;
assert(tree != NULL);assert(*tree != NULL);
assert(node != NULL);
if((node->subtree = ln_newPTree((*tree)->ctx, &node->subtree)) == NULL) {
r = -1;
goto done;
}
ln_dbgprintf((*tree)->ctx, "got new subtree %p", node->subtree);
/* check if we already have this field, if so, merge
* TODO: optimized, check logic
*/
for(curr = (*tree)->froot ; curr != NULL ; curr = curr->next) {
if(!es_strcmp(curr->name, node->name)
&& curr->parser == node->parser
&& ((curr->raw_data == NULL && node->raw_data == NULL)
|| (curr->raw_data != NULL && node->raw_data != NULL
&& !es_strcmp(curr->raw_data, node->raw_data)))) {
*tree = curr->subtree;
ln_deletePTreeNode(node);
r = 0;
ln_dbgprintf((*tree)->ctx, "merging with tree %p\n", *tree);
goto done;
}
}
if((*tree)->froot == NULL) {
(*tree)->froot = (*tree)->ftail = node;
} else {
(*tree)->ftail->next = node;
(*tree)->ftail = node;
}
r = 0;
ln_dbgprintf((*tree)->ctx, "prev subtree %p", *tree);
*tree = node->subtree;
ln_dbgprintf((*tree)->ctx, "new subtree %p", *tree);
done: return r;
}
struct ln_ptree *
ln_addPTree(struct ln_ptree *tree, es_str_t *str, size_t offs)
{
struct ln_ptree *r;
struct ln_ptree **parentptr; /**< pointer in parent that needs to be updated */
ln_dbgprintf(tree->ctx, "addPTree: offs %zu", offs);
parentptr = &(tree->subtree[es_getBufAddr(str)[offs]]);
/* First check if tree node is totaly empty. If so, we can simply add
* the prefix to this node. This case is important, because it happens
* every time with a new field.
*/
if(isTrueLeaf(tree)) {
if(setPrefix(tree, es_getBufAddr(str), es_strlen(str), offs) != 0) {
r = NULL;
} else {
r = tree;
}
goto done;
}
if(tree->ctx->debug) {
char *cstr = es_str2cstr(str, NULL);
ln_dbgprintf(tree->ctx, "addPTree: add '%s', offs %zu, tree %p",
cstr + offs, offs, tree);
free(cstr);
}
if((r = ln_newPTree(tree->ctx, parentptr)) == NULL)
goto done;
if(setPrefix(r, es_getBufAddr(str) + offs + 1, es_strlen(str) - offs - 1, 0) != 0) {
free(r);
r = NULL;
goto done;
}
*parentptr = r;
done: return r;
}
