Fix legacy C. Pass -Wall -W -Wmissing-declarations -Wwrite-strings on

gcc45. - avoid implicit int, declare void functions void - return values from non-void functions - put most external declarations properly in header files - use some static and const - fix up a big mess with function pointer casting - use standard includes, don't provide own decls of standard functions - use types matching libc when providing own malloc, printf, and putchar - use <ctype.h> functions correctly - silence assorted compiler warnings - fix some bugs exposed by compiler warnings - don't intentionally exercise signed overflow - remove some unused items - add patch comments to other patch (patch-aa) As this includes several fixes and removes some undefined behavior on a commonly reachable code path, bump PKGREVISION.
author: dholland <dholland> 2012-12-28 03:03:08 +0000
committer: dholland <dholland> 2012-12-28 03:03:08 +0000
commit: 07b24342c151565b853024240776c2856aee34ef (patch)
tree: 8c0484149657a50a301fa0bcb9d58f2f596c8985 /editors
parent: ad2c90a7d99400d4797dcba661d63a6ce9a6a683 (diff)
download: pkgsrc-07b24342c151565b853024240776c2856aee34ef.tar.gz
43 files changed, 7800 insertions, 37 deletions
diff --git a/editors/ex/Makefile b/editors/ex/Makefile
index be13dd77c5b..51daa8b67f8 100644
--- a/editors/ex/Makefile
+++ b/editors/ex/Makefile
@@ -1,9 +1,9 @@
-# $NetBSD: Makefile,v 1.10 2012/10/03 11:43:33 asau Exp $
+# $NetBSD: Makefile,v 1.11 2012/12/28 03:03:08 dholland Exp $
 #
 
 DISTNAME=	ex-040103
 PKGNAME=	ex-20040103
-PKGREVISION=	2
+PKGREVISION=	3
 CATEGORIES=	editors
 MASTER_SITES=	${MASTER_SITE_SOURCEFORGE:=ex-vi/files/ex-vi/040103/}
 
@@ -12,6 +12,12 @@ HOMEPAGE=	http://ex-vi.sourceforge.net/
 COMMENT=	Berkeley vi 3.7
 LICENSE=	original-bsd
 
+SUBST_CLASSES+=		getline
+SUBST_STAGE.getline=	post-extract
+SUBST_MESSAGE.getline=	Changing 'getline' to 'get_line'
+SUBST_FILES.getline=	ex*.c ex_proto.h
+SUBST_SED.getline=	-e "s,getline,get_line,g"
+
 MAKE_DIRS_PERMS+=	${VARBASE}/tmp/vi.recover ${REAL_ROOT_USER} ${REAL_ROOT_GROUP} 1777
 
 .include "../../mk/curses.buildlink3.mk"
diff --git a/editors/ex/distinfo b/editors/ex/distinfo
index 666602b364f..de3a716062b 100644
--- a/editors/ex/distinfo
+++ b/editors/ex/distinfo
@@ -1,10 +1,46 @@
-$NetBSD: distinfo,v 1.14 2011/08/01 05:47:40 dholland Exp $
+$NetBSD: distinfo,v 1.15 2012/12/28 03:03:08 dholland Exp $
 
 SHA1 (ex-040103.tar.gz) = 51fa1d613b37a4f3aed1ef2968be691465cdff09
 RMD160 (ex-040103.tar.gz) = 5fc3f222dde5a8d00e1b233281ccf210affdbdf1
 Size (ex-040103.tar.gz) = 284130 bytes
-SHA1 (patch-aa) = 8902846a518fbf214725a801293610ebe12c143b
-SHA1 (patch-ab) = 5bac9911e71b7fe787023568a7a46d1e87fb4d0e
-SHA1 (patch-ac) = 0401448724a4aba59b4aeb07a4cb00982bb52d98
-SHA1 (patch-ad) = 31bafb04f553ca286baf90505da450964fea9954
-SHA1 (patch-exrecover_c) = f5fd1bff1f1e8229170415081815531d86e482da
+SHA1 (patch-aa) = a8b9fd02ec7e576ea1bbf239cbd34bf7bae7c4a8
+SHA1 (patch-ab) = 1b75764cb5ef0873a307874bb94dd9d4e7e74290
+SHA1 (patch-ac) = a849730017d13a60686cdca81c9c74a55cd29b53
+SHA1 (patch-ad) = 497407efc9b2afc397a735abc6234bed8ece97ae
+SHA1 (patch-ex__addr_c) = 61d9851b746fe90b2f413dd42b09659fda13ffdb
+SHA1 (patch-ex__argv_h) = e121a95b2dd50ed5778af43df716913758d643d5
+SHA1 (patch-ex__cmds2_c) = 9856d947c0be80a3f597c7b16ec28ac729880668
+SHA1 (patch-ex__cmds_c) = 730252b283392a944f3b95c43182ed178a459ddd
+SHA1 (patch-ex__cmdsub_c) = d76d0e0d2748c30f1541a95fe194b3cf70a670fa
+SHA1 (patch-ex__get_c) = 19f439eaa2ab68755fb2f1b9e38bd6b2bfff6466
+SHA1 (patch-ex__io_c) = cc490141c0eaf6c172d36eccb403e21f762052f7
+SHA1 (patch-ex__proto_h) = ecd701f056e9ab78fd47d07b997e80e32e1e47fe
+SHA1 (patch-ex__put_c) = c3f8dddff3919b745f460aead3bc2dfda8b30083
+SHA1 (patch-ex__re_c) = fde8ef4a089ffc64980fde00a320ff906f7f4ee2
+SHA1 (patch-ex__set_c) = fa59569a6fa00649a01c2f399ec17f1e3d9e2de9
+SHA1 (patch-ex__subr_c) = 2c7291aa9988644c8eb7fa62778497743dd96d14
+SHA1 (patch-ex__tagio_c) = 83227d9ff2e88e55e06d3c8db94e106a25d2e00a
+SHA1 (patch-ex__temp_c) = 1b45c4f02d6ad0ff90f814e8e9c18e2ec739ec15
+SHA1 (patch-ex__tty_c) = 65d2ea5b01f6049419a00ece6664a86d9044fafc
+SHA1 (patch-ex__tty_h) = 64d7a196f499d3eedb7330a904e192e67d83cf3a
+SHA1 (patch-ex__unix_c) = f52c637a52987191404befd262e3717472995d91
+SHA1 (patch-ex__v_c) = 1af23e5f70f92e0269a740fcef665b45e1a0b461
+SHA1 (patch-ex__vadj_c) = 4de4dae1865d61a56da756493e8c098eff05039c
+SHA1 (patch-ex__version_c) = ddc81149794020a151435c1571817ad2315c305f
+SHA1 (patch-ex__vget_c) = 6b28e0fd02b6c6304a7996da9825e397a4f7635a
+SHA1 (patch-ex__vis_h) = be29bf377a0badf691ad3b65f8fedef73d67de4d
+SHA1 (patch-ex__vmain_c) = 52822b649d88acf16899ba1beb4559a3534b489d
+SHA1 (patch-ex__voper_c) = 2f0a55d21466f581ce4089986632339a67795633
+SHA1 (patch-ex__vops2_c) = cea13dde0335b81507f87838137e3360fe545d60
+SHA1 (patch-ex__vops3_c) = d2bab4f54f3bf8d7fa9b5cc44a8a5210dfdba87a
+SHA1 (patch-ex__vops_c) = f7c15746a93544ed058ab4af6a389049b74a99a8
+SHA1 (patch-ex__vput_c) = fa0216eb004ae58a297c3f00a610d689c978f273
+SHA1 (patch-ex__vwind_c) = 9ed05094167870f5eb9af28deb39318aa69cf832
+SHA1 (patch-ex_c) = c0c5d5d5fd45da46e2594101a7a3d4350c49ae05
+SHA1 (patch-expreserve_c) = 2c94b4eefa3e72c6abc4aaa2f54750557705c794
+SHA1 (patch-exrecover_c) = 8742a5ba155996632971891cdd4a24b4d97d4376
+SHA1 (patch-libterm_libterm_h) = 2f552d89726baf1d8b2c3be15ef386db7dffe04d
+SHA1 (patch-libterm_termcap_c) = cbc3ece52b9bbfd286be7953d9cb3bcf6e460b0e
+SHA1 (patch-libterm_tgoto_c) = d4299bdd468f0fff4d0fbbb67f37b8080a334787
+SHA1 (patch-libterm_tputs_c) = a305e0ccc35aafe30b3b061bb47964b0ae845e9a
+SHA1 (patch-printf_c) = 4a64b79fd7d3f1c6271d238cc3b71f02f43537d0
diff --git a/editors/ex/patches/patch-aa b/editors/ex/patches/patch-aa
index e8423752b27..bc3158a28b8 100644
--- a/editors/ex/patches/patch-aa
+++ b/editors/ex/patches/patch-aa
@@ -1,4 +1,9 @@
-$NetBSD: patch-aa,v 1.7 2010/01/31 21:24:04 joerg Exp $
+$NetBSD: patch-aa,v 1.8 2012/12/28 03:03:08 dholland Exp $
+
+- configure paths and programs for pkgsrc
+- don't install the executable sticky as that's often no longer allowed
+- don't create the PRESERVEDIR at install time
+  (the pkgsrc makefile takes care of it)
 
 --- Makefile.orig	2004-01-03 14:22:47.000000000 +0000
 +++ Makefile
diff --git a/editors/ex/patches/patch-ab b/editors/ex/patches/patch-ab
index 4cb692d3ef6..e110c484bfe 100644
--- a/editors/ex/patches/patch-ab
+++ b/editors/ex/patches/patch-ab
@@ -1,6 +1,11 @@
-$NetBSD: patch-ab,v 1.1 2005/10/31 20:04:46 tv Exp $
+$NetBSD: patch-ab,v 1.2 2012/12/28 03:03:08 dholland Exp $
 
---- malloc.c.orig	2002-03-02 07:15:03.000000000 -0500
+- use standard headers
+  (these functions are supposed to substitute for the libc ones, so they
+  need to match stdlib.h exactly)
+- declare void functions void
+
+--- malloc.c.orig	2002-03-02 12:15:03.000000000 +0000
 +++ malloc.c
 @@ -45,6 +45,7 @@
  #include <sys/types.h>
@@ -10,3 +15,19 @@ $NetBSD: patch-ab,v 1.1 2005/10/31 20:04:46 tv Exp $
  #else	/* !POSIX_1 */
  #include <sys/types.h>
  extern int errno;
+@@ -235,6 +236,7 @@ found:
+ 
+ /*	freeing strategy tuned for LIFO allocation
+ */
++void
+ free(ap)
+ register char *ap;
+ {
+@@ -331,6 +333,7 @@ size_t num, size;
+ }
+ 
+ /*ARGSUSED*/
++void
+ cfree(p, num, size)
+ char *p;
+ size_t num, size;
diff --git a/editors/ex/patches/patch-ac b/editors/ex/patches/patch-ac
index 1434c62a7d0..64139b817a8 100644
--- a/editors/ex/patches/patch-ac
+++ b/editors/ex/patches/patch-ac
@@ -1,26 +1,166 @@
-$NetBSD: patch-ac,v 1.4 2006/07/22 04:23:29 minskim Exp $
+$NetBSD: patch-ac,v 1.5 2012/12/28 03:03:08 dholland Exp $
 
---- mapmalloc.c.orig	2003-01-28 12:04:25.000000000 -0800
+- use standard headers
+  (these functions are supposed to substitute for the libc ones, so they
+  need to match stdlib.h exactly)
+- use own headers
+- declare void functions void
+- fix return and argument types
+
+--- mapmalloc.c.orig	2003-01-28 20:04:25.000000000 +0000
 +++ mapmalloc.c
-@@ -54,6 +54,9 @@
+@@ -54,18 +54,12 @@
  #include <fcntl.h>
  #include <errno.h>
  #include <limits.h>
-+#if defined(__INTERIX)
+-#ifdef	__GLIBC__
+-/*
+- * Broken GNU libc will include stdlib.h with conflicting
+- * malloc() types otherwise.
+- */
+-#ifndef	__NO_STRING_INLINES
+-#define	__NO_STRING_INLINES
+-#endif	/* !__NO_STRING_INLINES */
+-#endif	/* __GLIBC__ */
 +#include <stdlib.h>
