git.pond.sub.org Git - empserver/blob - src/client/bit.c

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2000, Dave Pare, Jeff Bailey, Thomas Ruschak,
   4  *                           Ken Stevens, Steve McClure
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  *  ---
  21  *
  22  *  See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
  23  *  related information and legal notices. It is expected that any future
  24  *  projects/authors will amend these files as needed.
  25  *
  26  *  ---
  27  *
  28  *  bit.c: Bit field manipulation routines
  29  *
  30  *  Known contributors to this file:
  31  *
  32  */
  33
  34 #include "misc.h"
  35
  36 /*
  37  * bits.c
  38  *
  39  * allocate and search select-style bitfields
  40  *
  41  */
  42
  43 #include "bit.h"
  44
  45 int bit_nfile;
  46 int bit_nbytes;
  47
  48 int getfdtablesize();
  49 void bit_zero(bit_fdmask);
  50
  51 bit_fdmask
  52 bit_newfdmask()
  53 {
  54     extern s_char *malloc();
  55     bit_fdmask mask;
  56
  57     if (bit_nfile == 0) {
  58         bit_nfile = getfdtablesize();
  59         bit_nbytes = (bit_nfile + (BIT_BITSPERMASK - 1)) / BIT_NBBY;
  60     }
  61     mask = (bit_fdmask)malloc(bit_nbytes);
  62     (void)bit_zero(mask);
  63     return mask;
  64 }
  65
  66 /*
  67  * zero the bitfield
  68  */
  69 void
  70 bit_zero(bitp)
  71 bit_fdmask bitp;
  72 {
  73     bit_mask *mask;
  74     register int i;
  75     register int nwords;
  76
  77     mask = bitp;
  78     nwords = bit_nbytes / sizeof(*mask);
  79     for (i = 0; i < nwords; i++)
  80         *mask++ = 0;
  81 }
  82
  83 /*
  84  * zero the bitfield
  85  */
  86 void
  87 bit_not(bitp)
  88 bit_fdmask bitp;
  89 {
  90     register bit_mask *mask;
  91     register int i;
  92     register int nwords;
  93
  94     mask = bitp;
  95     nwords = bit_nbytes / sizeof(*mask);
  96     for (i = 0; i < nwords; i++, mask++)
  97         *mask = ~(*mask);
  98 }
  99
 100 /*
 101  * zero the bitfield
 102  */
 103 void
 104 bit_copy(bitsrc, bitdst)
 105 bit_fdmask bitsrc;
 106 bit_fdmask bitdst;
 107 {
 108     register bit_mask *src;
 109     register bit_mask *dst;
 110     register int i;
 111     register int nwords;
 112
 113     dst = bitdst;
 114     src = bitsrc;
 115     nwords = bit_nbytes / sizeof(*dst);
 116     for (i = 0; i < nwords; i++)
 117         *dst++ = *src++;
 118 }
 119
 120 /*
 121  * zero the bitfield
 122  */
 123 void
 124 bit_or(bitsrc, bitdst)
 125 bit_fdmask bitsrc;
 126 bit_fdmask bitdst;
 127 {
 128     register bit_mask *src;
 129     register bit_mask *dst;
 130     register int i;
 131     register int nwords;
 132
 133     nwords = bit_nbytes / sizeof(*dst);
 134     src = bitsrc;
 135     dst = bitdst;
 136     for (i = 0; i < nwords; i++)
 137         *dst++ |= *src++;
 138 }
 139
 140 /*
 141  * zero the bitfield
 142  */
 143 void
 144 bit_or3(bitsrc1, bitsrc2, bitdst)
 145 bit_fdmask bitsrc1;
 146 bit_fdmask bitsrc2;
 147 bit_fdmask bitdst;
 148 {
 149     register bit_mask *src1;
 150     register bit_mask *src2;
 151     register bit_mask *dst;
 152     register int i;
 153     register int nwords;
 154
 155     src1 = bitsrc1;
 156     src2 = bitsrc2;
 157     dst = bitdst;
 158     nwords = bit_nbytes / sizeof(*dst);
 159     for (i = 0; i < nwords; i++)
 160         *dst++ = *src1++ | *src2++;
 161 }
 162
 163 /*
 164  * zero the bitfield
 165  */
 166 void
 167 bit_and(bitsrc, bitdst)
 168 bit_fdmask bitsrc;
 169 bit_fdmask bitdst;
 170 {
 171     register bit_mask *src;
 172     register bit_mask *dst;
 173     register int i;
 174     register int nwords;
 175
 176     nwords = bit_nbytes / sizeof(*src);
 177     src = bitsrc;
 178     dst = bitdst;
 179     for (i = 0; i < nwords; i++)
 180         *dst++ &= *src++;
 181 }
 182
 183 /*
 184  * zero the bitfield
 185  */
 186 void
 187 bit_and3(bitsrc1, bitsrc2, bitdst)
 188 bit_fdmask bitsrc1;
 189 bit_fdmask bitsrc2;
 190 bit_fdmask bitdst;
 191 {
 192     register bit_mask *src1;
 193     register bit_mask *src2;
 194     register bit_mask *dst;
 195     register int i;
 196     register int nwords;
 197
 198     src1 = bitsrc1;
 199     src2 = bitsrc2;
 200     dst = bitdst;
 201     nwords = bit_nbytes / sizeof(*dst);
 202     for (i = 0; i < nwords; i++)
 203         *dst++ = *src1++ & *src2++;
 204 }
 205
 206 /*
 207  * Return first bit set in fd mask.
 208  * speedy version, not using BIT_ISSETB()
 209  */
 210 int
 211 bit_fd(bitp)
 212 bit_fdmask bitp;
 213 {
 214     register bit_mask *mask;
 215     register unsigned int j;
 216     register bit_mask m;
 217     register int i;
 218     int nwords;
 219
 220     mask = bitp;
 221     nwords = bit_nbytes / sizeof(m);
 222     for (i = 0; i < nwords; i++, mask++) {
 223         if ((m = *mask) == 0)
 224             continue;
 225         for (j = 0; j < BIT_BITSPERMASK; j++) {
 226             if (m & bit(j))
 227                 return i * BIT_BITSPERMASK + j;
 228         }
 229         /*NOTREACHED*/
 230     }
 231     return -1;
 232 }