src/termcap.c

   1 /* Work-alike for termcap, plus extra features.
   2    Copyright (C) 1985, 86, 93, 94, 95, 2000, 2001
   3    Free 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; see the file COPYING.  If not, write to
  17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18 Boston, MA 02111-1307, USA.  */
  19
  20 /* Emacs config.h may rename various library functions such as malloc.  */
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #ifdef emacs
  26
  27 #include <lisp.h>               /* xmalloc is here */
  28 /* Get the O_* definitions for open et al.  */
  29 #include <sys/file.h>
  30 #ifdef HAVE_FCNTL_H
  31 #include <fcntl.h>
  32 #endif
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36
  37 #else /* not emacs */
  38
  39 #ifdef STDC_HEADERS
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #else
  43 char *getenv ();
  44 char *malloc ();
  45 char *realloc ();
  46 #endif
  47
  48 /* Do this after the include, in case string.h prototypes bcopy.  */
  49 #if (defined(HAVE_STRING_H) || defined(STDC_HEADERS)) && !defined(bcopy)
  50 #define bcopy(s, d, n) memcpy ((d), (s), (n))
  51 #endif
  52
  53 #ifdef HAVE_UNISTD_H
  54 #include <unistd.h>
  55 #endif
  56 #ifdef _POSIX_VERSION
  57 #include <fcntl.h>
  58 #endif
  59
  60 #endif /* not emacs */
  61
  62 #ifndef NULL
  63 #define NULL (char *) 0
  64 #endif
  65
  66 #ifndef O_RDONLY
  67 #define O_RDONLY 0
  68 #endif
  69
  70 /* BUFSIZE is the initial size allocated for the buffer
  71    for reading the termcap file.
  72    It is not a limit.
  73    Make it large normally for speed.
  74    Make it variable when debugging, so can exercise
  75    increasing the space dynamically.  */
  76
  77 #ifndef BUFSIZE
  78 #ifdef DEBUG
  79 #define BUFSIZE bufsize
  80
  81 int bufsize = 128;
  82 #else
  83 #define BUFSIZE 2048
  84 #endif
  85 #endif
  86
  87 #ifndef TERMCAP_FILE
  88 #define TERMCAP_FILE "/etc/termcap"
  89 #endif
  90
  91 #ifndef emacs
  92 static void
  93 memory_out ()
  94 {
  95   write (2, "virtual memory exhausted\n", 25);
  96   exit (1);
  97 }
  98
  99 static char *
 100 xmalloc (size)
 101      unsigned size;
 102 {
 103   register char *tem = malloc (size);
 104
 105   if (!tem)
 106     memory_out ();
 107   return tem;
 108 }
 109
 110 static char *
 111 xrealloc (ptr, size)
 112      char *ptr;
 113      unsigned size;
 114 {
 115   register char *tem = realloc (ptr, size);
 116
 117   if (!tem)
 118     memory_out ();
 119   return tem;
 120 }
 121 #endif /* not emacs */
 122 \f
 123 /* Looking up capabilities in the entry already found.  */
 124
 125 /* The pointer to the data made by tgetent is left here
 126    for tgetnum, tgetflag and tgetstr to find.  */
 127 static char *term_entry;
 128
 129 static char *tgetst1 ();
 130
 131 /* Search entry BP for capability CAP.
 132    Return a pointer to the capability (in BP) if found,
 133    0 if not found.  */
 134
 135 static char *
 136 find_capability (bp, cap)
 137      register char *bp, *cap;
 138 {
 139   for (; *bp; bp++)
 140     if (bp[0] == ':'
 141         && bp[1] == cap[0]
 142         && bp[2] == cap[1])
 143       return &bp[4];
 144   return NULL;
 145 }
 146
 147 int
 148 tgetnum (cap)
 149      char *cap;
 150 {
 151   register char *ptr = find_capability (term_entry, cap);
 152   if (!ptr || ptr[-1] != '#')
 153     return -1;
 154   return atoi (ptr);
 155 }
 156
 157 int
 158 tgetflag (cap)
 159      char *cap;
 160 {
 161   register char *ptr = find_capability (term_entry, cap);
 162   return ptr && ptr[-1] == ':';
 163 }
 164
 165 /* Look up a string-valued capability CAP.
 166    If AREA is non-null, it points to a pointer to a block in which
 167    to store the string.  That pointer is advanced over the space used.
 168    If AREA is null, space is allocated with `malloc'.  */
 169
 170 char *
 171 tgetstr (cap, area)
 172      char *cap;
 173      char **area;
 174 {
 175   register char *ptr = find_capability (term_entry, cap);
 176   if (!ptr || (ptr[-1] != '=' && ptr[-1] != '~'))
 177     return NULL;
 178   return tgetst1 (ptr, area);
 179 }
 180
 181 #ifdef IS_EBCDIC_HOST
 182 /* Table, indexed by a character in range 0200 to 0300 with 0200 subtracted,
 183    gives meaning of character following \, or a space if no special meaning.
 184    Sixteen characters per line within the string.  */
 185
 186 static char esctab[]
 187   = " \057\026  \047\014         \
 188      \025   \015      \
 189    \005 \013          \
 190                 ";
 191 #else
 192 /* Table, indexed by a character in range 0100 to 0140 with 0100 subtracted,
 193    gives meaning of character following \, or a space if no special meaning.
 194    Eight characters per line within the string.  */
 195
 196 static char esctab[]
 197   = " \007\010  \033\014 \
 198       \012 \
 199   \015 \011 \013 \
 200         ";
 201 #endif
 202
 203 /* PTR points to a string value inside a termcap entry.
 204    Copy that value, processing \ and ^ abbreviations,
 205    into the block that *AREA points to,
 206    or to newly allocated storage if AREA is NULL.
 207    Return the address to which we copied the value,
 208    or NULL if PTR is NULL.  */
 209
 210 static char *
 211 tgetst1 (ptr, area)
 212      char *ptr;
 213      char **area;
 214 {
 215   register char *p, *r;
 216   register int c;
 217   register int size;
 218   char *ret;
 219   register int c1;
 220
 221   if (!ptr)
 222     return NULL;
 223
 224   /* `ret' gets address of where to store the string.  */
 225   if (!area)
 226     {
 227       /* Compute size of block needed (may overestimate).  */
 228       p = ptr;
 229       while ((c = *p++) && c != ':' && c != '\n')
 230         ;
 231       ret = (char *) xmalloc (p - ptr + 1);
 232     }
 233   else
 234     ret = *area;
 235
 236   /* Copy the string value, stopping at null or colon.
 237      Also process ^ and \ abbreviations.  */
 238   p = ptr;
 239   r = ret;
 240   while ((c = *p++) && c != ':' && c != '\n')
 241     {
 242       if (c == '^')
 243         {
 244           c = *p++;
 245           if (c == '?')
 246             c = 0177;
 247           else
 248             c &= 037;
 249         }
 250       else if (c == '\\')
 251         {
 252           c = *p++;
 253           if (c >= '0' && c <= '7')
 254             {
 255               c -= '0';
 256               size = 0;
 257
 258               while (++size < 3 && (c1 = *p) >= '0' && c1 <= '7')
 259                 {
 260                   c *= 8;
 261                   c += c1 - '0';
 262                   p++;
 263                 }
 264             }
 265 #ifdef IS_EBCDIC_HOST
 266           else if (c >= 0200 && c < 0360)
 267             {
 268               c1 = esctab[(c & ~0100) - 0200];
 269               if (c1 != ' ')
 270                 c = c1;
 271             }
 272 #else
 273           else if (c >= 0100 && c < 0200)
 274             {
 275               c1 = esctab[(c & ~040) - 0100];
 276               if (c1 != ' ')
 277                 c = c1;
 278             }
 279 #endif
 280         }
 281       *r++ = c;
 282     }
 283   *r = '\0';
 284   /* Update *AREA.  */
 285   if (area)
 286     *area = r + 1;
 287   return ret;
 288 }
 289 \f
 290 /* Outputting a string with padding.  */
 291
 292 #ifndef emacs
 293 short ospeed;
 294 /* If OSPEED is 0, we use this as the actual baud rate.  */
 295 int tputs_baud_rate;
 296 #endif
 297 char PC;
 298
 299 #ifndef emacs
 300 /* Actual baud rate if positive;
 301    - baud rate / 100 if negative.  */
 302
 303 static int speeds[] =
 304   {
 305 #ifdef VMS
 306     0, 50, 75, 110, 134, 150, -3, -6, -12, -18,
 307     -20, -24, -36, -48, -72, -96, -192
 308 #else /* not VMS */
 309     0, 50, 75, 110, 135, 150, -2, -3, -6, -12,
 310     -18, -24, -48, -96, -192, -288, -384, -576, -1152
 311 #endif /* not VMS */
 312   };
 313
 314 #endif /* not emacs */
 315
 316 void
 317 tputs (str, nlines, outfun)
 318      register char *str;
 319      int nlines;
 320      register int (*outfun) ();
 321 {
 322   register int padcount = 0;
 323   register int speed;
 324
 325 #ifdef emacs
 326   extern EMACS_INT baud_rate;
 327   speed = baud_rate;
 328   /* For quite high speeds, convert to the smaller
 329      units to avoid overflow.  */
 330   if (speed > 10000)
 331     speed = - speed / 100;
 332 #else
 333   if (ospeed == 0)
 334     speed = tputs_baud_rate;
 335   else
 336     speed = speeds[ospeed];
 337 #endif
 338
 339   if (!str)
 340     return;
 341
 342   while (*str >= '0' && *str <= '9')
 343     {
 344       padcount += *str++ - '0';
 345       padcount *= 10;
 346     }
 347   if (*str == '.')
 348     {
 349       str++;
 350       padcount += *str++ - '0';
 351     }
 352   if (*str == '*')
 353     {
 354       str++;
 355       padcount *= nlines;
 356     }
 357   while (*str)
 358     (*outfun) (*str++);
 359
 360   /* PADCOUNT is now in units of tenths of msec.
 361      SPEED is measured in characters per 10 seconds
 362      or in characters per .1 seconds (if negative).
 363      We use the smaller units for larger speeds to avoid overflow.  */
 364   padcount *= speed;
 365   padcount += 500;
 366   padcount /= 1000;
 367   if (speed < 0)
 368     padcount = -padcount;
 369   else
 370     {
 371       padcount += 50;
 372       padcount /= 100;
 373     }
 374
 375   while (padcount-- > 0)
 376     (*outfun) (PC);
 377 }
 378 \f
 379 /* Finding the termcap entry in the termcap data base.  */
 380
 381 struct termcap_buffer
 382   {
 383     char *beg;
 384     int size;
 385     char *ptr;
 386     int ateof;
 387     int full;
 388   };
 389
 390 /* Forward declarations of static functions.  */
 391
 392 static int scan_file ();
 393 static char *gobble_line ();
 394 static int compare_contin ();
 395 static int name_match ();
 396
 397 #ifdef VMS
 398
 399 #include <rmsdef.h>
 400 #include <fab.h>
 401 #include <nam.h>
 402
 403 static int
 404 valid_filename_p (fn)
 405      char *fn;
 406 {
 407   struct FAB fab = cc$rms_fab;
 408   struct NAM nam = cc$rms_nam;
 409   char esa[NAM$C_MAXRSS];
 410
 411   fab.fab$l_fna = fn;
 412   fab.fab$b_fns = strlen(fn);
 413   fab.fab$l_nam = &nam;
 414   fab.fab$l_fop = FAB$M_NAM;
 415
 416   nam.nam$l_esa = esa;
 417   nam.nam$b_ess = sizeof esa;
 418
 419   return SYS$PARSE(&fab, 0, 0) == RMS$_NORMAL;
 420 }
 421
 422 #else /* !VMS */
 423
 424 #ifdef MSDOS /* MW, May 1993 */
 425 static int
 426 valid_filename_p (fn)
 427      char *fn;
 428 {
 429   return *fn == '/' || fn[1] == ':';
 430 }
 431 #else
 432 #define valid_filename_p(fn) (*(fn) == '/')
 433 #endif
 434
 435 #endif /* !VMS */
 436
 437 /* Find the termcap entry data for terminal type NAME
 438    and store it in the block that BP points to.
 439    Record its address for future use.
 440
 441    If BP is null, space is dynamically allocated.
 442
 443    Return -1 if there is some difficulty accessing the data base
 444    of terminal types,
 445    0 if the data base is accessible but the type NAME is not defined
 446    in it, and some other value otherwise.  */
 447
 448 int
 449 tgetent (bp, name)
 450      char *bp, *name;
 451 {
 452   register char *termcap_name;
 453   register int fd;
 454   struct termcap_buffer buf;
 455   register char *bp1;
 456   char *tc_search_point;
 457   char *term;
 458   int malloc_size = 0;
 459   register int c;
 460   char *tcenv = NULL;           /* TERMCAP value, if it contains :tc=.  */
 461   char *indirect = NULL;        /* Terminal type in :tc= in TERMCAP value.  */
 462   int filep;
 463
 464 #ifdef INTERNAL_TERMINAL
 465   /* For the internal terminal we don't want to read any termcap file,
 466      so fake it.  */
 467   if (!strcmp (name, "internal"))
 468     {
 469       term = INTERNAL_TERMINAL;
 470       if (!bp)
 471         {
 472           malloc_size = 1 + strlen (term);
 473           bp = (char *) xmalloc (malloc_size);
 474         }
 475       strcpy (bp, term);
 476       goto ret;
 477     }
 478 #endif /* INTERNAL_TERMINAL */
 479
 480   /* For compatibility with programs like `less' that want to
 481      put data in the termcap buffer themselves as a fallback.  */
 482   if (bp)
 483     term_entry = bp;
 484
 485   termcap_name = getenv ("TERMCAP");
 486   if (termcap_name && *termcap_name == '\0')
 487     termcap_name = NULL;
 488 #if defined (MSDOS) && !defined (TEST)
 489   if (termcap_name && (*termcap_name == '\\'
 490                        || *termcap_name == '/'
 491                        || termcap_name[1] == ':'))
 492     dostounix_filename(termcap_name);
 493 #endif
 494
 495   filep = termcap_name && valid_filename_p (termcap_name);
 496
 497   /* If termcap_name is non-null and starts with / (in the un*x case, that is),
 498      it is a file name to use instead of /etc/termcap.
 499      If it is non-null and does not start with /,
 500      it is the entry itself, but only if
 501      the name the caller requested matches the TERM variable.  */
 502
 503   if (termcap_name && !filep && !strcmp (name, getenv ("TERM")))
 504     {
 505       indirect = tgetst1 (find_capability (termcap_name, "tc"), (char **) 0);
 506       if (!indirect)
 507         {
 508           if (!bp)
 509             bp = termcap_name;
 510           else
 511             strcpy (bp, termcap_name);
 512           goto ret;
 513         }
 514       else
 515         {                       /* It has tc=.  Need to read /etc/termcap.  */
 516           tcenv = termcap_name;
 517           termcap_name = NULL;
 518         }
 519     }
 520
 521   if (!termcap_name || !filep)
 522     termcap_name = TERMCAP_FILE;
 523
 524   /* Here we know we must search a file and termcap_name has its name.  */
 525
 526 #ifdef MSDOS
 527   fd = open (termcap_name, O_RDONLY|O_TEXT, 0);
 528 #else
 529   fd = open (termcap_name, O_RDONLY, 0);
 530 #endif
 531   if (fd < 0)
 532     return -1;
 533
 534   buf.size = BUFSIZE;
 535   /* Add 1 to size to ensure room for terminating null.  */
 536   buf.beg = (char *) xmalloc (buf.size + 1);
 537   term = indirect ? indirect : name;
 538
 539   if (!bp)
 540     {
 541       malloc_size = indirect ? strlen (tcenv) + 1 : buf.size;
 542       bp = (char *) xmalloc (malloc_size);
 543     }
 544   tc_search_point = bp1 = bp;
 545
 546   if (indirect)
 547     /* Copy the data from the environment variable.  */
 548     {
 549       strcpy (bp, tcenv);
 550       bp1 += strlen (tcenv);
 551     }
 552
 553   while (term)
 554     {
 555       /* Scan the file, reading it via buf, till find start of main entry.  */
 556       if (scan_file (term, fd, &buf) == 0)
 557         {
 558           close (fd);
 559           free (buf.beg);
 560           if (malloc_size)
 561             free (bp);
 562           return 0;
 563         }
 564
 565       /* Free old `term' if appropriate.  */
 566       if (term != name)
 567         free (term);
 568
 569       /* If BP is malloc'd by us, make sure it is big enough.  */
 570       if (malloc_size)
 571         {
 572           int offset1 = bp1 - bp, offset2 = tc_search_point - bp;
 573           malloc_size = offset1 + buf.size;
 574           bp = termcap_name = (char *) xrealloc (bp, malloc_size);
 575           bp1 = termcap_name + offset1;
 576           tc_search_point = termcap_name + offset2;
 577         }
 578
 579       /* Copy the line of the entry from buf into bp.  */
 580       termcap_name = buf.ptr;
 581       while ((*bp1++ = c = *termcap_name++) && c != '\n')
 582         /* Drop out any \ newline sequence.  */
 583         if (c == '\\' && *termcap_name == '\n')
 584           {
 585             bp1--;
 586             termcap_name++;
 587           }
 588       *bp1 = '\0';
 589
 590       /* Does this entry refer to another terminal type's entry?
 591          If something is found, copy it into heap and null-terminate it.  */
 592       tc_search_point = find_capability (tc_search_point, "tc");
 593       term = tgetst1 (tc_search_point, (char **) 0);
 594     }
 595
 596   close (fd);
 597   free (buf.beg);
 598
 599   if (malloc_size)
 600     bp = (char *) xrealloc (bp, bp1 - bp + 1);
 601
 602  ret:
 603   term_entry = bp;
 604   return 1;
 605 }
 606
 607 /* Given file open on FD and buffer BUFP,
 608    scan the file from the beginning until a line is found
 609    that starts the entry for terminal type STR.
 610    Return 1 if successful, with that line in BUFP,
 611    or 0 if no entry is found in the file.  */
 612
 613 static int
 614 scan_file (str, fd, bufp)
 615      char *str;
 616      int fd;
 617      register struct termcap_buffer *bufp;
 618 {
 619   register char *end;
 620
 621   bufp->ptr = bufp->beg;
 622   bufp->full = 0;
 623   bufp->ateof = 0;
 624   *bufp->ptr = '\0';
 625
 626   lseek (fd, 0L, 0);
 627
 628   while (!bufp->ateof)
 629     {
 630       /* Read a line into the buffer.  */
 631       end = NULL;
 632       do
 633         {
 634           /* if it is continued, append another line to it,
 635              until a non-continued line ends.  */
 636           end = gobble_line (fd, bufp, end);
 637         }
 638       while (!bufp->ateof && end[-2] == '\\');
 639
 640       if (*bufp->ptr != '#'
 641           && name_match (bufp->ptr, str))
 642         return 1;
 643
 644       /* Discard the line just processed.  */
 645       bufp->ptr = end;
 646     }
 647   return 0;
 648 }
 649
 650 /* Return nonzero if NAME is one of the names specified
 651    by termcap entry LINE.  */
 652
 653 static int
 654 name_match (line, name)
 655      char *line, *name;
 656 {
 657   register char *tem;
 658
 659   if (!compare_contin (line, name))
 660     return 1;
 661   /* This line starts an entry.  Is it the right one?  */
 662   for (tem = line; *tem && *tem != '\n' && *tem != ':'; tem++)
 663     if (*tem == '|' && !compare_contin (tem + 1, name))
 664       return 1;
 665
 666   return 0;
 667 }
 668
 669 static int
 670 compare_contin (str1, str2)
 671      register char *str1, *str2;
 672 {
 673   register int c1, c2;
 674   while (1)
 675     {
 676       c1 = *str1++;
 677       c2 = *str2++;
 678       while (c1 == '\\' && *str1 == '\n')
 679         {
 680           str1++;
 681           while ((c1 = *str1++) == ' ' || c1 == '\t');
 682         }
 683       if (c2 == '\0')
 684         {
 685           /* End of type being looked up.  */
 686           if (c1 == '|' || c1 == ':')
 687             /* If end of name in data base, we win.  */
 688             return 0;
 689           else
 690             return 1;
 691         }
 692       else if (c1 != c2)
 693         return 1;
 694     }
 695 }
 696
 697 /* Make sure that the buffer <- BUFP contains a full line
 698    of the file open on FD, starting at the place BUFP->ptr
 699    points to.  Can read more of the file, discard stuff before
 700    BUFP->ptr, or make the buffer bigger.
 701
 702    Return the pointer to after the newline ending the line,
 703    or to the end of the file, if there is no newline to end it.
 704
 705    Can also merge on continuation lines.  If APPEND_END is
 706    non-null, it points past the newline of a line that is
 707    continued; we add another line onto it and regard the whole
 708    thing as one line.  The caller decides when a line is continued.  */
 709
 710 static char *
 711 gobble_line (fd, bufp, append_end)
 712      int fd;
 713      register struct termcap_buffer *bufp;
 714      char *append_end;
 715 {
 716   register char *end;
 717   register int nread;
 718   register char *buf = bufp->beg;
 719   register char *tem;
 720
 721   if (!append_end)
 722     append_end = bufp->ptr;
 723
 724   while (1)
 725     {
 726       end = append_end;
 727       while (*end && *end != '\n') end++;
 728       if (*end)
 729         break;
 730       if (bufp->ateof)
 731         return buf + bufp->full;
 732       if (bufp->ptr == buf)
 733         {
 734           if (bufp->full == bufp->size)
 735             {
 736               bufp->size *= 2;
 737               /* Add 1 to size to ensure room for terminating null.  */
 738               tem = (char *) xrealloc (buf, bufp->size + 1);
 739               bufp->ptr = (bufp->ptr - buf) + tem;
 740               append_end = (append_end - buf) + tem;
 741               bufp->beg = buf = tem;
 742             }
 743         }
 744       else
 745         {
 746           append_end -= bufp->ptr - buf;
 747           bcopy (bufp->ptr, buf, bufp->full -= bufp->ptr - buf);
 748           bufp->ptr = buf;
 749         }
 750       if (!(nread = read (fd, buf + bufp->full, bufp->size - bufp->full)))
 751         bufp->ateof = 1;
 752       bufp->full += nread;
 753       buf[bufp->full] = '\0';
 754     }
 755   return end + 1;
 756 }
 757 \f
 758 #ifdef TEST
 759
 760 #ifdef NULL
 761 #undef NULL
 762 #endif
 763
 764 #include <stdio.h>
 765
 766 main (argc, argv)
 767      int argc;
 768      char **argv;
 769 {
 770   char *term;
 771   char *buf;
 772
 773   term = argv[1];
 774   printf ("TERM: %s\n", term);
 775
 776   buf = (char *) tgetent (0, term);
 777   if ((int) buf <= 0)
 778     {
 779       printf ("No entry.\n");
 780       return 0;
 781     }
 782
 783   printf ("Entry: %s\n", buf);
 784
 785   tprint ("cm");
 786   tprint ("AL");
 787
 788   printf ("co: %d\n", tgetnum ("co"));
 789   printf ("am: %d\n", tgetflag ("am"));
 790 }
 791
 792 tprint (cap)
 793      char *cap;
 794 {
 795   char *x = tgetstr (cap, 0);
 796   register char *y;
 797
 798   printf ("%s: ", cap);
 799   if (x)
 800     {
 801       for (y = x; *y; y++)
 802         if (*y <= ' ' || *y == 0177)
 803           printf ("\\%0o", *y);
 804         else
 805           putchar (*y);
 806       free (x);
 807     }
 808   else
 809     printf ("none");
 810   putchar ('\n');
 811 }
 812
 813 #endif /* TEST */