1 /* Work-alike for termcap, plus extra features.
2 Copyright (C) 1985-1986, 1993-1995, 2000-2008, 2011, 2013 Free
3 Software Foundation, Inc.
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)
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.
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/>. */
18 /* Emacs config.h may rename various library functions such as malloc. */
30 /* BUFSIZE is the initial size allocated for the buffer
31 for reading the termcap file.
33 Make it large normally for speed.
34 Make it variable when debugging, so can exercise
35 increasing the space dynamically. */
39 #define BUFSIZE bufsize
48 #define TERMCAP_FILE "/etc/termcap"
52 /* Looking up capabilities in the entry already found. */
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
;
58 static char *tgetst1 (char *ptr
, char **area
);
60 /* Search entry BP for capability CAP.
61 Return a pointer to the capability (in BP) if found,
65 find_capability (register char *bp
, register const char *cap
)
76 tgetnum (const char *cap
)
78 register char *ptr
= find_capability (term_entry
, cap
);
79 if (!ptr
|| ptr
[-1] != '#')
85 tgetflag (const char *cap
)
87 register char *ptr
= find_capability (term_entry
, cap
);
88 return ptr
&& ptr
[-1] == ':';
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'. */
97 tgetstr (const char *cap
, char **area
)
99 register char *ptr
= find_capability (term_entry
, cap
);
100 if (!ptr
|| (ptr
[-1] != '=' && ptr
[-1] != '~'))
102 return tgetst1 (ptr
, area
);
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. */
110 static const char esctab
[]
111 = " \057\026 \047\014 \
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. */
120 static const char esctab
[]
121 = " \007\010 \033\014 \
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. */
135 tgetst1 (char *ptr
, char **area
)
137 register char *p
, *r
;
146 /* `ret' gets address of where to store the string. */
149 /* Compute size of block needed (may overestimate). */
151 while ((c
= *p
++) && c
!= ':' && c
!= '\n')
153 ret
= xmalloc (p
- ptr
+ 1);
158 /* Copy the string value, stopping at null or colon.
159 Also process ^ and \ abbreviations. */
162 while ((c
= *p
++) && c
!= ':' && c
!= '\n')
175 if (c
>= '0' && c
<= '7')
180 while (++size
< 3 && (c1
= *p
) >= '0' && c1
<= '7')
187 #ifdef IS_EBCDIC_HOST
188 else if (c
>= 0200 && c
< 0360)
190 c1
= esctab
[(c
& ~0100) - 0200];
195 else if (c
>= 0100 && c
< 0200)
197 c1
= esctab
[(c
& ~040) - 0100];
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.
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. */
216 register int last_p_param
= 0;
217 int remove_p_params
= 1;
218 struct { char *beg
; int len
; } cut
[11];
220 for (cut
[0].beg
= p
= ret
; p
< r
- 3; p
++)
222 if (!remove_p_params
)
224 if (*p
== '%' && *(p
+ 1) == 'p')
226 if (*(p
+ 2) - '0' == 1 + last_p_param
)
228 cut
[last_p_param
].len
= p
- cut
[last_p_param
].beg
;
231 cut
[last_p_param
].beg
= p
;
233 else /* not continuous: bail */
235 if (last_p_param
> 10) /* too many: bail */
239 if (remove_p_params
&& last_p_param
)
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
);
258 /* Outputting a string with padding. */
263 tputs (register const char *str
, int nlines
, int (*outfun
) (int))
265 register int padcount
= 0;
269 /* For quite high speeds, convert to the smaller
270 units to avoid overflow. */
272 speed
= - speed
/ 100;
277 while (*str
>= '0' && *str
<= '9')
279 padcount
+= *str
++ - '0';
285 padcount
+= *str
++ - '0';
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. */
303 padcount
= -padcount
;
310 while (padcount
-- > 0)
314 /* Finding the termcap entry in the termcap data base. */
316 struct termcap_buffer
325 /* Forward declarations of static functions. */
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
);
332 #ifdef MSDOS /* MW, May 1993 */
334 valid_filename_p (char *fn
)
336 return *fn
== '/' || fn
[1] == ':';
339 #define valid_filename_p(fn) (*(fn) == '/')
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.
346 If BP is null, space is dynamically allocated.
348 Return -1 if there is some difficulty accessing the data base
350 0 if the data base is accessible but the type NAME is not defined
351 in it, and some other value otherwise. */
354 tgetent (char *bp
, const char *name
)
356 register char *termcap_name
;
358 struct termcap_buffer buf
;
360 char *tc_search_point
;
362 ptrdiff_t malloc_size
= 0;
364 char *tcenv
= NULL
; /* TERMCAP value, if it contains :tc=. */
365 char *indirect
= NULL
; /* Terminal type in :tc= in TERMCAP value. */
368 #ifdef INTERNAL_TERMINAL
369 /* For the internal terminal we don't want to read any termcap file,
371 if (!strcmp (name
, "internal"))
373 term
= INTERNAL_TERMINAL
;
376 malloc_size
= 1 + strlen (term
);
377 bp
= xmalloc (malloc_size
);
382 #endif /* INTERNAL_TERMINAL */
384 /* For compatibility with programs like `less' that want to
385 put data in the termcap buffer themselves as a fallback. */
389 termcap_name
= getenv ("TERMCAP");
390 if (termcap_name
&& *termcap_name
== '\0')
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);
399 filep
= termcap_name
&& valid_filename_p (termcap_name
);
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. */
407 if (termcap_name
&& !filep
&& !strcmp (name
, getenv ("TERM")))
409 indirect
= tgetst1 (find_capability (termcap_name
, "tc"), (char **) 0);
415 strcpy (bp
, termcap_name
);
419 { /* It has tc=. Need to read /etc/termcap. */
420 tcenv
= termcap_name
;
425 if (!termcap_name
|| !filep
)
426 termcap_name
= TERMCAP_FILE
;
428 /* Here we know we must search a file and termcap_name has its name. */
430 fd
= emacs_open (termcap_name
, O_RDONLY
| O_TEXT
, 0);
435 /* Add 1 to size to ensure room for terminating null. */
436 buf
.beg
= xmalloc (buf
.size
+ 1);
437 term
= indirect
? indirect
: (char *)name
;
441 malloc_size
= indirect
? strlen (tcenv
) + 1 : buf
.size
;
442 bp
= xmalloc (malloc_size
);
444 tc_search_point
= bp1
= bp
;
447 /* Copy the data from the environment variable. */
450 bp1
+= strlen (tcenv
);
455 /* Scan the file, reading it via buf, till find start of main entry. */
456 if (scan_file (term
, fd
, &buf
) == 0)
465 /* Free old `term' if appropriate. */
469 /* If BP is malloc'd by us, make sure it is big enough. */
472 ptrdiff_t offset1
= bp1
- bp
, offset2
= tc_search_point
- bp
;
473 malloc_size
= offset1
+ buf
.size
;
474 bp
= termcap_name
= xrealloc (bp
, malloc_size
);
475 bp1
= termcap_name
+ offset1
;
476 tc_search_point
= termcap_name
+ offset2
;
479 /* Copy the line of the entry from buf into bp. */
480 termcap_name
= buf
.ptr
;
481 while ((*bp1
++ = c
= *termcap_name
++) && c
!= '\n')
482 /* Drop out any \ newline sequence. */
483 if (c
== '\\' && *termcap_name
== '\n')
490 /* Does this entry refer to another terminal type's entry?
491 If something is found, copy it into heap and null-terminate it. */
492 tc_search_point
= find_capability (tc_search_point
, "tc");
493 term
= tgetst1 (tc_search_point
, (char **) 0);
500 bp
= xrealloc (bp
, bp1
- bp
+ 1);
507 /* Given file open on FD and buffer BUFP,
508 scan the file from the beginning until a line is found
509 that starts the entry for terminal type STR.
510 Return 1 if successful, with that line in BUFP,
511 or 0 if no entry is found in the file. */
514 scan_file (char *str
, int fd
, register struct termcap_buffer
*bufp
)
518 bufp
->ptr
= bufp
->beg
;
527 /* Read a line into the buffer. */
531 /* if it is continued, append another line to it,
532 until a non-continued line ends. */
533 end
= gobble_line (fd
, bufp
, end
);
535 while (!bufp
->ateof
&& end
[-2] == '\\');
537 if (*bufp
->ptr
!= '#'
538 && name_match (bufp
->ptr
, str
))
541 /* Discard the line just processed. */
547 /* Return nonzero if NAME is one of the names specified
548 by termcap entry LINE. */
551 name_match (char *line
, char *name
)
555 if (!compare_contin (line
, name
))
557 /* This line starts an entry. Is it the right one? */
558 for (tem
= line
; *tem
&& *tem
!= '\n' && *tem
!= ':'; tem
++)
559 if (*tem
== '|' && !compare_contin (tem
+ 1, name
))
566 compare_contin (register char *str1
, register char *str2
)
573 while (c1
== '\\' && *str1
== '\n')
576 while ((c1
= *str1
++) == ' ' || c1
== '\t');
580 /* End of type being looked up. */
581 if (c1
== '|' || c1
== ':')
582 /* If end of name in data base, we win. */
592 /* Make sure that the buffer <- BUFP contains a full line
593 of the file open on FD, starting at the place BUFP->ptr
594 points to. Can read more of the file, discard stuff before
595 BUFP->ptr, or make the buffer bigger.
597 Return the pointer to after the newline ending the line,
598 or to the end of the file, if there is no newline to end it.
600 Can also merge on continuation lines. If APPEND_END is
601 non-null, it points past the newline of a line that is
602 continued; we add another line onto it and regard the whole
603 thing as one line. The caller decides when a line is continued. */
606 gobble_line (int fd
, register struct termcap_buffer
*bufp
, char *append_end
)
610 register char *buf
= bufp
->beg
;
613 append_end
= bufp
->ptr
;
618 while (*end
&& *end
!= '\n') end
++;
622 return buf
+ bufp
->full
;
623 if (bufp
->ptr
== buf
)
625 if (bufp
->full
== bufp
->size
)
627 ptrdiff_t ptr_offset
= bufp
->ptr
- buf
;
628 ptrdiff_t append_end_offset
= append_end
- buf
;
629 /* Add 1 to size to ensure room for terminating null. */
630 ptrdiff_t size
= bufp
->size
+ 1;
631 bufp
->beg
= buf
= xpalloc (buf
, &size
, 1, -1, 1);
632 bufp
->size
= size
- 1;
633 bufp
->ptr
= buf
+ ptr_offset
;
634 append_end
= buf
+ append_end_offset
;
639 append_end
-= bufp
->ptr
- buf
;
640 memcpy (buf
, bufp
->ptr
, bufp
->full
-= bufp
->ptr
- buf
);
643 if (!(nread
= read (fd
, buf
+ bufp
->full
, bufp
->size
- bufp
->full
)))
646 buf
[bufp
->full
] = '\0';
658 char *x
= tgetstr (cap
, 0);
661 printf ("%s: ", cap
);
665 if (*y
<= ' ' || *y
== 0177)
666 printf ("\\%0o", *y
);
677 main (int argc
, char **argv
)
683 printf ("TERM: %s\n", term
);
685 buf
= (char *) tgetent (0, term
);
688 printf ("No entry.\n");
692 printf ("Entry: %s\n", buf
);
697 printf ("co: %d\n", tgetnum ("co"));
698 printf ("am: %d\n", tgetflag ("am"));