mlpiGlobal.h

Go to the documentation of this file.

#ifndef __MLPIGLOBAL_H__
#define __MLPIGLOBAL_H__

// -----------------------------------------------------------------------
// MLPI - <mlpiGlobal.h>
// -----------------------------------------------------------------------
// Copyright (c) 2013 Bosch Rexroth. All rights reserved.
// Redistribution and use in source and binary forms of this MLPI software
// (SW) provided to you, with or without modification, are permitted
// without prior approval provided that the following conditions are met:
//
// 1. Redistributions of source code of SW must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form of SW must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. User recognizes and acknowledges that it acquires no right,
// title or interest in or to any of the names or trademarks used in
// connection with the SW ("names") by virtue of this License and waives
// any right to or interest in the names. User recognizes and acknowledges
// that names of companies or names or products of companies displayed
// in the documentation of SW to indicate the interoperability of products
// with the SW are the names of their respective owners. The use of such
// names in the documentation of SW does not imply any sponsorship,
// approval, or endorsement by such companies of this product.
//
// 4. Modified code versions, i.e. any addition to or deletion from
// the substance or structure of the original code of the SW running
// the MLPI must be plainly marked as such and must not be misrepresented
// as being original SW.
//
// 5. The SW may only be used in connection with a Bosch Rexroth product.
//
// THIS INFORMATION IS PROVIDED BY BOSCH REXROTH CORPORATION "AS IS"
// AND WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING
// (BUT NOTLIMITED TO) ANY IMPLIED WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR ANY PARTICULAR PURPOSE, OR NON-INFRINGEMENT. WHILE THE
// INFORMATION PROVIDED IS BELIEVED TO BE ACCURATE, IT MAY INCLUDE
// ERRORS OR INACCURACIES.
// SUBJECT TO COMPULSORY STATUTORY PROVISIONS OF THE GERMAN LAW AS
// THE APPLICABLE LAW FOR THIS LICENSE BOSCH REXROTH CORPORATION WILL
// NOT BE LIABLE FOR ANY DAMAGES OF ANY KIND ARISING FROM THE USE OF
// THE  SOFTWARE  DISTRIBUTED HEREUNDER, INCLUDING BUT NOT LIMITED TO
// DIRECT, INDIRECT, INCIDENTAL, PUNITIVE, AND CONSEQUENTIAL DAMAGES.
// -----------------------------------------------------------------------
//
//
// -----------------------------------------------------------------------


#ifndef __cplusplus
  #error MLPI requires C++ compilation (use a .cpp suffix)
#endif

#include "targetinfo.h"

// Needed only when RTP is used.
// Because when RTP is used. The ACI includes the libBase type definition headers and they cause conflic with the
// VxWorks header semLib.h added in marshal.h
// The conflict hierarchy occurs as follows:
// mlpiApiLibClient.cpp -> mlpiApiLibId.h -> mlpiGlobalId.h -> marshal.h -> semLib.h -> vxWorks.h -> vxWorksCommon.h -> vxTypesOld.h (VOID defined here)
// mlpiApiLibClient.cpp -> mlpiApiLib.h -> mlpiGlobal.h -> globtype.h (VOID defined here)
#if defined(__RTP__)
#undef VOID
#endif

// In case ACI is used, then the Atomic Double is used to avoid redefine conflicts
#if defined(__ACI_MLPI__) && defined(GLOBTYPE_USE_ATOMIC_DOUBLE)
  #include "AtomicDouble.h"
#endif

#if defined (TARGET_OS_LINUX) && (_SYS_SYSMACROS_H)
  // There is a capital mistake within sysmacros.h by define 'major',
  // which cause the error 'class 'MlpiVersion' does not have any field named 'gnu_dev_major''
  // therefore we switched it off.
  // Note: You have to add the 'major' define of sysmacros.h (below) again if needed.
  //       #define major(dev) gnu_dev_major(dev)
  #undef major
#endif

#if defined (TARGET_OS_LINUX) && (_SYS_SYSMACROS_H)
  // There is a capital mistake within sysmacros.h by define 'minor',
  // which cause the error 'class 'MlpiVersion' does not have any field named 'gnu_dev_minor''
  // therefore we switched it off.
  // Note: You have to add the 'minor' define of sysmacros.h (below) again if needed.
  //       #define minor(dev) gnu_dev_minor(dev)
  #undef minor
#endif


