static VALUE
rg_operator_p_compare(VALUE self, VALUE other)
{
    if (rb_obj_is_kind_of(other, GTYPE2CLASS(GTK_TYPE_PRINTER))){
        return INT2NUM(gtk_printer_compare(_SELF(self), _SELF(other)));
    } else {
        rb_raise(rb_eTypeError, "%s isn't a kind of Gtk::Printer", rb_class2name(other));
    }
}

static VALUE zipruby_archive_replace_function(int argc, VALUE *argv, VALUE self) {
    VALUE index, flags, mtime;
    struct zipruby_archive *p_archive;
    struct zip_source *zsource;
    struct read_proc *z;
    int i_index, i_flags = 0;

    rb_scan_args(argc, argv, "12", &index, &mtime, &flags);
    rb_need_block();

    if (TYPE(index) != T_STRING && !FIXNUM_P(index)) {
        rb_raise(rb_eTypeError, "wrong argument type %s (expected Fixnum or String)", rb_class2name(CLASS_OF(index)));
    }

    if (NIL_P(mtime)) {
        mtime = rb_funcall(rb_cTime, rb_intern("now"), 0);
    } else if (!rb_obj_is_instance_of(mtime, rb_cTime)) {
        rb_raise(rb_eTypeError, "wrong argument type %s (expected Time)", rb_class2name(CLASS_OF(mtime)));
    }

    if (!NIL_P(flags)) {
        i_flags = NUM2INT(flags);
    }

    Data_Get_Struct(self, struct zipruby_archive, p_archive);
    Check_Archive(p_archive);

    if (FIXNUM_P(index)) {
        i_index = NUM2INT(index);
    } else if ((i_index = zip_name_locate(p_archive->archive, RSTRING_PTR(index), i_flags)) == -1) {
        rb_raise(Error, "Replace file failed - %s: Archive does not contain a file", RSTRING_PTR(index));
    }

    if ((z = malloc(sizeof(struct read_proc))) == NULL) {
        zip_unchange_all(p_archive->archive);
        zip_unchange_archive(p_archive->archive);
        rb_raise(rb_eRuntimeError, "Replace failed at %d: Cannot allocate memory", i_index);
    }

    z->proc = rb_block_proc();
    rb_ary_push(p_archive->sources, z->proc);
    z->mtime = TIME2LONG(mtime);

    if ((zsource = zip_source_proc(p_archive->archive, z)) == NULL) {
        free(z);
        rb_raise(Error, "Replace failed at %d: %s", i_index, zip_strerror(p_archive->archive));
    }

    if (zip_replace(p_archive->archive, i_index, zsource) == -1) {
        zip_source_free(zsource);
        zip_unchange_all(p_archive->archive);
        zip_unchange_archive(p_archive->archive);
        rb_raise(Error, "Replace failed at %d: %s", i_index, zip_strerror(p_archive->archive));
    }

    return Qnil;
}

static VALUE rb_ool_conmin_constraint_set_n(VALUE obj, VALUE n)
{	
	ool_conmin_constraint *C;
	if (!FIXNUM_P(n)) rb_raise(rb_eArgError, "Wrong argument type %s (Fixnum expected)",
		rb_class2name(CLASS_OF(n)));
	Data_Get_Struct(obj, ool_conmin_constraint, C);
	C->n = (size_t) FIX2INT(n);
	return n;
}

/*
 * call-seq:
 *   to_s -> "<Delineate::Point:(self.x,self.y)>"
 *
 * Return x and y by String.
 */
VALUE rb_point_to_s(VALUE self) {
  const int i = 4;
  VALUE str[i];
  str[0] = rb_str_new2("<%s:(%g,%g)>");
  str[1] = rb_str_new2(rb_class2name(CLASS_OF(self)));
  str[2] = rb_point_x(self);
  str[3] = rb_point_y(self);
  return rb_f_sprintf(i, str);
}

static usb_dev_handle *check_usb_devhandle(VALUE v)
{
  Check_Type(v, T_DATA);
  if (RDATA(v)->dfree != rusb_devhandle_free) {
    rb_raise(rb_eTypeError, "wrong argument type %s (expected USB::DevHandle)",
             rb_class2name(CLASS_OF(v)));
  }
  return DATA_PTR(v);
}

