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