自学教程：C++ stderror函数代码示例

static intskipargs(Char ***v, const char *dstr, const char *str){    Char  **n = *v, *s;    int dflag = 0, loop = 1;    for (n++; loop && *n != NULL && (*n)[0] == '-'; n++) 	if (*(s = &((*n)[1])) == '/0')	/* test for bare "-" argument */	    dflag |= DIR_OLD;	else if ((*n)[1] == '-' && (*n)[2] == '/0') {   /* test for -- */	    n++;	    break;	} else {	    char *p;	    while (*s != '/0')	/* examine flags */ {		if ((p = strchr(dstr, *s++)) != NULL)		    dflag |= (1 << (p - dstr));	        else		    stderror(ERR_DIRUS, short2str(**v), dstr, str);	    }	}    if (*n && (dflag & DIR_OLD))	stderror(ERR_DIRUS, short2str(**v), dstr, str);    *v = n;    /* make -l, -v, and -n imply -p */    if (dflag & (DIR_LONG|DIR_VERT|DIR_LINE))	dflag |= DIR_PRINT;    return dflag;}

void store_list_push(struct store_list *list, const char *item) {  if (!(list->item = realloc(list->item, sizeof(*list->item) *                                         (list->size + 1))))    stderror("realloc");  if (!(list->item[list->size++] = strdup(item)))    stderror("strdup");}

/*ARGSUSED*/voiddouniverse(Char **v, struct command *c) {    Char *cp = v[1];    Char *cp2;		/* dunno how many elements v comes in with */    char    ubuf[100];    if (cp == 0) {	(void) getuniverse(ubuf);	xprintf("%s/n", ubuf);    }    else {	cp2 = v[2];	if (cp2 == 0) {	    if (*cp == '/0' || setuniverse(short2str(cp)) != 0)		stderror(ERR_NAME | ERR_STRING, CGETS(23, 12, "Illegal universe"));	    }	else {	    (void) getuniverse(ubuf);	    if (*cp == '/0' || setuniverse(short2str(cp)) != 0)		stderror(ERR_NAME | ERR_STRING, CGETS(23, 12, "Illegal universe"));	    cleanup_push(ubuf, setuniverse_cleanup);	    if (setintr) {		pintr_disabled++;		cleanup_push(&pintr_disabled, disabled_cleanup);	    }	    lshift(v, 2);	    if (setintr)		cleanup_until(&pintr_disabled);	    reexecute(c);	    cleanup_until(ubuf);	}    }}

static Char *globtilde(Char *s){    Char *name, *u, *home, *res;    u = s;    for (s++; *s && *s != '/' && *s != ':'; s++)	continue;    name = Strnsave(u + 1, s - (u + 1));    cleanup_push(name, xfree);    home = gethdir(name);    if (home == NULL) {	if (adrof(STRnonomatch)) {	    cleanup_until(name);	    return u;	}	if (*name)	    stderror(ERR_UNKUSER, short2str(name));	else	    stderror(ERR_NOHOME);    }    cleanup_until(name);    if (home[0] == '/' && home[1] == '/0' && s[0] == '/')	res = Strsave(s);    else	res = Strspl(home, s);    xfree(home);    xfree(u);    return res;}

voiddodmmode(Char **v, struct command *c){    Char *cp = v[1];    USE(c);    if ( !cp ) {	int mode;	mode = dmmode(0);	dmmode(mode);	xprintf("%d/n",mode);    }    else {	if (cp[1] != '/0')	    stderror(ERR_NAME | ERR_STRING,		     CGETS(23, 30, "Too many arguments"));	else	    switch(*cp) {	    case '0':		dmmode(0);		break;	    case '1':		dmmode(1);		break;	    default:		stderror(ERR_NAME | ERR_STRING,			 CGETS(23, 31, "Invalid argument"));	    }    }}

