captoinfo - zygaena/hammerhead

root / base / usr / src / cmd / captoinfo
captoinfo Plain Text 2113 lines 50.5 KB
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#

#
# Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# Copyright (c) 2018, Joyent, Inc.

PROG= captoinfo

OBJS= captoinfo.o otermcap.o
SRCS= $(OBJS:%.o=%.c)

include ../Makefile.cmd

LDFLAGS +=	$(MAPFILE.INT:%=-Wl,-M%)
LDLIBS +=	-lcurses
CPPFLAGS +=	-I../../lib/libcurses/screen
CERRWARN +=	-Wno-parentheses

# code is a mess right now
SMATCH=off

.KEEP_STATE:

all: $(PROG)

$(PROG): $(OBJS) $(MAPFILE.INT)
	$(LINK.c) $(OBJS) -o $@ $(LDLIBS)
	$(POST_PROCESS)

install: all $(ROOTPROG)

clean:
	$(RM) $(OBJS)

include ../Makefile.targ
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1988 AT&T	*/
/*	  All Rights Reserved	*/

/*
 *  NAME
 *	captoinfo - convert a termcap description to a terminfo description
 *
 *  SYNOPSIS
 *	captoinfo [-1vV] [-w width] [ filename ... ]
 *
 *  AUTHOR
 *	Tony Hansen, January 22, 1984.
 */

#include "curses.h"
#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "otermcap.h"
#include "print.h"

#define	trace stderr			/* send trace messages to stderr */

/* extra termcap variables no longer in terminfo */
char *oboolcodes[] =
	{
	"bs",	/* Terminal can backspace with "^H" */
	"nc",	/* No correctly working carriage return (DM2500,H2000) */
	"ns",	/* Terminal is a CRT but does not scroll. */
	"pt",	/* Has hardware tabs (may need to be set with "is") */
	"MT",	/* Has meta key, alternate code. */
	"xr",	/* Return acts like ce \r \n (Delta Data) */
	0
};
int cap_bs = 0, cap_nc = 1, cap_ns = 2, cap_pt = 3, cap_MT = 4, cap_xr = 5;
char *onumcodes[] =
	{
	"dB",	/* Number of millisec of bs delay needed */
	"dC",	/* Number of millisec of cr delay needed */
	"dF",	/* Number of millisec of ff delay needed */
	"dN",	/* Number of millisec of nl delay needed */
	"dT",	/* Number of millisec of tab delay needed */
	"ug",	/* Number of blank chars left by us or ue */
/* Ignore the 'kn' number. It was ill-defined and never used. */
	"kn",	/* Number of "other" keys */
	0
};
int cap_dB = 0, cap_dC = 1, cap_dF = 2, cap_dN = 3, cap_dT = 4, cap_ug = 5;

char *ostrcodes[] =
	{
	"bc",	/* Backspace if not "^H" */
	"ko",	/* Termcap entries for other non-function keys */
	"ma",	/* Arrow key map, used by vi version 2 only */
	"nl",	/* Newline character (default "\n") */
	"rs",	/* undocumented reset string, like is (info is2) */
/* Ignore the 'ml' and 'mu' strings. */
	"ml",	/* Memory lock on above cursor. */
	"mu",	/* Memory unlock (turn off memory lock). */
	0
};
int cap_bc = 0, cap_ko = 1, cap_ma = 2, cap_nl = 3, cap_rs = 4;

#define	numelements(x)	(sizeof (x)/sizeof (x[0]))
char oboolval[2][numelements(oboolcodes)];
short onumval[2][numelements(onumcodes)];
char *ostrval[2][numelements(ostrcodes)];

/* externs from libcurses.a */
extern char *boolnames[], *boolcodes[];
extern char *numnames[], *numcodes[];
extern char *strnames[], *strcodes[];

/* globals for this file */
char *progname;			/* argv [0], the name of the program */
static char *term_name;		/* the name of the terminal being worked on */
static int uselevel;		/* whether we're dealing with use= info */
static int boolcount,		/* the maximum numbers of each name array */
	    numcount,
	    strcount;

/* globals dealing with the environment */
extern char **environ;
static char TERM[100];
#if defined(SYSV) || defined(USG)  /* handle both Sys Vr2 and Vr3 curses */
static char dirname[BUFSIZ];
#else
#include <sys/param.h>
static char dirname[MAXPATHLEN];
#endif /* SYSV || USG */
static char TERMCAP[BUFSIZ+15];
static char *newenviron[] = { &TERM[0], &TERMCAP[0], 0 };

/* dynamic arrays */
static char *boolval[2];	/* dynamic array of boolean values */
static short *numval[2];	/* dynamic array of numeric values */
static char **strval[2];	/* dynamic array of string pointers */

/* data buffers */
static char *capbuffer;		/* string table, pointed at by strval */
static char *nextstring;	/* pointer into string table */
static char *bp;		/* termcap raw string table */
static char *buflongname;	/* place to copy the long names */

/* flags */
static int verbose = 0;		/* debugging printing level */
static int copycomments = 0;	/* copy comments from tercap source */

#define	ispadchar(c)	(isdigit(c) || (c) == '.' || (c) == '*')

static void getlongname(void);
static void handleko(void);
static void handlema(void);
static void print_no_use_entry(void);
static void print_use_entry(char *);
static void captoinfo(void);
static void use_etc_termcap(void);
static void initdirname(void);
static void setfilename(char *);
static void setterm_name(void);
static void use_file(char *);
static void sorttable(char *[], char *[]);
static void inittables(void);

/*
 *  Verify that the names given in the termcap entry are all valid.
 */

int
capsearch(char *codes[], char *ocodes[], char *cap)
{
	for (; *codes; codes++)
		if (((*codes)[0] == cap[0]) && ((*codes)[1] == cap[1]))
			return (1);

	for (; *ocodes; ocodes++)
		if (((*ocodes)[0] == cap[0]) && ((*ocodes)[1] == cap[1]))
			return (1);

	return (0);
}

