home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / g__inc / xbitstri.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-23  |  19.8 KB  |  769 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /* 
  3. Copyright (C) 1988 Free Software Foundation
  4.     written by Doug Lea (dl@rocky.oswego.edu)
  5.  
  6. This file is part of the GNU C++ Library.  This library is free
  7. software; you can redistribute it and/or modify it under the terms of
  8. the GNU Library General Public License as published by the Free
  9. Software Foundation; either version 2 of the License, or (at your
  10. option) any later version.  This library is distributed in the hope
  11. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13. PURPOSE.  See the GNU Library General Public License for more details.
  14. You should have received a copy of the GNU Library General Public
  15. License along with this library; if not, write to the Free Software
  16. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18.  
  19. #ifndef _BitString_h
  20. #ifdef __GNUG__
  21. #pragma once
  22. #pragma interface
  23. #endif
  24.  
  25. #define _BitString_h 1
  26.  
  27. #include <stream.h>
  28. #include <values.h>
  29.  
  30. #define BITSTRBITS   BITS(short)
  31.  
  32. struct BitStrRep
  33. {
  34.   unsigned int    len;          // length in bits
  35.   unsigned short  sz;           // allocated slots
  36.   unsigned short  s[1];         // bits start here
  37. };
  38.  
  39. extern BitStrRep*  BStr_alloc(BitStrRep*, const unsigned short*, int, int,int);
  40. extern BitStrRep*  BStr_resize(BitStrRep*, int);
  41. extern BitStrRep*  BStr_copy(BitStrRep*, const BitStrRep*);
  42. extern BitStrRep*  cmpl(const BitStrRep*, BitStrRep*);
  43. extern BitStrRep*  and(const BitStrRep*, const BitStrRep*, BitStrRep*);
  44. extern BitStrRep*  or(const BitStrRep*, const BitStrRep*, BitStrRep*);
  45. extern BitStrRep*  xor(const BitStrRep*, const BitStrRep*, BitStrRep*);
  46. extern BitStrRep*  diff(const BitStrRep*, const BitStrRep*, BitStrRep*);
  47. extern BitStrRep*  cat(const BitStrRep*, const BitStrRep*, BitStrRep*);
  48. extern BitStrRep*  cat(const BitStrRep*, unsigned int, BitStrRep*);
  49. extern BitStrRep*  lshift(const BitStrRep*, int, BitStrRep*);
  50.  
  51.  
  52. class BitString;
  53. class BitPattern;
  54.  
  55. class BitStrBit
  56. {
  57. protected:
  58.   BitString&        src;
  59.   unsigned int      pos;
  60.  
  61.  public:
  62.                     BitStrBit(BitString& v, int p);
  63.                     BitStrBit(const BitStrBit& b);
  64.                    ~BitStrBit();
  65.                     operator unsigned int() const;
  66.   int               operator =  (unsigned int b);
  67.   int               operator == (unsigned int b) const ;
  68.   int               operator != (unsigned int b) const ;
  69. };
  70.  
  71. class BitSubString
  72. {
  73.   friend class      BitString;
  74.   friend class      BitPattern;
  75.  
  76. protected:
  77.  
  78.   BitString&        S;
  79.   int               pos;
  80.   int               len;
  81.  
  82.                     BitSubString(BitString& x, int p, int l);
  83.                     BitSubString(const BitSubString& x);
  84. public:
  85.                     ~BitSubString();
  86.  
  87.   void              operator =  (const BitString&);
  88.   void              operator =  (const BitSubString&);
  89.  
  90.   int               length() const;
  91.   int               empty() const;
  92.  
  93.   int               OK() const;
  94. };
  95.  
  96. class BitString
  97. {
  98.   friend class       BitSubString;
  99.   friend class       BitPattern;
  100. protected:
  101.   BitStrRep*         rep;
  102.  
  103.   int                search(int, int, const unsigned short*, int, int) const;
  104.   int                match(int, int, int, const unsigned short*,int,int) const;
  105.   BitSubString       _substr(int first, int l);
  106.  
  107. public:
  108.  
  109. // constructors
  110.                      BitString();
  111.                      BitString(const BitString&);
  112.                      BitString(const BitSubString& y);
  113.  
  114.                     ~BitString();
  115.  
  116.   void               operator =  (unsigned int bit);
  117.   void               operator =  (const BitString& y);
  118.   void               operator =  (const BitSubString& y);
  119.  
  120. // equality & subset tests
  121.  
  122.   friend int         operator == (const BitString&, const BitString&);
  123.   friend int         operator != (const BitString&, const BitString&);
  124.   friend int         operator <  (const BitString&, const BitString&);
  125.   friend int         operator <= (const BitString&, const BitString&);
  126.   friend int         operator >  (const BitString&, const BitString&);
  127.   friend int         operator >= (const BitString&, const BitString&);
  128.  
  129. // procedural versions of operators
  130.  
  131.  
  132.   friend void        and(const BitString&, const BitString&, BitString&);
  133.   friend void        or(const BitString&, const BitString&, BitString&);
  134.   friend void        xor(const BitString&, const BitString&, BitString&);
  135.   friend void        diff(const BitString&, const BitString&, BitString&);
  136.   friend void        cat(const BitString&, const BitString&, BitString&);
  137.   friend void        cat(const BitString&, unsigned int, BitString&);
  138.   friend void        lshift(const BitString&, int, BitString&);
  139.   friend void        rshift(const BitString&, int, BitString&);
  140.  
  141.   friend void        complement(const BitString&, BitString&);
  142.  
  143.   friend int         lcompare(const BitString&, const BitString&); 
  144.  
  145. // assignment-based operators
  146. // (constuctive versions decalred inline below
  147.  
  148.   void               operator |= (const BitString&);
  149.   void               operator &= (const BitString&);
  150.   void               operator -= (const BitString&);
  151.   void               operator ^= (const BitString&);
  152.   void               operator += (const BitString&);
  153.   void               operator += (unsigned int b);
  154.   void               operator <<=(int s);
  155.   void               operator >>=(int s);
  156.  
  157.   void               complement();
  158.  
  159. // individual bit manipulation
  160.  
  161.   void               set(int pos);
  162.   void               set(int from, int to);
  163.   void               set();
  164.  
  165.   void               clear(int pos);
  166.   void               clear(int from, int to);
  167.   void               clear(); 
  168.  
  169.   void               invert(int pos);
  170.   void               invert(int from, int to);
  171.  
  172.   int                test(int pos) const;
  173.   int                test(int from, int to) const;
  174.  
  175.   void               assign(int p, unsigned int bit);
  176.  
  177. // indexing
  178.  
  179.   BitStrBit          operator [] (int pos);
  180.  
  181. // iterators
  182.  
  183.   int                first(unsigned int bit = 1) const;
  184.   int                last(unsigned int b = 1) const;
  185.  
  186.   int                next(int pos, unsigned int b = 1) const;
  187.   int                previous(int pos, unsigned int b = 1) const;
  188.  
  189. // searching & matching
  190.  
  191.   int                index(unsigned int bit, int startpos = 0) const ;      
  192.   int                index(const BitString&, int startpos = 0) const;
  193.   int                index(const BitSubString&, int startpos = 0) const;
  194.   int                index(const BitPattern&, int startpos = 0) const;
  195.  
  196.   int                contains(const BitString&) const;
  197.   int                contains(const BitSubString&) const;
  198.   int                contains(const BitPattern&) const;
  199.  
  200.   int                contains(const BitString&, int pos) const;
  201.   int                contains(const BitSubString&, int pos) const;
  202.   int                contains(const BitPattern&, int pos) const;
  203.  
  204.   int                matches(const BitString&, int pos = 0) const;
  205.   int                matches(const BitSubString&, int pos = 0) const;
  206.   int                matches(const BitPattern&, int pos = 0) const;
  207.  
  208. // BitSubString extraction
  209.  
  210.   BitSubString       at(int pos, int len);
  211.   BitSubString       at(const BitString&, int startpos = 0); 
  212.   BitSubString       at(const BitSubString&, int startpos = 0); 
  213.   BitSubString       at(const BitPattern&, int startpos = 0); 
  214.  
  215.   BitSubString       before(int pos);
  216.   BitSubString       before(const BitString&, int startpos = 0);
  217.   BitSubString       before(const BitSubString&, int startpos = 0);
  218.   BitSubString       before(const BitPattern&, int startpos = 0);
  219.  
  220.   BitSubString       after(int pos);
  221.   BitSubString       after(const BitString&, int startpos = 0);
  222.   BitSubString       after(const BitSubString&, int startpos = 0);
  223.   BitSubString       after(const BitPattern&, int startpos = 0);
  224.  
  225. // other friends & utilities
  226.  
  227.   friend BitString   common_prefix(const BitString&, const BitString&, 
  228.                                    int pos = 0);
  229.   friend BitString   common_suffix(const BitString&, const BitString&, 
  230.                                    int pos = -1);
  231.   friend BitString   reverse(const BitString&);
  232.  
  233.   void               right_trim(unsigned int bit);
  234.   void               left_trim(unsigned int bit);
  235.  
  236. // status
  237.  
  238.   int                empty() const ;
  239.   int                count(unsigned int bit = 1) const;
  240.   int                length() const;
  241.  
  242. // convertors & IO
  243.  
  244.   friend BitString   atoBitString(const char* s, char f='0', char t='1');
  245.   friend const char* BitStringtoa(const BitString&, char f='0', char t='1');
  246.  
  247.   friend BitString   shorttoBitString(unsigned short);
  248.   friend BitString   longtoBitString(unsigned long);
  249.  
  250.   friend ostream&    operator << (ostream& s, const BitString&);
  251.  
  252. // misc
  253.  
  254.   volatile void      error(const char* msg) const;
  255.  
  256. // indirect friends
  257.  
  258.   friend const char* BitPatterntoa(const BitPattern& p, 
  259.                                   char f='0',char t='1',char x='X');
  260.   friend BitPattern  atoBitPattern(const char* s,
  261.                                   char f='0',char t='1',char x='X');
  262.  
  263.   int                OK() const;
  264. };
  265.  
  266.  
  267. class BitPattern
  268. {
  269. public:
  270.   BitString          pattern;
  271.   BitString          mask;
  272.  
  273.                      BitPattern();
  274.                      BitPattern(const BitPattern&);
  275.                      BitPattern(const BitString& p, const BitString& m);
  276.  
  277.                     ~BitPattern();
  278.  
  279.   friend const char* BitPatterntoa(const BitPattern&, char f, char t, char x);
  280.   friend BitPattern atoBitPattern(const char* s, char f,char t, char x);
  281.   friend ostream&   operator << (ostream& s, const BitPattern&);
  282.  
  283.   int               search(const unsigned short*, int, int) const;
  284.   int               match(const unsigned short* xs, int, int, int) const;
  285.  
  286.   int               OK() const;
  287. };
  288.  
  289. BitString  operator & (const BitString& x, const BitString& y);
  290. BitString  operator | (const BitString& x, const BitString& y);
  291. BitString  operator ^ (const BitString& x, const BitString& y);
  292. BitString  operator << (const BitString& x, int y);
  293. BitString  operator >> (const BitString& x, int y);
  294. BitString  operator - (const BitString& x, const BitString& y);
  295. BitString  operator + (const BitString& x, const BitString& y);
  296. BitString  operator + (const BitString& x, unsigned int y);
  297. BitString  operator ~ (const BitString& x);
  298. int operator != (const BitString& x, const BitString& y);
  299. int operator>(const BitString& x, const BitString& y);
  300. int operator>=(const BitString& x, const BitString& y);
  301.  
  302. extern BitStrRep    _nilBitStrRep;
  303. extern BitString    _nil_BitString;
  304.  
  305. // primitive bit extraction
  306.  
  307. // These must be inlined regardless of optimization.
  308.  
  309. inline int BitStr_index(int l) { return (unsigned)(l) / BITSTRBITS; }
  310.  
  311. inline int BitStr_pos(int l) { return l & (BITSTRBITS - 1); }
  312.  
  313. #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
  314.  
  315. // constructors & assignment
  316.  
  317. inline BitString::BitString() :rep(&_nilBitStrRep) {}
  318.  
  319. inline BitString::BitString(const BitString& x) :rep(BStr_copy(0, x.rep)) {}
  320.  
  321. inline BitString::BitString(const BitSubString& y) 
  322.    :rep (BStr_alloc(0, y.S.rep->s, y.pos, y.pos+y.len, y.len)) {}
  323.  
  324. inline BitString::~BitString()
  325. { 
  326.   if (rep != &_nilBitStrRep) delete rep;
  327. }
  328.  
  329. #if defined(__GNUG__) && !defined(NO_NRV)
  330.  
  331. inline BitString shorttoBitString(unsigned short w) return r
  332. { 
  333.   r.rep = BStr_alloc(0, &w, 0, BITSTRBITS, BITSTRBITS);
  334. }
  335.  
  336. inline BitString longtoBitString(unsigned long w) return r
  337. { 
  338.   unsigned short u[2];
  339.   u[0] = w & ((unsigned short)(~(0)));
  340.   u[1] = w >> BITSTRBITS;
  341.   r.rep = BStr_alloc(0, &u[0], 0, 2*BITSTRBITS, 2*BITSTRBITS);
  342. }
  343.  
  344. #else
  345.  
  346. inline BitString shorttoBitString(unsigned short w) 
  347. { 
  348.   BitString r; r.rep = BStr_alloc(0, &w, 0, BITSTRBITS, BITSTRBITS); return r;
  349. }
  350.  
  351. inline BitString longtoBitString(unsigned long w) 
  352. { 
  353.   BitString r;
  354.   unsigned short u[2];
  355.   u[0] = w & ((unsigned short)(~(0)));
  356.   u[1] = w >> BITSTRBITS;
  357.   r.rep = BStr_alloc(0, &u[0], 0, 2*BITSTRBITS, 2*BITSTRBITS);
  358.   return r;
  359. }
  360.  
  361. #endif
  362.  
  363. inline void BitString::operator =  (const BitString& y)
  364. { 
  365.   rep = BStr_copy(rep, y.rep);
  366. }
  367.  
  368. inline void BitString::operator = (unsigned int b)
  369. { 
  370.   unsigned short bit = b;
  371.   rep = BStr_alloc(rep, &bit, 0, 1, 1);
  372. }
  373.  
  374. inline void BitString::operator=(const BitSubString&  y)
  375. {
  376.   rep = BStr_alloc(rep, y.S.rep->s, y.pos, y.pos+y.len, y.len);
  377. }
  378.  
  379. inline BitSubString::BitSubString(const BitSubString& x) 
  380.     :S(x.S), pos(x.pos), len(x.len) {}
  381.  
  382. inline BitSubString::BitSubString(BitString& x, int p, int l)
  383.      : S(x), pos(p), len(l) {}
  384.  
  385. inline BitSubString::~BitSubString() {}
  386.  
  387. inline BitPattern::BitPattern(const BitString& p, const BitString& m)
  388.     :pattern(p), mask(m) {}
  389.  
  390. inline BitPattern::BitPattern(const BitPattern& b)
  391.     :pattern(b.pattern), mask(b.mask) {}
  392.  
  393. inline BitPattern::BitPattern() {}
  394. inline BitPattern::~BitPattern() {}
  395.  
  396.  
  397. // procedural versions of operators
  398.  
  399. inline void and(const BitString& x, const BitString& y, BitString& r)
  400. {
  401.   r.rep = and(x.rep, y.rep, r.rep);
  402. }
  403.  
  404. inline void or(const BitString& x, const BitString& y, BitString& r)
  405. {
  406.   r.rep = or(x.rep, y.rep, r.rep);
  407. }
  408.  
  409. inline void xor(const BitString& x, const BitString& y, BitString& r)
  410. {
  411.   r.rep = xor(x.rep, y.rep, r.rep);
  412. }
  413.  
  414. inline void diff(const BitString& x, const BitString& y, BitString& r)
  415. {
  416.   r.rep = diff(x.rep, y.rep, r.rep);
  417. }
  418.  
  419. inline void cat(const BitString& x, const BitString& y, BitString& r)
  420. {
  421.   r.rep = cat(x.rep, y.rep, r.rep);
  422. }
  423.  
  424. inline void cat(const BitString& x, unsigned int y, BitString& r)
  425. {
  426.   r.rep = cat(x.rep, y, r.rep);
  427. }
  428.  
  429. inline void rshift(const BitString& x, int y, BitString& r)
  430. {
  431.   r.rep = lshift(x.rep, -y, r.rep);
  432. }
  433.  
  434. inline void lshift(const BitString& x, int y, BitString& r)
  435. {
  436.   r.rep = lshift(x.rep, y, r.rep);
  437. }
  438.  
  439. inline void complement(const BitString& x, BitString& r)
  440. {
  441.   r.rep = cmpl(x.rep, r.rep);
  442. }
  443.  
  444. // operators
  445.  
  446.  
  447. inline void BitString::operator &= (const BitString& y)
  448. {
  449.   and(*this, y, *this);
  450. }
  451.  
  452.  
  453. inline void BitString::operator |= (const BitString& y)
  454. {
  455.   or(*this, y, *this);
  456. }
  457.  
  458. inline void BitString::operator ^= (const BitString& y)
  459. {
  460.   xor(*this, y, *this);
  461. }
  462.  
  463. inline void BitString::operator <<= (int y)
  464. {
  465.   lshift(*this, y, *this);
  466. }
  467.  
  468. inline void BitString::operator >>= (int y)
  469. {
  470.   rshift(*this, y, *this);
  471. }
  472.  
  473. inline void BitString::operator -= (const BitString& y)
  474. {
  475.   diff(*this, y, *this);
  476. }
  477.  
  478. inline void BitString::operator += (const BitString& y)
  479. {
  480.   cat(*this, y, *this);
  481. }
  482.  
  483. inline void BitString::operator += (unsigned int y)
  484. {
  485.   cat(*this, y, *this);
  486. }
  487.  
  488. inline void BitString::complement()
  489. {
  490.   ::complement(*this, *this);
  491. }
  492.  
  493. #if defined(__GNUG__) && !defined(NO_NRV)
  494.  
  495. inline BitString  operator & (const BitString& x, const BitString& y) return r
  496. {
  497.   and(x, y, r);
  498. }
  499.  
  500. inline BitString  operator | (const BitString& x, const BitString& y) return r
  501. {
  502.   or(x, y, r);
  503. }
  504.  
  505. inline BitString  operator ^ (const BitString& x, const BitString& y) return r
  506. {
  507.   xor(x, y, r);
  508. }
  509.  
  510. inline BitString  operator << (const BitString& x, int y) return r
  511. {
  512.   lshift(x, y, r);
  513. }
  514.  
  515. inline BitString  operator >> (const BitString& x, int y) return r
  516. {
  517.   rshift(x, y, r);
  518. }
  519.  
  520. inline BitString  operator - (const BitString& x, const BitString& y) return r
  521. {
  522.   diff(x, y, r);
  523. }
  524.  
  525. inline BitString  operator + (const BitString& x, const BitString& y) return r
  526. {
  527.   cat(x, y, r);
  528. }
  529.  
  530. inline BitString  operator + (const BitString& x, unsigned int y) return r
  531. {
  532.   cat(x, y, r);
  533. }
  534.  
  535. inline BitString  operator ~ (const BitString& x) return r
  536. {
  537.   complement(x, r);
  538. }
  539.  
  540. #else /* NO_NRV */
  541.  
  542. inline BitString  operator & (const BitString& x, const BitString& y) 
  543. {
  544.   BitString r; and(x, y, r); return r;
  545. }
  546.  
  547. inline BitString  operator | (const BitString& x, const BitString& y) 
  548. {
  549.   BitString r; or(x, y, r); return r;
  550. }
  551.  
  552. inline BitString  operator ^ (const BitString& x, const BitString& y) 
  553. {
  554.   BitString r; xor(x, y, r); return r;
  555. }
  556.  
  557. inline BitString  operator << (const BitString& x, int y) 
  558. {
  559.   BitString r; lshift(x, y, r); return r;
  560. }
  561.  
  562. inline BitString  operator >> (const BitString& x, int y) 
  563. {
  564.   BitString r; rshift(x, y, r); return r;
  565. }
  566.  
  567. inline BitString  operator - (const BitString& x, const BitString& y) 
  568. {
  569.   BitString r; diff(x, y, r); return r;
  570. }
  571.  
  572. inline BitString  operator + (const BitString& x, const BitString& y) 
  573. {
  574.   BitString r; cat(x, y, r); return r;
  575. }
  576.  
  577. inline BitString  operator + (const BitString& x, unsigned int y) 
  578. {
  579.   BitString r; cat(x, y, r); return r;
  580. }
  581.  
  582. inline BitString  operator ~ (const BitString& x) 
  583. {
  584.   BitString r; complement(x, r); return r;
  585. }
  586.  
  587. #endif
  588.  
  589. // status, matching
  590.  
  591. inline int BitString::length() const
  592. { 
  593.   return rep->len;
  594. }
  595.  
  596. inline int BitString::empty() const
  597. { 
  598.   return rep->len == 0;
  599. }
  600.  
  601. inline int BitString::index(const BitString& y, int startpos) const
  602. {   
  603.   return search(startpos, rep->len, y.rep->s, 0, y.rep->len);
  604. }
  605.  
  606. inline int BitString::index(const BitSubString& y, int startpos) const
  607. {   
  608.   return search(startpos, rep->len, y.S.rep->s, y.pos, y.pos+y.len);
  609. }
  610.  
  611. inline int BitString::contains(const BitString& y) const
  612. {   
  613.   return search(0, rep->len, y.rep->s, 0, y.rep->len) >= 0;
  614. }
  615.  
  616. inline int BitString::contains(const BitSubString& y) const
  617. {   
  618.   return search(0, rep->len, y.S.rep->s, y.pos, y.pos+y.len) >= 0;
  619. }
  620.  
  621. inline int BitString::contains(const BitString& y, int p) const
  622. {
  623.   return match(p, rep->len, 0, y.rep->s, 0, y.rep->len);
  624. }
  625.  
  626. inline int BitString::matches(const BitString& y, int p) const
  627. {
  628.   return match(p, rep->len, 1, y.rep->s, 0, y.rep->len);
  629. }
  630.  
  631. inline int BitString::contains(const BitSubString& y, int p) const
  632. {
  633.   return match(p, rep->len, 0, y.S.rep->s, y.pos, y.pos+y.len);
  634. }
  635.  
  636. inline int BitString::matches(const BitSubString& y, int p) const
  637. {
  638.   return match(p, rep->len, 1, y.S.rep->s, y.pos, y.pos+y.len);
  639. }
  640.  
  641. inline int BitString::contains(const BitPattern& r) const
  642. {
  643.   return r.search(rep->s, 0, rep->len) >= 0;
  644. }
  645.  
  646. inline int BitString::contains(const BitPattern& r, int p) const
  647. {
  648.   return r.match(rep->s, p, rep->len, 0);
  649. }
  650.  
  651. inline int BitString::matches(const BitPattern& r, int p) const
  652. {
  653.   return r.match(rep->s, p, rep->len, 1);
  654. }
  655.  
  656. inline int BitString::index(const BitPattern& r, int startpos) const
  657. {
  658.   return r.search(rep->s, startpos, rep->len);
  659. }
  660.  
  661. inline  int BitSubString::length() const
  662. { 
  663.   return len;
  664. }
  665.  
  666. inline  int BitSubString::empty() const
  667. { 
  668.   return len == 0;
  669. }
  670.  
  671. inline int operator != (const BitString& x, const BitString& y)
  672. {
  673.   return !(x == y);
  674. }
  675.  
  676. inline int operator>(const BitString& x, const BitString& y)
  677. {
  678.   return y < x;
  679. }
  680.  
  681. inline int operator>=(const BitString& x, const BitString& y)
  682. {
  683.   return y <= x;
  684. }
  685.  
  686. inline int BitString::first(unsigned int b) const
  687. {
  688.   return next(-1, b);
  689. }
  690.  
  691. inline int BitString::last(unsigned int b) const
  692. {
  693.   return previous(rep->len, b);
  694. }
  695.  
  696. inline int BitString::index(unsigned int bit, int startpos) const
  697. {
  698.   if (startpos >= 0)
  699.     return next(startpos - 1, bit);
  700.   else
  701.     return previous(rep->len + startpos + 1, bit);
  702. }
  703.  
  704. inline void BitString::right_trim(unsigned int b) 
  705. {
  706.   int nb = (b == 0)? 1 : 0;
  707.   rep = BStr_resize(rep, previous(rep->len, nb) + 1);
  708. }
  709.  
  710. inline void BitString::left_trim(unsigned int b)
  711. {
  712.   int nb = (b == 0)? 1 : 0;
  713.   int p = next(-1, nb);
  714.   rep = BStr_alloc(rep, rep->s, p, rep->len, rep->len - p);
  715. }
  716.  
  717. inline int BitString::test(int i) const
  718. {
  719.   return ((unsigned)(i) >= rep->len)? 0 : 
  720.          ((rep->s[BitStr_index(i)] & (1 << (BitStr_pos(i)))) != 0);
  721. }
  722.  
  723.  
  724. // subscripting
  725.  
  726. inline BitStrBit::BitStrBit(const BitStrBit& b) :src(b.src), pos(b.pos) {}
  727.  
  728. inline BitStrBit::BitStrBit(BitString& v, int p) :src(v), pos(p) {}
  729.  
  730. inline BitStrBit::~BitStrBit() {}
  731.  
  732. inline BitStrBit::operator unsigned int() const
  733. {
  734.   return src.test(pos);
  735. }
  736.  
  737. inline int BitStrBit::operator = (unsigned int b)
  738. {
  739.   src.assign(pos, b); return b;
  740. }
  741.  
  742. inline int BitStrBit::operator == (unsigned int b) const
  743. {
  744.   return src.test(pos) == b;
  745. }
  746.  
  747. inline int BitStrBit::operator != (unsigned int b) const
  748. {
  749.   return src.test(pos) != b;
  750. }
  751.  
  752. inline BitStrBit BitString::operator [] (int i)
  753. {
  754.   if ((unsigned)(i) >= rep->len) error("illegal bit index");
  755.   return BitStrBit(*this, i);
  756. }
  757.  
  758. inline BitSubString BitString::_substr(int first, int l)
  759. {
  760.   if (first < 0 || l <= 0 || (unsigned)(first + l) > rep->len)
  761.     return BitSubString(_nil_BitString, 0, 0) ;
  762.   else 
  763.     return BitSubString(*this, first, l);
  764. }
  765.  
  766. #endif
  767.  
  768. #endif
  769.