/* * dopopd - pop a directory out of the directory stack *	with a numeric argument just discard it. */void/*ARGSUSED*/dopopd(Char **v, struct command *t){    struct directory *dp, *p = NULL;    skipargs(&v, " [+<n>]");    printd = 1;    if (*v == NULL)	dp = dcwd;    else if (v[1] != NULL)	stderror(ERR_NAME | ERR_TOOMANY);    else if ((dp = dfind(*v)) == 0)	stderror(ERR_NAME | ERR_BADDIR);    if (dp->di_prev == &dhead && dp->di_next == &dhead)	stderror(ERR_NAME | ERR_EMPTY);    if (dp == dcwd) {	char *tmp;	if ((p = dp->di_prev) == &dhead)	    p = dhead.di_prev;	if (chdir(tmp = short2str(p->di_name)) < 0)	    stderror(ERR_SYSTEM, tmp, strerror(errno));    }    dp->di_prev->di_next = dp->di_next;    dp->di_next->di_prev = dp->di_prev;    if (dp == dcwd)	dnewcwd(p);    else {	printdirs();    }    dfree(dp);}

int already_running(void){    int ffd;    char buf[16];    fd=open(LOCKFILE,O_RDWR|O_CREAT|LOCKMODE);    if(fd<0)    {        syslog(LOG_ERR,"can;t open %s: %s",LOCKFILE,stderror(errno));        exit(1);    }    if(lockfile(fd)<0)    {        if(errno==EACCES||errno==EAGAIN)        {            close(fd);            return 1;        }        syslog(LOG_ERR,"can't lock %s:%s",LOCKFILE,stderror(errno));        exit(1);    }    ftruncate(fd,0);    sprintf(buf,"%ld",(long)getpid());    write(fd,buf,strlen(buf)+1);    return 0;}

/* * Print the termcap string out with variable substitution */	voidEchoTC(Char **v){	Char **globbed;	char    cv[BUFSIZE];/*FIXBUF*/	int     verbose = 0, silent = 0;	static char *fmts = "%s/n", *fmtd = "%d/n";	int li,co;	setname("echotc");	v = glob_all_or_error(v);	globbed = v;	cleanup_push(globbed, blk_cleanup);	if (!v || !*v || *v[0] == '/0')		goto end;	if (v[0][0] == '-') {		switch (v[0][1]) {			case 'v':				verbose = 1;				break;			case 's':				silent = 1;				break;			default:				stderror(ERR_NAME | ERR_TCUSAGE);				break;		}		v++;	}	if (!*v || *v[0] == '/0')		goto end;	(void) StringCbCopy(cv,sizeof(cv), short2str(*v));	GetSize(&li,&co);	if(!lstrcmp(cv,"rows") || !lstrcmp(cv,"lines") ) {		xprintf(fmtd,T_Lines);		goto end;	}	else if(!lstrcmp(cv,"cols") ) {		xprintf(fmtd,T_ActualWindowSize);		goto end;	}	else if(!lstrcmp(cv,"buffer") ) {		xprintf(fmtd,T_Cols);		goto end;	}	else		stderror(ERR_SYSTEM, "EchoTC","Sorry, this function is not supported");end:	cleanup_until(globbed);}

/*ARGSUSED*/voiddowarp(Char **v, struct command *c) {    int     warp, oldwarp;    struct warpent *we;    volatile struct sigaction old_sigsys_handler;    char   *newwarp;    if (setjmp(sigsys_buf)) {	sigaction(SIGSYS, &old_sigsys_handler, NULL);	stderror(ERR_NAME | ERR_STRING,		 CGETS(23, 8, "You're trapped in a universe you never made"));	return;    }    sigaction(SIGSYS, NULL, &old_sigsys_handler);    signal(SIGSYS, catch_sigsys);    warp = getwarp();    v++;    if (*v == 0) {		/* display warp value */	if (warp < 0)	    stderror(ERR_NAME | ERR_STRING, CGETS(23, 9, "Getwarp failed"));	we = getwarpbyvalue(warp);	if (we)	    printf("%s/n", we->w_name);	else	    printf("%d/n", warp);    }    else {			/* set warp value */	oldwarp = warp;	newwarp = short2str(*v);	if (Isdigit(*v[0]))	    warp = atoi(newwarp);	else {	    we = getwarpbyname(newwarp);	    if (we)		warp = we->w_value;	    else		warp = -1;	}	if ((warp < 0) || (warp >= WARP_MAXLINK))	    stderror(ERR_NAME | ERR_STRING, CGETS(23, 10, "Invalid warp"));	if ((setwarp(warp) < 0) || (getwarp() != warp)) {	    (void) setwarp(oldwarp);	    stderror(ERR_NAME | ERR_STRING, CGETS(23, 11, "Setwarp failed"));	}    }    sigaction(SIGSYS, &old_sigsys_handler, NULL);}

