![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to termcap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / src|
Return to termcap.c CVS log | Up to [Apple XNU] / GNUtools / emacs / src |
1.1 root 1: /* Work-alike for termcap, plus extra features.
2: Copyright (C) 1985, 1986 Free Software Foundation, Inc.
3:
4: This program is free software; you can redistribute it and/or modify
5: it under the terms of the GNU General Public License as published by
6: the Free Software Foundation; either version 1, or (at your option)
7: any later version.
8:
9: This program is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12: GNU General Public License for more details.
13:
14: You should have received a copy of the GNU General Public License
15: along with this program; if not, write to the Free Software
16: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17:
18: In other words, you are welcome to use, share and improve this program.
19: You are forbidden to forbid anyone else to use, share and improve
20: what you give them. Help stamp out software-hoarding! */
21:
22:
23:
24: /* BUFSIZE is the initial size allocated for the buffer
25: for reading the termcap file.
26: It is not a limit.
27: Make it large normally for speed.
28: Make it variable when debugging, so can exercise
29: increasing the space dynamically. */
30:
31: #ifdef emacs
32: #include "config.h"
33: #endif
34:
35: #ifndef BUFSIZE
36: #ifdef DEBUG
37: #define BUFSIZE bufsize
38:
39: int bufsize = 128;
40: #else
41: #define BUFSIZE 2048
42: #endif
43: #endif
44:
45: #ifndef emacs
46: static
47: memory_out ()
48: {
49: write (2, "Virtual memory exhausted\n", 25);
50: exit (1);
51: }
52:
53: static int
54: xmalloc (size)
55: int size;
56: {
57: register tem = malloc (size);
58: if (!tem)
59: memory_out ();
60: return tem;
61: }
62:
63: static int
64: xrealloc (ptr, size)
65: int ptr;
66: int size;
67: {
68: register tem = realloc (ptr, size);
69: if (!tem)
70: memory_out ();
71: return tem;
72: }
73: #endif /* not emacs */
74:
75: /* Looking up capabilities in the entry already found */
76:
77: /* The pointer to the data made by tgetent is left here
78: for tgetnum, tgetflag and tgetstr to find. */
79:
80: static char *term_entry;
81:
82: static char *tgetst1 ();
83:
84: /* This is the main subroutine that is used to search
85: an entry for a particular capability */
86:
87: static char *
88: find_capability (bp, cap)
89: register char *bp, *cap;
90: {
91: for (; *bp; bp++)
92: if (bp[0] == ':'
93: && bp[1] == cap[0]
94: && bp[2] == cap[1])
95: return &bp[4];
96: return 0;
97: }
98:
99: int
100: tgetnum (cap)
101: char *cap;
102: {
103: register char *ptr = find_capability (term_entry, cap);
104: if (!ptr || ptr[-1] != '#')
105: return -1;
106: return atoi (ptr);
107: }
108:
109: int
110: tgetflag (cap)
111: char *cap;
112: {
113: register char *ptr = find_capability (term_entry, cap);
114: return 0 != ptr && ptr[-1] == ':';
115: }
116:
117: /* Look up a string-valued capability `cap'.
118: If `area' is nonzero, it points to a pointer to a block in which
119: to store the string. That pointer is advanced over the space used.
120: If `area' is zero, space is allocated with `malloc'. */
121:
122: char *
123: tgetstr (cap, area)
124: char *cap;
125: char **area;
126: {
127: register char *ptr = find_capability (term_entry, cap);
128: if (!ptr || (ptr[-1] != '=' && ptr[-1] != '~'))
129: return 0;
130: return tgetst1 (ptr, area);
131: }
132:
133: /* Table, indexed by a character in range 0100 to 0140 with 0100 subtracted,
134: gives meaning of character following \, or a space if no special meaning.
135: Eight characters per line within the string. */
136:
137: static char esctab[]
138: = " \007\010 \033\014 \
139: \012 \
140: \015 \011 \013 \
141: ";
142:
143: /* Given a pointer to a string value inside a termcap entry (`ptr'),
144: copy the value and process \ and ^ abbreviations.
145: Copy into block that *area points to,
146: or to newly allocated storage if area is 0. */
147:
148: static char *
149: tgetst1 (ptr, area)
150: char *ptr;
151: char **area;
152: {
153: register char *p, *r;
154: register int c;
155: register int size;
156: char *ret;
157: register int c1;
158:
159: if (!ptr)
160: return 0;
161:
162: /* `ret' gets address of where to store the string */
163: if (!area)
164: {
165: /* Compute size of block needed (may overestimate) */
166: p = ptr;
167: while ((c = *p++) && c != ':' && c != '\n');
168: ret = (char *) xmalloc (p - ptr + 1);
169: }
170: else
171: ret = *area;
172:
173: /* Copy the string value, stopping at null or colon. */
174: /* Also process ^ and \ abbreviations. */
175: p = ptr;
176: r = ret;
177: while ((c = *p++) && c != ':' && c != '\n')
178: {
179: if (c == '^')
180: c = *p++ & 037;
181: else if (c == '\\')
182: {
183: c = *p++;
184: if (c >= '0' && c <= '7')
185: {
186: c -= '0';
187: size = 0;
188:
189: while (++size < 3 && (c1 = *p) >= '0' && c1 <= '7')
190: {
191: c *= 8;
192: c += c1 - '0';
193: p++;
194: }
195: }
196: else if (c >= 0100 && c < 0200)
197: {
198: c1 = esctab[(c & ~040) - 0100];
199: if (c1 != ' ')
200: c = c1;
201: }
202: }
203: *r++ = c;
204: }
205: *r = 0;
206: /* Update *area */
207: if (area)
208: *area = r + 1;
209: return ret;
210: }
211:
212: /* Outputting a string with padding */
213:
214: short ospeed;
215: char PC;
216:
217: /* Actual baud rate if positive;
218: - baud rate / 100 if negative. */
219:
220: static short speeds[] =
221: {
222: #ifdef VMS
223: 0, 50, 75, 110, 134, 150, -3, -6, -12, -18,
224: -20, -24, -36, -48, -72, -96, -192
225: #else /* not VMS */
226: 0, 50, 75, 110, 135, 150, -2, -3, -6, -12,
227: -18, -24, -48, -96, -192, -384
228: #endif /* not VMS */
229: };
230:
231: tputs (string, nlines, outfun)
232: register char *string;
233: int nlines;
234: register int (*outfun) ();
235: {
236: register int padcount = 0;
237:
238: if (string == (char *) 0)
239: return;
240: while (*string >= '0' && *string <= '9')
241: {
242: padcount += *string++ - '0';
243: padcount *= 10;
244: }
245: if (*string == '.')
246: {
247: string++;
248: padcount += *string++ - '0';
249: }
250: if (*string == '*')
251: {
252: string++;
253: padcount *= nlines;
254: }
255: while (*string)
256: (*outfun) (*string++);
257:
258: /* padcount is now in units of tenths of msec. */
259: padcount *= speeds[ospeed];
260: padcount += 500;
261: padcount /= 1000;
262: if (speeds[ospeed] < 0)
263: padcount = -padcount;
264: else
265: {
266: padcount += 50;
267: padcount /= 100;
268: }
269:
270: while (padcount-- > 0)
271: (*outfun) (PC);
272: }
273:
274: /* Finding the termcap entry in the termcap data base */
275:
276: struct buffer
277: {
278: char *beg;
279: int size;
280: char *ptr;
281: int ateof;
282: int full;
283: };
284:
285: /* Forward declarations of static functions */
286:
287: static int scan_file ();
288: static char *gobble_line ();
289: static int compare_contin ();
290: static int name_match ();
291:
292: #ifdef VMS
293:
294: #include <rmsdef.h>
295: #include <fab.h>
296: #include <nam.h>
297:
298: static int
299: legal_filename_p (fn)
300: char *fn;
301: {
302: struct FAB fab = cc$rms_fab;
303: struct NAM nam = cc$rms_nam;
304: char esa[NAM$C_MAXRSS];
305:
306: fab.fab$l_fna = fn;
307: fab.fab$b_fns = strlen(fn);
308: fab.fab$l_nam = &nam;
309: fab.fab$l_fop = FAB$M_NAM;
310:
311: nam.nam$l_esa = esa;
312: nam.nam$b_ess = sizeof esa;
313:
314: return SYS$PARSE(&fab, 0, 0) == RMS$_NORMAL;
315: }
316:
317: #endif /* VMS */
318:
319: /* Find the termcap entry data for terminal type `name'
320: and store it in the block that `bp' points to.
321: Record its address for future use.
322:
323: If `bp' is zero, space is dynamically allocated. */
324:
325: int
326: tgetent (bp, name)
327: char *bp, *name;
328: {
329: register char *tem;
330: register int fd;
331: struct buffer buf;
332: register char *bp1;
333: char *bp2;
334: char *term;
335: int malloc_size = 0;
336: register int c;
337: char *tcenv; /* TERMCAP value, if it contais :tc=. */
338: char *indirect = 0; /* Terminal type in :tc= in TERMCAP value. */
339: int filep;
340:
341: tem = (char *) getenv ("TERMCAP");
342: if (tem && *tem == 0) tem = 0;
343:
344: #ifdef VMS
345: filep = tem && legal_filename_p (tem);
346: #else
347: filep = tem && (*tem == '/');
348: #endif /* VMS */
349:
350: /* If tem is non-null and starts with / (in the un*x case, that is),
351: it is a file name to use instead of /etc/termcap.
352: If it is non-null and does not start with /,
353: it is the entry itself, but only if
354: the name the caller requested matches the TERM variable. */
355:
356: if (tem && !filep && !strcmp (name, getenv ("TERM")))
357: {
358: indirect = tgetst1 (find_capability (tem, "tc"), 0);
359: if (!indirect)
360: {
361: if (!bp)
362: bp = tem;
363: else
364: strcpy (bp, tem);
365: goto ret;
366: }
367: else
368: { /* we will need to read /etc/termcap */
369: tcenv = tem;
370: tem = 0;
371: }
372: }
373: else
374: indirect = (char *) 0;
375:
376: if (!tem)
377: #ifdef VMS
378: tem = "emacs_library:[etc]termcap.dat";
379: #else
380: tem = "/etc/termcap";
381: #endif
382:
383: /* Here we know we must search a file and tem has its name. */
384:
385: fd = open (tem, 0, 0);
386: if (fd < 0)
387: return -1;
388:
389: buf.size = BUFSIZE;
390: /* Add 1 to size to ensure room for terminating null. */
391: buf.beg = (char *) xmalloc (buf.size + 1);
392: term = indirect ? indirect : name;
393:
394: if (!bp)
395: {
396: malloc_size = indirect ? strlen (tcenv) + 1 : buf.size;
397: bp = (char *) xmalloc (malloc_size);
398: }
399: bp1 = bp;
400:
401: if (indirect) /* copy the data from the environment variable */
402: {
403: strcpy (bp, tcenv);
404: bp1 += strlen (tcenv);
405: }
406:
407: while (term)
408: {
409: /* Scan file, reading it via buf, till find start of main entry */
410: if (scan_file (term, fd, &buf) == 0)
411: return 0;
412:
413: /* Free old `term' if appropriate. */
414: if (term != name)
415: free (term);
416:
417: /* If `bp' is malloc'd by us, make sure it is big enough. */
418: if (malloc_size)
419: {
420: malloc_size = bp1 - bp + buf.size;
421: tem = (char *) xrealloc (bp, malloc_size);
422: bp1 += tem - bp;
423: bp = tem;
424: }
425:
426: bp2 = bp1;
427:
428: /* Copy the line of the entry from buf into bp. */
429: tem = buf.ptr;
430: while ((*bp1++ = c = *tem++) && c != '\n')
431: /* Drop out any \ newline sequence. */
432: if (c == '\\' && *tem == '\n')
433: {
434: bp1--;
435: tem++;
436: }
437: *bp1 = 0;
438:
439: /* Does this entry refer to another terminal type's entry? */
440: /* If something is found, copy it into heap and null-terminate it */
441: term = tgetst1 (find_capability (bp2, "tc"), 0);
442: }
443:
444: close (fd);
445: free (buf.beg);
446:
447: if (malloc_size)
448: {
449: bp = (char *) xrealloc (bp, bp1 - bp + 1);
450: }
451:
452: ret:
453: term_entry = bp;
454: if (malloc_size)
455: return (int) bp;
456: return 1;
457: }
458:
459: /* Given file open on `fd' and buffer `bufp',
460: scan the file from the beginning until a line is found
461: that starts the entry for terminal type `string'.
462: Returns 1 if successful, with that line in `bufp',
463: or returns 0 if no entry found in the file. */
464:
465: static int
466: scan_file (string, fd, bufp)
467: char *string;
468: int fd;
469: register struct buffer *bufp;
470: {
471: register char *tem;
472: register char *end;
473:
474: bufp->ptr = bufp->beg;
475: bufp->full = 0;
476: bufp->ateof = 0;
477: *bufp->ptr = 0;
478:
479: lseek (fd, 0L, 0);
480:
481: while (!bufp->ateof)
482: {
483: /* Read a line into the buffer */
484: end = 0;
485: do
486: {
487: /* if it is continued, append another line to it,
488: until a non-continued line ends */
489: end = gobble_line (fd, bufp, end);
490: }
491: while (!bufp->ateof && end[-2] == '\\');
492:
493: if (*bufp->ptr != '#'
494: && name_match (bufp->ptr, string))
495: return 1;
496:
497: /* Discard the line just processed */
498: bufp->ptr = end;
499: }
500: return 0;
501: }
502:
503: /* Return nonzero if NAME is one of the names specified
504: by termcap entry LINE. */
505:
506: static int
507: name_match (line, name)
508: char *line, *name;
509: {
510: register char *tem;
511:
512: if (!compare_contin (line, name))
513: return 1;
514: /* This line starts an entry. Is it the right one? */
515: for (tem = line; *tem && *tem != '\n' && *tem != ':'; tem++)
516: if (*tem == '|' && !compare_contin (tem + 1, name))
517: return 1;
518:
519: return 0;
520: }
521:
522: static int
523: compare_contin (str1, str2)
524: register char *str1, *str2;
525: {
526: register int c1, c2;
527: while (1)
528: {
529: c1 = *str1++;
530: c2 = *str2++;
531: while (c1 == '\\' && *str1 == '\n')
532: {
533: str1++;
534: while ((c1 = *str1++) == ' ' || c1 == '\t');
535: }
536: if (c2 == '\0') /* end of type being looked up */
537: {
538: if (c1 == '|' || c1 == ':') /* If end of name in data base, */
539: return 0; /* we win. */
540: else
541: return 1;
542: }
543: else if (c1 != c2)
544: return 1;
545: }
546: }
547:
548: /* Make sure that the buffer <- `bufp' contains a full line
549: of the file open on `fd', starting at the place `bufp->ptr'
550: points to. Can read more of the file, discard stuff before
551: `bufp->ptr', or make the buffer bigger.
552:
553: Returns the pointer to after the newline ending the line,
554: or to the end of the file, if there is no newline to end it.
555:
556: Can also merge on continuation lines. If `append_end' is
557: nonzero, it points past the newline of a line that is
558: continued; we add another line onto it and regard the whole
559: thing as one line. The caller decides when a line is continued. */
560:
561: static char *
562: gobble_line (fd, bufp, append_end)
563: int fd;
564: register struct buffer *bufp;
565: char *append_end;
566: {
567: register char *end;
568: register int nread;
569: register char *buf = bufp->beg;
570: register char *tem;
571:
572: if (append_end == 0)
573: append_end = bufp->ptr;
574:
575: while (1)
576: {
577: end = append_end;
578: while (*end && *end != '\n') end++;
579: if (*end)
580: break;
581: if (bufp->ateof)
582: return buf + bufp->full;
583: if (bufp->ptr == buf)
584: {
585: if (bufp->full == bufp->size)
586: {
587: bufp->size *= 2;
588: /* Add 1 to size to ensure room for terminating null. */
589: tem = (char *) xrealloc (buf, bufp->size + 1);
590: bufp->ptr = (bufp->ptr - buf) + tem;
591: append_end = (append_end - buf) + tem;
592: bufp->beg = buf = tem;
593: }
594: }
595: else
596: {
597: append_end -= bufp->ptr - buf;
598: bcopy (bufp->ptr, buf, bufp->full -= bufp->ptr - buf);
599: bufp->ptr = buf;
600: }
601: if (!(nread = read (fd, buf + bufp->full, bufp->size - bufp->full)))
602: bufp->ateof = 1;
603: bufp->full += nread;
604: buf[bufp->full] = 0;
605: }
606: return end + 1;
607: }
608:
609: #ifdef TEST
610:
611: #include <stdio.h>
612:
613: main (argc, argv)
614: int argc;
615: char **argv;
616: {
617: char *term;
618: char *buf;
619:
620: term = argv[1];
621: printf ("TERM: %s\n", term);
622:
623: buf = (char *) tgetent (0, term);
624: if ((int) buf <= 0)
625: {
626: printf ("No entry.\n");
627: return 0;
628: }
629:
630: printf ("Entry: %s\n", buf);
631:
632: tprint ("cm");
633: tprint ("AL");
634:
635: printf ("co: %d\n", tgetnum ("co"));
636: printf ("am: %d\n", tgetflag ("am"));
637: }
638:
639: tprint (cap)
640: char *cap;
641: {
642: char *x = tgetstr (cap, 0);
643: register char *y;
644:
645: printf ("%s: ", cap);
646: if (x)
647: {
648: for (y = x; *y; y++)
649: if (*y <= ' ' || *y == 0177)
650: printf ("\\%0o", *y);
651: else
652: putchar (*y);
653: free (x);
654: }
655: else
656: printf ("none");
657: putchar ('\n');
658: }
659:
660: #endif /* TEST */
661:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.