str.c

一个内存数据库的源代码这是服务器端还有客户端

	return GDK_SUCCEED;
}

int
codeset(str *res)
{
#ifdef HAVE_NL_LANGINFO
	char *codeset = nl_langinfo(CODESET);

	if (!codeset)
		return GDK_FAIL;
	*res = GDKstrdup(codeset);
	return GDK_SUCCEED;
#else
	*res = GDKstrdup("UTF-8");
	return GDK_SUCCEED;
#endif
}

int
strIconv(str *res, str org, str f, str t)
{
#ifdef HAVE_ICONV
	size_t len = strlen(org);
	iconv_t cd = iconv_open(t, f);
	size_t size = 4 * len;	/* make sure enough memory is claimed */
	char *r;
	ICONV_CONST char *from = org;

	if (!cd) {
		GDKerror("strIconv: Cannot convert strings from (%s) to (%s)\n", f, t);
		return GDK_FAIL;
	}
	*res = r = GDKmalloc(size);
	if (iconv(cd, &from, &len, &r, &size) == (size_t) - 1) {
		GDKfree(*res);
		*res = NULL;
		GDKerror("strIconv: String conversion failed from (%s) to (%s)\n", f, t);
		return GDK_FAIL;
	}
	*r = 0;
	iconv_close(cd);
	return GDK_SUCCEED;
#else
	*res = NULL;
	if (strcmp(f, t) == 0) {
		*res = GDKstrdup(org);
		return GDK_SUCCEED;
	}
	return GDK_FAIL;
#endif
}

int
strChrAt(chr *res, str val, int *at)
{
	int v;

	strWChrAt(&v, val, at);
	if (0 <= v && v <= 127)
		*res = (chr) v;
	else
		*res = chr_nil;
	return GDK_SUCCEED;
}

int
strPrefix(bit *res, str s, str prefix)
{
	size_t pl, i;

	RETURN_NIL_IF(strNil(s) || strNil(prefix), TYPE_bit);
	pl = strlen(prefix);
	if (strlen(s) < pl) {
		*res = 0;
		return GDK_SUCCEED;
	}
	*res = 1;
	for (i = 0; i < pl; i++) {
		if (s[i] != prefix[i]) {
			*res = 0;
			return GDK_SUCCEED;
		}
	}
	return GDK_SUCCEED;
}

int
strSuffix(bit *res, str s, str suffix)
{
	size_t i, sl, sul;

	RETURN_NIL_IF(strNil(s) || strNil(suffix), TYPE_bit);
	sl = strlen(s);
	sul = strlen(suffix);

	if (sl < sul) {
		*res = 0;
		return GDK_SUCCEED;
	}
	*res = 1;
	for (i = 0; i < sul; i++) {
		if (s[sl - 1 - i] != suffix[sul - 1 - i]) {
			*res = 0;
			return GDK_SUCCEED;
		}
	}
	return GDK_SUCCEED;
}