void
rb_undef(VALUE klass, ID id)
{
    // TODO
#if 0
    VALUE origin;
    NODE *body;

#if 0 // TODO
    if (rb_vm_cbase() == rb_cObject && klass == rb_cObject) {
	rb_secure(4);
    }
#endif
    if (rb_safe_level() >= 4 && !OBJ_TAINTED(klass)) {
	rb_raise(rb_eSecurityError, "Insecure: can't undef `%s'",
		 rb_id2name(id));
    }
    rb_frozen_class_p(klass);
    if (id == object_id || id == __send__ || id == idInitialize) {
	rb_warn("undefining `%s' may cause serious problem", rb_id2name(id));
    }
    /* TODO: warn if a very important method of NSObject is undefined 
     * by default, pure objc methods are not exposed by introspections API 
     */
    body = search_method(klass, id, &origin);
    if (!body || !body->nd_body) {
	const char *s0 = " class";
	VALUE c = klass;

	if (RCLASS_SINGLETON(c)) {
	    VALUE obj = rb_iv_get(klass, "__attached__");

	    switch (TYPE(obj)) {
	      case T_MODULE:
	      case T_CLASS:
		c = obj;
		s0 = "";
	    }
	}
	else if (TYPE(c) == T_MODULE) {
	    s0 = " module";
	}
	rb_name_error(id, "undefined method `%s' for%s `%s'",
		      rb_id2name(id), s0, rb_class2name(c));
    }

    rb_add_method(klass, id, 0, NOEX_PUBLIC);

    if (RCLASS_SINGLETON(klass)) {
	rb_funcall(rb_iv_get(klass, "__attached__"),
		   singleton_undefined, 1, ID2SYM(id));
    }
    else {
	rb_funcall(klass, undefined, 1, ID2SYM(id));
    }
#endif
}

static VALUE
ossl_cipher_update_deprecated(VALUE self, VALUE data)
{
    char *cname;

    cname = rb_class2name(rb_obj_class(self));
    rb_warning("%s#<< is deprecated; use %s#update instead", cname, cname);
    return ossl_cipher_update(self, data);
}

/*
 *  call-seq:
 *     cipher << data -> string
 *
 *  === Parameters
 *  +data+ is a nonempty string.
 *
 * This method is deprecated and not available in 1.9.x or later.
 */
static VALUE
ossl_cipher_update_deprecated(VALUE self, VALUE data)
{
    const char *cname;

    cname = rb_class2name(rb_obj_class(self));
    rb_warning("%s#<< is deprecated; use %s#update instead", cname, cname);
    return rb_funcall(self, rb_intern("update"), 1, data);
}

static void oci8_assign_lob(VALUE klass, oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest)
{
    oci8_base_t *base = oci8_check_typeddata(lob, &oci8_lob_data_type, 1);
    if (!rb_obj_is_kind_of(lob, klass)) {
        rb_raise(rb_eTypeError, "wrong argument %s (expect %s)",
                 rb_obj_classname(lob), rb_class2name(klass));
    }
    chker2(OCILobLocatorAssign_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, base->hp.lob, dest), base);
}

static VALUE
actiongroup_add_actions(VALUE self, VALUE entries)
{
    guint i;
    VALUE action_procs;
    guint n_entries = (guint)RARRAY_LEN(entries);
    GtkActionEntry* gentries = g_new0(GtkActionEntry, n_entries);

    if (rb_ivar_defined(self, id_action_procs) == Qtrue){
        action_procs = rb_ivar_get(self, id_action_procs);
    } else {
        action_procs = rb_hash_new();
    }

    for (i = 0; i < n_entries; i++){
        VALUE entry;
        int size;

	entry = RARRAY_PTR(entries)[i];
	size = RARRAY_LEN(entry);
        if (size < 1)
            rb_raise(rb_eArgError, "wrong array parameter");

        gentries[i].name = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[0]);
        gentries[i].callback = G_CALLBACK(activate_action);

        if (size < 2) continue;

        if (NIL_P(RARRAY_PTR(entry)[1])){
            gentries[i].stock_id = NULL;
        } else if (SYMBOL_P(RARRAY_PTR(entry)[1])){
            gentries[i].stock_id = rb_id2name(SYM2ID(RARRAY_PTR(entry)[1]));
        } else if (TYPE(RARRAY_PTR(entry)[1]) == T_STRING){
            gentries[i].stock_id = RVAL2CSTR(RARRAY_PTR(entry)[1]);
        } else{
            rb_raise(rb_eArgError,
		     "invalid argument %s (expect Symbol or String)",
                     rb_class2name(CLASS_OF(RARRAY_PTR(entry)[1])));
        }

        if (size < 3) continue;
        gentries[i].label = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[2]);
        if (size < 4) continue;
        gentries[i].accelerator = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[3]);
        if (size < 4) continue;
        gentries[i].tooltip = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[4]);
        if (size < 5) continue;
        rb_hash_aset(action_procs, RARRAY_PTR(entry)[0], RARRAY_PTR(entry)[5]);
    }
    rb_ivar_set(self, id_action_procs, action_procs);
    gtk_action_group_add_actions(_SELF(self), gentries, n_entries,
				 (gpointer)self);
    g_free(gentries);

    return self;
}

