RTConfig.h

/*
 * Licensed Materials - Property of HCL and/or IBM
 * Copyright HCL Technologies Ltd. 2016, 2021. All Rights Reserved.
 * Copyright IBM Corporation 1999, 2016. All Rights Reserved.
 *
 * U.S. Government Users Restricted Rights -  Use, duplication or 
 * disclosure restricted by GSA ADP Schedule.
 */
 
#ifndef __RTConfig_h__
#define __RTConfig_h__ included
 
#define __RTSExternal__
 
// These are retained only for use by applications that may need differing
// implementations certain operating environments. RTTarget.h will equate
// the macro TARGET with one of these. These are provided for backwards
// compatibility only. The preferred approach is to use the preprocessor
// symbol TARGET_VRTX, for example, which will only be defined in VRTX
// configurations.
 
#define platAIX3     1
#define platAIX4     2
#define platBSS      3
#define platHPRT     4
#define platHPUX     5
#define platIRIX5    6
#define platLynx2    7
#define platpSOS     8
#define platQNX      9
#define platSun4    10
#define platSun5    11
#define platVRTX    12
#define platVxWorks 13
 
// Possible values for OTRTSDEBUG
 
#define DEBUG_NONE    0
#define DEBUG_TERSE   1
#define DEBUG_VERBOSE 2
 
// Possible values for RTFRAME_CHECKING:
// The frame service is intended to provide operations on components of the
// actor which has the frame SAP. The checking can be relaxed or removed.
 
#define RTFRAME_CHECK_NONE   0 // no checking (pre-5.2 compatible)
#define RTFRAME_CHECK_LOOSE  1 // references must be in same thread
#define RTFRAME_CHECK_STRICT 2 // references must be in same actor
 
// Possible values for RTTYPECHECK_PROTOCOL, RTTYPECHECK_SEND
// and RTTYPECHECK_RECEIVE.
 
#define RTTYPECHECK_DONT 0 // no checking
#define RTTYPECHECK_WARN 1 // set error code, but proceed
#define RTTYPECHECK_FAIL 2 // set error code, fail operation
 
// Peculiarities of the compiler we are using are captured in RTLibSet.h.
 
#ifndef __RTLibSet_h__
#include <RTLibSet.h>
#endif
 
// Peculiarities of the target operating environment are captured in RTTarget.h.
 
#ifndef __RTTarget_h__
#include <RTTarget.h>
#endif
 
// Overall defaults are specified here. They can be overridden in the two files included above.
 
// Occasionally we must cast the const away.
#ifndef RTConstCast
#define RTConstCast( type, value ) ( const_cast<type *>( value ) )
#endif
 
// Is there a defer queue in every actor?
// By default, there is one per controller.
 
#ifndef DEFER_IN_ACTOR
#define DEFER_IN_ACTOR 0
#endif
 
// Is the internet protocol (IP) supported?
 
#ifndef HAVE_INET
#define HAVE_INET 1
#endif
 
// Does the compiler support postfix increment and decrement operators?
 
#ifndef INTEGER_POSTFIX
#define INTEGER_POSTFIX 1
#endif
 
// Should RTActor::logMsg be declared and called for every message handled?
 
#ifndef LOG_MESSAGE
#define LOG_MESSAGE 1
#endif
 
// Should the decoding classes and functions be present?
 
#ifndef OBJECT_DECODE
#define OBJECT_DECODE 1
#endif
 
// Should the encoding classes and functions be present?
 
#ifndef OBJECT_ENCODE
#define OBJECT_ENCODE 1
#endif
 
// How much of the debugger should be present?
 
#ifndef OTRTSDEBUG
#define OTRTSDEBUG DEBUG_VERBOSE
#endif
 
// Should the run-time tracer be present?
 
#ifndef RTS_TRACE
#define RTS_TRACE 1
#endif
 
