Example #1
0
static VALUE rb_tinytds_result_do(VALUE self) {
  GET_RESULT_WRAPPER(self);
  if (rwrap->client) {
    rb_tinytds_result_exec_helper(rwrap->client);
    return LONG2NUM((long)dbcount(rwrap->client));
  } else {
    return Qnil;
  }
}
Example #2
0
inline static void
call_error(const char *msg, ParseInfo pi, const char* file, int line) {
    char	buf[128];
    const char	*s = pi->s;
    int		jline = 1;
    int		col = 1;

    for (; pi->str < s && '\n' != *s; s--) {
	col++;
    }
    for (; pi->str < s; s--) {
	if ('\n' == *s) {
	    jline++;
	}
    }
    sprintf(buf, "%s at line %d, column %d [%s:%d]", msg, jline, col, file, line);
    rb_funcall(pi->handler, oj_error_id, 3, rb_str_new2(buf), LONG2NUM(jline), LONG2NUM(col));
}
Example #3
0
static VALUE
lazy_take_size(VALUE generator, VALUE args, VALUE lazy)
{
    VALUE receiver = lazy_size(lazy);
    long len = NUM2LONG(RARRAY_AREF(rb_ivar_get(lazy, id_arguments), 0));
    if (NIL_P(receiver) || (FIXNUM_P(receiver) && FIX2LONG(receiver) < len))
	return receiver;
    return LONG2NUM(len);
}
Example #4
0
/*
 *  call-seq:
 *     ctx.session_cache_size -> integer
 *
 */
static VALUE
ossl_sslctx_get_session_cache_size(VALUE self)
{
    SSL_CTX *ctx;

    Data_Get_Struct(self, SSL_CTX, ctx);

    return LONG2NUM(SSL_CTX_sess_get_cache_size(ctx));
}
Example #5
0
static VALUE
memory_size(VALUE self) 
{
    AbstractMemory* ptr;

    Data_Get_Struct(self, AbstractMemory, ptr);

    return LONG2NUM(ptr->size);
}
/*
 * call-seq: from_string(s)
 * @param [String] s string
 * @return [MemoryPointer]
 * Create a {MemoryPointer} with +s+ inside.
 */
static VALUE
memptr_s_from_string(VALUE klass, VALUE to_str)
{
    VALUE s = StringValue(to_str);
    VALUE args[] = { INT2FIX(1), LONG2NUM(RSTRING_LEN(s) + 1), Qfalse };
    VALUE obj = rb_class_new_instance(3, args, klass);
    rb_funcall(obj, rb_intern("put_string"), 2, INT2FIX(0), s);

    return obj;
}
Example #7
0
/**
 * call-seq:
 *    hdfs.capacity -> retval
 *
 * Returns the capacity of this HDFS file system in bytes, raising a
 * DFSException if this was unsuccessful.
 */
VALUE HDFS_File_System_capacity(VALUE self) {
  FSData* data = get_FSData(self);
  long capacity = hdfsGetCapacity(data->fs);
  if (capacity < 0) {
    rb_raise(e_dfs_exception, "Error while retrieving capacity: %s",
        get_error(errno));
    return Qnil;
  }
  return LONG2NUM(capacity);
}
Example #8
0
/**
 * call-seq:
 *    hdfs.default_block_size -> retval
 *
 * Returns the default block size of this HDFS file system in bytes, raising a
 * DFSException if this was unsuccessful.
 */
