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;
}
