void tiemu_message (const gchar *format, ...)
{
va_list args;
va_start (args, format);
g_logv (LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, format, args);
va_end (args);
}
/* Geany's main debug/log function, declared in geany.h */
void geany_debug(gchar const *format, ...)
{
va_list args;
va_start(args, format);
g_logv(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format, args);
va_end(args);
}
void tiemu_critical (const gchar *format, ...)
{
va_list args;
va_start (args, format);
g_logv (LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, format, args);
va_end (args);
}
void tiemu_warning (const gchar *format, ...)
{
va_list args;
va_start (args, format);
g_logv (LOG_DOMAIN, G_LOG_LEVEL_WARNING, format, args);
va_end (args);
}
static void pacman_manager_log_cb (pmloglevel_t level, gchar *format, va_list args) {
GLogLevelFlags flags = 0;
if (format == NULL || format[0] == '\0') {
return;
}
switch (level) {
case PM_LOG_DEBUG:
flags |= G_LOG_LEVEL_DEBUG;
break;
case PM_LOG_ERROR:
flags |= G_LOG_LEVEL_CRITICAL;
break;
case PM_LOG_WARNING:
flags |= G_LOG_LEVEL_WARNING;
break;
case PM_LOG_FUNCTION:
flags |= G_LOG_LEVEL_INFO;
break;
}
g_logv (G_LOG_DOMAIN, flags, format, args);
}
void tiemu_error (const gchar *format, ...)
{
va_list args;
va_start (args, format);
g_logv (LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args);
va_end (args);
}
void tiemu_debug (const gchar *format, ...)
{
va_list args;
va_start (args, format);
g_logv (LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format, args);
va_end (args);
}
void tiemu_info (const gchar *format, ...)
{
va_list args;
va_start (args, format);
g_logv (LOG_DOMAIN, G_LOG_LEVEL_INFO, format, args);
va_end (args);
}
static inline void
g_debug_inotify(const char *msg, ...)
{
va_list va;
va_start(va, msg);
g_logv("inotify",G_LOG_LEVEL_DEBUG, msg, va);
va_end(va);
}
void G_DEBUG_MSG(gint level, const char *format, ...){
va_list ap;
if (level<verboseLevel){
va_start(ap, format);
g_logv("MakerDialog",G_LOG_LEVEL_DEBUG, format, ap);
va_end(ap);
}
}
/* Note: in some situations, like with the fsfreeze, logging may be
* temporarilly disabled. if it is necessary that a command be able
* to log for accounting purposes, check ga_logging_enabled() beforehand,
* and use the QERR_QGA_LOGGING_DISABLED to generate an error
*/
void slog(const gchar *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
g_logv("syslog", G_LOG_LEVEL_INFO, fmt, ap);
va_end(ap);
}
void
rerror (const gchar *format, ...)
{
va_list args;
va_start (args, format);
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, format, args);
exit (EXIT_FAILURE);
}
void
g_assertion_message (const gchar *format, ...)
{
va_list args;
va_start (args, format);
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args);
va_end (args);
}
void
g_log (const gchar *log_domain, GLogLevelFlags log_level, const gchar *format, ...)
{
va_list args;
va_start (args, format);
g_logv (log_domain, log_level, format, args);
va_end (args);
}
void nice_debug (const char *fmt, ...)
{
va_list ap;
if (debug_enabled) {
va_start (ap, fmt);
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, fmt, ap);
va_end (ap);
}
}
static void
arv_dom_parser_fatal_error (void *user_data, const char *msg, ...)
{
va_list args;
va_start(args, msg);
g_logv("XML", G_LOG_LEVEL_ERROR, msg, args);
va_end(args);
}
void
gkr_debug_message (GkrDebugFlags flag,
const gchar *format,
...)
{
static gsize initialized_flags = 0;
const gchar *messages_env;
const gchar *debug_env;
va_list args;
if (g_once_init_enter (&initialized_flags)) {
messages_env = g_getenv ("G_MESSAGES_DEBUG");
debug_env = g_getenv ("GKR_DEBUG");
#ifdef GKR_DEBUG
if (debug_env == NULL)
debug_env = G_STRINGIFY (GKR_DEBUG);
#endif
/*
* If the caller is selectively asking for certain debug
* messages with the GKR_DEBUG environment variable, then
* we install our own output handler and only print those
* messages. This happens irrespective of G_MESSAGES_DEBUG
*/
if (messages_env == NULL && debug_env != NULL)
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
on_gkr_log_debug, NULL);
/*
* If the caller is using G_MESSAGES_DEBUG then we enable
* all our debug messages, and let Glib filter which ones
* to display.
*/
if (messages_env != NULL && debug_env == NULL)
debug_env = "all";
gkr_debug_set_flags (debug_env);
#ifdef FOR_WHEN_ALL_ELSE_FAILS
openlog ("libgnome-keyring", LOG_NDELAY | LOG_PID, LOG_AUTHPRIV);
gkr_debug_set_flags ("all");
#endif
g_once_init_leave (&initialized_flags, 1);
}
if (flag & current_flags) {
va_start (args, format);
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format, args);
va_end (args);
}
#ifdef FOR_WHEN_ALL_ELSE_FAILS
va_start (args, format);
vsyslog (LOG_ERR, format, args);
va_end (args);
#endif
}
void
po_error(const gchar *format, ...)
{
va_list ap;
va_start(ap, format);
g_logv(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, format, ap);
va_end(ap);
exit(1);
}
static void
arv_dom_parser_warning (void *user_data, const char *msg, ...)
{
va_list args;
va_start(args, msg);
g_logv("XML", G_LOG_LEVEL_WARNING, msg, args);
va_end(args);
}
/**
* mono_tracev:
*
* @level: Verbose level of the specified message
* @mask: Type of the specified message
*
* Traces a new message, depending on the current logging level
* and trace mask.
*/
void
mono_tracev (GLogLevelFlags level, MonoTraceMask mask, const char *format, va_list args)
{
if (level_stack == NULL)
mono_trace_init ();
if(level <= current_level && mask & current_mask)
g_logv (mono_log_domain, level, format, args);
}
void
seafile_debug_impl (SeafileDebugFlags flag, const gchar *format, ...)
{
if (flag & debug_flags) {
va_list args;
va_start (args, format);
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format, args);
va_end (args);
}
}
static void
glib_vlog(os_handler_t *handler,
enum ipmi_log_type_e log_type,
const char *format,
va_list ap)
{
GLogLevelFlags flags;
vlog_data_t *info;
g_os_hnd_data_t *ginfo = handler->internal_data;
os_vlog_t log_handler = ginfo->log_handler;
if (log_handler) {
log_handler(handler, format, log_type, ap);
return;
}
switch (log_type) {
case IPMI_LOG_INFO: flags = G_LOG_LEVEL_INFO; break;
case IPMI_LOG_WARNING: flags = G_LOG_LEVEL_WARNING; break;
case IPMI_LOG_SEVERE: flags = G_LOG_LEVEL_CRITICAL; break;
case IPMI_LOG_FATAL: flags = G_LOG_LEVEL_ERROR; break;
case IPMI_LOG_ERR_INFO: flags = G_LOG_LEVEL_MESSAGE; break;
case IPMI_LOG_DEBUG: flags = G_LOG_LEVEL_DEBUG; break;
case IPMI_LOG_DEBUG_END:
info = get_vlog_data();
if (!info)
return;
add_vlog_data(info, format, ap);
g_log("OpenIPMI", G_LOG_LEVEL_DEBUG, "%s", info->data);
info->curr = 0;
return;
case IPMI_LOG_DEBUG_START:
info = get_vlog_data();
if (!info)
return;
info->curr = 0;
add_vlog_data(info, format, ap);
return;
case IPMI_LOG_DEBUG_CONT:
info = get_vlog_data();
if (!info)
return;
add_vlog_data(info, format, ap);
return;
default:
flags = G_LOG_LEVEL_INFO;
break;
}
g_logv("OpenIPMI", flags, format, ap);
}
void bmain_log(ShadowLogLevel level, const gchar* functionName, const gchar* format, ...) {
va_list vargs;
va_start(vargs, format);
GString* newformat = g_string_new(NULL);
g_string_append_printf(newformat, "[%s] %s", functionName, format);
g_logv(G_LOG_DOMAIN, (GLogLevelFlags)level, newformat->str, vargs);
g_string_free(newformat, TRUE);
va_end(vargs);
}
static void __view_error(xmlNode *node, const gchar *msg, ...)
{
g_assert(node != NULL);
va_list args;
va_start (args, msg);
g_logv(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, msg, args);
va_end(args);
g_error("Failed to parse %s view (line %ld)", parsed_view, xmlGetLineNo(node));
}
void
nautilus_debug_valist (DebugFlags flag,
const gchar *format,
va_list args)
{
if (G_UNLIKELY(!initialized))
nautilus_debug_set_flags_from_env ();
if (flag & flags)
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format, args);
}
void
_clutter_profile_trace_message (const char *format, ...)
{
va_list ap;
va_start (ap, format);
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, format, ap);
va_end (ap);
if (_clutter_uprof_context)
uprof_context_vtrace_message (_clutter_uprof_context, format, ap);
}
/**
* gimp_any_to_utf8:
* @str: The string to be converted to UTF-8.
* @len: The length of the string, or -1 if the string
* is nul-terminated.
* @warning_format: The message format for the warning message if conversion
* to UTF-8 fails. See the <function>printf()</function>
* documentation.
* @...: The parameters to insert into the format string.
*
* This function takes any string (UTF-8 or not) and always returns a valid
* UTF-8 string.
*
* If @str is valid UTF-8, a copy of the string is returned.
*
* If UTF-8 validation fails, g_locale_to_utf8() is tried and if it
* succeeds the resulting string is returned.
*
* Otherwise, the portion of @str that is UTF-8, concatenated
* with "(invalid UTF-8 string)" is returned. If not even the start
* of @str is valid UTF-8, only "(invalid UTF-8 string)" is returned.
*
* Return value: The UTF-8 string as described above.
**/
gchar *
gimp_any_to_utf8 (const gchar *str,
gssize len,
const gchar *warning_format,
...)
{
const gchar *start_invalid;
gchar *utf8;
g_return_val_if_fail (str != NULL, NULL);
if (g_utf8_validate (str, len, &start_invalid))
{
if (len < 0)
utf8 = g_strdup (str);
else
utf8 = g_strndup (str, len);
}
else
{
utf8 = g_locale_to_utf8 (str, len, NULL, NULL, NULL);
}
if (! utf8)
{
if (warning_format)
{
va_list warning_args;
va_start (warning_args, warning_format);
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE,
warning_format, warning_args);
va_end (warning_args);
}
if (start_invalid > str)
{
gchar *tmp;
tmp = g_strndup (str, start_invalid - str);
utf8 = g_strconcat (tmp, " ", _("(invalid UTF-8 string)"), NULL);
g_free (tmp);
}
else
{
utf8 = g_strdup (_("(invalid UTF-8 string)"));
}
}
return utf8;
}
void
champlain_debug (ChamplainDebugFlags flag,
const gchar *format,
...)
{
if (flag & flags)
{
va_list args;
va_start (args, format);
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format, args);
va_end (args);
}
}
/**
* ags_lv2_log_manager_vprintf:
* @handle: the log handle
* @type: LV2 URID
* @fmt: format
* @ap: argument pointer
*
* Variadict print formatted.
*
* Returns: 0
*
* Since: 2.0.0
*/
int
ags_lv2_log_manager_vprintf(LV2_Log_Handle handle,
LV2_URID type,
const char* fmt,
va_list ap)
{
g_logv(G_LOG_DOMAIN,
0,
fmt,
ap);
return(0);
}
/**
* mono_trace:
*
* @level: Verbose level of the specified message
* @mask: Type of the specified message
*
* Traces a new message, depending on the current logging level
* and trace mask.
*/
void
mono_trace(GLogLevelFlags level, MonoTraceMask mask, const char *format, ...)
{
if(level_stack == NULL)
mono_trace_init();
if(level <= current_level && mask & current_mask) {
va_list args;
va_start (args, format);
g_logv (mono_log_domain, level, format, args);
va_end (args);
}
}