VALUE HDFS_File_System_default_block_size(VALUE self) {
  FSData* data = get_FSData(self);
  long block_size = hdfsGetDefaultBlockSize(data->fs);
  if (block_size == -1) {
    rb_raise(e_dfs_exception, "Error while retrieving default block size: %s",
        get_error(errno));
    return Qnil;
  }
  return LONG2NUM(block_size);
}
Example #9
0
VALUE
supplement_rindex_val( VALUE ary, VALUE val)
{
    long i;

    for (i = RARRAY_LEN( ary); i;)
        if (rb_equal( RARRAY_PTR( ary)[ --i], val))
            return LONG2NUM( i);
    return Qnil;
}
Example #10
0
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;
}
Example #11
0
static VALUE rb_mysql_result_count(VALUE self) {
  mysql2_result_wrapper *wrapper;

  GetMysql2Result(self, wrapper);
  if(wrapper->resultFreed) {
    return LONG2NUM(RARRAY_LEN(wrapper->rows));
  } else {
    return INT2FIX(mysql_num_rows(wrapper->result));
  }
}
Example #12
0
/**
 * call-seq:
 *    hdfs.used -> retval
 *
 * Returns the bytes currently in use by this filesystem, raising a
 * DFSException if unsuccessful.
 */
VALUE HDFS_File_System_used(VALUE self) {
  FSData* data = get_FSData(self);
  tOffset used = hdfsGetUsed(data->fs);
  if (used == -1) {
    rb_raise(e_dfs_exception, "Error while retrieving used capacity: %s",
        get_error(errno));
    return Qnil;
  }
  return LONG2NUM(used);
}
Example #13
0
VALUE
supplement_index_blk( VALUE ary)
{
    long i, j;

    for (i = 0, j = RARRAY_LEN( ary); j > 0; i++, j--) {
        if (RTEST( rb_yield( RARRAY_PTR( ary)[ i])))
            return LONG2NUM( i);
    }
    return Qnil;
}
Example #14
0
File: class.c Project: MSch/MacRuby
void
rb_singleton_class_attached(VALUE klass, VALUE obj)
{
    if (RCLASS_SINGLETON(klass)) {
	// Weak ref.
	VALUE wobj = LONG2NUM((long)obj);
	rb_ivar_set(klass, idAttached, wobj);
	// FIXME commented for now as it breaks some RubySpecs.
	//rb_singleton_class_promote_for_gc(klass);
    }
}
Example #15
0
static VALUE 
ossl_x509crl_get_version(VALUE self)
{
    X509_CRL *crl;
    long ver;

    GetX509CRL(self, crl);
    ver = X509_CRL_get_version(crl);

    return LONG2NUM(ver);
}
Example #16
0
static VALUE
ptrace_getsiginfo(VALUE self)
{
    pid_t pid = get_pid(self);
    siginfo_t si;
    void *data_ptr = (void *)&si;
    long ret;
    VALUE v;

    CALL_PTRACE(ret, PT_GETSIGINFO, pid, 0, data_ptr);

    v = rb_hash_new();

#define SI_SET(name, val) rb_hash_aset(v, ID2SYM(rb_intern("si_" #name)), val)
    SI_SET(sig, si_signo_symbol(si.si_signo));
    SI_SET(signo, INT2NUM(si.si_signo));
    SI_SET(errno, INT2NUM(si.si_errno));
    SI_SET(code, si_code_symbol(si.si_signo, si.si_code));
    SI_SET(codeno, INT2NUM(si.si_code));

    switch (si.si_signo) {
      case SIGKILL:
	SI_SET(pid, ULONG2NUM(si.si_pid));
	SI_SET(uid, ULONG2NUM(si.si_uid));
	break;

      case SIGILL:
      case SIGFPE:
      case SIGSEGV:
      case SIGBUS:
	SI_SET(addr, ULONG2NUM((unsigned long)si.si_addr));
	break;

      case SIGCHLD:
	SI_SET(pid, ULONG2NUM(si.si_pid));
	SI_SET(uid, ULONG2NUM(si.si_uid));
	SI_SET(status, INT2NUM(si.si_status));
	SI_SET(utime, ULONG2NUM(si.si_utime));
	SI_SET(stime, ULONG2NUM(si.si_stime));
	break;

      case SIGPOLL:
	SI_SET(band, LONG2NUM(si.si_band));
	SI_SET(fd, INT2NUM(si.si_fd));
	break;

      default: /* POSIX.1b signal? */
	;
    }

#undef SI_SET

    return v;
}
Example #17
0
/* subColorInstantiate {{{ */
VALUE
subColorInstantiate(unsigned long pixel)
{
  VALUE klass = Qnil, color = Qnil;

  /* Create new instance */
  klass  = rb_const_get(mod, rb_intern("Color"));
  color = rb_funcall(klass, rb_intern("new"), 1, LONG2NUM(pixel));

  return color;
} /* }}} */
Example #18
0
/**
 * call-seq:
 *    hdfs.default_block_size_at_path(path) -> default_block_size
 *
 * Returns the default block size at the supplied HDFS path, raising a
 * DFSException if this was unsuccessful.
 */