// Normally, free lists of certain types of objects are managed by the
// run-time system. This hides some allocation and deallocation events
// from tools like purify. A non-zero value for PURIFY disables those
// free lists.
 
#ifndef PURIFY
#define PURIFY 0
#endif
 
// Obsolescent features may be used by setting RTS_COMPATIBLE to a smaller
// number. For example, to enable features present in 5.2, use the value 520.
 
#ifndef RTS_COMPATIBLE
#define RTS_COMPATIBLE 520
#endif
 
// Should statistics be gathered?
 
#ifndef RTS_COUNT
#define RTS_COUNT 0
#endif
 
// RTS_INLINES controls whether RTS header files define any inline functions.
 
#ifndef RTS_INLINES
#define RTS_INLINES 1
#endif
 
#ifndef RTS_INLINE
#   if RTS_INLINES
#       define RTS_INLINE inline
#   else
#       define RTS_INLINE
#   endif
#endif
 
// What level of semantic checking should be done by the frame service?
 
#ifndef RTFRAME_CHECKING
#define RTFRAME_CHECKING RTFRAME_CHECK_STRICT
#endif
 
// When importing a capsule instance into a plugin capsule part, should we check for cycles in the reference graph?
 
#ifndef RTIMPORT_ISREFERENCEDBY_CHECK
#define RTIMPORT_ISREFERENCEDBY_CHECK 1
#endif
 
// Setting this macro to 1 guarantees that the frame service is thread safe.
// This is an option because some applications may use the frame service in
// ways that don't require this level of safety.
 
#ifndef RTFRAME_THREAD_SAFE
#define RTFRAME_THREAD_SAFE 1
#endif
 
// Reserve this many bytes in RTMessage for small objects. When data must
// be copied, objects that are no larger than this will use that space in
// the message itself rather than allocated on the heap.
 
#ifndef RTMESSAGE_PAYLOAD_SIZE
#define RTMESSAGE_PAYLOAD_SIZE 100
#endif
 
// Should we support floating point at all?
 
#ifndef RTUseFloatingPoint
#define RTUseFloatingPoint 1
#endif
 
// Should the class RTReal be present? Target environments that don't
// support floating point data types, or can't afford them, should set
// RTREAL_INCLUDED to zero.
 
#ifndef RTREAL_INCLUDED
#define RTREAL_INCLUDED RTUseFloatingPoint
#endif
 
#if RTREAL_INCLUDED && ! RTUseFloatingPoint
#error RTREAL_INCLUDED requires RTUseFloatingPoint
#endif
 
// RTAlignment: a type with the most demanding alignment.
 
#ifndef RTAlignment
#  if RTUseFloatingPoint
#    define RTAlignment double
#  else
#    define RTAlignment long
#  endif
#endif
 
// What to do about protocols which have signals of incompatible data types?
 
#ifndef RTTYPECHECK_PROTOCOL
#define RTTYPECHECK_PROTOCOL RTTYPECHECK_WARN
#endif
 
// What to do about send, invoke or reply when the type
// is incompatible with the protocol?
 
#ifndef RTTYPECHECK_SEND
#define RTTYPECHECK_SEND RTTYPECHECK_WARN
#endif
 
// Should data be checked for type compatibility as it is received?
 
#ifndef RTTYPECHECK_RECEIVE
#   if ( RTTYPECHECK_PROTOCOL == RTTYPECHECK_FAIL ) && \
       ( RTTYPECHECK_SEND     == RTTYPECHECK_FAIL )
    // There is no point in re-checking: the binding and send were checked.
#       define RTTYPECHECK_RECEIVE RTTYPECHECK_DONT
#   else
#       define RTTYPECHECK_RECEIVE RTTYPECHECK_WARN
#   endif
#endif
 
// Some compilers have trouble with the class nesting for protocol
// backwards compatibility and require the class names to be fully
// qualified.
 
#ifndef RTQUALIFY_NESTED
#define RTQUALIFY_NESTED 0
#endif
 
