ncurses 4.1
[ncurses.git] / ncurses / captoinfo.c
1
2 /***************************************************************************
3 *                            COPYRIGHT NOTICE                              *
4 ****************************************************************************
5 *                ncurses is copyright (C) 1992-1995                        *
6 *                          Zeyd M. Ben-Halim                               *
7 *                          zmbenhal@netcom.com                             *
8 *                          Eric S. Raymond                                 *
9 *                          esr@snark.thyrsus.com                           *
10 *                                                                          *
11 *        Permission is hereby granted to reproduce and distribute ncurses  *
12 *        by any means and for any fee, whether alone or as part of a       *
13 *        larger distribution, in source or in binary form, PROVIDED        *
14 *        this notice is included with any such distribution, and is not    *
15 *        removed from any of its header files. Mention of ncurses in any   *
16 *        applications linked with it is highly appreciated.                *
17 *                                                                          *
18 *        ncurses comes AS IS with no warranty, implied or expressed.       *
19 *                                                                          *
20 ***************************************************************************/
21
22
23
24 /*
25  *      captoinfo.c --- conversion between termcap and terminfo formats
26  *
27  *      The captoinfo() code was swiped from Ross Ridge's mytinfo package,
28  *      adapted to fit ncurses by Eric S. Raymond <esr@snark.thyrsus.com>.
29  *
30  *      There is just one entry point:
31  *
32  *      char *captoinfo(n, s, parametrized)
33  *
34  *      Convert value s for termcap string capability named n into terminfo
35  *      format.
36  *
37  *      This code recognizes all the standard 4.4BSD %-escapes:
38  *
39  *      %%       output `%'
40  *      %d       output value as in printf %d
41  *      %2       output value as in printf %2d
42  *      %3       output value as in printf %3d
43  *      %.       output value as in printf %c
44  *      %+x      add x to value, then do %.
45  *      %>xy     if value > x then add y, no output
46  *      %r       reverse order of two parameters, no output
47  *      %i       increment by one, no output
48  *      %n       exclusive-or all parameters with 0140 (Datamedia 2500)
49  *      %B       BCD (16*(value/10)) + (value%10), no output
50  *      %D       Reverse coding (value - 2*(value%16)), no output (Delta Data).
51  *
52  *      Also, %02 and %03 are accepted as synonyms for %2 and %3.
53  *
54  *      Besides all the standard termcap escapes, this translator understands
55  *      the following extended escapes:
56  *
57  *      used by GNU Emacs termcap libraries
58  *              %a[+*-/=][cp]x  GNU arithmetic.
59  *              %m              xor the first two parameters by 0177
60  *              %b              backup to previous parameter
61  *              %f              skip this parameter
62  *
63  *      used by the University of Waterloo (MFCF) termcap libraries
64  *              %-x      subtract parameter FROM char x and output it as a char
65  *              %ax      add the character x to parameter
66  *
67  *      If #define WATERLOO is on, also enable these translations:
68  *
69  *              %sx      subtract parameter FROM the character x
70  *
71  *      By default, this Waterloo translations are not compiled in, because
72  *      the Waterloo %s conflicts with the way terminfo uses %s in strings for
73  *      function programming.
74  *
75  *      Note the two definitions of %a: the GNU definition is translated if the
76  *      characters after the 'a' are valid for it, otherwise the UW definition
77  *      is translated.
78  */
79
80 #include <curses.priv.h>
81
82 #include <ctype.h>
83 #include <tic.h>
84
85 MODULE_ID("$Id: captoinfo.c,v 1.15 1996/12/21 14:24:06 tom Exp $")
86
87 #define MAX_PUSHED      16      /* max # args we can push onto the stack */
88 #define MAX_ENTRY       2048    /* maximum chars in a translated capability */
89
90 static int stack[MAX_PUSHED];   /* the stack */
91 static int stackptr;            /* the next empty place on the stack */
92 static int onstack;             /* the top of stack */
93 static int seenm;               /* seen a %m */
94 static int seenn;               /* seen a %n */
95 static int seenr;               /* seen a %r */
96 static int param;               /* current parameter */
97 static char *dp;                /* pointer to end of the converted string */
98
99 static char  *my_string;
100 static size_t my_length;
101
102 static char *init_string(void)
103 /* initialize 'my_string', 'my_length' */
104 {
105         if (my_string == 0)
106                 my_string = malloc(my_length = 256);
107         if (my_string == 0)
108             _nc_err_abort("Out of memory");
109
110         *my_string = '\0';
111         return my_string;
112 }
113
114 static char *save_string(char *d, const char *const s)
115 {
116         size_t have = (d - my_string);
117         size_t need = have + strlen(s) + 2;
118         if (need > my_length) {
119                 my_string = realloc(my_string, my_length = (need + need));
120                 d = my_string + have;
121         }
122         (void) strcpy(d, s);
123         return d + strlen(d);
124 }
125
126 static inline char *save_char(char *s, char c)
127 {
128         static char temp[2];
129         temp[0] = c;
130         return save_string(s, temp);
131 }
132
133 static void push(void)
134 /* push onstack on to the stack */
135 {
136     if (stackptr > MAX_PUSHED)
137         _nc_warning("string too complex to convert");
138     else
139         stack[stackptr++] = onstack;
140 }
141
142 static void pop(void)
143 /* pop the top of the stack into onstack */
144 {
145     if (stackptr == 0)
146         if (onstack == 0)
147             _nc_warning("I'm confused");
148         else
149             onstack = 0;
150     else
151         onstack = stack[--stackptr];
152     param++;
153 }
154
155 static int cvtchar(register char *sp)
156 /* convert a character to a terminfo push */
157 {
158     unsigned char c = 0;
159     int len;
160
161     switch(*sp) {
162     case '\\':
163         switch(*++sp) {
164         case '\'':
165         case '$':
166         case '\\':
167         case '%':
168             c = *sp;
169             len = 2;
170             break;
171         case '\0':
172             c = '\\';
173             len = 1;
174             break;
175         case '0':
176         case '1':
177         case '2':
178         case '3':
179             len = 1;
180             while (isdigit(*sp))
181             {
182                 c = 8 * c + (*sp++ - '0');
183                 len++;
184             }
185             break;
186         default:
187             c = *sp;
188             len = 2;
189             break;
190         }
191         break;
192     case '^':
193         c = (*++sp & 0x1f);
194         len = 2;
195         break;
196     default:
197         c = *sp;
198         len = 1;
199     }
200     if (isgraph(c) && c != ',' && c != '\'' && c != '\\' && c != ':') {
201         *dp++ = '%'; *dp++ = '\''; *dp++ = c; *dp++ = '\'';
202     } else {
203         *dp++ = '%'; *dp++ = '{';
204         if (c > 99)
205             *dp++ = c / 100 + '0';
206         if (c > 9)
207             *dp++ = ((int)(c / 10)) % 10 + '0';
208         *dp++ = c % 10 + '0';
209         *dp++ = '}';
210     }
211     return len;
212 }
213
214 static void getparm(int parm, int n)
215 /* push n copies of param on the terminfo stack if not already there */
216 {
217         if (seenr) {
218                 if (parm == 1)
219                         parm = 2;
220                 else if (parm == 2)
221                         parm = 1;
222                 }
223         if (onstack == parm) {
224                 if (n > 1) {
225                         _nc_warning("string may not be optimal");
226                         *dp++ = '%'; *dp++ = 'P'; *dp++ = 'a';
227                         while(n--) {
228                                 *dp++ = '%'; *dp++ = 'g'; *dp++ = 'a';
229                         }
230                 }
231                 return;
232         }
233         if (onstack != 0)
234                 push();
235
236         onstack = parm;
237
238         while(n--) {            /* %p0 */
239                 *dp++ = '%'; *dp++ = 'p'; *dp++ = '0' + parm;
240         }
241
242         if (seenn && parm < 3) {        /* %{96}%^ */
243                 *dp++ = '%'; *dp++ = '{'; *dp++ = '9'; *dp++ = '6'; *dp++ = '}';
244                 *dp++ = '%'; *dp++ = '^';
245         }
246
247         if (seenm && parm < 3) {        /* %{127}%^ */
248                 *dp++ = '%'; *dp++ = '{'; *dp++ = '1'; *dp++ = '2'; *dp++ = '7';
249                 *dp++ = '}'; *dp++ = '%'; *dp++ = '^';
250         }
251 }
252
253 char *_nc_captoinfo(
254 /* convert a termcap string to terminfo format */
255 register char *const cap,       /* relevant terminfo capability index */
256 register char *s,               /* string value of the capability */
257 int const parametrized)         /* do % translations if 1, pad translations if >=0 */
258 {
259     static char line[MAX_ENTRY];
260     char *capstart;
261
262     stackptr = 0;
263     onstack = 0;
264     seenm = 0;
265     seenn = 0;
266     seenr = 0;
267     param = 1;
268
269     dp = line;
270
271     /* skip the initial padding (if we haven't been told not to) */
272     capstart = (char *)NULL;
273     if (s == 0)
274         s = "";
275     if (parametrized >= 0 && isdigit(*s))
276         for (capstart = s; ; s++)
277             if (!(isdigit(*s) || *s == '*' || *s == '.'))
278                 break;
279
280     while(*s != '\0') {
281         switch(*s) {
282         case '%':
283             s++;
284             if (parametrized < 1) {
285                 *dp++ = '%';
286                 break;
287             }
288             switch(*s++) {
289             case '%': *dp++ = '%'; break;
290             case 'r':
291                 if (seenr++ == 1) {
292                     _nc_warning("saw %%r twice in %s", cap);
293                 }
294                 break;
295             case 'm':
296                 if (seenm++ == 1) {
297                     _nc_warning("saw %%m twice in %s", cap);
298                 }
299                 break;
300             case 'n':
301                 if (seenn++ == 1) {
302                     _nc_warning("saw %%n twice in %s", cap);
303                 }
304                 break;
305             case 'i': *dp++ = '%'; *dp++ = 'i'; break;
306             case '6':
307             case 'B':
308                 getparm(param, 2);
309                 /* %{6}%*%+ */
310                 *dp++ = '%'; *dp++ = '{'; *dp++ = '6';
311                 *dp++ = '}'; *dp++ = '%'; *dp++ = '*';
312                 *dp++ = '%'; *dp++ = '+';
313                 break;
314             case '8':
315             case 'D':
316                 getparm(param, 2);
317                 /* %{2}%*%- */
318                 *dp++ = '%'; *dp++ = '{'; *dp++ = '2';
319                 *dp++ = '}'; *dp++ = '%'; *dp++ = '*';
320                 *dp++ = '%'; *dp++ = '-';
321                 break;
322             case '>':
323                 getparm(param, 2);
324                 /* %?%{x}%>%t%{y}%+%; */
325                 *dp++ = '%'; *dp++ = '?';
326                 s += cvtchar(s);
327                 *dp++ = '%'; *dp++ = '>';
328                 *dp++ = '%'; *dp++ = 't';
329                 s += cvtchar(s);
330                 *dp++ = '%'; *dp++ = '+';
331                 *dp++ = '%'; *dp++ = ';';
332                 break;
333             case 'a':
334                 if ((*s == '=' || *s == '+' || *s == '-'
335                      || *s == '*' || *s == '/')
336                     && (s[1] == 'p' || s[1] == 'c')
337                     && s[2] != '\0') {
338                     int l;
339                     l = 2;
340                     if (*s != '=')
341                         getparm(param, 1);
342                     if (s[1] == 'p') {
343                         getparm(param + s[2] - '@', 1);
344                         if (param != onstack) {
345                             pop();
346                             param--;
347                         }
348                         l++;
349                     } else
350                         l += cvtchar(s + 2);
351                     switch(*s) {
352                     case '+':
353                         *dp++ = '%'; *dp++ = '+';
354                         break;
355                     case '-':
356                         *dp++ = '%'; *dp++ = '-';
357                         break;
358                     case '*':
359                         *dp++ = '%'; *dp++ = '*';
360                         break;
361                     case '/':
362                         *dp++ = '%'; *dp++ = '/';
363                         break;
364                     case '=':
365                         if (seenr)
366                             if (param == 1)
367                                 onstack = 2;
368                             else if (param == 2)
369                                 onstack = 1;
370                             else
371                                 onstack = param;
372                         else
373                             onstack = param;
374                         break;
375                     }
376                     s += l;
377                     break;
378                 }
379                 getparm(param, 1);
380                 s += cvtchar(s);
381                 *dp++ = '%'; *dp++ = '+';
382                 break;
383             case '+':
384                 getparm(param, 1);
385                 s += cvtchar(s);
386                 *dp++ = '%'; *dp++ = '+';
387                 *dp++ = '%'; *dp++ = 'c';
388                 pop();
389                 break;
390             case 's':
391 #ifdef WATERLOO
392                 s += cvtchar(s);
393                 getparm(param, 1);
394                 *dp++ = '%'; *dp++ = '-';
395 #else
396                 getparm(param, 1);
397                 *dp++ = '%'; *dp++ = 's';
398                 pop();
399 #endif /* WATERLOO */
400                 break;
401             case '-':
402                 s += cvtchar(s);
403                 getparm(param, 1);
404                 *dp++ = '%'; *dp++ = '-';
405                 *dp++ = '%'; *dp++ = 'c';
406                 pop();
407                 break;
408             case '.':
409                 getparm(param, 1);
410                 *dp++ = '%'; *dp++ = 'c';
411                 pop();
412                 break;
413             case '0':   /* not clear any of the historical termcaps did this */
414                 if (*s == '3')
415                     goto see03;
416                 else if (*s != '2')
417                     goto invalid;
418                 /* FALLTHRU */
419             case '2':
420                 getparm(param, 1);
421                 *dp++ = '%'; /* *dp++ = '0'; */
422                 *dp++ = '2'; *dp++ = 'd';
423                 pop();
424                 break;
425             case '3': see03:
426                 getparm(param, 1);
427                 *dp++ = '%'; /* *dp++ = '0'; */
428                 *dp++ = '3'; *dp++ = 'd';
429                 pop();
430                 break;
431             case 'd':
432                 getparm(param, 1);
433                 *dp++ = '%'; *dp++ = 'd';
434                 pop();
435                 break;
436             case 'f':
437                 param++;
438                 break;
439             case 'b':
440                 param--;
441                 break;
442             case '\\':
443                 *dp++ = '%';
444                 *dp++ = '\\';
445                 break;
446             default: invalid:
447                 *dp++ = '%';
448                 s--;
449                 _nc_warning("unknown %% code %s in %s",
450                         _tracechar(*s), cap);
451                 break;
452             }
453             break;
454 #ifdef REVISIBILIZE
455         case '\\':
456             *dp++ = *s++; *dp++ = *s++; break;
457         case '\n':
458             *dp++ = '\\'; *dp++ = 'n'; s++; break;
459         case '\t':
460             *dp++ = '\\'; *dp++ = 't'; s++; break;
461         case '\r':
462             *dp++ = '\\'; *dp++ = 'r'; s++; break;
463         case '\200':
464             *dp++ = '\\'; *dp++ = '0'; s++; break;
465         case '\f':
466             *dp++ = '\\'; *dp++ = 'f'; s++; break;
467         case '\b':
468             *dp++ = '\\'; *dp++ = 'b'; s++; break;
469         case ' ':
470             *dp++ = '\\'; *dp++ = 's'; s++; break;
471         case '^':
472             *dp++ = '\\'; *dp++ = '^'; s++; break;
473         case ':':
474             *dp++ = '\\'; *dp++ = ':'; s++; break;
475         case ',':
476             *dp++ = '\\'; *dp++ = ','; s++; break;
477         default:
478             if (*s == '\033') {
479                 *dp++ = '\\';
480                 *dp++ = 'E';
481                 s++;
482             } else if (*s > 0 && *s < 32) {
483                 *dp++ = '^';
484                 *dp++ = *s + '@';
485                 s++;
486             } else if (*s <= 0 || *s >= 127) {
487                 *dp++ = '\\';
488                 *dp++ = ((*s & 0300) >> 6) + '0';
489                 *dp++ = ((*s & 0070) >> 3) + '0';
490                 *dp++ = (*s & 0007) + '0';
491                 s++;
492             } else
493                 *dp++ = *s++;
494             break;
495 #else
496         default:
497             *dp++ = *s++;
498             break;
499 #endif
500         }
501     }
502
503     /*
504      * Now, if we stripped off some leading padding, add it at the end
505      * of the string as mandatory padding.
506      */
507     if (capstart)
508     {
509         *dp++ = '$';
510         *dp++ = '<';
511         for (s = capstart; ; s++)
512             if (isdigit(*s) || *s == '*' || *s == '.')
513                 *dp++ = *s;
514             else
515                 break;
516         *dp++ = '/';
517         *dp++ = '>';
518     }
519
520     *dp = '\0';
521     return(line);
522 }
523
524 /*
525  * Here are the capabilities infotocap assumes it can translate to:
526  *
527  *     %%       output `%'
528  *     %d       output value as in printf %d
529  *     %2       output value as in printf %2d
530  *     %3       output value as in printf %3d
531  *     %.       output value as in printf %c
532  *     %+c      add character c to value, then do %.
533  *     %>xy     if value > x then add y, no output
534  *     %r       reverse order of two parameters, no output
535  *     %i       increment by one, no output
536  *     %n       exclusive-or all parameters with 0140 (Datamedia 2500)
537  *     %B       BCD (16*(value/10)) + (value%10), no output
538  *     %D       Reverse coding (value - 2*(value%16)), no output (Delta Data).
539  *     %m       exclusive-or all parameters with 0177 (not in 4.4BSD)
540  */
541
542 char *_nc_infotocap(
543 /* convert a terminfo string to termcap format */
544 register char *const cap GCC_UNUSED, /* relevant termcap capability index */
545 register char *str,             /* string value of the capability */
546 int const parametrized)         /* do % translations if 1, pad translations if >=0 */
547 {
548     int seenone = 0, seentwo = 0, saw_m = 0, saw_n = 0;
549     char *padding, ch1 = 0, ch2 = 0;
550     char *bufptr = init_string();
551     char temp[256];
552
553     /* we may have to move some trailing mandatory padding up front */
554     padding = str + strlen(str) - 1;
555     if (*padding == '>' && *--padding == '/')
556     {
557         --padding;
558         while (isdigit(*padding) || *padding == '.' || *padding == '*')
559             padding--;
560         if (*padding == '<' && *--padding == '$')
561             *padding = '\0';
562         padding += 2;
563
564         while (isdigit(*padding) || *padding == '.' || *padding == '*')
565             bufptr = save_char(bufptr, *padding++);
566     }
567
568     for (; *str; str++)
569     {
570         int     c1, c2;
571         char    *cp;
572
573         if (str[0] == '\\' && (str[1] == '^' || str[1] == ','))
574         {
575             bufptr = save_char(bufptr, *++str);
576         }
577         else if (str[0] == '$' && str[1] == '<')        /* discard padding */
578         {
579             str += 2;
580             while (isdigit(*str) || *str == '.' || *str == '*' || *str == '/' || *str == '>')
581                 str++;
582             --str;
583         }
584         else if (*str != '%' || (parametrized < 1))
585             bufptr = save_char(bufptr, *str);
586         else if (sscanf(str, "%%?%%{%d}%%>%%t%%{%d}%%+%%;", &c1,&c2) == 2)
587         {
588             str = strchr(str, ';');
589             (void) sprintf(temp, "%%>");
590             (void) strcat(temp, unctrl(c1));
591             (void) strcat(temp, unctrl(c2));
592             bufptr = save_string(bufptr, temp);
593         }
594         else if (sscanf(str, "%%?%%{%d}%%>%%t%%'%c'%%+%%;", &c1,&ch2) == 2)
595         {
596             str = strchr(str, ';');
597             (void) sprintf(temp, "%%>%s%c", unctrl(c1), ch2);
598             bufptr = save_string(bufptr, temp);
599         }
600         else if (sscanf(str, "%%?%%'%c'%%>%%t%%{%d}%%+%%;", &ch1,&c2) == 2)
601         {
602             str = strchr(str, ';');
603             (void) sprintf(temp, "%%>%c%c", ch1, c2);
604             bufptr = save_string(bufptr, temp);
605         }
606         else if (sscanf(str, "%%?%%'%c'%%>%%t%%'%c'%%+%%;", &ch1, &ch2) == 2)
607         {
608             str = strchr(str, ';');
609             (void) sprintf(temp, "%%>%c%c", ch1, ch2);
610             bufptr = save_string(bufptr, temp);
611         }
612         else if (strncmp(str, "%{6}%*%+", 8) == 0)
613         {
614             str += 7;
615             (void) sprintf(temp, "%%B");
616             bufptr = save_string(bufptr, temp);
617         }
618         else if ((sscanf(str, "%%{%d}%%+%%c", &c1) == 1
619                   || sscanf(str, "%%'%c'%%+%%c", &ch1) == 1)
620                  && (cp = strchr(str, '+')))
621         {
622             str = cp + 2;
623             bufptr = save_char(bufptr, '%');
624             bufptr = save_char(bufptr, '+');
625
626             if (ch1)
627                 c1 = ch1;
628             if (is7bits(c1) && isprint(c1))
629                 bufptr = save_char(bufptr, (char)c1);
630             else
631             {
632                 if (c1 == (c1 & 0x1f)) /* iscntrl() returns T on 255 */
633                     (void) strcpy(temp, unctrl(c1));
634                 else
635                     (void) sprintf(temp, "\\%03o", c1);
636                 bufptr = save_string(bufptr, temp);
637             }
638         }
639         else if (strncmp(str, "%{2}%*%-", 8) == 0)
640         {
641             str += 7;
642             (void) sprintf(temp, "%%D");
643             bufptr = save_string(bufptr, temp);
644         }
645         else if (strncmp(str, "%{96}%^", 7) == 0)
646         {
647             str += 6;
648             if (saw_m++ == 0)
649             {
650                 (void) sprintf(temp, "%%n");
651                 bufptr = save_string(bufptr, temp);
652             }
653         }
654         else if (strncmp(str, "%{127}%^", 8) == 0)
655         {
656             str += 7;
657             if (saw_n++ == 0)
658             {
659                 (void) sprintf(temp, "%%m");
660                 bufptr = save_string(bufptr, temp);
661             }
662         }
663         else
664         {
665             str++;
666             switch (*str) {
667             case '%':
668                 bufptr = save_char(bufptr, '%');
669                 break;
670
671             case '0':
672             case '1':
673             case '2':
674             case '3':
675             case '4':
676             case '5':
677             case '6':
678             case '7':
679             case '8':
680             case '9':
681                 bufptr = save_char(bufptr, '%');
682                 while (isdigit(*str))
683                     bufptr = save_char(bufptr, *str++);
684                 if (*str == 'd')
685                     str++;
686                 else
687                     _nc_warning("numeric prefix is missing trailing d in %s",
688                                 cap);
689                 --str;
690                 break;
691
692             case 'd':
693                 bufptr = save_char(bufptr, '%');
694                 bufptr = save_char(bufptr, 'd');
695                 break;
696
697             case 'c':
698                 bufptr = save_char(bufptr, '%');
699                 bufptr = save_char(bufptr, '.');
700                 break;
701
702             /*
703              * %s isn't in termcap, but it's convenient to pass it through
704              * so we can represent things like terminfo pfkey strings in
705              * termcap notation.
706              */
707             case 's':
708                 bufptr = save_char(bufptr, '%');
709                 bufptr = save_char(bufptr, 's');
710                 break;
711
712             case 'p':
713                 str++;
714                 if (*str == '1')
715                     seenone = 1;
716                 else if (*str == '2')
717                 {
718                     if (!seenone && !seentwo)
719                     {
720                         bufptr = save_char(bufptr, '%');
721                         bufptr = save_char(bufptr, 'r');
722                         seentwo++;
723                     }
724                 }
725                 else if (*str >= '3')
726                     return((char *)NULL);
727                 break;
728
729             case 'i':
730                 bufptr = save_char(bufptr, '%');
731                 bufptr = save_char(bufptr, 'i');
732                 break;
733
734             default:
735                 return((char *)NULL);
736
737             } /* endswitch (*str) */
738         } /* endelse (*str == '%') */
739
740         if (*str == '\0')
741             break;
742
743     } /* endwhile (*str) */
744
745     return(my_string);
746 }
747
748 #ifdef MAIN
749
750 int curr_line;
751
752 int main(int argc, char *argv[])
753 {
754     int c, tc = FALSE;
755
756     while ((c = getopt(argc, argv, "c")) != EOF)
757         switch (c)
758         {
759         case 'c':
760             tc = TRUE;
761             break;
762         }
763
764     curr_line = 0;
765     for (;;)
766     {
767         char    buf[BUFSIZ];
768
769         ++curr_line;
770         if (fgets(buf, sizeof(buf), stdin) == (char *)NULL)
771             break;
772         buf[strlen(buf) - 1] = '\0';
773         _nc_set_source(buf);
774
775         if (tc)
776         {
777             char        *cp = _nc_infotocap("to termcap", buf, 1);
778
779             if (cp)
780                 (void) fputs(cp, stdout);
781         }
782         else
783             (void) fputs(_nc_captoinfo("to terminfo", buf, 1), stdout);
784         (void) putchar('\n');
785     }
786     return(0);
787 }
788 #endif /* MAIN */
789
790 /* captoinfo.c ends here */
791