/**************************************************************************** * Copyright 2020 Thomas E. Dickey * * * * Permission is hereby granted, free of charge, to any person obtaining a * * copy of this software and associated documentation files (the * * "Software"), to deal in the Software without restriction, including * * without limitation the rights to use, copy, modify, merge, publish, * * distribute, distribute with modifications, sublicense, and/or sell * * copies of the Software, and to permit persons to whom the Software is * * furnished to do so, subject to the following conditions: * * * * The above copyright notice and this permission notice shall be included * * in all copies or substantial portions of the Software. * * * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * * * * Except as contained in this notice, the name(s) of the above copyright * * holders shall not be used in advertising or otherwise to promote the * * sale, use or other dealings in this Software without prior written * * authorization. * ****************************************************************************/ /* * Author: Thomas E. Dickey * * $Id: test_tparm.c,v 1.4 2020/05/31 00:51:32 tom Exp $ * * Exercise tparm, either for all possible capabilities with fixed parameters, * or one capability with all possible parameters. * * TODO: incorporate tic.h and _nc_tparm_analyze * TODO: optionally test tiparm * TODO: add checks/logic to handle "%s" in tparm */ #define USE_TINFO #include static void failed(const char *) GCC_NORETURN; static void failed(const char *msg) { fprintf(stderr, "%s\n", msg); ExitProgram(EXIT_FAILURE); } #if HAVE_TIGETSTR static int a_opt; static int v_opt; static int isNumeric(char *source) { char *next = 0; long value = strtol(source, &next, 0); int result = (next == 0 || next == source || *next != '\0') ? 0 : 1; (void) value; return result; } static char * validate(const char *name) { char *value = tigetstr(name); if (!VALID_STRING(value)) { if (v_opt > 1) { printf("? %s %s\n", (value == ABSENT_STRING) ? "absent" : "cancel", name); } value = 0; } return value; } static int increment(int *all_parms, int *num_parms, int len_parms, int end_parms) { int rc = 0; int n; if (len_parms > 9) len_parms = 9; if (end_parms < len_parms) { if (all_parms[end_parms]++ >= num_parms[end_parms]) { all_parms[end_parms] = 0; increment(all_parms, num_parms, len_parms, end_parms + 1); } } for (n = 0; n < len_parms; ++n) { if (all_parms[n] != 0) { rc = 1; break; } } /* return 1 until the vector resets to all 0's */ return rc; } static void test_tparm(const char *name, int *number) { char *format = tigetstr(name); if ((format = validate(name)) != 0) { char *result = tparm(format, number[0], number[1], number[2], number[3], number[4], number[5], number[6], number[7], number[8]); if (v_opt > 1) printf(".. %2d = %2d %2d %2d %2d %2d %2d %2d %2d %2d %s\n", result != 0 ? (int) strlen(result) : -1, number[0], number[1], number[2], number[3], number[4], number[5], number[6], number[7], number[8], name); } } static void usage(void) { static const char *msg[] = { "Usage: test_tparm [options] [capability] [value1 [value2 [...]]]", "", "Print all distinct combinations of given capability.", "", "Options:", " -T TERM override $TERM; this may be a comma-separated list or \"-\"", " to read a list from standard-input", " -a if capability is given, test all combinations of values", " -r NUM repeat tests NUM times", " -v show values and results", }; unsigned n; for (n = 0; n < SIZEOF(msg); ++n) { fprintf(stderr, "%s\n", msg[n]); } ExitProgram(EXIT_FAILURE); } #define PLURAL(n) n, (n != 1) ? "s" : "" #define COLONS(n) (n >= 1) ? ":" : "" int main(int argc, char *argv[]) { int n; int r_run, t_run, n_run; char *old_term = getenv("TERM"); int r_opt = 1; char *t_opt = 0; int len_names = 0; /* cur # of items in all_names[] */ int use_names = 10; /* max # of items in all_names[] */ char **all_names = typeCalloc(char *, use_names); int all_parms[10]; /* workspace for "-a" option */ int len_terms = 0; /* cur # of items in all_terms[] */ int use_terms = 10; /* max # of items in all_terms[] */ char **all_terms = typeCalloc(char *, use_terms); int len_parms = 0; /* cur # of items in num_parms[], str_parms[] */ int use_parms = argc + 10; /* max # of items in num_parms[], str_parms[] */ int *num_parms = typeCalloc(int, use_parms); char **str_parms = typeCalloc(char *, use_parms); if (all_names == 0 || all_terms == 0 || num_parms == 0 || str_parms == 0) failed("no memory"); while ((n = getopt(argc, argv, "T:ar:v")) != -1) { switch (n) { case 'T': t_opt = optarg; break; case 'a': ++a_opt; break; case 'r': r_opt = atoi(optarg); break; case 'v': ++v_opt; break; default: usage(); break; } } /* * If there is a nonnumeric parameter after the options, use that as the * capability name. */ if (optind < argc) { if (!isNumeric(argv[optind])) { all_names[len_names++] = strdup(argv[optind++]); } } /* * Any remaining arguments must be possible parameter values. If numeric, * and "-a" is not set, use those as the maximum values within which the * test parameters should vary. */ while (optind < argc) { if (isNumeric(argv[optind])) { char *dummy = 0; long value = strtol(argv[optind], &dummy, 0); num_parms[len_parms] = (int) value; } str_parms[len_parms] = argv[optind]; ++optind; ++len_parms; } for (n = len_parms; n < use_parms; ++n) { static char dummy[1]; str_parms[n] = dummy; } if (v_opt) { printf("%d parameter%s%s\n", PLURAL(len_parms), COLONS(len_parms)); for (n = 0; n < len_parms; ++n) { printf(" %d: %d (%s)\n", n + 1, num_parms[n], str_parms[n]); } } /* * Make a list of values for $TERM. Accept "-" for standard input to * simplify scripting a check of the whole database. */ old_term = strdup((old_term == 0) ? "unknown" : old_term); if (t_opt != 0) { if (!strcmp(t_opt, "-")) { char buffer[BUFSIZ]; while (fgets(buffer, sizeof(buffer) - 1, stdin) != 0) { char *s = buffer; char *t; while (isspace(UChar(s[0]))) ++s; t = s + strlen(s); while (t != s && isspace(UChar(t[-1]))) *--t = '\0'; s = strdup(s); if (len_terms + 2 >= use_terms) { use_terms *= 2; all_terms = typeRealloc(char *, use_terms, all_terms); if (all_terms == 0) failed("no memory: all_terms"); } all_terms[len_terms++] = s; } } else { char *s = t_opt; char *t; while ((t = strtok(s, ",")) != 0) { s = 0; if (len_terms + 2 >= use_terms) { use_terms *= 2; all_terms = typeRealloc(char *, use_terms, all_terms); if (all_terms == 0) failed("no memory: all_terms"); } all_terms[len_terms++] = strdup(t); } } } else { all_terms[len_terms++] = strdup(old_term); } all_terms[len_terms] = 0; if (v_opt) { printf("%d term%s:\n", PLURAL(len_terms)); for (n = 0; n < len_terms; ++n) { printf(" %d: %s\n", n + 1, all_terms[n]); } } /* * If no capability name was selected, use the predefined list of string * capabilities. * * TODO: To address the "other" systems which do not follow SVr4, * just use the output from infocmp on $TERM. */ if (len_names == 0) { #if defined(HAVE_CURSES_DATA_BOOLNAMES) || defined(DECL_CURSES_DATA_BOOLNAMES) for (n = 0; strnames[n] != 0; ++n) { if (len_names + 2 >= use_names) { use_names *= 2; all_names = typeRealloc(char *, use_names, all_names); if (all_names == 0) { failed("no memory: all_names"); } } all_names[len_names++] = strdup(strnames[n]); } #else all_names[len_names++] = strdup("cup"); all_names[len_names++] = strdup("sgr"); #endif } all_names[len_names] = 0; if (v_opt) { printf("%d name%s%s\n", PLURAL(len_names), COLONS(len_names)); for (n = 0; n < len_names; ++n) { printf(" %d: %s\n", n + 1, all_names[n]); } } if (r_opt <= 0) r_opt = 1; for (r_run = 0; r_run < r_opt; ++r_run) { for (t_run = 0; t_run < len_terms; ++t_run) { int errs; if (setupterm(all_terms[t_run], fileno(stdout), &errs) != OK) { printf("** skipping %s (errs:%d)\n", all_terms[t_run], errs); } if (v_opt) printf("** testing %s\n", all_terms[t_run]); if (len_names == 1) { if (a_opt) { /* for each combination of values */ memset(all_parms, 0, sizeof(all_parms)); do { test_tparm(all_names[0], all_parms); } while (increment(all_parms, num_parms, len_parms, 0)); } else { /* for the given values */ test_tparm(all_names[0], num_parms); } } else { for (n_run = 0; n_run < len_names; ++n_run) { test_tparm(all_names[n_run], num_parms); } } if (cur_term != 0) { del_curterm(cur_term); } else { printf("? no cur_term\n"); } } } #if NO_LEAKS for (n = 0; n < len_names; ++n) { free(all_names[n]); } free(all_names); free(old_term); for (n = 0; n < len_terms; ++n) { free(all_terms[n]); } free(all_terms); free(num_parms); free(str_parms); #endif ExitProgram(EXIT_SUCCESS); } #else /* !HAVE_TIGETSTR */ int main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED) { failed("This program requires the terminfo functions such as tigetstr"); } #endif /* HAVE_TIGETSTR */