home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / g__inc / xstring.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-23  |  35.7 KB  |  1,337 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. #if defined(SHORT_NAMES) || defined(VMS)
  20. #define re_compile_pattern    recmppat
  21. #define re_pattern_buffer    repatbuf
  22. #define re_registers        reregs
  23. #endif
  24.  
  25. #ifndef _String_h
  26. #ifdef __GNUG__
  27. #pragma once
  28. #pragma interface
  29. #endif
  30. #define _String_h 1
  31.  
  32. #include <stream.h>
  33. #include <xregex.h>
  34.  
  35. struct StrRep                     // internal String representations
  36. {
  37.   unsigned short    len;         // string length 
  38.   unsigned short    sz;          // allocated space
  39.   char              s[1];        // the string starts here 
  40.                                  // (at least 1 char for trailing null)
  41.                                  // allocated & expanded via non-public fcts
  42. };
  43.  
  44. // primitive ops on StrReps -- nearly all String fns go through these.
  45.  
  46. StrRep*     Salloc(StrRep*, const char*, int, int);
  47. StrRep*     Scopy(StrRep*, StrRep*);
  48. StrRep*     Sresize(StrRep*, int);
  49. StrRep*     Scat(StrRep*, const char*, int, const char*, int);
  50. StrRep*     Scat(StrRep*, const char*, int,const char*,int, const char*,int);
  51. StrRep*     Sprepend(StrRep*, const char*, int);
  52. StrRep*     Sreverse(StrRep*, StrRep*);
  53. StrRep*     Supcase(StrRep*, StrRep*);
  54. StrRep*     Sdowncase(StrRep*, StrRep*);
  55. StrRep*     Scapitalize(StrRep*, StrRep*);
  56.  
  57. // These classes need to be defined in the order given
  58.  
  59. class String;
  60. class SubString;
  61.  
  62. class SubString
  63. {
  64.   friend class      String;
  65. protected:
  66.  
  67.   String&           S;        // The String I'm a substring of
  68.   unsigned short    pos;      // starting position in S's rep
  69.   unsigned short    len;      // length of substring
  70.  
  71.   void              assign(StrRep*, const char*, int = -1);
  72.                     SubString(String& x, int p, int l);
  73.                     SubString(const SubString& x);
  74.  
  75. public:
  76.  
  77. // Note there are no public constructors. SubStrings are always
  78. // created via String operations
  79.  
  80.                    ~SubString();
  81.  
  82.   void              operator =  (const String&     y);
  83.   void              operator =  (const SubString&  y);
  84.   void              operator =  (const char* t);
  85.   void              operator =  (char        c);
  86.  
  87. // return 1 if target appears anywhere in SubString; else 0
  88.  
  89.   int               contains(char        c) const;
  90.   int               contains(const String&     y) const;
  91.   int               contains(const SubString&  y) const;
  92.   int               contains(const char* t) const;
  93.   int               contains(const Regex&       r) const;
  94.  
  95. // return 1 if target matches entire SubString
  96.  
  97.   int               matches(const Regex&  r) const;
  98.  
  99. // IO 
  100.  
  101.   friend ostream&   operator<<(ostream& s, const SubString& x);
  102.  
  103. // status
  104.  
  105.   int               length() const;
  106.   int               empty() const;
  107.   const char*       chars() const;
  108.  
  109.   int               OK() const; 
  110.  
  111. };
  112.  
  113.  
  114. class String
  115. {
  116.   friend class      SubString;
  117.  
  118. protected:
  119.   StrRep*           rep;   // Strings are pointers to their representations
  120.  
  121. // some helper functions
  122.  
  123.   int               search(int, int, const char*, int = -1) const;
  124.   int               search(int, int, char) const;
  125.   int               match(int, int, int, const char*, int = -1) const;
  126.   int               _gsub(const char*, int, const char* ,int);
  127.   int               _gsub(const Regex&, const char*, int);
  128.   SubString         _substr(int, int);
  129.  
  130. public:
  131.  
  132. // constructors & assignment
  133.  
  134.                     String();
  135.                     String(const String& x);
  136.                     String(const SubString&  x);
  137.                     String(const char* t);
  138.                     String(const char* t, int len);
  139.                     String(char c);
  140.  
  141.                     ~String();
  142.  
  143.   void              operator =  (const String&     y);
  144.   void              operator =  (const char* y);
  145.   void              operator =  (char        c);
  146.   void              operator =  (const SubString&  y);
  147.  
  148. // concatenation
  149.  
  150.   void              operator += (const String&     y); 
  151.   void              operator += (const SubString&  y);
  152.   void              operator += (const char* t);
  153.   void              operator += (char        c);
  154.  
  155.   void              prepend(const String&     y); 
  156.   void              prepend(const SubString&  y);
  157.   void              prepend(const char* t);
  158.   void              prepend(char        c);
  159.  
  160.  
  161. // procedural versions:
  162. // concatenate first 2 args, store result in last arg
  163.  
  164.   friend void     cat(const String&, const String&, String&);
  165.   friend void     cat(const String&, const SubString&, String&);
  166.   friend void     cat(const String&, const char*, String&);
  167.   friend void     cat(const String&, char, String&);
  168.  
  169.   friend void     cat(const SubString&, const String&, String&);
  170.   friend void     cat(const SubString&, const SubString&, String&);
  171.   friend void     cat(const SubString&, const char*, String&);
  172.   friend void     cat(const SubString&, char, String&);
  173.  
  174.   friend void     cat(const char*, const String&, String&);
  175.   friend void     cat(const char*, const SubString&, String&);
  176.   friend void     cat(const char*, const char*, String&);
  177.   friend void     cat(const char*, char, String&);
  178.  
  179. // double concatenation, by request. (yes, there are too many versions, 
  180. // but if one is supported, then the others should be too...)
  181. // Concatenate first 3 args, store in last arg
  182.  
  183.   friend void     cat(const String&,const String&, const String&,String&);
  184.   friend void     cat(const String&,const String&,const SubString&,String&);
  185.   friend void     cat(const String&,const String&, const char*, String&);
  186.   friend void     cat(const String&,const String&, char, String&);
  187.   friend void     cat(const String&,const SubString&,const String&,String&);
  188.   friend void     cat(const String&,const SubString&,const SubString&,String&);
  189.   friend void     cat(const String&,const SubString&, const char*, String&);
  190.   friend void     cat(const String&,const SubString&, char, String&);
  191.   friend void     cat(const String&,const char*, const String&,    String&);
  192.   friend void     cat(const String&,const char*, const SubString&, String&);
  193.   friend void     cat(const String&,const char*, const char*, String&);
  194.   friend void     cat(const String&,const char*, char, String&);
  195.  
  196.   friend void     cat(const char*, const String&, const String&,String&);
  197.   friend void     cat(const char*,const String&,const SubString&,String&);
  198.   friend void     cat(const char*,const String&, const char*, String&);
  199.   friend void     cat(const char*,const String&, char, String&);
  200.   friend void     cat(const char*,const SubString&,const String&,String&);
  201.   friend void     cat(const char*,const SubString&,const SubString&,String&);
  202.   friend void     cat(const char*,const SubString&, const char*, String&);
  203.   friend void     cat(const char*,const SubString&, char, String&);
  204.   friend void     cat(const char*,const char*, const String&,    String&);
  205.   friend void     cat(const char*,const char*, const SubString&, String&);
  206.   friend void     cat(const char*,const char*, const char*, String&);
  207.   friend void     cat(const char*,const char*, char, String&);
  208.  
  209.  
  210. // searching & matching
  211.  
  212. // return position of target in string or -1 for failure
  213.  
  214.   int               index(char        c, int startpos = 0) const;      
  215.   int               index(const String&     y, int startpos = 0) const;      
  216.   int               index(const SubString&  y, int startpos = 0) const;      
  217.   int               index(const char* t, int startpos = 0) const;  
  218.   int               index(const Regex&      r, int startpos = 0) const;       
  219.  
  220. // return 1 if target appears anyhere in String; else 0
  221.  
  222.   int               contains(char        c) const;
  223.   int               contains(const String&     y) const;
  224.   int               contains(const SubString&  y) const;
  225.   int               contains(const char* t) const;
  226.   int               contains(const Regex&      r) const;
  227.  
  228. // return 1 if target appears anywhere after position pos 
  229. // (or before, if pos is negative) in String; else 0
  230.  
  231.   int               contains(char        c, int pos) const;
  232.   int               contains(const String&     y, int pos) const;
  233.   int               contains(const SubString&  y, int pos) const;
  234.   int               contains(const char* t, int pos) const;
  235.   int               contains(const Regex&      r, int pos) const;
  236.  
  237. // return 1 if target appears at position pos in String; else 0
  238.  
  239.   int               matches(char        c, int pos = 0) const;
  240.   int               matches(const String&     y, int pos = 0) const;
  241.   int               matches(const SubString&  y, int pos = 0) const;
  242.   int               matches(const char* t, int pos = 0) const;
  243.   int               matches(const Regex&      r, int pos = 0) const;
  244.  
  245. //  return number of occurences of target in String
  246.  
  247.   int               freq(char        c) const; 
  248.   int               freq(const String&     y) const;
  249.   int               freq(const SubString&  y) const;
  250.   int               freq(const char* t) const;
  251.  
  252. // SubString extraction
  253.  
  254. // Note that you can't take a substring of a const String, since
  255. // this leaves open the possiblility of indirectly modifying the
  256. // String through the SubString
  257.  
  258.   SubString         at(int         pos, int len);
  259.   SubString         operator () (int         pos, int len); // synonym for at
  260.  
  261.   SubString         at(const String&     x, int startpos = 0); 
  262.   SubString         at(const SubString&  x, int startpos = 0); 
  263.   SubString         at(const char* t, int startpos = 0);
  264.   SubString         at(char        c, int startpos = 0);
  265.   SubString         at(const Regex&      r, int startpos = 0); 
  266.  
  267.   SubString         before(int          pos);
  268.   SubString         before(const String&      x, int startpos = 0);
  269.   SubString         before(const SubString&   x, int startpos = 0);
  270.   SubString         before(const char*  t, int startpos = 0);
  271.   SubString         before(char         c, int startpos = 0);
  272.   SubString         before(const Regex&       r, int startpos = 0);
  273.  
  274.   SubString         through(int          pos);
  275.   SubString         through(const String&      x, int startpos = 0);
  276.   SubString         through(const SubString&   x, int startpos = 0);
  277.   SubString         through(const char*  t, int startpos = 0);
  278.   SubString         through(char         c, int startpos = 0);
  279.   SubString         through(const Regex&       r, int startpos = 0);
  280.  
  281.   SubString         from(int          pos);
  282.   SubString         from(const String&      x, int startpos = 0);
  283.   SubString         from(const SubString&   x, int startpos = 0);
  284.   SubString         from(const char*  t, int startpos = 0);
  285.   SubString         from(char         c, int startpos = 0);
  286.   SubString         from(const Regex&       r, int startpos = 0);
  287.  
  288.   SubString         after(int         pos);
  289.   SubString         after(const String&     x, int startpos = 0);
  290.   SubString         after(const SubString&  x, int startpos = 0);
  291.   SubString         after(const char* t, int startpos = 0);
  292.   SubString         after(char        c, int startpos = 0);
  293.   SubString         after(const Regex&      r, int startpos = 0);
  294.  
  295.  
  296. // deletion
  297.  
  298. // delete len chars starting at pos
  299.   void              del(int         pos, int len);
  300.  
  301. // delete the first occurrence of target after startpos
  302.  
  303.   void              del(const String&     y, int startpos = 0);
  304.   void              del(const SubString&  y, int startpos = 0);
  305.   void              del(const char* t, int startpos = 0);
  306.   void              del(char        c, int startpos = 0);
  307.   void              del(const Regex&      r, int startpos = 0);
  308.  
  309. // global substitution: substitute all occurrences of pat with repl
  310.  
  311.   int               gsub(const String&     pat, const String&     repl);
  312.   int               gsub(const SubString&  pat, const String&     repl);
  313.   int               gsub(const char* pat, const String&     repl);
  314.   int               gsub(const char* pat, const char* repl);
  315.   int               gsub(const Regex&      pat, const String&     repl);
  316.  
  317. // friends & utilities
  318.  
  319. // split string into array res at separators; return number of elements
  320.  
  321.   friend int        split(const String& x, String res[], int maxn, 
  322.                           const String& sep);
  323.   friend int        split(const String& x, String res[], int maxn, 
  324.                           const Regex&  sep);
  325.  
  326.   friend String     common_prefix(const String& x, const String& y, 
  327.                                   int startpos = 0);
  328.   friend String     common_suffix(const String& x, const String& y, 
  329.                                   int startpos = -1);
  330.   friend String     replicate(char        c, int n);
  331.   friend String     replicate(const String&     y, int n);
  332.   friend String     join(String src[], int n, const String& sep);
  333.  
  334. // simple builtin transformations
  335.  
  336.   friend String     reverse(const String& x);
  337.   friend String     upcase(const String& x);
  338.   friend String     downcase(const String& x);
  339.   friend String     capitalize(const String& x);
  340.  
  341. // in-place versions of above
  342.  
  343.   void              reverse();
  344.   void              upcase();
  345.   void              downcase();
  346.   void              capitalize();
  347.  
  348. // element extraction
  349.  
  350.   char&             operator [] (int i);
  351.   char              elem(int i) const;
  352.   char              firstchar() const;
  353.   char              lastchar() const;
  354.  
  355. // conversion
  356.  
  357.                     operator const char*() const;
  358.   const char*       chars() const;
  359.  
  360.  
  361. // IO
  362.  
  363.   friend ostream&   operator<<(ostream& s, const String& x);
  364.   friend ostream&   operator<<(ostream& s, const SubString& x);
  365.   friend istream&   operator>>(istream& s, String& x);
  366.  
  367.   friend int        readline(istream& s, String& x, 
  368.                              char terminator = '\n',
  369.                              int discard_terminator = 1);
  370.  
  371. // status
  372.  
  373.   int               length() const;
  374.   int               empty() const;
  375.  
  376. // preallocate some space for String
  377.   void              alloc(int newsize);
  378.  
  379. // report current allocation (not length!)
  380.  
  381.   int               allocation() const;
  382.  
  383.  
  384.   volatile void     error(const char* msg) const;
  385.  
  386.   int               OK() const;
  387. };
  388.  
  389. typedef String StrTmp; // for backward compatibility
  390.  
  391. // other externs
  392.  
  393. int        compare(const String&    x, const String&     y);
  394. int        compare(const String&    x, const SubString&  y);
  395. int        compare(const String&    x, const char* y);
  396. int        compare(const SubString& x, const String&     y);
  397. int        compare(const SubString& x, const SubString&  y);
  398. int        compare(const SubString& x, const char* y);
  399. int        fcompare(const String&   x, const String&     y); // ignore case
  400.  
  401. extern StrRep  _nilStrRep;
  402. extern String _nilString;
  403.  
  404. // other inlines
  405.  
  406. String operator + (const String& x, const String& y);
  407. String operator + (const String& x, const SubString& y);
  408. String operator + (const String& x, const char* y);
  409. String operator + (const String& x, char y);
  410. String operator + (const SubString& x, const String& y);
  411. String operator + (const SubString& x, const SubString& y);
  412. String operator + (const SubString& x, const char* y);
  413. String operator + (const SubString& x, char y);
  414. String operator + (const char* x, const String& y);
  415. String operator + (const char* x, const SubString& y);
  416.  
  417. int operator==(const String& x, const String& y); 
  418. int operator!=(const String& x, const String& y);
  419. int operator> (const String& x, const String& y);
  420. int operator>=(const String& x, const String& y);
  421. int operator< (const String& x, const String& y);
  422. int operator<=(const String& x, const String& y);
  423. int operator==(const String& x, const SubString&  y);
  424. int operator!=(const String& x, const SubString&  y);
  425. int operator> (const String& x, const SubString&  y);
  426. int operator>=(const String& x, const SubString&  y);
  427. int operator< (const String& x, const SubString&  y);
  428. int operator<=(const String& x, const SubString&  y);
  429. int operator==(const String& x, const char* t);
  430. int operator!=(const String& x, const char* t);
  431. int operator> (const String& x, const char* t);
  432. int operator>=(const String& x, const char* t);
  433. int operator< (const String& x, const char* t);
  434. int operator<=(const String& x, const char* t);
  435. int operator==(const SubString& x, const String& y);
  436. int operator!=(const SubString& x, const String& y);
  437. int operator> (const SubString& x, const String& y);
  438. int operator>=(const SubString& x, const String& y);
  439. int operator< (const SubString& x, const String& y);
  440. int operator<=(const SubString& x, const String& y);
  441. int operator==(const SubString& x, const SubString&  y);
  442. int operator!=(const SubString& x, const SubString&  y);
  443. int operator> (const SubString& x, const SubString&  y);
  444. int operator>=(const SubString& x, const SubString&  y);
  445. int operator< (const SubString& x, const SubString&  y);
  446. int operator<=(const SubString& x, const SubString&  y);
  447. int operator==(const SubString& x, const char* t);
  448. int operator!=(const SubString& x, const char* t);
  449. int operator> (const SubString& x, const char* t);
  450. int operator>=(const SubString& x, const char* t);
  451. int operator< (const SubString& x, const char* t);
  452. int operator<=(const SubString& x, const char* t);
  453.  
  454. #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
  455.  
  456.  
  457. // status reports, needed before defining other things
  458.  
  459. inline int         String::length() const {  return rep->len; }
  460. inline int         String::empty() const { return rep->len == 0; }
  461. inline const char* String::chars() const { return &(rep->s[0]); }
  462. inline int         String::allocation() const { return rep->sz; }
  463. inline void        String::alloc(int newsize) { rep = Sresize(rep, newsize); }
  464.  
  465. inline int         SubString::length() const { return len; }
  466. inline int         SubString::empty() const { return len == 0; }
  467. inline const char* SubString::chars() const { return &(S.rep->s[pos]); }
  468.  
  469.  
  470. // constructors
  471.  
  472. inline String::String() 
  473.   : rep(&_nilStrRep) {}
  474. inline String::String(const String& x) 
  475.   : rep(Scopy(0, x.rep)) {}
  476. inline String::String(const char* t) 
  477.   : rep(Salloc(0, t, -1, -1)) {}
  478. inline String::String(const char* t, int tlen)
  479.   : rep(Salloc(0, t, tlen, tlen)) {}
  480. inline String::String(const SubString& y)
  481.   : rep(Salloc(0, y.chars(), y.length(), y.length())) {}
  482. inline String::String(char c) 
  483.   : rep(Salloc(0, &c, 1, 1)) {}
  484.  
  485. inline String::~String() { if (rep != &_nilStrRep) delete rep; }
  486.  
  487. inline SubString::SubString(const SubString& x)
  488.   :S(x.S), pos(x.pos), len(x.len) {}
  489. inline SubString::SubString(String& x, int first, int l)
  490.   :S(x), pos(first), len(l) {}
  491.  
  492. inline SubString::~SubString() {}
  493.  
  494. // assignment
  495.  
  496. inline void String::operator =  (const String& y)
  497. { 
  498.   rep = Scopy(rep, y.rep);
  499. }
  500.  
  501. inline void String::operator=(const char* t)
  502. {
  503.   rep = Salloc(rep, t, -1, -1); 
  504. }
  505.  
  506. inline void String::operator=(const SubString&  y)
  507. {
  508.   rep = Salloc(rep, y.chars(), y.length(), y.length());
  509. }
  510.  
  511. inline void String::operator=(char c)
  512. {
  513.   rep = Salloc(rep, &c, 1, 1); 
  514. }
  515.  
  516.  
  517. inline void SubString::operator = (const char* ys)
  518. {
  519.   assign(0, ys);
  520. }
  521.  
  522. inline void SubString::operator = (char ch)
  523. {
  524.   assign(0, &ch, 1);
  525. }
  526.  
  527. inline void SubString::operator = (const String& y)
  528. {
  529.   assign(y.rep, y.chars(), y.length());
  530. }
  531.  
  532. inline void SubString::operator = (const SubString& y)
  533. {
  534.   assign(y.S.rep, y.chars(), y.length());
  535. }
  536.  
  537. // Zillions of cats...
  538.  
  539. inline void cat(const String& x, const String& y, String& r)
  540. {
  541.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  542. }
  543.  
  544. inline void cat(const String& x, const SubString& y, String& r)
  545. {
  546.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  547. }
  548.  
  549. inline void cat(const String& x, const char* y, String& r)
  550. {
  551.   r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
  552. }
  553.  
  554. inline void cat(const String& x, char y, String& r)
  555. {
  556.   r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
  557. }
  558.  
  559. inline void cat(const SubString& x, const String& y, String& r)
  560. {
  561.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  562. }
  563.  
  564. inline void cat(const SubString& x, const SubString& y, String& r)
  565. {
  566.   r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
  567. }
  568.  
  569. inline void cat(const SubString& x, const char* y, String& r)
  570. {
  571.   r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
  572. }
  573.  
  574. inline void cat(const SubString& x, char y, String& r)
  575. {
  576.   r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
  577. }
  578.  
  579. inline void cat(const char* x, const String& y, String& r)
  580. {
  581.   r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
  582. }
  583.  
  584. inline void cat(const char* x, const SubString& y, String& r)
  585. {
  586.   r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
  587. }
  588.  
  589. inline void cat(const char* x, const char* y, String& r)
  590. {
  591.   r.rep = Scat(r.rep, x, -1, y, -1);
  592. }
  593.  
  594. inline void cat(const char* x, char y, String& r)
  595. {
  596.   r.rep = Scat(r.rep, x, -1, &y, 1);
  597. }
  598.  
  599. inline void cat(const String& a, const String& x, const String& y, String& r)
  600. {
  601.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  602. }
  603.  
  604. inline void cat(const String& a, const String& x, const SubString& y, String& r)
  605. {
  606.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  607. }
  608.  
  609. inline void cat(const String& a, const String& x, const char* y, String& r)
  610. {
  611.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
  612. }
  613.  
  614. inline void cat(const String& a, const String& x, char y, String& r)
  615. {
  616.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
  617. }
  618.  
  619. inline void cat(const String& a, const SubString& x, const String& y, String& r)
  620. {
  621.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  622. }
  623.  
  624. inline void cat(const String& a, const SubString& x, const SubString& y, String& r)
  625. {
  626.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
  627. }
  628.  
  629. inline void cat(const String& a, const SubString& x, const char* y, String& r)
  630. {
  631.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
  632. }
  633.  
  634. inline void cat(const String& a, const SubString& x, char y, String& r)
  635. {
  636.   r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
  637. }
  638.  
  639. inline void cat(const String& a, const char* x, const String& y, String& r)
  640. {
  641.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
  642. }
  643.  
  644. inline void cat(const String& a, const char* x, const SubString& y, String& r)
  645. {
  646.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
  647. }
  648.  
  649. inline void cat(const String& a, const char* x, const char* y, String& r)
  650. {
  651.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y, -1);
  652. }
  653.  
  654. inline void cat(const String& a, const char* x, char y, String& r)
  655. {
  656.   r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, &y, 1);
  657. }
  658.  
  659.  
  660. inline void cat(const char* a, const String& x, const String& y, String& r)
  661. {
  662.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  663. }
  664.  
  665. inline void cat(const char* a, const String& x, const SubString& y, String& r)
  666. {
  667.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  668. }
  669.  
  670. inline void cat(const char* a, const String& x, const char* y, String& r)
  671. {
  672.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
  673. }
  674.  
  675. inline void cat(const char* a, const String& x, char y, String& r)
  676. {
  677.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
  678. }
  679.  
  680. inline void cat(const char* a, const SubString& x, const String& y, String& r)
  681. {
  682.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  683. }
  684.  
  685. inline void cat(const char* a, const SubString& x, const SubString& y, String& r)
  686. {
  687.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
  688. }
  689.  
  690. inline void cat(const char* a, const SubString& x, const char* y, String& r)
  691. {
  692.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
  693. }
  694.  
  695. inline void cat(const char* a, const SubString& x, char y, String& r)
  696. {
  697.   r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
  698. }
  699.  
  700. inline void cat(const char* a, const char* x, const String& y, String& r)
  701. {
  702.   r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
  703. }
  704.  
  705. inline void cat(const char* a, const char* x, const SubString& y, String& r)
  706. {
  707.   r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
  708. }
  709.  
  710. inline void cat(const char* a, const char* x, const char* y, String& r)
  711. {
  712.   r.rep = Scat(r.rep, a, -1, x, -1, y, -1);
  713. }
  714.  
  715. inline void cat(const char* a, const char* x, char y, String& r)
  716. {
  717.   r.rep = Scat(r.rep, a, -1, x, -1, &y, 1);
  718. }
  719.  
  720.  
  721. // operator versions
  722.  
  723. inline void String::operator +=(const String& y)
  724. {
  725.   cat(*this, y, *this);
  726. }
  727.  
  728. inline void String::operator +=(const SubString& y)
  729. {
  730.   cat(*this, y, *this);
  731. }
  732.  
  733. inline void String::operator += (const char* y)
  734. {
  735.   cat(*this, y, *this);
  736. }
  737.  
  738. inline void String:: operator +=(char y)
  739. {
  740.   cat(*this, y, *this);
  741. }
  742.  
  743. // constructive concatenation
  744.  
  745. #if defined(__GNUG__) && !defined(NO_NRV)
  746.  
  747. inline String operator + (const String& x, const String& y) return r;
  748. {
  749.   cat(x, y, r);
  750. }
  751.  
  752. inline String operator + (const String& x, const SubString& y) return r;
  753. {
  754.   cat(x, y, r);
  755. }
  756.  
  757. inline String operator + (const String& x, const char* y) return r;
  758. {
  759.   cat(x, y, r);
  760. }
  761.  
  762. inline String operator + (const String& x, char y) return r;
  763. {
  764.   cat(x, y, r);
  765. }
  766.  
  767. inline String operator + (const SubString& x, const String& y) return r;
  768. {
  769.   cat(x, y, r);
  770. }
  771.  
  772. inline String operator + (const SubString& x, const SubString& y) return r;
  773. {
  774.   cat(x, y, r);
  775. }
  776.  
  777. inline String operator + (const SubString& x, const char* y) return r;
  778. {
  779.   cat(x, y, r);
  780. }
  781.  
  782. inline String operator + (const SubString& x, char y) return r;
  783. {
  784.   cat(x, y, r);
  785. }
  786.  
  787. inline String operator + (const char* x, const String& y) return r;
  788. {
  789.   cat(x, y, r);
  790. }
  791.  
  792. inline String operator + (const char* x, const SubString& y) return r;
  793. {
  794.   cat(x, y, r);
  795. }
  796.  
  797. inline String reverse(const String& x) return r;
  798. {
  799.   r.rep = Sreverse(x.rep, r.rep);
  800. }
  801.  
  802. inline String upcase(const String& x) return r;
  803. {
  804.   r.rep = Supcase(x.rep, r.rep);
  805. }
  806.  
  807. inline String downcase(const String& x) return r;
  808. {
  809.   r.rep = Sdowncase(x.rep, r.rep);
  810. }
  811.  
  812. inline String capitalize(const String& x) return r;
  813. {
  814.   r.rep = Scapitalize(x.rep, r.rep);
  815. }
  816.  
  817. #else /* NO_NRV */
  818.  
  819. inline String operator + (const String& x, const String& y)
  820. {
  821.   String r;  cat(x, y, r);  return r;
  822. }
  823.  
  824. inline String operator + (const String& x, const SubString& y) 
  825. {
  826.   String r; cat(x, y, r); return r;
  827. }
  828.  
  829. inline String operator + (const String& x, const char* y) 
  830. {
  831.   String r; cat(x, y, r); return r;
  832. }
  833.  
  834. inline String operator + (const String& x, char y) 
  835. {
  836.   String r; cat(x, y, r); return r;
  837. }
  838.  
  839. inline String operator + (const SubString& x, const String& y) 
  840. {
  841.   String r; cat(x, y, r); return r;
  842. }
  843.  
  844. inline String operator + (const SubString& x, const SubString& y) 
  845. {
  846.   String r; cat(x, y, r); return r;
  847. }
  848.  
  849. inline String operator + (const SubString& x, const char* y) 
  850. {
  851.   String r; cat(x, y, r); return r;
  852. }
  853.  
  854. inline String operator + (const SubString& x, char y) 
  855. {
  856.   String r; cat(x, y, r); return r;
  857. }
  858.  
  859. inline String operator + (const char* x, const String& y) 
  860. {
  861.   String r; cat(x, y, r); return r;
  862. }
  863.  
  864. inline String operator + (const char* x, const SubString& y) 
  865. {
  866.   String r; cat(x, y, r); return r;
  867. }
  868.  
  869. inline String reverse(const String& x) 
  870. {
  871.   String r; r.rep = Sreverse(x.rep, r.rep); return r;
  872. }
  873.  
  874. inline String upcase(const String& x) 
  875. {
  876.   String r; r.rep = Supcase(x.rep, r.rep); return r;
  877. }
  878.  
  879. inline String downcase(const String& x) 
  880. {
  881.   String r; r.rep = Sdowncase(x.rep, r.rep); return r;
  882. }
  883.  
  884. inline String capitalize(const String& x) 
  885. {
  886.   String r; r.rep = Scapitalize(x.rep, r.rep); return r;
  887. }
  888.  
  889. #endif
  890.  
  891. // prepend
  892.  
  893. inline void String::prepend(const String& y)
  894. {
  895.   rep = Sprepend(rep, y.chars(), y.length());
  896. }
  897.  
  898. inline void String::prepend(const char* y)
  899. {
  900.   rep = Sprepend(rep, y, -1); 
  901. }
  902.  
  903. inline void String::prepend(char y)
  904. {
  905.   rep = Sprepend(rep, &y, 1); 
  906. }
  907.  
  908. inline void String::prepend(const SubString& y)
  909. {
  910.   rep = Sprepend(rep, y.chars(), y.length());
  911. }
  912.  
  913. // misc transformations
  914.  
  915.  
  916. inline void String::reverse()
  917. {
  918.   rep = Sreverse(rep, rep);
  919. }
  920.  
  921.  
  922. inline void String::upcase()
  923. {
  924.   rep = Supcase(rep, rep);
  925. }
  926.  
  927.  
  928. inline void String::downcase()
  929. {
  930.   rep = Sdowncase(rep, rep);
  931. }
  932.  
  933.  
  934. inline void String::capitalize()
  935. {
  936.   rep = Scapitalize(rep, rep);
  937. }
  938.  
  939. // element extraction
  940.  
  941. inline char&  String::operator [] (int i) 
  942. { 
  943.   if (((unsigned)i) >= length()) error("invalid index");
  944.   return rep->s[i];
  945. }
  946.  
  947. inline char  String::elem (int i) const
  948. { 
  949.   if (((unsigned)i) >= length()) error("invalid index");
  950.   return rep->s[i];
  951. }
  952.  
  953. inline char  String::firstchar() const
  954. { 
  955.   return elem(0);
  956. }
  957.  
  958. inline char  String::lastchar() const
  959. { 
  960.   return elem(length() - 1);
  961. }
  962.  
  963. // searching
  964.  
  965. inline int String::index(char c, int startpos) const
  966. {
  967.   return search(startpos, length(), c);
  968. }
  969.  
  970. inline int String::index(const char* t, int startpos) const
  971. {   
  972.   return search(startpos, length(), t);
  973. }
  974.  
  975. inline int String::index(const String& y, int startpos) const
  976. {   
  977.   return search(startpos, length(), y.chars(), y.length());
  978. }
  979.  
  980. inline int String::index(const SubString& y, int startpos) const
  981. {   
  982.   return search(startpos, length(), y.chars(), y.length());
  983. }
  984.  
  985. inline int String::index(const Regex& r, int startpos) const
  986. {
  987.   int unused;  return r.search(chars(), length(), unused, startpos);
  988. }
  989.  
  990. inline int String::contains(char c) const
  991. {
  992.   return search(0, length(), c) >= 0;
  993. }
  994.  
  995. inline int String::contains(const char* t) const
  996. {   
  997.   return search(0, length(), t) >= 0;
  998. }
  999.  
  1000. inline int String::contains(const String& y) const
  1001. {   
  1002.   return search(0, length(), y.chars(), y.length()) >= 0;
  1003. }
  1004.  
  1005. inline int String::contains(const SubString& y) const
  1006. {   
  1007.   return search(0, length(), y.chars(), y.length()) >= 0;
  1008. }
  1009.  
  1010. inline int String::contains(char c, int p) const
  1011. {
  1012.   return match(p, length(), 0, &c, 1) >= 0;
  1013. }
  1014.  
  1015. inline int String::contains(const char* t, int p) const
  1016. {
  1017.   return match(p, length(), 0, t) >= 0;
  1018. }
  1019.  
  1020. inline int String::contains(const String& y, int p) const
  1021. {
  1022.   return match(p, length(), 0, y.chars(), y.length()) >= 0;
  1023. }
  1024.  
  1025. inline int String::contains(const SubString& y, int p) const
  1026. {
  1027.   return match(p, length(), 0, y.chars(), y.length()) >= 0;
  1028. }
  1029.  
  1030. inline int String::contains(const Regex& r) const
  1031. {
  1032.   int unused;  return r.search(chars(), length(), unused, 0) >= 0;
  1033. }
  1034.  
  1035. inline int String::contains(const Regex& r, int p) const
  1036. {
  1037.   return r.match(chars(), length(), p) >= 0;
  1038. }
  1039.  
  1040.  
  1041. inline int String::matches(const SubString& y, int p) const
  1042. {
  1043.   return match(p, length(), 1, y.chars(), y.length()) >= 0;
  1044. }
  1045.  
  1046. inline int String::matches(const String& y, int p) const
  1047. {
  1048.   return match(p, length(), 1, y.chars(), y.length()) >= 0;
  1049. }
  1050.  
  1051. inline int String::matches(const char* t, int p) const
  1052. {
  1053.   return match(p, length(), 1, t) >= 0;
  1054. }
  1055.  
  1056. inline int String::matches(char c, int p) const
  1057. {
  1058.   return match(p, length(), 1, &c, 1) >= 0;
  1059. }
  1060.  
  1061. inline int String::matches(const Regex& r, int p) const
  1062. {
  1063.   int l = (p < 0)? -p : length() - p;
  1064.   return r.match(chars(), length(), p) == l;
  1065. }
  1066.  
  1067.  
  1068. inline int SubString::contains(const char* t) const
  1069. {   
  1070.   return S.search(pos, pos+len, t) >= 0;
  1071. }
  1072.  
  1073. inline int SubString::contains(const String& y) const
  1074. {   
  1075.   return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
  1076. }
  1077.  
  1078. inline int SubString::contains(const SubString&  y) const
  1079. {   
  1080.   return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
  1081. }
  1082.  
  1083. inline int SubString::contains(char c) const
  1084. {
  1085.   return S.search(pos, pos+len, 0, c) >= 0;
  1086. }
  1087.  
  1088. inline int SubString::contains(const Regex& r) const
  1089. {
  1090.   int unused;  return r.search(chars(), len, unused, 0) >= 0;
  1091. }
  1092.  
  1093. inline int SubString::matches(const Regex& r) const
  1094. {
  1095.   return r.match(chars(), len, 0) == len;
  1096. }
  1097.  
  1098.  
  1099. inline int String::gsub(const String& pat, const String& r)
  1100. {
  1101.   return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
  1102. }
  1103.  
  1104. inline int String::gsub(const SubString&  pat, const String& r)
  1105. {
  1106.   return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
  1107. }
  1108.  
  1109. inline int String::gsub(const Regex& pat, const String& r)
  1110. {
  1111.   return _gsub(pat, r.chars(), r.length());
  1112. }
  1113.  
  1114. inline int String::gsub(const char* pat, const String& r)
  1115. {
  1116.   return _gsub(pat, -1, r.chars(), r.length());
  1117. }
  1118.  
  1119. inline int String::gsub(const char* pat, const char* r)
  1120. {
  1121.   return _gsub(pat, -1, r, -1);
  1122. }
  1123.  
  1124.  
  1125. inline String::operator const char*() const
  1126. { 
  1127.   return str(chars());
  1128. }
  1129.  
  1130. inline  ostream& operator<<(ostream& s, const String& x)
  1131. {
  1132. #ifdef VMS
  1133.    s << x.chars(); return s;
  1134. #else
  1135.   s.put(x.chars()); return s;
  1136. #endif
  1137.  
  1138. }
  1139.  
  1140. // a zillion comparison operators
  1141.  
  1142. inline int operator==(const String& x, const String& y) 
  1143. {
  1144.   return compare(x, y) == 0; 
  1145. }
  1146.  
  1147. inline int operator!=(const String& x, const String& y)
  1148. {
  1149.   return compare(x, y) != 0; 
  1150. }
  1151.  
  1152. inline int operator>(const String& x, const String& y)
  1153. {
  1154.   return compare(x, y) > 0; 
  1155. }
  1156.  
  1157. inline int operator>=(const String& x, const String& y)
  1158. {
  1159.   return compare(x, y) >= 0; 
  1160. }
  1161.  
  1162. inline int operator<(const String& x, const String& y)
  1163. {
  1164.   return compare(x, y) < 0; 
  1165. }
  1166.  
  1167. inline int operator<=(const String& x, const String& y)
  1168. {
  1169.   return compare(x, y) <= 0; 
  1170. }
  1171.  
  1172. inline int operator==(const String& x, const SubString&  y) 
  1173. {
  1174.   return compare(x, y) == 0; 
  1175. }
  1176.  
  1177. inline int operator!=(const String& x, const SubString&  y)
  1178. {
  1179.   return compare(x, y) != 0; 
  1180. }
  1181.  
  1182. inline int operator>(const String& x, const SubString&  y)      
  1183. {
  1184.   return compare(x, y) > 0; 
  1185. }
  1186.  
  1187. inline int operator>=(const String& x, const SubString&  y)
  1188. {
  1189.   return compare(x, y) >= 0; 
  1190. }
  1191.  
  1192. inline int operator<(const String& x, const SubString&  y) 
  1193. {
  1194.   return compare(x, y) < 0; 
  1195. }
  1196.  
  1197. inline int operator<=(const String& x, const SubString&  y)
  1198. {
  1199.   return compare(x, y) <= 0; 
  1200. }
  1201.  
  1202. inline int operator==(const String& x, const char* t) 
  1203. {
  1204.   return compare(x, t) == 0; 
  1205. }
  1206.  
  1207. inline int operator!=(const String& x, const char* t) 
  1208. {
  1209.   return compare(x, t) != 0; 
  1210. }
  1211.  
  1212. inline int operator>(const String& x, const char* t)  
  1213. {
  1214.   return compare(x, t) > 0; 
  1215. }
  1216.  
  1217. inline int operator>=(const String& x, const char* t) 
  1218. {
  1219.   return compare(x, t) >= 0; 
  1220. }
  1221.  
  1222. inline int operator<(const String& x, const char* t)  
  1223. {
  1224.   return compare(x, t) < 0; 
  1225. }
  1226.  
  1227. inline int operator<=(const String& x, const char* t) 
  1228. {
  1229.   return compare(x, t) <= 0; 
  1230. }
  1231.  
  1232. inline int operator==(const SubString& x, const String& y) 
  1233. {
  1234.   return compare(y, x) == 0; 
  1235. }
  1236.  
  1237. inline int operator!=(const SubString& x, const String& y)
  1238. {
  1239.   return compare(y, x) != 0;
  1240. }
  1241.  
  1242. inline int operator>(const SubString& x, const String& y)      
  1243. {
  1244.   return compare(y, x) < 0;
  1245. }
  1246.  
  1247. inline int operator>=(const SubString& x, const String& y)     
  1248. {
  1249.   return compare(y, x) <= 0;
  1250. }
  1251.  
  1252. inline int operator<(const SubString& x, const String& y)      
  1253. {
  1254.   return compare(y, x) > 0;
  1255. }
  1256.  
  1257. inline int operator<=(const SubString& x, const String& y)     
  1258. {
  1259.   return compare(y, x) >= 0;
  1260. }
  1261.  
  1262. inline int operator==(const SubString& x, const SubString&  y) 
  1263. {
  1264.   return compare(x, y) == 0; 
  1265. }
  1266.  
  1267. inline int operator!=(const SubString& x, const SubString&  y)
  1268. {
  1269.   return compare(x, y) != 0;
  1270. }
  1271.  
  1272. inline int operator>(const SubString& x, const SubString&  y)      
  1273. {
  1274.   return compare(x, y) > 0;
  1275. }
  1276.  
  1277. inline int operator>=(const SubString& x, const SubString&  y)
  1278. {
  1279.   return compare(x, y) >= 0;
  1280. }
  1281.  
  1282. inline int operator<(const SubString& x, const SubString&  y) 
  1283. {
  1284.   return compare(x, y) < 0;
  1285. }
  1286.  
  1287. inline int operator<=(const SubString& x, const SubString&  y)
  1288. {
  1289.   return compare(x, y) <= 0;
  1290. }
  1291.  
  1292. inline int operator==(const SubString& x, const char* t) 
  1293. {
  1294.   return compare(x, t) == 0; 
  1295. }
  1296.  
  1297. inline int operator!=(const SubString& x, const char* t) 
  1298. {
  1299.   return compare(x, t) != 0;
  1300. }
  1301.  
  1302. inline int operator>(const SubString& x, const char* t)  
  1303. {
  1304.   return compare(x, t) > 0; 
  1305. }
  1306.  
  1307. inline int operator>=(const SubString& x, const char* t) 
  1308. {
  1309.   return compare(x, t) >= 0; 
  1310. }
  1311.  
  1312. inline int operator<(const SubString& x, const char* t)  
  1313. {
  1314.   return compare(x, t) < 0; 
  1315. }
  1316.  
  1317. inline int operator<=(const SubString& x, const char* t) 
  1318. {
  1319.   return compare(x, t) <= 0; 
  1320. }
  1321.  
  1322.  
  1323. // a helper needed by at, before, etc.
  1324.  
  1325. inline SubString String::_substr(int first, int l)
  1326. {
  1327.   if (first < 0 || (unsigned)(first + l) > length()) 
  1328.     return SubString(_nilString, 0, 0) ;
  1329.   else 
  1330.     return SubString(*this, first, l);
  1331. }
  1332.  
  1333.  
  1334. #endif
  1335.  
  1336. #endif
  1337.