[unix-history] / usr / src / bin / csh / err.c

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley Software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char *sccsid = "@(#)err.c	5.3 (Berkeley) %G%";
#endif

#include "sh.h"
#include <sys/ioctl.h>

/*
 * C Shell
 */

bool	errspl;			/* Argument to error was spliced by seterr2 */
char	one[2] = { '1', 0 };
char	*onev[2] = { one, NOSTR };
/*
 * Print error string s with optional argument arg.
 * This routine always resets or exits.  The flag haderr
 * is set so the routine who catches the unwind can propogate
 * it if they want.
 *
 * Note that any open files at the point of error will eventually
 * be closed in the routine process in sh.c which is the only
 * place error unwinds are ever caught.
 */
/*VARARGS1*/
error(s, arg)
	char *s;
{
	register char **v;
	register char *ep;

	/*
	 * Must flush before we print as we wish output before the error
	 * to go on (some form of) standard output, while output after
	 * goes on (some form of) diagnostic output.
	 * If didfds then output will go to 1/2 else to FSHOUT/FSHDIAG.
	 * See flush in sh.print.c.
	 */
	flush();
	haderr = 1;		/* Now to diagnostic output */
	timflg = 0;		/* This isn't otherwise reset */
	if (v = pargv)
		pargv = 0, blkfree(v);
	if (v = gargv)
		gargv = 0, blkfree(v);

	/*
	 * A zero arguments causes no printing, else print
	 * an error diagnostic here.
	 */
	if (s)
		printf(s, arg), printf(".\n");

	didfds = 0;		/* Forget about 0,1,2 */
	if ((ep = err) && errspl) {
		errspl = 0;
		xfree(ep);
	}
	errspl = 0;

	/*
	 * Go away if -e or we are a child shell
	 */
	if (exiterr || child)
		exit(1);

	/*
	 * Reset the state of the input.
	 * This buffered seek to end of file will also
	 * clear the while/foreach stack.
	 */
	btoeof();

	setq("status", onev, &shvhed);
	if (tpgrp > 0)
		(void) ioctl(FSHTTY, TIOCSPGRP, (char *)&tpgrp);
	reset();		/* Unwind */
}

/*
 * Perror is the shells version of perror which should otherwise
 * never be called.
 */
Perror(s)
	char *s;
{

	/*
	 * Perror uses unit 2, thus if we didn't set up the fd's
	 * we must set up unit 2 now else the diagnostic will disappear
	 */
	if (!didfds) {
		register int oerrno = errno;

		(void) dcopy(SHDIAG, 2);
		errno = oerrno;
	}
	perror(s);
	error(NOSTR);		/* To exit or unwind */
}

bferr(cp)
	char *cp;
{

	flush();
	haderr = 1;
	printf("%s: ", bname);
	error(cp);
}

/*
 * The parser and scanner set up errors for later by calling seterr,
 * which sets the variable err as a side effect; later to be tested,
 * e.g. in process.
 */
seterr(s)
	char *s;
{

	if (err == 0)
		err = s, errspl = 0;
}

/* Set err to a splice of cp and dp, to be freed later in error() */
seterr2(cp, dp)
	char *cp, *dp;
{

	if (err)
		return;
	err = strspl(cp, dp);
	errspl++;
}

/* Set err to a splice of cp with a string form of character d */
seterrc(cp, d)
	char *cp, d;
{
	char chbuf[2];

	chbuf[0] = d;
	chbuf[1] = 0;
	seterr2(cp, chbuf);
}
Commit	Line	Data
b79f4fa9 DF	1	/*
b79f4fa9 DF	2	* Copyright (c) 1980 Regents of the University of California.
094e80ed	3	* All rights reserved. The Berkeley Software License Agreement
b79f4fa9 DF	4	* specifies the terms and conditions for redistribution.
	5	*/
	6
