Ticket #8397: plugin.patch

common.rules

@@ -10 +10 @@
 # TODO: Right now, for Mac OS X only. We either will have to generate this
 # via the configure script, or put in some 'if' statements to choose from
 # one of several build rules
-PLUGIN-$(MODULE) := $(MODULE)/$(PLUGIN_PREFIX)$(MODULE)$(PLUGIN_SUFFIX)
+PLUGIN-$(MODULE) := plugins/$(PLUGIN_PREFIX)$(MODULE)$(PLUGIN_SUFFIX)
 $(PLUGIN-$(MODULE)): $(MODULE_OBJS) $(PLUGIN_EXTRA_DEPS)
+        $(MKDIR) plugins
         $(CXX) $(PLUGIN_LDFLAGS) $(filter-out $(PLUGIN_EXTRA_DEPS),$+) -o $@
 PLUGIN:=
 plugins: $(PLUGIN-$(MODULE))

base/plugins.cpp

@@ -39 +39 @@
 
 #ifdef UNIX
 #include <dlfcn.h>
-#define DYNAMIC_PLUGIN_PATH(name) (name "/" PLUGIN_PREFIX name PLUGIN_SUFFIX)
+#define PLUGIN_DIRECTORY        "plugins/"
 #else
 #ifdef __DC__
 #include "dcloader.h"
-#define DYNAMIC_PLUGIN_PATH(name) (name ".plg")
+#define PLUGIN_DIRECTORY        ""
+#define PLUGIN_PREFIX           ""
+#define PLUGIN_SUFFIX           ".plg"
 #else
 #error No support for loading plugins on non-unix systems at this point!
 #endif
 #endif
 
+
+#else
+
+PluginRegistrator *PluginRegistrator::_head = 0;
+
+PluginRegistrator::PluginRegistrator(const char *name, GameList games, EngineFactory ef, DetectFunc df)
+        : _name(name), _ef(ef), _df(df), _games(games) {
+        printf("Automatically registered plugin '%s'\n", name);
+        _next = _head;
+        _head = this;
+}
+
 #endif
 
 
@@ -108 +122 @@
         void *findSymbol(const char *symbol);
 
 public:
-        DynamicPlugin(const char *filename)
+        DynamicPlugin(const Common::String &filename)
                 : _dlHandle(0), _filename(filename), _ef(0), _df(0), _games() {}
 
         const char *getName() const                                     { return _name.c_str(); }
@@ -222 +236 @@
         // Hence one more symbol should be exported by plugins which returns
         // the "ABI" version the plugin was built for, and we can compare that
         // to the ABI version of the executable.
