common.h

Go to the documentation of this file.

/*
 * $Id: common.h 13649 2010-11-26 10:01:36Z xwyan $
 *
 *             MiniGUI for Linux/uClinux, eCos, uC/OS-II, VxWorks, 
 *                     pSOS, ThreadX, NuCleus, OSE, and Win32.
 *
 *             Copyright (C) 2002-2009 Feynman Software.
 *             Copyright (C) 1998-2002 Wei Yongming.
 *
 *             The definitions of some data types and byte order macros 
 *             borrowed from LGPL'ed SDL by Sam Lantinga.
 *
 *             Fix point math routines come from Allegro (a gift software)
 *             by Shawn Hargreaves and others.
 */

#ifndef _MGUI_COMMON_H
#define _MGUI_COMMON_H

#ifndef MINIGUI_MAJOR_VERSION
#  ifdef __MINIGUI_LIB__
#    ifdef _FOR_DATANG
#      ifdef WIN32
#        include <config-win32/mgconfig.h>
#      elif defined (__THREADX__)
#        include "config-threadx/mgconfig.h"
#      elif defined (__NUCLEUS__)
#        include "config-nucleus/mgconfig.h"
#      endif
#    else
#      if  defined(__CMAKE_PROJECT__) || defined(WIN32)
#        include "mgconfig.h"
#      else
#        include "../mgconfig.h"
#      endif
#    endif
#  else
#    include "mgconfig.h"
#    undef PACKAGE_BUGREPORT
#    undef PACKAGE_NAME
#    undef PACKAGE_STRING
#    undef PACKAGE_TARNAME
#    undef PACKAGE_VERSION
#  endif
#endif

#define _VERSION_CODE(major, minor, micro)  (((major)<<16) | ((minor)<<8) | (micro))

#define _MINIGUI_VERSION_CODE \
        ((MINIGUI_MAJOR_VERSION << 16) | (MINIGUI_MINOR_VERSION << 8) | MINIGUI_MICRO_VERSION)

typedef unsigned char   Uint8;
typedef signed char     Sint8;
typedef unsigned short  Uint16;
typedef signed short    Sint16;
typedef unsigned int    Uint32;
typedef signed int      Sint32;

/* Figure out how to support 64-bit datatypes */
#if !defined(__STRICT_ANSI__)
#if defined(__GNUC__)
#define MGUI_HAS_64BIT_TYPE     long long
#endif
#if defined(__CC_ARM)
#define MGUI_HAS_64BIT_TYPE     long long
#endif
#if defined(_MSC_VER)
#define MGUI_HAS_64BIT_TYPE __int64
#endif
#endif /* !__STRICT_ANSI__ */

/* The 64-bit datatype isn't supported on all platforms */
#ifdef MGUI_HAS_64BIT_TYPE

typedef unsigned MGUI_HAS_64BIT_TYPE Uint64;
typedef signed MGUI_HAS_64BIT_TYPE Sint64;
#else
/* This is really just a hack to prevent the compiler from complaining */
typedef struct {
        Uint32 hi;
        Uint32 lo;
} Uint64, Sint64;
#endif

/* Make sure the types really have the right sizes */
#define MGUI_COMPILE_TIME_ASSERT(name, x)               \
       typedef int MGUI_dummy_ ## name[(x) * 2 - 1]

MGUI_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
MGUI_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);
MGUI_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);
MGUI_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);
MGUI_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);
MGUI_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);
MGUI_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
MGUI_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);

#undef MGUI_COMPILE_TIME_ASSERT

#define MGUI_LIL_ENDIAN  1234

#define MGUI_BIG_ENDIAN  4321

/* Pardon the mess, I'm trying to determine the endianness of this host.
 *    I'm doing it by preprocessor defines rather than some sort of configure
 *    script so that application code can use this too.  The "right" way would
 *    be to dynamically generate this file on install, but that's a lot of work.
 */

#if  defined(__i386__) || defined(__ia64__) || \
    (defined(__alpha__) || defined(__alpha)) || \
     defined(__arm__) || \
    (defined(__CC_ARM) && !defined(__BIG_ENDIAN)) || \
    (defined(__mips__) && defined(__MIPSEL__)) || \
     defined(__LITTLE_ENDIAN__) || \
    defined(WIN32)
#define MGUI_BYTEORDER   MGUI_LIL_ENDIAN
#else
#define MGUI_BYTEORDER   MGUI_BIG_ENDIAN
#endif

