/usr/include/planarity/listcoll.h is in libplanarity-dev 3.0.0.5-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 | /*
Copyright (c) 1997-2015, John M. Boyer
All rights reserved.
See the LICENSE.TXT file for licensing information.
*/
#ifndef _LISTCOLL_H
#define _LISTCOLL_H
#ifdef __cplusplus
extern "C" {
#endif
/* This include is needed for memset and memcpy */
#include <string.h>
typedef struct
{
int prev, next;
} lcnode;
typedef struct
{
int N;
lcnode *List;
} listCollectionRec;
typedef listCollectionRec * listCollectionP;
listCollectionP LCNew(int N);
void LCFree(listCollectionP *pListColl);
void LCInsertAfter(listCollectionP listColl, int theAnchor, int theNewNode);
void LCInsertBefore(listCollectionP listColl, int theAnchor, int theNewNode);
#ifndef SPEED_MACROS
void LCReset(listCollectionP listColl);
void LCCopy(listCollectionP dst, listCollectionP src);
int LCGetNext(listCollectionP listColl, int theList, int theNode);
int LCGetPrev(listCollectionP listColl, int theList, int theNode);
int LCPrepend(listCollectionP listColl, int theList, int theNode);
int LCAppend(listCollectionP listColl, int theList, int theNode);
int LCDelete(listCollectionP listColl, int theList, int theNode);
#else
/* void LCReset(listCollectionP listColl); */
#define LCReset(listColl) memset(listColl->List, NIL_CHAR, listColl->N*sizeof(lcnode))
/* void LCCopy(listCollectionP dst, listCollectionP src) */
#define LCCopy(dst, src) memcpy(dst->List, src->List, src->N*sizeof(lcnode))
/* int LCGetNext(listCollectionP listColl, int theList, int theNode);
Return theNode's successor, unless it is theList head pointer */
#define LCGetNext(listColl, theList, theNode) listColl->List[theNode].next==theList ? NIL : listColl->List[theNode].next
/* int LCGetPrev(listCollectionP listColl, int theList, int theNode);
Return theNode's predecessor unless theNode is theList head.
To start going backwards, use NIL for theNode, which returns theList head's predecessor
Usage: Obtain last node, loop while NIL not returned, process node then get predecessor.
After theList head processed, get predecessor returns NIL because we started with
theList head's predecessor. */
#define LCGetPrev(listColl, theList, theNode) \
(theNode==NIL \
? listColl->List[theList].prev \
: theNode==theList ? NIL : listColl->List[theNode].prev)
/* int LCPrepend(listCollectionP listColl, int theList, int theNode);
After an append, theNode is last, which in a circular list is the direct predecessor
of the list head node, so we just back up one. For singletons, this has no effect.*/
#define LCPrepend(listColl, theList, theNode) listColl->List[LCAppend(listColl, theList, theNode)].prev
/* int LCAppend(listCollectionP listColl, int theList, int theNode);
If theList is empty, then theNode becomes its only member and is returned.
Otherwise, theNode is placed before theList head, which is returned. */
#define LCAppend(listColl, theList, theNode) \
(theList==NIL \
? (listColl->List[theNode].prev = listColl->List[theNode].next = theNode) \
: (listColl->List[theNode].next = theList, \
listColl->List[theNode].prev = listColl->List[theList].prev, \
listColl->List[listColl->List[theNode].prev].next = theNode, \
listColl->List[theList].prev = theNode, \
theList))
/* int LCDelete(listCollectionP listColl, int theList, int theNode);
If theList contains only one node, then NIL it out and return NIL meaning empty list
Otherwise, join the predecessor and successor, then
return either the list head or its successor if the deleted node is the list head
(in that case, the caller makes the successor become the new list head).*/
#define LCDelete(listColl, theList, theNode) \
listColl->List[theList].next == theList \
? (listColl->List[theList].prev = listColl->List[theList].next = NIL) \
: (listColl->List[listColl->List[theNode].prev].next = listColl->List[theNode].next, \
listColl->List[listColl->List[theNode].next].prev = listColl->List[theNode].prev, \
(theList==theNode ? listColl->List[theNode].next : theList))
#endif
#ifdef __cplusplus
}
#endif
#endif
|