root/src/common/utils.c @ 1

// Copyright (c) Athena Dev Teams - Licensed under GNU GPL
// For more information, see LICENCE in the main folder

#include "../common/cbasetypes.h"
#include "../common/mmo.h"
#include "../common/malloc.h"
#include "../common/showmsg.h"
#include "utils.h"

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <math.h> // floor()

#ifdef WIN32
        #include <windows.h>
#else
        #include <unistd.h>
        #include <dirent.h>
        #include <sys/stat.h>
#endif

// generate a hex dump of the first 'length' bytes of 'buffer'
void dump(FILE* fp, const unsigned char* buffer, int length)
{
        int i, j;

        fprintf(fp, "         Hex                                                  ASCII\n");
        fprintf(fp, "         -----------------------------------------------      ----------------");

        for (i = 0; i < length; i += 16)
        {
                fprintf(fp, "\n%p ", &buffer[i]);
                for (j = i; j < i + 16; ++j)
                {
                        if (j < length)
                                fprintf(fp, "%02hX ", buffer[j]);
                        else
                                fprintf(fp, "   ");
                }

                fprintf(fp, "  |  ");

                for (j = i; j < i + 16; ++j)
                {
                        if (j < length) {
                                if (buffer[j] > 31 && buffer[j] < 127)
                                        fprintf(fp, "%c", buffer[j]);
                                else
                                        fprintf(fp, ".");
                        } else
                                fprintf(fp, " ");
                }
        }
        fprintf(fp, "\n");
}


#ifdef WIN32

static char* checkpath(char *path, const char *srcpath)
{       // just make sure the char*path is not const
        char *p=path;
        if(NULL!=path && NULL!=srcpath)
        while(*srcpath) {
                if (*srcpath=='/') {
                        *p++ = '\\';
                        srcpath++;
                }
                else
                        *p++ = *srcpath++;
        }
        *p = *srcpath; //EOS
        return path;
}

void findfile(const char *p, const char *pat, void (func)(const char*))
{       
        WIN32_FIND_DATA FindFileData;
        HANDLE hFind;
        char tmppath[MAX_PATH+1];
        
        const char *path    = (p  ==NULL)? "." : p;
        const char *pattern = (pat==NULL)? "" : pat;
        
        checkpath(tmppath,path);
        if( PATHSEP != tmppath[strlen(tmppath)-1])
                strcat(tmppath, "\\*");
        else
                strcat(tmppath, "*");
        
        hFind = FindFirstFile(tmppath, &FindFileData);
        if (hFind != INVALID_HANDLE_VALUE)
        {
                do
                {
                        if (strcmp(FindFileData.cFileName, ".") == 0)
                                continue;
                        if (strcmp(FindFileData.cFileName, "..") == 0)
                                continue;

                        sprintf(tmppath,"%s%c%s",path,PATHSEP,FindFileData.cFileName);

                        if (FindFileData.cFileName && strstr(FindFileData.cFileName, pattern)) {
                                func( tmppath );
                        }


                        if( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
                        {
                                findfile(tmppath, pat, func);
                        }
                }while (FindNextFile(hFind, &FindFileData) != 0);
                FindClose(hFind);
        }
        return;
}
#else

#define MAX_DIR_PATH 2048

static char* checkpath(char *path, const char*srcpath)
{       // just make sure the char*path is not const
        char *p=path;
        if(NULL!=path && NULL!=srcpath)
        while(*srcpath) {
                if (*srcpath=='\\') {
                        *p++ = '/';
                        srcpath++;
                }
                else
                        *p++ = *srcpath++;
        }
        *p = *srcpath; //EOS
        return path;
}

void findfile(const char *p, const char *pat, void (func)(const char*))
{       
        DIR* dir;                                       // pointer to the scanned directory.
        struct dirent* entry;           // pointer to one directory entry.
        struct stat dir_stat;       // used by stat().
        char tmppath[MAX_DIR_PATH+1];
        char path[MAX_DIR_PATH+1]= ".";
        const char *pattern = (pat==NULL)? "" : pat;
        if(p!=NULL) strcpy(path,p);

        // open the directory for reading
        dir = opendir( checkpath(path, path) );
        if (!dir) {
                ShowError("Cannot read directory '%s'\n", path);
                return;
        }

        // scan the directory, traversing each sub-directory
        // matching the pattern for each file name.
        while ((entry = readdir(dir))) {
                // skip the "." and ".." entries.
                if (strcmp(entry->d_name, ".") == 0)
                        continue;
                if (strcmp(entry->d_name, "..") == 0)
                        continue;

                sprintf(tmppath,"%s%c%s",path, PATHSEP, entry->d_name);

                // check if the pattern matchs.
                if (entry->d_name && strstr(entry->d_name, pattern)) {
                        func( tmppath );
                }
                // check if it is a directory.
                if (stat(tmppath, &dir_stat) == -1) {
                        ShowError("stat error %s\n': ", tmppath);
                        continue;
                }
                // is this a directory?
                if (S_ISDIR(dir_stat.st_mode)) {
                        // decent recursivly
                        findfile(tmppath, pat, func);
                }
        }//end while
}
#endif

uint8 GetByte(uint32 val, int idx)
{
        switch( idx )
        {
        case 0: return (uint8)( (val & 0x000000FF)         );
        case 1: return (uint8)( (val & 0x0000FF00) >> 0x08 );
        case 2: return (uint8)( (val & 0x00FF0000) >> 0x10 );
        case 3: return (uint8)( (val & 0xFF000000) >> 0x18 );
        default:
#if defined(DEBUG)
                ShowDebug("GetByte: invalid index (idx=%d)\n", idx);
#endif
                return 0;
        }
}

uint16 GetWord(uint32 val, int idx)
{
        switch( idx )
        {
        case 0: return (uint16)( (val & 0x0000FFFF)         );
        case 1: return (uint16)( (val & 0xFFFF0000) >> 0x10 );
        default:
#if defined(DEBUG)
                ShowDebug("GetWord: invalid index (idx=%d)\n", idx);
#endif
                return 0;
        }
}
uint16 MakeWord(uint8 byte0, uint8 byte1)
{
        return byte0 | (byte1 << 0x08);
}

uint32 MakeDWord(uint16 word0, uint16 word1)
{
        return
                ( (uint32)(word0        ) )|
                ( (uint32)(word1 << 0x10) );
}


/// calculates the value of A / B, in percent (rounded down)
unsigned int get_percentage(const unsigned int A, const unsigned int B)
{
        double result;

        if( B == 0 )
        {
                ShowError("get_percentage(): divison by zero! (A=%u,B=%u)\n", A, B);
                return -1;
        }

        result = 100 * ((double)A / (double)B);

        if( result > UINT_MAX )
        {
                ShowError("get_percentage(): result percentage too high! (A=%u,B=%u,result=%g)\n", A, B, result);
                return UINT_MAX;
        }

        return (unsigned int)floor(result);
}