/* Parse result structure. */ struct cparam * cparam_alloc(void) { struct cparam *cparam; cparam = calloc(1, sizeof(struct cparam)); if (cparam == NULL) { return NULL; } cparam->args = vector_alloc(); if (cparam->args == NULL) { cparam_free(cparam); return NULL; } cparam->matched = vector_alloc(); if (cparam->matched == NULL) { cparam_free(cparam); return NULL; } cparam->candidate = vector_alloc(); if (cparam->candidate == NULL) { cparam_free(cparam); return NULL; } cparam->argv = vector_alloc(); if (cparam->argv == NULL) { cparam_free(cparam); return NULL; } return cparam; }
static int blacklist_exceptions_handler(vector strvec) { conf->elist_devnode = vector_alloc(); conf->elist_wwid = vector_alloc(); conf->elist_device = vector_alloc(); if (!conf->elist_devnode || !conf->elist_wwid || !conf->elist_device) return 1; return 0; }
void main( ) { Matrix *m, *mT, *eig_vec_J, *eig_vec_T, *L; Vector *eig_val_J, *eig_val_T; int i, j, tt_ja, tt_ho; m = matrix_alloc( 100, 50 ); for( i = 0; i < m->dim_M; i++ ) for( j = 0; j < m->dim_N; j++ ) { M( m, i, j) = (double) i*i + 120.0; } mT = matrix_alloc( 50, 100 ); matrix_transpose( m, mT ); eig_vec_J = matrix_alloc( 100, 100 ); eig_val_J = vector_alloc( 100 ); L = matrix_alloc( 100, 100 ); matrix_prod( m, mT, L ); Start_Clock_once( &tt_ja ); jacobi( L, eig_val_J, eig_vec_J ); End_ms_Clock_once( tt_ja, 1, "jacobi used " ); printf("done with jacobi\n" ); /* for( i = 0; i < 100; i++ ) printf(" %f", V(eig_val_J,i) ); printf("\n"); for( i = 0; i < 100; i++ ) printf(" %f", M(eig_vec_J,i,0) ); printf("\n"); */ matrix_prod( m, mT, L ); eig_vec_T = matrix_alloc( 100, 100 ); eig_val_T = vector_alloc( 100 ); Start_Clock_once( &tt_ho ); eigen_householder( L, eig_val_T, eig_vec_T ); End_ms_Clock_once( tt_ho, 1, "householder used " ); printf(" done with householder\n" ); /* for( i = 0; i < 100; i++ ) printf(" %f", V(eig_val_T,i) ); printf("\n"); for( i = 0; i < 100; i++ ) printf(" %f", M(eig_vec_T,i,0) ); printf("\n"); */ }
static void init_inner_problem(const struct Struct_FALM *s, struct Struct_FGM *p_in) { // Setting the inner problem to point to the outer problem except for c and z0 // Setting the inner problem to point to the same as the outer saves some memory p_in->H = s->H_hat; p_in->lb = s->prob->lb; p_in->ub = s->prob->ub; p_in->lb_is_inf = s->info->lb_is_inf; p_in->ub_is_inf = s->info->ub_is_inf; p_in->eigH_max = s->info->eigH_max; p_in->eigH_min = s->info->eigH_min; // Make own allocation for c (This is changing for each outer iteration) p_in->c = vector_alloc(N); p_in->z0 = vector_alloc(N); // Allocate other necessary vectors p_in->zopt = vector_alloc(N); p_in->z = vector_alloc(N); p_in->y = vector_alloc(N); p_in->znew = vector_alloc(N); p_in->ynew = vector_alloc(N); p_in->temp1_dim_N = vector_alloc(N); // Initialize options p_in->maxiter = s->opt->maxiter_inner; p_in->eps = s->opt->eps_inner; }
/* ============================================================================= * net_alloc * ============================================================================= */ net_t* net_alloc (long numNode) { net_t* netPtr; netPtr = (net_t*)SEQ_MALLOC(sizeof(net_t)); if (netPtr) { vector_t* nodeVectorPtr = vector_alloc(numNode); if (nodeVectorPtr == NULL) { SEQ_FREE(netPtr); return NULL; } long i; for (i = 0; i < numNode; i++) { net_node_t* nodePtr = allocNode(i); if (nodePtr == NULL) { long j; for (j = 0; j < i; j++) { nodePtr = (net_node_t*)vector_at(nodeVectorPtr, j); freeNode(nodePtr); } vector_free(nodeVectorPtr); SEQ_FREE(netPtr); return NULL; } bool_t status = vector_pushBack(nodeVectorPtr, (void*)nodePtr); assert(status); } netPtr->nodeVectorPtr = nodeVectorPtr; } return netPtr; }
/* Data initialization */ int init_data(char *conf_file, void (*init_keywords) (void)) { int r; if (!keywords) keywords = vector_alloc(); if (!keywords) return 1; stream = fopen(conf_file, "r"); if (!stream) { syslog(LOG_WARNING, "Configuration file open problem"); return 1; } /* Init Keywords structure */ (*init_keywords) (); /* Dump configuration * vector_dump(keywords); dump_keywords(keywords, 0); */ /* Stream handling */ r = process_stream(keywords); fclose(stream); //free_keywords(keywords); return r; }
eng_table_t* eng_table_init() { eng_table_t* eng_table = my_malloc(sizeof(eng_table_t)); // eng_table->eng_datas = vector_alloc((vector_entry_free_func)eng_data_destroy); eng_table->eng_keys = vector_alloc((vector_entry_free_func)eng_data_destroy); return eng_table; }
static void dpdk_interface_set_index(struct interface *ifp) { if (ifp_vector == NULL) { ifp_vector = vector_alloc(); } vector_set_index(ifp_vector, ifp->info.eth_dpdk_phy.port_number, ifp); }
int _install_keyword(vector keywords, char *string, int (*handler) (struct config *, vector), int (*print) (struct config *, char *, int, void *), int unique) { int i = 0; struct keyword *keyword; /* fetch last keyword */ keyword = VECTOR_SLOT(keywords, VECTOR_SIZE(keywords) - 1); /* position to last sub level */ for (i = 0; i < sublevel; i++) keyword = VECTOR_SLOT(keyword->sub, VECTOR_SIZE(keyword->sub) - 1); /* First sub level allocation */ if (!keyword->sub) keyword->sub = vector_alloc(); if (!keyword->sub) return 1; /* add new sub keyword */ return keyword_alloc(keyword->sub, string, handler, print, unique); }
vector_t * alloc_strvec(char *string) { char *cp, *start, *token; size_t str_len; vector_t *strvec; if (!string) return NULL; cp = string; /* Skip white spaces */ while (isspace((int) *cp) && *cp != '\0') cp++; /* Return if there is only white spaces */ if (*cp == '\0') return NULL; /* Return if string begin with a comment */ if (*cp == '!' || *cp == '#') return NULL; /* Create a vector and alloc each command piece */ strvec = vector_alloc(); while (1) { start = cp; /* Save a quoted string without the "s as a single string */ if (*cp == '"') { start++; if (!(cp = strchr(start, '"'))) { log_message(LOG_INFO, "Unmatched quote: '%s'", string); return strvec; } str_len = (size_t)(cp - start); cp++; } else { while (!isspace((int) *cp) && *cp != '\0' && *cp != '"' && *cp != '!' && *cp != '#') cp++; str_len = (size_t)(cp - start); } token = MALLOC(str_len + 1); memcpy(token, start, str_len); token[str_len] = '\0'; /* Alloc & set the slot */ vector_alloc_slot(strvec); vector_set_slot(strvec, token); while (isspace((int) *cp) && *cp != '\0') cp++; if (*cp == '\0' || *cp == '!' || *cp == '#') return strvec; } }
int load_keys (void) { int r = 0; keys = vector_alloc(); if (!keys) return 1; r += add_key(keys, "list", LIST, 0); r += add_key(keys, "show", LIST, 0); r += add_key(keys, "add", ADD, 0); r += add_key(keys, "remove", DEL, 0); r += add_key(keys, "del", DEL, 0); r += add_key(keys, "switch", SWITCH, 0); r += add_key(keys, "switchgroup", SWITCH, 0); r += add_key(keys, "suspend", SUSPEND, 0); r += add_key(keys, "resume", RESUME, 0); r += add_key(keys, "reinstate", REINSTATE, 0); r += add_key(keys, "fail", FAIL, 0); r += add_key(keys, "resize", RESIZE, 0); r += add_key(keys, "reset", RESET, 0); r += add_key(keys, "reload", RELOAD, 0); r += add_key(keys, "forcequeueing", FORCEQ, 0); r += add_key(keys, "disablequeueing", DISABLEQ, 0); r += add_key(keys, "restorequeueing", RESTOREQ, 0); r += add_key(keys, "paths", PATHS, 0); r += add_key(keys, "maps", MAPS, 0); r += add_key(keys, "multipaths", MAPS, 0); r += add_key(keys, "path", PATH, 1); r += add_key(keys, "map", MAP, 1); r += add_key(keys, "multipath", MAP, 1); r += add_key(keys, "group", GROUP, 1); r += add_key(keys, "reconfigure", RECONFIGURE, 0); r += add_key(keys, "daemon", DAEMON, 0); r += add_key(keys, "status", STATUS, 0); r += add_key(keys, "stats", STATS, 0); r += add_key(keys, "topology", TOPOLOGY, 0); r += add_key(keys, "config", CONFIG, 0); r += add_key(keys, "blacklist", BLACKLIST, 0); r += add_key(keys, "devices", DEVICES, 0); r += add_key(keys, "raw", RAW, 0); r += add_key(keys, "wildcards", WILDCARDS, 0); r += add_key(keys, "quit", QUIT, 0); r += add_key(keys, "exit", QUIT, 0); r += add_key(keys, "shutdown", SHUTDOWN, 0); r += add_key(keys, "getprstatus", GETPRSTATUS, 0); r += add_key(keys, "setprstatus", SETPRSTATUS, 0); r += add_key(keys, "unsetprstatus", UNSETPRSTATUS, 0); r += add_key(keys, "format", FMT, 1); r += add_key(keys, "json", JSON, 0); if (r) { free_keys(keys); keys = NULL; return 1; } return 0; }
vector_t * read_value_block(vector_t *strvec) { char *buf; unsigned int word; char *str = NULL; char *dup; vector_t *vec = NULL; vector_t *elements = vector_alloc(); int first = 1; int need_bob = 1; int got_eob = 0; buf = (char *) MALLOC(MAXBUF); while (first || read_line(buf, MAXBUF)) { if (first && vector_size(strvec) > 1) { vec = strvec; word = 1; } else { vec = alloc_strvec(buf); word = 0; } if (vec) { str = vector_slot(vec, word); if (need_bob) { if (!strcmp(str, BOB)) word++; else log_message(LOG_INFO, "'{' missing at beginning of block %s", FMT_STR_VSLOT(strvec,0)); need_bob = 0; } for (; word < vector_size(vec); word++) { str = vector_slot(vec, word); if (!strcmp(str, EOB)) { if (word != vector_size(vec) - 1) log_message(LOG_INFO, "Extra characters after '}' - \"%s\"", buf); got_eob = 1; break; } dup = (char *) MALLOC(strlen(str) + 1); memcpy(dup, str, strlen(str)); vector_alloc_slot(elements); vector_set_slot(elements, dup); } if (vec != strvec) free_strvec(vec); if (got_eob) break; } memset(buf, 0, MAXBUF); first = 0; } FREE(buf); return elements; }
static int blacklist_exceptions_handler(struct config *conf, vector strvec) { if (!conf->elist_devnode) conf->elist_devnode = vector_alloc(); if (!conf->elist_wwid) conf->elist_wwid = vector_alloc(); if (!conf->elist_device) conf->elist_device = vector_alloc(); if (!conf->elist_property) conf->elist_property = vector_alloc(); if (!conf->elist_devnode || !conf->elist_wwid || !conf->elist_device || !conf->elist_property) return 1; return 0; }
int alloc_handlers (void) { handlers = vector_alloc(); if (!handlers) return 1; return 0; }
/* * multipaths block handlers */ static int multipaths_handler(vector strvec) { conf->mptable = vector_alloc(); if (!conf->mptable) return 1; return 0; }
vector read_value_block(void) { char *buf; int i; char *str = NULL; char *dup; vector vec = NULL; vector elements = vector_alloc(); if (!elements) return NULL; buf = (char *) MALLOC(MAXBUF); if (!buf) return NULL; while (read_line(buf, MAXBUF)) { vec = alloc_strvec(buf); if (vec) { str = VECTOR_SLOT(vec, 0); if (!strcmp(str, EOB)) { free_strvec(vec); break; } if (VECTOR_SIZE(vec)) for (i = 0; i < VECTOR_SIZE(vec); i++) { str = VECTOR_SLOT(vec, i); dup = (char *) MALLOC(strlen(str) + 1); if (!dup) goto out; memcpy(dup, str, strlen(str)); if (!vector_alloc_slot(elements)) { free_strvec(vec); goto out1; } vector_set_slot(elements, dup); } free_strvec(vec); } memset(buf, 0, MAXBUF); } FREE(buf); return elements; out1: FREE(dup); out: FREE(buf); return NULL; }
static void testCounts (adtree_t* adtreePtr, data_t* dataPtr) { long numVar = dataPtr->numVar; vector_t* queryVectorPtr = vector_alloc(numVar); long v; for (v = -1; v < numVar; v++) { testCount(adtreePtr, dataPtr, queryVectorPtr, v, dataPtr->numVar); } vector_free(queryVectorPtr); }
/* ============================================================================= * maze_alloc * ============================================================================= */ maze_t* maze_alloc () { maze_t* mazePtr; mazePtr = (maze_t*)malloc(sizeof(maze_t)); if (mazePtr) { mazePtr->gridPtr = NULL; mazePtr->workQueuePtr = queue_alloc(1024); mazePtr->wallVectorPtr = vector_alloc(1); mazePtr->srcVectorPtr = vector_alloc(1); mazePtr->dstVectorPtr = vector_alloc(1); assert(mazePtr->workQueuePtr && mazePtr->wallVectorPtr && mazePtr->srcVectorPtr && mazePtr->dstVectorPtr); } return mazePtr; }
/* * devices block handlers */ static int devices_handler(struct config *conf, vector strvec) { if (!conf->hwtable) conf->hwtable = vector_alloc(); if (!conf->hwtable) return 1; return 0; }
struct vector * ports_alloc(void) { struct vector *v; v = vector_alloc(); if (v == NULL) { return NULL; } return v; }
/* * multipaths block handlers */ static int multipaths_handler(struct config *conf, vector strvec) { if (!conf->mptable) conf->mptable = vector_alloc(); if (!conf->mptable) return 1; return 0; }
vector_t * alloc_strvec(char *string) { char *cp, *start, *token; int str_len; vector_t *strvec; if (!string) return NULL; cp = string; /* Skip white spaces */ while (isspace((int) *cp) && *cp != '\0') cp++; /* Return if there is only white spaces */ if (*cp == '\0') return NULL; /* Return if string begin with a comment */ if (*cp == '!' || *cp == '#') return NULL; /* Create a vector and alloc each command piece */ strvec = vector_alloc(); while (1) { start = cp; if (*cp == '"') { cp++; token = MALLOC(2); *(token) = '"'; *(token + 1) = '\0'; } else { while (!isspace((int) *cp) && *cp != '\0' && *cp != '"') cp++; str_len = cp - start; token = MALLOC(str_len + 1); memcpy(token, start, str_len); *(token + str_len) = '\0'; } /* Alloc & set the slot */ vector_alloc_slot(strvec); vector_set_slot(strvec, token); while (isspace((int) *cp) && *cp != '\0') cp++; if (*cp == '\0' || *cp == '!' || *cp == '#') return strvec; } }
void cmd_bucket_init() { cq_cmd_bucket = my_malloc(sizeof(cmd_bucket_t)); cq_cmd_bucket->cmd_lists = vector_alloc((vector_entry_free_func)cmd_list_destroy); if (NULL == cq_cmd_bucket->cmd_lists) { log_error("init cmd vector failed!"); abort(); } return; }
int main () { vector_t* vectorPtr; vector_t* copyVectorPtr; long data[] = {3, 1, 4, 1, 5, -1}; long i; puts("Starting..."); vectorPtr = vector_alloc(1); copyVectorPtr = vector_alloc(1); for (i = 0; data[i] >= 0; i++) { insertInt(vectorPtr, &data[i]); } vector_copy(copyVectorPtr, vectorPtr); while (i-- > 0) { removeInt(vectorPtr); } printf("copy "); printVector(copyVectorPtr); printf("sort "); vector_sort(copyVectorPtr, &compareInt); printVector(copyVectorPtr); vector_free(vectorPtr); vector_free(copyVectorPtr); puts("Done."); return 0; }
/* ============================================================================= * stream_alloc * ============================================================================= */ stream_t* stream_alloc (long percentAttack) { stream_t* streamPtr; streamPtr = (stream_t*)malloc(sizeof(stream_t)); if (streamPtr) { streamPtr->percentAttack = percentAttack; streamPtr->randomPtr = random_alloc(); streamPtr->allocVectorPtr = vector_alloc(1); streamPtr->packetQueuePtr = queue_alloc(-1); streamPtr->attackMapPtr = MAP_ALLOC(NULL, NULL); } return streamPtr; }
/* Standard allocation function, with initialization of the elements. */ matrix_t* matrix_alloc(size_t nbrows, size_t nbcols, bool s) { size_t i; assert(nbcols>0 || nbrows==0); matrix_t* mat = (matrix_t*)malloc(sizeof(matrix_t)); mat->nbrows = mat->_maxrows = nbrows; mat->nbcolumns = nbcols; mat->_sorted = s; mat->p = (numint_t**)malloc(nbrows * sizeof(numint_t*)); for (i=0; i<nbrows; i++) { mat->p[i] = vector_alloc(nbcols); } return mat; }
struct cnode * cnode_alloc(void) { struct cnode *cnode; cnode = (struct cnode *)calloc(1, sizeof(struct cnode)); if (cnode == NULL) { return NULL; } cnode->v = vector_alloc(); if (cnode->v == NULL) { cnode_free(cnode); return NULL; } return cnode; }
struct adapter_group * alloc_adaptergroup(void) { struct adapter_group *agp; agp = (struct adapter_group *)MALLOC(sizeof(struct adapter_group)); if (!agp) return NULL; agp->host_groups = vector_alloc(); if (!agp->host_groups) { FREE(agp); agp = NULL; } return agp; }
/* Data initialization */ void init_data(char *conf_file, vector_t * (*init_keywords) (void)) { /* Init Keywords structure */ keywords = vector_alloc(); (*init_keywords) (); #if 0 /* Dump configuration */ vector_dump(keywords); dump_keywords(keywords, 0); #endif /* Stream handling */ current_keywords = keywords; read_conf_file((conf_file) ? conf_file : CONF); free_keywords(keywords); }
struct pathgroup * alloc_pathgroup (void) { struct pathgroup * pgp; pgp = (struct pathgroup *)MALLOC(sizeof(struct pathgroup)); if (!pgp) return NULL; pgp->paths = vector_alloc(); if (!pgp->paths) { FREE(pgp); pgp = NULL; } return pgp; }