SAFE public projects git trees. - safe/jmp/vzgot/blob - lib/utlvec.c

   1 /************************************************/
   2 /*                                              */
   3 /*      Copyright:                              */
   4 /*       Jean-Marc Pigeon <jmp@safe.ca>  2009   */
   5 /*                                              */
   6 /************************************************/
   7 /* This program is free software; you can       */
   8 /* redistribute it and/or modify it under the   */
   9 /* terms of the GNU General Public License as   */
  10 /* published by the Free Software Foundation    */
  11 /* version 2 of the License                     */
  12 /*                                              */
  13 /* This program is distributed in the hope that */
  14 /* it will be useful, but WITHOUT ANY WARRANTY; */
  15 /* without even the implied warranty of         */
  16 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR  */
  17 /* PURPOSE.  See the GNU General Public License */
  18 /* for more details.                            */
  19 /*                                              */
  20 /* You should have received a copy of the GNU   */
  21 /* General Public License along with this       */
  22 /* program; if not, write to the Free Software  */
  23 /* Foundation, Inc., 51 Franklin Street,        */
  24 /* Fifth Floor, Boston, MA  02110-1301, USA.    */
  25 /************************************************/
  26 /*                                              */
  27 /*      Implement utlity level procedure to     */
  28 /*      manage linked list                      */
  29 /*                                              */
  30 /************************************************/
  31 #include        <stdio.h>
  32 #include        <memory.h>
  33 #include        "dbgmem.h"
  34 #include        "lowtyp.h"
  35 #include        "utlvec.h"
  36 /*
  37 \f
  38 */
  39 /************************************************/
  40 /*                                              */
  41 /*      Procedure to add a payload within       */
  42 /*      a vectored list                         */
  43 /*                                              */
  44 /************************************************/
  45 VPTR *vec_addveclst(VPTR *vptr,void *payload)
  46
  47 {
  48 VECLST *node;
  49
  50 node=(VECLST *)calloc(1,sizeof(VECLST));
  51 node->payload=payload;
  52 if (vptr==(VPTR *)0) {
  53   vptr=(VPTR *)calloc(1,sizeof(VPTR));
  54   vptr->vcl=node;
  55   node->nxt=node;
  56   node->prv=node;
  57   }
  58 else {
  59   node->nxt=vptr->vcl;
  60   node->prv=vptr->vcl->prv;
  61   vptr->vcl->prv->nxt=node;
  62   vptr->vcl->prv=node;
  63   }
  64 vptr->numvec++;
  65 return vptr;
  66 }
  67 /*
  68 \f
  69 */
  70 /************************************************/
  71 /*                                              */
  72 /*      Procedure to remove on vector from the  */
  73 /*      vector list, return the number of       */
  74 /*      payload subtracted.                     */
  75 /*                                              */
  76 /************************************************/
  77 int vec_rmveclst(VPTR **vptr,void *payload)
  78
  79 {
  80 register int done;
  81
  82 done=0;
  83 if (*vptr!=(VPTR *)0) {
  84   register u_int i;
  85   register VECLST *cur;
  86
  87   for (i=0,cur=(*vptr)->vcl;i<(*vptr)->numvec;i++) {
  88     if (payload==cur->payload) {
  89       register VECLST *prv;
  90
  91       prv=cur->prv;
  92       (*vptr)->numvec--;
  93       cur->prv->nxt=cur->nxt;
  94       cur->nxt->prv=cur->prv;
  95       (void) free(cur);
  96       cur=prv;
  97       done++;
  98       }
  99     cur=cur->nxt;
 100     }
 101   if ((*vptr)->numvec==0) {
 102     (void) free(*vptr);
 103     *vptr=(VPTR *)0;
 104     }
 105   }
 106 return done;
 107 }
 108 /*
 109 \f
 110 */
 111 /************************************************/
 112 /*                                              */
 113 /*      Procedure to free a vector list,        */
 114 /*      memory used by payload is freed too.    */
 115 /*                                              */
 116 /************************************************/
 117 VPTR *vec_freeveclst(VPTR *vptr,void *(*freepayload)(void *))
 118
 119 {
 120 if (vptr!=(VPTR *)0) {
 121   register u_int i;
 122   register VECLST *cur;
 123
 124   for (i=0,cur=vptr->vcl->prv;i<vptr->numvec;i++) {
 125     register VECLST *tofree;
 126     register void *payload;
 127
 128     tofree=cur;
 129     payload=tofree->payload;
 130     cur=tofree->prv;
 131     (void) free(tofree);
 132     if ((payload!=(void *)0)&&(freepayload!=(void *(*)(void*))0))
 133       (void) freepayload(payload);
 134     }
 135   (void) free(vptr);
 136   vptr=(VPTR *)0;
 137   }
 138 return vptr;
 139 }
 140 /*
 141 \f
 142 */
 143 /************************************************/
 144 /*                                              */
 145 /*      Procedure to count number of element    */
 146 /*      within an ordered list.                 */
 147 /*                                              */
 148 /************************************************/
 149 unsigned int vec_sizelstlst(void **lptr)
 150
 151 {
 152 register unsigned int num;
 153
 154 num=(unsigned int)0;
 155 if (lptr!=(void **)0) {
 156   for (;*lptr!=(void *)0;lptr++,num++);
 157   }
 158 return num;
 159 }
 160 /*
 161 \f
 162 */
 163 /************************************************/
 164 /*                                              */
 165 /*      Procedure to add a payload within       */
 166 /*      an ordered list                         */
 167 /*                                              */
 168 /************************************************/
 169 void **vec_addlstlst(void **lptr,void *payload)
 170
 171 {
 172 int num;
 173
 174 num=0;
 175 if (lptr!=(void **)0) {
 176   num=vec_sizelstlst(lptr);
 177   lptr=(void **)realloc(lptr,(num+2)*sizeof(void *));
 178   }
 179 else
 180   lptr=(void **)calloc(2,sizeof(void *));
 181 lptr[num]=payload;
 182 lptr[num+1]=(void *)0;
 183 return lptr;
 184 }
 185 /*
 186 \f
 187 */
 188 /************************************************/
 189 /*                                              */
 190 /*      Procedure to merge to ordereded list    */
 191 /*      second list array definition is freed   */
 192 /*                                              */
 193 /************************************************/
 194 void **vec_mrglstlst(void **lptr,void **ladd)
 195
 196 {
 197 if (ladd!=(void **)0) {
 198   register unsigned int t1;
 199   register unsigned int t2;
 200
 201   if (lptr==(void **)0)
 202     lptr=(void **)calloc(1,sizeof(void *));
 203   t1=vec_sizelstlst(lptr);
 204   t2=vec_sizelstlst(ladd);
 205   lptr=(void **)realloc(lptr,(t1+t2+1)*sizeof(void *));
 206   (void) memcpy(lptr+t1,ladd,(t2+1)*sizeof(void *));
 207   (void) free(ladd);
 208   }
 209 return lptr;
 210 }
 211 /*
 212 \f
 213 */
 214 /************************************************/
 215 /*                                              */
 216 /*      Procedure to remove one payload from    */
 217 /*      within an ordered list                  */
 218 /*      Return true if success, false otherwise */
 219 /*                                              */
 220 /************************************************/
 221 int vec_rmlstlst(void **lptr,void *payload)
 222
 223 {
 224 int success;
 225
 226 success=false;
 227 if (lptr!=(void **)0) {
 228   for (;*lptr!=(void *)0;lptr++) {
 229     if (success==false) {
 230       if (*lptr==payload) {
 231         success=true;
 232         lptr--;
 233         }
 234       }
 235     else
 236       *lptr=*(lptr+1);
 237     }
 238   }
 239 return success;
 240 }
 241 /*
 242 \f
 243 */
 244 /************************************************/
 245 /*                                              */
 246 /*      Procedure to remove all payload from    */
 247 /*      an ordered list.                        */
 248 /*                                              */
 249 /************************************************/
 250 void **vec_freelstlst(void **lptr,void *(*freepayload)(void *))
 251
 252 {
 253 if (lptr!=(void **)0) {
 254   register void **p;
 255
 256   for (p=lptr;*p!=(void *)0;p++) {
 257     if (freepayload!=(void *(*)(void*))0)
 258       *p=freepayload(*p);
 259     }
 260   (void) free(lptr);
 261   lptr=(void **)0;
 262   }
 263 return lptr;
 264 }