int main()
{
int i, n;
char *a = "AaAa";
char *b = "BbBb";
char *c = "CcCc";
char *p;
cp_vector *v = cp_vector_create(1);
for (i = 0; i < 30; i++)
{
char buf[0x20];
sprintf(buf, "%s %d", a, i);
cp_vector_add_element(v, strdup(buf));
sprintf(buf, "%s %d", b, i);
cp_vector_add_element(v, strdup(buf));
sprintf(buf, "%s %d", c, i);
cp_vector_add_element(v, strdup(buf));
}
n = cp_vector_size(v);
for (i = 0; i < n; i++)
{
p = cp_vector_element_at(v, i);
printf("%d: %s\n", i, p);
}
cp_vector_destroy_custom(v, free);
return 0;
}
/* implement COLLECTION_MODE_COPY if set */
static cp_avlnode *create_avlnode(cp_avltree *tree, void *key, void *value)
{
cp_avlnode *node = NULL;
if (tree->mode & COLLECTION_MODE_COPY)
{
void *k = tree->key_copy ? (*tree->key_copy)(key) : key;
if (k)
{
void *v = tree->value_copy ? (*tree->value_copy)(value) : value;
if (v)
node = cp_avlnode_create(k, v, tree->mempool);
}
}
else
node = cp_avlnode_create(key, value, tree->mempool);
if (node && (tree->mode & COLLECTION_MODE_MULTIPLE_VALUES))
{
cp_vector *m = cp_vector_create(1);
if (m == NULL)
{
cp_avltree_destroy_node(tree, node);
return NULL;
}
cp_vector_add_element(m, node->value);
node->value = m;
}
return node;
}
/* update_avlnode - implement COLLECTION_MODE_COPY, COLLECTION_MODE_DEEP and
* COLLECTION_MODE_MULTIPLE_VALUES when inserting a value for an existing key
*/
static void *
update_avlnode(cp_avltree *tree, cp_avlnode *node, void *key, void *value)
{
void *new_key = key;
void *new_value = value;
if (tree->mode & COLLECTION_MODE_COPY)
{
if (tree->key_copy)
{
new_key = (*tree->key_copy)(key);
if (new_key == NULL) return NULL;
}
if (tree->value_copy)
{
new_value = (*tree->value_copy)(value);
if (new_value == NULL) return NULL;
}
}
if (tree->mode & COLLECTION_MODE_DEEP)
{
if (tree->key_dtr)
(*tree->key_dtr)(node->key);
if (tree->value_dtr && !(tree->mode & COLLECTION_MODE_MULTIPLE_VALUES))
(*tree->value_dtr)(node->value);
}
node->key = new_key;
if ((tree->mode & COLLECTION_MODE_MULTIPLE_VALUES))
{
cp_vector_add_element(node->value, new_value);
return node->value;
}
else
node->value = new_value;
return new_value;
}
void cp_pooled_thread_scheduler_register_client
(cp_pooled_thread_scheduler *scheduler,
cp_pooled_thread_client_interface *client)
{
cp_vector_add_element(scheduler->client_list, client);
}
int cp_db_connection_execute_statement_args(cp_db_connection *connection,
cp_db_statement *statement,
cp_result_set **results, ...)
{
if (connection->data_source->act->execute_statement)
{
int i;
int rc;
va_list argp;
int p_int;
long p_long;
#ifdef CP_HAS_LONG_LONG
long long p_longlong;
#else
__int64 p_longlong;
#endif /* CP_HAS_LONG_LONG */
double p_double;
cp_timestampz p_timestamp;
cp_string p_str;
cp_vector *tmp = NULL;
void *ptr;
int *lengths = NULL;
void **prm = NULL;
if (statement->prm_count)
{
prm = calloc(statement->prm_count, sizeof(void *));
lengths = calloc(statement->prm_count, sizeof(int));
}
va_start(argp, results);
for (i = 0; i < statement->prm_count; i++)
{
tmp = cp_vector_create(statement->prm_count);
switch (statement->types[i])
{
case CP_FIELD_TYPE_CHAR:
case CP_FIELD_TYPE_VARCHAR:
prm[i] = va_arg(argp, char *);
lengths[i] = strlen(prm[i]);
break;
case CP_FIELD_TYPE_BLOB:
ptr = malloc(sizeof(int));
p_str = va_arg(argp, cp_string);
memcpy(ptr, &p_str, sizeof(cp_string));
prm[i] = ptr;
lengths[i] = p_str.len;
break;
case CP_FIELD_TYPE_BOOLEAN:
case CP_FIELD_TYPE_SHORT:
case CP_FIELD_TYPE_INT:
ptr = malloc(sizeof(int));
p_int = va_arg(argp, int);
memcpy(ptr, &p_int, sizeof(int));
cp_vector_add_element(tmp, ptr);
prm[i] = ptr;
lengths[i] = sizeof(int);
break;
case CP_FIELD_TYPE_LONG:
ptr = malloc(sizeof(long));
p_long = va_arg(argp, long);
memcpy(ptr, &p_long, sizeof(long));
cp_vector_add_element(tmp, ptr);
prm[i] = ptr;
lengths[i] = sizeof(long);
break;
case CP_FIELD_TYPE_LONG_LONG:
#ifdef CP_HAS_LONG_LONG
ptr = malloc(sizeof(long long));
p_longlong = va_arg(argp, long long);
memcpy(ptr, &p_longlong, sizeof(long long));
lengths[i] = sizeof(long long);
#else
ptr = malloc(sizeof(__int64));
p_longlong = va_arg(argp, __int64);
memcpy(ptr, &p_longlong, sizeof(__int64));
lengths[i] = sizeof(__int64);
#endif /* CP_HAS_LONG_LONG */
cp_vector_add_element(tmp, ptr);
prm[i] = ptr;
break;
case CP_FIELD_TYPE_FLOAT:
case CP_FIELD_TYPE_DOUBLE:
ptr = malloc(sizeof(double));
p_double = va_arg(argp, double);
memcpy(ptr, &p_double, sizeof(double));
cp_vector_add_element(tmp, ptr);
prm[i] = ptr;
lengths[i] = sizeof(double);
break;
case CP_FIELD_TYPE_DATE:
case CP_FIELD_TYPE_TIME:
case CP_FIELD_TYPE_TIMESTAMP:
ptr = malloc(sizeof(cp_timestampz));
p_timestamp = va_arg(argp, cp_timestampz);
memcpy(ptr, &p_timestamp, sizeof(cp_timestampz));
cp_vector_add_element(tmp, ptr);
prm[i] = ptr;
break;
}
}
rc = (*connection->data_source->act->execute_statement)(connection,
statement,
results,
lengths,
prm);
va_end(argp);
if (statement->prm_count)
{
free(prm);
free(lengths);
}
if (prm) free(prm);
if (tmp)
cp_vector_destroy_custom(tmp, (cp_destructor_fn) free);
return rc;
}
int parse_input(char* file, globals* vars) {
cfg_opt_t operation_opts[] =
{
CFG_STR_LIST("in","{}", CFGF_NONE),
CFG_STR("out", 0, CFGF_NONE),
CFG_END() };
cfg_opt_t opts[] =
{ CFG_STR_LIST("sorts", "{}", CFGF_NONE),
CFG_SEC("op", operation_opts, CFGF_MULTI | CFGF_TITLE),
CFG_FUNC("include", &cfg_include), CFG_END() };
cfg_t *cfg;
int i, j, N, err;
char *found, *sortname, *opname;
op_signature *ops = malloc(sizeof(op_signature)+sizeof(char*)*MAX_OP_INPUTS);
assert(ops);
cfg = cfg_init(opts, CFGF_NONE);
assert(cfg);
if (cfg_parse(cfg, file) == CFG_PARSE_ERROR)
return 1;
/**
* add new sort names to the sorts trie
*/
N = cfg_size(cfg, "sorts");
for (i = 0; i < N; i++)
{
sortname = cfg_getnstr(cfg, "sorts", i);
found = cp_trie_exact_match(vars->sorts, sortname);
if (!found)
{
sortname = strdup(sortname);
cp_trie_add(vars->sorts, sortname, sortname);
vars->sorts_N += 1;
}
}
/**
* the the operations to the operation list
*/
N = cfg_size(cfg, "op");
for (i = 0; i < N; i++)
{
cfg_t *op = cfg_getnsec(cfg, "op", i);
opname = strdup(cfg_title(op));
cp_vector_add_element(vars->op_names, opname);
sortname = cfg_getstr(op,"out");
assert(sortname);
found = cp_trie_exact_match(vars->sorts,sortname);
if (! found) {
fputs("Operation ",stderr);
fputs(opname,stderr);
fputs(" uses undeclared output sort ",stderr);
fputs(sortname,stderr);
fputs("\n",stderr);
/** fix it */
sortname = strdup(sortname);
cp_trie_add(vars->sorts, sortname, sortname);
vars->sorts_N += 1;
found = sortname;
}
ops->id = vars->ops_N;
ops->out = found;
ops->in_N = cfg_size(op, "in");
assert(ops->in_N <= MAX_OP_INPUTS);
for (j=0;j<ops->in_N; ++j) {
sortname = cfg_getnstr(op,"in",j);
assert(sortname);
found = cp_trie_exact_match(vars->sorts,sortname);
if (! found) {
fputs("Operation ",stderr);
fputs(opname,stderr);
fputs(" uses undeclared input sort ",stderr);
fputs(sortname,stderr);
fputs("\n",stderr);
/** fix it */
sortname = strdup(sortname);
cp_trie_add(vars->sorts, sortname, sortname);
vars->sorts_N += 1;
found = sortname;
}
ops->in[j] = found;
}
err = 0;
cp_multimap_insert(vars->ops, ops, &err);
if (err) {
fputs("Operation ",stderr);
fputs(opname,stderr);
fputs(": cannot add to multimap ",stderr);
fprintf(stderr,"%d",err);
fputs("\n",stderr);
}
vars->ops_N += 1;
}
cfg_free(cfg);
free(ops);
return 0;
}
