/***** BEGIN LICENSE BLOCK *****

* Version: CPL 1.0/GPL 2.0/LGPL 2.1

*

* The contents of this file are subject to the Common Public

* License Version 1.0 (the "License"); you may not use this file

* except in compliance with the License. You may obtain a copy of

* the License at http://www.eclipse.org/legal/cpl-v10.html

*

* Software distributed under the License is distributed on an "AS

* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or

* implied. See the License for the specific language governing

* rights and limitations under the License.

*

* Copyright (C) 2008-2010 Wayne Meissner

*

* Alternatively, the contents of this file may be used under the terms of

* either of the GNU General Public License Version 2 or later (the "GPL"),

* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

* in which case the provisions of the GPL or the LGPL are applicable instead

* of those above. If you wish to allow use of your version of this file only

* under the terms of either the GPL or the LGPL, and not to allow others to

* use your version of this file under the terms of the CPL, indicate your

* decision by deleting the provisions above and replace them with the notice

* and other provisions required by the GPL or the LGPL. If you do not delete

* the provisions above, a recipient may use your version of this file under

* the terms of any one of the CPL, the GPL or the LGPL.

***** END LICENSE BLOCK *****/

#include "jruby.h"

#include "JUtil.h"

#include "ruby.h"

#include "Handle.h"

#include "JLocalEnv.h"

using namespace jruby;

#define CACHE_OFFSET (128L)

static jobject fixnumCache[2 * CACHE_OFFSET];

static inline RubyFixnum* newNumber(jmethodID method, long long v);

extern "C" int

rb_num2int(VALUE v)

{

return likely(FIXNUM_P(v)) ? FIX2INT(v) : (int) rb_num2ll(v);

}

extern "C" unsigned int

rb_num2uint(VALUE v)

{

return likely(FIXNUM_P(v)) ? FIX2UINT(v) : (unsigned int) rb_num2ull(v);

}

extern "C" long

rb_num2long(VALUE v)

{

return likely(FIXNUM_P(v)) ? FIX2LONG(v) : (long) rb_num2ll(v);

}

extern "C" unsigned long

rb_num2ulong(VALUE v)

{

return likely(FIXNUM_P(v)) ? FIX2ULONG(v) : (unsigned long) rb_num2ull(v);

}

extern "C" long

rb_fix2int(VALUE v)

{

return FIX2LONG(v);

}

extern "C" unsigned long

rb_fix2uint(VALUE v)

{

return FIX2ULONG(v);

}

extern "C" long long

rb_num2ll(VALUE v)

{

if (FIXNUM_P(v)) {

return FIX2LONG(v);

}

Handle* h = Handle::valueOf(v);

if (h->getType() == T_FIXNUM) {

return ((RubyFixnum *) h)->longValue();

}

JLocalEnv env;

jsync(env);

jvalue params[1];

params[0].l = valueToObject(env, v);

jlong result = env->CallStaticLongMethodA(RubyNumeric_class, RubyNumeric_num2long_method, params);

checkExceptions(env);

return (long long) result;

}

extern "C" unsigned long long

rb_num2ull(VALUE v)

{

return (unsigned long long) rb_num2ll(v);

}

extern "C" char

rb_num2chr(VALUE v)

{

JLocalEnv env;

jbyte result = env->CallStaticByteMethod(RubyNumeric_class, RubyNumeric_num2chr_method, valueToObject(env, v));

checkExceptions(env);

return (char) result;

}

extern "C" VALUE

rb_int2inum(long v)

{

return FIXABLE(v) ? INT2FIX(v) : rb_ll2inum(v);

}

extern "C" VALUE

rb_uint2inum(unsigned long v)

{

return POSFIXABLE(v) ? UINT2FIX(v) : rb_ull2inum(v);

}

extern "C" VALUE

rb_Integer(VALUE val)

{

return rb_to_integer(val, "to_i");

}

extern "C" VALUE

rb_to_int(VALUE val)

{

return rb_to_integer(val, "to_int");

}

static inline RubyFixnum*

newNumber(jmethodID method, long long v)

{

JLocalEnv env;

jvalue params[2];

params[0].l = getRuntime();

params[1].j = (jlong) v;

jlong result = env->CallStaticLongMethodA(JRuby_class, method, params);

checkExceptions(env);

return (RubyFixnum *) j2p(result);

}

jobject

jruby::fixnumToObject(JNIEnv* env, VALUE v)

{

SIGNED_VALUE i = RSHIFT((SIGNED_VALUE) v, 1);

jobject obj;

if (likely(i >= -CACHE_OFFSET && i < CACHE_OFFSET && fixnumCache[i + CACHE_OFFSET] != NULL)) {

return fixnumCache[i + CACHE_OFFSET];

}

jvalue params[2];

params[0].l = getRuntime();

params[1].j = i;

obj = env->CallStaticObjectMethodA(RubyNumeric_class, RubyNumeric_int2fix_method, params);

if (unlikely(i >= -CACHE_OFFSET && i < CACHE_OFFSET)) {

fixnumCache[i + CACHE_OFFSET] = env->NewGlobalRef(obj);

}

return obj;

}

extern "C" VALUE

rb_ll2inum(long long v)

{

if (v < FIXNUM_MAX && v >= FIXNUM_MIN) {

return ((VALUE)(((SIGNED_VALUE)(v))<<1 | FIXNUM_FLAG));

}

return (VALUE) newNumber(JRuby_ll2inum, v);

}

extern "C" VALUE

rb_ull2inum(unsigned long long v)

{

if (v < (unsigned long long) FIXNUM_MAX) {

return ((VALUE)(((SIGNED_VALUE)(v))<<1 | FIXNUM_FLAG));

}

return (VALUE) newNumber(JRuby_ull2inum, (long long) v);

}

extern "C" VALUE

rb_int2big(long long v)

{

return (VALUE) newNumber(JRuby_int2big, v);

}

extern "C" VALUE

rb_uint2big(unsigned long long v)

{

return (VALUE) newNumber(JRuby_uint2big, (long long) v);

}