/*ARGSUSED*/voiddochngd(Char **v, struct command *c){    Char *cp;    struct directory *dp;    int dflag = skipargs(&v, "plvn", "[-|<dir>]");    USE(c);    printd = 0;    cp = (dflag & DIR_OLD) ? varval(STRowd) : *v;    if (cp == NULL) {	if (!cdtohome)	    stderror(ERR_NAME | ERR_TOOFEW);	else if ((cp = varval(STRhome)) == STRNULL || *cp == 0)	    stderror(ERR_NAME | ERR_NOHOMEDIR);	if (chdir(short2str(cp)) < 0)	    stderror(ERR_NAME | ERR_CANTCHANGE);	cp = Strsave(cp);    }    else if ((dflag & DIR_OLD) == 0 && v[1] != NULL) {	stderror(ERR_NAME | ERR_TOOMANY);	/* NOTREACHED */	return;    }    else if ((dp = dfind(cp)) != 0) {	char   *tmp;	printd = 1;	if (chdir(tmp = short2str(dp->di_name)) < 0)	    stderror(ERR_SYSTEM, tmp, strerror(errno));	dcwd->di_prev->di_next = dcwd->di_next;	dcwd->di_next->di_prev = dcwd->di_prev;	dfree(dcwd);	dnewcwd(dp, dflag);	return;    }    else	if ((cp = dfollow(cp, dflag & DIR_OLD)) == NULL)	    return;    dp = xcalloc(sizeof(struct directory), 1);    dp->di_name = cp;    dp->di_count = 0;    dp->di_next = dcwd->di_next;    dp->di_prev = dcwd->di_prev;    dp->di_prev->di_next = dp;    dp->di_next->di_prev = dp;    dfree(dcwd);    dnewcwd(dp, dflag);}

/* * dopushd - push new directory onto directory stack. *	with no arguments exchange top and second. *	with numeric argument (+n) bring it to top. */void/*ARGSUSED*/dopushd(Char **v, struct command *t){    struct directory *dp;    skipargs(&v, " [<dir>|+<n>]");    printd = 1;    if (*v == NULL) {	char   *tmp;	if ((dp = dcwd->di_prev) == &dhead)	    dp = dhead.di_prev;	if (dp == dcwd)	    stderror(ERR_NAME | ERR_NODIR);	if (chdir(tmp = short2str(dp->di_name)) < 0)	    stderror(ERR_SYSTEM, tmp, strerror(errno));	dp->di_prev->di_next = dp->di_next;	dp->di_next->di_prev = dp->di_prev;	dp->di_next = dcwd->di_next;	dp->di_prev = dcwd;	dcwd->di_next->di_prev = dp;	dcwd->di_next = dp;    }    else if (v[1] != NULL) {	stderror(ERR_NAME | ERR_TOOMANY);	/* NOTREACHED */	return;    }    else if ((dp = dfind(*v)) != NULL) {	char   *tmp;	if (chdir(tmp = short2str(dp->di_name)) < 0)	    stderror(ERR_SYSTEM, tmp, strerror(errno));    }    else {	Char *ccp;	ccp = dfollow(*v);	dp = xcalloc(1, sizeof(struct directory));	dp->di_name = ccp;	dp->di_count = 0;	dp->di_prev = dcwd;	dp->di_next = dcwd->di_next;	dcwd->di_next = dp;	dp->di_next->di_prev = dp;    }    dnewcwd(dp);}

voidudvar(Char *name){    setname(vis_str(name));    stderror(ERR_NAME | ERR_UNDVAR);    /* NOTREACHED */}

static Char *handleone(Char *str, Char **vl, int action){    size_t chars;    Char **t, *p, *strp;    switch (action) {    case G_ERROR:	setname(short2str(str));	blkfree(vl);	stderror(ERR_NAME | ERR_AMBIG);	break;    case G_APPEND:	chars = 0;	for (t = vl; (p = *t++) != NULL; chars++)	    chars += Strlen(p);	str = xmalloc(chars * sizeof(Char));	for (t = vl, strp = str; (p = *t++) != '/0'; chars++) {	    while (*p)		 *strp++ = *p++ & TRIM;	    *strp++ = ' ';	}	*--strp = '/0';	blkfree(vl);	break;    case G_IGNORE:	str = Strsave(strip(*vl));	blkfree(vl);	break;    default:	break;    }    return (str);}

