superstr.cpp

用bcg库编写的java IDE 源码

}

SS& SS::replaceRange (std::vector<SS> const & s, std::vector< Pair<int> > const & beglen)
{
	resizeOpHelper(this,beglen,s,replaceRange,adjust,Pair<int>,VectSS,0);
	return *this;
}

template <class T>
static inline SS& replaceHelper (SS* s, T const & t, SS const & newseq, int beg, int len)
{
	SS str = s->getRegion (beg, len);
	std::vector< Pair<int> > mat;
	str.match (t, mat);
	{for (int i=0; i<mat.size(); i++) {
		mat[i]._0 += beg;
	}}
	return s->replaceRange (newseq, mat);
}

SS& SS::replace (SS const & oldseq, SS const & newseq, int beg, int len)
{
	return replaceHelper (this, oldseq, newseq, beg, len);
}

SS& SS::replace (Find const & finder, SS const & newseq, int beg, int len)
{
	return replaceHelper (this, finder, newseq, beg, len);
}

SS& SS::replace (SS const & oldseq, SS const & newseq, Pair<int> const & beglen)
{
	return replace (oldseq, newseq, beglen._0, beglen._1);
}

SS& SS::replace (Find const & finder, SS const & newseq, Pair<int> const & beglen)
{
	return replace (finder, newseq, beglen._0, beglen._1);
}

SS& SS::replace (SS const & oldseq, SS const & newseq, std::vector< Pair<int> > const & beglen)
{
	resizeOpHelper(this,beglen,newseq,replace,adjust,Pair<int>,ReplSS,oldseq);
	return *this;
}

SS& SS::replace (Find const & finder, SS const & newseq, std::vector< Pair<int> > const & beglen)
{
	resizeOpHelper(this,beglen,newseq,replace,adjust,Pair<int>,ReplSS,finder);
	return *this;
}

template <class T>
static inline std::vector< Pair<int> >& matchHelper0 (SS const * s, T const & t, std::vector< Pair<int> >& beglen, int count, int beg, int len, bool forward)
{
	beglen.clear();
	if (count>0 || count==SS::allitems) {
		s->adjust (beg, len);
		SS str = s->getRegion (beg, len);
		if (forward) {
			int n=0,pos=0;
			SS result;
			while ( (pos = str.findNext (t, pos, result)) >= 0) {
				int len = result.length();
				beglen.insert (beglen.end(), Pair<int>(beg+pos, len));
				n++;
				if (count!=SS::allitems && n==count) break;
				pos += len;
			}
		} else {
			int n=0,pos=SS::maxindex;
			SS result;
			while ( (pos = str.findPrev (t, pos, result)) >= 0) {
				int len = result.length();
				beglen.insert (beglen.begin(), Pair<int>(beg+pos, len));
				n++;
				if (count!=SS::allitems && n==count) break;
				--pos;
			}
		}
	}
	return beglen;
}

template <class T>
static inline std::vector< Pair<int> >& matchHelper1 (SS const * s, T const & t, std::vector< Pair<int> >& beglen, int beg, int len)
{
	return matchHelper0 (s, t, beglen, SS::allitems, beg, len, true);
}

template <class T>
static inline std::vector< Pair<int> >& matchHelper2 (SS const * s, T const & t, std::vector< Pair<int> >& beglen, std::vector< Pair<int> > const & beglen_src)
{
	beglen.clear();
	{for (int i=0; i<beglen_src.size(); i++) {
		std::vector< Pair<int> > v;
		matchHelper0 (s, t, v, SS::allitems, beglen_src[i]._0, beglen_src[i]._1, true);
		beglen.insert (beglen.end(), v.begin(), v.end());
	}}
	return beglen;
}

std::vector< Pair<int> >& SS::match (SS const & sequence, std::vector< Pair<int> >& beglen, int beg, int len) const
{
	return matchHelper1 (this, sequence, beglen, beg, len);
}

