void Logger::LogEscapeMore(LogLevelType level, const char *fmt, va_list ap) {
if (!IsEnabled()) return;
std::string msg;
string_vsnprintf(msg, fmt, ap);
Log(level, msg, nullptr, true, true);
}
void raise_message(ErrorConstants::ErrorModes mode,
const char *fmt,
va_list ap) {
std::string msg;
string_vsnprintf(msg, fmt, ap);
raise_message(mode, msg);
}
void omxRaiseErrorf(const char* msg, ...)
{
std::string str;
va_list ap;
va_start(ap, msg);
string_vsnprintf(msg, ap, str);
va_end(ap);
_omxRaiseError();
if(OMX_DEBUG) {
mxLog("Error raised: %s", str.c_str());
}
bool overflow = false;
#pragma omp critical(bads)
{
if (Global->bads.size() > 100) {
overflow = true;
} else {
Global->bads.push_back(str);
}
}
// mxLog takes a lock too, so call it outside of critical section
if (overflow) mxLog("Too many errors: %s", str.c_str());
}
void raise_warning_unsampled(const char *fmt, ...) {
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_warning_unsampled(msg);
}
void raise_debugging(const char *fmt, ...) {
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_debugging(msg);
}
void raise_notice(const char *fmt, ...) {
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_message(ErrorConstants::ErrorModes::NOTICE, msg);
}
void raise_deprecated(const char *fmt, ...) {
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_message(ErrorConstants::ErrorModes::PHP_DEPRECATED, msg);
}
void raise_recoverable_error(const char *fmt, ...) {
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_recoverable_error(msg);
}
void raise_deprecated(const char *fmt, ...) {
if (!notice_freq_check(ErrorMode::PHP_DEPRECATED)) return;
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_notice_helper(ErrorMode::PHP_DEPRECATED, false, msg);
}
void raise_notice(const char *fmt, ...) {
if (!notice_freq_check(ErrorMode::NOTICE)) return;
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_notice_helper(ErrorMode::NOTICE, false, msg);
}
void raise_warning(const char *fmt, ...) {
if (!warning_freq_check()) return;
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_warning_helper(false, msg);
}
std::string string_snprintf(const char *fmt, ...)
{
std::string str;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(fmt, ap, str);
va_end(ap);
return str;
}
void raise_hack_strict(HackStrictOption option, const char *ini_setting,
const char *fmt, ...) {
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_hack_strict(option, ini_setting, msg);
}
void Scanner::warn(const char* fmt, ...) {
va_list ap;
va_start(ap, fmt);
std::string msg;
string_vsnprintf(msg, fmt, ap);
va_end(ap);
Logger::Warning("%s: %s (Line: %d, Char %d)", msg.c_str(),
m_filename.c_str(), m_loc->r.line0, m_loc->r.char0);
}
void raise_message(ErrorMode mode,
const char *fmt,
...) {
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_message(mode, false, msg);
}
void raise_hack_strict(HackStrictOption option, const char *ini_setting,
const char *fmt, ...) {
if (option == HackStrictOption::WARN ?
!warning_freq_check() : (option != HackStrictOption::ON)) {
return;
}
std::string msg;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
raise_hack_strict_helper(option, ini_setting, msg);
}
void throw_invalid_argument(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
string msg;
string_vsnprintf(msg, fmt, ap);
va_end(ap);
if (RuntimeOption::ThrowInvalidArguments) {
throw InvalidArgumentException(msg.c_str());
}
raise_warning("Invalid argument: %s", msg.c_str());
}
void throw_bad_type_exception(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
string msg;
string_vsnprintf(msg, fmt, ap);
va_end(ap);
if (RuntimeOption::ThrowBadTypeExceptions) {
throw InvalidOperandException(msg.c_str());
}
raise_warning("Invalid operand type was used: %s", msg.c_str());
}
void omxGlobal::checkpointMessage(FitContext *fc, double *est, const char *fmt, ...)
{
std::string str;
va_list ap;
va_start(ap, fmt);
string_vsnprintf(fmt, ap, str);
va_end(ap);
if (OMX_DEBUG) mxLog("checkpointMessage: %s", str.c_str());
for(size_t i = 0; i < checkpointList.size(); i++) {
checkpointList[i]->message(fc, est, str.c_str());
}
}
void IntlError::setError(UErrorCode code, const char *format, ...) {
m_errorCode = code;
if (format) {
va_list args;
va_start(args, format);
string_vsnprintf(m_errorMessage, format, args);
va_end(args);
} else {
m_errorMessage.clear();
}
if (this != s_intl_error.get()) {
s_intl_error->m_errorCode = m_errorCode;
s_intl_error->m_errorMessage = m_errorMessage;
}
}
static void xslt_ext_error_handler(void *ctx,
const char *fmt, ...) {
va_list args;
va_start(args, fmt);
try {
std::string msg;
string_vsnprintf(msg, fmt, args);
/* remove any trailing \n */
while (!msg.empty() && msg[msg.size() - 1] == '\n') {
msg = msg.substr(0, msg.size() - 1);
}
raise_warning("%s", msg.c_str());
} catch (...) {}
va_end(args);
}
void raise_warning(const char *fmt, ...) {
if (RuntimeOption::WarningFrequency <= 0 ||
(g_warning_counter++) % RuntimeOption::WarningFrequency != 0) {
return;
}
std::string msg;
int errnum = static_cast<int>(ErrorConstants::ErrorModes::WARNING);
if (!g_context->errorNeedsHandling(errnum, true,
ExecutionContext::ErrorThrowMode::Never)) {
return;
}
va_list ap;
va_start(ap, fmt);
string_vsnprintf(msg, fmt, ap);
va_end(ap);
g_context->handleError(msg, errnum, true,
ExecutionContext::ErrorThrowMode::Never,
"\nWarning: ");
}
void Exception::format(const char *fmt, va_list ap) {
string_vsnprintf(m_msg, fmt, ap);
}
void Scanner::error(const char* fmt, ...) {
va_list ap;
va_start(ap, fmt);
string_vsnprintf(m_error, fmt, ap);
va_end(ap);
}
