int
lgi_type_get_name (lua_State *L, GIBaseInfo *info)
{
GSList *list = NULL, *i;
int n = 1;
lua_pushstring (L, g_base_info_get_namespace (info));
if (g_base_info_get_type (info) == GI_INFO_TYPE_CALLBACK)
/* Avoid duplicate name for callbacks. */
info = g_base_info_get_container (info);
/* Add names on the whole path, but in reverse order. */
for (; info != NULL; info = g_base_info_get_container (info))
if (!GI_IS_TYPE_INFO (info))
list = g_slist_prepend (list, info);
for (i = list; i != NULL; i = g_slist_next (i))
{
if (g_base_info_get_type (i->data) != GI_INFO_TYPE_TYPE)
{
lua_pushstring (L, ".");
lua_pushstring (L, g_base_info_get_name (i->data));
n += 2;
}
}
g_slist_free (list);
return n;
}
static PyObject *
_wrap_g_base_info_get_container (PyGIBaseInfo *self)
{
GIBaseInfo *info;
info = g_base_info_get_container (self->info);
if (info == NULL) {
Py_RETURN_NONE;
}
return _pygi_info_new (info);
}
static gboolean
gobject_based_p(GIBaseInfo *info)
{
GIBaseInfo *container_info;
GIRegisteredTypeInfo *registered_type_info;
container_info = g_base_info_get_container(info);
if (g_base_info_get_type(container_info) != GI_INFO_TYPE_STRUCT) {
return TRUE;
}
registered_type_info = (GIRegisteredTypeInfo *)container_info;
if (g_registered_type_info_get_type_init(registered_type_info)) {
return TRUE;
}
return FALSE;
}
gchar *
_pygi_g_base_info_get_fullname (GIBaseInfo *info)
{
GIBaseInfo *container_info;
gchar *fullname;
container_info = g_base_info_get_container (info);
if (container_info != NULL) {
fullname = g_strdup_printf ("%s.%s.%s",
g_base_info_get_namespace (container_info),
g_base_info_get_name (container_info),
g_base_info_get_name (info));
} else {
fullname = g_strdup_printf ("%s.%s",
g_base_info_get_namespace (info),
g_base_info_get_name (info));
}
if (fullname == NULL) {
PyErr_NoMemory();
}
return fullname;
}
JSBool
gjs_define_fundamental_class(JSContext *context,
JSObject *in_object,
GIObjectInfo *info,
JSObject **constructor_p,
JSObject **prototype_p)
{
const char *constructor_name;
JSObject *prototype;
jsval value;
jsid js_constructor_name = JSID_VOID;
JSObject *parent_proto;
Fundamental *priv;
JSObject *constructor;
GType parent_gtype;
GType gtype;
GIFunctionInfo *constructor_info;
/* See the comment in gjs_define_object_class() for an explanation
* of how this all works; Fundamental is pretty much the same as
* Object.
*/
constructor_name = g_base_info_get_name((GIBaseInfo *) info);
constructor_info = find_fundamental_constructor(context, info,
&js_constructor_name);
gtype = g_registered_type_info_get_g_type (info);
parent_gtype = g_type_parent(gtype);
parent_proto = NULL;
if (parent_gtype != G_TYPE_INVALID)
parent_proto = gjs_lookup_fundamental_prototype_from_gtype(context,
parent_gtype);
if (!gjs_init_class_dynamic(context, in_object,
/* parent prototype JSObject* for
* prototype; NULL for
* Object.prototype
*/
parent_proto,
g_base_info_get_namespace((GIBaseInfo *) info),
constructor_name,
&gjs_fundamental_instance_class,
gjs_fundamental_instance_constructor,
/* number of constructor args (less can be passed) */
constructor_info != NULL ? g_callable_info_get_n_args((GICallableInfo *) constructor_info) : 0,
/* props of prototype */
parent_proto ? NULL : &gjs_fundamental_instance_proto_props[0],
/* funcs of prototype */
parent_proto ? NULL : &gjs_fundamental_instance_proto_funcs[0],
/* props of constructor, MyConstructor.myprop */
NULL,
/* funcs of constructor, MyConstructor.myfunc() */
NULL,
&prototype,
&constructor)) {
gjs_log_exception(context);
g_error("Can't init class %s", constructor_name);
}
/* Put the info in the prototype */
priv = g_slice_new0(Fundamental);
g_assert(priv != NULL);
g_assert(priv->info == NULL);
priv->info = g_base_info_ref((GIBaseInfo *) info);
priv->gtype = gtype;
priv->constructor_name = js_constructor_name;
priv->constructor_info = constructor_info;
priv->ref_function = g_object_info_get_ref_function_pointer(info);
g_assert(priv->ref_function != NULL);
priv->unref_function = g_object_info_get_unref_function_pointer(info);
g_assert(priv->unref_function != NULL);
priv->set_value_function = g_object_info_get_set_value_function_pointer(info);
g_assert(priv->set_value_function != NULL);
priv->get_value_function = g_object_info_get_get_value_function_pointer(info);
g_assert(priv->get_value_function != NULL);
JS_SetPrivate(prototype, priv);
gjs_debug(GJS_DEBUG_GFUNDAMENTAL,
"Defined class %s prototype is %p class %p in object %p constructor %s.%s.%s",
constructor_name, prototype, JS_GetClass(prototype),
in_object,
constructor_info != NULL ? g_base_info_get_namespace(constructor_info) : "unknown",
constructor_info != NULL ? g_base_info_get_name(g_base_info_get_container(constructor_info)) : "unknown",
constructor_info != NULL ? g_base_info_get_name(constructor_info) : "unknown");
if (g_object_info_get_n_fields(priv->info) > 0) {
gjs_debug(GJS_DEBUG_GFUNDAMENTAL,
"Fundamental type '%s.%s' apparently has accessible fields. "
"Gjs has no support for this yet, ignoring these.",
g_base_info_get_namespace((GIBaseInfo *)priv->info),
g_base_info_get_name ((GIBaseInfo *)priv->info));
}
gjs_object_define_static_methods(context, constructor, gtype, info);
value = OBJECT_TO_JSVAL(gjs_gtype_create_gtype_wrapper(context, gtype));
JS_DefineProperty(context, constructor, "$gtype", value,
NULL, NULL, JSPROP_PERMANENT);
if (constructor_p)
*constructor_p = constructor;
if (prototype_p)
*prototype_p = prototype;
return JS_TRUE;
}
static PyObject *
_wrap_g_field_info_set_value (PyGIBaseInfo *self,
PyObject *args)
{
PyObject *instance;
PyObject *py_value;
GIBaseInfo *container_info;
GIInfoType container_info_type;
gpointer pointer;
GITypeInfo *field_type_info;
GIArgument value;
PyObject *retval = NULL;
if (!PyArg_ParseTuple (args, "OO:FieldInfo.set_value", &instance, &py_value)) {
return NULL;
}
container_info = g_base_info_get_container (self->info);
g_assert (container_info != NULL);
/* Check the instance. */
if (!_pygi_g_registered_type_info_check_object ( (GIRegisteredTypeInfo *) container_info, TRUE, instance)) {
_PyGI_ERROR_PREFIX ("argument 1: ");
return NULL;
}
/* Get the pointer to the container. */
container_info_type = g_base_info_get_type (container_info);
switch (container_info_type) {
case GI_INFO_TYPE_UNION:
case GI_INFO_TYPE_STRUCT:
pointer = pyg_boxed_get (instance, void);
break;
case GI_INFO_TYPE_OBJECT:
pointer = pygobject_get (instance);
break;
default:
/* Other types don't have fields. */
g_assert_not_reached();
}
field_type_info = g_field_info_get_type ( (GIFieldInfo *) self->info);
/* Check the value. */
{
gboolean retval;
retval = _pygi_g_type_info_check_object (field_type_info, py_value, TRUE);
if (retval < 0) {
goto out;
}
if (!retval) {
_PyGI_ERROR_PREFIX ("argument 2: ");
goto out;
}
}
/* Set the field's value. */
/* A few types are not handled by g_field_info_set_field, so do it here. */
if (!g_type_info_is_pointer (field_type_info)
&& g_type_info_get_tag (field_type_info) == GI_TYPE_TAG_INTERFACE) {
GIBaseInfo *info;
GIInfoType info_type;
if (! (g_field_info_get_flags ( (GIFieldInfo *) self->info) & GI_FIELD_IS_WRITABLE)) {
PyErr_SetString (PyExc_RuntimeError, "field is not writable");
goto out;
}
info = g_type_info_get_interface (field_type_info);
info_type = g_base_info_get_type (info);
switch (info_type) {
case GI_INFO_TYPE_UNION:
PyErr_SetString (PyExc_NotImplementedError, "setting an union is not supported yet");
goto out;
case GI_INFO_TYPE_STRUCT:
{
gboolean is_simple;
gsize offset;
gssize size;
is_simple = pygi_g_struct_info_is_simple ( (GIStructInfo *) info);
if (!is_simple) {
PyErr_SetString (PyExc_TypeError,
"cannot set a structure which has no well-defined ownership transfer rules");
g_base_info_unref (info);
goto out;
}
value = _pygi_argument_from_object (py_value, field_type_info, GI_TRANSFER_NOTHING);
if (PyErr_Occurred()) {
g_base_info_unref (info);
goto out;
}
offset = g_field_info_get_offset ( (GIFieldInfo *) self->info);
size = g_struct_info_get_size ( (GIStructInfo *) info);
g_assert (size > 0);
g_memmove ((char*) pointer + offset, value.v_pointer, size);
g_base_info_unref (info);
retval = Py_None;
goto out;
}
default:
/* Fallback. */
break;
}
g_base_info_unref (info);
} else if (g_type_info_is_pointer (field_type_info)
&& g_type_info_get_tag (field_type_info) == GI_TYPE_TAG_VOID) {
int offset;
if (py_value != Py_None && !PYGLIB_PyLong_Check(py_value)) {
if (PyErr_WarnEx(PyExc_RuntimeWarning,
"Usage of gpointers to store objects is being deprecated. "
"Please use integer values only, see: https://bugzilla.gnome.org/show_bug.cgi?id=683599",
1))
goto out;
}
offset = g_field_info_get_offset ((GIFieldInfo *) self->info);
value = _pygi_argument_from_object (py_value, field_type_info, GI_TRANSFER_NOTHING);
/* Decrement the previous python object stashed on the void pointer.
* This seems somewhat dangerous as the code is blindly assuming any
* void pointer field stores a python object pointer and then decrefs it.
* This is essentially the same as something like:
* Py_XDECREF(struct->void_ptr); */
Py_XDECREF(G_STRUCT_MEMBER (gpointer, pointer, offset));
/* Assign and increment the newly assigned object. At this point the value
* arg will hold a pointer the python object "py_value" or NULL.
* This is essentially:
* struct->void_ptr = value.v_pointer;
* Py_XINCREF(struct->void_ptr);
*/
G_STRUCT_MEMBER (gpointer, pointer, offset) = (gpointer)value.v_pointer;
Py_XINCREF(G_STRUCT_MEMBER (gpointer, pointer, offset));
retval = Py_None;
goto out;
}
value = _pygi_argument_from_object (py_value, field_type_info, GI_TRANSFER_EVERYTHING);
if (PyErr_Occurred()) {
goto out;
}
if (!g_field_info_set_field ( (GIFieldInfo *) self->info, pointer, &value)) {
_pygi_argument_release (&value, field_type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
PyErr_SetString (PyExc_RuntimeError, "unable to set value for field");
goto out;
}
retval = Py_None;
out:
g_base_info_unref ( (GIBaseInfo *) field_type_info);
Py_XINCREF (retval);
return retval;
}
static PyObject *
_wrap_g_field_info_get_value (PyGIBaseInfo *self,
PyObject *args)
{
PyObject *instance;
GIBaseInfo *container_info;
GIInfoType container_info_type;
gpointer pointer;
GITypeInfo *field_type_info;
GIArgument value;
PyObject *py_value = NULL;
gboolean free_array = FALSE;
memset(&value, 0, sizeof(GIArgument));
if (!PyArg_ParseTuple (args, "O:FieldInfo.get_value", &instance)) {
return NULL;
}
container_info = g_base_info_get_container (self->info);
g_assert (container_info != NULL);
/* Check the instance. */
if (!_pygi_g_registered_type_info_check_object ( (GIRegisteredTypeInfo *) container_info, TRUE, instance)) {
_PyGI_ERROR_PREFIX ("argument 1: ");
return NULL;
}
/* Get the pointer to the container. */
container_info_type = g_base_info_get_type (container_info);
switch (container_info_type) {
case GI_INFO_TYPE_UNION:
case GI_INFO_TYPE_STRUCT:
pointer = pyg_boxed_get (instance, void);
break;
case GI_INFO_TYPE_OBJECT:
pointer = pygobject_get (instance);
break;
default:
/* Other types don't have fields. */
g_assert_not_reached();
}
/* Get the field's value. */
field_type_info = g_field_info_get_type ( (GIFieldInfo *) self->info);
/* A few types are not handled by g_field_info_get_field, so do it here. */
if (!g_type_info_is_pointer (field_type_info)
&& g_type_info_get_tag (field_type_info) == GI_TYPE_TAG_INTERFACE) {
GIBaseInfo *info;
GIInfoType info_type;
if (! (g_field_info_get_flags ( (GIFieldInfo *) self->info) & GI_FIELD_IS_READABLE)) {
PyErr_SetString (PyExc_RuntimeError, "field is not readable");
goto out;
}
info = g_type_info_get_interface (field_type_info);
info_type = g_base_info_get_type (info);
g_base_info_unref (info);
switch (info_type) {
case GI_INFO_TYPE_UNION:
PyErr_SetString (PyExc_NotImplementedError, "getting an union is not supported yet");
goto out;
case GI_INFO_TYPE_STRUCT:
{
gsize offset;
offset = g_field_info_get_offset ( (GIFieldInfo *) self->info);
value.v_pointer = (char*) pointer + offset;
goto argument_to_object;
}
default:
/* Fallback. */
break;
}
}
if (!g_field_info_get_field ( (GIFieldInfo *) self->info, pointer, &value)) {
PyErr_SetString (PyExc_RuntimeError, "unable to get the value");
goto out;
}
if (g_type_info_get_tag (field_type_info) == GI_TYPE_TAG_ARRAY) {
value.v_pointer = _pygi_argument_to_array (&value, NULL, NULL,
field_type_info, &free_array);
}
argument_to_object:
py_value = _pygi_argument_to_object (&value, field_type_info, GI_TRANSFER_NOTHING);
if (free_array) {
g_array_free (value.v_pointer, FALSE);
}
out:
g_base_info_unref ( (GIBaseInfo *) field_type_info);
return py_value;
}
int
lgi_marshal_field (lua_State *L, gpointer object, gboolean getmode,
int parent_arg, int field_arg, int val_arg)
{
GITypeInfo *ti;
int to_remove, nret;
/* Check the type of the field information. */
if (lgi_udata_test (L, field_arg, LGI_GI_INFO))
{
GIFieldInfo **fi = lua_touserdata (L, field_arg);
GIFieldInfoFlags flags;
/* Check, whether field is readable/writable. */
flags = g_field_info_get_flags (*fi);
if ((flags & (getmode ? GI_FIELD_IS_READABLE
: GI_FIELD_IS_WRITABLE)) == 0)
{
/* Check, whether parent did not disable access checks
completely. */
lua_getfield (L, -1, "_allow");
if (!lua_toboolean (L, -1))
{
/* Prepare proper error message. */
lua_concat (L,
lgi_type_get_name (L,
g_base_info_get_container (*fi)));
return luaL_error (L, "%s: field `%s' is not %s",
lua_tostring (L, -1),
g_base_info_get_name (*fi),
getmode ? "readable" : "writable");
}
lua_pop (L, 1);
}
/* Map GIArgument to proper memory location, get typeinfo of the
field and perform actual marshalling. */
object = (char *) object + g_field_info_get_offset (*fi);
ti = g_field_info_get_type (*fi);
lgi_gi_info_new (L, ti);
to_remove = lua_gettop (L);
}
else
{
/* Consult field table, get kind of field and offset. */
int kind;
lgi_makeabs (L, field_arg);
luaL_checktype (L, field_arg, LUA_TTABLE);
lua_rawgeti (L, field_arg, 1);
object = (char *) object + lua_tointeger (L, -1);
lua_rawgeti (L, field_arg, 2);
kind = lua_tonumber (L, -1);
lua_pop (L, 2);
/* Load type information from the table and decide how to handle
it according to 'kind' */
lua_rawgeti (L, field_arg, 3);
switch (kind)
{
case 0:
/* field[3] contains typeinfo, load it and fall through. */
ti = *(GITypeInfo **) luaL_checkudata (L, -1, LGI_GI_INFO);
to_remove = lua_gettop (L);
break;
case 1:
case 2:
{
GIArgument *arg = (GIArgument *) object;
if (getmode)
{
if (kind == 1)
{
object = arg->v_pointer;
parent_arg = 0;
}
lgi_record_2lua (L, object, FALSE, parent_arg);
return 1;
}
else
{
g_assert (kind == 1);
lgi_record_2c (L, val_arg, arg->v_pointer,
FALSE, TRUE, FALSE, FALSE);
return 0;
}
break;
}
case 3:
{
/* Get the typeinfo for marshalling the numeric enum value. */
lua_rawgeti (L, field_arg, 4);
ti = *(GITypeInfo **) luaL_checkudata (L, -1, LGI_GI_INFO);
if (getmode)
{
/* Use typeinfo to unmarshal numeric value. */
lgi_marshal_2lua (L, ti, NULL, GI_DIRECTION_OUT,
GI_TRANSFER_NOTHING, object, 0,
NULL, NULL);
/* Replace numeric field with symbolic value. */
lua_gettable (L, -3);
lua_replace (L, -3);
lua_pop (L, 1);
return 1;
}
else
{
/* Convert enum symbol to numeric value. */
if (lua_type (L, val_arg != LUA_TNUMBER))
{
lua_pushvalue (L, -1);
lua_pushvalue (L, val_arg);
lua_call (L, 1, 1);
lua_replace (L, val_arg);
}
/* Use typeinfo to marshal the numeric value. */
lgi_marshal_2c (L, ti, NULL, GI_TRANSFER_NOTHING, object,
val_arg, 0, NULL, NULL);
lua_pop (L, 2);
return 0;
}
}
default:
return luaL_error (L, "field has bad kind %d", kind);
}
}
if (getmode)
{
lgi_marshal_2lua (L, ti, NULL, GI_DIRECTION_OUT, GI_TRANSFER_NOTHING,
object, parent_arg, NULL, NULL);
nret = 1;
}
else
{
lgi_marshal_2c (L, ti, NULL, GI_TRANSFER_EVERYTHING, object, val_arg,
0, NULL, NULL);
nret = 0;
}
lua_remove (L, to_remove);
return nret;
}
static PyObject *
_wrap_g_field_info_set_value (PyGIBaseInfo *self,
PyObject *args)
{
PyObject *instance;
PyObject *py_value;
GIBaseInfo *container_info;
GIInfoType container_info_type;
gpointer pointer;
GITypeInfo *field_type_info;
GIArgument value;
PyObject *retval = NULL;
if (!PyArg_ParseTuple (args, "OO:FieldInfo.set_value", &instance, &py_value)) {
return NULL;
}
container_info = g_base_info_get_container (self->info);
g_assert (container_info != NULL);
/* Check the instance. */
if (!_pygi_g_registered_type_info_check_object ( (GIRegisteredTypeInfo *) container_info, TRUE, instance)) {
_PyGI_ERROR_PREFIX ("argument 1: ");
return NULL;
}
/* Get the pointer to the container. */
container_info_type = g_base_info_get_type (container_info);
switch (container_info_type) {
case GI_INFO_TYPE_UNION:
case GI_INFO_TYPE_STRUCT:
pointer = pyg_boxed_get (instance, void);
break;
case GI_INFO_TYPE_OBJECT:
pointer = pygobject_get (instance);
break;
default:
/* Other types don't have fields. */
g_assert_not_reached();
}
field_type_info = g_field_info_get_type ( (GIFieldInfo *) self->info);
/* Check the value. */
{
gboolean retval;
retval = _pygi_g_type_info_check_object (field_type_info, py_value, TRUE);
if (retval < 0) {
goto out;
}
if (!retval) {
_PyGI_ERROR_PREFIX ("argument 2: ");
goto out;
}
}
/* Set the field's value. */
/* A few types are not handled by g_field_info_set_field, so do it here. */
if (!g_type_info_is_pointer (field_type_info)
&& g_type_info_get_tag (field_type_info) == GI_TYPE_TAG_INTERFACE) {
GIBaseInfo *info;
GIInfoType info_type;
if (! (g_field_info_get_flags ( (GIFieldInfo *) self->info) & GI_FIELD_IS_WRITABLE)) {
PyErr_SetString (PyExc_RuntimeError, "field is not writable");
goto out;
}
info = g_type_info_get_interface (field_type_info);
info_type = g_base_info_get_type (info);
switch (info_type) {
case GI_INFO_TYPE_UNION:
PyErr_SetString (PyExc_NotImplementedError, "setting an union is not supported yet");
goto out;
case GI_INFO_TYPE_STRUCT:
{
gboolean is_simple;
gsize offset;
gssize size;
is_simple = pygi_g_struct_info_is_simple ( (GIStructInfo *) info);
if (!is_simple) {
PyErr_SetString (PyExc_TypeError,
"cannot set a structure which has no well-defined ownership transfer rules");
g_base_info_unref (info);
goto out;
}
value = _pygi_argument_from_object (py_value, field_type_info, GI_TRANSFER_NOTHING);
if (PyErr_Occurred()) {
g_base_info_unref (info);
goto out;
}
offset = g_field_info_get_offset ( (GIFieldInfo *) self->info);
size = g_struct_info_get_size ( (GIStructInfo *) info);
g_assert (size > 0);
g_memmove (pointer + offset, value.v_pointer, size);
g_base_info_unref (info);
retval = Py_None;
goto out;
}
default:
/* Fallback. */
break;
}
g_base_info_unref (info);
}
value = _pygi_argument_from_object (py_value, field_type_info, GI_TRANSFER_EVERYTHING);
if (PyErr_Occurred()) {
goto out;
}
if (!g_field_info_set_field ( (GIFieldInfo *) self->info, pointer, &value)) {
_pygi_argument_release (&value, field_type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
PyErr_SetString (PyExc_RuntimeError, "unable to set value for field");
goto out;
}
retval = Py_None;
out:
g_base_info_unref ( (GIBaseInfo *) field_type_info);
Py_XINCREF (retval);
return retval;
}