#ifndef _HAVE_TYPE_BOOL
#ifndef BOOL
typedef int BOOL;
#endif
#endif

#ifndef FALSE
    #define FALSE       0
#endif

#ifndef TRUE
    #define TRUE        1
#endif

#ifndef NULL
#   ifdef __cplusplus
#       define NULL            (0)
#   else
#       define NULL            ((void *)0)
#   endif
#endif

#define GUIAPI

#if !defined(__NODLL__) && (defined (WIN32) || defined (__NUCLEUS_MNT__))
  #if defined(__MINIGUI_LIB__) && !defined(__MGEXT_LIB__)
  #define MG_EXPORT       __declspec(dllexport)
  #else
  #define MG_EXPORT       __declspec(dllimport) 
  #endif
  #if defined(__MGEXT_LIB__)
  #define MGEXT_EXPORT    __declspec(dllexport)
  #else
  #define MGEXT_EXPORT    __declspec(dllimport) 
  #endif
#else
  #define MG_EXPORT
  #define MGEXT_EXPORT
#endif

typedef unsigned int GHANDLE;
typedef unsigned int HWND;
typedef unsigned int HDC;
typedef unsigned int HPALETTE;
typedef unsigned int HCURSOR;
typedef unsigned int HICON;
typedef unsigned int HMENU;
typedef unsigned int HACCEL;
typedef unsigned int HDLG;
typedef unsigned int HHOOK;

#ifndef _HAVE_TYPE_BYTE
typedef unsigned char   BYTE;
#endif

typedef signed char     SBYTE;

#ifndef _HAVE_TYPE_WORD
typedef unsigned short  WORD;
#endif

typedef signed short    SWORD;

#ifndef _HAVE_TYPE_DWORD
typedef unsigned long   DWORD;
#endif

typedef signed long     SDWORD;

#ifndef _HAVE_TYPE_UINT
typedef unsigned int    UINT;
#endif

#ifndef _HAVE_TYPE_LONG
typedef long            LONG;
#endif

typedef unsigned int    WPARAM;

typedef unsigned long   LPARAM;

#define LOBYTE(w)           ((BYTE)(w))

#define HIBYTE(w)           ((BYTE)(((WORD)(w) >> 8) & 0xFF))

#define MAKEWORD(low, high) ((WORD)(((BYTE)(low)) | (((WORD)((BYTE)(high))) << 8)))

#define LOWORD(l)           ((WORD)(DWORD)(l))

#define HIWORD(l)           ((WORD)((((DWORD)(l)) >> 16) & 0xFFFF))

#define LOSWORD(l)          ((SWORD)(DWORD)(l))

#define HISWORD(l)          ((SWORD)((((DWORD)(l)) >> 16) & 0xFFFF))

#define MAKELONG(low, high) ((DWORD)(((WORD)(low)) | (((DWORD)((WORD)(high))) << 16)))

#define GetRValue(rgba)      ((BYTE)(rgba))

#define GetGValue(rgba)      ((BYTE)(((DWORD)(rgba)) >> 8))

#define GetBValue(rgba)      ((BYTE)((DWORD)(rgba) >> 16))

#define GetAValue(rgba)      ((BYTE)((DWORD)(rgba) >> 24))

#define MakeRGBA(r, g, b, a)    (((DWORD)((BYTE)(r))) | ((DWORD)((BYTE)(g)) << 8) \
                | ((DWORD)((BYTE)(b)) << 16) | ((DWORD)((BYTE)(a)) << 24))

#define MakeRGB(r, g, b)    (((DWORD)((BYTE)(r))) | ((DWORD)((BYTE)(g)) << 8) \
                | ((DWORD)((BYTE)(b)) << 16))

typedef DWORD RGBCOLOR;

typedef struct _RECT
{
    int left;
    int top;
    int right;
    int bottom;
} RECT;
typedef RECT* PRECT;

typedef struct _POINT
{
    int x;
    int y;
} POINT;
typedef POINT* PPOINT;

typedef struct _SIZE
{
    int cx;
    int cy;
} SIZE;
typedef SIZE* PSIZE;

typedef struct _RGB
{
    BYTE r;
    BYTE g;
    BYTE b;
    BYTE a;
} RGB;

typedef RGB* PRGB;

typedef Sint8       gal_sint8;
typedef Uint8       gal_uint8;

