PyObject * _pygi_marshal_to_py_unichar (PyGIInvokeState *state, PyGICallableCache *callable_cache, PyGIArgCache *arg_cache, GIArgument *arg) { PyObject *py_obj = NULL; /* Preserve the bidirectional mapping between 0 and "" */ if (arg->v_uint32 == 0) { py_obj = PYGLIB_PyUnicode_FromString (""); } else if (g_unichar_validate (arg->v_uint32)) { gchar utf8[6]; gint bytes; bytes = g_unichar_to_utf8 (arg->v_uint32, utf8); py_obj = PYGLIB_PyUnicode_FromStringAndSize ((char*)utf8, bytes); } else { /* TODO: Convert the error to an exception. */ PyErr_Format (PyExc_TypeError, "Invalid unicode codepoint %" G_GUINT32_FORMAT, arg->v_uint32); } return py_obj; }
static PyObject * _wrap_g_irepository_get_dependencies (PyGIRepository *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "namespace", NULL }; const char *namespace_; char **namespaces; PyObject *py_namespaces; gssize i; if (!PyArg_ParseTupleAndKeywords (args, kwargs, "s:Repository.get_dependencies", kwlist, &namespace_)) { return NULL; } py_namespaces = PyList_New (0); /* Returns NULL in case of no dependencies */ namespaces = g_irepository_get_dependencies (self->repository, namespace_); if (namespaces == NULL) { return py_namespaces; } for (i = 0; namespaces[i] != NULL; i++) { PyObject *py_namespace = PYGLIB_PyUnicode_FromString (namespaces[i]); PyList_Append (py_namespaces, py_namespace); Py_DECREF(py_namespace); } g_strfreev (namespaces); return py_namespaces; }
static PyObject * _wrap_g_irepository_enumerate_versions (PyGIRepository *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "namespace", NULL }; const char *namespace_; GList *versions, *item; PyObject *ret = NULL; if (!PyArg_ParseTupleAndKeywords (args, kwargs, "s:Repository.enumerate_versions", kwlist, &namespace_)) { return NULL; } versions = g_irepository_enumerate_versions (self->repository, namespace_); ret = PyList_New(0); for (item = versions; item; item = item->next) { char *version = item->data; PyObject *py_version = PYGLIB_PyUnicode_FromString (version); PyList_Append(ret, py_version); Py_DECREF(py_version); g_free (version); } g_list_free(versions); return ret; }
PyObject * _pygi_marshal_to_py_filename (PyGIInvokeState *state, PyGICallableCache *callable_cache, PyGIArgCache *arg_cache, GIArgument *arg) { gchar *string; PyObject *py_obj = NULL; GError *error = NULL; if (arg->v_string == NULL) { py_obj = Py_None; Py_INCREF (py_obj); return py_obj; } string = g_filename_to_utf8 (arg->v_string, -1, NULL, NULL, &error); if (string == NULL) { PyErr_SetString (PyExc_Exception, error->message); /* TODO: Convert the error to an exception. */ return NULL; } py_obj = PYGLIB_PyUnicode_FromString (string); g_free (string); return py_obj; }
/** * Extends __dir__ with the extra attributes accessible through * resulttuple_getattro() */ static PyObject * resulttuple_dir(PyObject *self) { PyObject *mapping_attr; PyObject *items = NULL; PyObject *mapping = NULL; PyObject *mapping_values = NULL; PyObject *result = NULL; mapping_attr = PYGLIB_PyUnicode_FromString (tuple_indices_key); mapping = PyTuple_Type.tp_getattro (self, mapping_attr); Py_DECREF (mapping_attr); if (mapping == NULL) goto error; items = PyObject_Dir ((PyObject*)self->ob_type); if (items == NULL) goto error; mapping_values = PyDict_Keys (mapping); if (mapping_values == NULL) goto error; result = PySequence_InPlaceConcat (items, mapping_values); error: Py_XDECREF (items); Py_XDECREF (mapping); Py_XDECREF (mapping_values); return result; }
static PyObject * pyg_enum_repr(PyGEnum *self) { GEnumClass *enum_class; const char *value; guint index; static char tmp[256]; long l; enum_class = g_type_class_ref(self->gtype); g_assert(G_IS_ENUM_CLASS(enum_class)); l = PYGLIB_PyLong_AS_LONG(self); for (index = 0; index < enum_class->n_values; index++) if (l == enum_class->values[index].value) break; value = enum_class->values[index].value_name; if (value) sprintf(tmp, "<enum %s of type %s>", value, g_type_name(self->gtype)); else sprintf(tmp, "<enum %ld of type %s>", PYGLIB_PyLong_AS_LONG(self), g_type_name(self->gtype)); g_type_class_unref(enum_class); return PYGLIB_PyUnicode_FromString(tmp); }
static PyObject * pyg_type_wrapper_repr(PyGTypeWrapper *self) { char buf[80]; const gchar *name = g_type_name(self->type); g_snprintf(buf, sizeof(buf), "<GType %s (%lu)>", name?name:"invalid", (unsigned long int) self->type); return PYGLIB_PyUnicode_FromString(buf); }
static PyObject * _pygi_marshal_to_py_utf8 (GIArgument *arg) { PyObject *py_obj = NULL; if (arg->v_string == NULL) { Py_RETURN_NONE; } py_obj = PYGLIB_PyUnicode_FromString (arg->v_string); return py_obj; }
static PyObject * _wrap_g_base_info_get_name (PyGIBaseInfo *self) { /* It may be better to use keyword.iskeyword(); keep in sync with * python -c 'import keyword; print(keyword.kwlist)' */ #if PY_VERSION_HEX < 0x03000000 /* Python 2.x */ static const gchar* keywords[] = {"and", "as", "assert", "break", "class", "continue", "def", "del", "elif", "else", "except", "exec", "finally", "for", "from", "global", "if", "import", "in", "is", "lambda", "not", "or", "pass", "print", "raise", "return", "try", "while", "with", "yield", NULL}; #elif PY_VERSION_HEX < 0x04000000 /* Python 3.x; note that we explicitly keep "print"; it is not a keyword * any more, but we do not want to break API between Python versions */ static const gchar* keywords[] = {"False", "None", "True", "and", "as", "assert", "break", "class", "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global", "if", "import", "in", "is", "lambda", "nonlocal", "not", "or", "pass", "raise", "return", "try", "while", "with", "yield", "print", NULL}; #else #error Need keyword list for this major Python version #endif const gchar *name, **i; name = g_base_info_get_name (self->info); /* escape keywords */ for (i = keywords; *i != NULL; ++i) { if (strcmp (name, *i) == 0) { gchar *escaped = g_strconcat (name, "_", NULL); PyObject *obj = PYGLIB_PyUnicode_FromString (escaped); g_free (escaped); return obj; } } return PYGLIB_PyUnicode_FromString (name); }
static PyObject * _wrap_constant_strip_prefix(PyObject *self, PyObject *args) { const char *name, *strip_prefix; const gchar *result; if (!PyArg_ParseTuple (args, "ss", &name, &strip_prefix)) return NULL; result = pyg_constant_strip_prefix (name, strip_prefix); return PYGLIB_PyUnicode_FromString (result); }
/** * ResultTuple.__repr__() implementation. * Takes the _ResultTuple.__repr_format format string and applies the tuple * values to it. */ static PyObject* resulttuple_repr(PyObject *self) { PyObject *format, *repr, *format_attr; format_attr = PYGLIB_PyUnicode_FromString (repr_format_key); format = PyTuple_Type.tp_getattro (self, format_attr); Py_DECREF (format_attr); if (format == NULL) return NULL; repr = PYGLIB_PyUnicode_Format (format, self); Py_DECREF (format); return repr; }
PyObject * _pygi_marshal_to_py_utf8 (PyGIInvokeState *state, PyGICallableCache *callable_cache, PyGIArgCache *arg_cache, GIArgument *arg) { PyObject *py_obj = NULL; if (arg->v_string == NULL) { py_obj = Py_None; Py_INCREF (py_obj); return py_obj; } py_obj = PYGLIB_PyUnicode_FromString (arg->v_string); return py_obj; }
static PyObject * pyg_flags_repr(PyGFlags *self) { char *tmp, *retval; PyObject *pyretval; tmp = generate_repr(self->gtype, PYGLIB_PyLong_AS_LONG(self)); if (tmp) retval = g_strdup_printf("<flags %s of type %s>", tmp, g_type_name(self->gtype)); else retval = g_strdup_printf("<flags %ld of type %s>", PYGLIB_PyLong_AS_LONG(self), g_type_name(self->gtype)); g_free(tmp); pyretval = PYGLIB_PyUnicode_FromString(retval); g_free(retval); return pyretval; }
static PyObject * _wrap_g_irepository_get_loaded_namespaces (PyGIRepository *self) { char **namespaces; PyObject *py_namespaces; gssize i; namespaces = g_irepository_get_loaded_namespaces (self->repository); py_namespaces = PyList_New (0); for (i = 0; namespaces[i] != NULL; i++) { PyObject *py_namespace = PYGLIB_PyUnicode_FromString (namespaces[i]); PyList_Append (py_namespaces, py_namespace); Py_DECREF(py_namespace); g_free (namespaces[i]); } g_free (namespaces); return py_namespaces; }
/** * PyGIResultTuple_Type.tp_getattro implementation. * Looks up the tuple index in _ResultTuple.__tuple_indices and returns the * tuple item. */ static PyObject* resulttuple_getattro(PyObject *self, PyObject *name) { PyObject *mapping, *index, *mapping_attr, *item; mapping_attr = PYGLIB_PyUnicode_FromString (tuple_indices_key); mapping = PyTuple_Type.tp_getattro (self, mapping_attr); Py_DECREF (mapping_attr); if (mapping == NULL) return NULL; g_assert (PyDict_Check (mapping)); index = PyDict_GetItem (mapping, name); if (index != NULL) { item = PyTuple_GET_ITEM (self, PYGLIB_PyLong_AsSsize_t (index)); Py_INCREF (item); } else { item = PyTuple_Type.tp_getattro (self, name); } Py_DECREF (mapping); return item; }
static PyObject * _wrap_g_irepository_get_version (PyGIRepository *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "namespace", NULL }; const char *namespace_; const gchar *version; if (!PyArg_ParseTupleAndKeywords (args, kwargs, "s:Repository.get_version", kwlist, &namespace_)) { return NULL; } version = g_irepository_get_version (self->repository, namespace_); if (version == NULL) { PyErr_Format (PyExc_RuntimeError, "Namespace '%s' not loaded", namespace_); return NULL; } return PYGLIB_PyUnicode_FromString (version); }
static PyObject * _pygi_marshal_to_py_filename (GIArgument *arg) { gchar *string = NULL; PyObject *py_obj = NULL; GError *error = NULL; if (arg->v_string == NULL) { Py_RETURN_NONE; } string = g_filename_to_utf8 (arg->v_string, -1, NULL, NULL, &error); if (string == NULL) { PyErr_SetString (PyExc_Exception, error->message); /* TODO: Convert the error to an exception. */ return NULL; } py_obj = PYGLIB_PyUnicode_FromString (string); g_free (string); return py_obj; }
static PyObject * _wrap_g_base_info_get_namespace (PyGIBaseInfo *self) { return PYGLIB_PyUnicode_FromString (g_base_info_get_namespace (self->info)); }
/** * pyg_value_as_pyobject: * @value: the GValue object. * @copy_boxed: true if boxed values should be copied. * * This function creates/returns a Python wrapper object that * represents the GValue passed as an argument. * * Returns: a PyObject representing the value. */ PyObject * pyg_value_as_pyobject(const GValue *value, gboolean copy_boxed) { gchar buf[128]; switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { case G_TYPE_INTERFACE: if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) return pygobject_new(g_value_get_object(value)); else break; case G_TYPE_CHAR: { gint8 val = g_value_get_char(value); return PYGLIB_PyUnicode_FromStringAndSize((char *)&val, 1); } case G_TYPE_UCHAR: { guint8 val = g_value_get_uchar(value); return PYGLIB_PyBytes_FromStringAndSize((char *)&val, 1); } case G_TYPE_BOOLEAN: { return PyBool_FromLong(g_value_get_boolean(value)); } case G_TYPE_INT: return PYGLIB_PyLong_FromLong(g_value_get_int(value)); case G_TYPE_UINT: { /* in Python, the Int object is backed by a long. If a long can hold the whole value of an unsigned int, use an Int. Otherwise, use a Long object to avoid overflow. This matches the ULongArg behavior in codegen/argtypes.h */ #if (G_MAXUINT <= G_MAXLONG) return PYGLIB_PyLong_FromLong((glong) g_value_get_uint(value)); #else return PyLong_FromUnsignedLong((gulong) g_value_get_uint(value)); #endif } case G_TYPE_LONG: return PYGLIB_PyLong_FromLong(g_value_get_long(value)); case G_TYPE_ULONG: { gulong val = g_value_get_ulong(value); if (val <= G_MAXLONG) return PYGLIB_PyLong_FromLong((glong) val); else return PyLong_FromUnsignedLong(val); } case G_TYPE_INT64: { gint64 val = g_value_get_int64(value); if (G_MINLONG <= val && val <= G_MAXLONG) return PYGLIB_PyLong_FromLong((glong) val); else return PyLong_FromLongLong(val); } case G_TYPE_UINT64: { guint64 val = g_value_get_uint64(value); if (val <= G_MAXLONG) return PYGLIB_PyLong_FromLong((glong) val); else return PyLong_FromUnsignedLongLong(val); } case G_TYPE_ENUM: return pyg_enum_from_gtype(G_VALUE_TYPE(value), g_value_get_enum(value)); case G_TYPE_FLAGS: return pyg_flags_from_gtype(G_VALUE_TYPE(value), g_value_get_flags(value)); case G_TYPE_FLOAT: return PyFloat_FromDouble(g_value_get_float(value)); case G_TYPE_DOUBLE: return PyFloat_FromDouble(g_value_get_double(value)); case G_TYPE_STRING: { const gchar *str = g_value_get_string(value); if (str) return PYGLIB_PyUnicode_FromString(str); Py_INCREF(Py_None); return Py_None; } case G_TYPE_POINTER: return pyg_pointer_new(G_VALUE_TYPE(value), g_value_get_pointer(value)); case G_TYPE_BOXED: { PyGTypeMarshal *bm; if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT)) { PyObject *ret = (PyObject *)g_value_dup_boxed(value); if (ret == NULL) { Py_INCREF(Py_None); return Py_None; } return ret; } else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) { GValue *n_value = g_value_get_boxed (value); return pyg_value_as_pyobject(n_value, copy_boxed); } else if (G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY)) { GValueArray *array = (GValueArray *) g_value_get_boxed(value); PyObject *ret = PyList_New(array->n_values); int i; for (i = 0; i < array->n_values; ++i) PyList_SET_ITEM(ret, i, pyg_value_as_pyobject (array->values + i, copy_boxed)); return ret; } else if (G_VALUE_HOLDS(value, G_TYPE_GSTRING)) { GString *string = (GString *) g_value_get_boxed(value); PyObject *ret = PYGLIB_PyUnicode_FromStringAndSize(string->str, string->len); return ret; } bm = pyg_type_lookup(G_VALUE_TYPE(value)); if (bm) { return bm->fromvalue(value); } else { if (copy_boxed) return pyg_boxed_new(G_VALUE_TYPE(value), g_value_get_boxed(value), TRUE, TRUE); else return pyg_boxed_new(G_VALUE_TYPE(value), g_value_get_boxed(value),FALSE,FALSE); } } case G_TYPE_PARAM: return pyg_param_spec_new(g_value_get_param(value)); case G_TYPE_OBJECT: return pygobject_new(g_value_get_object(value)); default: { PyGTypeMarshal *bm; if ((bm = pyg_type_lookup(G_VALUE_TYPE(value)))) return bm->fromvalue(value); break; } } g_snprintf(buf, sizeof(buf), "unknown type %s", g_type_name(G_VALUE_TYPE(value))); PyErr_SetString(PyExc_TypeError, buf); return NULL; }
/** * pygi_resulttuple_new_type: * @tuple_names: A python list containing str or None items. * * Similar to namedtuple() creates a new tuple subclass which * allows to access items by name and have a pretty __repr__. * Each item in the passed name list corresponds to an item with * the same index in the tuple class. If the name is None the item/index * is unnamed. * * Returns: A new PyTypeObject which is a subclass of PyGIResultTuple_Type * or %NULL in case of an error. */ PyTypeObject* pygi_resulttuple_new_type(PyObject *tuple_names) { PyTypeObject *new_type; PyObject *class_dict, *format_string, *empty_format, *named_format, *format_list, *sep, *index_dict, *slots, *paren_format, *new_type_args, *paren_string; Py_ssize_t len, i; g_assert (PyList_Check (tuple_names)); class_dict = PyDict_New (); /* To save some memory don't use an instance dict */ slots = PyTuple_New (0); PyDict_SetItemString (class_dict, "__slots__", slots); Py_DECREF (slots); format_list = PyList_New (0); index_dict = PyDict_New (); empty_format = PYGLIB_PyUnicode_FromString ("%r"); named_format = PYGLIB_PyUnicode_FromString ("%s=%%r"); len = PyList_Size (tuple_names); for (i = 0; i < len; i++) { PyObject *item, *named_args, *named_build, *index; item = PyList_GET_ITEM (tuple_names, i); if (item == Py_None) { PyList_Append (format_list, empty_format); } else { named_args = Py_BuildValue ("(O)", item); named_build = PYGLIB_PyUnicode_Format (named_format, named_args); Py_DECREF (named_args); PyList_Append (format_list, named_build); Py_DECREF (named_build); index = PYGLIB_PyLong_FromSsize_t (i); PyDict_SetItem (index_dict, item, index); Py_DECREF (index); } } Py_DECREF (empty_format); Py_DECREF (named_format); sep = PYGLIB_PyUnicode_FromString (", "); format_string = PyObject_CallMethod (sep, "join", "O", format_list); Py_DECREF (sep); Py_DECREF (format_list); paren_format = PYGLIB_PyUnicode_FromString ("(%s)"); paren_string = PYGLIB_PyUnicode_Format (paren_format, format_string); Py_DECREF (paren_format); Py_DECREF (format_string); PyDict_SetItemString (class_dict, repr_format_key, paren_string); Py_DECREF (paren_string); PyDict_SetItemString (class_dict, tuple_indices_key, index_dict); Py_DECREF (index_dict); new_type_args = Py_BuildValue ("s(O)O", "_ResultTuple", &PyGIResultTuple_Type, class_dict); new_type = (PyTypeObject *)PyType_Type.tp_new (&PyType_Type, new_type_args, NULL); Py_DECREF (new_type_args); Py_DECREF (class_dict); if (new_type != NULL) { /* disallow subclassing as that would break the free list caching * since we assume that all subclasses use PyTupleObject */ new_type->tp_flags &= ~Py_TPFLAGS_BASETYPE; } return new_type; }
static PyObject * _wrap_g_type_wrapper__get_name(PyGTypeWrapper *self, void *closure) { const char *name = g_type_name(self->type); return PYGLIB_PyUnicode_FromString(name ? name : "invalid"); }