Re: Build original Csh on Linux and FreeBSD.

[RVP <rvp%SDF.ORG@localhost>]

> Here are the errors I get: http://bwass.org/bucket/err_csh.txt

A _very_ quick hack to compile NetBSD csh on FreeBSD is attached.
Linux would be slightly more complicated (you would need libbsd,
libedit, ...). It should get your started.

There are issues with cmdline editing--try completing a filename
using ESC, then back-spacing over it--probably because I had to
#ifdef out EL_SAFEREAD?. Maybe a newer libedit from ports would
work...

-RVP

diff -urN csh.orig/Makefile csh/Makefile
--- csh.orig/Makefile	2018-06-10 17:55:11.000000000 +0000
+++ csh/Makefile	2022-09-04 22:00:23.845602000 +0000
@@ -19,9 +19,10 @@
 DFLAGS+=-DEDIT
 .endif
 CPPFLAGS+=-I${.CURDIR} -I. ${DFLAGS}
+CFLAGS+=-D__dead=__dead2 ${DFLAGS}
 SRCS=	alloc.c char.c const.c csh.c dir.c dol.c err.c exec.c exp.c file.c \
 	func.c glob.c hist.c init.c lex.c misc.c parse.c printf.c proc.c \
-	sem.c set.c str.c time.c
+	sem.c set.c str.c time.c strpct.c
 .PATH:	${NETBSDSRCDIR}/usr.bin/printf
 
 MLINKS=	csh.1 limit.1 csh.1 alias.1 csh.1 bg.1 csh.1 dirs.1 csh.1 fg.1 \
@@ -49,7 +50,7 @@
 	rm -f ${.TARGET}
 	echo '/* Do not edit this file, make creates it. */' > ${.TARGET}
 	${CC} -E ${CPPFLAGS} ${.ALLSRC} | egrep 'Char STR' | \
-	    ${TOOL_SED} -e 's/Char \([a-zA-Z0-9_]*\)\(.*\)/extern Char \1[];/' | \
+	    sed -e 's/Char \([a-zA-Z0-9_]*\)\(.*\)/extern Char \1[];/' | \
 	    sort >> ${.TARGET}
 
 SUBDIR.roff+=USD.doc
@@ -59,7 +60,7 @@
 COPTS.proc.c = -Wno-format-nonliteral
 
 .if !empty(DFLAGS:M*EDIT)
-LDADD+=-ledit -lterminfo -lutil
+LDADD+=-ledit -ltinfo
 DPADD+=${LIBEDIT} ${LIBUTIL}
 .else
 LDADD+=-lutil
@@ -68,3 +69,4 @@
 
 .include <bsd.prog.mk>
 .include <bsd.subdir.mk>
+CFLAGS+=-Wno-error
diff -urN csh.orig/csh.c csh/csh.c
--- csh.orig/csh.c	2020-08-09 00:53:38.000000000 +0000
+++ csh/csh.c	2022-09-04 21:26:58.723047000 +0000
@@ -298,14 +298,11 @@
     (void)fclose(cshin);
     (void)fclose(cshout);
     (void)fclose(csherr);
-    if (!(cshin  = funopen2((void *) &SHIN,  readf, writef, seekf, NULL,
-	closef)))
+    if (!(cshin  = funopen((void *) &SHIN,  readf, writef, seekf, closef)))
 	exit(1);
-    if (!(cshout = funopen2((void *) &SHOUT, readf, writef, seekf, NULL,
-	closef)))
+    if (!(cshout = funopen((void *) &SHOUT, readf, writef, seekf, closef)))
 	exit(1);
-    if (!(csherr = funopen2((void *) &SHERR, readf, writef, seekf, NULL,
-	closef)))
+    if (!(csherr = funopen((void *) &SHERR, readf, writef, seekf, closef)))
 	exit(1);
     (void)setvbuf(cshin,  NULL, _IOLBF, 0);
     (void)setvbuf(cshout, NULL, _IOLBF, 0);
diff -urN csh.orig/func.c csh/func.c
--- csh.orig/func.c	2020-08-09 00:22:53.000000000 +0000
+++ csh/func.c	2022-09-04 21:09:54.088881000 +0000
@@ -1105,7 +1105,9 @@
     { RLIMIT_RSS,	"memoryuse",	1024,	"kbytes" },
     { RLIMIT_MEMLOCK,	"memorylocked",	1024,	"kbytes" },
     { RLIMIT_NPROC,	"maxproc",	1,	"" },
