DBus Micropython Module

dbus_pp.h

#define __extension__
#define __attribute__(x)
#define __builtin_va_list void*
#define __restrict 
#define __inline 
#define __asm__(x)

#include <dbus/dbus.h>       // for dbus_*   
#include <dbus/dbus-glib.h>  // for dbus_g_*

dbusmod.c

/*
 * Auto-Generated file, DO NOT EDIT!
 *
 * Command line:
 * /home/amirgon/esp/projects/lv_mpy/lib/lv_bindings/gen/gen_mpy.py -M dbus -MD dbusmod.json -I~/esp/projects/lv_mpy/lib/lv_bindings/pycparser/utils/fake_libc_include -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include/ dbus_pp.h
 *
 * Preprocessing command:
 * gcc -E -std=c99 -DPYCPARSER  -I ~/esp/projects/lv_mpy/lib/lv_bindings/pycparser/utils/fake_libc_include -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include/ -include dbus_pp.h dbus_pp.h
 *
 * Generating Objects: 
 */

/*
 * Mpy includes
 */

#include <stdlib.h>
#include <string.h>
#include "py/obj.h"
#include "py/objstr.h"
#include "py/runtime.h"
#include "py/binary.h"
#include "py/objarray.h"

/*
 * dbus includes
 */

#include "dbus_pp.h"


/*
 * Helper functions
 */

// Custom function mp object

typedef struct _mp_lv_obj_fun_builtin_var_t {
    mp_obj_base_t base;
    mp_uint_t n_args;
    mp_fun_var_t mp_fun;
    void *lv_fun;
} mp_lv_obj_fun_builtin_var_t;

STATIC mp_obj_t lv_fun_builtin_var_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args);
STATIC mp_int_t mp_func_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags);

STATIC const mp_obj_type_t mp_lv_type_fun_builtin_var = {
    { &mp_type_type },
    .name = MP_QSTR_function,
    .call = lv_fun_builtin_var_call,
    .unary_op = mp_generic_unary_op,
    .buffer_p = { .get_buffer = mp_func_get_buffer }
};

STATIC mp_obj_t lv_fun_builtin_var_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
    assert(MP_OBJ_IS_TYPE(self_in, &mp_lv_type_fun_builtin_var));
    mp_lv_obj_fun_builtin_var_t *self = MP_OBJ_TO_PTR(self_in);
    mp_arg_check_num(n_args, n_kw, self->n_args, self->n_args, false);
    return self->mp_fun(n_args, args);
}

STATIC mp_int_t mp_func_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
    (void)flags;
    assert(MP_OBJ_IS_TYPE(self_in, &mp_lv_type_fun_builtin_var));
    mp_lv_obj_fun_builtin_var_t *self = MP_OBJ_TO_PTR(self_in);

    bufinfo->buf = &self->lv_fun;
    bufinfo->len = sizeof(self->lv_fun);
    bufinfo->typecode = BYTEARRAY_TYPECODE;
    return 0;
}

#define MP_DEFINE_CONST_LV_FUN_OBJ_VAR(obj_name, n_args, mp_fun, lv_fun) \
    const mp_lv_obj_fun_builtin_var_t obj_name = \
        {{&mp_lv_type_fun_builtin_var}, n_args, mp_fun, lv_fun}

// Casting

STATIC mp_obj_t get_native_obj(mp_obj_t *mp_obj)
{
    if (!MP_OBJ_IS_OBJ(mp_obj)) return mp_obj;
    const mp_obj_type_t *native_type = ((mp_obj_base_t*)mp_obj)->type;
    if (native_type->parent == NULL) return mp_obj;
    while (native_type->parent) native_type = native_type->parent;
    return mp_instance_cast_to_native_base(mp_obj, MP_OBJ_FROM_PTR(native_type));
}

STATIC mp_obj_t dict_to_struct(mp_obj_t dict, const mp_obj_type_t *type);

STATIC mp_obj_t make_new_lv_struct(
    const mp_obj_type_t *type,
    size_t n_args,
    size_t n_kw,
    const mp_obj_t *args);

STATIC mp_obj_t *cast(mp_obj_t *mp_obj, const mp_obj_type_t *mp_type)
{
    mp_obj_t *res = NULL;
    if (MP_OBJ_IS_OBJ(mp_obj)){
        res = get_native_obj(mp_obj);
        if (res){
            const mp_obj_type_t *res_type = ((mp_obj_base_t*)res)->type;
            if (res_type != mp_type){
                if (res_type == &mp_type_dict && mp_type->make_new == &make_new_lv_struct) res = dict_to_struct(res, mp_type);
                else res = NULL;
            }
        }
    }
    if (res == NULL) nlr_raise(
        mp_obj_new_exception_msg_varg(
            &mp_type_SyntaxError, "Can't convert %s to %s!", mp_obj_get_type_str(mp_obj), qstr_str(mp_type->name)));
    return res;
}

// object handling
// This section is enabled only when objects are supported 

#ifdef LV_OBJ_T

typedef LV_OBJ_T* (*lv_create)(LV_OBJ_T * par, const LV_OBJ_T * copy);

typedef struct mp_lv_obj_t {
    mp_obj_base_t base;
    LV_OBJ_T *lv_obj;
    LV_OBJ_T *callbacks;
} mp_lv_obj_t;

STATIC inline LV_OBJ_T *mp_to_lv(mp_obj_t *mp_obj)
{
    if (mp_obj == NULL || mp_obj == mp_const_none) return NULL;
    mp_lv_obj_t *mp_lv_obj = MP_OBJ_TO_PTR(get_native_obj(mp_obj));
    return mp_lv_obj->lv_obj;
}

STATIC inline LV_OBJ_T *mp_get_callbacks(mp_obj_t mp_obj)
{
    if (mp_obj == NULL || mp_obj == mp_const_none) return NULL;
    mp_lv_obj_t *mp_lv_obj = MP_OBJ_TO_PTR(get_native_obj(mp_obj));
    if (!mp_lv_obj->callbacks) mp_lv_obj->callbacks = mp_obj_new_dict(0);
    return mp_lv_obj->callbacks;
}

STATIC inline const mp_obj_type_t *get_BaseObj_type();

STATIC inline mp_obj_t *lv_to_mp(LV_OBJ_T *lv_obj)
{
    mp_lv_obj_t *self = (mp_lv_obj_t*)lv_obj->user_data;
    if (!self) 
    {
        self = m_new_obj(mp_lv_obj_t);
        *self = (mp_lv_obj_t){
            .base = {get_BaseObj_type()},
            .lv_obj = lv_obj,
            .callbacks = NULL,
        };
        lv_obj->user_data = self;
    }
    return MP_OBJ_FROM_PTR(self);
}

STATIC mp_obj_t make_new(
    lv_create create,
    const mp_obj_type_t *type,
    size_t n_args,
    size_t n_kw,
    const mp_obj_t *args)
{
    mp_arg_check_num(n_args, n_kw, 0, 2, false);
    mp_lv_obj_t *self = m_new_obj(mp_lv_obj_t);
    LV_OBJ_T *parent = n_args > 0? mp_to_lv(args[0]): NULL;
    LV_OBJ_T *copy = n_args > 1? mp_to_lv(args[1]): NULL;
    *self = (mp_lv_obj_t){
        .base = {type}, 
        .lv_obj = create(parent, copy),
        .callbacks = NULL,
    };
    if (!self->lv_obj) return mp_const_none;
    self->lv_obj->user_data = self;
    return MP_OBJ_FROM_PTR(self);
}

STATIC void* mp_to_ptr(mp_obj_t self_in);

STATIC mp_obj_t cast_obj(mp_obj_t type_obj, mp_obj_t obj)
{
    mp_lv_obj_t *self = m_new_obj(mp_lv_obj_t);
    *self = (mp_lv_obj_t){
        .base = {(const mp_obj_type_t*)type_obj},
        .lv_obj = mp_to_ptr(obj),
        .callbacks = NULL,
    };
    if (!self->lv_obj) return mp_const_none;
    return MP_OBJ_FROM_PTR(self);
}

STATIC MP_DEFINE_CONST_FUN_OBJ_2(cast_obj_obj, cast_obj);
STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(cast_obj_class_method, MP_ROM_PTR(&cast_obj_obj));

STATIC mp_int_t mp_obj_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
    (void)flags;
    mp_lv_obj_t *self = MP_OBJ_TO_PTR(self_in);

    bufinfo->buf = &self->lv_obj;
    bufinfo->len = sizeof(self->lv_obj);
    bufinfo->typecode = BYTEARRAY_TYPECODE;
    return 0;
}

#endif

STATIC inline mp_obj_t convert_to_bool(bool b)
{
    return b? mp_const_true: mp_const_false;
}

STATIC inline mp_obj_t convert_to_str(const char *str)
{
    return str? mp_obj_new_str(str, strlen(str)): mp_const_none;
}

// struct handling

typedef struct mp_lv_struct_t
{
    mp_obj_base_t base;
    void *data;
} mp_lv_struct_t;

STATIC inline mp_lv_struct_t *mp_to_lv_struct(mp_obj_t mp_obj)
{
    if (mp_obj == NULL || mp_obj == mp_const_none) return NULL;
    if (!MP_OBJ_IS_OBJ(mp_obj)) nlr_raise(
            mp_obj_new_exception_msg(
                &mp_type_SyntaxError, "Struct argument is not an object!"));
    mp_lv_struct_t *mp_lv_struct = MP_OBJ_TO_PTR(get_native_obj(mp_obj));
    return mp_lv_struct;
}

STATIC inline size_t get_lv_struct_size(const mp_obj_type_t *type)
{
    mp_obj_t size_obj = mp_obj_dict_get(type->locals_dict, MP_OBJ_NEW_QSTR(MP_QSTR_SIZE));
    return (size_t)mp_obj_get_int(size_obj);
}

STATIC mp_obj_t make_new_lv_struct(
    const mp_obj_type_t *type,
    size_t n_args,
    size_t n_kw,
    const mp_obj_t *args)
{
    if ((!MP_OBJ_IS_TYPE(type, &mp_type_type)) || type->make_new != &make_new_lv_struct)
        nlr_raise(
            mp_obj_new_exception_msg(
                &mp_type_SyntaxError, "Argument is not a struct type!"));
    size_t size = get_lv_struct_size(type);
    mp_arg_check_num(n_args, n_kw, 0, 1, false);
    mp_lv_struct_t *self = m_new_obj(mp_lv_struct_t);
    *self = (mp_lv_struct_t){
        .base = {type}, 
        .data = m_malloc(size)
    };
    mp_lv_struct_t *other = n_args > 0? mp_to_lv_struct(cast(args[0], type)): NULL;
    if (other) {
        memcpy(self->data, other->data, size);
    } else {
        memset(self->data, 0, size);
    }
    return MP_OBJ_FROM_PTR(self);
}

STATIC void *copy_buffer(const void *buffer, size_t size)
{
    void *new_buffer = m_malloc(size);
    memcpy(new_buffer, buffer, size);
    return new_buffer;
}

// Reference an existing lv struct (or part of it)

STATIC mp_obj_t lv_to_mp_struct(const mp_obj_type_t *type, void *lv_struct)
{
    mp_lv_struct_t *self = m_new_obj(mp_lv_struct_t);
    *self = (mp_lv_struct_t){
        .base = {type},
        .data = lv_struct
    };
    return MP_OBJ_FROM_PTR(self);
}

// Convert dict to struct

STATIC mp_obj_t dict_to_struct(mp_obj_t dict, const mp_obj_type_t *type)
{
    mp_obj_t mp_struct = make_new_lv_struct(type, 0, 0, NULL);
    mp_obj_t *native_dict = cast(dict, &mp_type_dict);
    mp_map_t *map = mp_obj_dict_get_map(native_dict);
    if (map == NULL) return mp_const_none;
    for (uint i = 0; i < map->alloc; i++) {
        mp_obj_t key = map->table[i].key;
        mp_obj_t value = map->table[i].value;
        if (key != MP_OBJ_NULL) {
            mp_obj_t dest[] = {MP_OBJ_SENTINEL, value};
            type->attr(mp_struct, mp_obj_str_get_qstr(key), dest);
            if (dest[0]) nlr_raise(
                mp_obj_new_exception_msg_varg(
                    &mp_type_SyntaxError, "Cannot set field %s on struct %s!", qstr_str(mp_obj_str_get_qstr(key)), qstr_str(type->name)));
        }
    }
    return mp_struct;
}

// Convert mp object to ptr

STATIC void* mp_to_ptr(mp_obj_t self_in)
{
    mp_buffer_info_t buffer_info;
    if (self_in == mp_const_none)
        return NULL;

//    if (MP_OBJ_IS_INT(self_in))
//        return (void*)mp_obj_get_int(self_in);

    if (!mp_get_buffer(self_in, &buffer_info, MP_BUFFER_READ)) {
        // No buffer protocol - this is not a Struct or a Blob, it's some other mp object.
        // We only allow setting dict directly, since it's useful to setting user_data for passing data to C.
        // On other cases throw an exception, to avoid a crash later
        if (MP_OBJ_IS_TYPE(self_in, &mp_type_dict))
            return MP_OBJ_TO_PTR(self_in);
        else nlr_raise(
                mp_obj_new_exception_msg_varg(
                    &mp_type_SyntaxError, "Cannot convert '%s' to pointer!", mp_obj_get_type_str(self_in)));
    }

    if (MP_OBJ_IS_STR_OR_BYTES(self_in) || 
        MP_OBJ_IS_TYPE(self_in, &mp_type_bytearray) ||
        MP_OBJ_IS_TYPE(self_in, &mp_type_memoryview))
            return buffer_info.buf;
    else
    {
        void *result;
        if (buffer_info.len != sizeof(result) || buffer_info.typecode != BYTEARRAY_TYPECODE){
            nlr_raise(
                mp_obj_new_exception_msg_varg(
                    &mp_type_SyntaxError, "Cannot convert %s to pointer! (buffer does not represent a pointer)", mp_obj_get_type_str(self_in)));
        }
        memcpy(&result, buffer_info.buf, sizeof(result));
        return result;
    }
}

// Blob is a wrapper for void* 

STATIC void mp_blob_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "Blob");
}

STATIC mp_int_t mp_blob_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
    (void)flags;
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);

    bufinfo->buf = &self->data;
    bufinfo->len = sizeof(self->data);
    bufinfo->typecode = BYTEARRAY_TYPECODE;
    return 0;
}

STATIC const mp_obj_fun_builtin_var_t mp_lv_dereference_obj;

// Sometimes (but not always!) Blob represents a Micropython object.
// In such cases it's safe to cast the Blob back to the Micropython object
// cast argument is the underlying object type, and it's optional.

STATIC mp_obj_t mp_blob_cast(size_t argc, const mp_obj_t *argv)
{
    mp_obj_t self = argv[0];
    void *ptr = mp_to_ptr(self);
    if (argc == 1) return MP_OBJ_FROM_PTR(ptr);
    mp_obj_t type = argv[1];
    if (!MP_OBJ_IS_TYPE(type, &mp_type_type))
        nlr_raise(
            mp_obj_new_exception_msg(
                &mp_type_SyntaxError, "Cast argument must be a type!"));
    return cast(MP_OBJ_FROM_PTR(ptr), type);
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_blob_cast_obj, 1, 2, mp_blob_cast);

STATIC const mp_rom_map_elem_t mp_blob_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_blob_cast_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_blob_locals_dict, mp_blob_locals_dict_table);

STATIC const mp_obj_type_t mp_blob_type = {
    { &mp_type_type },
    .name = MP_QSTR_Blob,
    .print = mp_blob_print,
    //.make_new = make_new_blob,
    .locals_dict = (mp_obj_dict_t*)&mp_blob_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline mp_obj_t ptr_to_mp(void *data)
{
    if (data == NULL) return mp_const_none;
    return lv_to_mp_struct(&mp_blob_type, data);
}

// Cast pointer to struct

STATIC mp_obj_t mp_lv_cast(mp_obj_t type_obj, mp_obj_t ptr_obj)
{
    mp_lv_struct_t *self = m_new_obj(mp_lv_struct_t);
    *self = (mp_lv_struct_t){
        .base = {(const mp_obj_type_t*)type_obj}, 
        .data = mp_to_ptr(ptr_obj)
    };
    return MP_OBJ_FROM_PTR(self);
}

// Cast instance. Can be used in ISR when memory allocation is prohibited

STATIC inline mp_obj_t mp_lv_cast_instance(mp_obj_t self_in, mp_obj_t ptr_obj)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    self->data = mp_to_ptr(ptr_obj);
    return self_in;
}

STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_lv_cast_obj, mp_lv_cast);
STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(mp_lv_cast_class_method, MP_ROM_PTR(&mp_lv_cast_obj));

STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_lv_cast_instance_obj, mp_lv_cast_instance);

// Dereference a struct/blob. This allows access to the raw data the struct holds

STATIC mp_obj_t mp_lv_dereference(size_t argc, const mp_obj_t *argv)
{
    mp_obj_t self_in = argv[0];
    mp_obj_t size_in = argc > 1? argv[1]: mp_const_none;
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    size_t size = 0;
    if (size_in == mp_const_none){
        const mp_obj_type_t *type = self->base.type;
        size = get_lv_struct_size(type);
    } else {
        size = (size_t)mp_obj_get_int(size_in);
    }
    mp_obj_array_t *view = MP_OBJ_TO_PTR(mp_obj_new_memoryview(BYTEARRAY_TYPECODE,
        size, self->data));
    view->typecode |= 0x80; // used to indicate writable buffer
    return MP_OBJ_FROM_PTR(view);
}

STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_lv_dereference_obj, 1, 2, mp_lv_dereference);

// Callback function handling
// Callback is either a callable object or a pointer. If it's a callable object, set user_data to the callback.
// Multiple callbacks are kept per object/struct using a dict that associate callback name with callback object
// In case of an lv_obj_t, user_data is mp_lv_obj_t which contains a member "callbacks" for that dict.
// In case of a struct, user_data is a pointer to that dict directly

STATIC mp_obj_t get_callback_dict_from_user_data(void *user_data)
{
    if (user_data){
        mp_obj_t obj = MP_OBJ_FROM_PTR(user_data);
#ifdef LV_OBJ_T
        return 
            MP_OBJ_IS_TYPE(obj, &mp_type_dict)? obj: // Handle the case of dict for a struct
            mp_get_callbacks(obj); // Handle the case of mp_lv_obj_t for an lv_obj_t
#else
        return obj;
#endif
    }
    return NULL;
}

STATIC void *mp_lv_callback(mp_obj_t mp_callback, void *lv_callback, qstr callback_name, void **user_data_ptr)
{
    if (lv_callback && mp_obj_is_callable(mp_callback)){
        if (user_data_ptr){
            // user_data is either a dict of callbacks in case of struct, or a pointer to mp_lv_obj_t in case of lv_obj_t
            if (! (*user_data_ptr) ) *user_data_ptr = MP_OBJ_TO_PTR(mp_obj_new_dict(0)); // if it's NULL - it's a dict for a struct
            mp_obj_t callbacks = get_callback_dict_from_user_data(*user_data_ptr);
            mp_obj_dict_store(callbacks, MP_OBJ_NEW_QSTR(callback_name), mp_callback);
        }
        return lv_callback;
    } else {
        return mp_to_ptr(mp_callback);
    }
}

// Dict to hold user data for global callbacks (callbacks without context)



/*
 * LVGL string constants
 */


/*
 * Helper Structs
 */
        

typedef union {
    void *ptr_val;
    int int_val;
    unsigned int uint_val;
    const char *str_val;
} C_Pointer;


/*
 * Struct C_Pointer
 */

STATIC inline const mp_obj_type_t *get_mp_C_Pointer_type();

STATIC inline C_Pointer* mp_write_ptr_C_Pointer(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_C_Pointer_type()));
    return (C_Pointer*)self->data;
}

#define mp_write_C_Pointer(struct_obj) *mp_write_ptr_C_Pointer(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_C_Pointer(C_Pointer *field)
{
    return lv_to_mp_struct(get_mp_C_Pointer_type(), (void*)field);
}

#define mp_read_C_Pointer(field) mp_read_ptr_C_Pointer(copy_buffer(&field, sizeof(C_Pointer)))
#define mp_read_byref_C_Pointer(field) mp_read_ptr_C_Pointer(&field)

STATIC void mp_C_Pointer_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    C_Pointer *data = (C_Pointer*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_ptr_val: dest[0] = ptr_to_mp((void*)data->ptr_val); break; // converting from void *;
            case MP_QSTR_int_val: dest[0] = mp_obj_new_int(data->int_val); break; // converting from int;
            case MP_QSTR_uint_val: dest[0] = mp_obj_new_int_from_uint(data->uint_val); break; // converting from unsigned int;
            case MP_QSTR_str_val: dest[0] = convert_to_str((void*)data->str_val); break; // converting from char *;
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_ptr_val: data->ptr_val = (void*)mp_to_ptr(dest[1]); break; // converting to void *;
                case MP_QSTR_int_val: data->int_val = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_uint_val: data->uint_val = (unsigned int)mp_obj_get_int(dest[1]); break; // converting to unsigned int;
                case MP_QSTR_str_val: data->str_val = (void*)(char*)mp_obj_str_get_str(dest[1]); break; // converting to char *;
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_C_Pointer_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct C_Pointer");
}

STATIC const mp_rom_map_elem_t mp_C_Pointer_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(C_Pointer))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_C_Pointer_locals_dict, mp_C_Pointer_locals_dict_table);

STATIC const mp_obj_type_t mp_C_Pointer_type = {
    { &mp_type_type },
    .name = MP_QSTR_C_Pointer,
    .print = mp_C_Pointer_print,
    .make_new = make_new_lv_struct,
    .attr = mp_C_Pointer_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_C_Pointer_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_C_Pointer_type()
{
    return &mp_C_Pointer_type;
}
    

/*
 * dbus PTHREAD_CREATE object definitions
 */
    

STATIC const mp_rom_map_elem_t PTHREAD_CREATE_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_JOINABLE), MP_ROM_PTR(MP_ROM_INT(PTHREAD_CREATE_JOINABLE)) },
    { MP_ROM_QSTR(MP_QSTR_DETACHED), MP_ROM_PTR(MP_ROM_INT(PTHREAD_CREATE_DETACHED)) }
};

STATIC MP_DEFINE_CONST_DICT(PTHREAD_CREATE_locals_dict, PTHREAD_CREATE_locals_dict_table);

STATIC void PTHREAD_CREATE_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus PTHREAD_CREATE");
}



STATIC const mp_obj_type_t mp_PTHREAD_CREATE_type = {
    { &mp_type_type },
    .name = MP_QSTR_PTHREAD_CREATE,
    .print = PTHREAD_CREATE_print,
    
    .locals_dict = (mp_obj_dict_t*)&PTHREAD_CREATE_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus PTHREAD_MUTEX object definitions
 */
    

STATIC const mp_rom_map_elem_t PTHREAD_MUTEX_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_TIMED_NP), MP_ROM_PTR(MP_ROM_INT(PTHREAD_MUTEX_TIMED_NP)) },
    { MP_ROM_QSTR(MP_QSTR_RECURSIVE_NP), MP_ROM_PTR(MP_ROM_INT(PTHREAD_MUTEX_RECURSIVE_NP)) },
    { MP_ROM_QSTR(MP_QSTR_ERRORCHECK_NP), MP_ROM_PTR(MP_ROM_INT(PTHREAD_MUTEX_ERRORCHECK_NP)) },
    { MP_ROM_QSTR(MP_QSTR_ADAPTIVE_NP), MP_ROM_PTR(MP_ROM_INT(PTHREAD_MUTEX_ADAPTIVE_NP)) }
};

STATIC MP_DEFINE_CONST_DICT(PTHREAD_MUTEX_locals_dict, PTHREAD_MUTEX_locals_dict_table);

STATIC void PTHREAD_MUTEX_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus PTHREAD_MUTEX");
}



STATIC const mp_obj_type_t mp_PTHREAD_MUTEX_type = {
    { &mp_type_type },
    .name = MP_QSTR_PTHREAD_MUTEX,
    .print = PTHREAD_MUTEX_print,
    
    .locals_dict = (mp_obj_dict_t*)&PTHREAD_MUTEX_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus PTHREAD object definitions
 */
    

STATIC const mp_rom_map_elem_t PTHREAD_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_INHERIT_SCHED), MP_ROM_PTR(MP_ROM_INT(PTHREAD_INHERIT_SCHED)) },
    { MP_ROM_QSTR(MP_QSTR_EXPLICIT_SCHED), MP_ROM_PTR(MP_ROM_INT(PTHREAD_EXPLICIT_SCHED)) }
};

STATIC MP_DEFINE_CONST_DICT(PTHREAD_locals_dict, PTHREAD_locals_dict_table);

STATIC void PTHREAD_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus PTHREAD");
}



STATIC const mp_obj_type_t mp_PTHREAD_type = {
    { &mp_type_type },
    .name = MP_QSTR_PTHREAD,
    .print = PTHREAD_print,
    
    .locals_dict = (mp_obj_dict_t*)&PTHREAD_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus PTHREAD_SCOPE object definitions
 */
    

STATIC const mp_rom_map_elem_t PTHREAD_SCOPE_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SYSTEM), MP_ROM_PTR(MP_ROM_INT(PTHREAD_SCOPE_SYSTEM)) },
    { MP_ROM_QSTR(MP_QSTR_PROCESS), MP_ROM_PTR(MP_ROM_INT(PTHREAD_SCOPE_PROCESS)) }
};

STATIC MP_DEFINE_CONST_DICT(PTHREAD_SCOPE_locals_dict, PTHREAD_SCOPE_locals_dict_table);

STATIC void PTHREAD_SCOPE_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus PTHREAD_SCOPE");
}



STATIC const mp_obj_type_t mp_PTHREAD_SCOPE_type = {
    { &mp_type_type },
    .name = MP_QSTR_PTHREAD_SCOPE,
    .print = PTHREAD_SCOPE_print,
    
    .locals_dict = (mp_obj_dict_t*)&PTHREAD_SCOPE_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus PTHREAD_PROCESS object definitions
 */
    

STATIC const mp_rom_map_elem_t PTHREAD_PROCESS_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_PRIVATE), MP_ROM_PTR(MP_ROM_INT(PTHREAD_PROCESS_PRIVATE)) },
    { MP_ROM_QSTR(MP_QSTR_SHARED), MP_ROM_PTR(MP_ROM_INT(PTHREAD_PROCESS_SHARED)) }
};

STATIC MP_DEFINE_CONST_DICT(PTHREAD_PROCESS_locals_dict, PTHREAD_PROCESS_locals_dict_table);

STATIC void PTHREAD_PROCESS_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus PTHREAD_PROCESS");
}



STATIC const mp_obj_type_t mp_PTHREAD_PROCESS_type = {
    { &mp_type_type },
    .name = MP_QSTR_PTHREAD_PROCESS,
    .print = PTHREAD_PROCESS_print,
    
    .locals_dict = (mp_obj_dict_t*)&PTHREAD_PROCESS_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus PTHREAD_CANCEL object definitions
 */
    

STATIC const mp_rom_map_elem_t PTHREAD_CANCEL_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_ENABLE), MP_ROM_PTR(MP_ROM_INT(PTHREAD_CANCEL_ENABLE)) },
    { MP_ROM_QSTR(MP_QSTR_DISABLE), MP_ROM_PTR(MP_ROM_INT(PTHREAD_CANCEL_DISABLE)) },
    { MP_ROM_QSTR(MP_QSTR_DEFERRED), MP_ROM_PTR(MP_ROM_INT(PTHREAD_CANCEL_DEFERRED)) },
    { MP_ROM_QSTR(MP_QSTR_ASYNCHRONOUS), MP_ROM_PTR(MP_ROM_INT(PTHREAD_CANCEL_ASYNCHRONOUS)) }
};

STATIC MP_DEFINE_CONST_DICT(PTHREAD_CANCEL_locals_dict, PTHREAD_CANCEL_locals_dict_table);

STATIC void PTHREAD_CANCEL_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus PTHREAD_CANCEL");
}



STATIC const mp_obj_type_t mp_PTHREAD_CANCEL_type = {
    { &mp_type_type },
    .name = MP_QSTR_PTHREAD_CANCEL,
    .print = PTHREAD_CANCEL_print,
    
    .locals_dict = (mp_obj_dict_t*)&PTHREAD_CANCEL_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus DBUS_BUS object definitions
 */
    

STATIC const mp_rom_map_elem_t DBUS_BUS_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SESSION), MP_ROM_PTR(MP_ROM_INT(DBUS_BUS_SESSION)) },
    { MP_ROM_QSTR(MP_QSTR_SYSTEM), MP_ROM_PTR(MP_ROM_INT(DBUS_BUS_SYSTEM)) },
    { MP_ROM_QSTR(MP_QSTR_STARTER), MP_ROM_PTR(MP_ROM_INT(DBUS_BUS_STARTER)) }
};

STATIC MP_DEFINE_CONST_DICT(DBUS_BUS_locals_dict, DBUS_BUS_locals_dict_table);

STATIC void DBUS_BUS_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus DBUS_BUS");
}



STATIC const mp_obj_type_t mp_DBUS_BUS_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBUS_BUS,
    .print = DBUS_BUS_print,
    
    .locals_dict = (mp_obj_dict_t*)&DBUS_BUS_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus DBUS_HANDLER_RESULT object definitions
 */
    

STATIC const mp_rom_map_elem_t DBUS_HANDLER_RESULT_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_HANDLED), MP_ROM_PTR(MP_ROM_INT(DBUS_HANDLER_RESULT_HANDLED)) },
    { MP_ROM_QSTR(MP_QSTR_NOT_YET_HANDLED), MP_ROM_PTR(MP_ROM_INT(DBUS_HANDLER_RESULT_NOT_YET_HANDLED)) },
    { MP_ROM_QSTR(MP_QSTR_NEED_MEMORY), MP_ROM_PTR(MP_ROM_INT(DBUS_HANDLER_RESULT_NEED_MEMORY)) }
};

STATIC MP_DEFINE_CONST_DICT(DBUS_HANDLER_RESULT_locals_dict, DBUS_HANDLER_RESULT_locals_dict_table);

STATIC void DBUS_HANDLER_RESULT_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus DBUS_HANDLER_RESULT");
}



STATIC const mp_obj_type_t mp_DBUS_HANDLER_RESULT_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBUS_HANDLER_RESULT,
    .print = DBUS_HANDLER_RESULT_print,
    
    .locals_dict = (mp_obj_dict_t*)&DBUS_HANDLER_RESULT_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus DBUS_WATCH object definitions
 */
    

STATIC const mp_rom_map_elem_t DBUS_WATCH_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_READABLE), MP_ROM_PTR(MP_ROM_INT(DBUS_WATCH_READABLE)) },
    { MP_ROM_QSTR(MP_QSTR_WRITABLE), MP_ROM_PTR(MP_ROM_INT(DBUS_WATCH_WRITABLE)) },
    { MP_ROM_QSTR(MP_QSTR_ERROR), MP_ROM_PTR(MP_ROM_INT(DBUS_WATCH_ERROR)) },
    { MP_ROM_QSTR(MP_QSTR_HANGUP), MP_ROM_PTR(MP_ROM_INT(DBUS_WATCH_HANGUP)) }
};

STATIC MP_DEFINE_CONST_DICT(DBUS_WATCH_locals_dict, DBUS_WATCH_locals_dict_table);

STATIC void DBUS_WATCH_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus DBUS_WATCH");
}



STATIC const mp_obj_type_t mp_DBUS_WATCH_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBUS_WATCH,
    .print = DBUS_WATCH_print,
    
    .locals_dict = (mp_obj_dict_t*)&DBUS_WATCH_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus DBUS_DISPATCH object definitions
 */
    

STATIC const mp_rom_map_elem_t DBUS_DISPATCH_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_DATA_REMAINS), MP_ROM_PTR(MP_ROM_INT(DBUS_DISPATCH_DATA_REMAINS)) },
    { MP_ROM_QSTR(MP_QSTR_COMPLETE), MP_ROM_PTR(MP_ROM_INT(DBUS_DISPATCH_COMPLETE)) },
    { MP_ROM_QSTR(MP_QSTR_NEED_MEMORY), MP_ROM_PTR(MP_ROM_INT(DBUS_DISPATCH_NEED_MEMORY)) }
};

STATIC MP_DEFINE_CONST_DICT(DBUS_DISPATCH_locals_dict, DBUS_DISPATCH_locals_dict_table);

STATIC void DBUS_DISPATCH_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus DBUS_DISPATCH");
}



STATIC const mp_obj_type_t mp_DBUS_DISPATCH_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBUS_DISPATCH,
    .print = DBUS_DISPATCH_print,
    
    .locals_dict = (mp_obj_dict_t*)&DBUS_DISPATCH_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus DBUS_THREAD_FUNCTIONS object definitions
 */
    

STATIC const mp_rom_map_elem_t DBUS_THREAD_FUNCTIONS_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_MUTEX_NEW_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_MUTEX_FREE_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_MUTEX_LOCK_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_MUTEX_UNLOCK_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_CONDVAR_NEW_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_CONDVAR_FREE_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_CONDVAR_WAIT_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_CONDVAR_WAIT_TIMEOUT_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_CONDVAR_WAKE_ONE_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_CONDVAR_WAKE_ALL_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_RECURSIVE_MUTEX_NEW_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_NEW_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_RECURSIVE_MUTEX_FREE_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_FREE_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_RECURSIVE_MUTEX_LOCK_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_LOCK_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_RECURSIVE_MUTEX_UNLOCK_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_UNLOCK_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_ALL_MASK), MP_ROM_PTR(MP_ROM_INT(DBUS_THREAD_FUNCTIONS_ALL_MASK)) }
};

STATIC MP_DEFINE_CONST_DICT(DBUS_THREAD_FUNCTIONS_locals_dict, DBUS_THREAD_FUNCTIONS_locals_dict_table);

STATIC void DBUS_THREAD_FUNCTIONS_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus DBUS_THREAD_FUNCTIONS");
}



STATIC const mp_obj_type_t mp_DBUS_THREAD_FUNCTIONS_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBUS_THREAD_FUNCTIONS,
    .print = DBUS_THREAD_FUNCTIONS_print,
    
    .locals_dict = (mp_obj_dict_t*)&DBUS_THREAD_FUNCTIONS_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_USER object definitions
 */
    

STATIC const mp_rom_map_elem_t G_USER_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_DIRECTORY_DESKTOP), MP_ROM_PTR(MP_ROM_INT(G_USER_DIRECTORY_DESKTOP)) },
    { MP_ROM_QSTR(MP_QSTR_DIRECTORY_DOCUMENTS), MP_ROM_PTR(MP_ROM_INT(G_USER_DIRECTORY_DOCUMENTS)) },
    { MP_ROM_QSTR(MP_QSTR_DIRECTORY_DOWNLOAD), MP_ROM_PTR(MP_ROM_INT(G_USER_DIRECTORY_DOWNLOAD)) },
    { MP_ROM_QSTR(MP_QSTR_DIRECTORY_MUSIC), MP_ROM_PTR(MP_ROM_INT(G_USER_DIRECTORY_MUSIC)) },
    { MP_ROM_QSTR(MP_QSTR_DIRECTORY_PICTURES), MP_ROM_PTR(MP_ROM_INT(G_USER_DIRECTORY_PICTURES)) },
    { MP_ROM_QSTR(MP_QSTR_DIRECTORY_PUBLIC_SHARE), MP_ROM_PTR(MP_ROM_INT(G_USER_DIRECTORY_PUBLIC_SHARE)) },
    { MP_ROM_QSTR(MP_QSTR_DIRECTORY_TEMPLATES), MP_ROM_PTR(MP_ROM_INT(G_USER_DIRECTORY_TEMPLATES)) },
    { MP_ROM_QSTR(MP_QSTR_DIRECTORY_VIDEOS), MP_ROM_PTR(MP_ROM_INT(G_USER_DIRECTORY_VIDEOS)) },
    { MP_ROM_QSTR(MP_QSTR_N_DIRECTORIES), MP_ROM_PTR(MP_ROM_INT(G_USER_N_DIRECTORIES)) }
};

STATIC MP_DEFINE_CONST_DICT(G_USER_locals_dict, G_USER_locals_dict_table);

STATIC void G_USER_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_USER");
}



STATIC const mp_obj_type_t mp_G_USER_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_USER,
    .print = G_USER_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_USER_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_FORMAT_SIZE object definitions
 */
    

STATIC const mp_rom_map_elem_t G_FORMAT_SIZE_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_DEFAULT), MP_ROM_PTR(MP_ROM_INT(G_FORMAT_SIZE_DEFAULT)) },
    { MP_ROM_QSTR(MP_QSTR_LONG_FORMAT), MP_ROM_PTR(MP_ROM_INT(G_FORMAT_SIZE_LONG_FORMAT)) },
    { MP_ROM_QSTR(MP_QSTR_IEC_UNITS), MP_ROM_PTR(MP_ROM_INT(G_FORMAT_SIZE_IEC_UNITS)) }
};

STATIC MP_DEFINE_CONST_DICT(G_FORMAT_SIZE_locals_dict, G_FORMAT_SIZE_locals_dict_table);

STATIC void G_FORMAT_SIZE_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_FORMAT_SIZE");
}



STATIC const mp_obj_type_t mp_G_FORMAT_SIZE_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_FORMAT_SIZE,
    .print = G_FORMAT_SIZE_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_FORMAT_SIZE_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_THREAD_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_THREAD_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_AGAIN), MP_ROM_PTR(MP_ROM_INT(G_THREAD_ERROR_AGAIN)) }
};

STATIC MP_DEFINE_CONST_DICT(G_THREAD_ERROR_locals_dict, G_THREAD_ERROR_locals_dict_table);

STATIC void G_THREAD_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_THREAD_ERROR");
}



STATIC const mp_obj_type_t mp_G_THREAD_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_THREAD_ERROR,
    .print = G_THREAD_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_THREAD_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_ONCE_STATUS object definitions
 */
    

STATIC const mp_rom_map_elem_t G_ONCE_STATUS_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_NOTCALLED), MP_ROM_PTR(MP_ROM_INT(G_ONCE_STATUS_NOTCALLED)) },
    { MP_ROM_QSTR(MP_QSTR_PROGRESS), MP_ROM_PTR(MP_ROM_INT(G_ONCE_STATUS_PROGRESS)) },
    { MP_ROM_QSTR(MP_QSTR_READY), MP_ROM_PTR(MP_ROM_INT(G_ONCE_STATUS_READY)) }
};

STATIC MP_DEFINE_CONST_DICT(G_ONCE_STATUS_locals_dict, G_ONCE_STATUS_locals_dict_table);

STATIC void G_ONCE_STATUS_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_ONCE_STATUS");
}



STATIC const mp_obj_type_t mp_G_ONCE_STATUS_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_ONCE_STATUS,
    .print = G_ONCE_STATUS_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_ONCE_STATUS_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_BOOKMARK_FILE_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_BOOKMARK_FILE_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_INVALID_URI), MP_ROM_PTR(MP_ROM_INT(G_BOOKMARK_FILE_ERROR_INVALID_URI)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_VALUE), MP_ROM_PTR(MP_ROM_INT(G_BOOKMARK_FILE_ERROR_INVALID_VALUE)) },
    { MP_ROM_QSTR(MP_QSTR_APP_NOT_REGISTERED), MP_ROM_PTR(MP_ROM_INT(G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED)) },
    { MP_ROM_QSTR(MP_QSTR_URI_NOT_FOUND), MP_ROM_PTR(MP_ROM_INT(G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND)) },
    { MP_ROM_QSTR(MP_QSTR_READ), MP_ROM_PTR(MP_ROM_INT(G_BOOKMARK_FILE_ERROR_READ)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN_ENCODING), MP_ROM_PTR(MP_ROM_INT(G_BOOKMARK_FILE_ERROR_UNKNOWN_ENCODING)) },
    { MP_ROM_QSTR(MP_QSTR_WRITE), MP_ROM_PTR(MP_ROM_INT(G_BOOKMARK_FILE_ERROR_WRITE)) },
    { MP_ROM_QSTR(MP_QSTR_FILE_NOT_FOUND), MP_ROM_PTR(MP_ROM_INT(G_BOOKMARK_FILE_ERROR_FILE_NOT_FOUND)) }
};

STATIC MP_DEFINE_CONST_DICT(G_BOOKMARK_FILE_ERROR_locals_dict, G_BOOKMARK_FILE_ERROR_locals_dict_table);

STATIC void G_BOOKMARK_FILE_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_BOOKMARK_FILE_ERROR");
}



STATIC const mp_obj_type_t mp_G_BOOKMARK_FILE_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_BOOKMARK_FILE_ERROR,
    .print = G_BOOKMARK_FILE_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_BOOKMARK_FILE_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_CHECKSUM object definitions
 */
    

STATIC const mp_rom_map_elem_t G_CHECKSUM_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_MD5), MP_ROM_PTR(MP_ROM_INT(G_CHECKSUM_MD5)) },
    { MP_ROM_QSTR(MP_QSTR_SHA1), MP_ROM_PTR(MP_ROM_INT(G_CHECKSUM_SHA1)) },
    { MP_ROM_QSTR(MP_QSTR_SHA256), MP_ROM_PTR(MP_ROM_INT(G_CHECKSUM_SHA256)) },
    { MP_ROM_QSTR(MP_QSTR_SHA512), MP_ROM_PTR(MP_ROM_INT(G_CHECKSUM_SHA512)) }
};

STATIC MP_DEFINE_CONST_DICT(G_CHECKSUM_locals_dict, G_CHECKSUM_locals_dict_table);

STATIC void G_CHECKSUM_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_CHECKSUM");
}



STATIC const mp_obj_type_t mp_G_CHECKSUM_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_CHECKSUM,
    .print = G_CHECKSUM_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_CHECKSUM_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_CONVERT_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_CONVERT_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_NO_CONVERSION), MP_ROM_PTR(MP_ROM_INT(G_CONVERT_ERROR_NO_CONVERSION)) },
    { MP_ROM_QSTR(MP_QSTR_ILLEGAL_SEQUENCE), MP_ROM_PTR(MP_ROM_INT(G_CONVERT_ERROR_ILLEGAL_SEQUENCE)) },
    { MP_ROM_QSTR(MP_QSTR_FAILED), MP_ROM_PTR(MP_ROM_INT(G_CONVERT_ERROR_FAILED)) },
    { MP_ROM_QSTR(MP_QSTR_PARTIAL_INPUT), MP_ROM_PTR(MP_ROM_INT(G_CONVERT_ERROR_PARTIAL_INPUT)) },
    { MP_ROM_QSTR(MP_QSTR_BAD_URI), MP_ROM_PTR(MP_ROM_INT(G_CONVERT_ERROR_BAD_URI)) },
    { MP_ROM_QSTR(MP_QSTR_NOT_ABSOLUTE_PATH), MP_ROM_PTR(MP_ROM_INT(G_CONVERT_ERROR_NOT_ABSOLUTE_PATH)) },
    { MP_ROM_QSTR(MP_QSTR_NO_MEMORY), MP_ROM_PTR(MP_ROM_INT(G_CONVERT_ERROR_NO_MEMORY)) }
};

STATIC MP_DEFINE_CONST_DICT(G_CONVERT_ERROR_locals_dict, G_CONVERT_ERROR_locals_dict_table);

STATIC void G_CONVERT_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_CONVERT_ERROR");
}



STATIC const mp_obj_type_t mp_G_CONVERT_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_CONVERT_ERROR,
    .print = G_CONVERT_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_CONVERT_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_DATE object definitions
 */
    

STATIC const mp_rom_map_elem_t G_DATE_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_DAY), MP_ROM_PTR(MP_ROM_INT(G_DATE_DAY)) },
    { MP_ROM_QSTR(MP_QSTR_MONTH), MP_ROM_PTR(MP_ROM_INT(G_DATE_MONTH)) },
    { MP_ROM_QSTR(MP_QSTR_YEAR), MP_ROM_PTR(MP_ROM_INT(G_DATE_YEAR)) },
    { MP_ROM_QSTR(MP_QSTR_BAD_WEEKDAY), MP_ROM_PTR(MP_ROM_INT(G_DATE_BAD_WEEKDAY)) },
    { MP_ROM_QSTR(MP_QSTR_MONDAY), MP_ROM_PTR(MP_ROM_INT(G_DATE_MONDAY)) },
    { MP_ROM_QSTR(MP_QSTR_TUESDAY), MP_ROM_PTR(MP_ROM_INT(G_DATE_TUESDAY)) },
    { MP_ROM_QSTR(MP_QSTR_WEDNESDAY), MP_ROM_PTR(MP_ROM_INT(G_DATE_WEDNESDAY)) },
    { MP_ROM_QSTR(MP_QSTR_THURSDAY), MP_ROM_PTR(MP_ROM_INT(G_DATE_THURSDAY)) },
    { MP_ROM_QSTR(MP_QSTR_FRIDAY), MP_ROM_PTR(MP_ROM_INT(G_DATE_FRIDAY)) },
    { MP_ROM_QSTR(MP_QSTR_SATURDAY), MP_ROM_PTR(MP_ROM_INT(G_DATE_SATURDAY)) },
    { MP_ROM_QSTR(MP_QSTR_SUNDAY), MP_ROM_PTR(MP_ROM_INT(G_DATE_SUNDAY)) },
    { MP_ROM_QSTR(MP_QSTR_BAD_MONTH), MP_ROM_PTR(MP_ROM_INT(G_DATE_BAD_MONTH)) },
    { MP_ROM_QSTR(MP_QSTR_JANUARY), MP_ROM_PTR(MP_ROM_INT(G_DATE_JANUARY)) },
    { MP_ROM_QSTR(MP_QSTR_FEBRUARY), MP_ROM_PTR(MP_ROM_INT(G_DATE_FEBRUARY)) },
    { MP_ROM_QSTR(MP_QSTR_MARCH), MP_ROM_PTR(MP_ROM_INT(G_DATE_MARCH)) },
    { MP_ROM_QSTR(MP_QSTR_APRIL), MP_ROM_PTR(MP_ROM_INT(G_DATE_APRIL)) },
    { MP_ROM_QSTR(MP_QSTR_MAY), MP_ROM_PTR(MP_ROM_INT(G_DATE_MAY)) },
    { MP_ROM_QSTR(MP_QSTR_JUNE), MP_ROM_PTR(MP_ROM_INT(G_DATE_JUNE)) },
    { MP_ROM_QSTR(MP_QSTR_JULY), MP_ROM_PTR(MP_ROM_INT(G_DATE_JULY)) },
    { MP_ROM_QSTR(MP_QSTR_AUGUST), MP_ROM_PTR(MP_ROM_INT(G_DATE_AUGUST)) },
    { MP_ROM_QSTR(MP_QSTR_SEPTEMBER), MP_ROM_PTR(MP_ROM_INT(G_DATE_SEPTEMBER)) },
    { MP_ROM_QSTR(MP_QSTR_OCTOBER), MP_ROM_PTR(MP_ROM_INT(G_DATE_OCTOBER)) },
    { MP_ROM_QSTR(MP_QSTR_NOVEMBER), MP_ROM_PTR(MP_ROM_INT(G_DATE_NOVEMBER)) },
    { MP_ROM_QSTR(MP_QSTR_DECEMBER), MP_ROM_PTR(MP_ROM_INT(G_DATE_DECEMBER)) }
};

STATIC MP_DEFINE_CONST_DICT(G_DATE_locals_dict, G_DATE_locals_dict_table);

STATIC void G_DATE_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_DATE");
}



STATIC const mp_obj_type_t mp_G_DATE_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_DATE,
    .print = G_DATE_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_DATE_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_TIME_TYPE object definitions
 */
    

STATIC const mp_rom_map_elem_t G_TIME_TYPE_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_STANDARD), MP_ROM_PTR(MP_ROM_INT(G_TIME_TYPE_STANDARD)) },
    { MP_ROM_QSTR(MP_QSTR_DAYLIGHT), MP_ROM_PTR(MP_ROM_INT(G_TIME_TYPE_DAYLIGHT)) },
    { MP_ROM_QSTR(MP_QSTR_UNIVERSAL), MP_ROM_PTR(MP_ROM_INT(G_TIME_TYPE_UNIVERSAL)) }
};

STATIC MP_DEFINE_CONST_DICT(G_TIME_TYPE_locals_dict, G_TIME_TYPE_locals_dict_table);

STATIC void G_TIME_TYPE_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_TIME_TYPE");
}



STATIC const mp_obj_type_t mp_G_TIME_TYPE_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_TIME_TYPE,
    .print = G_TIME_TYPE_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_TIME_TYPE_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_FILE_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_FILE_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_EXIST), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_EXIST)) },
    { MP_ROM_QSTR(MP_QSTR_ISDIR), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_ISDIR)) },
    { MP_ROM_QSTR(MP_QSTR_ACCES), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_ACCES)) },
    { MP_ROM_QSTR(MP_QSTR_NAMETOOLONG), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_NAMETOOLONG)) },
    { MP_ROM_QSTR(MP_QSTR_NOENT), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_NOENT)) },
    { MP_ROM_QSTR(MP_QSTR_NOTDIR), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_NOTDIR)) },
    { MP_ROM_QSTR(MP_QSTR_NXIO), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_NXIO)) },
    { MP_ROM_QSTR(MP_QSTR_NODEV), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_NODEV)) },
    { MP_ROM_QSTR(MP_QSTR_ROFS), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_ROFS)) },
    { MP_ROM_QSTR(MP_QSTR_TXTBSY), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_TXTBSY)) },
    { MP_ROM_QSTR(MP_QSTR_FAULT), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_FAULT)) },
    { MP_ROM_QSTR(MP_QSTR_LOOP), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_LOOP)) },
    { MP_ROM_QSTR(MP_QSTR_NOSPC), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_NOSPC)) },
    { MP_ROM_QSTR(MP_QSTR_NOMEM), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_NOMEM)) },
    { MP_ROM_QSTR(MP_QSTR_MFILE), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_MFILE)) },
    { MP_ROM_QSTR(MP_QSTR_NFILE), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_NFILE)) },
    { MP_ROM_QSTR(MP_QSTR_BADF), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_BADF)) },
    { MP_ROM_QSTR(MP_QSTR_INVAL), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_INVAL)) },
    { MP_ROM_QSTR(MP_QSTR_PIPE), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_PIPE)) },
    { MP_ROM_QSTR(MP_QSTR_AGAIN), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_AGAIN)) },
    { MP_ROM_QSTR(MP_QSTR_INTR), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_INTR)) },
    { MP_ROM_QSTR(MP_QSTR_IO), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_IO)) },
    { MP_ROM_QSTR(MP_QSTR_PERM), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_PERM)) },
    { MP_ROM_QSTR(MP_QSTR_NOSYS), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_NOSYS)) },
    { MP_ROM_QSTR(MP_QSTR_FAILED), MP_ROM_PTR(MP_ROM_INT(G_FILE_ERROR_FAILED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_FILE_ERROR_locals_dict, G_FILE_ERROR_locals_dict_table);

STATIC void G_FILE_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_FILE_ERROR");
}



STATIC const mp_obj_type_t mp_G_FILE_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_FILE_ERROR,
    .print = G_FILE_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_FILE_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_FILE_TEST object definitions
 */
    

STATIC const mp_rom_map_elem_t G_FILE_TEST_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_IS_REGULAR), MP_ROM_PTR(MP_ROM_INT(G_FILE_TEST_IS_REGULAR)) },
    { MP_ROM_QSTR(MP_QSTR_IS_SYMLINK), MP_ROM_PTR(MP_ROM_INT(G_FILE_TEST_IS_SYMLINK)) },
    { MP_ROM_QSTR(MP_QSTR_IS_DIR), MP_ROM_PTR(MP_ROM_INT(G_FILE_TEST_IS_DIR)) },
    { MP_ROM_QSTR(MP_QSTR_IS_EXECUTABLE), MP_ROM_PTR(MP_ROM_INT(G_FILE_TEST_IS_EXECUTABLE)) },
    { MP_ROM_QSTR(MP_QSTR_EXISTS), MP_ROM_PTR(MP_ROM_INT(G_FILE_TEST_EXISTS)) }
};

STATIC MP_DEFINE_CONST_DICT(G_FILE_TEST_locals_dict, G_FILE_TEST_locals_dict_table);

STATIC void G_FILE_TEST_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_FILE_TEST");
}



STATIC const mp_obj_type_t mp_G_FILE_TEST_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_FILE_TEST,
    .print = G_FILE_TEST_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_FILE_TEST_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_TRAVERSE object definitions
 */
    

STATIC const mp_rom_map_elem_t G_TRAVERSE_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_LEAVES), MP_ROM_PTR(MP_ROM_INT(G_TRAVERSE_LEAVES)) },
    { MP_ROM_QSTR(MP_QSTR_NON_LEAVES), MP_ROM_PTR(MP_ROM_INT(G_TRAVERSE_NON_LEAVES)) },
    { MP_ROM_QSTR(MP_QSTR_ALL), MP_ROM_PTR(MP_ROM_INT(G_TRAVERSE_ALL)) },
    { MP_ROM_QSTR(MP_QSTR_MASK), MP_ROM_PTR(MP_ROM_INT(G_TRAVERSE_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_LEAFS), MP_ROM_PTR(MP_ROM_INT(G_TRAVERSE_LEAFS)) },
    { MP_ROM_QSTR(MP_QSTR_NON_LEAFS), MP_ROM_PTR(MP_ROM_INT(G_TRAVERSE_NON_LEAFS)) }
};

STATIC MP_DEFINE_CONST_DICT(G_TRAVERSE_locals_dict, G_TRAVERSE_locals_dict_table);

STATIC void G_TRAVERSE_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_TRAVERSE");
}



STATIC const mp_obj_type_t mp_G_TRAVERSE_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_TRAVERSE,
    .print = G_TRAVERSE_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_TRAVERSE_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus extension definition for:
 * GType dbus_g_connection_get_g_type(void)
 */
 
STATIC mp_obj_t mp_dbus_g_connection_get_g_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GType res = dbus_g_connection_get_g_type();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_connection_get_g_type_obj, 0, mp_dbus_g_connection_get_g_type, dbus_g_connection_get_g_type);

 

/*
 * dbus extension definition for:
 * GType dbus_g_message_get_g_type(void)
 */
 
STATIC mp_obj_t mp_dbus_g_message_get_g_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GType res = dbus_g_message_get_g_type();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_message_get_g_type_obj, 0, mp_dbus_g_message_get_g_type, dbus_g_message_get_g_type);

 

/*
 * dbus extension definition for:
 * DBusGConnection *dbus_g_connection_ref(DBusGConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_g_connection_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGConnection *connection = mp_to_ptr(mp_args[0]);
    DBusGConnection * res = dbus_g_connection_ref(connection);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_connection_ref_obj, 1, mp_dbus_g_connection_ref, dbus_g_connection_ref);

 

/*
 * dbus extension definition for:
 * void dbus_g_connection_unref(DBusGConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_g_connection_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_g_connection_unref(connection);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_connection_unref_obj, 1, mp_dbus_g_connection_unref, dbus_g_connection_unref);

 

/*
 * dbus extension definition for:
 * DBusGMessage *dbus_g_message_ref(DBusGMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_g_message_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGMessage *message = mp_to_ptr(mp_args[0]);
    DBusGMessage * res = dbus_g_message_ref(message);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_message_ref_obj, 1, mp_dbus_g_message_ref, dbus_g_message_ref);

 

/*
 * dbus extension definition for:
 * void dbus_g_message_unref(DBusGMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_g_message_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGMessage *message = mp_to_ptr(mp_args[0]);
    dbus_g_message_unref(message);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_message_unref_obj, 1, mp_dbus_g_message_unref, dbus_g_message_unref);

 

/*
 * dbus extension definition for:
 * void dbus_g_connection_flush(DBusGConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_g_connection_flush(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_g_connection_flush(connection);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_connection_flush_obj, 1, mp_dbus_g_connection_flush, dbus_g_connection_flush);

 

/*
 * dbus extension definition for:
 * GQuark dbus_g_error_quark(void)
 */
 
STATIC mp_obj_t mp_dbus_g_error_quark(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GQuark res = dbus_g_error_quark();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_error_quark_obj, 0, mp_dbus_g_error_quark, dbus_g_error_quark);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_error_has_name(GError *error, const char *name)
 */
 
STATIC mp_obj_t mp_dbus_g_error_has_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GError *error = mp_to_ptr(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    gboolean res = dbus_g_error_has_name(error, name);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_error_has_name_obj, 2, mp_dbus_g_error_has_name, dbus_g_error_has_name);

 

/*
 * dbus extension definition for:
 * const char *dbus_g_error_get_name(GError *error)
 */
 
STATIC mp_obj_t mp_dbus_g_error_get_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GError *error = mp_to_ptr(mp_args[0]);
    const char * res = dbus_g_error_get_name(error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_error_get_name_obj, 1, mp_dbus_g_error_get_name, dbus_g_error_get_name);

 

/*
 * dbus extension definition for:
 * void dbus_g_thread_init(void)
 */
 
STATIC mp_obj_t mp_dbus_g_thread_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    dbus_g_thread_init();
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_thread_init_obj, 0, mp_dbus_g_thread_init, dbus_g_thread_init);

 

/*
 * dbus extension definition for:
 * DBusGConnection *dbus_g_connection_open(const gchar *address, GError **error)
 */
 
STATIC mp_obj_t mp_dbus_g_connection_open(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *address = mp_to_ptr(mp_args[0]);
    GError **error = mp_to_ptr(mp_args[1]);
    DBusGConnection * res = dbus_g_connection_open(address, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_connection_open_obj, 2, mp_dbus_g_connection_open, dbus_g_connection_open);

 

/*
 * dbus extension definition for:
 * DBusGConnection *dbus_g_connection_open_private(const gchar *address, GMainContext *context, GError **error)
 */
 
STATIC mp_obj_t mp_dbus_g_connection_open_private(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *address = mp_to_ptr(mp_args[0]);
    GMainContext *context = mp_to_ptr(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    DBusGConnection * res = dbus_g_connection_open_private(address, context, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_connection_open_private_obj, 3, mp_dbus_g_connection_open_private, dbus_g_connection_open_private);

 

/*
 * dbus extension definition for:
 * DBusGConnection *dbus_g_bus_get(DBusBusType type, GError **error)
 */
 
STATIC mp_obj_t mp_dbus_g_bus_get(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusBusType type = (int)mp_obj_get_int(mp_args[0]);
    GError **error = mp_to_ptr(mp_args[1]);
    DBusGConnection * res = dbus_g_bus_get(type, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_bus_get_obj, 2, mp_dbus_g_bus_get, dbus_g_bus_get);

 

/*
 * dbus extension definition for:
 * DBusGConnection *dbus_g_bus_get_private(DBusBusType type, GMainContext *context, GError **error)
 */
 
STATIC mp_obj_t mp_dbus_g_bus_get_private(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusBusType type = (int)mp_obj_get_int(mp_args[0]);
    GMainContext *context = mp_to_ptr(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    DBusGConnection * res = dbus_g_bus_get_private(type, context, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_bus_get_private_obj, 3, mp_dbus_g_bus_get_private, dbus_g_bus_get_private);

 

/*
 * dbus extension definition for:
 * void dbus_g_object_type_install_info(GType object_type, const DBusGObjectInfo *info)
 */
 
STATIC mp_obj_t mp_dbus_g_object_type_install_info(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType object_type = (unsigned long)mp_obj_get_int(mp_args[0]);
    const DBusGObjectInfo *info = mp_to_ptr(mp_args[1]);
    dbus_g_object_type_install_info(object_type, info);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_object_type_install_info_obj, 2, mp_dbus_g_object_type_install_info, dbus_g_object_type_install_info);

 

/*
 * dbus extension definition for:
 * void dbus_g_object_type_register_shadow_property(GType iface_type, const char *dbus_prop_name, const char *shadow_prop_name)
 */
 
STATIC mp_obj_t mp_dbus_g_object_type_register_shadow_property(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType iface_type = (unsigned long)mp_obj_get_int(mp_args[0]);
    const char *dbus_prop_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *shadow_prop_name = (char*)mp_obj_str_get_str(mp_args[2]);
    dbus_g_object_type_register_shadow_property(iface_type, dbus_prop_name, shadow_prop_name);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_object_type_register_shadow_property_obj, 3, mp_dbus_g_object_type_register_shadow_property, dbus_g_object_type_register_shadow_property);

 

/*
 * dbus extension definition for:
 * void dbus_g_error_domain_register(GQuark domain, const char *default_iface, GType code_enum)
 */
 
STATIC mp_obj_t mp_dbus_g_error_domain_register(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GQuark domain = (unsigned int)mp_obj_get_int(mp_args[0]);
    const char *default_iface = (char*)mp_obj_str_get_str(mp_args[1]);
    GType code_enum = (unsigned long)mp_obj_get_int(mp_args[2]);
    dbus_g_error_domain_register(domain, default_iface, code_enum);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_error_domain_register_obj, 3, mp_dbus_g_error_domain_register, dbus_g_error_domain_register);

 

/*
 * dbus extension definition for:
 * void dbus_g_connection_register_g_object(DBusGConnection *connection, const char *at_path, GObject *object)
 */
 
STATIC mp_obj_t mp_dbus_g_connection_register_g_object(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGConnection *connection = mp_to_ptr(mp_args[0]);
    const char *at_path = (char*)mp_obj_str_get_str(mp_args[1]);
    GObject *object = mp_to_ptr(mp_args[2]);
    dbus_g_connection_register_g_object(connection, at_path, object);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_connection_register_g_object_obj, 3, mp_dbus_g_connection_register_g_object, dbus_g_connection_register_g_object);

 

/*
 * dbus extension definition for:
 * void dbus_g_connection_unregister_g_object(DBusGConnection *connection, GObject *object)
 */
 
STATIC mp_obj_t mp_dbus_g_connection_unregister_g_object(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGConnection *connection = mp_to_ptr(mp_args[0]);
    GObject *object = mp_to_ptr(mp_args[1]);
    dbus_g_connection_unregister_g_object(connection, object);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_connection_unregister_g_object_obj, 2, mp_dbus_g_connection_unregister_g_object, dbus_g_connection_unregister_g_object);

 

/*
 * dbus extension definition for:
 * GObject *dbus_g_connection_lookup_g_object(DBusGConnection *connection, const char *at_path)
 */
 
STATIC mp_obj_t mp_dbus_g_connection_lookup_g_object(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGConnection *connection = mp_to_ptr(mp_args[0]);
    const char *at_path = (char*)mp_obj_str_get_str(mp_args[1]);
    GObject * res = dbus_g_connection_lookup_g_object(connection, at_path);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_connection_lookup_g_object_obj, 2, mp_dbus_g_connection_lookup_g_object, dbus_g_connection_lookup_g_object);

 

/*
 * dbus extension definition for:
 * GType dbus_g_type_get_collection(const char *container, GType specialization)
 */
 
STATIC mp_obj_t mp_dbus_g_type_get_collection(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *container = (char*)mp_obj_str_get_str(mp_args[0]);
    GType specialization = (unsigned long)mp_obj_get_int(mp_args[1]);
    GType res = dbus_g_type_get_collection(container, specialization);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_get_collection_obj, 2, mp_dbus_g_type_get_collection, dbus_g_type_get_collection);

 

/*
 * dbus extension definition for:
 * GType dbus_g_type_get_map(const char *container, GType key_specialization, GType value_specialization)
 */
 
STATIC mp_obj_t mp_dbus_g_type_get_map(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *container = (char*)mp_obj_str_get_str(mp_args[0]);
    GType key_specialization = (unsigned long)mp_obj_get_int(mp_args[1]);
    GType value_specialization = (unsigned long)mp_obj_get_int(mp_args[2]);
    GType res = dbus_g_type_get_map(container, key_specialization, value_specialization);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_get_map_obj, 3, mp_dbus_g_type_get_map, dbus_g_type_get_map);

 

/*
 * dbus extension definition for:
 * GType dbus_g_type_get_structv(const char *container, guint num_members, GType *types)
 */
 
STATIC mp_obj_t mp_dbus_g_type_get_structv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *container = (char*)mp_obj_str_get_str(mp_args[0]);
    guint num_members = (unsigned int)mp_obj_get_int(mp_args[1]);
    GType *types = mp_to_ptr(mp_args[2]);
    GType res = dbus_g_type_get_structv(container, num_members, types);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_get_structv_obj, 3, mp_dbus_g_type_get_structv, dbus_g_type_get_structv);

 

/*
 * dbus extension definition for:
 * GType dbus_g_type_get_struct(const char *container, GType first_type, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_type_get_struct(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *container = (char*)mp_obj_str_get_str(mp_args[0]);
    GType first_type = (unsigned long)mp_obj_get_int(mp_args[1]);
    GType res = dbus_g_type_get_struct(container, first_type);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_get_struct_obj, 3, mp_dbus_g_type_get_struct, dbus_g_type_get_struct);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_type_is_collection(GType gtype)
 */
 
STATIC mp_obj_t mp_dbus_g_type_is_collection(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType gtype = (unsigned long)mp_obj_get_int(mp_args[0]);
    gboolean res = dbus_g_type_is_collection(gtype);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_is_collection_obj, 1, mp_dbus_g_type_is_collection, dbus_g_type_is_collection);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_type_is_map(GType gtype)
 */
 
STATIC mp_obj_t mp_dbus_g_type_is_map(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType gtype = (unsigned long)mp_obj_get_int(mp_args[0]);
    gboolean res = dbus_g_type_is_map(gtype);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_is_map_obj, 1, mp_dbus_g_type_is_map, dbus_g_type_is_map);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_type_is_struct(GType gtype)
 */
 
STATIC mp_obj_t mp_dbus_g_type_is_struct(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType gtype = (unsigned long)mp_obj_get_int(mp_args[0]);
    gboolean res = dbus_g_type_is_struct(gtype);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_is_struct_obj, 1, mp_dbus_g_type_is_struct, dbus_g_type_is_struct);

 

/*
 * dbus extension definition for:
 * GType dbus_g_type_get_collection_specialization(GType gtype)
 */
 
STATIC mp_obj_t mp_dbus_g_type_get_collection_specialization(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType gtype = (unsigned long)mp_obj_get_int(mp_args[0]);
    GType res = dbus_g_type_get_collection_specialization(gtype);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_get_collection_specialization_obj, 1, mp_dbus_g_type_get_collection_specialization, dbus_g_type_get_collection_specialization);

 

/*
 * dbus extension definition for:
 * GType dbus_g_type_get_map_key_specialization(GType gtype)
 */
 
STATIC mp_obj_t mp_dbus_g_type_get_map_key_specialization(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType gtype = (unsigned long)mp_obj_get_int(mp_args[0]);
    GType res = dbus_g_type_get_map_key_specialization(gtype);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_get_map_key_specialization_obj, 1, mp_dbus_g_type_get_map_key_specialization, dbus_g_type_get_map_key_specialization);

 

/*
 * dbus extension definition for:
 * GType dbus_g_type_get_map_value_specialization(GType gtype)
 */
 
STATIC mp_obj_t mp_dbus_g_type_get_map_value_specialization(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType gtype = (unsigned long)mp_obj_get_int(mp_args[0]);
    GType res = dbus_g_type_get_map_value_specialization(gtype);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_get_map_value_specialization_obj, 1, mp_dbus_g_type_get_map_value_specialization, dbus_g_type_get_map_value_specialization);

 

/*
 * dbus extension definition for:
 * GType dbus_g_type_get_struct_member_type(GType gtype, guint member)
 */
 
STATIC mp_obj_t mp_dbus_g_type_get_struct_member_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType gtype = (unsigned long)mp_obj_get_int(mp_args[0]);
    guint member = (unsigned int)mp_obj_get_int(mp_args[1]);
    GType res = dbus_g_type_get_struct_member_type(gtype, member);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_get_struct_member_type_obj, 2, mp_dbus_g_type_get_struct_member_type, dbus_g_type_get_struct_member_type);

 

/*
 * dbus extension definition for:
 * guint dbus_g_type_get_struct_size(GType gtype)
 */
 
STATIC mp_obj_t mp_dbus_g_type_get_struct_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType gtype = (unsigned long)mp_obj_get_int(mp_args[0]);
    guint res = dbus_g_type_get_struct_size(gtype);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_get_struct_size_obj, 1, mp_dbus_g_type_get_struct_size, dbus_g_type_get_struct_size);

 

/*
 * dbus extension definition for:
 * gpointer dbus_g_type_specialized_construct(GType gtype)
 */
 
STATIC mp_obj_t mp_dbus_g_type_specialized_construct(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType gtype = (unsigned long)mp_obj_get_int(mp_args[0]);
    gpointer res = dbus_g_type_specialized_construct(gtype);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_specialized_construct_obj, 1, mp_dbus_g_type_specialized_construct, dbus_g_type_specialized_construct);

 

/*
 * Struct DBusGTypeSpecializedAppendContext
 */

STATIC inline const mp_obj_type_t *get_mp_DBusGTypeSpecializedAppendContext_type();

STATIC inline DBusGTypeSpecializedAppendContext* mp_write_ptr_DBusGTypeSpecializedAppendContext(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_DBusGTypeSpecializedAppendContext_type()));
    return (DBusGTypeSpecializedAppendContext*)self->data;
}

#define mp_write_DBusGTypeSpecializedAppendContext(struct_obj) *mp_write_ptr_DBusGTypeSpecializedAppendContext(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_DBusGTypeSpecializedAppendContext(DBusGTypeSpecializedAppendContext *field)
{
    return lv_to_mp_struct(get_mp_DBusGTypeSpecializedAppendContext_type(), (void*)field);
}

#define mp_read_DBusGTypeSpecializedAppendContext(field) mp_read_ptr_DBusGTypeSpecializedAppendContext(copy_buffer(&field, sizeof(DBusGTypeSpecializedAppendContext)))
#define mp_read_byref_DBusGTypeSpecializedAppendContext(field) mp_read_ptr_DBusGTypeSpecializedAppendContext(&field)

STATIC void mp_DBusGTypeSpecializedAppendContext_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    DBusGTypeSpecializedAppendContext *data = (DBusGTypeSpecializedAppendContext*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_val: dest[0] = ptr_to_mp((void*)data->val); break; // converting from GValue *;
            case MP_QSTR_specialization_type: dest[0] = mp_obj_new_int_from_uint(data->specialization_type); break; // converting from GType;
            case MP_QSTR_b: dest[0] = ptr_to_mp(data->b); break; // converting from gpointer;
            case MP_QSTR_c: dest[0] = mp_obj_new_int_from_uint(data->c); break; // converting from guint;
            case MP_QSTR_d: dest[0] = ptr_to_mp(data->d); break; // converting from gpointer;
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_val: data->val = (void*)mp_to_ptr(dest[1]); break; // converting to GValue *;
                case MP_QSTR_specialization_type: data->specialization_type = (unsigned long)mp_obj_get_int(dest[1]); break; // converting to GType;
                case MP_QSTR_b: data->b = mp_to_ptr(dest[1]); break; // converting to gpointer;
                case MP_QSTR_c: data->c = (unsigned int)mp_obj_get_int(dest[1]); break; // converting to guint;
                case MP_QSTR_d: data->d = mp_to_ptr(dest[1]); break; // converting to gpointer;
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_DBusGTypeSpecializedAppendContext_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct DBusGTypeSpecializedAppendContext");
}

STATIC const mp_rom_map_elem_t mp_DBusGTypeSpecializedAppendContext_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(DBusGTypeSpecializedAppendContext))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_DBusGTypeSpecializedAppendContext_locals_dict, mp_DBusGTypeSpecializedAppendContext_locals_dict_table);

STATIC const mp_obj_type_t mp_DBusGTypeSpecializedAppendContext_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBusGTypeSpecializedAppendContext,
    .print = mp_DBusGTypeSpecializedAppendContext_print,
    .make_new = make_new_lv_struct,
    .attr = mp_DBusGTypeSpecializedAppendContext_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_DBusGTypeSpecializedAppendContext_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_DBusGTypeSpecializedAppendContext_type()
{
    return &mp_DBusGTypeSpecializedAppendContext_type;
}
    

/*
 * dbus extension definition for:
 * void dbus_g_type_specialized_init_append(GValue *value, DBusGTypeSpecializedAppendContext *ctx)
 */
 
STATIC mp_obj_t mp_dbus_g_type_specialized_init_append(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GValue *value = mp_to_ptr(mp_args[0]);
    DBusGTypeSpecializedAppendContext *ctx = mp_write_ptr_DBusGTypeSpecializedAppendContext(mp_args[1]);
    dbus_g_type_specialized_init_append(value, ctx);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_specialized_init_append_obj, 2, mp_dbus_g_type_specialized_init_append, dbus_g_type_specialized_init_append);

 

/*
 * dbus extension definition for:
 * void dbus_g_type_specialized_collection_append(DBusGTypeSpecializedAppendContext *ctx, GValue *elt)
 */
 
STATIC mp_obj_t mp_dbus_g_type_specialized_collection_append(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGTypeSpecializedAppendContext *ctx = mp_write_ptr_DBusGTypeSpecializedAppendContext(mp_args[0]);
    GValue *elt = mp_to_ptr(mp_args[1]);
    dbus_g_type_specialized_collection_append(ctx, elt);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_specialized_collection_append_obj, 2, mp_dbus_g_type_specialized_collection_append, dbus_g_type_specialized_collection_append);

 

/*
 * dbus extension definition for:
 * void dbus_g_type_specialized_collection_end_append(DBusGTypeSpecializedAppendContext *ctx)
 */
 
STATIC mp_obj_t mp_dbus_g_type_specialized_collection_end_append(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGTypeSpecializedAppendContext *ctx = mp_write_ptr_DBusGTypeSpecializedAppendContext(mp_args[0]);
    dbus_g_type_specialized_collection_end_append(ctx);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_specialized_collection_end_append_obj, 1, mp_dbus_g_type_specialized_collection_end_append, dbus_g_type_specialized_collection_end_append);

 

/*
 * dbus extension definition for:
 * void dbus_g_type_specialized_map_append(DBusGTypeSpecializedAppendContext *ctx, GValue *key, GValue *val)
 */
 
STATIC mp_obj_t mp_dbus_g_type_specialized_map_append(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGTypeSpecializedAppendContext *ctx = mp_write_ptr_DBusGTypeSpecializedAppendContext(mp_args[0]);
    GValue *key = mp_to_ptr(mp_args[1]);
    GValue *val = mp_to_ptr(mp_args[2]);
    dbus_g_type_specialized_map_append(ctx, key, val);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_specialized_map_append_obj, 3, mp_dbus_g_type_specialized_map_append, dbus_g_type_specialized_map_append);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_type_collection_get_fixed(GValue *value, gpointer *data_ret, guint *len_ret)
 */
 
STATIC mp_obj_t mp_dbus_g_type_collection_get_fixed(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GValue *value = mp_to_ptr(mp_args[0]);
    gpointer *data_ret = mp_to_ptr(mp_args[1]);
    guint *len_ret = mp_to_ptr(mp_args[2]);
    gboolean res = dbus_g_type_collection_get_fixed(value, data_ret, len_ret);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_collection_get_fixed_obj, 3, mp_dbus_g_type_collection_get_fixed, dbus_g_type_collection_get_fixed);

 

/*
 * Function NOT generated:
 * Callback function 'DBusGTypeSpecializedCollectionIterator iterator' must receive a struct pointer with user_data member as its first argument!
 * DBusGTypeSpecializedCollectionIterator iterator
 */
    

/*
 * dbus extension definition for:
 * void dbus_g_type_collection_value_iterate(const GValue *value, DBusGTypeSpecializedCollectionIterator iterator, gpointer user_data)
 */
 
STATIC mp_obj_t mp_dbus_g_type_collection_value_iterate(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GValue *value = mp_to_ptr(mp_args[0]);
    DBusGTypeSpecializedCollectionIterator iterator = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    dbus_g_type_collection_value_iterate(value, iterator, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_collection_value_iterate_obj, 3, mp_dbus_g_type_collection_value_iterate, dbus_g_type_collection_value_iterate);

 

/*
 * Function NOT generated:
 * Callback function 'DBusGTypeSpecializedMapIterator iterator' must receive a struct pointer with user_data member as its first argument!
 * DBusGTypeSpecializedMapIterator iterator
 */
    

/*
 * dbus extension definition for:
 * void dbus_g_type_map_value_iterate(const GValue *value, DBusGTypeSpecializedMapIterator iterator, gpointer user_data)
 */
 
STATIC mp_obj_t mp_dbus_g_type_map_value_iterate(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GValue *value = mp_to_ptr(mp_args[0]);
    DBusGTypeSpecializedMapIterator iterator = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    dbus_g_type_map_value_iterate(value, iterator, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_map_value_iterate_obj, 3, mp_dbus_g_type_map_value_iterate, dbus_g_type_map_value_iterate);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_type_struct_get_member(const GValue *value, guint member, GValue *dest)
 */
 
STATIC mp_obj_t mp_dbus_g_type_struct_get_member(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GValue *value = mp_to_ptr(mp_args[0]);
    guint member = (unsigned int)mp_obj_get_int(mp_args[1]);
    GValue *dest = mp_to_ptr(mp_args[2]);
    gboolean res = dbus_g_type_struct_get_member(value, member, dest);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_struct_get_member_obj, 3, mp_dbus_g_type_struct_get_member, dbus_g_type_struct_get_member);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_type_struct_set_member(GValue *value, guint member, const GValue *src)
 */
 
STATIC mp_obj_t mp_dbus_g_type_struct_set_member(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GValue *value = mp_to_ptr(mp_args[0]);
    guint member = (unsigned int)mp_obj_get_int(mp_args[1]);
    const GValue *src = mp_to_ptr(mp_args[2]);
    gboolean res = dbus_g_type_struct_set_member(value, member, src);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_struct_set_member_obj, 3, mp_dbus_g_type_struct_set_member, dbus_g_type_struct_set_member);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_type_struct_get(const GValue *value, guint member, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_type_struct_get(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GValue *value = mp_to_ptr(mp_args[0]);
    guint member = (unsigned int)mp_obj_get_int(mp_args[1]);
    gboolean res = dbus_g_type_struct_get(value, member);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_struct_get_obj, 3, mp_dbus_g_type_struct_get, dbus_g_type_struct_get);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_type_struct_set(GValue *value, guint member, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_type_struct_set(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GValue *value = mp_to_ptr(mp_args[0]);
    guint member = (unsigned int)mp_obj_get_int(mp_args[1]);
    gboolean res = dbus_g_type_struct_set(value, member);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_struct_set_obj, 3, mp_dbus_g_type_struct_set, dbus_g_type_struct_set);

 

/*
 * dbus extension definition for:
 * void dbus_g_type_specialized_init(void)
 */
 
STATIC mp_obj_t mp_dbus_g_type_specialized_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    dbus_g_type_specialized_init();
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_specialized_init_obj, 0, mp_dbus_g_type_specialized_init, dbus_g_type_specialized_init);

 

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedVtable_constructor_callback'
 * DBusGTypeSpecializedConstructor constructor
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedVtable_free_func_callback'
 * DBusGTypeSpecializedFreeFunc free_func
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedVtable_copy_func_callback'
 * DBusGTypeSpecializedCopyFunc copy_func
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedVtable_simple_free_func_callback'
 * GDestroyNotify simple_free_func
 */
    

/*
 * Struct DBusGTypeSpecializedVtable
 */

STATIC inline const mp_obj_type_t *get_mp_DBusGTypeSpecializedVtable_type();

STATIC inline DBusGTypeSpecializedVtable* mp_write_ptr_DBusGTypeSpecializedVtable(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_DBusGTypeSpecializedVtable_type()));
    return (DBusGTypeSpecializedVtable*)self->data;
}

#define mp_write_DBusGTypeSpecializedVtable(struct_obj) *mp_write_ptr_DBusGTypeSpecializedVtable(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_DBusGTypeSpecializedVtable(DBusGTypeSpecializedVtable *field)
{
    return lv_to_mp_struct(get_mp_DBusGTypeSpecializedVtable_type(), (void*)field);
}

#define mp_read_DBusGTypeSpecializedVtable(field) mp_read_ptr_DBusGTypeSpecializedVtable(copy_buffer(&field, sizeof(DBusGTypeSpecializedVtable)))
#define mp_read_byref_DBusGTypeSpecializedVtable(field) mp_read_ptr_DBusGTypeSpecializedVtable(&field)

STATIC void mp_DBusGTypeSpecializedVtable_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    DBusGTypeSpecializedVtable *data = (DBusGTypeSpecializedVtable*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_constructor: dest[0] = ptr_to_mp(data->constructor); break; // converting from callback DBusGTypeSpecializedConstructor;
            case MP_QSTR_free_func: dest[0] = ptr_to_mp(data->free_func); break; // converting from callback DBusGTypeSpecializedFreeFunc;
            case MP_QSTR_copy_func: dest[0] = ptr_to_mp(data->copy_func); break; // converting from callback DBusGTypeSpecializedCopyFunc;
            case MP_QSTR_simple_free_func: dest[0] = ptr_to_mp(data->simple_free_func); break; // converting from callback GDestroyNotify;
            case MP_QSTR_padding2: dest[0] = ptr_to_mp(data->padding2); break; // converting from gpointer;
            case MP_QSTR_padding3: dest[0] = ptr_to_mp(data->padding3); break; // converting from gpointer;
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_constructor: data->constructor = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedVtable_constructor, NULL); break; // converting to callback DBusGTypeSpecializedConstructor;
                case MP_QSTR_free_func: data->free_func = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedVtable_free_func, NULL); break; // converting to callback DBusGTypeSpecializedFreeFunc;
                case MP_QSTR_copy_func: data->copy_func = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedVtable_copy_func, NULL); break; // converting to callback DBusGTypeSpecializedCopyFunc;
                case MP_QSTR_simple_free_func: data->simple_free_func = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedVtable_simple_free_func, NULL); break; // converting to callback GDestroyNotify;
                case MP_QSTR_padding2: data->padding2 = mp_to_ptr(dest[1]); break; // converting to gpointer;
                case MP_QSTR_padding3: data->padding3 = mp_to_ptr(dest[1]); break; // converting to gpointer;
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_DBusGTypeSpecializedVtable_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct DBusGTypeSpecializedVtable");
}

STATIC const mp_rom_map_elem_t mp_DBusGTypeSpecializedVtable_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(DBusGTypeSpecializedVtable))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_DBusGTypeSpecializedVtable_locals_dict, mp_DBusGTypeSpecializedVtable_locals_dict_table);

STATIC const mp_obj_type_t mp_DBusGTypeSpecializedVtable_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBusGTypeSpecializedVtable,
    .print = mp_DBusGTypeSpecializedVtable_print,
    .make_new = make_new_lv_struct,
    .attr = mp_DBusGTypeSpecializedVtable_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_DBusGTypeSpecializedVtable_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_DBusGTypeSpecializedVtable_type()
{
    return &mp_DBusGTypeSpecializedVtable_type;
}
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedCollectionVtable_fixed_accessor_callback'
 * DBusGTypeSpecializedCollectionFixedAccessorFunc fixed_accessor
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedCollectionVtable_iterator_callback'
 * DBusGTypeSpecializedCollectionIteratorFunc iterator
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedCollectionVtable_append_func_callback'
 * DBusGTypeSpecializedCollectionAppendFunc append_func
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedCollectionVtable_end_append_func_callback'
 * DBusGTypeSpecializedCollectionEndAppendFunc end_append_func
 */
    

/*
 * Struct DBusGTypeSpecializedCollectionVtable
 */

STATIC inline const mp_obj_type_t *get_mp_DBusGTypeSpecializedCollectionVtable_type();

STATIC inline DBusGTypeSpecializedCollectionVtable* mp_write_ptr_DBusGTypeSpecializedCollectionVtable(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_DBusGTypeSpecializedCollectionVtable_type()));
    return (DBusGTypeSpecializedCollectionVtable*)self->data;
}

#define mp_write_DBusGTypeSpecializedCollectionVtable(struct_obj) *mp_write_ptr_DBusGTypeSpecializedCollectionVtable(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_DBusGTypeSpecializedCollectionVtable(DBusGTypeSpecializedCollectionVtable *field)
{
    return lv_to_mp_struct(get_mp_DBusGTypeSpecializedCollectionVtable_type(), (void*)field);
}

#define mp_read_DBusGTypeSpecializedCollectionVtable(field) mp_read_ptr_DBusGTypeSpecializedCollectionVtable(copy_buffer(&field, sizeof(DBusGTypeSpecializedCollectionVtable)))
#define mp_read_byref_DBusGTypeSpecializedCollectionVtable(field) mp_read_ptr_DBusGTypeSpecializedCollectionVtable(&field)

STATIC void mp_DBusGTypeSpecializedCollectionVtable_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    DBusGTypeSpecializedCollectionVtable *data = (DBusGTypeSpecializedCollectionVtable*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_base_vtable: dest[0] = mp_read_byref_DBusGTypeSpecializedVtable(data->base_vtable); break; // converting from DBusGTypeSpecializedVtable;
            case MP_QSTR_fixed_accessor: dest[0] = ptr_to_mp(data->fixed_accessor); break; // converting from callback DBusGTypeSpecializedCollectionFixedAccessorFunc;
            case MP_QSTR_iterator: dest[0] = ptr_to_mp(data->iterator); break; // converting from callback DBusGTypeSpecializedCollectionIteratorFunc;
            case MP_QSTR_append_func: dest[0] = ptr_to_mp(data->append_func); break; // converting from callback DBusGTypeSpecializedCollectionAppendFunc;
            case MP_QSTR_end_append_func: dest[0] = ptr_to_mp(data->end_append_func); break; // converting from callback DBusGTypeSpecializedCollectionEndAppendFunc;
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_base_vtable: data->base_vtable = mp_write_DBusGTypeSpecializedVtable(dest[1]); break; // converting to DBusGTypeSpecializedVtable;
                case MP_QSTR_fixed_accessor: data->fixed_accessor = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedCollectionVtable_fixed_accessor, NULL); break; // converting to callback DBusGTypeSpecializedCollectionFixedAccessorFunc;
                case MP_QSTR_iterator: data->iterator = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedCollectionVtable_iterator, NULL); break; // converting to callback DBusGTypeSpecializedCollectionIteratorFunc;
                case MP_QSTR_append_func: data->append_func = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedCollectionVtable_append_func, NULL); break; // converting to callback DBusGTypeSpecializedCollectionAppendFunc;
                case MP_QSTR_end_append_func: data->end_append_func = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedCollectionVtable_end_append_func, NULL); break; // converting to callback DBusGTypeSpecializedCollectionEndAppendFunc;
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_DBusGTypeSpecializedCollectionVtable_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct DBusGTypeSpecializedCollectionVtable");
}

STATIC const mp_rom_map_elem_t mp_DBusGTypeSpecializedCollectionVtable_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(DBusGTypeSpecializedCollectionVtable))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_DBusGTypeSpecializedCollectionVtable_locals_dict, mp_DBusGTypeSpecializedCollectionVtable_locals_dict_table);

STATIC const mp_obj_type_t mp_DBusGTypeSpecializedCollectionVtable_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBusGTypeSpecializedCollectionVtable,
    .print = mp_DBusGTypeSpecializedCollectionVtable_print,
    .make_new = make_new_lv_struct,
    .attr = mp_DBusGTypeSpecializedCollectionVtable_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_DBusGTypeSpecializedCollectionVtable_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_DBusGTypeSpecializedCollectionVtable_type()
{
    return &mp_DBusGTypeSpecializedCollectionVtable_type;
}
    

/*
 * dbus extension definition for:
 * void dbus_g_type_register_collection(const char *name, const DBusGTypeSpecializedCollectionVtable *vtable, guint flags)
 */
 
STATIC mp_obj_t mp_dbus_g_type_register_collection(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *name = (char*)mp_obj_str_get_str(mp_args[0]);
    const DBusGTypeSpecializedCollectionVtable *vtable = mp_write_ptr_DBusGTypeSpecializedCollectionVtable(mp_args[1]);
    guint flags = (unsigned int)mp_obj_get_int(mp_args[2]);
    dbus_g_type_register_collection(name, vtable, flags);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_register_collection_obj, 3, mp_dbus_g_type_register_collection, dbus_g_type_register_collection);

 

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedMapVtable_iterator_callback'
 * DBusGTypeSpecializedMapIteratorFunc iterator
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedMapVtable_append_func_callback'
 * DBusGTypeSpecializedMapAppendFunc append_func
 */
    

/*
 * Struct DBusGTypeSpecializedMapVtable
 */

STATIC inline const mp_obj_type_t *get_mp_DBusGTypeSpecializedMapVtable_type();

STATIC inline DBusGTypeSpecializedMapVtable* mp_write_ptr_DBusGTypeSpecializedMapVtable(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_DBusGTypeSpecializedMapVtable_type()));
    return (DBusGTypeSpecializedMapVtable*)self->data;
}

#define mp_write_DBusGTypeSpecializedMapVtable(struct_obj) *mp_write_ptr_DBusGTypeSpecializedMapVtable(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_DBusGTypeSpecializedMapVtable(DBusGTypeSpecializedMapVtable *field)
{
    return lv_to_mp_struct(get_mp_DBusGTypeSpecializedMapVtable_type(), (void*)field);
}

#define mp_read_DBusGTypeSpecializedMapVtable(field) mp_read_ptr_DBusGTypeSpecializedMapVtable(copy_buffer(&field, sizeof(DBusGTypeSpecializedMapVtable)))
#define mp_read_byref_DBusGTypeSpecializedMapVtable(field) mp_read_ptr_DBusGTypeSpecializedMapVtable(&field)

STATIC void mp_DBusGTypeSpecializedMapVtable_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    DBusGTypeSpecializedMapVtable *data = (DBusGTypeSpecializedMapVtable*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_base_vtable: dest[0] = mp_read_byref_DBusGTypeSpecializedVtable(data->base_vtable); break; // converting from DBusGTypeSpecializedVtable;
            case MP_QSTR_iterator: dest[0] = ptr_to_mp(data->iterator); break; // converting from callback DBusGTypeSpecializedMapIteratorFunc;
            case MP_QSTR_append_func: dest[0] = ptr_to_mp(data->append_func); break; // converting from callback DBusGTypeSpecializedMapAppendFunc;
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_base_vtable: data->base_vtable = mp_write_DBusGTypeSpecializedVtable(dest[1]); break; // converting to DBusGTypeSpecializedVtable;
                case MP_QSTR_iterator: data->iterator = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedMapVtable_iterator, NULL); break; // converting to callback DBusGTypeSpecializedMapIteratorFunc;
                case MP_QSTR_append_func: data->append_func = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedMapVtable_append_func, NULL); break; // converting to callback DBusGTypeSpecializedMapAppendFunc;
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_DBusGTypeSpecializedMapVtable_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct DBusGTypeSpecializedMapVtable");
}

STATIC const mp_rom_map_elem_t mp_DBusGTypeSpecializedMapVtable_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(DBusGTypeSpecializedMapVtable))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_DBusGTypeSpecializedMapVtable_locals_dict, mp_DBusGTypeSpecializedMapVtable_locals_dict_table);

STATIC const mp_obj_type_t mp_DBusGTypeSpecializedMapVtable_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBusGTypeSpecializedMapVtable,
    .print = mp_DBusGTypeSpecializedMapVtable_print,
    .make_new = make_new_lv_struct,
    .attr = mp_DBusGTypeSpecializedMapVtable_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_DBusGTypeSpecializedMapVtable_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_DBusGTypeSpecializedMapVtable_type()
{
    return &mp_DBusGTypeSpecializedMapVtable_type;
}
    

/*
 * dbus extension definition for:
 * void dbus_g_type_register_map(const char *name, const DBusGTypeSpecializedMapVtable *vtable, guint flags)
 */
 
STATIC mp_obj_t mp_dbus_g_type_register_map(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *name = (char*)mp_obj_str_get_str(mp_args[0]);
    const DBusGTypeSpecializedMapVtable *vtable = mp_write_ptr_DBusGTypeSpecializedMapVtable(mp_args[1]);
    guint flags = (unsigned int)mp_obj_get_int(mp_args[2]);
    dbus_g_type_register_map(name, vtable, flags);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_register_map_obj, 3, mp_dbus_g_type_register_map, dbus_g_type_register_map);

 

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedStructVtable_get_member_callback'
 * DBusGTypeSpecializedStructGetMember get_member
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusGTypeSpecializedStructVtable_set_member_callback'
 * DBusGTypeSpecializedStructSetMember set_member
 */
    

/*
 * Struct DBusGTypeSpecializedStructVtable
 */

STATIC inline const mp_obj_type_t *get_mp_DBusGTypeSpecializedStructVtable_type();

STATIC inline DBusGTypeSpecializedStructVtable* mp_write_ptr_DBusGTypeSpecializedStructVtable(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_DBusGTypeSpecializedStructVtable_type()));
    return (DBusGTypeSpecializedStructVtable*)self->data;
}

#define mp_write_DBusGTypeSpecializedStructVtable(struct_obj) *mp_write_ptr_DBusGTypeSpecializedStructVtable(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_DBusGTypeSpecializedStructVtable(DBusGTypeSpecializedStructVtable *field)
{
    return lv_to_mp_struct(get_mp_DBusGTypeSpecializedStructVtable_type(), (void*)field);
}

#define mp_read_DBusGTypeSpecializedStructVtable(field) mp_read_ptr_DBusGTypeSpecializedStructVtable(copy_buffer(&field, sizeof(DBusGTypeSpecializedStructVtable)))
#define mp_read_byref_DBusGTypeSpecializedStructVtable(field) mp_read_ptr_DBusGTypeSpecializedStructVtable(&field)

STATIC void mp_DBusGTypeSpecializedStructVtable_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    DBusGTypeSpecializedStructVtable *data = (DBusGTypeSpecializedStructVtable*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_base_vtable: dest[0] = mp_read_byref_DBusGTypeSpecializedVtable(data->base_vtable); break; // converting from DBusGTypeSpecializedVtable;
            case MP_QSTR_get_member: dest[0] = ptr_to_mp(data->get_member); break; // converting from callback DBusGTypeSpecializedStructGetMember;
            case MP_QSTR_set_member: dest[0] = ptr_to_mp(data->set_member); break; // converting from callback DBusGTypeSpecializedStructSetMember;
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_base_vtable: data->base_vtable = mp_write_DBusGTypeSpecializedVtable(dest[1]); break; // converting to DBusGTypeSpecializedVtable;
                case MP_QSTR_get_member: data->get_member = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedStructVtable_get_member, NULL); break; // converting to callback DBusGTypeSpecializedStructGetMember;
                case MP_QSTR_set_member: data->set_member = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusGTypeSpecializedStructVtable_set_member, NULL); break; // converting to callback DBusGTypeSpecializedStructSetMember;
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_DBusGTypeSpecializedStructVtable_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct DBusGTypeSpecializedStructVtable");
}

STATIC const mp_rom_map_elem_t mp_DBusGTypeSpecializedStructVtable_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(DBusGTypeSpecializedStructVtable))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_DBusGTypeSpecializedStructVtable_locals_dict, mp_DBusGTypeSpecializedStructVtable_locals_dict_table);

STATIC const mp_obj_type_t mp_DBusGTypeSpecializedStructVtable_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBusGTypeSpecializedStructVtable,
    .print = mp_DBusGTypeSpecializedStructVtable_print,
    .make_new = make_new_lv_struct,
    .attr = mp_DBusGTypeSpecializedStructVtable_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_DBusGTypeSpecializedStructVtable_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_DBusGTypeSpecializedStructVtable_type()
{
    return &mp_DBusGTypeSpecializedStructVtable_type;
}
    

/*
 * dbus extension definition for:
 * void dbus_g_type_register_struct(const char *name, const DBusGTypeSpecializedStructVtable *vtable, guint flags)
 */
 
STATIC mp_obj_t mp_dbus_g_type_register_struct(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *name = (char*)mp_obj_str_get_str(mp_args[0]);
    const DBusGTypeSpecializedStructVtable *vtable = mp_write_ptr_DBusGTypeSpecializedStructVtable(mp_args[1]);
    guint flags = (unsigned int)mp_obj_get_int(mp_args[2]);
    dbus_g_type_register_struct(name, vtable, flags);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_register_struct_obj, 3, mp_dbus_g_type_register_struct, dbus_g_type_register_struct);

 

/*
 * dbus extension definition for:
 * const DBusGTypeSpecializedMapVtable *dbus_g_type_map_peek_vtable(GType map_type)
 */
 
STATIC mp_obj_t mp_dbus_g_type_map_peek_vtable(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType map_type = (unsigned long)mp_obj_get_int(mp_args[0]);
    const DBusGTypeSpecializedMapVtable * res = dbus_g_type_map_peek_vtable(map_type);
    return mp_read_ptr_DBusGTypeSpecializedMapVtable((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_map_peek_vtable_obj, 1, mp_dbus_g_type_map_peek_vtable, dbus_g_type_map_peek_vtable);

 

/*
 * dbus extension definition for:
 * const DBusGTypeSpecializedCollectionVtable *dbus_g_type_collection_peek_vtable(GType collection_type)
 */
 
STATIC mp_obj_t mp_dbus_g_type_collection_peek_vtable(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType collection_type = (unsigned long)mp_obj_get_int(mp_args[0]);
    const DBusGTypeSpecializedCollectionVtable * res = dbus_g_type_collection_peek_vtable(collection_type);
    return mp_read_ptr_DBusGTypeSpecializedCollectionVtable((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_collection_peek_vtable_obj, 1, mp_dbus_g_type_collection_peek_vtable, dbus_g_type_collection_peek_vtable);

 

/*
 * dbus extension definition for:
 * const DBusGTypeSpecializedStructVtable *dbus_g_type_struct_peek_vtable(GType struct_type)
 */
 
STATIC mp_obj_t mp_dbus_g_type_struct_peek_vtable(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GType struct_type = (unsigned long)mp_obj_get_int(mp_args[0]);
    const DBusGTypeSpecializedStructVtable * res = dbus_g_type_struct_peek_vtable(struct_type);
    return mp_read_ptr_DBusGTypeSpecializedStructVtable((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_type_struct_peek_vtable_obj, 1, mp_dbus_g_type_struct_peek_vtable, dbus_g_type_struct_peek_vtable);

 

/*
 * dbus extension definition for:
 * GVariant *dbus_g_value_build_g_variant(const GValue *value)
 */
 
STATIC mp_obj_t mp_dbus_g_value_build_g_variant(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GValue *value = mp_to_ptr(mp_args[0]);
    GVariant * res = dbus_g_value_build_g_variant(value);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_value_build_g_variant_obj, 1, mp_dbus_g_value_build_g_variant, dbus_g_value_build_g_variant);

 

/*
 * dbus extension definition for:
 * GType dbus_g_object_path_get_g_type(void)
 */
 
STATIC mp_obj_t mp_dbus_g_object_path_get_g_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GType res = dbus_g_object_path_get_g_type();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_object_path_get_g_type_obj, 0, mp_dbus_g_object_path_get_g_type, dbus_g_object_path_get_g_type);

 

/*
 * dbus extension definition for:
 * GType dbus_g_signature_get_g_type(void)
 */
 
STATIC mp_obj_t mp_dbus_g_signature_get_g_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GType res = dbus_g_signature_get_g_type();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_signature_get_g_type_obj, 0, mp_dbus_g_signature_get_g_type, dbus_g_signature_get_g_type);

 

/*
 * Function NOT generated:
 * Callback argument 'GClosureMarshal marshaller' cannot be the first argument! We assume the first argument contains the user_data
 * GClosureMarshal marshaller
 */
    

/*
 * dbus extension definition for:
 * void dbus_g_object_register_marshaller(GClosureMarshal marshaller, GType rettype, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_object_register_marshaller(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GClosureMarshal marshaller = mp_to_ptr(mp_args[0]);
    GType rettype = (unsigned long)mp_obj_get_int(mp_args[1]);
    dbus_g_object_register_marshaller(marshaller, rettype);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_object_register_marshaller_obj, 3, mp_dbus_g_object_register_marshaller, dbus_g_object_register_marshaller);

 

/*
 * Function NOT generated:
 * Callback argument 'GClosureMarshal marshaller' cannot be the first argument! We assume the first argument contains the user_data
 * GClosureMarshal marshaller
 */
    

/*
 * dbus extension definition for:
 * void dbus_g_object_register_marshaller_array(GClosureMarshal marshaller, GType rettype, guint n_types, const GType *types)
 */
 
STATIC mp_obj_t mp_dbus_g_object_register_marshaller_array(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GClosureMarshal marshaller = mp_to_ptr(mp_args[0]);
    GType rettype = (unsigned long)mp_obj_get_int(mp_args[1]);
    guint n_types = (unsigned int)mp_obj_get_int(mp_args[2]);
    const GType *types = mp_to_ptr(mp_args[3]);
    dbus_g_object_register_marshaller_array(marshaller, rettype, n_types, types);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_object_register_marshaller_array_obj, 4, mp_dbus_g_object_register_marshaller_array, dbus_g_object_register_marshaller_array);

 

/*
 * dbus extension definition for:
 * GType dbus_g_proxy_get_type(void)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_get_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GType res = dbus_g_proxy_get_type();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_get_type_obj, 0, mp_dbus_g_proxy_get_type, dbus_g_proxy_get_type);

 

/*
 * dbus extension definition for:
 * DBusGProxy *dbus_g_proxy_new_for_name(DBusGConnection *connection, const char *name, const char *path, const char *iface)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_new_for_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGConnection *connection = mp_to_ptr(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[2]);
    const char *iface = (char*)mp_obj_str_get_str(mp_args[3]);
    DBusGProxy * res = dbus_g_proxy_new_for_name(connection, name, path, iface);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_new_for_name_obj, 4, mp_dbus_g_proxy_new_for_name, dbus_g_proxy_new_for_name);

 

/*
 * dbus extension definition for:
 * DBusGProxy *dbus_g_proxy_new_for_name_owner(DBusGConnection *connection, const char *name, const char *path, const char *iface, GError **error)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_new_for_name_owner(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGConnection *connection = mp_to_ptr(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[2]);
    const char *iface = (char*)mp_obj_str_get_str(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    DBusGProxy * res = dbus_g_proxy_new_for_name_owner(connection, name, path, iface, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_new_for_name_owner_obj, 5, mp_dbus_g_proxy_new_for_name_owner, dbus_g_proxy_new_for_name_owner);

 

/*
 * dbus extension definition for:
 * DBusGProxy *dbus_g_proxy_new_from_proxy(DBusGProxy *proxy, const char *iface, const char *path)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_new_from_proxy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char *iface = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[2]);
    DBusGProxy * res = dbus_g_proxy_new_from_proxy(proxy, iface, path);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_new_from_proxy_obj, 3, mp_dbus_g_proxy_new_from_proxy, dbus_g_proxy_new_from_proxy);

 

/*
 * dbus extension definition for:
 * DBusGProxy *dbus_g_proxy_new_for_peer(DBusGConnection *connection, const char *path, const char *iface)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_new_for_peer(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGConnection *connection = mp_to_ptr(mp_args[0]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *iface = (char*)mp_obj_str_get_str(mp_args[2]);
    DBusGProxy * res = dbus_g_proxy_new_for_peer(connection, path, iface);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_new_for_peer_obj, 3, mp_dbus_g_proxy_new_for_peer, dbus_g_proxy_new_for_peer);

 

/*
 * dbus extension definition for:
 * void dbus_g_proxy_set_interface(DBusGProxy *proxy, const char *interface_name)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_set_interface(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char *interface_name = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_g_proxy_set_interface(proxy, interface_name);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_set_interface_obj, 2, mp_dbus_g_proxy_set_interface, dbus_g_proxy_set_interface);

 

/*
 * dbus extension definition for:
 * void dbus_g_proxy_add_signal(DBusGProxy *proxy, const char *signal_name, GType first_type, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_add_signal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char *signal_name = (char*)mp_obj_str_get_str(mp_args[1]);
    GType first_type = (unsigned long)mp_obj_get_int(mp_args[2]);
    dbus_g_proxy_add_signal(proxy, signal_name, first_type);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_add_signal_obj, 4, mp_dbus_g_proxy_add_signal, dbus_g_proxy_add_signal);

 

/*
 * Function NOT generated:
 * Callback function 'GCallback handler' must receive a struct pointer with user_data member as its first argument!
 * GCallback handler
 */
    

/*
 * Function NOT generated:
 * Callback function 'GClosureNotify free_data_func' must receive a struct pointer with user_data member as its first argument!
 * GClosureNotify free_data_func
 */
    

/*
 * dbus extension definition for:
 * void dbus_g_proxy_connect_signal(DBusGProxy *proxy, const char *signal_name, GCallback handler, void *data, GClosureNotify free_data_func)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_connect_signal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char *signal_name = (char*)mp_obj_str_get_str(mp_args[1]);
    GCallback handler = mp_to_ptr(mp_args[2]);
    void *data = mp_to_ptr(mp_args[3]);
    GClosureNotify free_data_func = mp_to_ptr(mp_args[4]);
    dbus_g_proxy_connect_signal(proxy, signal_name, handler, data, free_data_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_connect_signal_obj, 5, mp_dbus_g_proxy_connect_signal, dbus_g_proxy_connect_signal);

 

/*
 * Function NOT generated:
 * Callback function 'GCallback handler' must receive a struct pointer with user_data member as its first argument!
 * GCallback handler
 */
    

/*
 * dbus extension definition for:
 * void dbus_g_proxy_disconnect_signal(DBusGProxy *proxy, const char *signal_name, GCallback handler, void *data)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_disconnect_signal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char *signal_name = (char*)mp_obj_str_get_str(mp_args[1]);
    GCallback handler = mp_to_ptr(mp_args[2]);
    void *data = mp_to_ptr(mp_args[3]);
    dbus_g_proxy_disconnect_signal(proxy, signal_name, handler, data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_disconnect_signal_obj, 4, mp_dbus_g_proxy_disconnect_signal, dbus_g_proxy_disconnect_signal);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_proxy_call(DBusGProxy *proxy, const char *method, GError **error, GType first_arg_type, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_call(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char *method = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    GType first_arg_type = (unsigned long)mp_obj_get_int(mp_args[3]);
    gboolean res = dbus_g_proxy_call(proxy, method, error, first_arg_type);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_call_obj, 5, mp_dbus_g_proxy_call, dbus_g_proxy_call);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_proxy_call_with_timeout(DBusGProxy *proxy, const char *method, int timeout, GError **error, GType first_arg_type, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_call_with_timeout(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char *method = (char*)mp_obj_str_get_str(mp_args[1]);
    int timeout = (int)mp_obj_get_int(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    GType first_arg_type = (unsigned long)mp_obj_get_int(mp_args[4]);
    gboolean res = dbus_g_proxy_call_with_timeout(proxy, method, timeout, error, first_arg_type);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_call_with_timeout_obj, 6, mp_dbus_g_proxy_call_with_timeout, dbus_g_proxy_call_with_timeout);

 

/*
 * dbus extension definition for:
 * void dbus_g_proxy_call_no_reply(DBusGProxy *proxy, const char *method, GType first_arg_type, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_call_no_reply(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char *method = (char*)mp_obj_str_get_str(mp_args[1]);
    GType first_arg_type = (unsigned long)mp_obj_get_int(mp_args[2]);
    dbus_g_proxy_call_no_reply(proxy, method, first_arg_type);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_call_no_reply_obj, 4, mp_dbus_g_proxy_call_no_reply, dbus_g_proxy_call_no_reply);

 

/*
 * Function NOT generated:
 * Callback function 'DBusGProxyCallNotify notify' must receive a struct pointer with user_data member as its first argument!
 * DBusGProxyCallNotify notify
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify destroy' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify destroy
 */
    

/*
 * dbus extension definition for:
 * DBusGProxyCall *dbus_g_proxy_begin_call(DBusGProxy *proxy, const char *method, DBusGProxyCallNotify notify, gpointer user_data, GDestroyNotify destroy, GType first_arg_type, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_begin_call(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char *method = (char*)mp_obj_str_get_str(mp_args[1]);
    DBusGProxyCallNotify notify = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    GDestroyNotify destroy = mp_to_ptr(mp_args[4]);
    GType first_arg_type = (unsigned long)mp_obj_get_int(mp_args[5]);
    DBusGProxyCall * res = dbus_g_proxy_begin_call(proxy, method, notify, user_data, destroy, first_arg_type);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_begin_call_obj, 7, mp_dbus_g_proxy_begin_call, dbus_g_proxy_begin_call);

 

/*
 * Function NOT generated:
 * Callback function 'DBusGProxyCallNotify notify' must receive a struct pointer with user_data member as its first argument!
 * DBusGProxyCallNotify notify
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify destroy' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify destroy
 */
    

/*
 * dbus extension definition for:
 * DBusGProxyCall *dbus_g_proxy_begin_call_with_timeout(DBusGProxy *proxy, const char *method, DBusGProxyCallNotify notify, gpointer user_data, GDestroyNotify destroy, int timeout, GType first_arg_type, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_begin_call_with_timeout(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char *method = (char*)mp_obj_str_get_str(mp_args[1]);
    DBusGProxyCallNotify notify = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    GDestroyNotify destroy = mp_to_ptr(mp_args[4]);
    int timeout = (int)mp_obj_get_int(mp_args[5]);
    GType first_arg_type = (unsigned long)mp_obj_get_int(mp_args[6]);
    DBusGProxyCall * res = dbus_g_proxy_begin_call_with_timeout(proxy, method, notify, user_data, destroy, timeout, first_arg_type);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_begin_call_with_timeout_obj, 8, mp_dbus_g_proxy_begin_call_with_timeout, dbus_g_proxy_begin_call_with_timeout);

 

/*
 * dbus extension definition for:
 * void dbus_g_proxy_set_default_timeout(DBusGProxy *proxy, int timeout)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_set_default_timeout(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    int timeout = (int)mp_obj_get_int(mp_args[1]);
    dbus_g_proxy_set_default_timeout(proxy, timeout);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_set_default_timeout_obj, 2, mp_dbus_g_proxy_set_default_timeout, dbus_g_proxy_set_default_timeout);

 

/*
 * dbus extension definition for:
 * gboolean dbus_g_proxy_end_call(DBusGProxy *proxy, DBusGProxyCall *call, GError **error, GType first_arg_type, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_end_call(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    DBusGProxyCall *call = mp_to_ptr(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    GType first_arg_type = (unsigned long)mp_obj_get_int(mp_args[3]);
    gboolean res = dbus_g_proxy_end_call(proxy, call, error, first_arg_type);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_end_call_obj, 5, mp_dbus_g_proxy_end_call, dbus_g_proxy_end_call);

 

/*
 * dbus extension definition for:
 * void dbus_g_proxy_cancel_call(DBusGProxy *proxy, DBusGProxyCall *call)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_cancel_call(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    DBusGProxyCall *call = mp_to_ptr(mp_args[1]);
    dbus_g_proxy_cancel_call(proxy, call);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_cancel_call_obj, 2, mp_dbus_g_proxy_cancel_call, dbus_g_proxy_cancel_call);

 

/*
 * dbus extension definition for:
 * const char *dbus_g_proxy_get_path(DBusGProxy *proxy)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_get_path(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char * res = dbus_g_proxy_get_path(proxy);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_get_path_obj, 1, mp_dbus_g_proxy_get_path, dbus_g_proxy_get_path);

 

/*
 * dbus extension definition for:
 * const char *dbus_g_proxy_get_bus_name(DBusGProxy *proxy)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_get_bus_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char * res = dbus_g_proxy_get_bus_name(proxy);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_get_bus_name_obj, 1, mp_dbus_g_proxy_get_bus_name, dbus_g_proxy_get_bus_name);

 

/*
 * dbus extension definition for:
 * const char *dbus_g_proxy_get_interface(DBusGProxy *proxy)
 */
 
STATIC mp_obj_t mp_dbus_g_proxy_get_interface(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGProxy *proxy = mp_to_ptr(mp_args[0]);
    const char * res = dbus_g_proxy_get_interface(proxy);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_proxy_get_interface_obj, 1, mp_dbus_g_proxy_get_interface, dbus_g_proxy_get_interface);

 

/*
 * dbus extension definition for:
 * void dbus_g_method_return(DBusGMethodInvocation *context, ...)
 */
 
STATIC mp_obj_t mp_dbus_g_method_return(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGMethodInvocation *context = mp_to_ptr(mp_args[0]);
    dbus_g_method_return(context);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_method_return_obj, 2, mp_dbus_g_method_return, dbus_g_method_return);

 

/*
 * dbus extension definition for:
 * void dbus_g_method_return_error(DBusGMethodInvocation *context, const GError *error)
 */
 
STATIC mp_obj_t mp_dbus_g_method_return_error(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGMethodInvocation *context = mp_to_ptr(mp_args[0]);
    const GError *error = mp_to_ptr(mp_args[1]);
    dbus_g_method_return_error(context, error);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_method_return_error_obj, 2, mp_dbus_g_method_return_error, dbus_g_method_return_error);

 

/*
 * dbus extension definition for:
 * DBusGConnection *dbus_g_method_invocation_get_g_connection(DBusGMethodInvocation *context)
 */
 
STATIC mp_obj_t mp_dbus_g_method_invocation_get_g_connection(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusGMethodInvocation *context = mp_to_ptr(mp_args[0]);
    DBusGConnection * res = dbus_g_method_invocation_get_g_connection(context);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_method_invocation_get_g_connection_obj, 1, mp_dbus_g_method_invocation_get_g_connection, dbus_g_method_invocation_get_g_connection);

 

/*
 * dbus extension definition for:
 * void dbus_g_value_parse_g_variant(GVariant *variant, GValue *value)
 */
 
STATIC mp_obj_t mp_dbus_g_value_parse_g_variant(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GVariant *variant = mp_to_ptr(mp_args[0]);
    GValue *value = mp_to_ptr(mp_args[1]);
    dbus_g_value_parse_g_variant(variant, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_g_value_parse_g_variant_obj, 2, mp_dbus_g_value_parse_g_variant, dbus_g_value_parse_g_variant);

 

/*
 * dbus G object definitions
 */
    

STATIC const mp_rom_map_elem_t G_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_connection_get_g_type), MP_ROM_PTR(&mp_dbus_g_connection_get_g_type_obj) },
    { MP_ROM_QSTR(MP_QSTR_message_get_g_type), MP_ROM_PTR(&mp_dbus_g_message_get_g_type_obj) },
    { MP_ROM_QSTR(MP_QSTR_connection_ref), MP_ROM_PTR(&mp_dbus_g_connection_ref_obj) },
    { MP_ROM_QSTR(MP_QSTR_connection_unref), MP_ROM_PTR(&mp_dbus_g_connection_unref_obj) },
    { MP_ROM_QSTR(MP_QSTR_message_ref), MP_ROM_PTR(&mp_dbus_g_message_ref_obj) },
    { MP_ROM_QSTR(MP_QSTR_message_unref), MP_ROM_PTR(&mp_dbus_g_message_unref_obj) },
    { MP_ROM_QSTR(MP_QSTR_connection_flush), MP_ROM_PTR(&mp_dbus_g_connection_flush_obj) },
    { MP_ROM_QSTR(MP_QSTR_error_quark), MP_ROM_PTR(&mp_dbus_g_error_quark_obj) },
    { MP_ROM_QSTR(MP_QSTR_error_has_name), MP_ROM_PTR(&mp_dbus_g_error_has_name_obj) },
    { MP_ROM_QSTR(MP_QSTR_error_get_name), MP_ROM_PTR(&mp_dbus_g_error_get_name_obj) },
    { MP_ROM_QSTR(MP_QSTR_thread_init), MP_ROM_PTR(&mp_dbus_g_thread_init_obj) },
    { MP_ROM_QSTR(MP_QSTR_connection_open), MP_ROM_PTR(&mp_dbus_g_connection_open_obj) },
    { MP_ROM_QSTR(MP_QSTR_connection_open_private), MP_ROM_PTR(&mp_dbus_g_connection_open_private_obj) },
    { MP_ROM_QSTR(MP_QSTR_bus_get), MP_ROM_PTR(&mp_dbus_g_bus_get_obj) },
    { MP_ROM_QSTR(MP_QSTR_bus_get_private), MP_ROM_PTR(&mp_dbus_g_bus_get_private_obj) },
    { MP_ROM_QSTR(MP_QSTR_object_type_install_info), MP_ROM_PTR(&mp_dbus_g_object_type_install_info_obj) },
    { MP_ROM_QSTR(MP_QSTR_object_type_register_shadow_property), MP_ROM_PTR(&mp_dbus_g_object_type_register_shadow_property_obj) },
    { MP_ROM_QSTR(MP_QSTR_error_domain_register), MP_ROM_PTR(&mp_dbus_g_error_domain_register_obj) },
    { MP_ROM_QSTR(MP_QSTR_connection_register_g_object), MP_ROM_PTR(&mp_dbus_g_connection_register_g_object_obj) },
    { MP_ROM_QSTR(MP_QSTR_connection_unregister_g_object), MP_ROM_PTR(&mp_dbus_g_connection_unregister_g_object_obj) },
    { MP_ROM_QSTR(MP_QSTR_connection_lookup_g_object), MP_ROM_PTR(&mp_dbus_g_connection_lookup_g_object_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_get_collection), MP_ROM_PTR(&mp_dbus_g_type_get_collection_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_get_map), MP_ROM_PTR(&mp_dbus_g_type_get_map_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_get_structv), MP_ROM_PTR(&mp_dbus_g_type_get_structv_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_get_struct), MP_ROM_PTR(&mp_dbus_g_type_get_struct_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_is_collection), MP_ROM_PTR(&mp_dbus_g_type_is_collection_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_is_map), MP_ROM_PTR(&mp_dbus_g_type_is_map_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_is_struct), MP_ROM_PTR(&mp_dbus_g_type_is_struct_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_get_collection_specialization), MP_ROM_PTR(&mp_dbus_g_type_get_collection_specialization_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_get_map_key_specialization), MP_ROM_PTR(&mp_dbus_g_type_get_map_key_specialization_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_get_map_value_specialization), MP_ROM_PTR(&mp_dbus_g_type_get_map_value_specialization_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_get_struct_member_type), MP_ROM_PTR(&mp_dbus_g_type_get_struct_member_type_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_get_struct_size), MP_ROM_PTR(&mp_dbus_g_type_get_struct_size_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_specialized_construct), MP_ROM_PTR(&mp_dbus_g_type_specialized_construct_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_specialized_init_append), MP_ROM_PTR(&mp_dbus_g_type_specialized_init_append_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_specialized_collection_append), MP_ROM_PTR(&mp_dbus_g_type_specialized_collection_append_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_specialized_collection_end_append), MP_ROM_PTR(&mp_dbus_g_type_specialized_collection_end_append_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_specialized_map_append), MP_ROM_PTR(&mp_dbus_g_type_specialized_map_append_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_collection_get_fixed), MP_ROM_PTR(&mp_dbus_g_type_collection_get_fixed_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_collection_value_iterate), MP_ROM_PTR(&mp_dbus_g_type_collection_value_iterate_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_map_value_iterate), MP_ROM_PTR(&mp_dbus_g_type_map_value_iterate_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_struct_get_member), MP_ROM_PTR(&mp_dbus_g_type_struct_get_member_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_struct_set_member), MP_ROM_PTR(&mp_dbus_g_type_struct_set_member_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_struct_get), MP_ROM_PTR(&mp_dbus_g_type_struct_get_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_struct_set), MP_ROM_PTR(&mp_dbus_g_type_struct_set_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_specialized_init), MP_ROM_PTR(&mp_dbus_g_type_specialized_init_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_register_collection), MP_ROM_PTR(&mp_dbus_g_type_register_collection_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_register_map), MP_ROM_PTR(&mp_dbus_g_type_register_map_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_register_struct), MP_ROM_PTR(&mp_dbus_g_type_register_struct_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_map_peek_vtable), MP_ROM_PTR(&mp_dbus_g_type_map_peek_vtable_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_collection_peek_vtable), MP_ROM_PTR(&mp_dbus_g_type_collection_peek_vtable_obj) },
    { MP_ROM_QSTR(MP_QSTR_type_struct_peek_vtable), MP_ROM_PTR(&mp_dbus_g_type_struct_peek_vtable_obj) },
    { MP_ROM_QSTR(MP_QSTR_value_build_g_variant), MP_ROM_PTR(&mp_dbus_g_value_build_g_variant_obj) },
    { MP_ROM_QSTR(MP_QSTR_object_path_get_g_type), MP_ROM_PTR(&mp_dbus_g_object_path_get_g_type_obj) },
    { MP_ROM_QSTR(MP_QSTR_signature_get_g_type), MP_ROM_PTR(&mp_dbus_g_signature_get_g_type_obj) },
    { MP_ROM_QSTR(MP_QSTR_object_register_marshaller), MP_ROM_PTR(&mp_dbus_g_object_register_marshaller_obj) },
    { MP_ROM_QSTR(MP_QSTR_object_register_marshaller_array), MP_ROM_PTR(&mp_dbus_g_object_register_marshaller_array_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_get_type), MP_ROM_PTR(&mp_dbus_g_proxy_get_type_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_new_for_name), MP_ROM_PTR(&mp_dbus_g_proxy_new_for_name_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_new_for_name_owner), MP_ROM_PTR(&mp_dbus_g_proxy_new_for_name_owner_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_new_from_proxy), MP_ROM_PTR(&mp_dbus_g_proxy_new_from_proxy_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_new_for_peer), MP_ROM_PTR(&mp_dbus_g_proxy_new_for_peer_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_set_interface), MP_ROM_PTR(&mp_dbus_g_proxy_set_interface_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_add_signal), MP_ROM_PTR(&mp_dbus_g_proxy_add_signal_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_connect_signal), MP_ROM_PTR(&mp_dbus_g_proxy_connect_signal_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_disconnect_signal), MP_ROM_PTR(&mp_dbus_g_proxy_disconnect_signal_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_call), MP_ROM_PTR(&mp_dbus_g_proxy_call_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_call_with_timeout), MP_ROM_PTR(&mp_dbus_g_proxy_call_with_timeout_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_call_no_reply), MP_ROM_PTR(&mp_dbus_g_proxy_call_no_reply_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_begin_call), MP_ROM_PTR(&mp_dbus_g_proxy_begin_call_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_begin_call_with_timeout), MP_ROM_PTR(&mp_dbus_g_proxy_begin_call_with_timeout_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_set_default_timeout), MP_ROM_PTR(&mp_dbus_g_proxy_set_default_timeout_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_end_call), MP_ROM_PTR(&mp_dbus_g_proxy_end_call_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_cancel_call), MP_ROM_PTR(&mp_dbus_g_proxy_cancel_call_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_get_path), MP_ROM_PTR(&mp_dbus_g_proxy_get_path_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_get_bus_name), MP_ROM_PTR(&mp_dbus_g_proxy_get_bus_name_obj) },
    { MP_ROM_QSTR(MP_QSTR_proxy_get_interface), MP_ROM_PTR(&mp_dbus_g_proxy_get_interface_obj) },
    { MP_ROM_QSTR(MP_QSTR_method_return), MP_ROM_PTR(&mp_dbus_g_method_return_obj) },
    { MP_ROM_QSTR(MP_QSTR_method_return_error), MP_ROM_PTR(&mp_dbus_g_method_return_error_obj) },
    { MP_ROM_QSTR(MP_QSTR_method_invocation_get_g_connection), MP_ROM_PTR(&mp_dbus_g_method_invocation_get_g_connection_obj) },
    { MP_ROM_QSTR(MP_QSTR_value_parse_g_variant), MP_ROM_PTR(&mp_dbus_g_value_parse_g_variant_obj) },
    { MP_ROM_QSTR(MP_QSTR_IN_ORDER), MP_ROM_PTR(MP_ROM_INT(G_IN_ORDER)) },
    { MP_ROM_QSTR(MP_QSTR_PRE_ORDER), MP_ROM_PTR(MP_ROM_INT(G_PRE_ORDER)) },
    { MP_ROM_QSTR(MP_QSTR_POST_ORDER), MP_ROM_PTR(MP_ROM_INT(G_POST_ORDER)) },
    { MP_ROM_QSTR(MP_QSTR_LEVEL_ORDER), MP_ROM_PTR(MP_ROM_INT(G_LEVEL_ORDER)) }
};

STATIC MP_DEFINE_CONST_DICT(G_locals_dict, G_locals_dict_table);

STATIC void G_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G");
}



STATIC const mp_obj_type_t mp_G_type = {
    { &mp_type_type },
    .name = MP_QSTR_G,
    .print = G_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_HOOK_FLAG object definitions
 */
    

STATIC const mp_rom_map_elem_t G_HOOK_FLAG_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_ACTIVE), MP_ROM_PTR(MP_ROM_INT(G_HOOK_FLAG_ACTIVE)) },
    { MP_ROM_QSTR(MP_QSTR_IN_CALL), MP_ROM_PTR(MP_ROM_INT(G_HOOK_FLAG_IN_CALL)) },
    { MP_ROM_QSTR(MP_QSTR_MASK), MP_ROM_PTR(MP_ROM_INT(G_HOOK_FLAG_MASK)) }
};

STATIC MP_DEFINE_CONST_DICT(G_HOOK_FLAG_locals_dict, G_HOOK_FLAG_locals_dict_table);

STATIC void G_HOOK_FLAG_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_HOOK_FLAG");
}



STATIC const mp_obj_type_t mp_G_HOOK_FLAG_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_HOOK_FLAG,
    .print = G_HOOK_FLAG_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_HOOK_FLAG_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_IO object definitions
 */
    

STATIC const mp_rom_map_elem_t G_IO_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_IN), MP_ROM_PTR(MP_ROM_INT(G_IO_IN)) },
    { MP_ROM_QSTR(MP_QSTR_OUT), MP_ROM_PTR(MP_ROM_INT(G_IO_OUT)) },
    { MP_ROM_QSTR(MP_QSTR_PRI), MP_ROM_PTR(MP_ROM_INT(G_IO_PRI)) },
    { MP_ROM_QSTR(MP_QSTR_ERR), MP_ROM_PTR(MP_ROM_INT(G_IO_ERR)) },
    { MP_ROM_QSTR(MP_QSTR_HUP), MP_ROM_PTR(MP_ROM_INT(G_IO_HUP)) },
    { MP_ROM_QSTR(MP_QSTR_NVAL), MP_ROM_PTR(MP_ROM_INT(G_IO_NVAL)) }
};

STATIC MP_DEFINE_CONST_DICT(G_IO_locals_dict, G_IO_locals_dict_table);

STATIC void G_IO_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_IO");
}



STATIC const mp_obj_type_t mp_G_IO_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_IO,
    .print = G_IO_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_IO_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_UNICODE object definitions
 */
    

STATIC const mp_rom_map_elem_t G_UNICODE_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_CONTROL), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_CONTROL)) },
    { MP_ROM_QSTR(MP_QSTR_FORMAT), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_FORMAT)) },
    { MP_ROM_QSTR(MP_QSTR_UNASSIGNED), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_UNASSIGNED)) },
    { MP_ROM_QSTR(MP_QSTR_PRIVATE_USE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_PRIVATE_USE)) },
    { MP_ROM_QSTR(MP_QSTR_SURROGATE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SURROGATE)) },
    { MP_ROM_QSTR(MP_QSTR_LOWERCASE_LETTER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_LOWERCASE_LETTER)) },
    { MP_ROM_QSTR(MP_QSTR_MODIFIER_LETTER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_MODIFIER_LETTER)) },
    { MP_ROM_QSTR(MP_QSTR_OTHER_LETTER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_OTHER_LETTER)) },
    { MP_ROM_QSTR(MP_QSTR_TITLECASE_LETTER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_TITLECASE_LETTER)) },
    { MP_ROM_QSTR(MP_QSTR_UPPERCASE_LETTER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_UPPERCASE_LETTER)) },
    { MP_ROM_QSTR(MP_QSTR_SPACING_MARK), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SPACING_MARK)) },
    { MP_ROM_QSTR(MP_QSTR_ENCLOSING_MARK), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_ENCLOSING_MARK)) },
    { MP_ROM_QSTR(MP_QSTR_NON_SPACING_MARK), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_NON_SPACING_MARK)) },
    { MP_ROM_QSTR(MP_QSTR_DECIMAL_NUMBER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_DECIMAL_NUMBER)) },
    { MP_ROM_QSTR(MP_QSTR_LETTER_NUMBER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_LETTER_NUMBER)) },
    { MP_ROM_QSTR(MP_QSTR_OTHER_NUMBER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_OTHER_NUMBER)) },
    { MP_ROM_QSTR(MP_QSTR_CONNECT_PUNCTUATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_CONNECT_PUNCTUATION)) },
    { MP_ROM_QSTR(MP_QSTR_DASH_PUNCTUATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_DASH_PUNCTUATION)) },
    { MP_ROM_QSTR(MP_QSTR_CLOSE_PUNCTUATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_CLOSE_PUNCTUATION)) },
    { MP_ROM_QSTR(MP_QSTR_FINAL_PUNCTUATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_FINAL_PUNCTUATION)) },
    { MP_ROM_QSTR(MP_QSTR_INITIAL_PUNCTUATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_INITIAL_PUNCTUATION)) },
    { MP_ROM_QSTR(MP_QSTR_OTHER_PUNCTUATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_OTHER_PUNCTUATION)) },
    { MP_ROM_QSTR(MP_QSTR_OPEN_PUNCTUATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_OPEN_PUNCTUATION)) },
    { MP_ROM_QSTR(MP_QSTR_CURRENCY_SYMBOL), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_CURRENCY_SYMBOL)) },
    { MP_ROM_QSTR(MP_QSTR_MODIFIER_SYMBOL), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_MODIFIER_SYMBOL)) },
    { MP_ROM_QSTR(MP_QSTR_MATH_SYMBOL), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_MATH_SYMBOL)) },
    { MP_ROM_QSTR(MP_QSTR_OTHER_SYMBOL), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_OTHER_SYMBOL)) },
    { MP_ROM_QSTR(MP_QSTR_LINE_SEPARATOR), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_LINE_SEPARATOR)) },
    { MP_ROM_QSTR(MP_QSTR_PARAGRAPH_SEPARATOR), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_PARAGRAPH_SEPARATOR)) },
    { MP_ROM_QSTR(MP_QSTR_SPACE_SEPARATOR), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SPACE_SEPARATOR)) }
};

STATIC MP_DEFINE_CONST_DICT(G_UNICODE_locals_dict, G_UNICODE_locals_dict_table);

STATIC void G_UNICODE_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_UNICODE");
}



STATIC const mp_obj_type_t mp_G_UNICODE_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_UNICODE,
    .print = G_UNICODE_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_UNICODE_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_UNICODE_BREAK object definitions
 */
    

STATIC const mp_rom_map_elem_t G_UNICODE_BREAK_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_MANDATORY), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_MANDATORY)) },
    { MP_ROM_QSTR(MP_QSTR_CARRIAGE_RETURN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_CARRIAGE_RETURN)) },
    { MP_ROM_QSTR(MP_QSTR_LINE_FEED), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_LINE_FEED)) },
    { MP_ROM_QSTR(MP_QSTR_COMBINING_MARK), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_COMBINING_MARK)) },
    { MP_ROM_QSTR(MP_QSTR_SURROGATE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_SURROGATE)) },
    { MP_ROM_QSTR(MP_QSTR_ZERO_WIDTH_SPACE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_ZERO_WIDTH_SPACE)) },
    { MP_ROM_QSTR(MP_QSTR_INSEPARABLE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_INSEPARABLE)) },
    { MP_ROM_QSTR(MP_QSTR_NON_BREAKING_GLUE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_NON_BREAKING_GLUE)) },
    { MP_ROM_QSTR(MP_QSTR_CONTINGENT), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_CONTINGENT)) },
    { MP_ROM_QSTR(MP_QSTR_SPACE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_SPACE)) },
    { MP_ROM_QSTR(MP_QSTR_AFTER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_AFTER)) },
    { MP_ROM_QSTR(MP_QSTR_BEFORE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_BEFORE)) },
    { MP_ROM_QSTR(MP_QSTR_BEFORE_AND_AFTER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_BEFORE_AND_AFTER)) },
    { MP_ROM_QSTR(MP_QSTR_HYPHEN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_HYPHEN)) },
    { MP_ROM_QSTR(MP_QSTR_NON_STARTER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_NON_STARTER)) },
    { MP_ROM_QSTR(MP_QSTR_OPEN_PUNCTUATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_OPEN_PUNCTUATION)) },
    { MP_ROM_QSTR(MP_QSTR_CLOSE_PUNCTUATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_CLOSE_PUNCTUATION)) },
    { MP_ROM_QSTR(MP_QSTR_QUOTATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_QUOTATION)) },
    { MP_ROM_QSTR(MP_QSTR_EXCLAMATION), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_EXCLAMATION)) },
    { MP_ROM_QSTR(MP_QSTR_IDEOGRAPHIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_IDEOGRAPHIC)) },
    { MP_ROM_QSTR(MP_QSTR_NUMERIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_NUMERIC)) },
    { MP_ROM_QSTR(MP_QSTR_INFIX_SEPARATOR), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_INFIX_SEPARATOR)) },
    { MP_ROM_QSTR(MP_QSTR_SYMBOL), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_SYMBOL)) },
    { MP_ROM_QSTR(MP_QSTR_ALPHABETIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_ALPHABETIC)) },
    { MP_ROM_QSTR(MP_QSTR_PREFIX), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_PREFIX)) },
    { MP_ROM_QSTR(MP_QSTR_POSTFIX), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_POSTFIX)) },
    { MP_ROM_QSTR(MP_QSTR_COMPLEX_CONTEXT), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_COMPLEX_CONTEXT)) },
    { MP_ROM_QSTR(MP_QSTR_AMBIGUOUS), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_AMBIGUOUS)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_UNKNOWN)) },
    { MP_ROM_QSTR(MP_QSTR_NEXT_LINE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_NEXT_LINE)) },
    { MP_ROM_QSTR(MP_QSTR_WORD_JOINER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_WORD_JOINER)) },
    { MP_ROM_QSTR(MP_QSTR_HANGUL_L_JAMO), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_HANGUL_L_JAMO)) },
    { MP_ROM_QSTR(MP_QSTR_HANGUL_V_JAMO), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_HANGUL_V_JAMO)) },
    { MP_ROM_QSTR(MP_QSTR_HANGUL_T_JAMO), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_HANGUL_T_JAMO)) },
    { MP_ROM_QSTR(MP_QSTR_HANGUL_LV_SYLLABLE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_HANGUL_LV_SYLLABLE)) },
    { MP_ROM_QSTR(MP_QSTR_HANGUL_LVT_SYLLABLE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE)) },
    { MP_ROM_QSTR(MP_QSTR_CLOSE_PARANTHESIS), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_CLOSE_PARANTHESIS)) },
    { MP_ROM_QSTR(MP_QSTR_CONDITIONAL_JAPANESE_STARTER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER)) },
    { MP_ROM_QSTR(MP_QSTR_HEBREW_LETTER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_HEBREW_LETTER)) },
    { MP_ROM_QSTR(MP_QSTR_REGIONAL_INDICATOR), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_BREAK_REGIONAL_INDICATOR)) }
};

STATIC MP_DEFINE_CONST_DICT(G_UNICODE_BREAK_locals_dict, G_UNICODE_BREAK_locals_dict_table);

STATIC void G_UNICODE_BREAK_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_UNICODE_BREAK");
}



STATIC const mp_obj_type_t mp_G_UNICODE_BREAK_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_UNICODE_BREAK,
    .print = G_UNICODE_BREAK_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_UNICODE_BREAK_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_UNICODE_SCRIPT object definitions
 */
    

STATIC const mp_rom_map_elem_t G_UNICODE_SCRIPT_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_INVALID_CODE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_INVALID_CODE)) },
    { MP_ROM_QSTR(MP_QSTR_COMMON), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_COMMON)) },
    { MP_ROM_QSTR(MP_QSTR_INHERITED), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_INHERITED)) },
    { MP_ROM_QSTR(MP_QSTR_ARABIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_ARABIC)) },
    { MP_ROM_QSTR(MP_QSTR_ARMENIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_ARMENIAN)) },
    { MP_ROM_QSTR(MP_QSTR_BENGALI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_BENGALI)) },
    { MP_ROM_QSTR(MP_QSTR_BOPOMOFO), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_BOPOMOFO)) },
    { MP_ROM_QSTR(MP_QSTR_CHEROKEE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_CHEROKEE)) },
    { MP_ROM_QSTR(MP_QSTR_COPTIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_COPTIC)) },
    { MP_ROM_QSTR(MP_QSTR_CYRILLIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_CYRILLIC)) },
    { MP_ROM_QSTR(MP_QSTR_DESERET), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_DESERET)) },
    { MP_ROM_QSTR(MP_QSTR_DEVANAGARI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_DEVANAGARI)) },
    { MP_ROM_QSTR(MP_QSTR_ETHIOPIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_ETHIOPIC)) },
    { MP_ROM_QSTR(MP_QSTR_GEORGIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_GEORGIAN)) },
    { MP_ROM_QSTR(MP_QSTR_GOTHIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_GOTHIC)) },
    { MP_ROM_QSTR(MP_QSTR_GREEK), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_GREEK)) },
    { MP_ROM_QSTR(MP_QSTR_GUJARATI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_GUJARATI)) },
    { MP_ROM_QSTR(MP_QSTR_GURMUKHI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_GURMUKHI)) },
    { MP_ROM_QSTR(MP_QSTR_HAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_HAN)) },
    { MP_ROM_QSTR(MP_QSTR_HANGUL), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_HANGUL)) },
    { MP_ROM_QSTR(MP_QSTR_HEBREW), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_HEBREW)) },
    { MP_ROM_QSTR(MP_QSTR_HIRAGANA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_HIRAGANA)) },
    { MP_ROM_QSTR(MP_QSTR_KANNADA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_KANNADA)) },
    { MP_ROM_QSTR(MP_QSTR_KATAKANA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_KATAKANA)) },
    { MP_ROM_QSTR(MP_QSTR_KHMER), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_KHMER)) },
    { MP_ROM_QSTR(MP_QSTR_LAO), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_LAO)) },
    { MP_ROM_QSTR(MP_QSTR_LATIN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_LATIN)) },
    { MP_ROM_QSTR(MP_QSTR_MALAYALAM), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MALAYALAM)) },
    { MP_ROM_QSTR(MP_QSTR_MONGOLIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MONGOLIAN)) },
    { MP_ROM_QSTR(MP_QSTR_MYANMAR), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MYANMAR)) },
    { MP_ROM_QSTR(MP_QSTR_OGHAM), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_OGHAM)) },
    { MP_ROM_QSTR(MP_QSTR_OLD_ITALIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_OLD_ITALIC)) },
    { MP_ROM_QSTR(MP_QSTR_ORIYA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_ORIYA)) },
    { MP_ROM_QSTR(MP_QSTR_RUNIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_RUNIC)) },
    { MP_ROM_QSTR(MP_QSTR_SINHALA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SINHALA)) },
    { MP_ROM_QSTR(MP_QSTR_SYRIAC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SYRIAC)) },
    { MP_ROM_QSTR(MP_QSTR_TAMIL), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TAMIL)) },
    { MP_ROM_QSTR(MP_QSTR_TELUGU), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TELUGU)) },
    { MP_ROM_QSTR(MP_QSTR_THAANA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_THAANA)) },
    { MP_ROM_QSTR(MP_QSTR_THAI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_THAI)) },
    { MP_ROM_QSTR(MP_QSTR_TIBETAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TIBETAN)) },
    { MP_ROM_QSTR(MP_QSTR_CANADIAN_ABORIGINAL), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL)) },
    { MP_ROM_QSTR(MP_QSTR_YI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_YI)) },
    { MP_ROM_QSTR(MP_QSTR_TAGALOG), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TAGALOG)) },
    { MP_ROM_QSTR(MP_QSTR_HANUNOO), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_HANUNOO)) },
    { MP_ROM_QSTR(MP_QSTR_BUHID), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_BUHID)) },
    { MP_ROM_QSTR(MP_QSTR_TAGBANWA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TAGBANWA)) },
    { MP_ROM_QSTR(MP_QSTR_BRAILLE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_BRAILLE)) },
    { MP_ROM_QSTR(MP_QSTR_CYPRIOT), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_CYPRIOT)) },
    { MP_ROM_QSTR(MP_QSTR_LIMBU), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_LIMBU)) },
    { MP_ROM_QSTR(MP_QSTR_OSMANYA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_OSMANYA)) },
    { MP_ROM_QSTR(MP_QSTR_SHAVIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SHAVIAN)) },
    { MP_ROM_QSTR(MP_QSTR_LINEAR_B), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_LINEAR_B)) },
    { MP_ROM_QSTR(MP_QSTR_TAI_LE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TAI_LE)) },
    { MP_ROM_QSTR(MP_QSTR_UGARITIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_UGARITIC)) },
    { MP_ROM_QSTR(MP_QSTR_NEW_TAI_LUE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_NEW_TAI_LUE)) },
    { MP_ROM_QSTR(MP_QSTR_BUGINESE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_BUGINESE)) },
    { MP_ROM_QSTR(MP_QSTR_GLAGOLITIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_GLAGOLITIC)) },
    { MP_ROM_QSTR(MP_QSTR_TIFINAGH), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TIFINAGH)) },
    { MP_ROM_QSTR(MP_QSTR_SYLOTI_NAGRI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SYLOTI_NAGRI)) },
    { MP_ROM_QSTR(MP_QSTR_OLD_PERSIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_OLD_PERSIAN)) },
    { MP_ROM_QSTR(MP_QSTR_KHAROSHTHI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_KHAROSHTHI)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_UNKNOWN)) },
    { MP_ROM_QSTR(MP_QSTR_BALINESE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_BALINESE)) },
    { MP_ROM_QSTR(MP_QSTR_CUNEIFORM), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_CUNEIFORM)) },
    { MP_ROM_QSTR(MP_QSTR_PHOENICIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_PHOENICIAN)) },
    { MP_ROM_QSTR(MP_QSTR_PHAGS_PA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_PHAGS_PA)) },
    { MP_ROM_QSTR(MP_QSTR_NKO), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_NKO)) },
    { MP_ROM_QSTR(MP_QSTR_KAYAH_LI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_KAYAH_LI)) },
    { MP_ROM_QSTR(MP_QSTR_LEPCHA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_LEPCHA)) },
    { MP_ROM_QSTR(MP_QSTR_REJANG), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_REJANG)) },
    { MP_ROM_QSTR(MP_QSTR_SUNDANESE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SUNDANESE)) },
    { MP_ROM_QSTR(MP_QSTR_SAURASHTRA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SAURASHTRA)) },
    { MP_ROM_QSTR(MP_QSTR_CHAM), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_CHAM)) },
    { MP_ROM_QSTR(MP_QSTR_OL_CHIKI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_OL_CHIKI)) },
    { MP_ROM_QSTR(MP_QSTR_VAI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_VAI)) },
    { MP_ROM_QSTR(MP_QSTR_CARIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_CARIAN)) },
    { MP_ROM_QSTR(MP_QSTR_LYCIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_LYCIAN)) },
    { MP_ROM_QSTR(MP_QSTR_LYDIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_LYDIAN)) },
    { MP_ROM_QSTR(MP_QSTR_AVESTAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_AVESTAN)) },
    { MP_ROM_QSTR(MP_QSTR_BAMUM), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_BAMUM)) },
    { MP_ROM_QSTR(MP_QSTR_EGYPTIAN_HIEROGLYPHS), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS)) },
    { MP_ROM_QSTR(MP_QSTR_IMPERIAL_ARAMAIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC)) },
    { MP_ROM_QSTR(MP_QSTR_INSCRIPTIONAL_PAHLAVI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI)) },
    { MP_ROM_QSTR(MP_QSTR_INSCRIPTIONAL_PARTHIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN)) },
    { MP_ROM_QSTR(MP_QSTR_JAVANESE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_JAVANESE)) },
    { MP_ROM_QSTR(MP_QSTR_KAITHI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_KAITHI)) },
    { MP_ROM_QSTR(MP_QSTR_LISU), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_LISU)) },
    { MP_ROM_QSTR(MP_QSTR_MEETEI_MAYEK), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MEETEI_MAYEK)) },
    { MP_ROM_QSTR(MP_QSTR_OLD_SOUTH_ARABIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN)) },
    { MP_ROM_QSTR(MP_QSTR_OLD_TURKIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_OLD_TURKIC)) },
    { MP_ROM_QSTR(MP_QSTR_SAMARITAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SAMARITAN)) },
    { MP_ROM_QSTR(MP_QSTR_TAI_THAM), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TAI_THAM)) },
    { MP_ROM_QSTR(MP_QSTR_TAI_VIET), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TAI_VIET)) },
    { MP_ROM_QSTR(MP_QSTR_BATAK), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_BATAK)) },
    { MP_ROM_QSTR(MP_QSTR_BRAHMI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_BRAHMI)) },
    { MP_ROM_QSTR(MP_QSTR_MANDAIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MANDAIC)) },
    { MP_ROM_QSTR(MP_QSTR_CHAKMA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_CHAKMA)) },
    { MP_ROM_QSTR(MP_QSTR_MEROITIC_CURSIVE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MEROITIC_CURSIVE)) },
    { MP_ROM_QSTR(MP_QSTR_MEROITIC_HIEROGLYPHS), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS)) },
    { MP_ROM_QSTR(MP_QSTR_MIAO), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MIAO)) },
    { MP_ROM_QSTR(MP_QSTR_SHARADA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SHARADA)) },
    { MP_ROM_QSTR(MP_QSTR_SORA_SOMPENG), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SORA_SOMPENG)) },
    { MP_ROM_QSTR(MP_QSTR_TAKRI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TAKRI)) },
    { MP_ROM_QSTR(MP_QSTR_BASSA_VAH), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_BASSA_VAH)) },
    { MP_ROM_QSTR(MP_QSTR_CAUCASIAN_ALBANIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_CAUCASIAN_ALBANIAN)) },
    { MP_ROM_QSTR(MP_QSTR_DUPLOYAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_DUPLOYAN)) },
    { MP_ROM_QSTR(MP_QSTR_ELBASAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_ELBASAN)) },
    { MP_ROM_QSTR(MP_QSTR_GRANTHA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_GRANTHA)) },
    { MP_ROM_QSTR(MP_QSTR_KHOJKI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_KHOJKI)) },
    { MP_ROM_QSTR(MP_QSTR_KHUDAWADI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_KHUDAWADI)) },
    { MP_ROM_QSTR(MP_QSTR_LINEAR_A), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_LINEAR_A)) },
    { MP_ROM_QSTR(MP_QSTR_MAHAJANI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MAHAJANI)) },
    { MP_ROM_QSTR(MP_QSTR_MANICHAEAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MANICHAEAN)) },
    { MP_ROM_QSTR(MP_QSTR_MENDE_KIKAKUI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MENDE_KIKAKUI)) },
    { MP_ROM_QSTR(MP_QSTR_MODI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MODI)) },
    { MP_ROM_QSTR(MP_QSTR_MRO), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MRO)) },
    { MP_ROM_QSTR(MP_QSTR_NABATAEAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_NABATAEAN)) },
    { MP_ROM_QSTR(MP_QSTR_OLD_NORTH_ARABIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_OLD_NORTH_ARABIAN)) },
    { MP_ROM_QSTR(MP_QSTR_OLD_PERMIC), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_OLD_PERMIC)) },
    { MP_ROM_QSTR(MP_QSTR_PAHAWH_HMONG), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_PAHAWH_HMONG)) },
    { MP_ROM_QSTR(MP_QSTR_PALMYRENE), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_PALMYRENE)) },
    { MP_ROM_QSTR(MP_QSTR_PAU_CIN_HAU), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_PAU_CIN_HAU)) },
    { MP_ROM_QSTR(MP_QSTR_PSALTER_PAHLAVI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_PSALTER_PAHLAVI)) },
    { MP_ROM_QSTR(MP_QSTR_SIDDHAM), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SIDDHAM)) },
    { MP_ROM_QSTR(MP_QSTR_TIRHUTA), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_TIRHUTA)) },
    { MP_ROM_QSTR(MP_QSTR_WARANG_CITI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_WARANG_CITI)) },
    { MP_ROM_QSTR(MP_QSTR_AHOM), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_AHOM)) },
    { MP_ROM_QSTR(MP_QSTR_ANATOLIAN_HIEROGLYPHS), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_ANATOLIAN_HIEROGLYPHS)) },
    { MP_ROM_QSTR(MP_QSTR_HATRAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_HATRAN)) },
    { MP_ROM_QSTR(MP_QSTR_MULTANI), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_MULTANI)) },
    { MP_ROM_QSTR(MP_QSTR_OLD_HUNGARIAN), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_OLD_HUNGARIAN)) },
    { MP_ROM_QSTR(MP_QSTR_SIGNWRITING), MP_ROM_PTR(MP_ROM_INT(G_UNICODE_SCRIPT_SIGNWRITING)) }
};

STATIC MP_DEFINE_CONST_DICT(G_UNICODE_SCRIPT_locals_dict, G_UNICODE_SCRIPT_locals_dict_table);

STATIC void G_UNICODE_SCRIPT_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_UNICODE_SCRIPT");
}



STATIC const mp_obj_type_t mp_G_UNICODE_SCRIPT_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_UNICODE_SCRIPT,
    .print = G_UNICODE_SCRIPT_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_UNICODE_SCRIPT_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_NORMALIZE object definitions
 */
    

STATIC const mp_rom_map_elem_t G_NORMALIZE_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_DEFAULT), MP_ROM_PTR(MP_ROM_INT(G_NORMALIZE_DEFAULT)) },
    { MP_ROM_QSTR(MP_QSTR_NFD), MP_ROM_PTR(MP_ROM_INT(G_NORMALIZE_NFD)) },
    { MP_ROM_QSTR(MP_QSTR_DEFAULT_COMPOSE), MP_ROM_PTR(MP_ROM_INT(G_NORMALIZE_DEFAULT_COMPOSE)) },
    { MP_ROM_QSTR(MP_QSTR_NFC), MP_ROM_PTR(MP_ROM_INT(G_NORMALIZE_NFC)) },
    { MP_ROM_QSTR(MP_QSTR_ALL), MP_ROM_PTR(MP_ROM_INT(G_NORMALIZE_ALL)) },
    { MP_ROM_QSTR(MP_QSTR_NFKD), MP_ROM_PTR(MP_ROM_INT(G_NORMALIZE_NFKD)) },
    { MP_ROM_QSTR(MP_QSTR_ALL_COMPOSE), MP_ROM_PTR(MP_ROM_INT(G_NORMALIZE_ALL_COMPOSE)) },
    { MP_ROM_QSTR(MP_QSTR_NFKC), MP_ROM_PTR(MP_ROM_INT(G_NORMALIZE_NFKC)) }
};

STATIC MP_DEFINE_CONST_DICT(G_NORMALIZE_locals_dict, G_NORMALIZE_locals_dict_table);

STATIC void G_NORMALIZE_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_NORMALIZE");
}



STATIC const mp_obj_type_t mp_G_NORMALIZE_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_NORMALIZE,
    .print = G_NORMALIZE_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_NORMALIZE_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_IO_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_IO_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(G_IO_ERROR_NONE)) },
    { MP_ROM_QSTR(MP_QSTR_AGAIN), MP_ROM_PTR(MP_ROM_INT(G_IO_ERROR_AGAIN)) },
    { MP_ROM_QSTR(MP_QSTR_INVAL), MP_ROM_PTR(MP_ROM_INT(G_IO_ERROR_INVAL)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN), MP_ROM_PTR(MP_ROM_INT(G_IO_ERROR_UNKNOWN)) }
};

STATIC MP_DEFINE_CONST_DICT(G_IO_ERROR_locals_dict, G_IO_ERROR_locals_dict_table);

STATIC void G_IO_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_IO_ERROR");
}



STATIC const mp_obj_type_t mp_G_IO_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_IO_ERROR,
    .print = G_IO_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_IO_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_IO_CHANNEL_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_IO_CHANNEL_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_FBIG), MP_ROM_PTR(MP_ROM_INT(G_IO_CHANNEL_ERROR_FBIG)) },
    { MP_ROM_QSTR(MP_QSTR_INVAL), MP_ROM_PTR(MP_ROM_INT(G_IO_CHANNEL_ERROR_INVAL)) },
    { MP_ROM_QSTR(MP_QSTR_IO), MP_ROM_PTR(MP_ROM_INT(G_IO_CHANNEL_ERROR_IO)) },
    { MP_ROM_QSTR(MP_QSTR_ISDIR), MP_ROM_PTR(MP_ROM_INT(G_IO_CHANNEL_ERROR_ISDIR)) },
    { MP_ROM_QSTR(MP_QSTR_NOSPC), MP_ROM_PTR(MP_ROM_INT(G_IO_CHANNEL_ERROR_NOSPC)) },
    { MP_ROM_QSTR(MP_QSTR_NXIO), MP_ROM_PTR(MP_ROM_INT(G_IO_CHANNEL_ERROR_NXIO)) },
    { MP_ROM_QSTR(MP_QSTR_OVERFLOW), MP_ROM_PTR(MP_ROM_INT(G_IO_CHANNEL_ERROR_OVERFLOW)) },
    { MP_ROM_QSTR(MP_QSTR_PIPE), MP_ROM_PTR(MP_ROM_INT(G_IO_CHANNEL_ERROR_PIPE)) },
    { MP_ROM_QSTR(MP_QSTR_FAILED), MP_ROM_PTR(MP_ROM_INT(G_IO_CHANNEL_ERROR_FAILED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_IO_CHANNEL_ERROR_locals_dict, G_IO_CHANNEL_ERROR_locals_dict_table);

STATIC void G_IO_CHANNEL_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_IO_CHANNEL_ERROR");
}



STATIC const mp_obj_type_t mp_G_IO_CHANNEL_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_IO_CHANNEL_ERROR,
    .print = G_IO_CHANNEL_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_IO_CHANNEL_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_IO_STATUS object definitions
 */
    

STATIC const mp_rom_map_elem_t G_IO_STATUS_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_ERROR), MP_ROM_PTR(MP_ROM_INT(G_IO_STATUS_ERROR)) },
    { MP_ROM_QSTR(MP_QSTR_NORMAL), MP_ROM_PTR(MP_ROM_INT(G_IO_STATUS_NORMAL)) },
    { MP_ROM_QSTR(MP_QSTR_EOF), MP_ROM_PTR(MP_ROM_INT(G_IO_STATUS_EOF)) },
    { MP_ROM_QSTR(MP_QSTR_AGAIN), MP_ROM_PTR(MP_ROM_INT(G_IO_STATUS_AGAIN)) }
};

STATIC MP_DEFINE_CONST_DICT(G_IO_STATUS_locals_dict, G_IO_STATUS_locals_dict_table);

STATIC void G_IO_STATUS_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_IO_STATUS");
}



STATIC const mp_obj_type_t mp_G_IO_STATUS_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_IO_STATUS,
    .print = G_IO_STATUS_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_IO_STATUS_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_SEEK object definitions
 */
    

STATIC const mp_rom_map_elem_t G_SEEK_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_CUR), MP_ROM_PTR(MP_ROM_INT(G_SEEK_CUR)) },
    { MP_ROM_QSTR(MP_QSTR_SET), MP_ROM_PTR(MP_ROM_INT(G_SEEK_SET)) },
    { MP_ROM_QSTR(MP_QSTR_END), MP_ROM_PTR(MP_ROM_INT(G_SEEK_END)) }
};

STATIC MP_DEFINE_CONST_DICT(G_SEEK_locals_dict, G_SEEK_locals_dict_table);

STATIC void G_SEEK_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_SEEK");
}



STATIC const mp_obj_type_t mp_G_SEEK_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_SEEK,
    .print = G_SEEK_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_SEEK_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_IO_FLAG object definitions
 */
    

STATIC const mp_rom_map_elem_t G_IO_FLAG_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_APPEND), MP_ROM_PTR(MP_ROM_INT(G_IO_FLAG_APPEND)) },
    { MP_ROM_QSTR(MP_QSTR_NONBLOCK), MP_ROM_PTR(MP_ROM_INT(G_IO_FLAG_NONBLOCK)) },
    { MP_ROM_QSTR(MP_QSTR_IS_READABLE), MP_ROM_PTR(MP_ROM_INT(G_IO_FLAG_IS_READABLE)) },
    { MP_ROM_QSTR(MP_QSTR_IS_WRITABLE), MP_ROM_PTR(MP_ROM_INT(G_IO_FLAG_IS_WRITABLE)) },
    { MP_ROM_QSTR(MP_QSTR_IS_WRITEABLE), MP_ROM_PTR(MP_ROM_INT(G_IO_FLAG_IS_WRITEABLE)) },
    { MP_ROM_QSTR(MP_QSTR_IS_SEEKABLE), MP_ROM_PTR(MP_ROM_INT(G_IO_FLAG_IS_SEEKABLE)) },
    { MP_ROM_QSTR(MP_QSTR_MASK), MP_ROM_PTR(MP_ROM_INT(G_IO_FLAG_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_GET_MASK), MP_ROM_PTR(MP_ROM_INT(G_IO_FLAG_GET_MASK)) },
    { MP_ROM_QSTR(MP_QSTR_SET_MASK), MP_ROM_PTR(MP_ROM_INT(G_IO_FLAG_SET_MASK)) }
};

STATIC MP_DEFINE_CONST_DICT(G_IO_FLAG_locals_dict, G_IO_FLAG_locals_dict_table);

STATIC void G_IO_FLAG_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_IO_FLAG");
}



STATIC const mp_obj_type_t mp_G_IO_FLAG_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_IO_FLAG,
    .print = G_IO_FLAG_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_IO_FLAG_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_KEY_FILE_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_KEY_FILE_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN_ENCODING), MP_ROM_PTR(MP_ROM_INT(G_KEY_FILE_ERROR_UNKNOWN_ENCODING)) },
    { MP_ROM_QSTR(MP_QSTR_PARSE), MP_ROM_PTR(MP_ROM_INT(G_KEY_FILE_ERROR_PARSE)) },
    { MP_ROM_QSTR(MP_QSTR_NOT_FOUND), MP_ROM_PTR(MP_ROM_INT(G_KEY_FILE_ERROR_NOT_FOUND)) },
    { MP_ROM_QSTR(MP_QSTR_KEY_NOT_FOUND), MP_ROM_PTR(MP_ROM_INT(G_KEY_FILE_ERROR_KEY_NOT_FOUND)) },
    { MP_ROM_QSTR(MP_QSTR_GROUP_NOT_FOUND), MP_ROM_PTR(MP_ROM_INT(G_KEY_FILE_ERROR_GROUP_NOT_FOUND)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_VALUE), MP_ROM_PTR(MP_ROM_INT(G_KEY_FILE_ERROR_INVALID_VALUE)) }
};

STATIC MP_DEFINE_CONST_DICT(G_KEY_FILE_ERROR_locals_dict, G_KEY_FILE_ERROR_locals_dict_table);

STATIC void G_KEY_FILE_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_KEY_FILE_ERROR");
}



STATIC const mp_obj_type_t mp_G_KEY_FILE_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_KEY_FILE_ERROR,
    .print = G_KEY_FILE_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_KEY_FILE_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_KEY_FILE object definitions
 */
    

STATIC const mp_rom_map_elem_t G_KEY_FILE_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(G_KEY_FILE_NONE)) },
    { MP_ROM_QSTR(MP_QSTR_KEEP_COMMENTS), MP_ROM_PTR(MP_ROM_INT(G_KEY_FILE_KEEP_COMMENTS)) },
    { MP_ROM_QSTR(MP_QSTR_KEEP_TRANSLATIONS), MP_ROM_PTR(MP_ROM_INT(G_KEY_FILE_KEEP_TRANSLATIONS)) }
};

STATIC MP_DEFINE_CONST_DICT(G_KEY_FILE_locals_dict, G_KEY_FILE_locals_dict_table);

STATIC void G_KEY_FILE_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_KEY_FILE");
}



STATIC const mp_obj_type_t mp_G_KEY_FILE_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_KEY_FILE,
    .print = G_KEY_FILE_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_KEY_FILE_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_MARKUP_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_MARKUP_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_BAD_UTF8), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_ERROR_BAD_UTF8)) },
    { MP_ROM_QSTR(MP_QSTR_EMPTY), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_ERROR_EMPTY)) },
    { MP_ROM_QSTR(MP_QSTR_PARSE), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_ERROR_PARSE)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN_ELEMENT), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_ERROR_UNKNOWN_ELEMENT)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN_ATTRIBUTE), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_CONTENT), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_ERROR_INVALID_CONTENT)) },
    { MP_ROM_QSTR(MP_QSTR_MISSING_ATTRIBUTE), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_ERROR_MISSING_ATTRIBUTE)) }
};

STATIC MP_DEFINE_CONST_DICT(G_MARKUP_ERROR_locals_dict, G_MARKUP_ERROR_locals_dict_table);

STATIC void G_MARKUP_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_MARKUP_ERROR");
}



STATIC const mp_obj_type_t mp_G_MARKUP_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_MARKUP_ERROR,
    .print = G_MARKUP_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_MARKUP_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_MARKUP object definitions
 */
    

STATIC const mp_rom_map_elem_t G_MARKUP_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_DO_NOT_USE_THIS_UNSUPPORTED_FLAG), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG)) },
    { MP_ROM_QSTR(MP_QSTR_TREAT_CDATA_AS_TEXT), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_TREAT_CDATA_AS_TEXT)) },
    { MP_ROM_QSTR(MP_QSTR_PREFIX_ERROR_POSITION), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_PREFIX_ERROR_POSITION)) },
    { MP_ROM_QSTR(MP_QSTR_IGNORE_QUALIFIED), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_IGNORE_QUALIFIED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_MARKUP_locals_dict, G_MARKUP_locals_dict_table);

STATIC void G_MARKUP_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_MARKUP");
}



STATIC const mp_obj_type_t mp_G_MARKUP_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_MARKUP,
    .print = G_MARKUP_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_MARKUP_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_MARKUP_COLLECT object definitions
 */
    

STATIC const mp_rom_map_elem_t G_MARKUP_COLLECT_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_INVALID), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_COLLECT_INVALID)) },
    { MP_ROM_QSTR(MP_QSTR_STRING), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_COLLECT_STRING)) },
    { MP_ROM_QSTR(MP_QSTR_STRDUP), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_COLLECT_STRDUP)) },
    { MP_ROM_QSTR(MP_QSTR_BOOLEAN), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_COLLECT_BOOLEAN)) },
    { MP_ROM_QSTR(MP_QSTR_TRISTATE), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_COLLECT_TRISTATE)) },
    { MP_ROM_QSTR(MP_QSTR_OPTIONAL), MP_ROM_PTR(MP_ROM_INT(G_MARKUP_COLLECT_OPTIONAL)) }
};

STATIC MP_DEFINE_CONST_DICT(G_MARKUP_COLLECT_locals_dict, G_MARKUP_COLLECT_locals_dict_table);

STATIC void G_MARKUP_COLLECT_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_MARKUP_COLLECT");
}



STATIC const mp_obj_type_t mp_G_MARKUP_COLLECT_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_MARKUP_COLLECT,
    .print = G_MARKUP_COLLECT_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_MARKUP_COLLECT_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_LOG object definitions
 */
    

STATIC const mp_rom_map_elem_t G_LOG_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_FLAG_RECURSION), MP_ROM_PTR(MP_ROM_INT(G_LOG_FLAG_RECURSION)) },
    { MP_ROM_QSTR(MP_QSTR_FLAG_FATAL), MP_ROM_PTR(MP_ROM_INT(G_LOG_FLAG_FATAL)) },
    { MP_ROM_QSTR(MP_QSTR_LEVEL_ERROR), MP_ROM_PTR(MP_ROM_INT(G_LOG_LEVEL_ERROR)) },
    { MP_ROM_QSTR(MP_QSTR_LEVEL_CRITICAL), MP_ROM_PTR(MP_ROM_INT(G_LOG_LEVEL_CRITICAL)) },
    { MP_ROM_QSTR(MP_QSTR_LEVEL_WARNING), MP_ROM_PTR(MP_ROM_INT(G_LOG_LEVEL_WARNING)) },
    { MP_ROM_QSTR(MP_QSTR_LEVEL_MESSAGE), MP_ROM_PTR(MP_ROM_INT(G_LOG_LEVEL_MESSAGE)) },
    { MP_ROM_QSTR(MP_QSTR_LEVEL_INFO), MP_ROM_PTR(MP_ROM_INT(G_LOG_LEVEL_INFO)) },
    { MP_ROM_QSTR(MP_QSTR_LEVEL_DEBUG), MP_ROM_PTR(MP_ROM_INT(G_LOG_LEVEL_DEBUG)) },
    { MP_ROM_QSTR(MP_QSTR_LEVEL_MASK), MP_ROM_PTR(MP_ROM_INT(G_LOG_LEVEL_MASK)) }
};

STATIC MP_DEFINE_CONST_DICT(G_LOG_locals_dict, G_LOG_locals_dict_table);

STATIC void G_LOG_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_LOG");
}



STATIC const mp_obj_type_t mp_G_LOG_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_LOG,
    .print = G_LOG_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_LOG_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_OPTION_FLAG object definitions
 */
    

STATIC const mp_rom_map_elem_t G_OPTION_FLAG_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(G_OPTION_FLAG_NONE)) },
    { MP_ROM_QSTR(MP_QSTR_HIDDEN), MP_ROM_PTR(MP_ROM_INT(G_OPTION_FLAG_HIDDEN)) },
    { MP_ROM_QSTR(MP_QSTR_IN_MAIN), MP_ROM_PTR(MP_ROM_INT(G_OPTION_FLAG_IN_MAIN)) },
    { MP_ROM_QSTR(MP_QSTR_REVERSE), MP_ROM_PTR(MP_ROM_INT(G_OPTION_FLAG_REVERSE)) },
    { MP_ROM_QSTR(MP_QSTR_NO_ARG), MP_ROM_PTR(MP_ROM_INT(G_OPTION_FLAG_NO_ARG)) },
    { MP_ROM_QSTR(MP_QSTR_FILENAME), MP_ROM_PTR(MP_ROM_INT(G_OPTION_FLAG_FILENAME)) },
    { MP_ROM_QSTR(MP_QSTR_OPTIONAL_ARG), MP_ROM_PTR(MP_ROM_INT(G_OPTION_FLAG_OPTIONAL_ARG)) },
    { MP_ROM_QSTR(MP_QSTR_NOALIAS), MP_ROM_PTR(MP_ROM_INT(G_OPTION_FLAG_NOALIAS)) }
};

STATIC MP_DEFINE_CONST_DICT(G_OPTION_FLAG_locals_dict, G_OPTION_FLAG_locals_dict_table);

STATIC void G_OPTION_FLAG_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_OPTION_FLAG");
}



STATIC const mp_obj_type_t mp_G_OPTION_FLAG_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_OPTION_FLAG,
    .print = G_OPTION_FLAG_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_OPTION_FLAG_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_OPTION_ARG object definitions
 */
    

STATIC const mp_rom_map_elem_t G_OPTION_ARG_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ARG_NONE)) },
    { MP_ROM_QSTR(MP_QSTR_STRING), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ARG_STRING)) },
    { MP_ROM_QSTR(MP_QSTR_INT), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ARG_INT)) },
    { MP_ROM_QSTR(MP_QSTR_CALLBACK), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ARG_CALLBACK)) },
    { MP_ROM_QSTR(MP_QSTR_FILENAME), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ARG_FILENAME)) },
    { MP_ROM_QSTR(MP_QSTR_STRING_ARRAY), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ARG_STRING_ARRAY)) },
    { MP_ROM_QSTR(MP_QSTR_FILENAME_ARRAY), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ARG_FILENAME_ARRAY)) },
    { MP_ROM_QSTR(MP_QSTR_DOUBLE), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ARG_DOUBLE)) },
    { MP_ROM_QSTR(MP_QSTR_INT64), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ARG_INT64)) }
};

STATIC MP_DEFINE_CONST_DICT(G_OPTION_ARG_locals_dict, G_OPTION_ARG_locals_dict_table);

STATIC void G_OPTION_ARG_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_OPTION_ARG");
}



STATIC const mp_obj_type_t mp_G_OPTION_ARG_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_OPTION_ARG,
    .print = G_OPTION_ARG_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_OPTION_ARG_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_OPTION_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_OPTION_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN_OPTION), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ERROR_UNKNOWN_OPTION)) },
    { MP_ROM_QSTR(MP_QSTR_BAD_VALUE), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ERROR_BAD_VALUE)) },
    { MP_ROM_QSTR(MP_QSTR_FAILED), MP_ROM_PTR(MP_ROM_INT(G_OPTION_ERROR_FAILED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_OPTION_ERROR_locals_dict, G_OPTION_ERROR_locals_dict_table);

STATIC void G_OPTION_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_OPTION_ERROR");
}



STATIC const mp_obj_type_t mp_G_OPTION_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_OPTION_ERROR,
    .print = G_OPTION_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_OPTION_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_REGEX_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_REGEX_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_COMPILE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_COMPILE)) },
    { MP_ROM_QSTR(MP_QSTR_OPTIMIZE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_OPTIMIZE)) },
    { MP_ROM_QSTR(MP_QSTR_REPLACE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_REPLACE)) },
    { MP_ROM_QSTR(MP_QSTR_MATCH), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_MATCH)) },
    { MP_ROM_QSTR(MP_QSTR_INTERNAL), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_INTERNAL)) },
    { MP_ROM_QSTR(MP_QSTR_STRAY_BACKSLASH), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_STRAY_BACKSLASH)) },
    { MP_ROM_QSTR(MP_QSTR_MISSING_CONTROL_CHAR), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_MISSING_CONTROL_CHAR)) },
    { MP_ROM_QSTR(MP_QSTR_UNRECOGNIZED_ESCAPE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_UNRECOGNIZED_ESCAPE)) },
    { MP_ROM_QSTR(MP_QSTR_QUANTIFIERS_OUT_OF_ORDER), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER)) },
    { MP_ROM_QSTR(MP_QSTR_QUANTIFIER_TOO_BIG), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_QUANTIFIER_TOO_BIG)) },
    { MP_ROM_QSTR(MP_QSTR_UNTERMINATED_CHARACTER_CLASS), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_ESCAPE_IN_CHARACTER_CLASS), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS)) },
    { MP_ROM_QSTR(MP_QSTR_RANGE_OUT_OF_ORDER), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_RANGE_OUT_OF_ORDER)) },
    { MP_ROM_QSTR(MP_QSTR_NOTHING_TO_REPEAT), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_NOTHING_TO_REPEAT)) },
    { MP_ROM_QSTR(MP_QSTR_UNRECOGNIZED_CHARACTER), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_UNRECOGNIZED_CHARACTER)) },
    { MP_ROM_QSTR(MP_QSTR_POSIX_NAMED_CLASS_OUTSIDE_CLASS), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS)) },
    { MP_ROM_QSTR(MP_QSTR_UNMATCHED_PARENTHESIS), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_UNMATCHED_PARENTHESIS)) },
    { MP_ROM_QSTR(MP_QSTR_INEXISTENT_SUBPATTERN_REFERENCE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE)) },
    { MP_ROM_QSTR(MP_QSTR_UNTERMINATED_COMMENT), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_UNTERMINATED_COMMENT)) },
    { MP_ROM_QSTR(MP_QSTR_EXPRESSION_TOO_LARGE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_EXPRESSION_TOO_LARGE)) },
    { MP_ROM_QSTR(MP_QSTR_MEMORY_ERROR), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_MEMORY_ERROR)) },
    { MP_ROM_QSTR(MP_QSTR_VARIABLE_LENGTH_LOOKBEHIND), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND)) },
    { MP_ROM_QSTR(MP_QSTR_MALFORMED_CONDITION), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_MALFORMED_CONDITION)) },
    { MP_ROM_QSTR(MP_QSTR_TOO_MANY_CONDITIONAL_BRANCHES), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES)) },
    { MP_ROM_QSTR(MP_QSTR_ASSERTION_EXPECTED), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_ASSERTION_EXPECTED)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN_POSIX_CLASS_NAME), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME)) },
    { MP_ROM_QSTR(MP_QSTR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED)) },
    { MP_ROM_QSTR(MP_QSTR_HEX_CODE_TOO_LARGE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_HEX_CODE_TOO_LARGE)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_CONDITION), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_INVALID_CONDITION)) },
    { MP_ROM_QSTR(MP_QSTR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND)) },
    { MP_ROM_QSTR(MP_QSTR_INFINITE_LOOP), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_INFINITE_LOOP)) },
    { MP_ROM_QSTR(MP_QSTR_MISSING_SUBPATTERN_NAME_TERMINATOR), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR)) },
    { MP_ROM_QSTR(MP_QSTR_DUPLICATE_SUBPATTERN_NAME), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME)) },
    { MP_ROM_QSTR(MP_QSTR_MALFORMED_PROPERTY), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_MALFORMED_PROPERTY)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN_PROPERTY), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_UNKNOWN_PROPERTY)) },
    { MP_ROM_QSTR(MP_QSTR_SUBPATTERN_NAME_TOO_LONG), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG)) },
    { MP_ROM_QSTR(MP_QSTR_TOO_MANY_SUBPATTERNS), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_TOO_MANY_SUBPATTERNS)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_OCTAL_VALUE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_INVALID_OCTAL_VALUE)) },
    { MP_ROM_QSTR(MP_QSTR_TOO_MANY_BRANCHES_IN_DEFINE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE)) },
    { MP_ROM_QSTR(MP_QSTR_DEFINE_REPETION), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_DEFINE_REPETION)) },
    { MP_ROM_QSTR(MP_QSTR_INCONSISTENT_NEWLINE_OPTIONS), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS)) },
    { MP_ROM_QSTR(MP_QSTR_MISSING_BACK_REFERENCE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_MISSING_BACK_REFERENCE)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_RELATIVE_REFERENCE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE)) },
    { MP_ROM_QSTR(MP_QSTR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN_BACKTRACKING_CONTROL_VERB), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB)) },
    { MP_ROM_QSTR(MP_QSTR_NUMBER_TOO_BIG), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_NUMBER_TOO_BIG)) },
    { MP_ROM_QSTR(MP_QSTR_MISSING_SUBPATTERN_NAME), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_MISSING_SUBPATTERN_NAME)) },
    { MP_ROM_QSTR(MP_QSTR_MISSING_DIGIT), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_MISSING_DIGIT)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_DATA_CHARACTER), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_INVALID_DATA_CHARACTER)) },
    { MP_ROM_QSTR(MP_QSTR_EXTRA_SUBPATTERN_NAME), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME)) },
    { MP_ROM_QSTR(MP_QSTR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_CONTROL_CHAR), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_INVALID_CONTROL_CHAR)) },
    { MP_ROM_QSTR(MP_QSTR_MISSING_NAME), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_MISSING_NAME)) },
    { MP_ROM_QSTR(MP_QSTR_NOT_SUPPORTED_IN_CLASS), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS)) },
    { MP_ROM_QSTR(MP_QSTR_TOO_MANY_FORWARD_REFERENCES), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_TOO_MANY_FORWARD_REFERENCES)) },
    { MP_ROM_QSTR(MP_QSTR_NAME_TOO_LONG), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_NAME_TOO_LONG)) },
    { MP_ROM_QSTR(MP_QSTR_CHARACTER_VALUE_TOO_LARGE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE)) }
};

STATIC MP_DEFINE_CONST_DICT(G_REGEX_ERROR_locals_dict, G_REGEX_ERROR_locals_dict_table);

STATIC void G_REGEX_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_REGEX_ERROR");
}



STATIC const mp_obj_type_t mp_G_REGEX_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_REGEX_ERROR,
    .print = G_REGEX_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_REGEX_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_REGEX object definitions
 */
    

STATIC const mp_rom_map_elem_t G_REGEX_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_CASELESS), MP_ROM_PTR(MP_ROM_INT(G_REGEX_CASELESS)) },
    { MP_ROM_QSTR(MP_QSTR_MULTILINE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MULTILINE)) },
    { MP_ROM_QSTR(MP_QSTR_DOTALL), MP_ROM_PTR(MP_ROM_INT(G_REGEX_DOTALL)) },
    { MP_ROM_QSTR(MP_QSTR_EXTENDED), MP_ROM_PTR(MP_ROM_INT(G_REGEX_EXTENDED)) },
    { MP_ROM_QSTR(MP_QSTR_ANCHORED), MP_ROM_PTR(MP_ROM_INT(G_REGEX_ANCHORED)) },
    { MP_ROM_QSTR(MP_QSTR_DOLLAR_ENDONLY), MP_ROM_PTR(MP_ROM_INT(G_REGEX_DOLLAR_ENDONLY)) },
    { MP_ROM_QSTR(MP_QSTR_UNGREEDY), MP_ROM_PTR(MP_ROM_INT(G_REGEX_UNGREEDY)) },
    { MP_ROM_QSTR(MP_QSTR_RAW), MP_ROM_PTR(MP_ROM_INT(G_REGEX_RAW)) },
    { MP_ROM_QSTR(MP_QSTR_NO_AUTO_CAPTURE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_NO_AUTO_CAPTURE)) },
    { MP_ROM_QSTR(MP_QSTR_OPTIMIZE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_OPTIMIZE)) },
    { MP_ROM_QSTR(MP_QSTR_FIRSTLINE), MP_ROM_PTR(MP_ROM_INT(G_REGEX_FIRSTLINE)) },
    { MP_ROM_QSTR(MP_QSTR_DUPNAMES), MP_ROM_PTR(MP_ROM_INT(G_REGEX_DUPNAMES)) },
    { MP_ROM_QSTR(MP_QSTR_NEWLINE_CR), MP_ROM_PTR(MP_ROM_INT(G_REGEX_NEWLINE_CR)) },
    { MP_ROM_QSTR(MP_QSTR_NEWLINE_LF), MP_ROM_PTR(MP_ROM_INT(G_REGEX_NEWLINE_LF)) },
    { MP_ROM_QSTR(MP_QSTR_NEWLINE_CRLF), MP_ROM_PTR(MP_ROM_INT(G_REGEX_NEWLINE_CRLF)) },
    { MP_ROM_QSTR(MP_QSTR_NEWLINE_ANYCRLF), MP_ROM_PTR(MP_ROM_INT(G_REGEX_NEWLINE_ANYCRLF)) },
    { MP_ROM_QSTR(MP_QSTR_BSR_ANYCRLF), MP_ROM_PTR(MP_ROM_INT(G_REGEX_BSR_ANYCRLF)) },
    { MP_ROM_QSTR(MP_QSTR_JAVASCRIPT_COMPAT), MP_ROM_PTR(MP_ROM_INT(G_REGEX_JAVASCRIPT_COMPAT)) }
};

STATIC MP_DEFINE_CONST_DICT(G_REGEX_locals_dict, G_REGEX_locals_dict_table);

STATIC void G_REGEX_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_REGEX");
}



STATIC const mp_obj_type_t mp_G_REGEX_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_REGEX,
    .print = G_REGEX_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_REGEX_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_REGEX_MATCH object definitions
 */
    

STATIC const mp_rom_map_elem_t G_REGEX_MATCH_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_ANCHORED), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_ANCHORED)) },
    { MP_ROM_QSTR(MP_QSTR_NOTBOL), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_NOTBOL)) },
    { MP_ROM_QSTR(MP_QSTR_NOTEOL), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_NOTEOL)) },
    { MP_ROM_QSTR(MP_QSTR_NOTEMPTY), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_NOTEMPTY)) },
    { MP_ROM_QSTR(MP_QSTR_PARTIAL), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_PARTIAL)) },
    { MP_ROM_QSTR(MP_QSTR_NEWLINE_CR), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_NEWLINE_CR)) },
    { MP_ROM_QSTR(MP_QSTR_NEWLINE_LF), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_NEWLINE_LF)) },
    { MP_ROM_QSTR(MP_QSTR_NEWLINE_CRLF), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_NEWLINE_CRLF)) },
    { MP_ROM_QSTR(MP_QSTR_NEWLINE_ANY), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_NEWLINE_ANY)) },
    { MP_ROM_QSTR(MP_QSTR_NEWLINE_ANYCRLF), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_NEWLINE_ANYCRLF)) },
    { MP_ROM_QSTR(MP_QSTR_BSR_ANYCRLF), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_BSR_ANYCRLF)) },
    { MP_ROM_QSTR(MP_QSTR_BSR_ANY), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_BSR_ANY)) },
    { MP_ROM_QSTR(MP_QSTR_PARTIAL_SOFT), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_PARTIAL_SOFT)) },
    { MP_ROM_QSTR(MP_QSTR_PARTIAL_HARD), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_PARTIAL_HARD)) },
    { MP_ROM_QSTR(MP_QSTR_NOTEMPTY_ATSTART), MP_ROM_PTR(MP_ROM_INT(G_REGEX_MATCH_NOTEMPTY_ATSTART)) }
};

STATIC MP_DEFINE_CONST_DICT(G_REGEX_MATCH_locals_dict, G_REGEX_MATCH_locals_dict_table);

STATIC void G_REGEX_MATCH_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_REGEX_MATCH");
}



STATIC const mp_obj_type_t mp_G_REGEX_MATCH_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_REGEX_MATCH,
    .print = G_REGEX_MATCH_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_REGEX_MATCH_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_ERR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_ERR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN), MP_ROM_PTR(MP_ROM_INT(G_ERR_UNKNOWN)) },
    { MP_ROM_QSTR(MP_QSTR_UNEXP_EOF), MP_ROM_PTR(MP_ROM_INT(G_ERR_UNEXP_EOF)) },
    { MP_ROM_QSTR(MP_QSTR_UNEXP_EOF_IN_STRING), MP_ROM_PTR(MP_ROM_INT(G_ERR_UNEXP_EOF_IN_STRING)) },
    { MP_ROM_QSTR(MP_QSTR_UNEXP_EOF_IN_COMMENT), MP_ROM_PTR(MP_ROM_INT(G_ERR_UNEXP_EOF_IN_COMMENT)) },
    { MP_ROM_QSTR(MP_QSTR_NON_DIGIT_IN_CONST), MP_ROM_PTR(MP_ROM_INT(G_ERR_NON_DIGIT_IN_CONST)) },
    { MP_ROM_QSTR(MP_QSTR_DIGIT_RADIX), MP_ROM_PTR(MP_ROM_INT(G_ERR_DIGIT_RADIX)) },
    { MP_ROM_QSTR(MP_QSTR_FLOAT_RADIX), MP_ROM_PTR(MP_ROM_INT(G_ERR_FLOAT_RADIX)) },
    { MP_ROM_QSTR(MP_QSTR_FLOAT_MALFORMED), MP_ROM_PTR(MP_ROM_INT(G_ERR_FLOAT_MALFORMED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_ERR_locals_dict, G_ERR_locals_dict_table);

STATIC void G_ERR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_ERR");
}



STATIC const mp_obj_type_t mp_G_ERR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_ERR,
    .print = G_ERR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_ERR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_TOKEN object definitions
 */
    

STATIC const mp_rom_map_elem_t G_TOKEN_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_EOF), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_EOF)) },
    { MP_ROM_QSTR(MP_QSTR_LEFT_PAREN), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_LEFT_PAREN)) },
    { MP_ROM_QSTR(MP_QSTR_RIGHT_PAREN), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_RIGHT_PAREN)) },
    { MP_ROM_QSTR(MP_QSTR_LEFT_CURLY), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_LEFT_CURLY)) },
    { MP_ROM_QSTR(MP_QSTR_RIGHT_CURLY), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_RIGHT_CURLY)) },
    { MP_ROM_QSTR(MP_QSTR_LEFT_BRACE), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_LEFT_BRACE)) },
    { MP_ROM_QSTR(MP_QSTR_RIGHT_BRACE), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_RIGHT_BRACE)) },
    { MP_ROM_QSTR(MP_QSTR_EQUAL_SIGN), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_EQUAL_SIGN)) },
    { MP_ROM_QSTR(MP_QSTR_COMMA), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_COMMA)) },
    { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_NONE)) },
    { MP_ROM_QSTR(MP_QSTR_ERROR), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_ERROR)) },
    { MP_ROM_QSTR(MP_QSTR_CHAR), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_CHAR)) },
    { MP_ROM_QSTR(MP_QSTR_BINARY), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_BINARY)) },
    { MP_ROM_QSTR(MP_QSTR_OCTAL), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_OCTAL)) },
    { MP_ROM_QSTR(MP_QSTR_INT), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_INT)) },
    { MP_ROM_QSTR(MP_QSTR_HEX), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_HEX)) },
    { MP_ROM_QSTR(MP_QSTR_FLOAT), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_FLOAT)) },
    { MP_ROM_QSTR(MP_QSTR_STRING), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_STRING)) },
    { MP_ROM_QSTR(MP_QSTR_SYMBOL), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_SYMBOL)) },
    { MP_ROM_QSTR(MP_QSTR_IDENTIFIER), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_IDENTIFIER)) },
    { MP_ROM_QSTR(MP_QSTR_IDENTIFIER_NULL), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_IDENTIFIER_NULL)) },
    { MP_ROM_QSTR(MP_QSTR_COMMENT_SINGLE), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_COMMENT_SINGLE)) },
    { MP_ROM_QSTR(MP_QSTR_COMMENT_MULTI), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_COMMENT_MULTI)) },
    { MP_ROM_QSTR(MP_QSTR_LAST), MP_ROM_PTR(MP_ROM_INT(G_TOKEN_LAST)) }
};

STATIC MP_DEFINE_CONST_DICT(G_TOKEN_locals_dict, G_TOKEN_locals_dict_table);

STATIC void G_TOKEN_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_TOKEN");
}



STATIC const mp_obj_type_t mp_G_TOKEN_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_TOKEN,
    .print = G_TOKEN_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_TOKEN_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_SHELL_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_SHELL_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_BAD_QUOTING), MP_ROM_PTR(MP_ROM_INT(G_SHELL_ERROR_BAD_QUOTING)) },
    { MP_ROM_QSTR(MP_QSTR_EMPTY_STRING), MP_ROM_PTR(MP_ROM_INT(G_SHELL_ERROR_EMPTY_STRING)) },
    { MP_ROM_QSTR(MP_QSTR_FAILED), MP_ROM_PTR(MP_ROM_INT(G_SHELL_ERROR_FAILED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_SHELL_ERROR_locals_dict, G_SHELL_ERROR_locals_dict_table);

STATIC void G_SHELL_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_SHELL_ERROR");
}



STATIC const mp_obj_type_t mp_G_SHELL_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_SHELL_ERROR,
    .print = G_SHELL_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_SHELL_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_SLICE_CONFIG object definitions
 */
    

STATIC const mp_rom_map_elem_t G_SLICE_CONFIG_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_ALWAYS_MALLOC), MP_ROM_PTR(MP_ROM_INT(G_SLICE_CONFIG_ALWAYS_MALLOC)) },
    { MP_ROM_QSTR(MP_QSTR_BYPASS_MAGAZINES), MP_ROM_PTR(MP_ROM_INT(G_SLICE_CONFIG_BYPASS_MAGAZINES)) },
    { MP_ROM_QSTR(MP_QSTR_WORKING_SET_MSECS), MP_ROM_PTR(MP_ROM_INT(G_SLICE_CONFIG_WORKING_SET_MSECS)) },
    { MP_ROM_QSTR(MP_QSTR_COLOR_INCREMENT), MP_ROM_PTR(MP_ROM_INT(G_SLICE_CONFIG_COLOR_INCREMENT)) },
    { MP_ROM_QSTR(MP_QSTR_CHUNK_SIZES), MP_ROM_PTR(MP_ROM_INT(G_SLICE_CONFIG_CHUNK_SIZES)) },
    { MP_ROM_QSTR(MP_QSTR_CONTENTION_COUNTER), MP_ROM_PTR(MP_ROM_INT(G_SLICE_CONFIG_CONTENTION_COUNTER)) }
};

STATIC MP_DEFINE_CONST_DICT(G_SLICE_CONFIG_locals_dict, G_SLICE_CONFIG_locals_dict_table);

STATIC void G_SLICE_CONFIG_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_SLICE_CONFIG");
}



STATIC const mp_obj_type_t mp_G_SLICE_CONFIG_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_SLICE_CONFIG,
    .print = G_SLICE_CONFIG_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_SLICE_CONFIG_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_SPAWN_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_SPAWN_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_FORK), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_FORK)) },
    { MP_ROM_QSTR(MP_QSTR_READ), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_READ)) },
    { MP_ROM_QSTR(MP_QSTR_CHDIR), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_CHDIR)) },
    { MP_ROM_QSTR(MP_QSTR_ACCES), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_ACCES)) },
    { MP_ROM_QSTR(MP_QSTR_PERM), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_PERM)) },
    { MP_ROM_QSTR(MP_QSTR_TOO_BIG), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_TOO_BIG)) },
    { MP_ROM_QSTR(MP_QSTR__2BIG), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_2BIG)) },
    { MP_ROM_QSTR(MP_QSTR_NOEXEC), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_NOEXEC)) },
    { MP_ROM_QSTR(MP_QSTR_NAMETOOLONG), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_NAMETOOLONG)) },
    { MP_ROM_QSTR(MP_QSTR_NOENT), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_NOENT)) },
    { MP_ROM_QSTR(MP_QSTR_NOMEM), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_NOMEM)) },
    { MP_ROM_QSTR(MP_QSTR_NOTDIR), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_NOTDIR)) },
    { MP_ROM_QSTR(MP_QSTR_LOOP), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_LOOP)) },
    { MP_ROM_QSTR(MP_QSTR_TXTBUSY), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_TXTBUSY)) },
    { MP_ROM_QSTR(MP_QSTR_IO), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_IO)) },
    { MP_ROM_QSTR(MP_QSTR_NFILE), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_NFILE)) },
    { MP_ROM_QSTR(MP_QSTR_MFILE), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_MFILE)) },
    { MP_ROM_QSTR(MP_QSTR_INVAL), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_INVAL)) },
    { MP_ROM_QSTR(MP_QSTR_ISDIR), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_ISDIR)) },
    { MP_ROM_QSTR(MP_QSTR_LIBBAD), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_LIBBAD)) },
    { MP_ROM_QSTR(MP_QSTR_FAILED), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_ERROR_FAILED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_SPAWN_ERROR_locals_dict, G_SPAWN_ERROR_locals_dict_table);

STATIC void G_SPAWN_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_SPAWN_ERROR");
}



STATIC const mp_obj_type_t mp_G_SPAWN_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_SPAWN_ERROR,
    .print = G_SPAWN_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_SPAWN_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_SPAWN object definitions
 */
    

STATIC const mp_rom_map_elem_t G_SPAWN_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_DEFAULT), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_DEFAULT)) },
    { MP_ROM_QSTR(MP_QSTR_LEAVE_DESCRIPTORS_OPEN), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_LEAVE_DESCRIPTORS_OPEN)) },
    { MP_ROM_QSTR(MP_QSTR_DO_NOT_REAP_CHILD), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_DO_NOT_REAP_CHILD)) },
    { MP_ROM_QSTR(MP_QSTR_SEARCH_PATH), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_SEARCH_PATH)) },
    { MP_ROM_QSTR(MP_QSTR_STDOUT_TO_DEV_NULL), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_STDOUT_TO_DEV_NULL)) },
    { MP_ROM_QSTR(MP_QSTR_STDERR_TO_DEV_NULL), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_STDERR_TO_DEV_NULL)) },
    { MP_ROM_QSTR(MP_QSTR_CHILD_INHERITS_STDIN), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_CHILD_INHERITS_STDIN)) },
    { MP_ROM_QSTR(MP_QSTR_FILE_AND_ARGV_ZERO), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_FILE_AND_ARGV_ZERO)) },
    { MP_ROM_QSTR(MP_QSTR_SEARCH_PATH_FROM_ENVP), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_SEARCH_PATH_FROM_ENVP)) },
    { MP_ROM_QSTR(MP_QSTR_CLOEXEC_PIPES), MP_ROM_PTR(MP_ROM_INT(G_SPAWN_CLOEXEC_PIPES)) }
};

STATIC MP_DEFINE_CONST_DICT(G_SPAWN_locals_dict, G_SPAWN_locals_dict_table);

STATIC void G_SPAWN_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_SPAWN");
}



STATIC const mp_obj_type_t mp_G_SPAWN_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_SPAWN,
    .print = G_SPAWN_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_SPAWN_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_ASCII object definitions
 */
    

STATIC const mp_rom_map_elem_t G_ASCII_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_ALNUM), MP_ROM_PTR(MP_ROM_INT(G_ASCII_ALNUM)) },
    { MP_ROM_QSTR(MP_QSTR_ALPHA), MP_ROM_PTR(MP_ROM_INT(G_ASCII_ALPHA)) },
    { MP_ROM_QSTR(MP_QSTR_CNTRL), MP_ROM_PTR(MP_ROM_INT(G_ASCII_CNTRL)) },
    { MP_ROM_QSTR(MP_QSTR_DIGIT), MP_ROM_PTR(MP_ROM_INT(G_ASCII_DIGIT)) },
    { MP_ROM_QSTR(MP_QSTR_GRAPH), MP_ROM_PTR(MP_ROM_INT(G_ASCII_GRAPH)) },
    { MP_ROM_QSTR(MP_QSTR_LOWER), MP_ROM_PTR(MP_ROM_INT(G_ASCII_LOWER)) },
    { MP_ROM_QSTR(MP_QSTR_PRINT), MP_ROM_PTR(MP_ROM_INT(G_ASCII_PRINT)) },
    { MP_ROM_QSTR(MP_QSTR_PUNCT), MP_ROM_PTR(MP_ROM_INT(G_ASCII_PUNCT)) },
    { MP_ROM_QSTR(MP_QSTR_SPACE), MP_ROM_PTR(MP_ROM_INT(G_ASCII_SPACE)) },
    { MP_ROM_QSTR(MP_QSTR_UPPER), MP_ROM_PTR(MP_ROM_INT(G_ASCII_UPPER)) },
    { MP_ROM_QSTR(MP_QSTR_XDIGIT), MP_ROM_PTR(MP_ROM_INT(G_ASCII_XDIGIT)) }
};

STATIC MP_DEFINE_CONST_DICT(G_ASCII_locals_dict, G_ASCII_locals_dict_table);

STATIC void G_ASCII_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_ASCII");
}



STATIC const mp_obj_type_t mp_G_ASCII_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_ASCII,
    .print = G_ASCII_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_ASCII_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_TEST_TRAP object definitions
 */
    

STATIC const mp_rom_map_elem_t G_TEST_TRAP_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SILENCE_STDOUT), MP_ROM_PTR(MP_ROM_INT(G_TEST_TRAP_SILENCE_STDOUT)) },
    { MP_ROM_QSTR(MP_QSTR_SILENCE_STDERR), MP_ROM_PTR(MP_ROM_INT(G_TEST_TRAP_SILENCE_STDERR)) },
    { MP_ROM_QSTR(MP_QSTR_INHERIT_STDIN), MP_ROM_PTR(MP_ROM_INT(G_TEST_TRAP_INHERIT_STDIN)) }
};

STATIC MP_DEFINE_CONST_DICT(G_TEST_TRAP_locals_dict, G_TEST_TRAP_locals_dict_table);

STATIC void G_TEST_TRAP_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_TEST_TRAP");
}



STATIC const mp_obj_type_t mp_G_TEST_TRAP_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_TEST_TRAP,
    .print = G_TEST_TRAP_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_TEST_TRAP_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_TEST_SUBPROCESS_INHERIT object definitions
 */
    

STATIC const mp_rom_map_elem_t G_TEST_SUBPROCESS_INHERIT_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_STDIN), MP_ROM_PTR(MP_ROM_INT(G_TEST_SUBPROCESS_INHERIT_STDIN)) },
    { MP_ROM_QSTR(MP_QSTR_STDOUT), MP_ROM_PTR(MP_ROM_INT(G_TEST_SUBPROCESS_INHERIT_STDOUT)) },
    { MP_ROM_QSTR(MP_QSTR_STDERR), MP_ROM_PTR(MP_ROM_INT(G_TEST_SUBPROCESS_INHERIT_STDERR)) }
};

STATIC MP_DEFINE_CONST_DICT(G_TEST_SUBPROCESS_INHERIT_locals_dict, G_TEST_SUBPROCESS_INHERIT_locals_dict_table);

STATIC void G_TEST_SUBPROCESS_INHERIT_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_TEST_SUBPROCESS_INHERIT");
}



STATIC const mp_obj_type_t mp_G_TEST_SUBPROCESS_INHERIT_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_TEST_SUBPROCESS_INHERIT,
    .print = G_TEST_SUBPROCESS_INHERIT_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_TEST_SUBPROCESS_INHERIT_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_TEST_LOG object definitions
 */
    

STATIC const mp_rom_map_elem_t G_TEST_LOG_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_NONE)) },
    { MP_ROM_QSTR(MP_QSTR_ERROR), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_ERROR)) },
    { MP_ROM_QSTR(MP_QSTR_START_BINARY), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_START_BINARY)) },
    { MP_ROM_QSTR(MP_QSTR_LIST_CASE), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_LIST_CASE)) },
    { MP_ROM_QSTR(MP_QSTR_SKIP_CASE), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_SKIP_CASE)) },
    { MP_ROM_QSTR(MP_QSTR_START_CASE), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_START_CASE)) },
    { MP_ROM_QSTR(MP_QSTR_STOP_CASE), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_STOP_CASE)) },
    { MP_ROM_QSTR(MP_QSTR_MIN_RESULT), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_MIN_RESULT)) },
    { MP_ROM_QSTR(MP_QSTR_MAX_RESULT), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_MAX_RESULT)) },
    { MP_ROM_QSTR(MP_QSTR_MESSAGE), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_MESSAGE)) },
    { MP_ROM_QSTR(MP_QSTR_START_SUITE), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_START_SUITE)) },
    { MP_ROM_QSTR(MP_QSTR_STOP_SUITE), MP_ROM_PTR(MP_ROM_INT(G_TEST_LOG_STOP_SUITE)) }
};

STATIC MP_DEFINE_CONST_DICT(G_TEST_LOG_locals_dict, G_TEST_LOG_locals_dict_table);

STATIC void G_TEST_LOG_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_TEST_LOG");
}



STATIC const mp_obj_type_t mp_G_TEST_LOG_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_TEST_LOG,
    .print = G_TEST_LOG_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_TEST_LOG_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_TEST object definitions
 */
    

STATIC const mp_rom_map_elem_t G_TEST_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_DIST), MP_ROM_PTR(MP_ROM_INT(G_TEST_DIST)) },
    { MP_ROM_QSTR(MP_QSTR_BUILT), MP_ROM_PTR(MP_ROM_INT(G_TEST_BUILT)) }
};

STATIC MP_DEFINE_CONST_DICT(G_TEST_locals_dict, G_TEST_locals_dict_table);

STATIC void G_TEST_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_TEST");
}



STATIC const mp_obj_type_t mp_G_TEST_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_TEST,
    .print = G_TEST_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_TEST_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_VARIANT_CLASS object definitions
 */
    

STATIC const mp_rom_map_elem_t G_VARIANT_CLASS_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_BOOLEAN), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_BOOLEAN)) },
    { MP_ROM_QSTR(MP_QSTR_BYTE), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_BYTE)) },
    { MP_ROM_QSTR(MP_QSTR_INT16), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_INT16)) },
    { MP_ROM_QSTR(MP_QSTR_UINT16), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_UINT16)) },
    { MP_ROM_QSTR(MP_QSTR_INT32), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_INT32)) },
    { MP_ROM_QSTR(MP_QSTR_UINT32), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_UINT32)) },
    { MP_ROM_QSTR(MP_QSTR_INT64), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_INT64)) },
    { MP_ROM_QSTR(MP_QSTR_UINT64), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_UINT64)) },
    { MP_ROM_QSTR(MP_QSTR_HANDLE), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_HANDLE)) },
    { MP_ROM_QSTR(MP_QSTR_DOUBLE), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_DOUBLE)) },
    { MP_ROM_QSTR(MP_QSTR_STRING), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_STRING)) },
    { MP_ROM_QSTR(MP_QSTR_OBJECT_PATH), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_OBJECT_PATH)) },
    { MP_ROM_QSTR(MP_QSTR_SIGNATURE), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_SIGNATURE)) },
    { MP_ROM_QSTR(MP_QSTR_VARIANT), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_VARIANT)) },
    { MP_ROM_QSTR(MP_QSTR_MAYBE), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_MAYBE)) },
    { MP_ROM_QSTR(MP_QSTR_ARRAY), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_ARRAY)) },
    { MP_ROM_QSTR(MP_QSTR_TUPLE), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_TUPLE)) },
    { MP_ROM_QSTR(MP_QSTR_DICT_ENTRY), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_CLASS_DICT_ENTRY)) }
};

STATIC MP_DEFINE_CONST_DICT(G_VARIANT_CLASS_locals_dict, G_VARIANT_CLASS_locals_dict_table);

STATIC void G_VARIANT_CLASS_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_VARIANT_CLASS");
}



STATIC const mp_obj_type_t mp_G_VARIANT_CLASS_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_VARIANT_CLASS,
    .print = G_VARIANT_CLASS_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_VARIANT_CLASS_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_VARIANT_PARSE_ERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t G_VARIANT_PARSE_ERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_FAILED), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_FAILED)) },
    { MP_ROM_QSTR(MP_QSTR_BASIC_TYPE_EXPECTED), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_BASIC_TYPE_EXPECTED)) },
    { MP_ROM_QSTR(MP_QSTR_CANNOT_INFER_TYPE), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_CANNOT_INFER_TYPE)) },
    { MP_ROM_QSTR(MP_QSTR_DEFINITE_TYPE_EXPECTED), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_DEFINITE_TYPE_EXPECTED)) },
    { MP_ROM_QSTR(MP_QSTR_INPUT_NOT_AT_END), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_INPUT_NOT_AT_END)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_CHARACTER), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_INVALID_CHARACTER)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_FORMAT_STRING), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_INVALID_FORMAT_STRING)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_OBJECT_PATH), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_INVALID_OBJECT_PATH)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_SIGNATURE), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_INVALID_SIGNATURE)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_TYPE_STRING), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_INVALID_TYPE_STRING)) },
    { MP_ROM_QSTR(MP_QSTR_NO_COMMON_TYPE), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_NO_COMMON_TYPE)) },
    { MP_ROM_QSTR(MP_QSTR_NUMBER_OUT_OF_RANGE), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_NUMBER_OUT_OF_RANGE)) },
    { MP_ROM_QSTR(MP_QSTR_NUMBER_TOO_BIG), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG)) },
    { MP_ROM_QSTR(MP_QSTR_TYPE_ERROR), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_TYPE_ERROR)) },
    { MP_ROM_QSTR(MP_QSTR_UNEXPECTED_TOKEN), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_UNEXPECTED_TOKEN)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN_KEYWORD), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_UNKNOWN_KEYWORD)) },
    { MP_ROM_QSTR(MP_QSTR_UNTERMINATED_STRING_CONSTANT), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_UNTERMINATED_STRING_CONSTANT)) },
    { MP_ROM_QSTR(MP_QSTR_VALUE_EXPECTED), MP_ROM_PTR(MP_ROM_INT(G_VARIANT_PARSE_ERROR_VALUE_EXPECTED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_VARIANT_PARSE_ERROR_locals_dict, G_VARIANT_PARSE_ERROR_locals_dict_table);

STATIC void G_VARIANT_PARSE_ERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_VARIANT_PARSE_ERROR");
}



STATIC const mp_obj_type_t mp_G_VARIANT_PARSE_ERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_VARIANT_PARSE_ERROR,
    .print = G_VARIANT_PARSE_ERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_VARIANT_PARSE_ERROR_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_THREAD_PRIORITY object definitions
 */
    

STATIC const mp_rom_map_elem_t G_THREAD_PRIORITY_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_LOW), MP_ROM_PTR(MP_ROM_INT(G_THREAD_PRIORITY_LOW)) },
    { MP_ROM_QSTR(MP_QSTR_NORMAL), MP_ROM_PTR(MP_ROM_INT(G_THREAD_PRIORITY_NORMAL)) },
    { MP_ROM_QSTR(MP_QSTR_HIGH), MP_ROM_PTR(MP_ROM_INT(G_THREAD_PRIORITY_HIGH)) },
    { MP_ROM_QSTR(MP_QSTR_URGENT), MP_ROM_PTR(MP_ROM_INT(G_THREAD_PRIORITY_URGENT)) }
};

STATIC MP_DEFINE_CONST_DICT(G_THREAD_PRIORITY_locals_dict, G_THREAD_PRIORITY_locals_dict_table);

STATIC void G_THREAD_PRIORITY_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_THREAD_PRIORITY");
}



STATIC const mp_obj_type_t mp_G_THREAD_PRIORITY_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_THREAD_PRIORITY,
    .print = G_THREAD_PRIORITY_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_THREAD_PRIORITY_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_TYPE_DEBUG object definitions
 */
    

STATIC const mp_rom_map_elem_t G_TYPE_DEBUG_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_NONE), MP_ROM_PTR(MP_ROM_INT(G_TYPE_DEBUG_NONE)) },
    { MP_ROM_QSTR(MP_QSTR_OBJECTS), MP_ROM_PTR(MP_ROM_INT(G_TYPE_DEBUG_OBJECTS)) },
    { MP_ROM_QSTR(MP_QSTR_SIGNALS), MP_ROM_PTR(MP_ROM_INT(G_TYPE_DEBUG_SIGNALS)) },
    { MP_ROM_QSTR(MP_QSTR_INSTANCE_COUNT), MP_ROM_PTR(MP_ROM_INT(G_TYPE_DEBUG_INSTANCE_COUNT)) },
    { MP_ROM_QSTR(MP_QSTR_MASK), MP_ROM_PTR(MP_ROM_INT(G_TYPE_DEBUG_MASK)) }
};

STATIC MP_DEFINE_CONST_DICT(G_TYPE_DEBUG_locals_dict, G_TYPE_DEBUG_locals_dict_table);

STATIC void G_TYPE_DEBUG_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_TYPE_DEBUG");
}



STATIC const mp_obj_type_t mp_G_TYPE_DEBUG_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_TYPE_DEBUG,
    .print = G_TYPE_DEBUG_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_TYPE_DEBUG_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_TYPE_FLAG object definitions
 */
    

STATIC const mp_rom_map_elem_t G_TYPE_FLAG_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_CLASSED), MP_ROM_PTR(MP_ROM_INT(G_TYPE_FLAG_CLASSED)) },
    { MP_ROM_QSTR(MP_QSTR_INSTANTIATABLE), MP_ROM_PTR(MP_ROM_INT(G_TYPE_FLAG_INSTANTIATABLE)) },
    { MP_ROM_QSTR(MP_QSTR_DERIVABLE), MP_ROM_PTR(MP_ROM_INT(G_TYPE_FLAG_DERIVABLE)) },
    { MP_ROM_QSTR(MP_QSTR_DEEP_DERIVABLE), MP_ROM_PTR(MP_ROM_INT(G_TYPE_FLAG_DEEP_DERIVABLE)) },
    { MP_ROM_QSTR(MP_QSTR_ABSTRACT), MP_ROM_PTR(MP_ROM_INT(G_TYPE_FLAG_ABSTRACT)) },
    { MP_ROM_QSTR(MP_QSTR_VALUE_ABSTRACT), MP_ROM_PTR(MP_ROM_INT(G_TYPE_FLAG_VALUE_ABSTRACT)) }
};

STATIC MP_DEFINE_CONST_DICT(G_TYPE_FLAG_locals_dict, G_TYPE_FLAG_locals_dict_table);

STATIC void G_TYPE_FLAG_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_TYPE_FLAG");
}



STATIC const mp_obj_type_t mp_G_TYPE_FLAG_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_TYPE_FLAG,
    .print = G_TYPE_FLAG_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_TYPE_FLAG_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_PARAM object definitions
 */
    

STATIC const mp_rom_map_elem_t G_PARAM_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_READABLE), MP_ROM_PTR(MP_ROM_INT(G_PARAM_READABLE)) },
    { MP_ROM_QSTR(MP_QSTR_WRITABLE), MP_ROM_PTR(MP_ROM_INT(G_PARAM_WRITABLE)) },
    { MP_ROM_QSTR(MP_QSTR_READWRITE), MP_ROM_PTR(MP_ROM_INT(G_PARAM_READWRITE)) },
    { MP_ROM_QSTR(MP_QSTR_CONSTRUCT), MP_ROM_PTR(MP_ROM_INT(G_PARAM_CONSTRUCT)) },
    { MP_ROM_QSTR(MP_QSTR_CONSTRUCT_ONLY), MP_ROM_PTR(MP_ROM_INT(G_PARAM_CONSTRUCT_ONLY)) },
    { MP_ROM_QSTR(MP_QSTR_LAX_VALIDATION), MP_ROM_PTR(MP_ROM_INT(G_PARAM_LAX_VALIDATION)) },
    { MP_ROM_QSTR(MP_QSTR_STATIC_NAME), MP_ROM_PTR(MP_ROM_INT(G_PARAM_STATIC_NAME)) },
    { MP_ROM_QSTR(MP_QSTR_PRIVATE), MP_ROM_PTR(MP_ROM_INT(G_PARAM_PRIVATE)) },
    { MP_ROM_QSTR(MP_QSTR_STATIC_NICK), MP_ROM_PTR(MP_ROM_INT(G_PARAM_STATIC_NICK)) },
    { MP_ROM_QSTR(MP_QSTR_STATIC_BLURB), MP_ROM_PTR(MP_ROM_INT(G_PARAM_STATIC_BLURB)) },
    { MP_ROM_QSTR(MP_QSTR_EXPLICIT_NOTIFY), MP_ROM_PTR(MP_ROM_INT(G_PARAM_EXPLICIT_NOTIFY)) },
    { MP_ROM_QSTR(MP_QSTR_DEPRECATED), MP_ROM_PTR(MP_ROM_INT(G_PARAM_DEPRECATED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_PARAM_locals_dict, G_PARAM_locals_dict_table);

STATIC void G_PARAM_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_PARAM");
}



STATIC const mp_obj_type_t mp_G_PARAM_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_PARAM,
    .print = G_PARAM_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_PARAM_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_SIGNAL object definitions
 */
    

STATIC const mp_rom_map_elem_t G_SIGNAL_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_RUN_FIRST), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_RUN_FIRST)) },
    { MP_ROM_QSTR(MP_QSTR_RUN_LAST), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_RUN_LAST)) },
    { MP_ROM_QSTR(MP_QSTR_RUN_CLEANUP), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_RUN_CLEANUP)) },
    { MP_ROM_QSTR(MP_QSTR_NO_RECURSE), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_NO_RECURSE)) },
    { MP_ROM_QSTR(MP_QSTR_DETAILED), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_DETAILED)) },
    { MP_ROM_QSTR(MP_QSTR_ACTION), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_ACTION)) },
    { MP_ROM_QSTR(MP_QSTR_NO_HOOKS), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_NO_HOOKS)) },
    { MP_ROM_QSTR(MP_QSTR_MUST_COLLECT), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_MUST_COLLECT)) },
    { MP_ROM_QSTR(MP_QSTR_DEPRECATED), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_DEPRECATED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_SIGNAL_locals_dict, G_SIGNAL_locals_dict_table);

STATIC void G_SIGNAL_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_SIGNAL");
}



STATIC const mp_obj_type_t mp_G_SIGNAL_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_SIGNAL,
    .print = G_SIGNAL_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_SIGNAL_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_CONNECT object definitions
 */
    

STATIC const mp_rom_map_elem_t G_CONNECT_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_AFTER), MP_ROM_PTR(MP_ROM_INT(G_CONNECT_AFTER)) },
    { MP_ROM_QSTR(MP_QSTR_SWAPPED), MP_ROM_PTR(MP_ROM_INT(G_CONNECT_SWAPPED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_CONNECT_locals_dict, G_CONNECT_locals_dict_table);

STATIC void G_CONNECT_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_CONNECT");
}



STATIC const mp_obj_type_t mp_G_CONNECT_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_CONNECT,
    .print = G_CONNECT_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_CONNECT_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_SIGNAL_MATCH object definitions
 */
    

STATIC const mp_rom_map_elem_t G_SIGNAL_MATCH_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_ID), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_MATCH_ID)) },
    { MP_ROM_QSTR(MP_QSTR_DETAIL), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_MATCH_DETAIL)) },
    { MP_ROM_QSTR(MP_QSTR_CLOSURE), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_MATCH_CLOSURE)) },
    { MP_ROM_QSTR(MP_QSTR_FUNC), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_MATCH_FUNC)) },
    { MP_ROM_QSTR(MP_QSTR_DATA), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_MATCH_DATA)) },
    { MP_ROM_QSTR(MP_QSTR_UNBLOCKED), MP_ROM_PTR(MP_ROM_INT(G_SIGNAL_MATCH_UNBLOCKED)) }
};

STATIC MP_DEFINE_CONST_DICT(G_SIGNAL_MATCH_locals_dict, G_SIGNAL_MATCH_locals_dict_table);

STATIC void G_SIGNAL_MATCH_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_SIGNAL_MATCH");
}



STATIC const mp_obj_type_t mp_G_SIGNAL_MATCH_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_SIGNAL_MATCH,
    .print = G_SIGNAL_MATCH_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_SIGNAL_MATCH_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus G_BINDING object definitions
 */
    

STATIC const mp_rom_map_elem_t G_BINDING_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_DEFAULT), MP_ROM_PTR(MP_ROM_INT(G_BINDING_DEFAULT)) },
    { MP_ROM_QSTR(MP_QSTR_BIDIRECTIONAL), MP_ROM_PTR(MP_ROM_INT(G_BINDING_BIDIRECTIONAL)) },
    { MP_ROM_QSTR(MP_QSTR_SYNC_CREATE), MP_ROM_PTR(MP_ROM_INT(G_BINDING_SYNC_CREATE)) },
    { MP_ROM_QSTR(MP_QSTR_INVERT_BOOLEAN), MP_ROM_PTR(MP_ROM_INT(G_BINDING_INVERT_BOOLEAN)) }
};

STATIC MP_DEFINE_CONST_DICT(G_BINDING_locals_dict, G_BINDING_locals_dict_table);

STATIC void G_BINDING_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus G_BINDING");
}



STATIC const mp_obj_type_t mp_G_BINDING_type = {
    { &mp_type_type },
    .name = MP_QSTR_G_BINDING,
    .print = G_BINDING_print,
    
    .locals_dict = (mp_obj_dict_t*)&G_BINDING_locals_dict,
    
    .parent = NULL,
};
    

/*
 * dbus DBUS_GERROR object definitions
 */
    

STATIC const mp_rom_map_elem_t DBUS_GERROR_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_FAILED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_FAILED)) },
    { MP_ROM_QSTR(MP_QSTR_NO_MEMORY), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_NO_MEMORY)) },
    { MP_ROM_QSTR(MP_QSTR_SERVICE_UNKNOWN), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_SERVICE_UNKNOWN)) },
    { MP_ROM_QSTR(MP_QSTR_NAME_HAS_NO_OWNER), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_NAME_HAS_NO_OWNER)) },
    { MP_ROM_QSTR(MP_QSTR_NO_REPLY), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_NO_REPLY)) },
    { MP_ROM_QSTR(MP_QSTR_IO_ERROR), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_IO_ERROR)) },
    { MP_ROM_QSTR(MP_QSTR_BAD_ADDRESS), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_BAD_ADDRESS)) },
    { MP_ROM_QSTR(MP_QSTR_NOT_SUPPORTED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_NOT_SUPPORTED)) },
    { MP_ROM_QSTR(MP_QSTR_LIMITS_EXCEEDED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_LIMITS_EXCEEDED)) },
    { MP_ROM_QSTR(MP_QSTR_ACCESS_DENIED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_ACCESS_DENIED)) },
    { MP_ROM_QSTR(MP_QSTR_AUTH_FAILED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_AUTH_FAILED)) },
    { MP_ROM_QSTR(MP_QSTR_NO_SERVER), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_NO_SERVER)) },
    { MP_ROM_QSTR(MP_QSTR_TIMEOUT), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_TIMEOUT)) },
    { MP_ROM_QSTR(MP_QSTR_NO_NETWORK), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_NO_NETWORK)) },
    { MP_ROM_QSTR(MP_QSTR_ADDRESS_IN_USE), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_ADDRESS_IN_USE)) },
    { MP_ROM_QSTR(MP_QSTR_DISCONNECTED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_DISCONNECTED)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_ARGS), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_INVALID_ARGS)) },
    { MP_ROM_QSTR(MP_QSTR_FILE_NOT_FOUND), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_FILE_NOT_FOUND)) },
    { MP_ROM_QSTR(MP_QSTR_FILE_EXISTS), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_FILE_EXISTS)) },
    { MP_ROM_QSTR(MP_QSTR_UNKNOWN_METHOD), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_UNKNOWN_METHOD)) },
    { MP_ROM_QSTR(MP_QSTR_TIMED_OUT), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_TIMED_OUT)) },
    { MP_ROM_QSTR(MP_QSTR_MATCH_RULE_NOT_FOUND), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_MATCH_RULE_NOT_FOUND)) },
    { MP_ROM_QSTR(MP_QSTR_MATCH_RULE_INVALID), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_MATCH_RULE_INVALID)) },
    { MP_ROM_QSTR(MP_QSTR_SPAWN_EXEC_FAILED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_SPAWN_EXEC_FAILED)) },
    { MP_ROM_QSTR(MP_QSTR_SPAWN_FORK_FAILED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_SPAWN_FORK_FAILED)) },
    { MP_ROM_QSTR(MP_QSTR_SPAWN_CHILD_EXITED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_SPAWN_CHILD_EXITED)) },
    { MP_ROM_QSTR(MP_QSTR_SPAWN_CHILD_SIGNALED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_SPAWN_CHILD_SIGNALED)) },
    { MP_ROM_QSTR(MP_QSTR_SPAWN_FAILED), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_SPAWN_FAILED)) },
    { MP_ROM_QSTR(MP_QSTR_UNIX_PROCESS_ID_UNKNOWN), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_SIGNATURE), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_INVALID_SIGNATURE)) },
    { MP_ROM_QSTR(MP_QSTR_INVALID_FILE_CONTENT), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_INVALID_FILE_CONTENT)) },
    { MP_ROM_QSTR(MP_QSTR_SELINUX_SECURITY_CONTEXT_UNKNOWN), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN)) },
    { MP_ROM_QSTR(MP_QSTR_REMOTE_EXCEPTION), MP_ROM_PTR(MP_ROM_INT(DBUS_GERROR_REMOTE_EXCEPTION)) }
};

STATIC MP_DEFINE_CONST_DICT(DBUS_GERROR_locals_dict, DBUS_GERROR_locals_dict_table);

STATIC void DBUS_GERROR_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "dbus DBUS_GERROR");
}



STATIC const mp_obj_type_t mp_DBUS_GERROR_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBUS_GERROR,
    .print = DBUS_GERROR_print,
    
    .locals_dict = (mp_obj_dict_t*)&DBUS_GERROR_locals_dict,
    
    .parent = NULL,
};
    

STATIC const mp_obj_type_t mp_obj_type;

STATIC inline const mp_obj_type_t *get_BaseObj_type()
{
    return &mp_obj_type;
}


/* 
 *
 * Global Module Functions
 *
 */


/*
 * dbus extension definition for:
 * inline static gboolean _GLIB_CHECKED_ADD_U32(guint32 *dest, guint32 a, guint32 b)
 */
 
STATIC mp_obj_t mp__GLIB_CHECKED_ADD_U32(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint32 *dest = mp_to_ptr(mp_args[0]);
    guint32 a = (unsigned int)mp_obj_get_int(mp_args[1]);
    guint32 b = (unsigned int)mp_obj_get_int(mp_args[2]);
    gboolean res = _GLIB_CHECKED_ADD_U32(dest, a, b);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp__GLIB_CHECKED_ADD_U32_obj, 3, mp__GLIB_CHECKED_ADD_U32, _GLIB_CHECKED_ADD_U32);

 

/*
 * dbus extension definition for:
 * inline static gboolean _GLIB_CHECKED_MUL_U32(guint32 *dest, guint32 a, guint32 b)
 */
 
STATIC mp_obj_t mp__GLIB_CHECKED_MUL_U32(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint32 *dest = mp_to_ptr(mp_args[0]);
    guint32 a = (unsigned int)mp_obj_get_int(mp_args[1]);
    guint32 b = (unsigned int)mp_obj_get_int(mp_args[2]);
    gboolean res = _GLIB_CHECKED_MUL_U32(dest, a, b);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp__GLIB_CHECKED_MUL_U32_obj, 3, mp__GLIB_CHECKED_MUL_U32, _GLIB_CHECKED_MUL_U32);

 

/*
 * dbus extension definition for:
 * inline static gboolean _GLIB_CHECKED_ADD_U64(guint64 *dest, guint64 a, guint64 b)
 */
 
STATIC mp_obj_t mp__GLIB_CHECKED_ADD_U64(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint64 *dest = mp_to_ptr(mp_args[0]);
    guint64 a = (unsigned long)mp_obj_get_int(mp_args[1]);
    guint64 b = (unsigned long)mp_obj_get_int(mp_args[2]);
    gboolean res = _GLIB_CHECKED_ADD_U64(dest, a, b);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp__GLIB_CHECKED_ADD_U64_obj, 3, mp__GLIB_CHECKED_ADD_U64, _GLIB_CHECKED_ADD_U64);

 

/*
 * dbus extension definition for:
 * inline static gboolean _GLIB_CHECKED_MUL_U64(guint64 *dest, guint64 a, guint64 b)
 */
 
STATIC mp_obj_t mp__GLIB_CHECKED_MUL_U64(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint64 *dest = mp_to_ptr(mp_args[0]);
    guint64 a = (unsigned long)mp_obj_get_int(mp_args[1]);
    guint64 b = (unsigned long)mp_obj_get_int(mp_args[2]);
    gboolean res = _GLIB_CHECKED_MUL_U64(dest, a, b);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp__GLIB_CHECKED_MUL_U64_obj, 3, mp__GLIB_CHECKED_MUL_U64, _GLIB_CHECKED_MUL_U64);

 

/*
 * dbus extension definition for:
 * inline static gint g_bit_nth_lsf_impl(gulong mask, gint nth_bit)
 */
 
STATIC mp_obj_t mp_g_bit_nth_lsf_impl(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gulong mask = (unsigned long)mp_obj_get_int(mp_args[0]);
    gint nth_bit = (int)mp_obj_get_int(mp_args[1]);
    gint res = g_bit_nth_lsf_impl(mask, nth_bit);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bit_nth_lsf_impl_obj, 2, mp_g_bit_nth_lsf_impl, g_bit_nth_lsf_impl);

 

/*
 * dbus extension definition for:
 * inline static gint g_bit_nth_msf_impl(gulong mask, gint nth_bit)
 */
 
STATIC mp_obj_t mp_g_bit_nth_msf_impl(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gulong mask = (unsigned long)mp_obj_get_int(mp_args[0]);
    gint nth_bit = (int)mp_obj_get_int(mp_args[1]);
    gint res = g_bit_nth_msf_impl(mask, nth_bit);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bit_nth_msf_impl_obj, 2, mp_g_bit_nth_msf_impl, g_bit_nth_msf_impl);

 

/*
 * dbus extension definition for:
 * inline static guint g_bit_storage_impl(gulong number)
 */
 
STATIC mp_obj_t mp_g_bit_storage_impl(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gulong number = (unsigned long)mp_obj_get_int(mp_args[0]);
    guint res = g_bit_storage_impl(number);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bit_storage_impl_obj, 1, mp_g_bit_storage_impl, g_bit_storage_impl);

 

/*
 * dbus extension definition for:
 * inline static GMutexLocker *g_mutex_locker_new(GMutex *mutex)
 */
 
STATIC mp_obj_t mp_g_mutex_locker_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMutex *mutex = mp_to_ptr(mp_args[0]);
    GMutexLocker * res = g_mutex_locker_new(mutex);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mutex_locker_new_obj, 1, mp_g_mutex_locker_new, g_mutex_locker_new);

 

/*
 * dbus extension definition for:
 * inline static void g_mutex_locker_free(GMutexLocker *locker)
 */
 
STATIC mp_obj_t mp_g_mutex_locker_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMutexLocker *locker = mp_to_ptr(mp_args[0]);
    g_mutex_locker_free(locker);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mutex_locker_free_obj, 1, mp_g_mutex_locker_free, g_mutex_locker_free);

 

/*
 * dbus extension definition for:
 * inline static gpointer g_steal_pointer(gpointer pp)
 */
 
STATIC mp_obj_t mp_g_steal_pointer(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer pp = mp_to_ptr(mp_args[0]);
    gpointer res = g_steal_pointer(pp);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_steal_pointer_obj, 1, mp_g_steal_pointer, g_steal_pointer);

 

/*
 * dbus extension definition for:
 * inline static GString *g_string_append_c_inline(GString *gstring, gchar c)
 */
 
STATIC mp_obj_t mp_g_string_append_c_inline(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *gstring = mp_to_ptr(mp_args[0]);
    gchar c = (char)mp_obj_get_int(mp_args[1]);
    GString * res = g_string_append_c_inline(gstring, c);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_append_c_inline_obj, 2, mp_g_string_append_c_inline, g_string_append_c_inline);

 

/*
 * dbus extension definition for:
 * inline static void g_autoptr_cleanup_generic_gfree(void *p)
 */
 
STATIC mp_obj_t mp_g_autoptr_cleanup_generic_gfree(size_t mp_n_args, const mp_obj_t *mp_args)
{
    void *p = mp_to_ptr(mp_args[0]);
    g_autoptr_cleanup_generic_gfree(p);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_autoptr_cleanup_generic_gfree_obj, 1, mp_g_autoptr_cleanup_generic_gfree, g_autoptr_cleanup_generic_gfree);

 

/*
 * dbus extension definition for:
 * inline static void g_autoptr_cleanup_gstring_free(GString *string)
 */
 
STATIC mp_obj_t mp_g_autoptr_cleanup_gstring_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    g_autoptr_cleanup_gstring_free(string);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_autoptr_cleanup_gstring_free_obj, 1, mp_g_autoptr_cleanup_gstring_free, g_autoptr_cleanup_gstring_free);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GAsyncQueue(GAsyncQueue **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GAsyncQueue(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GAsyncQueue(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GAsyncQueue_obj, 1, mp_glib_autoptr_cleanup_GAsyncQueue, glib_autoptr_cleanup_GAsyncQueue);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GBookmarkFile(GBookmarkFile **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GBookmarkFile(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GBookmarkFile(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GBookmarkFile_obj, 1, mp_glib_autoptr_cleanup_GBookmarkFile, glib_autoptr_cleanup_GBookmarkFile);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GBytes(GBytes **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GBytes(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBytes **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GBytes(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GBytes_obj, 1, mp_glib_autoptr_cleanup_GBytes, glib_autoptr_cleanup_GBytes);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GChecksum(GChecksum **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GChecksum(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GChecksum **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GChecksum(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GChecksum_obj, 1, mp_glib_autoptr_cleanup_GChecksum, glib_autoptr_cleanup_GChecksum);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GDateTime(GDateTime **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GDateTime(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GDateTime(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GDateTime_obj, 1, mp_glib_autoptr_cleanup_GDateTime, glib_autoptr_cleanup_GDateTime);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GDir(GDir **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GDir(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDir **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GDir(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GDir_obj, 1, mp_glib_autoptr_cleanup_GDir, glib_autoptr_cleanup_GDir);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GError(GError **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GError(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GError **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GError(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GError_obj, 1, mp_glib_autoptr_cleanup_GError, glib_autoptr_cleanup_GError);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GHashTable(GHashTable **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GHashTable(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GHashTable(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GHashTable_obj, 1, mp_glib_autoptr_cleanup_GHashTable, glib_autoptr_cleanup_GHashTable);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GHmac(GHmac **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GHmac(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHmac **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GHmac(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GHmac_obj, 1, mp_glib_autoptr_cleanup_GHmac, glib_autoptr_cleanup_GHmac);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GIOChannel(GIOChannel **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GIOChannel(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GIOChannel(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GIOChannel_obj, 1, mp_glib_autoptr_cleanup_GIOChannel, glib_autoptr_cleanup_GIOChannel);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GKeyFile(GKeyFile **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GKeyFile(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GKeyFile(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GKeyFile_obj, 1, mp_glib_autoptr_cleanup_GKeyFile, glib_autoptr_cleanup_GKeyFile);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GList(GList **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GList(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GList(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GList_obj, 1, mp_glib_autoptr_cleanup_GList, glib_autoptr_cleanup_GList);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GArray(GArray **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GArray(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GArray(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GArray_obj, 1, mp_glib_autoptr_cleanup_GArray, glib_autoptr_cleanup_GArray);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GPtrArray(GPtrArray **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GPtrArray(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GPtrArray(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GPtrArray_obj, 1, mp_glib_autoptr_cleanup_GPtrArray, glib_autoptr_cleanup_GPtrArray);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GByteArray(GByteArray **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GByteArray(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GByteArray(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GByteArray_obj, 1, mp_glib_autoptr_cleanup_GByteArray, glib_autoptr_cleanup_GByteArray);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GMainContext(GMainContext **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GMainContext(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GMainContext(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GMainContext_obj, 1, mp_glib_autoptr_cleanup_GMainContext, glib_autoptr_cleanup_GMainContext);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GMainLoop(GMainLoop **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GMainLoop(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainLoop **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GMainLoop(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GMainLoop_obj, 1, mp_glib_autoptr_cleanup_GMainLoop, glib_autoptr_cleanup_GMainLoop);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GSource(GSource **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GSource(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GSource(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GSource_obj, 1, mp_glib_autoptr_cleanup_GSource, glib_autoptr_cleanup_GSource);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GMappedFile(GMappedFile **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GMappedFile(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMappedFile **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GMappedFile(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GMappedFile_obj, 1, mp_glib_autoptr_cleanup_GMappedFile, glib_autoptr_cleanup_GMappedFile);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GMarkupParseContext(GMarkupParseContext **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GMarkupParseContext(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMarkupParseContext **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GMarkupParseContext(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GMarkupParseContext_obj, 1, mp_glib_autoptr_cleanup_GMarkupParseContext, glib_autoptr_cleanup_GMarkupParseContext);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GNode(GNode **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GNode(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GNode(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GNode_obj, 1, mp_glib_autoptr_cleanup_GNode, glib_autoptr_cleanup_GNode);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GOptionContext(GOptionContext **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GOptionContext(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GOptionContext(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GOptionContext_obj, 1, mp_glib_autoptr_cleanup_GOptionContext, glib_autoptr_cleanup_GOptionContext);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GOptionGroup(GOptionGroup **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GOptionGroup(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionGroup **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GOptionGroup(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GOptionGroup_obj, 1, mp_glib_autoptr_cleanup_GOptionGroup, glib_autoptr_cleanup_GOptionGroup);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GPatternSpec(GPatternSpec **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GPatternSpec(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPatternSpec **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GPatternSpec(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GPatternSpec_obj, 1, mp_glib_autoptr_cleanup_GPatternSpec, glib_autoptr_cleanup_GPatternSpec);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GQueue(GQueue **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GQueue(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GQueue **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GQueue(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GQueue_obj, 1, mp_glib_autoptr_cleanup_GQueue, glib_autoptr_cleanup_GQueue);

 

/*
 * dbus extension definition for:
 * inline static void glib_auto_cleanup_GQueue(GQueue *_ptr)
 */
 
STATIC mp_obj_t mp_glib_auto_cleanup_GQueue(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GQueue *_ptr = mp_to_ptr(mp_args[0]);
    glib_auto_cleanup_GQueue(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_auto_cleanup_GQueue_obj, 1, mp_glib_auto_cleanup_GQueue, glib_auto_cleanup_GQueue);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GRand(GRand **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GRand(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRand **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GRand(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GRand_obj, 1, mp_glib_autoptr_cleanup_GRand, glib_autoptr_cleanup_GRand);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GRegex(GRegex **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GRegex(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRegex **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GRegex(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GRegex_obj, 1, mp_glib_autoptr_cleanup_GRegex, glib_autoptr_cleanup_GRegex);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GMatchInfo(GMatchInfo **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GMatchInfo(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMatchInfo **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GMatchInfo(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GMatchInfo_obj, 1, mp_glib_autoptr_cleanup_GMatchInfo, glib_autoptr_cleanup_GMatchInfo);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GScanner(GScanner **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GScanner(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GScanner **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GScanner(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GScanner_obj, 1, mp_glib_autoptr_cleanup_GScanner, glib_autoptr_cleanup_GScanner);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GSequence(GSequence **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GSequence(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSequence **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GSequence(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GSequence_obj, 1, mp_glib_autoptr_cleanup_GSequence, glib_autoptr_cleanup_GSequence);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GSList(GSList **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GSList(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GSList(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GSList_obj, 1, mp_glib_autoptr_cleanup_GSList, glib_autoptr_cleanup_GSList);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GString(GString **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GString(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GString(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GString_obj, 1, mp_glib_autoptr_cleanup_GString, glib_autoptr_cleanup_GString);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GStringChunk(GStringChunk **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GStringChunk(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GStringChunk **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GStringChunk(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GStringChunk_obj, 1, mp_glib_autoptr_cleanup_GStringChunk, glib_autoptr_cleanup_GStringChunk);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GThread(GThread **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GThread(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GThread **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GThread(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GThread_obj, 1, mp_glib_autoptr_cleanup_GThread, glib_autoptr_cleanup_GThread);

 

/*
 * dbus extension definition for:
 * inline static void glib_auto_cleanup_GMutex(GMutex *_ptr)
 */
 
STATIC mp_obj_t mp_glib_auto_cleanup_GMutex(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMutex *_ptr = mp_to_ptr(mp_args[0]);
    glib_auto_cleanup_GMutex(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_auto_cleanup_GMutex_obj, 1, mp_glib_auto_cleanup_GMutex, glib_auto_cleanup_GMutex);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GMutexLocker(GMutexLocker **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GMutexLocker(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMutexLocker **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GMutexLocker(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GMutexLocker_obj, 1, mp_glib_autoptr_cleanup_GMutexLocker, glib_autoptr_cleanup_GMutexLocker);

 

/*
 * dbus extension definition for:
 * inline static void glib_auto_cleanup_GCond(GCond *_ptr)
 */
 
STATIC mp_obj_t mp_glib_auto_cleanup_GCond(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GCond *_ptr = mp_to_ptr(mp_args[0]);
    glib_auto_cleanup_GCond(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_auto_cleanup_GCond_obj, 1, mp_glib_auto_cleanup_GCond, glib_auto_cleanup_GCond);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GTimer(GTimer **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GTimer(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GTimer **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GTimer(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GTimer_obj, 1, mp_glib_autoptr_cleanup_GTimer, glib_autoptr_cleanup_GTimer);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GTimeZone(GTimeZone **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GTimeZone(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GTimeZone **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GTimeZone(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GTimeZone_obj, 1, mp_glib_autoptr_cleanup_GTimeZone, glib_autoptr_cleanup_GTimeZone);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GTree(GTree **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GTree(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GTree **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GTree(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GTree_obj, 1, mp_glib_autoptr_cleanup_GTree, glib_autoptr_cleanup_GTree);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GVariant(GVariant **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GVariant(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GVariant **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GVariant(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GVariant_obj, 1, mp_glib_autoptr_cleanup_GVariant, glib_autoptr_cleanup_GVariant);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GVariantBuilder(GVariantBuilder **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GVariantBuilder(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GVariantBuilder **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GVariantBuilder(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GVariantBuilder_obj, 1, mp_glib_autoptr_cleanup_GVariantBuilder, glib_autoptr_cleanup_GVariantBuilder);

 

/*
 * dbus extension definition for:
 * inline static void glib_auto_cleanup_GVariantBuilder(GVariantBuilder *_ptr)
 */
 
STATIC mp_obj_t mp_glib_auto_cleanup_GVariantBuilder(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GVariantBuilder *_ptr = mp_to_ptr(mp_args[0]);
    glib_auto_cleanup_GVariantBuilder(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_auto_cleanup_GVariantBuilder_obj, 1, mp_glib_auto_cleanup_GVariantBuilder, glib_auto_cleanup_GVariantBuilder);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GVariantIter(GVariantIter **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GVariantIter(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GVariantIter **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GVariantIter(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GVariantIter_obj, 1, mp_glib_autoptr_cleanup_GVariantIter, glib_autoptr_cleanup_GVariantIter);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GVariantDict(GVariantDict **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GVariantDict(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GVariantDict **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GVariantDict(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GVariantDict_obj, 1, mp_glib_autoptr_cleanup_GVariantDict, glib_autoptr_cleanup_GVariantDict);

 

/*
 * dbus extension definition for:
 * inline static void glib_auto_cleanup_GVariantDict(GVariantDict *_ptr)
 */
 
STATIC mp_obj_t mp_glib_auto_cleanup_GVariantDict(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GVariantDict *_ptr = mp_to_ptr(mp_args[0]);
    glib_auto_cleanup_GVariantDict(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_auto_cleanup_GVariantDict_obj, 1, mp_glib_auto_cleanup_GVariantDict, glib_auto_cleanup_GVariantDict);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GVariantType(GVariantType **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GVariantType(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GVariantType **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GVariantType(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GVariantType_obj, 1, mp_glib_autoptr_cleanup_GVariantType, glib_autoptr_cleanup_GVariantType);

 

/*
 * dbus extension definition for:
 * inline static void glib_auto_cleanup_GStrv(GStrv *_ptr)
 */
 
STATIC mp_obj_t mp_glib_auto_cleanup_GStrv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GStrv *_ptr = mp_to_ptr(mp_args[0]);
    glib_auto_cleanup_GStrv(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_auto_cleanup_GStrv_obj, 1, mp_glib_auto_cleanup_GStrv, glib_auto_cleanup_GStrv);

 

/*
 * dbus extension definition for:
 * inline static gboolean g_set_object(GObject **object_ptr, GObject *new_object)
 */
 
STATIC mp_obj_t mp_g_set_object(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GObject **object_ptr = mp_to_ptr(mp_args[0]);
    GObject *new_object = mp_to_ptr(mp_args[1]);
    gboolean res = g_set_object(object_ptr, new_object);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_set_object_obj, 2, mp_g_set_object, g_set_object);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GObject(GObject **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GObject(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GObject **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GObject(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GObject_obj, 1, mp_glib_autoptr_cleanup_GObject, glib_autoptr_cleanup_GObject);

 

/*
 * dbus extension definition for:
 * inline static void glib_autoptr_cleanup_GInitiallyUnowned(GInitiallyUnowned **_ptr)
 */
 
STATIC mp_obj_t mp_glib_autoptr_cleanup_GInitiallyUnowned(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GInitiallyUnowned **_ptr = mp_to_ptr(mp_args[0]);
    glib_autoptr_cleanup_GInitiallyUnowned(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_autoptr_cleanup_GInitiallyUnowned_obj, 1, mp_glib_autoptr_cleanup_GInitiallyUnowned, glib_autoptr_cleanup_GInitiallyUnowned);

 

/*
 * dbus extension definition for:
 * inline static void glib_auto_cleanup_GValue(GValue *_ptr)
 */
 
STATIC mp_obj_t mp_glib_auto_cleanup_GValue(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GValue *_ptr = mp_to_ptr(mp_args[0]);
    glib_auto_cleanup_GValue(_ptr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_glib_auto_cleanup_GValue_obj, 1, mp_glib_auto_cleanup_GValue, glib_auto_cleanup_GValue);

 

/*
 * Struct DBusError
 */

STATIC inline const mp_obj_type_t *get_mp_DBusError_type();

STATIC inline DBusError* mp_write_ptr_DBusError(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_DBusError_type()));
    return (DBusError*)self->data;
}

#define mp_write_DBusError(struct_obj) *mp_write_ptr_DBusError(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_DBusError(DBusError *field)
{
    return lv_to_mp_struct(get_mp_DBusError_type(), (void*)field);
}

#define mp_read_DBusError(field) mp_read_ptr_DBusError(copy_buffer(&field, sizeof(DBusError)))
#define mp_read_byref_DBusError(field) mp_read_ptr_DBusError(&field)

STATIC void mp_DBusError_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    DBusError *data = (DBusError*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_name: dest[0] = convert_to_str((void*)data->name); break; // converting from char *;
            case MP_QSTR_message: dest[0] = convert_to_str((void*)data->message); break; // converting from char *;
            case MP_QSTR_dummy1: dest[0] = mp_obj_new_int_from_uint(data->dummy1); break; // converting from unsigned int;
            case MP_QSTR_dummy2: dest[0] = mp_obj_new_int_from_uint(data->dummy2); break; // converting from unsigned int;
            case MP_QSTR_dummy3: dest[0] = mp_obj_new_int_from_uint(data->dummy3); break; // converting from unsigned int;
            case MP_QSTR_dummy4: dest[0] = mp_obj_new_int_from_uint(data->dummy4); break; // converting from unsigned int;
            case MP_QSTR_dummy5: dest[0] = mp_obj_new_int_from_uint(data->dummy5); break; // converting from unsigned int;
            case MP_QSTR_padding1: dest[0] = ptr_to_mp((void*)data->padding1); break; // converting from void *;
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_name: data->name = (void*)(char*)mp_obj_str_get_str(dest[1]); break; // converting to char *;
                case MP_QSTR_message: data->message = (void*)(char*)mp_obj_str_get_str(dest[1]); break; // converting to char *;
                case MP_QSTR_dummy1: data->dummy1 = (unsigned int)mp_obj_get_int(dest[1]); break; // converting to unsigned int;
                case MP_QSTR_dummy2: data->dummy2 = (unsigned int)mp_obj_get_int(dest[1]); break; // converting to unsigned int;
                case MP_QSTR_dummy3: data->dummy3 = (unsigned int)mp_obj_get_int(dest[1]); break; // converting to unsigned int;
                case MP_QSTR_dummy4: data->dummy4 = (unsigned int)mp_obj_get_int(dest[1]); break; // converting to unsigned int;
                case MP_QSTR_dummy5: data->dummy5 = (unsigned int)mp_obj_get_int(dest[1]); break; // converting to unsigned int;
                case MP_QSTR_padding1: data->padding1 = (void*)mp_to_ptr(dest[1]); break; // converting to void *;
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_DBusError_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct DBusError");
}

STATIC const mp_rom_map_elem_t mp_DBusError_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(DBusError))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_DBusError_locals_dict, mp_DBusError_locals_dict_table);

STATIC const mp_obj_type_t mp_DBusError_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBusError,
    .print = mp_DBusError_print,
    .make_new = make_new_lv_struct,
    .attr = mp_DBusError_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_DBusError_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_DBusError_type()
{
    return &mp_DBusError_type;
}
    

/*
 * dbus extension definition for:
 * void dbus_error_init(DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_error_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusError *error = mp_write_ptr_DBusError(mp_args[0]);
    dbus_error_init(error);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_error_init_obj, 1, mp_dbus_error_init, dbus_error_init);

 

/*
 * dbus extension definition for:
 * void dbus_error_free(DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_error_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusError *error = mp_write_ptr_DBusError(mp_args[0]);
    dbus_error_free(error);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_error_free_obj, 1, mp_dbus_error_free, dbus_error_free);

 

/*
 * dbus extension definition for:
 * void dbus_set_error(DBusError *error, const char *name, const char *message, ...)
 */
 
STATIC mp_obj_t mp_dbus_set_error(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusError *error = mp_write_ptr_DBusError(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *message = (char*)mp_obj_str_get_str(mp_args[2]);
    dbus_set_error(error, name, message);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_set_error_obj, 4, mp_dbus_set_error, dbus_set_error);

 

/*
 * dbus extension definition for:
 * void dbus_set_error_const(DBusError *error, const char *name, const char *message)
 */
 
STATIC mp_obj_t mp_dbus_set_error_const(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusError *error = mp_write_ptr_DBusError(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *message = (char*)mp_obj_str_get_str(mp_args[2]);
    dbus_set_error_const(error, name, message);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_set_error_const_obj, 3, mp_dbus_set_error_const, dbus_set_error_const);

 

/*
 * dbus extension definition for:
 * void dbus_move_error(DBusError *src, DBusError *dest)
 */
 
STATIC mp_obj_t mp_dbus_move_error(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusError *src = mp_write_ptr_DBusError(mp_args[0]);
    DBusError *dest = mp_write_ptr_DBusError(mp_args[1]);
    dbus_move_error(src, dest);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_move_error_obj, 2, mp_dbus_move_error, dbus_move_error);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_error_has_name(const DBusError *error, const char *name)
 */
 
STATIC mp_obj_t mp_dbus_error_has_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const DBusError *error = mp_write_ptr_DBusError(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_error_has_name(error, name);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_error_has_name_obj, 2, mp_dbus_error_has_name, dbus_error_has_name);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_error_is_set(const DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_error_is_set(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const DBusError *error = mp_write_ptr_DBusError(mp_args[0]);
    dbus_bool_t res = dbus_error_is_set(error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_error_is_set_obj, 1, mp_dbus_error_is_set, dbus_error_is_set);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_parse_address(const char *address, DBusAddressEntry ***entry, int *array_len, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_parse_address(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *address = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusAddressEntry ***entry = mp_to_ptr(mp_args[1]);
    int *array_len = mp_to_ptr(mp_args[2]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[3]);
    dbus_bool_t res = dbus_parse_address(address, entry, array_len, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_parse_address_obj, 4, mp_dbus_parse_address, dbus_parse_address);

 

/*
 * dbus extension definition for:
 * const char *dbus_address_entry_get_value(DBusAddressEntry *entry, const char *key)
 */
 
STATIC mp_obj_t mp_dbus_address_entry_get_value(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusAddressEntry *entry = mp_to_ptr(mp_args[0]);
    const char *key = (char*)mp_obj_str_get_str(mp_args[1]);
    const char * res = dbus_address_entry_get_value(entry, key);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_address_entry_get_value_obj, 2, mp_dbus_address_entry_get_value, dbus_address_entry_get_value);

 

/*
 * dbus extension definition for:
 * const char *dbus_address_entry_get_method(DBusAddressEntry *entry)
 */
 
STATIC mp_obj_t mp_dbus_address_entry_get_method(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusAddressEntry *entry = mp_to_ptr(mp_args[0]);
    const char * res = dbus_address_entry_get_method(entry);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_address_entry_get_method_obj, 1, mp_dbus_address_entry_get_method, dbus_address_entry_get_method);

 

/*
 * dbus extension definition for:
 * void dbus_address_entries_free(DBusAddressEntry **entries)
 */
 
STATIC mp_obj_t mp_dbus_address_entries_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusAddressEntry **entries = mp_to_ptr(mp_args[0]);
    dbus_address_entries_free(entries);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_address_entries_free_obj, 1, mp_dbus_address_entries_free, dbus_address_entries_free);

 

/*
 * dbus extension definition for:
 * char *dbus_address_escape_value(const char *value)
 */
 
STATIC mp_obj_t mp_dbus_address_escape_value(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *value = (char*)mp_obj_str_get_str(mp_args[0]);
    char * res = dbus_address_escape_value(value);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_address_escape_value_obj, 1, mp_dbus_address_escape_value, dbus_address_escape_value);

 

/*
 * dbus extension definition for:
 * char *dbus_address_unescape_value(const char *value, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_address_unescape_value(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *value = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    char * res = dbus_address_unescape_value(value, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_address_unescape_value_obj, 2, mp_dbus_address_unescape_value, dbus_address_unescape_value);

 

/*
 * dbus extension definition for:
 * void *dbus_malloc(size_t bytes)
 */
 
STATIC mp_obj_t mp_dbus_malloc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    size_t bytes = (size_t)mp_obj_get_int(mp_args[0]);
    void * res = dbus_malloc(bytes);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_malloc_obj, 1, mp_dbus_malloc, dbus_malloc);

 

/*
 * dbus extension definition for:
 * void *dbus_malloc0(size_t bytes)
 */
 
STATIC mp_obj_t mp_dbus_malloc0(size_t mp_n_args, const mp_obj_t *mp_args)
{
    size_t bytes = (size_t)mp_obj_get_int(mp_args[0]);
    void * res = dbus_malloc0(bytes);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_malloc0_obj, 1, mp_dbus_malloc0, dbus_malloc0);

 

/*
 * dbus extension definition for:
 * void *dbus_realloc(void *memory, size_t bytes)
 */
 
STATIC mp_obj_t mp_dbus_realloc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    void *memory = mp_to_ptr(mp_args[0]);
    size_t bytes = (size_t)mp_obj_get_int(mp_args[1]);
    void * res = dbus_realloc(memory, bytes);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_realloc_obj, 2, mp_dbus_realloc, dbus_realloc);

 

/*
 * dbus extension definition for:
 * void dbus_free(void *memory)
 */
 
STATIC mp_obj_t mp_dbus_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    void *memory = mp_to_ptr(mp_args[0]);
    dbus_free(memory);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_free_obj, 1, mp_dbus_free, dbus_free);

 

/*
 * dbus extension definition for:
 * void dbus_free_string_array(char **str_array)
 */
 
STATIC mp_obj_t mp_dbus_free_string_array(size_t mp_n_args, const mp_obj_t *mp_args)
{
    char **str_array = mp_to_ptr(mp_args[0]);
    dbus_free_string_array(str_array);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_free_string_array_obj, 1, mp_dbus_free_string_array, dbus_free_string_array);

 

/*
 * dbus extension definition for:
 * void dbus_shutdown(void)
 */
 
STATIC mp_obj_t mp_dbus_shutdown(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    dbus_shutdown();
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_shutdown_obj, 0, mp_dbus_shutdown, dbus_shutdown);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_message_new(int message_type)
 */
 
STATIC mp_obj_t mp_dbus_message_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int message_type = (int)mp_obj_get_int(mp_args[0]);
    DBusMessage * res = dbus_message_new(message_type);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_new_obj, 1, mp_dbus_message_new, dbus_message_new);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_message_new_method_call(const char *bus_name, const char *path, const char *iface, const char *method)
 */
 
STATIC mp_obj_t mp_dbus_message_new_method_call(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *bus_name = (char*)mp_obj_str_get_str(mp_args[0]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *iface = (char*)mp_obj_str_get_str(mp_args[2]);
    const char *method = (char*)mp_obj_str_get_str(mp_args[3]);
    DBusMessage * res = dbus_message_new_method_call(bus_name, path, iface, method);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_new_method_call_obj, 4, mp_dbus_message_new_method_call, dbus_message_new_method_call);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_message_new_method_return(DBusMessage *method_call)
 */
 
STATIC mp_obj_t mp_dbus_message_new_method_return(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *method_call = mp_to_ptr(mp_args[0]);
    DBusMessage * res = dbus_message_new_method_return(method_call);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_new_method_return_obj, 1, mp_dbus_message_new_method_return, dbus_message_new_method_return);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_message_new_signal(const char *path, const char *iface, const char *name)
 */
 
STATIC mp_obj_t mp_dbus_message_new_signal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *path = (char*)mp_obj_str_get_str(mp_args[0]);
    const char *iface = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[2]);
    DBusMessage * res = dbus_message_new_signal(path, iface, name);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_new_signal_obj, 3, mp_dbus_message_new_signal, dbus_message_new_signal);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_message_new_error(DBusMessage *reply_to, const char *error_name, const char *error_message)
 */
 
STATIC mp_obj_t mp_dbus_message_new_error(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *reply_to = mp_to_ptr(mp_args[0]);
    const char *error_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *error_message = (char*)mp_obj_str_get_str(mp_args[2]);
    DBusMessage * res = dbus_message_new_error(reply_to, error_name, error_message);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_new_error_obj, 3, mp_dbus_message_new_error, dbus_message_new_error);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_message_new_error_printf(DBusMessage *reply_to, const char *error_name, const char *error_format, ...)
 */
 
STATIC mp_obj_t mp_dbus_message_new_error_printf(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *reply_to = mp_to_ptr(mp_args[0]);
    const char *error_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *error_format = (char*)mp_obj_str_get_str(mp_args[2]);
    DBusMessage * res = dbus_message_new_error_printf(reply_to, error_name, error_format);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_new_error_printf_obj, 4, mp_dbus_message_new_error_printf, dbus_message_new_error_printf);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_message_copy(const DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_copy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const DBusMessage *message = mp_to_ptr(mp_args[0]);
    DBusMessage * res = dbus_message_copy(message);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_copy_obj, 1, mp_dbus_message_copy, dbus_message_copy);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_message_ref(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    DBusMessage * res = dbus_message_ref(message);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_ref_obj, 1, mp_dbus_message_ref, dbus_message_ref);

 

/*
 * dbus extension definition for:
 * void dbus_message_unref(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_message_unref(message);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_unref_obj, 1, mp_dbus_message_unref, dbus_message_unref);

 

/*
 * dbus extension definition for:
 * int dbus_message_get_type(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    int res = dbus_message_get_type(message);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_type_obj, 1, mp_dbus_message_get_type, dbus_message_get_type);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_set_path(DBusMessage *message, const char *object_path)
 */
 
STATIC mp_obj_t mp_dbus_message_set_path(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *object_path = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_set_path(message, object_path);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_path_obj, 2, mp_dbus_message_set_path, dbus_message_set_path);

 

/*
 * dbus extension definition for:
 * const char *dbus_message_get_path(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_path(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char * res = dbus_message_get_path(message);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_path_obj, 1, mp_dbus_message_get_path, dbus_message_get_path);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_has_path(DBusMessage *message, const char *object_path)
 */
 
STATIC mp_obj_t mp_dbus_message_has_path(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *object_path = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_has_path(message, object_path);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_has_path_obj, 2, mp_dbus_message_has_path, dbus_message_has_path);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_set_interface(DBusMessage *message, const char *iface)
 */
 
STATIC mp_obj_t mp_dbus_message_set_interface(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *iface = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_set_interface(message, iface);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_interface_obj, 2, mp_dbus_message_set_interface, dbus_message_set_interface);

 

/*
 * dbus extension definition for:
 * const char *dbus_message_get_interface(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_interface(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char * res = dbus_message_get_interface(message);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_interface_obj, 1, mp_dbus_message_get_interface, dbus_message_get_interface);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_has_interface(DBusMessage *message, const char *iface)
 */
 
STATIC mp_obj_t mp_dbus_message_has_interface(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *iface = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_has_interface(message, iface);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_has_interface_obj, 2, mp_dbus_message_has_interface, dbus_message_has_interface);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_set_member(DBusMessage *message, const char *member)
 */
 
STATIC mp_obj_t mp_dbus_message_set_member(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *member = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_set_member(message, member);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_member_obj, 2, mp_dbus_message_set_member, dbus_message_set_member);

 

/*
 * dbus extension definition for:
 * const char *dbus_message_get_member(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_member(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char * res = dbus_message_get_member(message);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_member_obj, 1, mp_dbus_message_get_member, dbus_message_get_member);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_has_member(DBusMessage *message, const char *member)
 */
 
STATIC mp_obj_t mp_dbus_message_has_member(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *member = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_has_member(message, member);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_has_member_obj, 2, mp_dbus_message_has_member, dbus_message_has_member);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_set_error_name(DBusMessage *message, const char *name)
 */
 
STATIC mp_obj_t mp_dbus_message_set_error_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_set_error_name(message, name);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_error_name_obj, 2, mp_dbus_message_set_error_name, dbus_message_set_error_name);

 

/*
 * dbus extension definition for:
 * const char *dbus_message_get_error_name(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_error_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char * res = dbus_message_get_error_name(message);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_error_name_obj, 1, mp_dbus_message_get_error_name, dbus_message_get_error_name);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_set_destination(DBusMessage *message, const char *destination)
 */
 
STATIC mp_obj_t mp_dbus_message_set_destination(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *destination = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_set_destination(message, destination);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_destination_obj, 2, mp_dbus_message_set_destination, dbus_message_set_destination);

 

/*
 * dbus extension definition for:
 * const char *dbus_message_get_destination(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_destination(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char * res = dbus_message_get_destination(message);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_destination_obj, 1, mp_dbus_message_get_destination, dbus_message_get_destination);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_set_sender(DBusMessage *message, const char *sender)
 */
 
STATIC mp_obj_t mp_dbus_message_set_sender(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *sender = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_set_sender(message, sender);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_sender_obj, 2, mp_dbus_message_set_sender, dbus_message_set_sender);

 

/*
 * dbus extension definition for:
 * const char *dbus_message_get_sender(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_sender(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char * res = dbus_message_get_sender(message);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_sender_obj, 1, mp_dbus_message_get_sender, dbus_message_get_sender);

 

/*
 * dbus extension definition for:
 * const char *dbus_message_get_signature(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_signature(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char * res = dbus_message_get_signature(message);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_signature_obj, 1, mp_dbus_message_get_signature, dbus_message_get_signature);

 

/*
 * dbus extension definition for:
 * void dbus_message_set_no_reply(DBusMessage *message, dbus_bool_t no_reply)
 */
 
STATIC mp_obj_t mp_dbus_message_set_no_reply(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_bool_t no_reply = (unsigned int)mp_obj_get_int(mp_args[1]);
    dbus_message_set_no_reply(message, no_reply);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_no_reply_obj, 2, mp_dbus_message_set_no_reply, dbus_message_set_no_reply);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_get_no_reply(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_no_reply(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_message_get_no_reply(message);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_no_reply_obj, 1, mp_dbus_message_get_no_reply, dbus_message_get_no_reply);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_is_method_call(DBusMessage *message, const char *iface, const char *method)
 */
 
STATIC mp_obj_t mp_dbus_message_is_method_call(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *iface = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *method = (char*)mp_obj_str_get_str(mp_args[2]);
    dbus_bool_t res = dbus_message_is_method_call(message, iface, method);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_is_method_call_obj, 3, mp_dbus_message_is_method_call, dbus_message_is_method_call);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_is_signal(DBusMessage *message, const char *iface, const char *signal_name)
 */
 
STATIC mp_obj_t mp_dbus_message_is_signal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *iface = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *signal_name = (char*)mp_obj_str_get_str(mp_args[2]);
    dbus_bool_t res = dbus_message_is_signal(message, iface, signal_name);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_is_signal_obj, 3, mp_dbus_message_is_signal, dbus_message_is_signal);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_is_error(DBusMessage *message, const char *error_name)
 */
 
STATIC mp_obj_t mp_dbus_message_is_error(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *error_name = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_is_error(message, error_name);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_is_error_obj, 2, mp_dbus_message_is_error, dbus_message_is_error);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_has_destination(DBusMessage *message, const char *bus_name)
 */
 
STATIC mp_obj_t mp_dbus_message_has_destination(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *bus_name = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_has_destination(message, bus_name);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_has_destination_obj, 2, mp_dbus_message_has_destination, dbus_message_has_destination);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_has_sender(DBusMessage *message, const char *unique_bus_name)
 */
 
STATIC mp_obj_t mp_dbus_message_has_sender(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *unique_bus_name = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_has_sender(message, unique_bus_name);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_has_sender_obj, 2, mp_dbus_message_has_sender, dbus_message_has_sender);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_has_signature(DBusMessage *message, const char *signature)
 */
 
STATIC mp_obj_t mp_dbus_message_has_signature(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    const char *signature = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_message_has_signature(message, signature);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_has_signature_obj, 2, mp_dbus_message_has_signature, dbus_message_has_signature);

 

/*
 * dbus extension definition for:
 * dbus_uint32_t dbus_message_get_serial(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_serial(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_uint32_t res = dbus_message_get_serial(message);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_serial_obj, 1, mp_dbus_message_get_serial, dbus_message_get_serial);

 

/*
 * dbus extension definition for:
 * void dbus_message_set_serial(DBusMessage *message, dbus_uint32_t serial)
 */
 
STATIC mp_obj_t mp_dbus_message_set_serial(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_uint32_t serial = (unsigned int)mp_obj_get_int(mp_args[1]);
    dbus_message_set_serial(message, serial);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_serial_obj, 2, mp_dbus_message_set_serial, dbus_message_set_serial);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_set_reply_serial(DBusMessage *message, dbus_uint32_t reply_serial)
 */
 
STATIC mp_obj_t mp_dbus_message_set_reply_serial(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_uint32_t reply_serial = (unsigned int)mp_obj_get_int(mp_args[1]);
    dbus_bool_t res = dbus_message_set_reply_serial(message, reply_serial);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_reply_serial_obj, 2, mp_dbus_message_set_reply_serial, dbus_message_set_reply_serial);

 

/*
 * dbus extension definition for:
 * dbus_uint32_t dbus_message_get_reply_serial(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_reply_serial(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_uint32_t res = dbus_message_get_reply_serial(message);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_reply_serial_obj, 1, mp_dbus_message_get_reply_serial, dbus_message_get_reply_serial);

 

/*
 * dbus extension definition for:
 * void dbus_message_set_auto_start(DBusMessage *message, dbus_bool_t auto_start)
 */
 
STATIC mp_obj_t mp_dbus_message_set_auto_start(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_bool_t auto_start = (unsigned int)mp_obj_get_int(mp_args[1]);
    dbus_message_set_auto_start(message, auto_start);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_auto_start_obj, 2, mp_dbus_message_set_auto_start, dbus_message_set_auto_start);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_get_auto_start(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_auto_start(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_message_get_auto_start(message);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_auto_start_obj, 1, mp_dbus_message_get_auto_start, dbus_message_get_auto_start);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_get_path_decomposed(DBusMessage *message, char ***path)
 */
 
STATIC mp_obj_t mp_dbus_message_get_path_decomposed(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    char ***path = mp_to_ptr(mp_args[1]);
    dbus_bool_t res = dbus_message_get_path_decomposed(message, path);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_path_decomposed_obj, 2, mp_dbus_message_get_path_decomposed, dbus_message_get_path_decomposed);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_append_args(DBusMessage *message, int first_arg_type, ...)
 */
 
STATIC mp_obj_t mp_dbus_message_append_args(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    int first_arg_type = (int)mp_obj_get_int(mp_args[1]);
    dbus_bool_t res = dbus_message_append_args(message, first_arg_type);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_append_args_obj, 3, mp_dbus_message_append_args, dbus_message_append_args);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_append_args_valist(DBusMessage *message, int first_arg_type, va_list var_args)
 */
 
STATIC mp_obj_t mp_dbus_message_append_args_valist(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    int first_arg_type = (int)mp_obj_get_int(mp_args[1]);
    va_list var_args = mp_to_ptr(mp_args[2]);
    dbus_bool_t res = dbus_message_append_args_valist(message, first_arg_type, var_args);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_append_args_valist_obj, 3, mp_dbus_message_append_args_valist, dbus_message_append_args_valist);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_get_args(DBusMessage *message, DBusError *error, int first_arg_type, ...)
 */
 
STATIC mp_obj_t mp_dbus_message_get_args(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    int first_arg_type = (int)mp_obj_get_int(mp_args[2]);
    dbus_bool_t res = dbus_message_get_args(message, error, first_arg_type);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_args_obj, 4, mp_dbus_message_get_args, dbus_message_get_args);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_get_args_valist(DBusMessage *message, DBusError *error, int first_arg_type, va_list var_args)
 */
 
STATIC mp_obj_t mp_dbus_message_get_args_valist(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    int first_arg_type = (int)mp_obj_get_int(mp_args[2]);
    va_list var_args = mp_to_ptr(mp_args[3]);
    dbus_bool_t res = dbus_message_get_args_valist(message, error, first_arg_type, var_args);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_args_valist_obj, 4, mp_dbus_message_get_args_valist, dbus_message_get_args_valist);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_contains_unix_fds(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_contains_unix_fds(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_message_contains_unix_fds(message);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_contains_unix_fds_obj, 1, mp_dbus_message_contains_unix_fds, dbus_message_contains_unix_fds);

 

/*
 * Struct DBusMessageIter
 */

STATIC inline const mp_obj_type_t *get_mp_DBusMessageIter_type();

STATIC inline DBusMessageIter* mp_write_ptr_DBusMessageIter(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_DBusMessageIter_type()));
    return (DBusMessageIter*)self->data;
}

#define mp_write_DBusMessageIter(struct_obj) *mp_write_ptr_DBusMessageIter(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_DBusMessageIter(DBusMessageIter *field)
{
    return lv_to_mp_struct(get_mp_DBusMessageIter_type(), (void*)field);
}

#define mp_read_DBusMessageIter(field) mp_read_ptr_DBusMessageIter(copy_buffer(&field, sizeof(DBusMessageIter)))
#define mp_read_byref_DBusMessageIter(field) mp_read_ptr_DBusMessageIter(&field)

STATIC void mp_DBusMessageIter_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    DBusMessageIter *data = (DBusMessageIter*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_dummy1: dest[0] = ptr_to_mp((void*)data->dummy1); break; // converting from void *;
            case MP_QSTR_dummy2: dest[0] = ptr_to_mp((void*)data->dummy2); break; // converting from void *;
            case MP_QSTR_dummy3: dest[0] = mp_obj_new_int_from_uint(data->dummy3); break; // converting from dbus_uint32_t;
            case MP_QSTR_dummy4: dest[0] = mp_obj_new_int(data->dummy4); break; // converting from int;
            case MP_QSTR_dummy5: dest[0] = mp_obj_new_int(data->dummy5); break; // converting from int;
            case MP_QSTR_dummy6: dest[0] = mp_obj_new_int(data->dummy6); break; // converting from int;
            case MP_QSTR_dummy7: dest[0] = mp_obj_new_int(data->dummy7); break; // converting from int;
            case MP_QSTR_dummy8: dest[0] = mp_obj_new_int(data->dummy8); break; // converting from int;
            case MP_QSTR_dummy9: dest[0] = mp_obj_new_int(data->dummy9); break; // converting from int;
            case MP_QSTR_dummy10: dest[0] = mp_obj_new_int(data->dummy10); break; // converting from int;
            case MP_QSTR_dummy11: dest[0] = mp_obj_new_int(data->dummy11); break; // converting from int;
            case MP_QSTR_pad1: dest[0] = mp_obj_new_int(data->pad1); break; // converting from int;
            case MP_QSTR_pad2: dest[0] = mp_obj_new_int(data->pad2); break; // converting from int;
            case MP_QSTR_pad3: dest[0] = ptr_to_mp((void*)data->pad3); break; // converting from void *;
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_dummy1: data->dummy1 = (void*)mp_to_ptr(dest[1]); break; // converting to void *;
                case MP_QSTR_dummy2: data->dummy2 = (void*)mp_to_ptr(dest[1]); break; // converting to void *;
                case MP_QSTR_dummy3: data->dummy3 = (unsigned int)mp_obj_get_int(dest[1]); break; // converting to dbus_uint32_t;
                case MP_QSTR_dummy4: data->dummy4 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_dummy5: data->dummy5 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_dummy6: data->dummy6 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_dummy7: data->dummy7 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_dummy8: data->dummy8 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_dummy9: data->dummy9 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_dummy10: data->dummy10 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_dummy11: data->dummy11 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_pad1: data->pad1 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_pad2: data->pad2 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_pad3: data->pad3 = (void*)mp_to_ptr(dest[1]); break; // converting to void *;
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_DBusMessageIter_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct DBusMessageIter");
}

STATIC const mp_rom_map_elem_t mp_DBusMessageIter_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(DBusMessageIter))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_DBusMessageIter_locals_dict, mp_DBusMessageIter_locals_dict_table);

STATIC const mp_obj_type_t mp_DBusMessageIter_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBusMessageIter,
    .print = mp_DBusMessageIter_print,
    .make_new = make_new_lv_struct,
    .attr = mp_DBusMessageIter_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_DBusMessageIter_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_DBusMessageIter_type()
{
    return &mp_DBusMessageIter_type;
}
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_iter_init(DBusMessage *message, DBusMessageIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[1]);
    dbus_bool_t res = dbus_message_iter_init(message, iter);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_init_obj, 2, mp_dbus_message_iter_init, dbus_message_iter_init);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_iter_has_next(DBusMessageIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_has_next(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    dbus_bool_t res = dbus_message_iter_has_next(iter);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_has_next_obj, 1, mp_dbus_message_iter_has_next, dbus_message_iter_has_next);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_iter_next(DBusMessageIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_next(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    dbus_bool_t res = dbus_message_iter_next(iter);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_next_obj, 1, mp_dbus_message_iter_next, dbus_message_iter_next);

 

/*
 * dbus extension definition for:
 * char *dbus_message_iter_get_signature(DBusMessageIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_get_signature(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    char * res = dbus_message_iter_get_signature(iter);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_get_signature_obj, 1, mp_dbus_message_iter_get_signature, dbus_message_iter_get_signature);

 

/*
 * dbus extension definition for:
 * int dbus_message_iter_get_arg_type(DBusMessageIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_get_arg_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    int res = dbus_message_iter_get_arg_type(iter);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_get_arg_type_obj, 1, mp_dbus_message_iter_get_arg_type, dbus_message_iter_get_arg_type);

 

/*
 * dbus extension definition for:
 * int dbus_message_iter_get_element_type(DBusMessageIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_get_element_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    int res = dbus_message_iter_get_element_type(iter);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_get_element_type_obj, 1, mp_dbus_message_iter_get_element_type, dbus_message_iter_get_element_type);

 

/*
 * dbus extension definition for:
 * void dbus_message_iter_recurse(DBusMessageIter *iter, DBusMessageIter *sub)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_recurse(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    DBusMessageIter *sub = mp_write_ptr_DBusMessageIter(mp_args[1]);
    dbus_message_iter_recurse(iter, sub);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_recurse_obj, 2, mp_dbus_message_iter_recurse, dbus_message_iter_recurse);

 

/*
 * dbus extension definition for:
 * void dbus_message_iter_get_basic(DBusMessageIter *iter, void *value)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_get_basic(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    void *value = mp_to_ptr(mp_args[1]);
    dbus_message_iter_get_basic(iter, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_get_basic_obj, 2, mp_dbus_message_iter_get_basic, dbus_message_iter_get_basic);

 

/*
 * dbus extension definition for:
 * int dbus_message_iter_get_element_count(DBusMessageIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_get_element_count(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    int res = dbus_message_iter_get_element_count(iter);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_get_element_count_obj, 1, mp_dbus_message_iter_get_element_count, dbus_message_iter_get_element_count);

 

/*
 * dbus extension definition for:
 * int dbus_message_iter_get_array_len(DBusMessageIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_get_array_len(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    int res = dbus_message_iter_get_array_len(iter);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_get_array_len_obj, 1, mp_dbus_message_iter_get_array_len, dbus_message_iter_get_array_len);

 

/*
 * dbus extension definition for:
 * void dbus_message_iter_get_fixed_array(DBusMessageIter *iter, void *value, int *n_elements)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_get_fixed_array(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    void *value = mp_to_ptr(mp_args[1]);
    int *n_elements = mp_to_ptr(mp_args[2]);
    dbus_message_iter_get_fixed_array(iter, value, n_elements);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_get_fixed_array_obj, 3, mp_dbus_message_iter_get_fixed_array, dbus_message_iter_get_fixed_array);

 

/*
 * dbus extension definition for:
 * void dbus_message_iter_init_append(DBusMessage *message, DBusMessageIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_init_append(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[1]);
    dbus_message_iter_init_append(message, iter);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_init_append_obj, 2, mp_dbus_message_iter_init_append, dbus_message_iter_init_append);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter *iter, int type, const void *value)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_append_basic(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    int type = (int)mp_obj_get_int(mp_args[1]);
    const void *value = mp_to_ptr(mp_args[2]);
    dbus_bool_t res = dbus_message_iter_append_basic(iter, type, value);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_append_basic_obj, 3, mp_dbus_message_iter_append_basic, dbus_message_iter_append_basic);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_iter_append_fixed_array(DBusMessageIter *iter, int element_type, const void *value, int n_elements)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_append_fixed_array(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    int element_type = (int)mp_obj_get_int(mp_args[1]);
    const void *value = mp_to_ptr(mp_args[2]);
    int n_elements = (int)mp_obj_get_int(mp_args[3]);
    dbus_bool_t res = dbus_message_iter_append_fixed_array(iter, element_type, value, n_elements);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_append_fixed_array_obj, 4, mp_dbus_message_iter_append_fixed_array, dbus_message_iter_append_fixed_array);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_iter_open_container(DBusMessageIter *iter, int type, const char *contained_signature, DBusMessageIter *sub)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_open_container(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    int type = (int)mp_obj_get_int(mp_args[1]);
    const char *contained_signature = (char*)mp_obj_str_get_str(mp_args[2]);
    DBusMessageIter *sub = mp_write_ptr_DBusMessageIter(mp_args[3]);
    dbus_bool_t res = dbus_message_iter_open_container(iter, type, contained_signature, sub);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_open_container_obj, 4, mp_dbus_message_iter_open_container, dbus_message_iter_open_container);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_iter_close_container(DBusMessageIter *iter, DBusMessageIter *sub)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_close_container(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    DBusMessageIter *sub = mp_write_ptr_DBusMessageIter(mp_args[1]);
    dbus_bool_t res = dbus_message_iter_close_container(iter, sub);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_close_container_obj, 2, mp_dbus_message_iter_close_container, dbus_message_iter_close_container);

 

/*
 * dbus extension definition for:
 * void dbus_message_iter_abandon_container(DBusMessageIter *iter, DBusMessageIter *sub)
 */
 
STATIC mp_obj_t mp_dbus_message_iter_abandon_container(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessageIter *iter = mp_write_ptr_DBusMessageIter(mp_args[0]);
    DBusMessageIter *sub = mp_write_ptr_DBusMessageIter(mp_args[1]);
    dbus_message_iter_abandon_container(iter, sub);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_iter_abandon_container_obj, 2, mp_dbus_message_iter_abandon_container, dbus_message_iter_abandon_container);

 

/*
 * dbus extension definition for:
 * void dbus_message_lock(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_lock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_message_lock(message);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_lock_obj, 1, mp_dbus_message_lock, dbus_message_lock);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_set_error_from_message(DBusError *error, DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_set_error_from_message(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusError *error = mp_write_ptr_DBusError(mp_args[0]);
    DBusMessage *message = mp_to_ptr(mp_args[1]);
    dbus_bool_t res = dbus_set_error_from_message(error, message);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_set_error_from_message_obj, 2, mp_dbus_set_error_from_message, dbus_set_error_from_message);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_allocate_data_slot(dbus_int32_t *slot_p)
 */
 
STATIC mp_obj_t mp_dbus_message_allocate_data_slot(size_t mp_n_args, const mp_obj_t *mp_args)
{
    dbus_int32_t *slot_p = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_message_allocate_data_slot(slot_p);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_allocate_data_slot_obj, 1, mp_dbus_message_allocate_data_slot, dbus_message_allocate_data_slot);

 

/*
 * dbus extension definition for:
 * void dbus_message_free_data_slot(dbus_int32_t *slot_p)
 */
 
STATIC mp_obj_t mp_dbus_message_free_data_slot(size_t mp_n_args, const mp_obj_t *mp_args)
{
    dbus_int32_t *slot_p = mp_to_ptr(mp_args[0]);
    dbus_message_free_data_slot(slot_p);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_free_data_slot_obj, 1, mp_dbus_message_free_data_slot, dbus_message_free_data_slot);

 

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_func' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_func
 */
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_set_data(DBusMessage *message, dbus_int32_t slot, void *data, DBusFreeFunction free_data_func)
 */
 
STATIC mp_obj_t mp_dbus_message_set_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_int32_t slot = (int)mp_obj_get_int(mp_args[1]);
    void *data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_data_func = mp_to_ptr(mp_args[3]);
    dbus_bool_t res = dbus_message_set_data(message, slot, data, free_data_func);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_data_obj, 4, mp_dbus_message_set_data, dbus_message_set_data);

 

/*
 * dbus extension definition for:
 * void *dbus_message_get_data(DBusMessage *message, dbus_int32_t slot)
 */
 
STATIC mp_obj_t mp_dbus_message_get_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_int32_t slot = (int)mp_obj_get_int(mp_args[1]);
    void * res = dbus_message_get_data(message, slot);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_data_obj, 2, mp_dbus_message_get_data, dbus_message_get_data);

 

/*
 * dbus extension definition for:
 * int dbus_message_type_from_string(const char *type_str)
 */
 
STATIC mp_obj_t mp_dbus_message_type_from_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *type_str = (char*)mp_obj_str_get_str(mp_args[0]);
    int res = dbus_message_type_from_string(type_str);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_type_from_string_obj, 1, mp_dbus_message_type_from_string, dbus_message_type_from_string);

 

/*
 * dbus extension definition for:
 * const char *dbus_message_type_to_string(int type)
 */
 
STATIC mp_obj_t mp_dbus_message_type_to_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int type = (int)mp_obj_get_int(mp_args[0]);
    const char * res = dbus_message_type_to_string(type);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_type_to_string_obj, 1, mp_dbus_message_type_to_string, dbus_message_type_to_string);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_marshal(DBusMessage *msg, char **marshalled_data_p, int *len_p)
 */
 
STATIC mp_obj_t mp_dbus_message_marshal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *msg = mp_to_ptr(mp_args[0]);
    char **marshalled_data_p = mp_to_ptr(mp_args[1]);
    int *len_p = mp_to_ptr(mp_args[2]);
    dbus_bool_t res = dbus_message_marshal(msg, marshalled_data_p, len_p);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_marshal_obj, 3, mp_dbus_message_marshal, dbus_message_marshal);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_message_demarshal(const char *str, int len, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_message_demarshal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *str = (char*)mp_obj_str_get_str(mp_args[0]);
    int len = (int)mp_obj_get_int(mp_args[1]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[2]);
    DBusMessage * res = dbus_message_demarshal(str, len, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_demarshal_obj, 3, mp_dbus_message_demarshal, dbus_message_demarshal);

 

/*
 * dbus extension definition for:
 * int dbus_message_demarshal_bytes_needed(const char *str, int len)
 */
 
STATIC mp_obj_t mp_dbus_message_demarshal_bytes_needed(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *str = (char*)mp_obj_str_get_str(mp_args[0]);
    int len = (int)mp_obj_get_int(mp_args[1]);
    int res = dbus_message_demarshal_bytes_needed(str, len);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_demarshal_bytes_needed_obj, 2, mp_dbus_message_demarshal_bytes_needed, dbus_message_demarshal_bytes_needed);

 

/*
 * dbus extension definition for:
 * void dbus_message_set_allow_interactive_authorization(DBusMessage *message, dbus_bool_t allow)
 */
 
STATIC mp_obj_t mp_dbus_message_set_allow_interactive_authorization(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_bool_t allow = (unsigned int)mp_obj_get_int(mp_args[1]);
    dbus_message_set_allow_interactive_authorization(message, allow);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_set_allow_interactive_authorization_obj, 2, mp_dbus_message_set_allow_interactive_authorization, dbus_message_set_allow_interactive_authorization);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_message_get_allow_interactive_authorization(DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_message_get_allow_interactive_authorization(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusMessage *message = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_message_get_allow_interactive_authorization(message);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_message_get_allow_interactive_authorization_obj, 1, mp_dbus_message_get_allow_interactive_authorization, dbus_message_get_allow_interactive_authorization);

 

/*
 * dbus extension definition for:
 * DBusConnection *dbus_connection_open(const char *address, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_connection_open(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *address = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    DBusConnection * res = dbus_connection_open(address, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_open_obj, 2, mp_dbus_connection_open, dbus_connection_open);

 

/*
 * dbus extension definition for:
 * DBusConnection *dbus_connection_open_private(const char *address, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_connection_open_private(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *address = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    DBusConnection * res = dbus_connection_open_private(address, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_open_private_obj, 2, mp_dbus_connection_open_private, dbus_connection_open_private);

 

/*
 * dbus extension definition for:
 * DBusConnection *dbus_connection_ref(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusConnection * res = dbus_connection_ref(connection);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_ref_obj, 1, mp_dbus_connection_ref, dbus_connection_ref);

 

/*
 * dbus extension definition for:
 * void dbus_connection_unref(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_connection_unref(connection);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_unref_obj, 1, mp_dbus_connection_unref, dbus_connection_unref);

 

/*
 * dbus extension definition for:
 * void dbus_connection_close(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_close(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_connection_close(connection);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_close_obj, 1, mp_dbus_connection_close, dbus_connection_close);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_get_is_connected(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_is_connected(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_connection_get_is_connected(connection);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_is_connected_obj, 1, mp_dbus_connection_get_is_connected, dbus_connection_get_is_connected);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_get_is_authenticated(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_is_authenticated(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_connection_get_is_authenticated(connection);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_is_authenticated_obj, 1, mp_dbus_connection_get_is_authenticated, dbus_connection_get_is_authenticated);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_get_is_anonymous(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_is_anonymous(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_connection_get_is_anonymous(connection);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_is_anonymous_obj, 1, mp_dbus_connection_get_is_anonymous, dbus_connection_get_is_anonymous);

 

/*
 * dbus extension definition for:
 * char *dbus_connection_get_server_id(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_server_id(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    char * res = dbus_connection_get_server_id(connection);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_server_id_obj, 1, mp_dbus_connection_get_server_id, dbus_connection_get_server_id);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_can_send_type(DBusConnection *connection, int type)
 */
 
STATIC mp_obj_t mp_dbus_connection_can_send_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    int type = (int)mp_obj_get_int(mp_args[1]);
    dbus_bool_t res = dbus_connection_can_send_type(connection, type);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_can_send_type_obj, 2, mp_dbus_connection_can_send_type, dbus_connection_can_send_type);

 

/*
 * dbus extension definition for:
 * void dbus_connection_set_exit_on_disconnect(DBusConnection *connection, dbus_bool_t exit_on_disconnect)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_exit_on_disconnect(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_bool_t exit_on_disconnect = (unsigned int)mp_obj_get_int(mp_args[1]);
    dbus_connection_set_exit_on_disconnect(connection, exit_on_disconnect);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_exit_on_disconnect_obj, 2, mp_dbus_connection_set_exit_on_disconnect, dbus_connection_set_exit_on_disconnect);

 

/*
 * dbus extension definition for:
 * void dbus_connection_flush(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_flush(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_connection_flush(connection);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_flush_obj, 1, mp_dbus_connection_flush, dbus_connection_flush);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_read_write_dispatch(DBusConnection *connection, int timeout_milliseconds)
 */
 
STATIC mp_obj_t mp_dbus_connection_read_write_dispatch(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    int timeout_milliseconds = (int)mp_obj_get_int(mp_args[1]);
    dbus_bool_t res = dbus_connection_read_write_dispatch(connection, timeout_milliseconds);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_read_write_dispatch_obj, 2, mp_dbus_connection_read_write_dispatch, dbus_connection_read_write_dispatch);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_read_write(DBusConnection *connection, int timeout_milliseconds)
 */
 
STATIC mp_obj_t mp_dbus_connection_read_write(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    int timeout_milliseconds = (int)mp_obj_get_int(mp_args[1]);
    dbus_bool_t res = dbus_connection_read_write(connection, timeout_milliseconds);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_read_write_obj, 2, mp_dbus_connection_read_write, dbus_connection_read_write);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_connection_borrow_message(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_borrow_message(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusMessage * res = dbus_connection_borrow_message(connection);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_borrow_message_obj, 1, mp_dbus_connection_borrow_message, dbus_connection_borrow_message);

 

/*
 * dbus extension definition for:
 * void dbus_connection_return_message(DBusConnection *connection, DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_connection_return_message(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusMessage *message = mp_to_ptr(mp_args[1]);
    dbus_connection_return_message(connection, message);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_return_message_obj, 2, mp_dbus_connection_return_message, dbus_connection_return_message);

 

/*
 * dbus extension definition for:
 * void dbus_connection_steal_borrowed_message(DBusConnection *connection, DBusMessage *message)
 */
 
STATIC mp_obj_t mp_dbus_connection_steal_borrowed_message(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusMessage *message = mp_to_ptr(mp_args[1]);
    dbus_connection_steal_borrowed_message(connection, message);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_steal_borrowed_message_obj, 2, mp_dbus_connection_steal_borrowed_message, dbus_connection_steal_borrowed_message);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_connection_pop_message(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_pop_message(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusMessage * res = dbus_connection_pop_message(connection);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_pop_message_obj, 1, mp_dbus_connection_pop_message, dbus_connection_pop_message);

 

/*
 * dbus extension definition for:
 * DBusDispatchStatus dbus_connection_get_dispatch_status(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_dispatch_status(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusDispatchStatus res = dbus_connection_get_dispatch_status(connection);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_dispatch_status_obj, 1, mp_dbus_connection_get_dispatch_status, dbus_connection_get_dispatch_status);

 

/*
 * dbus extension definition for:
 * DBusDispatchStatus dbus_connection_dispatch(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_dispatch(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusDispatchStatus res = dbus_connection_dispatch(connection);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_dispatch_obj, 1, mp_dbus_connection_dispatch, dbus_connection_dispatch);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_has_messages_to_send(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_has_messages_to_send(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_connection_has_messages_to_send(connection);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_has_messages_to_send_obj, 1, mp_dbus_connection_has_messages_to_send, dbus_connection_has_messages_to_send);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_send(DBusConnection *connection, DBusMessage *message, dbus_uint32_t *client_serial)
 */
 
STATIC mp_obj_t mp_dbus_connection_send(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusMessage *message = mp_to_ptr(mp_args[1]);
    dbus_uint32_t *client_serial = mp_to_ptr(mp_args[2]);
    dbus_bool_t res = dbus_connection_send(connection, message, client_serial);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_send_obj, 3, mp_dbus_connection_send, dbus_connection_send);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_send_with_reply(DBusConnection *connection, DBusMessage *message, DBusPendingCall **pending_return, int timeout_milliseconds)
 */
 
STATIC mp_obj_t mp_dbus_connection_send_with_reply(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusMessage *message = mp_to_ptr(mp_args[1]);
    DBusPendingCall **pending_return = mp_to_ptr(mp_args[2]);
    int timeout_milliseconds = (int)mp_obj_get_int(mp_args[3]);
    dbus_bool_t res = dbus_connection_send_with_reply(connection, message, pending_return, timeout_milliseconds);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_send_with_reply_obj, 4, mp_dbus_connection_send_with_reply, dbus_connection_send_with_reply);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_connection_send_with_reply_and_block(DBusConnection *connection, DBusMessage *message, int timeout_milliseconds, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_connection_send_with_reply_and_block(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusMessage *message = mp_to_ptr(mp_args[1]);
    int timeout_milliseconds = (int)mp_obj_get_int(mp_args[2]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[3]);
    DBusMessage * res = dbus_connection_send_with_reply_and_block(connection, message, timeout_milliseconds, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_send_with_reply_and_block_obj, 4, mp_dbus_connection_send_with_reply_and_block, dbus_connection_send_with_reply_and_block);

 

/*
 * Function NOT generated:
 * Callback function 'DBusAddWatchFunction add_function' must receive a struct pointer with user_data member as its first argument!
 * DBusAddWatchFunction add_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusRemoveWatchFunction remove_function' must receive a struct pointer with user_data member as its first argument!
 * DBusRemoveWatchFunction remove_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusWatchToggledFunction toggled_function' must receive a struct pointer with user_data member as its first argument!
 * DBusWatchToggledFunction toggled_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_set_watch_functions(DBusConnection *connection, DBusAddWatchFunction add_function, DBusRemoveWatchFunction remove_function, DBusWatchToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_watch_functions(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusAddWatchFunction add_function = mp_to_ptr(mp_args[1]);
    DBusRemoveWatchFunction remove_function = mp_to_ptr(mp_args[2]);
    DBusWatchToggledFunction toggled_function = mp_to_ptr(mp_args[3]);
    void *data = mp_to_ptr(mp_args[4]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[5]);
    dbus_bool_t res = dbus_connection_set_watch_functions(connection, add_function, remove_function, toggled_function, data, free_data_function);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_watch_functions_obj, 6, mp_dbus_connection_set_watch_functions, dbus_connection_set_watch_functions);

 

/*
 * Function NOT generated:
 * Callback function 'DBusAddTimeoutFunction add_function' must receive a struct pointer with user_data member as its first argument!
 * DBusAddTimeoutFunction add_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusRemoveTimeoutFunction remove_function' must receive a struct pointer with user_data member as its first argument!
 * DBusRemoveTimeoutFunction remove_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusTimeoutToggledFunction toggled_function' must receive a struct pointer with user_data member as its first argument!
 * DBusTimeoutToggledFunction toggled_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_set_timeout_functions(DBusConnection *connection, DBusAddTimeoutFunction add_function, DBusRemoveTimeoutFunction remove_function, DBusTimeoutToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_timeout_functions(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusAddTimeoutFunction add_function = mp_to_ptr(mp_args[1]);
    DBusRemoveTimeoutFunction remove_function = mp_to_ptr(mp_args[2]);
    DBusTimeoutToggledFunction toggled_function = mp_to_ptr(mp_args[3]);
    void *data = mp_to_ptr(mp_args[4]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[5]);
    dbus_bool_t res = dbus_connection_set_timeout_functions(connection, add_function, remove_function, toggled_function, data, free_data_function);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_timeout_functions_obj, 6, mp_dbus_connection_set_timeout_functions, dbus_connection_set_timeout_functions);

 

/*
 * Function NOT generated:
 * Callback function 'DBusWakeupMainFunction wakeup_main_function' must receive a struct pointer with user_data member as its first argument!
 * DBusWakeupMainFunction wakeup_main_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * void dbus_connection_set_wakeup_main_function(DBusConnection *connection, DBusWakeupMainFunction wakeup_main_function, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_wakeup_main_function(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusWakeupMainFunction wakeup_main_function = mp_to_ptr(mp_args[1]);
    void *data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[3]);
    dbus_connection_set_wakeup_main_function(connection, wakeup_main_function, data, free_data_function);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_wakeup_main_function_obj, 4, mp_dbus_connection_set_wakeup_main_function, dbus_connection_set_wakeup_main_function);

 

/*
 * Function NOT generated:
 * Callback function 'DBusDispatchStatusFunction function' must receive a struct pointer with user_data member as its first argument!
 * DBusDispatchStatusFunction function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * void dbus_connection_set_dispatch_status_function(DBusConnection *connection, DBusDispatchStatusFunction function, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_dispatch_status_function(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusDispatchStatusFunction function = mp_to_ptr(mp_args[1]);
    void *data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[3]);
    dbus_connection_set_dispatch_status_function(connection, function, data, free_data_function);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_dispatch_status_function_obj, 4, mp_dbus_connection_set_dispatch_status_function, dbus_connection_set_dispatch_status_function);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_get_unix_user(DBusConnection *connection, unsigned long *uid)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_unix_user(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    unsigned long *uid = mp_to_ptr(mp_args[1]);
    dbus_bool_t res = dbus_connection_get_unix_user(connection, uid);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_unix_user_obj, 2, mp_dbus_connection_get_unix_user, dbus_connection_get_unix_user);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_get_unix_process_id(DBusConnection *connection, unsigned long *pid)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_unix_process_id(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    unsigned long *pid = mp_to_ptr(mp_args[1]);
    dbus_bool_t res = dbus_connection_get_unix_process_id(connection, pid);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_unix_process_id_obj, 2, mp_dbus_connection_get_unix_process_id, dbus_connection_get_unix_process_id);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_get_adt_audit_session_data(DBusConnection *connection, void **data, dbus_int32_t *data_size)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_adt_audit_session_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    void **data = mp_to_ptr(mp_args[1]);
    dbus_int32_t *data_size = mp_to_ptr(mp_args[2]);
    dbus_bool_t res = dbus_connection_get_adt_audit_session_data(connection, data, data_size);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_adt_audit_session_data_obj, 3, mp_dbus_connection_get_adt_audit_session_data, dbus_connection_get_adt_audit_session_data);

 

/*
 * Function NOT generated:
 * Callback function 'DBusAllowUnixUserFunction function' must receive a struct pointer with user_data member as its first argument!
 * DBusAllowUnixUserFunction function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * void dbus_connection_set_unix_user_function(DBusConnection *connection, DBusAllowUnixUserFunction function, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_unix_user_function(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusAllowUnixUserFunction function = mp_to_ptr(mp_args[1]);
    void *data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[3]);
    dbus_connection_set_unix_user_function(connection, function, data, free_data_function);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_unix_user_function_obj, 4, mp_dbus_connection_set_unix_user_function, dbus_connection_set_unix_user_function);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_get_windows_user(DBusConnection *connection, char **windows_sid_p)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_windows_user(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    char **windows_sid_p = mp_to_ptr(mp_args[1]);
    dbus_bool_t res = dbus_connection_get_windows_user(connection, windows_sid_p);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_windows_user_obj, 2, mp_dbus_connection_get_windows_user, dbus_connection_get_windows_user);

 

/*
 * Function NOT generated:
 * Callback function 'DBusAllowWindowsUserFunction function' must receive a struct pointer with user_data member as its first argument!
 * DBusAllowWindowsUserFunction function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * void dbus_connection_set_windows_user_function(DBusConnection *connection, DBusAllowWindowsUserFunction function, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_windows_user_function(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusAllowWindowsUserFunction function = mp_to_ptr(mp_args[1]);
    void *data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[3]);
    dbus_connection_set_windows_user_function(connection, function, data, free_data_function);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_windows_user_function_obj, 4, mp_dbus_connection_set_windows_user_function, dbus_connection_set_windows_user_function);

 

/*
 * dbus extension definition for:
 * void dbus_connection_set_allow_anonymous(DBusConnection *connection, dbus_bool_t value)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_allow_anonymous(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_bool_t value = (unsigned int)mp_obj_get_int(mp_args[1]);
    dbus_connection_set_allow_anonymous(connection, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_allow_anonymous_obj, 2, mp_dbus_connection_set_allow_anonymous, dbus_connection_set_allow_anonymous);

 

/*
 * dbus extension definition for:
 * void dbus_connection_set_route_peer_messages(DBusConnection *connection, dbus_bool_t value)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_route_peer_messages(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_bool_t value = (unsigned int)mp_obj_get_int(mp_args[1]);
    dbus_connection_set_route_peer_messages(connection, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_route_peer_messages_obj, 2, mp_dbus_connection_set_route_peer_messages, dbus_connection_set_route_peer_messages);

 

/*
 * Function NOT generated:
 * Callback function 'DBusHandleMessageFunction function' must receive a struct pointer with user_data member as its first argument!
 * DBusHandleMessageFunction function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_add_filter(DBusConnection *connection, DBusHandleMessageFunction function, void *user_data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_connection_add_filter(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusHandleMessageFunction function = mp_to_ptr(mp_args[1]);
    void *user_data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[3]);
    dbus_bool_t res = dbus_connection_add_filter(connection, function, user_data, free_data_function);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_add_filter_obj, 4, mp_dbus_connection_add_filter, dbus_connection_add_filter);

 

/*
 * Function NOT generated:
 * Callback function 'DBusHandleMessageFunction function' must receive a struct pointer with user_data member as its first argument!
 * DBusHandleMessageFunction function
 */
    

/*
 * dbus extension definition for:
 * void dbus_connection_remove_filter(DBusConnection *connection, DBusHandleMessageFunction function, void *user_data)
 */
 
STATIC mp_obj_t mp_dbus_connection_remove_filter(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusHandleMessageFunction function = mp_to_ptr(mp_args[1]);
    void *user_data = mp_to_ptr(mp_args[2]);
    dbus_connection_remove_filter(connection, function, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_remove_filter_obj, 3, mp_dbus_connection_remove_filter, dbus_connection_remove_filter);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_allocate_data_slot(dbus_int32_t *slot_p)
 */
 
STATIC mp_obj_t mp_dbus_connection_allocate_data_slot(size_t mp_n_args, const mp_obj_t *mp_args)
{
    dbus_int32_t *slot_p = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_connection_allocate_data_slot(slot_p);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_allocate_data_slot_obj, 1, mp_dbus_connection_allocate_data_slot, dbus_connection_allocate_data_slot);

 

/*
 * dbus extension definition for:
 * void dbus_connection_free_data_slot(dbus_int32_t *slot_p)
 */
 
STATIC mp_obj_t mp_dbus_connection_free_data_slot(size_t mp_n_args, const mp_obj_t *mp_args)
{
    dbus_int32_t *slot_p = mp_to_ptr(mp_args[0]);
    dbus_connection_free_data_slot(slot_p);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_free_data_slot_obj, 1, mp_dbus_connection_free_data_slot, dbus_connection_free_data_slot);

 

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_func' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_func
 */
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_set_data(DBusConnection *connection, dbus_int32_t slot, void *data, DBusFreeFunction free_data_func)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_int32_t slot = (int)mp_obj_get_int(mp_args[1]);
    void *data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_data_func = mp_to_ptr(mp_args[3]);
    dbus_bool_t res = dbus_connection_set_data(connection, slot, data, free_data_func);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_data_obj, 4, mp_dbus_connection_set_data, dbus_connection_set_data);

 

/*
 * dbus extension definition for:
 * void *dbus_connection_get_data(DBusConnection *connection, dbus_int32_t slot)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    dbus_int32_t slot = (int)mp_obj_get_int(mp_args[1]);
    void * res = dbus_connection_get_data(connection, slot);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_data_obj, 2, mp_dbus_connection_get_data, dbus_connection_get_data);

 

/*
 * dbus extension definition for:
 * void dbus_connection_set_change_sigpipe(dbus_bool_t will_modify_sigpipe)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_change_sigpipe(size_t mp_n_args, const mp_obj_t *mp_args)
{
    dbus_bool_t will_modify_sigpipe = (unsigned int)mp_obj_get_int(mp_args[0]);
    dbus_connection_set_change_sigpipe(will_modify_sigpipe);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_change_sigpipe_obj, 1, mp_dbus_connection_set_change_sigpipe, dbus_connection_set_change_sigpipe);

 

/*
 * dbus extension definition for:
 * void dbus_connection_set_max_message_size(DBusConnection *connection, long size)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_max_message_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    long size = (long)mp_obj_get_int(mp_args[1]);
    dbus_connection_set_max_message_size(connection, size);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_max_message_size_obj, 2, mp_dbus_connection_set_max_message_size, dbus_connection_set_max_message_size);

 

/*
 * dbus extension definition for:
 * long dbus_connection_get_max_message_size(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_max_message_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    long res = dbus_connection_get_max_message_size(connection);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_max_message_size_obj, 1, mp_dbus_connection_get_max_message_size, dbus_connection_get_max_message_size);

 

/*
 * dbus extension definition for:
 * void dbus_connection_set_max_received_size(DBusConnection *connection, long size)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_max_received_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    long size = (long)mp_obj_get_int(mp_args[1]);
    dbus_connection_set_max_received_size(connection, size);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_max_received_size_obj, 2, mp_dbus_connection_set_max_received_size, dbus_connection_set_max_received_size);

 

/*
 * dbus extension definition for:
 * long dbus_connection_get_max_received_size(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_max_received_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    long res = dbus_connection_get_max_received_size(connection);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_max_received_size_obj, 1, mp_dbus_connection_get_max_received_size, dbus_connection_get_max_received_size);

 

/*
 * dbus extension definition for:
 * void dbus_connection_set_max_message_unix_fds(DBusConnection *connection, long n)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_max_message_unix_fds(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    long n = (long)mp_obj_get_int(mp_args[1]);
    dbus_connection_set_max_message_unix_fds(connection, n);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_max_message_unix_fds_obj, 2, mp_dbus_connection_set_max_message_unix_fds, dbus_connection_set_max_message_unix_fds);

 

/*
 * dbus extension definition for:
 * long dbus_connection_get_max_message_unix_fds(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_max_message_unix_fds(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    long res = dbus_connection_get_max_message_unix_fds(connection);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_max_message_unix_fds_obj, 1, mp_dbus_connection_get_max_message_unix_fds, dbus_connection_get_max_message_unix_fds);

 

/*
 * dbus extension definition for:
 * void dbus_connection_set_max_received_unix_fds(DBusConnection *connection, long n)
 */
 
STATIC mp_obj_t mp_dbus_connection_set_max_received_unix_fds(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    long n = (long)mp_obj_get_int(mp_args[1]);
    dbus_connection_set_max_received_unix_fds(connection, n);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_set_max_received_unix_fds_obj, 2, mp_dbus_connection_set_max_received_unix_fds, dbus_connection_set_max_received_unix_fds);

 

/*
 * dbus extension definition for:
 * long dbus_connection_get_max_received_unix_fds(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_max_received_unix_fds(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    long res = dbus_connection_get_max_received_unix_fds(connection);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_max_received_unix_fds_obj, 1, mp_dbus_connection_get_max_received_unix_fds, dbus_connection_get_max_received_unix_fds);

 

/*
 * dbus extension definition for:
 * long dbus_connection_get_outgoing_size(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_outgoing_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    long res = dbus_connection_get_outgoing_size(connection);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_outgoing_size_obj, 1, mp_dbus_connection_get_outgoing_size, dbus_connection_get_outgoing_size);

 

/*
 * dbus extension definition for:
 * long dbus_connection_get_outgoing_unix_fds(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_outgoing_unix_fds(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    long res = dbus_connection_get_outgoing_unix_fds(connection);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_outgoing_unix_fds_obj, 1, mp_dbus_connection_get_outgoing_unix_fds, dbus_connection_get_outgoing_unix_fds);

 

/*
 * dbus extension definition for:
 * DBusPreallocatedSend *dbus_connection_preallocate_send(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_connection_preallocate_send(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusPreallocatedSend * res = dbus_connection_preallocate_send(connection);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_preallocate_send_obj, 1, mp_dbus_connection_preallocate_send, dbus_connection_preallocate_send);

 

/*
 * dbus extension definition for:
 * void dbus_connection_free_preallocated_send(DBusConnection *connection, DBusPreallocatedSend *preallocated)
 */
 
STATIC mp_obj_t mp_dbus_connection_free_preallocated_send(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusPreallocatedSend *preallocated = mp_to_ptr(mp_args[1]);
    dbus_connection_free_preallocated_send(connection, preallocated);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_free_preallocated_send_obj, 2, mp_dbus_connection_free_preallocated_send, dbus_connection_free_preallocated_send);

 

/*
 * dbus extension definition for:
 * void dbus_connection_send_preallocated(DBusConnection *connection, DBusPreallocatedSend *preallocated, DBusMessage *message, dbus_uint32_t *client_serial)
 */
 
STATIC mp_obj_t mp_dbus_connection_send_preallocated(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusPreallocatedSend *preallocated = mp_to_ptr(mp_args[1]);
    DBusMessage *message = mp_to_ptr(mp_args[2]);
    dbus_uint32_t *client_serial = mp_to_ptr(mp_args[3]);
    dbus_connection_send_preallocated(connection, preallocated, message, client_serial);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_send_preallocated_obj, 4, mp_dbus_connection_send_preallocated, dbus_connection_send_preallocated);

 

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusObjectPathVTable_unregister_function_callback'
 * DBusObjectPathUnregisterFunction unregister_function
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusObjectPathVTable_message_function_callback'
 * DBusObjectPathMessageFunction message_function
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusObjectPathVTable_dbus_internal_pad1_callback'
 * void (*dbus_internal_pad1)(void *)
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusObjectPathVTable_dbus_internal_pad2_callback'
 * void (*dbus_internal_pad2)(void *)
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusObjectPathVTable_dbus_internal_pad3_callback'
 * void (*dbus_internal_pad3)(void *)
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusObjectPathVTable_dbus_internal_pad4_callback'
 * void (*dbus_internal_pad4)(void *)
 */
    

/*
 * Struct DBusObjectPathVTable
 */

STATIC inline const mp_obj_type_t *get_mp_DBusObjectPathVTable_type();

STATIC inline DBusObjectPathVTable* mp_write_ptr_DBusObjectPathVTable(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_DBusObjectPathVTable_type()));
    return (DBusObjectPathVTable*)self->data;
}

#define mp_write_DBusObjectPathVTable(struct_obj) *mp_write_ptr_DBusObjectPathVTable(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_DBusObjectPathVTable(DBusObjectPathVTable *field)
{
    return lv_to_mp_struct(get_mp_DBusObjectPathVTable_type(), (void*)field);
}

#define mp_read_DBusObjectPathVTable(field) mp_read_ptr_DBusObjectPathVTable(copy_buffer(&field, sizeof(DBusObjectPathVTable)))
#define mp_read_byref_DBusObjectPathVTable(field) mp_read_ptr_DBusObjectPathVTable(&field)

STATIC void mp_DBusObjectPathVTable_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    DBusObjectPathVTable *data = (DBusObjectPathVTable*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_unregister_function: dest[0] = ptr_to_mp(data->unregister_function); break; // converting from callback DBusObjectPathUnregisterFunction;
            case MP_QSTR_message_function: dest[0] = ptr_to_mp(data->message_function); break; // converting from callback DBusObjectPathMessageFunction;
            case MP_QSTR_dbus_internal_pad1: dest[0] = ptr_to_mp((void*)data->dbus_internal_pad1); break; // converting from callback void (*)(void *);
            case MP_QSTR_dbus_internal_pad2: dest[0] = ptr_to_mp((void*)data->dbus_internal_pad2); break; // converting from callback void (*)(void *);
            case MP_QSTR_dbus_internal_pad3: dest[0] = ptr_to_mp((void*)data->dbus_internal_pad3); break; // converting from callback void (*)(void *);
            case MP_QSTR_dbus_internal_pad4: dest[0] = ptr_to_mp((void*)data->dbus_internal_pad4); break; // converting from callback void (*)(void *);
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_unregister_function: data->unregister_function = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusObjectPathVTable_unregister_function, NULL); break; // converting to callback DBusObjectPathUnregisterFunction;
                case MP_QSTR_message_function: data->message_function = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusObjectPathVTable_message_function, NULL); break; // converting to callback DBusObjectPathMessageFunction;
                case MP_QSTR_dbus_internal_pad1: data->dbus_internal_pad1 = (void*)mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusObjectPathVTable_dbus_internal_pad1, NULL); break; // converting to callback void (*)(void *);
                case MP_QSTR_dbus_internal_pad2: data->dbus_internal_pad2 = (void*)mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusObjectPathVTable_dbus_internal_pad2, NULL); break; // converting to callback void (*)(void *);
                case MP_QSTR_dbus_internal_pad3: data->dbus_internal_pad3 = (void*)mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusObjectPathVTable_dbus_internal_pad3, NULL); break; // converting to callback void (*)(void *);
                case MP_QSTR_dbus_internal_pad4: data->dbus_internal_pad4 = (void*)mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusObjectPathVTable_dbus_internal_pad4, NULL); break; // converting to callback void (*)(void *);
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_DBusObjectPathVTable_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct DBusObjectPathVTable");
}

STATIC const mp_rom_map_elem_t mp_DBusObjectPathVTable_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(DBusObjectPathVTable))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_DBusObjectPathVTable_locals_dict, mp_DBusObjectPathVTable_locals_dict_table);

STATIC const mp_obj_type_t mp_DBusObjectPathVTable_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBusObjectPathVTable,
    .print = mp_DBusObjectPathVTable_print,
    .make_new = make_new_lv_struct,
    .attr = mp_DBusObjectPathVTable_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_DBusObjectPathVTable_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_DBusObjectPathVTable_type()
{
    return &mp_DBusObjectPathVTable_type;
}
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_try_register_object_path(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_connection_try_register_object_path(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[1]);
    const DBusObjectPathVTable *vtable = mp_write_ptr_DBusObjectPathVTable(mp_args[2]);
    void *user_data = mp_to_ptr(mp_args[3]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[4]);
    dbus_bool_t res = dbus_connection_try_register_object_path(connection, path, vtable, user_data, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_try_register_object_path_obj, 5, mp_dbus_connection_try_register_object_path, dbus_connection_try_register_object_path);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_register_object_path(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data)
 */
 
STATIC mp_obj_t mp_dbus_connection_register_object_path(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[1]);
    const DBusObjectPathVTable *vtable = mp_write_ptr_DBusObjectPathVTable(mp_args[2]);
    void *user_data = mp_to_ptr(mp_args[3]);
    dbus_bool_t res = dbus_connection_register_object_path(connection, path, vtable, user_data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_register_object_path_obj, 4, mp_dbus_connection_register_object_path, dbus_connection_register_object_path);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_try_register_fallback(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_connection_try_register_fallback(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[1]);
    const DBusObjectPathVTable *vtable = mp_write_ptr_DBusObjectPathVTable(mp_args[2]);
    void *user_data = mp_to_ptr(mp_args[3]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[4]);
    dbus_bool_t res = dbus_connection_try_register_fallback(connection, path, vtable, user_data, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_try_register_fallback_obj, 5, mp_dbus_connection_try_register_fallback, dbus_connection_try_register_fallback);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_register_fallback(DBusConnection *connection, const char *path, const DBusObjectPathVTable *vtable, void *user_data)
 */
 
STATIC mp_obj_t mp_dbus_connection_register_fallback(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[1]);
    const DBusObjectPathVTable *vtable = mp_write_ptr_DBusObjectPathVTable(mp_args[2]);
    void *user_data = mp_to_ptr(mp_args[3]);
    dbus_bool_t res = dbus_connection_register_fallback(connection, path, vtable, user_data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_register_fallback_obj, 4, mp_dbus_connection_register_fallback, dbus_connection_register_fallback);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_unregister_object_path(DBusConnection *connection, const char *path)
 */
 
STATIC mp_obj_t mp_dbus_connection_unregister_object_path(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_connection_unregister_object_path(connection, path);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_unregister_object_path_obj, 2, mp_dbus_connection_unregister_object_path, dbus_connection_unregister_object_path);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_get_object_path_data(DBusConnection *connection, const char *path, void **data_p)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_object_path_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *path = (char*)mp_obj_str_get_str(mp_args[1]);
    void **data_p = mp_to_ptr(mp_args[2]);
    dbus_bool_t res = dbus_connection_get_object_path_data(connection, path, data_p);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_object_path_data_obj, 3, mp_dbus_connection_get_object_path_data, dbus_connection_get_object_path_data);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_list_registered(DBusConnection *connection, const char *parent_path, char ***child_entries)
 */
 
STATIC mp_obj_t mp_dbus_connection_list_registered(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *parent_path = (char*)mp_obj_str_get_str(mp_args[1]);
    char ***child_entries = mp_to_ptr(mp_args[2]);
    dbus_bool_t res = dbus_connection_list_registered(connection, parent_path, child_entries);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_list_registered_obj, 3, mp_dbus_connection_list_registered, dbus_connection_list_registered);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_get_unix_fd(DBusConnection *connection, int *fd)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_unix_fd(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    int *fd = mp_to_ptr(mp_args[1]);
    dbus_bool_t res = dbus_connection_get_unix_fd(connection, fd);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_unix_fd_obj, 2, mp_dbus_connection_get_unix_fd, dbus_connection_get_unix_fd);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_connection_get_socket(DBusConnection *connection, int *fd)
 */
 
STATIC mp_obj_t mp_dbus_connection_get_socket(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    int *fd = mp_to_ptr(mp_args[1]);
    dbus_bool_t res = dbus_connection_get_socket(connection, fd);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_connection_get_socket_obj, 2, mp_dbus_connection_get_socket, dbus_connection_get_socket);

 

/*
 * dbus extension definition for:
 * int dbus_watch_get_fd(DBusWatch *watch)
 */
 
STATIC mp_obj_t mp_dbus_watch_get_fd(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusWatch *watch = mp_to_ptr(mp_args[0]);
    int res = dbus_watch_get_fd(watch);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_watch_get_fd_obj, 1, mp_dbus_watch_get_fd, dbus_watch_get_fd);

 

/*
 * dbus extension definition for:
 * int dbus_watch_get_unix_fd(DBusWatch *watch)
 */
 
STATIC mp_obj_t mp_dbus_watch_get_unix_fd(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusWatch *watch = mp_to_ptr(mp_args[0]);
    int res = dbus_watch_get_unix_fd(watch);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_watch_get_unix_fd_obj, 1, mp_dbus_watch_get_unix_fd, dbus_watch_get_unix_fd);

 

/*
 * dbus extension definition for:
 * int dbus_watch_get_socket(DBusWatch *watch)
 */
 
STATIC mp_obj_t mp_dbus_watch_get_socket(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusWatch *watch = mp_to_ptr(mp_args[0]);
    int res = dbus_watch_get_socket(watch);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_watch_get_socket_obj, 1, mp_dbus_watch_get_socket, dbus_watch_get_socket);

 

/*
 * dbus extension definition for:
 * unsigned int dbus_watch_get_flags(DBusWatch *watch)
 */
 
STATIC mp_obj_t mp_dbus_watch_get_flags(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusWatch *watch = mp_to_ptr(mp_args[0]);
    unsigned int res = dbus_watch_get_flags(watch);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_watch_get_flags_obj, 1, mp_dbus_watch_get_flags, dbus_watch_get_flags);

 

/*
 * dbus extension definition for:
 * void *dbus_watch_get_data(DBusWatch *watch)
 */
 
STATIC mp_obj_t mp_dbus_watch_get_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusWatch *watch = mp_to_ptr(mp_args[0]);
    void * res = dbus_watch_get_data(watch);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_watch_get_data_obj, 1, mp_dbus_watch_get_data, dbus_watch_get_data);

 

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * void dbus_watch_set_data(DBusWatch *watch, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_watch_set_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusWatch *watch = mp_to_ptr(mp_args[0]);
    void *data = mp_to_ptr(mp_args[1]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[2]);
    dbus_watch_set_data(watch, data, free_data_function);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_watch_set_data_obj, 3, mp_dbus_watch_set_data, dbus_watch_set_data);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_watch_handle(DBusWatch *watch, unsigned int flags)
 */
 
STATIC mp_obj_t mp_dbus_watch_handle(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusWatch *watch = mp_to_ptr(mp_args[0]);
    unsigned int flags = (unsigned int)mp_obj_get_int(mp_args[1]);
    dbus_bool_t res = dbus_watch_handle(watch, flags);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_watch_handle_obj, 2, mp_dbus_watch_handle, dbus_watch_handle);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_watch_get_enabled(DBusWatch *watch)
 */
 
STATIC mp_obj_t mp_dbus_watch_get_enabled(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusWatch *watch = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_watch_get_enabled(watch);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_watch_get_enabled_obj, 1, mp_dbus_watch_get_enabled, dbus_watch_get_enabled);

 

/*
 * dbus extension definition for:
 * int dbus_timeout_get_interval(DBusTimeout *timeout)
 */
 
STATIC mp_obj_t mp_dbus_timeout_get_interval(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusTimeout *timeout = mp_to_ptr(mp_args[0]);
    int res = dbus_timeout_get_interval(timeout);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_timeout_get_interval_obj, 1, mp_dbus_timeout_get_interval, dbus_timeout_get_interval);

 

/*
 * dbus extension definition for:
 * void *dbus_timeout_get_data(DBusTimeout *timeout)
 */
 
STATIC mp_obj_t mp_dbus_timeout_get_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusTimeout *timeout = mp_to_ptr(mp_args[0]);
    void * res = dbus_timeout_get_data(timeout);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_timeout_get_data_obj, 1, mp_dbus_timeout_get_data, dbus_timeout_get_data);

 

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * void dbus_timeout_set_data(DBusTimeout *timeout, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_timeout_set_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusTimeout *timeout = mp_to_ptr(mp_args[0]);
    void *data = mp_to_ptr(mp_args[1]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[2]);
    dbus_timeout_set_data(timeout, data, free_data_function);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_timeout_set_data_obj, 3, mp_dbus_timeout_set_data, dbus_timeout_set_data);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_timeout_handle(DBusTimeout *timeout)
 */
 
STATIC mp_obj_t mp_dbus_timeout_handle(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusTimeout *timeout = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_timeout_handle(timeout);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_timeout_handle_obj, 1, mp_dbus_timeout_handle, dbus_timeout_handle);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_timeout_get_enabled(DBusTimeout *timeout)
 */
 
STATIC mp_obj_t mp_dbus_timeout_get_enabled(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusTimeout *timeout = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_timeout_get_enabled(timeout);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_timeout_get_enabled_obj, 1, mp_dbus_timeout_get_enabled, dbus_timeout_get_enabled);

 

/*
 * dbus extension definition for:
 * DBusConnection *dbus_bus_get(DBusBusType type, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_get(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusBusType type = (int)mp_obj_get_int(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    DBusConnection * res = dbus_bus_get(type, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_get_obj, 2, mp_dbus_bus_get, dbus_bus_get);

 

/*
 * dbus extension definition for:
 * DBusConnection *dbus_bus_get_private(DBusBusType type, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_get_private(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusBusType type = (int)mp_obj_get_int(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    DBusConnection * res = dbus_bus_get_private(type, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_get_private_obj, 2, mp_dbus_bus_get_private, dbus_bus_get_private);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_bus_register(DBusConnection *connection, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_register(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    dbus_bool_t res = dbus_bus_register(connection, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_register_obj, 2, mp_dbus_bus_register, dbus_bus_register);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_bus_set_unique_name(DBusConnection *connection, const char *unique_name)
 */
 
STATIC mp_obj_t mp_dbus_bus_set_unique_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *unique_name = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_bus_set_unique_name(connection, unique_name);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_set_unique_name_obj, 2, mp_dbus_bus_set_unique_name, dbus_bus_set_unique_name);

 

/*
 * dbus extension definition for:
 * const char *dbus_bus_get_unique_name(DBusConnection *connection)
 */
 
STATIC mp_obj_t mp_dbus_bus_get_unique_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char * res = dbus_bus_get_unique_name(connection);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_get_unique_name_obj, 1, mp_dbus_bus_get_unique_name, dbus_bus_get_unique_name);

 

/*
 * dbus extension definition for:
 * unsigned long dbus_bus_get_unix_user(DBusConnection *connection, const char *name, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_get_unix_user(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[2]);
    unsigned long res = dbus_bus_get_unix_user(connection, name, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_get_unix_user_obj, 3, mp_dbus_bus_get_unix_user, dbus_bus_get_unix_user);

 

/*
 * dbus extension definition for:
 * char *dbus_bus_get_id(DBusConnection *connection, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_get_id(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    char * res = dbus_bus_get_id(connection, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_get_id_obj, 2, mp_dbus_bus_get_id, dbus_bus_get_id);

 

/*
 * dbus extension definition for:
 * int dbus_bus_request_name(DBusConnection *connection, const char *name, unsigned int flags, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_request_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    unsigned int flags = (unsigned int)mp_obj_get_int(mp_args[2]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[3]);
    int res = dbus_bus_request_name(connection, name, flags, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_request_name_obj, 4, mp_dbus_bus_request_name, dbus_bus_request_name);

 

/*
 * dbus extension definition for:
 * int dbus_bus_release_name(DBusConnection *connection, const char *name, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_release_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[2]);
    int res = dbus_bus_release_name(connection, name, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_release_name_obj, 3, mp_dbus_bus_release_name, dbus_bus_release_name);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_bus_name_has_owner(DBusConnection *connection, const char *name, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_name_has_owner(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[2]);
    dbus_bool_t res = dbus_bus_name_has_owner(connection, name, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_name_has_owner_obj, 3, mp_dbus_bus_name_has_owner, dbus_bus_name_has_owner);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_bus_start_service_by_name(DBusConnection *connection, const char *name, dbus_uint32_t flags, dbus_uint32_t *reply, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_start_service_by_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_uint32_t flags = (unsigned int)mp_obj_get_int(mp_args[2]);
    dbus_uint32_t *reply = mp_to_ptr(mp_args[3]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[4]);
    dbus_bool_t res = dbus_bus_start_service_by_name(connection, name, flags, reply, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_start_service_by_name_obj, 5, mp_dbus_bus_start_service_by_name, dbus_bus_start_service_by_name);

 

/*
 * dbus extension definition for:
 * void dbus_bus_add_match(DBusConnection *connection, const char *rule, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_add_match(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *rule = (char*)mp_obj_str_get_str(mp_args[1]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[2]);
    dbus_bus_add_match(connection, rule, error);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_add_match_obj, 3, mp_dbus_bus_add_match, dbus_bus_add_match);

 

/*
 * dbus extension definition for:
 * void dbus_bus_remove_match(DBusConnection *connection, const char *rule, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_bus_remove_match(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusConnection *connection = mp_to_ptr(mp_args[0]);
    const char *rule = (char*)mp_obj_str_get_str(mp_args[1]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[2]);
    dbus_bus_remove_match(connection, rule, error);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_bus_remove_match_obj, 3, mp_dbus_bus_remove_match, dbus_bus_remove_match);

 

/*
 * dbus extension definition for:
 * char *dbus_get_local_machine_id(void)
 */
 
STATIC mp_obj_t mp_dbus_get_local_machine_id(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    char * res = dbus_get_local_machine_id();
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_get_local_machine_id_obj, 0, mp_dbus_get_local_machine_id, dbus_get_local_machine_id);

 

/*
 * dbus extension definition for:
 * void dbus_get_version(int *major_version_p, int *minor_version_p, int *micro_version_p)
 */
 
STATIC mp_obj_t mp_dbus_get_version(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int *major_version_p = mp_to_ptr(mp_args[0]);
    int *minor_version_p = mp_to_ptr(mp_args[1]);
    int *micro_version_p = mp_to_ptr(mp_args[2]);
    dbus_get_version(major_version_p, minor_version_p, micro_version_p);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_get_version_obj, 3, mp_dbus_get_version, dbus_get_version);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_setenv(const char *variable, const char *value)
 */
 
STATIC mp_obj_t mp_dbus_setenv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *variable = (char*)mp_obj_str_get_str(mp_args[0]);
    const char *value = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_bool_t res = dbus_setenv(variable, value);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_setenv_obj, 2, mp_dbus_setenv, dbus_setenv);

 

/*
 * dbus extension definition for:
 * DBusPendingCall *dbus_pending_call_ref(DBusPendingCall *pending)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusPendingCall *pending = mp_to_ptr(mp_args[0]);
    DBusPendingCall * res = dbus_pending_call_ref(pending);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_ref_obj, 1, mp_dbus_pending_call_ref, dbus_pending_call_ref);

 

/*
 * dbus extension definition for:
 * void dbus_pending_call_unref(DBusPendingCall *pending)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusPendingCall *pending = mp_to_ptr(mp_args[0]);
    dbus_pending_call_unref(pending);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_unref_obj, 1, mp_dbus_pending_call_unref, dbus_pending_call_unref);

 

/*
 * Function NOT generated:
 * Callback function 'DBusPendingCallNotifyFunction function' must receive a struct pointer with user_data member as its first argument!
 * DBusPendingCallNotifyFunction function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_user_data' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_user_data
 */
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_pending_call_set_notify(DBusPendingCall *pending, DBusPendingCallNotifyFunction function, void *user_data, DBusFreeFunction free_user_data)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_set_notify(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusPendingCall *pending = mp_to_ptr(mp_args[0]);
    DBusPendingCallNotifyFunction function = mp_to_ptr(mp_args[1]);
    void *user_data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_user_data = mp_to_ptr(mp_args[3]);
    dbus_bool_t res = dbus_pending_call_set_notify(pending, function, user_data, free_user_data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_set_notify_obj, 4, mp_dbus_pending_call_set_notify, dbus_pending_call_set_notify);

 

/*
 * dbus extension definition for:
 * void dbus_pending_call_cancel(DBusPendingCall *pending)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_cancel(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusPendingCall *pending = mp_to_ptr(mp_args[0]);
    dbus_pending_call_cancel(pending);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_cancel_obj, 1, mp_dbus_pending_call_cancel, dbus_pending_call_cancel);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_pending_call_get_completed(DBusPendingCall *pending)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_get_completed(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusPendingCall *pending = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_pending_call_get_completed(pending);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_get_completed_obj, 1, mp_dbus_pending_call_get_completed, dbus_pending_call_get_completed);

 

/*
 * dbus extension definition for:
 * DBusMessage *dbus_pending_call_steal_reply(DBusPendingCall *pending)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_steal_reply(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusPendingCall *pending = mp_to_ptr(mp_args[0]);
    DBusMessage * res = dbus_pending_call_steal_reply(pending);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_steal_reply_obj, 1, mp_dbus_pending_call_steal_reply, dbus_pending_call_steal_reply);

 

/*
 * dbus extension definition for:
 * void dbus_pending_call_block(DBusPendingCall *pending)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_block(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusPendingCall *pending = mp_to_ptr(mp_args[0]);
    dbus_pending_call_block(pending);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_block_obj, 1, mp_dbus_pending_call_block, dbus_pending_call_block);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_pending_call_allocate_data_slot(dbus_int32_t *slot_p)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_allocate_data_slot(size_t mp_n_args, const mp_obj_t *mp_args)
{
    dbus_int32_t *slot_p = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_pending_call_allocate_data_slot(slot_p);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_allocate_data_slot_obj, 1, mp_dbus_pending_call_allocate_data_slot, dbus_pending_call_allocate_data_slot);

 

/*
 * dbus extension definition for:
 * void dbus_pending_call_free_data_slot(dbus_int32_t *slot_p)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_free_data_slot(size_t mp_n_args, const mp_obj_t *mp_args)
{
    dbus_int32_t *slot_p = mp_to_ptr(mp_args[0]);
    dbus_pending_call_free_data_slot(slot_p);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_free_data_slot_obj, 1, mp_dbus_pending_call_free_data_slot, dbus_pending_call_free_data_slot);

 

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_func' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_func
 */
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_pending_call_set_data(DBusPendingCall *pending, dbus_int32_t slot, void *data, DBusFreeFunction free_data_func)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_set_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusPendingCall *pending = mp_to_ptr(mp_args[0]);
    dbus_int32_t slot = (int)mp_obj_get_int(mp_args[1]);
    void *data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_data_func = mp_to_ptr(mp_args[3]);
    dbus_bool_t res = dbus_pending_call_set_data(pending, slot, data, free_data_func);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_set_data_obj, 4, mp_dbus_pending_call_set_data, dbus_pending_call_set_data);

 

/*
 * dbus extension definition for:
 * void *dbus_pending_call_get_data(DBusPendingCall *pending, dbus_int32_t slot)
 */
 
STATIC mp_obj_t mp_dbus_pending_call_get_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusPendingCall *pending = mp_to_ptr(mp_args[0]);
    dbus_int32_t slot = (int)mp_obj_get_int(mp_args[1]);
    void * res = dbus_pending_call_get_data(pending, slot);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_pending_call_get_data_obj, 2, mp_dbus_pending_call_get_data, dbus_pending_call_get_data);

 

/*
 * dbus extension definition for:
 * DBusServer *dbus_server_listen(const char *address, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_server_listen(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *address = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    DBusServer * res = dbus_server_listen(address, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_listen_obj, 2, mp_dbus_server_listen, dbus_server_listen);

 

/*
 * dbus extension definition for:
 * DBusServer *dbus_server_ref(DBusServer *server)
 */
 
STATIC mp_obj_t mp_dbus_server_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    DBusServer * res = dbus_server_ref(server);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_ref_obj, 1, mp_dbus_server_ref, dbus_server_ref);

 

/*
 * dbus extension definition for:
 * void dbus_server_unref(DBusServer *server)
 */
 
STATIC mp_obj_t mp_dbus_server_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    dbus_server_unref(server);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_unref_obj, 1, mp_dbus_server_unref, dbus_server_unref);

 

/*
 * dbus extension definition for:
 * void dbus_server_disconnect(DBusServer *server)
 */
 
STATIC mp_obj_t mp_dbus_server_disconnect(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    dbus_server_disconnect(server);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_disconnect_obj, 1, mp_dbus_server_disconnect, dbus_server_disconnect);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_server_get_is_connected(DBusServer *server)
 */
 
STATIC mp_obj_t mp_dbus_server_get_is_connected(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_server_get_is_connected(server);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_get_is_connected_obj, 1, mp_dbus_server_get_is_connected, dbus_server_get_is_connected);

 

/*
 * dbus extension definition for:
 * char *dbus_server_get_address(DBusServer *server)
 */
 
STATIC mp_obj_t mp_dbus_server_get_address(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    char * res = dbus_server_get_address(server);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_get_address_obj, 1, mp_dbus_server_get_address, dbus_server_get_address);

 

/*
 * dbus extension definition for:
 * char *dbus_server_get_id(DBusServer *server)
 */
 
STATIC mp_obj_t mp_dbus_server_get_id(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    char * res = dbus_server_get_id(server);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_get_id_obj, 1, mp_dbus_server_get_id, dbus_server_get_id);

 

/*
 * Function NOT generated:
 * Callback function 'DBusNewConnectionFunction function' must receive a struct pointer with user_data member as its first argument!
 * DBusNewConnectionFunction function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * void dbus_server_set_new_connection_function(DBusServer *server, DBusNewConnectionFunction function, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_server_set_new_connection_function(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    DBusNewConnectionFunction function = mp_to_ptr(mp_args[1]);
    void *data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[3]);
    dbus_server_set_new_connection_function(server, function, data, free_data_function);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_set_new_connection_function_obj, 4, mp_dbus_server_set_new_connection_function, dbus_server_set_new_connection_function);

 

/*
 * Function NOT generated:
 * Callback function 'DBusAddWatchFunction add_function' must receive a struct pointer with user_data member as its first argument!
 * DBusAddWatchFunction add_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusRemoveWatchFunction remove_function' must receive a struct pointer with user_data member as its first argument!
 * DBusRemoveWatchFunction remove_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusWatchToggledFunction toggled_function' must receive a struct pointer with user_data member as its first argument!
 * DBusWatchToggledFunction toggled_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_server_set_watch_functions(DBusServer *server, DBusAddWatchFunction add_function, DBusRemoveWatchFunction remove_function, DBusWatchToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_server_set_watch_functions(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    DBusAddWatchFunction add_function = mp_to_ptr(mp_args[1]);
    DBusRemoveWatchFunction remove_function = mp_to_ptr(mp_args[2]);
    DBusWatchToggledFunction toggled_function = mp_to_ptr(mp_args[3]);
    void *data = mp_to_ptr(mp_args[4]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[5]);
    dbus_bool_t res = dbus_server_set_watch_functions(server, add_function, remove_function, toggled_function, data, free_data_function);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_set_watch_functions_obj, 6, mp_dbus_server_set_watch_functions, dbus_server_set_watch_functions);

 

/*
 * Function NOT generated:
 * Callback function 'DBusAddTimeoutFunction add_function' must receive a struct pointer with user_data member as its first argument!
 * DBusAddTimeoutFunction add_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusRemoveTimeoutFunction remove_function' must receive a struct pointer with user_data member as its first argument!
 * DBusRemoveTimeoutFunction remove_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusTimeoutToggledFunction toggled_function' must receive a struct pointer with user_data member as its first argument!
 * DBusTimeoutToggledFunction toggled_function
 */
    

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_function' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_function
 */
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_server_set_timeout_functions(DBusServer *server, DBusAddTimeoutFunction add_function, DBusRemoveTimeoutFunction remove_function, DBusTimeoutToggledFunction toggled_function, void *data, DBusFreeFunction free_data_function)
 */
 
STATIC mp_obj_t mp_dbus_server_set_timeout_functions(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    DBusAddTimeoutFunction add_function = mp_to_ptr(mp_args[1]);
    DBusRemoveTimeoutFunction remove_function = mp_to_ptr(mp_args[2]);
    DBusTimeoutToggledFunction toggled_function = mp_to_ptr(mp_args[3]);
    void *data = mp_to_ptr(mp_args[4]);
    DBusFreeFunction free_data_function = mp_to_ptr(mp_args[5]);
    dbus_bool_t res = dbus_server_set_timeout_functions(server, add_function, remove_function, toggled_function, data, free_data_function);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_set_timeout_functions_obj, 6, mp_dbus_server_set_timeout_functions, dbus_server_set_timeout_functions);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_server_set_auth_mechanisms(DBusServer *server, const char **mechanisms)
 */
 
STATIC mp_obj_t mp_dbus_server_set_auth_mechanisms(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    const char **mechanisms = mp_to_ptr(mp_args[1]);
    dbus_bool_t res = dbus_server_set_auth_mechanisms(server, mechanisms);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_set_auth_mechanisms_obj, 2, mp_dbus_server_set_auth_mechanisms, dbus_server_set_auth_mechanisms);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_server_allocate_data_slot(dbus_int32_t *slot_p)
 */
 
STATIC mp_obj_t mp_dbus_server_allocate_data_slot(size_t mp_n_args, const mp_obj_t *mp_args)
{
    dbus_int32_t *slot_p = mp_to_ptr(mp_args[0]);
    dbus_bool_t res = dbus_server_allocate_data_slot(slot_p);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_allocate_data_slot_obj, 1, mp_dbus_server_allocate_data_slot, dbus_server_allocate_data_slot);

 

/*
 * dbus extension definition for:
 * void dbus_server_free_data_slot(dbus_int32_t *slot_p)
 */
 
STATIC mp_obj_t mp_dbus_server_free_data_slot(size_t mp_n_args, const mp_obj_t *mp_args)
{
    dbus_int32_t *slot_p = mp_to_ptr(mp_args[0]);
    dbus_server_free_data_slot(slot_p);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_free_data_slot_obj, 1, mp_dbus_server_free_data_slot, dbus_server_free_data_slot);

 

/*
 * Function NOT generated:
 * Callback function 'DBusFreeFunction free_data_func' must receive a struct pointer with user_data member as its first argument!
 * DBusFreeFunction free_data_func
 */
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_server_set_data(DBusServer *server, int slot, void *data, DBusFreeFunction free_data_func)
 */
 
STATIC mp_obj_t mp_dbus_server_set_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    int slot = (int)mp_obj_get_int(mp_args[1]);
    void *data = mp_to_ptr(mp_args[2]);
    DBusFreeFunction free_data_func = mp_to_ptr(mp_args[3]);
    dbus_bool_t res = dbus_server_set_data(server, slot, data, free_data_func);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_set_data_obj, 4, mp_dbus_server_set_data, dbus_server_set_data);

 

/*
 * dbus extension definition for:
 * void *dbus_server_get_data(DBusServer *server, int slot)
 */
 
STATIC mp_obj_t mp_dbus_server_get_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusServer *server = mp_to_ptr(mp_args[0]);
    int slot = (int)mp_obj_get_int(mp_args[1]);
    void * res = dbus_server_get_data(server, slot);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_server_get_data_obj, 2, mp_dbus_server_get_data, dbus_server_get_data);

 

/*
 * Struct DBusSignatureIter
 */

STATIC inline const mp_obj_type_t *get_mp_DBusSignatureIter_type();

STATIC inline DBusSignatureIter* mp_write_ptr_DBusSignatureIter(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_DBusSignatureIter_type()));
    return (DBusSignatureIter*)self->data;
}

#define mp_write_DBusSignatureIter(struct_obj) *mp_write_ptr_DBusSignatureIter(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_DBusSignatureIter(DBusSignatureIter *field)
{
    return lv_to_mp_struct(get_mp_DBusSignatureIter_type(), (void*)field);
}

#define mp_read_DBusSignatureIter(field) mp_read_ptr_DBusSignatureIter(copy_buffer(&field, sizeof(DBusSignatureIter)))
#define mp_read_byref_DBusSignatureIter(field) mp_read_ptr_DBusSignatureIter(&field)

STATIC void mp_DBusSignatureIter_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    DBusSignatureIter *data = (DBusSignatureIter*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_dummy1: dest[0] = ptr_to_mp((void*)data->dummy1); break; // converting from void *;
            case MP_QSTR_dummy2: dest[0] = ptr_to_mp((void*)data->dummy2); break; // converting from void *;
            case MP_QSTR_dummy8: dest[0] = mp_obj_new_int_from_uint(data->dummy8); break; // converting from dbus_uint32_t;
            case MP_QSTR_dummy12: dest[0] = mp_obj_new_int(data->dummy12); break; // converting from int;
            case MP_QSTR_dummy17: dest[0] = mp_obj_new_int(data->dummy17); break; // converting from int;
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_dummy1: data->dummy1 = (void*)mp_to_ptr(dest[1]); break; // converting to void *;
                case MP_QSTR_dummy2: data->dummy2 = (void*)mp_to_ptr(dest[1]); break; // converting to void *;
                case MP_QSTR_dummy8: data->dummy8 = (unsigned int)mp_obj_get_int(dest[1]); break; // converting to dbus_uint32_t;
                case MP_QSTR_dummy12: data->dummy12 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                case MP_QSTR_dummy17: data->dummy17 = (int)mp_obj_get_int(dest[1]); break; // converting to int;
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_DBusSignatureIter_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct DBusSignatureIter");
}

STATIC const mp_rom_map_elem_t mp_DBusSignatureIter_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(DBusSignatureIter))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_DBusSignatureIter_locals_dict, mp_DBusSignatureIter_locals_dict_table);

STATIC const mp_obj_type_t mp_DBusSignatureIter_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBusSignatureIter,
    .print = mp_DBusSignatureIter_print,
    .make_new = make_new_lv_struct,
    .attr = mp_DBusSignatureIter_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_DBusSignatureIter_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_DBusSignatureIter_type()
{
    return &mp_DBusSignatureIter_type;
}
    

/*
 * dbus extension definition for:
 * void dbus_signature_iter_init(DBusSignatureIter *iter, const char *signature)
 */
 
STATIC mp_obj_t mp_dbus_signature_iter_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusSignatureIter *iter = mp_write_ptr_DBusSignatureIter(mp_args[0]);
    const char *signature = (char*)mp_obj_str_get_str(mp_args[1]);
    dbus_signature_iter_init(iter, signature);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_signature_iter_init_obj, 2, mp_dbus_signature_iter_init, dbus_signature_iter_init);

 

/*
 * dbus extension definition for:
 * int dbus_signature_iter_get_current_type(const DBusSignatureIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_signature_iter_get_current_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const DBusSignatureIter *iter = mp_write_ptr_DBusSignatureIter(mp_args[0]);
    int res = dbus_signature_iter_get_current_type(iter);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_signature_iter_get_current_type_obj, 1, mp_dbus_signature_iter_get_current_type, dbus_signature_iter_get_current_type);

 

/*
 * dbus extension definition for:
 * char *dbus_signature_iter_get_signature(const DBusSignatureIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_signature_iter_get_signature(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const DBusSignatureIter *iter = mp_write_ptr_DBusSignatureIter(mp_args[0]);
    char * res = dbus_signature_iter_get_signature(iter);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_signature_iter_get_signature_obj, 1, mp_dbus_signature_iter_get_signature, dbus_signature_iter_get_signature);

 

/*
 * dbus extension definition for:
 * int dbus_signature_iter_get_element_type(const DBusSignatureIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_signature_iter_get_element_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const DBusSignatureIter *iter = mp_write_ptr_DBusSignatureIter(mp_args[0]);
    int res = dbus_signature_iter_get_element_type(iter);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_signature_iter_get_element_type_obj, 1, mp_dbus_signature_iter_get_element_type, dbus_signature_iter_get_element_type);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_signature_iter_next(DBusSignatureIter *iter)
 */
 
STATIC mp_obj_t mp_dbus_signature_iter_next(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DBusSignatureIter *iter = mp_write_ptr_DBusSignatureIter(mp_args[0]);
    dbus_bool_t res = dbus_signature_iter_next(iter);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_signature_iter_next_obj, 1, mp_dbus_signature_iter_next, dbus_signature_iter_next);

 

/*
 * dbus extension definition for:
 * void dbus_signature_iter_recurse(const DBusSignatureIter *iter, DBusSignatureIter *subiter)
 */
 
STATIC mp_obj_t mp_dbus_signature_iter_recurse(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const DBusSignatureIter *iter = mp_write_ptr_DBusSignatureIter(mp_args[0]);
    DBusSignatureIter *subiter = mp_write_ptr_DBusSignatureIter(mp_args[1]);
    dbus_signature_iter_recurse(iter, subiter);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_signature_iter_recurse_obj, 2, mp_dbus_signature_iter_recurse, dbus_signature_iter_recurse);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_signature_validate(const char *signature, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_signature_validate(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *signature = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    dbus_bool_t res = dbus_signature_validate(signature, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_signature_validate_obj, 2, mp_dbus_signature_validate, dbus_signature_validate);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_signature_validate_single(const char *signature, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_signature_validate_single(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *signature = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    dbus_bool_t res = dbus_signature_validate_single(signature, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_signature_validate_single_obj, 2, mp_dbus_signature_validate_single, dbus_signature_validate_single);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_type_is_valid(int typecode)
 */
 
STATIC mp_obj_t mp_dbus_type_is_valid(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int typecode = (int)mp_obj_get_int(mp_args[0]);
    dbus_bool_t res = dbus_type_is_valid(typecode);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_type_is_valid_obj, 1, mp_dbus_type_is_valid, dbus_type_is_valid);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_type_is_basic(int typecode)
 */
 
STATIC mp_obj_t mp_dbus_type_is_basic(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int typecode = (int)mp_obj_get_int(mp_args[0]);
    dbus_bool_t res = dbus_type_is_basic(typecode);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_type_is_basic_obj, 1, mp_dbus_type_is_basic, dbus_type_is_basic);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_type_is_container(int typecode)
 */
 
STATIC mp_obj_t mp_dbus_type_is_container(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int typecode = (int)mp_obj_get_int(mp_args[0]);
    dbus_bool_t res = dbus_type_is_container(typecode);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_type_is_container_obj, 1, mp_dbus_type_is_container, dbus_type_is_container);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_type_is_fixed(int typecode)
 */
 
STATIC mp_obj_t mp_dbus_type_is_fixed(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int typecode = (int)mp_obj_get_int(mp_args[0]);
    dbus_bool_t res = dbus_type_is_fixed(typecode);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_type_is_fixed_obj, 1, mp_dbus_type_is_fixed, dbus_type_is_fixed);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_validate_path(const char *path, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_validate_path(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *path = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    dbus_bool_t res = dbus_validate_path(path, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_validate_path_obj, 2, mp_dbus_validate_path, dbus_validate_path);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_validate_interface(const char *name, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_validate_interface(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *name = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    dbus_bool_t res = dbus_validate_interface(name, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_validate_interface_obj, 2, mp_dbus_validate_interface, dbus_validate_interface);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_validate_member(const char *name, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_validate_member(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *name = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    dbus_bool_t res = dbus_validate_member(name, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_validate_member_obj, 2, mp_dbus_validate_member, dbus_validate_member);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_validate_error_name(const char *name, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_validate_error_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *name = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    dbus_bool_t res = dbus_validate_error_name(name, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_validate_error_name_obj, 2, mp_dbus_validate_error_name, dbus_validate_error_name);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_validate_bus_name(const char *name, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_validate_bus_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *name = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    dbus_bool_t res = dbus_validate_bus_name(name, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_validate_bus_name_obj, 2, mp_dbus_validate_bus_name, dbus_validate_bus_name);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_validate_utf8(const char *alleged_utf8, DBusError *error)
 */
 
STATIC mp_obj_t mp_dbus_validate_utf8(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *alleged_utf8 = (char*)mp_obj_str_get_str(mp_args[0]);
    DBusError *error = mp_write_ptr_DBusError(mp_args[1]);
    dbus_bool_t res = dbus_validate_utf8(alleged_utf8, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_validate_utf8_obj, 2, mp_dbus_validate_utf8, dbus_validate_utf8);

 

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_mutex_new_callback'
 * DBusMutexNewFunction mutex_new
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_mutex_free_callback'
 * DBusMutexFreeFunction mutex_free
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_mutex_lock_callback'
 * DBusMutexLockFunction mutex_lock
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_mutex_unlock_callback'
 * DBusMutexUnlockFunction mutex_unlock
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_condvar_new_callback'
 * DBusCondVarNewFunction condvar_new
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_condvar_free_callback'
 * DBusCondVarFreeFunction condvar_free
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_condvar_wait_callback'
 * DBusCondVarWaitFunction condvar_wait
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_condvar_wait_timeout_callback'
 * DBusCondVarWaitTimeoutFunction condvar_wait_timeout
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_condvar_wake_one_callback'
 * DBusCondVarWakeOneFunction condvar_wake_one
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_condvar_wake_all_callback'
 * DBusCondVarWakeAllFunction condvar_wake_all
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_recursive_mutex_new_callback'
 * DBusRecursiveMutexNewFunction recursive_mutex_new
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_recursive_mutex_free_callback'
 * DBusRecursiveMutexFreeFunction recursive_mutex_free
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_recursive_mutex_lock_callback'
 * DBusRecursiveMutexLockFunction recursive_mutex_lock
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_recursive_mutex_unlock_callback'
 * DBusRecursiveMutexUnlockFunction recursive_mutex_unlock
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_padding1_callback'
 * void (*padding1)(void)
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_padding2_callback'
 * void (*padding2)(void)
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_padding3_callback'
 * void (*padding3)(void)
 */
    

/*
 * Function NOT generated:
 * Missing 'user_data' as a field of the first parameter of the callback function 'DBusThreadFunctions_padding4_callback'
 * void (*padding4)(void)
 */
    

/*
 * Struct DBusThreadFunctions
 */

STATIC inline const mp_obj_type_t *get_mp_DBusThreadFunctions_type();

STATIC inline DBusThreadFunctions* mp_write_ptr_DBusThreadFunctions(mp_obj_t self_in)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(cast(self_in, get_mp_DBusThreadFunctions_type()));
    return (DBusThreadFunctions*)self->data;
}

#define mp_write_DBusThreadFunctions(struct_obj) *mp_write_ptr_DBusThreadFunctions(struct_obj)

STATIC inline mp_obj_t mp_read_ptr_DBusThreadFunctions(DBusThreadFunctions *field)
{
    return lv_to_mp_struct(get_mp_DBusThreadFunctions_type(), (void*)field);
}

#define mp_read_DBusThreadFunctions(field) mp_read_ptr_DBusThreadFunctions(copy_buffer(&field, sizeof(DBusThreadFunctions)))
#define mp_read_byref_DBusThreadFunctions(field) mp_read_ptr_DBusThreadFunctions(&field)

STATIC void mp_DBusThreadFunctions_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest)
{
    mp_lv_struct_t *self = MP_OBJ_TO_PTR(self_in);
    DBusThreadFunctions *data = (DBusThreadFunctions*)self->data;

    if (dest[0] == MP_OBJ_NULL) {
        // load attribute
        switch(attr)
        {
            case MP_QSTR_mask: dest[0] = mp_obj_new_int_from_uint(data->mask); break; // converting from unsigned int;
            case MP_QSTR_mutex_new: dest[0] = ptr_to_mp(data->mutex_new); break; // converting from callback DBusMutexNewFunction;
            case MP_QSTR_mutex_free: dest[0] = ptr_to_mp(data->mutex_free); break; // converting from callback DBusMutexFreeFunction;
            case MP_QSTR_mutex_lock: dest[0] = ptr_to_mp(data->mutex_lock); break; // converting from callback DBusMutexLockFunction;
            case MP_QSTR_mutex_unlock: dest[0] = ptr_to_mp(data->mutex_unlock); break; // converting from callback DBusMutexUnlockFunction;
            case MP_QSTR_condvar_new: dest[0] = ptr_to_mp(data->condvar_new); break; // converting from callback DBusCondVarNewFunction;
            case MP_QSTR_condvar_free: dest[0] = ptr_to_mp(data->condvar_free); break; // converting from callback DBusCondVarFreeFunction;
            case MP_QSTR_condvar_wait: dest[0] = ptr_to_mp(data->condvar_wait); break; // converting from callback DBusCondVarWaitFunction;
            case MP_QSTR_condvar_wait_timeout: dest[0] = ptr_to_mp(data->condvar_wait_timeout); break; // converting from callback DBusCondVarWaitTimeoutFunction;
            case MP_QSTR_condvar_wake_one: dest[0] = ptr_to_mp(data->condvar_wake_one); break; // converting from callback DBusCondVarWakeOneFunction;
            case MP_QSTR_condvar_wake_all: dest[0] = ptr_to_mp(data->condvar_wake_all); break; // converting from callback DBusCondVarWakeAllFunction;
            case MP_QSTR_recursive_mutex_new: dest[0] = ptr_to_mp(data->recursive_mutex_new); break; // converting from callback DBusRecursiveMutexNewFunction;
            case MP_QSTR_recursive_mutex_free: dest[0] = ptr_to_mp(data->recursive_mutex_free); break; // converting from callback DBusRecursiveMutexFreeFunction;
            case MP_QSTR_recursive_mutex_lock: dest[0] = ptr_to_mp(data->recursive_mutex_lock); break; // converting from callback DBusRecursiveMutexLockFunction;
            case MP_QSTR_recursive_mutex_unlock: dest[0] = ptr_to_mp(data->recursive_mutex_unlock); break; // converting from callback DBusRecursiveMutexUnlockFunction;
            case MP_QSTR_padding1: dest[0] = ptr_to_mp((void*)data->padding1); break; // converting from callback void (*)(void);
            case MP_QSTR_padding2: dest[0] = ptr_to_mp((void*)data->padding2); break; // converting from callback void (*)(void);
            case MP_QSTR_padding3: dest[0] = ptr_to_mp((void*)data->padding3); break; // converting from callback void (*)(void);
            case MP_QSTR_padding4: dest[0] = ptr_to_mp((void*)data->padding4); break; // converting from callback void (*)(void);
            case MP_QSTR___dereference__: {
                dest[0] = (void*)&mp_lv_dereference_obj; 
                dest[1] = self_in;
            }
            break;
        }
    } else {
        if (dest[1])
        {
            // store attribute
            switch(attr)
            {
                case MP_QSTR_mask: data->mask = (unsigned int)mp_obj_get_int(dest[1]); break; // converting to unsigned int;
                case MP_QSTR_mutex_new: data->mutex_new = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_mutex_new, NULL); break; // converting to callback DBusMutexNewFunction;
                case MP_QSTR_mutex_free: data->mutex_free = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_mutex_free, NULL); break; // converting to callback DBusMutexFreeFunction;
                case MP_QSTR_mutex_lock: data->mutex_lock = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_mutex_lock, NULL); break; // converting to callback DBusMutexLockFunction;
                case MP_QSTR_mutex_unlock: data->mutex_unlock = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_mutex_unlock, NULL); break; // converting to callback DBusMutexUnlockFunction;
                case MP_QSTR_condvar_new: data->condvar_new = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_condvar_new, NULL); break; // converting to callback DBusCondVarNewFunction;
                case MP_QSTR_condvar_free: data->condvar_free = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_condvar_free, NULL); break; // converting to callback DBusCondVarFreeFunction;
                case MP_QSTR_condvar_wait: data->condvar_wait = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_condvar_wait, NULL); break; // converting to callback DBusCondVarWaitFunction;
                case MP_QSTR_condvar_wait_timeout: data->condvar_wait_timeout = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_condvar_wait_timeout, NULL); break; // converting to callback DBusCondVarWaitTimeoutFunction;
                case MP_QSTR_condvar_wake_one: data->condvar_wake_one = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_condvar_wake_one, NULL); break; // converting to callback DBusCondVarWakeOneFunction;
                case MP_QSTR_condvar_wake_all: data->condvar_wake_all = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_condvar_wake_all, NULL); break; // converting to callback DBusCondVarWakeAllFunction;
                case MP_QSTR_recursive_mutex_new: data->recursive_mutex_new = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_recursive_mutex_new, NULL); break; // converting to callback DBusRecursiveMutexNewFunction;
                case MP_QSTR_recursive_mutex_free: data->recursive_mutex_free = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_recursive_mutex_free, NULL); break; // converting to callback DBusRecursiveMutexFreeFunction;
                case MP_QSTR_recursive_mutex_lock: data->recursive_mutex_lock = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_recursive_mutex_lock, NULL); break; // converting to callback DBusRecursiveMutexLockFunction;
                case MP_QSTR_recursive_mutex_unlock: data->recursive_mutex_unlock = mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_recursive_mutex_unlock, NULL); break; // converting to callback DBusRecursiveMutexUnlockFunction;
                case MP_QSTR_padding1: data->padding1 = (void*)mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_padding1, NULL); break; // converting to callback void (*)(void);
                case MP_QSTR_padding2: data->padding2 = (void*)mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_padding2, NULL); break; // converting to callback void (*)(void);
                case MP_QSTR_padding3: data->padding3 = (void*)mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_padding3, NULL); break; // converting to callback void (*)(void);
                case MP_QSTR_padding4: data->padding4 = (void*)mp_lv_callback(dest[1], NULL ,MP_QSTR_DBusThreadFunctions_padding4, NULL); break; // converting to callback void (*)(void);
                default: return;
            }

            dest[0] = MP_OBJ_NULL; // indicate success
        }
    }
}

STATIC void mp_DBusThreadFunctions_print(const mp_print_t *print,
    mp_obj_t self_in,
    mp_print_kind_t kind)
{
    mp_printf(print, "struct DBusThreadFunctions");
}

STATIC const mp_rom_map_elem_t mp_DBusThreadFunctions_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_SIZE), MP_ROM_PTR(MP_ROM_INT(sizeof(DBusThreadFunctions))) },
    { MP_ROM_QSTR(MP_QSTR_cast), MP_ROM_PTR(&mp_lv_cast_class_method) },
    { MP_ROM_QSTR(MP_QSTR_cast_instance), MP_ROM_PTR(&mp_lv_cast_instance_obj) },
//    { MP_ROM_QSTR(MP_QSTR___dereference__), MP_ROM_PTR(&mp_lv_dereference_obj) },
};

STATIC MP_DEFINE_CONST_DICT(mp_DBusThreadFunctions_locals_dict, mp_DBusThreadFunctions_locals_dict_table);

STATIC const mp_obj_type_t mp_DBusThreadFunctions_type = {
    { &mp_type_type },
    .name = MP_QSTR_DBusThreadFunctions,
    .print = mp_DBusThreadFunctions_print,
    .make_new = make_new_lv_struct,
    .attr = mp_DBusThreadFunctions_attr,
    .locals_dict = (mp_obj_dict_t*)&mp_DBusThreadFunctions_locals_dict,
    .buffer_p = { .get_buffer = mp_blob_get_buffer }
};

STATIC inline const mp_obj_type_t *get_mp_DBusThreadFunctions_type()
{
    return &mp_DBusThreadFunctions_type;
}
    

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_threads_init(const DBusThreadFunctions *functions)
 */
 
STATIC mp_obj_t mp_dbus_threads_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const DBusThreadFunctions *functions = mp_write_ptr_DBusThreadFunctions(mp_args[0]);
    dbus_bool_t res = dbus_threads_init(functions);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_threads_init_obj, 1, mp_dbus_threads_init, dbus_threads_init);

 

/*
 * dbus extension definition for:
 * dbus_bool_t dbus_threads_init_default(void)
 */
 
STATIC mp_obj_t mp_dbus_threads_init_default(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    dbus_bool_t res = dbus_threads_init_default();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_dbus_threads_init_default_obj, 0, mp_dbus_threads_init_default, dbus_threads_init_default);

 

/*
 * dbus extension definition for:
 * extern clock_t clock(void)
 */
 
STATIC mp_obj_t mp_clock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    clock_t res = clock();
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_clock_obj, 0, mp_clock, clock);

 

/*
 * dbus extension definition for:
 * extern time_t time(time_t *__timer)
 */
 
STATIC mp_obj_t mp_time(size_t mp_n_args, const mp_obj_t *mp_args)
{
    time_t *__timer = mp_to_ptr(mp_args[0]);
    time_t res = time(__timer);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_time_obj, 1, mp_time, time);

 

/*
 * Function NOT generated:
 * Missing convertion from double
 * extern double difftime(time_t __time1, time_t __time0)
 */
    

/*
 * dbus extension definition for:
 * extern time_t mktime(struct tm *__tp)
 */
 
STATIC mp_obj_t mp_mktime(size_t mp_n_args, const mp_obj_t *mp_args)
{
    struct tm *__tp = mp_to_ptr(mp_args[0]);
    time_t res = mktime(__tp);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_mktime_obj, 1, mp_mktime, mktime);

 

/*
 * dbus extension definition for:
 * extern size_t strftime(char *__s, size_t __maxsize, const char *__format, const struct tm *__tp)
 */
 
STATIC mp_obj_t mp_strftime(size_t mp_n_args, const mp_obj_t *mp_args)
{
    char *__s = (char*)mp_obj_str_get_str(mp_args[0]);
    size_t __maxsize = (size_t)mp_obj_get_int(mp_args[1]);
    const char *__format = (char*)mp_obj_str_get_str(mp_args[2]);
    const struct tm *__tp = mp_to_ptr(mp_args[3]);
    size_t res = strftime(__s, __maxsize, __format, __tp);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_strftime_obj, 4, mp_strftime, strftime);

 

/*
 * dbus extension definition for:
 * extern struct tm *gmtime(const time_t *__timer)
 */
 
STATIC mp_obj_t mp_gmtime(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const time_t *__timer = mp_to_ptr(mp_args[0]);
    struct tm * res = gmtime(__timer);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_gmtime_obj, 1, mp_gmtime, gmtime);

 

/*
 * dbus extension definition for:
 * extern struct tm *localtime(const time_t *__timer)
 */
 
STATIC mp_obj_t mp_localtime(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const time_t *__timer = mp_to_ptr(mp_args[0]);
    struct tm * res = localtime(__timer);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_localtime_obj, 1, mp_localtime, localtime);

 

/*
 * dbus extension definition for:
 * extern char *asctime(const struct tm *__tp)
 */
 
STATIC mp_obj_t mp_asctime(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const struct tm *__tp = mp_to_ptr(mp_args[0]);
    char * res = asctime(__tp);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_asctime_obj, 1, mp_asctime, asctime);

 

/*
 * dbus extension definition for:
 * extern char *ctime(const time_t *__timer)
 */
 
STATIC mp_obj_t mp_ctime(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const time_t *__timer = mp_to_ptr(mp_args[0]);
    char * res = ctime(__timer);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_ctime_obj, 1, mp_ctime, ctime);

 

/*
 * dbus extension definition for:
 * extern GArray *g_array_new(gboolean zero_terminated, gboolean clear_, guint element_size)
 */
 
STATIC mp_obj_t mp_g_array_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gboolean zero_terminated = (int)mp_obj_get_int(mp_args[0]);
    gboolean clear_ = (int)mp_obj_get_int(mp_args[1]);
    guint element_size = (unsigned int)mp_obj_get_int(mp_args[2]);
    GArray * res = g_array_new(zero_terminated, clear_, element_size);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_new_obj, 3, mp_g_array_new, g_array_new);

 

/*
 * dbus extension definition for:
 * extern GArray *g_array_sized_new(gboolean zero_terminated, gboolean clear_, guint element_size, guint reserved_size)
 */
 
STATIC mp_obj_t mp_g_array_sized_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gboolean zero_terminated = (int)mp_obj_get_int(mp_args[0]);
    gboolean clear_ = (int)mp_obj_get_int(mp_args[1]);
    guint element_size = (unsigned int)mp_obj_get_int(mp_args[2]);
    guint reserved_size = (unsigned int)mp_obj_get_int(mp_args[3]);
    GArray * res = g_array_sized_new(zero_terminated, clear_, element_size, reserved_size);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_sized_new_obj, 4, mp_g_array_sized_new, g_array_sized_new);

 

/*
 * dbus extension definition for:
 * extern gchar *g_array_free(GArray *array, gboolean free_segment)
 */
 
STATIC mp_obj_t mp_g_array_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    gboolean free_segment = (int)mp_obj_get_int(mp_args[1]);
    gchar * res = g_array_free(array, free_segment);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_free_obj, 2, mp_g_array_free, g_array_free);

 

/*
 * dbus extension definition for:
 * extern GArray *g_array_ref(GArray *array)
 */
 
STATIC mp_obj_t mp_g_array_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    GArray * res = g_array_ref(array);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_ref_obj, 1, mp_g_array_ref, g_array_ref);

 

/*
 * dbus extension definition for:
 * extern void g_array_unref(GArray *array)
 */
 
STATIC mp_obj_t mp_g_array_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    g_array_unref(array);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_unref_obj, 1, mp_g_array_unref, g_array_unref);

 

/*
 * dbus extension definition for:
 * extern guint g_array_get_element_size(GArray *array)
 */
 
STATIC mp_obj_t mp_g_array_get_element_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    guint res = g_array_get_element_size(array);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_get_element_size_obj, 1, mp_g_array_get_element_size, g_array_get_element_size);

 

/*
 * dbus extension definition for:
 * extern GArray *g_array_append_vals(GArray *array, gconstpointer data, guint len)
 */
 
STATIC mp_obj_t mp_g_array_append_vals(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    guint len = (unsigned int)mp_obj_get_int(mp_args[2]);
    GArray * res = g_array_append_vals(array, data, len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_append_vals_obj, 3, mp_g_array_append_vals, g_array_append_vals);

 

/*
 * dbus extension definition for:
 * extern GArray *g_array_prepend_vals(GArray *array, gconstpointer data, guint len)
 */
 
STATIC mp_obj_t mp_g_array_prepend_vals(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    guint len = (unsigned int)mp_obj_get_int(mp_args[2]);
    GArray * res = g_array_prepend_vals(array, data, len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_prepend_vals_obj, 3, mp_g_array_prepend_vals, g_array_prepend_vals);

 

/*
 * dbus extension definition for:
 * extern GArray *g_array_insert_vals(GArray *array, guint index_, gconstpointer data, guint len)
 */
 
STATIC mp_obj_t mp_g_array_insert_vals(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    guint index_ = (unsigned int)mp_obj_get_int(mp_args[1]);
    gconstpointer data = mp_to_ptr(mp_args[2]);
    guint len = (unsigned int)mp_obj_get_int(mp_args[3]);
    GArray * res = g_array_insert_vals(array, index_, data, len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_insert_vals_obj, 4, mp_g_array_insert_vals, g_array_insert_vals);

 

/*
 * dbus extension definition for:
 * extern GArray *g_array_set_size(GArray *array, guint length)
 */
 
STATIC mp_obj_t mp_g_array_set_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    guint length = (unsigned int)mp_obj_get_int(mp_args[1]);
    GArray * res = g_array_set_size(array, length);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_set_size_obj, 2, mp_g_array_set_size, g_array_set_size);

 

/*
 * dbus extension definition for:
 * extern GArray *g_array_remove_index(GArray *array, guint index_)
 */
 
STATIC mp_obj_t mp_g_array_remove_index(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    guint index_ = (unsigned int)mp_obj_get_int(mp_args[1]);
    GArray * res = g_array_remove_index(array, index_);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_remove_index_obj, 2, mp_g_array_remove_index, g_array_remove_index);

 

/*
 * dbus extension definition for:
 * extern GArray *g_array_remove_index_fast(GArray *array, guint index_)
 */
 
STATIC mp_obj_t mp_g_array_remove_index_fast(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    guint index_ = (unsigned int)mp_obj_get_int(mp_args[1]);
    GArray * res = g_array_remove_index_fast(array, index_);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_remove_index_fast_obj, 2, mp_g_array_remove_index_fast, g_array_remove_index_fast);

 

/*
 * dbus extension definition for:
 * extern GArray *g_array_remove_range(GArray *array, guint index_, guint length)
 */
 
STATIC mp_obj_t mp_g_array_remove_range(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    guint index_ = (unsigned int)mp_obj_get_int(mp_args[1]);
    guint length = (unsigned int)mp_obj_get_int(mp_args[2]);
    GArray * res = g_array_remove_range(array, index_, length);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_remove_range_obj, 3, mp_g_array_remove_range, g_array_remove_range);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_array_sort(GArray *array, GCompareFunc compare_func)
 */
 
STATIC mp_obj_t mp_g_array_sort(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    GCompareFunc compare_func = mp_to_ptr(mp_args[1]);
    g_array_sort(array, compare_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_sort_obj, 2, mp_g_array_sort, g_array_sort);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_array_sort_with_data(GArray *array, GCompareDataFunc compare_func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_array_sort_with_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    GCompareDataFunc compare_func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_array_sort_with_data(array, compare_func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_sort_with_data_obj, 3, mp_g_array_sort_with_data, g_array_sort_with_data);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify clear_func' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify clear_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_array_set_clear_func(GArray *array, GDestroyNotify clear_func)
 */
 
STATIC mp_obj_t mp_g_array_set_clear_func(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GArray *array = mp_to_ptr(mp_args[0]);
    GDestroyNotify clear_func = mp_to_ptr(mp_args[1]);
    g_array_set_clear_func(array, clear_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_array_set_clear_func_obj, 2, mp_g_array_set_clear_func, g_array_set_clear_func);

 

/*
 * dbus extension definition for:
 * extern GPtrArray *g_ptr_array_new(void)
 */
 
STATIC mp_obj_t mp_g_ptr_array_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GPtrArray * res = g_ptr_array_new();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_new_obj, 0, mp_g_ptr_array_new, g_ptr_array_new);

 

/*
 * Function NOT generated:
 * Callback argument 'GDestroyNotify element_free_func' cannot be the first argument! We assume the first argument contains the user_data
 * GDestroyNotify element_free_func
 */
    

/*
 * dbus extension definition for:
 * extern GPtrArray *g_ptr_array_new_with_free_func(GDestroyNotify element_free_func)
 */
 
STATIC mp_obj_t mp_g_ptr_array_new_with_free_func(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDestroyNotify element_free_func = mp_to_ptr(mp_args[0]);
    GPtrArray * res = g_ptr_array_new_with_free_func(element_free_func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_new_with_free_func_obj, 1, mp_g_ptr_array_new_with_free_func, g_ptr_array_new_with_free_func);

 

/*
 * dbus extension definition for:
 * extern GPtrArray *g_ptr_array_sized_new(guint reserved_size)
 */
 
STATIC mp_obj_t mp_g_ptr_array_sized_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint reserved_size = (unsigned int)mp_obj_get_int(mp_args[0]);
    GPtrArray * res = g_ptr_array_sized_new(reserved_size);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_sized_new_obj, 1, mp_g_ptr_array_sized_new, g_ptr_array_sized_new);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify element_free_func' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify element_free_func
 */
    

/*
 * dbus extension definition for:
 * extern GPtrArray *g_ptr_array_new_full(guint reserved_size, GDestroyNotify element_free_func)
 */
 
STATIC mp_obj_t mp_g_ptr_array_new_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint reserved_size = (unsigned int)mp_obj_get_int(mp_args[0]);
    GDestroyNotify element_free_func = mp_to_ptr(mp_args[1]);
    GPtrArray * res = g_ptr_array_new_full(reserved_size, element_free_func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_new_full_obj, 2, mp_g_ptr_array_new_full, g_ptr_array_new_full);

 

/*
 * dbus extension definition for:
 * extern gpointer *g_ptr_array_free(GPtrArray *array, gboolean free_seg)
 */
 
STATIC mp_obj_t mp_g_ptr_array_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    gboolean free_seg = (int)mp_obj_get_int(mp_args[1]);
    gpointer * res = g_ptr_array_free(array, free_seg);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_free_obj, 2, mp_g_ptr_array_free, g_ptr_array_free);

 

/*
 * dbus extension definition for:
 * extern GPtrArray *g_ptr_array_ref(GPtrArray *array)
 */
 
STATIC mp_obj_t mp_g_ptr_array_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    GPtrArray * res = g_ptr_array_ref(array);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_ref_obj, 1, mp_g_ptr_array_ref, g_ptr_array_ref);

 

/*
 * dbus extension definition for:
 * extern void g_ptr_array_unref(GPtrArray *array)
 */
 
STATIC mp_obj_t mp_g_ptr_array_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    g_ptr_array_unref(array);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_unref_obj, 1, mp_g_ptr_array_unref, g_ptr_array_unref);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify element_free_func' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify element_free_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_ptr_array_set_free_func(GPtrArray *array, GDestroyNotify element_free_func)
 */
 
STATIC mp_obj_t mp_g_ptr_array_set_free_func(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    GDestroyNotify element_free_func = mp_to_ptr(mp_args[1]);
    g_ptr_array_set_free_func(array, element_free_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_set_free_func_obj, 2, mp_g_ptr_array_set_free_func, g_ptr_array_set_free_func);

 

/*
 * dbus extension definition for:
 * extern void g_ptr_array_set_size(GPtrArray *array, gint length)
 */
 
STATIC mp_obj_t mp_g_ptr_array_set_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    gint length = (int)mp_obj_get_int(mp_args[1]);
    g_ptr_array_set_size(array, length);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_set_size_obj, 2, mp_g_ptr_array_set_size, g_ptr_array_set_size);

 

/*
 * dbus extension definition for:
 * extern gpointer g_ptr_array_remove_index(GPtrArray *array, guint index_)
 */
 
STATIC mp_obj_t mp_g_ptr_array_remove_index(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    guint index_ = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer res = g_ptr_array_remove_index(array, index_);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_remove_index_obj, 2, mp_g_ptr_array_remove_index, g_ptr_array_remove_index);

 

/*
 * dbus extension definition for:
 * extern gpointer g_ptr_array_remove_index_fast(GPtrArray *array, guint index_)
 */
 
STATIC mp_obj_t mp_g_ptr_array_remove_index_fast(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    guint index_ = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer res = g_ptr_array_remove_index_fast(array, index_);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_remove_index_fast_obj, 2, mp_g_ptr_array_remove_index_fast, g_ptr_array_remove_index_fast);

 

/*
 * dbus extension definition for:
 * extern gboolean g_ptr_array_remove(GPtrArray *array, gpointer data)
 */
 
STATIC mp_obj_t mp_g_ptr_array_remove(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    gboolean res = g_ptr_array_remove(array, data);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_remove_obj, 2, mp_g_ptr_array_remove, g_ptr_array_remove);

 

/*
 * dbus extension definition for:
 * extern gboolean g_ptr_array_remove_fast(GPtrArray *array, gpointer data)
 */
 
STATIC mp_obj_t mp_g_ptr_array_remove_fast(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    gboolean res = g_ptr_array_remove_fast(array, data);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_remove_fast_obj, 2, mp_g_ptr_array_remove_fast, g_ptr_array_remove_fast);

 

/*
 * dbus extension definition for:
 * extern GPtrArray *g_ptr_array_remove_range(GPtrArray *array, guint index_, guint length)
 */
 
STATIC mp_obj_t mp_g_ptr_array_remove_range(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    guint index_ = (unsigned int)mp_obj_get_int(mp_args[1]);
    guint length = (unsigned int)mp_obj_get_int(mp_args[2]);
    GPtrArray * res = g_ptr_array_remove_range(array, index_, length);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_remove_range_obj, 3, mp_g_ptr_array_remove_range, g_ptr_array_remove_range);

 

/*
 * dbus extension definition for:
 * extern void g_ptr_array_add(GPtrArray *array, gpointer data)
 */
 
STATIC mp_obj_t mp_g_ptr_array_add(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    g_ptr_array_add(array, data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_add_obj, 2, mp_g_ptr_array_add, g_ptr_array_add);

 

/*
 * dbus extension definition for:
 * extern void g_ptr_array_insert(GPtrArray *array, gint index_, gpointer data)
 */
 
STATIC mp_obj_t mp_g_ptr_array_insert(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    gint index_ = (int)mp_obj_get_int(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    g_ptr_array_insert(array, index_, data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_insert_obj, 3, mp_g_ptr_array_insert, g_ptr_array_insert);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_ptr_array_sort(GPtrArray *array, GCompareFunc compare_func)
 */
 
STATIC mp_obj_t mp_g_ptr_array_sort(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    GCompareFunc compare_func = mp_to_ptr(mp_args[1]);
    g_ptr_array_sort(array, compare_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_sort_obj, 2, mp_g_ptr_array_sort, g_ptr_array_sort);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_ptr_array_sort_with_data(GPtrArray *array, GCompareDataFunc compare_func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_ptr_array_sort_with_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    GCompareDataFunc compare_func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_ptr_array_sort_with_data(array, compare_func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_sort_with_data_obj, 3, mp_g_ptr_array_sort_with_data, g_ptr_array_sort_with_data);

 

/*
 * Function NOT generated:
 * Callback function 'GFunc func' must receive a struct pointer with user_data member as its first argument!
 * GFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_ptr_array_foreach(GPtrArray *array, GFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_ptr_array_foreach(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPtrArray *array = mp_to_ptr(mp_args[0]);
    GFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_ptr_array_foreach(array, func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ptr_array_foreach_obj, 3, mp_g_ptr_array_foreach, g_ptr_array_foreach);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_byte_array_new(void)
 */
 
STATIC mp_obj_t mp_g_byte_array_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GByteArray * res = g_byte_array_new();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_new_obj, 0, mp_g_byte_array_new, g_byte_array_new);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_byte_array_new_take(guint8 *data, gsize len)
 */
 
STATIC mp_obj_t mp_g_byte_array_new_take(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint8 *data = mp_to_ptr(mp_args[0]);
    gsize len = (unsigned long)mp_obj_get_int(mp_args[1]);
    GByteArray * res = g_byte_array_new_take(data, len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_new_take_obj, 2, mp_g_byte_array_new_take, g_byte_array_new_take);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_byte_array_sized_new(guint reserved_size)
 */
 
STATIC mp_obj_t mp_g_byte_array_sized_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint reserved_size = (unsigned int)mp_obj_get_int(mp_args[0]);
    GByteArray * res = g_byte_array_sized_new(reserved_size);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_sized_new_obj, 1, mp_g_byte_array_sized_new, g_byte_array_sized_new);

 

/*
 * dbus extension definition for:
 * extern guint8 *g_byte_array_free(GByteArray *array, gboolean free_segment)
 */
 
STATIC mp_obj_t mp_g_byte_array_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    gboolean free_segment = (int)mp_obj_get_int(mp_args[1]);
    guint8 * res = g_byte_array_free(array, free_segment);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_free_obj, 2, mp_g_byte_array_free, g_byte_array_free);

 

/*
 * dbus extension definition for:
 * extern GBytes *g_byte_array_free_to_bytes(GByteArray *array)
 */
 
STATIC mp_obj_t mp_g_byte_array_free_to_bytes(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    GBytes * res = g_byte_array_free_to_bytes(array);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_free_to_bytes_obj, 1, mp_g_byte_array_free_to_bytes, g_byte_array_free_to_bytes);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_byte_array_ref(GByteArray *array)
 */
 
STATIC mp_obj_t mp_g_byte_array_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    GByteArray * res = g_byte_array_ref(array);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_ref_obj, 1, mp_g_byte_array_ref, g_byte_array_ref);

 

/*
 * dbus extension definition for:
 * extern void g_byte_array_unref(GByteArray *array)
 */
 
STATIC mp_obj_t mp_g_byte_array_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    g_byte_array_unref(array);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_unref_obj, 1, mp_g_byte_array_unref, g_byte_array_unref);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_byte_array_append(GByteArray *array, const guint8 *data, guint len)
 */
 
STATIC mp_obj_t mp_g_byte_array_append(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    const guint8 *data = mp_to_ptr(mp_args[1]);
    guint len = (unsigned int)mp_obj_get_int(mp_args[2]);
    GByteArray * res = g_byte_array_append(array, data, len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_append_obj, 3, mp_g_byte_array_append, g_byte_array_append);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_byte_array_prepend(GByteArray *array, const guint8 *data, guint len)
 */
 
STATIC mp_obj_t mp_g_byte_array_prepend(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    const guint8 *data = mp_to_ptr(mp_args[1]);
    guint len = (unsigned int)mp_obj_get_int(mp_args[2]);
    GByteArray * res = g_byte_array_prepend(array, data, len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_prepend_obj, 3, mp_g_byte_array_prepend, g_byte_array_prepend);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_byte_array_set_size(GByteArray *array, guint length)
 */
 
STATIC mp_obj_t mp_g_byte_array_set_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    guint length = (unsigned int)mp_obj_get_int(mp_args[1]);
    GByteArray * res = g_byte_array_set_size(array, length);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_set_size_obj, 2, mp_g_byte_array_set_size, g_byte_array_set_size);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_byte_array_remove_index(GByteArray *array, guint index_)
 */
 
STATIC mp_obj_t mp_g_byte_array_remove_index(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    guint index_ = (unsigned int)mp_obj_get_int(mp_args[1]);
    GByteArray * res = g_byte_array_remove_index(array, index_);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_remove_index_obj, 2, mp_g_byte_array_remove_index, g_byte_array_remove_index);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_byte_array_remove_index_fast(GByteArray *array, guint index_)
 */
 
STATIC mp_obj_t mp_g_byte_array_remove_index_fast(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    guint index_ = (unsigned int)mp_obj_get_int(mp_args[1]);
    GByteArray * res = g_byte_array_remove_index_fast(array, index_);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_remove_index_fast_obj, 2, mp_g_byte_array_remove_index_fast, g_byte_array_remove_index_fast);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_byte_array_remove_range(GByteArray *array, guint index_, guint length)
 */
 
STATIC mp_obj_t mp_g_byte_array_remove_range(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    guint index_ = (unsigned int)mp_obj_get_int(mp_args[1]);
    guint length = (unsigned int)mp_obj_get_int(mp_args[2]);
    GByteArray * res = g_byte_array_remove_range(array, index_, length);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_remove_range_obj, 3, mp_g_byte_array_remove_range, g_byte_array_remove_range);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_byte_array_sort(GByteArray *array, GCompareFunc compare_func)
 */
 
STATIC mp_obj_t mp_g_byte_array_sort(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    GCompareFunc compare_func = mp_to_ptr(mp_args[1]);
    g_byte_array_sort(array, compare_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_sort_obj, 2, mp_g_byte_array_sort, g_byte_array_sort);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_byte_array_sort_with_data(GByteArray *array, GCompareDataFunc compare_func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_byte_array_sort_with_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GByteArray *array = mp_to_ptr(mp_args[0]);
    GCompareDataFunc compare_func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_byte_array_sort_with_data(array, compare_func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_byte_array_sort_with_data_obj, 3, mp_g_byte_array_sort_with_data, g_byte_array_sort_with_data);

 

/*
 * dbus extension definition for:
 * extern gint g_atomic_int_get(const volatile gint *atomic)
 */
 
STATIC mp_obj_t mp_g_atomic_int_get(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const volatile gint *atomic = mp_to_ptr(mp_args[0]);
    gint res = g_atomic_int_get(atomic);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_int_get_obj, 1, mp_g_atomic_int_get, g_atomic_int_get);

 

/*
 * dbus extension definition for:
 * extern void g_atomic_int_set(volatile gint *atomic, gint newval)
 */
 
STATIC mp_obj_t mp_g_atomic_int_set(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile gint *atomic = mp_to_ptr(mp_args[0]);
    gint newval = (int)mp_obj_get_int(mp_args[1]);
    g_atomic_int_set(atomic, newval);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_int_set_obj, 2, mp_g_atomic_int_set, g_atomic_int_set);

 

/*
 * dbus extension definition for:
 * extern void g_atomic_int_inc(volatile gint *atomic)
 */
 
STATIC mp_obj_t mp_g_atomic_int_inc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile gint *atomic = mp_to_ptr(mp_args[0]);
    g_atomic_int_inc(atomic);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_int_inc_obj, 1, mp_g_atomic_int_inc, g_atomic_int_inc);

 

/*
 * dbus extension definition for:
 * extern gboolean g_atomic_int_dec_and_test(volatile gint *atomic)
 */
 
STATIC mp_obj_t mp_g_atomic_int_dec_and_test(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile gint *atomic = mp_to_ptr(mp_args[0]);
    gboolean res = g_atomic_int_dec_and_test(atomic);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_int_dec_and_test_obj, 1, mp_g_atomic_int_dec_and_test, g_atomic_int_dec_and_test);

 

/*
 * dbus extension definition for:
 * extern gboolean g_atomic_int_compare_and_exchange(volatile gint *atomic, gint oldval, gint newval)
 */
 
STATIC mp_obj_t mp_g_atomic_int_compare_and_exchange(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile gint *atomic = mp_to_ptr(mp_args[0]);
    gint oldval = (int)mp_obj_get_int(mp_args[1]);
    gint newval = (int)mp_obj_get_int(mp_args[2]);
    gboolean res = g_atomic_int_compare_and_exchange(atomic, oldval, newval);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_int_compare_and_exchange_obj, 3, mp_g_atomic_int_compare_and_exchange, g_atomic_int_compare_and_exchange);

 

/*
 * dbus extension definition for:
 * extern gint g_atomic_int_add(volatile gint *atomic, gint val)
 */
 
STATIC mp_obj_t mp_g_atomic_int_add(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile gint *atomic = mp_to_ptr(mp_args[0]);
    gint val = (int)mp_obj_get_int(mp_args[1]);
    gint res = g_atomic_int_add(atomic, val);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_int_add_obj, 2, mp_g_atomic_int_add, g_atomic_int_add);

 

/*
 * dbus extension definition for:
 * extern guint g_atomic_int_and(volatile guint *atomic, guint val)
 */
 
STATIC mp_obj_t mp_g_atomic_int_and(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile guint *atomic = mp_to_ptr(mp_args[0]);
    guint val = (unsigned int)mp_obj_get_int(mp_args[1]);
    guint res = g_atomic_int_and(atomic, val);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_int_and_obj, 2, mp_g_atomic_int_and, g_atomic_int_and);

 

/*
 * dbus extension definition for:
 * extern guint g_atomic_int_or(volatile guint *atomic, guint val)
 */
 
STATIC mp_obj_t mp_g_atomic_int_or(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile guint *atomic = mp_to_ptr(mp_args[0]);
    guint val = (unsigned int)mp_obj_get_int(mp_args[1]);
    guint res = g_atomic_int_or(atomic, val);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_int_or_obj, 2, mp_g_atomic_int_or, g_atomic_int_or);

 

/*
 * dbus extension definition for:
 * extern guint g_atomic_int_xor(volatile guint *atomic, guint val)
 */
 
STATIC mp_obj_t mp_g_atomic_int_xor(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile guint *atomic = mp_to_ptr(mp_args[0]);
    guint val = (unsigned int)mp_obj_get_int(mp_args[1]);
    guint res = g_atomic_int_xor(atomic, val);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_int_xor_obj, 2, mp_g_atomic_int_xor, g_atomic_int_xor);

 

/*
 * dbus extension definition for:
 * extern gpointer g_atomic_pointer_get(const volatile void *atomic)
 */
 
STATIC mp_obj_t mp_g_atomic_pointer_get(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const volatile void *atomic = mp_to_ptr(mp_args[0]);
    gpointer res = g_atomic_pointer_get(atomic);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_pointer_get_obj, 1, mp_g_atomic_pointer_get, g_atomic_pointer_get);

 

/*
 * dbus extension definition for:
 * extern void g_atomic_pointer_set(volatile void *atomic, gpointer newval)
 */
 
STATIC mp_obj_t mp_g_atomic_pointer_set(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile void *atomic = mp_to_ptr(mp_args[0]);
    gpointer newval = mp_to_ptr(mp_args[1]);
    g_atomic_pointer_set(atomic, newval);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_pointer_set_obj, 2, mp_g_atomic_pointer_set, g_atomic_pointer_set);

 

/*
 * dbus extension definition for:
 * extern gboolean g_atomic_pointer_compare_and_exchange(volatile void *atomic, gpointer oldval, gpointer newval)
 */
 
STATIC mp_obj_t mp_g_atomic_pointer_compare_and_exchange(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile void *atomic = mp_to_ptr(mp_args[0]);
    gpointer oldval = mp_to_ptr(mp_args[1]);
    gpointer newval = mp_to_ptr(mp_args[2]);
    gboolean res = g_atomic_pointer_compare_and_exchange(atomic, oldval, newval);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_pointer_compare_and_exchange_obj, 3, mp_g_atomic_pointer_compare_and_exchange, g_atomic_pointer_compare_and_exchange);

 

/*
 * Function NOT generated:
 * Missing convertion from gssize
 * extern gssize g_atomic_pointer_add(volatile void *atomic, gssize val)
 */
    

/*
 * dbus extension definition for:
 * extern gsize g_atomic_pointer_and(volatile void *atomic, gsize val)
 */
 
STATIC mp_obj_t mp_g_atomic_pointer_and(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile void *atomic = mp_to_ptr(mp_args[0]);
    gsize val = (unsigned long)mp_obj_get_int(mp_args[1]);
    gsize res = g_atomic_pointer_and(atomic, val);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_pointer_and_obj, 2, mp_g_atomic_pointer_and, g_atomic_pointer_and);

 

/*
 * dbus extension definition for:
 * extern gsize g_atomic_pointer_or(volatile void *atomic, gsize val)
 */
 
STATIC mp_obj_t mp_g_atomic_pointer_or(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile void *atomic = mp_to_ptr(mp_args[0]);
    gsize val = (unsigned long)mp_obj_get_int(mp_args[1]);
    gsize res = g_atomic_pointer_or(atomic, val);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_pointer_or_obj, 2, mp_g_atomic_pointer_or, g_atomic_pointer_or);

 

/*
 * dbus extension definition for:
 * extern gsize g_atomic_pointer_xor(volatile void *atomic, gsize val)
 */
 
STATIC mp_obj_t mp_g_atomic_pointer_xor(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile void *atomic = mp_to_ptr(mp_args[0]);
    gsize val = (unsigned long)mp_obj_get_int(mp_args[1]);
    gsize res = g_atomic_pointer_xor(atomic, val);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_pointer_xor_obj, 2, mp_g_atomic_pointer_xor, g_atomic_pointer_xor);

 

/*
 * dbus extension definition for:
 * extern gint g_atomic_int_exchange_and_add(volatile gint *atomic, gint val)
 */
 
STATIC mp_obj_t mp_g_atomic_int_exchange_and_add(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile gint *atomic = mp_to_ptr(mp_args[0]);
    gint val = (int)mp_obj_get_int(mp_args[1]);
    gint res = g_atomic_int_exchange_and_add(atomic, val);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atomic_int_exchange_and_add_obj, 2, mp_g_atomic_int_exchange_and_add, g_atomic_int_exchange_and_add);

 

/*
 * dbus extension definition for:
 * extern GQuark g_quark_try_string(const gchar *string)
 */
 
STATIC mp_obj_t mp_g_quark_try_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *string = (char*)mp_obj_str_get_str(mp_args[0]);
    GQuark res = g_quark_try_string(string);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_quark_try_string_obj, 1, mp_g_quark_try_string, g_quark_try_string);

 

/*
 * dbus extension definition for:
 * extern GQuark g_quark_from_static_string(const gchar *string)
 */
 
STATIC mp_obj_t mp_g_quark_from_static_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *string = (char*)mp_obj_str_get_str(mp_args[0]);
    GQuark res = g_quark_from_static_string(string);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_quark_from_static_string_obj, 1, mp_g_quark_from_static_string, g_quark_from_static_string);

 

/*
 * dbus extension definition for:
 * extern GQuark g_quark_from_string(const gchar *string)
 */
 
STATIC mp_obj_t mp_g_quark_from_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *string = (char*)mp_obj_str_get_str(mp_args[0]);
    GQuark res = g_quark_from_string(string);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_quark_from_string_obj, 1, mp_g_quark_from_string, g_quark_from_string);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_quark_to_string(GQuark quark)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_intern_string(const gchar *string)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_intern_static_string(const gchar *string)
 */
    

/*
 * dbus extension definition for:
 * extern GError *g_error_new(GQuark domain, gint code, const gchar *format, ...)
 */
 
STATIC mp_obj_t mp_g_error_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GQuark domain = (unsigned int)mp_obj_get_int(mp_args[0]);
    gint code = (int)mp_obj_get_int(mp_args[1]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[2]);
    GError * res = g_error_new(domain, code, format);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_error_new_obj, 4, mp_g_error_new, g_error_new);

 

/*
 * dbus extension definition for:
 * extern GError *g_error_new_literal(GQuark domain, gint code, const gchar *message)
 */
 
STATIC mp_obj_t mp_g_error_new_literal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GQuark domain = (unsigned int)mp_obj_get_int(mp_args[0]);
    gint code = (int)mp_obj_get_int(mp_args[1]);
    const gchar *message = (char*)mp_obj_str_get_str(mp_args[2]);
    GError * res = g_error_new_literal(domain, code, message);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_error_new_literal_obj, 3, mp_g_error_new_literal, g_error_new_literal);

 

/*
 * dbus extension definition for:
 * extern GError *g_error_new_valist(GQuark domain, gint code, const gchar *format, va_list args)
 */
 
STATIC mp_obj_t mp_g_error_new_valist(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GQuark domain = (unsigned int)mp_obj_get_int(mp_args[0]);
    gint code = (int)mp_obj_get_int(mp_args[1]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[2]);
    va_list args = mp_to_ptr(mp_args[3]);
    GError * res = g_error_new_valist(domain, code, format, args);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_error_new_valist_obj, 4, mp_g_error_new_valist, g_error_new_valist);

 

/*
 * dbus extension definition for:
 * extern void g_error_free(GError *error)
 */
 
STATIC mp_obj_t mp_g_error_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GError *error = mp_to_ptr(mp_args[0]);
    g_error_free(error);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_error_free_obj, 1, mp_g_error_free, g_error_free);

 

/*
 * dbus extension definition for:
 * extern GError *g_error_copy(const GError *error)
 */
 
STATIC mp_obj_t mp_g_error_copy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GError *error = mp_to_ptr(mp_args[0]);
    GError * res = g_error_copy(error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_error_copy_obj, 1, mp_g_error_copy, g_error_copy);

 

/*
 * dbus extension definition for:
 * extern gboolean g_error_matches(const GError *error, GQuark domain, gint code)
 */
 
STATIC mp_obj_t mp_g_error_matches(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GError *error = mp_to_ptr(mp_args[0]);
    GQuark domain = (unsigned int)mp_obj_get_int(mp_args[1]);
    gint code = (int)mp_obj_get_int(mp_args[2]);
    gboolean res = g_error_matches(error, domain, code);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_error_matches_obj, 3, mp_g_error_matches, g_error_matches);

 

/*
 * dbus extension definition for:
 * extern void g_set_error(GError **err, GQuark domain, gint code, const gchar *format, ...)
 */
 
STATIC mp_obj_t mp_g_set_error(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GError **err = mp_to_ptr(mp_args[0]);
    GQuark domain = (unsigned int)mp_obj_get_int(mp_args[1]);
    gint code = (int)mp_obj_get_int(mp_args[2]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[3]);
    g_set_error(err, domain, code, format);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_set_error_obj, 5, mp_g_set_error, g_set_error);

 

/*
 * dbus extension definition for:
 * extern void g_set_error_literal(GError **err, GQuark domain, gint code, const gchar *message)
 */
 
STATIC mp_obj_t mp_g_set_error_literal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GError **err = mp_to_ptr(mp_args[0]);
    GQuark domain = (unsigned int)mp_obj_get_int(mp_args[1]);
    gint code = (int)mp_obj_get_int(mp_args[2]);
    const gchar *message = (char*)mp_obj_str_get_str(mp_args[3]);
    g_set_error_literal(err, domain, code, message);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_set_error_literal_obj, 4, mp_g_set_error_literal, g_set_error_literal);

 

/*
 * dbus extension definition for:
 * extern void g_propagate_error(GError **dest, GError *src)
 */
 
STATIC mp_obj_t mp_g_propagate_error(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GError **dest = mp_to_ptr(mp_args[0]);
    GError *src = mp_to_ptr(mp_args[1]);
    g_propagate_error(dest, src);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_propagate_error_obj, 2, mp_g_propagate_error, g_propagate_error);

 

/*
 * dbus extension definition for:
 * extern void g_clear_error(GError **err)
 */
 
STATIC mp_obj_t mp_g_clear_error(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GError **err = mp_to_ptr(mp_args[0]);
    g_clear_error(err);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_clear_error_obj, 1, mp_g_clear_error, g_clear_error);

 

/*
 * dbus extension definition for:
 * extern void g_prefix_error(GError **err, const gchar *format, ...)
 */
 
STATIC mp_obj_t mp_g_prefix_error(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GError **err = mp_to_ptr(mp_args[0]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[1]);
    g_prefix_error(err, format);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_prefix_error_obj, 3, mp_g_prefix_error, g_prefix_error);

 

/*
 * dbus extension definition for:
 * extern void g_propagate_prefixed_error(GError **dest, GError *src, const gchar *format, ...)
 */
 
STATIC mp_obj_t mp_g_propagate_prefixed_error(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GError **dest = mp_to_ptr(mp_args[0]);
    GError *src = mp_to_ptr(mp_args[1]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[2]);
    g_propagate_prefixed_error(dest, src, format);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_propagate_prefixed_error_obj, 4, mp_g_propagate_prefixed_error, g_propagate_prefixed_error);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_user_name(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_real_name(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_home_dir(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_tmp_dir(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_host_name(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_prgname(void)
 */
    

/*
 * dbus extension definition for:
 * extern void g_set_prgname(const gchar *prgname)
 */
 
STATIC mp_obj_t mp_g_set_prgname(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *prgname = (char*)mp_obj_str_get_str(mp_args[0]);
    g_set_prgname(prgname);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_set_prgname_obj, 1, mp_g_set_prgname, g_set_prgname);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_application_name(void)
 */
    

/*
 * dbus extension definition for:
 * extern void g_set_application_name(const gchar *application_name)
 */
 
STATIC mp_obj_t mp_g_set_application_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *application_name = (char*)mp_obj_str_get_str(mp_args[0]);
    g_set_application_name(application_name);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_set_application_name_obj, 1, mp_g_set_application_name, g_set_application_name);

 

/*
 * dbus extension definition for:
 * extern void g_reload_user_special_dirs_cache(void)
 */
 
STATIC mp_obj_t mp_g_reload_user_special_dirs_cache(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    g_reload_user_special_dirs_cache();
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_reload_user_special_dirs_cache_obj, 0, mp_g_reload_user_special_dirs_cache, g_reload_user_special_dirs_cache);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_user_data_dir(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_user_config_dir(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_user_cache_dir(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar * const *
 * extern const gchar * const *g_get_system_data_dirs(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar * const *
 * extern const gchar * const *g_get_system_config_dirs(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_user_runtime_dir(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_get_user_special_dir(GUserDirectory directory)
 */
    

/*
 * dbus extension definition for:
 * extern guint g_parse_debug_string(const gchar *string, const GDebugKey *keys, guint nkeys)
 */
 
STATIC mp_obj_t mp_g_parse_debug_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *string = (char*)mp_obj_str_get_str(mp_args[0]);
    const GDebugKey *keys = mp_to_ptr(mp_args[1]);
    guint nkeys = (unsigned int)mp_obj_get_int(mp_args[2]);
    guint res = g_parse_debug_string(string, keys, nkeys);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_parse_debug_string_obj, 3, mp_g_parse_debug_string, g_parse_debug_string);

 

/*
 * dbus extension definition for:
 * extern gint g_snprintf(gchar *string, gulong n, const gchar *format, ...)
 */
 
STATIC mp_obj_t mp_g_snprintf(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar *string = (char*)mp_obj_str_get_str(mp_args[0]);
    gulong n = (unsigned long)mp_obj_get_int(mp_args[1]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[2]);
    gint res = g_snprintf(string, n, format);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_snprintf_obj, 4, mp_g_snprintf, g_snprintf);

 

/*
 * dbus extension definition for:
 * extern gint g_vsnprintf(gchar *string, gulong n, const gchar *format, va_list args)
 */
 
STATIC mp_obj_t mp_g_vsnprintf(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar *string = (char*)mp_obj_str_get_str(mp_args[0]);
    gulong n = (unsigned long)mp_obj_get_int(mp_args[1]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[2]);
    va_list args = mp_to_ptr(mp_args[3]);
    gint res = g_vsnprintf(string, n, format, args);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_vsnprintf_obj, 4, mp_g_vsnprintf, g_vsnprintf);

 

/*
 * dbus extension definition for:
 * extern void g_nullify_pointer(gpointer *nullify_location)
 */
 
STATIC mp_obj_t mp_g_nullify_pointer(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer *nullify_location = mp_to_ptr(mp_args[0]);
    g_nullify_pointer(nullify_location);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_nullify_pointer_obj, 1, mp_g_nullify_pointer, g_nullify_pointer);

 

/*
 * dbus extension definition for:
 * extern gchar *g_format_size_full(guint64 size, GFormatSizeFlags flags)
 */
 
STATIC mp_obj_t mp_g_format_size_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint64 size = (unsigned long)mp_obj_get_int(mp_args[0]);
    GFormatSizeFlags flags = (int)mp_obj_get_int(mp_args[1]);
    gchar * res = g_format_size_full(size, flags);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_format_size_full_obj, 2, mp_g_format_size_full, g_format_size_full);

 

/*
 * dbus extension definition for:
 * extern gchar *g_format_size(guint64 size)
 */
 
STATIC mp_obj_t mp_g_format_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint64 size = (unsigned long)mp_obj_get_int(mp_args[0]);
    gchar * res = g_format_size(size);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_format_size_obj, 1, mp_g_format_size, g_format_size);

 

/*
 * Function NOT generated:
 * Missing conversion to goffset
 * extern gchar *g_format_size_for_display(goffset size)
 */
    

/*
 * Function NOT generated:
 * Callback argument 'GVoidFunc func' cannot be the first argument! We assume the first argument contains the user_data
 * GVoidFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_atexit(GVoidFunc func)
 */
 
STATIC mp_obj_t mp_g_atexit(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GVoidFunc func = mp_to_ptr(mp_args[0]);
    g_atexit(func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_atexit_obj, 1, mp_g_atexit, g_atexit);

 

/*
 * dbus extension definition for:
 * extern gchar *g_find_program_in_path(const gchar *program)
 */
 
STATIC mp_obj_t mp_g_find_program_in_path(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *program = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_find_program_in_path(program);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_find_program_in_path_obj, 1, mp_g_find_program_in_path, g_find_program_in_path);

 

/*
 * dbus extension definition for:
 * extern gint g_bit_nth_lsf(gulong mask, gint nth_bit)
 */
 
STATIC mp_obj_t mp_g_bit_nth_lsf(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gulong mask = (unsigned long)mp_obj_get_int(mp_args[0]);
    gint nth_bit = (int)mp_obj_get_int(mp_args[1]);
    gint res = g_bit_nth_lsf(mask, nth_bit);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bit_nth_lsf_obj, 2, mp_g_bit_nth_lsf, g_bit_nth_lsf);

 

/*
 * dbus extension definition for:
 * extern gint g_bit_nth_msf(gulong mask, gint nth_bit)
 */
 
STATIC mp_obj_t mp_g_bit_nth_msf(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gulong mask = (unsigned long)mp_obj_get_int(mp_args[0]);
    gint nth_bit = (int)mp_obj_get_int(mp_args[1]);
    gint res = g_bit_nth_msf(mask, nth_bit);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bit_nth_msf_obj, 2, mp_g_bit_nth_msf, g_bit_nth_msf);

 

/*
 * dbus extension definition for:
 * extern guint g_bit_storage(gulong number)
 */
 
STATIC mp_obj_t mp_g_bit_storage(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gulong number = (unsigned long)mp_obj_get_int(mp_args[0]);
    guint res = g_bit_storage(number);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bit_storage_obj, 1, mp_g_bit_storage, g_bit_storage);

 

/*
 * dbus extension definition for:
 * extern GQuark g_thread_error_quark(void)
 */
 
STATIC mp_obj_t mp_g_thread_error_quark(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GQuark res = g_thread_error_quark();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_thread_error_quark_obj, 0, mp_g_thread_error_quark, g_thread_error_quark);

 

/*
 * dbus extension definition for:
 * extern GThread *g_thread_ref(GThread *thread)
 */
 
STATIC mp_obj_t mp_g_thread_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GThread *thread = mp_to_ptr(mp_args[0]);
    GThread * res = g_thread_ref(thread);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_thread_ref_obj, 1, mp_g_thread_ref, g_thread_ref);

 

/*
 * dbus extension definition for:
 * extern void g_thread_unref(GThread *thread)
 */
 
STATIC mp_obj_t mp_g_thread_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GThread *thread = mp_to_ptr(mp_args[0]);
    g_thread_unref(thread);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_thread_unref_obj, 1, mp_g_thread_unref, g_thread_unref);

 

/*
 * Function NOT generated:
 * Callback function 'GThreadFunc func' must receive a struct pointer with user_data member as its first argument!
 * GThreadFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GThread *g_thread_new(const gchar *name, GThreadFunc func, gpointer data)
 */
 
STATIC mp_obj_t mp_g_thread_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *name = (char*)mp_obj_str_get_str(mp_args[0]);
    GThreadFunc func = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GThread * res = g_thread_new(name, func, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_thread_new_obj, 3, mp_g_thread_new, g_thread_new);

 

/*
 * Function NOT generated:
 * Callback function 'GThreadFunc func' must receive a struct pointer with user_data member as its first argument!
 * GThreadFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GThread *g_thread_try_new(const gchar *name, GThreadFunc func, gpointer data, GError **error)
 */
 
STATIC mp_obj_t mp_g_thread_try_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *name = (char*)mp_obj_str_get_str(mp_args[0]);
    GThreadFunc func = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    GThread * res = g_thread_try_new(name, func, data, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_thread_try_new_obj, 4, mp_g_thread_try_new, g_thread_try_new);

 

/*
 * dbus extension definition for:
 * extern GThread *g_thread_self(void)
 */
 
STATIC mp_obj_t mp_g_thread_self(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GThread * res = g_thread_self();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_thread_self_obj, 0, mp_g_thread_self, g_thread_self);

 

/*
 * dbus extension definition for:
 * extern void g_thread_exit(gpointer retval)
 */
 
STATIC mp_obj_t mp_g_thread_exit(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer retval = mp_to_ptr(mp_args[0]);
    g_thread_exit(retval);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_thread_exit_obj, 1, mp_g_thread_exit, g_thread_exit);

 

/*
 * dbus extension definition for:
 * extern gpointer g_thread_join(GThread *thread)
 */
 
STATIC mp_obj_t mp_g_thread_join(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GThread *thread = mp_to_ptr(mp_args[0]);
    gpointer res = g_thread_join(thread);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_thread_join_obj, 1, mp_g_thread_join, g_thread_join);

 

/*
 * dbus extension definition for:
 * extern void g_thread_yield(void)
 */
 
STATIC mp_obj_t mp_g_thread_yield(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    g_thread_yield();
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_thread_yield_obj, 0, mp_g_thread_yield, g_thread_yield);

 

/*
 * dbus extension definition for:
 * extern void g_mutex_init(GMutex *mutex)
 */
 
STATIC mp_obj_t mp_g_mutex_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMutex *mutex = mp_to_ptr(mp_args[0]);
    g_mutex_init(mutex);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mutex_init_obj, 1, mp_g_mutex_init, g_mutex_init);

 

/*
 * dbus extension definition for:
 * extern void g_mutex_clear(GMutex *mutex)
 */
 
STATIC mp_obj_t mp_g_mutex_clear(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMutex *mutex = mp_to_ptr(mp_args[0]);
    g_mutex_clear(mutex);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mutex_clear_obj, 1, mp_g_mutex_clear, g_mutex_clear);

 

/*
 * dbus extension definition for:
 * extern void g_mutex_lock(GMutex *mutex)
 */
 
STATIC mp_obj_t mp_g_mutex_lock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMutex *mutex = mp_to_ptr(mp_args[0]);
    g_mutex_lock(mutex);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mutex_lock_obj, 1, mp_g_mutex_lock, g_mutex_lock);

 

/*
 * dbus extension definition for:
 * extern gboolean g_mutex_trylock(GMutex *mutex)
 */
 
STATIC mp_obj_t mp_g_mutex_trylock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMutex *mutex = mp_to_ptr(mp_args[0]);
    gboolean res = g_mutex_trylock(mutex);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mutex_trylock_obj, 1, mp_g_mutex_trylock, g_mutex_trylock);

 

/*
 * dbus extension definition for:
 * extern void g_mutex_unlock(GMutex *mutex)
 */
 
STATIC mp_obj_t mp_g_mutex_unlock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMutex *mutex = mp_to_ptr(mp_args[0]);
    g_mutex_unlock(mutex);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mutex_unlock_obj, 1, mp_g_mutex_unlock, g_mutex_unlock);

 

/*
 * dbus extension definition for:
 * extern void g_rw_lock_init(GRWLock *rw_lock)
 */
 
STATIC mp_obj_t mp_g_rw_lock_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRWLock *rw_lock = mp_to_ptr(mp_args[0]);
    g_rw_lock_init(rw_lock);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rw_lock_init_obj, 1, mp_g_rw_lock_init, g_rw_lock_init);

 

/*
 * dbus extension definition for:
 * extern void g_rw_lock_clear(GRWLock *rw_lock)
 */
 
STATIC mp_obj_t mp_g_rw_lock_clear(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRWLock *rw_lock = mp_to_ptr(mp_args[0]);
    g_rw_lock_clear(rw_lock);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rw_lock_clear_obj, 1, mp_g_rw_lock_clear, g_rw_lock_clear);

 

/*
 * dbus extension definition for:
 * extern void g_rw_lock_writer_lock(GRWLock *rw_lock)
 */
 
STATIC mp_obj_t mp_g_rw_lock_writer_lock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRWLock *rw_lock = mp_to_ptr(mp_args[0]);
    g_rw_lock_writer_lock(rw_lock);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rw_lock_writer_lock_obj, 1, mp_g_rw_lock_writer_lock, g_rw_lock_writer_lock);

 

/*
 * dbus extension definition for:
 * extern gboolean g_rw_lock_writer_trylock(GRWLock *rw_lock)
 */
 
STATIC mp_obj_t mp_g_rw_lock_writer_trylock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRWLock *rw_lock = mp_to_ptr(mp_args[0]);
    gboolean res = g_rw_lock_writer_trylock(rw_lock);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rw_lock_writer_trylock_obj, 1, mp_g_rw_lock_writer_trylock, g_rw_lock_writer_trylock);

 

/*
 * dbus extension definition for:
 * extern void g_rw_lock_writer_unlock(GRWLock *rw_lock)
 */
 
STATIC mp_obj_t mp_g_rw_lock_writer_unlock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRWLock *rw_lock = mp_to_ptr(mp_args[0]);
    g_rw_lock_writer_unlock(rw_lock);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rw_lock_writer_unlock_obj, 1, mp_g_rw_lock_writer_unlock, g_rw_lock_writer_unlock);

 

/*
 * dbus extension definition for:
 * extern void g_rw_lock_reader_lock(GRWLock *rw_lock)
 */
 
STATIC mp_obj_t mp_g_rw_lock_reader_lock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRWLock *rw_lock = mp_to_ptr(mp_args[0]);
    g_rw_lock_reader_lock(rw_lock);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rw_lock_reader_lock_obj, 1, mp_g_rw_lock_reader_lock, g_rw_lock_reader_lock);

 

/*
 * dbus extension definition for:
 * extern gboolean g_rw_lock_reader_trylock(GRWLock *rw_lock)
 */
 
STATIC mp_obj_t mp_g_rw_lock_reader_trylock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRWLock *rw_lock = mp_to_ptr(mp_args[0]);
    gboolean res = g_rw_lock_reader_trylock(rw_lock);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rw_lock_reader_trylock_obj, 1, mp_g_rw_lock_reader_trylock, g_rw_lock_reader_trylock);

 

/*
 * dbus extension definition for:
 * extern void g_rw_lock_reader_unlock(GRWLock *rw_lock)
 */
 
STATIC mp_obj_t mp_g_rw_lock_reader_unlock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRWLock *rw_lock = mp_to_ptr(mp_args[0]);
    g_rw_lock_reader_unlock(rw_lock);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rw_lock_reader_unlock_obj, 1, mp_g_rw_lock_reader_unlock, g_rw_lock_reader_unlock);

 

/*
 * dbus extension definition for:
 * extern void g_rec_mutex_init(GRecMutex *rec_mutex)
 */
 
STATIC mp_obj_t mp_g_rec_mutex_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRecMutex *rec_mutex = mp_to_ptr(mp_args[0]);
    g_rec_mutex_init(rec_mutex);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rec_mutex_init_obj, 1, mp_g_rec_mutex_init, g_rec_mutex_init);

 

/*
 * dbus extension definition for:
 * extern void g_rec_mutex_clear(GRecMutex *rec_mutex)
 */
 
STATIC mp_obj_t mp_g_rec_mutex_clear(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRecMutex *rec_mutex = mp_to_ptr(mp_args[0]);
    g_rec_mutex_clear(rec_mutex);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rec_mutex_clear_obj, 1, mp_g_rec_mutex_clear, g_rec_mutex_clear);

 

/*
 * dbus extension definition for:
 * extern void g_rec_mutex_lock(GRecMutex *rec_mutex)
 */
 
STATIC mp_obj_t mp_g_rec_mutex_lock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRecMutex *rec_mutex = mp_to_ptr(mp_args[0]);
    g_rec_mutex_lock(rec_mutex);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rec_mutex_lock_obj, 1, mp_g_rec_mutex_lock, g_rec_mutex_lock);

 

/*
 * dbus extension definition for:
 * extern gboolean g_rec_mutex_trylock(GRecMutex *rec_mutex)
 */
 
STATIC mp_obj_t mp_g_rec_mutex_trylock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRecMutex *rec_mutex = mp_to_ptr(mp_args[0]);
    gboolean res = g_rec_mutex_trylock(rec_mutex);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rec_mutex_trylock_obj, 1, mp_g_rec_mutex_trylock, g_rec_mutex_trylock);

 

/*
 * dbus extension definition for:
 * extern void g_rec_mutex_unlock(GRecMutex *rec_mutex)
 */
 
STATIC mp_obj_t mp_g_rec_mutex_unlock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GRecMutex *rec_mutex = mp_to_ptr(mp_args[0]);
    g_rec_mutex_unlock(rec_mutex);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_rec_mutex_unlock_obj, 1, mp_g_rec_mutex_unlock, g_rec_mutex_unlock);

 

/*
 * dbus extension definition for:
 * extern void g_cond_init(GCond *cond)
 */
 
STATIC mp_obj_t mp_g_cond_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GCond *cond = mp_to_ptr(mp_args[0]);
    g_cond_init(cond);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_cond_init_obj, 1, mp_g_cond_init, g_cond_init);

 

/*
 * dbus extension definition for:
 * extern void g_cond_clear(GCond *cond)
 */
 
STATIC mp_obj_t mp_g_cond_clear(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GCond *cond = mp_to_ptr(mp_args[0]);
    g_cond_clear(cond);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_cond_clear_obj, 1, mp_g_cond_clear, g_cond_clear);

 

/*
 * dbus extension definition for:
 * extern void g_cond_wait(GCond *cond, GMutex *mutex)
 */
 
STATIC mp_obj_t mp_g_cond_wait(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GCond *cond = mp_to_ptr(mp_args[0]);
    GMutex *mutex = mp_to_ptr(mp_args[1]);
    g_cond_wait(cond, mutex);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_cond_wait_obj, 2, mp_g_cond_wait, g_cond_wait);

 

/*
 * dbus extension definition for:
 * extern void g_cond_signal(GCond *cond)
 */
 
STATIC mp_obj_t mp_g_cond_signal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GCond *cond = mp_to_ptr(mp_args[0]);
    g_cond_signal(cond);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_cond_signal_obj, 1, mp_g_cond_signal, g_cond_signal);

 

/*
 * dbus extension definition for:
 * extern void g_cond_broadcast(GCond *cond)
 */
 
STATIC mp_obj_t mp_g_cond_broadcast(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GCond *cond = mp_to_ptr(mp_args[0]);
    g_cond_broadcast(cond);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_cond_broadcast_obj, 1, mp_g_cond_broadcast, g_cond_broadcast);

 

/*
 * Function NOT generated:
 * Missing conversion to gint64
 * extern gboolean g_cond_wait_until(GCond *cond, GMutex *mutex, gint64 end_time)
 */
    

/*
 * dbus extension definition for:
 * extern gpointer g_private_get(GPrivate *key)
 */
 
STATIC mp_obj_t mp_g_private_get(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPrivate *key = mp_to_ptr(mp_args[0]);
    gpointer res = g_private_get(key);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_private_get_obj, 1, mp_g_private_get, g_private_get);

 

/*
 * dbus extension definition for:
 * extern void g_private_set(GPrivate *key, gpointer value)
 */
 
STATIC mp_obj_t mp_g_private_set(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPrivate *key = mp_to_ptr(mp_args[0]);
    gpointer value = mp_to_ptr(mp_args[1]);
    g_private_set(key, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_private_set_obj, 2, mp_g_private_set, g_private_set);

 

/*
 * dbus extension definition for:
 * extern void g_private_replace(GPrivate *key, gpointer value)
 */
 
STATIC mp_obj_t mp_g_private_replace(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPrivate *key = mp_to_ptr(mp_args[0]);
    gpointer value = mp_to_ptr(mp_args[1]);
    g_private_replace(key, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_private_replace_obj, 2, mp_g_private_replace, g_private_replace);

 

/*
 * Function NOT generated:
 * Callback function 'GThreadFunc func' must receive a struct pointer with user_data member as its first argument!
 * GThreadFunc func
 */
    

/*
 * dbus extension definition for:
 * extern gpointer g_once_impl(GOnce *once, GThreadFunc func, gpointer arg)
 */
 
STATIC mp_obj_t mp_g_once_impl(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOnce *once = mp_to_ptr(mp_args[0]);
    GThreadFunc func = mp_to_ptr(mp_args[1]);
    gpointer arg = mp_to_ptr(mp_args[2]);
    gpointer res = g_once_impl(once, func, arg);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_once_impl_obj, 3, mp_g_once_impl, g_once_impl);

 

/*
 * dbus extension definition for:
 * extern gboolean g_once_init_enter(volatile void *location)
 */
 
STATIC mp_obj_t mp_g_once_init_enter(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile void *location = mp_to_ptr(mp_args[0]);
    gboolean res = g_once_init_enter(location);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_once_init_enter_obj, 1, mp_g_once_init_enter, g_once_init_enter);

 

/*
 * dbus extension definition for:
 * extern void g_once_init_leave(volatile void *location, gsize result)
 */
 
STATIC mp_obj_t mp_g_once_init_leave(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile void *location = mp_to_ptr(mp_args[0]);
    gsize result = (unsigned long)mp_obj_get_int(mp_args[1]);
    g_once_init_leave(location, result);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_once_init_leave_obj, 2, mp_g_once_init_leave, g_once_init_leave);

 

/*
 * dbus extension definition for:
 * extern guint g_get_num_processors(void)
 */
 
STATIC mp_obj_t mp_g_get_num_processors(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    guint res = g_get_num_processors();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_get_num_processors_obj, 0, mp_g_get_num_processors, g_get_num_processors);

 

/*
 * dbus extension definition for:
 * extern GAsyncQueue *g_async_queue_new(void)
 */
 
STATIC mp_obj_t mp_g_async_queue_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GAsyncQueue * res = g_async_queue_new();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_new_obj, 0, mp_g_async_queue_new, g_async_queue_new);

 

/*
 * Function NOT generated:
 * Callback argument 'GDestroyNotify item_free_func' cannot be the first argument! We assume the first argument contains the user_data
 * GDestroyNotify item_free_func
 */
    

/*
 * dbus extension definition for:
 * extern GAsyncQueue *g_async_queue_new_full(GDestroyNotify item_free_func)
 */
 
STATIC mp_obj_t mp_g_async_queue_new_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDestroyNotify item_free_func = mp_to_ptr(mp_args[0]);
    GAsyncQueue * res = g_async_queue_new_full(item_free_func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_new_full_obj, 1, mp_g_async_queue_new_full, g_async_queue_new_full);

 

/*
 * dbus extension definition for:
 * extern void g_async_queue_lock(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_lock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    g_async_queue_lock(queue);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_lock_obj, 1, mp_g_async_queue_lock, g_async_queue_lock);

 

/*
 * dbus extension definition for:
 * extern void g_async_queue_unlock(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_unlock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    g_async_queue_unlock(queue);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_unlock_obj, 1, mp_g_async_queue_unlock, g_async_queue_unlock);

 

/*
 * dbus extension definition for:
 * extern GAsyncQueue *g_async_queue_ref(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    GAsyncQueue * res = g_async_queue_ref(queue);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_ref_obj, 1, mp_g_async_queue_ref, g_async_queue_ref);

 

/*
 * dbus extension definition for:
 * extern void g_async_queue_unref(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    g_async_queue_unref(queue);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_unref_obj, 1, mp_g_async_queue_unref, g_async_queue_unref);

 

/*
 * dbus extension definition for:
 * extern void g_async_queue_ref_unlocked(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_ref_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    g_async_queue_ref_unlocked(queue);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_ref_unlocked_obj, 1, mp_g_async_queue_ref_unlocked, g_async_queue_ref_unlocked);

 

/*
 * dbus extension definition for:
 * extern void g_async_queue_unref_and_unlock(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_unref_and_unlock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    g_async_queue_unref_and_unlock(queue);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_unref_and_unlock_obj, 1, mp_g_async_queue_unref_and_unlock, g_async_queue_unref_and_unlock);

 

/*
 * dbus extension definition for:
 * extern void g_async_queue_push(GAsyncQueue *queue, gpointer data)
 */
 
STATIC mp_obj_t mp_g_async_queue_push(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    g_async_queue_push(queue, data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_push_obj, 2, mp_g_async_queue_push, g_async_queue_push);

 

/*
 * dbus extension definition for:
 * extern void g_async_queue_push_unlocked(GAsyncQueue *queue, gpointer data)
 */
 
STATIC mp_obj_t mp_g_async_queue_push_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    g_async_queue_push_unlocked(queue, data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_push_unlocked_obj, 2, mp_g_async_queue_push_unlocked, g_async_queue_push_unlocked);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_async_queue_push_sorted(GAsyncQueue *queue, gpointer data, GCompareDataFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_async_queue_push_sorted(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    GCompareDataFunc func = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    g_async_queue_push_sorted(queue, data, func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_push_sorted_obj, 4, mp_g_async_queue_push_sorted, g_async_queue_push_sorted);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_async_queue_push_sorted_unlocked(GAsyncQueue *queue, gpointer data, GCompareDataFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_async_queue_push_sorted_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    GCompareDataFunc func = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    g_async_queue_push_sorted_unlocked(queue, data, func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_push_sorted_unlocked_obj, 4, mp_g_async_queue_push_sorted_unlocked, g_async_queue_push_sorted_unlocked);

 

/*
 * dbus extension definition for:
 * extern gpointer g_async_queue_pop(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_pop(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer res = g_async_queue_pop(queue);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_pop_obj, 1, mp_g_async_queue_pop, g_async_queue_pop);

 

/*
 * dbus extension definition for:
 * extern gpointer g_async_queue_pop_unlocked(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_pop_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer res = g_async_queue_pop_unlocked(queue);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_pop_unlocked_obj, 1, mp_g_async_queue_pop_unlocked, g_async_queue_pop_unlocked);

 

/*
 * dbus extension definition for:
 * extern gpointer g_async_queue_try_pop(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_try_pop(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer res = g_async_queue_try_pop(queue);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_try_pop_obj, 1, mp_g_async_queue_try_pop, g_async_queue_try_pop);

 

/*
 * dbus extension definition for:
 * extern gpointer g_async_queue_try_pop_unlocked(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_try_pop_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer res = g_async_queue_try_pop_unlocked(queue);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_try_pop_unlocked_obj, 1, mp_g_async_queue_try_pop_unlocked, g_async_queue_try_pop_unlocked);

 

/*
 * dbus extension definition for:
 * extern gpointer g_async_queue_timeout_pop(GAsyncQueue *queue, guint64 timeout)
 */
 
STATIC mp_obj_t mp_g_async_queue_timeout_pop(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    guint64 timeout = (unsigned long)mp_obj_get_int(mp_args[1]);
    gpointer res = g_async_queue_timeout_pop(queue, timeout);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_timeout_pop_obj, 2, mp_g_async_queue_timeout_pop, g_async_queue_timeout_pop);

 

/*
 * dbus extension definition for:
 * extern gpointer g_async_queue_timeout_pop_unlocked(GAsyncQueue *queue, guint64 timeout)
 */
 
STATIC mp_obj_t mp_g_async_queue_timeout_pop_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    guint64 timeout = (unsigned long)mp_obj_get_int(mp_args[1]);
    gpointer res = g_async_queue_timeout_pop_unlocked(queue, timeout);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_timeout_pop_unlocked_obj, 2, mp_g_async_queue_timeout_pop_unlocked, g_async_queue_timeout_pop_unlocked);

 

/*
 * dbus extension definition for:
 * extern gint g_async_queue_length(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_length(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gint res = g_async_queue_length(queue);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_length_obj, 1, mp_g_async_queue_length, g_async_queue_length);

 

/*
 * dbus extension definition for:
 * extern gint g_async_queue_length_unlocked(GAsyncQueue *queue)
 */
 
STATIC mp_obj_t mp_g_async_queue_length_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gint res = g_async_queue_length_unlocked(queue);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_length_unlocked_obj, 1, mp_g_async_queue_length_unlocked, g_async_queue_length_unlocked);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_async_queue_sort(GAsyncQueue *queue, GCompareDataFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_async_queue_sort(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    GCompareDataFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_async_queue_sort(queue, func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_sort_obj, 3, mp_g_async_queue_sort, g_async_queue_sort);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_async_queue_sort_unlocked(GAsyncQueue *queue, GCompareDataFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_async_queue_sort_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    GCompareDataFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_async_queue_sort_unlocked(queue, func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_sort_unlocked_obj, 3, mp_g_async_queue_sort_unlocked, g_async_queue_sort_unlocked);

 

/*
 * dbus extension definition for:
 * extern gboolean g_async_queue_remove(GAsyncQueue *queue, gpointer item)
 */
 
STATIC mp_obj_t mp_g_async_queue_remove(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer item = mp_to_ptr(mp_args[1]);
    gboolean res = g_async_queue_remove(queue, item);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_remove_obj, 2, mp_g_async_queue_remove, g_async_queue_remove);

 

/*
 * dbus extension definition for:
 * extern gboolean g_async_queue_remove_unlocked(GAsyncQueue *queue, gpointer item)
 */
 
STATIC mp_obj_t mp_g_async_queue_remove_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer item = mp_to_ptr(mp_args[1]);
    gboolean res = g_async_queue_remove_unlocked(queue, item);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_remove_unlocked_obj, 2, mp_g_async_queue_remove_unlocked, g_async_queue_remove_unlocked);

 

/*
 * dbus extension definition for:
 * extern void g_async_queue_push_front(GAsyncQueue *queue, gpointer item)
 */
 
STATIC mp_obj_t mp_g_async_queue_push_front(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer item = mp_to_ptr(mp_args[1]);
    g_async_queue_push_front(queue, item);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_push_front_obj, 2, mp_g_async_queue_push_front, g_async_queue_push_front);

 

/*
 * dbus extension definition for:
 * extern void g_async_queue_push_front_unlocked(GAsyncQueue *queue, gpointer item)
 */
 
STATIC mp_obj_t mp_g_async_queue_push_front_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    gpointer item = mp_to_ptr(mp_args[1]);
    g_async_queue_push_front_unlocked(queue, item);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_push_front_unlocked_obj, 2, mp_g_async_queue_push_front_unlocked, g_async_queue_push_front_unlocked);

 

/*
 * dbus extension definition for:
 * extern gpointer g_async_queue_timed_pop(GAsyncQueue *queue, GTimeVal *end_time)
 */
 
STATIC mp_obj_t mp_g_async_queue_timed_pop(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    GTimeVal *end_time = mp_to_ptr(mp_args[1]);
    gpointer res = g_async_queue_timed_pop(queue, end_time);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_timed_pop_obj, 2, mp_g_async_queue_timed_pop, g_async_queue_timed_pop);

 

/*
 * dbus extension definition for:
 * extern gpointer g_async_queue_timed_pop_unlocked(GAsyncQueue *queue, GTimeVal *end_time)
 */
 
STATIC mp_obj_t mp_g_async_queue_timed_pop_unlocked(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GAsyncQueue *queue = mp_to_ptr(mp_args[0]);
    GTimeVal *end_time = mp_to_ptr(mp_args[1]);
    gpointer res = g_async_queue_timed_pop_unlocked(queue, end_time);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_async_queue_timed_pop_unlocked_obj, 2, mp_g_async_queue_timed_pop_unlocked, g_async_queue_timed_pop_unlocked);

 

/*
 * dbus extension definition for:
 * extern int __sigismember(const __sigset_t *, int)
 */
 
STATIC mp_obj_t mp___sigismember(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    int res = __sigismember();
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp___sigismember_obj, 2, mp___sigismember, __sigismember);

 

/*
 * dbus extension definition for:
 * extern int __sigaddset(__sigset_t *, int)
 */
 
STATIC mp_obj_t mp___sigaddset(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    int res = __sigaddset();
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp___sigaddset_obj, 2, mp___sigaddset, __sigaddset);

 

/*
 * dbus extension definition for:
 * extern int __sigdelset(__sigset_t *, int)
 */
 
STATIC mp_obj_t mp___sigdelset(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    int res = __sigdelset();
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp___sigdelset_obj, 2, mp___sigdelset, __sigdelset);

 

/*
 * Function NOT generated:
 * Callback function '__sighandler_t __handler' must receive a struct pointer with user_data member as its first argument!
 * __sighandler_t __handler
 */
    

/*
 * dbus extension definition for:
 * extern __sighandler_t __sysv_signal(int __sig, __sighandler_t __handler)
 */
 
STATIC mp_obj_t mp___sysv_signal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int __sig = (int)mp_obj_get_int(mp_args[0]);
    __sighandler_t __handler = mp_to_ptr(mp_args[1]);
    __sighandler_t res = __sysv_signal(__sig, __handler);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp___sysv_signal_obj, 2, mp___sysv_signal, __sysv_signal);

 

/*
 * Function NOT generated:
 * Callback function '__sighandler_t __handler' must receive a struct pointer with user_data member as its first argument!
 * __sighandler_t __handler
 */
    

/*
 * dbus extension definition for:
 * extern __sighandler_t signal(int __sig, __sighandler_t __handler)
 */
 
STATIC mp_obj_t mp_signal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int __sig = (int)mp_obj_get_int(mp_args[0]);
    __sighandler_t __handler = mp_to_ptr(mp_args[1]);
    __sighandler_t res = signal(__sig, __handler);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_signal_obj, 2, mp_signal, signal);

 

/*
 * dbus extension definition for:
 * extern int raise(int __sig)
 */
 
STATIC mp_obj_t mp_raise(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int __sig = (int)mp_obj_get_int(mp_args[0]);
    int res = raise(__sig);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_raise_obj, 1, mp_raise, raise);

 

/*
 * dbus extension definition for:
 * extern int __libc_current_sigrtmin(void)
 */
 
STATIC mp_obj_t mp___libc_current_sigrtmin(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    int res = __libc_current_sigrtmin();
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp___libc_current_sigrtmin_obj, 0, mp___libc_current_sigrtmin, __libc_current_sigrtmin);

 

/*
 * dbus extension definition for:
 * extern int __libc_current_sigrtmax(void)
 */
 
STATIC mp_obj_t mp___libc_current_sigrtmax(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    int res = __libc_current_sigrtmax();
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp___libc_current_sigrtmax_obj, 0, mp___libc_current_sigrtmax, __libc_current_sigrtmax);

 

/*
 * dbus extension definition for:
 * extern void g_on_error_query(const gchar *prg_name)
 */
 
STATIC mp_obj_t mp_g_on_error_query(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *prg_name = (char*)mp_obj_str_get_str(mp_args[0]);
    g_on_error_query(prg_name);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_on_error_query_obj, 1, mp_g_on_error_query, g_on_error_query);

 

/*
 * dbus extension definition for:
 * extern void g_on_error_stack_trace(const gchar *prg_name)
 */
 
STATIC mp_obj_t mp_g_on_error_stack_trace(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *prg_name = (char*)mp_obj_str_get_str(mp_args[0]);
    g_on_error_stack_trace(prg_name);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_on_error_stack_trace_obj, 1, mp_g_on_error_stack_trace, g_on_error_stack_trace);

 

/*
 * dbus extension definition for:
 * extern gsize g_base64_encode_step(const guchar *in, gsize len, gboolean break_lines, gchar *out, gint *state, gint *save)
 */
 
STATIC mp_obj_t mp_g_base64_encode_step(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const guchar *in = mp_to_ptr(mp_args[0]);
    gsize len = (unsigned long)mp_obj_get_int(mp_args[1]);
    gboolean break_lines = (int)mp_obj_get_int(mp_args[2]);
    gchar *out = (char*)mp_obj_str_get_str(mp_args[3]);
    gint *state = mp_to_ptr(mp_args[4]);
    gint *save = mp_to_ptr(mp_args[5]);
    gsize res = g_base64_encode_step(in, len, break_lines, out, state, save);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_base64_encode_step_obj, 6, mp_g_base64_encode_step, g_base64_encode_step);

 

/*
 * dbus extension definition for:
 * extern gsize g_base64_encode_close(gboolean break_lines, gchar *out, gint *state, gint *save)
 */
 
STATIC mp_obj_t mp_g_base64_encode_close(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gboolean break_lines = (int)mp_obj_get_int(mp_args[0]);
    gchar *out = (char*)mp_obj_str_get_str(mp_args[1]);
    gint *state = mp_to_ptr(mp_args[2]);
    gint *save = mp_to_ptr(mp_args[3]);
    gsize res = g_base64_encode_close(break_lines, out, state, save);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_base64_encode_close_obj, 4, mp_g_base64_encode_close, g_base64_encode_close);

 

/*
 * dbus extension definition for:
 * extern gchar *g_base64_encode(const guchar *data, gsize len)
 */
 
STATIC mp_obj_t mp_g_base64_encode(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const guchar *data = mp_to_ptr(mp_args[0]);
    gsize len = (unsigned long)mp_obj_get_int(mp_args[1]);
    gchar * res = g_base64_encode(data, len);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_base64_encode_obj, 2, mp_g_base64_encode, g_base64_encode);

 

/*
 * dbus extension definition for:
 * extern gsize g_base64_decode_step(const gchar *in, gsize len, guchar *out, gint *state, guint *save)
 */
 
STATIC mp_obj_t mp_g_base64_decode_step(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *in = (char*)mp_obj_str_get_str(mp_args[0]);
    gsize len = (unsigned long)mp_obj_get_int(mp_args[1]);
    guchar *out = mp_to_ptr(mp_args[2]);
    gint *state = mp_to_ptr(mp_args[3]);
    guint *save = mp_to_ptr(mp_args[4]);
    gsize res = g_base64_decode_step(in, len, out, state, save);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_base64_decode_step_obj, 5, mp_g_base64_decode_step, g_base64_decode_step);

 

/*
 * dbus extension definition for:
 * extern guchar *g_base64_decode(const gchar *text, gsize *out_len)
 */
 
STATIC mp_obj_t mp_g_base64_decode(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *text = (char*)mp_obj_str_get_str(mp_args[0]);
    gsize *out_len = mp_to_ptr(mp_args[1]);
    guchar * res = g_base64_decode(text, out_len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_base64_decode_obj, 2, mp_g_base64_decode, g_base64_decode);

 

/*
 * dbus extension definition for:
 * extern guchar *g_base64_decode_inplace(gchar *text, gsize *out_len)
 */
 
STATIC mp_obj_t mp_g_base64_decode_inplace(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar *text = (char*)mp_obj_str_get_str(mp_args[0]);
    gsize *out_len = mp_to_ptr(mp_args[1]);
    guchar * res = g_base64_decode_inplace(text, out_len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_base64_decode_inplace_obj, 2, mp_g_base64_decode_inplace, g_base64_decode_inplace);

 

/*
 * dbus extension definition for:
 * extern void g_bit_lock(volatile gint *address, gint lock_bit)
 */
 
STATIC mp_obj_t mp_g_bit_lock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile gint *address = mp_to_ptr(mp_args[0]);
    gint lock_bit = (int)mp_obj_get_int(mp_args[1]);
    g_bit_lock(address, lock_bit);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bit_lock_obj, 2, mp_g_bit_lock, g_bit_lock);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bit_trylock(volatile gint *address, gint lock_bit)
 */
 
STATIC mp_obj_t mp_g_bit_trylock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile gint *address = mp_to_ptr(mp_args[0]);
    gint lock_bit = (int)mp_obj_get_int(mp_args[1]);
    gboolean res = g_bit_trylock(address, lock_bit);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bit_trylock_obj, 2, mp_g_bit_trylock, g_bit_trylock);

 

/*
 * dbus extension definition for:
 * extern void g_bit_unlock(volatile gint *address, gint lock_bit)
 */
 
STATIC mp_obj_t mp_g_bit_unlock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile gint *address = mp_to_ptr(mp_args[0]);
    gint lock_bit = (int)mp_obj_get_int(mp_args[1]);
    g_bit_unlock(address, lock_bit);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bit_unlock_obj, 2, mp_g_bit_unlock, g_bit_unlock);

 

/*
 * dbus extension definition for:
 * extern void g_pointer_bit_lock(volatile void *address, gint lock_bit)
 */
 
STATIC mp_obj_t mp_g_pointer_bit_lock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile void *address = mp_to_ptr(mp_args[0]);
    gint lock_bit = (int)mp_obj_get_int(mp_args[1]);
    g_pointer_bit_lock(address, lock_bit);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_pointer_bit_lock_obj, 2, mp_g_pointer_bit_lock, g_pointer_bit_lock);

 

/*
 * dbus extension definition for:
 * extern gboolean g_pointer_bit_trylock(volatile void *address, gint lock_bit)
 */
 
STATIC mp_obj_t mp_g_pointer_bit_trylock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile void *address = mp_to_ptr(mp_args[0]);
    gint lock_bit = (int)mp_obj_get_int(mp_args[1]);
    gboolean res = g_pointer_bit_trylock(address, lock_bit);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_pointer_bit_trylock_obj, 2, mp_g_pointer_bit_trylock, g_pointer_bit_trylock);

 

/*
 * dbus extension definition for:
 * extern void g_pointer_bit_unlock(volatile void *address, gint lock_bit)
 */
 
STATIC mp_obj_t mp_g_pointer_bit_unlock(size_t mp_n_args, const mp_obj_t *mp_args)
{
    volatile void *address = mp_to_ptr(mp_args[0]);
    gint lock_bit = (int)mp_obj_get_int(mp_args[1]);
    g_pointer_bit_unlock(address, lock_bit);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_pointer_bit_unlock_obj, 2, mp_g_pointer_bit_unlock, g_pointer_bit_unlock);

 

/*
 * dbus extension definition for:
 * extern GQuark g_bookmark_file_error_quark(void)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_error_quark(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GQuark res = g_bookmark_file_error_quark();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_error_quark_obj, 0, mp_g_bookmark_file_error_quark, g_bookmark_file_error_quark);

 

/*
 * dbus extension definition for:
 * extern GBookmarkFile *g_bookmark_file_new(void)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GBookmarkFile * res = g_bookmark_file_new();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_new_obj, 0, mp_g_bookmark_file_new, g_bookmark_file_new);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_free(GBookmarkFile *bookmark)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    g_bookmark_file_free(bookmark);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_free_obj, 1, mp_g_bookmark_file_free, g_bookmark_file_free);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_load_from_file(GBookmarkFile *bookmark, const gchar *filename, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_load_from_file(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gboolean res = g_bookmark_file_load_from_file(bookmark, filename, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_load_from_file_obj, 3, mp_g_bookmark_file_load_from_file, g_bookmark_file_load_from_file);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_load_from_data(GBookmarkFile *bookmark, const gchar *data, gsize length, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_load_from_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *data = (char*)mp_obj_str_get_str(mp_args[1]);
    gsize length = (unsigned long)mp_obj_get_int(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_bookmark_file_load_from_data(bookmark, data, length, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_load_from_data_obj, 4, mp_g_bookmark_file_load_from_data, g_bookmark_file_load_from_data);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_load_from_data_dirs(GBookmarkFile *bookmark, const gchar *file, gchar **full_path, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_load_from_data_dirs(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *file = (char*)mp_obj_str_get_str(mp_args[1]);
    gchar **full_path = mp_to_ptr(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_bookmark_file_load_from_data_dirs(bookmark, file, full_path, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_load_from_data_dirs_obj, 4, mp_g_bookmark_file_load_from_data_dirs, g_bookmark_file_load_from_data_dirs);

 

/*
 * dbus extension definition for:
 * extern gchar *g_bookmark_file_to_data(GBookmarkFile *bookmark, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_to_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    gsize *length = mp_to_ptr(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gchar * res = g_bookmark_file_to_data(bookmark, length, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_to_data_obj, 3, mp_g_bookmark_file_to_data, g_bookmark_file_to_data);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_to_file(GBookmarkFile *bookmark, const gchar *filename, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_to_file(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gboolean res = g_bookmark_file_to_file(bookmark, filename, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_to_file_obj, 3, mp_g_bookmark_file_to_file, g_bookmark_file_to_file);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_set_title(GBookmarkFile *bookmark, const gchar *uri, const gchar *title)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_set_title(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *title = (char*)mp_obj_str_get_str(mp_args[2]);
    g_bookmark_file_set_title(bookmark, uri, title);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_set_title_obj, 3, mp_g_bookmark_file_set_title, g_bookmark_file_set_title);

 

/*
 * dbus extension definition for:
 * extern gchar *g_bookmark_file_get_title(GBookmarkFile *bookmark, const gchar *uri, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_title(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gchar * res = g_bookmark_file_get_title(bookmark, uri, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_title_obj, 3, mp_g_bookmark_file_get_title, g_bookmark_file_get_title);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_set_description(GBookmarkFile *bookmark, const gchar *uri, const gchar *description)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_set_description(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *description = (char*)mp_obj_str_get_str(mp_args[2]);
    g_bookmark_file_set_description(bookmark, uri, description);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_set_description_obj, 3, mp_g_bookmark_file_set_description, g_bookmark_file_set_description);

 

/*
 * dbus extension definition for:
 * extern gchar *g_bookmark_file_get_description(GBookmarkFile *bookmark, const gchar *uri, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_description(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gchar * res = g_bookmark_file_get_description(bookmark, uri, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_description_obj, 3, mp_g_bookmark_file_get_description, g_bookmark_file_get_description);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_set_mime_type(GBookmarkFile *bookmark, const gchar *uri, const gchar *mime_type)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_set_mime_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *mime_type = (char*)mp_obj_str_get_str(mp_args[2]);
    g_bookmark_file_set_mime_type(bookmark, uri, mime_type);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_set_mime_type_obj, 3, mp_g_bookmark_file_set_mime_type, g_bookmark_file_set_mime_type);

 

/*
 * dbus extension definition for:
 * extern gchar *g_bookmark_file_get_mime_type(GBookmarkFile *bookmark, const gchar *uri, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_mime_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gchar * res = g_bookmark_file_get_mime_type(bookmark, uri, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_mime_type_obj, 3, mp_g_bookmark_file_get_mime_type, g_bookmark_file_get_mime_type);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_set_groups(GBookmarkFile *bookmark, const gchar *uri, const gchar **groups, gsize length)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_set_groups(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar **groups = mp_to_ptr(mp_args[2]);
    gsize length = (unsigned long)mp_obj_get_int(mp_args[3]);
    g_bookmark_file_set_groups(bookmark, uri, groups, length);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_set_groups_obj, 4, mp_g_bookmark_file_set_groups, g_bookmark_file_set_groups);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_add_group(GBookmarkFile *bookmark, const gchar *uri, const gchar *group)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_add_group(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *group = (char*)mp_obj_str_get_str(mp_args[2]);
    g_bookmark_file_add_group(bookmark, uri, group);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_add_group_obj, 3, mp_g_bookmark_file_add_group, g_bookmark_file_add_group);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_has_group(GBookmarkFile *bookmark, const gchar *uri, const gchar *group, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_has_group(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *group = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_bookmark_file_has_group(bookmark, uri, group, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_has_group_obj, 4, mp_g_bookmark_file_has_group, g_bookmark_file_has_group);

 

/*
 * dbus extension definition for:
 * extern gchar **g_bookmark_file_get_groups(GBookmarkFile *bookmark, const gchar *uri, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_groups(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    gsize *length = mp_to_ptr(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gchar ** res = g_bookmark_file_get_groups(bookmark, uri, length, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_groups_obj, 4, mp_g_bookmark_file_get_groups, g_bookmark_file_get_groups);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_add_application(GBookmarkFile *bookmark, const gchar *uri, const gchar *name, const gchar *exec)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_add_application(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *name = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *exec = (char*)mp_obj_str_get_str(mp_args[3]);
    g_bookmark_file_add_application(bookmark, uri, name, exec);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_add_application_obj, 4, mp_g_bookmark_file_add_application, g_bookmark_file_add_application);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_has_application(GBookmarkFile *bookmark, const gchar *uri, const gchar *name, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_has_application(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *name = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_bookmark_file_has_application(bookmark, uri, name, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_has_application_obj, 4, mp_g_bookmark_file_has_application, g_bookmark_file_has_application);

 

/*
 * dbus extension definition for:
 * extern gchar **g_bookmark_file_get_applications(GBookmarkFile *bookmark, const gchar *uri, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_applications(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    gsize *length = mp_to_ptr(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gchar ** res = g_bookmark_file_get_applications(bookmark, uri, length, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_applications_obj, 4, mp_g_bookmark_file_get_applications, g_bookmark_file_get_applications);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_set_app_info(GBookmarkFile *bookmark, const gchar *uri, const gchar *name, const gchar *exec, gint count, time_t stamp, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_set_app_info(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *name = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *exec = (char*)mp_obj_str_get_str(mp_args[3]);
    gint count = (int)mp_obj_get_int(mp_args[4]);
    time_t stamp = (long int)mp_obj_get_int(mp_args[5]);
    GError **error = mp_to_ptr(mp_args[6]);
    gboolean res = g_bookmark_file_set_app_info(bookmark, uri, name, exec, count, stamp, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_set_app_info_obj, 7, mp_g_bookmark_file_set_app_info, g_bookmark_file_set_app_info);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_get_app_info(GBookmarkFile *bookmark, const gchar *uri, const gchar *name, gchar **exec, guint *count, time_t *stamp, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_app_info(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *name = (char*)mp_obj_str_get_str(mp_args[2]);
    gchar **exec = mp_to_ptr(mp_args[3]);
    guint *count = mp_to_ptr(mp_args[4]);
    time_t *stamp = mp_to_ptr(mp_args[5]);
    GError **error = mp_to_ptr(mp_args[6]);
    gboolean res = g_bookmark_file_get_app_info(bookmark, uri, name, exec, count, stamp, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_app_info_obj, 7, mp_g_bookmark_file_get_app_info, g_bookmark_file_get_app_info);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_set_is_private(GBookmarkFile *bookmark, const gchar *uri, gboolean is_private)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_set_is_private(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    gboolean is_private = (int)mp_obj_get_int(mp_args[2]);
    g_bookmark_file_set_is_private(bookmark, uri, is_private);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_set_is_private_obj, 3, mp_g_bookmark_file_set_is_private, g_bookmark_file_set_is_private);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_get_is_private(GBookmarkFile *bookmark, const gchar *uri, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_is_private(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gboolean res = g_bookmark_file_get_is_private(bookmark, uri, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_is_private_obj, 3, mp_g_bookmark_file_get_is_private, g_bookmark_file_get_is_private);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_set_icon(GBookmarkFile *bookmark, const gchar *uri, const gchar *href, const gchar *mime_type)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_set_icon(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *href = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *mime_type = (char*)mp_obj_str_get_str(mp_args[3]);
    g_bookmark_file_set_icon(bookmark, uri, href, mime_type);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_set_icon_obj, 4, mp_g_bookmark_file_set_icon, g_bookmark_file_set_icon);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_get_icon(GBookmarkFile *bookmark, const gchar *uri, gchar **href, gchar **mime_type, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_icon(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    gchar **href = mp_to_ptr(mp_args[2]);
    gchar **mime_type = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gboolean res = g_bookmark_file_get_icon(bookmark, uri, href, mime_type, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_icon_obj, 5, mp_g_bookmark_file_get_icon, g_bookmark_file_get_icon);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_set_added(GBookmarkFile *bookmark, const gchar *uri, time_t added)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_set_added(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    time_t added = (long int)mp_obj_get_int(mp_args[2]);
    g_bookmark_file_set_added(bookmark, uri, added);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_set_added_obj, 3, mp_g_bookmark_file_set_added, g_bookmark_file_set_added);

 

/*
 * dbus extension definition for:
 * extern time_t g_bookmark_file_get_added(GBookmarkFile *bookmark, const gchar *uri, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_added(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    time_t res = g_bookmark_file_get_added(bookmark, uri, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_added_obj, 3, mp_g_bookmark_file_get_added, g_bookmark_file_get_added);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_set_modified(GBookmarkFile *bookmark, const gchar *uri, time_t modified)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_set_modified(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    time_t modified = (long int)mp_obj_get_int(mp_args[2]);
    g_bookmark_file_set_modified(bookmark, uri, modified);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_set_modified_obj, 3, mp_g_bookmark_file_set_modified, g_bookmark_file_set_modified);

 

/*
 * dbus extension definition for:
 * extern time_t g_bookmark_file_get_modified(GBookmarkFile *bookmark, const gchar *uri, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_modified(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    time_t res = g_bookmark_file_get_modified(bookmark, uri, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_modified_obj, 3, mp_g_bookmark_file_get_modified, g_bookmark_file_get_modified);

 

/*
 * dbus extension definition for:
 * extern void g_bookmark_file_set_visited(GBookmarkFile *bookmark, const gchar *uri, time_t visited)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_set_visited(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    time_t visited = (long int)mp_obj_get_int(mp_args[2]);
    g_bookmark_file_set_visited(bookmark, uri, visited);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_set_visited_obj, 3, mp_g_bookmark_file_set_visited, g_bookmark_file_set_visited);

 

/*
 * dbus extension definition for:
 * extern time_t g_bookmark_file_get_visited(GBookmarkFile *bookmark, const gchar *uri, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_visited(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    time_t res = g_bookmark_file_get_visited(bookmark, uri, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_visited_obj, 3, mp_g_bookmark_file_get_visited, g_bookmark_file_get_visited);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_has_item(GBookmarkFile *bookmark, const gchar *uri)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_has_item(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    gboolean res = g_bookmark_file_has_item(bookmark, uri);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_has_item_obj, 2, mp_g_bookmark_file_has_item, g_bookmark_file_has_item);

 

/*
 * dbus extension definition for:
 * extern gint g_bookmark_file_get_size(GBookmarkFile *bookmark)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    gint res = g_bookmark_file_get_size(bookmark);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_size_obj, 1, mp_g_bookmark_file_get_size, g_bookmark_file_get_size);

 

/*
 * dbus extension definition for:
 * extern gchar **g_bookmark_file_get_uris(GBookmarkFile *bookmark, gsize *length)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_get_uris(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    gsize *length = mp_to_ptr(mp_args[1]);
    gchar ** res = g_bookmark_file_get_uris(bookmark, length);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_get_uris_obj, 2, mp_g_bookmark_file_get_uris, g_bookmark_file_get_uris);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_remove_group(GBookmarkFile *bookmark, const gchar *uri, const gchar *group, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_remove_group(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *group = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_bookmark_file_remove_group(bookmark, uri, group, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_remove_group_obj, 4, mp_g_bookmark_file_remove_group, g_bookmark_file_remove_group);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_remove_application(GBookmarkFile *bookmark, const gchar *uri, const gchar *name, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_remove_application(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *name = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_bookmark_file_remove_application(bookmark, uri, name, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_remove_application_obj, 4, mp_g_bookmark_file_remove_application, g_bookmark_file_remove_application);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_remove_item(GBookmarkFile *bookmark, const gchar *uri, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_remove_item(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gboolean res = g_bookmark_file_remove_item(bookmark, uri, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_remove_item_obj, 3, mp_g_bookmark_file_remove_item, g_bookmark_file_remove_item);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bookmark_file_move_item(GBookmarkFile *bookmark, const gchar *old_uri, const gchar *new_uri, GError **error)
 */
 
STATIC mp_obj_t mp_g_bookmark_file_move_item(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBookmarkFile *bookmark = mp_to_ptr(mp_args[0]);
    const gchar *old_uri = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *new_uri = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_bookmark_file_move_item(bookmark, old_uri, new_uri, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bookmark_file_move_item_obj, 4, mp_g_bookmark_file_move_item, g_bookmark_file_move_item);

 

/*
 * dbus extension definition for:
 * extern GBytes *g_bytes_new(gconstpointer data, gsize size)
 */
 
STATIC mp_obj_t mp_g_bytes_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer data = mp_to_ptr(mp_args[0]);
    gsize size = (unsigned long)mp_obj_get_int(mp_args[1]);
    GBytes * res = g_bytes_new(data, size);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_new_obj, 2, mp_g_bytes_new, g_bytes_new);

 

/*
 * dbus extension definition for:
 * extern GBytes *g_bytes_new_take(gpointer data, gsize size)
 */
 
STATIC mp_obj_t mp_g_bytes_new_take(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer data = mp_to_ptr(mp_args[0]);
    gsize size = (unsigned long)mp_obj_get_int(mp_args[1]);
    GBytes * res = g_bytes_new_take(data, size);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_new_take_obj, 2, mp_g_bytes_new_take, g_bytes_new_take);

 

/*
 * dbus extension definition for:
 * extern GBytes *g_bytes_new_static(gconstpointer data, gsize size)
 */
 
STATIC mp_obj_t mp_g_bytes_new_static(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer data = mp_to_ptr(mp_args[0]);
    gsize size = (unsigned long)mp_obj_get_int(mp_args[1]);
    GBytes * res = g_bytes_new_static(data, size);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_new_static_obj, 2, mp_g_bytes_new_static, g_bytes_new_static);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify free_func' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify free_func
 */
    

/*
 * dbus extension definition for:
 * extern GBytes *g_bytes_new_with_free_func(gconstpointer data, gsize size, GDestroyNotify free_func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_bytes_new_with_free_func(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer data = mp_to_ptr(mp_args[0]);
    gsize size = (unsigned long)mp_obj_get_int(mp_args[1]);
    GDestroyNotify free_func = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    GBytes * res = g_bytes_new_with_free_func(data, size, free_func, user_data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_new_with_free_func_obj, 4, mp_g_bytes_new_with_free_func, g_bytes_new_with_free_func);

 

/*
 * dbus extension definition for:
 * extern GBytes *g_bytes_new_from_bytes(GBytes *bytes, gsize offset, gsize length)
 */
 
STATIC mp_obj_t mp_g_bytes_new_from_bytes(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBytes *bytes = mp_to_ptr(mp_args[0]);
    gsize offset = (unsigned long)mp_obj_get_int(mp_args[1]);
    gsize length = (unsigned long)mp_obj_get_int(mp_args[2]);
    GBytes * res = g_bytes_new_from_bytes(bytes, offset, length);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_new_from_bytes_obj, 3, mp_g_bytes_new_from_bytes, g_bytes_new_from_bytes);

 

/*
 * dbus extension definition for:
 * extern gconstpointer g_bytes_get_data(GBytes *bytes, gsize *size)
 */
 
STATIC mp_obj_t mp_g_bytes_get_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBytes *bytes = mp_to_ptr(mp_args[0]);
    gsize *size = mp_to_ptr(mp_args[1]);
    gconstpointer res = g_bytes_get_data(bytes, size);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_get_data_obj, 2, mp_g_bytes_get_data, g_bytes_get_data);

 

/*
 * dbus extension definition for:
 * extern gsize g_bytes_get_size(GBytes *bytes)
 */
 
STATIC mp_obj_t mp_g_bytes_get_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBytes *bytes = mp_to_ptr(mp_args[0]);
    gsize res = g_bytes_get_size(bytes);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_get_size_obj, 1, mp_g_bytes_get_size, g_bytes_get_size);

 

/*
 * dbus extension definition for:
 * extern GBytes *g_bytes_ref(GBytes *bytes)
 */
 
STATIC mp_obj_t mp_g_bytes_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBytes *bytes = mp_to_ptr(mp_args[0]);
    GBytes * res = g_bytes_ref(bytes);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_ref_obj, 1, mp_g_bytes_ref, g_bytes_ref);

 

/*
 * dbus extension definition for:
 * extern void g_bytes_unref(GBytes *bytes)
 */
 
STATIC mp_obj_t mp_g_bytes_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBytes *bytes = mp_to_ptr(mp_args[0]);
    g_bytes_unref(bytes);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_unref_obj, 1, mp_g_bytes_unref, g_bytes_unref);

 

/*
 * dbus extension definition for:
 * extern gpointer g_bytes_unref_to_data(GBytes *bytes, gsize *size)
 */
 
STATIC mp_obj_t mp_g_bytes_unref_to_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBytes *bytes = mp_to_ptr(mp_args[0]);
    gsize *size = mp_to_ptr(mp_args[1]);
    gpointer res = g_bytes_unref_to_data(bytes, size);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_unref_to_data_obj, 2, mp_g_bytes_unref_to_data, g_bytes_unref_to_data);

 

/*
 * dbus extension definition for:
 * extern GByteArray *g_bytes_unref_to_array(GBytes *bytes)
 */
 
STATIC mp_obj_t mp_g_bytes_unref_to_array(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GBytes *bytes = mp_to_ptr(mp_args[0]);
    GByteArray * res = g_bytes_unref_to_array(bytes);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_unref_to_array_obj, 1, mp_g_bytes_unref_to_array, g_bytes_unref_to_array);

 

/*
 * dbus extension definition for:
 * extern guint g_bytes_hash(gconstpointer bytes)
 */
 
STATIC mp_obj_t mp_g_bytes_hash(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer bytes = mp_to_ptr(mp_args[0]);
    guint res = g_bytes_hash(bytes);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_hash_obj, 1, mp_g_bytes_hash, g_bytes_hash);

 

/*
 * dbus extension definition for:
 * extern gboolean g_bytes_equal(gconstpointer bytes1, gconstpointer bytes2)
 */
 
STATIC mp_obj_t mp_g_bytes_equal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer bytes1 = mp_to_ptr(mp_args[0]);
    gconstpointer bytes2 = mp_to_ptr(mp_args[1]);
    gboolean res = g_bytes_equal(bytes1, bytes2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_equal_obj, 2, mp_g_bytes_equal, g_bytes_equal);

 

/*
 * dbus extension definition for:
 * extern gint g_bytes_compare(gconstpointer bytes1, gconstpointer bytes2)
 */
 
STATIC mp_obj_t mp_g_bytes_compare(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer bytes1 = mp_to_ptr(mp_args[0]);
    gconstpointer bytes2 = mp_to_ptr(mp_args[1]);
    gint res = g_bytes_compare(bytes1, bytes2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_bytes_compare_obj, 2, mp_g_bytes_compare, g_bytes_compare);

 

/*
 * dbus extension definition for:
 * extern gboolean g_get_charset(const char **charset)
 */
 
STATIC mp_obj_t mp_g_get_charset(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char **charset = mp_to_ptr(mp_args[0]);
    gboolean res = g_get_charset(charset);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_get_charset_obj, 1, mp_g_get_charset, g_get_charset);

 

/*
 * dbus extension definition for:
 * extern gchar *g_get_codeset(void)
 */
 
STATIC mp_obj_t mp_g_get_codeset(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    gchar * res = g_get_codeset();
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_get_codeset_obj, 0, mp_g_get_codeset, g_get_codeset);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar * const *
 * extern const gchar * const *g_get_language_names(void)
 */
    

/*
 * dbus extension definition for:
 * extern gchar **g_get_locale_variants(const gchar *locale)
 */
 
STATIC mp_obj_t mp_g_get_locale_variants(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *locale = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar ** res = g_get_locale_variants(locale);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_get_locale_variants_obj, 1, mp_g_get_locale_variants, g_get_locale_variants);

 

/*
 * Function NOT generated:
 * Missing convertion from gssize
 * extern gssize g_checksum_type_get_length(GChecksumType checksum_type)
 */
    

/*
 * dbus extension definition for:
 * extern GChecksum *g_checksum_new(GChecksumType checksum_type)
 */
 
STATIC mp_obj_t mp_g_checksum_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GChecksumType checksum_type = (int)mp_obj_get_int(mp_args[0]);
    GChecksum * res = g_checksum_new(checksum_type);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_checksum_new_obj, 1, mp_g_checksum_new, g_checksum_new);

 

/*
 * dbus extension definition for:
 * extern void g_checksum_reset(GChecksum *checksum)
 */
 
STATIC mp_obj_t mp_g_checksum_reset(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GChecksum *checksum = mp_to_ptr(mp_args[0]);
    g_checksum_reset(checksum);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_checksum_reset_obj, 1, mp_g_checksum_reset, g_checksum_reset);

 

/*
 * dbus extension definition for:
 * extern GChecksum *g_checksum_copy(const GChecksum *checksum)
 */
 
STATIC mp_obj_t mp_g_checksum_copy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GChecksum *checksum = mp_to_ptr(mp_args[0]);
    GChecksum * res = g_checksum_copy(checksum);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_checksum_copy_obj, 1, mp_g_checksum_copy, g_checksum_copy);

 

/*
 * dbus extension definition for:
 * extern void g_checksum_free(GChecksum *checksum)
 */
 
STATIC mp_obj_t mp_g_checksum_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GChecksum *checksum = mp_to_ptr(mp_args[0]);
    g_checksum_free(checksum);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_checksum_free_obj, 1, mp_g_checksum_free, g_checksum_free);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern void g_checksum_update(GChecksum *checksum, const guchar *data, gssize length)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_checksum_get_string(GChecksum *checksum)
 */
    

/*
 * dbus extension definition for:
 * extern void g_checksum_get_digest(GChecksum *checksum, guint8 *buffer, gsize *digest_len)
 */
 
STATIC mp_obj_t mp_g_checksum_get_digest(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GChecksum *checksum = mp_to_ptr(mp_args[0]);
    guint8 *buffer = mp_to_ptr(mp_args[1]);
    gsize *digest_len = mp_to_ptr(mp_args[2]);
    g_checksum_get_digest(checksum, buffer, digest_len);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_checksum_get_digest_obj, 3, mp_g_checksum_get_digest, g_checksum_get_digest);

 

/*
 * dbus extension definition for:
 * extern gchar *g_compute_checksum_for_data(GChecksumType checksum_type, const guchar *data, gsize length)
 */
 
STATIC mp_obj_t mp_g_compute_checksum_for_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GChecksumType checksum_type = (int)mp_obj_get_int(mp_args[0]);
    const guchar *data = mp_to_ptr(mp_args[1]);
    gsize length = (unsigned long)mp_obj_get_int(mp_args[2]);
    gchar * res = g_compute_checksum_for_data(checksum_type, data, length);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_compute_checksum_for_data_obj, 3, mp_g_compute_checksum_for_data, g_compute_checksum_for_data);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_compute_checksum_for_string(GChecksumType checksum_type, const gchar *str, gssize length)
 */
    

/*
 * dbus extension definition for:
 * extern gchar *g_compute_checksum_for_bytes(GChecksumType checksum_type, GBytes *data)
 */
 
STATIC mp_obj_t mp_g_compute_checksum_for_bytes(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GChecksumType checksum_type = (int)mp_obj_get_int(mp_args[0]);
    GBytes *data = mp_to_ptr(mp_args[1]);
    gchar * res = g_compute_checksum_for_bytes(checksum_type, data);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_compute_checksum_for_bytes_obj, 2, mp_g_compute_checksum_for_bytes, g_compute_checksum_for_bytes);

 

/*
 * dbus extension definition for:
 * extern GQuark g_convert_error_quark(void)
 */
 
STATIC mp_obj_t mp_g_convert_error_quark(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GQuark res = g_convert_error_quark();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_convert_error_quark_obj, 0, mp_g_convert_error_quark, g_convert_error_quark);

 

/*
 * dbus extension definition for:
 * extern GIConv g_iconv_open(const gchar *to_codeset, const gchar *from_codeset)
 */
 
STATIC mp_obj_t mp_g_iconv_open(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *to_codeset = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *from_codeset = (char*)mp_obj_str_get_str(mp_args[1]);
    GIConv res = g_iconv_open(to_codeset, from_codeset);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_iconv_open_obj, 2, mp_g_iconv_open, g_iconv_open);

 

/*
 * dbus extension definition for:
 * extern gsize g_iconv(GIConv converter, gchar **inbuf, gsize *inbytes_left, gchar **outbuf, gsize *outbytes_left)
 */
 
STATIC mp_obj_t mp_g_iconv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIConv converter = mp_to_ptr(mp_args[0]);
    gchar **inbuf = mp_to_ptr(mp_args[1]);
    gsize *inbytes_left = mp_to_ptr(mp_args[2]);
    gchar **outbuf = mp_to_ptr(mp_args[3]);
    gsize *outbytes_left = mp_to_ptr(mp_args[4]);
    gsize res = g_iconv(converter, inbuf, inbytes_left, outbuf, outbytes_left);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_iconv_obj, 5, mp_g_iconv, g_iconv);

 

/*
 * dbus extension definition for:
 * extern gint g_iconv_close(GIConv converter)
 */
 
STATIC mp_obj_t mp_g_iconv_close(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIConv converter = mp_to_ptr(mp_args[0]);
    gint res = g_iconv_close(converter);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_iconv_close_obj, 1, mp_g_iconv_close, g_iconv_close);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_convert(const gchar *str, gssize len, const gchar *to_codeset, const gchar *from_codeset, gsize *bytes_read, gsize *bytes_written, GError **error)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_convert_with_iconv(const gchar *str, gssize len, GIConv converter, gsize *bytes_read, gsize *bytes_written, GError **error)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_convert_with_fallback(const gchar *str, gssize len, const gchar *to_codeset, const gchar *from_codeset, const gchar *fallback, gsize *bytes_read, gsize *bytes_written, GError **error)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_locale_to_utf8(const gchar *opsysstring, gssize len, gsize *bytes_read, gsize *bytes_written, GError **error)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_locale_from_utf8(const gchar *utf8string, gssize len, gsize *bytes_read, gsize *bytes_written, GError **error)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_filename_to_utf8(const gchar *opsysstring, gssize len, gsize *bytes_read, gsize *bytes_written, GError **error)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_filename_from_utf8(const gchar *utf8string, gssize len, gsize *bytes_read, gsize *bytes_written, GError **error)
 */
    

/*
 * dbus extension definition for:
 * extern gchar *g_filename_from_uri(const gchar *uri, gchar **hostname, GError **error)
 */
 
STATIC mp_obj_t mp_g_filename_from_uri(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *uri = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar **hostname = mp_to_ptr(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gchar * res = g_filename_from_uri(uri, hostname, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_filename_from_uri_obj, 3, mp_g_filename_from_uri, g_filename_from_uri);

 

/*
 * dbus extension definition for:
 * extern gchar *g_filename_to_uri(const gchar *filename, const gchar *hostname, GError **error)
 */
 
STATIC mp_obj_t mp_g_filename_to_uri(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *hostname = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gchar * res = g_filename_to_uri(filename, hostname, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_filename_to_uri_obj, 3, mp_g_filename_to_uri, g_filename_to_uri);

 

/*
 * dbus extension definition for:
 * extern gchar *g_filename_display_name(const gchar *filename)
 */
 
STATIC mp_obj_t mp_g_filename_display_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_filename_display_name(filename);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_filename_display_name_obj, 1, mp_g_filename_display_name, g_filename_display_name);

 

/*
 * dbus extension definition for:
 * extern gboolean g_get_filename_charsets(const gchar ***charsets)
 */
 
STATIC mp_obj_t mp_g_get_filename_charsets(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar ***charsets = mp_to_ptr(mp_args[0]);
    gboolean res = g_get_filename_charsets(charsets);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_get_filename_charsets_obj, 1, mp_g_get_filename_charsets, g_get_filename_charsets);

 

/*
 * dbus extension definition for:
 * extern gchar *g_filename_display_basename(const gchar *filename)
 */
 
STATIC mp_obj_t mp_g_filename_display_basename(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_filename_display_basename(filename);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_filename_display_basename_obj, 1, mp_g_filename_display_basename, g_filename_display_basename);

 

/*
 * dbus extension definition for:
 * extern gchar **g_uri_list_extract_uris(const gchar *uri_list)
 */
 
STATIC mp_obj_t mp_g_uri_list_extract_uris(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *uri_list = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar ** res = g_uri_list_extract_uris(uri_list);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_uri_list_extract_uris_obj, 1, mp_g_uri_list_extract_uris, g_uri_list_extract_uris);

 

/*
 * dbus extension definition for:
 * extern void g_datalist_init(GData **datalist)
 */
 
STATIC mp_obj_t mp_g_datalist_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    g_datalist_init(datalist);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_init_obj, 1, mp_g_datalist_init, g_datalist_init);

 

/*
 * dbus extension definition for:
 * extern void g_datalist_clear(GData **datalist)
 */
 
STATIC mp_obj_t mp_g_datalist_clear(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    g_datalist_clear(datalist);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_clear_obj, 1, mp_g_datalist_clear, g_datalist_clear);

 

/*
 * dbus extension definition for:
 * extern gpointer g_datalist_id_get_data(GData **datalist, GQuark key_id)
 */
 
STATIC mp_obj_t mp_g_datalist_id_get_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    GQuark key_id = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer res = g_datalist_id_get_data(datalist, key_id);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_id_get_data_obj, 2, mp_g_datalist_id_get_data, g_datalist_id_get_data);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify destroy_func' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify destroy_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_datalist_id_set_data_full(GData **datalist, GQuark key_id, gpointer data, GDestroyNotify destroy_func)
 */
 
STATIC mp_obj_t mp_g_datalist_id_set_data_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    GQuark key_id = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GDestroyNotify destroy_func = mp_to_ptr(mp_args[3]);
    g_datalist_id_set_data_full(datalist, key_id, data, destroy_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_id_set_data_full_obj, 4, mp_g_datalist_id_set_data_full, g_datalist_id_set_data_full);

 

/*
 * Function NOT generated:
 * Callback function 'GDuplicateFunc dup_func' must receive a struct pointer with user_data member as its first argument!
 * GDuplicateFunc dup_func
 */
    

/*
 * dbus extension definition for:
 * extern gpointer g_datalist_id_dup_data(GData **datalist, GQuark key_id, GDuplicateFunc dup_func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_datalist_id_dup_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    GQuark key_id = (unsigned int)mp_obj_get_int(mp_args[1]);
    GDuplicateFunc dup_func = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    gpointer res = g_datalist_id_dup_data(datalist, key_id, dup_func, user_data);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_id_dup_data_obj, 4, mp_g_datalist_id_dup_data, g_datalist_id_dup_data);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify destroy' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify destroy
 */
    

/*
 * dbus extension definition for:
 * extern gboolean g_datalist_id_replace_data(GData **datalist, GQuark key_id, gpointer oldval, gpointer newval, GDestroyNotify destroy, GDestroyNotify *old_destroy)
 */
 
STATIC mp_obj_t mp_g_datalist_id_replace_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    GQuark key_id = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer oldval = mp_to_ptr(mp_args[2]);
    gpointer newval = mp_to_ptr(mp_args[3]);
    GDestroyNotify destroy = mp_to_ptr(mp_args[4]);
    GDestroyNotify *old_destroy = mp_to_ptr(mp_args[5]);
    gboolean res = g_datalist_id_replace_data(datalist, key_id, oldval, newval, destroy, old_destroy);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_id_replace_data_obj, 6, mp_g_datalist_id_replace_data, g_datalist_id_replace_data);

 

/*
 * dbus extension definition for:
 * extern gpointer g_datalist_id_remove_no_notify(GData **datalist, GQuark key_id)
 */
 
STATIC mp_obj_t mp_g_datalist_id_remove_no_notify(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    GQuark key_id = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer res = g_datalist_id_remove_no_notify(datalist, key_id);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_id_remove_no_notify_obj, 2, mp_g_datalist_id_remove_no_notify, g_datalist_id_remove_no_notify);

 

/*
 * Function NOT generated:
 * Callback function 'GDataForeachFunc func' must receive a struct pointer with user_data member as its first argument!
 * GDataForeachFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_datalist_foreach(GData **datalist, GDataForeachFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_datalist_foreach(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    GDataForeachFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_datalist_foreach(datalist, func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_foreach_obj, 3, mp_g_datalist_foreach, g_datalist_foreach);

 

/*
 * dbus extension definition for:
 * extern void g_datalist_set_flags(GData **datalist, guint flags)
 */
 
STATIC mp_obj_t mp_g_datalist_set_flags(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    guint flags = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_datalist_set_flags(datalist, flags);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_set_flags_obj, 2, mp_g_datalist_set_flags, g_datalist_set_flags);

 

/*
 * dbus extension definition for:
 * extern void g_datalist_unset_flags(GData **datalist, guint flags)
 */
 
STATIC mp_obj_t mp_g_datalist_unset_flags(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    guint flags = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_datalist_unset_flags(datalist, flags);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_unset_flags_obj, 2, mp_g_datalist_unset_flags, g_datalist_unset_flags);

 

/*
 * dbus extension definition for:
 * extern guint g_datalist_get_flags(GData **datalist)
 */
 
STATIC mp_obj_t mp_g_datalist_get_flags(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    guint res = g_datalist_get_flags(datalist);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_get_flags_obj, 1, mp_g_datalist_get_flags, g_datalist_get_flags);

 

/*
 * dbus extension definition for:
 * extern void g_dataset_destroy(gconstpointer dataset_location)
 */
 
STATIC mp_obj_t mp_g_dataset_destroy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer dataset_location = mp_to_ptr(mp_args[0]);
    g_dataset_destroy(dataset_location);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_dataset_destroy_obj, 1, mp_g_dataset_destroy, g_dataset_destroy);

 

/*
 * dbus extension definition for:
 * extern gpointer g_dataset_id_get_data(gconstpointer dataset_location, GQuark key_id)
 */
 
STATIC mp_obj_t mp_g_dataset_id_get_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer dataset_location = mp_to_ptr(mp_args[0]);
    GQuark key_id = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer res = g_dataset_id_get_data(dataset_location, key_id);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_dataset_id_get_data_obj, 2, mp_g_dataset_id_get_data, g_dataset_id_get_data);

 

/*
 * dbus extension definition for:
 * extern gpointer g_datalist_get_data(GData **datalist, const gchar *key)
 */
 
STATIC mp_obj_t mp_g_datalist_get_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GData **datalist = mp_to_ptr(mp_args[0]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[1]);
    gpointer res = g_datalist_get_data(datalist, key);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_datalist_get_data_obj, 2, mp_g_datalist_get_data, g_datalist_get_data);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify destroy_func' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify destroy_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_dataset_id_set_data_full(gconstpointer dataset_location, GQuark key_id, gpointer data, GDestroyNotify destroy_func)
 */
 
STATIC mp_obj_t mp_g_dataset_id_set_data_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer dataset_location = mp_to_ptr(mp_args[0]);
    GQuark key_id = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GDestroyNotify destroy_func = mp_to_ptr(mp_args[3]);
    g_dataset_id_set_data_full(dataset_location, key_id, data, destroy_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_dataset_id_set_data_full_obj, 4, mp_g_dataset_id_set_data_full, g_dataset_id_set_data_full);

 

/*
 * dbus extension definition for:
 * extern gpointer g_dataset_id_remove_no_notify(gconstpointer dataset_location, GQuark key_id)
 */
 
STATIC mp_obj_t mp_g_dataset_id_remove_no_notify(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer dataset_location = mp_to_ptr(mp_args[0]);
    GQuark key_id = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer res = g_dataset_id_remove_no_notify(dataset_location, key_id);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_dataset_id_remove_no_notify_obj, 2, mp_g_dataset_id_remove_no_notify, g_dataset_id_remove_no_notify);

 

/*
 * Function NOT generated:
 * Callback function 'GDataForeachFunc func' must receive a struct pointer with user_data member as its first argument!
 * GDataForeachFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_dataset_foreach(gconstpointer dataset_location, GDataForeachFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_dataset_foreach(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer dataset_location = mp_to_ptr(mp_args[0]);
    GDataForeachFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_dataset_foreach(dataset_location, func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_dataset_foreach_obj, 3, mp_g_dataset_foreach, g_dataset_foreach);

 

/*
 * dbus extension definition for:
 * extern GDate *g_date_new(void)
 */
 
STATIC mp_obj_t mp_g_date_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GDate * res = g_date_new();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_new_obj, 0, mp_g_date_new, g_date_new);

 

/*
 * dbus extension definition for:
 * extern GDate *g_date_new_dmy(GDateDay day, GDateMonth month, GDateYear year)
 */
 
STATIC mp_obj_t mp_g_date_new_dmy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateDay day = (unsigned char)mp_obj_get_int(mp_args[0]);
    GDateMonth month = (int)mp_obj_get_int(mp_args[1]);
    GDateYear year = (unsigned short)mp_obj_get_int(mp_args[2]);
    GDate * res = g_date_new_dmy(day, month, year);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_new_dmy_obj, 3, mp_g_date_new_dmy, g_date_new_dmy);

 

/*
 * dbus extension definition for:
 * extern GDate *g_date_new_julian(guint32 julian_day)
 */
 
STATIC mp_obj_t mp_g_date_new_julian(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint32 julian_day = (unsigned int)mp_obj_get_int(mp_args[0]);
    GDate * res = g_date_new_julian(julian_day);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_new_julian_obj, 1, mp_g_date_new_julian, g_date_new_julian);

 

/*
 * dbus extension definition for:
 * extern void g_date_free(GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    g_date_free(date);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_free_obj, 1, mp_g_date_free, g_date_free);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_valid(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_valid(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    gboolean res = g_date_valid(date);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_valid_obj, 1, mp_g_date_valid, g_date_valid);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_valid_day(GDateDay day)
 */
 
STATIC mp_obj_t mp_g_date_valid_day(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateDay day = (unsigned char)mp_obj_get_int(mp_args[0]);
    gboolean res = g_date_valid_day(day);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_valid_day_obj, 1, mp_g_date_valid_day, g_date_valid_day);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_valid_month(GDateMonth month)
 */
 
STATIC mp_obj_t mp_g_date_valid_month(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateMonth month = (int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_date_valid_month(month);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_valid_month_obj, 1, mp_g_date_valid_month, g_date_valid_month);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_valid_year(GDateYear year)
 */
 
STATIC mp_obj_t mp_g_date_valid_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateYear year = (unsigned short)mp_obj_get_int(mp_args[0]);
    gboolean res = g_date_valid_year(year);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_valid_year_obj, 1, mp_g_date_valid_year, g_date_valid_year);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_valid_weekday(GDateWeekday weekday)
 */
 
STATIC mp_obj_t mp_g_date_valid_weekday(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateWeekday weekday = (int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_date_valid_weekday(weekday);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_valid_weekday_obj, 1, mp_g_date_valid_weekday, g_date_valid_weekday);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_valid_julian(guint32 julian_date)
 */
 
STATIC mp_obj_t mp_g_date_valid_julian(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint32 julian_date = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_date_valid_julian(julian_date);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_valid_julian_obj, 1, mp_g_date_valid_julian, g_date_valid_julian);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_valid_dmy(GDateDay day, GDateMonth month, GDateYear year)
 */
 
STATIC mp_obj_t mp_g_date_valid_dmy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateDay day = (unsigned char)mp_obj_get_int(mp_args[0]);
    GDateMonth month = (int)mp_obj_get_int(mp_args[1]);
    GDateYear year = (unsigned short)mp_obj_get_int(mp_args[2]);
    gboolean res = g_date_valid_dmy(day, month, year);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_valid_dmy_obj, 3, mp_g_date_valid_dmy, g_date_valid_dmy);

 

/*
 * dbus extension definition for:
 * extern GDateWeekday g_date_get_weekday(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_get_weekday(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    GDateWeekday res = g_date_get_weekday(date);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_weekday_obj, 1, mp_g_date_get_weekday, g_date_get_weekday);

 

/*
 * dbus extension definition for:
 * extern GDateMonth g_date_get_month(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_get_month(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    GDateMonth res = g_date_get_month(date);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_month_obj, 1, mp_g_date_get_month, g_date_get_month);

 

/*
 * dbus extension definition for:
 * extern GDateYear g_date_get_year(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_get_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    GDateYear res = g_date_get_year(date);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_year_obj, 1, mp_g_date_get_year, g_date_get_year);

 

/*
 * dbus extension definition for:
 * extern GDateDay g_date_get_day(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_get_day(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    GDateDay res = g_date_get_day(date);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_day_obj, 1, mp_g_date_get_day, g_date_get_day);

 

/*
 * dbus extension definition for:
 * extern guint32 g_date_get_julian(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_get_julian(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    guint32 res = g_date_get_julian(date);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_julian_obj, 1, mp_g_date_get_julian, g_date_get_julian);

 

/*
 * dbus extension definition for:
 * extern guint g_date_get_day_of_year(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_get_day_of_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    guint res = g_date_get_day_of_year(date);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_day_of_year_obj, 1, mp_g_date_get_day_of_year, g_date_get_day_of_year);

 

/*
 * dbus extension definition for:
 * extern guint g_date_get_monday_week_of_year(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_get_monday_week_of_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    guint res = g_date_get_monday_week_of_year(date);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_monday_week_of_year_obj, 1, mp_g_date_get_monday_week_of_year, g_date_get_monday_week_of_year);

 

/*
 * dbus extension definition for:
 * extern guint g_date_get_sunday_week_of_year(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_get_sunday_week_of_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    guint res = g_date_get_sunday_week_of_year(date);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_sunday_week_of_year_obj, 1, mp_g_date_get_sunday_week_of_year, g_date_get_sunday_week_of_year);

 

/*
 * dbus extension definition for:
 * extern guint g_date_get_iso8601_week_of_year(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_get_iso8601_week_of_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    guint res = g_date_get_iso8601_week_of_year(date);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_iso8601_week_of_year_obj, 1, mp_g_date_get_iso8601_week_of_year, g_date_get_iso8601_week_of_year);

 

/*
 * dbus extension definition for:
 * extern void g_date_clear(GDate *date, guint n_dates)
 */
 
STATIC mp_obj_t mp_g_date_clear(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    guint n_dates = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_date_clear(date, n_dates);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_clear_obj, 2, mp_g_date_clear, g_date_clear);

 

/*
 * dbus extension definition for:
 * extern void g_date_set_parse(GDate *date, const gchar *str)
 */
 
STATIC mp_obj_t mp_g_date_set_parse(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    const gchar *str = (char*)mp_obj_str_get_str(mp_args[1]);
    g_date_set_parse(date, str);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_set_parse_obj, 2, mp_g_date_set_parse, g_date_set_parse);

 

/*
 * dbus extension definition for:
 * extern void g_date_set_time_t(GDate *date, time_t timet)
 */
 
STATIC mp_obj_t mp_g_date_set_time_t(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    time_t timet = (long int)mp_obj_get_int(mp_args[1]);
    g_date_set_time_t(date, timet);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_set_time_t_obj, 2, mp_g_date_set_time_t, g_date_set_time_t);

 

/*
 * dbus extension definition for:
 * extern void g_date_set_time_val(GDate *date, GTimeVal *timeval)
 */
 
STATIC mp_obj_t mp_g_date_set_time_val(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    GTimeVal *timeval = mp_to_ptr(mp_args[1]);
    g_date_set_time_val(date, timeval);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_set_time_val_obj, 2, mp_g_date_set_time_val, g_date_set_time_val);

 

/*
 * Function NOT generated:
 * Missing conversion to GTime
 * extern void g_date_set_time(GDate *date, GTime time_)
 */
    

/*
 * dbus extension definition for:
 * extern void g_date_set_month(GDate *date, GDateMonth month)
 */
 
STATIC mp_obj_t mp_g_date_set_month(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    GDateMonth month = (int)mp_obj_get_int(mp_args[1]);
    g_date_set_month(date, month);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_set_month_obj, 2, mp_g_date_set_month, g_date_set_month);

 

/*
 * dbus extension definition for:
 * extern void g_date_set_day(GDate *date, GDateDay day)
 */
 
STATIC mp_obj_t mp_g_date_set_day(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    GDateDay day = (unsigned char)mp_obj_get_int(mp_args[1]);
    g_date_set_day(date, day);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_set_day_obj, 2, mp_g_date_set_day, g_date_set_day);

 

/*
 * dbus extension definition for:
 * extern void g_date_set_year(GDate *date, GDateYear year)
 */
 
STATIC mp_obj_t mp_g_date_set_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    GDateYear year = (unsigned short)mp_obj_get_int(mp_args[1]);
    g_date_set_year(date, year);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_set_year_obj, 2, mp_g_date_set_year, g_date_set_year);

 

/*
 * dbus extension definition for:
 * extern void g_date_set_dmy(GDate *date, GDateDay day, GDateMonth month, GDateYear y)
 */
 
STATIC mp_obj_t mp_g_date_set_dmy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    GDateDay day = (unsigned char)mp_obj_get_int(mp_args[1]);
    GDateMonth month = (int)mp_obj_get_int(mp_args[2]);
    GDateYear y = (unsigned short)mp_obj_get_int(mp_args[3]);
    g_date_set_dmy(date, day, month, y);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_set_dmy_obj, 4, mp_g_date_set_dmy, g_date_set_dmy);

 

/*
 * dbus extension definition for:
 * extern void g_date_set_julian(GDate *date, guint32 julian_date)
 */
 
STATIC mp_obj_t mp_g_date_set_julian(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    guint32 julian_date = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_date_set_julian(date, julian_date);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_set_julian_obj, 2, mp_g_date_set_julian, g_date_set_julian);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_is_first_of_month(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_is_first_of_month(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    gboolean res = g_date_is_first_of_month(date);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_is_first_of_month_obj, 1, mp_g_date_is_first_of_month, g_date_is_first_of_month);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_is_last_of_month(const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_is_last_of_month(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    gboolean res = g_date_is_last_of_month(date);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_is_last_of_month_obj, 1, mp_g_date_is_last_of_month, g_date_is_last_of_month);

 

/*
 * dbus extension definition for:
 * extern void g_date_add_days(GDate *date, guint n_days)
 */
 
STATIC mp_obj_t mp_g_date_add_days(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    guint n_days = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_date_add_days(date, n_days);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_add_days_obj, 2, mp_g_date_add_days, g_date_add_days);

 

/*
 * dbus extension definition for:
 * extern void g_date_subtract_days(GDate *date, guint n_days)
 */
 
STATIC mp_obj_t mp_g_date_subtract_days(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    guint n_days = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_date_subtract_days(date, n_days);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_subtract_days_obj, 2, mp_g_date_subtract_days, g_date_subtract_days);

 

/*
 * dbus extension definition for:
 * extern void g_date_add_months(GDate *date, guint n_months)
 */
 
STATIC mp_obj_t mp_g_date_add_months(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    guint n_months = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_date_add_months(date, n_months);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_add_months_obj, 2, mp_g_date_add_months, g_date_add_months);

 

/*
 * dbus extension definition for:
 * extern void g_date_subtract_months(GDate *date, guint n_months)
 */
 
STATIC mp_obj_t mp_g_date_subtract_months(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    guint n_months = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_date_subtract_months(date, n_months);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_subtract_months_obj, 2, mp_g_date_subtract_months, g_date_subtract_months);

 

/*
 * dbus extension definition for:
 * extern void g_date_add_years(GDate *date, guint n_years)
 */
 
STATIC mp_obj_t mp_g_date_add_years(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    guint n_years = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_date_add_years(date, n_years);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_add_years_obj, 2, mp_g_date_add_years, g_date_add_years);

 

/*
 * dbus extension definition for:
 * extern void g_date_subtract_years(GDate *date, guint n_years)
 */
 
STATIC mp_obj_t mp_g_date_subtract_years(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    guint n_years = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_date_subtract_years(date, n_years);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_subtract_years_obj, 2, mp_g_date_subtract_years, g_date_subtract_years);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_is_leap_year(GDateYear year)
 */
 
STATIC mp_obj_t mp_g_date_is_leap_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateYear year = (unsigned short)mp_obj_get_int(mp_args[0]);
    gboolean res = g_date_is_leap_year(year);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_is_leap_year_obj, 1, mp_g_date_is_leap_year, g_date_is_leap_year);

 

/*
 * dbus extension definition for:
 * extern guint8 g_date_get_days_in_month(GDateMonth month, GDateYear year)
 */
 
STATIC mp_obj_t mp_g_date_get_days_in_month(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateMonth month = (int)mp_obj_get_int(mp_args[0]);
    GDateYear year = (unsigned short)mp_obj_get_int(mp_args[1]);
    guint8 res = g_date_get_days_in_month(month, year);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_days_in_month_obj, 2, mp_g_date_get_days_in_month, g_date_get_days_in_month);

 

/*
 * dbus extension definition for:
 * extern guint8 g_date_get_monday_weeks_in_year(GDateYear year)
 */
 
STATIC mp_obj_t mp_g_date_get_monday_weeks_in_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateYear year = (unsigned short)mp_obj_get_int(mp_args[0]);
    guint8 res = g_date_get_monday_weeks_in_year(year);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_monday_weeks_in_year_obj, 1, mp_g_date_get_monday_weeks_in_year, g_date_get_monday_weeks_in_year);

 

/*
 * dbus extension definition for:
 * extern guint8 g_date_get_sunday_weeks_in_year(GDateYear year)
 */
 
STATIC mp_obj_t mp_g_date_get_sunday_weeks_in_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateYear year = (unsigned short)mp_obj_get_int(mp_args[0]);
    guint8 res = g_date_get_sunday_weeks_in_year(year);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_get_sunday_weeks_in_year_obj, 1, mp_g_date_get_sunday_weeks_in_year, g_date_get_sunday_weeks_in_year);

 

/*
 * dbus extension definition for:
 * extern gint g_date_days_between(const GDate *date1, const GDate *date2)
 */
 
STATIC mp_obj_t mp_g_date_days_between(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date1 = mp_to_ptr(mp_args[0]);
    const GDate *date2 = mp_to_ptr(mp_args[1]);
    gint res = g_date_days_between(date1, date2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_days_between_obj, 2, mp_g_date_days_between, g_date_days_between);

 

/*
 * dbus extension definition for:
 * extern gint g_date_compare(const GDate *lhs, const GDate *rhs)
 */
 
STATIC mp_obj_t mp_g_date_compare(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *lhs = mp_to_ptr(mp_args[0]);
    const GDate *rhs = mp_to_ptr(mp_args[1]);
    gint res = g_date_compare(lhs, rhs);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_compare_obj, 2, mp_g_date_compare, g_date_compare);

 

/*
 * dbus extension definition for:
 * extern void g_date_to_struct_tm(const GDate *date, struct tm *tm)
 */
 
STATIC mp_obj_t mp_g_date_to_struct_tm(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GDate *date = mp_to_ptr(mp_args[0]);
    struct tm *tm = mp_to_ptr(mp_args[1]);
    g_date_to_struct_tm(date, tm);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_to_struct_tm_obj, 2, mp_g_date_to_struct_tm, g_date_to_struct_tm);

 

/*
 * dbus extension definition for:
 * extern void g_date_clamp(GDate *date, const GDate *min_date, const GDate *max_date)
 */
 
STATIC mp_obj_t mp_g_date_clamp(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date = mp_to_ptr(mp_args[0]);
    const GDate *min_date = mp_to_ptr(mp_args[1]);
    const GDate *max_date = mp_to_ptr(mp_args[2]);
    g_date_clamp(date, min_date, max_date);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_clamp_obj, 3, mp_g_date_clamp, g_date_clamp);

 

/*
 * dbus extension definition for:
 * extern void g_date_order(GDate *date1, GDate *date2)
 */
 
STATIC mp_obj_t mp_g_date_order(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDate *date1 = mp_to_ptr(mp_args[0]);
    GDate *date2 = mp_to_ptr(mp_args[1]);
    g_date_order(date1, date2);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_order_obj, 2, mp_g_date_order, g_date_order);

 

/*
 * dbus extension definition for:
 * extern gsize g_date_strftime(gchar *s, gsize slen, const gchar *format, const GDate *date)
 */
 
STATIC mp_obj_t mp_g_date_strftime(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar *s = (char*)mp_obj_str_get_str(mp_args[0]);
    gsize slen = (unsigned long)mp_obj_get_int(mp_args[1]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[2]);
    const GDate *date = mp_to_ptr(mp_args[3]);
    gsize res = g_date_strftime(s, slen, format, date);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_strftime_obj, 4, mp_g_date_strftime, g_date_strftime);

 

/*
 * dbus extension definition for:
 * extern GTimeZone *g_time_zone_new(const gchar *identifier)
 */
 
STATIC mp_obj_t mp_g_time_zone_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *identifier = (char*)mp_obj_str_get_str(mp_args[0]);
    GTimeZone * res = g_time_zone_new(identifier);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_time_zone_new_obj, 1, mp_g_time_zone_new, g_time_zone_new);

 

/*
 * dbus extension definition for:
 * extern GTimeZone *g_time_zone_new_utc(void)
 */
 
STATIC mp_obj_t mp_g_time_zone_new_utc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GTimeZone * res = g_time_zone_new_utc();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_time_zone_new_utc_obj, 0, mp_g_time_zone_new_utc, g_time_zone_new_utc);

 

/*
 * dbus extension definition for:
 * extern GTimeZone *g_time_zone_new_local(void)
 */
 
STATIC mp_obj_t mp_g_time_zone_new_local(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GTimeZone * res = g_time_zone_new_local();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_time_zone_new_local_obj, 0, mp_g_time_zone_new_local, g_time_zone_new_local);

 

/*
 * dbus extension definition for:
 * extern GTimeZone *g_time_zone_ref(GTimeZone *tz)
 */
 
STATIC mp_obj_t mp_g_time_zone_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GTimeZone *tz = mp_to_ptr(mp_args[0]);
    GTimeZone * res = g_time_zone_ref(tz);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_time_zone_ref_obj, 1, mp_g_time_zone_ref, g_time_zone_ref);

 

/*
 * dbus extension definition for:
 * extern void g_time_zone_unref(GTimeZone *tz)
 */
 
STATIC mp_obj_t mp_g_time_zone_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GTimeZone *tz = mp_to_ptr(mp_args[0]);
    g_time_zone_unref(tz);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_time_zone_unref_obj, 1, mp_g_time_zone_unref, g_time_zone_unref);

 

/*
 * Function NOT generated:
 * Missing conversion to gint64
 * extern gint g_time_zone_find_interval(GTimeZone *tz, GTimeType type, gint64 time_)
 */
    

/*
 * dbus extension definition for:
 * extern gint g_time_zone_adjust_time(GTimeZone *tz, GTimeType type, gint64 *time_)
 */
 
STATIC mp_obj_t mp_g_time_zone_adjust_time(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GTimeZone *tz = mp_to_ptr(mp_args[0]);
    GTimeType type = (int)mp_obj_get_int(mp_args[1]);
    gint64 *time_ = mp_to_ptr(mp_args[2]);
    gint res = g_time_zone_adjust_time(tz, type, time_);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_time_zone_adjust_time_obj, 3, mp_g_time_zone_adjust_time, g_time_zone_adjust_time);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_time_zone_get_abbreviation(GTimeZone *tz, gint interval)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from gint32
 * extern gint32 g_time_zone_get_offset(GTimeZone *tz, gint interval)
 */
    

/*
 * dbus extension definition for:
 * extern gboolean g_time_zone_is_dst(GTimeZone *tz, gint interval)
 */
 
STATIC mp_obj_t mp_g_time_zone_is_dst(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GTimeZone *tz = mp_to_ptr(mp_args[0]);
    gint interval = (int)mp_obj_get_int(mp_args[1]);
    gboolean res = g_time_zone_is_dst(tz, interval);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_time_zone_is_dst_obj, 2, mp_g_time_zone_is_dst, g_time_zone_is_dst);

 

/*
 * dbus extension definition for:
 * extern void g_date_time_unref(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    g_date_time_unref(datetime);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_unref_obj, 1, mp_g_date_time_unref, g_date_time_unref);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_ref(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    GDateTime * res = g_date_time_ref(datetime);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_ref_obj, 1, mp_g_date_time_ref, g_date_time_ref);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_new_now(GTimeZone *tz)
 */
 
STATIC mp_obj_t mp_g_date_time_new_now(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GTimeZone *tz = mp_to_ptr(mp_args[0]);
    GDateTime * res = g_date_time_new_now(tz);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_new_now_obj, 1, mp_g_date_time_new_now, g_date_time_new_now);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_new_now_local(void)
 */
 
STATIC mp_obj_t mp_g_date_time_new_now_local(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GDateTime * res = g_date_time_new_now_local();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_new_now_local_obj, 0, mp_g_date_time_new_now_local, g_date_time_new_now_local);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_new_now_utc(void)
 */
 
STATIC mp_obj_t mp_g_date_time_new_now_utc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GDateTime * res = g_date_time_new_now_utc();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_new_now_utc_obj, 0, mp_g_date_time_new_now_utc, g_date_time_new_now_utc);

 

/*
 * Function NOT generated:
 * Missing conversion to gint64
 * extern GDateTime *g_date_time_new_from_unix_local(gint64 t)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gint64
 * extern GDateTime *g_date_time_new_from_unix_utc(gint64 t)
 */
    

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_new_from_timeval_local(const GTimeVal *tv)
 */
 
STATIC mp_obj_t mp_g_date_time_new_from_timeval_local(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GTimeVal *tv = mp_to_ptr(mp_args[0]);
    GDateTime * res = g_date_time_new_from_timeval_local(tv);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_new_from_timeval_local_obj, 1, mp_g_date_time_new_from_timeval_local, g_date_time_new_from_timeval_local);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_new_from_timeval_utc(const GTimeVal *tv)
 */
 
STATIC mp_obj_t mp_g_date_time_new_from_timeval_utc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GTimeVal *tv = mp_to_ptr(mp_args[0]);
    GDateTime * res = g_date_time_new_from_timeval_utc(tv);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_new_from_timeval_utc_obj, 1, mp_g_date_time_new_from_timeval_utc, g_date_time_new_from_timeval_utc);

 

/*
 * Function NOT generated:
 * Missing conversion to gdouble
 * extern GDateTime *g_date_time_new(GTimeZone *tz, gint year, gint month, gint day, gint hour, gint minute, gdouble seconds)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gdouble
 * extern GDateTime *g_date_time_new_local(gint year, gint month, gint day, gint hour, gint minute, gdouble seconds)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gdouble
 * extern GDateTime *g_date_time_new_utc(gint year, gint month, gint day, gint hour, gint minute, gdouble seconds)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to GTimeSpan
 * extern GDateTime *g_date_time_add(GDateTime *datetime, GTimeSpan timespan)
 */
    

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_add_years(GDateTime *datetime, gint years)
 */
 
STATIC mp_obj_t mp_g_date_time_add_years(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint years = (int)mp_obj_get_int(mp_args[1]);
    GDateTime * res = g_date_time_add_years(datetime, years);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_add_years_obj, 2, mp_g_date_time_add_years, g_date_time_add_years);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_add_months(GDateTime *datetime, gint months)
 */
 
STATIC mp_obj_t mp_g_date_time_add_months(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint months = (int)mp_obj_get_int(mp_args[1]);
    GDateTime * res = g_date_time_add_months(datetime, months);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_add_months_obj, 2, mp_g_date_time_add_months, g_date_time_add_months);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_add_weeks(GDateTime *datetime, gint weeks)
 */
 
STATIC mp_obj_t mp_g_date_time_add_weeks(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint weeks = (int)mp_obj_get_int(mp_args[1]);
    GDateTime * res = g_date_time_add_weeks(datetime, weeks);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_add_weeks_obj, 2, mp_g_date_time_add_weeks, g_date_time_add_weeks);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_add_days(GDateTime *datetime, gint days)
 */
 
STATIC mp_obj_t mp_g_date_time_add_days(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint days = (int)mp_obj_get_int(mp_args[1]);
    GDateTime * res = g_date_time_add_days(datetime, days);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_add_days_obj, 2, mp_g_date_time_add_days, g_date_time_add_days);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_add_hours(GDateTime *datetime, gint hours)
 */
 
STATIC mp_obj_t mp_g_date_time_add_hours(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint hours = (int)mp_obj_get_int(mp_args[1]);
    GDateTime * res = g_date_time_add_hours(datetime, hours);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_add_hours_obj, 2, mp_g_date_time_add_hours, g_date_time_add_hours);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_add_minutes(GDateTime *datetime, gint minutes)
 */
 
STATIC mp_obj_t mp_g_date_time_add_minutes(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint minutes = (int)mp_obj_get_int(mp_args[1]);
    GDateTime * res = g_date_time_add_minutes(datetime, minutes);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_add_minutes_obj, 2, mp_g_date_time_add_minutes, g_date_time_add_minutes);

 

/*
 * Function NOT generated:
 * Missing conversion to gdouble
 * extern GDateTime *g_date_time_add_seconds(GDateTime *datetime, gdouble seconds)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gdouble
 * extern GDateTime *g_date_time_add_full(GDateTime *datetime, gint years, gint months, gint days, gint hours, gint minutes, gdouble seconds)
 */
    

/*
 * dbus extension definition for:
 * extern gint g_date_time_compare(gconstpointer dt1, gconstpointer dt2)
 */
 
STATIC mp_obj_t mp_g_date_time_compare(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer dt1 = mp_to_ptr(mp_args[0]);
    gconstpointer dt2 = mp_to_ptr(mp_args[1]);
    gint res = g_date_time_compare(dt1, dt2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_compare_obj, 2, mp_g_date_time_compare, g_date_time_compare);

 

/*
 * Function NOT generated:
 * Missing convertion from GTimeSpan
 * extern GTimeSpan g_date_time_difference(GDateTime *end, GDateTime *begin)
 */
    

/*
 * dbus extension definition for:
 * extern guint g_date_time_hash(gconstpointer datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_hash(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer datetime = mp_to_ptr(mp_args[0]);
    guint res = g_date_time_hash(datetime);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_hash_obj, 1, mp_g_date_time_hash, g_date_time_hash);

 

/*
 * dbus extension definition for:
 * extern gboolean g_date_time_equal(gconstpointer dt1, gconstpointer dt2)
 */
 
STATIC mp_obj_t mp_g_date_time_equal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer dt1 = mp_to_ptr(mp_args[0]);
    gconstpointer dt2 = mp_to_ptr(mp_args[1]);
    gboolean res = g_date_time_equal(dt1, dt2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_equal_obj, 2, mp_g_date_time_equal, g_date_time_equal);

 

/*
 * dbus extension definition for:
 * extern void g_date_time_get_ymd(GDateTime *datetime, gint *year, gint *month, gint *day)
 */
 
STATIC mp_obj_t mp_g_date_time_get_ymd(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint *year = mp_to_ptr(mp_args[1]);
    gint *month = mp_to_ptr(mp_args[2]);
    gint *day = mp_to_ptr(mp_args[3]);
    g_date_time_get_ymd(datetime, year, month, day);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_ymd_obj, 4, mp_g_date_time_get_ymd, g_date_time_get_ymd);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_year(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_year(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_year_obj, 1, mp_g_date_time_get_year, g_date_time_get_year);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_month(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_month(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_month(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_month_obj, 1, mp_g_date_time_get_month, g_date_time_get_month);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_day_of_month(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_day_of_month(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_day_of_month(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_day_of_month_obj, 1, mp_g_date_time_get_day_of_month, g_date_time_get_day_of_month);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_week_numbering_year(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_week_numbering_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_week_numbering_year(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_week_numbering_year_obj, 1, mp_g_date_time_get_week_numbering_year, g_date_time_get_week_numbering_year);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_week_of_year(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_week_of_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_week_of_year(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_week_of_year_obj, 1, mp_g_date_time_get_week_of_year, g_date_time_get_week_of_year);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_day_of_week(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_day_of_week(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_day_of_week(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_day_of_week_obj, 1, mp_g_date_time_get_day_of_week, g_date_time_get_day_of_week);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_day_of_year(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_day_of_year(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_day_of_year(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_day_of_year_obj, 1, mp_g_date_time_get_day_of_year, g_date_time_get_day_of_year);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_hour(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_hour(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_hour(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_hour_obj, 1, mp_g_date_time_get_hour, g_date_time_get_hour);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_minute(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_minute(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_minute(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_minute_obj, 1, mp_g_date_time_get_minute, g_date_time_get_minute);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_second(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_second(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_second(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_second_obj, 1, mp_g_date_time_get_second, g_date_time_get_second);

 

/*
 * dbus extension definition for:
 * extern gint g_date_time_get_microsecond(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_get_microsecond(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gint res = g_date_time_get_microsecond(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_get_microsecond_obj, 1, mp_g_date_time_get_microsecond, g_date_time_get_microsecond);

 

/*
 * Function NOT generated:
 * Missing convertion from gdouble
 * extern gdouble g_date_time_get_seconds(GDateTime *datetime)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from gint64
 * extern gint64 g_date_time_to_unix(GDateTime *datetime)
 */
    

/*
 * dbus extension definition for:
 * extern gboolean g_date_time_to_timeval(GDateTime *datetime, GTimeVal *tv)
 */
 
STATIC mp_obj_t mp_g_date_time_to_timeval(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    GTimeVal *tv = mp_to_ptr(mp_args[1]);
    gboolean res = g_date_time_to_timeval(datetime, tv);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_to_timeval_obj, 2, mp_g_date_time_to_timeval, g_date_time_to_timeval);

 

/*
 * Function NOT generated:
 * Missing convertion from GTimeSpan
 * extern GTimeSpan g_date_time_get_utc_offset(GDateTime *datetime)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_date_time_get_timezone_abbreviation(GDateTime *datetime)
 */
    

/*
 * dbus extension definition for:
 * extern gboolean g_date_time_is_daylight_savings(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_is_daylight_savings(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    gboolean res = g_date_time_is_daylight_savings(datetime);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_is_daylight_savings_obj, 1, mp_g_date_time_is_daylight_savings, g_date_time_is_daylight_savings);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_to_timezone(GDateTime *datetime, GTimeZone *tz)
 */
 
STATIC mp_obj_t mp_g_date_time_to_timezone(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    GTimeZone *tz = mp_to_ptr(mp_args[1]);
    GDateTime * res = g_date_time_to_timezone(datetime, tz);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_to_timezone_obj, 2, mp_g_date_time_to_timezone, g_date_time_to_timezone);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_to_local(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_to_local(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    GDateTime * res = g_date_time_to_local(datetime);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_to_local_obj, 1, mp_g_date_time_to_local, g_date_time_to_local);

 

/*
 * dbus extension definition for:
 * extern GDateTime *g_date_time_to_utc(GDateTime *datetime)
 */
 
STATIC mp_obj_t mp_g_date_time_to_utc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    GDateTime * res = g_date_time_to_utc(datetime);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_to_utc_obj, 1, mp_g_date_time_to_utc, g_date_time_to_utc);

 

/*
 * dbus extension definition for:
 * extern gchar *g_date_time_format(GDateTime *datetime, const gchar *format)
 */
 
STATIC mp_obj_t mp_g_date_time_format(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDateTime *datetime = mp_to_ptr(mp_args[0]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[1]);
    gchar * res = g_date_time_format(datetime, format);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_date_time_format_obj, 2, mp_g_date_time_format, g_date_time_format);

 

/*
 * dbus extension definition for:
 * extern DIR *opendir(const char *__name)
 */
 
STATIC mp_obj_t mp_opendir(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *__name = (char*)mp_obj_str_get_str(mp_args[0]);
    DIR * res = opendir(__name);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_opendir_obj, 1, mp_opendir, opendir);

 

/*
 * dbus extension definition for:
 * extern int closedir(DIR *__dirp)
 */
 
STATIC mp_obj_t mp_closedir(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DIR *__dirp = mp_to_ptr(mp_args[0]);
    int res = closedir(__dirp);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_closedir_obj, 1, mp_closedir, closedir);

 

/*
 * dbus extension definition for:
 * extern struct dirent *readdir(DIR *__dirp)
 */
 
STATIC mp_obj_t mp_readdir(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DIR *__dirp = mp_to_ptr(mp_args[0]);
    struct dirent * res = readdir(__dirp);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_readdir_obj, 1, mp_readdir, readdir);

 

/*
 * dbus extension definition for:
 * extern void rewinddir(DIR *__dirp)
 */
 
STATIC mp_obj_t mp_rewinddir(size_t mp_n_args, const mp_obj_t *mp_args)
{
    DIR *__dirp = mp_to_ptr(mp_args[0]);
    rewinddir(__dirp);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_rewinddir_obj, 1, mp_rewinddir, rewinddir);

 

/*
 * dbus extension definition for:
 * extern GDir *g_dir_open(const gchar *path, guint flags, GError **error)
 */
 
STATIC mp_obj_t mp_g_dir_open(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *path = (char*)mp_obj_str_get_str(mp_args[0]);
    guint flags = (unsigned int)mp_obj_get_int(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    GDir * res = g_dir_open(path, flags, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_dir_open_obj, 3, mp_g_dir_open, g_dir_open);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_dir_read_name(GDir *dir)
 */
    

/*
 * dbus extension definition for:
 * extern void g_dir_rewind(GDir *dir)
 */
 
STATIC mp_obj_t mp_g_dir_rewind(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDir *dir = mp_to_ptr(mp_args[0]);
    g_dir_rewind(dir);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_dir_rewind_obj, 1, mp_g_dir_rewind, g_dir_rewind);

 

/*
 * dbus extension definition for:
 * extern void g_dir_close(GDir *dir)
 */
 
STATIC mp_obj_t mp_g_dir_close(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GDir *dir = mp_to_ptr(mp_args[0]);
    g_dir_close(dir);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_dir_close_obj, 1, mp_g_dir_close, g_dir_close);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_getenv(const gchar *variable)
 */
    

/*
 * dbus extension definition for:
 * extern gboolean g_setenv(const gchar *variable, const gchar *value, gboolean overwrite)
 */
 
STATIC mp_obj_t mp_g_setenv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *variable = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *value = (char*)mp_obj_str_get_str(mp_args[1]);
    gboolean overwrite = (int)mp_obj_get_int(mp_args[2]);
    gboolean res = g_setenv(variable, value, overwrite);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_setenv_obj, 3, mp_g_setenv, g_setenv);

 

/*
 * dbus extension definition for:
 * extern void g_unsetenv(const gchar *variable)
 */
 
STATIC mp_obj_t mp_g_unsetenv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *variable = (char*)mp_obj_str_get_str(mp_args[0]);
    g_unsetenv(variable);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unsetenv_obj, 1, mp_g_unsetenv, g_unsetenv);

 

/*
 * dbus extension definition for:
 * extern gchar **g_listenv(void)
 */
 
STATIC mp_obj_t mp_g_listenv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    gchar ** res = g_listenv();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_listenv_obj, 0, mp_g_listenv, g_listenv);

 

/*
 * dbus extension definition for:
 * extern gchar **g_get_environ(void)
 */
 
STATIC mp_obj_t mp_g_get_environ(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    gchar ** res = g_get_environ();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_get_environ_obj, 0, mp_g_get_environ, g_get_environ);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_environ_getenv(gchar **envp, const gchar *variable)
 */
    

/*
 * dbus extension definition for:
 * extern gchar **g_environ_setenv(gchar **envp, const gchar *variable, const gchar *value, gboolean overwrite)
 */
 
STATIC mp_obj_t mp_g_environ_setenv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar **envp = mp_to_ptr(mp_args[0]);
    const gchar *variable = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *value = (char*)mp_obj_str_get_str(mp_args[2]);
    gboolean overwrite = (int)mp_obj_get_int(mp_args[3]);
    gchar ** res = g_environ_setenv(envp, variable, value, overwrite);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_environ_setenv_obj, 4, mp_g_environ_setenv, g_environ_setenv);

 

/*
 * dbus extension definition for:
 * extern gchar **g_environ_unsetenv(gchar **envp, const gchar *variable)
 */
 
STATIC mp_obj_t mp_g_environ_unsetenv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar **envp = mp_to_ptr(mp_args[0]);
    const gchar *variable = (char*)mp_obj_str_get_str(mp_args[1]);
    gchar ** res = g_environ_unsetenv(envp, variable);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_environ_unsetenv_obj, 2, mp_g_environ_unsetenv, g_environ_unsetenv);

 

/*
 * dbus extension definition for:
 * extern GQuark g_file_error_quark(void)
 */
 
STATIC mp_obj_t mp_g_file_error_quark(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GQuark res = g_file_error_quark();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_file_error_quark_obj, 0, mp_g_file_error_quark, g_file_error_quark);

 

/*
 * dbus extension definition for:
 * extern GFileError g_file_error_from_errno(gint err_no)
 */
 
STATIC mp_obj_t mp_g_file_error_from_errno(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gint err_no = (int)mp_obj_get_int(mp_args[0]);
    GFileError res = g_file_error_from_errno(err_no);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_file_error_from_errno_obj, 1, mp_g_file_error_from_errno, g_file_error_from_errno);

 

/*
 * dbus extension definition for:
 * extern gboolean g_file_test(const gchar *filename, GFileTest test)
 */
 
STATIC mp_obj_t mp_g_file_test(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[0]);
    GFileTest test = (int)mp_obj_get_int(mp_args[1]);
    gboolean res = g_file_test(filename, test);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_file_test_obj, 2, mp_g_file_test, g_file_test);

 

/*
 * dbus extension definition for:
 * extern gboolean g_file_get_contents(const gchar *filename, gchar **contents, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_file_get_contents(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar **contents = mp_to_ptr(mp_args[1]);
    gsize *length = mp_to_ptr(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_file_get_contents(filename, contents, length, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_file_get_contents_obj, 4, mp_g_file_get_contents, g_file_get_contents);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gboolean g_file_set_contents(const gchar *filename, const gchar *contents, gssize length, GError **error)
 */
    

/*
 * dbus extension definition for:
 * extern gchar *g_file_read_link(const gchar *filename, GError **error)
 */
 
STATIC mp_obj_t mp_g_file_read_link(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[0]);
    GError **error = mp_to_ptr(mp_args[1]);
    gchar * res = g_file_read_link(filename, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_file_read_link_obj, 2, mp_g_file_read_link, g_file_read_link);

 

/*
 * dbus extension definition for:
 * extern gchar *g_mkdtemp(gchar *tmpl)
 */
 
STATIC mp_obj_t mp_g_mkdtemp(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar *tmpl = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_mkdtemp(tmpl);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mkdtemp_obj, 1, mp_g_mkdtemp, g_mkdtemp);

 

/*
 * dbus extension definition for:
 * extern gchar *g_mkdtemp_full(gchar *tmpl, gint mode)
 */
 
STATIC mp_obj_t mp_g_mkdtemp_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar *tmpl = (char*)mp_obj_str_get_str(mp_args[0]);
    gint mode = (int)mp_obj_get_int(mp_args[1]);
    gchar * res = g_mkdtemp_full(tmpl, mode);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mkdtemp_full_obj, 2, mp_g_mkdtemp_full, g_mkdtemp_full);

 

/*
 * dbus extension definition for:
 * extern gint g_mkstemp(gchar *tmpl)
 */
 
STATIC mp_obj_t mp_g_mkstemp(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar *tmpl = (char*)mp_obj_str_get_str(mp_args[0]);
    gint res = g_mkstemp(tmpl);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mkstemp_obj, 1, mp_g_mkstemp, g_mkstemp);

 

/*
 * dbus extension definition for:
 * extern gint g_mkstemp_full(gchar *tmpl, gint flags, gint mode)
 */
 
STATIC mp_obj_t mp_g_mkstemp_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar *tmpl = (char*)mp_obj_str_get_str(mp_args[0]);
    gint flags = (int)mp_obj_get_int(mp_args[1]);
    gint mode = (int)mp_obj_get_int(mp_args[2]);
    gint res = g_mkstemp_full(tmpl, flags, mode);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mkstemp_full_obj, 3, mp_g_mkstemp_full, g_mkstemp_full);

 

/*
 * dbus extension definition for:
 * extern gint g_file_open_tmp(const gchar *tmpl, gchar **name_used, GError **error)
 */
 
STATIC mp_obj_t mp_g_file_open_tmp(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *tmpl = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar **name_used = mp_to_ptr(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gint res = g_file_open_tmp(tmpl, name_used, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_file_open_tmp_obj, 3, mp_g_file_open_tmp, g_file_open_tmp);

 

/*
 * dbus extension definition for:
 * extern gchar *g_dir_make_tmp(const gchar *tmpl, GError **error)
 */
 
STATIC mp_obj_t mp_g_dir_make_tmp(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *tmpl = (char*)mp_obj_str_get_str(mp_args[0]);
    GError **error = mp_to_ptr(mp_args[1]);
    gchar * res = g_dir_make_tmp(tmpl, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_dir_make_tmp_obj, 2, mp_g_dir_make_tmp, g_dir_make_tmp);

 

/*
 * dbus extension definition for:
 * extern gchar *g_build_path(const gchar *separator, const gchar *first_element, ...)
 */
 
STATIC mp_obj_t mp_g_build_path(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *separator = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *first_element = (char*)mp_obj_str_get_str(mp_args[1]);
    gchar * res = g_build_path(separator, first_element);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_build_path_obj, 3, mp_g_build_path, g_build_path);

 

/*
 * dbus extension definition for:
 * extern gchar *g_build_pathv(const gchar *separator, gchar **args)
 */
 
STATIC mp_obj_t mp_g_build_pathv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *separator = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar **args = mp_to_ptr(mp_args[1]);
    gchar * res = g_build_pathv(separator, args);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_build_pathv_obj, 2, mp_g_build_pathv, g_build_pathv);

 

/*
 * dbus extension definition for:
 * extern gchar *g_build_filename(const gchar *first_element, ...)
 */
 
STATIC mp_obj_t mp_g_build_filename(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *first_element = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_build_filename(first_element);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_build_filename_obj, 2, mp_g_build_filename, g_build_filename);

 

/*
 * dbus extension definition for:
 * extern gchar *g_build_filenamev(gchar **args)
 */
 
STATIC mp_obj_t mp_g_build_filenamev(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar **args = mp_to_ptr(mp_args[0]);
    gchar * res = g_build_filenamev(args);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_build_filenamev_obj, 1, mp_g_build_filenamev, g_build_filenamev);

 

/*
 * dbus extension definition for:
 * extern gint g_mkdir_with_parents(const gchar *pathname, gint mode)
 */
 
STATIC mp_obj_t mp_g_mkdir_with_parents(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *pathname = (char*)mp_obj_str_get_str(mp_args[0]);
    gint mode = (int)mp_obj_get_int(mp_args[1]);
    gint res = g_mkdir_with_parents(pathname, mode);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mkdir_with_parents_obj, 2, mp_g_mkdir_with_parents, g_mkdir_with_parents);

 

/*
 * dbus extension definition for:
 * extern gboolean g_path_is_absolute(const gchar *file_name)
 */
 
STATIC mp_obj_t mp_g_path_is_absolute(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *file_name = (char*)mp_obj_str_get_str(mp_args[0]);
    gboolean res = g_path_is_absolute(file_name);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_path_is_absolute_obj, 1, mp_g_path_is_absolute, g_path_is_absolute);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_path_skip_root(const gchar *file_name)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_basename(const gchar *file_name)
 */
    

/*
 * dbus extension definition for:
 * extern gchar *g_get_current_dir(void)
 */
 
STATIC mp_obj_t mp_g_get_current_dir(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    gchar * res = g_get_current_dir();
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_get_current_dir_obj, 0, mp_g_get_current_dir, g_get_current_dir);

 

/*
 * dbus extension definition for:
 * extern gchar *g_path_get_basename(const gchar *file_name)
 */
 
STATIC mp_obj_t mp_g_path_get_basename(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *file_name = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_path_get_basename(file_name);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_path_get_basename_obj, 1, mp_g_path_get_basename, g_path_get_basename);

 

/*
 * dbus extension definition for:
 * extern gchar *g_path_get_dirname(const gchar *file_name)
 */
 
STATIC mp_obj_t mp_g_path_get_dirname(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *file_name = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_path_get_dirname(file_name);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_path_get_dirname_obj, 1, mp_g_path_get_dirname, g_path_get_dirname);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_strip_context(const gchar *msgid, const gchar *msgval)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_dgettext(const gchar *domain, const gchar *msgid)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_dcgettext(const gchar *domain, const gchar *msgid, gint category)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_dngettext(const gchar *domain, const gchar *msgid, const gchar *msgid_plural, gulong n)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_dpgettext(const gchar *domain, const gchar *msgctxtid, gsize msgidoffset)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_dpgettext2(const gchar *domain, const gchar *context, const gchar *msgid)
 */
    

/*
 * dbus extension definition for:
 * extern void g_free(gpointer mem)
 */
 
STATIC mp_obj_t mp_g_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer mem = mp_to_ptr(mp_args[0]);
    g_free(mem);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_free_obj, 1, mp_g_free, g_free);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify destroy' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify destroy
 */
    

/*
 * dbus extension definition for:
 * extern void g_clear_pointer(gpointer *pp, GDestroyNotify destroy)
 */
 
STATIC mp_obj_t mp_g_clear_pointer(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer *pp = mp_to_ptr(mp_args[0]);
    GDestroyNotify destroy = mp_to_ptr(mp_args[1]);
    g_clear_pointer(pp, destroy);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_clear_pointer_obj, 2, mp_g_clear_pointer, g_clear_pointer);

 

/*
 * dbus extension definition for:
 * extern gpointer g_malloc(gsize n_bytes)
 */
 
STATIC mp_obj_t mp_g_malloc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gsize n_bytes = (unsigned long)mp_obj_get_int(mp_args[0]);
    gpointer res = g_malloc(n_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_malloc_obj, 1, mp_g_malloc, g_malloc);

 

/*
 * dbus extension definition for:
 * extern gpointer g_malloc0(gsize n_bytes)
 */
 
STATIC mp_obj_t mp_g_malloc0(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gsize n_bytes = (unsigned long)mp_obj_get_int(mp_args[0]);
    gpointer res = g_malloc0(n_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_malloc0_obj, 1, mp_g_malloc0, g_malloc0);

 

/*
 * dbus extension definition for:
 * extern gpointer g_realloc(gpointer mem, gsize n_bytes)
 */
 
STATIC mp_obj_t mp_g_realloc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer mem = mp_to_ptr(mp_args[0]);
    gsize n_bytes = (unsigned long)mp_obj_get_int(mp_args[1]);
    gpointer res = g_realloc(mem, n_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_realloc_obj, 2, mp_g_realloc, g_realloc);

 

/*
 * dbus extension definition for:
 * extern gpointer g_try_malloc(gsize n_bytes)
 */
 
STATIC mp_obj_t mp_g_try_malloc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gsize n_bytes = (unsigned long)mp_obj_get_int(mp_args[0]);
    gpointer res = g_try_malloc(n_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_try_malloc_obj, 1, mp_g_try_malloc, g_try_malloc);

 

/*
 * dbus extension definition for:
 * extern gpointer g_try_malloc0(gsize n_bytes)
 */
 
STATIC mp_obj_t mp_g_try_malloc0(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gsize n_bytes = (unsigned long)mp_obj_get_int(mp_args[0]);
    gpointer res = g_try_malloc0(n_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_try_malloc0_obj, 1, mp_g_try_malloc0, g_try_malloc0);

 

/*
 * dbus extension definition for:
 * extern gpointer g_try_realloc(gpointer mem, gsize n_bytes)
 */
 
STATIC mp_obj_t mp_g_try_realloc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer mem = mp_to_ptr(mp_args[0]);
    gsize n_bytes = (unsigned long)mp_obj_get_int(mp_args[1]);
    gpointer res = g_try_realloc(mem, n_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_try_realloc_obj, 2, mp_g_try_realloc, g_try_realloc);

 

/*
 * dbus extension definition for:
 * extern gpointer g_malloc_n(gsize n_blocks, gsize n_block_bytes)
 */
 
STATIC mp_obj_t mp_g_malloc_n(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gsize n_blocks = (unsigned long)mp_obj_get_int(mp_args[0]);
    gsize n_block_bytes = (unsigned long)mp_obj_get_int(mp_args[1]);
    gpointer res = g_malloc_n(n_blocks, n_block_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_malloc_n_obj, 2, mp_g_malloc_n, g_malloc_n);

 

/*
 * dbus extension definition for:
 * extern gpointer g_malloc0_n(gsize n_blocks, gsize n_block_bytes)
 */
 
STATIC mp_obj_t mp_g_malloc0_n(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gsize n_blocks = (unsigned long)mp_obj_get_int(mp_args[0]);
    gsize n_block_bytes = (unsigned long)mp_obj_get_int(mp_args[1]);
    gpointer res = g_malloc0_n(n_blocks, n_block_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_malloc0_n_obj, 2, mp_g_malloc0_n, g_malloc0_n);

 

/*
 * dbus extension definition for:
 * extern gpointer g_realloc_n(gpointer mem, gsize n_blocks, gsize n_block_bytes)
 */
 
STATIC mp_obj_t mp_g_realloc_n(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer mem = mp_to_ptr(mp_args[0]);
    gsize n_blocks = (unsigned long)mp_obj_get_int(mp_args[1]);
    gsize n_block_bytes = (unsigned long)mp_obj_get_int(mp_args[2]);
    gpointer res = g_realloc_n(mem, n_blocks, n_block_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_realloc_n_obj, 3, mp_g_realloc_n, g_realloc_n);

 

/*
 * dbus extension definition for:
 * extern gpointer g_try_malloc_n(gsize n_blocks, gsize n_block_bytes)
 */
 
STATIC mp_obj_t mp_g_try_malloc_n(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gsize n_blocks = (unsigned long)mp_obj_get_int(mp_args[0]);
    gsize n_block_bytes = (unsigned long)mp_obj_get_int(mp_args[1]);
    gpointer res = g_try_malloc_n(n_blocks, n_block_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_try_malloc_n_obj, 2, mp_g_try_malloc_n, g_try_malloc_n);

 

/*
 * dbus extension definition for:
 * extern gpointer g_try_malloc0_n(gsize n_blocks, gsize n_block_bytes)
 */
 
STATIC mp_obj_t mp_g_try_malloc0_n(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gsize n_blocks = (unsigned long)mp_obj_get_int(mp_args[0]);
    gsize n_block_bytes = (unsigned long)mp_obj_get_int(mp_args[1]);
    gpointer res = g_try_malloc0_n(n_blocks, n_block_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_try_malloc0_n_obj, 2, mp_g_try_malloc0_n, g_try_malloc0_n);

 

/*
 * dbus extension definition for:
 * extern gpointer g_try_realloc_n(gpointer mem, gsize n_blocks, gsize n_block_bytes)
 */
 
STATIC mp_obj_t mp_g_try_realloc_n(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer mem = mp_to_ptr(mp_args[0]);
    gsize n_blocks = (unsigned long)mp_obj_get_int(mp_args[1]);
    gsize n_block_bytes = (unsigned long)mp_obj_get_int(mp_args[2]);
    gpointer res = g_try_realloc_n(mem, n_blocks, n_block_bytes);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_try_realloc_n_obj, 3, mp_g_try_realloc_n, g_try_realloc_n);

 

/*
 * dbus extension definition for:
 * extern void g_mem_set_vtable(GMemVTable *vtable)
 */
 
STATIC mp_obj_t mp_g_mem_set_vtable(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMemVTable *vtable = mp_to_ptr(mp_args[0]);
    g_mem_set_vtable(vtable);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mem_set_vtable_obj, 1, mp_g_mem_set_vtable, g_mem_set_vtable);

 

/*
 * dbus extension definition for:
 * extern gboolean g_mem_is_system_malloc(void)
 */
 
STATIC mp_obj_t mp_g_mem_is_system_malloc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    gboolean res = g_mem_is_system_malloc();
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mem_is_system_malloc_obj, 0, mp_g_mem_is_system_malloc, g_mem_is_system_malloc);

 

/*
 * dbus extension definition for:
 * extern void g_mem_profile(void)
 */
 
STATIC mp_obj_t mp_g_mem_profile(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    g_mem_profile();
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mem_profile_obj, 0, mp_g_mem_profile, g_mem_profile);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_new(gpointer data)
 */
 
STATIC mp_obj_t mp_g_node_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer data = mp_to_ptr(mp_args[0]);
    GNode * res = g_node_new(data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_new_obj, 1, mp_g_node_new, g_node_new);

 

/*
 * dbus extension definition for:
 * extern void g_node_destroy(GNode *root)
 */
 
STATIC mp_obj_t mp_g_node_destroy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *root = mp_to_ptr(mp_args[0]);
    g_node_destroy(root);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_destroy_obj, 1, mp_g_node_destroy, g_node_destroy);

 

/*
 * dbus extension definition for:
 * extern void g_node_unlink(GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_unlink(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    g_node_unlink(node);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_unlink_obj, 1, mp_g_node_unlink, g_node_unlink);

 

/*
 * Function NOT generated:
 * Callback function 'GCopyFunc copy_func' must receive a struct pointer with user_data member as its first argument!
 * GCopyFunc copy_func
 */
    

/*
 * dbus extension definition for:
 * extern GNode *g_node_copy_deep(GNode *node, GCopyFunc copy_func, gpointer data)
 */
 
STATIC mp_obj_t mp_g_node_copy_deep(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    GCopyFunc copy_func = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GNode * res = g_node_copy_deep(node, copy_func, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_copy_deep_obj, 3, mp_g_node_copy_deep, g_node_copy_deep);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_copy(GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_copy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    GNode * res = g_node_copy(node);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_copy_obj, 1, mp_g_node_copy, g_node_copy);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_insert(GNode *parent, gint position, GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_insert(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *parent = mp_to_ptr(mp_args[0]);
    gint position = (int)mp_obj_get_int(mp_args[1]);
    GNode *node = mp_to_ptr(mp_args[2]);
    GNode * res = g_node_insert(parent, position, node);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_insert_obj, 3, mp_g_node_insert, g_node_insert);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_insert_before(GNode *parent, GNode *sibling, GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_insert_before(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *parent = mp_to_ptr(mp_args[0]);
    GNode *sibling = mp_to_ptr(mp_args[1]);
    GNode *node = mp_to_ptr(mp_args[2]);
    GNode * res = g_node_insert_before(parent, sibling, node);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_insert_before_obj, 3, mp_g_node_insert_before, g_node_insert_before);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_insert_after(GNode *parent, GNode *sibling, GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_insert_after(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *parent = mp_to_ptr(mp_args[0]);
    GNode *sibling = mp_to_ptr(mp_args[1]);
    GNode *node = mp_to_ptr(mp_args[2]);
    GNode * res = g_node_insert_after(parent, sibling, node);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_insert_after_obj, 3, mp_g_node_insert_after, g_node_insert_after);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_prepend(GNode *parent, GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_prepend(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *parent = mp_to_ptr(mp_args[0]);
    GNode *node = mp_to_ptr(mp_args[1]);
    GNode * res = g_node_prepend(parent, node);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_prepend_obj, 2, mp_g_node_prepend, g_node_prepend);

 

/*
 * dbus extension definition for:
 * extern guint g_node_n_nodes(GNode *root, GTraverseFlags flags)
 */
 
STATIC mp_obj_t mp_g_node_n_nodes(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *root = mp_to_ptr(mp_args[0]);
    GTraverseFlags flags = (int)mp_obj_get_int(mp_args[1]);
    guint res = g_node_n_nodes(root, flags);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_n_nodes_obj, 2, mp_g_node_n_nodes, g_node_n_nodes);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_get_root(GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_get_root(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    GNode * res = g_node_get_root(node);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_get_root_obj, 1, mp_g_node_get_root, g_node_get_root);

 

/*
 * dbus extension definition for:
 * extern gboolean g_node_is_ancestor(GNode *node, GNode *descendant)
 */
 
STATIC mp_obj_t mp_g_node_is_ancestor(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    GNode *descendant = mp_to_ptr(mp_args[1]);
    gboolean res = g_node_is_ancestor(node, descendant);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_is_ancestor_obj, 2, mp_g_node_is_ancestor, g_node_is_ancestor);

 

/*
 * dbus extension definition for:
 * extern guint g_node_depth(GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_depth(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    guint res = g_node_depth(node);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_depth_obj, 1, mp_g_node_depth, g_node_depth);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_find(GNode *root, GTraverseType order, GTraverseFlags flags, gpointer data)
 */
 
STATIC mp_obj_t mp_g_node_find(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *root = mp_to_ptr(mp_args[0]);
    GTraverseType order = (int)mp_obj_get_int(mp_args[1]);
    GTraverseFlags flags = (int)mp_obj_get_int(mp_args[2]);
    gpointer data = mp_to_ptr(mp_args[3]);
    GNode * res = g_node_find(root, order, flags, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_find_obj, 4, mp_g_node_find, g_node_find);

 

/*
 * Function NOT generated:
 * Callback function 'GNodeTraverseFunc func' must receive a struct pointer with user_data member as its first argument!
 * GNodeTraverseFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_node_traverse(GNode *root, GTraverseType order, GTraverseFlags flags, gint max_depth, GNodeTraverseFunc func, gpointer data)
 */
 
STATIC mp_obj_t mp_g_node_traverse(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *root = mp_to_ptr(mp_args[0]);
    GTraverseType order = (int)mp_obj_get_int(mp_args[1]);
    GTraverseFlags flags = (int)mp_obj_get_int(mp_args[2]);
    gint max_depth = (int)mp_obj_get_int(mp_args[3]);
    GNodeTraverseFunc func = mp_to_ptr(mp_args[4]);
    gpointer data = mp_to_ptr(mp_args[5]);
    g_node_traverse(root, order, flags, max_depth, func, data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_traverse_obj, 6, mp_g_node_traverse, g_node_traverse);

 

/*
 * dbus extension definition for:
 * extern guint g_node_max_height(GNode *root)
 */
 
STATIC mp_obj_t mp_g_node_max_height(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *root = mp_to_ptr(mp_args[0]);
    guint res = g_node_max_height(root);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_max_height_obj, 1, mp_g_node_max_height, g_node_max_height);

 

/*
 * Function NOT generated:
 * Callback function 'GNodeForeachFunc func' must receive a struct pointer with user_data member as its first argument!
 * GNodeForeachFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_node_children_foreach(GNode *node, GTraverseFlags flags, GNodeForeachFunc func, gpointer data)
 */
 
STATIC mp_obj_t mp_g_node_children_foreach(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    GTraverseFlags flags = (int)mp_obj_get_int(mp_args[1]);
    GNodeForeachFunc func = mp_to_ptr(mp_args[2]);
    gpointer data = mp_to_ptr(mp_args[3]);
    g_node_children_foreach(node, flags, func, data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_children_foreach_obj, 4, mp_g_node_children_foreach, g_node_children_foreach);

 

/*
 * dbus extension definition for:
 * extern void g_node_reverse_children(GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_reverse_children(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    g_node_reverse_children(node);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_reverse_children_obj, 1, mp_g_node_reverse_children, g_node_reverse_children);

 

/*
 * dbus extension definition for:
 * extern guint g_node_n_children(GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_n_children(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    guint res = g_node_n_children(node);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_n_children_obj, 1, mp_g_node_n_children, g_node_n_children);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_nth_child(GNode *node, guint n)
 */
 
STATIC mp_obj_t mp_g_node_nth_child(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    guint n = (unsigned int)mp_obj_get_int(mp_args[1]);
    GNode * res = g_node_nth_child(node, n);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_nth_child_obj, 2, mp_g_node_nth_child, g_node_nth_child);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_last_child(GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_last_child(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    GNode * res = g_node_last_child(node);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_last_child_obj, 1, mp_g_node_last_child, g_node_last_child);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_find_child(GNode *node, GTraverseFlags flags, gpointer data)
 */
 
STATIC mp_obj_t mp_g_node_find_child(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    GTraverseFlags flags = (int)mp_obj_get_int(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GNode * res = g_node_find_child(node, flags, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_find_child_obj, 3, mp_g_node_find_child, g_node_find_child);

 

/*
 * dbus extension definition for:
 * extern gint g_node_child_position(GNode *node, GNode *child)
 */
 
STATIC mp_obj_t mp_g_node_child_position(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    GNode *child = mp_to_ptr(mp_args[1]);
    gint res = g_node_child_position(node, child);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_child_position_obj, 2, mp_g_node_child_position, g_node_child_position);

 

/*
 * dbus extension definition for:
 * extern gint g_node_child_index(GNode *node, gpointer data)
 */
 
STATIC mp_obj_t mp_g_node_child_index(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    gint res = g_node_child_index(node, data);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_child_index_obj, 2, mp_g_node_child_index, g_node_child_index);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_first_sibling(GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_first_sibling(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    GNode * res = g_node_first_sibling(node);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_first_sibling_obj, 1, mp_g_node_first_sibling, g_node_first_sibling);

 

/*
 * dbus extension definition for:
 * extern GNode *g_node_last_sibling(GNode *node)
 */
 
STATIC mp_obj_t mp_g_node_last_sibling(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GNode *node = mp_to_ptr(mp_args[0]);
    GNode * res = g_node_last_sibling(node);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_node_last_sibling_obj, 1, mp_g_node_last_sibling, g_node_last_sibling);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_alloc(void)
 */
 
STATIC mp_obj_t mp_g_list_alloc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GList * res = g_list_alloc();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_alloc_obj, 0, mp_g_list_alloc, g_list_alloc);

 

/*
 * dbus extension definition for:
 * extern void g_list_free(GList *list)
 */
 
STATIC mp_obj_t mp_g_list_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    g_list_free(list);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_free_obj, 1, mp_g_list_free, g_list_free);

 

/*
 * dbus extension definition for:
 * extern void g_list_free_1(GList *list)
 */
 
STATIC mp_obj_t mp_g_list_free_1(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    g_list_free_1(list);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_free_1_obj, 1, mp_g_list_free_1, g_list_free_1);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify free_func' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify free_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_list_free_full(GList *list, GDestroyNotify free_func)
 */
 
STATIC mp_obj_t mp_g_list_free_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GDestroyNotify free_func = mp_to_ptr(mp_args[1]);
    g_list_free_full(list, free_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_free_full_obj, 2, mp_g_list_free_full, g_list_free_full);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_append(GList *list, gpointer data)
 */
 
STATIC mp_obj_t mp_g_list_append(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    GList * res = g_list_append(list, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_append_obj, 2, mp_g_list_append, g_list_append);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_prepend(GList *list, gpointer data)
 */
 
STATIC mp_obj_t mp_g_list_prepend(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    GList * res = g_list_prepend(list, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_prepend_obj, 2, mp_g_list_prepend, g_list_prepend);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_insert(GList *list, gpointer data, gint position)
 */
 
STATIC mp_obj_t mp_g_list_insert(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    gint position = (int)mp_obj_get_int(mp_args[2]);
    GList * res = g_list_insert(list, data, position);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_insert_obj, 3, mp_g_list_insert, g_list_insert);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCompareFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GList *g_list_insert_sorted(GList *list, gpointer data, GCompareFunc func)
 */
 
STATIC mp_obj_t mp_g_list_insert_sorted(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    GCompareFunc func = mp_to_ptr(mp_args[2]);
    GList * res = g_list_insert_sorted(list, data, func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_insert_sorted_obj, 3, mp_g_list_insert_sorted, g_list_insert_sorted);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GList *g_list_insert_sorted_with_data(GList *list, gpointer data, GCompareDataFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_list_insert_sorted_with_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    GCompareDataFunc func = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    GList * res = g_list_insert_sorted_with_data(list, data, func, user_data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_insert_sorted_with_data_obj, 4, mp_g_list_insert_sorted_with_data, g_list_insert_sorted_with_data);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_insert_before(GList *list, GList *sibling, gpointer data)
 */
 
STATIC mp_obj_t mp_g_list_insert_before(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GList *sibling = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GList * res = g_list_insert_before(list, sibling, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_insert_before_obj, 3, mp_g_list_insert_before, g_list_insert_before);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_concat(GList *list1, GList *list2)
 */
 
STATIC mp_obj_t mp_g_list_concat(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list1 = mp_to_ptr(mp_args[0]);
    GList *list2 = mp_to_ptr(mp_args[1]);
    GList * res = g_list_concat(list1, list2);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_concat_obj, 2, mp_g_list_concat, g_list_concat);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_remove(GList *list, gconstpointer data)
 */
 
STATIC mp_obj_t mp_g_list_remove(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    GList * res = g_list_remove(list, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_remove_obj, 2, mp_g_list_remove, g_list_remove);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_remove_all(GList *list, gconstpointer data)
 */
 
STATIC mp_obj_t mp_g_list_remove_all(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    GList * res = g_list_remove_all(list, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_remove_all_obj, 2, mp_g_list_remove_all, g_list_remove_all);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_remove_link(GList *list, GList *llink)
 */
 
STATIC mp_obj_t mp_g_list_remove_link(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GList *llink = mp_to_ptr(mp_args[1]);
    GList * res = g_list_remove_link(list, llink);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_remove_link_obj, 2, mp_g_list_remove_link, g_list_remove_link);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_delete_link(GList *list, GList *link_)
 */
 
STATIC mp_obj_t mp_g_list_delete_link(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GList *link_ = mp_to_ptr(mp_args[1]);
    GList * res = g_list_delete_link(list, link_);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_delete_link_obj, 2, mp_g_list_delete_link, g_list_delete_link);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_reverse(GList *list)
 */
 
STATIC mp_obj_t mp_g_list_reverse(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GList * res = g_list_reverse(list);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_reverse_obj, 1, mp_g_list_reverse, g_list_reverse);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_copy(GList *list)
 */
 
STATIC mp_obj_t mp_g_list_copy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GList * res = g_list_copy(list);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_copy_obj, 1, mp_g_list_copy, g_list_copy);

 

/*
 * Function NOT generated:
 * Callback function 'GCopyFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCopyFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GList *g_list_copy_deep(GList *list, GCopyFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_list_copy_deep(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GCopyFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    GList * res = g_list_copy_deep(list, func, user_data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_copy_deep_obj, 3, mp_g_list_copy_deep, g_list_copy_deep);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_nth(GList *list, guint n)
 */
 
STATIC mp_obj_t mp_g_list_nth(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    guint n = (unsigned int)mp_obj_get_int(mp_args[1]);
    GList * res = g_list_nth(list, n);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_nth_obj, 2, mp_g_list_nth, g_list_nth);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_nth_prev(GList *list, guint n)
 */
 
STATIC mp_obj_t mp_g_list_nth_prev(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    guint n = (unsigned int)mp_obj_get_int(mp_args[1]);
    GList * res = g_list_nth_prev(list, n);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_nth_prev_obj, 2, mp_g_list_nth_prev, g_list_nth_prev);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_find(GList *list, gconstpointer data)
 */
 
STATIC mp_obj_t mp_g_list_find(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    GList * res = g_list_find(list, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_find_obj, 2, mp_g_list_find, g_list_find);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCompareFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GList *g_list_find_custom(GList *list, gconstpointer data, GCompareFunc func)
 */
 
STATIC mp_obj_t mp_g_list_find_custom(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    GCompareFunc func = mp_to_ptr(mp_args[2]);
    GList * res = g_list_find_custom(list, data, func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_find_custom_obj, 3, mp_g_list_find_custom, g_list_find_custom);

 

/*
 * dbus extension definition for:
 * extern gint g_list_position(GList *list, GList *llink)
 */
 
STATIC mp_obj_t mp_g_list_position(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GList *llink = mp_to_ptr(mp_args[1]);
    gint res = g_list_position(list, llink);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_position_obj, 2, mp_g_list_position, g_list_position);

 

/*
 * dbus extension definition for:
 * extern gint g_list_index(GList *list, gconstpointer data)
 */
 
STATIC mp_obj_t mp_g_list_index(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    gint res = g_list_index(list, data);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_index_obj, 2, mp_g_list_index, g_list_index);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_last(GList *list)
 */
 
STATIC mp_obj_t mp_g_list_last(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GList * res = g_list_last(list);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_last_obj, 1, mp_g_list_last, g_list_last);

 

/*
 * dbus extension definition for:
 * extern GList *g_list_first(GList *list)
 */
 
STATIC mp_obj_t mp_g_list_first(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GList * res = g_list_first(list);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_first_obj, 1, mp_g_list_first, g_list_first);

 

/*
 * dbus extension definition for:
 * extern guint g_list_length(GList *list)
 */
 
STATIC mp_obj_t mp_g_list_length(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    guint res = g_list_length(list);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_length_obj, 1, mp_g_list_length, g_list_length);

 

/*
 * Function NOT generated:
 * Callback function 'GFunc func' must receive a struct pointer with user_data member as its first argument!
 * GFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_list_foreach(GList *list, GFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_list_foreach(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_list_foreach(list, func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_foreach_obj, 3, mp_g_list_foreach, g_list_foreach);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern GList *g_list_sort(GList *list, GCompareFunc compare_func)
 */
 
STATIC mp_obj_t mp_g_list_sort(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GCompareFunc compare_func = mp_to_ptr(mp_args[1]);
    GList * res = g_list_sort(list, compare_func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_sort_obj, 2, mp_g_list_sort, g_list_sort);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern GList *g_list_sort_with_data(GList *list, GCompareDataFunc compare_func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_list_sort_with_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    GCompareDataFunc compare_func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    GList * res = g_list_sort_with_data(list, compare_func, user_data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_sort_with_data_obj, 3, mp_g_list_sort_with_data, g_list_sort_with_data);

 

/*
 * dbus extension definition for:
 * extern gpointer g_list_nth_data(GList *list, guint n)
 */
 
STATIC mp_obj_t mp_g_list_nth_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GList *list = mp_to_ptr(mp_args[0]);
    guint n = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer res = g_list_nth_data(list, n);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_list_nth_data_obj, 2, mp_g_list_nth_data, g_list_nth_data);

 

/*
 * Function NOT generated:
 * Callback argument 'GHashFunc hash_func' cannot be the first argument! We assume the first argument contains the user_data
 * GHashFunc hash_func
 */
    

/*
 * Function NOT generated:
 * Callback function 'GEqualFunc key_equal_func' must receive a struct pointer with user_data member as its first argument!
 * GEqualFunc key_equal_func
 */
    

/*
 * dbus extension definition for:
 * extern GHashTable *g_hash_table_new(GHashFunc hash_func, GEqualFunc key_equal_func)
 */
 
STATIC mp_obj_t mp_g_hash_table_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashFunc hash_func = mp_to_ptr(mp_args[0]);
    GEqualFunc key_equal_func = mp_to_ptr(mp_args[1]);
    GHashTable * res = g_hash_table_new(hash_func, key_equal_func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_new_obj, 2, mp_g_hash_table_new, g_hash_table_new);

 

/*
 * Function NOT generated:
 * Callback argument 'GHashFunc hash_func' cannot be the first argument! We assume the first argument contains the user_data
 * GHashFunc hash_func
 */
    

/*
 * Function NOT generated:
 * Callback function 'GEqualFunc key_equal_func' must receive a struct pointer with user_data member as its first argument!
 * GEqualFunc key_equal_func
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify key_destroy_func' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify key_destroy_func
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify value_destroy_func' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify value_destroy_func
 */
    

/*
 * dbus extension definition for:
 * extern GHashTable *g_hash_table_new_full(GHashFunc hash_func, GEqualFunc key_equal_func, GDestroyNotify key_destroy_func, GDestroyNotify value_destroy_func)
 */
 
STATIC mp_obj_t mp_g_hash_table_new_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashFunc hash_func = mp_to_ptr(mp_args[0]);
    GEqualFunc key_equal_func = mp_to_ptr(mp_args[1]);
    GDestroyNotify key_destroy_func = mp_to_ptr(mp_args[2]);
    GDestroyNotify value_destroy_func = mp_to_ptr(mp_args[3]);
    GHashTable * res = g_hash_table_new_full(hash_func, key_equal_func, key_destroy_func, value_destroy_func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_new_full_obj, 4, mp_g_hash_table_new_full, g_hash_table_new_full);

 

/*
 * dbus extension definition for:
 * extern void g_hash_table_destroy(GHashTable *hash_table)
 */
 
STATIC mp_obj_t mp_g_hash_table_destroy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    g_hash_table_destroy(hash_table);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_destroy_obj, 1, mp_g_hash_table_destroy, g_hash_table_destroy);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hash_table_insert(GHashTable *hash_table, gpointer key, gpointer value)
 */
 
STATIC mp_obj_t mp_g_hash_table_insert(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    gpointer key = mp_to_ptr(mp_args[1]);
    gpointer value = mp_to_ptr(mp_args[2]);
    gboolean res = g_hash_table_insert(hash_table, key, value);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_insert_obj, 3, mp_g_hash_table_insert, g_hash_table_insert);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hash_table_replace(GHashTable *hash_table, gpointer key, gpointer value)
 */
 
STATIC mp_obj_t mp_g_hash_table_replace(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    gpointer key = mp_to_ptr(mp_args[1]);
    gpointer value = mp_to_ptr(mp_args[2]);
    gboolean res = g_hash_table_replace(hash_table, key, value);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_replace_obj, 3, mp_g_hash_table_replace, g_hash_table_replace);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hash_table_add(GHashTable *hash_table, gpointer key)
 */
 
STATIC mp_obj_t mp_g_hash_table_add(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    gpointer key = mp_to_ptr(mp_args[1]);
    gboolean res = g_hash_table_add(hash_table, key);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_add_obj, 2, mp_g_hash_table_add, g_hash_table_add);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hash_table_remove(GHashTable *hash_table, gconstpointer key)
 */
 
STATIC mp_obj_t mp_g_hash_table_remove(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    gconstpointer key = mp_to_ptr(mp_args[1]);
    gboolean res = g_hash_table_remove(hash_table, key);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_remove_obj, 2, mp_g_hash_table_remove, g_hash_table_remove);

 

/*
 * dbus extension definition for:
 * extern void g_hash_table_remove_all(GHashTable *hash_table)
 */
 
STATIC mp_obj_t mp_g_hash_table_remove_all(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    g_hash_table_remove_all(hash_table);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_remove_all_obj, 1, mp_g_hash_table_remove_all, g_hash_table_remove_all);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hash_table_steal(GHashTable *hash_table, gconstpointer key)
 */
 
STATIC mp_obj_t mp_g_hash_table_steal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    gconstpointer key = mp_to_ptr(mp_args[1]);
    gboolean res = g_hash_table_steal(hash_table, key);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_steal_obj, 2, mp_g_hash_table_steal, g_hash_table_steal);

 

/*
 * dbus extension definition for:
 * extern void g_hash_table_steal_all(GHashTable *hash_table)
 */
 
STATIC mp_obj_t mp_g_hash_table_steal_all(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    g_hash_table_steal_all(hash_table);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_steal_all_obj, 1, mp_g_hash_table_steal_all, g_hash_table_steal_all);

 

/*
 * dbus extension definition for:
 * extern gpointer g_hash_table_lookup(GHashTable *hash_table, gconstpointer key)
 */
 
STATIC mp_obj_t mp_g_hash_table_lookup(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    gconstpointer key = mp_to_ptr(mp_args[1]);
    gpointer res = g_hash_table_lookup(hash_table, key);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_lookup_obj, 2, mp_g_hash_table_lookup, g_hash_table_lookup);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hash_table_contains(GHashTable *hash_table, gconstpointer key)
 */
 
STATIC mp_obj_t mp_g_hash_table_contains(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    gconstpointer key = mp_to_ptr(mp_args[1]);
    gboolean res = g_hash_table_contains(hash_table, key);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_contains_obj, 2, mp_g_hash_table_contains, g_hash_table_contains);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hash_table_lookup_extended(GHashTable *hash_table, gconstpointer lookup_key, gpointer *orig_key, gpointer *value)
 */
 
STATIC mp_obj_t mp_g_hash_table_lookup_extended(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    gconstpointer lookup_key = mp_to_ptr(mp_args[1]);
    gpointer *orig_key = mp_to_ptr(mp_args[2]);
    gpointer *value = mp_to_ptr(mp_args[3]);
    gboolean res = g_hash_table_lookup_extended(hash_table, lookup_key, orig_key, value);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_lookup_extended_obj, 4, mp_g_hash_table_lookup_extended, g_hash_table_lookup_extended);

 

/*
 * Function NOT generated:
 * Callback function 'GHFunc func' must receive a struct pointer with user_data member as its first argument!
 * GHFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_hash_table_foreach(GHashTable *hash_table, GHFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_hash_table_foreach(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    GHFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_hash_table_foreach(hash_table, func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_foreach_obj, 3, mp_g_hash_table_foreach, g_hash_table_foreach);

 

/*
 * Function NOT generated:
 * Callback function 'GHRFunc predicate' must receive a struct pointer with user_data member as its first argument!
 * GHRFunc predicate
 */
    

/*
 * dbus extension definition for:
 * extern gpointer g_hash_table_find(GHashTable *hash_table, GHRFunc predicate, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_hash_table_find(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    GHRFunc predicate = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    gpointer res = g_hash_table_find(hash_table, predicate, user_data);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_find_obj, 3, mp_g_hash_table_find, g_hash_table_find);

 

/*
 * Function NOT generated:
 * Callback function 'GHRFunc func' must receive a struct pointer with user_data member as its first argument!
 * GHRFunc func
 */
    

/*
 * dbus extension definition for:
 * extern guint g_hash_table_foreach_remove(GHashTable *hash_table, GHRFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_hash_table_foreach_remove(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    GHRFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    guint res = g_hash_table_foreach_remove(hash_table, func, user_data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_foreach_remove_obj, 3, mp_g_hash_table_foreach_remove, g_hash_table_foreach_remove);

 

/*
 * Function NOT generated:
 * Callback function 'GHRFunc func' must receive a struct pointer with user_data member as its first argument!
 * GHRFunc func
 */
    

/*
 * dbus extension definition for:
 * extern guint g_hash_table_foreach_steal(GHashTable *hash_table, GHRFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_hash_table_foreach_steal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    GHRFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    guint res = g_hash_table_foreach_steal(hash_table, func, user_data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_foreach_steal_obj, 3, mp_g_hash_table_foreach_steal, g_hash_table_foreach_steal);

 

/*
 * dbus extension definition for:
 * extern guint g_hash_table_size(GHashTable *hash_table)
 */
 
STATIC mp_obj_t mp_g_hash_table_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    guint res = g_hash_table_size(hash_table);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_size_obj, 1, mp_g_hash_table_size, g_hash_table_size);

 

/*
 * dbus extension definition for:
 * extern GList *g_hash_table_get_keys(GHashTable *hash_table)
 */
 
STATIC mp_obj_t mp_g_hash_table_get_keys(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    GList * res = g_hash_table_get_keys(hash_table);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_get_keys_obj, 1, mp_g_hash_table_get_keys, g_hash_table_get_keys);

 

/*
 * dbus extension definition for:
 * extern GList *g_hash_table_get_values(GHashTable *hash_table)
 */
 
STATIC mp_obj_t mp_g_hash_table_get_values(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    GList * res = g_hash_table_get_values(hash_table);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_get_values_obj, 1, mp_g_hash_table_get_values, g_hash_table_get_values);

 

/*
 * dbus extension definition for:
 * extern gpointer *g_hash_table_get_keys_as_array(GHashTable *hash_table, guint *length)
 */
 
STATIC mp_obj_t mp_g_hash_table_get_keys_as_array(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    guint *length = mp_to_ptr(mp_args[1]);
    gpointer * res = g_hash_table_get_keys_as_array(hash_table, length);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_get_keys_as_array_obj, 2, mp_g_hash_table_get_keys_as_array, g_hash_table_get_keys_as_array);

 

/*
 * dbus extension definition for:
 * extern void g_hash_table_iter_init(GHashTableIter *iter, GHashTable *hash_table)
 */
 
STATIC mp_obj_t mp_g_hash_table_iter_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTableIter *iter = mp_to_ptr(mp_args[0]);
    GHashTable *hash_table = mp_to_ptr(mp_args[1]);
    g_hash_table_iter_init(iter, hash_table);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_iter_init_obj, 2, mp_g_hash_table_iter_init, g_hash_table_iter_init);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hash_table_iter_next(GHashTableIter *iter, gpointer *key, gpointer *value)
 */
 
STATIC mp_obj_t mp_g_hash_table_iter_next(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTableIter *iter = mp_to_ptr(mp_args[0]);
    gpointer *key = mp_to_ptr(mp_args[1]);
    gpointer *value = mp_to_ptr(mp_args[2]);
    gboolean res = g_hash_table_iter_next(iter, key, value);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_iter_next_obj, 3, mp_g_hash_table_iter_next, g_hash_table_iter_next);

 

/*
 * dbus extension definition for:
 * extern GHashTable *g_hash_table_iter_get_hash_table(GHashTableIter *iter)
 */
 
STATIC mp_obj_t mp_g_hash_table_iter_get_hash_table(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTableIter *iter = mp_to_ptr(mp_args[0]);
    GHashTable * res = g_hash_table_iter_get_hash_table(iter);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_iter_get_hash_table_obj, 1, mp_g_hash_table_iter_get_hash_table, g_hash_table_iter_get_hash_table);

 

/*
 * dbus extension definition for:
 * extern void g_hash_table_iter_remove(GHashTableIter *iter)
 */
 
STATIC mp_obj_t mp_g_hash_table_iter_remove(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTableIter *iter = mp_to_ptr(mp_args[0]);
    g_hash_table_iter_remove(iter);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_iter_remove_obj, 1, mp_g_hash_table_iter_remove, g_hash_table_iter_remove);

 

/*
 * dbus extension definition for:
 * extern void g_hash_table_iter_replace(GHashTableIter *iter, gpointer value)
 */
 
STATIC mp_obj_t mp_g_hash_table_iter_replace(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTableIter *iter = mp_to_ptr(mp_args[0]);
    gpointer value = mp_to_ptr(mp_args[1]);
    g_hash_table_iter_replace(iter, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_iter_replace_obj, 2, mp_g_hash_table_iter_replace, g_hash_table_iter_replace);

 

/*
 * dbus extension definition for:
 * extern void g_hash_table_iter_steal(GHashTableIter *iter)
 */
 
STATIC mp_obj_t mp_g_hash_table_iter_steal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTableIter *iter = mp_to_ptr(mp_args[0]);
    g_hash_table_iter_steal(iter);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_iter_steal_obj, 1, mp_g_hash_table_iter_steal, g_hash_table_iter_steal);

 

/*
 * dbus extension definition for:
 * extern GHashTable *g_hash_table_ref(GHashTable *hash_table)
 */
 
STATIC mp_obj_t mp_g_hash_table_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    GHashTable * res = g_hash_table_ref(hash_table);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_ref_obj, 1, mp_g_hash_table_ref, g_hash_table_ref);

 

/*
 * dbus extension definition for:
 * extern void g_hash_table_unref(GHashTable *hash_table)
 */
 
STATIC mp_obj_t mp_g_hash_table_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHashTable *hash_table = mp_to_ptr(mp_args[0]);
    g_hash_table_unref(hash_table);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hash_table_unref_obj, 1, mp_g_hash_table_unref, g_hash_table_unref);

 

/*
 * dbus extension definition for:
 * extern gboolean g_str_equal(gconstpointer v1, gconstpointer v2)
 */
 
STATIC mp_obj_t mp_g_str_equal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer v1 = mp_to_ptr(mp_args[0]);
    gconstpointer v2 = mp_to_ptr(mp_args[1]);
    gboolean res = g_str_equal(v1, v2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_str_equal_obj, 2, mp_g_str_equal, g_str_equal);

 

/*
 * dbus extension definition for:
 * extern guint g_str_hash(gconstpointer v)
 */
 
STATIC mp_obj_t mp_g_str_hash(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer v = mp_to_ptr(mp_args[0]);
    guint res = g_str_hash(v);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_str_hash_obj, 1, mp_g_str_hash, g_str_hash);

 

/*
 * dbus extension definition for:
 * extern gboolean g_int_equal(gconstpointer v1, gconstpointer v2)
 */
 
STATIC mp_obj_t mp_g_int_equal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer v1 = mp_to_ptr(mp_args[0]);
    gconstpointer v2 = mp_to_ptr(mp_args[1]);
    gboolean res = g_int_equal(v1, v2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_int_equal_obj, 2, mp_g_int_equal, g_int_equal);

 

/*
 * dbus extension definition for:
 * extern guint g_int_hash(gconstpointer v)
 */
 
STATIC mp_obj_t mp_g_int_hash(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer v = mp_to_ptr(mp_args[0]);
    guint res = g_int_hash(v);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_int_hash_obj, 1, mp_g_int_hash, g_int_hash);

 

/*
 * dbus extension definition for:
 * extern gboolean g_int64_equal(gconstpointer v1, gconstpointer v2)
 */
 
STATIC mp_obj_t mp_g_int64_equal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer v1 = mp_to_ptr(mp_args[0]);
    gconstpointer v2 = mp_to_ptr(mp_args[1]);
    gboolean res = g_int64_equal(v1, v2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_int64_equal_obj, 2, mp_g_int64_equal, g_int64_equal);

 

/*
 * dbus extension definition for:
 * extern guint g_int64_hash(gconstpointer v)
 */
 
STATIC mp_obj_t mp_g_int64_hash(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer v = mp_to_ptr(mp_args[0]);
    guint res = g_int64_hash(v);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_int64_hash_obj, 1, mp_g_int64_hash, g_int64_hash);

 

/*
 * dbus extension definition for:
 * extern gboolean g_double_equal(gconstpointer v1, gconstpointer v2)
 */
 
STATIC mp_obj_t mp_g_double_equal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer v1 = mp_to_ptr(mp_args[0]);
    gconstpointer v2 = mp_to_ptr(mp_args[1]);
    gboolean res = g_double_equal(v1, v2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_double_equal_obj, 2, mp_g_double_equal, g_double_equal);

 

/*
 * dbus extension definition for:
 * extern guint g_double_hash(gconstpointer v)
 */
 
STATIC mp_obj_t mp_g_double_hash(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer v = mp_to_ptr(mp_args[0]);
    guint res = g_double_hash(v);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_double_hash_obj, 1, mp_g_double_hash, g_double_hash);

 

/*
 * dbus extension definition for:
 * extern guint g_direct_hash(gconstpointer v)
 */
 
STATIC mp_obj_t mp_g_direct_hash(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer v = mp_to_ptr(mp_args[0]);
    guint res = g_direct_hash(v);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_direct_hash_obj, 1, mp_g_direct_hash, g_direct_hash);

 

/*
 * dbus extension definition for:
 * extern gboolean g_direct_equal(gconstpointer v1, gconstpointer v2)
 */
 
STATIC mp_obj_t mp_g_direct_equal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gconstpointer v1 = mp_to_ptr(mp_args[0]);
    gconstpointer v2 = mp_to_ptr(mp_args[1]);
    gboolean res = g_direct_equal(v1, v2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_direct_equal_obj, 2, mp_g_direct_equal, g_direct_equal);

 

/*
 * dbus extension definition for:
 * extern GHmac *g_hmac_new(GChecksumType digest_type, const guchar *key, gsize key_len)
 */
 
STATIC mp_obj_t mp_g_hmac_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GChecksumType digest_type = (int)mp_obj_get_int(mp_args[0]);
    const guchar *key = mp_to_ptr(mp_args[1]);
    gsize key_len = (unsigned long)mp_obj_get_int(mp_args[2]);
    GHmac * res = g_hmac_new(digest_type, key, key_len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hmac_new_obj, 3, mp_g_hmac_new, g_hmac_new);

 

/*
 * dbus extension definition for:
 * extern GHmac *g_hmac_copy(const GHmac *hmac)
 */
 
STATIC mp_obj_t mp_g_hmac_copy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GHmac *hmac = mp_to_ptr(mp_args[0]);
    GHmac * res = g_hmac_copy(hmac);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hmac_copy_obj, 1, mp_g_hmac_copy, g_hmac_copy);

 

/*
 * dbus extension definition for:
 * extern GHmac *g_hmac_ref(GHmac *hmac)
 */
 
STATIC mp_obj_t mp_g_hmac_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHmac *hmac = mp_to_ptr(mp_args[0]);
    GHmac * res = g_hmac_ref(hmac);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hmac_ref_obj, 1, mp_g_hmac_ref, g_hmac_ref);

 

/*
 * dbus extension definition for:
 * extern void g_hmac_unref(GHmac *hmac)
 */
 
STATIC mp_obj_t mp_g_hmac_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHmac *hmac = mp_to_ptr(mp_args[0]);
    g_hmac_unref(hmac);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hmac_unref_obj, 1, mp_g_hmac_unref, g_hmac_unref);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern void g_hmac_update(GHmac *hmac, const guchar *data, gssize length)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_hmac_get_string(GHmac *hmac)
 */
    

/*
 * dbus extension definition for:
 * extern void g_hmac_get_digest(GHmac *hmac, guint8 *buffer, gsize *digest_len)
 */
 
STATIC mp_obj_t mp_g_hmac_get_digest(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHmac *hmac = mp_to_ptr(mp_args[0]);
    guint8 *buffer = mp_to_ptr(mp_args[1]);
    gsize *digest_len = mp_to_ptr(mp_args[2]);
    g_hmac_get_digest(hmac, buffer, digest_len);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hmac_get_digest_obj, 3, mp_g_hmac_get_digest, g_hmac_get_digest);

 

/*
 * dbus extension definition for:
 * extern gchar *g_compute_hmac_for_data(GChecksumType digest_type, const guchar *key, gsize key_len, const guchar *data, gsize length)
 */
 
STATIC mp_obj_t mp_g_compute_hmac_for_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GChecksumType digest_type = (int)mp_obj_get_int(mp_args[0]);
    const guchar *key = mp_to_ptr(mp_args[1]);
    gsize key_len = (unsigned long)mp_obj_get_int(mp_args[2]);
    const guchar *data = mp_to_ptr(mp_args[3]);
    gsize length = (unsigned long)mp_obj_get_int(mp_args[4]);
    gchar * res = g_compute_hmac_for_data(digest_type, key, key_len, data, length);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_compute_hmac_for_data_obj, 5, mp_g_compute_hmac_for_data, g_compute_hmac_for_data);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_compute_hmac_for_string(GChecksumType digest_type, const guchar *key, gsize key_len, const gchar *str, gssize length)
 */
    

/*
 * dbus extension definition for:
 * extern void g_hook_list_init(GHookList *hook_list, guint hook_size)
 */
 
STATIC mp_obj_t mp_g_hook_list_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    guint hook_size = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_hook_list_init(hook_list, hook_size);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_list_init_obj, 2, mp_g_hook_list_init, g_hook_list_init);

 

/*
 * dbus extension definition for:
 * extern void g_hook_list_clear(GHookList *hook_list)
 */
 
STATIC mp_obj_t mp_g_hook_list_clear(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    g_hook_list_clear(hook_list);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_list_clear_obj, 1, mp_g_hook_list_clear, g_hook_list_clear);

 

/*
 * dbus extension definition for:
 * extern GHook *g_hook_alloc(GHookList *hook_list)
 */
 
STATIC mp_obj_t mp_g_hook_alloc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    GHook * res = g_hook_alloc(hook_list);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_alloc_obj, 1, mp_g_hook_alloc, g_hook_alloc);

 

/*
 * dbus extension definition for:
 * extern void g_hook_free(GHookList *hook_list, GHook *hook)
 */
 
STATIC mp_obj_t mp_g_hook_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    GHook *hook = mp_to_ptr(mp_args[1]);
    g_hook_free(hook_list, hook);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_free_obj, 2, mp_g_hook_free, g_hook_free);

 

/*
 * dbus extension definition for:
 * extern GHook *g_hook_ref(GHookList *hook_list, GHook *hook)
 */
 
STATIC mp_obj_t mp_g_hook_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    GHook *hook = mp_to_ptr(mp_args[1]);
    GHook * res = g_hook_ref(hook_list, hook);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_ref_obj, 2, mp_g_hook_ref, g_hook_ref);

 

/*
 * dbus extension definition for:
 * extern void g_hook_unref(GHookList *hook_list, GHook *hook)
 */
 
STATIC mp_obj_t mp_g_hook_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    GHook *hook = mp_to_ptr(mp_args[1]);
    g_hook_unref(hook_list, hook);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_unref_obj, 2, mp_g_hook_unref, g_hook_unref);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hook_destroy(GHookList *hook_list, gulong hook_id)
 */
 
STATIC mp_obj_t mp_g_hook_destroy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gulong hook_id = (unsigned long)mp_obj_get_int(mp_args[1]);
    gboolean res = g_hook_destroy(hook_list, hook_id);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_destroy_obj, 2, mp_g_hook_destroy, g_hook_destroy);

 

/*
 * dbus extension definition for:
 * extern void g_hook_destroy_link(GHookList *hook_list, GHook *hook)
 */
 
STATIC mp_obj_t mp_g_hook_destroy_link(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    GHook *hook = mp_to_ptr(mp_args[1]);
    g_hook_destroy_link(hook_list, hook);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_destroy_link_obj, 2, mp_g_hook_destroy_link, g_hook_destroy_link);

 

/*
 * dbus extension definition for:
 * extern void g_hook_prepend(GHookList *hook_list, GHook *hook)
 */
 
STATIC mp_obj_t mp_g_hook_prepend(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    GHook *hook = mp_to_ptr(mp_args[1]);
    g_hook_prepend(hook_list, hook);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_prepend_obj, 2, mp_g_hook_prepend, g_hook_prepend);

 

/*
 * dbus extension definition for:
 * extern void g_hook_insert_before(GHookList *hook_list, GHook *sibling, GHook *hook)
 */
 
STATIC mp_obj_t mp_g_hook_insert_before(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    GHook *sibling = mp_to_ptr(mp_args[1]);
    GHook *hook = mp_to_ptr(mp_args[2]);
    g_hook_insert_before(hook_list, sibling, hook);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_insert_before_obj, 3, mp_g_hook_insert_before, g_hook_insert_before);

 

/*
 * Function NOT generated:
 * Callback function 'GHookCompareFunc func' must receive a struct pointer with user_data member as its first argument!
 * GHookCompareFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_hook_insert_sorted(GHookList *hook_list, GHook *hook, GHookCompareFunc func)
 */
 
STATIC mp_obj_t mp_g_hook_insert_sorted(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    GHook *hook = mp_to_ptr(mp_args[1]);
    GHookCompareFunc func = mp_to_ptr(mp_args[2]);
    g_hook_insert_sorted(hook_list, hook, func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_insert_sorted_obj, 3, mp_g_hook_insert_sorted, g_hook_insert_sorted);

 

/*
 * dbus extension definition for:
 * extern GHook *g_hook_get(GHookList *hook_list, gulong hook_id)
 */
 
STATIC mp_obj_t mp_g_hook_get(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gulong hook_id = (unsigned long)mp_obj_get_int(mp_args[1]);
    GHook * res = g_hook_get(hook_list, hook_id);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_get_obj, 2, mp_g_hook_get, g_hook_get);

 

/*
 * Function NOT generated:
 * Callback function 'GHookFindFunc func' must receive a struct pointer with user_data member as its first argument!
 * GHookFindFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GHook *g_hook_find(GHookList *hook_list, gboolean need_valids, GHookFindFunc func, gpointer data)
 */
 
STATIC mp_obj_t mp_g_hook_find(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gboolean need_valids = (int)mp_obj_get_int(mp_args[1]);
    GHookFindFunc func = mp_to_ptr(mp_args[2]);
    gpointer data = mp_to_ptr(mp_args[3]);
    GHook * res = g_hook_find(hook_list, need_valids, func, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_find_obj, 4, mp_g_hook_find, g_hook_find);

 

/*
 * dbus extension definition for:
 * extern GHook *g_hook_find_data(GHookList *hook_list, gboolean need_valids, gpointer data)
 */
 
STATIC mp_obj_t mp_g_hook_find_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gboolean need_valids = (int)mp_obj_get_int(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GHook * res = g_hook_find_data(hook_list, need_valids, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_find_data_obj, 3, mp_g_hook_find_data, g_hook_find_data);

 

/*
 * dbus extension definition for:
 * extern GHook *g_hook_find_func(GHookList *hook_list, gboolean need_valids, gpointer func)
 */
 
STATIC mp_obj_t mp_g_hook_find_func(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gboolean need_valids = (int)mp_obj_get_int(mp_args[1]);
    gpointer func = mp_to_ptr(mp_args[2]);
    GHook * res = g_hook_find_func(hook_list, need_valids, func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_find_func_obj, 3, mp_g_hook_find_func, g_hook_find_func);

 

/*
 * dbus extension definition for:
 * extern GHook *g_hook_find_func_data(GHookList *hook_list, gboolean need_valids, gpointer func, gpointer data)
 */
 
STATIC mp_obj_t mp_g_hook_find_func_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gboolean need_valids = (int)mp_obj_get_int(mp_args[1]);
    gpointer func = mp_to_ptr(mp_args[2]);
    gpointer data = mp_to_ptr(mp_args[3]);
    GHook * res = g_hook_find_func_data(hook_list, need_valids, func, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_find_func_data_obj, 4, mp_g_hook_find_func_data, g_hook_find_func_data);

 

/*
 * dbus extension definition for:
 * extern GHook *g_hook_first_valid(GHookList *hook_list, gboolean may_be_in_call)
 */
 
STATIC mp_obj_t mp_g_hook_first_valid(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gboolean may_be_in_call = (int)mp_obj_get_int(mp_args[1]);
    GHook * res = g_hook_first_valid(hook_list, may_be_in_call);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_first_valid_obj, 2, mp_g_hook_first_valid, g_hook_first_valid);

 

/*
 * dbus extension definition for:
 * extern GHook *g_hook_next_valid(GHookList *hook_list, GHook *hook, gboolean may_be_in_call)
 */
 
STATIC mp_obj_t mp_g_hook_next_valid(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    GHook *hook = mp_to_ptr(mp_args[1]);
    gboolean may_be_in_call = (int)mp_obj_get_int(mp_args[2]);
    GHook * res = g_hook_next_valid(hook_list, hook, may_be_in_call);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_next_valid_obj, 3, mp_g_hook_next_valid, g_hook_next_valid);

 

/*
 * dbus extension definition for:
 * extern gint g_hook_compare_ids(GHook *new_hook, GHook *sibling)
 */
 
STATIC mp_obj_t mp_g_hook_compare_ids(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHook *new_hook = mp_to_ptr(mp_args[0]);
    GHook *sibling = mp_to_ptr(mp_args[1]);
    gint res = g_hook_compare_ids(new_hook, sibling);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_compare_ids_obj, 2, mp_g_hook_compare_ids, g_hook_compare_ids);

 

/*
 * dbus extension definition for:
 * extern void g_hook_list_invoke(GHookList *hook_list, gboolean may_recurse)
 */
 
STATIC mp_obj_t mp_g_hook_list_invoke(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gboolean may_recurse = (int)mp_obj_get_int(mp_args[1]);
    g_hook_list_invoke(hook_list, may_recurse);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_list_invoke_obj, 2, mp_g_hook_list_invoke, g_hook_list_invoke);

 

/*
 * dbus extension definition for:
 * extern void g_hook_list_invoke_check(GHookList *hook_list, gboolean may_recurse)
 */
 
STATIC mp_obj_t mp_g_hook_list_invoke_check(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gboolean may_recurse = (int)mp_obj_get_int(mp_args[1]);
    g_hook_list_invoke_check(hook_list, may_recurse);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_list_invoke_check_obj, 2, mp_g_hook_list_invoke_check, g_hook_list_invoke_check);

 

/*
 * Function NOT generated:
 * Callback function 'GHookMarshaller marshaller' must receive a struct pointer with user_data member as its first argument!
 * GHookMarshaller marshaller
 */
    

/*
 * dbus extension definition for:
 * extern void g_hook_list_marshal(GHookList *hook_list, gboolean may_recurse, GHookMarshaller marshaller, gpointer marshal_data)
 */
 
STATIC mp_obj_t mp_g_hook_list_marshal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gboolean may_recurse = (int)mp_obj_get_int(mp_args[1]);
    GHookMarshaller marshaller = mp_to_ptr(mp_args[2]);
    gpointer marshal_data = mp_to_ptr(mp_args[3]);
    g_hook_list_marshal(hook_list, may_recurse, marshaller, marshal_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_list_marshal_obj, 4, mp_g_hook_list_marshal, g_hook_list_marshal);

 

/*
 * Function NOT generated:
 * Callback function 'GHookCheckMarshaller marshaller' must receive a struct pointer with user_data member as its first argument!
 * GHookCheckMarshaller marshaller
 */
    

/*
 * dbus extension definition for:
 * extern void g_hook_list_marshal_check(GHookList *hook_list, gboolean may_recurse, GHookCheckMarshaller marshaller, gpointer marshal_data)
 */
 
STATIC mp_obj_t mp_g_hook_list_marshal_check(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GHookList *hook_list = mp_to_ptr(mp_args[0]);
    gboolean may_recurse = (int)mp_obj_get_int(mp_args[1]);
    GHookCheckMarshaller marshaller = mp_to_ptr(mp_args[2]);
    gpointer marshal_data = mp_to_ptr(mp_args[3]);
    g_hook_list_marshal_check(hook_list, may_recurse, marshaller, marshal_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hook_list_marshal_check_obj, 4, mp_g_hook_list_marshal_check, g_hook_list_marshal_check);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hostname_is_non_ascii(const gchar *hostname)
 */
 
STATIC mp_obj_t mp_g_hostname_is_non_ascii(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *hostname = (char*)mp_obj_str_get_str(mp_args[0]);
    gboolean res = g_hostname_is_non_ascii(hostname);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hostname_is_non_ascii_obj, 1, mp_g_hostname_is_non_ascii, g_hostname_is_non_ascii);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hostname_is_ascii_encoded(const gchar *hostname)
 */
 
STATIC mp_obj_t mp_g_hostname_is_ascii_encoded(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *hostname = (char*)mp_obj_str_get_str(mp_args[0]);
    gboolean res = g_hostname_is_ascii_encoded(hostname);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hostname_is_ascii_encoded_obj, 1, mp_g_hostname_is_ascii_encoded, g_hostname_is_ascii_encoded);

 

/*
 * dbus extension definition for:
 * extern gboolean g_hostname_is_ip_address(const gchar *hostname)
 */
 
STATIC mp_obj_t mp_g_hostname_is_ip_address(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *hostname = (char*)mp_obj_str_get_str(mp_args[0]);
    gboolean res = g_hostname_is_ip_address(hostname);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hostname_is_ip_address_obj, 1, mp_g_hostname_is_ip_address, g_hostname_is_ip_address);

 

/*
 * dbus extension definition for:
 * extern gchar *g_hostname_to_ascii(const gchar *hostname)
 */
 
STATIC mp_obj_t mp_g_hostname_to_ascii(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *hostname = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_hostname_to_ascii(hostname);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hostname_to_ascii_obj, 1, mp_g_hostname_to_ascii, g_hostname_to_ascii);

 

/*
 * dbus extension definition for:
 * extern gchar *g_hostname_to_unicode(const gchar *hostname)
 */
 
STATIC mp_obj_t mp_g_hostname_to_unicode(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *hostname = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_hostname_to_unicode(hostname);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_hostname_to_unicode_obj, 1, mp_g_hostname_to_unicode, g_hostname_to_unicode);

 

/*
 * dbus extension definition for:
 * extern gint g_poll(GPollFD *fds, guint nfds, gint timeout)
 */
 
STATIC mp_obj_t mp_g_poll(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPollFD *fds = mp_to_ptr(mp_args[0]);
    guint nfds = (unsigned int)mp_obj_get_int(mp_args[1]);
    gint timeout = (int)mp_obj_get_int(mp_args[2]);
    gint res = g_poll(fds, nfds, timeout);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_poll_obj, 3, mp_g_poll, g_poll);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_alloc(void)
 */
 
STATIC mp_obj_t mp_g_slist_alloc(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GSList * res = g_slist_alloc();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_alloc_obj, 0, mp_g_slist_alloc, g_slist_alloc);

 

/*
 * dbus extension definition for:
 * extern void g_slist_free(GSList *list)
 */
 
STATIC mp_obj_t mp_g_slist_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    g_slist_free(list);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_free_obj, 1, mp_g_slist_free, g_slist_free);

 

/*
 * dbus extension definition for:
 * extern void g_slist_free_1(GSList *list)
 */
 
STATIC mp_obj_t mp_g_slist_free_1(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    g_slist_free_1(list);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_free_1_obj, 1, mp_g_slist_free_1, g_slist_free_1);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify free_func' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify free_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_slist_free_full(GSList *list, GDestroyNotify free_func)
 */
 
STATIC mp_obj_t mp_g_slist_free_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GDestroyNotify free_func = mp_to_ptr(mp_args[1]);
    g_slist_free_full(list, free_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_free_full_obj, 2, mp_g_slist_free_full, g_slist_free_full);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_append(GSList *list, gpointer data)
 */
 
STATIC mp_obj_t mp_g_slist_append(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    GSList * res = g_slist_append(list, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_append_obj, 2, mp_g_slist_append, g_slist_append);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_prepend(GSList *list, gpointer data)
 */
 
STATIC mp_obj_t mp_g_slist_prepend(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    GSList * res = g_slist_prepend(list, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_prepend_obj, 2, mp_g_slist_prepend, g_slist_prepend);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_insert(GSList *list, gpointer data, gint position)
 */
 
STATIC mp_obj_t mp_g_slist_insert(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    gint position = (int)mp_obj_get_int(mp_args[2]);
    GSList * res = g_slist_insert(list, data, position);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_insert_obj, 3, mp_g_slist_insert, g_slist_insert);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCompareFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GSList *g_slist_insert_sorted(GSList *list, gpointer data, GCompareFunc func)
 */
 
STATIC mp_obj_t mp_g_slist_insert_sorted(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    GCompareFunc func = mp_to_ptr(mp_args[2]);
    GSList * res = g_slist_insert_sorted(list, data, func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_insert_sorted_obj, 3, mp_g_slist_insert_sorted, g_slist_insert_sorted);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GSList *g_slist_insert_sorted_with_data(GSList *list, gpointer data, GCompareDataFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_slist_insert_sorted_with_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    GCompareDataFunc func = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    GSList * res = g_slist_insert_sorted_with_data(list, data, func, user_data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_insert_sorted_with_data_obj, 4, mp_g_slist_insert_sorted_with_data, g_slist_insert_sorted_with_data);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_insert_before(GSList *slist, GSList *sibling, gpointer data)
 */
 
STATIC mp_obj_t mp_g_slist_insert_before(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *slist = mp_to_ptr(mp_args[0]);
    GSList *sibling = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GSList * res = g_slist_insert_before(slist, sibling, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_insert_before_obj, 3, mp_g_slist_insert_before, g_slist_insert_before);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_concat(GSList *list1, GSList *list2)
 */
 
STATIC mp_obj_t mp_g_slist_concat(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list1 = mp_to_ptr(mp_args[0]);
    GSList *list2 = mp_to_ptr(mp_args[1]);
    GSList * res = g_slist_concat(list1, list2);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_concat_obj, 2, mp_g_slist_concat, g_slist_concat);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_remove(GSList *list, gconstpointer data)
 */
 
STATIC mp_obj_t mp_g_slist_remove(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    GSList * res = g_slist_remove(list, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_remove_obj, 2, mp_g_slist_remove, g_slist_remove);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_remove_all(GSList *list, gconstpointer data)
 */
 
STATIC mp_obj_t mp_g_slist_remove_all(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    GSList * res = g_slist_remove_all(list, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_remove_all_obj, 2, mp_g_slist_remove_all, g_slist_remove_all);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_remove_link(GSList *list, GSList *link_)
 */
 
STATIC mp_obj_t mp_g_slist_remove_link(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GSList *link_ = mp_to_ptr(mp_args[1]);
    GSList * res = g_slist_remove_link(list, link_);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_remove_link_obj, 2, mp_g_slist_remove_link, g_slist_remove_link);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_delete_link(GSList *list, GSList *link_)
 */
 
STATIC mp_obj_t mp_g_slist_delete_link(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GSList *link_ = mp_to_ptr(mp_args[1]);
    GSList * res = g_slist_delete_link(list, link_);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_delete_link_obj, 2, mp_g_slist_delete_link, g_slist_delete_link);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_reverse(GSList *list)
 */
 
STATIC mp_obj_t mp_g_slist_reverse(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GSList * res = g_slist_reverse(list);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_reverse_obj, 1, mp_g_slist_reverse, g_slist_reverse);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_copy(GSList *list)
 */
 
STATIC mp_obj_t mp_g_slist_copy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GSList * res = g_slist_copy(list);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_copy_obj, 1, mp_g_slist_copy, g_slist_copy);

 

/*
 * Function NOT generated:
 * Callback function 'GCopyFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCopyFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GSList *g_slist_copy_deep(GSList *list, GCopyFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_slist_copy_deep(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GCopyFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    GSList * res = g_slist_copy_deep(list, func, user_data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_copy_deep_obj, 3, mp_g_slist_copy_deep, g_slist_copy_deep);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_nth(GSList *list, guint n)
 */
 
STATIC mp_obj_t mp_g_slist_nth(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    guint n = (unsigned int)mp_obj_get_int(mp_args[1]);
    GSList * res = g_slist_nth(list, n);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_nth_obj, 2, mp_g_slist_nth, g_slist_nth);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_find(GSList *list, gconstpointer data)
 */
 
STATIC mp_obj_t mp_g_slist_find(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    GSList * res = g_slist_find(list, data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_find_obj, 2, mp_g_slist_find, g_slist_find);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareFunc func' must receive a struct pointer with user_data member as its first argument!
 * GCompareFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GSList *g_slist_find_custom(GSList *list, gconstpointer data, GCompareFunc func)
 */
 
STATIC mp_obj_t mp_g_slist_find_custom(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    GCompareFunc func = mp_to_ptr(mp_args[2]);
    GSList * res = g_slist_find_custom(list, data, func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_find_custom_obj, 3, mp_g_slist_find_custom, g_slist_find_custom);

 

/*
 * dbus extension definition for:
 * extern gint g_slist_position(GSList *list, GSList *llink)
 */
 
STATIC mp_obj_t mp_g_slist_position(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GSList *llink = mp_to_ptr(mp_args[1]);
    gint res = g_slist_position(list, llink);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_position_obj, 2, mp_g_slist_position, g_slist_position);

 

/*
 * dbus extension definition for:
 * extern gint g_slist_index(GSList *list, gconstpointer data)
 */
 
STATIC mp_obj_t mp_g_slist_index(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    gconstpointer data = mp_to_ptr(mp_args[1]);
    gint res = g_slist_index(list, data);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_index_obj, 2, mp_g_slist_index, g_slist_index);

 

/*
 * dbus extension definition for:
 * extern GSList *g_slist_last(GSList *list)
 */
 
STATIC mp_obj_t mp_g_slist_last(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GSList * res = g_slist_last(list);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_last_obj, 1, mp_g_slist_last, g_slist_last);

 

/*
 * dbus extension definition for:
 * extern guint g_slist_length(GSList *list)
 */
 
STATIC mp_obj_t mp_g_slist_length(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    guint res = g_slist_length(list);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_length_obj, 1, mp_g_slist_length, g_slist_length);

 

/*
 * Function NOT generated:
 * Callback function 'GFunc func' must receive a struct pointer with user_data member as its first argument!
 * GFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_slist_foreach(GSList *list, GFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_slist_foreach(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GFunc func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_slist_foreach(list, func, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_foreach_obj, 3, mp_g_slist_foreach, g_slist_foreach);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern GSList *g_slist_sort(GSList *list, GCompareFunc compare_func)
 */
 
STATIC mp_obj_t mp_g_slist_sort(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GCompareFunc compare_func = mp_to_ptr(mp_args[1]);
    GSList * res = g_slist_sort(list, compare_func);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_sort_obj, 2, mp_g_slist_sort, g_slist_sort);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern GSList *g_slist_sort_with_data(GSList *list, GCompareDataFunc compare_func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_slist_sort_with_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    GCompareDataFunc compare_func = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    GSList * res = g_slist_sort_with_data(list, compare_func, user_data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_sort_with_data_obj, 3, mp_g_slist_sort_with_data, g_slist_sort_with_data);

 

/*
 * dbus extension definition for:
 * extern gpointer g_slist_nth_data(GSList *list, guint n)
 */
 
STATIC mp_obj_t mp_g_slist_nth_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSList *list = mp_to_ptr(mp_args[0]);
    guint n = (unsigned int)mp_obj_get_int(mp_args[1]);
    gpointer res = g_slist_nth_data(list, n);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_slist_nth_data_obj, 2, mp_g_slist_nth_data, g_slist_nth_data);

 

/*
 * dbus extension definition for:
 * extern GMainContext *g_main_context_new(void)
 */
 
STATIC mp_obj_t mp_g_main_context_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GMainContext * res = g_main_context_new();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_new_obj, 0, mp_g_main_context_new, g_main_context_new);

 

/*
 * dbus extension definition for:
 * extern GMainContext *g_main_context_ref(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    GMainContext * res = g_main_context_ref(context);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_ref_obj, 1, mp_g_main_context_ref, g_main_context_ref);

 

/*
 * dbus extension definition for:
 * extern void g_main_context_unref(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    g_main_context_unref(context);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_unref_obj, 1, mp_g_main_context_unref, g_main_context_unref);

 

/*
 * dbus extension definition for:
 * extern GMainContext *g_main_context_default(void)
 */
 
STATIC mp_obj_t mp_g_main_context_default(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GMainContext * res = g_main_context_default();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_default_obj, 0, mp_g_main_context_default, g_main_context_default);

 

/*
 * dbus extension definition for:
 * extern gboolean g_main_context_iteration(GMainContext *context, gboolean may_block)
 */
 
STATIC mp_obj_t mp_g_main_context_iteration(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    gboolean may_block = (int)mp_obj_get_int(mp_args[1]);
    gboolean res = g_main_context_iteration(context, may_block);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_iteration_obj, 2, mp_g_main_context_iteration, g_main_context_iteration);

 

/*
 * dbus extension definition for:
 * extern gboolean g_main_context_pending(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_pending(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    gboolean res = g_main_context_pending(context);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_pending_obj, 1, mp_g_main_context_pending, g_main_context_pending);

 

/*
 * dbus extension definition for:
 * extern GSource *g_main_context_find_source_by_id(GMainContext *context, guint source_id)
 */
 
STATIC mp_obj_t mp_g_main_context_find_source_by_id(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    guint source_id = (unsigned int)mp_obj_get_int(mp_args[1]);
    GSource * res = g_main_context_find_source_by_id(context, source_id);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_find_source_by_id_obj, 2, mp_g_main_context_find_source_by_id, g_main_context_find_source_by_id);

 

/*
 * dbus extension definition for:
 * extern GSource *g_main_context_find_source_by_user_data(GMainContext *context, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_main_context_find_source_by_user_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    gpointer user_data = mp_to_ptr(mp_args[1]);
    GSource * res = g_main_context_find_source_by_user_data(context, user_data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_find_source_by_user_data_obj, 2, mp_g_main_context_find_source_by_user_data, g_main_context_find_source_by_user_data);

 

/*
 * dbus extension definition for:
 * extern GSource *g_main_context_find_source_by_funcs_user_data(GMainContext *context, GSourceFuncs *funcs, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_main_context_find_source_by_funcs_user_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    GSourceFuncs *funcs = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    GSource * res = g_main_context_find_source_by_funcs_user_data(context, funcs, user_data);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_find_source_by_funcs_user_data_obj, 3, mp_g_main_context_find_source_by_funcs_user_data, g_main_context_find_source_by_funcs_user_data);

 

/*
 * dbus extension definition for:
 * extern void g_main_context_wakeup(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_wakeup(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    g_main_context_wakeup(context);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_wakeup_obj, 1, mp_g_main_context_wakeup, g_main_context_wakeup);

 

/*
 * dbus extension definition for:
 * extern gboolean g_main_context_acquire(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_acquire(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    gboolean res = g_main_context_acquire(context);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_acquire_obj, 1, mp_g_main_context_acquire, g_main_context_acquire);

 

/*
 * dbus extension definition for:
 * extern void g_main_context_release(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_release(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    g_main_context_release(context);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_release_obj, 1, mp_g_main_context_release, g_main_context_release);

 

/*
 * dbus extension definition for:
 * extern gboolean g_main_context_is_owner(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_is_owner(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    gboolean res = g_main_context_is_owner(context);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_is_owner_obj, 1, mp_g_main_context_is_owner, g_main_context_is_owner);

 

/*
 * dbus extension definition for:
 * extern gboolean g_main_context_wait(GMainContext *context, GCond *cond, GMutex *mutex)
 */
 
STATIC mp_obj_t mp_g_main_context_wait(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    GCond *cond = mp_to_ptr(mp_args[1]);
    GMutex *mutex = mp_to_ptr(mp_args[2]);
    gboolean res = g_main_context_wait(context, cond, mutex);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_wait_obj, 3, mp_g_main_context_wait, g_main_context_wait);

 

/*
 * dbus extension definition for:
 * extern gboolean g_main_context_prepare(GMainContext *context, gint *priority)
 */
 
STATIC mp_obj_t mp_g_main_context_prepare(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    gint *priority = mp_to_ptr(mp_args[1]);
    gboolean res = g_main_context_prepare(context, priority);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_prepare_obj, 2, mp_g_main_context_prepare, g_main_context_prepare);

 

/*
 * dbus extension definition for:
 * extern gint g_main_context_query(GMainContext *context, gint max_priority, gint *timeout_, GPollFD *fds, gint n_fds)
 */
 
STATIC mp_obj_t mp_g_main_context_query(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    gint max_priority = (int)mp_obj_get_int(mp_args[1]);
    gint *timeout_ = mp_to_ptr(mp_args[2]);
    GPollFD *fds = mp_to_ptr(mp_args[3]);
    gint n_fds = (int)mp_obj_get_int(mp_args[4]);
    gint res = g_main_context_query(context, max_priority, timeout_, fds, n_fds);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_query_obj, 5, mp_g_main_context_query, g_main_context_query);

 

/*
 * dbus extension definition for:
 * extern gint g_main_context_check(GMainContext *context, gint max_priority, GPollFD *fds, gint n_fds)
 */
 
STATIC mp_obj_t mp_g_main_context_check(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    gint max_priority = (int)mp_obj_get_int(mp_args[1]);
    GPollFD *fds = mp_to_ptr(mp_args[2]);
    gint n_fds = (int)mp_obj_get_int(mp_args[3]);
    gint res = g_main_context_check(context, max_priority, fds, n_fds);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_check_obj, 4, mp_g_main_context_check, g_main_context_check);

 

/*
 * dbus extension definition for:
 * extern void g_main_context_dispatch(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_dispatch(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    g_main_context_dispatch(context);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_dispatch_obj, 1, mp_g_main_context_dispatch, g_main_context_dispatch);

 

/*
 * Function NOT generated:
 * Callback function 'GPollFunc func' must receive a struct pointer with user_data member as its first argument!
 * GPollFunc func
 */
    

/*
 * dbus extension definition for:
 * extern void g_main_context_set_poll_func(GMainContext *context, GPollFunc func)
 */
 
STATIC mp_obj_t mp_g_main_context_set_poll_func(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    GPollFunc func = mp_to_ptr(mp_args[1]);
    g_main_context_set_poll_func(context, func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_set_poll_func_obj, 2, mp_g_main_context_set_poll_func, g_main_context_set_poll_func);

 

/*
 * dbus extension definition for:
 * extern GPollFunc g_main_context_get_poll_func(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_get_poll_func(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    GPollFunc res = g_main_context_get_poll_func(context);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_get_poll_func_obj, 1, mp_g_main_context_get_poll_func, g_main_context_get_poll_func);

 

/*
 * dbus extension definition for:
 * extern void g_main_context_add_poll(GMainContext *context, GPollFD *fd, gint priority)
 */
 
STATIC mp_obj_t mp_g_main_context_add_poll(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    GPollFD *fd = mp_to_ptr(mp_args[1]);
    gint priority = (int)mp_obj_get_int(mp_args[2]);
    g_main_context_add_poll(context, fd, priority);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_add_poll_obj, 3, mp_g_main_context_add_poll, g_main_context_add_poll);

 

/*
 * dbus extension definition for:
 * extern void g_main_context_remove_poll(GMainContext *context, GPollFD *fd)
 */
 
STATIC mp_obj_t mp_g_main_context_remove_poll(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    GPollFD *fd = mp_to_ptr(mp_args[1]);
    g_main_context_remove_poll(context, fd);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_remove_poll_obj, 2, mp_g_main_context_remove_poll, g_main_context_remove_poll);

 

/*
 * dbus extension definition for:
 * extern gint g_main_depth(void)
 */
 
STATIC mp_obj_t mp_g_main_depth(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    gint res = g_main_depth();
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_depth_obj, 0, mp_g_main_depth, g_main_depth);

 

/*
 * dbus extension definition for:
 * extern GSource *g_main_current_source(void)
 */
 
STATIC mp_obj_t mp_g_main_current_source(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GSource * res = g_main_current_source();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_current_source_obj, 0, mp_g_main_current_source, g_main_current_source);

 

/*
 * dbus extension definition for:
 * extern void g_main_context_push_thread_default(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_push_thread_default(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    g_main_context_push_thread_default(context);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_push_thread_default_obj, 1, mp_g_main_context_push_thread_default, g_main_context_push_thread_default);

 

/*
 * dbus extension definition for:
 * extern void g_main_context_pop_thread_default(GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_main_context_pop_thread_default(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    g_main_context_pop_thread_default(context);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_pop_thread_default_obj, 1, mp_g_main_context_pop_thread_default, g_main_context_pop_thread_default);

 

/*
 * dbus extension definition for:
 * extern GMainContext *g_main_context_get_thread_default(void)
 */
 
STATIC mp_obj_t mp_g_main_context_get_thread_default(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GMainContext * res = g_main_context_get_thread_default();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_get_thread_default_obj, 0, mp_g_main_context_get_thread_default, g_main_context_get_thread_default);

 

/*
 * dbus extension definition for:
 * extern GMainContext *g_main_context_ref_thread_default(void)
 */
 
STATIC mp_obj_t mp_g_main_context_ref_thread_default(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GMainContext * res = g_main_context_ref_thread_default();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_ref_thread_default_obj, 0, mp_g_main_context_ref_thread_default, g_main_context_ref_thread_default);

 

/*
 * dbus extension definition for:
 * extern GMainLoop *g_main_loop_new(GMainContext *context, gboolean is_running)
 */
 
STATIC mp_obj_t mp_g_main_loop_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    gboolean is_running = (int)mp_obj_get_int(mp_args[1]);
    GMainLoop * res = g_main_loop_new(context, is_running);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_loop_new_obj, 2, mp_g_main_loop_new, g_main_loop_new);

 

/*
 * dbus extension definition for:
 * extern void g_main_loop_run(GMainLoop *loop)
 */
 
STATIC mp_obj_t mp_g_main_loop_run(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainLoop *loop = mp_to_ptr(mp_args[0]);
    g_main_loop_run(loop);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_loop_run_obj, 1, mp_g_main_loop_run, g_main_loop_run);

 

/*
 * dbus extension definition for:
 * extern void g_main_loop_quit(GMainLoop *loop)
 */
 
STATIC mp_obj_t mp_g_main_loop_quit(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainLoop *loop = mp_to_ptr(mp_args[0]);
    g_main_loop_quit(loop);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_loop_quit_obj, 1, mp_g_main_loop_quit, g_main_loop_quit);

 

/*
 * dbus extension definition for:
 * extern GMainLoop *g_main_loop_ref(GMainLoop *loop)
 */
 
STATIC mp_obj_t mp_g_main_loop_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainLoop *loop = mp_to_ptr(mp_args[0]);
    GMainLoop * res = g_main_loop_ref(loop);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_loop_ref_obj, 1, mp_g_main_loop_ref, g_main_loop_ref);

 

/*
 * dbus extension definition for:
 * extern void g_main_loop_unref(GMainLoop *loop)
 */
 
STATIC mp_obj_t mp_g_main_loop_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainLoop *loop = mp_to_ptr(mp_args[0]);
    g_main_loop_unref(loop);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_loop_unref_obj, 1, mp_g_main_loop_unref, g_main_loop_unref);

 

/*
 * dbus extension definition for:
 * extern gboolean g_main_loop_is_running(GMainLoop *loop)
 */
 
STATIC mp_obj_t mp_g_main_loop_is_running(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainLoop *loop = mp_to_ptr(mp_args[0]);
    gboolean res = g_main_loop_is_running(loop);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_loop_is_running_obj, 1, mp_g_main_loop_is_running, g_main_loop_is_running);

 

/*
 * dbus extension definition for:
 * extern GMainContext *g_main_loop_get_context(GMainLoop *loop)
 */
 
STATIC mp_obj_t mp_g_main_loop_get_context(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainLoop *loop = mp_to_ptr(mp_args[0]);
    GMainContext * res = g_main_loop_get_context(loop);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_loop_get_context_obj, 1, mp_g_main_loop_get_context, g_main_loop_get_context);

 

/*
 * dbus extension definition for:
 * extern GSource *g_source_new(GSourceFuncs *source_funcs, guint struct_size)
 */
 
STATIC mp_obj_t mp_g_source_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSourceFuncs *source_funcs = mp_to_ptr(mp_args[0]);
    guint struct_size = (unsigned int)mp_obj_get_int(mp_args[1]);
    GSource * res = g_source_new(source_funcs, struct_size);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_new_obj, 2, mp_g_source_new, g_source_new);

 

/*
 * dbus extension definition for:
 * extern GSource *g_source_ref(GSource *source)
 */
 
STATIC mp_obj_t mp_g_source_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    GSource * res = g_source_ref(source);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_ref_obj, 1, mp_g_source_ref, g_source_ref);

 

/*
 * dbus extension definition for:
 * extern void g_source_unref(GSource *source)
 */
 
STATIC mp_obj_t mp_g_source_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    g_source_unref(source);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_unref_obj, 1, mp_g_source_unref, g_source_unref);

 

/*
 * dbus extension definition for:
 * extern guint g_source_attach(GSource *source, GMainContext *context)
 */
 
STATIC mp_obj_t mp_g_source_attach(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    GMainContext *context = mp_to_ptr(mp_args[1]);
    guint res = g_source_attach(source, context);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_attach_obj, 2, mp_g_source_attach, g_source_attach);

 

/*
 * dbus extension definition for:
 * extern void g_source_destroy(GSource *source)
 */
 
STATIC mp_obj_t mp_g_source_destroy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    g_source_destroy(source);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_destroy_obj, 1, mp_g_source_destroy, g_source_destroy);

 

/*
 * dbus extension definition for:
 * extern void g_source_set_priority(GSource *source, gint priority)
 */
 
STATIC mp_obj_t mp_g_source_set_priority(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    gint priority = (int)mp_obj_get_int(mp_args[1]);
    g_source_set_priority(source, priority);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_set_priority_obj, 2, mp_g_source_set_priority, g_source_set_priority);

 

/*
 * dbus extension definition for:
 * extern gint g_source_get_priority(GSource *source)
 */
 
STATIC mp_obj_t mp_g_source_get_priority(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    gint res = g_source_get_priority(source);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_get_priority_obj, 1, mp_g_source_get_priority, g_source_get_priority);

 

/*
 * dbus extension definition for:
 * extern void g_source_set_can_recurse(GSource *source, gboolean can_recurse)
 */
 
STATIC mp_obj_t mp_g_source_set_can_recurse(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    gboolean can_recurse = (int)mp_obj_get_int(mp_args[1]);
    g_source_set_can_recurse(source, can_recurse);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_set_can_recurse_obj, 2, mp_g_source_set_can_recurse, g_source_set_can_recurse);

 

/*
 * dbus extension definition for:
 * extern gboolean g_source_get_can_recurse(GSource *source)
 */
 
STATIC mp_obj_t mp_g_source_get_can_recurse(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    gboolean res = g_source_get_can_recurse(source);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_get_can_recurse_obj, 1, mp_g_source_get_can_recurse, g_source_get_can_recurse);

 

/*
 * dbus extension definition for:
 * extern guint g_source_get_id(GSource *source)
 */
 
STATIC mp_obj_t mp_g_source_get_id(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    guint res = g_source_get_id(source);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_get_id_obj, 1, mp_g_source_get_id, g_source_get_id);

 

/*
 * dbus extension definition for:
 * extern GMainContext *g_source_get_context(GSource *source)
 */
 
STATIC mp_obj_t mp_g_source_get_context(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    GMainContext * res = g_source_get_context(source);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_get_context_obj, 1, mp_g_source_get_context, g_source_get_context);

 

/*
 * Function NOT generated:
 * Callback function 'GSourceFunc func' must receive a struct pointer with user_data member as its first argument!
 * GSourceFunc func
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify notify' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify notify
 */
    

/*
 * dbus extension definition for:
 * extern void g_source_set_callback(GSource *source, GSourceFunc func, gpointer data, GDestroyNotify notify)
 */
 
STATIC mp_obj_t mp_g_source_set_callback(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    GSourceFunc func = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GDestroyNotify notify = mp_to_ptr(mp_args[3]);
    g_source_set_callback(source, func, data, notify);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_set_callback_obj, 4, mp_g_source_set_callback, g_source_set_callback);

 

/*
 * dbus extension definition for:
 * extern void g_source_set_funcs(GSource *source, GSourceFuncs *funcs)
 */
 
STATIC mp_obj_t mp_g_source_set_funcs(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    GSourceFuncs *funcs = mp_to_ptr(mp_args[1]);
    g_source_set_funcs(source, funcs);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_set_funcs_obj, 2, mp_g_source_set_funcs, g_source_set_funcs);

 

/*
 * dbus extension definition for:
 * extern gboolean g_source_is_destroyed(GSource *source)
 */
 
STATIC mp_obj_t mp_g_source_is_destroyed(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    gboolean res = g_source_is_destroyed(source);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_is_destroyed_obj, 1, mp_g_source_is_destroyed, g_source_is_destroyed);

 

/*
 * dbus extension definition for:
 * extern void g_source_set_name(GSource *source, const char *name)
 */
 
STATIC mp_obj_t mp_g_source_set_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    g_source_set_name(source, name);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_set_name_obj, 2, mp_g_source_set_name, g_source_set_name);

 

/*
 * dbus extension definition for:
 * extern const char *g_source_get_name(GSource *source)
 */
 
STATIC mp_obj_t mp_g_source_get_name(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    const char * res = g_source_get_name(source);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_get_name_obj, 1, mp_g_source_get_name, g_source_get_name);

 

/*
 * dbus extension definition for:
 * extern void g_source_set_name_by_id(guint tag, const char *name)
 */
 
STATIC mp_obj_t mp_g_source_set_name_by_id(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint tag = (unsigned int)mp_obj_get_int(mp_args[0]);
    const char *name = (char*)mp_obj_str_get_str(mp_args[1]);
    g_source_set_name_by_id(tag, name);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_set_name_by_id_obj, 2, mp_g_source_set_name_by_id, g_source_set_name_by_id);

 

/*
 * Function NOT generated:
 * Missing conversion to gint64
 * extern void g_source_set_ready_time(GSource *source, gint64 ready_time)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from gint64
 * extern gint64 g_source_get_ready_time(GSource *source)
 */
    

/*
 * dbus extension definition for:
 * extern gpointer g_source_add_unix_fd(GSource *source, gint fd, GIOCondition events)
 */
 
STATIC mp_obj_t mp_g_source_add_unix_fd(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    gint fd = (int)mp_obj_get_int(mp_args[1]);
    GIOCondition events = (int)mp_obj_get_int(mp_args[2]);
    gpointer res = g_source_add_unix_fd(source, fd, events);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_add_unix_fd_obj, 3, mp_g_source_add_unix_fd, g_source_add_unix_fd);

 

/*
 * dbus extension definition for:
 * extern void g_source_modify_unix_fd(GSource *source, gpointer tag, GIOCondition new_events)
 */
 
STATIC mp_obj_t mp_g_source_modify_unix_fd(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    gpointer tag = mp_to_ptr(mp_args[1]);
    GIOCondition new_events = (int)mp_obj_get_int(mp_args[2]);
    g_source_modify_unix_fd(source, tag, new_events);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_modify_unix_fd_obj, 3, mp_g_source_modify_unix_fd, g_source_modify_unix_fd);

 

/*
 * dbus extension definition for:
 * extern void g_source_remove_unix_fd(GSource *source, gpointer tag)
 */
 
STATIC mp_obj_t mp_g_source_remove_unix_fd(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    gpointer tag = mp_to_ptr(mp_args[1]);
    g_source_remove_unix_fd(source, tag);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_remove_unix_fd_obj, 2, mp_g_source_remove_unix_fd, g_source_remove_unix_fd);

 

/*
 * dbus extension definition for:
 * extern GIOCondition g_source_query_unix_fd(GSource *source, gpointer tag)
 */
 
STATIC mp_obj_t mp_g_source_query_unix_fd(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    gpointer tag = mp_to_ptr(mp_args[1]);
    GIOCondition res = g_source_query_unix_fd(source, tag);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_query_unix_fd_obj, 2, mp_g_source_query_unix_fd, g_source_query_unix_fd);

 

/*
 * dbus extension definition for:
 * extern void g_source_set_callback_indirect(GSource *source, gpointer callback_data, GSourceCallbackFuncs *callback_funcs)
 */
 
STATIC mp_obj_t mp_g_source_set_callback_indirect(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    gpointer callback_data = mp_to_ptr(mp_args[1]);
    GSourceCallbackFuncs *callback_funcs = mp_to_ptr(mp_args[2]);
    g_source_set_callback_indirect(source, callback_data, callback_funcs);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_set_callback_indirect_obj, 3, mp_g_source_set_callback_indirect, g_source_set_callback_indirect);

 

/*
 * dbus extension definition for:
 * extern void g_source_add_poll(GSource *source, GPollFD *fd)
 */
 
STATIC mp_obj_t mp_g_source_add_poll(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    GPollFD *fd = mp_to_ptr(mp_args[1]);
    g_source_add_poll(source, fd);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_add_poll_obj, 2, mp_g_source_add_poll, g_source_add_poll);

 

/*
 * dbus extension definition for:
 * extern void g_source_remove_poll(GSource *source, GPollFD *fd)
 */
 
STATIC mp_obj_t mp_g_source_remove_poll(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    GPollFD *fd = mp_to_ptr(mp_args[1]);
    g_source_remove_poll(source, fd);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_remove_poll_obj, 2, mp_g_source_remove_poll, g_source_remove_poll);

 

/*
 * dbus extension definition for:
 * extern void g_source_add_child_source(GSource *source, GSource *child_source)
 */
 
STATIC mp_obj_t mp_g_source_add_child_source(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    GSource *child_source = mp_to_ptr(mp_args[1]);
    g_source_add_child_source(source, child_source);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_add_child_source_obj, 2, mp_g_source_add_child_source, g_source_add_child_source);

 

/*
 * dbus extension definition for:
 * extern void g_source_remove_child_source(GSource *source, GSource *child_source)
 */
 
STATIC mp_obj_t mp_g_source_remove_child_source(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    GSource *child_source = mp_to_ptr(mp_args[1]);
    g_source_remove_child_source(source, child_source);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_remove_child_source_obj, 2, mp_g_source_remove_child_source, g_source_remove_child_source);

 

/*
 * dbus extension definition for:
 * extern void g_source_get_current_time(GSource *source, GTimeVal *timeval)
 */
 
STATIC mp_obj_t mp_g_source_get_current_time(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSource *source = mp_to_ptr(mp_args[0]);
    GTimeVal *timeval = mp_to_ptr(mp_args[1]);
    g_source_get_current_time(source, timeval);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_get_current_time_obj, 2, mp_g_source_get_current_time, g_source_get_current_time);

 

/*
 * Function NOT generated:
 * Missing convertion from gint64
 * extern gint64 g_source_get_time(GSource *source)
 */
    

/*
 * dbus extension definition for:
 * extern GSource *g_idle_source_new(void)
 */
 
STATIC mp_obj_t mp_g_idle_source_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GSource * res = g_idle_source_new();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_idle_source_new_obj, 0, mp_g_idle_source_new, g_idle_source_new);

 

/*
 * dbus extension definition for:
 * extern GSource *g_child_watch_source_new(GPid pid)
 */
 
STATIC mp_obj_t mp_g_child_watch_source_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPid pid = (int)mp_obj_get_int(mp_args[0]);
    GSource * res = g_child_watch_source_new(pid);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_child_watch_source_new_obj, 1, mp_g_child_watch_source_new, g_child_watch_source_new);

 

/*
 * dbus extension definition for:
 * extern GSource *g_timeout_source_new(guint interval)
 */
 
STATIC mp_obj_t mp_g_timeout_source_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint interval = (unsigned int)mp_obj_get_int(mp_args[0]);
    GSource * res = g_timeout_source_new(interval);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_timeout_source_new_obj, 1, mp_g_timeout_source_new, g_timeout_source_new);

 

/*
 * dbus extension definition for:
 * extern GSource *g_timeout_source_new_seconds(guint interval)
 */
 
STATIC mp_obj_t mp_g_timeout_source_new_seconds(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint interval = (unsigned int)mp_obj_get_int(mp_args[0]);
    GSource * res = g_timeout_source_new_seconds(interval);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_timeout_source_new_seconds_obj, 1, mp_g_timeout_source_new_seconds, g_timeout_source_new_seconds);

 

/*
 * dbus extension definition for:
 * extern void g_get_current_time(GTimeVal *result)
 */
 
STATIC mp_obj_t mp_g_get_current_time(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GTimeVal *result = mp_to_ptr(mp_args[0]);
    g_get_current_time(result);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_get_current_time_obj, 1, mp_g_get_current_time, g_get_current_time);

 

/*
 * Function NOT generated:
 * Missing convertion from gint64
 * extern gint64 g_get_monotonic_time(void)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from gint64
 * extern gint64 g_get_real_time(void)
 */
    

/*
 * dbus extension definition for:
 * extern gboolean g_source_remove(guint tag)
 */
 
STATIC mp_obj_t mp_g_source_remove(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint tag = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_source_remove(tag);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_remove_obj, 1, mp_g_source_remove, g_source_remove);

 

/*
 * dbus extension definition for:
 * extern gboolean g_source_remove_by_user_data(gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_source_remove_by_user_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer user_data = mp_to_ptr(mp_args[0]);
    gboolean res = g_source_remove_by_user_data(user_data);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_remove_by_user_data_obj, 1, mp_g_source_remove_by_user_data, g_source_remove_by_user_data);

 

/*
 * dbus extension definition for:
 * extern gboolean g_source_remove_by_funcs_user_data(GSourceFuncs *funcs, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_source_remove_by_funcs_user_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSourceFuncs *funcs = mp_to_ptr(mp_args[0]);
    gpointer user_data = mp_to_ptr(mp_args[1]);
    gboolean res = g_source_remove_by_funcs_user_data(funcs, user_data);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_source_remove_by_funcs_user_data_obj, 2, mp_g_source_remove_by_funcs_user_data, g_source_remove_by_funcs_user_data);

 

/*
 * Function NOT generated:
 * Callback function 'GSourceFunc function' must receive a struct pointer with user_data member as its first argument!
 * GSourceFunc function
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify notify' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify notify
 */
    

/*
 * dbus extension definition for:
 * extern guint g_timeout_add_full(gint priority, guint interval, GSourceFunc function, gpointer data, GDestroyNotify notify)
 */
 
STATIC mp_obj_t mp_g_timeout_add_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gint priority = (int)mp_obj_get_int(mp_args[0]);
    guint interval = (unsigned int)mp_obj_get_int(mp_args[1]);
    GSourceFunc function = mp_to_ptr(mp_args[2]);
    gpointer data = mp_to_ptr(mp_args[3]);
    GDestroyNotify notify = mp_to_ptr(mp_args[4]);
    guint res = g_timeout_add_full(priority, interval, function, data, notify);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_timeout_add_full_obj, 5, mp_g_timeout_add_full, g_timeout_add_full);

 

/*
 * Function NOT generated:
 * Callback function 'GSourceFunc function' must receive a struct pointer with user_data member as its first argument!
 * GSourceFunc function
 */
    

/*
 * dbus extension definition for:
 * extern guint g_timeout_add(guint interval, GSourceFunc function, gpointer data)
 */
 
STATIC mp_obj_t mp_g_timeout_add(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint interval = (unsigned int)mp_obj_get_int(mp_args[0]);
    GSourceFunc function = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    guint res = g_timeout_add(interval, function, data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_timeout_add_obj, 3, mp_g_timeout_add, g_timeout_add);

 

/*
 * Function NOT generated:
 * Callback function 'GSourceFunc function' must receive a struct pointer with user_data member as its first argument!
 * GSourceFunc function
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify notify' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify notify
 */
    

/*
 * dbus extension definition for:
 * extern guint g_timeout_add_seconds_full(gint priority, guint interval, GSourceFunc function, gpointer data, GDestroyNotify notify)
 */
 
STATIC mp_obj_t mp_g_timeout_add_seconds_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gint priority = (int)mp_obj_get_int(mp_args[0]);
    guint interval = (unsigned int)mp_obj_get_int(mp_args[1]);
    GSourceFunc function = mp_to_ptr(mp_args[2]);
    gpointer data = mp_to_ptr(mp_args[3]);
    GDestroyNotify notify = mp_to_ptr(mp_args[4]);
    guint res = g_timeout_add_seconds_full(priority, interval, function, data, notify);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_timeout_add_seconds_full_obj, 5, mp_g_timeout_add_seconds_full, g_timeout_add_seconds_full);

 

/*
 * Function NOT generated:
 * Callback function 'GSourceFunc function' must receive a struct pointer with user_data member as its first argument!
 * GSourceFunc function
 */
    

/*
 * dbus extension definition for:
 * extern guint g_timeout_add_seconds(guint interval, GSourceFunc function, gpointer data)
 */
 
STATIC mp_obj_t mp_g_timeout_add_seconds(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint interval = (unsigned int)mp_obj_get_int(mp_args[0]);
    GSourceFunc function = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    guint res = g_timeout_add_seconds(interval, function, data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_timeout_add_seconds_obj, 3, mp_g_timeout_add_seconds, g_timeout_add_seconds);

 

/*
 * Function NOT generated:
 * Callback function 'GChildWatchFunc function' must receive a struct pointer with user_data member as its first argument!
 * GChildWatchFunc function
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify notify' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify notify
 */
    

/*
 * dbus extension definition for:
 * extern guint g_child_watch_add_full(gint priority, GPid pid, GChildWatchFunc function, gpointer data, GDestroyNotify notify)
 */
 
STATIC mp_obj_t mp_g_child_watch_add_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gint priority = (int)mp_obj_get_int(mp_args[0]);
    GPid pid = (int)mp_obj_get_int(mp_args[1]);
    GChildWatchFunc function = mp_to_ptr(mp_args[2]);
    gpointer data = mp_to_ptr(mp_args[3]);
    GDestroyNotify notify = mp_to_ptr(mp_args[4]);
    guint res = g_child_watch_add_full(priority, pid, function, data, notify);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_child_watch_add_full_obj, 5, mp_g_child_watch_add_full, g_child_watch_add_full);

 

/*
 * Function NOT generated:
 * Callback function 'GChildWatchFunc function' must receive a struct pointer with user_data member as its first argument!
 * GChildWatchFunc function
 */
    

/*
 * dbus extension definition for:
 * extern guint g_child_watch_add(GPid pid, GChildWatchFunc function, gpointer data)
 */
 
STATIC mp_obj_t mp_g_child_watch_add(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPid pid = (int)mp_obj_get_int(mp_args[0]);
    GChildWatchFunc function = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    guint res = g_child_watch_add(pid, function, data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_child_watch_add_obj, 3, mp_g_child_watch_add, g_child_watch_add);

 

/*
 * Function NOT generated:
 * Callback argument 'GSourceFunc function' cannot be the first argument! We assume the first argument contains the user_data
 * GSourceFunc function
 */
    

/*
 * dbus extension definition for:
 * extern guint g_idle_add(GSourceFunc function, gpointer data)
 */
 
STATIC mp_obj_t mp_g_idle_add(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GSourceFunc function = mp_to_ptr(mp_args[0]);
    gpointer data = mp_to_ptr(mp_args[1]);
    guint res = g_idle_add(function, data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_idle_add_obj, 2, mp_g_idle_add, g_idle_add);

 

/*
 * Function NOT generated:
 * Callback function 'GSourceFunc function' must receive a struct pointer with user_data member as its first argument!
 * GSourceFunc function
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify notify' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify notify
 */
    

/*
 * dbus extension definition for:
 * extern guint g_idle_add_full(gint priority, GSourceFunc function, gpointer data, GDestroyNotify notify)
 */
 
STATIC mp_obj_t mp_g_idle_add_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gint priority = (int)mp_obj_get_int(mp_args[0]);
    GSourceFunc function = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GDestroyNotify notify = mp_to_ptr(mp_args[3]);
    guint res = g_idle_add_full(priority, function, data, notify);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_idle_add_full_obj, 4, mp_g_idle_add_full, g_idle_add_full);

 

/*
 * dbus extension definition for:
 * extern gboolean g_idle_remove_by_data(gpointer data)
 */
 
STATIC mp_obj_t mp_g_idle_remove_by_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gpointer data = mp_to_ptr(mp_args[0]);
    gboolean res = g_idle_remove_by_data(data);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_idle_remove_by_data_obj, 1, mp_g_idle_remove_by_data, g_idle_remove_by_data);

 

/*
 * Function NOT generated:
 * Callback function 'GSourceFunc function' must receive a struct pointer with user_data member as its first argument!
 * GSourceFunc function
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify notify' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify notify
 */
    

/*
 * dbus extension definition for:
 * extern void g_main_context_invoke_full(GMainContext *context, gint priority, GSourceFunc function, gpointer data, GDestroyNotify notify)
 */
 
STATIC mp_obj_t mp_g_main_context_invoke_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    gint priority = (int)mp_obj_get_int(mp_args[1]);
    GSourceFunc function = mp_to_ptr(mp_args[2]);
    gpointer data = mp_to_ptr(mp_args[3]);
    GDestroyNotify notify = mp_to_ptr(mp_args[4]);
    g_main_context_invoke_full(context, priority, function, data, notify);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_invoke_full_obj, 5, mp_g_main_context_invoke_full, g_main_context_invoke_full);

 

/*
 * Function NOT generated:
 * Callback function 'GSourceFunc function' must receive a struct pointer with user_data member as its first argument!
 * GSourceFunc function
 */
    

/*
 * dbus extension definition for:
 * extern void g_main_context_invoke(GMainContext *context, GSourceFunc function, gpointer data)
 */
 
STATIC mp_obj_t mp_g_main_context_invoke(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMainContext *context = mp_to_ptr(mp_args[0]);
    GSourceFunc function = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    g_main_context_invoke(context, function, data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_main_context_invoke_obj, 3, mp_g_main_context_invoke, g_main_context_invoke);

 

/*
 * dbus extension definition for:
 * extern guint32 g_unicode_script_to_iso15924(GUnicodeScript script)
 */
 
STATIC mp_obj_t mp_g_unicode_script_to_iso15924(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GUnicodeScript script = (int)mp_obj_get_int(mp_args[0]);
    guint32 res = g_unicode_script_to_iso15924(script);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unicode_script_to_iso15924_obj, 1, mp_g_unicode_script_to_iso15924, g_unicode_script_to_iso15924);

 

/*
 * dbus extension definition for:
 * extern GUnicodeScript g_unicode_script_from_iso15924(guint32 iso15924)
 */
 
STATIC mp_obj_t mp_g_unicode_script_from_iso15924(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint32 iso15924 = (unsigned int)mp_obj_get_int(mp_args[0]);
    GUnicodeScript res = g_unicode_script_from_iso15924(iso15924);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unicode_script_from_iso15924_obj, 1, mp_g_unicode_script_from_iso15924, g_unicode_script_from_iso15924);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_isalnum(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_isalnum(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_isalnum(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_isalnum_obj, 1, mp_g_unichar_isalnum, g_unichar_isalnum);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_isalpha(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_isalpha(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_isalpha(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_isalpha_obj, 1, mp_g_unichar_isalpha, g_unichar_isalpha);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_iscntrl(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_iscntrl(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_iscntrl(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_iscntrl_obj, 1, mp_g_unichar_iscntrl, g_unichar_iscntrl);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_isdigit(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_isdigit(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_isdigit(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_isdigit_obj, 1, mp_g_unichar_isdigit, g_unichar_isdigit);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_isgraph(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_isgraph(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_isgraph(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_isgraph_obj, 1, mp_g_unichar_isgraph, g_unichar_isgraph);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_islower(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_islower(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_islower(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_islower_obj, 1, mp_g_unichar_islower, g_unichar_islower);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_isprint(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_isprint(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_isprint(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_isprint_obj, 1, mp_g_unichar_isprint, g_unichar_isprint);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_ispunct(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_ispunct(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_ispunct(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_ispunct_obj, 1, mp_g_unichar_ispunct, g_unichar_ispunct);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_isspace(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_isspace(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_isspace(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_isspace_obj, 1, mp_g_unichar_isspace, g_unichar_isspace);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_isupper(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_isupper(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_isupper(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_isupper_obj, 1, mp_g_unichar_isupper, g_unichar_isupper);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_isxdigit(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_isxdigit(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_isxdigit(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_isxdigit_obj, 1, mp_g_unichar_isxdigit, g_unichar_isxdigit);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_istitle(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_istitle(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_istitle(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_istitle_obj, 1, mp_g_unichar_istitle, g_unichar_istitle);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_isdefined(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_isdefined(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_isdefined(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_isdefined_obj, 1, mp_g_unichar_isdefined, g_unichar_isdefined);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_iswide(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_iswide(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_iswide(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_iswide_obj, 1, mp_g_unichar_iswide, g_unichar_iswide);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_iswide_cjk(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_iswide_cjk(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_iswide_cjk(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_iswide_cjk_obj, 1, mp_g_unichar_iswide_cjk, g_unichar_iswide_cjk);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_iszerowidth(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_iszerowidth(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_iszerowidth(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_iszerowidth_obj, 1, mp_g_unichar_iszerowidth, g_unichar_iszerowidth);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_ismark(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_ismark(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_ismark(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_ismark_obj, 1, mp_g_unichar_ismark, g_unichar_ismark);

 

/*
 * dbus extension definition for:
 * extern gunichar g_unichar_toupper(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_toupper(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gunichar res = g_unichar_toupper(c);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_toupper_obj, 1, mp_g_unichar_toupper, g_unichar_toupper);

 

/*
 * dbus extension definition for:
 * extern gunichar g_unichar_tolower(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_tolower(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gunichar res = g_unichar_tolower(c);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_tolower_obj, 1, mp_g_unichar_tolower, g_unichar_tolower);

 

/*
 * dbus extension definition for:
 * extern gunichar g_unichar_totitle(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_totitle(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gunichar res = g_unichar_totitle(c);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_totitle_obj, 1, mp_g_unichar_totitle, g_unichar_totitle);

 

/*
 * dbus extension definition for:
 * extern gint g_unichar_digit_value(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_digit_value(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gint res = g_unichar_digit_value(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_digit_value_obj, 1, mp_g_unichar_digit_value, g_unichar_digit_value);

 

/*
 * dbus extension definition for:
 * extern gint g_unichar_xdigit_value(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_xdigit_value(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gint res = g_unichar_xdigit_value(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_xdigit_value_obj, 1, mp_g_unichar_xdigit_value, g_unichar_xdigit_value);

 

/*
 * dbus extension definition for:
 * extern GUnicodeType g_unichar_type(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    GUnicodeType res = g_unichar_type(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_type_obj, 1, mp_g_unichar_type, g_unichar_type);

 

/*
 * dbus extension definition for:
 * extern GUnicodeBreakType g_unichar_break_type(gunichar c)
 */
 
STATIC mp_obj_t mp_g_unichar_break_type(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    GUnicodeBreakType res = g_unichar_break_type(c);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_break_type_obj, 1, mp_g_unichar_break_type, g_unichar_break_type);

 

/*
 * dbus extension definition for:
 * extern gint g_unichar_combining_class(gunichar uc)
 */
 
STATIC mp_obj_t mp_g_unichar_combining_class(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar uc = (unsigned int)mp_obj_get_int(mp_args[0]);
    gint res = g_unichar_combining_class(uc);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_combining_class_obj, 1, mp_g_unichar_combining_class, g_unichar_combining_class);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_get_mirror_char(gunichar ch, gunichar *mirrored_ch)
 */
 
STATIC mp_obj_t mp_g_unichar_get_mirror_char(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar ch = (unsigned int)mp_obj_get_int(mp_args[0]);
    gunichar *mirrored_ch = mp_to_ptr(mp_args[1]);
    gboolean res = g_unichar_get_mirror_char(ch, mirrored_ch);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_get_mirror_char_obj, 2, mp_g_unichar_get_mirror_char, g_unichar_get_mirror_char);

 

/*
 * dbus extension definition for:
 * extern GUnicodeScript g_unichar_get_script(gunichar ch)
 */
 
STATIC mp_obj_t mp_g_unichar_get_script(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar ch = (unsigned int)mp_obj_get_int(mp_args[0]);
    GUnicodeScript res = g_unichar_get_script(ch);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_get_script_obj, 1, mp_g_unichar_get_script, g_unichar_get_script);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_validate(gunichar ch)
 */
 
STATIC mp_obj_t mp_g_unichar_validate(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar ch = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean res = g_unichar_validate(ch);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_validate_obj, 1, mp_g_unichar_validate, g_unichar_validate);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_compose(gunichar a, gunichar b, gunichar *ch)
 */
 
STATIC mp_obj_t mp_g_unichar_compose(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar a = (unsigned int)mp_obj_get_int(mp_args[0]);
    gunichar b = (unsigned int)mp_obj_get_int(mp_args[1]);
    gunichar *ch = mp_to_ptr(mp_args[2]);
    gboolean res = g_unichar_compose(a, b, ch);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_compose_obj, 3, mp_g_unichar_compose, g_unichar_compose);

 

/*
 * dbus extension definition for:
 * extern gboolean g_unichar_decompose(gunichar ch, gunichar *a, gunichar *b)
 */
 
STATIC mp_obj_t mp_g_unichar_decompose(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar ch = (unsigned int)mp_obj_get_int(mp_args[0]);
    gunichar *a = mp_to_ptr(mp_args[1]);
    gunichar *b = mp_to_ptr(mp_args[2]);
    gboolean res = g_unichar_decompose(ch, a, b);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_decompose_obj, 3, mp_g_unichar_decompose, g_unichar_decompose);

 

/*
 * dbus extension definition for:
 * extern gsize g_unichar_fully_decompose(gunichar ch, gboolean compat, gunichar *result, gsize result_len)
 */
 
STATIC mp_obj_t mp_g_unichar_fully_decompose(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar ch = (unsigned int)mp_obj_get_int(mp_args[0]);
    gboolean compat = (int)mp_obj_get_int(mp_args[1]);
    gunichar *result = mp_to_ptr(mp_args[2]);
    gsize result_len = (unsigned long)mp_obj_get_int(mp_args[3]);
    gsize res = g_unichar_fully_decompose(ch, compat, result, result_len);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_fully_decompose_obj, 4, mp_g_unichar_fully_decompose, g_unichar_fully_decompose);

 

/*
 * dbus extension definition for:
 * extern void g_unicode_canonical_ordering(gunichar *string, gsize len)
 */
 
STATIC mp_obj_t mp_g_unicode_canonical_ordering(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar *string = mp_to_ptr(mp_args[0]);
    gsize len = (unsigned long)mp_obj_get_int(mp_args[1]);
    g_unicode_canonical_ordering(string, len);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unicode_canonical_ordering_obj, 2, mp_g_unicode_canonical_ordering, g_unicode_canonical_ordering);

 

/*
 * dbus extension definition for:
 * extern gunichar *g_unicode_canonical_decomposition(gunichar ch, gsize *result_len)
 */
 
STATIC mp_obj_t mp_g_unicode_canonical_decomposition(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar ch = (unsigned int)mp_obj_get_int(mp_args[0]);
    gsize *result_len = mp_to_ptr(mp_args[1]);
    gunichar * res = g_unicode_canonical_decomposition(ch, result_len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unicode_canonical_decomposition_obj, 2, mp_g_unicode_canonical_decomposition, g_unicode_canonical_decomposition);

 

/*
 * dbus extension definition for:
 * extern gunichar g_utf8_get_char(const gchar *p)
 */
 
STATIC mp_obj_t mp_g_utf8_get_char(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *p = (char*)mp_obj_str_get_str(mp_args[0]);
    gunichar res = g_utf8_get_char(p);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_get_char_obj, 1, mp_g_utf8_get_char, g_utf8_get_char);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gunichar g_utf8_get_char_validated(const gchar *p, gssize max_len)
 */
    

/*
 * dbus extension definition for:
 * extern gchar *g_utf8_offset_to_pointer(const gchar *str, glong offset)
 */
 
STATIC mp_obj_t mp_g_utf8_offset_to_pointer(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *str = (char*)mp_obj_str_get_str(mp_args[0]);
    glong offset = (long)mp_obj_get_int(mp_args[1]);
    gchar * res = g_utf8_offset_to_pointer(str, offset);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_offset_to_pointer_obj, 2, mp_g_utf8_offset_to_pointer, g_utf8_offset_to_pointer);

 

/*
 * dbus extension definition for:
 * extern glong g_utf8_pointer_to_offset(const gchar *str, const gchar *pos)
 */
 
STATIC mp_obj_t mp_g_utf8_pointer_to_offset(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *str = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *pos = (char*)mp_obj_str_get_str(mp_args[1]);
    glong res = g_utf8_pointer_to_offset(str, pos);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_pointer_to_offset_obj, 2, mp_g_utf8_pointer_to_offset, g_utf8_pointer_to_offset);

 

/*
 * dbus extension definition for:
 * extern gchar *g_utf8_prev_char(const gchar *p)
 */
 
STATIC mp_obj_t mp_g_utf8_prev_char(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *p = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_utf8_prev_char(p);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_prev_char_obj, 1, mp_g_utf8_prev_char, g_utf8_prev_char);

 

/*
 * dbus extension definition for:
 * extern gchar *g_utf8_find_next_char(const gchar *p, const gchar *end)
 */
 
STATIC mp_obj_t mp_g_utf8_find_next_char(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *p = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *end = (char*)mp_obj_str_get_str(mp_args[1]);
    gchar * res = g_utf8_find_next_char(p, end);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_find_next_char_obj, 2, mp_g_utf8_find_next_char, g_utf8_find_next_char);

 

/*
 * dbus extension definition for:
 * extern gchar *g_utf8_find_prev_char(const gchar *str, const gchar *p)
 */
 
STATIC mp_obj_t mp_g_utf8_find_prev_char(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *str = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *p = (char*)mp_obj_str_get_str(mp_args[1]);
    gchar * res = g_utf8_find_prev_char(str, p);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_find_prev_char_obj, 2, mp_g_utf8_find_prev_char, g_utf8_find_prev_char);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern glong g_utf8_strlen(const gchar *p, gssize max)
 */
    

/*
 * dbus extension definition for:
 * extern gchar *g_utf8_substring(const gchar *str, glong start_pos, glong end_pos)
 */
 
STATIC mp_obj_t mp_g_utf8_substring(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *str = (char*)mp_obj_str_get_str(mp_args[0]);
    glong start_pos = (long)mp_obj_get_int(mp_args[1]);
    glong end_pos = (long)mp_obj_get_int(mp_args[2]);
    gchar * res = g_utf8_substring(str, start_pos, end_pos);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_substring_obj, 3, mp_g_utf8_substring, g_utf8_substring);

 

/*
 * dbus extension definition for:
 * extern gchar *g_utf8_strncpy(gchar *dest, const gchar *src, gsize n)
 */
 
STATIC mp_obj_t mp_g_utf8_strncpy(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gchar *dest = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *src = (char*)mp_obj_str_get_str(mp_args[1]);
    gsize n = (unsigned long)mp_obj_get_int(mp_args[2]);
    gchar * res = g_utf8_strncpy(dest, src, n);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_strncpy_obj, 3, mp_g_utf8_strncpy, g_utf8_strncpy);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_utf8_strchr(const gchar *p, gssize len, gunichar c)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_utf8_strrchr(const gchar *p, gssize len, gunichar c)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_utf8_strreverse(const gchar *str, gssize len)
 */
    

/*
 * dbus extension definition for:
 * extern gunichar2 *g_utf8_to_utf16(const gchar *str, glong len, glong *items_read, glong *items_written, GError **error)
 */
 
STATIC mp_obj_t mp_g_utf8_to_utf16(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *str = (char*)mp_obj_str_get_str(mp_args[0]);
    glong len = (long)mp_obj_get_int(mp_args[1]);
    glong *items_read = mp_to_ptr(mp_args[2]);
    glong *items_written = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gunichar2 * res = g_utf8_to_utf16(str, len, items_read, items_written, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_to_utf16_obj, 5, mp_g_utf8_to_utf16, g_utf8_to_utf16);

 

/*
 * dbus extension definition for:
 * extern gunichar *g_utf8_to_ucs4(const gchar *str, glong len, glong *items_read, glong *items_written, GError **error)
 */
 
STATIC mp_obj_t mp_g_utf8_to_ucs4(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *str = (char*)mp_obj_str_get_str(mp_args[0]);
    glong len = (long)mp_obj_get_int(mp_args[1]);
    glong *items_read = mp_to_ptr(mp_args[2]);
    glong *items_written = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gunichar * res = g_utf8_to_ucs4(str, len, items_read, items_written, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_to_ucs4_obj, 5, mp_g_utf8_to_ucs4, g_utf8_to_ucs4);

 

/*
 * dbus extension definition for:
 * extern gunichar *g_utf8_to_ucs4_fast(const gchar *str, glong len, glong *items_written)
 */
 
STATIC mp_obj_t mp_g_utf8_to_ucs4_fast(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *str = (char*)mp_obj_str_get_str(mp_args[0]);
    glong len = (long)mp_obj_get_int(mp_args[1]);
    glong *items_written = mp_to_ptr(mp_args[2]);
    gunichar * res = g_utf8_to_ucs4_fast(str, len, items_written);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_to_ucs4_fast_obj, 3, mp_g_utf8_to_ucs4_fast, g_utf8_to_ucs4_fast);

 

/*
 * dbus extension definition for:
 * extern gunichar *g_utf16_to_ucs4(const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **error)
 */
 
STATIC mp_obj_t mp_g_utf16_to_ucs4(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gunichar2 *str = mp_to_ptr(mp_args[0]);
    glong len = (long)mp_obj_get_int(mp_args[1]);
    glong *items_read = mp_to_ptr(mp_args[2]);
    glong *items_written = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gunichar * res = g_utf16_to_ucs4(str, len, items_read, items_written, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf16_to_ucs4_obj, 5, mp_g_utf16_to_ucs4, g_utf16_to_ucs4);

 

/*
 * dbus extension definition for:
 * extern gchar *g_utf16_to_utf8(const gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **error)
 */
 
STATIC mp_obj_t mp_g_utf16_to_utf8(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gunichar2 *str = mp_to_ptr(mp_args[0]);
    glong len = (long)mp_obj_get_int(mp_args[1]);
    glong *items_read = mp_to_ptr(mp_args[2]);
    glong *items_written = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gchar * res = g_utf16_to_utf8(str, len, items_read, items_written, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf16_to_utf8_obj, 5, mp_g_utf16_to_utf8, g_utf16_to_utf8);

 

/*
 * dbus extension definition for:
 * extern gunichar2 *g_ucs4_to_utf16(const gunichar *str, glong len, glong *items_read, glong *items_written, GError **error)
 */
 
STATIC mp_obj_t mp_g_ucs4_to_utf16(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gunichar *str = mp_to_ptr(mp_args[0]);
    glong len = (long)mp_obj_get_int(mp_args[1]);
    glong *items_read = mp_to_ptr(mp_args[2]);
    glong *items_written = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gunichar2 * res = g_ucs4_to_utf16(str, len, items_read, items_written, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ucs4_to_utf16_obj, 5, mp_g_ucs4_to_utf16, g_ucs4_to_utf16);

 

/*
 * dbus extension definition for:
 * extern gchar *g_ucs4_to_utf8(const gunichar *str, glong len, glong *items_read, glong *items_written, GError **error)
 */
 
STATIC mp_obj_t mp_g_ucs4_to_utf8(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gunichar *str = mp_to_ptr(mp_args[0]);
    glong len = (long)mp_obj_get_int(mp_args[1]);
    glong *items_read = mp_to_ptr(mp_args[2]);
    glong *items_written = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gchar * res = g_ucs4_to_utf8(str, len, items_read, items_written, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_ucs4_to_utf8_obj, 5, mp_g_ucs4_to_utf8, g_ucs4_to_utf8);

 

/*
 * dbus extension definition for:
 * extern gint g_unichar_to_utf8(gunichar c, gchar *outbuf)
 */
 
STATIC mp_obj_t mp_g_unichar_to_utf8(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gunichar c = (unsigned int)mp_obj_get_int(mp_args[0]);
    gchar *outbuf = (char*)mp_obj_str_get_str(mp_args[1]);
    gint res = g_unichar_to_utf8(c, outbuf);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_unichar_to_utf8_obj, 2, mp_g_unichar_to_utf8, g_unichar_to_utf8);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gboolean g_utf8_validate(const gchar *str, gssize max_len, const gchar **end)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_utf8_strup(const gchar *str, gssize len)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_utf8_strdown(const gchar *str, gssize len)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_utf8_casefold(const gchar *str, gssize len)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_utf8_normalize(const gchar *str, gssize len, GNormalizeMode mode)
 */
    

/*
 * dbus extension definition for:
 * extern gint g_utf8_collate(const gchar *str1, const gchar *str2)
 */
 
STATIC mp_obj_t mp_g_utf8_collate(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *str1 = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *str2 = (char*)mp_obj_str_get_str(mp_args[1]);
    gint res = g_utf8_collate(str1, str2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_utf8_collate_obj, 2, mp_g_utf8_collate, g_utf8_collate);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_utf8_collate_key(const gchar *str, gssize len)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_utf8_collate_key_for_filename(const gchar *str, gssize len)
 */
    

/*
 * dbus extension definition for:
 * gchar *_g_utf8_make_valid(const gchar *name)
 */
 
STATIC mp_obj_t mp__g_utf8_make_valid(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *name = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = _g_utf8_make_valid(name);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp__g_utf8_make_valid_obj, 1, mp__g_utf8_make_valid, _g_utf8_make_valid);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_new(const gchar *init)
 */
 
STATIC mp_obj_t mp_g_string_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *init = (char*)mp_obj_str_get_str(mp_args[0]);
    GString * res = g_string_new(init);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_new_obj, 1, mp_g_string_new, g_string_new);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern GString *g_string_new_len(const gchar *init, gssize len)
 */
    

/*
 * dbus extension definition for:
 * extern GString *g_string_sized_new(gsize dfl_size)
 */
 
STATIC mp_obj_t mp_g_string_sized_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gsize dfl_size = (unsigned long)mp_obj_get_int(mp_args[0]);
    GString * res = g_string_sized_new(dfl_size);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_sized_new_obj, 1, mp_g_string_sized_new, g_string_sized_new);

 

/*
 * dbus extension definition for:
 * extern gchar *g_string_free(GString *string, gboolean free_segment)
 */
 
STATIC mp_obj_t mp_g_string_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    gboolean free_segment = (int)mp_obj_get_int(mp_args[1]);
    gchar * res = g_string_free(string, free_segment);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_free_obj, 2, mp_g_string_free, g_string_free);

 

/*
 * dbus extension definition for:
 * extern GBytes *g_string_free_to_bytes(GString *string)
 */
 
STATIC mp_obj_t mp_g_string_free_to_bytes(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    GBytes * res = g_string_free_to_bytes(string);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_free_to_bytes_obj, 1, mp_g_string_free_to_bytes, g_string_free_to_bytes);

 

/*
 * dbus extension definition for:
 * extern gboolean g_string_equal(const GString *v, const GString *v2)
 */
 
STATIC mp_obj_t mp_g_string_equal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GString *v = mp_to_ptr(mp_args[0]);
    const GString *v2 = mp_to_ptr(mp_args[1]);
    gboolean res = g_string_equal(v, v2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_equal_obj, 2, mp_g_string_equal, g_string_equal);

 

/*
 * dbus extension definition for:
 * extern guint g_string_hash(const GString *str)
 */
 
STATIC mp_obj_t mp_g_string_hash(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GString *str = mp_to_ptr(mp_args[0]);
    guint res = g_string_hash(str);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_hash_obj, 1, mp_g_string_hash, g_string_hash);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_assign(GString *string, const gchar *rval)
 */
 
STATIC mp_obj_t mp_g_string_assign(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    const gchar *rval = (char*)mp_obj_str_get_str(mp_args[1]);
    GString * res = g_string_assign(string, rval);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_assign_obj, 2, mp_g_string_assign, g_string_assign);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_truncate(GString *string, gsize len)
 */
 
STATIC mp_obj_t mp_g_string_truncate(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    gsize len = (unsigned long)mp_obj_get_int(mp_args[1]);
    GString * res = g_string_truncate(string, len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_truncate_obj, 2, mp_g_string_truncate, g_string_truncate);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_set_size(GString *string, gsize len)
 */
 
STATIC mp_obj_t mp_g_string_set_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    gsize len = (unsigned long)mp_obj_get_int(mp_args[1]);
    GString * res = g_string_set_size(string, len);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_set_size_obj, 2, mp_g_string_set_size, g_string_set_size);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern GString *g_string_insert_len(GString *string, gssize pos, const gchar *val, gssize len)
 */
    

/*
 * dbus extension definition for:
 * extern GString *g_string_append(GString *string, const gchar *val)
 */
 
STATIC mp_obj_t mp_g_string_append(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    const gchar *val = (char*)mp_obj_str_get_str(mp_args[1]);
    GString * res = g_string_append(string, val);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_append_obj, 2, mp_g_string_append, g_string_append);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern GString *g_string_append_len(GString *string, const gchar *val, gssize len)
 */
    

/*
 * dbus extension definition for:
 * extern GString *g_string_append_c(GString *string, gchar c)
 */
 
STATIC mp_obj_t mp_g_string_append_c(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    gchar c = (char)mp_obj_get_int(mp_args[1]);
    GString * res = g_string_append_c(string, c);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_append_c_obj, 2, mp_g_string_append_c, g_string_append_c);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_append_unichar(GString *string, gunichar wc)
 */
 
STATIC mp_obj_t mp_g_string_append_unichar(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    gunichar wc = (unsigned int)mp_obj_get_int(mp_args[1]);
    GString * res = g_string_append_unichar(string, wc);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_append_unichar_obj, 2, mp_g_string_append_unichar, g_string_append_unichar);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_prepend(GString *string, const gchar *val)
 */
 
STATIC mp_obj_t mp_g_string_prepend(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    const gchar *val = (char*)mp_obj_str_get_str(mp_args[1]);
    GString * res = g_string_prepend(string, val);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_prepend_obj, 2, mp_g_string_prepend, g_string_prepend);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_prepend_c(GString *string, gchar c)
 */
 
STATIC mp_obj_t mp_g_string_prepend_c(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    gchar c = (char)mp_obj_get_int(mp_args[1]);
    GString * res = g_string_prepend_c(string, c);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_prepend_c_obj, 2, mp_g_string_prepend_c, g_string_prepend_c);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_prepend_unichar(GString *string, gunichar wc)
 */
 
STATIC mp_obj_t mp_g_string_prepend_unichar(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    gunichar wc = (unsigned int)mp_obj_get_int(mp_args[1]);
    GString * res = g_string_prepend_unichar(string, wc);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_prepend_unichar_obj, 2, mp_g_string_prepend_unichar, g_string_prepend_unichar);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern GString *g_string_prepend_len(GString *string, const gchar *val, gssize len)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern GString *g_string_insert(GString *string, gssize pos, const gchar *val)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern GString *g_string_insert_c(GString *string, gssize pos, gchar c)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern GString *g_string_insert_unichar(GString *string, gssize pos, gunichar wc)
 */
    

/*
 * dbus extension definition for:
 * extern GString *g_string_overwrite(GString *string, gsize pos, const gchar *val)
 */
 
STATIC mp_obj_t mp_g_string_overwrite(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    gsize pos = (unsigned long)mp_obj_get_int(mp_args[1]);
    const gchar *val = (char*)mp_obj_str_get_str(mp_args[2]);
    GString * res = g_string_overwrite(string, pos, val);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_overwrite_obj, 3, mp_g_string_overwrite, g_string_overwrite);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern GString *g_string_overwrite_len(GString *string, gsize pos, const gchar *val, gssize len)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern GString *g_string_erase(GString *string, gssize pos, gssize len)
 */
    

/*
 * dbus extension definition for:
 * extern GString *g_string_ascii_down(GString *string)
 */
 
STATIC mp_obj_t mp_g_string_ascii_down(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    GString * res = g_string_ascii_down(string);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_ascii_down_obj, 1, mp_g_string_ascii_down, g_string_ascii_down);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_ascii_up(GString *string)
 */
 
STATIC mp_obj_t mp_g_string_ascii_up(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    GString * res = g_string_ascii_up(string);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_ascii_up_obj, 1, mp_g_string_ascii_up, g_string_ascii_up);

 

/*
 * dbus extension definition for:
 * extern void g_string_vprintf(GString *string, const gchar *format, va_list args)
 */
 
STATIC mp_obj_t mp_g_string_vprintf(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[1]);
    va_list args = mp_to_ptr(mp_args[2]);
    g_string_vprintf(string, format, args);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_vprintf_obj, 3, mp_g_string_vprintf, g_string_vprintf);

 

/*
 * dbus extension definition for:
 * extern void g_string_printf(GString *string, const gchar *format, ...)
 */
 
STATIC mp_obj_t mp_g_string_printf(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[1]);
    g_string_printf(string, format);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_printf_obj, 3, mp_g_string_printf, g_string_printf);

 

/*
 * dbus extension definition for:
 * extern void g_string_append_vprintf(GString *string, const gchar *format, va_list args)
 */
 
STATIC mp_obj_t mp_g_string_append_vprintf(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[1]);
    va_list args = mp_to_ptr(mp_args[2]);
    g_string_append_vprintf(string, format, args);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_append_vprintf_obj, 3, mp_g_string_append_vprintf, g_string_append_vprintf);

 

/*
 * dbus extension definition for:
 * extern void g_string_append_printf(GString *string, const gchar *format, ...)
 */
 
STATIC mp_obj_t mp_g_string_append_printf(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[1]);
    g_string_append_printf(string, format);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_append_printf_obj, 3, mp_g_string_append_printf, g_string_append_printf);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_append_uri_escaped(GString *string, const gchar *unescaped, const gchar *reserved_chars_allowed, gboolean allow_utf8)
 */
 
STATIC mp_obj_t mp_g_string_append_uri_escaped(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    const gchar *unescaped = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *reserved_chars_allowed = (char*)mp_obj_str_get_str(mp_args[2]);
    gboolean allow_utf8 = (int)mp_obj_get_int(mp_args[3]);
    GString * res = g_string_append_uri_escaped(string, unescaped, reserved_chars_allowed, allow_utf8);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_append_uri_escaped_obj, 4, mp_g_string_append_uri_escaped, g_string_append_uri_escaped);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_down(GString *string)
 */
 
STATIC mp_obj_t mp_g_string_down(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    GString * res = g_string_down(string);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_down_obj, 1, mp_g_string_down, g_string_down);

 

/*
 * dbus extension definition for:
 * extern GString *g_string_up(GString *string)
 */
 
STATIC mp_obj_t mp_g_string_up(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GString *string = mp_to_ptr(mp_args[0]);
    GString * res = g_string_up(string);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_string_up_obj, 1, mp_g_string_up, g_string_up);

 

/*
 * dbus extension definition for:
 * extern void g_io_channel_init(GIOChannel *channel)
 */
 
STATIC mp_obj_t mp_g_io_channel_init(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    g_io_channel_init(channel);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_init_obj, 1, mp_g_io_channel_init, g_io_channel_init);

 

/*
 * dbus extension definition for:
 * extern GIOChannel *g_io_channel_ref(GIOChannel *channel)
 */
 
STATIC mp_obj_t mp_g_io_channel_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    GIOChannel * res = g_io_channel_ref(channel);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_ref_obj, 1, mp_g_io_channel_ref, g_io_channel_ref);

 

/*
 * dbus extension definition for:
 * extern void g_io_channel_unref(GIOChannel *channel)
 */
 
STATIC mp_obj_t mp_g_io_channel_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    g_io_channel_unref(channel);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_unref_obj, 1, mp_g_io_channel_unref, g_io_channel_unref);

 

/*
 * dbus extension definition for:
 * extern GIOError g_io_channel_read(GIOChannel *channel, gchar *buf, gsize count, gsize *bytes_read)
 */
 
STATIC mp_obj_t mp_g_io_channel_read(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gchar *buf = (char*)mp_obj_str_get_str(mp_args[1]);
    gsize count = (unsigned long)mp_obj_get_int(mp_args[2]);
    gsize *bytes_read = mp_to_ptr(mp_args[3]);
    GIOError res = g_io_channel_read(channel, buf, count, bytes_read);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_read_obj, 4, mp_g_io_channel_read, g_io_channel_read);

 

/*
 * dbus extension definition for:
 * extern GIOError g_io_channel_write(GIOChannel *channel, const gchar *buf, gsize count, gsize *bytes_written)
 */
 
STATIC mp_obj_t mp_g_io_channel_write(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    const gchar *buf = (char*)mp_obj_str_get_str(mp_args[1]);
    gsize count = (unsigned long)mp_obj_get_int(mp_args[2]);
    gsize *bytes_written = mp_to_ptr(mp_args[3]);
    GIOError res = g_io_channel_write(channel, buf, count, bytes_written);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_write_obj, 4, mp_g_io_channel_write, g_io_channel_write);

 

/*
 * Function NOT generated:
 * Missing conversion to gint64
 * extern GIOError g_io_channel_seek(GIOChannel *channel, gint64 offset, GSeekType type)
 */
    

/*
 * dbus extension definition for:
 * extern void g_io_channel_close(GIOChannel *channel)
 */
 
STATIC mp_obj_t mp_g_io_channel_close(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    g_io_channel_close(channel);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_close_obj, 1, mp_g_io_channel_close, g_io_channel_close);

 

/*
 * dbus extension definition for:
 * extern GIOStatus g_io_channel_shutdown(GIOChannel *channel, gboolean flush, GError **err)
 */
 
STATIC mp_obj_t mp_g_io_channel_shutdown(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gboolean flush = (int)mp_obj_get_int(mp_args[1]);
    GError **err = mp_to_ptr(mp_args[2]);
    GIOStatus res = g_io_channel_shutdown(channel, flush, err);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_shutdown_obj, 3, mp_g_io_channel_shutdown, g_io_channel_shutdown);

 

/*
 * Function NOT generated:
 * Callback function 'GIOFunc func' must receive a struct pointer with user_data member as its first argument!
 * GIOFunc func
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify notify' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify notify
 */
    

/*
 * dbus extension definition for:
 * extern guint g_io_add_watch_full(GIOChannel *channel, gint priority, GIOCondition condition, GIOFunc func, gpointer user_data, GDestroyNotify notify)
 */
 
STATIC mp_obj_t mp_g_io_add_watch_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gint priority = (int)mp_obj_get_int(mp_args[1]);
    GIOCondition condition = (int)mp_obj_get_int(mp_args[2]);
    GIOFunc func = mp_to_ptr(mp_args[3]);
    gpointer user_data = mp_to_ptr(mp_args[4]);
    GDestroyNotify notify = mp_to_ptr(mp_args[5]);
    guint res = g_io_add_watch_full(channel, priority, condition, func, user_data, notify);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_add_watch_full_obj, 6, mp_g_io_add_watch_full, g_io_add_watch_full);

 

/*
 * dbus extension definition for:
 * extern GSource *g_io_create_watch(GIOChannel *channel, GIOCondition condition)
 */
 
STATIC mp_obj_t mp_g_io_create_watch(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    GIOCondition condition = (int)mp_obj_get_int(mp_args[1]);
    GSource * res = g_io_create_watch(channel, condition);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_create_watch_obj, 2, mp_g_io_create_watch, g_io_create_watch);

 

/*
 * Function NOT generated:
 * Callback function 'GIOFunc func' must receive a struct pointer with user_data member as its first argument!
 * GIOFunc func
 */
    

/*
 * dbus extension definition for:
 * extern guint g_io_add_watch(GIOChannel *channel, GIOCondition condition, GIOFunc func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_io_add_watch(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    GIOCondition condition = (int)mp_obj_get_int(mp_args[1]);
    GIOFunc func = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    guint res = g_io_add_watch(channel, condition, func, user_data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_add_watch_obj, 4, mp_g_io_add_watch, g_io_add_watch);

 

/*
 * dbus extension definition for:
 * extern void g_io_channel_set_buffer_size(GIOChannel *channel, gsize size)
 */
 
STATIC mp_obj_t mp_g_io_channel_set_buffer_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gsize size = (unsigned long)mp_obj_get_int(mp_args[1]);
    g_io_channel_set_buffer_size(channel, size);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_set_buffer_size_obj, 2, mp_g_io_channel_set_buffer_size, g_io_channel_set_buffer_size);

 

/*
 * dbus extension definition for:
 * extern gsize g_io_channel_get_buffer_size(GIOChannel *channel)
 */
 
STATIC mp_obj_t mp_g_io_channel_get_buffer_size(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gsize res = g_io_channel_get_buffer_size(channel);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_get_buffer_size_obj, 1, mp_g_io_channel_get_buffer_size, g_io_channel_get_buffer_size);

 

/*
 * dbus extension definition for:
 * extern GIOCondition g_io_channel_get_buffer_condition(GIOChannel *channel)
 */
 
STATIC mp_obj_t mp_g_io_channel_get_buffer_condition(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    GIOCondition res = g_io_channel_get_buffer_condition(channel);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_get_buffer_condition_obj, 1, mp_g_io_channel_get_buffer_condition, g_io_channel_get_buffer_condition);

 

/*
 * dbus extension definition for:
 * extern GIOStatus g_io_channel_set_flags(GIOChannel *channel, GIOFlags flags, GError **error)
 */
 
STATIC mp_obj_t mp_g_io_channel_set_flags(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    GIOFlags flags = (int)mp_obj_get_int(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    GIOStatus res = g_io_channel_set_flags(channel, flags, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_set_flags_obj, 3, mp_g_io_channel_set_flags, g_io_channel_set_flags);

 

/*
 * dbus extension definition for:
 * extern GIOFlags g_io_channel_get_flags(GIOChannel *channel)
 */
 
STATIC mp_obj_t mp_g_io_channel_get_flags(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    GIOFlags res = g_io_channel_get_flags(channel);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_get_flags_obj, 1, mp_g_io_channel_get_flags, g_io_channel_get_flags);

 

/*
 * dbus extension definition for:
 * extern void g_io_channel_set_line_term(GIOChannel *channel, const gchar *line_term, gint length)
 */
 
STATIC mp_obj_t mp_g_io_channel_set_line_term(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    const gchar *line_term = (char*)mp_obj_str_get_str(mp_args[1]);
    gint length = (int)mp_obj_get_int(mp_args[2]);
    g_io_channel_set_line_term(channel, line_term, length);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_set_line_term_obj, 3, mp_g_io_channel_set_line_term, g_io_channel_set_line_term);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_io_channel_get_line_term(GIOChannel *channel, gint *length)
 */
    

/*
 * dbus extension definition for:
 * extern void g_io_channel_set_buffered(GIOChannel *channel, gboolean buffered)
 */
 
STATIC mp_obj_t mp_g_io_channel_set_buffered(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gboolean buffered = (int)mp_obj_get_int(mp_args[1]);
    g_io_channel_set_buffered(channel, buffered);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_set_buffered_obj, 2, mp_g_io_channel_set_buffered, g_io_channel_set_buffered);

 

/*
 * dbus extension definition for:
 * extern gboolean g_io_channel_get_buffered(GIOChannel *channel)
 */
 
STATIC mp_obj_t mp_g_io_channel_get_buffered(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gboolean res = g_io_channel_get_buffered(channel);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_get_buffered_obj, 1, mp_g_io_channel_get_buffered, g_io_channel_get_buffered);

 

/*
 * dbus extension definition for:
 * extern GIOStatus g_io_channel_set_encoding(GIOChannel *channel, const gchar *encoding, GError **error)
 */
 
STATIC mp_obj_t mp_g_io_channel_set_encoding(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    const gchar *encoding = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    GIOStatus res = g_io_channel_set_encoding(channel, encoding, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_set_encoding_obj, 3, mp_g_io_channel_set_encoding, g_io_channel_set_encoding);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_io_channel_get_encoding(GIOChannel *channel)
 */
    

/*
 * dbus extension definition for:
 * extern void g_io_channel_set_close_on_unref(GIOChannel *channel, gboolean do_close)
 */
 
STATIC mp_obj_t mp_g_io_channel_set_close_on_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gboolean do_close = (int)mp_obj_get_int(mp_args[1]);
    g_io_channel_set_close_on_unref(channel, do_close);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_set_close_on_unref_obj, 2, mp_g_io_channel_set_close_on_unref, g_io_channel_set_close_on_unref);

 

/*
 * dbus extension definition for:
 * extern gboolean g_io_channel_get_close_on_unref(GIOChannel *channel)
 */
 
STATIC mp_obj_t mp_g_io_channel_get_close_on_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gboolean res = g_io_channel_get_close_on_unref(channel);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_get_close_on_unref_obj, 1, mp_g_io_channel_get_close_on_unref, g_io_channel_get_close_on_unref);

 

/*
 * dbus extension definition for:
 * extern GIOStatus g_io_channel_flush(GIOChannel *channel, GError **error)
 */
 
STATIC mp_obj_t mp_g_io_channel_flush(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    GError **error = mp_to_ptr(mp_args[1]);
    GIOStatus res = g_io_channel_flush(channel, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_flush_obj, 2, mp_g_io_channel_flush, g_io_channel_flush);

 

/*
 * dbus extension definition for:
 * extern GIOStatus g_io_channel_read_line(GIOChannel *channel, gchar **str_return, gsize *length, gsize *terminator_pos, GError **error)
 */
 
STATIC mp_obj_t mp_g_io_channel_read_line(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gchar **str_return = mp_to_ptr(mp_args[1]);
    gsize *length = mp_to_ptr(mp_args[2]);
    gsize *terminator_pos = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    GIOStatus res = g_io_channel_read_line(channel, str_return, length, terminator_pos, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_read_line_obj, 5, mp_g_io_channel_read_line, g_io_channel_read_line);

 

/*
 * dbus extension definition for:
 * extern GIOStatus g_io_channel_read_line_string(GIOChannel *channel, GString *buffer, gsize *terminator_pos, GError **error)
 */
 
STATIC mp_obj_t mp_g_io_channel_read_line_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    GString *buffer = mp_to_ptr(mp_args[1]);
    gsize *terminator_pos = mp_to_ptr(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    GIOStatus res = g_io_channel_read_line_string(channel, buffer, terminator_pos, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_read_line_string_obj, 4, mp_g_io_channel_read_line_string, g_io_channel_read_line_string);

 

/*
 * dbus extension definition for:
 * extern GIOStatus g_io_channel_read_to_end(GIOChannel *channel, gchar **str_return, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_io_channel_read_to_end(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gchar **str_return = mp_to_ptr(mp_args[1]);
    gsize *length = mp_to_ptr(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    GIOStatus res = g_io_channel_read_to_end(channel, str_return, length, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_read_to_end_obj, 4, mp_g_io_channel_read_to_end, g_io_channel_read_to_end);

 

/*
 * dbus extension definition for:
 * extern GIOStatus g_io_channel_read_chars(GIOChannel *channel, gchar *buf, gsize count, gsize *bytes_read, GError **error)
 */
 
STATIC mp_obj_t mp_g_io_channel_read_chars(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gchar *buf = (char*)mp_obj_str_get_str(mp_args[1]);
    gsize count = (unsigned long)mp_obj_get_int(mp_args[2]);
    gsize *bytes_read = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    GIOStatus res = g_io_channel_read_chars(channel, buf, count, bytes_read, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_read_chars_obj, 5, mp_g_io_channel_read_chars, g_io_channel_read_chars);

 

/*
 * dbus extension definition for:
 * extern GIOStatus g_io_channel_read_unichar(GIOChannel *channel, gunichar *thechar, GError **error)
 */
 
STATIC mp_obj_t mp_g_io_channel_read_unichar(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gunichar *thechar = mp_to_ptr(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    GIOStatus res = g_io_channel_read_unichar(channel, thechar, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_read_unichar_obj, 3, mp_g_io_channel_read_unichar, g_io_channel_read_unichar);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern GIOStatus g_io_channel_write_chars(GIOChannel *channel, const gchar *buf, gssize count, gsize *bytes_written, GError **error)
 */
    

/*
 * dbus extension definition for:
 * extern GIOStatus g_io_channel_write_unichar(GIOChannel *channel, gunichar thechar, GError **error)
 */
 
STATIC mp_obj_t mp_g_io_channel_write_unichar(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gunichar thechar = (unsigned int)mp_obj_get_int(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    GIOStatus res = g_io_channel_write_unichar(channel, thechar, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_write_unichar_obj, 3, mp_g_io_channel_write_unichar, g_io_channel_write_unichar);

 

/*
 * Function NOT generated:
 * Missing conversion to gint64
 * extern GIOStatus g_io_channel_seek_position(GIOChannel *channel, gint64 offset, GSeekType type, GError **error)
 */
    

/*
 * dbus extension definition for:
 * extern GIOChannel *g_io_channel_new_file(const gchar *filename, const gchar *mode, GError **error)
 */
 
STATIC mp_obj_t mp_g_io_channel_new_file(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *mode = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    GIOChannel * res = g_io_channel_new_file(filename, mode, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_new_file_obj, 3, mp_g_io_channel_new_file, g_io_channel_new_file);

 

/*
 * dbus extension definition for:
 * extern GQuark g_io_channel_error_quark(void)
 */
 
STATIC mp_obj_t mp_g_io_channel_error_quark(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GQuark res = g_io_channel_error_quark();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_error_quark_obj, 0, mp_g_io_channel_error_quark, g_io_channel_error_quark);

 

/*
 * dbus extension definition for:
 * extern GIOChannelError g_io_channel_error_from_errno(gint en)
 */
 
STATIC mp_obj_t mp_g_io_channel_error_from_errno(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gint en = (int)mp_obj_get_int(mp_args[0]);
    GIOChannelError res = g_io_channel_error_from_errno(en);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_error_from_errno_obj, 1, mp_g_io_channel_error_from_errno, g_io_channel_error_from_errno);

 

/*
 * dbus extension definition for:
 * extern GIOChannel *g_io_channel_unix_new(int fd)
 */
 
STATIC mp_obj_t mp_g_io_channel_unix_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    int fd = (int)mp_obj_get_int(mp_args[0]);
    GIOChannel * res = g_io_channel_unix_new(fd);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_unix_new_obj, 1, mp_g_io_channel_unix_new, g_io_channel_unix_new);

 

/*
 * dbus extension definition for:
 * extern gint g_io_channel_unix_get_fd(GIOChannel *channel)
 */
 
STATIC mp_obj_t mp_g_io_channel_unix_get_fd(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GIOChannel *channel = mp_to_ptr(mp_args[0]);
    gint res = g_io_channel_unix_get_fd(channel);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_io_channel_unix_get_fd_obj, 1, mp_g_io_channel_unix_get_fd, g_io_channel_unix_get_fd);

 

/*
 * dbus extension definition for:
 * extern GQuark g_key_file_error_quark(void)
 */
 
STATIC mp_obj_t mp_g_key_file_error_quark(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GQuark res = g_key_file_error_quark();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_error_quark_obj, 0, mp_g_key_file_error_quark, g_key_file_error_quark);

 

/*
 * dbus extension definition for:
 * extern GKeyFile *g_key_file_new(void)
 */
 
STATIC mp_obj_t mp_g_key_file_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GKeyFile * res = g_key_file_new();
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_new_obj, 0, mp_g_key_file_new, g_key_file_new);

 

/*
 * dbus extension definition for:
 * extern GKeyFile *g_key_file_ref(GKeyFile *key_file)
 */
 
STATIC mp_obj_t mp_g_key_file_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    GKeyFile * res = g_key_file_ref(key_file);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_ref_obj, 1, mp_g_key_file_ref, g_key_file_ref);

 

/*
 * dbus extension definition for:
 * extern void g_key_file_unref(GKeyFile *key_file)
 */
 
STATIC mp_obj_t mp_g_key_file_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    g_key_file_unref(key_file);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_unref_obj, 1, mp_g_key_file_unref, g_key_file_unref);

 

/*
 * dbus extension definition for:
 * extern void g_key_file_free(GKeyFile *key_file)
 */
 
STATIC mp_obj_t mp_g_key_file_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    g_key_file_free(key_file);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_free_obj, 1, mp_g_key_file_free, g_key_file_free);

 

/*
 * dbus extension definition for:
 * extern void g_key_file_set_list_separator(GKeyFile *key_file, gchar separator)
 */
 
STATIC mp_obj_t mp_g_key_file_set_list_separator(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    gchar separator = (char)mp_obj_get_int(mp_args[1]);
    g_key_file_set_list_separator(key_file, separator);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_list_separator_obj, 2, mp_g_key_file_set_list_separator, g_key_file_set_list_separator);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_load_from_file(GKeyFile *key_file, const gchar *file, GKeyFileFlags flags, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_load_from_file(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *file = (char*)mp_obj_str_get_str(mp_args[1]);
    GKeyFileFlags flags = (int)mp_obj_get_int(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_key_file_load_from_file(key_file, file, flags, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_load_from_file_obj, 4, mp_g_key_file_load_from_file, g_key_file_load_from_file);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_load_from_data(GKeyFile *key_file, const gchar *data, gsize length, GKeyFileFlags flags, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_load_from_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *data = (char*)mp_obj_str_get_str(mp_args[1]);
    gsize length = (unsigned long)mp_obj_get_int(mp_args[2]);
    GKeyFileFlags flags = (int)mp_obj_get_int(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gboolean res = g_key_file_load_from_data(key_file, data, length, flags, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_load_from_data_obj, 5, mp_g_key_file_load_from_data, g_key_file_load_from_data);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_load_from_dirs(GKeyFile *key_file, const gchar *file, const gchar **search_dirs, gchar **full_path, GKeyFileFlags flags, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_load_from_dirs(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *file = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar **search_dirs = mp_to_ptr(mp_args[2]);
    gchar **full_path = mp_to_ptr(mp_args[3]);
    GKeyFileFlags flags = (int)mp_obj_get_int(mp_args[4]);
    GError **error = mp_to_ptr(mp_args[5]);
    gboolean res = g_key_file_load_from_dirs(key_file, file, search_dirs, full_path, flags, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_load_from_dirs_obj, 6, mp_g_key_file_load_from_dirs, g_key_file_load_from_dirs);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_load_from_data_dirs(GKeyFile *key_file, const gchar *file, gchar **full_path, GKeyFileFlags flags, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_load_from_data_dirs(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *file = (char*)mp_obj_str_get_str(mp_args[1]);
    gchar **full_path = mp_to_ptr(mp_args[2]);
    GKeyFileFlags flags = (int)mp_obj_get_int(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gboolean res = g_key_file_load_from_data_dirs(key_file, file, full_path, flags, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_load_from_data_dirs_obj, 5, mp_g_key_file_load_from_data_dirs, g_key_file_load_from_data_dirs);

 

/*
 * dbus extension definition for:
 * extern gchar *g_key_file_to_data(GKeyFile *key_file, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_to_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    gsize *length = mp_to_ptr(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gchar * res = g_key_file_to_data(key_file, length, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_to_data_obj, 3, mp_g_key_file_to_data, g_key_file_to_data);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_save_to_file(GKeyFile *key_file, const gchar *filename, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_save_to_file(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gboolean res = g_key_file_save_to_file(key_file, filename, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_save_to_file_obj, 3, mp_g_key_file_save_to_file, g_key_file_save_to_file);

 

/*
 * dbus extension definition for:
 * extern gchar *g_key_file_get_start_group(GKeyFile *key_file)
 */
 
STATIC mp_obj_t mp_g_key_file_get_start_group(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    gchar * res = g_key_file_get_start_group(key_file);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_start_group_obj, 1, mp_g_key_file_get_start_group, g_key_file_get_start_group);

 

/*
 * dbus extension definition for:
 * extern gchar **g_key_file_get_groups(GKeyFile *key_file, gsize *length)
 */
 
STATIC mp_obj_t mp_g_key_file_get_groups(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    gsize *length = mp_to_ptr(mp_args[1]);
    gchar ** res = g_key_file_get_groups(key_file, length);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_groups_obj, 2, mp_g_key_file_get_groups, g_key_file_get_groups);

 

/*
 * dbus extension definition for:
 * extern gchar **g_key_file_get_keys(GKeyFile *key_file, const gchar *group_name, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_keys(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    gsize *length = mp_to_ptr(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gchar ** res = g_key_file_get_keys(key_file, group_name, length, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_keys_obj, 4, mp_g_key_file_get_keys, g_key_file_get_keys);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_has_group(GKeyFile *key_file, const gchar *group_name)
 */
 
STATIC mp_obj_t mp_g_key_file_has_group(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    gboolean res = g_key_file_has_group(key_file, group_name);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_has_group_obj, 2, mp_g_key_file_has_group, g_key_file_has_group);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_has_key(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_has_key(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_key_file_has_key(key_file, group_name, key, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_has_key_obj, 4, mp_g_key_file_has_key, g_key_file_has_key);

 

/*
 * dbus extension definition for:
 * extern gchar *g_key_file_get_value(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_value(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gchar * res = g_key_file_get_value(key_file, group_name, key, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_value_obj, 4, mp_g_key_file_get_value, g_key_file_get_value);

 

/*
 * dbus extension definition for:
 * extern void g_key_file_set_value(GKeyFile *key_file, const gchar *group_name, const gchar *key, const gchar *value)
 */
 
STATIC mp_obj_t mp_g_key_file_set_value(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *value = (char*)mp_obj_str_get_str(mp_args[3]);
    g_key_file_set_value(key_file, group_name, key, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_value_obj, 4, mp_g_key_file_set_value, g_key_file_set_value);

 

/*
 * dbus extension definition for:
 * extern gchar *g_key_file_get_string(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gchar * res = g_key_file_get_string(key_file, group_name, key, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_string_obj, 4, mp_g_key_file_get_string, g_key_file_get_string);

 

/*
 * dbus extension definition for:
 * extern void g_key_file_set_string(GKeyFile *key_file, const gchar *group_name, const gchar *key, const gchar *string)
 */
 
STATIC mp_obj_t mp_g_key_file_set_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *string = (char*)mp_obj_str_get_str(mp_args[3]);
    g_key_file_set_string(key_file, group_name, key, string);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_string_obj, 4, mp_g_key_file_set_string, g_key_file_set_string);

 

/*
 * dbus extension definition for:
 * extern gchar *g_key_file_get_locale_string(GKeyFile *key_file, const gchar *group_name, const gchar *key, const gchar *locale, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_locale_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *locale = (char*)mp_obj_str_get_str(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gchar * res = g_key_file_get_locale_string(key_file, group_name, key, locale, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_locale_string_obj, 5, mp_g_key_file_get_locale_string, g_key_file_get_locale_string);

 

/*
 * dbus extension definition for:
 * extern void g_key_file_set_locale_string(GKeyFile *key_file, const gchar *group_name, const gchar *key, const gchar *locale, const gchar *string)
 */
 
STATIC mp_obj_t mp_g_key_file_set_locale_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *locale = (char*)mp_obj_str_get_str(mp_args[3]);
    const gchar *string = (char*)mp_obj_str_get_str(mp_args[4]);
    g_key_file_set_locale_string(key_file, group_name, key, locale, string);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_locale_string_obj, 5, mp_g_key_file_set_locale_string, g_key_file_set_locale_string);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_get_boolean(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_boolean(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_key_file_get_boolean(key_file, group_name, key, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_boolean_obj, 4, mp_g_key_file_get_boolean, g_key_file_get_boolean);

 

/*
 * dbus extension definition for:
 * extern void g_key_file_set_boolean(GKeyFile *key_file, const gchar *group_name, const gchar *key, gboolean value)
 */
 
STATIC mp_obj_t mp_g_key_file_set_boolean(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    gboolean value = (int)mp_obj_get_int(mp_args[3]);
    g_key_file_set_boolean(key_file, group_name, key, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_boolean_obj, 4, mp_g_key_file_set_boolean, g_key_file_set_boolean);

 

/*
 * dbus extension definition for:
 * extern gint g_key_file_get_integer(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_integer(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gint res = g_key_file_get_integer(key_file, group_name, key, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_integer_obj, 4, mp_g_key_file_get_integer, g_key_file_get_integer);

 

/*
 * dbus extension definition for:
 * extern void g_key_file_set_integer(GKeyFile *key_file, const gchar *group_name, const gchar *key, gint value)
 */
 
STATIC mp_obj_t mp_g_key_file_set_integer(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    gint value = (int)mp_obj_get_int(mp_args[3]);
    g_key_file_set_integer(key_file, group_name, key, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_integer_obj, 4, mp_g_key_file_set_integer, g_key_file_set_integer);

 

/*
 * Function NOT generated:
 * Missing convertion from gint64
 * extern gint64 g_key_file_get_int64(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gint64
 * extern void g_key_file_set_int64(GKeyFile *key_file, const gchar *group_name, const gchar *key, gint64 value)
 */
    

/*
 * dbus extension definition for:
 * extern guint64 g_key_file_get_uint64(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_uint64(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    guint64 res = g_key_file_get_uint64(key_file, group_name, key, error);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_uint64_obj, 4, mp_g_key_file_get_uint64, g_key_file_get_uint64);

 

/*
 * dbus extension definition for:
 * extern void g_key_file_set_uint64(GKeyFile *key_file, const gchar *group_name, const gchar *key, guint64 value)
 */
 
STATIC mp_obj_t mp_g_key_file_set_uint64(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    guint64 value = (unsigned long)mp_obj_get_int(mp_args[3]);
    g_key_file_set_uint64(key_file, group_name, key, value);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_uint64_obj, 4, mp_g_key_file_set_uint64, g_key_file_set_uint64);

 

/*
 * Function NOT generated:
 * Missing convertion from gdouble
 * extern gdouble g_key_file_get_double(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
    

/*
 * Function NOT generated:
 * Missing conversion to gdouble
 * extern void g_key_file_set_double(GKeyFile *key_file, const gchar *group_name, const gchar *key, gdouble value)
 */
    

/*
 * dbus extension definition for:
 * extern gchar **g_key_file_get_string_list(GKeyFile *key_file, const gchar *group_name, const gchar *key, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_string_list(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    gsize *length = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gchar ** res = g_key_file_get_string_list(key_file, group_name, key, length, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_string_list_obj, 5, mp_g_key_file_get_string_list, g_key_file_get_string_list);

 

/*
 * Array convertors for gchar *[]
 */

STATIC const gchar * const *mp_arr_to_gchar_ptr____(mp_obj_t mp_arr)
{
    mp_obj_t mp_len = mp_obj_len_maybe(mp_arr);
    if (mp_len == MP_OBJ_NULL) return mp_to_ptr(mp_arr);
    mp_int_t len = mp_obj_get_int(mp_len);
    
    gchar * *lv_arr = (gchar **)m_malloc(len * sizeof(gchar *));
    mp_obj_t iter = mp_getiter(mp_arr, NULL);
    mp_obj_t item;
    size_t i = 0;
    while ((item = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
        lv_arr[i++] = (char*)mp_obj_str_get_str(item);
    }
    return (const gchar * const *)lv_arr;
}
    
STATIC mp_obj_t mp_arr_from_gchar_ptr____(const gchar * const *arr)
{
    mp_obj_t obj_arr[1];
    for (int i=0; i<1; i++){
        obj_arr[i] = convert_to_str(arr[i]);
    }
    return mp_obj_new_list(1, obj_arr); // TODO: return custom iterable object!
}
    

/*
 * dbus extension definition for:
 * extern void g_key_file_set_string_list(GKeyFile *key_file, const gchar *group_name, const gchar *key, const gchar * const list[], gsize length)
 */
 
STATIC mp_obj_t mp_g_key_file_set_string_list(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar * const *list = mp_arr_to_gchar_ptr____(mp_args[3]);
    gsize length = (unsigned long)mp_obj_get_int(mp_args[4]);
    g_key_file_set_string_list(key_file, group_name, key, list, length);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_string_list_obj, 5, mp_g_key_file_set_string_list, g_key_file_set_string_list);

 

/*
 * dbus extension definition for:
 * extern gchar **g_key_file_get_locale_string_list(GKeyFile *key_file, const gchar *group_name, const gchar *key, const gchar *locale, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_locale_string_list(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *locale = (char*)mp_obj_str_get_str(mp_args[3]);
    gsize *length = mp_to_ptr(mp_args[4]);
    GError **error = mp_to_ptr(mp_args[5]);
    gchar ** res = g_key_file_get_locale_string_list(key_file, group_name, key, locale, length, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_locale_string_list_obj, 6, mp_g_key_file_get_locale_string_list, g_key_file_get_locale_string_list);

 

/*
 * dbus extension definition for:
 * extern void g_key_file_set_locale_string_list(GKeyFile *key_file, const gchar *group_name, const gchar *key, const gchar *locale, const gchar * const list[], gsize length)
 */
 
STATIC mp_obj_t mp_g_key_file_set_locale_string_list(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *locale = (char*)mp_obj_str_get_str(mp_args[3]);
    const gchar * const *list = mp_arr_to_gchar_ptr____(mp_args[4]);
    gsize length = (unsigned long)mp_obj_get_int(mp_args[5]);
    g_key_file_set_locale_string_list(key_file, group_name, key, locale, list, length);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_locale_string_list_obj, 6, mp_g_key_file_set_locale_string_list, g_key_file_set_locale_string_list);

 

/*
 * dbus extension definition for:
 * extern gboolean *g_key_file_get_boolean_list(GKeyFile *key_file, const gchar *group_name, const gchar *key, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_boolean_list(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    gsize *length = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gboolean * res = g_key_file_get_boolean_list(key_file, group_name, key, length, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_boolean_list_obj, 5, mp_g_key_file_get_boolean_list, g_key_file_get_boolean_list);

 

/*
 * Array convertors for gboolean []
 */

STATIC gboolean *mp_arr_to_gboolean_____(mp_obj_t mp_arr)
{
    mp_obj_t mp_len = mp_obj_len_maybe(mp_arr);
    if (mp_len == MP_OBJ_NULL) return mp_to_ptr(mp_arr);
    mp_int_t len = mp_obj_get_int(mp_len);
    
    gboolean *lv_arr = (gboolean*)m_malloc(len * sizeof(gboolean));
    mp_obj_t iter = mp_getiter(mp_arr, NULL);
    mp_obj_t item;
    size_t i = 0;
    while ((item = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
        lv_arr[i++] = (int)mp_obj_get_int(item);
    }
    return (gboolean *)lv_arr;
}
    
STATIC mp_obj_t mp_arr_from_gboolean_____(gboolean *arr)
{
    mp_obj_t obj_arr[1];
    for (int i=0; i<1; i++){
        obj_arr[i] = mp_obj_new_int(arr[i]);
    }
    return mp_obj_new_list(1, obj_arr); // TODO: return custom iterable object!
}
    

/*
 * dbus extension definition for:
 * extern void g_key_file_set_boolean_list(GKeyFile *key_file, const gchar *group_name, const gchar *key, gboolean list[], gsize length)
 */
 
STATIC mp_obj_t mp_g_key_file_set_boolean_list(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    gboolean *list = mp_arr_to_gboolean_____(mp_args[3]);
    gsize length = (unsigned long)mp_obj_get_int(mp_args[4]);
    g_key_file_set_boolean_list(key_file, group_name, key, list, length);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_boolean_list_obj, 5, mp_g_key_file_set_boolean_list, g_key_file_set_boolean_list);

 

/*
 * dbus extension definition for:
 * extern gint *g_key_file_get_integer_list(GKeyFile *key_file, const gchar *group_name, const gchar *key, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_integer_list(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    gsize *length = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gint * res = g_key_file_get_integer_list(key_file, group_name, key, length, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_integer_list_obj, 5, mp_g_key_file_get_integer_list, g_key_file_get_integer_list);

 

/*
 * Function NOT generated:
 * Missing conversion to gdouble while generating array type conversion
 * extern void g_key_file_set_double_list(GKeyFile *key_file, const gchar *group_name, const gchar *key, gdouble list[], gsize length)
 */
    

/*
 * dbus extension definition for:
 * extern gdouble *g_key_file_get_double_list(GKeyFile *key_file, const gchar *group_name, const gchar *key, gsize *length, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_double_list(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    gsize *length = mp_to_ptr(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gdouble * res = g_key_file_get_double_list(key_file, group_name, key, length, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_double_list_obj, 5, mp_g_key_file_get_double_list, g_key_file_get_double_list);

 

/*
 * Array convertors for gint []
 */

STATIC gint *mp_arr_to_gint_____(mp_obj_t mp_arr)
{
    mp_obj_t mp_len = mp_obj_len_maybe(mp_arr);
    if (mp_len == MP_OBJ_NULL) return mp_to_ptr(mp_arr);
    mp_int_t len = mp_obj_get_int(mp_len);
    
    gint *lv_arr = (gint*)m_malloc(len * sizeof(gint));
    mp_obj_t iter = mp_getiter(mp_arr, NULL);
    mp_obj_t item;
    size_t i = 0;
    while ((item = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
        lv_arr[i++] = (int)mp_obj_get_int(item);
    }
    return (gint *)lv_arr;
}
    
STATIC mp_obj_t mp_arr_from_gint_____(gint *arr)
{
    mp_obj_t obj_arr[1];
    for (int i=0; i<1; i++){
        obj_arr[i] = mp_obj_new_int(arr[i]);
    }
    return mp_obj_new_list(1, obj_arr); // TODO: return custom iterable object!
}
    

/*
 * dbus extension definition for:
 * extern void g_key_file_set_integer_list(GKeyFile *key_file, const gchar *group_name, const gchar *key, gint list[], gsize length)
 */
 
STATIC mp_obj_t mp_g_key_file_set_integer_list(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    gint *list = mp_arr_to_gint_____(mp_args[3]);
    gsize length = (unsigned long)mp_obj_get_int(mp_args[4]);
    g_key_file_set_integer_list(key_file, group_name, key, list, length);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_integer_list_obj, 5, mp_g_key_file_set_integer_list, g_key_file_set_integer_list);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_set_comment(GKeyFile *key_file, const gchar *group_name, const gchar *key, const gchar *comment, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_set_comment(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *comment = (char*)mp_obj_str_get_str(mp_args[3]);
    GError **error = mp_to_ptr(mp_args[4]);
    gboolean res = g_key_file_set_comment(key_file, group_name, key, comment, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_set_comment_obj, 5, mp_g_key_file_set_comment, g_key_file_set_comment);

 

/*
 * dbus extension definition for:
 * extern gchar *g_key_file_get_comment(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_get_comment(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gchar * res = g_key_file_get_comment(key_file, group_name, key, error);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_get_comment_obj, 4, mp_g_key_file_get_comment, g_key_file_get_comment);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_remove_comment(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_remove_comment(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_key_file_remove_comment(key_file, group_name, key, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_remove_comment_obj, 4, mp_g_key_file_remove_comment, g_key_file_remove_comment);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_remove_key(GKeyFile *key_file, const gchar *group_name, const gchar *key, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_remove_key(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *key = (char*)mp_obj_str_get_str(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_key_file_remove_key(key_file, group_name, key, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_remove_key_obj, 4, mp_g_key_file_remove_key, g_key_file_remove_key);

 

/*
 * dbus extension definition for:
 * extern gboolean g_key_file_remove_group(GKeyFile *key_file, const gchar *group_name, GError **error)
 */
 
STATIC mp_obj_t mp_g_key_file_remove_group(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GKeyFile *key_file = mp_to_ptr(mp_args[0]);
    const gchar *group_name = (char*)mp_obj_str_get_str(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gboolean res = g_key_file_remove_group(key_file, group_name, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_key_file_remove_group_obj, 3, mp_g_key_file_remove_group, g_key_file_remove_group);

 

/*
 * dbus extension definition for:
 * extern GMappedFile *g_mapped_file_new(const gchar *filename, gboolean writable, GError **error)
 */
 
STATIC mp_obj_t mp_g_mapped_file_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *filename = (char*)mp_obj_str_get_str(mp_args[0]);
    gboolean writable = (int)mp_obj_get_int(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    GMappedFile * res = g_mapped_file_new(filename, writable, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mapped_file_new_obj, 3, mp_g_mapped_file_new, g_mapped_file_new);

 

/*
 * dbus extension definition for:
 * extern GMappedFile *g_mapped_file_new_from_fd(gint fd, gboolean writable, GError **error)
 */
 
STATIC mp_obj_t mp_g_mapped_file_new_from_fd(size_t mp_n_args, const mp_obj_t *mp_args)
{
    gint fd = (int)mp_obj_get_int(mp_args[0]);
    gboolean writable = (int)mp_obj_get_int(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    GMappedFile * res = g_mapped_file_new_from_fd(fd, writable, error);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mapped_file_new_from_fd_obj, 3, mp_g_mapped_file_new_from_fd, g_mapped_file_new_from_fd);

 

/*
 * dbus extension definition for:
 * extern gsize g_mapped_file_get_length(GMappedFile *file)
 */
 
STATIC mp_obj_t mp_g_mapped_file_get_length(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMappedFile *file = mp_to_ptr(mp_args[0]);
    gsize res = g_mapped_file_get_length(file);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mapped_file_get_length_obj, 1, mp_g_mapped_file_get_length, g_mapped_file_get_length);

 

/*
 * dbus extension definition for:
 * extern gchar *g_mapped_file_get_contents(GMappedFile *file)
 */
 
STATIC mp_obj_t mp_g_mapped_file_get_contents(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMappedFile *file = mp_to_ptr(mp_args[0]);
    gchar * res = g_mapped_file_get_contents(file);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mapped_file_get_contents_obj, 1, mp_g_mapped_file_get_contents, g_mapped_file_get_contents);

 

/*
 * dbus extension definition for:
 * extern GBytes *g_mapped_file_get_bytes(GMappedFile *file)
 */
 
STATIC mp_obj_t mp_g_mapped_file_get_bytes(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMappedFile *file = mp_to_ptr(mp_args[0]);
    GBytes * res = g_mapped_file_get_bytes(file);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mapped_file_get_bytes_obj, 1, mp_g_mapped_file_get_bytes, g_mapped_file_get_bytes);

 

/*
 * dbus extension definition for:
 * extern GMappedFile *g_mapped_file_ref(GMappedFile *file)
 */
 
STATIC mp_obj_t mp_g_mapped_file_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMappedFile *file = mp_to_ptr(mp_args[0]);
    GMappedFile * res = g_mapped_file_ref(file);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mapped_file_ref_obj, 1, mp_g_mapped_file_ref, g_mapped_file_ref);

 

/*
 * dbus extension definition for:
 * extern void g_mapped_file_unref(GMappedFile *file)
 */
 
STATIC mp_obj_t mp_g_mapped_file_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMappedFile *file = mp_to_ptr(mp_args[0]);
    g_mapped_file_unref(file);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mapped_file_unref_obj, 1, mp_g_mapped_file_unref, g_mapped_file_unref);

 

/*
 * dbus extension definition for:
 * extern void g_mapped_file_free(GMappedFile *file)
 */
 
STATIC mp_obj_t mp_g_mapped_file_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMappedFile *file = mp_to_ptr(mp_args[0]);
    g_mapped_file_free(file);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_mapped_file_free_obj, 1, mp_g_mapped_file_free, g_mapped_file_free);

 

/*
 * dbus extension definition for:
 * extern GQuark g_markup_error_quark(void)
 */
 
STATIC mp_obj_t mp_g_markup_error_quark(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GQuark res = g_markup_error_quark();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_error_quark_obj, 0, mp_g_markup_error_quark, g_markup_error_quark);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify user_data_dnotify' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify user_data_dnotify
 */
    

/*
 * dbus extension definition for:
 * extern GMarkupParseContext *g_markup_parse_context_new(const GMarkupParser *parser, GMarkupParseFlags flags, gpointer user_data, GDestroyNotify user_data_dnotify)
 */
 
STATIC mp_obj_t mp_g_markup_parse_context_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const GMarkupParser *parser = mp_to_ptr(mp_args[0]);
    GMarkupParseFlags flags = (int)mp_obj_get_int(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    GDestroyNotify user_data_dnotify = mp_to_ptr(mp_args[3]);
    GMarkupParseContext * res = g_markup_parse_context_new(parser, flags, user_data, user_data_dnotify);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_parse_context_new_obj, 4, mp_g_markup_parse_context_new, g_markup_parse_context_new);

 

/*
 * dbus extension definition for:
 * extern GMarkupParseContext *g_markup_parse_context_ref(GMarkupParseContext *context)
 */
 
STATIC mp_obj_t mp_g_markup_parse_context_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMarkupParseContext *context = mp_to_ptr(mp_args[0]);
    GMarkupParseContext * res = g_markup_parse_context_ref(context);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_parse_context_ref_obj, 1, mp_g_markup_parse_context_ref, g_markup_parse_context_ref);

 

/*
 * dbus extension definition for:
 * extern void g_markup_parse_context_unref(GMarkupParseContext *context)
 */
 
STATIC mp_obj_t mp_g_markup_parse_context_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMarkupParseContext *context = mp_to_ptr(mp_args[0]);
    g_markup_parse_context_unref(context);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_parse_context_unref_obj, 1, mp_g_markup_parse_context_unref, g_markup_parse_context_unref);

 

/*
 * dbus extension definition for:
 * extern void g_markup_parse_context_free(GMarkupParseContext *context)
 */
 
STATIC mp_obj_t mp_g_markup_parse_context_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMarkupParseContext *context = mp_to_ptr(mp_args[0]);
    g_markup_parse_context_free(context);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_parse_context_free_obj, 1, mp_g_markup_parse_context_free, g_markup_parse_context_free);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gboolean g_markup_parse_context_parse(GMarkupParseContext *context, const gchar *text, gssize text_len, GError **error)
 */
    

/*
 * dbus extension definition for:
 * extern void g_markup_parse_context_push(GMarkupParseContext *context, const GMarkupParser *parser, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_markup_parse_context_push(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMarkupParseContext *context = mp_to_ptr(mp_args[0]);
    const GMarkupParser *parser = mp_to_ptr(mp_args[1]);
    gpointer user_data = mp_to_ptr(mp_args[2]);
    g_markup_parse_context_push(context, parser, user_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_parse_context_push_obj, 3, mp_g_markup_parse_context_push, g_markup_parse_context_push);

 

/*
 * dbus extension definition for:
 * extern gpointer g_markup_parse_context_pop(GMarkupParseContext *context)
 */
 
STATIC mp_obj_t mp_g_markup_parse_context_pop(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMarkupParseContext *context = mp_to_ptr(mp_args[0]);
    gpointer res = g_markup_parse_context_pop(context);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_parse_context_pop_obj, 1, mp_g_markup_parse_context_pop, g_markup_parse_context_pop);

 

/*
 * dbus extension definition for:
 * extern gboolean g_markup_parse_context_end_parse(GMarkupParseContext *context, GError **error)
 */
 
STATIC mp_obj_t mp_g_markup_parse_context_end_parse(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMarkupParseContext *context = mp_to_ptr(mp_args[0]);
    GError **error = mp_to_ptr(mp_args[1]);
    gboolean res = g_markup_parse_context_end_parse(context, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_parse_context_end_parse_obj, 2, mp_g_markup_parse_context_end_parse, g_markup_parse_context_end_parse);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_markup_parse_context_get_element(GMarkupParseContext *context)
 */
    

/*
 * Function NOT generated:
 * Missing convertion from const GSList *
 * extern const GSList *g_markup_parse_context_get_element_stack(GMarkupParseContext *context)
 */
    

/*
 * dbus extension definition for:
 * extern void g_markup_parse_context_get_position(GMarkupParseContext *context, gint *line_number, gint *char_number)
 */
 
STATIC mp_obj_t mp_g_markup_parse_context_get_position(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMarkupParseContext *context = mp_to_ptr(mp_args[0]);
    gint *line_number = mp_to_ptr(mp_args[1]);
    gint *char_number = mp_to_ptr(mp_args[2]);
    g_markup_parse_context_get_position(context, line_number, char_number);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_parse_context_get_position_obj, 3, mp_g_markup_parse_context_get_position, g_markup_parse_context_get_position);

 

/*
 * dbus extension definition for:
 * extern gpointer g_markup_parse_context_get_user_data(GMarkupParseContext *context)
 */
 
STATIC mp_obj_t mp_g_markup_parse_context_get_user_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GMarkupParseContext *context = mp_to_ptr(mp_args[0]);
    gpointer res = g_markup_parse_context_get_user_data(context);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_parse_context_get_user_data_obj, 1, mp_g_markup_parse_context_get_user_data, g_markup_parse_context_get_user_data);

 

/*
 * Function NOT generated:
 * Missing conversion to gssize
 * extern gchar *g_markup_escape_text(const gchar *text, gssize length)
 */
    

/*
 * dbus extension definition for:
 * extern gchar *g_markup_printf_escaped(const char *format, ...)
 */
 
STATIC mp_obj_t mp_g_markup_printf_escaped(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *format = (char*)mp_obj_str_get_str(mp_args[0]);
    gchar * res = g_markup_printf_escaped(format);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_printf_escaped_obj, 2, mp_g_markup_printf_escaped, g_markup_printf_escaped);

 

/*
 * dbus extension definition for:
 * extern gchar *g_markup_vprintf_escaped(const char *format, va_list args)
 */
 
STATIC mp_obj_t mp_g_markup_vprintf_escaped(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *format = (char*)mp_obj_str_get_str(mp_args[0]);
    va_list args = mp_to_ptr(mp_args[1]);
    gchar * res = g_markup_vprintf_escaped(format, args);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_vprintf_escaped_obj, 2, mp_g_markup_vprintf_escaped, g_markup_vprintf_escaped);

 

/*
 * dbus extension definition for:
 * extern gboolean g_markup_collect_attributes(const gchar *element_name, const gchar **attribute_names, const gchar **attribute_values, GError **error, GMarkupCollectType first_type, const gchar *first_attr, ...)
 */
 
STATIC mp_obj_t mp_g_markup_collect_attributes(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *element_name = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar **attribute_names = mp_to_ptr(mp_args[1]);
    const gchar **attribute_values = mp_to_ptr(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    GMarkupCollectType first_type = (int)mp_obj_get_int(mp_args[4]);
    const gchar *first_attr = (char*)mp_obj_str_get_str(mp_args[5]);
    gboolean res = g_markup_collect_attributes(element_name, attribute_names, attribute_values, error, first_type, first_attr);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_markup_collect_attributes_obj, 7, mp_g_markup_collect_attributes, g_markup_collect_attributes);

 

/*
 * dbus extension definition for:
 * extern gsize g_printf_string_upper_bound(const gchar *format, va_list args)
 */
 
STATIC mp_obj_t mp_g_printf_string_upper_bound(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[0]);
    va_list args = mp_to_ptr(mp_args[1]);
    gsize res = g_printf_string_upper_bound(format, args);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_printf_string_upper_bound_obj, 2, mp_g_printf_string_upper_bound, g_printf_string_upper_bound);

 

/*
 * Function NOT generated:
 * Callback function 'GLogFunc log_func' must receive a struct pointer with user_data member as its first argument!
 * GLogFunc log_func
 */
    

/*
 * dbus extension definition for:
 * extern guint g_log_set_handler(const gchar *log_domain, GLogLevelFlags log_levels, GLogFunc log_func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_log_set_handler(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *log_domain = (char*)mp_obj_str_get_str(mp_args[0]);
    GLogLevelFlags log_levels = (int)mp_obj_get_int(mp_args[1]);
    GLogFunc log_func = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    guint res = g_log_set_handler(log_domain, log_levels, log_func, user_data);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_log_set_handler_obj, 4, mp_g_log_set_handler, g_log_set_handler);

 

/*
 * Function NOT generated:
 * Callback function 'GLogFunc log_func' must receive a struct pointer with user_data member as its first argument!
 * GLogFunc log_func
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify destroy' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify destroy
 */
    

/*
 * dbus extension definition for:
 * extern guint g_log_set_handler_full(const gchar *log_domain, GLogLevelFlags log_levels, GLogFunc log_func, gpointer user_data, GDestroyNotify destroy)
 */
 
STATIC mp_obj_t mp_g_log_set_handler_full(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *log_domain = (char*)mp_obj_str_get_str(mp_args[0]);
    GLogLevelFlags log_levels = (int)mp_obj_get_int(mp_args[1]);
    GLogFunc log_func = mp_to_ptr(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    GDestroyNotify destroy = mp_to_ptr(mp_args[4]);
    guint res = g_log_set_handler_full(log_domain, log_levels, log_func, user_data, destroy);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_log_set_handler_full_obj, 5, mp_g_log_set_handler_full, g_log_set_handler_full);

 

/*
 * dbus extension definition for:
 * extern void g_log_remove_handler(const gchar *log_domain, guint handler_id)
 */
 
STATIC mp_obj_t mp_g_log_remove_handler(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *log_domain = (char*)mp_obj_str_get_str(mp_args[0]);
    guint handler_id = (unsigned int)mp_obj_get_int(mp_args[1]);
    g_log_remove_handler(log_domain, handler_id);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_log_remove_handler_obj, 2, mp_g_log_remove_handler, g_log_remove_handler);

 

/*
 * dbus extension definition for:
 * extern void g_log_default_handler(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 */
 
STATIC mp_obj_t mp_g_log_default_handler(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *log_domain = (char*)mp_obj_str_get_str(mp_args[0]);
    GLogLevelFlags log_level = (int)mp_obj_get_int(mp_args[1]);
    const gchar *message = (char*)mp_obj_str_get_str(mp_args[2]);
    gpointer unused_data = mp_to_ptr(mp_args[3]);
    g_log_default_handler(log_domain, log_level, message, unused_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_log_default_handler_obj, 4, mp_g_log_default_handler, g_log_default_handler);

 

/*
 * Function NOT generated:
 * Callback argument 'GLogFunc log_func' cannot be the first argument! We assume the first argument contains the user_data
 * GLogFunc log_func
 */
    

/*
 * dbus extension definition for:
 * extern GLogFunc g_log_set_default_handler(GLogFunc log_func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_log_set_default_handler(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GLogFunc log_func = mp_to_ptr(mp_args[0]);
    gpointer user_data = mp_to_ptr(mp_args[1]);
    GLogFunc res = g_log_set_default_handler(log_func, user_data);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_log_set_default_handler_obj, 2, mp_g_log_set_default_handler, g_log_set_default_handler);

 

/*
 * dbus extension definition for:
 * extern void g_log(const gchar *log_domain, GLogLevelFlags log_level, const gchar *format, ...)
 */
 
STATIC mp_obj_t mp_g_log(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *log_domain = (char*)mp_obj_str_get_str(mp_args[0]);
    GLogLevelFlags log_level = (int)mp_obj_get_int(mp_args[1]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[2]);
    g_log(log_domain, log_level, format);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_log_obj, 4, mp_g_log, g_log);

 

/*
 * dbus extension definition for:
 * extern void g_logv(const gchar *log_domain, GLogLevelFlags log_level, const gchar *format, va_list args)
 */
 
STATIC mp_obj_t mp_g_logv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *log_domain = (char*)mp_obj_str_get_str(mp_args[0]);
    GLogLevelFlags log_level = (int)mp_obj_get_int(mp_args[1]);
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[2]);
    va_list args = mp_to_ptr(mp_args[3]);
    g_logv(log_domain, log_level, format, args);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_logv_obj, 4, mp_g_logv, g_logv);

 

/*
 * dbus extension definition for:
 * extern GLogLevelFlags g_log_set_fatal_mask(const gchar *log_domain, GLogLevelFlags fatal_mask)
 */
 
STATIC mp_obj_t mp_g_log_set_fatal_mask(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *log_domain = (char*)mp_obj_str_get_str(mp_args[0]);
    GLogLevelFlags fatal_mask = (int)mp_obj_get_int(mp_args[1]);
    GLogLevelFlags res = g_log_set_fatal_mask(log_domain, fatal_mask);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_log_set_fatal_mask_obj, 2, mp_g_log_set_fatal_mask, g_log_set_fatal_mask);

 

/*
 * dbus extension definition for:
 * extern GLogLevelFlags g_log_set_always_fatal(GLogLevelFlags fatal_mask)
 */
 
STATIC mp_obj_t mp_g_log_set_always_fatal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GLogLevelFlags fatal_mask = (int)mp_obj_get_int(mp_args[0]);
    GLogLevelFlags res = g_log_set_always_fatal(fatal_mask);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_log_set_always_fatal_obj, 1, mp_g_log_set_always_fatal, g_log_set_always_fatal);

 

/*
 * dbus extension definition for:
 * void _g_log_fallback_handler(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 */
 
STATIC mp_obj_t mp__g_log_fallback_handler(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *log_domain = (char*)mp_obj_str_get_str(mp_args[0]);
    GLogLevelFlags log_level = (int)mp_obj_get_int(mp_args[1]);
    const gchar *message = (char*)mp_obj_str_get_str(mp_args[2]);
    gpointer unused_data = mp_to_ptr(mp_args[3]);
    _g_log_fallback_handler(log_domain, log_level, message, unused_data);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp__g_log_fallback_handler_obj, 4, mp__g_log_fallback_handler, _g_log_fallback_handler);

 

/*
 * dbus extension definition for:
 * extern void g_return_if_fail_warning(const char *log_domain, const char *pretty_function, const char *expression)
 */
 
STATIC mp_obj_t mp_g_return_if_fail_warning(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *log_domain = (char*)mp_obj_str_get_str(mp_args[0]);
    const char *pretty_function = (char*)mp_obj_str_get_str(mp_args[1]);
    const char *expression = (char*)mp_obj_str_get_str(mp_args[2]);
    g_return_if_fail_warning(log_domain, pretty_function, expression);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_return_if_fail_warning_obj, 3, mp_g_return_if_fail_warning, g_return_if_fail_warning);

 

/*
 * dbus extension definition for:
 * extern void g_warn_message(const char *domain, const char *file, int line, const char *func, const char *warnexpr)
 */
 
STATIC mp_obj_t mp_g_warn_message(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *domain = (char*)mp_obj_str_get_str(mp_args[0]);
    const char *file = (char*)mp_obj_str_get_str(mp_args[1]);
    int line = (int)mp_obj_get_int(mp_args[2]);
    const char *func = (char*)mp_obj_str_get_str(mp_args[3]);
    const char *warnexpr = (char*)mp_obj_str_get_str(mp_args[4]);
    g_warn_message(domain, file, line, func, warnexpr);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_warn_message_obj, 5, mp_g_warn_message, g_warn_message);

 

/*
 * dbus extension definition for:
 * extern void g_assert_warning(const char *log_domain, const char *file, const int line, const char *pretty_function, const char *expression)
 */
 
STATIC mp_obj_t mp_g_assert_warning(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const char *log_domain = (char*)mp_obj_str_get_str(mp_args[0]);
    const char *file = (char*)mp_obj_str_get_str(mp_args[1]);
    const int line = (int)mp_obj_get_int(mp_args[2]);
    const char *pretty_function = (char*)mp_obj_str_get_str(mp_args[3]);
    const char *expression = (char*)mp_obj_str_get_str(mp_args[4]);
    g_assert_warning(log_domain, file, line, pretty_function, expression);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_assert_warning_obj, 5, mp_g_assert_warning, g_assert_warning);

 

/*
 * dbus extension definition for:
 * extern void g_print(const gchar *format, ...)
 */
 
STATIC mp_obj_t mp_g_print(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[0]);
    g_print(format);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_print_obj, 2, mp_g_print, g_print);

 

/*
 * Function NOT generated:
 * Callback argument 'GPrintFunc func' cannot be the first argument! We assume the first argument contains the user_data
 * GPrintFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GPrintFunc g_set_print_handler(GPrintFunc func)
 */
 
STATIC mp_obj_t mp_g_set_print_handler(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPrintFunc func = mp_to_ptr(mp_args[0]);
    GPrintFunc res = g_set_print_handler(func);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_set_print_handler_obj, 1, mp_g_set_print_handler, g_set_print_handler);

 

/*
 * dbus extension definition for:
 * extern void g_printerr(const gchar *format, ...)
 */
 
STATIC mp_obj_t mp_g_printerr(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *format = (char*)mp_obj_str_get_str(mp_args[0]);
    g_printerr(format);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_printerr_obj, 2, mp_g_printerr, g_printerr);

 

/*
 * Function NOT generated:
 * Callback argument 'GPrintFunc func' cannot be the first argument! We assume the first argument contains the user_data
 * GPrintFunc func
 */
    

/*
 * dbus extension definition for:
 * extern GPrintFunc g_set_printerr_handler(GPrintFunc func)
 */
 
STATIC mp_obj_t mp_g_set_printerr_handler(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPrintFunc func = mp_to_ptr(mp_args[0]);
    GPrintFunc res = g_set_printerr_handler(func);
    return ptr_to_mp(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_set_printerr_handler_obj, 1, mp_g_set_printerr_handler, g_set_printerr_handler);

 

/*
 * dbus extension definition for:
 * extern GQuark g_option_error_quark(void)
 */
 
STATIC mp_obj_t mp_g_option_error_quark(size_t mp_n_args, const mp_obj_t *mp_args)
{
    
    GQuark res = g_option_error_quark();
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_error_quark_obj, 0, mp_g_option_error_quark, g_option_error_quark);

 

/*
 * dbus extension definition for:
 * extern GOptionContext *g_option_context_new(const gchar *parameter_string)
 */
 
STATIC mp_obj_t mp_g_option_context_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *parameter_string = (char*)mp_obj_str_get_str(mp_args[0]);
    GOptionContext * res = g_option_context_new(parameter_string);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_new_obj, 1, mp_g_option_context_new, g_option_context_new);

 

/*
 * dbus extension definition for:
 * extern void g_option_context_set_summary(GOptionContext *context, const gchar *summary)
 */
 
STATIC mp_obj_t mp_g_option_context_set_summary(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    const gchar *summary = (char*)mp_obj_str_get_str(mp_args[1]);
    g_option_context_set_summary(context, summary);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_set_summary_obj, 2, mp_g_option_context_set_summary, g_option_context_set_summary);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_option_context_get_summary(GOptionContext *context)
 */
    

/*
 * dbus extension definition for:
 * extern void g_option_context_set_description(GOptionContext *context, const gchar *description)
 */
 
STATIC mp_obj_t mp_g_option_context_set_description(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    const gchar *description = (char*)mp_obj_str_get_str(mp_args[1]);
    g_option_context_set_description(context, description);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_set_description_obj, 2, mp_g_option_context_set_description, g_option_context_set_description);

 

/*
 * Function NOT generated:
 * Missing convertion from const gchar *
 * extern const gchar *g_option_context_get_description(GOptionContext *context)
 */
    

/*
 * dbus extension definition for:
 * extern void g_option_context_free(GOptionContext *context)
 */
 
STATIC mp_obj_t mp_g_option_context_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    g_option_context_free(context);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_free_obj, 1, mp_g_option_context_free, g_option_context_free);

 

/*
 * dbus extension definition for:
 * extern void g_option_context_set_help_enabled(GOptionContext *context, gboolean help_enabled)
 */
 
STATIC mp_obj_t mp_g_option_context_set_help_enabled(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    gboolean help_enabled = (int)mp_obj_get_int(mp_args[1]);
    g_option_context_set_help_enabled(context, help_enabled);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_set_help_enabled_obj, 2, mp_g_option_context_set_help_enabled, g_option_context_set_help_enabled);

 

/*
 * dbus extension definition for:
 * extern gboolean g_option_context_get_help_enabled(GOptionContext *context)
 */
 
STATIC mp_obj_t mp_g_option_context_get_help_enabled(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    gboolean res = g_option_context_get_help_enabled(context);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_get_help_enabled_obj, 1, mp_g_option_context_get_help_enabled, g_option_context_get_help_enabled);

 

/*
 * dbus extension definition for:
 * extern void g_option_context_set_ignore_unknown_options(GOptionContext *context, gboolean ignore_unknown)
 */
 
STATIC mp_obj_t mp_g_option_context_set_ignore_unknown_options(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    gboolean ignore_unknown = (int)mp_obj_get_int(mp_args[1]);
    g_option_context_set_ignore_unknown_options(context, ignore_unknown);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_set_ignore_unknown_options_obj, 2, mp_g_option_context_set_ignore_unknown_options, g_option_context_set_ignore_unknown_options);

 

/*
 * dbus extension definition for:
 * extern gboolean g_option_context_get_ignore_unknown_options(GOptionContext *context)
 */
 
STATIC mp_obj_t mp_g_option_context_get_ignore_unknown_options(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    gboolean res = g_option_context_get_ignore_unknown_options(context);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_get_ignore_unknown_options_obj, 1, mp_g_option_context_get_ignore_unknown_options, g_option_context_get_ignore_unknown_options);

 

/*
 * dbus extension definition for:
 * extern void g_option_context_set_strict_posix(GOptionContext *context, gboolean strict_posix)
 */
 
STATIC mp_obj_t mp_g_option_context_set_strict_posix(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    gboolean strict_posix = (int)mp_obj_get_int(mp_args[1]);
    g_option_context_set_strict_posix(context, strict_posix);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_set_strict_posix_obj, 2, mp_g_option_context_set_strict_posix, g_option_context_set_strict_posix);

 

/*
 * dbus extension definition for:
 * extern gboolean g_option_context_get_strict_posix(GOptionContext *context)
 */
 
STATIC mp_obj_t mp_g_option_context_get_strict_posix(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    gboolean res = g_option_context_get_strict_posix(context);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_get_strict_posix_obj, 1, mp_g_option_context_get_strict_posix, g_option_context_get_strict_posix);

 

/*
 * dbus extension definition for:
 * extern void g_option_context_add_main_entries(GOptionContext *context, const GOptionEntry *entries, const gchar *translation_domain)
 */
 
STATIC mp_obj_t mp_g_option_context_add_main_entries(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    const GOptionEntry *entries = mp_to_ptr(mp_args[1]);
    const gchar *translation_domain = (char*)mp_obj_str_get_str(mp_args[2]);
    g_option_context_add_main_entries(context, entries, translation_domain);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_add_main_entries_obj, 3, mp_g_option_context_add_main_entries, g_option_context_add_main_entries);

 

/*
 * dbus extension definition for:
 * extern gboolean g_option_context_parse(GOptionContext *context, gint *argc, gchar ***argv, GError **error)
 */
 
STATIC mp_obj_t mp_g_option_context_parse(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    gint *argc = mp_to_ptr(mp_args[1]);
    gchar ***argv = mp_to_ptr(mp_args[2]);
    GError **error = mp_to_ptr(mp_args[3]);
    gboolean res = g_option_context_parse(context, argc, argv, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_parse_obj, 4, mp_g_option_context_parse, g_option_context_parse);

 

/*
 * dbus extension definition for:
 * extern gboolean g_option_context_parse_strv(GOptionContext *context, gchar ***arguments, GError **error)
 */
 
STATIC mp_obj_t mp_g_option_context_parse_strv(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    gchar ***arguments = mp_to_ptr(mp_args[1]);
    GError **error = mp_to_ptr(mp_args[2]);
    gboolean res = g_option_context_parse_strv(context, arguments, error);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_parse_strv_obj, 3, mp_g_option_context_parse_strv, g_option_context_parse_strv);

 

/*
 * Function NOT generated:
 * Callback function 'GTranslateFunc func' must receive a struct pointer with user_data member as its first argument!
 * GTranslateFunc func
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify destroy_notify' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify destroy_notify
 */
    

/*
 * dbus extension definition for:
 * extern void g_option_context_set_translate_func(GOptionContext *context, GTranslateFunc func, gpointer data, GDestroyNotify destroy_notify)
 */
 
STATIC mp_obj_t mp_g_option_context_set_translate_func(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    GTranslateFunc func = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GDestroyNotify destroy_notify = mp_to_ptr(mp_args[3]);
    g_option_context_set_translate_func(context, func, data, destroy_notify);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_set_translate_func_obj, 4, mp_g_option_context_set_translate_func, g_option_context_set_translate_func);

 

/*
 * dbus extension definition for:
 * extern void g_option_context_set_translation_domain(GOptionContext *context, const gchar *domain)
 */
 
STATIC mp_obj_t mp_g_option_context_set_translation_domain(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    const gchar *domain = (char*)mp_obj_str_get_str(mp_args[1]);
    g_option_context_set_translation_domain(context, domain);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_set_translation_domain_obj, 2, mp_g_option_context_set_translation_domain, g_option_context_set_translation_domain);

 

/*
 * dbus extension definition for:
 * extern void g_option_context_add_group(GOptionContext *context, GOptionGroup *group)
 */
 
STATIC mp_obj_t mp_g_option_context_add_group(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    GOptionGroup *group = mp_to_ptr(mp_args[1]);
    g_option_context_add_group(context, group);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_add_group_obj, 2, mp_g_option_context_add_group, g_option_context_add_group);

 

/*
 * dbus extension definition for:
 * extern void g_option_context_set_main_group(GOptionContext *context, GOptionGroup *group)
 */
 
STATIC mp_obj_t mp_g_option_context_set_main_group(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    GOptionGroup *group = mp_to_ptr(mp_args[1]);
    g_option_context_set_main_group(context, group);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_set_main_group_obj, 2, mp_g_option_context_set_main_group, g_option_context_set_main_group);

 

/*
 * dbus extension definition for:
 * extern GOptionGroup *g_option_context_get_main_group(GOptionContext *context)
 */
 
STATIC mp_obj_t mp_g_option_context_get_main_group(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    GOptionGroup * res = g_option_context_get_main_group(context);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_get_main_group_obj, 1, mp_g_option_context_get_main_group, g_option_context_get_main_group);

 

/*
 * dbus extension definition for:
 * extern gchar *g_option_context_get_help(GOptionContext *context, gboolean main_help, GOptionGroup *group)
 */
 
STATIC mp_obj_t mp_g_option_context_get_help(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionContext *context = mp_to_ptr(mp_args[0]);
    gboolean main_help = (int)mp_obj_get_int(mp_args[1]);
    GOptionGroup *group = mp_to_ptr(mp_args[2]);
    gchar * res = g_option_context_get_help(context, main_help, group);
    return convert_to_str((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_context_get_help_obj, 3, mp_g_option_context_get_help, g_option_context_get_help);

 

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify destroy' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify destroy
 */
    

/*
 * dbus extension definition for:
 * extern GOptionGroup *g_option_group_new(const gchar *name, const gchar *description, const gchar *help_description, gpointer user_data, GDestroyNotify destroy)
 */
 
STATIC mp_obj_t mp_g_option_group_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *name = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *description = (char*)mp_obj_str_get_str(mp_args[1]);
    const gchar *help_description = (char*)mp_obj_str_get_str(mp_args[2]);
    gpointer user_data = mp_to_ptr(mp_args[3]);
    GDestroyNotify destroy = mp_to_ptr(mp_args[4]);
    GOptionGroup * res = g_option_group_new(name, description, help_description, user_data, destroy);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_group_new_obj, 5, mp_g_option_group_new, g_option_group_new);

 

/*
 * Function NOT generated:
 * Callback function 'GOptionParseFunc pre_parse_func' must receive a struct pointer with user_data member as its first argument!
 * GOptionParseFunc pre_parse_func
 */
    

/*
 * Function NOT generated:
 * Callback function 'GOptionParseFunc post_parse_func' must receive a struct pointer with user_data member as its first argument!
 * GOptionParseFunc post_parse_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_option_group_set_parse_hooks(GOptionGroup *group, GOptionParseFunc pre_parse_func, GOptionParseFunc post_parse_func)
 */
 
STATIC mp_obj_t mp_g_option_group_set_parse_hooks(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionGroup *group = mp_to_ptr(mp_args[0]);
    GOptionParseFunc pre_parse_func = mp_to_ptr(mp_args[1]);
    GOptionParseFunc post_parse_func = mp_to_ptr(mp_args[2]);
    g_option_group_set_parse_hooks(group, pre_parse_func, post_parse_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_group_set_parse_hooks_obj, 3, mp_g_option_group_set_parse_hooks, g_option_group_set_parse_hooks);

 

/*
 * Function NOT generated:
 * Callback function 'GOptionErrorFunc error_func' must receive a struct pointer with user_data member as its first argument!
 * GOptionErrorFunc error_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_option_group_set_error_hook(GOptionGroup *group, GOptionErrorFunc error_func)
 */
 
STATIC mp_obj_t mp_g_option_group_set_error_hook(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionGroup *group = mp_to_ptr(mp_args[0]);
    GOptionErrorFunc error_func = mp_to_ptr(mp_args[1]);
    g_option_group_set_error_hook(group, error_func);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_group_set_error_hook_obj, 2, mp_g_option_group_set_error_hook, g_option_group_set_error_hook);

 

/*
 * dbus extension definition for:
 * extern void g_option_group_free(GOptionGroup *group)
 */
 
STATIC mp_obj_t mp_g_option_group_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionGroup *group = mp_to_ptr(mp_args[0]);
    g_option_group_free(group);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_group_free_obj, 1, mp_g_option_group_free, g_option_group_free);

 

/*
 * dbus extension definition for:
 * extern GOptionGroup *g_option_group_ref(GOptionGroup *group)
 */
 
STATIC mp_obj_t mp_g_option_group_ref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionGroup *group = mp_to_ptr(mp_args[0]);
    GOptionGroup * res = g_option_group_ref(group);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_group_ref_obj, 1, mp_g_option_group_ref, g_option_group_ref);

 

/*
 * dbus extension definition for:
 * extern void g_option_group_unref(GOptionGroup *group)
 */
 
STATIC mp_obj_t mp_g_option_group_unref(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionGroup *group = mp_to_ptr(mp_args[0]);
    g_option_group_unref(group);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_group_unref_obj, 1, mp_g_option_group_unref, g_option_group_unref);

 

/*
 * dbus extension definition for:
 * extern void g_option_group_add_entries(GOptionGroup *group, const GOptionEntry *entries)
 */
 
STATIC mp_obj_t mp_g_option_group_add_entries(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionGroup *group = mp_to_ptr(mp_args[0]);
    const GOptionEntry *entries = mp_to_ptr(mp_args[1]);
    g_option_group_add_entries(group, entries);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_group_add_entries_obj, 2, mp_g_option_group_add_entries, g_option_group_add_entries);

 

/*
 * Function NOT generated:
 * Callback function 'GTranslateFunc func' must receive a struct pointer with user_data member as its first argument!
 * GTranslateFunc func
 */
    

/*
 * Function NOT generated:
 * Callback function 'GDestroyNotify destroy_notify' must receive a struct pointer with user_data member as its first argument!
 * GDestroyNotify destroy_notify
 */
    

/*
 * dbus extension definition for:
 * extern void g_option_group_set_translate_func(GOptionGroup *group, GTranslateFunc func, gpointer data, GDestroyNotify destroy_notify)
 */
 
STATIC mp_obj_t mp_g_option_group_set_translate_func(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionGroup *group = mp_to_ptr(mp_args[0]);
    GTranslateFunc func = mp_to_ptr(mp_args[1]);
    gpointer data = mp_to_ptr(mp_args[2]);
    GDestroyNotify destroy_notify = mp_to_ptr(mp_args[3]);
    g_option_group_set_translate_func(group, func, data, destroy_notify);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_group_set_translate_func_obj, 4, mp_g_option_group_set_translate_func, g_option_group_set_translate_func);

 

/*
 * dbus extension definition for:
 * extern void g_option_group_set_translation_domain(GOptionGroup *group, const gchar *domain)
 */
 
STATIC mp_obj_t mp_g_option_group_set_translation_domain(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GOptionGroup *group = mp_to_ptr(mp_args[0]);
    const gchar *domain = (char*)mp_obj_str_get_str(mp_args[1]);
    g_option_group_set_translation_domain(group, domain);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_option_group_set_translation_domain_obj, 2, mp_g_option_group_set_translation_domain, g_option_group_set_translation_domain);

 

/*
 * dbus extension definition for:
 * extern GPatternSpec *g_pattern_spec_new(const gchar *pattern)
 */
 
STATIC mp_obj_t mp_g_pattern_spec_new(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *pattern = (char*)mp_obj_str_get_str(mp_args[0]);
    GPatternSpec * res = g_pattern_spec_new(pattern);
    return ptr_to_mp((void*)res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_pattern_spec_new_obj, 1, mp_g_pattern_spec_new, g_pattern_spec_new);

 

/*
 * dbus extension definition for:
 * extern void g_pattern_spec_free(GPatternSpec *pspec)
 */
 
STATIC mp_obj_t mp_g_pattern_spec_free(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPatternSpec *pspec = mp_to_ptr(mp_args[0]);
    g_pattern_spec_free(pspec);
    return mp_const_none;
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_pattern_spec_free_obj, 1, mp_g_pattern_spec_free, g_pattern_spec_free);

 

/*
 * dbus extension definition for:
 * extern gboolean g_pattern_spec_equal(GPatternSpec *pspec1, GPatternSpec *pspec2)
 */
 
STATIC mp_obj_t mp_g_pattern_spec_equal(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPatternSpec *pspec1 = mp_to_ptr(mp_args[0]);
    GPatternSpec *pspec2 = mp_to_ptr(mp_args[1]);
    gboolean res = g_pattern_spec_equal(pspec1, pspec2);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_pattern_spec_equal_obj, 2, mp_g_pattern_spec_equal, g_pattern_spec_equal);

 

/*
 * dbus extension definition for:
 * extern gboolean g_pattern_match(GPatternSpec *pspec, guint string_length, const gchar *string, const gchar *string_reversed)
 */
 
STATIC mp_obj_t mp_g_pattern_match(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPatternSpec *pspec = mp_to_ptr(mp_args[0]);
    guint string_length = (unsigned int)mp_obj_get_int(mp_args[1]);
    const gchar *string = (char*)mp_obj_str_get_str(mp_args[2]);
    const gchar *string_reversed = (char*)mp_obj_str_get_str(mp_args[3]);
    gboolean res = g_pattern_match(pspec, string_length, string, string_reversed);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_pattern_match_obj, 4, mp_g_pattern_match, g_pattern_match);

 

/*
 * dbus extension definition for:
 * extern gboolean g_pattern_match_string(GPatternSpec *pspec, const gchar *string)
 */
 
STATIC mp_obj_t mp_g_pattern_match_string(size_t mp_n_args, const mp_obj_t *mp_args)
{
    GPatternSpec *pspec = mp_to_ptr(mp_args[0]);
    const gchar *string = (char*)mp_obj_str_get_str(mp_args[1]);
    gboolean res = g_pattern_match_string(pspec, string);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_pattern_match_string_obj, 2, mp_g_pattern_match_string, g_pattern_match_string);

 

/*
 * dbus extension definition for:
 * extern gboolean g_pattern_match_simple(const gchar *pattern, const gchar *string)
 */
 
STATIC mp_obj_t mp_g_pattern_match_simple(size_t mp_n_args, const mp_obj_t *mp_args)
{
    const gchar *pattern = (char*)mp_obj_str_get_str(mp_args[0]);
    const gchar *string = (char*)mp_obj_str_get_str(mp_args[1]);
    gboolean res = g_pattern_match_simple(pattern, string);
    return mp_obj_new_int(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_pattern_match_simple_obj, 2, mp_g_pattern_match_simple, g_pattern_match_simple);

 

/*
 * dbus extension definition for:
 * extern guint g_spaced_primes_closest(guint num)
 */
 
STATIC mp_obj_t mp_g_spaced_primes_closest(size_t mp_n_args, const mp_obj_t *mp_args)
{
    guint num = (unsigned int)mp_obj_get_int(mp_args[0]);
    guint res = g_spaced_primes_closest(num);
    return mp_obj_new_int_from_uint(res);
}

STATIC MP_DEFINE_CONST_LV_FUN_OBJ_VAR(mp_g_spaced_primes_closest_obj, 1, mp_g_spaced_primes_closest, g_spaced_primes_closest);

 

/*
 * Function NOT generated:
 * Callback function 'GCompareDataFunc compare_func' must receive a struct pointer with user_data member as its first argument!
 * GCompareDataFunc compare_func
 */
    

/*
 * dbus extension definition for:
 * extern void g_qsort_with_data(gconstpointer pbase, gint total_elems, gsize size, GCompareDataFunc compare_func, gpointer user_data)
 */
 
STATIC mp_obj_t mp_g_qsort_with_data(size_t mp_n_args, const mp_obj_t *mp_args)
{
   

MPDBUS_README.md

Example of converting dbus.h to Micropython module.

Command line:

python ~/esp/projects/lv_mpy/lib/lv_bindings/gen/gen_mpy.py -M dbus -MD dbusmod.json -I~/esp/projects/lv_mpy/lib/lv_bindings/pycparser/utils/fake_libc_include -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include/ dbus_pp.h > dbusmod.c

dbusmod.json