//
// supported platforms
//
#if defined (TARGET_OS_VXWORKS_KERNEL)
  // compiling under VxWorks environment
#elif defined (TARGET_OS_VXWORKS_RTP)
  // compiling under WIN64 environment
#elif defined (TARGET_OS_WINNT64)
  // compiling under WIN64 environment
#elif defined (TARGET_OS_WINNT32)
  // compiling under WIN32 environment
#elif defined (TARGET_OS_WINCE32)
  // compiling under WINCE environment
#elif defined (TARGET_OS_MAC)
  // compiling under Mac OS environment
#elif defined (TARGET_OS_IOS)
  // compiling under iOS environment
#elif defined (TARGET_OS_ANDROID)
  // compiling under Android environment
#elif defined (TARGET_OS_LINUX)
  // compiling under Linux environment
#else
  #pragma warning "unknown operating system"
#endif

//
// supported compilers
//
#if defined(TARGET_COMPILER_GCC)
  // compiling with GNU GCC/G++ Compiler
#elif defined(TARGET_COMPILER_MSVC)
  // compiling with Microsoft Visual Studio Compiler
#elif defined(TARGET_COMPILER_INTEL)
  // compiling with Intel ICC/ICPC Compiler
#elif defined(TARGET_COMPILER_LLVM)
  // compiling with Clang/LLVM Compiler
#else
  // unknown compiler
  #pragma warning "unknown compiler"
#endif

//
// additional defines
//
// - MLPI_SERVER_LIB: to be used only in the server lib. do not set in the client application!
// - MLPI_CLIENT_LIB: to be used only in the client lib. do not set in the server application!



// -----------------------------------------------------------------------
// GLOBAL TYPES
// -----------------------------------------------------------------------

//
// MLPI basic data types
//
typedef signed char                   BOOL8;      
typedef char                          CHAR;       
typedef unsigned char                 UCHAR;      
typedef short                         SHORT;      
typedef unsigned short                USHORT;     
#if !defined (TARGET_COMPILER_MSVC) && !defined (TARGET_OS_VXWORKS)
typedef int                           LONG;       
typedef unsigned int                  ULONG;      
#else
typedef long                          LONG;       
typedef unsigned long                 ULONG;      
#endif
typedef long long                     LLONG;      
typedef unsigned long long            ULLONG;     
typedef float                         FLOAT;      
#if !defined(MLPI_SERVER_LIB)
  #if defined(__ACI_MLPI__) && defined(GLOBTYPE_USE_ATOMIC_DOUBLE)
  typedef AtomicDouble                DOUBLE;  
  #else
  typedef double                      DOUBLE;     
  #endif
#endif
#if defined(MLPI_SHORT_WCHAR16)
// This is the setting for all unix platforms, as they have buildin 4 byte wchar_t (__APPLE__, __ANDROID__, __linux__).
typedef unsigned short                WCHAR16;    
#else
  #if (__cplusplus > 201103L)
  // This is the alternative setting for all unix platforms with C++11 support (__APPLE__, __ANDROID__, __linux__).
  typedef char16_t                    WCHAR16;    
  #else
  // This is the alternative settings on unix platforms without C++11 support (__APPLE__, __ANDROID__, __linux__) and all
  // other platforms (_WIN32, __VXWORKS__).
  //
  // Note: Unix platforms (__APPLE__, __ANDROID__, __linux__) has to be used with compiler option '-fshort-wchar' to make
  //       wchar 2 byte wide.
  typedef wchar_t                     WCHAR16;    
  #endif
#endif

#if !defined (TARGET_COMPILER_MSVC) && !defined (TARGET_OS_VXWORKS)
typedef int                           MLPIRESULT; 
#else
typedef long                          MLPIRESULT; 
#endif

#if defined (TARGET_BITNESS_64BIT)
typedef unsigned long long            MLPIHANDLE; 
#else
typedef unsigned long                 MLPIHANDLE; 
#endif

typedef unsigned long long MLPITASKHANDLE;        

typedef unsigned long      PROCESSHANDLE;         



