ModuleDynamiqueModule.cpp

Aller à la documentation de ce fichier.

/*! \file ModuleDynamiqueModule.cpp
    \brief Gestion de module dynamique.

    Gestion d'un module. \n

    \author     aerith (www.aerith.fr)
    \version    1.0
    \date       24/07/2007
*/

#include    "ModuleDynamiqueModule.h"

ModuleDynamiqueModule::ModuleDynamiqueModule()
{
    *File           = '\0';
    *Name           = '\0';
    *Realname       = '\0';
    *Version        = '\0';
    *Autor          = '\0';
    *Desc           = '\0';
    Fonction        = NULL;
    ModuleAdr       = NULL;
    NbFonction      = 0;
    Loaded          = 0;
}

ModuleDynamiqueModule::~ModuleDynamiqueModule()
{
    UnLoad();
}

int     ModuleDynamiqueModule::Load(char *pName, char *pFile)
{
    int         i = 0, Nb;
    ROUTINE     Temp;
    BEGIN
    LOC("ModuleDynamiqueModule::Load")

    if(!Loaded)
    {
        strcpy(Name, pName);
        strcpy(File, pFile);

        TRY if(ModuleLoad(&ModuleAdr, File))
        {
            printf("[Module] Load %-56s [  OK  ]\n", Name);

            TRYIF(ModuleImport(ModuleAdr, &Temp, "ModuleInit"), ERROR_C_IMPORT_FUNC)
            TRYIF((int)Temp(NULL), ERROR_C_FUNCTION)

            TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleName"))
            {
                strcpy(Realname, (char *)Temp(NULL));
            }
            ENDTRY(ERROR_C_IMPORT_FUNC)

            TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleVersion"))
            {
                strcpy(Version, (char *)Temp(NULL));
            }
            ENDTRY(ERROR_C_IMPORT_FUNC)

            TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleDesc"))
            {
                strcpy(Desc, (char *)Temp(NULL));
            }
            ENDTRY(ERROR_C_IMPORT_FUNC)

            TRY if(ModuleImport(ModuleAdr, &Temp, "ModuleAutor"))
            {
                strcpy(Autor, (char *)Temp(NULL));
            }
            ENDTRY(ERROR_C_IMPORT_FUNC)

            Loaded = 1;

            TRYIF(ModuleImport(ModuleAdr, &Fonction, "ModuleFonction"), 25)

            TRY {
                while(NbFonction)
                    DelFonction(NbFonction - 1);
                Fonctions.clear();

                printf("\t%s V%s by %s\n", Realname, Version, Autor);
                printf("\t%s\n", Desc);
            }

            TRY Nb = AtoI((char *)Fonction(0));
            TRY if(Nb)
            {
                for(i = 0; i < (Nb && !CERROR); i++)
                {
                    CERROR = AddFonction((char *)Fonction((PARAMETRE)(i + 1)));
                }
            }
            ENDTRY(ERROR_C_NO_FUNC)
        }
        else
        {
            printf("[Module] Load %-56s [FAILED]\n", pName);
            CERROR = ERROR_C_LOAD_DLL;
        }
    }

    PERROR

    ENDBEGIN
}

int     ModuleDynamiqueModule::UnLoad()
{
    ROUTINE     Close;
    BEGIN
    LOC("ModuleDynamiqueModule::UnLoad")

    if(Loaded)
    {
        if(ModuleImport(ModuleAdr, &Close, "ModuleClose"))
            Close(NULL);

        while(NbFonction)
            DelFonction(NbFonction - 1);
        Fonctions.clear();

        if(!ModuleUnload(&ModuleAdr))
        {
            printf("[Module] Unload %-54s [  OK  ]\n", Name);

            Loaded = 0;
        }
        else
        {
            printf("[Module] Unload %-54s [FAILED]\n", Name);
            CERROR = ERROR_C_UNLOAD_DLL;
        }
    }

    PERROR

    ENDBEGIN
}

int     ModuleDynamiqueModule::AddFonction(char *pName)
{
    BEGIN
    LOC("ModuleDynamiqueModule::AddFonction")

    if(Loaded)
    {
        Fonctions.push_back(new ModuleFonction);
        TRY if(ModuleImport(ModuleAdr, &Fonctions.back()->Fonction, pName))
        {
            strcpy(Fonctions.back()->Name, pName);

            NbFonction++;

            printf("[Module] Import %-54s [  OK  ]\n", pName);
        }
        else
        {
            Fonctions.erase(Fonctions.begin() + NbFonction);
            printf("[Module] Import %-54s [FAILED]\n", pName);
            CERROR = ERROR_C_IMPORT_FUNC;
        }
    }
    ENDTRY(ERROR_C_LOAD_DLL)

    PERROR

    ENDBEGIN
}

int     ModuleDynamiqueModule::DelFonction(int iPos)
{
    BEGIN
    LOC("ModuleDynamiqueModule::DelFonction")

    TRY if(Loaded)
    {
        TRY if(iPos < NbFonction)
        {
            delete Fonctions[iPos];
            Fonctions.erase(Fonctions.begin() + iPos);

            NbFonction--;
        }
        ENDTRY(ERROR_C_NO_FUNC)
    }
    ENDTRY(ERROR_C_LOAD_DLL)

    PERROR

    ENDBEGIN
}

---