SeedValue seed_mpfr_nexttoward (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_ptr rop, op;
CHECK_ARG_COUNT("mpfr.nexttoward", 1);
rop = seed_object_get_private(this_object);
if ( seed_value_is_object_of_class(ctx, args[0], mpfr_class) )
{
op = seed_object_get_private(args[0]);
}
else
{
TYPE_EXCEPTION("mpfr.nexttoward", "mpfr_t");
}
mpfr_nexttoward(rop, op);
return seed_make_null(ctx);
}
SeedValue seed_mpfr_sub (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_rnd_t rnd;
mpfr_ptr rop, op1, op2;
gdouble dop1, dop2;
gint ret;
seed_mpfr_t argt1, argt2;
/* only want 1 double argument. alternatively, could accept 2,
add those, and set from the result*/
CHECK_ARG_COUNT("mpfr.sub", 3);
rop = seed_object_get_private(this_object);
rnd = seed_value_to_mpfr_rnd_t(ctx, args[2], exception);
argt1 = seed_mpfr_arg_type(ctx, args[0], exception);
argt2 = seed_mpfr_arg_type(ctx, args[1], exception);
if ( (argt1 & argt2) == SEED_MPFR_MPFR )
{
/* both mpfr_t */
op1 = seed_object_get_private(args[0]);
op2 = seed_object_get_private(args[1]);
ret = mpfr_sub(rop, op1, op2, rnd);
}
else if ( (argt1 | argt2) == (SEED_MPFR_MPFR | SEED_MPFR_DOUBLE) )
{
/* a double and an mpfr_t. Figure out the order */
if ( argt1 == SEED_MPFR_MPFR )
{
op1 = seed_object_get_private(args[0]);
dop2 = seed_value_to_double(ctx, args[1], exception);
mpfr_sub_d(rop, op1, dop2, rnd);
}
else
{
dop1 = seed_value_to_double(ctx, args[0], exception);
op2 = seed_object_get_private(args[1]);
mpfr_d_sub(rop, dop1, op2, rnd);
}
}
else if ( (argt1 & argt2) == SEED_MPFR_DOUBLE )
{
/* 2 doubles. hopefully doesn't happen */
dop1 = seed_value_to_double(ctx, args[0], exception);
dop2 = seed_value_to_double(ctx, args[1], exception);
ret = mpfr_set_d(rop, dop1 - dop2, rnd);
}
else
{
TYPE_EXCEPTION("mpfr.sub", "double or mpfr_t");
}
return seed_value_from_int(ctx, ret, exception);
}
SeedValue seed_mpfr_remainder (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_rnd_t rnd;
mpfr_ptr rop, op1, op2;
gint ret;
CHECK_ARG_COUNT("mpfr.remainder", 3);
rop = seed_object_get_private(this_object);
rnd = seed_value_to_mpfr_rnd_t(ctx, args[2], exception);
if ( seed_value_is_object_of_class(ctx, args[0], mpfr_class) &&
seed_value_is_object_of_class(ctx, args[1], mpfr_class))
{
op1 = seed_object_get_private(args[0]);
op2 = seed_object_get_private(args[1]);
}
else
{
TYPE_EXCEPTION("mpfr.remainder", "mpfr_t");
}
ret = mpfr_remainder(rop, op1, op2, rnd);
return seed_value_from_int(ctx, ret, exception);
}
SeedValue seed_mpfr_cmpabs (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_ptr rop, op;
gint ret;
CHECK_ARG_COUNT("mpfr.cmpabs", 1);
rop = seed_object_get_private(this_object);
if ( seed_value_is_object_of_class(ctx, args[0], mpfr_class) )
{
op = seed_object_get_private(args[0]);
}
else
{
TYPE_EXCEPTION("mpfr.cmpabs", "mpfr_t");
}
ret = mpfr_cmpabs(rop, op);
return seed_value_from_int(ctx, ret, exception);
}
static SeedValue
seed_cairo_surface_write_to_png (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue arguments[],
SeedException *exception)
{
cairo_status_t ret;
cairo_surface_t *surf;
gchar *filename;
CHECK_THIS();
if (argument_count != 1)
{
EXPECTED_EXCEPTION("write_to_png", "1 argument");
}
surf = seed_object_get_private (this_object);
filename = seed_value_to_string (ctx, arguments[0], exception);
ret = cairo_surface_write_to_png (surf, filename);
g_free (filename);
return seed_value_from_long (ctx, ret, exception);
}
static SeedValue
seed_cairo_pattern_add_color_stop_rgba (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue arguments[],
SeedException *exception)
{
gdouble offset, r, g, b, a;
cairo_pattern_t *pat;
CHECK_THIS();
if (argument_count != 5)
{
EXPECTED_EXCEPTION("add_color_stop_rgba", "5 arguments");
}
pat = seed_object_get_private (this_object);
offset = seed_value_to_double (ctx, arguments[0], exception);
r = seed_value_to_double (ctx, arguments[1], exception);
g = seed_value_to_double (ctx, arguments[2], exception);
b = seed_value_to_double (ctx, arguments[3], exception);
a = seed_value_to_double (ctx, arguments[4], exception);
cairo_pattern_add_color_stop_rgba (pat, offset, r, g, b, a);
return seed_make_undefined (ctx);
}
void pipe_finalize(SeedObject pipeobj)
{
pipe_priv *priv = seed_object_get_private(pipeobj);
g_io_channel_unref(priv->read);
g_io_channel_unref(priv->write);
g_free(priv);
}
static gboolean
seed_ffi_set_signature (SeedContext ctx,
SeedObject this_object,
SeedString property_name,
SeedValue value,
SeedException *exception)
{
seed_ffi_function_priv *priv = seed_object_get_private (this_object);
if (priv->signature_obj)
{
seed_make_exception (ctx, exception, "FFIError",
"Can not reset signature of function once set");
return FALSE;
}
else if (!seed_value_is_object (ctx, value))
{
seed_make_exception (ctx, exception, "FFIError",
"Signature must be an object");
return FALSE;
}
else
{
if (!seed_ffi_build_signature (ctx, priv, (SeedObject) value, exception))
return FALSE;
}
return TRUE;
}
static void
exports_finalize (SeedObject obj)
{
Exports *priv;
BigDBusConnectFuncs const *connect_funcs = NULL;
priv = seed_object_get_private (obj);
if (priv == NULL)
return; /* we are the prototype, not a real instance, so constructor never called */
if (priv->which_bus == DBUS_BUS_SESSION) {
connect_funcs = &session_connect_funcs;
} else if (priv->which_bus == DBUS_BUS_SYSTEM) {
connect_funcs = &system_connect_funcs;
} else
g_assert_not_reached();
big_dbus_remove_connect_funcs(connect_funcs, priv);
if (priv->connection_weak_ref != NULL) {
on_bus_closed(priv->connection_weak_ref, priv);
}
g_slice_free(Exports, priv);
}
static SeedValue
seed_ffi_library_get_property (SeedContext ctx,
SeedObject this_object,
SeedString property_name,
SeedException *exception)
{
SeedValue ret;
GModule *mod;
gchar *prop;
gsize len = seed_string_get_maximum_size (property_name);
gpointer symbol;
seed_ffi_library_priv *priv;
prop = g_alloca (len);
seed_string_to_utf8_buffer (property_name, prop, len);
priv = seed_object_get_private (this_object);
mod = priv->mod;
if ((ret = g_hash_table_lookup (priv->symbols, prop)))
return ret;
if (!g_module_symbol (mod, prop, &symbol))
{
return NULL;
}
return seed_ffi_make_function (ctx, this_object, symbol, prop, priv->symbols);
}
static void
seed_ffi_library_finalize (SeedObject obj)
{
seed_ffi_library_priv *priv;
priv = seed_object_get_private (obj);
g_module_close (priv->mod);
}
SeedValue seed_sqlite_close(SeedContext ctx,
SeedObject function,
SeedObject this_object,
size_t argument_count,
const SeedValue arguments[],
SeedException * exception)
{
sqlite3 *db = seed_object_get_private(this_object);
sqlite3_close(db);
return seed_value_from_boolean(ctx, TRUE, exception);
}
SeedValue seed_mpfr_root (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_rnd_t rnd;
mpfr_ptr rop, op;
gint ret;
gulong k;
CHECK_ARG_COUNT("mpfr.root", 3);
rop = seed_object_get_private(this_object);
rnd = seed_value_to_mpfr_rnd_t(ctx, args[2], exception);
if ( seed_value_is_object_of_class(ctx, args[0], mpfr_class) )
{
op = seed_object_get_private(args[0]);
}
else
{
TYPE_EXCEPTION("mpfr.root", "mpfr_t");
}
if ( seed_value_is_number(ctx, args[1]) )
{
k = seed_value_to_ulong(ctx, args[1], exception);
}
else
{
TYPE_EXCEPTION("mpfr.root", "unsigned long int");
}
ret = mpfr_root(rop, op, k, rnd);
return seed_value_from_int(ctx, ret, exception);
}
static SeedValue
seed_ffi_get_signature (SeedContext ctx,
SeedObject this_object,
SeedString property_name,
SeedException *exception)
{
seed_ffi_function_priv *priv = seed_object_get_private (this_object);
if (priv->signature_obj)
return priv->signature_obj;
else
return seed_make_null (ctx);
}
SeedValue seed_mpfr_nextabove (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_ptr rop;
CHECK_ARG_COUNT("mpfr.nextabove", 0);
rop = seed_object_get_private(this_object);
mpfr_nextabove(rop);
return seed_make_null(ctx);
}
SeedValue seed_mpfr_integer_p (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_ptr rop;
gboolean ret;
CHECK_ARG_COUNT("mpfr.integer", 0);
rop = seed_object_get_private(this_object);
ret = mpfr_integer_p(rop);
return seed_value_from_boolean(ctx, ret, exception);
}
static void
seed_ffi_function_finalize (SeedObject obj)
{
seed_ffi_function_priv *priv = seed_object_get_private (obj);
if (priv->signature_obj)
{
seed_value_unprotect (eng->context, priv->signature_obj);
g_slice_free1 (priv->n_args * sizeof(GType), priv->args);
}
g_free (priv->name);
g_slice_free1 (sizeof(seed_ffi_function_priv), priv);
seed_value_unprotect (eng->context, priv->module_obj);
}
SeedValue seed_sqlite_exec(SeedContext ctx,
SeedObject function,
SeedObject this_object,
size_t argument_count,
const SeedValue arguments[],
SeedException * exception)
{
gchar *statement;
gchar *sqlite_error = 0;
sqlite3 *db;
int rc;
if (argument_count < 1)
{
seed_make_exception(ctx, exception, "ArgumentError",
"sqlite.Database.exec expected 1 or 2 arguments");
return seed_make_null(ctx);
}
statement = seed_value_to_string(ctx, arguments[0], exception);
db = seed_object_get_private(this_object);
g_assert(db);
rc = sqlite3_exec(db, statement,
seed_sqlite_exec_callback,
argument_count == 2 ? arguments[1] : 0, &sqlite_error);
g_free(statement);
if (rc != SQLITE_OK)
{
if (sqlite_error)
{
seed_make_exception(ctx, exception, "SqliteError",
sqlite_error, NULL);
sqlite3_free(sqlite_error);
}
return seed_make_null(ctx);
}
return seed_value_from_int(ctx, rc, exception);
}
static SeedValue
seed_ffi_function_call (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue arguments[],
SeedException *exception)
{
GArgument rvalue;
GArgument *gargs;
ffi_type *rtype;
ffi_type **atypes;
gpointer *args;
int i;
ffi_cif cif;
seed_ffi_function_priv *priv = seed_object_get_private (function);
if (argument_count != priv->n_args)
{
seed_make_exception (ctx, exception, "ArgumentError", "%s expected %d arguments got %zd",
priv->name, priv->n_args, argument_count);
return seed_make_null (ctx);
}
atypes = g_alloca (sizeof (ffi_type *) * (argument_count));
args = g_alloca (sizeof (gpointer) * (argument_count));
gargs = g_alloca (sizeof (GArgument) * (argument_count));
for (i = 0; i < argument_count; i++)
{
atypes[i] = gtype_to_ffi_type (ctx, arguments[i], priv->args[i], &(gargs[i]), &args[i],exception);
}
rtype = return_type_to_ffi_type (priv->ret_val);
if (ffi_prep_cif (&cif, FFI_DEFAULT_ABI, argument_count, rtype, atypes) != FFI_OK)
g_assert_not_reached();
ffi_call (&cif, priv->symbol, &rvalue, args);
return value_from_ffi_type (ctx, priv->ret_val, &rvalue, exception);
}
SeedValue seed_mpfr_prec_round (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_rnd_t rnd;
mp_prec_t prec;
mpfr_ptr rop;
gint ret;
CHECK_ARG_COUNT("mpfr.prec_round", 2);
rop = seed_object_get_private(this_object);
prec = seed_value_to_mpfr_prec_t(ctx, args[0], exception);
rnd = seed_value_to_mpfr_rnd_t(ctx, args[1], exception);
ret = mpfr_prec_round(rop, prec, rnd);
return seed_value_from_int(ctx, ret, exception);
}
SeedValue seed_mpfr_cmp_si_2exp (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException *exception)
{
mpfr_ptr op1;
gulong op2;
mp_exp_t exp;
gint ret;
CHECK_ARG_COUNT("mpfr.cmp_si_2exp", 2);
op1 = seed_object_get_private(this_object);
if ( seed_value_is_number(ctx, args[0]) )
{
op2 = seed_value_to_ulong(ctx, args[0], exception);
}
else
{
TYPE_EXCEPTION("mpfr.cmp_si_2exp", "long int");
}
if ( seed_value_is_number(ctx, args[1]) )
{
exp = seed_value_to_mp_exp_t(ctx, args[1], exception);
}
else
{
TYPE_EXCEPTION("mpfr.cmp_si_2exp", "mp_exp_t");
}
ret = mpfr_cmp_si_2exp(op1, op2, exp);
return seed_value_from_int(ctx, ret, exception);
}
static gboolean
add_connect_funcs(SeedContext ctx,
SeedObject obj,
DBusBusType which_bus)
{
Exports *priv;
BigDBusConnectFuncs const *connect_funcs;
priv = seed_object_get_private (obj);
if (priv == NULL)
return FALSE;
if (which_bus == DBUS_BUS_SESSION) {
connect_funcs = &session_connect_funcs;
} else if (which_bus == DBUS_BUS_SYSTEM) {
connect_funcs = &system_connect_funcs;
} else
g_assert_not_reached();
priv->which_bus = which_bus;
big_dbus_add_connect_funcs_sync_notify(connect_funcs, priv);
return TRUE;
}
static SeedValue
seed_cairo_pdf_surface_set_size (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue arguments[],
SeedException *exception)
{
cairo_surface_t *surf;
gdouble x, y;
CHECK_THIS();
if (argument_count != 2)
{
EXPECTED_EXCEPTION("set_size", "2 arguments");
}
surf = seed_object_get_private (this_object);
x = seed_value_to_double (ctx, arguments[0], exception);
y = seed_value_to_double (ctx, arguments[1], exception);
cairo_pdf_surface_set_size (surf, x, y);
return seed_make_undefined (ctx);
}
void sqlite_database_finalize(SeedObject object)
{
sqlite3 *db = seed_object_get_private(object);
if (db)
sqlite3_close(db);
}
SeedValue seed_mpfr_pow (SeedContext ctx,
SeedObject function,
SeedObject this_object,
gsize argument_count,
const SeedValue args[],
SeedException * exception)
{
mpfr_rnd_t rnd;
mpfr_ptr rop, op1, op2;
gint ret;
glong iop;
gulong uiop1, uiop2;
seed_mpfr_t argt1, argt2;
/* only want 1 double argument. alternatively, could accept 2,
add those, and set from the result*/
CHECK_ARG_COUNT("mpfr.pow", 3);
rop = seed_object_get_private(this_object);
rnd = seed_value_to_mpfr_rnd_t(ctx, args[2], exception);
argt1 = seed_mpfr_arg_type(ctx, args[0], exception);
argt2 = seed_mpfr_arg_type(ctx, args[1], exception);
if ( (argt1 & argt2) == SEED_MPFR_MPFR )
{
/* both mpfr_t */
op1 = seed_object_get_private(args[0]);
op2 = seed_object_get_private(args[1]);
ret = mpfr_pow(rop, op1, op2, rnd);
}
else if ( (argt1 | argt2) == (SEED_MPFR_MPFR | SEED_MPFR_DOUBLE) )
{
/* a double and an mpfr_t. Figure out the order */
/* FIXME: is this switching ui and si bad? si_pow doesn't exist,
and it's all from double anyway */
if ( argt1 == SEED_MPFR_MPFR )
{
op1 = seed_object_get_private(args[0]);
iop = seed_value_to_long(ctx, args[1], exception);
ret = mpfr_pow_si(rop, op1, iop, rnd);
}
else
{
uiop1 = seed_value_to_ulong(ctx, args[0], exception);
op2 = seed_object_get_private(args[1]);
ret = mpfr_ui_pow(rop, uiop1, op2, rnd);
}
}
else if ( (argt1 & argt2) == SEED_MPFR_DOUBLE )
{
/* pretend both ui */
uiop1 = seed_value_to_ulong(ctx, args[0], exception);
uiop2 = seed_value_to_ulong(ctx, args[1], exception);
ret = mpfr_ui_pow_ui(rop, uiop1, uiop2, rnd);
}
else
{
TYPE_EXCEPTION("mpfr.pow", "int or unsigned int and mpfr_t");
}
return seed_value_from_int(ctx, ret, exception);
}