Esempio n. 1
0
static int
frame_lines_i(st_data_t key, st_data_t val, st_data_t arg)
{
    VALUE lines = (VALUE)arg;

    size_t weight = (size_t)val;
    size_t total = weight & (~(size_t)0 << (8*SIZEOF_SIZE_T/2));
    weight -= total;
    total = total >> (8*SIZEOF_SIZE_T/2);
    rb_hash_aset(lines, INT2FIX(key), rb_ary_new3(2, ULONG2NUM(total), ULONG2NUM(weight)));
    return ST_CONTINUE;
}
Esempio n. 2
0
static VALUE
qos_parse(VALUE self)
{
    gdouble proportion;
    GstClockTimeDiff diff;
    GstClockTime timestamp;

    gst_event_parse_qos(RGST_EVENT(self), &proportion, &diff, &timestamp);

    return rb_ary_new3(3, DBL2NUM(proportion), LL2NUM(diff),
                       ULL2NUM(timestamp));
}
Esempio n. 3
0
void
rb_trap_exit(void)
{
#ifndef MACOS_UNUSE_SIGNAL
    if (trap_list[0].cmd) {
	VALUE trap_exit = trap_list[0].cmd;

	trap_list[0].cmd = 0;
	rb_eval_cmd(trap_exit, rb_ary_new3(1, INT2FIX(0)), trap_list[0].safe);
    }
#endif
}
static VALUE
rbclt_behaviour_rotate_get_bounds (VALUE self)
{
  ClutterBehaviourRotate *brotate = CLUTTER_BEHAVIOUR_ROTATE (RVAL2GOBJ (self));
  gdouble angle_start, angle_end;

  clutter_behaviour_rotate_get_bounds (brotate,
                                       &angle_start,
                                       &angle_end);

  return rb_ary_new3 (2, rb_float_new (angle_start), rb_float_new (angle_end));
}
Esempio n. 5
0
static VALUE
lazy_drop(VALUE obj, VALUE n)
{
    long len = NUM2LONG(n);

    if (len < 0) {
	rb_raise(rb_eArgError, "attempt to drop negative size");
    }
    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
					 lazy_drop_func, n),
			   rb_ary_new3(1, n), lazy_drop_size);
}
Esempio n. 6
0
//
// same as above, but reversed:
// >> require 'fnmatch'
// >> Globber.match_any_string('*hn', ['john', 'bill', 'bob'])
// => true
// >> Globber.match_any_string('*hn', ['jake', 'jim', 'sam'])
// => false
//
static VALUE fnm_match_any_string(VALUE self, VALUE args)
{
  // variable holders
  VALUE strings, pattern, flags, nargs;

  long len = RARRAY_LEN(args);

  // extract arguments
  if ( len > 3 || len < 2 ) {
    rb_raise(rb_eArgError, "Accepts either 2 or 3 arguments"); 
  } else if ( len == 2 ) {
    pattern = rb_ary_entry(args, 0);
    strings = rb_ary_entry(args, 1);
    flags   = INT2NUM(DEFAULT_FLAG);
  } else {
    pattern = rb_ary_entry(args, 0);
    strings = rb_ary_entry(args, 1);
    flags   = rb_ary_entry(args, 2);
  }


  // sanity
  check_type(pattern, T_STRING, "input pattern");
  check_type(flags  , T_FIXNUM, "module flags");
  check_type(strings, T_ARRAY , "string list");

  int s_len = RARRAY_LEN( strings );

  // these are the loop counter and the match tracker
  int i;
	VALUE match = Qfalse,	string;

  // get a VALUE ptr to the first element
  VALUE * s_arr = RARRAY_PTR( strings );

  // go through each element and try to match
  for ( i = 0 ; i < s_len ; ++i )
  {
		// the current string
    string = s_arr[i];
    
    // perform the actual matching
		match = fnm_match( self, rb_ary_new3(3, string, pattern, flags) );

    // fnmatch returns 0 if glob match was found
    if ( match == Qtrue ) {
      return Qtrue;
    }
	}

  return Qfalse;
}
Esempio n. 7
0
File: signal.c Progetto: genki/ruby
static void
signal_exec(VALUE cmd, int sig)
{
    rb_proc_t *proc;
    VALUE signum = INT2FIX(sig);

    if (TYPE(cmd) == T_STRING) {
	rb_eval_cmd(cmd, rb_ary_new3(1, signum), trap_list[sig].safe);
	return;
    }
    GetProcPtr(cmd, proc);
    vm_invoke_proc(GET_THREAD(), proc, proc->block.self, 1, &signum, 0);
}
Esempio n. 8
0
VALUE oci8_server_release(VALUE self)
{
    oci8_handle_t *h;
    OraText buf[1024];
    ub4 version = 0;
    sword rv;

    Get_Handle(self, h); /* 0 */
    rv = OCIServerRelease(h->hp, h->errhp, buf, sizeof(buf), h->type, &version);
    if (rv != OCI_SUCCESS)
        oci8_raise(h->errhp, rv, NULL);
    return rb_ary_new3(2, INT2FIX(version), rb_str_new2(buf));
}
Esempio n. 9
0
static VALUE
rg_size(VALUE self)
{
    int rows, columns;
    gboolean result;
    GError *error = NULL;

    result = vte_pty_get_size(_SELF(self), &rows, &columns, &error);
    if (error)
        RAISE_GERROR(error);

    return rb_ary_new3(2, INT2NUM(rows), INT2NUM(columns));
}
Esempio n. 10
0
static VALUE
cr_surface_get_fallback_resolution (VALUE self)
{
  double x_pixels_per_inch, y_pixels_per_inch;

  cairo_surface_get_fallback_resolution (_SELF,
                                         &x_pixels_per_inch,
                                         &y_pixels_per_inch);
  cr_surface_check_status (_SELF);
  return rb_ary_new3 (2,
                      rb_float_new (x_pixels_per_inch),
                      rb_float_new (y_pixels_per_inch));
}
Esempio n. 11
0
File: wait.c Progetto: 7kaji/try
#include "kgio.h"
#include "my_fileno.h"
static ID id_wait_rd, id_wait_wr;

