X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=ncurses%2Ftrace%2Flib_trace.c;h=effd3c1c158e2675dbdff506a750c9f4bc377265;hp=519a5ca90dcda6d4bb69b9719624255a8e577561;hb=3ffedbf1016b2d7026e7543fe73e87b046fbd862;hpb=5da4544722decdeb2bfd0c7c4581af0ea62148f9 diff --git a/ncurses/trace/lib_trace.c b/ncurses/trace/lib_trace.c index 519a5ca9..effd3c1c 100644 --- a/ncurses/trace/lib_trace.c +++ b/ncurses/trace/lib_trace.c @@ -1,5 +1,6 @@ /**************************************************************************** - * Copyright (c) 1998-2017,2018 Free Software Foundation, Inc. * + * Copyright 2018-2021,2022 Thomas E. Dickey * + * Copyright 1998-2016,2017 Free Software Foundation, Inc. * * * * Permission is hereby granted, free of charge, to any person obtaining a * * copy of this software and associated documentation files (the * @@ -36,7 +37,7 @@ /* * lib_trace.c - Tracing/Debugging routines * - * The _tracef() function is originally from pcurses (by Pavel Curtis) in 1982. + * The _tracef() function is originally from pcurses (by Pavel Curtis) in 1982. * pcurses allowed one to enable/disable tracing using traceon() and traceoff() * functions. ncurses provides a trace() function which allows one to * selectively enable or disable several tracing features. @@ -47,7 +48,7 @@ #include -MODULE_ID("$Id: lib_trace.c,v 1.87 2018/06/24 00:06:37 tom Exp $") +MODULE_ID("$Id: lib_trace.c,v 1.101 2022/09/17 14:57:02 tom Exp $") NCURSES_EXPORT_VAR(unsigned) _nc_tracing = 0; /* always define this */ @@ -91,14 +92,53 @@ NCURSES_EXPORT_VAR(long) _nc_outchars = 0; #define MyPath _nc_globals.trace_fname #define MyLevel _nc_globals.trace_level #define MyNested _nc_globals.nested_tracef +#endif /* TRACE */ -NCURSES_EXPORT(void) -trace(const unsigned int tracelevel) +#if USE_REENTRANT +#define Locked(statement) { \ + _nc_lock_global(tst_tracef); \ + statement; \ + _nc_unlock_global(tst_tracef); \ + } +#else +#define Locked(statement) statement +#endif + +NCURSES_EXPORT(unsigned) +curses_trace(unsigned tracelevel) { + unsigned result; + +#if defined(TRACE) + int bit; + +#define DATA(name) { name, #name } + static struct { + unsigned mask; + const char *name; + } trace_names[] = { + DATA(TRACE_TIMES), + DATA(TRACE_TPUTS), + DATA(TRACE_UPDATE), + DATA(TRACE_MOVE), + DATA(TRACE_CHARPUT), + DATA(TRACE_CALLS), + DATA(TRACE_VIRTPUT), + DATA(TRACE_IEVENT), + DATA(TRACE_BITS), + DATA(TRACE_ICALLS), + DATA(TRACE_CCALLS), + DATA(TRACE_DATABASE), + DATA(TRACE_ATTRS) + }; +#undef DATA + + Locked(result = _nc_tracing); + if ((MyFP == 0) && tracelevel) { MyInit = TRUE; if (MyFD >= 0) { - MyFP = fdopen(MyFD, "wb"); + MyFP = fdopen(MyFD, BIN_W); } else { if (MyPath[0] == '\0') { size_t size = sizeof(MyPath) - 12; @@ -113,16 +153,17 @@ trace(const unsigned int tracelevel) _nc_STRCAT(MyPath, ".log", sizeof(MyPath)); } } +#define SAFE_MODE (O_CREAT | O_EXCL | O_RDWR) if (_nc_access(MyPath, W_OK) < 0 - || (MyFD = open(MyPath, O_CREAT | O_EXCL | O_RDWR, 0600)) < 0 - || (MyFP = fdopen(MyFD, "wb")) == 0) { + || (MyFD = safe_open3(MyPath, SAFE_MODE, 0600)) < 0 + || (MyFP = fdopen(MyFD, BIN_W)) == 0) { ; /* EMPTY */ } } - _nc_tracing = tracelevel; + Locked(_nc_tracing = tracelevel); /* Try to set line-buffered mode, or (failing that) unbuffered, * so that the trace-output gets flushed automatically at the - * end of each line. This is useful in case the program dies. + * end of each line. This is useful in case the program dies. */ if (MyFP != 0) { #if HAVE_SETVBUF /* ANSI */ @@ -135,17 +176,47 @@ trace(const unsigned int tracelevel) NCURSES_VERSION, NCURSES_VERSION_PATCH, tracelevel); + +#define SPECIAL_MASK(mask) \ + if ((tracelevel & mask) == mask) \ + _tracef("- %s (%u)", #mask, mask) + + for (bit = 0; bit < TRACE_SHIFT; ++bit) { + unsigned mask = (1U << bit) & tracelevel; + if ((mask & trace_names[bit].mask) != 0) { + _tracef("- %s (%u)", trace_names[bit].name, mask); + } + } + SPECIAL_MASK(TRACE_MAXIMUM); + else + SPECIAL_MASK(TRACE_ORDINARY); + + if (tracelevel > TRACE_MAXIMUM) { + _tracef("- DEBUG_LEVEL(%u)", tracelevel >> TRACE_SHIFT); + } } else if (tracelevel == 0) { if (MyFP != 0) { MyFD = dup(MyFD); /* allow reopen of same file */ fclose(MyFP); MyFP = 0; } - _nc_tracing = tracelevel; + Locked(_nc_tracing = tracelevel); } else if (_nc_tracing != tracelevel) { - _nc_tracing = tracelevel; + Locked(_nc_tracing = tracelevel); _tracef("tracelevel=%#x", tracelevel); } +#else + (void) tracelevel; + result = 0; +#endif + return result; +} + +#if defined(TRACE) +NCURSES_EXPORT(void) +trace(const unsigned int tracelevel) +{ + curses_trace(tracelevel); } static void @@ -196,7 +267,7 @@ _nc_va_tracef(const char *fmt, va_list ap) # if USE_WEAK_SYMBOLS if ((pthread_self)) # endif -#ifdef _WIN32 +#ifdef _NC_WINDOWS fprintf(fp, "%#lx:", (long) (intptr_t) pthread_self().p); #else fprintf(fp, "%#lx:", (long) (intptr_t) pthread_self()); @@ -219,7 +290,7 @@ _nc_va_tracef(const char *fmt, va_list ap) } NCURSES_EXPORT(void) -_tracef(const char *fmt,...) +_tracef(const char *fmt, ...) { va_list ap; @@ -308,6 +379,39 @@ _nc_retrace_win(WINDOW *code) return code; } +NCURSES_EXPORT(char *) +_nc_fmt_funcptr(char *target, const char *source, size_t size) +{ + size_t n; + char *dst = target; + bool leading = TRUE; + + union { + int value; + char bytes[sizeof(int)]; + } byteorder; + + byteorder.value = 0x1234; + + *dst++ = '0'; + *dst++ = 'x'; + + for (n = 0; n < size; ++n) { + unsigned ch = ((byteorder.bytes[0] == 0x34) + ? UChar(source[size - n - 1]) + : UChar(source[n])); + if (ch != 0 || (n + 1) >= size) + leading = FALSE; + if (!leading) { + _nc_SPRINTF(dst, _nc_SLIMIT(TR_FUNC_LEN - (size_t) (dst - target)) + "%02x", ch & 0xff); + dst += 2; + } + } + *dst = '\0'; + return target; +} + #if USE_REENTRANT /* * Check if the given trace-mask is enabled. @@ -343,7 +447,7 @@ _nc_use_tracef(unsigned mask) * the tracef mutex. */ NCURSES_EXPORT(void) -_nc_locked_tracef(const char *fmt,...) +_nc_locked_tracef(const char *fmt, ...) { va_list ap;