void
checktermcap()
{
	char *tbuf = bp;
	enum { tbool, tnum, tstr, tcancel, tunknown } type;

	for (;;) {
		tbuf = tskip(tbuf);
		while (*tbuf == '\t' || *tbuf == ' ' || *tbuf == ':')
			tbuf++;

		if (*tbuf == 0)
			return;

		/* commented out entry? */
		if (*tbuf == '.') {
			if (verbose)
				(void) fprintf(trace, "termcap string '%c%c' "
				    "commented out.\n", tbuf[1], tbuf[2]);
			if (!capsearch(boolcodes, oboolcodes, tbuf + 1) &&
			    !capsearch(numcodes, onumcodes, tbuf + 1) &&
			    !capsearch(strcodes, ostrcodes, tbuf + 1))
				(void) fprintf(stderr,
				    "%s: TERM=%s: commented out code '%.2s' "
				    "is unknown.\n", progname, term_name,
				    tbuf+1);
			continue;
		}

		if (verbose)
			(void) fprintf(trace, "looking at termcap string "
			    "'%.2s'.\n", tbuf);

		switch (tbuf[2]) {
			case ':': case '\0':	type = tbool;	break;
			case '#':			type = tnum;	break;
			case '=':			type = tstr;	break;
			case '@':			type = tcancel;	break;
			default:
				(void) fprintf(stderr,
				    "%s: TERM=%s: unknown type given for the "
				    "termcap code '%.2s'.\n", progname,
				    term_name, tbuf);
				type = tunknown;
		}

		if (verbose > 1)
			(void) fprintf(trace, "type of '%.2s' is %s.\n", tbuf,
			    (type == tbool) ? "boolean" :
			    (type == tnum) ? "numeric" :
			    (type = tstr) ? "string" :
			    (type = tcancel) ? "canceled" : "unknown");

		/* look for the name in bools */
		if (capsearch(boolcodes, oboolcodes, tbuf)) {
			if (type != tbool && type != tcancel)
				(void) fprintf(stderr,
				    "%s: TERM=%s: wrong type given for the "
				    "boolean termcap code '%.2s'.\n", progname,
				    term_name, tbuf);
			continue;
		}

		/* look for the name in nums */
		if (capsearch(numcodes, onumcodes, tbuf)) {
			if (type != tnum && type != tcancel)
				(void) fprintf(stderr,
				    "%s: TERM=%s: wrong type given for the "
				    "numeric termcap code '%.2s'.\n", progname,
				    term_name, tbuf);
			continue;
		}

		/* look for the name in strs */
		if (capsearch(strcodes, ostrcodes, tbuf)) {
			if (type != tstr && type != tcancel)
				(void) fprintf(stderr,
				    "%s: TERM=%s: wrong type given for the "
				    "string termcap code '%.2s'.\n", progname,
				    term_name, tbuf);
			continue;
		}

		(void) fprintf(stderr,
		    "%s: TERM=%s: the %s termcap code '%.2s' is not a valid "
		    "name.\n", progname, term_name,
		    (type == tbool) ? "boolean" :
		    (type == tnum) ? "numeric" :
		    (type = tstr) ? "string" :
		    (type = tcancel) ? "canceled" : "(unknown type)", tbuf);
	}
}

/*
 *  Fill up the termcap tables.
 */
int
filltables(void)
{
	int i, tret;

	/* Retrieve the termcap entry. */
	if ((tret = otgetent(bp, term_name)) != 1) {
		(void) fprintf(stderr,
		    "%s: TERM=%s: tgetent failed with return code %d (%s).\n",
		    progname, term_name, tret,
		    (tret == 0) ? "non-existent or invalid entry" :
		    (tret == -1) ? "cannot open $TERMCAP" : "unknown reason");
		return (0);
	}

	if (verbose) {
		(void) fprintf(trace, "bp=");
		(void) cpr(trace, bp);
		(void) fprintf(trace, ".\n");
	}

	if (uselevel == 0)
		checktermcap();

	/* Retrieve the values that are in terminfo. */

	/* booleans */
	for (i = 0; boolcodes[i]; i++) {
		boolval[uselevel][i] = otgetflag(boolcodes[i]);
		if (verbose > 1) {
			(void) fprintf(trace, "boolcodes=%s, ", boolcodes[i]);
			(void) fprintf(trace, "boolnames=%s, ", boolnames[i]);
			(void) fprintf(trace,
			    "flag=%d.\n", boolval[uselevel][i]);
		}
	}

	/* numbers */
	for (i = 0; numcodes[i]; i++) {
		numval[uselevel][i] = otgetnum(numcodes[i]);
		if (verbose > 1) {
			(void) fprintf(trace, "numcodes=%s, ", numcodes[i]);
			(void) fprintf(trace, "numnames=%s, ", numnames[i]);
			(void) fprintf(trace, "num=%d.\n", numval[uselevel][i]);
		}
	}

	if (uselevel == 0)
		nextstring = capbuffer;

	/* strings */
	for (i = 0; strcodes[i]; i++) {
		strval[uselevel][i] = otgetstr(strcodes[i], &nextstring);
		if (verbose > 1) {
			(void) fprintf(trace, "strcodes=%s, ", strcodes [i]);
			(void) fprintf(trace, "strnames=%s, ", strnames [i]);
			if (strval[uselevel][i]) {
				(void) fprintf(trace, "str=");
				tpr(trace, strval[uselevel][i]);
				(void) fprintf(trace, ".\n");
			}
		else
			(void) fprintf(trace, "str=NULL.\n");
		}
		/* remove zero length strings */
		if (strval[uselevel][i] && (strval[uselevel][i][0] == '\0')) {
			(void) fprintf(stderr,
			    "%s: TERM=%s: cap %s (info %s) is NULL: REMOVED\n",
			    progname, term_name, strcodes[i], strnames[i]);
			strval[uselevel][i] = NULL;
		}
	}

	/* Retrieve the values not found in terminfo anymore. */

	/* booleans */
	for (i = 0; oboolcodes[i]; i++) {
		oboolval[uselevel][i] = otgetflag(oboolcodes[i]);
		if (verbose > 1) {
			(void) fprintf(trace, "oboolcodes=%s, ",
			    oboolcodes[i]);
			(void) fprintf(trace, "flag=%d.\n",
			    oboolval[uselevel][i]);
		}
	}

	/* numbers */
	for (i = 0; onumcodes[i]; i++) {
		onumval[uselevel][i] = otgetnum(onumcodes[i]);
		if (verbose > 1) {
			(void) fprintf(trace, "onumcodes=%s, ", onumcodes[i]);
			(void) fprintf(trace, "num=%d.\n",
			    onumval[uselevel][i]);
		}
	}

	/* strings */
	for (i = 0; ostrcodes[i]; i++) {
		ostrval[uselevel][i] = otgetstr(ostrcodes[i], &nextstring);
		if (verbose > 1) {
			(void) fprintf(trace, "ostrcodes=%s, ", ostrcodes[i]);
			if (ostrval[uselevel][i]) {
				(void) fprintf(trace, "ostr=");
				tpr(trace, ostrval[uselevel][i]);
				(void) fprintf(trace, ".\n");
			}
			else
				(void) fprintf(trace, "ostr=NULL.\n");
		}
		/* remove zero length strings */
		if (ostrval[uselevel][i] && (ostrval[uselevel][i][0] == '\0')) {
			(void) fprintf(stderr,
			    "%s: TERM=%s: cap %s (no terminfo name) is NULL: "
			    "REMOVED\n", progname, term_name, ostrcodes[i]);
			ostrval[uselevel][i] = NULL;
		}
	}
	return (1);
}

/*
 *  This routine copies the set of names from the termcap entry into
 *  a separate buffer, getting rid of the old obsolete two character
 *  names.
 */
static void
getlongname(void)
{
	char *b = &bp[0],  *l = buflongname;

	/* Skip the two character name */
	if (bp[2] == '|')
		b = &bp[3];

	/* Copy the rest of the names */
	while (*b && *b != ':')
		*l++ = *b++;
	*l = '\0';

	if (b != &bp[0]) {
		(void) fprintf(stderr, "%s: obsolete 2 character name "
		    "'%2.2s' removed.\n", progname, bp);
		(void) fprintf(stderr, "\tsynonyms are: '%s'\n", buflongname);
	}
}

/*
 *  Return the value of the termcap string 'capname' as stored in our list.
 */
