1 /* bit.c -- Implementation File (module.c template V1.0)
2 Copyright (C) 1995 Free Software Foundation, Inc.
3 Contributed by James Craig Burley.
5 This file is part of GNU Fortran.
7 GNU Fortran is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Fortran is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Fortran; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
26 Tracks arrays of booleans in useful ways.
38 /* Externals defined here. */
41 /* Simple definitions and enumerations. */
44 /* Internal typedefs. */
47 /* Private include files. */
50 /* Internal structure definitions. */
53 /* Static objects accessed by functions in this module. */
56 /* Static functions (internal). */
59 /* Internal macros. */
62 /* ffebit_count -- Count # of bits set a particular way
64 ffebit b; // the ffebit object
65 ffebitCount offset; // 0..size-1
66 bool value; // FALSE (0), TRUE (1)
67 ffebitCount range; // # bits to test
68 ffebitCount number; // # bits equal to value
69 ffebit_count(b,offset,value,range,&number);
71 Sets <number> to # bits at <offset> through <offset + range - 1> set to
72 <value>. If <range> is 0, <number> is set to 0. */
75 ffebit_count (ffebit b, ffebitCount offset, bool value, ffebitCount range,
81 assert (offset + range <= b->size);
83 for (*number = 0; range != 0; --range, ++offset)
85 element = offset / CHAR_BIT;
86 bitno = offset % CHAR_BIT;
88 == ((b->bits[element] & ((unsigned char) 1 << bitno)) == 0 ? FALSE : TRUE))
93 /* ffebit_new -- Create a new ffebit object
98 Destroys an ffebit object obtained via ffebit_new. */
101 ffebit_kill (ffebit b)
103 malloc_kill_ks (b->pool, b,
104 offsetof (struct _ffebit_, bits)
105 + (b->size + CHAR_BIT - 1) / CHAR_BIT);
108 /* ffebit_new -- Create a new ffebit object
113 b = ffebit_new(pool,size);
115 Allocates an ffebit object that holds the values of <size> bits in pool
119 ffebit_new (mallocPool pool, ffebitCount size)
123 b = malloc_new_zks (pool, "ffebit",
124 offsetof (struct _ffebit_, bits)
125 + (size + CHAR_BIT - 1) / CHAR_BIT,
133 /* ffebit_set -- Set value of # of bits
135 ffebit b; // the ffebit object
136 ffebitCount offset; // 0..size-1
137 bool value; // FALSE (0), TRUE (1)
138 ffebitCount length; // # bits to set starting at offset (usually 1)
139 ffebit_set(b,offset,value,length);
141 Sets bit #s <offset> through <offset + length - 1> to <value>. */
144 ffebit_set (ffebit b, ffebitCount offset, bool value, ffebitCount length)
150 assert (offset + length <= b->size);
152 for (i = 0; i < length; ++i, ++offset)
154 element = offset / CHAR_BIT;
155 bitno = offset % CHAR_BIT;
156 b->bits[element] = (((unsigned char) (value ? 1 : 0)) << bitno)
157 | (b->bits[element] & ~((unsigned char) 1 << bitno));
161 /* ffebit_test -- Test value of # of bits
163 ffebit b; // the ffebit object
164 ffebitCount offset; // 0..size-1
165 bool value; // FALSE (0), TRUE (1)
166 ffebitCount length; // # bits with same value
167 ffebit_test(b,offset,&value,&length);
169 Returns value of bits at <offset> through <offset + length - 1> in
170 <value>. If <offset> is already at the end of the bit array (if
171 offset == ffebit_size(b)), <length> is set to 0 and <value> is
175 ffebit_test (ffebit b, ffebitCount offset, bool *value, ffebitCount *length)
181 if (offset >= b->size)
183 assert (offset == b->size);
188 element = offset / CHAR_BIT;
189 bitno = offset % CHAR_BIT;
190 *value = (b->bits[element] & ((unsigned char) 1 << bitno)) == 0 ? FALSE : TRUE;
193 for (i = b->size - offset - 1, ++offset; i != 0; --i, ++offset, ++*length)
195 element = offset / CHAR_BIT;
196 bitno = offset % CHAR_BIT;
198 != ((b->bits[element] & ((unsigned char) 1 << bitno)) == 0 ? FALSE : TRUE))