1 /****************************************************************************
2 * Copyright 2018-2022,2023 Thomas E. Dickey *
3 * Copyright 1998-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: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 *
32 * and: Eric S. Raymond <esr@snark.thyrsus.com> *
33 * and: Thomas E. Dickey 1996 on *
34 ****************************************************************************/
35
36 #define __INTERNAL_CAPS_VISIBLE
37 #include <progs.priv.h>
38
39 #include <dump_entry.h>
40 #include <termsort.h> /* this C file is generated */
41 #include <parametrized.h> /* so is this */
42
43 MODULE_ID("$Id: dump_entry.c,v 1.196 2023/05/27 20:13:10 tom Exp $")
44
45 #define DISCARD(string) string = ABSENT_STRING
46 #define PRINTF (void) printf
47 #define WRAPPED 32
48
49 #define OkIndex(index,array) ((int)(index) >= 0 && (int)(index) < (int) SIZEOF(array))
50 #define TcOutput() (outform == F_TERMCAP || outform == F_TCONVERR)
51
52 typedef struct {
53 char *text;
54 size_t used;
55 size_t size;
56 } DYNBUF;
57
58 static int tversion; /* terminfo version */
59 static int outform; /* output format to use */
60 static int sortmode; /* sort mode to use */
61 static int width = 60; /* max line width for listings */
62 static int height = 65535; /* max number of lines for listings */
63 static int column; /* current column, limited by 'width' */
64 static int oldcol; /* last value of column before wrap */
65 static bool pretty; /* true if we format if-then-else strings */
66 static bool wrapped; /* true if we wrap too-long strings */
67 static bool did_wrap; /* true if last wrap_concat did wrapping */
68 static bool checking; /* true if we are checking for tic */
69 static int quickdump; /* true if we are dumping compiled data */
70
71 static char *save_sgr;
72
73 static DYNBUF outbuf;
74 static DYNBUF tmpbuf;
75
76 /* indirection pointers for implementing sort and display modes */
77 static const PredIdx *bool_indirect, *num_indirect, *str_indirect;
78 static NCURSES_CONST char *const *bool_names;
79 static NCURSES_CONST char *const *num_names;
80 static NCURSES_CONST char *const *str_names;
81
82 static const char *separator = "", *trailer = "";
83 static int indent = 8;
84
85 /* cover various ports and variants of terminfo */
86 #define V_ALLCAPS 0 /* all capabilities (SVr4, XSI, ncurses) */
87 #define V_SVR1 1 /* SVR1, Ultrix */
88 #define V_HPUX 2 /* HP-UX */
89 #define V_AIX 3 /* AIX */
90 #define V_BSD 4 /* BSD */
91
92 #if NCURSES_XNAMES
93 #define OBSOLETE(n) (!_nc_user_definable && (n[0] == 'O' && n[1] == 'T'))
94 #else
95 #define OBSOLETE(n) (n[0] == 'O' && n[1] == 'T')
96 #endif
97
98 #define isObsolete(f,n) ((f == F_TERMINFO || f == F_VARIABLE) && (sortmode != S_VARIABLE) && OBSOLETE(n))
99
100 #if NCURSES_XNAMES
101 #define BoolIndirect(j) ((j >= BOOLCOUNT) ? (j) : ((sortmode == S_NOSORT) ? j : bool_indirect[j]))
102 #define NumIndirect(j) ((j >= NUMCOUNT) ? (j) : ((sortmode == S_NOSORT) ? j : num_indirect[j]))
103 #define StrIndirect(j) ((j >= STRCOUNT) ? (j) : ((sortmode == S_NOSORT) ? j : str_indirect[j]))
104 #else
105 #define BoolIndirect(j) ((sortmode == S_NOSORT) ? (j) : bool_indirect[j])
106 #define NumIndirect(j) ((sortmode == S_NOSORT) ? (j) : num_indirect[j])
107 #define StrIndirect(j) ((sortmode == S_NOSORT) ? (j) : str_indirect[j])
108 #endif
109
110 static GCC_NORETURN void
failed(const char * s)111 failed(const char *s)
112 {
113 perror(s);
114 ExitProgram(EXIT_FAILURE);
115 }
116
117 static void
strncpy_DYN(DYNBUF * dst,const char * src,size_t need)118 strncpy_DYN(DYNBUF * dst, const char *src, size_t need)
119 {
120 size_t want = need + dst->used + 1;
121 if (want > dst->size) {
122 dst->size += (want + 1024); /* be generous */
123 dst->text = typeRealloc(char, dst->size, dst->text);
124 if (dst->text == 0)
125 failed("strncpy_DYN");
126 }
127 _nc_STRNCPY(dst->text + dst->used, src, need + 1);
128 dst->used += need;
129 dst->text[dst->used] = 0;
130 }
131
132 static void
strcpy_DYN(DYNBUF * dst,const char * src)133 strcpy_DYN(DYNBUF * dst, const char *src)
134 {
135 if (src == 0) {
136 dst->used = 0;
137 strcpy_DYN(dst, "");
138 } else {
139 strncpy_DYN(dst, src, strlen(src));
140 }
141 }
142
143 #if NO_LEAKS
144 static void
free_DYN(DYNBUF * p)145 free_DYN(DYNBUF * p)
146 {
147 if (p->text != 0)
148 free(p->text);
149 p->text = 0;
150 p->size = 0;
151 p->used = 0;
152 }
153
154 void
_nc_leaks_dump_entry(void)155 _nc_leaks_dump_entry(void)
156 {
157 free_DYN(&outbuf);
158 free_DYN(&tmpbuf);
159 }
160 #endif
161
162 #define NameTrans(check,result) \
163 if ((np->nte_index <= OK_ ## check) \
164 && check[np->nte_index]) \
165 return (result[np->nte_index])
166
167 NCURSES_CONST char *
nametrans(const char * name)168 nametrans(const char *name)
169 /* translate a capability name to termcap from terminfo */
170 {
171 const struct name_table_entry *np;
172
173 if ((np = _nc_find_entry(name, _nc_get_hash_table(0))) != 0) {
174 switch (np->nte_type) {
175 case BOOLEAN:
176 NameTrans(bool_from_termcap, boolcodes);
177 break;
178
179 case NUMBER:
180 NameTrans(num_from_termcap, numcodes);
181 break;
182
183 case STRING:
184 NameTrans(str_from_termcap, strcodes);
185 break;
186 }
187 }
188
189 return (0);
190 }
191
192 void
dump_init(const char * version,int mode,int sort,bool wrap_strings,int twidth,int theight,unsigned traceval,bool formatted,bool check,int quick)193 dump_init(const char *version,
194 int mode,
195 int sort,
196 bool wrap_strings,
197 int twidth,
198 int theight,
199 unsigned traceval,
200 bool formatted,
201 bool check,
202 int quick)
203 /* set up for entry display */
204 {
205 width = twidth;
206 height = theight;
207 pretty = formatted;
208 wrapped = wrap_strings;
209 checking = check;
210 quickdump = (quick & 3);
211
212 did_wrap = (width <= 0);
213
214 /* versions */
215 if (version == 0)
216 tversion = V_ALLCAPS;
217 else if (!strcmp(version, "SVr1") || !strcmp(version, "SVR1")
218 || !strcmp(version, "Ultrix"))
219 tversion = V_SVR1;
220 else if (!strcmp(version, "HP"))
221 tversion = V_HPUX;
222 else if (!strcmp(version, "AIX"))
223 tversion = V_AIX;
224 else if (!strcmp(version, "BSD"))
225 tversion = V_BSD;
226 else
227 tversion = V_ALLCAPS;
228
229 /* implement display modes */
230 switch (outform = mode) {
231 case F_LITERAL:
232 case F_TERMINFO:
233 bool_names = boolnames;
234 num_names = numnames;
235 str_names = strnames;
236 separator = (twidth > 0 && theight > 1) ? ", " : ",";
237 trailer = "\n\t";
238 break;
239
240 case F_VARIABLE:
241 bool_names = boolfnames;
242 num_names = numfnames;
243 str_names = strfnames;
244 separator = (twidth > 0 && theight > 1) ? ", " : ",";
245 trailer = "\n\t";
246 break;
247
248 case F_TERMCAP:
249 case F_TCONVERR:
250 bool_names = boolcodes;
251 num_names = numcodes;
252 str_names = strcodes;
253 separator = ":";
254 trailer = "\\\n\t:";
255 break;
256 }
257 indent = 8;
258
259 /* implement sort modes */
260 switch (sortmode = sort) {
261 case S_NOSORT:
262 if (traceval)
263 (void) fprintf(stderr,
264 "%s: sorting by term structure order\n", _nc_progname);
265 break;
266
267 case S_TERMINFO:
268 if (traceval)
269 (void) fprintf(stderr,
270 "%s: sorting by terminfo name order\n", _nc_progname);
271 bool_indirect = bool_terminfo_sort;
272 num_indirect = num_terminfo_sort;
273 str_indirect = str_terminfo_sort;
274 break;
275
276 case S_VARIABLE:
277 if (traceval)
278 (void) fprintf(stderr,
279 "%s: sorting by C variable order\n", _nc_progname);
280 bool_indirect = bool_variable_sort;
281 num_indirect = num_variable_sort;
282 str_indirect = str_variable_sort;
283 break;
284
285 case S_TERMCAP:
286 if (traceval)
287 (void) fprintf(stderr,
288 "%s: sorting by termcap name order\n", _nc_progname);
289 bool_indirect = bool_termcap_sort;
290 num_indirect = num_termcap_sort;
291 str_indirect = str_termcap_sort;
292 break;
293 }
294
295 if (traceval)
296 (void) fprintf(stderr,
297 "%s: width = %d, tversion = %d, outform = %d\n",
298 _nc_progname, width, tversion, outform);
299 }
300
301 static TERMTYPE2 *cur_type;
302
303 static int
dump_predicate(PredType type,PredIdx idx)304 dump_predicate(PredType type, PredIdx idx)
305 /* predicate function to use for ordinary decompilation */
306 {
307 switch (type) {
308 case BOOLEAN:
309 return (cur_type->Booleans[idx] == FALSE)
310 ? FAIL : cur_type->Booleans[idx];
311
312 case NUMBER:
313 return (cur_type->Numbers[idx] == ABSENT_NUMERIC)
314 ? FAIL : cur_type->Numbers[idx];
315
316 case STRING:
317 return (cur_type->Strings[idx] != ABSENT_STRING)
318 ? (int) TRUE : FAIL;
319 }
320
321 return (FALSE); /* pacify compiler */
322 }
323
324 static void set_obsolete_termcaps(TERMTYPE2 *tp);
325
326 /* is this the index of a function key string? */
327 #define FNKEY(i) \
328 (((i) >= STR_IDX(key_f0) && \
329 (i) <= STR_IDX(key_f9)) || \
330 ((i) >= STR_IDX(key_f11) && \
331 (i) <= STR_IDX(key_f63)))
332
333 /*
334 * If we configure with a different Caps file, the offsets into the arrays
335 * will change. So we use an address expression.
336 */
337 #define BOOL_IDX(name) (PredType) (&(name) - &(CUR Booleans[0]))
338 #define NUM_IDX(name) (PredType) (&(name) - &(CUR Numbers[0]))
339 #define STR_IDX(name) (PredType) (&(name) - &(CUR Strings[0]))
340
341 static bool
version_filter(PredType type,PredIdx idx)342 version_filter(PredType type, PredIdx idx)
343 /* filter out capabilities we may want to suppress */
344 {
345 switch (tversion) {
346 case V_ALLCAPS: /* SVr4, XSI Curses */
347 return (TRUE);
348
349 case V_SVR1: /* System V Release 1, Ultrix */
350 switch (type) {
351 case BOOLEAN:
352 return ((idx <= BOOL_IDX(xon_xoff)) ? TRUE : FALSE);
353 case NUMBER:
354 return ((idx <= NUM_IDX(width_status_line)) ? TRUE : FALSE);
355 case STRING:
356 return ((idx <= STR_IDX(prtr_non)) ? TRUE : FALSE);
357 }
358 break;
359
360 case V_HPUX: /* Hewlett-Packard */
361 switch (type) {
362 case BOOLEAN:
363 return ((idx <= BOOL_IDX(xon_xoff)) ? TRUE : FALSE);
364 case NUMBER:
365 return ((idx <= NUM_IDX(label_width)) ? TRUE : FALSE);
366 case STRING:
367 if (idx <= STR_IDX(prtr_non))
368 return (TRUE);
369 else if (FNKEY(idx)) /* function keys */
370 return (TRUE);
371 else if (idx == STR_IDX(plab_norm)
372 || idx == STR_IDX(label_on)
373 || idx == STR_IDX(label_off))
374 return (TRUE);
375 else
376 return (FALSE);
377 }
378 break;
379
380 case V_AIX: /* AIX */
381 switch (type) {
382 case BOOLEAN:
383 return ((idx <= BOOL_IDX(xon_xoff)) ? TRUE : FALSE);
384 case NUMBER:
385 return ((idx <= NUM_IDX(width_status_line)) ? TRUE : FALSE);
386 case STRING:
387 if (idx <= STR_IDX(prtr_non))
388 return (TRUE);
389 else if (FNKEY(idx)) /* function keys */
390 return (TRUE);
391 else
392 return (FALSE);
393 }
394 break;
395
396 #define is_termcap(type) (OkIndex(idx, type##_from_termcap) && \
397 type##_from_termcap[idx])
398
399 case V_BSD: /* BSD */
400 switch (type) {
401 case BOOLEAN:
402 return is_termcap(bool);
403 case NUMBER:
404 return is_termcap(num);
405 case STRING:
406 return is_termcap(str);
407 }
408 break;
409 }
410
411 return (FALSE); /* pacify the compiler */
412 }
413
414 static void
trim_trailing(void)415 trim_trailing(void)
416 {
417 while (outbuf.used > 0 && outbuf.text[outbuf.used - 1] == ' ')
418 outbuf.text[--outbuf.used] = '\0';
419 }
420
421 static void
force_wrap(void)422 force_wrap(void)
423 {
424 oldcol = column;
425 trim_trailing();
426 strcpy_DYN(&outbuf, trailer);
427 column = indent;
428 }
429
430 static int
op_length(const char * src,int offset)431 op_length(const char *src, int offset)
432 {
433 int result = 0;
434
435 if (offset > 0 && src[offset - 1] == '\\') {
436 result = 0;
437 } else {
438 int ch;
439
440 result++; /* for '%' mark */
441 ch = src[offset + result];
442 if (TcOutput()) {
443 if (ch == '>') {
444 result += 3;
445 } else if (ch == '+') {
446 result += 2;
447 } else {
448 result++;
449 }
450 } else if (ch == '\'') {
451 result += 3;
452 } else if (ch == L_CURL[0]) {
453 int n = result;
454 while ((ch = src[offset + n]) != '\0') {
455 if (ch == R_CURL[0]) {
456 result = ++n;
457 break;
458 }
459 n++;
460 }
461 } else if (strchr("pPg", ch) != 0) {
462 result += 2;
463 } else {
464 result++; /* ordinary operator */
465 }
466 }
467 return result;
468 }
469
470 /*
471 * When wrapping too-long strings, avoid splitting a backslash sequence, or
472 * a terminfo '%' operator. That will leave things a little ragged, but avoids
473 * a stray backslash at the end of the line, as well as making the result a
474 * little more readable.
475 */
476 static int
find_split(const char * src,int step,int size)477 find_split(const char *src, int step, int size)
478 {
479 int result = size;
480
481 if (size > 0) {
482 /* check if that would split a backslash-sequence */
483 int mark = size;
484 int n;
485
486 for (n = size - 1; n > 0; --n) {
487 int ch = UChar(src[step + n]);
488 if (ch == '\\') {
489 if (n > 0 && src[step + n - 1] == ch)
490 --n;
491 mark = n;
492 break;
493 } else if (!isalnum(ch)) {
494 break;
495 }
496 }
497 if (mark < size) {
498 result = mark;
499 } else {
500 /* check if that would split a backslash-sequence */
501 for (n = size - 1; n > 0; --n) {
502 int ch = UChar(src[step + n]);
503 if (ch == '%') {
504 int need = op_length(src, step + n);
505 if ((n + need) > size) {
506 mark = n;
507 }
508 break;
509 }
510 }
511 if (mark < size) {
512 result = mark;
513 }
514 }
515 }
516 return result;
517 }
518
519 /*
520 * If we are going to wrap lines, we cannot leave literal spaces because that
521 * would be ambiguous if we split on that space.
522 */
523 static char *
fill_spaces(const char * src)524 fill_spaces(const char *src)
525 {
526 const char *fill = "\\s";
527 size_t need = strlen(src);
528 size_t size = strlen(fill);
529 char *result = 0;
530 int pass;
531 size_t s, d;
532 for (pass = 0; pass < 2; ++pass) {
533 for (s = d = 0; src[s] != '\0'; ++s) {
534 if (src[s] == ' ') {
535 if (pass) {
536 _nc_STRCPY(&result[d], fill, need + 1 - d);
537 d += size;
538 } else {
539 need += size;
540 }
541 } else {
542 if (pass) {
543 result[d++] = src[s];
544 } else {
545 ++d;
546 }
547 }
548 }
549 if (pass) {
550 result[d] = '\0';
551 } else {
552 result = calloc(need + 1, sizeof(char));
553 if (result == 0)
554 failed("fill_spaces");
555 }
556 }
557 return result;
558 }
559
560 typedef enum {
561 wOFF = 0
562 ,w1ST = 1
563 ,w2ND = 2
564 ,wEND = 4
565 ,wERR = 8
566 } WRAPMODE;
567
568 #define wrap_1ST(mode) ((mode)&w1ST)
569 #define wrap_END(mode) ((mode)&wEND)
570 #define wrap_ERR(mode) ((mode)&wERR)
571
572 static void
wrap_concat(const char * src,int need,unsigned mode)573 wrap_concat(const char *src, int need, unsigned mode)
574 {
575 int gaps = (int) strlen(separator);
576 int want = gaps + need;
577
578 did_wrap = (width <= 0);
579 if (wrap_1ST(mode)
580 && column > indent
581 && column + want > width) {
582 force_wrap();
583 }
584 if ((wrap_END(mode) && !wrap_ERR(mode)) &&
585 wrapped &&
586 (width >= 0) &&
587 (column + want) > width) {
588 int step = 0;
589 int used = width > WRAPPED ? width : WRAPPED;
590 int base = 0;
591 char *p, align[9];
592 const char *my_t = trailer;
593 char *fill = fill_spaces(src);
594 int last = (int) strlen(fill);
595
596 need = last;
597
598 if (TcOutput())
599 trailer = "\\\n\t ";
600
601 if (!TcOutput() && (p = strchr(fill, '=')) != 0) {
602 base = (int) (p + 1 - fill);
603 if (base > 8)
604 base = 8;
605 _nc_SPRINTF(align, _nc_SLIMIT(align) "%*s", base, " ");
606 } else if (column > 8) {
607 base = column - 8;
608 if (base > 8)
609 base = 8;
610 _nc_SPRINTF(align, _nc_SLIMIT(align) "%*s", base, " ");
611 } else {
612 align[base] = '\0';
613 }
614 /* "pretty" overrides wrapping if it already split the line */
615 if (!pretty || strchr(fill, '\n') == 0) {
616 int tag = 0;
617
618 if (TcOutput() && outbuf.used && !wrap_1ST(mode)) {
619 tag = 3;
620 }
621
622 while ((column + (need + gaps)) > used) {
623 int size = used - tag;
624 if (step) {
625 strcpy_DYN(&outbuf, align);
626 size -= base;
627 }
628 if (size > (last - step)) {
629 size = (last - step);
630 }
631 size = find_split(fill, step, size);
632 strncpy_DYN(&outbuf, fill + step, (size_t) size);
633 step += size;
634 need -= size;
635 if (need > 0) {
636 force_wrap();
637 did_wrap = TRUE;
638 tag = 0;
639 }
640 }
641 }
642 if (need > 0) {
643 if (step)
644 strcpy_DYN(&outbuf, align);
645 strcpy_DYN(&outbuf, fill + step);
646 }
647 if (wrap_END(mode))
648 strcpy_DYN(&outbuf, separator);
649 trailer = my_t;
650 force_wrap();
651
652 free(fill);
653 } else {
654 strcpy_DYN(&outbuf, src);
655 if (wrap_END(mode))
656 strcpy_DYN(&outbuf, separator);
657 column += (int) strlen(src);
658 }
659 }
660
661 static void
wrap_concat1(const char * src)662 wrap_concat1(const char *src)
663 {
664 int need = (int) strlen(src);
665 wrap_concat(src, need, w1ST | wEND);
666 }
667
668 static void
wrap_concat3(const char * name,const char * eqls,const char * value)669 wrap_concat3(const char *name, const char *eqls, const char *value)
670 {
671 int nlen = (int) strlen(name);
672 int elen = (int) strlen(eqls);
673 int vlen = (int) strlen(value);
674
675 wrap_concat(name, nlen + elen + vlen, w1ST);
676 wrap_concat(eqls, elen + vlen, w2ND);
677 wrap_concat(value, vlen, wEND);
678 }
679
680 #define IGNORE_SEP_TRAIL(first,last,sep_trail) \
681 if ((size_t)(last - first) > sizeof(sep_trail)-1 \
682 && !strncmp(first, sep_trail, sizeof(sep_trail)-1)) \
683 first += sizeof(sep_trail)-2
684
685 /* Returns the nominal length of the buffer assuming it is termcap format,
686 * i.e., the continuation sequence is treated as a single character ":".
687 *
688 * There are several implementations of termcap which read the text into a
689 * fixed-size buffer. Generally they strip the newlines from the text, but may
690 * not do it until after the buffer is read. Also, "tc=" resolution may be
691 * expanded in the same buffer. This function is useful for measuring the size
692 * of the best fixed-buffer implementation; the worst case may be much worse.
693 */
694 #ifdef TEST_TERMCAP_LENGTH
695 static int
termcap_length(const char * src)696 termcap_length(const char *src)
697 {
698 static const char pattern[] = ":\\\n\t:";
699
700 int len = 0;
701 const char *const t = src + strlen(src);
702
703 while (*src != '\0') {
704 IGNORE_SEP_TRAIL(src, t, pattern);
705 src++;
706 len++;
707 }
708 return len;
709 }
710 #else
711 #define termcap_length(src) strlen(src)
712 #endif
713
714 static void
indent_DYN(DYNBUF * buffer,int level)715 indent_DYN(DYNBUF * buffer, int level)
716 {
717 int n;
718
719 for (n = 0; n < level; n++)
720 strncpy_DYN(buffer, "\t", (size_t) 1);
721 }
722
723 /*
724 * Check if the current line which was begun consists only of a tab and the
725 * given leading text.
726 */
727 static bool
leading_DYN(DYNBUF * buffer,const char * leading)728 leading_DYN(DYNBUF * buffer, const char *leading)
729 {
730 bool result = FALSE;
731 size_t need = strlen(leading);
732 if (buffer->used > need) {
733 need = buffer->used - need;
734 if (!strcmp(buffer->text + need, leading)) {
735 result = TRUE;
736 while (--need != 0) {
737 if (buffer->text[need] == '\n') {
738 break;
739 }
740 if (buffer->text[need] != '\t') {
741 result = FALSE;
742 break;
743 }
744 }
745 }
746 }
747 return result;
748 }
749
750 bool
has_params(const char * src,bool formatting)751 has_params(const char *src, bool formatting)
752 {
753 bool result = FALSE;
754 int len = (int) strlen(src);
755 int n;
756 bool ifthen = FALSE;
757 bool params = FALSE;
758
759 for (n = 0; n < len - 1; ++n) {
760 if (!strncmp(src + n, "%p", (size_t) 2)) {
761 params = TRUE;
762 } else if (!strncmp(src + n, "%;", (size_t) 2)) {
763 ifthen = TRUE;
764 result = params;
765 break;
766 }
767 }
768 if (!ifthen) {
769 if (formatting) {
770 result = ((len > 50) && params);
771 } else {
772 result = params;
773 }
774 }
775 return result;
776 }
777
778 static char *
fmt_complex(TERMTYPE2 * tterm,const char * capability,char * src,int level)779 fmt_complex(TERMTYPE2 *tterm, const char *capability, char *src, int level)
780 {
781 bool percent = FALSE;
782 bool params = has_params(src, TRUE);
783
784 while (*src != '\0') {
785 switch (*src) {
786 case '^':
787 percent = FALSE;
788 strncpy_DYN(&tmpbuf, src++, (size_t) 1);
789 break;
790 case '\\':
791 percent = FALSE;
792 strncpy_DYN(&tmpbuf, src++, (size_t) 1);
793 break;
794 case '%':
795 percent = TRUE;
796 break;
797 case '?': /* "if" */
798 case 't': /* "then" */
799 case 'e': /* "else" */
800 if (percent) {
801 percent = FALSE;
802 tmpbuf.text[tmpbuf.used - 1] = '\n';
803 /* treat a "%e" as else-if, on the same level */
804 if (*src == 'e') {
805 indent_DYN(&tmpbuf, level);
806 strncpy_DYN(&tmpbuf, "%", (size_t) 1);
807 strncpy_DYN(&tmpbuf, src, (size_t) 1);
808 src++;
809 params = has_params(src, TRUE);
810 if (!params && *src != '\0' && *src != '%') {
811 strncpy_DYN(&tmpbuf, "\n", (size_t) 1);
812 indent_DYN(&tmpbuf, level + 1);
813 }
814 } else {
815 indent_DYN(&tmpbuf, level + 1);
816 strncpy_DYN(&tmpbuf, "%", (size_t) 1);
817 strncpy_DYN(&tmpbuf, src, (size_t) 1);
818 if (*src++ == '?') {
819 src = fmt_complex(tterm, capability, src, level + 1);
820 if (*src != '\0' && *src != '%') {
821 strncpy_DYN(&tmpbuf, "\n", (size_t) 1);
822 indent_DYN(&tmpbuf, level + 1);
823 }
824 } else if (level == 1) {
825 if (checking)
826 _nc_warning("%s: %%%c without %%? in %s",
827 _nc_first_name(tterm->term_names),
828 *src, capability);
829 }
830 }
831 continue;
832 }
833 break;
834 case ';': /* "endif" */
835 if (percent) {
836 percent = FALSE;
837 if (level > 1) {
838 tmpbuf.text[tmpbuf.used - 1] = '\n';
839 indent_DYN(&tmpbuf, level);
840 strncpy_DYN(&tmpbuf, "%", (size_t) 1);
841 strncpy_DYN(&tmpbuf, src++, (size_t) 1);
842 if (src[0] == '%'
843 && src[1] != '\0'
844 && (strchr("?e;", src[1])) == 0) {
845 tmpbuf.text[tmpbuf.used++] = '\n';
846 indent_DYN(&tmpbuf, level);
847 }
848 return src;
849 }
850 if (checking)
851 _nc_warning("%s: %%; without %%? in %s",
852 _nc_first_name(tterm->term_names),
853 capability);
854 }
855 break;
856 case 'p':
857 if (percent && params && !leading_DYN(&tmpbuf, "%")) {
858 tmpbuf.text[tmpbuf.used - 1] = '\n';
859 indent_DYN(&tmpbuf, level + 1);
860 strncpy_DYN(&tmpbuf, "%", (size_t) 1);
861 }
862 percent = FALSE;
863 break;
864 case ' ':
865 strncpy_DYN(&tmpbuf, "\\s", (size_t) 2);
866 ++src;
867 continue;
868 default:
869 percent = FALSE;
870 break;
871 }
872 strncpy_DYN(&tmpbuf, src++, (size_t) 1);
873 }
874 return src;
875 }
876
877 /*
878 * Make "large" numbers a little easier to read by showing them in hexadecimal
879 * if they are "close" to a power of two.
880 */
881 static const char *
number_format(int value)882 number_format(int value)
883 {
884 const char *result = "%d";
885
886 if ((outform != F_TERMCAP) && (value > 255)) {
887 unsigned long lv = (unsigned long) value;
888 int bits = sizeof(unsigned long) * 8;
889 int nn;
890
891 for (nn = 8; nn < bits; ++nn) {
892 unsigned long mm;
893
894 mm = 1UL << nn;
895 if ((mm - 16) <= lv && (mm + 16) > lv) {
896 result = "%#x";
897 break;
898 }
899 }
900 }
901 return result;
902 }
903
904 #define SAME_CAP(n,cap) (&tterm->Strings[n] == &cap)
905 #define EXTRA_CAP 20
906
907 int
fmt_entry(TERMTYPE2 * tterm,PredFunc pred,int content_only,int suppress_untranslatable,int infodump,int numbers)908 fmt_entry(TERMTYPE2 *tterm,
909 PredFunc pred,
910 int content_only,
911 int suppress_untranslatable,
912 int infodump,
913 int numbers)
914 {
915 PredIdx i, j;
916 char buffer[MAX_TERMINFO_LENGTH + EXTRA_CAP];
917 NCURSES_CONST char *name;
918 int predval, len;
919 PredIdx num_bools = 0;
920 PredIdx num_values = 0;
921 PredIdx num_strings = 0;
922 bool outcount = 0;
923
924 #define WRAP_CONCAT1(s) wrap_concat1(s); outcount = TRUE
925 #define WRAP_CONCAT WRAP_CONCAT1(buffer)
926
927 len = 12; /* terminfo file-header */
928
929 if (pred == 0) {
930 cur_type = tterm;
931 pred = dump_predicate;
932 }
933
934 strcpy_DYN(&outbuf, 0);
935 if (content_only) {
936 column = indent; /* workaround to prevent empty lines */
937 } else {
938 strcpy_DYN(&outbuf, tterm->term_names);
939
940 /*
941 * Colon is legal in terminfo descriptions, but not in termcap.
942 */
943 if (!infodump) {
944 char *p = outbuf.text;
945 while (*p) {
946 if (*p == ':') {
947 *p = '=';
948 }
949 ++p;
950 }
951 }
952 strcpy_DYN(&outbuf, separator);
953 column = (int) outbuf.used;
954 if (height > 1)
955 force_wrap();
956 }
957
958 for_each_boolean(j, tterm) {
959 i = BoolIndirect(j);
960 name = ExtBoolname(tterm, (int) i, bool_names);
961 assert(strlen(name) < sizeof(buffer) - EXTRA_CAP);
962
963 if (!version_filter(BOOLEAN, i))
964 continue;
965 else if (isObsolete(outform, name))
966 continue;
967
968 predval = pred(BOOLEAN, i);
969 if (predval != FAIL) {
970 _nc_STRCPY(buffer, name, sizeof(buffer));
971 if (predval <= 0)
972 _nc_STRCAT(buffer, "@", sizeof(buffer));
973 else if (i + 1 > num_bools)
974 num_bools = i + 1;
975 WRAP_CONCAT;
976 }
977 }
978
979 if (column != indent && height > 1)
980 force_wrap();
981
982 for_each_number(j, tterm) {
983 i = NumIndirect(j);
984 name = ExtNumname(tterm, (int) i, num_names);
985 assert(strlen(name) < sizeof(buffer) - EXTRA_CAP);
986
987 if (!version_filter(NUMBER, i))
988 continue;
989 else if (isObsolete(outform, name))
990 continue;
991
992 predval = pred(NUMBER, i);
993 if (predval != FAIL) {
994 if (tterm->Numbers[i] < 0) {
995 _nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
996 "%s@", name);
997 } else {
998 size_t nn;
999 _nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
1000 "%s#", name);
1001 nn = strlen(buffer);
1002 _nc_SPRINTF(buffer + nn, _nc_SLIMIT(sizeof(buffer) - nn)
1003 number_format(tterm->Numbers[i]),
1004 tterm->Numbers[i]);
1005 if (i + 1 > num_values)
1006 num_values = i + 1;
1007 }
1008 WRAP_CONCAT;
1009 }
1010 }
1011
1012 if (column != indent && height > 1)
1013 force_wrap();
1014
1015 len += (int) (num_bools
1016 + num_values * 2
1017 + strlen(tterm->term_names) + 1);
1018 if (len & 1)
1019 len++;
1020
1021 #undef CUR
1022 #define CUR tterm->
1023 if (outform == F_TERMCAP) {
1024 if (VALID_STRING(termcap_reset)) {
1025 if (VALID_STRING(init_3string)
1026 && !strcmp(init_3string, termcap_reset))
1027 DISCARD(init_3string);
1028
1029 if (VALID_STRING(reset_2string)
1030 && !strcmp(reset_2string, termcap_reset))
1031 DISCARD(reset_2string);
1032 }
1033 }
1034
1035 for_each_string(j, tterm) {
1036 char *capability;
1037 i = StrIndirect(j);
1038 name = ExtStrname(tterm, (int) i, str_names);
1039 assert(strlen(name) < sizeof(buffer) - EXTRA_CAP);
1040
1041 capability = tterm->Strings[i];
1042
1043 if (!version_filter(STRING, i))
1044 continue;
1045 else if (isObsolete(outform, name))
1046 continue;
1047
1048 #if NCURSES_XNAMES
1049 /*
1050 * Extended names can be longer than 2 characters, but termcap programs
1051 * cannot read those (filter them out).
1052 */
1053 if (outform == F_TERMCAP && (strlen(name) > 2))
1054 continue;
1055 #endif
1056
1057 if (outform == F_TERMCAP) {
1058 /*
1059 * Some older versions of vi want rmir/smir to be defined
1060 * for ich/ich1 to work. If they're not defined, force
1061 * them to be output as defined and empty.
1062 */
1063 if (PRESENT(insert_character) || PRESENT(parm_ich)) {
1064 if (SAME_CAP(i, enter_insert_mode)
1065 && enter_insert_mode == ABSENT_STRING) {
1066 _nc_STRCPY(buffer, "im=", sizeof(buffer));
1067 WRAP_CONCAT;
1068 continue;
1069 }
1070
1071 if (SAME_CAP(i, exit_insert_mode)
1072 && exit_insert_mode == ABSENT_STRING) {
1073 _nc_STRCPY(buffer, "ei=", sizeof(buffer));
1074 WRAP_CONCAT;
1075 continue;
1076 }
1077 }
1078 /*
1079 * termcap applications such as screen will be confused if sgr0
1080 * is translated to a string containing rmacs. Filter that out.
1081 */
1082 if (PRESENT(exit_attribute_mode)) {
1083 if (SAME_CAP(i, exit_attribute_mode)) {
1084 char *trimmed_sgr0;
1085 char *my_sgr = set_attributes;
1086
1087 set_attributes = save_sgr;
1088
1089 trimmed_sgr0 = _nc_trim_sgr0(tterm);
1090 if (strcmp(capability, trimmed_sgr0)) {
1091 capability = trimmed_sgr0;
1092 } else {
1093 if (trimmed_sgr0 != exit_attribute_mode)
1094 free(trimmed_sgr0);
1095 }
1096
1097 set_attributes = my_sgr;
1098 }
1099 }
1100 }
1101
1102 predval = pred(STRING, i);
1103 buffer[0] = '\0';
1104
1105 if (predval != FAIL) {
1106 if (VALID_STRING(capability)
1107 && i + 1 > num_strings)
1108 num_strings = i + 1;
1109
1110 if (!VALID_STRING(capability)) {
1111 _nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
1112 "%s@", name);
1113 WRAP_CONCAT;
1114 } else if (TcOutput()) {
1115 char *srccap = _nc_tic_expand(capability, TRUE, numbers);
1116 int params = ((i < (int) SIZEOF(parametrized))
1117 ? parametrized[i]
1118 : ((*srccap == 'k')
1119 ? 0
1120 : has_params(srccap, FALSE)));
1121 char *cv = _nc_infotocap(name, srccap, params);
1122
1123 if (cv == 0) {
1124 if (outform == F_TCONVERR) {
1125 _nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
1126 "%s=!!! %s WILL NOT CONVERT !!!",
1127 name, srccap);
1128 WRAP_CONCAT;
1129 } else if (suppress_untranslatable) {
1130 continue;
1131 } else {
1132 char *s = srccap, *d = buffer;
1133 int need = 3 + (int) strlen(name);
1134 while ((*d = *s++) != 0) {
1135 if ((d - buffer + 2) >= (int) sizeof(buffer)) {
1136 fprintf(stderr,
1137 "%s: value for %s is too long\n",
1138 _nc_progname,
1139 name);
1140 *d = '\0';
1141 break;
1142 }
1143 if (*d == ':') {
1144 *d++ = '\\';
1145 *d = ':';
1146 } else if (*d == '\\') {
1147 if ((*++d = *s++) == '\0')
1148 break;
1149 }
1150 d++;
1151 *d = '\0';
1152 }
1153 need += (int) (d - buffer);
1154 wrap_concat("..", need, w1ST | wERR);
1155 need -= 2;
1156 wrap_concat(name, need, wOFF | wERR);
1157 need -= (int) strlen(name);
1158 wrap_concat("=", need, w2ND | wERR);
1159 need -= 1;
1160 wrap_concat(buffer, need, wEND | wERR);
1161 outcount = TRUE;
1162 }
1163 } else {
1164 wrap_concat3(name, "=", cv);
1165 }
1166 len += (int) strlen(capability) + 1;
1167 } else {
1168 char *src = _nc_tic_expand(capability,
1169 outform == F_TERMINFO, numbers);
1170
1171 strcpy_DYN(&tmpbuf, 0);
1172 strcpy_DYN(&tmpbuf, name);
1173 strcpy_DYN(&tmpbuf, "=");
1174 if (pretty
1175 && (outform == F_TERMINFO
1176 || outform == F_VARIABLE)) {
1177 fmt_complex(tterm, name, src, 1);
1178 } else {
1179 strcpy_DYN(&tmpbuf, src);
1180 }
1181 len += (int) strlen(capability) + 1;
1182 WRAP_CONCAT1(tmpbuf.text);
1183 }
1184 }
1185 /* e.g., trimmed_sgr0 */
1186 if (VALID_STRING(capability) &&
1187 capability != tterm->Strings[i])
1188 free(capability);
1189 }
1190 len += (int) (num_strings * 2);
1191
1192 /*
1193 * This piece of code should be an effective inverse of the functions
1194 * postprocess_terminfo() and postprocess_terminfo() in parse_entry.c.
1195 * Much more work should be done on this to support dumping termcaps.
1196 */
1197 if (tversion == V_HPUX) {
1198 if (VALID_STRING(memory_lock)) {
1199 _nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
1200 "meml=%s", memory_lock);
1201 WRAP_CONCAT;
1202 }
1203 if (VALID_STRING(memory_unlock)) {
1204 _nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
1205 "memu=%s", memory_unlock);
1206 WRAP_CONCAT;
1207 }
1208 } else if (tversion == V_AIX) {
1209 if (VALID_STRING(acs_chars)) {
1210 bool box_ok = TRUE;
1211 const char *acstrans = "lqkxjmwuvtn";
1212 const char *cp;
1213 char *tp, *sp, boxchars[11];
1214
1215 tp = boxchars;
1216 for (cp = acstrans; *cp; cp++) {
1217 sp = (strchr) (acs_chars, *cp);
1218 if (sp)
1219 *tp++ = sp[1];
1220 else {
1221 box_ok = FALSE;
1222 break;
1223 }
1224 }
1225 tp[0] = '\0';
1226
1227 if (box_ok) {
1228 char *tmp = _nc_tic_expand(boxchars,
1229 (outform == F_TERMINFO),
1230 numbers);
1231 _nc_STRCPY(buffer, "box1=", sizeof(buffer));
1232 while (*tmp != '\0') {
1233 size_t have = strlen(buffer);
1234 size_t next = strlen(tmp);
1235 size_t want = have + next + 1;
1236 size_t last = next;
1237 char save = '\0';
1238
1239 /*
1240 * If the expanded string is too long for the buffer,
1241 * chop it off and save the location where we chopped it.
1242 */
1243 if (want >= sizeof(buffer)) {
1244 save = tmp[last];
1245 tmp[last] = '\0';
1246 }
1247 _nc_STRCAT(buffer, tmp, sizeof(buffer));
1248
1249 /*
1250 * If we chopped the buffer, replace the missing piece and
1251 * shift everything to append the remainder.
1252 */
1253 if (save != '\0') {
1254 next = 0;
1255 tmp[last] = save;
1256 while ((tmp[next] = tmp[last + next]) != '\0') {
1257 ++next;
1258 }
1259 } else {
1260 break;
1261 }
1262 }
1263 WRAP_CONCAT;
1264 }
1265 }
1266 }
1267
1268 /*
1269 * kludge: trim off trailer to avoid an extra blank line
1270 * in infocmp -u output when there are no string differences
1271 */
1272 if (outcount) {
1273 bool trimmed = FALSE;
1274 j = (PredIdx) outbuf.used;
1275 if (wrapped && did_wrap) {
1276 /* EMPTY */ ;
1277 } else if (j >= 2
1278 && outbuf.text[j - 1] == '\t'
1279 && outbuf.text[j - 2] == '\n') {
1280 outbuf.used -= 2;
1281 trimmed = TRUE;
1282 } else if (j >= 4
1283 && outbuf.text[j - 1] == ':'
1284 && outbuf.text[j - 2] == '\t'
1285 && outbuf.text[j - 3] == '\n'
1286 && outbuf.text[j - 4] == '\\') {
1287 outbuf.used -= 4;
1288 trimmed = TRUE;
1289 }
1290 if (trimmed) {
1291 outbuf.text[outbuf.used] = '\0';
1292 column = oldcol;
1293 strcpy_DYN(&outbuf, " ");
1294 }
1295 }
1296 #if 0
1297 fprintf(stderr, "num_bools = %d\n", num_bools);
1298 fprintf(stderr, "num_values = %d\n", num_values);
1299 fprintf(stderr, "num_strings = %d\n", num_strings);
1300 fprintf(stderr, "term_names=%s, len=%d, strlen(outbuf)=%d, outbuf=%s\n",
1301 tterm->term_names, len, outbuf.used, outbuf.text);
1302 #endif
1303 /*
1304 * Here's where we use infodump to trigger a more stringent length check
1305 * for termcap-translation purposes.
1306 * Return the length of the raw entry, without tc= expansions,
1307 * It gives an idea of which entries are deadly to even *scan past*,
1308 * as opposed to *use*.
1309 */
1310 return (infodump ? len : (int) termcap_length(outbuf.text));
1311 }
1312
1313 static bool
kill_string(TERMTYPE2 * tterm,const char * const cap)1314 kill_string(TERMTYPE2 *tterm, const char *const cap)
1315 {
1316 unsigned n;
1317 for (n = 0; n < NUM_STRINGS(tterm); ++n) {
1318 if (cap == tterm->Strings[n]) {
1319 tterm->Strings[n] = ABSENT_STRING;
1320 return TRUE;
1321 }
1322 }
1323 return FALSE;
1324 }
1325
1326 static char *
find_string(TERMTYPE2 * tterm,char * name)1327 find_string(TERMTYPE2 *tterm, char *name)
1328 {
1329 PredIdx n;
1330 for (n = 0; n < NUM_STRINGS(tterm); ++n) {
1331 if (version_filter(STRING, n)
1332 && !strcmp(name, strnames[n])) {
1333 char *cap = tterm->Strings[n];
1334 if (VALID_STRING(cap)) {
1335 return cap;
1336 }
1337 break;
1338 }
1339 }
1340 return ABSENT_STRING;
1341 }
1342
1343 /*
1344 * This is used to remove function-key labels from a termcap entry to
1345 * make it smaller.
1346 */
1347 static int
kill_labels(TERMTYPE2 * tterm,int target)1348 kill_labels(TERMTYPE2 *tterm, int target)
1349 {
1350 int n;
1351 int result = 0;
1352 char name[20];
1353
1354 for (n = 0; n <= 10; ++n) {
1355 char *cap;
1356
1357 _nc_SPRINTF(name, _nc_SLIMIT(sizeof(name)) "lf%d", n);
1358 cap = find_string(tterm, name);
1359 if (VALID_STRING(cap)
1360 && kill_string(tterm, cap)) {
1361 target -= (int) (strlen(cap) + 5);
1362 ++result;
1363 if (target < 0)
1364 break;
1365 }
1366 }
1367 return result;
1368 }
1369
1370 /*
1371 * This is used to remove function-key definitions from a termcap entry to
1372 * make it smaller.
1373 */
1374 static int
kill_fkeys(TERMTYPE2 * tterm,int target)1375 kill_fkeys(TERMTYPE2 *tterm, int target)
1376 {
1377 int n;
1378 int result = 0;
1379 char name[20];
1380
1381 for (n = 60; n >= 0; --n) {
1382 char *cap;
1383
1384 _nc_SPRINTF(name, _nc_SLIMIT(sizeof(name)) "kf%d", n);
1385 cap = find_string(tterm, name);
1386 if (VALID_STRING(cap)
1387 && kill_string(tterm, cap)) {
1388 target -= (int) (strlen(cap) + 5);
1389 ++result;
1390 if (target < 0)
1391 break;
1392 }
1393 }
1394 return result;
1395 }
1396
1397 /*
1398 * Check if the given acsc string is a 1-1 mapping, i.e., just-like-vt100.
1399 * Also, since this is for termcap, we only care about the line-drawing map.
1400 */
1401 #define isLine(c) (strchr("lmkjtuvwqxn", c) != 0)
1402
1403 static bool
one_one_mapping(const char * mapping)1404 one_one_mapping(const char *mapping)
1405 {
1406 bool result = TRUE;
1407
1408 if (VALID_STRING(mapping)) {
1409 int n = 0;
1410 while (mapping[n] != '\0' && mapping[n + 1] != '\0') {
1411 if (isLine(mapping[n]) &&
1412 mapping[n] != mapping[n + 1]) {
1413 result = FALSE;
1414 break;
1415 }
1416 n += 2;
1417 }
1418 }
1419 return result;
1420 }
1421
1422 #define FMT_ENTRY() \
1423 fmt_entry(tterm, pred, \
1424 0, \
1425 suppress_untranslatable, \
1426 infodump, numbers)
1427
1428 #define SHOW_WHY PRINTF
1429
1430 static bool
purged_acs(TERMTYPE2 * tterm)1431 purged_acs(TERMTYPE2 *tterm)
1432 {
1433 bool result = FALSE;
1434
1435 if (VALID_STRING(acs_chars)) {
1436 if (!one_one_mapping(acs_chars)) {
1437 enter_alt_charset_mode = ABSENT_STRING;
1438 exit_alt_charset_mode = ABSENT_STRING;
1439 SHOW_WHY("# (rmacs/smacs removed for consistency)\n");
1440 }
1441 result = TRUE;
1442 }
1443 return result;
1444 }
1445
1446 static void
encode_b64(char * target,char * source,unsigned state,int * saved)1447 encode_b64(char *target, char *source, unsigned state, int *saved)
1448 {
1449 /* RFC-4648 */
1450 static const char data[] =
1451 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1452 "abcdefghijklmnopqrstuvwxyz"
1453 "0123456789" "-_";
1454 int ch = UChar(source[state]);
1455
1456 switch (state % 3) {
1457 case 0:
1458 *target++ = data[(ch >> 2) & 077];
1459 *saved = (ch << 4);
1460 break;
1461 case 1:
1462 *target++ = data[((ch >> 4) | *saved) & 077];
1463 *saved = (ch << 2);
1464 break;
1465 case 2:
1466 *target++ = data[((ch >> 6) | *saved) & 077];
1467 *target++ = data[ch & 077];
1468 *saved = 0;
1469 break;
1470 }
1471 *target = '\0';
1472 }
1473
1474 /*
1475 * Dump a single entry.
1476 */
1477 void
dump_entry(TERMTYPE2 * tterm,int suppress_untranslatable,int limited,int numbers,PredFunc pred)1478 dump_entry(TERMTYPE2 *tterm,
1479 int suppress_untranslatable,
1480 int limited,
1481 int numbers,
1482 PredFunc pred)
1483 {
1484 TERMTYPE2 save_tterm;
1485 int critlen;
1486 const char *legend;
1487 bool infodump;
1488
1489 if (quickdump) {
1490 char bigbuf[65536];
1491 unsigned offset = 0;
1492
1493 separator = "";
1494 trailer = "\n";
1495 indent = 0;
1496
1497 if (_nc_write_object(tterm, bigbuf, &offset, sizeof(bigbuf)) == OK) {
1498 char numbuf[80];
1499 unsigned n;
1500
1501 if (quickdump & 1) {
1502 if (outbuf.used)
1503 wrap_concat1("\n");
1504 wrap_concat1("hex:");
1505 for (n = 0; n < offset; ++n) {
1506 _nc_SPRINTF(numbuf, _nc_SLIMIT(sizeof(numbuf))
1507 "%02X", UChar(bigbuf[n]));
1508 wrap_concat1(numbuf);
1509 }
1510 }
1511 if (quickdump & 2) {
1512 static char padding[] =
1513 {0, 0};
1514 int value = 0;
1515
1516 if (outbuf.used)
1517 wrap_concat1("\n");
1518 wrap_concat1("b64:");
1519 for (n = 0; n < offset; ++n) {
1520 encode_b64(numbuf, bigbuf, n, &value);
1521 wrap_concat1(numbuf);
1522 }
1523 switch (n % 3) {
1524 case 0:
1525 break;
1526 case 1:
1527 encode_b64(numbuf, padding, 1, &value);
1528 wrap_concat1(numbuf);
1529 wrap_concat1("==");
1530 break;
1531 case 2:
1532 encode_b64(numbuf, padding, 1, &value);
1533 wrap_concat1(numbuf);
1534 wrap_concat1("=");
1535 break;
1536 }
1537 }
1538 }
1539 return;
1540 }
1541
1542 if (TcOutput()) {
1543 critlen = MAX_TERMCAP_LENGTH;
1544 legend = "older termcap";
1545 infodump = FALSE;
1546 set_obsolete_termcaps(tterm);
1547 } else {
1548 critlen = MAX_TERMINFO_LENGTH;
1549 legend = "terminfo";
1550 infodump = TRUE;
1551 }
1552
1553 save_sgr = set_attributes;
1554
1555 if ((FMT_ENTRY() > critlen)
1556 && TcOutput()
1557 && limited) {
1558
1559 save_tterm = *tterm;
1560 if (!suppress_untranslatable) {
1561 SHOW_WHY("# (untranslatable capabilities removed to fit entry within %d bytes)\n",
1562 critlen);
1563 suppress_untranslatable = TRUE;
1564 }
1565 if (FMT_ENTRY() > critlen) {
1566 /*
1567 * We pick on sgr because it is a nice long string capability that
1568 * is really just an optimization hack. Another good candidate is
1569 * acsc since it is both long and unused by BSD termcap.
1570 */
1571 bool changed = FALSE;
1572
1573 #if NCURSES_XNAMES
1574 /*
1575 * Extended names are most likely function-key definitions. Drop
1576 * those first.
1577 */
1578 unsigned n;
1579 for (n = STRCOUNT; n < NUM_STRINGS(tterm); n++) {
1580 const char *name = ExtStrname(tterm, (int) n, strnames);
1581
1582 if (VALID_STRING(tterm->Strings[n])) {
1583 set_attributes = ABSENT_STRING;
1584 /* we remove long names anyway - only report the short */
1585 if (strlen(name) <= 2) {
1586 SHOW_WHY("# (%s removed to fit entry within %d bytes)\n",
1587 name,
1588 critlen);
1589 }
1590 changed = TRUE;
1591 if (FMT_ENTRY() <= critlen)
1592 break;
1593 }
1594 }
1595 #endif
1596 if (VALID_STRING(set_attributes)) {
1597 set_attributes = ABSENT_STRING;
1598 SHOW_WHY("# (sgr removed to fit entry within %d bytes)\n",
1599 critlen);
1600 changed = TRUE;
1601 }
1602 if (!changed || (FMT_ENTRY() > critlen)) {
1603 if (purged_acs(tterm)) {
1604 acs_chars = ABSENT_STRING;
1605 SHOW_WHY("# (acsc removed to fit entry within %d bytes)\n",
1606 critlen);
1607 changed = TRUE;
1608 }
1609 }
1610 if (!changed || (FMT_ENTRY() > critlen)) {
1611 int oldversion = tversion;
1612 int len;
1613
1614 tversion = V_BSD;
1615 SHOW_WHY("# (terminfo-only capabilities suppressed to fit entry within %d bytes)\n",
1616 critlen);
1617
1618 len = FMT_ENTRY();
1619 if (len > critlen
1620 && kill_labels(tterm, len - critlen)) {
1621 SHOW_WHY("# (some labels capabilities suppressed to fit entry within %d bytes)\n",
1622 critlen);
1623 len = FMT_ENTRY();
1624 }
1625 if (len > critlen
1626 && kill_fkeys(tterm, len - critlen)) {
1627 SHOW_WHY("# (some function-key capabilities suppressed to fit entry within %d bytes)\n",
1628 critlen);
1629 len = FMT_ENTRY();
1630 }
1631 if (len > critlen) {
1632 (void) fprintf(stderr,
1633 "%s: %s entry is %d bytes long\n",
1634 _nc_progname,
1635 _nc_first_name(tterm->term_names),
1636 len);
1637 SHOW_WHY("# WARNING: this entry, %d bytes long, may core-dump %s libraries!\n",
1638 len, legend);
1639 }
1640 tversion = oldversion;
1641 }
1642 set_attributes = save_sgr;
1643 *tterm = save_tterm;
1644 }
1645 } else if (!version_filter(STRING, STR_IDX(acs_chars))) {
1646 save_tterm = *tterm;
1647 if (purged_acs(tterm)) {
1648 (void) FMT_ENTRY();
1649 }
1650 *tterm = save_tterm;
1651 }
1652 }
1653
1654 void
dump_uses(const char * value,bool infodump)1655 dump_uses(const char *value, bool infodump)
1656 /* dump "use=" clauses in the appropriate format */
1657 {
1658 char buffer[MAX_TERMINFO_LENGTH + EXTRA_CAP];
1659 int limit = (VALID_STRING(value) ? (int) strlen(value) : 0);
1660 const char *cap = infodump ? "use" : "tc";
1661
1662 if (TcOutput())
1663 trim_trailing();
1664 if (limit == 0) {
1665 _nc_warning("empty \"%s\" field", cap);
1666 value = "";
1667 } else if (limit > MAX_ALIAS) {
1668 _nc_warning("\"%s\" field too long (%d), limit to %d",
1669 cap, limit, MAX_ALIAS);
1670 limit = MAX_ALIAS;
1671 }
1672 _nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
1673 "%s=%.*s", cap, limit, value);
1674 wrap_concat1(buffer);
1675 }
1676
1677 int
show_entry(void)1678 show_entry(void)
1679 {
1680 /*
1681 * Trim any remaining whitespace.
1682 */
1683 if (outbuf.used != 0) {
1684 bool infodump = !TcOutput();
1685 char delim = (char) (infodump ? ',' : ':');
1686 int j;
1687
1688 for (j = (int) outbuf.used - 1; j > 0; --j) {
1689 char ch = outbuf.text[j];
1690 if (ch == '\n') {
1691 ;
1692 } else if (isspace(UChar(ch))) {
1693 outbuf.used = (size_t) j;
1694 } else if (!infodump && ch == '\\') {
1695 outbuf.used = (size_t) j;
1696 } else if (ch == delim && (outbuf.text[j - 1] != '\\')) {
1697 outbuf.used = (size_t) (j + 1);
1698 } else {
1699 break;
1700 }
1701 }
1702 outbuf.text[outbuf.used] = '\0';
1703 }
1704 if (outbuf.text != 0) {
1705 (void) fputs(outbuf.text, stdout);
1706 putchar('\n');
1707 }
1708 return (int) outbuf.used;
1709 }
1710
1711 void
compare_entry(PredHook hook,TERMTYPE2 * tp GCC_UNUSED,bool quiet)1712 compare_entry(PredHook hook,
1713 TERMTYPE2 *tp GCC_UNUSED,
1714 bool quiet)
1715 /* compare two entries */
1716 {
1717 PredIdx i, j;
1718 NCURSES_CONST char *name;
1719
1720 if (!quiet)
1721 fputs(" comparing booleans.\n", stdout);
1722 for_each_boolean(j, tp) {
1723 i = BoolIndirect(j);
1724 name = ExtBoolname(tp, (int) i, bool_names);
1725
1726 if (isObsolete(outform, name))
1727 continue;
1728
1729 (*hook) (CMP_BOOLEAN, i, name);
1730 }
1731
1732 if (!quiet)
1733 fputs(" comparing numbers.\n", stdout);
1734 for_each_number(j, tp) {
1735 i = NumIndirect(j);
1736 name = ExtNumname(tp, (int) i, num_names);
1737
1738 if (isObsolete(outform, name))
1739 continue;
1740
1741 (*hook) (CMP_NUMBER, i, name);
1742 }
1743
1744 if (!quiet)
1745 fputs(" comparing strings.\n", stdout);
1746 for_each_string(j, tp) {
1747 i = StrIndirect(j);
1748 name = ExtStrname(tp, (int) i, str_names);
1749
1750 if (isObsolete(outform, name))
1751 continue;
1752
1753 (*hook) (CMP_STRING, i, name);
1754 }
1755
1756 /* (void) fputs(" comparing use entries.\n", stdout); */
1757 (*hook) (CMP_USE, 0, "use");
1758
1759 }
1760
1761 #define NOTSET(s) ((s) == 0)
1762
1763 /*
1764 * This bit of legerdemain turns all the terminfo variable names into
1765 * references to locations in the arrays Booleans, Numbers, and Strings ---
1766 * precisely what's needed.
1767 */
1768 #undef CUR
1769 #define CUR tp->
1770
1771 static void
set_obsolete_termcaps(TERMTYPE2 * tp)1772 set_obsolete_termcaps(TERMTYPE2 *tp)
1773 {
1774 #include "capdefaults.c"
1775 }
1776
1777 /*
1778 * Convert an alternate-character-set string to canonical form: sorted and
1779 * unique.
1780 */
1781 void
repair_acsc(TERMTYPE2 * tp)1782 repair_acsc(TERMTYPE2 *tp)
1783 {
1784 if (VALID_STRING(acs_chars)) {
1785 size_t n;
1786 char mapped[256];
1787 unsigned source;
1788 unsigned target;
1789 bool fix_needed = FALSE;
1790
1791 for (n = 0, source = 0; acs_chars[n] != 0; n++) {
1792 target = UChar(acs_chars[n]);
1793 if (source >= target) {
1794 fix_needed = TRUE;
1795 break;
1796 }
1797 source = target;
1798 if (acs_chars[n + 1])
1799 n++;
1800 }
1801
1802 if (fix_needed) {
1803 size_t m;
1804 char extra = 0;
1805
1806 memset(mapped, 0, sizeof(mapped));
1807 for (n = 0; acs_chars[n] != 0; n++) {
1808 source = UChar(acs_chars[n]);
1809 if ((target = (unsigned char) acs_chars[n + 1]) != 0) {
1810 mapped[source] = (char) target;
1811 n++;
1812 } else {
1813 extra = (char) source;
1814 }
1815 }
1816 for (n = m = 0; n < sizeof(mapped); n++) {
1817 if (mapped[n]) {
1818 acs_chars[m++] = (char) n;
1819 acs_chars[m++] = mapped[n];
1820 }
1821 }
1822 if (extra)
1823 acs_chars[m++] = extra; /* garbage in, garbage out */
1824 acs_chars[m] = 0;
1825 }
1826 }
1827 }
1828