d4d_extsrc.h

Go to the documentation of this file.

/**************************************************************************
*
* Copyright 2014 by Petr Gargulak. eGUI Community.
* Copyright 2009-2013 by Petr Gargulak. Freescale Semiconductor, Inc.
*
***************************************************************************
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License Version 3
* or later (the "LGPL").
*
* As a special exception, the copyright holders of the eGUI project give you
* permission to link the eGUI sources with independent modules to produce an
* executable, regardless of the license terms of these independent modules,
* and to copy and distribute the resulting executable under terms of your
* choice, provided that you also meet, for each linked independent module,
* the terms and conditions of the license of that module.
* An independent module is a module which is not derived from or based
* on this library.
* If you modify the eGUI sources, you may extend this exception
* to your version of the eGUI sources, but you are not obligated
* to do so. If you do not wish to do so, delete this
* exception statement from your version.
*
* This program 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.
*
* You should have received a copy of the GNU General Public License
* and the GNU Lesser General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>.
*
***************************************************************************/
#ifndef __D4D_EXTSRC_H
#define __D4D_EXTSRC_H

#if !defined(__MQX__) && !defined(D4D_OS_MQX)
 // #include <stdlib.h>
#endif

/******************************************************************************
* D4D External Resources  constants
*
*/
#ifndef D4D_IMG_WORK_PATH_DEFAULT
  #define D4D_IMG_WORK_PATH_DEFAULT "a:\\"
#endif

#ifndef D4D_FNT_WORK_PATH_DEFAULT
  #define D4D_FNT_WORK_PATH_DEFAULT "a:\\"
#endif

#ifndef D4D_DRIVE_MAX_STRLEN
  #define D4D_DRIVE_MAX_STRLEN 8
#endif

/******************************************************************************
* D4D External Resources types
*
*/
/**************************************************************************/ 
typedef D4D_FILEPTR (*D4DFILE_FOPEN)(D4D_CHAR* filename, D4D_CHAR* mode);

/**************************************************************************/ 
typedef int (*D4DFILE_FCLOSE)(D4D_FILEPTR p_file);

/**************************************************************************/ 
typedef int (*D4DFILE_READ)(D4D_FILEPTR p_file, void* buffer, int size);

/**************************************************************************/ 
typedef int (*D4DFILE_WRITE)(D4D_FILEPTR p_file, const void* buffer, int size);

/**************************************************************************/ 
typedef int (*D4DFILE_FSEEK)(D4D_FILEPTR p_file, long offset, int origin);

#define D4D_SEEK_SET    1

#define D4D_SEEK_CUR    2

#define D4D_SEEK_END    3

/**************************************************************************/ 
typedef long (*D4DFILE_FTELL)(D4D_FILEPTR p_file);

/**************************************************************************/ 
typedef int (*D4DLOCALE_TRANSLATE_STR)(const D4D_TCHAR* originTxt, D4D_TCHAR* newTxt, int offset, int size);

/**************************************************************************/ 
typedef int (*D4DLOCALE_GET_TRANSLATE_STR_LEN)(const D4D_TCHAR* originTxt);

typedef struct D4DFILE_FUNCTIONS_S
{
  D4DFILE_FOPEN D4DFILE_fopen;          
  D4DFILE_FCLOSE D4DFILE_fclose;        
  D4DFILE_READ D4DFILE_read;            
  D4DFILE_WRITE D4DFILE_write;          
  D4DFILE_FSEEK D4DFILE_fseek;          
  D4DFILE_FTELL D4DFILE_ftell;          
}D4DFILE_FUNCTIONS;

typedef struct D4DLOCALE_FUNCTIONS_S
{
  D4DLOCALE_TRANSLATE_STR D4DLOCALE_TranslateStr;                       
  D4DLOCALE_GET_TRANSLATE_STR_LEN D4DLOCALE_GetTranslateStrLength;      
}D4DLOCALE_FUNCTIONS;

/******************************************************************************
* Internal types
******************************************************************************/
/******************************************************************************
* D4D External resources macros
*
*/
/**************************************************************************/ 
#define D4D_DECLARE_LOCALE_FUNCTIONS(D4DLOCALE_TranslateStr, D4DLOCALE_GetTranslateStrLength) \
  const D4DLOCALE_FUNCTIONS d4d_extsrcLocale = \
  { \
    D4DLOCALE_TranslateStr, /* Translate locale function pointer */ \
    D4DLOCALE_GetTranslateStrLength  /* Translate locale get str Length function pointer */ \
  };

/**************************************************************************/ 
#define D4D_DECLARE_FILE_FUNCTIONS(D4DFILE_fopen, D4DFILE_fclose, D4DFILE_read, D4DFILE_write, D4DFILE_fseek, D4DFILE_ftell) \
  const D4DFILE_FUNCTIONS d4d_extsrcFile = \
  { \
    D4DFILE_fopen, /* D4D File - fopen */ \
    D4DFILE_fclose, /* D4D File - fclose */ \
    D4DFILE_read, /* D4D File - fread */ \
    D4DFILE_write, /* D4D File - fwrite */ \
    D4DFILE_fseek, /* D4D File - fseek */ \
    D4DFILE_ftell /* D4D File - ftell */ \
  };



