ModuleModule.cpp

Aller à la documentation de ce fichier.

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

    Gestion d'un module. \n

    \author     aerith (contact@aerith.biz - www.aerith.biz)
    \version    1.0
    \date       16/02/2006
*/

#include    "ModuleModule.h"

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

ModuleModule::~ModuleModule()
{
    int     i;

    UnLoad();

    for(i = 0; i < NbFonction; i++)
    {
        if(Fonctions[i])
            free(Fonctions[i]);
        Fonctions[i] = NULL;
    }
    if(Fonctions)
        free(Fonctions);
    Fonctions = NULL;
}

int     ModuleModule::Load(char *pName, char *pFile)
{
    int         i = 0, Nb;
    char        Nbr[12];
    ROUTINE     Temp;
    BEGIN
    LOC("ModuleModule::Load")

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

        TRY if(ModuleLoad(&ModuleAdr, pFile))
        {
            printf("[Module] Load %36s [  OK  ]\n", pName);

            TRYIF(ModuleImport(ModuleAdr, &Temp, "ModuleInit"), 25)
            TRYIF((int)Temp(NULL), 27)

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

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

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

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

            Loaded = 1;

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

            TRY {
                for(i = 0; i < NbFonction; i++)
                {
                    if(Fonctions[i])
                        free(Fonctions[i]);
                    Fonctions[i] = NULL;
                }
                if(Fonctions)
                    free(Fonctions);
                Fonctions = NULL;

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

            TRY Nb = AtoD((char *)Fonction(NULL));
            TRY if(Nb)
            {
                Fonctions = (ModuleFonction **)realloc(Fonctions, Nb * sizeof(ModuleFonction *));

                for(i = 0; i < (Nb && !CERROR); i++)
                {
                    Fonctions[i] = new ModuleFonction;

                    DtoA(i + 1, Nbr);
                    CERROR = AddFonction((char *)Fonction(Nbr));
                }
            }
            ENDTRY(26)
        }
        else
        {
            printf("[Module] Load %36s [FAILED]\n", pName);
            CERROR = 23;
        }
    }

    PERROR

    ENDBEGIN
}

int     ModuleModule::UnLoad()
{
    int         i = 0;
    ROUTINE     Close;
    BEGIN
    LOC("ModuleModule::UnLoad")

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

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

            for(i = 0; i < NbFonction; i++)
            {
                if(Fonctions[i])
                    free(Fonctions[i]);
                Fonctions[i] = NULL;
            }
            if(Fonctions)
                free(Fonctions);
            Fonctions = NULL;
            NbFonction = 0;
            Loaded = 0;
        }
        else
        {
            printf("[Module] Unload %34s [FAILED]\n", Name);
            CERROR = 24;
        }
    }

    PERROR

    ENDBEGIN
}

int     ModuleModule::AddFonction(char *pName)
{
    ModuleFonction  *Fonction;
    BEGIN
    LOC("ModuleModule::AddFonction")

    TRY if(Loaded)
    {
        Fonction = new ModuleFonction;

        printf("[Module] Import %34s ", pName);
        TRY if(ModuleImport(ModuleAdr, &Fonction->Fonction, pName))
        {
            Fonctions = (ModuleFonction **)realloc(Fonctions, (NbFonction + 1) * sizeof(ModuleFonction *));

            Fonctions[NbFonction] = Fonction;
            strcpy(Fonctions[NbFonction]->Name, pName);

            NbFonction++;

            printf("[  OK  ]\n");
        }
        else
        {
            printf("[FAILED]\n");
            CERROR = 25;
        }
    }
    ENDTRY(23)

    PERROR

    ENDBEGIN
}

int     ModuleModule::DelFonction(int iPos)
{
    int     i = 0;
    BEGIN
    LOC("ModuleModule::DelFonction")

    TRY if(Loaded)
    {
        TRY if(iPos < NbFonction)
        {
            if(Fonctions[iPos])
                free(Fonctions[iPos]);
            Fonctions[iPos] = NULL;

            for(i = iPos; i < (NbFonction - 1); Fonctions[i] = Fonctions[i++]);
            Fonctions = (ModuleFonction **)realloc(Fonctions, (NbFonction - 1) * sizeof(ModuleFonction *));

            NbFonction--;
        }
        ENDTRY(26)
    }
    ENDTRY(23)

    PERROR

    ENDBEGIN
}

---