X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=progs%2Finfocmp.c;h=82c48419a047f6ddce2ff02d350c103b604b7ad7;hp=71e0a7c083b03e4b23f45c81217c56488d1c1242;hb=6a586fefa9985809fdfbc96d2dcb838a13e4e4d2;hpb=3a9b6a3bf0269231bef7de74757a910dedd04e0c diff --git a/progs/infocmp.c b/progs/infocmp.c index 71e0a7c0..82c48419 100644 --- a/progs/infocmp.c +++ b/progs/infocmp.c @@ -1,49 +1,54 @@ - -/*************************************************************************** -* COPYRIGHT NOTICE * -**************************************************************************** -* ncurses is copyright (C) 1992-1995 * -* Zeyd M. Ben-Halim * -* zmbenhal@netcom.com * -* Eric S. Raymond * -* esr@snark.thyrsus.com * -* * -* Permission is hereby granted to reproduce and distribute ncurses * -* by any means and for any fee, whether alone or as part of a * -* larger distribution, in source or in binary form, PROVIDED * -* this notice is included with any such distribution, and is not * -* removed from any of its header files. Mention of ncurses in any * -* applications linked with it is highly appreciated. * -* * -* ncurses comes AS IS with no warranty, implied or expressed. * -* * -***************************************************************************/ - +/**************************************************************************** + * Copyright (c) 1998-2016,2017 Free Software Foundation, Inc. * + * * + * Permission is hereby granted, free of charge, to any person obtaining a * + * copy of this software and associated documentation files (the * + * "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: Zeyd M. Ben-Halim 1992,1995 * + * and: Eric S. Raymond * + * and: Thomas E. Dickey 1996-on * + ****************************************************************************/ /* * infocmp.c -- decompile an entry, or compare two entries * written by Eric S. Raymond + * and Thomas E Dickey */ #include -#include - -#include #include -MODULE_ID("$Id: infocmp.c,v 1.27 1997/02/15 18:54:44 tom Exp $") +MODULE_ID("$Id: infocmp.c,v 1.143 2017/04/05 09:27:51 tom Exp $") -#define L_CURL "{" -#define R_CURL "}" - -#define VALID_STRING(s) ((s) != CANCELLED_STRING && (s) != ABSENT_STRING) - -#define MAXTERMS 32 /* max # terminal arguments we can handle */ +#define MAX_STRING 1024 /* maximum formatted string */ const char *_nc_progname = "infocmp"; -typedef char path[PATH_MAX]; +typedef char path[PATH_MAX]; /*************************************************************************** * @@ -52,15 +57,22 @@ typedef char path[PATH_MAX]; * ***************************************************************************/ -static char *tname[MAXTERMS]; /* terminal type names */ -static TERMTYPE term[MAXTERMS]; /* terminfo entries */ +static ENTRY *entries; /* terminfo entries */ static int termcount; /* count of terminal entries */ +static bool limited = TRUE; /* "-r" option is not set */ +static bool quiet = FALSE; +static bool literal = FALSE; +static const char *bool_sep = ":"; +static const char *s_absent = "NULL"; +static const char *s_cancel = "NULL"; static const char *tversion; /* terminfo version selected */ -static int outform; /* output format */ -static int sortmode; /* sort_mode */ -static int itrace; /* trace flag for debugging */ +static unsigned itrace; /* trace flag for debugging */ static int mwidth = 60; +static int mheight = 65535; +static int numbers = 0; /* format "%'char'" to/from "%{number}" */ +static int outform = F_TERMINFO; /* output format */ +static int sortmode; /* sort_mode */ /* main comparison mode */ static int compare; @@ -72,27 +84,83 @@ static int compare; static bool ignorepads; /* ignore pad prefixes when diffing */ #if NO_LEAKS + +typedef struct { + ENTRY *head; + ENTRY *tail; +} ENTERED; + +static ENTERED *entered; + #undef ExitProgram static void ExitProgram(int code) GCC_NORETURN; -static void ExitProgram(int code) +/* prototype is to get gcc to accept the noreturn attribute */ +static void +ExitProgram(int code) { - while (termcount-- > 0) - _nc_free_termtype(&term[termcount], FALSE); - _nc_leaks_dump_entry(); - _nc_free_and_exit(code); + int n; + + for (n = 0; n < termcount; ++n) { + ENTRY *new_head = _nc_head; + ENTRY *new_tail = _nc_tail; + _nc_head = entered[n].head; + _nc_tail = entered[n].tail; + _nc_free_entries(entered[n].head); + _nc_head = new_head; + _nc_tail = new_tail; + } + _nc_leaks_dump_entry(); + free(entries); + free(entered); + _nc_free_tic(code); } #endif -static char *canonical_name(char *ptr, char *buf) +static void +failed(const char *s) +{ + perror(s); + ExitProgram(EXIT_FAILURE); +} + +static char * +canonical_name(char *ptr, char *buf) /* extract the terminal type's primary name */ { - char *bp; + char *bp; - (void) strcpy(buf, ptr); - if ((bp = strchr(buf, '|')) != (char *)NULL) + _nc_STRCPY(buf, ptr, NAMESIZE); + if ((bp = strchr(buf, '|')) != 0) *bp = '\0'; - return(buf); + return (buf); +} + +static bool +no_boolean(int value) +{ + bool result = (value == ABSENT_BOOLEAN); + if (!strcmp(s_absent, s_cancel)) + result = !VALID_BOOLEAN(value); + return result; +} + +static bool +no_numeric(int value) +{ + bool result = (value == ABSENT_NUMERIC); + if (!strcmp(s_absent, s_cancel)) + result = !VALID_NUMERIC(value); + return result; +} + +static bool +no_string(char *value) +{ + bool result = (value == ABSENT_STRING); + if (!strcmp(s_absent, s_cancel)) + result = !VALID_STRING(value); + return result; } /*************************************************************************** @@ -101,217 +169,484 @@ static char *canonical_name(char *ptr, char *buf) * ***************************************************************************/ -static int capcmp(const char *s, const char *t) +static int +capcmp(PredIdx idx, const char *s, const char *t) /* capability comparison function */ { if (!VALID_STRING(s) && !VALID_STRING(t)) - return(0); + return (s != t); else if (!VALID_STRING(s) || !VALID_STRING(t)) - return(1); + return (1); - if (ignorepads) - return(_nc_capcmp(s, t)); + if ((idx == acs_chars_index) || !ignorepads) + return (strcmp(s, t)); else - return(strcmp(s, t)); + return (_nc_capcmp(s, t)); } -static int use_predicate(int type, int idx) +static int +use_predicate(unsigned type, PredIdx idx) /* predicate function to use for use decompilation */ { - TERMTYPE *tp; + ENTRY *ep; - switch(type) + switch (type) { + case BOOLEAN: { - case BOOLEAN: { - int is_set = FALSE; + int is_set = FALSE; - /* - * This assumes that multiple use entries are supposed - * to contribute the logical or of their boolean capabilities. - * This is true if we take the semantics of multiple uses to - * be 'each capability gets the first non-default value found - * in the sequence of use entries'. - */ - for (tp = &term[1]; tp < term + termcount; tp++) - if (tp->Booleans[idx]) { - is_set = TRUE; - break; - } - if (is_set != term->Booleans[idx]) - return(!is_set); - else - return(FAIL); + /* + * This assumes that multiple use entries are supposed + * to contribute the logical or of their boolean capabilities. + * This is true if we take the semantics of multiple uses to + * be 'each capability gets the first non-default value found + * in the sequence of use entries'. + * + * Note that cancelled or absent booleans are stored as FALSE, + * unlike numbers and strings, whose cancelled/absent state is + * recorded in the terminfo database. + */ + for (ep = &entries[1]; ep < entries + termcount; ep++) + if (ep->tterm.Booleans[idx] == TRUE) { + is_set = entries[0].tterm.Booleans[idx]; + break; } + if (is_set != entries[0].tterm.Booleans[idx]) + return (!is_set); + else + return (FAIL); + } - case NUMBER: { - int value = ABSENT_NUMERIC; + case NUMBER: + { + int value = ABSENT_NUMERIC; - /* - * We take the semantics of multiple uses to be 'each - * capability gets the first non-default value found - * in the sequence of use entries'. - */ - for (tp = &term[1]; tp < term + termcount; tp++) - if (tp->Numbers[idx] >= 0) { - value = tp->Numbers[idx]; - break; - } - - if (value != term->Numbers[idx]) - return(value != ABSENT_NUMERIC); - else - return(FAIL); + /* + * We take the semantics of multiple uses to be 'each + * capability gets the first non-default value found + * in the sequence of use entries'. + */ + for (ep = &entries[1]; ep < entries + termcount; ep++) + if (VALID_NUMERIC(ep->tterm.Numbers[idx])) { + value = ep->tterm.Numbers[idx]; + break; } - case STRING: { - char *termstr, *usestr = ABSENT_STRING; + if (value != entries[0].tterm.Numbers[idx]) + return (value != ABSENT_NUMERIC); + else + return (FAIL); + } - termstr = term->Strings[idx]; + case STRING: + { + char *termstr, *usestr = ABSENT_STRING; - /* - * We take the semantics of multiple uses to be 'each - * capability gets the first non-default value found - * in the sequence of use entries'. - */ - for (tp = &term[1]; tp < term + termcount; tp++) - if (tp->Strings[idx]) - { - usestr = tp->Strings[idx]; - break; - } - - if (usestr == ABSENT_STRING && termstr == ABSENT_STRING) - return(FAIL); - else if (!usestr || !termstr || capcmp(usestr,termstr)) - return(TRUE); - else - return(FAIL); - } + termstr = entries[0].tterm.Strings[idx]; + + /* + * We take the semantics of multiple uses to be 'each + * capability gets the first non-default value found + * in the sequence of use entries'. + */ + for (ep = &entries[1]; ep < entries + termcount; ep++) + if (ep->tterm.Strings[idx]) { + usestr = ep->tterm.Strings[idx]; + break; + } + + if (usestr == ABSENT_STRING && termstr == ABSENT_STRING) + return (FAIL); + else if (!usestr || !termstr || capcmp(idx, usestr, termstr)) + return (TRUE); + else + return (FAIL); } + } - return(FALSE); /* pacify compiler */ + return (FALSE); /* pacify compiler */ } -static bool entryeq(TERMTYPE *t1, TERMTYPE *t2) -/* are two terminal types equal */ +static bool +useeq(ENTRY * e1, ENTRY * e2) +/* are the use references in two entries equivalent? */ { - int i; + unsigned i, j; - for (i = 0; i < BOOLCOUNT; i++) + if (e1->nuses != e2->nuses) + return (FALSE); + + /* Ugh...this is quadratic again */ + for (i = 0; i < e1->nuses; i++) { + bool foundmatch = FALSE; + + /* search second entry for given use reference */ + for (j = 0; j < e2->nuses; j++) + if (!strcmp(e1->uses[i].name, e2->uses[j].name)) { + foundmatch = TRUE; + break; + } + + if (!foundmatch) + return (FALSE); + } + + return (TRUE); +} + +static bool +entryeq(TERMTYPE2 *t1, TERMTYPE2 *t2) +/* are two entries equivalent? */ +{ + unsigned i; + + for (i = 0; i < NUM_BOOLEANS(t1); i++) if (t1->Booleans[i] != t2->Booleans[i]) - return(FALSE); + return (FALSE); - for (i = 0; i < NUMCOUNT; i++) + for (i = 0; i < NUM_NUMBERS(t1); i++) if (t1->Numbers[i] != t2->Numbers[i]) - return(FALSE); + return (FALSE); - for (i = 0; i < STRCOUNT; i++) - if (capcmp(t1->Strings[i], t2->Strings[i])) - return(FALSE); + for (i = 0; i < NUM_STRINGS(t1); i++) + if (capcmp((PredIdx) i, t1->Strings[i], t2->Strings[i])) + return (FALSE); - return(TRUE); + return (TRUE); } -static void compare_predicate(int type, int idx, const char *name) -/* predicate function to use for entry difference reports */ +#define TIC_EXPAND(result) _nc_tic_expand(result, outform==F_TERMINFO, numbers) + +static void +print_uses(ENTRY * ep, FILE *fp) +/* print an entry's use references */ { - register TERMTYPE *t1 = &term[0]; - register TERMTYPE *t2 = &term[1]; - char *s1, *s2; + unsigned i; - switch(type) - { - case BOOLEAN: - switch(compare) - { - case C_DIFFERENCE: - if (t1->Booleans[idx] != t2->Booleans[idx]) - (void) printf("\t%s: %c:%c.\n", - name, - t1->Booleans[idx] ? 'T' : 'F', - t2->Booleans[idx] ? 'T' : 'F'); - break; + if (!ep->nuses) + fputs("NULL", fp); + else + for (i = 0; i < ep->nuses; i++) { + fputs(ep->uses[i].name, fp); + if (i < ep->nuses - 1) + fputs(" ", fp); + } +} - case C_COMMON: - if (t1->Booleans[idx] && t2->Booleans[idx]) - (void) printf("\t%s= T.\n", name); - break; +static const char * +dump_boolean(int val) +/* display the value of a boolean capability */ +{ + switch (val) { + case ABSENT_BOOLEAN: + return (s_absent); + case CANCELLED_BOOLEAN: + return (s_cancel); + case FALSE: + return ("F"); + case TRUE: + return ("T"); + default: + return ("?"); + } +} - case C_NAND: - if (!t1->Booleans[idx] && !t2->Booleans[idx]) - (void) printf("\t!%s.\n", name); +static void +dump_numeric(int val, char *buf) +/* display the value of a numeric capability */ +{ + switch (val) { + case ABSENT_NUMERIC: + _nc_STRCPY(buf, s_absent, MAX_STRING); + break; + case CANCELLED_NUMERIC: + _nc_STRCPY(buf, s_cancel, MAX_STRING); + break; + default: + _nc_SPRINTF(buf, _nc_SLIMIT(MAX_STRING) "%d", val); + break; + } +} + +static void +dump_string(char *val, char *buf) +/* display the value of a string capability */ +{ + if (val == ABSENT_STRING) + _nc_STRCPY(buf, s_absent, MAX_STRING); + else if (val == CANCELLED_STRING) + _nc_STRCPY(buf, s_cancel, MAX_STRING); + else { + _nc_SPRINTF(buf, _nc_SLIMIT(MAX_STRING) + "'%.*s'", MAX_STRING - 3, TIC_EXPAND(val)); + } +} + +/* + * Show "comparing..." message for the given terminal names. + */ +static void +show_comparing(char **names) +{ + if (itrace) { + switch (compare) { + case C_DIFFERENCE: + (void) fprintf(stderr, "%s: dumping differences\n", _nc_progname); + break; + + case C_COMMON: + (void) fprintf(stderr, "%s: dumping common capabilities\n", _nc_progname); + break; + + case C_NAND: + (void) fprintf(stderr, "%s: dumping differences\n", _nc_progname); + break; + } + } + if (*names) { + printf("comparing %s", *names++); + if (*names) { + printf(" to %s", *names++); + while (*names) { + printf(", %s", *names++); + } + } + printf(".\n"); + } +} + +/* + * ncurses stores two types of non-standard capabilities: + * a) capabilities listed past the "STOP-HERE" comment in the Caps file. + * These are used in the terminfo source file to provide data for termcaps, + * e.g., when there is no equivalent capability in terminfo, as well as for + * widely-used non-standard capabilities. + * b) user-definable capabilities, via "tic -x". + * + * However, if "-x" is omitted from the tic command, both types of + * non-standard capability are not loaded into the terminfo database. This + * macro is used for limit-checks against the symbols that tic uses to omit + * the two types of non-standard entry. + */ +#if NCURSES_XNAMES +#define check_user_definable(n,limit) if (!_nc_user_definable && (n) > (limit)) break +#else +#define check_user_definable(n,limit) if ((n) > (limit)) break +#endif + +/* + * Use these macros to simplify loops on C_COMMON and C_NAND: + */ +#define for_each_entry() while (entries[extra].tterm.term_names) +#define next_entry (&(entries[extra++].tterm)) + +static void +compare_predicate(PredType type, PredIdx idx, const char *name) +/* predicate function to use for entry difference reports */ +{ + ENTRY *e1 = &entries[0]; + ENTRY *e2 = &entries[1]; + char buf1[MAX_STRING]; + char buf2[MAX_STRING]; + int b1, b2; + int n1, n2; + char *s1, *s2; + bool found; + int extra = 1; + + switch (type) { + case CMP_BOOLEAN: + check_user_definable(idx, BOOLWRITE); + b1 = e1->tterm.Booleans[idx]; + switch (compare) { + case C_DIFFERENCE: + b2 = next_entry->Booleans[idx]; + if (!(no_boolean(b1) && no_boolean(b2)) && (b1 != b2)) + (void) printf("\t%s: %s%s%s.\n", + name, + dump_boolean(b1), + bool_sep, + dump_boolean(b2)); + break; + + case C_COMMON: + if (b1 != ABSENT_BOOLEAN) { + found = TRUE; + for_each_entry() { + b2 = next_entry->Booleans[idx]; + if (b1 != b2) { + found = FALSE; break; + } } - break; - - case NUMBER: - switch(compare) - { - case C_DIFFERENCE: - if (t1->Numbers[idx] != t2->Numbers[idx]) - (void) printf("\t%s: %d:%d.\n", - name, t1->Numbers[idx], t2->Numbers[idx]); + if (found) { + (void) printf("\t%s= %s.\n", name, dump_boolean(b1)); + } + } + break; + + case C_NAND: + if (b1 == ABSENT_BOOLEAN) { + found = TRUE; + for_each_entry() { + b2 = next_entry->Booleans[idx]; + if (b1 != b2) { + found = FALSE; break; + } + } + if (found) { + (void) printf("\t!%s.\n", name); + } + } + break; + } + break; - case C_COMMON: - if (t1->Numbers[idx]!=-1 && t2->Numbers[idx]!=-1 - && t1->Numbers[idx] == t2->Numbers[idx]) - (void) printf("\t%s= %d.\n", name, t1->Numbers[idx]); + case CMP_NUMBER: + check_user_definable(idx, NUMWRITE); + n1 = e1->tterm.Numbers[idx]; + switch (compare) { + case C_DIFFERENCE: + n2 = next_entry->Numbers[idx]; + if (!(no_numeric(n1) && no_numeric(n2)) && n1 != n2) { + dump_numeric(n1, buf1); + dump_numeric(n2, buf2); + (void) printf("\t%s: %s, %s.\n", name, buf1, buf2); + } + break; + + case C_COMMON: + if (n1 != ABSENT_NUMERIC) { + found = TRUE; + for_each_entry() { + n2 = next_entry->Numbers[idx]; + if (n1 != n2) { + found = FALSE; break; - - case C_NAND: - if (t1->Numbers[idx]==-1 && t2->Numbers[idx] == -1) - (void) printf("\t!%s.\n", name); + } + } + if (found) { + dump_numeric(n1, buf1); + (void) printf("\t%s= %s.\n", name, buf1); + } + } + break; + + case C_NAND: + if (n1 == ABSENT_NUMERIC) { + found = TRUE; + for_each_entry() { + n2 = next_entry->Numbers[idx]; + if (n1 != n2) { + found = FALSE; break; + } + } + if (found) { + (void) printf("\t!%s.\n", name); } + } + break; + } break; - case STRING: - s1 = t1->Strings[idx]; - s2 = t2->Strings[idx]; - switch(compare) - { - case C_DIFFERENCE: - if (capcmp(s1, s2)) - { - char buf1[BUFSIZ], buf2[BUFSIZ]; - - if (s1 == (char *)NULL) - (void) strcpy(buf1, "NULL"); - else - { - (void) strcpy(buf1, "'"); - (void) strcat(buf1, expand(s1)); - (void) strcat(buf1, "'"); - } - - if (s2 == (char *)NULL) - (void) strcpy(buf2, "NULL"); - else - { - (void) strcpy(buf2, "'"); - (void) strcat(buf2, expand(s2)); - (void) strcat(buf2, "'"); - } - - (void) printf("\t%s: %s, %s.\n", - name, buf1, buf2); - } + case CMP_STRING: + check_user_definable(idx, STRWRITE); + s1 = e1->tterm.Strings[idx]; + switch (compare) { + case C_DIFFERENCE: + s2 = next_entry->Strings[idx]; + if (!(no_string(s1) && no_string(s2)) && capcmp(idx, s1, s2)) { + dump_string(s1, buf1); + dump_string(s2, buf2); + if (strcmp(buf1, buf2)) + (void) printf("\t%s: %s, %s.\n", name, buf1, buf2); + } + break; + + case C_COMMON: + if (s1 != ABSENT_STRING) { + found = TRUE; + for_each_entry() { + s2 = next_entry->Strings[idx]; + if (capcmp(idx, s1, s2) != 0) { + found = FALSE; break; - - case C_COMMON: - if (s1 && s2 && !capcmp(s1, s2)) - (void) printf("\t%s= '%s'.\n",name,expand(s1)); + } + } + if (found) { + (void) printf("\t%s= '%s'.\n", name, TIC_EXPAND(s1)); + } + } + break; + + case C_NAND: + if (s1 == ABSENT_STRING) { + found = TRUE; + for_each_entry() { + s2 = next_entry->Strings[idx]; + if (s2 != s1) { + found = FALSE; break; + } + } + if (found) { + (void) printf("\t!%s.\n", name); + } + } + break; + } + break; - case C_NAND: - if (!s1 && !s2) - (void) printf("\t!%s.\n", name); + case CMP_USE: + /* unlike the other modes, this compares *all* use entries */ + switch (compare) { + case C_DIFFERENCE: + if (!useeq(e1, e2)) { + (void) fputs("\tuse: ", stdout); + print_uses(e1, stdout); + fputs(", ", stdout); + print_uses(e2, stdout); + fputs(".\n", stdout); + } + break; + + case C_COMMON: + if (e1->nuses) { + found = TRUE; + for_each_entry() { + e2 = &entries[extra++]; + if (e2->nuses != e1->nuses || !useeq(e1, e2)) { + found = FALSE; + break; + } + } + if (found) { + (void) fputs("\tuse: ", stdout); + print_uses(e1, stdout); + fputs(".\n", stdout); + } + } + break; + + case C_NAND: + if (!e1->nuses) { + found = TRUE; + for_each_entry() { + e2 = &entries[extra++]; + if (e2->nuses != e1->nuses) { + found = FALSE; break; + } } - break; + if (found) { + (void) printf("\t!use.\n"); + } + } + break; } - + } } /*************************************************************************** @@ -320,122 +655,199 @@ static void compare_predicate(int type, int idx, const char *name) * ***************************************************************************/ -typedef struct {const char *from; const char *to;} assoc; +#define DATA(from, to) { { from }, { to } } +#define DATAX() DATA("", "") + +typedef struct { + const char from[4]; + const char to[12]; +} assoc; static const assoc std_caps[] = { /* these are specified by X.364 and iBCS2 */ - {"\033c", "RIS"}, /* full reset */ - {"\0337", "SC"}, /* save cursor */ - {"\0338", "RC"}, /* restore cursor */ - {"\033[r", "RSR"}, /* not an X.364 mnemonic */ - {"\033[m", "SGR0"}, /* not an X.364 mnemonic */ - {"\033[2J", "ED2"}, /* clear page */ + DATA("\033c", "RIS"), /* full reset */ + DATA("\0337", "SC"), /* save cursor */ + DATA("\0338", "RC"), /* restore cursor */ + DATA("\033[r", "RSR"), /* not an X.364 mnemonic */ + DATA("\033[m", "SGR0"), /* not an X.364 mnemonic */ + DATA("\033[2J", "ED2"), /* clear page */ /* this group is specified by ISO 2022 */ - {"\033(0", "ISO DEC G0"}, /* enable DEC graphics for G0 */ - {"\033(A", "ISO UK G0"}, /* enable UK chars for G0 */ - {"\033(B", "ISO US G0"}, /* enable US chars for G0 */ - {"\033)0", "ISO DEC G1"}, /* enable DEC graphics for G1 */ - {"\033)A", "ISO UK G1"}, /* enable UK chars for G1 */ - {"\033)B", "ISO US G1"}, /* enable US chars for G1 */ - - /* these are DEC private modes widely supported by emulators */ - {"\033=", "DECPAM"}, /* application keypad mode */ - {"\033>", "DECPNM"}, /* normal keypad mode */ - {"\033<", "DECANSI"}, /* enter ANSI mode */ - - { (char *)0, (char *)0} + DATA("\033(0", "ISO DEC G0"), /* enable DEC graphics for G0 */ + DATA("\033(A", "ISO UK G0"), /* enable UK chars for G0 */ + DATA("\033(B", "ISO US G0"), /* enable US chars for G0 */ + DATA("\033)0", "ISO DEC G1"), /* enable DEC graphics for G1 */ + DATA("\033)A", "ISO UK G1"), /* enable UK chars for G1 */ + DATA("\033)B", "ISO US G1"), /* enable US chars for G1 */ + + /* these are DEC private controls widely supported by emulators */ + DATA("\033=", "DECPAM"), /* application keypad mode */ + DATA("\033>", "DECPNM"), /* normal keypad mode */ + DATA("\033<", "DECANSI"), /* enter ANSI mode */ + DATA("\033[!p", "DECSTR"), /* soft reset */ + DATA("\033 F", "S7C1T"), /* 7-bit controls */ + + DATAX() +}; + +static const assoc std_modes[] = +/* ECMA \E[ ... [hl] modes recognized by many emulators */ +{ + DATA("2", "AM"), /* keyboard action mode */ + DATA("4", "IRM"), /* insert/replace mode */ + DATA("12", "SRM"), /* send/receive mode */ + DATA("20", "LNM"), /* linefeed mode */ + DATAX() }; static const assoc private_modes[] = /* DEC \E[ ... [hl] modes recognized by many emulators */ { - {"1", "CKM"}, /* application cursor keys */ - {"2", "ANM"}, /* set VT52 mode */ - {"3", "COLM"}, /* 132-column mode */ - {"4", "SCLM"}, /* smooth scroll */ - {"5", "SCNM"}, /* reverse video mode */ - {"6", "OM"}, /* origin mode */ - {"7", "AWM"}, /* wraparound mode */ - {"8", "ARM"}, /* auto-repeat mode */ - {(char *)0, (char *)0} + DATA("1", "CKM"), /* application cursor keys */ + DATA("2", "ANM"), /* set VT52 mode */ + DATA("3", "COLM"), /* 132-column mode */ + DATA("4", "SCLM"), /* smooth scroll */ + DATA("5", "SCNM"), /* reverse video mode */ + DATA("6", "OM"), /* origin mode */ + DATA("7", "AWM"), /* wraparound mode */ + DATA("8", "ARM"), /* auto-repeat mode */ + DATAX() }; static const assoc ecma_highlights[] = /* recognize ECMA attribute sequences */ { - {"0", "NORMAL"}, /* normal */ - {"1", "+BOLD"}, /* bold on */ - {"2", "+DIM"}, /* dim on */ - {"3", "+ITALIC"}, /* italic on */ - {"4", "+UNDERLINE"}, /* underline on */ - {"5", "+BLINK"}, /* blink on */ - {"6", "+FASTBLINK"}, /* fastblink on */ - {"7", "+REVERSE"}, /* reverse on */ - {"8", "+INVISIBLE"}, /* invisible on */ - {"9", "+DELETED"}, /* deleted on */ - {"10", "MAIN-FONT"}, /* select primary font */ - {"11", "ALT-FONT-1"}, /* select alternate font 1 */ - {"12", "ALT-FONT-2"}, /* select alternate font 2 */ - {"13", "ALT-FONT-3"}, /* select alternate font 3 */ - {"14", "ALT-FONT-4"}, /* select alternate font 4 */ - {"15", "ALT-FONT-5"}, /* select alternate font 5 */ - {"16", "ALT-FONT-6"}, /* select alternate font 6 */ - {"17", "ALT-FONT-7"}, /* select alternate font 7 */ - {"18", "ALT-FONT-1"}, /* select alternate font 1 */ - {"19", "ALT-FONT-1"}, /* select alternate font 1 */ - {"20", "FRAKTUR"}, /* Fraktur font */ - {"21", "DOUBLEUNDER"}, /* double underline */ - {"22", "-DIM"}, /* dim off */ - {"23", "-ITALIC"}, /* italic off */ - {"24", "-UNDERLINE"}, /* underline off */ - {"25", "-BLINK"}, /* blink off */ - {"26", "-FASTBLINK"}, /* fastblink off */ - {"27", "-REVERSE"}, /* reverse off */ - {"28", "-INVISIBLE"}, /* invisible off */ - {"29", "-DELETED"}, /* deleted off */ - {(char *)0, (char *)0} + DATA("0", "NORMAL"), /* normal */ + DATA("1", "+BOLD"), /* bold on */ + DATA("2", "+DIM"), /* dim on */ + DATA("3", "+ITALIC"), /* italic on */ + DATA("4", "+UNDERLINE"), /* underline on */ + DATA("5", "+BLINK"), /* blink on */ + DATA("6", "+FASTBLINK"), /* fastblink on */ + DATA("7", "+REVERSE"), /* reverse on */ + DATA("8", "+INVISIBLE"), /* invisible on */ + DATA("9", "+DELETED"), /* deleted on */ + DATA("10", "MAIN-FONT"), /* select primary font */ + DATA("11", "ALT-FONT-1"), /* select alternate font 1 */ + DATA("12", "ALT-FONT-2"), /* select alternate font 2 */ + DATA("13", "ALT-FONT-3"), /* select alternate font 3 */ + DATA("14", "ALT-FONT-4"), /* select alternate font 4 */ + DATA("15", "ALT-FONT-5"), /* select alternate font 5 */ + DATA("16", "ALT-FONT-6"), /* select alternate font 6 */ + DATA("17", "ALT-FONT-7"), /* select alternate font 7 */ + DATA("18", "ALT-FONT-1"), /* select alternate font 1 */ + DATA("19", "ALT-FONT-1"), /* select alternate font 1 */ + DATA("20", "FRAKTUR"), /* Fraktur font */ + DATA("21", "DOUBLEUNDER"), /* double underline */ + DATA("22", "-DIM"), /* dim off */ + DATA("23", "-ITALIC"), /* italic off */ + DATA("24", "-UNDERLINE"), /* underline off */ + DATA("25", "-BLINK"), /* blink off */ + DATA("26", "-FASTBLINK"), /* fastblink off */ + DATA("27", "-REVERSE"), /* reverse off */ + DATA("28", "-INVISIBLE"), /* invisible off */ + DATA("29", "-DELETED"), /* deleted off */ + DATAX() }; -static void analyze_string(const char *name, const char *cap, TERMTYPE *tp) +#undef DATA + +static int +skip_csi(const char *cap) +{ + int result = 0; + if (cap[0] == '\033' && cap[1] == '[') + result = 2; + else if (UChar(cap[0]) == 0233) + result = 1; + return result; +} + +static bool +same_param(const char *table, const char *param, size_t length) +{ + bool result = FALSE; + if (strncmp(table, param, length) == 0) { + result = !isdigit(UChar(param[length])); + } + return result; +} + +static char * +lookup_params(const assoc * table, char *dst, char *src) +{ + char *result = 0; + const char *ep = strtok(src, ";"); + + if (ep != 0) { + const assoc *ap; + + do { + bool found = FALSE; + + for (ap = table; ap->from[0]; ap++) { + size_t tlen = strlen(ap->from); + + if (same_param(ap->from, ep, tlen)) { + _nc_STRCAT(dst, ap->to, MAX_TERMINFO_LENGTH); + found = TRUE; + break; + } + } + + if (!found) + _nc_STRCAT(dst, ep, MAX_TERMINFO_LENGTH); + _nc_STRCAT(dst, ";", MAX_TERMINFO_LENGTH); + } while + ((ep = strtok((char *) 0, ";"))); + + dst[strlen(dst) - 1] = '\0'; + + result = dst; + } + return result; +} + +static void +analyze_string(const char *name, const char *cap, TERMTYPE2 *tp) { - char buf[MAX_TERMINFO_LENGTH]; - char buf2[MAX_TERMINFO_LENGTH]; - const char *sp, *ep; - const assoc *ap; + char buf2[MAX_TERMINFO_LENGTH]; + const char *sp; + const assoc *ap; + int tp_lines = tp->Numbers[2]; - if (cap == ABSENT_STRING || cap == CANCELLED_STRING) + if (!VALID_STRING(cap)) return; (void) printf("%s: ", name); - buf[0] = '\0'; - for (sp = cap; *sp; sp++) - { - int i; - size_t len = 0; + for (sp = cap; *sp; sp++) { + int i; + int csi; + size_t len = 0; + size_t next; const char *expansion = 0; + char buf3[MAX_TERMINFO_LENGTH]; /* first, check other capabilities in this entry */ - for (i = 0; i < STRCOUNT; i++) - { - char *cp = tp->Strings[i]; + for (i = 0; i < STRCOUNT; i++) { + char *cp = tp->Strings[i]; - /* don't use soft-key capabilities */ - if (strnames[i][0] == 'k' && strnames[i][0] == 'f') + /* don't use function-key capabilities */ + if (strnames[i][0] == 'k' && strnames[i][1] == 'f') continue; - - if (cp != ABSENT_STRING && cp != CANCELLED_STRING && cp[0] && cp != cap) - { + if (VALID_STRING(cp) && + cp[0] != '\0' && + cp != cap) { len = strlen(cp); - (void) strncpy(buf2, sp, len); + _nc_STRNCPY(buf2, sp, len); buf2[len] = '\0'; if (_nc_capcmp(cp, buf2)) continue; -#define ISRS(s) (!strncmp((s), "is", 2) || !strncmp((s), "rs", 2)) +#define ISRS(s) (!strncmp((s), "is", (size_t) 2) || !strncmp((s), "rs", (size_t) 2)) /* * Theoretically we just passed the test for translation * (equality once the padding is stripped). However, there @@ -454,128 +866,134 @@ static void analyze_string(const char *name, const char *cap, TERMTYPE *tp) } /* now check the standard capabilities */ - if (!expansion) - for (ap = std_caps; ap->from; ap++) - { - len = strlen(ap->from); + if (!expansion) { + csi = skip_csi(sp); + for (ap = std_caps; ap->from[0]; ap++) { + size_t adj = (size_t) (csi ? 2 : 0); - if (strncmp(ap->from, sp, len) == 0) - { + len = strlen(ap->from); + if (csi && skip_csi(ap->from) != csi) + continue; + if (len > adj + && strncmp(ap->from + adj, sp + csi, len - adj) == 0) { expansion = ap->to; + len -= adj; + len += (size_t) csi; break; } } + } - /* now check for private-mode sequences */ + /* now check for standard-mode sequences */ if (!expansion - && sp[0] == '\033' && sp[1] == '[' && sp[2] == '?' - && (len = strspn(sp + 3, "0123456789;")) - && ((sp[3 + len] == 'h') || (sp[3 + len] == 'l'))) - { - char buf3[MAX_TERMINFO_LENGTH]; + && (csi = skip_csi(sp)) != 0 + && (len = (strspn) (sp + csi, "0123456789;")) + && (len < sizeof(buf3)) + && (next = (size_t) csi + len) + && ((sp[next] == 'h') || (sp[next] == 'l'))) { + + _nc_STRCPY(buf2, + ((sp[next] == 'h') + ? "ECMA+" + : "ECMA-"), + sizeof(buf2)); + _nc_STRNCPY(buf3, sp + csi, len); + buf3[len] = '\0'; + len += (size_t) csi + 1; + + expansion = lookup_params(std_modes, buf2, buf3); + } - (void) strcpy(buf2, (sp[3 + len] == 'h') ? "DEC+" : "DEC-"); - (void) strncpy(buf3, sp + 3, len); - len += 4; + /* now check for private-mode sequences */ + if (!expansion + && (csi = skip_csi(sp)) != 0 + && sp[csi] == '?' + && (len = (strspn) (sp + csi + 1, "0123456789;")) + && (len < sizeof(buf3)) + && (next = (size_t) csi + 1 + len) + && ((sp[next] == 'h') || (sp[next] == 'l'))) { + + _nc_STRCPY(buf2, + ((sp[next] == 'h') + ? "DEC+" + : "DEC-"), + sizeof(buf2)); + _nc_STRNCPY(buf3, sp + csi + 1, len); buf3[len] = '\0'; + len += (size_t) csi + 2; - ep = strtok(buf3, ";"); - do { - bool found = FALSE; - - for (ap = private_modes; ap->from; ap++) - { - size_t tlen = strlen(ap->from); - - if (strncmp(ap->from, ep, tlen) == 0) - { - (void) strcat(buf2, ap->to); - found = TRUE; - break; - } - } - - if (!found) - (void) strcat(buf2, ep); - (void) strcat(buf2, ";"); - } while - ((ep = strtok((char *)NULL, ";"))); - buf2[strlen(buf2) - 1] = '\0'; - expansion = buf2; + expansion = lookup_params(private_modes, buf2, buf3); } /* now check for ECMA highlight sequences */ if (!expansion - && sp[0] == '\033' && sp[1] == '[' - && (len = strspn(sp + 2, "0123456789;")) - && sp[2 + len] == 'm') - { - char buf3[MAX_TERMINFO_LENGTH]; - - (void) strcpy(buf2, "SGR:"); - (void) strncpy(buf3, sp + 2, len); - len += 3; + && (csi = skip_csi(sp)) != 0 + && (len = (strspn) (sp + csi, "0123456789;")) != 0 + && (len < sizeof(buf3)) + && (next = (size_t) csi + len) + && sp[next] == 'm') { + + _nc_STRCPY(buf2, "SGR:", sizeof(buf2)); + _nc_STRNCPY(buf3, sp + csi, len); buf3[len] = '\0'; + len += (size_t) csi + 1; - ep = strtok(buf3, ";"); - do { - bool found = FALSE; - - for (ap = ecma_highlights; ap->from; ap++) - { - size_t tlen = strlen(ap->from); - - if (strncmp(ap->from, ep, tlen) == 0) - { - (void) strcat(buf2, ap->to); - found = TRUE; - break; - } - } - - if (!found) - (void) strcat(buf2, ep); - (void) strcat(buf2, ";"); - } while - ((ep = strtok((char *)NULL, ";"))); - - buf2[strlen(buf2) - 1] = '\0'; + expansion = lookup_params(ecma_highlights, buf2, buf3); + } + + if (!expansion + && (csi = skip_csi(sp)) != 0 + && sp[csi] == 'm') { + len = (size_t) csi + 1; + _nc_STRCPY(buf2, "SGR:", sizeof(buf2)); + _nc_STRCAT(buf2, ecma_highlights[0].to, sizeof(buf2)); expansion = buf2; } + /* now check for scroll region reset */ - if (!expansion) - { - (void) sprintf(buf2, "\033[1;%dr", tp->Numbers[2]); - len = strlen(buf2); - if (strncmp(buf2, sp, len) == 0) + if (!expansion + && (csi = skip_csi(sp)) != 0) { + if (sp[csi] == 'r') { expansion = "RSR"; + len = 1; + } else { + _nc_SPRINTF(buf2, _nc_SLIMIT(sizeof(buf2)) "1;%dr", tp_lines); + len = strlen(buf2); + if (strncmp(buf2, sp + csi, len) == 0) + expansion = "RSR"; + } + len += (size_t) csi; } /* now check for home-down */ - if (!expansion) - { - (void) sprintf(buf2, "\033[%d;1H", tp->Numbers[2]); + if (!expansion + && (csi = skip_csi(sp)) != 0) { + _nc_SPRINTF(buf2, _nc_SLIMIT(sizeof(buf2)) "%d;1H", tp_lines); len = strlen(buf2); - if (strncmp(buf2, sp, len) == 0) + if (strncmp(buf2, sp + csi, len) == 0) { + expansion = "LL"; + } else { + _nc_SPRINTF(buf2, _nc_SLIMIT(sizeof(buf2)) "%dH", tp_lines); + len = strlen(buf2); + if (strncmp(buf2, sp + csi, len) == 0) { expansion = "LL"; + } + } + len += (size_t) csi; } /* now look at the expansion we got, if any */ - if (expansion) - { - (void) sprintf(buf + strlen(buf), "{%s}", expansion); + if (expansion) { + printf("{%s}", expansion); sp += len - 1; - continue; - } - else - { + } else { /* couldn't match anything */ buf2[0] = *sp; buf2[1] = '\0'; - (void) strcat(buf, expand(buf2)); + fputs(TIC_EXPAND(buf2), stdout); } } - (void) printf("%s\n", buf); + putchar('\n'); } /*************************************************************************** @@ -584,49 +1002,52 @@ static void analyze_string(const char *name, const char *cap, TERMTYPE *tp) * ***************************************************************************/ -static void file_comparison(int argc, char *argv[]) +static void +file_comparison(int argc, char *argv[]) { #define MAXCOMPARE 2 /* someday we may allow comparisons on more files */ - int filecount = 0; - ENTRY *heads[MAXCOMPARE]; - ENTRY *tails[MAXCOMPARE]; - ENTRY *qp, *rp; - int i, n; + int filecount = 0; + ENTRY *heads[MAXCOMPARE]; + ENTRY *qp, *rp; + int i, n; - dump_init((char *)NULL, F_LITERAL, S_TERMINFO, 0, itrace); + memset(heads, 0, sizeof(heads)); + dump_init((char *) 0, F_LITERAL, S_TERMINFO, + FALSE, 0, 65535, itrace, FALSE, FALSE, FALSE); - for (n = 0; n < argc && n < MAXCOMPARE; n++) - { - if (freopen(argv[n], "r", stdin) == NULL) + for (n = 0; n < argc && n < MAXCOMPARE; n++) { + if (freopen(argv[n], "r", stdin) == 0) _nc_err_abort("Can't open %s", argv[n]); - _nc_head = _nc_tail = (ENTRY *)NULL; +#if NO_LEAKS + entered[n].head = _nc_head; + entered[n].tail = _nc_tail; +#endif + _nc_head = _nc_tail = 0; /* parse entries out of the source file */ _nc_set_source(argv[n]); - _nc_read_entry_source(stdin, NULL, TRUE, FALSE, NULLHOOK); + _nc_read_entry_source(stdin, NULL, TRUE, literal, NULLHOOK); if (itrace) - (void) fprintf(stderr, "Resolving file %d...\n",n-0); + (void) fprintf(stderr, "Resolving file %d...\n", n - 0); - /* do use resolution */ - if (!_nc_resolve_uses()) - { + /* maybe do use resolution */ + if (!_nc_resolve_uses2(!limited, literal)) { (void) fprintf(stderr, "There are unresolved use entries in %s:\n", argv[n]); - for_entry_list(qp) - if (qp->nuses) - { + for_entry_list(qp) { + if (qp->nuses) { (void) fputs(qp->tterm.term_names, stderr); (void) fputc('\n', stderr); } - exit(EXIT_FAILURE); + } + ExitProgram(EXIT_FAILURE); } heads[filecount] = _nc_head; - tails[filecount] = _nc_tail; filecount++; } @@ -634,30 +1055,17 @@ static void file_comparison(int argc, char *argv[]) if (itrace) (void) fprintf(stderr, "Entries are now in core...\n"); - /* - * The entry-matching loop. We're not using the use[] - * slots any more (they got zeroed out by resolve_uses) so - * we stash each entry's matches in the other file there. - * Sigh, this is intrinsically quadratic. - */ - for (qp = heads[0]; qp; qp = qp->next) - { + /* The entry-matching loop. Sigh, this is intrinsically quadratic. */ + for (qp = heads[0]; qp; qp = qp->next) { for (rp = heads[1]; rp; rp = rp->next) - if (_nc_entry_match(qp->tterm.term_names,rp->tterm.term_names)) - { - /* - * This is why the uses structure parent element is - * (void *) -- so we can have either (char *) for - * names or entry structure pointers in them and still - * be type-safe. - */ - if (qp->nuses < MAX_USES) - qp->uses[qp->nuses].parent = (void *)rp; - qp->nuses++; - - if (rp->nuses < MAX_USES) - rp->uses[rp->nuses].parent = (void *)qp; - rp->nuses++; + if (_nc_entry_match(qp->tterm.term_names, rp->tterm.term_names)) { + if (qp->ncrosslinks < MAX_CROSSLINKS) + qp->crosslinks[qp->ncrosslinks] = rp; + qp->ncrosslinks++; + + if (rp->ncrosslinks < MAX_CROSSLINKS) + rp->crosslinks[rp->ncrosslinks] = qp; + rp->ncrosslinks++; } } @@ -665,505 +1073,882 @@ static void file_comparison(int argc, char *argv[]) if (itrace) (void) fprintf(stderr, "Name matches are done...\n"); - for (qp = heads[0]; qp; qp = qp->next) - if (qp->nuses > 1) - { + for (qp = heads[0]; qp; qp = qp->next) { + if (qp->ncrosslinks > 1) { (void) fprintf(stderr, "%s in file 1 (%s) has %d matches in file 2 (%s):\n", _nc_first_name(qp->tterm.term_names), argv[0], - qp->nuses, + qp->ncrosslinks, argv[1]); - for (i = 0; i < qp->nuses; i++) + for (i = 0; i < qp->ncrosslinks; i++) (void) fprintf(stderr, "\t%s\n", - _nc_first_name(((ENTRY *)qp->uses[i].parent)->tterm.term_names)); + _nc_first_name((qp->crosslinks[i])->tterm.term_names)); } - for (rp = heads[1]; rp; rp = rp->next) - if (rp->nuses > 1) - { + } + + for (rp = heads[1]; rp; rp = rp->next) { + if (rp->ncrosslinks > 1) { (void) fprintf(stderr, "%s in file 2 (%s) has %d matches in file 1 (%s):\n", _nc_first_name(rp->tterm.term_names), argv[1], - rp->nuses, + rp->ncrosslinks, argv[0]); - for (i = 0; i < rp->nuses; i++) + for (i = 0; i < rp->ncrosslinks; i++) (void) fprintf(stderr, "\t%s\n", - _nc_first_name(((ENTRY *)rp->uses[i].parent)->tterm.term_names)); + _nc_first_name((rp->crosslinks[i])->tterm.term_names)); } + } (void) printf("In file 1 (%s) only:\n", argv[0]); for (qp = heads[0]; qp; qp = qp->next) - if (qp->nuses == 0) + if (qp->ncrosslinks == 0) (void) printf("\t%s\n", _nc_first_name(qp->tterm.term_names)); (void) printf("In file 2 (%s) only:\n", argv[1]); for (rp = heads[1]; rp; rp = rp->next) - if (rp->nuses == 0) + if (rp->ncrosslinks == 0) (void) printf("\t%s\n", _nc_first_name(rp->tterm.term_names)); (void) printf("The following entries are equivalent:\n"); - for (qp = heads[0]; qp; qp = qp->next) - { - rp = (ENTRY *)qp->uses[0].parent; - - if (qp->nuses == 1 && entryeq(&qp->tterm, &rp->tterm)) - { - char name1[NAMESIZE], name2[NAMESIZE]; + for (qp = heads[0]; qp; qp = qp->next) { + if (qp->ncrosslinks == 1) { + rp = qp->crosslinks[0]; + + repair_acsc(&qp->tterm); + repair_acsc(&rp->tterm); +#if NCURSES_XNAMES + _nc_align_termtype(&qp->tterm, &rp->tterm); +#endif + if (entryeq(&qp->tterm, &rp->tterm) && useeq(qp, rp)) { + char name1[NAMESIZE], name2[NAMESIZE]; - (void) canonical_name(qp->tterm.term_names, name1); - (void) canonical_name(rp->tterm.term_names, name2); + (void) canonical_name(qp->tterm.term_names, name1); + (void) canonical_name(rp->tterm.term_names, name2); - (void) printf("%s = %s\n", name1, name2); + (void) printf("%s = %s\n", name1, name2); + } } } (void) printf("Differing entries:\n"); termcount = 2; - for (qp = heads[0]; qp; qp = qp->next) - { - rp = (ENTRY *)qp->uses[0].parent; + for (qp = heads[0]; qp; qp = qp->next) { - if (qp->nuses == 1 && !entryeq(&qp->tterm, &rp->tterm)) - { - char name1[NAMESIZE], name2[NAMESIZE]; + if (qp->ncrosslinks == 1) { + rp = qp->crosslinks[0]; +#if NCURSES_XNAMES + /* sorry - we have to do this on each pass */ + _nc_align_termtype(&qp->tterm, &rp->tterm); +#endif + if (!(entryeq(&qp->tterm, &rp->tterm) && useeq(qp, rp))) { + char name1[NAMESIZE], name2[NAMESIZE]; + char *names[3]; - memcpy(&term[0], &qp->tterm, sizeof(TERMTYPE)); - memcpy(&term[1], &rp->tterm, sizeof(TERMTYPE)); + names[0] = name1; + names[1] = name2; + names[2] = 0; - (void) canonical_name(qp->tterm.term_names, name1); - (void) canonical_name(rp->tterm.term_names, name2); + entries[0] = *qp; + entries[1] = *rp; - switch (compare) - { - case C_DIFFERENCE: - if (itrace) - (void)fprintf(stderr,"infocmp: dumping differences\n"); - (void) printf("comparing %s to %s.\n", name1, name2); - compare_entry(compare_predicate); - break; + (void) canonical_name(qp->tterm.term_names, name1); + (void) canonical_name(rp->tterm.term_names, name2); - case C_COMMON: - if (itrace) - (void) fprintf(stderr, - "infocmp: dumping common capabilities\n"); - (void) printf("comparing %s to %s.\n", name1, name2); - compare_entry(compare_predicate); - break; + switch (compare) { + case C_DIFFERENCE: + show_comparing(names); + compare_entry(compare_predicate, &entries->tterm, quiet); + break; - case C_NAND: - if (itrace) - (void) fprintf(stderr, - "infocmp: dumping differences\n"); - (void) printf("comparing %s to %s.\n", name1, name2); - compare_entry(compare_predicate); - break; + case C_COMMON: + show_comparing(names); + compare_entry(compare_predicate, &entries->tterm, quiet); + break; + + case C_NAND: + show_comparing(names); + compare_entry(compare_predicate, &entries->tterm, quiet); + break; + } } } } } -static void usage(void) +static void +usage(void) { - fprintf(stderr, -"usage: infocmp [-dcnILCuvV1T] [-s d| i| l| c] [-w width] [-A directory] [-B directory] [termname...]\n"); - exit(EXIT_FAILURE); +#define DATA(s) s "\n" + static const char head[] = + { + DATA("Usage: infocmp [options] [-A directory] [-B directory] [termname...]") + DATA("") + DATA("Options:") + }; +#undef DATA +#define DATA(s) s + static const char options[][45] = + { + " -0 print single-row" + ," -1 print single-column" + ," -C use termcap-names" + ," -D print database locations" + ," -E format output as C tables" + ," -F compare terminfo-files" + ," -G format %{number} to %'char'" + ," -I use terminfo-names" + ," -K use termcap-names and BSD syntax" + ," -L use long names" + ," -R subset (see manpage)" + ," -T eliminate size limits (test)" + ," -U do not post-process entries" + ," -V print version" + ," -W wrap long strings per -w[n]" +#if NCURSES_XNAMES + ," -a with -F, list commented-out caps" +#endif + ," -c list common capabilities" + ," -d list different capabilities" + ," -e format output for C initializer" + ," -f with -1, format complex strings" + ," -g format %'char' to %{number}" + ," -i analyze initialization/reset" + ," -l output terminfo names" + ," -n list capabilities in neither" + ," -p ignore padding specifiers" + ," -Q number dump compiled description" + ," -q brief listing, removes headers" + ," -r with -C, output in termcap form" + ," -r with -F, resolve use-references" + ," -s [d|i|l|c] sort fields" +#if NCURSES_XNAMES + ," -t suppress commented-out capabilities" +#endif + ," -u produce source with 'use='" + ," -v number (verbose)" + ," -w number (width)" +#if NCURSES_XNAMES + ," -x unknown capabilities are user-defined" +#endif + }; +#undef DATA + const size_t last = SIZEOF(options); + const size_t left = (last + 1) / 2; + size_t n; + + fputs(head, stderr); + for (n = 0; n < left; n++) { + size_t m = n + left; + if (m < last) + fprintf(stderr, "%-40.40s%s\n", options[n], options[m]); + else + fprintf(stderr, "%s\n", options[n]); + } + ExitProgram(EXIT_FAILURE); } -/*************************************************************************** - * - * Main sequence - * - ***************************************************************************/ +static char * +any_initializer(const char *fmt, const char *type) +{ + static char *initializer; + static size_t need; + char *s; + + if (initializer == 0) { + need = (strlen(entries->tterm.term_names) + + strlen(type) + + strlen(fmt)); + initializer = (char *) malloc(need + 1); + if (initializer == 0) + failed("any_initializer"); + } + + _nc_STRCPY(initializer, entries->tterm.term_names, need); + for (s = initializer; *s != 0 && *s != '|'; s++) { + if (!isalnum(UChar(*s))) + *s = '_'; + } + *s = 0; + _nc_SPRINTF(s, _nc_SLIMIT(need) fmt, type); + return initializer; +} -int main(int argc, char *argv[]) +static char * +name_initializer(const char *type) { - char *terminal, *firstdir, *restdir; - path tfile[MAXTERMS]; - int c, i, len; - bool filecompare = FALSE; - bool initdump = FALSE; - bool init_analyze = FALSE; - bool limited = TRUE; - - if ((terminal = getenv("TERM")) == NULL) - { - (void) fprintf(stderr, - "infocmp: environment variable TERM not set\n"); - return EXIT_FAILURE; + return any_initializer("_%s_data", type); +} + +static char * +string_variable(const char *type) +{ + return any_initializer("_s_%s", type); +} + +/* dump C initializers for the terminal type */ +static void +dump_initializers(TERMTYPE2 *term) +{ + unsigned n; + const char *str = 0; + + printf("\nstatic char %s[] = \"%s\";\n\n", + name_initializer("alias"), entries->tterm.term_names); + + for_each_string(n, term) { + char buf[MAX_STRING], *sp, *tp; + + if (VALID_STRING(term->Strings[n])) { + tp = buf; +#define TP_LIMIT ((MAX_STRING - 5) - (size_t)(tp - buf)) + *tp++ = '"'; + for (sp = term->Strings[n]; + *sp != 0 && TP_LIMIT > 2; + sp++) { + if (isascii(UChar(*sp)) + && isprint(UChar(*sp)) + && *sp != '\\' + && *sp != '"') + *tp++ = *sp; + else { + _nc_SPRINTF(tp, _nc_SLIMIT(TP_LIMIT) "\\%03o", UChar(*sp)); + tp += 4; + } + } + *tp++ = '"'; + *tp = '\0'; + (void) printf("static char %-20s[] = %s;\n", + string_variable(ExtStrname(term, (int) n, strnames)), + buf); } + } + printf("\n"); - /* where is the terminfo database location going to default to? */ - restdir = firstdir = 0; + (void) printf("static char %s[] = %s\n", name_initializer("bool"), L_CURL); - while ((c = getopt(argc, argv, "decCFIinlLprR:s:uv:Vw:A:B:1T")) != EOF) - switch (c) - { - case 'd': - compare = C_DIFFERENCE; - break; + for_each_boolean(n, term) { + switch ((int) (term->Booleans[n])) { + case TRUE: + str = "TRUE"; + break; - case 'e': - initdump = TRUE; - break; + case FALSE: + str = "FALSE"; + break; - case 'c': - compare = C_COMMON; - break; + case ABSENT_BOOLEAN: + str = "ABSENT_BOOLEAN"; + break; - case 'C': - outform = F_TERMCAP; - tversion = "BSD"; - if (sortmode == S_DEFAULT) - sortmode = S_TERMCAP; - break; + case CANCELLED_BOOLEAN: + str = "CANCELLED_BOOLEAN"; + break; + } + (void) printf("\t/* %3u: %-8s */\t%s,\n", + n, ExtBoolname(term, (int) n, boolnames), str); + } + (void) printf("%s;\n", R_CURL); + + (void) printf("static short %s[] = %s\n", name_initializer("number"), L_CURL); + + for_each_number(n, term) { + char buf[BUFSIZ]; + switch (term->Numbers[n]) { + case ABSENT_NUMERIC: + str = "ABSENT_NUMERIC"; + break; + case CANCELLED_NUMERIC: + str = "CANCELLED_NUMERIC"; + break; + default: + _nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf)) "%d", term->Numbers[n]); + str = buf; + break; + } + (void) printf("\t/* %3u: %-8s */\t%s,\n", n, + ExtNumname(term, (int) n, numnames), str); + } + (void) printf("%s;\n", R_CURL); - case 'F': - filecompare = TRUE; - break; + (void) printf("static char * %s[] = %s\n", name_initializer("string"), L_CURL); - case 'i': - init_analyze = TRUE; - break; + for_each_string(n, term) { - case 'l': - outform = F_TERMINFO; - break; + if (term->Strings[n] == ABSENT_STRING) + str = "ABSENT_STRING"; + else if (term->Strings[n] == CANCELLED_STRING) + str = "CANCELLED_STRING"; + else { + str = string_variable(ExtStrname(term, (int) n, strnames)); + } + (void) printf("\t/* %3u: %-8s */\t%s,\n", n, + ExtStrname(term, (int) n, strnames), str); + } + (void) printf("%s;\n", R_CURL); + +#if NCURSES_XNAMES + if ((NUM_BOOLEANS(term) != BOOLCOUNT) + || (NUM_NUMBERS(term) != NUMCOUNT) + || (NUM_STRINGS(term) != STRCOUNT)) { + (void) printf("static char * %s[] = %s\n", + name_initializer("string_ext"), L_CURL); + for (n = BOOLCOUNT; n < NUM_BOOLEANS(term); ++n) { + (void) printf("\t/* %3u: bool */\t\"%s\",\n", + n, ExtBoolname(term, (int) n, boolnames)); + } + for (n = NUMCOUNT; n < NUM_NUMBERS(term); ++n) { + (void) printf("\t/* %3u: num */\t\"%s\",\n", + n, ExtNumname(term, (int) n, numnames)); + } + for (n = STRCOUNT; n < NUM_STRINGS(term); ++n) { + (void) printf("\t/* %3u: str */\t\"%s\",\n", + n, ExtStrname(term, (int) n, strnames)); + } + (void) printf("%s;\n", R_CURL); + } +#endif +} - case 'L': - outform = F_VARIABLE; - if (sortmode == S_DEFAULT) - sortmode = S_VARIABLE; - break; +/* dump C initializers for the terminal type */ +static void +dump_termtype(TERMTYPE2 *term) +{ + (void) printf("\t%s\n\t\t%s,\n", L_CURL, name_initializer("alias")); + (void) printf("\t\t(char *)0,\t/* pointer to string table */\n"); + + (void) printf("\t\t%s,\n", name_initializer("bool")); + (void) printf("\t\t%s,\n", name_initializer("number")); + + (void) printf("\t\t%s,\n", name_initializer("string")); + +#if NCURSES_XNAMES + (void) printf("#if NCURSES_XNAMES\n"); + (void) printf("\t\t(char *)0,\t/* pointer to extended string table */\n"); + (void) printf("\t\t%s,\t/* ...corresponding names */\n", + ((NUM_BOOLEANS(term) != BOOLCOUNT) + || (NUM_NUMBERS(term) != NUMCOUNT) + || (NUM_STRINGS(term) != STRCOUNT)) + ? name_initializer("string_ext") + : "(char **)0"); + + (void) printf("\t\t%d,\t\t/* count total Booleans */\n", NUM_BOOLEANS(term)); + (void) printf("\t\t%d,\t\t/* count total Numbers */\n", NUM_NUMBERS(term)); + (void) printf("\t\t%d,\t\t/* count total Strings */\n", NUM_STRINGS(term)); + + (void) printf("\t\t%d,\t\t/* count extensions to Booleans */\n", + NUM_BOOLEANS(term) - BOOLCOUNT); + (void) printf("\t\t%d,\t\t/* count extensions to Numbers */\n", + NUM_NUMBERS(term) - NUMCOUNT); + (void) printf("\t\t%d,\t\t/* count extensions to Strings */\n", + NUM_STRINGS(term) - STRCOUNT); + + (void) printf("#endif /* NCURSES_XNAMES */\n"); +#else + (void) term; +#endif /* NCURSES_XNAMES */ + (void) printf("\t%s\n", R_CURL); +} - case 'n': - compare = C_NAND; - break; +static int +optarg_to_number(void) +{ + char *temp = 0; + long value = strtol(optarg, &temp, 0); - case 'p': - ignorepads = TRUE; - break; + if (temp == 0 || temp == optarg || *temp != 0) { + fprintf(stderr, "Expected a number, not \"%s\"\n", optarg); + ExitProgram(EXIT_FAILURE); + } + return (int) value; +} - case 'r': - tversion = (char *)NULL; - break; +static char * +terminal_env(void) +{ + char *terminal; - case 'R': - tversion = optarg; - break; + if ((terminal = getenv("TERM")) == 0) { + (void) fprintf(stderr, + "%s: environment variable TERM not set\n", + _nc_progname); + exit(EXIT_FAILURE); + } + return terminal; +} - case 's': - if (*optarg == 'd') - sortmode = S_NOSORT; - else if (*optarg == 'i') - sortmode = S_TERMINFO; - else if (*optarg == 'l') - sortmode = S_VARIABLE; - else if (*optarg == 'c') - sortmode = S_TERMCAP; - else - { - (void) fprintf(stderr, - "infocmp: unknown sort mode\n"); - return EXIT_FAILURE; - } - break; +/* + * Show the databases that infocmp knows about. The location to which it writes is + */ +static void +show_databases(void) +{ + DBDIRS state; + int offset; + const char *path2; - case 'u': - compare = C_USEALL; - break; + _nc_first_db(&state, &offset); + while ((path2 = _nc_next_db(&state, &offset)) != 0) { + printf("%s\n", path2); + } + _nc_last_db(); +} - case 'v': - itrace = atoi(optarg); - _nc_tracing = (1 << itrace) - 1; - break; +/*************************************************************************** + * + * Main sequence + * + ***************************************************************************/ - case 'V': - (void) fputs(NCURSES_VERSION, stdout); - putchar('\n'); - ExitProgram(EXIT_SUCCESS); +#if NO_LEAKS +#define MAIN_LEAKS() \ + free(myargv); \ + free(tfile); \ + free(tname) +#else +#define MAIN_LEAKS() /* nothing */ +#endif - case 'w': - mwidth = atoi(optarg); - break; +int +main(int argc, char *argv[]) +{ + /* Avoid "local data >32k" error with mwcc */ + /* Also avoid overflowing smaller stacks on systems like AmigaOS */ + path *tfile = 0; + char **tname = 0; + size_t maxterms; + + char **myargv; + + char *firstdir, *restdir; + int c, i, len; + bool formatted = FALSE; + bool filecompare = FALSE; + int initdump = 0; + bool init_analyze = FALSE; + bool suppress_untranslatable = FALSE; + int quickdump = 0; + bool wrap_strings = FALSE; + + /* where is the terminfo database location going to default to? */ + restdir = firstdir = 0; + +#if NCURSES_XNAMES + use_extended_names(FALSE); +#endif + _nc_strict_bsd = 0; + + _nc_progname = _nc_rootname(argv[0]); + + /* make sure we have enough space to add two terminal entries */ + myargv = typeCalloc(char *, (size_t) (argc + 3)); + if (myargv == 0) + failed("myargv"); + + memcpy(myargv, argv, (sizeof(char *) * (size_t) argc)); + argv = myargv; + + while ((c = getopt(argc, + argv, + "01A:aB:CcDdEeFfGgIiKLlnpQ:qR:rs:TtUuVv:Ww:x")) != -1) { + switch (c) { + case '0': + mwidth = 65535; + mheight = 1; + break; + + case '1': + mwidth = 0; + break; + + case 'A': + firstdir = optarg; + break; + +#if NCURSES_XNAMES + case 'a': + _nc_disable_period = TRUE; + use_extended_names(TRUE); + break; +#endif + case 'B': + restdir = optarg; + break; + + case 'K': + _nc_strict_bsd = 1; + /* FALLTHRU */ + case 'C': + outform = F_TERMCAP; + tversion = "BSD"; + if (sortmode == S_DEFAULT) + sortmode = S_TERMCAP; + break; + + case 'D': + show_databases(); + ExitProgram(EXIT_SUCCESS); + break; + + case 'c': + compare = C_COMMON; + break; + + case 'd': + compare = C_DIFFERENCE; + break; + + case 'E': + initdump |= 2; + break; + + case 'e': + initdump |= 1; + break; + + case 'F': + filecompare = TRUE; + break; + + case 'f': + formatted = TRUE; + break; + + case 'G': + numbers = 1; + break; + + case 'g': + numbers = -1; + break; + + case 'I': + outform = F_TERMINFO; + if (sortmode == S_DEFAULT) + sortmode = S_VARIABLE; + tversion = 0; + break; + + case 'i': + init_analyze = TRUE; + break; + + case 'L': + outform = F_VARIABLE; + if (sortmode == S_DEFAULT) + sortmode = S_VARIABLE; + break; + + case 'l': + outform = F_TERMINFO; + break; + + case 'n': + compare = C_NAND; + break; + + case 'p': + ignorepads = TRUE; + break; + + case 'Q': + quickdump = optarg_to_number(); + break; + + case 'q': + quiet = TRUE; + s_absent = "-"; + s_cancel = "@"; + bool_sep = ", "; + break; + + case 'R': + tversion = optarg; + break; + + case 'r': + tversion = 0; + break; + + case 's': + if (*optarg == 'd') + sortmode = S_NOSORT; + else if (*optarg == 'i') + sortmode = S_TERMINFO; + else if (*optarg == 'l') + sortmode = S_VARIABLE; + else if (*optarg == 'c') + sortmode = S_TERMCAP; + else { + (void) fprintf(stderr, + "%s: unknown sort mode\n", + _nc_progname); + ExitProgram(EXIT_FAILURE); + } + break; - case 'A': - firstdir = optarg; - break; + case 'T': + limited = FALSE; + break; - case 'B': - restdir = optarg; - break; +#if NCURSES_XNAMES + case 't': + _nc_disable_period = FALSE; + suppress_untranslatable = TRUE; + break; +#endif - case '1': - mwidth = 0; - break; - case 'T': - limited = FALSE; - break; - default: - usage(); - } + case 'U': + literal = TRUE; + break; - /* by default, sort by terminfo name */ - if (sortmode == S_DEFAULT) - sortmode = S_TERMINFO; + case 'u': + compare = C_USEALL; + break; - /* set up for display */ - dump_init(tversion, outform, sortmode, mwidth, itrace); + case 'V': + puts(curses_version()); + ExitProgram(EXIT_SUCCESS); - /* make sure we have at least one terminal name to work with */ - if (optind >= argc) - argv[argc++] = terminal; + case 'v': + itrace = (unsigned) optarg_to_number(); + set_trace_level(itrace); + break; - /* if user is after a comparison, make sure we have two entries */ - if (compare != C_DEFAULT && optind >= argc - 1) - argv[argc++] = terminal; + case 'W': + wrap_strings = TRUE; + break; - /* exactly two terminal names with no options means do -d */ - if (argc - optind == 2 && compare == C_DEFAULT) - compare = C_DIFFERENCE; + case 'w': + mwidth = optarg_to_number(); + break; - if (!filecompare) - { - /* grab the entries */ - termcount = 0; - for (; optind < argc; optind++) - { - if (termcount >= MAXTERMS) - { - (void) fprintf(stderr, - "infocmp: too many terminal type arguments\n"); - return EXIT_FAILURE; - } - else - { - const char *directory = termcount ? restdir : firstdir; - int status; - - tname[termcount] = argv[optind]; - - if (directory) - { - (void) sprintf(tfile[termcount], "%s/%c/%s", - directory, - *argv[optind], argv[optind]); - if (itrace) - (void) fprintf(stderr, - "infocmp: reading entry %s from file %s\n", - argv[optind], tfile[termcount]); - - status = _nc_read_file_entry(tfile[termcount], - &term[termcount]); - } - else - { - if (itrace) - (void) fprintf(stderr, - "infocmp: reading entry %s from system directories %s\n", - argv[optind], tname[termcount]); - - status = _nc_read_entry(tname[termcount], - tfile[termcount], - &term[termcount]); - directory = TERMINFO; /* for error message */ - } +#if NCURSES_XNAMES + case 'x': + use_extended_names(TRUE); + break; +#endif - if (status <= 0) - { - (void) fprintf(stderr, - "infocmp: couldn't open terminfo file %s.\n", - tfile[termcount]); - return EXIT_FAILURE; - } - termcount++; - } - } + default: + usage(); + } + } - /* dump as C initializer for the terminal type */ - if (initdump) - { - int n; - const char *str = 0; - int size; - - (void) printf("\t%s\n\t\t\"%s\",\n", - L_CURL, term->term_names); - (void) printf("\t\t(char *)0,\n"); - - (void) printf("\t\t%s /* BOOLEANS */\n", L_CURL); - for (n = 0; n < BOOLCOUNT; n++) - { - switch((int)(term->Booleans[n])) - { - case TRUE: - str = "TRUE"; - break; + maxterms = (size_t) (argc + 2 - optind); + if ((tfile = typeMalloc(path, maxterms)) == 0) + failed("tfile"); + if ((tname = typeCalloc(char *, maxterms)) == 0) + failed("tname"); + if ((entries = typeCalloc(ENTRY, maxterms)) == 0) + failed("entries"); +#if NO_LEAKS + if ((entered = typeCalloc(ENTERED, maxterms)) == 0) + failed("entered"); +#endif - case FALSE: - str = "FALSE"; - break; + if (tfile == 0 + || tname == 0 + || entries == 0) { + fprintf(stderr, "%s: not enough memory\n", _nc_progname); + ExitProgram(EXIT_FAILURE); + } - case ABSENT_BOOLEAN: - str = "ABSENT_BOOLEAN"; - break; + /* by default, sort by terminfo name */ + if (sortmode == S_DEFAULT) + sortmode = S_TERMINFO; + + /* make sure we have at least one terminal name to work with */ + if (optind >= argc) + argv[argc++] = terminal_env(); + + /* if user is after a comparison, make sure we have two entries */ + if (compare != C_DEFAULT && optind >= argc - 1) + argv[argc++] = terminal_env(); + + /* exactly one terminal name with no options means display it */ + /* exactly two terminal names with no options means do -d */ + if (compare == C_DEFAULT) { + switch (argc - optind) { + default: + fprintf(stderr, "%s: too many names to compare\n", _nc_progname); + ExitProgram(EXIT_FAILURE); + case 1: + break; + case 2: + compare = C_DIFFERENCE; + break; + } + } - case CANCELLED_BOOLEAN: - str = "CANCELLED_BOOLEAN"; - break; - } - (void) printf("\t\t/* %s */\t%s%s,\n", - boolnames[n], str, - n == BOOLCOUNT-1 ? R_CURL : ""); - } + /* set up for display */ + dump_init(tversion, outform, sortmode, + wrap_strings, mwidth, mheight, itrace, + formatted, FALSE, quickdump); + + if (!filecompare) { + /* grab the entries */ + termcount = 0; + for (; optind < argc; optind++) { + const char *directory = termcount ? restdir : firstdir; + int status; + + tname[termcount] = argv[optind]; + + if (directory) { +#if NCURSES_USE_DATABASE +#if MIXEDCASE_FILENAMES +#define LEAF_FMT "%c" +#else +#define LEAF_FMT "%02x" +#endif + _nc_SPRINTF(tfile[termcount], + _nc_SLIMIT(sizeof(path)) + "%s/" LEAF_FMT "/%s", + directory, + UChar(*argv[optind]), argv[optind]); + if (itrace) + (void) fprintf(stderr, + "%s: reading entry %s from file %s\n", + _nc_progname, + argv[optind], tfile[termcount]); + + status = _nc_read_file_entry(tfile[termcount], + &entries[termcount].tterm); +#else + (void) fprintf(stderr, "%s: terminfo files not supported\n", + _nc_progname); + MAIN_LEAKS(); + ExitProgram(EXIT_FAILURE); +#endif + } else { + if (itrace) + (void) fprintf(stderr, + "%s: reading entry %s from database\n", + _nc_progname, + tname[termcount]); - (void) printf("\t\t%s /* NUMERICS */\n", L_CURL); - for (n = 0; n < NUMCOUNT; n++) - { - char buf[BUFSIZ]; - switch (term->Numbers[n]) - { - case ABSENT_NUMERIC: - str = "ABSENT_NUMERIC"; - break; - case CANCELLED_NUMERIC: - str = "CANCELLED_NUMERIC"; - break; - default: - sprintf(buf, "%d", term->Numbers[n]); - str = buf; - break; - } - (void) printf("\t\t/* %s */\t%s%s,\n", - numnames[n], str, - n == NUMCOUNT-1 ? R_CURL : ""); - } + status = _nc_read_entry2(tname[termcount], + tfile[termcount], + &entries[termcount].tterm); + } - size = sizeof(TERMTYPE) - + (BOOLCOUNT * sizeof(term->Booleans[0])) - + (NUMCOUNT * sizeof(term->Numbers[0])); - - (void) printf("\t\t%s /* STRINGS */\n", L_CURL); - for (n = 0; n < STRCOUNT; n++) - { - char buf[BUFSIZ], *sp, *tp; - - if (term->Strings[n] == ABSENT_STRING) - str = "ABSENT_STRING"; - else if (term->Strings[n] == CANCELLED_STRING) - str = "CANCELLED_STRING"; - else - { - tp = buf; - *tp++ = '"'; - for (sp = term->Strings[n]; *sp; sp++) - if (isascii(*sp) && isprint(*sp) && *sp !='\\' && *sp != '"') - *tp++ = *sp; - else - { - (void) sprintf(tp, "\\%03o", *sp); - tp += 4; - } - *tp++ = '"'; - *tp = '\0'; - size += (strlen(term->Strings[n]) + 1); - str = buf; - } - (void) printf("\t\t/* %s */\t%s%s%s\n", - strnames[n], str, - n == STRCOUNT-1 ? R_CURL : "", - n == STRCOUNT-1 ? "" : ","); - } - (void) printf("\t%s /* size = %d */\n", R_CURL, size); - ExitProgram(EXIT_SUCCESS); + if (status <= 0) { + (void) fprintf(stderr, + "%s: couldn't open terminfo file %s.\n", + _nc_progname, + tfile[termcount]); + MAIN_LEAKS(); + ExitProgram(EXIT_FAILURE); } + repair_acsc(&entries[termcount].tterm); + termcount++; + } - /* analyze the init strings */ - if (init_analyze) - { +#if NCURSES_XNAMES + if (termcount > 1) + _nc_align_termtype(&entries[0].tterm, &entries[1].tterm); +#endif + + /* dump as C initializer for the terminal type */ + if (initdump) { + if (initdump & 1) + dump_termtype(&entries[0].tterm); + if (initdump & 2) + dump_initializers(&entries[0].tterm); + } + + /* analyze the init strings */ + else if (init_analyze) { #undef CUR -#define CUR term[0]. - analyze_string("is1", init_1string, &term[0]); - analyze_string("is2", init_2string, &term[0]); - analyze_string("is3", init_3string, &term[0]); - analyze_string("rs1", reset_1string, &term[0]); - analyze_string("rs2", reset_2string, &term[0]); - analyze_string("rs3", reset_3string, &term[0]); - analyze_string("smcup", enter_ca_mode, &term[0]); - analyze_string("rmcup", exit_ca_mode, &term[0]); +#define CUR entries[0].tterm. + analyze_string("is1", init_1string, &entries[0].tterm); + analyze_string("is2", init_2string, &entries[0].tterm); + analyze_string("is3", init_3string, &entries[0].tterm); + analyze_string("rs1", reset_1string, &entries[0].tterm); + analyze_string("rs2", reset_2string, &entries[0].tterm); + analyze_string("rs3", reset_3string, &entries[0].tterm); + analyze_string("smcup", enter_ca_mode, &entries[0].tterm); + analyze_string("rmcup", exit_ca_mode, &entries[0].tterm); + analyze_string("smkx", keypad_xmit, &entries[0].tterm); + analyze_string("rmkx", keypad_local, &entries[0].tterm); #undef CUR - ExitProgram(EXIT_SUCCESS); - } + } else { /* * Here's where the real work gets done */ - switch (compare) - { + switch (compare) { case C_DEFAULT: if (itrace) (void) fprintf(stderr, - "infocmp: about to dump %s\n", + "%s: about to dump %s\n", + _nc_progname, tname[0]); - (void) printf("#\tReconstructed via infocmp from file: %s\n", - tfile[0]); - len = dump_entry(&term[0], limited, NULL); - putchar('\n'); + if (!quiet) + (void) + printf("#\tReconstructed via infocmp from file: %s\n", + tfile[0]); + dump_entry(&entries[0].tterm, + suppress_untranslatable, + limited, + numbers, + NULL); + len = show_entry(); if (itrace) - (void)fprintf(stderr,"infocmp: length %d\n", len); + (void) fprintf(stderr, "%s: length %d\n", _nc_progname, len); break; case C_DIFFERENCE: - if (itrace) - (void)fprintf(stderr,"infocmp: dumping differences\n"); - (void) printf("comparing %s to %s.\n", tname[0], tname[1]); - compare_entry(compare_predicate); + show_comparing(tname); + compare_entry(compare_predicate, &entries->tterm, quiet); break; case C_COMMON: - if (itrace) - (void) fprintf(stderr, - "infocmp: dumping common capabilities\n"); - (void) printf("comparing %s to %s.\n", tname[0], tname[1]); - compare_entry(compare_predicate); + show_comparing(tname); + compare_entry(compare_predicate, &entries->tterm, quiet); break; case C_NAND: - if (itrace) - (void) fprintf(stderr, - "infocmp: dumping differences\n"); - (void) printf("comparing %s to %s.\n", tname[0], tname[1]); - compare_entry(compare_predicate); + show_comparing(tname); + compare_entry(compare_predicate, &entries->tterm, quiet); break; case C_USEALL: if (itrace) - (void) fprintf(stderr, "infocmp: dumping use entry\n"); - len = dump_entry(&term[0], limited, use_predicate); + (void) fprintf(stderr, "%s: dumping use entry\n", _nc_progname); + dump_entry(&entries[0].tterm, + suppress_untranslatable, + limited, + numbers, + use_predicate); for (i = 1; i < termcount; i++) - len += dump_uses(tname[i], !(outform==F_TERMCAP || outform==F_TCONVERR)); - putchar('\n'); + dump_uses(tname[i], !(outform == F_TERMCAP + || outform == F_TCONVERR)); + len = show_entry(); if (itrace) - (void)fprintf(stderr,"infocmp: length %d\n", len); + (void) fprintf(stderr, "%s: length %d\n", _nc_progname, len); break; } } - else if (compare == C_USEALL) - (void) fprintf(stderr, "Sorry, -u doesn't work with -F\n"); - else if (compare == C_DEFAULT) - (void) fprintf(stderr, "Use `tic -[CI] ' for this.\n"); - else if (argc - optind != 2) - (void) fprintf(stderr, - "File comparison needs exactly two file arguments.\n"); - else - file_comparison(argc-optind, argv+optind); + } else if (compare == C_USEALL) { + (void) fprintf(stderr, "Sorry, -u doesn't work with -F\n"); + } else if (compare == C_DEFAULT) { + (void) fprintf(stderr, "Use `tic -[CI] ' for this.\n"); + } else if (argc - optind != 2) { + (void) fprintf(stderr, + "File comparison needs exactly two file arguments.\n"); + } else { + file_comparison(argc - optind, argv + optind); + } - ExitProgram(EXIT_SUCCESS); + MAIN_LEAKS(); + ExitProgram(EXIT_SUCCESS); } /* infocmp.c ends here */