+#ifdef RLIMIT_NTHR
     { RLIMIT_NTHR,	"maxthread",	1,	"" },
+#endif
     { RLIMIT_NOFILE,	"openfiles",	1,	"" },
     { RLIMIT_SBSIZE,	"sbsize",	1,	"bytes" },
     { RLIMIT_AS,	"vmemoryuse",	1024,	"kbytes" },
diff -urN csh.orig/printf.c csh/printf.c
--- csh.orig/printf.c	1970-01-01 00:00:00.000000000 +0000
+++ csh/printf.c	2021-05-20 02:01:07.000000000 +0000
@@ -0,0 +1,773 @@
+/*	$NetBSD: printf.c,v 1.54 2021/05/20 02:01:07 christos Exp $	*/
+
+/*
+ * Copyright (c) 1989, 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 !defined(BUILTIN) && !defined(SHELL)
+__COPYRIGHT("@(#) Copyright (c) 1989, 1993\
+ The Regents of the University of California.  All rights reserved.");
+#endif
+#endif
+
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)printf.c	8.2 (Berkeley) 3/22/95";
+#else
+__RCSID("$NetBSD: printf.c,v 1.54 2021/05/20 02:01:07 christos Exp $");
+#endif
+#endif /* not lint */
+
+#include <sys/types.h>
+
+#include <ctype.h>
+#include <err.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <locale.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifdef __GNUC__
+#define ESCAPE '\e'
+#else
+#define ESCAPE 033
+#endif
+
+static void	 conv_escape_str(char *, void (*)(int), int);
+static char	*conv_escape(char *, char *, int);
+static char	*conv_expand(const char *);
+static char	 getchr(void);
+static double	 getdouble(void);
+static int	 getwidth(void);
+static intmax_t	 getintmax(void);
+static char	*getstr(void);
+static char	*mklong(const char *, char);
+static intmax_t	 wide_char(const char *);
+static void      check_conversion(const char *, const char *);
+static void	 usage(void);
+
+static void	b_count(int);
+static void	b_output(int);
+static size_t	b_length;
+static char	*b_fmt;
+
+static int	rval;
+static char  **gargv;
+
+#ifdef BUILTIN		/* csh builtin */
+#define main progprintf
+#endif
+
+#ifdef SHELL		/* sh (aka ash) builtin */
+#define main printfcmd
+#include "../../bin/sh/bltin/bltin.h"
+#endif /* SHELL */
+
+#define PF(f, func) { \
+	if (fieldwidth != -1) { \
+		if (precision != -1) \
+			error = printf(f, fieldwidth, precision, func); \
+		else \
+			error = printf(f, fieldwidth, func); \
+	} else if (precision != -1) \
+		error = printf(f, precision, func); \
+	else \
+		error = printf(f, func); \
+}
+
+#define APF(cpp, f, func) { \
+	if (fieldwidth != -1) { \
+		if (precision != -1) \
+			error = asprintf(cpp, f, fieldwidth, precision, func); \
+		else \
+			error = asprintf(cpp, f, fieldwidth, func); \
+	} else if (precision != -1) \
+		error = asprintf(cpp, f, precision, func); \
+	else \
+		error = asprintf(cpp, f, func); \
+}
+
+#define isodigit(c)	((c) >= '0' && (c) <= '7')
+#define octtobin(c)	((c) - '0')
+#define check(c, a)	(c) >= (a) && (c) <= (a) + 5 ? (c) - (a) + 10
+#define hextobin(c)	(check(c, 'a') : check(c, 'A') : (c) - '0')
+#ifdef main
+int main(int, char *[]);
+#endif
+
+int
+main(int argc, char *argv[])
+{
+	char *fmt, *start;
+	int fieldwidth, precision;
+	char nextch;
+	char *format;
+	char ch;
+	int error;
+
+#if !defined(SHELL) && !defined(BUILTIN)
+	(void)setlocale (LC_ALL, "");
+#endif
+
+	rval = 0;	/* clear for builtin versions (avoid holdover) */
+	clearerr(stdout);	/* for the builtin version */
+
+	/*
+	 * printf does not comply with Posix XBD 12.2 - there are no opts,
+	 * not even the -- end of options marker.   Do not run getoot().
+	 */
+	if (argc > 2 && strchr(argv[1], '%') == NULL) {
+		int o;
+
+		/*
+		 * except that if there are multiple args and
+		 * the first (the nominal format) contains no '%'
+		 * conversions (which we will approximate as no '%'
+		 * characters at all, conversions or not) then the
+		 * results are unspecified, and we can do what we
+		 * like.   So in that case, for some backward compat
+		 * to scripts which (stupidly) do:
+		 *	printf -- format args
+		 * process this case the old way.
+		 */
+
+		while ((o = getopt(argc, argv, "")) != -1) {
+			switch (o) {
+			case '?':
+			default:
+				usage();
+				return 1;
+			}
+		}
+		argc -= optind;
+		argv += optind;
+	} else {
+		argc -= 1;	/* drop argv[0] (the program name) */
+		argv += 1;
+	}
+
+	if (argc < 1) {
+		usage();
+		return 1;
+	}
+
+	format = *argv;
+	gargv = ++argv;
+
+#define SKIP1	"#-+ 0'"
+#define SKIP2	"0123456789"
+	do {
+		/*
+		 * Basic algorithm is to scan the format string for conversion
+		 * specifications -- once one is found, find out if the field
+		 * width or precision is a '*'; if it is, gather up value.
+		 * Note, format strings are reused as necessary to use up the
+		 * provided arguments, arguments of zero/null string are
+		 * provided to use up the format string.
+		 */
+
+		/* find next format specification */
+		for (fmt = format; (ch = *fmt++) != '\0';) {
+			if (ch == '\\') {
+				char c_ch;
+				fmt = conv_escape(fmt, &c_ch, 0);
+				putchar(c_ch);
+				continue;
+			}
+			if (ch != '%' || (*fmt == '%' && ++fmt)) {
+				(void)putchar(ch);
+				continue;
+			}
+
+			/*
+			 * Ok - we've found a format specification,
+			 * Save its address for a later printf().
+			 */
+			start = fmt - 1;
+
+			/* skip to field width */
+			fmt += strspn(fmt, SKIP1);
+			if (*fmt == '*') {
+				fmt++;
+				fieldwidth = getwidth();
+			} else {
+				fieldwidth = -1;
+
+				/* skip to possible '.' for precision */
+				fmt += strspn(fmt, SKIP2);
+			}
+
+			if (*fmt == '.') {
+				 /* get following precision */
+				fmt++;
+				if (*fmt == '*') {
+					fmt++;
+					precision = getwidth();
+				} else {
+					precision = -1;
+					fmt += strspn(fmt, SKIP2);
+				}
+			} else
+				precision = -1;
+
+			ch = *fmt;
+			if (!ch) {
+				warnx("%s: missing format character", start);
+				return 1;
+			}
+
+			/*
+			 * null terminate format string to we can use it
+			 * as an argument to printf.
+			 */
+			nextch = fmt[1];
+			fmt[1] = 0;
+
+			switch (ch) {
+
+			case 'B': {
+				const char *p = conv_expand(getstr());
+
+				if (p == NULL)
+					goto out;
+				*fmt = 's';
+				PF(start, p);
+				if (error < 0)
+					goto out;
+				break;
+			}
+			case 'b': {
+				/*
+				 * There has to be a better way to do this,
+				 * but the string we generate might have
+				 * embedded nulls
+				 */
+				static char *a, *t;
+				char *cp = getstr();
+
+				/* Free on entry in case shell longjumped out */
+				if (a != NULL)
+					free(a);
+				a = NULL;
+				if (t != NULL)
+					free(t);
+				t = NULL;
+
+				/* Count number of bytes we want to output */
+				b_length = 0;
+				conv_escape_str(cp, b_count, 0);
+				t = malloc(b_length + 1);
+				if (t == NULL)
+					goto out;
+				(void)memset(t, 'x', b_length);
+				t[b_length] = 0;
+
+				/* Get printf to calculate the lengths */
+				*fmt = 's';
+				APF(&a, start, t);
+				if (error == -1)
+					goto out;
+				b_fmt = a;
+
+				/* Output leading spaces and data bytes */
+				conv_escape_str(cp, b_output, 1);
+
+				/* Add any trailing spaces */
+				printf("%s", b_fmt);
+				break;
+			}
+			case 'c': {
+				char p = getchr();
+
+				PF(start, p);
+				if (error < 0)
+					goto out;
+				break;
+			}
+			case 's': {
+				char *p = getstr();
+
+				PF(start, p);
+				if (error < 0)
+					goto out;
+				break;
+			}
+			case 'd':
+			case 'i': {
+				intmax_t p = getintmax();
+				char *f = mklong(start, ch);
+
+				PF(f, p);
+				if (error < 0)
+					goto out;
+				break;
+			}
+			case 'o':
+			case 'u':
+			case 'x':
+			case 'X': {
+				uintmax_t p = (uintmax_t)getintmax();
+				char *f = mklong(start, ch);
+
+				PF(f, p);
+				if (error < 0)
+					goto out;
+				break;
+			}
+			case 'a':
+			case 'A':
+			case 'e':
+			case 'E':
+			case 'f':
+			case 'F':
+			case 'g':
+			case 'G': {
+				double p = getdouble();
+
+				PF(start, p);
+				if (error < 0)
+					goto out;
+				break;
+			}
+			case '%':
+				/* Don't ask, but this is useful ... */
+				if (fieldwidth == 'N' && precision == 'B')
+					return 0;
+				/* FALLTHROUGH */
+			default:
+				warnx("%s: invalid directive", start);
+				return 1;
+			}
+			*fmt++ = ch;
+			*fmt = nextch;
+			/* escape if a \c was encountered */
+			if (rval & 0x100)
+				goto done;
+		}
+	} while (gargv != argv && *gargv);
+
+  done:
+	(void)fflush(stdout);
+	if (ferror(stdout)) {
+		clearerr(stdout);
+		err(1, "write error");
+	}
+	return rval & ~0x100;
+  out:
+	warn("print failed");
+	return 1;
+}
+
+/* helper functions for conv_escape_str */
+
+static void
+/*ARGSUSED*/
+b_count(int ch)
+{
+	b_length++;
+}
+
+/* Output one converted character for every 'x' in the 'format' */
+
+static void
+b_output(int ch)
+{
+	for (;;) {
+		switch (*b_fmt++) {
+		case 0:
+			b_fmt--;
+			return;
+		case ' ':
+			putchar(' ');
+			break;
+		default:
+			putchar(ch);
+			return;
+		}
+	}
+}
+
+
+/*
+ * Print SysV echo(1) style escape string
+ *	Halts processing string if a \c escape is encountered.
+ */
+static void
+conv_escape_str(char *str, void (*do_putchar)(int), int quiet)
+{
+	int value;
+	int ch;
+	char c;
+
+	while ((ch = *str++) != '\0') {
+		if (ch != '\\') {
+			do_putchar(ch);
+			continue;
+		}
+
+		ch = *str++;
+		if (ch == 'c') {
+			/* \c as in SYSV echo - abort all processing.... */
+			rval |= 0x100;
+			break;
+		}
+
+		/*
+		 * %b string octal constants are not like those in C.
+		 * They start with a \0, and are followed by 0, 1, 2,
+		 * or 3 octal digits.
+		 */
+		if (ch == '0') {
+			int octnum = 0, i;
+			for (i = 0; i < 3; i++) {
+				if (!isdigit((unsigned char)*str) || *str > '7')
+					break;
+				octnum = (octnum << 3) | (*str++ - '0');
+			}
+			do_putchar(octnum);
+			continue;
+		}
+
+		/* \[M][^|-]C as defined by vis(3) */
+		if (ch == 'M' && *str == '-') {
+			do_putchar(0200 | str[1]);
+			str += 2;
+			continue;
+		}
+		if (ch == 'M' && *str == '^') {
+			str++;
+			value = 0200;
+			ch = '^';
+		} else
+			value = 0;
+		if (ch == '^') {
+			ch = *str++;
+			if (ch == '?')
+				value |= 0177;
+			else
+				value |= ch & 037;
+			do_putchar(value);
+			continue;
+		}
+
+		/* Finally test for sequences valid in the format string */
+		str = conv_escape(str - 1, &c, quiet);
+		do_putchar(c);
+	}
+}
+
+/*
+ * Print "standard" escape characters
+ */
+static char *
+conv_escape(char *str, char *conv_ch, int quiet)
+{
+	int value = 0;
+	char ch, *begin;
+	int c;
+
+	ch = *str++;
+
+	switch (ch) {
+	case '\0':
+		if (!quiet)
+			warnx("incomplete escape sequence");
+		rval = 1;
+		value = '\\';
+		--str;
+		break;
+
+	case '0': case '1': case '2': case '3':
+	case '4': case '5': case '6': case '7':
+		str--;
+		for (c = 3; c-- && isodigit(*str); str++) {
+			value <<= 3;
+			value += octtobin(*str);
+		}
+		break;
+
+	case 'x':
+		/*
+		 * Hexadecimal character constants are not required to be
+		 * supported (by SuS v1) because there is no consistent
+		 * way to detect the end of the constant.
+		 * Supporting 2 byte constants is a compromise.
+		 */
+		begin = str;
+		for (c = 2; c-- && isxdigit((unsigned char)*str); str++) {
+			value <<= 4;
+			value += hextobin(*str);
+		}
+		if (str == begin) {
+			if (!quiet)
+				warnx("\\x%s: missing hexadecimal number "
+				    "in escape", begin);
+			rval = 1;
+		}
+		break;
+
+	case '\\':	value = '\\';	break;	/* backslash */
+	case '\'':	value = '\'';	break;	/* single quote */
+	case '"':	value = '"';	break;	/* double quote */
+	case 'a':	value = '\a';	break;	/* alert */
+	case 'b':	value = '\b';	break;	/* backspace */
+	case 'e':	value = ESCAPE;	break;	/* escape */
+	case 'E':	value = ESCAPE;	break;	/* escape */
+	case 'f':	value = '\f';	break;	/* form-feed */
+	case 'n':	value = '\n';	break;	/* newline */
+	case 'r':	value = '\r';	break;	/* carriage-return */
+	case 't':	value = '\t';	break;	/* tab */
+	case 'v':	value = '\v';	break;	/* vertical-tab */
+
+	default:
+		if (!quiet)
+			warnx("unknown escape sequence `\\%c'", ch);
+		rval = 1;
+		value = ch;
+		break;
+	}
+
+	*conv_ch = (char)value;
+	return str;
+}
+
+/* expand a string so that everything is printable */
+
+static char *
+conv_expand(const char *str)
+{
+	static char *conv_str;
+	char *cp;
+	char ch;
+
+	if (conv_str)
+		free(conv_str);
+	/* get a buffer that is definitely large enough.... */
+	conv_str = malloc(4 * strlen(str) + 1);
+	if (!conv_str)
+		return NULL;
+	cp = conv_str;
+
+	while ((ch = *(const char *)str++) != '\0') {
+		switch (ch) {
+		/* Use C escapes for expected control characters */
+		case '\\':	ch = '\\';	break;	/* backslash */
+		case '\'':	ch = '\'';	break;	/* single quote */
+		case '"':	ch = '"';	break;	/* double quote */
+		case '\a':	ch = 'a';	break;	/* alert */
+		case '\b':	ch = 'b';	break;	/* backspace */
+		case ESCAPE:	ch = 'e';	break;	/* escape */
+		case '\f':	ch = 'f';	break;	/* form-feed */
+		case '\n':	ch = 'n';	break;	/* newline */
+		case '\r':	ch = 'r';	break;	/* carriage-return */
+		case '\t':	ch = 't';	break;	/* tab */
+		case '\v':	ch = 'v';	break;	/* vertical-tab */
+		default:
+			/* Copy anything printable */
+			if (isprint((unsigned char)ch)) {
+				*cp++ = ch;
+				continue;
+			}
+			/* Use vis(3) encodings for the rest */
+			*cp++ = '\\';
+			if (ch & 0200) {
+				*cp++ = 'M';
+				ch &= (char)~0200;
+			}
+			if (ch == 0177) {
+				*cp++ = '^';
+				*cp++ = '?';
+				continue;
+			}
+			if (ch < 040) {
+				*cp++ = '^';
+				*cp++ = ch | 0100;
+				continue;
+			}
+			*cp++ = '-';
+			*cp++ = ch;
+			continue;
+		}
+		*cp++ = '\\';
+		*cp++ = ch;
+	}
+
+	*cp = 0;
+	return conv_str;
+}
+
+static char *
+mklong(const char *str, char ch)
+{
+	static char copy[64];
+	size_t len;	
+
+	len = strlen(str) + 2;
+	if (len > sizeof copy) {
+		warnx("format \"%s\" too complex", str);
+		len = 4;
+		rval = 1;
+	}
+	(void)memmove(copy, str, len - 3);
+	copy[len - 3] = 'j';
+	copy[len - 2] = ch;
+	copy[len - 1] = '\0';
+	return copy;	
+}
+
+static char
+getchr(void)
+{
+	if (!*gargv)
+		return 0;
+	return **gargv++;
+}
+
+static char *
+getstr(void)
+{
+	static char empty[] = "";
+	if (!*gargv)
+		return empty;
+	return *gargv++;
+}
+
+static int
+getwidth(void)
+{
+	unsigned long val;
+	char *s, *ep;
+
+	s = *gargv;
+	if (s == NULL)
+		return 0;
+	gargv++;
+
+	errno = 0;
+	val = strtoul(s, &ep, 0);
+	check_conversion(s, ep);
+
+	/* Arbitrarily 'restrict' field widths to 1Mbyte */
+	if (val > 1 << 20) {
+		warnx("%s: invalid field width", s);
+		return 0;
+	}
+
+	return (int)val;
+}
+
+static intmax_t
+getintmax(void)
+{
+	intmax_t val;
+	char *cp, *ep;
+
+	cp = *gargv;
+	if (cp == NULL)
+		return 0;
+	gargv++;
+
+	if (*cp == '\"' || *cp == '\'')
+		return wide_char(cp);
+
+	errno = 0;
+	val = strtoimax(cp, &ep, 0);
+	check_conversion(cp, ep);
+	return val;
+}
+
+static double
+getdouble(void)
+{
+	double val;
+	char *ep;
+
+	if (!*gargv)
+		return 0.0;
+
+	/* This is a NetBSD extension, not required by POSIX (it is useless) */
+	if (*(ep = *gargv) == '\"' || *ep == '\'')
+		return (double)wide_char(ep);
+
+	errno = 0;
+	val = strtod(*gargv, &ep);
+	check_conversion(*gargv++, ep);
+	return val;
+}
+
+/*
+ * XXX This is just a placeholder for a later version which
+ *     will do mbtowc() on p+1 (and after checking that all of the
+ *     string has been consumed) return that value.
+ *
+ * This (mbtowc) behaviour is required by POSIX (as is the check
+ * that the whole arg is consumed).
+ *
+ * What follows is actually correct if we assume that LC_CTYPE=C
+ * (or something else similar that is a single byte charset).
+ */
+static intmax_t
+wide_char(const char *p)
+{
+	intmax_t ch = (intmax_t)(unsigned char)p[1];
+
+	if (ch != 0 && p[2] != '\0') {
+		warnx("%s: not completely converted", p);
+		rval = 1;
+	}
+
+	return ch;
+}
+
+static void
+check_conversion(const char *s, const char *ep)
+{
+	if (*ep) {
+		if (ep == s)
+			warnx("%s: expected numeric value", s);
+		else
+			warnx("%s: not completely converted", s);
+		rval = 1;
+	} else if (errno == ERANGE) {
+		warnx("%s: %s", s, strerror(ERANGE));
+		rval = 1;
+	}
+}
+
+static void
+usage(void)
+{
+	(void)fprintf(stderr, "Usage: %s format [arg ...]\n", getprogname());
+}
diff -urN csh.orig/set.c csh/set.c
--- csh.orig/set.c	2021-08-15 12:16:02.000000000 +0000
+++ csh/set.c	2022-09-04 21:10:29.168105000 +0000
@@ -158,7 +158,9 @@
 	el_set(el, EL_EDITOR, *vn ? short2str(vn) : "emacs");
 	el_set(el, EL_PROMPT, printpromptstr);
 	el_set(el, EL_ALIAS_TEXT, alias_text, NULL);
