radiant/server.cpp

   1 /*
   2    Copyright (C) 2001-2006, William Joseph.
   3    All Rights Reserved.
   4
   5    This file is part of GtkRadiant.
   6
   7    GtkRadiant is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    GtkRadiant is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GtkRadiant; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #include "server.h"
  23
  24 #include "debugging/debugging.h"
  25 #include "warnings.h"
  26
  27 #include <vector>
  28 #include <map>
  29 #include "os/path.h"
  30
  31 #include "modulesystem.h"
  32
  33 class RadiantModuleServer : public ModuleServer
  34 {
  35 typedef std::pair<std::string, int> ModuleType;
  36 typedef std::pair<ModuleType, std::string> ModuleKey;
  37 typedef std::map<ModuleKey, Module*> Modules_;
  38 Modules_ m_modules;
  39 bool m_error;
  40
  41 public:
  42 RadiantModuleServer() : m_error( false ){
  43 }
  44
  45 void setError( bool error ){
  46         m_error = error;
  47 }
  48 bool getError() const {
  49         return m_error;
  50 }
  51
  52 TextOutputStream& getOutputStream(){
  53         return globalOutputStream();
  54 }
  55 TextOutputStream& getErrorStream(){
  56         return globalErrorStream();
  57 }
  58 DebugMessageHandler& getDebugMessageHandler(){
  59         return globalDebugMessageHandler();
  60 }
  61
  62 void registerModule( const char* type, int version, const char* name, Module& module ){
  63         ASSERT_NOTNULL( &module );
  64         if ( !m_modules.insert( Modules_::value_type( ModuleKey( ModuleType( type, version ), name ), &module ) ).second ) {
  65                 globalErrorStream() << "module already registered: type=" << makeQuoted( type ) << " name=" << makeQuoted( name ) << "\n";
  66         }
  67         else
  68         {
  69                 globalOutputStream() << "Module Registered: type=" << makeQuoted( type ) << " version=" << makeQuoted( version ) << " name=" << makeQuoted( name ) << "\n";
  70         }
  71 }
  72
  73 Module* findModule( const char* type, int version, const char* name ) const {
  74         Modules_::const_iterator i = m_modules.find( ModuleKey( ModuleType( type, version ), name ) );
  75         if ( i != m_modules.end() ) {
  76                 return ( *i ).second;
  77         }
  78         return 0;
  79 }
  80
  81 void foreachModule( const char* type, int version, const Visitor& visitor ){
  82         for ( Modules_::const_iterator i = m_modules.begin(); i != m_modules.end(); ++i )
  83         {
  84                 if ( string_equal( ( *i ).first.first.first.c_str(), type ) ) {
  85                         visitor.visit( ( *i ).first.second.c_str(), *( *i ).second );
  86                 }
  87         }
  88 }
  89 };
  90
  91
  92 #if defined( WIN32 )
  93
  94 #include <windows.h>
  95
  96 #define FORMAT_BUFSIZE 2048
  97 const char* FormatGetLastError(){
  98         static char buf[FORMAT_BUFSIZE];
  99         FormatMessage(
 100                 FORMAT_MESSAGE_FROM_SYSTEM |
 101                 FORMAT_MESSAGE_IGNORE_INSERTS,
 102                 NULL,
 103                 GetLastError(),
 104                 MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), // Default language
 105                 buf,
 106                 FORMAT_BUFSIZE,
 107                 NULL
 108                 );
 109         return buf;
 110 }
 111
 112 class DynamicLibrary
 113 {
 114 HMODULE m_library;
 115 public:
 116 typedef int ( __stdcall * FunctionPointer )();
 117
 118 DynamicLibrary( const char* filename ){
 119         m_library = LoadLibrary( filename );
 120         if ( m_library == 0 ) {
 121                 globalErrorStream() << "LoadLibrary failed: '" << filename << "'\n";
 122                 globalErrorStream() << "GetLastError: " << FormatGetLastError();
 123         }
 124 }
 125 ~DynamicLibrary(){
 126         if ( !failed() ) {
 127                 FreeLibrary( m_library );
 128         }
 129 }
 130 bool failed(){
 131         return m_library == 0;
 132 }
 133 FunctionPointer findSymbol( const char* symbol ){
 134         FunctionPointer address = (FunctionPointer) GetProcAddress( m_library, symbol );
 135         if ( address == 0 ) {
 136                 globalErrorStream() << "GetProcAddress failed: '" << symbol << "'\n";
 137                 globalErrorStream() << "GetLastError: " << FormatGetLastError();
 138         }
 139         return address;
 140 }
 141 };
 142
 143 #elif defined( POSIX )
 144
 145 #include <dlfcn.h>
 146
 147 class DynamicLibrary
 148 {
 149 void* m_library;
 150 public:
 151 typedef int ( *FunctionPointer )();
 152
 153 DynamicLibrary( const char* filename ){
 154         m_library = dlopen( filename, RTLD_NOW|RTLD_LOCAL|RTLD_DEEPBIND );
 155         if ( !m_library )
 156         {
 157                 globalErrorStream() << "LoadLibrary failed: '" << filename << "'\n";
 158                 if ( const char* error = dlerror() )
 159                         globalErrorStream() << "GetLastError: " << error;
 160         }
 161 }
 162 ~DynamicLibrary(){
 163         if ( !failed() ) {
 164                 dlclose( m_library );
 165         }
 166 }
 167 bool failed(){
 168         return m_library == 0;
 169 }
 170 FunctionPointer findSymbol( const char* symbol ){
 171         FunctionPointer p = (FunctionPointer)dlsym( m_library, symbol );
 172         if ( p == 0 ) {
 173                 const char* error = reinterpret_cast<const char*>( dlerror() );
 174                 if ( error != 0 ) {
 175                         globalErrorStream() << error;
 176                 }
 177         }
 178         return p;
 179 }
 180 };
 181
 182 #else
 183 #error "unsupported platform"
 184 #endif
 185
 186 class DynamicLibraryModule
 187 {
 188 typedef void ( RADIANT_DLLIMPORT * RegisterModulesFunc )( ModuleServer& server );
 189 DynamicLibrary m_library;
 190 RegisterModulesFunc m_registerModule;
 191 public:
 192 DynamicLibraryModule( const char* filename )
 193         : m_library( filename ), m_registerModule( 0 ){
 194         if ( !m_library.failed() ) {
 195                 m_registerModule = reinterpret_cast<RegisterModulesFunc>( m_library.findSymbol( "Radiant_RegisterModules" ) );
 196 #if 0
 197                 if ( !m_registerModule ) {
 198                         m_registerModule = reinterpret_cast<RegisterModulesFunc>( m_library.findSymbol( "Radiant_RegisterModules@4" ) );
 199                 }
 200 #endif
 201         }
 202 }
 203 bool failed(){
 204         return m_registerModule == 0;
 205 }
 206 void registerModules( ModuleServer& server ){
 207         m_registerModule( server );
 208 }
 209 };
 210
 211
 212 class Libraries
 213 {
 214 typedef std::vector<DynamicLibraryModule*> libraries_t;
 215 libraries_t m_libraries;
 216
 217 public:
 218 ~Libraries(){
 219         release();
 220 }
 221 void registerLibrary( const char* filename, ModuleServer& server ){
 222         DynamicLibraryModule* library = new DynamicLibraryModule( filename );
 223
 224         if ( library->failed() ) {
 225                 delete library;
 226         }
 227         else
 228         {
 229                 m_libraries.push_back( library );
 230                 library->registerModules( server );
 231         }
 232 }
 233 void release(){
 234         for ( libraries_t::iterator i = m_libraries.begin(); i != m_libraries.end(); ++i )
 235         {
 236                 delete *i;
 237         }
 238 }
 239 void clear(){
 240         m_libraries.clear();
 241 }
 242 };
 243
 244
 245 Libraries g_libraries;
 246 RadiantModuleServer g_server;
 247
 248 ModuleServer& GlobalModuleServer_get(){
 249         return g_server;
 250 }
 251
 252 void GlobalModuleServer_loadModule( const char* filename ){
 253         g_libraries.registerLibrary( filename, g_server );
 254 }
 255
 256 void GlobalModuleServer_Initialise(){
 257 }
 258
 259 void GlobalModuleServer_Shutdown(){
 260 }