SList* listConcatUnique(SList* list1, SList* list2, int(*cmp)(void*, void*)) { if(!list1 || listEmpty(list1)) { list1->head = list2->head; list1->curr = list2->curr; } else if(!list2 || listEmpty(list2)) { return list1; } else { listHead(list2); do { int found = 0; listHead(list1); do { found = cmp(listCurrent(list1), listCurrent(list2)); }while(!found && listNext(list1)); if(!found) { listAdd(list1, listCurrent(list2)); } }while(listNext(list2)); } return list1; }
/* * Sort <list> using comparison function <cmp>. */ void listSort(List *list, int(*cmp)(const void *, const void *)) { ListNode *l, *r; /* Current node in l(eft) and r(ight) list. */ List left; /* Left list (<list> is used as the right list). */ int i, len = listLength(list); /* This is a standard Merge Sort... */ if (len <= 1) return; /* A list with 1 element is already sorted. */ /* Split <list> in two at (or near) the halfway point. */ left.length = len / 2; list->length -= left.length; l = listHead(list); for (i = 0; i < left.length; i++) { l->list = &left; l = l->next; } left.head = list->head; left.tail = l->prev; list->head = l; l->prev->next = NULL; l->prev = NULL; /* At this point <left> is a valid list containing the left half of the * original <list>, and <list> contains the right half. Call myself * recursively to sort these two lists. */ listSort(&left, cmp); listSort(list, cmp); /* OK, so <left> and <list> are now both sorted. Now pick elements from * <left> and merge them into <list>. */ l = listHead(&left); r = listHead(list); /* As long as we still have an element from <left>... */ while (l) { /* If we reached the end of <list> *or* <l> should be left of <r>... */ if (r == NULL || cmp(l, r) <= 0) { f_listRemove(&left, l); /* Remove <l> from <left>... */ f_listInsert(list, l, r); /* Put <l> into <list>, before <r>. */ l = listHead(&left); /* Get the next <l>. */ } else { r = f_listNext(r); /* Move onto the next <r>. */ } } }
int main(int argc, char *argv[]) { Page *page = pageFetch("http://www.cs.columbia.edu/~sedwards/"); // printf("%s\n", page->url); // printf("%s\n", page->html); NODE * first = pageFind(page, "#titlebar"); printf("id: %s\n",elementAttr((Element*)listHead(first), "id")); printf("text: %s\n",elementText((Element*)listHead(first))); printf("type: %s\n\n\n",elementType((Element*)listHead(first))); NODE *child_list = elementChildren(page, (Element*)listHead(first)); Element * e = (Element*)listHead(listTail(child_list)); printf("text first child: %s\n",elementText(e)); printf("type first child: %s\n",elementType(e)); printf("id first child: %s\n",elementAttr(e,"id")); // // NODE * first = listNew(); // listAddLast(first, "a"); // listAddLast(first, "b"); // listAddLast(first, "c"); // listAddLast(first, "c"); // listAddLast(first, "d"); // listAddLast(first, "e"); // listPrint(first); // printf("\n"); // list_remove(first,3); // // listPrint(first); // printf("\n"); // // NODE * newFirst = listNew(); // NODE * f = listAddLast(newFirst, "f"); // listAddAfter(f,"G"); // listAddLast(newFirst, "h"); // listConcate(first,newFirst); // listPrint(first); // printf("\n"); // listSet(f,"F Modified"); // listPrint(first); // // // printf("should be a: %s\n",listHead(first)); // printf("should be b: %s\n",listHead(listTail(first))); return 0; }
void* listRemove(SList* list, int index) { void* res = NULL; if(list) { listHead(list); if(!listEmpty(list)) { if(index == 0) { SListNode* to_delete = list->head; list->head = list->head->next; res = to_delete->data; free(to_delete); } else { int i = 1; while(listNext(list) && i != index-1) ++i; if( i == index-1) { // l'element existe SListNode* to_delete = list->curr->next; list->curr->next = list->curr->next->next; res = to_delete->data; free(to_delete); } } } } return res; }
/* * Write a log message out to all output channels. */ static void log_output(Logger *logger) { LOG_Output *out; for (out = listHead(&logger->outputs); out; out = listNext(out)) { pthread_mutex_lock(&out->output); switch(out->type) { case LOG_OT_UDP: case LOG_OT_TCP: case LOG_OT_FD: tcpWrite(out->u.fd, bufGet(&logger->scratch), bufLen(&logger->scratch)); break; case LOG_OT_FILE: case LOG_OT_FP: fwrite(bufGet(&logger->scratch), bufLen(&logger->scratch), 1, out->u.fp); fflush(out->u.fp); break; case LOG_OT_SYSLOG: syslog(out->u.priority, "%s", bufGet(&logger->scratch)); break; } pthread_mutex_unlock(&out->output); } }
int listSize(SList* list) { int res = 0; if(list) { listHead(list); ++res; while(listNext(list)) ++res; } return res; }
std::vector<int> Expr::footprint(const Func& f) const { MLVal fp = footprintOfFuncInExpr(f.name(), contents->node); assert(!listEmpty(fp)); std::vector<int> footprint; for (; !listEmpty(fp); fp = listTail(fp)) { footprint.push_back(int(listHead(fp))); } return footprint; }
int listFind(SList* list, void* elem) { listHead(list); while(listCurrent(list) != elem) { if(!listNext(list)) { return 0; } } return 1; }
int listSearch(SList* list, void* elem, int(*cmp)(void*, void*)) { int found = 0; if(list && elem && cmp && !listEmpty(list)) { listHead(list); do { found = cmp(listCurrent(list), elem); }while(!found && listNext(list)); } return found; }
/* * Write the requested prefixes into the log message. */ static void log_write_prefixes(Logger *logger, const char *file, int line, const char *func) { struct tm tm = { 0 }; struct timeval tv = { 0 }; LOG_Prefix *pfx; tv.tv_sec = -1; for (pfx = listHead(&logger->prefixes); pfx; pfx = listNext(pfx)) { switch(pfx->type) { case LOG_PT_DATE: if (tv.tv_sec == -1) log_get_time(&tm, &tv); bufAddF(&logger->scratch, "%04d-%02d-%02d ", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday); break; case LOG_PT_TIME: if (tv.tv_sec == -1) log_get_time(&tm, &tv); bufAddF(&logger->scratch, "%02d:%02d:", tm.tm_hour, tm.tm_min); if (pfx->u.precision == 0) { bufAddF(&logger->scratch, "%02d ", tm.tm_sec); } else { double seconds = (double) tm.tm_sec + (double) tv.tv_usec / 1000000.0; bufAddF(&logger->scratch, "%0*.*f ", 3 + pfx->u.precision, pfx->u.precision, seconds); } break; case LOG_PT_FILE: bufAddF(&logger->scratch, "%s ", file); break; case LOG_PT_LINE: bufAddF(&logger->scratch, "%d ", line); break; case LOG_PT_FUNC: bufAddF(&logger->scratch, "%s ", func); break; case LOG_PT_STR: bufAddF(&logger->scratch, "%s ", pfx->u.string); break; } } }
/* * Cancel the timer that was set for time <t> with callback <cb>. */ void disDropTime(Dispatcher *dis, double t, void (*cb)(Dispatcher *dis, double t, void *udata)) { DIS_Timer *timer; for (timer = listHead(&dis->timers); timer; timer = listNext(timer)) { if (timer->t == t && timer->cb == cb) { listRemove(&dis->timers, timer); free(timer); return; } } dbgAbort(stderr, "no such timer\n"); }
/* * Arrange for <cb> to be called at time <t>, which is the (double precision floating point) number * of seconds since 00:00:00 UTC on 1970-01-01 (aka. the UNIX epoch). <cb> will be called with the * given <dis>, <t> and <udata>. You can get the current time using nowd() from utils.c. */ void disOnTime(Dispatcher *dis, double t, void (*cb)(Dispatcher *dis, double t, void *udata), const void *udata) { DIS_Timer *next_timer, *new_timer = calloc(1, sizeof(DIS_Timer)); new_timer->t = t; new_timer->cb = cb; new_timer->udata = udata; for (next_timer = listHead(&dis->timers); next_timer; next_timer = listNext(next_timer)) { if (next_timer->t > new_timer->t) break; } listInsert(&dis->timers, new_timer, next_timer); }
HETIMERELEM etimerFind(HETIMER timer, ETimerHandler callback,void *param) { etimerStruct *tm = (etimerStruct *)timer; etimerNode node; int loc=0; if (!timer) return (HETIMERELEM)RVERROR; /* NULL function */ node.callback = callback; node.param = param; if ( (loc = listFind(tm->timer, listHead(tm->timer), (void *)&node))<0 ) return (HETIMERELEM)RVERROR; else return ((HETIMERELEM)loc); }
void plateau_realiser_capture(SPlateau* plateau, SChaines* chaines, SChaine* chaine) { if(chaine) { SList* list = listEnsembleColore(chaine); listHead(list); do { SPosition* pos = listCurrent(list); plateau_set(plateau, pos, VIDE); }while(listNext(list)); //listDelete(list); listRemoveElement(chaines, chaine); //free(chaine); } }
void renderList(sLinkedList* list, sSdlWrapper* wrap) { Uint32 bg = makeColor(255, 50, 25, 175); Uint32 fg = makeColor(255, 75, 50, 200); if(listEmpty(list)) return; sListIterator* it = 0; listHead(list, &it); point* toDraw = 0; int x = 0; int y = 0; while(!listIteratorEnd(it)) { toDraw = (point*)listGet(it); pointGetPos(toDraw, &x, &y); drawBevel(wrap, x*25, y*25, 25, 25, bg, fg); listIteratorNext(it); } free(it); }
void* listRemoveElement(SList* list, void* elem) { void* res = NULL; if(!listEmpty(list)) { SListNode* prev = NULL; SListNode* curr = NULL; listHead(list); int found = 0; do { prev = curr; curr = list->curr; if(listCurrent(list) == elem) { found = 1; if(curr == list->head) { list->head = list->head->next; list->curr = list->head; } else { prev->next = curr->next; list->curr = prev; } res = curr->data; free(curr); } }while(!found && listNext(list)); } return res; }
const char *get_script_locale(void) { return listHead(locale_stack); }
/* * Prepare a call to select() based on the files and timeouts set in <dis>. The necessary parameters * to select() are returned through <nfds>, <rfds>, <wfds> and <tv> (exception-fds should be set to * NULL). <*tv> is set to point to an appropriate timeout value, or NULL if no timeout is to be set. * This function will clear <rfds> and <wfds>, so if callers want to add their own file descriptors, * they should do so after calling this function. This function returns -1 if the first timeout * should already have occurred, otherwise 0. */ int disPrepareSelect(Dispatcher *dis, int *nfds, fd_set *rfds, fd_set *wfds, struct timeval **tv) { int fd; double delta_t; DIS_Timer *timer; *nfds = paCount(&dis->files); FD_ZERO(rfds); FD_ZERO(wfds); P dbgPrint(stderr, "File descriptors:"); for (fd = 0; fd < *nfds; fd++) { DIS_File *file = paGet(&dis->files, fd); if (file == NULL) continue; P fprintf(stderr, " %d", fd); FD_SET(fd, rfds); if (bufLen(&file->outgoing) > 0) FD_SET(fd, wfds); P { fprintf(stderr, " (%s%s)", FD_ISSET(fd, rfds) ? "r" : "", FD_ISSET(fd, wfds) ? "w" : ""); } } P fprintf(stderr, "\n"); P dbgPrint(stderr, "%d pending timers:\n", listLength(&dis->timers)); P for (timer = listHead(&dis->timers); timer; timer = listNext(timer)) { fprintf(stderr, "\t%f seconds\n", timer->t - nowd()); } if ((timer = listHead(&dis->timers)) == NULL) { *tv = NULL; } else if ((delta_t = timer->t - nowd()) < 0) { #if 0 P dbgPrint(stderr, "First timer %f seconds ago, return -1\n", -delta_t); return -1; #endif dis->tv.tv_sec = 0; dis->tv.tv_usec = 0; *tv = &dis->tv; } else { P dbgPrint(stderr, "First timer in %f seconds.\n", delta_t); dis->tv.tv_sec = (int) delta_t; dis->tv.tv_usec = 1000000 * fmod(delta_t, 1.0); *tv = &dis->tv; } return 0; }
int main(int argc, char *argv[]) { List list; Data *data[6]; int i, errors = 0; for (i = 0; i < 6; i++) { data[i] = calloc(1, sizeof(Data)); } listInitialize(&list); TEST_INT(listLength(&list), 0); TEST_INT(listIsEmpty(&list), TRUE); listAppendTail(&list, data[0]); listAppendTail(&list, data[1]); listAppendTail(&list, data[2]); listAppendTail(&list, data[3]); TEST_INT(listLength(&list), 4); TEST_INT(listIsEmpty(&list), FALSE); TEST_PTR(listHead(&list), data[0]); TEST_PTR(listTail(&list), data[3]); TEST_PTR(listNext(data[0]), data[1]); TEST_PTR(listNext(data[1]), data[2]); TEST_PTR(listNext(data[2]), data[3]); TEST_PTR(listNext(data[3]), NULL); TEST_PTR(listPrev(data[3]), data[2]); TEST_PTR(listPrev(data[2]), data[1]); TEST_PTR(listPrev(data[1]), data[0]); TEST_PTR(listPrev(data[0]), NULL); TEST_PTR(listContaining(data[0]), &list); TEST_PTR(listContaining(data[1]), &list); TEST_PTR(listContaining(data[2]), &list); TEST_PTR(listContaining(data[3]), &list); listRemove(&list, data[0]); listRemove(&list, data[1]); listRemove(&list, data[2]); listRemove(&list, data[3]); TEST_INT(listLength(&list), 0); TEST_INT(listIsEmpty(&list), TRUE); TEST_PTR(listContaining(data[0]), NULL); TEST_PTR(listContaining(data[1]), NULL); TEST_PTR(listContaining(data[2]), NULL); TEST_PTR(listContaining(data[3]), NULL); listInsertHead(&list, data[3]); listInsertHead(&list, data[2]); listInsertHead(&list, data[1]); listInsertHead(&list, data[0]); TEST_INT(listLength(&list), 4); TEST_INT(listIsEmpty(&list), FALSE); TEST_PTR(listHead(&list), data[0]); TEST_PTR(listTail(&list), data[3]); TEST_PTR(listNext(data[0]), data[1]); TEST_PTR(listNext(data[1]), data[2]); TEST_PTR(listNext(data[2]), data[3]); TEST_PTR(listNext(data[3]), NULL); TEST_PTR(listPrev(data[3]), data[2]); TEST_PTR(listPrev(data[2]), data[1]); TEST_PTR(listPrev(data[1]), data[0]); TEST_PTR(listPrev(data[0]), NULL); TEST_PTR(listRemoveHead(&list), data[0]); TEST_PTR(listRemoveHead(&list), data[1]); TEST_PTR(listRemoveTail(&list), data[3]); TEST_PTR(listRemoveTail(&list), data[2]); TEST_INT(listLength(&list), 0); TEST_INT(listIsEmpty(&list), TRUE); listAppendTail(&list, data[0]); listAppendTail(&list, data[3]); listAppend(&list, data[1], data[0]); listInsert(&list, data[2], data[3]); TEST_PTR(listRemoveHead(&list), data[0]); TEST_PTR(listRemoveHead(&list), data[1]); TEST_PTR(listRemoveTail(&list), data[3]); TEST_PTR(listRemoveTail(&list), data[2]); data[0]->i = 3; data[1]->i = 4; data[2]->i = 5; data[3]->i = 1; data[4]->i = 2; data[5]->i = 3; listAppendTail(&list, data[0]); listAppendTail(&list, data[1]); listAppendTail(&list, data[2]); listAppendTail(&list, data[3]); listAppendTail(&list, data[4]); listAppendTail(&list, data[5]); listSort(&list, cmp); TEST_PTR(listRemoveHead(&list), data[3]); TEST_PTR(listRemoveHead(&list), data[4]); TEST_PTR(listRemoveHead(&list), data[0]); TEST_PTR(listRemoveHead(&list), data[5]); TEST_PTR(listRemoveHead(&list), data[1]); TEST_PTR(listRemoveHead(&list), data[2]); exit(errors); }