예제 #1
0
파일: debug.c 프로젝트: Alkzndr/freebsd
void
svn_dbg__print_props(apr_hash_t *props,
                     const char *header_fmt,
                     ...)
{
/* We only build this code if SVN_DEBUG is defined. */
#ifdef SVN_DEBUG

  apr_hash_index_t *hi;
  va_list ap;

  va_start(ap, header_fmt);
  debug_vprintf(header_fmt, ap);
  va_end(ap);

  if (props == NULL)
    {
      svn_dbg__printf("    (null)\n");
      return;
    }

  for (hi = apr_hash_first(apr_hash_pool_get(props), props); hi;
        hi = apr_hash_next(hi))
    {
      const char *name = svn__apr_hash_index_key(hi);
      svn_string_t *val = svn__apr_hash_index_val(hi);

      svn_dbg__printf("    '%s' -> '%s'\n", name, val->data);
    }
#endif /* SVN_DEBUG */
}
예제 #2
0
파일: printf.c 프로젝트: oscarlab/graphene
void debug_printf (const char * fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    debug_vprintf(fmt, &ap);
    va_end(ap);
}
예제 #3
0
파일: profile.c 프로젝트: justinzane/navit
void
profile_timer(int level, const char *module, const char *function, const char *fmt, ...)
{
	va_list ap;
	static struct timeval last[3];
	struct timeval curr;
	int msec,usec;
	char buffer[strlen(module)+20];

	va_start(ap, fmt);
	if (level < 0)
		level=0;
	if (level > 2)
		level=2;
	if (fmt) {
		gettimeofday(&curr, NULL);
		msec=(curr.tv_usec-last[level].tv_usec)/1000+
		     (curr.tv_sec-last[level].tv_sec)*1000;
	
		sprintf(buffer, "profile:%s", module);
		debug_vprintf(1, buffer, strlen(buffer), function, strlen(function), 1, fmt, ap); 
		if (msec >= 100) 
			debug_printf(1, buffer, strlen(buffer), function, strlen(function), 0, " %d msec\n", msec);
		else {
			usec=(curr.tv_usec-last[level].tv_usec)+(curr.tv_sec-last[level].tv_sec)*1000*1000;
			debug_printf(1, buffer, strlen(buffer), function, strlen(function), 0, " %d.%d msec\n", usec/1000, usec%1000);
		}
		gettimeofday(&last[level], NULL);
	} else {
		gettimeofday(&curr, NULL);
		for (level = 0 ; level < 3 ; level++) 
			last[level]=curr;
	}
	va_end(ap);
}
예제 #4
0
파일: profile.c 프로젝트: aerostitch/navit
/**
 * @brief Log timing information.
 *
 * @note Normally this function is called via the macro 'profile', which automatically fills in
 * parameters 'module' and 'function'.
 *
 * Successive calls to this function will print the elapsed time between calls, using an
 * internal timer. To start/reset the internal timer without printing a message, set parameter
 * 'fmt' to NULL.
 *
 * To run multiple timers in parallel, the parameter 'level' can be used. Each invocation will
 * print the elapsed time to the last invocation with the same level. As an exception, calling
 * with 'fmt'=NULL wll reset all timers with a level greater or equal to the level parameter.
 *
 * Typically, profiling is started by calling profile(0, NULL). Then calls with various levels
 * can be used to print different intermediate timings.
 *
 * @param level level of timer to use (0 to PROFILE_LEVEL_MAX).
 * @param module name of current module (for logging)
 * @param function name of current function (for logging)
 * @param fmt format string Log message to print (as a printf format string), followed by required
 * parameters as varargs. May be NULL; then no message is printed, and all timers with the
 * same or higher level are reset.
 */
