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.
37 /* Externals defined here. */
40 /* Simple definitions and enumerations. */
43 /* Internal typedefs. */
46 /* Private include files. */
49 /* Internal structure definitions. */
52 /* Static objects accessed by functions in this module. */
55 /* Static functions (internal). */
58 /* Internal macros. */
61 /* ffebit_count -- Count # of bits set a particular way
63 ffebit b; // the ffebit object
64 ffebitCount offset; // 0..size-1
65 bool value; // FALSE (0), TRUE (1)
66 ffebitCount range; // # bits to test
67 ffebitCount number; // # bits equal to value
68 ffebit_count(b,offset,value,range,&number);
70 Sets <number> to # bits at <offset> through <offset + range - 1> set to
71 <value>. If <range> is 0, <number> is set to 0. */
74 ffebit_count (ffebit b, ffebitCount offset, bool value, ffebitCount range,
80 assert (offset + range <= b->size);
82 for (*number = 0; range != 0; --range, ++offset)
84 element = offset / CHAR_BIT;
85 bitno = offset % CHAR_BIT;
87 == ((b->bits[element] & ((unsigned char) 1 << bitno)) == 0 ? FALSE : TRUE))
92 /* ffebit_new -- Create a new ffebit object
97 Destroys an ffebit object obtained via ffebit_new. */
100 ffebit_kill (ffebit b)
102 malloc_kill_ks (b->pool, b,
103 offsetof (struct _ffebit_, bits)
104 + (b->size + CHAR_BIT - 1) / CHAR_BIT);
107 /* ffebit_new -- Create a new ffebit object
112 b = ffebit_new(pool,size);
114 Allocates an ffebit object that holds the values of <size> bits in pool
118 ffebit_new (mallocPool pool, ffebitCount size)
122 b = malloc_new_zks (pool, "ffebit",
123 offsetof (struct _ffebit_, bits)
124 + (size + CHAR_BIT - 1) / CHAR_BIT,
132 /* ffebit_set -- Set value of # of bits
134 ffebit b; // the ffebit object
135 ffebitCount offset; // 0..size-1
136 bool value; // FALSE (0), TRUE (1)
137 ffebitCount length; // # bits to set starting at offset (usually 1)
138 ffebit_set(b,offset,value,length);
140 Sets bit #s <offset> through <offset + length - 1> to <value>. */
143 ffebit_set (ffebit b, ffebitCount offset, bool value, ffebitCount length)
149 assert (offset + length <= b->size);
151 for (i = 0; i < length; ++i, ++offset)
153 element = offset / CHAR_BIT;
154 bitno = offset % CHAR_BIT;
155 b->bits[element] = (((unsigned char) (value ? 1 : 0)) << bitno)
156 | (b->bits[element] & ~((unsigned char) 1 << bitno));
160 /* ffebit_test -- Test value of # of bits
162 ffebit b; // the ffebit object
163 ffebitCount offset; // 0..size-1
164 bool value; // FALSE (0), TRUE (1)
165 ffebitCount length; // # bits with same value
166 ffebit_test(b,offset,&value,&length);
168 Returns value of bits at <offset> through <offset + length - 1> in
169 <value>. If <offset> is already at the end of the bit array (if
170 offset == ffebit_size(b)), <length> is set to 0 and <value> is
174 ffebit_test (ffebit b, ffebitCount offset, bool *value, ffebitCount *length)
180 if (offset >= b->size)
182 assert (offset == b->size);
187 element = offset / CHAR_BIT;
188 bitno = offset % CHAR_BIT;
189 *value = (b->bits[element] & ((unsigned char) 1 << bitno)) == 0 ? FALSE : TRUE;
192 for (i = b->size - offset - 1, ++offset; i != 0; --i, ++offset, ++*length)
194 element = offset / CHAR_BIT;
195 bitno = offset % CHAR_BIT;
197 != ((b->bits[element] & ((unsigned char) 1 << bitno)) == 0 ? FALSE : TRUE))