/*
* Converts string values such as TRUE/FALSE/true/false etc to 1/0/NULL.
* Switched from byte-to-byte compare to library function strncasecmp,
* experiments showed that library function is even slightly faster and we
* now also support True/False (and trUe/FAlSE should this become a thing).
*/
ssize_t
bitFromStr(const char *src, size_t *len, bit **dst, bool external)
{
const char *p = src;
atommem(sizeof(bit));
**dst = bit_nil;
if (GDK_STRNIL(src))
return 1;
while (GDKisspace(*p))
p++;
if (*p == '0') {
**dst = FALSE;
p++;
} else if (*p == '1') {
**dst = TRUE;
p++;
} else if (strncasecmp(p, "true", 4) == 0) {
**dst = TRUE;
p += 4;
} else if (strncasecmp(p, "false", 5) == 0) {
**dst = FALSE;
p += 5;
} else if (external && strncasecmp(p, "nil", 3) == 0) {
p += 3;
} else {
return -1;
}
while (GDKisspace(*p))
p++;
return (ssize_t) (p - src);
}
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 */
}
str
URLnew4(url *u, str *protocol, str *server, int *port, str *file)
{
str Protocol = *protocol;
str Server = *server;
str File = *file;
size_t l;
if (GDK_STRNIL(File))
File = "";
else if (*File == '/')
File++;
if (GDK_STRNIL(Server))
Server = "";
if (GDK_STRNIL(Protocol))
Protocol = "";
l = strlen(File) + strlen(Server) + strlen(Protocol) + 20;
*u = GDKmalloc(l);
if (*u == NULL)
throw(MAL, "url.newurl", "Allocation failed");
snprintf(*u, l, "%s://%s:%d/%s", Protocol, Server, *port, File);
return MAL_SUCCEED;
}
/*
* String conversion routines.
*/
ssize_t
OIDfromStr(const char *src, size_t *len, oid **dst, bool external)
{
#if SIZEOF_OID == SIZEOF_INT
int ui = 0, *uip = &ui;
#else
lng ui = 0, *uip = &ui;
#endif
size_t l = sizeof(ui);
ssize_t pos = 0;
const char *p = src;
atommem(sizeof(oid));
**dst = oid_nil;
if (GDK_STRNIL(src))
return 1;
while (GDKisspace(*p))
p++;
if (external && strncmp(p, "nil", 3) == 0)
return (ssize_t) (p - src) + 3;
if (GDKisdigit(*p)) {
#if SIZEOF_OID == SIZEOF_INT
pos = intFromStr(p, &l, &uip, external);
#else
pos = lngFromStr(p, &l, &uip, external);
#endif
if (pos < 0)
return pos;
if (p[pos] == '@') {
pos++;
while (GDKisdigit(p[pos]))
pos++;
}
if (ui >= 0) {
**dst = ui;
}
p += pos;
} else {
GDKerror("not an OID\n");
return -1;
}
while (GDKisspace(*p))
p++;
return (ssize_t) (p - src);
}
ssize_t
dblFromStr(const char *src, size_t *len, dbl **dst, bool external)
{
const char *p = src;
ssize_t n = 0;
double d;
/* alloc memory */
atommem(sizeof(dbl));
if (GDK_STRNIL(src)) {
**dst = dbl_nil;
return 1;
}
while (GDKisspace(*p))
p++;
if (external && strncmp(p, "nil", 3) == 0) {
**dst = dbl_nil;
p += 3;
n = (ssize_t) (p - src);
} else {
/* on overflow, strtod returns HUGE_VAL and sets
* errno to ERANGE; on underflow, it returns a value
* whose magnitude is no greater than the smallest
* normalized double, and may or may not set errno to
* ERANGE. We accept underflow, but not overflow. */
char *pe;
errno = 0;
d = strtod(p, &pe);
if (p == pe)
p = src; /* nothing converted */
else
p = pe;
n = (ssize_t) (p - src);
if (n == 0 || (errno == ERANGE && (d < -1 || d > 1))
|| !isfinite(d) /* no NaN or Infinte */
) {
GDKerror("overflow or not a number\n");
return -1;
} else {
while (src[n] && GDKisspace(src[n]))
n++;
**dst = (dbl) d;
}
}
return n;
}
int
URLtoString(str *s, int *len, str src)
{
int l;
if (GDK_STRNIL(src)) {
*s = GDKstrdup("nil");
return 0;
}
l = (int) strlen(src) + 3;
/* if( !*s) *s= (str)GDKmalloc(*len = l); */
if (l >= *len) {
GDKfree(*s);
*s = (str) GDKmalloc(l);
if (*s == NULL)
return 0;
}
snprintf(*s, l, "\"%s\"", src);
*len = l - 1;
return *len;
}
ssize_t
ptrFromStr(const char *src, size_t *len, ptr **dst, bool external)
{
size_t base = 0;
const char *p = src;
atommem(sizeof(ptr));
**dst = ptr_nil;
if (GDK_STRNIL(src))
return 1;
while (GDKisspace(*p))
p++;
if (external && strncmp(p, "nil", 3) == 0) {
p += 3;
} else {
if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
p += 2;
}
if (!num16(*p)) {
GDKerror("not a number\n");
return -1;
}
while (num16(*p)) {
if (base >= ((size_t) 1 << (8 * sizeof(size_t) - 4))) {
GDKerror("overflow\n");
return -1;
}
base = mult16(base) + base16(*p);
p++;
}
**dst = (ptr) base;
}
while (GDKisspace(*p))
p++;
return (ssize_t) (p - src);
}
ssize_t
batFromStr(const char *src, size_t *len, bat **dst, bool external)
{
char *s;
const char *t, *r = src;
int c;
bat bid = 0;
atommem(sizeof(bat));
if (GDK_STRNIL(src)) {
**dst = bat_nil;
return 1;
}
while (GDKisspace(*r))
r++;
if (external && strcmp(r, "nil") == 0) {
**dst = bat_nil;
return (ssize_t) (r - src) + 3;
}
if (*r == '<')
r++;
t = r;
while ((c = *t) && (c == '_' || GDKisalnum(c)))
t++;
s = GDKstrndup(r, t - r);
if (s == NULL)
return -1;
bid = BBPindex(s);
GDKfree(s);
**dst = bid == 0 ? bat_nil : bid;
return (ssize_t) (t + (c == '>') - src);
}
static ssize_t
numFromStr(const char *src, size_t *len, void **dst, int tp, bool external)
{
const char *p = src;
size_t sz = ATOMsize(tp);
#ifdef HAVE_HGE
hge base = 0;
#else
lng base = 0;
#endif
int sign = 1;
/* a valid number has the following syntax:
* [-+]?[0-9]+([eE][0-9]+)?(LL)? -- PCRE syntax, or in other words
* optional sign, one or more digits, optional exponent, optional LL
* the exponent has the following syntax:
* lower or upper case letter E, one or more digits
* embedded spaces are not allowed
* the optional LL at the end are only allowed for lng and hge
* values */
atommem(sz);
if (GDK_STRNIL(src)) {
memcpy(*dst, ATOMnilptr(tp), sz);
return 1;
}
while (GDKisspace(*p))
p++;
if (!num10(*p)) {
switch (*p) {
case 'n':
if (external) {
memcpy(*dst, ATOMnilptr(tp), sz);
if (p[1] == 'i' && p[2] == 'l') {
p += 3;
return (ssize_t) (p - src);
}
}
GDKerror("not a number");
goto bailout;
case '-':
sign = -1;
p++;
break;
case '+':
p++;
break;
}
if (!num10(*p)) {
GDKerror("not a number");
goto bailout;
}
}
do {
int dig = base10(*p);
if (base > maxdiv[1].maxval ||
(base == maxdiv[1].maxval && dig > maxmod10)) {
/* overflow */
goto overflow;
}
base = 10 * base + dig;
p++;
} while (num10(*p));
if ((*p == 'e' || *p == 'E') && num10(p[1])) {
p++;
if (base == 0) {
/* if base is 0, any exponent will do, the
* result is still 0 */
while (num10(*p))
p++;
} else {
int exp = 0;
do {
/* this calculation cannot overflow */
exp = exp * 10 + base10(*p);
if (exp >= (int) (sizeof(maxdiv) / sizeof(maxdiv[0]))) {
/* overflow */
goto overflow;
}
p++;
} while (num10(*p));
if (base > maxdiv[exp].maxval) {
/* overflow */
goto overflow;
}
base *= maxdiv[exp].scale;
}
}
base *= sign;
switch (sz) {
case 1: {
bte **dstbte = (bte **) dst;
if (base < GDK_bte_min || base > GDK_bte_max) {
goto overflow;
}
**dstbte = (bte) base;
break;
}
case 2: {
sht **dstsht = (sht **) dst;
if (base < GDK_sht_min || base > GDK_sht_max) {
goto overflow;
}
**dstsht = (sht) base;
break;
}
case 4: {
int **dstint = (int **) dst;
if (base < GDK_int_min || base > GDK_int_max) {
goto overflow;
}
**dstint = (int) base;
break;
}
case 8: {
lng **dstlng = (lng **) dst;
#ifdef HAVE_HGE
if (base < GDK_lng_min || base > GDK_lng_max) {
goto overflow;
}
#endif
**dstlng = (lng) base;
if (p[0] == 'L' && p[1] == 'L')
p += 2;
break;
}
#ifdef HAVE_HGE
case 16: {
hge **dsthge = (hge **) dst;
**dsthge = (hge) base;
if (p[0] == 'L' && p[1] == 'L')
p += 2;
break;
}
#endif
}
while (GDKisspace(*p))
p++;
return (ssize_t) (p - src);
overflow:
while (num10(*p))
p++;
GDKerror("overflow: \"%.*s\" does not fit in %s\n",
(int) (p - src), src, ATOMname(tp));
bailout:
memcpy(*dst, ATOMnilptr(tp), sz);
return -1;
}