typedef Sint16      gal_sint16;
typedef Uint16      gal_uint16;

typedef Sint32      gal_sint32;
typedef Uint32      gal_uint32;

typedef signed int      gal_sint;
typedef unsigned int    gal_uint;

typedef Uint32          gal_pixel;
typedef Uint32          gal_attr;

typedef long fixed;

typedef struct _GAL_Color
{
    gal_uint8 r;
    gal_uint8 g;
    gal_uint8 b;
    gal_uint8 a;
} GAL_Color;

typedef struct _GAL_Palette
{
    int        ncolors;
    GAL_Color* colors;
} GAL_Palette;

typedef struct _GAL_Rect {
    Sint32      x, y;
    Sint32      w, h;
} GAL_Rect;

#define MGUI_NR_KEYS                    255

#ifndef NR_KEYS
#define NR_KEYS                         128
#endif

#define SCANCODE_USER                   (NR_KEYS + 1)

#define SCANCODE_ESCAPE                 1

#define SCANCODE_1                      2
#define SCANCODE_2                      3
#define SCANCODE_3                      4
#define SCANCODE_4                      5
#define SCANCODE_5                      6
#define SCANCODE_6                      7
#define SCANCODE_7                      8
#define SCANCODE_8                      9
#define SCANCODE_9                      10
#define SCANCODE_0                      11

#define SCANCODE_MINUS                  12
#define SCANCODE_EQUAL                  13

#define SCANCODE_BACKSPACE              14
#define SCANCODE_TAB                    15

#define SCANCODE_Q                      16
#define SCANCODE_W                      17
#define SCANCODE_E                      18
#define SCANCODE_R                      19
#define SCANCODE_T                      20
#define SCANCODE_Y                      21
#define SCANCODE_U                      22
#define SCANCODE_I                      23
#define SCANCODE_O                      24
#define SCANCODE_P                      25
#define SCANCODE_BRACKET_LEFT           26
#define SCANCODE_BRACKET_RIGHT          27

#define SCANCODE_ENTER                  28

#define SCANCODE_LEFTCONTROL            29

#define SCANCODE_A                      30
#define SCANCODE_S                      31
#define SCANCODE_D                      32
#define SCANCODE_F                      33
#define SCANCODE_G                      34
#define SCANCODE_H                      35
#define SCANCODE_J                      36
#define SCANCODE_K                      37
#define SCANCODE_L                      38
#define SCANCODE_SEMICOLON              39
#define SCANCODE_APOSTROPHE             40
#define SCANCODE_GRAVE                  41

#define SCANCODE_LEFTSHIFT              42
#define SCANCODE_BACKSLASH              43

#define SCANCODE_Z                      44
#define SCANCODE_X                      45
#define SCANCODE_C                      46
#define SCANCODE_V                      47
#define SCANCODE_B                      48
#define SCANCODE_N                      49
#define SCANCODE_M                      50
#define SCANCODE_COMMA                  51
#define SCANCODE_PERIOD                 52
#define SCANCODE_SLASH                  53

#define SCANCODE_RIGHTSHIFT             54
#define SCANCODE_KEYPADMULTIPLY         55

#define SCANCODE_LEFTALT                56
#define SCANCODE_SPACE                  57
#define SCANCODE_CAPSLOCK               58

#define SCANCODE_F1                     59
#define SCANCODE_F2                     60
#define SCANCODE_F3                     61
#define SCANCODE_F4                     62
#define SCANCODE_F5                     63
#define SCANCODE_F6                     64
#define SCANCODE_F7                     65
#define SCANCODE_F8                     66
#define SCANCODE_F9                     67
#define SCANCODE_F10                    68

#define SCANCODE_NUMLOCK                69
#define SCANCODE_SCROLLLOCK             70

#define SCANCODE_KEYPAD7                71
#define SCANCODE_CURSORUPLEFT           71
#define SCANCODE_KEYPAD8                72
#define SCANCODE_CURSORUP               72
#define SCANCODE_KEYPAD9                73
#define SCANCODE_CURSORUPRIGHT          73
#define SCANCODE_KEYPADMINUS            74
#define SCANCODE_KEYPAD4                75
#define SCANCODE_CURSORLEFT             75
#define SCANCODE_KEYPAD5                76
#define SCANCODE_KEYPAD6                77
#define SCANCODE_CURSORRIGHT            77
#define SCANCODE_KEYPADPLUS             78
#define SCANCODE_KEYPAD1                79
#define SCANCODE_CURSORDOWNLEFT         79
#define SCANCODE_KEYPAD2                80
#define SCANCODE_CURSORDOWN             80
#define SCANCODE_KEYPAD3                81
#define SCANCODE_CURSORDOWNRIGHT        81
#define SCANCODE_KEYPAD0                82
#define SCANCODE_KEYPADPERIOD           83