/*
 *  Extern:     rm_get_geometry
 *  Purpose:    Get the values from a Geometry object and return
 *              them in C variables.
*/
void
rm_get_geometry(
    VALUE geom,
    long *x,
    long *y,
    unsigned long *width,
    unsigned long *height,
    int *flag)
{
    VALUE v;

    v = rb_funcall(geom, rm_ID_x, 0);
    *x = NUM2LONG(v);
    v = rb_funcall(geom, rm_ID_y, 0);
    *y = NUM2LONG(v);
    v = rb_funcall(geom, rm_ID_width, 0);
    *width = NUM2ULONG(v);
    v = rb_funcall(geom, rm_ID_height, 0);
    *height = NUM2ULONG(v);

    // Getting the flag field is a bit more difficult since it's
    // supposed to be an instance of the GeometryValue Enum class. We
    // may not know the VALUE for the GeometryValue class, and we
    // need to check that the flag field is an instance of that class.
    if (flag)
    {
        MagickEnum *magick_enum;

        v = rb_funcall(geom, rm_ID_flag, 0);
        if (!Class_GeometryValue)
        {
            Class_GeometryValue = rb_const_get(Module_Magick, rm_ID_GeometryValue);
        }
        if (CLASS_OF(v) != Class_GeometryValue)
        {
            rb_raise(rb_eTypeError, "wrong enumeration type - expected %s, got %s"
                        , rb_class2name(Class_GeometryValue),rb_class2name(CLASS_OF(v)));
        }
        Data_Get_Struct(v, MagickEnum, magick_enum);
        *flag = magick_enum->val;
    }

}

static VALUE mSyslog_inspect(VALUE self)
{
    char buf[1024];

    if (syslog_opened) {
	snprintf(buf, sizeof(buf),
	  "<#%s: opened=true, ident=\"%s\", options=%d, facility=%d, mask=%d>",
	  rb_class2name(self),
	  syslog_ident,
	  syslog_options,
	  syslog_facility,
	  syslog_mask);
    } else {
	snprintf(buf, sizeof(buf),
	  "<#%s: opened=false>", rb_class2name(self));
    }

    return rb_str_new2(buf);
}

static TERMINAL *
check_rt(VALUE self)
{
    Check_Type(self, T_DATA);
    if (RDATA(self)->dfree != rt_free) {
        rb_raise(rb_eTypeError, "wrong argument type %s (expected TermInfo)",
                 rb_class2name(CLASS_OF(self)));
    }
    return DATA_PTR(self);
}

/*
 * call-seq:
 *   CvSeq.new(<i>type[,storage]</i>)
 *
 * Return a new CvSeq. <i>type</i> should be following classes.
 *
 * * CvIndex
 * * CvPoint
 */
VALUE
rb_initialize(int argc, VALUE *argv, VALUE self)
{
  VALUE klass, storage_value;
  CvMemStorage *storage;

  if (rb_scan_args(argc, argv, "11", &klass, &storage_value) > 1) {
    storage_value = CHECK_CVMEMSTORAGE(storage_value);
    storage = CVMEMSTORAGE(storage_value);
  }
  else
    storage = cvCreateMemStorage(0);
  
  if(!rb_obj_is_kind_of(klass, rb_cClass))
    rb_raise(rb_eTypeError, "argument 1 (sequence-block class) should be %s.", rb_class2name(rb_cClass));

  int type = 0, size = 0;
  if (klass == cCvIndex::rb_class()) {
    type = CV_SEQ_ELTYPE_INDEX;
    size = sizeof(CvIndex);
  }
  else if (klass == cCvPoint::rb_class()) {
    type = CV_SEQ_ELTYPE_POINT;
    size = sizeof(CvPoint);
  }
  else if (klass == cCvPoint2D32f::rb_class()) {
    type = CV_SEQ_ELTYPE_POINT;
    size = sizeof(CvPoint2D32f);
  }
  else if (klass == cCvPoint3D32f::rb_class()) {
    type = CV_SEQ_ELTYPE_POINT3D;
    size = sizeof(CvPoint3D32f);
  }
  // todo: more various class will be support.
  if (!size)
    rb_raise(rb_eTypeError, "unsupport %s class for sequence-block.", rb_class2name(klass));
  
  CvSeq* seq = cvCreateSeq(type, sizeof(CvSeq), size, storage);
  DATA_PTR(self) = seq;
  resist_class_information_of_sequence(seq, klass);
  
  return self;
}

