int eval(linkedlist *expr, double *val) { int i; stack_t stk; /* operator stack */ stack_init(&stk); for(i = 0; i < linkedlist_size(expr); i++) { token_t *t = linkedlist_get(expr, i); token_t *n2, *n1, *res; /* if number, push to stack: */ if (t->type == TOKEN_NUMBER) { stack_push(&stk, t); continue; } /* all operators in the postfix expression are binary. */ if (stack_size(&stk) < 2) { while(!stack_isEmpty(&stk)) free(stack_pop(&stk)); /* free the remaining tokens in expr: */ while(i < linkedlist_size(expr)) free(linkedlist_get(expr, i++)); return -1; /* error. */ } n2 = stack_pop(&stk); n1 = stack_pop(&stk); res = malloc(sizeof(token_t)); res->type = TOKEN_NUMBER; res->op = 0; res->num = do_op(n1->num, n2->num, t->op); stack_push(&stk, res); free(n2); free(n1); free(t); } if (stack_size(&stk) != 1) { while(!stack_isEmpty(&stk)) { free(stack_pop(&stk)); } return -1; /* error. */ } *val = ((token_t *) stack_peek(&stk))->num; free(stack_pop(&stk)); return 0; }
static void work(_lazyworker_t* worker) { _unit* unit = NULL; static struct timespec time_wait; for(;worker->threadStatus == eThreadStatus_RUNNING;) { pthread_mutex_lock(&worker->mutex); for(;;) { int que_size = linkedlist_size(worker->sth_todo); if(que_size > 0) { break; } pthread_cond_wait(&worker->cond, &worker->mutex); if(worker->threadStatus == eThreadStatus_CLOSED) { pthread_mutex_unlock(&worker->mutex); pthread_exit((void*) NULL); } } fprintf(stderr, "who wakes me up?"); struct timeval current; gettimeofday(¤t, NULL); unit = (_unit*)linkedlist_get(worker->sth_todo, 0); if(current.tv_sec - unit->t.tv_sec < 1) { // Be lazy time_wait.tv_sec = unit->t.tv_sec + worker->time_wait.tv_sec; time_wait.tv_nsec = unit->t.tv_usec * 1000 + worker->time_wait.tv_nsec; fprintf(stderr, "I am too lazy to work, I'll be back in 1 minute. OK?"); pthread_cond_timedwait(&worker->cond, &worker->mutex, &time_wait); } else { unit = (_unit*)linkedlist_remove_at(worker->sth_todo, 0); free(unit); if(worker->fp != NULL) { fprintf(stderr, "OK, now I am ready to work, what's on your mind?\n"); worker->fp(worker->args); } } pthread_mutex_unlock(&worker->mutex); } // for }
int LinkedlistExercise(int verbose, struct cfg *cfg, char *args[]) { int rate, i, n = 0, idx; char *str; struct linkedlist *l = linkedlist_new(EXERCISE_MED_COUNT, NULL); cfg = NULL; args[0] = NULL; if (l == NULL) { AMSG(""); return -1; } rate = EXERCISE_R0; for (i = 0; i < EXERCISE_MED_COUNT; i++) { if (i == EXERCISE_MED_P1) { rate = EXERCISE_R1; } else if (i == EXERCISE_MED_P2) { rate = EXERCISE_R2; } else if (i == EXERCISE_MED_P3) { rate = EXERCISE_R3; } if (rand() % 10 < rate) { idx = 0; str = malloc(8); sprintf(str, "%07d", n++); if (rand() % 5) { idx = linkedlist_size(l); if (idx) { idx = rand() % idx; } } if (linkedlist_insert(l, idx, str) == -1) { PMNO(errno); return -1; } tcase_printf(verbose, "INSERT: %s size now %d\n", str, linkedlist_size(l)); } else { if (linkedlist_is_empty(l)) { tcase_printf(verbose, "EMPTY\n"); } else { idx = rand() % linkedlist_size(l); str = linkedlist_get(l, idx); if (linkedlist_remove_data(l, str) == NULL) { PMNO(errno); return -1; } if ((idx % 10) == 0) { unsigned int count = 0; iter_t iter; linkedlist_iterate(l, &iter); while (linkedlist_next(l, &iter)) { count++; } if (count != linkedlist_size(l)) { PMSG("count=%u,linkedlist_size=%u\n", count, linkedlist_size(l)); return -1; } } if (str) { tcase_printf(verbose, "REMOVE: %s %d\n", str, linkedlist_size(l)); free(str); } else { PMSG("remove failure"); return -1; } } } } linkedlist_del(l, allocator_free, NULL); return 0; }