ncurses 6.0 - patch 20171118
[ncurses.git] / ncurses / trace / visbuf.c
index 4fbecc50e4f6132ba50adbe2dd4900dd71f1ce1e..581bfbd259bd5a76862dd09616fdbcc8acb40f82 100644 (file)
@@ -1,5 +1,5 @@
 /****************************************************************************
 /****************************************************************************
- * Copyright (c) 2001 Free Software Foundation, Inc.                        *
+ * Copyright (c) 2001-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            *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *
@@ -27,7 +27,7 @@
  ****************************************************************************/
 
 /****************************************************************************
  ****************************************************************************/
 
 /****************************************************************************
- *  Author: Thomas E. Dickey 1996-2001                                      *
+ *  Author: Thomas E. Dickey                        1996-on                 *
  *     and: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
  ****************************************************************************/
  *     and: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
  ****************************************************************************/
  *     visbuf.c - Tracing/Debugging support routines
  */
 
  *     visbuf.c - Tracing/Debugging support routines
  */
 
+#define NEED_NCURSES_CH_T
 #include <curses.priv.h>
 
 #include <tic.h>
 #include <ctype.h>
 
 #include <curses.priv.h>
 
 #include <tic.h>
 #include <ctype.h>
 
-MODULE_ID("$Id: visbuf.c,v 1.6 2002/10/06 00:03:43 tom Exp $")
+MODULE_ID("$Id: visbuf.c,v 1.49 2017/10/21 23:34:20 tom Exp $")
+
+#define NUM_VISBUFS 4
+
+#define NormalLen(len) (size_t) (((size_t)(len) + 1) * 4)
+#define WideLen(len)   (size_t) (((size_t)(len) + 1) * 4 * (size_t) MB_CUR_MAX)
+
+#ifdef TRACE
+static const char d_quote[] = StringOf(D_QUOTE);
+static const char l_brace[] = StringOf(L_BRACE);
+static const char r_brace[] = StringOf(R_BRACE);
+#endif
+
+#if USE_STRING_HACKS && HAVE_SNPRINTF
+#define VisChar(tp, chr, limit) _nc_vischar(tp, chr, limit)
+#define LIMIT_ARG ,size_t limit
+#else
+#define VisChar(tp, chr, limit) _nc_vischar(tp, chr)
+#define LIMIT_ARG              /* nothing */
+#endif
 
 static char *
 
 static char *
-_nc_vischar(char *tp, unsigned c)
+_nc_vischar(char *tp, unsigned c LIMIT_ARG)
 {
     if (c == '"' || c == '\\') {
        *tp++ = '\\';
 {
     if (c == '"' || c == '\\') {
        *tp++ = '\\';
-       *tp++ = c;
-    } else if (is7bits(c) && (isgraph(c) || c == ' ')) {
-       *tp++ = c;
+       *tp++ = (char) c;
+    } else if (is7bits((int) c) && (isgraph((int) c) || c == ' ')) {
+       *tp++ = (char) c;
     } else if (c == '\n') {
        *tp++ = '\\';
        *tp++ = 'n';
     } else if (c == '\n') {
        *tp++ = '\\';
        *tp++ = 'n';
@@ -63,23 +83,29 @@ _nc_vischar(char *tp, unsigned c)
     } else if (c == '\033') {
        *tp++ = '\\';
        *tp++ = 'e';
     } else if (c == '\033') {
        *tp++ = '\\';
        *tp++ = 'e';
+    } else if (UChar(c) == 0x7f) {
+       *tp++ = '\\';
+       *tp++ = '^';
+       *tp++ = '?';
     } else if (is7bits(c) && iscntrl(UChar(c))) {
        *tp++ = '\\';
        *tp++ = '^';
     } else if (is7bits(c) && iscntrl(UChar(c))) {
        *tp++ = '\\';
        *tp++ = '^';
-       *tp++ = '@' + c;
+       *tp++ = (char) ('@' + c);
     } else {
     } else {
-       sprintf(tp, "\\%03lo", ChCharOf(c));
+       _nc_SPRINTF(tp, _nc_SLIMIT(limit)
+                   "\\%03lo", (unsigned long) ChCharOf(c));
        tp += strlen(tp);
     }
        tp += strlen(tp);
     }
+    *tp = 0;
     return tp;
 }
 
 static const char *
 _nc_visbuf2n(int bufnum, const char *buf, int len)
 {
     return tp;
 }
 
 static const char *
 _nc_visbuf2n(int bufnum, const char *buf, int len)
 {
-    char *vbuf;
+    const char *vbuf = 0;
     char *tp;
     char *tp;
-    int c;
+    int count;
 
     if (buf == 0)
        return ("(null)");
 
     if (buf == 0)
        return ("(null)");
@@ -87,23 +113,39 @@ _nc_visbuf2n(int bufnum, const char *buf, int len)
        return ("(cancelled)");
 
     if (len < 0)
        return ("(cancelled)");
 
     if (len < 0)
-       len = strlen(buf);
+       len = (int) strlen(buf);
 
 
+    count = len;
 #ifdef TRACE
 #ifdef TRACE
-    tp = vbuf = _nc_trace_buf(bufnum, (unsigned) (len * 4) + 5);
+    vbuf = tp = _nc_trace_buf(bufnum, NormalLen(len));
 #else
     {
 #else
     {
-       static char *mybuf[2];
-       mybuf[bufnum] = typeRealloc(char, (unsigned) (len * 4) + 5, mybuf[bufnum]);
-       tp = vbuf = mybuf[bufnum];
+       static char *mybuf[NUM_VISBUFS];
+       int c;
+
+       if (bufnum < 0) {
+           for (c = 0; c < NUM_VISBUFS; ++c) {
+               FreeAndNull(mybuf[c]);
+           }
+           tp = 0;
+       } else {
+           mybuf[bufnum] = typeRealloc(char, NormalLen(len), mybuf[bufnum]);
+           vbuf = tp = mybuf[bufnum];
+       }
     }
 #endif
     }
 #endif
-    *tp++ = D_QUOTE;
-    while ((--len >= 0) && (c = *buf++) != '\0') {
-       tp = _nc_vischar(tp, UChar(c));
+    if (tp != 0) {
+       int c;
+
+       *tp++ = D_QUOTE;
+       while ((--count >= 0) && (c = *buf++) != '\0') {
+           tp = VisChar(tp, UChar(c), NormalLen(len));
+       }
+       *tp++ = D_QUOTE;
+       *tp = '\0';
+    } else {
+       vbuf = ("(_nc_visbuf2n failed)");
     }
     }
-    *tp++ = D_QUOTE;
-    *tp++ = '\0';
     return (vbuf);
 }
 
     return (vbuf);
 }
 
