HBAO+ 4.0.0.23740451

11 files changed, 0 insertions, 8614 deletions

diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/bsafe.c b/build/tools/HLSLcc/May_2014/src/cbstring/bsafe.c
deleted file mode 100644
index 2a4cf1f..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/bsafe.c
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2010, and is covered by either the 3-clause 
- * BSD open source license or GPL v2.0. Refer to the accompanying documentation 
- * for details on usage and license.
- */
-
-/*
- * bsafe.c
- *
- * This is an optional module that can be used to help enforce a safety
- * standard based on pervasive usage of bstrlib.  This file is not necessarily
- * portable, however, it has been tested to work correctly with Intel's C/C++
- * compiler, WATCOM C/C++ v11.x and Microsoft Visual C++.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "bsafe.h"
-
-static int bsafeShouldExit = 1;
-
-#if 0
-char * strcpy (char *dst, const char *src);
-char * strcat (char *dst, const char *src);
-
-char * strcpy (char *dst, const char *src) {
-	dst = dst;
-	src = src;
-	fprintf (stderr, "bsafe error: strcpy() is not safe, use bstrcpy instead.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-char * strcat (char *dst, const char *src) {
-	dst = dst;
-	src = src;
-	fprintf (stderr, "bsafe error: strcat() is not safe, use bstrcat instead.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-#if !defined (__GNUC__) && (!defined(_MSC_VER) || (_MSC_VER <= 1310))
-char * (gets) (char * buf) {
-	buf = buf;
-	fprintf (stderr, "bsafe error: gets() is not safe, use bgets.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-#endif
-
-char * (strncpy) (char *dst, const char *src, size_t n) {
-	dst = dst;
-	src = src;
-	n = n;
-	fprintf (stderr, "bsafe error: strncpy() is not safe, use bmidstr instead.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-char * (strncat) (char *dst, const char *src, size_t n) {
-	dst = dst;
-	src = src;
-	n = n;
-	fprintf (stderr, "bsafe error: strncat() is not safe, use bstrcat then btrunc\n\tor cstr2tbstr, btrunc then bstrcat instead.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-char * (strtok) (char *s1, const char *s2) {
-	s1 = s1;
-	s2 = s2;
-	fprintf (stderr, "bsafe error: strtok() is not safe, use bsplit or bsplits instead.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-char * (strdup) (const char *s) {
-	s = s;
-	fprintf (stderr, "bsafe error: strdup() is not safe, use bstrcpy.\n");
-	if (bsafeShouldExit) exit (-1);
-	return NULL;
-}
-
-#endif
diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/bsafe.h b/build/tools/HLSLcc/May_2014/src/cbstring/bsafe.h
deleted file mode 100644
index eb41ec2..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/bsafe.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2010, and is covered by either the 3-clause 
- * BSD open source license or GPL v2.0. Refer to the accompanying documentation 
- * for details on usage and license.
- */
-
-/*
- * bsafe.h
- *
- * This is an optional module that can be used to help enforce a safety
- * standard based on pervasive usage of bstrlib.  This file is not necessarily
- * portable, however, it has been tested to work correctly with Intel's C/C++
- * compiler, WATCOM C/C++ v11.x and Microsoft Visual C++.
- */
-
-#ifndef BSTRLIB_BSAFE_INCLUDE
-#define BSTRLIB_BSAFE_INCLUDE
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if !defined (__GNUC__) && (!defined(_MSC_VER) || (_MSC_VER <= 1310))
-/* This is caught in the linker, so its not necessary for gcc. */
-extern char * (gets) (char * buf);
-#endif
-
-extern char * (strncpy) (char *dst, const char *src, size_t n);
-extern char * (strncat) (char *dst, const char *src, size_t n);
-extern char * (strtok) (char *s1, const char *s2);
-extern char * (strdup) (const char *s);
-
-#undef strcpy
-#undef strcat
-#define strcpy(a,b) bsafe_strcpy(a,b) 
-#define strcat(a,b) bsafe_strcat(a,b) 
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/bstraux.c b/build/tools/HLSLcc/May_2014/src/cbstring/bstraux.c
deleted file mode 100644
index 975932c..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/bstraux.c
+++ /dev/null
@@ -1,1133 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2010, and is covered by either the 3-clause 
- * BSD open source license or GPL v2.0. Refer to the accompanying documentation 
- * for details on usage and license.
- */
-
-/*
- * bstraux.c
- *
- * This file is not necessarily part of the core bstring library itself, but
- * is just an auxilliary module which includes miscellaneous or trivial 
- * functions.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <ctype.h>
-#include "bstrlib.h"
-#include "bstraux.h"
-
-/*  bstring bTail (bstring b, int n)
- *
- *  Return with a string of the last n characters of b.
- */
-bstring bTail (bstring b, int n) {
-	if (b == NULL || n < 0 || (b->mlen < b->slen && b->mlen > 0)) return NULL;
-	if (n >= b->slen) return bstrcpy (b);
-	return bmidstr (b, b->slen - n, n);
-}
-
-/*  bstring bHead (bstring b, int n)
- *
- *  Return with a string of the first n characters of b.
- */
-bstring bHead (bstring b, int n) {
-	if (b == NULL || n < 0 || (b->mlen < b->slen && b->mlen > 0)) return NULL;
-	if (n >= b->slen) return bstrcpy (b);
-	return bmidstr (b, 0, n);
-}
-
-/*  int bFill (bstring a, char c, int len)
- *
- *  Fill a given bstring with the character in parameter c, for a length n.
- */
-int bFill (bstring b, char c, int len) {
-	if (b == NULL || len < 0 || (b->mlen < b->slen && b->mlen > 0)) return -__LINE__;
-	b->slen = 0;
-	return bsetstr (b, len, NULL, c);
-}
-
-/*  int bReplicate (bstring b, int n)
- *
- *  Replicate the contents of b end to end n times and replace it in b.
- */
-int bReplicate (bstring b, int n) {
-	return bpattern (b, n * b->slen);
-}
-
-/*  int bReverse (bstring b)
- *
- *  Reverse the contents of b in place.
- */
-int bReverse (bstring b) {
-int i, n, m;
-unsigned char t;
-
-	if (b == NULL || b->slen < 0 || b->mlen < b->slen) return -__LINE__;
-	n = b->slen;
-	if (2 <= n) {
-		m = ((unsigned)n) >> 1;
-		n--;
-		for (i=0; i < m; i++) {
-			t = b->data[n - i];
-			b->data[n - i] = b->data[i];
-			b->data[i] = t;
-		}
-	}
-	return 0;
-}
-
-/*  int bInsertChrs (bstring b, int pos, int len, unsigned char c, unsigned char fill)
- *
- *  Insert a repeated sequence of a given character into the string at 
- *  position pos for a length len.
- */
-int bInsertChrs (bstring b, int pos, int len, unsigned char c, unsigned char fill) {
-	if (b == NULL || b->slen < 0 || b->mlen < b->slen || pos < 0 || len <= 0) return -__LINE__;
-
-	if (pos > b->slen 
-	 && 0 > bsetstr (b, pos, NULL, fill)) return -__LINE__;
-
-	if (0 > balloc (b, b->slen + len)) return -__LINE__;
-	if (pos < b->slen) memmove (b->data + pos + len, b->data + pos, b->slen - pos);
-	memset (b->data + pos, c, len);
-	b->slen += len;
-	b->data[b->slen] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  int bJustifyLeft (bstring b, int space)
- *
- *  Left justify a string.
- */
-int bJustifyLeft (bstring b, int space) {
-int j, i, s, t;
-unsigned char c = (unsigned char) space;
-
-	if (b == NULL || b->slen < 0 || b->mlen < b->slen) return -__LINE__;
-	if (space != (int) c) return BSTR_OK;
-
-	for (s=j=i=0; i < b->slen; i++) {
-		t = s;
-		s = c != (b->data[j] = b->data[i]);
-		j += (t|s);
-	}
-	if (j > 0 && b->data[j-1] == c) j--;
-
-	b->data[j] = (unsigned char) '\0';
-	b->slen = j;
-	return BSTR_OK;
-}
-
-/*  int bJustifyRight (bstring b, int width, int space)
- *
- *  Right justify a string to within a given width.
- */
-int bJustifyRight (bstring b, int width, int space) {
-int ret;
-	if (width <= 0) return -__LINE__;
-	if (0 > (ret = bJustifyLeft (b, space))) return ret;
-	if (b->slen <= width)
-		return bInsertChrs (b, 0, width - b->slen, (unsigned char) space, (unsigned char) space);
-	return BSTR_OK;
-}
-
-/*  int bJustifyCenter (bstring b, int width, int space)
- *
- *  Center a string's non-white space characters to within a given width by
- *  inserting whitespaces at the beginning.
- */
-int bJustifyCenter (bstring b, int width, int space) {
-int ret;
-	if (width <= 0) return -__LINE__;
-	if (0 > (ret = bJustifyLeft (b, space))) return ret;
-	if (b->slen <= width)
-		return bInsertChrs (b, 0, (width - b->slen + 1) >> 1, (unsigned char) space, (unsigned char) space);
-	return BSTR_OK;
-}
-
-/*  int bJustifyMargin (bstring b, int width, int space)
- *
- *  Stretch a string to flush against left and right margins by evenly
- *  distributing additional white space between words.  If the line is too
- *  long to be margin justified, it is left justified.
- */
-int bJustifyMargin (bstring b, int width, int space) {
-struct bstrList * sl;
-int i, l, c;
-
-	if (b == NULL || b->slen < 0 || b->mlen == 0 || b->mlen < b->slen) return -__LINE__;
-	if (NULL == (sl = bsplit (b, (unsigned char) space))) return -__LINE__;
-	for (l=c=i=0; i < sl->qty; i++) {
-		if (sl->entry[i]->slen > 0) {
-			c ++;
-			l += sl->entry[i]->slen;
-		}
-	}
-
-	if (l + c >= width || c < 2) {
-		bstrListDestroy (sl);
-		return bJustifyLeft (b, space);
-	}
-
-	b->slen = 0;
-	for (i=0; i < sl->qty; i++) {
-		if (sl->entry[i]->slen > 0) {
-			if (b->slen > 0) {
-				int s = (width - l + (c / 2)) / c;
-				bInsertChrs (b, b->slen, s, (unsigned char) space, (unsigned char) space);
-				l += s;
-			}
-			bconcat (b, sl->entry[i]);
-			c--;
-			if (c <= 0) break;
-		}
-	}
-
-	bstrListDestroy (sl);
-	return BSTR_OK;
-}
-
-static size_t readNothing (void *buff, size_t elsize, size_t nelem, void *parm) {
-	buff = buff;
-	elsize = elsize;
-	nelem = nelem;
-	parm = parm;
-	return 0; /* Immediately indicate EOF. */
-}
-
-/*  struct bStream * bsFromBstr (const_bstring b);
- *
- *  Create a bStream whose contents are a copy of the bstring passed in.
- *  This allows the use of all the bStream APIs with bstrings.
- */
-struct bStream * bsFromBstr (const_bstring b) {
-struct bStream * s = bsopen ((bNread) readNothing, NULL);
-	bsunread (s, b); /* Push the bstring data into the empty bStream. */
-	return s;
-}
-
-static size_t readRef (void *buff, size_t elsize, size_t nelem, void *parm) {
-struct tagbstring * t = (struct tagbstring *) parm;
-size_t tsz = elsize * nelem;
-
-	if (tsz > (size_t) t->slen) tsz = (size_t) t->slen;
-	if (tsz > 0) {
-		memcpy (buff, t->data, tsz);
-		t->slen -= (int) tsz;
-		t->data += tsz;
-		return tsz / elsize;
-	}
-	return 0;
-}
-
-/*  The "by reference" version of the above function.  This function puts
- *  a number of restrictions on the call site (the passed in struct 
- *  tagbstring *will* be modified by this function, and the source data
- *  must remain alive and constant for the lifetime of the bStream).  
- *  Hence it is not presented as an extern.
- */
-static struct bStream * bsFromBstrRef (struct tagbstring * t) {
-	if (!t) return NULL;
-	return bsopen ((bNread) readRef, t);
-}
-
-/*  char * bStr2NetStr (const_bstring b)
- *
- *  Convert a bstring to a netstring.  See 
- *  http://cr.yp.to/proto/netstrings.txt for a description of netstrings.
- *  Note: 1) The value returned should be freed with a call to bcstrfree() at 
- *           the point when it will no longer be referenced to avoid a memory 
- *           leak.
- *        2) If the returned value is non-NULL, then it also '\0' terminated
- *           in the character position one past the "," terminator.
- */
-char * bStr2NetStr (const_bstring b) {
-char strnum[sizeof (b->slen) * 3 + 1];
-bstring s;
-unsigned char * buff;
-
-	if (b == NULL || b->data == NULL || b->slen < 0) return NULL;
-	sprintf (strnum, "%d:", b->slen);
-	if (NULL == (s = bfromcstr (strnum))
-	 || bconcat (s, b) == BSTR_ERR || bconchar (s, (char) ',') == BSTR_ERR) {
-		bdestroy (s);
-		return NULL;
-	}
-	buff = s->data;
-	bcstrfree ((char *) s);
-	return (char *) buff;
-}
-
-/*  bstring bNetStr2Bstr (const char * buf)
- *
- *  Convert a netstring to a bstring.  See 
- *  http://cr.yp.to/proto/netstrings.txt for a description of netstrings.
- *  Note that the terminating "," *must* be present, however a following '\0'
- *  is *not* required.
- */
-bstring bNetStr2Bstr (const char * buff) {
-int i, x;
-bstring b;
-	if (buff == NULL) return NULL;
-	x = 0;
-	for (i=0; buff[i] != ':'; i++) {
-		unsigned int v = buff[i] - '0';
-		if (v > 9 || x > ((INT_MAX - (signed int)v) / 10)) return NULL;
-		x = (x * 10) + v;
-	}
-
-	/* This thing has to be properly terminated */
-	if (buff[i + 1 + x] != ',') return NULL;
-
-	if (NULL == (b = bfromcstr (""))) return NULL;
-	if (balloc (b, x + 1) != BSTR_OK)  {
-		bdestroy (b);
-		return NULL;
-	}
-	memcpy (b->data, buff + i + 1, x);
-	b->data[x] = (unsigned char) '\0';
-	b->slen = x;
-	return b;
-}
-
-static char b64ETable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-/*  bstring bBase64Encode (const_bstring b)
- *
- *  Generate a base64 encoding.  See: RFC1341
- */
-bstring bBase64Encode (const_bstring b) {
-int i, c0, c1, c2, c3;
-bstring out;
-
-	if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
-
-	out = bfromcstr ("");
-	for (i=0; i + 2 < b->slen; i += 3) {
-		if (i && ((i % 57) == 0)) {
-			if (bconchar (out, (char) '\015') < 0 || bconchar (out, (char) '\012') < 0) {
-				bdestroy (out);
-				return NULL;
-			}
-		}
-		c0 = b->data[i] >> 2;
-		c1 = ((b->data[i] << 4) |
-		      (b->data[i+1] >> 4)) & 0x3F;
-		c2 = ((b->data[i+1] << 2) |
-		      (b->data[i+2] >> 6)) & 0x3F;
-		c3 = b->data[i+2] & 0x3F;
-		if (bconchar (out, b64ETable[c0]) < 0 ||
-			bconchar (out, b64ETable[c1]) < 0 ||
-			bconchar (out, b64ETable[c2]) < 0 ||
-			bconchar (out, b64ETable[c3]) < 0) {
-			bdestroy (out);
-			return NULL;
-		}
-	}
-
-	if (i && ((i % 57) == 0)) {
-		if (bconchar (out, (char) '\015') < 0 || bconchar (out, (char) '\012') < 0) {
-			bdestroy (out);
-			return NULL;
-		}
-	}
-
-	switch (i + 2 - b->slen) {
-		case 0:	c0 = b->data[i] >> 2;
-				c1 = ((b->data[i] << 4) |
-					  (b->data[i+1] >> 4)) & 0x3F;
-				c2 = (b->data[i+1] << 2) & 0x3F;
-			if (bconchar (out, b64ETable[c0]) < 0 ||
-				bconchar (out, b64ETable[c1]) < 0 ||
-				bconchar (out, b64ETable[c2]) < 0 ||
-				bconchar (out, (char) '=') < 0) {
-				bdestroy (out);
-				return NULL;
-			}
-			break;
-		case 1:	c0 =  b->data[i] >> 2;
-				c1 = (b->data[i] << 4) & 0x3F;
-			if (bconchar (out, b64ETable[c0]) < 0 ||
-				bconchar (out, b64ETable[c1]) < 0 ||
-				bconchar (out, (char) '=') < 0 ||
-				bconchar (out, (char) '=') < 0) {
-				bdestroy (out);
-				return NULL;
-			}
-			break;
-		case 2: break;
-	}
-
-	return out;
-}
-
-#define B64_PAD (-2)
-#define B64_ERR (-1)
-
-static int base64DecodeSymbol (unsigned char alpha) {
-   if      ((alpha >= 'A') && (alpha <= 'Z')) return (int)(alpha - 'A');
-   else if ((alpha >= 'a') && (alpha <= 'z'))
-        return 26 + (int)(alpha - 'a');
-   else if ((alpha >= '0') && (alpha <= '9'))
-        return 52 + (int)(alpha - '0');
-   else if (alpha == '+') return 62;
-   else if (alpha == '/') return 63;
-   else if (alpha == '=') return B64_PAD;
-   else                   return B64_ERR;
-}
-
-/*  bstring bBase64DecodeEx (const_bstring b, int * boolTruncError)
- *
- *  Decode a base64 block of data.  All MIME headers are assumed to have been
- *  removed.  See: RFC1341
- */
-bstring bBase64DecodeEx (const_bstring b, int * boolTruncError) {
-int i, v;
-unsigned char c0, c1, c2;
-bstring out;
-
-	if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
-	if (boolTruncError) *boolTruncError = 0;
-	out = bfromcstr ("");
-	i = 0;
-	for (;;) {
-		do {
-			if (i >= b->slen) return out;
-			if (b->data[i] == '=') {	/* Bad "too early" truncation */
-				if (boolTruncError) {
-					*boolTruncError = 1;
-					return out;
-				}
-				bdestroy (out);
-				return NULL;
-			}
-			v = base64DecodeSymbol (b->data[i]);
-			i++;
-		} while (v < 0);
-		c0 = (unsigned char) (v << 2);
-		do {
-			if (i >= b->slen || b->data[i] == '=') {	/* Bad "too early" truncation */
-				if (boolTruncError) {
-					*boolTruncError = 1;
-					return out;
-				}
-				bdestroy (out);
-				return NULL;
-			}
-			v = base64DecodeSymbol (b->data[i]);
-			i++;
-		} while (v < 0);
-		c0 |= (unsigned char) (v >> 4);
-		c1  = (unsigned char) (v << 4);
-		do {
-			if (i >= b->slen) {
-				if (boolTruncError) {
-					*boolTruncError = 1;
-					return out;
-				}
-				bdestroy (out);
-				return NULL;
-			}
-			if (b->data[i] == '=') {
-				i++;
-				if (i >= b->slen || b->data[i] != '=' || bconchar (out, c0) < 0) {
-					if (boolTruncError) {
-						*boolTruncError = 1;
-						return out;
-					}
-					bdestroy (out); /* Missing "=" at the end. */
-					return NULL;
-				}
-				return out;
-			}
-			v = base64DecodeSymbol (b->data[i]);
-			i++;
-		} while (v < 0);
-		c1 |= (unsigned char) (v >> 2);
-		c2  = (unsigned char) (v << 6);
-		do {
-			if (i >= b->slen) {
-				if (boolTruncError) {
-					*boolTruncError = 1;
-					return out;
-				}
-				bdestroy (out);
-				return NULL;
-			}
-			if (b->data[i] == '=') {
-				if (bconchar (out, c0) < 0 || bconchar (out, c1) < 0) {
-					if (boolTruncError) {
-						*boolTruncError = 1;
-						return out;
-					}
-					bdestroy (out);
-					return NULL;
-				}
-				if (boolTruncError) *boolTruncError = 0;
-				return out;
-			}
-			v = base64DecodeSymbol (b->data[i]);
-			i++;
-		} while (v < 0);
-		c2 |= (unsigned char) (v);
-		if (bconchar (out, c0) < 0 ||
-			bconchar (out, c1) < 0 ||
-			bconchar (out, c2) < 0) {
-			if (boolTruncError) {
-				*boolTruncError = -1;
-				return out;
-			}
-			bdestroy (out);
-			return NULL;
-		}
-	}
-}
-
-#define UU_DECODE_BYTE(b) (((b) == (signed int)'`') ? 0 : (b) - (signed int)' ')
-
-struct bUuInOut {
-	bstring src, dst;
-	int * badlines;
-};
-
-#define UU_MAX_LINELEN 45
-
-static int bUuDecLine (void * parm, int ofs, int len) {
-struct bUuInOut * io = (struct bUuInOut *) parm;
-bstring s = io->src;
-bstring t = io->dst;
-int i, llen, otlen, ret, c0, c1, c2, c3, d0, d1, d2, d3;
-
-	if (len == 0) return 0;
-	llen = UU_DECODE_BYTE (s->data[ofs]);
-	ret = 0;
-
-	otlen = t->slen;
-
-	if (((unsigned) llen) > UU_MAX_LINELEN) { ret = -__LINE__; 
-		goto bl;
-	}
-
-	llen += t->slen;
-
-	for (i=1; i < s->slen && t->slen < llen;i += 4) {
-		unsigned char outoctet[3];
-		c0 = UU_DECODE_BYTE (d0 = (int) bchare (s, i+ofs+0, ' ' - 1));
-		c1 = UU_DECODE_BYTE (d1 = (int) bchare (s, i+ofs+1, ' ' - 1));
-		c2 = UU_DECODE_BYTE (d2 = (int) bchare (s, i+ofs+2, ' ' - 1));
-		c3 = UU_DECODE_BYTE (d3 = (int) bchare (s, i+ofs+3, ' ' - 1));
-
-		if (((unsigned) (c0|c1) >= 0x40)) { if (!ret) ret = -__LINE__;
-			if (d0 > 0x60 || (d0 < (' ' - 1) && !isspace (d0)) ||
-			    d1 > 0x60 || (d1 < (' ' - 1) && !isspace (d1))) {
-				t->slen = otlen;
-				goto bl;
-			}
-			c0 = c1 = 0;
-		}
-		outoctet[0] = (unsigned char) ((c0 << 2) | ((unsigned) c1 >> 4));
-		if (t->slen+1 >= llen) {
-			if (0 > bconchar (t, (char) outoctet[0])) return -__LINE__;
-			break;
-		}
-		if ((unsigned) c2 >= 0x40) { if (!ret) ret = -__LINE__;
-			if (d2 > 0x60 || (d2 < (' ' - 1) && !isspace (d2))) {
-				t->slen = otlen;
-				goto bl;
-			}
-			c2 = 0;
-		}
-		outoctet[1] = (unsigned char) ((c1 << 4) | ((unsigned) c2 >> 2));
-		if (t->slen+2 >= llen) {
-			if (0 > bcatblk (t, outoctet, 2)) return -__LINE__;
-			break;
-		}
-		if ((unsigned) c3 >= 0x40) { if (!ret) ret = -__LINE__;
-			if (d3 > 0x60 || (d3 < (' ' - 1) && !isspace (d3))) {
-				t->slen = otlen;
-				goto bl;
-			}
-			c3 = 0;
-		}
-		outoctet[2] = (unsigned char) ((c2 << 6) | ((unsigned) c3));
-		if (0 > bcatblk (t, outoctet, 3)) return -__LINE__;
-	}
-	if (t->slen < llen) { if (0 == ret) ret = -__LINE__;
-		t->slen = otlen;
-	}
-	bl:;
-	if (ret && io->badlines) {
-		(*io->badlines)++;
-		return 0;
-	}
-	return ret;
-}
-
-/*  bstring bUuDecodeEx (const_bstring src, int * badlines)
- *
- *  Performs a UUDecode of a block of data.  If there are errors in the
- *  decoding, they are counted up and returned in "badlines", if badlines is
- *  not NULL. It is assumed that the "begin" and "end" lines have already 
- *  been stripped off.  The potential security problem of writing the 
- *  filename in the begin line is something that is beyond the scope of a 
- *  portable library.
- */
-
-#ifdef _MSC_VER
-#pragma warning(disable:4204)
-#endif
-
-bstring bUuDecodeEx (const_bstring src, int * badlines) {
-struct tagbstring t;
-struct bStream * s;
-struct bStream * d;
-bstring b;
-
-	if (!src) return NULL;
-	t = *src; /* Short lifetime alias to header of src */
-	s = bsFromBstrRef (&t); /* t is undefined after this */
-	if (!s) return NULL;
-	d = bsUuDecode (s, badlines);
-	b = bfromcstralloc (256, "");
-	if (NULL == b || 0 > bsread (b, d, INT_MAX)) {
-		bdestroy (b);
-		bsclose (d);
-		bsclose (s);
-		return NULL;
-	}
-	return b;
-}
-
-struct bsUuCtx {
-	struct bUuInOut io;
-	struct bStream * sInp;
-};
-
-static size_t bsUuDecodePart (void *buff, size_t elsize, size_t nelem, void *parm) {
-static struct tagbstring eol = bsStatic ("\r\n");
-struct bsUuCtx * luuCtx = (struct bsUuCtx *) parm;
-size_t tsz;
-int l, lret;
-
-	if (NULL == buff || NULL == parm) return 0;
-	tsz = elsize * nelem;
-
-	CheckInternalBuffer:;
-	/* If internal buffer has sufficient data, just output it */
-	if (((size_t) luuCtx->io.dst->slen) > tsz) {
-		memcpy (buff, luuCtx->io.dst->data, tsz);
-		bdelete (luuCtx->io.dst, 0, (int) tsz);
-		return nelem;
-	}
-
-	DecodeMore:;
-	if (0 <= (l = binchr (luuCtx->io.src, 0, &eol))) {
-		int ol = 0;
-		struct tagbstring t;
-		bstring s = luuCtx->io.src;
-		luuCtx->io.src = &t;
-
-		do {
-			if (l > ol) {
-				bmid2tbstr (t, s, ol, l - ol);
-				lret = bUuDecLine (&luuCtx->io, 0, t.slen);
-				if (0 > lret) {
-					luuCtx->io.src = s;
-					goto Done;
-				}
-			}
-			ol = l + 1;
-			if (((size_t) luuCtx->io.dst->slen) > tsz) break;
-			l = binchr (s, ol, &eol);
-		} while (BSTR_ERR != l);
-		bdelete (s, 0, ol);
-		luuCtx->io.src = s;
-		goto CheckInternalBuffer;
-	}
-
-	if (BSTR_ERR != bsreada (luuCtx->io.src, luuCtx->sInp, bsbufflength (luuCtx->sInp, BSTR_BS_BUFF_LENGTH_GET))) {
-		goto DecodeMore;
-	}
-
-	bUuDecLine (&luuCtx->io, 0, luuCtx->io.src->slen);
-
-	Done:;
-	/* Output any lingering data that has been translated */
-	if (((size_t) luuCtx->io.dst->slen) > 0) {
-		if (((size_t) luuCtx->io.dst->slen) > tsz) goto CheckInternalBuffer;
-		memcpy (buff, luuCtx->io.dst->data, luuCtx->io.dst->slen);
-		tsz = luuCtx->io.dst->slen / elsize;
-		luuCtx->io.dst->slen = 0;
-		if (tsz > 0) return tsz;
-	}
-
-	/* Deallocate once EOF becomes triggered */
-	bdestroy (luuCtx->io.dst);
-	bdestroy (luuCtx->io.src);
-	free (luuCtx);
-	return 0;
-}
-
-/*  bStream * bsUuDecode (struct bStream * sInp, int * badlines)
- *
- *  Creates a bStream which performs the UUDecode of an an input stream.  If
- *  there are errors in the decoding, they are counted up and returned in 
- *  "badlines", if badlines is not NULL. It is assumed that the "begin" and 
- *  "end" lines have already been stripped off.  The potential security 
- *  problem of writing the filename in the begin line is something that is 
- *  beyond the scope of a portable library.
- */
-
-struct bStream * bsUuDecode (struct bStream * sInp, int * badlines) {
-struct bsUuCtx * luuCtx = (struct bsUuCtx *) malloc (sizeof (struct bsUuCtx));
-struct bStream * sOut;
-
-	if (NULL == luuCtx) return NULL;
-
-	luuCtx->io.src = bfromcstr ("");
-	luuCtx->io.dst = bfromcstr ("");
-	if (NULL == luuCtx->io.dst || NULL == luuCtx->io.src) {
-		CleanUpFailureToAllocate:;
-		bdestroy (luuCtx->io.dst);
-		bdestroy (luuCtx->io.src);
-		free (luuCtx);
-		return NULL;
-	}
-	luuCtx->io.badlines = badlines;
-	if (badlines) *badlines = 0;
-
-	luuCtx->sInp = sInp;
-
-	sOut = bsopen ((bNread) bsUuDecodePart, luuCtx);
-	if (NULL == sOut) goto CleanUpFailureToAllocate;
-	return sOut;
-}
-
-#define UU_ENCODE_BYTE(b) (char) (((b) == 0) ? '`' : ((b) + ' '))
-
-/*  bstring bUuEncode (const_bstring src)
- *
- *  Performs a UUEncode of a block of data.  The "begin" and "end" lines are 
- *  not appended.
- */
-bstring bUuEncode (const_bstring src) {
-bstring out;
-int i, j, jm;
-unsigned int c0, c1, c2;
-	if (src == NULL || src->slen < 0 || src->data == NULL) return NULL;
-	if ((out = bfromcstr ("")) == NULL) return NULL;
-	for (i=0; i < src->slen; i += UU_MAX_LINELEN) {
-		if ((jm = i + UU_MAX_LINELEN) > src->slen) jm = src->slen;
-		if (bconchar (out, UU_ENCODE_BYTE (jm - i)) < 0) {
-			bstrFree (out);
-			break;
-		}
-		for (j = i; j < jm; j += 3) {
-			c0 = (unsigned int) bchar (src, j    );
-			c1 = (unsigned int) bchar (src, j + 1);
-			c2 = (unsigned int) bchar (src, j + 2);
-			if (bconchar (out, UU_ENCODE_BYTE ( (c0 & 0xFC) >> 2)) < 0 ||
-			    bconchar (out, UU_ENCODE_BYTE (((c0 & 0x03) << 4) | ((c1 & 0xF0) >> 4))) < 0 ||
-			    bconchar (out, UU_ENCODE_BYTE (((c1 & 0x0F) << 2) | ((c2 & 0xC0) >> 6))) < 0 ||
-			    bconchar (out, UU_ENCODE_BYTE ( (c2 & 0x3F))) < 0) {
-				bstrFree (out);
-				goto End;
-			}
-		}
-		if (bconchar (out, (char) '\r') < 0 || bconchar (out, (char) '\n') < 0) {
-			bstrFree (out);
-			break;
-		}
-	}
-	End:;
-	return out;
-}
-
-/*  bstring bYEncode (const_bstring src)
- *
- *  Performs a YEncode of a block of data.  No header or tail info is 
- *  appended.  See: http://www.yenc.org/whatis.htm and 
- *  http://www.yenc.org/yenc-draft.1.3.txt
- */
-bstring bYEncode (const_bstring src) {
-int i;
-bstring out;
-unsigned char c;
-
-	if (src == NULL || src->slen < 0 || src->data == NULL) return NULL;
-	if ((out = bfromcstr ("")) == NULL) return NULL;
-	for (i=0; i < src->slen; i++) {
-		c = (unsigned char)(src->data[i] + 42);
-		if (c == '=' || c == '\0' || c == '\r' || c == '\n') {
-			if (0 > bconchar (out, (char) '=')) {
-				bdestroy (out);
-				return NULL;
-			}
-			c += (unsigned char) 64;
-		}
-		if (0 > bconchar (out, c)) {
-			bdestroy (out);
-			return NULL;
-		}
-	}
-	return out;
-}
-
-/*  bstring bYDecode (const_bstring src)
- *
- *  Performs a YDecode of a block of data.  See: 
- *  http://www.yenc.org/whatis.htm and http://www.yenc.org/yenc-draft.1.3.txt
- */
-#define MAX_OB_LEN (64)
-
-bstring bYDecode (const_bstring src) {
-int i;
-bstring out;
-unsigned char c;
-unsigned char octetbuff[MAX_OB_LEN];
-int obl;
-
-	if (src == NULL || src->slen < 0 || src->data == NULL) return NULL;
-	if ((out = bfromcstr ("")) == NULL) return NULL;
-
-	obl = 0;
-
-	for (i=0; i < src->slen; i++) {
-		if ('=' == (c = src->data[i])) { /* The = escape mode */
-			i++;
-			if (i >= src->slen) {
-				bdestroy (out);
-				return NULL;
-			}
-			c = (unsigned char) (src->data[i] - 64);
-		} else {
-			if ('\0' == c) {
-				bdestroy (out);
-				return NULL;
-			}
-
-			/* Extraneous CR/LFs are to be ignored. */
-			if (c == '\r' || c == '\n') continue;
-		}
-
-		octetbuff[obl] = (unsigned char) ((int) c - 42);
-		obl++;
-
-		if (obl >= MAX_OB_LEN) {
-			if (0 > bcatblk (out, octetbuff, obl)) {
-				bdestroy (out);
-				return NULL;
-			}
-			obl = 0;
-		}
-	}
-
-	if (0 > bcatblk (out, octetbuff, obl)) {
-		bdestroy (out);
-		out = NULL;
-	}
-	return out;
-}
-
-/*  bstring bStrfTime (const char * fmt, const struct tm * timeptr)
- *
- *  Takes a format string that is compatible with strftime and a struct tm
- *  pointer, formats the time according to the format string and outputs
- *  the bstring as a result. Note that if there is an early generation of a 
- *  '\0' character, the bstring will be truncated to this end point.
- */
-bstring bStrfTime (const char * fmt, const struct tm * timeptr) {
-#if defined (__TURBOC__) && !defined (__BORLANDC__)
-static struct tagbstring ns = bsStatic ("bStrfTime Not supported");
-	fmt = fmt;
-	timeptr = timeptr;
-	return &ns;
-#else
-bstring buff;
-int n;
-size_t r;
-
-	if (fmt == NULL) return NULL;
-
-	/* Since the length is not determinable beforehand, a search is
-	   performed using the truncating "strftime" call on increasing 
-	   potential sizes for the output result. */
-
-	if ((n = (int) (2*strlen (fmt))) < 16) n = 16;
-	buff = bfromcstralloc (n+2, "");
-
-	for (;;) {
-		if (BSTR_OK != balloc (buff, n + 2)) {
-			bdestroy (buff);
-			return NULL;
-		}
-
-		r = strftime ((char *) buff->data, n + 1, fmt, timeptr);
-
-		if (r > 0) {
-			buff->slen = (int) r;
-			break;
-		}
-
-		n += n;
-	}
-
-	return buff;
-#endif
-}
-
-/*  int bSetCstrChar (bstring a, int pos, char c)
- *
- *  Sets the character at position pos to the character c in the bstring a.
- *  If the character c is NUL ('\0') then the string is truncated at this
- *  point.  Note: this does not enable any other '\0' character in the bstring
- *  as terminator indicator for the string.  pos must be in the position 
- *  between 0 and b->slen inclusive, otherwise BSTR_ERR will be returned.
- */
-int bSetCstrChar (bstring b, int pos, char c) {
-	if (NULL == b || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen)
-		return BSTR_ERR;
-	if (pos < 0 || pos > b->slen) return BSTR_ERR;
-
-	if (pos == b->slen) {
-		if ('\0' != c) return bconchar (b, c);
-		return 0;
-	}
-
-	b->data[pos] = (unsigned char) c;
-	if ('\0' == c) b->slen = pos;
-
-	return 0;
-}
-
-/*  int bSetChar (bstring b, int pos, char c)
- *
- *  Sets the character at position pos to the character c in the bstring a.
- *  The string is not truncated if the character c is NUL ('\0').  pos must
- *  be in the position between 0 and b->slen inclusive, otherwise BSTR_ERR
- *  will be returned.
- */
-int bSetChar (bstring b, int pos, char c) {
-	if (NULL == b || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen)
-		return BSTR_ERR;
-	if (pos < 0 || pos > b->slen) return BSTR_ERR;
-
-	if (pos == b->slen) {
-		return bconchar (b, c);
-	}
-
-	b->data[pos] = (unsigned char) c;
-	return 0;
-}
-
-#define INIT_SECURE_INPUT_LENGTH (256)
-
-/*  bstring bSecureInput (int maxlen, int termchar, 
- *                        bNgetc vgetchar, void * vgcCtx)
- *
- *  Read input from an abstracted input interface, for a length of at most
- *  maxlen characters.  If maxlen <= 0, then there is no length limit put
- *  on the input.  The result is terminated early if vgetchar() return EOF
- *  or the user specified value termchar.
- *
- */
-bstring bSecureInput (int maxlen, int termchar, bNgetc vgetchar, void * vgcCtx) {
-int i, m, c;
-bstring b, t;
-
-	if (!vgetchar) return NULL;
-
-	b = bfromcstralloc (INIT_SECURE_INPUT_LENGTH, "");
-	if ((c = UCHAR_MAX + 1) == termchar) c++;
-
-	for (i=0; ; i++) {
-		if (termchar == c || (maxlen > 0 && i >= maxlen)) c = EOF;
-		else c = vgetchar (vgcCtx);
-
-		if (EOF == c) break;
-
-		if (i+1 >= b->mlen) {
-
-			/* Double size, but deal with unusual case of numeric
-			   overflows */
-
-			if ((m = b->mlen << 1)   <= b->mlen &&
-			    (m = b->mlen + 1024) <= b->mlen &&
-			    (m = b->mlen + 16)   <= b->mlen &&
-			    (m = b->mlen + 1)    <= b->mlen) t = NULL;
-			else t = bfromcstralloc (m, "");
-
-			if (t) memcpy (t->data, b->data, i);
-			bSecureDestroy (b); /* Cleanse previous buffer */
-			b = t;
-			if (!b) return b;
-		}
-
-		b->data[i] = (unsigned char) c;
-	}
-
-	b->slen = i;
-	b->data[i] = (unsigned char) '\0';
-	return b;
-}
-
-#define BWS_BUFF_SZ (1024)
-
-struct bwriteStream {
-    bstring buff;    /* Buffer for underwrites                   */
-    void * parm;     /* The stream handle for core stream        */
-    bNwrite writeFn; /* fwrite work-a-like fnptr for core stream */
-    int isEOF;       /* track stream's EOF state                 */
-    int minBuffSz;
-};
-
-/*  struct bwriteStream * bwsOpen (bNwrite writeFn, void * parm)
- *
- *  Wrap a given open stream (described by a fwrite work-a-like function 
- *  pointer and stream handle) into an open bwriteStream suitable for write
- *  streaming functions.
- */
-struct bwriteStream * bwsOpen (bNwrite writeFn, void * parm) {
-struct bwriteStream * ws;
-
-	if (NULL == writeFn) return NULL;
-	ws = (struct bwriteStream *) malloc (sizeof (struct bwriteStream));
-	if (ws) {
-		if (NULL == (ws->buff = bfromcstr (""))) {
-			free (ws);
-			ws = NULL;
-		} else {
-			ws->parm = parm;
-			ws->writeFn = writeFn;
-			ws->isEOF = 0;
-			ws->minBuffSz = BWS_BUFF_SZ;
-		}
-	}
-	return ws;
-}
-
-#define internal_bwswriteout(ws,b) { \
-	if ((b)->slen > 0) { \
-		if (1 != (ws->writeFn ((b)->data, (b)->slen, 1, ws->parm))) { \
-			ws->isEOF = 1; \
-			return BSTR_ERR; \
-		} \
-	} \
-}
-
-/*  int bwsWriteFlush (struct bwriteStream * ws)
- *
- *  Force any pending data to be written to the core stream.
- */
-int bwsWriteFlush (struct bwriteStream * ws) {
-	if (NULL == ws || ws->isEOF || 0 >= ws->minBuffSz || 
-	    NULL == ws->writeFn || NULL == ws->buff) return BSTR_ERR;
-	internal_bwswriteout (ws, ws->buff);
-	ws->buff->slen = 0;
-	return 0;
-}
-
-/*  int bwsWriteBstr (struct bwriteStream * ws, const_bstring b)
- *
- *  Send a bstring to a bwriteStream.  If the stream is at EOF BSTR_ERR is
- *  returned.  Note that there is no deterministic way to determine the exact
- *  cut off point where the core stream stopped accepting data.
- */
-int bwsWriteBstr (struct bwriteStream * ws, const_bstring b) {
-struct tagbstring t;
-int l;
-
-	if (NULL == ws || NULL == b || NULL == ws->buff ||
-	    ws->isEOF || 0 >= ws->minBuffSz || NULL == ws->writeFn)
-		return BSTR_ERR;
-
-	/* Buffer prepacking optimization */
-	if (b->slen > 0 && ws->buff->mlen - ws->buff->slen > b->slen) {
-		static struct tagbstring empty = bsStatic ("");
-		if (0 > bconcat (ws->buff, b)) return BSTR_ERR;
-		return bwsWriteBstr (ws, &empty);
-	}
-
-	if (0 > (l = ws->minBuffSz - ws->buff->slen)) {
-		internal_bwswriteout (ws, ws->buff);
-		ws->buff->slen = 0;
-		l = ws->minBuffSz;
-	}
-
-	if (b->slen < l) return bconcat (ws->buff, b);
-
-	if (0 > bcatblk (ws->buff, b->data, l)) return BSTR_ERR;
-	internal_bwswriteout (ws, ws->buff);
-	ws->buff->slen = 0;
-
-	bmid2tbstr (t, (bstring) b, l, b->slen);
-
-	if (t.slen >= ws->minBuffSz) {
-		internal_bwswriteout (ws, &t);
-		return 0;
-	}
-
-	return bassign (ws->buff, &t);
-}
-
-/*  int bwsWriteBlk (struct bwriteStream * ws, void * blk, int len)
- *
- *  Send a block of data a bwriteStream.  If the stream is at EOF BSTR_ERR is 
- *  returned.
- */
-int bwsWriteBlk (struct bwriteStream * ws, void * blk, int len) {
-struct tagbstring t;
-	if (NULL == blk || len < 0) return BSTR_ERR;
-	blk2tbstr (t, blk, len);
-	return bwsWriteBstr (ws, &t);
-}
-
-/*  int bwsIsEOF (const struct bwriteStream * ws)
- *
- *  Returns 0 if the stream is currently writable, 1 if the core stream has 
- *  responded by not accepting the previous attempted write.
- */
-int bwsIsEOF (const struct bwriteStream * ws) {
-	if (NULL == ws || NULL == ws->buff || 0 > ws->minBuffSz || 
-	    NULL == ws->writeFn) return BSTR_ERR;
-	return ws->isEOF;
-}
-
-/*  int bwsBuffLength (struct bwriteStream * ws, int sz)
- *
- *  Set the length of the buffer used by the bwsStream.  If sz is zero, the 
- *  length is not set.  This function returns with the previous length.
- */
-int bwsBuffLength (struct bwriteStream * ws, int sz) {
-int oldSz;
-	if (ws == NULL || sz < 0) return BSTR_ERR;
-	oldSz = ws->minBuffSz;
-	if (sz > 0) ws->minBuffSz = sz;
-	return oldSz;
-}
-
-/*  void * bwsClose (struct bwriteStream * s)
- *
- *  Close the bwriteStream, and return the handle to the stream that was 
- *  originally used to open the given stream.  Note that even if the stream
- *  is at EOF it still needs to be closed with a call to bwsClose.
- */
-void * bwsClose (struct bwriteStream * ws) {
-void * parm;
-	if (NULL == ws || NULL == ws->buff || 0 >= ws->minBuffSz || 
-	    NULL == ws->writeFn) return NULL;
-	bwsWriteFlush (ws);
-	parm = ws->parm;
-	ws->parm = NULL;
-	ws->minBuffSz = -1;
-	ws->writeFn = NULL;
-	bstrFree (ws->buff);
-	free (ws);
-	return parm;
-}
-
diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/bstraux.h b/build/tools/HLSLcc/May_2014/src/cbstring/bstraux.h
deleted file mode 100644
index 17d4ea7..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/bstraux.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2010, and is covered by either the 3-clause 
- * BSD open source license or GPL v2.0. Refer to the accompanying documentation 
- * for details on usage and license.
- */
-
-/*
- * bstraux.h
- *
- * This file is not a necessary part of the core bstring library itself, but
- * is just an auxilliary module which includes miscellaneous or trivial 
- * functions.
- */
-
-#ifndef BSTRAUX_INCLUDE
-#define BSTRAUX_INCLUDE
-
-#include <time.h>
-#include "bstrlib.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Safety mechanisms */
-#define bstrDeclare(b)               bstring (b) = NULL; 
-#define bstrFree(b)                  {if ((b) != NULL && (b)->slen >= 0 && (b)->mlen >= (b)->slen) { bdestroy (b); (b) = NULL; }}
-
-/* Backward compatibilty with previous versions of Bstrlib */
-#define bAssign(a,b)                 ((bassign)((a), (b)))
-#define bSubs(b,pos,len,a,c)         ((breplace)((b),(pos),(len),(a),(unsigned char)(c)))
-#define bStrchr(b,c)                 ((bstrchr)((b), (c)))
-#define bStrchrFast(b,c)             ((bstrchr)((b), (c)))
-#define bCatCstr(b,s)                ((bcatcstr)((b), (s)))
-#define bCatBlk(b,s,len)             ((bcatblk)((b),(s),(len)))
-#define bCatStatic(b,s)              bCatBlk ((b), ("" s ""), sizeof (s) - 1)
-#define bTrunc(b,n)                  ((btrunc)((b), (n)))
-#define bReplaceAll(b,find,repl,pos) ((bfindreplace)((b),(find),(repl),(pos)))
-#define bUppercase(b)                ((btoupper)(b))
-#define bLowercase(b)                ((btolower)(b))
-#define bCaselessCmp(a,b)            ((bstricmp)((a), (b)))
-#define bCaselessNCmp(a,b,n)         ((bstrnicmp)((a), (b), (n)))
-#define bBase64Decode(b)             (bBase64DecodeEx ((b), NULL))
-#define bUuDecode(b)                 (bUuDecodeEx ((b), NULL))
-
-/* Unusual functions */
-extern struct bStream * bsFromBstr (const_bstring b);
-extern bstring bTail (bstring b, int n);
-extern bstring bHead (bstring b, int n);
-extern int bSetCstrChar (bstring a, int pos, char c);
-extern int bSetChar (bstring b, int pos, char c);
-extern int bFill (bstring a, char c, int len);
-extern int bReplicate (bstring b, int n);
-extern int bReverse (bstring b);
-extern int bInsertChrs (bstring b, int pos, int len, unsigned char c, unsigned char fill);
-extern bstring bStrfTime (const char * fmt, const struct tm * timeptr);
-#define bAscTime(t) (bStrfTime ("%c\n", (t)))
-#define bCTime(t)   ((t) ? bAscTime (localtime (t)) : NULL)
-
-/* Spacing formatting */
-extern int bJustifyLeft (bstring b, int space);
-extern int bJustifyRight (bstring b, int width, int space);
-extern int bJustifyMargin (bstring b, int width, int space);
-extern int bJustifyCenter (bstring b, int width, int space);
-
-/* Esoteric standards specific functions */
-extern char * bStr2NetStr (const_bstring b);
-extern bstring bNetStr2Bstr (const char * buf);
-extern bstring bBase64Encode (const_bstring b);
-extern bstring bBase64DecodeEx (const_bstring b, int * boolTruncError);
-extern struct bStream * bsUuDecode (struct bStream * sInp, int * badlines);
-extern bstring bUuDecodeEx (const_bstring src, int * badlines);
-extern bstring bUuEncode (const_bstring src);
-extern bstring bYEncode (const_bstring src);
-extern bstring bYDecode (const_bstring src);
-
-/* Writable stream */
-typedef int (* bNwrite) (const void * buf, size_t elsize, size_t nelem, void * parm);
-
-struct bwriteStream * bwsOpen (bNwrite writeFn, void * parm);
-int bwsWriteBstr (struct bwriteStream * stream, const_bstring b);
-int bwsWriteBlk (struct bwriteStream * stream, void * blk, int len);
-int bwsWriteFlush (struct bwriteStream * stream);
-int bwsIsEOF (const struct bwriteStream * stream);
-int bwsBuffLength (struct bwriteStream * stream, int sz);
-void * bwsClose (struct bwriteStream * stream);
-
-/* Security functions */
-#define bSecureDestroy(b) {	                                            \
-bstring bstr__tmp = (b);	                                            \
-	if (bstr__tmp && bstr__tmp->mlen > 0 && bstr__tmp->data) {          \
-	    (void) memset (bstr__tmp->data, 0, (size_t) bstr__tmp->mlen);   \
-	    bdestroy (bstr__tmp);                                           \
-	}                                                                   \
-}
-#define bSecureWriteProtect(t) {	                                              \
-	if ((t).mlen >= 0) {                                                          \
-	    if ((t).mlen > (t).slen)) {                                               \
-	        (void) memset ((t).data + (t).slen, 0, (size_t) (t).mlen - (t).slen); \
-	    }                                                                         \
-	    (t).mlen = -1;                                                            \
-	}                                                                             \
-}
-extern bstring bSecureInput (int maxlen, int termchar, 
-                             bNgetc vgetchar, void * vgcCtx);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/bstrlib.c b/build/tools/HLSLcc/May_2014/src/cbstring/bstrlib.c
deleted file mode 100644
index f7f57de..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/bstrlib.c
+++ /dev/null
@@ -1,2975 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2010, and is covered by either the 3-clause 
- * BSD open source license or GPL v2.0. Refer to the accompanying documentation 
- * for details on usage and license.
- */
-
-/*
- * bstrlib.c
- *
- * This file is the core module for implementing the bstring functions.
- */
-
-#include <stdio.h>
-#include <stddef.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include "bstrlib.h"
-#include "../internal_includes/hlslcc_malloc.h"
-
-/* Optionally include a mechanism for debugging memory */
-
-#if defined(MEMORY_DEBUG) || defined(BSTRLIB_MEMORY_DEBUG)
-#include "memdbg.h"
-#endif
-
-#ifndef bstr__alloc
-#define bstr__alloc(x) malloc (x)
-#endif
-
-#ifndef bstr__free
-#define bstr__free(p) free (p)
-#endif
-
-#ifndef bstr__realloc
-#define bstr__realloc(p,x) realloc ((p), (x))
-#endif
-
-#ifndef bstr__memcpy
-#define bstr__memcpy(d,s,l) memcpy ((d), (s), (l))
-#endif
-
-#ifndef bstr__memmove
-#define bstr__memmove(d,s,l) memmove ((d), (s), (l))
-#endif
-
-#ifndef bstr__memset
-#define bstr__memset(d,c,l) memset ((d), (c), (l))
-#endif
-
-#ifndef bstr__memcmp
-#define bstr__memcmp(d,c,l) memcmp ((d), (c), (l))
-#endif
-
-#ifndef bstr__memchr
-#define bstr__memchr(s,c,l) memchr ((s), (c), (l))
-#endif
-
-/* Just a length safe wrapper for memmove. */
-
-#define bBlockCopy(D,S,L) { if ((L) > 0) bstr__memmove ((D),(S),(L)); }
-
-/* Compute the snapped size for a given requested size.  By snapping to powers
-   of 2 like this, repeated reallocations are avoided. */
-static int snapUpSize (int i) {
-	if (i < 8) {
-		i = 8;
-	} else {
-		unsigned int j;
-		j = (unsigned int) i;
-
-		j |= (j >>  1);
-		j |= (j >>  2);
-		j |= (j >>  4);
-		j |= (j >>  8);		/* Ok, since int >= 16 bits */
-#if (UINT_MAX != 0xffff)
-		j |= (j >> 16);		/* For 32 bit int systems */
-#if (UINT_MAX > 0xffffffffUL)
-		j |= (j >> 32);		/* For 64 bit int systems */
-#endif
-#endif
-		/* Least power of two greater than i */
-		j++;
-		if ((int) j >= i) i = (int) j;
-	}
-	return i;
-}
-
-/*  int balloc (bstring b, int len)
- *
- *  Increase the size of the memory backing the bstring b to at least len.
- */
-int balloc (bstring b, int olen) {
-	int len;
-	if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen <= 0 || 
-	    b->mlen < b->slen || olen <= 0) {
-		return BSTR_ERR;
-	}
-
-	if (olen >= b->mlen) {
-		unsigned char * x;
-
-		if ((len = snapUpSize (olen)) <= b->mlen) return BSTR_OK;
-
-		/* Assume probability of a non-moving realloc is 0.125 */
-		if (7 * b->mlen < 8 * b->slen) {
-
-			/* If slen is close to mlen in size then use realloc to reduce
-			   the memory defragmentation */
-
-			reallocStrategy:;
-
-			x = (unsigned char *) bstr__realloc (b->data, (size_t) len);
-			if (x == NULL) {
-
-				/* Since we failed, try allocating the tighest possible 
-				   allocation */
-
-				if (NULL == (x = (unsigned char *) bstr__realloc (b->data, (size_t) (len = olen)))) {
-					return BSTR_ERR;
-				}
-			}
-		} else {
-
-			/* If slen is not close to mlen then avoid the penalty of copying
-			   the extra bytes that are allocated, but not considered part of
-			   the string */
-
-			if (NULL == (x = (unsigned char *) bstr__alloc ((size_t) len))) {
-
-				/* Perhaps there is no available memory for the two 
-				   allocations to be in memory at once */
-
-				goto reallocStrategy;
-
-			} else {
-				if (b->slen) bstr__memcpy ((char *) x, (char *) b->data, (size_t) b->slen);
-				bstr__free (b->data);
-			}
-		}
-		b->data = x;
-		b->mlen = len;
-		b->data[b->slen] = (unsigned char) '\0';
-	}
-
-	return BSTR_OK;
-}
-
-/*  int ballocmin (bstring b, int len)
- *
- *  Set the size of the memory backing the bstring b to len or b->slen+1,
- *  whichever is larger.  Note that repeated use of this function can degrade
- *  performance.
- */
-int ballocmin (bstring b, int len) {
-	unsigned char * s;
-
-	if (b == NULL || b->data == NULL || (b->slen+1) < 0 || b->mlen <= 0 || 
-	    b->mlen < b->slen || len <= 0) {
-		return BSTR_ERR;
-	}
-
-	if (len < b->slen + 1) len = b->slen + 1;
-
-	if (len != b->mlen) {
-		s = (unsigned char *) bstr__realloc (b->data, (size_t) len);
-		if (NULL == s) return BSTR_ERR;
-		s[b->slen] = (unsigned char) '\0';
-		b->data = s;
-		b->mlen = len;
-	}
-
-	return BSTR_OK;
-}
-
-/*  bstring bfromcstr (const char * str)
- *
- *  Create a bstring which contains the contents of the '\0' terminated char *
- *  buffer str.
- */
-bstring bfromcstr (const char * str) {
-bstring b;
-int i;
-size_t j;
-
-	if (str == NULL) return NULL;
-	j = (strlen) (str);
-	i = snapUpSize ((int) (j + (2 - (j != 0))));
-	if (i <= (int) j) return NULL;
-
-	b = (bstring) bstr__alloc (sizeof (struct tagbstring));
-	if (NULL == b) return NULL;
-	b->slen = (int) j;
-	if (NULL == (b->data = (unsigned char *) bstr__alloc (b->mlen = i))) {
-		bstr__free (b);
-		return NULL;
-	}
-
-	bstr__memcpy (b->data, str, j+1);
-	return b;
-}
-
-/*  bstring bfromcstralloc (int mlen, const char * str)
- *
- *  Create a bstring which contains the contents of the '\0' terminated char *
- *  buffer str.  The memory buffer backing the string is at least len 
- *  characters in length.
- */
-bstring bfromcstralloc (int mlen, const char * str) {
-bstring b;
-int i;
-size_t j;
-
-	if (str == NULL) return NULL;
-	j = (strlen) (str);
-	i = snapUpSize ((int) (j + (2 - (j != 0))));
-	if (i <= (int) j) return NULL;
-
-	b = (bstring) bstr__alloc (sizeof (struct tagbstring));
-	if (b == NULL) return NULL;
-	b->slen = (int) j;
-	if (i < mlen) i = mlen;
-
-	if (NULL == (b->data = (unsigned char *) bstr__alloc (b->mlen = i))) {
-		bstr__free (b);
-		return NULL;
-	}
-
-	bstr__memcpy (b->data, str, j+1);
-	return b;
-}
-
-/*  bstring blk2bstr (const void * blk, int len)
- *
- *  Create a bstring which contains the content of the block blk of length 
- *  len.
- */
-bstring blk2bstr (const void * blk, int len) {
-bstring b;
-int i;
-
-	if (blk == NULL || len < 0) return NULL;
-	b = (bstring) bstr__alloc (sizeof (struct tagbstring));
-	if (b == NULL) return NULL;
-	b->slen = len;
-
-	i = len + (2 - (len != 0));
-	i = snapUpSize (i);
-
-	b->mlen = i;
-
-	b->data = (unsigned char *) bstr__alloc ((size_t) b->mlen);
-	if (b->data == NULL) {
-		bstr__free (b);
-		return NULL;
-	}
-
-	if (len > 0) bstr__memcpy (b->data, blk, (size_t) len);
-	b->data[len] = (unsigned char) '\0';
-
-	return b;
-}
-
-/*  char * bstr2cstr (const_bstring s, char z)
- *
- *  Create a '\0' terminated char * buffer which is equal to the contents of 
- *  the bstring s, except that any contained '\0' characters are converted 
- *  to the character in z. This returned value should be freed with a 
- *  bcstrfree () call, by the calling application.
- */
-char * bstr2cstr (const_bstring b, char z) {
-int i, l;
-char * r;
-
-	if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
-	l = b->slen;
-	r = (char *) bstr__alloc ((size_t) (l + 1));
-	if (r == NULL) return r;
-
-	for (i=0; i < l; i ++) {
-		r[i] = (char) ((b->data[i] == '\0') ? z : (char) (b->data[i]));
-	}
-
-	r[l] = (unsigned char) '\0';
-
-	return r;
-}
-
-/*  int bcstrfree (char * s)
- *
- *  Frees a C-string generated by bstr2cstr ().  This is normally unnecessary
- *  since it just wraps a call to bstr__free (), however, if bstr__alloc () 
- *  and bstr__free () have been redefined as a macros within the bstrlib 
- *  module (via defining them in memdbg.h after defining 
- *  BSTRLIB_MEMORY_DEBUG) with some difference in behaviour from the std 
- *  library functions, then this allows a correct way of freeing the memory 
- *  that allows higher level code to be independent from these macro 
- *  redefinitions.
- */
-int bcstrfree (char * s) {
-	if (s) {
-		bstr__free (s);
-		return BSTR_OK;
-	}
-	return BSTR_ERR;
-}
-
-/*  int bconcat (bstring b0, const_bstring b1)
- *
- *  Concatenate the bstring b1 to the bstring b0.
- */
-int bconcat (bstring b0, const_bstring b1) {
-int len, d;
-bstring aux = (bstring) b1;
-
-	if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL) return BSTR_ERR;
-
-	d = b0->slen;
-	len = b1->slen;
-	if ((d | (b0->mlen - d) | len | (d + len)) < 0) return BSTR_ERR;
-
-	if (b0->mlen <= d + len + 1) {
-		ptrdiff_t pd = b1->data - b0->data;
-		if (0 <= pd && pd < b0->mlen) {
-			if (NULL == (aux = bstrcpy (b1))) return BSTR_ERR;
-		}
-		if (balloc (b0, d + len + 1) != BSTR_OK) {
-			if (aux != b1) bdestroy (aux);
-			return BSTR_ERR;
-		}
-	}
-
-	bBlockCopy (&b0->data[d], &aux->data[0], (size_t) len);
-	b0->data[d + len] = (unsigned char) '\0';
-	b0->slen = d + len;
-	if (aux != b1) bdestroy (aux);
-	return BSTR_OK;
-}
-
-/*  int bconchar (bstring b, char c)
-/ *
- *  Concatenate the single character c to the bstring b.
- */
-int bconchar (bstring b, char c) {
-int d;
-
-	if (b == NULL) return BSTR_ERR;
-	d = b->slen;
-	if ((d | (b->mlen - d)) < 0 || balloc (b, d + 2) != BSTR_OK) return BSTR_ERR;
-	b->data[d] = (unsigned char) c;
-	b->data[d + 1] = (unsigned char) '\0';
-	b->slen++;
-	return BSTR_OK;
-}
-
-/*  int bcatcstr (bstring b, const char * s)
- *
- *  Concatenate a char * string to a bstring.
- */
-int bcatcstr (bstring b, const char * s) {
-char * d;
-int i, l;
-
-	if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen < b->slen
-	 || b->mlen <= 0 || s == NULL) return BSTR_ERR;
-
-	/* Optimistically concatenate directly */
-	l = b->mlen - b->slen;
-	d = (char *) &b->data[b->slen];
-	for (i=0; i < l; i++) {
-		if ((*d++ = *s++) == '\0') {
-			b->slen += i;
-			return BSTR_OK;
-		}
-	}
-	b->slen += i;
-
-	/* Need to explicitely resize and concatenate tail */
-	return bcatblk (b, (const void *) s, (int) strlen (s));
-}
-
-/*  int bcatblk (bstring b, const void * s, int len)
- *
- *  Concatenate a fixed length buffer to a bstring.
- */
-int bcatblk (bstring b, const void * s, int len) {
-int nl;
-
-	if (b == NULL || b->data == NULL || b->slen < 0 || b->mlen < b->slen
-	 || b->mlen <= 0 || s == NULL || len < 0) return BSTR_ERR;
-
-	if (0 > (nl = b->slen + len)) return BSTR_ERR; /* Overflow? */
-	if (b->mlen <= nl && 0 > balloc (b, nl + 1)) return BSTR_ERR;
-
-	bBlockCopy (&b->data[b->slen], s, (size_t) len);
-	b->slen = nl;
-	b->data[nl] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  bstring bstrcpy (const_bstring b)
- *
- *  Create a copy of the bstring b.
- */
-bstring bstrcpy (const_bstring b) {
-bstring b0;
-int i,j;
-
-	/* Attempted to copy an invalid string? */
-	if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
-
-	b0 = (bstring) bstr__alloc (sizeof (struct tagbstring));
-	if (b0 == NULL) {
-		/* Unable to allocate memory for string header */
-		return NULL;
-	}
-
-	i = b->slen;
-	j = snapUpSize (i + 1);
-
-	b0->data = (unsigned char *) bstr__alloc (j);
-	if (b0->data == NULL) {
-		j = i + 1;
-		b0->data = (unsigned char *) bstr__alloc (j);
-		if (b0->data == NULL) {
-			/* Unable to allocate memory for string data */
-			bstr__free (b0);
-			return NULL;
-		}
-	}
-
-	b0->mlen = j;
-	b0->slen = i;
-
-	if (i) bstr__memcpy ((char *) b0->data, (char *) b->data, i);
-	b0->data[b0->slen] = (unsigned char) '\0';
-
-	return b0;
-}
-
-/*  int bassign (bstring a, const_bstring b)
- *
- *  Overwrite the string a with the contents of string b.
- */
-int bassign (bstring a, const_bstring b) {
-	if (b == NULL || b->data == NULL || b->slen < 0)
-		return BSTR_ERR;
-	if (b->slen != 0) {
-		if (balloc (a, b->slen) != BSTR_OK) return BSTR_ERR;
-		bstr__memmove (a->data, b->data, b->slen);
-	} else {
-		if (a == NULL || a->data == NULL || a->mlen < a->slen || 
-		    a->slen < 0 || a->mlen == 0) 
-			return BSTR_ERR;
-	}
-	a->data[b->slen] = (unsigned char) '\0';
-	a->slen = b->slen;
-	return BSTR_OK;
-}
-
-/*  int bassignmidstr (bstring a, const_bstring b, int left, int len)
- *
- *  Overwrite the string a with the middle of contents of string b 
- *  starting from position left and running for a length len.  left and 
- *  len are clamped to the ends of b as with the function bmidstr.
- */
-int bassignmidstr (bstring a, const_bstring b, int left, int len) {
-	if (b == NULL || b->data == NULL || b->slen < 0)
-		return BSTR_ERR;
-
-	if (left < 0) {
-		len += left;
-		left = 0;
-	}
-
-	if (len > b->slen - left) len = b->slen - left;
-
-	if (a == NULL || a->data == NULL || a->mlen < a->slen ||
-	    a->slen < 0 || a->mlen == 0)
-		return BSTR_ERR;
-
-	if (len > 0) {
-		if (balloc (a, len) != BSTR_OK) return BSTR_ERR;
-		bstr__memmove (a->data, b->data + left, len);
-		a->slen = len;
-	} else {
-		a->slen = 0;
-	}
-	a->data[a->slen] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  int bassigncstr (bstring a, const char * str)
- *
- *  Overwrite the string a with the contents of char * string str.  Note that 
- *  the bstring a must be a well defined and writable bstring.  If an error 
- *  occurs BSTR_ERR is returned however a may be partially overwritten.
- */
-int bassigncstr (bstring a, const char * str) {
-int i;
-size_t len;
-	if (a == NULL || a->data == NULL || a->mlen < a->slen ||
-	    a->slen < 0 || a->mlen == 0 || NULL == str) 
-		return BSTR_ERR;
-
-	for (i=0; i < a->mlen; i++) {
-		if ('\0' == (a->data[i] = str[i])) {
-			a->slen = i;
-			return BSTR_OK;
-		}
-	}
-
-	a->slen = i;
-	len = strlen (str + i);
-	if (len > INT_MAX || i + len + 1 > INT_MAX ||
-	    0 > balloc (a, (int) (i + len + 1))) return BSTR_ERR;
-	bBlockCopy (a->data + i, str + i, (size_t) len + 1);
-	a->slen += (int) len;
-	return BSTR_OK;
-}
-
-/*  int bassignblk (bstring a, const void * s, int len)
- *
- *  Overwrite the string a with the contents of the block (s, len).  Note that 
- *  the bstring a must be a well defined and writable bstring.  If an error 
- *  occurs BSTR_ERR is returned and a is not overwritten.
- */
-int bassignblk (bstring a, const void * s, int len) {
-	if (a == NULL || a->data == NULL || a->mlen < a->slen ||
-	    a->slen < 0 || a->mlen == 0 || NULL == s || len + 1 < 1) 
-		return BSTR_ERR;
-	if (len + 1 > a->mlen && 0 > balloc (a, len + 1)) return BSTR_ERR;
-	bBlockCopy (a->data, s, (size_t) len);
-	a->data[len] = (unsigned char) '\0';
-	a->slen = len;
-	return BSTR_OK;
-}
-
-/*  int btrunc (bstring b, int n)
- *
- *  Truncate the bstring to at most n characters.
- */
-int btrunc (bstring b, int n) {
-	if (n < 0 || b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-	if (b->slen > n) {
-		b->slen = n;
-		b->data[n] = (unsigned char) '\0';
-	}
-	return BSTR_OK;
-}
-
-#define   upcase(c) (toupper ((unsigned char) c))
-#define downcase(c) (tolower ((unsigned char) c))
-#define   wspace(c) (isspace ((unsigned char) c))
-
-/*  int btoupper (bstring b)
- *
- *  Convert contents of bstring to upper case.
- */
-int btoupper (bstring b) {
-int i, len;
-	if (b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-	for (i=0, len = b->slen; i < len; i++) {
-		b->data[i] = (unsigned char) upcase (b->data[i]);
-	}
-	return BSTR_OK;
-}
-
-/*  int btolower (bstring b)
- *
- *  Convert contents of bstring to lower case.
- */
-int btolower (bstring b) {
-int i, len;
-	if (b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-	for (i=0, len = b->slen; i < len; i++) {
-		b->data[i] = (unsigned char) downcase (b->data[i]);
-	}
-	return BSTR_OK;
-}
-
-/*  int bstricmp (const_bstring b0, const_bstring b1)
- *
- *  Compare two strings without differentiating between case.  The return 
- *  value is the difference of the values of the characters where the two 
- *  strings first differ after lower case transformation, otherwise 0 is 
- *  returned indicating that the strings are equal.  If the lengths are 
- *  different, then a difference from 0 is given, but if the first extra 
- *  character is '\0', then it is taken to be the value UCHAR_MAX+1.
- */
-int bstricmp (const_bstring b0, const_bstring b1) {
-int i, v, n;
-
-	if (bdata (b0) == NULL || b0->slen < 0 || 
-	    bdata (b1) == NULL || b1->slen < 0) return SHRT_MIN;
-	if ((n = b0->slen) > b1->slen) n = b1->slen;
-	else if (b0->slen == b1->slen && b0->data == b1->data) return BSTR_OK;
-
-	for (i = 0; i < n; i ++) {
-		v  = (char) downcase (b0->data[i])
-		   - (char) downcase (b1->data[i]);
-		if (0 != v) return v;
-	}
-
-	if (b0->slen > n) {
-		v = (char) downcase (b0->data[n]);
-		if (v) return v;
-		return UCHAR_MAX + 1;
-	}
-	if (b1->slen > n) {
-		v = - (char) downcase (b1->data[n]);
-		if (v) return v;
-		return - (int) (UCHAR_MAX + 1);
-	}
-	return BSTR_OK;
-}
-
-/*  int bstrnicmp (const_bstring b0, const_bstring b1, int n)
- *
- *  Compare two strings without differentiating between case for at most n
- *  characters.  If the position where the two strings first differ is
- *  before the nth position, the return value is the difference of the values
- *  of the characters, otherwise 0 is returned.  If the lengths are different
- *  and less than n characters, then a difference from 0 is given, but if the 
- *  first extra character is '\0', then it is taken to be the value 
- *  UCHAR_MAX+1.
- */
-int bstrnicmp (const_bstring b0, const_bstring b1, int n) {
-int i, v, m;
-
-	if (bdata (b0) == NULL || b0->slen < 0 || 
-	    bdata (b1) == NULL || b1->slen < 0 || n < 0) return SHRT_MIN;
-	m = n;
-	if (m > b0->slen) m = b0->slen;
-	if (m > b1->slen) m = b1->slen;
-
-	if (b0->data != b1->data) {
-		for (i = 0; i < m; i ++) {
-			v  = (char) downcase (b0->data[i]);
-			v -= (char) downcase (b1->data[i]);
-			if (v != 0) return b0->data[i] - b1->data[i];
-		}
-	}
-
-	if (n == m || b0->slen == b1->slen) return BSTR_OK;
-
-	if (b0->slen > m) {
-		v = (char) downcase (b0->data[m]);
-		if (v) return v;
-		return UCHAR_MAX + 1;
-	}
-
-	v = - (char) downcase (b1->data[m]);
-	if (v) return v;
-	return - (int) (UCHAR_MAX + 1);
-}
-
-/*  int biseqcaseless (const_bstring b0, const_bstring b1)
- *
- *  Compare two strings for equality without differentiating between case.  
- *  If the strings differ other than in case, 0 is returned, if the strings 
- *  are the same, 1 is returned, if there is an error, -1 is returned.  If 
- *  the length of the strings are different, this function is O(1).  '\0' 
- *  termination characters are not treated in any special way.
- */
-int biseqcaseless (const_bstring b0, const_bstring b1) {
-int i, n;
-
-	if (bdata (b0) == NULL || b0->slen < 0 || 
-	    bdata (b1) == NULL || b1->slen < 0) return BSTR_ERR;
-	if (b0->slen != b1->slen) return BSTR_OK;
-	if (b0->data == b1->data || b0->slen == 0) return 1;
-	for (i=0, n=b0->slen; i < n; i++) {
-		if (b0->data[i] != b1->data[i]) {
-			unsigned char c = (unsigned char) downcase (b0->data[i]);
-			if (c != (unsigned char) downcase (b1->data[i])) return 0;
-		}
-	}
-	return 1;
-}
-
-/*  int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len)
- *
- *  Compare beginning of string b0 with a block of memory of length len 
- *  without differentiating between case for equality.  If the beginning of b0
- *  differs from the memory block other than in case (or if b0 is too short), 
- *  0 is returned, if the strings are the same, 1 is returned, if there is an 
- *  error, -1 is returned.  '\0' characters are not treated in any special 
- *  way.
- */
-int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len) {
-int i;
-
-	if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0)
-		return BSTR_ERR;
-	if (b0->slen < len) return BSTR_OK;
-	if (b0->data == (const unsigned char *) blk || len == 0) return 1;
-
-	for (i = 0; i < len; i ++) {
-		if (b0->data[i] != ((const unsigned char *) blk)[i]) {
-			if (downcase (b0->data[i]) != 
-			    downcase (((const unsigned char *) blk)[i])) return 0;
-		}
-	}
-	return 1;
-}
-
-/*
- * int bltrimws (bstring b)
- *
- * Delete whitespace contiguous from the left end of the string.
- */
-int bltrimws (bstring b) {
-int i, len;
-
-	if (b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-
-	for (len = b->slen, i = 0; i < len; i++) {
-		if (!wspace (b->data[i])) {
-			return bdelete (b, 0, i);
-		}
-	}
-
-	b->data[0] = (unsigned char) '\0';
-	b->slen = 0;
-	return BSTR_OK;
-}
-
-/*
- * int brtrimws (bstring b)
- *
- * Delete whitespace contiguous from the right end of the string.
- */
-int brtrimws (bstring b) {
-int i;
-
-	if (b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-
-	for (i = b->slen - 1; i >= 0; i--) {
-		if (!wspace (b->data[i])) {
-			if (b->mlen > i) b->data[i+1] = (unsigned char) '\0';
-			b->slen = i + 1;
-			return BSTR_OK;
-		}
-	}
-
-	b->data[0] = (unsigned char) '\0';
-	b->slen = 0;
-	return BSTR_OK;
-}
-
-/*
- * int btrimws (bstring b)
- *
- * Delete whitespace contiguous from both ends of the string.
- */
-int btrimws (bstring b) {
-int i, j;
-
-	if (b == NULL || b->data == NULL || b->mlen < b->slen ||
-	    b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
-
-	for (i = b->slen - 1; i >= 0; i--) {
-		if (!wspace (b->data[i])) {
-			if (b->mlen > i) b->data[i+1] = (unsigned char) '\0';
-			b->slen = i + 1;
-			for (j = 0; wspace (b->data[j]); j++) {}
-			return bdelete (b, 0, j);
-		}
-	}
-
-	b->data[0] = (unsigned char) '\0';
-	b->slen = 0;
-	return BSTR_OK;
-}
-
-/*  int biseq (const_bstring b0, const_bstring b1)
- *
- *  Compare the string b0 and b1.  If the strings differ, 0 is returned, if 
- *  the strings are the same, 1 is returned, if there is an error, -1 is 
- *  returned.  If the length of the strings are different, this function is
- *  O(1).  '\0' termination characters are not treated in any special way.
- */
-int biseq (const_bstring b0, const_bstring b1) {
-	if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
-		b0->slen < 0 || b1->slen < 0) return BSTR_ERR;
-	if (b0->slen != b1->slen) return BSTR_OK;
-	if (b0->data == b1->data || b0->slen == 0) return 1;
-	return !bstr__memcmp (b0->data, b1->data, b0->slen);
-}
-
-/*  int bisstemeqblk (const_bstring b0, const void * blk, int len)
- *
- *  Compare beginning of string b0 with a block of memory of length len for 
- *  equality.  If the beginning of b0 differs from the memory block (or if b0 
- *  is too short), 0 is returned, if the strings are the same, 1 is returned, 
- *  if there is an error, -1 is returned.  '\0' characters are not treated in 
- *  any special way.
- */
-int bisstemeqblk (const_bstring b0, const void * blk, int len) {
-int i;
-
-	if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0)
-		return BSTR_ERR;
-	if (b0->slen < len) return BSTR_OK;
-	if (b0->data == (const unsigned char *) blk || len == 0) return 1;
-
-	for (i = 0; i < len; i ++) {
-		if (b0->data[i] != ((const unsigned char *) blk)[i]) return BSTR_OK;
-	}
-	return 1;
-}
-
-/*  int biseqcstr (const_bstring b, const char *s)
- *
- *  Compare the bstring b and char * string s.  The C string s must be '\0' 
- *  terminated at exactly the length of the bstring b, and the contents 
- *  between the two must be identical with the bstring b with no '\0' 
- *  characters for the two contents to be considered equal.  This is 
- *  equivalent to the condition that their current contents will be always be 
- *  equal when comparing them in the same format after converting one or the 
- *  other.  If the strings are equal 1 is returned, if they are unequal 0 is 
- *  returned and if there is a detectable error BSTR_ERR is returned.
- */
-int biseqcstr (const_bstring b, const char * s) {
-int i;
-	if (b == NULL || s == NULL || b->data == NULL || b->slen < 0) return BSTR_ERR;
-	for (i=0; i < b->slen; i++) {
-		if (s[i] == '\0' || b->data[i] != (unsigned char) s[i]) return BSTR_OK;
-	}
-	return s[i] == '\0';
-}
-
-/*  int biseqcstrcaseless (const_bstring b, const char *s)
- *
- *  Compare the bstring b and char * string s.  The C string s must be '\0' 
- *  terminated at exactly the length of the bstring b, and the contents 
- *  between the two must be identical except for case with the bstring b with 
- *  no '\0' characters for the two contents to be considered equal.  This is 
- *  equivalent to the condition that their current contents will be always be 
- *  equal ignoring case when comparing them in the same format after 
- *  converting one or the other.  If the strings are equal, except for case, 
- *  1 is returned, if they are unequal regardless of case 0 is returned and 
- *  if there is a detectable error BSTR_ERR is returned.
- */
-int biseqcstrcaseless (const_bstring b, const char * s) {
-int i;
-	if (b == NULL || s == NULL || b->data == NULL || b->slen < 0) return BSTR_ERR;
-	for (i=0; i < b->slen; i++) {
-		if (s[i] == '\0' || 
-		    (b->data[i] != (unsigned char) s[i] && 
-		     downcase (b->data[i]) != (unsigned char) downcase (s[i])))
-			return BSTR_OK;
-	}
-	return s[i] == '\0';
-}
-
-/*  int bstrcmp (const_bstring b0, const_bstring b1)
- *
- *  Compare the string b0 and b1.  If there is an error, SHRT_MIN is returned, 
- *  otherwise a value less than or greater than zero, indicating that the 
- *  string pointed to by b0 is lexicographically less than or greater than 
- *  the string pointed to by b1 is returned.  If the the string lengths are 
- *  unequal but the characters up until the length of the shorter are equal 
- *  then a value less than, or greater than zero, indicating that the string 
- *  pointed to by b0 is shorter or longer than the string pointed to by b1 is 
- *  returned.  0 is returned if and only if the two strings are the same.  If 
- *  the length of the strings are different, this function is O(n).  Like its
- *  standard C library counter part strcmp, the comparison does not proceed 
- *  past any '\0' termination characters encountered.
- */
-int bstrcmp (const_bstring b0, const_bstring b1) {
-int i, v, n;
-
-	if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
-		b0->slen < 0 || b1->slen < 0) return SHRT_MIN;
-	n = b0->slen; if (n > b1->slen) n = b1->slen;
-	if (b0->slen == b1->slen && (b0->data == b1->data || b0->slen == 0))
-		return BSTR_OK;
-
-	for (i = 0; i < n; i ++) {
-		v = ((char) b0->data[i]) - ((char) b1->data[i]);
-		if (v != 0) return v;
-		if (b0->data[i] == (unsigned char) '\0') return BSTR_OK;
-	}
-
-	if (b0->slen > n) return 1;
-	if (b1->slen > n) return -1;
-	return BSTR_OK;
-}
-
-/*  int bstrncmp (const_bstring b0, const_bstring b1, int n)
- *
- *  Compare the string b0 and b1 for at most n characters.  If there is an 
- *  error, SHRT_MIN is returned, otherwise a value is returned as if b0 and 
- *  b1 were first truncated to at most n characters then bstrcmp was called
- *  with these new strings are paremeters.  If the length of the strings are 
- *  different, this function is O(n).  Like its standard C library counter 
- *  part strcmp, the comparison does not proceed past any '\0' termination 
- *  characters encountered.
- */
-int bstrncmp (const_bstring b0, const_bstring b1, int n) {
-int i, v, m;
-
-	if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
-		b0->slen < 0 || b1->slen < 0) return SHRT_MIN;
-	m = n;
-	if (m > b0->slen) m = b0->slen;
-	if (m > b1->slen) m = b1->slen;
-
-	if (b0->data != b1->data) {
-		for (i = 0; i < m; i ++) {
-			v = ((char) b0->data[i]) - ((char) b1->data[i]);
-			if (v != 0) return v;
-			if (b0->data[i] == (unsigned char) '\0') return BSTR_OK;
-		}
-	}
-
-	if (n == m || b0->slen == b1->slen) return BSTR_OK;
-
-	if (b0->slen > m) return 1;
-	return -1;
-}
-
-/*  bstring bmidstr (const_bstring b, int left, int len)
- *
- *  Create a bstring which is the substring of b starting from position left
- *  and running for a length len (clamped by the end of the bstring b.)  If
- *  b is detectably invalid, then NULL is returned.  The section described 
- *  by (left, len) is clamped to the boundaries of b.
- */
-bstring bmidstr (const_bstring b, int left, int len) {
-
-	if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
-
-	if (left < 0) {
-		len += left;
-		left = 0;
-	}
-
-	if (len > b->slen - left) len = b->slen - left;
-
-	if (len <= 0) return bfromcstr ("");
-	return blk2bstr (b->data + left, len);
-}
-
-/*  int bdelete (bstring b, int pos, int len)
- *
- *  Removes characters from pos to pos+len-1 inclusive and shifts the tail of 
- *  the bstring starting from pos+len to pos.  len must be positive for this 
- *  call to have any effect.  The section of the string described by (pos, 
- *  len) is clamped to boundaries of the bstring b.
- */
-int bdelete (bstring b, int pos, int len) {
-	/* Clamp to left side of bstring */
-	if (pos < 0) {
-		len += pos;
-		pos = 0;
-	}
-
-	if (len < 0 || b == NULL || b->data == NULL || b->slen < 0 || 
-	    b->mlen < b->slen || b->mlen <= 0) 
-		return BSTR_ERR;
-	if (len > 0 && pos < b->slen) {
-		if (pos + len >= b->slen) {
-			b->slen = pos;
-		} else {
-			bBlockCopy ((char *) (b->data + pos),
-			            (char *) (b->data + pos + len), 
-			            b->slen - (pos+len));
-			b->slen -= len;
-		}
-		b->data[b->slen] = (unsigned char) '\0';
-	}
-	return BSTR_OK;
-}
-
-/*  int bdestroy (bstring b)
- *
- *  Free up the bstring.  Note that if b is detectably invalid or not writable
- *  then no action is performed and BSTR_ERR is returned.  Like a freed memory
- *  allocation, dereferences, writes or any other action on b after it has 
- *  been bdestroyed is undefined.
- */
-int bdestroy (bstring b) {
-	if (b == NULL || b->slen < 0 || b->mlen <= 0 || b->mlen < b->slen ||
-	    b->data == NULL)
-		return BSTR_ERR;
-
-	bstr__free (b->data);
-
-	/* In case there is any stale usage, there is one more chance to 
-	   notice this error. */
-
-	b->slen = -1;
-	b->mlen = -__LINE__;
-	b->data = NULL;
-
-	bstr__free (b);
-	return BSTR_OK;
-}
-
-/*  int binstr (const_bstring b1, int pos, const_bstring b2)
- *
- *  Search for the bstring b2 in b1 starting from position pos, and searching 
- *  forward.  If it is found then return with the first position where it is 
- *  found, otherwise return BSTR_ERR.  Note that this is just a brute force 
- *  string searcher that does not attempt clever things like the Boyer-Moore 
- *  search algorithm.  Because of this there are many degenerate cases where 
- *  this can take much longer than it needs to.
- */
-int binstr (const_bstring b1, int pos, const_bstring b2) {
-int j, ii, ll, lf;
-unsigned char * d0;
-unsigned char c0;
-register unsigned char * d1;
-register unsigned char c1;
-register int i;
-
-	if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
-	    b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
-	if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR;
-	if (b1->slen < pos || pos < 0) return BSTR_ERR;
-	if (b2->slen == 0) return pos;
-
-	/* No space to find such a string? */
-	if ((lf = b1->slen - b2->slen + 1) <= pos) return BSTR_ERR;
-
-	/* An obvious alias case */
-	if (b1->data == b2->data && pos == 0) return 0;
-
-	i = pos;
-
-	d0 = b2->data;
-	d1 = b1->data;
-	ll = b2->slen;
-
-	/* Peel off the b2->slen == 1 case */
-	c0 = d0[0];
-	if (1 == ll) {
-		for (;i < lf; i++) if (c0 == d1[i]) return i;
-		return BSTR_ERR;
-	}
-
-	c1 = c0;
-	j = 0;
-	lf = b1->slen - 1;
-
-	ii = -1;
-	if (i < lf) do {
-		/* Unrolled current character test */
-		if (c1 != d1[i]) {
-			if (c1 != d1[1+i]) {
-				i += 2;
-				continue;
-			}
-			i++;
-		}
-
-		/* Take note if this is the start of a potential match */
-		if (0 == j) ii = i;
-
-		/* Shift the test character down by one */
-		j++;
-		i++;
-
-		/* If this isn't past the last character continue */
-		if (j < ll) {
-			c1 = d0[j];
-			continue;
-		}
-
-		N0:;
-
-		/* If no characters mismatched, then we matched */
-		if (i == ii+j) return ii;
-
-		/* Shift back to the beginning */
-		i -= j;
-		j  = 0;
-		c1 = c0;
-	} while (i < lf);
-
-	/* Deal with last case if unrolling caused a misalignment */
-	if (i == lf && ll == j+1 && c1 == d1[i]) goto N0;
-
-	return BSTR_ERR;
-}
-
-/*  int binstrr (const_bstring b1, int pos, const_bstring b2)
- *
- *  Search for the bstring b2 in b1 starting from position pos, and searching 
- *  backward.  If it is found then return with the first position where it is 
- *  found, otherwise return BSTR_ERR.  Note that this is just a brute force 
- *  string searcher that does not attempt clever things like the Boyer-Moore 
- *  search algorithm.  Because of this there are many degenerate cases where 
- *  this can take much longer than it needs to.
- */
-int binstrr (const_bstring b1, int pos, const_bstring b2) {
-int j, i, l;
-unsigned char * d0, * d1;
-
-	if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
-	    b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
-	if (b1->slen == pos && b2->slen == 0) return pos;
-	if (b1->slen < pos || pos < 0) return BSTR_ERR;
-	if (b2->slen == 0) return pos;
-
-	/* Obvious alias case */
-	if (b1->data == b2->data && pos == 0 && b2->slen <= b1->slen) return 0;
-
-	i = pos;
-	if ((l = b1->slen - b2->slen) < 0) return BSTR_ERR;
-
-	/* If no space to find such a string then snap back */
-	if (l + 1 <= i) i = l;
-	j = 0;
-
-	d0 = b2->data;
-	d1 = b1->data;
-	l  = b2->slen;
-
-	for (;;) {
-		if (d0[j] == d1[i + j]) {
-			j ++;
-			if (j >= l) return i;
-		} else {
-			i --;
-			if (i < 0) break;
-			j=0;
-		}
-	}
-
-	return BSTR_ERR;
-}
-
-/*  int binstrcaseless (const_bstring b1, int pos, const_bstring b2)
- *
- *  Search for the bstring b2 in b1 starting from position pos, and searching 
- *  forward but without regard to case.  If it is found then return with the 
- *  first position where it is found, otherwise return BSTR_ERR.  Note that 
- *  this is just a brute force string searcher that does not attempt clever 
- *  things like the Boyer-Moore search algorithm.  Because of this there are 
- *  many degenerate cases where this can take much longer than it needs to.
- */
-int binstrcaseless (const_bstring b1, int pos, const_bstring b2) {
-int j, i, l, ll;
-unsigned char * d0, * d1;
-
-	if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
-	    b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
-	if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR;
-	if (b1->slen < pos || pos < 0) return BSTR_ERR;
-	if (b2->slen == 0) return pos;
-
-	l = b1->slen - b2->slen + 1;
-
-	/* No space to find such a string? */
-	if (l <= pos) return BSTR_ERR;
-
-	/* An obvious alias case */
-	if (b1->data == b2->data && pos == 0) return BSTR_OK;
-
-	i = pos;
-	j = 0;
-
-	d0 = b2->data;
-	d1 = b1->data;
-	ll = b2->slen;
-
-	for (;;) {
-		if (d0[j] == d1[i + j] || downcase (d0[j]) == downcase (d1[i + j])) {
-			j ++;
-			if (j >= ll) return i;
-		} else {
-			i ++;
-			if (i >= l) break;
-			j=0;
-		}
-	}
-
-	return BSTR_ERR;
-}
-
-/*  int binstrrcaseless (const_bstring b1, int pos, const_bstring b2)
- *
- *  Search for the bstring b2 in b1 starting from position pos, and searching 
- *  backward but without regard to case.  If it is found then return with the 
- *  first position where it is found, otherwise return BSTR_ERR.  Note that 
- *  this is just a brute force string searcher that does not attempt clever 
- *  things like the Boyer-Moore search algorithm.  Because of this there are 
- *  many degenerate cases where this can take much longer than it needs to.
- */
-int binstrrcaseless (const_bstring b1, int pos, const_bstring b2) {
-int j, i, l;
-unsigned char * d0, * d1;
-
-	if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
-	    b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
-	if (b1->slen == pos && b2->slen == 0) return pos;
-	if (b1->slen < pos || pos < 0) return BSTR_ERR;
-	if (b2->slen == 0) return pos;
-
-	/* Obvious alias case */
-	if (b1->data == b2->data && pos == 0 && b2->slen <= b1->slen) return BSTR_OK;
-
-	i = pos;
-	if ((l = b1->slen - b2->slen) < 0) return BSTR_ERR;
-
-	/* If no space to find such a string then snap back */
-	if (l + 1 <= i) i = l;
-	j = 0;
-
-	d0 = b2->data;
-	d1 = b1->data;
-	l  = b2->slen;
-
-	for (;;) {
-		if (d0[j] == d1[i + j] || downcase (d0[j]) == downcase (d1[i + j])) {
-			j ++;
-			if (j >= l) return i;
-		} else {
-			i --;
-			if (i < 0) break;
-			j=0;
-		}
-	}
-
-	return BSTR_ERR;
-}
-
-
-/*  int bstrchrp (const_bstring b, int c, int pos)
- *
- *  Search for the character c in b forwards from the position pos 
- *  (inclusive).
- */
-int bstrchrp (const_bstring b, int c, int pos) {
-unsigned char * p;
-
-	if (b == NULL || b->data == NULL || b->slen <= pos || pos < 0) return BSTR_ERR;
-	p = (unsigned char *) bstr__memchr ((b->data + pos), (unsigned char) c, (b->slen - pos));
-	if (p) return (int) (p - b->data);
-	return BSTR_ERR;
-}
-
-/*  int bstrrchrp (const_bstring b, int c, int pos)
- *
- *  Search for the character c in b backwards from the position pos in string 
- *  (inclusive).
- */
-int bstrrchrp (const_bstring b, int c, int pos) {
-int i;
- 
-	if (b == NULL || b->data == NULL || b->slen <= pos || pos < 0) return BSTR_ERR;
-	for (i=pos; i >= 0; i--) {
-		if (b->data[i] == (unsigned char) c) return i;
-	}
-	return BSTR_ERR;
-}
-
-#if !defined (BSTRLIB_AGGRESSIVE_MEMORY_FOR_SPEED_TRADEOFF)
-#define LONG_LOG_BITS_QTY (3)
-#define LONG_BITS_QTY (1 << LONG_LOG_BITS_QTY)
-#define LONG_TYPE unsigned char
-
-#define CFCLEN ((1 << CHAR_BIT) / LONG_BITS_QTY)
-struct charField { LONG_TYPE content[CFCLEN]; };
-#define testInCharField(cf,c) ((cf)->content[(c) >> LONG_LOG_BITS_QTY] & (((long)1) << ((c) & (LONG_BITS_QTY-1))))
-#define setInCharField(cf,idx) { \
-	unsigned int c = (unsigned int) (idx); \
-	(cf)->content[c >> LONG_LOG_BITS_QTY] |= (LONG_TYPE) (1ul << (c & (LONG_BITS_QTY-1))); \
-}
-
-#else
-
-#define CFCLEN (1 << CHAR_BIT)
-struct charField { unsigned char content[CFCLEN]; };
-#define testInCharField(cf,c) ((cf)->content[(unsigned char) (c)])
-#define setInCharField(cf,idx) (cf)->content[(unsigned int) (idx)] = ~0
-
-#endif
-
-/* Convert a bstring to charField */
-static int buildCharField (struct charField * cf, const_bstring b) {
-int i;
-	if (b == NULL || b->data == NULL || b->slen <= 0) return BSTR_ERR;
-	memset ((void *) cf->content, 0, sizeof (struct charField));
-	for (i=0; i < b->slen; i++) {
-		setInCharField (cf, b->data[i]);
-	}
-	return BSTR_OK;
-}
-
-static void invertCharField (struct charField * cf) {
-int i;
-	for (i=0; i < CFCLEN; i++) cf->content[i] = ~cf->content[i];
-}
-
-/* Inner engine for binchr */
-static int binchrCF (const unsigned char * data, int len, int pos, const struct charField * cf) {
-int i;
-	for (i=pos; i < len; i++) {
-		unsigned char c = (unsigned char) data[i];
-		if (testInCharField (cf, c)) return i;
-	}
-	return BSTR_ERR;
-}
-
-/*  int binchr (const_bstring b0, int pos, const_bstring b1);
- *
- *  Search for the first position in b0 starting from pos or after, in which 
- *  one of the characters in b1 is found and return it.  If such a position 
- *  does not exist in b0, then BSTR_ERR is returned.
- */
-int binchr (const_bstring b0, int pos, const_bstring b1) {
-struct charField chrs;
-	if (pos < 0 || b0 == NULL || b0->data == NULL ||
-	    b0->slen <= pos) return BSTR_ERR;
-	if (1 == b1->slen) return bstrchrp (b0, b1->data[0], pos);
-	if (0 > buildCharField (&chrs, b1)) return BSTR_ERR;
-	return binchrCF (b0->data, b0->slen, pos, &chrs);
-}
-
-/* Inner engine for binchrr */
-static int binchrrCF (const unsigned char * data, int pos, const struct charField * cf) {
-int i;
-	for (i=pos; i >= 0; i--) {
-		unsigned int c = (unsigned int) data[i];
-		if (testInCharField (cf, c)) return i;
-	}
-	return BSTR_ERR;
-}
-
-/*  int binchrr (const_bstring b0, int pos, const_bstring b1);
- *
- *  Search for the last position in b0 no greater than pos, in which one of 
- *  the characters in b1 is found and return it.  If such a position does not 
- *  exist in b0, then BSTR_ERR is returned.
- */
-int binchrr (const_bstring b0, int pos, const_bstring b1) {
-struct charField chrs;
-	if (pos < 0 || b0 == NULL || b0->data == NULL || b1 == NULL ||
-	    b0->slen < pos) return BSTR_ERR;
-	if (pos == b0->slen) pos--;
-	if (1 == b1->slen) return bstrrchrp (b0, b1->data[0], pos);
-	if (0 > buildCharField (&chrs, b1)) return BSTR_ERR;
-	return binchrrCF (b0->data, pos, &chrs);
-}
-
-/*  int bninchr (const_bstring b0, int pos, const_bstring b1);
- *
- *  Search for the first position in b0 starting from pos or after, in which 
- *  none of the characters in b1 is found and return it.  If such a position 
- *  does not exist in b0, then BSTR_ERR is returned.
- */
-int bninchr (const_bstring b0, int pos, const_bstring b1) {
-struct charField chrs;
-	if (pos < 0 || b0 == NULL || b0->data == NULL || 
-	    b0->slen <= pos) return BSTR_ERR;
-	if (buildCharField (&chrs, b1) < 0) return BSTR_ERR;
-	invertCharField (&chrs);
-	return binchrCF (b0->data, b0->slen, pos, &chrs);
-}
-
-/*  int bninchrr (const_bstring b0, int pos, const_bstring b1);
- *
- *  Search for the last position in b0 no greater than pos, in which none of 
- *  the characters in b1 is found and return it.  If such a position does not 
- *  exist in b0, then BSTR_ERR is returned.
- */
-int bninchrr (const_bstring b0, int pos, const_bstring b1) {
-struct charField chrs;
-	if (pos < 0 || b0 == NULL || b0->data == NULL || 
-	    b0->slen < pos) return BSTR_ERR;
-	if (pos == b0->slen) pos--;
-	if (buildCharField (&chrs, b1) < 0) return BSTR_ERR;
-	invertCharField (&chrs);
-	return binchrrCF (b0->data, pos, &chrs);
-}
-
-/*  int bsetstr (bstring b0, int pos, bstring b1, unsigned char fill)
- *
- *  Overwrite the string b0 starting at position pos with the string b1. If 
- *  the position pos is past the end of b0, then the character "fill" is 
- *  appended as necessary to make up the gap between the end of b0 and pos.
- *  If b1 is NULL, it behaves as if it were a 0-length string.
- */
-int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill) {
-int d, newlen;
-ptrdiff_t pd;
-bstring aux = (bstring) b1;
-
-	if (pos < 0 || b0 == NULL || b0->slen < 0 || NULL == b0->data || 
-	    b0->mlen < b0->slen || b0->mlen <= 0) return BSTR_ERR;
-	if (b1 != NULL && (b1->slen < 0 || b1->data == NULL)) return BSTR_ERR;
-
-	d = pos;
-
-	/* Aliasing case */
-	if (NULL != aux) {
-		if ((pd = (ptrdiff_t) (b1->data - b0->data)) >= 0 && pd < (ptrdiff_t) b0->mlen) {
-			if (NULL == (aux = bstrcpy (b1))) return BSTR_ERR;
-		}
-		d += aux->slen;
-	}
-
-	/* Increase memory size if necessary */
-	if (balloc (b0, d + 1) != BSTR_OK) {
-		if (aux != b1) bdestroy (aux);
-		return BSTR_ERR;
-	}
-
-	newlen = b0->slen;
-
-	/* Fill in "fill" character as necessary */
-	if (pos > newlen) {
-		bstr__memset (b0->data + b0->slen, (int) fill, (size_t) (pos - b0->slen));
-		newlen = pos;
-	}
-
-	/* Copy b1 to position pos in b0. */
-	if (aux != NULL) {
-		bBlockCopy ((char *) (b0->data + pos), (char *) aux->data, aux->slen);
-		if (aux != b1) bdestroy (aux);
-	}
-
-	/* Indicate the potentially increased size of b0 */
-	if (d > newlen) newlen = d;
-
-	b0->slen = newlen;
-	b0->data[newlen] = (unsigned char) '\0';
-
-	return BSTR_OK;
-}
-
-/*  int binsert (bstring b1, int pos, bstring b2, unsigned char fill)
- *
- *  Inserts the string b2 into b1 at position pos.  If the position pos is 
- *  past the end of b1, then the character "fill" is appended as necessary to 
- *  make up the gap between the end of b1 and pos.  Unlike bsetstr, binsert
- *  does not allow b2 to be NULL.
- */
-int binsert (bstring b1, int pos, const_bstring b2, unsigned char fill) {
-int d, l;
-ptrdiff_t pd;
-bstring aux = (bstring) b2;
-
-	if (pos < 0 || b1 == NULL || b2 == NULL || b1->slen < 0 || 
-	    b2->slen < 0 || b1->mlen < b1->slen || b1->mlen <= 0) return BSTR_ERR;
-
-	/* Aliasing case */
-	if ((pd = (ptrdiff_t) (b2->data - b1->data)) >= 0 && pd < (ptrdiff_t) b1->mlen) {
-		if (NULL == (aux = bstrcpy (b2))) return BSTR_ERR;
-	}
-
-	/* Compute the two possible end pointers */
-	d = b1->slen + aux->slen;
-	l = pos + aux->slen;
-	if ((d|l) < 0) return BSTR_ERR;
-
-	if (l > d) {
-		/* Inserting past the end of the string */
-		if (balloc (b1, l + 1) != BSTR_OK) {
-			if (aux != b2) bdestroy (aux);
-			return BSTR_ERR;
-		}
-		bstr__memset (b1->data + b1->slen, (int) fill, (size_t) (pos - b1->slen));
-		b1->slen = l;
-	} else {
-		/* Inserting in the middle of the string */
-		if (balloc (b1, d + 1) != BSTR_OK) {
-			if (aux != b2) bdestroy (aux);
-			return BSTR_ERR;
-		}
-		bBlockCopy (b1->data + l, b1->data + pos, d - l);
-		b1->slen = d;
-	}
-	bBlockCopy (b1->data + pos, aux->data, aux->slen);
-	b1->data[b1->slen] = (unsigned char) '\0';
-	if (aux != b2) bdestroy (aux);
-	return BSTR_OK;
-}
-
-/*  int breplace (bstring b1, int pos, int len, bstring b2, 
- *                unsigned char fill)
- *
- *  Replace a section of a string from pos for a length len with the string b2.
- *  fill is used is pos > b1->slen.
- */
-int breplace (bstring b1, int pos, int len, const_bstring b2, 
-			  unsigned char fill) {
-int pl, ret;
-ptrdiff_t pd;
-bstring aux = (bstring) b2;
-
-	if (pos < 0 || len < 0 || (pl = pos + len) < 0 || b1 == NULL || 
-	    b2 == NULL || b1->data == NULL || b2->data == NULL || 
-	    b1->slen < 0 || b2->slen < 0 || b1->mlen < b1->slen ||
-	    b1->mlen <= 0) return BSTR_ERR;
-
-	/* Straddles the end? */
-	if (pl >= b1->slen) {
-		if ((ret = bsetstr (b1, pos, b2, fill)) < 0) return ret;
-		if (pos + b2->slen < b1->slen) {
-			b1->slen = pos + b2->slen;
-			b1->data[b1->slen] = (unsigned char) '\0';
-		}
-		return ret;
-	}
-
-	/* Aliasing case */
-	if ((pd = (ptrdiff_t) (b2->data - b1->data)) >= 0 && pd < (ptrdiff_t) b1->slen) {
-		if (NULL == (aux = bstrcpy (b2))) return BSTR_ERR;
-	}
-
-	if (aux->slen > len) {
-		if (balloc (b1, b1->slen + aux->slen - len) != BSTR_OK) {
-			if (aux != b2) bdestroy (aux);
-			return BSTR_ERR;
-		}
-	}
-
-	if (aux->slen != len) bstr__memmove (b1->data + pos + aux->slen, b1->data + pos + len, b1->slen - (pos + len));
-	bstr__memcpy (b1->data + pos, aux->data, aux->slen);
-	b1->slen += aux->slen - len;
-	b1->data[b1->slen] = (unsigned char) '\0';
-	if (aux != b2) bdestroy (aux);
-	return BSTR_OK;
-}
-
-/*  
- *  findreplaceengine is used to implement bfindreplace and 
- *  bfindreplacecaseless. It works by breaking the three cases of
- *  expansion, reduction and replacement, and solving each of these
- *  in the most efficient way possible.
- */
-
-typedef int (*instr_fnptr) (const_bstring s1, int pos, const_bstring s2);
-
-#define INITIAL_STATIC_FIND_INDEX_COUNT 32
-
-static int findreplaceengine (bstring b, const_bstring find, const_bstring repl, int pos, instr_fnptr instr) {
-int i, ret, slen, mlen, delta, acc;
-int * d;
-int static_d[INITIAL_STATIC_FIND_INDEX_COUNT+1]; /* This +1 is unnecessary, but it shuts up LINT. */
-ptrdiff_t pd;
-bstring auxf = (bstring) find;
-bstring auxr = (bstring) repl;
-
-	if (b == NULL || b->data == NULL || find == NULL ||
-	    find->data == NULL || repl == NULL || repl->data == NULL || 
-	    pos < 0 || find->slen <= 0 || b->mlen < 0 || b->slen > b->mlen || 
-	    b->mlen <= 0 || b->slen < 0 || repl->slen < 0) return BSTR_ERR;
-	if (pos > b->slen - find->slen) return BSTR_OK;
-
-	/* Alias with find string */
-	pd = (ptrdiff_t) (find->data - b->data);
-	if ((ptrdiff_t) (pos - find->slen) < pd && pd < (ptrdiff_t) b->slen) {
-		if (NULL == (auxf = bstrcpy (find))) return BSTR_ERR;
-	}
-
-	/* Alias with repl string */
-	pd = (ptrdiff_t) (repl->data - b->data);
-	if ((ptrdiff_t) (pos - repl->slen) < pd && pd < (ptrdiff_t) b->slen) {
-		if (NULL == (auxr = bstrcpy (repl))) {
-			if (auxf != find) bdestroy (auxf);
-			return BSTR_ERR;
-		}
-	}
-
-	delta = auxf->slen - auxr->slen;
-
-	/* in-place replacement since find and replace strings are of equal 
-	   length */
-	if (delta == 0) {
-		while ((pos = instr (b, pos, auxf)) >= 0) {
-			bstr__memcpy (b->data + pos, auxr->data, auxr->slen);
-			pos += auxf->slen;
-		}
-		if (auxf != find) bdestroy (auxf);
-		if (auxr != repl) bdestroy (auxr);
-		return BSTR_OK;
-	}
-
-	/* shrinking replacement since auxf->slen > auxr->slen */
-	if (delta > 0) {
-		acc = 0;
-
-		while ((i = instr (b, pos, auxf)) >= 0) {
-			if (acc && i > pos)
-				bstr__memmove (b->data + pos - acc, b->data + pos, i - pos);
-			if (auxr->slen)
-				bstr__memcpy (b->data + i - acc, auxr->data, auxr->slen);
-			acc += delta;
-			pos = i + auxf->slen;
-		}
-
-		if (acc) {
-			i = b->slen;
-			if (i > pos)
-				bstr__memmove (b->data + pos - acc, b->data + pos, i - pos);
-			b->slen -= acc;
-			b->data[b->slen] = (unsigned char) '\0';
-		}
-
-		if (auxf != find) bdestroy (auxf);
-		if (auxr != repl) bdestroy (auxr);
-		return BSTR_OK;
-	}
-
-	/* expanding replacement since find->slen < repl->slen.  Its a lot 
-	   more complicated.  This works by first finding all the matches and 
-	   storing them to a growable array, then doing at most one resize of
-	   the destination bstring and then performing the direct memory transfers
-	   of the string segment pieces to form the final result. The growable 
-	   array of matches uses a deferred doubling reallocing strategy.  What 
-	   this means is that it starts as a reasonably fixed sized auto array in 
-	   the hopes that many if not most cases will never need to grow this 
-	   array.  But it switches as soon as the bounds of the array will be 
-	   exceeded.  An extra find result is always appended to this array that
-	   corresponds to the end of the destination string, so slen is checked
-	   against mlen - 1 rather than mlen before resizing.
-	*/
-
-	mlen = INITIAL_STATIC_FIND_INDEX_COUNT;
-	d = (int *) static_d; /* Avoid malloc for trivial/initial cases */
-	acc = slen = 0;
-
-	while ((pos = instr (b, pos, auxf)) >= 0) {
-		if (slen >= mlen - 1) {
-			int sl, *t;
-
-			mlen += mlen;
-			sl = sizeof (int *) * mlen;
-			if (static_d == d) d = NULL; /* static_d cannot be realloced */
-			if (mlen <= 0 || sl < mlen || NULL == (t = (int *) bstr__realloc (d, sl))) {
-				ret = BSTR_ERR;
-				goto done;
-			}
-			if (NULL == d) bstr__memcpy (t, static_d, sizeof (static_d));
-			d = t;
-		}
-		d[slen] = pos;
-		slen++;
-		acc -= delta;
-		pos += auxf->slen;
-		if (pos < 0 || acc < 0) {
-			ret = BSTR_ERR;
-			goto done;
-		}
-	}
-	
-	/* slen <= INITIAL_STATIC_INDEX_COUNT-1 or mlen-1 here. */
-	d[slen] = b->slen;
-
-	if (BSTR_OK == (ret = balloc (b, b->slen + acc + 1))) {
-		b->slen += acc;
-		for (i = slen-1; i >= 0; i--) {
-			int s, l;
-			s = d[i] + auxf->slen;
-			l = d[i+1] - s; /* d[slen] may be accessed here. */
-			if (l) {
-				bstr__memmove (b->data + s + acc, b->data + s, l);
-			}
-			if (auxr->slen) {
-				bstr__memmove (b->data + s + acc - auxr->slen, 
-				               auxr->data, auxr->slen);
-			}
-			acc += delta;		
-		}
-		b->data[b->slen] = (unsigned char) '\0';
-	}
-
-	done:;
-	if (static_d == d) d = NULL;
-	bstr__free (d);
-	if (auxf != find) bdestroy (auxf);
-	if (auxr != repl) bdestroy (auxr);
-	return ret;
-}
-
-/*  int bfindreplace (bstring b, const_bstring find, const_bstring repl, 
- *                    int pos)
- *
- *  Replace all occurrences of a find string with a replace string after a
- *  given point in a bstring.
- */
-int bfindreplace (bstring b, const_bstring find, const_bstring repl, int pos) {
-	return findreplaceengine (b, find, repl, pos, binstr);
-}
-
-/*  int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, 
- *                    int pos)
- *
- *  Replace all occurrences of a find string, ignoring case, with a replace 
- *  string after a given point in a bstring.
- */
-int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, int pos) {
-	return findreplaceengine (b, find, repl, pos, binstrcaseless);
-}
-
-/*  int binsertch (bstring b, int pos, int len, unsigned char fill)
- *
- *  Inserts the character fill repeatedly into b at position pos for a 
- *  length len.  If the position pos is past the end of b, then the 
- *  character "fill" is appended as necessary to make up the gap between the 
- *  end of b and the position pos + len.
- */
-int binsertch (bstring b, int pos, int len, unsigned char fill) {
-int d, l, i;
-
-	if (pos < 0 || b == NULL || b->slen < 0 || b->mlen < b->slen ||
-	    b->mlen <= 0 || len < 0) return BSTR_ERR;
-
-	/* Compute the two possible end pointers */
-	d = b->slen + len;
-	l = pos + len;
-	if ((d|l) < 0) return BSTR_ERR;
-
-	if (l > d) {
-		/* Inserting past the end of the string */
-		if (balloc (b, l + 1) != BSTR_OK) return BSTR_ERR;
-		pos = b->slen;
-		b->slen = l;
-	} else {
-		/* Inserting in the middle of the string */
-		if (balloc (b, d + 1) != BSTR_OK) return BSTR_ERR;
-		for (i = d - 1; i >= l; i--) {
-			b->data[i] = b->data[i - len];
-		}
-		b->slen = d;
-	}
-
-	for (i=pos; i < l; i++) b->data[i] = fill;
-	b->data[b->slen] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  int bpattern (bstring b, int len)
- *
- *  Replicate the bstring, b in place, end to end repeatedly until it 
- *  surpasses len characters, then chop the result to exactly len characters. 
- *  This function operates in-place.  The function will return with BSTR_ERR 
- *  if b is NULL or of length 0, otherwise BSTR_OK is returned.
- */
-int bpattern (bstring b, int len) {
-int i, d;
-
-	d = blength (b);
-	if (d <= 0 || len < 0 || balloc (b, len + 1) != BSTR_OK) return BSTR_ERR;
-	if (len > 0) {
-		if (d == 1) return bsetstr (b, len, NULL, b->data[0]);
-		for (i = d; i < len; i++) b->data[i] = b->data[i - d];
-	}
-	b->data[len] = (unsigned char) '\0';
-	b->slen = len;
-	return BSTR_OK;
-}
-
-#define BS_BUFF_SZ (1024)
-
-/*  int breada (bstring b, bNread readPtr, void * parm)
- *
- *  Use a finite buffer fread-like function readPtr to concatenate to the 
- *  bstring b the entire contents of file-like source data in a roughly 
- *  efficient way.
- */
-int breada (bstring b, bNread readPtr, void * parm) {
-int i, l, n;
-
-	if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
-	    b->mlen <= 0 || readPtr == NULL) return BSTR_ERR;
-
-	i = b->slen;
-	for (n=i+16; ; n += ((n < BS_BUFF_SZ) ? n : BS_BUFF_SZ)) {
-		if (BSTR_OK != balloc (b, n + 1)) return BSTR_ERR;
-		l = (int) readPtr ((void *) (b->data + i), 1, n - i, parm);
-		i += l;
-		b->slen = i;
-		if (i < n) break;
-	}
-
-	b->data[i] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  bstring bread (bNread readPtr, void * parm)
- *
- *  Use a finite buffer fread-like function readPtr to create a bstring 
- *  filled with the entire contents of file-like source data in a roughly 
- *  efficient way.
- */
-bstring bread (bNread readPtr, void * parm) {
-bstring buff;
-
-	if (0 > breada (buff = bfromcstr (""), readPtr, parm)) {
-		bdestroy (buff);
-		return NULL;
-	}
-	return buff;
-}
-
-/*  int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator)
- *
- *  Use an fgetc-like single character stream reading function (getcPtr) to 
- *  obtain a sequence of characters which are concatenated to the end of the
- *  bstring b.  The stream read is terminated by the passed in terminator 
- *  parameter.
- *
- *  If getcPtr returns with a negative number, or the terminator character 
- *  (which is appended) is read, then the stream reading is halted and the 
- *  function returns with a partial result in b.  If there is an empty partial
- *  result, 1 is returned.  If no characters are read, or there is some other 
- *  detectable error, BSTR_ERR is returned.
- */
-int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator) {
-int c, d, e;
-
-	if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
-	    b->mlen <= 0 || getcPtr == NULL) return BSTR_ERR;
-	d = 0;
-	e = b->mlen - 2;
-
-	while ((c = getcPtr (parm)) >= 0) {
-		if (d > e) {
-			b->slen = d;
-			if (balloc (b, d + 2) != BSTR_OK) return BSTR_ERR;
-			e = b->mlen - 2;
-		}
-		b->data[d] = (unsigned char) c;
-		d++;
-		if (c == terminator) break;
-	}
-
-	b->data[d] = (unsigned char) '\0';
-	b->slen = d;
-
-	return d == 0 && c < 0;
-}
-
-/*  int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator)
- *
- *  Use an fgetc-like single character stream reading function (getcPtr) to 
- *  obtain a sequence of characters which are concatenated to the end of the
- *  bstring b.  The stream read is terminated by the passed in terminator 
- *  parameter.
- *
- *  If getcPtr returns with a negative number, or the terminator character 
- *  (which is appended) is read, then the stream reading is halted and the 
- *  function returns with a partial result concatentated to b.  If there is 
- *  an empty partial result, 1 is returned.  If no characters are read, or 
- *  there is some other detectable error, BSTR_ERR is returned.
- */
-int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator) {
-int c, d, e;
-
-	if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
-	    b->mlen <= 0 || getcPtr == NULL) return BSTR_ERR;
-	d = b->slen;
-	e = b->mlen - 2;
-
-	while ((c = getcPtr (parm)) >= 0) {
-		if (d > e) {
-			b->slen = d;
-			if (balloc (b, d + 2) != BSTR_OK) return BSTR_ERR;
-			e = b->mlen - 2;
-		}
-		b->data[d] = (unsigned char) c;
-		d++;
-		if (c == terminator) break;
-	}
-
-	b->data[d] = (unsigned char) '\0';
-	b->slen = d;
-
-	return d == 0 && c < 0;
-}
-
-/*  bstring bgets (bNgetc getcPtr, void * parm, char terminator)
- *
- *  Use an fgetc-like single character stream reading function (getcPtr) to 
- *  obtain a sequence of characters which are concatenated into a bstring.  
- *  The stream read is terminated by the passed in terminator function.
- *
- *  If getcPtr returns with a negative number, or the terminator character 
- *  (which is appended) is read, then the stream reading is halted and the 
- *  result obtained thus far is returned.  If no characters are read, or 
- *  there is some other detectable error, NULL is returned.
- */
-bstring bgets (bNgetc getcPtr, void * parm, char terminator) {
-bstring buff;
-
-	if (0 > bgetsa (buff = bfromcstr (""), getcPtr, parm, terminator) || 0 >= buff->slen) {
-		bdestroy (buff);
-		buff = NULL;
-	}
-	return buff;
-}
-
-struct bStream {
-	bstring buff;		/* Buffer for over-reads */
-	void * parm;		/* The stream handle for core stream */
-	bNread readFnPtr;	/* fread compatible fnptr for core stream */
-	int isEOF;		/* track file's EOF state */
-	int maxBuffSz;
-};
-
-/*  struct bStream * bsopen (bNread readPtr, void * parm)
- *
- *  Wrap a given open stream (described by a fread compatible function 
- *  pointer and stream handle) into an open bStream suitable for the bstring 
- *  library streaming functions.
- */
-struct bStream * bsopen (bNread readPtr, void * parm) {
-struct bStream * s;
-
-	if (readPtr == NULL) return NULL;
-	s = (struct bStream *) bstr__alloc (sizeof (struct bStream));
-	if (s == NULL) return NULL;
-	s->parm = parm;
-	s->buff = bfromcstr ("");
-	s->readFnPtr = readPtr;
-	s->maxBuffSz = BS_BUFF_SZ;
-	s->isEOF = 0;
-	return s;
-}
-
-/*  int bsbufflength (struct bStream * s, int sz)
- *
- *  Set the length of the buffer used by the bStream.  If sz is zero, the 
- *  length is not set.  This function returns with the previous length.
- */
-int bsbufflength (struct bStream * s, int sz) {
-int oldSz;
-	if (s == NULL || sz < 0) return BSTR_ERR;
-	oldSz = s->maxBuffSz;
-	if (sz > 0) s->maxBuffSz = sz;
-	return oldSz;
-}
-
-int bseof (const struct bStream * s) {
-	if (s == NULL || s->readFnPtr == NULL) return BSTR_ERR;
-	return s->isEOF && (s->buff->slen == 0);
-}
-
-/*  void * bsclose (struct bStream * s)
- *
- *  Close the bStream, and return the handle to the stream that was originally
- *  used to open the given stream.
- */
-void * bsclose (struct bStream * s) {
-void * parm;
-	if (s == NULL) return NULL;
-	s->readFnPtr = NULL;
-	if (s->buff) bdestroy (s->buff);
-	s->buff = NULL;
-	parm = s->parm;
-	s->parm = NULL;
-	s->isEOF = 1;
-	bstr__free (s);
-	return parm;
-}
-
-/*  int bsreadlna (bstring r, struct bStream * s, char terminator)
- *
- *  Read a bstring terminated by the terminator character or the end of the
- *  stream from the bStream (s) and return it into the parameter r.  This 
- *  function may read additional characters from the core stream that are not 
- *  returned, but will be retained for subsequent read operations.
- */
-int bsreadlna (bstring r, struct bStream * s, char terminator) {
-int i, l, ret, rlo;
-char * b;
-struct tagbstring x;
-
-	if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0 ||
-	    r->slen < 0 || r->mlen < r->slen) return BSTR_ERR;
-	l = s->buff->slen;
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	b = (char *) s->buff->data;
-	x.data = (unsigned char *) b;
-
-	/* First check if the current buffer holds the terminator */
-	b[l] = terminator; /* Set sentinel */
-	for (i=0; b[i] != terminator; i++) ;
-	if (i < l) {
-		x.slen = i + 1;
-		ret = bconcat (r, &x);
-		s->buff->slen = l;
-		if (BSTR_OK == ret) bdelete (s->buff, 0, i + 1);
-		return BSTR_OK;
-	}
-
-	rlo = r->slen;
-
-	/* If not then just concatenate the entire buffer to the output */
-	x.slen = l;
-	if (BSTR_OK != bconcat (r, &x)) return BSTR_ERR;
-
-	/* Perform direct in-place reads into the destination to allow for
-	   the minimum of data-copies */
-	for (;;) {
-		if (BSTR_OK != balloc (r, r->slen + s->maxBuffSz + 1)) return BSTR_ERR;
-		b = (char *) (r->data + r->slen);
-		l = (int) s->readFnPtr (b, 1, s->maxBuffSz, s->parm);
-		if (l <= 0) {
-			r->data[r->slen] = (unsigned char) '\0';
-			s->buff->slen = 0;
-			s->isEOF = 1;
-			/* If nothing was read return with an error message */
-			return BSTR_ERR & -(r->slen == rlo);
-		}
-		b[l] = terminator; /* Set sentinel */
-		for (i=0; b[i] != terminator; i++) ;
-		if (i < l) break;
-		r->slen += l;
-	}
-
-	/* Terminator found, push over-read back to buffer */
-	i++;
-	r->slen += i;
-	s->buff->slen = l - i;
-	bstr__memcpy (s->buff->data, b + i, l - i);
-	r->data[r->slen] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  int bsreadlnsa (bstring r, struct bStream * s, bstring term)
- *
- *  Read a bstring terminated by any character in the term string or the end 
- *  of the stream from the bStream (s) and return it into the parameter r.  
- *  This function may read additional characters from the core stream that 
- *  are not returned, but will be retained for subsequent read operations.
- */
-int bsreadlnsa (bstring r, struct bStream * s, const_bstring term) {
-int i, l, ret, rlo;
-unsigned char * b;
-struct tagbstring x;
-struct charField cf;
-
-	if (s == NULL || s->buff == NULL || r == NULL || term == NULL ||
-	    term->data == NULL || r->mlen <= 0 || r->slen < 0 ||
-	    r->mlen < r->slen) return BSTR_ERR;
-	if (term->slen == 1) return bsreadlna (r, s, term->data[0]);
-	if (term->slen < 1 || buildCharField (&cf, term)) return BSTR_ERR;
-
-	l = s->buff->slen;
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	b = (unsigned char *) s->buff->data;
-	x.data = b;
-
-	/* First check if the current buffer holds the terminator */
-	b[l] = term->data[0]; /* Set sentinel */
-	for (i=0; !testInCharField (&cf, b[i]); i++) ;
-	if (i < l) {
-		x.slen = i + 1;
-		ret = bconcat (r, &x);
-		s->buff->slen = l;
-		if (BSTR_OK == ret) bdelete (s->buff, 0, i + 1);
-		return BSTR_OK;
-	}
-
-	rlo = r->slen;
-
-	/* If not then just concatenate the entire buffer to the output */
-	x.slen = l;
-	if (BSTR_OK != bconcat (r, &x)) return BSTR_ERR;
-
-	/* Perform direct in-place reads into the destination to allow for
-	   the minimum of data-copies */
-	for (;;) {
-		if (BSTR_OK != balloc (r, r->slen + s->maxBuffSz + 1)) return BSTR_ERR;
-		b = (unsigned char *) (r->data + r->slen);
-		l = (int) s->readFnPtr (b, 1, s->maxBuffSz, s->parm);
-		if (l <= 0) {
-			r->data[r->slen] = (unsigned char) '\0';
-			s->buff->slen = 0;
-			s->isEOF = 1;
-			/* If nothing was read return with an error message */
-			return BSTR_ERR & -(r->slen == rlo);
-		}
-
-		b[l] = term->data[0]; /* Set sentinel */
-		for (i=0; !testInCharField (&cf, b[i]); i++) ;
-		if (i < l) break;
-		r->slen += l;
-	}
-
-	/* Terminator found, push over-read back to buffer */
-	i++;
-	r->slen += i;
-	s->buff->slen = l - i;
-	bstr__memcpy (s->buff->data, b + i, l - i);
-	r->data[r->slen] = (unsigned char) '\0';
-	return BSTR_OK;
-}
-
-/*  int bsreada (bstring r, struct bStream * s, int n)
- *
- *  Read a bstring of length n (or, if it is fewer, as many bytes as is 
- *  remaining) from the bStream.  This function may read additional 
- *  characters from the core stream that are not returned, but will be 
- *  retained for subsequent read operations.  This function will not read
- *  additional characters from the core stream beyond virtual stream pointer.
- */
-int bsreada (bstring r, struct bStream * s, int n) {
-int l, ret, orslen;
-char * b;
-struct tagbstring x;
-
-	if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0
-	 || r->slen < 0 || r->mlen < r->slen || n <= 0) return BSTR_ERR;
-
-	n += r->slen;
-	if (n <= 0) return BSTR_ERR;
-
-	l = s->buff->slen;
-
-	orslen = r->slen;
-
-	if (0 == l) {
-		if (s->isEOF) return BSTR_ERR;
-		if (r->mlen > n) {
-			l = (int) s->readFnPtr (r->data + r->slen, 1, n - r->slen, s->parm);
-			if (0 >= l || l > n - r->slen) {
-				s->isEOF = 1;
-				return BSTR_ERR;
-			}
-			r->slen += l;
-			r->data[r->slen] = (unsigned char) '\0';
-			return 0;
-		}
-	}
-
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	b = (char *) s->buff->data;
-	x.data = (unsigned char *) b;
-
-	do {
-		if (l + r->slen >= n) {
-			x.slen = n - r->slen;
-			ret = bconcat (r, &x);
-			s->buff->slen = l;
-			if (BSTR_OK == ret) bdelete (s->buff, 0, x.slen);
-			return BSTR_ERR & -(r->slen == orslen);
-		}
-
-		x.slen = l;
-		if (BSTR_OK != bconcat (r, &x)) break;
-
-		l = n - r->slen;
-		if (l > s->maxBuffSz) l = s->maxBuffSz;
-
-		l = (int) s->readFnPtr (b, 1, l, s->parm);
-
-	} while (l > 0);
-	if (l < 0) l = 0;
-	if (l == 0) s->isEOF = 1;
-	s->buff->slen = l;
-	return BSTR_ERR & -(r->slen == orslen);
-}
-
-/*  int bsreadln (bstring r, struct bStream * s, char terminator)
- *
- *  Read a bstring terminated by the terminator character or the end of the
- *  stream from the bStream (s) and return it into the parameter r.  This 
- *  function may read additional characters from the core stream that are not 
- *  returned, but will be retained for subsequent read operations.
- */
-int bsreadln (bstring r, struct bStream * s, char terminator) {
-	if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0)
-		return BSTR_ERR;
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	r->slen = 0;
-	return bsreadlna (r, s, terminator);
-}
-
-/*  int bsreadlns (bstring r, struct bStream * s, bstring term)
- *
- *  Read a bstring terminated by any character in the term string or the end 
- *  of the stream from the bStream (s) and return it into the parameter r.  
- *  This function may read additional characters from the core stream that 
- *  are not returned, but will be retained for subsequent read operations.
- */
-int bsreadlns (bstring r, struct bStream * s, const_bstring term) {
-	if (s == NULL || s->buff == NULL || r == NULL || term == NULL 
-	 || term->data == NULL || r->mlen <= 0) return BSTR_ERR;
-	if (term->slen == 1) return bsreadln (r, s, term->data[0]);
-	if (term->slen < 1) return BSTR_ERR;
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	r->slen = 0;
-	return bsreadlnsa (r, s, term);
-}
-
-/*  int bsread (bstring r, struct bStream * s, int n)
- *
- *  Read a bstring of length n (or, if it is fewer, as many bytes as is 
- *  remaining) from the bStream.  This function may read additional 
- *  characters from the core stream that are not returned, but will be 
- *  retained for subsequent read operations.  This function will not read
- *  additional characters from the core stream beyond virtual stream pointer.
- */
-int bsread (bstring r, struct bStream * s, int n) {
-	if (s == NULL || s->buff == NULL || r == NULL || r->mlen <= 0
-	 || n <= 0) return BSTR_ERR;
-	if (BSTR_OK != balloc (s->buff, s->maxBuffSz + 1)) return BSTR_ERR;
-	r->slen = 0;
-	return bsreada (r, s, n);
-}
-
-/*  int bsunread (struct bStream * s, const_bstring b)
- *
- *  Insert a bstring into the bStream at the current position.  These 
- *  characters will be read prior to those that actually come from the core 
- *  stream.
- */
-int bsunread (struct bStream * s, const_bstring b) {
-	if (s == NULL || s->buff == NULL) return BSTR_ERR;
-	return binsert (s->buff, 0, b, (unsigned char) '?');
-}
-
-/*  int bspeek (bstring r, const struct bStream * s)
- *
- *  Return the currently buffered characters from the bStream that will be 
- *  read prior to reads from the core stream.
- */
-int bspeek (bstring r, const struct bStream * s) {
-	if (s == NULL || s->buff == NULL) return BSTR_ERR;
-	return bassign (r, s->buff);
-}
-
-/*  bstring bjoin (const struct bstrList * bl, const_bstring sep);
- *
- *  Join the entries of a bstrList into one bstring by sequentially 
- *  concatenating them with the sep string in between.  If there is an error 
- *  NULL is returned, otherwise a bstring with the correct result is returned.
- */
-bstring bjoin (const struct bstrList * bl, const_bstring sep) {
-bstring b;
-int i, c, v;
-
-	if (bl == NULL || bl->qty < 0) return NULL;
-	if (sep != NULL && (sep->slen < 0 || sep->data == NULL)) return NULL;
-
-	for (i = 0, c = 1; i < bl->qty; i++) {
-		v = bl->entry[i]->slen;
-		if (v < 0) return NULL;	/* Invalid input */
-		c += v;
-		if (c < 0) return NULL;	/* Wrap around ?? */
-	}
-
-	if (sep != NULL) c += (bl->qty - 1) * sep->slen;
-
-	b = (bstring) bstr__alloc (sizeof (struct tagbstring));
-	if (NULL == b) return NULL; /* Out of memory */
-	b->data = (unsigned char *) bstr__alloc (c);
-	if (b->data == NULL) {
-		bstr__free (b);
-		return NULL;
-	}
-
-	b->mlen = c;
-	b->slen = c-1;
-
-	for (i = 0, c = 0; i < bl->qty; i++) {
-		if (i > 0 && sep != NULL) {
-			bstr__memcpy (b->data + c, sep->data, sep->slen);
-			c += sep->slen;
-		}
-		v = bl->entry[i]->slen;
-		bstr__memcpy (b->data + c, bl->entry[i]->data, v);
-		c += v;
-	}
-	b->data[c] = (unsigned char) '\0';
-	return b;
-}
-
-#define BSSSC_BUFF_LEN (256)
-
-/*  int bssplitscb (struct bStream * s, const_bstring splitStr, 
- *	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm)
- *
- *  Iterate the set of disjoint sequential substrings read from a stream 
- *  divided by any of the characters in splitStr.  An empty splitStr causes 
- *  the whole stream to be iterated once.
- *
- *  Note: At the point of calling the cb function, the bStream pointer is 
- *  pointed exactly at the position right after having read the split 
- *  character.  The cb function can act on the stream by causing the bStream
- *  pointer to move, and bssplitscb will continue by starting the next split
- *  at the position of the pointer after the return from cb.
- *
- *  However, if the cb causes the bStream s to be destroyed then the cb must
- *  return with a negative value, otherwise bssplitscb will continue in an 
- *  undefined manner.
- */
-int bssplitscb (struct bStream * s, const_bstring splitStr, 
-	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) {
-struct charField chrs;
-bstring buff;
-int i, p, ret;
-
-	if (cb == NULL || s == NULL || s->readFnPtr == NULL 
-	 || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
-
-	if (NULL == (buff = bfromcstr (""))) return BSTR_ERR;
-
-	if (splitStr->slen == 0) {
-		while (bsreada (buff, s, BSSSC_BUFF_LEN) >= 0) ;
-		if ((ret = cb (parm, 0, buff)) > 0) 
-			ret = 0;
-	} else {
-		buildCharField (&chrs, splitStr);
-		ret = p = i = 0;
-		for (;;) {
-			if (i >= buff->slen) {
-				bsreada (buff, s, BSSSC_BUFF_LEN);
-				if (i >= buff->slen) {
-					if (0 < (ret = cb (parm, p, buff))) ret = 0;
-					break;
-				}
-			}
-			if (testInCharField (&chrs, buff->data[i])) {
-				struct tagbstring t;
-				unsigned char c;
-
-				blk2tbstr (t, buff->data + i + 1, buff->slen - (i + 1));
-				if ((ret = bsunread (s, &t)) < 0) break;
-				buff->slen = i;
-				c = buff->data[i];
-				buff->data[i] = (unsigned char) '\0';
-				if ((ret = cb (parm, p, buff)) < 0) break;
-				buff->data[i] = c;
-				buff->slen = 0;
-				p += i + 1;
-				i = -1;
-			}
-			i++;
-		}
-	}
-
-	bdestroy (buff);
-	return ret;
-}
-
-/*  int bssplitstrcb (struct bStream * s, const_bstring splitStr, 
- *	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm)
- *
- *  Iterate the set of disjoint sequential substrings read from a stream 
- *  divided by the entire substring splitStr.  An empty splitStr causes 
- *  each character of the stream to be iterated.
- *
- *  Note: At the point of calling the cb function, the bStream pointer is 
- *  pointed exactly at the position right after having read the split 
- *  character.  The cb function can act on the stream by causing the bStream
- *  pointer to move, and bssplitscb will continue by starting the next split
- *  at the position of the pointer after the return from cb.
- *
- *  However, if the cb causes the bStream s to be destroyed then the cb must
- *  return with a negative value, otherwise bssplitscb will continue in an 
- *  undefined manner.
- */
-int bssplitstrcb (struct bStream * s, const_bstring splitStr, 
-	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm) {
-bstring buff;
-int i, p, ret;
-
-	if (cb == NULL || s == NULL || s->readFnPtr == NULL 
-	 || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
-
-	if (splitStr->slen == 1) return bssplitscb (s, splitStr, cb, parm);
-
-	if (NULL == (buff = bfromcstr (""))) return BSTR_ERR;
-
-	if (splitStr->slen == 0) {
-		for (i=0; bsreada (buff, s, BSSSC_BUFF_LEN) >= 0; i++) {
-			if ((ret = cb (parm, 0, buff)) < 0) {
-				bdestroy (buff);
-				return ret;
-			}
-			buff->slen = 0;
-		}
-		return BSTR_OK;
-	} else {
-		ret = p = i = 0;
-		for (i=p=0;;) {
-			if ((ret = binstr (buff, 0, splitStr)) >= 0) {
-				struct tagbstring t;
-				blk2tbstr (t, buff->data, ret);
-				i = ret + splitStr->slen;
-				if ((ret = cb (parm, p, &t)) < 0) break;
-				p += i;
-				bdelete (buff, 0, i);
-			} else {
-				bsreada (buff, s, BSSSC_BUFF_LEN);
-				if (bseof (s)) {
-					if ((ret = cb (parm, p, buff)) > 0) ret = 0;
-					break;
-				}
-			}
-		}
-	}
-
-	bdestroy (buff);
-	return ret;
-}
-
-/*  int bstrListCreate (void)
- *
- *  Create a bstrList.
- */
-struct bstrList * bstrListCreate (void) {
-struct bstrList * sl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
-	if (sl) {
-		sl->entry = (bstring *) bstr__alloc (1*sizeof (bstring));
-		if (!sl->entry) {
-			bstr__free (sl);
-			sl = NULL;
-		} else {
-			sl->qty = 0;
-			sl->mlen = 1;
-		}
-	}
-	return sl;
-}
-
-/*  int bstrListDestroy (struct bstrList * sl)
- *
- *  Destroy a bstrList that has been created by bsplit, bsplits or bstrListCreate.
- */
-int bstrListDestroy (struct bstrList * sl) {
-int i;
-	if (sl == NULL || sl->qty < 0) return BSTR_ERR;
-	for (i=0; i < sl->qty; i++) {
-		if (sl->entry[i]) {
-			bdestroy (sl->entry[i]);
-			sl->entry[i] = NULL;
-		}
-	}
-	sl->qty  = -1;
-	sl->mlen = -1;
-	bstr__free (sl->entry);
-	sl->entry = NULL;
-	bstr__free (sl);
-	return BSTR_OK;
-}
-
-/*  int bstrListAlloc (struct bstrList * sl, int msz)
- *
- *  Ensure that there is memory for at least msz number of entries for the
- *  list.
- */
-int bstrListAlloc (struct bstrList * sl, int msz) {
-bstring * l;
-int smsz;
-size_t nsz;
-	if (!sl || msz <= 0 || !sl->entry || sl->qty < 0 || sl->mlen <= 0 || sl->qty > sl->mlen) return BSTR_ERR;
-	if (sl->mlen >= msz) return BSTR_OK;
-	smsz = snapUpSize (msz);
-	nsz = ((size_t) smsz) * sizeof (bstring);
-	if (nsz < (size_t) smsz) return BSTR_ERR;
-	l = (bstring *) bstr__realloc (sl->entry, nsz);
-	if (!l) {
-		smsz = msz;
-		nsz = ((size_t) smsz) * sizeof (bstring);
-		l = (bstring *) bstr__realloc (sl->entry, nsz);
-		if (!l) return BSTR_ERR;
-	}
-	sl->mlen = smsz;
-	sl->entry = l;
-	return BSTR_OK;
-}
-
-/*  int bstrListAllocMin (struct bstrList * sl, int msz)
- *
- *  Try to allocate the minimum amount of memory for the list to include at
- *  least msz entries or sl->qty whichever is greater.
- */
-int bstrListAllocMin (struct bstrList * sl, int msz) {
-bstring * l;
-size_t nsz;
-	if (!sl || msz <= 0 || !sl->entry || sl->qty < 0 || sl->mlen <= 0 || sl->qty > sl->mlen) return BSTR_ERR;
-	if (msz < sl->qty) msz = sl->qty;
-	if (sl->mlen == msz) return BSTR_OK;
-	nsz = ((size_t) msz) * sizeof (bstring);
-	if (nsz < (size_t) msz) return BSTR_ERR;
-	l = (bstring *) bstr__realloc (sl->entry, nsz);
-	if (!l) return BSTR_ERR;
-	sl->mlen = msz;
-	sl->entry = l;
-	return BSTR_OK;
-}
-
-/*  int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
- *	int (* cb) (void * parm, int ofs, int len), void * parm)
- *
- *  Iterate the set of disjoint sequential substrings over str divided by the
- *  character in splitChar.
- *
- *  Note: Non-destructive modification of str from within the cb function 
- *  while performing this split is not undefined.  bsplitcb behaves in 
- *  sequential lock step with calls to cb.  I.e., after returning from a cb 
- *  that return a non-negative integer, bsplitcb continues from the position 
- *  1 character after the last detected split character and it will halt 
- *  immediately if the length of str falls below this point.  However, if the 
- *  cb function destroys str, then it *must* return with a negative value, 
- *  otherwise bsplitcb will continue in an undefined manner.
- */
-int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm) {
-int i, p, ret;
-
-	if (cb == NULL || str == NULL || pos < 0 || pos > str->slen) 
-		return BSTR_ERR;
-
-	p = pos;
-	do {
-		for (i=p; i < str->slen; i++) {
-			if (str->data[i] == splitChar) break;
-		}
-		if ((ret = cb (parm, p, i - p)) < 0) return ret;
-		p = i + 1;
-	} while (p <= str->slen);
-	return BSTR_OK;
-}
-
-/*  int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
- *	int (* cb) (void * parm, int ofs, int len), void * parm)
- *
- *  Iterate the set of disjoint sequential substrings over str divided by any 
- *  of the characters in splitStr.  An empty splitStr causes the whole str to
- *  be iterated once.
- *
- *  Note: Non-destructive modification of str from within the cb function 
- *  while performing this split is not undefined.  bsplitscb behaves in 
- *  sequential lock step with calls to cb.  I.e., after returning from a cb 
- *  that return a non-negative integer, bsplitscb continues from the position 
- *  1 character after the last detected split character and it will halt 
- *  immediately if the length of str falls below this point.  However, if the 
- *  cb function destroys str, then it *must* return with a negative value, 
- *  otherwise bsplitscb will continue in an undefined manner.
- */
-int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm) {
-struct charField chrs;
-int i, p, ret;
-
-	if (cb == NULL || str == NULL || pos < 0 || pos > str->slen 
-	 || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
-	if (splitStr->slen == 0) {
-		if ((ret = cb (parm, 0, str->slen)) > 0) ret = 0;
-		return ret;
-	}
-
-	if (splitStr->slen == 1) 
-		return bsplitcb (str, splitStr->data[0], pos, cb, parm);
-
-	buildCharField (&chrs, splitStr);
-
-	p = pos;
-	do {
-		for (i=p; i < str->slen; i++) {
-			if (testInCharField (&chrs, str->data[i])) break;
-		}
-		if ((ret = cb (parm, p, i - p)) < 0) return ret;
-		p = i + 1;
-	} while (p <= str->slen);
-	return BSTR_OK;
-}
-
-/*  int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
- *	int (* cb) (void * parm, int ofs, int len), void * parm)
- *
- *  Iterate the set of disjoint sequential substrings over str divided by the 
- *  substring splitStr.  An empty splitStr causes the whole str to be 
- *  iterated once.
- *
- *  Note: Non-destructive modification of str from within the cb function 
- *  while performing this split is not undefined.  bsplitstrcb behaves in 
- *  sequential lock step with calls to cb.  I.e., after returning from a cb 
- *  that return a non-negative integer, bsplitscb continues from the position 
- *  1 character after the last detected split character and it will halt 
- *  immediately if the length of str falls below this point.  However, if the 
- *  cb function destroys str, then it *must* return with a negative value, 
- *  otherwise bsplitscb will continue in an undefined manner.
- */
-int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm) {
-int i, p, ret;
-
-	if (cb == NULL || str == NULL || pos < 0 || pos > str->slen 
-	 || splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
-
-	if (0 == splitStr->slen) {
-		for (i=pos; i < str->slen; i++) {
-			if ((ret = cb (parm, i, 1)) < 0) return ret;
-		}
-		return BSTR_OK;
-	}
-
-	if (splitStr->slen == 1) 
-		return bsplitcb (str, splitStr->data[0], pos, cb, parm);
-
-	for (i=p=pos; i <= str->slen - splitStr->slen; i++) {
-		if (0 == bstr__memcmp (splitStr->data, str->data + i, splitStr->slen)) {
-			if ((ret = cb (parm, p, i - p)) < 0) return ret;
-			i += splitStr->slen;
-			p = i;
-		}
-	}
-	if ((ret = cb (parm, p, str->slen - p)) < 0) return ret;
-	return BSTR_OK;
-}
-
-struct genBstrList {
-	bstring b;
-	struct bstrList * bl;
-};
-
-static int bscb (void * parm, int ofs, int len) {
-struct genBstrList * g = (struct genBstrList *) parm;
-	if (g->bl->qty >= g->bl->mlen) {
-		int mlen = g->bl->mlen * 2;
-		bstring * tbl;
-
-		while (g->bl->qty >= mlen) {
-			if (mlen < g->bl->mlen) return BSTR_ERR;
-			mlen += mlen;
-		}
-
-		tbl = (bstring *) bstr__realloc (g->bl->entry, sizeof (bstring) * mlen);
-		if (tbl == NULL) return BSTR_ERR;
-
-		g->bl->entry = tbl;
-		g->bl->mlen = mlen;
-	}
-
-	g->bl->entry[g->bl->qty] = bmidstr (g->b, ofs, len);
-	g->bl->qty++;
-	return BSTR_OK;
-}
-
-/*  struct bstrList * bsplit (const_bstring str, unsigned char splitChar)
- *
- *  Create an array of sequential substrings from str divided by the character
- *  splitChar.  
- */
-struct bstrList * bsplit (const_bstring str, unsigned char splitChar) {
-struct genBstrList g;
-
-	if (str == NULL || str->data == NULL || str->slen < 0) return NULL;
-
-	g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
-	if (g.bl == NULL) return NULL;
-	g.bl->mlen = 4;
-	g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring));
-	if (NULL == g.bl->entry) {
-		bstr__free (g.bl);
-		return NULL;
-	}
-
-	g.b = (bstring) str;
-	g.bl->qty = 0;
-	if (bsplitcb (str, splitChar, 0, bscb, &g) < 0) {
-		bstrListDestroy (g.bl);
-		return NULL;
-	}
-	return g.bl;
-}
-
-/*  struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr)
- *
- *  Create an array of sequential substrings from str divided by the entire
- *  substring splitStr.
- */
-struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr) {
-struct genBstrList g;
-
-	if (str == NULL || str->data == NULL || str->slen < 0) return NULL;
-
-	g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
-	if (g.bl == NULL) return NULL;
-	g.bl->mlen = 4;
-	g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring));
-	if (NULL == g.bl->entry) {
-		bstr__free (g.bl);
-		return NULL;
-	}
-
-	g.b = (bstring) str;
-	g.bl->qty = 0;
-	if (bsplitstrcb (str, splitStr, 0, bscb, &g) < 0) {
-		bstrListDestroy (g.bl);
-		return NULL;
-	}
-	return g.bl;
-}
-
-/*  struct bstrList * bsplits (const_bstring str, bstring splitStr)
- *
- *  Create an array of sequential substrings from str divided by any of the 
- *  characters in splitStr.  An empty splitStr causes a single entry bstrList
- *  containing a copy of str to be returned.
- */
-struct bstrList * bsplits (const_bstring str, const_bstring splitStr) {
-struct genBstrList g;
-
-	if (     str == NULL ||      str->slen < 0 ||      str->data == NULL ||
-	    splitStr == NULL || splitStr->slen < 0 || splitStr->data == NULL)
-		return NULL;
-
-	g.bl = (struct bstrList *) bstr__alloc (sizeof (struct bstrList));
-	if (g.bl == NULL) return NULL;
-	g.bl->mlen = 4;
-	g.bl->entry = (bstring *) bstr__alloc (g.bl->mlen * sizeof (bstring));
-	if (NULL == g.bl->entry) {
-		bstr__free (g.bl);
-		return NULL;
-	}
-	g.b = (bstring) str;
-	g.bl->qty = 0;
-
-	if (bsplitscb (str, splitStr, 0, bscb, &g) < 0) {
-		bstrListDestroy (g.bl);
-		return NULL;
-	}
-	return g.bl;
-}
-
-#if defined (__TURBOC__) && !defined (__BORLANDC__)
-# ifndef BSTRLIB_NOVSNP
-#  define BSTRLIB_NOVSNP
-# endif
-#endif
-
-/* Give WATCOM C/C++, MSVC some latitude for their non-support of vsnprintf */
-#if defined(__WATCOMC__) || defined(_MSC_VER)
-#define exvsnprintf(r,b,n,f,a) {r = _vsnprintf (b,n,f,a);}
-#else
-#ifdef BSTRLIB_NOVSNP
-/* This is just a hack.  If you are using a system without a vsnprintf, it is 
-   not recommended that bformat be used at all. */
-#define exvsnprintf(r,b,n,f,a) {vsprintf (b,f,a); r = -1;}
-#define START_VSNBUFF (256)
-#else
-
-#ifdef __GNUC__
-/* Something is making gcc complain about this prototype not being here, so 
-   I've just gone ahead and put it in. */
-extern int vsnprintf (char *buf, size_t count, const char *format, va_list arg);
-#endif
-
-#define exvsnprintf(r,b,n,f,a) {r = vsnprintf (b,n,f,a);}
-#endif
-#endif
-
-#if !defined (BSTRLIB_NOVSNP)
-
-#ifndef START_VSNBUFF
-#define START_VSNBUFF (16)
-#endif
-
-/* On IRIX vsnprintf returns n-1 when the operation would overflow the target 
-   buffer, WATCOM and MSVC both return -1, while C99 requires that the 
-   returned value be exactly what the length would be if the buffer would be
-   large enough.  This leads to the idea that if the return value is larger 
-   than n, then changing n to the return value will reduce the number of
-   iterations required. */
-
-/*  int bformata (bstring b, const char * fmt, ...)
- *
- *  After the first parameter, it takes the same parameters as printf (), but 
- *  rather than outputting results to stdio, it appends the results to 
- *  a bstring which contains what would have been output. Note that if there 
- *  is an early generation of a '\0' character, the bstring will be truncated 
- *  to this end point.
- */
-int bformata (bstring b, const char * fmt, ...) {
-va_list arglist;
-bstring buff;
-int n, r;
-
-	if (b == NULL || fmt == NULL || b->data == NULL || b->mlen <= 0 
-	 || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR;
-
-	/* Since the length is not determinable beforehand, a search is
-	   performed using the truncating "vsnprintf" call (to avoid buffer
-	   overflows) on increasing potential sizes for the output result. */
-
-	if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF;
-	if (NULL == (buff = bfromcstralloc (n + 2, ""))) {
-		n = 1;
-		if (NULL == (buff = bfromcstralloc (n + 2, ""))) return BSTR_ERR;
-	}
-
-	for (;;) {
-		va_start (arglist, fmt);
-		exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist);
-		va_end (arglist);
-
-		buff->data[n] = (unsigned char) '\0';
-		buff->slen = (int) (strlen) ((char *) buff->data);
-
-		if (buff->slen < n) break;
-
-		if (r > n) n = r; else n += n;
-
-		if (BSTR_OK != balloc (buff, n + 2)) {
-			bdestroy (buff);
-			return BSTR_ERR;
-		}
-	}
-
-	r = bconcat (b, buff);
-	bdestroy (buff);
-	return r;
-}
-
-/*  int bassignformat (bstring b, const char * fmt, ...)
- *
- *  After the first parameter, it takes the same parameters as printf (), but 
- *  rather than outputting results to stdio, it outputs the results to 
- *  the bstring parameter b. Note that if there is an early generation of a 
- *  '\0' character, the bstring will be truncated to this end point.
- */
-int bassignformat (bstring b, const char * fmt, ...) {
-va_list arglist;
-bstring buff;
-int n, r;
-
-	if (b == NULL || fmt == NULL || b->data == NULL || b->mlen <= 0 
-	 || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR;
-
-	/* Since the length is not determinable beforehand, a search is
-	   performed using the truncating "vsnprintf" call (to avoid buffer
-	   overflows) on increasing potential sizes for the output result. */
-
-	if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF;
-	if (NULL == (buff = bfromcstralloc (n + 2, ""))) {
-		n = 1;
-		if (NULL == (buff = bfromcstralloc (n + 2, ""))) return BSTR_ERR;
-	}
-
-	for (;;) {
-		va_start (arglist, fmt);
-		exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist);
-		va_end (arglist);
-
-		buff->data[n] = (unsigned char) '\0';
-		buff->slen = (int) (strlen) ((char *) buff->data);
-
-		if (buff->slen < n) break;
-
-		if (r > n) n = r; else n += n;
-
-		if (BSTR_OK != balloc (buff, n + 2)) {
-			bdestroy (buff);
-			return BSTR_ERR;
-		}
-	}
-
-	r = bassign (b, buff);
-	bdestroy (buff);
-	return r;
-}
-
-/*  bstring bformat (const char * fmt, ...)
- *
- *  Takes the same parameters as printf (), but rather than outputting results
- *  to stdio, it forms a bstring which contains what would have been output.
- *  Note that if there is an early generation of a '\0' character, the 
- *  bstring will be truncated to this end point.
- */
-bstring bformat (const char * fmt, ...) {
-va_list arglist;
-bstring buff;
-int n, r;
-
-	if (fmt == NULL) return NULL;
-
-	/* Since the length is not determinable beforehand, a search is
-	   performed using the truncating "vsnprintf" call (to avoid buffer
-	   overflows) on increasing potential sizes for the output result. */
-
-	if ((n = (int) (2*strlen (fmt))) < START_VSNBUFF) n = START_VSNBUFF;
-	if (NULL == (buff = bfromcstralloc (n + 2, ""))) {
-		n = 1;
-		if (NULL == (buff = bfromcstralloc (n + 2, ""))) return NULL;
-	}
-
-	for (;;) {
-		va_start (arglist, fmt);
-		exvsnprintf (r, (char *) buff->data, n + 1, fmt, arglist);
-		va_end (arglist);
-
-		buff->data[n] = (unsigned char) '\0';
-		buff->slen = (int) (strlen) ((char *) buff->data);
-
-		if (buff->slen < n) break;
-
-		if (r > n) n = r; else n += n;
-
-		if (BSTR_OK != balloc (buff, n + 2)) {
-			bdestroy (buff);
-			return NULL;
-		}
-	}
-
-	return buff;
-}
-
-/*  int bvcformata (bstring b, int count, const char * fmt, va_list arglist)
- *
- *  The bvcformata function formats data under control of the format control 
- *  string fmt and attempts to append the result to b.  The fmt parameter is 
- *  the same as that of the printf function.  The variable argument list is 
- *  replaced with arglist, which has been initialized by the va_start macro.
- *  The size of the appended output is upper bounded by count.  If the 
- *  required output exceeds count, the string b is not augmented with any 
- *  contents and a value below BSTR_ERR is returned.  If a value below -count 
- *  is returned then it is recommended that the negative of this value be 
- *  used as an update to the count in a subsequent pass.  On other errors, 
- *  such as running out of memory, parameter errors or numeric wrap around 
- *  BSTR_ERR is returned.  BSTR_OK is returned when the output is successfully 
- *  generated and appended to b.
- *
- *  Note: There is no sanity checking of arglist, and this function is
- *  destructive of the contents of b from the b->slen point onward.  If there 
- *  is an early generation of a '\0' character, the bstring will be truncated 
- *  to this end point.
- */
-int bvcformata (bstring b, int count, const char * fmt, va_list arg) {
-int n, r, l;
-
-	if (b == NULL || fmt == NULL || count <= 0 || b->data == NULL
-	 || b->mlen <= 0 || b->slen < 0 || b->slen > b->mlen) return BSTR_ERR;
-
-	if (count > (n = b->slen + count) + 2) return BSTR_ERR;
-	if (BSTR_OK != balloc (b, n + 2)) return BSTR_ERR;
-
-	exvsnprintf (r, (char *) b->data + b->slen, count + 2, fmt, arg);
-
-	/* Did the operation complete successfully within bounds? */
-	for (l = b->slen; l <= n; l++) {
-		if ('\0' == b->data[l]) {
-			b->slen = l;
-			return BSTR_OK;
-		}
-	}
-
-	/* Abort, since the buffer was not large enough.  The return value 
-	   tries to help set what the retry length should be. */
-
-	b->data[b->slen] = '\0';
-	if (r > count + 1) {	/* Does r specify a particular target length? */
-		n = r;
-	} else {
-		n = count + count;	/* If not, just double the size of count */
-		if (count > n) n = INT_MAX;
-	}
-	n = -n;
-
-	if (n > BSTR_ERR-1) n = BSTR_ERR-1;
-	return n;
-}
-
-#endif
diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/bstrlib.h b/build/tools/HLSLcc/May_2014/src/cbstring/bstrlib.h
deleted file mode 100644
index 24626b9..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/bstrlib.h
+++ /dev/null
@@ -1,304 +0,0 @@
-/*
- * This source file is part of the bstring string library.  This code was
- * written by Paul Hsieh in 2002-2010, and is covered by either the 3-clause 
- * BSD open source license or GPL v2.0. Refer to the accompanying documentation 
- * for details on usage and license.
- */
-
-/*
- * bstrlib.h
- *
- * This file is the header file for the core module for implementing the 
- * bstring functions.
- */
-
-#ifndef BSTRLIB_INCLUDE
-#define BSTRLIB_INCLUDE
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdarg.h>
-#include <string.h>
-#include <limits.h>
-#include <ctype.h>
-
-#if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP)
-# if defined (__TURBOC__) && !defined (__BORLANDC__)
-#  define BSTRLIB_NOVSNP
-# endif
-#endif
-
-#define BSTR_ERR (-1)
-#define BSTR_OK (0)
-#define BSTR_BS_BUFF_LENGTH_GET (0)
-
-typedef struct tagbstring * bstring;
-typedef const struct tagbstring * const_bstring;
-
-/* Copy functions */
-#define cstr2bstr bfromcstr
-extern bstring bfromcstr (const char * str);
-extern bstring bfromcstralloc (int mlen, const char * str);
-extern bstring blk2bstr (const void * blk, int len);
-extern char * bstr2cstr (const_bstring s, char z);
-extern int bcstrfree (char * s);
-extern bstring bstrcpy (const_bstring b1);
-extern int bassign (bstring a, const_bstring b);
-extern int bassignmidstr (bstring a, const_bstring b, int left, int len);
-extern int bassigncstr (bstring a, const char * str);
-extern int bassignblk (bstring a, const void * s, int len);
-
-/* Destroy function */
-extern int bdestroy (bstring b);
-
-/* Space allocation hinting functions */
-extern int balloc (bstring s, int len);
-extern int ballocmin (bstring b, int len);
-
-/* Substring extraction */
-extern bstring bmidstr (const_bstring b, int left, int len);
-
-/* Various standard manipulations */
-extern int bconcat (bstring b0, const_bstring b1);
-extern int bconchar (bstring b0, char c);
-extern int bcatcstr (bstring b, const char * s);
-extern int bcatblk (bstring b, const void * s, int len);
-extern int binsert (bstring s1, int pos, const_bstring s2, unsigned char fill);
-extern int binsertch (bstring s1, int pos, int len, unsigned char fill);
-extern int breplace (bstring b1, int pos, int len, const_bstring b2, unsigned char fill);
-extern int bdelete (bstring s1, int pos, int len);
-extern int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill);
-extern int btrunc (bstring b, int n);
-
-/* Scan/search functions */
-extern int bstricmp (const_bstring b0, const_bstring b1);
-extern int bstrnicmp (const_bstring b0, const_bstring b1, int n);
-extern int biseqcaseless (const_bstring b0, const_bstring b1);
-extern int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len);
-extern int biseq (const_bstring b0, const_bstring b1);
-extern int bisstemeqblk (const_bstring b0, const void * blk, int len);
-extern int biseqcstr (const_bstring b, const char * s);
-extern int biseqcstrcaseless (const_bstring b, const char * s);
-extern int bstrcmp (const_bstring b0, const_bstring b1);
-extern int bstrncmp (const_bstring b0, const_bstring b1, int n);
-extern int binstr (const_bstring s1, int pos, const_bstring s2);
-extern int binstrr (const_bstring s1, int pos, const_bstring s2);
-extern int binstrcaseless (const_bstring s1, int pos, const_bstring s2);
-extern int binstrrcaseless (const_bstring s1, int pos, const_bstring s2);
-extern int bstrchrp (const_bstring b, int c, int pos);
-extern int bstrrchrp (const_bstring b, int c, int pos);
-#define bstrchr(b,c) bstrchrp ((b), (c), 0)
-#define bstrrchr(b,c) bstrrchrp ((b), (c), blength(b)-1)
-extern int binchr (const_bstring b0, int pos, const_bstring b1);
-extern int binchrr (const_bstring b0, int pos, const_bstring b1);
-extern int bninchr (const_bstring b0, int pos, const_bstring b1);
-extern int bninchrr (const_bstring b0, int pos, const_bstring b1);
-extern int bfindreplace (bstring b, const_bstring find, const_bstring repl, int pos);
-extern int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, int pos);
-
-/* List of string container functions */
-struct bstrList {
-    int qty, mlen;
-    bstring * entry;
-};
-extern struct bstrList * bstrListCreate (void);
-extern int bstrListDestroy (struct bstrList * sl);
-extern int bstrListAlloc (struct bstrList * sl, int msz);
-extern int bstrListAllocMin (struct bstrList * sl, int msz);
-
-/* String split and join functions */
-extern struct bstrList * bsplit (const_bstring str, unsigned char splitChar);
-extern struct bstrList * bsplits (const_bstring str, const_bstring splitStr);
-extern struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr);
-extern bstring bjoin (const struct bstrList * bl, const_bstring sep);
-extern int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm);
-extern int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm);
-extern int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm);
-
-/* Miscellaneous functions */
-extern int bpattern (bstring b, int len);
-extern int btoupper (bstring b);
-extern int btolower (bstring b);
-extern int bltrimws (bstring b);
-extern int brtrimws (bstring b);
-extern int btrimws (bstring b);
-
-/* <*>printf format functions */
-#if !defined (BSTRLIB_NOVSNP)
-extern bstring bformat (const char * fmt, ...);
-extern int bformata (bstring b, const char * fmt, ...);
-extern int bassignformat (bstring b, const char * fmt, ...);
-extern int bvcformata (bstring b, int count, const char * fmt, va_list arglist);
-
-#define bvformata(ret, b, fmt, lastarg) { \
-bstring bstrtmp_b = (b); \
-const char * bstrtmp_fmt = (fmt); \
-int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16; \
-	for (;;) { \
-		va_list bstrtmp_arglist; \
-		va_start (bstrtmp_arglist, lastarg); \
-		bstrtmp_r = bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \
-		va_end (bstrtmp_arglist); \
-		if (bstrtmp_r >= 0) { /* Everything went ok */ \
-			bstrtmp_r = BSTR_OK; \
-			break; \
-		} else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \
-			bstrtmp_r = BSTR_ERR; \
-			break; \
-		} \
-		bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \
-	} \
-	ret = bstrtmp_r; \
-}
-
-#endif
-
-typedef int (*bNgetc) (void *parm);
-typedef size_t (* bNread) (void *buff, size_t elsize, size_t nelem, void *parm);
-
-/* Input functions */
-extern bstring bgets (bNgetc getcPtr, void * parm, char terminator);
-extern bstring bread (bNread readPtr, void * parm);
-extern int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator);
-extern int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator);
-extern int breada (bstring b, bNread readPtr, void * parm);
-
-/* Stream functions */
-extern struct bStream * bsopen (bNread readPtr, void * parm);
-extern void * bsclose (struct bStream * s);
-extern int bsbufflength (struct bStream * s, int sz);
-extern int bsreadln (bstring b, struct bStream * s, char terminator);
-extern int bsreadlns (bstring r, struct bStream * s, const_bstring term);
-extern int bsread (bstring b, struct bStream * s, int n);
-extern int bsreadlna (bstring b, struct bStream * s, char terminator);
-extern int bsreadlnsa (bstring r, struct bStream * s, const_bstring term);
-extern int bsreada (bstring b, struct bStream * s, int n);
-extern int bsunread (struct bStream * s, const_bstring b);
-extern int bspeek (bstring r, const struct bStream * s);
-extern int bssplitscb (struct bStream * s, const_bstring splitStr, 
-	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
-extern int bssplitstrcb (struct bStream * s, const_bstring splitStr, 
-	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
-extern int bseof (const struct bStream * s);
-
-struct tagbstring {
-	int mlen;
-	int slen;
-	unsigned char * data;
-};
-
-/* Accessor macros */
-#define blengthe(b, e)      (((b) == (void *)0 || (b)->slen < 0) ? (int)(e) : ((b)->slen))
-#define blength(b)          (blengthe ((b), 0))
-#define bdataofse(b, o, e)  (((b) == (void *)0 || (b)->data == (void*)0) ? (char *)(e) : ((char *)(b)->data) + (o))
-#define bdataofs(b, o)      (bdataofse ((b), (o), (void *)0))
-#define bdatae(b, e)        (bdataofse (b, 0, e))
-#define bdata(b)            (bdataofs (b, 0))
-#define bchare(b, p, e)     ((((unsigned)(p)) < (unsigned)blength(b)) ? ((b)->data[(p)]) : (e))
-#define bchar(b, p)         bchare ((b), (p), '\0')
-
-/* Static constant string initialization macro */
-#define bsStaticMlen(q,m)   {(m), (int) sizeof(q)-1, (unsigned char *) ("" q "")}
-#if defined(_MSC_VER)
-/* There are many versions of MSVC which emit __LINE__ as a non-constant. */
-# define bsStatic(q)        bsStaticMlen(q,-32)
-#endif
-#ifndef bsStatic
-# define bsStatic(q)        bsStaticMlen(q,-__LINE__)
-#endif
-
-/* Static constant block parameter pair */
-#define bsStaticBlkParms(q) ((void *)("" q "")), ((int) sizeof(q)-1)
-
-/* Reference building macros */
-#define cstr2tbstr btfromcstr
-#define btfromcstr(t,s) {                                            \
-    (t).data = (unsigned char *) (s);                                \
-    (t).slen = ((t).data) ? ((int) (strlen) ((char *)(t).data)) : 0; \
-    (t).mlen = -1;                                                   \
-}
-#define blk2tbstr(t,s,l) {            \
-    (t).data = (unsigned char *) (s); \
-    (t).slen = l;                     \
-    (t).mlen = -1;                    \
-}
-#define btfromblk(t,s,l) blk2tbstr(t,s,l)
-#define bmid2tbstr(t,b,p,l) {                                                \
-    const_bstring bstrtmp_s = (b);                                           \
-    if (bstrtmp_s && bstrtmp_s->data && bstrtmp_s->slen >= 0) {              \
-        int bstrtmp_left = (p);                                              \
-        int bstrtmp_len  = (l);                                              \
-        if (bstrtmp_left < 0) {                                              \
-            bstrtmp_len += bstrtmp_left;                                     \
-            bstrtmp_left = 0;                                                \
-        }                                                                    \
-        if (bstrtmp_len > bstrtmp_s->slen - bstrtmp_left)                    \
-            bstrtmp_len = bstrtmp_s->slen - bstrtmp_left;                    \
-        if (bstrtmp_len <= 0) {                                              \
-            (t).data = (unsigned char *)"";                                  \
-            (t).slen = 0;                                                    \
-        } else {                                                             \
-            (t).data = bstrtmp_s->data + bstrtmp_left;                       \
-            (t).slen = bstrtmp_len;                                          \
-        }                                                                    \
-    } else {                                                                 \
-        (t).data = (unsigned char *)"";                                      \
-        (t).slen = 0;                                                        \
-    }                                                                        \
-    (t).mlen = -__LINE__;                                                    \
-}
-#define btfromblkltrimws(t,s,l) {                                            \
-    int bstrtmp_idx = 0, bstrtmp_len = (l);                                  \
-    unsigned char * bstrtmp_s = (s);                                         \
-    if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
-        for (; bstrtmp_idx < bstrtmp_len; bstrtmp_idx++) {                   \
-            if (!isspace (bstrtmp_s[bstrtmp_idx])) break;                    \
-        }                                                                    \
-    }                                                                        \
-    (t).data = bstrtmp_s + bstrtmp_idx;                                      \
-    (t).slen = bstrtmp_len - bstrtmp_idx;                                    \
-    (t).mlen = -__LINE__;                                                    \
-}
-#define btfromblkrtrimws(t,s,l) {                                            \
-    int bstrtmp_len = (l) - 1;                                               \
-    unsigned char * bstrtmp_s = (s);                                         \
-    if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
-        for (; bstrtmp_len >= 0; bstrtmp_len--) {                            \
-            if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \
-        }                                                                    \
-    }                                                                        \
-    (t).data = bstrtmp_s;                                                    \
-    (t).slen = bstrtmp_len + 1;                                              \
-    (t).mlen = -__LINE__;                                                    \
-}
-#define btfromblktrimws(t,s,l) {                                             \
-    int bstrtmp_idx = 0, bstrtmp_len = (l) - 1;                              \
-    unsigned char * bstrtmp_s = (s);                                         \
-    if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
-        for (; bstrtmp_idx <= bstrtmp_len; bstrtmp_idx++) {                  \
-            if (!isspace (bstrtmp_s[bstrtmp_idx])) break;                    \
-        }                                                                    \
-        for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) {                  \
-            if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \
-        }                                                                    \
-    }                                                                        \
-    (t).data = bstrtmp_s + bstrtmp_idx;                                      \
-    (t).slen = bstrtmp_len + 1 - bstrtmp_idx;                                \
-    (t).mlen = -__LINE__;                                                    \
-}
-
-/* Write protection macros */
-#define bwriteprotect(t)     { if ((t).mlen >=  0) (t).mlen = -1; }
-#define bwriteallow(t)       { if ((t).mlen == -1) (t).mlen = (t).slen + ((t).slen == 0); }
-#define biswriteprotected(t) ((t).mlen <= 0)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/bstrlib.txt b/build/tools/HLSLcc/May_2014/src/cbstring/bstrlib.txt
deleted file mode 100644
index 8ebb188..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/bstrlib.txt
+++ /dev/null
@@ -1,3201 +0,0 @@
-Better String library
----------------------
-
-by Paul Hsieh
-
-The bstring library is an attempt to provide improved string processing 
-functionality to the C and C++ language.  At the heart of the bstring library 
-(Bstrlib for short) is the management of "bstring"s which are a significant 
-improvement over '\0' terminated char buffers.
-
-===============================================================================
-
-Motivation
-----------
-
-The standard C string library has serious problems:
-
-    1) Its use of '\0' to denote the end of the string means knowing a 
-       string's length is O(n) when it could be O(1).
-    2) It imposes an interpretation for the character value '\0'.
-    3) gets() always exposes the application to a buffer overflow.
-    4) strtok() modifies the string its parsing and thus may not be usable in
-       programs which are re-entrant or multithreaded.
-    5) fgets has the unusual semantic of ignoring '\0's that occur before
-       '\n's are consumed.
-    6) There is no memory management, and actions performed such as strcpy,
-       strcat and sprintf are common places for buffer overflows.
-    7) strncpy() doesn't '\0' terminate the destination in some cases.
-    8) Passing NULL to C library string functions causes an undefined NULL 
-       pointer access.
-    9) Parameter aliasing (overlapping, or self-referencing parameters) 
-       within most C library functions has undefined behavior.
-   10) Many C library string function calls take integer parameters with 
-       restricted legal ranges.  Parameters passed outside these ranges are
-       not typically detected and cause undefined behavior.
-
-So the desire is to create an alternative string library that does not suffer
-from the above problems and adds in the following functionality:
-
-    1) Incorporate string functionality seen from other languages.
-        a) MID$() - from BASIC
-        b) split()/join() - from Python
-        c) string/char x n - from Perl
-    2) Implement analogs to functions that combine stream IO and char buffers
-       without creating a dependency on stream IO functionality.
-    3) Implement the basic text editor-style functions insert, delete, find,
-       and replace.
-    4) Implement reference based sub-string access (as a generalization of 
-       pointer arithmetic.)
-    5) Implement runtime write protection for strings.
-
-There is also a desire to avoid "API-bloat".  So functionality that can be
-implemented trivially in other functionality is omitted.  So there is no
-left$() or right$() or reverse() or anything like that as part of the core 
-functionality.
-
-Explaining Bstrings
--------------------
-
-A bstring is basically a header which wraps a pointer to a char buffer.  Lets
-start with the declaration of a struct tagbstring:
-
-    struct tagbstring {
-        int mlen;
-        int slen;
-        unsigned char * data;
-    };
-
-This definition is considered exposed, not opaque (though it is neither 
-necessary nor recommended that low level maintenance of bstrings be performed 
-whenever the abstract interfaces are sufficient).  The mlen field (usually)
-describes a lower bound for the memory allocated for the data field.  The 
-slen field describes the exact length for the bstring.  The data field is a 
-single contiguous buffer of unsigned chars.  Note that the existence of a '\0' 
-character in the unsigned char buffer pointed to by the data field does not 
-necessarily denote the end of the bstring.
-
-To be a well formed modifiable bstring the mlen field must be at least the 
-length of the slen field, and slen must be non-negative.  Furthermore, the 
-data field must point to a valid buffer in which access to the first mlen 
-characters has been acquired.  So the minimal check for correctness is:
-
-    (slen >= 0 && mlen >= slen && data != NULL)
-
-bstrings returned by bstring functions can be assumed to be either NULL or
-satisfy the above property.  (When bstrings are only readable, the mlen >= 
-slen restriction is not required; this is discussed later in this section.)  
-A bstring itself is just a pointer to a struct tagbstring:
-
-    typedef struct tagbstring * bstring;
-
-Note that use of the prefix "tag" in struct tagbstring is required to work
-around the inconsistency between C and C++'s struct namespace usage.  This
-definition is also considered exposed.
-
-Bstrlib basically manages bstrings allocated as a header and an associated 
-data-buffer.  Since the implementation is exposed, they can also be 
-constructed manually.  Functions which mutate bstrings assume that the header 
-and data buffer have been malloced; the bstring library may perform free() or 
-realloc() on both the header and data buffer of any bstring parameter. 
-Functions which return bstring's create new bstrings.  The string memory is 
-freed by a bdestroy() call (or using the bstrFree macro).
-
-The following related typedef is also provided:
-
-    typedef const struct tagbstring * const_bstring;
-
-which is also considered exposed.  These are directly bstring compatible (no
-casting required) but are just used for parameters which are meant to be 
-non-mutable.  So in general, bstring parameters which are read as input but 
-not meant to be modified will be declared as const_bstring, and bstring
-parameters which may be modified will be declared as bstring.  This convention
-is recommended for user written functions as well.
-
-Since bstrings maintain interoperability with C library char-buffer style 
-strings, all functions which modify, update or create bstrings also append a 
-'\0' character into the position slen + 1.  This trailing '\0' character is 
-not required for bstrings input to the bstring functions; this is provided 
-solely as a convenience for interoperability with standard C char-buffer 
-functionality.
-
-Analogs for the ANSI C string library functions have been created when they
-are necessary, but have also been left out when they are not.  In particular
-there are no functions analogous to fwrite, or puts just for the purposes of
-bstring.  The ->data member of any string is exposed, and therefore can be
-used just as easily as char buffers for C functions which read strings.
-
-For those that wish to hand construct bstrings, the following should be kept 
-in mind:
-
-    1) While bstrlib can accept constructed bstrings without terminating
-       '\0' characters, the rest of the C language string library will not
-       function properly on such non-terminated strings.  This is obvious
-       but must be kept in mind.
-    2) If it is intended that a constructed bstring be written to by the
-       bstring library functions then the data portion should be allocated
-       by the malloc function and the slen and mlen fields should be entered
-       properly.  The struct tagbstring header is not reallocated, and only
-       freed by bdestroy.
-    3) Writing arbitrary '\0' characters at various places in the string
-       will not modify its length as perceived by the bstring library 
-       functions.  In fact, '\0' is a legitimate non-terminating character
-       for a bstring to contain.
-    4) For read only parameters, bstring functions do not check the mlen.  
-       I.e., the minimal correctness requirements are reduced to:
-
-            (slen >= 0 && data != NULL)
-
-Better pointer arithmetic
--------------------------
-
-One built-in feature of '\0' terminated char * strings, is that its very easy
-and fast to obtain a reference to the tail of any string using pointer 
-arithmetic.  Bstrlib does one better by providing a way to get a reference to
-any substring of a bstring (or any other length delimited block of memory.)
-So rather than just having pointer arithmetic, with bstrlib one essentially 
-has segment arithmetic.  This is achieved using the macro blk2tbstr() which 
-builds a reference to a block of memory and the macro bmid2tbstr() which 
-builds a reference to a segment of a bstring.  Bstrlib also includes 
-functions for direct consumption of memory blocks into bstrings, namely 
-bcatblk () and blk2bstr ().
-
-One scenario where this can be extremely useful is when string contains many 
-substrings which one would like to pass as read-only reference parameters to 
-some string consuming function without the need to allocate entire new 
-containers for the string data.  More concretely, imagine parsing a command 
-line string whose parameters are space delimited.  This can only be done for 
-tails of the string with '\0' terminated char * strings.
-
-Improved NULL semantics and error handling
-------------------------------------------
-
-Unless otherwise noted, if a NULL pointer is passed as a bstring or any other 
-detectably illegal parameter, the called function will return with an error 
-indicator (either NULL or BSTR_ERR) rather than simply performing a NULL 
-pointer access, or having undefined behavior.
-
-To illustrate the value of this, consider the following example:
-
-        strcpy (p = malloc (13 * sizeof (char)), "Hello,");
-        strcat (p, " World");
-
-This is not correct because malloc may return NULL (due to an out of memory 
-condition), and the behaviour of strcpy is undefined if either of its 
-parameters are NULL.  However:
-
-        bstrcat (p = bfromcstr ("Hello,"), q = bfromcstr (" World"));
-        bdestroy (q);
-
-is well defined, because if either p or q are assigned NULL (indicating a 
-failure to allocate memory) both bstrcat and bdestroy will recognize it and 
-perform no detrimental action.
-
-Note that it is not necessary to check any of the members of a returned 
-bstring for internal correctness (in particular the data member does not need 
-to be checked against NULL when the header is non-NULL), since this is 
-assured by the bstring library itself.
-
-bStreams
---------
-
-In addition to the bgets and bread functions, bstrlib can abstract streams 
-with a high performance read only stream called a bStream.  In general, the 
-idea is to open a core stream (with something like fopen) then pass its
-handle as well as a bNread function pointer (like fread) to the bsopen 
-function which will return a handle to an open bStream.  Then the functions 
-bsread, bsreadln or bsreadlns can be called to read portions of the stream.  
-Finally, the bsclose function is called to close the bStream -- it will 
-return a handle to the original (core) stream.  So bStreams, essentially, 
-wrap other streams.
-
-The bStreams have two main advantages over the bgets and bread (as well as
-fgets/ungetc) paradigms:
-
-1) Improved functionality via the bunread function which allows a stream to 
-   unread characters, giving the bStream stack-like functionality if so 
-   desired.
-2) A very high performance bsreadln function.  The C library function fgets()
-   (and the bgets function) can typically be written as a loop on top of 
-   fgetc(), thus paying all of the overhead costs of calling fgetc on a per 
-   character basis.  bsreadln will read blocks at a time, thus amortizing the 
-   overhead of fread calls over many characters at once.
-
-However, clearly bStreams are suboptimal or unusable for certain kinds of 
-streams (stdin) or certain usage patterns (a few spotty, or non-sequential
-reads from a slow stream.)  For those situations, using bgets will be more 
-appropriate.
-
-The semantics of bStreams allows practical construction of layerable data 
-streams.  What this means is that by writing a bNread compatible function on
-top of a bStream, one can construct a new bStream on top of it.  This can be
-useful for writing multi-pass parsers that don't actually read the entire
-input more than once and don't require the use of intermediate storage.
-
-Aliasing
---------
-
-Aliasing occurs when a function is given two parameters which point to data
-structures which overlap in the memory they occupy.  While this does not
-disturb read only functions, for many libraries this can make functions that 
-write to these memory locations malfunction.  This is a common problem of the 
-C standard library and especially the string functions in the C standard 
-library.
-
-The C standard string library is entirely char by char oriented (as is 
-bstring) which makes conforming implementations alias safe for some 
-scenarios.  However no actual detection of aliasing is typically performed, 
-so it is easy to find cases where the aliasing will cause anomolous or 
-undesirable behaviour (consider: strcat (p, p).)  The C99 standard includes 
-the "restrict" pointer modifier which allows the compiler to document and 
-assume a no-alias condition on usage.  However, only the most trivial cases 
-can be caught (if at all) by the compiler at compile time, and thus there is 
-no actual enforcement of non-aliasing.
-
-Bstrlib, by contrast, permits aliasing and is completely aliasing safe, in 
-the C99 sense of aliasing.  That is to say, under the assumption that 
-pointers of incompatible types from distinct objects can never alias, bstrlib 
-is completely aliasing safe.  (In practice this means that the data buffer 
-portion of any bstring and header of any bstring are assumed to never alias.) 
-With the exception of the reference building macros, the library behaves as 
-if all read-only parameters are first copied and replaced by temporary 
-non-aliased parameters before any writing to any output bstring is performed 
-(though actual copying is extremely rarely ever done.)
-
-Besides being a useful safety feature, bstring searching/comparison 
-functions can improve to O(1) execution when aliasing is detected.
-
-Note that aliasing detection and handling code in Bstrlib is generally 
-extremely cheap.  There is almost never any appreciable performance penalty
-for using aliased parameters.
-
-Reenterancy
------------
-
-Nearly every function in Bstrlib is a leaf function, and is completely 
-reenterable with the exception of writing to common bstrings.  The split 
-functions which use a callback mechanism requires only that the source string 
-not be destroyed by the callback function unless the callback function returns
-with an error status (note that Bstrlib functions which return an error do 
-not modify the string in any way.)  The string can in fact be modified by the
-callback and the behaviour is deterministic.  See the documentation of the 
-various split functions for more details.
-
-Undefined scenarios
--------------------
-
-One of the basic important premises for Bstrlib is to not to increase the
-propogation of undefined situations from parameters that are otherwise legal
-in of themselves.  In particular, except for extremely marginal cases, usages 
-of bstrings that use the bstring library functions alone cannot lead to any 
-undefined action.  But due to C/C++ language and library limitations, there 
-is no way to define a non-trivial library that is completely without 
-undefined operations.  All such possible undefined operations are described 
-below:
-
-1) bstrings or struct tagbstrings that are not explicitely initialized cannot
-   be passed as a parameter to any bstring function.
-2) The members of the NULL bstring cannot be accessed directly.  (Though all
-   APIs and macros detect the NULL bstring.)
-3) A bstring whose data member has not been obtained from a malloc or 
-   compatible call and which is write accessible passed as a writable 
-   parameter will lead to undefined results.  (i.e., do not writeAllow any 
-   constructed bstrings unless the data portion has been obtained from the 
-   heap.)
-4) If the headers of two strings alias but are not identical (which can only 
-   happen via a defective manual construction), then passing them to a 
-   bstring function in which one is writable is not defined.
-5) If the mlen member is larger than the actual accessible length of the data 
-   member for a writable bstring, or if the slen member is larger than the 
-   readable length of the data member for a readable bstring, then the 
-   corresponding bstring operations are undefined.
-6) Any bstring definition whose header or accessible data portion has been
-   assigned to inaccessible or otherwise illegal memory clearly cannot be
-   acted upon by the bstring library in any way.
-7) Destroying the source of an incremental split from within the callback
-   and not returning with a negative value (indicating that it should abort)
-   will lead to undefined behaviour.  (Though *modifying* or adjusting the 
-   state of the source data, even if those modification fail within the 
-   bstrlib API, has well defined behavior.)
-8) Modifying a bstring which is write protected by direct access has 
-   undefined behavior.
-
-While this may seem like a long list, with the exception of invalid uses of 
-the writeAllow macro, and source destruction during an iterative split 
-without an accompanying abort, no usage of the bstring API alone can cause 
-any undefined scenario to occurr.  I.e., the policy of restricting usage of 
-bstrings to the bstring API can significantly reduce the risk of runtime 
-errors (in practice it should eliminate them) related to string manipulation 
-due to undefined action.
-
-C++ wrapper
------------
-
-A C++ wrapper has been created to enable bstring functionality for C++ in the
-most natural (for C++ programers) way possible.  The mandate for the C++ 
-wrapper is different from the base C bstring library.  Since the C++ language 
-has far more abstracting capabilities, the CBString structure is considered 
-fully abstracted -- i.e., hand generated CBStrings are not supported (though 
-conversion from a struct tagbstring is allowed) and all detectable errors are
-manifest as thrown exceptions.
-
-- The C++ class definitions are all under the namespace Bstrlib.  bstrwrap.h 
-  enables this namespace (with a using namespace Bstrlib; directive at the 
-  end) unless the macro BSTRLIB_DONT_ASSUME_NAMESPACE has been defined before 
-  it is included.
-
-- Erroneous accesses results in an exception being thrown.  The exception 
-  parameter is of type "struct CBStringException" which is derived from
-  std::exception if STL is used.  A verbose description of the error message 
-  can be obtained from the what() method.
-
-- CBString is a C++ structure derived from a struct tagbstring.  An address 
-  of a CBString cast to a bstring must not be passed to bdestroy.  The bstring 
-  C API has been made C++ safe and can be used directly in a C++ project.
-
-- It includes constructors which can take a char, '\0' terminated char 
-  buffer, tagbstring, (char, repeat-value), a length delimited buffer or a 
-  CBStringList to initialize it.
-
-- Concatenation is performed with the + and += operators.  Comparisons are 
-  done with the ==, !=, <, >, <= and >= operators.  Note that == and != use
-  the biseq call, while <, >, <= and >= use bstrcmp.
-
-- CBString's can be directly cast to const character buffers.
-
-- CBString's can be directly cast to double, float, int or unsigned int so
-  long as the CBString are decimal representations of those types (otherwise
-  an exception will be thrown).  Converting the other way should be done with
-  the format(a) method(s).
-
-- CBString contains the length, character and [] accessor methods.  The
-  character and [] accessors are aliases of each other.  If the bounds for 
-  the string are exceeded, an exception is thrown.  To avoid the overhead for
-  this check, first cast the CBString to a (const char *) and use [] to 
-  dereference the array as normal.  Note that the character and [] accessor 
-  methods allows both reading and writing of individual characters.
-
-- The methods: format, formata, find, reversefind, findcaseless, 
-  reversefindcaseless, midstr, insert, insertchrs, replace, findreplace, 
-  findreplacecaseless, remove, findchr, nfindchr, alloc, toupper, tolower, 
-  gets, read are analogous to the functions that can be found in the C API.
-
-- The caselessEqual and caselessCmp methods are analogous to biseqcaseless
-  and bstricmp functions respectively.
-
-- Note that just like the bformat function, the format and formata methods do 
-  not automatically cast CBStrings into char * strings for "%s"-type 
-  substitutions:
-
-	CBString w("world");
-	CBString h("Hello");
-	CBString hw;
-
-	/* The casts are necessary */
-	hw.format ("%s, %s", (const char *)h, (const char *)w);
-
-- The methods trunc and repeat have been added instead of using pattern.
-
-- ltrim, rtrim and trim methods have been added.  These remove characters 
-  from a given character string set (defaulting to the whitespace characters) 
-  from either the left, right or both ends of the CBString, respectively.
-
-- The method setsubstr is also analogous in functionality to bsetstr, except 
-  that it cannot be passed NULL.  Instead the method fill and the fill-style 
-  constructor have been supplied to enable this functionality.
-
-- The writeprotect(), writeallow() and iswriteprotected() methods are 
-  analogous to the bwriteprotect(), bwriteallow() and biswriteprotected() 
-  macros in the C API.  Write protection semantics in CBString are stronger 
-  than with the C API in that indexed character assignment is checked for 
-  write protection.  However, unlike with the C API, a write protected 
-  CBString can be destroyed by the destructor.
-
-- CBStream is a C++ structure which wraps a struct bStream (its not derived
-  from it, since destruction is slightly different).  It is constructed by
-  passing in a bNread function pointer and a stream parameter cast to void *. 
-  This structure includes methods for detecting eof, setting the buffer 
-  length, reading the whole stream or reading entries line by line or block 
-  by block, an unread function, and a peek function.
-
-- If STL is available, the CBStringList structure is derived from a vector of 
-  CBString with various split methods.  The split method has been overloaded 
-  to accept either a character or CBString as the second parameter (when the 
-  split parameter is a CBString any character in that CBString is used as a
-  seperator).  The splitstr method takes a CBString as a substring seperator. 
-  Joins can be performed via a CBString constructor which takes a 
-  CBStringList as a parameter, or just using the CBString::join() method.
-
-- If there is proper support for std::iostreams, then the >> and << operators 
-  and the getline() function have been added (with semantics the same as 
-  those for std::string).
-
-Multithreading
---------------
-
-A mutable bstring is kind of analogous to a small (two entry) linked list 
-allocated by malloc, with all aliasing completely under programmer control. 
-I.e., manipulation of one bstring will never affect any other distinct 
-bstring unless explicitely constructed to do so by the programmer via hand 
-construction or via building a reference.  Bstrlib also does not use any 
-static or global storage, so there are no hidden unremovable race conditions. 
-Bstrings are also clearly not inherently thread local.  So just like 
-char *'s, bstrings can be passed around from thread to thread and shared and 
-so on, so long as modifications to a bstring correspond to some kind of 
-exclusive access lock as should be expected (or if the bstring is read-only, 
-which can be enforced by bstring write protection) for any sort of shared 
-object in a multithreaded environment.
-
-Bsafe module
-------------
-
-For convenience, a bsafe module has been included.  The idea is that if this
-module is included, inadvertant usage of the most dangerous C functions will 
-be overridden and lead to an immediate run time abort.  Of course, it should 
-be emphasized that usage of this module is completely optional.  The 
-intention is essentially to provide an option for creating project safety 
-rules which can be enforced mechanically rather than socially.  This is 
-useful for larger, or open development projects where its more difficult to 
-enforce social rules or "coding conventions".
-
-Problems not solved
--------------------
-
-Bstrlib is written for the C and C++ languages, which have inherent weaknesses
-that cannot be easily solved:
-
-1. Memory leaks:  Forgetting to call bdestroy on a bstring that is about to be
-   unreferenced, just as forgetting to call free on a heap buffer that is 
-   about to be dereferenced.  Though bstrlib itself is leak free.
-2. Read before write usage:  In C, declaring an auto bstring does not 
-   automatically fill it with legal/valid contents.  This problem has been 
-   somewhat mitigated in C++.  (The bstrDeclare and bstrFree macros from 
-   bstraux can be used to help mitigate this problem.)
-
-Other problems not addressed:
-
-3. Built-in mutex usage to automatically avoid all bstring internal race 
-   conditions in multitasking environments: The problem with trying to 
-   implement such things at this low a level is that it is typically more 
-   efficient to use locks in higher level primitives. There is also no 
-   platform independent way to implement locks or mutexes.
-4. Unicode/widecharacter support.
-
-Note that except for spotty support of wide characters, the default C 
-standard library does not address any of these problems either.
-
-Configurable compilation options
---------------------------------
-
-All configuration options are meant solely for the purpose of compiler 
-compatibility.  Configuration options are not meant to change the semantics
-or capabilities of the library, except where it is unavoidable.
-
-Since some C++ compilers don't include the Standard Template Library and some 
-have the options of disabling exception handling, a number of macros can be 
-used to conditionally compile support for each of this:
-
-BSTRLIB_CAN_USE_STL
-
-  - defining this will enable the used of the Standard Template Library.  
-    Defining BSTRLIB_CAN_USE_STL overrides the BSTRLIB_CANNOT_USE_STL macro.
-
-BSTRLIB_CANNOT_USE_STL
-
-  - defining this will disable the use of the Standard Template Library.  
-    Defining BSTRLIB_CAN_USE_STL overrides the BSTRLIB_CANNOT_USE_STL macro.
-
-BSTRLIB_CAN_USE_IOSTREAM
-
-  - defining this will enable the used of streams from class std.  Defining 
-    BSTRLIB_CAN_USE_IOSTREAM overrides the BSTRLIB_CANNOT_USE_IOSTREAM macro.
-
-BSTRLIB_CANNOT_USE_IOSTREAM
-
-  - defining this will disable the use of streams from class std.  Defining 
-    BSTRLIB_CAN_USE_IOSTREAM overrides the BSTRLIB_CANNOT_USE_IOSTREAM macro.
-
-BSTRLIB_THROWS_EXCEPTIONS
-
-  - defining this will enable the exception handling within bstring.
-    Defining BSTRLIB_THROWS_EXCEPTIONS overrides the 
-    BSTRLIB_DOESNT_THROWS_EXCEPTIONS macro.
-
-BSTRLIB_DOESNT_THROW_EXCEPTIONS
-
-  - defining this will disable the exception handling within bstring.
-    Defining BSTRLIB_THROWS_EXCEPTIONS overrides the 
-    BSTRLIB_DOESNT_THROW_EXCEPTIONS macro.
-
-Note that these macros must be defined consistently throughout all modules 
-that use CBStrings including bstrwrap.cpp.
-
-Some older C compilers do not support functions such as vsnprintf.  This is 
-handled by the following macro variables:
-
-BSTRLIB_NOVSNP
-
-  - defining this indicates that the compiler does not support vsnprintf.
-    This will cause bformat and bformata to not be declared.  Note that
-    for some compilers, such as Turbo C, this is set automatically.
-    Defining BSTRLIB_NOVSNP overrides the BSTRLIB_VSNP_OK macro.
-
-BSTRLIB_VSNP_OK
-
-  - defining this will disable the autodetection of compilers the do not
-    support of compilers that do not support vsnprintf.
-    Defining BSTRLIB_NOVSNP overrides the BSTRLIB_VSNP_OK macro.
-
-Semantic compilation options
-----------------------------
-
-Bstrlib comes with very few compilation options for changing the semantics of
-of the library.  These are described below.
-
-BSTRLIB_DONT_ASSUME_NAMESPACE
-
-  - Defining this before including bstrwrap.h will disable the automatic 
-    enabling of the Bstrlib namespace for the C++ declarations.
-
-BSTRLIB_DONT_USE_VIRTUAL_DESTRUCTOR
-
-  - Defining this will make the CBString destructor non-virtual.
-
-BSTRLIB_MEMORY_DEBUG
-
-  - Defining this will cause the bstrlib modules bstrlib.c and bstrwrap.cpp
-    to invoke a #include "memdbg.h".  memdbg.h has to be supplied by the user.
-
-Note that these macros must be defined consistently throughout all modules 
-that use bstrings or CBStrings including bstrlib.c, bstraux.c and 
-bstrwrap.cpp.
-
-===============================================================================
-
-Files
------
-
-bstrlib.c       - C implementaion of bstring functions.
-bstrlib.h       - C header file for bstring functions.
-bstraux.c       - C example that implements trivial additional functions.
-bstraux.h       - C header for bstraux.c
-bstest.c        - C unit/regression test for bstrlib.c
-
-bstrwrap.cpp    - C++ implementation of CBString.
-bstrwrap.h      - C++ header file for CBString.
-test.cpp        - C++ unit/regression test for bstrwrap.cpp
-
-bsafe.c         - C runtime stubs to abort usage of unsafe C functions.
-bsafe.h         - C header file for bsafe.c functions.
-
-C projects need only include bstrlib.h and compile/link bstrlib.c to use the
-bstring library.  C++ projects need to additionally include bstrwrap.h and
-compile/link bstrwrap.cpp.  For both, there may be a need to make choices 
-about feature configuration as described in the "Configurable compilation 
-options" in the section above.
-
-Other files that are included in this archive are:
-
-license.txt     - The 3 clause BSD license for Bstrlib
-gpl.txt         - The GPL version 2
-security.txt    - A security statement useful for auditting Bstrlib
-porting.txt     - A guide to porting Bstrlib
-bstrlib.txt     - This file
-
-===============================================================================
-
-The functions
--------------
-
-    extern bstring bfromcstr (const char * str);
-
-    Take a standard C library style '\0' terminated char buffer and generate
-    a bstring with the same contents as the char buffer.  If an error occurs 
-    NULL is returned.
-
-    So for example:
-
-	bstring b = bfromcstr ("Hello");
-	if (!b) {
-		fprintf (stderr, "Out of memory");
-	} else {
-		puts ((char *) b->data);
-	}
-
-    ..........................................................................
-
-    extern bstring bfromcstralloc (int mlen, const char * str);
-
-    Create a bstring which contains the contents of the '\0' terminated 
-    char * buffer str.  The memory buffer backing the bstring is at least 
-    mlen characters in length.  If an error occurs NULL is returned.
-
-    So for example:
-
-	bstring b = bfromcstralloc (64, someCstr);
-	if (b) b->data[63] = 'x';
-
-    The idea is that this will set the 64th character of b to 'x' if it is at 
-    least 64 characters long otherwise do nothing.  And we know this is well 
-    defined so long as b was successfully created, since it will have been 
-    allocated with at least 64 characters.
-
-    ..........................................................................
-
-    extern bstring blk2bstr (const void * blk, int len);
-
-    Create a bstring whose contents are described by the contiguous buffer 
-    pointing to by blk with a length of len bytes.  Note that this function
-    creates a copy of the data in blk, rather than simply referencing it.  
-    Compare with the blk2tbstr macro.  If an error occurs NULL is returned.
-
-    ..........................................................................
-
-    extern char * bstr2cstr (const_bstring s, char z);
-
-    Create a '\0' terminated char buffer which contains the contents of the 
-    bstring s, except that any contained '\0' characters are converted to the 
-    character in z.  This returned value should be freed with bcstrfree(), by 
-    the caller.  If an error occurs NULL is returned.
-
-    ..........................................................................
-
-    extern int bcstrfree (char * s);
-
-    Frees a C-string generated by bstr2cstr ().  This is normally unnecessary
-    since it just wraps a call to free (), however, if malloc () and free () 
-    have been redefined as a macros within the bstrlib module (via macros in 
-    the memdbg.h backdoor) with some difference in behaviour from the std 
-    library functions, then this allows a correct way of freeing the memory 
-    that allows higher level code to be independent from these macro 
-    redefinitions.
-
-    ..........................................................................
-
-    extern bstring bstrcpy (const_bstring b1);
-
-    Make a copy of the passed in bstring.  The copied bstring is returned if 
-    there is no error, otherwise NULL is returned.
-
-    ..........................................................................
-
-    extern int bassign (bstring a, const_bstring b);
-
-    Overwrite the bstring a with the contents of bstring b.  Note that the 
-    bstring a must be a well defined and writable bstring.  If an error 
-    occurs BSTR_ERR is returned and a is not overwritten.
-
-    ..........................................................................
-
-    int bassigncstr (bstring a, const char * str);
-
-    Overwrite the string a with the contents of char * string str.  Note that 
-    the bstring a must be a well defined and writable bstring.  If an error 
-    occurs BSTR_ERR is returned and a may be partially overwritten.
-
-    ..........................................................................
-
-    int bassignblk (bstring a, const void * s, int len);
-
-    Overwrite the string a with the contents of the block (s, len).  Note that 
-    the bstring a must be a well defined and writable bstring.  If an error 
-    occurs BSTR_ERR is returned and a is not overwritten.
-
-    ..........................................................................
-
-    extern int bassignmidstr (bstring a, const_bstring b, int left, int len);
-
-    Overwrite the bstring a with the middle of contents of bstring b 
-    starting from position left and running for a length len.  left and 
-    len are clamped to the ends of b as with the function bmidstr.  Note that 
-    the bstring a must be a well defined and writable bstring.  If an error 
-    occurs BSTR_ERR is returned and a is not overwritten.
-
-    ..........................................................................
-
-    extern bstring bmidstr (const_bstring b, int left, int len);
-
-    Create a bstring which is the substring of b starting from position left 
-    and running for a length len (clamped by the end of the bstring b.)  If 
-    there was no error, the value of this constructed bstring is returned 
-    otherwise NULL is returned.
-
-    ..........................................................................
-
-    extern int bdelete (bstring s1, int pos, int len);
-
-    Removes characters from pos to pos+len-1 and shifts the tail of the 
-    bstring starting from pos+len to pos.  len must be positive for this call 
-    to have any effect.  The section of the bstring described by (pos, len) 
-    is clamped to boundaries of the bstring b.  The value BSTR_OK is returned 
-    if the operation is successful, otherwise BSTR_ERR is returned.
-
-    ..........................................................................
-
-    extern int bconcat (bstring b0, const_bstring b1);
-
-    Concatenate the bstring b1 to the end of bstring b0.  The value BSTR_OK 
-    is returned if the operation is successful, otherwise BSTR_ERR is 
-    returned.
-
-    ..........................................................................
-
-    extern int bconchar (bstring b, char c);
-
-    Concatenate the character c to the end of bstring b.  The value BSTR_OK 
-    is returned if the operation is successful, otherwise BSTR_ERR is 
-    returned.
-
-    ..........................................................................
-
-    extern int bcatcstr (bstring b, const char * s);
-
-    Concatenate the char * string s to the end of bstring b.  The value 
-    BSTR_OK is returned if the operation is successful, otherwise BSTR_ERR is 
-    returned.
-
-    ..........................................................................
-
-    extern int bcatblk (bstring b, const void * s, int len);
-
-    Concatenate a fixed length buffer (s, len) to the end of bstring b.  The 
-    value BSTR_OK is returned if the operation is successful, otherwise 
-    BSTR_ERR is returned.
-
-    ..........................................................................
-
-    extern int biseq (const_bstring b0, const_bstring b1);
-
-    Compare the bstring b0 and b1 for equality.  If the bstrings differ, 0 
-    is returned, if the bstrings are the same, 1 is returned, if there is an 
-    error, -1 is returned.  If the length of the bstrings are different, this 
-    function has O(1) complexity.  Contained '\0' characters are not treated 
-    as a termination character.
-
-    Note that the semantics of biseq are not completely compatible with 
-    bstrcmp because of its different treatment of the '\0' character.
-
-    ..........................................................................
-
-    extern int bisstemeqblk (const_bstring b, const void * blk, int len);
-
-    Compare beginning of bstring b0 with a block of memory of length len for 
-    equality.  If the beginning of b0 differs from the memory block (or if b0 
-    is too short), 0 is returned, if the bstrings are the same, 1 is returned, 
-    if there is an error, -1 is returned.
-
-    ..........................................................................
-
-    extern int biseqcaseless (const_bstring b0, const_bstring b1);
-
-    Compare two bstrings for equality without differentiating between case.  
-    If the bstrings differ other than in case, 0 is returned, if the bstrings 
-    are the same, 1 is returned, if there is an error, -1 is returned.  If 
-    the length of the bstrings are different, this function is O(1).  '\0' 
-    termination characters are not treated in any special way.
-
-    ..........................................................................
-
-    extern int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len);
-
-    Compare beginning of bstring b0 with a block of memory of length len 
-    without differentiating between case for equality.  If the beginning of b0
-    differs from the memory block other than in case (or if b0 is too short), 
-    0 is returned, if the bstrings are the same, 1 is returned, if there is an 
-    error, -1 is returned.
-
-    ..........................................................................
-
-    extern int biseqcstr (const_bstring b, const char *s);
-
-    Compare the bstring b and char * bstring s.  The C string s must be '\0' 
-    terminated at exactly the length of the bstring b, and the contents 
-    between the two must be identical with the bstring b with no '\0' 
-    characters for the two contents to be considered equal.  This is 
-    equivalent to the condition that their current contents will be always be 
-    equal when comparing them in the same format after converting one or the 
-    other.  If they are equal 1 is returned, if they are unequal 0 is 
-    returned and if there is a detectable error BSTR_ERR is returned.
-
-    ..........................................................................
-
-    extern int biseqcstrcaseless (const_bstring b, const char *s);
-
-    Compare the bstring b and char * string s.  The C string s must be '\0'
-    terminated at exactly the length of the bstring b, and the contents
-    between the two must be identical except for case with the bstring b with
-    no '\0' characters for the two contents to be considered equal.  This is
-    equivalent to the condition that their current contents will be always be
-    equal ignoring case when comparing them in the same format after
-    converting one or the other.  If they are equal, except for case, 1 is 
-    returned, if they are unequal regardless of case 0 is returned and if 
-    there is a detectable error BSTR_ERR is returned.
-
-    ..........................................................................
-
-    extern int bstrcmp (const_bstring b0, const_bstring b1);
-
-    Compare the bstrings b0 and b1 for ordering.  If there is an error, 
-    SHRT_MIN is returned, otherwise a value less than or greater than zero, 
-    indicating that the bstring pointed to by b0 is lexicographically less 
-    than or greater than the bstring pointed to by b1 is returned.  If the
-    bstring lengths are unequal but the characters up until the length of the 
-    shorter are equal then a value less than, or greater than zero, 
-    indicating that the bstring pointed to by b0 is shorter or longer than the 
-    bstring pointed to by b1 is returned.  0 is returned if and only if the 
-    two bstrings are the same.  If the length of the bstrings are different, 
-    this function is O(n).  Like its standard C library counter part, the 
-    comparison does not proceed past any '\0' termination characters 
-    encountered.
-
-    The seemingly odd error return value, merely provides slightly more 
-    granularity than the undefined situation given in the C library function 
-    strcmp.  The function otherwise behaves very much like strcmp().
-
-    Note that the semantics of bstrcmp are not completely compatible with 
-    biseq because of its different treatment of the '\0' termination 
-    character.
-
-    ..........................................................................
-
-    extern int bstrncmp (const_bstring b0, const_bstring b1, int n);
-
-    Compare the bstrings b0 and b1 for ordering for at most n characters.  If 
-    there is an error, SHRT_MIN is returned, otherwise a value is returned as 
-    if b0 and b1 were first truncated to at most n characters then bstrcmp 
-    was called with these new bstrings are paremeters.  If the length of the 
-    bstrings are different, this function is O(n).  Like its standard C 
-    library counter part, the comparison does not proceed past any '\0' 
-    termination characters encountered.
-
-    The seemingly odd error return value, merely provides slightly more 
-    granularity than the undefined situation given in the C library function 
-    strncmp.  The function otherwise behaves very much like strncmp().
-
-    ..........................................................................
-
-    extern int bstricmp (const_bstring b0, const_bstring b1);
-
-    Compare two bstrings without differentiating between case.  The return 
-    value is the difference of the values of the characters where the two 
-    bstrings first differ, otherwise 0 is returned indicating that the 
-    bstrings are equal.  If the lengths are different, then a difference from 
-    0 is given, but if the first extra character is '\0', then it is taken to 
-    be the value UCHAR_MAX+1.
-
-    ..........................................................................
-
-    extern int bstrnicmp (const_bstring b0, const_bstring b1, int n);
-
-    Compare two bstrings without differentiating between case for at most n
-    characters.  If the position where the two bstrings first differ is
-    before the nth position, the return value is the difference of the values
-    of the characters, otherwise 0 is returned.  If the lengths are different
-    and less than n characters, then a difference from 0 is given, but if the 
-    first extra character is '\0', then it is taken to be the value 
-    UCHAR_MAX+1.
-
-    ..........................................................................
-
-    extern int bdestroy (bstring b);
-
-    Deallocate the bstring passed.  Passing NULL in as a parameter will have 
-    no effect.  Note that both the header and the data portion of the bstring 
-    will be freed.  No other bstring function which modifies one of its 
-    parameters will free or reallocate the header.  Because of this, in 
-    general, bdestroy cannot be called on any declared struct tagbstring even 
-    if it is not write protected.  A bstring which is write protected cannot 
-    be destroyed via the bdestroy call.  Any attempt to do so will result in 
-    no action taken, and BSTR_ERR will be returned.
-
-    Note to C++ users: Passing in a CBString cast to a bstring will lead to
-    undefined behavior (free will be called on the header, rather than the
-    CBString destructor.)  Instead just use the ordinary C++ language 
-    facilities to dealloc a CBString.
-
-    ..........................................................................
-
-    extern int binstr (const_bstring s1, int pos, const_bstring s2);
-
-    Search for the bstring s2 in s1 starting at position pos and looking in a
-    forward (increasing) direction.  If it is found then it returns with the 
-    first position after pos where it is found, otherwise it returns BSTR_ERR.  
-    The algorithm used is brute force; O(m*n).
-
-    ..........................................................................
-
-    extern int binstrr (const_bstring s1, int pos, const_bstring s2);
-
-    Search for the bstring s2 in s1 starting at position pos and looking in a
-    backward (decreasing) direction.  If it is found then it returns with the 
-    first position after pos where it is found, otherwise return BSTR_ERR.  
-    Note that the current position at pos is tested as well -- so to be 
-    disjoint from a previous forward search it is recommended that the 
-    position be backed up (decremented) by one position.  The algorithm used 
-    is brute force; O(m*n).
-
-    ..........................................................................
-
-    extern int binstrcaseless (const_bstring s1, int pos, const_bstring s2);
-
-    Search for the bstring s2 in s1 starting at position pos and looking in a
-    forward (increasing) direction but without regard to case.  If it is 
-    found then it returns with the first position after pos where it is 
-    found, otherwise it returns BSTR_ERR. The algorithm used is brute force; 
-    O(m*n).
-
-    ..........................................................................
-
-    extern int binstrrcaseless (const_bstring s1, int pos, const_bstring s2);
-
-    Search for the bstring s2 in s1 starting at position pos and looking in a
-    backward (decreasing) direction but without regard to case.  If it is 
-    found then it returns with the first position after pos where it is 
-    found, otherwise return BSTR_ERR. Note that the current position at pos 
-    is tested as well -- so to be disjoint from a previous forward search it 
-    is recommended that the position be backed up (decremented) by one 
-    position.  The algorithm used is brute force; O(m*n).
-
-    ..........................................................................
-
-    extern int binchr (const_bstring b0, int pos, const_bstring b1);
-
-    Search for the first position in b0 starting from pos or after, in which 
-    one of the characters in b1 is found.  This function has an execution 
-    time of O(b0->slen + b1->slen).  If such a position does not exist in b0, 
-    then BSTR_ERR is returned.
-
-    ..........................................................................
-
-    extern int binchrr (const_bstring b0, int pos, const_bstring b1);
-
-    Search for the last position in b0 no greater than pos, in which one of 
-    the characters in b1 is found.  This function has an execution time
-    of O(b0->slen + b1->slen).  If such a position does not exist in b0, 
-    then BSTR_ERR is returned.
-
-    ..........................................................................
-
-    extern int bninchr (const_bstring b0, int pos, const_bstring b1);
-
-    Search for the first position in b0 starting from pos or after, in which 
-    none of the characters in b1 is found and return it.  This function has 
-    an execution time of O(b0->slen + b1->slen).  If such a position does 
-    not exist in b0, then BSTR_ERR is returned.
-
-    ..........................................................................
-
-    extern int bninchrr (const_bstring b0, int pos, const_bstring b1);
-  
-    Search for the last position in b0 no greater than pos, in which none of 
-    the characters in b1 is found and return it.  This function has an 
-    execution time of O(b0->slen + b1->slen).  If such a position does not 
-    exist in b0, then BSTR_ERR is returned.
-
-    ..........................................................................
-
-    extern int bstrchr (const_bstring b, int c);
-
-    Search for the character c in the bstring b forwards from the start of 
-    the bstring.  Returns the position of the found character or BSTR_ERR if 
-    it is not found.
-
-    NOTE: This has been implemented as a macro on top of bstrchrp ().
-
-    ..........................................................................
-
-    extern int bstrrchr (const_bstring b, int c);
-
-    Search for the character c in the bstring b backwards from the end of the 
-    bstring.  Returns the position of the found character or BSTR_ERR if it is 
-    not found.
-
-    NOTE: This has been implemented as a macro on top of bstrrchrp ().
-
-    ..........................................................................
-
-    extern int bstrchrp (const_bstring b, int c, int pos);
-  
-    Search for the character c in b forwards from the position pos 
-    (inclusive).  Returns the position of the found character or BSTR_ERR if 
-    it is not found.
-
-    ..........................................................................
-
-    extern int bstrrchrp (const_bstring b, int c, int pos);
-
-    Search for the character c in b backwards from the position pos in bstring 
-    (inclusive).  Returns the position of the found character or BSTR_ERR if 
-    it is not found.
-
-    ..........................................................................
-
-    extern int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill);
-
-    Overwrite the bstring b0 starting at position pos with the bstring b1. If 
-    the position pos is past the end of b0, then the character "fill" is 
-    appended as necessary to make up the gap between the end of b0 and pos.
-    If b1 is NULL, it behaves as if it were a 0-length bstring. The value 
-    BSTR_OK is returned if the operation is successful, otherwise BSTR_ERR is 
-    returned.
-
-    ..........................................................................
-
-    extern int binsert (bstring s1, int pos, const_bstring s2, unsigned char fill);
-
-    Inserts the bstring s2 into s1 at position pos.  If the position pos is 
-    past the end of s1, then the character "fill" is appended as necessary to 
-    make up the gap between the end of s1 and pos.  The value BSTR_OK is 
-    returned if the operation is successful, otherwise BSTR_ERR is returned.
-
-    ..........................................................................
-
-    extern int binsertch (bstring s1, int pos, int len, unsigned char fill);
-
-    Inserts the character fill repeatedly into s1 at position pos for a 
-    length len.  If the position pos is past the end of s1, then the 
-    character "fill" is appended as necessary to make up the gap between the 
-    end of s1 and the position pos + len (exclusive).  The value BSTR_OK is 
-    returned if the operation is successful, otherwise BSTR_ERR is returned.
-
-    ..........................................................................
-
-    extern int breplace (bstring b1, int pos, int len, const_bstring b2, 
-                         unsigned char fill);
-
-    Replace a section of a bstring from pos for a length len with the bstring 
-    b2. If the position pos is past the end of b1 then the character "fill"
-    is appended as necessary to make up the gap between the end of b1 and 
-    pos.
-
-    ..........................................................................
-
-    extern int bfindreplace (bstring b, const_bstring find,
-                             const_bstring replace, int position);
-
-    Replace all occurrences of the find substring with a replace bstring 
-    after a given position in the bstring b.  The find bstring must have a 
-    length > 0 otherwise BSTR_ERR is returned.  This function does not 
-    perform recursive per character replacement; that is to say successive
-    searches resume at the position after the last replace.
-
-    So for example:
-
-        bfindreplace (a0 = bfromcstr("aabaAb"), a1 = bfromcstr("a"),
-                      a2 = bfromcstr("aa"), 0);
-
-    Should result in changing a0 to "aaaabaaAb".
-
-    This function performs exactly (b->slen - position) bstring comparisons, 
-    and data movement is bounded above by character volume equivalent to size 
-    of the output bstring.
-
-    ..........................................................................
-
-    extern int bfindreplacecaseless (bstring b, const_bstring find,
-                             const_bstring replace, int position);
-
-    Replace all occurrences of the find substring, ignoring case, with a 
-    replace bstring after a given position in the bstring b.  The find bstring 
-    must have a length > 0 otherwise BSTR_ERR is returned.  This function 
-    does not perform recursive per character replacement; that is to say 
-    successive searches resume at the position after the last replace.
-
-    So for example:
-
-        bfindreplacecaseless (a0 = bfromcstr("AAbaAb"), a1 = bfromcstr("a"),
-                              a2 = bfromcstr("aa"), 0);
-
-    Should result in changing a0 to "aaaabaaaab".
-
-    This function performs exactly (b->slen - position) bstring comparisons, 
-    and data movement is bounded above by character volume equivalent to size 
-    of the output bstring.
-
-    ..........................................................................
-
-    extern int balloc (bstring b, int length);
-
-    Increase the allocated memory backing the data buffer for the bstring b
-    to a length of at least length.  If the memory backing the bstring b is
-    already large enough, not action is performed.  This has no effect on the 
-    bstring b that is visible to the bstring API.  Usually this function will 
-    only be used when a minimum buffer size is required coupled with a direct 
-    access to the ->data member of the bstring structure.
-
-    Be warned that like any other bstring function, the bstring must be well
-    defined upon entry to this function.  I.e., doing something like:
-
-        b->slen *= 2; /* ?? Most likely incorrect */
-        balloc (b, b->slen);
-
-    is invalid, and should be implemented as:
-
-        int t;
-        if (BSTR_OK == balloc (b, t = (b->slen * 2))) b->slen = t;
-
-    This function will return with BSTR_ERR if b is not detected as a valid 
-    bstring or length is not greater than 0, otherwise BSTR_OK is returned.
-
-    ..........................................................................
-
-    extern int ballocmin (bstring b, int length);
-
-    Change the amount of memory backing the bstring b to at least length.  
-    This operation will never truncate the bstring data including the 
-    extra terminating '\0' and thus will not decrease the length to less than
-    b->slen + 1.  Note that repeated use of this function may cause 
-    performance problems (realloc may be called on the bstring more than
-    the O(log(INT_MAX)) times).  This function will return with BSTR_ERR if b 
-    is not detected as a valid bstring or length is not greater than 0, 
-    otherwise BSTR_OK is returned.
-
-    So for example:
-
-	if (BSTR_OK == ballocmin (b, 64)) b->data[63] = 'x';
-
-    The idea is that this will set the 64th character of b to 'x' if it is at 
-    least 64 characters long otherwise do nothing.  And we know this is well 
-    defined so long as the ballocmin call was successfully, since it will 
-    ensure that b has been allocated with at least 64 characters.
-
-    ..........................................................................
-
-    int btrunc (bstring b, int n);
-
-    Truncate the bstring to at most n characters.  This function will return 
-    with BSTR_ERR if b is not detected as a valid bstring or n is less than 
-    0, otherwise BSTR_OK is returned.
-
-    ..........................................................................
-
-    extern int bpattern (bstring b, int len);
-
-    Replicate the starting bstring, b, end to end repeatedly until it 
-    surpasses len characters, then chop the result to exactly len characters. 
-    This function operates in-place.  This function will return with BSTR_ERR 
-    if b is NULL or of length 0, otherwise BSTR_OK is returned.
-
-    ..........................................................................
-
-    extern int btoupper (bstring b);
-
-    Convert contents of bstring to upper case.  This function will return with 
-    BSTR_ERR if b is NULL or of length 0, otherwise BSTR_OK is returned.
-
-    ..........................................................................
-
-    extern int btolower (bstring b);
-
-    Convert contents of bstring to lower case.  This function will return with 
-    BSTR_ERR if b is NULL or of length 0, otherwise BSTR_OK is returned.
-
-    ..........................................................................
-
-    extern int bltrimws (bstring b);
-
-    Delete whitespace contiguous from the left end of the bstring.  This 
-    function will return with BSTR_ERR if b is NULL or of length 0, otherwise 
-    BSTR_OK is returned.
-
-    ..........................................................................
-
-    extern int brtrimws (bstring b);
-
-    Delete whitespace contiguous from the right end of the bstring.  This 
-    function will return with BSTR_ERR if b is NULL or of length 0, otherwise 
-    BSTR_OK is returned.
-
-    ..........................................................................
-
-    extern int btrimws (bstring b);
-
-    Delete whitespace contiguous from both ends of the bstring.  This function 
-    will return with BSTR_ERR if b is NULL or of length 0, otherwise BSTR_OK 
-    is returned.
-
-    ..........................................................................
-
-    extern int bstrListCreate (void);
-
-    Create an empty struct bstrList. The struct bstrList output structure is 
-    declared as follows:
-
-    struct bstrList {
-        int qty, mlen;
-        bstring * entry;
-    };
-
-    The entry field actually is an array with qty number entries.  The mlen
-    record counts the maximum number of bstring's for which there is memory
-    in the entry record.
-
-    The Bstrlib API does *NOT* include a comprehensive set of functions for 
-    full management of struct bstrList in an abstracted way.  The reason for 
-    this is because aliasing semantics of the list are best left to the user 
-    of this function, and performance varies wildly depending on the 
-    assumptions made.  For a complete list of bstring data type it is 
-    recommended that the C++ public std::vector<CBString> be used, since its
-    semantics are usage are more standard.
-
-    ..........................................................................
-
-    extern int bstrListDestroy (struct bstrList * sl);
-
-    Destroy a struct bstrList structure that was returned by the bsplit 
-    function.  Note that this will destroy each bstring in the ->entry array
-    as well.  See bstrListCreate() above for structure of struct bstrList.
-
-    ..........................................................................
-
-    extern int bstrListAlloc (struct bstrList * sl, int msz);
-
-    Ensure that there is memory for at least msz number of entries for the
-    list.
-
-    ..........................................................................
-
-    extern int bstrListAllocMin (struct bstrList * sl, int msz);
-
-    Try to allocate the minimum amount of memory for the list to include at
-    least msz entries or sl->qty whichever is greater.
-
-    ..........................................................................
-
-    extern struct bstrList * bsplit (bstring str, unsigned char splitChar);
-
-    Create an array of sequential substrings from str divided by the 
-    character splitChar.  Successive occurrences of the splitChar will be 
-    divided by empty bstring entries, following the semantics from the Python 
-    programming language.  To reclaim the memory from this output structure, 
-    bstrListDestroy () should be called.  See bstrListCreate() above for 
-    structure of struct bstrList.
-
-    ..........................................................................
-
-    extern struct bstrList * bsplits (bstring str, const_bstring splitStr);
-
-    Create an array of sequential substrings from str divided by any 
-    character contained in splitStr.  An empty splitStr causes a single entry 
-    bstrList containing a copy of str to be returned.  See bstrListCreate() 
-    above for structure of struct bstrList.
-
-    ..........................................................................
-
-    extern struct bstrList * bsplitstr (bstring str, const_bstring splitStr);
-
-    Create an array of sequential substrings from str divided by the entire 
-    substring splitStr.  An empty splitStr causes a single entry bstrList 
-    containing a copy of str to be returned.  See bstrListCreate() above for 
-    structure of struct bstrList.
-
-    ..........................................................................
-
-    extern bstring bjoin (const struct bstrList * bl, const_bstring sep);
-
-    Join the entries of a bstrList into one bstring by sequentially 
-    concatenating them with the sep bstring in between.  If sep is NULL, it
-    is treated as if it were the empty bstring.  Note that:
-
-        bjoin (l = bsplit (b, s->data[0]), s);
-
-    should result in a copy of b, if s->slen is 1.  If there is an error NULL 
-    is returned, otherwise a bstring with the correct result is returned.  
-    See bstrListCreate() above for structure of struct bstrList.
-
-    ..........................................................................
-
-    extern int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm);
-
-    Iterate the set of disjoint sequential substrings over str starting at 
-    position pos divided by the character splitChar.  The parm passed to 
-    bsplitcb is passed on to cb.  If the function cb returns a value < 0, 
-    then further iterating is halted and this value is returned by bsplitcb.
-
-    Note: Non-destructive modification of str from within the cb function 
-    while performing this split is not undefined.  bsplitcb behaves in 
-    sequential lock step with calls to cb.  I.e., after returning from a cb 
-    that return a non-negative integer, bsplitcb continues from the position 
-    1 character after the last detected split character and it will halt 
-    immediately if the length of str falls below this point.  However, if the 
-    cb function destroys str, then it *must* return with a negative value, 
-    otherwise bsplitcb will continue in an undefined manner.
-
-    This function is provided as an incremental alternative to bsplit that is
-    abortable and which does not impose additional memory allocation.
-
-    ..........................................................................
-
-    extern int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm);
-
-    Iterate the set of disjoint sequential substrings over str starting at 
-    position pos divided by any of the characters in splitStr.  An empty 
-    splitStr causes the whole str to be iterated once.  The parm passed to 
-    bsplitcb is passed on to cb.  If the function cb returns a value < 0, 
-    then further iterating is halted and this value is returned by bsplitcb.
-
-    Note: Non-destructive modification of str from within the cb function 
-    while performing this split is not undefined.  bsplitscb behaves in 
-    sequential lock step with calls to cb.  I.e., after returning from a cb 
-    that return a non-negative integer, bsplitscb continues from the position 
-    1 character after the last detected split character and it will halt 
-    immediately if the length of str falls below this point.  However, if the 
-    cb function destroys str, then it *must* return with a negative value, 
-    otherwise bsplitscb will continue in an undefined manner.
-
-    This function is provided as an incremental alternative to bsplits that 
-    is abortable and which does not impose additional memory allocation.
-
-    ..........................................................................
-
-    extern int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
-	int (* cb) (void * parm, int ofs, int len), void * parm);
-
-    Iterate the set of disjoint sequential substrings over str starting at 
-    position pos divided by the entire substring splitStr.  An empty splitStr 
-    causes each character of str to be iterated.  The parm passed to bsplitcb 
-    is passed on to cb.  If the function cb returns a value < 0, then further 
-    iterating is halted and this value is returned by bsplitcb.
-
-    Note: Non-destructive modification of str from within the cb function 
-    while performing this split is not undefined.  bsplitstrcb behaves in 
-    sequential lock step with calls to cb.  I.e., after returning from a cb 
-    that return a non-negative integer, bsplitstrcb continues from the position 
-    1 character after the last detected split character and it will halt 
-    immediately if the length of str falls below this point.  However, if the 
-    cb function destroys str, then it *must* return with a negative value, 
-    otherwise bsplitscb will continue in an undefined manner.
-
-    This function is provided as an incremental alternative to bsplitstr that 
-    is abortable and which does not impose additional memory allocation.
-
-    ..........................................................................
-
-    extern bstring bformat (const char * fmt, ...);
-
-    Takes the same parameters as printf (), but rather than outputting 
-    results to stdio, it forms a bstring which contains what would have been 
-    output. Note that if there is an early generation of a '\0' character, 
-    the bstring will be truncated to this end point.
-
-    Note that %s format tokens correspond to '\0' terminated char * buffers, 
-    not bstrings.  To print a bstring, first dereference data element of the 
-    the bstring:
-
-        /* b1->data needs to be '\0' terminated, so tagbstrings generated 
-           by blk2tbstr () might not be suitable. */
-        b0 = bformat ("Hello, %s", b1->data);
-
-    Note that if the BSTRLIB_NOVSNP macro has been set when bstrlib has been 
-    compiled the bformat function is not present.
-
-    ..........................................................................
-
-    extern int bformata (bstring b, const char * fmt, ...);
-
-    In addition to the initial output buffer b, bformata takes the same 
-    parameters as printf (), but rather than outputting results to stdio, it 
-    appends the results to the initial bstring parameter. Note that if 
-    there is an early generation of a '\0' character, the bstring will be 
-    truncated to this end point.
-
-    Note that %s format tokens correspond to '\0' terminated char * buffers, 
-    not bstrings.  To print a bstring, first dereference data element of the 
-    the bstring:
-
-        /* b1->data needs to be '\0' terminated, so tagbstrings generated 
-           by blk2tbstr () might not be suitable. */
-        bformata (b0 = bfromcstr ("Hello"), ", %s", b1->data); 
-
-    Note that if the BSTRLIB_NOVSNP macro has been set when bstrlib has been 
-    compiled the bformata function is not present.
-
-    ..........................................................................
-
-    extern int bassignformat (bstring b, const char * fmt, ...);
-
-    After the first parameter, it takes the same parameters as printf (), but 
-    rather than outputting results to stdio, it outputs the results to 
-    the bstring parameter b. Note that if there is an early generation of a 
-    '\0' character, the bstring will be truncated to this end point.
-
-    Note that %s format tokens correspond to '\0' terminated char * buffers, 
-    not bstrings.  To print a bstring, first dereference data element of the 
-    the bstring:
-
-        /* b1->data needs to be '\0' terminated, so tagbstrings generated 
-           by blk2tbstr () might not be suitable. */
-        bassignformat (b0 = bfromcstr ("Hello"), ", %s", b1->data); 
-
-    Note that if the BSTRLIB_NOVSNP macro has been set when bstrlib has been 
-    compiled the bassignformat function is not present.
-
-    ..........................................................................
-
-    extern int bvcformata (bstring b, int count, const char * fmt, va_list arglist);
-
-    The bvcformata function formats data under control of the format control 
-    string fmt and attempts to append the result to b.  The fmt parameter is 
-    the same as that of the printf function.  The variable argument list is 
-    replaced with arglist, which has been initialized by the va_start macro.
-    The size of the output is upper bounded by count.  If the required output
-    exceeds count, the string b is not augmented with any contents and a value
-    below BSTR_ERR is returned.  If a value below -count is returned then it
-    is recommended that the negative of this value be used as an update to the
-    count in a subsequent pass.  On other errors, such as running out of 
-    memory, parameter errors or numeric wrap around BSTR_ERR is returned.  
-    BSTR_OK is returned when the output is successfully generated and 
-    appended to b.
-
-    Note: There is no sanity checking of arglist, and this function is
-    destructive of the contents of b from the b->slen point onward.  If there 
-    is an early generation of a '\0' character, the bstring will be truncated 
-    to this end point.
-
-    Although this function is part of the external API for Bstrlib, the 
-    interface and semantics (length limitations, and unusual return codes) 
-    are fairly atypical.  The real purpose for this function is to provide an 
-    engine for the bvformata macro.
-
-    Note that if the BSTRLIB_NOVSNP macro has been set when bstrlib has been 
-    compiled the bvcformata function is not present.
-
-    ..........................................................................
-
-    extern bstring bread (bNread readPtr, void * parm);
-    typedef size_t (* bNread) (void *buff, size_t elsize, size_t nelem, 
-                               void *parm);
-
-    Read an entire stream into a bstring, verbatum.  The readPtr function 
-    pointer is compatible with fread sematics, except that it need not obtain 
-    the stream data from a file.  The intention is that parm would contain 
-    the stream data context/state required (similar to the role of the FILE* 
-    I/O stream parameter of fread.)
-
-    Abstracting the block read function allows for block devices other than 
-    file streams to be read if desired.  Note that there is an ANSI 
-    compatibility issue if "fread" is used directly; see the ANSI issues 
-    section below.
-
-    ..........................................................................
-
-    extern int breada (bstring b, bNread readPtr, void * parm);
-
-    Read an entire stream and append it to a bstring, verbatum.  Behaves 
-    like bread, except that it appends it results to the bstring b.
-    BSTR_ERR is returned on error, otherwise 0 is returned.
-
-    ..........................................................................
-
-    extern bstring bgets (bNgetc getcPtr, void * parm, char terminator);
-    typedef int (* bNgetc) (void * parm);
-
-    Read a bstring from a stream.  As many bytes as is necessary are read
-    until the terminator is consumed or no more characters are available from
-    the stream.  If read from the stream, the terminator character will be
-    appended to the end of the returned bstring.  The getcPtr function must 
-    have the same semantics as the fgetc C library function (i.e., returning 
-    an integer whose value is negative when there are no more characters 
-    available, otherwise the value of the next available unsigned character 
-    from the stream.)  The intention is that parm would contain the stream 
-    data context/state required (similar to the role of the FILE* I/O stream 
-    parameter of fgets.)  If no characters are read, or there is some other 
-    detectable error, NULL is returned.
-
-    bgets will never call the getcPtr function more often than necessary to
-    construct its output (including a single call, if required, to determine 
-    that the stream contains no more characters.)
-
-    Abstracting the character stream function and terminator character allows
-    for different stream devices and string formats other than '\n' 
-    terminated lines in a file if desired (consider \032 terminated email 
-    messages, in a UNIX mailbox for example.)
-
-    For files, this function can be used analogously as fgets as follows:
-
-        fp = fopen ( ... );
-        if (fp) b = bgets ((bNgetc) fgetc, fp, '\n');
-
-    (Note that only one terminator character can be used, and that '\0' is 
-    not assumed to terminate the stream in addition to the terminator 
-    character. This is consistent with the semantics of fgets.)
-
-    ..........................................................................
-
-    extern int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator);
-
-    Read from a stream and concatenate to a bstring.  Behaves like bgets, 
-    except that it appends it results to the bstring b.  The value 1 is 
-    returned if no characters are read before a negative result is returned
-    from getcPtr.  Otherwise BSTR_ERR is returned on error, and 0 is returned
-    in other normal cases.
-
-    ..........................................................................
-
-    extern int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator);
-
-    Read from a stream and concatenate to a bstring.  Behaves like bgets, 
-    except that it assigns the results to the bstring b.  The value 1 is 
-    returned if no characters are read before a negative result is returned
-    from getcPtr.  Otherwise BSTR_ERR is returned on error, and 0 is returned
-    in other normal cases.
-
-    ..........................................................................
-
-    extern struct bStream * bsopen (bNread readPtr, void * parm);
-  
-    Wrap a given open stream (described by a fread compatible function 
-    pointer and stream handle) into an open bStream suitable for the bstring 
-    library streaming functions.
-  
-    ..........................................................................
-
-    extern void * bsclose (struct bStream * s);
-  
-    Close the bStream, and return the handle to the stream that was 
-    originally used to open the given stream.  If s is NULL or detectably 
-    invalid, NULL will be returned.
-
-    ..........................................................................
-
-    extern int bsbufflength (struct bStream * s, int sz);
-
-    Set the length of the buffer used by the bStream.  If sz is the macro
-    BSTR_BS_BUFF_LENGTH_GET (which is 0), the length is not set.  If s is 
-    NULL or sz is negative, the function will return with BSTR_ERR, otherwise 
-    this function returns with the previous length.
-
-    ..........................................................................
-
-    extern int bsreadln (bstring r, struct bStream * s, char terminator);
-  
-    Read a bstring terminated by the terminator character or the end of the
-    stream from the bStream (s) and return it into the parameter r.  The 
-    matched terminator, if found, appears at the end of the line read.  If
-    the stream has been exhausted of all available data, before any can be
-    read, BSTR_ERR is returned.  This function may read additional characters 
-    into the stream buffer from the core stream that are not returned, but 
-    will be retained for subsequent read operations.  When reading from high 
-    speed streams, this function can perform significantly faster than bgets.
-
-    ..........................................................................
-
-    extern int bsreadlna (bstring r, struct bStream * s, char terminator);
-  
-    Read a bstring terminated by the terminator character or the end of the
-    stream from the bStream (s) and concatenate it to the parameter r.  The 
-    matched terminator, if found, appears at the end of the line read.  If
-    the stream has been exhausted of all available data, before any can be
-    read, BSTR_ERR is returned.  This function may read additional characters 
-    into the stream buffer from the core stream that are not returned, but 
-    will be retained for subsequent read operations.  When reading from high 
-    speed streams, this function can perform significantly faster than bgets.
-
-    ..........................................................................
-
-    extern int bsreadlns (bstring r, struct bStream * s, bstring terminators);
-
-    Read a bstring terminated by any character in the terminators bstring or 
-    the end of the stream from the bStream (s) and return it into the 
-    parameter r. This function may read additional characters from the core 
-    stream that are not returned, but will be retained for subsequent read 
-    operations.
-
-    ..........................................................................
-
-    extern int bsreadlnsa (bstring r, struct bStream * s, bstring terminators);
-
-    Read a bstring terminated by any character in the terminators bstring or 
-    the end of the stream from the bStream (s) and concatenate it to the 
-    parameter r.  If the stream has been exhausted of all available data, 
-    before any can be read, BSTR_ERR is returned.  This function may read 
-    additional characters from the core stream that are not returned, but 
-    will be retained for subsequent read operations.
-
-    ..........................................................................
-
-    extern int bsread (bstring r, struct bStream * s, int n);
-  
-    Read a bstring of length n (or, if it is fewer, as many bytes as is 
-    remaining) from the bStream.  This function will read the minimum 
-    required number of additional characters from the core stream.  When the
-    stream is at the end of the file BSTR_ERR is returned, otherwise BSTR_OK 
-    is returned.
-
-    ..........................................................................
-
-    extern int bsreada (bstring r, struct bStream * s, int n);
-  
-    Read a bstring of length n (or, if it is fewer, as many bytes as is 
-    remaining) from the bStream and concatenate it to the parameter r.  This 
-    function will read the minimum required number of additional characters 
-    from the core stream.  When the stream is at the end of the file BSTR_ERR 
-    is returned, otherwise BSTR_OK is returned.
-  
-    ..........................................................................
-  
-    extern int bsunread (struct bStream * s, const_bstring b);
-  
-    Insert a bstring into the bStream at the current position.  These 
-    characters will be read prior to those that actually come from the core 
-    stream.
-
-    ..........................................................................
-
-    extern int bspeek (bstring r, const struct bStream * s);
-  
-    Return the number of currently buffered characters from the bStream that 
-    will be read prior to reads from the core stream, and append it to the
-    the parameter r.
-
-    ..........................................................................
-
-    extern int bssplitscb (struct bStream * s, const_bstring splitStr, 
-	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
-
-    Iterate the set of disjoint sequential substrings over the stream s 
-    divided by any character from the bstring splitStr.  The parm passed to 
-    bssplitscb is passed on to cb.  If the function cb returns a value < 0, 
-    then further iterating is halted and this return value is returned by 
-    bssplitscb.
-
-    Note: At the point of calling the cb function, the bStream pointer is 
-    pointed exactly at the position right after having read the split 
-    character.  The cb function can act on the stream by causing the bStream
-    pointer to move, and bssplitscb will continue by starting the next split
-    at the position of the pointer after the return from cb.
-
-    However, if the cb causes the bStream s to be destroyed then the cb must
-    return with a negative value, otherwise bssplitscb will continue in an 
-    undefined manner.
-
-    This function is provided as way to incrementally parse through a file
-    or other generic stream that in total size may otherwise exceed the 
-    practical or desired memory available.  As with the other split callback
-    based functions this is abortable and does not impose additional memory 
-    allocation.
-
-    ..........................................................................
-    
-    extern int bssplitstrcb (struct bStream * s, const_bstring splitStr, 
-	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
-	
-    Iterate the set of disjoint sequential substrings over the stream s 
-    divided by the entire substring splitStr.  The parm passed to 
-    bssplitstrcb is passed on to cb.  If the function cb returns a 
-    value < 0, then further iterating is halted and this return value is 
-    returned by bssplitstrcb.
-
-    Note: At the point of calling the cb function, the bStream pointer is 
-    pointed exactly at the position right after having read the split 
-    character.  The cb function can act on the stream by causing the bStream
-    pointer to move, and bssplitstrcb will continue by starting the next 
-    split at the position of the pointer after the return from cb.
-
-    However, if the cb causes the bStream s to be destroyed then the cb must
-    return with a negative value, otherwise bssplitscb will continue in an 
-    undefined manner.
-
-    This function is provided as way to incrementally parse through a file
-    or other generic stream that in total size may otherwise exceed the 
-    practical or desired memory available.  As with the other split callback
-    based functions this is abortable and does not impose additional memory 
-    allocation.
-    
-    ..........................................................................
-    
-    extern int bseof (const struct bStream * s);
-
-    Return the defacto "EOF" (end of file) state of a stream (1 if the 
-    bStream is in an EOF state, 0 if not, and BSTR_ERR if stream is closed or 
-    detectably erroneous.)  When the readPtr callback returns a value <= 0 
-    the stream reaches its "EOF" state. Note that bunread with non-empty 
-    content will essentially turn off this state, and the stream will not be 
-    in its "EOF" state so long as its possible to read more data out of it.
-
-    Also note that the semantics of bseof() are slightly different from 
-    something like feof().  I.e., reaching the end of the stream does not
-    necessarily guarantee that bseof() will return with a value indicating
-    that this has happened.  bseof() will only return indicating that it has
-    reached the "EOF" and an attempt has been made to read past the end of
-    the bStream.
-
-The macros
-----------
-
-    The macros described below are shown in a prototype form indicating their
-    intended usage.  Note that the parameters passed to these macros will be
-    referenced multiple times.  As with all macros, programmer care is 
-    required to guard against unintended side effects.
-
-    int blengthe (const_bstring b, int err);
-
-    Returns the length of the bstring.  If the bstring is NULL err is 
-    returned.
-
-    ..........................................................................
-
-    int blength (const_bstring b);
-
-    Returns the length of the bstring.  If the bstring is NULL, the length 
-    returned is 0.
-
-    ..........................................................................
-
-    int bchare (const_bstring b, int p, int c);
-
-    Returns the p'th character of the bstring b.  If the position p refers to 
-    a position that does not exist in the bstring or the bstring is NULL, 
-    then c is returned.
-
-    ..........................................................................
-
-    char bchar (const_bstring b, int p);
-
-    Returns the p'th character of the bstring b.  If the position p refers to 
-    a position that does not exist in the bstring or the bstring is NULL, 
-    then '\0' is returned.
-
-    ..........................................................................
-
-    char * bdatae (bstring b, char * err);
-
-    Returns the char * data portion of the bstring b.  If b is NULL, err is
-    returned.
-
-    ..........................................................................
-
-    char * bdata (bstring b);
-
-    Returns the char * data portion of the bstring b.  If b is NULL, NULL is
-    returned.
-
-    ..........................................................................
-
-    char * bdataofse (bstring b, int ofs, char * err);
-
-    Returns the char * data portion of the bstring b offset by ofs.  If b is 
-    NULL, err is returned.
-
-    ..........................................................................
-
-    char * bdataofs (bstring b, int ofs);
-
-    Returns the char * data portion of the bstring b offset by ofs.  If b is 
-    NULL, NULL is returned.
-
-    ..........................................................................
-
-    struct tagbstring var = bsStatic ("...");
-
-    The bsStatic macro allows for static declarations of literal string 
-    constants as struct tagbstring structures.  The resulting tagbstring does 
-    not need to be freed or destroyed.  Note that this macro is only well
-    defined for string literal arguments.  For more general string pointers, 
-    use the btfromcstr macro.
-
-    The resulting struct tagbstring is permanently write protected.  Attempts 
-    to write to this struct tagbstring from any bstrlib function will lead to 
-    BSTR_ERR being returned.  Invoking the bwriteallow macro onto this struct 
-    tagbstring has no effect.
-
-    ..........................................................................
-
-    <void * blk, int len> <- bsStaticBlkParms ("...")
-
-    The bsStaticBlkParms macro emits a pair of comma seperated parameters 
-    corresponding to the block parameters for the block functions in Bstrlib 
-    (i.e., blk2bstr, bcatblk, blk2tbstr, bisstemeqblk, bisstemeqcaselessblk.) 
-    Note that this macro is only well defined for string literal arguments.
-
-    Examples:
-
-    bstring b = blk2bstr (bsStaticBlkParms ("Fast init. "));
-    bcatblk (b, bsStaticBlkParms ("No frills fast concatenation."));
-
-    These are faster than using bfromcstr() and bcatcstr() respectively 
-    because the length of the inline string is known as a compile time
-    constant.  Also note that seperate struct tagbstring declarations for
-    holding the output of a bsStatic() macro are not required.
-
-    ..........................................................................
-
-    void btfromcstr (struct tagbstring& t, const char * s);
-
-    Fill in the tagbstring t with the '\0' terminated char buffer s.  This 
-    action is purely reference oriented; no memory management is done.  The 
-    data member is just assigned s, and slen is assigned the strlen of s.  
-    The s parameter is accessed exactly once in this macro.
-
-    The resulting struct tagbstring is initially write protected.  Attempts 
-    to write to this struct tagbstring in a write protected state from any 
-    bstrlib function will lead to BSTR_ERR being returned.  Invoke the 
-    bwriteallow on this struct tagbstring to make it writeable (though this 
-    requires that s be obtained from a function compatible with malloc.)
-
-    ..........................................................................
-
-    void btfromblk (struct tagbstring& t, void * s, int len);
-
-    Fill in the tagbstring t with the data buffer s with length len.  This 
-    action is purely reference oriented; no memory management is done.  The 
-    data member of t is just assigned s, and slen is assigned len.  Note that 
-    the buffer is not appended with a '\0' character.  The s and len 
-    parameters are accessed exactly once each in this macro.
-
-    The resulting struct tagbstring is initially write protected.  Attempts 
-    to write to this struct tagbstring in a write protected state from any 
-    bstrlib function will lead to BSTR_ERR being returned.  Invoke the 
-    bwriteallow on this struct tagbstring to make it writeable (though this 
-    requires that s be obtained from a function compatible with malloc.)
-
-    ..........................................................................
-
-    void btfromblkltrimws (struct tagbstring& t, void * s, int len);
-
-    Fill in the tagbstring t with the data buffer s with length len after it
-    has been left trimmed.  This action is purely reference oriented; no 
-    memory management is done.  The data member of t is just assigned to a 
-    pointer inside the buffer s.  Note that the buffer is not appended with a 
-    '\0' character.  The s and len parameters are accessed exactly once each 
-    in this macro.
-
-    The resulting struct tagbstring is permanently write protected.  Attempts 
-    to write to this struct tagbstring from any bstrlib function will lead to 
-    BSTR_ERR being returned.  Invoking the bwriteallow macro onto this struct 
-    tagbstring has no effect.
-
-    ..........................................................................
-
-    void btfromblkrtrimws (struct tagbstring& t, void * s, int len);
-
-    Fill in the tagbstring t with the data buffer s with length len after it
-    has been right trimmed.  This action is purely reference oriented; no 
-    memory management is done.  The data member of t is just assigned to a 
-    pointer inside the buffer s.  Note that the buffer is not appended with a 
-    '\0' character.  The s and len parameters are accessed exactly once each 
-    in this macro.
-
-    The resulting struct tagbstring is permanently write protected.  Attempts 
-    to write to this struct tagbstring from any bstrlib function will lead to 
-    BSTR_ERR being returned.  Invoking the bwriteallow macro onto this struct 
-    tagbstring has no effect.
-
-    ..........................................................................
-
-    void btfromblktrimws (struct tagbstring& t, void * s, int len);
-
-    Fill in the tagbstring t with the data buffer s with length len after it
-    has been left and right trimmed.  This action is purely reference 
-    oriented; no memory management is done.  The data member of t is just 
-    assigned to a pointer inside the buffer s.  Note that the buffer is not 
-    appended with a '\0' character.  The s and len parameters are accessed 
-    exactly once each in this macro.
-
-    The resulting struct tagbstring is permanently write protected.  Attempts 
-    to write to this struct tagbstring from any bstrlib function will lead to 
-    BSTR_ERR being returned.  Invoking the bwriteallow macro onto this struct 
-    tagbstring has no effect.
-
-    ..........................................................................
-
-    void bmid2tbstr (struct tagbstring& t, bstring b, int pos, int len);
-
-    Fill the tagbstring t with the substring from b, starting from position
-    pos with a length len.  The segment is clamped by the boundaries of
-    the bstring b.  This action is purely reference oriented; no memory 
-    management is done.  Note that the buffer is not appended with a '\0' 
-    character.  Note that the t parameter to this macro may be accessed 
-    multiple times.  Note that the contents of t will become undefined 
-    if the contents of b change or are destroyed.
-
-    The resulting struct tagbstring is permanently write protected.  Attempts 
-    to write to this struct tagbstring in a write protected state from any 
-    bstrlib function will lead to BSTR_ERR being returned.  Invoking the
-    bwriteallow macro on this struct tagbstring will have no effect.
-
-    ..........................................................................
-
-    void bvformata (int& ret, bstring b, const char * format, lastarg);
-
-    Append the bstring b with printf like formatting with the format control
-    string, and the arguments taken from the ... list of arguments after
-    lastarg passed to the containing function.  If the containing function 
-    does not have ... parameters or lastarg is not the last named parameter 
-    before the ... then the results are undefined.  If successful, the 
-    results are appended to b and BSTR_OK is assigned to ret.  Otherwise 
-    BSTR_ERR is assigned to ret.
-
-    Example:
-
-    void dbgerror (FILE * fp, const char * fmt, ...) {
-        int ret;
-        bstring b;
-        bvformata (ret, b = bfromcstr ("DBG: "), fmt, fmt);
-        if (BSTR_OK == ret) fputs ((char *) bdata (b), fp);
-        bdestroy (b);
-    }
-
-    Note that if the BSTRLIB_NOVSNP macro was set when bstrlib had been 
-    compiled the bvformata macro will not link properly.  If the 
-    BSTRLIB_NOVSNP macro has been set, the bvformata macro will not be 
-    available.
-
-    ..........................................................................
-
-    void bwriteprotect (struct tagbstring& t);
-
-    Disallow bstring from being written to via the bstrlib API.  Attempts to 
-    write to the resulting tagbstring from any bstrlib function will lead to 
-    BSTR_ERR being returned.
-
-    Note: bstrings which are write protected cannot be destroyed via bdestroy.
-
-    Note to C++ users: Setting a CBString as write protected will not prevent
-    it from being destroyed by the destructor.
-
-    ..........................................................................
-
-    void bwriteallow (struct tagbstring& t);
-
-    Allow bstring to be written to via the bstrlib API.  Note that such an 
-    action makes the bstring both writable and destroyable.  If the bstring is
-    not legitimately writable (as is the case for struct tagbstrings 
-    initialized with a bsStatic value), the results of this are undefined.
-
-    Note that invoking the bwriteallow macro may increase the number of 
-    reallocs by one more than necessary for every call to bwriteallow 
-    interleaved with any bstring API which writes to this bstring.
-
-    ..........................................................................
-
-    int biswriteprotected (struct tagbstring& t);
-
-    Returns 1 if the bstring is write protected, otherwise 0 is returned.
-
-===============================================================================
-
-The bstest module
------------------
-
-The bstest module is just a unit test for the bstrlib module.  For correct
-implementations of bstrlib, it should execute with 0 failures being reported.
-This test should be utilized if modifications/customizations to bstrlib have
-been performed.  It tests each core bstrlib function with bstrings of every 
-mode (read-only, NULL, static and mutable) and ensures that the expected 
-semantics are observed (including results that should indicate an error). It
-also tests for aliasing support.  Passing bstest is a necessary but not a 
-sufficient condition for ensuring the correctness of the bstrlib module.
-
-
-The test module
----------------
-
-The test module is just a unit test for the bstrwrap module.  For correct
-implementations of bstrwrap, it should execute with 0 failures being 
-reported.  This test should be utilized if modifications/customizations to 
-bstrwrap have been performed.  It tests each core bstrwrap function with 
-CBStrings write protected or not and ensures that the expected semantics are 
-observed (including expected exceptions.)  Note that exceptions cannot be
-disabled to run this test.  Passing test is a necessary but not a sufficient 
-condition for ensuring the correctness of the bstrwrap module.
-
-===============================================================================
-
-Using Bstring and CBString as an alternative to the C library
--------------------------------------------------------------
-
-First let us give a table of C library functions and the alternative bstring 
-functions and CBString methods that should be used instead of them.
-
-C-library         Bstring alternative             CBString alternative
----------         -------------------             --------------------
-gets              bgets                           ::gets
-strcpy            bassign                         = operator
-strncpy           bassignmidstr                   ::midstr
-strcat            bconcat                         += operator
-strncat           bconcat + btrunc                += operator + ::trunc
-strtok            bsplit, bsplits                 ::split
-sprintf           b(assign)format                 ::format
-snprintf          b(assign)format + btrunc        ::format + ::trunc
-vsprintf          bvformata                       bvformata
-
-vsnprintf         bvformata + btrunc              bvformata + btrunc
-vfprintf          bvformata + fputs               use bvformata + fputs
-strcmp            biseq, bstrcmp                  comparison operators.
-strncmp           bstrncmp, memcmp                bstrncmp, memcmp
-strlen            ->slen, blength                 ::length
-strdup            bstrcpy                         constructor
-strset            bpattern                        ::fill
-strstr            binstr                          ::find
-strpbrk           binchr                          ::findchr
-stricmp           bstricmp                        cast & use bstricmp
-strlwr            btolower                        cast & use btolower
-strupr            btoupper                        cast & use btoupper
-strrev            bReverse (aux module)           cast & use bReverse
-strchr            bstrchr                         cast & use bstrchr
-strspnp           use strspn                      use strspn
-ungetc            bsunread                        bsunread
-
-The top 9 C functions listed here are troublesome in that they impose memory 
-management in the calling function.  The Bstring and CBstring interfaces have
-built-in memory management, so there is far less code with far less potential 
-for buffer overrun problems.  strtok can only be reliably called as a "leaf" 
-calculation, since it (quite bizarrely) maintains hidden internal state.  And
-gets is well known to be broken no matter what.  The Bstrlib alternatives do
-not suffer from those sorts of problems.
-
-The substitute for strncat can be performed with higher performance by using 
-the blk2tbstr macro to create a presized second operand for bconcat.
-
-C-library         Bstring alternative             CBString alternative
----------         -------------------             --------------------
-strspn            strspn acceptable               strspn acceptable
-strcspn           strcspn acceptable              strcspn acceptable
-strnset           strnset acceptable              strnset acceptable
-printf            printf acceptable               printf acceptable
-puts              puts acceptable                 puts acceptable
-fprintf           fprintf acceptable              fprintf acceptable
-fputs             fputs acceptable                fputs acceptable
-memcmp            memcmp acceptable               memcmp acceptable
-
-Remember that Bstring (and CBstring) functions will automatically append the
-'\0' character to the character data buffer.  So by simply accessing the data
-buffer directly, ordinary C string library functions can be called directly 
-on them.  Note that bstrcmp is not the same as memcmp in exactly the same way
-that strcmp is not the same as memcmp.
-
-C-library         Bstring alternative             CBString alternative
----------         -------------------             --------------------
-fread             balloc + fread                  ::alloc + fread
-fgets             balloc + fgets                  ::alloc + fgets
-
-These are odd ones because of the exact sizing of the buffer required.  The 
-Bstring and CBString alternatives requires that the buffers are forced to 
-hold at least the prescribed length, then just use fread or fgets directly.  
-However, typically the automatic memory management of Bstring and CBstring 
-will make the typical use of fgets and fread to read specifically sized 
-strings unnecessary.
-
-Implementation Choices
-----------------------
-
-Overhead:
-.........
-
-The bstring library has more overhead versus straight char buffers for most
-functions.  This overhead is essentially just the memory management and 
-string header allocation.  This overhead usually only shows up for small 
-string manipulations.  The performance loss has to be considered in
-light of the following:
-
-1) What would be the performance loss of trying to write this management
-   code in one's own application?
-2) Since the bstring library source code is given, a sufficiently powerful 
-   modern inlining globally optimizing compiler can remove function call 
-   overhead.
-
-Since the data type is exposed, a developer can replace any unsatisfactory
-function with their own inline implementation.  And that is besides the main 
-point of what the better string library is mainly meant to provide.  Any 
-overhead lost has to be compared against the value of the safe abstraction 
-for coupling memory management and string functionality.
-
-Performance of the C interface:
-...............................
-
-The algorithms used have performance advantages versus the analogous C 
-library functions.  For example:
-
-1. bfromcstr/blk2str/bstrcpy versus strcpy/strdup.  By using memmove instead 
-   of strcpy, the break condition of the copy loop is based on an independent 
-   counter (that should be allocated in a register) rather than having to 
-   check the results of the load.  Modern out-of-order executing CPUs can 
-   parallelize the final branch mis-predict penality with the loading of the 
-   source string.  Some CPUs will also tend to have better built-in hardware 
-   support for counted memory moves than load-compare-store.  (This is a 
-   minor, but non-zero gain.)
-2. biseq versus strcmp.  If the strings are unequal in length, bsiseq will
-   return in O(1) time.  If the strings are aliased, or have aliased data
-   buffers, biseq will return in O(1) time.  strcmp will always be O(k), 
-   where k is the length of the common prefix or the whole string if they are 
-   identical.
-3. ->slen versus strlen.  ->slen is obviously always O(1), while strlen is
-   always O(n) where n is the length of the string.
-4. bconcat versus strcat.  Both rely on precomputing the length of the 
-   destination string argument, which will favor the bstring library.  On 
-   iterated concatenations the performance difference can be enormous.
-5. bsreadln versus fgets.  The bsreadln function reads large blocks at a time
-   from the given stream, then parses out lines from the buffers directly.
-   Some C libraries will implement fgets as a loop over single fgetc calls.
-   Testing indicates that the bsreadln approach can be several times faster
-   for fast stream devices (such as a file that has been entirely cached.)
-6. bsplits/bsplitscb versus strspn.  Accelerators for the set of match 
-   characters are generated only once.
-7. binstr versus strstr.  The binstr implementation unrolls the loops to
-   help reduce loop overhead.  This will matter if the target string is 
-   long and source string is not found very early in the target string.
-   With strstr, while it is possible to unroll the source contents, it is
-   not possible to do so with the destination contents in a way that is
-   effective because every destination character must be tested against
-   '\0' before proceeding to the next character.
-8. bReverse versus strrev.  The C function must find the end of the string
-   first before swaping character pairs.
-9. bstrrchr versus no comparable C function.  Its not hard to write some C
-   code to search for a character from the end going backwards.  But there
-   is no way to do this without computing the length of the string with
-   strlen.
-
-Practical testing indicates that in general Bstrlib is never signifcantly 
-slower than the C library for common operations, while very often having a
-performance advantage that ranges from significant to massive.  Even for 
-functions like b(n)inchr versus str(c)spn() (where, in theory, there is no 
-advantage for the Bstrlib architecture) the performance of Bstrlib is vastly 
-superior to most tested C library implementations.
-
-Some of Bstrlib's extra functionality also lead to inevitable performance
-advantages over typical C solutions.  For example, using the blk2tbstr macro,
-one can (in O(1) time) generate an internal substring by reference while not 
-disturbing the original string.  If disturbing the original string is not an
-option, typically, a comparable char * solution would have to make a copy of 
-the substring to provide similar functionality.  Another example is reverse 
-character set scanning -- the str(c)spn functions only scan in a forward 
-direction which can complicate some parsing algorithms.
-
-Where high performance char * based algorithms are available, Bstrlib can 
-still leverage them by accessing the ->data field on bstrings.  So 
-realistically Bstrlib can never be significantly slower than any standard
-'\0' terminated char * based solutions.
-
-Performance of the C++ interface:
-.................................
-
-The C++ interface has been designed with an emphasis on abstraction and safety
-first.  However, since it is substantially a wrapper for the C bstring 
-functions, for longer strings the performance comments described in the 
-"Performance of the C interface" section above still apply. Note that the 
-(CBString *) type can be directly cast to a (bstring) type, and passed as 
-parameters to the C functions (though a CBString must never be passed to 
-bdestroy.)
-
-Probably the most controversial choice is performing full bounds checking on
-the [] operator.  This decision was made because 1) the fast alternative of
-not bounds checking is still available by first casting the CBString to a 
-(const char *) buffer or to a (struct tagbstring) then derefencing .data and 
-2) because the lack of bounds checking is seen as one of the main weaknesses 
-of C/C++ versus other languages.  This check being done on every access leads 
-to individual character extraction being actually slower than other languages 
-in this one respect (other language's compilers will normally dedicate more 
-resources on hoisting or removing bounds checking as necessary) but otherwise 
-bring C++ up to the level of other languages in terms of functionality.
-
-It is common for other C++ libraries to leverage the abstractions provided by
-C++ to use reference counting and "copy on write" policies.  While these 
-techniques can speed up some scenarios, they impose a problem with respect to
-thread safety.  bstrings and CBStrings can be properly protected with 
-"per-object" mutexes, meaning that two bstrlib calls can be made and execute
-simultaneously, so long as the bstrings and CBstrings are distinct.  With a
-reference count and alias before copy on write policy, global mutexes are 
-required that prevent multiple calls to the strings library to execute 
-simultaneously regardless of whether or not the strings represent the same
-string.
-
-One interesting trade off in CBString is that the default constructor is not 
-trivial.  I.e., it always prepares a ready to use memory buffer.  The purpose 
-is to ensure that there is a uniform internal composition for any functioning 
-CBString that is compatible with bstrings.  It also means that the other 
-methods in the class are not forced to perform "late initialization" checks. 
-In the end it means that construction of CBStrings are slower than other 
-comparable C++ string classes.  Initial testing, however, indicates that 
-CBString outperforms std::string and MFC's CString, for example, in all other 
-operations.  So to work around this weakness it is recommended that CBString 
-declarations be pushed outside of inner loops.
-
-Practical testing indicates that with the exception of the caveats given 
-above (constructors and safe index character manipulations) the C++ API for
-Bstrlib generally outperforms popular standard C++ string classes.  Amongst 
-the standard libraries and compilers, the quality of concatenation operations 
-varies wildly and very little care has gone into search functions.  Bstrlib
-dominates those performance benchmarks.
-
-Memory management:
-..................
-
-The bstring functions which write and modify bstrings will automatically 
-reallocate the backing memory for the char buffer whenever it is required to 
-grow.  The algorithm for resizing chosen is to snap up to sizes that are a 
-power of two which are sufficient to hold the intended new size.  Memory 
-reallocation is not performed when the required size of the buffer is 
-decreased.  This behavior can be relied on, and is necessary to make the 
-behaviour of balloc deterministic.  This trades off additional memory usage 
-for decreasing the frequency for required reallocations:
-
-1. For any bstring whose size never exceeds n, its buffer is not ever 
-   reallocated more than log_2(n) times for its lifetime.
-2. For any bstring whose size never exceeds n, its buffer is never more than
-   2*(n+1) in length.  (The extra characters beyond 2*n are to allow for the 
-   implicit '\0' which is always added by the bstring modifying functions.)
-
-Decreasing the buffer size when the string decreases in size would violate 1) 
-above and in real world case lead to pathological heap thrashing.  Similarly, 
-allocating more tightly than "least power of 2 greater than necessary" would 
-lead to a violation of 1) and have the same potential for heap thrashing.
-
-Property 2) needs emphasizing.  Although the memory allocated is always a 
-power of 2, for a bstring that grows linearly in size, its buffer memory also 
-grows linearly, not exponentially.  The reason is that the amount of extra 
-space increases with each reallocation, which decreases the frequency of 
-future reallocations.
-
-Obviously, given that bstring writing functions may reallocate the data 
-buffer backing the target bstring, one should not attempt to cache the data 
-buffer address and use it after such bstring functions have been called.  
-This includes making reference struct tagbstrings which alias to a writable 
-bstring.
-
-balloc or bfromcstralloc can be used to preallocate the minimum amount of 
-space used for a given bstring.  This will reduce even further the number of 
-times the data portion is reallocated.  If the length of the string is never 
-more than one less than the memory length then there will be no further 
-reallocations.
-
-Note that invoking the bwriteallow macro may increase the number of reallocs 
-by one more than necessary for every call to bwriteallow interleaved with any 
-bstring API which writes to this bstring.
-
-The library does not use any mechanism for automatic clean up for the C API.
-Thus explicit clean up via calls to bdestroy() are required to avoid memory
-leaks.
-
-Constant and static tagbstrings:
-................................
-
-A struct tagbstring can be write protected from any bstrlib function using 
-the bwriteprotect macro.  A write protected struct tagbstring can then be 
-reset to being writable via the bwriteallow macro.  There is, of course, no 
-protection from attempts to directly access the bstring members.  Modifying a 
-bstring which is write protected by direct access has undefined behavior.
-
-static struct tagbstrings can be declared via the bsStatic macro.  They are
-considered permanently unwritable.  Such struct tagbstrings's are declared 
-such that attempts to write to it are not well defined.  Invoking either 
-bwriteallow or bwriteprotect on static struct tagbstrings has no effect.  
-
-struct tagbstring's initialized via btfromcstr or blk2tbstr are protected by 
-default but can be made writeable via the bwriteallow macro.  If bwriteallow 
-is called on such struct tagbstring's, it is the programmer's responsibility 
-to ensure that:
-
-1) the buffer supplied was allocated from the heap.
-2) bdestroy is not called on this tagbstring (unless the header itself has
-   also been allocated from the heap.)
-3) free is called on the buffer to reclaim its memory.
-
-bwriteallow and bwriteprotect can be invoked on ordinary bstrings (they have 
-to be dereferenced with the (*) operator to get the levels of indirection 
-correct) to give them write protection.
-
-Buffer declaration:
-...................
-
-The memory buffer is actually declared "unsigned char *" instead of "char *".
-The reason for this is to trigger compiler warnings whenever uncasted char
-buffers are assigned to the data portion of a bstring.  This will draw more
-diligent programmers into taking a second look at the code where they 
-have carelessly left off the typically required cast.  (Research from 
-AT&T/Lucent indicates that additional programmer eyeballs is one of the most 
-effective mechanisms at ferreting out bugs.)
-
-Function pointers:
-..................
-
-The bgets, bread and bStream functions use function pointers to obtain 
-strings from data streams.  The function pointer declarations have been 
-specifically chosen to be compatible with the fgetc and fread functions. 
-While this may seem to be a convoluted way of implementing fgets and fread 
-style functionality, it has been specifically designed this way to ensure 
-that there is no dependency on a single narrowly defined set of device 
-interfaces, such as just stream I/O.  In the embedded world, its quite 
-possible to have environments where such interfaces may not exist in the 
-standard C library form.  Furthermore, the generalization that this opens up 
-allows for more sophisticated uses for these functions (performing an fgets 
-like function on a socket, for example.) By using function pointers, it also 
-allows such abstract stream interfaces to be created using the bstring library 
-itself while not creating a circular dependency.
-
-Use of int's for sizes:
-.......................
-
-This is just a recognition that 16bit platforms with requirements for strings
-that are larger than 64K and 32bit+ platforms with requirements for strings
-that are larger than 4GB are pretty marginal.  The main focus is for 32bit 
-platforms, and emerging 64bit platforms with reasonable < 4GB string 
-requirements.  Using ints allows for negative values which has meaning 
-internally to bstrlib.
-
-Semantic consideration:
-.......................
-
-Certain care needs to be taken when copying and aliasing bstrings.  A bstring
-is essentially a pointer type which points to a multipart abstract data
-structure.  Thus usage, and lifetime of bstrings have semantics that follow
-these considerations.  For example:
-
-    bstring a, b;
-    struct tagbstring t;
-
-    a = bfromcstr("Hello"); /* Create new bstring and copy "Hello" into it. */
-    b = a;                  /* Alias b to the contents of a.                */
-    t = *a;                 /* Create a current instance pseudo-alias of a. */
-    bconcat (a, b);         /* Double a and b, t is now undefined.          */
-    bdestroy (a);           /* Destroy the contents of both a and b.        */
-
-Variables of type bstring are really just references that point to real 
-bstring objects.  The equal operator (=) creates aliases, and the asterisk 
-dereference operator (*) creates a kind of alias to the current instance (which
-is generally not useful for any purpose.)  Using bstrcpy() is the correct way 
-of creating duplicate instances.  The ampersand operator (&) is useful for 
-creating aliases to struct tagbstrings (remembering that constructed struct 
-tagbstrings are not writable by default.)
-
-CBStrings use complete copy semantics for the equal operator (=), and thus do 
-not have these sorts of issues.  
-
-Debugging:
-..........
-
-Bstrings have a simple, exposed definition and construction, and the library 
-itself is open source.  So most debugging is going to be fairly straight- 
-forward.  But the memory for bstrings come from the heap, which can often be
-corrupted indirectly, and it might not be obvious what has happened even from
-direct examination of the contents in a debugger or a core dump.  There are
-some tools such as Purify, Insure++ and Electric Fence which can help solve
-such problems, however another common approach is to directly instrument the
-calls to malloc, realloc, calloc, free, memcpy, memmove and/or other calls
-by overriding them with macro definitions.
-
-Although the user could hack on the Bstrlib sources directly as necessary to 
-perform such an instrumentation, Bstrlib comes with a built-in mechanism for 
-doing this.  By defining the macro BSTRLIB_MEMORY_DEBUG and providing an 
-include file named memdbg.h this will force the core Bstrlib modules to 
-attempt to include this file.  In such a file, macros could be defined which 
-overrides Bstrlib's useage of the C standard library.
-
-Rather than calling malloc, realloc, free, memcpy or memmove directly, Bstrlib
-emits the macros bstr__alloc, bstr__realloc, bstr__free, bstr__memcpy and 
-bstr__memmove in their place respectively.  By default these macros are simply
-assigned to be equivalent to their corresponding C standard library function
-call.  However, if they are given earlier macro definitions (via the back 
-door include file) they will not be given their default definition.  In this
-way Bstrlib's interface to the standard library can be changed but without
-having to directly redefine or link standard library symbols (both of which 
-are not strictly ANSI C compliant.)
-
-An example definition might include:
-
-    #define bstr__alloc(sz) X_malloc ((sz), __LINE__, __FILE__)
-
-which might help contextualize heap entries in a debugging environment.
-
-The NULL parameter and sanity checking of bstrings is part of the Bstrlib 
-API, and thus Bstrlib itself does not present any different modes which would 
-correspond to "Debug" or "Release" modes.  Bstrlib always contains mechanisms
-which one might think of as debugging features, but retains the performance
-and small memory footprint one would normally associate with release mode
-code.
-
-Integration Microsoft's Visual Studio debugger:
-...............................................
-
-Microsoft's Visual Studio debugger has a capability of customizable mouse 
-float over data type descriptions.  This is accomplished by editting the
-AUTOEXP.DAT file to include the following:
-
-    ; new for CBString
-    tagbstring =slen=<slen> mlen=<mlen> <data,st>
-    Bstrlib::CBStringList =count=<size()>
-
-In Visual C++ 6.0 this file is located in the directory:
-
-    C:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin
-
-and in Visual Studio .NET 2003 its located here:
-
-    C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Packages\Debugger
-
-This will improve the ability of debugging with Bstrlib under Visual Studio.
-
-Security
---------
-
-Bstrlib does not come with explicit security features outside of its fairly
-comprehensive error detection, coupled with its strict semantic support.  
-That is to say that certain common security problems, such as buffer overrun,
-constant overwrite, arbitrary truncation etc, are far less likely to happen 
-inadvertently.  Where it does help, Bstrlib maximizes its advantage by 
-providing developers a simple adoption path that lets them leave less secure
-string mechanisms behind.  The library will not leave developers wanting, so 
-they will be less likely to add new code using a less secure string library 
-to add functionality that might be missing from Bstrlib.
-
-That said there are a number of security ideas not addressed by Bstrlib:
-
-1. Race condition exploitation (i.e., verifying a string's contents, then 
-raising the privilege level and execute it as a shell command as two 
-non-atomic steps) is well beyond the scope of what Bstrlib can provide.  It 
-should be noted that MFC's built-in string mutex actually does not solve this 
-problem either -- it just removes immediate data corruption as a possible 
-outcome of such exploit attempts (it can be argued that this is worse, since 
-it will leave no trace of the exploitation).  In general race conditions have 
-to be dealt with by careful design and implementation; it cannot be assisted 
-by a string library.
-
-2. Any kind of access control or security attributes to prevent usage in 
-dangerous interfaces such as system().  Perl includes a "trust" attribute 
-which can be endowed upon strings that are intended to be passed to such 
-dangerous interfaces.  However, Perl's solution reflects its own limitations 
--- notably that it is not a strongly typed language.  In the example code for 
-Bstrlib, there is a module called taint.cpp.  It demonstrates how to write a 
-simple wrapper class for managing "untainted" or trusted strings using the 
-type system to prevent questionable mixing of ordinary untrusted strings with 
-untainted ones then passing them to dangerous interfaces.  In this way the 
-security correctness of the code reduces to auditing the direct usages of 
-dangerous interfaces or promotions of tainted strings to untainted ones.
-
-3. Encryption of string contents is way beyond the scope of Bstrlib.  
-Maintaining encrypted string contents in the futile hopes of thwarting things 
-like using system-level debuggers to examine sensitive string data is likely 
-to be a wasted effort (imagine a debugger that runs at a higher level than a 
-virtual processor where the application runs).  For more standard encryption 
-usages, since the bstring contents are simply binary blocks of data, this 
-should pose no problem for usage with other standard encryption libraries.
-
-Compatibility
--------------
-
-The Better String Library is known to compile and function correctly with the 
-following compilers:
-
-  - Microsoft Visual C++
-  - Watcom C/C++
-  - Intel's C/C++ compiler (Windows)
-  - The GNU C/C++ compiler (cygwin and Linux on PPC64)
-  - Borland C
-  - Turbo C
-
-Setting of configuration options should be unnecessary for these compilers
-(unless exceptions are being disabled or STLport has been added to WATCOM 
-C/C++).  Bstrlib has been developed with an emphasis on portability.  As such 
-porting it to other compilers should be straight forward.  This package 
-includes a porting guide (called porting.txt) which explains what issues may 
-exist for porting Bstrlib to different compilers and environments.
-
-ANSI issues
------------
-
-1. The function pointer types bNgetc and bNread have prototypes which are very
-similar to, but not exactly the same as fgetc and fread respectively.  
-Basically the FILE * parameter is replaced by void *.  The purpose of this
-was to allow one to create other functions with fgetc and fread like 
-semantics without being tied to ANSI C's file streaming mechanism.  I.e., one 
-could very easily adapt it to sockets, or simply reading a block of memory, 
-or procedurally generated strings (for fractal generation, for example.)
-
-The problem is that invoking the functions (bNgetc)fgetc and (bNread)fread is 
-not technically legal in ANSI C.  The reason being that the compiler is only 
-able to coerce the function pointers themselves into the target type, however 
-are unable to perform any cast (implicit or otherwise) on the parameters 
-passed once invoked.  I.e., if internally void * and FILE * need some kind of 
-mechanical coercion, the compiler will not properly perform this conversion 
-and thus lead to undefined behavior.
-
-Apparently a platform from Data General called "Eclipse" and another from 
-Tandem called "NonStop" have a different representation for pointers to bytes 
-and pointers to words, for example, where coercion via casting is necessary.  
-(Actual confirmation of the existence of such machines is hard to come by, so
-it is prudent to be skeptical about this information.)  However, this is not 
-an issue for any known contemporary platforms.  One may conclude that such 
-platforms are effectively apocryphal even if they do exist.
-
-To correctly work around this problem to the satisfaction of the ANSI 
-limitations, one needs to create wrapper functions for fgets and/or 
-fread with the prototypes of bNgetc and/or bNread respectively which performs 
-no other action other than to explicitely cast the void * parameter to a
-FILE *, and simply pass the remaining parameters straight to the function 
-pointer call.
-
-The wrappers themselves are trivial:
-
-    size_t freadWrap (void * buff, size_t esz, size_t eqty, void * parm) {
-        return fread (buff, esz, eqty, (FILE *) parm);
-    }
-
-    int fgetcWrap (void * parm) {
-        return fgetc ((FILE *) parm);
-    }
-
-These have not been supplied in bstrlib or bstraux to prevent unnecessary
-linking with file I/O functions.
-
-2. vsnprintf is not available on all compilers.  Because of this, the bformat
-and bformata functions (and format and formata methods) are not guaranteed to 
-work properly.  For those compilers that don't have vsnprintf, the 
-BSTRLIB_NOVSNP macro should be set before compiling bstrlib, and the format 
-functions/method will be disabled.
-
-The more recent ANSI C standards have specified the required inclusion of a 
-vsnprintf function.
-
-3. The bstrlib function names are not unique in the first 6 characters.  This
-is only an issue for older C compiler environments which do not store more 
-than 6 characters for function names.
-
-4. The bsafe module defines macros and function names which are part of the
-C library.  This simply overrides the definition as expected on all platforms
-tested, however it is not sanctioned by the ANSI standard.  This module is 
-clearly optional and should be omitted on platforms which disallow its 
-undefined semantics.
-
-In practice the real issue is that some compilers in some modes of operation 
-can/will inline these standard library functions on a module by module basis 
-as they appear in each.  The linker will thus have no opportunity to override
-the implementation of these functions for those cases.  This can lead to 
-inconsistent behaviour of the bsafe module on different platforms and 
-compilers.
-
-===============================================================================
-
-Comparison with Microsoft's CString class
------------------------------------------
-
-Although developed independently, CBStrings have very similar functionality to 
-Microsoft's CString class.  However, the bstring library has significant 
-advantages over CString:
-
-1. Bstrlib is a C-library as well as a C++ library (using the C++ wrapper).
-
-    - Thus it is compatible with more programming environments and 
-      available to a wider population of programmers.
-
-2. The internal structure of a bstring is considered exposed.
-
-    - A single contiguous block of data can be cut into read-only pieces by 
-      simply creating headers, without allocating additional memory to create 
-      reference copies of each of these sub-strings.
-    - In this way, using bstrings in a totally abstracted way becomes a choice
-      rather than an imposition.  Further this choice can be made differently
-      at different layers of applications that use it.
-
-3. Static declaration support precludes the need for constructor 
-   invocation.
-
-    - Allows for static declarations of constant strings that has no 
-      additional constructor overhead.
-
-4. Bstrlib is not attached to another library.
-
-    - Bstrlib is designed to be easily plugged into any other library 
-      collection, without dependencies on other libraries or paradigms (such 
-      as "MFC".)
-
-The bstring library also comes with a few additional functions that are not 
-available in the CString class:
-
-    - bsetstr
-    - bsplit
-    - bread
-    - breplace (this is different from CString::Replace())
-    - Writable indexed characters (for example a[i]='x')
-
-Interestingly, although Microsoft did implement mid$(), left$() and right$() 
-functional analogues (these are functions from GWBASIC) they seem to have
-forgotten that mid$() could be also used to write into the middle of a string.  
-This functionality exists in Bstrlib with the bsetstr() and breplace() 
-functions.
-
-Among the disadvantages of Bstrlib is that there is no special support for 
-localization or wide characters.  Such things are considered beyond the scope 
-of what bstrings are trying to deliver.  CString essentially supports the 
-older UCS-2 version of Unicode via widechar_t as an application-wide compile 
-time switch.
-
-CString's also use built-in mechanisms for ensuring thread safety under all
-situations.  While this makes writing thread safe code that much easier, this
-built-in safety feature has a price -- the inner loops of each CString method
-runs in its own critical section (grabbing and releasing a light weight mutex
-on every operation.)  The usual way to decrease the impact of a critical 
-section performance penalty is to amortize more operations per critical 
-section.  But since the implementation of CStrings is fixed as a one critical 
-section per-operation cost, there is no way to leverage this common 
-performance enhancing idea.
-
-The search facilities in Bstrlib are comparable to those in MFC's CString 
-class, though it is missing locale specific collation.  But because Bstrlib 
-is interoperable with C's char buffers, it will allow programmers to write 
-their own string searching mechanism (such as Boyer-Moore), or be able to 
-choose from a variety of available existing string searching libraries (such 
-as those for regular expressions) without difficulty.
-
-Microsoft used a very non-ANSI conforming trick in its implementation to
-allow printf() to use the "%s" specifier to output a CString correctly.  This
-can be convenient, but it is inherently not portable.  CBString requires an
-explicit cast, while bstring requires the data member to be dereferenced.  
-Microsoft's own documentation recommends casting, instead of relying on this
-feature.
-
-Comparison with C++'s std::string
----------------------------------
-
-This is the C++ language's standard STL based string class.
-
-1. There is no C implementation.
-2. The [] operator is not bounds checked.
-3. Missing a lot of useful functions like printf-like formatting.
-4. Some sub-standard std::string implementations (SGI) are necessarily unsafe 
-   to use with multithreading.
-5. Limited by STL's std::iostream which in turn is limited by ifstream which
-   can only take input from files.  (Compare to CBStream's API which can take
-   abstracted input.)
-6. Extremely uneven performance across implementations.
-
-Comparison with ISO C TR 24731 proposal
----------------------------------------
-
-Following the ISO C99 standard, Microsoft has proposed a group of C library 
-extensions which are supposedly "safer and more secure".  This proposal is
-expected to be adopted by the ISO C standard which follows C99.
-
-The proposal reveals itself to be very similar to Microsoft's "StrSafe" 
-library. The functions are basically the same as other standard C library 
-string functions except that destination parameters are paired with an 
-additional length parameter of type rsize_t.  rsize_t is the same as size_t, 
-however, the range is checked to make sure its between 1 and RSIZE_MAX.  Like 
-Bstrlib, the functions perform a "parameter check".  Unlike Bstrlib, when a 
-parameter check fails, rather than simply outputing accumulatable error 
-statuses, they call a user settable global error function handler, and upon 
-return of control performs no (additional) detrimental action.  The proposal 
-covers basic string functions as well as a few non-reenterable functions 
-(asctime, ctime, and strtok).
-
-1. Still based solely on char * buffers (and therefore strlen() and strcat()
-   is still O(n), and there are no faster streq() comparison functions.)
-2. No growable string semantics.
-3. Requires manual buffer length synchronization in the source code.
-4. No attempt to enhance functionality of the C library.
-5. Introduces a new error scenario (strings exceeding RSIZE_MAX length).
-
-The hope is that by exposing the buffer length requirements there will be 
-fewer buffer overrun errors.  However, the error modes are really just 
-transformed, rather than removed.  The real problem of buffer overflows is 
-that they all happen as a result of erroneous programming.  So forcing 
-programmers to manually deal with buffer limits, will make them more aware of 
-the problem but doesn't remove the possibility of erroneous programming.  So
-a programmer that erroneously mixes up the rsize_t parameters is no better off
-from a programmer that introduces potential buffer overflows through other 
-more typical lapses.  So at best this may reduce the rate of erroneous 
-programming, rather than making any attempt at removing failure modes.
-
-The error handler can discriminate between types of failures, but does not 
-take into account any callsite context.  So the problem is that the error is 
-going to be manifest in a piece of code, but there is no pointer to that 
-code.  It would seem that passing in the call site __FILE__, __LINE__ as 
-parameters would be very useful, but the API clearly doesn't support such a 
-thing (it would increase code bloat even more than the extra length 
-parameter does, and would require macro tricks to implement).
-
-The Bstrlib C API takes the position that error handling needs to be done at 
-the callsite, and just tries to make it as painless as possible.  Furthermore, 
-error modes are removed by supporting auto-growing strings and aliasing.  For 
-capturing errors in more central code fragments, Bstrlib's C++ API uses 
-exception handling extensively, which is superior to the leaf-only error 
-handler approach.
-
-Comparison with Managed String Library CERT proposal
-----------------------------------------------------
-
-The main webpage for the managed string library:
-http://www.cert.org/secure-coding/managedstring.html
-
-Robert Seacord at CERT has proposed a C string library that he calls the 
-"Managed String Library" for C. Like Bstrlib, it introduces a new type 
-which is called a managed string. The structure of a managed string 
-(string_m) is like a struct tagbstring but missing the length field.  This 
-internal structure is considered opaque. The length is, like the C standard 
-library, always computed on the fly by searching for a terminating NUL on 
-every operation that requires it. So it suffers from every performance 
-problem that the C standard library suffers from. Interoperating with C 
-string APIs (like printf, fopen, or anything else that takes a string 
-parameter) requires copying to additionally allocating buffers that have to 
-be manually freed -- this makes this library probably slower and more 
-cumbersome than any other string library in existence.
-
-The library gives a fully populated error status as the return value of every
-string function.  The hope is to be able to diagnose all problems 
-specifically from the return code alone.  Comparing this to Bstrlib, which 
-aways returns one consistent error message, might make it seem that Bstrlib 
-would be harder to debug; but this is not true.  With Bstrlib, if an error 
-occurs there is always enough information from just knowing there was an error
-and examining the parameters to deduce exactly what kind of error has 
-happened.  The managed string library thus gives up nested function calls 
-while achieving little benefit, while Bstrlib does not.
-
-One interesting feature that "managed strings" has is the idea of data 
-sanitization via character set whitelisting.  That is to say, a globally
-definable filter that makes any attempt to put invalid characters into strings 
-lead to an error and not modify the string.  The author gives the following 
-example:
-
-    // create valid char set
-    if (retValue = strcreate_m(&str1, "abc") ) {
-      fprintf(
-        stderr, 
-        "Error %d from strcreate_m.\n", 
-        retValue
-      );
-    }  
-    if (retValue = setcharset(str1)) {
-      fprintf(
-        stderr, 
-        "Error %d from  setcharset().\n", 
-        retValue
-      );
-    }
-    if (retValue = strcreate_m(&str1, "aabbccabc")) {
-      fprintf(
-        stderr, 
-        "Error %d from strcreate_m.\n", 
-        retValue
-      );
-    }
-    // create string with invalid char set
-    if (retValue = strcreate_m(&str1, "abbccdabc")) {
-      fprintf(
-        stderr, 
-        "Error %d from strcreate_m.\n", 
-        retValue
-      );
-    } 
-
-Which we can compare with a more Bstrlib way of doing things:
-
-    bstring bCreateWithFilter (const char * cstr, const_bstring filter) {
-      bstring b = bfromcstr (cstr);
-      if (BSTR_ERR != bninchr (b, filter) && NULL != b) {
-        fprintf (stderr, "Filter violation.\n");
-        bdestroy (b);
-        b = NULL;
-      }
-      return b;
-    }
-
-    struct tagbstring charFilter = bsStatic ("abc");
-    bstring str1 = bCreateWithFilter ("aabbccabc", &charFilter);
-    bstring str2 = bCreateWithFilter ("aabbccdabc", &charFilter);
-
-The first thing we should notice is that with the Bstrlib approach you can 
-have different filters for different strings if necessary.  Furthermore, 
-selecting a charset filter in the Managed String Library is uni-contextual. 
-That is to say, there can only be one such filter active for the entire 
-program, which means its usage is not well defined for intermediate library 
-usage (a library that uses it will interfere with user code that uses it, and 
-vice versa.)  It is also likely to be poorly defined in multi-threading 
-environments.
-
-There is also a question as to whether the data sanitization filter is checked
-on every operation, or just on creation operations.  Since the charset can be
-set arbitrarily at run time, it might be set *after* some managed strings have
-been created.  This would seem to imply that all functions should run this
-additional check every time if there is an attempt to enforce this.  This 
-would make things tremendously slow.  On the other hand, if it is assumed that
-only creates and other operations that take char *'s as input need be checked 
-because the charset was only supposed to be called once at and before any 
-other managed string was created, then one can see that its easy to cover 
-Bstrlib with equivalent functionality via a few wrapper calls such as the 
-example given above.
-
-And finally we have to question the value of sanitation in the first place.
-For example, for httpd servers, there is generally a requirement that the
-URLs parsed have some form that avoids undesirable translation to local file 
-system filenames or resources.  The problem is that the way URLs can be 
-encoded, it must be completely parsed and translated to know if it is using 
-certain invalid character combinations.  That is to say, merely filtering
-each character one at a time is not necessarily the right way to ensure that
-a string has safe contents.
-
-In the article that describes this proposal, it is claimed that it fairly 
-closely approximates the existing C API semantics.  On this point we should 
-compare this "closeness" with Bstrlib:
-
-                      Bstrlib                     Managed String Library
-                      -------                     ----------------------
-
-Pointer arithmetic    Segment arithmetic          N/A
-
-Use in C Std lib      ->data, or bdata{e}         getstr_m(x,*) ... free(x)
-
-String literals       bsStatic, bsStaticBlk       strcreate_m()
-
-Transparency          Complete                    None
-
-Its pretty clear that the semantic mapping from C strings to Bstrlib is fairly 
-straightforward, and that in general semantic capabilities are the same or
-superior in Bstrlib.  On the other hand the Managed String Library is either
-missing semantics or changes things fairly significantly.
-
-Comparison with Annexia's c2lib library
----------------------------------------
-
-This library is available at:
-http://www.annexia.org/freeware/c2lib
-
-1. Still based solely on char * buffers (and therefore strlen() and strcat()
-   is still O(n), and there are no faster streq() comparison functions.)
-   Their suggestion that alternatives which wrap the string data type (such as 
-   bstring does) imposes a difficulty in interoperating with the C langauge's
-   ordinary C string library is not founded.
-2. Introduction of memory (and vector?) abstractions imposes a learning
-   curve, and some kind of memory usage policy that is outside of the strings
-   themselves (and therefore must be maintained by the developer.)
-3. The API is massive, and filled with all sorts of trivial (pjoin) and
-   controvertial (pmatch -- regular expression are not sufficiently 
-   standardized, and there is a very large difference in performance between
-   compiled and non-compiled, REs) functions.  Bstrlib takes a decidely 
-   minimal approach -- none of the functionality in c2lib is difficult or
-   challenging to implement on top of Bstrlib (except the regex stuff, which
-   is going to be difficult, and controvertial no matter what.)
-4. Understanding why c2lib is the way it is pretty much requires a working 
-   knowledge of Perl.  bstrlib requires only knowledge of the C string library
-   while providing just a very select few worthwhile extras.
-5. It is attached to a lot of cruft like a matrix math library (that doesn't
-   include any functions for getting the determinant, eigenvectors, 
-   eigenvalues, the matrix inverse, test for singularity, test for 
-   orthogonality, a grahm schmit orthogonlization, LU decomposition ... I 
-   mean why bother?)
-
-Convincing a development house to use c2lib is likely quite difficult.  It
-introduces too much, while not being part of any kind of standards body.  The
-code must therefore be trusted, or maintained by those that use it.  While
-bstring offers nothing more on this front, since its so much smaller, covers 
-far less in terms of scope, and will typically improve string performance, 
-the barrier to usage should be much smaller.
-
-Comparison with stralloc/qmail
-------------------------------
-
-More information about this library can be found here:
-http://www.canonical.org/~kragen/stralloc.html or here:
-http://cr.yp.to/lib/stralloc.html
-
-1. Library is very very minimal.  A little too minimal.
-2. Untargetted source parameters are not declared const.
-3. Slightly different expected emphasis (like _cats function which takes an
-   ordinary C string char buffer as a parameter.)  Its clear that the 
-   remainder of the C string library is still required to perform more
-   useful string operations.
-
-The struct declaration for their string header is essentially the same as that
-for bstring.  But its clear that this was a quickly written hack whose goals
-are clearly a subset of what Bstrlib supplies.  For anyone who is served by
-stralloc, Bstrlib is complete substitute that just adds more functionality.
-
-stralloc actually uses the interesting policy that a NULL data pointer 
-indicates an empty string.  In this way, non-static empty strings can be
-declared without construction.  This advantage is minimal, since static empty
-bstrings can be declared inline without construction, and if the string needs
-to be written to it should be constructed from an empty string (or its first 
-initializer) in any event.
-
-wxString class
---------------
-
-This is the string class used in the wxWindows project.  A description of 
-wxString can be found here:
-http://www.wxwindows.org/manuals/2.4.2/wx368.htm#wxstring
-
-This C++ library is similar to CBString.  However, it is littered with 
-trivial functions (IsAscii, UpperCase, RemoveLast etc.)
-
-1. There is no C implementation.
-2. The memory management strategy is to allocate a bounded fixed amount of 
-   additional space on each resize, meaning that it does not have the 
-   log_2(n) property that Bstrlib has (it will thrash very easily, cause 
-   massive fragmentation in common heap implementations, and can easily be a 
-   common source of performance problems).
-3. The library uses a "copy on write" strategy, meaning that it has to deal 
-   with multithreading problems.
-
-Vstr
-----
-
-This is a highly orthogonal C string library with an emphasis on 
-networking/realtime programming.  It can be found here:
-http://www.and.org/vstr/
-
-1. The convoluted internal structure does not contain a '\0' char * compatible
-   buffer, so interoperability with the C library a non-starter.
-2. The API and implementation is very large (owing to its orthogonality) and
-   can lead to difficulty in understanding its exact functionality.
-3. An obvious dependency on gnu tools (confusing make configure step)
-4. Uses a reference counting system, meaning that it is not likely to be 
-   thread safe.
-
-The implementation has an extreme emphasis on performance for nontrivial 
-actions (adds, inserts and deletes are all constant or roughly O(#operations) 
-time) following the "zero copy" principle.  This trades off performance of 
-trivial functions (character access, char buffer access/coersion, alias 
-detection) which becomes significantly slower, as well as incremental 
-accumulative costs for its searching/parsing functions.  Whether or not Vstr 
-wins any particular performance benchmark will depend a lot on the benchmark, 
-but it should handily win on some, while losing dreadfully on others.
-
-The learning curve for Vstr is very steep, and it doesn't come with any 
-obvious way to build for Windows or other platforms without gnu tools.  At 
-least one mechanism (the iterator) introduces a new undefined scenario 
-(writing to a Vstr while iterating through it.)  Vstr has a very large 
-footprint, and is very ambitious in its total functionality.  Vstr has no C++ 
-API.
-
-Vstr usage requires context initialization via vstr_init() which must be run
-in a thread-local context.  Given the totally reference based architecture
-this means that sharing Vstrings across threads is not well defined, or at
-least not safe from race conditions.  This API is clearly geared to the older
-standard of fork() style multitasking in UNIX, and is not safely transportable
-to modern shared memory multithreading available in Linux and Windows.  There 
-is no portable external solution making the library thread safe (since it 
-requires a mutex around each Vstr context -- not each string.)
-
-In the documentation for this library, a big deal is made of its self hosted
-s(n)printf-like function.  This is an issue for older compilers that don't
-include vsnprintf(), but also an issue because Vstr has a slow conversion to
-'\0' terminated char * mechanism.  That is to say, using "%s" to format data 
-that originates from Vstr would be slow without some sort of native function 
-to do so.  Bstrlib sidesteps the issue by relying on what snprintf-like 
-functionality does exist and having a high performance conversion to a char * 
-compatible string so that "%s" can be used directly.
-
-Str Library
------------
-
-This is a fairly extensive string library, that includes full unicode support
-and targetted at the goal of out performing MFC and STL.  The architecture, 
-similarly to MFC's CStrings, is a copy on write reference counting mechanism.
-
-http://www.utilitycode.com/str/default.aspx
-
-1. Commercial.
-2. C++ only.
-
-This library, like Vstr, uses a ref counting system.  There is only so deeply
-I can analyze it, since I don't have a license for it.  However, performance 
-improvements over MFC's and STL, doesn't seem like a sufficient reason to 
-move your source base to it.  For example, in the future, Microsoft may 
-improve the performance CString.
-
-It should be pointed out that performance testing of Bstrlib has indicated 
-that its relative performance advantage versus MFC's CString and STL's 
-std::string is at least as high as that for the Str library.
-
-libmib astrings
----------------
-
-A handful of functional extensions to the C library that add dynamic string
-functionality.
-http://www.mibsoftware.com/libmib/astring/
-
-This package basically references strings through char ** pointers and assumes
-they are pointing to the top of an allocated heap entry (or NULL, in which 
-case memory will be newly allocated from the heap.)  So its still up to user
-to mix and match the older C string functions with these functions whenever
-pointer arithmetic is used (i.e., there is no leveraging of the type system
-to assert semantic differences between references and base strings as Bstrlib 
-does since no new types are introduced.)  Unlike Bstrlib, exact string length 
-meta data is not stored, thus requiring a strlen() call on *every* string 
-writing operation.  The library is very small, covering only a handful of C's
-functions.
-
-While this is better than nothing, it is clearly slower than even the 
-standard C library, less safe and less functional than Bstrlib.
-
-To explain the advantage of using libmib, their website shows an example of
-how dangerous C code:
-
-    char buf[256];
-    char *pszExtraPath = ";/usr/local/bin";
-
-    strcpy(buf,getenv("PATH")); /* oops! could overrun! */
-    strcat(buf,pszExtraPath); /* Could overrun as well! */
-
-    printf("Checking...%s\n",buf); /* Some printfs overrun too! */
-
-is avoided using libmib:
-
-    char *pasz = 0;      /* Must initialize to 0 */
-    char *paszOut = 0;
-    char *pszExtraPath = ";/usr/local/bin";
-
-    if (!astrcpy(&pasz,getenv("PATH"))) /* malloc error */ exit(-1);
-    if (!astrcat(&pasz,pszExtraPath)) /* malloc error */ exit(-1);
-	
-    /* Finally, a "limitless" printf! we can use */
-    asprintf(&paszOut,"Checking...%s\n",pasz);fputs(paszOut,stdout);
-
-    astrfree(&pasz); /* Can use free(pasz) also. */
-    astrfree(&paszOut);
-
-However, compare this to Bstrlib:
-
-    bstring b, out;
-
-    bcatcstr (b = bfromcstr (getenv ("PATH")), ";/usr/local/bin");
-    out = bformat ("Checking...%s\n", bdatae (b, "<Out of memory>"));
-    /* if (out && b) */ fputs (bdatae (out, "<Out of memory>"), stdout);
-    bdestroy (b);
-    bdestroy (out);
-
-Besides being shorter, we can see that error handling can be deferred right
-to the very end.  Also, unlike the above two versions, if getenv() returns 
-with NULL, the Bstrlib version will not exhibit undefined behavior. 
-Initialization starts with the relevant content rather than an extra 
-autoinitialization step.
-
-libclc
-------
-
-An attempt to add to the standard C library with a number of common useful
-functions, including additional string functions.
-http://libclc.sourceforge.net/
-
-1. Uses standard char * buffer, and adopts C 99's usage of "restrict" to pass
-   the responsibility to guard against aliasing to the programmer.
-2. Adds no safety or memory management whatsoever.
-3. Most of the supplied string functions are completely trivial.
-
-The goals of libclc and Bstrlib are clearly quite different.
-
-fireString
-----------
-
-http://firestuff.org/
-
-1. Uses standard char * buffer, and adopts C 99's usage of "restrict" to pass
-   the responsibility to guard against aliasing to the programmer.
-2. Mixes char * and length wrapped buffers (estr) functions, doubling the API
-   size, with safety limited to only half of the functions.
-
-Firestring was originally just a wrapper of char * functionality with extra
-length parameters.  However, it has been augmented with the inclusion of the 
-estr type which has similar functionality to stralloc.  But firestring does 
-not nearly cover the functional scope of Bstrlib.
-
-Safe C String Library
----------------------
-
-A library written for the purpose of increasing safety and power to C's string
-handling capabilities.
-http://www.zork.org/safestr/safestr.html
-
-1. While the safestr_* functions are safe in of themselves, interoperating 
-   with char * string has dangerous unsafe modes of operation.
-2. The architecture of safestr's causes the base pointer to change.  Thus,
-   its not practical/safe to store a safestr in multiple locations if any 
-   single instance can be manipulated.
-3. Dependent on an additional error handling library.
-4. Uses reference counting, meaning that it is either not thread safe or
-   slow and not portable.
-
-I think the idea of reallocating (and hence potentially changing) the base 
-pointer is a serious design flaw that is fatal to this architecture.  True 
-safety is obtained by having automatic handling of all common scenarios 
-without creating implicit constraints on the user.
-
-Because of its automatic temporary clean up system, it cannot use "const" 
-semantics on input arguments.  Interesting anomolies such as:
-
-    safestr_t s, t;
-    s = safestr_replace (t = SAFESTR_TEMP ("This is a test"),
-                         SAFESTR_TEMP (" "), SAFESTR_TEMP ("."));
-    /* t is now undefined. */
-
-are possible.  If one defines a function which takes a safestr_t as a 
-parameter, then the function would not know whether or not the safestr_t is 
-defined after it passes it to a safestr library function.  The author 
-recommended method for working around this problem is to examine the 
-attributes of the safestr_t within the function which is to modify any of
-its parameters and play games with its reference count.  I think, therefore,
-that the whole SAFESTR_TEMP idea is also fatally broken.
-
-The library implements immutability, optional non-resizability, and a "trust" 
-flag.  This trust flag is interesting, and suggests that applying any 
-arbitrary sequence of safestr_* function calls on any set of trusted strings 
-will result in a trusted string.  It seems to me, however, that if one wanted 
-to implement a trusted string semantic, one might do so by actually creating 
-a different *type* and only implement the subset of string functions that are 
-deemed safe (i.e., user input would be excluded, for example.)  This, in 
-essence, would allow the compiler to enforce trust propogation at compile 
-time rather than run time.  Non-resizability is also interesting, however, 
-it seems marginal (i.e., to want a string that cannot be resized, yet can be 
-modified and yet where a fixed sized buffer is undesirable.)
-
-===============================================================================
-
-Examples
---------
-
-    Dumping a line numbered file:
-
-    FILE * fp;
-    int i, ret;
-    struct bstrList * lines;
-    struct tagbstring prefix = bsStatic ("-> ");
-
-    if (NULL != (fp = fopen ("bstrlib.txt", "rb"))) {
-        bstring b = bread ((bNread) fread, fp);
-        fclose (fp);
-        if (NULL != (lines = bsplit (b, '\n'))) {
-            for (i=0; i < lines->qty; i++) {
-                binsert (lines->entry[i], 0, &prefix, '?');
-                printf ("%04d: %s\n", i, bdatae (lines->entry[i], "NULL"));
-            }
-            bstrListDestroy (lines);
-        }
-        bdestroy (b);
-    }
-
-For numerous other examples, see bstraux.c, bstraux.h and the example archive.
-
-===============================================================================
-
-License
--------
-
-The Better String Library is available under either the 3 clause BSD license 
-(see the accompanying license.txt) or the Gnu Public License version 2 (see 
-the accompanying gpl.txt) at the option of the user.
-
-===============================================================================
-
-Acknowledgements
-----------------
-
-The following individuals have made significant contributions to the design
-and testing of the Better String Library:
-
-Bjorn Augestad
-Clint Olsen
-Darryl Bleau
-Fabian Cenedese
-Graham Wideman
-Ignacio Burgueno
-International Business Machines Corporation
-Ira Mica
-John Kortink
-Manuel Woelker
-Marcel van Kervinck
-Michael Hsieh
-Richard A. Smith
-Simon Ekstrom
-Wayne Scott
-
-===============================================================================
diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/gpl.txt b/build/tools/HLSLcc/May_2014/src/cbstring/gpl.txt
deleted file mode 100644
index d511905..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/gpl.txt
+++ /dev/null
@@ -1,339 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-	    How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.
diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/license.txt b/build/tools/HLSLcc/May_2014/src/cbstring/license.txt
deleted file mode 100644
index cf78a98..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/license.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-Copyright (c) 2002-2008 Paul Hsieh
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without 
-modification, are permitted provided that the following conditions are met:
-
-    Redistributions of source code must retain the above copyright notice, 
-    this list of conditions and the following disclaimer. 
-
-    Redistributions in binary form must reproduce the above copyright notice, 
-    this list of conditions and the following disclaimer in the documentation 
-    and/or other materials provided with the distribution. 
-
-    Neither the name of bstrlib nor the names of its contributors may be used 
-    to endorse or promote products derived from this software without 
-    specific prior written permission. 
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
-POSSIBILITY OF SUCH DAMAGE.
-
diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/porting.txt b/build/tools/HLSLcc/May_2014/src/cbstring/porting.txt
deleted file mode 100644
index 11d8d13..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/porting.txt
+++ /dev/null
@@ -1,172 +0,0 @@
-Better String library Porting Guide
------------------------------------
-
-by Paul Hsieh
-
-The bstring library is an attempt to provide improved string processing 
-functionality to the C and C++ language.  At the heart of the bstring library 
-is the management of "bstring"s which are a significant improvement over '\0'
-terminated char buffers.  See the accompanying documenation file bstrlib.txt
-for more information.
-
-===============================================================================
-
-Identifying the Compiler
-------------------------
-
-Bstrlib has been tested on the following compilers:
-
-    Microsoft Visual C++
-    Watcom C/C++ (32 bit flat)
-    Intel's C/C++ compiler (on Windows)
-    The GNU C/C++ compiler (on Windows/Linux on x86 and PPC64)
-    Borland C++
-    Turbo C
-
-There are slight differences in these compilers which requires slight 
-differences in the implementation of Bstrlib.  These are accomodated in the
-same sources using #ifdef/#if defined() on compiler specific macros.  To
-port Bstrlib to a new compiler not listed above, it is recommended that the
-same strategy be followed.  If you are unaware of the compiler specific 
-identifying preprocessor macro for your compiler you might find it here:
-
-http://predef.sourceforge.net/precomp.html
-
-Note that Intel C/C++ on Windows sets the Microsoft identifier: _MSC_VER.
-
-16-bit vs. 32-bit vs. 64-bit Systems
-------------------------------------
-
-Bstrlib has been architected to deal with strings of length between 0 and
-INT_MAX (inclusive).  Since the values of int are never higher than size_t
-there will be no issue here.  Note that on most 64-bit systems int is 32-bit.
-
-Dependency on The C-Library
----------------------------
-
-Bstrlib uses the functions memcpy, memmove, malloc, realloc, free and 
-vsnprintf.  Many free standing C compiler implementations that have a mode in 
-which the C library is not available will typically not include these 
-functions which will make porting Bstrlib to it onerous.  Bstrlib is not 
-designed for such bare bones compiler environments.  This usually includes 
-compilers that target ROM environments.
-
-Porting Issues
---------------
-
-Bstrlib has been written completely in ANSI/ISO C and ISO C++, however, there 
-are still a few porting issues.  These are described below.
-
-1. The vsnprintf () function.
-
-Unfortunately, the earlier ANSI/ISO C standards did not include this function.
-If the compiler of interest does not support this function then the 
-BSTRLIB_NOVSNP should be defined via something like:
-
-    #if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP)
-    # if defined (__TURBOC__) || defined (__COMPILERVENDORSPECIFICMACRO__)
-    #  define BSTRLIB_NOVSNP
-    # endif
-    #endif
-
-which appears at the top of bstrlib.h.  Note that the bformat(a) functions 
-will not be declared or implemented if the BSTRLIB_NOVSNP macro is set.  If 
-the compiler has renamed vsnprintf() to some other named function, then 
-search for the definition of the exvsnprintf macro in bstrlib.c file and be 
-sure its defined appropriately:
-
-    #if defined (__COMPILERVENDORSPECIFICMACRO__)
-    # define exvsnprintf(r,b,n,f,a) {r=__compiler_specific_vsnprintf(b,n,f,a);}
-    #else
-    # define exvsnprintf(r,b,n,f,a) {r=vsnprintf(b,n,f,a);}
-    #endif
-
-Take notice of the return value being captured in the variable r.  It is 
-assumed that r exceeds n if and only if the underlying vsnprintf function has
-determined what the true maximal output length would be for output if the 
-buffer were large enough to hold it.  Non-modern implementations must output a
-lesser number (the macro can and should be modified to ensure this).
-
-2. Weak C++ compiler.
-
-C++ is a much more complicated language to implement than C.  This has lead 
-to varying quality of compiler implementations.  The weaknesses isolated in
-the initial ports are inclusion of the Standard Template Library, 
-std::iostream and exception handling.  By default it is assumed that the C++
-compiler supports all of these things correctly.  If your compiler does not
-support one or more of these define the corresponding macro:
-
-    BSTRLIB_CANNOT_USE_STL
-    BSTRLIB_CANNOT_USE_IOSTREAM
-    BSTRLIB_DOESNT_THROW_EXCEPTIONS
-
-The compiler specific detected macro should be defined at the top of 
-bstrwrap.h in the Configuration defines section.  Note that these disabling
-macros can be overrided with the associated enabling macro if a subsequent
-version of the compiler gains support.  (For example, its possible to rig
-up STLport to provide STL support for WATCOM C/C++, so -DBSTRLIB_CAN_USE_STL
-can be passed in as a compiler option.)
-
-3. The bsafe module, and reserved words.
-
-The bsafe module is in gross violation of the ANSI/ISO C standard in the 
-sense that it redefines what could be implemented as reserved words on a 
-given compiler.  The typical problem is that a compiler may inline some of the 
-functions and thus not be properly overridden by the definitions in the bsafe 
-module.  It is also possible that a compiler may prohibit the redefinitions in 
-the bsafe module.  Compiler specific action will be required to deal with 
-these situations.
-
-Platform Specific Files
------------------------
-
-The makefiles for the examples are basically setup of for particular 
-environments for each platform.  In general these makefiles are not portable
-and should be constructed as necessary from scratch for each platform.
-
-Testing a port
---------------
-
-To test that a port compiles correctly do the following:
-
-1. Build a sample project that includes the bstrlib, bstraux, bstrwrap, and 
-   bsafe modules.
-2. Compile bstest against the bstrlib module.
-3. Run bstest and ensure that 0 errors are reported.
-4. Compile test against the bstrlib and bstrwrap modules.
-5. Run test and ensure that 0 errors are reported.
-6. Compile each of the examples (except for the "re" example, which may be 
-   complicated and is not a real test of bstrlib and except for the mfcbench 
-   example which is Windows specific.)
-7. Run each of the examples.
-
-The builds must have 0 errors, and should have the absolute minimum number of
-warnings (in most cases can be reduced to 0.)  The result of execution should 
-be essentially identical on each platform.
-
-Performance
------------
-
-Different CPU and compilers have different capabilities in terms of 
-performance.  It is possible for Bstrlib to assume performance 
-characteristics that a platform doesn't have (since it was primarily 
-developed on just one platform).  The goal of Bstrlib is to provide very good 
-performance on all platforms regardless of this but without resorting to 
-extreme measures (such as using assembly language, or non-portable intrinsics 
-or library extensions.)
-
-There are two performance benchmarks that can be found in the example/ 
-directory.  They are: cbench.c and cppbench.cpp.  These are variations and 
-expansions of a benchmark for another string library.  They don't cover all
-string functionality, but do include the most basic functions which will be
-common in most string manipulation kernels.
-
-...............................................................................
-
-Feedback
---------
-
-In all cases, you may email issues found to the primary author of Bstrlib at 
-the email address: [email protected]
-
-===============================================================================
diff --git a/build/tools/HLSLcc/May_2014/src/cbstring/security.txt b/build/tools/HLSLcc/May_2014/src/cbstring/security.txt
deleted file mode 100644
index 9761409..0000000
--- a/build/tools/HLSLcc/May_2014/src/cbstring/security.txt
+++ /dev/null
@@ -1,221 +0,0 @@
-Better String library Security Statement
-----------------------------------------
-
-by Paul Hsieh
-
-===============================================================================
-
-Introduction
-------------
-
-The Better String library (hereafter referred to as Bstrlib) is an attempt to 
-provide improved string processing functionality to the C and C++ languages.  
-At the heart of the Bstrlib is the management of "bstring"s which are a 
-significant improvement over '\0' terminated char buffers.  See the 
-accompanying documenation file bstrlib.txt for more information.
-
-DISCLAIMER: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
-CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT 
-NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
-OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
-WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
-OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-Like any software, there is always a possibility of failure due to a flawed
-implementation.  Nevertheless a good faith effort has been made to minimize 
-such flaws in Bstrlib.  Also, use of Bstrlib by itself will not make an 
-application secure or free from implementation failures.  However, it is the
-author's conviction that use of Bstrlib can greatly facilitate the creation 
-of software meeting the highest possible standards of security.
-
-Part of the reason why this document has been created, is for the purpose of 
-security auditing, or the creation of further "Statements on Security" for 
-software that is created that uses Bstrlib.  An auditor may check the claims 
-below against Bstrlib, and use this as a basis for analysis of software which 
-uses Bstrlib.
-
-===============================================================================
-
-Statement on Security
----------------------
-
-This is a document intended to give consumers of the Better String Library
-who are interested in security an idea of where the Better String Library 
-stands on various security issues.  Any deviation observed in the actual 
-library itself from the descriptions below should be considered an 
-implementation error, not a design flaw.
-
-This statement is not an analytical proof of correctness or an outline of one
-but rather an assertion similar to a scientific claim or hypothesis.  By use,
-testing and open independent examination (otherwise known as scientific 
-falsifiability), the credibility of the claims made below can rise to the 
-level of an established theory.
-
-Common security issues:
-.......................
-
-1. Buffer Overflows
-
-The Bstrlib API allows the programmer a way to deal with strings without 
-having to deal with the buffers containing them.  Ordinary usage of the 
-Bstrlib API itself makes buffer overflows impossible.
-
-Furthermore, the Bstrlib API has a superset of basic string functionality as 
-compared to the C library's char * functions, C++'s std::string class and 
-Microsoft's MFC based CString class.  It also has abstracted mechanisms for 
-dealing with IO.  This is important as it gives developers a way of migrating 
-all their code from a functionality point of view.
-
-2. Memory size overflow/wrap around attack
-
-Bstrlib is, by design, impervious to memory size overflow attacks.  The 
-reason is it is resiliant to length overflows is that bstring lengths are 
-bounded above by INT_MAX, instead of ~(size_t)0.  So length addition 
-overflows cause a wrap around of the integer value making them negative 
-causing balloc() to fail before an erroneous operation can occurr.  Attempted 
-conversions of char * strings which may have lengths greater than INT_MAX are 
-detected and the conversion is aborted.
-
-It is unknown if this property holds on machines that don't represent 
-integers as 2s complement.  It is recommended that Bstrlib be carefully 
-auditted by anyone using a system which is not 2s complement based.
-
-3. Constant string protection
-
-Bstrlib implements runtime enforced constant and read-only string semantics.
-I.e., bstrings which are declared as constant via the bsStatic() macro cannot
-be modified or deallocated directly through the Bstrlib API, and this cannot
-be subverted by casting or other type coercion.  This is independent of the
-use of the const_bstring data type.
-
-The Bstrlib C API uses the type const_bstring to specify bstring parameters 
-whose contents do not change.  Although the C language cannot enforce this,
-this is nevertheless guaranteed by the implementation of the Bstrlib library
-of C functions.  The C++ API enforces the const attribute on CBString types
-correctly.
-
-4. Aliased bstring support
-
-Bstrlib detects and supports aliased parameter management throughout the API. 
-The kind of aliasing that is allowed is the one where pointers of the same
-basic type may be pointing to overlapping objects (this is the assumption the 
-ANSI C99 specification makes.)  Each function behaves as if all read-only 
-parameters were copied to temporaries which are used in their stead before 
-the function is enacted (it rarely actually does this).  No function in the 
-Bstrlib uses the "restrict" parameter attribute from the ANSI C99 
-specification.
-
-5. Information leaking
-
-In bstraux.h, using the semantically equivalent macros bSecureDestroy() and 
-bSecureWriteProtect() in place of bdestroy() and bwriteprotect() respectively 
-will ensure that stale data does not linger in the heap's free space after 
-strings have been released back to memory.  Created bstrings or CBStrings
-are not linked to anything external to themselves, and thus cannot expose 
-deterministic data leaking.  If a bstring is resized, the preimage may exist
-as a copy that is released to the heap.  Thus for sensitive data, the bstring 
-should be sufficiently presized before manipulated so that it is not resized. 
-bSecureInput() has been supplied in bstraux.c, which can be used to obtain 
-input securely without any risk of leaving any part of the input image in the 
-heap except for the allocated bstring that is returned.
-
-6. Memory leaking
-
-Bstrlib can be built using memdbg.h enabled via the BSTRLIB_MEMORY_DEBUG 
-macro.  User generated definitions for malloc, realloc and free can then be
-supplied which can implement special strategies for memory corruption 
-detection or memory leaking.  Otherwise, bstrlib does not do anything out of 
-the ordinary to attempt to deal with the standard problem of memory leaking 
-(i.e., losing references to allocated memory) when programming in the C and 
-C++ languages.  However, it does not compound the problem any more than exists 
-either, as it doesn't have any intrinsic inescapable leaks in it.  Bstrlib 
-does not preclude the use of automatic garbage collection mechanisms such as 
-the Boehm garbage collector.
-
-7. Encryption
-
-Bstrlib does not present any built-in encryption mechanism.  However, it 
-supports full binary contents in its data buffers, so any standard block 
-based encryption mechanism can make direct use of bstrings/CBStrings for 
-buffer management.
-
-8. Double freeing
-
-Freeing a pointer that is already free is an extremely rare, but nevertheless 
-a potentially ruthlessly corrupting operation (its possible to cause Win 98 to
-reboot, by calling free mulitiple times on already freed data using the WATCOM
-CRT.)  Bstrlib invalidates the bstring header data before freeing, so that in
-many cases a double free will be detected and an error will be reported 
-(though this behaviour is not guaranteed and should not be relied on).
-
-Using bstrFree pervasively (instead of bdestroy) can lead to somewhat 
-improved invalid free avoidance (it is completely safe whenever bstring
-instances are only stored in unique variables).  For example:
-
-    struct tagbstring hw = bsStatic ("Hello, world");
-    bstring cpHw = bstrcpy (&hw);
-
-    #ifdef NOT_QUITE_AS_SAFE
-        bdestroy (cpHw); /* Never fail */
-        bdestroy (cpHw); /* Error sometimes detected at runtime */
-        bdestroy (&hw);  /* Error detected at run time */
-    #else
-        bstrFree (cpHw); /* Never fail */
-        bstrFree (cpHw); /* Will do nothing */
-        bstrFree (&hw);  /* Will lead to a compile time error */
-    #endif
-
-9. Resource based denial of service
-
-bSecureInput() has been supplied in bstraux.c.  It has an optional upper limit
-for input length.  But unlike fgets(), it is also easily determined if the 
-buffer has been truncated early.  In this way, a program can set an upper limit
-on input sizes while still allowing for implementing context specific 
-truncation semantics (i.e., does the program consume but dump the extra 
-input, or does it consume it in later inputs?)
-
-10. Mixing char *'s and bstrings
-
-The bstring and char * representations are not identical.  So there is a risk
-when converting back and forth that data may lost.  Essentially bstrings can
-contain '\0' as a valid non-terminating character, while char * strings 
-cannot and in fact must use the character as a terminator.  The risk of data 
-loss is very low, since:
-
-  A) the simple method of only using bstrings in a char * semantically 
-     compatible way is both easy to achieve and pervasively supported.
-  B) obtaining '\0' content in a string is either deliberate or indicative
-     of another, likely more serious problem in the code.
-  C) the library comes with various functions which deal with this issue
-     (namely: bfromcstr(), bstr2cstr (), and bSetCstrChar ())
-
-Marginal security issues:
-.........................
-
-11. 8-bit versus 9-bit portability
-
-Bstrlib uses CHAR_BIT and other limits.h constants to the maximum extent 
-possible to avoid portability problems.  However, Bstrlib has not been tested 
-on any system that does not represent char as 8-bits.  So whether or not it 
-works on 9-bit systems is an open question.  It is recommended that Bstrlib be 
-carefully auditted by anyone using a system in which CHAR_BIT is not 8.
-
-12. EBCDIC/ASCII/UTF-8 data representation attacks.
-
-Bstrlib uses ctype.h functions to ensure that it remains portable to non-
-ASCII systems.  It also checks range to make sure it is well defined even for
-data that ANSI does not define for the ctype functions.
-
-Obscure issues:
-...............
-
-13. Data attributes
-
-There is no support for a Perl-like "taint" attribute, however, an example of 
-how to do this using C++'s type system is given as an example.
-