Ruby » Ruby master

#define BIGNUM_SET_NEGATIVE_SIGN(b) BIGNUM_SET_SIGN(b, 0)

#define BIGNUM_SET_POSITIVE_SIGN(b) BIGNUM_SET_SIGN(b, 1)

#define BDIGITS_ZERO(ptr, n) do { \

BDIGIT *bdigitz_zero_ptr = (ptr); \

*/

static VALUE

{

}

}

}

VALUE

void

Init_Bignum(void)

{

#ifdef USE_GMP

/* The version of loaded GMP. */

rb_define_const(rb_cInteger, "GMP_VERSION", rb_sprintf("GMP %s", gmp_version));

#endif

assert_equal ':sym', ':sym.inspect'

assert_equal 'Symbol', ':sym.class'

assert_equal '1234', '1234'

assert_equal '1234', '1_2_3_4'

assert_equal '18', '0x12'

assert_equal '15', '0o17'

assert_equal '5', '0b101'

assert_equal '123456789012345678901234567890', '123456789012345678901234567890'

assert_equal '2.0', '2.0'

assert_equal 'Float', '1.3.class'

assert_equal 'c', 'r = ("a".."c"); r.end'

assert_equal 'String', '__FILE__.class'

###

etype = "nil";

}

else if (FIXNUM_P(x)) {

}

else if (SYMBOL_P(x)) {

etype = "Symbol";

#endif

static VALUE mJSON, mExt, mGenerator, cState, mGeneratorMethods, mObject,

mTrueClass, mFalseClass, mNilClass, eGeneratorError,

eNestingError, CRegexp_MULTILINE, CJSON_SAFE_STATE_PROTOTYPE,

i_SAFE_STATE_PROTOTYPE;

*

* Returns a JSON string representation for this Integer number.

*/

static VALUE mFixnum_to_json(int argc, VALUE *argv, VALUE self)

{

GENERATE_JSON(fixnum);

fbuffer_append_str(buffer, tmp);

}

static void generate_json_float(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)

{

double value = RFLOAT_VALUE(obj);

generate_json_false(buffer, Vstate, state, obj);

} else if (obj == Qtrue) {

generate_json_true(buffer, Vstate, state, obj);

generate_json_fixnum(buffer, Vstate, state, obj);

generate_json_bignum(buffer, Vstate, state, obj);

} else if (klass == rb_cFloat) {

generate_json_float(buffer, Vstate, state, obj);

rb_define_method(mHash, "to_json", mHash_to_json, -1);

mArray = rb_define_module_under(mGeneratorMethods, "Array");

rb_define_method(mArray, "to_json", mArray_to_json, -1);

mFloat = rb_define_module_under(mGeneratorMethods, "Float");

rb_define_method(mFloat, "to_json", mFloat_to_json, -1);

mString = rb_define_module_under(mGeneratorMethods, "String");

static void generate_json_null(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);

static void generate_json_false(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);

static void generate_json_true(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);

static void generate_json_fixnum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);

static void generate_json_bignum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);

static void generate_json_float(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);

rb_class_of(VALUE obj)