typedef enum MlpiType
{
  MLPI_TYPE_INVALID           =    0,   

  MLPI_TYPE_CHAR              =    1,   
  MLPI_TYPE_UCHAR             =    2,   
  MLPI_TYPE_SHORT             =    3,   
  MLPI_TYPE_USHORT            =    4,   
  MLPI_TYPE_LONG              =    5,   
  MLPI_TYPE_ULONG             =    6,   
  MLPI_TYPE_LLONG             =    7,   
  MLPI_TYPE_ULLONG            =    8,   
  MLPI_TYPE_FLOAT             =    9,   
  MLPI_TYPE_DOUBLE            =   10,   

  MLPI_TYPE_CHAR_ARRAY        =   11,   
  MLPI_TYPE_UCHAR_ARRAY       =   12,   
  MLPI_TYPE_SHORT_ARRAY       =   13,   
  MLPI_TYPE_USHORT_ARRAY      =   14,   
  MLPI_TYPE_LONG_ARRAY        =   15,   
  MLPI_TYPE_ULONG_ARRAY       =   16,   
  MLPI_TYPE_LLONG_ARRAY       =   17,   
  MLPI_TYPE_ULLONG_ARRAY      =   18,   
  MLPI_TYPE_FLOAT_ARRAY       =   19,   
  MLPI_TYPE_DOUBLE_ARRAY      =   20,   

  MLPI_TYPE_BOOL8             =   21,   
  MLPI_TYPE_BOOL8_ARRAY       =   22,   

  MLPI_TYPE_CHAR_UTF8         =   23,   
  MLPI_TYPE_CHAR_UTF16        =   24,   
  MLPI_TYPE_CHAR_UTF8_ARRAY   =   25,   
  MLPI_TYPE_CHAR_UTF16_ARRAY  =   26    
}MlpiType;

typedef enum MlpiProcessState
{
  MLPI_PROCESS_STATUS_NOT_STARTED          =   0, 
  MLPI_PROCESS_STATUS_INITIALIZATION       =  32, 
  MLPI_PROCESS_STATUS_INWORK               =  64, 
  MLPI_PROCESS_STATUS_FINISHED             = 128, 
  MLPI_PROCESS_STATUS_ERROR                = 256, 
}MlpiProcessState;

// -----------------------------------------------------------------------
// Alignment
// -----------------------------------------------------------------------

#if defined(TARGET_COMPILER_GCC)
  // compiling with GNU GCC/G++ Compiler
  #define MLPI_DATA_ALIGN(x) __attribute__ ((aligned(x)))
#elif defined(TARGET_COMPILER_MSVC)
  // compiling with Microsoft Visual Studio Compiler
  #define MLPI_DATA_ALIGN(x) __declspec(align(x))
#elif defined(TARGET_COMPILER_INTEL)
  // compiling with Intel ICC/ICPC Compiler
  #define MLPI_DATA_ALIGN(x) __declspec(align(x))
#elif defined(TARGET_COMPILER_LLVM)
  // compiling with Clang/LLVM Compiler
  #define MLPI_DATA_ALIGN(x) __attribute__ ((aligned(x)))
#else
  // unknown compiler
  #pragma warning "unknown compiler"
#endif


// NOTE: Macros for alignment and packing of data structures within MLPI structs.

#define MLPI_STRUCT_ALIGN_BOOL8     MLPI_DATA_ALIGN(1)      

#define MLPI_STRUCT_ALIGN_CHAR      MLPI_DATA_ALIGN(1)      
#define MLPI_STRUCT_ALIGN_SHORT     MLPI_DATA_ALIGN(2)      
#define MLPI_STRUCT_ALIGN_LONG      MLPI_DATA_ALIGN(4)      
#define MLPI_STRUCT_ALIGN_LLONG     MLPI_DATA_ALIGN(8)      

#define MLPI_STRUCT_ALIGN_UCHAR     MLPI_DATA_ALIGN(1)      
#define MLPI_STRUCT_ALIGN_USHORT    MLPI_DATA_ALIGN(2)      
#define MLPI_STRUCT_ALIGN_ULONG     MLPI_DATA_ALIGN(4)      
#define MLPI_STRUCT_ALIGN_ULLONG    MLPI_DATA_ALIGN(8)      

#define MLPI_STRUCT_ALIGN_FLOAT     MLPI_DATA_ALIGN(4)      
#define MLPI_STRUCT_ALIGN_DOUBLE    MLPI_DATA_ALIGN(8)      

#define MLPI_STRUCT_ALIGN_ENUM      MLPI_DATA_ALIGN(4)      

#define MLPI_STRUCT_ALIGN_WCHAR16   MLPI_DATA_ALIGN(2)      

#define MLPI_STRUCT_ALIGN_STRUCT                            


