static VALUE
PRInt64ToRuby(PRInt64 aNative)
{
if(LL_CMP(aNative, <, LL_ZERO))
{
PRUint64 abs64;
LL_NEG(abs64, aNative);
return rb_funcall(RubyFrom64BitInt(abs64), id_uminus, 0);
}
else
return RubyFrom64BitInt((PRUint64)aNative);
static PRInt64
RubyToPRInt64(VALUE aRuby)
{
if(RVAL2CBOOL(rb_funcall(aRuby, id_lt, 1, INT2FIX(0))))
{
VALUE absRuby = rb_funcall(aRuby, id_abs, 0);
PRInt64 result;
LL_NEG(result, RubyTo64BitInt(absRuby));
return result;
} else
return (PRInt64)RubyTo64BitInt(aRuby);
}
static PRUint64
_pr_strtoull(const char *str, char **endptr, int base)
{
static const int BASE_MAX = 16;
static const char digits[] = "0123456789abcdef";
char *digitPtr;
PRUint64 x; /* return value */
PRInt64 base64;
const char *cPtr;
PRBool negative;
const char *digitStart;
PR_ASSERT(base == 0 || base == 8 || base == 10 || base == 16);
if (base < 0 || base == 1 || base > BASE_MAX) {
if (endptr) {
*endptr = (char *) str;
return LL_ZERO;
}
}
cPtr = str;
while (isspace(*cPtr)) {
++cPtr;
}
negative = PR_FALSE;
if (*cPtr == '-') {
negative = PR_TRUE;
cPtr++;
} else if (*cPtr == '+') {
cPtr++;
}
if (base == 16) {
if (*cPtr == '0' && (cPtr[1] == 'x' || cPtr[1] == 'X')) {
cPtr += 2;
}
} else if (base == 0) {
if (*cPtr != '0') {
base = 10;
} else if (cPtr[1] == 'x' || cPtr[1] == 'X') {
base = 16;
cPtr += 2;
} else {
base = 8;
}
}
PR_ASSERT(base != 0);
LL_I2L(base64, base);
digitStart = cPtr;
/* Skip leading zeros */
while (*cPtr == '0') {
cPtr++;
}
LL_I2L(x, 0);
while ((digitPtr = (char*)memchr(digits, tolower(*cPtr), base)) != NULL) {
PRUint64 d;
LL_I2L(d, (digitPtr - digits));
LL_MUL(x, x, base64);
LL_ADD(x, x, d);
cPtr++;
}
if (cPtr == digitStart) {
if (endptr) {
*endptr = (char *) str;
}
return LL_ZERO;
}
if (negative) {
#ifdef HAVE_LONG_LONG
/* The cast to a signed type is to avoid a compiler warning */
x = -(PRInt64)x;
#else
LL_NEG(x, x);
#endif
}
if (endptr) {
*endptr = (char *) cPtr;
}
return x;
}
