 @@ -1,903 +1,904 @@
-/* $NetBSD: dir.c,v 1.35 2020/08/09 00:34:21 dholland Exp $ */
+/* $NetBSD: dir.c,v 1.36 2024/04/24 15:49:03 nia Exp $ */
 /*-
  * Copyright (c) 1980, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)dir.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: dir.c,v 1.35 2020/08/09 00:34:21 dholland Exp $");
+__RCSID("$NetBSD: dir.c,v 1.36 2024/04/24 15:49:03 nia Exp $");
 #endif
 #endif /* not lint */
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "csh.h"
 #include "dir.h"
 #include "extern.h"
 /* Directory management. */
 static struct directory *dfind(Char *);
 static Char *dfollow(Char *);
 static void printdirs(void);
 static Char *dgoto(Char *);
 static void skipargs(Char ***, const char *);
 static void dnewcwd(struct directory *);
 static void dset(Char *);
 struct directory dhead;		/* "head" of loop */
 int printd;			/* force name to be printed */
 static int dirflag = 0;
 struct directory *dcwd;
 /*
  * dinit - initialize current working directory
  */
 void
 dinit(Char *hp)
+{
     static const char emsg[] = "csh: Trying to start from \"%s\"\n";
     char path[MAXPATHLEN];
     struct directory *dp;
     const char *ecp;
     Char *cp;
     /* Don't believe the login shell home, because it may be a symlink */
     ecp = getcwd(path, MAXPATHLEN);
     if (ecp == NULL || *ecp == '\0') {
 	(void)fprintf(csherr, "csh: %s\n", strerror(errno));
 	if (hp && *hp) {
 	    ecp = short2str(hp);
 	    if (chdir(ecp) == -1)
 		cp = NULL;
 	    else
 		cp = Strsave(hp);
 	    (void)fprintf(csherr, emsg, vis_str(hp));
+	}
 	else
 	    cp = NULL;
 	if (cp == NULL) {
 	    (void)fprintf(csherr, emsg, "/");
 	    if (chdir("/") == -1) {
 		/* I am not even try to print an error message! */
 		xexit(1);
+	    }
 	    cp = SAVE("/");
+	}
+    }
     else {
 	struct stat swd, shp;
 	/*
 	 * See if $HOME is the working directory we got and use that
 	 */
 	if (hp && *hp &&
 	    stat(ecp, &swd) != -1 && stat(short2str(hp), &shp) != -1 &&
 	    swd.st_dev == shp.st_dev && swd.st_ino == shp.st_ino)
 	    cp = Strsave(hp);
 	else {
 	    const char *cwd;
 	    /*
 	     * use PWD if we have it (for subshells)
 	     */
 	    if ((cwd = getenv("PWD")) != NULL) {
 		if (stat(cwd, &shp) != -1 && swd.st_dev == shp.st_dev &&
 		    swd.st_ino == shp.st_ino)
 		    ecp = cwd;
+	    }
 	    cp = dcanon(SAVE(ecp), STRNULL);
+	}
+    }
     dp = xcalloc(1, sizeof(*dp));
     dp->di_name = cp;
     dp->di_count = 0;
     dhead.di_next = dhead.di_prev = dp;
     dp->di_next = dp->di_prev = &dhead;
     printd = 0;
     dnewcwd(dp);
+}
 static void
 dset(Char *dp)
+{
     Char **vec;
     /*
      * Don't call set() directly cause if the directory contains ` or
      * other junk characters glob will fail.
      */
     vec = xmalloc(2 * sizeof(*vec));
     vec[0] = Strsave(dp);
     vec[1] = 0;
     setq(STRcwd, vec, &shvhed);
     Setenv(STRPWD, dp);
+}
 #define DIR_LONG 1
 #define DIR_VERT 2
 #define DIR_LINE 4
 static void
 skipargs(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;
+}
 /*
  * dodirs - list all directories in directory loop
  */
 void
 /*ARGSUSED*/
 dodirs(Char **v, struct command *t)
+{
     skipargs(&v, "");
     if (*v != NULL)
 	stderror(ERR_DIRUS, "dirs", "");
     printdirs();
+}
 static void
 printdirs(void)
+{
     struct directory *dp;
     Char *hp, *s;
     size_t cur, idx, len;
     hp = value(STRhome);
     if (*hp == '\0')
 	hp = NULL;
     dp = dcwd;
     idx = 0;
     cur = 0;
     do {
 	if (dp == &dhead)
 	    continue;
 	if (dirflag & DIR_VERT) {
 	    (void)fprintf(cshout, "%zu\t", idx++);
 	    cur = 0;
+	}
 	if (!(dirflag & DIR_LONG) && hp != NULL && !eq(hp, STRslash) &&
 	    (len = Strlen(hp), Strncmp(hp, dp->di_name, len) == 0) &&
 	    (dp->di_name[len] == '\0' || dp->di_name[len] == '/'))
 	    len = Strlen(s = (dp->di_name + len)) + 2;
 	else
 	    len = Strlen(s = dp->di_name) + 1;
 	cur += len;
 	if ((dirflag & DIR_LINE) && cur >= 80 - 1 && len < 80) {
 	    (void)fprintf(cshout, "\n");
 	    cur = len;
+	}
 	(void) fprintf(cshout, "%s%s%c", (s != dp->di_name)? "~" : "",
 	    vis_str(s), (dirflag & DIR_VERT) ? '\n' : ' ');
     } while ((dp = dp->di_prev) != dcwd);
     if (!(dirflag & DIR_VERT))
 	(void)fprintf(cshout, "\n");
+}
 void
 dtildepr(Char *home, Char *dir)
+{
     if (!eq(home, STRslash) && prefix(home, dir))
 	(void)fprintf(cshout, "~%s", vis_str(dir + Strlen(home)));
     else
 	(void)fprintf(cshout, "%s", vis_str(dir));
+}
 void
 dtilde(void)
+{
     struct directory *d;
     d = dcwd;
     do {
 	if (d == &dhead)
 	    continue;
 	d->di_name = dcanon(d->di_name, STRNULL);
     } while ((d = d->di_prev) != dcwd);
     dset(dcwd->di_name);
+}
 /* dnormalize():
  *	If the name starts with . or .. then we might need to normalize
  *	it depending on the symbolic link flags
  */
 Char *
 dnormalize(Char *cp)
+{
 #define UC (unsigned char)
 #define ISDOT(c) (UC(c)[0] == '.' && ((UC(c)[1] == '\0') || (UC(c)[1] == '/')))
 #define ISDOTDOT(c) (UC(c)[0] == '.' && ISDOT(&((c)[1])))
     if ((unsigned char) cp[0] == '/')
 	return (Strsave(cp));
     if (adrof(STRignore_symlinks)) {
 	size_t  dotdot = 0;
 	Char   *dp, *cwd;
-	cwd = xmalloc((size_t)((Strlen(dcwd->di_name) + 3) *
+	cwd = xreallocarray(NULL, (size_t)(Strlen(dcwd->di_name) + 3),
-	    sizeof(Char)));
+	    sizeof(Char));
 	(void)Strcpy(cwd, dcwd->di_name);
 	/*
 	 * Ignore . and count ..'s
 	 */
 	while (*cp) {
 	    if (ISDOT(cp)) {
 		if (*++cp)
 		    cp++;
+	    }
 	    else if (ISDOTDOT(cp)) {
 		dotdot++;
 		cp += 2;
 		if (*cp)
 		    cp++;
+	    }
 	    else
 		break;
+	}
 	while (dotdot > 0) {
 	    dp = Strrchr(cwd, '/');
 	    if (dp) {
 		*dp = '\0';
 		dotdot--;
+	    }
 	    else
 		break;
+	}
 	if (*cp) {
 	    cwd[dotdot = Strlen(cwd)] = '/';
 	    cwd[dotdot + 1] = '\0';
 	    dp = Strspl(cwd, cp);
 	    free(cwd);
 	    return dp;
+	}
 	else {
 	    if (!*cwd) {
 		cwd[0] = '/';
 		cwd[1] = '\0';
+	    }
 	    return cwd;
+	}
+    }
     return Strsave(cp);
+}
 /*
  * dochngd - implement chdir command.
  */
 void
 /*ARGSUSED*/
 dochngd(Char **v, struct command *t)
+{
     struct directory *dp;
     Char *cp;
     skipargs(&v, " [<dir>]");
     printd = 0;
     if (*v == NULL) {
 	if ((cp = value(STRhome)) == NULL || *cp == 0)
 	    stderror(ERR_NAME | ERR_NOHOMEDIR);
 	if (chdir(short2str(cp)) < 0)
 	    stderror(ERR_NAME | ERR_CANTCHANGE);
 	cp = Strsave(cp);
+    }
     else if (v[1] != NULL)
 	stderror(ERR_NAME | ERR_TOOMANY);
     else if ((dp = dfind(*v)) != 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);
 	return;
+    }
     else
 	cp = dfollow(*v);
     dp = xcalloc(1, sizeof(*dp));
     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);
+}
 static Char *
 dgoto(Char *cp)
+{
     Char *dp;
     if (*cp != '/') {
 	Char *p, *q;
 	size_t cwdlen;
 	for (p = dcwd->di_name; *p++;)
 	    continue;
 	if ((cwdlen = (size_t)(p - dcwd->di_name - 1)) == 1)	/* root */
 	    cwdlen = 0;
 	for (p = cp; *p++;)
 	    continue;
-	dp = xmalloc((size_t)(cwdlen + (size_t)(p - cp) + 1) * sizeof(Char));
+	dp = xreallocarray(NULL,
 	    (size_t)(cwdlen + (size_t)(p - cp) + 1), sizeof(Char));
 	for (p = dp, q = dcwd->di_name; (*p++ = *q++) != '\0';)
 	    continue;
 	if (cwdlen)
 	    p[-1] = '/';
 	else
 	    p--;		/* don't add a / after root */
 	for (q = cp; (*p++ = *q++) != '\0';)
 	    continue;
 	free(cp);
 	cp = dp;
 	dp += cwdlen;
+    }
     else
 	dp = cp;
     cp = dcanon(cp, dp);
     return cp;
+}
 /*
  * dfollow - change to arg directory; fall back on cdpath if not valid
  */
 static Char *
 dfollow(Char *cp)
+{
     char ebuf[MAXPATHLEN];
     struct varent *c;
     Char *dp;
     int serrno;
     cp = globone(cp, G_ERROR);
     /*
      * if we are ignoring symlinks, try to fix relatives now.
      */
     dp = dnormalize(cp);
     if (chdir(short2str(dp)) >= 0) {
 	free(cp);
 	return dgoto(dp);
+    }
     else {
 	free(dp);
 	if (chdir(short2str(cp)) >= 0)
 	    return dgoto(cp);
 	serrno = errno;
+    }
     if (cp[0] != '/' && !prefix(STRdotsl, cp) && !prefix(STRdotdotsl, cp)
 	&& (c = adrof(STRcdpath))) {
 	Char  **cdp;
 	Char *p;
 	Char    buf[MAXPATHLEN];
 	for (cdp = c->vec; *cdp; cdp++) {
 	    for (dp = buf, p = *cdp; (*dp++ = *p++) != '\0';)
 		continue;
 	    dp[-1] = '/';
 	    for (p = cp; (*dp++ = *p++) != '\0';)
 		continue;
 	    if (chdir(short2str(buf)) >= 0) {
 		printd = 1;
 		free(cp);
 		cp = Strsave(buf);
 		return dgoto(cp);
+	    }
+	}
+    }
     dp = value(cp);
     if ((dp[0] == '/' || dp[0] == '.') && chdir(short2str(dp)) >= 0) {
 	free(cp);
 	cp = Strsave(dp);
 	printd = 1;
 	return dgoto(cp);
+    }
     (void)strcpy(ebuf, short2str(cp));
     free(cp);
     stderror(ERR_SYSTEM, ebuf, strerror(serrno));
     /* NOTREACHED */
+}
 /*
  * 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);
     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(*dp));
 	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);
+}
 /*
  * dfind - find a directory if specified by numeric (+n) argument
  */
 static struct directory *
 dfind(Char *cp)
+{
     struct directory *dp;
     Char *ep;
     int i;
     if (*cp++ != '+')
 	return (0);
     for (ep = cp; Isdigit(*ep); ep++)
 	continue;
     if (*ep)
 	return (0);
     i = getn(cp);
     if (i <= 0)
 	return (0);
     for (dp = dcwd; i != 0; i--) {
 	if ((dp = dp->di_prev) == &dhead)
 	    dp = dp->di_prev;
 	if (dp == dcwd)
 	    stderror(ERR_NAME | ERR_DEEP);
+    }
     return (dp);
+}
 /*
  * 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);
+}
 /*
  * dfree - free the directory (or keep it if it still has ref count)
  */
 void
 dfree(struct directory *dp)
+{
     if (dp->di_count != 0) {
 	dp->di_next = dp->di_prev = 0;
+    }
     else {
 	free(dp->di_name);
 	free(dp);
+    }
+}
 /*
  * dcanon - canonicalize the pathname, removing excess ./ and ../ etc.
  *	we are of course assuming that the file system is standardly
  *	constructed (always have ..'s, directories have links)
  */
 Char *
 dcanon(Char *cp, Char *p)
