自学教程：C++ FIXNUM_P函数代码示例

/* * call-seq: *   GMP::RandState.new() *   GMP::RandState.new(:mt) #=> uses gmp_randinit_mt *   GMP::RandState.new(:lc_2exp, a, c, m2exp) #=> uses gmp_randinit_lc_2exp *   GMP::RandState.new(:lc_2exp_size, size) #=> uses gmp_randinit_lc_2exp_size * * Initializes a new Random State object. Multiple GMP::RandState objects can * be instantiated. They may use different generators and the states * are kept separate. */VALUE r_gmprandstatesg_new(int argc, VALUE *argv, VALUE klass){  MP_RANDSTATE *rs_val;  VALUE rs;  VALUE algorithm, arg2, arg3, arg4;  ID algorithm_id = rb_intern("default");  MP_INT *a_val;  unsigned long c_val, m2exp_val;  unsigned long size_val;  int free_a_val = 0;  ID default_algorithm      = rb_intern("default");  ID mt_algorithm           = rb_intern("mt");  ID lc_2exp_algorithm      = rb_intern("lc_2exp");  ID lc_2exp_size_algorithm = rb_intern("lc_2exp_size");  (void)klass;  mprandstate_make_struct(rs, rs_val);  rb_scan_args(argc, argv, "04", &algorithm, &arg2, &arg3, &arg4);  if (NIL_P(algorithm))    { algorithm_id = rb_intern("default"); }  /* default value */  if (SYMBOL_P(algorithm)) { algorithm_id = rb_to_id(algorithm); }  if (algorithm_id == default_algorithm ||      algorithm_id == mt_algorithm) {    if (argc > 1)      rb_raise(rb_eArgError, "wrong # of arguments (%d for 0 or 1)", argc);    gmp_randinit_default(rs_val);  } else if (algorithm_id == lc_2exp_algorithm) {    if (argc != 4)      rb_raise(rb_eArgError, "wrong # of arguments (%d for 4)", argc);    if (GMPZ_P(arg2)) {      mpz_get_struct(arg2, a_val);    } else if (FIXNUM_P(arg2)) {      mpz_temp_alloc(a_val);      mpz_init_set_ui(a_val, FIX2INT(arg2));      free_a_val = 1;    } else if (BIGNUM_P(arg2)) {      mpz_temp_from_bignum(a_val, arg2);      free_a_val = 1;    } else {      typeerror_as(ZXB, "b");    }    c_val     = NUM2LONG(arg3);    m2exp_val = NUM2LONG(arg4);    gmp_randinit_lc_2exp(rs_val, a_val, c_val, m2exp_val);  } else if (algorithm_id == lc_2exp_size_algorithm) {    if (argc != 2)      rb_raise(rb_eArgError, "wrong # of arguments (%d for 2)", argc);    size_val = NUM2LONG(arg2);    if (size_val > 128)      rb_raise(rb_eArgError, "size must be within [0..128]");    if (gmp_randinit_lc_2exp_size (rs_val, size_val) == 0)      rb_raise(rb_eArgError, "could not gmp_randinit_lc_2exp_size with %lu", size_val);  }  if (free_a_val) { mpz_temp_free(a_val); }  rb_obj_call_init(rs, argc, argv);  return rs;}

inline static VALUEf_div(VALUE x, VALUE y){    if (FIXNUM_P(y) && FIX2LONG(y) == 1)	return x;    return rb_funcall(x, '/', 1, y);}

/* * call-seq: *   rand_state.urandomm(integer) * * From the GMP Manual: * * Generate a uniformly distributed random integer in the range 0 to * _integer-1_, inclusive. _integer_ can be an instance of GMP::Z, *  Fixnum, or Bignum */VALUE r_gmprandstate_urandomm(VALUE self, VALUE arg){  MP_RANDSTATE *self_val;  MP_INT *res_val, *arg_val;  int free_arg_val = 0;  VALUE res;  mprandstate_get_struct(self,self_val);  if (GMPZ_P(arg)) {    mpz_get_struct(arg, arg_val);  } else if (FIXNUM_P(arg)) {    mpz_temp_alloc(arg_val);    mpz_init_set_ui(arg_val, FIX2INT(arg));    free_arg_val = 1;  } else if (BIGNUM_P(arg)) {    mpz_temp_from_bignum(arg_val, arg);    free_arg_val = 1;  } else {    typeerror_as(ZXB, "arg");  }  mpz_make_struct_init(res, res_val);  mpz_urandomm(res_val, self_val, arg_val);  if (free_arg_val) { mpz_temp_free(arg_val); }  return res;}

