/** * Connects queue_iterate interface to free with rule_destroy call. * * @param arg Address to be freed. * @param trash do NOT use. * @return Void. */ static void rule_free_adapter(void *arg, void *trash){ rule_t *rule = arg; queue_iterate(rule->deps, free_adapter, 0); queue_iterate(rule->commands, free_adapter, 0); free(rule->target); rule_destroy(arg); free(arg); }
void handler(int sig) { sig++; pthread_mutex_lock(&mutex); queue_iterate(&fd_queue, fd_close, NULL); shutdown(sock_fd,2); close(sock_fd); queue_iterate(&pthread_queue, thread_join, NULL); queue_destroy(&pthread_queue); queue_destroy(&fd_queue); pthread_mutex_unlock(&mutex); pthread_mutex_destroy(&mutex); free(result); save(); exit(0); }
void destroy_thread_pool(thread_pool* pool) { pool->cancelled = true; pthread_mutex_lock(pool->mutex); pthread_cond_broadcast(pool->cond); pthread_mutex_unlock(pool->mutex); for(int i = 0; i < pool->threads_num; i++) { pthread_join(pool->threads[i], NULL); } free(pool->threads); pthread_mutex_destroy(pool->mutex); pthread_mutex_destroy(pool->mutex_free); pthread_cond_destroy(pool->cond); queue_iterate(pool->tasks_queue, free); queue_struct_free(pool->tasks_queue); free(pool); }
/** * Removes all rules which are not descendants of simulated DAG rooted at targets. * * @param rules Queue of rules which is read and modified. * @param targets List of targets which act as roots. * @return Void. */ static void filterOnTargets(queue_t **rules, char **targets){ queue_t *validRules = malloc(sizeof(queue_t)); queue_init(validRules); int idx; //initialize validRules with targets for(idx=0; idx < queue_size(*rules);idx++){ rule_t *curRule = queue_at(*rules, idx); int tarIdx; for(tarIdx=0; targets[tarIdx] != NULL; tarIdx++){ if(strcmp(curRule->target, targets[tarIdx]) == 0){ queue_enqueue(validRules, curRule); queue_remove_at(*rules, idx); idx--; break; } } } //repeated linear search for new valid targets int prevSize = 0; while(prevSize != queue_size(validRules)){ prevSize = queue_size(validRules); for(idx=0; idx < queue_size(*rules); idx++){ rule_t *curRule = queue_at(*rules, idx); if(findMatch(curRule, validRules)){ queue_enqueue(validRules, curRule); queue_remove_at(*rules, idx); idx--; } } } //cleanup old rules queue_iterate(*rules, rule_free_adapter, 0); queue_destroy(*rules); free(*rules); //assign new queue *rules = validRules; }
int main(){ int counter; int arraya[5] = {1,2,3,4,5}; int arrayb[] = {3,4,5}; int arrayc[] = {2,4,5}; int* inty = malloc(sizeof(int *)); int** item1 = malloc(sizeof(int **)); int** item2 = malloc(sizeof(int **)); int iny = 3; queue_t queue = queue_new(); printf("prepend prior\n"); queue_prepend(queue, &iny); printf("prepend post\n"); int inty1 = 2; queue_prepend(queue, &inty1); printf("prepend post\n"); int inty2 = 1; queue_prepend(queue, &inty2); int inty3 = 4; queue_append(queue, &inty3); printf("prepend post\n"); int inty4 = inty3+1; queue_append(queue, &inty4); if (test(queue,arraya,5) == 0){ printf("test 1 PASSED\n"); } else { printf("test 1 FAILED\n"); } queue_dequeue(queue,(void **)item1); queue_dequeue(queue,(void **)item2); if (test(queue,arrayb,3) == 0 && **item1 == 1 && **item2 == 2){ printf("test 2 PASSED\n"); } else { printf("test 2 FAILED\n"); } queue_prepend(queue, &inty1); *inty = 0; queue_iterate(queue,iter_tester,(void *)inty); if (*inty == 14){ printf("test 3 PASSED\n"); } else{ printf("test 3 FAILED, total = %i\n",*inty); } queue_delete(queue, &iny); if (test(queue,arrayc,3) == 0){ printf("test 4 PASSED\n"); } else { printf("test 4 FAILED\n"); } queue_t q = queue_new(); for(counter=0;counter<100;counter++){ printf("Index %i\n",counter); queue_append(q,&counter); } if (q->length = 100){ printf("test 5 PASSED\n"); } else { printf("test 5 FAILED\n"); } queue_free(q); queue_free(queue); free(inty); free(item1); free(item2); }
/** * Parses makeFileName based on GNU 'make' utility. * * @param makeFileName Path to valid makefile. * @param run_targets Null-terminated list of targets as listed on command-line. * @param parsed_new_target Function pointer to callback function for new target. * @param parsed_new_dependency Function pointer to callback function for new dependency. * @param parsed_new_command Function pointer to callback function for new command. * @return Void. */ void parser_parse_makefile ( const char *makeFileName, char **run_targets, void (*parsed_new_target)(char *target), void (*parsed_new_dependency)(char *target, char *dependency), void (*parsed_new_command)(char *target, char *command) ) { boolean run_targetsMalloced = False; FILE *f = fopen(makeFileName, "r"); assert(f != NULL); queue_t *rules = malloc(sizeof(queue_t)); queue_init(rules); queue_t curRules; queue_init(&curRules); char *lineBuf = NULL; size_t bytes; size_t len; while((len = getline(&lineBuf, &bytes, f)) != -1){ if(len && lineBuf[len-1] == '\n'){ lineBuf[--len] = '\0'; if(len && lineBuf[len-1] == '\r') lineBuf[--len] = '\0'; } if(isalnum(lineBuf[0])){ char *depLine = strstr(lineBuf, ":"); assert(depLine != NULL); depLine[0] = '\0'; depLine = depLine + 1; //insert prev Rule to queue int ruleIdx; for(ruleIdx=0; ruleIdx < queue_size(&curRules); ruleIdx++){ queue_enqueue(rules, queue_at(&curRules,ruleIdx)); } queue_destroy(&curRules); queue_init(&curRules); char **targets = parse_line(lineBuf); int tarIdx; for(tarIdx=0; targets[tarIdx] != NULL; tarIdx++){ rule_t *newRule = malloc(sizeof(rule_t)); rule_init(newRule); char *target = strdup(targets[tarIdx]); newRule->target = target; queue_enqueue(&curRules, newRule); } if(run_targets == NULL || run_targets[0] == NULL){ run_targetsMalloced = True; run_targets = calloc(sizeof(char *), tarIdx + 1); int rtIdx; for(rtIdx=0; rtIdx < tarIdx; rtIdx++) run_targets[rtIdx] = strdup(targets[rtIdx]); } free(targets); char **deps = parse_line(depLine); int depIdx; for(depIdx=0; deps[depIdx] != NULL; depIdx++){ int ruleIdx; for(ruleIdx=0; ruleIdx < queue_size(&curRules); ruleIdx++){ rule_t *curRule = queue_at(&curRules, ruleIdx); char *dep = strdup(deps[depIdx]); queue_enqueue(curRule->deps, dep); } } free(deps); } else if(lineBuf[0] == '\t') { assert(queue_size(&curRules) != 0); //command without target int idx; for(idx=0; idx < queue_size(&curRules); idx++){ rule_t *curRule = queue_at(&curRules, idx); char *command = strdup(lineBuf + 1); queue_enqueue(curRule->commands, command); } }else { ;//ignore line } } int ruleIdx; for(ruleIdx=0; ruleIdx < queue_size(&curRules); ruleIdx++){ queue_enqueue(rules, queue_at(&curRules, ruleIdx)); } queue_destroy(&curRules); //No longer need curRules filterOnTargets(&rules, run_targets); //send callbacks notifyRules(rules, parsed_new_target, parsed_new_dependency, parsed_new_command); //cleanup queue_iterate(rules, rule_free_adapter, 0); queue_destroy(rules); if(run_targetsMalloced){ int tarIdx; for(tarIdx=0; run_targets[tarIdx] != NULL; tarIdx++) free(run_targets[tarIdx]); free(run_targets); } free(lineBuf); free(rules); fclose(f); }
void test_queue_iterate() { CU_ASSERT_EQUAL_FATAL(queue_iterate(&queue, display_node), 4); }