char *
getcapstr(char *capname)
{
	int i;

	if (verbose > 1)
		(void) fprintf(trace, "looking for termcap value of %s.\n",
		    capname);

	/* Check the old termcap list. */
	for (i = 0; ostrcodes[i]; i++)
		if (strcmp(ostrcodes[i], capname) == 0) {
			if (verbose > 1) {
				(void) fprintf(trace, "\tvalue is:");
				tpr(trace, ostrval[uselevel][i]);
				(void) fprintf(trace, ".\n");
			}
			return (ostrval[uselevel][i]);
		}

	if (verbose > 1)
		(void) fprintf(trace, "termcap name '%s' not found in "
		    "ostrcodes.\n", capname);

	/* Check the terminfo list. */
	for (i = 0; strcodes[i]; i++)
		if (strcmp(strcodes[i], capname) == 0) {
			if (verbose > 1) {
				(void) fprintf(trace, "\tvalue is:");
				tpr(trace, strval[uselevel][i]);
				(void) fprintf(trace, ".\n");
			}
			return (strval[uselevel][i]);
		}

	(void) fprintf(stderr, "%s: TERM=%s: termcap name '%s' not found.\n",
	    progname, term_name, capname);

	return ((char *)NULL);
}

/*
 *  Search for a name in the given table and
 *  return the index.
 *  Someday I'll redo this to use bsearch().
 */
/* ARGSUSED */
int
search(char *names[], int max, char *infoname)
{
#ifndef BSEARCH
	int i;
	for (i = 0; names [i] != NULL; i++)
		if (strcmp(names [i], infoname) == 0)
			return (i);
	return (-1);
#else				/* this doesn't work for some reason */
	char **bret;

	bret = (char **)bsearch(infoname, (char *)names, max,
	    sizeof (char *), strcmp);
	(void) fprintf(trace, "search looking for %s.\n", infoname);
	(void) fprintf(trace, "base=%#x, bret=%#x, nel=%d.\n", names,
	    bret, max);
	(void) fprintf(trace, "returning %d.\n", bret == NULL ? -1 :
	    bret - names);
	if (bret == NULL)
		return (-1);
	else
		return (bret - names);
#endif /* OLD */
}

/*
 *  return the value of the terminfo string 'infoname'
 */
char *
getinfostr(char *infoname)
{
	int i;

	if (verbose > 1)
		(void) fprintf(trace, "looking for terminfo value of %s.\n",
		    infoname);

	i = search(strnames, strcount, infoname);
	if (i != -1) {
		if (verbose > 1) {
			(void) fprintf(trace, "\tvalue is:");
			tpr(trace, strval[uselevel][i]);
			(void) fprintf(trace, ".\n");
		}
		return (strval[uselevel][i]);
	}

	if (verbose > 1)
		(void) fprintf(trace, "terminfo name '%s' not found.\n",
		    infoname);

	return ((char *)NULL);
}

/*
 *  Replace the value stored for the terminfo boolean
 *  capability 'infoname' with the newvalue.
 */
void
putbool(char *infoname, int newvalue)
{
	int i;

	if (verbose > 1)
		(void) fprintf(trace, "changing value for %s to %d.\n",
		    infoname, newvalue);

	i = search(boolnames, boolcount, infoname);
	if (i != -1) {
		if (verbose > 1)
			(void) fprintf(trace, "value was: %d.\n",
			    boolval[uselevel][i]);

		boolval[uselevel][i] = newvalue;
		return;
	}

	(void) fprintf(stderr, "%s: TERM=%s: the boolean name '%s' was not "
	    "found!\n", progname, term_name, infoname);
}

/*
 *  Replace the value stored for the terminfo number
 *  capability 'infoname' with the newvalue.
 */
void
putnum(char *infoname, int newvalue)
{
	int i;

	if (verbose > 1)
		(void) fprintf(trace, "changing value for %s to %d.\n",
		    infoname, newvalue);

	i = search(numnames, numcount, infoname);
	if (i != -1) {
		if (verbose > 1)
			(void) fprintf(trace, "value was: %d.\n",
			    numval[uselevel][i]);

		numval[uselevel][i] = newvalue;
		return;
	}

	(void) fprintf(stderr, "%s: TERM=%s: the numeric name '%s' was not "
	    "found!\n",
	    progname, term_name, infoname);
}

/*
 *  replace the value stored for the terminfo string capability 'infoname'
 *  with the newvalue.
 */
void
putstr(char *infoname, char *newvalue)
{
	int i;

	if (verbose > 1) {
		(void) fprintf(trace, "changing value for %s to ", infoname);
		tpr(trace, newvalue);
		(void) fprintf(trace, ".\n");
	}

	i = search(strnames, strcount, infoname);
	if (i != -1) {
		if (verbose > 1) {
			(void) fprintf(trace, "value was:");
			tpr(trace, strval[uselevel][i]);
			(void) fprintf(trace, ".\n");
		}
		strval[uselevel][i] = nextstring;
		while (*newvalue)
			*nextstring++ = *newvalue++;
		*nextstring++ = '\0';
		return;
	}

	(void) fprintf(stderr, "%s: TERM=%s: the string name '%s' was not "
	    "found!\n",
	    progname, term_name, infoname);
}

/*
 *  Add in extra delays if they are not recorded already.
 *  This is done before the padding information has been modified by
 *  changecalculations() below, so the padding information, if there
 *  already, is still at the beginning of the string in termcap format.
 */
void
addpadding(int cappadding, char *infostr)
{
	char *cap;
	char tempbuffer [100];

	/* Is there padding to add? */
	if (cappadding > 0)
	/* Is there a string to add it to? */
		if (cap = getinfostr(infostr))
		/* Is there any padding info already? */
			if (ispadchar(*cap)) {
				/* EMPTY */;
		/* Assume that the padding info that is there is correct. */
			} else {
		/* Add the padding at the end of the present string. */
				(void) snprintf(tempbuffer, sizeof (tempbuffer),
				    "%s$<%d>", cap, cappadding);
				putstr(infostr, tempbuffer);
		} else {
			/* Create a new string that only has the padding. */
			(void) sprintf(tempbuffer, "$<%d>", cappadding);
			putstr(infostr, tempbuffer);
		}
}

struct
	{
	char *capname;
	char *keyedinfoname;
	} ko_map[] = {
	"al",		"kil1",
	"bs",		"kbs",		/* special addition */
	"bt",		"kcbt",
	"cd",		"ked",
	"ce",		"kel",
	"cl",		"kclr",
	"ct",		"ktbc",
	"dc",		"kdch1",
	"dl",		"kdl1",
	"do",		"kcud1",
	"ei",		"krmir",
	"ho",		"khome",
	"ic",		"kich1",
	"im",		"kich1",	/* special addition */
	"le",		"kcub1",
	"ll",		"kll",
	"nd",		"kcuf1",
	"sf",		"kind",
	"sr",		"kri",
	"st",		"khts",
	"up",		"kcuu1",
/*	"",		"kctab",	*/
/*	"",		"knp",		*/
/*	"",		"kpp",		*/
	0,		0
	};

