Ticket #8397: plugin3.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.
-#ifndef DISABLE_SCUMM
-        LOAD_MODULE("scumm", SCUMM);
-#endif
-
-#ifndef DISABLE_SIMON
-        LOAD_MODULE("simon", SIMON);
-#endif
-
-#ifndef DISABLE_SKY
-        LOAD_MODULE("sky", SKY);
-#endif
-
-#ifndef DISABLE_SWORD1
-        LOAD_MODULE("sword1", SWORD1);
-#endif
+        // 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()));
+                }
+        }
 
-#ifndef DISABLE_SWORD2
-        LOAD_MODULE("sword2", SWORD2);
-#endif
+#else
+        #define LINK_PLUGIN(ID) \
+                extern PluginRegistrator g_##ID##_PluginReg; \
+                plugin = &g_##ID##_PluginReg;
 
-#ifndef DISABLE_QUEEN
-        LOAD_MODULE("queen", QUEEN);
-#endif
+        // "Loader" for the static plugins.
+        // Iterate over all registered (static) plugins and load them.
+        PluginRegistrator *plugin;
+        
+        LINK_PLUGIN(SCUMM)
+        LINK_PLUGIN(SKY)
+        LINK_PLUGIN(SWORD1)
+        LINK_PLUGIN(SWORD2)
+        LINK_PLUGIN(SIMON)
+        LINK_PLUGIN(QUEEN)
+        LINK_PLUGIN(SAGA)
+        //LOAD_PLUGIN(KYRA)
 
-#ifndef DISABLE_KYRA
-        LOAD_MODULE("kyra", KYRA);
+        for (plugin = PluginRegistrator::_head; plugin != 0; plugin = plugin->_next) {
+                tryLoadPlugin(new StaticPlugin(plugin->_name, plugin->_games, plugin->_ef, plugin->_df));
+        }
 #endif
 
-#ifndef DISABLE_SAGA
-        LOAD_MODULE("saga", SAGA);
-#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(ID,name) \
+        PluginRegistrator g_##ID##_PluginReg(name, Engine_##ID##_gameList(), Engine_##ID##_create, Engine_##ID##_detectGames);
 #else
