src/uobject/module.c

   1 /*
   2  * upkg: tool for manipulating Unreal Tournament packages.
   3  * Copyright © 2009-2012, 2022 Nick Bowler
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <config.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <ctype.h>
  24 #include <glib-object.h>
  25 #include <ltdl.h>
  26
  27 #include <uobject/module.h>
  28 #include <uobject/uobject.h>
  29 #include <uobject/package.h>
  30 #include <upkg.h>
  31 #include "avl.h"
  32
  33 static unsigned initialized;
  34 static struct avl_table *package_tree;
  35
  36 static char *str_cpy_lower(char *dst, const char *src)
  37 {
  38         size_t i;
  39
  40         for (i = 0; src[i]; i++)
  41                 dst[i] = tolower(src[i]);
  42         dst[i] = 0;
  43
  44         return dst;
  45 }
  46
  47 static int modcmp(const void *a, const void *b, void *_data)
  48 {
  49         const GTypeModule *ma = a;
  50         const GTypeModule *mb = b;
  51
  52         return strcmp(ma->name, mb->name);
  53 }
  54
  55 int u_object_module_init(void)
  56 {
  57         if (!initialized) {
  58                 package_tree = avl_create(modcmp, NULL, NULL);
  59                 if (!package_tree) {
  60                         fprintf(stderr, "%s: failed to create package tree.\n", __func__);
  61                         return -1;
  62                 }
  63
  64                 g_type_init();
  65         }
  66
  67         initialized++;
  68         return 0;
  69 }
  70
  71 int u_object_module_exit(void)
  72 {
  73         if (--initialized)
  74                 return 0;
  75
  76         avl_destroy(package_tree, NULL);
  77
  78         return 0;
  79 }
  80
  81 static int lookup_module(GTypeModule **out, const char *name)
  82 {
  83         struct { GTypeModule pkg; char buf[]; } *search_key;
  84         GTypeModule *result;
  85
  86         search_key = malloc(sizeof *search_key + strlen(name) + 1);
  87         if (!search_key)
  88                 return -1;
  89
  90         search_key->pkg = (GTypeModule) {
  91                 .name = str_cpy_lower(search_key->buf, name),
  92         };
  93
  94         result = avl_find(package_tree, search_key);
  95         free(search_key);
  96
  97         *out = result;
  98         return 0;
  99 }
 100
 101 GTypeModule *
 102 u_module_get_from_import(GTypeModule *pkg, const struct upkg_import *i)
 103 {
 104         GTypeModule *result;
 105
 106         while (i->parent != NULL)
 107                 i = i->parent;
 108
 109         if (strcmp(i->class_package, "Core") != 0
 110             || strcmp(i->class_name, "Package") != 0) {
 111                 u_err(pkg, "import root must be an instance of Core.Package");
 112                 return NULL;
 113         }
 114
 115         if (lookup_module(&result, i->name) != 0) {
 116                 u_err(pkg, "fatal error performing package lookup");
 117                 return NULL;
 118         }
 119
 120         if (!result) {
 121                 void **p;
 122
 123                 result = u_pkg_open(i->name);
 124                 if (!result) {
 125                         u_warn(pkg, "failed to open package: %s", i->name);
 126                         return NULL;
 127                 }
 128
 129                 p = avl_probe(package_tree, result);
 130                 if (!p) {
 131                         u_err(pkg, "fatal error inserting package");
 132                         g_object_unref(result);
 133                         return NULL;
 134                 }
 135         }
 136
 137         return result;
 138 }
 139
 140 GType u_object_module_get_class(GTypeModule *pkg, long class)
 141 {
 142         GTypeModule *mod;
 143         const char *classname;
 144
 145         if (class == 0) {
 146                 u_warn(pkg, "class implementations not supported yet");
 147                 return 0;
 148         } else if (class < 0) {
 149                 const struct upkg_import *import;
 150
 151                 import = upkg_get_import(U_PKG(pkg)->pkg, -(class+1));
 152                 if (!import) {
 153                         u_err(pkg, "invalid package import: %ld", -(class+1));
 154                         return 0;
 155                 }
 156
 157                 mod = u_module_get_from_import(pkg, import);
 158                 if (!mod)
 159                         return 0;
 160
 161                 classname = import->name;
 162         } else if (class > 0) {
 163                 const struct upkg_export *export;
 164
 165                 export = upkg_get_export(U_PKG(pkg)->pkg, class-1);
 166                 if (!export) {
 167                         u_err(pkg, "invalid package export: %ld", class-1);
 168                         return 0;
 169                 }
 170
 171                 mod = pkg;
 172                 classname = export->name;
 173         }
 174
 175         if (!g_type_module_use(mod))
 176                 return 0;
 177
 178         /* XXX: Do this better. */
 179         char typename[strlen(mod->name) + strlen(classname) + 1];
 180         str_cpy_lower(typename, mod->name);
 181         str_cpy_lower(typename+strlen(mod->name), classname);
 182         typename[0] = toupper(typename[0]);
 183         typename[strlen(mod->name)] = toupper(typename[strlen(mod->name)]);
 184
 185         return g_type_from_name(typename);
 186 }