/*
 *  Work with the ko string. It is a comma separated list of keys for which
 *  the keyboard has a key by the same name that emits the same sequence.
 *  For example, ko = dc, im, ei means that there are keys called
 *  delete-character, enter-insert-mode and exit-insert-mode on the keyboard,
 *  and they emit the same sequences as specified in the dc, im and ei
 *  capabilities.
 */
static void
handleko(void)
{
	char capname[3];
	char *capstr;
	int i, j, found;
	char *infostr;

	if (verbose > 1)
		(void) fprintf(trace, "working on termcap ko string.\n");

	if (ostrval[uselevel][cap_ko] == NULL)
		return;

	capname[2] = '\0';
	for (i = 0; ostrval[uselevel][cap_ko][i] != '\0'; ) {
		/* isolate the termcap name */
		capname[0] = ostrval[uselevel][cap_ko][i++];
		if (ostrval[uselevel][cap_ko][i] == '\0')
			break;
		capname[1] = ostrval[uselevel][cap_ko][i++];
		if (ostrval[uselevel][cap_ko][i] == ',')
			i++;

		if (verbose > 1) {
			(void) fprintf(trace, "key termcap name is '");
			tpr(trace, capname);
			(void) fprintf(trace, "'.\n");
		}

		/* match it up into our list */
		found = 0;
		for (j = 0; !found && ko_map[j].keyedinfoname != NULL; j++) {
			if (verbose > 1)
			(void) fprintf(trace, "looking at termcap name %s.\n",
			    ko_map[j].capname);
			if (capname[0] == ko_map[j].capname[0] &&
			    capname[1] == ko_map[j].capname[1]) {
				/* add the value to our database */
				if ((capstr = getcapstr(capname)) != NULL) {
					infostr = getinfostr
					    (ko_map[j].keyedinfoname);
				if (infostr == NULL) {
					/* skip any possible padding */
					/* information */
					while (ispadchar(*capstr))
						capstr++;
					putstr(ko_map[j].keyedinfoname, capstr);
				} else
					if (strcmp(capstr, infostr) != 0) {
						(void) fprintf(stderr,
						    "%s: TERM=%s: a function "
						    "key for '%s' was "
						    "specified with the "
						    "value ", progname,
						    term_name, capname);
						tpr(stderr, capstr);
						(void) fprintf(stderr,
						    ", but it already has the "
						    "value '");
						tpr(stderr, infostr);
						(void) fprintf(stderr, "'.\n");
					}
				}
				found = 1;
			}
		}

		if (!found) {
			(void) fprintf(stderr, "%s: TERM=%s: the unknown "
			    "termcap name '%s' was\n", progname, term_name,
			    capname);
			(void) fprintf(stderr, "specified in the 'ko' "
			    "termcap capability.\n");
		}
	}
}

#define	CONTROL(x)		((x) & 037)
struct
	{
	char vichar;
	char *keyedinfoname;
	} ma_map[] = {
		CONTROL('J'),	"kcud1",	/* down */
		CONTROL('N'),	"kcud1",
		'j',		"kcud1",
		CONTROL('P'),	"kcuu1",	/* up */
		'k',		"kcuu1",
		'h',		"kcub1",	/* left */
		CONTROL('H'),	"kcub1",
		' ',		"kcuf1",	/* right */
		'l',		"kcuf1",
		'H',		"khome",	/* home */
		CONTROL('L'),	"kclr",		/* clear */
		0,		0
	};

/*
 *  Work with the ma string. This is a list of pairs of characters.
 *  The first character is the what a function key sends. The second
 *  character is the equivalent vi function that should be done when
 *  it receives that character. Note that only function keys that send
 *  a single character could be defined by this list.
 */

void
prchar(FILE *stream, int c)
{
	char xbuf[2];
	xbuf[0] = c;
	xbuf[1] = '\0';
	(void) fprintf(stream, "%s", iexpand(xbuf));
}

static void
handlema(void)
{
	char vichar;
	char cap[2];
	int i, j, found;
	char *infostr;

	if (verbose > 1)
		(void) fprintf(trace, "working on termcap ma string.\n");

	if (ostrval[uselevel][cap_ma] == NULL)
		return;

	cap[1] = '\0';
	for (i = 0; ostrval[uselevel][cap_ma][i] != '\0'; ) {
		/* isolate the key's value */
		cap[0] = ostrval[uselevel][cap_ma][i++];
		if (verbose > 1) {
			(void) fprintf(trace, "key value is '");
			tpr(trace, cap);
			(void) fprintf(trace, "'.\n");
		}

		if (ostrval[uselevel][cap_ma][i] == '\0')
			break;

		/* isolate the vi key name */
		vichar = ostrval[uselevel][cap_ma][i++];
		if (verbose > 1) {
			(void) fprintf(trace, "the vi key is '");
			prchar(trace, vichar);
			(void) fprintf(trace, "'.\n");
		}

		/* match up the vi name in our list */
		found = 0;
		for (j = 0; !found && ma_map[j].keyedinfoname != NULL; j++) {
			if (verbose > 1) {
				(void) fprintf(trace, "looking at vi "
				    "character '");
				prchar(trace, ma_map[j].vichar);
				(void) fprintf(trace, "'\n");
			}
			if (vichar == ma_map[j].vichar) {
				infostr = getinfostr(ma_map[j].keyedinfoname);
				if (infostr == NULL)
					putstr(ma_map[j].keyedinfoname, cap);
				else if (strcmp(cap, infostr) != 0) {
					(void) fprintf(stderr, "%s: TERM=%s: "
					    "the vi character '", progname,
					    term_name);
					prchar(stderr, vichar);
					(void) fprintf(stderr,
					    "' (info '%s') has the value '",
					    ma_map[j].keyedinfoname);
					tpr(stderr, infostr);
					(void) fprintf(stderr, "', but 'ma' "
					    "gives '");
					prchar(stderr, cap[0]);
					(void) fprintf(stderr, "'.\n");
				}
				found = 1;
			}
		}

		if (!found) {
			(void) fprintf(stderr, "%s: the unknown vi key '",
			    progname);
			prchar(stderr, vichar);
			(void) fprintf(stderr, "' was\n");
			(void) fprintf(stderr, "specified in the 'ma' termcap "
			    "capability.\n");
		}
	}
}

/*
 *  Many capabilities were defaulted in termcap which must now be explicitly
 *  given. We'll assume that the defaults are in effect for this terminal.
 */