#define SCANCODE_LESS                   86

#define SCANCODE_F11                    87
#define SCANCODE_F12                    88

#define SCANCODE_KEYPADENTER            96
#define SCANCODE_RIGHTCONTROL           97
#define SCANCODE_CONTROL                97
#define SCANCODE_KEYPADDIVIDE           98
#define SCANCODE_PRINTSCREEN            99
#define SCANCODE_RIGHTALT               100
#define SCANCODE_BREAK                  101    /* Beware: is 119     */
#define SCANCODE_BREAK_ALTERNATIVE      119    /* on some keyboards! */

#define SCANCODE_HOME                   102
#define SCANCODE_CURSORBLOCKUP          103    /* Cursor key block */
#define SCANCODE_PAGEUP                 104
#define SCANCODE_CURSORBLOCKLEFT        105    /* Cursor key block */
#define SCANCODE_CURSORBLOCKRIGHT       106    /* Cursor key block */
#define SCANCODE_END                    107
#define SCANCODE_CURSORBLOCKDOWN        108    /* Cursor key block */
#define SCANCODE_PAGEDOWN               109
#define SCANCODE_INSERT                 110
#define SCANCODE_REMOVE                 111

#define SCANCODE_PAUSE                  119

#define SCANCODE_POWER                  120
#define SCANCODE_SLEEP                  121
#define SCANCODE_WAKEUP                 122

#define SCANCODE_LEFTWIN                125
#define SCANCODE_RIGHTWIN               126
#define SCANCODE_MENU                   127

#define SCANCODE_LEFTBUTTON             0x1000
#define SCANCODE_RIGHTBUTTON            0x2000
#define SCANCODE_MIDDLBUTTON            0x4000

#define KS_REPEATED                     0x00000800

#define KS_CAPTURED                     0x00000400

#define KS_IMEPOST                      0x00000200

#define KS_CAPSLOCK                     0x00000100

#define KS_NUMLOCK                      0x00000080

#define KS_SCROLLLOCK                   0x00000040

#define KS_LEFTCTRL                     0x00000020

#define KS_RIGHTCTRL                    0x00000010

#define KS_CTRL                         0x00000030

#define KS_LEFTALT                      0x00000008

#define KS_RIGHTALT                     0x00000004

#define KS_ALT                          0x0000000C

#define KS_LEFTSHIFT                    0x00000002

#define KS_RIGHTSHIFT                   0x00000001

#define KS_SHIFT                        0x00000003

#define MASK_KS_SHIFTKEYS               0x00000FFF

#define KS_LEFTBUTTON                   0x00001000

#define KS_RIGHTBUTTON                  0x00002000

#define KS_MIDDLBUTTON                  0x00004000

#define MASK_KS_BUTTONS                 0x0000F000

#define ERR_OK                   0

#define ERR_INV_HWND            -1

#define ERR_QUEUE_FULL          -2

#define ERR_INVALID_HANDLE      -3

#define ERR_INVALID_HMENU       -4

#define ERR_INVALID_POS         -5

#define ERR_INVALID_ID          -6

#define ERR_RES_ALLOCATION      -7

#define ERR_CTRLCLASS_INVNAME   -8

#define ERR_CTRLCLASS_INVLEN    -9

#define ERR_CTRLCLASS_MEM       -10

#define ERR_CTRLCLASS_INUSE     -11

#define ERR_ALREADY_EXIST       -12

#define ERR_NO_MATCH            -13

#define ERR_BAD_OWNER           -14

#define ERR_IME_TOOMUCHIMEWND   -15

#define ERR_IME_NOSUCHIMEWND    -16

#define ERR_IME_NOIMEWND        -17

#define ERR_CONFIG_FILE         -18

#define ERR_FILE_IO             -19

#define ERR_GFX_ENGINE          -20

#define ERR_INPUT_ENGINE        -21

#define ERR_NO_ENGINE           -22

#define ERR_INVALID_ARGS        -23

#define TABLESIZE(table)    (sizeof(table)/sizeof(table[0]))