std::vector< Pair<int> >& SS::match (Find const & finder, std::vector< Pair<int> >& beglen, int beg, int len) const
{
	return matchHelper1 (this, finder, beglen, beg, len);
}

std::vector< Pair<int> >& SS::match (SS const & sequence, std::vector< Pair<int> >& beglen, Pair<int> const & beglen_src) const
{
	return match (sequence, beglen, beglen_src._0, beglen_src._1);
}

std::vector< Pair<int> >& SS::match (Find const & finder, std::vector< Pair<int> >& beglen, Pair<int> const & beglen_src) const
{
	return match (finder, beglen, beglen_src._0, beglen_src._1);
}

std::vector< Pair<int> >& SS::match (SS const & sequence, std::vector< Pair<int> >& beglen, std::vector< Pair<int> > const & beglen_src) const
{
	return matchHelper2 (this, sequence, beglen, beglen_src);
}

std::vector< Pair<int> >& SS::match (Find const & finder, std::vector< Pair<int> >& beglen, std::vector< Pair<int> > const & beglen_src) const
{
	return matchHelper2 (this, finder, beglen, beglen_src);
}

std::vector< Pair<int> >& SS::matchForward (SS const & sequence, std::vector< Pair<int> >& beglen, int count, int beg, int len) const
{
	return matchHelper0 (this, sequence, beglen, count, beg, len, true);
}

std::vector< Pair<int> >& SS::matchForward  (Find const & finder, std::vector< Pair<int> >& beglen, int count, int beg, int len) const
{
	return matchHelper0 (this, finder, beglen, count, beg, len, true);
}

std::vector< Pair<int> >& SS::matchBackward (SS const & sequence, std::vector< Pair<int> >& beglen, int count, int beg, int len) const
{
	return matchHelper0 (this, sequence, beglen, count, beg, len, false);
}

std::vector< Pair<int> >& SS::matchBackward (Find const & finder, std::vector< Pair<int> >& beglen, int count, int beg, int len) const
{
	return matchHelper0 (this, finder, beglen, count, beg, len, false);
}

int SS::removeForward (SS const & oldseq, int count, int beg, int len)
{
	return replaceForward (oldseq, "", count, beg, len);
}

int SS::removeForward (Find const & finder, int count, int beg, int len)
{
	return replaceForward (finder, "", count, beg, len);
}

int SS::removeBackward (SS const & oldseq, int count, int beg, int len)
{
	return replaceBackward (oldseq, "", count, beg, len);
}

int SS::removeBackward (Find const & finder, int count, int beg, int len)
{
	return replaceBackward (finder, "", count, beg, len);
}

template <class T>
static inline int replaceDirHelper (SS* s, T const & t, SS const & newseq, int count, int beg, int len, bool forward)
{
	std::vector< Pair<int> > beglen;
	matchHelper0 (s, t, beglen, count, beg, len, forward);
	s->replaceRange (newseq, beglen);
	return beglen.size();
}

int SS::replaceForward (SS const & oldseq, SS const newseq, int count, int beg, int len)
{
	return replaceDirHelper (this, oldseq, newseq, count, beg, len, true);
}

int SS::replaceForward (Find const & finder, SS const newseq, int count, int beg, int len)
{
	return replaceDirHelper (this, finder, newseq, count, beg, len, true);
}

int SS::replaceBackward (SS const & oldseq, SS const newseq, int count, int beg, int len)
{
	return replaceDirHelper (this, oldseq, newseq, count, beg, len, false);
}

int SS::replaceBackward (Find const & finder, SS const newseq, int count, int beg, int len)
{
	return replaceDirHelper (this, finder, newseq, count, beg, len, false);
}

SS& SS::swap (int pos0, int pos1)
{
	char& c0 = at (pos0);
	char& c1 = at (pos1);
	char c = c0;
	c0 = c1;
	c1 = c;
	return *this;
}

// old value of this destroyed when tmp goes out of scope
SS& SS::become (SS& s)
{
	SS tmp;
	tmp.swap (s);
	swap (tmp);
	return *this;
}