int
strLower(str *res, str s)
{
	size_t len = strlen(s);
	unsigned char *dst, *src = (unsigned char *) s, *end = (unsigned char *) (src + len);

	RETURN_NIL_IF(strNil(s), TYPE_str);
	*res = GDKmalloc(len + 1);
	dst = (unsigned char *) *res;
	while (src < end) {
		int c;

		
#line 1217 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"
	if (*src < 0x80) {
		(c) = *(src)++;
	} else if (*(src) < 0xE0) {
		(c)  = (*(src)++ & 0x1F) << 6;
		(c) |= (*(src)++ & 0x3F);
	} else if (*(src) < 0xF0) {
		(c)  = (*(src)++ & 0x0F) << 12;
		(c) |= (*(src)++ & 0x3F) << 6;
		(c) |= (*(src)++ & 0x3F);
	} else if (*src < 0xF8) {
		(c)  = (*(src)++ & 0x07) << 18;
		(c) |= (*(src)++ & 0x3F) << 12;
		(c) |= (*(src)++ & 0x3F) << 6;
		(c) |= (*(src)++ & 0x3F);
	} else if (*src < 0xFC) {
		(c)  = (*(src)++ & 0x03) << 24;
		(c) |= (*(src)++ & 0x3F) << 18;
		(c) |= (*(src)++ & 0x3F) << 12;
		(c) |= (*(src)++ & 0x3F) << 6;
		(c) |= (*(src)++ & 0x3F);
	} else if (*src < 0xFE) {
		(c)  = (*(src)++ & 0x01) << 30;
		(c) |= (*(src)++ & 0x3F) << 24;
		(c) |= (*(src)++ & 0x3F) << 18;
		(c) |= (*(src)++ & 0x3F) << 12;
		(c) |= (*(src)++ & 0x3F) << 6;
		(c) |= (*(src)++ & 0x3F);
	} else {
		(c) = int_nil;
	}


#line 1649 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"

		
#line 1209 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"
{
	BUN UTF8_CONV_r;
	int UTF8_CONV_v = (c);
	HASHfnd_int(UTF8_CONV_r, UTF8_tolowerBat, &UTF8_CONV_v);
	if (UTF8_CONV_r)
		(c) = *(int*) BUNtloc(UTF8_tolowerBat, UTF8_CONV_r);
}


#line 1650 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"

		if (dst + 6 > (unsigned char *) *res + len) {
			/* not guaranteed to fit, so allocate more space;
			   also allocate enough for the rest of the source */
			size_t off = dst - (unsigned char *) *res;

			*res = GDKrealloc(*res, (len += 6 + (end - src)) + 1);
			dst = (unsigned char *) *res + off;
		}
		
#line 1248 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"
	if ((c) < 0
#if SIZEOF_INT > 4
	    || (int) (c) >= 0x80000000
#endif
	   ) {
		*(dst)++ = chr_nil;
	} else if ((c) < 0x80) {
		*(dst)++ = (c);
	} else if ((c) < 0x800) {
		*(dst)++ = 0xC0 | ((c) >> 6);
		*(dst)++ = 0x80 | ((c) & 0x3F);
	} else if ((c) < 0x10000) {
		*(dst)++ = 0xE0 | ((c) >> 12);
		*(dst)++ = 0x80 | (((c) >> 6) & 0x3F);
		*(dst)++ = 0x80 | ((c) & 0x3F);
	} else if ((c) < 0x200000) {
		*(dst)++ = 0xF0 | ((c) >> 18);
		*(dst)++ = 0x80 | (((c) >> 12) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 6) & 0x3F);
		*(dst)++ = 0x80 | ((c) & 0x3F);
	} else if ((c) < 0x4000000) {
		*(dst)++ = 0xF8 | ((c) >> 24);
		*(dst)++ = 0x80 | (((c) >> 18) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 12) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 6) & 0x3F);
		*(dst)++ = 0x80 | ((c) & 0x3F);
	} else /* if ((c) < 0x80000000) */ {
		*(dst)++ = 0xFC | ((c) >> 30);
		*(dst)++ = 0x80 | (((c) >> 24) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 18) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 12) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 6) & 0x3F);
		*(dst)++ = 0x80 | ((c) & 0x3F);
	}


#line 1659 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"

	}
	*dst = 0;
	return GDK_SUCCEED;
}

