diff options
Diffstat (limited to 'libdtv/liblx')
| -rw-r--r-- | libdtv/liblx/COPYING | 339 | ||||
| -rw-r--r-- | libdtv/liblx/Makefile | 62 | ||||
| -rw-r--r-- | libdtv/liblx/liblx.h | 449 | ||||
| -rw-r--r-- | libdtv/liblx/xListFuncs.c | 189 | ||||
| -rw-r--r-- | libdtv/liblx/xMemMgt.c | 624 |
5 files changed, 0 insertions, 1663 deletions
diff --git a/libdtv/liblx/COPYING b/libdtv/liblx/COPYING deleted file mode 100644 index a43ea212..00000000 --- a/libdtv/liblx/COPYING +++ /dev/null @@ -1,339 +0,0 @@ - GNU GENERAL PUBLIC LICENSE - Version 2, June 1991 - - Copyright (C) 1989, 1991 Free Software Foundation, Inc. - 675 Mass Ave, Cambridge, MA 02139, USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -License is intended to guarantee your freedom to share and change free -software--to make sure the software is free for all its users. This -General Public License applies to most of the Free Software -Foundation's software and to any other program whose authors commit to -using it. (Some other Free Software Foundation software is covered by -the GNU Library General Public License instead.) You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -this service if you wish), that you receive source code or can get it -if you want it, that you can change the software or use pieces of it -in new free programs; and that you know you can do these things. - - To protect your rights, we need to make restrictions that forbid -anyone to deny you these rights or to ask you to surrender the rights. -These restrictions translate to certain responsibilities for you if you -distribute copies of the software, or if you modify it. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must give the recipients all the rights that -you have. You must make sure that they, too, receive or can get the -source code. And you must show them these terms so they know their -rights. - - We protect your rights with two steps: (1) copyright the software, and -(2) offer you this license which gives you legal permission to copy, -distribute and/or modify the software. - - Also, for each author's protection and ours, we want to make certain -that everyone understands that there is no warranty for this free -software. If the software is modified by someone else and passed on, we -want its recipients to know that what they have is not the original, so -that any problems introduced by others will not reflect on the original -authors' reputations. - - Finally, any free program is threatened constantly by software -patents. We wish to avoid the danger that redistributors of a free -program will individually obtain patent licenses, in effect making the -program proprietary. To prevent this, we have made it clear that any -patent must be licensed for everyone's free use or not licensed at all. - - The precise terms and conditions for copying, distribution and -modification follow. - - GNU GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License applies to any program or other work which contains -a notice placed by the copyright holder saying it may be distributed -under the terms of this General Public License. The "Program", below, -refers to any such program or work, and a "work based on the Program" -means either the Program or any derivative work under copyright law: -that is to say, a work containing the Program or a portion of it, -either verbatim or with modifications and/or translated into another -language. (Hereinafter, translation is included without limitation in -the term "modification".) Each licensee is addressed as "you". - -Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running the Program is not restricted, and the output from the Program -is covered only if its contents constitute a work based on the -Program (independent of having been made by running the Program). -Whether that is true depends on what the Program does. - - 1. You may copy and distribute verbatim copies of the Program's -source code as you receive it, in any medium, provided that you -conspicuously and appropriately publish on each copy an appropriate -copyright notice and disclaimer of warranty; keep intact all the -notices that refer to this License and to the absence of any warranty; -and give any other recipients of the Program a copy of this License -along with the Program. - -You may charge a fee for the physical act of transferring a copy, and -you may at your option offer warranty protection in exchange for a fee. - - 2. You may modify your copy or copies of the Program or any portion -of it, thus forming a work based on the Program, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) You must cause the modified files to carry prominent notices - stating that you changed the files and the date of any change. - - b) You must cause any work that you distribute or publish, that in - whole or in part contains or is derived from the Program or any - part thereof, to be licensed as a whole at no charge to all third - parties under the terms of this License. - - c) If the modified program normally reads commands interactively - when run, you must cause it, when started running for such - interactive use in the most ordinary way, to print or display an - announcement including an appropriate copyright notice and a - notice that there is no warranty (or else, saying that you provide - a warranty) and that users may redistribute the program under - these conditions, and telling the user how to view a copy of this - License. (Exception: if the Program itself is interactive but - does not normally print such an announcement, your work based on - the Program is not required to print an announcement.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Program, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Program, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Program. - -In addition, mere aggregation of another work not based on the Program -with the Program (or with a work based on the Program) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may copy and distribute the Program (or a work based on it, -under Section 2) in object code or executable form under the terms of -Sections 1 and 2 above provided that you also do one of the following: - - a) Accompany it with the complete corresponding machine-readable - source code, which must be distributed under the terms of Sections - 1 and 2 above on a medium customarily used for software interchange; or, - - b) Accompany it with a written offer, valid for at least three - years, to give any third party, for a charge no more than your - cost of physically performing source distribution, a complete - machine-readable copy of the corresponding source code, to be - distributed under the terms of Sections 1 and 2 above on a medium - customarily used for software interchange; or, - - c) Accompany it with the information you received as to the offer - to distribute corresponding source code. (This alternative is - allowed only for noncommercial distribution and only if you - received the program in object code or executable form with such - an offer, in accord with Subsection b above.) - -The source code for a work means the preferred form of the work for -making modifications to it. For an executable work, complete source -code means all the source code for all modules it contains, plus any -associated interface definition files, plus the scripts used to -control compilation and installation of the executable. However, as a -special exception, the source code distributed need not include -anything that is normally distributed (in either source or binary -form) with the major components (compiler, kernel, and so on) of the -operating system on which the executable runs, unless that component -itself accompanies the executable. - -If distribution of executable or object code is made by offering -access to copy from a designated place, then offering equivalent -access to copy the source code from the same place counts as -distribution of the source code, even though third parties are not -compelled to copy the source along with the object code. - - 4. You may not copy, modify, sublicense, or distribute the Program -except as expressly provided under this License. Any attempt -otherwise to copy, modify, sublicense or distribute the Program is -void, and will automatically terminate your rights under this License. -However, parties who have received copies, or rights, from you under -this License will not have their licenses terminated so long as such -parties remain in full compliance. - - 5. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Program or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Program (or any work based on the -Program), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Program or works based on it. - - 6. Each time you redistribute the Program (or any work based on the -Program), the recipient automatically receives a license from the -original licensor to copy, distribute or modify the Program subject to -these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties to -this License. - - 7. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Program at all. For example, if a patent -license would not permit royalty-free redistribution of the Program by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Program. - -If any portion of this section is held invalid or unenforceable under -any particular circumstance, the balance of the section is intended to -apply and the section as a whole is intended to apply in other -circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system, which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 8. If the distribution and/or use of the Program is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Program under this License -may add an explicit geographical distribution limitation excluding -those countries, so that distribution is permitted only in or among -countries not thus excluded. In such case, this License incorporates -the limitation as if written in the body of this License. - - 9. The Free Software Foundation may publish revised and/or new versions -of the General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - -Each version is given a distinguishing version number. If the Program -specifies a version number of this License which applies to it and "any -later version", you have the option of following the terms and conditions -either of that version or of any later version published by the Free -Software Foundation. If the Program does not specify a version number of -this License, you may choose any version ever published by the Free Software -Foundation. - - 10. If you wish to incorporate parts of the Program into other free -programs whose distribution conditions are different, write to the author -to ask for permission. For software which is copyrighted by the Free -Software Foundation, write to the Free Software Foundation; we sometimes -make exceptions for this. Our decision will be guided by the two goals -of preserving the free status of all derivatives of our free software and -of promoting the sharing and reuse of software generally. - - NO WARRANTY - - 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY -FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN -OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES -PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED -OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS -TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE -PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, -REPAIR OR CORRECTION. - - 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR -REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, -INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING -OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED -TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY -YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER -PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE -POSSIBILITY OF SUCH DAMAGES. - - END OF TERMS AND CONDITIONS - - Appendix: How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -convey the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - <one line to give the program's name and a brief idea of what it does.> - Copyright (C) 19yy <name of author> - - This program 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 of the License, or - (at your option) any later version. - - This program 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 should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - -Also add information on how to contact you by electronic and paper mail. - -If the program is interactive, make it output a short notice like this -when it starts in an interactive mode: - - Gnomovision version 69, Copyright (C) 19yy name of author - Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, the commands you use may -be called something other than `show w' and `show c'; they could even be -mouse-clicks or menu items--whatever suits your program. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the program, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the program - `Gnomovision' (which makes passes at compilers) written by James Hacker. - - <signature of Ty Coon>, 1 April 1989 - Ty Coon, President of Vice - -This General Public License does not permit incorporating your program into -proprietary programs. If your program is a subroutine library, you may -consider it more useful to permit linking proprietary applications with the -library. If this is what you want to do, use the GNU Library General -Public License instead of this License. diff --git a/libdtv/liblx/Makefile b/libdtv/liblx/Makefile deleted file mode 100644 index d06ee091..00000000 --- a/libdtv/liblx/Makefile +++ /dev/null @@ -1,62 +0,0 @@ -############################################################## -### ### -### Makefile: local makefile for liblx ### -### ### -############################################################## - -## $Revision: 1.2 $ -## $Date: 2001/06/25 19:39:00 $ -## $Author: hakenes $ -## -## (C) 2001 Rolf Hakenes <hakenes@hippomi.de>, under the GNU GPL. -## -## dtv_scan 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. -## -## dtv_scan 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 dtv_scan; see the file COPYING. If not, write to the -## Free Software Foundation, Inc., 59 Temple Place - Suite 330, -## Boston, MA 02111-1307, USA. -# -# -# -CC ?= gcc -CFLAGS ?= -O2 -g -pedantic -Wmissing-prototypes -Wstrict-prototypes \ - -Wimplicit -D__USE_FIXED_PROTOTYPES__ # -DDEBUG - - -AR = ar -ARFLAGS = r -RANLIB = ranlib -RM = rm -f -CP = cp - -LXINCLUDE = liblx.h -LXLIB = liblx.a -LXOBJS = xMemMgt.o xListFuncs.o - -all : $(LXLIB) - -clean : - @echo "cleaning workspace..." - @$(RM) $(LXOBJS) $(LXLIB) - -new : clean all - -$(LXLIB) : $(LXOBJS) - @echo "updating library..." - @$(AR) $(ARFLAGS) $(LXLIB) $(LXOBJS) - @$(RANLIB) $(LXLIB) - -dist: all - @echo "distributing liblx.a and liblx.h..." - @$(CP) $(LXLIB) ../lib - @$(CP) $(LXINCLUDE) ../include - diff --git a/libdtv/liblx/liblx.h b/libdtv/liblx/liblx.h deleted file mode 100644 index 2e122956..00000000 --- a/libdtv/liblx/liblx.h +++ /dev/null @@ -1,449 +0,0 @@ -/* - * - * liblx.h: definitions necessary for the liblx package - * - * - * $Revision: 1.2 $ - * $Date: 2001/06/25 19:39:00 $ - * $Author: hakenes $ - * - * (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 diff --git a/libdtv/liblx/xListFuncs.c b/libdtv/liblx/xListFuncs.c deleted file mode 100644 index 348c7800..00000000 --- a/libdtv/liblx/xListFuncs.c +++ /dev/null @@ -1,189 +0,0 @@ -/* - * - * xListFuncs.c: list handling functions of liblx - * - * - * $Revision: 1.1 $ - * $Date: 2001/08/15 10:00:00 $ - * $Author: hakenes $ - * - * (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. - * - */ - -#include <string.h> -#include "liblx.h" - - -/************************************************************************* - * * - * function : xHashKey * - * * - * arguments : Name - character pointer * - * * - * return : 16 Bit CRC checksum as hashkey * - * * - *************************************************************************/ -unsigned short xHashKey (Name) - -char *Name; -{ - unsigned short Key = 0; - unsigned long Value; - char *Ptr; - - if (!Name) return (0); - - for (Ptr = Name; *Ptr; Ptr++) { - Value = ((Key >> 8) ^ (*Ptr)) & 0xFF; - Value = Value ^ (Value >> 4); - Key = 0xFFFF & ((Key << 8) ^ Value ^ (Value << 5) ^ (Value << 12)); - } - return (Key); -} - - -/************************************************************************* - * * - * function : xNewNode * - * * - * arguments : Name - character pointer to the node's name * - * * - * Size - size of the surrounding structure in bytes * - * * - * return : pointer to a correct initialized NODE structure * - * * - *-----------------------------------------------------------------------* - * * - * xNewNode() allocates memory for a NODE structure and initializes * - * it properly. If argument Name points to a string, it copies that * - * into a new allocated memory area and assigns Node->Name to it. * - * Because NODE's are often part of bigger structures, the size of * - * the surrounding structure could be specified to allocate it. * - * * - *************************************************************************/ - -struct NODE *xNewNode (Name, Size) - -char *Name; -unsigned long Size; -{ - struct NODE *Node; - - if (Size < sizeof(struct NODE)) Size = sizeof(struct NODE); - - xMemAlloc (Size, &Node); - - Node->Succ = NULL; - Node->Pred = NULL; - - if (Name == NULL) - { - Node->Name = NULL; - Node->HashKey = 0; - } - else - { - xMemAlloc (strlen (Name) + 1, &(Node->Name)); - strcpy (Node->Name, Name); - Node->HashKey = xHashKey (Name); - } - - return (Node); -} - - -/************************************************************************* - * * - * function : xNewList * - * * - * arguments : Name - character pointer to the list's name * - * * - * return : pointer to a correct initialized LIST structure * - * * - *-----------------------------------------------------------------------* - * * - * xNewList() allocates memory for a LIST structure and initializes * - * it properly. If argument Name points to a string, it copies that * - * into a new allocated memory area and assigns List->Name to it. * - * * - *************************************************************************/ - -struct LIST *xNewList (Name) - -char *Name; -{ - struct LIST *List; - - xMemAlloc (sizeof(struct LIST), &List); - - List->Head = NULL; - List->Tail = NULL; - List->Size = 0; - - if (Name == NULL) - { - List->Name = NULL; - } - else - { - xMemAlloc (strlen (Name) + 1, &(List->Name)); - strcpy (List->Name, Name); - } - - return (List); -} - - - -/************************************************************************* - * * - * function : xFindName * - * * - * arguments : List - pointer to a LIST structure * - * * - * Name - pointer to a name string * - * * - * return : pointer to a NODE structure * - * * - *-----------------------------------------------------------------------* - * * - * xFindName() looks for element with name 'Name' in list 'List' and * - * returns its NODE structure. * - * * - *************************************************************************/ - -struct NODE *xFindName (List, Name) - -struct LIST *List; -char *Name; -{ - struct NODE *Node; - unsigned short HashKey; - - if (!Name || !List) return (NULL); - - HashKey = xHashKey (Name); - - for (Node = List->Head; Node; Node = Node->Succ) - if (HashKey == Node->HashKey) - if (Node->Name) - if (strcmp (Node->Name, Name) == 0) return (Node); - - return (NULL); -} diff --git a/libdtv/liblx/xMemMgt.c b/libdtv/liblx/xMemMgt.c deleted file mode 100644 index 5f32ce2c..00000000 --- a/libdtv/liblx/xMemMgt.c +++ /dev/null @@ -1,624 +0,0 @@ -/* - * - * xMemMgt.c: memory management functions of liblx - * - * - * $Revision: 1.1 $ - * $Date: 2001/08/15 10:00:00 $ - * $Author: hakenes $ - * - * (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. - * - */ - -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <malloc.h> - -#include "liblx.h" - -#ifdef DEBUG -void logPrintf(int, char *, ...); -#endif - -static struct MEM_CHUNK *xRememberKey = NULL; - -static struct MEM_CHUNK **xRememberPtr = &xRememberKey; - -unsigned long xAllocatedMemory = 0; - -/************************************************************************* - * * - * function : xMemAlloc * - * * - * parameter : Size - size of the requested memory area * - * * - * DataPointer - pointer to data pointer * - * * - * return : none * - * * - *-----------------------------------------------------------------------* - * * - * xMemAlloc() is a clustered, remembering memory management routine. * - * It uses its own tables for free and used memory blocks on private * - * memory area. With xMemFree(), you can free this memory likewise * - * the C free() routine, with xMemFreeAll() all memory at once. * - * By changing the current remember key with xSetRemember() you can * - * define a local memory area, which can be freed by only one call of * - * xMemFreeAll() (see xSetRemember() / xGetRemember()). * - * * - *************************************************************************/ - -void xMemAllo (Size, DataPointer) - -unsigned long Size; -unsigned char **DataPointer; -{ - struct MEM_CHUNK *MemChunk, *MemChunkPred; - struct MEM_ENTRY *MemEntry, *MemEntryPred; - long int NewSize; - unsigned short FoundFlag; -#ifdef DEBUG - unsigned char *ptr; -#endif - - while (Size % 4) Size++; - - if (Size > (MEM_CHUNK_SIZE - sizeof(struct MEM_CHUNK) - - sizeof(struct MEM_ENTRY))) - { - NewSize = Size + sizeof(struct MEM_CHUNK) + sizeof(struct MEM_ENTRY); - - if (MemChunk = (*xRememberPtr)) - { - do - { - MemChunkPred = MemChunk; - } while (MemChunk = MemChunk->Succ); - } - else MemChunkPred = (struct MEM_CHUNK *) &(*xRememberPtr); - - MemChunk = MemChunkPred->Succ = (struct MEM_CHUNK *) malloc (NewSize); - xAllocatedMemory += NewSize; - -#ifdef DEBUG - for (ptr = (unsigned char *) MemChunk; ptr < (unsigned char *) - (MemChunk) + NewSize; ptr++) - *ptr = (((unsigned long)ptr)&1) ? 0x55 : 0xAA; -#endif - - if (!MemChunk) - { -#ifdef DEBUG - logPrintf (0, "Not enough memory...\r\n"); -#endif - exit (1); - } - - MemChunk->Size = NewSize; - MemChunk->Pred = MemChunkPred; - MemChunk->Succ = NULL; - MemChunk->FirstFreeMemEntry = NULL; - MemChunk->FirstUsedMemEntry = - MemEntry = (struct MEM_ENTRY *) ((unsigned char *)MemChunk + - sizeof(struct MEM_CHUNK)); - - MemEntry->Size = Size; - MemEntry->Pred = (struct MEM_ENTRY *) &MemChunk->FirstUsedMemEntry; - MemEntry->Succ = NULL; - - *DataPointer = (unsigned char *) ((unsigned char *)MemEntry + - sizeof(struct MEM_ENTRY)); -#ifdef DEBUG_CALLS - logPrintf (0, "xMemAlloc: %x, %d bytes\r\n", *DataPointer, Size); -#endif - return; - } - - MemEntry = NULL; - FoundFlag = 0; - - if (MemChunk = (*xRememberPtr)) - { - do - { - if (MemEntry = MemChunk->FirstFreeMemEntry) - do - { - if (Size <= MemEntry->Size) FoundFlag = 1; - } while ((FoundFlag == 0) && (MemEntry = MemEntry->Succ)); - MemChunkPred = MemChunk; - } while ((FoundFlag == 0) && (MemChunk = MemChunk->Succ)); - } - else MemChunkPred = (struct MEM_CHUNK *) &(*xRememberPtr); - - if (!MemEntry) - { - MemChunk = MemChunkPred->Succ = - (struct MEM_CHUNK *) malloc (MEM_CHUNK_SIZE); - xAllocatedMemory += MEM_CHUNK_SIZE; - -#ifdef DEBUG - for (ptr = (unsigned char *) MemChunk; ptr < (unsigned char *) - (MemChunk) + MEM_CHUNK_SIZE; ptr++) - *ptr = (((unsigned long)ptr)&1) ? 0x55 : 0xAA; -#endif - - if (!MemChunk) - { -#ifdef DEBUG - logPrintf (0, "Not enough memory...\r\n"); -#endif - exit (1); - } - - MemChunk->Size = MEM_CHUNK_SIZE; - MemChunk->Pred = MemChunkPred; - MemChunk->Succ = NULL; - MemChunk->FirstUsedMemEntry = NULL; - MemChunk->FirstFreeMemEntry = - MemEntry = (struct MEM_ENTRY *) - ((unsigned char *)MemChunk + sizeof(struct MEM_CHUNK)); - - MemEntry->Size = MEM_CHUNK_SIZE - sizeof(struct MEM_CHUNK) - - sizeof(struct MEM_ENTRY); - MemEntry->Pred = (struct MEM_ENTRY *) &MemChunk->FirstFreeMemEntry; - MemEntry->Succ = NULL; - } - - NewSize = MemEntry->Size - sizeof(struct MEM_ENTRY) - Size; - - MemEntry->Size = Size; - *DataPointer = (unsigned char *) - ((unsigned char *)MemEntry + sizeof(struct MEM_ENTRY)); - -#ifdef DEBUG - for (ptr = *DataPointer; ptr < (unsigned char *) - (*DataPointer) + Size; ptr++) - { - if (((unsigned long )ptr)&1) - { if (*ptr != 0x55) - logPrintf (0, "freed memory was used\r\n"); } - else { if (*ptr != 0xAA) - logPrintf (0, "freed memory was used\r\n"); } - } -#endif - - if (MemEntry->Succ) - ((struct MEM_ENTRY *)MemEntry->Succ)->Pred = MemEntry->Pred; - ((struct MEM_ENTRY *)MemEntry->Pred)->Succ = MemEntry->Succ; - - if (MemChunk->FirstUsedMemEntry) - MemChunk->FirstUsedMemEntry->Pred = MemEntry; - MemEntry->Succ = MemChunk->FirstUsedMemEntry; - MemChunk->FirstUsedMemEntry = MemEntry; - MemEntry->Pred = (struct MEM_ENTRY *) &MemChunk->FirstUsedMemEntry; - - if (NewSize > 0) - { - MemEntry = (struct MEM_ENTRY *) - ((unsigned char *)MemEntry + sizeof(struct MEM_ENTRY) + Size); - MemEntry->Size = NewSize; - - if (MemChunk->FirstFreeMemEntry) - MemChunk->FirstFreeMemEntry->Pred = MemEntry; - MemEntry->Succ = MemChunk->FirstFreeMemEntry; - MemChunk->FirstFreeMemEntry = MemEntry; - MemEntry->Pred = (struct MEM_ENTRY *) &MemChunk->FirstFreeMemEntry; - } -#ifdef DEBUG_CALLS - logPrintf (0, "xMemAlloc: %x, %d bytes\r\n", *DataPointer, Size); -#endif - return; -} - - - -/************************************************************************* - * * - * function : xMemFree * - * * - * parameter : DataPointer - data pointer * - * * - * return : none * - * * - *-----------------------------------------------------------------------* - * * - * xMemFree() frees with xMemAlloc() allocated memory. * - * * - *************************************************************************/ - -void xMemFre (DataPointer) - -unsigned char *DataPointer; -{ - struct MEM_CHUNK *MemChunk, *MemChunkPred; - struct MEM_ENTRY *MemEntry, *TempEntry, *PredEntry, *SuccEntry; - unsigned short FoundFlag; -#ifdef DEBUG - unsigned char *ptr; -#endif - - if (!DataPointer) - { - return; - } - else - { - MemEntry = NULL; - FoundFlag = 0; - - if (MemChunk = (*xRememberPtr)) - do - { - if (MemEntry = MemChunk->FirstUsedMemEntry) - do - { - if (DataPointer == (unsigned char *) ((unsigned char *) MemEntry + - sizeof(struct MEM_ENTRY))) FoundFlag = 1; - } while ((FoundFlag == 0) && (MemEntry = MemEntry->Succ)); - } while ((FoundFlag == 0) && (MemChunk = MemChunk->Succ)); - - if (FoundFlag == 1) - { -#ifdef DEBUG_CALLS - logPrintf (0, "xMemFree: %x, %d bytes\r\n", DataPointer, MemEntry->Size); -#endif - if (MemEntry->Succ) - ((struct MEM_ENTRY *)MemEntry->Succ)->Pred = MemEntry->Pred; - ((struct MEM_ENTRY *)MemEntry->Pred)->Succ = MemEntry->Succ; - - if (!MemChunk->FirstUsedMemEntry) - { - if (MemChunk->Succ) - ((struct MEM_CHUNK *)MemChunk->Succ)->Pred = MemChunk->Pred; - ((struct MEM_CHUNK *)MemChunk->Pred)->Succ = MemChunk->Succ; - if (xAllocatedMemory > 0) xAllocatedMemory -= MemChunk->Size; - free (MemChunk); - return; - } - - FoundFlag = 0; - PredEntry = NULL; - SuccEntry = NULL; - if (TempEntry = MemChunk->FirstFreeMemEntry) - do - { - if ((struct MEM_ENTRY *)((unsigned char *)TempEntry + - TempEntry->Size + sizeof(struct MEM_ENTRY)) == MemEntry) - { - FoundFlag ++; - PredEntry = TempEntry; - } - if ((struct MEM_ENTRY *)((unsigned char *)MemEntry + - MemEntry->Size + sizeof(struct MEM_ENTRY)) == TempEntry) - { - FoundFlag ++; - SuccEntry = TempEntry; - } - } while ((FoundFlag != 2) && (TempEntry = TempEntry->Succ)); - - if (PredEntry) - { - if (SuccEntry) - { - /* Vorgdnger + Nachfolger */ - - if (SuccEntry->Succ) - ((struct MEM_ENTRY *)SuccEntry->Succ)->Pred = SuccEntry->Pred; - ((struct MEM_ENTRY *)SuccEntry->Pred)->Succ = SuccEntry->Succ; - - PredEntry->Size += MemEntry->Size + sizeof(struct MEM_ENTRY) + - SuccEntry->Size + sizeof(struct MEM_ENTRY); - } - else - { - /* nur Vorgaenger */ - - PredEntry->Size += MemEntry->Size + sizeof(struct MEM_ENTRY); - } -#ifdef DEBUG - for (ptr = (unsigned char *) (PredEntry) + sizeof(struct MEM_ENTRY); - ptr < (unsigned char *) (PredEntry) + sizeof(struct MEM_ENTRY) + - PredEntry->Size; ptr++) - *ptr = (((unsigned long)ptr)&1) ? 0x55 : 0xAA; -#endif - } - else - { - if (SuccEntry) - { - /* nur Nachfolger */ - - if (SuccEntry->Succ) - ((struct MEM_ENTRY *)SuccEntry->Succ)->Pred = SuccEntry->Pred; - ((struct MEM_ENTRY *)SuccEntry->Pred)->Succ = SuccEntry->Succ; - - MemEntry->Size += SuccEntry->Size + sizeof(struct MEM_ENTRY); - } - - if (MemChunk->FirstFreeMemEntry) - MemChunk->FirstFreeMemEntry->Pred = MemEntry; - MemEntry->Succ = MemChunk->FirstFreeMemEntry; - MemChunk->FirstFreeMemEntry = MemEntry; - MemEntry->Pred = (struct MEM_ENTRY *) &MemChunk->FirstFreeMemEntry; -#ifdef DEBUG - for (ptr = (unsigned char *) (MemEntry) + sizeof(struct MEM_ENTRY); - ptr < (unsigned char *) (MemEntry) + sizeof(struct MEM_ENTRY) + - MemEntry->Size; ptr++) - *ptr = (((unsigned long)ptr)&1) ? 0x55 : 0xAA; -#endif - } - } -#ifdef DEBUG_CALLS - else - logPrintf (0, "xMemFree: tried to free unallocated data %x\r\n", DataPointer); -#endif - } - return; -} - - - -/************************************************************************* - * * - * function : xMemFreeAll * - * * - * parameter : RememberPtr * - * * - * return : none * - * * - *-----------------------------------------------------------------------* - * * - * xMemFreeAll() frees all with xMemAlloc() allocated memory. If Re- * - * memberPtr is not NULL, the MEM_CHUNK structure from the specified * - * Address is freed, otherwise the natural MEM_CHUNK will be done. * - * * - *************************************************************************/ - - -void xMemFreeAll (RememberPtr) - -struct MEM_CHUNK **RememberPtr; -{ - struct MEM_CHUNK *MemChunk, *MemChunkPred; - - if (RememberPtr) - { - if (MemChunkPred = (*RememberPtr)) - do - { - MemChunk = MemChunkPred->Succ; - if (xAllocatedMemory > 0) xAllocatedMemory -= MemChunkPred->Size; - free (MemChunkPred); - } while (MemChunkPred = MemChunk); - *RememberPtr = NULL; - } - else - { - if (MemChunkPred = (*xRememberPtr)) - do - { - MemChunk = MemChunkPred->Succ; - if (xAllocatedMemory > 0) xAllocatedMemory -= MemChunkPred->Size; - free (MemChunkPred); - } while (MemChunkPred = MemChunk); - *xRememberPtr = NULL; - } -} - - -/************************************************************************* - * * - * function : xMemMerge * - * * - * parameter : RememberPtr * - * * - * return : none * - * * - *-----------------------------------------------------------------------* - * * - * xMemMerge() merges the memory area pointed to by RememberKey with * - * the currently used in xRememberPtr. * - * * - *************************************************************************/ - -void xMemMerge (RememberPtr) - -struct MEM_CHUNK **RememberPtr; -{ - struct MEM_CHUNK *MemChunk, *MemChunkPred; - - if (RememberPtr) - { - if (MemChunk = (*xRememberPtr)) - { - while (MemChunk->Succ) MemChunk = MemChunk->Succ; - MemChunk->Succ = (*RememberPtr); - *RememberPtr = NULL; - } - else (*xRememberPtr = *RememberPtr); - } - return; -} - -/************************************************************************* - * * - * function : xGetRemember * - * * - * parameter : none * - * * - * return : pointer to a MEM_CHUNK tree * - * * - *-----------------------------------------------------------------------* - * * - * xGetRemember() returns the currently used MEM_CHUNK tree. * - * * - *************************************************************************/ - - -struct MEM_CHUNK **xGetRemember () -{ - return (xRememberPtr); -} - - -/************************************************************************* - * * - * function : xSetRemember * - * * - * parameter : pointer to a MEM_CHUNK tree * - * * - * return : none * - * * - *-----------------------------------------------------------------------* - * * - * xSetRemember() redefines the currently used MEM_CHUNK pointer. If * - * RememberPtr is NULL, the natural MEM_CHUNK is reloaded. * - * * - *************************************************************************/ - - -void xSetRemember (RememberPtr) - -struct MEM_CHUNK **RememberPtr; -{ - if (RememberPtr) - xRememberPtr = RememberPtr; - else - xRememberPtr = &xRememberKey; -} - -/************************************************************************* - * * - * function : xPrintMemList * - * * - * parameter : pointer to a MEM_CHUNK tree * - * * - * return : none * - * * - *-----------------------------------------------------------------------* - * * - * xPrintMemList() prints the currently allocated memory blocks of * - * the specified RememberPtr. * - * * - *************************************************************************/ - - -void xPrintMemList (Remember) - -struct MEM_CHUNK **Remember; -{ - struct MEM_CHUNK *MemChunk; - struct MEM_ENTRY *MemEntry; - - fprintf (stderr, "MemChunkPtr = %x\n", (int) Remember); - - if (MemChunk = *Remember) - do - { - fprintf (stderr, "\tMemChunk at %x with Size %d\n", (int) MemChunk, - (int) MemChunk->Size); - - if (MemEntry = MemChunk->FirstFreeMemEntry) - do - { - fprintf (stderr, "\t\tFree MemEntry at %x (%x) with Size %d\n", - (int) MemEntry, (int)((unsigned char *)MemEntry + - sizeof(struct MEM_ENTRY)), (int) MemEntry->Size); - - } while (MemEntry = MemEntry->Succ); - - if (MemEntry = MemChunk->FirstUsedMemEntry) - do - { - fprintf (stderr, "\t\tUsed MemEntry at %x (%x) with Size %d\n", - (int) MemEntry, (int)((unsigned char *)MemEntry + - sizeof(struct MEM_ENTRY)), (int) MemEntry->Size); - - } while (MemEntry = MemEntry->Succ); - - } while (MemChunk = MemChunk->Succ); - else fprintf (stderr, "\tNo current MemChunk\n"); -} - - -/************************************************************************* - * * - * function : xGetMemSize * - * * - * parameter : pointer to a MEM_CHUNK tree * - * * - * return : none * - * * - *-----------------------------------------------------------------------* - * * - * xGetMemSize() gets the size of the currently allocated memory * - * blocks of the specified (or natural if NULL) RememberPtr * - * * - *************************************************************************/ - - -unsigned long xGetMemSize (RememberPtr) - -struct MEM_CHUNK **RememberPtr; -{ - struct MEM_CHUNK *MemChunk; - struct MEM_ENTRY *MemEntry; - unsigned long Result = 0; - - if (RememberPtr) MemChunk = *RememberPtr; - else MemChunk = xRememberKey; - - if (MemChunk) - do { Result += (unsigned long) MemChunk->Size; } - while (MemChunk = MemChunk->Succ); - - return (Result); -} - - -/************************************************************************* - * * - * function : xSetText * - * * - * arguments : xText - pointer to a string * - * * - * return : pointer to an new allocated string * - * * - *-----------------------------------------------------------------------* - * * - * xSetText() allocates memory for the string pointed to by 'xText' * - * and duplicates it. * - * * - *************************************************************************/ - -char *xSetText (xText) - -char *xText; -{ - char *NewText; - - if (!xText) return (NULL); - - xMemAlloc (strlen(xText) + 1, &NewText); - strcpy (NewText, xText); - - return (NewText); -} |