Return to bitstring.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc

Annotation of embedaddon/ntp/lib/isc/bitstring.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Copyright (C) 2004, 2005, 2007  Internet Systems Consortium, Inc. ("ISC")
                      3:  * Copyright (C) 1999-2001  Internet Software Consortium.
                      4:  *
                      5:  * Permission to use, copy, modify, and/or distribute this software for any
                      6:  * purpose with or without fee is hereby granted, provided that the above
                      7:  * copyright notice and this permission notice appear in all copies.
                      8:  *
                      9:  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
                     10:  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
                     11:  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
                     12:  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
                     13:  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
                     14:  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
                     15:  * PERFORMANCE OF THIS SOFTWARE.
                     16:  */
                     17: 
                     18: /* $Id: bitstring.c,v 1.17 2007/06/19 23:47:17 tbox Exp $ */
                     19: 
                     20: /*! \file */
                     21: 
                     22: #include <config.h>
                     23: 
                     24: #include <stddef.h>
                     25: 
                     26: #include <isc/magic.h>
                     27: #include <isc/bitstring.h>
                     28: #include <isc/util.h>
                     29: 
                     30: #define DIV8(x)                        ((x) >> 3)
                     31: #define MOD8(x)                        ((x) & 0x00000007U)
                     32: #define OCTETS(n)              (((n) + 7) >> 3)
                     33: #define PADDED(n)              ((((n) + 7) >> 3) << 3)
                     34: #define BITSET(bs, n)          (((bs)->data[DIV8(n)] & \
                     35:                                 (1 << (7 - MOD8(n)))) != 0)
                     36: #define SETBIT(bs, n)          (bs)->data[DIV8(n)] |= (1 << (7 - MOD8(n)))
                     37: #define CLEARBIT(bs, n)                (bs)->data[DIV8(n)] &= ~(1 << (7 - MOD8(n)))
                     38: 
                     39: #define BITSTRING_MAGIC                ISC_MAGIC('B', 'S', 't', 'r')
                     40: #define VALID_BITSTRING(b)     ISC_MAGIC_VALID(b, BITSTRING_MAGIC)
                     41: 
                     42: void
                     43: isc_bitstring_init(isc_bitstring_t *bitstring, unsigned char *data,
                     44:                   unsigned int length, unsigned int size, isc_boolean_t lsb0)
                     45: {
                     46:        /*
                     47:         * Make 'bitstring' refer to the bitstring of 'size' bits starting
                     48:         * at 'data'.  'length' bits of the bitstring are valid.  If 'lsb0'
                     49:         * is set then, bit 0 refers to the least significant bit of the
                     50:         * bitstring.  Otherwise bit 0 is the most significant bit.
                     51:         */
                     52: 
                     53:        REQUIRE(bitstring != NULL);
                     54:        REQUIRE(data != NULL);
                     55:        REQUIRE(length <= size);
                     56: 
                     57:        bitstring->magic = BITSTRING_MAGIC;
                     58:        bitstring->data = data;
                     59:        bitstring->length = length;
                     60:        bitstring->size = size;
                     61:        bitstring->lsb0 = lsb0;
                     62: }
                     63: 
                     64: void
                     65: isc_bitstring_invalidate(isc_bitstring_t *bitstring) {
                     66: 
                     67:        /*
                     68:         * Invalidate 'bitstring'.
                     69:         */
                     70: 
                     71:        REQUIRE(VALID_BITSTRING(bitstring));
                     72: 
                     73:        bitstring->magic = 0;
                     74:        bitstring->data = NULL;
                     75:        bitstring->length = 0;
                     76:        bitstring->size = 0;
                     77:        bitstring->lsb0 = ISC_FALSE;
                     78: }
                     79: 
                     80: void
                     81: isc_bitstring_copy(isc_bitstring_t *source, unsigned int sbitpos,
                     82:                   isc_bitstring_t *target, unsigned int tbitpos,
                     83:                   unsigned int n)
                     84: {
                     85:        unsigned int tlast;
                     86: 
                     87:        /*
                     88:         * Starting at bit 'sbitpos', copy 'n' bits from 'source' to
                     89:         * the 'n' bits of 'target' starting at 'tbitpos'.
                     90:         */
                     91: 
                     92:        REQUIRE(VALID_BITSTRING(source));
                     93:        REQUIRE(VALID_BITSTRING(target));
                     94:        REQUIRE(source->lsb0 == target->lsb0);
                     95:        if (source->lsb0) {
                     96:                REQUIRE(sbitpos <= source->length);
                     97:                sbitpos = PADDED(source->size) - sbitpos;
                     98:                REQUIRE(sbitpos >= n);
                     99:                sbitpos -= n;
                    100:        } else
                    101:                REQUIRE(sbitpos + n <= source->length);
                    102:        tlast = tbitpos + n;
                    103:        if (target->lsb0) {
                    104:                REQUIRE(tbitpos <= target->length);
                    105:                tbitpos = PADDED(target->size) - tbitpos;
                    106:                REQUIRE(tbitpos >= n);
                    107:                tbitpos -= n;
                    108:        } else
                    109:                REQUIRE(tlast <= target->size);
                    110: 
                    111:        if (tlast > target->length)
                    112:                target->length = tlast;
                    113: 
                    114:        /*
                    115:         * This is far from optimal...
                    116:         */
                    117: 
                    118:        while (n > 0) {
                    119:                if (BITSET(source, sbitpos))
                    120:                        SETBIT(target, tbitpos);
                    121:                else
                    122:                        CLEARBIT(target, tbitpos);
                    123:                sbitpos++;
                    124:                tbitpos++;
                    125:                n--;
                    126:        }
                    127: }