-        #define LOAD_MODULE(name, NAME) \
-                tryLoadPlugin(new DynamicPlugin(DYNAMIC_PLUGIN_PATH(name)));
-#else
-        // "Loader" for the static plugins
-        #define LOAD_MODULE(name, NAME) \
-                tryLoadPlugin(new StaticPlugin(name, Engine_##NAME##_gameList(), Engine_##NAME##_create, Engine_##NAME##_detectGames));
-#endif
 
         // Load all plugins.
         // Right now the list is hardcoded. On the long run, of course it should
         // automatically be determined.
+#if 0
+        static const char *plugin_names[] = {
 #ifndef DISABLE_SCUMM
-        LOAD_MODULE("scumm", SCUMM);
+                "scumm",
 #endif
-
 #ifndef DISABLE_SIMON
-        LOAD_MODULE("simon", SIMON);
+                "simon",
 #endif
-
 #ifndef DISABLE_SKY
-        LOAD_MODULE("sky", SKY);
+                "sky",
 #endif
-
 #ifndef DISABLE_SWORD1
-        LOAD_MODULE("sword1", SWORD1);
+                "sword1",
 #endif
-
 #ifndef DISABLE_SWORD2
-        LOAD_MODULE("sword2", SWORD2);
+                "sword2",
 #endif
-
 #ifndef DISABLE_QUEEN
-        LOAD_MODULE("queen", QUEEN);
+                "queen",
 #endif
-
 #ifndef DISABLE_KYRA
-        LOAD_MODULE("kyra", KYRA);
+                "kyra",
 #endif
-
 #ifndef DISABLE_SAGA
-        LOAD_MODULE("saga", SAGA);
+                "saga",
+#endif
+                0
+        };
+        const char **plugin;
+        for (plugin = plugin_names; *plugin != 0; plugin++) {
+                Common::String path(PLUGIN_DIRECTORY);
+                path += PLUGIN_PREFIX;
+                path += *plugin;
+                path += PLUGIN_SUFFIX;
+                tryLoadPlugin(new DynamicPlugin(path));
+        }
+#else
+        // Scan for all plugins in this directory
+        FilesystemNode dir(PLUGIN_DIRECTORY);
+        FSList files(dir.listDir(FilesystemNode::kListFilesOnly));
+        
+        for (FSList::const_iterator i = files.begin(); i != files.end(); ++i) {
+                Common::String name(i->displayName());
+                if (name.hasPrefix(PLUGIN_PREFIX) && name.hasSuffix(PLUGIN_SUFFIX)) {
+                        tryLoadPlugin(new DynamicPlugin(i->path()));
+                }
+        }
+
 #endif
+
+#else
+        // "Loader" for the static plugins.
+        // Iterate over all registered (static) plugins and load them.
+        PluginRegistrator *plugin = PluginRegistrator::_head;
+        for (; plugin != 0; plugin = plugin->_next) {
+                tryLoadPlugin(new StaticPlugin(plugin->_name, plugin->_games, plugin->_ef, plugin->_df));
+        }
+#endif
+
 }
 
 void PluginManager::unloadPlugins() {

base/plugins.h

@@ -78 +78 @@
 
 
 /**
- * The REGISTER_PLUGIN is a convenience macro meant to ease writing
+ * REGISTER_PLUGIN is a convenience macro meant to ease writing
  * the plugin interface for our modules. In particular, using it
  * makes it possible to compile the very same code in a module
  * both as a static and a dynamic plugin.
@@ -87 +87 @@
  * @todo        on Windows, we might need __declspec(dllexport) ?
  */
 #ifndef DYNAMIC_MODULES
-#define REGISTER_PLUGIN(name,gameListFactory,engineFactory,detectGames)
+#define REGISTER_PLUGIN(name,gameListFactory,engineFactory,detectGames) \
+        static PluginRegistrator pluginReg(name, gameListFactory(), engineFactory, detectGames);
 #else
 #define REGISTER_PLUGIN(name,gameListFactory,engineFactory,detectGames) \
         extern "C" { \
@@ -98 +99 @@
         }
 #endif
 
+#ifndef DYNAMIC_MODULES
+/**
+ * The PluginRegistrator class is used by the static version of REGISTER_PLUGIN
+ * to allow static 'plugins' to automatically register with the PluginManager.
+ * The trick is to put a global instance of PluginRegistrator into each engine.
+ * Then when the application is started, the constructor of each of these
+ * objects is run. They then hook themselves into a linked list, and store
+ * all data passed to them, which the PluginManager then can use to load
+ * and initialize the static plugins.
+ * Neat, isn't it ? ;-)
+ *
+ * Caveat: there may be systems / linkers where this trick doesn't work because
+ * the linker doesn't invoke the object constructors. This system has currently
+ * been tested on Mac OS X only.
+ */
+class PluginRegistrator {
+        friend class PluginManager;
+public:
+        typedef Engine *(*EngineFactory)(GameDetector *detector, OSystem *syst);
+        typedef DetectedGameList (*DetectFunc)(const FSList &fslist);
+
+protected:
+        static PluginRegistrator *_head;
+        
+        PluginRegistrator *_next;
+
+        const char *_name;
+        EngineFactory _ef;
+        DetectFunc _df;
+        GameList _games;
+
+public:
+        PluginRegistrator(const char *name, GameList games, EngineFactory ef, DetectFunc df);
+};
+#endif
+
 
 /** List of plugins. */
 typedef Common::Array<Plugin *> PluginList;