+{
     Char slink[MAXPATHLEN];
     char tlink[MAXPATHLEN];
     Char *newcp, *sp;
     Char *p1, *p2;	/* general purpose */
     ssize_t cc;
     size_t len;
     int slash;
     /*
      * christos: if the path given does not start with a slash prepend cwd. If
      * cwd does not start with a path or the result would be too long abort().
      */
     if (*cp != '/') {
 	Char tmpdir[MAXPATHLEN];
 	p1 = value(STRcwd);
 	if (p1 == NULL || *p1 != '/')
 	    abort();
 	if (Strlen(p1) + Strlen(cp) + 1 >= MAXPATHLEN)
 	    abort();
 	(void)Strcpy(tmpdir, p1);
 	(void)Strcat(tmpdir, STRslash);
 	(void)Strcat(tmpdir, cp);
 	free(cp);
 	cp = p = Strsave(tmpdir);
+    }
     while (*p) {		/* for each component */
 	sp = p;			/* save slash address */
 	while (*++p == '/')	/* flush extra slashes */
 	    continue;
 	if (p != ++sp)
 	    for (p1 = sp, p2 = p; (*p1++ = *p2++) != '\0';)
 		continue;
 	p = sp;			/* save start of component */
 	slash = 0;
 	while (*++p)		/* find next slash or end of path */
 	    if (*p == '/') {
 		slash = 1;
 		*p = 0;
 		break;
+	    }
 	if (*sp == '\0') {	/* if component is null */
 	    if (--sp == cp)	/* if path is one char (i.e. /) */
 		break;
 	    else
 		*sp = '\0';
 	} else if (sp[0] == '.' && sp[1] == 0) {
 	    if (slash) {
 		for (p1 = sp, p2 = p + 1; (*p1++ = *p2++) != '\0';)
 		    continue;
 		p = --sp;
+	    }
 	    else if (--sp != cp)
 		*sp = '\0';
+	}
 	else if (sp[0] == '.' && sp[1] == '.' && sp[2] == 0) {
 	    /*
 	     * We have something like "yyy/xxx/..", where "yyy" can be null or
 	     * a path starting at /, and "xxx" is a single component. Before
 	     * compressing "xxx/..", we want to expand "yyy/xxx", if it is a
 	     * symbolic link.
 	     */
 	    *--sp = 0;		/* form the pathname for readlink */
 	    if (sp != cp && !adrof(STRignore_symlinks) &&
 		(cc = readlink(short2str(cp), tlink,
 			       sizeof(tlink) - 1)) >= 0) {
 		tlink[cc] = '\0';
 		(void)Strcpy(slink, str2short(tlink));
 		if (slash)
 		    *p = '/';
 		/*
 		 * Point p to the '/' in "/..", and restore the '/'.
 		 */
 		*(p = sp) = '/';
 		/*
 		 * find length of p
 		 */
 		for (p1 = p; *p1++;)
 		    continue;
 		if (*slink != '/') {
 		    /*
 		     * Relative path, expand it between the "yyy/" and the
 		     * "/..". First, back sp up to the character past "yyy/".
 		     */
 		    while (*--sp != '/')
 			continue;
 		    sp++;
 		    *sp = 0;
 		    /*
 		     * New length is "yyy/" + slink + "/.." and rest
 		     */
-		    p1 = newcp = xmalloc(
+		    p1 = newcp = xreallocarray(NULL,
-		        (size_t)((sp - cp) + cc + (p1 - p)) * sizeof(Char));
+		        (size_t)((sp - cp) + cc + (p1 - p)), sizeof(Char));
 		    /*
 		     * Copy new path into newcp
 		     */
 		    for (p2 = cp; (*p1++ = *p2++) != '\0';)
 			continue;
 		    for (p1--, p2 = slink; (*p1++ = *p2++) != '\0';)
 			continue;
 		    for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
 			continue;
 		    /*
 		     * Restart canonicalization at expanded "/xxx".
 		     */
 		    p = sp - cp - 1 + newcp;
+		}
 		else {
 		    /*
 		     * New length is slink + "/.." and rest
 		     */
-		    p1 = newcp = xmalloc(
+		    p1 = newcp = xreallocarray(NULL,
-		        (size_t)(cc + (p1 - p)) * sizeof(Char));
+		        (size_t)(cc + (p1 - p)), sizeof(Char));
 		    /*
 		     * Copy new path into newcp
 		     */
 		    for (p2 = slink; (*p1++ = *p2++) != '\0';)
 			continue;
 		    for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
 			continue;
 		    /*
 		     * Restart canonicalization at beginning
 		     */
 		    p = newcp;
+		}
 		free(cp);
 		cp = newcp;
 		continue;	/* canonicalize the link */
+	    }
 	    *sp = '/';
 	    if (sp != cp)
 		while (*--sp != '/')
 		    continue;
 	    if (slash) {
 		for (p1 = sp + 1, p2 = p + 1; (*p1++ = *p2++) != '\0';)
 		    continue;
 		p = sp;
+	    }
 	    else if (cp == sp)
 		*++sp = '\0';
 	    else
 		*sp = '\0';
+	}
 	else {			/* normal dir name (not . or .. or nothing) */
 	    if (sp != cp && adrof(STRchase_symlinks) &&
 		!adrof(STRignore_symlinks) &&
 		(cc = readlink(short2str(cp), tlink, sizeof(tlink)-1)) >= 0) {
 		tlink[cc] = '\0';
 		(void)Strcpy(slink, str2short(tlink));
 		/*
 		 * restore the '/'.
 		 */
 		if (slash)
 		    *p = '/';
 		/*
 		 * point sp to p (rather than backing up).
 		 */
 		sp = p;
 		/*
 		 * find length of p
 		 */
 		for (p1 = p; *p1++;)
 		    continue;
 		if (*slink != '/') {
 		    /*
 		     * Relative path, expand it between the "yyy/" and the
 		     * remainder. First, back sp up to the character past
 		     * "yyy/".
 		     */
 		    while (*--sp != '/')
 			continue;
 		    sp++;
 		    *sp = 0;
 		    /*
 		     * New length is "yyy/" + slink + "/.." and rest
 		     */
-		    p1 = newcp = xmalloc(
+		    p1 = newcp = xreallocarray(NULL,
-		        (size_t)((sp - cp) + cc + (p1 - p)) * sizeof(Char));
+		        (size_t)((sp - cp) + cc + (p1 - p)), sizeof(Char));
 		    /*
 		     * Copy new path into newcp
 		     */
 		    for (p2 = cp; (*p1++ = *p2++) != '\0';)
 			continue;
 		    for (p1--, p2 = slink; (*p1++ = *p2++) != '\0';)
 			continue;
 		    for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
 			continue;
 		    /*
 		     * Restart canonicalization at expanded "/xxx".
 		     */
 		    p = sp - cp - 1 + newcp;
+		}
 		else {
 		    /*
 		     * New length is slink + the rest
 		     */
-		    p1 = newcp = xmalloc(
+		    p1 = newcp = xreallocarray(NULL,
-		        (size_t)(cc + (p1 - p)) * sizeof(Char));
+		        (size_t)(cc + (p1 - p)), sizeof(Char));
 		    /*
 		     * Copy new path into newcp
 		     */
 		    for (p2 = slink; (*p1++ = *p2++) != '\0';)
 			continue;
 		    for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
 			continue;
 		    /*
 		     * Restart canonicalization at beginning
 		     */
 		    p = newcp;
+		}
 		free(cp);
 		cp = newcp;
 		continue;	/* canonicalize the link */
+	    }
 	    if (slash)
 		*p = '/';
+	}
+    }
     /*
      * fix home...
      */
     p1 = value(STRhome);
     len = Strlen(p1);
     /*
      * See if we're not in a subdir of STRhome
      */
     if (p1 && *p1 == '/' &&
 	(Strncmp(p1, cp, len) != 0 || (cp[len] != '/' && cp[len] != '\0'))) {
 	static ino_t home_ino;
 	static dev_t home_dev = NODEV;
 	static Char *home_ptr = NULL;
 	struct stat statbuf;
 	/*
 	 * Get dev and ino of STRhome
 	 */
 	if (home_ptr != p1 &&
 	    stat(short2str(p1), &statbuf) != -1) {
 	    home_dev = statbuf.st_dev;
 	    home_ino = statbuf.st_ino;
 	    home_ptr = p1;
+	}
 	/*
 	 * Start comparing dev & ino backwards
 	 */
 	p2 = Strcpy(slink, cp);
 	for (sp = NULL; *p2 && stat(short2str(p2), &statbuf) != -1;) {
 	    if (statbuf.st_dev == home_dev &&
 		statbuf.st_ino == home_ino) {
 		sp = (Char *) - 1;
 		break;
+	    }
 	    if ((sp = Strrchr(p2, '/')) != NULL)
 		*sp = '\0';
+	}
 	/*
 	 * See if we found it
 	 */
 	if (*p2 && sp == (Char *) -1) {
 	    /*
 	     * Use STRhome to make '~' work
 	     */
 	    newcp = Strspl(p1, cp + Strlen(p2));
 	    free(cp);
 	    cp = newcp;
+	}
+    }
     return cp;
+}
 /*
  * dnewcwd - make a new directory in the loop the current one
  */
 static void
 dnewcwd(struct directory *dp)
+{
     dcwd = dp;
     dset(dcwd->di_name);
     if (printd && !(adrof(STRpushdsilent)))
 	printdirs();
+}

 @@ -1,728 +1,725 @@
-/* $NetBSD: file.c,v 1.33 2020/09/29 02:58:51 msaitoh Exp $ */
+/* $NetBSD: file.c,v 1.34 2024/04/24 15:49:03 nia Exp $ */
 /*-
  * Copyright (c) 1980, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)file.c	8.2 (Berkeley) 3/19/94";
 #else
-__RCSID("$NetBSD: file.c,v 1.33 2020/09/29 02:58:51 msaitoh Exp $");
+__RCSID("$NetBSD: file.c,v 1.34 2024/04/24 15:49:03 nia Exp $");
 #endif
 #endif /* not lint */
 #ifdef FILEC
 #include <sys/ioctl.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <sys/tty.h>
 #include <dirent.h>
 #include <pwd.h>
 #include <termios.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <unistd.h>
 #ifndef SHORT_STRINGS
 #include <string.h>
 #endif /* SHORT_STRINGS */
 #include "csh.h"
 #include "extern.h"
 /*
  * Tenex style file name recognition, .. and more.
  * History:
  *	Author: Ken Greer, Sept. 1975, CMU.
  *	Finally got around to adding to the Cshell., Ken Greer, Dec. 1981.
  */
 #define ON	1
 #define OFF	0
 #ifndef TRUE
 #define TRUE 1
 #endif
 #ifndef FALSE
 #define FALSE 0
 #endif
 #define ESC '\033'
 typedef enum {
     LIST, RECOGNIZE
 }       COMMAND;
 static void setup_tty(int);
 static void back_to_col_1(void);
 static int pushback(Char *);
 static void catn(Char *, Char *, size_t);
 static void copyn(Char *, Char *, size_t);
 static Char filetype(Char *, Char *);
 static void print_by_column(Char *, Char *[], size_t);
 static Char *tilde(Char *, Char *);
 static void retype(void);
 static void beep(void);
 static void print_recognized_stuff(Char *);
 static void extract_dir_and_name(Char *, Char *, Char *);
 static Char *getentry(DIR *, int);
 static void free_items(Char **, size_t);
 static size_t tsearch(Char *, COMMAND, size_t);
 static int recognize(Char *, Char *, size_t, size_t);
 static int is_prefix(Char *, Char *);
 static int is_suffix(Char *, Char *);
 static int ignored(Char *);
 /*
  * Put this here so the binary can be patched with adb to enable file
  * completion by default.  Filec controls completion, nobeep controls
  * ringing the terminal bell on incomplete expansions.
  */
 int filec = 0;
 static void
 setup_tty(int on)
+{
     struct termios tchars;
     (void)tcgetattr(SHIN, &tchars);
     if (on) {
 	tchars.c_cc[VEOL] = ESC;
 	if (tchars.c_lflag & ICANON)
 	    on = TCSADRAIN;
 	else {
 	    tchars.c_lflag |= ICANON;
 	    on = TCSAFLUSH;
+	}
+    }
     else {
 	tchars.c_cc[VEOL] = _POSIX_VDISABLE;
 	on = TCSADRAIN;
+    }
     (void)tcsetattr(SHIN, on, &tchars);
+}
 /*
  * Move back to beginning of current line
  */
 static void
 back_to_col_1(void)
+{
     struct termios tty, tty_normal;
     sigset_t nsigset, osigset;
     sigemptyset(&nsigset);
     (void)sigaddset(&nsigset, SIGINT);
     (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset);
     (void)tcgetattr(SHOUT, &tty);
     tty_normal = tty;
     tty.c_iflag &= ~INLCR;
     tty.c_oflag &= ~ONLCR;
     (void)tcsetattr(SHOUT, TCSADRAIN, &tty);
     (void)write(SHOUT, "\r", 1);
     (void)tcsetattr(SHOUT, TCSADRAIN, &tty_normal);
     (void)sigprocmask(SIG_SETMASK, &osigset, NULL);
+}
 /*
  * Push string contents back into tty queue
  */
 static int
 pushback(Char *string)
+{
     struct termios tty, tty_normal;
     char buf[64], svchars[sizeof(buf)];
     sigset_t nsigset, osigset;
     Char *p;
     size_t bufidx, i, len_str, nbuf, nsv, onsv, retrycnt;
     char c;
     nsv = 0;
     sigemptyset(&nsigset);
     (void)sigaddset(&nsigset, SIGINT);
     (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset);
     (void)tcgetattr(SHOUT, &tty);
     tty_normal = tty;
     tty.c_lflag &= ~(ECHOKE | ECHO | ECHOE | ECHOK | ECHONL | ECHOPRT | ECHOCTL);
     /* FIONREAD works only in noncanonical mode. */
     tty.c_lflag &= ~ICANON;
     tty.c_cc[VMIN] = 0;
     (void)tcsetattr(SHOUT, TCSADRAIN, &tty);
     for (retrycnt = 5; ; retrycnt--) {
 	/*
 	 * Push back characters.
 	 */
 	for (p = string; (c = (char)*p) != '\0'; p++)
 	    (void)ioctl(SHOUT, TIOCSTI, (ioctl_t) &c);
 	for (i = 0; i < nsv; i++)
 	    (void)ioctl(SHOUT, TIOCSTI, (ioctl_t) &svchars[i]);
 	if (retrycnt == 0)
 	    break;		/* give up salvaging characters */
 	len_str = (size_t)(p - string);
 	if (ioctl(SHOUT, FIONREAD, (ioctl_t) &nbuf) ||
 	    nbuf <= len_str + nsv ||	/* The string fit. */
 	    nbuf > sizeof(buf))		/* For future binary compatibility
 					   (and safety). */
 	    break;
 	/*
 	 * User has typed characters before the pushback finished.
 	 * Salvage the characters.
 	 */
 	/* This read() should be in noncanonical mode. */
 	if (read(SHOUT, &buf, nbuf) != (ssize_t)nbuf)
 	    continue;		/* hangup? */
 	onsv = nsv;
 	for (bufidx = 0, i = 0; bufidx < nbuf; bufidx++, i++) {
 	    c = buf[bufidx];
 	    if ((i < len_str) ? c != (char)string[i] :
 			(i < len_str + onsv) ? c != svchars[i - len_str] : 1) {
 		/* Salvage a character. */
 		if (nsv < (int)(sizeof svchars / sizeof svchars[0])) {
 		    svchars[nsv++] = c;
 		    i--;	/* try this comparison with the next char */
 		} else
 		    break;	/* too many */
+	    }
+	}
+    }
 #if 1
     /*
      * XXX  Is this a bug or a feature of kernel tty driver?
+     *
      * FIONREAD in canonical mode does not return correct byte count
      * in tty input queue, but this is required to avoid unwanted echo.
      */
     tty.c_lflag |= ICANON;
     (void)tcsetattr(SHOUT, TCSADRAIN, &tty);
     (void)ioctl(SHOUT, FIONREAD, (ioctl_t) &i);
 #endif
     (void)tcsetattr(SHOUT, TCSADRAIN, &tty_normal);
     (void)sigprocmask(SIG_SETMASK, &osigset, NULL);
     return (int)nsv;
+}
 /*
  * Concatenate src onto tail of des.
  * Des is a string whose maximum length is count.
  * Always null terminate.
  */
 static void
 catn(Char *des, Char *src, size_t count)
+{
     while (count-- > 0 && *des)
 	des++;
     while (count-- > 0)
 	if ((*des++ = *src++) == 0)
 	    return;
     *des = '\0';
+}
 /*
  * Like strncpy but always leave room for trailing \0
  * and always null terminate.
  */
 static void
 copyn(Char *des, Char *src, size_t count)
+{
     while (count-- > 0)
 	if ((*des++ = *src++) == 0)
 	    return;
     *des = '\0';
+}
 static Char
 filetype(Char *dir, Char *file)
+{
     struct stat statb;
     Char path[MAXPATHLEN];
     catn(Strcpy(path, dir), file, sizeof(path) / sizeof(Char));
     if (lstat(short2str(path), &statb) == 0) {
 	switch (statb.st_mode & S_IFMT) {
 	case S_IFDIR:
 	    return ('/');
 	case S_IFLNK:
 	    if (stat(short2str(path), &statb) == 0 &&	/* follow it out */
 		S_ISDIR(statb.st_mode))
 		return ('>');
 	    else
 		return ('@');
 	case S_IFSOCK:
 	    return ('=');
 	default:
 	    if (statb.st_mode & 0111)
 		return ('*');
+	}
+    }
     return (' ');
+}
 static struct winsize win;
 /*
  * Print sorted down columns
  */
 static void
 print_by_column(Char *dir, Char *items[], size_t count)
+{
     size_t c, columns, i, maxwidth, r, rows;
     maxwidth = 0;
     if (ioctl(SHOUT, TIOCGWINSZ, (ioctl_t) & win) < 0 || win.ws_col == 0)
 	win.ws_col = 80;
     for (i = 0; i < count; i++)
 	maxwidth = maxwidth > (r = Strlen(items[i])) ? maxwidth : r;
     maxwidth += 2;		/* for the file tag and space */
     columns = win.ws_col / maxwidth;
     if (columns == 0)
 	columns = 1;
     rows = (count + (columns - 1)) / columns;
     for (r = 0; r < rows; r++) {
 	for (c = 0; c < columns; c++) {
 	    i = c * rows + r;
 	    if (i < count) {
 		size_t w;
 		(void)fprintf(cshout, "%s", vis_str(items[i]));
 		(void)fputc(dir ? filetype(dir, items[i]) : ' ', cshout);
 		if (c < columns - 1) {	/* last column? */
 		    w = Strlen(items[i]) + 1;
 		    for (; w < maxwidth; w++)
 			(void) fputc(' ', cshout);
+		}
+	    }
+	}
 	(void)fputc('\r', cshout);
 	(void)fputc('\n', cshout);
+    }
+}
 /*
  * Expand file name with possible tilde usage
  *	~person/mumble
  * expands to
  *	home_directory_of_person/mumble
  */
 static Char *
 tilde(Char *new, Char *old)
