Detailed Description
The defined here are for the most part only applicable when compiling using an RDM source package or an engineering build.
Regarding an object package this is provided here for your information.
Some defined have information about certain safety issues such as thread safeness, reentrancy, and locale dependencies.
Macro Definition Documentation
RDM_ALLOCA_HAVE_ALLOCA
| #define RDM_ALLOCA_HAVE_ALLOCA |
#include <pspplatos.h>
Have alloca (may be defined on some OS)
RDM_ALLOCA_HAVE_MALLOC_H_WITH_ALLOCA
| #define RDM_ALLOCA_HAVE_MALLOC_H_WITH_ALLOCA |
#include <pspplatos.h>
Have malloc.h that declares alloca (may be defined on some OS)
RDM_ALLOCA_HAVE_VARIABLE_SIZE_ARRAY
| #define RDM_ALLOCA_HAVE_VARIABLE_SIZE_ARRAY |
#include <pspplatos.h>
Have variable size arrays (may be defined on some OS)
RDM_ALLOCA_USES_MAX_SIZES
| #define RDM_ALLOCA_USES_MAX_SIZES |
#include <pspplatos.h>
Use the maximum sizes instead of actual size
Use the maximum sizes instead of actual size when dynamically allocating memory on the system stack. Consider using the other metods to save space since many platorms may have a limited stack size.
RDM_ASSERT_INFINITE_LOOP
| #define RDM_ASSERT_INFINITE_LOOP |
#include <pspplatos.h>
Implement assert using an infinite loop (may be defined on some OS)
RDM_ATOMIC_INTEGRITY
| #define RDM_ATOMIC_INTEGRITY |
#include <pspplatos.h>
Atomic integer implementation for Integrity (may be defined on some OS)
RDM_ATOMIC_NO
| #define RDM_ATOMIC_NO |
#include <pspplatos.h>
No atomic integer implementation (may be defined on some OS)
RDM_ATOMIC_UNIX
| #define RDM_ATOMIC_UNIX |
#include <pspplatos.h>
Atomic integer implementation for Unix (may be defined on some OS)
RDM_ATOMIC_WINDOWS
| #define RDM_ATOMIC_WINDOWS |
#include <pspplatos.h>
Atomic integer implementation for Windows (may be defined on some OS)
RDM_COLLATE_HAVE_XLOCALE_H
| #define RDM_COLLATE_HAVE_XLOCALE_H |
#include <pspplatos.h>
Get collate functinality from xlocale.h instead of locale.h
RDM_COLLATE_NO
| #define RDM_COLLATE_NO |
#include <pspplatos.h>
No implementation for string collate (may be defined on some OS)
RDM_COLLATE_REENTRANT
| #define RDM_COLLATE_REENTRANT |
#include <pspplatos.h>
Have reentrant versions of collate (may be defined on some OS)
RDM_COLLATE_UNIX
| #define RDM_COLLATE_UNIX |
#include <pspplatos.h>
Unix implementation for string collate (may be defined on some OS)
RDM_COLLATE_WINDOWS
| #define RDM_COLLATE_WINDOWS |
#include <pspplatos.h>
Windows implementation for string collate (may be defined on some OS)
RDM_CONVERT_NO_PREPRO
| #define RDM_CONVERT_NO_PREPRO |
#include <pspplatos.h>
Do not invode the C preprocessor for input file to rdm-convert (may be defined on some OS)
RDM_CPP_HAVE_STD_STRING
| #define RDM_CPP_HAVE_STD_STRING |
#include <pspplatos.h>
Have C++ standard String class (may be defined on some OS)
RDM_DAEMON_NO
| #define RDM_DAEMON_NO |
#include <pspplatos.h>
No Daemon implementation (may be defined on some OS)
RDM_DAEMON_UNIX
| #define RDM_DAEMON_UNIX |
#include <pspplatos.h>
Daemon implementation for Unix (may be defined on some OS)
RDM_ENV_HAVE_GETIFADDRS
| #define RDM_ENV_HAVE_GETIFADDRS |
#include <pspplatos.h>
Have getifaddrs (may be defined on some OS)
RDM_ENV_LINUX
| #define RDM_ENV_LINUX |
#include <pspplatos.h>
Envirionment implementation for Linux (may be defined on some OS)
RDM_ENV_NO
| #define RDM_ENV_NO |
#include <pspplatos.h>
No environment implementation (may be defined on some OS)
RDM_ENV_OSX
| #define RDM_ENV_OSX |
#include <pspplatos.h>
Envirionment implementation for macOS (may be defined on some OS)
RDM_ENV_UNIX
| #define RDM_ENV_UNIX |
#include <pspplatos.h>
Envirionment implementation for Unix (may be defined on some OS)
RDM_ENV_VXWORKS
| #define RDM_ENV_VXWORKS |
#include <pspplatos.h>
Envirionment implementation for Vxworks Kernel modules (may be defined on some OS)
RDM_ENV_VXWORKS_RTP
| #define RDM_ENV_VXWORKS_RTP |
#include <pspplatos.h>
Envirionment implementation for Vxworks RTP (may be defined on some OS)
RDM_ENV_WINDOWS
| #define RDM_ENV_WINDOWS |
#include <pspplatos.h>
Envirionment implementation for Windows (may be defined on some OS)
RDM_EXPANDABLE_NO_FLEXIBLE_ARRAY_MEMBER
| #define RDM_EXPANDABLE_NO_FLEXIBLE_ARRAY_MEMBER |
#include <pspplatos.h>
No support for flexible array members (last element of a sruct without specified array length)
RDM_FEATURES__EXTENSIONS__
| #define RDM_FEATURES__EXTENSIONS__ |
#include <pspplatos.h>
Define EXTENSIONS (may be defined on some OS)
RDM_FEATURES_GNU_SOURCE
| #define RDM_FEATURES_GNU_SOURCE |
#include <pspplatos.h>
Define _GNU_SOURCE (may be defined on some OS)
RDM_FEATURES_POSIX_C_SOURCE
| #define RDM_FEATURES_POSIX_C_SOURCE |
#include <pspplatos.h>
Define _POSIX_C_SOURCE to the specified value (may be defined on some OS)
RDM_FEATURES_REENTRANT
| #define RDM_FEATURES_REENTRANT |
#include <pspplatos.h>
Define _REENTRANT (may be defined on some OS)
RDM_FEATURES_RW_MULTI_THREAD
| #define RDM_FEATURES_RW_MULTI_THREAD |
#include <pspplatos.h>
Define RW_MULTI_THREAD (may be defined on some OS)
RDM_FFT_USE_FFTW
| #define RDM_FFT_USE_FFTW |
#include <pspplatos.h>
Use FFTW instead of RDM FFT
Use FFTW instead of a simple algorithm included with RDM. RDM is not distributed with FFTW for licensing reasons.
If you want to use FFTW in your program you should probably not use the interface provided here, but rather use FFTW directly.
Please be aware that the license for RDM is incompatible with the GPL license for FFTW. You will need a commercial license. See https://tlo.mit.edu/technologies/fftw-fastest-fourier-transform-west for details.
Define RDM_FFT_USE_FFTW2 if you want to use version 2 of FFTW or RDM_FFT_USE_FFTW3 for version 3. RDM_FFT_USE_FFTW will currently default to version 3.
RDM_FILE_HAVE_DIR_SYNC
| #define RDM_FILE_HAVE_DIR_SYNC |
#include <pspplatos.h>
Have the capability of syncing a directory (may be defined on some OS)
RDM_FILE_HAVE_FALLOCATE
| #define RDM_FILE_HAVE_FALLOCATE |
#include <pspplatos.h>
Have fallocate for punching holes in files (may be defined on some OS)
RDM_FILE_HAVE_FILE_ID
| #define RDM_FILE_HAVE_FILE_ID |
#include <pspplatos.h>
We have an implementation to get a unique ID for a file
This will only be defined for flavors of Unix, Linux, and Windows.
On Unix and Linux the device and inode numbers will be used as returned from fstat.
On Windows the volume serial number and the file index will be used as returned by GetFileInformationByHandle. This is not guaranteed to be unique with the ReFS file system and some 3rd party file systems and defragmentation tools.
RDM_FILE_HAVE_FLOCK
| #define RDM_FILE_HAVE_FLOCK |
#include <pspplatos.h>
Have flock for doing file locking (may be defined on some OS)
RDM_FILE_HAVE_LOCKF
| #define RDM_FILE_HAVE_LOCKF |
#include <pspplatos.h>
Have lockf for doing file locking (may be defined on some OS)
RDM_FILE_HAVE_MADVISE
| #define RDM_FILE_HAVE_MADVISE |
#include <pspplatos.h>
Have madvise
Have the capability of advising the kernal about memory access patterns (may be defined on some OS). This setting may improve overall system performance. We advise the kernal that memory mapped database file pages are references in random order.
RDM_FILE_HAVE_MMAP
| #define RDM_FILE_HAVE_MMAP |
#include <pspplatos.h>
Have the capability of memory mapping files using mmap on Unix or CreateFileMappingA/MapViewOfFile on Windows
RDM_FILE_HAVE_POSIX_FADVISE
| #define RDM_FILE_HAVE_POSIX_FADVISE |
#include <pspplatos.h>
Have posix_fadvise for paging out pages in the file cache (may be defined on some OS)
RDM_FILE_HAVE_PREAD
| #define RDM_FILE_HAVE_PREAD |
#include <pspplatos.h>
Have pread and pwrite (may be defined on some OS) or ReadFile and WriteFile on Windows (which have the same capabilities as the Unix functions)
RDM_FILE_LOCK_NO
| #define RDM_FILE_LOCK_NO |
#include <pspplatos.h>
No file locking (may be defined on some OS)
RDM_FILE_MKDIR_WITH_ONE_PARAMETER
| #define RDM_FILE_MKDIR_WITH_ONE_PARAMETER |
#include <pspplatos.h>
Function mkdir does only take one parameter
- Note
- mkdir may only take one argument on some versions of VxWorks with kernel modules
RDM_FILE_NO
| #define RDM_FILE_NO |
#include <pspplatos.h>
No file system implementation for unbuffered read and write and other file operations (may be defined on some OS)
RDM_FILE_RED
| #define RDM_FILE_RED |
#include <pspplatos.h>
Reliance Edge file system from Datalight
RDM_FILE_SET_ECHO_NO
| #define RDM_FILE_SET_ECHO_NO |
#include <pspplatos.h>
Set echo mode to a terminal is not implemented (may be defined on some OS)
RDM_FILE_STDIO
| #define RDM_FILE_STDIO |
#include <pspplatos.h>
Reading and writing of buffered files using stdio. No other file operations (may be defined on some OS)
RDM_FILE_UNIX
| #define RDM_FILE_UNIX |
#include <pspplatos.h>
Unix file system implementation for unbuffered read and write and other file operations (may be defined on some OS)
RDM_FILE_WINDOWS
| #define RDM_FILE_WINDOWS |
#include <pspplatos.h>
Windows file system implementation for unbuffered read and write and other file operations (may be defined on some OS)
RDM_FLOAT_BITMASKS_FOR_ISFINITE_AND_ISN
| #define RDM_FLOAT_BITMASKS_FOR_ISFINITE_AND_ISN |
#include <pspplatos.h>
Use bitmasks for determining IEEE-754 INF and NAN (may be defined on some OS)
RDM_FLOAT_HAVE_FLOORF
| #define RDM_FLOAT_HAVE_FLOORF |
#include <pspplatos.h>
Have floorf and ceilf (may be defined on some OS)
RDM_FLOAT_HAVE_ISFINITE
| #define RDM_FLOAT_HAVE_ISFINITE |
#include <pspplatos.h>
Have isfinite and isnan (may be defined on some OS)
RDM_INTMAX_NO
| #define RDM_INTMAX_NO |
#include <pspplatos.h>
Does not have uintmax_t and intmax_t defined in stdint.h (may be defined on some OS)
RDM_LOGGING
| #define RDM_LOGGING |
#include <pspplatos.h>
A platform independent logging implementation (may be defined on some OS)
RDM_LOGGING_NO
| #define RDM_LOGGING_NO |
#include <pspplatos.h>
No logging implementation (may be defined on some OS)
RDM_MATH_CONST_FLOAT_H
| #define RDM_MATH_CONST_FLOAT_H |
#include <pspplatos.h>
Get floatingoint constants from float.h
RDM_MATH_CONST_VALUES_H
| #define RDM_MATH_CONST_VALUES_H |
#include <pspplatos.h>
Get floatingoint constants from values.h
RDM_MATH_GCC_BUILTIN
| #define RDM_MATH_GCC_BUILTIN |
#include <pspplatos.h>
Use GCC builtin for floatingoint constants
RDM_MEM_ALIGN_4K
| #define RDM_MEM_ALIGN_4K |
#include <pspplatos.h>
Dynamic memory allocated is 4K aligned (may be defined on some OS)
RDM_MEM_MALLOC
| #define RDM_MEM_MALLOC |
#include <pspplatos.h>
Dynamic memory allocation using malloc and request large blocks (may be defined on some OS)
RDM_MEM_MMAP
| #define RDM_MEM_MMAP |
#include <pspplatos.h>
Dynamic memory allocation using mmap on Unix and request large blocks (may be defined on some OS)
RDM_MEM_NO
| #define RDM_MEM_NO |
#include <pspplatos.h>
No dynamic memory allocation (may be defined on some OS)
RDM_MEM_STATIC_SIZE
| #define RDM_MEM_STATIC_SIZE |
#include <pspplatos.h>
Use a buffer of this size when allocating memory statically (may be defined on some OS)
RDM_MEM_VIRTUAL_ALLOC
| #define RDM_MEM_VIRTUAL_ALLOC |
#include <pspplatos.h>
Dynamic memory allocation using virtual_alloc on Windows and request large blocks (may be defined on some OS)
RDM_MEM_VXWORKS
| #define RDM_MEM_VXWORKS |
#include <pspplatos.h>
Dynamic memory allocation using memalign/free on VxWorks and request large blocks (may be defined on some OS)
RDM_ODBC_UNICODE
| #define RDM_ODBC_UNICODE |
#include <pspplatos.h>
ODBC driver support for Unicode
The ODBC driver include Unicode versions of all functions that accept pointers to character strings or SQLPOINTER in their arguments. The Unicode functions have a suffix of W. (May be defined on some OS).
RDM_STARTUP_WITH_10_ARGS
| #define RDM_STARTUP_WITH_10_ARGS |
#include <pspplatos.h>
Use a startup function with 10 string arguments
We use this with VxWorks kernel modules for the application to be started directly from the VxWorks command prompt or the debugger.
RDM_STR_ASSUME_SPRINTF_IS_SAFE
| #define RDM_STR_ASSUME_SPRINTF_IS_SAFE |
#include <pspplatos.h>
Assume sprintf is safe for floating point numbers (may be defined on some OS)
- Note
- This assumes that sprintf is safe for converting floating point numbers to a string. This may not always be the case. Consider using RDM_STR_HAVE_UNDERSCORE_SPRINTF_L or none at all.
RDM_STR_HAVE_ATOF
| #define RDM_STR_HAVE_ATOF |
#include <pspplatos.h>
Have atof (may be defined on some OS)
- Note
- atof is not reentrant nor safe in an environment where the application sets the global locale. Consider using RDM_STR_HAVE_STRTOD_L instead
RDM_STR_HAVE_STRCASECMP
| #define RDM_STR_HAVE_STRCASECMP |
#include <pspplatos.h>
Have strcasecmp and strncasecmp (may be defined on some OS)
- Note
- strcasecmp and strncasecmp are not reentrant nor safe in an environment where the application sets the global locale. Consider using RDM_STR_HAVE_UNDERSCORE_STRICMP_L or none at all.
RDM_STR_HAVE_STRCASESTR
| #define RDM_STR_HAVE_STRCASESTR |
#include <pspplatos.h>
Have strcasestr (may be defined on some OS)
- Note
- strcasestr is not reentrant nor safe in an environment where the application sets the global locale. Consider not defining this at all.
RDM_STR_HAVE_STRNCMP
| #define RDM_STR_HAVE_STRNCMP |
#include <pspplatos.h>
Have strncmp (may be defined on some OS)
RDM_STR_HAVE_STRTOD
| #define RDM_STR_HAVE_STRTOD |
#include <pspplatos.h>
Have strtod (may be defined on some OS)
- Note
- strtod and strtof are not reentrant nor safe in an environment where the application sets the global locale. Consider using RDM_STR_HAVE_STRTOD_L or RDM_STR_HAVE_UNDERSCORE_STRTOD_L
RDM_STR_HAVE_STRTOD_L
| #define RDM_STR_HAVE_STRTOD_L |
#include <pspplatos.h>
Have strtof_l and strtod_l (may be defined on some OS)
- Note
- This uses strtof_l and strtod_l with a C locale instead of strtof and strtod as a safe replacement
RDM_STR_HAVE_STRTOF
| #define RDM_STR_HAVE_STRTOF |
#include <pspplatos.h>
Have strtof (may be defined on some OS)
- Note
- strtod and strtof are not reentrant nor safe in an environment where the application sets the global locale. Consider using RDM_STR_HAVE_STRTOD_L or RDM_STR_HAVE_UNDERSCORE_STRTOD_L
RDM_STR_HAVE_STRTOK_R
| #define RDM_STR_HAVE_STRTOK_R |
#include <pspplatos.h>
Use strtok_r implementation
- Note
- strtok will be used if RDM_THREAD_NO is defined and neither RDM_STR_HAVE_STRTOK_S nor RDM_STR_HAVE_STRTOK_R is defined. Use of strtok from more than one thread without proper protection is not safe.
RDM_STR_HAVE_STRTOK_S
| #define RDM_STR_HAVE_STRTOK_S |
#include <pspplatos.h>
Use strtok_s implementation
- Note
- strtok will be used if RDM_THREAD_NO is defined and neither RDM_STR_HAVE_STRTOK_S nor RDM_STR_HAVE_STRTOK_R is defined. Use of strtok from more than one thread without proper protection is not safe.
RDM_STR_HAVE_STRTOLL
| #define RDM_STR_HAVE_STRTOLL |
#include <pspplatos.h>
Have strtoll and strtoull (may be defined on some OS)
- Note
- strtod is not reentrant nor safe in an environment where the application sets the global locale. Consider using RDM_STR_HAVE_STRTOLL_L
RDM_STR_HAVE_STRTOLL_L
| #define RDM_STR_HAVE_STRTOLL_L |
#include <pspplatos.h>
Have strtoll_l and strtoull_l (may be defined on some OS)
- Note
- This uses strtoll_l and strtoull_l with a C locale instead of strtoll and strtoull as a safe replacement
RDM_STR_HAVE_UNDERSCORE_SPRINTF_L
| #define RDM_STR_HAVE_UNDERSCORE_SPRINTF_L |
#include <pspplatos.h>
Have _sprintf_l (may be defined on some OS)
- Note
- This uses _sprintf_l with a C locale instead of printf as a safe replacement for converting double to a string.
RDM_STR_HAVE_UNDERSCORE_STRICMP
| #define RDM_STR_HAVE_UNDERSCORE_STRICMP |
#include <pspplatos.h>
Have _tricmp and _strnicmp (may be defined on some OS)
- Note
- _stricmp and _strnicmp are not reentrant nor safe in an environment where the application sets the global locale. Consider using RDM_STR_HAVE_UNDERSCORE_STRICMP_L or none at all.
RDM_STR_HAVE_UNDERSCORE_STRICMP_L
| #define RDM_STR_HAVE_UNDERSCORE_STRICMP_L |
#include <pspplatos.h>
Have _stricmp_l and _strnicmp_l (may be defined on some OS)
- Note
- This uses _stricmp_l and _stricmp_l with a C locale instead of _stricmp and _strnicmp as a safe replacement.
RDM_STR_HAVE_UNDERSCORE_STRTOD_L
| #define RDM_STR_HAVE_UNDERSCORE_STRTOD_L |
#include <pspplatos.h>
Have _strtof_l and _strtod_l (may be defined on some OS)
- Note
- This uses _strtof_l and _strtod_l with a C locale instead of strtof and strtod as a safe replacement
RDM_STR_HAVE_UNDERSCORE_STRTOLL_L
| #define RDM_STR_HAVE_UNDERSCORE_STRTOLL_L |
#include <pspplatos.h>
Have _strtoll_l and _strtoull_l (may be defined on some OS)
- Note
- This uses _strtoll_l and _strtoull_l with a C locale instead of strtoll and strtoull as a safe replacement
RDM_STR_HAVE_UNDERSCORE_STRUPR
| #define RDM_STR_HAVE_UNDERSCORE_STRUPR |
#include <pspplatos.h>
Have _strupr and _strlwr (may be defined on some OS)
- Note
- _strupr and _strlwl are not reentrant nor safe in an environment where the application sets the global locale. Consider using RDM_STR_HAVE_UNDERSCORE_STRUPR_L or none at all.
RDM_STR_HAVE_UNDERSCORE_STRUPR_L
| #define RDM_STR_HAVE_UNDERSCORE_STRUPR_L |
#include <pspplatos.h>
Have _strupr_l and _strlwr_l (may be defined on some OS)
- Note
- This uses _strupr_l and _strlwr_l with a C locale instead of __strupr and _strlwr as a safe replacement.
RDM_TAG_HAVE_FFSLL
| #define RDM_TAG_HAVE_FFSLL |
#include <pspplatos.h>
Have ffsll for finding the first bit set in a word (may be defined on some OS)
RDM_THREAD_BASE_PRIORITY
| #define RDM_THREAD_BASE_PRIORITY |
#include <pspplatos.h>
Thread priority levels are derived from this and RDM_THREAD_INC_PRIORITY (may be defined on some OS)
RDM_THREAD_CALL_PTHREAD_SELF_ON_STARTUP
| #define RDM_THREAD_CALL_PTHREAD_SELF_ON_STARTUP |
#include <pspplatos.h>
Call pthread_self on startup
Run Time Processes (RTP) on VxWorks have a call to pthread_self as part of starting up the process to signal that pthreads are used
RDM_THREAD_FREE_RTOS
| #define RDM_THREAD_FREE_RTOS |
#include <pspplatos.h>
Thread implemantation for FreeRTOS
RDM_THREAD_INC_PRIORITY
| #define RDM_THREAD_INC_PRIORITY |
#include <pspplatos.h>
Thread priority levels are derived from this and RDM_THREAD_BASE_PRIORITY (may be defined on some OS)
RDM_THREAD_INTEGRITY
| #define RDM_THREAD_INTEGRITY |
#include <pspplatos.h>
Thread implementation for INTEGRITY (may be defined on some OS)
RDM_THREAD_NO
| #define RDM_THREAD_NO |
#include <pspplatos.h>
No thread implementation (may be defined on some OS)
RDM_THREAD_PTHREAD
| #define RDM_THREAD_PTHREAD |
#include <pspplatos.h>
Thread implementation for Posix Threads on Unix (may be defined on some OS)
RDM_THREAD_USE_PPOLL_TO_SLEEP
| #define RDM_THREAD_USE_PPOLL_TO_SLEEP |
#include <pspplatos.h>
Use ppoll and proper signal masking to sleep where it needs to be interuptible (may be defined on some OS)
RDM_THREAD_USE_PSELECT_TO_SLEEP
| #define RDM_THREAD_USE_PSELECT_TO_SLEEP |
#include <pspplatos.h>
Use pselect and proper signal masking to sleep where it needs to be interuptible (may be defined on some OS)
RDM_THREAD_VXWORKS
| #define RDM_THREAD_VXWORKS |
#include <pspplatos.h>
Thread implementation for VxWorks (may be defined on some OS)
RDM_THREAD_WINDOWS
| #define RDM_THREAD_WINDOWS |
#include <pspplatos.h>
Thread implementation for Windows (may be defined on some OS)
RDM_TIME_FREE_RTOS
| #define RDM_TIME_FREE_RTOS |
#include <pspplatos.h>
Use clock ticks for FREE_RTOS to measure elapsed time
RDM_TIME_HAVE_CLOCK_GETTIME
| #define RDM_TIME_HAVE_CLOCK_GETTIME |
#include <pspplatos.h>
Have clock_gettime (may be defined on some OS)
RDM_TIME_HAVE_TIME64_T
| #define RDM_TIME_HAVE_TIME64_T |
#include <pspplatos.h>
Have the time64_t type (may be defined on some OS)
RDM_TIME_NO
| #define RDM_TIME_NO |
#include <pspplatos.h>
No time implementation (may be defined on some OS)
RDM_TIME_UNIX
| #define RDM_TIME_UNIX |
#include <pspplatos.h>
Timed implementation for Unix (may be defined on some OS)
RDM_TIME_WINDOWS
| #define RDM_TIME_WINDOWS |
#include <pspplatos.h>
Time implementation for Windows (may be defined on some OS)
RDM_TRANSPORT_HAVE_SHARED_MEMORY
| #define RDM_TRANSPORT_HAVE_SHARED_MEMORY |
#include <pspplatos.h>
Shared memory (may be defined on some OS)
RDM_TRANSPORT_HAVE_TCP [1/2]
| #define RDM_TRANSPORT_HAVE_TCP |
#include <pspplatos.h>
We have a TCP implementation (may be defined on some OS)
Implement a TCP transport (may be defined on some OS)
RDM_TRANSPORT_HAVE_TCP [2/2]
| #define RDM_TRANSPORT_HAVE_TCP |
#include <pspplatos.h>
We have a TCP implementation (may be defined on some OS)
Implement a TCP transport (may be defined on some OS)
RDM_TRANSPORT_TCP_ACCEPT_NO_DELAY
| #define RDM_TRANSPORT_TCP_ACCEPT_NO_DELAY |
#include <pspplatos.h>
Use socket option TCP_NODELAY for accepting a connection (may be defined on some OS)
RDM_TRANSPORT_TCP_CONNECT_NO_DELAY
| #define RDM_TRANSPORT_TCP_CONNECT_NO_DELAY |
#include <pspplatos.h>
Use socket option TCP_NODELAY for conneting (may be defined on some OS)
RDM_TRANSPORT_TCP_DONT_USE_KEEPALIVES
| #define RDM_TRANSPORT_TCP_DONT_USE_KEEPALIVES |
#include <pspplatos.h>
Use socket option SO_KEEPALIVE (may be defined on some OS)
RDM_TRANSPORT_TCP_HAVE_MSG_NOSIGNAL
| #define RDM_TRANSPORT_TCP_HAVE_MSG_NOSIGNAL |
#include <pspplatos.h>
Have the send flag MSG_NOSIGNAL (may be defined on some OS)
RDM_TRANSPORT_TCP_HAVE_POLL
| #define RDM_TRANSPORT_TCP_HAVE_POLL |
#include <pspplatos.h>
Have poll and use this instead of select (may be defined on some OS)
RDM_TRANSPORT_TCP_HAVE_QOS
| #define RDM_TRANSPORT_TCP_HAVE_QOS |
#include <pspplatos.h>
Have Quality Of Service (may be defined on some OS)
RDM_TRANSPORT_TCP_LOCALHOST
| #define RDM_TRANSPORT_TCP_LOCALHOST "127.0.0.1" |
#include <pspplatos.h>
The IP address to use for localhost (may be defined on some OS)
RDM_TRANSPORT_TCP_NO_IPV6
| #define RDM_TRANSPORT_TCP_NO_IPV6 |
#include <pspplatos.h>
No IP version 6 implementation (may be defined on some OS)
RDM_UNIX
| #define RDM_UNIX |
#include <pspplatos.h>
This is a Posix or Unix like system (may be defined on some OS)
RDM_VARARGS_HAVE_VA_COPY
| #define RDM_VARARGS_HAVE_VA_COPY |
#include <pspplatos.h>
Have va_copy (may be defined on some OS)
RDM_VSNPRINTF
| #define RDM_VSNPRINTF |
#include <pspplatos.h>
Using our own vsnprintf (may be defined on some OS)