// NOTE: Macros for alignment and packing of data structures regarding a PLC interface.
//       It's recommended to use these MLPI IEC types for data types within structures
//       which represent a interface of a external implemented IEC POU (see also
//       mlpiLogicPouExtensionRegister etc.).

typedef BOOL8     MLPI_DATA_ALIGN(1)    MLPI_IEC_BOOL;      

typedef CHAR      MLPI_DATA_ALIGN(1)    MLPI_IEC_SINT;      
typedef SHORT     MLPI_DATA_ALIGN(2)    MLPI_IEC_INT;       
typedef LONG      MLPI_DATA_ALIGN(4)    MLPI_IEC_DINT;      
typedef LLONG     MLPI_DATA_ALIGN(8)    MLPI_IEC_LINT;      

typedef UCHAR     MLPI_DATA_ALIGN(1)    MLPI_IEC_USINT;     
typedef USHORT    MLPI_DATA_ALIGN(2)    MLPI_IEC_UINT;      
typedef ULONG     MLPI_DATA_ALIGN(4)    MLPI_IEC_UDINT;     
typedef ULLONG    MLPI_DATA_ALIGN(8)    MLPI_IEC_ULINT;     

typedef UCHAR     MLPI_DATA_ALIGN(1)    MLPI_IEC_BYTE;      
typedef USHORT    MLPI_DATA_ALIGN(2)    MLPI_IEC_WORD;      
typedef ULONG     MLPI_DATA_ALIGN(4)    MLPI_IEC_DWORD;     
typedef ULLONG    MLPI_DATA_ALIGN(8)    MLPI_IEC_LWORD;     

typedef FLOAT     MLPI_DATA_ALIGN(4)    MLPI_IEC_REAL;      
typedef DOUBLE    MLPI_DATA_ALIGN(8)    MLPI_IEC_LREAL;     

typedef ULONG     MLPI_DATA_ALIGN(4)    MLPI_IEC_TIME;      
typedef ULONG     MLPI_DATA_ALIGN(4)    MLPI_IEC_DATE;      
typedef ULONG     MLPI_DATA_ALIGN(4)    MLPI_IEC_DAT;       
typedef ULONG     MLPI_DATA_ALIGN(4)    MLPI_IEC_TOD;       
typedef SHORT     MLPI_DATA_ALIGN(4)    MLPI_IEC_ENUM;      

typedef CHAR      MLPI_DATA_ALIGN(1)    MLPI_IEC_STRING;    
typedef SHORT     MLPI_DATA_ALIGN(2)    MLPI_IEC_WSTRING;   



// -----------------------------------------------------------------------
// GLOBAL CONSTANTS
// -----------------------------------------------------------------------

#ifndef TRUE
#define TRUE                        ( 1 )    /* Boolean true  */
#endif

#ifndef FALSE
#define FALSE                       ( 0 )    /* Boolean false */
#endif

