Annotation of src/usr.bin/infocmp/infocmp.c, Revision 1.5
1.5 ! millert 1: /* $OpenBSD: infocmp.c,v 1.4 1999/05/08 20:30:44 millert Exp $ */
1.1 millert 2:
3: /****************************************************************************
1.2 millert 4: * Copyright (c) 1998,1999 Free Software Foundation, Inc. *
1.1 millert 5: * *
6: * Permission is hereby granted, free of charge, to any person obtaining a *
7: * copy of this software and associated documentation files (the *
8: * "Software"), to deal in the Software without restriction, including *
9: * without limitation the rights to use, copy, modify, merge, publish, *
10: * distribute, distribute with modifications, sublicense, and/or sell *
11: * copies of the Software, and to permit persons to whom the Software is *
12: * furnished to do so, subject to the following conditions: *
13: * *
14: * The above copyright notice and this permission notice shall be included *
15: * in all copies or substantial portions of the Software. *
16: * *
17: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
18: * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
19: * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
20: * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
21: * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
22: * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
23: * THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
24: * *
25: * Except as contained in this notice, the name(s) of the above copyright *
26: * holders shall not be used in advertising or otherwise to promote the *
27: * sale, use or other dealings in this Software without prior written *
28: * authorization. *
29: ****************************************************************************/
30:
31: /****************************************************************************
32: * Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 *
33: * and: Eric S. Raymond <esr@snark.thyrsus.com> *
34: ****************************************************************************/
35:
36:
37: /*
38: * infocmp.c -- decompile an entry, or compare two entries
39: * written by Eric S. Raymond
40: */
41:
42: #include <progs.priv.h>
43:
44: #include <term_entry.h>
45: #include <dump_entry.h>
46:
1.5 ! millert 47: MODULE_ID("$From: infocmp.c,v 1.44 1999/06/16 00:39:48 tom Exp $")
1.1 millert 48:
49: #define L_CURL "{"
50: #define R_CURL "}"
51:
52: #define MAXTERMS 32 /* max # terminal arguments we can handle */
53:
54: const char *_nc_progname = "infocmp";
55:
56: typedef char path[PATH_MAX];
57:
58: /***************************************************************************
59: *
60: * The following control variables, together with the contents of the
61: * terminfo entries, completely determine the actions of the program.
62: *
63: ***************************************************************************/
64:
65: static char *tname[MAXTERMS]; /* terminal type names */
66: static TERMTYPE term[MAXTERMS]; /* terminfo entries */
67: static int termcount; /* count of terminal entries */
68:
69: static const char *tversion; /* terminfo version selected */
1.3 millert 70: static int numbers = 0; /* format "%'char'" to/from "%{number}" */
1.1 millert 71: static int outform; /* output format */
72: static int sortmode; /* sort_mode */
73: static int itrace; /* trace flag for debugging */
74: static int mwidth = 60;
75:
76: /* main comparison mode */
77: static int compare;
78: #define C_DEFAULT 0 /* don't force comparison mode */
79: #define C_DIFFERENCE 1 /* list differences between two terminals */
80: #define C_COMMON 2 /* list common capabilities */
81: #define C_NAND 3 /* list capabilities in neither terminal */
82: #define C_USEALL 4 /* generate relative use-form entry */
83: static bool ignorepads; /* ignore pad prefixes when diffing */
84:
85: #if NO_LEAKS
86: #undef ExitProgram
87: static void ExitProgram(int code) GCC_NORETURN;
88: static void ExitProgram(int code)
89: {
90: while (termcount-- > 0)
1.4 millert 91: _nc_free_termtype(&term[termcount]);
1.1 millert 92: _nc_leaks_dump_entry();
93: _nc_free_and_exit(code);
94: }
95: #endif
96:
97: static char *canonical_name(char *ptr, char *buf)
98: /* extract the terminal type's primary name */
99: {
100: char *bp;
101:
102: (void) strcpy(buf, ptr);
103: if ((bp = strchr(buf, '|')) != (char *)NULL)
104: *bp = '\0';
105:
106: return(buf);
107: }
108:
109: /***************************************************************************
110: *
111: * Predicates for dump function
112: *
113: ***************************************************************************/
114:
115: static int capcmp(const char *s, const char *t)
116: /* capability comparison function */
117: {
118: if (!VALID_STRING(s) && !VALID_STRING(t))
119: return(0);
120: else if (!VALID_STRING(s) || !VALID_STRING(t))
121: return(1);
122:
123: if (ignorepads)
124: return(_nc_capcmp(s, t));
125: else
126: return(strcmp(s, t));
127: }
128:
129: static int use_predicate(int type, int idx)
130: /* predicate function to use for use decompilation */
131: {
132: TERMTYPE *tp;
133:
134: switch(type)
135: {
136: case BOOLEAN: {
137: int is_set = FALSE;
138:
139: /*
140: * This assumes that multiple use entries are supposed
141: * to contribute the logical or of their boolean capabilities.
142: * This is true if we take the semantics of multiple uses to
143: * be 'each capability gets the first non-default value found
144: * in the sequence of use entries'.
145: */
146: for (tp = &term[1]; tp < term + termcount; tp++)
147: if (tp->Booleans[idx]) {
148: is_set = TRUE;
149: break;
150: }
151: if (is_set != term->Booleans[idx])
152: return(!is_set);
153: else
154: return(FAIL);
155: }
156:
157: case NUMBER: {
158: int value = ABSENT_NUMERIC;
159:
160: /*
161: * We take the semantics of multiple uses to be 'each
162: * capability gets the first non-default value found
163: * in the sequence of use entries'.
164: */
165: for (tp = &term[1]; tp < term + termcount; tp++)
166: if (tp->Numbers[idx] >= 0) {
167: value = tp->Numbers[idx];
168: break;
169: }
170:
171: if (value != term->Numbers[idx])
172: return(value != ABSENT_NUMERIC);
173: else
174: return(FAIL);
175: }
176:
177: case STRING: {
178: char *termstr, *usestr = ABSENT_STRING;
179:
180: termstr = term->Strings[idx];
181:
182: /*
183: * We take the semantics of multiple uses to be 'each
184: * capability gets the first non-default value found
185: * in the sequence of use entries'.
186: */
187: for (tp = &term[1]; tp < term + termcount; tp++)
188: if (tp->Strings[idx])
189: {
190: usestr = tp->Strings[idx];
191: break;
192: }
193:
194: if (usestr == ABSENT_STRING && termstr == ABSENT_STRING)
195: return(FAIL);
196: else if (!usestr || !termstr || capcmp(usestr, termstr))
197: return(TRUE);
198: else
199: return(FAIL);
200: }
201: }
202:
203: return(FALSE); /* pacify compiler */
204: }
205:
206: static bool entryeq(TERMTYPE *t1, TERMTYPE *t2)
207: /* are two terminal types equal */
208: {
209: int i;
210:
1.2 millert 211: for (i = 0; i < NUM_BOOLEANS(t1); i++)
1.1 millert 212: if (t1->Booleans[i] != t2->Booleans[i])
213: return(FALSE);
214:
1.2 millert 215: for (i = 0; i < NUM_NUMBERS(t1); i++)
1.1 millert 216: if (t1->Numbers[i] != t2->Numbers[i])
217: return(FALSE);
218:
1.2 millert 219: for (i = 0; i < NUM_STRINGS(t1); i++)
1.1 millert 220: if (capcmp(t1->Strings[i], t2->Strings[i]))
221: return(FALSE);
222:
223: return(TRUE);
224: }
225:
226: #define TIC_EXPAND(result) _nc_tic_expand(result, outform==F_TERMINFO, numbers)
227:
228: static void compare_predicate(int type, int idx, const char *name)
229: /* predicate function to use for entry difference reports */
230: {
231: register TERMTYPE *t1 = &term[0];
232: register TERMTYPE *t2 = &term[1];
233: char *s1, *s2;
234:
235: switch(type)
236: {
237: case BOOLEAN:
238: switch(compare)
239: {
240: case C_DIFFERENCE:
241: if (t1->Booleans[idx] != t2->Booleans[idx])
242: (void) printf("\t%s: %c:%c.\n",
243: name,
244: t1->Booleans[idx] ? 'T' : 'F',
245: t2->Booleans[idx] ? 'T' : 'F');
246: break;
247:
248: case C_COMMON:
249: if (t1->Booleans[idx] && t2->Booleans[idx])
250: (void) printf("\t%s= T.\n", name);
251: break;
252:
253: case C_NAND:
254: if (!t1->Booleans[idx] && !t2->Booleans[idx])
255: (void) printf("\t!%s.\n", name);
256: break;
257: }
258: break;
259:
260: case NUMBER:
261: switch(compare)
262: {
263: case C_DIFFERENCE:
264: if (t1->Numbers[idx] != t2->Numbers[idx])
265: (void) printf("\t%s: %d:%d.\n",
266: name, t1->Numbers[idx], t2->Numbers[idx]);
267: break;
268:
269: case C_COMMON:
270: if (t1->Numbers[idx]!=-1 && t2->Numbers[idx]!=-1
271: && t1->Numbers[idx] == t2->Numbers[idx])
272: (void) printf("\t%s= %d.\n", name, t1->Numbers[idx]);
273: break;
274:
275: case C_NAND:
276: if (t1->Numbers[idx]==-1 && t2->Numbers[idx] == -1)
277: (void) printf("\t!%s.\n", name);
278: break;
279: }
280: break;
281:
282: case STRING:
283: s1 = t1->Strings[idx];
284: s2 = t2->Strings[idx];
285: switch(compare)
286: {
287: case C_DIFFERENCE:
288: if (capcmp(s1, s2))
289: {
290: char buf1[BUFSIZ], buf2[BUFSIZ];
291:
292: if (s1 == (char *)NULL)
293: (void) strcpy(buf1, "NULL");
294: else
295: {
296: (void) strcpy(buf1, "'");
297: (void) strcat(buf1, TIC_EXPAND(s1));
298: (void) strcat(buf1, "'");
299: }
300:
301: if (s2 == (char *)NULL)
302: (void) strcpy(buf2, "NULL");
303: else
304: {
305: (void) strcpy(buf2, "'");
306: (void) strcat(buf2, TIC_EXPAND(s2));
307: (void) strcat(buf2, "'");
308: }
309:
310: if (strcmp(buf1, buf2))
311: (void) printf("\t%s: %s, %s.\n",
312: name, buf1, buf2);
313: }
314: break;
315:
316: case C_COMMON:
317: if (s1 && s2 && !capcmp(s1, s2))
318: (void) printf("\t%s= '%s'.\n", name, TIC_EXPAND(s1));
319: break;
320:
321: case C_NAND:
322: if (!s1 && !s2)
323: (void) printf("\t!%s.\n", name);
324: break;
325: }
326: break;
327: }
328:
329: }
330:
331: /***************************************************************************
332: *
333: * Init string analysis
334: *
335: ***************************************************************************/
336:
337: typedef struct {const char *from; const char *to;} assoc;
338:
339: static const assoc std_caps[] =
340: {
341: /* these are specified by X.364 and iBCS2 */
342: {"\033c", "RIS"}, /* full reset */
343: {"\0337", "SC"}, /* save cursor */
344: {"\0338", "RC"}, /* restore cursor */
345: {"\033[r", "RSR"}, /* not an X.364 mnemonic */
346: {"\033[m", "SGR0"}, /* not an X.364 mnemonic */
347: {"\033[2J", "ED2"}, /* clear page */
348:
349: /* this group is specified by ISO 2022 */
350: {"\033(0", "ISO DEC G0"}, /* enable DEC graphics for G0 */
351: {"\033(A", "ISO UK G0"}, /* enable UK chars for G0 */
352: {"\033(B", "ISO US G0"}, /* enable US chars for G0 */
353: {"\033)0", "ISO DEC G1"}, /* enable DEC graphics for G1 */
354: {"\033)A", "ISO UK G1"}, /* enable UK chars for G1 */
355: {"\033)B", "ISO US G1"}, /* enable US chars for G1 */
356:
357: /* these are DEC private modes widely supported by emulators */
358: {"\033=", "DECPAM"}, /* application keypad mode */
359: {"\033>", "DECPNM"}, /* normal keypad mode */
360: {"\033<", "DECANSI"}, /* enter ANSI mode */
361:
362: { (char *)0, (char *)0}
363: };
364:
365: static const assoc private_modes[] =
366: /* DEC \E[ ... [hl] modes recognized by many emulators */
367: {
368: {"1", "CKM"}, /* application cursor keys */
369: {"2", "ANM"}, /* set VT52 mode */
370: {"3", "COLM"}, /* 132-column mode */
371: {"4", "SCLM"}, /* smooth scroll */
372: {"5", "SCNM"}, /* reverse video mode */
373: {"6", "OM"}, /* origin mode */
374: {"7", "AWM"}, /* wraparound mode */
375: {"8", "ARM"}, /* auto-repeat mode */
376: {(char *)0, (char *)0}
377: };
378:
379: static const assoc ecma_highlights[] =
380: /* recognize ECMA attribute sequences */
381: {
382: {"0", "NORMAL"}, /* normal */
383: {"1", "+BOLD"}, /* bold on */
384: {"2", "+DIM"}, /* dim on */
385: {"3", "+ITALIC"}, /* italic on */
386: {"4", "+UNDERLINE"}, /* underline on */
387: {"5", "+BLINK"}, /* blink on */
388: {"6", "+FASTBLINK"}, /* fastblink on */
389: {"7", "+REVERSE"}, /* reverse on */
390: {"8", "+INVISIBLE"}, /* invisible on */
391: {"9", "+DELETED"}, /* deleted on */
392: {"10", "MAIN-FONT"}, /* select primary font */
393: {"11", "ALT-FONT-1"}, /* select alternate font 1 */
394: {"12", "ALT-FONT-2"}, /* select alternate font 2 */
395: {"13", "ALT-FONT-3"}, /* select alternate font 3 */
396: {"14", "ALT-FONT-4"}, /* select alternate font 4 */
397: {"15", "ALT-FONT-5"}, /* select alternate font 5 */
398: {"16", "ALT-FONT-6"}, /* select alternate font 6 */
399: {"17", "ALT-FONT-7"}, /* select alternate font 7 */
400: {"18", "ALT-FONT-1"}, /* select alternate font 1 */
401: {"19", "ALT-FONT-1"}, /* select alternate font 1 */
402: {"20", "FRAKTUR"}, /* Fraktur font */
403: {"21", "DOUBLEUNDER"}, /* double underline */
404: {"22", "-DIM"}, /* dim off */
405: {"23", "-ITALIC"}, /* italic off */
406: {"24", "-UNDERLINE"}, /* underline off */
407: {"25", "-BLINK"}, /* blink off */
408: {"26", "-FASTBLINK"}, /* fastblink off */
409: {"27", "-REVERSE"}, /* reverse off */
410: {"28", "-INVISIBLE"}, /* invisible off */
411: {"29", "-DELETED"}, /* deleted off */
412: {(char *)0, (char *)0}
413: };
414:
415: static void analyze_string(const char *name, const char *cap, TERMTYPE *tp)
416: {
417: char buf[MAX_TERMINFO_LENGTH];
418: char buf2[MAX_TERMINFO_LENGTH];
419: const char *sp, *ep;
420: const assoc *ap;
421:
422: if (cap == ABSENT_STRING || cap == CANCELLED_STRING)
423: return;
424: (void) printf("%s: ", name);
425:
426: buf[0] = '\0';
427: for (sp = cap; *sp; sp++)
428: {
429: int i;
430: size_t len = 0;
431: const char *expansion = 0;
432:
433: /* first, check other capabilities in this entry */
434: for (i = 0; i < STRCOUNT; i++)
435: {
436: char *cp = tp->Strings[i];
437:
438: /* don't use soft-key capabilities */
439: if (strnames[i][0] == 'k' && strnames[i][0] == 'f')
440: continue;
441:
442:
443: if (cp != ABSENT_STRING && cp != CANCELLED_STRING && cp[0] && cp != cap)
444: {
445: len = strlen(cp);
446: (void) strncpy(buf2, sp, len);
447: buf2[len] = '\0';
448:
449: if (_nc_capcmp(cp, buf2))
450: continue;
451:
452: #define ISRS(s) (!strncmp((s), "is", 2) || !strncmp((s), "rs", 2))
453: /*
454: * Theoretically we just passed the test for translation
455: * (equality once the padding is stripped). However, there
456: * are a few more hoops that need to be jumped so that
457: * identical pairs of initialization and reset strings
458: * don't just refer to each other.
459: */
460: if (ISRS(name) || ISRS(strnames[i]))
461: if (cap < cp)
462: continue;
463: #undef ISRS
464:
465: expansion = strnames[i];
466: break;
467: }
468: }
469:
470: /* now check the standard capabilities */
471: if (!expansion)
472: for (ap = std_caps; ap->from; ap++)
473: {
474: len = strlen(ap->from);
475:
476: if (strncmp(ap->from, sp, len) == 0)
477: {
478: expansion = ap->to;
479: break;
480: }
481: }
482:
483: /* now check for private-mode sequences */
484: if (!expansion
485: && sp[0] == '\033' && sp[1] == '[' && sp[2] == '?'
486: && (len = strspn(sp + 3, "0123456789;"))
487: && ((sp[3 + len] == 'h') || (sp[3 + len] == 'l')))
488: {
489: char buf3[MAX_TERMINFO_LENGTH];
490:
491: (void) strcpy(buf2, (sp[3 + len] == 'h') ? "DEC+" : "DEC-");
492: (void) strncpy(buf3, sp + 3, len);
493: len += 4;
494: buf3[len] = '\0';
495:
496: ep = strtok(buf3, ";");
497: do {
498: bool found = FALSE;
499:
500: for (ap = private_modes; ap->from; ap++)
501: {
502: size_t tlen = strlen(ap->from);
503:
504: if (strncmp(ap->from, ep, tlen) == 0)
505: {
506: (void) strcat(buf2, ap->to);
507: found = TRUE;
508: break;
509: }
510: }
511:
512: if (!found)
513: (void) strcat(buf2, ep);
514: (void) strcat(buf2, ";");
515: } while
516: ((ep = strtok((char *)NULL, ";")));
517: buf2[strlen(buf2) - 1] = '\0';
518: expansion = buf2;
519: }
520:
521: /* now check for ECMA highlight sequences */
522: if (!expansion
523: && sp[0] == '\033' && sp[1] == '['
524: && (len = strspn(sp + 2, "0123456789;"))
525: && sp[2 + len] == 'm')
526: {
527: char buf3[MAX_TERMINFO_LENGTH];
528:
529: (void) strcpy(buf2, "SGR:");
530: (void) strncpy(buf3, sp + 2, len);
531: len += 3;
532: buf3[len] = '\0';
533:
534: ep = strtok(buf3, ";");
535: do {
536: bool found = FALSE;
537:
538: for (ap = ecma_highlights; ap->from; ap++)
539: {
540: size_t tlen = strlen(ap->from);
541:
542: if (strncmp(ap->from, ep, tlen) == 0)
543: {
544: (void) strcat(buf2, ap->to);
545: found = TRUE;
546: break;
547: }
548: }
549:
550: if (!found)
551: (void) strcat(buf2, ep);
552: (void) strcat(buf2, ";");
553: } while
554: ((ep = strtok((char *)NULL, ";")));
555:
556: buf2[strlen(buf2) - 1] = '\0';
557: expansion = buf2;
558: }
559: /* now check for scroll region reset */
560: if (!expansion)
561: {
562: (void) sprintf(buf2, "\033[1;%dr", tp->Numbers[2]);
563: len = strlen(buf2);
564: if (strncmp(buf2, sp, len) == 0)
565: expansion = "RSR";
566: }
567:
568: /* now check for home-down */
569: if (!expansion)
570: {
571: (void) sprintf(buf2, "\033[%d;1H", tp->Numbers[2]);
572: len = strlen(buf2);
573: if (strncmp(buf2, sp, len) == 0)
574: expansion = "LL";
575: }
576:
577: /* now look at the expansion we got, if any */
578: if (expansion)
579: {
580: (void) sprintf(buf + strlen(buf), "{%s}", expansion);
581: sp += len - 1;
582: continue;
583: }
584: else
585: {
586: /* couldn't match anything */
587: buf2[0] = *sp;
588: buf2[1] = '\0';
589: (void) strcat(buf, TIC_EXPAND(buf2));
590: }
591: }
592: (void) printf("%s\n", buf);
593: }
594:
595: /***************************************************************************
596: *
597: * File comparison
598: *
599: ***************************************************************************/
600:
601: static void file_comparison(int argc, char *argv[])
602: {
603: #define MAXCOMPARE 2
604: /* someday we may allow comparisons on more files */
605: int filecount = 0;
606: ENTRY *heads[MAXCOMPARE];
607: ENTRY *tails[MAXCOMPARE];
608: ENTRY *qp, *rp;
609: int i, n;
610:
611: dump_init((char *)NULL, F_LITERAL, S_TERMINFO, 0, itrace, FALSE);
612:
613: for (n = 0; n < argc && n < MAXCOMPARE; n++)
614: {
615: if (freopen(argv[n], "r", stdin) == NULL)
616: _nc_err_abort("Can't open %s", argv[n]);
617:
618: _nc_head = _nc_tail = (ENTRY *)NULL;
619:
620: /* parse entries out of the source file */
621: _nc_set_source(argv[n]);
622: _nc_read_entry_source(stdin, NULL, TRUE, FALSE, NULLHOOK);
623:
624: if (itrace)
625: (void) fprintf(stderr, "Resolving file %d...\n", n-0);
626:
627: /* do use resolution */
628: if (!_nc_resolve_uses())
629: {
630: (void) fprintf(stderr,
631: "There are unresolved use entries in %s:\n",
632: argv[n]);
633: for_entry_list(qp)
634: if (qp->nuses)
635: {
636: (void) fputs(qp->tterm.term_names, stderr);
637: (void) fputc('\n', stderr);
638: }
639: exit(EXIT_FAILURE);
640: }
641:
642: heads[filecount] = _nc_head;
643: tails[filecount] = _nc_tail;
644: filecount++;
645: }
646:
647: /* OK, all entries are in core. Ready to do the comparison */
648: if (itrace)
649: (void) fprintf(stderr, "Entries are now in core...\n");
650:
651: /*
652: * The entry-matching loop. We're not using the use[]
653: * slots any more (they got zeroed out by resolve_uses) so
654: * we stash each entry's matches in the other file there.
655: * Sigh, this is intrinsically quadratic.
656: */
657: for (qp = heads[0]; qp; qp = qp->next)
658: {
659: for (rp = heads[1]; rp; rp = rp->next)
660: if (_nc_entry_match(qp->tterm.term_names, rp->tterm.term_names))
661: {
662: /*
663: * This is why the uses structure parent element is
664: * (void *) -- so we can have either (char *) for
665: * names or entry structure pointers in them and still
666: * be type-safe.
667: */
668: if (qp->nuses < MAX_USES)
669: qp->uses[qp->nuses].parent = (void *)rp;
670: qp->nuses++;
671:
672: if (rp->nuses < MAX_USES)
673: rp->uses[rp->nuses].parent = (void *)qp;
674: rp->nuses++;
675: }
676: }
677:
678: /* now we have two circular lists with crosslinks */
679: if (itrace)
680: (void) fprintf(stderr, "Name matches are done...\n");
681:
682: for (qp = heads[0]; qp; qp = qp->next)
683: if (qp->nuses > 1)
684: {
685: (void) fprintf(stderr,
686: "%s in file 1 (%s) has %d matches in file 2 (%s):\n",
687: _nc_first_name(qp->tterm.term_names),
688: argv[0],
689: qp->nuses,
690: argv[1]);
691: for (i = 0; i < qp->nuses; i++)
692: (void) fprintf(stderr,
693: "\t%s\n",
694: _nc_first_name(((ENTRY *)qp->uses[i].parent)->tterm.term_names));
695: }
696: for (rp = heads[1]; rp; rp = rp->next)
697: if (rp->nuses > 1)
698: {
699: (void) fprintf(stderr,
700: "%s in file 2 (%s) has %d matches in file 1 (%s):\n",
701: _nc_first_name(rp->tterm.term_names),
702: argv[1],
703: rp->nuses,
704: argv[0]);
705: for (i = 0; i < rp->nuses; i++)
706: (void) fprintf(stderr,
707: "\t%s\n",
708: _nc_first_name(((ENTRY *)rp->uses[i].parent)->tterm.term_names));
709: }
710:
711: (void) printf("In file 1 (%s) only:\n", argv[0]);
712: for (qp = heads[0]; qp; qp = qp->next)
713: if (qp->nuses == 0)
714: (void) printf("\t%s\n",
715: _nc_first_name(qp->tterm.term_names));
716:
717: (void) printf("In file 2 (%s) only:\n", argv[1]);
718: for (rp = heads[1]; rp; rp = rp->next)
719: if (rp->nuses == 0)
720: (void) printf("\t%s\n",
721: _nc_first_name(rp->tterm.term_names));
722:
723: (void) printf("The following entries are equivalent:\n");
724: for (qp = heads[0]; qp; qp = qp->next)
725: {
726: rp = (ENTRY *)qp->uses[0].parent;
727:
728: if (qp->nuses == 1 && entryeq(&qp->tterm, &rp->tterm))
729: {
730: char name1[NAMESIZE], name2[NAMESIZE];
731:
732: (void) canonical_name(qp->tterm.term_names, name1);
733: (void) canonical_name(rp->tterm.term_names, name2);
734:
735: (void) printf("%s = %s\n", name1, name2);
736: }
737: }
738:
739: (void) printf("Differing entries:\n");
740: termcount = 2;
741: for (qp = heads[0]; qp; qp = qp->next)
742: {
743: rp = (ENTRY *)qp->uses[0].parent;
744:
1.2 millert 745: #if NCURSES_XNAMES
746: if (termcount > 1)
747: _nc_align_termtype(&qp->tterm, &rp->tterm);
748: #endif
1.1 millert 749: if (qp->nuses == 1 && !entryeq(&qp->tterm, &rp->tterm))
750: {
751: char name1[NAMESIZE], name2[NAMESIZE];
752:
1.2 millert 753: term[0] = qp->tterm;
754: term[1] = rp->tterm;
1.1 millert 755:
756: (void) canonical_name(qp->tterm.term_names, name1);
757: (void) canonical_name(rp->tterm.term_names, name2);
758:
759: switch (compare)
760: {
761: case C_DIFFERENCE:
762: if (itrace)
763: (void)fprintf(stderr, "infocmp: dumping differences\n");
764: (void) printf("comparing %s to %s.\n", name1, name2);
1.2 millert 765: compare_entry(compare_predicate, term);
1.1 millert 766: break;
767:
768: case C_COMMON:
769: if (itrace)
770: (void) fprintf(stderr,
771: "infocmp: dumping common capabilities\n");
772: (void) printf("comparing %s to %s.\n", name1, name2);
1.2 millert 773: compare_entry(compare_predicate, term);
1.1 millert 774: break;
775:
776: case C_NAND:
777: if (itrace)
778: (void) fprintf(stderr,
779: "infocmp: dumping differences\n");
780: (void) printf("comparing %s to %s.\n", name1, name2);
1.2 millert 781: compare_entry(compare_predicate, term);
1.1 millert 782: break;
783:
784: }
785: }
786: }
787: }
788:
789: static void usage(void)
790: {
791: static const char *tbl[] = {
792: "Usage: infocmp [options] [-A directory] [-B directory] [termname...]"
793: ,""
794: ,"Options:"
795: ," -1 print single-column"
796: ," -C use termcap-names"
797: ," -F compare terminfo-files"
798: ," -I use terminfo-names"
799: ," -L use long names"
800: ," -R subset (see manpage)"
801: ," -T eliminate size limits (test)"
802: ," -V print version"
803: ," -c list common capabilities"
804: ," -d list different capabilities"
1.5 ! millert 805: ," -e format output for C initializer"
! 806: ," -E format output as C tables"
1.1 millert 807: ," -f with -1, format complex strings"
1.3 millert 808: ," -G format %{number} to %'char'"
1.1 millert 809: ," -g format %'char' to %{number}"
810: ," -i analyze initialization/reset"
811: ," -l output terminfo names"
812: ," -n list capabilities in neither"
813: ," -p ignore padding specifiers"
814: ," -r with -C, output in termcap form"
815: ," -s [d|i|l|c] sort fields"
816: ," -u produce source with 'use='"
817: ," -v number (verbose)"
818: ," -w number (width)"
819: };
820: const size_t first = 3;
821: const size_t last = sizeof(tbl)/sizeof(tbl[0]);
822: const size_t left = (last - first + 1) / 2 + first;
823: size_t n;
824:
825: for (n = 0; n < left; n++) {
826: size_t m = (n < first) ? last : n + left - first;
827: if (m < last)
828: fprintf(stderr, "%-40.40s%s\n", tbl[n], tbl[m]);
829: else
830: fprintf(stderr, "%s\n", tbl[n]);
831: }
832: exit(EXIT_FAILURE);
833: }
834:
1.5 ! millert 835: static char * name_initializer(const char *type)
! 836: {
! 837: static char *initializer;
! 838: char *s;
! 839:
! 840: if (initializer == 0)
! 841: initializer = malloc(strlen(term->term_names) + 20);
! 842:
! 843: (void) sprintf(initializer, "%s_data_%s", type, term->term_names);
! 844: for (s = initializer; *s != 0 && *s != '|'; s++)
! 845: {
! 846: if (!isalnum(*s))
! 847: *s = '_';
! 848: }
! 849: *s = 0;
! 850: return initializer;
! 851: }
! 852:
! 853: /* dump C initializers for the terminal type */
! 854: static void dump_initializers(void)
! 855: {
! 856: int n;
! 857: const char *str = 0;
! 858: int size;
! 859:
! 860: (void) printf("static bool %s[] = %s\n", name_initializer("bool"), L_CURL);
! 861:
! 862: for_each_boolean(n,term)
! 863: {
! 864: switch((int)(term->Booleans[n]))
! 865: {
! 866: case TRUE:
! 867: str = "TRUE";
! 868: break;
! 869:
! 870: case FALSE:
! 871: str = "FALSE";
! 872: break;
! 873:
! 874: case ABSENT_BOOLEAN:
! 875: str = "ABSENT_BOOLEAN";
! 876: break;
! 877:
! 878: case CANCELLED_BOOLEAN:
! 879: str = "CANCELLED_BOOLEAN";
! 880: break;
! 881: }
! 882: (void) printf("\t/* %3d: %-8s */\t%s,\n",
! 883: n, ExtBoolname(term,n,boolnames), str);
! 884: }
! 885: (void) printf("%s;\n", R_CURL);
! 886:
! 887: (void) printf("static short %s[] = %s\n", name_initializer("number"), L_CURL);
! 888:
! 889: for_each_number(n,term)
! 890: {
! 891: char buf[BUFSIZ];
! 892: switch (term->Numbers[n])
! 893: {
! 894: case ABSENT_NUMERIC:
! 895: str = "ABSENT_NUMERIC";
! 896: break;
! 897: case CANCELLED_NUMERIC:
! 898: str = "CANCELLED_NUMERIC";
! 899: break;
! 900: default:
! 901: sprintf(buf, "%d", term->Numbers[n]);
! 902: str = buf;
! 903: break;
! 904: }
! 905: (void) printf("\t/* %3d: %-8s */\t%s,\n", n, ExtNumname(term,n,numnames), str);
! 906: }
! 907: (void) printf("%s;\n", R_CURL);
! 908:
! 909: size = sizeof(TERMTYPE)
! 910: + (NUM_BOOLEANS(term) * sizeof(term->Booleans[0]))
! 911: + (NUM_NUMBERS(term) * sizeof(term->Numbers[0]));
! 912:
! 913: (void) printf("static char * %s[] = %s\n", name_initializer("string"), L_CURL);
! 914:
! 915: for_each_string(n,term)
! 916: {
! 917: char buf[BUFSIZ], *sp, *tp;
! 918:
! 919: if (term->Strings[n] == ABSENT_STRING)
! 920: str = "ABSENT_STRING";
! 921: else if (term->Strings[n] == CANCELLED_STRING)
! 922: str = "CANCELLED_STRING";
! 923: else
! 924: {
! 925: tp = buf;
! 926: *tp++ = '"';
! 927: for (sp = term->Strings[n]; *sp; sp++)
! 928: {
! 929: if (isascii(*sp) && isprint(*sp) && *sp !='\\' && *sp != '"')
! 930: *tp++ = *sp;
! 931: else
! 932: {
! 933: (void) sprintf(tp, "\\%03o", *sp & 0xff);
! 934: tp += 4;
! 935: }
! 936: }
! 937: *tp++ = '"';
! 938: *tp = '\0';
! 939: size += (strlen(term->Strings[n]) + 1);
! 940: str = buf;
! 941: }
! 942: #if NCURSES_XNAMES
! 943: if (n == STRCOUNT)
! 944: {
! 945: (void) printf("%s;\n", R_CURL);
! 946:
! 947: (void) printf("static char * %s[] = %s\n", name_initializer("string_ext"), L_CURL);
! 948: }
! 949: #endif
! 950: (void) printf("\t/* %3d: %-8s */\t%s,\n", n, ExtStrname(term,n,strnames), str);
! 951: }
! 952: (void) printf("%s;\n", R_CURL);
! 953: }
! 954:
! 955: /* dump C initializers for the terminal type */
! 956: static void dump_termtype(void)
! 957: {
! 958: (void) printf("\t%s\n\t\t\"%s\",\n", L_CURL, term->term_names);
! 959: (void) printf("\t\t(char *)0,\t/* pointer to string table */\n");
! 960:
! 961: (void) printf("\t\t%s,\n", name_initializer("bool"));
! 962: (void) printf("\t\t%s,\n", name_initializer("number"));
! 963:
! 964: (void) printf("\t\t%s,\n", name_initializer("string"));
! 965:
! 966: #if NCURSES_XNAMES
! 967: (void) printf("#if NCURSES_XNAMES\n");
! 968: (void) printf("\t\t(char *)0,\t/* pointer to extended string table */\n");
! 969: (void) printf("\t\t%s,\t/* ...corresponding names */\n",
! 970: (NUM_STRINGS(term) != STRCOUNT)
! 971: ? name_initializer("string_ext")
! 972: : "(char **)0");
! 973:
! 974: (void) printf("\t\t%d,\t\t/* count total Booleans */\n", NUM_BOOLEANS(term));
! 975: (void) printf("\t\t%d,\t\t/* count total Numbers */\n", NUM_NUMBERS(term));
! 976: (void) printf("\t\t%d,\t\t/* count total Strings */\n", NUM_STRINGS(term));
! 977:
! 978: (void) printf("\t\t%d,\t\t/* count extensions to Booleans */\n", NUM_BOOLEANS(term) - BOOLCOUNT);
! 979: (void) printf("\t\t%d,\t\t/* count extensions to Numbers */\n", NUM_NUMBERS(term) - NUMCOUNT);
! 980: (void) printf("\t\t%d,\t\t/* count extensions to Strings */\n", NUM_STRINGS(term) - STRCOUNT);
! 981:
! 982: (void) printf("#endif /* NCURSES_XNAMES */\n");
! 983: #endif /* NCURSES_XNAMES */
! 984: (void) printf("\t%s\n", R_CURL);
! 985: }
! 986:
1.1 millert 987: /***************************************************************************
988: *
989: * Main sequence
990: *
991: ***************************************************************************/
992:
993: int main(int argc, char *argv[])
994: {
995: char *terminal, *firstdir, *restdir;
996: /* Avoid "local data >32k" error with mwcc */
997: /* Also avoid overflowing smaller stacks on systems like AmigaOS */
998: path *tfile = malloc(sizeof(path)*MAXTERMS);
999: int c, i, len;
1000: bool formatted = FALSE;
1001: bool filecompare = FALSE;
1.5 ! millert 1002: int initdump = 0;
1.1 millert 1003: bool init_analyze = FALSE;
1004: bool limited = TRUE;
1005:
1006: if ((terminal = getenv("TERM")) == NULL)
1007: {
1008: (void) fprintf(stderr,
1009: "infocmp: environment variable TERM not set\n");
1010: return EXIT_FAILURE;
1011: }
1012:
1013: /* where is the terminfo database location going to default to? */
1014: restdir = firstdir = 0;
1015:
1.5 ! millert 1016: while ((c = getopt(argc, argv, "deEcCfFGgIinlLprR:s:uv:Vw:A:B:1T")) != EOF)
1.1 millert 1017: switch (c)
1018: {
1019: case 'd':
1020: compare = C_DIFFERENCE;
1021: break;
1022:
1023: case 'e':
1.5 ! millert 1024: initdump |= 1;
! 1025: break;
! 1026:
! 1027: case 'E':
! 1028: initdump |= 2;
1.1 millert 1029: break;
1030:
1031: case 'c':
1032: compare = C_COMMON;
1033: break;
1034:
1035: case 'C':
1036: outform = F_TERMCAP;
1037: tversion = "BSD";
1038: if (sortmode == S_DEFAULT)
1039: sortmode = S_TERMCAP;
1040: break;
1041:
1042: case 'f':
1043: formatted = TRUE;
1044: break;
1045:
1.3 millert 1046: case 'G':
1047: numbers = 1;
1048: break;
1049:
1.1 millert 1050: case 'g':
1.3 millert 1051: numbers = -1;
1.1 millert 1052: break;
1053:
1054: case 'F':
1055: filecompare = TRUE;
1056: break;
1057:
1058: case 'I':
1059: outform = F_TERMINFO;
1060: if (sortmode == S_DEFAULT)
1061: sortmode = S_VARIABLE;
1062: tversion = 0;
1063: break;
1064:
1065: case 'i':
1066: init_analyze = TRUE;
1067: break;
1068:
1069: case 'l':
1070: outform = F_TERMINFO;
1071: break;
1072:
1073: case 'L':
1074: outform = F_VARIABLE;
1075: if (sortmode == S_DEFAULT)
1076: sortmode = S_VARIABLE;
1077: break;
1078:
1079: case 'n':
1080: compare = C_NAND;
1081: break;
1082:
1083: case 'p':
1084: ignorepads = TRUE;
1085: break;
1086:
1087: case 'r':
1088: tversion = 0;
1089: limited = FALSE;
1090: break;
1091:
1092: case 'R':
1093: tversion = optarg;
1094: break;
1095:
1096: case 's':
1097: if (*optarg == 'd')
1098: sortmode = S_NOSORT;
1099: else if (*optarg == 'i')
1100: sortmode = S_TERMINFO;
1101: else if (*optarg == 'l')
1102: sortmode = S_VARIABLE;
1103: else if (*optarg == 'c')
1104: sortmode = S_TERMCAP;
1105: else
1106: {
1107: (void) fprintf(stderr,
1108: "infocmp: unknown sort mode\n");
1109: return EXIT_FAILURE;
1110: }
1111: break;
1112:
1113: case 'u':
1114: compare = C_USEALL;
1115: break;
1116:
1117: case 'v':
1118: itrace = atoi(optarg);
1119: _nc_tracing = (1 << itrace) - 1;
1120: break;
1121:
1122: case 'V':
1123: (void) fputs(NCURSES_VERSION, stdout);
1124: putchar('\n');
1125: ExitProgram(EXIT_SUCCESS);
1126:
1127: case 'w':
1128: mwidth = atoi(optarg);
1129: break;
1130:
1131: case 'A':
1132: firstdir = optarg;
1133: break;
1134:
1135: case 'B':
1136: restdir = optarg;
1137: break;
1138:
1139: case '1':
1140: mwidth = 0;
1141: break;
1142:
1143: case 'T':
1144: limited = FALSE;
1145: break;
1146: default:
1147: usage();
1148: }
1149:
1150: /* by default, sort by terminfo name */
1151: if (sortmode == S_DEFAULT)
1152: sortmode = S_TERMINFO;
1153:
1154: /* set up for display */
1155: dump_init(tversion, outform, sortmode, mwidth, itrace, formatted);
1156:
1157: /* make sure we have at least one terminal name to work with */
1158: if (optind >= argc)
1159: argv[argc++] = terminal;
1160:
1161: /* if user is after a comparison, make sure we have two entries */
1162: if (compare != C_DEFAULT && optind >= argc - 1)
1163: argv[argc++] = terminal;
1164:
1165: /* exactly two terminal names with no options means do -d */
1166: if (argc - optind == 2 && compare == C_DEFAULT)
1167: compare = C_DIFFERENCE;
1168:
1169: if (!filecompare)
1170: {
1171: /* grab the entries */
1172: termcount = 0;
1173: for (; optind < argc; optind++)
1174: {
1175: if (termcount >= MAXTERMS)
1176: {
1177: (void) fprintf(stderr,
1178: "infocmp: too many terminal type arguments\n");
1179: return EXIT_FAILURE;
1180: }
1181: else
1182: {
1183: const char *directory = termcount ? restdir : firstdir;
1184: int status;
1185:
1186: tname[termcount] = argv[optind];
1187:
1188: if (directory)
1189: {
1190: (void) sprintf(tfile[termcount], "%s/%c/%s",
1191: directory,
1192: *argv[optind], argv[optind]);
1193: if (itrace)
1194: (void) fprintf(stderr,
1195: "infocmp: reading entry %s from file %s\n",
1196: argv[optind], tfile[termcount]);
1197:
1198: status = _nc_read_file_entry(tfile[termcount],
1199: &term[termcount]);
1200: }
1201: else
1202: {
1203: if (itrace)
1204: (void) fprintf(stderr,
1205: "infocmp: reading entry %s from system directories %s\n",
1206: argv[optind], tname[termcount]);
1207:
1208: status = _nc_read_entry(tname[termcount],
1209: tfile[termcount],
1210: &term[termcount]);
1211: directory = TERMINFO; /* for error message */
1212: }
1213:
1214: if (status <= 0)
1215: {
1216: (void) fprintf(stderr,
1217: "infocmp: couldn't open terminfo file %s.\n",
1218: tfile[termcount]);
1219: return EXIT_FAILURE;
1220: }
1221: termcount++;
1222: }
1223: }
1224:
1.2 millert 1225: #if NCURSES_XNAMES
1226: if (termcount > 1)
1227: _nc_align_termtype(&term[0], &term[1]);
1228: #endif
1229:
1.1 millert 1230: /* dump as C initializer for the terminal type */
1231: if (initdump)
1232: {
1.5 ! millert 1233: if (initdump & 1)
! 1234: dump_termtype();
! 1235: if (initdump & 2)
! 1236: dump_initializers();
1.1 millert 1237: ExitProgram(EXIT_SUCCESS);
1238: }
1239:
1240: /* analyze the init strings */
1241: if (init_analyze)
1242: {
1243: #undef CUR
1244: #define CUR term[0].
1245: analyze_string("is1", init_1string, &term[0]);
1246: analyze_string("is2", init_2string, &term[0]);
1247: analyze_string("is3", init_3string, &term[0]);
1248: analyze_string("rs1", reset_1string, &term[0]);
1249: analyze_string("rs2", reset_2string, &term[0]);
1250: analyze_string("rs3", reset_3string, &term[0]);
1251: analyze_string("smcup", enter_ca_mode, &term[0]);
1252: analyze_string("rmcup", exit_ca_mode, &term[0]);
1253: #undef CUR
1254: ExitProgram(EXIT_SUCCESS);
1255: }
1256:
1257: /*
1258: * Here's where the real work gets done
1259: */
1260: switch (compare)
1261: {
1262: case C_DEFAULT:
1263: if (itrace)
1264: (void) fprintf(stderr,
1265: "infocmp: about to dump %s\n",
1266: tname[0]);
1267: (void) printf("#\tReconstructed via infocmp from file: %s\n",
1268: tfile[0]);
1269: len = dump_entry(&term[0], limited, numbers, NULL);
1270: putchar('\n');
1271: if (itrace)
1272: (void)fprintf(stderr, "infocmp: length %d\n", len);
1273: break;
1274:
1275: case C_DIFFERENCE:
1276: if (itrace)
1277: (void)fprintf(stderr, "infocmp: dumping differences\n");
1278: (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
1.2 millert 1279: compare_entry(compare_predicate, term);
1.1 millert 1280: break;
1281:
1282: case C_COMMON:
1283: if (itrace)
1284: (void) fprintf(stderr,
1285: "infocmp: dumping common capabilities\n");
1286: (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
1.2 millert 1287: compare_entry(compare_predicate, term);
1.1 millert 1288: break;
1289:
1290: case C_NAND:
1291: if (itrace)
1292: (void) fprintf(stderr,
1293: "infocmp: dumping differences\n");
1294: (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
1.2 millert 1295: compare_entry(compare_predicate, term);
1.1 millert 1296: break;
1297:
1298: case C_USEALL:
1299: if (itrace)
1300: (void) fprintf(stderr, "infocmp: dumping use entry\n");
1301: len = dump_entry(&term[0], limited, numbers, use_predicate);
1302: for (i = 1; i < termcount; i++)
1303: len += dump_uses(tname[i], !(outform==F_TERMCAP || outform==F_TCONVERR));
1304: putchar('\n');
1305: if (itrace)
1306: (void)fprintf(stderr, "infocmp: length %d\n", len);
1307: break;
1308: }
1309: }
1310: else if (compare == C_USEALL)
1311: (void) fprintf(stderr, "Sorry, -u doesn't work with -F\n");
1312: else if (compare == C_DEFAULT)
1313: (void) fprintf(stderr, "Use `tic -[CI] <file>' for this.\n");
1314: else if (argc - optind != 2)
1315: (void) fprintf(stderr,
1316: "File comparison needs exactly two file arguments.\n");
1317: else
1318: file_comparison(argc-optind, argv+optind);
1319:
1320: ExitProgram(EXIT_SUCCESS);
1321: }
1322:
1323: /* infocmp.c ends here */