common.h

Go to the documentation of this file.

/*
 * $Id: common.h 13674 2010-12-06 06:45:01Z wanzheng $
 *
 *      MiniGUI for Linux/uClinux, eCos, uC/OS-II, VxWorks, 
 *      pSOS, ThreadX, NuCleus, OSE, and Win32.
 *
 *      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
#   undef PACKAGE
#   undef VERSION
#   undef PACKAGE_BUGREPORT
#   undef PACKAGE_NAME
#   undef PACKAGE_STRING
#   undef PACKAGE_TARNAME
#   undef PACKAGE_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"
#   endif
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdarg.h>
#include <errno.h>
#include <assert.h>

#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(__x86_64__) || defined(__amd64) || \
        (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

typedef void *PVOID;

#ifndef BOOL
typedef int BOOL;
#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 INV_PTR                ((void *)-1)

#define GUIAPI

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

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

typedef unsigned char   BYTE;

typedef signed char     SBYTE;

#if defined(_WIN64)
#   define SIZEOF_PTR   8
#   define SIZEOF_HPTR  4
#elif defined(__LP64__)
#   define SIZEOF_PTR   8
#   define SIZEOF_HPTR  4
#else
#   define SIZEOF_PTR   4
#   define SIZEOF_HPTR  2
#endif

#if SIZEOF_PTR == 8
#   define NR_BITS_BYTE      (8)
#   define NR_BITS_WORD      (32)
#   define NR_BITS_DWORD     (64)

#   define BITMASK_BYTE      (0xFF)
#   define BITMASK_WORD      (0xFFFFFFFF)
#   define BITMASK_DWORD     (0xFFFFFFFFFFFFFFFF)

#   define INT_PTR_MIN       (-9223372036854775807L-1)
#   define INT_PTR_MAX       (9223372036854775807L)
#   define UINT_PTR_MAX      (18446744073709551615UL)
#else  
#   define NR_BITS_BYTE      (8)
#   define NR_BITS_WORD      (16)
#   define NR_BITS_DWORD     (32)

#   define BITMASK_BYTE      (0xFF)
#   define BITMASK_WORD      (0xFFFF)
#   define BITMASK_DWORD     (0xFFFFFFFF)

#   define INT_PTR_MIN       (-2147483647-1)
#   define INT_PTR_MAX       (2147483647)
#   define UINT_PTR_MAX      (4294967295U)
#endif  

#if defined(_WIN64)
typedef unsigned int WORD_HPTR;
#elif defined(__LP64__)
typedef unsigned int WORD_HPTR;
#else
typedef unsigned short WORD_HPTR;
#endif

#if defined(_WIN64)
typedef signed int SWORD_HPTR;
#elif defined(__LP64__)
typedef signed int SWORD_HPTR;
#else
typedef signed short SWORD_HPTR;
#endif

typedef WORD_HPTR WORD;

typedef SWORD_HPTR SWORD;

typedef unsigned short WORD16;

typedef signed short SWORD16;

#if defined(_WIN64)
typedef __int64 LONG_PTR;
#elif defined(__LP64__)
typedef long LONG_PTR;
#else
typedef long LONG_PTR;
#endif

typedef LONG_PTR LINT;

typedef LONG_PTR LRESULT;

#if defined(_WIN64)
typedef unsigned __int64 DWORD_PTR;
#elif defined(__LP64__)
typedef unsigned long DWORD_PTR;
#else
typedef unsigned long DWORD_PTR;
#endif

typedef DWORD_PTR DWORD;

typedef unsigned int DWORD32;

#if defined(_WIN64)
typedef signed __int64 SDWORD_PTR;
#elif defined(__LP64__)
typedef signed long SDWORD_PTR;
#else
typedef signed long SDWORD_PTR;
#endif

typedef SDWORD_PTR SDWORD;

typedef signed int SDWORD32;

typedef unsigned int UINT;

#if defined(_WIN64)
typedef __int64 INT_PTR;
#elif defined(__LP64__)
typedef long INT_PTR;
#else
typedef int INT_PTR;
#endif

#if defined(_WIN64)
typedef unsigned __int64 UINT_PTR;
#elif defined(__LP64__)
typedef unsigned long UINT_PTR;
#else
typedef unsigned long UINT_PTR;
#endif

typedef long LONG;

typedef unsigned long ULONG;

typedef UINT_PTR WPARAM;

typedef UINT_PTR LPARAM;

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

#define HIBYTE(w)           ((BYTE)(((WORD)(w) >> NR_BITS_BYTE) & BITMASK_BYTE))

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

#define MAKEWORD16(low, high) ((WORD16)(((BYTE)(low)) | (((WORD16)((BYTE)(high))) << 8)))

#define MAKEWPARAM(first, second, third, fourth) \
    ((WPARAM)( \
        ((BYTE)(first)) | \
        (((WPARAM)((BYTE)(second))) << 8) | \
        (((WPARAM)((BYTE)(third))) << 16) | \
        (((WPARAM)((BYTE)(fourth))) << 24) \
    ))

#define FIRSTBYTE(w)        ((BYTE)(w))

#define SECONDBYTE(w)        ((BYTE)(((DWORD32)(w)) >> 8))

#define THIRDBYTE(w)        ((BYTE)(((DWORD32)(w)) >> 16))

#define FOURTHBYTE(w)        ((BYTE)(((DWORD32)(w)) >> 24))

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

#define HIWORD(l)           ((WORD)((((DWORD)(l)) >> NR_BITS_WORD) & BITMASK_WORD))

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

#define HISWORD(l)          ((SWORD)((((DWORD)(l)) >> NR_BITS_WORD) & BITMASK_WORD))

#define MAKELONG32(low, high) ((DWORD32)(((WORD16)(low)) | (((DWORD32)((WORD16)(high))) << 16)))

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

typedef DWORD32 RGBCOLOR;

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

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

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

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

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

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

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 */

