自学教程：C++ GDKmalloc函数代码示例

intJSONtoString(str *s, int *len, json src){	size_t cnt;	char *c, *dst;	if (GDK_STRNIL(src)) {		if (*s == NULL || *len < 4) {			GDKfree(*s);			*len = 4;			*s = GDKmalloc(4);			if (*s == NULL)				return -1;		}		strncpy(*s, "nil", 4);		return 3;	}	/* count how much space we need for the output string */	cnt = 3;		/* two times " plus /0 */	for (c = src; *c; c++)		switch (*c) {		case '"':		case '//':		case '/n':			cnt++;			/* fall through */		default:			cnt++;			break;		}	if (cnt > (size_t) *len) {		GDKfree(*s);		*s = (str) GDKmalloc(cnt);		if (*s == NULL)			return 0;		*len = (int) cnt;	}	dst = *s;	*dst++ = '"';	for (c = src; *c; c++) {		switch (*c) {		case '"':		case '//':			*dst++ = '//';			/* fall through */		default:			*dst++ = *c;			break;		case '/n':			*dst++ = '//';			*dst++ = 'n';			break;		}	}	*dst++ = '"';	*dst++ = 0;	assert((size_t) (dst - *s) == cnt);	return (int) (cnt - 1);	/* length without /0 */}

static BAT *MATproject_any( BAT *map, BAT **bats, int len ){	BAT *res;	int i;	BUN j, cnt = BATcount(map);	BATiter *bats_i;	BUN *batsT;	bte *mapT;	res = BATnew(TYPE_void, bats[0]->ttype, cnt, TRANSIENT);	batsT = (BUN*)GDKmalloc(sizeof(BUN) * len);	bats_i = (BATiter*)GDKmalloc(sizeof(BATiter) * len);	if (res == NULL || batsT == NULL || bats_i == NULL) {		if (res)			BBPreclaim(res);		if (batsT)			GDKfree(batsT);		if (bats_i)			GDKfree(bats_i);		return NULL;	}	BATseqbase(res, map->hseqbase);	mapT = (bte*)Tloc(map, 0);	for (i=0; i<len; i++) {		batsT[i] = 0;		bats_i[i] = bat_iterator(bats[i]);	}	for (j=0; j<cnt; j++)		BUNappend(res, BUNtail(bats_i[mapT[j]], batsT[mapT[j]]++), FALSE);	GDKfree(batsT);	GDKfree(bats_i);	return res;}