/* * Like eval, only using the current file descriptors */static voiddoeval1(Char **v){    struct eval1_state state;    Char  **gv;    int gflag;    gflag = tglob(v);    if (gflag) {	gv = v = globall(v, gflag);	if (v == 0)	    stderror(ERR_NOMATCH);	v = copyblk(v);    }    else {	gv = NULL;	v = copyblk(v);	trim(v);    }    if (gv)	cleanup_push(gv, blk_cleanup);    state.evalvec = evalvec;    state.evalp = evalp;    evalvec = v;    evalp = 0;    cleanup_push(&state, eval1_cleanup);    process(0);    cleanup_until(&state);    if (gv)	cleanup_until(gv);}

void nt_set_env(const Char *name, const Char *val) {	char *cname, *cval;	int len;	cname = name?short2str(name):NULL;	if(cname) {		len = lstrlen(cname);		nameBuf = heap_alloc(len+1);		if (!nameBuf) {			stderror(ERR_TOOLARGE);		}		StringCbCopy(nameBuf,len+1,cname);	}	cval = val?short2str(val):NULL;	if(cval) {		len = lstrlen(cval);		valBuf = heap_alloc(len+1);		StringCbCopy(valBuf,len+1,cval);	}	SetEnvironmentVariable(nameBuf,cval?valBuf:NULL);	if (!lstrcmp(nameBuf,"TCSHONLYSTARTEXES")) 		init_shell_dll();	heap_free(nameBuf);	if (cval)		heap_free(valBuf);}

intisapad(void){    static int res = -1;    static status_$t st;    if (res == -1) {	int strm;	if (isatty(0))	    strm = 0;	if (isatty(1))	    strm = 1;	if (isatty(2))	    strm = 2;	else {	    res = 0;	    st.all = status_$ok;	    return(res);	}	res = stream_$isavt(&strm, &st);	res = res ? 1 : 0;    }    else {	if (st.all != status_$ok) 	    stderror(ERR_SYSTEM, "stream_$isavt", apperr(&st));    }    return(res);}

static voidasyn0(struct wordent *p1, struct wordent *p2){    struct wordent *p;    int l;    l = 0;    for (p = p1; p != p2; p = p->next)	switch (p->word[0]) {	case '(':	    l++;	    continue;	case ')':	    l--;	    if (l < 0)		stderror(ERR_TOOMANYRP);	    continue;	case '>':	    if (p->next != p2 && eq(p->next->word, STRand))		p = p->next;	    continue;	case '&':	case '|':	case ';':	case '/n':	    if (l != 0)		continue;	    asyn3(p1, p);	    asyntax(p->next, p2);	    return;	}    if (l == 0)	asyn3(p1, p2);}