void
adddefaults(void)
{
	char *cap;
	int sg;

	if (verbose > 1)
		(void) fprintf(trace, "assigning defaults.\n");

	/* cr was assumed to be ^M, unless nc was given, */
	/* which meant it could not be done. */
	/* Also, xr meant that ^M acted strangely. */
	if ((getinfostr("cr") == NULL) && !oboolval[uselevel][cap_nc] &&
	    !oboolval[uselevel][cap_xr])
		if ((cap = getcapstr("cr")) == NULL)
			putstr("cr", "\r");
		else
			putstr("cr", cap);

	/* cursor down was assumed to be ^J if not specified by nl */
	if (getinfostr("cud1") == NULL)
		if (ostrval[uselevel][cap_nl] != NULL)
			putstr("cud1", ostrval[uselevel][cap_nl]);
		else
			putstr("cud1", "\n");

	/* ind was assumed to be ^J, unless ns was given, */
	/* which meant it could not be done. */
	if ((getinfostr("ind") == NULL) && !oboolval[uselevel][cap_ns])
		if (ostrval[uselevel][cap_nl] == NULL)
			putstr("ind", "\n");
		else
			putstr("ind", ostrval[uselevel][cap_nl]);

	/* bel was assumed to be ^G */
	if (getinfostr("bel") == NULL)
		putstr("bel", "\07");

	/* if bs, then could do backspacing, */
	/* with value of bc, default of ^H */
	if ((getinfostr("cub1") == NULL) && oboolval[uselevel][cap_bs])
		if (ostrval[uselevel][cap_bc] != NULL)
			putstr("cub1", ostrval[uselevel][cap_bc]);
		else
			putstr("cub1", "\b");

	/* default xon to true */
	if (!otgetflag("xo"))
		putbool("xon", 1);

	/* if pt, then hardware tabs are allowed, */
	/* with value of ta, default of ^I */
	if ((getinfostr("ht") == NULL) && oboolval[uselevel][cap_pt])
		if ((cap = getcapstr("ta")) == NULL)
			putstr("ht", "\t");
		else
			putstr("ht", cap);

	/* The dX numbers are now stored as padding */
	/* in the appropriate terminfo string. */
	addpadding(onumval[uselevel][cap_dB], "cub1");
	addpadding(onumval[uselevel][cap_dC], "cr");
	addpadding(onumval[uselevel][cap_dF], "ff");
	addpadding(onumval[uselevel][cap_dN], "cud1");
	addpadding(onumval[uselevel][cap_dT], "ht");

	/* The ug and sg caps were essentially identical, */
	/* so ug almost never got used. We set sg from ug */
	/* if it hasn't already been set. */
	if (onumval[uselevel][cap_ug] >= 0 && (sg = otgetnum("sg")) < 0)
		putnum("xmc", onumval[uselevel][cap_ug]);
	else if ((onumval[uselevel][cap_ug] >= 0) &&
	    (sg >= 0) && (onumval[uselevel][cap_ug] != sg))
		(void) fprintf(stderr,
		    "%s: TERM=%s: Warning: termcap sg and ug had different "
		    "values (%d<->%d).\n", progname, term_name, sg,
		    onumval[uselevel][cap_ug]);

	/* The MT boolean was never really part of termcap, */
	/* but we can check for it anyways. */
	if (oboolval[uselevel][cap_MT] && !otgetflag("km"))
		putbool("km", 1);

	/* the rs string was renamed r2 (info rs2) */
	if ((ostrval[uselevel][cap_rs] != NULL) &&
	    (ostrval[uselevel][cap_rs][0] != '\0'))
		putstr("rs2", ostrval[uselevel][cap_rs]);

	handleko();
	handlema();
}

#define	caddch(x) *to++ = (x)

/*
 *  add the string to the string table
 */
char *
caddstr(char *to, char *str)
{
	while (*str)
		*to++ = *str++;
	return (to);
}

/* If there is no padding info or parmed strings, */
/* then we do not need to copy the string. */
int
needscopying(char *string)
{
	/* any string at all? */
	if (string == NULL)
		return (0);

	/* any padding info? */
	if (ispadchar(*string))
		return (1);

	/* any parmed info? */
	while (*string)
		if (*string++ == '%')
			return (1);

	return (0);
}

/*
 *  Certain manipulations of the stack require strange manipulations of the
 *  values that are on the stack. To handle these, we save the values of the
 *  parameters in registers at the very beginning and make the changes in
 *  the registers. We don't want to do this in the general case because of the
 *  potential performance loss.
 */
int
fancycap(char *string)
{
	int parmset = 0;

	while (*string)
		if (*string++ == '%') {
			switch (*string) {
				/* These manipulate just the top value on */
				/* the stack, so we only have to do */
				/* something strange if a %r follows. */
				case '>': case 'B': case 'D':
					parmset = 1;
					break;
				/* If the parm has already been been */
				/* pushed onto the stack by %>, then we */
				/* can not reverse the parms and must get */
				/* them from the registers. */
				case 'r':
					if (parmset)
						return (1);
					break;
				/* This manipulates both parameters, so we */
				/* cannot just do one and leave the value */
				/* on the stack like we can with %>, */
				/* %B or %D. */
				case 'n':
					return (1);
			}
			string++;
		}
	return (0);
}

/*
 *  Change old style of doing calculations to the new stack style.
 *  Note that this will not necessarily produce the most efficient string,
 *  but it will work.
 */
void
changecalculations()
{
	int i, currentparm;
	char *from, *to = nextstring;
	int ch;
	int parmset, parmsaved;
	char padding[100], *saveto;

	for (i = 0; strnames[i]; i++)
		if (needscopying(strval[uselevel][i])) {
			if (verbose) {
				(void) fprintf(trace, "%s needs copying, "
				    "was:", strnames [i]);
				tpr(trace, strval[uselevel][i]);
				(void) fprintf(trace, ".\n");
			}

			from = strval[uselevel][i];
			strval[uselevel][i] = to;
			currentparm = 1;
			parmset = 0;

	    /* Handle padding information. Save it so that it can be */
	    /* placed at the end of the string where it should */
	    /* have been in the first place. */
			if (ispadchar(*from)) {
				saveto = to;
				to = padding;
				to = caddstr(to, "$<");
				while (isdigit(*from) || *from == '.')
					caddch(*from++);
				if (*from == '*')
					caddch(*from++);
				caddch('>');
				caddch('\0');
				to = saveto;
			} else
				padding[0] = '\0';

			if (fancycap(from)) {
				to = caddstr(to, "%p1%Pa%p2%Pb");
				parmsaved = 1;
				(void) fprintf(stderr,
				    "%s: TERM=%s: Warning: the string "
				    "produced for '%s' may be inefficient.\n",
				    progname, term_name, strnames[i]);
				(void) fprintf(stderr, "It should be "
				    "looked at by hand.\n");
			} else
				parmsaved = 0;

			while ((ch = *from++) != '\0')
				if (ch != '%')
					caddch(ch);
				else
				switch (ch = *from++) {
					case '.':	/* %.  -> %p1%c */
					case 'd':	/* %d  -> %p1%d */
					case '2':	/* %2  -> %p1%2.2d */
					case '3':	/* %3  -> %p1%3.3d */
					case '+':
					/* %+x -> %p1%'x'%+%c */

					case '>':
					/* %>xy -> %p1%Pc%?%'x'%> */
					/* %t%gc%'y'%+ */
					/* if current value > x, then add y. */
					/* No output. */

					case 'B':
					/* %B: BCD */
					/* (16*(x/10))+(x%10) */
					/* No output. */
					/* (Adds Regent 100) */

					case 'D':
					/* %D: Reverse coding */
					/* (x-2*(x%16)) */
					/* No output. */
					/* (Delta Data) */

					if (!parmset)
						if (parmsaved) {
							to = caddstr(to, "%g");
							if (currentparm == 1)
								caddch('a');
							else
								caddch('b');
						} else {
							to = caddstr(to, "%p");
							if (currentparm == 1)
								caddch('1');
							else
								caddch('2');
						}
					currentparm = 3 - currentparm;
					parmset = 0;
					switch (ch) {
						case '.':
							to = caddstr(to, "%c");
							break;
						case 'd':
							to = caddstr(to, "%d");
							break;
						case '2': case '3':
#ifdef USG	/* Vr2==USG, Vr3==SYSV. Use %02d for Vr2, %2.2d for Vr3 */
							caddch('%');
							caddch('0');
#else
							caddch('%');
							caddch(ch);
							caddch('.');
#endif /* USG vs. SYSV */
							caddch(ch);
							caddch('d');
							break;
						case '+':
							to = caddstr(to, "%'");
							caddch(*from++);
							to = caddstr(to,
							    "'%+%c");
							break;
						case '>':
							to = caddstr(to,
							    "%Pc%?%'");
							caddch(*from++);
							to = caddstr(to,
							    "'%>%t%gc%'");
							caddch(*from++);
							to = caddstr(to,
							    "'%+");
							parmset = 1;
							break;
						case 'B':
							to = caddstr(to,
"%Pc%gc%{10}%/%{16}%*%gc%{10}%m%+");
						parmset = 1;
						break;

						case 'D':
							to = caddstr(to,
"%Pc%gc%gc%{16}%m%{2}%*%-");
							parmset = 1;
							break;
					}
					break;

					/* %r reverses current parameter */
					case 'r':
						currentparm = 3 - currentparm;
						break;

					/* %n: exclusive-or row AND column */
					/* with 0140, 96 decimal, no output */
					/* (Datamedia 2500, Exidy Sorceror) */
					case 'n':
						to = caddstr(to,
						    "%ga%'`'%^%Pa");
						to = caddstr(to,
						    "%gb%'`'%^%Pb");
						break;

					/* assume %x means %x */
					/* this includes %i and %% */
					default:
						caddch('%');
						caddch(ch);
				}
		to = caddstr(to, padding);
		caddch('\0');

		if (verbose) {
			(void) fprintf(trace, "and has become:");
			tpr(trace, strval[uselevel][i]);
			(void) fprintf(trace, ".\n");
		}
	}
	nextstring = to;
}

