/**
* 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);
}
