#ifndef _TMACRO_H_

#define _TMACRO_H_

#if defined(_WIN32) && !defined(WIN32)

#define WIN32

#endif

#ifndef WIN32

#include <sys param.h=""></sys>

#endif

#ifdef WIN32

//#include "tmacroW.h"

#endif

#if defined(DBMALLOC) && !defined(WIN32)

#include "dbmalloc.h"

#endif

/*---------------------------------------------------------------------------*/

#ifdef WIN32

#define TNZ_EXPORT_API __declspec(dllexport)

#define TNZ_IMPORT_API __declspec(dllimport)

#define TNZ_EXPORT_VAR __declspec(dllexport)

#define TNZ_IMPORT_VAR __declspec(dllimport)

#else

#define TNZ_EXPORT_API

#define TNZ_IMPORT_API

#define TNZ_EXPORT_VAR extern

#define TNZ_IMPORT_VAR extern

#endif

/*---------------------------------------------------------------------------*/

#ifndef TRUE

#define TRUE 1

#define FALSE 0

#endif

#define NIL ((void *)0)

typedef int TBOOL;

typedef signed char SCHAR;

typedef unsigned char UCHAR;

typedef unsigned short USHORT;

typedef unsigned int UINT;

typedef unsigned long ULONG;

#define CASE \

	break;   \

	case

#define __OR case

#define DEFAULT \

	break;      \

	default

/*---------------------------------------------------------------------------*/

typedef struct {

	int x0, y0, x1, y1;

} TRECT;

typedef struct {

	double x0, y0, x1, y1;

} TDRECT;

typedef struct {

	int x0, y0, x1, y1;

} TLINE;

typedef struct {

	double x0, y0, x1, y1;

} TDLINE;

typedef struct {

	int x, y;

} TPOINT;

typedef struct {

	double x, y;

} TDPOINT;

/*---------------------------------------------------------------------------*/

#define STR_EQ(s1, s2) (!strcmp((s1), (s2)))

#define STR_NE(s1, s2) (strcmp((s1), (s2)))

#define STR_GE(s1, s2) (strcmp((s1), (s2)) >= 0)

#define STR_LE(s1, s2) (strcmp((s1), (s2)) <= 0)

#define STR_GT(s1, s2) (strcmp((s1), (s2)) > 0)

#define STR_LT(s1, s2) (strcmp((s1), (s2)) < 0)

#define STRN_EQ(s1, s2, n) (!strncmp((s1), (s2), (n)))

#define STRN_NE(s1, s2, n) (strncmp((s1), (s2), (n)))

#define STR_START(s1, s2) (!strncmp((s1), (s2), strlen(s2)))

#define FILESTR_EQ(s1, s2) (!tnz_filestrcmp((s1), (s2)))

#define FILESTR_NE(s1, s2) (tnz_filestrcmp((s1), (s2)))

#define FILESTR_GE(s1, s2) (tnz_filestrcmp((s1), (s2)) >= 0)

#define FILESTR_LE(s1, s2) (tnz_filestrcmp((s1), (s2)) <= 0)

#define FILESTR_GT(s1, s2) (tnz_filestrcmp((s1), (s2)) > 0)

#define FILESTR_LT(s1, s2) (tnz_filestrcmp((s1), (s2)) < 0)

#define FILESTRN_EQ(s1, s2, n) (!tnz_filestrncmp((s1), (s2), (n)))

#define FILESTRN_NE(s1, s2, n) (tnz_filestrncmp((s1), (s2), (n)))

/*---------------------------------------------------------------------------*/

#ifndef MIN

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

#endif

#ifndef MAX

#define MAX(x, y) ((x) > (y) ? (x) : (y))

#endif

#define ROUND(x) ((int)(((int)(-0.9F) == 0 && (x) < 0.0F) ? ((x)-0.5F) : ((x) + 0.5F)))

/* solo per argomenti positivi: */