gpointer
rbgobj_boxed_get(VALUE obj, GType gtype)
{
    boxed_holder* holder;

    if (NIL_P(obj))
        return NULL;

    if (!RVAL2CBOOL(rb_obj_is_kind_of(obj, GTYPE2CLASS(gtype))))
        rb_raise(rb_eArgError, "invalid argument %s (expect %s)",
                 rb_class2name(CLASS_OF(obj)), 
                 rb_class2name(GTYPE2CLASS(gtype)));

    Data_Get_Struct(obj, boxed_holder, holder);
    if (!holder->boxed)
        rb_raise(rb_eArgError, "uninitialize %s", rb_class2name(CLASS_OF(obj)));

    return holder->boxed;
}

VALUE
rb_mod_init_copy(VALUE clone, SEL sel, VALUE orig)
{
    rb_obj_init_copy(clone, 0, orig);

    VALUE super;
    if (!RCLASS_RUBY(orig)) {
	super = orig;
	rb_warn("cloning class `%s' is not supported, creating a " \
		"subclass instead", rb_class2name(orig));
    }
    else {
	super = RCLASS_SUPER(orig);
    }
    RCLASS_SET_SUPER(clone, super);

    // Copy flags.
    unsigned long version_flag = RCLASS_IS_RUBY_CLASS;
    if ((RCLASS_VERSION(super) & RCLASS_IS_OBJECT_SUBCLASS)
	    == RCLASS_IS_OBJECT_SUBCLASS) {
	version_flag |= RCLASS_IS_OBJECT_SUBCLASS;
    }
    if (RCLASS_MODULE(orig)) {
	version_flag |= RCLASS_IS_MODULE;
    }
    RCLASS_SET_VERSION(clone, version_flag);
    if (!class_isMetaClass((Class)clone)) {
	// Clear type info.
	RCLASS_SET_VERSION(*(Class *)clone, RCLASS_VERSION(*(Class *)clone));
    }

    // Copy methods.
    rb_vm_copy_methods((Class)orig, (Class)clone);
    if (!class_isMetaClass((Class)orig)) {
	rb_vm_copy_methods(*(Class *)orig, *(Class *)clone);
    }

    // Copy ivars.
    CFMutableDictionaryRef orig_dict = rb_class_ivar_dict(orig);
    CFMutableDictionaryRef clone_dict;
    if (orig_dict != NULL) {
	clone_dict = CFDictionaryCreateMutableCopy(NULL, 0, orig_dict);
	rb_class_ivar_set_dict(clone, clone_dict);
	CFMakeCollectable(clone_dict);
    }
    else {
	clone_dict = rb_class_ivar_dict_or_create(clone);
    }

    // Remove the classpath & classid (name) so that they are not
    // copied over the new module / class.
    CFDictionaryRemoveValue(clone_dict, (const void *)id_classpath);
    CFDictionaryRemoveValue(clone_dict, (const void *)id_classid);
    return clone;
}

/*
 * call-seq:
 *   insert(<i>index,obj</i>) -> self
 *
 * Inserts the given values before element with the given index (which may be negative).
 */
VALUE
rb_insert(VALUE self, VALUE index, VALUE object)
{
  Check_Type(index, T_FIXNUM);
  CvSeq *seq = CVSEQ(self);
  VALUE klass = seqblock_class(seq);
  if(CLASS_OF(object) != klass)
    rb_raise(rb_eTypeError, "arguments should be %s.", rb_class2name(klass));
  cvSeqInsert(seq, FIX2INT(index), DATA_PTR(object));
  return self;
}

void require_class(VALUE x, VALUE cls)
{
    if(rb_obj_is_instance_of(x,cls) == Qfalse)
    {
        rb_raise( rb_eRuntimeError, 
                  "wrong argument type %s (expected %s)",
                  rb_obj_classname(x),
                  rb_class2name(cls)
            );
    }
}

/*
 * Object validity checker. Returns the data pointer.
 */
static struct rlink_sentence *
check_sentence(  VALUE	self ) {
	Check_Type( self, T_DATA );

    if ( !IsSentence(self) ) {
		rb_raise( rb_eTypeError, "wrong argument type %s (expected LinkParser::Sentence)",
				  rb_class2name(CLASS_OF( self )) );
    }

	return DATA_PTR( self );
}

static VALUE onum_inspect(VALUE self)
{
    const char *name = rb_class2name(CLASS_OF(self));
    volatile VALUE s = onum_to_s(self);
    size_t len = strlen(name) + RSTRING_LEN(s) + 5;
    char *str = ALLOCA_N(char, len);

    snprintf(str, len, "#<%s:%s>", name, RSTRING_PTR(s));
    str[len - 1] = '\0';
    return rb_usascii_str_new_cstr(str);
}