inline static VALUEf_zero_p(VALUE x){    if (FIXNUM_P(x))	return f_boolcast(FIX2LONG(x) == 0);    return rb_funcall(x, id_equal_p, 1, ZERO);}

/** call-seq:  time = timeSet the timestamp as removal condition.Parameters:[time]   an integer, for specifying ticks, or a tuple of splat of seconds and nanosecondsNormally used with the flags +SND_SEQ_REMOVE_TIME_AFTER+ or +SND_SEQ_REMOVE_TIME_BEFORE+.See RRTS::Driver::AlsaRemoveClass_i#condition=.*/static VALUEwrap_snd_seq_remove_events_set_time(int argc, VALUE *argv, VALUE v_rmp){  snd_seq_remove_events_t *rmp;  Data_Get_Struct(v_rmp, snd_seq_remove_events_t, rmp);  VALUE v_sec, v_nsec;  rb_scan_args(argc, argv, "11", &v_sec, &v_nsec);  snd_seq_timestamp_t time;  if (NIL_P(v_nsec))    {      if (FIXNUM_P(v_sec))          time.tick = NUM2UINT(v_sec);      else        {          v_sec = rb_check_array_type(v_sec);          if (!RTEST(v_sec)) RAISE_MIDI_ERROR_FMT0("API call error: bad time format");          time.time.tv_sec = NUM2UINT(rb_ary_entry(v_sec, 0));          time.time.tv_nsec = NUM2UINT(rb_ary_entry(v_sec, 1));        }    }  else    {      time.time.tv_sec = NUM2UINT(v_sec);      time.time.tv_nsec = NUM2UINT(v_nsec);    }  snd_seq_remove_events_set_time(rmp, &time);  return Qnil;}

inline static VALUEf_one_p(VALUE x){    if (FIXNUM_P(x))	return f_boolcast(FIX2LONG(x) == 1);    return rb_funcall(x, id_equal_p, 1, ONE);}

inline static VALUEf_negative_p(VALUE x){    if (FIXNUM_P(x))	return f_boolcast(FIX2LONG(x) < 0);    return rb_funcall(x, '<', 1, ZERO);}

inline static VALUEf_sub(VALUE x, VALUE y){    if (FIXNUM_P(y) && FIX2LONG(y) == 0)	return x;    return rb_funcall(x, '-', 1, y);}

static VALUEconsole_key_pressed_p(VALUE io, VALUE k){    int vk = -1;    if (FIXNUM_P(k)) {	vk = NUM2UINT(k);    }    else {	const struct vktable *t;	const char *kn;	if (SYMBOL_P(k)) {	    k = rb_sym2str(k);	    kn = RSTRING_PTR(k);	}	else {	    kn = StringValuePtr(k);	}	t = console_win32_vk(kn, RSTRING_LEN(k));	if (!t || (vk = (short)t->vk) == -1) {	    rb_raise(rb_eArgError, "unknown virtual key code: % "PRIsVALUE, k);	}    }    return GetKeyState(vk) & 0x80 ? Qtrue : Qfalse;}

/* * call-seq: *   rand_state.mpfr_urandomb() * * From the MPFR Manual: * * Generate a uniformly distributed random float in the interval 0 <= rop < 1. */VALUE r_gmprandstate_mpfr_urandomb(int argc, VALUE *argv, VALUE self){  MP_RANDSTATE *self_val;  MP_FLOAT *res_val;  VALUE res;  unsigned long prec = 0;    if (argc > 1)    rb_raise (rb_eArgError, "wrong # of arguments(%d for 0 or 1)", argc);  mprandstate_get_struct (self,self_val);    if (argc == 1) {    if (FIXNUM_P (argv[0])) {      if (FIX2INT (argv[0]) >= 0)        prec = FIX2INT (argv[0]);      else        rb_raise (rb_eRangeError, "prec must be non-negative");    } else {      rb_raise (rb_eTypeError, "prec must be a Fixnum");    }  }    mpf_make_struct (res, res_val);  if (prec == 0) { mpf_init (res_val); }  else           { mpf_init2 (res_val, prec); }    mpfr_urandomb (res_val, self_val);    return res;}

const char *rb_builtin_class_name(VALUE x){    const char *etype;    if (NIL_P(x)) {	etype = "nil";    }    else if (FIXNUM_P(x)) {	etype = "Fixnum";    }    else if (SYMBOL_P(x)) {	etype = "Symbol";    }    else if (RB_TYPE_P(x, T_TRUE)) {	etype = "true";    }    else if (RB_TYPE_P(x, T_FALSE)) {	etype = "false";    }    else {	etype = rb_obj_classname(x);    }    return etype;}

