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;
}
/* construct from es_str_t string
* rgerhards 2010-12-03
*/
rsRetVal cstrConstructFromESStr(cstr_t **ppThis, es_str_t *str)
{
DEFiRet;
cstr_t *pThis;
assert(ppThis != NULL);
CHKiRet(rsCStrConstruct(&pThis));
pThis->iBufSize = pThis->iStrLen = es_strlen(str);
if((pThis->pBuf = (uchar*) MALLOC(sizeof(uchar) * pThis->iStrLen)) == NULL) {
RSFREEOBJ(pThis);
ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
}
/* we do NOT need to copy the \0! */
memcpy(pThis->pBuf, es_getBufAddr(str), pThis->iStrLen);
*ppThis = pThis;
finalize_it:
RETiRet;
}
int *const iParams, es_str_t *const param_binary)
{
es_size_t iCnt;
es_size_t iStr;
int iPrm;
es_str_t *estrParams = NULL;
es_str_t *estrBinary = param_binary;
es_str_t *estrTmp = NULL;
uchar *c;
int bInQuotes;
DEFiRet;
assert(iParams != NULL);
assert(param_binary != NULL);
/* Search for end of binary name */
c = es_getBufAddr(param_binary);
iCnt = 0;
while(iCnt < es_strlen(param_binary) ) {
if (c[iCnt] == ' ') {
/* Split binary name from parameters */
estrBinary = es_newStrFromSubStr( param_binary, 0, iCnt);
estrParams = es_newStrFromSubStr( param_binary, iCnt+1,
es_strlen(param_binary));
break;
}
iCnt++;
}
*szBinary = (uchar*)es_str2cstr(estrBinary, NULL);
DBGPRINTF("szBinary = '%s'\n", *szBinary);
*iParams = 2; /* we always have argv[0], and NULL-terminator for array */
struct ln_ptree *
ln_buildPTree(struct ln_ptree *tree, es_str_t *str, size_t offs)
{
struct ln_ptree *r;
unsigned char *c;
unsigned char *cpfix;
size_t i;
unsigned short ipfix;
assert(tree != NULL);
ln_dbgprintf(tree->ctx, "buildPTree: begin at %p, offs %zu", tree, offs);
c = es_getBufAddr(str);
/* check if the prefix matches and, if not, at what offset it is different */
ipfix = 0;
cpfix = prefixBase(tree);
for( i = offs
; (i < es_strlen(str)) && (ipfix < tree->lenPrefix) && (c[i] == cpfix[ipfix])
; ++i, ++ipfix) {
; /*DO NOTHING - just find end of match */
ln_dbgprintf(tree->ctx, "buildPTree: tree %p, i %zu, char '%c'", tree, i, c[i]);
}
/* if we reach this point, we have processed as much of the common prefix
* as we could. The following code now does the proper actions based on
* the possible cases.
*/
if(i == es_strlen(str)) {
/* all of our input is consumed, no more recursion */
if(ipfix == tree->lenPrefix) {
ln_dbgprintf(tree->ctx, "case 1.1");
/* exact match, we are done! */
r = tree;
} else {
ln_dbgprintf(tree->ctx, "case 1.2");
/* we need to split the node at the current position */
r = splitTree(tree, ipfix);
}
} else if(ipfix < tree->lenPrefix) {
ln_dbgprintf(tree->ctx, "case 2, i=%zu, ipfix=%u", i, ipfix);
/* we need to split the node at the current position */
if((r = splitTree(tree, ipfix)) == NULL)
goto done; /* fail */
ln_dbgprintf(tree->ctx, "pre addPTree: i %zu", i);
if((r = ln_addPTree(r, str, i)) == NULL)
goto done;
//r = ln_buildPTree(r, str, i + 1);
} else {
/* we could consume the current common prefix, but now need
* to traverse the rest of the tree based on the next char.
*/
if(tree->subtree[c[i]] == NULL) {
ln_dbgprintf(tree->ctx, "case 3.1");
/* non-match, need new subtree */
r = ln_addPTree(tree, str, i);
} else {
ln_dbgprintf(tree->ctx, "case 3.2");
/* match, follow subtree */
r = ln_buildPTree(tree->subtree[c[i]], str, i + 1);
}
}
//ln_dbgprintf(tree->ctx, "---------------------------------------");
//ln_displayPTree(tree, 0);
//ln_dbgprintf(tree->ctx, "=======================================");
done: return r;
}
/* TODO: JSON encoding for Unicode characters is as of RFC4627 not fully
* supported. The algorithm is that we must build the wide character from
* UTF-8 (if char > 127) and build the full 4-octet Unicode character out
* of it. Then, this needs to be encoded. Currently, we work on a
* byte-by-byte basis, which simply is incorrect.
* rgerhards, 2010-11-09
*/
int
ee_addValue_JSON(struct ee_value *value, es_str_t **str)
{
int r;
es_str_t *valstr;
unsigned char *buf;
unsigned char c;
es_size_t i;
char numbuf[4];
int j;
assert(str != NULL); assert(*str != NULL);
assert(value != NULL); assert(value->objID == ObjID_VALUE);
// TODO: support other types!
assert(value->valtype == ee_valtype_str);
valstr = value->val.str;
es_addChar(str, '\"');
buf = es_getBufAddr(valstr);
for(i = 0 ; i < es_strlen(valstr) ; ++i) {
c = buf[i];
if( (c >= 0x23 && c <= 0x5b)
|| (c >= 0x5d /* && c <= 0x10FFFF*/)
|| c == 0x20 || c == 0x21) {
/* no need to escape */
es_addChar(str, c);
} else {
/* we must escape, try RFC4627-defined special sequences first */
switch(c) {
case '\0':
es_addBuf(str, "\\u0000", 6);
break;
case '\"':
es_addBuf(str, "\\\"", 2);
break;
case '/':
es_addBuf(str, "\\/", 2);
break;
case '\\':
es_addBuf(str, "\\\\", 2);
break;
case '\010':
es_addBuf(str, "\\b", 2);
break;
case '\014':
es_addBuf(str, "\\f", 2);
break;
case '\n':
es_addBuf(str, "\\n", 2);
break;
case '\r':
es_addBuf(str, "\\r", 2);
break;
case '\t':
es_addBuf(str, "\\t", 2);
break;
default:
/* TODO : proper Unicode encoding (see header comment) */
for(j = 0 ; j < 4 ; ++j) {
numbuf[3-j] = hexdigit[c % 16];
c = c / 16;
}
es_addBuf(str, "\\u", 2);
es_addBuf(str, numbuf, 4);
break;
}
}
}
es_addChar(str, '\"');
r = 0;
return r;
}