void
profile_timer(int level, const char *module, const char *function, const char *fmt, ...)
{
#ifndef _MSC_VER
	va_list ap;
	static struct timeval last[PROFILE_LEVEL_MAX+1];
	struct timeval curr;
	double msec;
	char buffer[strlen(module)+20];

	if (level < 0)
		level=0;
	if (level > PROFILE_LEVEL_MAX)
		level=PROFILE_LEVEL_MAX;
	if (fmt) {
		gettimeofday(&curr, NULL);
		msec=(curr.tv_usec-last[level].tv_usec)/((double)1000)+
		     (curr.tv_sec-last[level].tv_sec)*1000;
	
		sprintf(buffer, "profile:%s", module);
		va_start(ap, fmt);
		debug_vprintf(lvl_debug, buffer, strlen(buffer), function, strlen(function), 1, fmt, ap);
		va_end(ap);
		debug_printf(lvl_debug, buffer, strlen(buffer), function, strlen(function), 0, " %7.1f ms\n", msec);
		gettimeofday(&last[level], NULL);
	} else {
		gettimeofday(&curr, NULL);
		while (level <= PROFILE_LEVEL_MAX)
			last[level++]=curr;
	}
#endif /*_MSC_VER*/
}
예제 #5
0
void debug_printf2(int level, const char *module, const int mlen, const char *function, const int flen, int prefix, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	debug_vprintf(level, module, mlen, function, flen, prefix, fmt, ap);
	va_end(ap);
}
예제 #6
0
파일: debug.c 프로젝트: hjmjohnson/bart
void debug_printf(int level, const char* fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	debug_vprintf(level, fmt, ap);	
	va_end(ap);
}
예제 #7
0
파일: debug.c 프로젝트: hjmjohnson/bart
void debug_trace(const char* fmt, ...)
{
	debug_printf(DP_TRACE, "TRACE %f: ", timestamp());

	va_list ap;
	va_start(ap, fmt);
	debug_vprintf(DP_TRACE, fmt, ap);
	va_end(ap);
}
예제 #8
0
파일: debug.c 프로젝트: Alkzndr/freebsd
void
svn_dbg__printf(const char *fmt, ...)
{
  va_list ap;

  va_start(ap, fmt);
  debug_vprintf(fmt, ap);
  va_end(ap);
}
예제 #9
0
void debug_printf(int level, const char *module, const int mlen, const char *function, const int flen, int prefix, const char *fmt, ...)
{
#ifdef _DEBUG_BUILD_
	va_list ap;
	va_start(ap, fmt);
	debug_vprintf(level, module, mlen, function, flen, prefix, fmt, ap);
	va_end(ap);
#endif
}
예제 #10
0
void SB_SA_Util_Debug::debug_printf(const char *pp_where,
                                    const char *pp_format,
                                    ...) {
    va_list lv_ap;

    va_start(lv_ap, pp_format);
    debug_vprintf(pp_where, pp_format, lv_ap);
    va_end(lv_ap);
}
예제 #11
0
파일: debug.c 프로젝트: abbra/sssd
static void debug_printf(const char *format, ...)
{
    va_list ap;

    va_start(ap, format);

    debug_vprintf(format, ap);

    va_end(ap);
}
예제 #12
0
파일: misc.c 프로젝트: mjacob75/bart
void error(const char* fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);

	debug_vprintf(DP_ERROR, fmt, ap);

	va_end(ap);
	abort();
}
예제 #13
0
void error(const char* fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	if (!debug_logging)
		debug_printf(DP_ERROR, "Error: ");
	debug_vprintf(DP_ERROR, fmt, ap);
	va_end(ap);
	abort();
}
예제 #14
0
void PRINTDEBUGMSG(unsigned int level, const char* fmt, ...)
{
	if (debug_level & level) {
		va_list ap;

		va_start(ap, fmt);
		debug_vprintf(fmt, ap);
		va_end(ap);
	}
}
예제 #15
0
debug_agent_printf (const char *fmt, ...)
{
  va_list ap;

  if (!debug_agent)
    return;
  va_start (ap, fmt);
  debug_vprintf (fmt, ap);
  va_end (ap);
}
예제 #16
0
int
GdError (const char *fmt, ...)
{
	va_list args;
	int err;

	va_start (args, fmt);
	err = debug_vprintf (fmt, args);
	va_end (args);
	return err;

}
예제 #17
0
파일: garmin.c 프로젝트: justinzane/navit
void 
logfn(char *file, int line, int level, char *fmt, ...)
{
	va_list ap;
	char fileline[256];
	int sz;
	if (level > garmin_debug)
		return;
	va_start(ap, fmt);
	sz = sprintf(fileline, "%s:%d:%d|", file, line, level);
	debug_vprintf(0, "", strlen(""), fileline, sz,
		1, fmt, ap);
	va_end(ap);
}
예제 #18
0
파일: debug.c 프로젝트: oceaquaris/ainur
int debug_print(const char *format, ...) {
    int output = 0;

    va_list args;
    va_start(args, format);
#ifdef DEBUGGING
    if(debugging) {
        output += debug_vfprintf(format, args);
    }
#endif /*DEBUGGING*/

#ifdef VERBOSE
    if(verbose) {
        output += debug_vprintf(format, args);
    }
#endif /*VERBOSE*/
    va_end(args);
    return output;
}
예제 #19
0
void __assert_msg(const char *msg, ...)
{
    arch_intr_off ();
#ifdef UOS_EXCEPTION_STACK
    //* if have another stack, and current stack is broken or small,
    //      just go to exception as inevitable
    UOS_STRICT(STACK,)
    if(!(task_stack_enough( VPRINTF_FRAME )) ) {
        debug_puts(msg);
        debug_puts("\nbreak on exception stack\n");
        return;
    }
#endif//UOS_EXCEPTION_STACK

    va_list args;

    va_start (args, msg);
    if (0 == debug_vprintf (msg, args) )
        //если неудалась печать, обрушусь в стек исключений
        ARCH_BREAK();
    va_end (args);
}
예제 #20
0
파일: debug.c 프로젝트: abbra/sssd
void debug_fn(const char *file,
              long line,
              const char *function,
              int level,
              const char *format, ...)
{
    va_list ap;
    struct timeval tv;
    struct tm *tm;
    char datetime[20];
    int year;

#ifdef WITH_JOURNALD
    errno_t ret;
    va_list ap_fallback;

    if (!debug_file && !debug_to_stderr) {
        /* If we are not outputting logs to files, we should be sending them
         * to journald.
         * NOTE: on modern systems, this is where stdout/stderr will end up
         * from system services anyway. The only difference here is that we
         * can also provide extra structuring data to make it more easily
         * searchable.
         */
        va_start(ap, format);
        va_copy(ap_fallback, ap);
        ret = journal_send(file, line, function, level, format, ap);
        va_end(ap);
        if (ret != EOK) {
            /* Emergency fallback, send to STDERR */
            debug_vprintf(format, ap_fallback);
            debug_fflush();
        }
        va_end(ap_fallback);
        return;
    }
#endif

    if (debug_timestamps) {
        gettimeofday(&tv, NULL);
        tm = localtime(&tv.tv_sec);
        year = tm->tm_year + 1900;
        /* get date time without year */
        memcpy(datetime, ctime(&tv.tv_sec), 19);
        datetime[19] = '\0';
        if (debug_microseconds) {
            debug_printf("(%s:%.6ld %d) [%s] [%s] (%#.4x): ",
                         datetime, tv.tv_usec,
                         year, debug_prg_name,
                         function, level);
        } else {
            debug_printf("(%s %d) [%s] [%s] (%#.4x): ",
                         datetime, year,
                         debug_prg_name, function, level);
        }
    } else {
        debug_printf("[%s] [%s] (%#.4x): ",
                     debug_prg_name, function, level);
    }

    va_start(ap, format);
    debug_vprintf(format, ap);
    va_end(ap);
    debug_fflush();
}