home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 35 Internet / 35-Internet.zip / quot210s.zip / xtype / src / xtype.h < prev   
C/C++ Source or Header  |  1998-12-13  |  5KB  |  156 lines
  1. /*
  2.  * xtype.h
  3.  *
  4.  * Header file for xtype library of sophisticated data types.
  5.  *
  6.  *      Created: 21st January 1998
  7.  * Version 1.00: 13th December 1998
  8.  *
  9.  * (C) 1998 Nicholas Paul Sheppard. See the file licence.txt for details.
  10.  */
  11.  
  12. #ifndef XTYPES_H
  13. #define XTYPES_H
  14.  
  15. #include <stdio.h>
  16.  
  17.  
  18. /*******************************************************************************
  19.  *
  20.  * XARRAY - dynamically extensible array.
  21.  */
  22.  
  23. /* type definition for extensible arrays */
  24. typedef struct _XARRAY {
  25. /* private */
  26.     int    iElemSize;    /* size of an array element */
  27.     int    iCount;        /* current number of elements in the array */
  28.     int    iSize;        /* current size of the array space */
  29.     int    iBlock;        /* size to grow array by */
  30.     void *    pData;        /* the array data */
  31. } XARRAY;
  32.  
  33.  
  34. /* macros to typecast to normal arrays of some standard data types */
  35. #define xacast(x)    ((x)->pData)
  36. #define xachar(x)    ((char *)((x)->pData))
  37. #define xaint(x)    ((int *)(((x)->pData))
  38. #define xalong(x)    ((long *)(((x)->pData))
  39. #define xapchar(x)    ((char **)((x)->pData))
  40. #define xapint(x)    ((int **)((x)->pData))
  41. #define xaplong(x)    ((long **)((x)->pData))
  42. #define xaxarray(x)    ((XARRAY **)((x)->pData))
  43. #define xaxlist(x)    ((XLIST **)((x)->pData))
  44. #define xaxstr(x)    ((XSTR **)((x)->pData))
  45.  
  46. /* macro to return the current element count */
  47. #define xalen(x)    ((x)->iCount)
  48.  
  49. /* xarray.c - extensible array management */
  50. XARRAY *    xaappend(XARRAY *, void *);        /* add an element */
  51. void *        xacvt(XARRAY *);            /* convert to a normal array */
  52. void        xafree(XARRAY *);            /* de-allocate an array */
  53. void *        xaget(XARRAY *, int, void *);        /* retrieve an element */
  54. XARRAY *    xainsert(XARRAY *, int, void *);    /* insert an element */
  55. XARRAY *    xanew(int, int, int);            /* create a new array */
  56. XARRAY *    xaput(XARRAY *, int, void *);        /* replace an element */
  57. XARRAY *    xashrink(XARRAY *, int, int);        /* shrink an array */
  58.  
  59.  
  60. /*******************************************************************************
  61.  *
  62.  * XLIST - linked list.
  63.  */
  64.  
  65. /* type definition for a node */
  66. typedef struct _LNODE {
  67. /* private */
  68.     struct _LNODE *    pNext;        /* pointer to next node */
  69.     struct _LNODE *    pPrev;        /* pointer to previous node */
  70.     void *        pData;        /* node contents */
  71.     int        iSize;        /* node data size */
  72. } LNODE;
  73.  
  74.  
  75. /* type definition for linked lists */
  76. typedef struct _XLIST {
  77. /* private */
  78.     LNODE *        pHead;        /* head pointer */
  79.     LNODE *        pTail;        /* tail pointer */
  80.     LNODE *        pCursor;    /* cursor */
  81.     int        iCount;        /* list length */
  82. } XLIST;
  83.  
  84.  
  85. /* macro to test for end of linked list */
  86. #define xlend(x)        ((x)->pCursor == NULL)
  87.  
  88. /* macro to return pointer to current node's data */
  89. #define xldata(x)        (((x)->pCursor != NULL)? (x)->pCursor->pData : NULL)
  90.  
  91. /* macro to return the length of the list */
  92. #define xllen(x)        ((x)->iCount)
  93.  
  94. /* macro to query size of current node's data */
  95. #define xlsize(x)        (((x)->pCursor != NULL)? (x)->pCursor->iSize : NULL)
  96.  
  97. /* macros to use XLISTs as stacks */
  98. #define xlpop(x, p)        xlbehead((x), (p))
  99. #define xlpush(x, p, s)        xlprepend((x), (p), (s))
  100.  
  101. /* macros to use XLISTs as queues */
  102. #define xldequeue(x, p);    xlbehead((x), (p))
  103. #define xlenqueue(x, p, s)    xlappend((x), (p), (s))
  104.  
  105.  
  106. /* xlist.c - linked list management */
  107. XLIST *    xlappend(XLIST *, void *, int);        /* append a node */
  108. void *    xlbehead(XLIST *, void *);        /* retrieve head node */
  109. void    xldelete(XLIST *);            /* delete a node */
  110. void    xlfree(XLIST *);            /* de-allocate a list */
  111. void *    xlget(XLIST *, void *);            /* retrieve node data */
  112. XLIST *    xlnew(void);                /* create a new list */
  113. void *    xlnext(XLIST *);            /* move cursor to next node */
  114. XLIST *    xlprepend(XLIST *, void *, int);    /* prepend a node */
  115. void *    xlprev(XLIST *);            /* move cursor to previous node */
  116. void *    xlrewind(XLIST *);            /* return cursor to head node */
  117.  
  118.  
  119. /*******************************************************************************
  120.  *
  121.  * XSTR - dynamically extensible string.
  122.  */
  123.  
  124. /* type definition for extensible strings */
  125. typedef struct _XSTR {
  126. /* private */
  127.     int    iSize;        /* the current size of the of the space */
  128.     int    iBlock;        /* size to grow string by */
  129.     char    *pszString;    /* the string data */
  130. } XSTR;
  131.  
  132.  
  133. /* macro to typecast to a normal null-terminated string */
  134. #define xstrcast(x)    ((x)->pszString)
  135.  
  136. /* macro to return the nth character in the string */
  137. #define xstrch(x, n)    ((x)->pszString[n])
  138.  
  139. /* macro to return the length of an extensible string */
  140. #define xstrlen(x)    (strlen((x)->pszString))
  141.  
  142. /* xstr.c - extensible string management */
  143. XSTR *    fgetxstr(XSTR *, FILE *);        /* extensible version of fgets() */
  144. XSTR *    xstrcat(XSTR *, char *);        /* concatenate a string */
  145. XSTR *    xstrcatc(XSTR *, char);            /* concatenate a character */
  146. XSTR *    xstrcpy(XSTR *, char *);        /* copy a string */
  147. char *    xstrcvt(XSTR *);            /* convert to normal string */
  148. XSTR *    xstrdel(XSTR *, int, int);        /* delete characters from the string */
  149. void    xstrfree(XSTR *);            /* de-allocate a string */
  150. XSTR *    xstrncat(XSTR *, char *, int);        /* concatenate a string up to a length */
  151. XSTR *    xstrncpy(XSTR *, char *, int);        /* copy a string up to a length */
  152. XSTR *    xstrnew(int, int);            /* create a new string */
  153. XSTR *    xstrtrunc(XSTR *, int);            /* truncate a string */
  154.  
  155. #endif /* XTYPES_H */
  156.