static void
print_no_use_entry(void)
{
	int i;

	pr_heading("", buflongname);
	pr_bheading();

	for (i = 0; boolcodes[i]; i++)
		if (boolval[0][i])
			pr_boolean(boolnames[i], (char *)0, (char *)0, 1);

	pr_bfooting();
	pr_sheading();

	for (i = 0; numcodes[i]; i++)
		if (numval[0][i] > -1)
			pr_number(numnames[i], (char *)0, (char *)0,
			    numval[0][i]);

	pr_nfooting();
	pr_sheading();

	for (i = 0; strcodes[i]; i++)
		if (strval[0][i])
			pr_string(strnames[i], (char *)0, (char *)0,
			    strval[0][i]);

	pr_sfooting();
}

static void
print_use_entry(char *usename)
{
	int i;

	pr_heading("", buflongname);
	pr_bheading();

	for (i = 0; boolcodes[i]; i++)
		if (boolval[0][i] && !boolval[1][i])
			pr_boolean(boolnames[i], (char *)0, (char *)0, 1);
		else if (!boolval[0][i] && boolval[1][i])
			pr_boolean(boolnames[i], (char *)0, (char *)0, -1);

	pr_bfooting();
	pr_nheading();

	for (i = 0; numcodes[i]; i++)
		if ((numval[0][i] > -1) && (numval[0][i] != numval[1][i]))
			pr_number(numnames[i], (char *)0, (char *)0,
			    numval[0][i]);
		else if ((numval [0] [i] == -1) && (numval [1] [i] > -1))
			pr_number(numnames[i], (char *)0, (char *)0, -1);

	pr_nfooting();
	pr_sheading();

	for (i = 0; strcodes[i]; i++)
		/* print out str[0] if: */
		/* str[0] != NULL and str[1] == NULL, or str[0] != str[1] */
		if (strval[0][i] && ((strval[1][i] == NULL) ||
		    (strcmp(strval[0][i], strval[1][i]) != 0)))
				pr_string(strnames[i], (char *)0, (char *)0,
				    strval[0][i]);
		/* print out @ if str[0] == NULL and str[1] != NULL */
		else if (strval[0][i] == NULL && strval[1][i] != NULL)
			pr_string(strnames[i], (char *)0, (char *)0,
			    (char *)0);

	pr_sfooting();

	(void) printf("\tuse=%s,\n", usename);
}

static void
captoinfo(void)
{
	char usename[512];
	char *sterm_name;

	if (term_name == NULL) {
		(void) fprintf(stderr, "%s: Null term_name given.\n",
		    progname);
		return;
	}

	if (verbose)
		(void) fprintf(trace, "changing cap to info, TERM=%s.\n",
		    term_name);

	uselevel = 0;
	if (filltables() == 0)
		return;
	getlongname();
	adddefaults();
	changecalculations();
	if (TLHtcfound != 0) {
		uselevel = 1;
		if (verbose)
			(void) fprintf(trace, "use= found, %s uses %s.\n",
			    term_name, TLHtcname);
		(void) strcpy(usename, TLHtcname);
		sterm_name = term_name;
		term_name = usename;
		if (filltables() == 0)
			return;
		adddefaults();
		changecalculations();
		term_name = sterm_name;
		print_use_entry(usename);
	} else
		print_no_use_entry();
}


#include <signal.h>   /* use this file to determine if this is SVR4.0 system */

static void
use_etc_termcap(void)
{
	if (verbose)
#ifdef  SIGSTOP
		(void) fprintf(trace, "reading from /usr/share/lib/termcap\n");
#else   /* SIGSTOP */
		(void) fprintf(trace, "reading from /etc/termcap\n");
#endif  /* SIGSTOP */
		term_name = getenv("TERM");
		captoinfo();
}

static void
initdirname(void)
{
#if defined(SYSV) || defined(USG)  /* handle both Sys Vr2 and Vr3 curses */
	(void) getcwd(dirname, BUFSIZ-2);
#else
	(void) getwd(dirname);
#endif /* SYSV || USG */
	if (verbose)
		(void) fprintf(trace, "current directory name=%s.\n", dirname);
	environ = newenviron;
}

static void
setfilename(char *capfile)
{
	if (capfile [0] == '/')
		(void) snprintf(TERMCAP, sizeof (TERMCAP),
		    "TERMCAP=%s", capfile);
	else
		(void) snprintf(TERMCAP, sizeof (TERMCAP),
		    "TERMCAP=%s/%s", dirname, capfile);
	if (verbose)
		(void) fprintf(trace, "setting the environment for %s.\n",
		    TERMCAP);
}

static void
setterm_name(void)
{
	if (verbose)
		(void) fprintf(trace, "setting the environment "
		    "for TERM=%s.\n", term_name);
	(void) snprintf(TERM, sizeof (TERM), "TERM=%s", term_name);
}

/* Look at the current line to see if it is a list of names. */
/* If it is, return the first name in the list, else NULL. */
/* As a side-effect, comment lines and blank lines */
/* are copied to standard output. */

