Surcouche.c

Aller à la documentation de ce fichier.

/*! \file Surcouche.c
    \brief Surcouche pour reseau, multitache, console et temp.

    Redéfinie tout un tas de fonctions système pour les rendre portables unix et windows.

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

#include    "Surcouche.h"
#include    <string.h>

//****************************** Multitache ************************************
int     ThreadStart(THREAD *pThread, ROUTINE Process, PARAMETRE Param)
{
#ifdef WIN32
    *pThread = (THREAD)CreateThread(NULL, 0, (ROUTINE)Process, (PARAMETRE)Param, 0, NULL);
    if(pThread == INVALID_HANDLE_VALUE)
        return 1;
#else
    pthread_attr_t Type;

    if(pthread_attr_init(&Type))
        return(1);

    pthread_attr_setdetachstate(&Type, PTHREAD_CREATE_JOINABLE);

    if(pthread_create((THREAD *)pThread, &Type, (ROUTINE)Process, (PARAMETRE)Param))
        return 1;
#endif

    return 0;
}

void    ThreadStop(THREAD *pThread)
{
#ifdef WIN32
    TerminateThread((THREAD)pThread, FALSE);
    CloseHandle((THREAD)pThread);
#else
    pthread_cancel((THREAD)pThread);
#endif
    *pThread = 0;
}

void    ThreadExit(int ExitCode)
{
#ifdef WIN32
    ExitThread(ExitCode);
#else
    pthread_exit((void *)&ExitCode);
#endif
}

void    ThreadWait(THREAD *pThread)
{
#ifdef WIN32
    WaitForSingleObject((THREAD)pThread, INFINITE);
    CloseHandle((THREAD)pThread);
#else
    pthread_join((THREAD)pThread, NULL);
#endif
    *pThread = 0;
}

void    MutexInit(MUTEX *pMutex)
{
#ifdef WIN32
    *pMutex = (MUTEX)CreateMutex(NULL, FALSE, NULL);
#else
    pthread_mutex_init((MUTEX *)pMutex, NULL);
#endif
}

void    MutexLock(MUTEX *pMutex)
{
    if(!pMutex)
        MutexInit(pMutex);

#ifdef WIN32
    WaitForSingleObject((MUTEX)pMutex, INFINITE);
#else
    pthread_mutex_lock((MUTEX *)pMutex);
#endif
}

void    MutexUnLock(MUTEX *pMutex)
{
#ifdef WIN32
    ReleaseMutex((MUTEX)pMutex);
#else
    pthread_mutex_unlock((MUTEX *)pMutex);
#endif
}

void    MutexStop(MUTEX *pMutex)
{
#ifdef WIN32
    ReleaseMutex((MUTEX)pMutex);
    CloseHandle((MUTEX)pMutex);
    *pMutex = NULL;
#else
    pthread_mutex_destroy((MUTEX *)pMutex);
    pMutex = NULL;
#endif
}

//******************************* Module ***************************************
int     ModuleLoad(MODULE *pModule, char *pName)
{
    *pModule = NULL;
#ifdef WIN32
    *pModule = (MODULE)LoadLibrary(pName);
#else
    *pModule = (MODULE)dlopen(pName, RTLD_NOW);
#endif

    if(*pModule)
        return 1;

    return 0;
}

int     ModuleUnload(MODULE *pModule)
{
    int     r = 1;
#ifdef WIN32
    if(FreeLibrary((MODULE)*pModule))
        r = 0;
#else
    if(!dlclose((MODULE)*pModule))
        r = 0;
#endif

    *pModule = NULL;

    return r;
}

int     ModuleImport(MODULE Module, ROUTINE *pFonction, char *pName)
{
    *pFonction = NULL;

#ifdef WIN32
    *pFonction = (ROUTINE)GetProcAddress(Module, pName);
#else
    *pFonction = (ROUTINE)dlsym(Module, pName);
#endif

    if(*pFonction)
        return 1;

    return 0;
}


//******************************* Reseau ***************************************
int     SocketLoad(void)
{
#ifdef WIN32
    WORD        wVersionRequested = MAKEWORD(1, 1);
    WSADATA     wsaData;

    if(WSAStartup(wVersionRequested, &wsaData))
    {
        WSACleanup();
        return 1;
    }
#else
    signal(SIGPIPE, SIG_IGN);
#endif

    return 0;
}

void    SocketUnLoad(void)
{
#ifdef WIN32
    WSACleanup();
#endif
}

void    SocketClose(SOCKET Sock)
{
#ifdef WIN32
    closesocket(Sock);
#else
    close(Sock);
#endif
    Sock = 0;
}


//********************************** Temp **************************************
void    TempWait(unsigned int Delai)
{
#ifdef WIN32
    Sleep(Delai);
#else
    usleep(Delai * 1000);
#endif
}

void    TempPause()
{
#ifdef WIN32
    system("PAUSE");
#else

#endif
}

//******************************** Console *************************************
void    ConsoleClear()
{
#ifdef WIN32
    system("CLS");
#else
    printf("\033[2J");
#endif
}

void    ConsoleSetColor(unsigned int iColor)
{
#ifdef WIN32
    char    Buffer[12];

    sprintf(Buffer, "COLOR %X", iColor);
    system(Buffer);
#else

#endif
}

int     ConsoleCharColor(CONSOLE *pConsole, unsigned int iPosX, unsigned int iPosY, unsigned int iColor, int unsigned iLength)
{
#ifdef WIN32
    WORD    *Data;
    int     i;
    COORD   Pos;

    Pos.X = iPosX;
    Pos.Y = iPosY;

    Data = (WORD *)malloc(sizeof(WORD) * iLength);
    for(i = 0; i < iLength; Data[i++] = iColor);

    return WriteConsoleOutputAttribute(pConsole, Data, iLength, Pos, (LPDWORD)iLength);
#else
    return 0;
#endif
}

int     ConsoleCharWrite(CONSOLE *pConsole, unsigned int iPosX, unsigned int iPosY, char *pData, unsigned int iLength)
{
#ifdef WIN32
    COORD   Pos;

    Pos.X = iPosX;
    Pos.Y = iPosY;

    if(!iLength)
        iLength = strlen(pData);

    return WriteConsoleOutputCharacter(pConsole, pData, iLength, Pos, (LPDWORD)iLength);
#else
    return 0;
#endif
}

int     ConsoleCharRead(CONSOLE *pConsole, unsigned int iPosX, unsigned int iPosY, char *pData, unsigned int iLength)
{
#ifdef WIN32
    COORD   Pos;

    Pos.X = iPosX;
    Pos.Y = iPosY;

    if(!iLength)
        iLength = strlen(pData);

    return ReadConsoleOutputCharacter(pConsole, pData, iLength, Pos, (LPDWORD)iLength);
#else
    return 0;
#endif
}

int     ConsoleZoneWrite(CONSOLE *pConsole, unsigned int iPosX, unsigned int iPosY, unsigned int iLength, unsigned int iHeight, CHARINFO *pData)
{
#ifdef WIN32
    COORD       Pos;
    COORD       Size;
    SMALL_RECT  Zone;

    Pos.X       = iPosX;
    Pos.Y       = iPosY;
    Size.X      = iLength - iPosX;
    Size.Y      = iHeight - iPosY;
    Zone.Left   = Pos.X;
    Zone.Top    = Pos.Y;
    Zone.Right  = Size.X;
    Zone.Bottom = Size.Y;

    return WriteConsoleOutput(pConsole, pData, Size, Pos, &Zone);
#else
    return 0;
#endif
}

int     ConsoleZoneRead(CONSOLE *pConsole, unsigned int iPosX, unsigned int iPosY, unsigned int iLength, unsigned int iHeight, CHARINFO *pData)
{
#ifdef WIN32
    COORD       Pos;
    COORD       Size;
    SMALL_RECT  Zone;

    Pos.X       = iPosX;
    Pos.Y       = iPosY;
    Size.X      = iLength - iPosX;
    Size.Y      = iHeight - iPosY;
    Zone.Left   = Pos.X;
    Zone.Top    = Pos.Y;
    Zone.Right  = Size.X;
    Zone.Bottom = Size.Y;

    return ReadConsoleOutput(pConsole, pData, Size, Pos, &Zone);
#else
    return 0;
#endif
}

//******************************** Touche **************************************
int     KeyGet()
{
    fflush(stdin);

    return getchar();
}

int     KeyGet2()
{
#ifdef WIN32
    return _getch();
#else
    return 0;
#endif
}

int     KeyWait()
{
#ifdef WIN32
    while(!_kbhit());

    return _getch();
#else
    return 0;
#endif
}

int     KeyPressed()
{
#ifdef WIN32
    return _kbhit();
#else
    return 0;
#endif
}


//******************************** Fichier *************************************
int     FileDelete(char *pName)
{
#ifdef WIN32
    if(DeleteFile(pName))
        return 0;
#else
    if(!remove(pName))
        return 0;
#endif

    return 1;
}

int     FileRename(char *pName, char *pNewName)
{
#ifdef WIN32
    if(MoveFile(pName, pNewName))
        return 0;
#else
    if(!rename(pName, pNewName))
        return 0;
#endif

    return 1;
}

//******************************* Reperoire ************************************
DIRECTORY       DirOpen(char *pDirName, char *pFirstData, int *pIsFile)
{
    char        *DirName;
    DIRECTORY   Dir;
#ifdef WIN32
    WIN32_FIND_DATA Find;
#else
    struct dirent   *Find;
    struct stat     Stat;
#endif

    DirName = (char *)malloc(sizeof(char) * (strlen(pDirName) + 3));
    strcpy(DirName, pDirName);
    strcat(DirName, "\\");
    strcat(DirName, "*");
    *pFirstData = '\0';
    *pIsFile = 1;

#ifdef WIN32
    if(Dir = FindFirstFile(DirName, &Find))
    {
        if(Find.cFileName)
            strcpy(pFirstData, Find.cFileName);

        if(Find.dwFileAttributes)
            if(Find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                *pIsFile = 0;
    }
#else
    Dir = opendir(DirName);
    if(Dir)
    {
        Find = readdir(Dir);
        if(Find->d_name)
            strcpy(pFirstData, Find->d_name);

        lstat(DirName, &Stat);
        if(S_ISDIR(Stat.st_mode))
            *pIsFile = 0;
    }
#endif

    free(DirName);

    return Dir;
}

int     DirClose(DIRECTORY *pDir)
{
#ifdef WIN32
    if(FindClose(pDir))
        return 0;
#else
    if(!closedir(*pDir))
        return 0;
#endif

    return 1;
}

int     DirGetNext(DIRECTORY *pDir, char *pNextData, int *pIsFile)
{
#ifdef WIN32
    WIN32_FIND_DATA Find;
#else
    struct dirent   *Find;
    struct stat     Stat;
#endif

    *pNextData = '\0';
    *pIsFile = 1;

#ifdef WIN32
    if(FindNextFile(pDir, &Find))
    {
        if(Find.cFileName)
            strcpy(pNextData, Find.cFileName);

        if(Find.dwFileAttributes)
            if(Find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                *pIsFile = 0;
        return 0;
    }
#else
    if(Find = readdir(*pDir))
    {
        Find = readdir(*pDir);
        if(Find->d_name)
            strcpy(pNextData, Find->d_name);

        lstat(pNextData, &Stat);
        if(S_ISDIR(Stat.st_mode))
            *pIsFile = 0;

        return 0;
    }
#endif

    return 1;
}

int     DirCreate(char *pName)
{
#ifdef WIN32
    if(CreateDirectory(pName, NULL))
        return 0;
#else
    mode_t  modes;

    modes = S_IRWXU | S_IXGRP | S_IXOTH;
    if(!mkdir(pName, modes))
        return 0;
#endif

    return 1;
}

int     DirDelete(char *pName)
{
#ifdef WIN32
    if(RemoveDirectory(pName))
        return 0;
#else
    if(!rmdir(pName))
        return 0;
#endif

    return 1;
}

---