SS& SS::swap (SS& s)
{
	SS tmp;
	tmp._setData (s);
	s._setData (*this);
	_setData (tmp);
	tmp._zero();
	return *this;
}

bool SS::isUpperCase (int pos) const
{
	return upperP (_rep[pos]);
}

bool SS::isLowerCase (int pos) const
{
	return lowerP (_rep[pos]);
}

bool SS::isWhiteSpace (int pos) const
{
	return whiteP (_rep[pos]);
}

bool SS::isBlackSpace (int pos) const
{
	return blackP (_rep[pos]);
}

bool SS::isAlpha (int pos) const
{
	return alphaP (_rep[pos]);
}

bool SS::isDigit (int pos) const
{
	return digitP (_rep[pos]);
}

bool SS::isHexDigit (int pos) const
{
	return hexDigitP (_rep[pos]);
}

bool SS::isPrintable (int pos) const
{
	return printableP (_rep[pos]);
}

bool SS::isAlphaNumeric (int pos) const
{
	return alphaP (_rep[pos]);
}

bool SS::isPunct (int pos) const
{
	return punctP (_rep[pos]);
}

bool SS::isCntrl (int pos) const
{
	return cntrlP (_rep[pos]);
}

bool SS::isGraph (int pos) const
{
	return graphP (_rep[pos]);
}

bool SS::upperP (char c)
{
	return std::isupper (c, std::locale());
}

bool SS::lowerP (char c)
{
	return std::islower (c, std::locale());
}

bool SS::whiteP (char c)
{
	return std::isspace (c, std::locale());
}

bool SS::blackP (char c)
{
	return std::isgraph (c, std::locale());
}

bool SS::alphaP (char c)
{
	return std::isalpha (c, std::locale());
}

bool SS::digitP (char c)
{
	return std::isdigit(c, std::locale());
}

bool SS::printableP (char c)
{
	return std::isprint(c, std::locale());
}

bool SS::hexDigitP (char c)
{
	return std::isxdigit(c, std::locale());
}

bool SS::cntrlP (char c)
{
	return std::iscntrl(c, std::locale());
}

bool SS::punctP (char c)
{
	return std::ispunct(c, std::locale());
}

bool SS::alphanumP (char c)
{
	return std::isalnum(c, std::locale());
}

bool SS::graphP (char c)
{
	return std::isgraph(c, std::locale());
}

char SS::getLower (char c)
{
	return tolower(c);
}

char SS::getUpper (char c)
{
	return toupper(c);
}

void SS::to_lower (char& c)
{
	c = getLower(c);
}

void SS::to_upper (char& c)
{
	c = getUpper(c);
}

SS& SS::toLower ()
{
	{for (int i=0; i<length(); i++) {
		to_lower(_rep [i]);
	}}
	return *this;
}

SS& SS::toLower (int pos)
{
	to_lower (_rep[pos]);
	return *this;
}

SS& SS::toUpper ()
{
	{for (int i=0; i<length(); i++) {
		to_upper (_rep[i]);
	}}
	return *this;
}

SS& SS::toUpper (int pos)
{
	to_upper (_rep[pos]);
	return *this;
}

SS SS::toHex () const
{
	const char hex_codes [] = "0123456789abcdef";
	SS ret (Buffer(2*_len));
	{for (int i=0; i<_len; i++) {
		unsigned char byte = _rep[i];
		ret._rep[2*i]   = hex_codes [byte >> 4];
		ret._rep[2*i+1] = hex_codes [byte & 0xf];
	}}
	return ret;
}

SS SS::fromHex () const
{
	std::vector<char> ret;
	int pos = maxindex;
	SS hexchar;
	// find one or preferably two hex digits
	while ( (pos=findPrev (hexdigit, pos)) >= 0) {
		SS res;
		if (match (hexdigit, pos-1)) {
			hexchar = get (pos-1,2);
			pos -= 2;
		} else {
			hexchar = get (pos, 1);
			pos--;
		}
		int x=0;
		sscanf (hexchar, "%x", &x);
		char c = x;
		ret.insert (ret.end(), c);
	}
	std::reverse (ret.begin(), ret.end());
	return ret;
}