/* MAX/MIN/ABS macors */
#ifndef MAX
#define MAX(x, y)           (((x) > (y))?(x):(y))
#endif

#ifndef MIN
#define MIN(x, y)           (((x) < (y))?(x):(y))
#endif

#ifndef ABS
#define ABS(x)              (((x)<0) ? -(x) : (x))
#endif

/* Commonly used definitions */
#if !defined(__NOUNIX__) || defined (__ECOS__)
#include <limits.h>
#endif

#ifndef PATH_MAX
    #define PATH_MAX    256
#endif

#ifndef NAME_MAX
    #define NAME_MAX    64
#endif


#ifndef MAX_PATH
#   define MAX_PATH        PATH_MAX
#endif

#ifndef MAX_NAME
#define MAX_NAME        NAME_MAX
#endif

#ifdef __cplusplus
extern "C" {
#endif

#ifndef HAVE_TIME
typedef unsigned int time_t;

struct tm {
    int    tm_sec;   /* seconds [0,61] */
    int    tm_min;   /* minutes [0,59] */
    int    tm_hour;  /* hour [0,23] */
    int    tm_mday;  /* day of month [1,31] */
    int    tm_mon;   /* month of year [0,11] */
    int    tm_year;  /* years since 1900 */
    int    tm_wday;  /* day of week [0,6] (Sunday = 0) */
    int    tm_yday;  /* day of year [0,365] */
    int    tm_isdst; /* daylight savings flag */
};
#endif

#if defined (__THREADX__) && defined (__TARGET_VFANVIL__)
#include  "fx_api.h"
#include  "tx_api.h"
#include  "os_type.h"
#include  "os_file_api.h"

#define fopen   tp_fopen
#define fclose  tp_fclose
#define fwrite  tp_fwrite
#define fread   tp_fread
#define fseek   tp_fseek
#define feof    tp_feof


#undef assert 
#define _HAVE_ASSERT 1 

#define assert(e) do {              \
                         e;      \
                     } while(0);  

#undef stdin
#undef stdout
#undef stderr

#define stdin ((FILE*)0)
#define stdout ((FILE*)1)
#define stderr ((FILE*)2)
void Comm_Lock_Screen (void);
void Comm_Unlock_Screen (void);

#endif

#ifdef __UCOSII__

/* use our own implementation of strdup */
#undef HAVE_STRDUP
#undef strdup
#define strdup own_strdup

#endif /* __UCOSII__ */

#ifndef HAVE_STRDUP
MG_EXPORT char *strdup(const char *s);
#endif

#ifndef HAVE_STRCASECMP
MG_EXPORT int strcasecmp(const char *s1, const char *s2);
#endif

#ifndef HAVE_STRNCASECMP
MG_EXPORT int strncasecmp(const char *s1, const char *s2, unsigned int n);
#endif

#ifdef _MGUSE_OWN_MALLOC

int init_minigui_malloc (unsigned char* heap, unsigned int heap_size, 
                int (*lock_heap) (void), int (*unlock_heap) (void));

#define USE_DL_PREFIX

#include "own_malloc.h"

/* wrappers for malloc functions */
#define calloc      dlcalloc
#define free        dlfree
#define malloc      dlmalloc
#define memalign    dlmemalign
#define realloc     dlrealloc
#define valloc      dlvalloc

#endif

/* Do not use the alloca of ARMCC */
#if defined(__CC_ARM)
#   undef HAVE_ALLOCA
#   undef HAVE_ALLOCA_H
#endif

#ifdef HAVE_ALLOCA_H
#   include <alloca.h>
#   define ALLOCATE_LOCAL(size)    alloca((int)(size))
#   define DEALLOCATE_LOCAL(ptr)   /* as nothing */
#else
#   define ALLOCATE_LOCAL(size)    malloc((int)(size))
#   define DEALLOCATE_LOCAL(ptr)   free(ptr)
#endif

#ifdef _MGUSE_OWN_STDIO

int init_minigui_printf (int (*output_char) (int ch), 
                int (*input_char) (void));

#if defined (__UCOSII__) || defined (__VXWORKS__) || defined (__NUCLEUS__) || defined (__PSOS__)
#   undef _PRINTF_FLOATING_POINT
#   undef _SCANF_FLOATING_POINT
#else
#   ifdef HAVE_MATH_H
#       define _PRINTF_FLOATING_POINT      1
#       define _SCANF_FLOATING_POINT       1
#   endif
#endif

