worldspawn/radiant/server.cpp

/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "server.h"
#include "globaldefs.h"

#include "debugging/debugging.h"
#include "warnings.h"

#include <vector>
#include <map>
#include "os/path.h"

#include "modulesystem.h"

class RadiantModuleServer : public ModuleServer {
    typedef std::pair<CopiedString, int> ModuleType;
    typedef std::pair<ModuleType, CopiedString> ModuleKey;
    typedef std::map<ModuleKey, Module *> Modules_;
    Modules_ m_modules;
    bool m_error;

public:
    RadiantModuleServer() : m_error(false)
    {
    }

    void setError(bool error)
    {
        m_error = error;
    }

    bool getError() const
    {
        return m_error;
    }

    TextOutputStream &getOutputStream()
    {
        return globalOutputStream();
    }

    TextOutputStream &getErrorStream()
    {
        return globalErrorStream();
    }

    DebugMessageHandler &getDebugMessageHandler()
    {
        return globalDebugMessageHandler();
    }

    void registerModule(const char *type, int version, const char *name, Module &module)
    {
        if (!m_modules.insert(Modules_::value_type(ModuleKey(ModuleType(type, version), name), &module)).second) {
            globalErrorStream() << "module already registered: type=" << makeQuoted(type) << " name="
                                << makeQuoted(name) << "\n";
        } else {
            globalOutputStream() << "Module Registered: type=" << makeQuoted(type) << " version=" << makeQuoted(version)
                                 << " name=" << makeQuoted(name) << "\n";
        }
    }

    Module *findModule(const char *type, int version, const char *name) const
    {
        Modules_::const_iterator i = m_modules.find(ModuleKey(ModuleType(type, version), name));
        if (i != m_modules.end()) {
            return (*i).second;
        }
        return 0;
    }

    void foreachModule(const char *type, int version, const Visitor &visitor)
    {
        for (Modules_::const_iterator i = m_modules.begin(); i != m_modules.end(); ++i) {
            if (string_equal((*i).first.first.first.c_str(), type)) {
                visitor.visit((*i).first.second.c_str(), *(*i).second);
            }
        }
    }
};


#if GDEF_OS_WINDOWS

#include <windows.h>

const int FORMAT_BUFSIZE = 2048;
const char* FormatGetLastError(){
    static char buf[FORMAT_BUFSIZE];
    FormatMessage(
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        GetLastError(),
        MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), // Default language
        buf,
        FORMAT_BUFSIZE,
        NULL
        );
    return buf;
}

class DynamicLibrary
{
HMODULE m_library;
public:
typedef int ( __stdcall * FunctionPointer )();

DynamicLibrary( const char* filename ){
    m_library = LoadLibrary( filename );
    if ( m_library == 0 ) {
        globalErrorStream() << "LoadLibrary failed: '" << filename << "'\n";
        globalErrorStream() << "GetLastError: " << FormatGetLastError();
    }
}
~DynamicLibrary(){
    if ( !failed() ) {
        FreeLibrary( m_library );
    }
}
bool failed(){
    return m_library == 0;
}
FunctionPointer findSymbol( const char* symbol ){
    FunctionPointer address = (FunctionPointer) GetProcAddress( m_library, symbol );
    if ( address == 0 ) {
        globalErrorStream() << "GetProcAddress failed: '" << symbol << "'\n";
        globalErrorStream() << "GetLastError: " << FormatGetLastError();
    }
    return address;
}
};

#elif GDEF_OS_POSIX

#include <dlfcn.h>

class DynamicLibrary {
    void *m_library;
public:
    typedef int ( *FunctionPointer )();

    DynamicLibrary(const char *filename)
    {
        m_library = dlopen(filename, RTLD_NOW);
    }

    ~DynamicLibrary()
    {
        if (!failed()) {
            dlclose(m_library);
        }
    }

    bool failed()
    {
        return m_library == 0;
    }

    FunctionPointer findSymbol(const char *symbol)
    {
        FunctionPointer p = (FunctionPointer) dlsym(m_library, symbol);
        if (p == 0) {
            const char *error = reinterpret_cast<const char *>( dlerror());
            if (error != 0) {
                globalErrorStream() << error;
            }
        }
        return p;
    }
};

#else
#error "unsupported platform"
#endif

class DynamicLibraryModule {
    typedef void ( RADIANT_DLLIMPORT *RegisterModulesFunc )(ModuleServer &server);

    DynamicLibrary m_library;
    RegisterModulesFunc m_registerModule;
public:
    DynamicLibraryModule(const char *filename)
            : m_library(filename), m_registerModule(0)
    {
        if (!m_library.failed()) {
            m_registerModule = reinterpret_cast<RegisterModulesFunc>( m_library.findSymbol("Radiant_RegisterModules"));
#if 0
            if ( !m_registerModule ) {
                m_registerModule = reinterpret_cast<RegisterModulesFunc>( m_library.findSymbol( "Radiant_RegisterModules@4" ) );
            }
#endif
        }
    }

    bool failed()
    {
        return m_registerModule == 0;
    }

    void registerModules(ModuleServer &server)
    {
        m_registerModule(server);
    }
};


class Libraries {
    typedef std::vector<DynamicLibraryModule *> libraries_t;
    libraries_t m_libraries;

public:
    ~Libraries()
    {
        release();
    }

    void registerLibrary(const char *filename, ModuleServer &server)
    {
        DynamicLibraryModule *library = new DynamicLibraryModule(filename);

        if (library->failed()) {
            delete library;
        } else {
            m_libraries.push_back(library);
            library->registerModules(server);
        }
    }

    void release()
    {
        for (libraries_t::iterator i = m_libraries.begin(); i != m_libraries.end(); ++i) {
            delete *i;
        }
    }

    void clear()
    {
        m_libraries.clear();
    }
};


Libraries g_libraries;
RadiantModuleServer g_server;

ModuleServer &GlobalModuleServer_get()
{
    return g_server;
}

void GlobalModuleServer_loadModule(const char *filename)
{
    g_libraries.registerLibrary(filename, g_server);
}

void GlobalModuleServer_Initialise()
{
}

void GlobalModuleServer_Shutdown()
{
}