/**
* Fill cache entry structure with value data, marking it dirty and present.
*/
static void
fill_entry(const dbmw_t *dw,
struct cached *entry, gpointer value, size_t length)
{
/*
* Try to reuse old entry arena if same size.
*
* Also handle case where value points to the cached entry data, since
* that is likely to be the case when invoked from dbmw_write() (they
* issued a dbmw_read() before and changed the deserialized value from
* the cache).
*/
if (length != (size_t) entry->len) {
gpointer arena = NULL;
if (length)
arena = wcopy(value, length);
free_value(dw, entry, TRUE);
entry->data = arena;
entry->len = length;
} else if (value != entry->data && length) {
free_value(dw, entry, FALSE);
memcpy(entry->data, value, length);
}
entry->dirty = TRUE;
entry->absent = FALSE;
g_assert(!entry->len == !entry->data);
}
/* Parse and evaluate match (regex) expressions */
struct val *
eval5(void)
{
regex_t rp;
regmatch_t rm[2];
char errbuf[256];
int eval;
struct val *l, *r;
struct val *v;
l = eval6();
while (token == MATCH) {
nexttoken(1);
r = eval6();
/* coerce to both arguments to strings */
to_string(l);
to_string(r);
/* compile regular expression */
if ((eval = regcomp(&rp, r->u.s, 0)) != 0) {
regerror(eval, &rp, errbuf, sizeof(errbuf));
errx(2, "%s", errbuf);
}
/* compare string against pattern -- remember that patterns
are anchored to the beginning of the line */
if (regexec(&rp, l->u.s, 2, rm, 0) == 0 && rm[0].rm_so == 0) {
if (rm[1].rm_so >= 0) {
*(l->u.s + rm[1].rm_eo) = '\0';
v = make_str(l->u.s + rm[1].rm_so);
} else {
v = make_int((int)(rm[0].rm_eo - rm[0].rm_so));
}
} else {
if (rp.re_nsub == 0) {
v = make_int(0);
} else {
v = make_str("");
}
}
/* free arguments and pattern buffer */
free_value(l);
free_value(r);
regfree(&rp);
l = v;
}
return l;
}
read_and_parse()
{
#define BUFLEN 512
char buf[BUFLEN]; /* this will have to be dynamically expanded */
int bufpos = 0;
int ret;
Value *v = NULL;
Value *match_data;
Value *pattern = vmake_cons(vmake_symbol_c("integer"),
vmake_var(integer, (void **) &match_data));
while (1) {
ret = read(0, buf + bufpos, BUFLEN - bufpos);
if (ret < 0) {
perror("read");
exit(1);
}
else {
bufpos += ret;
do {
if (v != NULL) {
free_value(v);
v = NULL;
}
ret = parse(bufpos, buf, &v);
if (ret > 0) {
bcopy(buf + ret, buf, bufpos - ret);
bufpos -= ret;
printf("parsed: ");
prin(stdout, v);
fputc('\n', stdout);
if (destructure(pattern, v)) {
printf("match_data = ");
prin(stdout, match_data);
fputc('\n', stdout);
}
else {
printf("destructure failed\n");
}
free_value(v);
}
else
printf("EOF\n");
} while (ret > 0);
}
}
}
static int
_sc_free(void *config)
{
struct node *n, *nlist;
struct value *v, *vlist;
if (!config)
return -1;
vlist = ((struct parser_context *)config)->val_list;
nlist = ((struct parser_context *)config)->node_list;
while (nlist) {
n = nlist;
nlist = nlist->next;
_sc_free_node(n);
}
((struct parser_context *)config)->node_list = NULL;
while (vlist) {
v = vlist;
vlist = vlist->next;
free_value(v);
}
((struct parser_context *)config)->val_list = NULL;
free(config);
return 0;
}
enum update_type genhash_fun_update(genhash_t* h, const void* k, size_t klen,
void *(*upd)(const void *, const void *,
size_t *, void *),
void (*fr)(void*),
void *arg,
const void *def, size_t deflen)
{
struct genhash_entry_t *p;
enum update_type rv=0;
size_t newSize = 0;
(void)deflen;
p=genhash_find_entry(h, k, klen);
if(p) {
void *newValue=upd(k, p->value, &newSize, arg);
free_value(h, p->value);
p->value=dup_value(h, newValue, newSize);
fr(newValue);
rv=MODIFICATION;
} else {
void *newValue=upd(k, def, &newSize, arg);
genhash_store(h, k, klen, newValue, newSize);
fr(newValue);
rv=NEW;
}
return rv;
}
static void free_item(genhash_t *h, struct genhash_entry_t *i)
{
cb_assert(i);
free_key(h, i->key);
free_value(h, i->value);
free(i);
}
void
free_select_query (select_query *q)
{
if (q->c) {
// free the columns
free_value_array(q->c);
}
if (q->where_condition) {
free_condition(q->where_condition);
}
if (q->group_by) {
free_groupby_clause(q->group_by);
}
if (q->into_clause) {
free_value(q->into_clause->target);
free(q->into_clause);
}
if (q->from_clause) {
// free the from clause
free_from_clause(q->from_clause);
}
}
/* Parse and evaluate addition and subtraction expressions */
struct val *
eval3(void)
{
struct val *l, *r;
enum token op;
l = eval4();
while ((op = token) == ADD || op == SUB) {
nexttoken(0);
r = eval4();
if (!to_integer(l) || !to_integer(r)) {
errx(2, "non-numeric argument");
}
if (op == ADD) {
l->u.i += r->u.i;
} else {
l->u.i -= r->u.i;
}
free_value(r);
}
return l;
}
void
close_query (query *q)
{
if (q->select_query) {
free_select_query(q->select_query);
free(q->select_query);
}
if (q->list_series_query) {
if (q->list_series_query->has_regex)
free_value(q->list_series_query->regex);
free(q->list_series_query);
}
if (q->drop_series_query) {
free_drop_series_query(q->drop_series_query);
free(q->drop_series_query);
}
if (q->drop_query) {
free(q->drop_query);
}
if (q->delete_query) {
free_delete_query(q->delete_query);
free(q->delete_query);
}
}
/**
* Remove cached entry for key, optionally disposing of the whole structure.
* Cached entry is flushed if it was dirty and flush is set.
*
* @return the reusable cached entry if dispose was FALSE and the key was
* indeed cached, NULL otherwise.
*/
static struct cached *
remove_entry(dbmw_t *dw, gconstpointer key, gboolean dispose, gboolean flush)
{
struct cached *old;
gpointer old_key;
gboolean found;
found = map_lookup_extended(dw->values, key, &old_key, (gpointer) &old);
if (!found)
return NULL;
g_assert(old != NULL);
if (old->dirty && flush)
write_back(dw, key, old);
hash_list_remove(dw->keys, key);
map_remove(dw->values, key);
wfree(old_key, dbmw_keylen(dw, old_key));
if (!dispose)
return old;
/*
* Dispose of the cache structure.
*/
free_value(dw, old, TRUE);
WFREE(old);
return NULL;
}
void free_value(Value *v)
{
switch(VTAG(v)) {
case cons:
free_value(v->value.cons.car);
free_value(v->value.cons.cdr);
break;
case string:
case symbol:
free(v->value.s.string);
break;
default:
break;
}
free(v);
}
/* Parse and evaluate multiplication and division expressions */
struct val *
eval4(void)
{
struct val *l, *r;
enum token op;
l = eval5();
while ((op = token) == MUL || op == DIV || op == MOD) {
nexttoken(0);
r = eval5();
if (!to_integer(l) || !to_integer(r)) {
errx(2, "non-numeric argument");
}
if (op == MUL) {
l->u.i *= r->u.i;
} else {
if (r->u.i == 0) {
errx(2, "division by zero");
}
if (op == DIV) {
l->u.i /= r->u.i;
} else {
l->u.i %= r->u.i;
}
}
free_value(r);
}
return l;
}
static void
_sc_free_node(struct node *node)
{
struct node *n;
struct value *v;
int x;
if (!node)
return;
while (node->nodes) {
n = node->nodes;
if (n) {
node->nodes = node->nodes->next;
_sc_free_node(n);
}
}
while (node->values) {
v = node->values;
node->values = node->values->next;
free_value(v);
}
free(node->id);
free(node);
}
static int
parse_primary_expr(int need_eval, cfg_cond_value_t *prv)
{
int r;
while (parsecfg_state.raw.s[parsecfg_state.raw_i] > 0 && parsecfg_state.raw.s[parsecfg_state.raw_i] <= ' ') parsecfg_state.raw_i++;
if (parsecfg_state.raw.s[parsecfg_state.raw_i] == '(') {
parsecfg_state.raw_i++;
if ((r = parse_conditional_expr(need_eval, prv)) < 0) return -1;
while (parsecfg_state.raw.s[parsecfg_state.raw_i] > 0 && parsecfg_state.raw.s[parsecfg_state.raw_i] <= ' ') parsecfg_state.raw_i++;
if (parsecfg_state.raw.s[parsecfg_state.raw_i] != ')') {
fprintf(stderr, "%d: ')' expected\n", parsecfg_state.lineno);
if (need_eval) free_value(prv);
return -1;
}
parsecfg_state.raw_i++;
return r;
} else if (parsecfg_state.raw.s[parsecfg_state.raw_i] == '\"') {
return parse_string(need_eval, prv);
} else if (isalpha(parsecfg_state.raw.s[parsecfg_state.raw_i]) || parsecfg_state.raw.s[parsecfg_state.raw_i] == '_') {
return parse_ident(need_eval, prv);
} else if (isdigit(parsecfg_state.raw.s[parsecfg_state.raw_i])) {
return parse_number(need_eval, prv);
}
fprintf(stderr, "%d: primary expression expected\n", parsecfg_state.lineno);
return -1;
}
void
free_from_clause(from_clause *f)
{
if (f->names)
free_table_name_array(f->names);
if (f->regex_value)
free_value(f->regex_value);
free(f);
}
void
free_groupby_clause(groupby_clause *g)
{
free_value_array(g->elems);
if (g->fill_function) {
free_value(g->fill_function);
}
free(g);
}
void
free_value_array(value_array *array)
{
int i;
for (i = 0; i < array->size; i++)
free_value(array->elems[i]);
free(array->elems);
free(array);
}
static int
parse_equality_expr(int need_eval, cfg_cond_value_t *prv)
{
cfg_cond_value_t v1, v2;
int op;
if (parse_relational_expr(need_eval, &v1) < 0) return -1;
if (need_eval) *prv = v1;
while (1) {
while (parsecfg_state.raw.s[parsecfg_state.raw_i] > 0 && parsecfg_state.raw.s[parsecfg_state.raw_i] <= ' ') parsecfg_state.raw_i++;
if ((parsecfg_state.raw.s[parsecfg_state.raw_i] != '=' && parsecfg_state.raw.s[parsecfg_state.raw_i] != '!')
|| parsecfg_state.raw.s[parsecfg_state.raw_i + 1] != '=')
break;
if (parsecfg_state.raw.s[parsecfg_state.raw_i] == '=') op = 0;
else op = 1;
parsecfg_state.raw_i += 2;
while (parsecfg_state.raw.s[parsecfg_state.raw_i] > 0 && parsecfg_state.raw.s[parsecfg_state.raw_i] <= ' ') parsecfg_state.raw_i++;
if (parse_relational_expr(need_eval, &v2) < 0) {
if (need_eval) free_value(prv);
return -1;
}
if (need_eval) {
if (prv->tag != v2.tag) {
fprintf(stderr, "%d: type mismatch in expression\n", parsecfg_state.lineno);
free_value(prv);
free_value(&v2);
return -1;
}
XMEMZERO(&v1, 1);
v1.tag = CV_LONG;
if (prv->tag == CV_LONG) {
switch (op) {
case 0: v1.l.val = (prv->l.val == v2.l.val); break;
case 1: v1.l.val = (prv->l.val != v2.l.val); break;
default:
abort();
}
} else if (prv->tag == CV_STRING) {
switch (op) {
case 0: v1.l.val = (strcmp(prv->s.str, v2.s.str) == 0); break;
case 1: v1.l.val = (strcmp(prv->s.str, v2.s.str) != 0); break;
default:
abort();
}
} else {
fprintf(stderr, "%d: invalid type in expression\n", parsecfg_state.lineno);
free_value(prv);
free_value(&v2);
return -1;
}
free_value(prv);
free_value(&v2);
*prv = v1;
}
}
return 0;
}
void
free_expression(expression *expr)
{
if (expr->op == 0) {
free_value((value*)expr->left);
} else {
free_expression((expression*) expr->left);
free_expression(expr->right);
}
free(expr);
}
/* Parse and evaluate | expressions */
struct val *
eval0(void)
{
struct val *l, *r;
l = eval1();
while (token == OR) {
nexttoken(0);
r = eval1();
if (is_zero_or_null(l)) {
free_value(l);
l = r;
} else {
free_value(r);
}
}
return l;
}
void
free_condition(condition *condition)
{
if (condition->is_bool_expression) {
free_value((value*) condition->left);
} else {
free_condition(condition->left);
free_condition(condition->right);
}
free(condition);
}
void HandlerManager::releaseValue(uint16_t valueRelease)
{
// _mutex_left_value.lock();
// Verify if the value is in the current window
if ((leftValue <= lastGivenValue) && (lastGivenValue <= MAX_HANDLER)){
if ((leftValue <= valueRelease) && (valueRelease <= lastGivenValue)){
free_value(valueRelease);
}
// Discard becuase the value given is not in the current window.
}
if (lastGivenValue < leftValue){
if ((leftValue <= valueRelease) && (valueRelease <= MAX_HANDLER)){
free_value(valueRelease);
}
if ((0 <= valueRelease ) && (valueRelease <= lastGivenValue)){
free_value(valueRelease);
}
}
// _mutex_left_value.unlock();
}
/**
* Free a value_t pointer, as well as any data stored within it. Container types
* will be recursively freed.
* @param value value_t pointer to free
*/
void free_value(value_t *value) {
list_t *listval, *cur, *temp;
hashtable_t *hashval;
hashtable_itr_t *itr;
value_t *tempv;
switch(value->type) {
case INTTYPE:
case BOOLTYPE:
case LONGTYPE:
case DOUBLETYPE:
break;
case STRINGTYPE:
case REFTYPE:
free(value->value.s);
break;
case INVOTYPE:
free(value->value.v->name);
tempv = encap_hash(value->value.v->params);
free_value(tempv);
break;
case LISTTYPE:
listval = value->value.l;
list_for_each_safe(cur, temp, listval) {
free_value((value_t*)cur->item);
free(cur);
}
free(listval);
break;
case DICTTYPE:
hashval = value->value.h;
if (hashtable_count(hashval) > 0) {
itr = hashtable_iterator(hashval);
do {
free_value((value_t*)hashtable_iterator_value(itr));
} while (hashtable_iterator_advance(itr));
free(itr);
}
hashtable_destroy(hashval, 0);
break;
}
/* Parse and evaluate & expressions */
struct val *
eval1(void)
{
struct val *l, *r;
l = eval2();
while (token == AND) {
nexttoken(0);
r = eval2();
if (is_zero_or_null(l) || is_zero_or_null(r)) {
free_value(l);
free_value(r);
l = make_int(0);
} else {
free_value(r);
}
}
return l;
}
std::string __xmlcontext::get_Content()
{
char *p = (char*)xmlNodeGetContent(xml_node_);
if (p == NULL)
{
return "";
}
std::string str(p);
free_value(p);
return str;
}
static int
parse_logical_AND_expr(int need_eval, cfg_cond_value_t *prv)
{
cfg_cond_value_t v1, v2;
int b = 0, r;
if ((r = parse_OR_expr(need_eval, &v1)) < 0) return -1;
if (need_eval) {
while (parsecfg_state.raw.s[parsecfg_state.raw_i] > 0 && parsecfg_state.raw.s[parsecfg_state.raw_i] <= ' ') parsecfg_state.raw_i++;
if (parsecfg_state.raw.s[parsecfg_state.raw_i] != '&' || parsecfg_state.raw.s[parsecfg_state.raw_i + 1] != '&') {
*prv = v1;
return r;
}
if (!convert_to_bool(&v1)) {
set_bool_value(prv, 0);
b = 0;
need_eval = 0;
free_value(&v1);
}
}
while (1) {
while (parsecfg_state.raw.s[parsecfg_state.raw_i] > 0 && parsecfg_state.raw.s[parsecfg_state.raw_i] <= ' ') parsecfg_state.raw_i++;
if (parsecfg_state.raw.s[parsecfg_state.raw_i] != '&' || parsecfg_state.raw.s[parsecfg_state.raw_i + 1] != '&') break;
parsecfg_state.raw_i += 2;
while (parsecfg_state.raw.s[parsecfg_state.raw_i] > 0 && parsecfg_state.raw.s[parsecfg_state.raw_i] <= ' ') parsecfg_state.raw_i++;
if (parse_OR_expr(need_eval, &v2) < 0) return -1;
if (need_eval && !convert_to_bool(&v2)) {
set_bool_value(prv, 0);
b = 0;
need_eval = 0;
free_value(&v2);
}
}
if (need_eval) {
set_bool_value(prv, 1);
b = 1;
}
return b;
}
/**
* Map iterator to free cached entries.
*/
static bool
free_cached(void *key, void *value, void *data)
{
dbmw_t *dw = data;
struct cached *entry = value;
dbmw_check(dw);
g_assert(!entry->len == !entry->data);
free_value(dw, entry, TRUE);
wfree(key, dbmw_keylen(dw, key));
WFREE(entry);
return TRUE;
}
/**
* Map iterator to free cached entries.
*/
static gboolean
free_cached(gpointer key, gpointer value, gpointer data)
{
dbmw_t *dw = data;
struct cached *entry = value;
dbmw_check(dw);
g_assert(!entry->len == !entry->data);
free_value(dw, entry, TRUE);
wfree(key, dbmw_keylen(dw, key));
WFREE(entry);
return TRUE;
}
void mg_table_free(MG_Table *table, void free_value(void *value)) {
if ((*table)->length > 0) {
int i;
struct binding *p, *q;
for (i = 0; i < (*table)->size; i++)
for (p = (*table)->buckets[i]; p; p = q) {
q = p->link;
free_value(p->value);
free(p);
}
}
free(*table);
}
static int
parse_expr(int need_eval, cfg_cond_value_t *prv)
{
int b = 0;
if (parse_conditional_expr(need_eval, prv) < 0) return -1;
while (parsecfg_state.raw.s[parsecfg_state.raw_i] > 0 && parsecfg_state.raw.s[parsecfg_state.raw_i] <= ' ') parsecfg_state.raw_i++;
if (parsecfg_state.raw.s[parsecfg_state.raw_i]) {
fprintf(stderr, "%d: syntax error\n", parsecfg_state.lineno);
if (need_eval) free_value(prv);
return -1;
}
if (need_eval) b = convert_to_bool(prv);
return b;
}