#ifdef WIN32
#   include <float.h>
#   define isnan        _isnan
#   define finite       _finite
#endif

#undef _I18N_MB_REQUIRED

#if defined(__VXWORKS__) || defined(WIN32) || defined (__NUCLEUS_MNT__) || defined (__PSOS__)
  #define _MGUSE_OWN_SNPRINTF
  #define _MGUSE_OWN_VSNPRINTF
  #define _MGUSE_OWN_VFNPRINTF
#else
  #define _MGUSE_OWN_PRINTF
  #define _MGUSE_OWN_FPRINTF
  #define _MGUSE_OWN_SPRINTF
  #define _MGUSE_OWN_FNPRINTF
  #define _MGUSE_OWN_SNPRINTF
  #define _MGUSE_OWN_VPRINTF
  #define _MGUSE_OWN_VFPRINTF
  #define _MGUSE_OWN_VSPRINTF
  #define _MGUSE_OWN_VFNPRINTF
  #define _MGUSE_OWN_VSNPRINTF
  #define _MGUSE_OWN_SCANF
  #define _MGUSE_OWN_FSCANF
  #define _MGUSE_OWN_SSCANF
  #define _MGUSE_OWN_VSCANF
  #define _MGUSE_OWN_VFSCANF
  #define _MGUSE_OWN_VSSCANF
#endif

#include "own_stdio.h"

/* wrappers for stdio functions */
#ifdef _MGUSE_OWN_PRINTF
  #define printf      own_printf
#endif

#ifdef _MGUSE_OWN_FPRINTF
  #define fprintf     own_fprintf
#endif

#ifdef _MGUSE_OWN_SPRINTF
  #define sprintf     own_sprintf
#endif

#ifdef _MGUSE_OWN_FNPRINTF
  #define fnprintf    own_fnprintf
#endif

#ifdef _MGUSE_OWN_SNPRINTF
  #define snprintf    own_snprintf
#endif

#ifdef _MGUSE_OWN_VPRINTF
  #define vprintf     own_vprintf
#endif

#ifdef _MGUSE_OWN_VFPRINTF
  #define vfprintf    own_vfprintf
#endif

#ifdef _MGUSE_OWN_VSPRINTF
  #define vsprintf    own_vsprintf
#endif

#ifdef _MGUSE_OWN_VFNPRINTF
  #define vfnprintf   own_vfnprintf
#endif

#ifdef _MGUSE_OWN_VSNPRINTF
  #define vsnprintf   own_vsnprintf
#endif

#ifdef _MGUSE_OWN_SCANF
  #define scanf       own_scanf
#endif

#ifdef _MGUSE_OWN_FSCANF
  #define fscanf      own_fscanf
#endif

#ifdef _MGUSE_OWN_SSCANF
  #define sscanf      own_sscanf
#endif

#ifdef _MGUSE_OWN_VSCANF
  #define vscanf      own_vscanf
#endif

#ifdef _MGUSE_OWN_VFSCANF
  #define vfscanf     own_vfscanf
#endif

#ifdef _MGUSE_OWN_VSSCANF
  #define vsscanf     own_vsscanf
#endif

#endif /* _MGUSE_OWN_STDIO */

#if defined(__GNUC__)
#ifdef _DEBUG
#   define _MG_PRINTF(fmt...) fprintf (stderr, fmt)
#else
#   define _MG_PRINTF(fmt...)
#endif
#else /* __GNUC__ */
#include <stdio.h>
#include <stdarg.h>

static inline void _MG_PRINTF(const char* fmt, ...)
{
#ifdef _DEBUG
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
    va_end(ap);
#endif
}
#endif /* __GNUC__ */

#ifdef _MGRM_THREADS

#ifdef _MGUSE_OWN_PTHREAD

#define MAIN_PTH_MIN_STACK_SIZE (1024)
#define MAIN_PTH_DEF_STACK_SIZE (1024*4)

int start_minigui_pthread (int (* pth_entry) (int argc, const char* argv []), 
                int argc, const char* argv[], 
                char* stack_base, unsigned int stack_size);

#include <errno.h>

#ifndef ESRCH
# define ESRCH      3
#endif

#ifndef EAGAIN
# define EAGAIN     11
#endif

#ifndef ENOMEM
# define ENOMEM     12
#endif

#ifndef EBUSY
# define EBUSY      16
#endif

