summaryrefslogtreecommitdiff
path: root/libdtv/liblx/liblx.h
diff options
context:
space:
mode:
Diffstat (limited to 'libdtv/liblx/liblx.h')
-rw-r--r--libdtv/liblx/liblx.h448
1 files changed, 448 insertions, 0 deletions
diff --git a/libdtv/liblx/liblx.h b/libdtv/liblx/liblx.h
new file mode 100644
index 0000000..f2527e7
--- /dev/null
+++ b/libdtv/liblx/liblx.h
@@ -0,0 +1,448 @@
+//////////////////////////////////////////////////////////////
+/// ///
+/// liblx.h: definitions necessary for the liblx package ///
+/// ///
+//////////////////////////////////////////////////////////////
+
+// $Revision: 1.1 $
+// $Date: 2001/06/26 07:18:42 $
+// $Author: kls $
+//
+// (C) 1992-2001 Rolf Hakenes <hakenes@hippomi.de>, under the GNU GPL.
+//
+// liblx is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// liblx is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You may have received a copy of the GNU General Public License
+// along with liblx; see the file COPYING. If not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+#ifndef LIBLX_H
+#define LIBLX_H
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+
+/*
+ *
+ * list support structures
+ *
+ */
+struct NODE
+{
+ struct NODE *Succ;
+ struct NODE *Pred;
+ char *Name;
+ unsigned short HashKey;
+};
+
+struct LIST
+{
+ struct NODE *Head;
+ struct NODE *Tail;
+ char *Name;
+ unsigned long Size;
+};
+
+
+/*
+ *
+ * memory managment structures
+ *
+ */
+struct MEM_ENTRY
+{
+ struct MEM_ENTRY *Succ;
+ struct MEM_ENTRY *Pred;
+ unsigned long Size;
+};
+
+struct MEM_CHUNK
+{
+ struct MEM_CHUNK *Succ;
+ struct MEM_CHUNK *Pred;
+ unsigned long Size;
+ struct MEM_ENTRY *FirstFreeMemEntry;
+ struct MEM_ENTRY *FirstUsedMemEntry;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *
+ * list functions (package xList)
+ *
+ */
+ unsigned short xHashKey (char *);
+ struct LIST *xNewList (char *);
+ struct NODE *xNewNode (char *, unsigned long);
+ struct NODE *xFindName (struct LIST *, char *);
+/*
+ *
+ * memory management
+ *
+ */
+ void xMemAllo (unsigned long, unsigned char **);
+ void xMemFre (unsigned char *);
+ void xMemFreeAll (struct MEM_CHUNK **);
+ void xMemMerge (struct MEM_CHUNK **);
+ struct MEM_CHUNK **xGetRemember (void);
+ void xSetRemember (struct MEM_CHUNK **);
+ void xPrintMemList (struct MEM_CHUNK **);
+ unsigned long xGetMemSize (struct MEM_CHUNK **);
+extern unsigned long xAllocatedMemory;
+ char *xSetText (char *);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#define MEM_CHUNK_SIZE 65536
+
+#define xMemAlloc(size, ptr) \
+ xMemAllo (((unsigned long)((size))), ((unsigned char **)((ptr))))
+#define xMemFree(ptr) xMemFre (((unsigned char *)((ptr))))
+/*
+ *
+ * list support macros
+ *
+ */
+/*---------------------------------------------------------------------*
+ | |
+ | xCreateNode (NodeStruct,Name) allocates a correctly sized and |
+ | typed node struct. |
+ | |
+ *---------------------------------------------------------------------*/
+#define xCreateNode(NodeStruct,Name) \
+ (NodeStruct) = (void *) xNewNode(Name, sizeof(*(NodeStruct)))
+
+
+/*---------------------------------------------------------------------*
+ | |
+ | xSize (List) scans for the ->Size field of a list struct |
+ | |
+ *---------------------------------------------------------------------*/
+#define xSize(List) ((List) ? ((struct LIST *)(List))->Size : 0)
+
+
+/*---------------------------------------------------------------------*
+ | |
+ | xName (NodeStruct) scans for the ->Node.Name of a node struct |
+ | |
+ *---------------------------------------------------------------------*/
+#define xName(NodeStruct) (((struct NODE *)(NodeStruct))->Name)
+
+
+/*---------------------------------------------------------------------*
+ | |
+ | xSucc (NodeStruct) scans for the ->Node.Succ of a node struct |
+ | |
+ *---------------------------------------------------------------------*/
+#define xSucc(NodeStruct) (((struct NODE *)(NodeStruct))->Succ)
+
+
+/*---------------------------------------------------------------------*
+ | |
+ | xPred (NodeStruct) scans for the ->Node.Pred of a node struct |
+ | |
+ *---------------------------------------------------------------------*/
+#define xPred(NodeStruct) (((struct NODE *)(NodeStruct))->Pred)
+
+
+/*---------------------------------------------------------------------*
+ | |
+ | xForeach(List,NodeStruct) builds a loop to process each list |
+ | element. |
+ | |
+ *---------------------------------------------------------------------*/
+#define xForeach(List,NodeStruct) \
+ if (List) for ((NodeStruct) = (void *) ((struct LIST *)(List))->Head; \
+ (NodeStruct); (NodeStruct) = (void *) xSucc (NodeStruct))
+
+
+/*---------------------------------------------------------------------*
+ | |
+ | xForeachReverse(List,NodeStruct) builds a loop to process each |
+ | element in reverse order. |
+ | |
+ *---------------------------------------------------------------------*/
+#define xForeachReverse(List,NodeStruct) \
+ if (List) for ((NodeStruct) = (void *) ((struct LIST *)(List))->Tail; \
+ NodeStruct; (NodeStruct) = (void *) xPred (NodeStruct))
+
+
+/*---------------------------------------------------------------------*
+ | |
+ | xRemove(List,NodeStruct) unchains a node struct out of a list. |
+ | |
+ *---------------------------------------------------------------------*/
+#define xRemove(List,NodeStruct) \
+ do \
+ { \
+ struct NODE *TmpNode; \
+ struct LIST *TmpList; \
+ \
+ TmpNode = ((struct NODE *)(NodeStruct)); \
+ TmpList = ((struct LIST *)(List)); \
+ \
+ if (TmpNode->Pred) \
+ (TmpNode->Pred)->Succ = TmpNode->Succ; \
+ else TmpList->Head = TmpNode->Succ; \
+ if (TmpNode->Succ) \
+ (TmpNode->Succ)->Pred = TmpNode->Pred; \
+ else TmpList->Tail = TmpNode->Pred; \
+ TmpList->Size --; \
+ } while (0)
+
+
+/*************************************************************************
+ * *
+ * function : xAddHead *
+ * *
+ * arguments : List - pointer to a LIST structure *
+ * *
+ * Node - pointer to a NODE structure *
+ * *
+ *-----------------------------------------------------------------------*
+ * *
+ * xAddHead() inserts 'Node' at the head of 'List'. *
+ * *
+ *************************************************************************/
+#define xAddHead(List, NodeStruct) \
+ do { \
+ struct NODE *TmpNode; \
+ struct LIST *TmpList; \
+ \
+ TmpNode = ((struct NODE *)(NodeStruct)); \
+ TmpList = ((struct LIST *)(List)); \
+ \
+ if (TmpList->Head) { \
+ TmpNode->Pred = NULL; \
+ TmpNode->Succ = TmpList->Head; \
+ (TmpList->Head)->Pred = TmpNode; \
+ TmpList->Head = TmpNode; } \
+ else { \
+ TmpList->Head = TmpNode; \
+ TmpList->Tail = TmpNode; \
+ TmpNode->Pred = NULL; \
+ TmpNode->Succ = NULL; } \
+ TmpList->Size++; \
+ } while (0)
+
+
+/*************************************************************************
+ * *
+ * function : xAddTail *
+ * *
+ * arguments : List - pointer to a LIST structure *
+ * *
+ * Node - pointer to a NODE structure *
+ * *
+ *-----------------------------------------------------------------------*
+ * *
+ * xAddTail() inserts 'Node' at the tail of 'List'. *
+ * *
+ *************************************************************************/
+#define xAddTail(List, NodeStruct) \
+ do { \
+ struct NODE *TmpNode; \
+ struct LIST *TmpList; \
+ \
+ TmpNode = ((struct NODE *)(NodeStruct)); \
+ TmpList = ((struct LIST *)(List)); \
+ \
+ if (TmpList->Head) { \
+ TmpNode->Succ = NULL; \
+ TmpNode->Pred = TmpList->Tail; \
+ (TmpList->Tail)->Succ = TmpNode; \
+ TmpList->Tail = TmpNode; } \
+ else { \
+ TmpList->Head = TmpNode; \
+ TmpList->Tail = TmpNode; \
+ TmpNode->Pred = NULL; \
+ TmpNode->Succ = NULL; } \
+ TmpList->Size++; \
+ } while (0)
+
+
+/*************************************************************************
+ * *
+ * function : xRemHead *
+ * *
+ * arguments : List - pointer to a LIST structure *
+ * *
+ *-----------------------------------------------------------------------*
+ * *
+ * xRemHead() removes a Node from head of 'List'. *
+ * *
+ *************************************************************************/
+#define xRemHead(List) \
+ do { \
+ struct LIST *TmpList; \
+ \
+ TmpList = ((struct LIST *)(List)); \
+ \
+ if (TmpList->Head) \
+ { \
+ TmpList->Head = (TmpList->Head)->Succ; \
+ if (TmpList->Head) (TmpList->Head)->Pred = NULL; \
+ else TmpList->Tail = NULL; \
+ TmpList->Size--; \
+ } \
+ } while (0)
+
+
+/*************************************************************************
+ * *
+ * function : xRemTail *
+ * *
+ * arguments : List - pointer to a LIST structure *
+ * *
+ *-----------------------------------------------------------------------*
+ * *
+ * xRemTail() removes a Node from the tail of 'List'. *
+ * *
+ *************************************************************************/
+#define xRemTail(List) \
+ do { \
+ struct LIST *TmpList; \
+ \
+ TmpList = ((struct LIST *)(List)); \
+ \
+ if (TmpList->Tail) \
+ { \
+ TmpList->Tail = (TmpList->Tail)->Pred; \
+ if (TmpList->Tail) (TmpList->Tail)->Succ = NULL; \
+ else TmpList->Head = NULL; \
+ TmpList->Size--; \
+ } \
+ } while (0)
+
+
+/*************************************************************************
+ * *
+ * function : xConCat *
+ * *
+ * arguments : DestinationList - pointer to the destination *
+ * LIST structure *
+ * *
+ * SourceList - pointer to the source LIST structure *
+ * *
+ *-----------------------------------------------------------------------*
+ * *
+ * xConCat() concats 'SourceList' with 'DestinationList' and clears *
+ * 'SourceList'. *
+ * *
+ *************************************************************************/
+#define xConCat(DestinationList, SourceList) \
+ do { \
+ struct LIST *SrcList; \
+ struct LIST *DstList; \
+ \
+ SrcList = ((struct LIST *)(SourceList)); \
+ DstList = ((struct LIST *)(DestinationList)); \
+ \
+ if (DstList && SrcList) \
+ { \
+ if (DstList->Head) { \
+ if (SrcList->Head) { \
+ (DstList->Tail)->Succ = SrcList->Head; \
+ (SrcList->Head)->Pred = DstList->Tail; \
+ DstList->Tail = SrcList->Tail; \
+ DstList->Size += SrcList->Size; \
+ SrcList->Size = 0; \
+ SrcList->Head = NULL; \
+ SrcList->Tail = NULL; } } \
+ else { \
+ DstList->Head = SrcList->Head; \
+ DstList->Tail = SrcList->Tail; \
+ DstList->Size += SrcList->Size; \
+ SrcList->Size = 0; \
+ SrcList->Head = NULL; \
+ SrcList->Tail = NULL; } \
+ } \
+ else if (SrcList) ((struct LIST *)(DestinationList)) = SrcList; \
+ } while (0)
+
+
+
+#define xJoinList(SourceList, DestinationList, NodeStruct) \
+ do { \
+ struct NODE *KeyNode; \
+ struct NODE *TmpNode; \
+ struct LIST *SrcList; \
+ struct LIST *DstList; \
+ \
+ KeyNode = ((struct NODE *)(NodeStruct)); \
+ SrcList = ((struct LIST *)(SourceList)); \
+ DstList = ((struct LIST *)(DestinationList)); \
+ \
+ if (SrcList->Head) \
+ { \
+ TmpNode = KeyNode->Succ; \
+ KeyNode->Succ = SrcList->Head; \
+ SrcList->Tail->Succ = TmpNode; \
+ SrcList->Head->Pred = KeyNode; \
+ if (!TmpNode) DstList->Tail = SrcList->Tail; \
+ else TmpNode->Pred = SrcList->Tail; \
+ DstList->Size += SrcList->Size; \
+ SrcList->Size = 0; \
+ SrcList->Head = NULL; \
+ SrcList->Tail = NULL; \
+ } \
+ } while (0)
+
+#define xJoin(SourceNode, DestinationList, NodeStruct) \
+ do { \
+ struct NODE *KeyNode; \
+ struct NODE *TmpNode; \
+ struct NODE *SrcNode; \
+ struct LIST *DstList; \
+ \
+ KeyNode = ((struct NODE *)(NodeStruct)); \
+ SrcNode = ((struct NODE *)(SourceNode)); \
+ DstList = ((struct LIST *)(DestinationList)); \
+ \
+ if (SrcNode) \
+ { \
+ TmpNode = KeyNode->Succ; \
+ KeyNode->Succ = SrcNode; \
+ SrcNode->Succ = TmpNode; \
+ SrcNode->Pred = KeyNode; \
+ if (!TmpNode) DstList->Tail = SrcNode; \
+ else TmpNode->Pred = SrcNode; \
+ DstList->Size += 1; \
+ } \
+ } while (0)
+
+#define xClearList(SrcList) \
+ do { \
+ (SrcList)->Size = 0; \
+ (SrcList)->Head = NULL; \
+ (SrcList)->Tail = NULL; \
+ } while (0)
+
+#define xSetName(nodestruct, name) \
+ do { \
+ struct NODE *TmpNode; \
+ \
+ TmpNode = (struct NODE *) (nodestruct); \
+ \
+ TmpNode->Name = xSetText (name); \
+ TmpNode->HashKey = xHashKey (name); \
+ } while (0)
+
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-21 22:45:25 +0000