+{
     static Char person[40];
     struct passwd *pw;
     Char *o, *p;
     if (old[0] != '~')
 	return (Strcpy(new, old));
     for (p = person, o = &old[1]; *o && *o != '/'; *p++ = *o++)
 	continue;
     *p = '\0';
     if (person[0] == '\0')
 	(void)Strcpy(new, value(STRhome));
     else {
 	pw = getpwnam(short2str(person));
 	if (pw == NULL)
 	    return (NULL);
 	(void)Strcpy(new, str2short(pw->pw_dir));
+    }
     (void)Strcat(new, o);
     return (new);
+}
 /*
  * Cause pending line to be printed
  */
 static void
 retype(void)
+{
     struct termios tty;
     (void)tcgetattr(SHOUT, &tty);
     tty.c_lflag |= PENDIN;
     (void)tcsetattr(SHOUT, TCSADRAIN, &tty);
+}
 static void
 beep(void)
+{
     if (adrof(STRnobeep) == 0)
 	(void)write(SHOUT, "\007", 1);
+}
 /*
  * Erase that silly ^[ and
  * print the recognized part of the string
  */
 static void
 print_recognized_stuff(Char *recognized_part)
+{
     /* An optimized erasing of that silly ^[ */
     (void)fputc('\b', cshout);
     (void)fputc('\b', cshout);
     switch (Strlen(recognized_part)) {
     case 0:			/* erase two Characters: ^[ */
 	(void)fputc(' ', cshout);
 	(void)fputc(' ', cshout);
 	(void)fputc('\b', cshout);
 	(void)fputc('\b', cshout);
 	break;
     case 1:			/* overstrike the ^, erase the [ */
 	(void)fprintf(cshout, "%s", vis_str(recognized_part));
 	(void)fputc(' ', cshout);
 	(void)fputc('\b', cshout);
 	break;
     default:			/* overstrike both Characters ^[ */
 	(void)fprintf(cshout, "%s", vis_str(recognized_part));
 	break;
+    }
     (void)fflush(cshout);
+}
 /*
  * Parse full path in file into 2 parts: directory and file names
  * Should leave final slash (/) at end of dir.
  */
 static void
 extract_dir_and_name(Char *path, Char *dir, Char *name)
+{
     Char *p;
     p = Strrchr(path, '/');
     if (p == NULL) {
 	copyn(name, path, MAXNAMLEN);
 	dir[0] = '\0';
+    }
     else {
 	copyn(name, ++p, MAXNAMLEN);
 	copyn(dir, path, (size_t)(p - path));
+    }
+}
 static Char *
 getentry(DIR *dir_fd, int looking_for_lognames)
+{
     struct dirent *dirp;
     struct passwd *pw;
     if (looking_for_lognames) {
 	if ((pw = getpwent()) == NULL)
 	    return (NULL);
 	return (str2short(pw->pw_name));
+    }
     if ((dirp = readdir(dir_fd)) != NULL)
 	return (str2short(dirp->d_name));
     return (NULL);
+}
 static void
 free_items(Char **items, size_t numitems)
+{
     size_t i;
     for (i = 0; i < numitems; i++)
 	free(items[i]);
     free(items);
+}
 #define FREE_ITEMS(items, numitems) { \
 	sigset_t nsigset, osigset;\
+\
 	sigemptyset(&nsigset);\
 	(void) sigaddset(&nsigset, SIGINT);\
 	(void) sigprocmask(SIG_BLOCK, &nsigset, &osigset);\
 	free_items(items, numitems);\
 	(void) sigprocmask(SIG_SETMASK, &osigset, NULL);\
+}
 /*
  * Perform a RECOGNIZE or LIST command on string "word".
  */
 static size_t
 tsearch(Char *word, COMMAND command, size_t max_word_length)
+{
     Char dir[MAXPATHLEN + 1], extended_name[MAXNAMLEN + 1];
     Char name[MAXNAMLEN + 1], tilded_dir[MAXPATHLEN + 1];
     DIR *dir_fd;
     Char *entry;
     int ignoring, looking_for_lognames;
     size_t name_length, nignored, numitems;
     Char **items = NULL;
     size_t maxitems = 0;
     numitems = 0;
     ignoring = TRUE;
     nignored = 0;
     looking_for_lognames = (*word == '~') && (Strchr(word, '/') == NULL);
     if (looking_for_lognames) {
 	(void)setpwent();
 	copyn(name, &word[1], MAXNAMLEN);	/* name sans ~ */
 	dir_fd = NULL;
+    }
     else {
 	extract_dir_and_name(word, dir, name);
 	if (tilde(tilded_dir, dir) == 0)
 	    return (0);
 	dir_fd = opendir(*tilded_dir ? short2str(tilded_dir) : ".");
 	if (dir_fd == NULL)
 	    return (0);
+    }
 again:				/* search for matches */
     name_length = Strlen(name);
     for (numitems = 0; (entry = getentry(dir_fd, looking_for_lognames)) != NULL;) {
 	if (!is_prefix(name, entry))
 	    continue;
 	/* Don't match . files on null prefix match */
 	if (name_length == 0 && entry[0] == '.' &&
 	    !looking_for_lognames)
 	    continue;
 	if (command == LIST) {
 	    if ((size_t)numitems >= maxitems) {
 		maxitems += 1024;
-		if (items == NULL)
+		items = xreallocarray(items, sizeof(*items), maxitems);
 			items = xmalloc(sizeof(*items) * maxitems);
 		else
 			items = xrealloc(items, sizeof(*items) * maxitems);
+ 	    }
-	    items[numitems] = xmalloc((size_t) (Strlen(entry) + 1) *
+	    items[numitems] = xreallocarray(NULL,
-	        sizeof(Char));
+		(size_t) (Strlen(entry) + 1), sizeof(Char));
 	    copyn(items[numitems], entry, MAXNAMLEN);
 	    numitems++;
+	}
 	else {			/* RECOGNIZE command */
 	    if (ignoring && ignored(entry))
 		nignored++;
 	    else if (recognize(extended_name,
 	        entry, name_length, ++numitems))
 		break;
+	}
+    }
     if (ignoring && numitems == 0 && nignored > 0) {
 	ignoring = FALSE;
 	nignored = 0;
 	if (looking_for_lognames)
 	    (void)setpwent();
 	else
 	    rewinddir(dir_fd);
 	goto again;
+    }
     if (looking_for_lognames)
 	(void)endpwent();
     else
 	(void)closedir(dir_fd);
     if (numitems == 0)
 	return (0);
     if (command == RECOGNIZE) {
 	if (looking_for_lognames)
 	    copyn(word, STRtilde, 1);
 	else
 	    /* put back dir part */
 	    copyn(word, dir, max_word_length);
 	/* add extended name */
 	catn(word, extended_name, max_word_length);
 	return (numitems);
+    }
     else {			/* LIST */
 	qsort(items, numitems, sizeof(items[0]),
 		(int (*) (const void *, const void *)) sortscmp);
 	print_by_column(looking_for_lognames ? NULL : tilded_dir,
 			items, numitems);
 	if (items != NULL)
 	    FREE_ITEMS(items, numitems);
+    }
     return (0);
+}
 /*
  * Object: extend what user typed up to an ambiguity.
  * Algorithm:
  * On first match, copy full entry (assume it'll be the only match)
  * On subsequent matches, shorten extended_name to the first
  * Character mismatch between extended_name and entry.
  * If we shorten it back to the prefix length, stop searching.
  */
 static int
 recognize(Char *extended_name, Char *entry, size_t name_length, size_t numitems)
+{
     if (numitems == 1)		/* 1st match */
 	copyn(extended_name, entry, MAXNAMLEN);
     else {			/* 2nd & subsequent matches */
 	Char *ent, *x;
 	size_t len = 0;
 	x = extended_name;
 	for (ent = entry; *x && *x == *ent++; x++, len++)
 	    continue;
 	*x = '\0';		/* Shorten at 1st Char diff */
 	if (len == name_length)	/* Ambiguous to prefix? */
 	    return (-1);	/* So stop now and save time */
+    }
     return (0);
+}
 /*
  * Return true if check matches initial Chars in template.
  * This differs from PWB imatch in that if check is null
  * it matches anything.
  */
 static int
 is_prefix(Char *check, Char *template)
+{
     do
 	if (*check == 0)
 	    return (TRUE);
     while (*check++ == *template++);
     return (FALSE);
+}
 /*
  *  Return true if the Chars in template appear at the
  *  end of check, I.e., are its suffix.
  */
 static int
 is_suffix(Char *check, Char *template)
+{
     Char *c, *t;
     for (c = check; *c++;)
 	continue;
     for (t = template; *t++;)
 	continue;
     for (;;) {
 	if (t == template)
 	    return 1;
 	if (c == check || *--t != *--c)
 	    return 0;
+    }
+}
 ssize_t
 tenex(Char *inputline, size_t inputline_size)
+{
     char tinputline[BUFSIZE];
     ssize_t num_read;
     size_t numitems;
     setup_tty(ON);
     while ((num_read = read(SHIN, tinputline, BUFSIZE)) > 0) {
 	size_t i, nr = (size_t) num_read;
 	static Char delims[] = {' ', '\'', '"', '\t', ';', '&', '<',
 	'>', '(', ')', '|', '^', '%', '\0'};
 	Char *str_end, *word_start, last_Char, should_retype;
 	size_t space_left;
 	COMMAND command;
 	for (i = 0; i < nr; i++)
 	    inputline[i] = (unsigned char) tinputline[i];
 	last_Char = inputline[nr - 1] & ASCII;
 	if (last_Char == '\n' || nr == inputline_size)
 	    break;
 	command = (last_Char == ESC) ? RECOGNIZE : LIST;
 	if (command == LIST)
 	    (void)fputc('\n', cshout);
 	str_end = &inputline[nr];
 	if (last_Char == ESC)
 	    --str_end;		/* wipeout trailing cmd Char */
 	*str_end = '\0';
 	/*
 	 * Find LAST occurrence of a delimiter in the inputline. The word start
 	 * is one Character past it.
 	 */
 	for (word_start = str_end; word_start > inputline; --word_start)
 	    if (Strchr(delims, word_start[-1]))
 		break;
 	space_left = inputline_size - (size_t)(word_start - inputline) - 1;
 	numitems = tsearch(word_start, command, space_left);
 	if (command == RECOGNIZE) {
 	    /* print from str_end on */
 	    print_recognized_stuff(str_end);
 	    if (numitems != 1)	/* Beep = No match/ambiguous */
 		beep();
+	}
 	/*
 	 * Tabs in the input line cause trouble after a pushback. tty driver
 	 * won't backspace over them because column positions are now
 	 * incorrect. This is solved by retyping over current line.
 	 */
 	should_retype = FALSE;
 	if (Strchr(inputline, '\t')) {	/* tab Char in input line? */
 	    back_to_col_1();
 	    should_retype = TRUE;
+	}
 	if (command == LIST)	/* Always retype after a LIST */
 	    should_retype = TRUE;
 	if (pushback(inputline))
 	    should_retype = TRUE;
 	if (should_retype) {
 	    if (command == RECOGNIZE)
 		(void) fputc('\n', cshout);
 	    printprompt();
+	}
 	if (should_retype)
 	    retype();
+    }
     setup_tty(OFF);
     return num_read;
+}
 static int
 ignored(Char *entry)
+{
     struct varent *vp;
     Char **cp;
     if ((vp = adrof(STRfignore)) == NULL || (cp = vp->vec) == NULL)
 	return (FALSE);
     for (; *cp != NULL; cp++)
 	if (is_suffix(entry, *cp))
 	    return (TRUE);
     return (FALSE);
+}
 #endif				/* FILEC */

 @@ -1,1456 +1,1456 @@
-/* $NetBSD: func.c,v 1.44 2020/08/09 00:22:53 dholland Exp $ */
+/* $NetBSD: func.c,v 1.45 2024/04/24 15:49:03 nia Exp $ */
 /*-
  * Copyright (c) 1980, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)func.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: func.c,v 1.44 2020/08/09 00:22:53 dholland Exp $");
+__RCSID("$NetBSD: func.c,v 1.45 2024/04/24 15:49:03 nia Exp $");
 #endif
 #endif /* not lint */
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <locale.h>
 #include <inttypes.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
 #include "csh.h"
 #include "extern.h"
 #include "pathnames.h"
 extern char **environ;
 extern int progprintf(int, char **);
 static void islogin(void);
 static void reexecute(struct command *);
 static void preread(void);
 static void doagain(void);
 static void search(int, int, Char *);
 static int getword(Char *);
 static int keyword(Char *);
 static void toend(void);
 static void xecho(int, Char **);
 static void Unsetenv(Char *);
 static void wpfree(struct whyle *);
 struct biltins *
 isbfunc(struct command *t)
+{
     static struct biltins label = {"", dozip, 0, 0};
     static struct biltins foregnd = {"%job", dofg1, 0, 0};
     static struct biltins backgnd = {"%job &", dobg1, 0, 0};
     struct biltins *bp, *bp1, *bp2;
     Char *cp;
     cp = t->t_dcom[0];
     if (lastchr(cp) == ':') {
 	label.bname = short2str(cp);
 	return (&label);
+    }
     if (*cp == '%') {
 	if (t->t_dflg & F_AMPERSAND) {
 	    t->t_dflg &= ~F_AMPERSAND;
 	    backgnd.bname = short2str(cp);
 	    return (&backgnd);
+	}
 	foregnd.bname = short2str(cp);
 	return (&foregnd);
+    }
     /*
      * Binary search Bp1 is the beginning of the current search range. Bp2 is
      * one past the end.
      */
     for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) {
 	int i;
 	bp = bp1 + ((bp2 - bp1) >> 1);
 	if ((i = *cp - *bp->bname) == 0 &&
 	    (i = Strcmp(cp, str2short(bp->bname))) == 0)
 	    return bp;
 	if (i < 0)
 	    bp2 = bp;
 	else
 	    bp1 = bp + 1;
+    }
     return (0);
+}
 void
 func(struct command *t, struct biltins *bp)
+{
     int i;
     xechoit(t->t_dcom);
     setname(bp->bname);
     i = blklen(t->t_dcom) - 1;
     if (i < bp->minargs)
 	stderror(ERR_NAME | ERR_TOOFEW);
     if (i > bp->maxargs)
 	stderror(ERR_NAME | ERR_TOOMANY);
     (*bp->bfunct) (t->t_dcom, t);
+}
 void
 /*ARGSUSED*/
 doonintr(Char **v, struct command *t)