{

if (RB_IMMEDIATE_P(obj)) {

if (RB_FLONUM_P(obj)) return rb_cFloat;

if (obj == RUBY_Qtrue) return rb_cTrueClass;

if (RB_STATIC_SYM_P(obj)) return rb_cSymbol;

case T_STRING:

if (BASIC_OP_UNREDEFINED_P(BOP_EQQ,

SYMBOL_REDEFINED_OP_FLAG |

FLOAT_REDEFINED_OP_FLAG |

NIL_REDEFINED_OP_FLAG |

TRUE_REDEFINED_OP_FLAG |

FALSE_REDEFINED_OP_FLAG |

(VALUE val)

{

if (FIXNUM_2_P(recv, obj) &&

/* fixnum + fixnum */

#ifndef LONG_LONG_VALUE

val = (recv + (obj & (~1)));

(VALUE val)

{

if (FIXNUM_2_P(recv, obj) &&

long a, b, c;

a = FIX2LONG(recv);

(VALUE val)

{

if (FIXNUM_2_P(recv, obj) &&

val = rb_fix_mul_fix(recv, obj);

}

else if (FLONUM_2_P(recv, obj) &&

(VALUE val)

{

if (FIXNUM_2_P(recv, obj) &&

if (FIX2LONG(obj) == 0) goto INSN_LABEL(normal_dispatch);

val = rb_fix_div_fix(recv, obj);

}

(VALUE val)

{

if (FIXNUM_2_P(recv, obj) &&

if (FIX2LONG(obj) == 0) goto INSN_LABEL(normal_dispatch);

val = rb_fix_mod_fix(recv, obj);

}

(VALUE val)

{

if (FIXNUM_2_P(recv, obj) &&

SIGNED_VALUE a = recv, b = obj;

if (a < b) {

(VALUE val)

{

if (FIXNUM_2_P(recv, obj) &&

SIGNED_VALUE a = recv, b = obj;

if (a <= b) {

(VALUE val)

{

if (FIXNUM_2_P(recv, obj) &&

SIGNED_VALUE a = recv, b = obj;

if (a > b) {

(VALUE val)

{

if (FIXNUM_2_P(recv, obj) &&

SIGNED_VALUE a = recv, b = obj;

if (a >= b) {

{

if (SPECIAL_CONST_P(recv)) {

if (FIXNUM_P(recv) &&

const VALUE obj = INT2FIX(1);

/* fixnum + INT2FIX(1) */

val = (recv + (obj & (~1)));

end

##

# return more precise values from mathematical expressions.

#

# 2/3*3 # => 0

# require 'mathn'

# 2/3*3 # => 2

#

# (2**72) / ((2**70) * 3) # => 4/3

* (-1).succ #=> 0

*/

VALUE

rb_int_succ(VALUE num)

{

rb_define_method(rb_cInteger, "abs", int_abs, 0);

rb_define_method(rb_cInteger, "magnitude", int_abs, 0);

rb_define_method(rb_cInteger, "==", int_equal, 1);

rb_define_method(rb_cInteger, ">", int_gt, 1);

rb_define_method(rb_cInteger, ">=", int_ge, 1);

rb_define_method(rb_cInteger, "size", int_size, 0);

rb_define_method(rb_cInteger, "bit_length", rb_int_bit_length, 0);

rb_cFloat = rb_define_class("Float", rb_cNumeric);

if (value == rb_cNilClass) {

return LITERAL("nil");

}

}

else if (value == rb_cSymbol) {

return LITERAL("Symbol");

end

def assert_fix2i_success(type, num, result=num)

func = "FIX2#{type}".upcase

assert_fix2i_success_internal(result.to_s, func, num)

end

end

def assert_fix2i_error(type, num)

func = "FIX2#{type}".upcase

assert_num2i_error_internal(func, num)

end

assert_raise_with_message(TypeError, "wrong argument type Symbol (expected typed_data)") {Bug::TypedData.check(:e)}

assert_raise_with_message(TypeError, "wrong argument type String (expected typed_data)") {Bug::TypedData.check("a")}

end

def assert_fixnum(v, msg=nil)

end

def assert_bignum(v, msg=nil)

end

class << (AssertFile = Struct.new(:failure_message).new)

require_relative '../envutil'

require 'test/unit/testcase'

require 'optparse'

# See Test::Unit

module Test

end

BIGNUM_MIN_BITS = n

def setup

@verbose = $VERBOSE

end

def test_too_big_to_s

return

end

assert_raise_with_message(RangeError, /too big to convert/) {(1 << big).to_s}

def test_create

assert_equal({1=>2, 3=>4}, @cls[[[1,2],[3,4]]])

assert_raise(ArgumentError) { Hash[0, 1, 2] }

bug5406 = '[ruby-core:39945]'

assert_raise(ArgumentError, bug5406) { @cls[[[1, 2], [3, 4, 5]]] }

assert_equal({1=>2, 3=>4}, @cls[1,2,3,4])

def test_succ

assert_equal(2, 1.send(:succ))

end

def test_chr

assert_raise_with_message(TypeError, /:"\\u3042"/) {1^:"\u{3042}"}

bug10711 = '[ruby-core:67405] [Bug #10711]'

assert_raise_with_message(TypeError, exp, bug10711) { 1 & 1.2 }

end

assert_bignum FIXNUM_MAX + 1

assert_equal 21, 10 + 11

end

def test_fixnum_minus

assert_bignum FIXNUM_MIN - 1

assert_equal 5, 8 - 3

end

def test_fixnum_mul

assert_equal 15, 3 * 5

end

def test_fixnum_div

assert_equal 3, 15 / 5

end

def test_fixnum_mod

assert_equal 1, 8 % 7

end

def test_float_plus

def test_error_message_on_failed_conversion

bug7539 = '[ruby-core:50733]'

assert_equal false, /x/=== 42

Regexp.quote(42)

}

end

events.shift)

assert_equal(["line", 4, __method__, self.class],

events.shift)

events.shift)

events.shift)

assert_equal(["line", 5, __method__, self.class],

events.shift)

events.shift)

assert_equal(["line", 5, :add, self.class],

events.shift)

events.shift)

events.shift)

assert_equal(["return", 6, :add, self.class],

events.shift)

["c-return", 8, :new, Class],

["call", 4, :foo, ThreadTraceInnerClass],

["line", 5, :foo, ThreadTraceInnerClass],

["return", 6, :foo, ThreadTraceInnerClass],

["line", 9, __method__, self.class],

["c-call", 9, :set_trace_func, Thread]].each do |e|

# pp events

# expected_events =

[[:b_call, :test_tracepoint_block, TestSetTraceFunc, TestSetTraceFunc, nil],

[:b_call, :test_tracepoint_block, TestSetTraceFunc, TestSetTraceFunc, nil],

[:b_return, :test_tracepoint_block, TestSetTraceFunc, TestSetTraceFunc, 3],

[:call, :method_for_test_tracepoint_block, TestSetTraceFunc, TestSetTraceFunc, nil],

[:b_call, :test_tracepoint_block, TestSetTraceFunc, TestSetTraceFunc, nil],

[:b_return, :test_tracepoint_block, TestSetTraceFunc, TestSetTraceFunc, 4],

static int

vm_redefinition_check_flag(VALUE klass)

{

if (klass == rb_cFloat) return FLOAT_REDEFINED_OP_FLAG;

if (klass == rb_cString) return STRING_REDEFINED_OP_FLAG;

if (klass == rb_cArray) return ARRAY_REDEFINED_OP_FLAG;

if (klass == rb_cHash) return HASH_REDEFINED_OP_FLAG;

if (klass == rb_cSymbol) return SYMBOL_REDEFINED_OP_FLAG;

if (klass == rb_cTime) return TIME_REDEFINED_OP_FLAG;

if (klass == rb_cRegexp) return REGEXP_REDEFINED_OP_FLAG;

#define OP(mid_, bop_) (mid = id##mid_, bop = BOP_##bop_, ruby_vm_redefined_flag[bop] = 0)

#define C(k) add_opt_method(rb_c##k, mid, bop)

C(NilClass), C(TrueClass), C(FalseClass));

OP(LTLT, LTLT), (C(String), C(Array));

OP(AREF, AREF), (C(Array), C(Hash));

OP(ASET, ASET), (C(Array), C(Hash));

OP(Length, LENGTH), (C(Array), C(String), C(Hash));

OP(Size, SIZE), (C(Array), C(String), C(Hash));

OP(EmptyP, EMPTY_P), (C(Array), C(String), C(Hash));

OP(EqTilde, MATCH), (C(Regexp), C(String));

OP(Freeze, FREEZE), (C(String));

OP(Max, MAX), (C(Array));

#define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE)) /* 64 KB or 128 KB */

/* optimize insn */

#define FLOAT_REDEFINED_OP_FLAG (1 << 1)

#define STRING_REDEFINED_OP_FLAG (1 << 2)

#define ARRAY_REDEFINED_OP_FLAG (1 << 3)

#define HASH_REDEFINED_OP_FLAG (1 << 4)

#define SYMBOL_REDEFINED_OP_FLAG (1 << 6)

#define TIME_REDEFINED_OP_FLAG (1 << 7)

#define REGEXP_REDEFINED_OP_FLAG (1 << 8)

opt_eq_func(VALUE recv, VALUE obj, CALL_INFO ci, CALL_CACHE cc)

{

if (FIXNUM_2_P(recv, obj) &&

return (recv == obj) ? Qtrue : Qfalse;

}

else if (FLONUM_2_P(recv, obj) &&