X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=progs%2Finfocmp.c;h=8d2cabeed1898e84e854fc27c69c0b8acf694f34;hp=d603353b4d56c2efb84880eca1674d1f57354135;hb=d4d1d81ab6fc1ad681ff120d925099f947fefcf3;hpb=661078ddbde3ce0f3b06e95642fbb9b5fef7dca1 diff --git a/progs/infocmp.c b/progs/infocmp.c index d603353b..8d2cabee 100644 --- a/progs/infocmp.c +++ b/progs/infocmp.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998 Free Software Foundation, Inc. * + * Copyright (c) 1998-2010,2011 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 * @@ -29,29 +29,29 @@ /**************************************************************************** * 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 -MODULE_ID("$Id: infocmp.c,v 1.34 1998/02/11 12:14:03 tom Exp $") +MODULE_ID("$Id: infocmp.c,v 1.108 2011/08/06 16:36:06 tom Exp $") #define L_CURL "{" #define R_CURL "}" -#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]; /*************************************************************************** * @@ -60,15 +60,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; @@ -82,25 +89,29 @@ static bool ignorepads; /* ignore pad prefixes when diffing */ #if NO_LEAKS #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); + while (termcount-- > 0) + _nc_free_termtype(&entries[termcount].tterm); + _nc_leaks_dump_entry(); + free(entries); + _nc_free_tic(code); } #endif -static char *canonical_name(char *ptr, char *buf) +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) + if ((bp = strchr(buf, '|')) != 0) *bp = '\0'; - return(buf); + return (buf); } /*************************************************************************** @@ -109,217 +120,330 @@ 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; + + if (e1->nuses != e2->nuses) + return (FALSE); - for (i = 0; i < BOOLCOUNT; i++) + /* 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(TERMTYPE *t1, TERMTYPE *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); - break; - } - break; +static void +dump_numeric(int val, char *buf) +/* display the value of a boolean capability */ +{ + switch (val) { + case ABSENT_NUMERIC: + strcpy(buf, s_absent); + break; + case CANCELLED_NUMERIC: + strcpy(buf, s_cancel); + break; + default: + sprintf(buf, "%d", val); + 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]); - break; +static void +dump_string(char *val, char *buf) +/* display the value of a string capability */ +{ + if (val == ABSENT_STRING) + strcpy(buf, s_absent); + else if (val == CANCELLED_STRING) + strcpy(buf, s_cancel); + else { + sprintf(buf, "'%.*s'", MAX_STRING - 3, TIC_EXPAND(val)); + } +} - 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]); - break; +static void +compare_predicate(PredType type, PredIdx idx, const char *name) +/* predicate function to use for entry difference reports */ +{ + register ENTRY *e1 = &entries[0]; + register ENTRY *e2 = &entries[1]; + char buf1[MAX_STRING], buf2[MAX_STRING]; + int b1, b2; + int n1, n2; + char *s1, *s2; + + switch (type) { + case CMP_BOOLEAN: + b1 = e1->tterm.Booleans[idx]; + b2 = e2->tterm.Booleans[idx]; + switch (compare) { + case C_DIFFERENCE: + if (!(b1 == ABSENT_BOOLEAN && b2 == ABSENT_BOOLEAN) && 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 == b2 && b1 != ABSENT_BOOLEAN) + (void) printf("\t%s= %s.\n", name, dump_boolean(b1)); + break; + + case C_NAND: + if (b1 == ABSENT_BOOLEAN && b2 == ABSENT_BOOLEAN) + (void) printf("\t!%s.\n", name); + break; + } + break; - case C_NAND: - if (t1->Numbers[idx]==-1 && t2->Numbers[idx] == -1) - (void) printf("\t!%s.\n", name); - break; - } + case CMP_NUMBER: + n1 = e1->tterm.Numbers[idx]; + n2 = e2->tterm.Numbers[idx]; + dump_numeric(n1, buf1); + dump_numeric(n2, buf2); + switch (compare) { + case C_DIFFERENCE: + if (!((n1 == ABSENT_NUMERIC && n2 == ABSENT_NUMERIC)) && n1 != n2) + (void) printf("\t%s: %s, %s.\n", name, buf1, buf2); + break; + + case C_COMMON: + if (n1 != ABSENT_NUMERIC && n2 != ABSENT_NUMERIC && n1 == n2) + (void) printf("\t%s= %s.\n", name, buf1); + break; + + case C_NAND: + if (n1 == ABSENT_NUMERIC && n2 == ABSENT_NUMERIC) + (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, _nc_tic_expand(s1, outform==F_TERMINFO)); - (void) strcat(buf1, "'"); - } - - if (s2 == (char *)NULL) - (void) strcpy(buf2, "NULL"); - else - { - (void) strcpy(buf2, "'"); - (void) strcat(buf2, _nc_tic_expand(s2, outform==F_TERMINFO)); - (void) strcat(buf2, "'"); - } - - (void) printf("\t%s: %s, %s.\n", - name, buf1, buf2); - } - break; + case CMP_STRING: + s1 = e1->tterm.Strings[idx]; + s2 = e2->tterm.Strings[idx]; + switch (compare) { + case C_DIFFERENCE: + if (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 && s2 && !capcmp(s1, s2)) - (void) printf("\t%s= '%s'.\n", name, _nc_tic_expand(s1, outform==F_TERMINFO)); - break; + case C_COMMON: + if (s1 && s2 && !capcmp(idx, s1, s2)) + (void) printf("\t%s= '%s'.\n", name, TIC_EXPAND(s1)); + break; - case C_NAND: - if (!s1 && !s2) - (void) printf("\t!%s.\n", name); - break; - } - break; + case C_NAND: + if (!s1 && !s2) + (void) printf("\t!%s.\n", name); + break; } + break; + + 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 && e2->nuses && useeq(e1, e2)) { + (void) fputs("\tuse: ", stdout); + print_uses(e1, stdout); + fputs(".\n", stdout); + } + break; + case C_NAND: + if (!e1->nuses && !e2->nuses) + (void) printf("\t!use.\n"); + break; + } + } } /*************************************************************************** @@ -328,114 +452,185 @@ static void compare_predicate(int type, int idx, const char *name) * ***************************************************************************/ -typedef struct {const char *from; const char *to;} assoc; +typedef struct { + const char *from; + const char *to; +} 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 */ + {"\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 */ /* 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} + {"\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 controls widely supported by emulators */ + {"\033=", "DECPAM"}, /* application keypad mode */ + {"\033>", "DECPNM"}, /* normal keypad mode */ + {"\033<", "DECANSI"}, /* enter ANSI mode */ + {"\033[!p", "DECSTR"}, /* soft reset */ + {"\033 F", "S7C1T"}, /* 7-bit controls */ + + {(char *) 0, (char *) 0} +}; + +static const assoc std_modes[] = +/* ECMA \E[ ... [hl] modes recognized by many emulators */ +{ + {"2", "AM"}, /* keyboard action mode */ + {"4", "IRM"}, /* insert/replace mode */ + {"12", "SRM"}, /* send/receive mode */ + {"20", "LNM"}, /* linefeed mode */ + {(char *) 0, (char *) 0} }; 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} + {"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} }; 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} + {"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} }; -static void analyze_string(const char *name, const char *cap, TERMTYPE *tp) +static int +skip_csi(const char *cap) { - char buf[MAX_TERMINFO_LENGTH]; - char buf2[MAX_TERMINFO_LENGTH]; - const char *sp, *ep; - const assoc *ap; + 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; ap++) { + size_t tlen = strlen(ap->from); + + if (same_param(ap->from, ep, tlen)) { + (void) strcat(dst, ap->to); + found = TRUE; + break; + } + } + + if (!found) + (void) strcat(dst, ep); + (void) strcat(dst, ";"); + } while + ((ep = strtok((char *) 0, ";"))); + + dst[strlen(dst) - 1] = '\0'; + + result = dst; + } + return result; +} + +static void +analyze_string(const char *name, const char *cap, TERMTYPE *tp) +{ + char buf2[MAX_TERMINFO_LENGTH]; + const char *sp; + const assoc *ap; + int tp_lines = tp->Numbers[2]; if (cap == ABSENT_STRING || cap == CANCELLED_STRING) 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') continue; - - if (cp != ABSENT_STRING && cp != CANCELLED_STRING && cp[0] && cp != cap) - { + if (cp != ABSENT_STRING && cp != CANCELLED_STRING && cp[0] && cp + != cap) { len = strlen(cp); (void) strncpy(buf2, sp, len); buf2[len] = '\0'; @@ -462,128 +657,126 @@ 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; 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'))) { + + (void) strcpy(buf2, (sp[next] == 'h') ? "ECMA+" : "ECMA-"); + (void) 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'))) { + + (void) strcpy(buf2, (sp[next] == 'h') ? "DEC+" : "DEC-"); + (void) 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]; + && (csi = skip_csi(sp)) != 0 + && (len = strspn(sp + csi, "0123456789;")) != 0 + && (len < sizeof(buf3)) + && (next = (size_t) csi + len) + && sp[next] == 'm') { (void) strcpy(buf2, "SGR:"); - (void) strncpy(buf3, sp + 2, len); - len += 3; + (void) 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; + (void) strcpy(buf2, "SGR:"); + strcat(buf2, ecma_highlights[0].to); 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 { + (void) sprintf(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) { + (void) sprintf(buf2, "%d;1H", tp_lines); len = strlen(buf2); - if (strncmp(buf2, sp, len) == 0) + if (strncmp(buf2, sp + csi, len) == 0) { + expansion = "LL"; + } else { + (void) sprintf(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, _nc_tic_expand(buf2, outform==F_TERMINFO)); + fputs(TIC_EXPAND(buf2), stdout); } } - (void) printf("%s\n", buf); + putchar('\n'); } /*************************************************************************** @@ -592,49 +785,47 @@ 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, 0, 65535, itrace, 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; + _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++; } @@ -642,30 +833,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++; } } @@ -673,114 +851,404 @@ 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]; - memcpy(&term[0], &qp->tterm, sizeof(TERMTYPE)); - memcpy(&term[1], &rp->tterm, sizeof(TERMTYPE)); + entries[0] = *qp; + entries[1] = *rp; - (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); - 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; + switch (compare) { + case C_DIFFERENCE: + if (itrace) + (void) fprintf(stderr, + "%s: dumping differences\n", + _nc_progname); + (void) printf("comparing %s to %s.\n", name1, name2); + 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", name1, name2); - compare_entry(compare_predicate); - break; + case C_COMMON: + if (itrace) + (void) fprintf(stderr, + "%s: dumping common capabilities\n", + _nc_progname); + (void) printf("comparing %s to %s.\n", name1, name2); + 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_NAND: + if (itrace) + (void) fprintf(stderr, + "%s: dumping differences\n", + _nc_progname); + (void) printf("comparing %s to %s.\n", name1, name2); + compare_entry(compare_predicate, &entries->tterm, quiet); + break; + + } + } + } + } +} + +static void +usage(void) +{ + static const char *tbl[] = + { + "Usage: infocmp [options] [-A directory] [-B directory] [termname...]" + ,"" + ,"Options:" + ," -0 print single-row" + ," -1 print single-column" + ," -K use termcap-names and BSD syntax" + ," -C use termcap-names" + ," -F compare terminfo-files" + ," -I use terminfo-names" + ," -L use long names" + ," -R subset (see manpage)" + ," -T eliminate size limits (test)" + ," -U eliminate post-processing of entries" + ," -V print version" +#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" + ," -E format output as C tables" + ," -f with -1, format complex strings" + ," -G format %{number} to %'char'" + ," -g format %'char' to %{number}" + ," -i analyze initialization/reset" + ," -l output terminfo names" + ," -n list capabilities in neither" + ," -p ignore padding specifiers" + ," -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 treat unknown capabilities as user-defined" +#endif + }; + const size_t first = 3; + const size_t last = SIZEOF(tbl); + const size_t left = (last - first + 1) / 2 + first; + size_t n; + + for (n = 0; n < left; n++) { + size_t m = (n < first) ? last : n + left - first; + if (m < last) + fprintf(stderr, "%-40.40s%s\n", tbl[n], tbl[m]); + else + fprintf(stderr, "%s\n", tbl[n]); + } + ExitProgram(EXIT_FAILURE); +} + +static char * +any_initializer(const char *fmt, const char *type) +{ + static char *initializer; + char *s; + + if (initializer == 0) + initializer = (char *) malloc(strlen(entries->tterm.term_names) + + strlen(type) + strlen(fmt)); + + (void) strcpy(initializer, entries->tterm.term_names); + for (s = initializer; *s != 0 && *s != '|'; s++) { + if (!isalnum(UChar(*s))) + *s = '_'; + } + *s = 0; + (void) sprintf(s, fmt, type); + return initializer; +} + +static char * +name_initializer(const char *type) +{ + 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(TERMTYPE *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; + *tp++ = '"'; + for (sp = term->Strings[n]; + *sp != 0 && (tp - buf) < MAX_STRING - 6; + sp++) { + if (isascii(UChar(*sp)) + && isprint(UChar(*sp)) + && *sp != '\\' + && *sp != '"') + *tp++ = *sp; + else { + (void) sprintf(tp, "\\%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"); + + (void) printf("static char %s[] = %s\n", name_initializer("bool"), L_CURL); + + for_each_boolean(n, term) { + switch ((int) (term->Booleans[n])) { + case TRUE: + str = "TRUE"; + break; + + case FALSE: + str = "FALSE"; + break; + + case ABSENT_BOOLEAN: + str = "ABSENT_BOOLEAN"; + 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: + sprintf(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); + + (void) printf("static char * %s[] = %s\n", name_initializer("string"), L_CURL); + + for_each_string(n, term) { + + 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 } -static void usage(void) +/* dump C initializers for the terminal type */ +static void +dump_termtype(TERMTYPE *term) { - fprintf(stderr, -"usage: infocmp [-dcnILCuvV1T] [-s d| i| l| c] [-w width] [-A directory] [-B directory] [termname...]\n"); + (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); +} + +static int +optarg_to_number(void) +{ + char *temp = 0; + long value = strtol(optarg, &temp, 0); + + if (temp == 0 || temp == optarg || *temp != 0) { + fprintf(stderr, "Expected a number, not \"%s\"\n", optarg); + ExitProgram(EXIT_FAILURE); + } + return (int) value; +} + +static char * +terminal_env(void) +{ + char *terminal; + + if ((terminal = getenv("TERM")) == 0) { + (void) fprintf(stderr, + "%s: environment variable TERM not set\n", + _nc_progname); exit(EXIT_FAILURE); + } + return terminal; } /*************************************************************************** @@ -789,400 +1257,414 @@ static void usage(void) * ***************************************************************************/ -int main(int argc, char *argv[]) +#if NO_LEAKS +#define MAIN_LEAKS() \ + free(myargv); \ + free(tfile); \ + free(tname) +#else +#define MAIN_LEAKS() /* nothing */ +#endif + +int +main(int argc, char *argv[]) { - char *terminal, *firstdir, *restdir; - /* Avoid "local data >32k" error with mwcc */ - /* Also avoid overflowing smaller stacks on systems like AmigaOS */ - path *tfile = malloc(sizeof(path)*MAXTERMS); - int c, i, len; - bool filecompare = FALSE; - bool initdump = FALSE; - bool init_analyze = FALSE; - bool limited = TRUE; - - if ((terminal = getenv("TERM")) == NULL) - { + /* 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; + + /* 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)); + memcpy(myargv, argv, (sizeof(char *) * (size_t) argc)); + argv = myargv; + + while ((c = getopt(argc, + argv, + "01A:aB:CcdEeFfGgIiKLlnpqR:rs:TtUuVv:w: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 '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': + 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, - "infocmp: environment variable TERM not set\n"); - return EXIT_FAILURE; + "%s: unknown sort mode\n", + _nc_progname); + ExitProgram(EXIT_FAILURE); + } + break; + + case 'T': + limited = FALSE; + break; + +#if NCURSES_XNAMES + case 't': + _nc_disable_period = FALSE; + suppress_untranslatable = TRUE; + break; +#endif + + case 'U': + literal = TRUE; + break; + + case 'u': + compare = C_USEALL; + break; + + case 'V': + puts(curses_version()); + ExitProgram(EXIT_SUCCESS); + + case 'v': + itrace = (unsigned) optarg_to_number(); + set_trace_level(itrace); + break; + + case 'w': + mwidth = optarg_to_number(); + break; + +#if NCURSES_XNAMES + case 'x': + use_extended_names(TRUE); + break; +#endif + + default: + usage(); } + } - /* where is the terminfo database location going to default to? */ - restdir = firstdir = 0; - - while ((c = getopt(argc, argv, "decCFIinlLprR:s:uv:Vw:A:B:1T")) != EOF) - switch (c) - { - case 'd': - compare = C_DIFFERENCE; - break; - - case 'e': - initdump = TRUE; - break; - - case 'c': - compare = C_COMMON; - break; - - case 'C': - outform = F_TERMCAP; - tversion = "BSD"; - if (sortmode == S_DEFAULT) - sortmode = S_TERMCAP; - break; - - case 'F': - filecompare = TRUE; - 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_TERMINFO; - break; - - case 'L': - outform = F_VARIABLE; - if (sortmode == S_DEFAULT) - sortmode = S_VARIABLE; - break; - - case 'n': - compare = C_NAND; - break; - - case 'p': - ignorepads = TRUE; - break; - - case 'r': - tversion = 0; - break; - - case 'R': - tversion = optarg; - 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, - "infocmp: unknown sort mode\n"); - return EXIT_FAILURE; - } - break; - - case 'u': - compare = C_USEALL; - break; - - case 'v': - itrace = atoi(optarg); - _nc_tracing = (1 << itrace) - 1; - break; - - case 'V': - (void) fputs(NCURSES_VERSION, stdout); - putchar('\n'); - ExitProgram(EXIT_SUCCESS); - - case 'w': - mwidth = atoi(optarg); - break; - - case 'A': - firstdir = optarg; - break; - - case 'B': - restdir = optarg; - break; - - case '1': - mwidth = 0; - break; - case 'T': - limited = FALSE; - break; - default: - usage(); - } + maxterms = (size_t) (argc + 2 - optind); + tfile = typeMalloc(path, maxterms); + tname = typeCalloc(char *, maxterms); + entries = typeCalloc(ENTRY, maxterms); - /* by default, sort by terminfo name */ - if (sortmode == S_DEFAULT) - sortmode = S_TERMINFO; + if (tfile == 0 + || tname == 0 + || entries == 0) { + fprintf(stderr, "%s: not enough memory\n", _nc_progname); + ExitProgram(EXIT_FAILURE); + } - /* set up for display */ - dump_init(tversion, outform, sortmode, mwidth, itrace); + /* 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; + /* set up for display */ + dump_init(tversion, outform, sortmode, mwidth, mheight, itrace, formatted); - /* if user is after a comparison, make sure we have two entries */ - if (compare != C_DEFAULT && optind >= argc - 1) - argv[argc++] = terminal; + /* make sure we have at least one terminal name to work with */ + if (optind >= argc) + argv[argc++] = terminal_env(); - /* exactly two terminal names with no options means do -d */ - if (argc - optind == 2 && compare == C_DEFAULT) - compare = C_DIFFERENCE; + /* if user is after a comparison, make sure we have two entries */ + if (compare != C_DEFAULT && optind >= argc - 1) + argv[argc++] = terminal_env(); - if (!filecompare) - { - /* grab the entries */ - termcount = 0; - for (; optind < argc; optind++) - { - if (termcount >= MAXTERMS) - { + /* exactly two terminal names with no options means do -d */ + if (argc - optind == 2 && compare == C_DEFAULT) + compare = C_DIFFERENCE; + + 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 USE_DATABASE +#if MIXEDCASE_FILENAMES +#define LEAF_FMT "%c" +#else +#define LEAF_FMT "%02x" +#endif + (void) sprintf(tfile[termcount], "%s/" LEAF_FMT "/%s", + directory, + UChar(*argv[optind]), argv[optind]); + if (itrace) (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 (status <= 0) - { - (void) fprintf(stderr, - "infocmp: couldn't open terminfo file %s.\n", - tfile[termcount]); - return EXIT_FAILURE; - } - termcount++; - } + "%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]); + + status = _nc_read_entry(tname[termcount], + tfile[termcount], + &entries[termcount].tterm); } - /* 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; - - case FALSE: - str = "FALSE"; - break; - - case ABSENT_BOOLEAN: - str = "ABSENT_BOOLEAN"; - 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 : ""); - } + 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++; + } - (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 : ""); - } +#if NCURSES_XNAMES + if (termcount > 1) + _nc_align_termtype(&entries[0].tterm, &entries[1].tterm); +#endif - 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 & 0xff); - 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); - } + /* 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 */ - if (init_analyze) - { + /* 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); #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'); + 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) fprintf(stderr, "%s: dumping differences\n", _nc_progname); (void) printf("comparing %s to %s.\n", tname[0], tname[1]); - compare_entry(compare_predicate); + compare_entry(compare_predicate, &entries->tterm, quiet); break; case C_COMMON: if (itrace) (void) fprintf(stderr, - "infocmp: dumping common capabilities\n"); + "%s: dumping common capabilities\n", + _nc_progname); (void) printf("comparing %s to %s.\n", tname[0], tname[1]); - compare_entry(compare_predicate); + compare_entry(compare_predicate, &entries->tterm, quiet); break; case C_NAND: if (itrace) (void) fprintf(stderr, - "infocmp: dumping differences\n"); + "%s: dumping differences\n", + _nc_progname); (void) printf("comparing %s to %s.\n", tname[0], tname[1]); - compare_entry(compare_predicate); + 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 */