%{
/*
 * 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) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved	*/

%{
#include <stdio.h>
#include <stdarg.h>
#include <limits.h>
#include <libintl.h>
#include <locale.h>
#include <signal.h>

static void getout(int)	__NORETURN;
static int *bundle(int, ...);
static void usage(void);

int	cpeek(char, int, char, int, char);
int	yyerror(const char *);

#define	STRING_SIZE	(BC_STRING_MAX + 3)	/* string plus quotes */
						/* plus NULL */

FILE	*in;
char	cary[LINE_MAX+1];
char	*cp = { cary };
char	*cpend = &cary[LINE_MAX];	/* last address (not the null char) */
char	string[STRING_SIZE];
char	*str = { string };
int	crs = '0';
int	rcrs = '0';		/* reset crs */
int	bindx = 0;
int	lev = 0;			/* current scope level */
int	ln;				/* line number of current file */
int	*ttp;
char	*ss;				/* current input source */
int	bstack[10] = { 0 };
char	*numb[15] = {
	" 0", " 1", " 2", " 3", " 4", " 5",
	" 6", " 7", " 8", " 9", " 10", " 11",
	" 12", " 13", " 14"
};
int	*pre, *post;
int	interact = 0;			/* talking to a tty? */
%}

%union {
	int *iptr;
	char *cptr;
	int cc;
	}
%start start;
%type <iptr> stat def slist dlets e
%type <iptr> re fprefix cargs eora cons constant lora
%right '='
%left '+' '-'
%left '*' '/' '%'
%right '^'
%left UMINUS

%token <cptr> LETTER
%type <cptr> EQOP CRS
%token <cc> DIGIT SQRT LENGTH _IF FFF EQ
%token <cc> _WHILE _FOR NE LE GE INCR DECR
%token <cc> _RETURN _BREAK _DEFINE BASE OBASE SCALE
%token <cc> EQPL EQMI EQMUL EQDIV EQREM EQEXP
%token <cptr> _AUTO DOT
%token <cc> QSTR

%%
start	:
	| start stat tail
		{
			output($2);
		}
	| start def dargs ')' '{' dlist slist '}'
		{
			ttp = bundle(6, pre, $7, post, "0", numb[lev], "Q");
			conout(ttp, (char *)$2);
			rcrs = crs;
			output((int *)"");
			lev = bindx = 0;
		}
	;

dlist	: tail
	| dlist _AUTO dlets tail
	;

stat	: e
		{
			bundle(2, $1, "ps.");
		}
	|
		{
			bundle(1, "");
		}
	| QSTR
		{
			bundle(3, "[", $1, "]P");
		}
	| LETTER '=' e
		{
			bundle(3, $3, "s", $1);
		}
	| LETTER '[' e ']' '=' e
		{
			bundle(4, $6, $3, ":", geta($1));
		}
	| LETTER EQOP e
		{
			bundle(6, "l", $1, $3, $2, "s", $1);
		}
	| LETTER '[' e ']' EQOP e
		{
			bundle(8, $3, ";", geta($1), $6, $5, $3, ":", geta($1));
		}
	| _BREAK
		{
			bundle(2, numb[lev-bstack[bindx-1]], "Q");
		}
	| _RETURN '(' e ')'
		{
			bundle(4, $3, post, numb[lev], "Q");
		}
	| _RETURN '(' ')'
		{
			bundle(4, "0", post, numb[lev], "Q");
		}
	| _RETURN
		{
			bundle(4, "0", post, numb[lev], "Q");
		}
	| SCALE '=' e
		{
			bundle(2, $3, "k");
		}
	| SCALE EQOP e
		{
			bundle(4, "K", $3, $2, "k");
		}
	| BASE '=' e
		{
			bundle(2, $3, "i");
		}
	| BASE EQOP e
		{
			bundle(4, "I", $3, $2, "i");
		}
	| OBASE '=' e
		{
			bundle(2, $3, "o");
		}
	| OBASE EQOP e
		{
			bundle(4, "O", $3, $2, "o");
		}
	| '{' slist '}'
		{
			$$ = $2;
		}
	| FFF
		{
			bundle(1, "fY");
		}
	| error
		{
			bundle(1, "c");
		}
	| _IF CRS BLEV '(' re ')' stat
		{
			conout($7, $2);
			bundle(3, $5, $2, " ");
		}
	| _WHILE CRS '(' re ')' stat BLEV
		{
			bundle(3, $6, $4, $2);
			conout($$, $2);
			bundle(3, $4, $2, " ");
		}
	| fprefix CRS re ';' e ')' stat BLEV
		{
			bundle(5, $7, $5, "s.", $3, $2);
			conout($$, $2);
			bundle(5, $1, "s.", $3, $2, " ");
		}
	| '~' LETTER '=' e
		{
			bundle(3, $4, "S", $2);
		}
	;

EQOP	: EQPL
		{
			$$ = "+";
		}
	| EQMI
		{
			$$ = "-";
		}
	| EQMUL
		{
			$$ = "*";
		}
	| EQDIV
		{
			$$ = "/";
		}
	| EQREM
		{
			$$ = "%%";
		}
	| EQEXP
		{
			$$ = "^";
		}
	;

fprefix	: _FOR '(' e ';'
		{
			$$ = $3;
		}
	;

BLEV	:
		{
			--bindx;
		}
	;

slist	: stat
	| slist tail stat
		{
			bundle(2, $1, $3);
		}
	;

tail	: '\n'
		{
			ln++;
		}
	| ';'
	;

re	: e EQ e
		{
			$$ = bundle(3, $1, $3, "=");
		}
	| e '<' e
		{
			bundle(3, $1, $3, ">");
		}
	| e '>' e
		{
			bundle(3, $1, $3, "<");
		}
	| e NE e
		{
			bundle(3, $1, $3, "!=");
		}
	| e GE e
		{
			bundle(3, $1, $3, "!>");
		}
	| e LE e
		{
			bundle(3, $1, $3, "!<");
		}
	| e
		{
			bundle(2, $1, " 0!=");
		}
	;

e	: e '+' e
		{
			bundle(3, $1, $3, "+");
		}
	| e '-' e
		{
			bundle(3, $1, $3, "-");
		}
	| '-' e		%prec UMINUS
		{
			bundle(3, " 0", $2, "-");
		}
	| e '*' e
		{
			bundle(3, $1, $3, "*");
		}
	| e '/' e
		{
			bundle(3, $1, $3, "/");
		}
	| e '%' e
		{
			bundle(3, $1, $3, "%%");
		}
	| e '^' e
		{
			bundle(3, $1, $3, "^");
		}
	| LETTER '[' e ']'
		{
			bundle(3, $3, ";", geta($1));
		}
	| LETTER INCR
		{
			bundle(4, "l", $1, "d1+s", $1);
		}
	| INCR LETTER
		{
			bundle(4, "l", $2, "1+ds", $2);
		}
	| DECR LETTER
		{
			bundle(4, "l", $2, "1-ds", $2);
		}
	| LETTER DECR
		{
			bundle(4, "l", $1, "d1-s", $1);
		}
	| LETTER '[' e ']' INCR
		{
			bundle(7, $3, ";", geta($1), "d1+", $3, ":", geta($1));
		}
	| INCR LETTER '[' e ']'
		{
			bundle(7, $4, ";", geta($2), "1+d", $4, ":", geta($2));
		}
	| LETTER '[' e ']' DECR
		{
			 bundle(7, $3, ";", geta($1), "d1-", $3, ":", geta($1));
		}
	| DECR LETTER '[' e ']'
		{
			bundle(7, $4, ";", geta($2), "1-d", $4, ":", geta($2));
		}
	| SCALE INCR
		{
			bundle(1, "Kd1+k");
		}
	| INCR SCALE
		{
			bundle(1, "K1+dk");
		}
	| SCALE DECR
		{
			bundle(1, "Kd1-k");
		}
	| DECR SCALE
		{
			bundle(1, "K1-dk");
		}
	| BASE INCR
		{
			bundle(1, "Id1+i");
		}
	| INCR BASE
		{
			bundle(1, "I1+di");
		}
	| BASE DECR
		{
			bundle(1, "Id1-i");
		}
	| DECR BASE
		{
			bundle(1, "I1-di");
		}
	| OBASE INCR
		{
			bundle(1, "Od1+o");
		}
	| INCR OBASE
		{
			bundle(1, "O1+do");
		}
	| OBASE DECR
		{
			bundle(1, "Od1-o");
		}
	| DECR OBASE
		{
			bundle(1, "O1-do");
		}
	| LETTER '(' cargs ')'
		{
			bundle(4, $3, "l", getf($1), "x");
		}
	| LETTER '(' ')'
		{
			bundle(3, "l", getf($1), "x");
		}
	| cons
		{
			bundle(2, " ", $1);
		}
	| DOT cons
		{
			bundle(2, " .", $2);
		}
	| cons DOT cons
		{
			bundle(4, " ", $1, ".", $3);
		}
	| cons DOT
		{
			bundle(3, " ", $1, ".");
		}
	| DOT
		{
			$<cptr>$ = "l.";
		}
	| LETTER
		{
			bundle(2, "l", $1);
		}
	| LETTER '=' e
		{
			bundle(3, $3, "ds", $1);
		}
	| LETTER EQOP e		%prec '='
		{
			bundle(6, "l", $1, $3, $2, "ds", $1);
		}
	| LETTER '[' e ']' '=' e
		{
			bundle(5, $6, "d", $3, ":", geta($1));
		}
	| LETTER '[' e ']' EQOP e
		{
			bundle(9, $3, ";", geta($1), $6, $5, "d", $3, ":",
			    geta($1));
		}
	| LENGTH '(' e ')'
		{
			bundle(2, $3, "Z");
		}
	| SCALE '(' e ')'
		{
			bundle(2, $3, "X");	/* must be before '(' e ')' */
		}
	| '(' e ')'
		{
			$$ = $2;
		}
	| '?'
		{
			bundle(1, "?");
		}
	| SQRT '(' e ')'
		{
			bundle(2, $3, "v");
		}
	| '~' LETTER
		{
			bundle(2, "L", $2);
		}
	| SCALE '=' e
		{
			bundle(2, $3, "dk");
		}
	| SCALE EQOP e		%prec '='
		{
			bundle(4, "K", $3, $2, "dk");
		}
	| BASE '=' e
		{
			bundle(2, $3, "di");
		}
	| BASE EQOP e		%prec '='
		{
			bundle(4, "I", $3, $2, "di");
		}
	| OBASE '=' e
		{
			bundle(2, $3, "do");
		}
	| OBASE EQOP e		%prec '='
		{
			bundle(4, "O", $3, $2, "do");
		}
	| SCALE
		{
			bundle(1, "K");
		}
	| BASE
		{
			bundle(1, "I");
		}
	| OBASE
		{
			bundle(1, "O");
		}
	;

cargs	: eora
	| cargs ',' eora
		{
			bundle(2, $1, $3);
		}
	;
eora	: e
	| LETTER '[' ']'
		{
			bundle(2, "l", geta($1));
		}
	;

cons	: constant
		{
			*cp++ = '\0';
		}

constant: '_'
		{
			checkbuffer();
			$<cptr>$ = cp;
			*cp++ = '_';
		}
	| DIGIT
		{
			checkbuffer();
			$<cptr>$ = cp;
			*cp++ = $1;
		}
	| constant DIGIT
		{
			checkbuffer();
			*cp++ = $2;
		}
	;

CRS	:
		{
			checkbuffer();
			$$ = cp;
			*cp++ = crs++;
			*cp++ = '\0';
			if (crs == '[')
				crs += 3;
			if (crs == 'a')
				crs = '{';
			if (crs >= 0241) {
				(void) yyerror("program too big");
				getout(1);
			}
			bstack[bindx++] = lev++;
		}
	;

def	: _DEFINE LETTER '('
		{
			$$ = getf($2);
			pre = (int *)"";
			post = (int *)"";
			lev = 1;
			bstack[bindx = 0] = 0;
		}
	;

dargs	:		/* empty */
	| lora
		{
			pp($1);
		}
	| dargs ',' lora
		{
			pp($3);
		}
	;

dlets	: lora
		{
			tp($1);
		}
	| dlets ',' lora
		{
			tp($3);
		}
	;

lora	: LETTER
		{
			$<cptr>$ = $1;
		}
	| LETTER '[' ']'
		{
			$$ = geta($1);
		}
	;

%%
#define	error	256

int	peekc = -1;
int	ifile;			/* current index into sargv */
int	sargc;			/* size of sargv[] */
char	**sargv;		/* saved arg list without options */

char funtab[52] = {
	01, 0, 02, 0, 03, 0, 04, 0, 05, 0, 06, 0, 07, 0,
	010, 0, 011, 0, 012, 0, 013, 0, 014, 0, 015, 0, 016, 0, 017, 0,
	020, 0, 021, 0, 022, 0, 023, 0, 024, 0, 025, 0, 026, 0, 027, 0,
	030, 0, 031, 0, 032, 0
};

unsigned char atab[52] = {
	0241, 0, 0242, 0, 0243, 0, 0244, 0, 0245, 0, 0246, 0, 0247, 0, 0250, 0,
	0251, 0, 0252, 0, 0253, 0, 0254, 0, 0255, 0, 0256, 0, 0257, 0, 0260, 0,
	0261, 0, 0262, 0, 0263, 0, 0264, 0, 0265, 0, 0266, 0, 0267, 0, 0270, 0,
	0271, 0, 0272, 0
};

char *letr[26] = {
	"a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
	"k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
	"u", "v", "w", "x", "y", "z"
};

int
yylex(void)
{
	int c, ch;

restart:
	c = getch();
	peekc = -1;
	while (c == ' ' || c == '\t')
		c = getch();
	if (c == '\\') {
		(void) getch();
		goto restart;
	}
	if (c <= 'z' && c >= 'a') {
		/* look ahead to look for reserved words */
		peekc = getch();
		if (peekc >= 'a' && peekc <= 'z') {
			/* must be reserved word */
			if (c == 'i' && peekc == 'f') {
				c = _IF;
				goto skip;
			}
			if (c == 'w' && peekc == 'h') {
				c = _WHILE;
				goto skip;
			}
			if (c == 'f' && peekc == 'o') {
				c = _FOR;
				goto skip;
			}
			if (c == 's' && peekc == 'q') {
				c = SQRT;
				goto skip;
			}
			if (c == 'r' && peekc == 'e') {
				c = _RETURN;
				goto skip;
			}
			if (c == 'b' && peekc == 'r') {
				c = _BREAK;
				goto skip;
			}
			if (c == 'd' && peekc == 'e') {
				c = _DEFINE;
				goto skip;
			}
			if (c == 's' && peekc == 'c') {
				c = SCALE;
				goto skip;
			}
			if (c == 'b' && peekc == 'a') {
				c = BASE;
				goto skip;
			}
			if (c == 'i' && peekc == 'b') {
				c = BASE;
				goto skip;
			}
			if (c == 'o' && peekc == 'b') {
				c = OBASE;
				goto skip;
			}
			if (c == 'd' && peekc == 'i') {
				c = FFF;
				goto skip;
			}
			if (c == 'a' && peekc == 'u') {
				c = _AUTO;
				goto skip;
			}
			if (c == 'l' && peekc == 'e') {
				c = LENGTH;
				goto skip;
			}
			if (c == 'q' && peekc == 'u') {
				getout(0);
			}
			/* could not be found */
			return (error);

skip:	/* skip over rest of word */
			peekc = -1;
			while ((ch = getch()) >= 'a' && ch <= 'z')
				;
			peekc = ch;
			return (c);
		}

		/* usual case; just one single letter */

		yylval.cptr = letr[c-'a'];
		return (LETTER);
	}

	if (c >= '0' && c <= '9' || c >= 'A' && c <= 'F') {
		yylval.cc = c;
		return (DIGIT);
	}

	switch (c) {
	case '.':
		return (DOT);

	case '=':
		switch ((peekc = getch())) {
		case '=':
			c = EQ;
			goto gotit;

		case '+':
			c = EQPL;
			goto gotit;

		case '-':
			c = EQMI;
			goto gotit;

		case '*':
			c = EQMUL;
			goto gotit;

		case '/':
			c = EQDIV;
			goto gotit;

		case '%':
			c = EQREM;
			goto gotit;

		case '^':
			c = EQEXP;
			goto gotit;

		default:
			return ('=');
gotit:
			peekc = -1;
			return (c);
		}

	case '+':
		return (cpeek('+', INCR, '=', EQPL, '+'));

	case '-':
		return (cpeek('-', DECR, '=', EQMI, '-'));

	case '*':
		return (cpeek('=', EQMUL, '\0', 0, '*'));

	case '%':
		return (cpeek('=', EQREM, '\0', 0, '%'));

	case '^':
		return (cpeek('=', EQEXP, '\0', 0, '^'));

	case '<':
		return (cpeek('=', LE, '\0', 0, '<'));

	case '>':
		return (cpeek('=', GE, '\0', 0, '>'));

	case '!':
		return (cpeek('=', NE, '\0', 0, '!'));

	case '/':
		if ((peekc = getch()) == '=') {
			peekc = -1;
			return (EQDIV);
		}
		if (peekc == '*') {
			peekc = -1;
			while ((getch() != '*') || ((peekc = getch()) != '/'))
				;
			peekc = -1;
			goto restart;
		}
		else
			return (c);

	case '"':
		yylval.cptr = str;
		while ((c = getch()) != '"') {
			*str++ = c;
			if (str >= &string[STRING_SIZE-1]) {
				(void) yyerror("string space exceeded");
				getout(1);
			}
		}
		*str++ = '\0';
		return (QSTR);

	default:
		return (c);
	}
}

int
cpeek(char c1, int yes1, char c2, int yes2, char none)
{
	int r;

	peekc = getch();
	if (peekc == c1)
		r = yes1;
	else if (peekc == c2)
		r = yes2;
	else
		return (none);
	peekc = -1;
	return (r);
}


int
getch(void)
{
	int ch;
	char mbuf[LINE_MAX];

loop:
	ch = (peekc < 0) ? getc(in) : peekc;
	peekc = -1;
	if (ch != EOF)
		return (ch);

	if (++ifile >= sargc) {
		if (ifile >= sargc+1)
			getout(0);
		in = stdin;
		ln = 0;
		goto loop;
	}

	(void) fclose(in);
	if ((in = fopen(sargv[ifile], "r")) != NULL) {
		ln = 0;
		ss = sargv[ifile];
		goto loop;
	}
	(void) snprintf(mbuf, sizeof (mbuf), "can't open input file %s",
		sargv[ifile]);
	ln = -1;
	ss = "command line";
	(void) yyerror(mbuf);
	getout(1);
	/*NOTREACHED*/
}

#define	b_sp_max	5000
int b_space[b_sp_max];
int *b_sp_nxt = { b_space };

int	bdebug = 0;

static int *
bundle(int i, ...)
{
	va_list ap;
	int *q;

	va_start(ap, i);
	q = b_sp_nxt;
	if (bdebug)
		printf("bundle %d elements at %o\n", i, q);
	while (i-- > 0) {
		if (b_sp_nxt >= & b_space[b_sp_max])
			(void) yyerror("bundling space exceeded");
		*b_sp_nxt++ = va_arg(ap, int);
	}
	* b_sp_nxt++ = 0;
	yyval.iptr = q;
	va_end(ap);
	return (q);
}

void
routput(int *p)
{
	if (bdebug) printf("routput(%o)\n", p);
	if (p >= &b_space[0] && p < &b_space[b_sp_max]) {
		/* part of a bundle */
		while (*p != 0)
			routput((int *)*p++);
	}
	else
		printf((char *)p);	 /* character string */
}

void
output(int *p)
{
	routput(p);
	b_sp_nxt = & b_space[0];
	printf("\n");
	(void) fflush(stdout);
	cp = cary;
	crs = rcrs;
}

void
conout(int *p, char *s)
{
	printf("[");
	routput(p);
	printf("]s%s\n", s);
	(void) fflush(stdout);
	lev--;
}

int
yyerror(const char *s)
{
	if (ifile >= sargc)
		ss = "teletype";

	if (ss == 0 || *ss == 0)
		(void) fprintf(stderr, gettext("%s on line %d\n"), s, ln+1);
	else
		(void) fprintf(stderr, gettext("%s on line %d, %s\n"),
		    s, ln+1, ss);
	(void) fflush(stderr);

	cp = cary;
	crs = rcrs;
	bindx = 0;
	lev = 0;
	b_sp_nxt = &b_space[0];
	return (0);
}

void
checkbuffer(void)
{
	/* Do not exceed the last char in input line buffer */
	if (cp >= cpend) {
		(void) yyerror("line too long\n");
		getout(1);
	}
}

void
pp(int *s)
{
	/* puts the relevant stuff on pre and post for the letter s */

	(void) bundle(3, "S", s, pre);
	pre = yyval.iptr;
	(void) bundle(4, post, "L", s, "s.");
	post = yyval.iptr;
}

void
tp(int *s)
{		/* same as pp, but for temps */
	bundle(3, "0S", s, pre);
	pre = yyval.iptr;
	bundle(4, post, "L", s, "s.");
	post = yyval.iptr;
}

void
yyinit(int argc, char **argv)
{
	char	mbuf[LINE_MAX];

	(void) signal(SIGINT, SIG_IGN);		/* ignore all interrupts */

	sargv = argv;
	sargc = argc;
	if (sargc == 0)
		in = stdin;
	else if ((in = fopen(sargv[0], "r")) == NULL) {
		(void) snprintf(mbuf, sizeof (mbuf), "can't open input file %s",
			sargv[0]);
		ln = -1;
		ss = "command line";
		(void) yyerror(mbuf);
		getout(1);
	}
	ifile = 0;
	ln = 0;
	ss = sargv[0];
}

static void
getout(int code)
{
	printf("q");
	(void) fflush(stdout);
	exit(code);
}

int *
getf(char *p)
{
	return ((int *) &funtab[2*(*p -0141)]);
}

int *
geta(char *p)
{
	return ((int *) &atab[2*(*p - 0141)]);
}

int
main(int argc, char **argv)
{
	int	p[2];
	int	cflag = 0;
	int	lflag = 0;
	int	flag = 0;
	char	**av;
	int	filecounter = 0;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)		/* Should be defined by cc -D */
#define	TEXT_DOMAIN	"SYS_TEST"	/* Use this only if it weren't */
#endif
	(void) textdomain(TEXT_DOMAIN);

	while ((flag = getopt(argc, argv, "dcl")) != EOF) {
		switch (flag) {
		case 'd':
		case 'c':
			cflag++;
			break;

		case 'l':
			lflag++;
			break;

		default:
			fflush(stdout);
			usage();
			break;
		}
	}

	argc -= optind;
	av = &argv[optind];

	/*
	* argc is the count of arguments, which should be filenames,
	* remaining in argv. av is a pointer to the first of the
	* remaining arguments.
	*/

	for (filecounter = 0; filecounter < argc; filecounter++) {
		if ((strlen(av[filecounter])) >= PATH_MAX) {
			(void) fprintf(stderr,
			    gettext("File argument too long\n"));
			exit(2);
		}
	}

	if (lflag) {
		/*
		* if the user wants to include the math library, prepend
		* the math library filename to the argument list by
		* overwriting the last option (there must be at least one
		* supplied option if this is being done).
		*/
		av = &argv[optind-1];
		av[0] = "/usr/lib/lib.b";
		argc++;
	}

	if (cflag) {
		yyinit(argc, av);
		yyparse();
		exit(0);
	}

	pipe(p);
	if (fork() == 0) {
		(void) close(1);
		dup(p[1]);
		(void) close(p[0]);
		(void) close(p[1]);
		yyinit(argc, av);
		yyparse();
		exit(0);
	}
	(void) close(0);
	dup(p[0]);
	(void) close(p[0]);
	(void) close(p[1]);
#ifdef XPG6
	execl("/usr/xpg6/bin/dc", "dc", "-", 0);
#else
	execl("/usr/bin/dc", "dc", "-", 0);
#endif

	return (1);
}

static void
usage(void)
{
	(void) fprintf(stderr, gettext(
	    "usage: bc [ -c ] [ -l ] [ file ... ]\n"));
	exit(2);
}