C++ NUM2LONG函数代码示例

static VALUE
lazy_take_func(VALUE val, VALUE args, int argc, VALUE *argv)
{
    long remain;
    VALUE memo = rb_ivar_get(argv[0], id_memo);
    if (NIL_P(memo)) {
	memo = args;
    }

    rb_funcall2(argv[0], id_yield, argc - 1, argv + 1);
    if ((remain = NUM2LONG(memo)-1) == 0) {
	return Qundef;
    }
    else {
	rb_ivar_set(argv[0], id_memo, LONG2NUM(remain));
	return Qnil;
    }
}

/*
 * Check the arguments to a deserialize function and process args
 */
static void des_check_deserialize_args(AMF_DESERIALIZER *des, int argc, VALUE *argv) {
    VALUE src;
    rb_scan_args(argc, argv, "01", &src);
    if(des->depth == 0) {
        if(src != Qnil) {
            des_set_src(des, src);
        } else {
            rb_raise(rb_eArgError, "Missing deserialization source");
        }
    } else {
        if(src != Qnil) {
            rb_raise(rb_eArgError, "Already deserializing a source - don't pass a new one");
        } else {
            // Make sure pos matches src pos in case StringIO source pos changed
            des->pos = NUM2LONG(rb_funcall(des->src, rb_intern("pos"), 0));
        }
    }
}

/*
 * call-seq: memory.put_string(offset, str)
 * @param [Numeric] offset
 * @param [String] str
 * @return [self]
 * @raise {SecurityError} when writing unsafe string to memory
 * @raise {IndexError} if +offset+ is too great
 * @raise {NullPointerError} if memory not initialized
 * Put a string in memory.
 */
static VALUE
memory_put_string(VALUE self, VALUE offset, VALUE str)
{
    AbstractMemory* ptr = MEMORY(self);
    long off, len;

    Check_Type(str, T_STRING);
    off = NUM2LONG(offset);
    len = RSTRING_LEN(str);

    checkWrite(ptr);
    checkBounds(ptr, off, len + 1);

    memcpy(ptr->address + off, RSTRING_PTR(str), len);
    *((char *) ptr->address + off + len) = '\0';

    return self;
}

// Run a test command, and store the result in two separate strings
//
// Example:
//   out, err, rc, major, minor = target.test_and_store_results_separately("find /etc -type l", "nobody")
// Input:
//   command: the command to run
//   user: the user under which to run the command
//         (optional, defaults to "root")
//   timeout: the time in seconds after which the command is aborted 
//            (optional, defaults to 60L)
// Output:
//   out: the standard output of the command
//   err: the standard error of the command
//   rc: the return code of the testing platform
//   major: the return code of the system under test
//   minor: the return code of the command
VALUE method_test_and_store_results_separately(VALUE self, VALUE ruby_args)
{
  long len;
  VALUE ruby_command,
        ruby_user,
        ruby_timeout;
  struct twopence_target *target;
  twopence_buf_t stdout_buf, stderr_buf;
  twopence_status_t status;
  int rc;

  Check_Type(ruby_args, T_ARRAY);
  len = RARRAY_LEN(ruby_args);
  if (len < 1 || len > 3)
    rb_raise(rb_eArgError, "wrong number of arguments");
  ruby_command = rb_ary_entry(ruby_args, 0);
  if (len >= 2)
  {
    ruby_user = rb_ary_entry(ruby_args, 1);
    Check_Type(ruby_user, T_STRING);
  }
  else ruby_user = rb_str_new2("root");
  if (len >= 3)
  {
    ruby_timeout = rb_ary_entry(ruby_args, 2);
    Check_Type(ruby_timeout, T_FIXNUM);
  }
  else ruby_timeout = LONG2NUM(60L);
  Data_Get_Struct(self, struct twopence_target, target);

  twopence_buf_init(&stdout_buf);
  twopence_buf_init(&stderr_buf);
  twopence_buf_resize(&stdout_buf, 65536);
  twopence_buf_resize(&stderr_buf, 65536);

  rc = twopence_test_and_store_results_separately(target,
         StringValueCStr(ruby_user), NUM2LONG(ruby_timeout), StringValueCStr(ruby_command),
         &stdout_buf, &stderr_buf, &status);

  return rb_ary_new3(5,
                     buffer_value(&stdout_buf),
                     buffer_value(&stderr_buf),
                     INT2NUM(rc), INT2NUM(status.major), INT2NUM(status.minor));
}

static VALUE
lazy_take(VALUE obj, VALUE n)
{
    long len = NUM2LONG(n);
    VALUE lazy;

    if (len < 0) {
	rb_raise(rb_eArgError, "attempt to take negative size");
    }
    if (len == 0) {
	VALUE len = INT2FIX(0);
	lazy = lazy_to_enum_i(obj, sym_cycle, 1, &len, 0);
    }
    else {
	lazy = rb_block_call(rb_cLazy, id_new, 1, &obj,
					 lazy_take_func, n);
    }
    return lazy_set_method(lazy, rb_ary_new3(1, n), lazy_take_size);
}

