Deleted Added
sdiff udiff text old ( 97049 ) new ( 98503 )
full compact
dump_entry.c (97049) dump_entry.c (98503)
1/****************************************************************************
1/****************************************************************************
2 * Copyright (c) 1998-2000 Free Software Foundation, Inc. *
2 * Copyright (c) 1998-2001,2002 Free Software Foundation, Inc. *
3 * *
4 * Permission is hereby granted, free of charge, to any person obtaining a *
5 * copy of this software and associated documentation files (the *
6 * "Software"), to deal in the Software without restriction, including *
7 * without limitation the rights to use, copy, modify, merge, publish, *
8 * distribute, distribute with modifications, sublicense, and/or sell *
9 * copies of the Software, and to permit persons to whom the Software is *
10 * furnished to do so, subject to the following conditions: *

--- 13 unchanged lines hidden (view full) ---

24 * holders shall not be used in advertising or otherwise to promote the *
25 * sale, use or other dealings in this Software without prior written *
26 * authorization. *
27 ****************************************************************************/
28
29/****************************************************************************
30 * Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 *
31 * and: Eric S. Raymond <esr@snark.thyrsus.com> *
3 * *
4 * Permission is hereby granted, free of charge, to any person obtaining a *
5 * copy of this software and associated documentation files (the *
6 * "Software"), to deal in the Software without restriction, including *
7 * without limitation the rights to use, copy, modify, merge, publish, *
8 * distribute, distribute with modifications, sublicense, and/or sell *
9 * copies of the Software, and to permit persons to whom the Software is *
10 * furnished to do so, subject to the following conditions: *

--- 13 unchanged lines hidden (view full) ---

24 * holders shall not be used in advertising or otherwise to promote the *
25 * sale, use or other dealings in this Software without prior written *
26 * authorization. *
27 ****************************************************************************/
28
29/****************************************************************************
30 * Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 *
31 * and: Eric S. Raymond <esr@snark.thyrsus.com> *
32 * and: Thomas E. Dickey 1996 on *
32 ****************************************************************************/
33
34#define __INTERNAL_CAPS_VISIBLE
35#include <progs.priv.h>
36
37#include "dump_entry.h"
38#include "termsort.c" /* this C file is generated */
39#include <parametrized.h> /* so is this */
40
33 ****************************************************************************/
34
35#define __INTERNAL_CAPS_VISIBLE
36#include <progs.priv.h>
37
38#include "dump_entry.h"
39#include "termsort.c" /* this C file is generated */
40#include <parametrized.h> /* so is this */
41
41MODULE_ID("$Id: dump_entry.c,v 1.56 2001/08/12 00:21:22 tom Exp $")
42MODULE_ID("$Id: dump_entry.c,v 1.58 2002/06/01 22:58:11 tom Exp $")
42
43#define INDENT 8
44#define DISCARD(string) string = ABSENT_STRING
45#define PRINTF (void) printf
46
47typedef struct {
48 char *text;
49 size_t used;

--- 111 unchanged lines hidden (view full) ---

161 break;
162 }
163
164 return (0);
165}
166
167void
168dump_init(const char *version, int mode, int sort, int twidth, int traceval,
43
44#define INDENT 8
45#define DISCARD(string) string = ABSENT_STRING
46#define PRINTF (void) printf
47
48typedef struct {
49 char *text;
50 size_t used;

--- 111 unchanged lines hidden (view full) ---

162 break;
163 }
164
165 return (0);
166}
167
168void
169dump_init(const char *version, int mode, int sort, int twidth, int traceval,
169 bool formatted)
170 bool formatted)
170/* set up for entry display */
171{
172 width = twidth;
173 pretty = formatted;
174
175 /* versions */
176 if (version == 0)
177 tversion = V_ALLCAPS;
178 else if (!strcmp(version, "SVr1") || !strcmp(version, "SVR1")
171/* set up for entry display */
172{
173 width = twidth;
174 pretty = formatted;
175
176 /* versions */
177 if (version == 0)
178 tversion = V_ALLCAPS;
179 else if (!strcmp(version, "SVr1") || !strcmp(version, "SVR1")
179 || !strcmp(version, "Ultrix"))
180 || !strcmp(version, "Ultrix"))
180 tversion = V_SVR1;
181 else if (!strcmp(version, "HP"))
182 tversion = V_HPUX;
183 else if (!strcmp(version, "AIX"))
184 tversion = V_AIX;
185 else if (!strcmp(version, "BSD"))
186 tversion = V_BSD;
187 else

--- 28 unchanged lines hidden (view full) ---

216 break;
217 }
218
219 /* implement sort modes */
220 switch (sortmode = sort) {
221 case S_NOSORT:
222 if (traceval)
223 (void) fprintf(stderr,
181 tversion = V_SVR1;
182 else if (!strcmp(version, "HP"))
183 tversion = V_HPUX;
184 else if (!strcmp(version, "AIX"))
185 tversion = V_AIX;
186 else if (!strcmp(version, "BSD"))
187 tversion = V_BSD;
188 else

--- 28 unchanged lines hidden (view full) ---

217 break;
218 }
219
220 /* implement sort modes */
221 switch (sortmode = sort) {
222 case S_NOSORT:
223 if (traceval)
224 (void) fprintf(stderr,
224 "%s: sorting by term structure order\n", _nc_progname);
225 "%s: sorting by term structure order\n", _nc_progname);
225 break;
226
227 case S_TERMINFO:
228 if (traceval)
229 (void) fprintf(stderr,
226 break;
227
228 case S_TERMINFO:
229 if (traceval)
230 (void) fprintf(stderr,
230 "%s: sorting by terminfo name order\n", _nc_progname);
231 "%s: sorting by terminfo name order\n", _nc_progname);
231 bool_indirect = bool_terminfo_sort;
232 num_indirect = num_terminfo_sort;
233 str_indirect = str_terminfo_sort;
234 break;
235
236 case S_VARIABLE:
237 if (traceval)
238 (void) fprintf(stderr,
232 bool_indirect = bool_terminfo_sort;
233 num_indirect = num_terminfo_sort;
234 str_indirect = str_terminfo_sort;
235 break;
236
237 case S_VARIABLE:
238 if (traceval)
239 (void) fprintf(stderr,
239 "%s: sorting by C variable order\n", _nc_progname);
240 "%s: sorting by C variable order\n", _nc_progname);
240 bool_indirect = bool_variable_sort;
241 num_indirect = num_variable_sort;
242 str_indirect = str_variable_sort;
243 break;
244
245 case S_TERMCAP:
246 if (traceval)
247 (void) fprintf(stderr,
241 bool_indirect = bool_variable_sort;
242 num_indirect = num_variable_sort;
243 str_indirect = str_variable_sort;
244 break;
245
246 case S_TERMCAP:
247 if (traceval)
248 (void) fprintf(stderr,
248 "%s: sorting by termcap name order\n", _nc_progname);
249 "%s: sorting by termcap name order\n", _nc_progname);
249 bool_indirect = bool_termcap_sort;
250 num_indirect = num_termcap_sort;
251 str_indirect = str_termcap_sort;
252 break;
253 }
254
255 if (traceval)
256 (void) fprintf(stderr,
250 bool_indirect = bool_termcap_sort;
251 num_indirect = num_termcap_sort;
252 str_indirect = str_termcap_sort;
253 break;
254 }
255
256 if (traceval)
257 (void) fprintf(stderr,
257 "%s: width = %d, tversion = %d, outform = %d\n",
258 _nc_progname, width, tversion, outform);
258 "%s: width = %d, tversion = %d, outform = %d\n",
259 _nc_progname, width, tversion, outform);
259}
260
261static TERMTYPE *cur_type;
262
263static int
264dump_predicate(int type, int idx)
265/* predicate function to use for ordinary decompilation */
266{

--- 224 unchanged lines hidden (view full) ---

491 }
492 strncpy_DYN(&tmpbuf, src++, 1);
493 }
494 return src;
495}
496
497int
498fmt_entry(TERMTYPE * tterm,
260}
261
262static TERMTYPE *cur_type;
263
264static int
265dump_predicate(int type, int idx)
266/* predicate function to use for ordinary decompilation */
267{

--- 224 unchanged lines hidden (view full) ---

492 }
493 strncpy_DYN(&tmpbuf, src++, 1);
494 }
495 return src;
496}
497
498int
499fmt_entry(TERMTYPE * tterm,
499 int (*pred) (int type, int idx),
500 bool suppress_untranslatable,
501 bool infodump,
502 int numbers)
500 int (*pred) (int type, int idx),
501 bool suppress_untranslatable,
502 bool infodump,
503 int numbers)
503{
504 int i, j;
505 char buffer[MAX_TERMINFO_LENGTH];
506 NCURSES_CONST char *name;
507 int predval, len;
508 int num_bools = 0;
509 int num_values = 0;
510 int num_strings = 0;

--- 123 unchanged lines hidden (view full) ---

634 if (tterm->Strings[i] != ABSENT_STRING
635 && i + 1 > num_strings)
636 num_strings = i + 1;
637
638 if (!VALID_STRING(tterm->Strings[i])) {
639 sprintf(buffer, "%s@", name);
640 WRAP_CONCAT;
641 } else if (outform == F_TERMCAP || outform == F_TCONVERR) {
504{
505 int i, j;
506 char buffer[MAX_TERMINFO_LENGTH];
507 NCURSES_CONST char *name;
508 int predval, len;
509 int num_bools = 0;
510 int num_values = 0;
511 int num_strings = 0;

--- 123 unchanged lines hidden (view full) ---

635 if (tterm->Strings[i] != ABSENT_STRING
636 && i + 1 > num_strings)
637 num_strings = i + 1;
638
639 if (!VALID_STRING(tterm->Strings[i])) {
640 sprintf(buffer, "%s@", name);
641 WRAP_CONCAT;
642 } else if (outform == F_TERMCAP || outform == F_TCONVERR) {
642 int params = (i < (int) SIZEOF(parametrized)) ? parametrized[i] : 0;
643 int params = ((i < (int) SIZEOF(parametrized))
644 ? parametrized[i]
645 : 0);
643 char *srccap = _nc_tic_expand(tterm->Strings[i], TRUE, numbers);
644 char *cv = _nc_infotocap(name, srccap, params);
645
646 if (cv == 0) {
647 if (outform == F_TCONVERR) {
648 sprintf(buffer, "%s=!!! %s WILL NOT CONVERT !!!",
646 char *srccap = _nc_tic_expand(tterm->Strings[i], TRUE, numbers);
647 char *cv = _nc_infotocap(name, srccap, params);
648
649 if (cv == 0) {
650 if (outform == F_TCONVERR) {
651 sprintf(buffer, "%s=!!! %s WILL NOT CONVERT !!!",
649 name, srccap);
652 name, srccap);
650 } else if (suppress_untranslatable) {
651 continue;
652 } else {
653 char *s = srccap, *d = buffer;
654 sprintf(d, "..%s=", name);
655 d += strlen(d);
656 while ((*d = *s++) != 0) {
657 if (*d == ':') {

--- 7 unchanged lines hidden (view full) ---

665 }
666 } else {
667 sprintf(buffer, "%s=%s", name, cv);
668 }
669 len += strlen(tterm->Strings[i]) + 1;
670 WRAP_CONCAT;
671 } else {
672 char *src = _nc_tic_expand(tterm->Strings[i],
653 } else if (suppress_untranslatable) {
654 continue;
655 } else {
656 char *s = srccap, *d = buffer;
657 sprintf(d, "..%s=", name);
658 d += strlen(d);
659 while ((*d = *s++) != 0) {
660 if (*d == ':') {

--- 7 unchanged lines hidden (view full) ---

668 }
669 } else {
670 sprintf(buffer, "%s=%s", name, cv);
671 }
672 len += strlen(tterm->Strings[i]) + 1;
673 WRAP_CONCAT;
674 } else {
675 char *src = _nc_tic_expand(tterm->Strings[i],
673 outform == F_TERMINFO, numbers);
676 outform == F_TERMINFO, numbers);
674
675 strcpy_DYN(&tmpbuf, 0);
676 strcpy_DYN(&tmpbuf, name);
677 strcpy_DYN(&tmpbuf, "=");
678 if (pretty
679 && (outform == F_TERMINFO
680 || outform == F_VARIABLE)) {
681 fmt_complex(src, 1);

--- 39 unchanged lines hidden (view full) ---

721 break;
722 }
723 }
724 tp[0] = '\0';
725
726 if (box_ok) {
727 (void) strcpy(buffer, "box1=");
728 (void) strcat(buffer, _nc_tic_expand(boxchars,
677
678 strcpy_DYN(&tmpbuf, 0);
679 strcpy_DYN(&tmpbuf, name);
680 strcpy_DYN(&tmpbuf, "=");
681 if (pretty
682 && (outform == F_TERMINFO
683 || outform == F_VARIABLE)) {
684 fmt_complex(src, 1);

--- 39 unchanged lines hidden (view full) ---

724 break;
725 }
726 }
727 tp[0] = '\0';
728
729 if (box_ok) {
730 (void) strcpy(buffer, "box1=");
731 (void) strcat(buffer, _nc_tic_expand(boxchars,
729 outform == F_TERMINFO, numbers));
732 outform == F_TERMINFO, numbers));
730 WRAP_CONCAT;
731 }
732 }
733 }
734
735 /*
736 * kludge: trim off trailer to avoid an extra blank line
737 * in infocmp -u output when there are no string differences
738 */
739 if (outcount) {
740 bool trimmed = FALSE;
741 j = outbuf.used;
742 if (j >= 2
743 && outbuf.text[j - 1] == '\t'
744 && outbuf.text[j - 2] == '\n') {
745 outbuf.used -= 2;
746 trimmed = TRUE;
747 } else if (j >= 4
733 WRAP_CONCAT;
734 }
735 }
736 }
737
738 /*
739 * kludge: trim off trailer to avoid an extra blank line
740 * in infocmp -u output when there are no string differences
741 */
742 if (outcount) {
743 bool trimmed = FALSE;
744 j = outbuf.used;
745 if (j >= 2
746 && outbuf.text[j - 1] == '\t'
747 && outbuf.text[j - 2] == '\n') {
748 outbuf.used -= 2;
749 trimmed = TRUE;
750 } else if (j >= 4
748 && outbuf.text[j - 1] == ':'
749 && outbuf.text[j - 2] == '\t'
750 && outbuf.text[j - 3] == '\n'
751 && outbuf.text[j - 4] == '\\') {
751 && outbuf.text[j - 1] == ':'
752 && outbuf.text[j - 2] == '\t'
753 && outbuf.text[j - 3] == '\n'
754 && outbuf.text[j - 4] == '\\') {
752 outbuf.used -= 4;
753 trimmed = TRUE;
754 }
755 if (trimmed) {
756 outbuf.text[outbuf.used] = '\0';
757 column = oldcol;
758 }
759 }
760#if 0
761 fprintf(stderr, "num_bools = %d\n", num_bools);
762 fprintf(stderr, "num_values = %d\n", num_values);
763 fprintf(stderr, "num_strings = %d\n", num_strings);
764 fprintf(stderr, "term_names=%s, len=%d, strlen(outbuf)=%d, outbuf=%s\n",
755 outbuf.used -= 4;
756 trimmed = TRUE;
757 }
758 if (trimmed) {
759 outbuf.text[outbuf.used] = '\0';
760 column = oldcol;
761 }
762 }
763#if 0
764 fprintf(stderr, "num_bools = %d\n", num_bools);
765 fprintf(stderr, "num_values = %d\n", num_values);
766 fprintf(stderr, "num_strings = %d\n", num_strings);
767 fprintf(stderr, "term_names=%s, len=%d, strlen(outbuf)=%d, outbuf=%s\n",
765 tterm->term_names, len, outbuf.used, outbuf.text);
768 tterm->term_names, len, outbuf.used, outbuf.text);
766#endif
767 /*
768 * Here's where we use infodump to trigger a more stringent length check
769 * for termcap-translation purposes.
770 * Return the length of the raw entry, without tc= expansions,
771 * It gives an idea of which entries are deadly to even *scan past*,
772 * as opposed to *use*.
773 */
774 return (infodump ? len : (int) termcap_length(outbuf.text));
775}
776
769#endif
770 /*
771 * Here's where we use infodump to trigger a more stringent length check
772 * for termcap-translation purposes.
773 * Return the length of the raw entry, without tc= expansions,
774 * It gives an idea of which entries are deadly to even *scan past*,
775 * as opposed to *use*.
776 */
777 return (infodump ? len : (int) termcap_length(outbuf.text));
778}
779
780static bool
781kill_string(TERMTYPE * tterm, char *cap)
782{
783 int n;
784 for (n = 0; n < tterm->num_Strings; ++n) {
785 if (cap == tterm->Strings[n]) {
786 tterm->Strings[n] = ABSENT_STRING;
787 return TRUE;
788 }
789 }
790 return FALSE;
791}
792
793static char *
794find_string(TERMTYPE * tterm, char *name)
795{
796 int n;
797 for (n = 0; n < tterm->num_Strings; ++n) {
798 if (version_filter(STRING, n)
799 && !strcmp(name, strnames[n])) {
800 char *cap = tterm->Strings[n];
801 if (VALID_STRING(cap)) {
802 return cap;
803 }
804 break;
805 }
806 }
807 return ABSENT_STRING;
808}
809
810/*
811 * This is used to remove function-key labels from a termcap entry to
812 * make it smaller.
813 */
814static int
815kill_labels(TERMTYPE * tterm, int target)
816{
817 int n;
818 int result = 0;
819 char *cap;
820 char name[10];
821
822 for (n = 0; n <= 10; ++n) {
823 sprintf(name, "lf%d", n);
824 if ((cap = find_string(tterm, name)) != ABSENT_STRING
825 && kill_string(tterm, cap)) {
826 target -= (strlen(cap) + 5);
827 ++result;
828 if (target < 0)
829 break;
830 }
831 }
832 return result;
833}
834
835/*
836 * This is used to remove function-key definitions from a termcap entry to
837 * make it smaller.
838 */
839static int
840kill_fkeys(TERMTYPE * tterm, int target)
841{
842 int n;
843 int result = 0;
844 char *cap;
845 char name[10];
846
847 for (n = 60; n >= 0; --n) {
848 sprintf(name, "kf%d", n);
849 if ((cap = find_string(tterm, name)) != ABSENT_STRING
850 && kill_string(tterm, cap)) {
851 target -= (strlen(cap) + 5);
852 ++result;
853 if (target < 0)
854 break;
855 }
856 }
857 return result;
858}
859
777int
860int
778dump_entry(TERMTYPE * tterm, bool limited, int numbers, int (*pred) (int
779 type, int idx))
861dump_entry(TERMTYPE * tterm,
862 bool limited,
863 int numbers,
864 int (*pred) (int type, int idx))
780/* dump a single entry */
781{
782 int len, critlen;
783 const char *legend;
784 bool infodump;
785
786 if (outform == F_TERMCAP || outform == F_TCONVERR) {
787 critlen = MAX_TERMCAP_LENGTH;

--- 4 unchanged lines hidden (view full) ---

792 critlen = MAX_TERMINFO_LENGTH;
793 legend = "terminfo";
794 infodump = TRUE;
795 }
796
797 if (((len = fmt_entry(tterm, pred, FALSE, infodump, numbers)) > critlen)
798 && limited) {
799 PRINTF("# (untranslatable capabilities removed to fit entry within %d bytes)\n",
865/* dump a single entry */
866{
867 int len, critlen;
868 const char *legend;
869 bool infodump;
870
871 if (outform == F_TERMCAP || outform == F_TCONVERR) {
872 critlen = MAX_TERMCAP_LENGTH;

--- 4 unchanged lines hidden (view full) ---

877 critlen = MAX_TERMINFO_LENGTH;
878 legend = "terminfo";
879 infodump = TRUE;
880 }
881
882 if (((len = fmt_entry(tterm, pred, FALSE, infodump, numbers)) > critlen)
883 && limited) {
884 PRINTF("# (untranslatable capabilities removed to fit entry within %d bytes)\n",
800 critlen);
885 critlen);
801 if ((len = fmt_entry(tterm, pred, TRUE, infodump, numbers)) > critlen) {
802 /*
803 * We pick on sgr because it's a nice long string capability that
804 * is really just an optimization hack. Another good candidate is
805 * acsc since it is both long and unused by BSD termcap.
806 */
807 char *oldsgr = set_attributes;
808 char *oldacsc = acs_chars;
809 set_attributes = ABSENT_STRING;
810 PRINTF("# (sgr removed to fit entry within %d bytes)\n",
886 if ((len = fmt_entry(tterm, pred, TRUE, infodump, numbers)) > critlen) {
887 /*
888 * We pick on sgr because it's a nice long string capability that
889 * is really just an optimization hack. Another good candidate is
890 * acsc since it is both long and unused by BSD termcap.
891 */
892 char *oldsgr = set_attributes;
893 char *oldacsc = acs_chars;
894 set_attributes = ABSENT_STRING;
895 PRINTF("# (sgr removed to fit entry within %d bytes)\n",
811 critlen);
896 critlen);
812 if ((len = fmt_entry(tterm, pred, TRUE, infodump, numbers)) > critlen) {
813 acs_chars = ABSENT_STRING;
814 PRINTF("# (acsc removed to fit entry within %d bytes)\n",
897 if ((len = fmt_entry(tterm, pred, TRUE, infodump, numbers)) > critlen) {
898 acs_chars = ABSENT_STRING;
899 PRINTF("# (acsc removed to fit entry within %d bytes)\n",
815 critlen);
900 critlen);
816 }
817 if ((len = fmt_entry(tterm, pred, TRUE, infodump, numbers)) > critlen) {
818 int oldversion = tversion;
819
820 tversion = V_BSD;
821 PRINTF("# (terminfo-only capabilities suppressed to fit entry within %d bytes)\n",
901 }
902 if ((len = fmt_entry(tterm, pred, TRUE, infodump, numbers)) > critlen) {
903 int oldversion = tversion;
904
905 tversion = V_BSD;
906 PRINTF("# (terminfo-only capabilities suppressed to fit entry within %d bytes)\n",
822 critlen);
907 critlen);
823
908
824 if ((len = fmt_entry(tterm, pred, TRUE, infodump, numbers))
825 > critlen) {
909 len = fmt_entry(tterm, pred, TRUE, infodump, numbers);
910 if (len > critlen
911 && kill_labels(tterm, len - critlen)) {
912 PRINTF("# (some labels capabilities suppressed to fit entry within %d bytes)\n",
913 critlen);
914 len = fmt_entry(tterm, pred, TRUE, infodump, numbers);
915 }
916 if (len > critlen
917 && kill_fkeys(tterm, len - critlen)) {
918 PRINTF("# (some function-key capabilities suppressed to fit entry within %d bytes)\n",
919 critlen);
920 len = fmt_entry(tterm, pred, TRUE, infodump, numbers);
921 }
922 if (len > critlen) {
826 (void) fprintf(stderr,
923 (void) fprintf(stderr,
827 "warning: %s entry is %d bytes long\n",
828 _nc_first_name(tterm->term_names),
829 len);
924 "warning: %s entry is %d bytes long\n",
925 _nc_first_name(tterm->term_names),
926 len);
830 PRINTF(
927 PRINTF(
831 "# WARNING: this entry, %d bytes long, may core-dump %s libraries!\n",
832 len, legend);
928 "# WARNING: this entry, %d bytes long, may core-dump %s libraries!\n",
929 len, legend);
833 }
834 tversion = oldversion;
835 }
836 set_attributes = oldsgr;
837 acs_chars = oldacsc;
838 }
839 }
840

--- 11 unchanged lines hidden (view full) ---

852 (void) sprintf(buffer, "%s%s", infodump ? "use=" : "tc=", name);
853 wrap_concat(buffer);
854 (void) fputs(outbuf.text, stdout);
855 return outbuf.used;
856}
857
858void
859compare_entry(void (*hook) (int t, int i, const char *name), TERMTYPE * tp
930 }
931 tversion = oldversion;
932 }
933 set_attributes = oldsgr;
934 acs_chars = oldacsc;
935 }
936 }
937

--- 11 unchanged lines hidden (view full) ---

949 (void) sprintf(buffer, "%s%s", infodump ? "use=" : "tc=", name);
950 wrap_concat(buffer);
951 (void) fputs(outbuf.text, stdout);
952 return outbuf.used;
953}
954
955void
956compare_entry(void (*hook) (int t, int i, const char *name), TERMTYPE * tp
860 GCC_UNUSED, bool quiet)
957 GCC_UNUSED, bool quiet)
861/* compare two entries */
862{
863 int i, j;
864 NCURSES_CONST char *name;
865
866 if (!quiet)
867 fputs(" comparing booleans.\n", stdout);
868 for_each_boolean(j, tp) {

--- 102 unchanged lines hidden --- 		958/* compare two entries */
959{
960 int i, j;
961 NCURSES_CONST char *name;
962
963 if (!quiet)
964 fputs(" comparing booleans.\n", stdout);
965 for_each_boolean(j, tp) {

--- 102 unchanged lines hidden ---