])
])
+ifelse([$1], [gthread], [dnl
+ m4_append([_GLIB_MAIN], [dnl
+g_thread_init(NULL);
+])
+])
+
if test x"$PKG_CONFIG" != x; then
AC_MSG_CHECKING([pkg-config database for $1-2.0])
_PKG_CONFIG([lib$1_cflags], [cflags], [$1-2.0])
_GLIB_MODULE([glib], [glib])
_GLIB_MODULE([gobject], [$2])
+_GLIB_MODULE([gthread], [$2])
AC_LANG_PUSH([C])
old_cflags=$CFLAGS
+AM_CPPFLAGS = -DPKGLIBDIR=\"$(pkglibdir)\"
+
lib_LTLIBRARIES = libuobject.la libupkg.la
+pkglib_LTLIBRARIES =
include_HEADERS = upkg.h
noinst_HEADERS = pack.h avl.h
include uobject/Makefile.inc
include engine/Makefile.inc
-libuobject_la_SOURCES = uobject.c module.c avl.c loadable.c exportable.c
-libuobject_la_CPPFLAGS = $(GLIB_CFLAGS) $(LTDLINCL)
+libuobject_la_SOURCES = uobject.c module.c avl.c package.c \
+ loadable.c exportable.c
+libuobject_la_CPPFLAGS = $(AM_CPPFLAGS) $(GLIB_CFLAGS) $(LTDLINCL)
libuobject_la_LIBADD = $(LIBLTDL) $(GLIB_LIBS)
+libuobject_la_LDFLAGS = -export-symbols-regex '^u_'
libupkg_la_SOURCES = libupkg.c pack.c
noinst_HEADERS += engine/music.h engine/texture.h engine/music-module.h
-lib_LTLIBRARIES += engine.la
-engine_la_SOURCES = engine/music.c engine/texture.c engine/engine.c
-engine_la_CFLAGS = $(GLIB_CFLAGS)
-engine_la_LIBADD = $(GLIB_LIBS)
-engine_la_LDFLAGS = -module -avoid-version -export-symbols-regex _LTX_
+pkglib_LTLIBRARIES += engine.la
+engine_la_SOURCES = engine/music.c engine/texture.c engine/engine.c
+engine_la_CFLAGS = $(GLIB_CFLAGS)
+engine_la_LIBADD = $(GLIB_LIBS)
+engine_la_LDFLAGS = -module -avoid-version -export-symbols-regex _LTX_
if USE_DUMMYMOD
engine_la_SOURCES += engine/music-dummymod.c
static void exportable_init(UObjectExportable *);
static void loadable_init(UObjectLoadable *);
-G_DEFINE_DYNAMIC_TYPE_EXTENDED(EngineMusic, engine_music, UOBJECT_TYPE, 0,
- G_IMPLEMENT_INTERFACE(UOBJECT_TYPE_EXPORTABLE, exportable_init)
- G_IMPLEMENT_INTERFACE(UOBJECT_TYPE_LOADABLE, loadable_init)
+G_DEFINE_DYNAMIC_TYPE_EXTENDED(EngineMusic, engine_music, U_OBJECT_TYPE, 0,
+ G_IMPLEMENT_INTERFACE(U_OBJECT_TYPE_EXPORTABLE, exportable_init)
+ G_IMPLEMENT_INTERFACE(U_OBJECT_TYPE_LOADABLE, loadable_init)
);
static int load(GObject *o)
unsigned char buf[32];
long size;
- UOBJECT_CLASS(engine_music_parent_class)->deserialize(o, f);
+ U_OBJECT_CLASS(engine_music_parent_class)->deserialize(o, f);
buflen = upkg_export_read(f, buf, sizeof buf);
static void engine_music_class_init(EngineMusicClass *class)
{
- UObjectClass *uo = UOBJECT_CLASS(class);
+ UObjectClass *uo = U_OBJECT_CLASS(class);
GObjectClass *go = G_OBJECT_CLASS(class);
g_type_class_add_private(class, sizeof (struct music_priv));
{
}
-G_DEFINE_DYNAMIC_TYPE(EngineTexture, engine_texture, UOBJECT_TYPE);
+G_DEFINE_DYNAMIC_TYPE(EngineTexture, engine_texture, U_OBJECT_TYPE);
static int deserialize(UObject *o, struct upkg_file *f)
{
struct texture_priv *priv = TEXTURE_GET_PRIV(o);
EngineTexture *t = ENGINE_TEXTURE(o);
- UOBJECT_CLASS(engine_texture_parent_class)->deserialize(o, f);
+ U_OBJECT_CLASS(engine_texture_parent_class)->deserialize(o, f);
printf("Texture size: %ux%u\n", t->usize, t->vsize);
static void engine_texture_class_init(EngineTextureClass *class)
{
- UObjectClass *uo = UOBJECT_CLASS(class);
+ UObjectClass *uo = U_OBJECT_CLASS(class);
GObjectClass *go = G_OBJECT_CLASS(class);
g_type_class_add_private(class, sizeof (struct texture_priv));
#include <glib-object.h>
#include <uobject/exportable.h>
-GType uobject_exportable_get_type(void)
+GType u_object_exportable_get_type(void)
{
static GType type = 0;
if (type == 0) {
return type;
}
-int uobject_export(GObject *obj, FILE *f)
+int u_object_export(GObject *obj, FILE *f)
{
- g_return_val_if_fail(UOBJECT_IS_EXPORTABLE(obj), -1);
- return UOBJECT_EXPORTABLE_GET_INTERFACE(obj)->export(obj, f);
+ g_return_val_if_fail(U_OBJECT_IS_EXPORTABLE(obj), -1);
+ return U_OBJECT_EXPORTABLE_GET_INTERFACE(obj)->export(obj, f);
}
-int uobject_export_name(GObject *obj, char *buf, size_t n)
+int u_object_export_name(GObject *obj, char *buf, size_t n)
{
- g_return_val_if_fail(UOBJECT_IS_EXPORTABLE(obj), -1);
- return UOBJECT_EXPORTABLE_GET_INTERFACE(obj)->export_name(obj, buf, n);
+ g_return_val_if_fail(U_OBJECT_IS_EXPORTABLE(obj), -1);
+ return U_OBJECT_EXPORTABLE_GET_INTERFACE(obj)->export_name(obj, buf, n);
}
/* Read some data into buffer. */
if (!feof(pkg->priv->f)) {
rc = fread(buf+nbuf, 1, sizeof buf-nbuf, pkg->priv->f);
- if (rc == 0)
+ if (rc == 0 && nbuf == 0)
goto err;
nbuf += rc;
}
/* Read some data into buffer. */
if (!feof(pkg->priv->f)) {
rc = fread(buf+nbuf, 1, sizeof buf-nbuf, pkg->priv->f);
- if (rc == 0)
+ if (rc == 0 && nbuf == 0)
goto err;
nbuf += rc;
}
/* Read some data into buffer. */
if (!feof(pkg->priv->f)) {
rc = fread(buf+nbuf, 1, sizeof buf-nbuf, pkg->priv->f);
- if (rc == 0)
+ if (rc == 0 && nbuf == 0)
goto err;
nbuf += rc;
}
return -1;
}
+unsigned long upkg_export_flags(struct upkg *pkg, unsigned long idx)
+{
+ if (idx < pkg->export_count)
+ return pkg->priv->exports[idx].flags;
+ return 0;
+}
+
const char *upkg_export_name(struct upkg *pkg, unsigned long idx)
{
if (idx < pkg->export_count)
#include <glib-object.h>
#include <uobject/loadable.h>
-GType uobject_loadable_get_type(void)
+GType u_object_loadable_get_type(void)
{
static GType type = 0;
if (type == 0) {
return type;
}
-int uobject_load(GObject *obj)
+int u_object_load(GObject *obj)
{
- g_return_val_if_fail(UOBJECT_IS_LOADABLE(obj), -1);
- return UOBJECT_LOADABLE_GET_INTERFACE(obj)->load(obj);
+ g_return_val_if_fail(U_OBJECT_IS_LOADABLE(obj), -1);
+ return U_OBJECT_LOADABLE_GET_INTERFACE(obj)->load(obj);
}
-void uobject_unload(GObject *obj)
+void u_object_unload(GObject *obj)
{
- g_return_if_fail(UOBJECT_IS_LOADABLE(obj));
- UOBJECT_LOADABLE_GET_INTERFACE(obj)->unload(obj);
+ g_return_if_fail(U_OBJECT_IS_LOADABLE(obj));
+ U_OBJECT_LOADABLE_GET_INTERFACE(obj)->unload(obj);
}
#include <ltdl.h>
#include <uobject/module.h>
-#include "module.h"
+#include <uobject/package.h>
#include "avl.h"
static unsigned initialized;
return dst;
}
-G_DEFINE_TYPE(UPkgModule, upkg_module, G_TYPE_TYPE_MODULE);
-
-static void dl_print_errors(const char *prefix)
-{
- const char *err;
- while ((err = lt_dlerror())) {
- if (prefix) fprintf(stderr, "%s: ", prefix);
- puts(err);
- }
-}
-
-static gboolean module_load(GTypeModule *m)
-{
- UPkgModule *mod = UPKG_MODULE(m);
- int (*init_func)(GTypeModule *);
-
- mod->dl = lt_dlopenext(G_TYPE_MODULE(m)->name);
- if (!mod->dl) {
- dl_print_errors(G_TYPE_MODULE(m)->name);
- return FALSE;
- }
-
- init_func = lt_dlsym(mod->dl, "init");
- if (!init_func || init_func(m) != 0) {
- dl_print_errors(__func__);
- lt_dlclose(mod->dl);
- return FALSE;
- }
-
- return TRUE;
-}
-
-static void module_unload(GTypeModule *m)
-{
- UPkgModule *mod = UPKG_MODULE(m);
-
- if (lt_dlclose(mod->dl) != 0) {
- dl_print_errors(__func__);
- }
-}
-
-static void upkg_module_init(UPkgModule *mod)
-{
-}
-
-static void upkg_module_class_init(UPkgModuleClass *class)
-{
- GTypeModuleClass *modclass = G_TYPE_MODULE_CLASS(class);
-
- modclass->load = module_load;
- modclass->unload = module_unload;
-}
-
-static UPkgModule *uobject_module_new(const char *name)
-{
- char *name2;
-
- if (!name) {
- return NULL;
- }
-
- name2 = malloc(strlen(name)+1);
- if (!name2) {
- return NULL;
- }
-
- UPkgModule *mod = g_object_new(UPKG_MODULE_TYPE, NULL);
- if (!mod) {
- free(name2);
- return NULL;
- }
-
- G_TYPE_MODULE(mod)->name = str_cpy_lower(name2, name);
- return mod;
-}
-
static int modcmp(const void *a, const void *b, void *_data)
{
const GTypeModule *ma = a;
return strcmp(ma->name, mb->name);
}
-int uobject_module_init(void)
+int u_object_module_init(void)
{
if (!initialized) {
package_tree = avl_create(modcmp, NULL, NULL);
return -1;
}
- if (lt_dlinit() != 0) {
- avl_destroy(package_tree, NULL);
- dl_print_errors(__func__);
- return -1;
- }
-
g_type_init();
}
return 0;
}
-int uobject_module_exit(void)
+int u_object_module_exit(void)
{
if (--initialized)
return 0;
- if (lt_dlexit() != 0) {
- dl_print_errors(__func__);
- return -1;
- }
+ avl_destroy(package_tree, NULL);
return 0;
}
-GType uobject_module_get_class(const char *package, const char *class)
+GType u_object_module_get_class(const char *package, const char *class)
{
char buf[strlen(package) + strlen(class) + 1];
GTypeModule search = { .name = str_cpy_lower(buf, package) };
if (!mod) {
void **p;
- mod = G_TYPE_MODULE(uobject_module_new(package));
+ mod = u_pkg_new(package);
if (!mod) {
return 0;
}
--- /dev/null
+/*
+ * upkg: tool for manipulating Unreal Tournament packages.
+ * Copyright (C) 2009 Nick Bowler
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <glib-object.h>
+#include <ltdl.h>
+
+#include <uobject/package.h>
+
+#define U_PKG_GET_PRIV(o) \
+ G_TYPE_INSTANCE_GET_PRIVATE(o, U_PKG_TYPE, struct upkg_priv)
+
+struct upkg_priv {
+ lt_dlhandle native;
+};
+
+G_DEFINE_TYPE(UPkg, u_pkg, G_TYPE_TYPE_MODULE);
+
+static char *str_cpy_lower(char *dst, const char *src)
+{
+ size_t i;
+
+ for (i = 0; src[i]; i++)
+ dst[i] = tolower(src[i]);
+ dst[i] = 0;
+
+ return dst;
+}
+
+static void dl_print_errors(const char *prefix)
+{
+ const char *err;
+ while ((err = lt_dlerror())) {
+ if (prefix) fprintf(stderr, "%s: ", prefix);
+ fprintf(stderr, "%s\n", err);
+ }
+}
+
+static gboolean u_pkg_load(GTypeModule *m)
+{
+ struct upkg_priv *priv = U_PKG_GET_PRIV(m);
+ int (*init_func)(GTypeModule *);
+
+ priv->native = lt_dlopenext(m->name);
+ if (!priv->native) {
+ dl_print_errors(m->name);
+ return FALSE;
+ }
+
+ init_func = lt_dlsym(priv->native, "init");
+ if (!init_func || init_func(m) != 0) {
+ dl_print_errors(__func__);
+ lt_dlclose(priv->native);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void u_pkg_unload(GTypeModule *m)
+{
+ struct upkg_priv *priv = U_PKG_GET_PRIV(m);
+ void (*exit_func)(GTypeModule *);
+
+ if (priv->native) {
+ exit_func = lt_dlsym(priv->native, "exit");
+ if (exit_func) {
+ exit_func(m);
+ }
+
+ if (lt_dlclose(priv->native) != 0) {
+ dl_print_errors(__func__);
+ }
+ }
+}
+
+static void u_pkg_init(UPkg *pkg)
+{
+
+}
+
+static void u_pkg_class_init(UPkgClass *class)
+{
+ g_type_class_add_private(class, sizeof (struct upkg_priv));
+
+ GTypeModuleClass *modclass = G_TYPE_MODULE_CLASS(class);
+
+ if (lt_dlinit() != 0 || lt_dlsetsearchpath(PKGLIBDIR) != 0) {
+ dl_print_errors(__func__);
+ }
+
+ modclass->load = u_pkg_load;
+ modclass->unload = u_pkg_unload;
+}
+
+GTypeModule *u_pkg_new(const char *name)
+{
+ g_return_val_if_fail(name != NULL, NULL);
+
+ char *pkgname = malloc(strlen(name)+1);
+ if (!pkgname) {
+ return NULL;
+ }
+
+ GTypeModule *mod = g_object_new(U_PKG_TYPE, NULL);
+ if (!mod) {
+ free(pkgname);
+ return NULL;
+ }
+
+ mod->name = str_cpy_lower(pkgname, name);
+ return mod;
+}
#include "upkg.h"
#include "pack.h"
-#define UOBJECT_GET_PRIV(o) \
- G_TYPE_INSTANCE_GET_PRIVATE(o, UOBJECT_TYPE, struct uobject_priv)
+#define U_OBJECT_GET_PRIV(o) \
+ G_TYPE_INSTANCE_GET_PRIVATE(o, U_OBJECT_TYPE, struct u_object_priv)
enum {
PROPERTY_BYTE = 1,
PROPERTY_FIXEDARRAY,
};
-struct uobject_property {
- const char *name;
- GValue val;
-};
-
-struct uobject_priv {
+struct u_object_priv {
struct upkg_file *f;
size_t base, len;
unsigned long nbuf;
};
-G_DEFINE_TYPE(UObject, uobject, G_TYPE_OBJECT);
+G_DEFINE_TYPE(UObject, u_object, G_TYPE_OBJECT);
static unsigned long
get_real_size(unsigned long *real, unsigned size, unsigned char *buf, size_t n)
static unsigned long
decode_property(UObject *o, const char *name, struct upkg_file *f, unsigned long len)
{
- struct uobject_priv *priv = UOBJECT_GET_PRIV(o);
+ struct u_object_priv *priv = U_OBJECT_GET_PRIV(o);
unsigned long real_size, rc;
int type, size, top;
GValue val = {0};
/* Deserialize properties from an Unreal package. */
static int deserialize(UObject *o, struct upkg_file *f)
{
- struct uobject_priv *priv = UOBJECT_GET_PRIV(o);
+ struct u_object_priv *priv = U_OBJECT_GET_PRIV(o);
unsigned long rc, tot_len = 0;
while (1) {
void *buf = priv->buf + priv->nbuf;
size_t amt = sizeof priv->buf - priv->nbuf;
rc = upkg_export_read(f, buf, amt);
- if (rc == 0)
+ if (rc == 0 && priv->nbuf == 0)
return -1;
priv->nbuf += rc;
}
break;
}
- rc = decode_property(UOBJECT(o), name, f, len);
+ rc = decode_property(U_OBJECT(o), name, f, len);
if (rc == 0)
return -1;
len = rc;
return 0;
}
-int uobject_deserialize(GObject *obj, struct upkg *pkg, unsigned long idx)
+int u_object_deserialize(GObject *obj, struct upkg *pkg, unsigned long idx)
{
- g_return_val_if_fail(IS_UOBJECT(obj), -1);
- UObject *uo = UOBJECT(obj);
+ g_return_val_if_fail(IS_U_OBJECT(obj), -1);
+ UObject *uo = U_OBJECT(obj);
struct upkg_file *f;
int rc;
return -1;
}
- rc = UOBJECT_GET_CLASS(obj)->deserialize(uo, f);
+ rc = U_OBJECT_GET_CLASS(obj)->deserialize(uo, f);
if (rc != 0) {
upkg_export_close(f);
} else {
return rc;
}
-static void uobject_init(UObject *o)
+static void u_object_init(UObject *o)
{
o->pkg = NULL;
o->pkg_file = NULL;
o->pkg_idx = 0;
}
-static void uobject_finalize(GObject *o)
+static void u_object_finalize(GObject *o)
{
- UObject *uo = UOBJECT(o);
+ UObject *uo = U_OBJECT(o);
if (uo->pkg_file) {
upkg_export_close(uo->pkg_file);
}
- G_OBJECT_CLASS(uobject_parent_class)->finalize(o);
+ G_OBJECT_CLASS(u_object_parent_class)->finalize(o);
}
-static void uobject_class_init(UObjectClass *class)
+static void u_object_class_init(UObjectClass *class)
{
- g_type_class_add_private(class, sizeof (struct uobject_priv));
+ g_type_class_add_private(class, sizeof (struct u_object_priv));
GObjectClass *go = G_OBJECT_CLASS(class);
class->deserialize = deserialize;
- go->finalize = uobject_finalize;
+ go->finalize = u_object_finalize;
}
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-#ifndef UOBJECT_EXPORTABLE_H_
-#define UOBJECT_EXPORTABLE_H_
+#ifndef U_OBJECT_EXPORTABLE_H_
+#define U_OBJECT_EXPORTABLE_H_
#include <stdio.h>
#include <glib-object.h>
-#define UOBJECT_TYPE_EXPORTABLE (uobject_exportable_get_type())
-#define UOBJECT_EXPORTABLE(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, \
- UOBJECT_TYPE_EXPORTABLE, UObjectExportable)
-#define UOBJECT_IS_EXPORTABLE(obj) G_TYPE_CHECK_INSTANCE_TYPE(obj, \
- UOBJECT_TYPE_EXPORTABLE)
-#define UOBJECT_EXPORTABLE_GET_INTERFACE(inst) G_TYPE_INSTANCE_GET_INTERFACE \
- (inst, UOBJECT_TYPE_EXPORTABLE, UObjectExportable)
+#define U_OBJECT_TYPE_EXPORTABLE (u_object_exportable_get_type())
+#define U_OBJECT_EXPORTABLE(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, \
+ U_OBJECT_TYPE_EXPORTABLE, UObjectExportable)
+#define U_OBJECT_IS_EXPORTABLE(obj) G_TYPE_CHECK_INSTANCE_TYPE(obj, \
+ U_OBJECT_TYPE_EXPORTABLE)
+#define U_OBJECT_EXPORTABLE_GET_INTERFACE(inst) G_TYPE_INSTANCE_GET_INTERFACE \
+ (inst, U_OBJECT_TYPE_EXPORTABLE, UObjectExportable)
typedef struct UObjectExportable UObjectExportable;
int (*export_name)(GObject *obj, char *buf, size_t n);
};
-GType uobject_exportable_get_type(void);
+GType u_object_exportable_get_type(void);
/*
* Export the object by writing it to the given FILE handle, which must have
* been opened for writing in binary mode.
*/
-int uobject_export(GObject *obj, FILE *f);
+int u_object_export(GObject *obj, FILE *f);
/*
* Get the suggested output filename. Not more than n-1 characters of the
* not bounded. It is valid to call this function with a NULL buffer and a 0
* size in order to determine how large the buffer needs to be.
*/
-int uobject_export_name(GObject *obj, char *buf, size_t n);
+int u_object_export_name(GObject *obj, char *buf, size_t n);
#endif
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-#ifndef UOBJECT_LOADABLE_H_
-#define UOBJECT_LOADABLE_H_
+#ifndef U_OBJECT_LOADABLE_H_
+#define U_OBJECT_LOADABLE_H_
#include <stdio.h>
#include <glib-object.h>
-#define UOBJECT_TYPE_LOADABLE (uobject_loadable_get_type())
-#define UOBJECT_LOADABLE(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, \
- UOBJECT_TYPE_LOADABLE, UObjectLoadable)
-#define UOBJECT_IS_LOADABLE(obj) G_TYPE_CHECK_INSTANCE_TYPE(obj, \
- UOBJECT_TYPE_LOADABLE)
-#define UOBJECT_LOADABLE_GET_INTERFACE(inst) G_TYPE_INSTANCE_GET_INTERFACE \
- (inst, UOBJECT_TYPE_LOADABLE, UObjectLoadable)
+#define U_OBJECT_TYPE_LOADABLE (u_object_loadable_get_type())
+#define U_OBJECT_LOADABLE(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, \
+ U_OBJECT_TYPE_LOADABLE, UObjectLoadable)
+#define U_OBJECT_IS_LOADABLE(obj) G_TYPE_CHECK_INSTANCE_TYPE(obj, \
+ U_OBJECT_TYPE_LOADABLE)
+#define U_OBJECT_LOADABLE_GET_INTERFACE(inst) G_TYPE_INSTANCE_GET_INTERFACE \
+ (inst, U_OBJECT_TYPE_LOADABLE, UObjectLoadable)
typedef struct UObjectLoadable UObjectLoadable;
void (*unload)(GObject *obj);
};
-GType uobject_loadable_get_type(void);
+GType u_object_loadable_get_type(void);
-int uobject_load(GObject *obj);
-void uobject_unload(GObject *obj);
+int u_object_load(GObject *obj);
+void u_object_unload(GObject *obj);
#endif
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-#ifndef UOBJECT_MODULE_H_
-#define UOBJECT_MODULE_H_
+#ifndef U_OBJECT_MODULE_H_
+#define U_OBJECT_MODULE_H_
#include <glib-object.h>
* Initialize the UObject module system. Returns 0 on success, -1 otherwise.
* The module system can be safely initialized multiple times.
*/
-int uobject_module_init(void);
+int u_object_module_init(void);
/*
* Shutdown the UObject module system. Returns 0 on success, -1 otherwise.
* The module system is only shut down when this function has been called as
- * many times as uobject_module_init.
+ * many times as u_object_module_init.
*/
-int uobject_module_exit(void);
+int u_object_module_exit(void);
/*
* Get a class handle from the UObject module system. This will load the
*
* Returns 0 on failure.
*/
-GType uobject_module_get_class(const char *package, const char *class);
+GType u_object_module_get_class(const char *package, const char *class);
#endif
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-#ifndef MODULE_H_
-#define MODULE_H_
+#ifndef U_OBJECT_PACKAGE_H_
+#define U_OBJECT_PACKAGE_H_
#include <glib-object.h>
-#include <ltdl.h>
-
-#define UPKG_MODULE_TYPE (upkg_module_get_type())
-#define UPKG_MODULE(obj) \
- G_TYPE_CHECK_INSTANCE_CAST(obj, UPKG_MODULE_TYPE, UPkgModule)
-#define UPKG_MODULE_CLASS(class) \
- G_TYPE_CHECK_CLASS_CAST(class, UPKG_MODULE_TYPE, UPkgModuleClass)
-#define IS_UPKG_MODULE(obj) \
- G_TYPE_CHECK_INSTANCE_TYPE(obj, UPKG_MODULE_TYPE)
-#define IS_UPKG_MODULE_CLASS(class) \
- G_TYPE_CHECK_CLASS_TYPE(class, UPKG_MODULE_TYPE, UPkgModuleClass)
-
-typedef struct UPkgModule UPkgModule;
-typedef struct UPkgModuleClass UPkgModuleClass;
-
-struct UPkgModule {
- GTypeModule parent;
- lt_dlhandle dl;
+#define U_PKG_TYPE (u_pkg_get_type())
+#define U_PKG(obj) \
+ G_TYPE_CHECK_INSTANCE_CAST(obj, U_PKG_TYPE, UPkg)
+#define U_PKG_CLASS(class) \
+ G_TYPE_CHECK_CLASS_CAST(class, U_PKG_TYPE, UPkgClass)
+#define IS_U_PKG(obj) \
+ G_TYPE_CHECK_INSTANCE_TYPE(obj, U_PKG_TYPE)
+#define IS_U_PKG_CLASS(class) \
+ G_TYPE_CHECK_CLASS_TYPE(class, U_PKG_TYPE, UPkgClass)
+#define U_PKG_GET_CLASS(obj) \
+ G_TYPE_INSTANCE_GET_CLASS(obj, U_PKG_TYPE, UPkgClass)
+
+typedef struct UPkg UPkg;
+typedef struct UPkgClass UPkgClass;
+
+struct UPkg {
+ GTypeModule parent;
};
-struct UPkgModuleClass {
+struct UPkgClass {
GTypeModuleClass parent;
};
-static UPkgModule *uobject_module_new(const char *name);
+GType u_pkg_get_type(void);
+GTypeModule *u_pkg_new(const char *name);
#endif
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-#ifndef UOBJECT_UOBJECT_H_
-#define UOBJECT_UOBJECT_H_
+#ifndef U_OBJECT_H_
+#define U_OBJECT_H_
#include <glib-object.h>
#include "upkg.h"
-#define UOBJECT_TYPE uobject_get_type()
-#define UOBJECT(obj) \
- G_TYPE_CHECK_INSTANCE_CAST(obj, UOBJECT_TYPE, UObject)
-#define UOBJECT_CLASS(class) \
- G_TYPE_CHECK_CLASS_CAST(class, UOBJECT_TYPE, UObjectClass)
-#define IS_UOBJECT(obj) \
- G_TYPE_CHECK_INSTANCE_TYPE(obj, UOBJECT_TYPE)
-#define IS_UOBJECT_CLASS(class) \
- G_TYPE_CHECK_CLASS_TYPE(class, UOBJECT_TYPE, UObjectClass)
-#define UOBJECT_GET_CLASS(obj) \
- G_TYPE_INSTANCE_GET_CLASS(obj, UOBJECT_TYPE, UObjectClass)
+#define U_OBJECT_TYPE u_object_get_type()
+#define U_OBJECT(obj) \
+ G_TYPE_CHECK_INSTANCE_CAST(obj, U_OBJECT_TYPE, UObject)
+#define U_OBJECT_CLASS(class) \
+ G_TYPE_CHECK_CLASS_CAST(class, U_OBJECT_TYPE, UObjectClass)
+#define IS_U_OBJECT(obj) \
+ G_TYPE_CHECK_INSTANCE_TYPE(obj, U_OBJECT_TYPE)
+#define IS_U_OBJECT_CLASS(class) \
+ G_TYPE_CHECK_CLASS_TYPE(class, U_OBJECT_TYPE, UObjectClass)
+#define U_OBJECT_GET_CLASS(obj) \
+ G_TYPE_INSTANCE_GET_CLASS(obj, U_OBJECT_TYPE, UObjectClass)
typedef struct UObject UObject;
typedef struct UObjectClass UObjectClass;
int (*deserialize)(UObject *obj, struct upkg_file *f);
};
-GType uobject_get_type(void);
+GType u_object_get_type(void);
-int uobject_deserialize(GObject *obj, struct upkg *pkg, unsigned long idx);
+int u_object_deserialize(GObject *obj, struct upkg *pkg, unsigned long idx);
#endif
}
}
-void print_upkg_flags(const char *prefix, unsigned long flags)
+static void print_upkg_flags(const char *prefix, unsigned long flags)
{
if (flags & UPKG_FLAG_ALLOW_DOWNLOAD)
printf("%sAllowDownload\n", prefix);
printf("%sRequired\n", prefix);
}
+static void print_upkg_object_flags(const char *prefix, unsigned long flags)
+{
+ if (flags & UPKG_OBJ_FLAG_TRANSACTIONAL)
+ printf("%sTransactional\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_UNREACHABLE)
+ printf("%sUnreachable\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_PUBLIC)
+ printf("%sPublic\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_TAG_IMPORT)
+ printf("%sImport\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_TAG_EXPORT)
+ printf("%sTagExport\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_SOURCE_MODIFIED)
+ printf("%sSourceModified\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_TAG_GARBAGE)
+ printf("%sTagGarbage\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_NEED_LOAD)
+ printf("%sNeedLoad\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_HIGHLIGHT_NAME)
+ printf("%sHighlightName\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_IN_SINGULAR_FUNC)
+ printf("%sInSingularFunc\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_SUPPRESSED)
+ printf("%sSuppressed\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_IN_END_STATE)
+ printf("%sInEndState\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_TRANSIENT)
+ printf("%sTransient\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_PRELOADING)
+ printf("%sPreloading\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_LOAD_FOR_CLIENT)
+ printf("%sLoadForClient\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_LOAD_FOR_SERVER)
+ printf("%sLoadForServer\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_LOAD_FOR_EDIT)
+ printf("%sLoadForEdit\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_STANDALONE)
+ printf("%sStandalone\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_NOT_FOR_CLIENT)
+ printf("%sNotForClient\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_NOT_FOR_SERVER)
+ printf("%sNotForServer\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_NOT_FOR_EDIT)
+ printf("%sNotForEdit\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_DESTROYED)
+ printf("%sDestroyed\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_NEED_POST_LOAD)
+ printf("%sNeedPostLoad\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_HAS_STACK)
+ printf("%sHasStack\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_NATIVE)
+ printf("%sNative\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_MARKED)
+ printf("%sMarked\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_ERROR_SHUTDOWN)
+ printf("%sErrorShutdown\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_DEBUG_POST_LOAD)
+ printf("%sDebugPostLoad\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_DEBUG_SERIALIZE)
+ printf("%sDebugSerialize\n", prefix);
+ if (flags & UPKG_OBJ_FLAG_DEBUG_DESTROY)
+ printf("%sDebugDestroy\n", prefix);
+}
+
void print_guid(unsigned char guid[static 16])
{
for (unsigned i = 0; i < 16; i++) {
continue;
printf("%u - %s (%s.%s)\n", i+1, name, package, class);
+ printf(" Flags: %lx\n", upkg_export_flags(pkg, i));
+ print_upkg_object_flags(" ", upkg_export_flags(pkg, i));
}
}
printf("Flags: %lx\n", pkg->flags);
if (verbose >= 1) {
- print_upkg_flags("\t", pkg->flags);
+ print_upkg_flags(" ", pkg->flags);
}
if (verbose >= 1) {
char name[256];
FILE *of;
- if (uobject_deserialize(obj, pkg, idx) != 0) {
+ if (u_object_deserialize(obj, pkg, idx) != 0) {
return -1;
}
- if (UOBJECT_IS_LOADABLE(obj) && uobject_load(obj) != 0) {
+ if (U_OBJECT_IS_LOADABLE(obj) && u_object_load(obj) != 0) {
return -1;
}
- uobject_export_name(obj, name, sizeof name);
+ u_object_export_name(obj, name, sizeof name);
printf("exporting %s to %s\n", upkg_export_name(pkg, idx), name);
of = fopen(name, "wb");
return -1;
}
- uobject_export(obj, of);
+ u_object_export(obj, of);
if (fclose(of) != 0) {
perror(name);
return -1;
}
- if (UOBJECT_IS_LOADABLE(obj)) {
- uobject_unload(obj);
+ if (U_OBJECT_IS_LOADABLE(obj)) {
+ u_object_unload(obj);
}
return 0;
return EXIT_FAILURE;
}
- type = uobject_module_get_class(package, class);
+ type = u_object_module_get_class(package, class);
if (!type) continue;
obj = g_object_new(type, NULL);
- if (UOBJECT_IS_EXPORTABLE(obj)) {
+ if (U_OBJECT_IS_EXPORTABLE(obj)) {
if (export(pkg, obj, i) != 0) {
rc = EXIT_FAILURE;
}
return EXIT_FAILURE;
}
- if (uobject_module_init() != 0)
+ if (u_object_module_init() != 0)
return EXIT_FAILURE;
pkg = upkg_fopen(argv[optind]);
}
upkg_close(pkg);
- uobject_module_exit();
+ u_object_module_exit();
return rc;
}
#define UPKG_FLAG_INSECURE 0x0010
#define UPKG_FLAG_REQUIRED 0x8000
-#define UPKG_OBJ_FLAG_TRANSACTIONAL 0x00000001
-#define UPKG_OBJ_FLAG_UNREACHABLE 0x00000002
-#define UPKG_OBJ_FLAG_PUBLIC 0x00000004
-#define UPKG_OBJ_FLAG_TAG_IMPORT 0x00000008
-#define UPKG_OBJ_FLAG_TAG_EXPORT 0x00000010
-#define UPKG_OBJ_FLAG_SOURCE_MODIFIED 0x00000020
-#define UPKG_OBJ_FLAG_TAG_GARBAGE 0x00000040
-#define UPKG_OBJ_FLAG_NEED_LOAD 0x00000200
-#define UPKG_OBJ_FLAG_HIGHLIGHT_NAME 0x00000400
+#define UPKG_OBJ_FLAG_TRANSACTIONAL 0x00000001
+#define UPKG_OBJ_FLAG_UNREACHABLE 0x00000002
+#define UPKG_OBJ_FLAG_PUBLIC 0x00000004
+#define UPKG_OBJ_FLAG_TAG_IMPORT 0x00000008
+#define UPKG_OBJ_FLAG_TAG_EXPORT 0x00000010
+#define UPKG_OBJ_FLAG_SOURCE_MODIFIED 0x00000020
+#define UPKG_OBJ_FLAG_TAG_GARBAGE 0x00000040
+#define UPKG_OBJ_FLAG_NEED_LOAD 0x00000200
+#define UPKG_OBJ_FLAG_HIGHLIGHT_NAME 0x00000400
+#define UPKG_OBJ_FLAG_IN_SINGULAR_FUNC 0x00000800
+#define UPKG_OBJ_FLAG_SUPPRESSED 0x00001000
+#define UPKG_OBJ_FLAG_IN_END_STATE 0x00002000
+#define UPKG_OBJ_FLAG_TRANSIENT 0x00004000
+#define UPKG_OBJ_FLAG_PRELOADING 0x00008000
+#define UPKG_OBJ_FLAG_LOAD_FOR_CLIENT 0x00010000
+#define UPKG_OBJ_FLAG_LOAD_FOR_SERVER 0x00020000
+#define UPKG_OBJ_FLAG_LOAD_FOR_EDIT 0x00040000
+#define UPKG_OBJ_FLAG_STANDALONE 0x00080000
+#define UPKG_OBJ_FLAG_NOT_FOR_CLIENT 0x00100000
+#define UPKG_OBJ_FLAG_NOT_FOR_SERVER 0x00200000
+#define UPKG_OBJ_FLAG_NOT_FOR_EDIT 0x00400000
+#define UPKG_OBJ_FLAG_DESTROYED 0x00800000
+#define UPKG_OBJ_FLAG_NEED_POST_LOAD 0x01000000
+#define UPKG_OBJ_FLAG_HAS_STACK 0x02000000
+#define UPKG_OBJ_FLAG_NATIVE 0x04000000
+#define UPKG_OBJ_FLAG_MARKED 0x08000000
+#define UPKG_OBJ_FLAG_ERROR_SHUTDOWN 0x10000000
+#define UPKG_OBJ_FLAG_DEBUG_POST_LOAD 0x20000000
+#define UPKG_OBJ_FLAG_DEBUG_SERIALIZE 0x40000000
+#define UPKG_OBJ_FLAG_DEBUG_DESTROY 0x80000000
#define UPKG_HDR_MAGIC 0x9e2a83c1
#define UPKG_HDR_SIZE 36
const char *upkg_get_name(struct upkg *pkg, unsigned long idx);
long upkg_export_find(struct upkg *pkg, const char *name);
+
+unsigned long upkg_export_flags(struct upkg *pkg, unsigned long idx);
const char *upkg_export_name(struct upkg *pkg, unsigned long idx);
const char *upkg_export_class(struct upkg *pkg, unsigned long idx,
const char **package);
projects / upkg.git / commitdiff