inline VALUE wrap< CEGUI::FrameComponent >(CEGUI::FrameComponent *framecomponent ) { return Data_Wrap_Struct(rb_cCeguiFrameComponent, NULL, NULL, framecomponent); }
static VALUE cState_s_allocate(VALUE klass) { JSON_Generator_State *state = State_allocate(); return Data_Wrap_Struct(klass, NULL, State_free, state); }
static VALUE mutex_s_alloc(VALUE self, SEL sel) { rb_vm_mutex_t *t = (rb_vm_mutex_t *)xmalloc(sizeof(rb_vm_mutex_t)); return Data_Wrap_Struct(self, NULL, NULL, t); }
static VALUE connection_parent_context_alloc(VALUE klass) { redisParentContext *pc = malloc(sizeof(*pc)); pc->context = NULL; pc->timeout = NULL; return Data_Wrap_Struct(klass, parent_context_mark, parent_context_free, pc); }
static VALUE rb_cogl_program_allocate (VALUE klass) { return Data_Wrap_Struct (klass, NULL, rb_cogl_program_free, NULL); }
VALUE new_object(int blocksize) { CvMemStorage *storage = cvCreateMemStorage(blocksize); return Data_Wrap_Struct(rb_klass, 0, free, storage); }
static VALUE fs_watcher_init(VALUE arg) { FSWatcher *watcher = (FSWatcher *) arg; struct kevent *events; VALUE filename; unsigned int i; uint32_t fflags; VALUE filenum; struct stat buf; int fd; /* Open each file in the filenames list and add each one to the events array. */ /* +2 for the termination pipe and the interruption pipe. */ events = alloca((RARRAY_LEN(watcher->filenames) + 2) * sizeof(struct kevent)); watcher->fds = malloc(RARRAY_LEN(watcher->filenames) * sizeof(int)); if (watcher->fds == NULL) { rb_raise(rb_eNoMemError, "Cannot allocate memory."); return Qnil; } for (i = 0; i < RARRAY_LEN(watcher->filenames); i++) { filename = rb_ary_entry(watcher->filenames, i); if (TYPE(filename) != T_STRING) { filename = rb_obj_as_string(filename); } if (stat(RSTRING_PTR(filename), &buf) == -1) { watcher->preparation_error = 1; goto end; } #ifdef O_EVTONLY fd = open(RSTRING_PTR(filename), O_EVTONLY); #else fd = open(RSTRING_PTR(filename), O_RDONLY); #endif if (fd == -1) { watcher->preparation_error = 1; goto end; } watcher->fds[i] = fd; watcher->fds_len++; fflags = NOTE_WRITE | NOTE_EXTEND | NOTE_RENAME | NOTE_DELETE | NOTE_REVOKE; EV_SET(&events[i], fd, EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_CLEAR, fflags, 0, 0); } watcher->events_len = watcher->fds_len; /* Create pipes for inter-thread communication. */ if (pipe(watcher->notification_fd) == -1) { rb_sys_fail("pipe()"); return Qnil; } if (pipe(watcher->interruption_fd) == -1) { rb_sys_fail("pipe()"); return Qnil; } /* Create a kqueue and register all events. */ watcher->kq = kqueue(); if (watcher->kq == -1) { rb_sys_fail("kqueue()"); return Qnil; } if (watcher->termination_pipe != Qnil) { filenum = rb_funcall(watcher->termination_pipe, rb_intern("fileno"), 0); EV_SET(&events[watcher->events_len], NUM2INT(filenum), EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, 0); watcher->termination_fd = NUM2INT(filenum); watcher->events_len++; } EV_SET(&events[watcher->events_len], watcher->interruption_fd[0], EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, 0); watcher->events_len++; if (kevent(watcher->kq, events, watcher->events_len, NULL, 0, NULL) == -1) { rb_sys_fail("kevent()"); return Qnil; } end: if (watcher->preparation_error) { for (i = 0; i < watcher->fds_len; i++) { close(watcher->fds[i]); } free(watcher->fds); watcher->fds = NULL; watcher->fds_len = 0; } return Data_Wrap_Struct(watcher->klass, NULL, fs_watcher_free, watcher); }
static VALUE allocate(VALUE klass) { return Data_Wrap_Struct(klass, NULL, deallocate, NULL); }
static VALUE rb_gsl_integration_glfixed_table_alloc(VALUE klass, VALUE n) { gsl_integration_glfixed_table *t; t = gsl_integration_glfixed_table_alloc(FIX2INT(n)); return Data_Wrap_Struct(cgsl_integration_glfixed_table, 0, gsl_integration_glfixed_table_free, t); }
// Allocate object VALUE audio_stream_alloc(VALUE klass) { AudioStreamInternal * internal = (AudioStreamInternal *)av_mallocz(sizeof(AudioStreamInternal)); if (!internal) rb_raise(rb_eNoMemError, "Failed to allocate internal structure"); return Data_Wrap_Struct(klass, audio_stream_mark, audio_stream_free, (void *)internal); }
VALUE virtualmachine_initialize(VALUE self, VALUE vmname, VALUE memsize) { VALUE vctx, vvme; struct vmctx *ctx; struct vm_exit *vme; uint64_t *gdt, *pt4, *pt3, *pt2; int i, err; _vm_create(StringValuePtr(vmname)); ctx = _vm_open(StringValuePtr(vmname)); vctx = Data_Wrap_Struct(rb_cVMCtx, NULL, vmctx_free, ctx); vme = (struct vm_exit *)calloc(1, sizeof(*vme)); vvme = Data_Wrap_Struct(rb_cVMCtx, NULL, vme_free, vme); rb_iv_set(self, "@ctx", vctx); rb_iv_set(self, "@vmname", vmname); rb_iv_set(self, "@memsize", memsize); rb_iv_set(self, "@vmexit", vvme); _vm_setup_memory(ctx, FIX2INT(memsize) * MB, VM_MMAP_ALL); pt4 = _vm_map_gpa(ctx, ADDR_PT4, sizeof(uint64_t) * 512); pt3 = _vm_map_gpa(ctx, ADDR_PT3, sizeof(uint64_t) * 512); pt2 = _vm_map_gpa(ctx, ADDR_PT2, sizeof(uint64_t) * 512); gdt = _vm_map_gpa(ctx, ADDR_GDT, sizeof(uint64_t) * 3); bzero(pt4, PAGE_SIZE); bzero(pt3, PAGE_SIZE); bzero(pt2, PAGE_SIZE); for (i = 0; i < 512; i++) { pt4[i] = (uint64_t)ADDR_PT3; pt4[i] |= PG_V | PG_RW | PG_U; pt3[i] = (uint64_t)ADDR_PT2; pt3[i] |= PG_V | PG_RW | PG_U; pt2[i] = i * (2 * 1024 * 1024); pt2[i] |= PG_V | PG_RW | PG_PS | PG_U; } gdt[GUEST_NULL_SEL] = 0; gdt[GUEST_CODE_SEL] = 0x0020980000000000; gdt[GUEST_DATA_SEL] = 0x0000900000000000; _vm_set_desc(ctx, 0, VM_REG_GUEST_CS, 0, 0, 0x0000209B); _vm_set_desc(ctx, 0, VM_REG_GUEST_DS, 0, 0, 0x00000093); _vm_set_desc(ctx, 0, VM_REG_GUEST_ES, 0, 0, 0x00000093); _vm_set_desc(ctx, 0, VM_REG_GUEST_FS, 0, 0, 0x00000093); _vm_set_desc(ctx, 0, VM_REG_GUEST_GS, 0, 0, 0x00000093); _vm_set_desc(ctx, 0, VM_REG_GUEST_SS, 0, 0, 0x00000093); _vm_set_desc(ctx, 0, VM_REG_GUEST_TR, 0, 0, 0x0000008b); _vm_set_desc(ctx, 0, VM_REG_GUEST_LDTR, 0, 0, DESC_UNUSABLE); _vm_set_desc(ctx, 0, VM_REG_GUEST_GDTR, ADDR_GDT, GUEST_GDTR_LIMIT, 0); _vm_set_register(ctx, 0, VM_REG_GUEST_CS, GSEL(GUEST_CODE_SEL, SEL_KPL)); _vm_set_register(ctx, 0, VM_REG_GUEST_DS, GSEL(GUEST_DATA_SEL, SEL_KPL)); _vm_set_register(ctx, 0, VM_REG_GUEST_ES, GSEL(GUEST_DATA_SEL, SEL_KPL)); _vm_set_register(ctx, 0, VM_REG_GUEST_FS, GSEL(GUEST_DATA_SEL, SEL_KPL)); _vm_set_register(ctx, 0, VM_REG_GUEST_GS, GSEL(GUEST_DATA_SEL, SEL_KPL)); _vm_set_register(ctx, 0, VM_REG_GUEST_SS, GSEL(GUEST_DATA_SEL, SEL_KPL)); _vm_set_register(ctx, 0, VM_REG_GUEST_TR, 0); _vm_set_register(ctx, 0, VM_REG_GUEST_LDTR, 0); _vm_set_register(ctx, 0, VM_REG_GUEST_CR0, CR0_PG | CR0_PE | CR0_NE); _vm_set_register(ctx, 0, VM_REG_GUEST_CR3, ADDR_PT4); _vm_set_register(ctx, 0, VM_REG_GUEST_CR4, CR4_PAE | CR4_VMXE); _vm_set_register(ctx, 0, VM_REG_GUEST_EFER, EFER_LMA | EFER_LME); _vm_set_register(ctx, 0, VM_REG_GUEST_RFLAGS, 0x2); _vm_set_register(ctx, 0, VM_REG_GUEST_RSP, ADDR_STACK); return self; }
static VALUE allocate(VALUE klass) { alpm_handle_t* p_alpm = NULL; VALUE obj = Data_Wrap_Struct(klass, 0, deallocate, p_alpm); return obj; }
static VALUE fdbm_alloc(VALUE klass) { return Data_Wrap_Struct(klass, 0, free_dbm, 0); }
static VALUE ra_sound_allocate(VALUE klass) { RA_SOUND *snd = ALLOC(RA_SOUND); memset(snd, 0, sizeof(RA_SOUND)); VALUE self = Data_Wrap_Struct(klass, ra_sound_mark, ra_sound_free, snd); return self; }
static VALUE rxml_xpath_context_alloc(VALUE klass) { return Data_Wrap_Struct(cXMLXPathContext, rxml_xpath_context_mark, rxml_xpath_context_free, NULL); }
VALUE rb_binding_new_from_binding(rb_vm_binding_t *bind) { return Data_Wrap_Struct(rb_cBinding, NULL, NULL, bind); }
VALUE rb_allocate(VALUE klass) { CvMemStorage *storage = cvCreateMemStorage(); return Data_Wrap_Struct(klass, 0, free, storage); }
static VALUE match_alloc( VALUE klass ) { struct ofp_match *match = xmalloc( sizeof( struct ofp_match ) ); return Data_Wrap_Struct( klass, NULL, xfree, match ); }
static VALUE allocate(VALUE klass) { JohnsonRuntime* runtime = calloc(1L, sizeof(JohnsonRuntime)); return Data_Wrap_Struct(klass, 0, deallocate, runtime); }
/* * WkHtml::ToPdf::ObjectSettings */ VALUE wkhtml_topdf_objectsettings_alloc(VALUE self) { wkhtmltopdf_object_settings* settings = wkhtmltopdf_create_object_settings(); return Data_Wrap_Struct(self, NULL, wkhtmltopdf_destroy_object_settings, settings); }
static VALUE cr_font_face_allocate (VALUE klass) { return Data_Wrap_Struct (klass, NULL, cr_font_face_free, NULL); }
VALUE wkhtml_toimage_globalsettings_alloc(VALUE self) { wkhtmltoimage_global_settings* settings = wkhtmltoimage_create_global_settings(); return Data_Wrap_Struct(self, NULL, wkhtml_toimage_globalsettings_free, settings); }
VALUE rugged_index_new(VALUE klass, VALUE owner, git_index *index) { VALUE rb_index = Data_Wrap_Struct(klass, NULL, &rb_git_index__free, index); rugged_set_owner(rb_index, owner); return rb_index; }
static VALUE Unpacker_alloc(VALUE klass) { unpacker_t *ptr = ALLOC(unpacker_t); return Data_Wrap_Struct(klass, unpacker_mark, -1, ptr); }
static VALUE ruby_xslt_stylesheet_alloc(VALUE klass) { return Data_Wrap_Struct(cXSLTStylesheet, NULL, ruby_xslt_stylesheet_free, NULL); }
void do_postgres_full_connect(VALUE self, PGconn *db) { VALUE r_host; char *host = NULL; if ((r_host = rb_iv_get(self, "@host")) != Qnil) { host = StringValuePtr(r_host); } VALUE r_user; char *user = NULL; if ((r_user = rb_iv_get(self, "@user")) != Qnil) { user = StringValuePtr(r_user); } VALUE r_password; char *password = NULL; if ((r_password = rb_iv_get(self, "@password")) != Qnil) { password = StringValuePtr(r_password); } VALUE r_port; const char *port = "5432"; if ((r_port = rb_iv_get(self, "@port")) != Qnil) { port = StringValuePtr(r_port); } VALUE r_path; char *path = NULL; char *database = NULL; if ((r_path = rb_iv_get(self, "@path")) != Qnil) { path = StringValuePtr(r_path); database = strtok(path, "/"); } if (!database || !*database) { database = NULL; } VALUE r_query = rb_iv_get(self, "@query"); const char *search_path = data_objects_get_uri_option(r_query, "search_path"); db = PQsetdbLogin( host, port, NULL, NULL, database, user, password ); if (PQstatus(db) == CONNECTION_BAD) { rb_raise(eDO_ConnectionError, "%s", PQerrorMessage(db)); } PGresult *result; if (search_path) { char *search_path_query; if (!(search_path_query = calloc(256, sizeof(char)))) { rb_memerror(); } snprintf(search_path_query, 256, "set search_path to %s;", search_path); r_query = rb_str_new2(search_path_query); result = do_postgres_cCommand_execute(Qnil, self, db, r_query); if (PQresultStatus(result) != PGRES_COMMAND_OK) { free(search_path_query); do_postgres_raise_error(self, result, r_query); } free(search_path_query); } const char *backslash_off = "SET backslash_quote = off"; const char *standard_strings_on = "SET standard_conforming_strings = on"; const char *warning_messages = "SET client_min_messages = warning"; const char *date_format = "SET datestyle = ISO"; VALUE r_options; r_options = rb_str_new2(backslash_off); result = do_postgres_cCommand_execute(Qnil, self, db, r_options); if (PQresultStatus(result) != PGRES_COMMAND_OK) { rb_warn("%s", PQresultErrorMessage(result)); } r_options = rb_str_new2(standard_strings_on); result = do_postgres_cCommand_execute(Qnil, self, db, r_options); if (PQresultStatus(result) != PGRES_COMMAND_OK) { rb_warn("%s", PQresultErrorMessage(result)); } r_options = rb_str_new2(warning_messages); result = do_postgres_cCommand_execute(Qnil, self, db, r_options); if (PQresultStatus(result) != PGRES_COMMAND_OK) { rb_warn("%s", PQresultErrorMessage(result)); } r_options = rb_str_new2(date_format); result = do_postgres_cCommand_execute(Qnil, self, db, r_options); if (PQresultStatus(result) != PGRES_COMMAND_OK) { rb_warn("%s", PQresultErrorMessage(result)); } VALUE encoding = rb_iv_get(self, "@encoding"); #ifdef HAVE_PQSETCLIENTENCODING VALUE pg_encoding = rb_hash_aref(data_objects_const_get(mDO_PostgresEncoding, "MAP"), encoding); if (pg_encoding != Qnil) { if (PQsetClientEncoding(db, rb_str_ptr_readonly(pg_encoding))) { rb_raise(eDO_ConnectionError, "Couldn't set encoding: %s", rb_str_ptr_readonly(encoding)); } else { #ifdef HAVE_RUBY_ENCODING_H rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index(rb_str_ptr_readonly(encoding)))); #endif rb_iv_set(self, "@pg_encoding", pg_encoding); } } else { rb_warn("Encoding %s is not a known Ruby encoding for PostgreSQL\n", rb_str_ptr_readonly(encoding)); rb_iv_set(self, "@encoding", rb_str_new2("UTF-8")); #ifdef HAVE_RUBY_ENCODING_H rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8"))); #endif rb_iv_set(self, "@pg_encoding", rb_str_new2("UTF8")); } #endif rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db)); }
static VALUE helium_rb_allocate(VALUE klass) { return Data_Wrap_Struct(klass, helium_rb_mark, helium_free, helium_alloc()); }
// Allocation function for the Kerberos::Krb5::Keytab class. static VALUE rkrb5_princ_allocate(VALUE klass){ RUBY_KRB5_PRINC* ptr = malloc(sizeof(RUBY_KRB5_PRINC)); memset(ptr, 0, sizeof(RUBY_KRB5_PRINC)); return Data_Wrap_Struct(klass, 0, rkrb5_princ_free, ptr); }
VALUE frostbitten_message_allocate (VALUE klass) { fb_message *msg = ruby_xmalloc(sizeof(fb_message)); return Data_Wrap_Struct(klass, frostbitten_message_mark, frostbitten_message_deallocate, msg); }
static VALUE t_init(VALUE self) { Clist *st = clist_new(); VALUE stv = Data_Wrap_Struct(cArrayList, 0, free_clist, st); rb_iv_set(self, "@clist", stv); return self; }