int
strUpper(str *res, str s)
{
	size_t len = strlen(s);
	unsigned char *dst, *src = (unsigned char *) s, *end = (unsigned char *) (src + len);

	RETURN_NIL_IF(strNil(s), TYPE_str);
	*res = GDKmalloc(len + 1);
	dst = (unsigned char *) *res;
	while (src < end) {
		int c;

		
#line 1217 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"
	if (*src < 0x80) {
		(c) = *(src)++;
	} else if (*(src) < 0xE0) {
		(c)  = (*(src)++ & 0x1F) << 6;
		(c) |= (*(src)++ & 0x3F);
	} else if (*(src) < 0xF0) {
		(c)  = (*(src)++ & 0x0F) << 12;
		(c) |= (*(src)++ & 0x3F) << 6;
		(c) |= (*(src)++ & 0x3F);
	} else if (*src < 0xF8) {
		(c)  = (*(src)++ & 0x07) << 18;
		(c) |= (*(src)++ & 0x3F) << 12;
		(c) |= (*(src)++ & 0x3F) << 6;
		(c) |= (*(src)++ & 0x3F);
	} else if (*src < 0xFC) {
		(c)  = (*(src)++ & 0x03) << 24;
		(c) |= (*(src)++ & 0x3F) << 18;
		(c) |= (*(src)++ & 0x3F) << 12;
		(c) |= (*(src)++ & 0x3F) << 6;
		(c) |= (*(src)++ & 0x3F);
	} else if (*src < 0xFE) {
		(c)  = (*(src)++ & 0x01) << 30;
		(c) |= (*(src)++ & 0x3F) << 24;
		(c) |= (*(src)++ & 0x3F) << 18;
		(c) |= (*(src)++ & 0x3F) << 12;
		(c) |= (*(src)++ & 0x3F) << 6;
		(c) |= (*(src)++ & 0x3F);
	} else {
		(c) = int_nil;
	}


#line 1677 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"

		
#line 1209 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"
{
	BUN UTF8_CONV_r;
	int UTF8_CONV_v = (c);
	HASHfnd_int(UTF8_CONV_r, UTF8_toupperBat, &UTF8_CONV_v);
	if (UTF8_CONV_r)
		(c) = *(int*) BUNtloc(UTF8_toupperBat, UTF8_CONV_r);
}


#line 1678 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"

		if (dst + 6 > (unsigned char *) *res + len) {
			/* not guaranteed to fit, so allocate more space;
			   also allocate enough for the rest of the source */
			size_t off = dst - (unsigned char *) *res;

			*res = GDKrealloc(*res, (len += 6 + (end - src)) + 1);
			dst = (unsigned char *) *res + off;
		}
		
#line 1248 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"
	if ((c) < 0
#if SIZEOF_INT > 4
	    || (int) (c) >= 0x80000000
#endif
	   ) {
		*(dst)++ = chr_nil;
	} else if ((c) < 0x80) {
		*(dst)++ = (c);
	} else if ((c) < 0x800) {
		*(dst)++ = 0xC0 | ((c) >> 6);
		*(dst)++ = 0x80 | ((c) & 0x3F);
	} else if ((c) < 0x10000) {
		*(dst)++ = 0xE0 | ((c) >> 12);
		*(dst)++ = 0x80 | (((c) >> 6) & 0x3F);
		*(dst)++ = 0x80 | ((c) & 0x3F);
	} else if ((c) < 0x200000) {
		*(dst)++ = 0xF0 | ((c) >> 18);
		*(dst)++ = 0x80 | (((c) >> 12) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 6) & 0x3F);
		*(dst)++ = 0x80 | ((c) & 0x3F);
	} else if ((c) < 0x4000000) {
		*(dst)++ = 0xF8 | ((c) >> 24);
		*(dst)++ = 0x80 | (((c) >> 18) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 12) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 6) & 0x3F);
		*(dst)++ = 0x80 | ((c) & 0x3F);
	} else /* if ((c) < 0x80000000) */ {
		*(dst)++ = 0xFC | ((c) >> 30);
		*(dst)++ = 0x80 | (((c) >> 24) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 18) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 12) & 0x3F);
		*(dst)++ = 0x80 | (((c) >> 6) & 0x3F);
		*(dst)++ = 0x80 | ((c) & 0x3F);
	}


#line 1687 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"

	}
	*dst = 0;
	return GDK_SUCCEED;
}

int
strStrSearch(int *res, str s, str s2)
{
	char *p;

	RETURN_NIL_IF(strNil(s) || strNil(s2), TYPE_int);
	if ((p = strstr(s, s2)) != 0)
		*res = UTF8_strpos(s, p);
	else
		*res = -1;
	return GDK_SUCCEED;
}

int
strReverseStrSearch(int *res, str s, str s2)
{
	size_t len, slen;
	char *p, *q;
	size_t i;

	RETURN_NIL_IF(strNil(s) || strNil(s2), TYPE_int);
	*res = -1;
	len = strlen(s);
	slen = strlen(s2);
	for (p = s + len - slen; p >= s; p--) {
		for (i = 0, q = p; i < slen && *q == s2[i]; i++, q++)
			;
		if (i == slen) {
			*res = UTF8_strpos(s, p);
			break;
		}
	}

	return GDK_SUCCEED;
}