#if defined(HAVE_RB_TIME_INTERVAL) && defined(HAVE_RB_WAIT_FOR_SINGLE_FD)
static int kgio_timedwait(VALUE self, VALUE timeout, int write_p)
{
	struct timeval tv = rb_time_interval(timeout);
	int events = write_p ? RB_WAITFD_OUT : RB_WAITFD_IN;

	return rb_wait_for_single_fd(my_fileno(self), events, &tv);
}
#else  /* ! (HAVE_RB_TIME_INTERVAL && HAVE_RB_WAIT_FOR_SINGLE_FD) */
static int kgio_timedwait(VALUE self, VALUE timeout, int write_p)
{
	VALUE argv[4];
	VALUE set = rb_ary_new3(1, self);

	argv[0] = write_p ? Qnil : set;
	argv[1] = write_p ? set : Qnil;
	argv[2] = Qnil;
	argv[3] = timeout;

	set = rb_funcall2(rb_cIO, rb_intern("select"), 4, argv);
	return NIL_P(set) ? 0 : 1;
}
Esempio n. 12
0
static VALUE
rg_get_dest_row_at_pos(VALUE self, VALUE drag_x, VALUE drag_y)
{
    GtkTreePath* path;
    GtkTreeViewDropPosition pos;
    gboolean ret;

    ret = gtk_tree_view_get_dest_row_at_pos(_SELF(self), 
                                            NUM2INT(drag_x), NUM2INT(drag_y),
                                            &path, &pos);
    return ret ? rb_ary_new3(2, path ? GTKTREEPATH2RVAL(path) : Qnil, 
                             GENUM2RVAL(pos, GTK_TYPE_TREE_VIEW_DROP_POSITION)) : Qnil;
}
Esempio n. 13
0
/*
 * call-seq:
 *   to_ary -> [hu1, hu2, ... ,hu7]
 *
 * Return values by Array.
 */