VALUEsubIconDrawPoint(int argc,  VALUE *argv,  VALUE self){  VALUE data[4] = { Qnil };  rb_scan_args(argc, argv, "22", &data[0], &data[1], &data[2], &data[3]);  /* Check object types */  if(FIXNUM_P(data[0]) && FIXNUM_P(data[1]))    {      SubtlextIcon *i = NULL;      Data_Get_Struct(self, SubtlextIcon, i);      if(i)        {          XGCValues gvals;          /* Create on demand */          if(0 == i->gc)            i->gc = XCreateGC(display, i->pixmap, 0, NULL);          /* Update GC */          gvals.foreground = 1;          gvals.background = 0;          if(i->flags & ICON_PIXMAP)            {              if(!NIL_P(data[2]))                gvals.foreground = subColorPixel(data[2], Qnil, Qnil, NULL);              if(!NIL_P(data[3]))                gvals.background = subColorPixel(data[3], Qnil, Qnil, NULL);            }          XChangeGC(display, i->gc, GCForeground|GCBackground, &gvals);          XDrawPoint(display, i->pixmap, i->gc,            FIX2INT(data[0]), FIX2INT(data[1]));          XFlush(display);        }    }  else rb_raise(rb_eArgError, "Unexpected value-types");  return Qnil;} /* }}} */

static VALUErange_each(VALUE range){    VALUE beg, end;    RETURN_SIZED_ENUMERATOR(range, 0, 0, range_enum_size);    beg = RANGE_BEG(range);    end = RANGE_END(range);    if (FIXNUM_P(beg) && FIXNUM_P(end)) { /* fixnums are special */	long lim = FIX2LONG(end);	long i;	if (!EXCL(range))	    lim += 1;	for (i = FIX2LONG(beg); i < lim; i++) {	    rb_yield(LONG2FIX(i));	}    }    else if (SYMBOL_P(beg) && SYMBOL_P(end)) { /* symbols are special */	VALUE args[2];	args[0] = rb_sym_to_s(end);	args[1] = EXCL(range) ? Qtrue : Qfalse;	rb_block_call(rb_sym_to_s(beg), rb_intern("upto"), 2, args, sym_each_i, 0);    }    else {	VALUE tmp = rb_check_string_type(beg);	if (!NIL_P(tmp)) {	    VALUE args[2];	    args[0] = end;	    args[1] = EXCL(range) ? Qtrue : Qfalse;	    rb_block_call(tmp, rb_intern("upto"), 2, args, each_i, 0);	}	else {	    if (!discrete_object_p(beg)) {		rb_raise(rb_eTypeError, "can't iterate from %s",			 rb_obj_classname(beg));	    }	    range_each_func(range, each_i, 0);	}    }    return range;}

static VALUErange_include(VALUE range, VALUE val){    VALUE beg = RANGE_BEG(range);    VALUE end = RANGE_END(range);    int nv = FIXNUM_P(beg) || FIXNUM_P(end) ||	     rb_obj_is_kind_of(beg, rb_cNumeric) ||	     rb_obj_is_kind_of(end, rb_cNumeric);    if (nv ||	!NIL_P(rb_check_to_integer(beg, "to_int")) ||	!NIL_P(rb_check_to_integer(end, "to_int"))) {	if (r_le(beg, val)) {	    if (EXCL(range)) {		if (r_lt(val, end))		    return Qtrue;	    }	    else {		if (r_le(val, end))		    return Qtrue;	    }	}	return Qfalse;    }    else if (TYPE(beg) == T_STRING && TYPE(end) == T_STRING &&	     RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) {	if (NIL_P(val)) return Qfalse;	if (TYPE(val) == T_STRING) {	    if (RSTRING_LEN(val) == 0 || RSTRING_LEN(val) > 1)		return Qfalse;	    else {		char b = RSTRING_PTR(beg)[0];		char e = RSTRING_PTR(end)[0];		char v = RSTRING_PTR(val)[0];		if (ISASCII(b) && ISASCII(e) && ISASCII(v)) {		    if (b <= v && v < e) return Qtrue;		    if (!EXCL(range) && v == e) return Qtrue;		    return Qfalse;		}	    }	}    }    /* TODO: ruby_frame->this_func = rb_intern("include?"); */    return rb_call_super(1, &val);}

