diff --git a/bindings.c b/bindings.c index 0132f65..dfcb5d1 100644 --- a/bindings.c +++ b/bindings.c @@ -10,4 +10,4 @@ #include "bindings.h" -binding_list_t bindings = TAILQ_HEAD_INITIALIZER(bindings); +binding_list_t bindings = TTS_TAILQ_HEAD_INITIALIZER(bindings); diff --git a/bindings.h b/bindings.h index 8b7df24..1819a08 100644 --- a/bindings.h +++ b/bindings.h @@ -13,7 +13,7 @@ #include "wide.h" #include "functions.h" -#include "queue.h" +#include "tailq.h" typedef struct tkey { INT ky_code; @@ -21,13 +21,14 @@ typedef struct tkey { } tkey_t; typedef struct binding { - INT bi_code; - tkey_t *bi_key; - function_t *bi_func; - TAILQ_ENTRY(binding) bi_entries; + INT bi_code; + tkey_t *bi_key; + function_t *bi_func; + + TTS_TAILQ_ENTRY(binding) bi_entries; } binding_t; -typedef TAILQ_HEAD(bindlist, binding) binding_list_t; +typedef TTS_TAILQ_HEAD(bindlist, binding) binding_list_t; extern binding_list_t bindings; tkey_t *find_key(const WCHAR *name); diff --git a/configure b/configure index a3798e9..836b004 100755 --- a/configure +++ b/configure @@ -4243,7 +4243,7 @@ fi oLDFLAGS="$LDFLAGS" -LDFLAGS="$LDFLAGS -framework CoreFoundation -framework IOKit" +LDFLAGS="$LDFLAGS -framework IOKit" for ac_func in IORegisterForSystemPower do : ac_fn_c_check_func "$LINENO" "IORegisterForSystemPower" "ac_cv_func_IORegisterForSystemPower" diff --git a/configure.ac b/configure.ac index 05984dd..dce8aa5 100644 --- a/configure.ac +++ b/configure.ac @@ -17,7 +17,7 @@ AC_CHECK_HEADERS([IOKit/pwr_mgt/IOPMLib.h]) AC_CHECK_LIB(m, round) oLDFLAGS="$LDFLAGS" -LDFLAGS="$LDFLAGS -framework CoreFoundation -framework IOKit" +LDFLAGS="$LDFLAGS -framework IOKit" AC_CHECK_FUNCS([IORegisterForSystemPower], [], [LDFLAGS="$oLDFLAGS"]) AC_CONFIG_FILES([Makefile]) diff --git a/entry.c b/entry.c index b6e4ce6..6bcfefa 100644 --- a/entry.c +++ b/entry.c @@ -17,7 +17,7 @@ #include "wide.h" #include "tts.h" -entry_list entries = TAILQ_HEAD_INITIALIZER(entries); +entry_list entries = TTS_TAILQ_HEAD_INITIALIZER(entries); entry_t *running; @@ -32,7 +32,7 @@ entry_t *en; if (auto_nonbillable && STRSTR(desc, auto_nonbillable)) en->en_flags.efl_nonbillable = 1; - TAILQ_INSERT_HEAD(&entries, en, en_entries); + TTS_TAILQ_INSERT_HEAD(&entries, en, en_entries); en->en_desc = STRDUP(desc); time(&en->en_created); @@ -93,7 +93,7 @@ time_t day = time_day(when); time_t sum = 0; entry_t *en; int rnd = incr * 60; - TAILQ_FOREACH(en, &entries, en_entries) { + TTS_TAILQ_FOREACH(en, &entries, en_entries) { time_t n; if (entry_day(en) > day) diff --git a/entry.h b/entry.h index 68b45a1..54e33c0 100644 --- a/entry.h +++ b/entry.h @@ -13,7 +13,7 @@ #include -#include "queue.h" +#include "tailq.h" #include "wide.h" typedef struct entry { @@ -29,10 +29,10 @@ typedef struct entry { int efl_deleted:1; int efl_nonbillable:1; } en_flags; - TAILQ_ENTRY(entry) en_entries; + TTS_TAILQ_ENTRY(entry) en_entries; } entry_t; -typedef TAILQ_HEAD(entrylist, entry) entry_list; +typedef TTS_TAILQ_HEAD(entrylist, entry) entry_list; extern entry_list entries; extern entry_t *running; diff --git a/functions.c b/functions.c index 3b8631a..57c91a0 100644 --- a/functions.c +++ b/functions.c @@ -53,7 +53,7 @@ kquit() entry_t *en; int ndel = 0; - TAILQ_FOREACH(en, &entries, en_entries) { + TTS_TAILQ_FOREACH(en, &entries, en_entries) { if (en->en_flags.efl_deleted) ndel++; } @@ -140,7 +140,7 @@ kmarkdel() entry_t *en; int nmarked = 0; - TAILQ_FOREACH(en, &entries, en_entries) { + TTS_TAILQ_FOREACH(en, &entries, en_entries) { if (en->en_flags.efl_marked) { nmarked++; en->en_flags.efl_deleted = 1; @@ -166,17 +166,17 @@ ksync() { entry_t *en, *ten; - TAILQ_FOREACH_SAFE(en, &entries, en_entries, ten) { + TTS_TAILQ_FOREACH_SAFE(en, &entries, en_entries, ten) { if (!en->en_flags.efl_deleted) continue; if (en == curent) curent = NULL; - TAILQ_REMOVE(&entries, en, en_entries); + TTS_TAILQ_REMOVE(&entries, en, en_entries); entry_free(en); } if (curent == NULL) - curent = TAILQ_FIRST(&entries); + curent = TTS_TAILQ_FIRST(&entries); save(); } @@ -188,7 +188,7 @@ entry_t *prev = curent; return; do { - if ((prev = TAILQ_PREV(prev, entrylist, en_entries)) == NULL) + if ((prev = TTS_TAILQ_PREV(prev, entrylist, en_entries)) == NULL) break; } while (!showinv && prev->en_flags.efl_invoiced); @@ -210,7 +210,7 @@ entry_t *next = curent; return; do { - if ((next = TAILQ_NEXT(next, en_entries)) == NULL) + if ((next = TTS_TAILQ_NEXT(next, en_entries)) == NULL) break; } while (!showinv && next->en_flags.efl_invoiced); @@ -230,7 +230,7 @@ kinvoiced() entry_t *en; int anymarked = 0; - TAILQ_FOREACH(en, &entries, en_entries) { + TTS_TAILQ_FOREACH(en, &entries, en_entries) { if (!en->en_flags.efl_marked) continue; anymarked = 1; @@ -254,8 +254,8 @@ int anymarked = 0; en = curent; if (showinv) { - if (TAILQ_NEXT(curent, en_entries) != NULL) - curent = TAILQ_NEXT(curent, en_entries); + if (TTS_TAILQ_NEXT(curent, en_entries) != NULL) + curent = TTS_TAILQ_NEXT(curent, en_entries); return; } @@ -263,7 +263,7 @@ int anymarked = 0; * Try to find the next uninvoiced request to move the cursor to. */ for (;;) { - if ((curent = TAILQ_NEXT(curent, en_entries)) == NULL) + if ((curent = TTS_TAILQ_NEXT(curent, en_entries)) == NULL) break; /* end of list */ if (!curent->en_flags.efl_invoiced) return; @@ -273,7 +273,7 @@ int anymarked = 0; * We didn't find any, so try searching backwards instead. */ for (curent = en;;) { - if ((curent = TAILQ_PREV(curent, entrylist, en_entries)) == NULL) + if ((curent = TTS_TAILQ_PREV(curent, entrylist, en_entries)) == NULL) break; /* end of list */ if (!curent->en_flags.efl_invoiced) return; @@ -286,7 +286,7 @@ kbillable() entry_t *en; int anymarked = 0; - TAILQ_FOREACH(en, &entries, en_entries) { + TTS_TAILQ_FOREACH(en, &entries, en_entries) { if (!en->en_flags.efl_marked) continue; anymarked = 1; @@ -378,7 +378,7 @@ entry_t *en = curent; return; if (!curent) { - curent = TAILQ_FIRST(&entries); + curent = TTS_TAILQ_FIRST(&entries); return; } @@ -386,7 +386,7 @@ entry_t *en = curent; * Try to find the next uninvoiced request to move the cursor to. */ for (;;) { - if ((curent = TAILQ_NEXT(curent, en_entries)) == NULL) + if ((curent = TTS_TAILQ_NEXT(curent, en_entries)) == NULL) break; /* end of list */ if (!curent->en_flags.efl_invoiced) return; @@ -396,7 +396,7 @@ entry_t *en = curent; * We didn't find any, so try searching backwards instead. */ for (curent = en;;) { - if ((curent = TAILQ_PREV(curent, entrylist, en_entries)) == NULL) + if ((curent = TTS_TAILQ_PREV(curent, entrylist, en_entries)) == NULL) break; /* end of list */ if (!curent->en_flags.efl_invoiced) return; @@ -537,7 +537,7 @@ int h, m, s = 0; /* * Count number of marked entries and the summed time. */ - TAILQ_FOREACH(en, &entries, en_entries) { + TTS_TAILQ_FOREACH(en, &entries, en_entries) { if (!en->en_flags.efl_marked || en == curent) continue; nmarked++; @@ -561,13 +561,13 @@ int h, m, s = 0; if (!yesno(pr)) return; - TAILQ_FOREACH_SAFE(en, &entries, en_entries, ten) { + TTS_TAILQ_FOREACH_SAFE(en, &entries, en_entries, ten) { if (!en->en_flags.efl_marked || en == curent) continue; if (en->en_started) entry_stop(en); curent->en_secs += en->en_secs; - TAILQ_REMOVE(&entries, en, en_entries); + TTS_TAILQ_REMOVE(&entries, en, en_entries); entry_free(en); } save(); @@ -586,12 +586,12 @@ INT c; binding_t *bi; /* Count the number of bindings */ - TAILQ_FOREACH(bi, &bindings, bi_entries) + TTS_TAILQ_FOREACH(bi, &bindings, bi_entries) nhelp++; help = calloc(nhelp, sizeof(const WCHAR *)); i = 0; - TAILQ_FOREACH(bi, &bindings, bi_entries) { + TTS_TAILQ_FOREACH(bi, &bindings, bi_entries) { WCHAR s[128]; if (bi->bi_key) SNPRINTF(s, WSIZEOF(s), WIDE("%-10"FMT_L"s %"FMT_L"s (%"FMT_L"s)"), @@ -660,7 +660,7 @@ void kunmarkall() { entry_t *en; - TAILQ_FOREACH(en, &entries, en_entries) + TTS_TAILQ_FOREACH(en, &entries, en_entries) en->en_flags.efl_marked = 0; } @@ -746,10 +746,10 @@ entry_t *start, *cur; cur = start = curent; for (;;) { - cur = TAILQ_NEXT(cur, en_entries); + cur = TTS_TAILQ_NEXT(cur, en_entries); if (cur == NULL) { drawstatus(WIDE("Search reached last entry, continuing from top.")); - cur = TAILQ_FIRST(&entries); + cur = TTS_TAILQ_FIRST(&entries); } if (cur == start) { diff --git a/queue.h b/queue.h deleted file mode 100644 index fc3c633..0000000 --- a/queue.h +++ /dev/null @@ -1,611 +0,0 @@ -/*- - * Copyright (c) 1991, 1993 - * The Regents of the University of California. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - * - * @(#)queue.h 8.5 (Berkeley) 8/20/94 - * FreeBSD: release/9.0.0/sys/sys/queue.h 221843 2011-05-13 15:49:23Z mdf - */ - -#ifndef TTS_QUEUE_H -#define TTS_QUEUE_H - -/* - * This file defines four types of data structures: singly-linked lists, - * singly-linked tail queues, lists and tail queues. - * - * A singly-linked list is headed by a single forward pointer. The elements - * are singly linked for minimum space and pointer manipulation overhead at - * the expense of O(n) removal for arbitrary elements. New elements can be - * added to the list after an existing element or at the head of the list. - * Elements being removed from the head of the list should use the explicit - * macro for this purpose for optimum efficiency. A singly-linked list may - * only be traversed in the forward direction. Singly-linked lists are ideal - * for applications with large datasets and few or no removals or for - * implementing a LIFO queue. - * - * A singly-linked tail queue is headed by a pair of pointers, one to the - * head of the list and the other to the tail of the list. The elements are - * singly linked for minimum space and pointer manipulation overhead at the - * expense of O(n) removal for arbitrary elements. New elements can be added - * to the list after an existing element, at the head of the list, or at the - * end of the list. Elements being removed from the head of the tail queue - * should use the explicit macro for this purpose for optimum efficiency. - * A singly-linked tail queue may only be traversed in the forward direction. - * Singly-linked tail queues are ideal for applications with large datasets - * and few or no removals or for implementing a FIFO queue. - * - * A list is headed by a single forward pointer (or an array of forward - * pointers for a hash table header). The elements are doubly linked - * so that an arbitrary element can be removed without a need to - * traverse the list. New elements can be added to the list before - * or after an existing element or at the head of the list. A list - * may only be traversed in the forward direction. - * - * A tail queue is headed by a pair of pointers, one to the head of the - * list and the other to the tail of the list. The elements are doubly - * linked so that an arbitrary element can be removed without a need to - * traverse the list. New elements can be added to the list before or - * after an existing element, at the head of the list, or at the end of - * the list. A tail queue may be traversed in either direction. - * - * For details on the use of these macros, see the queue(3) manual page. - * - * - * SLIST LIST STAILQ TAILQ - * _HEAD + + + + - * _HEAD_INITIALIZER + + + + - * _ENTRY + + + + - * _INIT + + + + - * _EMPTY + + + + - * _FIRST + + + + - * _NEXT + + + + - * _PREV - - - + - * _LAST - - + + - * _FOREACH + + + + - * _FOREACH_SAFE + + + + - * _FOREACH_REVERSE - - - + - * _FOREACH_REVERSE_SAFE - - - + - * _INSERT_HEAD + + + + - * _INSERT_BEFORE - + - + - * _INSERT_AFTER + + + + - * _INSERT_TAIL - - + + - * _CONCAT - - + + - * _REMOVE_AFTER + - + - - * _REMOVE_HEAD + - + - - * _REMOVE + + + + - * _SWAP + + + + - * - */ -#ifdef QUEUE_MACRO_DEBUG -/* Store the last 2 places the queue element or head was altered */ -struct qm_trace { - char * lastfile; - int lastline; - char * prevfile; - int prevline; -}; - -#define TRACEBUF struct qm_trace trace; -#define TRASHIT(x) do {(x) = (void *)-1;} while (0) -#define QMD_SAVELINK(name, link) void **name = (void *)&(link) - -#define QMD_TRACE_HEAD(head) do { \ - (head)->trace.prevline = (head)->trace.lastline; \ - (head)->trace.prevfile = (head)->trace.lastfile; \ - (head)->trace.lastline = __LINE__; \ - (head)->trace.lastfile = __FILE__; \ -} while (0) - -#define QMD_TRACE_ELEM(elem) do { \ - (elem)->trace.prevline = (elem)->trace.lastline; \ - (elem)->trace.prevfile = (elem)->trace.lastfile; \ - (elem)->trace.lastline = __LINE__; \ - (elem)->trace.lastfile = __FILE__; \ -} while (0) - -#else -#define QMD_TRACE_ELEM(elem) -#define QMD_TRACE_HEAD(head) -#define QMD_SAVELINK(name, link) -#define TRACEBUF -#define TRASHIT(x) -#endif /* QUEUE_MACRO_DEBUG */ - -/* - * Singly-linked List declarations. - */ -#define SLIST_HEAD(name, type) \ -struct name { \ - struct type *slh_first; /* first element */ \ -} - -#define SLIST_HEAD_INITIALIZER(head) \ - { NULL } - -#define SLIST_ENTRY(type) \ -struct { \ - struct type *sle_next; /* next element */ \ -} - -/* - * Singly-linked List functions. - */ -#define SLIST_EMPTY(head) ((head)->slh_first == NULL) - -#define SLIST_FIRST(head) ((head)->slh_first) - -#define SLIST_FOREACH(var, head, field) \ - for ((var) = SLIST_FIRST((head)); \ - (var); \ - (var) = SLIST_NEXT((var), field)) - -#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = SLIST_FIRST((head)); \ - (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ - for ((varp) = &SLIST_FIRST((head)); \ - ((var) = *(varp)) != NULL; \ - (varp) = &SLIST_NEXT((var), field)) - -#define SLIST_INIT(head) do { \ - SLIST_FIRST((head)) = NULL; \ -} while (0) - -#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ - SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \ - SLIST_NEXT((slistelm), field) = (elm); \ -} while (0) - -#define SLIST_INSERT_HEAD(head, elm, field) do { \ - SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \ - SLIST_FIRST((head)) = (elm); \ -} while (0) - -#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) - -#define SLIST_REMOVE(head, elm, type, field) do { \ - QMD_SAVELINK(oldnext, (elm)->field.sle_next); \ - if (SLIST_FIRST((head)) == (elm)) { \ - SLIST_REMOVE_HEAD((head), field); \ - } \ - else { \ - struct type *curelm = SLIST_FIRST((head)); \ - while (SLIST_NEXT(curelm, field) != (elm)) \ - curelm = SLIST_NEXT(curelm, field); \ - SLIST_REMOVE_AFTER(curelm, field); \ - } \ - TRASHIT(*oldnext); \ -} while (0) - -#define SLIST_REMOVE_AFTER(elm, field) do { \ - SLIST_NEXT(elm, field) = \ - SLIST_NEXT(SLIST_NEXT(elm, field), field); \ -} while (0) - -#define SLIST_REMOVE_HEAD(head, field) do { \ - SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ -} while (0) - -#define SLIST_SWAP(head1, head2, type) do { \ - struct type *swap_first = SLIST_FIRST(head1); \ - SLIST_FIRST(head1) = SLIST_FIRST(head2); \ - SLIST_FIRST(head2) = swap_first; \ -} while (0) - -/* - * Singly-linked Tail queue declarations. - */ -#define STAILQ_HEAD(name, type) \ -struct name { \ - struct type *stqh_first;/* first element */ \ - struct type **stqh_last;/* addr of last next element */ \ -} - -#define STAILQ_HEAD_INITIALIZER(head) \ - { NULL, &(head).stqh_first } - -#define STAILQ_ENTRY(type) \ -struct { \ - struct type *stqe_next; /* next element */ \ -} - -/* - * Singly-linked Tail queue functions. - */ -#define STAILQ_CONCAT(head1, head2) do { \ - if (!STAILQ_EMPTY((head2))) { \ - *(head1)->stqh_last = (head2)->stqh_first; \ - (head1)->stqh_last = (head2)->stqh_last; \ - STAILQ_INIT((head2)); \ - } \ -} while (0) - -#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) - -#define STAILQ_FIRST(head) ((head)->stqh_first) - -#define STAILQ_FOREACH(var, head, field) \ - for((var) = STAILQ_FIRST((head)); \ - (var); \ - (var) = STAILQ_NEXT((var), field)) - - -#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = STAILQ_FIRST((head)); \ - (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define STAILQ_INIT(head) do { \ - STAILQ_FIRST((head)) = NULL; \ - (head)->stqh_last = &STAILQ_FIRST((head)); \ -} while (0) - -#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \ - if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\ - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ - STAILQ_NEXT((tqelm), field) = (elm); \ -} while (0) - -#define STAILQ_INSERT_HEAD(head, elm, field) do { \ - if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \ - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ - STAILQ_FIRST((head)) = (elm); \ -} while (0) - -#define STAILQ_INSERT_TAIL(head, elm, field) do { \ - STAILQ_NEXT((elm), field) = NULL; \ - *(head)->stqh_last = (elm); \ - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ -} while (0) - -#define STAILQ_LAST(head, type, field) \ - (STAILQ_EMPTY((head)) ? \ - NULL : \ - ((struct type *)(void *) \ - ((char *)((head)->stqh_last) - __offsetof(struct type, field)))) - -#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) - -#define STAILQ_REMOVE(head, elm, type, field) do { \ - QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \ - if (STAILQ_FIRST((head)) == (elm)) { \ - STAILQ_REMOVE_HEAD((head), field); \ - } \ - else { \ - struct type *curelm = STAILQ_FIRST((head)); \ - while (STAILQ_NEXT(curelm, field) != (elm)) \ - curelm = STAILQ_NEXT(curelm, field); \ - STAILQ_REMOVE_AFTER(head, curelm, field); \ - } \ - TRASHIT(*oldnext); \ -} while (0) - -#define STAILQ_REMOVE_AFTER(head, elm, field) do { \ - if ((STAILQ_NEXT(elm, field) = \ - STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \ - (head)->stqh_last = &STAILQ_NEXT((elm), field); \ -} while (0) - -#define STAILQ_REMOVE_HEAD(head, field) do { \ - if ((STAILQ_FIRST((head)) = \ - STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \ - (head)->stqh_last = &STAILQ_FIRST((head)); \ -} while (0) - -#define STAILQ_SWAP(head1, head2, type) do { \ - struct type *swap_first = STAILQ_FIRST(head1); \ - struct type **swap_last = (head1)->stqh_last; \ - STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \ - (head1)->stqh_last = (head2)->stqh_last; \ - STAILQ_FIRST(head2) = swap_first; \ - (head2)->stqh_last = swap_last; \ - if (STAILQ_EMPTY(head1)) \ - (head1)->stqh_last = &STAILQ_FIRST(head1); \ - if (STAILQ_EMPTY(head2)) \ - (head2)->stqh_last = &STAILQ_FIRST(head2); \ -} while (0) - - -/* - * List declarations. - */ -#define LIST_HEAD(name, type) \ -struct name { \ - struct type *lh_first; /* first element */ \ -} - -#define LIST_HEAD_INITIALIZER(head) \ - { NULL } - -#define LIST_ENTRY(type) \ -struct { \ - struct type *le_next; /* next element */ \ - struct type **le_prev; /* address of previous next element */ \ -} - -/* - * List functions. - */ - -#define LIST_EMPTY(head) ((head)->lh_first == NULL) - -#define LIST_FIRST(head) ((head)->lh_first) - -#define LIST_FOREACH(var, head, field) \ - for ((var) = LIST_FIRST((head)); \ - (var); \ - (var) = LIST_NEXT((var), field)) - -#define LIST_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = LIST_FIRST((head)); \ - (var) && ((tvar) = LIST_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define LIST_INIT(head) do { \ - LIST_FIRST((head)) = NULL; \ -} while (0) - -#define LIST_INSERT_AFTER(listelm, elm, field) do { \ - QMD_LIST_CHECK_NEXT(listelm, field); \ - if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\ - LIST_NEXT((listelm), field)->field.le_prev = \ - &LIST_NEXT((elm), field); \ - LIST_NEXT((listelm), field) = (elm); \ - (elm)->field.le_prev = &LIST_NEXT((listelm), field); \ -} while (0) - -#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ - QMD_LIST_CHECK_PREV(listelm, field); \ - (elm)->field.le_prev = (listelm)->field.le_prev; \ - LIST_NEXT((elm), field) = (listelm); \ - *(listelm)->field.le_prev = (elm); \ - (listelm)->field.le_prev = &LIST_NEXT((elm), field); \ -} while (0) - -#define LIST_INSERT_HEAD(head, elm, field) do { \ - QMD_LIST_CHECK_HEAD((head), field); \ - if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \ - LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\ - LIST_FIRST((head)) = (elm); \ - (elm)->field.le_prev = &LIST_FIRST((head)); \ -} while (0) - -#define LIST_PREV(elm, field) ((elm)->field.le_prev ? *(elm)->field.le_prev : NULL) -#define LIST_NEXT(elm, field) ((elm)->field.le_next) - -#define LIST_REMOVE(elm, field) do { \ - QMD_SAVELINK(oldnext, (elm)->field.le_next); \ - QMD_SAVELINK(oldprev, (elm)->field.le_prev); \ - QMD_LIST_CHECK_NEXT(elm, field); \ - QMD_LIST_CHECK_PREV(elm, field); \ - if (LIST_NEXT((elm), field) != NULL) \ - LIST_NEXT((elm), field)->field.le_prev = \ - (elm)->field.le_prev; \ - *(elm)->field.le_prev = LIST_NEXT((elm), field); \ - TRASHIT(*oldnext); \ - TRASHIT(*oldprev); \ -} while (0) - -#define LIST_SWAP(head1, head2, type, field) do { \ - struct type *swap_tmp = LIST_FIRST((head1)); \ - LIST_FIRST((head1)) = LIST_FIRST((head2)); \ - LIST_FIRST((head2)) = swap_tmp; \ - if ((swap_tmp = LIST_FIRST((head1))) != NULL) \ - swap_tmp->field.le_prev = &LIST_FIRST((head1)); \ - if ((swap_tmp = LIST_FIRST((head2))) != NULL) \ - swap_tmp->field.le_prev = &LIST_FIRST((head2)); \ -} while (0) - -/* - * Tail queue declarations. - */ -#define TAILQ_HEAD(name, type) \ -struct name { \ - struct type *tqh_first; /* first element */ \ - struct type **tqh_last; /* addr of last next element */ \ - TRACEBUF \ -} - -#define TAILQ_HEAD_INITIALIZER(head) \ - { NULL, &(head).tqh_first } - -#define TAILQ_ENTRY(type) \ -struct { \ - struct type *tqe_next; /* next element */ \ - struct type **tqe_prev; /* address of previous next element */ \ - TRACEBUF \ -} - -/* - * Tail queue functions. - */ -#if (defined(_KERNEL) && defined(INVARIANTS)) -#define QMD_TAILQ_CHECK_HEAD(head, field) do { \ - if (!TAILQ_EMPTY(head) && \ - TAILQ_FIRST((head))->field.tqe_prev != \ - &TAILQ_FIRST((head))) \ - panic("Bad tailq head %p first->prev != head", (head)); \ -} while (0) - -#define QMD_TAILQ_CHECK_TAIL(head, field) do { \ - if (*(head)->tqh_last != NULL) \ - panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); \ -} while (0) - -#define QMD_TAILQ_CHECK_NEXT(elm, field) do { \ - if (TAILQ_NEXT((elm), field) != NULL && \ - TAILQ_NEXT((elm), field)->field.tqe_prev != \ - &((elm)->field.tqe_next)) \ - panic("Bad link elm %p next->prev != elm", (elm)); \ -} while (0) - -#define QMD_TAILQ_CHECK_PREV(elm, field) do { \ - if (*(elm)->field.tqe_prev != (elm)) \ - panic("Bad link elm %p prev->next != elm", (elm)); \ -} while (0) -#else -#define QMD_TAILQ_CHECK_HEAD(head, field) -#define QMD_TAILQ_CHECK_TAIL(head, headname) -#define QMD_TAILQ_CHECK_NEXT(elm, field) -#define QMD_TAILQ_CHECK_PREV(elm, field) -#endif /* (_KERNEL && INVARIANTS) */ - -#define TAILQ_CONCAT(head1, head2, field) do { \ - if (!TAILQ_EMPTY(head2)) { \ - *(head1)->tqh_last = (head2)->tqh_first; \ - (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ - (head1)->tqh_last = (head2)->tqh_last; \ - TAILQ_INIT((head2)); \ - QMD_TRACE_HEAD(head1); \ - QMD_TRACE_HEAD(head2); \ - } \ -} while (0) - -#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) - -#define TAILQ_FIRST(head) ((head)->tqh_first) - -#define TAILQ_FOREACH(var, head, field) \ - for ((var) = TAILQ_FIRST((head)); \ - (var); \ - (var) = TAILQ_NEXT((var), field)) - -#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = TAILQ_FIRST((head)); \ - (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ - (var) = (tvar)) - -#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ - for ((var) = TAILQ_LAST((head), headname); \ - (var); \ - (var) = TAILQ_PREV((var), headname, field)) - -#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ - for ((var) = TAILQ_LAST((head), headname); \ - (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \ - (var) = (tvar)) - -#define TAILQ_INIT(head) do { \ - TAILQ_FIRST((head)) = NULL; \ - (head)->tqh_last = &TAILQ_FIRST((head)); \ - QMD_TRACE_HEAD(head); \ -} while (0) - -#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ - QMD_TAILQ_CHECK_NEXT(listelm, field); \ - if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\ - TAILQ_NEXT((elm), field)->field.tqe_prev = \ - &TAILQ_NEXT((elm), field); \ - else { \ - (head)->tqh_last = &TAILQ_NEXT((elm), field); \ - QMD_TRACE_HEAD(head); \ - } \ - TAILQ_NEXT((listelm), field) = (elm); \ - (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \ - QMD_TRACE_ELEM(&(elm)->field); \ - QMD_TRACE_ELEM(&listelm->field); \ -} while (0) - -#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ - QMD_TAILQ_CHECK_PREV(listelm, field); \ - (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ - TAILQ_NEXT((elm), field) = (listelm); \ - *(listelm)->field.tqe_prev = (elm); \ - (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \ - QMD_TRACE_ELEM(&(elm)->field); \ - QMD_TRACE_ELEM(&listelm->field); \ -} while (0) - -#define TAILQ_INSERT_HEAD(head, elm, field) do { \ - QMD_TAILQ_CHECK_HEAD(head, field); \ - if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \ - TAILQ_FIRST((head))->field.tqe_prev = \ - &TAILQ_NEXT((elm), field); \ - else \ - (head)->tqh_last = &TAILQ_NEXT((elm), field); \ - TAILQ_FIRST((head)) = (elm); \ - (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \ - QMD_TRACE_HEAD(head); \ - QMD_TRACE_ELEM(&(elm)->field); \ -} while (0) - -#define TAILQ_INSERT_TAIL(head, elm, field) do { \ - QMD_TAILQ_CHECK_TAIL(head, field); \ - TAILQ_NEXT((elm), field) = NULL; \ - (elm)->field.tqe_prev = (head)->tqh_last; \ - *(head)->tqh_last = (elm); \ - (head)->tqh_last = &TAILQ_NEXT((elm), field); \ - QMD_TRACE_HEAD(head); \ - QMD_TRACE_ELEM(&(elm)->field); \ -} while (0) - -#define TAILQ_LAST(head, headname) \ - (*(((struct headname *)((head)->tqh_last))->tqh_last)) - -#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) - -#define TAILQ_PREV(elm, headname, field) \ - (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) - -#define TAILQ_REMOVE(head, elm, field) do { \ - QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \ - QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \ - QMD_TAILQ_CHECK_NEXT(elm, field); \ - QMD_TAILQ_CHECK_PREV(elm, field); \ - if ((TAILQ_NEXT((elm), field)) != NULL) \ - TAILQ_NEXT((elm), field)->field.tqe_prev = \ - (elm)->field.tqe_prev; \ - else { \ - (head)->tqh_last = (elm)->field.tqe_prev; \ - QMD_TRACE_HEAD(head); \ - } \ - *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \ - TRASHIT(*oldnext); \ - TRASHIT(*oldprev); \ - QMD_TRACE_ELEM(&(elm)->field); \ -} while (0) - -#define TAILQ_SWAP(head1, head2, type, field) do { \ - struct type *swap_first = (head1)->tqh_first; \ - struct type **swap_last = (head1)->tqh_last; \ - (head1)->tqh_first = (head2)->tqh_first; \ - (head1)->tqh_last = (head2)->tqh_last; \ - (head2)->tqh_first = swap_first; \ - (head2)->tqh_last = swap_last; \ - if ((swap_first = (head1)->tqh_first) != NULL) \ - swap_first->field.tqe_prev = &(head1)->tqh_first; \ - else \ - (head1)->tqh_last = &(head1)->tqh_first; \ - if ((swap_first = (head2)->tqh_first) != NULL) \ - swap_first->field.tqe_prev = &(head2)->tqh_first; \ - else \ - (head2)->tqh_last = &(head2)->tqh_first; \ -} while (0) - -#endif /* !TTS_QUEUE_H */ diff --git a/tailq.h b/tailq.h new file mode 100644 index 0000000..940f155 --- /dev/null +++ b/tailq.h @@ -0,0 +1,163 @@ +/*- + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)queue.h 8.5 (Berkeley) 8/20/94 + * FreeBSD: release/9.0.0/sys/sys/queue.h 221843 2011-05-13 15:49:23Z mdf + */ + +#ifndef TTS_TAILQ_H +#define TTS_TAILQ_H + +/* + * Tail queue declarations. + */ +#define TTS_TAILQ_HEAD(name, type) \ +struct name { \ + struct type *tqh_first; /* first element */ \ + struct type **tqh_last; /* addr of last next element */ \ +} + +#define TTS_TAILQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).tqh_first } + +#define TTS_TAILQ_ENTRY(type) \ +struct { \ + struct type *tqe_next; /* next element */ \ + struct type **tqe_prev; /* address of previous next element */ \ +} + +#define TTS_TAILQ_CONCAT(head1, head2, field) do { \ + if (!TAILQ_EMPTY(head2)) { \ + *(head1)->tqh_last = (head2)->tqh_first; \ + (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ + (head1)->tqh_last = (head2)->tqh_last; \ + TTS_TAILQ_INIT((head2)); \ + } \ +} while (0) + +#define TTS_TAILQ_EMPTY(head) ((head)->tqh_first == NULL) + +#define TTS_TAILQ_FIRST(head) ((head)->tqh_first) + +#define TTS_TAILQ_FOREACH(var, head, field) \ + for ((var) = TTS_TAILQ_FIRST((head)); \ + (var); \ + (var) = TTS_TAILQ_NEXT((var), field)) + +#define TTS_TAILQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = TTS_TAILQ_FIRST((head)); \ + (var) && ((tvar) = TTS_TAILQ_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define TTS_TAILQ_FOREACH_REVERSE(var, head, headname, field) \ + for ((var) = TTS_TAILQ_LAST((head), headname); \ + (var); \ + (var) = TTS_TAILQ_PREV((var), headname, field)) + +#define TTS_TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)\ + for ((var) = TTS_TAILQ_LAST((head), headname); \ + (var) && ((tvar) = TTS_TAILQ_PREV((var), headname, field), 1); \ + (var) = (tvar)) + +#define TTS_TAILQ_INIT(head) do { \ + TTS_TAILQ_FIRST((head)) = NULL; \ + (head)->tqh_last = &TTS_TAILQ_FIRST((head)); \ +} while (0) + +#define TTS_TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ + if ((TTS_TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\ + TTS_TAILQ_NEXT((elm), field)->field.tqe_prev = \ + &TTS_TAILQ_NEXT((elm), field); \ + else { \ + (head)->tqh_last = &TTS_TAILQ_NEXT((elm), field); \ + } \ + TTS_TAILQ_NEXT((listelm), field) = (elm); \ + (elm)->field.tqe_prev = &TTS_TAILQ_NEXT((listelm), field); \ +} while (0) + +#define TTS_TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ + (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ + TTS_TAILQ_NEXT((elm), field) = (listelm); \ + *(listelm)->field.tqe_prev = (elm); \ + (listelm)->field.tqe_prev = &TTS_TAILQ_NEXT((elm), field); \ +} while (0) + +#define TTS_TAILQ_INSERT_HEAD(head, elm, field) do { \ + if ((TTS_TAILQ_NEXT((elm), field) = TTS_TAILQ_FIRST((head))) != NULL) \ + TTS_TAILQ_FIRST((head))->field.tqe_prev = \ + &TTS_TAILQ_NEXT((elm), field); \ + else \ + (head)->tqh_last = &TTS_TAILQ_NEXT((elm), field); \ + TTS_TAILQ_FIRST((head)) = (elm); \ + (elm)->field.tqe_prev = &TTS_TAILQ_FIRST((head)); \ +} while (0) + +#define TTS_TAILQ_INSERT_TAIL(head, elm, field) do { \ + TTS_TAILQ_NEXT((elm), field) = NULL; \ + (elm)->field.tqe_prev = (head)->tqh_last; \ + *(head)->tqh_last = (elm); \ + (head)->tqh_last = &TTS_TAILQ_NEXT((elm), field); \ +} while (0) + +#define TTS_TAILQ_LAST(head, headname) \ + (*(((struct headname *)((head)->tqh_last))->tqh_last)) + +#define TTS_TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) + +#define TTS_TAILQ_PREV(elm, headname, field) \ + (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) + +#define TTS_TAILQ_REMOVE(head, elm, field) do { \ + if ((TTS_TAILQ_NEXT((elm), field)) != NULL) \ + TTS_TAILQ_NEXT((elm), field)->field.tqe_prev = \ + (elm)->field.tqe_prev; \ + else { \ + (head)->tqh_last = (elm)->field.tqe_prev; \ + } \ + *(elm)->field.tqe_prev = TTS_TAILQ_NEXT((elm), field); \ +} while (0) + +#define TTS_TAILQ_SWAP(head1, head2, type, field) do { \ + struct type *swap_first = (head1)->tqh_first; \ + struct type **swap_last = (head1)->tqh_last; \ + (head1)->tqh_first = (head2)->tqh_first; \ + (head1)->tqh_last = (head2)->tqh_last; \ + (head2)->tqh_first = swap_first; \ + (head2)->tqh_last = swap_last; \ + if ((swap_first = (head1)->tqh_first) != NULL) \ + swap_first->field.tqe_prev = &(head1)->tqh_first; \ + else \ + (head1)->tqh_last = &(head1)->tqh_first; \ + if ((swap_first = (head2)->tqh_first) != NULL) \ + swap_first->field.tqe_prev = &(head2)->tqh_first; \ + else \ + (head2)->tqh_last = &(head2)->tqh_first; \ +} while (0) + + +#endif /* !TTS_TAILQ_H */ diff --git a/tts.c b/tts.c index 38fe8f9..019f23b 100644 --- a/tts.c +++ b/tts.c @@ -36,6 +36,9 @@ # include # include # include +# include + +# include # include # include @@ -43,7 +46,7 @@ # include #endif -#include "queue.h" +#include "tailq.h" #include "tts.h" #include "entry.h" #include "wide.h" @@ -223,9 +226,12 @@ static void * power_thread_run(arg) void *arg; { +struct kevent ev, rev; +int kq; sigset_t ss; IONotificationPortRef port_ref; io_object_t notifier; +mach_port_t ioport; /* Block SIGUSR1 so it's always delivered to the main thread, not us */ sigemptyset(&ss); @@ -235,10 +241,48 @@ io_object_t notifier; /* Register a handler for sleep and wake events */ root_port = IORegisterForSystemPower(NULL, &port_ref, power_event, ¬ifier); - CFRunLoopAddSource(CFRunLoopGetCurrent(), - IONotificationPortGetRunLoopSource(port_ref), - kCFRunLoopCommonModes); - CFRunLoopRun(); + ioport = IONotificationPortGetMachPort(port_ref); + EV_SET(&ev, ioport, EVFILT_MACHPORT, EV_ADD, 0, 0, 0); + +/* Create our queue */ + if ((kq = kqueue()) == -1) { + perror("kqueue"); + exit(1); + } + + for (;;) { + int nev; + + struct { + mach_msg_header_t hdr; + char data[8192]; + mach_msg_trailer_t trailer; + } msg; + mach_msg_return_t ret; + + /* Wait for an event */ + if ((nev = kevent(kq, &ev, 1, &rev, 1, NULL)) == -1) { + perror("kevent"); + exit(1); + } + + if (nev == 0) + continue; + + /* Receive the message */ + memset(&msg, 0, sizeof(ret)); + ret = mach_msg(&msg.hdr, MACH_RCV_MSG, 0, sizeof(msg), ioport, + MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + + if (ret != MACH_MSG_SUCCESS) { + fprintf(stderr, "mach_msg: %s [%x]\n", + mach_error_string(ret), ret); + exit(1); + } + + /* Give the message to IOKit to handle */ + IODispatchCalloutFromMessage(NULL, &msg.hdr, port_ref); + } /*NOTREACHED*/ return NULL; @@ -400,10 +444,10 @@ char rcfile[PATH_MAX + 1]; drawheader(); drawstatus(WIDE("")); - if (!TAILQ_EMPTY(&entries)) { - curent = TAILQ_FIRST(&entries); + if (!TTS_TAILQ_EMPTY(&entries)) { + curent = TTS_TAILQ_FIRST(&entries); while (!showinv && curent->en_flags.efl_invoiced) - if ((curent = TAILQ_NEXT(curent, en_entries)) == NULL) + if ((curent = TTS_TAILQ_NEXT(curent, en_entries)) == NULL) break; } @@ -444,7 +488,7 @@ char rcfile[PATH_MAX + 1]; drawstatus(WIDE("")); - TAILQ_FOREACH(bi, &bindings, bi_entries) { + TTS_TAILQ_FOREACH(bi, &bindings, bi_entries) { if (bi->bi_code != c) continue; bi->bi_func->fn_hdl(); @@ -471,15 +515,15 @@ chtype oldbg; getmaxyx(listwin, nlines, i); - TAILQ_FOREACH(en, &entries, en_entries) + TTS_TAILQ_FOREACH(en, &entries, en_entries) en->en_flags.efl_visible = 0; - en = TAILQ_FIRST(&entries); + en = TTS_TAILQ_FIRST(&entries); for (i = 0; i < pagestart; i++) - if ((en = TAILQ_NEXT(en, en_entries)) == NULL) + if ((en = TTS_TAILQ_NEXT(en, en_entries)) == NULL) return; - for (; en; en = TAILQ_NEXT(en, en_entries)) { + for (; en; en = TTS_TAILQ_NEXT(en, en_entries)) { time_t n; int h, s, m; WCHAR flags[10], stime[16], *p; @@ -660,7 +704,7 @@ char input[4096]; WCHAR line[4096]; entry_t *en; - TAILQ_FOREACH(en, &entries, en_entries) + TTS_TAILQ_FOREACH(en, &entries, en_entries) entry_free(en); if ((f = fopen(statfile, "r")) == NULL) { @@ -779,7 +823,7 @@ entry_t *en; exit(1); } - TAILQ_FOREACH_REVERSE(en, &entries, entrylist, en_entries) { + TTS_TAILQ_FOREACH_REVERSE(en, &entries, entrylist, en_entries) { char flags[10], *fp = flags, wdesc[4096] = {}; time_t n; @@ -884,7 +928,7 @@ hist_new() history_t *hi; if ((hi = calloc(1, sizeof(*hi))) == NULL) return NULL; - TAILQ_INIT(&hi->hi_ents); + TTS_TAILQ_INIT(&hi->hi_ents); return hi; } @@ -905,10 +949,10 @@ histent_t *hent; return; } - TAILQ_INSERT_TAIL(&hi->hi_ents, hent, he_entries); + TTS_TAILQ_INSERT_TAIL(&hi->hi_ents, hent, he_entries); if (hi->hi_nents == 50) - TAILQ_REMOVE(&hi->hi_ents, TAILQ_FIRST(&hi->hi_ents), he_entries); + TTS_TAILQ_REMOVE(&hi->hi_ents, TTS_TAILQ_FIRST(&hi->hi_ents), he_entries); else ++hi->hi_nents; } @@ -976,7 +1020,7 @@ INT code; } /* Do we already have a binding for this key? */ - TAILQ_FOREACH(binding, &bindings, bi_entries) { + TTS_TAILQ_FOREACH(binding, &bindings, bi_entries) { if (binding->bi_code == code) { binding->bi_func = func; return; @@ -990,7 +1034,7 @@ INT code; binding->bi_key = key; binding->bi_func = func; binding->bi_code = code; - TAILQ_INSERT_TAIL(&bindings, binding, bi_entries); + TTS_TAILQ_INSERT_TAIL(&bindings, binding, bi_entries); } variable_t * diff --git a/tts.h b/tts.h index d9e70e4..b1e779e 100644 --- a/tts.h +++ b/tts.h @@ -14,7 +14,7 @@ #include #include "wide.h" -#include "queue.h" +#include "tailq.h" #include "entry.h" extern char const *tts_version; @@ -50,9 +50,9 @@ int save(void); #define NHIST 50 typedef struct histent { WCHAR *he_text; - TAILQ_ENTRY(histent) he_entries; + TTS_TAILQ_ENTRY(histent) he_entries; } histent_t; -typedef TAILQ_HEAD(hentlist, histent) hentlist_t; +typedef TTS_TAILQ_HEAD(hentlist, histent) hentlist_t; typedef struct history { int hi_nents; diff --git a/ui.c b/ui.c index 325b745..c5aa9fd 100644 --- a/ui.c +++ b/ui.c @@ -27,14 +27,14 @@ cursadvance() entry_t *en; if (!curent) { - curent = TAILQ_FIRST(&entries); + curent = TTS_TAILQ_FIRST(&entries); return; } /* * Try to find the next suitable entry to move the cursor to. */ - for (en = TAILQ_NEXT(curent, en_entries); en; en = TAILQ_NEXT(en, en_entries)) { + for (en = TTS_TAILQ_NEXT(curent, en_entries); en; en = TTS_TAILQ_NEXT(en, en_entries)) { if (!showinv && en->en_flags.efl_invoiced) continue; curent = en; @@ -50,8 +50,8 @@ entry_t *en; if (showinv || !curent->en_flags.efl_invoiced) return; - for (en = TAILQ_PREV(curent, entrylist, en_entries); en; - en = TAILQ_PREV(en, entrylist, en_entries)) { + for (en = TTS_TAILQ_PREV(curent, entrylist, en_entries); en; + en = TTS_TAILQ_PREV(en, entrylist, en_entries)) { if (!showinv && en->en_flags.efl_invoiced) continue; curent = en; @@ -251,16 +251,16 @@ histent_t *histpos = NULL; case KEY_UP: if (histpos == NULL) { - if ((histpos = TAILQ_LAST(&hist->hi_ents, hentlist)) == NULL) { + if ((histpos = TTS_TAILQ_LAST(&hist->hi_ents, hentlist)) == NULL) { beep(); break; } } else { - if (TAILQ_PREV(histpos, hentlist, he_entries) == NULL) { + if (TTS_TAILQ_PREV(histpos, hentlist, he_entries) == NULL) { beep(); break; } else - histpos = TAILQ_PREV(histpos, hentlist, he_entries); + histpos = TTS_TAILQ_PREV(histpos, hentlist, he_entries); } @@ -274,11 +274,11 @@ histent_t *histpos = NULL; break; } - if (TAILQ_NEXT(histpos, he_entries) == NULL) { + if (TTS_TAILQ_NEXT(histpos, he_entries) == NULL) { beep(); break; } else - histpos = TAILQ_NEXT(histpos, he_entries); + histpos = TTS_TAILQ_NEXT(histpos, he_entries); STRNCPY(input, histpos->he_text, WSIZEOF(input) - 1);