#if D4D_ENDIAN == D4D_ENDIAN_LITTLE

  #define D4D_READ8L(x) (x)

  #define D4D_READ16L(x) (x)

  #define D4D_READ32L(x) (x)

  #define D4D_READ8B(x) (x)

  #define D4D_READ16B(x) D4D_SwapWord((x))

  #define D4D_READ32B(x) D4D_SwapLong((x))

  #define D4D_WRITE8L(x) (x)

  #define D4D_WRITE16L(x) (x)

  #define D4D_WRITE32L(x) (x)

  #define D4D_WRITE8B(x) (x)

  #define D4D_WRITE16B(x) D4D_SwapWord((x))

  #define D4D_WRITE32B(x) D4D_SwapLong((x))


#else
  #define D4D_READ8L(x) (x)
  #define D4D_READ16L(x) D4D_SwapWord((x))
  #define D4D_READ32L(x) D4D_SwapLong((x))

  #define D4D_READ8B(x) (x)
  #define D4D_READ16B(x) (x)
  #define D4D_READ32B(x) (x)

  #define D4D_WRITE8L(x) (x)
  #define D4D_WRITE16L(x) D4D_SwapWord((x))
  #define D4D_WRITE32L(x) D4D_SwapLong((x))

  #define D4D_WRITE8B(x) (x)
  #define D4D_WRITE16B(x) (x)
  #define D4D_WRITE32B(x) (x)

#endif



/******************************************************************************
* D4D External resources functions headers
*
*/
#define D4D_FileOpen    d4d_extsrcFile.D4DFILE_fopen

#define D4D_FileClose   d4d_extsrcFile.D4DFILE_fclose

#define D4D_FileRead    d4d_extsrcFile.D4DFILE_read

#define D4D_FileWrite   d4d_extsrcFile.D4DFILE_write

#define D4D_FileSeek    d4d_extsrcFile.D4DFILE_fseek

#define D4D_FileTell    d4d_extsrcFile.D4DFILE_ftell

#ifndef D4D_MemAlloc
  #if defined(__MQX__) || defined(D4D_OS_MQX)
    #define D4D_MemAlloc(size)  _mem_alloc(size)
  #else
    #define D4D_MemAlloc(size)  malloc(size)
  #endif
#endif

#ifndef D4D_MemFree
  #if defined(__MQX__) || defined(D4D_OS_MQX)
    #define D4D_MemFree(pMem)   _mem_free(pMem)
  #else
    #define D4D_MemFree(pMem)   free(pMem)
  #endif
#endif

#ifndef D4D_MemCopy
  #if defined(__MQX__) || defined(D4D_OS_MQX)
    #define D4D_MemCopy(pDst, pSrc, size)   _mem_copy(pSrc, pDst, size)
  #else
    #define D4D_MemCopy(pDst, pSrc, size)   memcpy(pDst, pSrc, size)
  #endif
#endif

/******************************************************************************
* Global variables
******************************************************************************/

extern const D4DLOCALE_FUNCTIONS d4d_extsrcLocale;
extern const D4DFILE_FUNCTIONS d4d_extsrcFile;

/******************************************************************************
* Global functions
******************************************************************************/
D4D_CHAR* D4D_GetFileExtension(D4D_CHAR* pFileName);
D4D_BOOL D4D_FileIsAbsolutePath(D4D_CHAR* pFileName);
int D4D_StrLen(register const D4D_CHAR *s);
D4D_CHAR* D4D_StrCopy(register D4D_CHAR *sd, register const D4D_CHAR *ss);
D4D_WCHAR* D4D_StrCopyAscii2Unicode(register D4D_WCHAR *sd, register const D4D_CHAR *ss);
D4D_CHAR* D4D_StrCopyUnicode2Ascii(register D4D_CHAR *sd, register const D4D_WCHAR *ss);
D4D_CHAR* D4D_StrCat(register D4D_CHAR *sd, register const D4D_CHAR *ss);
D4D_WCHAR* D4D_StrCatUnicode(register D4D_WCHAR *sd, register const D4D_WCHAR *ss);
int D4D_CompareStrings(const D4D_CHAR* s1, const D4D_CHAR* s2);
int D4D_CompareStringsUnicode(const D4D_WCHAR* s1, const D4D_WCHAR* s2);
void D4D_ToUpper(D4D_CHAR* s);
LWord D4D_SwapLong(LWord n);
Word D4D_SwapWord(Word n);

#ifdef D4D_UNICODE
  #define D4D_CompareStringsUniversal(s1, s2) D4D_CompareStringsUnicode(s1, s2)
#else
  #define D4D_CompareStringsUniversal(s1, s2) D4D_CompareStrings(s1, s2)
#endif

#endif /* __D4D_EXTSRC_H */