diff options
Diffstat (limited to 'drivers/staging/epl/global.h')
| -rw-r--r-- | drivers/staging/epl/global.h | 1391 |
1 files changed, 1391 insertions, 0 deletions
diff --git a/drivers/staging/epl/global.h b/drivers/staging/epl/global.h new file mode 100644 index 000000000000..fe167165a836 --- /dev/null +++ b/drivers/staging/epl/global.h @@ -0,0 +1,1391 @@ +/**************************************************************************** + + global project definition file + + 12.06.1998 -rs + 11.02.2002 r.d. Erweiterungen, Ergaenzungen + 20.08.2002 SYS TEC electronic -as + Definition Schluesselwort 'GENERIC' + fuer das Erzeugen von Generic Pointer + 28.08.2002 r.d. erweiterter SYS TEC Debug Code + 16.09.2002 r.d. komplette Uebersetzung in Englisch + 11.04.2003 f.j. Ergaenzung fuer Mitsubishi NC30 Compiler + 17.06.2003 -rs Definition von Basistypen in <#ifndef _WINDEF_> gesetzt + 16.04.2004 r.d. Ergaenzung fuer Borland C++ Builder + 30.08.2004 -rs TRACE5 eingefügt + 23.12.2005 d.k. Definitions for IAR compiler + + $Id: global.h,v 1.6 2008/11/07 13:55:56 D.Krueger Exp $ + +****************************************************************************/ + +#ifndef _GLOBAL_H_ +#define _GLOBAL_H_ + +//--------------------------------------------------------------------------- +// elements of defines for development system +//--------------------------------------------------------------------------- + +// these defines are necessary to check some of characteristics of the development system +#define _DEV_BIGEND_ 0x80000000L // big endian (motorolla format) +#define _DEV_ALIGNMENT_4_ 0x00400000L // the CPU needs alignment of 4 bytes +#define _DEV_ONLY_INT_MAIN_ 0x00004000L // the compiler needs "int main(int)" instead of "void main(void)" +#define _DEV_COMMA_EXT_ 0x00002000L // support of last comma in struct predefinition +#define _DEV_64BIT_SUPPORT_ 0x00001000L // support of 64 bit operations +#define _DEV_BIT64_ 0x00000400L // count of bits: 64 bit +#define _DEV_BIT32_ 0x00000300L // 32 bit +#define _DEV_BIT16_ 0x00000200L // 16 bit +#define _DEV_BIT8_ 0x00000100L // 8 bit +#define _DEV_RVCT_ARM_ 0x0000001CL // RealView ARM +#define _DEV_RENESASM32C 0x0000001BL // compiler from: Renesas +#define _DEV_GNUC_MIPS2_ 0x0000001AL // GNU for MIPS2 +#define _DEV_MPLAB_C30_ 0x00000019L // MPLAB C30 for Microchip dsPIC33F series +#define _DEV_GNUC_TC_ 0x00000018L // GNU for Infineon TriCore +#define _DEV_GNUC_X86_ 0x00000017L // GNU for I386 +#define _DEV_IAR_ARM_ 0x00000016L // ARM IAR C/C++ Compiler +#define _DEV_PARADGM_X86 0x00000015L // Paradigm C/C++ for Beck 1x3 +#define _DEV_GNUC_CF_ 0x00000014L // GNU for Coldfire +#define _DEV_KEIL_ARM_ 0x00000013L // Keil ARM +#define _DEV_MSEVC_ 0x00000012L // Microsoft embedded Visual C/C++ +#define _DEV_HIGHTEC_GNUC_X86_ 0x00000011L // Hightec elf386 gcc +#define _DEV_MSVC_RTX_ 0x00000010L // VC600 + RTX +#define _DEV_MSVC_V1_5_ 0x0000000FL // Microsoft Visual C/C++ V1.5 +#define _DEV_GNUC_ARM7_ 0x0000000EL // GNU Compiler gcc for ARM7 +#define _DEV_METROWERKS_CW_ 0x0000000DL // Metrowerks Code Warrior +#define _DEV_MITSUBISHIM16C_ 0x0000000CL //compiler from: Mitsubishi +#define _DEV_GNUC_C16X_ 0x0000000BL // GNU Compiler gcc166 for Infineon C16x +#define _DEV_LINUX_GCC_ 0x0000000AL // Linux GNU Compiler gcc +#define _DEV_GNUC_MPC5X5 0x00000009L // GNU for Motorola PPC5x5 +#define _DEV_TASKINGM16C_ 0x00000008L // Tasking for Mitsubishi M16C +#define _DEV_FUJITSU_ 0x00000007L // Fujitsu +#define _DEV_TASKING8_ 0x00000006L // Tasking 8051 +#define _DEV_TASKING16_ 0x00000005L // Tasking 166 +#define _DEV_KEIL8_ 0x00000004L // Keil C51 +#define _DEV_KEIL16_ 0x00000003L // Keil C166 +#define _DEV_BORLANDC_ 0x00000002L // Borland C/C++ +#define _DEV_MSVC16_ 0x00000001L // Microsoft Visual C/C++ +#define _DEV_MSVC32_ 0x00000000L // Microsoft Visual C/C++ + +// these defines can be used to mask previous elements +#define _DEV_MASK_COMPILER 0x000000FFL +#define _DEV_MASK_BITCOUNT 0x00000F00L +#define _DEV_MASK_ADDSUPPORT 0x0000F000L +#define _DEV_MASK_ALIGNMENT 0x00F00000L + +//--------------------------------------------------------------------------- +// defines for development system (DEV_SYSTEM) including previous elements +//--------------------------------------------------------------------------- + +#define _DEV_WIN16_ (_DEV_BIT16_ | _DEV_MSVC16_ ) +#define _DEV_WIN32_ (_DEV_BIT32_ | _DEV_MSVC32_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_MSVC_DOS_ (_DEV_BIT32_ | _DEV_MSVC_V1_5_ ) +#define _DEV_BORLAND_DOS_ (_DEV_BIT32_ | _DEV_BORLANDC_ ) //| _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_KEIL_C51X_ (_DEV_BIT8_ | _DEV_KEIL8_ | _DEV_BIGEND_ | _DEV_COMMA_EXT_) // at least C51 version 7.05 supports comma extension +#define _DEV_KEIL_C16X_ (_DEV_BIT16_ | _DEV_KEIL16_ | _DEV_COMMA_EXT_) // at least C166 version 5.03 supports comma extension +#define _DEV_TASKING_C51X_ (_DEV_BIT8_ | _DEV_TASKING8_ | _DEV_BIGEND_) +#define _DEV_TASKING_C16X_ (_DEV_BIT16_ | _DEV_TASKING16_ ) +#define _DEV_FUJITSU_F590_ (_DEV_BIT8_ | _DEV_FUJITSU_ | _DEV_COMMA_EXT_) // softune is not able to support 64 bit variables QWORD !!! +//f.j.29.04.03 M16C kann effektiv mit Bytes umgehen +//#define _DEV_TASKING_M16C_ (_DEV_BIT16_ | _DEV_TASKINGM16C_ ) +#define _DEV_TASKING_M16C_ (_DEV_BIT8_ | _DEV_TASKINGM16C_ ) +#define _DEV_MITSUBISHI_M16C_ (_DEV_BIT8_ | _DEV_MITSUBISHIM16C_ ) +#define _DEV_GNU_MPC5X5_ (_DEV_BIT32_ | _DEV_GNUC_MPC5X5| _DEV_BIGEND_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_LINUX_ (_DEV_BIT32_ | _DEV_LINUX_GCC_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_GNU_C16X_ (_DEV_BIT16_ | _DEV_GNUC_C16X_ ) //| _DEV_COMMA_EXT_) +#define _DEV_MCW_MPC5X5_ (_DEV_BIT32_ | _DEV_METROWERKS_CW_ ) //| _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_GNU_ARM7_ (_DEV_BIT32_ | _DEV_GNUC_ARM7_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_ | _DEV_ONLY_INT_MAIN_) +#define _DEV_WIN32_RTX_ (_DEV_BIT32_ | _DEV_MSVC_RTX_ ) //| _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_HIGHTEC_X86_ (_DEV_BIT32_ | _DEV_HIGHTEC_GNUC_X86_ ) //| _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_WIN_CE_ (_DEV_BIT32_ | _DEV_MSEVC_ ) //| _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_KEIL_CARM_ (_DEV_BIT32_ | _DEV_KEIL_ARM_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_IAR_CARM_ (_DEV_BIT32_ | _DEV_IAR_ARM_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_RVCT_CARM_ (_DEV_BIT32_ | _DEV_RVCT_ARM_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_ | _DEV_ONLY_INT_MAIN_) +#define _DEV_MCW_MCF5XXX_ (_DEV_BIT32_ | _DEV_METROWERKS_CW_ ) //| _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_GNU_CF5282_ (_DEV_BIT32_ | _DEV_GNUC_CF_ | _DEV_BIGEND_) +#define _DEV_PAR_BECK1X3_ (_DEV_BIT16_ | _DEV_PARADGM_X86) +#define _DEV_GNU_CF548X_ (_DEV_BIT32_ | _DEV_GNUC_CF_ | _DEV_BIGEND_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_) +#define _DEV_GNU_I386_ (_DEV_BIT32_ | _DEV_GNUC_X86_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_ | _DEV_ONLY_INT_MAIN_) +#define _DEV_GNU_TRICORE_ (_DEV_BIT32_ | _DEV_GNUC_TC_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_ | _DEV_ONLY_INT_MAIN_ | _DEV_ALIGNMENT_4_) +#define _DEV_MPLAB_DSPIC33F_ (_DEV_BIT16_ | _DEV_MPLAB_C30_ ) //| _DEV_COMMA_EXT_) +#define _DEV_GNU_MIPSEL_ (_DEV_BIT32_ | _DEV_GNUC_MIPS2_ | _DEV_BIGEND_ | _DEV_64BIT_SUPPORT_ | _DEV_COMMA_EXT_ | _DEV_ONLY_INT_MAIN_) + +#define _DEV_RENESAS_M32C_ (_DEV_BIT32_ | _DEV_RENESASM32C) + +//--------------------------------------------------------------------------- +// usefull macros +//--------------------------------------------------------------------------- + +#define CHECK_IF_ONLY_INT_MAIN() (DEV_SYSTEM & _DEV_ONLY_INT_MAIN_) +#define CHECK_MEMORY_ALINMENT() (DEV_SYSTEM & _DEV_MASK_ALIGNMENT) + +//--------------------------------------------------------------------------- +// defines for target system (TARGET_SYSTEM) +//--------------------------------------------------------------------------- + +#define _DOS_ (16 + 0x10000) +#define _WIN16_ 16 +#define _WIN32_ 32 +#define _WINCE_ (32 + 0x20000) +#define _NO_OS_ 0 +#define _LINUX_ 1 +#define _PXROS_ 2 +#define _ECOSPRO_ 3 + +//--------------------------------------------------------------------------- +// definitions for function inlining +//--------------------------------------------------------------------------- + +#define INLINE_FUNCTION // empty define +#undef INLINE_ENABLED // disable actual inlining of functions +#undef INLINE_FUNCTION_DEF // disable inlining for all compilers per default + +//--------------------------------------------------------------------------- +// definitions for Keil C51 +//--------------------------------------------------------------------------- + +#ifdef __C51__ + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_KEIL_C51X_ + +#pragma DEBUG OBJECTEXTEND +#pragma WARNINGLEVEL(2) // maximum warning level + +#define NEAR idata // variables mapped to internal data storage location +#define FAR xdata // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM code // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC xdata // hardware access through external memory (i.e. CAN) +#define LARGE large // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM xdata // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT reentrant +#define PUBLIC + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for GNU Compiler for Infineon C16x +// - it have to be befor Keil (it has __C166__ too) +//--------------------------------------------------------------------------- +#elif defined (__GNUC__) && defined (__C166__) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_GNU_C16X_ + +// #define NEAR idata // variables mapped to internal data storage location +#define NEAR near // variables mapped to internal data storage location +// #define FAR xhuge // variables mapped to external data storage location +#define FAR huge // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +// #define HWACC sdata // hardware access through external memory (i.e. CAN) +#define HWACC huge // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +// #define GENERIC xhuge // generic pointer to point to application data +#define GENERIC huge // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf + +#define ASSERT(p) \ + if (p) \ + { \ + ; \ + } \ + else \ + { \ + PRINTF0("Assert failed: " #p " (file %s line %d)\n", __FILE__, (int) __LINE__ ); \ + while (1); \ + } +#else +#define ASSERT(p) +#endif + +//--------------------------------------------------------------------------- +// definitions for Keil C166 +//--------------------------------------------------------------------------- +#elif defined (__C166__) // 24.01.2005 r.d.: Keil ARM7 needs directive 'defined' + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_KEIL_C16X_ + +#pragma CODE +#pragma MOD167 +#pragma NOINIT +#pragma DEBUG +#pragma WARNINGLEVEL(3) // maximum warning level +#pragma WARNING DISABLE = 47 // warning <unreferenced parameter> = OFF +#pragma WARNING DISABLE = 38 // warning <empty translation unit> = OFF +// #pragma WARNING DISABLE = 102 // warning <different const/volatile qualifiers> = OFF +#pragma WARNING DISABLE = 174 // warning <unreferenced 'static' function> = OFF +#pragma WARNING DISABLE = 183 // warning <dead assignement eliminated> = OFF + +#define NEAR idata // variables mapped to internal data storage location +#define FAR xhuge // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +// #define HWACC sdata // hardware access through external memory (i.e. CAN) +#define HWACC huge // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC xhuge // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for MPLAB C30 for dsPIC33F series +//--------------------------------------------------------------------------- +#elif defined (__C30__) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_MPLAB_DSPIC33F_ + +#define NEAR // variables mapped to internal data storage location +#define FAR // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT +#define PUBLIC + +// #ifndef QWORD +// #define QWORD long long +// #endif + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for Keil ARM +//--------------------------------------------------------------------------- +#elif defined (__CA__) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_KEIL_CARM_ + +#define NEAR // variables mapped to internal data storage location +#define FAR // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT +#define PUBLIC + +#ifndef QWORD +#define QWORD long long +#endif + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for RealView ARM compilation tools (provided by recent Keil Microcontroller Development Kits) +//--------------------------------------------------------------------------- +#elif defined (__ARMCC_VERSION) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_RVCT_CARM_ + +#define NEAR // variables mapped to internal data storage location +#define FAR // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT +#define PUBLIC + +#ifndef QWORD +#define QWORD long long +#endif + +#ifndef NDEBUG +#define ASSERT(expr) if (!(expr)) {\ + TRACE0 ("Assertion failed: " #expr );\ + while (1);} +#else +#define ASSERT(expr) +#endif + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for ARM IAR C Compiler +//--------------------------------------------------------------------------- +#elif defined (__ICCARM__) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_IAR_CARM_ + +#define NEAR // variables mapped to internal data storage location +#define FAR // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT +#define PUBLIC + +#ifndef QWORD +#define QWORD long long +#endif + + // Workaround: + // If we use IAR and want to debug but don't want to use C-Spy Debugger + // assert() doesn't work in debug mode because it needs support for FILE descriptors + // (_DLIB_FILE_DESCRIPTOR == 1). +#ifndef NDEBUG +#define ASSERT(expr) if (!(expr)) {\ + TRACE0 ("Assertion failed: " #expr );\ + while (1);} +#else +#define ASSERT(expr) +#endif + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +// #define TRACE PRINTF4 +#endif + +//--------------------------------------------------------------------------- +// definitions for Tasking 8051 +//--------------------------------------------------------------------------- + +#elif defined (_CC51) + +#include <cc51.h> + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_TASKING_C51X_ + +#define NEAR _data // variables mapped to internal data storage location +#define FAR _xdat // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC _xdat // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM _xdat // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT _reentrant +#define PUBLIC + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for Tasking C167CR and C164CI +//--------------------------------------------------------------------------- + +#elif defined (_C166) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_TASKING_C16X_ + +#define NEAR near // variables mapped to internal data storage location +#define FAR far // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC /* to be defined */ // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT +#define PUBLIC + + // Stdio.h has to be alway included here. If printf() is used stdio.h defines NULL + // without checking if it is already included. So an error occurs while compiling. + // (r.d.) +#include <stdio.h> // prototype printf() (for TRACE) +#ifndef NDEBUG +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for FUJITSU FFMC-16LX MB90590 +//--------------------------------------------------------------------------- + +//#elif (defined (F590) || defined (F543) || defined (F598) || defined (F495) || defined (F350)) +#elif defined(__COMPILER_FCC907__) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_FUJITSU_F590_ + +#define NEAR /* to be defined */ // variables mapped to internal data storage location +#define FAR /* to be defined */ // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM /* to be defined */ // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC /* to be defined */ // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + + // softune is not able to support 64 bit variables QWORD !!! + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for Mitsubishi M16C family for TASKING Compiler CM16 +//--------------------------------------------------------------------------- + +#elif defined (_CM16C) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_TASKING_M16C_ + +#define NEAR _near // variables mapped to internal data storage location +#define FAR _far // variables mapped to external data storage location +#define CONST _farrom // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC _near // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC _far // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. + // do you use memory model SMALL, than you have to set _far +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT +#define PUBLIC + + // Stdio.h has to be alway included here. If printf() is used stdio.h defines NULL + // without checking if it is already included. So an error occurs while compiling. + // (r.d.) +#include <stdio.h> // prototype printf() (for TRACE) +#ifndef NDEBUG +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for Mitsubishi M16C family for Mitsubishi Compiler NC30 +//--------------------------------------------------------------------------- +// name NC30, andere Form will der Compiler nicht !! +#elif defined (NC30) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_MITSUBISHI_M16C_ + +#define NEAR near // variables mapped to internal data storage location +#define FAR far // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC near // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC far // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for Renesas M32C family for Renesas Compiler +//--------------------------------------------------------------------------- +#elif defined (NC308) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_RENESAS_M32C_ + +#define NEAR near // variables mapped to internal data storage location +#define FAR far // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) +#define HWACC // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM far // Memory attribute to optimize speed and code of pointer access. + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +// #error ("RENESAS o.k.") + +//--------------------------------------------------------------------------- +// definitions for ARM7 family with GNU compiler +//--------------------------------------------------------------------------- + +#elif defined(__GNUC__) && defined(__arm__) && !defined(__LINUX_ARM_ARCH__) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_GNU_ARM7_ + +#define NEAR // variables mapped to internal data storage location +#define FAR // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. +#define HWACC // hardware access through external memory (i.e. CAN) + +#define REENTRANT +#define PUBLIC + +#ifndef QWORD +#define QWORD long long // i.A. durch Herr Kuschel +#endif + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for Motorola PowerPC family 5x5 (555/565) +// definitions Linux-PC +//--------------------------------------------------------------------------- + +#elif defined (__GNUC__) + +#if defined (LINUX) || defined (linux) || defined (__linux__) +#define LINUX_SYSTEM // define 'LINUX_SYSTEM' uniform for all Linux based systems + // r.d.: We will need an other solution here! There are two sections here which do check the preproc-definitions: + // LINUX and __linux__ . The first one was Linux for PC, the second one is this section for embedded Linux (MCF5xxx). + // But Linux for PC does not need the definitions for embedded Linux. +#endif + + // GNU C compiler supports function inlining +#define INLINE_FUNCTION_DEF extern inline + + // to actually enable inlining just include the following three lines + // #undef INLINE_FUNCTION + // #define INLINE_FUNCTION INLINE_FUNCTION_DEF + // #define INLINE_ENABLED TRUE + +#ifdef PXROS +#define TARGET_SYSTEM _PXROS_ +#ifdef __i386__ +#undef LINUX // this define seems to be set from compiler +#define DEV_SYSTEM _DEV_HIGHTEC_X86_ +#elif defined (__tricore__) +#define DEV_SYSTEM _DEV_GNU_TRICORE_ +#else // MPC5x5 +#define DEV_SYSTEM _DEV_GNU_MPC5X5_ +#endif + +#elif defined (LINUX) || defined (__linux__) +#define TARGET_SYSTEM _LINUX_ // Linux definition +#define DEV_SYSTEM _DEV_LINUX_ + +#elif defined (GNU_CF5282) +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_GNU_CF5282_ + +#elif defined (ECOSPRO_I386_PEAK_PCI) +#define TARGET_SYSTEM _ECOSPRO_ +#define DEV_SYSTEM _DEV_GNU_I386_ + +#elif defined (GNU_CF548X) +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_GNU_CF548X_ +#else +#error 'ERROR: DEV_SYSTEM not found!' +#endif + +#ifndef QWORD +#define QWORD long long int +#endif + +#if (TARGET_SYSTEM == _PXROS_) + +#ifndef __KERNEL__ +#include <string.h> +#endif + +#define NEAR // variables mapped to internal data storage location +#define FAR // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM /* to be defined */ // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define HWACC // hardware access through external memory (i.e. CAN) + +#define REENTRANT +#define PUBLIC + +#ifndef QWORD +#define QWORD long long int +#endif + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +#endif + + // ------------------ GNUC for I386 --------------------------------------------- + +#if (TARGET_SYSTEM == _LINUX_) || (TARGET_SYSTEM == _ECOSPRO_) + +#ifndef __KERNEL__ +#include <string.h> +#endif + +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#ifndef NEAR +#define NEAR // variables mapped to internal data storage location +#endif + +#ifndef FAR +#define FAR // variables mapped to external data storage location +#endif + +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif + +#define LARGE + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +#ifndef __KERNEL__ +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#else +#define TRACE printk +#endif +#endif +#endif + + // ------------------ GNU without OS --------------------------------------------- + +#if (TARGET_SYSTEM == _NO_OS_) + +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#ifndef NEAR +#define NEAR // variables mapped to internal data storage location +#endif + +#ifndef FAR +#define FAR // variables mapped to external data storage location +#endif + +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif + +#define LARGE + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +// #include "xuartdrv.h" +// #include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +// #define TRACE mprintf +// #ifndef TRACE +// #define TRACE trace +// void trace (char *fmt, ...); +// #endif +#endif + +#endif + +//--------------------------------------------------------------------------- +// definitions for MPC565 +//--------------------------------------------------------------------------- +#elif __MWERKS__ + +#ifdef __MC68K__ + +#define TARGET_SYSTEM = _MCF548X_ +#define DEV_SYSTEM _DEV_MCW_MCF5XXX_ + +#else +#define TARGET_SYSTEM = _MPC565_ +#define DEV_SYSTEM _DEV_MCW_MPC5X5_ +#endif + +#define NEAR // variables mapped to internal data storage location +#define FAR // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define LARGE // functions set parameters to external data storage location + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#define HWACC // hardware access through external memory (i.e. CAN) + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif + +//--------------------------------------------------------------------------- +// definitions for BECK 1x3 +//--------------------------------------------------------------------------- +#elif defined (__BORLANDC__) && defined (__PARADIGM__) + +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_PAR_BECK1X3_ + +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. +#define NEAR __near // variables mapped to internal data storage location +#define FAR __far // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define LARGE + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +#ifndef TRACE +#include <stdio.h> +#define TRACE printf +#endif +#endif + +//--------------------------------------------------------------------------- +// definitions for PC +//--------------------------------------------------------------------------- + +#elif defined (__BORLANDC__) + + // ------------------ definition target system -------------------------- + +#ifdef _WIN32 +#define TARGET_SYSTEM _WIN32_ // WIN32 definition +#define DEV_SYSTEM _DEV_WIN32_ +#else +#define TARGET_SYSTEM _DOS_ +#define DEV_SYSTEM _DEV_BORLAND_DOS_ +#endif + + // ------------------ WIN32 --------------------------------------------- + +#if (TARGET_SYSTEM == _WIN32_) + +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#ifndef NEAR +#define NEAR // variables mapped to internal data storage location +#endif + +#ifndef FAR +#define FAR // variables mapped to external data storage location +#endif + +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif + +#define LARGE + +#define REENTRANT +#define PUBLIC __stdcall + +#ifndef NDEBUG +#ifndef TRACE +#include <stdio.h> +#define TRACE printf +#endif +#endif + +#elif (TARGET_SYSTEM == _DOS_) + +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. +#define NEAR near // variables mapped to internal data storage location +#define FAR far // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define LARGE + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +#ifndef TRACE +#include <stdio.h> +#define TRACE printf +#endif +#endif + +#endif + +#elif (_MSC_VER == 800) // PC MS Visual C/C++ for DOS applications + +#define TARGET_SYSTEM _DOS_ +#define DEV_SYSTEM _DEV_MSVC_DOS_ + +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC near // hardware access through external memory (i.e. CAN) + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. +#define NEAR near // variables mapped to internal data storage location +#define FAR far // variables mapped to external data storage location +#define CONST const // variables mapped to ROM (i.e. flash) +#define LARGE + +#define REENTRANT +#define PUBLIC + +#ifndef NDEBUG +#ifndef TRACE +#include <stdio.h> +#define TRACE printf +#endif +#endif + +//--------------------------------------------------------------------------- +// definitions for RTX under WIN32 +//--------------------------------------------------------------------------- +#elif (defined (UNDER_RTSS) && defined (WIN32)) + + // ------------------ definition target system -------------------------- +#define TARGET_SYSTEM _WIN32_RTX_ +#define DEV_SYSTEM _DEV_WIN32_RTX_ + +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#ifndef NEAR +#define NEAR // variables mapped to internal data storage location +#endif + +#ifndef FAR +#define FAR // variables mapped to external data storage location +#endif + +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif + +#define LARGE + +#define REENTRANT +#define PUBLIC __stdcall + +#ifndef NDEBUG +#ifndef TRACE +#define TRACE RtPrintf +#endif +#endif + +//--------------------------------------------------------------------------- +// definitions for WinCE +//--------------------------------------------------------------------------- +#elif defined (_WIN32_WCE) + + // ------------------ definition target system -------------------------- +#define TARGET_SYSTEM _WINCE_ +#define DEV_SYSTEM _DEV_WIN_CE_ + +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#ifndef NEAR +#define NEAR // variables mapped to internal data storage location +#endif + +#ifndef FAR +#define FAR // variables mapped to external data storage location +#endif + +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif + +#define LARGE + +#ifndef QWORD + //#define QWORD long long int // MSVC .NET can use "long long int" too (like GNU) +#define QWORD __int64 +#endif + +#define REENTRANT +#define PUBLIC __cdecl + +#ifdef ASSERTMSG +#undef ASSERTMSG +#endif + +#ifndef NDEBUG +#ifndef TRACE +#define TRACE printf +// void trace (char *fmt, ...); +#endif +#endif + +#else // ===> PC MS Visual C/C++ + + // ------------------ definition target system -------------------------- + +#ifdef _WIN32 +#define TARGET_SYSTEM _WIN32_ // WIN32 definition +#define DEV_SYSTEM _DEV_WIN32_ +#else +#define TARGET_SYSTEM _WIN16_ // WIN16 definition +#define DEV_SYSTEM _DEV_WIN16_ +#endif + + // ------------------ WIN16 --------------------------------------------- + +#if (TARGET_SYSTEM == _WIN16_) + +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) + + // These types can be adjusted by users to match application requirements. The goal is to + // minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external + // or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. + +#ifndef NEAR +#define NEAR // variables mapped to internal data storage location +#endif + +#ifndef FAR +#define FAR far // variables mapped to external data storage location +#endif + +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif + +#define LARGE + +#define REENTRANT +#define PUBLIC _far _pascal _export + +#ifndef NDEBUG +#ifndef TRACE +#define TRACE trace +#ifdef __cplusplus +extern "C" { +#endif + void trace(const char *fmt, ...); +#ifdef __cplusplus +} +#endif +#endif +#endif +#endif + // ------------------ WIN32 --------------------------------------------- +#if (TARGET_SYSTEM == _WIN32_) +#define ROM // code or variables mapped to ROM (i.e. flash) + // usage: CONST BYTE ROM foo = 0x00; +#define HWACC // hardware access through external memory (i.e. CAN) + // These types can be adjusted by users to match application requirements. The goal is to// minimize code memory and maximize speed. +#define GENERIC // generic pointer to point to application data + // Variables with this attribute can be located in external// or internal data memory. +#define MEM // Memory attribute to optimize speed and code of pointer access. +#ifndef NEAR +#define NEAR // variables mapped to internal data storage location +#endif +#ifndef FAR +#define FAR // variables mapped to external data storage location +#endif +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif +#define LARGE +#define REENTRANT +#define PUBLIC __stdcall +#ifndef QWORD + //#define QWORD long long int // MSVC .NET can use "long long int" too (like GNU) +#define QWORD __int64 +#endif +#ifndef NDEBUG +#ifndef TRACE +#define TRACE trace +#ifdef __cplusplus +extern "C" { +#endif + void trace(const char *fmt, ...); +#ifdef __cplusplus +} +#endif +#endif +#endif + // MS Visual C++ compiler supports function inlining +#define INLINE_FUNCTION_DEF __forceinline + // to actually enable inlining just include the following two lines// #define INLINE_FUNCTION INLINE_FUNCTION_DEF// #define INLINE_ENABLED TRUE +#endif +#endif // ===> PC +//---------------------------------------------------------------------------// definitions of basic types//--------------------------------------------------------------------------- +#ifndef _WINDEF_ // defined in WINDEF.H, included by <windows.h> + // --- arithmetic types --- +#ifndef SHORT +#define SHORT short int +#endif +#ifndef USHORT +#define USHORT unsigned short int +#endif +#ifndef INT +#define INT int +#endif +#ifndef UINT +#define UINT unsigned int +#endif +#ifndef LONG +#define LONG long int +#endif +#ifndef ULONG +#define ULONG unsigned long int +#endif + // --- logic types --- +#ifndef BYTE +#define BYTE unsigned char +#endif +#ifndef WORD +#define WORD unsigned short int +#endif +#ifndef DWORD +#define DWORD unsigned long int +#endif +#ifndef BOOL +#define BOOL unsigned char +#endif + // --- alias types --- +#ifndef TRUE +#define TRUE 0xFF +#endif +#ifndef FALSE +#define FALSE 0x00 +#endif +#ifndef NULL +#define NULL ((void *) 0) +#endif +#endif +#ifndef _TIME_OF_DAY_DEFINED_ +typedef struct { + unsigned long int m_dwMs; + unsigned short int m_wDays; + +} tTimeOfDay; + +#define _TIME_OF_DAY_DEFINED_ + +#endif + +//--------------------------------------------------------------------------- +// Definition von TRACE +//--------------------------------------------------------------------------- + +#ifndef NDEBUG + +#ifndef TRACE0 +#define TRACE0(p0) TRACE(p0) +#endif + +#ifndef TRACE1 +#define TRACE1(p0, p1) TRACE(p0, p1) +#endif + +#ifndef TRACE2 +#define TRACE2(p0, p1, p2) TRACE(p0, p1, p2) +#endif + +#ifndef TRACE3 +#define TRACE3(p0, p1, p2, p3) TRACE(p0, p1, p2, p3) +#endif + +#ifndef TRACE4 +#define TRACE4(p0, p1, p2, p3, p4) TRACE(p0, p1, p2, p3, p4) +#endif + +#ifndef TRACE5 +#define TRACE5(p0, p1, p2, p3, p4, p5) TRACE(p0, p1, p2, p3, p4, p5) +#endif + +#ifndef TRACE6 +#define TRACE6(p0, p1, p2, p3, p4, p5, p6) TRACE(p0, p1, p2, p3, p4, p5, p6) +#endif + +#else + +#ifndef TRACE0 +#define TRACE0(p0) +#endif + +#ifndef TRACE1 +#define TRACE1(p0, p1) +#endif + +#ifndef TRACE2 +#define TRACE2(p0, p1, p2) +#endif + +#ifndef TRACE3 +#define TRACE3(p0, p1, p2, p3) +#endif + +#ifndef TRACE4 +#define TRACE4(p0, p1, p2, p3, p4) +#endif + +#ifndef TRACE5 +#define TRACE5(p0, p1, p2, p3, p4, p5) +#endif + +#ifndef TRACE6 +#define TRACE6(p0, p1, p2, p3, p4, p5, p6) +#endif + +#endif + +//--------------------------------------------------------------------------- +// definition of ASSERT +//--------------------------------------------------------------------------- + +#ifndef ASSERT +#if !defined (__linux__) && !defined (__KERNEL__) +#include <assert.h> +#ifndef ASSERT +#define ASSERT(p) assert(p) +#endif +#else +#define ASSERT(p) +#endif +#endif + +//--------------------------------------------------------------------------- +// SYS TEC extensions +//--------------------------------------------------------------------------- + +// This macro doesn't print out C-file and line number of the failed assertion +// but a string, which exactly names the mistake. +#ifndef NDEBUG + +#define ASSERTMSG(expr,string) if (!(expr)) {\ + PRINTF0 ("Assertion failed: " string );\ + while (1);} +#else +#define ASSERTMSG(expr,string) +#endif + +//--------------------------------------------------------------------------- + +#endif // #ifndef _GLOBAL_H_ + +// Please keep an empty line at the end of this file. |