@@ -125,146 +167,208 @@ _nc_visbufn(const char *buf, int len)
     return _nc_visbuf2n(0, buf, len);
 }
 
     return _nc_visbuf2n(0, buf, len);
 }
 
-#if USE_WIDEC_SUPPORT
 #ifdef TRACE
 #ifdef TRACE
+#if USE_WIDEC_SUPPORT
+
+#if defined(USE_TERMLIB)
+#define _nc_wchstrlen _my_wchstrlen
+static int
+_nc_wchstrlen(const cchar_t *s)
+{
+    int result = 0;
+    while (CharOf(s[result]) != L'\0') {
+       result++;
+    }
+    return result;
+}
+#endif
+
 static const char *
 static const char *
-_nc_viswbuf2n(int bufnum, const wchar_t * buf, int len)
+_nc_viswbuf2n(int bufnum, const wchar_t *buf, int len)
 {
 {
-    char *vbuf;
+    const char *vbuf;
     char *tp;
     char *tp;
-    wchar_t c;
+    int count;
 
     if (buf == 0)
        return ("(null)");
 
     if (len < 0)
 
     if (buf == 0)
        return ("(null)");
 
     if (len < 0)
-       len = wcslen(buf);
+       len = (int) wcslen(buf);
 
 
+    count = len;
 #ifdef TRACE
 #ifdef TRACE
-    tp = vbuf = _nc_trace_buf(bufnum, (unsigned) (len * 4) + 5);
+    vbuf = tp = _nc_trace_buf(bufnum, WideLen(len));
 #else
     {
 #else
     {
-       static char *mybuf[2];
-       mybuf[bufnum] = typeRealloc(char, (unsigned) (len * 4) + 5, mybuf[bufnum]);
-       tp = vbuf = mybuf[bufnum];
+       static char *mybuf[NUM_VISBUFS];
+       mybuf[bufnum] = typeRealloc(char, WideLen(len), mybuf[bufnum]);
+       vbuf = tp = mybuf[bufnum];
     }
 #endif
     }
 #endif
-    *tp++ = D_QUOTE;
-    while ((--len >= 0) && (c = *buf++) != '\0') {
-       char temp[CCHARW_MAX + 80];
-       int j = wctomb(temp, c), k;
-       if (j <= 0) {
-           sprintf(temp, "\\u%08X", (wint_t) c);
-           j = strlen(temp);
-       }
-       for (k = 0; k < j; ++k) {
-           tp = _nc_vischar(tp, temp[k]);
+    if (tp != 0) {
+       wchar_t c;
+
+       *tp++ = D_QUOTE;
+       while ((--count >= 0) && (c = *buf++) != '\0') {
+           char temp[CCHARW_MAX + 80];
+           int j = wctomb(temp, c), k;
+           if (j <= 0) {
+               _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
+                           "\\u%08X", (unsigned) c);
+               j = (int) strlen(temp);
+           }
+           for (k = 0; k < j; ++k) {
+               tp = VisChar(tp, UChar(temp[k]), WideLen(len));
+           }
        }
        }
+       *tp++ = D_QUOTE;
+       *tp = '\0';
+    } else {
+       vbuf = ("(_nc_viswbuf2n failed)");
     }
     }
-    *tp++ = D_QUOTE;
-    *tp++ = '\0';
     return (vbuf);
 }
 
 NCURSES_EXPORT(const char *)
     return (vbuf);
 }
 
 NCURSES_EXPORT(const char *)
