Main Page | Modules | Data Structures | Directories | File List | Data Fields | Globals

misc.h

Go to the documentation of this file.
00001 /***************************************************************************
00002  $RCSfile: misc.h,v $
00003  -------------------
00004  cvs         : $Id: misc.h,v 1.17 2004/08/18 11:04:50 cstim Exp $
00005  begin       : Sat Jun 28 2003
00006  copyright   : (C) 2003 by Martin Preuss
00007  email       : martin@libchipcard.de
00008 
00009  ***************************************************************************
00010  *                                                                         *
00011  *   This library is free software; you can redistribute it and/or         *
00012  *   modify it under the terms of the GNU Lesser General Public            *
00013  *   License as published by the Free Software Foundation; either          *
00014  *   version 2.1 of the License, or (at your option) any later version.    *
00015  *                                                                         *
00016  *   This library is distributed in the hope that it will be useful,       *
00017  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00018  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00019  *   Lesser General Public License for more details.                       *
00020  *                                                                         *
00021  *   You should have received a copy of the GNU Lesser General Public      *
00022  *   License along with this library; if not, write to the Free Software   *
00023  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00024  *   MA  02111-1307  USA                                                   *
00025  *                                                                         *
00026  ***************************************************************************/
00027 
00070 #ifndef GWENHYWFAR_MISC_H
00071 #define GWENHYWFAR_MISC_H
00072 
00073 #include <gwenhywfar/gwenhywfarapi.h>
00074 #include <gwenhywfar/types.h>
00075 #include <stdio.h>
00076 #include <stdlib.h>
00077 #include <string.h>
00078 #include <assert.h>
00079 
00080 #ifndef GWEN_DUMMY_EMPTY_ARG
00081 
00083 # define GWEN_DUMMY_EMPTY_ARG
00084 #endif
00085 
00086 #ifdef __cplusplus
00087 extern "C" {
00088 #endif
00089 
00187 #define GWEN_LIST_ADD(typ, sr, head) {\
00188   typ *curr;                \
00189                             \
00190   assert(sr);               \
00191   assert(head);             \
00192                             \
00193   curr=*head;               \
00194   if (!curr) {              \
00195     *head=sr;               \
00196   }                         \
00197   else {                    \
00198     while(curr->next) {     \
00199       curr=curr->next;      \
00200     }                       \
00201     curr->next=sr;          \
00202   }\
00203   }
00204 
00205 
00206 #define GWEN_LIST_INSERT(typ, sr, head) {\
00207   typ *curr;                \
00208                             \
00209   assert(sr);               \
00210   assert(head);             \
00211                             \
00212   curr=*head;               \
00213   if (!curr) {              \
00214     *head=sr;               \
00215   }                         \
00216   else {                    \
00217     sr->next=curr;\
00218     *head=sr;\
00219   }\
00220   }
00221 
00222 
00223 #define GWEN_LIST_DEL(typ, sr, head) {\
00224   typ *curr;                   \
00225                                \
00226   assert(sr);                  \
00227   assert(head);                \
00228   curr=*head;                  \
00229   if (curr) {                  \
00230     if (curr==sr) {            \
00231       *head=curr->next;        \
00232     }                          \
00233     else {                     \
00234       while(curr->next!=sr) {  \
00235         curr=curr->next;       \
00236       }                        \
00237       if (curr)                \
00238         curr->next=sr->next;   \
00239     }                          \
00240   }                            \
00241   sr->next=0;\
00242   }
00243 
00244 
00249 #define GWEN_LIST_ELEMENT(t) \
00250   t *next; \
00251   t##_LIST *listPtr;
00252 
00295 #define GWEN_LIST_FUNCTION_LIB_DEFS(t, pr, decl) \
00296   typedef struct t##_LIST_ELEMENT {\
00297   GWEN_TYPE_UINT32 id;\
00298   t *nextObject;\
00299   } t##_LIST__ELEMENT;\
00300   \
00301   typedef struct t##_LIST {\
00302   t *first;\
00303   GWEN_TYPE_UINT32 count;\
00304   GWEN_TYPE_UINT32 id;\
00305   } t##_LIST; \
00306   \
00307   decl void pr##_List_AddList(t##_LIST *dst, t##_LIST *l); \
00308   decl void pr##_List_Add(t *element, t##_LIST *list); \
00309   decl void pr##_List_Insert(t *element, t##_LIST *list); \
00310   decl void pr##_List_Del(t *element); \
00311   decl t* pr##_List_First(const t##_LIST *l); \
00312   decl t* pr##_List_Last(const t##_LIST *l); \
00313   decl void pr##_List_Clear(t##_LIST *l); \
00314   decl t##_LIST* pr##_List_new(); \
00315   decl void pr##_List_free(t##_LIST *l); \
00316   decl t* pr##_List_Next(const t *element); \
00317   decl t* pr##_List_Previous(const t *element); \
00318   decl GWEN_TYPE_UINT32 pr##_List_GetCount(const t##_LIST *l);
00319 
00362 #define GWEN_LIST_FUNCTION_DEFS(t, pr) \
00363   GWEN_LIST_FUNCTION_LIB_DEFS(t, pr, GWEN_DUMMY_EMPTY_ARG)
00364 
00370 #define GWEN_LIST_FUNCTIONS(t, pr) \
00371   static GWEN_TYPE_UINT32 pr##_List_NextId=0;\
00372   \
00373   void pr##_List_Add(t *element, t##_LIST *l) { \
00374     assert(l); \
00375     assert(element->listPtr==0); /* element MUST NOT be in any list */ \
00376     GWEN_LIST_ADD(t, element, &(l->first)) \
00377     element->listPtr=l;\
00378     l->count++;\
00379   } \
00380   \
00381   void pr##_List_AddList(t##_LIST *dst, t##_LIST *l) { \
00382     t *n; \
00383     \
00384     assert(dst);\
00385     assert(l); \
00386     if (l->first) {\
00387       n=l->first; \
00388       while(n) {\
00389         n->listPtr=dst; \
00390         dst->count++;\
00391         n=n->next; \
00392       } \
00393       GWEN_LIST_ADD(t, l->first, &(dst->first)) \
00394       l->count=0;\
00395       l->first=0;\
00396     } \
00397   } \
00398   \
00399   void pr##_List_Insert(t *element, t##_LIST *l) { \
00400     assert(l); \
00401     assert(element->listPtr==0); /* element MUST NOT be in any list */ \
00402     GWEN_LIST_INSERT(t, element, &(l->first)) \
00403     element->listPtr=l;\
00404     l->count++;\
00405   } \
00406   \
00407   void pr##_List_Del(t *element){ \
00408     assert(element->listPtr);\
00409     assert(element->listPtr->first); \
00410     assert(element->listPtr->count);\
00411     GWEN_LIST_DEL(t, element, &(element->listPtr->first)) \
00412     element->listPtr->count--;\
00413     element->listPtr=0;\
00414   }\
00415   \
00416   t* pr##_List_First(const t##_LIST *l) { \
00417     if (l) return l->first;\
00418     else return 0; \
00419   } \
00420   \
00421   t* pr##_List_Last(const t##_LIST *l) { \
00422     t* el; \
00423     \
00424     assert(l); \
00425     el=l->first; \
00426     if (!el) \
00427       return 0; \
00428     while(el->next)\
00429       el=el->next; \
00430     return el; \
00431   } \
00432   \
00433   void pr##_List_Clear(t##_LIST *l) { \
00434     t* el; \
00435     while(l->first) {\
00436       el=l->first;\
00437       pr##_List_Del(el);\
00438       pr##_free(el);\
00439     } /* while */ \
00440   } \
00441   \
00442   t##_LIST* pr##_List_new(){\
00443     t##_LIST *l; \
00444     GWEN_NEW_OBJECT(t##_LIST, l);\
00445     l->id=++pr##_List_NextId;\
00446     return l;\
00447   }\
00448   \
00449   void pr##_List_free(t##_LIST *l) {\
00450     if (l) pr##_List_Clear(l);\
00451     free(l);\
00452   } \
00453   \
00454   t* pr##_List_Next(const t *element) { \
00455     assert(element);\
00456     return element->next;\
00457   } \
00458   \
00459   t* pr##_List_Previous(const t *element) { \
00460     t *tmpel; \
00461     \
00462     assert(element);\
00463     assert(element->listPtr);\
00464     assert(element->listPtr->first); \
00465     tmpel=element->listPtr->first; \
00466     while(tmpel->next && tmpel->next!=element) \
00467       tmpel=tmpel->next; \
00468     if (tmpel->next!=element) \
00469       return 0; \
00470     return tmpel; \
00471   } \
00472   \
00473   GWEN_TYPE_UINT32 pr##_List_GetCount(const t##_LIST *l){\
00474     assert(l);\
00475     return l->count;\
00476   }
00477 
00478 
00479 
00485 #define GWEN_LIST_INIT(t, element) element->listPtr=0;
00486 
00487 
00493 #define GWEN_LIST_FINI(t, element) \
00494   if (element) { \
00495   if (element->listPtr) {\
00496   GWEN_LIST_DEL(t, element, &(element->listPtr->first)) \
00497   element->listPtr->count--;\
00498   element->listPtr=0;\
00499   }\
00500   }
00501  /* defgroup */
00502 
00503 #ifdef __cplusplus
00504 }
00505 #endif
00506 
00507 
00508 #include <gwenhywfar/memory.h>
00509 
00510 
00511 
00512 
00513 #endif
00514 
00515 
00516 

Generated on Thu Oct 13 04:23:10 2005 for gwenhywfar by  doxygen 1.4.1