533a5f0a1960ac00e84b724d39a54a3155748d46
[ncurses.git] / test / demo_terminfo.c
1 /****************************************************************************
2  * Copyright (c) 2009-2013,2014 Free Software Foundation, Inc.              *
3  *                                                                          *
4  * Permission is hereby granted, free of charge, to any person obtaining a  *
5  * copy of this software and associated documentation files (the            *
6  * "Software"), to deal in the Software without restriction, including      *
7  * without limitation the rights to use, copy, modify, merge, publish,      *
8  * distribute, distribute with modifications, sublicense, and/or sell       *
9  * copies of the Software, and to permit persons to whom the Software is    *
10  * furnished to do so, subject to the following conditions:                 *
11  *                                                                          *
12  * The above copyright notice and this permission notice shall be included  *
13  * in all copies or substantial portions of the Software.                   *
14  *                                                                          *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
22  *                                                                          *
23  * Except as contained in this notice, the name(s) of the above copyright   *
24  * holders shall not be used in advertising or otherwise to promote the     *
25  * sale, use or other dealings in this Software without prior written       *
26  * authorization.                                                           *
27  ****************************************************************************/
28
29 /*
30  * Author: Thomas E. Dickey
31  *
32  * $Id: demo_terminfo.c,v 1.34 2014/08/31 23:11:39 tom Exp $
33  *
34  * A simple demo of the terminfo interface.
35  */
36 #define USE_TINFO
37 #include <test.priv.h>
38 #include <sys/stat.h>
39
40 #if NCURSES_XNAMES
41 #if HAVE_TERM_ENTRY_H
42 #include <term_entry.h>
43 #else
44 #undef NCURSES_XNAMES
45 #define NCURSES_XNAMES 0
46 #endif
47 #endif
48
49 static void
50 failed(const char *msg)
51 {
52     fprintf(stderr, "%s\n", msg);
53     ExitProgram(EXIT_FAILURE);
54 }
55
56 #if HAVE_TIGETSTR
57
58 #if defined(HAVE_CURSES_DATA_BOOLNAMES) || defined(DECL_CURSES_DATA_BOOLNAMES)
59 #define USE_CODE_LISTS 1
60 #else
61 #define USE_CODE_LISTS 0
62 #endif
63
64 static bool a_opt = FALSE;
65 static bool b_opt = FALSE;
66 static bool f_opt = FALSE;
67 static bool n_opt = FALSE;
68 static bool q_opt = FALSE;
69 static bool s_opt = FALSE;
70 static bool x_opt = FALSE;
71 static bool y_opt = FALSE;
72
73 static char *d_opt;
74 static char *e_opt;
75 static char **db_list;
76 static int db_item;
77
78 static char *my_blob;
79 static char **my_boolcodes;
80 static char **my_numcodes;
81 static char **my_numvalues;
82 static char **my_strcodes;
83 static char **my_strvalues;
84
85 static long total_values;
86 static long total_b_values;
87 static long total_n_values;
88 static long total_s_values;
89
90 #define FCOLS 8
91 #define FNAME(type) "%s %-*s = ", #type, FCOLS
92
93 static char *
94 make_dbitem(char *p, char *q)
95 {
96     char *result = malloc(strlen(e_opt) + 2 + (size_t) (p - q));
97     sprintf(result, "%s=%.*s", e_opt, (int) (p - q), q);
98     return result;
99 }
100
101 static void
102 make_dblist(void)
103 {
104     if (d_opt && e_opt) {
105         int pass;
106
107         for (pass = 0; pass < 2; ++pass) {
108             char *p, *q;
109             size_t count = 0;
110
111             for (p = q = d_opt; *p != '\0'; ++p) {
112                 if (*p == ':') {
113                     if (p != q + 1) {
114                         if (pass) {
115                             db_list[count] = make_dbitem(p, q);
116                         }
117                         count++;
118                     }
119                     q = p + 1;
120                 }
121             }
122             if (p != q + 1) {
123                 if (pass) {
124                     db_list[count] = make_dbitem(p, q);
125                 }
126                 count++;
127             }
128             if (!pass) {
129                 db_list = typeCalloc(char *, count + 1);
130             }
131         }
132     }
133 }
134
135 static char *
136 next_dbitem(void)
137 {
138     char *result = 0;
139
140     if (db_list) {
141         if ((result = db_list[db_item]) == 0) {
142             db_item = 0;
143             result = db_list[0];
144         } else {
145             db_item++;
146         }
147     }
148     printf("** %s\n", result);
149     return result;
150 }
151
152 #ifdef NO_LEAKS
153 static void
154 free_dblist(void)
155 {
156     if (db_list) {
157         int n;
158         for (n = 0; db_list[n]; ++n)
159             free(db_list[n]);
160         free(db_list);
161         db_list = 0;
162     }
163 }
164 #endif
165
166 static void
167 dumpit(NCURSES_CONST char *cap)
168 {
169     const char *str;
170     int num;
171
172     if ((str = tigetstr(cap)) != 0 && (str != (char *) -1)) {
173         total_values++;
174         total_s_values++;
175         if (!q_opt) {
176             printf(FNAME(str), cap);
177             while (*str != 0) {
178                 int ch = UChar(*str++);
179                 switch (ch) {
180                 case '\177':
181                     fputs("^?", stdout);
182                     break;
183                 case '\033':
184                     fputs("\\E", stdout);
185                     break;
186                 case '\b':
187                     fputs("\\b", stdout);
188                     break;
189                 case '\f':
190                     fputs("\\f", stdout);
191                     break;
192                 case '\n':
193                     fputs("\\n", stdout);
194                     break;
195                 case '\r':
196                     fputs("\\r", stdout);
197                     break;
198                 case ' ':
199                     fputs("\\s", stdout);
200                     break;
201                 case '\t':
202                     fputs("\\t", stdout);
203                     break;
204                 case '^':
205                     fputs("\\^", stdout);
206                     break;
207                 case ':':
208                     fputs("\\072", stdout);
209                     break;
210                 case '\\':
211                     fputs("\\\\", stdout);
212                     break;
213                 default:
214                     if (isgraph(ch))
215                         fputc(ch, stdout);
216                     else if (ch < 32)
217                         printf("^%c", ch + '@');
218                     else
219                         printf("\\%03o", ch);
220                     break;
221                 }
222             }
223             printf("\n");
224         }
225     } else if ((num = tigetnum(cap)) >= 0) {
226         total_values++;
227         total_n_values++;
228         if (!q_opt) {
229             printf(FNAME(num), cap);
230             printf(" %d\n", num);
231         }
232     } else if ((num = tigetflag(cap)) >= 0) {
233         total_values++;
234         total_b_values++;
235         if (!q_opt) {
236             printf(FNAME(flg), cap);
237             printf("%s\n", num ? "true" : "false");
238         }
239     }
240
241     if (!q_opt)
242         fflush(stdout);
243 }
244
245 #define isCapName(c) (isalnum(UChar(c)) || ((c) == '_'))
246 #define LegalItem(c,n) (n)
247
248 static void
249 brute_force(const char *name)
250 {
251 #define MAX_FORCE 5             /* omit "colors", since CPU-time is a problem */
252     static const char legal[] = "\
253 0123456789\
254 ABCDEFGHIJKLMNOPQRSTUVWXYZ\
255 abcdefghijklmnopqrstuvwxyz_";
256     int length;
257     int j, k;
258     bool carry;
259     bool changed;
260     char cap[MAX_FORCE + 1];
261     int item[MAX_FORCE + 1];
262
263     if (db_list) {
264         putenv(next_dbitem());
265     }
266     if (!q_opt)
267         printf("Terminal type \"%s\"\n", name);
268     setupterm((NCURSES_CONST char *) name, 1, (int *) 0);
269
270     for (length = 1; length <= MAX_FORCE; ++length) {
271         /* set all digits to zeros */
272         for (j = 0; j < length; ++j) {
273             item[j] = LegalItem(j, 0);
274         }
275
276         do {
277             changed = FALSE;
278             /* copy digits to cap-name */
279             for (j = 0; j < length; ++j) {
280                 cap[j] = legal[item[j]];
281             }
282             cap[length] = '\0';
283             dumpit(cap);
284
285             k = length - 1;
286             do {
287                 carry = FALSE;
288                 for (; k >= 0; --k) {
289                     item[k] += 1;
290                     if (legal[item[k]]) {
291                         changed = TRUE;
292                         break;
293                     }
294                     if (k > 0 &&
295                         legal[item[k - 1] + 1]) {
296                         for (j = k; j < length; ++j) {
297                             item[j] = LegalItem(j, 0);
298                         }
299                         carry = TRUE;
300                         changed = TRUE;
301                     }
302                 }
303             } while (carry);
304         } while (changed);
305     }
306     del_curterm(cur_term);
307 }
308
309 static void
310 demo_terminfo(char *name)
311 {
312     unsigned n;
313     NCURSES_CONST char *cap;
314
315     if (db_list) {
316         putenv(next_dbitem());
317     }
318     if (!q_opt)
319         printf("Terminal type \"%s\"\n", name);
320     setupterm(name, 1, (int *) 0);
321
322     if (b_opt) {
323         for (n = 0;; ++n) {
324             cap = f_opt ? boolfnames[n] : my_boolcodes[n];
325             if (cap == 0)
326                 break;
327             dumpit(cap);
328         }
329     }
330
331     if (n_opt) {
332         for (n = 0;; ++n) {
333             cap = f_opt ? numfnames[n] : my_numcodes[n];
334             if (cap == 0)
335                 break;
336             dumpit(cap);
337         }
338     }
339
340     if (s_opt) {
341         for (n = 0;; ++n) {
342             cap = f_opt ? strfnames[n] : my_strcodes[n];
343             if (cap == 0)
344                 break;
345             dumpit(cap);
346         }
347     }
348 #ifdef NCURSES_VERSION
349     if (x_opt && (my_blob == 0)) {
350         int mod;
351         if (y_opt) {
352 #if NCURSES_XNAMES
353             TERMTYPE *term = &(cur_term->type);
354             if (term != 0
355                 && ((NUM_BOOLEANS(term) != BOOLCOUNT)
356                     || (NUM_NUMBERS(term) != NUMCOUNT)
357                     || (NUM_STRINGS(term) != STRCOUNT))) {
358                 for (n = BOOLCOUNT; n < NUM_BOOLEANS(term); ++n) {
359                     dumpit(ExtBoolname(term, (int) n, boolnames));
360                 }
361                 for (n = NUMCOUNT; n < NUM_NUMBERS(term); ++n) {
362                     dumpit(ExtNumname(term, (int) n, numnames));
363                 }
364                 for (n = STRCOUNT; n < NUM_STRINGS(term); ++n) {
365                     dumpit(ExtStrname(term, (int) n, strnames));
366                 }
367             }
368 #endif
369         } else {
370             char temp[80];
371             static const char *xterm_keys[] =
372             {
373                 "kDC", "kDN", "kEND", "kHOM", "kIC",
374                 "kLFT", "kNXT", "kPRV", "kRIT", "kUP",
375             };
376             for (n = 0; n < SIZEOF(xterm_keys); ++n) {
377                 for (mod = 0; mod < 8; ++mod) {
378                     if (mod == 0) {
379                         /* these happen to be standard - avoid duplicates */
380                         if (!strcmp(xterm_keys[n], "kDC") ||
381                             !strcmp(xterm_keys[n], "kEND") ||
382                             !strcmp(xterm_keys[n], "kHOM") ||
383                             !strcmp(xterm_keys[n], "kLFT") ||
384                             !strcmp(xterm_keys[n], "kRIT")) {
385                             continue;
386                         }
387                         sprintf(temp, "%.*s", 8, xterm_keys[n]);
388                     } else {
389                         sprintf(temp, "%.*s%d", 8, xterm_keys[n], mod);
390                     }
391                     dumpit(temp);
392                 }
393             }
394         }
395     }
396 #endif
397     del_curterm(cur_term);
398 }
399
400 typedef enum {
401     pDefault = 0
402     ,pComment
403     ,pDescription
404     ,pEscaped
405     ,pNewline
406     ,pName
407     ,pNumber
408     ,pString
409 } STATE;
410
411 static void
412 parse_description(const char *input_name)
413 {
414     FILE *fp;
415     struct stat sb;
416     size_t count_bools = 0;
417     size_t count_nums = 0;
418     size_t count_strs = 0;
419     size_t len;
420     size_t j, k, jl;
421     STATE state;
422
423     if (stat(input_name, &sb) != 0
424         || (sb.st_mode & S_IFMT) != S_IFREG) {
425         failed("input is not a file");
426     }
427
428     if (sb.st_size == 0) {
429         failed("input is empty");
430     }
431
432     /*
433      * None of the arrays could be larger than the input-file, and since it
434      * is small, just allocate the maximum for simplicity.
435      */
436     if ((my_blob = malloc((size_t) sb.st_size + 1)) == 0 ||
437         (my_boolcodes = typeCalloc(char *, sb.st_size)) == 0 ||
438           (my_numcodes = typeCalloc(char *, sb.st_size)) == 0 ||
439           (my_numvalues = typeCalloc(char *, sb.st_size)) == 0 ||
440           (my_strcodes = typeCalloc(char *, sb.st_size)) == 0 ||
441           (my_strvalues = typeCalloc(char *, sb.st_size)) == 0) {
442         failed("cannot allocate memory for input-file");
443     }
444
445     if ((fp = fopen(input_name, "r")) == 0)
446         failed("cannot open input-file");
447     len = fread(my_blob, sizeof(char), (size_t) sb.st_size, fp);
448     fclose(fp);
449
450     /*
451      * First, get rid of comments and escaped newlines, as well as repeated
452      * colons to construct a canonical entry.
453      */
454     state = pNewline;
455     for (j = k = 0; j < len; ++j) {
456         int ch = my_blob[j];
457         if (ch == '\t') {
458             ch = ' ';
459         }
460         switch (state) {
461         case pNewline:
462             if (ch == ' ') {
463                 continue;
464             }
465             if (ch == '#') {
466                 state = pComment;
467                 continue;
468             }
469             state = pDefault;
470             /* FALLTHRU */
471         case pDefault:
472             switch (ch) {
473             case '|':
474                 state = pDescription;
475                 continue;
476             case '\\':
477                 state = pEscaped;
478                 continue;
479             case '\n':
480                 state = pNewline;
481                 continue;
482             case ' ':
483                 break;
484             case ',':
485                 my_blob[k++] = (char) ch;
486                 break;
487             default:
488                 if (isalpha(UChar(ch)))
489                     state = pName;
490                 else
491                     fprintf(stderr, "OOPS @%d:%.20s\n", __LINE__, my_blob + j);
492                 my_blob[k++] = (char) ch;
493                 break;
494             }
495             break;
496         case pComment:
497             if (ch == '\n')
498                 state = pNewline;
499             break;
500         case pDescription:
501             switch (ch) {
502             case ',':
503                 state = pDefault;
504                 break;
505             case '\n':
506                 state = pNewline;
507                 break;
508             }
509             break;
510         case pEscaped:
511             if (ch != '\n') {
512                 my_blob[k++] = (char) ch;
513                 state = pDefault;
514             } else {
515                 state = pNewline;
516             }
517             break;
518         case pName:
519             switch (ch) {
520             case '\n':
521                 state = pNewline;
522                 continue;
523             case ' ':
524             case ',':
525                 state = pDefault;
526                 break;
527             case '#':
528                 state = pNumber;
529                 break;
530             case '=':
531                 state = pString;
532                 break;
533             case '|':
534                 state = pDescription;
535                 continue;
536             }
537             my_blob[k++] = (char) ch;
538             break;
539         case pNumber:
540             switch (ch) {
541             case '\n':
542                 state = pNewline;
543                 continue;
544             case ',':
545                 state = pDefault;
546                 break;
547             case ' ':
548                 state = pDefault;
549                 continue;
550             }
551             my_blob[k++] = (char) ch;
552             break;
553         case pString:
554             switch (ch) {
555             case '\n':
556                 state = pNewline;
557                 break;
558             case ',':
559                 state = pDefault;
560                 my_blob[k++] = (char) ch;
561                 break;
562             default:
563                 my_blob[k++] = (char) ch;
564                 break;
565             }
566             break;
567         default:
568             /* not used */
569             break;
570         }
571     }
572     my_blob[k] = '\0';
573
574     /*
575      * Then, parse what's left, making indexes of the names and values.
576      */
577     state = pDefault;
578     for (j = 0; my_blob[j] != '\0'; ++j) {
579         switch (state) {
580         case pDefault:
581             switch (my_blob[j]) {
582             case '\\':
583                 state = pEscaped;
584                 break;
585             case ',':
586                 my_blob[j] = '\0';
587                 if (my_blob[j + 1] != '\0' && my_blob[j + 1] != ',')
588                     state = pName;
589                 break;
590             case ' ':
591                 break;
592             default:
593                 break;
594             }
595         case pEscaped:
596             break;
597         case pName:
598             state = pDefault;
599             if (isalpha(UChar(my_blob[j]))) {
600                 for (jl = 1; isalnum(UChar(my_blob[j + jl])); ++jl) {
601                     ;
602                 }
603             } else {
604                 jl = 0;
605             }
606             if (jl != 0) {
607                 switch (my_blob[j + jl]) {
608                 case '#':
609                     my_numvalues[count_nums] = &my_blob[j + jl + 1];
610                     my_numcodes[count_nums++] = &my_blob[j];
611                     my_blob[j + jl] = '\0';
612                     state = pNumber;
613                     j += jl;
614                     break;
615                 case '=':
616                     my_strvalues[count_strs] = &my_blob[j + jl + 1];
617                     my_strcodes[count_strs++] = &my_blob[j];
618                     my_blob[j + jl] = '\0';
619                     state = pString;
620                     j += jl;
621                     break;
622                 default:
623                     if (my_blob[j + jl] == '@') {
624                         /*
625                          * We cannot get the type for a cancelled item
626                          * directly, but can infer it assuming the input
627                          * came from infocmp, which puts the data in a
628                          * known order.
629                          */
630                         if (count_strs) {
631                             my_strvalues[count_strs] = "";
632                             my_strcodes[count_strs++] = &my_blob[j];
633                         } else if (count_nums) {
634                             my_numvalues[count_nums] = "";
635                             my_numcodes[count_nums++] = &my_blob[j];
636                         } else {
637                             my_boolcodes[count_bools++] = &my_blob[j];
638                         }
639                         my_blob[j + jl] = '\0';
640                         j += jl + 1;
641                     } else {
642                         my_boolcodes[count_bools++] = &my_blob[j];
643                         my_blob[j + jl] = '\0';
644                         j += jl;
645                     }
646                     state = (isCapName(my_blob[j + 1])
647                              ? pName
648                              : pDefault);
649                     break;
650                 }
651             }
652             break;
653         case pNumber:
654             if (!isdigit(UChar(my_blob[j]))) {
655                 --j;
656                 state = pDefault;
657             }
658             break;
659         case pString:
660             switch (my_blob[j]) {
661             case '\\':
662                 if (my_blob[j + 1] != '\0') {
663                     ++j;
664                 } else {
665                     --j;
666                     state = pDefault;
667                 }
668                 break;
669             case ',':
670                 --j;
671                 state = pDefault;
672                 break;
673             }
674             break;
675         case pNewline:
676         case pComment:
677         case pDescription:
678         default:
679             break;
680         }
681     }
682     my_boolcodes[count_bools] = 0;
683     my_numcodes[count_nums] = 0;
684     my_numvalues[count_nums] = 0;
685     my_strcodes[count_strs] = 0;
686     my_strvalues[count_strs] = 0;
687
688 #if 0
689     printf("# bools:%d\n", (int) count_bools);
690     for (j = 0; my_boolcodes[j]; ++j)
691         printf("\t%s,\n", my_boolcodes[j]);
692
693     printf("# numbers:%d\n", (int) count_nums);
694     for (j = 0; my_numcodes[j]; ++j)
695         printf("\t%s#%s,\n", my_numcodes[j], my_numvalues[j]);
696
697     printf("# strings:%d\n", (int) count_strs);
698     for (j = 0; my_strcodes[j]; ++j)
699         printf("\t%s=%s,\n", my_strcodes[j], my_strvalues[j]);
700 #endif
701 }
702
703 #if USE_CODE_LISTS
704 static char **
705 copy_code_list(NCURSES_CONST char *const *list)
706 {
707     int pass;
708     size_t count;
709     size_t length = 0;
710     char **result = 0;
711     char *blob = 0;
712     char *unused = 0;
713
714     for (pass = 0; pass < 2; ++pass) {
715         for (count = 0; list[count] != 0; ++count) {
716             size_t chunk = strlen(list[count]) + 1;
717             if (pass == 0) {
718                 length += chunk;
719             } else {
720                 result[count] = unused;
721                 strcpy(unused, list[count]);
722                 unused += chunk;
723             }
724         }
725         if (pass == 0) {
726             blob = malloc(length);
727             result = typeCalloc(char *, count + 1);
728             unused = blob;
729             if (blob == 0 || result == 0)
730                 failed("copy_code_list failed");
731         }
732     }
733
734     return result;
735 }
736 #endif
737
738 static void
739 usage(void)
740 {
741     static const char *msg[] =
742     {
743         "Usage: demo_terminfo [options] [terminal]",
744         "",
745         "If no options are given, print all (boolean, numeric, string)",
746         "capabilities for the given terminal, using short names.",
747         "",
748         "Options:",
749         " -a       try all names, print capabilities found",
750         " -b       print boolean-capabilities",
751         " -d LIST  colon-separated list of databases to use",
752         " -e NAME  environment variable to set with -d option",
753         " -f       print full names",
754         " -i NAME  terminal description to use as names for \"-a\" option",
755         " -n       print numeric-capabilities",
756         " -q       quiet (prints only counts)",
757         " -r COUNT repeat for given count",
758         " -s       print string-capabilities",
759 #ifdef NCURSES_VERSION
760         " -x       print extended capabilities",
761         " -y       direct-lookup names of extended capabilities",
762 #endif
763     };
764     unsigned n;
765     for (n = 0; n < SIZEOF(msg); ++n) {
766         fprintf(stderr, "%s\n", msg[n]);
767     }
768     ExitProgram(EXIT_FAILURE);
769 }
770
771 int
772 main(int argc, char *argv[])
773 {
774     int n;
775     int repeat;
776     char *name;
777     int r_opt = 1;
778     char *input_name = 0;
779
780     while ((n = getopt(argc, argv, "abd:e:fi:nqr:sxy")) != -1) {
781         switch (n) {
782         case 'a':
783             a_opt = TRUE;
784             break;
785         case 'b':
786             b_opt = TRUE;
787             break;
788         case 'd':
789             d_opt = optarg;
790             break;
791         case 'e':
792             e_opt = optarg;
793             break;
794         case 'f':
795             f_opt = TRUE;
796             break;
797         case 'i':
798             input_name = optarg;
799             break;
800         case 'n':
801             n_opt = TRUE;
802             break;
803         case 'q':
804             q_opt = TRUE;
805             break;
806         case 'r':
807             if ((r_opt = atoi(optarg)) <= 0)
808                 usage();
809             break;
810         case 's':
811             s_opt = TRUE;
812             break;
813 #ifdef NCURSES_VERSION
814         case 'x':
815             x_opt = TRUE;
816             break;
817         case 'y':
818             y_opt = TRUE;
819             x_opt = TRUE;
820             break;
821 #endif
822         default:
823             usage();
824             break;
825         }
826     }
827
828 #if NCURSES_XNAMES
829     use_extended_names(x_opt);
830 #endif
831
832     if (!(b_opt || n_opt || s_opt)) {
833         b_opt = TRUE;
834         n_opt = TRUE;
835         s_opt = TRUE;
836     }
837
838     make_dblist();
839
840     if (a_opt) {
841         for (repeat = 0; repeat < r_opt; ++repeat) {
842             if (optind < argc) {
843                 for (n = optind; n < argc; ++n) {
844                     brute_force(argv[n]);
845                 }
846             } else if ((name = getenv("TERM")) != 0) {
847                 brute_force(name);
848             } else {
849                 static char dumb[] = "dumb";
850                 brute_force(dumb);
851             }
852         }
853     } else {
854         if (input_name != 0) {
855             parse_description(input_name);
856         }
857 #if USE_CODE_LISTS
858         else {
859             my_boolcodes = copy_code_list(boolnames);
860             my_numcodes = copy_code_list(numnames);
861             my_strcodes = copy_code_list(strnames);
862         }
863 #else
864         else {
865             failed("no capability-lists available (use -i option)");
866         }
867 #endif /* USE_CODE_LISTS */
868         for (repeat = 0; repeat < r_opt; ++repeat) {
869             if (optind < argc) {
870                 for (n = optind; n < argc; ++n) {
871                     demo_terminfo(argv[n]);
872                 }
873             } else if ((name = getenv("TERM")) != 0) {
874                 demo_terminfo(name);
875             } else {
876                 static char dumb[] = "dumb";
877                 demo_terminfo(dumb);
878             }
879         }
880     }
881
882     printf("%ld values (%ld booleans, %ld numbers, %ld strings)\n",
883            total_values, total_b_values, total_n_values, total_s_values);
884
885 #ifdef NO_LEAKS
886     free_dblist();
887     if (my_blob != 0) {
888         free(my_blob);
889         free(my_boolcodes);
890         free(my_numcodes);
891         free(my_numvalues);
892         free(my_strcodes);
893         free(my_strvalues);
894     }
895 #endif
896
897     ExitProgram(EXIT_SUCCESS);
898 }
899
900 #else /* !HAVE_TIGETSTR */
901 int
902 main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED)
903 {
904     printf("This program requires the terminfo functions such as tigetstr\n");
905     ExitProgram(EXIT_FAILURE);
906 }
907 #endif /* HAVE_TIGETSTR */