+{
     Char *cp, *vv;
     sigset_t nsigset;
     vv = v[1];
     if (parintr == SIG_IGN)
 	return;
     if (setintr && intty)
 	stderror(ERR_NAME | ERR_TERMINAL);
     cp = gointr;
     gointr = 0;
     free(cp);
     if (vv == 0) {
 	if (setintr) {
 	    sigemptyset(&nsigset);
 	    (void)sigaddset(&nsigset, SIGINT);
 	    (void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
 	} else
 	    (void)signal(SIGINT, SIG_DFL);
 	gointr = 0;
+    }
     else if (eq((vv = strip(vv)), STRminus)) {
 	(void)signal(SIGINT, SIG_IGN);
 	gointr = Strsave(STRminus);
+    }
     else {
 	gointr = Strsave(vv);
 	(void)signal(SIGINT, pintr);
+    }
+}
 void
 /*ARGSUSED*/
 donohup(Char **v, struct command *t)
+{
     if (intty)
 	stderror(ERR_NAME | ERR_TERMINAL);
     if (setintr == 0) {
 	(void) signal(SIGHUP, SIG_IGN);
+    }
+}
 void
 /*ARGSUSED*/
 dozip(Char **v, struct command *t)
+{
+    ;
+}
 void
 prvars(void)
+{
     plist(&shvhed);
+}
 void
 /*ARGSUSED*/
 doalias(Char **v, struct command *t)
+{
     struct varent *vp;
     Char *p;
     v++;
     p = *v++;
     if (p == 0)
 	plist(&aliases);
     else if (*v == 0) {
 	vp = adrof1(strip(p), &aliases);
 	if (vp) {
 	    blkpr(cshout, vp->vec);
 	    (void) fputc('\n', cshout);
+	}
+    }
     else {
 	if (eq(p, STRalias) || eq(p, STRunalias)) {
 	    setname(vis_str(p));
 	    stderror(ERR_NAME | ERR_DANGER);
+	}
 	set1(strip(p), saveblk(v), &aliases);
+    }
+}
 void
 /*ARGSUSED*/
 unalias(Char **v, struct command *t)
+{
     unset1(v, &aliases);
+}
 void
 /*ARGSUSED*/
 dologout(Char **v, struct command *t)
+{
     islogin();
     goodbye();
+}
 void
 /*ARGSUSED*/
 dologin(Char **v, struct command *t)
+{
     islogin();
     rechist();
     (void)signal(SIGTERM, parterm);
     (void)execl(_PATH_LOGIN, "login", short2str(v[1]), NULL);
     untty();
     xexit(1);
     /* NOTREACHED */
+}
 static void
 islogin(void)
+{
     if (chkstop == 0 && setintr)
 	panystop(0);
     if (loginsh)
 	return;
     stderror(ERR_NOTLOGIN);
     /* NOTREACHED */
+}
 void
 doif(Char **v, struct command *kp)
+{
     Char **vv;
     int i;
     v++;
     i = expr(&v);
     vv = v;
     if (*vv == NULL)
 	stderror(ERR_NAME | ERR_EMPTYIF);
     if (eq(*vv, STRthen)) {
 	if (*++vv)
 	    stderror(ERR_NAME | ERR_IMPRTHEN);
 	setname(vis_str(STRthen));
 	/*
 	 * If expression was zero, then scan to else, otherwise just fall into
 	 * following code.
 	 */
 	if (!i)
 	    search(T_IF, 0, NULL);
 	return;
+    }
     /*
      * Simple command attached to this if. Left shift the node in this tree,
      * munging it so we can reexecute it.
      */
     if (i) {
 	lshift(kp->t_dcom, (size_t)(vv - kp->t_dcom));
 	reexecute(kp);
 	donefds();
+    }
+}
 /*
  * Reexecute a command, being careful not
  * to redo i/o redirection, which is already set up.
  */
 static void
 reexecute(struct command *kp)
+{
     kp->t_dflg &= F_SAVE;
     kp->t_dflg |= F_REPEAT;
     /*
      * If tty is still ours to arbitrate, arbitrate it; otherwise dont even set
      * pgrp's as the jobs would then have no way to get the tty (we can't give
      * it to them, and our parent wouldn't know their pgrp, etc.
      */
     execute(kp, (tpgrp > 0 ? tpgrp : -1), NULL, NULL);
+}
 void
 /*ARGSUSED*/
 doelse(Char **v, struct command *t)
+{
     search(T_ELSE, 0, NULL);
+}
 void
 /*ARGSUSED*/
 dogoto(Char **v, struct command *t)
+{
     Char *lp;
     gotolab(lp = globone(v[1], G_ERROR));
     free(lp);
+}
 void
 gotolab(Char *lab)
+{
     struct whyle *wp;
     /*
      * While we still can, locate any unknown ends of existing loops. This
      * obscure code is the WORST result of the fact that we don't really parse.
      */
     for (wp = whyles; wp; wp = wp->w_next)
 	if (wp->w_end.type == F_SEEK && wp->w_end.f_seek == 0) {
 	    search(T_BREAK, 0, NULL);
 	    btell(&wp->w_end);
+	}
 	else
 	    bseek(&wp->w_end);
     search(T_GOTO, 0, lab);
     /*
      * Eliminate loops which were exited.
      */
     wfree();
+}
 void
 /*ARGSUSED*/
 doswitch(Char **v, struct command *t)
+{
     Char *cp, *lp;
     v++;
     if (!*v || *(*v++) != '(')
 	stderror(ERR_SYNTAX);
     cp = **v == ')' ? STRNULL : *v++;
     if (*(*v++) != ')')
 	v--;
     if (*v)
 	stderror(ERR_SYNTAX);
     search(T_SWITCH, 0, lp = globone(cp, G_ERROR));
     free(lp);
+}
 void
 /*ARGSUSED*/
 dobreak(Char **v, struct command *t)
+{
     if (whyles)
 	toend();
     else
 	stderror(ERR_NAME | ERR_NOTWHILE);
+}
 void
 /*ARGSUSED*/
 doexit(Char **v, struct command *t)
+{
     if (chkstop == 0 && (intty || intact) && evalvec == 0)
 	panystop(0);
     /*
      * Don't DEMAND parentheses here either.
      */
     v++;
     if (*v) {
 	set(STRstatus, putn(expr(&v)));
 	if (*v)
 	    stderror(ERR_NAME | ERR_EXPRESSION);
+    }
     btoeof();
     if (intty)
 	(void) close(SHIN);
+}
 void
 /*ARGSUSED*/
 doforeach(Char **v, struct command *t)
+{
     struct whyle *nwp;
     Char *cp, *sp;
     v++;
     sp = cp = strip(*v);
     if (!letter(*sp))
 	stderror(ERR_NAME | ERR_VARBEGIN);
     while (*cp && alnum(*cp))
 	cp++;
     if (*cp)
 	stderror(ERR_NAME | ERR_VARALNUM);
     if ((cp - sp) > MAXVARLEN)
 	stderror(ERR_NAME | ERR_VARTOOLONG);
     cp = *v++;
     if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
 	stderror(ERR_NAME | ERR_NOPAREN);
     v++;
     gflag = 0, tglob(v);
     v = globall(v);
     if (v == 0)
 	stderror(ERR_NAME | ERR_NOMATCH);
     nwp = xcalloc(1, sizeof *nwp);
     nwp->w_fe = nwp->w_fe0 = v;
     gargv = 0;
     btell(&nwp->w_start);
     nwp->w_fename = Strsave(cp);
     nwp->w_next = whyles;
     nwp->w_end.type = F_SEEK;
     whyles = nwp;
     /*
      * Pre-read the loop so as to be more comprehensible to a terminal user.
      */
     if (intty)
 	preread();
     doagain();
+}
 void
 /*ARGSUSED*/
 dowhile(Char **v, struct command *t)
+{
     int status;
     int again;
     again = whyles != 0 && SEEKEQ(&whyles->w_start, &lineloc) &&
         whyles->w_fename == 0;
     v++;
     /*
      * Implement prereading here also, taking care not to evaluate the
      * expression before the loop has been read up from a terminal.
      */
     if (intty && !again)
 	status = !exp0(&v, 1);
     else
 	status = !expr(&v);
     if (*v)
 	stderror(ERR_NAME | ERR_EXPRESSION);
     if (!again) {
 	struct whyle *nwp =
 		xcalloc(1, sizeof(*nwp));
 	nwp->w_start = lineloc;
 	nwp->w_end.type = F_SEEK;
 	nwp->w_end.f_seek = 0;
 	nwp->w_next = whyles;
 	whyles = nwp;
 	if (intty) {
 	    /*
 	     * The tty preread
 	     */
 	    preread();
 	    doagain();
 	    return;
+	}
+    }
     if (status)
 	/* We ain't gonna loop no more, no more! */
 	toend();
+}
 static void
 preread(void)
+{
     sigset_t nsigset;
     whyles->w_end.type = I_SEEK;
     if (setintr) {
 	sigemptyset(&nsigset);
 	(void) sigaddset(&nsigset, SIGINT);
 	(void) sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
+    }
     search(T_BREAK, 0, NULL);		/* read the expression in */
     if (setintr)
 	(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
     btell(&whyles->w_end);
+}
 void
 /*ARGSUSED*/
 doend(Char **v, struct command *t)
+{
     if (!whyles)
 	stderror(ERR_NAME | ERR_NOTWHILE);
     btell(&whyles->w_end);
     doagain();
+}
 void
 /*ARGSUSED*/
 docontin(Char **v, struct command *t)
+{
     if (!whyles)
 	stderror(ERR_NAME | ERR_NOTWHILE);
     doagain();
+}
 static void
 doagain(void)
+{
     /* Repeating a while is simple */
     if (whyles->w_fename == 0) {
 	bseek(&whyles->w_start);
 	return;
+    }
     /*
      * The foreach variable list actually has a spurious word ")" at the end of
      * the w_fe list.  Thus we are at the of the list if one word beyond this
      * is 0.
      */
     if (!whyles->w_fe[1]) {
 	dobreak(NULL, NULL);
 	return;
+    }
     set(whyles->w_fename, Strsave(*whyles->w_fe++));
     bseek(&whyles->w_start);
+}
 void
 dorepeat(Char **v, struct command *kp)
+{
     int i;
     sigset_t nsigset;
     i = getn(v[1]);
     if (setintr) {
 	sigemptyset(&nsigset);
 	(void)sigaddset(&nsigset, SIGINT);
 	(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
+    }
     lshift(v, 2);
     while (i > 0) {
 	if (setintr)
 	    (void)sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
 	reexecute(kp);
 	--i;
+    }
     donefds();
     if (setintr)
 	(void) sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
+}
 void
 /*ARGSUSED*/
 doswbrk(Char **v, struct command *t)
+{
     search(T_BRKSW, 0, NULL);
+}
 int
 srchx(Char *cp)
+{
     struct srch *sp, *sp1, *sp2;
     int i;
     /*
      * Binary search Sp1 is the beginning of the current search range. Sp2 is
      * one past the end.
      */
     for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2;) {
 	sp = sp1 + ((sp2 - sp1) >> 1);
 	if ((i = *cp - *sp->s_name) == 0 &&
 	    (i = Strcmp(cp, str2short(sp->s_name))) == 0)
 	    return sp->s_value;
 	if (i < 0)
 	    sp2 = sp;
 	else
 	    sp1 = sp + 1;
+    }
     return (-1);
+}
 static Char Stype;
 static Char *Sgoal;
 /*VARARGS2*/
 static void
 search(int type, int level, Char *goal)
+{
     Char wordbuf[BUFSIZE];
     Char *aword, *cp;
     struct whyle *wp;
     int wlevel = 0;
     aword = wordbuf;
     Stype = (Char)type;
     Sgoal = goal;
     if (type == T_GOTO) {
 	struct Ain a;
 	a.type = F_SEEK;
 	a.f_seek = 0;
 	bseek(&a);
+    }
     do {
 	if (intty && fseekp == feobp && aret == F_SEEK)
 	    (void)fprintf(cshout, "? "), (void)fflush(cshout);
 	aword[0] = 0;
 	(void)getword(aword);
 	switch (srchx(aword)) {
 	case T_CASE:
 	    if (type != T_SWITCH || level != 0)
 		break;
 	    (void) getword(aword);
 	    if (lastchr(aword) == ':')
 		aword[Strlen(aword) - 1] = 0;
 	    cp = strip(Dfix1(aword));
 	    if (Gmatch(goal, cp))
 		level = -1;
 	    free(cp);
 	    break;
 	case T_DEFAULT:
 	    if (type == T_SWITCH && level == 0)
 		level = -1;
 	    break;
 	case T_ELSE:
 	    if (level == 0 && type == T_IF)
 		return;
 	    break;
 	case T_END:
 	    if (type == T_BRKSW) {
 		if (wlevel == 0) {
 		    wp = whyles;
 		    if (wp) {
 			whyles = wp->w_next;
 			wpfree(wp);
+		    }
+		}
+	    }
 	    if (type == T_BREAK)
 		level--;
 	    wlevel--;
 	    break;
 	case T_ENDIF:
 	    if (type == T_IF || type == T_ELSE)
 		level--;
 	    break;
 	case T_ENDSW:
 	    if (type == T_SWITCH || type == T_BRKSW)
 		level--;
 	    break;
 	case T_IF:
 	    while (getword(aword))
 		continue;
 	    if ((type == T_IF || type == T_ELSE) &&
 		eq(aword, STRthen))
 		level++;
 	    break;
 	case T_LABEL:
 	    if (type == T_GOTO && getword(aword) && eq(aword, goal))
 		level = -1;
 	    break;
 	case T_SWITCH:
 	    if (type == T_SWITCH || type == T_BRKSW)
 		level++;
 	    break;
 	case T_FOREACH:
 	case T_WHILE:
 	    wlevel++;
 	    if (type == T_BREAK)
 		level++;
 	    break;
 	default:
 	    if (type != T_GOTO && (type != T_SWITCH || level != 0))
 		break;
 	    if (lastchr(aword) != ':')
 		break;
 	    aword[Strlen(aword) - 1] = 0;
 	    if ((type == T_GOTO && eq(aword, goal)) ||
 		(type == T_SWITCH && eq(aword, STRdefault)))
 		level = -1;
 	    break;
+	}
 	(void) getword(NULL);
     } while (level >= 0);
+}
 static void
 wpfree(struct whyle *wp)
+{
     if (wp->w_fe0)
 	blkfree(wp->w_fe0);
     if (wp->w_fename)
 	free(wp->w_fename);
     free(wp);
+}
 static int
 getword(Char *wp)
+{
     int c, d, found, kwd;
     Char *owp;
     c = readc(1);
     d = 0;
     found = 0;
     kwd = 0;
     owp = wp;
     do {
 	while (c == ' ' || c == '\t')
 	    c = readc(1);
 	if (c == '#')
 	    do
 		c = readc(1);
 	    while (c >= 0 && c != '\n');
 	if (c < 0)
 	    goto past;
 	if (c == '\n') {
 	    if (wp)
 		break;
 	    return (0);
+	}
 	unreadc(c);
 	found = 1;
 	do {
 	    c = readc(1);
 	    if (c == '\\' && (c = readc(1)) == '\n')
 		c = ' ';
 	    if (c == '\'' || c == '"') {
 		if (d == 0)
 		    d = c;
 		else if (d == c)
 		    d = 0;
+	    }
 	    if (c < 0)
 		goto past;
 	    if (wp) {
 		*wp++ = (Char)c;
 		*wp = 0;	/* end the string b4 test */
+	    }
 	} while ((d || (!(kwd = keyword(owp)) && c != ' '
 		  && c != '\t')) && c != '\n');
     } while (wp == 0);
     /*
      * if we have read a keyword ( "if", "switch" or "while" ) then we do not
      * need to unreadc the look-ahead char
      */
     if (!kwd) {
 	unreadc(c);
 	if (found)
 	    *--wp = 0;
+    }
     return (found);
 past:
     switch (Stype) {
     case T_BREAK:
 	stderror(ERR_NAME | ERR_NOTFOUND, "end");
 	/* NOTREACHED */
     case T_ELSE:
 	stderror(ERR_NAME | ERR_NOTFOUND, "endif");
 	/* NOTREACHED */
     case T_GOTO:
 	setname(vis_str(Sgoal));
 	stderror(ERR_NAME | ERR_NOTFOUND, "label");
 	/* NOTREACHED */
     case T_IF:
 	stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
 	/* NOTREACHED */
     case T_BRKSW:
     case T_SWITCH:
 	stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
 	/* NOTREACHED */
+    }
     return (0);
+}
 /*
  * keyword(wp) determines if wp is one of the built-n functions if,
  * switch or while. It seems that when an if statement looks like
  * "if(" then getword above sucks in the '(' and so the search routine
  * never finds what it is scanning for. Rather than rewrite doword, I hack
  * in a test to see if the string forms a keyword. Then doword stops
  * and returns the word "if" -strike
  */
 static int
 keyword(Char *wp)
+{
     static Char STRswitch[] = {'s', 'w', 'i', 't', 'c', 'h', '\0'};
     static Char STRwhile[] = {'w', 'h', 'i', 'l', 'e', '\0'};
     static Char STRif[] = {'i', 'f', '\0'};
     if (!wp)
 	return (0);
     if ((Strcmp(wp, STRif) == 0) || (Strcmp(wp, STRwhile) == 0)
 	|| (Strcmp(wp, STRswitch) == 0))
 	return (1);
     return (0);
+}
 static void
 toend(void)
+{
     if (whyles->w_end.type == F_SEEK && whyles->w_end.f_seek == 0) {
 	search(T_BREAK, 0, NULL);
 	btell(&whyles->w_end);
 	whyles->w_end.f_seek--;
+    }
     else
 	bseek(&whyles->w_end);
     wfree();
+}
 void
 wfree(void)
+{
     struct Ain o;
     struct whyle *nwp;
     btell(&o);
     for (; whyles; whyles = nwp) {
 	struct whyle *wp = whyles;
 	nwp = wp->w_next;
 	/*
 	 * We free loops that have different seek types.
 	 */
 	if (wp->w_end.type != I_SEEK && wp->w_start.type == wp->w_end.type &&
 	    wp->w_start.type == o.type) {
 	    if (wp->w_end.type == F_SEEK) {
 		if (o.f_seek >= wp->w_start.f_seek &&
 		    (wp->w_end.f_seek == 0 || o.f_seek < wp->w_end.f_seek))
 		    break;
+	    }
 	    else {
 		if (o.a_seek >= wp->w_start.a_seek &&
 		    (wp->w_end.a_seek == 0 || o.a_seek < wp->w_end.a_seek))
 		    break;
+	    }
+	}
 	wpfree(wp);
+    }
+}
 void
 /*ARGSUSED*/
 doecho(Char **v, struct command *t)
+{
     xecho(' ', v);
+}
 void
 /*ARGSUSED*/
 doglob(Char **v, struct command *t)
+{
     xecho(0, v);
     (void)fflush(cshout);
+}
 static void
 xecho(int sep, Char **v)
+{
     Char *cp;
     sigset_t nsigset;
     int nonl;
     nonl = 0;
     if (setintr) {
 	sigemptyset(&nsigset);
 	(void)sigaddset(&nsigset, SIGINT);
 	(void)sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
+    }
     v++;
     if (*v == 0)
 	goto done;
     gflag = 0, tglob(v);
     if (gflag) {
 	v = globall(v);
 	if (v == 0)
 	    stderror(ERR_NAME | ERR_NOMATCH);
+    }
     else {
 	v = gargv = saveblk(v);
 	trim(v);
+    }
     if (sep == ' ' && *v && eq(*v, STRmn))
 	nonl++, v++;
     while ((cp = *v++) != NULL) {
 	int c;
 	while ((c = *cp++) != '\0')
 	    (void)vis_fputc(c | QUOTE, cshout);
 	if (*v)
 	    (void)vis_fputc(sep | QUOTE, cshout);
+    }
 done:
     if (sep && nonl == 0)
 	(void)fputc('\n', cshout);
     else
 	(void)fflush(cshout);
     if (setintr)
 	(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
     if (gargv)
 	blkfree(gargv), gargv = 0;
+}
 void
 /*ARGSUSED*/
 dosetenv(Char **v, struct command *t)
+{
     Char *lp, *vp;
     sigset_t nsigset;
     v++;
     if ((vp = *v++) == 0) {
 	Char **ep;
 	if (setintr) {
 	    sigemptyset(&nsigset);
 	    (void)sigaddset(&nsigset, SIGINT);
 	    (void)sigprocmask(SIG_UNBLOCK, &nsigset, NULL);
+	}
 	for (ep = STR_environ; *ep; ep++)
 	    (void)fprintf(cshout, "%s\n", vis_str(*ep));
 	return;
+    }
     if ((lp = *v++) == 0)
 	lp = STRNULL;
     Setenv(vp, lp = globone(lp, G_APPEND));
     if (eq(vp, STRPATH)) {
 	importpath(lp);
 	dohash(NULL, NULL);
+    }
     else if (eq(vp, STRLANG) || eq(vp, STRLC_CTYPE)) {
 #ifdef NLS
 	int k;
 	(void)setlocale(LC_ALL, "");
 	for (k = 0200; k <= 0377 && !Isprint(k); k++)
 		continue;
 	AsciiOnly = k > 0377;
 #else
 	AsciiOnly = 0;
 #endif				/* NLS */
+    }
     free(lp);
+}
 void
 /*ARGSUSED*/
 dounsetenv(Char **v, struct command *t)
+{
     static Char *name = NULL;
     Char **ep, *p, *n;
     int i, maxi;
     if (name)
 	free(name);
     /*
      * Find the longest environment variable
      */
     for (maxi = 0, ep = STR_environ; *ep; ep++) {
 	for (i = 0, p = *ep; *p && *p != '='; p++, i++)
 	    continue;
 	if (i > maxi)
 	    maxi = i;
+    }
-    name = xmalloc((size_t)(maxi + 1) * sizeof(Char));
+    name = xreallocarray(NULL, (size_t)(maxi + 1), sizeof(Char));
     while (++v && *v)
 	for (maxi = 1; maxi;)
 	    for (maxi = 0, ep = STR_environ; *ep; ep++) {
 		for (n = name, p = *ep; *p && *p != '='; *n++ = *p++)
 		    continue;
 		*n = '\0';
 		if (!Gmatch(name, *v))
 		    continue;
 		maxi = 1;
 		if (eq(name, STRLANG) || eq(name, STRLC_CTYPE)) {
 #ifdef NLS
 		    int     k;
 		    (void) setlocale(LC_ALL, "");
 		    for (k = 0200; k <= 0377 && !Isprint(k); k++)
 			continue;
 		    AsciiOnly = k > 0377;
 #else
 		    AsciiOnly = getenv("LANG") == NULL &&
 			getenv("LC_CTYPE") == NULL;
 #endif				/* NLS */
+		}
 		/*
 		 * Delete name, and start again cause the environment changes
 		 */
 		Unsetenv(name);
 		break;
+	    }
     free(name);
     name = NULL;
+}
 void
 Setenv(Char *name, Char *val)
+{
     Char *blk[2], *cp, *dp, **ep, **oep;
     ep = STR_environ;
     oep = ep;
     for (; *ep; ep++) {
 	for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
 	    continue;
 	if (*cp != 0 || *dp != '=')
 	    continue;
 	cp = Strspl(STRequal, val);
 	free(* ep);
 	*ep = strip(Strspl(name, cp));
 	free(cp);
 	blkfree((Char **)environ);
 	environ = short2blk(STR_environ);
 	return;
+    }
     cp = Strspl(name, STRequal);
     blk[0] = strip(Strspl(cp, val));
     free(cp);
     blk[1] = 0;
     STR_environ = blkspl(STR_environ, blk);
     blkfree((Char **)environ);
     environ = short2blk(STR_environ);
     free(oep);
+}
 static void
 Unsetenv(Char *name)
+{
     Char *cp, *dp, **ep, **oep;
     ep = STR_environ;
     oep = ep;
     for (; *ep; ep++) {
 	for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
 	    continue;
 	if (*cp != 0 || *dp != '=')
 	    continue;
 	cp = *ep;
 	*ep = 0;
 	STR_environ = blkspl(STR_environ, ep + 1);
 	environ = short2blk(STR_environ);
 	*ep = cp;
 	free(cp);
 	free(oep);
 	return;
+    }
+}
 void
 /*ARGSUSED*/
 doumask(Char **v, struct command *t)
+{
     Char *cp;
     mode_t i;
     cp = v[1];
     if (cp == 0) {
 	i = umask(0);
 	(void)umask(i);
 	(void)fprintf(cshout, "%o\n", i);
 	return;
+    }
     i = 0;
     while (Isdigit(*cp) && *cp != '8' && *cp != '9')
 	i = i * 8 + (mode_t)(*cp++ - '0');
     if (*cp || i > 0777)
 	stderror(ERR_NAME | ERR_MASK);
     (void)umask(i);
+}
 typedef rlim_t RLIM_TYPE;
 static const struct limits {
     int     limconst;
     const   char *limname;
     int     limdiv;
     const   char *limscale;
 }       limits[] = {
     { RLIMIT_CPU,	"cputime",	1,	"seconds" },
     { RLIMIT_FSIZE,	"filesize",	1024,	"kbytes" },
     { RLIMIT_DATA,	"datasize",	1024,	"kbytes" },
     { RLIMIT_STACK,	"stacksize",	1024,	"kbytes" },
     { RLIMIT_CORE,	"coredumpsize", 1024,	"kbytes" },
     { RLIMIT_RSS,	"memoryuse",	1024,	"kbytes" },
     { RLIMIT_MEMLOCK,	"memorylocked",	1024,	"kbytes" },
     { RLIMIT_NPROC,	"maxproc",	1,	"" },
     { RLIMIT_NTHR,	"maxthread",	1,	"" },
     { RLIMIT_NOFILE,	"openfiles",	1,	"" },
     { RLIMIT_SBSIZE,	"sbsize",	1,	"bytes" },
     { RLIMIT_AS,	"vmemoryuse",	1024,	"kbytes" },
     { -1,		NULL,		0,	NULL }
 };
 static const struct limits *findlim(Char *);
 static RLIM_TYPE getval(const struct limits *, Char **);
 static void limtail(Char *, const char *);
 static void plim(const struct limits *, Char);
 static int setlim(const struct limits *, Char, RLIM_TYPE);
 static const struct limits *
 findlim(Char *cp)
+{
     const struct limits *lp, *res;
     res = NULL;
     for (lp = limits; lp->limconst >= 0; lp++)
 	if (prefix(cp, str2short(lp->limname))) {
 	    if (res)
 		stderror(ERR_NAME | ERR_AMBIG);
 	    res = lp;
+	}
     if (res)
 	return (res);
     stderror(ERR_NAME | ERR_LIMIT);
     /* NOTREACHED */
+}
 void
 /*ARGSUSED*/
 dolimit(Char **v, struct command *t)
+{
     const struct limits *lp;
     RLIM_TYPE limit;
     char hard;
     hard = 0;
     v++;
     if (*v && eq(*v, STRmh)) {
 	hard = 1;
 	v++;
+    }
     if (*v == 0) {
 	for (lp = limits; lp->limconst >= 0; lp++)
 	    plim(lp, hard);
 	return;
+    }
     lp = findlim(v[0]);
     if (v[1] == 0) {
 	plim(lp, hard);
 	return;
+    }
     limit = getval(lp, v + 1);
     if (setlim(lp, hard, limit) < 0)
 	stderror(ERR_SILENT);
+}
 static  RLIM_TYPE
 getval(const struct limits *lp, Char **v)
+{
     Char *cp;
     double d;
     cp = *v++;
     d = atof(short2str(cp));
     while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
 	cp++;
     if (*cp == 0) {
 	if (*v == 0)
 	    return ((RLIM_TYPE)((d + 0.5) * lp->limdiv));
 	cp = *v;
+    }
     switch (*cp) {
     case ':':
 	if (lp->limconst != RLIMIT_CPU)
 	    goto badscal;
 	return ((RLIM_TYPE)(d * 60.0 + atof(short2str(cp + 1))));
     case 'M':
 	if (lp->limconst == RLIMIT_CPU)
 	    goto badscal;
 	*cp = 'm';
 	limtail(cp, "megabytes");
 	d *= 1024.0 * 1024.0;
 	break;
     case 'h':
 	if (lp->limconst != RLIMIT_CPU)
 	    goto badscal;
 	limtail(cp, "hours");
 	d *= 3600.0;
 	break;
     case 'k':
 	if (lp->limconst == RLIMIT_CPU)
 	    goto badscal;
 	limtail(cp, "kbytes");
 	d *= 1024.0;
 	break;
     case 'm':
 	if (lp->limconst == RLIMIT_CPU) {
 	    limtail(cp, "minutes");
 	    d *= 60.0;
 	    break;
+	}
 	*cp = 'm';
 	limtail(cp, "megabytes");
 	d *= 1024.0 * 1024.0;
 	break;
     case 's':
 	if (lp->limconst != RLIMIT_CPU)
 	    goto badscal;
 	limtail(cp, "seconds");
 	break;
     case 'u':
 	limtail(cp, "unlimited");
 	return (RLIM_INFINITY);
     default:
     badscal:
 	stderror(ERR_NAME | ERR_SCALEF);
 	/* NOTREACHED */
+    }
     d += 0.5;
     if (d > (double) RLIM_INFINITY)
 	return RLIM_INFINITY;
     else
 	return ((RLIM_TYPE)d);
+}
 static void
 limtail(Char *cp, const char *str)
+{
     while (*cp && *cp == *str)
 	cp++, str++;
     if (*cp)
 	stderror(ERR_BADSCALE, str);
+}
 /*ARGSUSED*/
 static void
 plim(const struct limits *lp, Char hard)
+{
     struct rlimit rlim;
     RLIM_TYPE limit;
     (void)fprintf(cshout, "%-13.13s", lp->limname);
     (void)getrlimit(lp->limconst, &rlim);
     limit = hard ? rlim.rlim_max : rlim.rlim_cur;
     if (limit == RLIM_INFINITY)
 	(void)fprintf(cshout, "unlimited");
     else if (lp->limconst == RLIMIT_CPU)
 	psecs((long) limit);
     else
 	(void)fprintf(cshout, "%jd %s",
 	    (intmax_t) (limit / (RLIM_TYPE)lp->limdiv), lp->limscale);
     (void)fputc('\n', cshout);
+}
 void
 /*ARGSUSED*/
 dounlimit(Char **v, struct command *t)
+{
     const struct limits *lp;
     int lerr;
     Char hard;
     lerr = 0;
     hard = 0;
     v++;
     if (*v && eq(*v, STRmh)) {
 	hard = 1;
 	v++;
+    }
     if (*v == 0) {
 	for (lp = limits; lp->limconst >= 0; lp++)
 	    if (setlim(lp, hard, (RLIM_TYPE)RLIM_INFINITY) < 0)
 		lerr++;
 	if (lerr)
 	    stderror(ERR_SILENT);
 	return;
+    }
     while (*v) {
 	lp = findlim(*v++);
 	if (setlim(lp, hard, (RLIM_TYPE)RLIM_INFINITY) < 0)
 	    stderror(ERR_SILENT);
+    }
+}
 static int
 setlim(const struct limits *lp, Char hard, RLIM_TYPE limit)
+{
     struct rlimit rlim;
     (void)getrlimit(lp->limconst, &rlim);
     if (hard)
 	rlim.rlim_max = limit;
     else if (limit == RLIM_INFINITY && geteuid() != 0)
 	rlim.rlim_cur = rlim.rlim_max;
     else
 	rlim.rlim_cur = limit;
     if (rlim.rlim_max < rlim.rlim_cur)
 	rlim.rlim_max = rlim.rlim_cur;
     if (setrlimit(lp->limconst, &rlim) < 0) {
 	(void)fprintf(csherr, "%s: %s: Can't %s%s limit (%s)\n", bname,
 	    lp->limname, limit == RLIM_INFINITY ? "remove" : "set",
 	    hard ? " hard" : "", strerror(errno));
 	return (-1);
+    }
     return (0);
+}
 void
 /*ARGSUSED*/
 dosuspend(Char **v, struct command *t)
+{
     int     ctpgrp;
     void    (*old)(int);
     if (loginsh)
 	stderror(ERR_SUSPLOG);
     untty();
     old = signal(SIGTSTP, SIG_DFL);
     (void)kill(0, SIGTSTP);
     /* the shell stops here */
     (void)signal(SIGTSTP, old);
     if (tpgrp != -1) {
 retry:
 	ctpgrp = tcgetpgrp(FSHTTY);
 	if  (ctpgrp != opgrp) {
 	    old = signal(SIGTTIN, SIG_DFL);
 	    (void)kill(0, SIGTTIN);
 	    (void)signal(SIGTTIN, old);
 	    goto retry;
+	}
 	(void)setpgid(0, shpgrp);
 	(void)tcsetpgrp(FSHTTY, shpgrp);
+    }
+}
 /* This is the dreaded EVAL built-in.
  *   If you don't fiddle with file descriptors, and reset didfds,
  *   this command will either ignore redirection inside or outside
  *   its arguments, e.g. eval "date >x"  vs.  eval "date" >x
  *   The stuff here seems to work, but I did it by trial and error rather
  *   than really knowing what was going on.  If tpgrp is zero, we are
  *   probably a background eval, e.g. "eval date &", and we want to
  *   make sure that any processes we start stay in our pgrp.
  *   This is also the case for "time eval date" -- stay in same pgrp.
  *   Otherwise, under stty tostop, processes will stop in the wrong
  *   pgrp, with no way for the shell to get them going again.  -IAN!
  */
 static Char **gv = NULL;
 void
 /*ARGSUSED*/
 doeval(Char **v, struct command *t)
+{
     jmp_buf osetexit;
     Char *oevalp, **oevalvec, **savegv;
     int my_reenter, odidfds, oSHERR, oSHIN, oSHOUT, saveERR, saveIN, saveOUT;
     savegv = gv;
     UNREGISTER(v);
     oevalvec = evalvec;
     oevalp = evalp;
     odidfds = didfds;
     oSHIN = SHIN;
     oSHOUT = SHOUT;
     oSHERR = SHERR;
     v++;
     if (*v == 0)
 	return;
     gflag = 0, tglob(v);
     if (gflag) {
 	gv = v = globall(v);
 	gargv = 0;
 	if (v == 0)
 	    stderror(ERR_NOMATCH);
 	v = copyblk(v);
+    }
     else {
 	gv = NULL;
 	v = copyblk(v);
 	trim(v);
+    }
     saveIN = dcopy(SHIN, -1);
     saveOUT = dcopy(SHOUT, -1);
     saveERR = dcopy(SHERR, -1);
     getexit(osetexit);
     if ((my_reenter = setexit()) == 0) {
 	evalvec = v;
 	evalp = 0;
 	SHIN = dcopy(0, -1);
 	SHOUT = dcopy(1, -1);
 	SHERR = dcopy(2, -1);
 	didfds = 0;
 	process(0);
+    }
     evalvec = oevalvec;
     evalp = oevalp;
     doneinp = 0;
     didfds = odidfds;
     if (SHIN != -1)
 	(void)close(SHIN);
     if (SHOUT != -1)
 	(void)close(SHOUT);
     if (SHERR != -1)
 	(void)close(SHERR);
     SHIN = dmove(saveIN, oSHIN);
     SHOUT = dmove(saveOUT, oSHOUT);
     SHERR = dmove(saveERR, oSHERR);
     if (gv)
 	blkfree(gv), gv = NULL;
     resexit(osetexit);
     gv = savegv;
     if (my_reenter)
 	stderror(ERR_SILENT);
+}
 void
 /*ARGSUSED*/
 doprintf(Char **v, struct command *t)
+{
     char **c;
     int ret;
     ret = progprintf(blklen(v), c = short2blk(v));
     (void)fflush(cshout);
     (void)fflush(csherr);
     blkfree((Char **)c);
     if (ret)
 	stderror(ERR_SILENT);
+}

 @@ -1,937 +1,937 @@
-/* $NetBSD: glob.c,v 1.31 2019/01/05 16:56:25 christos Exp $ */
+/* $NetBSD: glob.c,v 1.32 2024/04/24 15:49:03 nia Exp $ */
 /*-
  * Copyright (c) 1980, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)glob.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: glob.c,v 1.31 2019/01/05 16:56:25 christos Exp $");
+__RCSID("$NetBSD: glob.c,v 1.32 2024/04/24 15:49:03 nia Exp $");
 #endif
 #endif /* not lint */
 #include <sys/param.h>
 #include <errno.h>
 #include <glob.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "csh.h"
 #include "extern.h"
 static int noglob;
 static int gargsiz, pargsiz;
 /*
  * Values for gflag
  */
 #define	G_NONE 0		/* No globbing needed			*/
 #define	G_GLOB 1		/* string contains *?[] characters	*/
 #define	G_CSH 2			/* string contains ~`{ characters	*/
 #define	GLOBSPACE 100		/* Alloc increment			*/
 #define LBRC '{'
 #define RBRC '}'
 #define LBRK '['
 #define RBRK ']'
 #define EOS '\0'
 Char **gargv = NULL;
 Char **pargv = NULL;
 long gargc = 0;
 long pargc = 0;
 /*
  * globbing is now done in two stages. In the first pass we expand
  * csh globbing idioms ~`{ and then we proceed doing the normal
  * globbing if needed ?*[
+ *
  * Csh type globbing is handled in globexpand() and the rest is
  * handled in glob() which is part of the 4.4BSD libc.
+ *
  */
 static Char *globtilde(Char **, Char *);
 static Char *handleone(Char *, Char **, int);
 static Char **libglob(Char **);
 static Char **globexpand(Char **);
 static int globbrace(Char *, Char *, Char ***);
 static void expbrace(Char ***, Char ***, size_t);
 static int pmatch(const Char *, const Char *);
 static void pword(void);
 static void psave(int);
 static void backeval(Char *, int);
 static Char *
 globtilde(Char **nv, Char *s)
+{
     Char gbuf[MAXPATHLEN], *b, *e, *gstart, *u;
     gstart = gbuf;
     *gstart++ = *s++;
     u = s;
     for (b = gstart, e = &gbuf[MAXPATHLEN - 1];
 	 *s && *s != '/' && *s != ':' && b < e;
 	 *b++ = *s++)
 	 continue;
     *b = EOS;
     if (gethdir(gstart)) {
 	blkfree(nv);
 	if (*gstart)
 	    stderror(ERR_UNKUSER, vis_str(gstart));
 	else
 	    stderror(ERR_NOHOME);
+    }
     b = &gstart[Strlen(gstart)];
     while (*s)
 	*b++ = *s++;
     *b = EOS;
     --u;
     free(u);
     return (Strsave(gstart));
+}
 static int
 globbrace(Char *s, Char *p, Char ***bl)
+{
     Char gbuf[MAXPATHLEN];
     Char *lm, *pe, *pl, *pm, **nv, **vl;
     int i, len, size;
     size = GLOBSPACE;
-    nv = vl = xmalloc(sizeof(Char *) * (size_t)size);
+    nv = vl = xreallocarray(NULL, sizeof(Char *), (size_t)size);
     *vl = NULL;
     len = 0;
     /* copy part up to the brace */
     for (lm = gbuf, p = s; *p != LBRC; *lm++ = *p++)
 	continue;
     /* check for balanced braces */
     for (i = 0, pe = ++p; *pe; pe++)
 	if (*pe == LBRK) {
 	    /* Ignore everything between [] */
 	    for (++pe; *pe != RBRK && *pe != EOS; pe++)
 		continue;
 	    if (*pe == EOS) {
 		blkfree(nv);
 		return (-RBRK);
+	    }
+	}
 	else if (*pe == LBRC)
 	    i++;
 	else if (*pe == RBRC) {
 	    if (i == 0)
 		break;
 	    i--;
+	}
     if (i != 0 || *pe == '\0') {
 	blkfree(nv);
 	return (-RBRC);
+    }
     for (i = 0, pl = pm = p; pm <= pe; pm++)
 	switch (*pm) {
 	case LBRK:
 	    for (++pm; *pm != RBRK && *pm != EOS; pm++)
 		continue;
 	    if (*pm == EOS) {
 		*vl = NULL;
 		blkfree(nv);
 		return (-RBRK);
+	    }
 	    break;
 	case LBRC:
 	    i++;
 	    break;
 	case RBRC:
 	    if (i) {
 		i--;
 		break;
+	    }
 	    /* FALLTHROUGH */
 	case ',':
 	    if (i && *pm == ',')
 		break;
 	    else {
 		Char    savec = *pm;
 		*pm = EOS;
 		(void)Strcpy(lm, pl);
 		(void)Strcat(gbuf, pe + 1);
 		*pm = savec;
 		*vl++ = Strsave(gbuf);
 		len++;
 		pl = pm + 1;
 		if (vl == &nv[size]) {
 		    size += GLOBSPACE;
-		    nv = xrealloc(nv, (size_t)size * sizeof(Char *));
+		    nv = xreallocarray(nv, (size_t)size, sizeof(Char *));
 		    vl = &nv[size - GLOBSPACE];
+		}
+	    }
 	    break;
 	default:
 	    break;
+	}
     *vl = NULL;
     *bl = nv;
     return (len);
+}
 static void
 expbrace(Char ***nvp, Char ***elp, size_t size)
+{
     Char **ex, **nv, *s, **vl;
     vl = nv = *nvp;
     if (elp != NULL)
 	ex = *elp;
     else
 	for (ex = vl; *ex; ex++)
 	    continue;
     for (s = *vl; s; s = *++vl) {
 	Char *b, **bp, **vp;
 	/* leave {} untouched for find */
 	if (s[0] == '{' && (s[1] == '\0' || (s[1] == '}' && s[2] == '\0')))
 	    continue;
 	if ((b = Strchr(s, '{')) != NULL) {
 	    Char **bl;
 	    int len;
 	    if ((len = globbrace(s, b, &bl)) < 0) {
 		free(nv);
 		stderror(ERR_MISSING, -len);
+	    }
 	    free(s);
 	    if (len == 1) {
 		*vl-- = *bl;
 		free(bl);
 		continue;
+	    }
 	    len = blklen(bl);
 	    if (&ex[len] >= &nv[size]) {
 		ptrdiff_t l, e;
 		l = &ex[len] - &nv[size];
 		size += (size_t)(GLOBSPACE > l ? GLOBSPACE : l);
 		l = vl - nv;
 		e = ex - nv;
-		nv = xrealloc(nv, (size_t)size * sizeof(Char *));
+		nv = xreallocarray(nv, size, sizeof(Char *));
 		vl = nv + l;
 		ex = nv + e;
+	    }
 	    vp = vl--;
 	    *vp = *bl;
 	    len--;
 	    for (bp = ex; bp != vp; bp--)
 		bp[len] = *bp;
 	    ex += len;
 	    vp++;
 	    for (bp = bl + 1; *bp; *vp++ = *bp++)
 		continue;
 	    free(bl);
+	}
+    }
     if (elp != NULL)
 	*elp = ex;
     *nvp = nv;
+}
 static Char **
 globexpand(Char **v)
+{
     Char **ex, **nv, *s, **vl;
     size_t size;
     size = GLOBSPACE;
-    nv = vl = xmalloc(sizeof(Char *) * size);
+    nv = vl = xreallocarray(NULL, sizeof(Char *), size);
     *vl = NULL;
     /*
      * Step 1: expand backquotes.
      */
     while ((s = *v++) != NULL) {
 	if (Strchr(s, '`')) {
 	    int i;
 	    (void) dobackp(s, 0);
 	    for (i = 0; i < pargc; i++) {
 		*vl++ = pargv[i];
 		if (vl == &nv[size]) {
 		    size += GLOBSPACE;
-		    nv = xrealloc(nv, (size_t)size * sizeof(Char *));
+		    nv = xreallocarray(nv, size, sizeof(Char *));
 		    vl = &nv[size - GLOBSPACE];
+		}
+	    }
 	    free(pargv);
 	    pargv = NULL;
+	}
 	else {
 	    *vl++ = Strsave(s);
 	    if (vl == &nv[size]) {
 		size += GLOBSPACE;
-		nv = xrealloc(nv, size * sizeof(Char *));
+		nv = xreallocarray(nv, size, sizeof(Char *));
 		vl = &nv[size - GLOBSPACE];
+	    }
+	}
+    }
     *vl = NULL;
     if (noglob)
 	return (nv);
     /*
      * Step 2: expand braces
      */
     ex = vl;
     expbrace(&nv, &ex, size);
     /*
      * Step 3: expand ~
      */
     vl = nv;
     for (s = *vl; s; s = *++vl)
 	if (*s == '~')
 	    *vl = globtilde(nv, s);
     vl = nv;
     return (vl);
+}
 static Char *
 handleone(Char *str, Char **vl, int action)
+{
     Char *cp, **vlp;
     vlp = vl;
     switch (action) {
     case G_ERROR:
 	setname(vis_str(str));
 	blkfree(vl);
 	stderror(ERR_NAME | ERR_AMBIG);
 	/* NOTREACHED */
     case G_APPEND:
 	trim(vlp);
 	str = Strsave(*vlp++);
 	do {
 	    cp = Strspl(str, STRspace);
 	    free(str);
 	    str = Strspl(cp, *vlp);
 	    free(cp);
+	}
 	while (*++vlp);
 	blkfree(vl);
 	break;
     case G_IGNORE:
 	str = Strsave(strip(*vlp));
 	blkfree(vl);
 	break;
     default:
 	break;
+    }
     return (str);
+}
 static Char **
 libglob(Char **vl)
+{
     glob_t globv;
     char *ptr;
     int gflgs, magic, match, nonomatch;
     gflgs = GLOB_NOMAGIC;
     magic = 0;
     match = 0;
     nonomatch = adrof(STRnonomatch) != 0;
     if (!vl || !vl[0])
 	return (vl);
     globv.gl_offs = 0;
     globv.gl_pathv = 0;
     globv.gl_pathc = 0;
     if (nonomatch)
 	gflgs |= GLOB_NOCHECK;
     do {
 	ptr = short2qstr(*vl);
 	switch (glob(ptr, gflgs, 0, &globv)) {
 	case GLOB_ABORTED:
 	    setname(vis_str(*vl));
 	    stderror(ERR_NAME | ERR_GLOB);
 	    /* NOTREACHED */
 	case GLOB_NOSPACE:
 	    stderror(ERR_NOMEM);
 	    /* NOTREACHED */
 	default:
 	    break;
+	}
 	if (globv.gl_flags & GLOB_MAGCHAR) {
 	    match |= (globv.gl_matchc != 0);
 	    magic = 1;
+	}
 	gflgs |= GLOB_APPEND;
+    }
     while (*++vl);
     vl = (globv.gl_pathc == 0 || (magic && !match && !nonomatch)) ?
 	NULL : blk2short(globv.gl_pathv);
     globfree(&globv);
     return (vl);
+}
 Char *
 globone(Char *str, int action)
+{
     Char *v[2], **vl, **vo;
     int gflg;
     noglob = adrof(STRnoglob) != 0;
     gflag = 0;
     v[0] = str;
     v[1] = 0;
     tglob(v);
     gflg = gflag;
     if (gflg == G_NONE)
 	return (strip(Strsave(str)));
     if (gflg & G_CSH) {
 	/*
 	 * Expand back-quote, tilde and brace
 	 */
 	vo = globexpand(v);
 	if (noglob || (gflg & G_GLOB) == 0) {
 	    if (vo[0] == NULL) {
 		free(vo);
 		return (Strsave(STRNULL));
+	    }
 	    if (vo[1] != NULL)
 		return (handleone(str, vo, action));
 	    else {
 		str = strip(vo[0]);
 		free(vo);
 		return (str);
+	    }
+	}
+    }
     else if (noglob || (gflg & G_GLOB) == 0)
 	return (strip(Strsave(str)));
     else
 	vo = v;
     vl = libglob(vo);
     if ((gflg & G_CSH) && vl != vo)
 	blkfree(vo);
     if (vl == NULL) {
 	setname(vis_str(str));
 	stderror(ERR_NAME | ERR_NOMATCH);
+    }
     if (vl[0] == NULL) {
 	free(vl);
 	return (Strsave(STRNULL));
+    }
     if (vl[1] != NULL)
 	return (handleone(str, vl, action));
     else {
 	str = strip(*vl);
 	free(vl);
 	return (str);
+    }
+}
 Char  **
 globall(Char **v)
+{
     Char **vl, **vo;
     int gflg;
     gflg = gflag;
     if (!v || !v[0]) {
 	gargv = saveblk(v);
 	gargc = blklen(gargv);
 	return (gargv);
+    }
     noglob = adrof(STRnoglob) != 0;
     if (gflg & G_CSH)
 	/*
 	 * Expand back-quote, tilde and brace
 	 */
 	vl = vo = globexpand(v);
     else
 	vl = vo = saveblk(v);
     if (!noglob && (gflg & G_GLOB)) {
 	vl = libglob(vo);
 	if ((gflg & G_CSH) && vl != vo)
 	    blkfree(vo);
+    }
     else
 	trim(vl);
     gargc = vl ? blklen(vl) : 0;
     return (gargv = vl);
+}
 void
 ginit(void)
+{
     gargsiz = GLOBSPACE;
-    gargv = xmalloc(sizeof(Char *) * (size_t)gargsiz);
+    gargv = xreallocarray(NULL, sizeof(Char *), (size_t)gargsiz);
     gargv[0] = 0;
     gargc = 0;
+}
 void
 rscan(Char **t, void (*f)(int))
+{
     Char *p;
     while ((p = *t++) != NULL)
 	while (*p)
 	    (*f) (*p++);
+}
 void
 trim(Char **t)
+{
     Char *p;
     while ((p = *t++) != NULL)
 	while (*p)
 	    *p++ &= TRIM;
+}
 void
 tglob(Char **t)
+{
     Char *p, c;
     while ((p = *t++) != NULL) {
 	if (*p == '~' || *p == '=')
 	    gflag |= G_CSH;
 	else if (*p == '{' &&
 		 (p[1] == '\0' || (p[1] == '}' && p[2] == '\0')))
 	    continue;
 	while ((c = *p++) != '\0') {
 	    /*
 	     * eat everything inside the matching backquotes
 	     */
 	    if (c == '`') {
 		gflag |= G_CSH;
 		while (*p && *p != '`')
 		    if (*p++ == '\\') {
 			if (*p)		/* Quoted chars */
 			    p++;
 			else
 			    break;
+		    }
 		if (*p)			/* The matching ` */
 		    p++;
 		else
 		    break;
+	    }
 	    else if (c == '{')
 		gflag |= G_CSH;
 	    else if (isglob(c))
 		gflag |= G_GLOB;
+	}
+    }
+}
 /*
  * Command substitute cp.  If literal, then this is a substitution from a
  * << redirection, and so we should not crunch blanks and tabs, separating
  * words only at newlines.
  */
 Char **
 dobackp(Char *cp, int literal)
+{
     Char word[MAXPATHLEN], *ep, *lp, *rp;
     if (pargv) {
 #ifdef notdef
 	abort();
 #endif
 	blkfree(pargv);
+    }
     pargsiz = GLOBSPACE;
-    pargv = xmalloc(sizeof(Char *) * (size_t)pargsiz);
+    pargv = xreallocarray(NULL, sizeof(Char *), (size_t)pargsiz);
     pargv[0] = NULL;
     pargcp = pargs = word;
     pargc = 0;
     pnleft = MAXPATHLEN - 4;
     for (;;) {
 	for (lp = cp; *lp != '`'; lp++) {
 	    if (*lp == 0) {
 		if (pargcp != pargs)
 		    pword();
 		return (pargv);
+	    }
 	    psave(*lp);
+	}
 	lp++;
 	for (rp = lp; *rp && *rp != '`'; rp++)
 	    if (*rp == '\\') {
 		rp++;
 		if (!*rp)
 		    goto oops;
+	    }
 	if (!*rp) {
 	oops:
 	    stderror(ERR_UNMATCHED, '`');
+	}
 	ep = Strsave(lp);
 	ep[rp - lp] = 0;
 	backeval(ep, literal);
 	cp = rp + 1;
+    }
+}
 static void
 backeval(Char *cp, int literal)
+{
     struct command faket;
     char tibuf[BUFSIZE];
     Char ibuf[BUFSIZE], *fakecom[2], *ip;
     int pvec[2], c, quoted;
     ssize_t icnt;
     int hadnl;
     hadnl = 0;
     icnt = 0;
     quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0;
     faket.t_dtyp = NODE_COMMAND;
     faket.t_dflg = 0;
     faket.t_dlef = 0;
     faket.t_drit = 0;
     faket.t_dspr = 0;
     faket.t_dcom = fakecom;
     fakecom[0] = STRfakecom1;
     fakecom[1] = 0;
     /*
      * We do the psave job to temporarily change the current job so that the
      * following fork is considered a separate job.  This is so that when
      * backquotes are used in a builtin function that calls glob the "current
      * job" is not corrupted.  We only need one level of pushed jobs as long as
      * we are sure to fork here.
      */
     psavejob();
     /*
      * It would be nicer if we could integrate this redirection more with the
      * routines in sh.sem.c by doing a fake execute on a builtin function that
      * was piped out.
      */
     mypipe(pvec);
     if (pfork(&faket, -1) == 0) {
 	struct wordent fparaml;
 	struct command *t;
 	(void)close(pvec[0]);
 	(void)dmove(pvec[1], 1);
 	(void)dmove(SHERR, 2);
 	initdesc();
 	/*
 	 * Bugfix for nested backquotes by Michael Greim <greim@sbsvax.UUCP>,
 	 * posted to comp.bugs.4bsd 12 Sep. 1989.
 	 */
 	if (pargv)		/* mg, 21.dec.88 */
 	    blkfree(pargv), pargv = 0, pargsiz = 0;
 	/* mg, 21.dec.88 */
 	arginp = cp;
 	for (arginp = cp; *cp; cp++) {
 	    *cp &= TRIM;
 	    if (*cp == '\n' || *cp == '\r')
 		*cp = ';';
+	}
         /*
 	 * In the child ``forget'' everything about current aliases or
 	 * eval vectors.
 	 */
 	alvec = NULL;
 	evalvec = NULL;
 	alvecp = NULL;
 	evalp = NULL;
 	(void) lex(&fparaml);
 	if (seterr)
 	    stderror(ERR_OLD);
 	alias(&fparaml);
 	t = syntax(fparaml.next, &fparaml, 0);
 	if (seterr)
 	    stderror(ERR_OLD);
 	if (t)
 	    t->t_dflg |= F_NOFORK;
 	(void)signal(SIGTSTP, SIG_IGN);
 	(void)signal(SIGTTIN, SIG_IGN);
 	(void)signal(SIGTTOU, SIG_IGN);
 	execute(t, -1, NULL, NULL);
 	exitstat();
+    }
     free(cp);
     (void)close(pvec[1]);
     c = 0;
     ip = NULL;
     do {
 	int cnt;
 	cnt = 0;
 	for (;;) {
 	    if (icnt == 0) {
 		int i;
 		ip = ibuf;
 		do
 		    icnt = read(pvec[0], tibuf, BUFSIZE);
 		while (icnt == -1 && errno == EINTR);
 		if (icnt <= 0) {
 		    c = -1;
 		    break;
+		}
 		for (i = 0; i < icnt; i++)
 		    ip[i] = (unsigned char) tibuf[i];
+	    }
 	    if (hadnl)
 		break;
 	    --icnt;
 	    c = (*ip++ & TRIM);
 	    if (c == 0)
 		break;
 	    if (c == '\n') {
 		/*
 		 * Continue around the loop one more time, so that we can eat
 		 * the last newline without terminating this word.
 		 */
 		hadnl = 1;
 		continue;
+	    }
 	    if (!quoted && (c == ' ' || c == '\t'))
 		break;
 	    cnt++;
 	    psave(c | quoted);
+	}
 	/*
 	 * Unless at end-of-file, we will form a new word here if there were
 	 * characters in the word, or in any case when we take text literally.
 	 * If we didn't make empty words here when literal was set then we
 	 * would lose blank lines.
 	 */
 	if (c != -1 && (cnt || literal))
 	    pword();
 	hadnl = 0;
     } while (c >= 0);
     (void)close(pvec[0]);
     pwait();
     prestjob();
+}
 static void
 psave(int c)
+{
     if (--pnleft <= 0)
 	stderror(ERR_WTOOLONG);
     *pargcp++ = (Char)c;
+}
 static void
 pword(void)
+{
     psave(0);
     if (pargc == pargsiz - 1) {
 	pargsiz += GLOBSPACE;
-	pargv = xrealloc(pargv, (size_t)pargsiz * sizeof(Char *));
+	pargv = xreallocarray(pargv, (size_t)pargsiz, sizeof(Char *));
+    }
     pargv[pargc++] = Strsave(pargs);
     pargv[pargc] = NULL;
     pargcp = pargs;
     pnleft = MAXPATHLEN - 4;
+}
 int
 Gmatch(Char *string, Char *pattern)
+{
     Char **blk, **p;
     int gpol, gres;
     gpol = 1;
     gres = 0;
     if (*pattern == '^') {
 	gpol = 0;
 	pattern++;
+    }
-    blk = xmalloc(GLOBSPACE * sizeof(Char *));
+    blk = xreallocarray(NULL, GLOBSPACE, sizeof(Char *));
     blk[0] = Strsave(pattern);
     blk[1] = NULL;
     expbrace(&blk, NULL, GLOBSPACE);
     for (p = blk; *p; p++)
 	gres |= pmatch(string, *p);
     blkfree(blk);
     return(gres == gpol);
+}
 static int
 pmatch(const Char *name, const Char *pat)
+{
     int match, negate_range;
     Char patc, namec, c;
     const Char *nameNext, *nameStart, *nameEnd, *patNext;
     nameNext = nameStart = name;
     patNext = pat;
     nameEnd = NULL;
     for (;;) {
 	namec = *name & TRIM;
 	if (namec == 0)
 	    nameEnd = name;
 	patc = *pat;
 	switch (patc) {
 	case 0:
 	    if (namec == 0)
 		return 1;
 	    break;
 	case '?':
 	    if (namec == 0)
 		break;
 	    pat++;
 	    name++;
 	    continue;
 	case '*':
 	    while ((pat[1] & TRIM) == '*')
 		pat++;
 	    patNext = pat;
 	    nameNext = name + 1;
 	    pat++;
 	    continue;
 	case '[':
 	    match = 0;
 	    if (namec == 0)
 		break;
 	    pat++;
 	    name++;
 	    if ((negate_range = (*pat == '^')) != 0)
 		pat++;
 	    while ((c = *pat++) != ']') {
 		c &= TRIM;
 		if (*pat == '-') {
 		    if (c <= namec && namec <= (pat[1] & TRIM))
 			match = 1;
 		    pat += 2;
 		} else if (c == namec)
 		    match = 1;
 		else if (c == 0)
 		    stderror(ERR_NAME | ERR_MISSING, ']');
+	    }
 	    if (match == negate_range)
 		break;
 	    continue;
 	default:
 	    if ((patc & TRIM) != namec)
 		break;
 	    pat++;
 	    name++;
 	    continue;
+	}
 	if (nameNext != nameStart && (nameEnd == NULL || nameNext <= nameEnd)) {
 	    pat = patNext;
 	    name = nameNext;
 	    continue;
+	}
 	return 0;
+    }
+}
 void
 Gcat(Char *s1, Char *s2)
+{
     Char *p, *q;
     ptrdiff_t n;
     for (p = s1; *p++;)
 	continue;
     for (q = s2; *q++;)
 	continue;
     n = (p - s1) + (q - s2) - 1;
     if (++gargc >= gargsiz) {
 	gargsiz += GLOBSPACE;
-	gargv = xrealloc(gargv, (size_t)gargsiz * sizeof(Char *));
+	gargv = xreallocarray(gargv, (size_t)gargsiz, sizeof(Char *));
+    }
     gargv[gargc] = 0;
-    p = gargv[gargc - 1] = xmalloc((size_t)n * sizeof(Char));
+    p = gargv[gargc - 1] = xreallocarray(NULL, (size_t)n, sizeof(Char));
     for (q = s1; (*p++ = *q++) != '\0';)
 	continue;
     for (p--, q = s2; (*p++ = *q++) != '\0';)
 	continue;
+}
 #ifdef FILEC
 int
 sortscmp(const void *va, const void *vb)
+{
 #if defined(NLS) && !defined(NOSTRCOLL)
     char buf[2048];
 #endif
     const Char * const *a = va;
     const Char * const *b = vb;
     if (!a)			/* check for NULL */
 	return (b ? 1 : 0);
     if (!b)
 	return -1;
     if (!*a)			/* check for NULL */
 	return *b ? 1 : 0;
     if (!*b)
 	return (-1);
 #if defined(NLS) && !defined(NOSTRCOLL)
     (void)strcpy(buf, short2str(*a));
     return (int)strcoll(buf, short2str(*b));
 #else
     return (int)Strcmp(*a, *b);
 #endif
+}
 #endif /* FILEC */

 @@ -1,407 +1,407 @@
-/* $NetBSD: misc.c,v 1.22 2019/01/05 16:54:00 christos Exp $ */
+/* $NetBSD: misc.c,v 1.23 2024/04/24 15:49:03 nia Exp $ */
 /*-
  * Copyright (c) 1980, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)misc.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: misc.c,v 1.22 2019/01/05 16:54:00 christos Exp $");
+__RCSID("$NetBSD: misc.c,v 1.23 2024/04/24 15:49:03 nia Exp $");
 #endif
 #endif /* not lint */
 #include <sys/param.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include "csh.h"
 #include "extern.h"
 static int renum(int, int);
 int
 any(const char *s, int c)
+{
     if (!s)
 	return (0);		/* Check for nil pointer */
     while (*s)
 	if (*s++ == c)
 	    return (1);
     return (0);
+}
 char *
 strsave(const char *s)
+{
     const char *n;
     char *p, *r;
     if (s == NULL)
 	s = "";
     for (n = s; *n++;)
 	continue;
-    r = p = xmalloc((size_t)(n - s) * sizeof(*p));
+    r = p = xreallocarray(NULL, (size_t)(n - s), sizeof(*p));
     while ((*p++ = *s++) != '\0')
 	continue;
     return (r);
+}
 Char **
 blkend(Char **up)
+{
     while (*up)
 	up++;
     return (up);
+}
 void
 blkpr(FILE *fp, Char **av)
+{
     for (; *av; av++) {
 	(void)fprintf(fp, "%s", vis_str(*av));
 	if (av[1])
 	    (void)fprintf(fp, " ");
+    }
+}
 int
 blklen(Char **av)
+{
     int i;
     i = 0;
     while (*av++)
 	i++;
     return (i);
+}
 Char **
 blkcpy(Char **oav, Char **bv)
+{
     Char **av;
     av = oav;
     while ((*av++ = *bv++) != NULL)
 	continue;
     return (oav);
+}
 Char **
 blkcat(Char **up, Char **vp)
+{
     (void)blkcpy(blkend(up), vp);
     return (up);
+}
 void
 blkfree(Char **av0)
+{
     Char **av;
     av = av0;
     if (!av0)
 	return;
     for (; *av; av++)
 	free(* av);
     free(av0);
+}
 Char **
 saveblk(Char **v)
+{
     Char **newv, **onewv;
     if (v == NULL)
 	return NULL;
     newv = xcalloc((size_t)(blklen(v) + 1), sizeof(*newv));
     onewv = newv;
     while (*v)
 	*newv++ = Strsave(*v++);
     return (onewv);
+}
 #ifdef NOTUSED
 char *
 strstr(char *s, char *t)
+{
     do {
 	char *ss;
 	char *tt;
 	ss = s;
 	tt = t;
 	do
 	    if (*tt == '\0')
 		return (s);
 	while (*ss++ == *tt++);
     } while (*s++ != '\0');
     return (NULL);
+}
 #endif /* NOTUSED */
 #ifndef SHORT_STRINGS
 char *
 strspl(char *cp, char *dp)
+{
     char *ep, *p, *q;
     if (!cp)
 	cp = "";
     if (!dp)
 	dp = "";
     for (p = cp; *p++;)
 	continue;
     for (q = dp; *q++;)
 	continue;
-    ep = xmalloc((size_t)(((p - cp) + (q - dp) - 1) * sizeof(*ep)));
+    ep = xreallocarray(NULL, (size_t)(((p - cp) + (q - dp) - 1), sizeof(*ep)));
     for (p = ep, q = cp; *p++ = *q++;)
 	continue;
     for (p--, q = dp; *p++ = *q++;)
 	continue;
     return (ep);
+}
 #endif
 Char **
 blkspl(Char **up, Char **vp)
+{
     Char **wp;
     wp = xcalloc((size_t)(blklen(up) + blklen(vp) + 1), sizeof(*wp));
     (void)blkcpy(wp, up);
     return (blkcat(wp, vp));
+}
 Char
 lastchr(Char *cp)
+{
     if (!cp)
 	return (0);
     if (!*cp)
 	return (0);
     while (cp[1])
 	cp++;
     return (*cp);
+}
 /*
  * This routine is called after an error to close up
  * any units which may have been left open accidentally.
  */
 void
 closem(void)
+{
     int f;
     int nofile;
 #ifdef F_CLOSEM
     nofile = FOLDSTD + 1;
     if (fcntl(nofile, F_CLOSEM, 0) == -1)
 #endif
 	nofile = NOFILE;
     for (f = 0; f < nofile; f++)
 	if (f != SHIN && f != SHOUT && f != SHERR && f != OLDSTD &&
 	    f != FSHTTY)
 	    (void) close(f);
+}
 void
 donefds(void)
+{
     (void)close(0);
     (void)close(1);
     (void)close(2);
     didfds = 0;
+}
 /*
  * Move descriptor i to j.
  * If j is -1 then we just want to get i to a safe place,
  * i.e. to a unit > 2.  This also happens in dcopy.
  */
 int
 dmove(int i, int j)
+{
     if (i == j || i < 0)
 	return (i);
     if (j >= 0) {
 	(void)dup2(i, j);
 	if (j != i)
 	    (void)close(i);
 	return (j);
+    }
     j = dcopy(i, j);
     if (j != i)
 	(void)close(i);
     return (j);
+}
 int
 dcopy(int i, int j)
+{
     if (i == j || i < 0 || (j < 0 && i > 2))
 	return (i);
     if (j >= 0) {
 	(void)dup2(i, j);
 	return (j);
+    }
     return (renum(i, j));
+}
 static int
 renum(int i, int j)
+{
     int k;
     k = dup(i);
     if (k < 0)
 	return (-1);
     if (j == -1 && k > 2)
 	return (k);
     if (k != j) {
 	j = renum(k, j);
 	(void)close(k);
 	return (j);
+    }
     return (k);
+}
 /*
  * Left shift a command argument list, discarding
  * the first c arguments.  Used in "shift" commands
  * as well as by commands like "repeat".
  */
 void
 lshift(Char **v, size_t c)
+{
     Char **u;
     for (u = v; *u && c-- > 0; u++)
 	free(*u);
     (void)blkcpy(v, u);
+}
 int
 number(Char *cp)
+{
     if (!cp)
 	return(0);
     if (*cp == '-') {
 	cp++;
 	if (!Isdigit(*cp))
 	    return (0);
 	cp++;
+    }
     while (*cp && Isdigit(*cp))
 	cp++;
     return (*cp == 0);
+}
 Char **
 copyblk(Char **v)
+{
     Char **nv;
     nv = xcalloc((size_t)(blklen(v) + 1), sizeof(*nv));
     return (blkcpy(nv, v));
+}
 #ifndef SHORT_STRINGS
 char *
 strend(char *cp)
+{
     if (!cp)
 	return (cp);
     while (*cp)
 	cp++;
     return (cp);
+}
 #endif /* SHORT_STRINGS */
 Char *
 strip(Char *cp)
+{
     Char *dp;
     dp = cp;
     if (!cp)
 	return (cp);
     while ((*dp++ &= TRIM) != '\0')
 	continue;
     return (cp);
+}
 Char *
 quote(Char *cp)
+{
     Char *dp;
     dp = cp;
     if (!cp)
 	return (cp);
     while (*dp != '\0')
 	*dp++ |= QUOTE;
     return (cp);
+}
 void
 udvar(Char *name)
+{
     setname(vis_str(name));
     stderror(ERR_NAME | ERR_UNDVAR);
     /* NOTREACHED */
+}
 int
 prefix(Char *sub, Char *str)
+{
     for (;;) {
 	if (*sub == 0)
 	    return (1);
 	if (*str == 0)
 	    return (0);
 	if (*sub++ != *str++)
 	    return (0);
+    }
+}

 @@ -1,437 +1,437 @@
-/* $NetBSD: str.c,v 1.16 2019/01/05 16:54:00 christos Exp $ */
+/* $NetBSD: str.c,v 1.17 2024/04/24 15:49:03 nia Exp $ */
 /*-
  * Copyright (c) 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)str.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: str.c,v 1.16 2019/01/05 16:54:00 christos Exp $");
+__RCSID("$NetBSD: str.c,v 1.17 2024/04/24 15:49:03 nia Exp $");
 #endif
 #endif /* not lint */
 #define MALLOC_INCR 128
 /*
  * tc.str.c: Short string package
  *	     This has been a lesson of how to write buggy code!
  */
 #include <sys/types.h>
 #include <stdarg.h>
 #include <vis.h>
 #include "csh.h"
 #include "extern.h"
 #ifdef SHORT_STRINGS
 Char **
 blk2short(char **src)
+{
     Char **dst, **sdst;
     size_t n;
     /*
      * Count
      */
     for (n = 0; src[n] != NULL; n++)
 	continue;
-    sdst = dst = xmalloc((size_t)((n + 1) * sizeof(*dst)));
+    sdst = dst = xreallocarray(NULL, n + 1, sizeof(*dst));
     for (; *src != NULL; src++)
 	*dst++ = SAVE(*src);
     *dst = NULL;
     return (sdst);
+}
 char **
 short2blk(Char *const *src)
+{
     char **dst, **sdst;
     size_t n;
     /*
      * Count
      */
     for (n = 0; src[n] != NULL; n++)
 	continue;
-    sdst = dst = xmalloc((size_t)((n + 1) * sizeof(*dst)));
+    sdst = dst = xreallocarray(NULL, n + 1, sizeof(*dst));
     for (; *src != NULL; src++)
 	*dst++ = strsave(short2str(*src));
     *dst = NULL;
     return (sdst);
+}
 Char *
 str2short(const char *src)
+{
     static Char *sdst;
     Char *dst, *edst;
     static size_t dstsize = 0;
     if (src == NULL)
 	return (NULL);
     if (sdst == (NULL)) {
 	dstsize = MALLOC_INCR;
-	sdst = xmalloc((size_t)dstsize * sizeof(*sdst));
+	sdst = xreallocarray(NULL, (size_t)dstsize, sizeof(*sdst));
+    }
     dst = sdst;
     edst = &dst[dstsize];
     while (*src) {
 	*dst++ = (Char) ((unsigned char) *src++);
 	if (dst == edst) {
 	    dstsize += MALLOC_INCR;
-	    sdst = xrealloc(sdst, (size_t)dstsize * sizeof(*sdst));
+	    sdst = xreallocarray(sdst, (size_t)dstsize, sizeof(*sdst));
 	    edst = &sdst[dstsize];
 	    dst = &edst[-MALLOC_INCR];
+	}
+    }
     *dst = 0;
     return (sdst);
+}
 char *
 short2str(const Char *src)
+{
     static char *sdst = NULL;
     static size_t dstsize = 0;
     char *dst, *edst;
     if (src == NULL)
 	return (NULL);
     if (sdst == NULL) {
 	dstsize = MALLOC_INCR;
-	sdst = xmalloc((size_t)dstsize * sizeof(*sdst));
+	sdst = xreallocarray(NULL, dstsize, sizeof(*sdst));
+    }
     dst = sdst;
     edst = &dst[dstsize];
     while (*src) {
 	*dst++ = (char) *src++;
 	if (dst == edst) {
 	    dstsize += MALLOC_INCR;
-	    sdst = xrealloc(sdst, (size_t)dstsize * sizeof(*sdst));
+	    sdst = xreallocarray(sdst, dstsize, sizeof(*sdst));
 	    edst = &sdst[dstsize];
 	    dst = &edst[-MALLOC_INCR];
+	}
+    }
     *dst = 0;
     return (sdst);
+}
 Char *
 s_strcpy(Char *dst, const Char *src)
+{
     Char *sdst;
     sdst = dst;
     while ((*dst++ = *src++) != '\0')
 	continue;
     return (sdst);
+}
 Char *
 s_strncpy(Char *dst, const Char *src, size_t n)
+{
     Char *sdst;
     if (n == 0)
 	return(dst);
     sdst = dst;
     do
 	if ((*dst++ = *src++) == '\0') {
 	    while (--n != 0)
 		*dst++ = '\0';
 	    return(sdst);
+	}
     while (--n != 0);
     return (sdst);
+}
 Char *
 s_strcat(Char *dst, const Char *src)
+{
     short *sdst;
     sdst = dst;
     while (*dst++)
 	continue;
     --dst;
     while ((*dst++ = *src++) != '\0')
 	continue;
     return (sdst);
+}
 #ifdef NOTUSED
 Char *
 s_strncat(Char *dst, Char *src, size_t n)
+{
     Char *sdst;
     if (n == 0)
 	return (dst);
     sdst = dst;
     while (*dst++)
 	continue;
     --dst;
     do
 	if ((*dst++ = *src++) == '\0')
 	    return(sdst);
     while (--n != 0)
 	continue;
     *dst = '\0';
     return (sdst);
+}
 #endif
 Char *
 s_strchr(const Char *str, int ch)
+{
     do
 	if (*str == ch)
 	    return __UNCONST(str);
     while (*str++);
     return (NULL);
+}
 Char *
 s_strrchr(const Char *str, int ch)
+{
     const Char *rstr;
     rstr = NULL;
     do
 	if (*str == ch)
 	    rstr = str;
     while (*str++);
     return __UNCONST(rstr);
+}
 size_t
 s_strlen(const Char *str)
+{
     size_t n;
     for (n = 0; *str++; n++)
 	continue;
     return (n);
+}
 int
 s_strcmp(const Char *str1, const Char *str2)
+{
     for (; *str1 && *str1 == *str2; str1++, str2++)
 	continue;
     /*
      * The following case analysis is necessary so that characters which look
      * negative collate low against normal characters but high against the
      * end-of-string NUL.
      */
     if (*str1 == '\0' && *str2 == '\0')
 	return (0);
     else if (*str1 == '\0')
 	return (-1);
     else if (*str2 == '\0')
 	return (1);
     else
 	return (*str1 - *str2);
+}
 int
 s_strncmp(const Char *str1, const Char *str2, size_t n)
+{
     if (n == 0)
 	return (0);
     do {
 	if (*str1 != *str2) {
 	    /*
 	     * The following case analysis is necessary so that characters
 	     * which look negative collate low against normal characters
 	     * but high against the end-of-string NUL.
 	     */
 	    if (*str1 == '\0')
 		return (-1);
 	    else if (*str2 == '\0')
 		return (1);
 	    else
 		return (*str1 - *str2);
+	}
         if (*str1 == '\0')
 	    return(0);
 	str1++, str2++;
     } while (--n != 0);
     return(0);
+}
 Char *
 s_strsave(const Char *s)
+{
     const Char *p;
     Char *n;
     if (s == 0)
 	s = STRNULL;
     for (p = s; *p++;)
 	continue;
-    p = n = xmalloc((size_t)(p - s) * sizeof(*n));
+    p = n = xreallocarray(NULL, (size_t)(p - s), sizeof(*n));
     while ((*n++ = *s++) != '\0')
 	continue;
     return __UNCONST(p);
+}
 Char *
 s_strspl(const Char *cp, const Char *dp)
+{
     Char *ep, *d;
     const Char *p, *q;
     if (!cp)
 	cp = STRNULL;
     if (!dp)
 	dp = STRNULL;
     for (p = cp; *p++;)
 	continue;
     for (q = dp; *q++;)
 	continue;
-    ep = xmalloc((size_t)((p - cp) + (q - dp) - 1) * sizeof(*ep));
+    ep = xreallocarray(NULL, (size_t)((p - cp) + (q - dp) - 1), sizeof(*ep));
     for (d = ep, q = cp; (*d++ = *q++) != '\0';)
 	continue;
     for (d--, q = dp; (*d++ = *q++) != '\0';)
 	continue;
     return (ep);
+}
 Char *
 s_strend(const Char *cp)
+{
     if (!cp)
 	return __UNCONST(cp);
     while (*cp)
 	cp++;
     return __UNCONST(cp);
+}
 Char *
 s_strstr(const Char *s, const Char *t)
+{
     do {
 	const Char *ss = s;
 	const Char *tt = t;
 	do
 	    if (*tt == '\0')
 		return __UNCONST(s);
 	while (*ss++ == *tt++);
     } while (*s++ != '\0');
     return (NULL);
+}
 #endif				/* SHORT_STRINGS */
 char *
 short2qstr(const Char *src)
+{
     static char *sdst = NULL;
     static size_t dstsize = 0;
     char *dst, *edst;
     if (src == NULL)
 	return (NULL);
     if (sdst == NULL) {
 	dstsize = MALLOC_INCR;
-	sdst = xmalloc((size_t)dstsize * sizeof(*sdst));
+	sdst = xreallocarray(NULL, dstsize, sizeof(*sdst));
+    }
     dst = sdst;
     edst = &dst[dstsize];
     while (*src) {
 	if (*src & QUOTE) {
 	    *dst++ = '\\';
 	    if (dst == edst) {
 		dstsize += MALLOC_INCR;
-		sdst = xrealloc(sdst, (size_t)dstsize * sizeof(*sdst));
+		sdst = xreallocarray(sdst, (size_t)dstsize, sizeof(*sdst));
 		edst = &sdst[dstsize];
 		dst = &edst[-MALLOC_INCR];
+	    }
+	}
 	*dst++ = (char) *src++;
 	if (dst == edst) {
 	    dstsize += MALLOC_INCR;
-	    sdst = xrealloc(sdst, (size_t)dstsize * sizeof(*sdst));
+	    sdst = xreallocarray(sdst, (size_t)dstsize, sizeof(*sdst));
 	    edst = &sdst[dstsize];
 	    dst = &edst[-MALLOC_INCR];
+	}
+    }
     *dst = 0;
     return (sdst);
+}
 /*
  * XXX: Should we worry about QUOTE'd chars?
  */
 char *
 vis_str(const Char *cp)
+{
     static char *sdst = NULL;
     static size_t dstsize = 0;
     const Char *dp;
     size_t n;
     if (cp == NULL)
 	return (NULL);
     for (dp = cp; *dp++;)
 	continue;
     n = ((size_t)(dp - cp) << 2) + 1; /* 4 times + NULL */
     if (dstsize < n) {
 	sdst = (dstsize ?
-	    xrealloc(sdst, (size_t)n * sizeof(*sdst)) :
+	    xreallocarray(sdst, (size_t)n, sizeof(*sdst)) :
-	    xmalloc((size_t)n * sizeof(*sdst)));
+	    xreallocarray(NULL, (size_t)n, sizeof(*sdst)));
 	dstsize = n;
+    }
     /*
      * XXX: When we are in AsciiOnly we want all characters >= 0200 to
      * be encoded, but currently there is no way in vis to do that.
      */
     (void)strvis(sdst, short2str(cp), VIS_NOSLASH);
     return (sdst);
+}