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); } }