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; }