# 2.11BSD#431 - /usr/src/usr.sbin/cron/bitstring.h

##### Macros

    _bit_byte         X
    _bit_mask         X
    bit_alloc         X
    bit_clear         X
    bit_decl          X
    bit_ffc           X
    bit_ffs           X
    bit_nclear        X
    bit_nset          X
    bit_set           X
    bit_test          X
    bitstr_size       X

##### typedef's

    bitstr_t          X

       1: /*
       2:  * Copyright (c) 1989 The Regents of the University of California.
       3:  * All rights reserved.
       4:  *
       5:  * This code is derived from software contributed to Berkeley by
       6:  * Paul Vixie.
       7:  *
       8:  * Redistribution and use in source and binary forms are permitted
       9:  * provided that the above copyright notice and this paragraph are
      10:  * duplicated in all such forms and that any documentation,
      11:  * advertising materials, and other materials related to such
      12:  * distribution and use acknowledge that the software was developed
      13:  * by the University of California, Berkeley.  The name of the
      14:  * University may not be used to endorse or promote products derived
      15:  * from this software without specific prior written permission.
      16:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
      17:  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
      18:  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
      19:  *
      20:  *	@(#)bitstring.h	5.2.1 (2.11BSD) 1999/8/5
      21:  */
      22:
      23: typedef unsigned char bitstr_t;
      24:
      25: /* internal macros */
      26:                 /* byte of the bitstring bit is in */
      27: #define _bit_byte(bit) \
      28:     ((bit) >> 3)
      29:
      30:                 /* mask for the bit within its byte */
      31: #define _bit_mask(bit) \
      32:     (1 << ((bit)&0x7))
      33:
      34: /* external macros */
      35:                 /* bytes in a bitstring of nbits bits */
      36: #define bitstr_size(nbits) \
      37:     ((((nbits) - 1) >> 3) + 1)
      38:
      39:                 /* allocate a bitstring */
      40: #define bit_alloc(nbits) \
      41:     (bitstr_t *)calloc(1, \
      42:         (unsigned int)bitstr_size(nbits) * sizeof(bitstr_t))
      43:
      44:                 /* allocate a bitstring on the stack */
      45: #define bit_decl(name, nbits) \
      46:     (name)[bitstr_size(nbits)]
      47:
      48:                 /* is bit N of bitstring name set? */
      49: #define bit_test(name, bit) \
      50:     ((name)[_bit_byte(bit)] & _bit_mask(bit))
      51:
      52:                 /* set bit N of bitstring name */
      53: #define bit_set(name, bit) \
      54:     (name)[_bit_byte(bit)] |= _bit_mask(bit)
      55:
      56:                 /* clear bit N of bitstring name */
      57: #define bit_clear(name, bit) \
      58:     (name)[_bit_byte(bit)] &= ~_bit_mask(bit)
      59:
      60:                 /* clear bits start ... stop in bitstring */
      61: #define bit_nclear(name, start, stop) { \
      62:     register bitstr_t *_name = name; \
      63:     register int _start = start, _stop = stop; \
      64:     register int _startbyte = _bit_byte(_start); \
      65:     register int _stopbyte = _bit_byte(_stop); \
      66:     if (_startbyte == _stopbyte) { \
      67:         _name[_startbyte] &= ((0xff >> (8 - (_start&0x7))) | \
      68:                       (0xff << ((_stop&0x7) + 1))); \
      69:     } else { \
      70:         _name[_startbyte] &= 0xff >> (8 - (_start&0x7)); \
      71:         while (++_startbyte < _stopbyte) \
      72:             _name[_startbyte] = 0; \
      73:         _name[_stopbyte] &= 0xff << ((_stop&0x7) + 1); \
      74:     } \
      75: }
      76:
      77:                 /* set bits start ... stop in bitstring */
      78: #define bit_nset(name, start, stop) { \
      79:     register bitstr_t *_name = name; \
      80:     register int _start = start, _stop = stop; \
      81:     register int _startbyte = _bit_byte(_start); \
      82:     register int _stopbyte = _bit_byte(_stop); \
      83:     if (_startbyte == _stopbyte) { \
      84:         _name[_startbyte] |= ((0xff << (_start&0x7)) & \
      85:                     (0xff >> (7 - (_stop&0x7)))); \
      86:     } else { \
      87:         _name[_startbyte] |= 0xff << ((_start)&0x7); \
      88:         while (++_startbyte < _stopbyte) \
      89:                 _name[_startbyte] = 0xff; \
      90:         _name[_stopbyte] |= 0xff >> (7 - (_stop&0x7)); \
      91:     } \
      92: }
      93:
      94:                 /* find first bit clear in name */
      95: #define bit_ffc(name, nbits, value) { \
      96:     register bitstr_t *_name = name; \
      97:     register int _byte, _nbits = nbits; \
      98:     register int _stopbyte = _bit_byte(_nbits), _value = -1; \
      99:     for (_byte = 0; _byte <= _stopbyte; ++_byte) \
     100:         if (_name[_byte] != 0xff) { \
     101:             _value = _byte << 3; \
     102:             for (_stopbyte = _name[_byte]; (_stopbyte&0x1); \
     103:                 ++_value, _stopbyte >>= 1); \
     104:             break; \
     105:         } \
     106:     *(value) = _value; \
     107: }
     108:
     109:                 /* find first bit set in name */
     110: #define bit_ffs(name, nbits, value) { \
     111:     register bitstr_t *_name = name; \
     112:     register int _byte, _nbits = nbits; \
     113:     register int _stopbyte = _bit_byte(_nbits), _value = -1; \
     114:     for (_byte = 0; _byte <= _stopbyte; ++_byte) \
     115:         if (_name[_byte]) { \
     116:             _value = _byte << 3; \
     117:             for (_stopbyte = _name[_byte]; !(_stopbyte&0x1); \
     118:                 ++_value, _stopbyte >>= 1); \
     119:             break; \
     120:         } \
     121:     *(value) = _value; \
     122: }

#### Defined typedef's

bitstr_t defined in line 23; used 6 times

- in line 41-42(2), 62, 79, 96, 111

#### Defined macros

_bit_byte defined in line 27; used 9 times

- in line 50-58(3), 64-65(2), 81-82(2), 98, 113

_bit_mask defined in line 31; used 3 times

- in line 50-58(3)

bit_alloc defined in line 40; never used
bit_clear defined in line 57; never used
bit_decl defined in line 45; never used
bit_ffc defined in line 95; never used
bit_ffs defined in line 110; never used
bit_nclear defined in line 61; never used
bit_nset defined in line 78; never used
bit_set defined in line 53; never used
bit_test defined in line 49; never used
bitstr_size defined in line 36; used 2 times

- in line 42-46(2)

Last modified: 1999-08-06 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 823 |