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