modules/ma/bitmask.c

/* [<][>]
[^][v][top][bottom][index][help] */

FUNCTIONS

This source file includes following functions.
  1. MA_isset
  2. MA_set
  3. MA_clear
  4. MA_new
  5. MA_prt
  6. MA_and
  7. MA_xor
  8. MA_or
  9. MA_not
  10. MA_bitcount
  11. MA_to_string
  12. main

   1 /***************************************
   2   $Revision: 1.11 $
   3 
   4   bitmask (ma) - bitmask.c - library for manipulating fixed size bitmasks.
   5 
   6   Status: NOT REVUED, TESTED, INCOMPLETE
   7 
   8   Design and implementation by: Marek Bukowy, Chris Ottrey.
   9 
  10   ******************/ /******************
  11   Copyright (c) 1999                              RIPE NCC
  12  
  13   All Rights Reserved
  14   
  15   Permission to use, copy, modify, and distribute this software and its
  16   documentation for any purpose and without fee is hereby granted,
  17   provided that the above copyright notice appear in all copies and that
  18   both that copyright notice and this permission notice appear in
  19   supporting documentation, and that the name of the author not be
  20   used in advertising or publicity pertaining to distribution of the
  21   software without specific, written prior permission.
  22   
  23   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  24   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
  25   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
  26   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  27   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  28   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  29   ***************************************/
  30 
  31 
  32 
  33 #include <stdio.h>
  34 #include <stdarg.h>
  35 #include <stdlib.h>
  36 #include <assert.h>
  37 
  38 #include <string.h>
  39 
  40 #include "bitmask.h"
  41 #include "memwrap.h"
  42 #include "globaldefs.h"
  43 
  44 int MA_isset(mask_t d, int b) {
     /* [<][>][^][v][top][bottom][index][help] */
  45   return( 
  46  (d.data[b / MASK_BITS_BASESIZE] &(1 <<(b % MASK_BITS_BASESIZE)))
  47    > 0);
  48 }
  49 
  50 void MA_set(mask_t *m_ptr, unsigned b, int v) {
     /* [<][>][^][v][top][bottom][index][help] */
  51   assert(b < MASK_MAX);
  52   assert(v == 0 || v == 1);
  53 
  54   if(v == 1)
  55     m_ptr->data[b / MASK_BITS_BASESIZE] |=(1 <<(b % MASK_BITS_BASESIZE));
  56   else
  57     m_ptr->data[b / MASK_BITS_BASESIZE] &= ~(1 <<(b % MASK_BITS_BASESIZE));
  58 }
  59 
  60 void MA_clear(mask_t *m_ptr) {
     /* [<][>][^][v][top][bottom][index][help] */
  61   memset(m_ptr, 0, sizeof(mask_t));
  62 } /* MA_clear() */
  63 
  64 
  65 /* set bits in dptr. variable number of args, terminated by MA_END */
  66 mask_t MA_new(int n,...) {
     /* [<][>][^][v][top][bottom][index][help] */
  67   va_list         ap;
  68   mask_t d;
  69 
  70   MA_clear(&d);
  71 
  72   /* cover the "empty mask" case => MA_new(MA_END) invoked */
  73   for ( va_start(ap, n); n != MA_END; n = va_arg(ap, int) ) {
  74       MA_set(&d, n, 1);
  75   }
  76   va_end(ap);
  77 
  78   return d;
  79 }
  80 
  81 
  82 void MA_prt(mask_t m) {
     /* [<][>][^][v][top][bottom][index][help] */
  83   int  i;
  84 
  85   for (i = 0; i < MASK_MAX; i++) {
  86     printf("%d", MA_isset(m, i));
  87   }
  88 
  89   printf("\n");
  90 
  91   for (i = 0; i < MASK_BITS_WORDS; i++) {
  92     printf("0x%0*X ", 2 * sizeof(MASK_BITS_BASETYPE), m.data[i]);
  93   }
  94 
  95   printf("\n");
  96 }
  97 
  98 /* Perform a logical AND on two masks.
  99    Author: ottrey
 100    Date: Tue Jul  6 13:28:24 CEST 1999
 101    NB: This operation could/should be done a word at a time?
 102 */
 103 mask_t MA_and(mask_t a, mask_t b) {
     /* [<][>][^][v][top][bottom][index][help] */
 104   mask_t c;
 105   int i;
 106 
 107   for (i=0; i < MASK_BITS_WORDS; i++ )  {
 108     c.data[i] = a.data[i] & b.data[i];
 109   }
 110   return c;
 111 } /* MA_and() */
 112 
 113 /* Perform a logical XOR on two masks.
 114    Author: ottrey
 115    Date: Thu Jul  8 14:50:14 CEST 1999
 116    NB: This operation could/should be done a word at a time?
 117 */
 118 mask_t MA_xor(mask_t a, mask_t b) {
     /* [<][>][^][v][top][bottom][index][help] */
 119   mask_t c;
 120   int i;
 121 
 122   for (i=0; i < MASK_BITS_WORDS; i++ )  {
 123     c.data[i] = a.data[i] ^ b.data[i];
 124   }
 125 
 126   return c;
 127 
 128 } /* MA_xor() */
 129 
 130 /* Perform a logical OR on two masks.
 131    Author: ottrey
 132    Date: Thu Jul  8 16:34:34 CEST 1999
 133    NB: This operation could/should be done a word at a time?
 134 */
 135 mask_t MA_or(mask_t a, mask_t b) {
     /* [<][>][^][v][top][bottom][index][help] */
 136   mask_t c;
 137   int i;
 138 
 139   for (i=0; i < MASK_BITS_WORDS; i++ )  {
 140     c.data[i] = a.data[i] | b.data[i];
 141   }
 142 
 143   return c;
 144 
 145 } /* MA_or() */
 146 
 147 /* Perform a logical NOT operation on a mask.
 148    Author: marek
 149    Date: Fri Jan 14 17:15:00 MET 2000
 150    NB: This operation is done a word at a time.
 151 */
 152 mask_t MA_not(mask_t a) {
     /* [<][>][^][v][top][bottom][index][help] */
 153   mask_t c;
 154   int i;
 155   
 156   for (i=0; i < MASK_BITS_WORDS; i++ )  {
 157     c.data[i] = ~a.data[i];
 158   }
 159   return c;
 160 }
 161 
 162 /* Counts the number of bits set. */
 163 int MA_bitcount(mask_t m) {
     /* [<][>][^][v][top][bottom][index][help] */
 164   int  i;
 165   int count=0;
 166 
 167   for (i=0; i < MASK_MAX; i++) {
 168     count += MA_isset(m, i);
 169   }
 170 
 171   return count;
 172 
 173 } /* MA_bitcount() */
 174 
 175 /* Convert the bitmap to a string comprising of tokens from an array of tokens.
 176    Author: ottrey
 177    Date: Tue Jul  6 13:28:24 CEST 1999
 178 */
 179 char *MA_to_string(mask_t mask, char * const *tokens) {
     /* [<][>][^][v][top][bottom][index][help] */
 180   char *str;
 181   char str_buf[STR_L];
 182   int count;
 183   int i;
 184   int length;
 185 
 186   strcpy(str_buf, "");
 187 
 188   count=0;
 189   sprintf(str_buf, "{");
 190   for (i=0;  tokens[i] != NULL; i++) {
 191     if ( MA_isset(mask, i) != 0) {
 192       strcat(str_buf, tokens[i]);
 193       strcat(str_buf, ",");
 194       count++;
 195     }
 196   }
 197   if (count == 0) {
 198     strcat(str_buf, "NULL ");
 199   }
 200   length = strlen(str_buf);
 201   str_buf[length-1] = '}';
 202 
 203   /* str = (char *)calloc(1, strlen(str_buf)+1); */
 204   dieif(wr_calloc( (void **) &str,  1, strlen(str_buf)+1) != UT_OK);
 205 
 206   strcpy(str, str_buf);
 207 
 208   return str;
 209 
 210 } /* MA_to_string() */
 211 
 212 #ifdef MODULE_TEST
 213 void 
 214 main() {
     /* [<][>][^][v][top][bottom][index][help] */
 215   mask_t  d;
 216 
 217   d = MA_new(1, 4, 56, 3, 5, 7, 19, MA_END);
 218 
 219   MA_prt(d);
 220 
 221   MA_set(&d, 3, 0);
 222   MA_set(&d, 7, 0);
 223   MA_set(&d, 9, 0);
 224   MA_set(&d, 19, 0);
 225 
 226   MA_prt(d);
 227 }
 228 #endif

/* [<][>][^][v][top][bottom][index][help] */