int
JSONtoString(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 */
str
mal2str(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;
}
str
BATXMLdocument(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 int
sql_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);
}
str
BATXMLcomment(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.
*/
str
BATXMLstr2xml(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 int
malFcnMatch(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; */
str
unescape_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;
}
int
color_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; */
str
URLgetUser(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; */
str
URLgetPort(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; */
str
URLgetQuery(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; */
str
URLgetDomain(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; */
str
URLgetExtension(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; */
str
URLgetBasename(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 QEP
QEPnew(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; */
str
escape_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" ]
*
*****************************/
str
CMDqgramnormalize(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;
}
ValPtr
VALcopy(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 str
createExceptionInternal(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.
*/
str
getExceptionPlace(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;
}
int
color_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;
}
ptr
ATOMdup(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;
}