char *
getterm_name(char *line)
{
	char *lineptr = line;

	if (verbose)
		(void) fprintf(trace, "extracting name from '%s'.\n", line);

	/* Copy comment lines out. */
	if (*line == '#') {
		if (copycomments)
			(void) printf("%s", line);
	}
	/* Blank lines get copied too. */
	else if (isspace (*line)) {
		if (copycomments) {
			for (; *lineptr; lineptr++)
				if (!isspace(*lineptr))
					break;
			if (*lineptr == '\0')
			(void) printf("\n");
		}
	}
	else
		for (; *lineptr; lineptr++)
			if (*lineptr == '|' || *lineptr == ':') {
				*lineptr = '\0';
				if (verbose)
					(void) fprintf(trace,
					    "returning %s.\n", line);
				return (line);
			}
	if (verbose)
		(void) fprintf(trace, "returning NULL.\n");
	return (NULL);
}

static void
use_file(char *filename)
{
	FILE *termfile;
	char buffer[BUFSIZ];

	if (verbose)
		(void) fprintf(trace, "reading from %s.\n", filename);

	if ((termfile = fopen(filename, "r")) == NULL) {
		(void) fprintf(stderr, "%s: cannot open %s for reading.\n",
		    progname, filename);
		return;
	}

	copycomments++;
	setfilename(filename);

	while (fgets(buffer, BUFSIZ, termfile) != NULL) {
		if ((term_name = getterm_name(buffer)) != NULL) {
			setterm_name();
			captoinfo();
		}
	}
}

/*
 *  Sort a name and code table pair according to the name table.
 *  Use a simple bubble sort for now. Too bad I can't call qsort(3).
 *  At least I only have to do it once for each table.
 */
static void
sorttable(char *nametable[], char *codetable[])
{
	int i, j;
	char *c;

	for (i = 0; nametable[i]; i++)
		for (j = 0; j < i; j++)
			if (strcmp(nametable[i], nametable[j]) < 0) {
				c = nametable[i];
				nametable[i] = nametable[j];
				nametable[j] = c;
				c = codetable[i];
				codetable[i] = codetable[j];
				codetable[j] = c;
			}
}

/*
 *  Initialize and sort the name and code tables. Allocate space for the
 *  value tables.
 */
static void
inittables(void)
{
	unsigned int i;

	for (i = 0; boolnames [i]; i++)
		;
	boolval[0] = (char *)malloc(i * sizeof (char));
	boolval[1] = (char *)malloc(i * sizeof (char));
	boolcount = i;
	sorttable(boolnames, boolcodes);

	for (i = 0; numcodes [i]; i++)
		;
	numval[0] = (short *)malloc(i * sizeof (short));
	numval[1] = (short *)malloc(i * sizeof (short));
	numcount = i;
	sorttable(numnames, numcodes);

	for (i = 0; strcodes [i]; i++)
		;
	strval[0] = (char **)malloc(i * sizeof (char *));
	strval[1] = (char **)malloc(i * sizeof (char *));
	strcount = i;
	sorttable(strnames, strcodes);
}

int
main(int argc, char **argv)
{
	int c;
	char _capbuffer [8192];
	char _bp [TBUFSIZE];
	char _buflongname [128];

	capbuffer = &_capbuffer[0];
	bp = &_bp[0];
	buflongname = &_buflongname[0];
	progname = argv[0];

	while ((c = getopt(argc, argv, "1vVw:")) != EOF)
		switch (c) {
			case '1':
				pr_onecolumn(1);
				break;
			case 'w':
				pr_width(atoi(optarg));
				break;
			case 'v':
				verbose++;
				break;
			case 'V':
				(void) printf("%s: version %s\n", progname,
				    "@(#)curses:screen/captoinfo.c	1.12");
				(void) fflush(stdout);
				exit(0);
				/* FALLTHROUGH (not really) */
			case '?':
				(void) fprintf(stderr,
				    "usage: %s [-1Vv] [-w width] "
				    "[filename ...]\n", progname);
				(void) fprintf(stderr, "\t-1\tsingle column "
				    "output\n");
				(void) fprintf(stderr,
				    "\t-v\tverbose debugging output\n");
				(void) fprintf(stderr,
				    "\t-V\tprint program version\n");
				exit(-1);
		}

	/* initialize */
	pr_init(pr_terminfo);
	inittables();

	if (optind >= argc)
		use_etc_termcap();
	else {
		initdirname();
	for (; optind < argc; optind++)
		use_file(argv [optind]);
	}

	return (0);
}

/* fake out the modules in print.c so we don't have to load in */
/* cexpand.c and infotocap.c */
/* ARGSUSED */
int
cpr(FILE *stream, char *string)
{
	return (0);
}
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#

#
# Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
#

#
# MAPFILE HEADER START
#
# WARNING:  STOP NOW.  DO NOT MODIFY THIS FILE.
# Object versioning must comply with the rules detailed in
#
#	usr/src/lib/README.mapfiles
#
# You should not be making modifications here until you've read the most current
# copy of that file. If you need help, contact a gatekeeper for guidance.
#
# MAPFILE HEADER END
#

$mapfile_version 2

# captoinfo interposes on cpr() and progname[].
SYMBOL_SCOPE {
	global:
		cpr		{ FLAGS = INTERPOSE };
		progname	{ FLAGS = INTERPOSE };
};
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1988 AT&T	*/
/*	  All Rights Reserved  	*/

/* Copyright (c) 1979 Regents of the University of California	*/
/* Modified to:							*/
/* 1) remember the name of the first tc= parameter		*/
/*	encountered during parsing.				*/
/* 2) handle multiple invocations of tgetent().			*/
/* 3) tskip() is now available outside of the library.		*/
/* 4) remember $TERM name for error messages.			*/
/* 5) have a larger buffer.					*/
/* 6) really fix the bug that 5) got around. This fix by	*/
/*		Marion Hakanson, orstcs!hakanson		*/


#include "otermcap.h"
#define	MAXHOP	32	/* max number of tc= indirections */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include <signal.h>   /* use this file to determine if this is SVR4.0 system */
#ifdef SIGSTOP /* SVR4.0 and beyond */
#define	E_TERMCAP "/usr/share/lib/termcap"
#else
#define	E_TERMCAP "/etc/termcap"
#endif

/*
 * 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;
static	int hopcount;	/* detect infinite loops in termcap, init 0 */
char	*tskip(char *);
char	*otgetstr(char *, char **);

/* Tony Hansen */
int	TLHtcfound = 0;
char	TLHtcname[16];
static	char *termname;

static int _tgetent(char *, char *);
static int otnchktc(void);
static char *tdecode(char *, char **);
static int otnamatch(char *);
/*
 * Get an entry for terminal name in buffer bp,
 * from the termcap file.  Parse is very rudimentary;
 * we just notice escaped newlines.
 */
int
otgetent(char *bp, char *name)
{
	/* Tony Hansen */
	int ret;
	TLHtcfound = 0;
	hopcount = 0;
	termname = name;
	ret = _tgetent(bp, name);
	/*
	 * There is some sort of bug in the check way down below to prevent
	 * buffer overflow. I really don't want to track it down, so I
	 * upped the standard buffer size and check here to see if the created
	 * buffer is larger than the old buffer size.
	 */
	if (strlen(bp) >= 1024)
		(void) fprintf(stderr,
		    "tgetent(): TERM=%s: Termcap entry is too long.\n",
		    termname);
	return (ret);
}

