diff options
| author | Greg Kroah-Hartman <gregkh@suse.de> | 2008-12-19 17:09:38 -0800 |
|---|---|---|
| committer | Greg Kroah-Hartman <gregkh@suse.de> | 2009-01-06 13:52:37 -0800 |
| commit | e0ca0595885e2e324eefe4f32cde6d65e61e6e28 (patch) | |
| tree | c53676354254656be8d1f197f5d8f88526355b7b /drivers/staging/epl/global.h | |
| parent | bd5cd82dc6148aa8f655620e6f3bf62e5e320078 (diff) | |
Staging: epl: run Lindent on *.h files
It's a start, still a mess...
Cc: Daniel Krueger <daniel.krueger@systec-electronic.com>
Cc: Ronald Sieber <Ronald.Sieber@systec-electronic.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat (limited to 'drivers/staging/epl/global.h')
| -rw-r--r-- | drivers/staging/epl/global.h | 1771 |
1 files changed, 847 insertions, 924 deletions
diff --git a/drivers/staging/epl/global.h b/drivers/staging/epl/global.h index 797e1f27835..fe167165a83 100644 --- a/drivers/staging/epl/global.h +++ b/drivers/staging/epl/global.h @@ -22,50 +22,49 @@ #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++ +#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 @@ -73,7 +72,6 @@ #define _DEV_MASK_ADDSUPPORT 0x0000F000L #define _DEV_MASK_ALIGNMENT 0x00F00000L - //--------------------------------------------------------------------------- // defines for development system (DEV_SYSTEM) including previous elements //--------------------------------------------------------------------------- @@ -81,34 +79,34 @@ #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_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 !!! +#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_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_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_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_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) @@ -120,7 +118,6 @@ #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) //--------------------------------------------------------------------------- @@ -134,14 +131,13 @@ #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 +#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 @@ -149,35 +145,34 @@ #ifdef __C51__ - #define TARGET_SYSTEM _NO_OS_ - #define DEV_SYSTEM _DEV_KEIL_C51X_ +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_KEIL_C51X_ - #pragma DEBUG OBJECTEXTEND - #pragma WARNINGLEVEL(2) // maximum warning level +#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 +#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 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 +#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 @@ -185,36 +180,36 @@ //--------------------------------------------------------------------------- #elif defined (__GNUC__) && defined (__C166__) - #define TARGET_SYSTEM _NO_OS_ - #define DEV_SYSTEM _DEV_GNU_C16X_ +#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 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 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 +#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 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 +#define REENTRANT +#define PUBLIC - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf - #define ASSERT(p) \ +#define ASSERT(p) \ if (p) \ { \ ; \ @@ -224,213 +219,213 @@ PRINTF0("Assert failed: " #p " (file %s line %d)\n", __FILE__, (int) __LINE__ ); \ while (1); \ } - #else - #define ASSERT(p) - #endif +#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 +#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; +#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 +#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 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 +#define REENTRANT +#define PUBLIC - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf - #endif +#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 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 +#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 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 +#define REENTRANT +#define PUBLIC // #ifndef QWORD // #define QWORD long long // #endif - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf - #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 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 +#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 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 +#define REENTRANT +#define PUBLIC - #ifndef QWORD - #define QWORD long long - #endif +#ifndef QWORD +#define QWORD long long +#endif - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf - #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 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 +#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 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 +#define REENTRANT +#define PUBLIC - #ifndef QWORD - #define QWORD long long - #endif +#ifndef QWORD +#define QWORD long long +#endif - #ifndef NDEBUG - #define ASSERT(expr) if (!(expr)) {\ +#ifndef NDEBUG +#define ASSERT(expr) if (!(expr)) {\ TRACE0 ("Assertion failed: " #expr );\ while (1);} - #else - #define ASSERT(expr) - #endif +#else +#define ASSERT(expr) +#endif - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf - #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 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 +#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 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 +#define REENTRANT +#define PUBLIC - #ifndef QWORD - #define QWORD long long - #endif +#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)) {\ +#ifndef NDEBUG +#define ASSERT(expr) if (!(expr)) {\ TRACE0 ("Assertion failed: " #expr );\ while (1);} - #else - #define ASSERT(expr) - #endif +#else +#define ASSERT(expr) +#endif - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf // #define TRACE PRINTF4 - #endif +#endif //--------------------------------------------------------------------------- // definitions for Tasking 8051 @@ -438,34 +433,33 @@ #elif defined (_CC51) - #include <cc51.h> +#include <cc51.h> - #define TARGET_SYSTEM _NO_OS_ - #define DEV_SYSTEM _DEV_TASKING_C51X_ +#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 +#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 +#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. - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf - #endif +#define REENTRANT _reentrant +#define PUBLIC +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif //--------------------------------------------------------------------------- // definitions for Tasking C167CR and C164CI @@ -473,35 +467,34 @@ #elif defined (_C166) - #define TARGET_SYSTEM _NO_OS_ - #define DEV_SYSTEM _DEV_TASKING_C16X_ +#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 +#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 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 +#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 - +#include <stdio.h> // prototype printf() (for TRACE) +#ifndef NDEBUG +#define TRACE printf +#endif //--------------------------------------------------------------------------- // definitions for FUJITSU FFMC-16LX MB90590 @@ -510,34 +503,33 @@ //#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 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 +#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. +#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 +#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 @@ -545,36 +537,35 @@ #elif defined (_CM16C) - #define TARGET_SYSTEM _NO_OS_ - #define DEV_SYSTEM _DEV_TASKING_M16C_ +#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 +#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 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 +#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 - +#include <stdio.h> // prototype printf() (for TRACE) +#ifndef NDEBUG +#define TRACE printf +#endif //--------------------------------------------------------------------------- // definitions for Mitsubishi M16C family for Mitsubishi Compiler NC30 @@ -582,61 +573,61 @@ // name NC30, andere Form will der Compiler nicht !! #elif defined (NC30) - #define TARGET_SYSTEM _NO_OS_ - #define DEV_SYSTEM _DEV_MITSUBISHI_M16C_ +#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 +#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 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 +#define REENTRANT +#define PUBLIC - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf - #endif +#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 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 +#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 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 +#define REENTRANT +#define PUBLIC - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf - #endif +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif // #error ("RENESAS o.k.") @@ -646,37 +637,36 @@ #elif defined(__GNUC__) && defined(__arm__) && !defined(__LINUX_ARM_ARCH__) - #define TARGET_SYSTEM _NO_OS_ - #define DEV_SYSTEM _DEV_GNU_ARM7_ +#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 +#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 +#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) - #ifndef QWORD - #define QWORD long long // i.A. durch Herr Kuschel - #endif +#define REENTRANT +#define PUBLIC - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf - #endif +#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) @@ -685,261 +675,253 @@ #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 +#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 +#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_ +#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 (ECOSPRO_I386_PEAK_PCI) - #define TARGET_SYSTEM _ECOSPRO_ - #define DEV_SYSTEM _DEV_GNU_I386_ +#elif defined (LINUX) || defined (__linux__) +#define TARGET_SYSTEM _LINUX_ // Linux definition +#define DEV_SYSTEM _DEV_LINUX_ - #elif defined (GNU_CF548X) - #define TARGET_SYSTEM _NO_OS_ - #define DEV_SYSTEM _DEV_GNU_CF548X_ - #else - #error 'ERROR: DEV_SYSTEM not found!' - #endif +#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_ - #ifndef QWORD - #define QWORD long long int - #endif +#elif defined (GNU_CF548X) +#define TARGET_SYSTEM _NO_OS_ +#define DEV_SYSTEM _DEV_GNU_CF548X_ +#else +#error 'ERROR: DEV_SYSTEM not found!' +#endif - #if (TARGET_SYSTEM == _PXROS_) +#ifndef QWORD +#define QWORD long long int +#endif - #ifndef __KERNEL__ - #include <string.h> - #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 +#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. + // 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 HWACC // hardware access through external memory (i.e. CAN) - #define REENTRANT - #define PUBLIC +#define REENTRANT +#define PUBLIC - #ifndef QWORD - #define QWORD long long int - #endif +#ifndef QWORD +#define QWORD long long int +#endif - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf - #endif +#ifndef NDEBUG +#include <stdio.h> // prototype printf() (for TRACE) +#define TRACE printf +#endif - #endif +#endif // ------------------ GNUC for I386 --------------------------------------------- - #if (TARGET_SYSTEM == _LINUX_) || (TARGET_SYSTEM == _ECOSPRO_) +#if (TARGET_SYSTEM == _LINUX_) || (TARGET_SYSTEM == _ECOSPRO_) - #ifndef __KERNEL__ - #include <string.h> - #endif +#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) +#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. + // 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 NEAR +#define NEAR // variables mapped to internal data storage location +#endif - #ifndef FAR - #define FAR // variables mapped to external 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 +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif - #define LARGE +#define LARGE - #define REENTRANT - #define PUBLIC +#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 +#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_) +#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) +#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. + // 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 NEAR +#define NEAR // variables mapped to internal data storage location +#endif - #ifndef FAR - #define FAR // variables mapped to external 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 +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif - #define LARGE +#define LARGE - #define REENTRANT - #define PUBLIC +#define REENTRANT +#define PUBLIC - #ifndef NDEBUG +#ifndef NDEBUG // #include "xuartdrv.h" // #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf +#define TRACE printf // #define TRACE mprintf // #ifndef TRACE // #define TRACE trace // void trace (char *fmt, ...); // #endif - #endif +#endif - #endif +#endif //--------------------------------------------------------------------------- // definitions for MPC565 //--------------------------------------------------------------------------- #elif __MWERKS__ - #ifdef __MC68K__ - #define TARGET_SYSTEM = _MCF548X_ - #define DEV_SYSTEM _DEV_MCW_MCF5XXX_ +#define TARGET_SYSTEM = _MCF548X_ +#define DEV_SYSTEM _DEV_MCW_MCF5XXX_ #else - #define TARGET_SYSTEM = _MPC565_ - #define DEV_SYSTEM _DEV_MCW_MPC5X5_ +#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 +#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 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 HWACC // hardware access through external memory (i.e. CAN) - #define REENTRANT - #define PUBLIC +#define REENTRANT +#define PUBLIC - #ifndef NDEBUG - #include <stdio.h> // prototype printf() (for TRACE) - #define TRACE printf - #endif +#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 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) +#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 - +#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 @@ -949,113 +931,111 @@ // ------------------ 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 - +#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_) +#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) +#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. + // 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 NEAR +#define NEAR // variables mapped to internal data storage location +#endif - #ifndef FAR - #define FAR // variables mapped to external 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 +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif - #define LARGE +#define LARGE - #define REENTRANT - #define PUBLIC __stdcall +#define REENTRANT +#define PUBLIC __stdcall - #ifndef NDEBUG - #ifndef TRACE - #include <stdio.h> - #define TRACE printf - #endif - #endif +#ifndef NDEBUG +#ifndef TRACE +#include <stdio.h> +#define TRACE printf +#endif +#endif - #elif (TARGET_SYSTEM == _DOS_) +#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) +#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 + // 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 +#define REENTRANT +#define PUBLIC - #ifndef NDEBUG - #ifndef TRACE - #include <stdio.h> - #define TRACE printf - #endif - #endif +#ifndef NDEBUG +#ifndef TRACE +#include <stdio.h> +#define TRACE printf +#endif +#endif - #endif +#endif -#elif (_MSC_VER == 800) // PC MS Visual C/C++ for DOS applications +#elif (_MSC_VER == 800) // PC MS Visual C/C++ for DOS applications - #define TARGET_SYSTEM _DOS_ - #define DEV_SYSTEM _DEV_MSVC_DOS_ +#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) +#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 +#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 @@ -1063,42 +1043,42 @@ #elif (defined (UNDER_RTSS) && defined (WIN32)) // ------------------ definition target system -------------------------- - #define TARGET_SYSTEM _WIN32_RTX_ - #define DEV_SYSTEM _DEV_WIN32_RTX_ +#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) +#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 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 NEAR +#define NEAR // variables mapped to internal data storage location +#endif - #ifndef FAR - #define FAR // variables mapped to external 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 +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif - #define LARGE +#define LARGE - #define REENTRANT - #define PUBLIC __stdcall +#define REENTRANT +#define PUBLIC __stdcall - #ifndef NDEBUG - #ifndef TRACE - #define TRACE RtPrintf - #endif - #endif +#ifndef NDEBUG +#ifndef TRACE +#define TRACE RtPrintf +#endif +#endif //--------------------------------------------------------------------------- // definitions for WinCE @@ -1106,341 +1086,288 @@ #elif defined (_WIN32_WCE) // ------------------ definition target system -------------------------- - #define TARGET_SYSTEM _WINCE_ - #define DEV_SYSTEM _DEV_WIN_CE_ +#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) +#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 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 NEAR +#define NEAR // variables mapped to internal data storage location +#endif - #ifndef FAR - #define FAR // variables mapped to external 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 +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif - #define LARGE +#define LARGE - #ifndef QWORD +#ifndef QWORD //#define QWORD long long int // MSVC .NET can use "long long int" too (like GNU) - #define QWORD __int64 - #endif +#define QWORD __int64 +#endif - #define REENTRANT - #define PUBLIC __cdecl +#define REENTRANT +#define PUBLIC __cdecl - #ifdef ASSERTMSG - #undef ASSERTMSG - #endif +#ifdef ASSERTMSG +#undef ASSERTMSG +#endif - #ifndef NDEBUG - #ifndef TRACE - #define TRACE printf +#ifndef NDEBUG +#ifndef TRACE +#define TRACE printf // void trace (char *fmt, ...); - #endif - #endif +#endif +#endif -#else // ===> PC MS Visual C/C++ +#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 - +#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 +#if (TARGET_SYSTEM == _WIN16_) - #ifndef FAR - #define FAR far // variables mapped to external data storage location - #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) - #ifndef CONST - #define CONST const // variables mapped to ROM (i.e. flash) - #endif + // 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 LARGE +#ifndef NEAR +#define NEAR // variables mapped to internal data storage location +#endif - #define REENTRANT - #define PUBLIC _far _pascal _export +#ifndef FAR +#define FAR far // variables mapped to external data storage location +#endif - #ifndef NDEBUG - #ifndef TRACE - #define TRACE trace - #ifdef __cplusplus - extern "C" - { - #endif - void trace (const char *fmt, ...); - #ifdef __cplusplus - } - #endif - #endif - #endif +#ifndef CONST +#define CONST const // variables mapped to ROM (i.e. flash) +#endif - #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> - +#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 - - +#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 - - +#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 - +#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; - typedef struct - { - unsigned long int m_dwMs; - unsigned short int m_wDays; +} tTimeOfDay; - } tTimeOfDay; - - #define _TIME_OF_DAY_DEFINED_ +#define _TIME_OF_DAY_DEFINED_ #endif - //--------------------------------------------------------------------------- // Definition von TRACE //--------------------------------------------------------------------------- #ifndef NDEBUG - #ifndef TRACE0 - #define TRACE0(p0) TRACE(p0) - #endif +#ifndef TRACE0 +#define TRACE0(p0) TRACE(p0) +#endif - #ifndef TRACE1 - #define TRACE1(p0, p1) TRACE(p0, p1) - #endif +#ifndef TRACE1 +#define TRACE1(p0, p1) TRACE(p0, p1) +#endif - #ifndef TRACE2 - #define TRACE2(p0, p1, p2) TRACE(p0, p1, p2) - #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 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 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 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 +#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 TRACE0 +#define TRACE0(p0) +#endif - #ifndef TRACE3 - #define TRACE3(p0, p1, p2, p3) - #endif +#ifndef TRACE1 +#define TRACE1(p0, p1) +#endif - #ifndef TRACE4 - #define TRACE4(p0, p1, p2, p3, p4) - #endif +#ifndef TRACE2 +#define TRACE2(p0, p1, p2) +#endif - #ifndef TRACE5 - #define TRACE5(p0, p1, p2, p3, p4, p5) - #endif +#ifndef TRACE3 +#define TRACE3(p0, p1, p2, p3) +#endif - #ifndef TRACE6 - #define TRACE6(p0, p1, p2, p3, p4, p5, p6) - #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 +#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 @@ -1450,19 +1377,15 @@ // but a string, which exactly names the mistake. #ifndef NDEBUG - #define ASSERTMSG(expr,string) if (!(expr)) {\ +#define ASSERTMSG(expr,string) if (!(expr)) {\ PRINTF0 ("Assertion failed: " string );\ while (1);} #else - #define ASSERTMSG(expr,string) +#define ASSERTMSG(expr,string) #endif - - - //--------------------------------------------------------------------------- -#endif // #ifndef _GLOBAL_H_ +#endif // #ifndef _GLOBAL_H_ // Please keep an empty line at the end of this file. - |