diff options
Diffstat (limited to 'lib/libtermcap')
| -rw-r--r-- | lib/libtermcap/Makefile | 25 | ||||
| -rw-r--r-- | lib/libtermcap/TEST/tc1.c | 63 | ||||
| -rw-r--r-- | lib/libtermcap/TEST/tc2.c | 90 | ||||
| -rw-r--r-- | lib/libtermcap/TEST/tc3.c | 112 | ||||
| -rw-r--r-- | lib/libtermcap/pathnames.h | 36 | ||||
| -rw-r--r-- | lib/libtermcap/termcap.3 | 279 | ||||
| -rw-r--r-- | lib/libtermcap/termcap.c | 209 | ||||
| -rw-r--r-- | lib/libtermcap/termcap.h | 51 | ||||
| -rw-r--r-- | lib/libtermcap/tgoto.c | 207 | ||||
| -rw-r--r-- | lib/libtermcap/tparm.c | 752 | ||||
| -rw-r--r-- | lib/libtermcap/tputs.c | 123 |
11 files changed, 1947 insertions, 0 deletions
diff --git a/lib/libtermcap/Makefile b/lib/libtermcap/Makefile new file mode 100644 index 0000000..cd0ba38 --- /dev/null +++ b/lib/libtermcap/Makefile @@ -0,0 +1,25 @@ +# @(#)Makefile 8.1 (Berkeley) 6/4/93 + +LIB= termcap +CFLAGS+=-DCM_N -DCM_GT -DCM_B -DCM_D +SRCS= termcap.c tgoto.c tputs.c tparm.c + +MAN3= termcap.3 +MLINKS= termcap.3 tgetent.3 termcap.3 tgetflag.3 termcap.3 tgetnum.3 \ + termcap.3 tgetstr.3 termcap.3 tgoto.3 termcap.3 tputs.3 \ + termcap.3 tparm.3 +LINKS= ${LIBDIR}/libtermcap.a ${LIBDIR}/libtermlib.a +.if !defined(NOPIC) +LINKS+= ${SHLIBDIR}/libtermcap.so.${SHLIB_MAJOR}.${SHLIB_MINOR} \ + ${SHLIBDIR}/libtermlib.so.${SHLIB_MAJOR}.${SHLIB_MINOR} +.endif +.if !defined(NOPROFILE) +LINKS+= ${LIBDIR}/libtermcap_p.a ${LIBDIR}/libtermlib_p.a +.endif + +beforeinstall: + -cd ${.CURDIR}; cmp -s termcap.h ${DESTDIR}/usr/include/termcap.h || \ + install -c -o ${BINOWN} -g ${BINGRP} -m 444 termcap.h \ + ${DESTDIR}/usr/include + +.include <bsd.lib.mk> diff --git a/lib/libtermcap/TEST/tc1.c b/lib/libtermcap/TEST/tc1.c new file mode 100644 index 0000000..fd0870a --- /dev/null +++ b/lib/libtermcap/TEST/tc1.c @@ -0,0 +1,63 @@ +/*- + * Copyright (c) 1983, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char copyright[] = +"@(#) Copyright (c) 1983, 1993\n\ + The Regents of the University of California. All rights reserved.\n"; +#endif /* not lint */ + +#ifndef lint +static char sccsid[] = "@(#)tc1.c 8.1 (Berkeley) 6/4/93"; +#endif /* not lint */ + +/* + * tc1 [term] + * dummy program to test termlib. + * gets entry, counts it, and prints it. + */ +#include <stdio.h> +char buf[1024]; +char *getenv(); + +main(argc, argv) char **argv; { + char *p; + int rc; + + if (argc < 2) + p = getenv("TERM"); + else + p = argv[1]; + rc = tgetent(buf,p); + printf("tgetent returns %d, len=%d, text=\n'%s'\n",rc,strlen(buf),buf); +} diff --git a/lib/libtermcap/TEST/tc2.c b/lib/libtermcap/TEST/tc2.c new file mode 100644 index 0000000..1db9d00 --- /dev/null +++ b/lib/libtermcap/TEST/tc2.c @@ -0,0 +1,90 @@ +/*- + * Copyright (c) 1983, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char copyright[] = +"@(#) Copyright (c) 1983, 1993\n\ + The Regents of the University of California. All rights reserved.\n"; +#endif /* not lint */ + +#ifndef lint +static char sccsid[] = "@(#)tc2.c 8.1 (Berkeley) 6/4/93"; +#endif /* not lint */ + +/* + * tc2 [term] + * Dummy program to test out termlib. + * Commands are "tcc\n" where t is type (s for string, f for flag, + * or n for number) and cc is the name of the capability. + */ +#include <stdio.h> +char buf[1024]; +char *getenv(), *tgetstr(); + +main(argc, argv) char **argv; { + char *p, *q; + int rc; + char b[3], c; + char area[200]; + + if (argc < 2) + p = getenv("TERM"); + else + p = argv[1]; + rc = tgetent(buf,p); + for (;;) { + c = getchar(); + if (c < 0) + exit(0); + b[0] = getchar(); + if (b[0] < ' ') + exit(0); + b[1] = getchar(); + b[2] = 0; + getchar(); + switch(c) { + case 'f': + printf("%s: %d\n",b,tgetflag(b)); + break; + case 'n': + printf("%s: %d\n",b,tgetnum(b)); + break; + case 's': + q = area; + printf("%s: %s\n",b,tgetstr(b,&q)); + break; + default: + exit(0); + } + } +} diff --git a/lib/libtermcap/TEST/tc3.c b/lib/libtermcap/TEST/tc3.c new file mode 100644 index 0000000..3935e10 --- /dev/null +++ b/lib/libtermcap/TEST/tc3.c @@ -0,0 +1,112 @@ +/*- + * Copyright (c) 1983, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char copyright[] = +"@(#) Copyright (c) 1983, 1993\n\ + The Regents of the University of California. All rights reserved.\n"; +#endif /* not lint */ + +#ifndef lint +static char sccsid[] = "@(#)tc3.c 8.1 (Berkeley) 6/4/93"; +#endif /* not lint */ + +/* + * tc3 [term] + * Dummy program to test out termlib. Input two numbers (row and col) + * and it prints out the tgoto string generated. + */ +#include <stdio.h> +char buf[1024]; +char *getenv(), *tgetstr(); +char *rdchar(); +char *tgoto(); +char *CM; +char cmbuff[30]; +char *x; +char *UP; +char *tgout; + +main(argc, argv) char **argv; { + char *p; + int rc; + int row, col; + + if (argc < 2) + p = getenv("TERM"); + else + p = argv[1]; + rc = tgetent(buf,p); + x = cmbuff; + UP = tgetstr("up", &x); + printf("UP = %x = ", UP); pr(UP); printf("\n"); + if (UP && *UP==0) + UP = 0; + CM = tgetstr("cm", &x); + printf("CM = "); pr(CM); printf("\n"); + for (;;) { + if (scanf("%d %d", &row, &col) < 2) + exit(0); + tgout = tgoto(CM, col, row); + pr(tgout); + printf("\n"); + } +} + +pr(p) +register char *p; +{ + for (; *p; p++) + printf("%s", rdchar(*p)); +} + +/* + * rdchar() returns a readable representation of an ASCII character + * using ^ for control, ' for meta. + */ +#include <ctype.h> +char *rdchar(c) +char c; +{ + static char ret[4]; + register char *p = ret; + + if ((c&0377) > 0177) + *p++ = '\''; + c &= 0177; + if (!isprint(c)) + *p++ = '^'; + *p++ = (isprint(c) ? c : c^0100); + *p = 0; + return (ret); +} diff --git a/lib/libtermcap/pathnames.h b/lib/libtermcap/pathnames.h new file mode 100644 index 0000000..db3ccf7 --- /dev/null +++ b/lib/libtermcap/pathnames.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 1989, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)pathnames.h 8.1 (Berkeley) 6/4/93 + */ + +#define _PATH_DEF ".termcap /usr/share/misc/termcap" diff --git a/lib/libtermcap/termcap.3 b/lib/libtermcap/termcap.3 new file mode 100644 index 0000000..861bc24 --- /dev/null +++ b/lib/libtermcap/termcap.3 @@ -0,0 +1,279 @@ +.\" Copyright (c) 1980, 1991, 1993 +.\" The Regents of the University of California. All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. All advertising materials mentioning features or use of this software +.\" must display the following acknowledgement: +.\" This product includes software developed by the University of +.\" California, Berkeley and its contributors. +.\" 4. Neither the name of the University nor the names of its contributors +.\" may be used to endorse or promote products derived from this software +.\" without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" @(#)termcap.3 8.2 (Berkeley) 12/11/93 +.\" +.Dd December 11, 1993 +.Dt TERMCAP 3 +.Os BSD 4 +.Sh NAME +.Nm tgetent , +.Nm tgetnum , +.Nm tgetflag , +.Nm tgetstr , +.Nm tgoto , +.Nm tputs , +.Nm tparm +.Nd terminal independent operation routines +.Sh SYNOPSIS +.Fd #include <termcap.h> +.Vt char PC; +.Vt char *BC; +.Vt char *UP; +.Vt short ospeed; +.Ft int +.Fn tgetent "char *bp" "const char *name" +.Ft int +.Fn tgetnum "const char *id" +.Ft int +.Fn tgetflag "const char *id" +.Ft char * +.Fn tgetstr "const char *id" "char **area" +.Ft char * +.Fn tgoto "const char *cm" "int destcol" "int destline" +.Ft int +.Fn tputs "const char *cp" "int affcnt" "int (*outc)(int)" +.Ft char * +.Fn tparm "const char *cp" "..." +.Sh DESCRIPTION +These functions extract and use capabilities from a terminal capability data +base, usually +.Pa /usr/share/misc/termcap , +the format of which is described in +.Xr termcap 5 . +These are low level routines; +see +.Xr curses 3 +for a higher level package. +.Pp +The +.Fn tgetent +function +extracts the entry for terminal +.Fa name +into the buffer at +.Fa bp . +The +.Fa bp +argument +should be a character buffer of size +1024 and must be retained through all subsequent calls to +.Fn tgetnum , +.Fn tgetflag , +and +.Fn tgetstr . +The +.Fn tgetent +function +returns \-1 if none of the +.Nm termcap +data base files could be opened, +0 if the terminal name given does not have an entry, +and 1 if all goes well. +It will look in the environment for a +.Ev TERMCAP +variable. +If found, and the value does not begin with a slash, +and the terminal type +.Fa name +is the same as the environment string +.Ev TERM , +the +.Ev TERMCAP +string is used instead of reading a +.Nm termcap +file. +If it does begin with a slash, the string is used as a path name +of the +.Nm termcap +file to search. +If +.Ev TERMCAP +does not begin with a slash and +.Fa name +is different from +.Ev TERM , +.Fn tgetent +searches the files +.Pa $HOME/.termcap +and +.Pa /usr/share/misc/termcap , +in that order, unless the environment variable +.Ev TERMPATH +exists, +in which case it specifies a list of file pathnames +(separated by spaces or colons) to be searched instead. +Whenever multiple files are searched and a +.Sy tc +field occurs in the requested entry, the entry it names must be found +in the same file or one of the succeeding files. +This can speed up entry into programs that call +.Fn tgetent , +as well as help debug new terminal descriptions +or make one for your terminal if you can't write the file +.Pa /usr/share/misc/termcap . +.Pp +The +.Fn tgetnum +function +gets the numeric value of capability +.Fa id , +returning \-1 if it is not given for the terminal. +The +.Fn tgetflag +function +returns 1 if the specified capability is present in +the terminal's entry, 0 if it is not. +The +.Fn tgetstr +function +returns the string value of the capability +.Fa id , +places it in the buffer at +.Fa area , +and advances the +.Fa area +pointer. +It decodes the abbreviations for this field described in +.Xr termcap 5 , +except for cursor addressing and padding information. +The +.Fn tgetstr +function +returns +.Dv NULL +if the capability was not found. +.Pp +The +.Fn tgoto +function +returns a cursor addressing string decoded from +.Fa cm +to go to column +.Fa destcol +in line +.Fa destline . +It uses the external variables +.Va UP +(from the +.Sy up +capability) +and +.Va BC +(if +.Sy bc +is given rather than +.Sy bs ) +if necessary to avoid placing +.Sy \en , +.Sy ^D +or +.Sy ^@ +in +the returned string. +(Programs which call +.Fn tgoto +should be sure to turn off the +.Dv XTABS +bit(s), +since +.Fn tgoto +may now output a tab. +Note that programs using termcap should in general turn off +.Dv XTABS +anyway since some terminals use control-I for other functions, +such as nondestructive space.) +If a +.Sy % +sequence is given which is not understood, then +.Fn tgoto +returns +.Pq Dv OOPS . +.Pp +The +.Fn tputs +function +decodes the leading padding information of the string +.Fa cp ; +.Fa affcnt +gives the number of lines affected by the operation, or 1 if this is +not applicable, +.Fa outc +is a routine which is called with each character in turn. +The external variable +.Va ospeed +should contain the output speed of the terminal as encoded by +.Xr stty 3 . +The external variable +.Va PC +should contain a pad character to be used (from the +.SY pc +capability) +if a null +.Pq Sy ^@ +is inappropriate. +.Pp +The +.Fn tparm +function +instantiates the string +.Fa cp +with given parameters. +A pointer is returned which points to +the result of +.Fa cp +with the parameters applied. +If a +.Sy % +sequence is given which is not understood, then +.Fn tparm +returns +.Pq Dv OOPS . +.Sh FILES +.Bl -tag -width /usr/share/misc/termcap -compact +.It Pa /usr/lib/libtermcap.a +.Fl l Ar ltermcap +library (also known as +.Fl l Ar ltermlib ) +.It Pa /usr/share/misc/termcap +standard terminal capability data base +.It Pa $HOME/.termcap +user's terminal capability data base +.El +.Sh SEE ALSO +.Xr ex 1 , +.Xr curses 3 , +.Xr termcap 5 +.Sh HISTORY +The +.Nm +functions appeared in +.Bx 4.0 . diff --git a/lib/libtermcap/termcap.c b/lib/libtermcap/termcap.c new file mode 100644 index 0000000..51f0288 --- /dev/null +++ b/lib/libtermcap/termcap.c @@ -0,0 +1,209 @@ +/* + * Copyright (c) 1980, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char sccsid[] = "@(#)termcap.c 8.1 (Berkeley) 6/4/93"; +#endif /* not lint */ + +#define PBUFSIZ 512 /* max length of filename path */ +#define PVECSIZ 32 /* max number of names in path */ + +#include <stdio.h> +#include <ctype.h> +#include <stdlib.h> +#include <string.h> +#include "pathnames.h" + +/* + * termcap - routines for dealing with the terminal capability data base + * + * BUG: Should use a "last" pointer in tbuf, so that searching + * for capabilities alphabetically would not be a n**2/2 + * process when large numbers of capabilities are given. + * Note: If we add a last pointer now we will screw up the + * tc capability. We really should compile termcap. + * + * Essentially all the work here is scanning and decoding escapes + * in string capabilities. We don't use stdio because the editor + * doesn't, and because living w/o it is not hard. + */ + +static char *tbuf; /* termcap buffer */ + +/* + * Get an entry for terminal name in buffer bp from the termcap file. + */ +int +tgetent(bp, name) + char *bp, *name; +{ + register char *p; + register char *cp; + char *dummy; + char **fname; + char *home; + int i; + char pathbuf[PBUFSIZ]; /* holds raw path of filenames */ + char *pathvec[PVECSIZ]; /* to point to names in pathbuf */ + char **pvec; /* holds usable tail of path vector */ + char *termpath; + + dummy = NULL; + fname = pathvec; + pvec = pathvec; + tbuf = bp; + p = pathbuf; + cp = getenv("TERMCAP"); + /* + * TERMCAP can have one of two things in it. It can be the + * name of a file to use instead of /etc/termcap. In this + * case it better start with a "/". Or it can be an entry to + * use so we don't have to read the file. In this case it + * has to already have the newlines crunched out. If TERMCAP + * does not hold a file name then a path of names is searched + * instead. The path is found in the TERMPATH variable, or + * becomes "$HOME/.termcap /etc/termcap" if no TERMPATH exists. + */ + if (!cp || *cp != '/') { /* no TERMCAP or it holds an entry */ + if (termpath = getenv("TERMPATH")) + strncpy(pathbuf, termpath, PBUFSIZ); + else { + if (home = getenv("HOME")) { /* set up default */ + p += strlen(home); /* path, looking in */ + strcpy(pathbuf, home); /* $HOME first */ + *p++ = '/'; + } /* if no $HOME look in current directory */ + strncpy(p, _PATH_DEF, PBUFSIZ - (p - pathbuf)); + } + } + else /* user-defined name in TERMCAP */ + strncpy(pathbuf, cp, PBUFSIZ); /* still can be tokenized */ + + *fname++ = pathbuf; /* tokenize path into vector of names */ + while (*++p) + if (*p == ' ' || *p == ':') { + *p = '\0'; + while (*++p) + if (*p != ' ' && *p != ':') + break; + if (*p == '\0') + break; + *fname++ = p; + if (fname >= pathvec + PVECSIZ) { + fname--; + break; + } + } + *fname = (char *) 0; /* mark end of vector */ + if (cp && *cp && *cp != '/') + if (cgetset(cp) < 0) + return(-2); + + i = cgetent(&dummy, pathvec, name); + + if (i == 0) + strcpy(bp, dummy); + + if (dummy) + free(dummy); + /* no tc reference loop return code in libterm XXX */ + if (i == -3) + return(-1); + return(i + 1); +} + +/* + * Return the (numeric) option id. + * Numeric options look like + * li#80 + * i.e. the option string is separated from the numeric value by + * a # character. If the option is not found we return -1. + * Note that we handle octal numbers beginning with 0. + */ +int +tgetnum(id) + char *id; +{ + long num; + + if (cgetnum(tbuf, id, &num) == 0) + return(num); + else + return(-1); +} + +/* + * Handle a flag option. + * Flag options are given "naked", i.e. followed by a : or the end + * of the buffer. Return 1 if we find the option, or 0 if it is + * not given. + */ +int +tgetflag(id) + char *id; +{ + return(cgetcap(tbuf, id, ':') != NULL); +} + +/* + * Get a string valued option. + * These are given as + * cl=^Z + * Much decoding is done on the strings, and the strings are + * placed in area, which is a ref parameter which is updated. + * No checking on area overflow. + */ +char * +tgetstr(id, area) + char *id, **area; +{ + char ids[3]; + char *s; + int i; + + /* + * XXX + * This is for all the boneheaded programs that relied on tgetstr + * to look only at the first 2 characters of the string passed... + */ + *ids = *id; + ids[1] = id[1]; + ids[2] = '\0'; + + if ((i = cgetstr(tbuf, ids, &s)) < 0) + return NULL; + + strcpy(*area, s); + *area += i + 1; + return(s); +} diff --git a/lib/libtermcap/termcap.h b/lib/libtermcap/termcap.h new file mode 100644 index 0000000..7cd1f06 --- /dev/null +++ b/lib/libtermcap/termcap.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 1994 by Andrew A. Chernov, Moscow, Russia. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* $Id: termcap.h,v 1.3 1994/12/09 21:55:52 ache Exp $ */ + +#ifndef _TERMCAP_H_ +#define _TERMCAP_H_ + +#include <sys/cdefs.h> + +__BEGIN_DECLS + +extern char PC, *UP, *BC; +extern short ospeed; + +extern int tgetent __P((char *, const char *)); +extern int tgetflag __P((const char *)); +extern int tgetnum __P((const char *)); +extern char *tgetstr __P((const char *, char **)); + +extern int tputs __P((const char *, int, int (*)(int))); + +extern char *tgoto __P((const char *, int, int)); +extern char *tparm __P((const char *, ...)); + +__END_DECLS + +#endif /* _TERMCAP_H_ */ diff --git a/lib/libtermcap/tgoto.c b/lib/libtermcap/tgoto.c new file mode 100644 index 0000000..f0e4cc4 --- /dev/null +++ b/lib/libtermcap/tgoto.c @@ -0,0 +1,207 @@ +/* + * Copyright (c) 1980, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char sccsid[] = "@(#)tgoto.c 8.1 (Berkeley) 6/4/93"; +#endif /* not lint */ + +#define CTRL(c) ((c) & 037) + +#define MAXRETURNSIZE 64 + +char *UP; +char *BC; + +/* + * Routine to perform cursor addressing. + * CM is a string containing printf type escapes to allow + * cursor addressing. We start out ready to print the destination + * line, and switch each time we print row or column. + * The following escapes are defined for substituting row/column: + * + * %d as in printf + * %2 like %2d + * %3 like %3d + * %. gives %c hacking special case characters + * %+x like %c but adding x first + * + * The codes below affect the state but don't use up a value. + * + * %>xy if value > x add y + * %r reverses row/column + * %i increments row/column (for one origin indexing) + * %% gives % + * %B BCD (2 decimal digits encoded in one byte) + * %D Delta Data (backwards bcd) + * + * all other characters are ``self-inserting''. + */ +char * +tgoto(CM, destcol, destline) + char *CM; + int destcol, destline; +{ + static char result[MAXRETURNSIZE]; + static char added[10]; + char *cp = CM; + register char *dp = result; + register int c; + int oncol = 0; + register int which = destline; + + if (cp == 0) { +toohard: + /* + * ``We don't do that under BOZO's big top'' + */ + return ("OOPS"); + } + added[0] = 0; + while (c = *cp++) { + if (c != '%') { + *dp++ = c; + continue; + } + switch (c = *cp++) { + +#ifdef CM_N + case 'n': + destcol ^= 0140; + destline ^= 0140; + goto setwhich; +#endif + + case 'd': + if (which < 10) + goto one; + if (which < 100) + goto two; + /* fall into... */ + + case '3': + *dp++ = (which / 100) | '0'; + which %= 100; + /* fall into... */ + + case '2': +two: + *dp++ = which / 10 | '0'; +one: + *dp++ = which % 10 | '0'; +swap: + oncol = 1 - oncol; +setwhich: + which = oncol ? destcol : destline; + continue; + +#ifdef CM_GT + case '>': + if (which > *cp++) + which += *cp++; + else + cp++; + continue; +#endif + + case '+': + which += *cp++; + /* fall into... */ + + case '.': +casedot: + /* + * This code is worth scratching your head at for a + * while. The idea is that various weird things can + * happen to nulls, EOT's, tabs, and newlines by the + * tty driver, arpanet, and so on, so we don't send + * them if we can help it. + * + * Tab is taken out to get Ann Arbors to work, otherwise + * when they go to column 9 we increment which is wrong + * because bcd isn't continuous. We should take out + * the rest too, or run the thing through more than + * once until it doesn't make any of these, but that + * would make termlib (and hence pdp-11 ex) bigger, + * and also somewhat slower. This requires all + * programs which use termlib to stty tabs so they + * don't get expanded. They should do this anyway + * because some terminals use ^I for other things, + * like nondestructive space. + */ + if (which == 0 || which == CTRL('d') || /* which == '\t' || */ which == '\n') { + if (oncol || UP) /* Assumption: backspace works */ + /* + * Loop needed because newline happens + * to be the successor of tab. + */ + do { + strcat(added, oncol ? (BC ? BC : "\b") : UP); + which++; + } while (which == '\n'); + } + *dp++ = which; + goto swap; + + case 'r': + oncol = 1; + goto setwhich; + + case 'i': + destcol++; + destline++; + which++; + continue; + + case '%': + *dp++ = c; + continue; + +#ifdef CM_B + case 'B': + which = (which/10 << 4) + which%10; + continue; +#endif + +#ifdef CM_D + case 'D': + which = which - 2 * (which%16); + continue; +#endif + + default: + goto toohard; + } + } + strcpy(dp, added); + return (result); +} diff --git a/lib/libtermcap/tparm.c b/lib/libtermcap/tparm.c new file mode 100644 index 0000000..96cbe3d --- /dev/null +++ b/lib/libtermcap/tparm.c @@ -0,0 +1,752 @@ +/* + * tparm.c + * + * By Ross Ridge + * Public Domain + * 92/02/01 07:30:36 + * + */ + +#include <ctype.h> +#include <stdarg.h> +#include <stdio.h> +#include <string.h> + +#ifdef USE_SCCS_IDS +static const char SCCSid[] = "@(#) mytinfo tparm.c 3.2 92/02/01 public domain, By Ross Ridge"; +#endif + +#ifndef MAX_PUSHED +#define MAX_PUSHED 32 +#endif + +#define ARG 1 +#define NUM 2 + +#define INTEGER 1 +#define STRING 2 + +#define MAX_LINE 640 + +typedef void* anyptr; + +typedef struct stack_str { + int type; + int argnum; + int value; +} stack; + +static stack S[MAX_PUSHED]; +static stack vars['z'-'a'+1]; +static int pos = 0; + +static struct arg_str { + int type; + int integer; + char *string; +} arg_list[10]; + +static int argcnt; + +static va_list tparm_args; + +static int +pusharg(arg) +int arg; { + if (pos == MAX_PUSHED) + return 1; + S[pos].type = ARG; + S[pos++].argnum = arg; + return 0; +} + +static int +pushnum(num) +int num; { + if (pos == MAX_PUSHED) + return 1; + S[pos].type = NUM; + S[pos++].value = num; + return 0; +} + +/* VARARGS2 */ +static int +getarg(argnum, type, p) +int argnum, type; +anyptr p; { + while (argcnt < argnum) { + arg_list[argcnt].type = INTEGER; + arg_list[argcnt++].integer = (int) va_arg(tparm_args, int); + } + if (argcnt > argnum) { + if (arg_list[argnum].type != type) + return 1; + else if (type == STRING) + *(char **)p = arg_list[argnum].string; + else + *(int *)p = arg_list[argnum].integer; + } else { + arg_list[argcnt].type = type; + if (type == STRING) + *(char **)p = arg_list[argcnt++].string + = (char *) va_arg(tparm_args, char *); + else + *(int *)p = arg_list[argcnt++].integer = (int) va_arg(tparm_args, int); + } + return 0; +} + + +static int +popstring(str) +char **str; { + if (pos-- == 0) + return 1; + if (S[pos].type != ARG) + return 1; + return(getarg(S[pos].argnum, STRING, (anyptr) str)); +} + +static int +popnum(num) +int *num; { + if (pos-- == 0) + return 1; + switch (S[pos].type) { + case ARG: + return (getarg(S[pos].argnum, INTEGER, (anyptr) num)); + case NUM: + *num = S[pos].value; + return 0; + } + return 1; +} + +static int +cvtchar(sp, c) +register char *sp, *c; { + switch(*sp) { + case '\\': + switch(*++sp) { + case '\'': + case '$': + case '\\': + case '%': + *c = *sp; + return 2; + case '\0': + *c = '\\'; + return 1; + case '0': + if (sp[1] == '0' && sp[2] == '0') { + *c = '\0'; + return 4; + } + *c = '\200'; /* '\0' ???? */ + return 2; + default: + *c = *sp; + return 2; + } + default: + *c = *sp; + return 1; + } +} + +static int termcap; + +/* sigh... this has got to be the ugliest code I've ever written. + Trying to handle everything has its cost, I guess. + + It actually isn't to hard to figure out if a given % code is supposed + to be interpeted with its termcap or terminfo meaning since almost + all terminfo codes are invalid unless something has been pushed on + the stack and termcap strings will never push things on the stack + (%p isn't used by termcap). So where we have a choice we make the + decision by wether or not somthing has been pushed on the stack. + The static variable termcap keeps track of this; it starts out set + to 1 and is incremented as each argument processed by a termcap % code, + however if something is pushed on the stack it's set to 0 and the + rest of the % codes are interpeted as terminfo % codes. Another way + of putting it is that if termcap equals one we haven't decided either + way yet, if it equals zero we're looking for terminfo codes, and if + its greater than 1 we're looking for termcap codes. + + Terminfo % codes: + + %% output a '%' + %[[:][-+# ][width][.precision]][doxXs] + output pop according to the printf format + %c output pop as a char + %'c' push character constant c. + %{n} push decimal constant n. + %p[1-9] push paramter [1-9] + %g[a-z] push variable [a-z] + %P[a-z] put pop in variable [a-z] + %l push the length of pop (a string) + %+ add pop to pop and push the result + %- subtract pop from pop and push the result + %* multiply pop and pop and push the result + %& bitwise and pop and pop and push the result + %| bitwise or pop and pop and push the result + %^ bitwise xor pop and pop and push the result + %~ push the bitwise not of pop + %= compare if pop and pop are equal and push the result + %> compare if pop is less than pop and push the result + %< compare if pop is greater than pop and push the result + %A logical and pop and pop and push the result + %O logical or pop and pop and push the result + %! push the logical not of pop + %? condition %t if_true [%e if_false] %; + if condtion evaulates as true then evaluate if_true, + else evaluate if_false. elseif's can be done: +%? cond %t true [%e cond2 %t true2] ... [%e condN %t trueN] [%e false] %; + %i add one to parameters 1 and 2. (ANSI) + + Termcap Codes: + + %% output a % + %. output parameter as a character + %d output parameter as a decimal number + %2 output parameter in printf format %02d + %3 output parameter in printf format %03d + %+x add the character x to parameter and output it as a character +(UW) %-x subtract parameter FROM the character x and output it as a char +(UW) %ax add the character x to parameter +(GNU) %a[+*-/=][cp]x + GNU arithmetic. +(UW) %sx subtract parameter FROM the character x + %>xy if parameter > character x then add character y to parameter + %B convert to BCD (parameter = (parameter/10)*16 + parameter%16) + %D Delta Data encode (parameter = parameter - 2*(paramter%16)) + %i increment the first two parameters by one + %n xor the first two parameters by 0140 +(GNU) %m xor the first two parameters by 0177 + %r swap the first two parameters +(GNU) %b backup to previous parameter +(GNU) %f skip this parameter + + Note the two definitions of %a, the GNU defintion is used if the characters + after the 'a' are valid, otherwise the UW definition is used. + + (GNU) used by GNU Emacs termcap libraries + (UW) used by the University of Waterloo (MFCF) termcap libraries + +*/ + +char *tparm(const char *str, ...) { + static char OOPS[] = "OOPS"; + static char buf[MAX_LINE]; + register const char *sp; + register char *dp; + register char *fmt; + char conv_char; + char scan_for; + int scan_depth = 0, if_depth; + static int i, j; + static char *s, c; + char fmt_buf[MAX_LINE]; + char sbuf[MAX_LINE]; + + va_start(tparm_args, str); + + sp = str; + dp = buf; + scan_for = 0; + if_depth = 0; + argcnt = 0; + pos = 0; + termcap = 1; + while(*sp != '\0') { + switch(*sp) { + case '\\': + if (scan_for) { + if (*++sp != '\0') + sp++; + break; + } + *dp++ = *sp++; + if (*sp != '\0') + *dp++ = *sp++; + break; + case '%': + sp++; + if (scan_for) { + if (*sp == scan_for && if_depth == scan_depth) { + if (scan_for == ';') + if_depth--; + scan_for = 0; + } else if (*sp == '?') + if_depth++; + else if (*sp == ';') { + if (if_depth == 0) + return OOPS; + else + if_depth--; + } + sp++; + break; + } + fmt = NULL; + switch(*sp) { + case '%': + *dp++ = *sp++; + break; + case '+': + if (!termcap) { + if (popnum(&j) || popnum(&i)) + return OOPS; + i += j; + if (pushnum(i)) + return OOPS; + sp++; + break; + } + ;/* FALLTHROUGH */ + case 'C': + if (*sp == 'C') { + if (getarg(termcap - 1, INTEGER, &i)) + return OOPS; + if (i >= 96) { + i /= 96; + if (i == '$') + *dp++ = '\\'; + *dp++ = i; + } + } + fmt = "%c"; + /* FALLTHROUGH */ + case 'a': + if (!termcap) + return OOPS; + if (getarg(termcap - 1, INTEGER, (anyptr) &i)) + return OOPS; + if (*++sp == '\0') + return OOPS; + if ((sp[1] == 'p' || sp[1] == 'c') + && sp[2] != '\0' && fmt == NULL) { + /* GNU aritmitic parameter, what they + realy need is terminfo. */ + int val, lc; + if (sp[1] == 'p' + && getarg(termcap - 1 + sp[2] - '@', + INTEGER, (anyptr) &val)) + return OOPS; + if (sp[1] == 'c') { + lc = cvtchar(sp + 2, &c) + 2; + /* Mask out 8th bit so \200 can be + used for \0 as per GNU doc's */ + val = c & 0177; + } else + lc = 2; + switch(sp[0]) { + case '=': + break; + case '+': + val = i + val; + break; + case '-': + val = i - val; + break; + case '*': + val = i * val; + break; + case '/': + val = i / val; + break; + default: + /* Not really GNU's %a after all... */ + lc = cvtchar(sp, &c); + val = c + i; + break; + } + arg_list[termcap - 1].integer = val; + sp += lc; + break; + } + sp += cvtchar(sp, &c); + arg_list[termcap - 1].integer = c + i; + if (fmt == NULL) + break; + sp--; + /* FALLTHROUGH */ + case '-': + if (!termcap) { + if (popnum(&j) || popnum(&i)) + return OOPS; + i -= j; + if (pushnum(i)) + return OOPS; + sp++; + break; + } + fmt = "%c"; + /* FALLTHROUGH */ + case 's': + if (termcap && (fmt == NULL || *sp == '-')) { + if (getarg(termcap - 1, INTEGER, &i)) + return OOPS; + if (*++sp == '\0') + return OOPS; + sp += cvtchar(sp, &c); + arg_list[termcap - 1].integer = c - i; + if (fmt == NULL) + break; + sp--; + } + if (!termcap) + return OOPS; + ;/* FALLTHROUGH */ + case '.': + if (termcap && fmt == NULL) + fmt = "%c"; + ;/* FALLTHROUGH */ + case 'd': + if (termcap && fmt == NULL) + fmt = "%d"; + ;/* FALLTHROUGH */ + case '2': + if (termcap && fmt == NULL) + fmt = "%02d"; + ;/* FALLTHROUGH */ + case '3': + if (termcap && fmt == NULL) + fmt = "%03d"; + ;/* FALLTHROUGH */ + case ':': case ' ': case '#': case 'u': + case 'x': case 'X': case 'o': case 'c': + case '0': case '1': case '4': case '5': + case '6': case '7': case '8': case '9': + if (fmt == NULL) { + if (termcap) + return OOPS; + if (*sp == ':') + sp++; + fmt = fmt_buf; + *fmt++ = '%'; + while(*sp != 's' && *sp != 'x' && *sp != 'X' && *sp != 'd' && *sp != 'o' && *sp != 'c' && *sp != 'u') { + if (*sp == '\0') + return OOPS; + *fmt++ = *sp++; + } + *fmt++ = *sp; + *fmt = '\0'; + fmt = fmt_buf; + } + conv_char = fmt[strlen(fmt) - 1]; + if (conv_char == 's') { + if (popstring(&s)) + return OOPS; + sprintf(sbuf, fmt, s); + } else { + if (termcap) { + if (getarg(termcap++ - 1, + INTEGER, &i)) + return OOPS; + } else + if (popnum(&i)) + return OOPS; + if (i == 0 && conv_char == 'c') + strcpy(sbuf, "\000"); + else + sprintf(sbuf, fmt, i); + } + sp++; + fmt = sbuf; + while(*fmt != '\0') { + if (*fmt == '$') + *dp++ = '\\'; + *dp++ = *fmt++; + } + break; + case 'r': + if (!termcap || getarg(1, INTEGER, &i)) + return OOPS; + arg_list[1].integer = arg_list[0].integer; + arg_list[0].integer = i; + sp++; + break; + case 'i': + if (getarg(1, INTEGER, &i) + || arg_list[0].type != INTEGER) + return OOPS; + arg_list[1].integer++; + arg_list[0].integer++; + sp++; + break; + case 'n': + if (!termcap || getarg(1, INTEGER, &i)) + return OOPS; + arg_list[0].integer ^= 0140; + arg_list[1].integer ^= 0140; + sp++; + break; + case '>': + if (!termcap) { + if (popnum(&j) || popnum(&i)) + return OOPS; + i = (i > j); + if (pushnum(i)) + return OOPS; + sp++; + break; + } + if (getarg(termcap-1, INTEGER, &i)) + return OOPS; + sp += cvtchar(sp, &c); + if (i > c) { + sp += cvtchar(sp, &c); + arg_list[termcap-1].integer += c; + } else + sp += cvtchar(sp, &c); + sp++; + break; + case 'B': + if (!termcap || getarg(termcap-1, INTEGER, &i)) + return OOPS; + arg_list[termcap-1].integer = 16*(i/10)+i%10; + sp++; + break; + case 'D': + if (!termcap || getarg(termcap-1, INTEGER, &i)) + return OOPS; + arg_list[termcap-1].integer = i - 2 * (i % 16); + sp++; + break; + case 'p': + if (termcap > 1) + return OOPS; + if (*++sp == '\0') + return OOPS; + if (*sp == '0') + i = 9; + else + i = *sp - '1'; + if (i < 0 || i > 9) + return OOPS; + if (pusharg(i)) + return OOPS; + termcap = 0; + sp++; + break; + case 'P': + if (termcap || *++sp == '\0') + return OOPS; + i = *sp++ - 'a'; + if (i < 0 || i > 25) + return OOPS; + if (pos-- == 0) + return OOPS; + switch(vars[i].type = S[pos].type) { + case ARG: + vars[i].argnum = S[pos].argnum; + break; + case NUM: + vars[i].value = S[pos].value; + break; + } + break; + case 'g': + if (termcap || *++sp == '\0') + return OOPS; + i = *sp++ - 'a'; + if (i < 0 || i > 25) + return OOPS; + switch(vars[i].type) { + case ARG: + if (pusharg(vars[i].argnum)) + return OOPS; + break; + case NUM: + if (pushnum(vars[i].value)) + return OOPS; + break; + } + break; + case '\'': + if (termcap > 1) + return OOPS; + if (*++sp == '\0') + return OOPS; + sp += cvtchar(sp, &c); + if (pushnum(c) || *sp++ != '\'') + return OOPS; + termcap = 0; + break; + case '{': + if (termcap > 1) + return OOPS; + i = 0; + sp++; + while(isdigit(*sp)) + i = 10 * i + *sp++ - '0'; + if (*sp++ != '}' || pushnum(i)) + return OOPS; + termcap = 0; + break; + case 'l': + if (termcap || popstring(&s)) + return OOPS; + i = strlen(s); + if (pushnum(i)) + return OOPS; + sp++; + break; + case '*': + if (termcap || popnum(&j) || popnum(&i)) + return OOPS; + i *= j; + if (pushnum(i)) + return OOPS; + sp++; + break; + case '/': + if (termcap || popnum(&j) || popnum(&i)) + return OOPS; + i /= j; + if (pushnum(i)) + return OOPS; + sp++; + break; + case 'm': + if (termcap) { + if (getarg(1, INTEGER, &i)) + return OOPS; + arg_list[0].integer ^= 0177; + arg_list[1].integer ^= 0177; + sp++; + break; + } + if (popnum(&j) || popnum(&i)) + return OOPS; + i %= j; + if (pushnum(i)) + return OOPS; + sp++; + break; + case '&': + if (popnum(&j) || popnum(&i)) + return OOPS; + i &= j; + if (pushnum(i)) + return OOPS; + sp++; + break; + case '|': + if (popnum(&j) || popnum(&i)) + return OOPS; + i |= j; + if (pushnum(i)) + return OOPS; + sp++; + break; + case '^': + if (popnum(&j) || popnum(&i)) + return OOPS; + i ^= j; + if (pushnum(i)) + return OOPS; + sp++; + break; + case '=': + if (popnum(&j) || popnum(&i)) + return OOPS; + i = (i == j); + if (pushnum(i)) + return OOPS; + sp++; + break; + case '<': + if (popnum(&j) || popnum(&i)) + return OOPS; + i = (i < j); + if (pushnum(i)) + return OOPS; + sp++; + break; + case 'A': + if (popnum(&j) || popnum(&i)) + return OOPS; + i = (i && j); + if (pushnum(i)) + return OOPS; + sp++; + break; + case 'O': + if (popnum(&j) || popnum(&i)) + return OOPS; + i = (i || j); + if (pushnum(i)) + return OOPS; + sp++; + break; + case '!': + if (popnum(&i)) + return OOPS; + i = !i; + if (pushnum(i)) + return OOPS; + sp++; + break; + case '~': + if (popnum(&i)) + return OOPS; + i = ~i; + if (pushnum(i)) + return OOPS; + sp++; + break; + case '?': + if (termcap > 1) + return OOPS; + termcap = 0; + if_depth++; + sp++; + break; + case 't': + if (popnum(&i) || if_depth == 0) + return OOPS; + if (!i) { + scan_for = 'e'; + scan_depth = if_depth; + } + sp++; + break; + case 'e': + if (if_depth == 0) + return OOPS; + scan_for = ';'; + scan_depth = if_depth; + sp++; + break; + case ';': + if (if_depth-- == 0) + return OOPS; + sp++; + break; + case 'b': + if (--termcap < 1) + return OOPS; + sp++; + break; + case 'f': + if (!termcap++) + return OOPS; + sp++; + break; + } + break; + default: + if (scan_for) + sp++; + else + *dp++ = *sp++; + break; + } + } + va_end(tparm_args); + *dp = '\0'; + return buf; +} diff --git a/lib/libtermcap/tputs.c b/lib/libtermcap/tputs.c new file mode 100644 index 0000000..857147d --- /dev/null +++ b/lib/libtermcap/tputs.c @@ -0,0 +1,123 @@ +/* + * Copyright (c) 1980, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static char sccsid[] = "@(#)tputs.c 8.1 (Berkeley) 6/4/93"; +#endif /* not lint */ + +#include <sgtty.h> +#include <ctype.h> + +/* + * The following array gives the number of tens of milliseconds per + * character for each speed as returned by gtty. Thus since 300 + * baud returns a 7, there are 33.3 milliseconds per char at 300 baud. + */ +static +short tmspc10[] = { + 0, 2000, 1333, 909, 743, 666, 500, 333, 166, 83, 55, 41, 20, 10, 5 +}; + +short ospeed; +char PC; + +/* + * Put the character string cp out, with padding. + * The number of affected lines is affcnt, and the routine + * used to output one character is outc. + */ +tputs(cp, affcnt, outc) + register char *cp; + int affcnt; + int (*outc)(); +{ + register int i = 0; + register int mspc10; + + if (cp == 0) + return; + + /* + * Convert the number representing the delay. + */ + if (isdigit(*cp)) { + do + i = i * 10 + *cp++ - '0'; + while (isdigit(*cp)); + } + i *= 10; + if (*cp == '.') { + cp++; + if (isdigit(*cp)) + i += *cp - '0'; + /* + * Only one digit to the right of the decimal point. + */ + while (isdigit(*cp)) + cp++; + } + + /* + * If the delay is followed by a `*', then + * multiply by the affected lines count. + */ + if (*cp == '*') + cp++, i *= affcnt; + + /* + * The guts of the string. + */ + while (*cp) + (*outc)(*cp++); + + /* + * If no delay needed, or output speed is + * not comprehensible, then don't try to delay. + */ + if (i == 0) + return; + if (ospeed <= 0 || ospeed >= (sizeof tmspc10 / sizeof tmspc10[0])) + return; + + /* + * Round up by a half a character frame, + * and then do the delay. + * Too bad there are no user program accessible programmed delays. + * Transmitting pad characters slows many + * terminals down and also loads the system. + */ + mspc10 = tmspc10[ospeed]; + i += mspc10 / 2; + for (i /= mspc10; i > 0; i--) + (*outc)(PC); +} |