PRIMITIVE VALUEvm_fast_minus(VALUE left, VALUE right, unsigned char overriden){    if (overriden == 0 && NUMERIC_IMM_P(left) && NUMERIC_IMM_P(right)) {	if (FIXNUM_P(left) && FIXNUM_P(right)) {	    const long res = FIX2LONG(left) - FIX2LONG(right);	    if (FIXABLE(res)) {		return LONG2FIX(res);	    }	}	else {	    const double res = IMM2DBL(left) - IMM2DBL(right);	    return DBL2FIXFLOAT(res);	}    }    return vm_dispatch(0, left, selMINUS, NULL, 0, 1, &right);}

static VALUEbackend_initialize(VALUE rb_obj, VALUE mysql_host, VALUE mysql_user, VALUE mysql_passwd, VALUE mysql_db, VALUE mysql_table_name, VALUE mysql_storage_engine, VALUE mysql_port, VALUE mysql_unix_socket, VALUE mysql_client_flag){  git_odb *odb;  git_odb_backend *backend;  int error;  char *error_msg;  if (!FIXNUM_P(mysql_port)) {    rb_raise(rb_eArgError, "MySQL port must be a Fixnum");  }  if (!FIXNUM_P(mysql_client_flag)) {    rb_raise(rb_eArgError, "MySQL client flag must be a Fixnum");  }  error =    git_odb_backend_mysql(      &backend,      StringValuePtr(mysql_host),      StringValuePtr(mysql_user),      StringValuePtr(mysql_passwd),      StringValuePtr(mysql_db),      StringValuePtr(mysql_table_name),      StringValuePtr(mysql_storage_engine),      FIX2INT(mysql_port),      StringValuePtr(mysql_unix_socket),      NUM2ULONG(mysql_client_flag),      &error_msg);  if (error != 0) {    if (*error_msg == 0) {      rb_raise(rb_eRuntimeError, "An error occurred when trying to connect to the database");    }    else {      rb_raise(rb_eRuntimeError, "%s", error_msg);    }  }  git_odb_new(&odb);  git_odb_add_backend(odb, backend, 10);  DATA_PTR(rb_obj) = odb;  return rb_obj;}

static VALUEprintf_test_call(int argc, VALUE *argv, VALUE self){    VALUE opt, type, num, result;    char format[sizeof(int) * 6 + 8], *p = format, cnv;    int n;    const char *s;    rb_scan_args(argc, argv, "2:", &type, &num, &opt);    Check_Type(type, T_STRING);    if (RSTRING_LEN(type) != 1) rb_raise(rb_eArgError, "wrong length(%ld)", RSTRING_LEN(type));    switch (cnv = RSTRING_PTR(type)[0]) {      case 'd': case 'x': case 'o': case 'X':	n = NUM2INT(num);	break;      case 's':	s = StringValueCStr(num);	break;      default: rb_raise(rb_eArgError, "wrong conversion(%c)", cnv);    }    *p++ = '%';    if (!NIL_P(opt)) {	VALUE v;	Check_Type(opt, T_HASH);	if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("space"))))) {	    *p++ = ' ';	}	if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("hash"))))) {	    *p++ = '#';	}	if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("plus"))))) {	    *p++ = '+';	}	if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("minus"))))) {	    *p++ = '-';	}	if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("zero"))))) {	    *p++ = '0';	}	if (!NIL_P(v = rb_hash_aref(opt, ID2SYM(rb_intern("width"))))) {	    p = utoa(p, format + sizeof(format), NUM2UINT(v));	}	if (!NIL_P(v = rb_hash_aref(opt, ID2SYM(rb_intern("prec"))))) {	    *p++ = '.';	    if (FIXNUM_P(v))		p = utoa(p, format + sizeof(format), NUM2UINT(v));	}    }    *p++ = cnv;    *p++ = '/0';    if (cnv == 's') {	result = rb_enc_sprintf(rb_usascii_encoding(), format, s);    }    else {	result = rb_enc_sprintf(rb_usascii_encoding(), format, n);    }    return rb_assoc_new(result, rb_usascii_str_new_cstr(format));}

VALUE board_subscript( int argc, VALUE *argv, VALUE self ) {  if( argc == 2 && FIXNUM_P(argv[0]) && FIXNUM_P(argv[1]) ) {    return board_get( self, argv[0], argv[1] );  }  else if( argc == 1 ) {    return board_get_coord( self, argv[0] );  }  else {    VALUE ary = rb_ary_new2( argc );    int i;    for( i = 0; i < argc; i++ ) {      rb_ary_push( ary, board_get_coord( self, argv[i] ) );    }    return ary;  }  return Qnil;}

/* * テ
C++ FI_VERSION函数代码示例
C++ FIXED_TO_INT函数代码示例