src/termcap.c

   1 /* Work-alike for termcap, plus extra features.
   2    Copyright (C) 1985-1986, 1993-1995, 2000-2008, 2011, 2013 Free
   3    Software Foundation, Inc.
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 /* Emacs config.h may rename various library functions such as malloc.  */
  19 #include <config.h>
  20 #include <sys/file.h>
  21 #include <fcntl.h>
  22 #include <unistd.h>
  23
  24 #include "lisp.h"
  25 #include "tparam.h"
  26 #ifdef MSDOS
  27 #include "msdos.h"
  28 #endif
  29
  30 /* BUFSIZE is the initial size allocated for the buffer
  31    for reading the termcap file.
  32    It is not a limit.
  33    Make it large normally for speed.
  34    Make it variable when debugging, so can exercise
  35    increasing the space dynamically.  */
  36
  37 #ifndef BUFSIZE
  38 #ifdef DEBUG
  39 #define BUFSIZE bufsize
  40
  41 int bufsize = 128;
  42 #else
  43 #define BUFSIZE 2048
  44 #endif
  45 #endif
  46
  47 #ifndef TERMCAP_FILE
  48 #define TERMCAP_FILE "/etc/termcap"
  49 #endif
  50
  51 \f
  52 /* Looking up capabilities in the entry already found.  */
  53
  54 /* The pointer to the data made by tgetent is left here
  55    for tgetnum, tgetflag and tgetstr to find.  */
  56 static char *term_entry;
  57
  58 static char *tgetst1 (char *ptr, char **area);
  59
  60 /* Search entry BP for capability CAP.
  61    Return a pointer to the capability (in BP) if found,
  62    0 if not found.  */
  63
  64 static char *
  65 find_capability (register char *bp, register const char *cap)
  66 {
  67   for (; *bp; bp++)
  68     if (bp[0] == ':'
  69         && bp[1] == cap[0]
  70         && bp[2] == cap[1])
  71       return &bp[4];
  72   return NULL;
  73 }
  74
  75 int
  76 tgetnum (const char *cap)
  77 {
  78   register char *ptr = find_capability (term_entry, cap);
  79   if (!ptr || ptr[-1] != '#')
  80     return -1;
  81   return atoi (ptr);
  82 }
  83
  84 int
  85 tgetflag (const char *cap)
  86 {
  87   register char *ptr = find_capability (term_entry, cap);
  88   return ptr && ptr[-1] == ':';
  89 }
  90
  91 /* Look up a string-valued capability CAP.
  92    If AREA is non-null, it points to a pointer to a block in which
  93    to store the string.  That pointer is advanced over the space used.
  94    If AREA is null, space is allocated with `malloc'.  */
  95
  96 char *
  97 tgetstr (const char *cap, char **area)
  98 {
  99   register char *ptr = find_capability (term_entry, cap);
 100   if (!ptr || (ptr[-1] != '=' && ptr[-1] != '~'))
 101     return NULL;
 102   return tgetst1 (ptr, area);
 103 }
 104
 105 #ifdef IS_EBCDIC_HOST
 106 /* Table, indexed by a character in range 0200 to 0300 with 0200 subtracted,
 107    gives meaning of character following \, or a space if no special meaning.
 108    Sixteen characters per line within the string.  */
 109
 110 static const char esctab[]
 111   = " \057\026  \047\014         \
 112      \025   \015      \
 113    \005 \013          \
 114                 ";
 115 #else
 116 /* Table, indexed by a character in range 0100 to 0140 with 0100 subtracted,
 117    gives meaning of character following \, or a space if no special meaning.
 118    Eight characters per line within the string.  */
 119
 120 static const char esctab[]
 121   = " \007\010  \033\014 \
 122       \012 \
 123   \015 \011 \013 \
 124         ";
 125 #endif
 126
 127 /* PTR points to a string value inside a termcap entry.
 128    Copy that value, processing \ and ^ abbreviations,
 129    into the block that *AREA points to,
 130    or to newly allocated storage if AREA is NULL.
 131    Return the address to which we copied the value,
 132    or NULL if PTR is NULL.  */
 133
 134 static char *
 135 tgetst1 (char *ptr, char **area)
 136 {
 137   register char *p, *r;
 138   register int c;
 139   register int size;
 140   char *ret;
 141   register int c1;
 142
 143   if (!ptr)
 144     return NULL;
 145
 146   /* `ret' gets address of where to store the string.  */
 147   if (!area)
 148     {
 149       /* Compute size of block needed (may overestimate).  */
 150       p = ptr;
 151       while ((c = *p++) && c != ':' && c != '\n')
 152         ;
 153       ret = xmalloc (p - ptr + 1);
 154     }
 155   else
 156     ret = *area;
 157
 158   /* Copy the string value, stopping at null or colon.
 159      Also process ^ and \ abbreviations.  */
 160   p = ptr;
 161   r = ret;
 162   while ((c = *p++) && c != ':' && c != '\n')
 163     {
 164       if (c == '^')
 165         {
 166           c = *p++;
 167           if (c == '?')
 168             c = 0177;
 169           else
 170             c &= 037;
 171         }
 172       else if (c == '\\')
 173         {
 174           c = *p++;
 175           if (c >= '0' && c <= '7')
 176             {
 177               c -= '0';
 178               size = 0;
 179
 180               while (++size < 3 && (c1 = *p) >= '0' && c1 <= '7')
 181                 {
 182                   c *= 8;
 183                   c += c1 - '0';
 184                   p++;
 185                 }
 186             }
 187 #ifdef IS_EBCDIC_HOST
 188           else if (c >= 0200 && c < 0360)
 189             {
 190               c1 = esctab[(c & ~0100) - 0200];
 191               if (c1 != ' ')
 192                 c = c1;
 193             }
 194 #else
 195           else if (c >= 0100 && c < 0200)
 196             {
 197               c1 = esctab[(c & ~040) - 0100];
 198               if (c1 != ' ')
 199                 c = c1;
 200             }
 201 #endif
 202         }
 203       *r++ = c;
 204     }
 205
 206   /* Sometimes entries have "%pN" which means use parameter N in the
 207      next %-substitution.  If all such N are continuous in the range
 208      [1,9] we can remove each "%pN" because they are redundant, thus
 209      reducing bandwidth requirements.  True, Emacs is well beyond the
 210      days of 150baud teletypes, but some of its users aren't much so.
 211
 212      This pass could probably be integrated into the one above but
 213      abbreviation expansion makes that effort a little more hairy than
 214      its worth; this is cleaner.  */
 215   {
 216     register int last_p_param = 0;
 217     int remove_p_params = 1;
 218     struct { char *beg; int len; } cut[11];
 219
 220     for (cut[0].beg = p = ret; p < r - 3; p++)
 221       {
 222         if (!remove_p_params)
 223           break;
 224         if (*p == '%' && *(p + 1) == 'p')
 225           {
 226             if (*(p + 2) - '0' == 1 + last_p_param)
 227               {
 228                 cut[last_p_param].len = p - cut[last_p_param].beg;
 229                 last_p_param++;
 230                 p += 3;
 231                 cut[last_p_param].beg = p;
 232               }
 233             else                                /* not continuous: bail */
 234               remove_p_params = 0;
 235             if (last_p_param > 10)              /* too many: bail */
 236               remove_p_params = 0;
 237           }
 238       }
 239     if (remove_p_params && last_p_param)
 240       {
 241         register int i;
 242         char *wp;
 243
 244         cut[last_p_param].len = r - cut[last_p_param].beg;
 245         for (i = 0, wp = ret; i <= last_p_param; wp += cut[i++].len)
 246           memcpy (wp, cut[i].beg, cut[i].len);
 247         r = wp;
 248       }
 249   }
 250
 251   *r = '\0';
 252   /* Update *AREA.  */
 253   if (area)
 254     *area = r + 1;
 255   return ret;
 256 }
 257 \f
 258 /* Outputting a string with padding.  */
 259
 260 char PC;
 261
 262 void
 263 tputs (register const char *str, int nlines, int (*outfun) (int))
 264 {
 265   register int padcount = 0;
 266   register int speed;
 267
 268   speed = baud_rate;
 269   /* For quite high speeds, convert to the smaller
 270      units to avoid overflow.  */
 271   if (speed > 10000)
 272     speed = - speed / 100;
 273
 274   if (!str)
 275     return;
 276
 277   while (*str >= '0' && *str <= '9')
 278     {
 279       padcount += *str++ - '0';
 280       padcount *= 10;
 281     }
 282   if (*str == '.')
 283     {
 284       str++;
 285       padcount += *str++ - '0';
 286     }
 287   if (*str == '*')
 288     {
 289       str++;
 290       padcount *= nlines;
 291     }
 292   while (*str)
 293     (*outfun) (*str++);
 294
 295   /* PADCOUNT is now in units of tenths of msec.
 296      SPEED is measured in characters per 10 seconds
 297      or in characters per .1 seconds (if negative).
 298      We use the smaller units for larger speeds to avoid overflow.  */
 299   padcount *= speed;
 300   padcount += 500;
 301   padcount /= 1000;
 302   if (speed < 0)
 303     padcount = -padcount;
 304   else
 305     {
 306       padcount += 50;
 307       padcount /= 100;
 308     }
 309
 310   while (padcount-- > 0)
 311     (*outfun) (PC);
 312 }
 313 \f
 314 /* Finding the termcap entry in the termcap data base.  */
 315
 316 struct termcap_buffer
 317   {
 318     char *beg;
 319     ptrdiff_t size;
 320     char *ptr;
 321     int ateof;
 322     ptrdiff_t full;
 323   };
 324
 325 /* Forward declarations of static functions.  */
 326
 327 static int scan_file (char *str, int fd, register struct termcap_buffer *bufp);
 328 static char *gobble_line (int fd, register struct termcap_buffer *bufp, char *append_end);
 329 static int compare_contin (register char *str1, register char *str2);
 330 static int name_match (char *line, char *name);
 331
 332 #ifdef MSDOS /* MW, May 1993 */
 333 static int
 334 valid_filename_p (char *fn)
 335 {
 336   return *fn == '/' || fn[1] == ':';
 337 }
 338 #else
 339 #define valid_filename_p(fn) (*(fn) == '/')
 340 #endif
 341
 342 /* Find the termcap entry data for terminal type NAME
 343    and store it in the block that BP points to.
 344    Record its address for future use.
 345
 346    If BP is null, space is dynamically allocated.
 347
 348    Return -1 if there is some difficulty accessing the data base
 349    of terminal types,
 350    0 if the data base is accessible but the type NAME is not defined
 351    in it, and some other value otherwise.  */
 352
 353 int
 354 tgetent (char *bp, const char *name)
 355 {
 356   register char *termcap_name;
 357   register int fd;
 358   struct termcap_buffer buf;
 359   register char *bp1;
 360   char *tc_search_point;
 361   char *term;
 362   ptrdiff_t malloc_size = 0;
 363   register int c;
 364   char *tcenv = NULL;           /* TERMCAP value, if it contains :tc=.  */
 365   char *indirect = NULL;        /* Terminal type in :tc= in TERMCAP value.  */
 366   int filep;
 367
 368 #ifdef INTERNAL_TERMINAL
 369   /* For the internal terminal we don't want to read any termcap file,
 370      so fake it.  */
 371   if (!strcmp (name, "internal"))
 372     {
 373       term = INTERNAL_TERMINAL;
 374       if (!bp)
 375         {
 376           malloc_size = 1 + strlen (term);
 377           bp = xmalloc (malloc_size);
 378         }
 379       strcpy (bp, term);
 380       goto ret;
 381     }
 382 #endif /* INTERNAL_TERMINAL */
 383
 384   /* For compatibility with programs like `less' that want to
 385      put data in the termcap buffer themselves as a fallback.  */
 386   if (bp)
 387     term_entry = bp;
 388
 389   termcap_name = getenv ("TERMCAP");
 390   if (termcap_name && *termcap_name == '\0')
 391     termcap_name = NULL;
 392 #if defined (MSDOS) && !defined (TEST)
 393   if (termcap_name && (*termcap_name == '\\'
 394                        || *termcap_name == '/'
 395                        || termcap_name[1] == ':'))
 396     dostounix_filename (termcap_name, 0);
 397 #endif
 398
 399   filep = termcap_name && valid_filename_p (termcap_name);
 400
 401   /* If termcap_name is non-null and starts with / (in the un*x case, that is),
 402      it is a file name to use instead of /etc/termcap.
 403      If it is non-null and does not start with /,
 404      it is the entry itself, but only if
 405      the name the caller requested matches the TERM variable.  */
 406
 407   if (termcap_name && !filep && !strcmp (name, getenv ("TERM")))
 408     {
 409       indirect = tgetst1 (find_capability (termcap_name, "tc"), (char **) 0);
 410       if (!indirect)
 411         {
 412           if (!bp)
 413             bp = termcap_name;
 414           else
 415             strcpy (bp, termcap_name);
 416           goto ret;
 417         }
 418       else
 419         {                       /* It has tc=.  Need to read /etc/termcap.  */
 420           tcenv = termcap_name;
 421           termcap_name = NULL;
 422         }
 423     }
 424
 425   if (!termcap_name || !filep)
 426     termcap_name = TERMCAP_FILE;
 427
 428   /* Here we know we must search a file and termcap_name has its name.  */
 429
 430 #ifdef MSDOS
 431   fd = open (termcap_name, O_RDONLY|O_TEXT, 0);
 432 #else
 433   fd = open (termcap_name, O_RDONLY, 0);
 434 #endif
 435   if (fd < 0)
 436     return -1;
 437
 438   buf.size = BUFSIZE;
 439   /* Add 1 to size to ensure room for terminating null.  */
 440   buf.beg = xmalloc (buf.size + 1);
 441   term = indirect ? indirect : (char *)name;
 442
 443   if (!bp)
 444     {
 445       malloc_size = indirect ? strlen (tcenv) + 1 : buf.size;
 446       bp = xmalloc (malloc_size);
 447     }
 448   tc_search_point = bp1 = bp;
 449
 450   if (indirect)
 451     /* Copy the data from the environment variable.  */
 452     {
 453       strcpy (bp, tcenv);
 454       bp1 += strlen (tcenv);
 455     }
 456
 457   while (term)
 458     {
 459       /* Scan the file, reading it via buf, till find start of main entry.  */
 460       if (scan_file (term, fd, &buf) == 0)
 461         {
 462           close (fd);
 463           xfree (buf.beg);
 464           if (malloc_size)
 465             xfree (bp);
 466           return 0;
 467         }
 468
 469       /* Free old `term' if appropriate.  */
 470       if (term != name)
 471         xfree (term);
 472
 473       /* If BP is malloc'd by us, make sure it is big enough.  */
 474       if (malloc_size)
 475         {
 476           ptrdiff_t offset1 = bp1 - bp, offset2 = tc_search_point - bp;
 477           malloc_size = offset1 + buf.size;
 478           bp = termcap_name = xrealloc (bp, malloc_size);
 479           bp1 = termcap_name + offset1;
 480           tc_search_point = termcap_name + offset2;
 481         }
 482
 483       /* Copy the line of the entry from buf into bp.  */
 484       termcap_name = buf.ptr;
 485       while ((*bp1++ = c = *termcap_name++) && c != '\n')
 486         /* Drop out any \ newline sequence.  */
 487         if (c == '\\' && *termcap_name == '\n')
 488           {
 489             bp1--;
 490             termcap_name++;
 491           }
 492       *bp1 = '\0';
 493
 494       /* Does this entry refer to another terminal type's entry?
 495          If something is found, copy it into heap and null-terminate it.  */
 496       tc_search_point = find_capability (tc_search_point, "tc");
 497       term = tgetst1 (tc_search_point, (char **) 0);
 498     }
 499
 500   close (fd);
 501   xfree (buf.beg);
 502
 503   if (malloc_size)
 504     bp = xrealloc (bp, bp1 - bp + 1);
 505
 506  ret:
 507   term_entry = bp;
 508   return 1;
 509 }
 510
 511 /* Given file open on FD and buffer BUFP,
 512    scan the file from the beginning until a line is found
 513    that starts the entry for terminal type STR.
 514    Return 1 if successful, with that line in BUFP,
 515    or 0 if no entry is found in the file.  */
 516
 517 static int
 518 scan_file (char *str, int fd, register struct termcap_buffer *bufp)
 519 {
 520   register char *end;
 521
 522   bufp->ptr = bufp->beg;
 523   bufp->full = 0;
 524   bufp->ateof = 0;
 525   *bufp->ptr = '\0';
 526
 527   lseek (fd, 0L, 0);
 528
 529   while (!bufp->ateof)
 530     {
 531       /* Read a line into the buffer.  */
 532       end = NULL;
 533       do
 534         {
 535           /* if it is continued, append another line to it,
 536              until a non-continued line ends.  */
 537           end = gobble_line (fd, bufp, end);
 538         }
 539       while (!bufp->ateof && end[-2] == '\\');
 540
 541       if (*bufp->ptr != '#'
 542           && name_match (bufp->ptr, str))
 543         return 1;
 544
 545       /* Discard the line just processed.  */
 546       bufp->ptr = end;
 547     }
 548   return 0;
 549 }
 550
 551 /* Return nonzero if NAME is one of the names specified
 552    by termcap entry LINE.  */
 553
 554 static int
 555 name_match (char *line, char *name)
 556 {
 557   register char *tem;
 558
 559   if (!compare_contin (line, name))
 560     return 1;
 561   /* This line starts an entry.  Is it the right one?  */
 562   for (tem = line; *tem && *tem != '\n' && *tem != ':'; tem++)
 563     if (*tem == '|' && !compare_contin (tem + 1, name))
 564       return 1;
 565
 566   return 0;
 567 }
 568
 569 static int
 570 compare_contin (register char *str1, register char *str2)
 571 {
 572   register int c1, c2;
 573   while (1)
 574     {
 575       c1 = *str1++;
 576       c2 = *str2++;
 577       while (c1 == '\\' && *str1 == '\n')
 578         {
 579           str1++;
 580           while ((c1 = *str1++) == ' ' || c1 == '\t');
 581         }
 582       if (c2 == '\0')
 583         {
 584           /* End of type being looked up.  */
 585           if (c1 == '|' || c1 == ':')
 586             /* If end of name in data base, we win.  */
 587             return 0;
 588           else
 589             return 1;
 590         }
 591       else if (c1 != c2)
 592         return 1;
 593     }
 594 }
 595
 596 /* Make sure that the buffer <- BUFP contains a full line
 597    of the file open on FD, starting at the place BUFP->ptr
 598    points to.  Can read more of the file, discard stuff before
 599    BUFP->ptr, or make the buffer bigger.
 600
 601    Return the pointer to after the newline ending the line,
 602    or to the end of the file, if there is no newline to end it.
 603
 604    Can also merge on continuation lines.  If APPEND_END is
 605    non-null, it points past the newline of a line that is
 606    continued; we add another line onto it and regard the whole
 607    thing as one line.  The caller decides when a line is continued.  */
 608
 609 static char *
 610 gobble_line (int fd, register struct termcap_buffer *bufp, char *append_end)
 611 {
 612   register char *end;
 613   register int nread;
 614   register char *buf = bufp->beg;
 615
 616   if (!append_end)
 617     append_end = bufp->ptr;
 618
 619   while (1)
 620     {
 621       end = append_end;
 622       while (*end && *end != '\n') end++;
 623       if (*end)
 624         break;
 625       if (bufp->ateof)
 626         return buf + bufp->full;
 627       if (bufp->ptr == buf)
 628         {
 629           if (bufp->full == bufp->size)
 630             {
 631               ptrdiff_t ptr_offset = bufp->ptr - buf;
 632               ptrdiff_t append_end_offset = append_end - buf;
 633               /* Add 1 to size to ensure room for terminating null.  */
 634               ptrdiff_t size = bufp->size + 1;
 635               bufp->beg = buf = xpalloc (buf, &size, 1, -1, 1);
 636               bufp->size = size - 1;
 637               bufp->ptr = buf + ptr_offset;
 638               append_end = buf + append_end_offset;
 639             }
 640         }
 641       else
 642         {
 643           append_end -= bufp->ptr - buf;
 644           memcpy (buf, bufp->ptr, bufp->full -= bufp->ptr - buf);
 645           bufp->ptr = buf;
 646         }
 647       if (!(nread = read (fd, buf + bufp->full, bufp->size - bufp->full)))
 648         bufp->ateof = 1;
 649       bufp->full += nread;
 650       buf[bufp->full] = '\0';
 651     }
 652   return end + 1;
 653 }
 654 \f
 655 #ifdef TEST
 656
 657 #include <stdio.h>
 658
 659 static void
 660 tprint (char *cap)
 661 {
 662   char *x = tgetstr (cap, 0);
 663   register char *y;
 664
 665   printf ("%s: ", cap);
 666   if (x)
 667     {
 668       for (y = x; *y; y++)
 669         if (*y <= ' ' || *y == 0177)
 670           printf ("\\%0o", *y);
 671         else
 672           putchar (*y);
 673       free (x);
 674     }
 675   else
 676     printf ("none");
 677   putchar ('\n');
 678 }
 679
 680 int
 681 main (int argc, char **argv)
 682 {
 683   char *term;
 684   char *buf;
 685
 686   term = argv[1];
 687   printf ("TERM: %s\n", term);
 688
 689   buf = (char *) tgetent (0, term);
 690   if ((int) buf <= 0)
 691     {
 692       printf ("No entry.\n");
 693       return 0;
 694     }
 695
 696   printf ("Entry: %s\n", buf);
 697
 698   tprint ("cm");
 699   tprint ("AL");
 700
 701   printf ("co: %d\n", tgetnum ("co"));
 702   printf ("am: %d\n", tgetflag ("am"));
 703
 704   return 0;
 705 }
 706
 707 #endif /* TEST */