VALUE HDFS_File_System_default_block_size_at_path(VALUE self, VALUE path) {
  FSData* data = get_FSData(self);
  long block_size = hdfsGetDefaultBlockSizeAtPath(data->fs,
      StringValuePtr(path));
  if (block_size == -1) {
    rb_raise(e_dfs_exception,
        "Error while retrieving default block size at path %s: %s",
        StringValuePtr(path), get_error(errno));
    return Qnil;
  }
  return LONG2NUM(block_size);
}
Example #19
0
VALUE
supplement_rindex_blk( VALUE ary)
{
    long i;

    for (i = RARRAY_LEN( ary); i;) {
        --i;
        if (RTEST( rb_yield( RARRAY_PTR( ary)[ i])))
            return LONG2NUM( i);
    }
    return Qnil;
}
Example #20
0
File: cparse.c Project: vasco/racc
static void
shift(struct cparse_params *v, long act, VALUE tok, VALUE val)
{
    PUSH(v->vstack, val);
    if (v->debug) {
        PUSH(v->tstack, tok);
        rb_funcall(v->parser, id_d_shift,
                   3, tok, v->tstack, v->vstack);
    }
    v->curstate = act;
    PUSH(v->state, LONG2NUM(v->curstate));
}
Example #21
0
size_t _msgpack_buffer_skip_from_io(msgpack_buffer_t* b, size_t length)
{
    if(b->io_buffer == Qnil) {
        b->io_buffer = rb_str_buf_new(0);
    }

    VALUE ret = rb_funcall(b->io, b->io_partial_read_method, 2, LONG2NUM(length), b->io_buffer);
    if(ret == Qnil) {
        return 0;
    }
    return RSTRING_LEN(b->io_buffer);
}
Example #22
0
VALUE
rb_ary_each_pair(VALUE array)
{
    long i;
    volatile VALUE ary = array;

    RETURN_SIZED_ENUMERATOR(ary, 0, 0, rb_ary_length);
    for (i=0; i<RARRAY_LEN(ary); i++) {
      rb_yield(LONG2NUM(i), RARRAY_PTR(ary)[i]);
    }
    return ary;
}
Example #23
0
VALUE oily_png_canvas_resample_nearest_neighbor_bang(VALUE self, VALUE v_new_width, VALUE v_new_height) {
  long new_width = NUM2LONG(v_new_width);
  long new_height = NUM2LONG(v_new_height);

  long self_width = NUM2LONG(rb_funcall(self, rb_intern("width"), 0));
  long self_height = NUM2LONG(rb_funcall(self, rb_intern("height"), 0));

  VALUE pixels = rb_ary_new2(new_width*new_height);
  VALUE source = rb_iv_get(self, "@pixels");

  long *steps_x = ALLOC_N(long, new_width);
  long *steps_y = ALLOC_N(long, new_height);

  oily_png_generate_steps_residues(self_width, new_width, steps_x, NULL);
  oily_png_generate_steps_residues(self_height, new_height, steps_y, NULL);

  long index = 0;
  long x, y;
  long src_index;
  for (y=0; y < new_height; y++) {
    for (x = 0; x < new_width; x++) {
      src_index = steps_y[y] * self_width + steps_x[x];
      VALUE pixel = rb_ary_entry(source, src_index);
      rb_ary_store(pixels, index, pixel);
      index++;
    }
  }

  xfree(steps_x);
  steps_x = NULL;

  xfree(steps_y);
  steps_y = NULL;

  rb_iv_set(self, "@pixels", pixels);
  rb_iv_set(self, "@width", LONG2NUM(new_width));
  rb_iv_set(self, "@height", LONG2NUM(new_height));

  return self;
}
Example #24
0
File: subtle.c Project: guns/subtle
VALUE
subSubtleSingColors(VALUE self)
{
  int i;
  unsigned long ncolors = 0, *colors = NULL;
  VALUE meth = Qnil, klass = Qnil, hash = Qnil;
  const char *names[] = {
    "title_fg",            "title_bg",             "title_bo_top",
    "title_bo_right",      "title_bo_bottom",      "title_bo_left",
    "view_fg",             "view_bg",              "view_bo_top",
    "view_bo_right",       "view_bo_bottom",       "view_bo_left",
    "focus_fg",            "focus_bg",             "focus_bo_top",
    "focus_bo_right",      "focus_bo_bottom",      "focus_bo_left",
    "urgent_fg",           "urgent_bg",            "urgent_bo_top",
    "urgent_bo_right",     "urgent_bo_bottom",     "urgent_bo_left",
    "occupied_fg",         "occupied_bg",          "occupied_bo_top",
    "occupied_bo_right",   "occupied_bo_bottom",   "occupied_bo_left",
    "unoccupied_fg",       "unoccupied_bg",        "unoccupied_bo_top",
    "unoccupied_bo_right", "unoccupied_bo_bottom", "unoccupied_bo_left",
    "sublets_fg",         "sublets_bg",            "sublets_bo_top",
    "sublets_bo_right",   "sublets_bo_bottom",     "sublets_bo_left",
    "separator_fg",       "separator_bg",          "separator_bo_top",
    "separator_bo_right", "separator_bo_bottom",   "separator_bo_left",
    "client_active",      "client_inactive",
    "panel_top",          "panel_bottom",
    "stipple",            "background"
  };

  subSubtlextConnect(NULL); ///< Implicit open connection

  /* Fetch data */
  meth  = rb_intern("new");
  klass = rb_const_get(mod, rb_intern("Color"));
  hash  = rb_hash_new();

  /* Check result */
  if((colors = (unsigned long *)subSharedPropertyGet(display,
      DefaultRootWindow(display), XA_CARDINAL,
      XInternAtom(display, "SUBTLE_COLORS", False), &ncolors)))
    {
      for(i = 0; i < ncolors && i < LENGTH(names); i++)
        {
          VALUE c = rb_funcall(klass, meth, 1, LONG2NUM(colors[i]));

          rb_hash_aset(hash, CHAR2SYM(names[i]), c);
        }

      free(colors);
    }

  return hash;
} /* }}} */
Example #25
0
static VALUE
make_struct(VALUE name, VALUE members, VALUE klass)
{
    VALUE nstr;
    ID id;
    long i, count;

    OBJ_FREEZE(members);
    if (NIL_P(name)) {
	nstr = rb_class_new(klass);
#if !WITH_OBJC
	rb_make_metaclass(nstr, RBASIC(klass)->klass);
#endif
	rb_class_inherited(klass, nstr);
    }
    else {
	/* old style: should we warn? */
	name = rb_str_to_str(name);
	id = rb_to_id(name);
	if (!rb_is_const_id(id)) {
	    rb_name_error(id, "identifier %s needs to be constant",
		    StringValuePtr(name));
	}
	if (rb_const_defined_at(klass, id)) {
	    rb_warn("redefining constant Struct::%s", StringValuePtr(name));
	    rb_mod_remove_const(klass, ID2SYM(id));
	}
	nstr = rb_define_class_under(klass, rb_id2name(id), klass);
    }
    rb_iv_set(nstr, "__size__", LONG2NUM(RARRAY_LEN(members)));
    rb_iv_set(nstr, "__members__", members);

    rb_objc_define_method(*(VALUE *)nstr, "alloc", struct_alloc, 0);
    rb_objc_define_method(*(VALUE *)nstr, "new", rb_class_new_instance_imp, -1);
    rb_objc_define_method(*(VALUE *)nstr, "[]", rb_class_new_instance_imp, -1);
    rb_objc_define_method(*(VALUE *)nstr, "members", rb_struct_s_members_m, 0);
    for (i = 0, count = RARRAY_LEN(members); i < count; i++) {
	ID id = SYM2ID(RARRAY_AT(members, i));
	if (rb_is_local_id(id) || rb_is_const_id(id)) {
	    if (i < N_REF_FUNC) {
		rb_objc_define_method(nstr, rb_id2name(id), ref_func[i], 0);
	    }
	    else {
		rb_objc_define_method(nstr, rb_id2name(id), rb_struct_ref, 0);
	    }
	    rb_objc_define_method(nstr, rb_id2name(rb_id_attrset(id)),
		    rb_struct_set, 1);
	}
    }

    return nstr;
}
Example #26
0
VALUE wrap_geo_known_position(int argc, VALUE *argv, VALUE self) {
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); goto fail;
  }
  result = (int)geo_known_position();
  vresult = LONG2NUM((int)(result));
  return vresult;