int
strChrSearch(int *res, str s, chr *c)
{
	int i = (int) *c;
	char buf[7], *p = buf;

	RETURN_NIL_IF(strNil(s) || *c == chr_nil, TYPE_int);
	
#line 1248 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"
	if ((i) < 0
#if SIZEOF_INT > 4
	    || (int) (i) >= 0x80000000
#endif
	   ) {
		*(p)++ = chr_nil;
	} else if ((i) < 0x80) {
		*(p)++ = (i);
	} else if ((i) < 0x800) {
		*(p)++ = 0xC0 | ((i) >> 6);
		*(p)++ = 0x80 | ((i) & 0x3F);
	} else if ((i) < 0x10000) {
		*(p)++ = 0xE0 | ((i) >> 12);
		*(p)++ = 0x80 | (((i) >> 6) & 0x3F);
		*(p)++ = 0x80 | ((i) & 0x3F);
	} else if ((i) < 0x200000) {
		*(p)++ = 0xF0 | ((i) >> 18);
		*(p)++ = 0x80 | (((i) >> 12) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 6) & 0x3F);
		*(p)++ = 0x80 | ((i) & 0x3F);
	} else if ((i) < 0x4000000) {
		*(p)++ = 0xF8 | ((i) >> 24);
		*(p)++ = 0x80 | (((i) >> 18) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 12) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 6) & 0x3F);
		*(p)++ = 0x80 | ((i) & 0x3F);
	} else /* if ((i) < 0x80000000) */ {
		*(p)++ = 0xFC | ((i) >> 30);
		*(p)++ = 0x80 | (((i) >> 24) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 18) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 12) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 6) & 0x3F);
		*(p)++ = 0x80 | ((i) & 0x3F);
	}


#line 1736 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"

	*p = 0;
	return strStrSearch(res, s, buf);
}

int
strReverseChrSearch(int *res, str s, chr *c)
{
	int i = (int) *c;
	char buf[7], *p = buf;

	RETURN_NIL_IF(strNil(s) || *c == chr_nil, TYPE_int);
	
#line 1248 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"
	if ((i) < 0
#if SIZEOF_INT > 4
	    || (int) (i) >= 0x80000000
#endif
	   ) {
		*(p)++ = chr_nil;
	} else if ((i) < 0x80) {
		*(p)++ = (i);
	} else if ((i) < 0x800) {
		*(p)++ = 0xC0 | ((i) >> 6);
		*(p)++ = 0x80 | ((i) & 0x3F);
	} else if ((i) < 0x10000) {
		*(p)++ = 0xE0 | ((i) >> 12);
		*(p)++ = 0x80 | (((i) >> 6) & 0x3F);
		*(p)++ = 0x80 | ((i) & 0x3F);
	} else if ((i) < 0x200000) {
		*(p)++ = 0xF0 | ((i) >> 18);
		*(p)++ = 0x80 | (((i) >> 12) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 6) & 0x3F);
		*(p)++ = 0x80 | ((i) & 0x3F);
	} else if ((i) < 0x4000000) {
		*(p)++ = 0xF8 | ((i) >> 24);
		*(p)++ = 0x80 | (((i) >> 18) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 12) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 6) & 0x3F);
		*(p)++ = 0x80 | ((i) & 0x3F);
	} else /* if ((i) < 0x80000000) */ {
		*(p)++ = 0xFC | ((i) >> 30);
		*(p)++ = 0x80 | (((i) >> 24) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 18) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 12) & 0x3F);
		*(p)++ = 0x80 | (((i) >> 6) & 0x3F);
		*(p)++ = 0x80 | ((i) & 0x3F);
	}


#line 1748 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"

	*p = 0;
	return strReverseStrSearch(res, s, buf);
}

int
strStrip(str *res, str s)
{
	str start = s;
	size_t len;

	while (GDKisspace(*start))
		start++;

	/* Remove the trailing spaces.  Make sure not to pass the start */
	/* pointer in case a string only contains spaces.		*/
	s = start + strlen(start);
	while (s > start && GDKisspace(*(s - 1)))
		s--;

	len = s - start + 1;
	*res = GDKmalloc(len);
	memcpy(*res, start, len - 1);
	(*res)[len - 1] = '\0';
	return GDK_SUCCEED;
}

