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