#define ROUNDP(x) ((int)((x) + 0.5F))

/* equivalenti a (int)floor() e (int)ceil() (ma piu' veloci)

   solo se la risoluzione dell'argomento e' inferiore ad 1 */

#define FLOOR(x) ((int)(x) > (x) ? (int)(x)-1 : (int)(x))

#define CEIL(x) ((int)(x) < (x) ? (int)(x) + 1 : (int)(x))

#define NOT_LESS_THAN(MIN, X) \

	{                         \

		if ((X) < (MIN))      \

			(X) = (MIN);      \

	}

#define NOT_MORE_THAN(MAX, X) \

	{                         \

		if ((X) > (MAX))      \

			(X) = (MAX);      \

	}

#define CROP(X, MIN, MAX) (X < MIN ? MIN : (X > MAX ? MAX : X))

#ifndef MAXINT

#define MAXINT ((int)((~0U) >> 1))

#endif

#ifndef MININT

#define MININT (~MAXINT)

#endif

/*---------------------------------------------------------------------------*/

static const char *const TALLOC_MSG_ =

	"Out of memory allocating %d bytes (%s line %d)";

static const char *const TREALLOC_MSG_ =

	"Out of memory reallocating %d bytes (%s line %d)";

#if defined(WIN32) && defined(_DEBUG)

#define WIN32_DBG_NBFL_ , _NORMAL_BLOCK, __FILE__, __LINE__

#define WIN32_DBG_NB_ , _NORMAL_BLOCK

#define TMALLOC_FUN_ _malloc_dbg

#define TCALLOC_FUN_ _calloc_dbg

#define TREALLOC_FUN_ _realloc_dbg

#define TFREE_FUN_ _free_dbg

#else

#define WIN32_DBG_NBFL_

#define WIN32_DBG_NB_

#define TMALLOC_FUN_ malloc

#define TCALLOC_FUN_ calloc

#define TREALLOC_FUN_ realloc

#define TFREE_FUN_ free

#endif

#define TMALLOC(ptr, elem)                                                     \

	{                                                                          \

		(ptr) = (void *)TMALLOC_FUN_((elem) * sizeof(*(ptr)) WIN32_DBG_NBFL_); \

		if (!ptr)                                                              \

			tmsg_error(TALLOC_MSG_, (int)((elem) * sizeof(*(ptr))), __FILE__,  \

					   __LINE__);                                              \

	}

#define TCALLOC(ptr, elem)                                                    \

	{                                                                         \

		(ptr) = (void *)TCALLOC_FUN_((elem), sizeof(*(ptr)) WIN32_DBG_NBFL_); \

		if (!ptr)                                                             \

			tmsg_error(TALLOC_MSG_, (int)((elem) * sizeof(*(ptr))), __FILE__, \

					   __LINE__);                                             \

	}

#define TREALLOC(ptr, elem)                                                        \

	{                                                                              \

		if (ptr)                                                                   \

			(ptr) = (void *)TREALLOC_FUN_((ptr), (elem) * sizeof(*(ptr))           \

															  WIN32_DBG_NBFL_);    \

		else                                                                       \

			(ptr) = (void *)TMALLOC_FUN_((elem) * sizeof(*(ptr)) WIN32_DBG_NBFL_); \

		if (!ptr)                                                                  \

			tmsg_error(TREALLOC_MSG_, (int)((elem) * sizeof(*(ptr))), __FILE__,    \

					   __LINE__);                                                  \

	}

#define TFREE(ptr)                          \

	{                                       \

		if (ptr) {                          \

			TFREE_FUN_((ptr)WIN32_DBG_NB_); \

			ptr = NIL;                      \

		}                                   \

	}

/*---------------------------------------------------------------------------*/

#define STR_ASSIGN(DST, SRC)          \

	{                                 \

		TFREE(DST);                   \

		DST = SRC ? strsave(SRC) : 0; \

	}

#endif