char *json_decode(char *str, uint32_t len) {  static struct {    char *ent, ctr;  } set[] = {    { "////", '//' },    { "///"",  '"' },    {  "//'", '/'' },  };  uint32_t i, num;  char *ptr, *nptr, *nstr;  bool f;  if (!(nstr = calloc(len + 1, 1)))    stderror("calloc");  for (ptr = str, nptr = nstr; ptr - str < len; ptr++) {    if (*ptr == '//') {      for (f = false, i = 0; i < sizeof(set) / sizeof(*set); i++) {        if (!strncmp(ptr, set[i].ent, strlen(set[i].ent))) {          *nptr++ = set[i].ctr;          ptr += strlen(set[i].ent) - 1;          f = true;          break;        }      }      if (!f && ptr[1] == 'x') {        num = strtoul(ptr + 2, NULL, 16);        if (num > 0xff) {          *nptr++ = num & 0xff;          *nptr++ = (num >> 8) & 0xff;        } else {          *nptr++ = num;        }        ptr++;      }

char *json_encode(char *str, uint32_t len) {  static char *set[0xff] = {    ['//'] = "////",    ['"']  = "///"",  };  char *ptr, *nptr, *nstr, *f;  uint32_t rlen;  for (rlen = 0, ptr = str; ptr - str < len; ptr++) {    f = set[(uint8_t)*ptr];    if (f)      rlen += strlen(f);    else if (!isprint(*ptr))      rlen += 4;    else      rlen++;  }  if (!(nstr = calloc(rlen + 1, 1)))    stderror("calloc");  for (ptr = str, nptr = nstr; ptr - str < len; ptr++) {    f = set[(uint8_t)*ptr];    if (f) {      strcpy(nptr, f);      nptr += strlen(f);    } else if (!isprint(*ptr)) {      sprintf(nptr, "//x%02X", (uint8_t)*ptr);      nptr += 4;    } else {      *nptr++ = *ptr;    }  }  *nptr = 0;  return nstr;}

/*ARGSUSED*/voiddodirs(Char **v, struct command *c){    static const char flags[] = "plvnSLc";    int dflag = skipargs(&v, flags, "");    USE(c);    if ((dflag & DIR_CLEAR) != 0) {	struct directory *dp, *fdp;	for (dp = dcwd->di_next; dp != dcwd; ) {	    fdp = dp;	    dp = dp->di_next;	    if (fdp != &dhead)		dfree(fdp);	}	dhead.di_next = dhead.di_prev = dp;	dp->di_next = dp->di_prev = &dhead;    }    if ((dflag & DIR_LOAD) != 0) 	loaddirs(*v);    else if ((dflag & DIR_SAVE) != 0)	recdirs(*v, 1);    if (*v && (dflag & (DIR_SAVE|DIR_LOAD)))	v++;    if (*v != NULL || (dflag & DIR_OLD))	stderror(ERR_DIRUS, "dirs", flags, "");    if ((dflag & (DIR_CLEAR|DIR_LOAD|DIR_SAVE)) == 0 || (dflag & DIR_PRINT))	printdirs(dflag);}

static voidskipargs(Char ***v, const char *str){    Char  **n, *s;    n = *v;    dirflag = 0;    for (n++; *n != NULL && (*n)[0] == '-'; n++)	for (s = &((*n)[1]); *s; s++)	    switch (*s) {	    case 'l':		dirflag |= DIR_LONG;		break;	    case 'n':		dirflag |= DIR_LINE;		break;	    case 'v':		dirflag |= DIR_VERT;		break;	    default:		stderror(ERR_DIRUS, vis_str(**v), str);		/* NOTREACHED */	    }    *v = n;}

struct store_list *store_list_new() {  struct store_list *list;  if (!(list = calloc(sizeof(*list), 1)))    stderror("calloc");  return list;}

static voidpexerr(void){    /* Couldn't find the damn thing */    if (expath) {	setname(vis_str(expath));	Vexpath = 0;	xfree(expath);	expath = 0;    }    else	setname("");    if (exerr)	stderror(ERR_NAME | ERR_STRING, exerr);    stderror(ERR_NAME | ERR_COMMAND);}

void *reallocv(char *filename, u_int32_t line, void *ptr, size_t size) {			size_t delSize=0;	if (ptr) {		delSize=del(&list, ptr);		if (!delSize) {#if DEBUG >= 4			myerror("No memory allocated for ptr %x freed (realloc) at %s:%u!", ptr, filename, line);#endif		}		mem_used -= delSize;	}	void* newPtr = realloc(ptr, size);	if (size && (newPtr == NULL)) {		stderror();		exit(1);			}	if (newPtr)		add(&list, newPtr, size, filename, line);		mem_used += size;	#if DEBUG >= 3	myerror("%d bytes reallocated in %s:%u, old ptr=%x, new ptr=%x (total memory %d)!", size-delSize, filename, line, ptr, newPtr, mem_used);#endif	return newPtr;}

voidfg_proc_entry(struct process *pp){    jmp_buf_t osetexit;    int    ohaderr;    Char    oGettingInput;    size_t omark;    getexit(osetexit);    pintr_disabled++;    oGettingInput = GettingInput;    GettingInput = 0;    ohaderr = haderr;		/* we need to ignore setting of haderr due to				 * process getting stopped by a signal */    omark = cleanup_push_mark();    if (setexit() == 0) {	/* come back here after pjwait */	pendjob();	(void) alarm(0);	/* No autologout */	alrmcatch_disabled = 1;	if (!pstart(pp, 1)) {	    pp->p_procid = 0;	    stderror(ERR_BADJOB, pp->p_command, strerror(errno));	}	pjwait(pp);    }    setalarm(1);		/* Autologout back on */    cleanup_pop_mark(omark);    resexit(osetexit);    haderr = ohaderr;    GettingInput = oGettingInput;    disabled_cleanup(&pintr_disabled);}

static voidfixDolMod(void){    int c;    c = DgetC(0);    if (c == ':') {	do {	    c = DgetC(0), dolmcnt = 1, dolwcnt = 1;	    if (c == 'g' || c == 'a') {		if (c == 'g')		    dolmcnt = 10000;		else		    dolwcnt = 10000;		c = DgetC(0);	    }	    if ((c == 'g' && dolmcnt != 10000) ||		(c == 'a' && dolwcnt != 10000)) {		if (c == 'g')		    dolmcnt = 10000;		else		    dolwcnt = 10000;		c = DgetC(0);	    }	    if (c == 's') {	/* [eichin:19910926.0755EST] */		int delimcnt = 2;		int delim = DgetC(0);		dolmod[dolnmod++] = c;		dolmod[dolnmod++] = delim;		if (!delim || letter(delim)		    || Isdigit(delim) || any(" /t/n", delim)) {		    seterror(ERR_BADSUBST);		    break;		}		while ((c = DgetC(0)) != (-1)) {		    dolmod[dolnmod++] = c;		    if(c == delim) delimcnt--;		    if(!delimcnt) break;		}		if(delimcnt) {		    seterror(ERR_BADSUBST);		    break;		}		continue;	    }	    if (!any("htrqxes", c))		stderror(ERR_BADMOD, c);	    dolmod[dolnmod++] = c;	    if (c == 'q')		dolmcnt = 10000;	}	while ((c = DgetC(0)) == ':');	unDredc(c);    }    else	unDredc(c);}

static voidfixDolMod(void){    eChar c;    c = DgetC(0);    if (c == ':') {	do {	    c = DgetC(0), dolmcnt = 1, dol_flag_a = 0;	    if (c == 'g' || c == 'a') {		if (c == 'g')		    dolmcnt = INT_MAX;		else		    dol_flag_a = 1;		c = DgetC(0);	    }	    if ((c == 'g' && dolmcnt != INT_MAX) || 		(c == 'a' && dol_flag_a == 0)) {		if (c == 'g')		    dolmcnt = INT_MAX;		else		    dol_flag_a = 1;		c = DgetC(0);	    }	    if (c == 's') {	/* [eichin:19910926.0755EST] */		int delimcnt = 2;		eChar delim = DgetC(0);		Strbuf_append1(&dolmod, (Char) c);		Strbuf_append1(&dolmod, (Char) delim);		if (delim == DEOF || !delim || letter(delim)		    || Isdigit(delim) || any(" /t/n", delim)) {		    seterror(ERR_BADSUBST);		    break;		}			while ((c = DgetC(0)) != DEOF) {		    Strbuf_append1(&dolmod, (Char) c);		    if(c == delim) delimcnt--;		    if(!delimcnt) break;		}		if(delimcnt) {		    seterror(ERR_BADSUBST);		    break;		}		continue;	    }	    if (!any("luhtrqxes", c))		stderror(ERR_BADMOD, (int)c);	    Strbuf_append1(&dolmod, (Char) c);	    if (c == 'q')		dolmcnt = INT_MAX;	}	while ((c = DgetC(0)) == ':');	unDredc(c);    }    else	unDredc(c);}

voidpintr1(int wantnl){    Char **v;    sigset_t nsigset, osigset;    sigemptyset(&nsigset);    (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset);    if (setintr) {	nsigset = osigset;	(void)sigdelset(&nsigset, SIGINT);	(void)sigprocmask(SIG_SETMASK, &nsigset, NULL);	if (pjobs) {	    pjobs = 0;	    (void)fprintf(cshout, "/n");	    dojobs(jobargv, NULL);	    stderror(ERR_NAME | ERR_INTR);	}    }    (void)sigdelset(&osigset, SIGCHLD);    (void)sigprocmask(SIG_SETMASK, &osigset, NULL);    (void)fpurge(cshout);    (void)endpwent();    /*     * If we have an active "onintr" then we search for the label. Note that if     * one does "onintr -" then we shan't be interruptible so we needn't worry     * about that here.     */    if (gointr) {	gotolab(gointr);	timflg = 0;	if ((v = pargv) != NULL)	    pargv = 0, blkfree(v);	if ((v = gargv) != NULL)	    gargv = 0, blkfree(v);	reset();    }    else if (intty && wantnl) {	(void)fputc('/r', cshout);	(void)fputc('/n', cshout);    }    stderror(ERR_SILENT);    /* NOTREACHED */}