#ifndef EINVAL
# define EINVAL     22
#endif

#ifndef EDEADLK
# define EDEADLK    35
#endif

#ifndef ENOSYS
# define ENOSYS     38
#endif

#ifndef ENOTSUP
# define ENOTSUP    95
#endif

#ifdef __VXWORKS__

#define pthread_create vxworks_pthread_create
#define pthread_self   vxworks_pthread_self
#define pthread_equal  vxworks_pthread_equal
#define pthread_exit   vxworks_pthread_exit
#define pthread_join   vxworks_pthread_join
#define pthread_detach vxworks_pthread_detach
#define pthread_cancel vxworks_pthread_cancel
#define pthread_once   vxworks_pthread_once
#define pthread_key_create vxworks_pthread_key_create
#define pthread_key_delete vxworks_pthread_key_delete
#define pthread_setspecific vxworks_pthread_setspecific
#define pthread_getspecific vxworks_pthread_getspecific
#define pthread_setcancelstate vxworks_pthread_setcancelstate
#define pthread_setcanceltype vxworks_pthread_setcanceltype
#define pthread_testcancel vxworks_pthread_testcancel

#define pthread_attr_init    vxworks_pthread_attr_init
#define pthread_attr_destroy vxworks_pthread_attr_destroy
#define pthread_attr_setdetachstate vxworks_pthread_attr_setdetachstate
#define pthread_attr_getdetachstate vxworks_pthread_attr_getdetachstate
#define pthread_attr_setscope vxworks_pthread_attr_setscope
#define pthread_attr_getscope vxworks_pthread_attr_getscope
#define pthread_attr_setinheritsched vxworks_pthread_attr_setinheritsched
#define pthread_attr_getinheritsched vxworks_pthread_attr_getinheritsched
#define pthread_attr_setschedpolicy vxworks_pthread_attr_setschedpolicy
#define pthread_attr_getschedpolicy vxworks_pthread_attr_getschedpolicy
#define pthread_attr_setschedparam vxworks_pthread_attr_setschedparam
#define pthread_attr_getschedparam vxworks_pthread_attr_getschedparam
#define pthread_attr_setstackaddr vxworks_pthread_attr_setstackaddr
#define pthread_attr_getstackaddr vxworks_pthread_attr_getstackaddr
#define pthread_attr_setstacksize vxworks_pthread_attr_setstacksize
#define pthread_attr_getstacksize vxworks_pthread_attr_getstacksize
#define pthread_setschedparam vxworks_pthread_setschedparam
#define pthread_getschedparam vxworks_pthread_getschedparam

#define pthread_mutex_init  vxworks_pthread_mutex_init
#define pthread_mutex_destroy vxworks_pthread_mutex_destroy
#define pthread_mutex_lock  vxworks_pthread_mutex_lock
#define pthread_mutex_unlock vxworks_pthread_mutex_unlock
#define pthread_mutex_trylock vxworks_pthread_mutex_trylock
#define pthread_mutexattr_init vxworks_pthread_mutexattr_init
#define pthread_mutexattr_destroy vxworks_pthread_mutexattr_destroy
#define pthread_mutexattr_setpriorityinherit vxworks_pthread_mutexattr_setpriorityinherit
#define pthread_mutexattr_getpriorityinherit vxworks_pthread_mutexattr_getpriorityinherit

#ifdef _MGUSE_OWN_SEMAPHORE

#define sem_t vxworks_sem_t

#define sem_init vxworks_sem_init
#define sem_destroy vxworks_sem_destroy
#define sem_wait vxworks_sem_wait
#define sem_trywait vxworks_sem_trywait
#define sem_post vxworks_sem_post
#define sem_getvalue vxworks_sem_getvalue

#endif /* _MGUSE_OWN_SEMAPHORE */

#endif /* __VXWORKS__ */

#ifdef __MINIGUI_LIB__

#ifdef __UCOSII__
  #include "ucos2_pthread.h"
  #include "ucos2_semaphore.h"
#elif defined (__THREADX__)
  #include "threadx_pthread.h"
  #include "threadx_semaphore.h"
#elif defined (__NUCLEUS__)
  #include "nucleus_pthread.h"
  #include "nucleus_semaphore.h"
#elif defined (__VXWORKS__)
  #include "vxworks_pthread.h"
  #ifdef _MGUSE_OWN_SEMAPHORE
    #include "vxworks_semaphore.h"
  #else
    #include "semaphore.h"
  #endif
