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; }