]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
Staging: epl: remove complier macros from global.h
authorGreg Kroah-Hartman <gregkh@suse.de>
Mon, 23 Mar 2009 16:31:01 +0000 (09:31 -0700)
committerGreg Kroah-Hartman <gregkh@suse.de>
Fri, 3 Apr 2009 21:54:18 +0000 (14:54 -0700)
As we are only building within the Linux kernel, remove all of the
different system types from global.h, they are not needed at all.

First step of many to clean up the code to match the kernel coding
style rules.

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>
drivers/staging/epl/global.h

index fe167165a8368ef6128690ea83e2fb519bea0b1b..11b75e4ef6be8d3696215fff88dc2e5f4c56f270 100644 (file)
 //---------------------------------------------------------------------------
 //  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
+#define _WIN32_             32
+#define _NO_OS_              0
+#define _LINUX_              1
 
 //---------------------------------------------------------------------------
-//  definitions for BECK 1x3
+//  definitions for function inlining
 //---------------------------------------------------------------------------
-#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 INLINE_FUNCTION                // empty define
+#undef  INLINE_ENABLED         // disable actual inlining of functions
+#undef  INLINE_FUNCTION_DEF    // disable inlining for all compilers per default
 
-#define REENTRANT
-#define PUBLIC
 
-#ifndef NDEBUG
-#ifndef TRACE
-#include <stdio.h>
-#define TRACE printf
-#endif
-#endif
+#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.
 
-//---------------------------------------------------------------------------
-//  definitions for PC
-//---------------------------------------------------------------------------
+    // GNU C compiler supports function inlining
+#define INLINE_FUNCTION_DEF extern inline
 
-#elif defined (__BORLANDC__)
+    // to actually enable inlining just include the following three lines
+    // #undef INLINE_FUNCTION
+    // #define INLINE_FUNCTION     INLINE_FUNCTION_DEF
+    // #define INLINE_ENABLED      TRUE
 
-    // ------------------ definition target system --------------------------
+#define TARGET_SYSTEM       _LINUX_    // Linux definition
+#define DEV_SYSTEM          _DEV_LINUX_
 
-#ifdef _WIN32
-#define TARGET_SYSTEM   _WIN32_        // WIN32 definition
-#define DEV_SYSTEM      _DEV_WIN32_
-#else
-#define TARGET_SYSTEM   _DOS_
-#define DEV_SYSTEM      _DEV_BORLAND_DOS_
+#ifndef QWORD
+#define QWORD long long int
 #endif
 
-    // ------------------ WIN32 ---------------------------------------------
-
-#if (TARGET_SYSTEM == _WIN32_)
+    // ------------------ GNUC for I386 ---------------------------------------------
 
 #define ROM                    // code or variables mapped to ROM (i.e. flash)
                                        // usage: CONST BYTE ROM foo = 0x00;
 #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
+#define TRACE  printk
 
-#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
@@ -1276,7 +225,6 @@ extern "C" {
 #ifndef NULL
 #define NULL ((void *) 0)
 #endif
-#endif
 #ifndef _TIME_OF_DAY_DEFINED_
 typedef struct {
        unsigned long int m_dwMs;