#elif defined (__OSE__)
  #include "pthread.h"
  #include "ose_semaphore.h"
#elif defined (__PSOS__)
  #include "psos_pthread.h"
  #include "psos_semaphore.h"
#elif defined (WIN32)
  #include "win32_pthread.h"
  #include "win32_semaphore.h"
#else
#error No own pthread implementation for this OS!
#endif
#else
#include <pthread.h>
#include <semaphore.h>
#endif /* __MINIGUI_LIB__ */

#else /* _MGUSE_OWN_PTHREAD */

#include <pthread.h>
#include <semaphore.h>

#endif /* !_MGUSE_OWN_PTHREAD */

#ifdef __DARWIN__

#define _USE_SEM_ON_SYSVIPC     1

#endif

#if defined (_USE_MUTEX_ON_SYSVIPC) || defined (_USE_SEM_ON_SYSVIPC)

int _sysvipc_mutex_sem_init (void);
int _sysvipc_mutex_sem_term (void);

#endif

#ifdef _USE_MUTEX_ON_SYSVIPC

#define pthread_mutex_t _sysvipc_pthread_mutex_t
#define pthread_mutexattr_t _sysvipc_pthread_mutexattr_t

#define pthread_mutexattr_init _sysvipc_pthread_mutexattr_init 
#define pthread_mutexattr_destroy _sysvipc_pthread_mutexattr_destroy 
#define pthread_mutexattr_settype _sysvipc_pthread_mutexattr_settype 
#define pthread_mutexattr_gettype _sysvipc_pthread_mutexattr_gettype

#define pthread_init _sysvipc_pthread_init 
#define pthread_mutex_init _sysvipc_pthread_mutex_init 
#define pthread_mutex_destroy _sysvipc_pthread_mutex_destroy
#define pthread_mutex_lock _sysvipc_pthread_mutex_lock 
#define pthread_mutex_trylock _sysvipc_pthread_mutex_trylock 
#define pthread_mutex_unlock _sysvipc_pthread_mutex_unlock 

typedef struct
{
    int kind;
    int semid;
    int sem_num;
    int locked_times;
} pthread_mutex_t;

#define SYSVIPC_PTHREAD_MUTEX_FAST_NP         0
#define SYSVIPC_PTHREAD_MUTEX_RECURSIVE_NP    1
#define SYSVIPC_PTHREAD_MUTEX_ERRORCHECK_NP   2

typedef struct
{
    int kind;
} pthread_mutexattr_t;

int pthread_mutexattr_init (pthread_mutexattr_t *attr);
int pthread_mutexattr_destroy (pthread_mutexattr_t *attr);
int pthread_mutexattr_settype (pthread_mutexattr_t *attr, int type);
int pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int* type);

int pthread_mutex_init (pthread_mutex_t *mutex,
                                const pthread_mutexattr_t *mutex_attr);

int pthread_mutex_destroy (pthread_mutex_t *mutex);

int pthread_mutex_lock (pthread_mutex_t *mutex);
int pthread_mutex_trylock (pthread_mutex_t *mutex);
int pthread_mutex_unlock (pthread_mutex_t *mutex);

#endif /* _USE_MUTEX_ON_SYSVIPC */

#ifdef _USE_SEM_ON_SYSVIPC

#define sem_t _sysvipc_sem_t

#define sem_init _sysvipc_sem_init
#define sem_destroy _sysvipc_sem_destroy
#define sem_wait _sysvipc_sem_wait
#define sem_trywait _sysvipc_sem_trywait
#define sem_post _sysvipc_sem_post
#define sem_getvalue _sysvipc_sem_getvalue

#define SYSVIPC_SEM_VALUE_MAX   USHRT_MAX

/*-----------------------------------------------------------------------------
** Semaphore object definition
*/

typedef struct
{
    int semid;
    int sem_num;
} sem_t;

int sem_init (sem_t *sem, int pshared, unsigned int value);
int sem_destroy (sem_t *sem);
int sem_wait (sem_t *sem);
int sem_trywait (sem_t *sem);
int sem_post (sem_t *sem);
int sem_getvalue (sem_t *sem, int *sval);

#endif /* _USE_SEM_ON_SYSVIPC */

#endif /* _MGRM_THREADS */

#ifdef __cplusplus
}  /* end of extern "C" */
#endif

#endif /* _MGUI_COMMON_H */