/* Remote execution of MAL calls for more type/property information to be exchanged */strmal2str(MalBlkPtr mb, int first, int last){	str ps = NULL, *txt;	int i, *len, totlen = 0, j;	txt = GDKmalloc(sizeof(str) * mb->stop);	len = GDKmalloc(sizeof(int) * mb->stop);	if( txt == NULL || len == NULL){		addMalException(mb,"mal2str: " MAL_MALLOC_FAIL);		GDKfree(txt);		GDKfree(len);		return NULL;	}	for (i = first; i < last; i++) {		if( i == 0)			txt[i] = instruction2str(mb, 0, getInstrPtr(mb, i), LIST_MAL_NAME | LIST_MAL_TYPE  | LIST_MAL_PROPS);		else			txt[i] = instruction2str(mb, 0, getInstrPtr(mb, i), LIST_MAL_CALL | LIST_MAL_PROPS | LIST_MAL_REMOTE);#ifdef _DEBUG_LISTING_		fprintf(stderr,"%s/n",txt[i]);#endif		if ( txt[i])			totlen += len[i] = (int)strlen(txt[i]);		else {			addMalException(mb,"mal2str: " MAL_MALLOC_FAIL);			GDKfree(len);			for (j = first; j < i; j++)				GDKfree(txt[j]);			GDKfree(txt);			return NULL;		}	}	ps = GDKmalloc(totlen + mb->stop + 1);	if( ps == NULL){		addMalException(mb,"mal2str: " MAL_MALLOC_FAIL);		GDKfree(len);		for (i = first; i < last; i++)			GDKfree(txt[i]);		GDKfree(txt);		return NULL;	}	totlen = 0;	for (i = first; i < last; i++) {		if( txt[i]){			strncpy(ps + totlen, txt[i], len[i]);			ps[totlen + len[i]] = '/n';			ps[totlen + len[i] + 1] = 0;			totlen += len[i] + 1;			GDKfree(txt[i]);		}	}	GDKfree(len);	GDKfree(txt);	return ps;}

strBATXMLdocument(bat *ret, const bat *bid){	BAT *b, *bn;	BUN p, q;	BATiter bi;	size_t size = BUFSIZ;	str buf = GDKmalloc(size);	const char *err = OPERATION_FAILED;	if (buf == NULL)		throw(MAL,"xml.document",MAL_MALLOC_FAIL);	if ((b = BATdescriptor(*bid)) == NULL) {		GDKfree(buf);		throw(MAL, "xml.document", INTERNAL_BAT_ACCESS);	}	prepareResult(bn, b, TYPE_xml, "document", GDKfree(buf));	bi = bat_iterator(b);	BATloop(b, p, q) {		const char *t = (const char *) BUNtail(bi, p);		xmlDocPtr doc;		int len;		xmlChar *s;		if (strNil(t)) {			bunfastapp(bn, str_nil);			bn->T->nonil = 0;			continue;		}		len = (int) strlen(t);		doc = xmlParseMemory(t, len);		if (doc == NULL) {			err = OPERATION_FAILED XML_PARSE_ERROR;			goto bunins_failed;		}		xmlDocDumpMemory(doc, &s, &len);		xmlFreeDoc(doc);		if ((size_t) len + 2 >= size) {			GDKfree(buf);			size = (size_t) len + 128;			buf = GDKmalloc(size);			if (buf == NULL) {				err= MAL_MALLOC_FAIL;				goto bunins_failed;			}		}		buf[0] = 'D';		strcpy(buf + 1, (char *) s);		bunfastapp(bn, buf);	}	GDKfree(buf);	finalizeResult(ret, bn, b);	return MAL_SUCCEED;  bunins_failed:	GDKfree(buf);	BBPunfix(b->batCacheid);	BBPunfix(bn->batCacheid);	throw(MAL, "xml.document", "%s", err);}

static intsql_time_tostr(void *TS_RES, char **buf, int *len, int type, ptr A){	struct time_res *ts_res = TS_RES;	int i, len1, big = 128;	char buf1[128], *s1 = buf1, *s;	lng val = 0, timezone = ts_res->timezone;	daytime tmp, *a = A;	daytime mtime = 24 * 60 * 60 * 1000;	(void) type;	if (ts_res->has_tz) 		val = *a + timezone;	else		val = *a;	if (val < 0)		val = mtime + val;	if (val > mtime)		val = val - mtime;	tmp = (daytime) val;	len1 = daytime_tostr(&s1, &big, &tmp);	if (len1 == 3 && strcmp(s1, "nil") == 0) {		if (*len < 4 || *buf == NULL) {			if (*buf)				GDKfree(*buf);			*buf = (str) GDKmalloc(*len = 4);		}		strcpy(*buf, s1);		return len1;	}	/* fixup the fraction, default is 3 */	len1 += (ts_res->fraction-3);	if (ts_res->fraction == 0) 		len1 --;	if (*len < len1 + 8) {		if (*buf)			GDKfree(*buf);		*buf = (str) GDKmalloc(*len = len1 + 8);	}	s = *buf;	strcpy(s, buf1);	s += len1;	s[0] = 0;	/* extra zero's for usec's */	for (i=3; i<ts_res->fraction; i++) 		s[-i+2] = '0';	if (ts_res->has_tz) {		timezone = ts_res->timezone/60000;		*s++ = (ts_res->timezone >= 0) ? '+' : '-';		sprintf(s, "%02d:%02d", ABS(timezone) / 60, ABS(timezone) % 60);		s += 5;	}	return (int) (s - *buf);}

strBATXMLcomment(bat *ret, const bat *bid){	BAT *b, *bn;	BUN p, q;	size_t size = BUFSIZ;	str buf = GDKmalloc(size);	BATiter bi;	const char *err= OPERATION_FAILED;	if (buf == NULL)		throw(MAL, "xml.comment", MAL_MALLOC_FAIL);	if ((b = BATdescriptor(*bid)) == NULL) {		GDKfree(buf);		throw(MAL, "xml.comment", INTERNAL_BAT_ACCESS);	}	prepareResult(bn, b, TYPE_xml, "comment", GDKfree(buf));	bi = bat_iterator(b);	BATloop(b, p, q) {		const char *t = (const char *) BUNtail(bi, p);		size_t len;		if (strNil(t)) {			bunfastapp(bn, str_nil);			bn->T->nonil = 0;			continue;		}		if (strstr(t, "--") != NULL) {			err = XML_COMMENT_ERROR;			goto bunins_failed;		}		len = strlen(t);		if (len + 9 >= size) {			/* make sure there is enough space */			size = len + 128;			/* free/malloc so we don't copy */			GDKfree(buf);			buf = GDKmalloc(size);			if (buf == NULL) {				err = MAL_MALLOC_FAIL;				goto bunins_failed;			}		}		snprintf(buf, size, "C<!--%s-->", t);		bunfastapp(bn, buf);	}	GDKfree(buf);	finalizeResult(ret, bn, b);	return MAL_SUCCEED;  bunins_failed:	BBPunfix(b->batCacheid);	BBPunfix(bn->batCacheid);	if (buf != NULL)		GDKfree(buf);	throw(MAL, "xml.comment", "%s", err);}

/* * The core of the activity is str2xml, where the actual strings * are constructed. * To avoid repetitive copying we make sure that the garbage * collector does not remove the xml intermediates. * This way, we know that as long as the xml-variables are not * reused, the complete structure of the xml document(s) are available. * We merely have to collect the pieces. * [FOR LATER, FIRST GO FOR THE EASY IMPLEMENTATION] * XML values are represented by strings already. */strBATXMLstr2xml(bat *ret, const bat *bid){	BAT *b, *bn;	BUN p, q;	size_t size = BUFSIZ;	str buf;	const char *err= OPERATION_FAILED;	BATiter bi;	buf = GDKmalloc(size);	if (buf == NULL)		throw(MAL,"xml.str2xml",MAL_MALLOC_FAIL);	if ((b = BATdescriptor(*bid)) == NULL) {		GDKfree(buf);		throw(MAL, "xml.xml", INTERNAL_BAT_ACCESS);	}	prepareResult(bn, b, TYPE_xml, "xml", GDKfree(buf));	bi = bat_iterator(b);	BATloop(b, p, q) {		const char *t = (const char *) BUNtail(bi, p);		size_t len;		if (strNil(t)) {			bunfastapp(bn, str_nil);			bn->T->nonil = 0;			continue;		}		len = strlen(t) * 6 + 1;		if (size < len) {			size = len + 128;			GDKfree(buf);			buf = GDKmalloc(size);			if (buf == NULL) {				err = MAL_MALLOC_FAIL;				goto bunins_failed;			}		}		buf[0] = 'C';		XMLquotestring(t, buf + 1, size - 1);		bunfastapp(bn, buf);	}	GDKfree(buf);	finalizeResult(ret, bn, b);	return MAL_SUCCEED;  bunins_failed:	BBPunfix(b->batCacheid);	BBPunfix(bn->batCacheid);	if (buf != NULL)		GDKfree(buf);	throw(MAL, "xml.xml", "%s", err);}

/* * Matching a block calls for building two variable lists used. * The isomorphism can be determined after-wards using a single scan. * The candidate block is matched with mb starting at a given pc. * The candidate block is expected to defined as a function, including * a signature and end-statement. They are ignored in the comparison * * Beware, the variables in the block being removed, could be * used furtheron in the program. [tricky to detect, todo] */static intmalFcnMatch(MalBlkPtr mc, MalBlkPtr mb, int pc){	int i, j, k, lim;	int *cvar, *mvar;	int ctop = 0, mtop = 0;	InstrPtr p, q;	if (mb->stop - pc < mc->stop - 2)		return 0;	cvar = (int *) GDKmalloc(mc->vtop * mc->maxarg * sizeof(*cvar));	if (cvar == NULL)		return 0;	mvar = (int *) GDKmalloc(mb->vtop * mc->maxarg * sizeof(*mvar));	if (mvar == NULL){		GDKfree(cvar);		return 0;	}	/* also trim the return statement */	lim = pc + mc->stop - 3;	k = 1;	for (i = pc; i < lim; i++, k++) {		p = getInstrPtr(mb, i);		q = getInstrPtr(mc, k);		if (malMatch(p, q) == 0){			GDKfree(cvar);			GDKfree(mvar);			return 0;		}		for (j = 0; j < p->argc; j++)			cvar[ctop++] = getArg(p, j);		for (j = 0; j < q->argc; j++)			mvar[mtop++] = getArg(q, j);	}	assert(mtop == ctop);	/*shouldn't happen */	for (i = 0; i < ctop; i++)		for (j = i + 1; j < ctop; j++)			if ((cvar[i] == cvar[j]) != (mvar[i] == mvar[j])) {				GDKfree(cvar);				GDKfree(mvar);				return 0;			}	GDKfree(cvar);	GDKfree(mvar);	return 1;}

/* COMMAND "unescape": Convert hexadecimal representations to ASCII characters. *                     All sequences of the form "% HEX HEX" are unescaped. * SIGNATURE: unescape(str) : str; */strunescape_str(str *retval, str s){	int x, y;	str res;	if (!s)		throw(ILLARG, "url.escape", "url missing");	res = (str) GDKmalloc(strlen(s));	if (!res)		throw(MAL, "url.unescape", "malloc failed");	for (x = 0, y = 0; s[x]; ++x, ++y) {		if (s[x] == '%') {			res[y] = x2c(&s[x + 1]);			x += 2;		} else {			res[y] = s[x];		}	}	res[y] = '/0';	*retval = GDKrealloc(res, strlen(res)+1);	return MAL_SUCCEED;}

intcolor_tostr(char **colorStr, int *len, color *c){	color sc = *c;#ifdef DEBUG_COLOR	printf("* color_tostr:/n");	printf("  - *len: %d/n", *len);	printf("  - c: %X/n", *c);#endif	/* allocate and fill a new string */	if (*len < 11) {		GDKfree(*colorStr);		*colorStr = GDKmalloc(11);		*len = 11;	}	if (sc == color_nil) {		strcpy(*colorStr, "nil");		return 3;	}	snprintf(*colorStr, *len, "0x%08X", (unsigned int) sc);#ifdef DEBUG_COLOR	printf("  = *colorStr: %s/n", *colorStr);	printf("  = *len: %d/n", *len);#endif	return (int) strlen(*colorStr);}

/* COMMAND "getUser": Extract the user identity from the URL * SIGNATURE: getUser(str) : str; */strURLgetUser(str *retval, url *val){	const char *s;	const char *p;	const char *u;	if (val == NULL || *val == NULL)		throw(ILLARG, "url.getUser", "url missing");	if ((s = skip_scheme(*val)) == NULL ||		(p = skip_authority(s, NULL, NULL, NULL, NULL)) == NULL ||		(s = skip_path(p, NULL, NULL)) == NULL)		throw(ILLARG, "url.getUser", "bad url");	if (p == s || *p != '/' || p[1] != '~') {		*retval = GDKstrdup(str_nil);	} else {		size_t l;		u = p + 2;		for (p = u; p < s && *p != '/'; p++)			;		l = p - u;		if ((*retval = GDKmalloc(l + 1)) != NULL) {			strncpy(*retval, u, l);			(*retval)[l] = 0;		}	}	if (*retval == NULL)		throw(MAL, "url.getUser", "Allocation failed");	return MAL_SUCCEED;}

/* COMMAND "getPort": Extract the port id from the URL * SIGNATURE: getPort(str) : str; */strURLgetPort(str *retval, url *val){	const char *s;	const char *p = NULL;	if (val == NULL || *val == NULL)		throw(ILLARG, "url.getPort", "url missing");	if ((s = skip_scheme(*val)) == NULL ||		(s = skip_authority(s, NULL, NULL, NULL, &p)) == NULL)		throw(ILLARG, "url.getPort", "bad url");	if (p == NULL) {		*retval = GDKstrdup(str_nil);	} else {		size_t l = s - p;		if ((*retval = GDKmalloc(l + 1)) != NULL) {			strncpy(*retval, p, l);			(*retval)[l] = 0;		}	}	if (*retval == NULL)		throw(MAL, "url.getPort", "Allocation failed");	return MAL_SUCCEED;}

/* COMMAND "getQuery": Extract the query part from the URL * SIGNATURE: getQuery(str) : str; */strURLgetQuery(str *retval, url *val){	const char *s;	const char *q;	if (val == NULL || *val == NULL)		throw(ILLARG, "url.getQuery", "url missing");	if ((s = skip_scheme(*val)) == NULL ||		(s = skip_authority(s, NULL, NULL, NULL, NULL)) == NULL ||		(q = skip_path(s, NULL, NULL)) == NULL ||		(s = skip_search(q)) == NULL)		throw(ILLARG, "url.getQuery", "bad url");	if (*q == '?') {		size_t l;		q++;		l = s - q;		if ((*retval = GDKmalloc(l + 1)) != NULL) {			strncpy(*retval, q, l);			(*retval)[l] = 0;		}	} else {		*retval = GDKstrdup(str_nil);	}	if (*retval == NULL)		throw(MAL, "url.getQuery", "Allocation failed");	return MAL_SUCCEED;}

/* COMMAND "getDomain": Extract the Internet domain from the URL * SIGNATURE: getDomain(str) : str; */strURLgetDomain(str *retval, url *val){	const char *s;	const char *h = NULL;	const char *p = NULL;	if (val == NULL || *val == NULL)		throw(ILLARG, "url.getDomain", "url missing");	if ((s = skip_scheme(*val)) == NULL ||		(s = skip_authority(s, NULL, NULL, &h, &p)) == NULL)		throw(ILLARG, "url.getDomain", "bad url");	if (h == NULL) {		*retval = GDKstrdup(str_nil);	} else {		size_t l;		if (p != NULL)			p--;		else			p = s;		l = 0;		while (p > h && p[-1] != '.') {			p--;			l++;		}		if ((*retval = GDKmalloc(l + 1)) != NULL) {			strncpy(*retval, p, l);			(*retval)[l] = 0;		}	}	if (*retval == NULL)		throw(MAL, "url.getDomain", "Allocation failed");	return MAL_SUCCEED;}

/* COMMAND "getExtension": Extract the file extension of the URL * SIGNATURE: getExtension(str) : str; */strURLgetExtension(str *retval, url *val){	const char *s;	const char *e = NULL;	if (val == NULL || *val == NULL)		throw(ILLARG, "url.getExtension", "url missing");	if ((s = skip_scheme(*val)) == NULL ||		(s = skip_authority(s, NULL, NULL, NULL, NULL)) == NULL ||		(s = skip_path(s, NULL, &e)) == NULL)		throw(ILLARG, "url.getExtension", "bad url");	if (e == NULL) {		*retval = GDKstrdup(str_nil);	} else {		size_t l = s - e;		assert(*e == '.');		if ((*retval = GDKmalloc(l)) != NULL) {			strncpy(*retval, e + 1, l - 1);			(*retval)[l - 1] = 0;		}	}	if (*retval == NULL)		throw(MAL, "url.getExtension", "Allocation failed");	return MAL_SUCCEED;}

/* COMMAND "getBasename": Extract the base of the last file name of the URL, *                        thus, excluding the file extension. * SIGNATURE: getBasename(str) : str; */strURLgetBasename(str *retval, url *val){	const char *s;	const char *b = NULL;	const char *e = NULL;	if (val == NULL || *val == NULL)		throw(ILLARG, "url.getBasename", "url missing");	if ((s = skip_scheme(*val)) == NULL ||		(s = skip_authority(s, NULL, NULL, NULL, NULL)) == NULL ||		(s = skip_path(s, &b, &e)) == NULL)		throw(ILLARG, "url.getBasename", "bad url");	if (b == NULL) {		*retval = GDKstrdup(str_nil);	} else {		size_t l;		if (e != NULL) {			l = e - b;		} else {			l = s - b;		}		if ((*retval = GDKmalloc(l + 1)) != NULL) {			strncpy(*retval, b, l);			(*retval)[l] = 0;		}	}	if (*retval == NULL)		throw(MAL, "url.getBasename", "Allocation failed");	return MAL_SUCCEED;}

static BAT *MATproject_hge( BAT *map, BAT **bats, int len, int ttpe ){	BAT *res;	int i;	BUN j, cnt = BATcount(map);	hge *resT, **batsT;	bte *mapT;	res = BATnew(TYPE_void, ttpe, cnt, TRANSIENT);	batsT = (hge**)GDKmalloc(sizeof(hge*) * len);	if (res == NULL || batsT == NULL) {		if (res)			BBPreclaim(res);		if (batsT)			GDKfree(batsT);		return NULL;	}	BATseqbase(res, map->hseqbase);	resT = (hge*)Tloc(res, 0);	mapT = (bte*)Tloc(map, 0);	for (i=0; i<len; i++)		batsT[i] = (hge*)Tloc(bats[i], 0);	for (j=0; j<cnt; j++)		resT[j] = *batsT[mapT[j]]++;	BATsetcount(res, j);	res->hrevsorted = j <= 1;	GDKfree(batsT);	return res;}

static QEPQEPnew(int p, int c){	QEP qep;	qep = (QEP) GDKmalloc( sizeof(struct QEPrecord));	if (qep == NULL)		return NULL;	qep->mb= NULL;	qep->p = NULL;	qep->plimit = p;	if( p ) {		qep->parents = (QEP*) GDKzalloc( sizeof(QEP) * p);		if( qep->parents == NULL){			GDKfree(qep);			return NULL;		}	}	qep->climit = c;	if( c){		qep->children = (QEP *) GDKzalloc( sizeof(QEP) * c);		if( qep->children == NULL){			GDKfree(qep);			return NULL;		}	}	return qep;}

/* COMMAND "escape": this function applies the URI escaping rules defined in * section 2 of [RFC 3986] to the string supplied as 's'. * The effect of the function is to escape a set of identified characters in * the string. Each such character is replaced in the string by an escape * sequence, which is formed by encoding the character as a sequence of octets * in UTF-8, and then reprensenting each of these octets in the form %HH. * * All characters are escaped other than: * [a-z], [A-Z], [0-9], "#", "-", "_", ".", "!", "~", "*", "'", "(", ")" * * This function must always generate hexadecimal values using the upper-case * letters A-F. * * SIGNATURE: escape(str) : str; */strescape_str(str *retval, str s){	int x, y;	str res;	if (!s)		throw(ILLARG, "url.escape", "url missing");	if (!( res = (str) GDKmalloc( strlen(s) * 3 ) ))		throw(MAL, "url.escape", "malloc failed");	for (x = 0, y = 0; s[x]; ++x, ++y) {		if (needEscape(s[x])) {			if (s[x] == ' ') {				res[y] = '+';			} else {				sprintf(res+y, "%%%2x", s[x]);				y += 2;			}		} else {			res[y] = s[x];		}	}	res[y] = '/0';	*retval = GDKrealloc(res, strlen(res)+1);	return MAL_SUCCEED;}

static void *column_find_value(sql_trans *tr, sql_column *c, oid rid){	BUN q = BUN_NONE;	BAT *b;	void *res = NULL;	b = full_column(tr, c);	if (b) {		if (rid < b->hseqbase || rid >= b->hseqbase + BATcount(b))			q = BUN_NONE;		else			q = rid - b->hseqbase;	}	if (q != BUN_NONE) {		BATiter bi = bat_iterator(b);		const void *r;		size_t sz;		r = BUNtail(bi, q);		sz = ATOMlen(b->ttype, r);		res = GDKmalloc(sz);		if (res)			memcpy(res, r, sz);	}	full_destroy(c, b);	return res;}

/* all non-exported functions must be declared static */static char *UDFreverse_(char **ret, const char *src){	size_t len = 0;	char *dst = NULL;	/* assert calling sanity */	assert(ret != NULL);	/* handle NULL pointer and NULL value */	if (src == NULL || strcmp(src, str_nil) == 0) {		*ret = GDKstrdup(str_nil);		if (*ret == NULL)			throw(MAL, "udf.reverse",			      "failed to create copy of str_nil");		return MAL_SUCCEED;	}	/* allocate result string */	len = strlen(src);	*ret = dst = GDKmalloc(len + 1);	if (dst == NULL)		throw(MAL, "udf.reverse",		      "failed to allocate string of length " SZFMT, len + 1);	/* copy characters from src to dst in reverse order */	dst[len] = 0;	while (len > 0)		*dst++ = src[--len];	return MAL_SUCCEED;}

/****************************** * QGRAMNORMALIZE * * This function 'normalizes' a string so valid q-grams can  be made of it: * All characters are transformed to uppercase, and all characters * which are not letters or digits are stripped to a single space. * * qgramnormalize("Hallo, allemaal!").print(); --> "HALLO ALLEMAAL" * qgramnormalize(" '' t ' est").print(); --> [ "T EST" ] * *****************************/strCMDqgramnormalize(str *res, str *Input){	char *input = *Input;	int i, j = 0;	char c, last = ' ';	RETURN_NIL_IF(strNil(input), TYPE_str);	*res = (str) GDKmalloc(sizeof(char) * (strlen(input) + 1));	/* normalized strings are never longer than original */	for (i = 0; input[i]; i++) {		c = toupper(input[i]);		if (!(('A' <= c && c <= 'Z') || ('0' <= c && c <= '9')))			c = ' ';		if (c != ' ' || last != ' ') {			(*res)[j++] = c;		}		last = c;	}	(*res)[j] = 0;	/* strip final whitespace */	while (j > 0 && (*res)[--j] == ' ')		(*res)[j] = 0;	return MAL_SUCCEED;}

ValPtrVALcopy(ValPtr d, const ValRecord *s){	if (!ATOMextern(s->vtype)) {		*d = *s;	} else if (s->val.pval == 0) {		d->val.pval = ATOMnil(s->vtype);		d->vtype = s->vtype;	} else if (s->vtype == TYPE_str) {		d->vtype = TYPE_str;		d->val.sval = GDKstrdup(s->val.sval);		d->len = strLen(d->val.sval);	} else if (s->vtype == TYPE_bit) {		d->vtype = s->vtype;		d->len = 1;		d->val.btval = s->val.btval;	} else {		ptr p = s->val.pval;		d->vtype = s->vtype;		d->len = ATOMlen(d->vtype, p);		d->val.pval = GDKmalloc(d->len);		memcpy(d->val.pval, p, d->len);	}	return d;}

static strcreateExceptionInternal(enum malexception type, const char *fcn, const char *format, va_list ap){	char *message;	int len;	// if there is an error we allow memory allocation once again#ifndef NDEBUG	GDKsetmallocsuccesscount(-1);#endif	message = GDKmalloc(GDKMAXERRLEN);	if (message == NULL)		return M5OutOfMemory;	/* last resort */	len = snprintf(message, GDKMAXERRLEN, "%s:%s:", exceptionNames[type], fcn);	if (len >= GDKMAXERRLEN)	/* shouldn't happen */		return message;	len += vsnprintf(message + len, GDKMAXERRLEN - len, format, ap);	/* realloc to reduce amount of allocated memory (GDKMAXERRLEN is	 * way more than what is normally needed) */	if (len < GDKMAXERRLEN) {		/* in the extremely unlikely case that GDKrealloc fails, the		 * original pointer is still valid, so use that and don't		 * overwrite */		char *newmsg = GDKrealloc(message, len + 1);		if (newmsg != NULL)			message = newmsg;	}	char *q = message;	for (char *p = strchr(q, '/n'); p; q = p + 1, p = strchr(q, '/n'))		fprintf(stderr, "#%s:!ERROR:%.*s/n", MT_thread_getname(), (int) (p - q), q);	if (*q)		fprintf(stderr, "#%s:!ERROR:%s/n", MT_thread_getname(), q);	return message;}

/** * Returns the location the exception was raised, if known.  It * depends on how the exception was created, what the location looks * like.  The returned string is mallocced with GDKmalloc, and hence * needs to be GDKfreed. */strgetExceptionPlace(const char *exception){	str ret;	const char *s, *t;	enum malexception i;	size_t l;	for (i = MAL; exceptionNames[i] != NULL; i++) {		l = strlen(exceptionNames[i]);		if (strncmp(exceptionNames[i], exception, l) == 0 &&			exception[l] == ':') {			s = exception + l + 1;			if ((t = strchr(s, ':')) != NULL) {				if ((ret = GDKmalloc(t - s + 1)) == NULL)					return NULL;				strncpy(ret, s, t - s);				ret[t - s] = 0;				return ret;			}			break;		}	}	return GDKstrdup("(unknown)");}

char *query_cleaned(const char *query){	char *q, *r;	int quote = 0;		/* inside quotes ('..', "..", {..}) */	int bs = 0;		/* seen a backslash in a quoted string */	int incomment1 = 0;	/* inside traditional C style comment */	int incomment2 = 0;	/* inside comment starting with --  */	r = GDKmalloc(strlen(query) + 1);	for (q = r; *query; query++) {		if (incomment1) {			if (*query == '/' && query[-1] == '*') {				incomment1 = 0;			}		} else if (incomment2) {			if (*query == '/n') {				incomment2 = 0;				/* add newline only if comment doesn't				 * occupy whole line */				if (q > r && q[-1] != '/n')					*q++ = '/n';			}		} else if (quote) {			if (bs) {				bs = 0;			} else if (*query == '//') {				bs = 1;			} else if (*query == quote) {				quote = 0;			}			*q++ = *query;		} else if (*query == '"' || *query == '/'') {			quote = *query;			*q++ = *query;		} else if (*query == '{') {			quote = '}';			*q++ = *query;		} else if (*query == '-' && query[1] == '-') {			incomment2 = 1;		} else if (*query == '/' && query[1] == '*') {			incomment1 = 1;		} else if (*query == '/n') {			/* collapse newlines */			if (q > r && q[-1] != '/n')				*q++ = '/n';		} else if (*query == ' ' || *query == '/t') {			/* collapse white space */			if (q > r && q[-1] != ' ')				*q++ = ' ';		} else {			*q++ = *query;		}	}	*q = 0;	return r;}

intcolor_fromstr(char *colorStr, int *len, color **c){	char *p = colorStr;#ifdef DEBUG_COLOR	printf("* color_fromstr:/n");	printf("  - colorStr: %s/n", (colorStr != NULL ? colorStr : "null"));	printf("  - *len: %d/n", *len);#endif	if (!*c) {		*c = (color *) GDKmalloc(sizeof(color));	} else if (*len < (int) sizeof(color)) {		GDKfree(*c);		*c = GDKmalloc(sizeof(color));		*len = sizeof(color);	}	while (GDKisspace(*p))		p++;	if (p[0] == 'n' && p[1] == 'i' && p[2] == 'l') {		color **sc = (color **) c;		**sc = color_nil;		p += 3;	} else {		if (p[0] == '0' && p[1] == 'x' && p[2] == '0' && p[3] == '0') {			int r = CLRhextoint(p[4], p[5]);			int g = CLRhextoint(p[6], p[7]);			int b = CLRhextoint(p[8], p[9]);			**c = (color) (r << 16 | g << 8 | b);		} else			**c = color_nil;	}#ifdef DEBUG_COLOR	printf("  = *c: 0x%08X/n", (int) **c);	printf("  = *len: %d/n", *len);#endif	return (int) (p - colorStr);}

char *GDKstrdup(const char *s){	int l = strLen(s);	char *n = (char *) GDKmalloc(l);	if (n)		memcpy(n, s, l);	return n;}

ptrATOMdup(int t, const void *p){	size_t len = ATOMlen(t, p);	ptr n = GDKmalloc(len);	if (n)		memcpy(n, p, len);	return n;}

    static char *asgeojson_point(GEOSGeom point, char *srs, bbox3D *bbox, int precision){    char *output;    int size;    size = asgeojson_point_size(point, srs, bbox, precision);    output = GDKmalloc(size);    asgeojson_point_buf(point, srs, output, bbox, precision);    return output;}