SS SS::outputHex () const
{
	const char hex_codes [] = "0123456789abcdef";
	const int bytesPerLine = 16;
	int offsetBytes = 0;
	{for (int tmp=_len; tmp; tmp >>= 8) offsetBytes++; }
	int hexOffset = 2*offsetBytes + 2; // colon and space
	int lineLength = hexOffset + 4*bytesPerLine + 2;
	int asciiOffset = lineLength - bytesPerLine - 1;
	int numberOfLines = (_len + bytesPerLine - 1) / bytesPerLine;

	SS ret (Buffer(numberOfLines*lineLength));
	ret.fill(' ');
	{for (int i=0; i<numberOfLines; i++) {
		int beg = i * bytesPerLine;
		int len = bytesPerLine;
		if (beg + len > _len) len = _len - beg;
		char* buff = ret._rep + i * lineLength;
		char* start = _rep + beg;
		int pos = 0;
		{
			unsigned char* byte = (unsigned char*)&beg;
			{for (int i=offsetBytes-1; i>=0; i--) {
				buff [pos++] = hex_codes [byte[i] >> 4];
				buff [pos++] = hex_codes [byte[i] & 0xf];
			}}
			buff [pos++] = ':';
		}
		{
			{for (int i=0; i<len; i++) {
				buff [pos++] = ' ';
				unsigned char byte = start[i];
				buff [pos++] = hex_codes [byte >> 4];
				buff [pos++] = hex_codes [byte & 0xf];
				buff [asciiOffset + i] = printableP(byte) ? byte : '.';
			}}
			buff [asciiOffset - 2] = buff [asciiOffset - 1] = ' ';
			buff [lineLength - 1] = '\n';
			buff [hexOffset+11] = buff [hexOffset+23] = buff [hexOffset+35] = '|';
		}
	}}
	return ret;
}

SS SS::trim () const
{
	int i0 = findNext (blackspace);
	if (i0==notfound) return "";
	int i1 = findPrev (blackspace);
	return get (i0, i1 - i0 + 1);
}

SS SS::dup (int n) const
{
	if (n<0) ErrorMacro(ErrorOutOfRange("SS::dup - n can't be < 0"));
	SS ret ((Buffer)(n*length()));
	ret.repeat (*this);
	return ret;
}

char* SS::extract ()
{
	setNoAlloc();
	checkFlags();
	return _rep;
}

long SS::hash () const
{
	return hash (_rep, size());
}

long SS::hash (void const * v, int n)
{
  const int halfchar = 4;
  const int threechar = 24;
  const unsigned long mask = ~(~(unsigned long)(0) >> halfchar);
  unsigned long p = 0;
  for (int i=0; i<n; i++) {
	p = ( p << halfchar) + ((char const *)v)[i];
	unsigned long q = p & mask;
	if (q) {
	  p ^= q >> threechar;
	  p &= ~mask;
    }
  }
  return p;
}

SS const & SS::copyTo (void* dst, int n, int beg) const
{
	adjust (beg, n);
	copy (dst, _rep+beg, n);
	return *this;
}

SS& SS::copyFrom (void* src, int n, int beg)
{
	adjust (beg, n);
	copy (_rep+beg, src, n);
	return *this;
}

SS& SS::assignFrom (void* src, int n)
{
	assign (src, n);
	return *this;
}

void SS::copy (void* dst, void const * src, int n)
{
	memmove (dst, src, n);
}

void SS::copy (void * dst, int l0, void const * src, int l1)
{
	int n = l0 < l1 ? l0 : l1;
	copy (dst, src, n);
}

int SS::compare (void const * bf0, void const * bf1, int n)
{
	return memcmp (bf0, bf1, n);
}