// Some structures can be made smaller through the use of bit-fields.
// This space savings often comes at the expense of greater code bulk.
 
#ifndef RTUseBitFields
#define RTUseBitFields 0
#endif
 
// The ability to 'suspend' actors is unsupported. Leave this alone.
 
#ifndef SUSPEND
#define SUSPEND 0
#endif
 
// RTStateId_MaxSize controls the maximum amount of space that will be
// allocated to store a state id. The default (2 bytes) supports state machines
// with up to 65535 states. Smaller state machines automatically use less space.
// If all state machines in an application have no more than 255 states, slightly less
// memory (1 byte per actor instance) will be required if RTStateId_MaxSize
// is reduced to 1. In the unlikely situation where one or more state machines have
// more than 65535 states, RTStateId_MaxSize may be increased to 4 without
// any extra overhead for smaller state machines.
 
#ifndef RTStateId_MaxSize
#define RTStateId_MaxSize 2
#endif
 
#if   RTStateId_MaxSize == 1
    typedef unsigned char  RTStateId;
#elif RTStateId_MaxSize == 2
    typedef unsigned short RTStateId;
#elif RTStateId_MaxSize == 4
    typedef unsigned       RTStateId;
#else
#   error RTStateId_MaxSize improperly defined.
#endif
 
// This macro is used in the declaration and definition of generated 'chain'
// functions. It should be either blank, as below, or the keyword 'inline'.
 
#ifndef INLINE_CHAINS
#define INLINE_CHAINS
#endif
 
// This macro is used in the declaration and definition of generated
// functions containing user code for guards, transitions and choie points,
// as well as entry and exit code. It should be either blank, as below, or
// the keyword 'inline'.
 
#ifndef INLINE_METHODS
#define INLINE_METHODS
#endif
 
// The default conditions for enabling target-observability.
 
#ifndef OBSERVABLE
#define OBSERVABLE ( OTRTSDEBUG != DEBUG_NONE && HAVE_INET && \
             OBJECT_DECODE && OBJECT_ENCODE )
#endif
 
// Make sure we have the minimum set of tools necessary.
 
#if OBSERVABLE && ! ( OTRTSDEBUG != DEBUG_NONE && HAVE_INET && \
              OBJECT_DECODE && OBJECT_ENCODE )
#error TargetRTS cannot be OBSERVABLE with OTRTSDEBUG    == DEBUG_NONE \
                    or HAVE_INET     == 0 \
                    or OBJECT_DECODE == 0 \
                    or OBJECT_ENCODE == 0
#endif
 
// The "els" connection service is NOT available.
// This macro is only for backwards compatibility of preprocessor conditions.
 
#define EXTERNAL_LAYER 0
 
// _MSC_VER macro is used to find out the Visual Studio version.
// _MSC_VER value in Visual Studio 2008 (9.0) is 1500.
// For other compilers it is not defined. So It will be consider zero.
// Visual Studio 2008 (9.0) is not having support for nullptr and override.
 
#if __cplusplus < 201103L && _MSC_VER  <= 1500
    #include <cstddef>
    #define nullptr NULL
    #define override /*override*/
    #define RTUseCPP11 0
#else
    #define RTUseCPP11 1
#endif
 
// Macros for the freeList
#ifndef MIN_FREE_LIST_SIZE
#define MIN_FREE_LIST_SIZE 20U
#endif
 
#ifndef MAX_FREE_LIST_SIZE
#define MAX_FREE_LIST_SIZE 100U
#endif
 
#ifndef RTMESSAGE_BLOCK_SIZE
#define RTMESSAGE_BLOCK_SIZE 250
#endif
 
// If this setting is enabled an array config_info will be included in mainLine.cc file,
// containing a textual encoding of all configuration settings used when compiling the TargetRTS.
#ifndef RTCONFIG_INFO
#define RTCONFIG_INFO 0
#endif
 
#endif // __RTConfig_h__