-_nc_viswbuf2(int bufnum, const wchar_t * buf)
+_nc_viswbuf2(int bufnum, const wchar_t *buf)
 {
     return _nc_viswbuf2n(bufnum, buf, -1);
 }
 
 NCURSES_EXPORT(const char *)
 {
     return _nc_viswbuf2n(bufnum, buf, -1);
 }
 
 NCURSES_EXPORT(const char *)
-_nc_viswbuf(const wchar_t * buf)
+_nc_viswbuf(const wchar_t *buf)
 {
     return _nc_viswbuf2(0, buf);
 }
 
 NCURSES_EXPORT(const char *)
 {
     return _nc_viswbuf2(0, buf);
 }
 
 NCURSES_EXPORT(const char *)
-_nc_viswbufn(const wchar_t * buf, int len)
+_nc_viswbufn(const wchar_t *buf, int len)
 {
     return _nc_viswbuf2n(0, buf, len);
 }
 
 {
     return _nc_viswbuf2n(0, buf, len);
 }
 
+/* this special case is used for wget_wstr() */
 NCURSES_EXPORT(const char *)
 NCURSES_EXPORT(const char *)
-_nc_viscbuf2(int bufnum, const cchar_t * buf, int len)
+_nc_viswibuf(const wint_t *buf)
 {
 {
-    size_t have = BUFSIZ;
-    char *result = _nc_trace_buf(bufnum, have);
-    char *tp = result;
-    int n;
-    bool same = TRUE;
-    attr_t attr = A_NORMAL;
-    const char *found;
-
-    if (len < 0)
-       len = _nc_wchstrlen(buf);
+    static wchar_t *mybuf;
+    static unsigned mylen;
+    unsigned n;
 
 
-    for (n = 1; n < len; n++) {
-       if (AttrOf(buf[n]) != AttrOf(buf[0])) {
-           same = FALSE;
-           break;
+    for (n = 0; buf[n] != 0; ++n) {
+       ;                       /* empty */
+    }
+    if (mylen < ++n) {
+       mylen = n + 80;
+       if (mybuf != 0)
+           mybuf = typeRealloc(wchar_t, mylen, mybuf);
+       else
+           mybuf = typeMalloc(wchar_t, mylen);
+    }
+    if (mybuf != 0) {
+       for (n = 0; buf[n] != 0; ++n) {
+           mybuf[n] = (wchar_t) buf[n];
        }
        }
+       mybuf[n] = L'\0';
     }
 
     }
 
-    /*
-     * If the rendition is the same for the whole string, display it as a
-     * quoted string, followed by the rendition.  Otherwise, use the more
-     * detailed trace function that displays each character separately.
-     */
-    if (same) {
-       *tp++ = D_QUOTE;
-       while (len-- > 0) {
-           if ((found = _nc_altcharset_name(attr, CharOfD(buf))) != 0) {
-               (void) strcpy(tp, found);
-               tp += strlen(tp);
-               attr &= ~A_ALTCHARSET;
-           } else if (!isnac(CHDEREF(buf))) {
-               PUTC_DATA;
-
-               memset(&PUT_st, '\0', sizeof(PUT_st));
-               PUTC_i = 0;
-               do {
-                   PUTC_ch = PUTC_i < CCHARW_MAX ? buf->chars[PUTC_i] : L'\0';
-                   PUTC_n = wcrtomb(PUTC_buf, buf->chars[PUTC_i], &PUT_st);
-                   if (PUTC_ch == L'\0')
-                       --PUTC_n;
-                   if (PUTC_n <= 0)
-                       break;
-                   for (n = 0; n < PUTC_n; n++) {
-                       tp = _nc_vischar(tp, UChar(PUTC_buf[n]));
+    return _nc_viswbuf2(0, mybuf);
+}
+#endif /* USE_WIDEC_SUPPORT */
+
+/* use these functions for displaying parts of a line within a window */
+NCURSES_EXPORT(const char *)
+_nc_viscbuf2(int bufnum, const NCURSES_CH_T * buf, int len)
+{
+    char *result = _nc_trace_buf(bufnum, (size_t) BUFSIZ);
+
+    if (result != 0) {
+       int first = 0;
+
+#if USE_WIDEC_SUPPORT
+       if (len < 0)
+           len = _nc_wchstrlen(buf);
+#endif /* USE_WIDEC_SUPPORT */
+
+       /*
+        * Display one or more strings followed by attributes.
+        */
+       while (first < len) {
+           attr_t attr = AttrOf(buf[first]);
+           int last = len - 1;
+           int j;
+
+           for (j = first + 1; j < len; ++j) {
+               if (!SameAttrOf(buf[j], buf[first])) {
+                   last = j - 1;
+                   break;
+               }
+           }
+
+           (void) _nc_trace_bufcat(bufnum, l_brace);
+           (void) _nc_trace_bufcat(bufnum, d_quote);
+           for (j = first; j <= last; ++j) {
+               const char *found = _nc_altcharset_name(attr, (chtype)
+                                                       CharOf(buf[j]));
+               if (found != 0) {
+                   (void) _nc_trace_bufcat(bufnum, found);
+                   attr &= ~A_ALTCHARSET;
+               } else
+#if USE_WIDEC_SUPPORT
+               if (!isWidecExt(buf[j])) {
+                   PUTC_DATA;
+
+                   for (PUTC_i = 0; PUTC_i < CCHARW_MAX; ++PUTC_i) {
+                       int k;
+                       char temp[80];
+
+                       PUTC_ch = buf[j].chars[PUTC_i];
+                       if (PUTC_ch == L'\0') {
+                           if (PUTC_i == 0)
+                               (void) _nc_trace_bufcat(bufnum, "\\000");
+                           break;
+                       }
+                       PUTC_INIT;
+                       PUTC_n = (int) wcrtomb(PUTC_buf,
+                                              buf[j].chars[PUTC_i], &PUT_st);
+                       if (PUTC_n <= 0 || buf[j].chars[PUTC_i] > 255) {
+                           _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
+                                       "{%d:\\u%lx}",
+                                       wcwidth(buf[j].chars[PUTC_i]),
+                                       (unsigned long) buf[j].chars[PUTC_i]);
+                           (void) _nc_trace_bufcat(bufnum, temp);
+                           break;
+                       }
+                       for (k = 0; k < PUTC_n; k++) {
+                           VisChar(temp, UChar(PUTC_buf[k]), sizeof(temp));
+                           (void) _nc_trace_bufcat(bufnum, temp);
+                       }
                    }
                    }
-                   ++PUTC_i;
-               } while (PUTC_ch != L'\0');
+               }
+#else
+               {
+                   char temp[80];
+                   VisChar(temp, UChar(buf[j]), sizeof(temp));
+                   (void) _nc_trace_bufcat(bufnum, temp);
+               }
+#endif /* USE_WIDEC_SUPPORT */
            }
            }
-           buf++;
-       }
-       *tp++ = D_QUOTE;
-       *tp++ = '\0';
-       if (attr != A_NORMAL)
-           (void) sprintf(tp, " | %s",
-                          _traceattr2(bufnum + 20, attr));
-    } else {
-       *tp++ = L_BRACE;
-       while (len-- > 0) {
-           char *temp = _tracecchar_t2(bufnum + 20, buf++);
-           size_t used = (tp - result);
-           size_t want = strlen(temp) + 5 + used;
-           if (want > have) {
-               result = _nc_trace_buf(bufnum, have = want);
-               tp = result + used;
+           (void) _nc_trace_bufcat(bufnum, d_quote);
+           if (attr != A_NORMAL) {
+               (void) _nc_trace_bufcat(bufnum, " | ");
+               (void) _nc_trace_bufcat(bufnum, _traceattr2(bufnum + 20, attr));
            }
            }
-           (void) strcpy(tp, temp);
-           tp += strlen(tp);
+           result = _nc_trace_bufcat(bufnum, r_brace);
+           first = last + 1;
        }
        }
-       *tp++ = R_BRACE;
-       *tp++ = '\0';
     }
     return result;
 }
 
 NCURSES_EXPORT(const char *)
     }
     return result;
 }
 
 NCURSES_EXPORT(const char *)
-_nc_viscbuf(const cchar_t * buf, int len)
+_nc_viscbuf(const NCURSES_CH_T * buf, int len)
 {
     return _nc_viscbuf2(0, buf, len);
 }
 #endif /* TRACE */
 {
     return _nc_viscbuf2(0, buf, len);
 }
 #endif /* TRACE */
-#endif /* USE_WIDEC_SUPPORT */