int WindowsDebugger_Context::rawLogEntry(int /* severity4 */, int /* severityX */, const pan_slice_t (&ar)[rawLogArrayDimension], size_t cchTotal)
{
// Allocate the buffer
buffer_t buff(cchTotal + 1 + 1);
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
// When exception support is not enabled, failure to allocate will yield an empty instance
if(buff.empty())
{
return 0;
}
else
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
{
size_t nWritten = concatenateSlices(&buff[0], buff.size(), rawLogArrayDimension, &ar[0]);
PANTHEIOS_CONTRACT_ENFORCE_POSTCONDITION_RETURN_INTERNAL(nWritten == cchTotal, "Written length differs from allocated length");
buff[nWritten++] = '\n';
buff[nWritten] = '\0';
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(nWritten + 1 == buff.size());
// Output
pan_OutputDebugString_(&buff[0]);
return static_cast<int>(nWritten);
}
}
int be_speech_context::rawLogEntry(int severity4, int /* severityX */, const pan_slice_t (&ar)[rawLogArrayDimension], size_t cchTotal)
{
// Define auto_buffer to use Windows process heap
// Allocate the buffer
buffer_t buff(cchTotal + 1 + 1);
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
// When exception support is not enabled, failure to allocate will yield an empty instance
if(buff.empty())
{
return 0;
}
else
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
{
size_t nWritten = concatenateSlices(&buff[0], buff.size(), rawLogArrayDimension, &ar[0]);
PANTHEIOS_CONTRACT_ENFORCE_POSTCONDITION_RETURN_INTERNAL(nWritten == cchTotal, "Written length differs from allocated length");
buff[nWritten++] = '\n';
buff[nWritten] = '\0';
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(nWritten + 1 == buff.size());
// Output
return this->speak(severity4, buff.data(), nWritten);
}
}
void pointer::construct_()
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(0 == m_sz[0], "cannot construct if value is non-empty");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(0 == m_len, "cannot construct if length is non-0");
if(static_cast<void const*>(0) == m_value)
{
static const pan_char_t s_null[] = PANTHEIOS_LITERAL_STRING("(null)");
STLSOFT_STATIC_ASSERT(sizeof(m_sz) >= sizeof(s_null));
::memcpy(&m_sz[0], &s_null[0], sizeof(s_null));
m_len = STLSOFT_NUM_ELEMENTS(s_null) - 1;
}
else
{
pan_char_t szFmt[101];
int width;
pan_char_t const* zeroX;
pan_char_t const* leadingMinus;
pan_char_t const* zeroPad;
if(m_minWidth < 0)
{
width = -m_minWidth;
leadingMinus = PANTHEIOS_LITERAL_STRING("-");
}
else
{
width = m_minWidth;
leadingMinus = PANTHEIOS_LITERAL_STRING("");
}
zeroX = (m_format & fmt::zeroXPrefix) ? PANTHEIOS_LITERAL_STRING("0x") : PANTHEIOS_LITERAL_STRING("");
zeroPad = (m_format & fmt::zeroPad) ? PANTHEIOS_LITERAL_STRING("0") : PANTHEIOS_LITERAL_STRING("");
if( 0 != width &&
fmt::zeroXPrefix == (m_format & (fmt::zeroXPrefix | fmt::zeroPad)))
{
// Special case
pan_char_t szTemp[23]; // 23 is always big enough, since the width is 21
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(0 == (m_format & fmt::zeroPad));
// Determine ptr-sized integer type
#if defined(STLSOFT_COMPILER_IS_GCC)
typedef unsigned long intptr_t_;
#else /* ? compiler */
typedef stlsoft::int_size_traits<sizeof(void*)>::unsigned_type intptr_t_;
#endif /* compiler */
int r = pantheios_util_snprintf(
&szTemp[0]
, STLSOFT_NUM_ELEMENTS(szTemp)
, PANTHEIOS_LITERAL_STRING("0x%lx")
, static_cast<intptr_t_>(stlsoft::union_cast<intptr_t_>(m_value))
);
if(r < 0)
{
return;
}
else
{
size_t n = static_cast<size_t>(r);
PANTHEIOS_CONTRACT_ENFORCE_POSTCONDITION_RETURN_INTERNAL((n + 2) <= STLSOFT_NUM_ELEMENTS(szTemp), "snprintf() overwrote the local buffer capacity");
width += 2;
if(static_cast<size_t>(width) > n)
{
if(m_minWidth < 0)
{
PANTHEIOS_char_copy(&m_sz[0], szTemp, n);
std::fill_n(&m_sz[0] + n, size_t(width - n), ' ');
m_sz[width] = '\0';
}
else
{
std::fill_n(&m_sz[0], size_t(width - n), ' ');
PANTHEIOS_char_copy(&m_sz[0] + (size_t(width) - n), szTemp, (n + 1));
}
m_len = static_cast<size_t>(width);
}
else
{
PANTHEIOS_char_copy(&m_sz[0], szTemp, (n + 1));
m_len = n;
}
}
}
else
{
pantheios_util_snprintf(&szFmt[0]
, STLSOFT_NUM_ELEMENTS(szFmt)
, PANTHEIOS_LITERAL_STRING("%s%%%s%s%dx")
, zeroX
, leadingMinus
, zeroPad
, width);
m_len = static_cast<size_t>(pantheios_util_snprintf(&m_sz[0], STLSOFT_NUM_ELEMENTS(m_sz), szFmt, m_value));
}
}
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(0 != m_sz[0], "failed to set value to non-empty");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(m_len > 0, "failed to set length");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(m_len < 23, "pantheios::pointer string too long");
}
static size_t pantheios_getHostName_body_(pan_char_t* buffer, size_t cchBuffer)
{
#if defined(PLATFORMSTL_OS_IS_UNIX)
if(0 == cchBuffer)
{
errno = ENAMETOOLONG;
return 0;
}
else
{
int res;
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(NULL != buffer);
/* First, we mark the last available character in the buffer with
* the nul terminator, to test later
*/
buffer[cchBuffer - 1] = '\0';
errno = 0;
res = gethostname(&buffer[0], cchBuffer);
/* Test for ENAMETOOLONG, to avoid any implementation-dependent
* behaviour wrt whether this it is set on a 0 or a -1 return
*/
if(ENAMETOOLONG == errno)
{
/* To homogenise platform behaviour, we ensure that no fragment is filled out */
buffer[0] = '\0';
return cchBuffer;
}
else
{
if(0 != res)
{
/* Was a failure, so return 0 */
return 0;
}
else if('\0' != buffer[cchBuffer - 1])
{
/* Was insufficient buffer, so we return the given size (which is the
* failure indicator for that condition
*
* Also, to homogenise platform behaviour, we ensure that no fragment
* of the buffer is returned as filled out.
*/
buffer[0] = '\0';
return cchBuffer;
}
else
{
/* Buffer was sufficient, and the value has been written. The only
* way to return the length is to do strlen on it
*/
return pan_strlen_(buffer);
}
}
}
#elif defined(PLATFORMSTL_OS_IS_WINDOWS)
DWORD cchSize = stlsoft_static_cast(DWORD, cchBuffer);
if(!pan_GetComputerName_(&buffer[0], &cchSize))
{
DWORD err = GetLastError();
if(ERROR_BUFFER_OVERFLOW == err)
{
return cchBuffer;
}
else
{
return 0;
}
}
else
{
return cchSize;
}
#else /* ? PLATFORMSTL_OS_IS_???? */
# error Platform not discriminated
#endif /* PLATFORMSTL_OS_IS_???? */
}
static int pantheios_be_WindowsSyslog_logEntry_a_(
void* feToken
, void* beToken
, int severity
, char const* entry
, size_t cchEntry
)
{
STLSOFT_SUPPRESS_UNUSED(feToken);
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != beToken, "back-end token must be non-null");
static const char tm_fmt[] = "%b %d %I:%M:%S";
# ifdef PANTHEIOS_USING_SAFE_STR_FUNCTIONS
static errno_t (*fns[2])(struct tm*, const time_t*) = { ::localtime_s, ::gmtime_s };
# else /* ? PANTHEIOS_USING_SAFE_STR_FUNCTIONS */
static struct tm* (*fns[2])(const time_t*) = { ::localtime, ::gmtime };
# endif /* PANTHEIOS_USING_SAFE_STR_FUNCTIONS */
WindowsSysLog_Context* ctxt = static_cast<WindowsSysLog_Context*>(beToken);
char szPri_[6];
char* szPri;
char szTime[31];
const int priority = (ctxt->facility * 8) + (severity % 8); /* This stock back-end ignores any custom severity information. */
time_t t = time(NULL);
# ifdef PANTHEIOS_USING_SAFE_STR_FUNCTIONS
struct tm tm_;
struct tm* tm = &tm_;
errno_t err = fns[0 != (ctxt->flags & PANTHEIOS_BE_WINDOWSSYSLOG_F_USE_SYSTEM_TIME)](tm, &t);
if(0 != err)
{
char msg[1001];
if(0 != ::strerror_s(&msg[0], STLSOFT_NUM_ELEMENTS(msg), err))
{
msg[0] = '\0';
}
pantheios_onBailOut3(pantheios::critical, "failed to elicit time", msg);
return 0;
}
# else /* ? PANTHEIOS_USING_SAFE_STR_FUNCTIONS */
struct tm* tm = fns[0 != (ctxt->flags & PANTHEIOS_BE_WINDOWSSYSLOG_F_USE_SYSTEM_TIME)](&t);
# endif /* PANTHEIOS_USING_SAFE_STR_FUNCTIONS */
size_t cchPriority;
size_t cchTime;
size_t cchTotal;
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(priority < 1000);
szPri = pri_print_(&szPri_[0], STLSOFT_NUM_ELEMENTS(szPri_), priority, cchPriority);
cchTime = ::strftime(&szTime[0], STLSOFT_NUM_ELEMENTS(szTime), tm_fmt, tm);
cchTotal = cchPriority + cchTime + 1 + ctxt->cchHostIdentity + 1 + ctxt->cchProcessIdentity + 1 + cchEntry;
buffer_a_t buffer(1 + cchTotal);
#ifndef STLSOFT_CF_THROW_BAD_ALLOC
if(0 == buffer.size())
{
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
else
#endif /* !STLSOFT_CF_THROW_BAD_ALLOC */
{
// === "%s%s %s %s %s", szPri, szTime, ctxt->hostIdentity, ctxt->processIdentity, entry
size_t cchWritten = 0;
char* p = &buffer[0];
::memcpy(p, szPri, cchPriority * sizeof(char));
cchWritten += cchPriority;
p += cchPriority;
::memcpy(p, szTime, cchTime * sizeof(char));
cchWritten += cchTime;
p += cchTime;
*p++ = ' ';
++cchWritten;
::memcpy(p, ctxt->hostIdentity, ctxt->cchHostIdentity * sizeof(char));
cchWritten += ctxt->cchHostIdentity;
p += ctxt->cchHostIdentity;
*p++ = ' ';
++cchWritten;
::memcpy(p, ctxt->processIdentity, ctxt->cchProcessIdentity * sizeof(char));
cchWritten += ctxt->cchProcessIdentity;
p += ctxt->cchProcessIdentity;
*p++ = ' ';
++cchWritten;
::memcpy(p, entry, cchEntry * sizeof(char));
cchWritten += cchEntry;
p += cchEntry;
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(cchWritten == size_t(p - buffer.data()));
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(cchWritten == cchTotal);
STLSOFT_SUPPRESS_UNUSED(p);
return ::send(ctxt->sk, buffer.data(), (int)cchWritten, 0);
}
}