gcc/f/bit.c

   1 /* bit.c -- Implementation File (module.c template V1.0)
   2    Copyright (C) 1995 Free Software Foundation, Inc.
   3    Contributed by James Craig Burley.
   4
   5 This file is part of GNU Fortran.
   6
   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)
  10 any later version.
  11
  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.
  16
  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
  20 02111-1307, USA.
  21
  22    Related Modules:
  23       None
  24
  25    Description:
  26       Tracks arrays of booleans in useful ways.
  27
  28    Modifications:
  29 */
  30
  31 /* Include files. */
  32
  33 #include "proj.h"
  34 #include "glimits.j"
  35 #include "bit.h"
  36 #include "malloc.h"
  37
  38 /* Externals defined here. */
  39
  40
  41 /* Simple definitions and enumerations. */
  42
  43
  44 /* Internal typedefs. */
  45
  46
  47 /* Private include files. */
  48
  49
  50 /* Internal structure definitions. */
  51
  52
  53 /* Static objects accessed by functions in this module. */
  54
  55
  56 /* Static functions (internal). */
  57
  58
  59 /* Internal macros. */
  60 \f
  61
  62 /* ffebit_count -- Count # of bits set a particular way
  63
  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);
  70
  71    Sets <number> to # bits at <offset> through <offset + range - 1> set to
  72    <value>.  If <range> is 0, <number> is set to 0.  */
  73
  74 void
  75 ffebit_count (ffebit b, ffebitCount offset, bool value, ffebitCount range,
  76               ffebitCount *number)
  77 {
  78   ffebitCount element;
  79   ffebitCount bitno;
  80
  81   assert (offset + range <= b->size);
  82
  83   for (*number = 0; range != 0; --range, ++offset)
  84     {
  85       element = offset / CHAR_BIT;
  86       bitno = offset % CHAR_BIT;
  87       if (value
  88           == ((b->bits[element] & ((unsigned char) 1 << bitno)) == 0 ? FALSE : TRUE))
  89         ++ * number;
  90     }
  91 }
  92
  93 /* ffebit_new -- Create a new ffebit object
  94
  95    ffebit b;
  96    ffebit_kill(b);
  97
  98    Destroys an ffebit object obtained via ffebit_new.  */
  99
 100 void
 101 ffebit_kill (ffebit b)
 102 {
 103   malloc_kill_ks (b->pool, b,
 104                   offsetof (struct _ffebit_, bits)
 105                   + (b->size + CHAR_BIT - 1) / CHAR_BIT);
 106 }
 107
 108 /* ffebit_new -- Create a new ffebit object
 109
 110    ffebit b;
 111    mallocPool pool;
 112    ffebitCount size;
 113    b = ffebit_new(pool,size);
 114
 115    Allocates an ffebit object that holds the values of <size> bits in pool
 116    <pool>.  */
 117
 118 ffebit
 119 ffebit_new (mallocPool pool, ffebitCount size)
 120 {
 121   ffebit b;
 122
 123   b = malloc_new_zks (pool, "ffebit",
 124                       offsetof (struct _ffebit_, bits)
 125                       + (size + CHAR_BIT - 1) / CHAR_BIT,
 126                       0);
 127   b->pool = pool;
 128   b->size = size;
 129
 130   return b;
 131 }
 132
 133 /* ffebit_set -- Set value of # of bits
 134
 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);
 140
 141    Sets bit #s <offset> through <offset + length - 1> to <value>.  */
 142
 143 void
 144 ffebit_set (ffebit b, ffebitCount offset, bool value, ffebitCount length)
 145 {
 146   ffebitCount i;
 147   ffebitCount element;
 148   ffebitCount bitno;
 149
 150   assert (offset + length <= b->size);
 151
 152   for (i = 0; i < length; ++i, ++offset)
 153     {
 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));
 158     }
 159 }
 160
 161 /* ffebit_test -- Test value of # of bits
 162
 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);
 168
 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
 172    undefined.  */
 173
 174 void
 175 ffebit_test (ffebit b, ffebitCount offset, bool *value, ffebitCount *length)
 176 {
 177   ffebitCount i;
 178   ffebitCount element;
 179   ffebitCount bitno;
 180
 181   if (offset >= b->size)
 182     {
 183       assert (offset == b->size);
 184       *length = 0;
 185       return;
 186     }
 187
 188   element = offset / CHAR_BIT;
 189   bitno = offset % CHAR_BIT;
 190   *value = (b->bits[element] & ((unsigned char) 1 << bitno)) == 0 ? FALSE : TRUE;
 191   *length = 1;
 192
 193   for (i = b->size - offset - 1, ++offset; i != 0; --i, ++offset, ++*length)
 194     {
 195       element = offset / CHAR_BIT;
 196       bitno = offset % CHAR_BIT;
 197       if (*value
 198           != ((b->bits[element] & ((unsigned char) 1 << bitno)) == 0 ? FALSE : TRUE))
 199         break;
 200     }
 201 }