35371dec	7	#ifndef lint
d337ee8d	8	static char *sccsid = "@(#)err.c 5.3 (Berkeley) %G%";
094e80ed	9	#endif
830edfac BJ	10
	11	#include "sh.h"
	12	#include <sys/ioctl.h>
	13
	14	/*
	15	* C Shell
	16	*/
	17
	18	bool errspl; /* Argument to error was spliced by seterr2 */
	19	char one[2] = { '1', 0 };
	20	char *onev[2] = { one, NOSTR };
	21	/*
	22	* Print error string s with optional argument arg.
	23	* This routine always resets or exits. The flag haderr
	24	* is set so the routine who catches the unwind can propogate
	25	* it if they want.
	26	*
	27	* Note that any open files at the point of error will eventually
	28	* be closed in the routine process in sh.c which is the only
	29	* place error unwinds are ever caught.
	30	*/
35371dec	31	/VARARGS1/
830edfac BJ	32	error(s, arg)
	33	char *s;
	34	{
	35	register char **v;
	36	register char *ep;
	37
	38	/*
	39	* Must flush before we print as we wish output before the error
	40	* to go on (some form of) standard output, while output after
	41	* goes on (some form of) diagnostic output.
	42	* If didfds then output will go to 1/2 else to FSHOUT/FSHDIAG.
	43	* See flush in sh.print.c.
	44	*/
	45	flush();
	46	haderr = 1; /* Now to diagnostic output */
	47	timflg = 0; /* This isn't otherwise reset */
	48	if (v = pargv)
	49	pargv = 0, blkfree(v);
	50	if (v = gargv)
	51	gargv = 0, blkfree(v);
	52
	53	/*
	54	* A zero arguments causes no printing, else print
	55	* an error diagnostic here.
	56	*/
	57	if (s)
	58	printf(s, arg), printf(".\n");
	59
	60	didfds = 0; /* Forget about 0,1,2 */
	61	if ((ep = err) && errspl) {
	62	errspl = 0;
	63	xfree(ep);
	64	}
	65	errspl = 0;
	66
d337ee8d JL	67	/*
	68	* Go away if -e or we are a child shell
	69	*/
	70	if (exiterr \|\| child)
	71	exit(1);
	72
830edfac BJ	73	/*
	74	* Reset the state of the input.
	75	* This buffered seek to end of file will also
	76	* clear the while/foreach stack.
	77	*/
	78	btoeof();
	79
830edfac BJ	80	setq("status", onev, &shvhed);
830edfac BJ	81	if (tpgrp > 0)
35371dec	82	(void) ioctl(FSHTTY, TIOCSPGRP, (char *)&tpgrp);
830edfac BJ	83	reset(); /* Unwind */
	84	}
	85
	86	/*
	87	* Perror is the shells version of perror which should otherwise
	88	* never be called.
	89	*/
	90	Perror(s)
	91	char *s;
	92	{
	93
	94	/*
	95	* Perror uses unit 2, thus if we didn't set up the fd's
	96	* we must set up unit 2 now else the diagnostic will disappear
	97	*/
	98	if (!didfds) {
	99	register int oerrno = errno;
	100
35371dec	101	(void) dcopy(SHDIAG, 2);
830edfac BJ	102	errno = oerrno;
	103	}
	104	perror(s);
	105	error(NOSTR); /* To exit or unwind */
	106	}
	107
	108	bferr(cp)
	109	char *cp;
	110	{
	111
	112	flush();
	113	haderr = 1;
	114	printf("%s: ", bname);
	115	error(cp);
	116	}
	117
	118	/*
	119	* The parser and scanner set up errors for later by calling seterr,
	120	* which sets the variable err as a side effect; later to be tested,
	121	* e.g. in process.
	122	*/
	123	seterr(s)
	124	char *s;
	125	{
	126
	127	if (err == 0)
	128	err = s, errspl = 0;
	129	}
	130
	131	/* Set err to a splice of cp and dp, to be freed later in error() */
	132	seterr2(cp, dp)
	133	char cp, dp;
	134	{
	135
	136	if (err)
	137	return;
	138	err = strspl(cp, dp);
	139	errspl++;
	140	}
	141
	142	/* Set err to a splice of cp with a string form of character d */
	143	seterrc(cp, d)
	144	char *cp, d;
	145	{
	146	char chbuf[2];
	147
	148	chbuf[0] = d;
	149	chbuf[1] = 0;
	150	seterr2(cp, chbuf);
	151	}