static VALUE
lazy_zip_arrays_func(VALUE val, VALUE arrays, int argc, VALUE *argv)
{
    VALUE yielder, ary, memo;
    long i, count;

    yielder = argv[0];
    memo = rb_attr_get(yielder, id_memo);
    count = NIL_P(memo) ? 0 : NUM2LONG(memo);

    ary = rb_ary_new2(RARRAY_LEN(arrays) + 1);
    rb_ary_push(ary, argv[1]);
    for (i = 0; i < RARRAY_LEN(arrays); i++) {
	rb_ary_push(ary, rb_ary_entry(RARRAY_AREF(arrays, i), count));
    }
    rb_funcall(yielder, id_yield, 1, ary);
    rb_ivar_set(yielder, id_memo, LONG2NUM(++count));
    return Qnil;
}

VALUE
rb_struct_aref(VALUE s, VALUE idx)
{
    long i;

    if (RB_TYPE_P(idx, T_STRING) || RB_TYPE_P(idx, T_SYMBOL)) {
	return rb_struct_aref_id(s, rb_to_id(idx));
    }

    i = NUM2LONG(idx);
    if (i < 0) i = RSTRUCT_LEN(s) + i;
    if (i < 0)
        rb_raise(rb_eIndexError, "offset %ld too small for struct(size:%ld)",
		 i, RSTRUCT_LEN(s));
    if (RSTRUCT_LEN(s) <= i)
        rb_raise(rb_eIndexError, "offset %ld too large for struct(size:%ld)",
		 i, RSTRUCT_LEN(s));
    return RSTRUCT_PTR(s)[i];
}

static VALUE
syserr_initialize(int argc, VALUE *argv, VALUE self)
{
#if !defined(_WIN32)
    char *strerror();
#endif
    const char *err;
    VALUE mesg, error;
    VALUE klass = rb_obj_class(self);

    if (klass == rb_eSystemCallError) {
	rb_scan_args(argc, argv, "11", &mesg, &error);
	if (argc == 1 && FIXNUM_P(mesg)) {
	    error = mesg; mesg = Qnil;
	}
	if (!NIL_P(error) && st_lookup(syserr_tbl, NUM2LONG(error), &klass)) {
	    /* change class */
	    if (TYPE(self) != T_OBJECT) { /* insurance to avoid type crash */
		rb_raise(rb_eTypeError, "invalid instance type");
	    }
	    RBASIC(self)->klass = klass;
	}
    }
    else {
	rb_scan_args(argc, argv, "01", &mesg);
	error = rb_const_get(klass, rb_intern("Errno"));
    }
    if (!NIL_P(error)) err = strerror(NUM2INT(error));
    else err = "unknown error";
    if (!NIL_P(mesg)) {
	VALUE str = mesg;

	StringValue(str);
	mesg = rb_sprintf("%s - %.*s", err,
			  (int)RSTRING_LEN(str), RSTRING_PTR(str));
    }
    else {
	mesg = rb_str_new2(err);
    }
    rb_call_super(1, &mesg);
    rb_iv_set(self, "errno", error);
    return self;
}

VALUE
rb_struct_aref(VALUE s, VALUE idx)
{
    long i;

    if (TYPE(idx) == T_STRING || TYPE(idx) == T_SYMBOL) {
	return rb_struct_aref_id(s, rb_to_id(idx));
    }

    i = NUM2LONG(idx);
    if (i < 0) i = RSTRUCT(s)->len + i;
    if (i < 0)
        rb_raise(rb_eIndexError, "offset %ld too small for struct(size:%ld)",
		 i, RSTRUCT(s)->len);
    if (RSTRUCT(s)->len <= i)
        rb_raise(rb_eIndexError, "offset %ld too large for struct(size:%ld)",
		 i, RSTRUCT(s)->len);
    return RSTRUCT(s)->ptr[i];
}

static VALUE
recursive_hash(VALUE s, VALUE dummy, int recur)
{
    long i, len;
    st_index_t h;
    VALUE n, *ptr;

    h = rb_hash_start(rb_hash(rb_obj_class(s)));
    if (!recur) {
	ptr = RSTRUCT_PTR(s);
	len = RSTRUCT_LEN(s);
	for (i = 0; i < len; i++) {
	    n = rb_hash(ptr[i]);
	    h = rb_hash_uint(h, NUM2LONG(n));
	}
    }
    h = rb_hash_end(h);
    return INT2FIX(h);
}

inline static VALUE
f_imul(long a, long b)
{
    VALUE r;
    long c;

    if (a == 0 || b == 0)
	return ZERO;
    else if (a == 1)
	return LONG2NUM(b);
    else if (b == 1)
	return LONG2NUM(a);

    c = a * b;
    r = LONG2NUM(c);
    if (NUM2LONG(r) != c || (c / a) != b)
	r = rb_big_mul(rb_int2big(a), rb_int2big(b));
    return r;
}

