gnu/lib/libg++/g++-include/BitString.h

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