ncurses 6.2 - patch 20210403
[ncurses.git] / ncurses / trace / visbuf.c
1 /****************************************************************************
2  * Copyright 2019-2020,2021 Thomas E. Dickey                                *
3  * Copyright 2001-2016,2017 Free Software Foundation, Inc.                  *
4  *                                                                          *
5  * Permission is hereby granted, free of charge, to any person obtaining a  *
6  * copy of this software and associated documentation files (the            *
7  * "Software"), to deal in the Software without restriction, including      *
8  * without limitation the rights to use, copy, modify, merge, publish,      *
9  * distribute, distribute with modifications, sublicense, and/or sell       *
10  * copies of the Software, and to permit persons to whom the Software is    *
11  * furnished to do so, subject to the following conditions:                 *
12  *                                                                          *
13  * The above copyright notice and this permission notice shall be included  *
14  * in all copies or substantial portions of the Software.                   *
15  *                                                                          *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
23  *                                                                          *
24  * Except as contained in this notice, the name(s) of the above copyright   *
25  * holders shall not be used in advertising or otherwise to promote the     *
26  * sale, use or other dealings in this Software without prior written       *
27  * authorization.                                                           *
28  ****************************************************************************/
29
30 /****************************************************************************
31  *  Author: Thomas E. Dickey                        1996-on                 *
32  *     and: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
33  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
34  ****************************************************************************/
35
36 /*
37  *      visbuf.c - Tracing/Debugging support routines
38  */
39
40 #define NEED_NCURSES_CH_T
41 #include <curses.priv.h>
42
43 #include <tic.h>
44 #include <ctype.h>
45
46 MODULE_ID("$Id: visbuf.c,v 1.53 2021/02/27 20:07:57 tom Exp $")
47
48 #define NUM_VISBUFS 4
49
50 #define NormalLen(len) (size_t) (((size_t)(len) + 1) * 4)
51 #define WideLen(len)   (size_t) (((size_t)(len) + 1) * 4 * (size_t) MB_CUR_MAX)
52
53 #ifdef TRACE
54 static const char d_quote[] = StringOf(D_QUOTE);
55 static const char l_brace[] = StringOf(L_BRACE);
56 static const char r_brace[] = StringOf(R_BRACE);
57 #endif
58
59 #if USE_STRING_HACKS && HAVE_SNPRINTF
60 #define VisChar(tp, chr, limit) _nc_vischar(tp, chr, limit)
61 #define LIMIT_ARG ,size_t limit
62 #else
63 #define VisChar(tp, chr, limit) _nc_vischar(tp, chr)
64 #define LIMIT_ARG               /* nothing */
65 #endif
66
67 static char *
68 _nc_vischar(char *tp, unsigned c LIMIT_ARG)
69 {
70     if (c == '"' || c == '\\') {
71         *tp++ = '\\';
72         *tp++ = (char) c;
73     } else if (is7bits((int) c) && (isgraph((int) c) || c == ' ')) {
74         *tp++ = (char) c;
75     } else if (c == '\n') {
76         *tp++ = '\\';
77         *tp++ = 'n';
78     } else if (c == '\r') {
79         *tp++ = '\\';
80         *tp++ = 'r';
81     } else if (c == '\b') {
82         *tp++ = '\\';
83         *tp++ = 'b';
84     } else if (c == '\t') {
85         *tp++ = '\\';
86         *tp++ = 't';
87     } else if (c == '\033') {
88         *tp++ = '\\';
89         *tp++ = 'e';
90     } else if (UChar(c) == 0x7f) {
91         *tp++ = '\\';
92         *tp++ = '^';
93         *tp++ = '?';
94     } else if (is7bits(c) && iscntrl(UChar(c))) {
95         *tp++ = '\\';
96         *tp++ = '^';
97         *tp++ = (char) ('@' + c);
98     } else {
99         _nc_SPRINTF(tp, _nc_SLIMIT(limit)
100                     "\\%03lo", (unsigned long) ChCharOf(c));
101         tp += strlen(tp);
102     }
103     *tp = 0;
104     return tp;
105 }
106
107 static const char *
108 _nc_visbuf2n(int bufnum, const char *buf, int len)
109 {
110     const char *vbuf = 0;
111     char *tp;
112     int count;
113
114     if (buf == 0)
115         return ("(null)");
116     if (buf == CANCELLED_STRING)
117         return ("(cancelled)");
118
119     if (len < 0)
120         len = (int) strlen(buf);
121
122     count = len;
123 #ifdef TRACE
124     vbuf = tp = _nc_trace_buf(bufnum, NormalLen(len));
125 #else
126     {
127         static char *mybuf[NUM_VISBUFS];
128         int c;
129
130         if (bufnum < 0) {
131             for (c = 0; c < NUM_VISBUFS; ++c) {
132                 FreeAndNull(mybuf[c]);
133             }
134             tp = 0;
135         } else {
136             mybuf[bufnum] = typeRealloc(char, NormalLen(len), mybuf[bufnum]);
137             vbuf = tp = mybuf[bufnum];
138         }
139     }
140 #endif
141     if (tp != 0) {
142         int c;
143
144         *tp++ = D_QUOTE;
145         while ((--count >= 0) && (c = *buf++) != '\0') {
146             tp = VisChar(tp, UChar(c), NormalLen(len));
147         }
148         *tp++ = D_QUOTE;
149         *tp = '\0';
150     } else {
151         vbuf = ("(_nc_visbuf2n failed)");
152     }
153     return (vbuf);
154 }
155
156 NCURSES_EXPORT(const char *)
157 _nc_visbuf2(int bufnum, const char *buf)
158 {
159     return _nc_visbuf2n(bufnum, buf, -1);
160 }
161
162 NCURSES_EXPORT(const char *)
163 _nc_visbuf(const char *buf)
164 {
165     return _nc_visbuf2(0, buf);
166 }
167
168 NCURSES_EXPORT(const char *)
169 _nc_visbufn(const char *buf, int len)
170 {
171     return _nc_visbuf2n(0, buf, len);
172 }
173
174 #ifdef TRACE
175 #if USE_WIDEC_SUPPORT
176
177 #if defined(USE_TERMLIB)
178 #define _nc_wchstrlen _my_wchstrlen
179 static int
180 _nc_wchstrlen(const cchar_t *s)
181 {
182     int result = 0;
183     while (CharOf(s[result]) != L'\0') {
184         result++;
185     }
186     return result;
187 }
188 #endif
189
190 static const char *
191 _nc_viswbuf2n(int bufnum, const wchar_t *buf, int len)
192 {
193     const char *vbuf;
194     char *tp;
195     int count;
196
197     if (buf == 0)
198         return ("(null)");
199
200     if (len < 0)
201         len = (int) wcslen(buf);
202
203     count = len;
204 #ifdef TRACE
205     vbuf = tp = _nc_trace_buf(bufnum, WideLen(len));
206 #else
207     {
208         static char *mybuf[NUM_VISBUFS];
209         mybuf[bufnum] = typeRealloc(char, WideLen(len), mybuf[bufnum]);
210         vbuf = tp = mybuf[bufnum];
211     }
212 #endif
213     if (tp != 0) {
214         wchar_t c;
215
216         *tp++ = D_QUOTE;
217         while ((--count >= 0) && (c = *buf++) != '\0') {
218             char temp[CCHARW_MAX + 80];
219             int j = wctomb(temp, c), k;
220             if (j <= 0) {
221                 _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
222                             "\\u%08X", (unsigned) c);
223                 j = (int) strlen(temp);
224             }
225             for (k = 0; k < j; ++k) {
226                 tp = VisChar(tp, UChar(temp[k]), WideLen(len));
227             }
228         }
229         *tp++ = D_QUOTE;
230         *tp = '\0';
231     } else {
232         vbuf = ("(_nc_viswbuf2n failed)");
233     }
234     return (vbuf);
235 }
236
237 NCURSES_EXPORT(const char *)
238 _nc_viswbuf2(int bufnum, const wchar_t *buf)
239 {
240     return _nc_viswbuf2n(bufnum, buf, -1);
241 }
242
243 NCURSES_EXPORT(const char *)
244 _nc_viswbuf(const wchar_t *buf)
245 {
246     return _nc_viswbuf2(0, buf);
247 }
248
249 NCURSES_EXPORT(const char *)
250 _nc_viswbufn(const wchar_t *buf, int len)
251 {
252     return _nc_viswbuf2n(0, buf, len);
253 }
254
255 /* this special case is used for wget_wstr() */
256 NCURSES_EXPORT(const char *)
257 _nc_viswibuf(const wint_t *buf)
258 {
259     static wchar_t *mybuf;
260     static unsigned mylen;
261     unsigned n;
262
263     for (n = 0; buf[n] != 0; ++n) {
264         ;                       /* empty */
265     }
266     if (mylen < ++n) {
267         mylen = n + 80;
268         if (mybuf != 0)
269             mybuf = typeRealloc(wchar_t, mylen, mybuf);
270         else
271             mybuf = typeMalloc(wchar_t, mylen);
272     }
273     if (mybuf != 0) {
274         for (n = 0; buf[n] != 0; ++n) {
275             mybuf[n] = (wchar_t) buf[n];
276         }
277         mybuf[n] = L'\0';
278     }
279
280     return _nc_viswbuf2(0, mybuf);
281 }
282 #endif /* USE_WIDEC_SUPPORT */
283
284 /* use these functions for displaying parts of a line within a window */
285 NCURSES_EXPORT(const char *)
286 _nc_viscbuf2(int bufnum, const NCURSES_CH_T *buf, int len)
287 {
288     char *result = _nc_trace_buf(bufnum, (size_t) BUFSIZ);
289
290     if (result != 0) {
291         int first = 0;
292
293 #if USE_WIDEC_SUPPORT
294         if (len < 0)
295             len = _nc_wchstrlen(buf);
296 #endif /* USE_WIDEC_SUPPORT */
297
298         /*
299          * Display one or more strings followed by attributes.
300          */
301         while (first < len) {
302             attr_t attr = AttrOf(buf[first]);
303             int last = len - 1;
304             int j;
305
306             for (j = first + 1; j < len; ++j) {
307                 if (!SameAttrOf(buf[j], buf[first])) {
308                     last = j - 1;
309                     break;
310                 }
311             }
312
313             (void) _nc_trace_bufcat(bufnum, l_brace);
314             (void) _nc_trace_bufcat(bufnum, d_quote);
315             for (j = first; j <= last; ++j) {
316                 const char *found = _nc_altcharset_name(attr, (chtype)
317                                                         CharOf(buf[j]));
318                 if (found != 0) {
319                     (void) _nc_trace_bufcat(bufnum, found);
320                     attr &= ~A_ALTCHARSET;
321                 } else
322 #if USE_WIDEC_SUPPORT
323                 if (!isWidecExt(buf[j])) {
324                     PUTC_DATA;
325
326                     for (PUTC_i = 0; PUTC_i < CCHARW_MAX; ++PUTC_i) {
327                         int k;
328                         char temp[80];
329
330                         PUTC_ch = buf[j].chars[PUTC_i];
331                         if (PUTC_ch == L'\0') {
332                             if (PUTC_i == 0)
333                                 (void) _nc_trace_bufcat(bufnum, "\\000");
334                             break;
335                         }
336                         PUTC_INIT;
337                         PUTC_n = (int) wcrtomb(PUTC_buf,
338                                                buf[j].chars[PUTC_i], &PUT_st);
339                         if (PUTC_n <= 0 || buf[j].chars[PUTC_i] > 255) {
340                             _nc_SPRINTF(temp, _nc_SLIMIT(sizeof(temp))
341                                         "{%d:\\u%lx}",
342                                         _nc_wacs_width(buf[j].chars[PUTC_i]),
343                                         (unsigned long) buf[j].chars[PUTC_i]);
344                             (void) _nc_trace_bufcat(bufnum, temp);
345                             break;
346                         }
347                         for (k = 0; k < PUTC_n; k++) {
348                             VisChar(temp, UChar(PUTC_buf[k]), sizeof(temp));
349                             (void) _nc_trace_bufcat(bufnum, temp);
350                         }
351                     }
352                 }
353 #else
354                 {
355                     char temp[80];
356                     VisChar(temp, UChar(buf[j]), sizeof(temp));
357                     (void) _nc_trace_bufcat(bufnum, temp);
358                 }
359 #endif /* USE_WIDEC_SUPPORT */
360             }
361             (void) _nc_trace_bufcat(bufnum, d_quote);
362             if (attr != A_NORMAL) {
363                 (void) _nc_trace_bufcat(bufnum, " | ");
364                 (void) _nc_trace_bufcat(bufnum, _traceattr2(bufnum + 20, attr));
365             }
366             result = _nc_trace_bufcat(bufnum, r_brace);
367             first = last + 1;
368         }
369     }
370     return result;
371 }
372
373 NCURSES_EXPORT(const char *)
374 _nc_viscbuf(const NCURSES_CH_T *buf, int len)
375 {
376     return _nc_viscbuf2(0, buf, len);
377 }
378 #endif /* TRACE */