Detailed Description
The defined here are for the most part only applicable when compiling using a RaimaDB 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_ASSERT_INFINITE_LOOP_STDERR
| #define RDM_ASSERT_INFINITE_LOOP_STDERR |
#include <pspplatos.h>
Also print a message to standard error (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_ATTRIBUTE_FORMAT_GCC
| #define RDM_ATTRIBUTE_FORMAT_GCC |
#include <pspplatos.h>
Use GCC style of attribute format to validate format strings (may be defined on some OS)
GCC style attribute format is the only one supported.
We use lld, llu, and llx for the 64-bit integer types. The underlying types for these are either variations of long or long long. GCC therefore issue warnings on platforms where the underlying type is a long. For this reason only some platforms have this enabled.
RDM_CLIENT_API_MUTEX
| #define RDM_CLIENT_API_MUTEX |
#include <pspplatos.h>
Mutex protect RaimaDB API call
Protect calls to any rdm_tfs..., rdm_db..., rdm_cursor..., and rdm_trans... public APIs by using a mutex where we acquire it when entering and release it when exit. This is for the purpose of using a transport where messages from multiple users (each has their own RDM_DB/TFS handle) are interleaved on one shared channel.
An alternative to this is to use a mutex when calling RaimaDB public functions.
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_NO_GHOST_CLASSES
| #define RDM_CPP_NO_GHOST_CLASSES |
#include <pspplatos.h>
No Ghost Clases (may be defined on some OS)
Do not do size of classes generated through a template that are not otherwise used without a using statement.
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_SEED_NO_ADDRESS_OF
| #define RDM_ENV_SEED_NO_ADDRESS_OF |
#include <pspplatos.h>
Don't take the address of a function and a stack variable to compute a seed
We may define this to comply with standards or for platforms where these numbers are deterministic.
RDM_ENV_SIGNAL
| #define RDM_ENV_SIGNAL |
#include <pspplatos.h>
Sending signals to a process (may be defined on some OS)
Allow sending a signal to a process as seen from the TFS. With this, clients on for example a micro controller can send a signal to a process where the TFS is hosted.
This feature should not be enabled on most platforms since it poses a security risk. In the event that the TFS is running as a different user or with elevated privileges compared to its clients the clients can send signals to other processis that it otherwise are not able to do.
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_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 RaimaDB FFT
Use FFTW instead of a simple algorithm included with RaimaDB. RaimaDB 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 RaimaDB 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_IGNORE
| #define RDM_FILE_IGNORE |
#include <pspplatos.h>
No implementation for buffered file operations except that any output is ignored and we get eNOTIMPLEMENTED_FILE for certain functions and EOF for any read operations. Opening files will silently succeed. (may be defined on some OS)
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_DONT_INCLUDE_MATH_H
| #define RDM_MATH_DONT_INCLUDE_MATH_H |
#include <pspplatos.h>
Dont include math.h
RDM_MATH_GCC_BUILTIN
| #define RDM_MATH_GCC_BUILTIN |
#include <pspplatos.h>
Use GCC builtin for floatingoint constants
RDM_MATH_SQRT_QUAKE3
| #define RDM_MATH_SQRT_QUAKE3 |
#include <pspplatos.h>
Quake 3 implementation of sqrt
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_QA_HAVE_EXIT
| #define RDM_QA_HAVE_EXIT |
#include <pspplatos.h>
The QA Framework may exit immediately using exit (may be defined on some OS)
RDM_QA_STACK_PROBE_NO
| #define RDM_QA_STACK_PROBE_NO |
#include <pspplatos.h>
The QA Framework should not probe the stack (may be defined on some OS)
RDM_QA_TIME_NO
| #define RDM_QA_TIME_NO |
#include <pspplatos.h>
The QA Framework should not as for time (may be defined on some OS)
RDM_RETURN_CODE_DEBUG [1/2]
| #define RDM_RETURN_CODE_DEBUG |
#include <pspplatos.h>
Additional debug information for RDM_RETURN_CODE
Internally we use a class RDM_RETURN_CODE instead of RDM_RETCODE with some additional information for debugging if enabled here. If NDEBUG is not defined then this will be enabled unless RDM_RETURN_CODE_NDEBUG is defined.
RDM_RETURN_CODE_DEBUG [2/2]
| #define RDM_RETURN_CODE_DEBUG |
#include <pspplatos.h>
Additional debug information for RDM_RETURN_CODE
Internally we use a class RDM_RETURN_CODE instead of RDM_RETCODE with some additional information for debugging if enabled here. If NDEBUG is not defined then this will be enabled unless RDM_RETURN_CODE_NDEBUG is defined.
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_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_NO_STRTOD
| #define RDM_STR_HAVE_NO_STRTOD |
#include <pspplatos.h>
Have no atof, strtod, strtod_l, or _strtod_l
- Note
- We have on implementation for converting a string to a double that we can use. If the conversion is attempted it will return eNOTIMPLEMENTED_STRTOD
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_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_STR_STRTOD_CALCULATE
| #define RDM_STR_STRTOD_CALCULATE |
#include <pspplatos.h>
Do string convertion to double by calculations
When other options are not available do string conversion to double using our own calculations. This method is not safe, meaning converting from double to a decimal string (with appropriate precision) and back again may not reproduce the same IEEE-754 double value. RDM_STR_STRTOD_CALCULATE_USING_LONG_DOUBLE is safe.
Please note that some of the other methods are local dependent and may therefor not be safe.
RDM_STR_STRTOD_CALCULATE_USING_LONG_DOUBLE
| #define RDM_STR_STRTOD_CALCULATE_USING_LONG_DOUBLE |
#include <pspplatos.h>
Do string convertion to double without use of pow or powl
When RDM_STR_STRTOD_CALCULATE is enabled do not adjust for the exponent using pow or powl. This avoids use of the math library. It may be less efficient than pow or powl especially for large or small exponents. Do string convertion to double by long double calculations
Same as RDM_STR_STRTOD_CALCULATE except that we here use long double instead of double for the calculation. This makes the conversion accurate, meaning converting from double to a decimal string (with appropriate precision) and back again reproduces the same IEEE-754 double value. The compiler need support for long double for this method to work.
Please note that some of the other methods are local dependent and may therefor not be safe.
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_TAG_NO_REPORT
| #define RDM_TAG_NO_REPORT |
#include <pspplatos.h>
Detailed report for memory usage where this is supported
RaimaDB have alternate implementations for allocating memory. A detailed report can be generated. Generating this report has some performance penalties.
RDM_TFS_CLIENT_NO_DIRECT_IO
| #define RDM_TFS_CLIENT_NO_DIRECT_IO |
#include <pspplatos.h>
TFS Client is not able to read and write directly to the database pack files
- Note
- Define this if a TFS client should not or can not read and write directly to the database pack files instead of having the TFS Server doing this on its behalf. This could be defined where data coherence between file handles are not guaranteed, persistent files are not implemented, the persistent database pack files would never be on the same machine as the client, or where the persistent database pack files are not otherwise accessible by the client.
RDM_TFS_SERVER_NO_CLIENT_THREADS
| #define RDM_TFS_SERVER_NO_CLIENT_THREADS |
#include <pspplatos.h>
TFS Server accept connections without client threads
The TFS normally accepts clients using a separate thread. This allows more than one connection. Defining this will not spawn extra threads and consequently only one client can be handled at a given time.
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) If a cycle counter is availabe the following can be defined in combination with this:
#define RDM_TIME_CYCLE_COUNT_ADR Address #define RDM_TIME_CYCLE_COUNT_HZ Hz
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_FIFO_FILES
| #define RDM_TRANSPORT_HAVE_FIFO_FILES |
#include <pspplatos.h>
A limited implementation that uses a pair of FIFO files on Linux (should not be defined except in some special limited cases)
RDM_TRANSPORT_HAVE_RPMSG
| #define RDM_TRANSPORT_HAVE_RPMSG |
#include <pspplatos.h>
A limited implementation that uses RPMSG under AUTOSAR to communicate with a Linux host (should not be defined except in some special limited cases)
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_SHM_POLL
| #define RDM_TRANSPORT_HAVE_SHM_POLL |
#include <pspplatos.h>
Shared memory between AUTOSAR (client) and Linux (TFS) (may be defined on some OS)
RDM_TRANSPORT_HAVE_SSL
| #define RDM_TRANSPORT_HAVE_SSL |
#include <pspplatos.h>
We have a TSL/SSL implementation (may be defined on some OS)
RDM_TRANSPORT_HAVE_TCP
| #define RDM_TRANSPORT_HAVE_TCP |
#include <pspplatos.h>
We have a TCP implementation (may be defined on some OS)
RDM_TRANSPORT_HAVE_TCP_SSL
| #define RDM_TRANSPORT_HAVE_TCP_SSL |
#include <pspplatos.h>
We have a SSL over TCP implementation (may be defined on some OS)
This is a complete replacement for TCP. The connection is always using SSL. There are no options to run this without use of the SSL layer. To enable this both RDM_TRANSPORT_HAVE_TCP and RDM_TRANSPORT_HAVE_TCP_SSL has to be defined.
RDM_TRANSPORT_SO_EXCLUSIVEADDRUSE
| #define RDM_TRANSPORT_SO_EXCLUSIVEADDRUSE |
#include <pspplatos.h>
Use socket option SO_EXCLUSIVEADDRUSE for binding a socket (may be defined on some OS)
RDM_TRANSPORT_SO_REUSERADDR
| #define RDM_TRANSPORT_SO_REUSERADDR |
#include <pspplatos.h>
Use socket option SO_REUSEADDR for binding a socket (may be defined on some OS)
RDM_TRANSPORT_SSL_DISCONNECT_BY_NOTIFYING_PEER
| #define RDM_TRANSPORT_SSL_DISCONNECT_BY_NOTIFYING_PEER |
#include <pspplatos.h>
Disconnect by always notifying the peer on the SSL protocol level
If neither this or RDM_TRANSPORT_SSL_DISCONNECT_MAY_NOTIFY_PEER are defined the peer will not be notified when we disconnect.
RDM_TRANSPORT_SSL_DISCONNECT_MAY_NOTIFY_PEER
| #define RDM_TRANSPORT_SSL_DISCONNECT_MAY_NOTIFY_PEER |
#include <pspplatos.h>
Disconnect may notify the peer on the SSL protocol level
This option only notifies the peer if there is no input data that is yet to be written into the internal BIO.
If neither this or RDM_TRANSPORT_SSL_DISCONNECT_BY_NOTIFYING_PEER are defined the peer will not be notified when we disconnect.
RDM_TRANSPORT_SSL_HAVE_ERR_GET_ERROR
| #define RDM_TRANSPORT_SSL_HAVE_ERR_GET_ERROR |
#include <pspplatos.h>
Have ERR_get_error
Have the Open SSL function ERR_get_error. Keep in mind that this function may not be supported everywhere since this function is not reentrant. It needs per thread or per task capabilities.
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_CLOSESOCKET
| #define RDM_TRANSPORT_TCP_CLOSESOCKET |
#include <pspplatos.h>
Use closesocket instead of close when closing a socket (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_FLUSH_NO_DELAY
| #define RDM_TRANSPORT_TCP_FLUSH_NO_DELAY |
#include <pspplatos.h>
Toggle socket option TCP_NODELAY to flush the TCP stream when we have a complete request from a client or a complete responce from the server (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_LINUX
| #define RDM_TRANSPORT_TCP_LINUX |
#include <pspplatos.h>
Linux specific implementation details for TCP
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_TRANSPORT_TCP_SHUTDOWN
| #define RDM_TRANSPORT_TCP_SHUTDOWN |
#include <pspplatos.h>
Do a shutdown before closing a socket (may be defined on some OS)
RDM_TRANSPORT_TCP_UNIX
| #define RDM_TRANSPORT_TCP_UNIX |
#include <pspplatos.h>
Unix specific implementation details for TCP
RDM_UNIX
| #define RDM_UNIX |
#include <pspplatos.h>
This is a Posix or Unix like system (may be defined on some OS)
RDM_VSNPRINTF_STB
| #define RDM_VSNPRINTF_STB |
#include <pspplatos.h>
A portable, fast, robust, and locale agnostic implementation of vsnprintf by Sean Barrett based on code from Jeff Roberts / RAD Game Tools and Fabian "ryg" Giesen.
This implementation is licensed by the original author under a dual license of MIT and Public Domain. We have made some trivial changes to this implementation and are hereby relicensing it to a Raima license.