-+#endif
- #ifdef	__GLIBC__
+ #include <string.h>
+ 
+ #include "config.h"
++#include "ex.h"
++#include "ex_proto.h"
+ 
+ #ifdef	LANGMSG
+ #include <nl_types.h>
+@@ -176,8 +170,6 @@ static MM	*mm_global = NULL;
+ static int	zerofd = -1;
+ #endif
+ 
+-extern int	error __P((char *, ...));
+-
  /*
-  * Broken GNU libc will include stdlib.h with conflicting
-@@ -551,7 +554,11 @@ size_t alignment, size;
+  * Determine memory page size of OS
+  */
+@@ -308,7 +300,7 @@ mm_create(MM *mmPrev, size_t usize)
+  * and/or next chunk when possible to form larger chunks out of
+  * smaller ones.
+  */
+-static
++static void
+ mm_insert_chunk(MM *mm, mem_chunk *mcInsert)
+ {
+ 	mem_chunk *mc;
+@@ -429,7 +421,7 @@ mm_retrieve_chunk(MM *mm, size_t size)
+ /*
+  * Allocate a chunk of memory
+  */
+-char *
++void *
+ malloc(size_t usize)
+ {
+ 	MM *mm;
+@@ -469,10 +461,12 @@ nextpool:
+ /*
+  * Free a chunk of memory
+  */
+-free(char *ptr)
++void
++free(void *ptrV)
+ {
+ 	MM *mm;
+ 	mem_chunk *mc;
++	char *ptr = ptrV;
+ 
+ 	if (mm_global == NULL || ptr == NULL)
+ 		return;
+@@ -494,12 +488,13 @@ free(char *ptr)
+ /*
+  * Reallocate a chunk of memory
+  */
+-char *
+-realloc(char *ptr, size_t usize)
++void *
++realloc(void *ptrV, size_t usize)
+ {
+ 	size_t size;
+ 	mem_chunk *mc;
+ 	char *vp;
++	char *ptr = ptrV;
+ 
+ 	if (ptr == NULL)
+ 		return malloc(usize);	/* POSIX.1 semantics */
+@@ -523,7 +518,7 @@ realloc(char *ptr, size_t usize)
+ /*
+  * Allocate and initialize a chunk of memory
+  */
+-char *
++void *
+ calloc(size_t number, size_t usize)
+ {
+ 	char *vp;
+@@ -534,38 +529,55 @@ calloc(size_t number, size_t usize)
+ 	return vp;
  }
  
++#ifndef __NetBSD__ /* signature does not agree with netbsd's libcompat */
  /*ARGSUSED*/
-+#if defined(__DragonFly__) || defined(__APPLE__)
-+void *
-+#else
- char *
+-cfree(p, num, size)
++void cfree(p, num, size)
+ char *p;
+ size_t num, size;
+ {
+ 	free(p);
+ }
 +#endif
++
++
++/*
++ * Not all systems have the following in libc, so avoid compiler warnings
++ * by inserting extra global declarations.
++ */
++char *memalign(size_t alignment, size_t size);
++void *valloc(size_t size);
++char *mallinfo(void);
++int mallopt(void);
++char *poolsbrk(intptr_t val);
++
+ 
+ /*ARGSUSED*/
+ char *
+ memalign(alignment, size)
+ size_t alignment, size;
+ {
++	(void)alignment;
++	(void)size;
+ 	return NULL;
+ }
+ 
+ /*ARGSUSED*/
+-char *
++void *
  valloc(size)
  size_t size;
  {
++	(void)size;
+ 	return NULL;
+ }
+ 
+ char *
+-mallinfo()
++mallinfo(void)
+ {
+ 	return NULL;
+ }
+ 
+ int
+-mallopt()
++mallopt(void)
+ {
+ 	return -1;
+ }
+@@ -574,5 +586,6 @@ mallopt()
+ char *
+ poolsbrk(intptr_t val)
+ {
++	(void)val;
+ 	return NULL;
+ }
diff --git a/editors/ex/patches/patch-ad b/editors/ex/patches/patch-ad
index fbecc97e450..b476d4b8b91 100644
--- a/editors/ex/patches/patch-ad
+++ b/editors/ex/patches/patch-ad
@@ -1,8 +1,76 @@
-$NetBSD: patch-ad,v 1.1 2006/06/08 16:15:47 minskim Exp $
+$NetBSD: patch-ad,v 1.2 2012/12/28 03:03:08 dholland Exp $
 
---- ex.h.orig	2003-03-18 20:29:07.000000000 +0000
+- teach it about dead functions
+- use const for string constants
+- use speed_t for tty speed
+- don't declare versionstring, which is static in ex_version.c
+- fix up function pointer casting mess
+
+--- ex.h.orig	2012-12-27 21:58:42.000000000 +0000
 +++ ex.h
-@@ -549,7 +549,6 @@ extern	int	tfile;		/* Temporary file uni
+@@ -238,6 +238,15 @@ typedef	int	woid;
+ #endif	/* !__STDC__ */
+ 
+ /*
++ * nonreturning functions
++ */
++#if defined(__GNUC__) || defined(__CLANG__)
++#define dead __attribute__((__noreturn__))
++#else
++#define dead
++#endif
++
++/*
+  * Use reliable POSIX.1 signals if available.
+  */
+ #ifdef	POSIX_1
+@@ -401,8 +410,8 @@ typedef	jmp_buf		JMP_BUF;
+  * ex_data.c... see the shell script "makeoptions".
+  */
+ struct	option {
+-	char	*oname;
+-	char	*oabbrev;
++	const char	*oname;
++	const char	*oabbrev;
+ 	short	otype;		/* Types -- see below */
+ 	short	odefault;	/* Default value */
+ 	short	ovalue;		/* Current value */
+@@ -483,7 +492,7 @@ var	bool	aiflag;		/* Append/change/inser
+ var	bool	anymarks;	/* We have used '[a-z] */
+ var	int	bsize;		/* Block size for disk i/o */
+ var	int	chng;		/* Warn "No write" */
+-var	char	*Command;
++var	const char *Command;
+ var	short	defwind;	/* -w# change default window size */
+ var	int	dirtcnt;	/* When >= MAXDIRT, should sync temporary */
+ #ifdef	TIOCLGET
+@@ -504,11 +513,11 @@ var	char	file[FNSIZE];	/* Working file n
+ var	bool	fixedzero;	/* zero file size was fixed (for visual) */
+ var	char	genbuf[MAXBSIZE]; /* Working buffer when manipulating linebuf */
+ var	bool	hush;		/* Command line option - was given, hush up! */
+-var	char	*globp;		/* (Untyped) input string to command mode */
++var	const char *globp;	/* (Untyped) input string to command mode */
+ var	bool	holdcm;		/* Don't cursor address */
+ var	bool	inappend;	/* in ex command append mode */
+ var	bool	inglobal;	/* Inside g//... or v//... */
+-var	char	*initev;	/* Initial : escape for visual */
++var	const char *initev;	/* Initial : escape for visual */
+ var	bool	inopen;		/* Inside open or visual */
+ var	char	*input;		/* Current position in cmd line input buffer */
+ var	bool	intty;		/* Input is a tty */
+@@ -530,7 +539,11 @@ var	shand	oldquit;	/* Previous SIGQUIT h
+ var	shand	oldxfsz;	/* Previous SIGXFSZ handler */
+ #endif
+ var	short	oprompt;	/* Saved during source */
++#ifdef POSIX_1
++extern	speed_t	ospeed;		/* Output speed (from gtty) */
++#else
+ extern	short	ospeed;		/* Output speed (from gtty) */
++#endif
+ var	int	otchng;		/* Backup tchng to find changes in macros */
+ var	short	peekc;		/* Peek ahead character (cmd mode input) */
+ var	char	*pkill[2];	/* Trim for put with ragged (LISP) delete */
+@@ -549,7 +562,6 @@ extern	int	tfile;		/* Temporary file uni
  var	bool	tflag;		/* -t option given on command line */
  var	bool	vcatch;		/* Want to catch an error (open/visual) */
  var	bool	verbose;	/* -V option; print command input to stderr */
@@ -10,3 +78,24 @@ $NetBSD: patch-ad,v 1.1 2006/06/08 16:15:47 minskim Exp $
  var	JMP_BUF	vreslab;	/* For error throws to a visual catch */
  var	bool	writing;	/* 1 if in middle of a file write */
  var	int	xchng;		/* Suppresses multiple "No writes" in !cmd */
+@@ -639,9 +651,9 @@ var	line	*undadot;	/* If we saved all li
+ #define	UNDNONE		3
+ #define	UNDPUT		4
+ 
+-extern	int	(*Outchar)();
+-extern	int	(*Pline)();
+-extern	int	(*Putchar)();
++extern	int	(*Outchar)(int);
++extern	int	(*Pline)(int);
++extern	int	(*Putchar)(int);
+ 
+ #define	NOSTR	(char *) 0
+ #define	NOLINE	(line *) 0
+@@ -663,6 +675,6 @@ var	nl_catd	catd;
+ #else	/* !LANGMSG */
+ #define	catgets(a, b, c, d)	(d)
+ #endif	/* !LANGMSG */
+-var	char	*cntrlhm;
++var	const char	*cntrlhm;
+ 
+ #include "ex_proto.h"
diff --git a/editors/ex/patches/patch-ex__addr_c b/editors/ex/patches/patch-ex__addr_c
new file mode 100644
index 00000000000..c482d705b3e
--- /dev/null
+++ b/editors/ex/patches/patch-ex__addr_c
@@ -0,0 +1,71 @@
+$NetBSD: patch-ex__addr_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- declare void functions void
+- avoid implicit int
+
+--- ex_addr.c~	2002-02-02 02:08:35.000000000 +0000
++++ ex_addr.c
+@@ -102,6 +102,7 @@ static	bool bigmove;
+ /*
+  * Set up addr1 and addr2 for commands whose default address is dot.
+  */
++void
+ setdot()
+ {
+ 
+@@ -114,6 +115,7 @@ setdot()
+  * Call setdot1 to set up default addresses without ever
+  * setting the previous context mark.
+  */
++void
+ setdot1()
+ {
+ 
+@@ -132,6 +134,7 @@ setdot1()
+  * to delete 5 lines, etc.
+  * Such nonsense is implemented by setcount.
+  */
++void
+ setcount()
+ {
+ 	register int cnt;
+@@ -155,6 +158,7 @@ setcount()
+ /*
+  * Parse a number out of the command input stream.
+  */
++int
+ getnum()
+ {
+ 	register int cnt;
+@@ -168,6 +172,7 @@ getnum()
+  * Set the default addresses for commands which use the whole
+  * buffer as default, notably write.
+  */
++void
+ setall()
+ {
+ 
+@@ -188,6 +193,7 @@ setall()
+ /*
+  * No address allowed on, e.g. the file command.
+  */
++void
+ setnoaddr()
+ {
+ 
+@@ -377,6 +383,7 @@ error(catgets(catd, 1, 11, "No match to 
+  * Left over from squashing ex version 1.1 into
+  * 11/34's and 11/40's.
+  */
++void
+ setCNL()
+ {
+ 
+@@ -384,6 +391,7 @@ setCNL()
+ 	newline();
+ }
+ 
++void
+ setNAEOL()
+ {
+ 
diff --git a/editors/ex/patches/patch-ex__argv_h b/editors/ex/patches/patch-ex__argv_h
new file mode 100644
index 00000000000..5594d9013be
--- /dev/null
+++ b/editors/ex/patches/patch-ex__argv_h
@@ -0,0 +1,12 @@
+$NetBSD: patch-ex__argv_h,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- declare void functions void
+
+--- ex_argv.h~	2002-02-02 00:05:46.000000000 +0000
++++ ex_argv.h
+@@ -102,4 +102,4 @@ struct	glob {
+ };
+ var struct	glob frob;
+ 
+-int gglob __P((struct glob *));
++void gglob __P((struct glob *));
diff --git a/editors/ex/patches/patch-ex__cmds2_c b/editors/ex/patches/patch-ex__cmds2_c
new file mode 100644
index 00000000000..d7e1ea433b3
--- /dev/null
+++ b/editors/ex/patches/patch-ex__cmds2_c
@@ -0,0 +1,239 @@
+$NetBSD: patch-ex__cmds2_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- avoid implicit int
+- declare void functions void
+- use const for string constants
+
+--- ex_cmds2.c~	2002-02-02 02:08:35.000000000 +0000
++++ ex_cmds2.c
+@@ -95,6 +95,7 @@ extern int	poffset;		/* mjm: extern; als
+ /*
+  * Is there a single letter indicating a named buffer next?
+  */
++int
+ cmdreg()
+ {
+ 	register int c = 0;
+@@ -108,6 +109,7 @@ cmdreg()
+ /*
+  * Tell whether the character ends a command
+  */
++int
+ endcmd(ch)
+ 	int ch;
+ {
+@@ -129,6 +131,7 @@ endcmd(ch)
+ /*
+  * Insist on the end of the command.
+  */
++void
+ eol()
+ {
+ 
+@@ -144,7 +147,8 @@ eol()
+  * just fixing up the echo area for the print.
+  * Otherwise we reset a number of externals, and discard unused input.
+  */
+-error0()
++static void
++error0(void)
+ {
+ 
+ 	if (vcatch) {
+@@ -191,8 +195,8 @@ error0()
+  * Otherwise, in the normal command mode error case,
+  * finish state reset, and throw to top.
+  */
+-error1(str)
+-	char *str;
++static void
++error1(const char *str)
+ {
+ 	bool die;
+ 
+@@ -230,17 +234,18 @@ error1(str)
+  * with i an integer argument to printf.
+  */
+ /*VARARGS2*/
++void
+ #ifndef	__STDC__
+ error(str, i)
+ #ifdef lint
+-	register char *str;
++	register const char *str;
+ #else
+ 	register int str;
+ #endif
+ 	int i;
+ {
+ #else
+-error(char *str, ...)
++error(const char *str, ...)
+ {
+ 	va_list ap;
+ #endif
+@@ -265,6 +270,7 @@ error(char *str, ...)
+ /*
+  * Rewind the argument list.
+  */
++void
+ erewind()
+ {
+ 
+@@ -280,6 +286,7 @@ erewind()
+ 	}
+ }
+ 
++void
+ fixol()
+ {
+ 	if (Outchar != vputchar) {
+@@ -298,6 +305,7 @@ fixol()
+ /*
+  * Does an ! character follow in the command stream?
+  */
++int
+ exclam()
+ {
+ 
+@@ -311,6 +319,7 @@ exclam()
+ /*
+  * Make an argument list for e.g. next.
+  */
++void
+ makargs()
+ {
+ 
+@@ -324,6 +333,7 @@ makargs()
+ /*
+  * Advance to next file in argument list.
+  */
++void
+ next()
+ {
+ 	extern short isalt;	/* defined in ex_io.c */
+@@ -343,6 +353,7 @@ next()
+  * Eat trailing flags and offsets after a command,
+  * saving for possible later post-command prints.
+  */
++void
+ newline()
+ {
+ 	register int c;
+@@ -399,6 +410,7 @@ serror(catgets(catd, 1, 32,
+  * Before quit or respec of arg list, check that there are
+  * no more files in the arg list.
+  */
++void
+ nomore()
+ {
+ 
+@@ -413,6 +425,7 @@ nomore()
+  * Before edit of new file check that either an ! follows
+  * or the file has not been changed.
+  */
++int
+ quickly()
+ {
+ 
+@@ -432,6 +445,7 @@ quickly()
+ /*
+  * Reset the flavor of the output to print mode with no numbering.
+  */
++void
+ resetflav()
+ {
+ 
+@@ -448,10 +462,11 @@ resetflav()
+  * Print an error message with a %s type argument to printf.
+  * Message text comes from error message file.
+  */
++void
+ #ifndef	__STDC__
+ serror(str, cp)
+ #ifdef lint
+-	register char *str;
++	register const char *str;
+ #else
+ 	register int str;
+ #endif
+@@ -463,7 +478,7 @@ serror(str, cp)
+ 	error1(str);
+ }
+ #else	/* __STDC__ */
+-serror(char *str, ...)
++serror(const char *str, ...)
+ {
+ 	va_list ap;
+ 
+@@ -482,6 +497,7 @@ serror(char *str, ...)
+  * and either use normally decoded (ARPAnet standard) characters or list mode,
+  * where end of lines are marked and tabs print as ^I.
+  */
++void
+ setflav()
+ {
+ 
+@@ -495,6 +511,7 @@ setflav()
+ /*
+  * Skip white space and tell whether command ends then.
+  */
++int
+ skipend()
+ {
+ 
+@@ -505,6 +522,7 @@ skipend()
+ /*
+  * Set the command name for non-word commands.
+  */
++void
+ tailspec(c)
+ 	int c;
+ {
+@@ -518,15 +536,17 @@ tailspec(c)
+  * Try to read off the rest of the command word.
+  * If alphabetics follow, then this is not the command we seek.
+  */
++void
+ tail(comm)
+-	char *comm;
++	const char *comm;
+ {
+ 
+ 	tailprim(comm, 1, 0);
+ }
+ 
++void
+ tail2of(comm)
+-	char *comm;
++	const char *comm;
+ {
+ 
+ 	tailprim(comm, 2, 0);
+@@ -534,8 +554,9 @@ tail2of(comm)
+ 
+ char	tcommand[20];
+ 
++void
+ tailprim(comm, i, notinvis)
+-	register char *comm;
++	register const char *comm;
+ 	int i;
+ 	bool notinvis;
+ {
+@@ -574,6 +595,7 @@ ret:
+ /*
+  * Continue after a : command from open/visual.
+  */
++void
+ vcontin(ask)
+ 	bool ask;
+ {
+@@ -643,6 +665,7 @@ vcontin(ask)
+  * Put out a newline (before a shell escape)
+  * if in open/visual.
+  */
++void
+ vnfl()
+ {
+ 
diff --git a/editors/ex/patches/patch-ex__cmds_c b/editors/ex/patches/patch-ex__cmds_c
new file mode 100644
index 00000000000..3bae7cb4713
--- /dev/null
+++ b/editors/ex/patches/patch-ex__cmds_c
@@ -0,0 +1,42 @@
+$NetBSD: patch-ex__cmds_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- declare void functions void
+- silence warnings about && and || precedence
+- silence warnings about braces
+
+--- ex_cmds.c~	2012-12-27 20:24:51.000000000 +0000
++++ ex_cmds.c
+@@ -96,6 +96,7 @@ int	poffset;
+  * is to strip command addresses, do a little address oriented
+  * processing and call command routines to do the real work.
+  */
++void
+ commands(noprompt, exitoneof)
+ 	bool noprompt, exitoneof;
+ {
+@@ -127,7 +128,7 @@ commands(noprompt, exitoneof)
+ 		 * before the next command.
+ 		 */
+ 		if (pflag ||
+-		    lchng != chng && value(AUTOPRINT) && !inglobal && !inopen && endline) {
++		    (lchng != chng && value(AUTOPRINT) && !inglobal && !inopen && endline)) {
+ 			pflag = 0;
+ 			nochng();
+ 			if (dol != zero) {
+@@ -165,7 +166,7 @@ error(catgets(catd, 1, 17,
+ 			addr1 = addr2;
+ 			addr = address(0);
+ 			c = getcd();
+-			if (addr == 0)
++			if (addr == 0) {
+ 				if (c == ',')
+ 					addr = dot;
+ 				else if (addr1 != 0) {
+@@ -173,6 +174,7 @@ error(catgets(catd, 1, 17,
+ 					break;
+ 				} else
+ 					break;
++			}
+ 			addr2 = addr;
+ 			given++;
+ 			if (c == ';') {
diff --git a/editors/ex/patches/patch-ex__cmdsub_c b/editors/ex/patches/patch-ex__cmdsub_c
new file mode 100644
index 00000000000..d3f95ad22e2
--- /dev/null
+++ b/editors/ex/patches/patch-ex__cmdsub_c
@@ -0,0 +1,296 @@
+$NetBSD: patch-ex__cmdsub_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- declare local functions static
+- avoid implicit int
+- declare void functions void
+- silence warnings about assignments in conditionals
+- use const for string constants
+
+--- ex_cmdsub.c.orig	2012-12-27 21:58:41.000000000 +0000
++++ ex_cmdsub.c
+@@ -93,15 +93,18 @@ static char sccsid[] = "@(#)ex_cmdsub.c	
+ 
+ bool	endline = 1;
+ line	*tad1;
+-static	jnoop();
++
++static	int jnoop(void);
++static int getcopy(void);
+ 
+ /*
+  * Append after line a lines returned by function f.
+  * Be careful about intermediate states to avoid scramble
+  * if an interrupt comes in.
+  */
++int
+ append(f, a)
+-	int (*f)();
++	int (*f)(void);
+ 	line *a;
+ {
+ 	register line *a1, *a2, *rdot;
+@@ -144,6 +147,7 @@ append(f, a)
+ 	return (nline);
+ }
+ 
++void
+ appendnone()
+ {
+ 
+@@ -156,6 +160,7 @@ appendnone()
+ /*
+  * Print out the argument list, with []'s around the current name.
+  */
++void
+ pargs()
+ {
+ 	register char **av = argv0, *as = args0;
+@@ -182,6 +187,7 @@ pargs()
+  * Delete lines; two cases are if we are really deleting,
+  * more commonly we are just moving lines to the undo save area.
+  */
++void
+ delete(hush)
+ 	bool hush;
+ {
+@@ -242,6 +248,7 @@ delete(hush)
+ 		killed();
+ }
+ 
++void
+ deletenone()
+ {
+ 
+@@ -256,6 +263,7 @@ deletenone()
+  * Crush out the undo save area, moving the open/visual
+  * save area down in its place.
+  */
++void
+ squish()
+ {
+ 	register line *a1 = dol + 1, *a2 = unddol + 1, *a3 = truedol + 1;
+@@ -276,8 +284,9 @@ squish()
+  * Join lines.  Special hacks put in spaces, two spaces if
+  * preceding line ends with '.', or no spaces if next line starts with ).
+  */
+-static	int jcount, jnoop();
++static	int jcount;
+ 
++void
+ join(c)
+ 	int c;
+ {
+@@ -300,7 +309,7 @@ join(c)
+ 				}
+ 			}
+ 		}
+-		while (*cp++ = *cp1++)
++		while ((*cp++ = *cp1++) != 0)
+ 			if (cp > &genbuf[LBSIZE-2])
+ 				error(catgets(catd, 1, 40,
+ 		"Line overflow|Result line of join would be too long"));
+@@ -316,8 +325,8 @@ join(c)
+ 		vundkind = VMANY;
+ }
+ 
+-static
+-jnoop()
++static int
++jnoop(void)
+ {
+ 
+ 	return(--jcount);
+@@ -327,11 +336,9 @@ jnoop()
+  * Move and copy lines.  Hard work is done by move1 which
+  * is also called by undo.
+  */
+-int	getcopy();
+ 
+-move1(cflag, addrt)
+-	int cflag;
+-	line *addrt;
++static void
++move1(int cflag, line *addrt)
+ {
+ 	register line *adt, *ad1, *ad2;
+ 	int lines;
+@@ -384,6 +391,7 @@ move1(cflag, addrt)
+ 		}
+ }
+ 
++void
+ move()
+ {
+ 	register line *adt;
+@@ -406,7 +414,8 @@ move()
+ 	killed();
+ }
+ 
+-getcopy()
++static int
++getcopy(void)
+ {
+ 
+ 	if (tad1 > addr2)
+@@ -418,7 +427,8 @@ getcopy()
+ /*
+  * Put lines in the buffer from the undo save area.
+  */
+-getput()
++static int
++getput(void)
+ {
+ 
+ 	if (tad1 > unddol)
+@@ -428,6 +438,7 @@ getput()
+ 	return (0);
+ }
+ 
++void
+ put()
+ {
+ 	register int cnt;
+@@ -452,6 +463,7 @@ put()
+  * Argument says pkills have meaning, e.g. called from
+  * put; it is 0 on calls from putreg.
+  */
++void
+ pragged(kill)
+ 	bool kill;
+ {
+@@ -489,6 +501,7 @@ pragged(kill)
+  * Shift lines, based on c.
+  * If c is neither < nor >, then this is a lisp aligning =.
+  */
++void
+ shift(c, cnt)
+ 	int c;
+ 	int cnt;
+@@ -546,6 +559,7 @@ shift(c, cnt)
+  * Find a tag in the tags file.
+  * Most work here is in parsing the tags file itself.
+  */
++void
+ tagfind(quick)
+ 	bool quick;
+ {
+@@ -634,7 +648,7 @@ badtag:
+ 			/* loop for each tags file entry */
+ 			register char *cp = linebuf;
+ 			register char *lp = lasttag;
+-			char *oglobp;
++			const char *oglobp;
+ 
+ #ifdef FASTTAG
+ 			mid = (top + bot) / 2;
+@@ -777,6 +791,7 @@ badtags:
+  * Save lines from addr1 thru addr2 as though
+  * they had been deleted.
+  */
++void
+ yank()
+ {
+ 
+@@ -801,6 +816,7 @@ bool	zhadpr;
+ bool	znoclear;
+ short	zweight;
+ 
++void
+ zop(hadpr)
+ 	int hadpr;
+ {
+@@ -862,8 +878,8 @@ zop(hadpr)
+ 	zop2(lines, op);
+ }
+ 
+-static
+-splitit()
++static void
++splitit(void)
+ {
+ 	register int l;
+ 
+@@ -872,6 +888,7 @@ splitit()
+ 	putnl();
+ }
+ 
++void
+ zop2(lines, op)
+ 	register int lines;
+ 	register int op;
+@@ -956,6 +973,7 @@ zop2(lines, op)
+ 	plines(addr1, addr2, 0);
+ }
+ 
++void
+ plines(adr1, adr2, movedot)
+ 	line *adr1;
+ 	register line *adr2;
+@@ -981,6 +999,7 @@ plines(adr1, adr2, movedot)
+ 	}
+ }
+ 
++void
+ pofix()
+ {
+ 
+@@ -994,6 +1013,7 @@ pofix()
+  * Be (almost completely) sure there really
+  * was a change, before claiming to undo.
+  */
++static void
+ somechange()
+ {
+ 	register line *ip, *jp;
+@@ -1045,6 +1065,7 @@ somechange()
+  *
+  * Undo is its own inverse.
+  */
++void
+ undo(c)
+ 	bool c;
+ {
+@@ -1191,6 +1212,7 @@ undo(c)
+  * Map command:
+  * map src dest
+  */
++void
+ mapcmd(un, ab)
+ 	int un;	/* true if this is unmap command */
+ 	int ab;	/* true if this is abbr command */
+@@ -1287,8 +1309,10 @@ mapcmd(un, ab)
+  * using NOSTR for dest.  Dname is what to show in listings.  mp is
+  * the structure to affect (arrows, etc).
+  */
++void
+ addmac(src,dest,dname,mp)
+-	register char *src, *dest, *dname;
++	register char *src;
++	register const char *dest, *dname;
+ 	register struct maps *mp;
+ {
+ 	register int slot, zer;
+@@ -1314,7 +1338,7 @@ addmac(src,dest,dname,mp)
+ 		 * linefeed, and escape, he can screw himself. This is
+ 		 * so weird I don't bother to check for it.
+ 		 */
+-		if (isalpha(cuc(src[0])) && src[1] || any(src[0],":"))
++		if ((isalpha(cuc(src[0])) && src[1]) || any(src[0],":"))
+ 			error(catgets(catd, 1, 64,
+ 						"Too dangerous to map that"));
+ 	}
+@@ -1385,12 +1409,13 @@ addmac(src,dest,dname,mp)
+  * Implements macros from command mode. c is the buffer to
+  * get the macro from.
+  */
++void
+ cmdmac(c)
+ char c;
+ {
+ 	char macbuf[BUFSIZ];
+ 	line *ad, *a1, *a2;
+-	char *oglobp;
++	const char *oglobp;
+ 	short pk;
+ 	bool oinglobal;
+ 
diff --git a/editors/ex/patches/patch-ex__get_c b/editors/ex/patches/patch-ex__get_c
new file mode 100644
index 00000000000..26b2472fc57
--- /dev/null
+++ b/editors/ex/patches/patch-ex__get_c
@@ -0,0 +1,121 @@
+$NetBSD: patch-ex__get_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- declare void functions void
+- avoid implicit int
+- silence warnings about assignments in conditionals
+- silence warnings about braces
+- don't put external declarations inside functions
+
+--- ex_get.c.orig	2012-12-27 21:58:42.000000000 +0000
++++ ex_get.c
+@@ -90,12 +90,14 @@ static char sccsid[] = "@(#)ex_get.c	1.1
+ static	bool junkbs;
+ short	lastc = '\n';
+ 
++void
+ ignchar()
+ {
+ 	ignore(getchar());
+ }
+ 
+-getach()
++static int
++getach(void)
+ {
+ 	register int c;
+ 	static char in_line[BUFSIZ];
+@@ -114,7 +116,7 @@ getach()
+ 	}
+ top:
+ 	if (input) {
+-		if (c = *input++&0377) {
++		if ((c = *input++&0377) != 0) {
+ 			if (verbose && !intty)
+ 				write(2, &input[-1], 1);
+ #ifndef	BIT8
+@@ -156,6 +158,7 @@ top:
+ 	goto top;
+ }
+ 
++int
+ getchar()
+ {
+ 	register int c;
+@@ -166,7 +169,8 @@ getchar()
+ 	return (c);
+ }
+ 
+-checkjunk(c)
++static void
++checkjunk(int c)
+ {
+ 
+ 	if (junkbs == 0 && c == '\b') {
+@@ -175,6 +179,7 @@ checkjunk(c)
+ 	}
+ }
+ 
++int
+ getcd()
+ {
+ 	register int c;
+@@ -188,16 +193,18 @@ again:
+ #else
+ 	c &= TRIM;
+ #endif
+-	if (!inopen)
++	if (!inopen) {
+ 		if (!globp && c == CTRL('d'))
+ 			setlastchar('\n');
+ 		else if (junk(c)) {
+ 			checkjunk(c);
+ 			goto again;
+ 		}
++	}
+ 	return (c);
+ }
+ 
++int
+ peekchar()
+ {
+ 
+@@ -206,6 +213,7 @@ peekchar()
+ 	return (peekc);
+ }
+ 
++int
+ peekcd()
+ {
+ 	if (peekc == 0)
+@@ -220,6 +228,7 @@ peekcd()
+  * This should really be done differently so as to use the whitecnt routine
+  * and also to hack indenting for LISP.
+  */
++static int
+ smunch(col, ocp)
+ 	register int col;
+ 	char *ocp;
+@@ -251,13 +260,12 @@ smunch(col, ocp)
+  */
+ static	short	lastin;
+ 
++int
+ gettty()
+ {
+ 	register int c = 0;
+ 	register char *cp = genbuf;
+ 	char hadup = 0;
+-	int numbline();
+-	extern int (*Pline)();
+ 	int offset = Pline == numbline ? 8 : 0;
+ 	int ch;
+ 
+@@ -354,7 +362,7 @@ gettty()
+ 	return (0);
+ }
+ 
+-line *
++void
+ setin(addr)
+ 	line *addr;
+ {
diff --git a/editors/ex/patches/patch-ex__io_c b/editors/ex/patches/patch-ex__io_c
new file mode 100644
index 00000000000..f8eef346ce3
--- /dev/null
+++ b/editors/ex/patches/patch-ex__io_c
@@ -0,0 +1,238 @@
+$NetBSD: patch-ex__io_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- avoid implicit int
+- silence miscellaneous gcc45 warning
+- silence warnings about braces
+- silence warnings about unused arguments
+- use const for string constants
+
+--- ex_io.c~	2012-12-27 20:24:51.000000000 +0000
++++ ex_io.c
+@@ -109,13 +109,14 @@ long	cntnull;		/* Count of nulls " */
+ long	cntodd;			/* Count of non-ascii characters " */
+ #endif
+ 
+-int	checkmodeline __P((char *));
++static void checkmodeline __P((char *));
+ 
+ /*
+  * Parse file name for command encoded by comm.
+  * If comm is E then command is doomed and we are
+  * parsing just so user won't have to retype the name.
+  */
++void
+ filename(comm)
+ 	int comm;
+ {
+@@ -168,7 +169,7 @@ filename(comm)
+ 			break;
+ 		}
+ 	}
+-	if (hush && comm != 'f' || comm == 'E')
++	if ((hush && comm != 'f') || comm == 'E')
+ 		return;
+ 	if (file[0] != 0) {
+ 		lprintf("\"%s\"", file);
+@@ -196,6 +197,7 @@ filename(comm)
+  * Get the argument words for a command into genbuf
+  * expanding # and %.
+  */
++int
+ getargs()
+ {
+ 	register int c;
+@@ -271,7 +273,8 @@ filexp:
+  * Scan genbuf for shell metacharacters.
+  * Set is union of v7 shell and csh metas.
+  */
+-gscan()
++static int
++gscan(void)
+ {
+ 	register char *cp;
+ 
+@@ -285,6 +288,7 @@ gscan()
+  * Glob the argument words in genbuf, or if no globbing
+  * is implied, just split them up directly.
+  */
++void
+ gglob(gp)
+ 	struct glob *gp;
+ {
+@@ -372,6 +376,8 @@ gglob(gp)
+  * Parse one filename into file.
+  */
+ struct glob G;
++
++void
+ getone()
+ {
+ 	register char *str;
+@@ -393,6 +399,7 @@ missing:
+ /*
+  * Are these two really the same inode?
+  */
++static int
+ samei(sp, cp)
+ 	struct stat *sp;
+ 	char *cp;
+@@ -408,6 +415,7 @@ samei(sp, cp)
+  * Read a file from the world.
+  * C is command, 'e' if this really an edit (or a recover).
+  */
++void
+ rop(c)
+ 	int c;
+ {
+@@ -603,6 +611,7 @@ end_ft:
+ 	rop3(c);
+ }
+ 
++void
+ rop2()
+ {
+ 	line *first, *last, *a;
+@@ -638,7 +647,8 @@ rop2()
+ /*
+  * Io is finished, close the unit and print statistics.
+  */
+-iostats()
++static int
++iostats(void)
+ {
+ 
+ 	fsync(io);
+@@ -683,6 +693,7 @@ iostats()
+ 			);
+ }
+ 
++void
+ rop3(c)
+ 	int c;
+ {
+@@ -732,10 +743,13 @@ other:
+  * if this is a partial buffer, and distinguish
+  * all cases.
+  */
+-edfile()
++static int
++edfile(void)
+ {
++	/* work around gcc45 warning in eq() because file is a char[] */
++	char *fyle = file;
+ 
+-	if (!edited || !eq(file, savedfile))
++	if (!edited || !eq(fyle, savedfile))
+ 		return (NOTEDF);
+ 	return (addr1 == one && addr2 == dol ? EDF : PARTBUF);
+ }
+@@ -743,6 +757,7 @@ edfile()
+ /*
+  * Write a file.
+  */
++void
+ wop(dofname)
+ bool dofname;	/* if 1 call filename, else use savedfile */
+ {
+@@ -831,12 +846,13 @@ cre:
+ 		if (io < 0)
+ 			syserror();
+ 		writing = 1;
+-		if (hush == 0)
++		if (hush == 0) {
+ 			if (nonexist)
+ 				printf(catgets(catd, 1, 115, " [New file]"));
+ 			else if (value(WRITEANY) && edfile() != EDF)
+ 				printf(catgets(catd, 1, 116,
+ 							" [Existing file]"));
++		}
+ 		break;
+ 
+ 	case 2:
+@@ -852,7 +868,10 @@ cre:
+ 	putfile(0);
+ 	ignore(iostats());
+ 	if (c != 2 && addr1 == one && addr2 == dol) {
+-		if (eq(file, savedfile))
++		/* work around gcc45 warning in eq() because file is a char[] */
++		char *fyle = file;
++
++		if (eq(fyle, savedfile))
+ 			edited = 1;
+ 		synced();
+ 	}
+@@ -868,6 +887,7 @@ cre:
+  */
+ char *nextip;
+ 
++int
+ getfile()
+ {
+ 	register short c;
+@@ -922,6 +942,7 @@ getfile()
+ /*
+  * Write a range onto the io stream.
+  */
++void
+ putfile(isfilter)
+ int isfilter;
+ {
+@@ -930,6 +951,8 @@ int isfilter;
+ 	register int nib;
+ 	struct stat statb;
+ 
++	(void)isfilter;
++
+ 	a1 = addr1;
+ 	clrstats();
+ 	cntln = fixedzero ? 0 : addr2 - a1 + 1;
+@@ -975,10 +998,13 @@ int isfilter;
+  * the edited file then we consider it to have changed since it is
+  * now likely scrambled.
+  */
++void
+ wrerror()
+ {
++	/* work around gcc45 warning in eq() because file is a char[] */
++	char *fyle = file;
+ 
+-	if (eq(file, savedfile) && edited)
++	if (eq(fyle, savedfile) && edited)
+ 		change();
+ 	syserror();
+ }
+@@ -990,13 +1016,14 @@ wrerror()
+ short slevel;
+ short ttyindes;
+ 
++void
+ source(fil, okfail)
+-	char *fil;
++	const char *fil;
+ 	bool okfail;
+ {
+ 	JMP_BUF osetexit;
+ 	register int saveinp, ointty, oerrno;
+-	char *saveglobp;
++	const char *saveglobp;
+ 	short savepeekc;
+ 
+ 	signal(SIGINT, SIG_IGN);
+@@ -1050,6 +1077,7 @@ source(fil, okfail)
+ /*
+  * Clear io statistics before a read or write.
+  */
++void
+ clrstats()
+ {
+ 
+@@ -1082,6 +1110,7 @@ char	*strrchr();
+ #endif	/* !USG3TTY */
+ #endif	/* !__STDC__ */
+ 
++static void
+ checkmodeline(lin)
+ char *lin;
+ {
diff --git a/editors/ex/patches/patch-ex__proto_h b/editors/ex/patches/patch-ex__proto_h
new file mode 100644
index 00000000000..2598cac47fc
--- /dev/null
+++ b/editors/ex/patches/patch-ex__proto_h
@@ -0,0 +1,595 @@
+$NetBSD: patch-ex__proto_h,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- declare void functions void
+- fix up function pointer casting mess
+- don't declare static functions in header files
+- avoid sloppy code that subtracts 1 from the base address of a char[]
+  (which isn't valid)
+
+--- ex_proto.h.orig	2012-12-27 21:58:42.000000000 +0000
++++ ex_proto.h
+@@ -81,352 +81,356 @@
+ #ifdef	POSIX_1
+ shand setsig __P((int, shand));
+ #endif
+-int init __P((void));
++void init __P((void));
+ /* ex_addr.c */
+-int setdot __P((void));
+-int setdot1 __P((void));
+-int setcount __P((void));
++void setdot __P((void));
++void setdot1 __P((void));
++void setcount __P((void));
+ int getnum __P((void));
+-int setall __P((void));
+-int setnoaddr __P((void));
++void setall __P((void));
++void setnoaddr __P((void));
+ line *address __P((char *));
+-int setCNL __P((void));
+-int setNAEOL __P((void));
++void setCNL __P((void));
++void setNAEOL __P((void));
+ /* ex_cmds.c */
+-int commands __P((int, int));
++void commands __P((int, int));
+ /* ex_cmds2.c */
+ int cmdreg __P((void));
+ int endcmd __P((int));
+-int eol __P((void));
+-int error __P((char *, ...));
+-int erewind __P((void));
+-int fixol __P((void));
++void eol __P((void));
++void error __P((const char *, ...));
++void erewind __P((void));
++void fixol __P((void));
+ int exclam __P((void));
+-int makargs __P((void));
+-int next __P((void));
+-int newline __P((void));
+-int nomore __P((void));
++void makargs __P((void));
++void next __P((void));
++void newline __P((void));
++void nomore __P((void));
+ int quickly __P((void));
+-int resetflav __P((void));
+-int serror __P((char *, ...));
+-int setflav __P((void));
++void resetflav __P((void));
++void serror __P((const char *, ...));
++void setflav __P((void));
+ int skipend __P((void));
+-int tailspec __P((int));
+-int tail __P((char *));
+-int tail2of __P((char *));
+-int tailprim __P((char *, int, int));
+-int vcontin __P((int));
+-int vnfl __P((void));
++void tailspec __P((int));
++void tail __P((const char *));
++void tail2of __P((const char *));
++void tailprim __P((const char *, int, int));
++void vcontin __P((int));
++void vnfl __P((void));
+ /* ex_cmdsub.c */
+-int append __P((int (*)(), line *));
+-int appendnone __P((void));
+-int pargs __P((void));
+-int delete __P((int));
+-int deletenone __P((void));
+-int squish __P((void));
+-int join __P((int));
+-int move __P((void));
+-int put __P((void));
+-int pragged __P((int));
+-int shift __P((int, int));
+-int tagfind __P((int));
+-int yank __P((void));
+-int zop __P((int));
+-int zop2 __P((int, int));
+-int plines __P((line *, line *, int));
+-int pofix __P((void));
+-int undo __P((int));
+-int mapcmd __P((int, int));
+-int cmdmac __P((int));
++int append __P((int (*)(void), line *));
++void appendnone __P((void));
++void pargs __P((void));
++void delete __P((int));
++void deletenone __P((void));
++void squish __P((void));
++void join __P((int));
++void move __P((void));
++void put __P((void));
++void pragged __P((int));
++void shift __P((int, int));
++void tagfind __P((int));
++void yank __P((void));
++void zop __P((int));
++void zop2 __P((int, int));
++void plines __P((line *, line *, int));
++void pofix __P((void));
++void undo __P((int));
++void mapcmd __P((int, int));
++void cmdmac __P((int));
+ /* ex_data.c */
+ /* ex_extern.c */
+ /* ex_get.c */
+-int ignchar __P((void));
++void ignchar __P((void));
+ int getchar __P((void));
+ int getcd __P((void));
+ int peekchar __P((void));
+ int peekcd __P((void));
+ int gettty __P((void));
+-line *setin __P((line *));
++void setin __P((line *));
+ /* ex_io.c */
+-int filename __P((int));
++void filename __P((int));
+ int getargs __P((void));
+-int getone __P((void));
+-int rop __P((int));
+-int rop2 __P((void));
+-int rop3 __P((int));
+-int wop __P((int));
++void getone __P((void));
++void rop __P((int));
++void rop2 __P((void));
++void rop3 __P((int));
++void wop __P((int));
+ int getfile __P((void));
+-int putfile __P((int));
+-int wrerror __P((void));
+-int source __P((char *, int));
+-int clrstats __P((void));
++void putfile __P((int));
++void wrerror __P((void));
++void source __P((const char *, int));
++void clrstats __P((void));
+ /* ex_put.c */
+-int (*setlist __P((int))) __P((void));
+-int (*setnumb __P((int))) __P((void));
++int (*setlist __P((bool))) __P((int));
++int (*setnumb __P((bool))) __P((int));
+ int listchar __P((int));
+ int normchar __P((int));
+ int numbline __P((int));
+-int normline __P((void));
++int normline __P((int));
+ int putchar __P((int));
+ int termchar __P((int));
+-int flush __P((void));
+-int flush1 __P((void));
+-int fgoto __P((void));
+-int tab __P((int));
+-int noteinp __P((void));
+-int termreset __P((void));
+-int draino __P((void));
+-int flusho __P((void));
+-int putnl __P((void));
++void flush __P((void));
++void flush1 __P((void));
++void fgoto __P((void));
++void tab __P((int));
++void noteinp __P((void));
++void termreset __P((void));
++void draino __P((void));
++void flusho __P((void));
++void putnl __P((void));
+ int putch __P((int));
+-int putpad __P((char *));
+-int setoutt __P((void));
+-int vlprintf __P((char *, va_list));
+-int lprintf __P((char *, ...));
+-int putNFL __P((void));
+-int pstart __P((void));
+-int pstop __P((void));
+-int tostart __P((void));
+-int tostop __P((void));
+-int gTTY __P((int));
+-int noonl __P((void));
++void putpad __P((const char *));
++void setoutt __P((void));
++void vlprintf __P((const char *, va_list));
++void lprintf __P((const char *, ...));
++void putNFL __P((void));
++void pstart __P((void));
++void pstop __P((void));
++void tostart __P((void));
++void tostop __P((void));
++void vcook __P((void));
++void vraw __P((void));
++void gTTY __P((int));
++void noonl __P((void));
+ /* ex_re.c */
+-int global __P((int));
++void global __P((int));
+ int substitute __P((int));
+ int getsub __P((void));
+-char *place __P((char *, char *, char *));
+ int compile __P((int, int));
+ int same __P((int, int));
+ int execute __P((int, line *));
+ int advance __P((char *, char *));
+ /* ex_set.c */
+-int set __P((void));
++void set __P((void));
+ /* ex_subr.c */
+-int any __P((int, char *));
++int any __P((int, const char *));
+ int backtab __P((int));
+-int change __P((void));
++void change __P((void));
+ int column __P((char *));
+-int comment __P((void));
+-int Copy __P((char *, char *, int));
+-int copyw __P((line *, line *, int));
+-int copywR __P((line *, line *, int));
++void comment __P((void));
++void Copy __P((char *, char *, int));
++void copyw __P((line *, line *, int));
++void copywR __P((line *, line *, int));
+ int ctlof __P((int));
+-int dingdong __P((void));
++void dingdong __P((void));
+ int fixindent __P((int));
+-int filioerr __P((char *));
++void filioerr __P((const char *));
+ char *genindent __P((int));
+-int getDOT __P((void));
++void getDOT __P((void));
+ line *getmark __P((int));
+ int getn __P((char *));
+-int ignnEOF __P((void));
++void ignnEOF __P((void));
+ int is_white __P((int));
+ int junk __P((int));
+-int killed __P((void));
+-int killcnt __P((int));
++void killed __P((void));
++void killcnt __P((int));
+ int lineno __P((line *));
+ int lineDOL __P((void));
+ int lineDOT __P((void));
+-int markDOT __P((void));
+-int markpr __P((line *));
++void markDOT __P((void));
++void markpr __P((line *));
+ int markreg __P((int));
+-char *mesg __P((char *));
+-int vmerror __P((char *, va_list));
+-int merror __P((char *, ...));
++char *mesg __P((const char *));
++void vmerror __P((const char *, va_list));
++void merror __P((const char *, ...));
+ int morelines __P((void));
+-int nonzero __P((void));
++void nonzero __P((void));
+ int notable __P((int));
+-int notempty __P((void));
+-int netchHAD __P((int));
+-int netchange __P((int));
++void notempty __P((void));
++void netchHAD __P((int));
++void netchange __P((int));
+ int printof __P((int));
+-int putmark __P((line *));
+-int putmk1 __P((line *, int));
+-char *plural __P((long));
+-int qcolumn __P((char *, char *));
+-int reverse __P((line *, line *));
+-int save __P((line *, line *));
+-int save12 __P((void));
+-int saveall __P((void));
++void putmark __P((line *));
++void putmk1 __P((line *, int));
++const char *plural __P((long));
++int qcolumn2 __P((char *, char *));
++void reverse __P((line *, line *));
++void save __P((line *, line *));
++void save12 __P((void));
++void saveall __P((void));
+ int span __P((void));
+-int synced __P((void));
++void synced __P((void));
+ int skipwh __P((void));
+-int vsmerror __P((char *, va_list));
+-int smerror __P((char *, ...));
++void vsmerror __P((const char *, va_list));
++void smerror __P((const char *, ...));
+ char *strend __P((char *));
+-int strcLIN __P((char *));
+-int syserror __P((void));
++const char *strendk __P((const char *));
++void strcLIN __P((const char *));
++void syserror __P((void));
+ int tabcol __P((int, int));
+ char *vfindcol __P((int));
+ char *vskipwh __P((char *));
+ char *vpastwh __P((char *));
+ int whitecnt __P((char *));
+-int markit __P((line *));
+-int setrupt __P((void));
++void markit __P((line *));
++void setrupt __P((void));
+ int preserve __P((void));
+-int exitex __P((int));
++dead void exitex __P((int));
+ /* ex_tagio.c */
+ int topen __P((char *, char *));
+ int tseek __P((int, off_t));
+ int tgets __P((char *, int, int));
+-int tclose __P((int));
++void tclose __P((int));
+ /* ex_temp.c */
+-int fileinit __P((void));
+-int cleanup __P((int));
+-int get_line __P((line));
++void fileinit __P((void));
++void cleanup __P((int));
++void get_line __P((line));
+ int putline __P((void));
+-int tlaste __P((void));
+-int tflush __P((void));
+-int synctmp __P((void));
+-int TSYNC __P((void));
+-int putreg __P((int));
++void tlaste __P((void));
++void tflush __P((void));
++void synctmp __P((void));
++void TSYNC __P((void));
++void putreg __P((int));
+ int partreg __P((int));
+-int notpart __P((int));
+-int YANKreg __P((int));
+-int kshift __P((void));
+-int regbuf __P((int, char *, int));
++void notpart __P((int));
++void YANKreg __P((int));
++void kshift __P((void));
++void regbuf __P((int, char *, int));
+ /* ex_tty.c */
+-int gettmode __P((void));
+-int setterm __P((char *));
+-int setsize __P((void));
++void gettmode __P((void));
++void setterm __P((const char *));
++void setsize __P((void));
+ char *fkey __P((int));
+-int cost __P((char *));
++int cost __P((const char *));
+ /* ex_unix.c */
+-int unix0 __P((int));
+-int filter __P((int));
+-int recover __P((void));
+-int waitfor __P((void));
+-int revocer __P((void));
++void unix0 __P((int));
++void filter __P((int));
++void recover __P((void));
++void waitfor __P((void));
++void revocer __P((void));
+ /* ex_v.c */
+-int oop __P((void));
+-int vop __P((void));
+-int fixzero __P((void));
+-int savevis __P((void));
+-int undvis __P((void));
+-int vsetsiz __P((int));
++void oop __P((void));
++void vop __P((void));
++void fixzero __P((void));
++void savevis __P((void));
++void undvis __P((void));
++void vsetsiz __P((int));
+ /* ex_vadj.c */
+-int vopen __P((line *, int));
++void vopen __P((line *, int));
+ int vreopen __P((int, int, int));
+ int vglitchup __P((int, int));
+-int vinslin __P((int, int, int));
+-int vrollup __P((int));
+-int vup1 __P((void));
+-int vmoveitup __P((int, int));
+-int vscrap __P((void));
+-int vrepaint __P((char *));
+-int vredraw __P((int));
+-int vsyncCL __P((void));
+-int vsync __P((int));
+-int vsync1 __P((int));
+-int vreplace __P((int, int, int));
+-int sethard __P((void));
+-int vdirty __P((int, int));
++void vinslin __P((int, int, int));
++void vrollup __P((int));
++void vup1 __P((void));
++void vmoveitup __P((int, int));
++void vscrap __P((void));
++void vrepaint __P((char *));
++void vredraw __P((int));
++void vsyncCL __P((void));
++void vsync __P((int));
++void vsync1 __P((int));
++void vreplace __P((int, int, int));
++void sethard __P((void));
++void vdirty __P((int, int));
+ /* ex_version.c */
+-int printver __P((void));
++void printver __P((void));
+ /* ex_vget.c */
+-int ungetkey __P((int));
++void ungetkey __P((int));
+ int getkey __P((void));
+ int peekbr __P((void));
+ int getbr __P((void));
+ int getesc __P((void));
+ int peekkey __P((void));
+ int readecho __P((int));
+-int setLAST __P((void));
+-int addtext __P((char *));
+-int setDEL __P((void));
+-int setBUF __P((cell *));
++void setLAST __P((void));
++void addtext __P((char *));
++void setDEL __P((void));
++void setBUF __P((cell *));
+ int noteit __P((int));
+-int macpush __P((char *, int));
++void macpush __P((const char *, int));
++void vudump __P((const char *s));
+ int vgetcnt __P((void));
+ /* ex_vmain.c */
+-int vmain __P((void));
+-int prepapp __P((void));
+-int vremote __P((int, int (*)(), int));
+-int vsave __P((void));
++void vmain __P((void));
++void prepapp __P((void));
++void vremote __P((int, void (*)(int), int));
++void vsave __P((void));
+ cell *str2cell __P((cell *, char *));
+ char *cell2str __P((char *, cell *));
+ cell *cellcpy __P((cell *, cell *));
+ size_t cellen __P((cell *));
+ cell *cellcat __P((cell *, cell *));
+ /* ex_voper.c */
+-int operate __P((int, int));
++void operate __P((int, int));
+ int find __P((int));
+-int word __P((int (*)(), int));
+-int eend __P((int (*)()));
++int word __P((void (*)(int), int));
++void eend __P((void (*)(int)));
+ int wordof __P((int, char *));
+ int wordch __P((char *));
+ int margin __P((void));
+ /* ex_vops.c */
+-int vUndo __P((void));
+-int vundo __P((int));
+-int vmacchng __P((int));
+-int vnoapp __P((void));
+-int vmove __P((void));
+-int vdelete __P((int));
+-int vchange __P((int));
+-int voOpen __P((int, int));
+-int vshftop __P((void));
+-int vfilter __P((void));
+-int vrep __P((int));
+-int vyankit __P((void));
++void vUndo __P((void));
++void vundo __P((int));
++void vmacchng __P((int));
++void vnoapp __P((void));
++void vmove __P((void));
++void vmove_i __P((int));
++void vdelete __P((int));
++void vchange __P((int));
++void voOpen __P((int, int));
++void vshftop __P((void));
++void vfilter __P((void));
++void vrep __P((int));
++void vyankit __P((void));
+ /* ex_vops2.c */
+-int bleep __P((int, char *));
++void bleep __P((int, char *));
+ int vdcMID __P((void));
+-int takeout __P((cell *));
++void takeout __P((cell *));
+ int ateopr __P((void));
+-int showmode __P((int));
+-int vappend __P((int, int, int));
+-int back1 __P((void));
++void showmode __P((int));
++void vappend __P((int, int, int));
++void back1 __P((void));
+ char *vget_line __P((int, char *, bool *, int));
+-int vdoappend __P((char *));
++void vdoappend __P((const char *));
+ /* ex_vops3.c */
+-int llfind __P((int, int, int (*)(), line *));
++int llfind __P((int, int, void (*)(int), line *));
+ int lindent __P((line *));
+ int lmatchp __P((line *));
+-int lsmatch __P((char *));
++void lsmatch __P((char *));
+ int lnext __P((void));
+-int lbrack __P((int, int (*)()));
++int lbrack __P((int, void (*)(int)));
+ /* ex_vput.c */
+-int vclear __P((void));
+-int vclrcell __P((cell *, int));
+-int vclrlin __P((int, line *));
+-int vclreol __P((void));
+-int vclrech __P((int));
+-int fixech __P((void));
+-int vcursbef __P((char *));
+-int vcursat __P((char *));
+-int vcursaft __P((char *));
+-int vfixcurs __P((void));
+-int vsetcurs __P((char *));
+-int vigoto __P((int, int));
+-int vcsync __P((void));
+-int vgotoCL __P((int));
+-int vgoto __P((int, int));
+-int vprepins __P((void));
++void vclear __P((void));
++void vclrcell __P((cell *, int));
++void vclrlin __P((int, line *));
++void vclreol __P((void));
++void vclrech __P((int));
++void fixech __P((void));
++void vcursbef __P((char *));
++void vcursat __P((char *));
++void vcursaft __P((char *));
++void vfixcurs __P((void));
++void vsetcurs __P((char *));
++void vigoto __P((int, int));
++void vcsync __P((void));
++void vgotoCL __P((int));
++void vgoto __P((int, int));
++void vprepins __P((void));
+ int vputch __P((int));
+ int vinschar __P((int));
+-int goim __P((void));
+-int endim __P((void));
++void goim __P((void));
++void endim __P((void));
+ int vputchar __P((int));
+-int physdc __P((int, int));
++void physdc __P((int, int));
+ /* ex_vwind.c */
+-int vmoveto __P((line *, char *, int));
+-int vjumpto __P((line *, char *, int));
+-int vupdown __P((int, char *));
+-int vup __P((int, int, int));
+-int vdown __P((int, int, int));
+-int vcontext __P((line *, int));
+-int vclean __P((void));
+-int vshow __P((line *, line *));
+-int vroll __P((int));
++void vmoveto __P((line *, char *, int));
++void vjumpto __P((line *, char *, int));
++void vupdown __P((int, char *));
++void vup __P((int, int, int));
++void vdown __P((int, int, int));
++void vcontext __P((line *, int));
++void vclean __P((void));
++void vshow __P((line *, line *));
++void vroll __P((int));
+ int vdepth __P((void));
+-int vnline __P((char *));
++void vnline __P((char *));
+ /* malloc.c */
+ char *poolsbrk __P((intptr_t));
+ /* printf.c */
+ int printf __P((const char *, ...));
+ int vprintf __P((const char *, va_list));
+-char *p_dconv __P((long, char *));
++char *p_dconv __P((unsigned long, char *));
+ 
+ woid onemt __P((int));
+ woid onhup __P((int));
diff --git a/editors/ex/patches/patch-ex__put_c b/editors/ex/patches/patch-ex__put_c
new file mode 100644
index 00000000000..bdcd03e6669
--- /dev/null
+++ b/editors/ex/patches/patch-ex__put_c
@@ -0,0 +1,530 @@
+$NetBSD: patch-ex__put_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- fix up function pointer casting mess
+- avoid implicit int
+- silence warnings about && and || precedence
+- use const for string constants
+- return values from non-void functions
+- silence warnings about braces
+- declare void functions void
+- remove unused function
+
+--- ex_put.c.orig	2012-12-27 21:58:42.000000000 +0000
++++ ex_put.c
+@@ -99,15 +99,13 @@ static char sccsid[] = "@(#)ex_put.c	1.1
+  * During open/visual, outchar and putchar will be set to
+  * routines in the file ex_vput.c (vputchar, vinschar, etc.).
+  */
+-int	(*Outchar)() = termchar;
+-int	(*Putchar)() = normchar;
+-int	(*Pline)() = normline;
+-
+-int (*
+-setlist(t))()
+-	bool t;
++int	(*Outchar)(int) = termchar;
++int	(*Putchar)(int) = normchar;
++int	(*Pline)(int) = normline;
++
++int (*setlist(bool t))(int)
+ {
+-	register int (*P)();
++	register int (*P)(int);
+ 
+ 	listf = t;
+ 	P = Putchar;
+@@ -115,15 +113,13 @@ setlist(t))()
+ 	return (P);
+ }
+ 
+-int (*
+-setnumb(t))()
+-	bool t;
++int (*setnumb(bool t))(int)
+ {
+-	register int (*P)();
++	register int (*P)(int);
+ 
+ 	numberf = t;
+ 	P = Pline;
+-	Pline = t ? (int(*)()) numbline : (int(*)()) normline;
++	Pline = t ? numbline : normline;
+ 	return (P);
+ }
+ 
+@@ -131,6 +127,7 @@ setnumb(t))()
+  * Format c for list mode; leave things in common
+  * with normal print mode to be done by normchar.
+  */
++int
+ listchar(c)
+ 	register short c;
+ {
+@@ -167,23 +164,24 @@ listchar(c)
+ 		if (c < ' ' && c != '\n')
+ 			outchar('^'), c = ctlof(c);
+ #else	/* !BIT8 */
+-		if (!is_print(c) && c != '\n' || c == DELETE)
++		if ((!is_print(c) && c != '\n') || c == DELETE)
+ 			c = printof(c);
+ #endif
+ 		break;
+ 	}
+-	normchar(c);
++	return normchar(c);
+ }
+ 
+ /*
+  * Format c for printing. Handle funnies of upper case terminals
+  * and crocky hazeltines which don't have ~.
+  */
++int
+ normchar(c)
+ 	register short c;
+ {
+ #ifdef	UCVISUAL
+-	register char *colp;
++	register const char *colp;
+ 
+ 	if (c == '~' && xHZ) {
+ 		normchar('\\');
+@@ -196,7 +194,7 @@ normchar(c)
+ 	if (c & QUOTE) {
+ #else
+ 	if (c == overbuf)
+-		return;
++		return c;
+ 	if (quot(c)) {
+ #endif
+ 		switch (c) {
+@@ -231,7 +229,7 @@ normchar(c)
+ 		putchar('^'), c = ctlof(c);
+ #endif	/* !BIT8 */
+ #ifdef	UCVISUAL
+-	else if (UPPERCASE)
++	else if (UPPERCASE) {
+ 		if (isupper(c)) {
+ 			outchar('\\');
+ 			c = tolower(c);
+@@ -244,11 +242,13 @@ normchar(c)
+ 					break;
+ 				}
+ 		}
++	}
+ #endif	/* UCVISUAL */
+ #ifdef	BIT8
+ 	}
+ #endif
+ 	outchar(c);
++	return c;
+ }
+ 
+ /*
+@@ -256,8 +256,8 @@ normchar(c)
+  * the printing of the line will erase or otherwise obliterate
+  * the prompt which was printed before.  If it won't, do it now.
+  */
+-slobber(c)
+-	int c;
++static void
++slobber(int c)
+ {
+ 
+ 	shudclob = 0;
+@@ -288,6 +288,7 @@ slobber(c)
+ /*
+  * Print a line with a number.
+  */
++int
+ numbline(i)
+ 	int i;
+ {
+@@ -295,13 +296,14 @@ numbline(i)
+ 	if (shudclob)
+ 		slobber(' ');
+ 	printf("%6d  ", i);
+-	normline();
++	return normline(i);
+ }
+ 
+ /*
+  * Normal line output, no numbering.
+  */
+-normline()
++int
++normline(int arg)
+ {
+ 	register char *cp;
+ 
+@@ -320,6 +322,7 @@ normline()
+ 		putchar('\n');
+ #endif
+ 	}
++	return arg;
+ }
+ 
+ /*
+@@ -340,11 +343,12 @@ static	bool phadnl;
+ /*
+  * Indirect to current definition of putchar.
+  */
++int
+ putchar(c)
+ 	int c;
+ {
+ 
+-	(*Putchar)(c);
++	return (*Putchar)(c);
+ }
+ 
+ /*
+@@ -353,6 +357,7 @@ putchar(c)
+  * Otherwise flush into next level of buffering when
+  * small buffer fills or at a newline.
+  */
++int
+ termchar(c)
+ 	int c;
+ {
+@@ -368,9 +373,11 @@ termchar(c)
+ 		fgoto();
+ 		flush1();
+ 	}
++	return c;
+ }
+ 
+-flush2()
++static void
++flush2(void)
+ {
+ 
+ 	fgoto();
+@@ -378,6 +385,7 @@ flush2()
+ 	pstop();
+ }
+ 
++void
+ flush()
+ {
+ 
+@@ -390,6 +398,7 @@ flush()
+  * Work here is destroying motion into positions, and then
+  * letting fgoto do the optimized motion.
+  */
++void
+ flush1()
+ {
+ 	register char *lp;
+@@ -472,16 +481,19 @@ static int plodcnt, plodflg;
+  * and backspace.
+  */
+ 
+-plodput(c)
++static int
++plodput(int c)
+ {
+ 
+ 	if (plodflg)
+ 		plodcnt--;
+ 	else
+ 		putch(c);
++	return c;
+ }
+ 
+-plod(cnt)
++static int
++plod(int cnt)
+ {
+ 	register int i, j, k = 0;
+ 	register int soutcol, soutline;
+@@ -585,7 +597,7 @@ plod(cnt)
+ 	 * If it will be cheaper, or if we can't back up, then send
+ 	 * a return preliminarily.
+ 	 */
+-	if (j > i + 1 || outcol > destcol && !BS && !BC) {
++	if (j > i + 1 || (outcol > destcol && !BS && !BC)) {
+ 		/*
+ 		 * BUG: this doesn't take the (possibly long) length
+ 		 * of xCR into account.
+@@ -764,6 +776,7 @@ out:
+  * column position implied by wraparound or the lack thereof and
+  * rolling up the screen to get destline on the screen.
+  */
++void
+ fgoto()
+ {
+ 	register int l, c;
+@@ -778,11 +791,12 @@ fgoto()
+ 		outcol %= TCOLUMNS;
+ 		if (AM == 0) {
+ 			while (l > 0) {
+-				if (pfast)
++				if (pfast) {
+ 					if (xCR)
+ 						tputs(xCR, 0, putch);
+ 					else
+ 						putch('\r');
++				}
+ 				if (xNL)
+ 					tputs(xNL, 0, putch);
+ 				else
+@@ -834,7 +848,7 @@ fgoto()
+ 				outcol = 0;
+ 		}
+ 	}
+-	if (destline < outline && !(CA && !holdcm || UP != NOSTR))
++	if (destline < outline && !((CA && !holdcm) || UP != NOSTR))
+ 		destline = outline;
+ 	if (CA && !holdcm)
+ 		if (plod(costCM) > 0)
+@@ -851,6 +865,7 @@ fgoto()
+  * Tab to column col by flushing and then setting destcol.
+  * Used by "set all".
+  */
++void
+ tab(col)
+ 	int col;
+ {
+@@ -865,6 +880,7 @@ tab(col)
+  * Approximate because kill character echoes newline with
+  * no feedback and also because of long input lines.
+  */
++void
+ noteinp()
+ {
+ 
+@@ -883,6 +899,7 @@ noteinp()
+  * On cursor addressible terminals setting to unknown
+  * will force a cursor address soon.
+  */
++void
+ termreset()
+ {
+ 
+@@ -906,12 +923,14 @@ termreset()
+  */
+ char	*obp = obuf;
+ 
++void
+ draino()
+ {
+ 
+ 	obp = obuf;
+ }
+ 
++void
+ flusho()
+ {
+ 
+@@ -921,12 +940,15 @@ flusho()
+ 	}
+ }
+ 
++void
+ putnl()
+ {
+ 
+ 	putchar('\n');
+ }
+ 
++#if 0 /* unused */
++void
+ putS(cp)
+ 	char *cp;
+ {
+@@ -936,8 +958,10 @@ putS(cp)
+ 	while (*cp)
+ 		putch(*cp++);
+ }
++#endif
+ 
+ 
++int
+ putch(c)
+ 	int c;
+ {
+@@ -953,6 +977,7 @@ putch(c)
+ #endif
+ 	if (obp >= &obuf[sizeof obuf])
+ 		flusho();
++	return c;
+ }
+ 
+ /*
+@@ -962,8 +987,9 @@ putch(c)
+ /*
+  * Put with padding
+  */
++void
+ putpad(cp)
+-	char *cp;
++	const char *cp;
+ {
+ 
+ 	flush();
+@@ -973,6 +999,7 @@ putpad(cp)
+ /*
+  * Set output through normal command mode routine.
+  */
++void
+ setoutt()
+ {
+ 
+@@ -983,27 +1010,29 @@ setoutt()
+  * Printf (temporarily) in list mode.
+  */
+ /*VARARGS2*/
++void
+ #ifndef	__STDC__
+ lprintf(cp, dp)
+-	char *cp, *dp;
++	const char *cp, *dp;
+ {
+-	register int (*P)();
++	register int (*P)(int);
+ 
+ 	P = setlist(1);
+ 	printf(cp, dp);
+ 	Putchar = P;
+ }
+ #else
+-vlprintf(char *cp, va_list ap)
++vlprintf(const char *cp, va_list ap)
+ {
+-	register int (*P)();
++	register int (*P)(int);
+ 
+ 	P = setlist(1);
+ 	vprintf(cp, ap);
+ 	Putchar = P;
+ }
+ 
+-lprintf(char *cp, ...)
++void
++lprintf(const char *cp, ...)
+ {
+ 	va_list ap;
+ 
+@@ -1016,6 +1045,7 @@ lprintf(char *cp, ...)
+ /*
+  * Newline + flush.
+  */
++void
+ putNFL()
+ {
+ 
+@@ -1027,8 +1057,8 @@ putNFL()
+  * sTTY: set the tty modes on file descriptor i to be what's
+  * currently in global "tty".  (Also use nttyc if needed.)
+  */
+-sTTY(i)
+-	int i;
++static void
++sTTY(int i)
+ {
+ 
+ #ifdef	POSIX_1
+@@ -1067,6 +1097,7 @@ sTTY(i)
+ /*
+  * Try to start -nl mode.
+  */
++void
+ pstart()
+ {
+ 
+@@ -1101,6 +1132,7 @@ pstart()
+ /*
+  * Stop -nl mode.
+  */
++void
+ pstop()
+ {
+ 
+@@ -1121,7 +1153,8 @@ pstop()
+  */
+ #ifndef	TERMIO_S
+ #ifdef TIOCGETC
+-ttcharoff()
++static void
++ttcharoff(void)
+ {
+ 	nttyc.t_quitc = '\377';
+ 	if (nttyc.t_startc != CTRL('q'))
+@@ -1138,7 +1171,8 @@ ttcharoff()
+ #endif
+ 
+ #else	/* TERMIO_S */
+-ttcharoff()
++static void
++ttcharoff(void)
+ {
+ #ifdef	_PC_VDISABLE
+ 	long vdis;
+@@ -1239,6 +1273,7 @@ ostart()
+ }
+ 
+ /* actions associated with putting the terminal in open mode */
++void
+ tostart()
+ {
+ 	putpad(VS);
+@@ -1275,6 +1310,7 @@ tostart()
+ /*
+  * Stop open, restoring tty modes.
+  */
++void
+ ostop(f)
+ 	ttymode f;
+ {
+@@ -1290,6 +1326,7 @@ ostop(f)
+ }
+ 
+ /* Actions associated with putting the terminal in the right mode. */
++void
+ tostop()
+ {
+ 	putpad(VE);
+@@ -1302,7 +1339,8 @@ tostop()
+ /*
+  * Into cooked mode for interruptibility.
+  */
+-vcook()
++void
++vcook(void)
+ {
+ 
+ 	tty.sg_flags &= ~RAW;
+@@ -1312,7 +1350,8 @@ vcook()
+ /*
+  * Back into raw mode.
+  */
+-vraw()
++void
++vraw(void)
+ {
+ 
+ 	tty.sg_flags |= RAW;
+@@ -1323,6 +1362,7 @@ vraw()
+ /*
+  * Restore flags to normal state f.
+  */
++void
+ normal(f)
+ 	ttymode f;
+ {
+@@ -1365,6 +1405,7 @@ setty(f)
+ 	return (ot);
+ }
+ 
++void
+ gTTY(i)
+ 	int i;
+ {
+@@ -1391,6 +1432,7 @@ gTTY(i)
+ /*
+  * Print newline, or blank if in open/visual
+  */
++void
+ noonl()
+ {
+ 
diff --git a/editors/ex/patches/patch-ex__re_c b/editors/ex/patches/patch-ex__re_c
new file mode 100644
index 00000000000..836f8ccc023
--- /dev/null
+++ b/editors/ex/patches/patch-ex__re_c
@@ -0,0 +1,348 @@
+$NetBSD: patch-ex__re_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- use const for string constants
+- wrap unused function in the proper matching ifdef
+- avoid implicit int
+- fix signed/unsigned mismatch
+- silence warnings about assignments in conditionals
+- silence warnings about && and || precedence
+
+--- ex_re.c~	2012-12-27 21:58:42.000000000 +0000
++++ ex_re.c
+@@ -82,32 +82,35 @@ static char sccsid[] = "@(#)ex_re.c	1.37
+ #include "ex.h"
+ #include "ex_re.h"
+ 
+-int compsub __P((int));
+-int dosubcon __P((int, line *));
+-int snote __P((register int, register int));
+-int comprhs __P((int));
+-int confirmed __P((line *));
+-int dosub __P((void));
+-int ugo __P((int, int));
+-int fixcase __P((register int));
+-int cerror __P((char *));
+-int cclass __P((register char *, register int, int));
++static int compsub __P((int));
++static int dosubcon __P((int, line *));
++static void snote __P((register int, register int));
++static void comprhs __P((int));
++static int confirmed __P((line *));
++static void dosub __P((void));
++static void ugo __P((int, int));
++static int fixcase __P((register int));
++static char *place __P((char *, char *, char *));
++static void cerror __P((const char *));
++static int cclass __P((register const char *, register int, int));
+ 
+ /*
+  * Global, substitute and regular expressions.
+  * Very similar to ed, with some re extensions and
+  * confirmed substitute.
+  */
++void
+ global(k)
+ 	bool k;
+ {
+ 	register char *gp;
+ 	register int c;
+ 	register line *a1;
+-	char globuf[GBSIZE], *Cwas;
++	char globuf[GBSIZE];
++	const char *Cwas;
+ 	int lines = lineDOL();
+ 	int oinglobal = inglobal;
+-	char *oglobp = globp;
++	const char *oglobp = globp;
+ 
+ 	Cwas = Command;
+ 	/*
+@@ -220,6 +223,7 @@ brkwh:
+ 	}
+ }
+ 
++#ifdef notdef /* used above in a notdef block */
+ /*
+  * gdelete: delete inside a global command. Handles the
+  * special case g/r.e./d. All lines to be deleted have
+@@ -228,7 +232,8 @@ brkwh:
+  * and g/r.e./.,/r.e.2/d are not treated specially.  There is no
+  * good reason for this except the question: where to you draw the line?
+  */
+-gdelete()
++static void
++gdelete(void)
+ {
+ 	register line *a1, *a2, *a3;
+ 
+@@ -250,16 +255,19 @@ gdelete()
+ 		dot = dol;
+ 	change();
+ }
++#endif
+ 
+ bool	cflag;
+ int	scount, slines, stotal;
+ 
++int
+ substitute(c)
+ 	int c;
+ {
+ 	register line *addr;
+ 	register int n;
+-	int gsubf, hopcount;
++	int gsubf;
++	unsigned hopcount;
+ 
+ 	gsubf = compsub(c);
+ 	if(FIXUNDO)
+@@ -267,7 +275,8 @@ substitute(c)
+ 	stotal = 0;
+ 	slines = 0;
+ 	for (addr = addr1; addr <= addr2; addr++) {
+-		scount = hopcount = 0;
++		scount = 0;
++		hopcount = 0;
+ 		if (dosubcon(0, addr) == 0)
+ 			continue;
+ 		if (gsubf) {
+@@ -299,7 +308,8 @@ substitute(c)
+ 	return (stotal);
+ }
+ 
+-compsub(ch)
++static int
++compsub(int ch)
+ {
+ 	register int seof, c, uselastre;
+ 	static int gsubf;
+@@ -368,6 +378,7 @@ compsub(ch)
+ 	}
+ }
+ 
++static void
+ comprhs(seof)
+ 	int seof;
+ {
+@@ -469,6 +480,7 @@ endrhs:
+ 	*rp++ = 0;
+ }
+ 
++int
+ getsub()
+ {
+ 	register char *p;
+@@ -480,6 +492,7 @@ getsub()
+ 	return (0);
+ }
+ 
++static int
+ dosubcon(f, a)
+ 	bool f;
+ 	line *a;
+@@ -494,11 +507,12 @@ dosubcon(f, a)
+ 	return (1);
+ }
+ 
++static int
+ confirmed(a)
+ 	line *a;
+ {
+ 	register int c;
+-	char *yesstr = catgets(catd, 1, 249, "y");
++	const char *yesstr = catgets(catd, 1, 249, "y");
+ 	int okay = -1;
+ 
+ 	if (cflag == 0)
+@@ -539,6 +553,7 @@ again:
+ }
+ 
+ #ifdef	notdef
++int
+ ex_getch()
+ {
+ 	char c;
+@@ -553,6 +568,7 @@ ex_getch()
+ }
+ #endif	/* notdef */
+ 
++static void
+ ugo(cnt, with)
+ 	int with;
+ 	int cnt;
+@@ -567,7 +583,8 @@ ugo(cnt, with)
+ int	casecnt;
+ bool	destuc;
+ 
+-dosub()
++static void
++dosub(void)
+ {
+ 	register char *lp, *sp, *rp;
+ 	int c;
+@@ -585,7 +602,7 @@ dosub()
+ 	while (lp < loc1)
+ 		*sp++ = *lp++;
+ 	casecnt = 0;
+-	while (c = *rp++) {
++	while ((c = *rp++) != 0) {
+ #ifdef	BIT8
+ 		c = cuc(c);
+ 		q = *qp++;
+@@ -661,12 +678,13 @@ ovflo:
+ 	}
+ 	lp = loc2;
+ 	loc2 = sp + (linebuf - genbuf);
+-	while (*sp++ = *lp++)
++	while ((*sp++ = *lp++) != 0)
+ 		if (sp >= &genbuf[LBSIZE])
+ 			goto ovflo;
+ 	strcLIN(genbuf);
+ }
+ 
++static int
+ fixcase(c)
+ 	register int c;
+ {
+@@ -683,7 +701,7 @@ fixcase(c)
+ 	return (c);
+ }
+ 
+-char *
++static char *
+ place(sp, l1, l2)
+ 	register char *sp, *l1, *l2;
+ {
+@@ -696,6 +714,7 @@ place(sp, l1, l2)
+ 	return (sp);
+ }
+ 
++static void
+ snote(total, lines)
+ 	register int total, lines;
+ {
+@@ -709,16 +728,17 @@ snote(total, lines)
+ 	flush();
+ }
+ 
++static void
+ cerror(s)
+-	char *s;
++	const char *s;
+ {
+ 	expbuf[0] = '\0';
+ 	error(s);
+ }
+ 
+ #ifdef	UXRE
+-refree(rp)
+-struct regexp *rp;
++static void
++refree(struct regexp *rp)
+ {
+ 	struct regexp *r1 = NULL, *r2 = NULL;
+ 	
+@@ -986,8 +1006,7 @@ complex:		cerror(catgets(catd, 1, 139,
+ }
+ 
+ int
+-execute(gf, addr)
+-line *addr;
++execute(int gf, line *addr)
+ {
+ 	char *p;
+ 	int c;
+@@ -1041,6 +1060,7 @@ line *addr;
+ 					goto complex; \
+ 			}
+ 
++int
+ compile(eof, oknl)
+ 	int eof;
+ 	int oknl;
+@@ -1123,7 +1143,7 @@ complex:
+ 			return (eof);
+ 		}
+ 		if (value(MAGIC)) {
+-			if (c != '*' && (c != '\\' || peekchar() != '{') ||
++			if ((c != '*' && (c != '\\' || peekchar() != '{')) ||
+ 					ep == expbuf) {
+ 				lastep = ep;
+ 			}
+@@ -1349,7 +1369,7 @@ magic:
+ 	"Badly formed re|Missing closing delimiter for regular expression"));
+ 
+ 		case '$':
+-			if (peekchar() == eof || peekchar() == EOF || oknl && peekchar() == '\n') {
++			if (peekchar() == eof || peekchar() == EOF || (oknl && peekchar() == '\n')) {
+ 				*ep++ = CDOL;
+ 				continue;
+ 			}
+@@ -1370,17 +1390,19 @@ defchar:
+ 	}
+ }
+ 
++int
+ same(a, b)
+ 	register int a, b;
+ {
+ 
+-	return (a == b || value(IGNORECASE) &&
+-	   ((islower(a) && toupper(a) == b) || (islower(b) && toupper(b) == a)));
++	return (a == b ||
++		(value(IGNORECASE) &&
++		 ((islower(a) && toupper(a) == b) ||
++		  (islower(b) && toupper(b) == a))));
+ }
+ 
+-ecmp(a, b, count)
+-	register char *a, *b;
+-	register int count;
++static int
++ecmp(register char *a, register char *b, register int count)
+ {
+ 	while (count--)
+ 		if (!same(*a++, *b++))
+@@ -1390,8 +1412,8 @@ ecmp(a, b, count)
+ 
+ char	*locs;
+ 
+-execute(gf, addr)
+-	line *addr;
++int
++execute(int gf, line *addr)
+ {
+ 	register char *p1, *p2;
+ 	register int c;
+@@ -1437,8 +1459,8 @@ execute(gf, addr)
+ 	return (0);
+ }
+ 
+-getrnge(str)
+-	register char *str;
++static void
++getrnge(register char *str)
+ {
+ 	low = *str++ & 0377;
+ 	siz = (*str & 0377) == 255 ? 20000 : (*str & 0377) - low;
+@@ -1446,6 +1468,7 @@ getrnge(str)
+ 
+ #define	uletter(c)	(isalpha(c) || c == '_')
+ 
++int
+ advance(lp, ep)
+ 	register char *lp, *ep;
+ {
+@@ -1628,8 +1651,9 @@ star:
+ 	}
+ }
+ 
++static int
+ cclass(set, c, af)
+-	register char *set;
++	register const char *set;
+ 	register int c;
+ 	int af;
+ {
diff --git a/editors/ex/patches/patch-ex__set_c b/editors/ex/patches/patch-ex__set_c
new file mode 100644
index 00000000000..a0a1537530f
--- /dev/null
+++ b/editors/ex/patches/patch-ex__set_c
@@ -0,0 +1,128 @@
+$NetBSD: patch-ex__set_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- avoid implicit int
+- use const for string constants
+- silence warnings about && and || precedence
+
+--- ex_set.c~	2012-12-27 21:58:42.000000000 +0000
++++ ex_set.c
+@@ -88,18 +88,19 @@ static char sccsid[] = "@(#)ex_set.c	1.8
+  */
+ char	optname[ONMSZ];
+ 
+-int setend __P((void));
+-int prall __P((void));
+-int propts __P((void));
+-int propt __P((register struct option *));
++static int setend __P((void));
++static void prall __P((void));
++static void propts __P((void));
++static void propt __P((register struct option *));
+ 
++void
+ set()
+ {
+-	register char *cp;
++	register const char *cp;
++	register char *cp2;
+ 	register struct option *op;
+ 	register int c;
+ 	bool no;
+-	extern short ospeed;
+ 
+ 	setnoaddr();
+ 	if (skipend()) {
+@@ -109,12 +110,12 @@ set()
+ 		return;
+ 	}
+ 	do {
+-		cp = optname;
++		cp2 = optname;
+ 		do {
+-			if (cp < &optname[ONMSZ - 2])
+-				*cp++ = getchar();
++			if (cp2 < &optname[ONMSZ - 2])
++				*cp2++ = getchar();
+ 		} while (isalnum(peekchar()));
+-		*cp = 0;
++		*cp2 = 0;
+ 		cp = optname;
+ 		if (eq("all", cp)) {
+ 			if (inopen)
+@@ -146,7 +147,7 @@ dontset:
+ 			cp = "window";
+ 		}
+ 		for (op = options; op < &options[NOPTS]; op++)
+-			if (eq(op->oname, cp) || op->oabbrev && eq(op->oabbrev, cp))
++			if (eq(op->oname, cp) || (op->oabbrev && eq(op->oabbrev, cp)))
+ 				break;
+ 		if (op->oname == 0)
+ 			serror(catgets(catd, 1, 159,
+@@ -193,18 +194,18 @@ printone:
+ 
+ 		case STRING:
+ 		case OTERM:
+-			cp = optname;
++			cp2 = optname;
+ 			while (!setend()) {
+-				if (cp >= &optname[ONMSZ])
++				if (cp2 >= &optname[ONMSZ])
+ 					error(catgets(catd, 1, 163,
+ 				"String too long@in option assignment"));
+ 				/* adb change:  allow whitepace in strings */
+-				if( (*cp = getchar()) == '\\')
++				if( (*cp2 = getchar()) == '\\')
+ 					if( peekchar() != EOF)
+-						*cp = getchar();
+-				cp++;
++						*cp2 = getchar();
++				cp2++;
+ 			}
+-			*cp = 0;
++			*cp2 = 0;
+ 			if (op->otype == OTERM) {
+ /*
+  * At first glance it seems like we shouldn't care if the terminal type
+@@ -237,13 +238,15 @@ setnext:
+ 	eol();
+ }
+ 
++static int
+ setend()
+ {
+ 
+ 	return (is_white(peekchar()) || endcmd(peekchar()));
+ }
+ 
+-prall()
++static void
++prall(void)
+ {
+ 	register int incr = (NOPTS + 2) / 3;
+ 	register int rows = incr;
+@@ -261,7 +264,8 @@ prall()
+ 	}
+ }
+ 
+-propts()
++static void
++propts(void)
+ {
+ 	register struct option *op;
+ 
+@@ -292,10 +296,10 @@ propts()
+ 	flush();
+ }
+ 
+-propt(op)
+-	register struct option *op;
++static void
++propt(register struct option *op)
+ {
+-	register char *name;
++	register const char *name;
+ 	
+ 	name = op->oname;
+ 
diff --git a/editors/ex/patches/patch-ex__subr_c b/editors/ex/patches/patch-ex__subr_c
new file mode 100644
index 00000000000..599b88f6ee2
--- /dev/null
+++ b/editors/ex/patches/patch-ex__subr_c
@@ -0,0 +1,686 @@
+$NetBSD: patch-ex__subr_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- use standard headers
+- avoid sloppy code that subtracts 1 from the base address of a char[]
+  (which isn't valid) (although this could be tidied further)
+- avoid implicit int
+- silence warnings about && and || precedence
+- declare void functions void
+- use const for string constants
+- use <ctype.h> functions properly
+- fix up function pointer casting mess
+- silence warnings about unused arguments
+- teach it about dead functions
+
+--- ex_subr.c~	2012-12-27 21:58:42.000000000 +0000
++++ ex_subr.c
+@@ -79,27 +79,33 @@ static char sccsid[] = "@(#)ex_subr.c	1.
+ 
+ /* from ex_subr.c	7.10.1 (2.11BSD) 1996/3/22 */
+ 
++#include <sys/ioctl.h>
++
+ #include "ex.h"
+ #include "ex_re.h"
+ #include "ex_tty.h"
+ #include "ex_vis.h"
+ 
++static int qcolumn __P((char *, char *));
++
+ /*
+  * Random routines, in alphabetical order.
+  */
+ 
++int
+ any(c, s)
+ 	int c;
+-	register char *s;
++	register const char *s;
+ {
+ 	register int x;
+ 
+-	while (x = *s++)
++	while ((x = *s++) != 0)
+ 		if (x == c)
+ 			return (1);
+ 	return (0);
+ }
+ 
++int
+ backtab(i)
+ 	register int i;
+ {
+@@ -114,6 +120,7 @@ backtab(i)
+ 	return (i);
+ }
+ 
++void
+ change()
+ {
+ 
+@@ -128,6 +135,7 @@ change()
+  * characters through position cp of the
+  * current line.
+  */
++int
+ column(cp)
+ 	register char *cp;
+ {
+@@ -141,6 +149,7 @@ column(cp)
+  * Ignore a comment to the end of the line.
+  * This routine eats the trailing newline so don't call newline().
+  */
++void
+ comment()
+ {
+ 	register int c;
+@@ -152,6 +161,7 @@ comment()
+ 		ungetchar(c);
+ }
+ 
++void
+ Copy(to, from, size)
+ 	register char *from, *to;
+ 	register int size;
+@@ -163,6 +173,7 @@ Copy(to, from, size)
+ 		while (--size > 0);
+ }
+ 
++void
+ copyw(to, from, size)
+ 	register line *from, *to;
+ 	register int size;
+@@ -174,6 +185,7 @@ copyw(to, from, size)
+ 		while (--size > 0);
+ }
+ 
++void
+ copywR(to, from, size)
+ 	register line *from, *to;
+ 	register int size;
+@@ -183,6 +195,7 @@ copywR(to, from, size)
+ 		to[size] = from[size];
+ }
+ 
++int
+ ctlof(c)
+ 	int c;
+ {
+@@ -190,6 +203,7 @@ ctlof(c)
+ 	return (c == DELETE ? '?' : c | ('A' - 1));
+ }
+ 
++void
+ dingdong()
+ {
+ 
+@@ -199,6 +213,7 @@ dingdong()
+ 		putch('\207');
+ }
+ 
++int
+ fixindent(indent)
+ 	int indent;
+ {
+@@ -215,8 +230,9 @@ fixindent(indent)
+ 	return (i);
+ }
+ 
++void
+ filioerr(cp)
+-	char *cp;
++	const char *cp;
+ {
+ 	register int oerrno = errno;
+ 
+@@ -238,6 +254,7 @@ genindent(indent)
+ 	return (cp);
+ }
+ 
++void
+ getDOT()
+ {
+ 
+@@ -257,6 +274,7 @@ getmark(c)
+ 	return (0);
+ }
+ 
++int
+ getn(cp)
+ 	register char *cp;
+ {
+@@ -269,6 +287,7 @@ getn(cp)
+ 	return (i);
+ }
+ 
++void
+ ignnEOF()
+ {
+ 	register int c = getchar();
+@@ -279,6 +298,7 @@ ignnEOF()
+ 		comment();
+ }
+ 
++int
+ is_white(c)
+ 	int c;
+ {
+@@ -286,11 +306,12 @@ is_white(c)
+ #ifndef	BIT8
+ 	return (c == ' ' || c == '\t');
+ #else
+-	return (isspace(c) && c != '\n' && c != '\r'
++	return (isspace((unsigned char)c) && c != '\n' && c != '\r'
+ 			&& c != '\f' && c != '\v');
+ #endif
+ }
+ 
++int
+ junk(c)
+ 	register int c;
+ {
+@@ -315,12 +336,14 @@ junk(c)
+ 	}
+ }
+ 
++void
+ killed()
+ {
+ 
+ 	killcnt(addr2 - addr1 + 1);
+ }
+ 
++void
+ killcnt(cnt)
+ 	register int cnt;
+ {
+@@ -343,6 +366,7 @@ killcnt(cnt)
+ 	putNFL();
+ }
+ 
++int
+ lineno(a)
+ 	line *a;
+ {
+@@ -350,24 +374,28 @@ lineno(a)
+ 	return (a - zero);
+ }
+ 
++int
+ lineDOL()
+ {
+ 
+ 	return (lineno(dol));
+ }
+ 
++int
+ lineDOT()
+ {
+ 
+ 	return (lineno(dot));
+ }
+ 
++void
+ markDOT()
+ {
+ 
+ 	markpr(dot);
+ }
+ 
++void
+ markpr(which)
+ 	line *which;
+ {
+@@ -379,6 +407,7 @@ markpr(which)
+ 	}
+ }
+ 
++int
+ markreg(c)
+ 	register int c;
+ {
+@@ -397,12 +426,13 @@ markreg(c)
+  * All others map to themselves.
+  */
+ char *
+-mesg(str)
+-	register char *str;
++mesg(arg)
++	const char *arg;
+ {
++	register char *str;
+ 	register char *cp;
+ 
+-	str = strcpy(genbuf, str);
++	str = strcpy(genbuf, arg);
+ 	for (cp = str; *cp; cp++)
+ 		switch (*cp) {
+ 
+@@ -422,12 +452,13 @@ mesg(str)
+ 	return (str);
+ }
+ 
++static void
+ merror1(seekpt)
+ #ifdef VMUNIX
+-	char *seekpt;
++	const char *seekpt;
+ #else
+ # ifdef lint
+-	char *seekpt;
++	const char *seekpt;
+ # else
+ 	int seekpt;
+ # endif
+@@ -444,20 +475,21 @@ merror1(seekpt)
+ }
+ 
+ /*VARARGS2*/
++void
+ #ifndef	__STDC__
+ merror(seekpt, i)
+ #ifdef VMUNIX
+-	char *seekpt;
++	const char *seekpt;
+ #else
+ # ifdef lint
+-	char *seekpt;
++	const char *seekpt;
+ # else
+ 	int seekpt;
+ # endif
+ #endif
+ 	int i;
+ #else
+-vmerror(char *seekpt, va_list ap)
++vmerror(const char *seekpt, va_list ap)
+ #endif
+ {
+ 
+@@ -482,7 +514,8 @@ vmerror(char *seekpt, va_list ap)
+ }
+ 
+ #ifdef	__STDC__
+-merror(char *cp, ...)
++void
++merror(const char *cp, ...)
+ {
+ 	va_list ap;
+ 
+@@ -494,6 +527,7 @@ merror(char *cp, ...)
+ }
+ #endif
+ 
++int
+ morelines()
+ {
+ #ifdef	_SC_PAGESIZE
+@@ -517,6 +551,7 @@ morelines()
+ #endif	/* !_SC_PAGESIZE */
+ }
+ 
++void
+ nonzero()
+ {
+ 
+@@ -527,6 +562,7 @@ nonzero()
+ 	}
+ }
+ 
++int
+ notable(i)
+ 	int i;
+ {
+@@ -534,7 +570,7 @@ notable(i)
+ 	return (hush == 0 && !inglobal && i > value(REPORT));
+ }
+ 
+-
++void
+ notempty()
+ {
+ 
+@@ -542,7 +578,7 @@ notempty()
+ 		error(catgets(catd, 1, 173, "No lines@in the buffer"));
+ }
+ 
+-
++void
+ netchHAD(cnt)
+ 	int cnt;
+ {
+@@ -550,10 +586,11 @@ netchHAD(cnt)
+ 	netchange(lineDOL() - cnt);
+ }
+ 
++void
+ netchange(i)
+ 	register int i;
+ {
+-	register char *cp;
++	register const char *cp;
+ 
+ 	if (i > 0)
+ 		notesgn = cp = catgets(catd, 1, 174, "more ");
+@@ -575,10 +612,11 @@ netchange(i)
+  * Print an escape sequence corresponding to c.
+  */
+ #ifdef	BIT8
++int
+ printof(c)
+ 	int c;
+ {
+-	char *nums = "01234567";
++	const char *nums = "01234567";
+ 	int d;
+ 
+ 	if (c < 040 || c == DELETE) {
+@@ -597,6 +635,7 @@ printof(c)
+ }
+ #endif
+ 
++void
+ putmark(addr)
+ 	line *addr;
+ {
+@@ -604,6 +643,7 @@ putmark(addr)
+ 	putmk1(addr, putline());
+ }
+ 
++void
+ putmk1(addr, n)
+ 	register line *addr;
+ 	int n;
+@@ -620,7 +660,7 @@ putmk1(addr, n)
+ 	*addr = n | oldglobmk;
+ }
+ 
+-char *
++const char *
+ plural(i)
+ 	long i;
+ {
+@@ -629,14 +669,15 @@ plural(i)
+ 			: catgets(catd, 1, 179, "s"));
+ }
+ 
+-int	qcount();
++static int qcount(int c);
+ short	vcntcol;
+ 
++static int
+ qcolumn(lim, gp)
+ 	register char *lim, *gp;
+ {
+ 	register int x = 0;
+-	int (*OO)();
++	int (*OO)(int);
+ 
+ 	OO = Outchar;
+ 	Outchar = qcount;
+@@ -653,18 +694,33 @@ qcolumn(lim, gp)
+ 	return (vcntcol);
+ }
+ 
++/*
++ * Like qcolumn() but doesn't require subtracting 1 from the first
++ * argument before calling it.
++ */
+ int
++qcolumn2(char *lim, char *gp)
++{
++	if (lim != NULL) {
++		lim--;
++	}
++	return qcolumn(lim, gp);
++}
++
++static int
+ qcount(c)
+ 	int c;
+ {
+ 
+ 	if (c == '\t') {
+ 		vcntcol += value(TABSTOP) - vcntcol % value(TABSTOP);
+-		return;
++		return c;
+ 	}
+ 	vcntcol++;
++	return c;
+ }
+ 
++void
+ reverse(a1, a2)
+ 	register line *a1, *a2;
+ {
+@@ -679,6 +735,7 @@ reverse(a1, a2)
+ 	}
+ }
+ 
++void
+ save(a1, a2)
+ 	line *a1;
+ 	register line *a2;
+@@ -714,24 +771,28 @@ save(a1, a2)
+ #endif
+ }
+ 
++void
+ save12()
+ {
+ 
+ 	save(addr1, addr2);
+ }
+ 
++void
+ saveall()
+ {
+ 
+ 	save(one, dol);
+ }
+ 
++int
+ span()
+ {
+ 
+ 	return (addr2 - addr1 + 1);
+ }
+ 
++void
+ synced()
+ {
+ 
+@@ -740,7 +801,7 @@ synced()
+ 	xchng = 0;
+ }
+ 
+-
++int
+ skipwh()
+ {
+ 	register int wh;
+@@ -754,17 +815,18 @@ skipwh()
+ }
+ 
+ /*VARARGS2*/
++void
+ #ifndef	__STDC__
+ smerror(seekpt, cp)
+ #ifdef lint
+-	char *seekpt;
++	const char *seekpt;
+ #else
+ 	int seekpt;
+ #endif
+-	char *cp;
++	const char *cp;
+ {
+ #else
+-vsmerror(char *seekpt, va_list ap)
++vsmerror(const char *seekpt, va_list ap)
+ {
+ 
+ #endif
+@@ -786,7 +848,8 @@ vsmerror(char *seekpt, va_list ap)
+ }
+ 
+ #ifdef	__STDC__
+-smerror(char *seekpt, ...)
++void
++smerror(const char *seekpt, ...)
+ {
+ 	va_list ap;
+ 
+@@ -808,13 +871,25 @@ strend(cp)
+ 	return (cp);
+ }
+ 
++const char *
++strendk(cp)
++	register const char *cp;
++{
++
++	while (*cp)
++		cp++;
++	return (cp);
++}
++
++void
+ strcLIN(dp)
+-	char *dp;
++	const char *dp;
+ {
+ 
+ 	CP(linebuf, dp);
+ }
+ 
++void
+ syserror()
+ {
+ 
+@@ -828,6 +903,7 @@ syserror()
+  * hitting a tab, where tabs are set every ts columns.  Work right for
+  * the case where col > TCOLUMNS, even if ts does not divide TCOLUMNS.
+  */
++int
+ tabcol(col, ts)
+ int col, ts;
+ {
+@@ -847,10 +923,10 @@ vfindcol(i)
+ 	int i;
+ {
+ 	register char *cp;
+-	register int (*OO)() = Outchar;
++	register int (*OO)(int) = Outchar;
+ 
+ 	Outchar = qcount;
+-	ignore(qcolumn(linebuf - 1, NOSTR));
++	ignore(qcolumn2(linebuf, NOSTR));
+ 	for (cp = linebuf; *cp && vcntcol < i; cp++)
+ 		putchar(*cp);
+ 	if (cp != linebuf)
+@@ -880,6 +956,7 @@ vpastwh(cp)
+ 	return (cp);
+ }
+ 
++int
+ whitecnt(cp)
+ 	register char *cp;
+ {
+@@ -911,13 +988,14 @@ Ignore(a)
+ }
+ 
+ Ignorf(a)
+-	int (*a)();
++	int (*a)(int);
+ {
+ 
+ 	a = a;
+ }
+ #endif
+ 
++void
+ markit(addr)
+ 	line *addr;
+ {
+@@ -937,10 +1015,12 @@ markit(addr)
+  */
+ int _ovno;
+ woid
+-onemt(signum)
++onemt(int signum)
+ {
+ 	int oovno;
+ 
++	(void)signum;
++
+ #ifndef	POSIX_1
+ 	signal(SIGEMT, onemt);
+ #endif
+@@ -963,8 +1043,9 @@ onemt(signum)
+  * are not removed.
+  */
+ woid
+-onhup(signum)
++onhup(int signum)
+ {
++	(void)signum;
+ 
+ 	/*
+ 	 * USG tty driver can send multiple HUP's!!
+@@ -993,9 +1074,11 @@ onhup(signum)
+  * suppressed in visual mode).
+  */
+ woid
+-onintr(signum)
++onintr(int signum)
+ {
+ 
++	(void)signum;
++
+ #ifndef	POSIX_1
+ #ifndef CBREAK
+ 	signal(SIGINT, onintr);
+@@ -1022,6 +1105,7 @@ onintr(signum)
+  * In some critical sections we turn interrupts off,
+  * but not very often.
+  */
++void
+ setrupt()
+ {
+ 
+@@ -1040,6 +1124,7 @@ setrupt()
+ 	}
+ }
+ 
++int
+ preserve()
+ {
+ 
+@@ -1063,6 +1148,8 @@ preserve()
+ }
+ 
+ #ifndef V6
++dead
++void
+ exitex(i)
+ 	int i;
+ {
+@@ -1081,7 +1168,7 @@ exitex(i)
+  * We have just gotten a susp.  Suspend and prepare to resume.
+  */
+ woid
+-onsusp(signum)
++onsusp(int signum)
+ {
+ 	ttymode f;
+ 	/* int omask; */
+@@ -1092,6 +1179,8 @@ onsusp(signum)
+ 	sigset_t set;
+ #endif
+ 
++	(void)signum;
++
+ 	f = setty(normf);
+ 	vnfl();
+ 	putpad(TE);
diff --git a/editors/ex/patches/patch-ex__tagio_c b/editors/ex/patches/patch-ex__tagio_c
new file mode 100644
index 00000000000..fc4314e0b67
--- /dev/null
+++ b/editors/ex/patches/patch-ex__tagio_c
@@ -0,0 +1,63 @@
+$NetBSD: patch-ex__tagio_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- avoid implicit int
+- don't misuse NULL
+- declare void functions void
+
+--- ex_tagio.c~	2003-09-03 19:53:02.000000000 +0000
++++ ex_tagio.c
+@@ -96,6 +96,7 @@ static int bcnt = 0;
+ static int b_size = MAXBSIZE;
+ static char *ibuf;
+ 
++int
+ topen(file, buf)
+ char *file, *buf;
+ {
+@@ -116,6 +117,7 @@ char *file, *buf;
+ 	return(fd);
+ }
+ 
++int
+ tseek(fd, off)
+ int fd;
+ off_t off;
+@@ -134,6 +136,7 @@ off_t off;
+ 	return(0);
+ }
+ 
++int
+ tgets(buf, cnt, fd)
+ register char *buf;
+ int cnt;
+@@ -145,19 +148,19 @@ int fd;
+ 	cc = offset;
+ 	if (cc == -1) {
+ 		if ((bcnt = read(fd, ibuf, b_size)) <= 0)
+-			return (NULL);
++			return 0;
+ 		cc = 0;
+ 		block = 0;
+ 	}
+ 	if (bcnt == 0)		/* EOF */
+-		return(NULL);
++		return 0;
+ 	cp = ibuf + cc;
+ 	while (--cnt > 0) {
+ 		if (++cc > bcnt) {
+ 			block += b_size;
+ 			if ((bcnt = read(fd, ibuf, b_size)) <= 0) {
+ 				offset = cc;
+-				return (NULL);
++				return 0;
+ 			}
+ 			cp = ibuf;
+ 			cc = 1;
+@@ -170,6 +173,7 @@ int fd;
+ 	return(1);
+ }
+ 
++void
+ tclose(fd)
+ int fd;
+ {
diff --git a/editors/ex/patches/patch-ex__temp_c b/editors/ex/patches/patch-ex__temp_c
new file mode 100644
index 00000000000..f3350266a31
--- /dev/null
+++ b/editors/ex/patches/patch-ex__temp_c
@@ -0,0 +1,255 @@
+$NetBSD: patch-ex__temp_c,v 1.1 2012/12/28 03:03:08 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- avoid implicit int
+- silence warnings about assignments in conditionals
+- silence signed/unsigned compiler warning
+- return values from non-void functions
+
+--- ex_temp.c~	2012-12-27 21:58:41.000000000 +0000
++++ ex_temp.c
+@@ -106,11 +106,14 @@ int	havetmp;
+ int	tfile = -1;
+ int	rfile = -1;
+ 
+-int YANKline __P((void));
+-int rbflush __P((void));
+-int blkio __P((bloc, char *, ssize_t (*) __P((int, void *, size_t))));
+-char *getblock __P((line, int));
++static void YANKline __P((void));
++static void rbflush __P((void));
++static void blkio __P((bloc, char *, ssize_t (*) __P((int, void *, size_t))));
++static char *getblock __P((line, int));
++static ssize_t shread __P((void));
++static int getREG __P((void));
+ 
++void
+ fileinit()
+ {
+ 	register char *p;
+@@ -196,6 +199,7 @@ dumbness:
+ /* 	brk((char *)fendcore); */
+ }
+ 
++void
+ cleanup(all)
+ 	bool all;
+ {
+@@ -213,6 +217,7 @@ cleanup(all)
+ 	}
+ }
+ 
++void
+ get_line(tl)
+ 	line tl;
+ {
+@@ -223,13 +228,14 @@ get_line(tl)
+ 	bp = getblock(tl, READ);
+ 	nl = nleft;
+ 	tl &= ~OFFMSK;
+-	while (*lp++ = *bp++)
++	while ((*lp++ = *bp++) != 0)
+ 		if (--nl == 0) {
+ 			bp = getblock(tl += INCRMT, READ);
+ 			nl = nleft;
+ 		}
+ }
+ 
++int
+ putline()
+ {
+ 	register char *bp, *lp;
+@@ -243,7 +249,7 @@ putline()
+ 	bp = getblock(tl, WRITE);
+ 	nl = nleft;
+ 	tl &= ~OFFMSK;
+-	while (*bp = *lp++) {
++	while ((*bp = *lp++) != 0) {
+ 		if (*bp++ == '\n') {
+ 			*--bp = 0;
+ 			linebp = lp;
+@@ -264,7 +270,7 @@ ssize_t	read __P((int, void *, size_t));
+ ssize_t	write __P((int, void *, size_t));
+ #endif
+ 
+-char *
++static char *
+ getblock(atl, iof)
+ 	line atl;
+ 	int iof;
+@@ -321,8 +327,8 @@ char	incorb[INCORB+1][BUFSIZ];
+ bloc	stilinc;	/* up to here not written yet */
+ #endif
+ 
++static void
+ #ifdef	__STDC__
+-int
+ blkio(bloc b, char *buf, ssize_t (*iofcn)(int, void *, size_t))
+ #else	/* !__STDC__ */
+ blkio(b, buf, iofcn)
+@@ -353,6 +359,7 @@ blkio(b, buf, iofcn)
+ }
+ 
+ #ifdef INCORB
++void
+ tlaste()
+ {
+ 
+@@ -360,6 +367,7 @@ tlaste()
+ 		dirtcnt = 0;
+ }
+ 
++void
+ tflush()
+ {
+ 	bbloc i = stilinc;
+@@ -375,6 +383,7 @@ tflush()
+  * Synchronize the state of the temporary file in case
+  * a crash occurs.
+  */
++void
+ synctmp()
+ {
+ 	register bbloc cnt;
+@@ -438,6 +447,7 @@ oops:
+ #endif
+ }
+ 
++void
+ TSYNC()
+ {
+ 
+@@ -493,6 +503,7 @@ short	rblock;
+ short	rnext;
+ char	*rbufcp;
+ 
++static void
+ regio(b, iofcn)
+ 	short b;
+ 	ssize_t (*iofcn) __P((int, void *, size_t));
+@@ -542,11 +553,12 @@ oops:
+ 	rblock = b;
+ }
+ 
++static int
+ REGblk()
+ {
+ 	register int i, j, m;
+ 
+-	for (i = 0; i < sizeof rused / sizeof rused[0]; i++) {
++	for (i = 0; i < (int)(sizeof rused / sizeof rused[0]); i++) {
+ 		m = (rused[i] ^ 0177777) & 0177777;
+ 		if (i == 0)
+ 			m &= ~1;
+@@ -562,10 +574,11 @@ REGblk()
+ 		}
+ 	}
+ 	error(catgets(catd, 1, 186, "Out of register space (ugh)"));
+-	/*NOTREACHED*/
++	/* XXX what do we do here? */
++	return 0;
+ }
+ 
+-struct	strreg *
++static struct	strreg *
+ mapreg(c)
+ 	register int c;
+ {
+@@ -575,8 +588,7 @@ mapreg(c)
+ 	return (isdigit(c) ? &strregs[('z'-'a'+1)+(c-'0')] : &strregs[c-'a']);
+ }
+ 
+-ssize_t	shread();
+-
++static void
+ KILLreg(c)
+ 	register int c;
+ {
+@@ -598,8 +610,8 @@ KILLreg(c)
+ }
+ 
+ /*VARARGS*/
+-ssize_t
+-shread()
++static ssize_t
++shread(void)
+ {
+ 	struct front { short a; short b; };
+ 
+@@ -608,9 +620,8 @@ shread()
+ 	return (0);
+ }
+ 
+-int	getREG();
+-
+-putreg(c)
++void
++putreg(int c)
+ {
+ 	register line *odot = dot;
+ 	register line *odol = dol;
+@@ -651,12 +662,14 @@ putreg(c)
+ 	notecnt = cnt;
+ }
+ 
+-partreg(c)
++int
++partreg(int c)
+ {
+ 
+ 	return (mapreg(c)->rg_flags);
+ }
+ 
++void
+ notpart(c)
+ 	register int c;
+ {
+@@ -665,6 +678,7 @@ notpart(c)
+ 		mapreg(c)->rg_flags = 0;
+ }
+ 
++static int
+ getREG()
+ {
+ 	register char *lp = linebuf;
+@@ -691,6 +705,7 @@ getREG()
+ 	}
+ }
+ 
++void
+ YANKreg(c)
+ 	register int c;
+ {
+@@ -729,6 +744,7 @@ YANKreg(c)
+ 	CP(linebuf,savelb);
+ }
+ 
++void
+ kshift()
+ {
+ 	register int i;
+@@ -738,6 +754,7 @@ kshift()
+ 		copy(mapreg(i+1), mapreg(i), sizeof (struct strreg));
+ }
+ 
++static void
+ YANKline()
+ {
+ 	register char *lp = linebuf;
+@@ -764,6 +781,7 @@ YANKline()
+ 		*rbufcp = 0;
+ }
+ 
++static void
+ rbflush()
+ {
+ 	register struct strreg *sp = strp;
+@@ -778,6 +796,7 @@ rbflush()
+ }
+ 
+ /* Register c to char buffer buf of size buflen */
++void
+ regbuf(c, buf, buflen)
+ char c;
+ char *buf;
diff --git a/editors/ex/patches/patch-ex__tty_c b/editors/ex/patches/patch-ex__tty_c
new file mode 100644
index 00000000000..497f08fb345
--- /dev/null
+++ b/editors/ex/patches/patch-ex__tty_c
@@ -0,0 +1,147 @@
+$NetBSD: patch-ex__tty_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- use standard headers
+- declare local functions (and data) static
+- declare void functions void
+- don't put function declarations inside other functions
+- return values from non-void functions
+
+--- ex_tty.c~	2003-03-18 20:29:07.000000000 +0000
++++ ex_tty.c
+@@ -79,14 +79,16 @@ static char sccsid[] = "@(#)ex_tty.c	1.1
+ 
+ /* from ex_tty.c	7.10.1 (2.11BSD GTE) 12/9/94 */
+ 
++#include <sys/ioctl.h>
++
+ #include "ex.h"
+ #include "ex_tty.h"
+ 
+ int ATTN = DELETE;
+ 
+-int gettmode __P((void));
+-char *gettlongname __P((char *, char *));
+-int zap __P((void));
++static const char *gettlongname __P((char *, const char *));
++static void zap __P((void));
++static int countnum(int ch);
+ 
+ /*
+  * Terminal type initialization routines,
+@@ -95,6 +97,7 @@ int zap __P((void));
+  */
+ /* short	ospeed = -1;	mjm: def also in tputs.c of termcap.a  */
+ 
++void
+ gettmode()
+ {
+ #ifdef	POSIX_1
+@@ -171,7 +174,7 @@ gettmode()
+ }
+ 
+ char *xPC;
+-char **sstrs[] = {
++static char **sstrs[] = {
+ 	&AL, &BC, &BT, &CD, &CE, &CL, &CM, &xCR, &xCS, &DC, &DL, &DM, &DO,
+ 	&ED, &EI, &F0, &F1, &F2, &F3, &F4, &F5, &F6, &F7, &F8, &F9,
+ 	&HO, &IC, &IM, &IP, &KD, &KE, &KH, &KL, &KR, &KS, &KU, &LL, &ND, &xNL,
+@@ -189,13 +192,17 @@ bool *sflags[] = {
+ char **fkeys[10] = {
+ 	&F0, &F1, &F2, &F3, &F4, &F5, &F6, &F7, &F8, &F9
+ };
++
++void
+ setterm(type)
+-	char *type;
++	const char *type;
+ {
+-	char *tgoto();
+ 	register int unknown;
+ 	char ltcbuf[TCBUFSIZE];
+ 
++	/* to avoid needing to make all the terminal strings const */
++	static char empty[] = "";
++
+ 	if (type[0] == 0)
+ 		type = "xx";
+ 	unknown = 0;
+@@ -221,13 +228,13 @@ setterm(type)
+ 	 * Handle funny termcap capabilities
+ 	 */
+ 	if (xCS && SC && RC) {
+-		if (AL==NULL) AL="";
+-		if (DL==NULL) DL="";
++		if (AL==NULL) AL=empty;
++		if (DL==NULL) DL=empty;
+ 	}
+-	if (AL_PARM && AL==NULL) AL="";
+-	if (DL_PARM && DL==NULL) DL="";
+-	if (IC && IM==NULL) IM="";
+-	if (IC && EI==NULL) EI="";
++	if (AL_PARM && AL==NULL) AL=empty;
++	if (DL_PARM && DL==NULL) DL=empty;
++	if (IC && IM==NULL) IM=empty;
++	if (IC && EI==NULL) EI=empty;
+ 	if (!GT) BT=NULL;	/* If we can't tab, we can't backtab either */
+ 
+ #ifndef	USG3TTY
+@@ -313,6 +320,7 @@ setterm(type)
+ 				"%s: Unknown terminal type"), type);
+ }
+ 
++void
+ setsize()
+ {
+ 	register int l, i;
+@@ -369,9 +377,10 @@ setsize()
+ 		TLINES = 2;
+ }
+ 
+-zap()
++static void
++zap(void)
+ {
+-	register char *namp;
++	register const char *namp;
+ 	register bool **fp;
+ 	register char ***sp;
+ 	int flag;
+@@ -397,10 +406,10 @@ zap()
+ 	} while (*namp);
+ }
+ 
+-char *
++static const char *
+ gettlongname(bp, def)
+ 	register char *bp;
+-	char *def;
++	const char *def;
+ {
+ 	register char *cp;
+ 
+@@ -438,11 +447,11 @@ fkey(i)
+  * than AL vs SR, won't be really affected.)
+  */
+ static int costnum;
++
++int
+ cost(str)
+-char *str;
++const char *str;
+ {
+-	int countnum();
+-
+ 	if (str == NULL || *str=='O')	/* OOPS */
+ 		return 10000;	/* infinity */
+ 	costnum = 0;
+@@ -451,8 +460,10 @@ char *str;
+ }
+ 
+ /* ARGSUSED */
++static int
+ countnum(ch)
+ char ch;
+ {
+ 	costnum++;
++	return ch;
+ }
diff --git a/editors/ex/patches/patch-ex__tty_h b/editors/ex/patches/patch-ex__tty_h
new file mode 100644
index 00000000000..6a2f94961c2
--- /dev/null
+++ b/editors/ex/patches/patch-ex__tty_h
@@ -0,0 +1,39 @@
+$NetBSD: patch-ex__tty_h,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- use const for string constants
+- declare void functions void
+- don't declare local functions in header files
+
+--- ex_tty.h.orig	2002-02-06 00:43:55.000000000 +0000
++++ ex_tty.h
+@@ -259,9 +259,9 @@ var	short	costRP;	/* likewise for RIGHT_
+ # define MAXCHARMACS	1536	/* max # of chars total in macros */
+ #endif
+ struct maps {
+-	char *cap;	/* pressing button that sends this.. */
+-	char *mapto;	/* .. maps to this string */
+-	char *descr;	/* legible description of key */
++	const char *cap;	/* pressing button that sends this.. */
++	const char *mapto;	/* .. maps to this string */
++	const char *descr;	/* legible description of key */
+ 	bool hadthis;	/* did this mapping already (avoid recursion) */
+ };
+ var	struct maps arrows[MAXNOMACS];	/* macro defs - 1st 5 built in */
+@@ -275,12 +275,11 @@ var	bool	anyabbrs;	/* true if abbr or un
+ var	char	ttynbuf[20];	/* result of ttyname() */
+ var	int	ttymesg;	/* original mode of users tty */
+ 
+-int addmac __P((register char *, register char *, register char *, register struct maps *));
++void addmac __P((register char *, register const char *, register const char *, register struct maps *));
+ ttymode ostart __P((void));
+-int normal __P((ttymode));
+-int ostop __P((ttymode));
++void normal __P((ttymode));
++void ostop __P((ttymode));
+ ttymode setty __P((ttymode));
+-ttymode unixex __P((char *, char *, int, int));
+-int unixwt __P((int, ttymode));
+-int ovend __P((ttymode));
++ttymode unixex __P((const char *, char *, int, int));
++void unixwt __P((int, ttymode));
+ int map __P((register int, register struct maps *));
diff --git a/editors/ex/patches/patch-ex__unix_c b/editors/ex/patches/patch-ex__unix_c
new file mode 100644
index 00000000000..49b7ca304ff
--- /dev/null
+++ b/editors/ex/patches/patch-ex__unix_c
@@ -0,0 +1,65 @@
+$NetBSD: patch-ex__unix_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare void functions void
+- use const for string constants
+
+--- ex_unix.c~	2003-09-03 19:53:02.000000000 +0000
++++ ex_unix.c
+@@ -95,6 +95,7 @@ static char sccsid[] = "@(#)ex_unix.c	1.
+  * First part of a shell escape,
+  * parse the line, expanding # and % and ! and printing if implied.
+  */
++void
+ unix0(warn)
+ 	bool warn;
+ {
+@@ -217,7 +218,8 @@ uexp:
+  */
+ ttymode
+ unixex(opt, up, newstdin, mode)
+-	char *opt, *up;
++	const char *opt;
++	char *up;
+ 	int newstdin, mode;
+ {
+ 	int pvec[2];
+@@ -299,6 +301,7 @@ unixex(opt, up, newstdin, mode)
+  * F is for restoration of tty mode if from open/visual.
+  * C flags suppression of printing.
+  */
++void
+ unixwt(c, f)
+ 	bool c;
+ 	ttymode f;
+@@ -328,6 +331,7 @@ unixwt(c, f)
+  * the filter, then a child editor is created to write it.
+  * If output is catch it from io which is created by unixex.
+  */
++void
+ filter(mode)
+ 	register int mode;
+ {
+@@ -391,6 +395,7 @@ filter(mode)
+  * Set up to do a recover, getting io to be a pipe from
+  * the recover process.
+  */
++void
+ recover()
+ {
+ 	static int pvec[2];
+@@ -420,6 +425,7 @@ recover()
+ /*
+  * Wait for the process (pid an external) to complete.
+  */
++void
+ waitfor()
+ {
+ 	int stat = 0;
+@@ -449,6 +455,7 @@ waitfor()
+  * exits non-zero, force not edited; otherwise force
+  * a write.
+  */
++void
+ revocer()
+ {
+ 
diff --git a/editors/ex/patches/patch-ex__v_c b/editors/ex/patches/patch-ex__v_c
new file mode 100644
index 00000000000..f25572baa51
--- /dev/null
+++ b/editors/ex/patches/patch-ex__v_c
@@ -0,0 +1,155 @@
+$NetBSD: patch-ex__v_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- don't declare local functions in headers
+- silence warnings about assignments in conditionals
+- avoid implicit int
+- silence warnings about unused arguments
+
+--- ex_v.c~	2012-12-27 21:58:42.000000000 +0000
++++ ex_v.c
+@@ -127,9 +127,10 @@ static char sccsid[] = "@(#)ex_v.c	1.14 
+ 
+ JMP_BUF venv;
+ 
+-int ovbeg __P((void));
+-int setwind __P((void));
+-int vok __P((cell *));
++static void ovbeg __P((void));
++static void ovend __P((ttymode f));
++static void setwind __P((void));
++static void vok __P((cell *));
+ 
+ /*
+  * Enter open mode
+@@ -137,6 +138,7 @@ int vok __P((cell *));
+ #ifdef u370
+ cell	atube[TUBESIZE+LBSIZE];
+ #endif
++void
+ oop()
+ {
+ 	register char *ic;
+@@ -146,7 +148,7 @@ oop()
+ 	ttymode f;	/* mjm: was register */
+ 	int resize;
+ 
+-	if (resize = SETJMP(venv)) {
++	if ((resize = SETJMP(venv)) != 0) {
+ 		setsize();
+ 		initev = (char *)0;
+ 		inopen = 0;
+@@ -217,7 +219,8 @@ oop()
+ #endif
+ }
+ 
+-ovbeg()
++static void
++ovbeg(void)
+ {
+ 
+ 	if (!value(OPEN))
+@@ -233,8 +236,8 @@ ovbeg()
+ 	dot = addr2;
+ }
+ 
+-ovend(f)
+-	ttymode f;
++static void
++ovend(ttymode f)
+ {
+ 
+ 	splitw++;
+@@ -255,6 +258,7 @@ ovend(f)
+ /*
+  * Enter visual mode
+  */
++void
+ vop()
+ {
+ 	register int c;
+@@ -292,7 +296,7 @@ toopen:
+ 			goto toopen;
+ 		error(catgets(catd, 1, 214, "Visual requires scrolling"));
+ 	}
+-	if (resize = SETJMP(venv)) {
++	if ((resize = SETJMP(venv)) != 0) {
+ 		setsize();
+ 		initev = (char *)0;
+ 		inopen = 0;
+@@ -333,6 +337,7 @@ toopen:
+  * empty buffer since routines internally
+  * demand at least one line.
+  */
++void
+ fixzero()
+ {
+ 
+@@ -361,6 +366,7 @@ fixzero()
+  * at some point, and then quit from the visual and undo
+  * you get the old file back.  Somewhat weird.
+  */
++void
+ savevis()
+ {
+ 
+@@ -376,6 +382,7 @@ savevis()
+  * Restore a sensible state after a visual/open, moving the saved
+  * stuff back to [unddol,dol], and killing the partial line kill indicators.
+  */
++void
+ undvis()
+ {
+ 
+@@ -396,6 +403,7 @@ undvis()
+  * Set the window parameters based on the base state bastate
+  * and the available buffer space.
+  */
++static void
+ setwind()
+ {
+ 
+@@ -436,6 +444,7 @@ setwind()
+  * If so, then divide the screen buffer up into lines,
+  * and initialize a bunch of state variables before we start.
+  */
++static void
+ vok(atube)
+ 	register cell *atube;
+ {
+@@ -478,11 +487,13 @@ vok(atube)
+ 
+ #ifdef CBREAK
+ woid
+-vintr(signum)
++vintr(int signum)
+ {
+ 	extern JMP_BUF readbuf;
+ 	extern int doingread;
+ 
++	(void)signum;
++
+ 	signal(SIGINT, vintr);
+ 	if (vcatch)
+ 		onintr(SIGINT);
+@@ -499,6 +510,7 @@ vintr(signum)
+  * Set the size of the screen to size lines, to take effect the
+  * next time the screen is redrawn.
+  */
++void
+ vsetsiz(size)
+ 	int size;
+ {
+@@ -517,8 +529,10 @@ vsetsiz(size)
+ 
+ #ifdef	SIGWINCH
+ woid
+-onwinch(signum)
++onwinch(int signum)
+ {
++	(void)signum;
++
+ 	vsave();
+ 	setty(normf);
+ 	LONGJMP(venv, 1);
diff --git a/editors/ex/patches/patch-ex__vadj_c b/editors/ex/patches/patch-ex__vadj_c
new file mode 100644
index 00000000000..577eb6dc166
--- /dev/null
+++ b/editors/ex/patches/patch-ex__vadj_c
@@ -0,0 +1,259 @@
+$NetBSD: patch-ex__vadj_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- avoid implicit int
+- silence warnings about braces
+- silence warnings about && and || precedence
+
+--- ex_vadj.c~	2012-12-27 21:58:42.000000000 +0000
++++ ex_vadj.c
+@@ -90,12 +90,12 @@ static char sccsid[] = "@(#)ex_vadj.c	1.
+  * screen cleanup after a change.
+  */
+ 
+-int vdellin __P((int, int, int));
+-int vscroll __P((register int));
+-int vadjAL __P((int, int));
+-int vcloseup __P((int, register int));
+-int vopenup __P((int, int, int));
+-int vadjDL __P((int, int));
++static void vdellin __P((int, int, int));
++static void vscroll __P((register int));
++static void vadjAL __P((int, int));
++static void vcloseup __P((int, register int));
++static void vopenup __P((int, int, int));
++static void vadjDL __P((int, int));
+ 
+ /*
+  * Display a new line at physical line p, returning
+@@ -106,6 +106,7 @@ int vadjDL __P((int, int));
+  * on the screen in which case the line may actually end up
+  * somewhere other than line p.
+  */
++void
+ vopen(tp, p)
+ 	line *tp;
+ 	int p;
+@@ -118,11 +119,12 @@ vopen(tp, p)
+ 		tfixnl(), fprintf(trace, "vopen(%d, %d)\n", lineno(tp), p);
+ #endif
+ 	if (state != VISUAL) {
+-		if (vcnt)
++		if (vcnt) {
+ 			if (hold & HOLDROL)
+ 				vup1();
+ 			else
+ 				vclean();
++		}
+ 
+ 		/*
+ 		 * Forget all that we once knew.
+@@ -169,6 +171,7 @@ vopen(tp, p)
+ /*
+  * Redisplay logical line l at physical line p with line number lineno.
+  */
++int
+ vreopen(p, lineno, l)
+ 	int p, lineno, l;
+ {
+@@ -256,6 +259,7 @@ vreopen(p, lineno, l)
+  * delete some (blank) lines from the top of the screen so that
+  * later inserts will not push stuff off the bottom.
+  */
++int
+ vglitchup(l, o)
+ 	int l, o;
+ {
+@@ -297,6 +301,7 @@ vglitchup(l, o)
+  * Insert cnt blank lines before line p,
+  * logically and (if supported) physically.
+  */
++void
+ vinslin(p, cnt, l)
+ 	register int p, cnt;
+ 	int l;
+@@ -378,9 +383,11 @@ vinslin(p, cnt, l)
+  * it ourselves (brute force) we will squish out @ lines in the process
+  * if this will save us work.
+  */
++static void
+ vopenup(cnt, could, l)
+ 	int cnt;
+ 	bool could;
++	int l;
+ {
+ 	register struct vlinfo *vc = &vlinfo[l + 1];
+ 	register struct vlinfo *ve = &vlinfo[vcnt];
+@@ -423,6 +430,7 @@ vopenup(cnt, could, l)
+  * Adjust data structure internally to account for insertion of
+  * blank lines on the screen.
+  */
++static void
+ vadjAL(p, cnt)
+ 	int p, cnt;
+ {
+@@ -451,6 +459,7 @@ vadjAL(p, cnt)
+  * Roll the screen up logically and physically
+  * so that line dl is the bottom line on the screen.
+  */
++void
+ vrollup(dl)
+ 	int dl;
+ {
+@@ -469,6 +478,7 @@ vrollup(dl)
+ 	destline = dl - cnt, destcol = dc;
+ }
+ 
++void
+ vup1()
+ {
+ 
+@@ -480,6 +490,7 @@ vup1()
+  * If doclr is true, do a clear eol if the terminal
+  * has standout (to prevent it from scrolling up)
+  */
++void
+ vmoveitup(cnt, doclr)
+ 	register int cnt;
+ 	bool doclr;
+@@ -513,6 +524,7 @@ vmoveitup(cnt, doclr)
+ /*
+  * Scroll the screen up cnt lines logically.
+  */
++static void
+ vscroll(cnt)
+ 	register int cnt;
+ {
+@@ -541,6 +553,7 @@ vscroll(cnt)
+ /*
+  * Discard logical lines due to physical wandering off the screen.
+  */
++void
+ vscrap()
+ {
+ 	register int i, j;
+@@ -591,6 +604,7 @@ vscrap()
+  * Repaint the screen, with cursor at curs, aftern an arbitrary change.
+  * Handle notification on large changes.
+  */
++void
+ vrepaint(curs)
+ 	char *curs;
+ {
+@@ -605,15 +619,16 @@ vrepaint(curs)
+ 	/*
+ 	 * Deal with a totally useless display.
+ 	 */
+-	if (vcnt == 0 || vcline < 0 || vcline > vcnt || holdupd && state != VISUAL) {
++	if (vcnt == 0 || vcline < 0 || vcline > vcnt || (holdupd && state != VISUAL)) {
+ 		register line *odol = dol;
+ 
+ 		vcnt = 0;
+-		if (holdupd)
++		if (holdupd) {
+ 			if (state == VISUAL)
+ 				ignore(peekkey());
+ 			else
+ 				vup1();
++		}
+ 		holdupd = 0;
+ 		if (odol == zero)
+ 			fixzero();
+@@ -682,6 +697,7 @@ vrepaint(curs)
+  * line after last won't completely fit.  The routine vsync is
+  * more conservative and much less work on dumb terminals.
+  */
++void
+ vredraw(p)
+ 	register int p;
+ {
+@@ -803,6 +819,7 @@ vredraw(p)
+  * Do the real work in deleting cnt lines starting at line p from
+  * the display.  First affected line is line l.
+  */
++static void
+ vdellin(p, cnt, l)
+ 	int p, cnt, l;
+ {
+@@ -849,6 +866,7 @@ vdellin(p, cnt, l)
+ /*
+  * Adjust internal physical screen image to account for deleted lines.
+  */
++static void
+ vadjDL(p, cnt)
+ 	int p, cnt;
+ {
+@@ -878,12 +896,14 @@ vadjDL(p, cnt)
+  * In any case, if the redraw option is set then all syncs map to redraws
+  * as if vsync didn't exist.
+  */
++void
+ vsyncCL()
+ {
+ 
+ 	vsync(LINE(vcline));
+ }
+ 
++void
+ vsync(p)
+ 	register int p;
+ {
+@@ -898,6 +918,7 @@ vsync(p)
+  * The guts of a sync.  Similar to redraw but
+  * just less ambitous.
+  */
++void
+ vsync1(p)
+ 	register int p;
+ {
+@@ -933,7 +954,7 @@ vsync1(p)
+ 		 * the current line, or if this line is piled under the
+ 		 * next line (vreplace does this and we undo it).
+ 		 */
+-		if (l == 0 && state != VISUAL ||
++		if ((l == 0 && state != VISUAL) ||
+ 		    (l < vcnt && (vp->vliny <= p || vp[0].vliny == vp[1].vliny))) {
+ 			if (l == 0 || vp->vliny < p || (vp->vflags & VDIRT)) {
+ 				if (l == vcline)
+@@ -972,6 +993,7 @@ vsync1(p)
+  * Subtract (logically) cnt physical lines from the 
+  * displayed position of lines starting with line l.
+  */
++static void
+ vcloseup(l, cnt)
+ 	int l;
+ 	register int cnt;
+@@ -996,6 +1018,7 @@ vcloseup(l, cnt)
+  *
+  * Many boundary conditions here.
+  */
++void
+ vreplace(l, cnt, newcnt)
+ 	int l, cnt, newcnt;
+ {
+@@ -1054,7 +1077,7 @@ vreplace(l, cnt, newcnt)
+ 	 * over them, since otherwise we will push them
+ 	 * slowly off the screen, a clear lose.
+ 	 */
+-	if (cnt == newcnt || vcnt - l == newcnt && AL && DL) {
++	if (cnt == newcnt || (vcnt - l == newcnt && AL && DL)) {
+ 		if (cnt > 1 && l + cnt > vcnt)
+ 			savenote++;
+ 		vdirty(l, newcnt);
+@@ -1135,6 +1158,7 @@ skip:
+  * If we are in a scroll ^D within hardcopy open then all this
+  * is suppressed.
+  */
++void
+ sethard()
+ {
+ 
+@@ -1155,6 +1179,7 @@ sethard()
+  * as dirty so that they will be checked for correct
+  * display at next sync/redraw.
+  */
++void
+ vdirty(base, i)
+ 	register int base, i;
+ {
diff --git a/editors/ex/patches/patch-ex__version_c b/editors/ex/patches/patch-ex__version_c
new file mode 100644
index 00000000000..8f6c4956db1
--- /dev/null
+++ b/editors/ex/patches/patch-ex__version_c
@@ -0,0 +1,21 @@
+$NetBSD: patch-ex__version_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare void functions void
+- use const for string constants
+
+--- ex_version.c~	2004-01-03 14:11:39.000000000 +0000
++++ ex_version.c
+@@ -74,10 +74,11 @@
+  */
+ 
+ #include "ex.h"
++#include "ex_proto.h"
+ 
+-static char *versionstring = "@(#)Version 3.7, 6/7/85 (gritter) 1/3/04";
++static const char *versionstring = "@(#)Version 3.7, 6/7/85 (gritter) 1/3/04";
+ 
+-int
++void
+ printver()
+ {
+ 	printf("%s%s%s", versionstring + 4,
diff --git a/editors/ex/patches/patch-ex__vget_c b/editors/ex/patches/patch-ex__vget_c
new file mode 100644
index 00000000000..5e55b18ec04
--- /dev/null
+++ b/editors/ex/patches/patch-ex__vget_c
@@ -0,0 +1,258 @@
+$NetBSD: patch-ex__vget_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- avoid implicit int
+- use const for string constants
+- silence warnings about assignments in conditionals
+- silence warnings about && and || precedence
+- silence warnings about unused arguments
+
+--- ex_vget.c~	2012-12-27 21:58:42.000000000 +0000
++++ ex_vget.c
+@@ -89,12 +89,13 @@ static char sccsid[] = "@(#)ex_vget.c	1.
+  * large changes which appears in the echo area.
+  */
+ 
+-int addto __P((cell *, char *));
+-int fastpeekkey __P((void));
++static void addto __P((cell *, char *));
++static int fastpeekkey __P((void));
+ 
+ /*
+  * Return the key.
+  */
++void
+ ungetkey(c)
+ 	int c;		/* mjm: char --> int */
+ {
+@@ -106,6 +107,7 @@ ungetkey(c)
+ /*
+  * Return a keystroke, but never a ^@.
+  */
++int
+ getkey()
+ {
+ 	register int c;		/* mjm: char --> int */
+@@ -121,6 +123,7 @@ getkey()
+ /*
+  * Tell whether next keystroke would be a ^@.
+  */
++int
+ peekbr()
+ {
+ 
+@@ -139,13 +142,14 @@ int	doingread = 0;
+  * from repeating commands with .), and finally new
+  * keystrokes.
+  */
++int
+ getbr()
+ {
+ 	char ch;
+ 	register int c;
+ #ifdef	UCVISUAL
+ 	register int d;
+-	register char *colp;
++	register const char *colp;
+ #endif
+ #ifdef BEEHIVE
+ 	int cnt;
+@@ -248,7 +252,7 @@ again:
+                                 d = toupper(c);
+                         else {
+                                 colp = "({)}!|^~'~";
+-                                while (d = *colp++)
++                                while ((d = *colp++) != 0)
+                                         if (d == c) {
+                                                 d = *colp++;
+                                                 break;
+@@ -292,6 +296,7 @@ again:
+  * Get a key, but if a delete, quit or attention
+  * is typed return 0 so we will abort a partial command.
+  */
++int
+ getesc()
+ {
+ 	register int c;
+@@ -320,6 +325,7 @@ case_ATTN:
+ /*
+  * Peek at the next keystroke.
+  */
++int
+ peekkey()
+ {
+ 
+@@ -331,7 +337,8 @@ peekkey()
+  * Read a line from the echo area, with single character prompt c.
+  * A return value of 1 means the user blewit or blewit away.
+  */
+-readecho(c)
++int
++readecho(int c)
+ {
+ 	register char *sc = cursor;
+ 	register int (*OP)();
+@@ -383,6 +390,7 @@ blewit:
+  * the purposes of repeat, so copy it from
+  * the working to the previous command buffer.
+  */
++void
+ setLAST()
+ {
+ 
+@@ -400,6 +408,7 @@ setLAST()
+  * If the insertion buffer oveflows, then destroy
+  * the repeatability of the insert.
+  */
++void
+ addtext(cp)
+ 	char *cp;
+ {
+@@ -415,6 +424,7 @@ addtext(cp)
+ 		lastcmd[0] = 0;
+ }
+ 
++void
+ setDEL()
+ {
+ 
+@@ -424,6 +434,7 @@ setDEL()
+ /*
+  * Put text from cursor upto wcursor in BUF.
+  */
++void
+ setBUF(BUF)
+ 	register cell *BUF;
+ {
+@@ -437,6 +448,7 @@ setBUF(BUF)
+ 	*wp = c;
+ }
+ 
++static void
+ addto(buf, str)
+ 	register cell *buf;
+ 	register char *str;
+@@ -467,12 +479,13 @@ addto(buf, str)
+  * to do this for open modes now; return and save for later
+  * notification in visual.
+  */
++int
+ noteit(must)
+ 	bool must;
+ {
+ 	register int sdl = destline, sdc = destcol;
+ 
+-	if (notecnt < 2 || !must && state == VISUAL)
++	if (notecnt < 2 || (!must && state == VISUAL))
+ 		return (0);
+ 	splitw++;
+ 	if (WBOT == WECHO)
+@@ -483,7 +496,7 @@ noteit(must)
+ 		putchar('s');
+ 	if (*notenam) {
+ 		printf(" %s", notenam);
+-		if (*(strend(notenam) - 1) != 'e')
++		if (*(strendk(notenam) - 1) != 'e')
+ 			putchar('e');
+ 		putchar('d');
+ 	}
+@@ -502,7 +515,8 @@ noteit(must)
+  * Rrrrringgggggg.
+  * If possible, use flash (VB).
+  */
+-beep()
++void
++beep(void)
+ {
+ 
+ 	if (VB && value(FLASH))
+@@ -517,13 +531,14 @@ beep()
+  * motions.  I.e. on an adm3a we might map ^K to ^P.
+  * DM1520 for example has a lot of mappable characters.
+  */
+-
++int
+ map(c,maps)
+ 	register int c;
+ 	register struct maps *maps;
+ {
+ 	register int d;
+-	register char *p, *q;
++	register const char *p;
++	register char *q;
+ 	char b[10];	/* Assumption: no keypad sends string longer than 10 */
+ 
+ 	/*
+@@ -559,7 +574,7 @@ map(c,maps)
+ 		if (trace)
+ 			fprintf(trace,"\ntry '%s', ",maps[d].cap);
+ #endif
+-		if (p = maps[d].cap) {
++		if ((p = maps[d].cap) != NULL) {
+ 			for (q=b; *p; p++, q++) {
+ #ifdef MDEBUG
+ 				if (trace)
+@@ -633,8 +648,9 @@ map(c,maps)
+  * is false for, for example, pushing back lookahead from fastpeekkey(),
+  * since otherwise two fast escapes can clobber our undo.
+  */
++void
+ macpush(st, canundo)
+-char *st;
++const char *st;
+ int canundo;
+ {
+ 	char tmpbuf[BUFSIZ];
+@@ -671,8 +687,8 @@ int canundo;
+ }
+ 
+ #ifdef TRACE
+-visdump(s)
+-char *s;
++static void
++visdump(const char *s)
+ {
+ 	register int i;
+ 
+@@ -688,8 +704,8 @@ char *s;
+ 	tvliny();
+ }
+ 
+-vudump(s)
+-char *s;
++void
++vudump(const char *s)
+ {
+ 	register line *p;
+ 	char savelb[1024];
+@@ -717,6 +733,7 @@ char *s;
+  * Get a count from the keyed input stream.
+  * A zero count is indistinguishable from no count.
+  */
++int
+ vgetcnt()
+ {
+ 	register int c, cnt;
+@@ -734,8 +751,11 @@ vgetcnt()
+ 	return(cnt);
+ }
+ 
+-woid
+-trapalarm(signum) {
++static woid
++trapalarm(int signum)
++{
++	(void)signum;
++
+ 	alarm(0);
+ 	if (vcatch)
+ 		LONGJMP(vreslab,1);
+@@ -747,6 +767,7 @@ trapalarm(signum) {
+  * a machine generated sequence (such as a function pad from an escape
+  * flavor terminal) but fail for a human hitting escape then waiting.
+  */
++static int
+ fastpeekkey()
+ {
+ 	shand Oint;
diff --git a/editors/ex/patches/patch-ex__vis_h b/editors/ex/patches/patch-ex__vis_h
new file mode 100644
index 00000000000..6f6abca2521
--- /dev/null
+++ b/editors/ex/patches/patch-ex__vis_h
@@ -0,0 +1,36 @@
+$NetBSD: patch-ex__vis_h,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- use const for string constants
+- declare void functions void
+- remove stray extra copies of function declarations from elsewhere
+
+--- ex_vis.h~	2012-12-27 21:58:42.000000000 +0000
++++ ex_vis.h
+@@ -300,8 +300,8 @@ var	bool	lasthad;	/* Last command had a 
+ var	short	lastvgk;	/* Previous input key, if not from keyboard */
+ var	short	lastreg;	/* Register with last command */
+ var	char	*ncols['z'-'a'+2];	/* Cursor positions of marks */
+-var	char	*notenam;	/* Name to be noted with change count */
+-var	char	*notesgn;	/* Change count from last command */
++var	const char *notenam;	/* Name to be noted with change count */
++var	const char *notesgn;	/* Change count from last command */
+ var	char	op;		/* Operation of current command */
+ var	short	Peekkey;	/* Peek ahead key */
+ var	bool	rubble;		/* Line is filthy (in hardcopy open), redraw! */
+@@ -333,13 +333,7 @@ var	cell	workcmd[5];	/* Temporary for la
+ /*
+  * Function types
+  */
+-int	beep();
+-int	qcount();
+-int	vchange();
+-int	vdelete();
++void	beep(void);
+ int	vgrabit();
+-int	vinschar();
+-int	vmove();
+-int	vputchar();
+-int	vshift();
+-int	vyankit();
++
++
diff --git a/editors/ex/patches/patch-ex__vmain_c b/editors/ex/patches/patch-ex__vmain_c
new file mode 100644
index 00000000000..52012ba41ac
--- /dev/null
+++ b/editors/ex/patches/patch-ex__vmain_c
@@ -0,0 +1,209 @@
+$NetBSD: patch-ex__vmain_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- use volatile for compiler warnings about setjmp/vfork clobbering
+- fix up function pointer casting mess
+- silence warnings about assignments in conditionals
+- use <ctype.h> functions correctly
+- silence warnings about && and || precedence
+
+--- ex_vmain.c~	2012-12-27 21:58:42.000000000 +0000
++++ ex_vmain.c
+@@ -83,8 +83,8 @@ static char sccsid[] = "@(#)ex_vmain.c	1
+ #include "ex_tty.h"
+ #include "ex_vis.h"
+ 
+-int vzop __P((int, int, register int));
+-int grabtag __P((void));
++static void vzop __P((int, int, register int));
++static void grabtag __P((void));
+ 
+ /*
+  * This is the main routine for visual.
+@@ -96,17 +96,26 @@ int grabtag __P((void));
+ 
+ #define	forbid(a)	{ if (a) goto fonfon; }
+ 
++static void
++doput(int ignore)
++{
++	(void)ignore;
++	put();
++}
++
++void
+ vmain()
+ {
+ 	int c, cnt, i;
+ 	cell esave[TUBECOLS];
+-	char *oglobp;
+-	short d;
+-	line *addr;
++	const char *volatile oglobp;
++	volatile short d;
++	line *volatile addr;
+ 	int ind, nlput;
+-	int shouldpo = 0;
+-	int onumber = 0, olist = 0,
+-		(*OPline)() = NULL, (*OPutchar)() = NULL;
++	volatile int shouldpo = 0;
++	volatile int onumber = 0, olist = 0;
++	int (*volatile OPline)(int) = NULL;
++	int (*volatile OPutchar)(int) = NULL;
+ 
+ 	CLOBBGRD(c);
+ 	CLOBBGRD(cnt);
+@@ -160,7 +169,7 @@ vmain()
+ 		Xhadcnt = hadcnt = 0;
+ 		Xcnt = cnt = 1;
+ 		splitw = 0;
+-		if (i = holdupd) {
++		if ((i = holdupd) != 0) {
+ 			if (state == VISUAL)
+ 				ignore(peekkey());
+ 			holdupd = 0;
+@@ -205,7 +214,7 @@ looptop:
+ 			 * an 'empty' named buffer spec in the routine
+ 			 * kshift (see ex_temp.c).
+ 			 */
+-			forbid (c == '0' || !isalpha(c) && !isdigit(c));
++			forbid (c == '0' || (!isalpha((unsigned char)c) && !isdigit((unsigned char)c)));
+ 			vreg = c;
+ 		}
+ reread:
+@@ -635,8 +644,8 @@ reread:
+ 				if (isalpha(cuc(mbuf[1])))
+ 				{
+ 					char x = cuc(mbuf[1]);
+-					mbuf[1] = isupper(x) ?
+-						tolower(x) : toupper(x);
++					mbuf[1] = isupper((unsigned char)x) ?
++						tolower((unsigned char)x) : toupper((unsigned char)x);
+ 				}
+ 				macpush(mbuf, 1);
+ 			}
+@@ -865,7 +874,7 @@ case_ATTN:
+ 			vmacchng(1);
+ 			setLAST();
+ 			i = 0;
+-			if (vreg && partreg(vreg) || !vreg && pkill[0]) {
++			if ((vreg && partreg(vreg)) || (!vreg && pkill[0])) {
+ 				/*
+ 				 * Restoring multiple lines which were partial
+ 				 * lines; will leave cursor in middle
+@@ -898,8 +907,7 @@ case_ATTN:
+ 			 */
+ 			addr = dol;	/* old dol */
+ 			CATCH
+-				vremote(1, vreg ? (int(*)())putreg
+-						: (int(*)())put, vreg);
++				vremote(1, vreg ? putreg : doput, vreg);
+ 			ONERR
+ 				if (vreg == -1) {
+ 					splitw = 0;
+@@ -1160,7 +1168,7 @@ fixup:
+ 			 * in open mode and . moved, then redraw.
+ 			 */
+ 			i = vcline + (dot - addr);
+-			if (i < 0 || i >= vcnt && i >= -vcnt || state != VISUAL && dot != addr) {
++			if (i < 0 || (i >= vcnt && i >= -vcnt) || (state != VISUAL && dot != addr)) {
+ 				if (state == CRTOPEN)
+ 					vup1();
+ 				if (vcnt > 0)
+@@ -1247,6 +1255,7 @@ fonfon:
+ /*
+  * Grab the word after the cursor so we can look for it as a tag.
+  */
++static void
+ grabtag()
+ {
+ 	register char *cp, *dp;
+@@ -1271,6 +1280,7 @@ grabtag()
+  * Before appending lines, set up addr1 and
+  * the command mode undo information.
+  */
++void
+ prepapp()
+ {
+ 
+@@ -1284,8 +1294,8 @@ prepapp()
+  * Execute function f with the address bounds addr1
+  * and addr2 surrounding cnt lines starting at dot.
+  */
+-vremote(cnt, f, arg)
+-	int cnt, (*f)(), arg;
++void
++vremote(int cnt, void (*f)(int), int arg)
+ {
+ 	register int oing = inglobal;
+ 
+@@ -1301,15 +1311,23 @@ vremote(cnt, f, arg)
+ 	vmcurs = 0;
+ }
+ 
++static void
++doyank(int ignore)
++{
++	(void)ignore;
++	yank();
++}
++
+ /*
+  * Save the current contents of linebuf, if it has changed.
+  */
++void
+ vsave()
+ {
+ 	char temp[LBSIZE];
+ 
+ 	CP(temp, linebuf);
+-	if (FIXUNDO && vundkind == VCHNG || vundkind == VCAPU) {
++	if ((FIXUNDO && vundkind == VCHNG) || vundkind == VCAPU) {
+ 		/*
+ 		 * If the undo state is saved in the temporary buffer
+ 		 * vutmp, then we sync this into the temp file so that
+@@ -1321,7 +1339,7 @@ vsave()
+ 		prepapp();
+ 		CP(linebuf, vutmp);
+ 		putmark(dot);
+-		vremote(1, yank, 0);
++		vremote(1, doyank, 0);
+ 		vundkind = VMCHNG;
+ 		notecnt = 0;
+ 		undkind = UNDCHANGE;
+@@ -1345,6 +1363,7 @@ vsave()
+  * Do a z operation.
+  * Code here is rather long, and very uninteresting.
+  */
++static void
+ vzop(hadcnt, cnt, c)
+ 	bool hadcnt;
+ 	int cnt;
+@@ -1434,7 +1453,7 @@ register char *src;
+ {
+ 	register cell *cp = dst;
+ 
+-	while (*cp++ = *src++ & 0377);
++	while ((*cp++ = *src++ & 0377) != 0);
+ 	return dst;
+ }
+ 
+@@ -1445,7 +1464,7 @@ register cell *src;
+ {
+ 	register char *cp = dst;
+ 
+-	while (*cp++ = *src++);
++	while ((*cp++ = *src++) != 0);
+ 	return dst;
+ }
+ 
+@@ -1456,7 +1475,7 @@ register cell *src;
+ {
+ 	register cell *cp = dst;
+ 
+-	while (*cp++ = *src++);
++	while ((*cp++ = *src++) != 0);
+ 	return dst;
+ }
+ 
diff --git a/editors/ex/patches/patch-ex__voper_c b/editors/ex/patches/patch-ex__voper_c
new file mode 100644
index 00000000000..0a6be127f5b
--- /dev/null
+++ b/editors/ex/patches/patch-ex__voper_c
@@ -0,0 +1,351 @@
+$NetBSD: patch-ex__voper_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- fix up function pointer casting mess
+- declare void functions void
+- use const for string constants
+- silence warnings about && and || precedence
+- use <ctype.h> functions correctly
+- avoid implicit int
+
+--- ex_voper.c~	2012-12-27 21:58:41.000000000 +0000
++++ ex_voper.c
+@@ -89,7 +89,35 @@ static char sccsid[] = "@(#)ex_voper.c	1
+ 
+ cell	vscandir[2] =	{ '/', 0 };
+ 
+-int edge __P((void));
++static int edge __P((void));
++
++static void
++dovfilter(int ignore)
++{
++	(void)ignore;
++	vfilter();
++}
++
++static void
++dovshftop(int ignore)
++{
++	(void)ignore;
++	vshftop();
++}
++
++static void
++dovyankit(int ignore)
++{
++	(void)ignore;
++	vyankit();
++}
++
++static void
++dobeep(int ignore)
++{
++	(void)ignore;
++	beep();
++}
+ 
+ /*
+  * Decode an operator/operand type command.
+@@ -101,14 +129,17 @@ int edge __P((void));
+  * and if wcursor is zero, then the first non-blank location of the
+  * other line is implied.
+  */
++void
+ operate(c, cnt)
+ 	register int c, cnt;
+ {
+ 	register int i = 0;
+-	int (*moveop)(), (*deleteop)();
+-	int (*opf)();
++	void (*volatile moveop)(int);
++	void (*deleteop)(int);
++	void (*opf)(int);
+ 	bool subop = 0;
+-	char *oglobp, *ocurs;
++	const char *oglobp;
++	char *ocurs;
+ 	register line *addr;
+ 	line *odot;
+ 	static char lastFKND, lastFCHR;
+@@ -120,7 +151,8 @@ operate(c, cnt)
+ 	qmarkcell[0] = '?';
+ 	slashcell[0] = '/';
+ 	nullcell[0] = qmarkcell[1] = slashcell[1] = 0;
+-	moveop = vmove, deleteop = vdelete;
++	moveop = vmove_i;
++	deleteop = vdelete;
+ 	wcursor = cursor;
+ 	wdot = NOLINE;
+ 	notecnt = 0;
+@@ -132,7 +164,7 @@ operate(c, cnt)
+ 	 */
+ 	case 'd':
+ 		moveop = vdelete;
+-		deleteop = beep;
++		deleteop = dobeep;
+ 		break;
+ 
+ 	/*
+@@ -147,18 +179,18 @@ operate(c, cnt)
+ 	 * c		Change operator.
+ 	 */
+ 	case 'c':
+-		if (c == 'c' && workcmd[0] == 'C' || workcmd[0] == 'S')
++		if ((c == 'c' && workcmd[0] == 'C') || workcmd[0] == 'S')
+ 			subop++;
+ 		moveop = vchange;
+-		deleteop = beep;
++		deleteop = dobeep;
+ 		break;
+ 
+ 	/*
+ 	 * !		Filter through a UNIX command.
+ 	 */
+ 	case '!':
+-		moveop = vfilter;
+-		deleteop = beep;
++		moveop = dovfilter;
++		deleteop = dobeep;
+ 		break;
+ 
+ 	/*
+@@ -166,8 +198,8 @@ operate(c, cnt)
+ 	 *		can be put back with p/P.  Also yanks to named buffers.
+ 	 */
+ 	case 'y':
+-		moveop = vyankit;
+-		deleteop = beep;
++		moveop = dovyankit;
++		deleteop = dobeep;
+ 		break;
+ 
+ 	/*
+@@ -185,8 +217,8 @@ operate(c, cnt)
+ 	 */
+ 	case '<':
+ 	case '>':
+-		moveop = vshftop;
+-		deleteop = beep;
++		moveop = dovshftop;
++		deleteop = dobeep;
+ 		break;
+ 
+ 	/*
+@@ -309,7 +341,7 @@ ein:
+ #endif
+ 		getDOT();
+ 		forbid(!i);
+-		if (opf != vmove)
++		if (opf != vmove_i)
+ 			if (dir > 0)
+ 				wcursor++;
+ 			else
+@@ -353,8 +385,8 @@ ein:
+ 	 */
+ 	case ',':
+ 		forbid (lastFKND == 0);
+-		c = isupper(cuc(lastFKND))
+-			? tolower(lastFKND) : toupper(lastFKND);
++		c = isupper(cuc((unsigned char)lastFKND))
++			? tolower((unsigned char)lastFKND) : toupper((unsigned char)lastFKND);
+ 		i = lastFCHR;
+ 		if (vglobp == 0)
+ 			vglobp = nullcell;
+@@ -415,7 +447,7 @@ ein:
+ 			wcursor--;
+ 		case 'f':
+ fixup:
+-			if (moveop != vmove)
++			if (moveop != vmove_i)
+ 				wcursor++;
+ 			break;
+ 		}
+@@ -444,13 +476,13 @@ fixup:
+ 	 * $		To end of line.
+ 	 */
+ 	case '$':
+-		if (opf == vmove) {
++		if (opf == vmove_i) {
+ 			vmoving = 1;
+ 			vmovcol = 20000;
+ 		} else
+ 			vmoving = 0;
+ 		if (cnt > 1) {
+-			if (opf == vmove) {
++			if (opf == vmove_i) {
+ 				wcursor = 0;
+ 				cnt--;
+ 			} else
+@@ -480,10 +512,10 @@ fixup:
+ 	 */
+ 	case 'l':
+ 	case ' ':
+-		forbid (margin() || opf == vmove && edge());
++		forbid (margin() || (opf == vmove_i && edge()));
+ 		while (cnt > 0 && !margin())
+ 			wcursor += dir, cnt--;
+-		if (margin() && opf == vmove || wcursor < linebuf)
++		if ((margin() && opf == vmove_i) || wcursor < linebuf)
+ 			wcursor -= dir;
+ 		vmoving = 0;
+ 		break;
+@@ -520,7 +552,7 @@ deleteit:
+ 		 * Stuttered operators are equivalent to the operator on
+ 		 * a line, thus turn dd into d_.
+ 		 */
+-		if (opf == vmove || c != workcmd[0]) {
++		if (opf == vmove_i || c != workcmd[0]) {
+ errlab:
+ 			beep();
+ 			vmacp = 0;
+@@ -545,7 +577,7 @@ errlab:
+ 	 */
+ 	case 'H':
+ 		wdot = (dot - vcline) + cnt - 1;
+-		if (opf == vmove)
++		if (opf == vmove_i)
+ 			markit(wdot);
+ 		vmoving = 0;
+ 		wcursor = 0;
+@@ -578,7 +610,7 @@ errlab:
+ 	 */
+ 	case 'L':
+ 		wdot = dot + vcnt - vcline - cnt;
+-		if (opf == vmove)
++		if (opf == vmove_i)
+ 			markit(wdot);
+ 		vmoving = 0;
+ 		wcursor = 0;
+@@ -589,7 +621,7 @@ errlab:
+ 	 */
+ 	case 'M':
+ 		wdot = dot + ((vcnt + 1) / 2) - vcline - 1;
+-		if (opf == vmove)
++		if (opf == vmove_i)
+ 			markit(wdot);
+ 		vmoving = 0;
+ 		wcursor = 0;
+@@ -656,7 +688,7 @@ errlab:
+ 		forbid (Xhadcnt);
+ 		vmoving = 0;
+ 		wcursor = d == '`' ? ncols[c - 'a'] : 0;
+-		if (opf == vmove && (wdot != dot || (d == '`' && wcursor != cursor)))
++		if (opf == vmove_i && (wdot != dot || (d == '`' && wcursor != cursor)))
+ 			markDOT();
+ 		if (wcursor) {
+ 			vsave();
+@@ -678,7 +710,7 @@ errlab:
+ 			cnt = lineDOL();
+ 		wdot = zero + cnt;
+ 		forbid (wdot < one || wdot > dol);
+-		if (opf == vmove)
++		if (opf == vmove_i)
+ 			markit(wdot);
+ 		vmoving = 0;
+ 		wcursor = 0;
+@@ -765,7 +797,7 @@ slerr:
+ 		wcursor = loc1;
+ 		if (i != 0)
+ 			vsetsiz(i);
+-		if (opf == vmove) {
++		if (opf == vmove_i) {
+ 			if (state == ONEOPEN || state == HARDOPEN)
+ 				outline = destline = WBOT;
+ 			if (addr != dot || loc1 != cursor)
+@@ -804,7 +836,8 @@ slerr:
+ /*
+  * Find single character c, in direction dir from cursor.
+  */
+-find(c)
++int
++find(int c)
+ {
+ 
+ 	for(;;) {
+@@ -820,8 +853,9 @@ find(c)
+  * Do a word motion with operator op, and cnt more words
+  * to go after this.
+  */
++int
+ word(op, cnt)
+-	register int (*op)();
++	register void (*op)(int);
+ 	int cnt;
+ {
+ 	register int which = 0;
+@@ -832,7 +866,7 @@ word(op, cnt)
+ 		iwc = wcursor;
+ 		which = wordch(wcursor);
+ 		while (wordof(which, wcursor)) {
+-			if (cnt == 1 && op != vmove && wcursor[1] == 0) {
++			if (cnt == 1 && op != vmove_i && wcursor[1] == 0) {
+ 				wcursor++;
+ 				break;
+ 			}
+@@ -848,7 +882,7 @@ word(op, cnt)
+ 		else
+ 			if (wcursor == iwc && iwdot == wdot && *iwc)
+ 				wcursor++;
+-		if (op == vmove && margin())
++		if (op == vmove_i && margin())
+ 			wcursor--;
+ 	} else {
+ 		if (!lnext())
+@@ -871,8 +905,9 @@ word(op, cnt)
+  * To end of word, with operator op and cnt more motions
+  * remaining after this.
+  */
++void
+ eend(op)
+-	register int (*op)();
++	register void (*op)(int);
+ {
+ 	register int which;
+ 
+@@ -898,8 +933,8 @@ eend(op)
+  * Wordof tells whether the character at *wc is in a word of
+  * kind which (blank/nonblank words are 0, conservative words 1).
+  */
+-wordof(which, wc)
+-	register char *wc;
++int
++wordof(int which, register char *wc)
+ {
+ 
+ 	if (isspace(cuc(*wc)))
+@@ -911,12 +946,13 @@ wordof(which, wc)
+  * Wordch tells whether character at *wc is a word character
+  * i.e. an alfa, digit, or underscore.
+  */
++int
+ wordch(wc)
+ 	char *wc;
+ {
+ 	register int c;
+ 
+-	c = wc[0];
++	c = (unsigned char)wc[0];
+ 	return (isalpha(c) || isdigit(c) || c == '_'
+ #ifdef	BIT8
+ #ifdef	ISO8859_1
+@@ -935,7 +971,8 @@ wordch(wc)
+ /*
+  * Edge tells when we hit the last character in the current line.
+  */
+-edge()
++static int
++edge(void)
+ {
+ 
+ 	if (linebuf[0] == 0)
+@@ -949,7 +986,8 @@ edge()
+ /*
+  * Margin tells us when we have fallen off the end of the line.
+  */
+-margin()
++int
++margin(void)
+ {
+ 
+ 	return (wcursor < linebuf || wcursor[0] == 0);
diff --git a/editors/ex/patches/patch-ex__vops2_c b/editors/ex/patches/patch-ex__vops2_c
new file mode 100644
index 00000000000..c075dfe97d5
--- /dev/null
+++ b/editors/ex/patches/patch-ex__vops2_c
@@ -0,0 +1,211 @@
+$NetBSD: patch-ex__vops2_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- avoid implicit int
+- use const for string constants
+- fix up function pointer casting mess
+- avoid sloppy code that subtracts 1 from the base address of a char[]
+  (which isn't valid)
+- silence warnings about && and || precedence
+- silence warnings about braces
+
+
+--- ex_vops2.c~	2012-12-27 21:58:42.000000000 +0000
++++ ex_vops2.c
+@@ -91,12 +91,14 @@ static char sccsid[] = "@(#)ex_vops2.c	1
+ extern char	*vUA1, *vUA2;		/* mjm: extern; also in ex_vops.c */
+ extern char	*vUD1, *vUD2;		/* mjm: extern; also in ex_vops.c */
+ 
+-int vmaxrep __P((int, register int));
++static int vmaxrep __P((int, register int));
++static int vgetsplit(void);
+ 
+ /*
+  * Obleeperate characters in hardcopy
+  * open with \'s.
+  */
++void
+ bleep(i, cp)
+ 	register int i;
+ 	char *cp;
+@@ -117,6 +119,7 @@ bleep(i, cp)
+  * Common code for middle part of delete
+  * and change operating on parts of lines.
+  */
++int
+ vdcMID()
+ {
+ 	register char *cp;
+@@ -136,6 +139,7 @@ vdcMID()
+  * in the VBSIZE buffer BUF.  Used to save
+  * deleted text of part of line.
+  */
++void
+ takeout(BUF)
+ 	cell *BUF;
+ {
+@@ -165,6 +169,7 @@ takeout(BUF)
+  * Are we at the end of the printed representation of the
+  * line?  Used internally in hardcopy open.
+  */
++int
+ ateopr()
+ {
+ 	register int i, c;
+@@ -185,10 +190,12 @@ ateopr()
+ 	return (1);
+ }
+ 
+-showmode(mode)
++void
++showmode(int mode)
+ {
+ 	int sdc = destcol, sdl = destline;
+-	char *ocurs, *str;
++	char *ocurs;
++	const char *str;
+ 
+ 	if (value(SHOWMODE) == 0 || TCOLUMNS <= 20 || state == ONEOPEN
+ 			|| state == HARDOPEN || vmacp != NULL)
+@@ -246,8 +253,8 @@ char	*ogcursor;
+  * The addtext() and addto() routines combined, accepting a single
+  * cell character.
+  */
+-addc(c)
+-cell c;
++static void
++addc(cell c)
+ {
+ 	register cell *cp = INS;
+ 
+@@ -274,6 +281,14 @@ cell c;
+ 	}
+ }
+ 
++static void
++doyank(int ignore)
++{
++	(void)ignore;
++	yank();
++}
++
++void
+ vappend(ch, cnt, indent)
+ 	int ch;		/* mjm: char --> int */
+ 	int cnt, indent;
+@@ -330,7 +345,7 @@ vappend(ch, cnt, indent)
+ 	if (value(AUTOINDENT) && indent != 0) {
+ 		gcursor = genindent(indent);
+ 		*gcursor = 0;
+-		vgotoCL(qcolumn(cursor - 1, genbuf));
++		vgotoCL(qcolumn2(cursor, genbuf));
+ 	} else {
+ 		gcursor = genbuf;
+ 		*gcursor = 0;
+@@ -536,7 +551,7 @@ vappend(ch, cnt, indent)
+ 		 * correctly later.
+ 		 */
+ 		if (FIXUNDO && vundkind == VCHNG) {
+-			vremote(1, yank, 0);
++			vremote(1, doyank, 0);
+ 			undap1--;
+ 		}
+ 
+@@ -561,7 +576,7 @@ vappend(ch, cnt, indent)
+ 		strcLIN(gcursor);
+ 		*gcursor = 0;
+ 		cursor = linebuf;
+-		vgotoCL(qcolumn(cursor - 1, genbuf));
++		vgotoCL(qcolumn2(cursor, genbuf));
+ 		showmode(ch);
+ 	}
+ 
+@@ -594,6 +609,7 @@ vappend(ch, cnt, indent)
+  * backwards around end of lines (vgoto can't hack columns which are
+  * less than 0 in general).
+  */
++void
+ back1()
+ {
+ 
+@@ -620,6 +636,7 @@ vget_line(cnt, gcursor, aescaped, commch
+ 	int cnt;
+ 	register char *gcursor;
+ 	bool *aescaped;
++	int commch;
+ {
+ 	register int c, ch;
+ 	register char *cp;
+@@ -771,7 +788,7 @@ vbackup:
+ 				endim();
+ 				*cp = 0;
+ 				c = cindent();
+-				vgotoCL(qcolumn(cursor - 1, genbuf));
++				vgotoCL(qcolumn2(cursor, genbuf));
+ 				if (doomed >= 0)
+ 					doomed += c - cindent();
+ 				gcursor = cp;
+@@ -836,7 +853,7 @@ vbackup:
+ 			}
+ 			if (value(WRAPMARGIN) &&
+ 				(outcol >= OCOLUMNS - value(WRAPMARGIN) ||
+-				 backsl && outcol==0) &&
++				 (backsl && outcol==0)) &&
+ 				commch != 'r') {
+ 				/*
+ 				 * At end of word and hit wrapmargin.
+@@ -991,7 +1008,7 @@ btrp:
+ 			 * generated autoindent.  We count the ^D for repeat
+ 			 * purposes.
+ 			 */
+-			if (c == iwhite && c != 0)
++			if (c == iwhite && c != 0) {
+ 				if (cp == gcursor) {
+ 					iwhite = backtab(c);
+ 					CDCNT++;
+@@ -1015,6 +1032,7 @@ btrp:
+ 					vputchar(' ');
+ 					goto vbackup;
+ 				}
++			}
+ 			if (vglobp && vglobp - iglobp >= 2 &&
+ 			    (vglobp[-2] == '^' || vglobp[-2] == '0')
+ 			    && gcursor == ogcursor + 1)
+@@ -1057,15 +1075,15 @@ vadone:
+ 	return (gcursor);
+ }
+ 
+-int	vgetsplit();
+-char	*vsplitpt;
++static const char	*vsplitpt;
+ 
+ /*
+  * Append the line in buffer at lp
+  * to the buffer after dot.
+  */
++void
+ vdoappend(lp)
+-	char *lp;
++	const char *lp;
+ {
+ 	register int oing = inglobal;
+ 
+@@ -1078,6 +1096,7 @@ vdoappend(lp)
+ /*
+  * Subroutine for vdoappend to pass to append.
+  */
++static int
+ vgetsplit()
+ {
+ 
+@@ -1093,7 +1112,9 @@ vgetsplit()
+  * allowed that will yield total line length less than
+  * LBSIZE characters and also does hacks for the R command.
+  */
++static int
+ vmaxrep(ch, cnt)
++	int ch;
+ 	register int cnt;
+ {
+ 	register int len, replen;
diff --git a/editors/ex/patches/patch-ex__vops3_c b/editors/ex/patches/patch-ex__vops3_c
new file mode 100644
index 00000000000..f795885e9ef
--- /dev/null
+++ b/editors/ex/patches/patch-ex__vops3_c
@@ -0,0 +1,323 @@
+$NetBSD: patch-ex__vops3_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions (and data) static
+- fix up function pointer casting mess
+- avoid implicit int
+- silence warnings about && and || precedence
+- silence warnings about unused arguments
+- use const for string constants
+- declare void functions void
+
+
+--- ex_vops3.c~	2012-12-27 21:58:41.000000000 +0000
++++ ex_vops3.c
+@@ -99,23 +99,26 @@ static char sccsid[] = "@(#)ex_vops3.c	1
+  *
+  * The code here is very hard to understand.
+  */
+-line	*llimit;
+-int	(*lf)();
++static line	*llimit;
++static bool	wasend;
+ 
+-int lskipa1 __P((register char *));
+-int endsent __P((int));
+-int endPS __P((void));
+-int lskipbal __P((register char *));
+-int ltosolid __P((void));
+-int lskipatom __P((void));
+-int isa __P((register char *));
+-int ltosol1 __P((register char *));
+-
+-#ifdef LISPCODE
+-int	lindent();
+-#endif
++/*
++ * lf is never called, but is compared against other function pointers.
++ * lindent() is the wrong type, so instead of setting lf = lindent, set
++ * it to 0 and set lf_is_lindent to nonzero. Other assignments to lf
++ * whould be accompanied by lf_is_lindent = 0.
++ */
++static void	(*lf)(int);
++static int	lf_is_lindent;
+ 
+-bool	wasend;
++static int lskipa1 __P((register const char *));
++static int endsent __P((int));
++static int endPS __P((void));
++static int lskipbal __P((register const char *));
++static int ltosolid __P((void));
++static int lskipatom __P((void));
++static int isa __P((register const char *));
++static int ltosol1 __P((register const char *));
+ 
+ /*
+  * Find over structure, repeated count times.
+@@ -124,9 +127,11 @@ bool	wasend;
+  * rather than (), implying past atoms in a list (or a paragraph
+  * rather than a sentence.
+  */
++int
+ llfind(pastatom, cnt, f, limit)
+ 	bool pastatom;
+-	int cnt, (*f)();
++	int cnt;
++	void (*f)(int);
+ 	line *limit;
+ {
+ #ifdef	LISPCODE
+@@ -142,6 +147,7 @@ llfind(pastatom, cnt, f, limit)
+ 	 */
+ 	wasend = 0;
+ 	lf = f;
++	lf_is_lindent = 0;
+ 	strcpy(save, linebuf);
+ 	if (limit == 0)
+ 		limit = dir < 0 ? one : dol;
+@@ -210,7 +216,7 @@ begin:
+ 			while (!endsent(pastatom))
+ 				if (!lnext())
+ 					goto ret;
+-			if (!pastatom || wcursor == linebuf && endPS())
++			if (!pastatom || (wcursor == linebuf && endPS()))
+ 				if (--cnt <= 0)
+ 					break;
+ 			if (linebuf[0] == 0) {
+@@ -246,7 +252,7 @@ begin:
+ 		 * If we are not at a section/paragraph division,
+ 		 * advance to next.
+ 		 */
+-		if (wcursor == icurs && wdot == idot || wcursor != linebuf || !endPS())
++		if ((wcursor == icurs && wdot == idot) || wcursor != linebuf || !endPS())
+ 			ignore(lskipa1(""));
+ 	}
+ #ifdef LISPCODE
+@@ -256,7 +262,7 @@ begin:
+ 		 * Startup by skipping if at a ( going left or a ) going
+ 		 * right to keep from getting stuck immediately.
+ 		 */
+-		if (dir < 0 && c == '(' || dir > 0 && c == ')') {
++		if ((dir < 0 && c == '(') || (dir > 0 && c == ')')) {
+ 			if (!lnext()) {
+ 				rc = -1;
+ 				goto ret;
+@@ -272,7 +278,7 @@ begin:
+ 		 */
+ 		while (cnt > 0) {
+ 			c = *wcursor;
+-			if (dir < 0 && c == ')' || dir > 0 && c == '(') {
++			if ((dir < 0 && c == ')') || (dir > 0 && c == '(')) {
+ 				if (!lskipbal("()"))
+ 					goto ret;
+ 				/*
+@@ -285,7 +291,7 @@ begin:
+ 				if (!lnext() || !ltosolid())
+ 					goto ret;
+ 				--cnt;
+-			} else if (dir < 0 && c == '(' || dir > 0 && c == ')')
++			} else if ((dir < 0 && c == '(') || (dir > 0 && c == ')'))
+ 				/* Found a higher level paren */
+ 				goto ret;
+ 			else {
+@@ -305,12 +311,15 @@ ret:
+ /*
+  * Is this the end of a sentence?
+  */
++static int
+ endsent(pastatom)
+ 	bool pastatom;
+ {
+ 	register char *cp = wcursor;
+ 	register int c, d;
+ 
++	(void)pastatom;
++
+ 	/*
+ 	 * If this is the beginning of a line, then
+ 	 * check for the end of a paragraph or section.
+@@ -330,7 +339,7 @@ endsent(pastatom)
+ 		if ((d = *++cp) == 0)
+ 			return (1);
+ 	while (any(d, ")]'"));
+-	if (*cp == 0 || *cp++ == ' ' && *cp == ' ')
++	if (*cp == 0 || (*cp++ == ' ' && *cp == ' '))
+ 		return (1);
+ tryps:
+ 	if (cp[1] == 0)
+@@ -342,6 +351,7 @@ tryps:
+  * End of paragraphs/sections are respective
+  * macros as well as blank lines and form feeds.
+  */
++static int
+ endPS()
+ {
+ 
+@@ -351,6 +361,7 @@ endPS()
+ }
+ 
+ #ifdef LISPCODE
++int
+ lindent(addr)
+ 	line *addr;
+ {
+@@ -382,7 +393,8 @@ again:
+ 	wdot = addr;
+ 	dir = -1;
+ 	llimit = one;
+-	lf = lindent;
++	lf = 0;
++	lf_is_lindent = 1;
+ 	if (!lskipbal("()"))
+ 		i = 0;
+ 	else if (wcursor == linebuf)
+@@ -407,16 +419,19 @@ again:
+ }
+ #endif
+ 
++int
+ lmatchp(addr)
+ 	line *addr;
+ {
+ 	register int i;
+-	register char *parens, *cp;
++	register const char *parens;
++	register char *cp;
+ 
+ 	for (cp = cursor; !any(*cp, "({[)}]");)
+ 		if (*cp++ == 0)
+ 			return (0);
+ 	lf = 0;
++	lf_is_lindent = 0;
+ 	parens = any(*cp, "()") ? "()" : any(*cp, "[]") ? "[]" : "{}";
+ 	if (*cp == parens[1]) {
+ 		dir = -1;
+@@ -435,6 +450,7 @@ lmatchp(addr)
+ 	return (i);
+ }
+ 
++void
+ lsmatch(cp)
+ 	char *cp;
+ {
+@@ -473,14 +489,16 @@ lsmatch(cp)
+ 	cursor = scurs;
+ }
+ 
++static int
+ ltosolid()
+ {
+ 
+ 	return (ltosol1("()"));
+ }
+ 
++static int
+ ltosol1(parens)
+-	register char *parens;
++	register const char *parens;
+ {
+ 	register char *cp;
+ 
+@@ -498,8 +516,9 @@ ltosol1(parens)
+ 	return (1);
+ }
+ 
++static int
+ lskipbal(parens)
+-	register char *parens;
++	register const char *parens;
+ {
+ 	register int level = dir;
+ 	register int c;
+@@ -518,14 +537,16 @@ lskipbal(parens)
+ 	return (1);
+ }
+ 
++static int
+ lskipatom()
+ {
+ 
+ 	return (lskipa1("()"));
+ }
+ 
++static int
+ lskipa1(parens)
+-	register char *parens;
++	register const char *parens;
+ {
+ 	register int c;
+ 
+@@ -546,6 +567,7 @@ lskipa1(parens)
+ 	return (ltosol1(parens));
+ }
+ 
++int
+ lnext()
+ {
+ 
+@@ -555,7 +577,7 @@ lnext()
+ 		if (*wcursor)
+ 			return (1);
+ 		if (wdot >= llimit) {
+-			if (lf == vmove && wcursor > linebuf)
++			if (lf == vmove_i && wcursor > linebuf)
+ 				wcursor--;
+ 			return (0);
+ 		}
+@@ -568,7 +590,7 @@ lnext()
+ 		if (wcursor >= linebuf)
+ 			return (1);
+ #ifdef LISPCODE
+-		if (lf == lindent && linebuf[0] == '(')
++		if (lf_is_lindent && linebuf[0] == '(')
+ 			llimit = wdot;
+ #endif
+ 		if (wdot <= llimit) {
+@@ -582,9 +604,10 @@ lnext()
+ 	}
+ }
+ 
++int
+ lbrack(c, f)
+ 	register int c;
+-	int (*f)();
++	void (*f)(int);
+ {
+ 	register line *addr;
+ 
+@@ -598,21 +621,21 @@ lbrack(c, f)
+ 		get_line(*addr);
+ 		if (linebuf[0] == '{' ||
+ #ifdef LISPCODE
+-		    value(LISP) && linebuf[0] == '(' ||
++		    (value(LISP) && linebuf[0] == '(') ||
+ #endif
+ 		    isa(svalue(SECTIONS))) {
+-			if (c == ']' && f != vmove) {
++			if (c == ']' && f != vmove_i) {
+ 				addr--;
+ 				get_line(*addr);
+ 			}
+ 			break;
+ 		}
+-		if (c == ']' && f != vmove && linebuf[0] == '}')
++		if (c == ']' && f != vmove_i && linebuf[0] == '}')
+ 			break;
+ 	}
+ 	if (addr == dot)
+ 		return (0);
+-	if (f != vmove)
++	if (f != vmove_i)
+ 		wcursor = c == ']' ? strend(linebuf) : linebuf;
+ 	else
+ 		wcursor = 0;
+@@ -621,8 +644,9 @@ lbrack(c, f)
+ 	return (1);
+ }
+ 
++static int
+ isa(cp)
+-	register char *cp;
++	register const char *cp;
+ {
+ 
+ 	if (linebuf[0] != '.')
diff --git a/editors/ex/patches/patch-ex__vops_c b/editors/ex/patches/patch-ex__vops_c
new file mode 100644
index 00000000000..adee374cd39
--- /dev/null
+++ b/editors/ex/patches/patch-ex__vops_c
@@ -0,0 +1,240 @@
+$NetBSD: patch-ex__vops_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- silence warnings about braces
+- fix up function pointer casting mess
+- avoid implicit int
+- silence warnings about && and || precedence
+- use const for string constants
+- silence warnings about unused arguments
+- silence signed/unsigned compiler warning
+
+--- ex_vops.c~	2012-12-27 21:58:42.000000000 +0000
++++ ex_vops.c
+@@ -89,8 +89,9 @@ static char sccsid[] = "@(#)ex_vops.c	1.
+  * display representations.
+  */
+ 
+-int xdw __P((void));
+-int setpk __P((void));
++static int xdw __P((void));
++static void vshift(int ignore);
++static void setpk __P((void));
+ 
+ /*
+  * Undo.
+@@ -111,6 +112,7 @@ int setpk __P((void));
+ char	*vUA1, *vUA2;
+ char	*vUD1, *vUD2;
+ 
++void
+ vUndo()
+ {
+ 
+@@ -137,6 +139,7 @@ vUndo()
+ 	vfixcurs();
+ }
+ 
++void
+ vundo(show)
+ bool show;	/* if true update the screen */
+ {
+@@ -173,12 +176,13 @@ bool show;	/* if true update the screen 
+ 		 * with dol through unddol-1.  Hack screen image to
+ 		 * reflect this replacement.
+ 		 */
+-		if (show)
++		if (show) {
+ 			if (undkind == UNDMOVE)
+ 				vdirty(0, TLINES);
+ 			else
+ 				vreplace(undap1 - addr, undap2 - undap1,
+ 				    undkind == UNDPUT ? 0 : unddol - dol);
++		}
+ 		savenote = notecnt;
+ 		undo(1);
+ 		if (show && (vundkind != VMCHNG || addr != dot))
+@@ -250,6 +254,7 @@ bool show;	/* if true update the screen 
+  * opposed to an ex command).  This has nothing to do with being
+  * in open/visual mode as :s/foo/bar is not fromvis.
+  */
++void
+ vmacchng(fromvis)
+ bool fromvis;
+ {
+@@ -259,7 +264,6 @@ bool fromvis;
+ 	int nlines, more;
+ 	/* register line *a1, *a2; */
+ 	/* char ch; */	/* DEBUG */
+-	int copyw(), copywR();
+ 
+ 	if (!inopen)
+ 		return;
+@@ -338,6 +342,7 @@ bool fromvis;
+ /*
+  * Initialize undo information before an append.
+  */
++void
+ vnoapp()
+ {
+ 
+@@ -357,6 +362,7 @@ vnoapp()
+ /*
+  * Move is simple, except for moving onto new lines in hardcopy open mode.
+  */
++void
+ vmove()
+ {
+ 	register int cnt;
+@@ -423,6 +429,17 @@ vmove()
+ }
+ 
+ /*
++ * This is the same as vmove, but throws away its argument, so
++ * it can be used in combination with other function pointers.
++ */
++void
++vmove_i(int ignore)
++{
++	(void)ignore;
++	vmove();
++}
++
++/*
+  * Delete operator.
+  *
+  * Hard case of deleting a range where both wcursor and wdot
+@@ -430,7 +447,8 @@ vmove()
+  * by vchange (although vchange may pass it back if it degenerates
+  * to a full line range delete.)
+  */
+-vdelete(c)
++void
++vdelete(int c)
+ {
+ 	register char *cp;
+ 	register int i;
+@@ -489,7 +507,8 @@ vdelete(c)
+  * Across lines with both wcursor and wdot given, we delete
+  * and sync then append (but one operation for undo).
+  */
+-vchange(c)
++void
++vchange(int c)
+ {
+ 	register char *cp;
+ 	register int i, ind, cnt;
+@@ -705,6 +724,7 @@ smallchange:
+  * Actually counts are obsoleted, since if your terminal is slow
+  * you are better off with slowopen.
+  */
++void
+ voOpen(c, cnt)
+ 	int c;	/* mjm: char --> int */
+ 	register int cnt;
+@@ -719,7 +739,7 @@ voOpen(c, cnt)
+ #endif
+ #endif
+ 
+-	if (value(SLOWOPEN) || value(REDRAW) && AL && DL)
++	if (value(SLOWOPEN) || (value(REDRAW) && AL && DL))
+ 		cnt = 1;
+ #ifdef	SIGWINCH
+ #ifndef	POSIX_1
+@@ -794,6 +814,7 @@ voOpen(c, cnt)
+  */
+ char	vshnam[2] = { 'x', 0 };
+ 
++void
+ vshftop()
+ {
+ 	register line *addr;
+@@ -817,11 +838,12 @@ vshftop()
+  *
+  * Filter portions of the buffer through unix commands.
+  */
++void
+ vfilter()
+ {
+ 	register line *addr;
+ 	register int cnt;
+-	char *oglobp;
++	const char *oglobp;
+ 	short d;
+ #ifdef	BIT8
+ 	cell cuxb[UXBSIZE + 2];
+@@ -885,6 +907,7 @@ vfilter()
+  * that wdot is reasonable.  Its name comes from
+  *	xchange dotand wdot
+  */
++static int
+ xdw()
+ {
+ 	register char *cp;
+@@ -956,9 +979,10 @@ xdw()
+ /*
+  * Routine for vremote to call to implement shifts.
+  */
+-vshift()
++static void
++vshift(int ignore)
+ {
+-
++	(void)ignore;
+ 	shift(op, 1);
+ }
+ 
+@@ -966,12 +990,13 @@ vshift()
+  * Replace a single character with the next input character.
+  * A funny kind of insert.
+  */
++void
+ vrep(cnt)
+ 	register int cnt;
+ {
+ 	register int i, c;
+ 
+-	if (cnt > strlen(cursor)) {
++	if (cnt > (int)strlen(cursor)) {
+ 		beep();
+ 		return;
+ 	}
+@@ -1000,12 +1025,20 @@ vrep(cnt)
+ 	setLAST();
+ }
+ 
++static void
++doyank(int ignore)
++{
++	(void)ignore;
++	yank();
++}
++
+ /*
+  * Yank.
+  *
+  * Yanking to string registers occurs for free (essentially)
+  * in the routine xdw().
+  */
++void
+ vyankit()
+ {
+ 	register int cnt;
+@@ -1013,7 +1046,7 @@ vyankit()
+ 	if (wdot) {
+ 		if ((cnt = xdw()) < 0)
+ 			return;
+-		vremote(cnt, yank, 0);
++		vremote(cnt, doyank, 0);
+ 		setpk();
+ 		notenam = "yank";
+ 		if (FIXUNDO)
+@@ -1036,6 +1069,7 @@ vyankit()
+  * the first and last lines.  The compromise
+  * is for put to be more clever.
+  */
++static void
+ setpk()
+ {
+ 
diff --git a/editors/ex/patches/patch-ex__vput_c b/editors/ex/patches/patch-ex__vput_c
new file mode 100644
index 00000000000..d1cb1010855
--- /dev/null
+++ b/editors/ex/patches/patch-ex__vput_c
@@ -0,0 +1,471 @@
+$NetBSD: patch-ex__vput_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- avoid implicit int
+- return values from non-void functions
+- silence warnings about && and || precedence
+- silence warnings about braces
+- fix up function pointer casting mess
+
+--- ex_vput.c~	2012-12-27 21:58:42.000000000 +0000
++++ ex_vput.c
+@@ -88,14 +88,14 @@ static char sccsid[] = "@(#)ex_vput.c	1.
+ #define	vquot(c)	(c == quotsp)
+ #endif	/* BIT8 */
+ 
+-int vmaktop __P((int, cell *));
+-int vnpins __P((int));
+-int vrigid __P((void));
+-int vneedpos __P((int));
+-int vishft __P((void));
+-int viin __P((int));
+-int godm __P((void));
+-int enddm __P((void));
++static void vmaktop __P((int, cell *));
++static void vnpins __P((int));
++static void vrigid __P((void));
++static void vneedpos __P((int));
++static void vishft __P((void));
++static void viin __P((int));
++static void godm __P((void));
++static void enddm __P((void));
+ 
+ /*
+  * Deal with the screen, clearing, cursor positioning, putting characters
+@@ -103,6 +103,7 @@ int enddm __P((void));
+  * Really hard stuff here is utilizing insert character operations
+  * on intelligent terminals which differs widely from terminal to terminal.
+  */
++void
+ vclear()
+ {
+ 
+@@ -122,6 +123,7 @@ vclear()
+ /*
+  * Clear memory.
+  */
++void
+ vclrcell(cp, i)
+ 	register cell *cp;
+ 	register int i;
+@@ -135,6 +137,7 @@ vclrcell(cp, i)
+ /*
+  * Clear a physical display line, high level.
+  */
++void
+ vclrlin(l, tp)
+ 	int l;
+ 	line *tp;
+@@ -155,6 +158,7 @@ vclrlin(l, tp)
+ /*
+  * Clear to the end of the current physical line
+  */
++void
+ vclreol()
+ {
+ 	register int i, j;
+@@ -169,7 +173,7 @@ vclreol()
+ 	i = WCOLS - destcol;
+ 	tp = vtube[destline] + destcol;
+ 	if (CE) {
+-		if (IN && *tp || !ateopr()) {
++		if ((IN && *tp) || !ateopr()) {
+ 			vcsync();
+ 			vputp(CE, 1);
+ 		}
+@@ -200,6 +204,7 @@ vclreol()
+  * If work here is being held off, just remember, in
+  * heldech, if work needs to be done, don't do anything.
+  */
++void
+ vclrech(didphys)
+ 	bool didphys;
+ {
+@@ -252,6 +257,7 @@ vclrech(didphys)
+  * the state variable splitw so we wont rollup
+  * when we move the cursor there.
+  */
++void
+ fixech()
+ {
+ 
+@@ -266,6 +272,7 @@ fixech()
+ /*
+  * Put the cursor ``before'' cp.
+  */
++void
+ vcursbef(cp)
+ 	register char *cp;
+ {
+@@ -279,6 +286,7 @@ vcursbef(cp)
+ /*
+  * Put the cursor ``at'' cp.
+  */
++void
+ vcursat(cp)
+ 	register char *cp;
+ {
+@@ -292,6 +300,7 @@ vcursat(cp)
+ /*
+  * Put the cursor ``after'' cp.
+  */
++void
+ vcursaft(cp)
+ 	register char *cp;
+ {
+@@ -303,6 +312,7 @@ vcursaft(cp)
+  * Fix the cursor to be positioned in the correct place
+  * to accept a command.
+  */
++void
+ vfixcurs()
+ {
+ 
+@@ -313,6 +323,7 @@ vfixcurs()
+  * Compute the column position implied by the cursor at ``nc'',
+  * and move the cursor there.
+  */
++void
+ vsetcurs(nc)
+ 	register char *nc;
+ {
+@@ -328,6 +339,7 @@ vsetcurs(nc)
+ /*
+  * Move the cursor invisibly, i.e. only remember to do it.
+  */
++void
+ vigoto(y, x)
+ 	int y, x;
+ {
+@@ -340,6 +352,7 @@ vigoto(y, x)
+  * Move the cursor to the position implied by any previous
+  * vigoto (or low level hacking with destcol/destline as in readecho).
+  */
++void
+ vcsync()
+ {
+ 
+@@ -349,6 +362,7 @@ vcsync()
+ /*
+  * Goto column x of the current line.
+  */
++void
+ vgotoCL(x)
+ 	register int x;
+ {
+@@ -362,8 +376,8 @@ vgotoCL(x)
+ /*
+  * Invisible goto column x of current line.
+  */
+-vigotoCL(x)
+-	register int x;
++static void
++vigotoCL(register int x)
+ {
+ 
+ 	if (splitw)
+@@ -375,6 +389,7 @@ vigotoCL(x)
+ /*
+  * Move cursor to line y, column x, handling wraparound and scrolling.
+  */
++void
+ vgoto(y, x)
+ 	register int y, x;
+ {
+@@ -523,7 +538,8 @@ vgoto(y, x)
+  * with a QUOTE.  We use QUOTE internally to represent a position
+  * which is part of the expansion of a tab.
+  */
+-vgotab()
++static void
++vgotab(void)
+ {
+ 	register int i = tabcol(destcol, value(TABSTOP)) - destcol;
+ 
+@@ -555,6 +571,7 @@ int	slakused;		/* This much of tabslack 
+  * of the screen image buffer so it is easier for us to
+  * maniuplate them.
+  */
++void
+ vprepins()
+ {
+ 	register int i;
+@@ -566,6 +583,7 @@ vprepins()
+ 	}
+ }
+ 
++static void
+ vmaktop(p, cp)
+ 	register int p;
+ 	cell *cp;
+@@ -594,6 +612,7 @@ vmaktop(p, cp)
+  * for tabs) and code assumes this in several place
+  * to make life simpler.
+  */
++int
+ vinschar(c)
+ 	int c;		/* mjm: char --> int */
+ {
+@@ -609,12 +628,12 @@ vinschar(c)
+ 		 */
+ 		if (c == '\t') {
+ 			vgotab();
+-			return;
++			return c;
+ 		}
+ 		vputchar(c);
+ 		if (DEPTH(vcline) * WCOLS + !value(REDRAW) >
+ 		    (destline - LINE(vcline)) * WCOLS + destcol)
+-			return;
++			return c;
+ 		/*
+ 		 * The next line is about to be clobbered
+ 		 * make space for another segment of this line
+@@ -627,14 +646,14 @@ vinschar(c)
+ 		} else {
+ 			c = LINE(vcline) + DEPTH(vcline);
+ 			if (c < LINE(vcline + 1) || c > WBOT)
+-				return;
++				return c;
+ 			i = destcol;
+ 			vinslin(c, 1, vcline);
+ 			DEPTH(vcline)++;
+ 			vigoto(c, i);
+ 			vprepins();
+ 		}
+-		return;
++		return c;
+ 	}
+ 	/*
+ 	 * Compute the number of positions in the line image of the
+@@ -693,7 +712,7 @@ vinschar(c)
+ 		do
+ 			vputchar(c);
+ 		while (--inssiz);
+-		return;
++		return c;
+ 	}
+ 
+ 	/*
+@@ -787,12 +806,14 @@ vinschar(c)
+ 	destline = LINE(vcline);
+ 	destcol = inscol + inssiz;
+ 	vcsync();
++	return c;
+ }
+ 
+ /*
+  * Rigidify the rest of the line after the first
+  * group of following tabs, typing blanks over ``spaces''.
+  */
++void
+ vrigid()
+ {
+ 	register int col;
+@@ -827,6 +848,7 @@ vrigid()
+  * On a dumb terminal we may infact redisplay the rest of the
+  * screen here brute force to keep it pretty.
+  */
++void
+ vneedpos(npcnt)
+ 	int npcnt;
+ {
+@@ -866,6 +888,7 @@ vneedpos(npcnt)
+ 	vnpins(1);
+ }
+ 
++void
+ vnpins(dosync)
+ 	int dosync;
+ {
+@@ -900,6 +923,7 @@ vnpins(dosync)
+  * Do the shift of the next tabstop implied by
+  * insertion so it expands.
+  */
++void
+ vishft()
+ {
+ 	int tshft = 0;
+@@ -1004,6 +1028,7 @@ vishft()
+ /*
+  * Now do the insert of the characters (finally).
+  */
++static void
+ viin(c)
+ 	int c;		/* mjm: char --> int */
+ {
+@@ -1014,7 +1039,7 @@ viin(c)
+ 	short oldhold = hold;
+ 
+ 	hold |= HOLDPUPD;
+-	if (tabsize && (IM && EI) && inssiz - doomed > tabslack)
++	if (tabsize && (IM && EI) && inssiz - doomed > tabslack) {
+ 		/*
+ 		 * There is a tab out there which will be affected
+ 		 * by the insertion since there aren't enough doomed
+@@ -1053,6 +1078,7 @@ viin(c)
+ 				enddm();
+ 			}
+ 		}
++	}
+ 
+ 	/* 
+ 	 * Now put out the characters of the actual insertion.
+@@ -1175,6 +1201,7 @@ viin(c)
+  * is the same as that which goes into insert
+  * mode, then we are in delete mode already.
+  */
++void
+ godm()
+ {
+ 
+@@ -1194,6 +1221,7 @@ godm()
+  * if we just moved over to delete space from part of
+  * a tab (above).
+  */
++static void
+ enddm()
+ {
+ 
+@@ -1211,6 +1239,7 @@ enddm()
+  * if the terminal does all insertions a single character
+  * at a time, since it branches based on whether IM is null.
+  */
++void
+ goim()
+ {
+ 
+@@ -1219,6 +1248,7 @@ goim()
+ 	insmode = 1;
+ }
+ 
++void
+ endim()
+ {
+ 
+@@ -1238,6 +1268,7 @@ endim()
+  * you can erase overstrikes with some work.  CRT's which do underlining
+  * implicitly which has to be erased (like CONCEPTS) are also handled.
+  */
++int
+ vputchar(c)
+ 	register int c;
+ {
+@@ -1292,7 +1323,7 @@ vputchar(c)
+ 				*tp = overbuf;
+ #endif
+ 			destcol++;
+-			return;
++			return c;
+ 		}
+ 		/*
+ 		 * A ``space'' ontop of a part of a tab.
+@@ -1303,7 +1334,7 @@ vputchar(c)
+ 		if (vquot(*tp)) {
+ #endif
+ 			destcol++;
+-			return;
++			return c;
+ 		}
+ #ifndef	BIT8
+ 		c = ' ' | QUOTE;
+@@ -1328,7 +1359,7 @@ vputchar(c)
+ 
+ 	case '\t':
+ 		vgotab();
+-		return;
++		return c;
+ 
+ 	case ' ':
+ 		/*
+@@ -1349,7 +1380,7 @@ vputchar(c)
+ 			) {
+ 			*tp = ' ';
+ 			destcol++;
+-			return;
++			return c;
+ 		}
+ 		goto def;
+ 
+@@ -1374,7 +1405,7 @@ def:
+ 			if ((hold & HOLDPUPD) == 0)
+ 				*tp = c;
+ 			destcol++;
+-			return;
++			return c;
+ 		}
+ 		/*
+ 		 * Backwards looking optimization.
+@@ -1413,7 +1444,7 @@ def:
+ 		e = trim(c);
+ 		if (!insmode && d && d != ' ' && d != e) {
+ #endif
+-			if (EO && (OS || UL && (c == '_' || d == '_'))) {
++			if (EO && (OS || (UL && (c == '_' || d == '_')))) {
+ 				vputc(' ');
+ 				outcol++, destcol++;
+ 				back1();
+@@ -1478,12 +1509,14 @@ def:
+ 			vputc('\n');
+ 		}
+ 	}
++	return c;
+ }
+ 
+ /*
+  * Delete display positions stcol through endcol.
+  * Amount of use of special terminal features here is limited.
+  */
++void
+ physdc(stcol, endcol)
+ 	int stcol, endcol;
+ {
+@@ -1578,7 +1611,7 @@ physdc(stcol, endcol)
+ 	if (IN) {
+ 		up = vtube0 + stcol;
+ 		tp = vtube0 + endcol;
+-		while (i = *tp++) {
++		while ((i = *tp++) != 0) {
+ #ifndef	BIT8
+ 			if ((i & (QUOTE|TRIM)) == QUOTE)
+ #else
+@@ -1602,6 +1635,7 @@ physdc(stcol, endcol)
+ }
+ 
+ #ifdef TRACE
++void
+ tfixnl()
+ {
+ 
+@@ -1610,6 +1644,7 @@ tfixnl()
+ 	trubble = 0, techoin = 0;
+ }
+ 
++void
+ tvliny()
+ {
+ 	register int i;
+@@ -1630,6 +1665,7 @@ tvliny()
+ 	fprintf(trace, "\n");
+ }
+ 
++void
+ tracec(c)
+ 	int c;		/* mjm: char --> int */
+ {
+@@ -1652,6 +1688,7 @@ tracec(c)
+ /*
+  * Put a character with possible tracing.
+  */
++int
+ vputch(c)
+ 	int c;
+ {
+@@ -1660,5 +1697,5 @@ vputch(c)
+ 	if (trace)
+ 		tracec(c);
+ #endif
+-	vputc(c);
++	return vputc(c);
+ }
diff --git a/editors/ex/patches/patch-ex__vwind_c b/editors/ex/patches/patch-ex__vwind_c
new file mode 100644
index 00000000000..f3e20e22d72
--- /dev/null
+++ b/editors/ex/patches/patch-ex__vwind_c
@@ -0,0 +1,173 @@
+$NetBSD: patch-ex__vwind_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- avoid implicit int
+- hide unused function in the proper matching ifdef
+
+--- ex_vwind.c~	2012-12-27 21:58:41.000000000 +0000
++++ ex_vwind.c
+@@ -89,10 +89,14 @@ static char sccsid[] = "@(#)ex_vwind.c	1
+  * directions.  Code here is very dependent on mode (open versus visual).
+  */
+ 
+-int vfit __P((register line *, int));
+-int vrollR __P((register int));
+-line *vback __P((register line *, register int));
+-int vreset __P((int));
++static int vfit __P((register line *, int));
++static void vrollR __P((register int));
++static line *vback __P((register line *, register int));
++static void vreset __P((int));
++
++#ifndef CBREAK
++static int vcookit(register int cnt);
++#endif
+ 
+ /*
+  * Move in a nonlocal way to line addr.
+@@ -100,9 +104,11 @@ int vreset __P((int));
+  * New position for cursor is curs.
+  * Like most routines here, we vsave().
+  */
++void
+ vmoveto(addr, curs, context)
+ 	register line *addr;
+ 	char *curs;
++	int context;
+ {
+ 
+ 	markit(addr);
+@@ -114,9 +120,11 @@ vmoveto(addr, curs, context)
+  * Vjumpto is like vmoveto, but doesn't mark previous
+  * context or save linebuf as current line.
+  */
++void
+ vjumpto(addr, curs, context)
+ 	register line *addr;
+ 	char *curs;
++	int context;
+ {
+ 
+ 	noteit(0);
+@@ -131,6 +139,7 @@ vjumpto(addr, curs, context)
+ /*
+  * Go up or down cnt (negative is up) to new position curs.
+  */
++void
+ vupdown(cnt, curs)
+ 	register int cnt;
+ 	char *curs;
+@@ -152,6 +161,7 @@ vupdown(cnt, curs)
+  * If scroll, then we MUST use a scroll.
+  * Otherwise clear and redraw if motion is far.
+  */
++void
+ vup(cnt, ind, scroll)
+ 	register int cnt, ind;
+ 	bool scroll;
+@@ -201,6 +211,7 @@ okr:
+ /*
+  * Like vup, but scrolling down.
+  */
++void
+ vdown(cnt, ind, scroll)
+ 	register int cnt, ind;
+ 	bool scroll;
+@@ -250,8 +261,10 @@ dcontxt:
+  * Work here is in determining new top line implied by
+  * this placement of line addr, since we always draw from the top.
+  */
++void
+ vcontext(addr, where)
+ 	register line *addr;
++	int where;
+ {
+ 	register line *top;
+ 
+@@ -293,6 +306,7 @@ vcontext(addr, where)
+  * we may be able to reuse the line we are on
+  * if it is blank.  This is a real win.
+  */
++void
+ vclean()
+ {
+ 
+@@ -310,6 +324,7 @@ vclean()
+  * (and call us recursively).  Eventually, we clear the screen
+  * (or its open mode equivalent) and redraw.
+  */
++void
+ vshow(addr, top)
+ 	line *addr, *top;
+ {
+@@ -363,6 +378,7 @@ vshow(addr, top)
+  * area;  we are called this way in the middle of a :e escape
+  * from visual, e.g.
+  */
++static void
+ vreset(inecho)
+ 	bool inecho;
+ {
+@@ -378,7 +394,7 @@ vreset(inecho)
+  * Starting from which line preceding tp uses almost (but not more
+  * than) cnt physical lines?
+  */
+-line *
++static line *
+ vback(tp, cnt)
+ 	register int cnt;
+ 	register line *tp;
+@@ -399,6 +415,7 @@ vback(tp, cnt)
+ /*
+  * How much scrolling will it take to roll cnt lines starting at tp?
+  */
++static int
+ vfit(tp, cnt)
+ 	register line *tp;
+ 	int cnt;
+@@ -419,6 +436,7 @@ vfit(tp, cnt)
+ /*
+  * Roll cnt lines onto the screen.
+  */
++void
+ vroll(cnt)
+ 	register int cnt;
+ {
+@@ -460,6 +478,7 @@ vroll(cnt)
+ /*
+  * Roll backwards (scroll up).
+  */
++static void
+ vrollR(cnt)
+ 	register int cnt;
+ {
+@@ -504,16 +523,20 @@ vrollR(cnt)
+  * BUG:		An interrupt during a scroll in this way
+  *		dumps to command mode.
+  */
++#ifndef CBREAK
++static int
+ vcookit(cnt)
+ 	register int cnt;
+ {
+ 
+ 	return (cnt > 1 && (ospeed < B1200 && !initev || cnt > TLINES * 2));
+ }
++#endif
+ 
+ /*
+  * Determine displayed depth of current line.
+  */
++int
+ vdepth()
+ {
+ 	register int d;
+@@ -529,6 +552,7 @@ vdepth()
+ /*
+  * Move onto a new line, with cursor at position curs.
+  */
++void
+ vnline(curs)
+ 	char *curs;
+ {
diff --git a/editors/ex/patches/patch-ex_c b/editors/ex/patches/patch-ex_c
new file mode 100644
index 00000000000..b8df97f15fa
--- /dev/null
+++ b/editors/ex/patches/patch-ex_c
@@ -0,0 +1,122 @@
+$NetBSD: patch-ex_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- declare void functions void
+- avoid implicit int
+- use volatile for compiler warnings about setjmp/vfork clobbering
+- silence warnings about assignments in conditionals
+
+--- ex.c~	2003-03-18 20:47:50.000000000 +0000
++++ ex.c
+@@ -144,13 +144,15 @@ char	tttrace[]	= { '/','d','e','v','/','
+ 
+ static char *progname;
+ 
+-erropen()
++static void
++erropen(void)
+ {
+ 	close(1);
+ 	dup(2);
+ }
+ 
+-usage()
++static void
++usage(void)
+ {
+ 	printf(catgets(catd, 1, 1, "\
+ Usage: %s [- | -s] [-l] [-L] [-R] [-r [file]] [-t tag]\n\
+@@ -160,7 +162,8 @@ Usage: %s [- | -s] [-l] [-L] [-R] [-r [f
+ 	exitex(1);
+ }
+ 
+-needarg(c)
++static void
++needarg(int c)
+ {
+ 	erropen();
+ 	printf(catgets(catd, 1, 2,
+@@ -168,7 +171,8 @@ needarg(c)
+ 	usage();
+ }
+ 
+-invopt(c)
++static void
++invopt(int c)
+ {
+ 	erropen();
+ 	printf(catgets(catd, 1, 3, "%s: illegal option -- %c\n"), progname, c);
+@@ -178,9 +182,8 @@ invopt(c)
+ /*
+  * Return last component of unix path name p.
+  */
+-char *
+-tailpath(p)
+-register char *p;
++static char *
++tailpath(register char *p)
+ {
+ 	register char *r;
+ 
+@@ -194,8 +197,8 @@ register char *p;
+  * Check ownership of file.  Return nonzero if it exists and is owned by the
+  * user or the option sourceany is used
+  */
+-iownit(file)
+-char *file;
++static int
++iownit(const char *file)
+ {
+ 	struct stat sb;
+ 
+@@ -214,8 +217,7 @@ char *file;
+ 
+ #ifdef	POSIX_1
+ shand
+-setsig(signum, handler)
+-shand handler;
++setsig(int signum, shand handler)
+ {
+ 	struct sigaction nact, oact;
+ 
+@@ -244,7 +246,8 @@ shand handler;
+  * Main thing here is to get a new buffer (in fileinit),
+  * rest is peripheral state resetting.
+  */
+-init()
++void
++init(void)
+ {
+ 	register int i;
+ 
+@@ -268,6 +271,7 @@ init()
+  * there is a 'd' in our name.  For edit we just diddle options;
+  * for vi we actually force an early visual command.
+  */
++int
+ main(ac, av)
+ 	register int ac;
+ 	register char *av[];
+@@ -280,7 +284,13 @@ main(ac, av)
+ #endif
+ 		char *cp = NULL;
+ 	register int c;
++#ifdef __STDC__
++	volatile
++#endif
+ 	bool ivis;
++#ifdef __STDC__
++	volatile
++#endif
+ 	bool fast = 0;
+ #ifdef TRACE
+ 	register char *tracef;
+@@ -560,7 +570,7 @@ argend:
+ 		setrupt();
+ 		intty = isatty(0);
+ 		value(PROMPT) = intty;
+-		if (cp = getenv("SHELL"))
++		if ((cp = getenv("SHELL")) != NULL)
+ 			strcpy(shell, cp);
+ 		if (fast || !intty)
+ 			setterm("dumb");
diff --git a/editors/ex/patches/patch-expreserve_c b/editors/ex/patches/patch-expreserve_c
new file mode 100644
index 00000000000..9a2da49a846
--- /dev/null
+++ b/editors/ex/patches/patch-expreserve_c
@@ -0,0 +1,90 @@
+$NetBSD: patch-expreserve_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare void functions void
+- use static for local functions
+- use a bit of const
+- silence gcc warnings about unused arguments
+- avoid implicit int
+- don't pass a string constant to putenv()
+
+--- expreserve.c.orig	2002-08-27 04:14:56.000000000 +0000
++++ expreserve.c
+@@ -203,10 +203,10 @@ char xstr[1];			/* make loader happy */
+ #endif
+ #endif
+ 
+-int notify __P((uid_t uid, char *fname, int flag, time_t time));
+-int copyout __P((char *name));
+-int mkdigits __P((char *cp));
+-int mknext __P((char *cp));
++static void notify __P((uid_t uid, const char *fname, int flag, time_t time));
++static int copyout __P((char *name));
++static void mkdigits __P((char *cp));
++static void mknext __P((char *cp));
+ 
+ /*
+  * Expreserve - preserve a file in /usr/preserve
+@@ -275,6 +275,7 @@ char **argv;
+ 			exit(1);
+ 		exit(0);
+ 	}
++	(void)argv;
+ 
+ 	/*
+ 	 * If not super user, then can only preserve standard input.
+@@ -328,9 +329,11 @@ char	pattern[] =	"/var/preserve/Exa`XXXX
+ /*
+  * Notify user uid that his file fname has been saved.
+  */
++static void
+ notify(uid, fname, flag, time)
+ 	uid_t uid;
+-	char *fname;
++	const char *fname;
++	int flag;
+ 	time_t	time;
+ {
+ 	struct passwd *pp = getpwuid(uid);
+@@ -345,6 +348,9 @@ notify(uid, fname, flag, time)
+ 	char	croak[128];
+ 	char	*timestamp, *ctime();
+ 
++	/* cannot properly string constants to putenv */
++	static char mailrc_var[] = "MAILRC=/dev/null";
++
+ 	if (pp == NULL)
+ 		return;
+ #ifndef	POSIX_1
+@@ -355,7 +361,7 @@ notify(uid, fname, flag, time)
+ #endif
+ 	timestamp = ctime(&time);
+ 	timestamp[16] = 0;	/* blast from seconds on */
+-	putenv("MAILRC=/dev/null");
++	putenv(mailrc_var);
+ 	sprintf(cmd, "/bin/mail %s", pp->pw_name);
+ 	setuid(getuid());
+ 	mf = popen(cmd, "w");
+@@ -411,6 +417,7 @@ notify(uid, fname, flag, time)
+  * file (this is the slowest thing since we must stat
+  * to find a unique name), and finally copy the file.
+  */
++static int
+ copyout(name)
+ 	char *name;
+ {
+@@ -546,6 +553,7 @@ format:
+ /*
+  * Blast the last 5 characters of cp to be the process number.
+  */
++static void
+ mkdigits(cp)
+ 	char *cp;
+ {
+@@ -566,6 +574,7 @@ mkdigits(cp)
+  * three alphabetic characters into a sequence of the form 'aab', 'aac', etc.
+  * Mktemp gets weird names too quickly to be useful here.
+  */
++static void
+ mknext(cp)
+ 	char *cp;
+ {
diff --git a/editors/ex/patches/patch-exrecover_c b/editors/ex/patches/patch-exrecover_c
index 2b114aae0c9..f943fcac58a 100644
--- a/editors/ex/patches/patch-exrecover_c
+++ b/editors/ex/patches/patch-exrecover_c
@@ -1,23 +1,333 @@
-$NetBSD: patch-exrecover_c,v 1.1 2011/08/01 05:47:40 dholland Exp $
+$NetBSD: patch-exrecover_c,v 1.2 2012/12/28 03:03:09 dholland Exp $
 
-Fix illegal C caught by clang.
+- use standard headers
+- don't declare own perror
+- declare void functions void
+- avoid implicit int
+- silence signed/unsigned compiler warning
+- use const for string constants
+- silence warnings about assignments in conditionals
+- return values from non-void functions
+- silence warnings about unused arguments
 
---- exrecover.c~	2002-04-07 12:02:27.000000000 +0000
+--- exrecover.c.orig	2012-12-27 21:58:41.000000000 +0000
 +++ exrecover.c
-@@ -198,7 +198,7 @@ char *getblock __P((line, int));
- int blkio __P((bloc, char *, ssize_t (*) __P((int, void *, size_t))));
+@@ -98,6 +98,8 @@ static char sccsid[] UNUSED = "@(#)exrec
+ typedef	int	xFILE;
+ #endif
+ 
++#include <stdio.h>
++
+ #define	var
+ 
+ #include "ex.h"
+@@ -193,30 +195,30 @@ int	vercnt;			/* Count number of version
+ #endif
+ #endif
+ 
+-extern int perror __P((const char *));
+ char *getblock __P((line, int));
+-int blkio __P((bloc, char *, ssize_t (*) __P((int, void *, size_t))));
++void blkio __P((bloc, char *, ssize_t (*) __P((int, void *, size_t))));
  char *poolsbrk __P((intptr_t));
- int error __P((char *str, ...));
+-int error __P((char *str, ...));
 -int listfiles __P((char *));
-+void listfiles __P((char *));
- int enter __P((struct svfile *, char *, int));
+-int enter __P((struct svfile *, char *, int));
++void error __P((const char *str, ...));
++void listfiles __P((const char *));
++void enter __P((struct svfile *, char *, int));
  int qucmp __P((struct svfile *, struct svfile *));
- int findtmp __P((char *));
-@@ -384,6 +384,7 @@ error(char *str, ...)
+-int findtmp __P((char *));
+-int searchdir __P((char *));
+-int yeah __P((char *));
++void findtmp __P((const char *));
++void searchdir __P((const char *));
++int yeah __P((const char *));
+ int preserve __P((void));
+-int scrapbad __P((void));
+-int putfile __P((int));
+-int wrerror __P((void));
+-int clrstats __P((void));
+-int get_line __P((line));
+-int syserror __P((void));
+-int xvfprintf __P((xFILE *, char *, va_list));
+-int xfprintf __P((xFILE *, char *, ...));
++void scrapbad __P((void));
++void putfile __P((int));
++void wrerror __P((void));
++void clrstats __P((void));
++void get_line __P((line));
++void syserror __P((void));
++void xvfprintf __P((xFILE *, const char *, va_list));
++void xfprintf __P((xFILE *, const char *, ...));
+ #ifdef	__STDC__
+ int vsprintf(char *, const char *, va_list);
+ #endif
+ 
++int
+ main(argc, argv)
+ 	int argc;
+ 	char *argv[];
+@@ -295,7 +297,7 @@ main(argc, argv)
+ 	while (H.Flines > 0) {
+ 		ignorl(lseek(tfile, (off_t) ((blocks[b] & BLKMSK) * BUFSIZ),
+ 					SEEK_SET));
+-		i = H.Flines < BUFSIZ / sizeof (line) ?
++		i = H.Flines < (int)(BUFSIZ / sizeof (line)) ?
+ 			H.Flines * sizeof (line) : BUFSIZ;
+ 		if (read(tfile, (char *) dot, i) != i) {
+ 			perror(nb);
+@@ -350,13 +352,14 @@ main(argc, argv)
+  * a newline which would screw up the screen.
+  */
+ /*VARARGS2*/
++void
+ #ifndef	__STDC__
+ error(str, inf)
+-	char *str;
++	const char *str;
+ 	int inf;
+ {
+ #else
+-error(char *str, ...)
++error(const char *str, ...)
+ {
+ 	va_list ap;
+ #endif
+@@ -384,8 +387,9 @@ error(char *str, ...)
  	exit(1);
  }
  
 +void
  listfiles(dirname)
- 	char *dirname;
+-	char *dirname;
++	const char *dirname;
+ {
+ 	register DIR *dir;
+ #ifndef	POSIX_1
+@@ -486,9 +490,11 @@ listfiles(dirname)
+ /*
+  * Enter a new file into the saved file information.
+  */
++void
+ enter(fp, fname, count)
+ 	struct svfile *fp;
+ 	char *fname;
++	int count;
+ {
+ 	register char *cp, *cp2;
+ 	register struct svfile *f, *fl;
+@@ -521,7 +527,7 @@ enter(fp, fname, count)
+ 	fp->sf_time = H.Time;
+ 	fp->sf_lines = H.Flines;
+ 	cp2 = fp->sf_name, cp = savedfile;
+-	while (*cp2++ = *cp++);
++	while ((*cp2++ = *cp++) != 0);
+ 	for (cp2 = fp->sf_entry, cp = fname; *cp && cp-fname < 14;)
+ 		*cp2++ = *cp++;
+ 	*cp2++ = 0;
+@@ -531,12 +537,13 @@ enter(fp, fname, count)
+  * Do the qsort compare to sort the entries first by file name,
+  * then by modify time.
+  */
++int
+ qucmp(p1, p2)
+ 	struct svfile *p1, *p2;
+ {
+ 	register int t;
+ 
+-	if (t = strcmp(p1->sf_name, p2->sf_name))
++	if ((t = strcmp(p1->sf_name, p2->sf_name)) != 0)
+ 		return(t);
+ 	if (p1->sf_time > p2->sf_time)
+ 		return(-1);
+@@ -555,8 +562,9 @@ int	bestfd;			/* Keep best file open so 
+  * (i.e. usually /tmp) and in /usr/preserve.
+  * Want to find the newest so we search on and on.
+  */
++void
+ findtmp(dir)
+-	char *dir;
++	const char *dir;
+ {
+ 
+ 	/*
+@@ -608,8 +616,9 @@ findtmp(dir)
+  * name of the file we want to unlink is relative, rather than absolute
+  * we won't be able to find it again.
+  */
++void
+ searchdir(dirname)
+-	char *dirname;
++	const char *dirname;
+ {
+ #ifndef	POSIX_1
+ 	struct direct *dirent;
+@@ -662,8 +671,9 @@ searchdir(dirname)
+  * if its really an editor temporary and of this
+  * user and the file specified.
+  */
++int
+ yeah(name)
+-	char *name;
++	const char *name;
+ {
+ 
+ 	tfile = open(name, O_RDWR);
+@@ -688,9 +698,10 @@ nope:
+ 	return (1);
+ }
+ 
++int
+ preserve()
+ {
+-
++	return 0;
+ }
+ 
+ /*
+@@ -707,6 +718,7 @@ preserve()
+  * This only seems to happen on very heavily loaded systems, and
+  * not very often.
+  */
++void
+ scrapbad()
+ {
+ 	register line *ip;
+@@ -791,6 +803,7 @@ null:
+  * Aw shucks, if we only had a (void) cast.
+  */
+ #ifdef lint
++void
+ Ignorl(a)
+ 	long a;
  {
+@@ -798,6 +811,7 @@ Ignorl(a)
+ 	a = a;
+ }
+ 
++void
+ Ignore(a)
+ 	char *a;
+ {
+@@ -805,13 +819,15 @@ Ignore(a)
+ 	a = a;
+ }
+ 
++void
+ Ignorf(a)
+-	int (*a)();
++	void (*a)(int);
+ {
+ 
+ 	a = a;
+ }
+ 
++void
+ ignorl(a)
+ 	long a;
+ {
+@@ -824,12 +840,15 @@ int	cntch, cntln, cntodd, cntnull;
+ /*
+  * Following routines stolen mercilessly from ex.
+  */
+-putfile(unused)
++void
++putfile(int unused)
+ {
+ 	line *a1;
+ 	register char *fp, *lp;
+ 	register int nib;
+ 
++	(void)unused;
++
+ 	a1 = addr1;
+ 	clrstats();
+ 	cntln = addr2 - a1 + 1;
+@@ -861,12 +880,14 @@ putfile(unused)
+ 	cntch += nib;
+ }
+ 
++void
+ wrerror()
+ {
+ 
+ 	syserror();
+ }
+ 
++void
+ clrstats()
+ {
+ 
+@@ -880,6 +901,7 @@ clrstats()
+ #define	READ	0
+ #define	WRITE	1
+ 
++void
+ get_line(tl)
+ 	line tl;
+ {
+@@ -890,7 +912,7 @@ get_line(tl)
+ 	bp = getblock(tl, READ);
+ 	nl = nleft;
+ 	tl &= ~OFFMSK;
+-	while (*lp++ = *bp++)
++	while ((*lp++ = *bp++) != 0)
+ 		if (--nl == 0) {
+ 			bp = getblock(tl += INCRMT, READ);
+ 			nl = nleft;
+@@ -934,8 +956,8 @@ getblock(atl, iof)
+ 	return (obuff + off);
+ }
+ 
++void
+ #ifdef	__STDC__
+-int
+ blkio(bloc b, char *buf, ssize_t (*iofcn)(int, void *, size_t))
+ #else	/* !__STDC__ */
+ blkio(b, buf, iofcn)
+@@ -950,6 +972,7 @@ blkio(b, buf, iofcn)
+ 		syserror();
+ }
+ 
++void
+ syserror()
+ {
+ 
+@@ -964,10 +987,11 @@ syserror()
+  * allocation and stdio uses malloc.
+  */
+ #ifndef	__STDC__
++void
+ xfprintf(fp, fmt, a1, a2, a3, a4, a5)
+ 	xFILE *fp;
+-	char *fmt;
+-	char *a1, *a2, *a3, *a4, *a5;
++	const char *fmt;
++	const char *a1, *a2, *a3, *a4, *a5;
+ {
+ 	char buf[BUFSIZ];
+ 
+@@ -981,17 +1005,19 @@ xfprintf(fp, fmt, a1, a2, a3, a4, a5)
+  * I do not know whether vsprintf() uses malloc() or not.
+  * So this may be fail, too.
+  */
+-xvfprintf(xFILE *fp, char *fmt, va_list ap)
++void
++xvfprintf(xFILE *fp, const char *fmt, va_list ap)
+ {
+ 	char buf[BUFSIZ];
+ 
+ 	if (fp != xstderr)
+ 		return;
+-	vsprintf(buf, fmt, ap);
++	vsnprintf(buf, sizeof(buf), fmt, ap);
+ 	write(2, buf, strlen(buf));
+ }
+ 
+-xfprintf(xFILE *fp, char *fmt, ...)
++void
++xfprintf(xFILE *fp, const char *fmt, ...)
+ {
+ 	va_list ap;
+ 
diff --git a/editors/ex/patches/patch-libterm_libterm_h b/editors/ex/patches/patch-libterm_libterm_h
new file mode 100644
index 00000000000..6eb244b2516
--- /dev/null
+++ b/editors/ex/patches/patch-libterm_libterm_h
@@ -0,0 +1,23 @@
+$NetBSD: patch-libterm_libterm_h,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- use const for string constants
+- declare type of function pointer properly
+
+--- libterm/libterm.h.orig	2002-02-04 01:30:04.000000000 +0000
++++ libterm/libterm.h
+@@ -56,9 +56,9 @@
+ #endif
+ #endif
+ 
+-int tgetent __P((char *, char *));
+-int tgetnum __P((char *));
+-int tgetflag __P((char *));
+-char *tgetstr __P((char *, char **));
+-char *tgoto __P((char *, int, int));
+-int tputs __P((register char *, int, int (*)()));
++int tgetent __P((char *, const char *));
++int tgetnum __P((const char *));
++int tgetflag __P((const char *));
++char *tgetstr __P((const char *, char **));
++const char *tgoto __P((char *, int, int));
++void tputs __P((register const char *, int, int (*)(int)));
diff --git a/editors/ex/patches/patch-libterm_termcap_c b/editors/ex/patches/patch-libterm_termcap_c
new file mode 100644
index 00000000000..5cc467454d7
--- /dev/null
+++ b/editors/ex/patches/patch-libterm_termcap_c
@@ -0,0 +1,77 @@
+$NetBSD: patch-libterm_termcap_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare local functions static
+- avoid implicit int
+- use const for string constants
+
+--- libterm/termcap.c.orig	2004-01-03 14:17:30.000000000 +0000
++++ libterm/termcap.c
+@@ -93,6 +93,7 @@ int	tgetent();
+  * against each such name.  The normal : terminator after the last
+  * name (before the first field) stops us.
+  */
++static int
+ tnamatch(np)
+ 	char *np;
+ {
+@@ -121,6 +122,7 @@ tnamatch(np)
+  * entries to say "like an HP2621 but doesn't turn on the labels".
+  * Note that this works because of the left to right scan.
+  */
++static int
+ tnchktc()
+ {
+ 	register char *p, *q;
+@@ -179,8 +181,10 @@ tnchktc()
+  * from the termcap file.  Parse is very rudimentary;
+  * we just notice escaped newlines.
+  */
++int
+ tgetent(bp, name)
+-	char *bp, *name;
++	char *bp;
++	const char *name;
+ {
+ 	register char *cp;
+ 	register int c;
+@@ -281,8 +285,9 @@ tskip(bp)
+  * a # character.  If the option is not found we return -1.
+  * Note that we handle octal numbers beginning with 0.
+  */
++int
+ tgetnum(id)
+-	char *id;
++	const char *id;
+ {
+ 	register int i, base;
+ 	register char *bp = tbuf;
+@@ -314,8 +319,9 @@ tgetnum(id)
+  * of the buffer.  Return 1 if we find the option, or 0 if it is
+  * not given.
+  */
++int
+ tgetflag(id)
+-	char *id;
++	const char *id;
+ {
+ 	register char *bp = tbuf;
+ 
+@@ -342,7 +348,8 @@ tgetflag(id)
+  */
+ char *
+ tgetstr(id, area)
+-	char *id, **area;
++	const char *id;
++	char **area;
+ {
+ 	register char *bp = tbuf;
+ 
+@@ -372,7 +379,7 @@ tdecode(str, area)
+ {
+ 	register char *cp;
+ 	register int c;
+-	register char *dp;
++	register const char *dp;
+ 	int i;
+ 
+ 	cp = *area;
diff --git a/editors/ex/patches/patch-libterm_tgoto_c b/editors/ex/patches/patch-libterm_tgoto_c
new file mode 100644
index 00000000000..bd8bffbc045
--- /dev/null
+++ b/editors/ex/patches/patch-libterm_tgoto_c
@@ -0,0 +1,25 @@
+$NetBSD: patch-libterm_tgoto_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- use const for string constants
+- silence warnings about assignments in conditionals
+
+--- libterm/tgoto.c~	2002-02-04 01:30:04.000000000 +0000
++++ libterm/tgoto.c
+@@ -83,7 +83,7 @@ char	*BC;
+  *
+  * all other characters are ``self-inserting''.
+  */
+-char *
++const char *
+ tgoto(CM, destcol, destline)
+ 	char *CM;
+ 	int destcol, destline;
+@@ -104,7 +104,7 @@ toohard:
+ 		return ("OOPS");
+ 	}
+ 	added[0] = 0;
+-	while (c = *cp++) {
++	while ((c = *cp++) != 0) {
+ 		if (c != '%') {
+ 			*dp++ = c;
+ 			continue;
diff --git a/editors/ex/patches/patch-libterm_tputs_c b/editors/ex/patches/patch-libterm_tputs_c
new file mode 100644
index 00000000000..e271e59584a
--- /dev/null
+++ b/editors/ex/patches/patch-libterm_tputs_c
@@ -0,0 +1,32 @@
+$NetBSD: patch-libterm_tputs_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- declare void functions void
+- use const for string constants
+- fix up function pointer casting mess
+- silence signed/unsigned compiler warning
+
+--- libterm/tputs.c.orig	2002-02-04 03:15:46.000000000 +0000
++++ libterm/tputs.c
+@@ -71,10 +71,11 @@ char	PC;
+  * The number of affected lines is affcnt, and the routine
+  * used to output one character is outc.
+  */
++void
+ tputs(cp, affcnt, outc)
+-	register char *cp;
++	register const char *cp;
+ 	int affcnt;
+-	int (*outc)();
++	int (*outc)(int);
+ {
+ 	register int i = 0;
+ 	register int mspc10;
+@@ -121,7 +122,7 @@ tputs(cp, affcnt, outc)
+ 	 */
+ 	if (i == 0)
+ 		return;
+-	if (ospeed <= 0 || ospeed >= (sizeof tmspc10 / sizeof tmspc10[0]))
++	if (ospeed <= 0 || ospeed >= (int)(sizeof tmspc10 / sizeof tmspc10[0]))
+ 		return;
+ 
+ 	/*
diff --git a/editors/ex/patches/patch-printf_c b/editors/ex/patches/patch-printf_c
new file mode 100644
index 00000000000..bbddb4b5035
--- /dev/null
+++ b/editors/ex/patches/patch-printf_c
@@ -0,0 +1,205 @@
+$NetBSD: patch-printf_c,v 1.1 2012/12/28 03:03:09 dholland Exp $
+
+- use standard headers
+  (this is supposed to substitute for libc's printf, so it *must*
+  match stdio.h)
+- use own headers
+- declare local functions static
+- avoid implicit int
+- return values from non-void functions
+- use const for string constants
+- remove/replace code that intentionally uses signed overflow
+
+--- printf.c.orig	2012-12-27 21:57:52.000000000 +0000
++++ printf.c
+@@ -82,6 +82,8 @@ static char sccsid[] = "@(#)printf.c	1.1
+ /* The pwb version this is based on */
+ /* from printf.c:2.2 6/5/79 */
+ 
++#include <stdio.h>
++
+ #ifndef	__STDC__
+ #include "varargs.h"
+ #else
+@@ -95,6 +97,8 @@ extern	nl_catd	catd;
+ #define	catgets(a, b, c, d)	(d)
+ #endif
+ 
++#include "ex.h"
++#include "ex_proto.h"
+ #include "config.h"
+ 
+ /*
+@@ -115,15 +119,13 @@ extern	nl_catd	catd;
+ 
+ static int width, sign, fill;
+ 
+-extern int putchar __P((int));
+-
+-char *p_dconv __P((long, char *));
+-int p_emit __P((char *, char *));
++static void p_emit __P((const char *, const char *));
+ 
+ #ifdef	__STDC__
+ int vprintf(const char *fmt, va_list ap);
+ #endif
+ 
++int
+ #ifndef	__STDC__
+ printf(va_alist)
+ 	va_dcl
+@@ -155,14 +157,17 @@ printf(const char *fmt, ...)
+ 	return ret;
+ }
+ 
++int
+ vprintf(const char *fmt, va_list ap)
+ {
+ 	char fcode;
+ 	int prec;
+ 	int length,mask1,nbits,n;
+ 	long int mask2, num;
+-	register char *bptr;
+-	char *ptr;
++	unsigned long unum;
++	register const char *bptr;
++	register char *vbptr;
++	const char *ptr;
+ 	char buf[134];
+ #endif	/* __STDC__ */
+ 
+@@ -171,7 +176,7 @@ vprintf(const char *fmt, va_list ap)
+ 		while ((fcode = *fmt++)!='%') {
+ 			/* ordinary (non-%) character */
+ 			if (fcode=='\0')
+-				return;
++				return 0;
+ 			putchar(fcode);
+ 		}
+ 		/* length modifier: -1 for h, 1 for l, 0 for none */
+@@ -288,18 +293,18 @@ vprintf(const char *fmt, va_list ap)
+ 					nbits = 4;
+ 				}
+ 				n = (num!=0);
+-				bptr = buf + MAXOCT + 3;
++				vbptr = buf + MAXOCT + 3;
+ 				/* shift and mask for speed */
+ 				do
+ 				    if (((int) num & mask1) < 10)
+-					*--bptr = ((int) num & mask1) + 060;
++					*--vbptr = ((int) num & mask1) + 060;
+ 				    else
+-					*--bptr = ((int) num & mask1) + 0127;
+-				while (num = (num >> nbits) & mask2);
++					*--vbptr = ((int) num & mask1) + 0127;
++				while ((num = (num >> nbits) & mask2) != 0);
+ 				
+ 				if (fcode=='o') {
+ 					if (n)
+-						*--bptr = '0';
++						*--vbptr = '0';
+ 				}
+ 				else
+ 					if (!sign && fill <= 0) {
+@@ -308,9 +313,10 @@ vprintf(const char *fmt, va_list ap)
+ 						width -= 2;
+ 					}
+ 					else {
+-						*--bptr = fcode;
+-						*--bptr = '0';
++						*--vbptr = fcode;
++						*--vbptr = '0';
+ 					}
++				bptr = vbptr;
+ 				ptr = buf + MAXOCT + 3;
+ 				break;
+ 			case 'D':
+@@ -331,14 +337,20 @@ vprintf(const char *fmt, va_list ap)
+ 					else
+ 						num = (long) n;
+ 				}
+-				if (n = (fcode != 'u' && num < 0))
+-					num = -num;
++				if ((n = (fcode != 'u' && num < 0)) != 0) {
++					/* avoid overflow on -LONG_MAX */
++					unum = ((unsigned long)-(num + 1)) + 1;
++				}
++				else {
++					unum = (unsigned long) num;
++				}
+ 				/* now convert to digits */
+-				bptr = p_dconv(num, buf);
++				vbptr = p_dconv(unum, buf);
+ 				if (n)
+-					*--bptr = '-';
++					*--vbptr = '-';
+ 				if (fill == 0)
+ 					fill = -1;
++				bptr = vbptr;
+ 				ptr = buf + MAXDIGS + 1;
+ 				break;
+ 			default:
+@@ -369,13 +381,15 @@ vprintf(const char *fmt, va_list ap)
+  */
+ char *
+ p_dconv(value, buffer)
+-	long value;
++	unsigned long value;
+ 	char *buffer;
+ {
+ 	register char *bp;
+-	register int svalue;
++	register unsigned int svalue;
++#if 0
+ 	int n;
+ 	long lval;
++#endif
+ 	
+ 	bp = buffer;
+ 	
+@@ -386,6 +400,7 @@ p_dconv(value, buffer)
+ 		return(bp);
+ 	}
+ 	
++#if 0 /* original code, undefined behavior */
+ 	/* develop the leading digit of the value in "n" */
+ 	n = 0;
+ 	while (value < 0) {
+@@ -399,6 +414,7 @@ p_dconv(value, buffer)
+ 	
+ 	/* stash it in buffer[1] to allow for a sign */
+ 	bp[1] = n + '0';
++#endif
+ 	/*
+ 	 * Now develop the rest of the digits. Since speed counts here,
+ 	 * we do it in two loops. The first gets "value" down until it
+@@ -417,13 +433,15 @@ p_dconv(value, buffer)
+ 		*--bp = (svalue % 10) + '0';
+ 		svalue /= 10;
+ 	}
+-	
++
++#if 0	
+ 	/* fill in intermediate zeroes if needed */
+ 	if (buffer[1] != '0') {
+ 		while (bp > buffer + 2)
+ 			*--bp = '0';
+ 		--bp;
+ 	}
++#endif
+ 	return(bp);
+ }
+ 
+@@ -439,9 +457,10 @@ p_dconv(value, buffer)
+  * any padding in right-justification (to avoid printing "-3" as
+  * "000-3" where "-0003" was intended).
+  */
++static void
+ p_emit(s, send)
+-	register char *s;
+-	char *send;
++	register const char *s;
++	const char *send;
+ {
+ 	char cfill;
+ 	register int alen;
author	dholland <dholland>	2012-12-28 03:03:08 +0000
committer	dholland <dholland>	2012-12-28 03:03:08 +0000
commit	07b24342c151565b853024240776c2856aee34ef (patch)
tree	8c0484149657a50a301fa0bcb9d58f2f596c8985 /editors
parent	ad2c90a7d99400d4797dcba661d63a6ce9a6a683 (diff)
download	pkgsrc-07b24342c151565b853024240776c2856aee34ef.tar.gz