int
strLtrim(str *res, str s)
{
	RETURN_NIL_IF(strNil(s), TYPE_str);
	while (GDKisspace(*s))
		s++;
	*res = GDKstrdup(s);
	return GDK_SUCCEED;
}

int
strRtrim(str *res, str s)
{
	size_t len = strlen(s);

	RETURN_NIL_IF(strNil(s), TYPE_str);
	while (len > 0 && GDKisspace(s[len - 1]))
		len--;
	*res = GDKmalloc(len + 1);
	memcpy(*res, s, len);
	(*res)[len] = '\0';
	return GDK_SUCCEED;
}

int
strSubstitute(str *res, str s, str src, str dst, bit *g)
{
	int repeat = *g;
	size_t lsrc = (src?strlen(src):0), ldst = (dst?strlen(dst):0);
	size_t l = (s?strLen(s):0), n = l + ldst;
	str buf, fnd, end;

	if (repeat && ldst > lsrc && lsrc) {
		n = (ldst * l) / lsrc;	/* max length */
	}
	buf = *res = (str) GDKmalloc(n);
	end = buf + l;
	fnd = buf;
	strcpy(buf, s);
	if (!lsrc)
		return GDK_SUCCEED;
	do {
		fnd = strstr((fnd < buf) ? buf : fnd, src);
		if (!fnd)
			break;
		memmove(fnd + ldst, fnd + lsrc, end - fnd);
		memcpy(fnd, dst, ldst);
		end += ldst - lsrc;
		fnd += ldst;
	} while (repeat);

	return GDK_SUCCEED;
}

int
strTranslate(str *res, str src, str mapstr, str transtr)
{
	unsigned char *s;
	unsigned char *dst;
	int *map, *tran;
	int c, n, m, i;

	/* if any of the inputs is nil, return nil */
	if (strNil(src) || strNil(mapstr) || strNil(transtr)) {
		* (ptr *) res = (ptr) ATOMnil(TYPE_str);
		return GDK_SUCCEED;
	}
	/* quick check: empty string in, empty string out;
	   quick check: empty mapstr, return src unchanged */
	if (*src == 0 || *mapstr == 0) {
		*res = GDKstrdup(src);
		return GDK_SUCCEED;
	}
	/* convert mapstr and transtr to arrays of Unicode code points */
	n = 0;
	map = GDKmalloc(strlen(mapstr) * sizeof(int));
	s = (unsigned char *) mapstr;
	for (;;) {
		
#line 1217 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"
	if (*s < 0x80) {
		(c) = *(s)++;
	} else if (*(s) < 0xE0) {
		(c)  = (*(s)++ & 0x1F) << 6;
		(c) |= (*(s)++ & 0x3F);
	} else if (*(s) < 0xF0) {
		(c)  = (*(s)++ & 0x0F) << 12;
		(c) |= (*(s)++ & 0x3F) << 6;
		(c) |= (*(s)++ & 0x3F);
	} else if (*s < 0xF8) {
		(c)  = (*(s)++ & 0x07) << 18;
		(c) |= (*(s)++ & 0x3F) << 12;
		(c) |= (*(s)++ & 0x3F) << 6;
		(c) |= (*(s)++ & 0x3F);
	} else if (*s < 0xFC) {
		(c)  = (*(s)++ & 0x03) << 24;
		(c) |= (*(s)++ & 0x3F) << 18;
		(c) |= (*(s)++ & 0x3F) << 12;
		(c) |= (*(s)++ & 0x3F) << 6;
		(c) |= (*(s)++ & 0x3F);
	} else if (*s < 0xFE) {
		(c)  = (*(s)++ & 0x01) << 30;
		(c) |= (*(s)++ & 0x3F) << 24;
		(c) |= (*(s)++ & 0x3F) << 18;
		(c) |= (*(s)++ & 0x3F) << 12;
		(c) |= (*(s)++ & 0x3F) << 6;
		(c) |= (*(s)++ & 0x3F);
	} else {
		(c) = int_nil;
	}


#line 1853 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/str.mx"

		if (c == int_nil) {
			GDKfree(map);
			* (ptr *) res = (ptr) ATOMnil(TYPE_str);
			return GDK_SUCCEED;