jobject rho_cast_helper<jobject, VALUE>::operator()(JNIEnv *env, VALUE value)
{
    RAWTRACE("rho_cast<jobject, VALUE>");

    if (NIL_P(value))
        return 0;

    if (!initConvertor(env))
        return 0;

    switch(TYPE(value))
    {
    case RUBY_T_SYMBOL:
        value = rb_funcall(value, rb_intern("to_s"), 0);
    case RUBY_T_STRING:
        RAWTRACE("Convert to String object");
        return env->NewStringUTF(RSTRING_PTR(value));
    case RUBY_T_ARRAY:
        RAWTRACE("Convert to Collection object");
        return convertRubyArrayToJavaCollection(value);
    case RUBY_T_HASH:
        RAWTRACE("Convert to Map object");
        return convertRubyHashToJavaMap(value);
    case RUBY_T_TRUE:
        RAWTRACE("Convert to TRUE Boolean obeject");
        return RhoJniConvertor::getBooleanObject(true);
    case RUBY_T_FALSE:
        RAWTRACE("Convert to FALSE Boolean object");
        return RhoJniConvertor::getBooleanObject(false);
    case RUBY_T_FIXNUM:
    case RUBY_T_BIGNUM:
        RAWTRACE("Convert to Integer object");
        return RhoJniConvertor::getIntegerObject(NUM2LONG(value));
    case RUBY_T_FLOAT:
    case RUBY_T_RATIONAL:
        RAWTRACE("Convert to Double object");
        return RhoJniConvertor::getDoubleObject(NUM2DBL(value));
    }

    RAWLOG_ERROR1("rho_cast<jobject, VALUE>: wrong type of VALUE: %d", TYPE(value));
    return 0;
}

static VALUE
bdb_sary_fetch(int argc, VALUE *argv, VALUE obj)
{
    VALUE pos, ifnone;
    bdb_DB *dbst;
    long idx;

    GetDB(obj, dbst);
    rb_scan_args(argc, argv, "11", &pos, &ifnone);
    idx = NUM2LONG(pos);

    if (idx < 0) {
	idx +=  dbst->len;
    }
    if (idx < 0 || dbst->len <= idx) {
	return ifnone;
    }
    pos = INT2NUM(idx);
    return bdb_get(1, &pos, obj);
}

/*
 * Set the source of the amf reader to a StringIO object, creating a new one to
 * wrap the source if it's only a string
 */
void des_set_src(AMF_DESERIALIZER *des, VALUE src) {
    VALUE klass = CLASS_OF(src);
    if(klass == cStringIO) {
        VALUE str = rb_funcall(src, rb_intern("string"), 0);
        des->src = src;
        des->stream = RSTRING_PTR(str);
        des->pos = NUM2LONG(rb_funcall(src, rb_intern("pos"), 0));
        des->size = RSTRING_LEN(str);
    } else if(klass == rb_cString) {
        VALUE args[1] = {src};
        des->src = rb_class_new_instance(1, args, cStringIO);
        des->stream = RSTRING_PTR(src);
        des->pos = 0;
        des->size = RSTRING_LEN(src);
    } else {
        rb_raise(rb_eArgError, "Invalid source type to deserialize from");
    }

    if(des->pos >= des->size) rb_raise(rb_eRangeError, "already at the end of the source");
}

/* @overload index(pattern, offset = 0)
 *
 *   Returns the minimal index of the receiver where PATTERN matches, equal to or
 *   greater than _i_, where _i_ = OFFSET if OFFSET ≥ 0, _i_ = {#length} -
 *   abs(OFFSET) otherwise, or nil if there is no match.
 *
 *   If PATTERN is a Regexp, the Regexp special variables `$&`, `$'`,
 *   <code>$\`</code>, `$1`, `$2`, …, `$`_n_ are updated accordingly.
 *
 *   If PATTERN responds to #to_str, the matching is performed by byte
 *   comparison.
 *
 *   @param [Regexp, #to_str] pattern
 *   @param [#to_int] offset
 *   @return [Integer, nil]
 *   @see #rindex */
VALUE
rb_u_string_index_m(int argc, VALUE *argv, VALUE self)
{
        VALUE sub, rboffset;
        long offset = 0;
        if (rb_scan_args(argc, argv, "11", &sub, &rboffset) == 2)
                offset = NUM2LONG(rboffset);

        const struct rb_u_string *string = RVAL2USTRING(self);

        const char *begin = rb_u_string_begin_from_offset(string, offset);
        if (begin == NULL) {
                if (TYPE(sub) == T_REGEXP)
                        rb_backref_set(Qnil);

                return Qnil;
        }

        switch (TYPE(sub)) {
        case T_REGEXP:
                offset = rb_u_string_index_regexp(self, begin, sub, false);
                break;
        default: {
                VALUE tmp = rb_check_string_type(sub);
                if (NIL_P(tmp))
                        rb_u_raise(rb_eTypeError, "type mismatch: %s given",
                                   rb_obj_classname(sub));

                sub = tmp;
        }
                /* fall through */
        case T_STRING:
                offset = rb_u_string_index(self, sub, offset);
                break;
        }

        if (offset < 0)
                return Qnil;

        return LONG2NUM(offset);
}