//
// MLPI error codes
//
// NOTE: here are the most common basic return codes given by the API.
//       It is not possible to list all codes here. See user documentation of the device for
//       specific error codes.
#define MLPI_S_OK                           ((MLPIRESULT) 0x00360000L)   
#define MLPI_E_FAIL                         ((MLPIRESULT) 0xF0360001L)   
#define MLPI_E_NOTSUPPORTED                 ((MLPIRESULT) 0xF0360002L)   
#define MLPI_E_INVALIDARG                   ((MLPIRESULT) 0xF0360003L)   
#define MLPI_E_OUTOFMEMORY                  ((MLPIRESULT) 0xF0360004L)   
#define MLPI_E_TIMEOUT                      ((MLPIRESULT) 0xF0360005L)   
#define MLPI_E_SERVEREXCEPTION              ((MLPIRESULT) 0xF0360006L)   
#define MLPI_E_CONNECTFAILED                ((MLPIRESULT) 0xF0360007L)   
#define MLPI_E_CREATEERROR                  ((MLPIRESULT) 0xF0360008L)   
#define MLPI_E_SYSTEMERROR                  ((MLPIRESULT) 0xF0360009L)   
#define MLPI_E_BUFFERTOOSHORT               ((MLPIRESULT) 0xF036000AL)   
#define MLPI_E_INVALIDSIGNATURE             ((MLPIRESULT) 0xF036000BL)   
#define MLPI_E_STARTERROR                   ((MLPIRESULT) 0xF036000CL)   
#define MLPI_E_WATCHDOGWARNING              ((MLPIRESULT) 0xF036000DL)   
#define MLPI_E_WATCHDOGERROR                ((MLPIRESULT) 0xF536000EL)   
#define MLPI_E_UNIMPLEMENTED                ((MLPIRESULT) 0xF036000FL)   
#define MLPI_E_LIMIT_MIN                    ((MLPIRESULT) 0xF0360010L)   
#define MLPI_E_LIMIT_MAX                    ((MLPIRESULT) 0xF0360011L)   
#define MLPI_E_VERSION                      ((MLPIRESULT) 0xF0360012L)   
#define MLPI_E_DEPRECATED                   ((MLPIRESULT) 0xF0360013L)   
#define MLPI_E_PERMISSION                   ((MLPIRESULT) 0xF0360014L)   
#define MLPI_E_TYPE_MISSMATCH               ((MLPIRESULT) 0xF0360015L)   
#define MLPI_E_SIZE_MISSMATCH               ((MLPIRESULT) 0xF0360016L)   
#define MLPI_E_INVALID_HANDLE               ((MLPIRESULT) 0xF0360017L)   
#define MLPI_E_NOCONNECTION                 ((MLPIRESULT) 0xF0360018L)   
#define MLPI_E_RD_WR_PROTECTION             ((MLPIRESULT) 0xF0360019L)   
#define MLPI_E_INVALID_FLOATINGPOINT        ((MLPIRESULT) 0xF036001AL)   
#define MLPI_E_NOTINITIALIZED               ((MLPIRESULT) 0xF036001BL)   
#define MLPI_E_STREAM_OUT_OF_SYNC           ((MLPIRESULT) 0xF036001CL)   
#define MLPI_E_INVALID_PRIVATEKEY_FILE      ((MLPIRESULT) 0xF036001DL)   
#define MLPI_E_INVALID_CERTIFICATE_FILE     ((MLPIRESULT) 0xF036001EL)   
#define MLPI_E_KEYPAIR_MISSMATCH            ((MLPIRESULT) 0xF036001FL)   
#define MLPI_E_TLS_HANDSHAKE_FAILED         ((MLPIRESULT) 0xF0360020L)   
#define MLPI_E_GENERAL_AC_ERROR             ((MLPIRESULT) 0xF0360021L)   
#define MLPI_E_POLICY_VIOLATION_AC          ((MLPIRESULT) 0xF0360022L)   
#define MLPI_E_USER_ALREADY_EXISTS          ((MLPIRESULT) 0xF0360023L)   
#define MLPI_E_GROUP_ALREADY_EXISTS         ((MLPIRESULT) 0xF0360024L)   
#define MLPI_E_MEMBERSHIP_ALREADY_EXISTS    ((MLPIRESULT) 0xF0360025L)   
#define MLPI_E_USER_NOT_EXISTING            ((MLPIRESULT) 0xF0360026L)   
#define MLPI_E_GROUP_NOT_EXISTING           ((MLPIRESULT) 0xF0360027L)   
#define MLPI_E_MEMBERSHIP_NOT_EXISTING      ((MLPIRESULT) 0xF0360028L)   
#define MLPI_E_PERMISSION_NOT_EXISTING      ((MLPIRESULT) 0xF0360029L)   

#define MLPI_SUCCEEDED(hr)                ((MLPIRESULT)(hr) >= 0)      
#define MLPI_FAILED(hr)                   ((MLPIRESULT)(hr) < 0)       


//
// Common constants
//
#if defined (TARGET_BITNESS_64BIT)
#define MLPI_INVALIDHANDLE           ((MLPIHANDLE) 0xFFFFFFFFFFFFFFFF)  
#else
#define MLPI_INVALIDHANDLE           ((MLPIHANDLE) 0xFFFFFFFF)          
#endif



// -----------------------------------------------------------------------
// GLOBAL TYPEDEFS
// -----------------------------------------------------------------------

// message packing follows 8 byte natural alignment
#if !defined(TARGET_OS_VXWORKS)
  #pragma pack(push,8)
#endif

typedef struct MlpiDateAndTime
{
  SHORT  year;           
  SHORT  month;          
  SHORT  day;            
  SHORT  hour;           
  SHORT  minute;         
  SHORT  second;         
  SHORT  milliSecond;    
  SHORT  microSecond;    
  SHORT  dayOfWeek;      
  SHORT  dayOfYear;      
}MlpiDateAndTime;


