PANTHEIOS_CALL(int) pantheios_be_logEntry(
void* feToken
, void* beToken
, int severity
, PAN_CHAR_T const* entry
, size_t cchEntry
)
{
STLSOFT_SUPPRESS_UNUSED(feToken);
STLSOFT_SUPPRESS_UNUSED(beToken);
STLSOFT_SUPPRESS_UNUSED(severity);
STLSOFT_SUPPRESS_UNUSED(entry);
if(0 == s_feInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("back-end entry logging", "front-end has not yet been initialised");
}
else if(1 != s_feInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("back-end entry logging", "front-end has been uninitialised");
}
else if(0 == s_beInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("back-end entry logging", "back-end has not been initialised");
}
else if(1 != s_beInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("back-end entry logging", "back-end has been uninitialised");
}
return (int)cchEntry;
}
static int main_(int argc, char **argv)
{
#ifndef PANTHEIOS_USE_WIDE_STRINGS
pantheios::log_DEBUG("main_(", pantheios::args(argc, argv), ")");
#endif
{
unsigned flags = PANTHEIOS_BE_FILE_F_DISCARD_CACHED_CONTENTS | PANTHEIOS_BE_FILE_F_TRUNCATE;
int res1 = pantheios_be_file_setFilePath(PSTR("test-%T-%D.log"), flags, flags, PANTHEIOS_BEID_LOCAL);
pantheios_be_file_flush(PANTHEIOS_BEID_LOCAL);
pantheios::log_NOTICE(PSTR("stmt 1"));
}
#ifndef PANTHEIOS_USE_WIDE_STRINGS
{
pantheios::log_NOTICE("stmt 1");
unsigned flags = PANTHEIOS_BE_FILE_F_DISCARD_CACHED_CONTENTS | PANTHEIOS_BE_FILE_F_TRUNCATE;
int res1 = pantheios_be_file_setFilePath(FILENAME_LOCAL, flags, flags, PANTHEIOS_BEID_LOCAL);
pantheios::log_NOTICE("stmt 2");
pantheios::log_NOTICE("stmt 3");
int res2 = pantheios_be_file_setFilePath(FILENAME_REMOTE, flags, flags, PANTHEIOS_BEID_REMOTE);
pantheios::log_NOTICE("stmt 4");
pantheios::log_NOTICE("stmt 5");
pantheios_be_file_setFilePath(NULL, PANTHEIOS_BEID_LOCAL);
pantheios_be_file_setFilePath(NULL, PANTHEIOS_BEID_REMOTE);
pantheios::log_NOTICE("stmt 6");
pantheios::log_NOTICE("stmt 7");
file_lines_t local_lines(FILENAME_LOCAL);
file_lines_t remote_lines(FILENAME_REMOTE);
const size_t numLocal = local_lines.size();
const size_t numRemote = remote_lines.size();
STLSOFT_ASSERT(4 == numLocal);
STLSOFT_ASSERT(2 == numRemote);
fs_traits_t::delete_file(FILENAME_LOCAL);
fs_traits_t::get_last_error();
fs_traits_t::delete_file(FILENAME_REMOTE);
fs_traits_t::get_last_error();
STLSOFT_SUPPRESS_UNUSED(res1);
STLSOFT_SUPPRESS_UNUSED(res2);
}
#endif
pantheios::log_DEBUG(PSTR("exiting main_()"));
return EXIT_SUCCESS;
}
inline bool truncation_test_helper_runtime_test(FROM from, no_type, TO ) // The use of the dummy variable is to fix a bug with VC++ 5-7.0
{
#ifdef _DEBUG
# if defined(STLSOFT_COMPILER_IS_MSVC)
int const flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
_CrtSetDbgFlag(flags & ~(_CRTDBG_ALLOC_MEM_DF));
# endif /* VC++ */
char const* TO_ = typeid(TO).name();
char const* FROM_ = typeid(FROM).name();
STLSOFT_SUPPRESS_UNUSED(TO_);
STLSOFT_SUPPRESS_UNUSED(FROM_);
# if defined(STLSOFT_COMPILER_IS_MSVC)
_CrtSetDbgFlag(flags);
# endif /* VC++ */
#endif /* _DEBUG */
// Types are different
// Next test for same sign
enum { TO_is_signed = is_signed_type<TO>::value };
enum { FROM_is_signed = is_signed_type<FROM>::value };
enum { types_have_same_sign = int(TO_is_signed) == int(FROM_is_signed) };
const ss_size_t sizeofFROM = sizeof(FROM);
const ss_size_t sizeofTO = sizeof(TO);
STLSOFT_STATIC_ASSERT(sizeofFROM >= sizeofTO || FROM_is_signed);
typedef ss_typename_param_k value_to_yesno_type<types_have_same_sign>::type same_sign_yesno_t;
return truncation_test_helper_runtime_test_same_sign<TO>(from, same_sign_yesno_t(), TO());
}
PANTHEIOS_CALL(int) pantheios_fe_isSeverityLogged( void* token
, int severity
, int backEndId)
{
STLSOFT_SUPPRESS_UNUSED(token);
STLSOFT_SUPPRESS_UNUSED(severity);
STLSOFT_SUPPRESS_UNUSED(backEndId);
if(0 == s_feInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("front-end severity test", "front-end has not yet been initialised");
}
else if(1 != s_feInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("front-end severity test", "front-end has been uninitialised");
}
else if(0 == s_beInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("front-end severity test", "back-end has not yet been initialised");
}
else if(1 != s_beInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("front-end severity test", "back-end has been uninitialised");
}
return 0;
}
bool truncation_test_v2(FROM from, TO dummy)
{
#ifdef _DEBUG
char const *TO_ = typeid(TO).name();
char const *FROM_ = typeid(FROM).name();
STLSOFT_SUPPRESS_UNUSED(TO_);
STLSOFT_SUPPRESS_UNUSED(FROM_);
#endif /* _DEBUG */
enum { fromIsSigned = stlsoft::is_signed_type<FROM>::value };
enum { toIsSigned = stlsoft::is_signed_type<TO>::value };
enum
{
is_statically_determined =
( int(fromIsSigned) == int(toIsSigned) &&
sizeof(FROM) <= sizeof(TO)) ||
( !fromIsSigned &&
toIsSigned &&
sizeof(FROM) < sizeof(TO))
};
typedef ss_typename_type_k value_to_yesno_type<is_statically_determined>::type yesno_t;
return truncation_test_v2_is_statically_determined(from, dummy, yesno_t());
}
static int pantheios_be_WindowsMessageBox_init_(
pan_char_t const* processIdentity
, int id
, void const* unused
, void* reserved
, void** ptoken
)
{
STLSOFT_SUPPRESS_UNUSED(unused);
STLSOFT_SUPPRESS_UNUSED(reserved);
// (iii) create the context
WindowsMessageBox_Context* ctxt = new(processIdentity) WindowsMessageBox_Context(id);
#ifndef STLSOFT_CF_THROW_BAD_ALLOC
if(NULL == ctxt)
{
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
#endif /* !STLSOFT_CF_THROW_BAD_ALLOC */
*ptoken = ctxt;
return 0;
}
int main(int argc, char **argv)
{
// Use of be.file involves several steps:
//
// 1. Linking to the back-end, either explicitly or implicitly
// 2. Setting the log file path for the given back-end(s)
// 3. Making log statements
// 4. Changing the log file path for the given back-end(s)
// 5. Closing the log file for the given back-end(s)
// In this case, linking is performed either by the build makefile or the
// IDE project file, to the be.file back-end.
//
// In this case, the log file path via the application-defined callback
// function pantheios_be_file_getAppInit(), which is called during program
// initialisation, prior to main() being called. At the same time, the
// flags PANTHEIOS_BE_FILE_F_TRUNCATE and
// PANTHEIOS_BE_FILE_F_DELETE_IF_EMPTY are specified
//
// In this case, the file is closed automatically during program
// uninitialisation.
try
{
#ifndef PANTHEIOS_USE_WIDE_STRINGS
pantheios::log_DEBUG("main(", pantheios::args(argc, argv), ")");
#else /* ? !PANTHEIOS_USE_WIDE_STRINGS */
STLSOFT_SUPPRESS_UNUSED(argc); STLSOFT_SUPPRESS_UNUSED(argv);
#endif /* !PANTHEIOS_USE_WIDE_STRINGS */
pantheios::log_NOTICE(PSTR("stmt 1"));
pantheios::log_NOTICE(PSTR("stmt 2"));
pantheios::log_NOTICE(PSTR("stmt 3"));
pantheios::log_NOTICE(PSTR("stmt 4"));
pantheios::log_DEBUG(PSTR("exiting main()"));
return EXIT_SUCCESS;
}
catch(std::bad_alloc&)
{
pantheios::log(pantheios::alert, PSTR("out of memory"));
}
catch(std::exception& x)
{
pantheios::log_CRITICAL(PSTR("Exception: "), x);
}
catch(...)
{
pantheios::logputs(pantheios::emergency, PSTR("Unexpected unknown error"));
}
return EXIT_FAILURE;
}
inline bool truncation_test_helper_runtime_test_same_sign(FROM from, no_type, TO)
{
#ifdef _DEBUG
# if defined(STLSOFT_COMPILER_IS_MSVC)
int const flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
_CrtSetDbgFlag(flags & ~(_CRTDBG_ALLOC_MEM_DF));
# endif /* VC++ */
char const* TO_ = typeid(TO).name();
char const* FROM_ = typeid(FROM).name();
STLSOFT_SUPPRESS_UNUSED(TO_);
STLSOFT_SUPPRESS_UNUSED(FROM_);
# if defined(STLSOFT_COMPILER_IS_MSVC)
_CrtSetDbgFlag(flags);
# endif /* VC++ */
#endif /* _DEBUG */
enum { TO_is_signed = is_signed_type<TO>::value };
enum { FROM_is_signed = is_signed_type<FROM>::value };
const ss_size_t sizeofFROM = sizeof(FROM);
const ss_size_t sizeofTO = sizeof(TO);
STLSOFT_SUPPRESS_UNUSED(sizeofFROM);
STLSOFT_SUPPRESS_UNUSED(sizeofTO);
STLSOFT_STATIC_ASSERT((0 == int(TO_is_signed)) != (0 == int(FROM_is_signed)));
typedef ss_typename_param_k value_to_yesno_type<FROM_is_signed>::type same_sign_yesno_t;
return truncation_test_helper_runtime_test_different_sign_FROM_is_signed<TO>(from, same_sign_yesno_t(), TO());
}
PANTHEIOS_CALL(int) pantheios_be_init(
PAN_CHAR_T const* processIdentity
, void* reserved
, void** ptoken
)
{
STLSOFT_SUPPRESS_UNUSED(processIdentity);
STLSOFT_SUPPRESS_UNUSED(reserved);
STLSOFT_SUPPRESS_UNUSED(ptoken);
if(0 == s_feInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("back-end initialisation", "front-end has not yet been initialised");
}
else if(1 != s_feInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("back-end initialisation", "front-end has been uninitialised");
}
else if(0 != s_beInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("back-end initialisation", "back-end has already been initialised");
}
else
{
++s_beInitValue;
return 0;
}
return PANTHEIOS_BE_INIT_RC_INTENDED_FAILURE;
}
static int main_(int argc, char **argv)
{
STLSOFT_SUPPRESS_UNUSED(argc);
STLSOFT_SUPPRESS_UNUSED(argv);
some_logging_1();
some_logging_2();
some_logging_3();
return 0;
}
PANTHEIOS_CALL(int) pantheios_fe_init(
void* reserved
, void** ptoken
)
{
STLSOFT_SUPPRESS_UNUSED(reserved);
STLSOFT_SUPPRESS_UNUSED(ptoken);
++s_numInits;
return 0;
}
PANTHEIOS_CALL(int) pantheios_fe_isSeverityLogged(
void* token
, int severity
, int backEndId
)
{
STLSOFT_SUPPRESS_UNUSED(token);
STLSOFT_SUPPRESS_UNUSED(severity);
STLSOFT_SUPPRESS_UNUSED(backEndId);
++s_numISL;
return 0;
}
static int main_(int argc, char** argv)
{
// This goes only to debugger
#ifndef PANTHEIOS_USE_WIDE_STRINGS
pantheios::log_NOTICE(PSTR("main("), pantheios::args(argc, argv), PSTR(")"));
#else /* ? !PANTHEIOS_USE_WIDE_STRINGS */
STLSOFT_SUPPRESS_UNUSED(argc); STLSOFT_SUPPRESS_UNUSED(argv);
#endif /* !PANTHEIOS_USE_WIDE_STRINGS */
// This goes to console and debugger
pantheios::log(pantheios::notice(beid_Syslog), PSTR("Isn't targeted multiplexing great?!"));
return EXIT_SUCCESS;
}
PANTHEIOS_CALL(int) pantheios_be_null_logEntry(
void* feToken
, void* beToken
, int severity
, pan_char_t const* entry
, size_t cchEntry
)
{
STLSOFT_SUPPRESS_UNUSED(feToken);
STLSOFT_SUPPRESS_UNUSED(beToken);
STLSOFT_SUPPRESS_UNUSED(severity);
STLSOFT_SUPPRESS_UNUSED(entry);
return (int)cchEntry;
}
void MatchEnd::setNext(Match *next)
{
SHWILD_ASSERT(NULL == next);
SHWILD_MESSAGE_ASSERT("WildEnd must always be the end", 0);
STLSOFT_SUPPRESS_UNUSED(next);
}
PANTHEIOS_CALL(void) pantheios_fe_uninit(
void* token
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL == token, "token must be null");
STLSOFT_SUPPRESS_UNUSED(token);
}
PANTHEIOS_CALL(int) pantheios_fe_isSeverityLogged(
void* token
, int severity
, int backEndId
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL == token, "token must be null");
/* PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_STATE_API(!pantheios_isInitialising(), "This cannot be called when Pantheios is initialising"); */
/* PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_STATE_API(pantheios_isInitialised(), "This can only be called when Pantheios is initialised"); */
STLSOFT_SUPPRESS_UNUSED(token);
STLSOFT_SUPPRESS_UNUSED(severity);
STLSOFT_SUPPRESS_UNUSED(backEndId);
return (severity & 0x0f) <= pantheios_fe_severity_ceiling_;
}
/// Unfortunately, something in this technique scares the Borland compilers (5.5
/// and 5.51) into Internal compiler errors so the s_init variable in
/// get_systeminfo_() is int rather than bool when compiling for borland.
static SYSTEM_INFO const& get_systeminfo_()
{
#if defined(STLSOFT_COMPILER_IS_MSVC) && \
_MSC_VER >= 1310
// Safe to suppress these warnings, because race-conditions are benign here
# pragma warning(push)
# pragma warning(disable : 4640)
#endif /* compiler */
static SYSTEM_INFO s_systeminfo;
#ifdef STLSOFT_COMPILER_IS_BORLAND
/* WSCB: Borland has an internal compiler error if use ws_bool_t */
static ws_int_t s_init = (::GetSystemInfo(&s_systeminfo), ws_true_v);
#else /* ? compiler */
static ws_bool_t s_init = (::GetSystemInfo(&s_systeminfo), ws_true_v);
#endif /* compiler */
STLSOFT_SUPPRESS_UNUSED(s_init);
return s_systeminfo;
#if defined(STLSOFT_COMPILER_IS_MSVC) && \
_MSC_VER >= 1310
# pragma warning(pop)
#endif /* compiler */
}
PANTHEIOS_CALL(void) pantheios_fe_uninit(void* token)
{
STLSOFT_SUPPRESS_UNUSED(token);
if(0 == s_feInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("front-end uninitialisation failed", "front-end has not yet been initialised");
}
else if(0 == s_beInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("front-end uninitialisation failed", "back-end has not yet been initialised");
}
else if(1 == s_beInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("front-end uninitialisation failed", "back-end has not yet been uninitialised");
}
else if(2 != s_beInitValue)
{
XTESTS_FAIL_WITH_QUALIFIER("front-end uninitialisation failed", "back-end initialisation count suggests multiple initialisations");
}
else
{
++s_feInitValue;
}
}
inline /* static */ OSVERSIONINFO &system_version::get_versioninfo_()
{
/// Unfortunately, something in this technique scares the Borland compilers (5.5
/// and 5.51) into Internal compiler errors so the s_init variable in
/// get_versioninfo_() is int rather than bool when compiling for borland.
#if !defined(STLSOFT_STRICT) && \
defined(STLSOFT_COMPILER_IS_MSVC) && \
_MSC_VER >= 1310
# pragma warning(push)
# pragma warning(disable : 4640) /* "construction of local static object is not thread-safe" - since it is here! (As long as one uses a 'conformant' allocator) - maybe use a spin_mutex in future */
#endif /* compiler */
static OSVERSIONINFO s_versioninfo;
#if defined(STLSOFT_COMPILER_IS_BORLAND)
/* WSCB: Borland has an internal compiler error if use ws_bool_t */
static ws_int_t s_init = (s_versioninfo.dwOSVersionInfoSize = sizeof(s_versioninfo), ::GetVersionEx(&s_versioninfo), ws_true_v);
#else /* ? compiler */
static ws_bool_t s_init = (s_versioninfo.dwOSVersionInfoSize = sizeof(s_versioninfo), ::GetVersionEx(&s_versioninfo), ws_true_v);
#endif /* compiler */
#if !defined(STLSOFT_STRICT) && \
defined(STLSOFT_COMPILER_IS_MSVC) && \
_MSC_VER >= 1310
# pragma warning(pop)
#endif /* compiler */
STLSOFT_SUPPRESS_UNUSED(s_init); // Placate GCC
return s_versioninfo;
}
int main(int argc, char **argv)
{
try
{
#ifndef PANTHEIOS_USE_WIDE_STRINGS
pantheios::log_DEBUG("main(", pantheios::args(argc, argv), ")");
#else /* ? !PANTHEIOS_USE_WIDE_STRINGS */
STLSOFT_SUPPRESS_UNUSED(argc); STLSOFT_SUPPRESS_UNUSED(argv);
#endif /* !PANTHEIOS_USE_WIDE_STRINGS */
pantheios::log_NOTICE(PSTR("stmt 1"));
// Set the file name for the local back-end, truncating the
// file's existing contents, if any.
pantheios_be_file_setFilePath(PSTR("log.local"), PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BE_FILE_F_TRUNCATE, PANTHEIOS_BEID_LOCAL);
pantheios::log_NOTICE(PSTR("stmt 2"));
// Set the file name for the remote back-end.
pantheios_be_file_setFilePath(PSTR("log.remote"), PANTHEIOS_BEID_REMOTE);
pantheios::log_NOTICE(PSTR("stmt 3"));
// Set the file name for all back-ends.
pantheios_be_file_setFilePath(PSTR("log.all"));
pantheios::log_NOTICE(PSTR("stmt 4"));
pantheios::log_DEBUG(PSTR("exiting main()"));
return EXIT_SUCCESS;
}
catch(std::bad_alloc&)
{
pantheios::log(pantheios::alert, PSTR("out of memory"));
}
catch(std::exception& x)
{
pantheios::log_CRITICAL(PSTR("Exception: "), pantheios::exception(x));
}
catch(...)
{
pantheios::logputs(pantheios::emergency, PSTR("Unexpected unknown error"));
}
return EXIT_FAILURE;
}
inline bool truncation_test_helper_runtime_test_different_sign_FROM_is_signed(FROM from, no_type, TO)
{
#ifdef _DEBUG
# if defined(STLSOFT_COMPILER_IS_MSVC)
int const flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
_CrtSetDbgFlag(flags & ~(_CRTDBG_ALLOC_MEM_DF));
# endif /* VC++ */
char const* TO_ = typeid(TO).name();
char const* FROM_ = typeid(FROM).name();
STLSOFT_SUPPRESS_UNUSED(TO_);
STLSOFT_SUPPRESS_UNUSED(FROM_);
# if defined(STLSOFT_COMPILER_IS_MSVC)
_CrtSetDbgFlag(flags);
# endif /* VC++ */
#endif /* _DEBUG */
enum { TO_is_signed = is_signed_type<TO>::value };
enum { FROM_is_signed = is_signed_type<FROM>::value };
const ss_size_t sizeofFROM = sizeof(FROM);
const ss_size_t sizeofTO = sizeof(TO);
STLSOFT_SUPPRESS_UNUSED(sizeofFROM);
STLSOFT_SUPPRESS_UNUSED(sizeofTO);
STLSOFT_STATIC_ASSERT((0 == int(TO_is_signed)) != (0 == int(FROM_is_signed)));
STLSOFT_STATIC_ASSERT(0 == int(FROM_is_signed));
STLSOFT_STATIC_ASSERT(0 != int(TO_is_signed));
// FROM is unsigned
// TO is signed
//
// Truncation occurs if from > toMax
FROM toMax = static_cast<FROM>(limit_traits<TO>::maximum());
if(from > toMax)
{
return false;
}
else
{
return true;
}
}
static int teardown(void* param)
{
STLSOFT_SUPPRESS_UNUSED(param);
cstring_destroy(&string);
return 0; /* Currently ignored by xTests */
}
static int pantheios_be_WindowsDebugger_init_(
pan_char_t const* processIdentity
, int backEndId
, pan_be_WindowsDebugger_init_t const* init
, void* reserved
, void** ptoken
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != processIdentity, "process identity may not be the null string");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API('\0' != 0[processIdentity], "process identity may not be the empty string");
STLSOFT_SUPPRESS_UNUSED(reserved);
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != ptoken, "token pointer may not be null");
/* (i) apply Null Object (Variable) pattern */
pan_be_WindowsDebugger_init_t init_;
if(NULL == init)
{
pantheios_be_WindowsDebugger_getDefaultAppInit(&init_);
init = &init_;
#ifdef PANTHEIOS_BE_USE_CALLBACK
pantheios_be_WindowsDebugger_getAppInit(backEndId, &init_);
#endif /* PANTHEIOS_BE_USE_CALLBACK */
}
/* (ii) verify the version */
if(init->version < 0x010001b8)
{
return PANTHEIOS_BE_INIT_RC_OLD_VERSION_NOT_SUPPORTED;
}
else if(init->version > PANTHEIOS_VER)
{
return PANTHEIOS_BE_INIT_RC_FUTURE_VERSION_REQUESTED;
}
/* (iii) create the context */
WindowsDebugger_Context* ctxt = new WindowsDebugger_Context(processIdentity, backEndId, init);
#ifndef STLSOFT_CF_THROW_BAD_ALLOC
if( NULL == ctxt ||
NULL == ctxt->getProcessIdentity())
{
delete ctxt;
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
#endif /* !STLSOFT_CF_THROW_BAD_ALLOC */
*ptoken = ctxt;
return 0;
}
bool truncation_test(FROM from, TO dummy = TO())
{
#ifdef _DEBUG
char const *TO_ = typeid(TO).name();
char const *FROM_ = typeid(FROM).name();
STLSOFT_SUPPRESS_UNUSED(TO_);
STLSOFT_SUPPRESS_UNUSED(FROM_);
#endif /* _DEBUG */
#if 0
return truncation_test_v1<TO, FROM>(from, dummy);
#elif 0
return truncation_test_v2<TO, FROM>(from, dummy);
#elif 1
return truncation_test_v3<TO, FROM>(from, dummy);
#endif /* 0 */
}
PANTHEIOS_CALL(int) pantheios_be_null_init(
pan_char_t const* processIdentity
, int id
, void* unused
, void* reserved
, void** ptoken
)
{
STLSOFT_SUPPRESS_UNUSED(processIdentity);
STLSOFT_SUPPRESS_UNUSED(id);
STLSOFT_SUPPRESS_UNUSED(unused);
STLSOFT_SUPPRESS_UNUSED(reserved);
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != ptoken, "token pointer may not be null");
*ptoken = NULL;
return 0;
}
inline bool truncation_test_helper_runtime_test_same_sign(FROM from, yes_type, TO) // The use of the dummy variable is to fix a bug with VC++ 5-7.0
{
#ifdef STLSOFT_DEBUG
# if defined(STLSOFT_COMPILER_IS_MSVC)
int const flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
_CrtSetDbgFlag(flags & ~(_CRTDBG_ALLOC_MEM_DF));
# endif /* VC++ */
char const* TO_ = typeid(TO).name();
char const* FROM_ = typeid(FROM).name();
STLSOFT_SUPPRESS_UNUSED(TO_);
STLSOFT_SUPPRESS_UNUSED(FROM_);
# if defined(STLSOFT_COMPILER_IS_MSVC)
_CrtSetDbgFlag(flags);
# endif /* VC++ */
#endif /* STLSOFT_DEBUG */
const ss_size_t sizeofFROM = sizeof(FROM);
const ss_size_t sizeofTO = sizeof(TO);
STLSOFT_STATIC_ASSERT(sizeofTO < sizeofFROM);
STLSOFT_SUPPRESS_UNUSED(sizeofTO);
STLSOFT_SUPPRESS_UNUSED(sizeofFROM);
// This is a fully runtime test: does FROM fit into TO's limits?
//
// To do this we elicit TO's min and max. The values are held in
// FROM, which involves no truncation because sizeof(FROM) > sizeof(TO)
FROM toMax = static_cast<FROM>(limit_traits<TO>::maximum());
FROM toMin = static_cast<FROM>(limit_traits<TO>::minimum());
if( from < toMin ||
from > toMax)
{
return false;
}
else
{
return true;
}
}
static int pantheios_be_WindowsEventLog_init_(
pan_char_t const* processIdentity
, int id
, void const* unused
, void* reserved
, void** ptoken
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != processIdentity, "process identity may not be NULL");
STLSOFT_SUPPRESS_UNUSED(unused);
STLSOFT_SUPPRESS_UNUSED(reserved);
// (iii) create the context
WindowsEventLog_Context* ctxt = new WindowsEventLog_Context(id);
#ifndef STLSOFT_CF_THROW_BAD_ALLOC
if(NULL == ctxt)
{
delete ctxt;
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
else
#endif /* !STLSOFT_CF_THROW_BAD_ALLOC */
{
int res = ctxt->Register(processIdentity);
if(0 != res)
{
delete ctxt;
return res;
}
}
*ptoken = ctxt;
return 0;
}
/** Writes a number of slices into a character array that must have
* sufficient space.
*
* \param cchBuff The number of characters in the array pointed to by the
* <code>buff</code> parameter
* \param buff A pointer to an array that has sufficient space to hold all
* the elements
* \param numResults The number of entries in the array pointed to by the
* <code>results</code> parameter
* \param results Pointer to an array of \link fastformat::ff_string_slice_t string_slice_t\endlink elements to be
* written into <code>buff</code>.
*/
inline size_t concat_slices(size_t cchBuff, ff_char_t* buff, size_t numResults, ff_string_slice_t const* results)
{
STLSOFT_SUPPRESS_UNUSED(cchBuff);
ff_char_t* p = &buff[0];
size_t total = 0;
{ for(size_t i = 0; i != numResults; ++i, ++results)
{
FASTFORMAT_CONTRACT_ENFORCE_PRECONDITION_STATE_INTERNAL(total + results->len <= cchBuff, "insufficient space in buffer to write the results");
STLSOFT_SUPPRESS_UNUSED(total);
::memcpy(p, results->ptr, results->len * sizeof(ff_char_t));
p += results->len;
total += results->len;
}}
return total;
}
ff_illformed_handler_info_t ximpl_core::fastformat_impl_handlers_getIllformedDefaultHandler(void* token)
{
FASTFORMAT_COVER_MARK_ENTRY();
FASTFORMAT_CONTRACT_ENFORCE_PRECONDITION_PARAMS_INTERNAL(NULL != token, "token must not be null");
STLSOFT_SUPPRESS_UNUSED(token);
ff_illformed_handler_info_t r;
r.param = NULL;
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
r.handler = fastformat_stock_illformedHandler_throw;
STLSOFT_SUPPRESS_UNUSED(fastformat_stock_illformedHandler_ignore);
#else /* ? STLSOFT_CF_EXCEPTION_SUPPORT */
r.handler = fastformat_stock_illformedHandler_ignore;
STLSOFT_SUPPRESS_UNUSED(fastformat_stock_illformedHandler_throw);
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
return r;
}