VALUE
rb_to_ary(VALUE self)
{
  CvHuMoments *hu_moments = CVHUMOMENTS(self);
  return rb_ary_new3(7,
		     rb_float_new(hu_moments->hu1),
		     rb_float_new(hu_moments->hu2),
		     rb_float_new(hu_moments->hu3),
		     rb_float_new(hu_moments->hu4),
		     rb_float_new(hu_moments->hu5),
		     rb_float_new(hu_moments->hu6),
		     rb_float_new(hu_moments->hu7));
}
Esempio n. 14
0
static VALUE
segment_parse(VALUE self)
{
    GstFormat format;
    gdouble rate;
    gint64 start_value, stop_value;

    gst_query_parse_segment(RVAL2GST_QUERY(self), &rate, &format,
                            &start_value, &stop_value);

    return rb_ary_new3(4, rb_dbl2big(rate), GST_FORMAT2RVAL(format),
                        LL2NUM(start_value), LL2NUM(stop_value));
}
Esempio n. 15
0
static VALUE
latency_parse(VALUE self)
{
    GstClockTime min_latency;
    GstClockTime max_latency;
    gboolean live;

    gst_query_parse_latency(RVAL2GST_QUERY(self), &live, &min_latency,
                            &max_latency);

    return rb_ary_new3(3, CBOOL2RVAL(live), ULL2NUM(min_latency),
                       ULL2NUM(max_latency));
}
Esempio n. 16
0
static VALUE
seeking_parse(VALUE self)
{
    GstFormat format;
    gboolean seekable;
    gint64 segment_start, segment_end;

    gst_query_parse_seeking(RVAL2GST_QUERY(self), &format, &seekable,
                            &segment_start, &segment_end);

    return rb_ary_new3(4, GST_FORMAT2RVAL(format), CBOOL2RVAL(seekable),
                       LL2NUM(segment_start), LL2NUM(segment_end));
}
Esempio n. 17
0
static VALUE rbhtp_r_string_table( table_t* table )
{
	if ( table == NULL ) return Qnil;
	
	bstr k, v;
	VALUE r = rb_ary_new();
	table_iterator_reset( table );
	while ( ( k = table_iterator_next( table, &v ) ) != NULL ) {
		rb_ary_push( r, rb_ary_new3( 2,
			BSTR_TO_RSTR( k ), BSTR_TO_RSTR( v ) ) );
	}
	return r;
}
Esempio n. 18
0
void
Init_rsvg2(void)
{
    VALUE RG_TARGET_NAMESPACE = rb_define_module("RSVG");

#if LIBRSVG_CHECK_VERSION(2, 9, 0)
    rsvg_init();
    atexit(rsvg_term);
#endif

    G_DEF_ERROR(RSVG_ERROR, "Error", RG_TARGET_NAMESPACE, rb_eRuntimeError, RSVG_TYPE_ERROR);

    rb_define_const(RG_TARGET_NAMESPACE, "BINDING_VERSION",
                    rb_ary_new3(3,
                                INT2FIX(RBRSVG_MAJOR_VERSION),
                                INT2FIX(RBRSVG_MINOR_VERSION),
                                INT2FIX(RBRSVG_MICRO_VERSION)));

    rb_define_const(RG_TARGET_NAMESPACE, "BUILD_VERSION",
                    rb_ary_new3(3,
                                INT2FIX(LIBRSVG_MAJOR_VERSION),
                                INT2FIX(LIBRSVG_MINOR_VERSION),
                                INT2FIX(LIBRSVG_MICRO_VERSION)));

    RG_DEF_SMETHOD(set_default_dpi, 1);
    RG_DEF_SMETHOD(set_default_dpi_x_y, 2);

    /* Convenience API */
    RG_DEF_SMETHOD(pixbuf_from_file, 1);
    RG_DEF_SMETHOD(pixbuf_from_file_at_zoom, 3);
    RG_DEF_SMETHOD(pixbuf_from_file_at_size, 3);
    RG_DEF_SMETHOD(pixbuf_from_file_at_max_size, 3);
    RG_DEF_SMETHOD(pixbuf_from_file_at_zoom_with_max, 5);

    RG_DEF_SMETHOD_P(cairo_available, 0);

    Init_rsvg_handle(RG_TARGET_NAMESPACE);
    Init_rsvg_dimensiondata(RG_TARGET_NAMESPACE);
}
Esempio n. 19
0
/*
 * Returns the #dirname and the #basename in an Array.
 *
 * See File.split.
 */
