From 3f26c19b0b7a9fa73c58189788972ea43b72f014 Mon Sep 17 00:00:00 2001
From: Mike Buland <eichlan@xagasoft.com>
Date: Mon, 25 Jun 2007 21:15:55 +0000
Subject: I think the plugger and programchain are all up to date to work with
 the new libbu++.  The program chain may undergo heavy changes still, or be
 removed entirely, but we need it for congo and squirrelmud, so here it is for
 a while longer.

The TafWriter isn't much closer, you still only get the groups in the output.
---
 src/plugger.h | 196 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 196 insertions(+)
 create mode 100644 src/plugger.h

(limited to 'src/plugger.h')

diff --git a/src/plugger.h b/src/plugger.h
new file mode 100644
index 0000000..98d4ecc
--- /dev/null
+++ b/src/plugger.h
@@ -0,0 +1,196 @@
+#ifndef PLUGGER_H
+#define PLUGGER_H
+
+
+#include "bu/hash.h"
+#include "bu/list.h"
+#include <dlfcn.h>
+#include "bu/exceptions.h"
+#include "bu/fstring.h"
+
+namespace Bu
+{
+	typedef struct PluginInfo
+	{
+		const char *sID;
+		const char *sAuthor;
+		unsigned short nVersion;
+		unsigned short nRevision;
+		void *(*createPlugin)();
+		void (*destroyPlugin)( void * );
+	} PluginInfo;
+
+	typedef struct PluginReg
+	{
+		bool bBuiltin;
+		void *dlHandle;
+		PluginInfo *pInfo;
+	} PluginReg;
+
+#define PluginInterface( classname, baseclass, name, ver, rev )			\
+	extern "C" {															\
+		baseclass *create ##classname()								\
+		{																	\
+			return new classname();											\
+		}																	\
+		void destroy ##classname( baseclass *pCls )					\
+		{																	\
+			delete pCls;													\
+		}																	\
+		PluginInfo classname = {						\
+			#classname, name, ver, rev,										\
+			create ##classname, destroy ##classname };						\
+	}
+
+#define PluginInterface2( pluginname, classname, baseclass, name, ver, rev ) \
+	extern "C" {															\
+		baseclass *create ##classname()										\
+		{																	\
+			return new classname();											\
+		}																	\
+		void destroy ##classname( baseclass *pCls )							\
+		{																	\
+			delete pCls;													\
+		}																	\
+		PluginInfo pluginname = {											\
+			#pluginname, name, ver, rev,									\
+			(void *(*)())(create ##classname),								\
+			(void (*)( void * ))(destroy ##classname) };					\
+	}
+
+#define PluginInterface3( structname, pluginname, classname, baseclass, name, ver, rev ) \
+	extern "C" {															\
+		baseclass *create ##classname()										\
+		{																	\
+			return new classname();											\
+		}																	\
+		void destroy ##classname( baseclass *pCls )							\
+		{																	\
+			delete pCls;													\
+		}																	\
+		PluginInfo structname = {											\
+			#pluginname, name, ver, rev,									\
+			(void *(*)())(create ##classname),								\
+			(void (*)( void * ))(destroy ##classname) };					\
+	}
+
+	template<class T>
+	class Plugger
+	{
+	public:
+		typedef Bu::Hash<Bu::FString, PluginReg *> PluginHash;
+		typedef Bu::Hash<int, void *> InstHash;
+
+	public:
+		Plugger()
+		{
+		}
+
+		virtual ~Plugger()
+		{
+			for( InstHash::iterator i = hObj.begin(); i != hObj.end(); i++ )
+			{
+				T *pPlug = (T *)i.getKey();
+				PluginReg *pReg = (PluginReg *)*i;
+				pReg->pInfo->destroyPlugin( pPlug );
+			}
+
+			for( PluginHash::iterator i = hPlugin.begin();
+				 i != hPlugin.end(); i++ )
+			{
+				if( (*i)->bBuiltin == false )
+				{
+					dlclose( (*i)->dlHandle );
+				}
+				delete (*i);
+			}
+		}
+
+		void registerBuiltinPlugin( PluginInfo *pInfo )
+		{
+			PluginReg *pReg = new PluginReg;
+			pReg->bBuiltin = true;
+			pReg->pInfo = pInfo;
+			hPlugin.insert( pInfo->sID, pReg );
+		}
+
+		void registerExternalPlugin( const char *sFName, const char *sPluginName )
+		{
+			PluginReg *pReg = (PluginReg *)hPlugin[sPluginName];
+			if( pReg != NULL )
+			{
+				hPlugin.erase( sPluginName );
+				dlclose( pReg->dlHandle );
+				delete pReg;
+				pReg = NULL;
+			}
+
+			pReg = new PluginReg;
+
+			pReg->bBuiltin = false;
+			pReg->dlHandle = dlopen( sFName, RTLD_NOW );
+			if( pReg->dlHandle == NULL )
+			{
+				throw PluginException( 1, "Error on %s: %s", sFName, dlerror() );
+			}
+			pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle, sPluginName );
+			if( pReg->pInfo == NULL )
+			{
+				throw PluginException( 2, "Error on %s: %s", sFName, dlerror() );
+			}
+			hPlugin.insert( pReg->pInfo->sID, pReg );
+		}
+
+		T *instantiate( const char *lpName )
+		{
+			PluginReg *pReg = (PluginReg *)hPlugin[lpName];
+			if( pReg == NULL )
+				return NULL;
+
+			T *p = (T *)pReg->pInfo->createPlugin();
+			hObj.insert( p, pReg );
+			//printf("pReg:  %08X, pPlug: %08X\n", pReg, p );
+		
+			return p;
+		}
+
+		bool hasPlugin( const char *lpName )
+		{
+			if( hPlugin[lpName] == NULL )
+				return false;
+			return true;
+		}
+
+		void destroy( T *pPlug )
+		{
+			PluginReg *pReg = (PluginReg *)hObj[pPlug];
+			//printf("pReg:  %08X, pPlug: %08X\n", pReg, pPlug );
+			if( pReg == NULL )
+				return;
+
+			pReg->pInfo->destroyPlugin( pPlug );
+
+			hObj.erase( pPlug );
+		}
+
+		void unloadAll()
+		{
+			for( PluginHash::iterator i = hPlugin.begin();
+				 i != hPlugin.end(); i++ )
+			{
+				if( (*i)->bBuiltin == false )
+				{
+					dlclose( (*i)->dlHandle );
+				}
+				delete (*i);
+			}
+			hPlugin.clear();
+		}
+
+	private:
+		PluginHash hPlugin;
+		InstHash hObj;
+	};
+}
+
+#endif
-- 
cgit v1.2.3