+#ifdef EL_SAFEREAD
 	el_set(el, EL_SAFEREAD, 1);
+#endif
 	el_set(el, EL_ADDFN, "rl-complete",
 	    "ReadLine compatible completion function", _el_fn_complete);
 	el_set(el, EL_BIND, "^I", adrof(STRfilec) ? "rl-complete" : "ed-insert",
diff -urN csh.orig/str.c csh/str.c
--- csh.orig/str.c	2019-01-05 16:54:00.000000000 +0000
+++ csh/str.c	2022-09-04 21:28:24.954076000 +0000
@@ -55,6 +55,8 @@
 
 #ifdef SHORT_STRINGS
 
+#define __UNCONST(s)	__DECONST(Char *, s)
+
 Char **
 blk2short(char **src)
 {
diff -urN csh.orig/strpct.c csh/strpct.c
--- csh.orig/strpct.c	1970-01-01 00:00:00.000000000 +0000
+++ csh/strpct.c	2022-09-04 21:31:45.256049000 +0000
@@ -0,0 +1,131 @@
+/* $NetBSD: strpct.c,v 1.3 2012/01/07 18:40:56 christos Exp $ */
+
+/*-
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Erik E. Fair
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
+ */
+
+/*
+ * Calculate a percentage without resorting to floating point
+ * and return a pointer to a string
+ *
+ * "digits" is the number of digits past the decimal place you want
+ * (zero being the straight percentage with no decimals)
+ *
+ * Erik E. Fair <fair%clock.org@localhost>, May 8, 1997
+ */
+
+#include <sys/cdefs.h>
+__RCSID("$NetBSD: strpct.c,v 1.3 2012/01/07 18:40:56 christos Exp $");
+
+#include <stdint.h>
+#include <locale.h>
+#include <limits.h>
+#include <stdio.h>
+#include <errno.h>
+#ifdef __NetBSD__
+#include <util.h>
+#else
+#include "strpct.h"
+#endif
+
+char *
+strspct(char *buf, size_t bufsiz, intmax_t numerator, intmax_t denominator,
+    size_t digits)
+{
+	int sign;
+
+	switch (bufsiz) {
+	case 1:
+		*buf = '\0';
+		/*FALLTHROUGH*/
+	case 0:
+		return buf;
+	default:
+		break;
+	}
+
+	if (denominator < 0) {
+		denominator = -denominator;
+		sign = 1;
+	} else
+		sign = 0;
+
+	if (numerator < 0) {
+		numerator = -numerator;
+		sign++;
+	}
+
+	sign &= 1;
+	(void)strpct(buf + sign, bufsiz - sign, (uintmax_t)numerator,
+	    (uintmax_t)denominator, digits);
+	if (sign)
+		*buf = '-';
+	return buf;
+}
+
+char *
+strpct(char *buf, size_t bufsiz, uintmax_t numerator, uintmax_t denominator,
+    size_t digits)
+{
+	uintmax_t factor, result;
+	size_t u;
+
+	factor = 100;
+	for (u = 0; u < digits; u++) {
+		/* watch out for overflow! */
+		if (factor < (UINTMAX_MAX / 10))
+			factor *= 10;
+		else
+			break;
+	}
+
+	/* watch out for overflow! */
+	if (numerator < (UINTMAX_MAX / factor))
+		numerator *= factor;
+	else {
+		/* toss some of the bits of lesser significance */
+		denominator /= factor;
+	}
+
+	if (denominator == 0)
+		denominator = 1;
+
+	result = numerator / denominator;
+
+	if (digits == 0)
+		(void)snprintf(buf, bufsiz, "%ju", result);
+	else {
+		factor /= 100;		/* undo initialization */
+
+		(void)snprintf(buf, bufsiz, "%ju%s%0*ju",
+		    result / factor, localeconv()->decimal_point, (int)u,
+		    result % factor);
+	}       
+
+	return buf;
+}
diff -urN csh.orig/strpct.h csh/strpct.h
--- csh.orig/strpct.h	1970-01-01 00:00:00.000000000 +0000
+++ csh/strpct.h	2022-09-04 21:33:24.594190000 +0000
@@ -0,0 +1,2 @@
+char * strpct(char *buf, size_t bufsiz, uintmax_t numerator, uintmax_t denominator, size_t precision);
+char * strspct(char *buf, size_t bufsiz, intmax_t numerator, intmax_t denominator, size_t precision);
diff -urN csh.orig/time.c csh/time.c
--- csh.orig/time.c	2020-10-17 08:46:02.000000000 +0000
+++ csh/time.c	2022-09-04 21:32:40.816078000 +0000
@@ -44,7 +44,11 @@
 #include "csh.h"
 #include "extern.h"
 #endif
+#ifdef __NetBSD__
 #include <util.h>
+#else
+#include "strpct.h"
+#endif
 
 /*
  * C Shell - routines handling process timing and niceing