-#define REGISTER_PLUGIN(name,gameListFactory,engineFactory,detectGames) \
+#define REGISTER_PLUGIN(ID,name) \
         extern "C" { \
                 const char *PLUGIN_name() { return name; } \
-                GameList PLUGIN_getSupportedGames() { return gameListFactory(); } \
-                Engine *PLUGIN_createEngine(GameDetector *detector, OSystem *syst) { return engineFactory(detector, syst); } \
-                DetectedGameList PLUGIN_detectGames(const FSList &fslist) { return detectGames(fslist); } \
+                GameList PLUGIN_getSupportedGames() { return Engine_##ID##_gameList(); } \
+                Engine *PLUGIN_createEngine(GameDetector *detector, OSystem *syst) { return Engine_##ID##_create(detector, syst); } \
+                DetectedGameList PLUGIN_detectGames(const FSList &fslist) { return Engine_##ID##_detectGames(fslist); } \
         }
 #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;
@@ -133 +170 @@
 };
 
 
-#ifndef DYNAMIC_MODULES
-
-#define DECLARE_PLUGIN(name) \
-        extern GameList Engine_##name##_gameList(); \
-        extern Engine *Engine_##name##_create(GameDetector *detector, OSystem *syst); \
-        extern DetectedGameList Engine_##name##_detectGames(const FSList &fslist);
-
-// Factory functions => no need to include the specific classes
-// in this header. This serves two purposes:
-// 1) Clean separation from the game modules (scumm, simon) and the generic code
-// 2) Faster (compiler doesn't have to parse lengthy header files)
-#ifndef DISABLE_SCUMM
-DECLARE_PLUGIN(SCUMM)
-#endif
-
-#ifndef DISABLE_SIMON
-DECLARE_PLUGIN(SIMON)
-#endif
-
-#ifndef DISABLE_SKY
-DECLARE_PLUGIN(SKY)
-#endif
-
-#ifndef DISABLE_SWORD1
-DECLARE_PLUGIN(SWORD1)
-#endif
-
-#ifndef DISABLE_SWORD2
-DECLARE_PLUGIN(SWORD2)
-#endif
-
-#ifndef DISABLE_QUEEN
-DECLARE_PLUGIN(QUEEN)
-#endif
-
-#ifndef DISABLE_KYRA
-DECLARE_PLUGIN(KYRA)
-#endif
-
-#ifndef DISABLE_SAGA
-DECLARE_PLUGIN(SAGA)
-#endif
-
-#endif
-
 #endif

kyra/kyra.cpp

@@ -95 +95 @@
         return new Kyra::KyraEngine(detector, syst);
 }
 
-REGISTER_PLUGIN("Legend of Kyrandia Engine", Engine_KYRA_gameList, Engine_KYRA_create, Engine_KYRA_detectGames)
+REGISTER_PLUGIN(KYRA, "Legend of Kyrandia Engine")
 
 namespace Kyra {
 KyraEngine::KyraEngine(GameDetector *detector, OSystem *syst)

queen/queen.cpp

@@ -83 +83 @@
         return new Queen::QueenEngine(detector, syst);
 }
 
-REGISTER_PLUGIN("Flight of the Amazon Queen", Engine_QUEEN_gameList, Engine_QUEEN_create, Engine_QUEEN_detectGames)
+REGISTER_PLUGIN(QUEEN, "Flight of the Amazon Queen")
 
 namespace Queen {
 

saga/saga.cpp

@@ -105 +105 @@
         return new Saga::SagaEngine(detector, syst);
 }
 
-REGISTER_PLUGIN("SAGA Engine", Engine_SAGA_gameList, Engine_SAGA_create, Engine_SAGA_detectGames)
+REGISTER_PLUGIN(SAGA, "SAGA Engine")
 
 namespace Saga {
 

scumm/scumm.cpp

@@ -3021 +3021 @@
         return engine;
 }
 
-REGISTER_PLUGIN("Scumm Engine", Engine_SCUMM_gameList, Engine_SCUMM_create, Engine_SCUMM_detectGames)
+REGISTER_PLUGIN(SCUMM, "Scumm Engine")

simon/simon.cpp

@@ -159 +159 @@
         return new Simon::SimonEngine(detector, syst);
 }
 
-REGISTER_PLUGIN("Simon the Sorcerer", Engine_SIMON_gameList, Engine_SIMON_create, Engine_SIMON_detectGames)
+REGISTER_PLUGIN(SIMON, "Simon the Sorcerer")
 
 namespace Simon {
 

sky/sky.cpp

@@ -106 +106 @@
         return new Sky::SkyEngine(detector, syst);
 }
 
-REGISTER_PLUGIN("Beneath a Steel Sky", Engine_SKY_gameList, Engine_SKY_create, Engine_SKY_detectGames)
+REGISTER_PLUGIN(SKY, "Beneath a Steel Sky")
 
 
 namespace Sky {

sword1/sword1.cpp

@@ -112 +112 @@
         return new SwordEngine(detector, syst);
 }
 
-REGISTER_PLUGIN("Broken Sword", Engine_SWORD1_gameList, Engine_SWORD1_create, Engine_SWORD1_detectGames)
+REGISTER_PLUGIN(SWORD1, "Broken Sword")
 
 namespace Sword1 {
 

sword2/sword2.cpp

@@ -102 +102 @@
         return new Sword2::Sword2Engine(detector, syst);
 }
 
-REGISTER_PLUGIN("Broken Sword II", Engine_SWORD2_gameList, Engine_SWORD2_create, Engine_SWORD2_detectGames)
+REGISTER_PLUGIN(SWORD2, "Broken Sword II")
 
 namespace Sword2 {