Index: stable/9/Makefile.inc1
===================================================================
--- stable/9/Makefile.inc1	(revision 275050)
+++ stable/9/Makefile.inc1	(revision 275051)
@@ -1,1790 +1,1794 @@
 #
 # $FreeBSD$
 #
 # Make command line options:
 #	-DNO_CLEANDIR run ${MAKE} clean, instead of ${MAKE} cleandir
 #	-DNO_CLEAN do not clean at all
 #	-DDB_FROM_SRC use the user/group databases in src/etc instead of
 #	    the system database when installing.
 #	-DNO_SHARE do not go into share subdir
 #	-DKERNFAST define NO_KERNEL{CONFIG,CLEAN,DEPEND,OBJ}
 #	-DNO_KERNELCONFIG do not run config in ${MAKE} buildkernel
 #	-DNO_KERNELCLEAN do not run ${MAKE} clean in ${MAKE} buildkernel
 #	-DNO_KERNELDEPEND do not run ${MAKE} depend in ${MAKE} buildkernel
 #	-DNO_KERNELOBJ do not run ${MAKE} obj in ${MAKE} buildkernel
 #	-DNO_PORTSUPDATE do not update ports in ${MAKE} update
 #	-DNO_ROOT install without using root privilege
 #	-DNO_DOCUPDATE do not update doc in ${MAKE} update
 #	-DNO_CTF do not run the DTrace CTF conversion tools on built objects
 #	LOCAL_DIRS="list of dirs" to add additional dirs to the SUBDIR list
 #	LOCAL_MTREE="list of mtree files" to process to allow local directories
 #	    to be created before files are installed
 #	METALOG="path to metadata log" to write permission and ownership
 #	    when NO_ROOT is set.  (default: ${DESTDIR}/METALOG)
 #	TARGET="machine" to crossbuild world for a different machine type
 #	TARGET_ARCH= may be required when a TARGET supports multiple endians
 #	BUILDENV_SHELL= shell to launch for the buildenv target (def:/bin/sh)
 #	WORLD_FLAGS= additional flags to pass to make(1) during buildworld
 #	KERNEL_FLAGS= additional flags to pass to make(1) during buildkernel
 
 #
 # The intended user-driven targets are:
 # buildworld  - rebuild *everything*, including glue to help do upgrades
 # installworld- install everything built by "buildworld"
 # doxygen     - build API documentation of the kernel
 # update      - convenient way to update your source tree (eg: cvsup/cvs)
 #
 # Standard targets (not defined here) are documented in the makefiles in
 # /usr/share/mk.  These include:
 #		obj depend all install clean cleandepend cleanobj
 
 # You are supposed to define both of these when calling Makefile.inc1
 # directly.  However, some old scripts don't.  Cope for the moment, but
 # issue a new warning for a transition period.
 .if defined(TARGET) && !defined(TARGET_ARCH)
 .warning "You must pass both TARGET and TARGET_ARCH to Makefile.inc1.  Setting TARGET_ARCH=${TARGET}."
 TARGET_ARCH=${TARGET}
 .endif
 .if !defined(TARGET) || !defined(TARGET_ARCH)
 .error "Both TARGET and TARGET_ARCH must be defined."
 .endif
 
 .include <bsd.own.mk>
 .include <bsd.arch.inc.mk>
 .include <bsd.compiler.mk>
 
 # We must do share/info early so that installation of info `dir'
 # entries works correctly.  Do it first since it is less likely to
 # grow dependencies on include and lib than vice versa.
 #
 # We must do lib/ and libexec/ before bin/, because if installworld
 # installs a new /bin/sh, the 'make' command will *immediately*
 # use that new version.  And the new (dynamically-linked) /bin/sh
 # will expect to find appropriate libraries in /lib and /libexec.
 #
 SRCDIR?=	${.CURDIR}
 .if defined(SUBDIR_OVERRIDE)
 SUBDIR=	${SUBDIR_OVERRIDE}
 .else
 SUBDIR=	share/info lib libexec
 SUBDIR+=bin
 .if ${MK_GAMES} != "no"
 SUBDIR+=games
 .endif
 .if ${MK_CDDL} != "no"
 SUBDIR+=cddl
 .endif
 SUBDIR+=gnu include
 .if ${MK_KERBEROS} != "no"
 SUBDIR+=kerberos5
 .endif
 .if ${MK_RESCUE} != "no"
 SUBDIR+=rescue
 .endif
 SUBDIR+=sbin
 .if ${MK_CRYPT} != "no"
 SUBDIR+=secure
 .endif
 .if !defined(NO_SHARE)
 SUBDIR+=share
 .endif
 SUBDIR+=sys usr.bin usr.sbin
 .if ${MK_OFED} != "no"
 SUBDIR+=contrib/ofed
 .endif
 #
 # We must do etc/ last for install/distribute to work.
 #
 SUBDIR+=etc
 
 # These are last, since it is nice to at least get the base system
 # rebuilt before you do them.
 .for _DIR in ${LOCAL_DIRS}
 .if exists(${.CURDIR}/${_DIR}/Makefile)
 SUBDIR+= ${_DIR}
 .endif
 .endfor
 .endif
 
 .if defined(NOCLEAN)
 NO_CLEAN=	${NOCLEAN}
 .endif
 .if defined(NO_CLEANDIR)
 CLEANDIR=	clean cleandepend
 .else
 CLEANDIR=	cleandir
 .endif
 
 BUILDENV_SHELL?=/bin/sh
 
 SVN?=		/usr/local/bin/svn
 SVNFLAGS?=	-r HEAD
 
 MAKEOBJDIRPREFIX?=	/usr/obj
 .if !defined(OSRELDATE)
 .if exists(/usr/include/osreldate.h)
 OSRELDATE!=	awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
 		/usr/include/osreldate.h
 .else
 OSRELDATE=	0
 .endif
 .endif
 
 .if !defined(VERSION)
 REVISION!=	${MAKE} -C ${SRCDIR}/release -V REVISION
 BRANCH!=	${MAKE} -C ${SRCDIR}/release -V BRANCH
 SRCRELDATE!=	awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
 		${SRCDIR}/sys/sys/param.h
 VERSION=	FreeBSD ${REVISION}-${BRANCH:C/-p[0-9]+$//} ${TARGET_ARCH} ${SRCRELDATE}
 .endif
 
 KNOWN_ARCHES?=	amd64 arm armeb/arm i386 i386/pc98 ia64 mipsel/mips mipseb/mips mips64el/mips mips64eb/mips mipsn32el/mips mipsn32eb/mips powerpc powerpc64/powerpc sparc64
 .if ${TARGET} == ${TARGET_ARCH}
 _t=		${TARGET}
 .else
 _t=		${TARGET_ARCH}/${TARGET}
 .endif
 .for _t in ${_t}
 .if empty(KNOWN_ARCHES:M${_t})
 .error Unknown target ${TARGET_ARCH}:${TARGET}.
 .endif
 .endfor
 
 .if ${TARGET} == ${MACHINE}
 TARGET_CPUTYPE?=${CPUTYPE}
 .else
 TARGET_CPUTYPE?=
 .endif
 
 .if !empty(TARGET_CPUTYPE)
 _TARGET_CPUTYPE=${TARGET_CPUTYPE}
 .else
 _TARGET_CPUTYPE=dummy
 .endif
 _CPUTYPE!=	MAKEFLAGS= CPUTYPE=${_TARGET_CPUTYPE} ${MAKE} \
 		-f /dev/null -m ${.CURDIR}/share/mk -V CPUTYPE
 .if ${_CPUTYPE} != ${_TARGET_CPUTYPE}
 .error CPUTYPE global should be set with ?=.
 .endif
 .if make(buildworld)
 BUILD_ARCH!=	uname -p
 .if ${MACHINE_ARCH} != ${BUILD_ARCH}
 .error To cross-build, set TARGET_ARCH.
 .endif
 .endif
 .if ${MACHINE} == ${TARGET} && ${MACHINE_ARCH} == ${TARGET_ARCH} && !defined(CROSS_BUILD_TESTING)
 OBJTREE=	${MAKEOBJDIRPREFIX}
 .else
 OBJTREE=	${MAKEOBJDIRPREFIX}/${TARGET}.${TARGET_ARCH}
 .endif
 WORLDTMP=	${OBJTREE}${.CURDIR}/tmp
 # /usr/games added for fortune which depend on strfile
 BPATH=		${WORLDTMP}/legacy/usr/sbin:${WORLDTMP}/legacy/usr/bin:${WORLDTMP}/legacy/usr/games:${WORLDTMP}/legacy/bin
 XPATH=		${WORLDTMP}/usr/sbin:${WORLDTMP}/usr/bin:${WORLDTMP}/usr/games
 STRICTTMPPATH=	${BPATH}:${XPATH}
 TMPPATH=	${STRICTTMPPATH}:${PATH}
 
 #
 # Avoid running mktemp(1) unless actually needed.
 # It may not be functional, e.g., due to new ABI
 # when in the middle of installing over this system.
 #
 .if make(distributeworld) || make(installworld)
 INSTALLTMP!=	/usr/bin/mktemp -d -u -t install
 .endif
 
 #
 # Building a world goes through the following stages
 #
 # 1. legacy stage [BMAKE]
 #	This stage is responsible for creating compatibility
 #	shims that are needed by the bootstrap-tools,
 #	build-tools and cross-tools stages.
 # 1. bootstrap-tools stage [BMAKE]
 #	This stage is responsible for creating programs that
 #	are needed for backward compatibility reasons. They
 #	are not built as cross-tools.
 # 2. build-tools stage [TMAKE]
 #	This stage is responsible for creating the object
 #	tree and building any tools that are needed during
 #	the build process.
 # 3. cross-tools stage [XMAKE]
 #	This stage is responsible for creating any tools that
 #	are needed for cross-builds. A cross-compiler is one
 #	of them.
 # 4. world stage [WMAKE]
 #	This stage actually builds the world.
 # 5. install stage (optional) [IMAKE]
 #	This stage installs a previously built world.
 #
 
 BOOTSTRAPPING?=	0
 
 # Common environment for world related stages
 CROSSENV=	MAKEOBJDIRPREFIX=${OBJTREE} \
 		MACHINE_ARCH=${TARGET_ARCH} \
 		MACHINE=${TARGET} \
 		CPUTYPE=${TARGET_CPUTYPE}
 .if ${OSRELDATE} < 700044
 CROSSENV+=	AR=gnu-ar RANLIB=gnu-ranlib
 .endif
 .if ${MK_GROFF} != "no"
 CROSSENV+=	GROFF_BIN_PATH=${WORLDTMP}/legacy/usr/bin \
 		GROFF_FONT_PATH=${WORLDTMP}/legacy/usr/share/groff_font \
 		GROFF_TMAC_PATH=${WORLDTMP}/legacy/usr/share/tmac
 .endif
 
 # bootstrap-tools stage
 BMAKEENV=	INSTALL="sh ${.CURDIR}/tools/install.sh" \
 		PATH=${BPATH}:${PATH} \
 		WORLDTMP=${WORLDTMP} \
 		VERSION="${VERSION}" \
 		MAKEFLAGS="-m ${.CURDIR}/tools/build/mk ${.MAKEFLAGS}" \
 		COMPILER_TYPE=${COMPILER_TYPE}
 BMAKE=		MAKEOBJDIRPREFIX=${WORLDTMP} \
 		${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
 		DESTDIR= \
 		BOOTSTRAPPING=${OSRELDATE} \
 		SSP_CFLAGS= \
 		-DWITHOUT_HTML -DWITHOUT_INFO -DNO_LINT -DWITHOUT_MAN \
 		-DNO_PIC -DWITHOUT_PROFILE -DNO_SHARED \
 		-DNO_CPU_CFLAGS -DNO_WARNS -DNO_CTF -DEARLY_BUILD
 
 # build-tools stage
 TMAKE=		MAKEOBJDIRPREFIX=${OBJTREE} \
 		${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
 		TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
 		DESTDIR= \
 		BOOTSTRAPPING=${OSRELDATE} \
 		SSP_CFLAGS= \
 		-DNO_LINT \
 		-DNO_CPU_CFLAGS -DNO_WARNS -DNO_CTF -DEARLY_BUILD
 
 # cross-tools stage
 XMAKE=		TOOLS_PREFIX=${WORLDTMP} ${BMAKE} \
 		TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
 		-DWITHOUT_GDB
 
 # world stage
 WMAKEENV=	${CROSSENV} \
 		_SHLIBDIRPREFIX=${WORLDTMP} \
 		_LDSCRIPTROOT= \
 		VERSION="${VERSION}" \
 		INSTALL="sh ${.CURDIR}/tools/install.sh" \
 		PATH=${TMPPATH}
 
 # make hierarchy
 HMAKE=		PATH=${TMPPATH} ${MAKE} LOCAL_MTREE=${LOCAL_MTREE:Q}
 .if defined(NO_ROOT)
 HMAKE+=		PATH=${TMPPATH} METALOG=${METALOG} -DNO_ROOT
 .endif
 
 .if ${MK_CDDL} == "no"
 WMAKEENV+=	NO_CTF=1
 .endif
 .if ${CC:T:Mgcc} == "gcc"
 WMAKE_COMPILER_TYPE=	gcc
 .elif ${CC:T:Mclang} == "clang"
 WMAKE_COMPILER_TYPE=	clang
 .elif ${MK_CLANG_IS_CC} == "no"
 WMAKE_COMPILER_TYPE=	gcc
 .else
 WMAKE_COMPILER_TYPE=	clang
 .endif
 WMAKEENV+=	COMPILER_TYPE=${WMAKE_COMPILER_TYPE}
 WMAKE=		${WMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 DESTDIR=${WORLDTMP}
 
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 # 32 bit world
 LIB32TMP=	${OBJTREE}${.CURDIR}/lib32
 
 .if ${TARGET_ARCH} == "amd64"
 .if empty(TARGET_CPUTYPE)
 LIB32CPUFLAGS=	-march=i686 -mmmx -msse -msse2
 .else
 LIB32CPUFLAGS=	-march=${TARGET_CPUTYPE}
 .endif
 LIB32WMAKEENV=	MACHINE=i386 MACHINE_ARCH=i386 \
 		MACHINE_CPU="i686 mmx sse sse2"
 LIB32WMAKEFLAGS=	\
 		AS="${AS} --32" \
 		LD="${LD} -m elf_i386_fbsd -Y P,${LIB32TMP}/usr/lib32"
 
 .elif ${TARGET_ARCH} == "powerpc64"
 .if empty(TARGET_CPUTYPE)
 LIB32CPUFLAGS=	-mcpu=powerpc
 .else
 LIB32CPUFLAGS=	-mcpu=${TARGET_CPUTYPE}
 .endif
 LIB32WMAKEENV=	MACHINE=powerpc MACHINE_ARCH=powerpc
 LIB32WMAKEFLAGS=	\
 		LD="${LD} -m elf32ppc"
 .endif
 
 
 LIB32FLAGS=	-m32 ${LIB32CPUFLAGS} -DCOMPAT_32BIT \
 		-isystem ${LIB32TMP}/usr/include/ \
 		-L${LIB32TMP}/usr/lib32 \
 		-B${LIB32TMP}/usr/lib32
 
 # Yes, the flags are redundant.
 LIB32WMAKEENV+=	MAKEOBJDIRPREFIX=${OBJTREE}/lib32 \
 		_SHLIBDIRPREFIX=${LIB32TMP} \
 		_LDSCRIPTROOT=${LIB32TMP} \
 		VERSION="${VERSION}" \
 		INSTALL="sh ${.CURDIR}/tools/install.sh" \
 		PATH=${TMPPATH} \
 		LIBDIR=/usr/lib32 \
 		SHLIBDIR=/usr/lib32 \
 		LIBPRIVATEDIR=/usr/lib32/private \
 		COMPILER_TYPE=${WMAKE_COMPILER_TYPE}
 LIB32WMAKEFLAGS+=	\
 		CC="${CC} ${LIB32FLAGS}" \
 		CXX="${CXX} ${LIB32FLAGS}" \
 		DESTDIR=${LIB32TMP} \
 		-DCOMPAT_32BIT \
 		-DLIBRARIES_ONLY \
 		-DNO_CPU_CFLAGS \
 		-DNO_CTF \
 		-DNO_LINT
 
 LIB32WMAKE=	${LIB32WMAKEENV} ${MAKE} ${LIB32WMAKEFLAGS} \
 		-DWITHOUT_BIND -DWITHOUT_MAN -DWITHOUT_INFO -DWITHOUT_HTML
 LIB32IMAKE=	${LIB32WMAKE:NINSTALL=*:NDESTDIR=*:N_LDSCRIPTROOT=*} -DNO_INCS \
 		${IMAKE_INSTALL}
 .endif
 
 IMAKEENV=	${CROSSENV:N_LDSCRIPTROOT=*}
 IMAKE=		${IMAKEENV} ${MAKE} -f Makefile.inc1 \
 		${IMAKE_INSTALL} ${IMAKE_MTREE}
 .if empty(.MAKEFLAGS:M-n)
 IMAKEENV+=	PATH=${STRICTTMPPATH}:${INSTALLTMP} \
 		LD_LIBRARY_PATH=${INSTALLTMP} \
 		PATH_LOCALE=${INSTALLTMP}/locale
 IMAKE+=		__MAKE_SHELL=${INSTALLTMP}/sh
 .else
 IMAKEENV+=	PATH=${TMPPATH}:${INSTALLTMP}
 .endif
 .if defined(DB_FROM_SRC)
 INSTALLFLAGS+=	-N ${.CURDIR}/etc
 MTREEFLAGS+=	-N ${.CURDIR}/etc
 .endif
 .if defined(NO_ROOT)
 METALOG?=	${DESTDIR}/${DISTDIR}/METALOG
 IMAKE+=		-DNO_ROOT METALOG=${METALOG}
 INSTALL_DDIR=	${DESTDIR}/${DISTDIR}
 INSTALLFLAGS+=	-U -M ${METALOG} -D ${INSTALL_DDIR:S://:/:g:C:/$::}
 MTREEFLAGS+=	-W
 .endif
 .if defined(DB_FROM_SRC) || defined(NO_ROOT)
 IMAKE_INSTALL=	INSTALL="install ${INSTALLFLAGS}"
 IMAKE_MTREE=	MTREE_CMD="nmtree ${MTREEFLAGS}"
 .endif
 
 # kernel stage
 KMAKEENV=	${WMAKEENV}
 KMAKE=		${KMAKEENV} ${MAKE} ${.MAKEFLAGS} ${KERNEL_FLAGS} KERNEL=${INSTKERNNAME}
 
 #
 # buildworld
 #
 # Attempt to rebuild the entire system, with reasonable chance of
 # success, regardless of how old your existing system is.
 #
 _worldtmp:
 .if ${.CURDIR:C/[^,]//g} != ""
 #	The m4 build of sendmail files doesn't like it if ',' is used
 #	anywhere in the path of it's files.
 	@echo
 	@echo "*** Error: path to source tree contains a comma ','"
 	@echo
 	false
 .endif
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Rebuilding the temporary build tree"
 	@echo "--------------------------------------------------------------"
 .if !defined(NO_CLEAN)
 	rm -rf ${WORLDTMP}
 .if defined(LIB32TMP)
 	rm -rf ${LIB32TMP}
 .endif
 .else
 	rm -rf ${WORLDTMP}/legacy/usr/include
 #	XXX - These three can depend on any header file.
 	rm -f ${OBJTREE}${.CURDIR}/usr.bin/kdump/ioctl.c
 	rm -f ${OBJTREE}${.CURDIR}/usr.bin/kdump/kdump_subr.c
 	rm -f ${OBJTREE}${.CURDIR}/usr.bin/truss/ioctl.c
 .endif
 .for _dir in \
     lib usr legacy/bin legacy/usr
 	mkdir -p ${WORLDTMP}/${_dir}
 .endfor
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${WORLDTMP}/legacy/usr >/dev/null
 .if ${MK_GROFF} != "no"
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.groff.dist \
 	    -p ${WORLDTMP}/legacy/usr >/dev/null
 .endif
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${WORLDTMP}/usr >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.include.dist \
 	    -p ${WORLDTMP}/usr/include >/dev/null
 	ln -sf ${.CURDIR}/sys ${WORLDTMP}
 .if ${MK_DEBUG_FILES} != "no"
 	# We could instead disable debug files for these build stages
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
 	    -p ${WORLDTMP}/legacy/usr/lib >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
 	    -p ${WORLDTMP}/usr/lib >/dev/null
 .endif
 .if ${MK_BIND_LIBS} != "no"
 	mtree -deU -f ${.CURDIR}/etc/mtree/BIND.include.dist \
 	    -p ${WORLDTMP}/usr/include >/dev/null
 .endif
 .for _mtree in ${LOCAL_MTREE}
 	mtree -deU -f ${.CURDIR}/${_mtree} -p ${WORLDTMP} > /dev/null
 .endfor
 _legacy:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 1.1: legacy release compatibility shims"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${BMAKE} legacy
 _bootstrap-tools:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 1.2: bootstrap tools"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${BMAKE} bootstrap-tools
 _cleanobj:
 .if !defined(NO_CLEAN)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.1: cleaning up the object tree"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${WMAKE} ${CLEANDIR:S/^/par-/}
 .if defined(LIB32TMP)
 	${_+_}cd ${.CURDIR}; ${LIB32WMAKE} -f Makefile.inc1 ${CLEANDIR:S/^/par-/}
 .endif
 .endif
 _obj:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.2: rebuilding the object tree"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${WMAKE} par-obj
 _build-tools:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.3: build tools"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${TMAKE} build-tools
 _cross-tools:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 3: cross tools"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${XMAKE} cross-tools
 _includes:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 4.1: building includes"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${WMAKE} SHARED=symlinks par-includes
 _libraries:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 4.2: building libraries"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; \
 	    ${WMAKE} -DNO_FSCHG -DWITHOUT_HTML -DWITHOUT_INFO -DNO_LINT \
 	    -DWITHOUT_MAN -DWITHOUT_PROFILE libraries
 _depend:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 4.3: make dependencies"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${WMAKE} par-depend
 everything:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 4.4: building everything"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${WMAKE} par-all
 .if defined(LIB32TMP)
 build32:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 5.1: building 32 bit shim libraries"
 	@echo "--------------------------------------------------------------"
 	mkdir -p ${LIB32TMP}/usr/include
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${LIB32TMP}/usr >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.include.dist \
 	    -p ${LIB32TMP}/usr/include >/dev/null
 .if ${MK_DEBUG_FILES} != "no"
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
 	    -p ${LIB32TMP}/usr/lib >/dev/null
 .endif
 	mkdir -p ${WORLDTMP}
 	ln -sf ${.CURDIR}/sys ${WORLDTMP}
 .if ${MK_KERBEROS} != "no"
 .for _t in obj depend all
 	cd ${.CURDIR}/kerberos5/tools; \
 	    MAKEOBJDIRPREFIX=${OBJTREE}/lib32 ${MAKE} SSP_CFLAGS= DESTDIR= \
 	    DIRPRFX=kerberos5/tools/ ${_t}
 .endfor
 .endif
 .for _t in obj includes
 	cd ${.CURDIR}/include; ${LIB32WMAKE} DIRPRFX=include/ ${_t}
 	cd ${.CURDIR}/lib; ${LIB32WMAKE} DIRPRFX=lib/ ${_t}
 .if ${MK_CDDL} != "no"
 	cd ${.CURDIR}/cddl/lib; ${LIB32WMAKE} DIRPRFX=cddl/lib/ ${_t}
 .endif
 	cd ${.CURDIR}/gnu/lib; ${LIB32WMAKE} DIRPRFX=gnu/lib/ ${_t}
 .if ${MK_CRYPT} != "no"
 	cd ${.CURDIR}/secure/lib; ${LIB32WMAKE} DIRPRFX=secure/lib/ ${_t}
 .endif
 .if ${MK_KERBEROS} != "no"
 	cd ${.CURDIR}/kerberos5/lib; ${LIB32WMAKE} DIRPRFX=kerberos5/lib ${_t}
 .endif
 .endfor
 .for _dir in usr.bin/lex/lib
 	cd ${.CURDIR}/${_dir}; ${LIB32WMAKE} DIRPRFX=${_dir}/ obj
 .endfor
 .for _dir in lib/ncurses/ncurses lib/ncurses/ncursesw lib/libmagic
 	cd ${.CURDIR}/${_dir}; \
 	    MAKEOBJDIRPREFIX=${OBJTREE}/lib32 ${MAKE} SSP_CFLAGS= DESTDIR= \
 	    DIRPRFX=${_dir}/ -DNO_LINT -DNO_CPU_CFLAGS -DNO_WARNS -DNO_CTF \
 	    -DEARLY_BUILD build-tools
 .endfor
 	cd ${.CURDIR}; \
 	    ${LIB32WMAKE} -f Makefile.inc1 libraries
 .for _t in obj depend all
 	cd ${.CURDIR}/libexec/rtld-elf; PROG=ld-elf32.so.1 ${LIB32WMAKE} \
 	    DIRPRFX=libexec/rtld-elf/ ${_t}
 	cd ${.CURDIR}/usr.bin/ldd; PROG=ldd32 ${LIB32WMAKE} \
 	    DIRPRFX=usr.bin/ldd ${_t}
 .endfor
 
 distribute32 install32:
 	cd ${.CURDIR}/lib; ${LIB32IMAKE} ${.TARGET:S/32$//}
 .if ${MK_CDDL} != "no"
 	cd ${.CURDIR}/cddl/lib; ${LIB32IMAKE} ${.TARGET:S/32$//}
 .endif
 	cd ${.CURDIR}/gnu/lib; ${LIB32IMAKE} ${.TARGET:S/32$//}
 .if ${MK_CRYPT} != "no"
 	cd ${.CURDIR}/secure/lib; ${LIB32IMAKE} ${.TARGET:S/32$//}
 .endif
 .if ${MK_KERBEROS} != "no"
 	cd ${.CURDIR}/kerberos5/lib; ${LIB32IMAKE} ${.TARGET:S/32$//}
 .endif
 	cd ${.CURDIR}/libexec/rtld-elf; \
 	    PROG=ld-elf32.so.1 ${LIB32IMAKE} ${.TARGET:S/32$//}
 	cd ${.CURDIR}/usr.bin/ldd; PROG=ldd32 ${LIB32IMAKE} ${.TARGET:S/32$//}
 .endif
 
 WMAKE_TGTS=
 .if !defined(SUBDIR_OVERRIDE)
 WMAKE_TGTS+=	_worldtmp _legacy _bootstrap-tools
 .endif
 WMAKE_TGTS+=	_cleanobj _obj _build-tools
 .if !defined(SUBDIR_OVERRIDE)
 WMAKE_TGTS+=	_cross-tools
 .endif
 WMAKE_TGTS+=	_includes _libraries _depend everything
 .if defined(LIB32TMP) && ${MK_LIB32} != "no"
 WMAKE_TGTS+=	build32
 .endif
 
 buildworld: buildworld_prologue ${WMAKE_TGTS} buildworld_epilogue
 .ORDER: buildworld_prologue ${WMAKE_TGTS} buildworld_epilogue
 
 buildworld_prologue:
 	@echo "--------------------------------------------------------------"
 	@echo ">>> World build started on `LC_ALL=C date`"
 	@echo "--------------------------------------------------------------"
 
 buildworld_epilogue:
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> World build completed on `LC_ALL=C date`"
 	@echo "--------------------------------------------------------------"
 
 #
 # We need to have this as a target because the indirection between Makefile
 # and Makefile.inc1 causes the correct PATH to be used, rather than a
 # modification of the current environment's PATH.  In addition, we need
 # to quote multiword values.
 #
 buildenvvars:
 	@echo ${WMAKEENV:Q}
 
 buildenv:
 	@echo Entering world for ${TARGET_ARCH}:${TARGET}
 	@cd ${.CURDIR} && env ${WMAKEENV} ${BUILDENV_SHELL} || true
 
 TOOLCHAIN_TGTS=	${WMAKE_TGTS:N_depend:Neverything:Nbuild32}
 toolchain: ${TOOLCHAIN_TGTS}
 kernel-toolchain: ${TOOLCHAIN_TGTS:N_includes:N_libraries}
 
 #
 # installcheck
 #
 # Checks to be sure system is ready for installworld/installkernel.
 #
 installcheck:
 installcheck_UGID:
 
 #
 # Require DESTDIR to be set if installing for a different architecture or
 # using the user/group database in the source tree.
 #
 .if ${TARGET_ARCH} != ${MACHINE_ARCH} || ${TARGET} != ${MACHINE} || \
     defined(DB_FROM_SRC)
 .if !make(distributeworld)
 installcheck: installcheck_DESTDIR
 installcheck_DESTDIR:
 .if !defined(DESTDIR) || empty(DESTDIR)
 	@echo "ERROR: Please set DESTDIR!"; \
 	false
 .endif
 .endif
 .endif
 
 .if !defined(DB_FROM_SRC)
 #
 # Check for missing UIDs/GIDs.
 #
 CHECK_UIDS=	auditdistd
 CHECK_GIDS=	audit
 .if ${MK_SENDMAIL} != "no"
 CHECK_UIDS+=	smmsp
 CHECK_GIDS+=	smmsp
 .endif
 .if ${MK_PF} != "no"
 CHECK_UIDS+=	proxy
 CHECK_GIDS+=	proxy authpf
 .endif
 installcheck_UGID:
 .for uid in ${CHECK_UIDS}
 	@if ! `id -u ${uid} >/dev/null 2>&1`; then \
 		echo "ERROR: Required ${uid} user is missing, see /usr/src/UPDATING."; \
 		false; \
 	fi
 .endfor
 .for gid in ${CHECK_GIDS}
 	@if ! `find / -prune -group ${gid} >/dev/null 2>&1`; then \
 		echo "ERROR: Required ${gid} group is missing, see /usr/src/UPDATING."; \
 		false; \
 	fi
 .endfor
 .endif
 
 #
 # Required install tools to be saved in a scratch dir for safety.
 #
 .if ${MK_INFO} != "no"
 _install-info=	install-info
 .endif
 .if ${MK_ZONEINFO} != "no"
 _zoneinfo=	zic tzsetup
 .endif
 
 .if exists(/usr/sbin/nmtree)
 _nmtree_itools=	nmtree
 .endif
 
 ITOOLS=	[ awk cap_mkdb cat chflags chmod chown \
 	date echo egrep find grep id install ${_install-info} \
 	ln lockf make mkdir mtree ${_nmtree_itools} mv pwd_mkdb \
 	rm sed sh sysctl test true uname wc ${_zoneinfo}
 
 #
 # distributeworld
 #
 # Distributes everything compiled by a `buildworld'.
 #
 # installworld
 #
 # Installs everything compiled by a 'buildworld'.
 #
 
 # Non-base distributions produced by the base system
 EXTRA_DISTRIBUTIONS=	doc
 .if ${MK_GAMES} != "no"
 EXTRA_DISTRIBUTIONS+=	games
 .endif
 .if defined(LIB32TMP) && ${MK_LIB32} != "no"
 EXTRA_DISTRIBUTIONS+=	lib32
 .endif
 
 MTREE_MAGIC?=	mtree 2.0
 
 distributeworld installworld: installcheck installcheck_UGID
 	mkdir -p ${INSTALLTMP}
 	progs=$$(for prog in ${ITOOLS}; do \
 		if progpath=`which $$prog`; then \
 			echo $$progpath; \
 		else \
 			echo "Required tool $$prog not found in PATH." >&2; \
 			exit 1; \
 		fi; \
 	    done); \
 	libs=$$(ldd -f "%o %p\n" -f "%o %p\n" $$progs 2>/dev/null | sort -u | \
 	    while read line; do \
 		set -- $$line; \
 		if [ "$$2 $$3" != "not found" ]; then \
 			echo $$2; \
 		else \
 			echo "Required library $$1 not found." >&2; \
 			exit 1; \
 		fi; \
 	    done); \
 	cp $$libs $$progs ${INSTALLTMP}
 	cp -R $${PATH_LOCALE:-"/usr/share/locale"} ${INSTALLTMP}/locale
 .if defined(NO_ROOT)
 	echo "#${MTREE_MAGIC}" > ${METALOG}
 .endif
 .if make(distributeworld)
 .for dist in ${EXTRA_DISTRIBUTIONS}
 	-mkdir ${DESTDIR}/${DISTDIR}/${dist}
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.root.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist} >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.include.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr/include >/dev/null
 .if ${MK_DEBUG_FILES} != "no"
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
 	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr/lib >/dev/null
 .endif
 .if defined(NO_ROOT)
 	${IMAKEENV} nmtree -C -f ${.CURDIR}/etc/mtree/BSD.root.dist | \
 	    sed -e 's#^\./#./${dist}/#' >> ${METALOG}
 	${IMAKEENV} nmtree -C -f ${.CURDIR}/etc/mtree/BSD.usr.dist | \
 	    sed -e 's#^\./#./${dist}/usr/#' >> ${METALOG}
 	${IMAKEENV} nmtree -C -f ${.CURDIR}/etc/mtree/BSD.include.dist | \
 	    sed -e 's#^\./#./${dist}/usr/include/#' >> ${METALOG}
 .endif
 .endfor
 	-mkdir ${DESTDIR}/${DISTDIR}/base
 	cd ${.CURDIR}/etc; ${CROSSENV} PATH=${TMPPATH} ${MAKE} \
 	    METALOG=${METALOG} ${IMAKE_INSTALL} ${IMAKE_MTREE} \
 	    DISTBASE=/base DESTDIR=${DESTDIR}/${DISTDIR}/base \
 	    LOCAL_MTREE=${LOCAL_MTREE:Q} distrib-dirs
 .endif
 	${_+_}cd ${.CURDIR}; ${IMAKE} re${.TARGET:S/world$//}; \
 	    ${IMAKEENV} rm -rf ${INSTALLTMP}
 .if make(distributeworld)
 .for dist in ${EXTRA_DISTRIBUTIONS}
 	find ${DESTDIR}/${DISTDIR}/${dist} -mindepth 1 -empty -delete
 .endfor
 .if defined(NO_ROOT)
 .for dist in base ${EXTRA_DISTRIBUTIONS}
 	@# For each file that exists in this dist, print the corresponding
 	@# line from the METALOG.  This relies on the fact that
 	@# a line containing only the filename will sort immediatly before
 	@# the relevant mtree line.
 	cd ${DESTDIR}/${DISTDIR}; \
 	find ./${dist} | sort -u ${METALOG} - | \
 	awk 'BEGIN { print "#${MTREE_MAGIC}" } !/ type=/ { file = $$1 } / type=/ { if ($$1 == file) { sub(/^\.\/${dist}\//, "./"); print } }' > \
 	${DESTDIR}/${DISTDIR}/${dist}.meta
 .endfor
 .endif
 .endif
 
 packageworld:
 .for dist in base ${EXTRA_DISTRIBUTIONS}
 .if defined(NO_ROOT)
 	${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
 	    tar cvJf ${DESTDIR}/${DISTDIR}/${dist}.txz \
 	    @${DESTDIR}/${DISTDIR}/${dist}.meta
 .else
 	${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
 	    tar cvJf ${DESTDIR}/${DISTDIR}/${dist}.txz .
 .endif
 .endfor
 
 #
 # reinstall
 #
 # If you have a build server, you can NFS mount the source and obj directories
 # and do a 'make reinstall' on the *client* to install new binaries from the
 # most recent server build.
 #
 reinstall:
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Making hierarchy"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 \
 	    LOCAL_MTREE=${LOCAL_MTREE:Q} hierarchy
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Installing everything"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 install
 .if defined(LIB32TMP) && ${MK_LIB32} != "no"
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 install32
 .endif
 
 redistribute:
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Distributing everything"
 	@echo "--------------------------------------------------------------"
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 distribute
 .if defined(LIB32TMP) && ${MK_LIB32} != "no"
 	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 distribute32 \
 	    DISTRIBUTION=lib32
 .endif
 
 distrib-dirs distribution:
 	cd ${.CURDIR}/etc; ${CROSSENV} PATH=${TMPPATH} ${MAKE} \
 	    ${IMAKE_INSTALL} ${IMAKE_MTREE} METALOG=${METALOG} ${.TARGET}
 
 #
 # buildkernel and installkernel
 #
 # Which kernels to build and/or install is specified by setting
 # KERNCONF. If not defined a GENERIC kernel is built/installed.
 # Only the existing (depending TARGET) config files are used
 # for building kernels and only the first of these is designated
 # as the one being installed.
 #
 # Note that we have to use TARGET instead of TARGET_ARCH when
 # we're in kernel-land. Since only TARGET_ARCH is (expected) to
 # be set to cross-build, we have to make sure TARGET is set
 # properly.
 
 .if defined(KERNFAST)
 NO_KERNELCLEAN=	t
 NO_KERNELCONFIG=	t
 NO_KERNELDEPEND=	t
 NO_KERNELOBJ=		t
 # Shortcut for KERNCONF=Blah -DKERNFAST is now KERNFAST=Blah
 .if !defined(KERNCONF) && ${KERNFAST} != "1"
 KERNCONF=${KERNFAST}
 .endif
 .endif
 .if !defined(KERNCONF) && defined(KERNEL)
 KERNCONF=	${KERNEL}
 KERNWARN=
 .else
 .if ${TARGET_ARCH} == "powerpc64"
 KERNCONF?=	GENERIC64
 .else
 KERNCONF?=	GENERIC
 .endif
 .endif
 INSTKERNNAME?=	kernel
 
 KERNSRCDIR?=	${.CURDIR}/sys
 KRNLCONFDIR=	${KERNSRCDIR}/${TARGET}/conf
 KRNLOBJDIR=	${OBJTREE}${KERNSRCDIR}
 KERNCONFDIR?=	${KRNLCONFDIR}
 
 BUILDKERNELS=
 INSTALLKERNEL=
 .for _kernel in ${KERNCONF}
 .if exists(${KERNCONFDIR}/${_kernel})
 BUILDKERNELS+=	${_kernel}
 .if empty(INSTALLKERNEL)
 INSTALLKERNEL= ${_kernel}
 .endif
 .endif
 .endfor
 
 #
 # buildkernel
 #
 # Builds all kernels defined by BUILDKERNELS.
 #
 buildkernel:
 .if empty(BUILDKERNELS)
 	@echo "ERROR: Missing kernel configuration file(s) (${KERNCONF})."; \
 	false
 .endif
 .if defined(KERNWARN)
 	@echo "--------------------------------------------------------------"
 	@echo ">>> WARNING: KERNEL= setting should be changed to KERNCONF="
 	@echo "--------------------------------------------------------------"
 	@sleep 3
 .endif
 	@echo
 .for _kernel in ${BUILDKERNELS}
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Kernel build for ${_kernel} started on `LC_ALL=C date`"
 	@echo "--------------------------------------------------------------"
 	@echo "===> ${_kernel}"
 	mkdir -p ${KRNLOBJDIR}
 .if !defined(NO_KERNELCONFIG)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 1: configuring the kernel"
 	@echo "--------------------------------------------------------------"
 	cd ${KRNLCONFDIR}; \
 		PATH=${TMPPATH} \
 		    config ${CONFIGARGS} -d ${KRNLOBJDIR}/${_kernel} \
 			-I '${KERNCONFDIR}' '${KERNCONFDIR}/${_kernel}'
 .endif
 .if !defined(NO_CLEAN) && !defined(NO_KERNELCLEAN)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.1: cleaning up the object tree"
 	@echo "--------------------------------------------------------------"
 	cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} ${CLEANDIR}
 .endif
 .if !defined(NO_KERNELOBJ)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.2: rebuilding the object tree"
 	@echo "--------------------------------------------------------------"
 	cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} obj
 .endif
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 2.3: build tools"
 	@echo "--------------------------------------------------------------"
 	cd ${KRNLOBJDIR}/${_kernel}; \
 	    PATH=${BPATH}:${PATH} \
 	    MAKESRCPATH=${KERNSRCDIR}/dev/aic7xxx/aicasm \
 	    ${MAKE} SSP_CFLAGS= -DNO_CPU_CFLAGS -DNO_WARNS -DNO_CTF \
 	    -DEARLY_BUILD -f ${KERNSRCDIR}/dev/aic7xxx/aicasm/Makefile
 # XXX - Gratuitously builds aicasm in the ``makeoptions NO_MODULES'' case.
 .if !defined(MODULES_WITH_WORLD) && !defined(NO_MODULES) && exists(${KERNSRCDIR}/modules)
 .for target in obj depend all
 	cd ${KERNSRCDIR}/modules/aic7xxx/aicasm; \
 	    PATH=${BPATH}:${PATH} \
 	    MAKEOBJDIRPREFIX=${KRNLOBJDIR}/${_kernel}/modules \
 	    ${MAKE} SSP_CFLAGS= -DNO_CPU_CFLAGS -DNO_WARNS -DNO_CTF \
 	    -DEARLY_BUILD ${target}
 .endfor
 .endif
 .if !defined(NO_KERNELDEPEND)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 3.1: making dependencies"
 	@echo "--------------------------------------------------------------"
 	cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} depend -DNO_MODULES_OBJ
 .endif
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> stage 3.2: building everything"
 	@echo "--------------------------------------------------------------"
 	cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} all -DNO_MODULES_OBJ
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Kernel build for ${_kernel} completed on `LC_ALL=C date`"
 	@echo "--------------------------------------------------------------"
 .endfor
 
 #
 # installkernel, etc.
 #
 # Install the kernel defined by INSTALLKERNEL
 #
 installkernel installkernel.debug \
 reinstallkernel reinstallkernel.debug: installcheck
 .if empty(INSTALLKERNEL)
 	@echo "ERROR: No kernel \"${KERNCONF}\" to install."; \
 	false
 .endif
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Installing kernel ${INSTALLKERNEL}"
 	@echo "--------------------------------------------------------------"
 	cd ${KRNLOBJDIR}/${INSTALLKERNEL}; \
 	    ${CROSSENV} PATH=${TMPPATH} \
 	    ${MAKE} ${IMAKE_INSTALL} KERNEL=${INSTKERNNAME} ${.TARGET:S/kernel//}
 
 distributekernel distributekernel.debug:
 .if empty(INSTALLKERNEL)
 	@echo "ERROR: No kernel \"${KERNCONF}\" to install."; \
 	false
 .endif
 	cd ${KRNLOBJDIR}/${INSTALLKERNEL}; \
 	    ${CROSSENV} PATH=${TMPPATH} ${MAKE} KERNEL=${INSTKERNNAME} \
 	    DESTDIR=${DESTDIR}/${DISTDIR}/kernel \
 	    ${.TARGET:S/distributekernel/install/}
 .for _kernel in ${BUILDKERNELS:S/${INSTALLKERNEL}//}
 	cd ${KRNLOBJDIR}/${_kernel}; \
 	    ${CROSSENV} PATH=${TMPPATH} ${MAKE} \
 	    KERNEL=${INSTKERNNAME}.${_kernel} \
 	    DESTDIR=${DESTDIR}/${DISTDIR}/kernel.${_kernel} \
 	    ${.TARGET:S/distributekernel/install/}
 .endfor
 
 packagekernel:
 	cd ${DESTDIR}/${DISTDIR}/kernel; \
 	    tar cvJf ${DESTDIR}/${DISTDIR}/kernel.txz .
 .for _kernel in ${BUILDKERNELS:S/${INSTALLKERNEL}//}
 	cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
 	    tar cvJf ${DESTDIR}/${DISTDIR}/kernel.${_kernel}.txz .
 .endfor
 
 #
 # doxygen
 #
 # Build the API documentation with doxygen
 #
 doxygen:
 	@if [ ! -x `/usr/bin/which doxygen` ]; then \
 		echo "You need doxygen (devel/doxygen) to generate the API documentation of the kernel." | /usr/bin/fmt; \
 		exit 1; \
 	fi
 	cd ${.CURDIR}/tools/kerneldoc/subsys && ${MAKE} obj all
 
 #
 # update
 #
 # Update the source tree(s), by running cvsup/cvs/svn to update to the
 # latest copy.
 #
 update:
 .if (defined(CVS_UPDATE) || defined(SUP_UPDATE)) && !defined(SVN_UPDATE)
 	@echo "--------------------------------------------------------------"
 	@echo "CVS_UPDATE and SUP_UPDATE are no longer supported."
 	@echo "Please see: https://wiki.freebsd.org/CvsIsDeprecated"
 	@echo "--------------------------------------------------------------"
 	@exit 1
 .endif
 .if defined(SVN_UPDATE)
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Updating ${.CURDIR} using Subversion"
 	@echo "--------------------------------------------------------------"
 	@(cd ${.CURDIR} && ${SVN} update ${SVNFLAGS})
 .endif
 
 #
 # ------------------------------------------------------------------------
 #
 # From here onwards are utility targets used by the 'make world' and
 # related targets.  If your 'world' breaks, you may like to try to fix
 # the problem and manually run the following targets to attempt to
 # complete the build.  Beware, this is *not* guaranteed to work, you
 # need to have a pretty good grip on the current state of the system
 # to attempt to manually finish it.  If in doubt, 'make world' again.
 #
 
 #
 # legacy: Build compatibility shims for the next three targets
 #
 legacy:
 .if ${BOOTSTRAPPING} < 600034 && ${BOOTSTRAPPING} != 0
 	@echo "ERROR: Source upgrades from versions prior to 6.0 not supported."; \
 	false
 .endif
 .for _tool in tools/build
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,includes,depend,all,install)"; \
 	    cd ${.CURDIR}/${_tool}; \
 	    ${MAKE} DIRPRFX=${_tool}/ obj; \
 	    ${MAKE} DIRPRFX=${_tool}/ DESTDIR=${MAKEOBJDIRPREFIX}/legacy includes; \
 	    ${MAKE} DIRPRFX=${_tool}/ depend; \
 	    ${MAKE} DIRPRFX=${_tool}/ all; \
 	    ${MAKE} DIRPRFX=${_tool}/ DESTDIR=${MAKEOBJDIRPREFIX}/legacy install
 .endfor
 
 #
 # bootstrap-tools: Build tools needed for compatibility
 #
 .if ${MK_GAMES} != "no"
 _strfile=	games/fortune/strfile
 .endif
 
 .if ${MK_CXX} != "no"
 _gperf=		gnu/usr.bin/gperf
 .endif
 
 .if ${MK_GROFF} != "no"
 _groff=		gnu/usr.bin/groff
 .endif
 
 .if ${BOOTSTRAPPING} >= 700044 && ${BOOTSTRAPPING} < 800022
 _ar=		usr.bin/ar
 .endif
 
 .if ${BOOTSTRAPPING} < 800013
 _mklocale=	usr.bin/mklocale
 .endif
 
 .if ${BOOTSTRAPPING} < 900002
 _sed=		usr.bin/sed
 .endif
 
 .if ${BOOTSTRAPPING} < 900006
 _lex=		usr.bin/lex
 .endif
 
 .if ${BOOTSTRAPPING} < 900006 || ${BOOTSTRAPPING} >= 1000013
 _yacc=		lib/liby \
 		usr.bin/yacc
 .endif
 
 .if ${BOOTSTRAPPING} < 1000026
 _nmtree=	lib/libnetbsd \
 		usr.sbin/nmtree
 .endif
 
 .if ${BOOTSTRAPPING} < 1000027
 _cat=		bin/cat
 .endif
 
 .if ${BOOTSTRAPPING} >= 900040 && ${BOOTSTRAPPING} < 900041
 _awk=		usr.bin/awk
 .endif
 
 .if ${MK_BSNMP} != "no" && \
     (${BOOTSTRAPPING} < 700018 || !exists(/usr/sbin/gensnmptree))
 _gensnmptree=	usr.sbin/bsnmpd/gensnmptree
 .endif
 
 .if ${MK_RESCUE} != "no" && \
     ${BOOTSTRAPPING} < 700026
 _crunchgen=	usr.sbin/crunch/crunchgen
 .endif
 
 .if ${MK_CLANG} != "no"
 _clang_tblgen= \
 	lib/clang/libllvmsupport \
 	lib/clang/libllvmtablegen \
 	usr.bin/clang/tblgen \
 	usr.bin/clang/clang-tblgen
 .endif
 
 .if ${MK_CDDL} != "no" && \
     ((${BOOTSTRAPPING} < 1000034 && \
           !(${BOOTSTRAPPING} >= 901505 && ${BOOTSTRAPPING} < 999999)) \
       || (${MACHINE} != ${TARGET} || ${MACHINE_ARCH} != ${TARGET_ARCH}))
 _dtrace_tools= cddl/usr.bin/sgsmsg cddl/lib/libctf lib/libelf \
     lib/libdwarf cddl/usr.bin/ctfconvert cddl/usr.bin/ctfmerge
 .endif
 
 .if ${MK_FDT} != "no"
 _dtc= gnu/usr.bin/dtc
 .endif
 
 #	Please document (add comment) why something is in 'bootstrap-tools'.
 #	Try to bound the building of the bootstrap-tool to just the
 #	FreeBSD versions that need the tool built at this stage of the build.
 bootstrap-tools:
 .for _tool in \
     ${_clang_tblgen} \
     ${_dtrace_tools} \
     ${_strfile} \
     ${_gperf} \
     ${_groff} \
     ${_ar} \
     ${_dtc} \
     ${_awk} \
     ${_cat} \
     usr.bin/lorder \
     usr.bin/makewhatis \
     ${_mklocale} \
     usr.bin/rpcgen \
     ${_sed} \
     ${_yacc} \
     ${_lex} \
     lib/libmd \
     usr.bin/xinstall \
     ${_gensnmptree} \
     usr.sbin/config \
     ${_crunchgen} \
     ${_nmtree}
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,depend,all,install)"; \
 		cd ${.CURDIR}/${_tool}; \
 		${MAKE} DIRPRFX=${_tool}/ obj; \
 		${MAKE} DIRPRFX=${_tool}/ depend; \
 		${MAKE} DIRPRFX=${_tool}/ all; \
 		${MAKE} DIRPRFX=${_tool}/ DESTDIR=${MAKEOBJDIRPREFIX}/legacy install
 .endfor
 
 #
 # build-tools: Build special purpose build tools
 #
 .if defined(MODULES_WITH_WORLD) && exists(${KERNSRCDIR}/modules)
 _aicasm= sys/modules/aic7xxx/aicasm
 .endif
 
 .if !defined(NO_SHARE)
 _share=	share/syscons/scrnmaps
 .endif
 
 .if ${MK_GCC} != "no"
 _gcc_tools= gnu/usr.bin/cc/cc_tools
 .endif
 
 .if ${MK_KERBEROS} != "no"
 _kerberos5_tools= kerberos5/tools
 .endif
 
 .if ${MK_RESCUE} != "no"
 _rescue= rescue/rescue
 .endif
 
 build-tools:
 .for _tool in \
     bin/csh \
     bin/sh \
     ${_rescue} \
     lib/ncurses/ncurses \
     lib/ncurses/ncursesw \
     ${_share} \
     ${_aicasm} \
     usr.bin/awk \
     lib/libmagic \
     usr.sbin/sysinstall \
     usr.bin/mkesdb_static \
     usr.bin/mkcsmapper_static
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,build-tools)"; \
 		cd ${.CURDIR}/${_tool}; \
 		${MAKE} DIRPRFX=${_tool}/ obj; \
 		${MAKE} DIRPRFX=${_tool}/ build-tools
 .endfor
 .for _tool in \
     ${_gcc_tools} \
     ${_kerberos5_tools}
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,depend,all)"; \
 		cd ${.CURDIR}/${_tool}; \
 		${MAKE} DIRPRFX=${_tool}/ obj; \
 		${MAKE} DIRPRFX=${_tool}/ depend; \
 		${MAKE} DIRPRFX=${_tool}/ all
 .endfor
 
 #
 # cross-tools: Build cross-building tools
 #
 .if ${TARGET_ARCH} != ${MACHINE_ARCH} || ${BOOTSTRAPPING} < 800035
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "i386"
 _btxld=		usr.sbin/btxld
 .endif
 .endif
 .if ${TARGET_ARCH} != ${MACHINE_ARCH}
 .if ${MK_RESCUE} != "no" || defined(RELEASEDIR)
 _crunchide=	usr.sbin/crunch/crunchide
 .endif
 .if ${TARGET_ARCH} == "i386" && defined(RELEASEDIR)
 _kgzip=		usr.sbin/kgzip
 .endif
 .endif
 
 .if ${MK_BINUTILS} != "no"
 _binutils=	gnu/usr.bin/binutils
 .endif
 
 .if ${MK_CLANG} != "no" && (${MK_CLANG_IS_CC} != "no" || ${CC:T:Mclang} == "clang")
 _clang=		usr.bin/clang
 _clang_libs=	lib/clang
 .endif
 
 .if ${MK_GCC} != "no" && (${MK_CLANG_IS_CC} == "no" || ${TARGET} == "pc98")
 _cc=		gnu/usr.bin/cc
 .endif
 
 cross-tools:
 .for _tool in \
     ${_clang_libs} \
     ${_clang} \
     ${_binutils} \
     ${_cc} \
     usr.bin/xlint/lint1 usr.bin/xlint/lint2 usr.bin/xlint/xlint \
     ${_btxld} \
     ${_crunchide} \
     ${_kgzip}
 	${_+_}@${ECHODIR} "===> ${_tool} (obj,depend,all,install)"; \
 		cd ${.CURDIR}/${_tool}; \
 		${MAKE} DIRPRFX=${_tool}/ obj; \
 		${MAKE} DIRPRFX=${_tool}/ depend; \
 		${MAKE} DIRPRFX=${_tool}/ all; \
 		${MAKE} DIRPRFX=${_tool}/ DESTDIR=${MAKEOBJDIRPREFIX} install
 .endfor
 
 #
 # hierarchy - ensure that all the needed directories are present
 #
 hierarchy hier:
 	cd ${.CURDIR}/etc && ${HMAKE} distrib-dirs
 
 #
 # libraries - build all libraries, and install them under ${DESTDIR}.
 #
 # The list of libraries with dependents (${_prebuild_libs}) and their
 # interdependencies (__L) are built automatically by the
 # ${.CURDIR}/tools/make_libdeps.sh script.
 #
 libraries:
 	cd ${.CURDIR}; \
 	    ${MAKE} -f Makefile.inc1 _prereq_libs; \
 	    ${MAKE} -f Makefile.inc1 _startup_libs; \
 	    ${MAKE} -f Makefile.inc1 _prebuild_libs; \
 	    ${MAKE} -f Makefile.inc1 _generic_libs;
 
 #
 # static libgcc.a prerequisite for shared libc
 #
 _prereq_libs= gnu/lib/libssp/libssp_nonshared gnu/lib/libgcc lib/libcompiler_rt
 
 # These dependencies are not automatically generated:
 #
 # gnu/lib/csu, gnu/lib/libgcc, lib/csu and lib/libc must be built before
 # all shared libraries for ELF.
 #
 _startup_libs=	gnu/lib/csu
 .if exists(${.CURDIR}/lib/csu/${MACHINE_ARCH}-elf)
 _startup_libs+=	lib/csu/${MACHINE_ARCH}-elf
 .elif exists(${.CURDIR}/lib/csu/${MACHINE_ARCH})
 _startup_libs+=	lib/csu/${MACHINE_ARCH}
 .else
 _startup_libs+=	lib/csu/${MACHINE_CPUARCH}
 .endif
 _startup_libs+=	gnu/lib/libgcc
 _startup_libs+=	lib/libcompiler_rt
 _startup_libs+=	lib/libc
 .if ${MK_LIBCPLUSPLUS} != "no"
 _startup_libs+=	lib/libcxxrt
 .endif
 
 gnu/lib/libgcc__L: lib/libc__L
 .if ${MK_LIBCPLUSPLUS} != "no"
 lib/libcxxrt__L: gnu/lib/libgcc__L
 .endif
 
 _prebuild_libs=	${_kerberos5_lib_libasn1} ${_kerberos5_lib_libhdb} \
 		${_kerberos5_lib_libheimntlm} \
 		${_kerberos5_lib_libhx509} ${_kerberos5_lib_libkrb5} \
 		${_kerberos5_lib_libroken} \
 		lib/libbz2 lib/libcom_err lib/libcrypt \
 		lib/libelf lib/libexpat \
+		lib/libfigpar \
 		${_lib_libgssapi} ${_lib_libipx} \
 		lib/libkiconv lib/libkvm lib/liblzma lib/libmd \
 		lib/ncurses/ncurses lib/ncurses/ncursesw \
 		lib/libopie lib/libpam ${_lib_libthr} \
 		lib/libradius lib/libsbuf lib/libtacplus \
 		${_cddl_lib_libumem} ${_cddl_lib_libnvpair} \
 		${_cddl_lib_libavl} \
 		${_cddl_lib_libzfs_core} \
 		lib/libutil ${_lib_libypclnt} lib/libz lib/msun \
 		${_secure_lib_libcrypto} ${_lib_libldns} \
-		${_secure_lib_libssh} ${_secure_lib_libssl}
+		${_secure_lib_libssh} ${_secure_lib_libssl} \
+		gnu/lib/libdialog
 
 .if ${MK_LIBTHR} != "no"
 _lib_libthr=	lib/libthr
 .endif
 
 .if ${MK_OFED} != "no"
 _ofed_lib=	contrib/ofed/usr.lib/
 .endif
 
 _generic_libs=	${_cddl_lib} gnu/lib ${_kerberos5_lib} lib ${_secure_lib} usr.bin/lex/lib ${_ofed_lib}
 
 lib/libopie__L lib/libtacplus__L: lib/libmd__L
 
 .if ${MK_CDDL} != "no"
 _cddl_lib_libumem= cddl/lib/libumem
 _cddl_lib_libnvpair= cddl/lib/libnvpair
 _cddl_lib_libavl= cddl/lib/libavl
 _cddl_lib_libzfs_core= cddl/lib/libzfs_core
 _cddl_lib= cddl/lib
 cddl/lib/libzfs_core__L: cddl/lib/libnvpair__L
 .endif
 
 .if ${MK_CRYPT} != "no"
 .if ${MK_OPENSSL} != "no"
 _secure_lib_libcrypto= secure/lib/libcrypto
 _secure_lib_libssl= secure/lib/libssl
 lib/libradius__L secure/lib/libssl__L: secure/lib/libcrypto__L
 .if ${MK_OPENSSH} != "no"
 _secure_lib_libssh= secure/lib/libssh
 secure/lib/libssh__L: lib/libz__L secure/lib/libcrypto__L lib/libcrypt__L
 .if ${MK_KERBEROS_SUPPORT} != "no"
 secure/lib/libssh__L: lib/libgssapi__L kerberos5/lib/libkrb5__L \
     kerberos5/lib/libhx509__L kerberos5/lib/libasn1__L lib/libcom_err__L \
     lib/libmd__L kerberos5/lib/libroken__L
 .endif
 .endif
 .endif
 _secure_lib=	secure/lib
 .endif
 
 .if ${MK_KERBEROS} != "no"
 kerberos5/lib/libasn1__L: lib/libcom_err__L kerberos5/lib/libroken__L
 kerberos5/lib/libhdb__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
     kerberos5/lib/libkrb5__L kerberos5/lib/libroken__L
 kerberos5/lib/libheimntlm__L: secure/lib/libcrypto__L kerberos5/lib/libkrb5__L
 kerberos5/lib/libhx509__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
     secure/lib/libcrypto__L kerberos5/lib/libroken__L
 kerberos5/lib/libkrb5__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
     lib/libcrypt__L secure/lib/libcrypto__L kerberos5/lib/libhx509__L \
     kerberos5/lib/libroken__L
 kerberos5/lib/libroken__L: lib/libcrypt__L
 .endif
 
 .if ${MK_GSSAPI} != "no"
 _lib_libgssapi=	lib/libgssapi
 .endif
 
 .if ${MK_IPX} != "no"
 _lib_libipx=	lib/libipx
 .endif
 
 .if ${MK_KERBEROS} != "no"
 _kerberos5_lib=	kerberos5/lib
 _kerberos5_lib_libasn1= kerberos5/lib/libasn1
 _kerberos5_lib_libhdb= kerberos5/lib/libhdb
 _kerberos5_lib_libkrb5= kerberos5/lib/libkrb5
 _kerberos5_lib_libhx509= kerberos5/lib/libhx509
 _kerberos5_lib_libroken= kerberos5/lib/libroken
 _kerberos5_lib_libheimntlm= kerberos5/lib/libheimntlm
 .endif
 
 .if ${MK_NIS} != "no"
 _lib_libypclnt=	lib/libypclnt
 .endif
 
 .if ${MK_OPENSSL} == "no"
 lib/libradius__L: lib/libmd__L
 .endif
+
+gnu/lib/libdialog__L: lib/msun__L lib/ncurses/ncursesw__L
 
 .for _lib in ${_prereq_libs}
 ${_lib}__PL: .PHONY
 .if exists(${.CURDIR}/${_lib})
 	${_+_}@${ECHODIR} "===> ${_lib} (obj,depend,all,install)"; \
 		cd ${.CURDIR}/${_lib}; \
 		${MAKE} DIRPRFX=${_lib}/ obj; \
 		${MAKE} DIRPRFX=${_lib}/ depend; \
 		${MAKE} -DWITHOUT_PROFILE -DNO_PIC DIRPRFX=${_lib}/ all; \
 		${MAKE} -DWITHOUT_PROFILE -DNO_PIC DIRPRFX=${_lib}/ install
 .endif
 .endfor
 
 .for _lib in ${_startup_libs} ${_prebuild_libs:Nlib/libpam} ${_generic_libs}
 ${_lib}__L: .PHONY
 .if exists(${.CURDIR}/${_lib})
 	${_+_}@${ECHODIR} "===> ${_lib} (obj,depend,all,install)"; \
 		cd ${.CURDIR}/${_lib}; \
 		${MAKE} DIRPRFX=${_lib}/ obj; \
 		${MAKE} DIRPRFX=${_lib}/ depend; \
 		${MAKE} DIRPRFX=${_lib}/ all; \
 		${MAKE} DIRPRFX=${_lib}/ install
 .endif
 .endfor
 
 # libpam is special: we need to build static PAM modules before
 # static PAM library, and dynamic PAM library before dynamic PAM
 # modules.
 lib/libpam__L: .PHONY
 	${_+_}@${ECHODIR} "===> lib/libpam (obj,depend,all,install)"; \
 		cd ${.CURDIR}/lib/libpam; \
 		${MAKE} DIRPRFX=lib/libpam/ obj; \
 		${MAKE} DIRPRFX=lib/libpam/ depend; \
 		${MAKE} DIRPRFX=lib/libpam/ -D_NO_LIBPAM_SO_YET all; \
 		${MAKE} DIRPRFX=lib/libpam/ -D_NO_LIBPAM_SO_YET install
 
 _prereq_libs: ${_prereq_libs:S/$/__PL/}
 _startup_libs: ${_startup_libs:S/$/__L/}
 _prebuild_libs: ${_prebuild_libs:S/$/__L/}
 _generic_libs: ${_generic_libs:S/$/__L/}
 
 .for __target in all clean cleandepend cleandir depend includes obj
 .for entry in ${SUBDIR}
 ${entry}.${__target}__D: .PHONY
 	${_+_}@if test -d ${.CURDIR}/${entry}.${MACHINE_ARCH}; then \
 		${ECHODIR} "===> ${DIRPRFX}${entry}.${MACHINE_ARCH} (${__target})"; \
 		edir=${entry}.${MACHINE_ARCH}; \
 		cd ${.CURDIR}/$${edir}; \
 	else \
 		${ECHODIR} "===> ${DIRPRFX}${entry} (${__target})"; \
 		edir=${entry}; \
 		cd ${.CURDIR}/$${edir}; \
 	fi; \
 	${MAKE} ${__target} DIRPRFX=${DIRPRFX}$${edir}/
 .endfor
 par-${__target}: ${SUBDIR:S/$/.${__target}__D/}
 .endfor
 
 .include <bsd.subdir.mk>
 
 .if make(check-old) || make(check-old-dirs) || \
     make(check-old-files) || make(check-old-libs) || \
     make(delete-old) || make(delete-old-dirs) || \
     make(delete-old-files) || make(delete-old-libs)
 
 #
 # check for / delete old files section
 #
 
 .include "ObsoleteFiles.inc"
 
 OLD_LIBS_MESSAGE="Please be sure no application still uses those libraries, \
 else you can not start such an application. Consult UPDATING for more \
 information regarding how to cope with the removal/revision bump of a \
 specific library."
 
 .if !defined(BATCH_DELETE_OLD_FILES)
 RM_I=-i
 .else
 RM_I=-v
 .endif
 
 delete-old-files:
 	@echo ">>> Removing old files (only deletes safe to delete libs)"
 # Ask for every old file if the user really wants to remove it.
 # It's annoying, but better safe than sorry.
 # NB: We cannot pass the list of OLD_FILES as a parameter because the
 # argument list will get too long. Using .for/.endfor make "loops" will make
 # the Makefile parser segfault.
 	@exec 3<&0; \
 	cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_FILES -V "OLD_FILES:Musr/share/*.gz:R" | xargs -n1 | \
 	while read file; do \
 		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
 			chflags noschg "${DESTDIR}/$${file}" 2>/dev/null || true; \
 			rm ${RM_I} "${DESTDIR}/$${file}" <&3; \
 		fi; \
 	done
 # Remove catpages without corresponding manpages.
 	@exec 3<&0; \
 	find ${DESTDIR}/usr/share/man/cat* ! -type d | \
 	sed -ep -e's:${DESTDIR}/usr/share/man/cat:${DESTDIR}/usr/share/man/man:' | \
 	while read catpage; do \
 		read manpage; \
 		if [ ! -e "$${manpage}" ]; then \
 			rm ${RM_I} $${catpage} <&3; \
 	        fi; \
 	done
 	@echo ">>> Old files removed"
 
 check-old-files:
 	@echo ">>> Checking for old files"
 	@cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_FILES -V "OLD_FILES:Musr/share/*.gz:R" | xargs -n1 | \
 	while read file; do \
 		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
 		 	echo "${DESTDIR}/$${file}"; \
 		fi; \
 	done
 # Check for catpages without corresponding manpages.
 	@find ${DESTDIR}/usr/share/man/cat* ! -type d | \
 	sed -ep -e's:${DESTDIR}/usr/share/man/cat:${DESTDIR}/usr/share/man/man:' | \
 	while read catpage; do \
 		read manpage; \
 		if [ ! -e "$${manpage}" ]; then \
 			echo $${catpage}; \
 	        fi; \
 	done
 
 delete-old-libs:
 	@echo ">>> Removing old libraries"
 	@echo "${OLD_LIBS_MESSAGE}" | fmt
 	@exec 3<&0; \
 	cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_LIBS | xargs -n1 | \
 	while read file; do \
 		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
 			chflags noschg "${DESTDIR}/$${file}" 2>/dev/null || true; \
 			rm ${RM_I} "${DESTDIR}/$${file}" <&3; \
 		fi; \
 		for ext in debug symbols; do \
 		  if ! [ -e "${DESTDIR}/$${file}" ] && [ -f \
 		      "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
 			  rm ${RM_I} "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" \
 			      <&3; \
 		  fi; \
 		done; \
 	done
 	@echo ">>> Old libraries removed"
 
 check-old-libs:
 	@echo ">>> Checking for old libraries"
 	@cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_LIBS | xargs -n1 | \
 	while read file; do \
 		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
 			echo "${DESTDIR}/$${file}"; \
 		fi; \
 		for ext in debug symbols; do \
 		  if [ -f "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
 			  echo "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}"; \
 		  fi; \
 		done; \
 	done
 
 delete-old-dirs:
 	@echo ">>> Removing old directories"
 	@cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_DIRS | xargs -n1 | \
 	while read dir; do \
 		if [ -d "${DESTDIR}/$${dir}" ]; then \
 			rmdir -v "${DESTDIR}/$${dir}" || true; \
 		elif [ -L "${DESTDIR}/$${dir}" ]; then \
 			echo "${DESTDIR}/$${dir} is a link, please remove everything manually."; \
 		fi; \
 	done
 	@echo ">>> Old directories removed"
 
 check-old-dirs:
 	@echo ">>> Checking for old directories"
 	@cd ${.CURDIR}; \
 	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
 	    -V OLD_DIRS | xargs -n1 | \
 	while read dir; do \
 		if [ -d "${DESTDIR}/$${dir}" ]; then \
 			echo "${DESTDIR}/$${dir}"; \
 		elif [ -L "${DESTDIR}/$${dir}" ]; then \
 			echo "${DESTDIR}/$${dir} is a link, please remove everything manually."; \
 		fi; \
 	done
 
 delete-old: delete-old-files delete-old-dirs
 	@echo "To remove old libraries run '${MAKE} delete-old-libs'."
 
 check-old: check-old-files check-old-libs check-old-dirs
 	@echo "To remove old files and directories run '${MAKE} delete-old'."
 	@echo "To remove old libraries run '${MAKE} delete-old-libs'."
 
 .endif
 
 #
 # showconfig - show build configuration.
 #
 showconfig:
 	@${MAKE} -n -f bsd.own.mk -V dummy -dg1 | grep ^MK_ | sort
 
 .if !empty(KRNLOBJDIR) && !empty(KERNCONF)
 DTBOUTPUTPATH= ${KRNLOBJDIR}/${KERNCONF}/
 
 .if !defined(FDT_DTS_FILE) || empty(FDT_DTS_FILE)
 .if exists(${KERNCONFDIR}/${KERNCONF})
 FDT_DTS_FILE!= awk 'BEGIN {FS="="} /^makeoptions[[:space:]]+FDT_DTS_FILE/ {print $$2}' \
 	'${KERNCONFDIR}/${KERNCONF}' ; echo
 .endif
 .endif
 
 .endif
 
 .if !defined(DTBOUTPUTPATH) || !exists(${DTBOUTPUTPATH})
 DTBOUTPUTPATH= ${.CURDIR}
 .endif
 
 #
 # Build 'standalone' Device Tree Blob
 #
 builddtb:
 	@if [ "${FDT_DTS_FILE}" = "" ]; then \
 		echo "ERROR: FDT_DTS_FILE must be specified!"; \
 		exit 1; \
 	fi;	\
 	if [ ! -f ${.CURDIR}/sys/boot/fdt/dts/${FDT_DTS_FILE} ]; then \
 		echo "ERROR: Specified DTS file (${FDT_DTS_FILE}) does not \
 			exist!"; \
 		exit 1;	\
 	fi;	\
 	if [ "${DTBOUTPUTPATH}" = "${.CURDIR}" ]; then	\
 		echo "WARNING: DTB will be placed in the current working \
 			directory"; \
 	fi
 	@PATH=${TMPPATH} \
 	dtc -O dtb -o \
 	    ${DTBOUTPUTPATH}/`echo ${FDT_DTS_FILE} | cut -d. -f1`.dtb -b 0 \
 	    -p 1024 ${.CURDIR}/sys/boot/fdt/dts/${FDT_DTS_FILE}
 
 ###############
 
 .if defined(XDEV) && defined(XDEV_ARCH)
 
 .if ${XDEV} == ${MACHINE} && ${XDEV_ARCH} == ${MACHINE_ARCH}
 XDEV_CPUTYPE?=${CPUTYPE}
 .else
 XDEV_CPUTYPE?=${TARGET_CPUTYPE}
 .endif
 
 NOFUN=-DNO_FSCHG -DWITHOUT_HTML -DWITHOUT_INFO -DNO_LINT \
 	-DWITHOUT_MAN -DWITHOUT_NLS -DWITHOUT_PROFILE \
 	-DWITHOUT_KERBEROS -DWITHOUT_RESCUE -DNO_WARNS \
 	TARGET=${XDEV} TARGET_ARCH=${XDEV_ARCH} \
 	CPUTYPE=${XDEV_CPUTYPE}
 
 XDDIR=${XDEV_ARCH}-freebsd
 XDTP=/usr/${XDDIR}
 CDBENV=MAKEOBJDIRPREFIX=${MAKEOBJDIRPREFIX}/${XDDIR} \
 	INSTALL="sh ${.CURDIR}/tools/install.sh"
 CDENV= ${CDBENV} \
 	_SHLIBDIRPREFIX=${XDTP} \
 	TOOLS_PREFIX=${XDTP}
 CD2ENV=${CDENV} \
 	MACHINE=${XDEV} MACHINE_ARCH=${XDEV_ARCH}
 
 CDTMP=	${MAKEOBJDIRPREFIX}/${XDEV}/${.CURDIR}/tmp
 CDMAKE=${CDENV} ${MAKE} ${NOFUN}
 CD2MAKE=${CD2ENV} PATH=${CDTMP}/usr/bin:${XDTP}/usr/bin:${PATH} ${MAKE} ${NOFUN}
 XDDESTDIR=${DESTDIR}${XDTP}
 .if !defined(OSREL)
 OSREL!= uname -r | sed -e 's/[-(].*//'
 .endif
 
 .ORDER: xdev-build xdev-install
 xdev: xdev-build xdev-install
 
 .ORDER: _xb-build-tools _xb-cross-tools
 xdev-build: _xb-build-tools _xb-cross-tools
 
 _xb-build-tools:
 	${_+_}@cd ${.CURDIR}; \
 	${CDBENV} ${MAKE} -f Makefile.inc1 ${NOFUN} build-tools
 
 _xb-cross-tools:
 .for _tool in \
     gnu/usr.bin/binutils \
     gnu/usr.bin/cc \
     usr.bin/ar
 	${_+_}@${ECHODIR} "===> xdev ${_tool} (obj,depend,all)"; \
 	cd ${.CURDIR}/${_tool}; \
 	${CDMAKE} DIRPRFX=${_tool}/ obj; \
 	${CDMAKE} DIRPRFX=${_tool}/ depend; \
 	${CDMAKE} DIRPRFX=${_tool}/ all
 .endfor
 
 _xi-mtree:
 	${_+_}@${ECHODIR} "mtree populating ${XDDESTDIR}"
 	mkdir -p ${XDDESTDIR}
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.root.dist \
 	    -p ${XDDESTDIR} >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
 	    -p ${XDDESTDIR}/usr >/dev/null
 	mtree -deU -f ${.CURDIR}/etc/mtree/BSD.include.dist \
 	    -p ${XDDESTDIR}/usr/include >/dev/null
 
 .ORDER: _xi-mtree _xi-cross-tools _xi-includes _xi-libraries _xi-links
 xdev-install: _xi-mtree _xi-cross-tools _xi-includes _xi-libraries _xi-links
 
 _xi-cross-tools:
 	@echo "_xi-cross-tools"
 .for _tool in \
     gnu/usr.bin/binutils \
     gnu/usr.bin/cc \
     usr.bin/ar
 	${_+_}@${ECHODIR} "===> xdev ${_tool} (install)"; \
 	cd ${.CURDIR}/${_tool}; \
 	${CDMAKE} DIRPRFX=${_tool}/ install DESTDIR=${XDDESTDIR}
 .endfor
 
 _xi-includes:
 	${_+_}cd ${.CURDIR}; ${CD2MAKE} -f Makefile.inc1 par-includes \
 		DESTDIR=${XDDESTDIR}
 
 _xi-libraries:
 	${_+_}cd ${.CURDIR}; ${CD2MAKE} -f Makefile.inc1 libraries \
 		DESTDIR=${XDDESTDIR}
 
 _xi-links:
 	${_+_}cd ${XDDESTDIR}/usr/bin; \
 		for i in *; do \
 			ln -sf ../../${XDTP}/usr/bin/$$i \
 			    ../../../../usr/bin/${XDDIR}-$$i; \
 			ln -sf ../../${XDTP}/usr/bin/$$i \
 			    ../../../../usr/bin/${XDDIR}${OSREL}-$$i; \
 		done
 .endif

Property changes on: stable/9/Makefile.inc1
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/Makefile.inc1:r274203,274209,274270
Index: stable/9/gnu/lib/libdialog/Makefile
===================================================================
--- stable/9/gnu/lib/libdialog/Makefile	(revision 275050)
+++ stable/9/gnu/lib/libdialog/Makefile	(revision 275051)
@@ -1,20 +1,23 @@
 # $FreeBSD$
 
 DIALOG=		${.CURDIR}/../../../contrib/dialog
 
 LIB=		dialog
 SHLIB_MAJOR=	7
 SRCS=		argv.c arrows.c buttons.c calendar.c checklist.c columns.c \
 		dlg_keys.c editbox.c fselect.c formbox.c guage.c help.c \
 		inputbox.c inputstr.c menubox.c mixedform.c mixedgauge.c \
 		mouse.c mousewget.c msgbox.c pause.c prgbox.c progressbox.c \
 		rc.c tailbox.c textbox.c timebox.c trace.c ui_getc.c util.c \
 		version.c yesno.c
 INCS=		dialog.h dlg_colors.h dlg_config.h dlg_keys.h
 MAN=		dialog.3
 
+DPADD=		${LIBNCURSESW} ${LIBM}
+LDADD=		-lncursesw -lm
+
 CFLAGS+= 	-I${.CURDIR} -I${DIALOG} -D_XOPEN_SOURCE_EXTENDED
 .PATH:		${DIALOG}
 WARNS?=		1
 
 .include <bsd.lib.mk>
Index: stable/9/gnu/lib/libdialog
===================================================================
--- stable/9/gnu/lib/libdialog	(revision 275050)
+++ stable/9/gnu/lib/libdialog	(revision 275051)

Property changes on: stable/9/gnu/lib/libdialog
___________________________________________________________________
Added: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/gnu/lib/libdialog:r274226
Index: stable/9/lib/libdpv/Makefile
===================================================================
--- stable/9/lib/libdpv/Makefile	(revision 275050)
+++ stable/9/lib/libdpv/Makefile	(revision 275051)
@@ -1,16 +1,18 @@
 # $FreeBSD$
 
 LIB=		dpv
 SHLIB_MAJOR=	1
 INCS=		dpv.h
 MAN=		dpv.3
 MLINKS=		dpv.3 dpv_free.3
 
-CFLAGS+=	-I${.CURDIR}
-LDFLAGS+=	-ldialog -lfigpar -lncurses -lutil
+DPADD=		${LIBDIALOG} ${LIBFIGPAR} ${LIBNCURSESW} ${LIBUTIL}
+LDADD=		-ldialog -lfigpar -lncursesw -lutil
 
 SRCS=		dialog_util.c dialogrc.c dprompt.c dpv.c status.c util.c
+
+CFLAGS+=	-I${.CURDIR}
 
 WARNS?=		6
 
 .include <bsd.lib.mk>
Index: stable/9/lib/libdpv/dialog_util.c
===================================================================
--- stable/9/lib/libdpv/dialog_util.c	(revision 275050)
+++ stable/9/lib/libdpv/dialog_util.c	(revision 275051)
@@ -1,633 +1,633 @@
 /*-
  * Copyright (c) 2013-2014 Devin Teske <dteske@FreeBSD.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/ioctl.h>
 
 #include <ctype.h>
 #include <err.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <spawn.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <termios.h>
 #include <unistd.h>
 
 #include "dialog_util.h"
 #include "dpv.h"
 #include "dpv_private.h"
 
 extern char **environ;
 
 #define TTY_DEFAULT_ROWS	24
 #define TTY_DEFAULT_COLS	80
 
 /* [X]dialog(1) characteristics */
 uint8_t dialog_test	= 0;
 uint8_t use_dialog	= 0;
 uint8_t use_libdialog	= 1;
 uint8_t use_xdialog	= 0;
 uint8_t use_color	= 1;
 char dialog[PATH_MAX]	= DIALOG;
 
 /* [X]dialog(1) functionality */
 char *title	= NULL;
 char *backtitle	= NULL;
 int dheight	= 0;
 int dwidth	= 0;
-char *dargv[64]	= { NULL };
+static char *dargv[64] = { NULL };
 
 /* TTY/Screen characteristics */
 static struct winsize *maxsize = NULL;
 
 /* Function prototypes */
 static void tty_maxsize_update(void);
 static void x11_maxsize_update(void);
 
 /*
  * Update row/column fields of `maxsize' global (used by dialog_maxrows() and
  * dialog_maxcols()). If the `maxsize' pointer is NULL, it will be initialized.
  * The `ws_row' and `ws_col' fields of `maxsize' are updated to hold current
  * maximum height and width (respectively) for a dialog(1) widget based on the
  * active TTY size.
  *
  * This function is called automatically by dialog_maxrows/cols() to reflect
  * changes in terminal size in-between calls.
  */
 static void
 tty_maxsize_update(void)
 {
 	int fd = STDIN_FILENO;
 	struct termios t;
 
 	if (maxsize == NULL) {
 		if ((maxsize = malloc(sizeof(struct winsize))) == NULL)
 			errx(EXIT_FAILURE, "Out of memory?!");
 		memset((void *)maxsize, '\0', sizeof(struct winsize));
 	}
 
 	if (!isatty(fd))
 		fd = open("/dev/tty", O_RDONLY);
 	if ((tcgetattr(fd, &t) < 0) || (ioctl(fd, TIOCGWINSZ, maxsize) < 0)) {
 		maxsize->ws_row = TTY_DEFAULT_ROWS;
 		maxsize->ws_col = TTY_DEFAULT_COLS;
 	}
 }
 
 /*
  * Update row/column fields of `maxsize' global (used by dialog_maxrows() and
  * dialog_maxcols()). If the `maxsize' pointer is NULL, it will be initialized.
  * The `ws_row' and `ws_col' fields of `maxsize' are updated to hold current
  * maximum height and width (respectively) for an Xdialog(1) widget based on
  * the active video resolution of the X11 environment.
  *
  * This function is called automatically by dialog_maxrows/cols() to initialize
  * `maxsize'. Since video resolution changes are less common and more obtrusive
  * than changes to terminal size, the dialog_maxrows/cols() functions only call
  * this function when `maxsize' is set to NULL.
  */
 static void
 x11_maxsize_update(void)
 {
 	FILE *f = NULL;
 	char *cols;
 	char *cp;
 	char *rows;
 	char cmdbuf[LINE_MAX];
 	char rbuf[LINE_MAX];
 
 	if (maxsize == NULL) {
 		if ((maxsize = malloc(sizeof(struct winsize))) == NULL)
 			errx(EXIT_FAILURE, "Out of memory?!");
 		memset((void *)maxsize, '\0', sizeof(struct winsize));
 	}
 
 	/* Assemble the command necessary to get X11 sizes */
 	snprintf(cmdbuf, LINE_MAX, "%s --print-maxsize 2>&1", dialog);
 
 	fflush(STDIN_FILENO); /* prevent popen(3) from seeking on stdin */
 
 	if ((f = popen(cmdbuf, "r")) == NULL) {
 		if (debug)
 			warnx("WARNING! Command `%s' failed", cmdbuf);
 		return;
 	}
 
 	/* Read in the line returned from Xdialog(1) */
 	if ((fgets(rbuf, LINE_MAX, f) == NULL) || (pclose(f) < 0))
 		return;
 
 	/* Check for X11-related errors */
 	if (strncmp(rbuf, "Xdialog: Error", 14) == 0)
 		return;
 
 	/* Parse expected output: MaxSize: YY, XXX */
 	if ((rows = strchr(rbuf, ' ')) == NULL)
 		return;
 	if ((cols = strchr(rows, ',')) != NULL) {
 		/* strtonum(3) doesn't like trailing junk */
 		*(cols++) = '\0';
 		if ((cp = strchr(cols, '\n')) != NULL)
 			*cp = '\0';
 	}
 
 	/* Convert to unsigned short */
 	maxsize->ws_row = (unsigned short)strtonum(
 	    rows, 0, USHRT_MAX, (const char **)NULL);
 	maxsize->ws_col = (unsigned short)strtonum(
 	    cols, 0, USHRT_MAX, (const char **)NULL);
 }
 
 /*
  * Return the current maximum height (rows) for an [X]dialog(1) widget.
  */
 int
 dialog_maxrows(void)
 {
 
 	if (use_xdialog && maxsize == NULL)
 		x11_maxsize_update(); /* initialize maxsize for GUI */
 	else if (!use_xdialog)
 		tty_maxsize_update(); /* update maxsize for TTY */
 	return (maxsize->ws_row);
 }
 
 /*
  * Return the current maximum width (cols) for an [X]dialog(1) widget.
  */
 int
 dialog_maxcols(void)
 {
 
 	if (use_xdialog && maxsize == NULL)
 		x11_maxsize_update(); /* initialize maxsize for GUI */
 	else if (!use_xdialog)
 		tty_maxsize_update(); /* update maxsize for TTY */
 
 	if (use_dialog || use_libdialog) {
 		if (use_shadow)
 			return (maxsize->ws_col - 2);
 		else
 			return (maxsize->ws_col);
 	} else
 		return (maxsize->ws_col);
 }
 
 /*
  * Return the current maximum width (cols) for the terminal.
  */
 int
 tty_maxcols(void)
 {
 
 	if (use_xdialog && maxsize == NULL)
 		x11_maxsize_update(); /* initialize maxsize for GUI */
 	else if (!use_xdialog)
 		tty_maxsize_update(); /* update maxsize for TTY */
 
 	return (maxsize->ws_col);
 }
 
 /*
  * Spawn an [X]dialog(1) `--gauge' box with a `--prompt' value of init_prompt.
  * Writes the resulting process ID to the pid_t pointed at by `pid'. Returns a
  * file descriptor (int) suitable for writing data to the [X]dialog(1) instance
  * (data written to the file descriptor is seen as standard-in by the spawned
  * [X]dialog(1) process).
  */
 int
 dialog_spawn_gauge(char *init_prompt, pid_t *pid)
 {
 	char dummy_init[2] = "";
 	char *cp;
 	int height;
 	int width;
 	int error;
 	posix_spawn_file_actions_t action;
 #if DIALOG_SPAWN_DEBUG
 	unsigned int i;
 #endif
 	unsigned int n = 0;
 	int stdin_pipe[2] = { -1, -1 };
 
 	/* Override `dialog' with a path from ENV_DIALOG if provided */
 	if ((cp = getenv(ENV_DIALOG)) != NULL)
 		snprintf(dialog, PATH_MAX, "%s", cp);
 
 	/* For Xdialog(1), set ENV_XDIALOG_HIGH_DIALOG_COMPAT */
 	setenv(ENV_XDIALOG_HIGH_DIALOG_COMPAT, "1", 1);
 
 	/* Constrain the height/width */
 	height = dialog_maxrows();
 	if (backtitle != NULL)
 		height -= use_shadow ? 5 : 4;
 	if (dheight < height)
 		height = dheight;
 	width = dialog_maxcols();
 	if (dwidth < width)
 		width = dwidth;
 
 	/* Populate argument array */
 	dargv[n++] = dialog;
 	if (title != NULL) {
 		if ((dargv[n] = malloc(8)) == NULL)
 			errx(EXIT_FAILURE, "Out of memory?!");
 		sprintf(dargv[n++], "--title");
 		dargv[n++] = title;
 	}
 	if (backtitle != NULL) {
 		if ((dargv[n] = malloc(12)) == NULL)
 			errx(EXIT_FAILURE, "Out of memory?!");
 		sprintf(dargv[n++], "--backtitle");
 		dargv[n++] = backtitle;
 	}
 	if (use_color) {
 		if ((dargv[n] = malloc(11)) == NULL)
 			errx(EXIT_FAILURE, "Out of memory?!");
 		sprintf(dargv[n++], "--colors");
 	}
 	if (use_xdialog) {
 		if ((dargv[n] = malloc(7)) == NULL)
 			errx(EXIT_FAILURE, "Out of memory?!");
 		sprintf(dargv[n++], "--left");
 
 		/*
 		 * NOTE: Xdialog(1)'s `--wrap' appears to be broken for the
 		 * `--gauge' widget prompt-updates. Add it anyway (in-case it
 		 * gets fixed in some later release).
 		 */
 		if ((dargv[n] = malloc(7)) == NULL)
 			errx(EXIT_FAILURE, "Out of memory?!");
 		sprintf(dargv[n++], "--wrap");
 	}
 	if ((dargv[n] = malloc(8)) == NULL)
 		errx(EXIT_FAILURE, "Out of memory?!");
 	sprintf(dargv[n++], "--gauge");
 	dargv[n++] = use_xdialog ? dummy_init : init_prompt;
 	if ((dargv[n] = malloc(40)) == NULL)
 		errx(EXIT_FAILURE, "Out of memory?!");
 	snprintf(dargv[n++], 40, "%u", height);
 	if ((dargv[n] = malloc(40)) == NULL)
 		errx(EXIT_FAILURE, "Out of memory?!");
 	snprintf(dargv[n++], 40, "%u", width);
 	dargv[n] = NULL;
 
 	/* Open a pipe(2) to communicate with [X]dialog(1) */
 	if (pipe(stdin_pipe) < 0)
 		err(EXIT_FAILURE, "%s: pipe(2)", __func__);
 
 	/* Fork [X]dialog(1) process */
 #if DIALOG_SPAWN_DEBUG
 	fprintf(stderr, "%s: spawning `", __func__);
 	for (i = 0; i < n; i++) {
 		if (i == 0)
 			fprintf(stderr, "%s", dargv[i]);
 		else if (*dargv[i] == '-' && *(dargv[i] + 1) == '-')
 			fprintf(stderr, " %s", dargv[i]);
 		else
 			fprintf(stderr, " \"%s\"", dargv[i]);
 	}
 	fprintf(stderr, "'\n");
 #endif
 	posix_spawn_file_actions_init(&action);
 	posix_spawn_file_actions_adddup2(&action, stdin_pipe[0], STDIN_FILENO);
 	posix_spawn_file_actions_addclose(&action, stdin_pipe[1]);
 	error = posix_spawnp(pid, dialog, &action,
 	    (const posix_spawnattr_t *)NULL, dargv, environ);
 	if (error != 0)
 		err(EXIT_FAILURE, "%s: posix_spawnp(3)", __func__);
 
 	/* NB: Do not free(3) *dargv[], else SIGSEGV */
 
 	return (stdin_pipe[1]);
 }
 
 /*
  * Returns the number of lines in buffer pointed to by `prompt'. Takes both
  * newlines and escaped-newlines into account.
  */
 unsigned int
 dialog_prompt_numlines(const char *prompt, uint8_t nlstate)
 {
 	uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
 	const char *cp = prompt;
 	unsigned int nlines = 1;
 
 	if (prompt == NULL || *prompt == '\0')
 		return (0);
 
 	while (*cp != '\0') {
 		if (use_dialog) {
 			if (strncmp(cp, "\\n", 2) == 0) {
 				cp++;
 				nlines++;
 				nls = TRUE; /* See declaration comment */
 			} else if (*cp == '\n') {
 				if (!nls)
 					nlines++;
 				nls = FALSE; /* See declaration comment */
 			}
 		} else if (use_libdialog) {
 			if (*cp == '\n')
 				nlines++;
 		} else if (strncmp(cp, "\\n", 2) == 0) {
 			cp++;
 			nlines++;
 		}
 		cp++;
 	}
 
 	return (nlines);
 }
 
 /*
  * Returns the length in bytes of the longest line in buffer pointed to by
  * `prompt'. Takes newlines and escaped newlines into account. Also discounts
  * dialog(1) color escape codes if enabled (via `use_color' global).
  */
 unsigned int
 dialog_prompt_longestline(const char *prompt, uint8_t nlstate)
 {
 	uint8_t backslash = 0;
 	uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
 	const char *p = prompt;
 	int longest = 0;
 	int n = 0;
 
 	/* `prompt' parameter is required */
 	if (prompt == NULL)
 		return (0);
 	if (*prompt == '\0')
 		return (0); /* shortcut */
 
 	/* Loop until the end of the string */
 	while (*p != '\0') {
 		/* dialog(1) and dialog(3) will render literal newlines */
 		if (use_dialog || use_libdialog) {
 			if (*p == '\n') {
 				if (!use_libdialog && nls)
 					n++;
 				else {
 					if (n > longest)
 						longest = n;
 					n = 0;
 				}
 				nls = FALSE; /* See declaration comment */
 				p++;
 				continue;
 			}
 		}
 
 		/* Check for backslash character */
 		if (*p == '\\') {
 			/* If second backslash, count as a single-char */
 			if ((backslash ^= 1) == 0)
 				n++;
 		} else if (backslash) {
 			if (*p == 'n' && !use_libdialog) { /* new line */
 				/* NB: dialog(3) ignores escaped newlines */
 				nls = TRUE; /* See declaration comment */
 				if (n > longest)
 					longest = n;
 				n = 0;
 			} else if (use_color && *p == 'Z') {
 				if (*++p != '\0')
 					p++;
 				backslash = 0;
 				continue;
 			} else /* [X]dialog(1)/dialog(3) only expand those */
 				n += 2;
 
 			backslash = 0;
 		} else
 			n++;
 		p++;
 	}
 	if (n > longest)
 		longest = n;
 
 	return (longest);
 }
 
 /*
  * Returns a pointer to the last line in buffer pointed to by `prompt'. Takes
  * both newlines (if using dialog(1) versus Xdialog(1)) and escaped newlines
  * into account. If no newlines (escaped or otherwise) appear in the buffer,
  * `prompt' is returned. If passed a NULL pointer, returns NULL.
  */
 char *
 dialog_prompt_lastline(char *prompt, uint8_t nlstate)
 {
 	uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
 	char *lastline;
 	char *p;
 
 	if (prompt == NULL)
 		return (NULL);
 	if (*prompt == '\0')
 		return (prompt); /* shortcut */
 
 	lastline = p = prompt;
 	while (*p != '\0') {
 		/* dialog(1) and dialog(3) will render literal newlines */
 		if (use_dialog || use_libdialog) {
 			if (*p == '\n') {
 				if (use_libdialog || !nls)
 					lastline = p + 1;
 				nls = FALSE; /* See declaration comment */
 			}
 		}
 		/* dialog(3) does not expand escaped newlines */
 		if (use_libdialog) {
 			p++;
 			continue;
 		}
 		if (*p == '\\' && *(p + 1) != '\0' && *(++p) == 'n') {
 			nls = TRUE; /* See declaration comment */
 			lastline = p + 1;
 		}
 		p++;
 	}
 
 	return (lastline);
 }
 
 /*
  * Returns the number of extra lines generated by wrapping the text in buffer
  * pointed to by `prompt' within `ncols' columns (for prompts, this should be
  * dwidth - 4). Also discounts dialog(1) color escape codes if enabled (via
  * `use_color' global).
  */
 int
 dialog_prompt_wrappedlines(char *prompt, int ncols, uint8_t nlstate)
 {
 	uint8_t backslash = 0;
 	uint8_t nls = nlstate; /* See dialog_prompt_nlstate() */
 	char *cp;
 	char *p = prompt;
 	int n = 0;
 	int wlines = 0;
 
 	/* `prompt' parameter is required */
 	if (p == NULL)
 		return (0);
 	if (*p == '\0')
 		return (0); /* shortcut */
 
 	/* Loop until the end of the string */
 	while (*p != '\0') {
 		/* dialog(1) and dialog(3) will render literal newlines */
 		if (use_dialog || use_libdialog) {
 			if (*p == '\n') {
 				if (use_dialog || !nls)
 					n = 0;
 				nls = FALSE; /* See declaration comment */
 			}
 		}
 
 		/* Check for backslash character */
 		if (*p == '\\') {
 			/* If second backslash, count as a single-char */
 			if ((backslash ^= 1) == 0)
 				n++;
 		} else if (backslash) {
 			if (*p == 'n' && !use_libdialog) { /* new line */
 				/* NB: dialog(3) ignores escaped newlines */
 				nls = TRUE; /* See declaration comment */
 				n = 0;
 			} else if (use_color && *p == 'Z') {
 				if (*++p != '\0')
 					p++;
 				backslash = 0;
 				continue;
 			} else /* [X]dialog(1)/dialog(3) only expand those */
 				n += 2;
 
 			backslash = 0;
 		} else
 			n++;
 
 		/* Did we pass the width barrier? */
 		if (n > ncols) {
 			/*
 			 * Work backward to find the first whitespace on-which
 			 * dialog(1) will wrap the line (but don't go before
 			 * the start of this line).
 			 */
 			cp = p;
 			while (n > 1 && !isspace(*cp)) {
 				cp--;
 				n--;
 			}
 			if (n > 0 && isspace(*cp))
 				p = cp;
 			wlines++;
 			n = 1;
 		}
 
 		p++;
 	}
 
 	return (wlines);
 }
 
 /*
  * Returns zero if the buffer pointed to by `prompt' contains an escaped
  * newline but only if appearing after any/all literal newlines. This is
  * specific to dialog(1) and does not apply to Xdialog(1).
  *
  * As an attempt to make shell scripts easier to read, dialog(1) will "eat"
  * the first literal newline after an escaped newline. This however has a bug
  * in its implementation in that rather than allowing `\\n\n' to be treated
  * similar to `\\n' or `\n', dialog(1) expands the `\\n' and then translates
  * the following literal newline (with or without characters between [!]) into
  * a single space.
  *
  * If you want to be compatible with Xdialog(1), it is suggested that you not
  * use literal newlines (they aren't supported); but if you have to use them,
  * go right ahead. But be forewarned... if you set $DIALOG in your environment
  * to something other than `cdialog' (our current dialog(1)), then it should
  * do the same thing w/respect to how to handle a literal newline after an
  * escaped newline (you could do no wrong by translating every literal newline
  * into a space but only when you've previously encountered an escaped one;
  * this is what dialog(1) is doing).
  *
  * The ``newline state'' (or nlstate for short; as I'm calling it) is helpful
  * if you plan to combine multiple strings into a single prompt text. In lead-
  * up to this procedure, a common task is to calculate and utilize the widths
  * and heights of each piece of prompt text to later be combined. However, if
  * (for example) the first string ends in a positive newline state (has an
  * escaped newline without trailing literal), the first literal newline in the
  * second string will be mangled.
  *
  * The return value of this function should be used as the `nlstate' argument
  * to dialog_*() functions that require it to allow accurate calculations in
  * the event such information is needed.
  */
 uint8_t
 dialog_prompt_nlstate(const char *prompt)
 {
 	const char *cp;
 
 	if (prompt == NULL)
 		return 0;
 
 	/*
 	 * Work our way backward from the end of the string for efficiency.
 	 */
 	cp = prompt + strlen(prompt);
 	while (--cp >= prompt) {
 		/*
 		 * If we get to a literal newline first, this prompt ends in a
 		 * clean state for rendering with dialog(1). Otherwise, if we
 		 * get to an escaped newline first, this prompt ends in an un-
 		 * clean state (following literal will be mangled; see above).
 		 */
 		if (*cp == '\n')
 			return (0);
 		else if (*cp == 'n' && --cp > prompt && *cp == '\\')
 			return (1);
 	}
 
 	return (0); /* no newlines (escaped or otherwise) */
 }
 
 /*
  * Free allocated items initialized by tty_maxsize_update() and
  * x11_maxsize_update()
  */
 void
 dialog_maxsize_free(void)
 {
 	if (maxsize != NULL) {
 		free(maxsize);
 		maxsize = NULL;
 	}
 }
Index: stable/9/lib/libdpv/dialogrc.c
===================================================================
--- stable/9/lib/libdpv/dialogrc.c	(revision 275050)
+++ stable/9/lib/libdpv/dialogrc.c	(revision 275051)
@@ -1,359 +1,359 @@
 /*-
  * Copyright (c) 2013-2014 Devin Teske <dteske@FreeBSD.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/types.h>
 
 #include <err.h>
 #include <errno.h>
 #include <figpar.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <string_m.h>
 
 #include "dialogrc.h"
 
 #define STR_BUFSIZE 255
 
 /* dialog(1) `.dialogrc' characteristics */
 uint8_t use_colors = 1;
 uint8_t use_shadow = 1;
 char gauge_color[STR_BUFSIZE]	= "47b"; /* (BLUE,WHITE,ON) */
 char separator[STR_BUFSIZE]	= "";
 
 /* Function prototypes */
-static int setattr(struct config *, uint32_t, char *, char *);
-static int setbool(struct config *, uint32_t, char *, char *);
-static int setnum(struct config *, uint32_t, char *, char *);
-static int setstr(struct config *, uint32_t, char *, char *);
+static int setattr(struct fp_config *, uint32_t, char *, char *);
+static int setbool(struct fp_config *, uint32_t, char *, char *);
+static int setnum(struct fp_config *, uint32_t, char *, char *);
+static int setstr(struct fp_config *, uint32_t, char *, char *);
 
 /*
  * Anatomy of DIALOGRC (~/.dialogrc by default)
  * NOTE: Must appear after private function prototypes (above)
  * NB: Brace-initialization of union requires cast to *first* member of union
  */
-static struct config dialogrc_config[] = {
-    /* TYPE     Directive			DEFAULT		HANDLER */
-    {TYPE_INT,	"aspect",			{(void *)0},	&setnum},
-    {TYPE_STR,	"separate_widget",		{separator},	&setstr},
-    {TYPE_INT,	"tab_len",			{(void *)0},	&setnum},
-    {TYPE_BOOL,	"visit_items",			{(void *)0},	&setbool},
-    {TYPE_BOOL, "use_shadow",			{(void *)1},	&setbool},
-    {TYPE_BOOL, "use_colors",			{(void *)1},	&setbool},
-    {TYPE_STR,	"screen_color",			{NULL},		&setattr},
-    {TYPE_STR,	"shadow_color",			{NULL},		&setattr},
-    {TYPE_STR,	"dialog_color",			{NULL},		&setattr},
-    {TYPE_STR,	"title_color",			{NULL},		&setattr},
-    {TYPE_STR,	"border_color",			{NULL},		&setattr},
-    {TYPE_STR,	"button_active_color",		{NULL},		&setattr},
-    {TYPE_STR,	"button_inactive_color",	{NULL},		&setattr},
-    {TYPE_STR,	"button_key_active_color",	{NULL},		&setattr},
-    {TYPE_STR,	"button_key_inactive_color",	{NULL},		&setattr},
-    {TYPE_STR,	"button_label_active_color",	{NULL},		&setattr},
-    {TYPE_STR,	"button_label_inactive_color",	{NULL},		&setattr},
-    {TYPE_STR,	"inputbox_color",		{NULL},		&setattr},
-    {TYPE_STR,	"inputbox_border_color",	{NULL},		&setattr},
-    {TYPE_STR,	"searchbox_color",		{NULL},		&setattr},
-    {TYPE_STR,	"searchbox_title_color",	{NULL},		&setattr},
-    {TYPE_STR,	"searchbox_border_color",	{NULL},		&setattr},
-    {TYPE_STR,	"position_indicator_color",	{NULL},		&setattr},
-    {TYPE_STR,	"menubox_color",		{NULL},		&setattr},
-    {TYPE_STR,	"menubox_border_color",		{NULL},		&setattr},
-    {TYPE_STR,	"item_color",			{NULL},		&setattr},
-    {TYPE_STR,	"item_selected_color",		{NULL},		&setattr},
-    {TYPE_STR,	"tag_color",			{NULL},		&setattr},
-    {TYPE_STR,	"tag_selected_color",		{NULL},		&setattr},
-    {TYPE_STR,	"tag_key_color",		{NULL},		&setattr},
-    {TYPE_STR,	"tag_key_selected_color",	{NULL},		&setattr},
-    {TYPE_STR,	"check_color",			{NULL},		&setattr},
-    {TYPE_STR,	"check_selected_color",		{NULL},		&setattr},
-    {TYPE_STR,	"uarrow_color",			{NULL},		&setattr},
-    {TYPE_STR,	"darrow_color",			{NULL},		&setattr},
-    {TYPE_STR,	"itemhelp_color",		{NULL},		&setattr},
-    {TYPE_STR,	"form_active_text_color",	{NULL},		&setattr},
-    {TYPE_STR,	"form_text_color",		{NULL},		&setattr},
-    {TYPE_STR,	"form_item_readonly_color",	{NULL},		&setattr},
-    {TYPE_STR,	"gauge_color",			{gauge_color},	&setattr},
+static struct fp_config dialogrc_config[] = {
+    /* TYPE        Directive                     DEFAULT        HANDLER */
+    {FP_TYPE_INT,  "aspect",                     {(void *)0},   &setnum},
+    {FP_TYPE_STR,  "separate_widget",            {separator},   &setstr},
+    {FP_TYPE_INT,  "tab_len",                    {(void *)0},   &setnum},
+    {FP_TYPE_BOOL, "visit_items",                {(void *)0},   &setbool},
+    {FP_TYPE_BOOL, "use_shadow",                 {(void *)1},   &setbool},
+    {FP_TYPE_BOOL, "use_colors",                 {(void *)1},   &setbool},
+    {FP_TYPE_STR,  "screen_color",               {NULL},        &setattr},
+    {FP_TYPE_STR,  "shadow_color",               {NULL},        &setattr},
+    {FP_TYPE_STR,  "dialog_color",               {NULL},        &setattr},
+    {FP_TYPE_STR,  "title_color",                {NULL},        &setattr},
+    {FP_TYPE_STR,  "border_color",               {NULL},        &setattr},
+    {FP_TYPE_STR,  "button_active_color",        {NULL},        &setattr},
+    {FP_TYPE_STR,  "button_inactive_color",      {NULL},        &setattr},
+    {FP_TYPE_STR,  "button_key_active_color",    {NULL},        &setattr},
+    {FP_TYPE_STR,  "button_key_inactive_color",  {NULL},        &setattr},
+    {FP_TYPE_STR,  "button_label_active_color",  {NULL},        &setattr},
+    {FP_TYPE_STR,  "button_label_inactive_color",{NULL},        &setattr},
+    {FP_TYPE_STR,  "inputbox_color",             {NULL},        &setattr},
+    {FP_TYPE_STR,  "inputbox_border_color",      {NULL},        &setattr},
+    {FP_TYPE_STR,  "searchbox_color",            {NULL},        &setattr},
+    {FP_TYPE_STR,  "searchbox_title_color",      {NULL},        &setattr},
+    {FP_TYPE_STR,  "searchbox_border_color",     {NULL},        &setattr},
+    {FP_TYPE_STR,  "position_indicator_color",   {NULL},        &setattr},
+    {FP_TYPE_STR,  "menubox_color",              {NULL},        &setattr},
+    {FP_TYPE_STR,  "menubox_border_color",       {NULL},        &setattr},
+    {FP_TYPE_STR,  "item_color",                 {NULL},        &setattr},
+    {FP_TYPE_STR,  "item_selected_color",        {NULL},        &setattr},
+    {FP_TYPE_STR,  "tag_color",                  {NULL},        &setattr},
+    {FP_TYPE_STR,  "tag_selected_color",         {NULL},        &setattr},
+    {FP_TYPE_STR,  "tag_key_color",              {NULL},        &setattr},
+    {FP_TYPE_STR,  "tag_key_selected_color",     {NULL},        &setattr},
+    {FP_TYPE_STR,  "check_color",                {NULL},        &setattr},
+    {FP_TYPE_STR,  "check_selected_color",       {NULL},        &setattr},
+    {FP_TYPE_STR,  "uarrow_color",               {NULL},        &setattr},
+    {FP_TYPE_STR,  "darrow_color",               {NULL},        &setattr},
+    {FP_TYPE_STR,  "itemhelp_color",             {NULL},        &setattr},
+    {FP_TYPE_STR,  "form_active_text_color",     {NULL},        &setattr},
+    {FP_TYPE_STR,  "form_text_color",            {NULL},        &setattr},
+    {FP_TYPE_STR,  "form_item_readonly_color",   {NULL},        &setattr},
+    {FP_TYPE_STR,  "gauge_color",                {gauge_color}, &setattr},
     {0, NULL, {0}, NULL}
 };
 
 /*
  * figpar call-back for interpreting value as .dialogrc `Attribute'
  */
 static int
-setattr(struct config *option, uint32_t line __unused,
+setattr(struct fp_config *option, uint32_t line __unused,
     char *directive __unused, char *value)
 {
 	char *cp = value;
 	char *val;
 	size_t len;
 	char attrbuf[4];
 
 	if (option == NULL) {
 		warnx("%s:%d:%s: Missing callback parameter", __FILE__,
 		    __LINE__, __func__);
 		return (-1); /* Abort processing */
 	}
 
 	/* Allocate memory for the data if not already done */
 	if (option->value.str == NULL) {
 		if ((option->value.str = malloc(STR_BUFSIZE)) == NULL)
 			return (-1);
 	}
 
 	/*
 	 * If the first character is left-parenthesis, the format is
 	 * `(background,foreground,highlight)' otherwise, we should take it
 	 * as a reference to another color.
 	 */
 	if (*cp != '(') {
 		/* Copy the [current] value from the referenced color */
 		val = dialogrc_config_option(cp)->value.str;
 		if (val != NULL)
 			snprintf(option->value.str, STR_BUFSIZE, "%s", val);
 
 		return (0);
 	} else
 		cp++;
 
 	strtolower(cp);
 
 	/* Initialize the attrbuf (fg,bg,hi,NUL) */
 	attrbuf[0] = '0';
 	attrbuf[1] = '0';
 	attrbuf[2] = 'B'; /* \ZB = disable; \Zb = enable (see dialog(1)) */
 	attrbuf[3] = '\0';
 
 	/* Interpret the foreground color */
 	if      (strncmp(cp, "red,",     4) == 0) attrbuf[0] = '1';
 	else if (strncmp(cp, "green,",   6) == 0) attrbuf[0] = '2';
 	else if (strncmp(cp, "yellow,",  7) == 0) attrbuf[0] = '3';
 	else if (strncmp(cp, "blue,",    5) == 0) attrbuf[0] = '4';
 	else if (strncmp(cp, "magenta,", 8) == 0) attrbuf[0] = '5';
 	else if (strncmp(cp, "cyan,",    5) == 0) attrbuf[0] = '6';
 	else if (strncmp(cp, "white,",   6) == 0) attrbuf[0] = '7';
 	else if (strncmp(cp, "black,",   6) == 0) attrbuf[0] = '8';
 
 	/* Advance to the background color */
 	cp = strchr(cp, ',');
 	if (cp == NULL)
 		goto write_attrbuf;
 	else
 		cp++;
 
 	/* Interpret the background color */
 	if      (strncmp(cp, "red,",     4) == 0) attrbuf[1] = '1';
 	else if (strncmp(cp, "green,",   6) == 0) attrbuf[1] = '2';
 	else if (strncmp(cp, "yellow,",  7) == 0) attrbuf[1] = '3';
 	else if (strncmp(cp, "blue,",    5) == 0) attrbuf[1] = '4';
 	else if (strncmp(cp, "magenta,", 8) == 0) attrbuf[1] = '5';
 	else if (strncmp(cp, "cyan,",    5) == 0) attrbuf[1] = '6';
 	else if (strncmp(cp, "white,",   6) == 0) attrbuf[1] = '7';
 	else if (strncmp(cp, "black,",   6) == 0) attrbuf[1] = '8';
 
 	/* Advance to the highlight */
 	cp = strchr(cp, ',');
 	if (cp == NULL)
 		goto write_attrbuf;
 	else
 		cp++;
 
 	/* Trim trailing parenthesis */
 	len = strlen(cp);
 	if (cp[len - 1] == ')')
 		cp[len - 1] = '\0';
 
 	/* Interpret the highlight (initialized to off above) */
 	if (strcmp(cp, "on") == 0 || strncmp(cp, "on,", 3) == 0)
 		attrbuf[2] = 'b'; /* \Zb = enable bold (see dialog(1)) */
 
 write_attrbuf:
 	sprintf(option->value.str, "%s", attrbuf);
 
 	return (0);
 }
 
 /*
  * figpar call-back for interpreting value as .dialogrc `Boolean'
  */
 static int
-setbool(struct config *option, uint32_t line __unused,
+setbool(struct fp_config *option, uint32_t line __unused,
     char *directive __unused, char *value)
 {
 
 	if (option == NULL) {
 		warnx("%s:%d:%s: Missing callback parameter", __FILE__,
 		    __LINE__, __func__);
 		return (-1); /* Abort processing */
 	}
 
 	/* Assume ON, check for OFF (case-insensitive) */
 	option->value.boolean = 1;
 	strtolower(value);
 	if (strcmp(value, "off") == 0)
 		option->value.boolean = 0;
 
 	return (0);
 }
 
 /*
  * figpar call-back for interpreting value as .dialogrc `Number'
  */
 static int
-setnum(struct config *option, uint32_t line __unused, char *directive __unused,
-    char *value)
+setnum(struct fp_config *option, uint32_t line __unused,
+    char *directive __unused, char *value)
 {
 
 	if (option == NULL) {
 		warnx("%s:%d:%s: Missing callback parameter", __FILE__,
 		    __LINE__, __func__);
 		return (-1); /* Abort processing */
 	}
 
 	/* Convert the string to a 32-bit signed integer */
 	option->value.num = (int32_t)strtol(value, (char **)NULL, 10);
 
 	return (0);
 }
 
 /*
  * figpar call-back for interpreting value as .dialogrc `String'
  */
 static int
-setstr(struct config *option, uint32_t line __unused, char *directive __unused,
-    char *value)
+setstr(struct fp_config *option, uint32_t line __unused,
+    char *directive __unused, char *value)
 {
 	size_t len;
 
 	if (option == NULL) {
 		warnx("%s:%d:%s: Missing callback parameter", __FILE__,
 		    __LINE__, __func__);
 		return (-1); /* Abort processing */
 	}
 
 	/* Allocate memory for the data if not already done */
 	if (option->value.str == NULL) {
 		if ((option->value.str = malloc(STR_BUFSIZE)) == NULL)
 			return (-1);
 	}
 
 	/* Trim leading quote */
 	if (*value == '"')
 		value++;
 
 	/* Write the data into the buffer */
 	snprintf(option->value.str, STR_BUFSIZE, "%s", value);
 
 	/* Trim trailing quote */
 	len = strlen(option->value.str);
 	if (option->value.str[len - 1] == '"')
 		option->value.str[len - 1] = '\0';
 
 	return (0);
 }
 
 /*
  * Parse (in order of preference) $DIALOGRC or `$HOME/.dialogrc'. Returns zero
  * on success, -1 on failure (and errno should be consulted).
  */
 int
 parse_dialogrc(void)
 {
 	char *cp;
 	int res;
 	size_t len;
 	char path[PATH_MAX];
 
 	/* Allow $DIALOGRC to override `$HOME/.dialogrc' default */
 	if ((cp = getenv(ENV_DIALOGRC)) != NULL && *cp != '\0')
 		snprintf(path, PATH_MAX, "%s", cp);
 	else if ((cp = getenv(ENV_HOME)) != NULL) {
 		/* Copy $HOME into buffer and append trailing `/' if missing */
 		snprintf(path, PATH_MAX, "%s", cp);
 		len = strlen(path);
 		cp = path + len;
 		if (len > 0 && len < (PATH_MAX - 1) && *(cp - 1) != '/') {
 			*cp++ = '/';
 			*cp = '\0';
 			len++;
 		}
 
 		/* If we still have room, shove in the name of rc file */
 		if (len < (PATH_MAX - 1))
 			snprintf(cp, PATH_MAX - len, "%s", DIALOGRC);
 	} else {
 		/* Like dialog(1), don't process a file if $HOME is unset */
 		errno = ENOENT;
 		return (-1);
 	}
 
 	/* Process file (either $DIALOGRC if set, or `$HOME/.dialogrc') */
-	res = parse_config(dialogrc_config, path, NULL, BREAK_ON_EQUALS);
+	res = parse_config(dialogrc_config, path, NULL, FP_BREAK_ON_EQUALS);
 
 	/* Set some globals based on what we parsed */
 	use_shadow = dialogrc_config_option("use_shadow")->value.boolean;
 	use_colors = dialogrc_config_option("use_colors")->value.boolean;
 	snprintf(gauge_color, STR_BUFSIZE, "%s",
 	    dialogrc_config_option("gauge_color")->value.str);
 
 	return (res);
 }
 
 /*
  * Return a pointer to the `.dialogrc' config option specific to `directive' or
- * static dummy_config (full of NULLs) if none found (see get_config_option(3);
- * part of figpar(3)).
+ * static fp_dummy_config (full of NULLs) if none found (see
+ * get_config_option(3); part of figpar(3)).
  */
-struct config *
+struct fp_config *
 dialogrc_config_option(const char *directive)
 {
 	return (get_config_option(dialogrc_config, directive));
 }
 
 /*
  * Free allocated items initialized by setattr() (via parse_config() callback
  * matrix [dialogrc_config] used in parse_dialogrc() above).
  */
 void
 dialogrc_free(void)
 {
 	char *value;
 	uint32_t n;
 
 	for (n = 0; dialogrc_config[n].directive != NULL; n++) {
 		if (dialogrc_config[n].action != &setattr)
 			continue;
 		value = dialogrc_config[n].value.str;
 		if (value != NULL && value != gauge_color) {
 			free(dialogrc_config[n].value.str);
 			dialogrc_config[n].value.str = NULL;
 		}
 	}
 }
Index: stable/9/lib/libdpv/dialogrc.h
===================================================================
--- stable/9/lib/libdpv/dialogrc.h	(revision 275050)
+++ stable/9/lib/libdpv/dialogrc.h	(revision 275051)
@@ -1,56 +1,56 @@
 /*-
  * Copyright (c) 2013-2014 Devin Teske <dteske@FreeBSD.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  * $FreeBSD$
  */
 
 #ifndef _DIALOGRC_H_
 #define _DIALOGRC_H_
 
 #include <sys/types.h>
 
 #include <figpar.h>
 
 /* dialog(3) dlg_color_table[] attributes */
 #define GAUGE_ATTR	33	/* entry used for gauge_color */
 
 /* dialog(1) characteristics */
 #define DIALOGRC	".dialogrc"
 #define ENV_DIALOGRC	"DIALOGRC"
 #define ENV_HOME	"HOME"
 
 /* dialog(1) `.dialogrc' characteristics */
 extern uint8_t use_colors;
 extern uint8_t use_shadow;
 extern char gauge_color[];
 extern char separator[];
 
 __BEGIN_DECLS
-void		 dialogrc_free(void);
-int		 parse_dialogrc(void);
-struct config	*dialogrc_config_option(const char *_directive);
+void			 dialogrc_free(void);
+int			 parse_dialogrc(void);
+struct fp_config	*dialogrc_config_option(const char *_directive);
 __END_DECLS
 
 #endif /* !_DIALOGRC_H_ */
Index: stable/9/lib/libdpv/dpv.c
===================================================================
--- stable/9/lib/libdpv/dpv.c	(revision 275050)
+++ stable/9/lib/libdpv/dpv.c	(revision 275051)
@@ -1,721 +1,721 @@
 /*-
  * Copyright (c) 2013-2014 Devin Teske <dteske@FreeBSD.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include <ctype.h>
 #include <dialog.h>
 #include <err.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <string_m.h>
 #include <unistd.h>
 
 #include "dialog_util.h"
 #include "dialogrc.h"
 #include "dprompt.h"
 #include "dpv.h"
 #include "dpv_private.h"
 #include "status.h"
 #include "util.h"
 
 /* Test Mechanics (Only used when dpv_config.options |= DPV_TEST_MODE) */
 #define INCREMENT		1	/* Increment % per-pass test-mode */
 #define XDIALOG_INCREMENT	15	/* different for slower Xdialog(1) */
 static uint8_t increment = INCREMENT;
 
 /* Debugging */
 uint8_t debug = FALSE;
 
 /* Data to process */
 int dpv_interrupt = FALSE;
 int dpv_abort = FALSE;
 unsigned int dpv_nfiles = 0;
 
 /* Data processing */
 long long dpv_overall_read = 0;
 static char pathbuf[PATH_MAX];
 
 /* Extra display information */
 uint8_t no_labels = FALSE;	/* dpv_config.options & DPV_NO_LABELS */
 uint8_t wide = FALSE;		/* dpv_config.options & DPV_WIDE_MODE */
 char *aprompt = NULL;		/* dpv_config.aprompt */
 char *msg_done = NULL;		/* dpv_config.msg_done */
 char *msg_fail = NULL;		/* dpv_config.msg_fail */
 char *msg_pending = NULL;	/* dpv_config.msg_pending */
 char *pprompt = NULL;		/* dpv_config.pprompt */
 
 /* Status-Line format for when using dialog(3) */
-const char *status_format_custom = NULL;
-char status_format_default[DPV_STATUS_FORMAT_MAX];
+static const char *status_format_custom = NULL;
+static char status_format_default[DPV_STATUS_FORMAT_MAX];
 
 /*
  * Takes a pointer to a dpv_config structure containing layout details and
  * pointer to initial element in a linked-list of dpv_file_node structures,
  * each presenting a file to process. Executes the `action' function passed-in
  * as a member to the `config' structure argument.
  */
 int
 dpv(struct dpv_config *config, struct dpv_file_node *file_list)
 {
 	char c;
 	uint8_t keep_going;
 	uint8_t nls = FALSE; /* See dialog_prompt_nlstate() */
 	uint8_t no_overrun = FALSE;
 	uint8_t pprompt_nls = FALSE; /* See dialog_prompt_nlstate() */
 	uint8_t shrink_label_size = FALSE;
 	mode_t mask;
 	uint16_t options;
 	char *cp;
 	char *fc;
 	char *last;
 	char *name;
 	char *output;
 	const char *status_fmt;
 	const char *path_fmt;
 	enum dpv_display display_type;
 	enum dpv_output output_type;
 	enum dpv_status status;
 	int (*action)(struct dpv_file_node *file, int out);
 	int backslash;
 	int dialog_last_update = 0;
 	int dialog_old_nthfile = 0;
 	int dialog_old_seconds = -1;
 	int dialog_out = STDOUT_FILENO;
 	int dialog_update_usec = 0;
 	int dialog_updates_per_second;
 	int files_left;
 	int max_cols;
 	int nthfile = 0;
 	int output_out;
 	int overall = 0;
 	int pct;
 	int res;
 	int seconds;
 	int status_last_update = 0;
 	int status_old_nthfile = 0;
 	int status_old_seconds = -1;
 	int status_update_usec = 0;
 	int status_updates_per_second;
 	pid_t output_pid;
 	pid_t pid;
 	size_t len;
 	struct dpv_file_node *curfile;
 	struct dpv_file_node *first_file;
 	struct dpv_file_node *list_head;
 	struct timeval now;
 	struct timeval start;
 	char init_prompt[PROMPT_MAX + 1] = "";
 
 	/* Initialize globals to default values */
 	aprompt		= NULL;
 	pprompt		= NULL;
 	options		= 0;
 	action		= NULL;
 	backtitle	= NULL;
 	debug		= FALSE;
 	dialog_test	= FALSE;
 	dialog_updates_per_second = DIALOG_UPDATES_PER_SEC;
 	display_limit	= DISPLAY_LIMIT_DEFAULT;
 	display_type	= DPV_DISPLAY_LIBDIALOG;
 	label_size	= LABEL_SIZE_DEFAULT;
 	msg_done	= NULL;
 	msg_fail	= NULL;
 	msg_pending	= NULL;
 	no_labels	= FALSE;
 	output		= NULL;
 	output_type	= DPV_OUTPUT_NONE;
 	pbar_size	= PBAR_SIZE_DEFAULT;
 	status_format_custom = NULL;
 	status_updates_per_second = STATUS_UPDATES_PER_SEC;
 	title		= NULL;
 	wide		= FALSE;
 
 	/* Process config options (overriding defaults) */
 	if (config != NULL) {
 		if (config->aprompt != NULL) {
 			if (aprompt == NULL) {
 				aprompt = malloc(DPV_APROMPT_MAX);
 				if (aprompt == NULL)
 					return (-1);
 			}
 			snprintf(aprompt, DPV_APROMPT_MAX, "%s",
 			    config->aprompt);
 		}
 		if (config->pprompt != NULL) {
 			if (pprompt == NULL) {
 				pprompt = malloc(DPV_PPROMPT_MAX + 2);
 				/* +2 is for implicit "\n" appended later */
 				if (pprompt == NULL)
 					return (-1);
 			}
 			snprintf(pprompt, DPV_APROMPT_MAX, "%s",
 			    config->pprompt);
 		}
 
 		options		= config->options;
 		action		= config->action;
 		backtitle	= config->backtitle;
 		debug		= config->debug;
 		dialog_test	= ((options & DPV_TEST_MODE) != 0);
 		dialog_updates_per_second = config->dialog_updates_per_second;
 		display_limit	= config->display_limit;
 		display_type	= config->display_type;
 		label_size	= config->label_size;
 		msg_done	= (char *)config->msg_done;
 		msg_fail	= (char *)config->msg_fail;
 		msg_pending	= (char *)config->msg_pending;
 		no_labels	= ((options & DPV_NO_LABELS) != 0);
 		no_overrun	= ((options & DPV_NO_OVERRUN) != 0);
 		output          = config->output;
 		output_type	= config->output_type;
 		pbar_size	= config->pbar_size;
 		status_updates_per_second = config->status_updates_per_second;
 		title		= config->title;
 		wide		= ((options & DPV_WIDE_MODE) != 0);
 
 		/* Enforce some minimums (pedantic) */
 		if (display_limit < -1)
 			display_limit = -1;
 		if (label_size < -1)
 			label_size = -1;
 		if (pbar_size < -1)
 			pbar_size = -1;
 
 		/* For the mini-pbar, -1 means hide, zero is invalid unless
 		 * only one file is given */
 		if (pbar_size == 0) {
 			if (file_list == NULL || file_list->next == NULL)
 				pbar_size = -1;
 			else
 				pbar_size = PBAR_SIZE_DEFAULT;
 		}
 
 		/* For the label, -1 means auto-size, zero is invalid unless
 		 * specifically requested through the use of options flag */
 		if (label_size == 0 && no_labels == FALSE)
 			label_size = LABEL_SIZE_DEFAULT;
 
 		/* Status update should not be zero */
 		if (status_updates_per_second == 0)
 			status_updates_per_second = STATUS_UPDATES_PER_SEC;
 	} /* config != NULL */
 
 	/* Process the type of display we've been requested to produce */
 	switch (display_type) {
 	case DPV_DISPLAY_STDOUT:
 		debug		= TRUE;
 		use_color	= FALSE;
 		use_dialog	= FALSE;
 		use_libdialog	= FALSE;
 		use_xdialog	= FALSE;
 		break;
 	case DPV_DISPLAY_DIALOG:
 		use_color	= TRUE;
 		use_dialog	= TRUE;
 		use_libdialog	= FALSE;
 		use_xdialog	= FALSE;
 		break;
 	case DPV_DISPLAY_XDIALOG:
 		snprintf(dialog, PATH_MAX, XDIALOG);
 		use_color	= FALSE;
 		use_dialog	= FALSE;
 		use_libdialog	= FALSE;
 		use_xdialog	= TRUE;
 		break;
 	default:
 		use_color	= TRUE;
 		use_dialog	= FALSE;
 		use_libdialog	= TRUE;
 		use_xdialog	= FALSE;
 		break;
 	} /* display_type */
 
 	/* Enforce additional minimums that require knowing our display type */
 	if (dialog_updates_per_second == 0)
 		dialog_updates_per_second = use_xdialog ?
 			XDIALOG_UPDATES_PER_SEC : DIALOG_UPDATES_PER_SEC;
 
 	/* Allow forceful override of use_color */
 	if (config != NULL && (config->options & DPV_USE_COLOR) != 0)
 		use_color = TRUE;
 
 	/* Count the number of files in provided list of dpv_file_node's */
 	if (use_dialog && pprompt != NULL && *pprompt != '\0')
 		pprompt_nls = dialog_prompt_nlstate(pprompt);
 
 	max_cols = dialog_maxcols();
 	if (label_size == -1)
 		shrink_label_size = TRUE;
 
 	/* Process file arguments */
 	for (curfile = file_list; curfile != NULL; curfile = curfile->next) {
 		dpv_nfiles++;
 
 		/* dialog(3) only expands literal newlines */
 		if (use_libdialog) strexpandnl(curfile->name);
 
 		/* Optionally calculate label size for file */
 		if (shrink_label_size) {
 			nls = FALSE;
 			name = curfile->name;
 			if (curfile == file_list)
 				nls = pprompt_nls;
 			last = (char *)dialog_prompt_lastline(name, nls);
 			if (use_dialog) {
 				c = *last;
 				*last = '\0';
 				nls = dialog_prompt_nlstate(name);
 				*last = c;
 			}
 			len = dialog_prompt_longestline(last, nls);
 			if ((int)len > (label_size - 3)) {
 				if (label_size > 0)
 					label_size += 3;
 				label_size = len;
 				/* Room for ellipsis (unless NULL) */
 				if (label_size > 0)
 					label_size += 3;
 			}
 
 			if (max_cols > 0 && label_size > (max_cols - pbar_size
 			    - 9))
 				label_size = max_cols - pbar_size - 9;
 		}
 
 		if (debug)
 			warnx("label=[%s] path=[%s] size=%lli",
 			    curfile->name, curfile->path, curfile->length);
 	} /* file_list */
 
 	/* Optionally process the contents of DIALOGRC (~/.dialogrc) */
 	if (use_dialog) {
 		res = parse_dialogrc();
 		if (debug && res == 0) {
 			warnx("Successfully read `%s' config file", DIALOGRC);
 			warnx("use_shadow = %i (Boolean)", use_shadow);
 			warnx("use_colors = %i (Boolean)", use_colors);
 			warnx("gauge_color=[%s] (FBH)", gauge_color);
 		}
 	} else if (use_libdialog) {
 		init_dialog(stdin, stdout);
 		use_shadow = dialog_state.use_shadow;
 		use_colors = dialog_state.use_colors;
 		gauge_color[0] = 48 + dlg_color_table[GAUGE_ATTR].fg;
 		gauge_color[1] = 48 + dlg_color_table[GAUGE_ATTR].bg;
 		gauge_color[2] = dlg_color_table[GAUGE_ATTR].hilite ?
 		    'b' : 'B';
 		gauge_color[3] = '\0';
 		end_dialog();
 		if (debug) {
 			warnx("Finished initializing dialog(3) library");
 			warnx("use_shadow = %i (Boolean)", use_shadow);
 			warnx("use_colors = %i (Boolean)", use_colors);
 			warnx("gauge_color=[%s] (FBH)", gauge_color);
 		}
 	}
 
 	/* Enable mini progress bar automatically for stdin streams if unable
 	 * to calculate progress (missing `lines:' syntax). */
 	if (dpv_nfiles <= 1 && file_list != NULL && file_list->length < 0 &&
 	    !dialog_test)
 		pbar_size = PBAR_SIZE_DEFAULT;
 
 	/* If $USE_COLOR is set and non-NULL enable color; otherwise disable */
 	if ((cp = getenv(ENV_USE_COLOR)) != 0)
 		use_color = *cp != '\0' ? 1 : 0;
 
 	/* Print error and return `-1' if not given at least one name */
 	if (dpv_nfiles == 0) {
 		warnx("%s: no labels provided", __func__);
 		return (-1);
 	} else if (debug)
 		warnx("%s: %u label%s provided", __func__, dpv_nfiles,
 		    dpv_nfiles == 1 ? "" : "s");
 
 	/* If only one file and pbar size is zero, default to `-1' */
 	if (dpv_nfiles <= 1 && pbar_size == 0)
 		pbar_size = -1;
 
 	/* Print some debugging information */
 	if (debug) {
 		warnx("%s: %s(%i) max rows x cols = %i x %i",
 		    __func__, use_xdialog ? XDIALOG : DIALOG,
 		    use_libdialog ? 3 : 1, dialog_maxrows(),
 		    dialog_maxcols());
 	}
 
 	/* Xdialog(1) updates a lot slower than dialog(1) */
 	if (dialog_test && use_xdialog)
 		increment = XDIALOG_INCREMENT;
 
 	/* Always add implicit newline to pprompt (when specified) */
 	if (pprompt != NULL && *pprompt != '\0') {
 		len = strlen(pprompt);
 		/*
 		 * NOTE: pprompt = malloc(PPROMPT_MAX + 2)
 		 * NOTE: (see getopt(2) section above for pprompt allocation)
 		 */
 		pprompt[len++] = '\\';
 		pprompt[len++] = 'n';
 		pprompt[len++] = '\0';
 	}
 
 	/* Xdialog(1) requires newlines (a) escaped and (b) in triplicate */
 	if (use_xdialog && pprompt != NULL) {
 		/* Replace `\n' with `\n\\n\n' in pprompt */
 		len = strlen(pprompt);
 		len += strcount(pprompt, "\\n") * 2;
 		if (len > DPV_PPROMPT_MAX)
 			errx(EXIT_FAILURE, "%s: Oops, pprompt buffer overflow "
 			    "(%zu > %i)", __func__, len, DPV_PPROMPT_MAX);
 		if (replaceall(pprompt, "\\n", "\n\\n\n") < 0)
 			err(EXIT_FAILURE, "%s: replaceall()", __func__);
 	}
 	/* libdialog requires literal newlines */
 	else if (use_libdialog && pprompt != NULL)
 		strexpandnl(pprompt);
 
 	/* Xdialog(1) requires newlines (a) escaped and (b) in triplicate */
 	if (use_xdialog && aprompt != NULL) {
 		/* Replace `\n' with `\n\\n\n' in aprompt */
 		len = strlen(aprompt);
 		len += strcount(aprompt, "\\n") * 2;
 		if (len > DPV_APROMPT_MAX)
 			errx(EXIT_FAILURE, "%s: Oops, aprompt buffer overflow "
 			    " (%zu > %i)", __func__, len, DPV_APROMPT_MAX);
 		if (replaceall(aprompt, "\\n", "\n\\n\n") < 0)
 			err(EXIT_FAILURE, "%s: replaceall()", __func__);
 	}
 	/* libdialog requires literal newlines */
 	else if (use_libdialog && aprompt != NULL)
 		strexpandnl(aprompt);
 
 	/*
 	 * Warn user about an obscure dialog(1) bug (neither Xdialog(1) nor
 	 * libdialog are affected) in the `--gauge' widget. If the first non-
 	 * whitespace letter of "{new_prompt}" in "XXX\n{new_prompt}\nXXX\n"
 	 * is a number, the number can sometimes be mistaken for a percentage
 	 * to the overall progressbar. Other nasty side-effects such as the
 	 * entire prompt not displaying or displaying improperly are caused by
 	 * this bug too.
 	 *
 	 * NOTE: When we can use color, we have a work-around... prefix the
 	 * output with `\Zn' (used to terminate ANSI and reset to normal).
 	 */
 	if (use_dialog && !use_color) {
 		backslash = 0;
 
 		/* First, check pprompt (falls through if NULL) */
 		fc = pprompt;
 		while (fc != NULL && *fc != '\0') {
 			if (*fc == '\n') /* leading literal newline OK */
 				break;
 			if (!isspace(*fc) && *fc != '\\' && backslash == 0)
 				break;
 			else if (backslash > 0 && *fc != 'n')
 				break;
 			else if (*fc == '\\') {
 				backslash++;
 				if (backslash > 2)
 					break; /* we're safe */
 			}
 			fc++;
 		}
 		/* First non-whitespace character that dialog(1) will see */
 		if (fc != NULL && *fc >= '0' && *fc <= '9')
 			warnx("%s: WARNING! text argument to `-p' begins with "
 			    "a number (not recommended)", __func__);
 		else if (fc > pprompt)
 			warnx("%s: WARNING! text argument to `-p' begins with "
 			    "whitespace (not recommended)", __func__);
 
 		/*
 		 * If no pprompt or pprompt is all whitespace, check the first
 		 * file name provided to make sure it is alright too.
 		 */
 		if ((pprompt == NULL || *fc == '\0') && file_list != NULL) {
 			first_file = file_list;
 			fc = first_file->name;
 			while (fc != NULL && *fc != '\0' && isspace(*fc))
 				fc++;
 			/* First non-whitespace char that dialog(1) will see */
 			if (fc != NULL && *fc >= '0' && *fc <= '9')
 				warnx("%s: WARNING! File name `%s' begins "
 				    "with a number (use `-p text' for safety)",
 				    __func__, first_file->name);
 		}
 	}
 
 	dprompt_init(file_list);
 		/* Reads: label_size pbar_size pprompt aprompt dpv_nfiles */
 		/* Inits: dheight and dwidth */
 
 	if (!debug) {
 		/* Internally create the initial `--gauge' prompt text */
 		dprompt_recreate(file_list, (struct dpv_file_node *)NULL, 0);
 
 		/* Spawn [X]dialog(1) `--gauge', returning pipe descriptor */
 		if (use_libdialog) {
 			status_printf("");
 			dprompt_libprint(pprompt, aprompt, 0);
 		} else {
 			dprompt_sprint(init_prompt, pprompt, aprompt);
 			dialog_out = dialog_spawn_gauge(init_prompt, &pid);
 			dprompt_dprint(dialog_out, pprompt, aprompt, 0);
 		}
 	} /* !debug */
 
 	/* Seed the random(3) generator */
 	if (dialog_test)
 		srandom(0xf1eeface);
 
 	/* Set default/custom status line format */
 	if (dpv_nfiles > 1) {
 		snprintf(status_format_default, DPV_STATUS_FORMAT_MAX, "%s",
 		    DPV_STATUS_MANY);
 		status_format_custom = config->status_many;
 	} else {
 		snprintf(status_format_default, DPV_STATUS_FORMAT_MAX, "%s",
 		    DPV_STATUS_SOLO);
 		status_format_custom = config->status_solo;
 	}
 
 	/* Add test mode identifier to default status line if enabled */
 	if (dialog_test && (strlen(status_format_default) + 12) <
 	    DPV_STATUS_FORMAT_MAX)
 		strcat(status_format_default, " [TEST MODE]");
 
 	/* Verify custom status format */
 	status_fmt = fmtcheck(status_format_custom, status_format_default);
 	if (status_format_custom != NULL &&
 	    status_fmt == status_format_default) {
 		warnx("WARNING! Invalid status_format configuration `%s'",
 		      status_format_custom);
 		warnx("Default status_format `%s'", status_format_default);
 	}
 
 	/* Record when we started (used to prevent updating too quickly) */
 	(void)gettimeofday(&start, (struct timezone *)NULL);
 
 	/* Calculate number of microseconds in-between sub-second updates */
 	if (status_updates_per_second != 0)
 		status_update_usec = 1000000 / status_updates_per_second;
 	if (dialog_updates_per_second != 0)
 		dialog_update_usec = 1000000 / dialog_updates_per_second;
 
 	/*
 	 * Process the file list [serially] (one for each argument passed)
 	 */
 	files_left = dpv_nfiles;
 	list_head = file_list;
 	for (curfile = file_list; curfile != NULL; curfile = curfile->next) {
 		keep_going = TRUE;
 		output_out = -1;
 		pct = 0;
 		nthfile++;
 		files_left--;
 
 		if (dpv_interrupt)
 			break;
 		if (dialog_test)
 			pct = 0 - increment;
 
 		/* Attempt to spawn output program for this file */
 		if (!dialog_test && output != NULL) {
 			mask = umask(0022);
 			(void)umask(mask);
 
 			switch (output_type) {
 			case DPV_OUTPUT_SHELL:
 				output_out = shell_spawn_pipecmd(output,
 				    curfile->name, &output_pid);
 				break;
 			case DPV_OUTPUT_FILE:
 				path_fmt = fmtcheck(output, "%s");
 				if (path_fmt == output)
 					len = snprintf(pathbuf,
 					    PATH_MAX, output, curfile->name);
 				else
 					len = snprintf(pathbuf,
 					    PATH_MAX, "%s", output);
 				if (len >= PATH_MAX) {
 					warnx("%s:%d:%s: pathbuf[%u] too small"
 					    "to hold output argument",
 					    __FILE__, __LINE__, __func__,
 					    PATH_MAX);
 					return (-1);
 				}
 				if ((output_out = open(pathbuf,
 				    O_CREAT|O_WRONLY, DEFFILEMODE & ~mask))
 				    < 0) {
 					warn("%s", pathbuf);
 					return (-1);
 				}
 				break;
 			default:
 				break;
 			}
 		}
 
 		while (!dpv_interrupt && keep_going) {
 			if (dialog_test) {
 				usleep(50000);
 				pct += increment;
 				dpv_overall_read +=
 				    (int)(random() / 512 / dpv_nfiles);
 				    /* 512 limits fake readout to Megabytes */
 			} else if (action != NULL)
 				pct = action(curfile, output_out);
 
 			if (no_overrun || dialog_test)
 				keep_going = (pct < 100);
 			else {
 				status = curfile->status;
 				keep_going = (status == DPV_STATUS_RUNNING);
 			}
 
 			/* Get current time and calculate seconds elapsed */
 			gettimeofday(&now, (struct timezone *)NULL);
 			now.tv_sec = now.tv_sec - start.tv_sec;
 			now.tv_usec = now.tv_usec - start.tv_usec;
 			if (now.tv_usec < 0)
 				now.tv_sec--, now.tv_usec += 1000000;
 			seconds = now.tv_sec + (now.tv_usec / 1000000.0);
 
 			/* Update dialog (be it dialog(3), dialog(1), etc.) */
 			if ((dialog_updates_per_second != 0 &&
 			   (
 			    seconds != dialog_old_seconds ||
 			    now.tv_usec - dialog_last_update >=
 			        dialog_update_usec ||
 			    nthfile != dialog_old_nthfile
 			   )) || pct == 100
 			) {
 				/* Calculate overall progress (rounding up) */
 				overall = (100 * nthfile - 100 + pct) /
 				    dpv_nfiles;
 				if (((100 * nthfile - 100 + pct) * 10 /
 				    dpv_nfiles % 100) > 50)
 					overall++;
 
 				dprompt_recreate(list_head, curfile, pct);
 
 				if (use_libdialog && !debug) {
 					/* Update dialog(3) widget */
 					dprompt_libprint(pprompt, aprompt,
 					    overall);
 				} else {
 					/* stdout, dialog(1), or Xdialog(1) */
 					dprompt_dprint(dialog_out, pprompt,
 					    aprompt, overall);
 					fsync(dialog_out);
 				}
 				dialog_old_seconds = seconds;
 				dialog_old_nthfile = nthfile;
 				dialog_last_update = now.tv_usec;
 			}
 
 			/* Update the status line */
 			if ((use_libdialog && !debug) &&
 			    status_updates_per_second != 0 &&
 			   (
 			    keep_going != TRUE ||
 			    seconds != status_old_seconds ||
 			    now.tv_usec - status_last_update >=
 			        status_update_usec ||
 			    nthfile != status_old_nthfile
 			   )
 			) {
 				status_printf(status_fmt, dpv_overall_read,
 				    (dpv_overall_read / (seconds == 0 ? 1 :
 					seconds) * 1.0),
 				    1, /* XXX until we add parallelism XXX */
 				    files_left);
 				status_old_seconds = seconds;
 				status_old_nthfile = nthfile;
 				status_last_update = now.tv_usec;
 			}
 		}
 
 		if (!dialog_test && output_out >= 0) {
 			close(output_out);
 			waitpid(output_pid, (int *)NULL, 0);	
 		}
 
 		if (dpv_abort)
 			break;
 
 		/* Advance head of list when we hit the max display lines */
 		if (display_limit > 0 && nthfile % display_limit == 0)
 			list_head = curfile->next;
 	}
 
 	if (!debug) {
 		if (use_libdialog)
 			end_dialog();
 		else {
 			close(dialog_out);
 			waitpid(pid, (int *)NULL, 0);	
 		}
 		if (!dpv_interrupt)
 			printf("\n");
 	} else
 		warnx("%s: %lli lines read", __func__, dpv_overall_read);
 
 	if (dpv_interrupt || dpv_abort)
 		return (-1);
 	else
 		return (0);
 }
 
 /*
  * Free allocated items initialized by dpv()
  */
 void
 dpv_free(void)
 {
 	dialogrc_free();
 	dprompt_free();
 	dialog_maxsize_free();
 	if (aprompt != NULL) {
 		free(aprompt);
 		aprompt = NULL;
 	}
 	if (pprompt != NULL) {
 		free(pprompt);
 		pprompt = NULL;
 	}
 	status_free();
 }
Index: stable/9/lib/libdpv
===================================================================
--- stable/9/lib/libdpv	(revision 275050)
+++ stable/9/lib/libdpv	(revision 275051)

Property changes on: stable/9/lib/libdpv
___________________________________________________________________
Added: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/lib/libdpv:r274120-274121,274123,274146
Index: stable/9/usr.bin/dpv/Makefile
===================================================================
--- stable/9/usr.bin/dpv/Makefile	(revision 275050)
+++ stable/9/usr.bin/dpv/Makefile	(revision 275051)
@@ -1,12 +1,12 @@
 # $FreeBSD$
 
 PROG=		dpv
 
 CFLAGS+=	-I${.CURDIR}
 
-DPADD+=		${LIBDPV} ${LIBDIALOG} ${LIBFIGPAR} ${LIBNCURSES} ${LIBUTIL}
-LDADD+=		-ldpv -ldialog -lfigpar -lncurses -lutil
+DPADD=		${LIBDPV} ${LIBDIALOG} ${LIBFIGPAR} ${LIBNCURSESW} ${LIBUTIL} ${LIBM}
+LDADD=		-ldpv -ldialog -lfigpar -lncursesw -lutil -lm
 
 WARNS?=		6
 
 .include <bsd.prog.mk>
Index: stable/9/usr.bin/dpv/dpv.c
===================================================================
--- stable/9/usr.bin/dpv/dpv.c	(revision 275050)
+++ stable/9/usr.bin/dpv/dpv.c	(revision 275051)
@@ -1,541 +1,541 @@
 /*-
  * Copyright (c) 2013-2014 Devin Teske <dteske@FreeBSD.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #define _BSD_SOURCE /* to get dprintf() prototype in stdio.h below */
 #include <dialog.h>
 #include <dpv.h>
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <string_m.h>
 #include <unistd.h>
 
 #include "dpv_util.h"
 
 /* Debugging */
 static uint8_t debug = FALSE;
 
 /* Data to process */
 static struct dpv_file_node *file_list = NULL;
 static unsigned int nfiles = 0;
 
 /* Data processing */
 static uint8_t line_mode = FALSE;
 static uint8_t no_overrun = FALSE;
 static char *buf = NULL;
 static int fd = -1;
 static int output_type = DPV_OUTPUT_NONE;
 static size_t bsize;
 static char rpath[PATH_MAX];
 
 /* Extra display information */
 static uint8_t multiple = FALSE; /* `-m' */
 static char *pgm; /* set to argv[0] by main() */
 
 /* Function prototypes */
 static void	sig_int(int sig);
 static void	usage(void);
 int		main(int argc, char *argv[]);
 static int	operate_common(struct dpv_file_node *file, int out);
 static int	operate_on_bytes(struct dpv_file_node *file, int out);
 static int	operate_on_lines(struct dpv_file_node *file, int out);
 
 static int
 operate_common(struct dpv_file_node *file, int out)
 {
 	struct stat sb;
 
 	/* Open the file if necessary */
 	if (fd < 0) {
 		if (multiple) {
 			/* Resolve the file path and attempt to open it */
 			if (realpath(file->path, rpath) == 0 ||
 			    (fd = open(rpath, O_RDONLY)) < 0) {
 				warn("%s", file->path);
 				file->status = DPV_STATUS_FAILED;
 				return (-1);
 			}
 		} else {
 			/* Assume stdin, but if that's a TTY instead use the
 			 * highest numbered file descriptor (obtained by
 			 * generating new fd and then decrementing).
 			 *
 			 * NB: /dev/stdin should always be open(2)'able
 			 */
 			fd = STDIN_FILENO;
 			if (isatty(fd)) {
 				fd = open("/dev/stdin", O_RDONLY);
 				close(fd--);
 			}
 
 			/* This answer might be wrong, if dpv(3) has (by
 			 * request) opened an output file or pipe. If we
 			 * told dpv(3) to open a file, subtract one from
 			 * previous answer. If instead we told dpv(3) to
 			 * prepare a pipe output, subtract two.
 			 */
 			switch(output_type) {
 			case DPV_OUTPUT_FILE:
 				fd -= 1;
 				break;
 			case DPV_OUTPUT_SHELL:
 				fd -= 2;
 				break;
 			}
 		}
 	}
 
 	/* Allocate buffer if necessary */
 	if (buf == NULL) {
 		/* Use output block size as buffer size if available */
 		if (out >= 0) {
 			if (fstat(out, &sb) != 0) {
 				warn("%i", out);
 				file->status = DPV_STATUS_FAILED;
 				return (-1);
 			}
 			if (S_ISREG(sb.st_mode)) {
 				if (sysconf(_SC_PHYS_PAGES) >
 				    PHYSPAGES_THRESHOLD)
 					bsize = MIN(BUFSIZE_MAX, MAXPHYS * 8);
 				else
 					bsize = BUFSIZE_SMALL;
 			} else
 				bsize = MAX(sb.st_blksize,
 				    (blksize_t)sysconf(_SC_PAGESIZE));
 		} else
 			bsize = MIN(BUFSIZE_MAX, MAXPHYS * 8);
 
 		/* Attempt to allocate */
 		if ((buf = malloc(bsize+1)) == NULL) {
 			end_dialog();
 			err(EXIT_FAILURE, "Out of memory?!");
 		}
 	}
 
 	return (0);
 }
 
 static int
 operate_on_bytes(struct dpv_file_node *file, int out)
 {
 	int progress;
 	ssize_t r, w;
 
 	if (operate_common(file, out) < 0)
 		return (-1);
 
 	/* [Re-]Fill the buffer */
 	if ((r = read(fd, buf, bsize)) <= 0) {
 		if (fd != STDIN_FILENO)
 			close(fd);
 		fd = -1;
 		file->status = DPV_STATUS_DONE;
 		return (100);
 	}
 
 	/* [Re-]Dump the buffer */
 	if (out >= 0) {
 		if ((w = write(out, buf, r)) < 0) {
 			end_dialog();
 			err(EXIT_FAILURE, "output");
 		}
 		fsync(out);
 	}
 
-	overall_read += r;
+	dpv_overall_read += r;
 	file->read += r;
 
 	/* Calculate percentage of completion (if possible) */
 	if (file->length >= 0) {
 		progress = (file->read * 100 / (file->length > 0 ?
 		    file->length : 1));
 
 		/* If no_overrun, do not return 100% until read >= length */
 		if (no_overrun && progress == 100 && file->read < file->length)
 			progress--;
 			
 		return (progress);
 	} else
 		return (-1);
 }
 
 static int
 operate_on_lines(struct dpv_file_node *file, int out)
 {
 	char *p;
 	int progress;
 	ssize_t r, w;
 
 	if (operate_common(file, out) < 0)
 		return (-1);
 
 	/* [Re-]Fill the buffer */
 	if ((r = read(fd, buf, bsize)) <= 0) {
 		if (fd != STDIN_FILENO)
 			close(fd);
 		fd = -1;
 		file->status = DPV_STATUS_DONE;
 		return (100);
 	}
 	buf[r] = '\0';
 
 	/* [Re-]Dump the buffer */
 	if (out >= 0) {
 		if ((w = write(out, buf, r)) < 0) {
 			end_dialog();
 			err(EXIT_FAILURE, "output");
 		}
 		fsync(out);
 	}
 
 	/* Process the buffer for number of lines */
 	for (p = buf; p != NULL && *p != '\0';)
 		if ((p = strchr(p, '\n')) != NULL)
-			overall_read++, p++, file->read++;
+			dpv_overall_read++, p++, file->read++;
 
 	/* Calculate percentage of completion (if possible) */
 	if (file->length >= 0) {
 		progress = (file->read * 100 / file->length);
 
 		/* If no_overrun, do not return 100% until read >= length */
 		if (no_overrun && progress == 100 && file->read < file->length)
 			progress--;
 			
 		return (progress);
 	} else
 		return (-1);
 }
 
 /*
  * Takes a list of names that are to correspond to input streams coming from
  * stdin or fifos and produces necessary config to drive dpv(3) `--gauge'
  * widget. If the `-d' flag is used, output is instead send to terminal
  * standard output (and the output can then be saved to a file, piped into
  * custom [X]dialog(1) invocation, or whatever.
  */
 int
 main(int argc, char *argv[])
 {
 	char dummy;
 	int ch;
 	int n = 0;
 	size_t config_size = sizeof(struct dpv_config);
 	size_t file_node_size = sizeof(struct dpv_file_node);
 	struct dpv_config *config;
 	struct dpv_file_node *curfile;
 	struct sigaction act;
 
 	pgm = argv[0]; /* store a copy of invocation name */
 
 	/* Allocate config structure */
 	if ((config = malloc(config_size)) == NULL)
 		errx(EXIT_FAILURE, "Out of memory?!");
 	memset((void *)(config), '\0', config_size);
 
 	/*
 	 * Process command-line options
 	 */
 	while ((ch = getopt(argc, argv,
 	    "a:b:dDhi:I:lL:mn:No:p:P:t:TU:wx:X")) != -1) {
 		switch(ch) {
 		case 'a': /* additional message text to append */
 			if (config->aprompt == NULL) {
 				config->aprompt = malloc(DPV_APROMPT_MAX);
 				if (config->aprompt == NULL)
 					errx(EXIT_FAILURE, "Out of memory?!");
 			}
 			snprintf(config->aprompt, DPV_APROMPT_MAX, "%s",
 			    optarg);
 			break;
 		case 'b': /* [X]dialog(1) backtitle */
 			if (config->backtitle != NULL)
 				free((char *)config->backtitle);
 			config->backtitle = malloc(strlen(optarg) + 1);
 			if (config->backtitle == NULL)
 				errx(EXIT_FAILURE, "Out of memory?!");
 			*(config->backtitle) = '\0';
 			strcat(config->backtitle, optarg);
 			break;
 		case 'd': /* debugging */
 			debug = TRUE;
 			config->debug = debug;
 			break;
 		case 'D': /* use dialog(1) instead of libdialog */
 			config->display_type = DPV_DISPLAY_DIALOG;
 			break;
 		case 'h': /* help/usage */
 			usage();
 			break; /* NOTREACHED */
 		case 'i': /* status line format string for single-file */
 			config->status_solo = optarg;
 			break;
 		case 'I': /* status line format string for many-files */
 			config->status_many = optarg;
 			break;
 		case 'l': /* Line mode */
 			line_mode = TRUE;
 			break;
 		case 'L': /* custom label size */
 			config->label_size =
 			    (int)strtol(optarg, (char **)NULL, 10);
 			if (config->label_size == 0 && errno == EINVAL)
 				errx(EXIT_FAILURE,
 				    "`-L' argument must be numeric");
 			else if (config->label_size < -1)
 				config->label_size = -1;
 			break;
 		case 'm': /* enable multiple file arguments */
 			multiple = TRUE;
 			break;
 		case 'o': /* `-o path' for sending data-read to file */
 			output_type = DPV_OUTPUT_FILE;
 			config->output_type = DPV_OUTPUT_FILE;
 			config->output = optarg;
 			break;
 		case 'n': /* custom number of files per `page' */
 			config->display_limit =
 				(int)strtol(optarg, (char **)NULL, 10);
 			if (config->display_limit == 0 && errno == EINVAL)
 				errx(EXIT_FAILURE,
 				    "`-n' argument must be numeric");
 			else if (config->display_limit < 0)
 				config->display_limit = -1;
 			break;
 		case 'N': /* No overrun (truncate reads of known-length) */
 			no_overrun = TRUE;
 			config->options |= DPV_NO_OVERRUN;
 			break;
 		case 'p': /* additional message text to use as prefix */
 			if (config->pprompt == NULL) {
 				config->pprompt = malloc(DPV_PPROMPT_MAX + 2);
 				if (config->pprompt == NULL)
 					errx(EXIT_FAILURE, "Out of memory?!");
 				/* +2 is for implicit "\n" appended later */
 			}
 			snprintf(config->pprompt, DPV_PPROMPT_MAX, "%s",
 			    optarg);
 			break;
 		case 'P': /* custom size for mini-progressbar */
 			config->pbar_size =
 			    (int)strtol(optarg, (char **)NULL, 10);
 			if (config->pbar_size == 0 && errno == EINVAL)
 				errx(EXIT_FAILURE,
 				    "`-P' argument must be numeric");
 			else if (config->pbar_size < -1)
 				config->pbar_size = -1;
 			break;
 		case 't': /* [X]dialog(1) title */
 			if (config->title != NULL)
 				free(config->title);
 			config->title = malloc(strlen(optarg) + 1);
 			if (config->title == NULL)
 				errx(EXIT_FAILURE, "Out of memory?!");
 			*(config->title) = '\0';
 			strcat(config->title, optarg);
 			break;
 		case 'T': /* test mode (don't read data, fake it) */
 			config->options |= DPV_TEST_MODE;
 			break;
 		case 'U': /* updates per second */
 			config->status_updates_per_second =
 			    (int)strtol(optarg, (char **)NULL, 10);
 			if (config->status_updates_per_second == 0 &&
 			    errno == EINVAL)
 				errx(EXIT_FAILURE,
 				    "`-U' argument must be numeric");
 			break;
 		case 'w': /* `-p' and `-a' widths bump [X]dialog(1) width */
 			config->options |= DPV_WIDE_MODE;
 			break;
 		case 'x': /* `-x cmd' for sending data-read to sh(1) code */
 			output_type = DPV_OUTPUT_SHELL;
 			config->output_type = DPV_OUTPUT_SHELL;
 			config->output = optarg;
 			break;
 		case 'X': /* X11 support through x11/xdialog */
 			config->display_type = DPV_DISPLAY_XDIALOG;
 			break;
 		case '?': /* unknown argument (based on optstring) */
 			/* FALLTHROUGH */
 		default: /* unhandled argument (based on switch) */
 			usage();
 			/* NOTREACHED */
 		}
 	}
 	argc -= optind;
 	argv += optind;
 
 	/* Process remaining arguments as list of names to display */
 	for (curfile = file_list; n < argc; n++) {
 		nfiles++;
 
 		/* Allocate a new struct for the file argument */
 		if (curfile == NULL) {
 			if ((curfile = malloc(file_node_size)) == NULL)
 				errx(EXIT_FAILURE, "Out of memory?!");
 			memset((void *)(curfile), '\0', file_node_size);
 			file_list = curfile;
 		} else {
 			if ((curfile->next = malloc(file_node_size)) == NULL)
 				errx(EXIT_FAILURE, "Out of memory?!");
 			memset((void *)(curfile->next), '\0', file_node_size);
 			curfile = curfile->next;
 		}
 		curfile->name = argv[n];
 
 		/* Read possible `lines:' prefix from label syntax */
 		if (sscanf(curfile->name, "%lli:%c", &(curfile->length),
 		    &dummy) == 2)
 			curfile->name = strchr(curfile->name, ':') + 1;
 		else
 			curfile->length = -1;
 
 		/* Read path argument if enabled */
 		if (multiple) {
 			if (++n >= argc)
 				errx(EXIT_FAILURE, "Missing path argument "
 				    "for label number %i", nfiles);
 			curfile->path = argv[n];
 		} else
 			break;
 	}
 
 	/* Display usage and exit if not given at least one name */
 	if (nfiles == 0) {
 		warnx("no labels provided");
 		usage();
 		/* NOTREACHED */
 	}
 
 	/*
 	 * Set cleanup routine for Ctrl-C action
 	 */
 	if (config->display_type == DPV_DISPLAY_LIBDIALOG) {
 		act.sa_handler = sig_int;
 		sigaction(SIGINT, &act, 0);
 	}
 
 	/* Set status formats and action */
 	if (line_mode) {
 		config->status_solo = LINE_STATUS_SOLO;
 		config->status_many = LINE_STATUS_SOLO;
 		config->action = operate_on_lines;
 	} else {
 		config->status_solo = BYTE_STATUS_SOLO;
 		config->status_many = BYTE_STATUS_SOLO;
 		config->action = operate_on_bytes;
 	}
 
 	/*
 	 * Hand off to dpv(3)...
 	 */
 	if (dpv(config, file_list) != 0 && debug)
 		warnx("dpv(3) returned error!?");
 
 	end_dialog();
 	dpv_free();
 
 	exit(EXIT_SUCCESS);
 }
 
 /*
  * Interrupt handler to indicate we received a Ctrl-C interrupt.
  */
 static void
 sig_int(int sig __unused)
 {
 	dpv_interrupt = TRUE;
 }
 
 /*
  * Print short usage statement to stderr and exit with error status.
  */
 static void
 usage(void)
 {
 
 	if (debug) /* No need for usage */
 		exit(EXIT_FAILURE);
 
 	fprintf(stderr, "Usage: %s [options] bytes:label\n", pgm);
 	fprintf(stderr, "       %s [options] -m bytes1:label1 path1 "
 	    "[bytes2:label2 path2 ...]\n", pgm);
 	fprintf(stderr, "OPTIONS:\n");
 #define OPTFMT "\t%-14s %s\n"
 	fprintf(stderr, OPTFMT, "-a text",
 	    "Append text. Displayed below file progress indicators.");
 	fprintf(stderr, OPTFMT, "-b backtitle",
 	    "String to be displayed on the backdrop, at top-left.");
 	fprintf(stderr, OPTFMT, "-d",
 	    "Debug. Write to standard output instead of dialog.");
 	fprintf(stderr, OPTFMT, "-D",
 	    "Use dialog(1) instead of dialog(3) [default].");
 	fprintf(stderr, OPTFMT, "-h",
 	    "Produce this output on standard error and exit.");
 	fprintf(stderr, OPTFMT, "-i format",
 	    "Customize status line format. See fdpv(1) for details.");
 	fprintf(stderr, OPTFMT, "-I format",
 	    "Customize status line format. See fdpv(1) for details.");
 	fprintf(stderr, OPTFMT, "-L size",
 	    "Label size. Must be a number greater than 0, or -1.");
 	fprintf(stderr, OPTFMT, "-m",
 	    "Enable processing of multiple file argiments.");
 	fprintf(stderr, OPTFMT, "-n num",
 	    "Display at-most num files per screen. Default is -1.");
 	fprintf(stderr, OPTFMT, "-N",
 	    "No overrun. Stop reading input at stated length, if any.");
 	fprintf(stderr, OPTFMT, "-o file",
 	    "Output data to file. First %s replaced with label text.");
 	fprintf(stderr, OPTFMT, "-p text",
 	    "Prefix text. Displayed above file progress indicators.");
 	fprintf(stderr, OPTFMT, "-P size",
 	    "Mini-progressbar size. Must be a number greater than 3.");
 	fprintf(stderr, OPTFMT, "-t title",
 	    "Title string to be displayed at top of dialog(1) box.");
 	fprintf(stderr, OPTFMT, "-T",
 	    "Test mode. Don't actually read any data, but fake it.");
 	fprintf(stderr, OPTFMT, "-U num",
 	    "Update status line num times per-second. Default is 2.");
 	fprintf(stderr, OPTFMT, "-w",
 	    "Wide. Width of `-p' and `-a' text bump dialog(1) width.");
 	fprintf(stderr, OPTFMT, "-x cmd",
 	    "Send data to executed cmd. First %s replaced with label.");
 	fprintf(stderr, OPTFMT, "-X",
 	    "X11. Use Xdialog(1) instead of dialog(1).");
 	exit(EXIT_FAILURE);
 }
Index: stable/9/usr.bin/dpv
===================================================================
--- stable/9/usr.bin/dpv	(revision 275050)
+++ stable/9/usr.bin/dpv	(revision 275051)

Property changes on: stable/9/usr.bin/dpv
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/usr.bin/dpv:r274120,274123,274146,274851
Index: stable/9
===================================================================
--- stable/9	(revision 275050)
+++ stable/9	(revision 275051)

Property changes on: stable/9
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head:r274203,274209,274270