src/termcap.c

   1 /* Copyright (c) 2008
   2  *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
   3  *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
   4  *      Micah Cowan (micah@cowan.name)
   5  *      Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
   6  * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007
   7  *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
   8  *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
   9  * Copyright (c) 1987 Oliver Laumann
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 3, or (at your option)
  14  * any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program (see the file COPYING); if not, see
  23  * http://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,
  24  * 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  25  *
  26  ****************************************************************
  27  */
  28
  29 #include <sys/types.h>
  30 #include "config.h"
  31 #include "screen.h"
  32 #include "extern.h"
  33
  34 #undef DEBUGG
  35
  36 extern struct display *display, *displays;
  37 extern int real_uid, real_gid, eff_uid, eff_gid;
  38 extern struct term term[];      /* terminal capabilities */
  39 extern struct NewWindow nwin_undef, nwin_default, nwin_options;
  40 extern int force_vt;
  41 extern int Z0width, Z1width;
  42 extern int hardstatusemu;
  43 #ifdef MAPKEYS
  44 extern struct action umtab[];
  45 extern struct action mmtab[];
  46 extern struct action dmtab[];
  47 extern struct action ktab[];
  48 extern struct kmap_ext *kmap_exts;
  49 extern int kmap_extn;
  50 extern int DefaultEsc;
  51 #endif
  52
  53
  54 static void  AddCap __P((char *));
  55 static void  MakeString __P((char *, char *, int, char *));
  56 static char *findcap __P((char *, char **, int));
  57 static int   copyarg __P((char **, char *));
  58 static int   e_tgetent __P((char *, char *));
  59 static char *e_tgetstr __P((char *, char **));
  60 static int   e_tgetflag __P((char *));
  61 static int   e_tgetnum __P((char *));
  62 #ifdef MAPKEYS
  63 static int   findseq_ge __P((char *, int, unsigned char **));
  64 static void  setseqoff __P((unsigned char *, int, int));
  65 static int   addmapseq __P((char *, int, int));
  66 static int   remmapseq __P((char *, int));
  67 #ifdef DEBUGG
  68 static void  dumpmap __P((void));
  69 #endif
  70 #endif
  71
  72
  73 char Termcap[TERMCAP_BUFSIZE + 8];      /* new termcap +8:"TERMCAP=" */
  74 static int Termcaplen;
  75 static int tcLineLen;
  76 char Term[MAXSTR+5];            /* +5: "TERM=" */
  77 char screenterm[20];            /* new $TERM, usually "screen" */
  78
  79 char *extra_incap, *extra_outcap;
  80
  81 static const char TermcapConst[] = "\\\n\
  82 \t:DO=\\E[%dB:LE=\\E[%dD:RI=\\E[%dC:UP=\\E[%dA:bs:bt=\\E[Z:\\\n\
  83 \t:cd=\\E[J:ce=\\E[K:cl=\\E[H\\E[J:cm=\\E[%i%d;%dH:ct=\\E[3g:\\\n\
  84 \t:do=^J:nd=\\E[C:pt:rc=\\E8:rs=\\Ec:sc=\\E7:st=\\EH:up=\\EM:\\\n\
  85 \t:le=^H:bl=^G:cr=^M:it#8:ho=\\E[H:nw=\\EE:ta=^I:is=\\E)0:";
  86
  87 char *
  88 gettermcapstring(s)
  89 char *s;
  90 {
  91   int i;
  92
  93   if (display == 0 || s == 0)
  94     return 0;
  95   for (i = 0; i < T_N; i++)
  96     {
  97       if (term[i].type != T_STR)
  98         continue;
  99       if (strcmp(term[i].tcname, s) == 0)
 100         return D_tcs[i].str;
 101     }
 102   return 0;
 103 }
 104
 105 /*
 106  * Compile the terminal capabilities for a display.
 107  * Input: tgetent(, D_termname) extra_incap, extra_outcap.
 108  * Effect: display initialisation.
 109  */
 110 int
 111 InitTermcap(wi, he)
 112 int wi;
 113 int he;
 114 {
 115   register char *s;
 116   int i;
 117   char tbuf[TERMCAP_BUFSIZE], *tp;
 118   int t, xue, xse, xme;
 119
 120   ASSERT(display);
 121   bzero(tbuf, sizeof(tbuf));
 122   debug1("InitTermcap: looking for tgetent('%s')\n", D_termname);
 123   if (*D_termname == 0 || e_tgetent(tbuf, D_termname) != 1)
 124     {
 125 #ifdef TERMINFO
 126       Msg(0, "Cannot find terminfo entry for '%s'.", D_termname);
 127 #else
 128       Msg(0, "Cannot find termcap entry for '%s'.", D_termname);
 129 #endif
 130       return -1;
 131     }
 132   debug1("got it:\n%s\n", tbuf);
 133 #ifdef DEBUG
 134   if (extra_incap)
 135     debug1("Extra incap: %s\n", extra_incap);
 136   if (extra_outcap)
 137     debug1("Extra outcap: %s\n", extra_outcap);
 138 #endif
 139
 140   if ((D_tentry = (char *)malloc(TERMCAP_BUFSIZE + (extra_incap ? strlen(extra_incap) + 1 : 0))) == 0)
 141     {
 142       Msg(0, strnomem);
 143       return -1;
 144     }
 145
 146   /*
 147    * loop through all needed capabilities, record their values in the display
 148    */
 149   tp = D_tentry;
 150   for (i = 0; i < T_N; i++)
 151     {
 152       switch(term[i].type)
 153         {
 154         case T_FLG:
 155           D_tcs[i].flg = e_tgetflag(term[i].tcname);
 156           break;
 157         case T_NUM:
 158           D_tcs[i].num = e_tgetnum(term[i].tcname);
 159           break;
 160         case T_STR:
 161           D_tcs[i].str = e_tgetstr(term[i].tcname, &tp);
 162           /* no empty strings, please */
 163           if (D_tcs[i].str && *D_tcs[i].str == 0)
 164             D_tcs[i].str = 0;
 165           break;
 166         default:
 167           Panic(0, "Illegal tc type in entry #%d", i);
 168           /*NOTREACHED*/
 169         }
 170     }
 171
 172   /*
 173    * Now a good deal of sanity checks on the retrieved capabilities.
 174    */
 175   if (D_HC)
 176     {
 177       Msg(0, "You can't run screen on a hardcopy terminal.");
 178       return -1;
 179     }
 180   if (D_OS)
 181     {
 182       Msg(0, "You can't run screen on a terminal that overstrikes.");
 183       return -1;
 184     }
 185   if (!D_CL)
 186     {
 187       Msg(0, "Clear screen capability required.");
 188       return -1;
 189     }
 190   if (!D_CM)
 191     {
 192       Msg(0, "Addressable cursor capability required.");
 193       return -1;
 194     }
 195   if ((s = getenv("COLUMNS")) && (i = atoi(s)) > 0)
 196     D_CO = i;
 197   if ((s = getenv("LINES")) && (i = atoi(s)) > 0)
 198     D_LI = i;
 199   if (wi)
 200     D_CO = wi;
 201   if (he)
 202     D_LI = he;
 203   if (D_CO <= 0)
 204     D_CO = 80;
 205   if (D_LI <= 0)
 206     D_LI = 24;
 207
 208   if (D_CTF)
 209     {
 210       /* standard fixes for xterms etc */
 211       /* assume color for everything that looks ansi-compatible */
 212       if (!D_CAF && D_ME && (InStr(D_ME, "\033[m") || InStr(D_ME, "\033[0m")))
 213         {
 214 #ifdef TERMINFO
 215           D_CAF = "\033[3%p1%dm";
 216           D_CAB = "\033[4%p1%dm";
 217 #else
 218           D_CAF = "\033[3%dm";
 219           D_CAB = "\033[4%dm";
 220 #endif
 221         }
 222       if (D_OP && InStr(D_OP, "\033[39;49m"))
 223         D_CAX = 1;
 224       if (D_OP && (InStr(D_OP, "\033[m") || InStr(D_OP, "\033[0m")))
 225         D_OP = 0;
 226       /* ISO2022 */
 227       if ((D_EA && InStr(D_EA, "\033(B")) || (D_AS && InStr(D_AS, "\033(0")))
 228         D_CG0 = 1;
 229       if (InStr(D_termname, "xterm") || InStr(D_termname, "rxvt"))
 230         D_CXT = 1;
 231       /* "be" seems to be standard for xterms... */
 232       if (D_CXT)
 233         D_BE = 1;
 234     }
 235   if (nwin_options.flowflag == nwin_undef.flowflag)
 236     nwin_default.flowflag = D_CNF ? FLOW_NOW * 0 :
 237                             D_NX ? FLOW_NOW * 1 :
 238                             FLOW_AUTOFLAG;
 239   D_CLP |= (!D_AM || D_XV || D_XN);
 240   if (!D_BL)
 241     D_BL = "\007";
 242   if (!D_BC)
 243     {
 244       if (D_BS)
 245         D_BC = "\b";
 246       else
 247         D_BC = D_LE;
 248     }
 249   if (!D_CR)
 250     D_CR = "\r";
 251   if (!D_NL)
 252     D_NL = "\n";
 253
 254   /*
 255    *  Set up attribute handling.
 256    *  This is rather complicated because termcap has different
 257    *  attribute groups.
 258    */
 259
 260   if (D_UG > 0)
 261     D_US = D_UE = 0;
 262   if (D_SG > 0)
 263     D_SO = D_SE = 0;
 264   /* Unfortunatelly there is no 'mg' capability.
 265    * For now we think that mg > 0 if sg and ug > 0.
 266    */
 267   if (D_UG > 0 && D_SG > 0)
 268     D_MH = D_MD = D_MR = D_MB = D_ME = 0;
 269
 270   xue = ATYP_U;
 271   xse = ATYP_S;
 272   xme = ATYP_M;
 273
 274   if (D_SO && D_SE == 0)
 275     {
 276       Msg(0, "Warning: 'so' but no 'se' capability.");
 277       if (D_ME)
 278         xse = xme;
 279       else
 280         D_SO = 0;
 281     }
 282   if (D_US && D_UE == 0)
 283     {
 284       Msg(0, "Warning: 'us' but no 'ue' capability.");
 285       if (D_ME)
 286         xue = xme;
 287       else
 288         D_US = 0;
 289     }
 290   if ((D_MH || D_MD || D_MR || D_MB) && D_ME == 0)
 291     {
 292       Msg(0, "Warning: 'm?' but no 'me' capability.");
 293       D_MH = D_MD = D_MR = D_MB = 0;
 294     }
 295   /*
 296    * Does ME also reverse the effect of SO and/or US?  This is not
 297    * clearly specified by the termcap manual. Anyway, we should at
 298    * least look whether ME and SE/UE are equal:
 299    */
 300   if (D_UE && D_SE && strcmp(D_SE, D_UE) == 0)
 301     xse = xue;
 302   if (D_SE && D_ME && strcmp(D_ME, D_SE) == 0)
 303     xse = xme;
 304   if (D_UE && D_ME && strcmp(D_ME, D_UE) == 0)
 305     xue = xme;
 306
 307   for (i = 0; i < NATTR; i++)
 308     {
 309       D_attrtab[i] = D_tcs[T_ATTR + i].str;
 310       D_attrtyp[i] = i == ATTR_SO ? xse : (i == ATTR_US ? xue : xme);
 311     }
 312
 313   /* Set up missing entries (attributes are priority ordered) */
 314   s = 0;
 315   t = 0;
 316   for (i = 0; i < NATTR; i++)
 317     if ((s = D_attrtab[i]))
 318       {
 319         t = D_attrtyp[i];
 320         break;
 321       }
 322   for (i = 0; i < NATTR; i++)
 323     {
 324       if (D_attrtab[i] == 0)
 325         {
 326           D_attrtab[i] = s;
 327           D_attrtyp[i] = t;
 328         }
 329       else
 330         {
 331           s = D_attrtab[i];
 332           t = D_attrtyp[i];
 333         }
 334     }
 335   if (D_CAF || D_CAB || D_CSF || D_CSB)
 336     D_hascolor = 1;
 337   if (D_UT)
 338     D_BE = 1;   /* screen erased with background color */
 339
 340   if (!D_DO)
 341     D_DO = D_NL;
 342   if (!D_SF)
 343     D_SF = D_NL;
 344   if (D_IN)
 345     D_IC = D_IM = 0;
 346   if (D_EI == 0)
 347     D_IM = 0;
 348   /* some strange termcap entries have IC == IM */
 349   if (D_IC && D_IM && strcmp(D_IC, D_IM) == 0)
 350     D_IC = 0;
 351   if (D_KE == 0)
 352     D_KS = 0;
 353   if (D_CVN == 0)
 354     D_CVR = 0;
 355   if (D_VE == 0)
 356     D_VI = D_VS = 0;
 357   if (D_CCE == 0)
 358     D_CCS = 0;
 359
 360 #ifdef FONT
 361   if (D_CG0)
 362     {
 363       if (D_CS0 == 0)
 364 #ifdef TERMINFO
 365         D_CS0 = "\033(%p1%c";
 366 #else
 367         D_CS0 = "\033(%.";
 368 #endif
 369       if (D_CE0 == 0)
 370         D_CE0 = "\033(B";
 371       D_AC = 0;
 372       D_EA = 0;
 373     }
 374   else if (D_AC || (D_AS && D_AE))      /* some kind of graphics */
 375     {
 376       D_CS0 = (D_AS && D_AE) ? D_AS : "";
 377       D_CE0 = (D_AS && D_AE) ? D_AE : "";
 378       D_CC0 = D_AC;
 379     }
 380   else
 381     {
 382       D_CS0 = D_CE0 = "";
 383       D_CC0 = 0;
 384       D_AC = "";        /* enable default string */
 385     }
 386
 387   for (i = 0; i < 256; i++)
 388     D_c0_tab[i] = i;
 389   if (D_AC)
 390     {
 391       /* init with default string first */
 392       s = "l+m+k+j+u+t+v+w+q-x|n+o~s_p\"r#`+a:f'g#~o.v-^+<,>h#I#0#y<z>";
 393       for (i = strlen(s) & ~1; i >= 0; i -= 2)
 394         D_c0_tab[(int)(unsigned char)s[i]] = s[i + 1];
 395     }
 396   if (D_CC0)
 397     for (i = strlen(D_CC0) & ~1; i >= 0; i -= 2)
 398       D_c0_tab[(int)(unsigned char)D_CC0[i]] = D_CC0[i + 1];
 399   debug1("ISO2022 = %d\n", D_CG0);
 400 #endif /* FONT */
 401   if (D_PF == 0)
 402     D_PO = 0;
 403   debug2("terminal size is %d, %d (says TERMCAP)\n", D_CO, D_LI);
 404
 405 #ifdef FONT
 406   if (D_CXC)
 407     if (CreateTransTable(D_CXC))
 408       return -1;
 409 #endif
 410
 411   /* Termcap fields Z0 & Z1 contain width-changing sequences. */
 412   if (D_CZ1 == 0)
 413     D_CZ0 = 0;
 414   Z0width = 132;
 415   Z1width = 80;
 416
 417   CheckScreenSize(0);
 418
 419   if (D_TS == 0 || D_FS == 0 || D_DS == 0)
 420     D_HS = 0;
 421   if (D_HS)
 422     {
 423       debug("oy! we have a hardware status line, says termcap\n");
 424       if (D_WS < 0)
 425         D_WS = 0;
 426     }
 427   D_has_hstatus = hardstatusemu & ~HSTATUS_ALWAYS;
 428   if (D_HS && !(hardstatusemu & HSTATUS_ALWAYS))
 429     D_has_hstatus = HSTATUS_HS;
 430
 431 #ifdef ENCODINGS
 432   if (D_CKJ)
 433     {
 434       int enc = FindEncoding(D_CKJ);
 435       if (enc != -1)
 436         D_encoding = enc;
 437     }
 438 #endif
 439   if (!D_tcs[T_NAVIGATE].str && D_tcs[T_NAVIGATE + 1].str)
 440     D_tcs[T_NAVIGATE].str = D_tcs[T_NAVIGATE + 1].str;  /* kh = @1 */
 441   if (!D_tcs[T_NAVIGATE + 2].str && D_tcs[T_NAVIGATE + 3].str)
 442     D_tcs[T_NAVIGATE + 2].str = D_tcs[T_NAVIGATE + 3].str; /* kH = @7 */
 443
 444   D_UPcost = CalcCost(D_UP);
 445   D_DOcost = CalcCost(D_DO);
 446   D_NLcost = CalcCost(D_NL);
 447   D_LEcost = CalcCost(D_BC);
 448   D_NDcost = CalcCost(D_ND);
 449   D_CRcost = CalcCost(D_CR);
 450   D_IMcost = CalcCost(D_IM);
 451   D_EIcost = CalcCost(D_EI);
 452
 453 #ifdef AUTO_NUKE
 454   if (D_CAN)
 455     {
 456       debug("termcap has AN, setting autonuke\n");
 457       D_auto_nuke = 1;
 458     }
 459 #endif
 460   if (D_COL > 0)
 461     {
 462       debug1("termcap has OL (%d), setting limit\n", D_COL);
 463       D_obufmax = D_COL;
 464       D_obuflenmax = D_obuflen - D_obufmax;
 465     }
 466
 467   /* Some xterm entries set F0 and F10 to the same string. Nuke F0. */
 468   if (D_tcs[T_CAPS].str && D_tcs[T_CAPS + 10].str && !strcmp(D_tcs[T_CAPS].str, D_tcs[T_CAPS + 10].str))
 469     D_tcs[T_CAPS].str = 0;
 470   /* Some xterm entries set kD to ^?. Nuke it. */
 471   if (D_tcs[T_NAVIGATE_DELETE].str && !strcmp(D_tcs[T_NAVIGATE_DELETE].str, "\0177"))
 472     D_tcs[T_NAVIGATE_DELETE].str = 0;
 473   /* wyse52 entries have kcub1 == kb == ^H. Nuke... */
 474   if (D_tcs[T_CURSOR + 3].str && !strcmp(D_tcs[T_CURSOR + 3].str, "\008"))
 475     D_tcs[T_CURSOR + 3].str = 0;
 476
 477 #ifdef MAPKEYS
 478   D_nseqs = 0;
 479   for (i = 0; i < T_OCAPS - T_CAPS; i++)
 480     remap(i, 1);
 481   for (i = 0; i < kmap_extn; i++)
 482     remap(i + (KMAP_KEYS+KMAP_AKEYS), 1);
 483   D_seqp = D_kmaps + 3;
 484   D_seql = 0;
 485   D_seqh = 0;
 486 #endif
 487
 488   D_tcinited = 1;
 489   MakeTermcap(0);
 490 #ifdef MAPKEYS
 491   CheckEscape();
 492 #endif
 493   return 0;
 494 }
 495
 496 #ifdef MAPKEYS
 497
 498 int
 499 remap(n, map)
 500 int n;
 501 int map;
 502 {
 503   char *s = 0;
 504   int fl = 0, domap = 0;
 505   struct action *a1, *a2, *tab;
 506   int l = 0;
 507   struct kmap_ext *kme = 0;
 508
 509   a1 = 0;
 510   if (n >= KMAP_KEYS+KMAP_AKEYS)
 511     {
 512       kme = kmap_exts + (n - (KMAP_KEYS+KMAP_AKEYS));
 513       s = kme->str;
 514       l = kme->fl & ~KMAP_NOTIMEOUT;
 515       fl = kme->fl & KMAP_NOTIMEOUT;
 516       a1 = &kme->um;
 517     }
 518   tab = umtab;
 519   for (;;)
 520     {
 521       a2 = 0;
 522       if (n < KMAP_KEYS+KMAP_AKEYS)
 523         {
 524           a1 = &tab[n];
 525           if (n >= KMAP_KEYS)
 526             n -= T_OCAPS-T_CURSOR;
 527           s = D_tcs[n + T_CAPS].str;
 528           l = s ? strlen(s) : 0;
 529           if (n >= T_CURSOR-T_CAPS)
 530             a2 = &tab[n + (T_OCAPS-T_CURSOR)];
 531         }
 532       if (s == 0 || l == 0)
 533         return 0;
 534       if (a1 && a1->nr == RC_ILLEGAL)
 535         a1 = 0;
 536       if (a2 && a2->nr == RC_ILLEGAL)
 537         a2 = 0;
 538       if (a1 && a1->nr == RC_STUFF && a1->args[0] && strcmp(a1->args[0], s) == 0)
 539         a1 = 0;
 540       if (a2 && a2->nr == RC_STUFF && a2->args[0] && strcmp(a2->args[0], s) == 0)
 541         a2 = 0;
 542       domap |= (a1 || a2);
 543       if (tab == umtab)
 544         {
 545           tab = dmtab;
 546           a1 = kme ? &kme->dm : 0;
 547         }
 548       else if (tab == dmtab)
 549         {
 550           tab = mmtab;
 551           a1 = kme ? &kme->mm : 0;
 552         }
 553       else
 554         break;
 555     }
 556   if (map == 0 && domap)
 557     return 0;
 558   if (map && !domap)
 559     return 0;
 560   debug3("%smapping %s %#x\n", map? "" :"un",s,n);
 561   if (map)
 562     return addmapseq(s, l, n | fl);
 563   else
 564     return remmapseq(s, l);
 565 }
 566
 567 void
 568 CheckEscape()
 569 {
 570   struct display *odisplay;
 571   int i, nr;
 572
 573   if (DefaultEsc >= 0)
 574     return;
 575
 576   odisplay = display;
 577   for (display = displays; display; display = display->d_next)
 578     {
 579       for (i = 0; i < D_nseqs; i += D_kmaps[i + 2] * 2 + 4)
 580         {
 581           nr = (D_kmaps[i] << 8 | D_kmaps[i + 1]) & ~KMAP_NOTIMEOUT;
 582           if (nr < KMAP_KEYS+KMAP_AKEYS)
 583             {
 584               if (umtab[nr].nr == RC_COMMAND)
 585                 break;
 586               if (umtab[nr].nr == RC_ILLEGAL && dmtab[nr].nr == RC_COMMAND)
 587                 break;
 588             }
 589           else
 590             {
 591               struct kmap_ext *kme = kmap_exts + nr - (KMAP_KEYS+KMAP_AKEYS);
 592               if (kme->um.nr == RC_COMMAND)
 593                 break;
 594               if (kme->um.nr == RC_ILLEGAL && kme->dm.nr == RC_COMMAND)
 595                 break;
 596             }
 597         }
 598     }
 599   if (display == 0)
 600     {
 601       display = odisplay;
 602       return;
 603     }
 604   SetEscape((struct acluser *)0, Ctrl('a'), 'a');
 605   if (odisplay->d_user->u_Esc == -1)
 606     odisplay->d_user->u_Esc = DefaultEsc;
 607   if (odisplay->d_user->u_MetaEsc == -1)
 608     odisplay->d_user->u_MetaEsc = DefaultMetaEsc;
 609   display = 0;
 610   Msg(0, "Warning: escape char set back to ^A");
 611   display = odisplay;
 612 }
 613
 614 static int
 615 findseq_ge(seq, k, sp)
 616 char *seq;
 617 int k;
 618 unsigned char **sp;
 619 {
 620   unsigned char *p;
 621   int j, l;
 622
 623   p = D_kmaps;
 624   while (p - D_kmaps < D_nseqs)
 625     {
 626       l = p[2];
 627       p += 3;
 628       for (j = 0; ; j++)
 629         {
 630           if (j == k || j == l)
 631             j = l - k;
 632           else if (p[j] != ((unsigned char *)seq)[j])
 633             j = p[j] - ((unsigned char *)seq)[j];
 634           else
 635             continue;
 636           break;
 637         }
 638       if (j >= 0)
 639         {
 640           *sp = p - 3;
 641           return j;
 642         }
 643       p += 2 * l + 1;
 644     }
 645   *sp = p;
 646   return -1;
 647 }
 648
 649 static void
 650 setseqoff(p, i, o)
 651 unsigned char *p;
 652 int i;
 653 int o;
 654 {
 655   unsigned char *q;
 656   int l, k;
 657
 658   k = p[2];
 659   if (o < 256)
 660     {
 661       p[k + 4 + i] = o;
 662       return;
 663     }
 664   /* go for the biggest offset */
 665   for (q = p + k * 2 + 4; ; q += l * 2 + 4)
 666     {
 667       l = q[2];
 668       if ((q + l * 2 - p) / 2 >= 256)
 669         {
 670           p[k + 4 + i] = (q - p - 4) / 2;
 671           return;
 672         }
 673     }
 674 }
 675
 676 static int
 677 addmapseq(seq, k, nr)
 678 char *seq;
 679 int k;
 680 int nr;
 681 {
 682   int i, j, l, mo, m;
 683   unsigned char *p, *q;
 684
 685   if (k >= 254)
 686     return -1;
 687   j = findseq_ge(seq, k, &p);
 688   if (j == 0)
 689     {
 690       p[0] = nr >> 8;
 691       p[1] = nr;
 692       return 0;
 693     }
 694   i = p - D_kmaps;
 695   if (D_nseqs + 2 * k + 4 >= D_aseqs)
 696     {
 697       D_kmaps = (unsigned char *)xrealloc((char *)D_kmaps, D_aseqs + 256);
 698       D_aseqs += 256;
 699       p = D_kmaps + i;
 700     }
 701   D_seqp = D_kmaps + 3;
 702   D_seql = 0;
 703   D_seqh = 0;
 704   evdeq(&D_mapev);
 705   if (j > 0)
 706     bcopy((char *)p, (char *)p + 2 * k + 4, D_nseqs - i);
 707   p[0] = nr >> 8;
 708   p[1] = nr;
 709   p[2] = k;
 710   bcopy(seq, (char *)p + 3, k);
 711   bzero(p + k + 3, k + 1);
 712   D_nseqs += 2 * k + 4;
 713   if (j > 0)
 714     {
 715       q = p + 2 * k + 4;
 716       l = q[2];
 717       for (i = 0; i < k; i++)
 718         {
 719           if (p[3 + i] != q[3 + i])
 720             {
 721               p[k + 4 + i] = k;
 722               break;
 723             }
 724           setseqoff(p, i, q[l + 4 + i] ? q[l + 4 + i] + k + 2: 0);
 725         }
 726     }
 727   for (q = D_kmaps; q < p; q += 2 * l + 4)
 728     {
 729       l = q[2];
 730       for (m = j = 0; j < l; j++)
 731         {
 732           mo = m;
 733           if (!m && q[3 + j] != seq[j])
 734             m = 1;
 735           if (q[l + 4 + j] == 0)
 736             {
 737               if (!mo && m)
 738                 setseqoff(q, j, (p - q - 4) / 2);
 739             }
 740           else if (q + q[l + 4 + j] * 2 + 4 > p || (q + q[l + 4 + j] * 2 + 4 == p && !m))
 741             setseqoff(q, j, q[l + 4 + j] + k + 2);
 742         }
 743     }
 744 #ifdef DEBUGG
 745   dumpmap();
 746 #endif
 747   return 0;
 748 }
 749
 750 static int
 751 remmapseq(seq, k)
 752 char *seq;
 753 int k;
 754 {
 755   int j, l;
 756   unsigned char *p, *q;
 757
 758   if (k >= 254 || (j = findseq_ge(seq, k, &p)) != 0)
 759     return -1;
 760   for (q = D_kmaps; q < p; q += 2 * l + 4)
 761     {
 762       l = q[2];
 763       for (j = 0; j < l; j++)
 764         {
 765           if (q + q[l + 4 + j] * 2 + 4 == p)
 766             setseqoff(q, j, p[k + 4 + j] ? q[l + 4 + j] + p[k + 4 + j] - k : 0);
 767           else if (q + q[l + 4 + j] * 2 + 4 > p)
 768             q[l + 4 + j] -= k + 2;
 769         }
 770     }
 771   if (D_kmaps + D_nseqs > p + 2 * k + 4)
 772     bcopy((char *)p + 2 * k + 4, (char *)p, (D_kmaps + D_nseqs) - (p + 2 * k + 4));
 773   D_nseqs -= 2 * k + 4;
 774   D_seqp = D_kmaps + 3;
 775   D_seql = 0;
 776   D_seqh = 0;
 777   evdeq(&D_mapev);
 778 #ifdef DEBUGG
 779   dumpmap();
 780 #endif
 781   return 0;
 782 }
 783
 784 #ifdef DEBUGG
 785 static void
 786 dumpmap()
 787 {
 788   unsigned char *p;
 789   int j, n, l, o, oo;
 790   debug("Mappings:\n");
 791   p = D_kmaps;
 792   if (!p)
 793     return;
 794   while (p < D_kmaps + D_nseqs)
 795     {
 796       l = p[2];
 797       debug1("%d: ", p - D_kmaps + 3);
 798       for (j = 0; j < l; j++)
 799         {
 800           o = oo = p[l + 4 + j];
 801           if (o)
 802             o = 2 * o + 4 + (p + 3 + j - D_kmaps);
 803           if (p[j + 3] > ' ' && p[j + 3] < 0177)
 804             {
 805               debug3("%c[%d:%d] ", p[j + 3], oo, o);
 806             }
 807           else
 808             debug3("\\%03o[%d:%d] ", p[j + 3], oo, o);
 809         }
 810       n = p[0] << 8 | p[1];
 811       debug2(" ==> %d%s\n", n & ~KMAP_NOTIMEOUT, (n & KMAP_NOTIMEOUT) ? " (no timeout)" : "");
 812       p += 2 * l + 4;
 813     }
 814 }
 815 #endif /* DEBUGG */
 816
 817 #endif /* MAPKEYS */
 818
 819 /*
 820  * Appends to the static variable Termcap
 821  */
 822 static void
 823 AddCap(s)
 824 char *s;
 825 {
 826   register int n;
 827
 828   if (tcLineLen + (n = strlen(s)) > 55 && Termcaplen < TERMCAP_BUFSIZE - 4 - 1)
 829     {
 830       strcpy(Termcap + Termcaplen, "\\\n\t:");
 831       Termcaplen += 4;
 832       tcLineLen = 0;
 833     }
 834   if (Termcaplen + n < TERMCAP_BUFSIZE - 1)
 835     {
 836       strcpy(Termcap + Termcaplen, s);
 837       Termcaplen += n;
 838       tcLineLen += n;
 839     }
 840   else
 841     Panic(0, "TERMCAP overflow - sorry.");
 842 }
 843
 844 /*
 845  * Reads a displays capabilities and reconstructs a termcap entry in the
 846  * global buffer "Termcap". A pointer to this buffer is returned.
 847  */
 848 char *
 849 MakeTermcap(aflag)
 850 int aflag;
 851 {
 852   char buf[TERMCAP_BUFSIZE];
 853   register char *p, *cp, *s, ch, *tname;
 854   int i, wi, he;
 855 #if 0
 856   int found;
 857 #endif
 858
 859   if (display)
 860     {
 861       wi = D_width;
 862       he = D_height;
 863       tname = D_termname;
 864     }
 865   else
 866     {
 867       wi = 80;
 868       he = 24;
 869       tname = "vt100";
 870     }
 871   debug1("MakeTermcap(%d)\n", aflag);
 872   if ((s = getenv("SCREENCAP")) && strlen(s) < TERMCAP_BUFSIZE)
 873     {
 874       sprintf(Termcap, "TERMCAP=%s", s);
 875       strcpy(Term, "TERM=screen");
 876       debug("getenvSCREENCAP o.k.\n");
 877       return Termcap;
 878     }
 879   Termcaplen = 0;
 880   debug1("MakeTermcap screenterm='%s'\n", screenterm);
 881   debug1("MakeTermcap termname='%s'\n", tname);
 882   if (*screenterm == '\0' || strlen(screenterm) > MAXSTR - 3)
 883     {
 884       debug("MakeTermcap sets screenterm=screen\n");
 885       strcpy(screenterm, "screen");
 886     }
 887 #if 0
 888   found = 1;
 889 #endif
 890   do
 891     {
 892       strcpy(Term, "TERM=");
 893       p = Term + 5;
 894       if (!aflag && strlen(screenterm) + strlen(tname) < MAXSTR-1)
 895         {
 896           sprintf(p, "%s.%s", screenterm, tname);
 897           if (e_tgetent(buf, p) == 1)
 898             break;
 899         }
 900 #ifdef COLOR
 901       if (nwin_default.bce)
 902         {
 903           sprintf(p, "%s-bce", screenterm);
 904           if (e_tgetent(buf, p) == 1)
 905             break;
 906         }
 907 #endif
 908 #ifdef CHECK_SCREEN_W
 909       if (wi >= 132)
 910         {
 911           sprintf(p, "%s-w", screenterm);
 912           if (e_tgetent(buf, p) == 1)
 913             break;
 914         }
 915 #endif
 916       strcpy(p, screenterm);
 917       if (e_tgetent(buf, p) == 1)
 918         break;
 919       strcpy(p, "vt100");
 920 #if 0
 921       found = 0;
 922 #endif
 923     }
 924   while (0);            /* Goto free programming... */
 925
 926 #if 0
 927 #ifndef TERMINFO
 928   /* check for compatibility problems, displays == 0 after fork */
 929   if (found)
 930     {
 931       char xbuf[TERMCAP_BUFSIZE], *xbp = xbuf;
 932       if (tgetstr("im", &xbp) && tgetstr("ic", &xbp) && displays)
 933         {
 934           Msg(0, "Warning: im and ic set in %s termcap entry", p);
 935         }
 936     }
 937 #endif
 938 #endif
 939
 940   tcLineLen = 100;      /* Force NL */
 941   if (strlen(Term) > TERMCAP_BUFSIZE - 40)
 942     strcpy(Term, "too_long");
 943   sprintf(Termcap, "TERMCAP=SC|%s|VT 100/ANSI X3.64 virtual terminal:", Term + 5);
 944   Termcaplen = strlen(Termcap);
 945   debug1("MakeTermcap decided '%s'\n", p);
 946   if (extra_outcap && *extra_outcap)
 947     {
 948       for (cp = extra_outcap; (p = index(cp, ':')); cp = p)
 949         {
 950           ch = *++p;
 951           *p = '\0';
 952           AddCap(cp);
 953           *p = ch;
 954         }
 955       tcLineLen = 100;  /* Force NL */
 956     }
 957   debug1("MakeTermcap after outcap '%s'\n", (char *)TermcapConst);
 958   if (Termcaplen + strlen(TermcapConst) < TERMCAP_BUFSIZE)
 959     {
 960       strcpy(Termcap + Termcaplen, (char *)TermcapConst);
 961       Termcaplen += strlen(TermcapConst);
 962     }
 963   sprintf(buf, "li#%d:co#%d:", he, wi);
 964   AddCap(buf);
 965   AddCap("am:");
 966   if (aflag || (force_vt && !D_COP) || D_CLP || !D_AM)
 967     {
 968       AddCap("xn:");
 969       AddCap("xv:");
 970       AddCap("LP:");
 971     }
 972   if (aflag || (D_CS && D_SR) || D_AL || D_CAL)
 973     {
 974       AddCap("sr=\\EM:");
 975       AddCap("al=\\E[L:");
 976       AddCap("AL=\\E[%dL:");
 977     }
 978   else if (D_SR)
 979     AddCap("sr=\\EM:");
 980   if (aflag || D_CS)
 981     AddCap("cs=\\E[%i%d;%dr:");
 982   if (aflag || D_CS || D_DL || D_CDL)
 983     {
 984       AddCap("dl=\\E[M:");
 985       AddCap("DL=\\E[%dM:");
 986     }
 987   if (aflag || D_DC || D_CDC)
 988     {
 989       AddCap("dc=\\E[P:");
 990       AddCap("DC=\\E[%dP:");
 991     }
 992   if (aflag || D_CIC || D_IC || D_IM)
 993     {
 994       AddCap("im=\\E[4h:");
 995       AddCap("ei=\\E[4l:");
 996       AddCap("mi:");
 997       AddCap("IC=\\E[%d@:");
 998     }
 999 #ifdef MAPKEYS
1000   AddCap("ks=\\E[?1h\\E=:");
1001   AddCap("ke=\\E[?1l\\E>:");
1002 #endif
1003   AddCap("vi=\\E[?25l:");
1004   AddCap("ve=\\E[34h\\E[?25h:");
1005   AddCap("vs=\\E[34l:");
1006   AddCap("ti=\\E[?1049h:");
1007   AddCap("te=\\E[?1049l:");
1008   if (display)
1009     {
1010       if (D_US)
1011         {
1012           AddCap("us=\\E[4m:");
1013           AddCap("ue=\\E[24m:");
1014         }
1015       if (D_SO)
1016         {
1017           AddCap("so=\\E[3m:");
1018           AddCap("se=\\E[23m:");
1019         }
1020       if (D_MB)
1021         AddCap("mb=\\E[5m:");
1022       if (D_MD)
1023         AddCap("md=\\E[1m:");
1024       if (D_MH)
1025         AddCap("mh=\\E[2m:");
1026       if (D_MR)
1027         AddCap("mr=\\E[7m:");
1028       if (D_MB || D_MD || D_MH || D_MR)
1029         AddCap("me=\\E[m:ms:");
1030       if (D_hascolor)
1031         AddCap("Co#8:pa#64:AF=\\E[3%dm:AB=\\E[4%dm:op=\\E[39;49m:AX:");
1032       if (D_VB)
1033         AddCap("vb=\\Eg:");
1034 #ifndef MAPKEYS
1035       if (D_KS)
1036         {
1037           AddCap("ks=\\E=:");
1038           AddCap("ke=\\E>:");
1039         }
1040       if (D_CCS)
1041         {
1042           AddCap("CS=\\E[?1h:");
1043           AddCap("CE=\\E[?1l:");
1044         }
1045 #endif
1046       if (D_CG0)
1047         AddCap("G0:");
1048       if (D_CC0 || (D_CS0 && *D_CS0))
1049         {
1050           AddCap("as=\\E(0:");
1051           AddCap("ae=\\E(B:");
1052           /* avoid `` because some shells dump core... */
1053           AddCap("ac=\\140\\140aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~..--++,,hhII00:");
1054         }
1055       if (D_PO)
1056         {
1057           AddCap("po=\\E[5i:");
1058           AddCap("pf=\\E[4i:");
1059         }
1060       if (D_CZ0)
1061         {
1062           AddCap("Z0=\\E[?3h:");
1063           AddCap("Z1=\\E[?3l:");
1064         }
1065       if (D_CWS)
1066         AddCap("WS=\\E[8;%d;%dt:");
1067     }
1068   for (i = T_CAPS; i < T_ECAPS; i++)
1069     {
1070 #ifdef MAPKEYS
1071       struct action *act;
1072       if (i < T_OCAPS)
1073         {
1074           if (i >= T_KEYPAD)    /* don't put keypad codes in TERMCAP */
1075             continue;           /* - makes it too big */
1076           if (i >= T_CURSOR && i < T_OCAPS)
1077             {
1078               act = &umtab[i - (T_CURSOR - T_OCAPS + T_CAPS)];
1079               if (act->nr == RC_ILLEGAL)
1080                 act = &dmtab[i - (T_CURSOR - T_OCAPS + T_CAPS)];
1081             }
1082           else
1083             {
1084               act = &umtab[i - T_CAPS];
1085               if (act->nr == RC_ILLEGAL)
1086                 act = &dmtab[i - T_CAPS];
1087             }
1088           if (act->nr == RC_ILLEGAL && (i == T_NAVIGATE + 1 || i == T_NAVIGATE + 3))
1089             {
1090               /* kh -> @1, kH -> @7 */
1091               act = &umtab[i - T_CAPS - 1];
1092               if (act->nr == RC_ILLEGAL)
1093                 act = &dmtab[i - T_CAPS - 1];
1094             }
1095           if (act->nr != RC_ILLEGAL)
1096             {
1097               if (act->nr == RC_STUFF)
1098                 {
1099                   MakeString(term[i].tcname, buf, sizeof(buf), act->args[0]);
1100                   AddCap(buf);
1101                 }
1102               continue;
1103             }
1104         }
1105 #endif
1106       if (display == 0)
1107         continue;
1108       switch(term[i].type)
1109         {
1110         case T_STR:
1111           if (D_tcs[i].str == 0)
1112             break;
1113           MakeString(term[i].tcname, buf, sizeof(buf), D_tcs[i].str);
1114           AddCap(buf);
1115           break;
1116         case T_FLG:
1117           if (D_tcs[i].flg == 0)
1118             break;
1119           sprintf(buf, "%s:", term[i].tcname);
1120           AddCap(buf);
1121           break;
1122         default:
1123           break;
1124         }
1125     }
1126   debug("MakeTermcap: end\n");
1127   return Termcap;
1128 }
1129
1130 static void
1131 MakeString(cap, buf, buflen, s)
1132 char *cap, *buf;
1133 int buflen;
1134 char *s;
1135 {
1136   register char *p, *pmax;
1137   register unsigned int c;
1138
1139   p = buf;
1140   pmax = p + buflen - (3+4+2);
1141   *p++ = *cap++;
1142   *p++ = *cap;
1143   *p++ = '=';
1144   while ((c = *s++) && (p < pmax))
1145     {
1146       switch (c)
1147         {
1148         case '\033':
1149           *p++ = '\\';
1150           *p++ = 'E';
1151           break;
1152         case ':':
1153           strcpy(p, "\\072");
1154           p += 4;
1155           break;
1156         case '^':
1157         case '\\':
1158           *p++ = '\\';
1159           *p++ = c;
1160           break;
1161         default:
1162           if (c >= 200)
1163             {
1164               sprintf(p, "\\%03o", c & 0377);
1165               p += 4;
1166             }
1167           else if (c < ' ')
1168             {
1169               *p++ = '^';
1170               *p++ = c + '@';
1171             }
1172           else
1173             *p++ = c;
1174         }
1175     }
1176   *p++ = ':';
1177   *p = '\0';
1178 }
1179
1180
1181 #undef QUOTES
1182 #define QUOTES(p) \
1183   (*p == '\\' && (p[1] == '\\' || p[1] == ',' || p[1] == '%'))
1184
1185 #ifdef FONT
1186 int
1187 CreateTransTable(s)
1188 char *s;
1189 {
1190   int curchar;
1191   char *templ, *arg;
1192   int templlen;
1193   int templnsub;
1194   char *p, *sx;
1195   char **ctable;
1196   int l, c;
1197
1198   if ((D_xtable = (char ***)calloc(256, sizeof(char **))) == 0)
1199     {
1200       Msg(0, strnomem);
1201       return -1;
1202     }
1203
1204   while (*s)
1205     {
1206       if (QUOTES(s))
1207         s++;
1208       curchar = (unsigned char)*s++;
1209       if (curchar == 'B')
1210         curchar = 0;    /* ASCII */
1211       templ = s;
1212       templlen = 0;
1213       templnsub = 0;
1214       if (D_xtable[curchar] == 0)
1215         {
1216           if ((D_xtable[curchar] = (char **)calloc(257, sizeof(char *))) == 0)
1217             {
1218               Msg(0, strnomem);
1219               FreeTransTable();
1220               return -1;
1221             }
1222         }
1223       ctable = D_xtable[curchar];
1224       for(; *s && *s != ','; s++)
1225         {
1226           if (QUOTES(s))
1227               s++;
1228           else if (*s == '%')
1229             {
1230               templnsub++;
1231               continue;
1232             }
1233           templlen++;
1234         }
1235       if (*s++ == 0)
1236         break;
1237       while (*s && *s != ',')
1238         {
1239           c = (unsigned char)*s++;
1240           if (QUOTES((s - 1)))
1241             c = (unsigned char)*s++;
1242           else if (c == '%')
1243             c = 256;
1244           if (ctable[c])
1245             free(ctable[c]);
1246           arg = s;
1247           l = copyarg(&s, (char *)0);
1248           if (c != 256)
1249             l = l * templnsub + templlen;
1250           if ((ctable[c] = (char *)malloc(l + 1)) == 0)
1251             {
1252               Msg(0, strnomem);
1253               FreeTransTable();
1254               return -1;
1255             }
1256           sx = ctable[c];
1257           for (p = ((c == 256) ? "%" : templ); *p && *p != ','; p++)
1258             {
1259               if (QUOTES(p))
1260                 p++;
1261               else if (*p == '%')
1262                 {
1263                   s = arg;
1264                   sx += copyarg(&s, sx);
1265                   continue;
1266                 }
1267               *sx++ = *p;
1268             }
1269           *sx = 0;
1270           ASSERT(ctable[c] + l * templnsub + templlen == sx);
1271           debug3("XC: %c %c->%s\n", curchar, c, ctable[c]);
1272         }
1273       if (*s == ',')
1274         s++;
1275     }
1276   return 0;
1277 }
1278
1279 void
1280 FreeTransTable()
1281 {
1282   char ***p, **q;
1283   int i, j;
1284
1285   if ((p = D_xtable) == 0)
1286     return;
1287   for (i = 0; i < 256; i++, p++)
1288     {
1289       if (*p == 0)
1290         continue;
1291       q = *p;
1292       for (j = 0; j < 257; j++, q++)
1293         if (*q)
1294           free(*q);
1295       free(*p);
1296     }
1297   free(D_xtable);
1298 }
1299 #endif /* FONT */
1300
1301 static int
1302 copyarg(pp, s)
1303 char **pp, *s;
1304 {
1305   int l;
1306   char *p;
1307
1308   for (l = 0, p = *pp; *p && *p != ','; p++)
1309     {
1310       if (QUOTES(p))
1311         p++;
1312       if (s)
1313         *s++ = *p;
1314       l++;
1315     }
1316   if (*p == ',')
1317     p++;
1318   *pp = p;
1319   return l;
1320 }
1321
1322
1323 /*
1324 **
1325 **  Termcap routines that use our extra_incap
1326 **
1327 */
1328
1329 static int
1330 e_tgetent(bp, name)
1331 char *bp, *name;
1332 {
1333   int r;
1334
1335 #ifdef USE_SETEUID
1336   xseteuid(real_uid);
1337   xsetegid(real_gid);
1338 #endif
1339   r = tgetent(bp, name);
1340 #ifdef USE_SETEUID
1341   xseteuid(eff_uid);
1342   xsetegid(eff_gid);
1343 #endif
1344   return r;
1345 }
1346
1347
1348 /* findcap:
1349  *   cap = capability we are looking for
1350  *   tepp = pointer to bufferpointer
1351  *   n = size of buffer (0 = infinity)
1352  */
1353
1354 static char *
1355 findcap(cap, tepp, n)
1356 char *cap;
1357 char **tepp;
1358 int n;
1359 {
1360   char *tep;
1361   char c, *p, *cp;
1362   int mode;     /* mode: 0=LIT  1=^  2=\x  3,4,5=\nnn */
1363   int num = 0, capl;
1364
1365   if (!extra_incap)
1366     return 0;
1367   tep = *tepp;
1368   capl = strlen(cap);
1369   cp = 0;
1370   mode = 0;
1371   for (p = extra_incap; *p; )
1372     {
1373       if (strncmp(p, cap, capl) == 0)
1374         {
1375           p += capl;
1376           c = *p;
1377           if (c && c != ':' && c != '@')
1378             p++;
1379           if (c == 0 || c == '@' || c == '=' || c == ':' || c == '#')
1380             cp = tep;
1381         }
1382       while ((c = *p))
1383         {
1384           p++;
1385           if (mode == 0)
1386             {
1387               if (c == ':')
1388                 break;
1389               if (c == '^')
1390                 mode = 1;
1391               if (c == '\\')
1392                 mode = 2;
1393             }
1394           else if (mode == 1)
1395             {
1396               mode = 0;
1397               c = c & 0x1f;
1398             }
1399           else if (mode == 2)
1400             {
1401               mode = 0;
1402               switch(c)
1403                 {
1404                 case '0':
1405                 case '1':
1406                 case '2':
1407                 case '3':
1408                 case '4':
1409                 case '5':
1410                 case '6':
1411                 case '7':
1412                 case '8':
1413                 case '9':
1414                   mode = 3;
1415                   num = 0;
1416                   break;
1417                 case 'E':
1418                   c = 27;
1419                   break;
1420                 case 'n':
1421                   c = '\n';
1422                   break;
1423                 case 'r':
1424                   c = '\r';
1425                   break;
1426                 case 't':
1427                   c = '\t';
1428                   break;
1429                 case 'b':
1430                   c = '\b';
1431                   break;
1432                 case 'f':
1433                   c = '\f';
1434                   break;
1435                 }
1436             }
1437           if (mode > 2)
1438             {
1439               num = num * 8 + (c - '0');
1440               if (mode++ == 5 || (*p < '0' || *p > '9'))
1441                 {
1442                   c = num;
1443                   mode = 0;
1444                 }
1445             }
1446           if (mode)
1447             continue;
1448
1449           if (cp && n != 1)
1450             {
1451               *cp++ = c;
1452               n--;
1453             }
1454         }
1455       if (cp)
1456         {
1457           *cp++ = 0;
1458           *tepp = cp;
1459           debug2("'%s' found in extra_incap -> %s\n", cap, tep);
1460           return tep;
1461         }
1462     }
1463   return 0;
1464 }
1465
1466 static char *
1467 e_tgetstr(cap, tepp)
1468 char *cap;
1469 char **tepp;
1470 {
1471   char *tep;
1472   if ((tep = findcap(cap, tepp, 0)))
1473     return (*tep == '@') ? 0 : tep;
1474   return tgetstr(cap, tepp);
1475 }
1476
1477 static int
1478 e_tgetflag(cap)
1479 char *cap;
1480 {
1481   char buf[2], *bufp;
1482   char *tep;
1483   bufp = buf;
1484   if ((tep = findcap(cap, &bufp, 2)))
1485     return (*tep == '@') ? 0 : 1;
1486   return tgetflag(cap) > 0;
1487 }
1488
1489 static int
1490 e_tgetnum(cap)
1491 char *cap;
1492 {
1493   char buf[20], *bufp;
1494   char *tep, c;
1495   int res, base = 10;
1496
1497   bufp = buf;
1498   if ((tep = findcap(cap, &bufp, 20)))
1499     {
1500       c = *tep;
1501       if (c == '@')
1502         return -1;
1503       if (c == '0')
1504         base = 8;
1505       res = 0;
1506       while ((c = *tep++) >= '0' && c <= '9')
1507         res = res * base + (c - '0');
1508       return res;
1509     }
1510   return tgetnum(cap);
1511 }
1512