fail:
  return Qnil;
}
Example #27
0
VALUE rb_rt_read_string(VALUE self, VALUE rb_buf) {
    rt_ctx *ctx;

    Check_Type(rb_buf, T_STRING);

    Data_Get_Struct(self, rt_ctx, ctx);
    if(ctx->ended)
        rb_raise(rb_eIOError, "data cannot be added after finalizing");

    rt_add(ctx, RSTRING_PTR(rb_buf), RSTRING_LEN(rb_buf));

    return LONG2NUM(RSTRING_LEN(rb_buf));
}
Example #28
0
VALUE
supplement_index_ref( VALUE ary, VALUE ref)
{
    long i, j;

    if (!id_eqq)
        id_eqq = rb_intern( "===");
    for (i = 0, j = RARRAY_LEN( ary); j > 0; i++, j--) {
        if (RTEST( rb_funcall( ref, id_eqq, 1, RARRAY_PTR( ary)[ i])))
            return LONG2NUM( i);
    }
    return Qnil;
}
Example #29
0
static VALUE
lazy_drop_size(VALUE generator, VALUE args, VALUE lazy)
{
    long len = NUM2LONG(RARRAY_AREF(rb_ivar_get(lazy, id_arguments), 0));
    VALUE receiver = lazy_size(lazy);
    if (NIL_P(receiver))
	return receiver;
    if (FIXNUM_P(receiver)) {
	len = FIX2LONG(receiver) - len;
	return LONG2FIX(len < 0 ? 0 : len);
    }
    return rb_funcall(receiver, '-', 1, LONG2NUM(len));
}
Example #30
0
VALUE method_cpu(VALUE self) {
  VALUE cpus = rb_ary_new();
  int cpu_count = system_int("hw.ncpu");
  size_t len = sizeof(cpu_time_t) * cpu_count;
  cpu_time_t * cp_times = ALLOC_N(cpu_time_t, cpu_count);
  int i;
  
  if (sysctlbyname("kern.cp_times", cp_times, &len, NULL, 0) == 0) {
    for (i = 0; i < cpu_count; i++) {
      VALUE cpu = rb_hash_new();
      cpu_time_t cp_time = cp_times[i];
      rb_hash_aset(cpu, SYM_USER, LONG2NUM(cp_time.user));
      rb_hash_aset(cpu, SYM_SYSTEM, LONG2NUM(cp_time.system + cp_time.intr));
      rb_hash_aset(cpu, SYM_NICE, LONG2NUM(cp_time.nice));
      rb_hash_aset(cpu, SYM_IDLE, LONG2NUM(cp_time.idle));
      rb_ary_push(cpus, cpu);
    }
  }
  free(cp_times);
  
  return cpus;
}