#include <uobject/uobject.h>
#include <uobject/module.h>
+#include <uobject/package.h>
#include "upkg.h"
#include "pack.h"
return len;
}
+/*
+ * TODO: Make this use the uobject_module stuff so packages are not loaded
+ * more than once.
+ */
+static GTypeModule *
+open_import_package(UObject *uo, const struct upkg_import *i)
+{
+ GTypeModule *pkg;
+
+ assert(i->parent == NULL);
+
+ if (strcmp(i->class_package, "Core") != 0
+ || strcmp(i->class_name, "Package") != 0) {
+ u_err(uo, "import root must be Core.Package");
+ return NULL;
+ }
+
+ pkg = u_pkg_open(i->name);
+ if (!pkg || !g_type_module_use(pkg)) {
+ u_err(uo, "failed to open package: %s", i->name);
+ return NULL;
+ }
+
+ if (!U_PKG(pkg)->pkg) {
+ g_type_module_unuse(pkg);
+ u_err(uo, "failed to open package: %s", pkg->name);
+ return NULL;
+ }
+
+ return pkg;
+}
+
+/* Find the export index of a package based on the import chain from another
+ * package. Returns the (non-negative) offset on success, or a negative value
+ * on failure. */
+static long resolve_import(struct upkg *pkg, const struct upkg_import *import)
+{
+ long current, index;
+
+ if (!import->parent)
+ return -1;
+
+ current = resolve_import(pkg, import->parent);
+ if (current != -1 && current >= 0)
+ return -42;
+
+ index = upkg_export_find(pkg, current, import->name);
+ if (index < 0)
+ return -42;
+
+ return index;
+}
+
+static GObject *get_import_object(UObject *uo, unsigned long index)
+{
+ const struct upkg_import *import;
+ GObject *obj = NULL;
+ GTypeModule *pkg;
+ long obj_index;
+
+ import = upkg_get_import(uo->pkg_file->pkg, index);
+ if (!import) {
+ u_err(uo, "invalid package import: %ld", index);
+ return NULL;
+ }
+
+ /* Get the package name at the top of the hierarchy. */
+ for (const struct upkg_import *i = import; i; i = i->parent) {
+ if (i->parent == NULL) {
+ pkg = open_import_package(uo, i);
+ if (!pkg)
+ return NULL;
+ }
+ }
+
+ obj_index = resolve_import(U_PKG(pkg)->pkg, import);
+ if (obj_index < 0) {
+ u_err(uo, "could not find import in package: %s", pkg->name);
+ goto out;
+ }
+
+ obj = u_object_new_from_package(pkg, obj_index);
+out:
+ g_type_module_unuse(pkg);
+ return obj;
+}
+
static int decode_object_property(UObject *uo, GValue *val, unsigned long len)
{
struct u_object_priv *priv = U_OBJECT_GET_PRIV(uo);
return -1;
if (index < 0) {
- fprintf(stderr, "Imports not supported yet.\n");
+ obj = get_import_object(uo, -(index+1));
} else {
obj = u_object_new_from_package(uo->pkg, index-1);
}
unsigned long rc, len = 0;
GValue val = {0};
- rc = decode_prop_header(uo->pkg, head, priv->buf, priv->nbuf);
+ rc = decode_prop_header(uo->pkg_file->pkg, head, priv->buf, priv->nbuf);
if (rc == 0)
return 0;
len += rc;
/*
* Get the full hierarchical object name for an export, used for diagnostics.
- * Currently, this does not include the package name (which is actually
- * required for this to be a "full" name) as it's not yet passed to the
- * deserialize method.
+ * The package name is passed in pname.
*
* Returns a buffer allocated by malloc on success, or NULL on failure.
*/
-static char *get_obj_fullname(const struct upkg_export *e)
+static char *get_obj_fullname(const char *pname, const struct upkg_export *e)
{
- size_t total_len = 0, len;
+ size_t total_len = strlen(pname) + 1, len;
char *fullname;
+ assert(e != NULL);
+
for (const struct upkg_export *c = e; c; c = c->parent) {
len = strlen(c->name) + 1;
if (total_len > SIZE_MAX - len)
fullname[total_len + len] = c == e ? '\0' : '.';
}
+ assert(total_len == strlen(pname)+1);
+ memcpy(fullname, pname, total_len-1);
+ fullname[total_len-1] = '.';
+
return fullname;
}
-int u_object_deserialize(GObject *obj, struct upkg *pkg, unsigned long idx)
+int u_object_deserialize(GObject *obj, GTypeModule *pkg, unsigned long idx)
{
g_return_val_if_fail(IS_U_OBJECT(obj), -1);
+ g_return_val_if_fail(IS_U_PKG(pkg), -1);
+
UObject *uo = U_OBJECT(obj);
+ struct upkg *upkg = U_PKG(pkg)->pkg;
const struct upkg_export *e;
struct upkg_file *f;
int rc;
g_return_val_if_fail(uo->pkg_file == NULL, -1);
- f = upkg_export_open(pkg, idx);
+ f = upkg_export_open(upkg, idx);
if (!f) {
return -1;
}
- uo->pkg = pkg;
+ uo->pkg = pkg;
uo->pkg_file = f;
- e = upkg_get_export(pkg, idx);
+ e = upkg_get_export(upkg, idx);
if (!e)
return -1;
- uo->pkg_name = get_obj_fullname(e);
+ uo->pkg_name = get_obj_fullname(pkg->name, e);
if (!uo->pkg_name)
return -1;
return rc;
}
-GObject *u_object_new_from_package(struct upkg *upkg, unsigned long idx)
+GObject *u_object_new_from_package(GTypeModule *pkg, unsigned long idx)
{
- const struct upkg_export *export;
+ g_return_val_if_fail(IS_U_PKG(pkg), NULL);
+
const char *class, *package;
GObject *obj = NULL;
GType type;
- class = upkg_export_class(upkg, idx, &package);
+ class = upkg_export_class(U_PKG(pkg)->pkg, idx, &package);
type = u_object_module_get_class(package, class);
if (type) {
obj = g_object_new(type, NULL);
- if (u_object_deserialize(obj, upkg, idx) != 0) {
+ if (u_object_deserialize(obj, pkg, idx) != 0) {
g_object_unref(obj);
return NULL;
}