typedef struct MlpiVersion
{
public:
  MlpiVersion()
    :major(0)
    ,minor(0)
    ,bugfix(0)
    ,patch(0)
    ,build(0){}

  MlpiVersion(ULONG major, ULONG minor, ULONG bugfix, ULONG patch, ULONG build)
    :major(major)
    ,minor(minor)
    ,bugfix(bugfix)
    ,patch(patch)
    ,build(build){}

  MlpiVersion(ULONG major, ULONG minor, ULONG bugfix, ULONG patch)
    :major(major)
    ,minor(minor)
    ,bugfix(bugfix)
    ,patch(patch)
    ,build(0){}

  ULONG major;         
  ULONG minor;         
  ULONG bugfix;        
  ULONG patch;         
  ULONG build;         
} MlpiVersion;


#if !defined(TARGET_OS_VXWORKS)
  #pragma pack(pop)
#endif



// -----------------------------------------------------------------------
// GLOBAL MACROS
// -----------------------------------------------------------------------

// unfortunately missing on some platforms
#ifndef _countof
  #define _countof(x) (sizeof(x)/sizeof(x[0]))
#endif

// convert a given literal to WCHAR16 format
#define MLPI_ADAPT_STRING_WCHAR16_(x) L ## x
#define MLPI_ADAPT_STRING_WCHAR16(x) MLPI_ADAPT_STRING_WCHAR16_(x)  // convert normal string always to WCHAR16 literal
#ifndef MLPI_SERVER_LIB
  #define MLPI_ADAPT_STRING(x) MLPI_ADAPT_STRING_WCHAR16_(x)        // convert normal string to WCHAR16 literal on client side
#else
  #define MLPI_ADAPT_STRING(x) x                                    // convert normal string NOT to WCHAR16 literal on server side
#endif



// -----------------------------------------------------------------------
// GLOBAL FUNCTIONS
// -----------------------------------------------------------------------

// Use to check whether FLOAT or DOUBLE 'data' contains a valid floating point number
class MlpiTestFpu
{
public:
  MlpiTestFpu(const FLOAT *in) {
    test(in);
  }
  MlpiTestFpu(const DOUBLE *in) {
    test(in);
  }
  template <typename T> MlpiTestFpu(const FLOAT *in, T numElements)
    : out(TRUE)
  {
    for(T i=0; (i<numElements) && (out==TRUE); i++) {
      test(in+i);
    }
  }
  template <typename T> MlpiTestFpu(const DOUBLE *in, T numElements)
    : out(TRUE)
  {
    for(T i=0; (i<numElements) && (out==TRUE); i++) {
      test(in+i);
    }
  }
  inline BOOL8 isValid(void) {return out;}

private:
  inline void test(const FLOAT *in)
  {
    ULONG ul = *reinterpret_cast<const ULONG*>(in);
    out = ((ul&0x7fffffff)==0) ? TRUE : ( ((ul&0x7f800000)==0) ? FALSE : ( ((ul&0x7f800000)==0x7f800000) ? FALSE : TRUE ) );
  }
  inline void test(const DOUBLE *in)
  {
    ULLONG ull = *reinterpret_cast<const ULLONG*>(in);
    out = ((ull&0x7fffffffffffffffLL)==0) ? TRUE : ( ((ull&0x7ff0000000000000LL)==0) ? FALSE : ( ((ull&0x7ff0000000000000LL)==0x7ff0000000000000LL) ? FALSE : TRUE ) );
  }
  BOOL8 out;
};

// Use to check whether FLOAT 'data' contains a valid floating point number
inline BOOL8 MLPI_TEST_IS_FLOAT(const FLOAT data) { return(MlpiTestFpu(&data).isValid()); }

// Use to check whether DOUBLE 'data' contains a valid floating point number
inline BOOL8 MLPI_TEST_IS_DOUBLE(const DOUBLE data) { return(MlpiTestFpu(&data).isValid()); }

// Use to check whether FLOAT array 'data' contains a valid array of floating point numbers with 'numElements' number of elements
template <typename T> inline BOOL8 MLPI_TEST_IS_FLOAT_ARRAY(const FLOAT *data, T numElements) { return(MlpiTestFpu(data, numElements).isValid()); }

// Use to check whether DOUBLE array 'data' contains a valid array of floating point numbers with 'numElements' number of elements
template <typename T> inline BOOL8 MLPI_TEST_IS_DOUBLE_ARRAY(const DOUBLE *data, T numElements)  { return(MlpiTestFpu(data, numElements).isValid()); }


#endif // endof: #ifndef __MLPIGLOBAL_H__