static int
_tgetent(char *bp, char *name)
{
	char *cp;
	int c;
	int i = 0, cnt = 0;
	char ibuf[TBUFSIZE];
	char *cp2;
	int tf;

	tbuf = bp;
	tf = 0;
#ifndef V6
	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 (cp && *cp) {
		if (*cp != '/') {
			cp2 = getenv("TERM");
			if (cp2 == (char *)0 || strcmp(name, cp2) == 0) {
				(void) strcpy(bp, cp);
				return (otnchktc());
			} else {
				tf = open(E_TERMCAP, 0);
			}
		} else
			tf = open(cp, 0);
	}
	if (tf == 0)
		tf = open(E_TERMCAP, 0);
#else
	tf = open(E_TERMCAP, 0);
#endif
	if (tf < 0)
		return (-1);
	for (; ; ) {
		cp = bp;
		for (; ; ) {
			if (i == cnt) {
				cnt = read(tf, ibuf, TBUFSIZE);
				if (cnt <= 0) {
					(void) close(tf);
					return (0);
				}
				i = 0;
			}
			c = ibuf[i++];
			if (c == '\n') {
				if (cp > bp && cp[-1] == '\\') {
					cp--;
					continue;
				}
				break;
			}
			if (cp >= bp + TBUFSIZE) {
				(void) fprintf(stderr, "tgetent(): TERM=%s: "
				    "Termcap entry too long\n", termname);
				break;
			} else
				*cp++ = c;
		}
		*cp = 0;

		/*
		 * The real work for the match.
		 */
		if (otnamatch(name)) {
			(void) close(tf);
			return (otnchktc());
		}
	}
}

/*
 * otnchktc: check the last entry, see if it's tc=xxx. If so,
 * recursively find xxx and append that entry (minus the names)
 * to take the place of the tc=xxx entry. This allows termcap
 * entries to say "like an HP2621 but doesn't turn on the labels".
 * Note that this works because of the left to right scan.
 */
static int
otnchktc(void)
{
	char *p, *q;
#define	TERMNAMESIZE 16
	char tcname[TERMNAMESIZE];	/* name of similar terminal */
	char tcbuf[TBUFSIZE];
	char *holdtbuf = tbuf;
	int l;

	p = tbuf + strlen(tbuf) - 2;	/* before the last colon */
	while (*--p != ':')
		if (p < tbuf) {
			(void) fprintf(stderr, "tnchktc(): TERM=%s: Bad "
			    "termcap entry\n", termname);
			return (0);
		}
	p++;
	/* p now points to beginning of last field */
	if (p[0] != 't' || p[1] != 'c')
		return (1);
	(void) strncpy(tcname, p + 3, TERMNAMESIZE);	/* TLH */
	q = tcname;
	while (*q && *q != ':')
		q++;
	*q = 0;
	if (++hopcount > MAXHOP) {
		(void) fprintf(stderr, "tnchktc(): TERM=%s: Infinite tc= "
		    "loop\n", termname);
		return (0);
	}
	if (_tgetent(tcbuf, tcname) != 1)
		return (0);
	/* Tony Hansen */
	TLHtcfound++;
	(void) strcpy(TLHtcname, tcname);

	for (q = tcbuf; *q != ':'; q++)
		;
	l = p - holdtbuf + strlen(q);
	if (l > TBUFSIZE) {
		(void) fprintf(stderr, "tnchktc(): TERM=%s: Termcap entry "
		    "too long\n", termname);
		q[TBUFSIZE - (p - holdtbuf)] = 0;
	}
	(void) strcpy(p, q + 1);
	tbuf = holdtbuf;
	return (1);
}

/*
 * Tnamatch deals with name matching.  The first field of the termcap
 * entry is a sequence of names separated by |'s, so we compare
 * against each such name.  The normal : terminator after the last
 * name (before the first field) stops us.
 */
static int
otnamatch(char *np)
{
	char *Np, *Bp;

	Bp = tbuf;
	if (*Bp == '#')
		return (0);
	for (;;) {
		for (Np = np; *Np && *Bp == *Np; Bp++, Np++)
			continue;
		if (*Np == 0 && (*Bp == '|' || *Bp == ':' || *Bp == 0))
			return (1);
		while (*Bp && *Bp != ':' && *Bp != '|')
			Bp++;
		if (*Bp == 0 || *Bp == ':')
			return (0);
		Bp++;
	}
}

/*
 * Skip to the next field.  Notice that this is very dumb, not
 * knowing about \: escapes or any such.  If necessary, :'s can be put
 * into the termcap file in octal.
 */
char *
tskip(char *bp)
{

	while (*bp && *bp != ':')
		bp++;
	if (*bp == ':')
		bp++;
	return (bp);
}

/*
 * 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
otgetnum(char *id)
{
	int i, base;
	char *bp = tbuf;

	for (;;) {
		bp = tskip(bp);
		if (*bp == 0)
			return (-1);
		if (*bp++ != id[0] || *bp == 0 || *bp++ != id[1])
			continue;
		if (*bp == '@')
			return (-1);
		if (*bp != '#')
			continue;
		bp++;
		base = 10;
		if (*bp == '0')
			base = 8;
		i = 0;
		while (isdigit(*bp))
			i *= base, i += *bp++ - '0';
		return (i);
	}
}

/*
 * 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
otgetflag(char *id)
{
	char *bp = tbuf;

	for (;;) {
		bp = tskip(bp);
		if (!*bp)
			return (0);
		if (*bp++ == id[0] && *bp != 0 && *bp++ == id[1]) {
			if (!*bp || *bp == ':')
				return (1);
			else if (*bp == '@')
				return (0);
		}
	}
}

/*
 * 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 *
otgetstr(char *id, char **area)
{
	char *bp = tbuf;

	for (; ; ) {
		bp = tskip(bp);
		if (!*bp)
			return (0);
		if (*bp++ != id[0] || *bp == 0 || *bp++ != id[1])
			continue;
		if (*bp == '@')
			return (0);
		if (*bp != '=')
			continue;
		bp++;
		return (tdecode(bp, area));
	}
}

/*
 * Tdecode does the grung work to decode the
 * string capability escapes.
 */
static char *
tdecode(char *str, char **area)
{
	char *cp;
	int c;
	char *dp;
	int i;

	cp = *area;
	while ((c = *str++) != '\0' && c != ':') {
		switch (c) {

		case '^':
			c = *str++ & 037;
			break;

		case '\\':
			dp = "E\033^^\\\\::n\nr\rt\tb\bf\f";
			c = *str++;
nextc:
			if (*dp++ == c) {
				c = *dp++;
				break;
			}
			dp++;
			if (*dp)
				goto nextc;
			if (isdigit(c)) {
				c -= '0', i = 2;
				do
					c <<= 3, c |= *str++ - '0';
				while (--i && isdigit(*str))
					;
			}
			break;
		}
		*cp++ = c;
	}
	*cp++ = 0;
	str = *area;
	*area = cp;
	return (str);
}