X-Git-Url: https://git.draconx.ca/gitweb/upkg.git/blobdiff_plain/d323b189345af7ff63c37f7501b70d0674cb74a4..559bcf15ef66d20d7e8527c690c0b4e5a66b6381:/src/upkg.c diff --git a/src/upkg.c b/src/upkg.c index 2c268b4..c13a867 100644 --- a/src/upkg.c +++ b/src/upkg.c @@ -1,6 +1,6 @@ /* * upkg: tool for manipulating Unreal Tournament packages. - * Copyright (C) 2009 Nick Bowler + * Copyright © 2009-2011 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 @@ -19,6 +19,8 @@ #include #include #include +#include +#include #include #include @@ -29,9 +31,11 @@ #include #include #include +#include enum { MODE_INFO, + MODE_LIST, MODE_EXPORT, MODE_MAX }; @@ -39,10 +43,12 @@ enum { int verbose = 0; static const char *progname = "upkg"; -static const char *sopts = "ixvVH"; +static const char *sopts = "ilxvf:VH"; static const struct option lopts[] = { { "info", 0, NULL, 'i' }, + { "list", 0, NULL, 'l' }, { "export", 0, NULL, 'x' }, + { "file", 1, NULL, 'f' }, { "verbose", 0, NULL, 'v' }, { "version", 0, NULL, 'V' }, { "help", 0, NULL, 'H' }, @@ -62,7 +68,7 @@ There is NO WARRANTY, to the extent permitted by law." void print_usage(FILE *f) { - fprintf(f, "Usage: %s [options] package\n", progname); + fprintf(f, "Usage: %s [options] [object ...]\n", progname); } void print_help(void) @@ -177,18 +183,18 @@ void print_guid(unsigned char guid[static 16]) void print_upkg_exports(struct upkg *pkg) { for (unsigned i = 0; i < pkg->export_count; i++) { - const char *name, *package, *class; + const struct upkg_export *export = upkg_get_export(pkg, i); + const char *package, *class; - name = upkg_export_name(pkg, i); class = upkg_export_class(pkg, i, &package); - if (!name || !class) + if (!class) continue; - printf("%u - %s (%s.%s)\n", i+1, name, package, class); - printf(" Flags: %lx\n", upkg_export_flags(pkg, i)); + printf("%u - %s (%s.%s)\n", i+1, export->name, package, class); + printf(" Flags: %lx\n", export->flags); if (verbose >= 2) { - print_upkg_object_flags(" ", upkg_export_flags(pkg, i)); + print_upkg_object_flags(" ", export->flags); } } } @@ -216,11 +222,96 @@ int package_info(struct upkg *pkg) if (verbose >= 1) print_upkg_exports(pkg); printf("Imports: %lu\n", pkg->import_count); - return EXIT_SUCCESS; + return 0; +} + +static void export_print_name(struct upkg *upkg, const struct upkg_export *e) +{ + if (e) { + export_print_name(upkg, upkg_get_export(upkg, e->package-1)); + printf(".%s", e->name); + } +} + +static void +export_print_fullname(GTypeModule *pkg, const struct upkg_export *export) +{ + printf("%s", pkg->name); + export_print_name(U_PKG(pkg)->pkg, export); +} + +static int package_list(GTypeModule *pkg, long parent) +{ + struct upkg *upkg = U_PKG(pkg)->pkg; + const struct upkg_export *export; + + for (unsigned i = 0; i < upkg->export_count; i++) { + export = upkg_get_export(upkg, i); + + if (export->package != parent) + continue; + + export_print_fullname(pkg, export); + + if (verbose >= 1) { + const char *class, *package; + + class = upkg_export_class(upkg, i, &package); + printf(" (%s.%s)", package, class); + } + + putchar('\n'); + } +} + +static int object_info(GTypeModule *pkg, unsigned long idx) +{ + struct upkg *upkg = U_PKG(pkg)->pkg; + const struct upkg_export *export; + const char *class, *package; + + export = upkg_get_export(upkg, idx); + export_print_fullname(pkg, export); + + class = upkg_export_class(upkg, idx, &package); + printf(" (%s.%s)\n", package, class); + + if (verbose >= 1) { + GParamSpec **props; + GObject *obj; + unsigned n; + + obj = u_object_new_from_package(upkg, idx); + if (!obj) { + fprintf(stderr, "%s: failed to load object.\n", + progname); + return -1; + } + + props = g_object_class_list_properties(G_OBJECT_GET_CLASS(obj), &n); + for (unsigned i = 0; i < n; i++) { + GValue val = {0}; + char *valstr; + + printf(" %s: ", props[i]->name); + fflush(stdout); + + g_value_init(&val, props[i]->value_type); + g_object_get_property(obj, props[i]->name, &val); + valstr = g_strdup_value_contents(&val); + printf("%s\n", valstr); + } + free(props); + + g_object_unref(obj); + } + + return 0; } static int export(struct upkg *pkg, GObject *obj, unsigned idx) { + const struct upkg_export *export = upkg_get_export(pkg, idx); char name[256]; FILE *of; @@ -234,7 +325,7 @@ static int export(struct upkg *pkg, GObject *obj, unsigned idx) u_object_export_name(obj, name, sizeof name); - printf("exporting %s to %s\n", upkg_export_name(pkg, idx), name); + printf("exporting %s to %s\n", export->name, name); of = fopen(name, "wb"); if (!of) { perror(name); @@ -260,13 +351,13 @@ int package_export(struct upkg *pkg) const char *class, *package; GObject *obj; GType type; - int rc = EXIT_SUCCESS; + int ret = 0; for (unsigned i = 0; i < pkg->export_count; i++) { class = upkg_export_class(pkg, i, &package); if (!class) { fprintf(stderr, "error getting class information.\n"); - return EXIT_FAILURE; + return -1; } type = u_object_module_get_class(package, class); @@ -275,28 +366,116 @@ int package_export(struct upkg *pkg) obj = g_object_new(type, NULL); if (U_OBJECT_IS_EXPORTABLE(obj)) { if (export(pkg, obj, i) != 0) { - rc = EXIT_FAILURE; + ret = -1; } } g_object_unref(obj); } - return rc; + return ret; +} + +static int process_object(int mode, const char *objname) +{ + char work[strlen(objname)+1], *p = work, *c; + GTypeModule *pkg; + long current = -1; + int ret = 0; + + strcpy(work, objname); + + /* First, find and open the actual package. */ + c = strchr(p, '.'); + if (c) *c = 0; + + pkg = u_pkg_open(p); + if (!pkg || !g_type_module_use(pkg)) { + fprintf(stderr, "%s: %s: failed to open package.\n", + progname, work); + goto out; + } + + if (!U_PKG(pkg)->pkg) { + if (u_pkg_is_native(pkg)) { + fprintf(stderr, "%s: %s: not a UObject package.\n", + progname, work); + } else { + fprintf(stderr, "%s: %s: package not found.\n", + progname, work); + } + + goto out_unuse; + } + + /* Resolve the hierarchical reference. */ + while (c) { + p = c+1; + c = strchr(p, '.'); + if (c) *c = 0; + + current = upkg_export_find(U_PKG(pkg)->pkg, current, p); + if (current == -1) { + /* We want to print the full name up to this point. */ + strcpy(work, objname); + if (c) *c = 0; + + fprintf(stderr, "%s: %s: object not found.\n", + progname, work); + goto out_unuse; + } + } + + switch (mode) { + case MODE_INFO: + if (current < 0) + ret = package_info(U_PKG(pkg)->pkg); + else + ret = object_info(pkg, current); + break; + case MODE_LIST: + ret = package_list(pkg, current+1); + break; + case MODE_EXPORT: + ret = package_export(U_PKG(pkg)->pkg); + break; + default: + abort(); + } + +out_unuse: + g_type_module_unuse(pkg); +out: + return ret; } int main(int argc, char **argv) { - UPkg *upkg; + const char *pkgname = NULL; unsigned mode = MODE_INFO; - int opt, rc = EXIT_FAILURE; + int opt, rc; if (argc > 0) progname = argv[0]; + if (u_pkg_vfs_init() != 0) + return EXIT_FAILURE; + if (u_object_module_init() != 0) + return EXIT_FAILURE; + while ((opt = getopt_long(argc, argv, sopts, lopts, NULL)) != -1) { switch (opt) { + case 'f': + pkgname = u_pkg_vfs_add_local(NULL, optarg); + if (!pkgname) { + fprintf(stderr, "failed to add package `%s'.\n", optarg); + return EXIT_FAILURE; + } + break; case 'i': mode = MODE_INFO; break; + case 'l': + mode = MODE_LIST; + break; case 'x': mode = MODE_EXPORT; break; @@ -315,30 +494,23 @@ int main(int argc, char **argv) } } - if (argv[optind] == NULL) { + if (!pkgname && !argv[optind]) { print_usage(stderr); return EXIT_FAILURE; } - if (u_object_module_init() != 0) - return EXIT_FAILURE; - - upkg = U_PKG(u_pkg_new_by_file(argv[optind])); - if (!upkg) { - fprintf(stderr, "failed to open package!\n"); - return EXIT_FAILURE; - } - - switch (mode) { - case MODE_INFO: - rc = package_info(upkg->pkg); - break; - case MODE_EXPORT: - rc = package_export(upkg->pkg); - break; + rc = EXIT_SUCCESS; + if (argv[optind]) { + for (int i = optind; i < argc; i++) { + if (process_object(mode, argv[i]) != 0) + rc = EXIT_FAILURE; + } + } else { + if (process_object(mode, pkgname) != 0) + rc = EXIT_FAILURE; } - g_object_unref(upkg); u_object_module_exit(); + u_pkg_vfs_exit(); return rc; }