home *** CD-ROM | disk | FTP | other *** search
/ Boldly Go Collection / version40.iso / TS / 17A / DRWIN101.ZIP / BITSTR.CPP next >
C/C++ Source or Header  |  1991-11-06  |  8KB  |  283 lines
  1. #include "bitstr.hpp"
  2.  
  3.  
  4. static UBIT16 bittab[0x10]={
  5.   0x0001,0x0002,0x0004,0x0008, 0x0010,0x0020,0x0040,0x0080,
  6.   0x0100,0x0200,0x0400,0x0800, 0x1000,0x2000,0x4000,0x8000
  7. };   //bittab
  8.  
  9.  
  10. //===========================================================================
  11. BIT_STREAM::BIT_STREAM(int maxbits)    //constructor
  12. {
  13.   max=maxbits;
  14. #if 0
  15.   if (max>(sizeof(base)<<3)) max=(sizeof(base)<<3);
  16. #else
  17.   if (max&7)
  18.     base=new UBIT8 [(max>>3)+1];       //get byte array -- leave room for end
  19.   else
  20.     base=new UBIT8 [max>>3];           //get byte array
  21. #endif
  22.   Flush();
  23. }   //BIT_STREAM::BIT_STREAM
  24.  
  25.  
  26. //===========================================================================
  27. UBIT8 BIT_STREAM::operator [] (UBIT16 index)
  28. {
  29.   if (index>=cnt) return 0;
  30.   UBIT16 off=tal+index;
  31.   if (off>=max) off-=max;
  32.   UBIT16 offbyt=off>>3;
  33.   UBIT16 offbit=off&7;
  34.   if (base[offbyt]&bittab[offbit]) return 1;
  35.   return 0;
  36. }   //[](UBIT16 k)
  37.  
  38.  
  39. //===========================================================================
  40. void BIT_STREAM::Set(UBIT16 index,UBIT8 bit)   //sets from current offset
  41. {
  42.   if (index>=cnt) return;
  43.   UBIT16 off=tal+index;
  44.   if (off>=max) off-=max;
  45.   UBIT16 offbyt=off>>3;
  46.   UBIT16 offbit=off&7;
  47.   if (bit)
  48.     base[offbyt]|=bittab[offbit];
  49.   else
  50.     base[offbyt]&=~bittab[offbit];
  51. }   //Set(UBIT16,UBIT8)
  52.  
  53.  
  54. //===========================================================================
  55. UBIT16 BIT_STREAM::Peek(UBIT16 off,UBIT16 bits)   //scans bits from offset
  56. {
  57.   register UBIT16 bit=1;
  58.   register UBIT16 val=0;
  59.   if (bits>16) bits=16;
  60.   for (UBIT16 i=0;i<bits;i++) {
  61.     if ((*this)[off+i]) val|=bit;
  62.     bit<<=1;
  63.   }   //for
  64.   return val;
  65. }   //BIT_STREAM::Peek(UBIT16,UBIT16)
  66.  
  67.  
  68. //===========================================================================
  69. void BIT_STREAM::BitPut(UBIT8 bit)     //inserts a single bit
  70. {
  71.   if (cnt>=max) return;                //make sure there's room
  72.   UBIT16 hedbyt=hed>>3;
  73.   UBIT16 hedbit=hed&7;
  74.   if (bit)
  75.     base[hedbyt]|=bittab[hedbit];
  76.   else
  77.     base[hedbyt]&=~bittab[hedbit];
  78.   cnt++;
  79.   hed++;
  80.   if (hed>=max) hed=0;
  81. }   //BitPut
  82.  
  83.  
  84. //===========================================================================
  85. void BIT_STREAM::Put(UBIT16 word,UBIT16 bits)  //add from a word
  86. {
  87.   UBIT16 register bit=1;
  88.   while (bits--) {
  89.     if (word & bit)
  90.       BitPut(1);                       //..if so, set a bit
  91.     else
  92.       BitPut(0);                       //..otherwise, reset a bit
  93.     if ((bit<<=1)==0) bit=1;           //..shift up
  94.   }
  95. }   //Put(UBIT16,UBIT16)
  96.  
  97.  
  98. //===========================================================================
  99. void BIT_STREAM::Put(UBIT32 word,UBIT16 bits)  //add from a long word
  100. {
  101.   UBIT32 register bit=1;
  102.   while (bits--) {
  103.     if (word & bit)
  104.       BitPut(1);                       //..if so, set a bit
  105.     else
  106.       BitPut(0);                       //..otherwise, reset a bit
  107.     if ((bit<<=1)==0) bit=1;           //..shift up
  108.   }
  109. }   //Put(UBIT32,UBIT16)
  110.  
  111.  
  112. //===========================================================================
  113. void BIT_STREAM::Put(UBIT8* data,UBIT16 bits)  //add from byte stream
  114. {
  115.   register UBIT8 bit=1;
  116.   while (bits-- && !Full()) {
  117.     if (*data & bit)
  118.       BitPut(1);                       //..if so, set a bit
  119.     else
  120.       BitPut(0);                       //..otherwise, reset a bit
  121.     if ((bit<<=1)==0) { bit=1; data++; }   //..shift up
  122.   }
  123. }   //Put(UBIT8*,UBIT16)
  124.  
  125.  
  126. //===========================================================================
  127. UBIT8 BIT_STREAM::BitGet(void)         //extracts a single bit
  128. {
  129.   if (!cnt) return 0;                  //make sure there's some
  130.   UBIT16 talbyt=tal>>3;
  131.   UBIT16 talbit=tal&7;
  132.   cnt--;
  133.   tal++;
  134.   if (tal>=max) tal=0;
  135.   if (base[talbyt]&bittab[talbit]) return 1;
  136.   return 0;
  137. }   //BitGet
  138.  
  139.  
  140. //===========================================================================
  141. UBIT16 BIT_STREAM::Get(UBIT16 bits)    //get bits
  142. {
  143.   UBIT16 val=0;
  144.   if (bits>32) bits=32;
  145.   UBIT16 register bit=1;
  146.   while (bits--) {
  147.     if (BitGet())
  148.       val|=bit;                        //..if so, set a bit
  149.     else
  150.       val&=~bit;                       //..otherwise, reset a bit
  151.     if ((bit<<=1)==0) bit=1;           //..shift up
  152.   }
  153.   return val;
  154. }   //Get(UBIT16)
  155.  
  156.  
  157. //===========================================================================
  158. void BIT_STREAM::Get(UBIT8* data,UBIT16 bits)  //get bits into byte buffer
  159. {
  160.   register UBIT8 bit=1;
  161.   while (bits-- && !Empty()) {
  162.     if (BitGet())
  163.       *data|=bit;                      //..if so, set a bit
  164.     else
  165.       *data&=~bit;                     //..otherwise, reset a bit
  166.     if ((bit<<=1)==0) { bit=1; data++; }   //..shift up
  167.   }
  168. }   //BIT_STREAM::Get(UBIT8*,UBIT16)
  169.  
  170.  
  171. //===========================================================================
  172. UBIT8 BIT_STREAM::BitUnPut(void)       //un-inserts a single bit
  173. {
  174.   if (!cnt) return 0;                  //make sure there's something
  175.   cnt--;
  176.   if (hed) hed--; else hed=max-1;
  177.   UBIT16 hedbyt=hed>>3;
  178.   UBIT16 hedbit=hed&7;
  179.   if (base[hedbyt]&bittab[hedbit]) return 1;
  180.   return 0;
  181. }   //BitUnPut
  182.  
  183.  
  184. //===========================================================================
  185. UBIT16 BIT_STREAM::UnPut(UBIT16 bits)  //unput bits
  186. {
  187.   UBIT16 val=0;
  188.   if (bits>32) bits=32;
  189.   UBIT16 register bit=1;
  190.   while (bits--) {
  191.     if (BitUnPut())
  192.       val|=bit;                        //..if so, set a bit
  193.     else
  194.       val&=~bit;                       //..otherwise, reset a bit
  195.     if ((bit<<=1)==0) bit=1;           //..shift up
  196.   }
  197.   return val;
  198. }   //UnPut(UBIT16)
  199.  
  200.  
  201. //===========================================================================
  202. void BIT_STREAM::UnPut(UBIT8* data,UBIT16 bits)  //unput bits into byte buff
  203. {
  204.   register UBIT8 bit=1;
  205.   while (bits-- && !Empty()) {
  206.     if (BitUnPut())
  207.       *data|=bit;                      //..if so, set a bit
  208.     else
  209.       *data&=~bit;                     //..otherwise, reset a bit
  210.     if ((bit<<=1)==0) { bit=1; data++; }   //..shift up
  211.   }
  212. }   //BIT_STREAM::UnPut(UBIT8*,UBIT16)
  213.  
  214.  
  215. //===========================================================================
  216. void BIT_STREAM::BitUnGet(UBIT8 bit)   //un-extracts a single bit
  217. {
  218.   if (cnt>=max) return;                //make sure it's not full
  219.   cnt++;
  220.   if (tal) tal--; else tal=max-1;      //make sure will work with BitGet
  221.   UBIT16 talbyt=tal>>3;
  222.   UBIT16 talbit=tal&7;
  223.   if (bit)
  224.     base[talbyt]|=bittab[talbit];
  225.   else
  226.     base[talbyt]&=~bittab[talbit];
  227. }   //BitUnGet
  228.  
  229.  
  230. //===========================================================================
  231. void BIT_STREAM::UnGet(UBIT16 bits)    //ungets with current contents
  232. {
  233.   while (bits--) {
  234.     if (cnt>=max) return;              //make sure it's not full
  235.     cnt++;                             //increment available bits count
  236.     if (tal) tal--; else tal=max-1;
  237.   }   //while
  238. }   //BIT_STREAM::UnGet(UBIT16)
  239.  
  240.  
  241. //===========================================================================
  242. void BIT_STREAM::UnGet(UBIT16 word,UBIT16 bits)  //unget from a word
  243. {
  244.   UBIT16 register bit=1;
  245.   while (bits--) {
  246.     if (word & bit)
  247.       BitUnGet(1);                     //..if so, set a bit
  248.     else
  249.       BitUnGet(0);                     //..otherwise, reset a bit
  250.     if ((bit<<=1)==0) bit=1;           //..shift up
  251.   }
  252. }   //UnGet(UBIT16,UBIT16)
  253.  
  254.  
  255. //===========================================================================
  256. void BIT_STREAM::UnGet(UBIT32 word,UBIT16 bits)  //unget from a long word
  257. {
  258.   UBIT32 register bit=1;
  259.   while (bits--) {
  260.     if (word & bit)
  261.       BitUnGet(1);                     //..if so, set a bit
  262.     else
  263.       BitUnGet(0);                     //..otherwise, reset a bit
  264.     if ((bit<<=1)==0) bit=1;           //..shift up
  265.   }
  266. }   //UnGet(UBIT32,UBIT16)
  267.  
  268.  
  269. //===========================================================================
  270. void BIT_STREAM::UnGet(UBIT8* data,UBIT16 bits)  //unget from byte stream
  271. {
  272.   register UBIT8 bit=1;
  273.   while (bits-- && !Full()) {
  274.     if (*data & bit)
  275.       BitUnGet(1);                     //..if so, set a bit
  276.     else
  277.       BitUnGet(0);                     //..otherwise, reset a bit
  278.     if ((bit<<=1)==0) { bit=1; data++; }   //..shift up
  279.   }
  280. }   //UnGet(UBIT8*,UBIT16)
  281.  
  282.  
  283.