#ifdef __LINUX__
    #define TCS_NONE(fp)            fprintf (fp, "\e[0m")
    #define TCS_BLACK(fp)           fprintf (fp, "\e[0;30m")
    #define TCS_BOLD_BLACK(fp)      fprintf (fp, "\e[1;30m")
    #define TCS_RED(fp)             fprintf (fp, "\e[0;31m")
    #define TCS_BOLD_RED(fp)        fprintf (fp, "\e[1;31m")
    #define TCS_GREEN(fp)           fprintf (fp, "\e[0;32m")
    #define TCS_BOLD_GREEN(fp)      fprintf (fp, "\e[1;32m")
    #define TCS_BROWN(fp)           fprintf (fp, "\e[0;33m")
    #define TCS_YELLOW(fp)          fprintf (fp, "\e[1;33m")
    #define TCS_BLUE(fp)            fprintf (fp, "\e[0;34m")
    #define TCS_BOLD_BLUE(fp)       fprintf (fp, "\e[1;34m")
    #define TCS_PURPLE(fp)          fprintf (fp, "\e[0;35m")
    #define TCS_BOLD_PURPLE(fp)     fprintf (fp, "\e[1;35m")
    #define TCS_CYAN(fp)            fprintf (fp, "\e[0;36m")
    #define TCS_BOLD_CYAN(fp)       fprintf (fp, "\e[1;36m")
    #define TCS_GRAY(fp)            fprintf (fp, "\e[0;37m")
    #define TCS_WHITE(fp)           fprintf (fp, "\e[1;37m")
    #define TCS_BOLD(fp)            fprintf (fp, "\e[1m")
    #define TCS_UNDERLINE(fp)       fprintf (fp, "\e[4m")
    #define TCS_BLINK(fp)           fprintf (fp, "\e[5m")
    #define TCS_REVERSE(fp)         fprintf (fp, "\e[7m")
    #define TCS_HIDE(fp)            fprintf (fp, "\e[8m")
    #define TCS_CLEAR(fp)           fprintf (fp, "\e[2J")
    #define TCS_CLRLINE(fp)         fprintf (fp, "\e[1K\r")
#else
    #define TCS_NONE(fp)
    #define TCS_BLACK(fp)
    #define TCS_BOLD_BLACK(fp)
    #define TCS_RED(fp)
    #define TCS_BOLD_RED(fp)
    #define TCS_GREEN(fp)
    #define TCS_BOLD_GREEN(fp)
    #define TCS_BROWN(fp)
    #define TCS_YELLOW(fp)
    #define TCS_BLUE(fp)
    #define TCS_BOLD_BLUE(fp)
    #define TCS_PURPLE(fp)
    #define TCS_BOLD_PURPLE(fp)
    #define TCS_CYAN(fp)
    #define TCS_BOLD_CYAN(fp)
    #define TCS_GRAY(fp)
    #define TCS_WHITE(fp)
    #define TCS_BOLD(fp)
    #define TCS_UNDERLINE(fp)
    #define TCS_BLINK(fp)
    #define TCS_REVERSE(fp)
    #define TCS_HIDE(fp)
    #define TCS_CLEAR(fp)
    #define TCS_CLRLINE(fp)
#endif

#if defined(__GNUC__)
#   define _ERR_PRINTF(fmt...)      \
        do {                        \
            TCS_BOLD_RED (stderr);  \
            fprintf (stderr, fmt);  \
            TCS_NONE (stderr);      \
        } while (0)
#   ifdef _DEBUG
#       define _MG_PRINTF(fmt...)   \
        do {                        \
            TCS_GREEN (stderr);     \
            fprintf (stderr, fmt);  \
            TCS_NONE (stderr);      \
        } while (0)
        
#       ifdef DEBUG
#           define _DBG_PRINTF(fmt...)  \
        do {                            \
            TCS_YELLOW (stderr);        \
            fprintf (stderr, fmt);      \
            TCS_NONE (stderr);          \
        } while (0)
#       else
#           define _DBG_PRINTF(fmt...)
#       endif
#   else
#       define _MG_PRINTF(fmt...)
#       define _DBG_PRINTF(fmt...)
#   endif
#else /* __GNUC__ */

static inline void _ERR_PRINTF(const char* fmt, ...)
{
    va_list ap;
    va_start (ap, fmt);
    TCS_BOLD_RED (stderr);
    vfprintf (stderr, fmt, ap);
    TCS_NONE (stderr);
    va_end (ap);
}
static inline void _MG_PRINTF(const char* fmt, ...)
{
#ifdef DEBUG
    va_list ap;
    va_start (ap, fmt);
    TCS_GREEN (stderr);
    vfprintf (stderr, fmt, ap);
    TCS_NONE (stderr);
    va_end (ap);
#endif
}

static inline void _DBG_PRINTF(const char* fmt, ...)
{
#if defined(DEBUG) && defined(_DEBUG)
    va_list ap;
    va_start (ap, fmt);
    TCS_YELLOW (stderr);
    vfprintf (stderr, fmt, ap);
    TCS_NONE (stderr);
    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);

#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 */