From f4092abdf94af6a99aff944d6264bc1284e8bdd4 Mon Sep 17 00:00:00 2001 From: Reinhard Tartler Date: Mon, 10 Oct 2011 17:43:39 +0200 Subject: Imported nx-X11-3.1.0-1.tar.gz Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository --- nx-X11/programs/xterm/trace.c | 490 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 490 insertions(+) create mode 100644 nx-X11/programs/xterm/trace.c (limited to 'nx-X11/programs/xterm/trace.c') diff --git a/nx-X11/programs/xterm/trace.c b/nx-X11/programs/xterm/trace.c new file mode 100644 index 000000000..abaaf634f --- /dev/null +++ b/nx-X11/programs/xterm/trace.c @@ -0,0 +1,490 @@ +/* $XTermId: trace.c,v 1.63 2005/09/18 23:48:13 tom Exp $ */ + +/* + * $XFree86: xc/programs/xterm/trace.c,v 3.23 2005/09/18 23:48:13 dickey Exp $ + */ + +/************************************************************ + +Copyright 1997-2004,2005 by Thomas E. Dickey + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of the above listed +copyright holder(s) not be used in advertising or publicity pertaining +to distribution of the software without specific, written prior +permission. + +THE ABOVE LISTED COPYRIGHT HOLDER(S) DISCLAIM ALL WARRANTIES WITH REGARD +TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS, IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE +LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +********************************************************/ + +/* + * debugging support via TRACE macro. + */ + +#include /* for definition of GCC_UNUSED */ +#include +#include + +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_X11_TRANSLATEI_H +#include +#else +#ifdef __cplusplus +extern "C" { +#endif + + extern String _XtPrintXlations(Widget w, + XtTranslations xlations, + Widget accelWidget, + _XtBoolean includeRHS); +#ifdef __cplusplus +} +#endif +#endif +char *trace_who = "parent"; + +void +Trace(char *fmt,...) +{ + static FILE *fp; + static char *trace_out; + va_list ap; + + if (fp != 0 + && trace_who != trace_out) { + fclose(fp); + fp = 0; + } + trace_out = trace_who; + + if (!fp) { + char name[BUFSIZ]; +#if 0 /* usually I do not want unique names */ + int unique; + for (unique = 0;; ++unique) { + if (unique) + sprintf(name, "Trace-%s.out-%d", trace_who, unique); + else + sprintf(name, "Trace-%s.out", trace_who); + if ((fp = fopen(name, "r")) == 0) { + break; + } + fclose(fp); + } +#else + sprintf(name, "Trace-%s.out", trace_who); +#endif + fp = fopen(name, "w"); + if (fp != 0) { + time_t now = time((time_t *) 0); + fprintf(fp, "%s\n", xtermVersion()); +#ifdef HAVE_UNISTD_H + fprintf(fp, "process %d real (%u/%u) effective (%u/%u) -- %s", + getpid(), + (unsigned) getuid(), (unsigned) getgid(), + (unsigned) geteuid(), (unsigned) getegid(), + ctime(&now)); +#else + fprintf(fp, "process %d -- %s", + getpid(), + ctime(&now)); +#endif + } + } + if (!fp) + abort(); + + va_start(ap, fmt); + if (fmt != 0) { + vfprintf(fp, fmt, ap); + (void) fflush(fp); + } else { + (void) fclose(fp); + (void) fflush(stdout); + (void) fflush(stderr); + } + va_end(ap); +} + +char * +visibleChars(PAIRED_CHARS(Char * buf, Char * buf2), unsigned len) +{ + static char *result; + static unsigned used; + unsigned limit = ((len + 1) * 8) + 1; + char *dst; + + if (limit > used) { + used = limit; + result = XtRealloc(result, used); + } + dst = result; + while (len--) { + unsigned value = *buf++; +#if OPT_WIDE_CHARS + if (buf2 != 0) { + value |= (*buf2 << 8); + buf2++; + } + if (value > 255) + sprintf(dst, "\\u+%04X", value); + else +#endif + if (E2A(value) < 32 || (E2A(value) >= 127 && E2A(value) < 160)) + sprintf(dst, "\\%03o", value); + else + sprintf(dst, "%c", CharOf(value)); + dst += strlen(dst); + } + return result; +} + +char * +visibleIChar(IChar * buf, unsigned len) +{ + static char *result; + static unsigned used; + unsigned limit = ((len + 1) * 6) + 1; + char *dst; + + if (limit > used) { + used = limit; + result = XtRealloc(result, used); + } + dst = result; + while (len--) { + unsigned value = *buf++; +#if OPT_WIDE_CHARS + if (value > 255) + sprintf(dst, "\\u+%04X", value); + else +#endif + if (E2A(value) < 32 || (E2A(value) >= 127 && E2A(value) < 160)) + sprintf(dst, "\\%03o", value); + else + sprintf(dst, "%c", CharOf(value)); + dst += strlen(dst); + } + return result; +} + +#define CASETYPE(name) case name: result = #name; break; + +const char * +visibleKeyboardType(xtermKeyboardType type) +{ + const char *result = "?"; + switch (type) { + CASETYPE(keyboardIsLegacy); /* bogus vt220 codes for F1-F4, etc. */ + CASETYPE(keyboardIsDefault); + CASETYPE(keyboardIsHP); + CASETYPE(keyboardIsSCO); + CASETYPE(keyboardIsSun); + CASETYPE(keyboardIsVT220); + } + return result; +} + +void +TraceSizeHints(XSizeHints * hints) +{ + TRACE(("size hints:\n")); + if (hints->flags & (USPosition | PPosition)) + TRACE((" position %d,%d%s%s\n", hints->y, hints->x, + hints->flags & USPosition ? " user" : "", + hints->flags & PPosition ? " prog" : "")); + if (hints->flags & (USSize | PSize)) + TRACE((" size %d,%d%s%s\n", hints->height, hints->width, + hints->flags & USSize ? " user" : "", + hints->flags & PSize ? " prog" : "")); + if (hints->flags & PMinSize) + TRACE((" min %d,%d\n", hints->min_height, hints->min_width)); + if (hints->flags & PMaxSize) + TRACE((" max %d,%d\n", hints->max_height, hints->max_width)); + if (hints->flags & PResizeInc) + TRACE((" inc %d,%d\n", hints->height_inc, hints->width_inc)); + if (hints->flags & PAspect) + TRACE((" min aspect %d/%d\n", hints->min_aspect.y, hints->min_aspect.y)); + if (hints->flags & PAspect) + TRACE((" max aspect %d/%d\n", hints->max_aspect.y, hints->max_aspect.y)); + if (hints->flags & PBaseSize) + TRACE((" base %d,%d\n", hints->base_height, hints->base_width)); + if (hints->flags & PWinGravity) + TRACE((" gravity %d\n", hints->win_gravity)); +} + +void +TraceWMSizeHints(XtermWidget xw) +{ + XSizeHints sizehints; + long supp = 0; + + bzero(&sizehints, sizeof(sizehints)); + if (!XGetWMNormalHints(xw->screen.display, XtWindow(SHELL_OF(xw)), + &sizehints, &supp)) + bzero(&sizehints, sizeof(sizehints)); + TraceSizeHints(&sizehints); +} + +/* + * Some calls to XGetAtom() will fail, and we don't want to stop. So we use + * our own error-handler. + */ +static int +no_error(Display * dpy GCC_UNUSED, XErrorEvent * event GCC_UNUSED) +{ + return 1; +} + +void +TraceTranslations(const char *name, Widget w) +{ + String result; + XErrorHandler save = XSetErrorHandler(no_error); + XtTranslations xlations; + Widget xcelerat; + + TRACE(("TraceTranslations for %s (widget %#lx)\n", name, (long) w)); + if (w) { + XtVaGetValues(w, + XtNtranslations, &xlations, + XtNaccelerators, &xcelerat, + (XtPointer) 0); + TRACE(("... xlations %#08lx\n", (long) xlations)); + TRACE(("... xcelerat %#08lx\n", (long) xcelerat)); + result = _XtPrintXlations(w, xlations, xcelerat, True); + TRACE(("%s\n", result != 0 ? result : "(null)")); + if (result) + XFree(result); + } else { + TRACE(("none (widget is null)\n")); + } + XSetErrorHandler(save); +} + +#define XRES_S(name) Trace(#name " = %s\n", NonNull(resp->name)) +#define XRES_B(name) Trace(#name " = %s\n", BtoS(resp->name)) +#define XRES_I(name) Trace(#name " = %d\n", resp->name) + +void +TraceXtermResources(void) +{ + XTERM_RESOURCE *resp = &resource; + + Trace("XTERM_RESOURCE settings:\n"); + XRES_S(xterm_name); + XRES_S(icon_geometry); + XRES_S(title); + XRES_S(icon_name); + XRES_S(term_name); + XRES_S(tty_modes); + XRES_B(hold_screen); + XRES_B(utmpInhibit); + XRES_B(utmpDisplayId); + XRES_B(messages); + XRES_B(sunFunctionKeys); +#if OPT_SUNPC_KBD + XRES_B(sunKeyboard); +#endif +#if OPT_HP_FUNC_KEYS + XRES_B(hpFunctionKeys); +#endif +#if OPT_SCO_FUNC_KEYS + XRES_B(scoFunctionKeys); +#endif +#if OPT_INITIAL_ERASE + XRES_B(ptyInitialErase); + XRES_B(backarrow_is_erase); +#endif + XRES_B(wait_for_map); + XRES_B(useInsertMode); +#if OPT_ZICONBEEP + XRES_I(zIconBeep); +#endif +#if OPT_PTY_HANDSHAKE + XRES_B(ptyHandshake); +#endif +#if OPT_SAME_NAME + XRES_B(sameName); +#endif +#if OPT_SESSION_MGT + XRES_B(sessionMgt); +#endif +} + +void +TraceArgv(const char *tag, char **argv) +{ + int n = 0; + + TRACE(("%s:\n", tag)); + while (*argv != 0) { + TRACE((" %d:%s\n", n++, *argv++)); + } +} + +static char * +parse_option(char *dst, char *src, int first) +{ + char *s; + + if (!strncmp(src, "-/+", 3)) { + dst[0] = first; + strcpy(dst + 1, src + 3); + } else { + strcpy(dst, src); + } + for (s = dst; *s != '\0'; s++) { + if (*s == '#' || *s == '%' || *s == 'S') { + s[1] = '\0'; + } else if (*s == ' ') { + *s = '\0'; + break; + } + } + return dst; +} + +static Bool +same_option(OptionHelp * opt, XrmOptionDescRec * res) +{ + char temp[BUFSIZ]; + return !strcmp(parse_option(temp, opt->opt, res->option[0]), res->option); +} + +static Bool +standard_option(char *opt) +{ + static const char *table[] = + { + "+rv", + "+synchronous", + "-background", + "-bd", + "-bg", + "-bordercolor", + "-borderwidth", + "-bw", + "-display", + "-fg", + "-fn", + "-font", + "-foreground", + "-geometry", + "-iconic", + "-name", + "-reverse", + "-rv", + "-selectionTimeout", + "-synchronous", + "-title", + "-xnllanguage", + "-xrm", + "-xtsessionID", + }; + Cardinal n; + char temp[BUFSIZ]; + + opt = parse_option(temp, opt, '-'); + for (n = 0; n < XtNumber(table); n++) { + if (!strcmp(opt, table[n])) + return True; + } + return False; +} + +/* + * Analyse the options/help messages for inconsistencies. + */ +void +TraceOptions(OptionHelp * options, XrmOptionDescRec * resources, Cardinal res_count) +{ + OptionHelp *opt_array = sortedOpts(options, resources, res_count); + size_t j, k; + XrmOptionDescRec *res_array = sortedOptDescs(resources, res_count); + Bool first, found; + + TRACE(("Checking options-tables for inconsistencies:\n")); + +#if 0 + TRACE(("Options listed in help-message:\n")); + for (j = 0; options[j].opt != 0; j++) + TRACE(("%5d %-28s %s\n", j, opt_array[j].opt, opt_array[j].desc)); + TRACE(("Options listed in resource-table:\n")); + for (j = 0; j < res_count; j++) + TRACE(("%5d %-28s %s\n", j, res_array[j].option, res_array[j].specifier)); +#endif + + /* list all options[] not found in resources[] */ + for (j = 0, first = True; options[j].opt != 0; j++) { + found = False; + for (k = 0; k < res_count; k++) { + if (same_option(&opt_array[j], &res_array[k])) { + found = True; + break; + } + } + if (!found) { + if (first) { + TRACE(("Options listed in help, not found in resource list:\n")); + first = False; + } + TRACE((" %-28s%s\n", opt_array[j].opt, + standard_option(opt_array[j].opt) ? " (standard)" : "")); + } + } + + /* list all resources[] not found in options[] */ + for (j = 0, first = True; j < res_count; j++) { + found = False; + for (k = 0; options[k].opt != 0; k++) { + if (same_option(&opt_array[k], &res_array[j])) { + found = True; + break; + } + } + if (!found) { + if (first) { + TRACE(("Resource list items not found in options-help:\n")); + first = False; + } + TRACE((" %s\n", res_array[j].option)); + } + } + + TRACE(("Resource list items that will be ignored by XtOpenApplication:\n")); + for (j = 0; j < res_count; j++) { + switch (res_array[j].argKind) { + case XrmoptionSkipArg: + TRACE((" %-28s {param}\n", res_array[j].option)); + break; + case XrmoptionSkipNArgs: + TRACE((" %-28s {%ld params}\n", res_array[j].option, (long) + res_array[j].value)); + break; + case XrmoptionSkipLine: + TRACE((" %-28s {remainder of line}\n", res_array[j].option)); + break; + default: + break; + } + } +} -- cgit v1.2.3