static VALUE
path_split(VALUE self)
{
    VALUE str = get_strpath(self);
    VALUE ary, dirname, basename;
    ary = rb_funcall(rb_cFile, rb_intern("split"), 1, str);
    ary = rb_check_array_type(ary);
    dirname = rb_ary_entry(ary, 0);
    basename = rb_ary_entry(ary, 1);
    dirname = rb_class_new_instance(1, &dirname, rb_obj_class(self));
    basename = rb_class_new_instance(1, &basename, rb_obj_class(self));
    return rb_ary_new3(2, dirname, basename);
}
Esempio n. 20
0
/* Evaluate block with each element and its index. */
static VALUE r_mpfi_vector_each_element_with_index (VALUE self) {
  MPFIMatrix *ptr_self;
  VALUE ret;
  int i;
  RETURN_ENUMERATOR(self, 0, NULL);
  r_mpfi_get_matrix_struct(ptr_self, self);
  ret = Qnil;
  for (i = 0; i < ptr_self->size; i++) {
    volatile VALUE el = r_mpfi_make_new_fi_obj(ptr_self->data + i);
    ret = rb_yield(rb_ary_new3(2, el, INT2NUM(i)));
  }
  return ret;
}
Esempio n. 21
0
static VALUE
device_keys(VALUE self)
{
    gint i;
    VALUE ary = rb_ary_new();
    GdkDeviceKey* keys = _SELF(self)->keys;

    for (i = 0; i < _SELF(self)->num_keys; i++){
        rb_ary_push(ary, rb_ary_new3(2, UINT2NUM(keys[i].keyval),
                                     GFLAGS2RVAL(keys[i].modifiers, GDK_TYPE_MODIFIER_TYPE)));
    }
    return ary;
}
Esempio n. 22
0
static VALUE
device_axes(VALUE self)
{
    gint i;
    VALUE ary = rb_ary_new();
    GdkDeviceAxis* axes = _SELF(self)->axes;

    for (i = 0; i < _SELF(self)->num_axes; i++){
        rb_ary_push(ary, rb_ary_new3(3, GENUM2RVAL(axes[i].use, GDK_TYPE_AXIS_USE), 
                                     rb_float_new(axes[i].min), rb_float_new(axes[i].max)));
    }
    return ary;
}
Esempio n. 23
0
static enum MqErrorE
FactoryCreate(
  struct MqS * const tmpl,
  enum MqFactoryE create,
  struct MqFactoryS *item,
  struct MqS  ** mqctxP
)
{
  enum MqErrorE mqret = MQ_OK;
  struct MqS * mqctx = NULL;
  VALUE args;
  VALUE vtmpl;
  VALUE self;

/*
  //struct MqS * const mqctx = tmpl;
  if (create == MQ_FACTORY_NEW_FORK) {
    //rb_thread_atfork();
  }
  if (create == MQ_FACTORY_NEW_THREAD) {
    //RUBY_INIT_STACK;
  }
*/

  // setup templ
  vtmpl = MqS2VAL(tmpl);

  // setup arguments
  args = rb_ary_new3(2, vtmpl, PTR2VAL(item->Create.data));

  // call "new"
  self = rb_rescue2(sFactoryCall, args, sFactoryError, vtmpl, rb_eException, (VALUE)0);

  if (NIL_P(self)) {
    if (create == MQ_FACTORY_NEW_INIT) {
      mqret = MQ_ERROR;
    } else {
      mqret = MqErrorGetCode(tmpl);
    }
  } else {
    mqctx = VAL2MqS(self);
    //rb_gc_register_address((VALUE*)&mqctx->self);
    INCR_REG(self);
    if (create == MQ_FACTORY_NEW_INIT) {
      MqSetupDup(mqctx, tmpl);
    }
  }
  
  *mqctxP = mqctx;
  return mqret;
}
rb_method_entry_t *
rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *opts, rb_method_flag_t noex)
{
    rb_thread_t *th;
    rb_control_frame_t *cfp;
    int line;
    rb_method_entry_t *me = rb_method_entry_make(klass, mid, type, 0, noex);
    rb_method_definition_t *def = ALLOC(rb_method_definition_t);
    me->def = def;
    def->type = type;
    def->original_id = mid;
    def->alias_count = 0;
    switch (type) {
      case VM_METHOD_TYPE_ISEQ:
	def->body.iseq = (rb_iseq_t *)opts;
	break;
      case VM_METHOD_TYPE_CFUNC:
	def->body.cfunc = *(rb_method_cfunc_t *)opts;
	break;
      case VM_METHOD_TYPE_ATTRSET:
      case VM_METHOD_TYPE_IVAR:
	def->body.attr.id = (ID)opts;
	def->body.attr.location = Qfalse;
	th = GET_THREAD();
	cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
	if (cfp && (line = rb_vm_get_sourceline(cfp))) {
	    VALUE location = rb_ary_new3(2, cfp->iseq->filename, INT2FIX(line));
	    def->body.attr.location = rb_ary_freeze(location);
	}
	break;
      case VM_METHOD_TYPE_BMETHOD:
	def->body.proc = (VALUE)opts;
	break;
      case VM_METHOD_TYPE_NOTIMPLEMENTED:
	def->body.cfunc.func = rb_f_notimplement;
	def->body.cfunc.argc = -1;
	break;
      case VM_METHOD_TYPE_OPTIMIZED:
	def->body.optimize_type = (enum method_optimized_type)opts;
	break;
      case VM_METHOD_TYPE_ZSUPER:
      case VM_METHOD_TYPE_UNDEF:
	break;
      default:
	rb_bug("rb_add_method: unsupported method type (%d)\n", type);
    }
    if (type != VM_METHOD_TYPE_UNDEF) {
	method_added(klass, mid);
    }
    return me;
}
Esempio n. 25
0
static void LibXML_validity_warning(void * ctxt, const char * msg, va_list ap)
{
  if (rb_block_given_p())
  {
    char buff[1024];
    snprintf(buff, 1024, msg, ap);
    rb_yield(rb_ary_new3(2, rb_str_new2(buff), Qfalse));
  }
  else
  {
    fprintf(stderr, "warning -- found validity error: ");
    fprintf(stderr, msg, ap);
  }
}
Esempio n. 26
0
VALUE zkrb_stat_to_rarray(const struct Stat* stat) {
  return rb_ary_new3(11,
		     LL2NUM(stat->czxid),
		     LL2NUM(stat->mzxid),
		     LL2NUM(stat->ctime),
		     LL2NUM(stat->mtime),
		     INT2NUM(stat->version),
		     INT2NUM(stat->cversion),
		     INT2NUM(stat->aversion),
		     LL2NUM(stat->ephemeralOwner),
		     INT2NUM(stat->dataLength),
		     INT2NUM(stat->numChildren),
		     LL2NUM(stat->pzxid));
}
Esempio n. 27
0
static VALUE
cr_gradient_pattern_get_color_stop_rgba (VALUE self, VALUE index)
{
  cairo_status_t status;
  double offset, red, green, blue, alpha;

  status = cairo_pattern_get_color_stop_rgba (_SELF (self), NUM2INT (index),
                                              &offset, &red, &green, &blue,
                                              &alpha);
  rb_cairo_check_status (status);
  return rb_ary_new3 (5, rb_float_new (offset),
                      rb_float_new (red), rb_float_new (green),
                      rb_float_new (blue), rb_float_new (alpha));
}
Esempio n. 28
0
static VALUE rb_gsl_utrunc_accel(VALUE obj)
{
  gsl_sum_levin_utrunc_workspace *w = NULL;
  double sum, err, sum_plain, *ptr;
  size_t terms_used, n, stride;
  ptr = get_vector_ptr(obj, &stride, &n);
  w = gsl_sum_levin_utrunc_alloc(n);
  gsl_sum_levin_utrunc_accel(ptr, n, w, &sum, &err);
  sum_plain = w->sum_plain;
  terms_used = w->terms_used;
  gsl_sum_levin_utrunc_free(w);
  return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err), 
		     rb_float_new(sum_plain), INT2FIX(terms_used));
}
Esempio n. 29
0
static VALUE
mlink_get(VALUE obj)
{
	struct mlink *lnkp;
	VALUE link, mark;

	Data_Get_Struct(obj, struct mlink, lnkp);

	link = lnkp->link;
	mark = link & 1 ? Qtrue : Qfalse ;
	link &= ~1;

	return rb_ary_new3(2, link, mark);
}
Esempio n. 30
0
static VALUE
rg_translate_coordinates(VALUE self, VALUE dest_widget, VALUE src_x, VALUE src_y)
{
    gint dest_x, dest_y;
    gboolean ret;
    VALUE result = Qnil;
    ret = gtk_widget_translate_coordinates(_SELF(self), _SELF(dest_widget),
                                           NUM2INT(src_x), NUM2INT(src_y),
                                           &dest_x, &dest_y);
    if (ret)
        result = rb_ary_new3(2, INT2FIX(dest_x), INT2FIX(dest_y));

    return result;
}