 @@ -1,1075 +1,1071 @@
 #! /bin/sh
+#
-# $NetBSD: regpkg,v 1.17 2009/10/17 23:43:22 agc Exp $
+# $NetBSD: regpkg,v 1.18 2009/12/01 15:49:21 apb Exp $
+#
 # Copyright (c) 2003,2009 The NetBSD Foundation, Inc.
 # All rights reserved.
+#
 # This code is derived from software contributed to The NetBSD Foundation
 # by Alistair Crooks (agc@NetBSD.org)
+#
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 # 1. Redistributions of source code must retain the above copyright
 #    notice, this list of conditions and the following disclaimer.
 # 2. Redistributions in binary form must reproduce the above copyright
 #    notice, this list of conditions and the following disclaimer in the
 #    documentation and/or other materials provided with the distribution.
+#
 # THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 # ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 # PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 # BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
+#
 # Usage: regpkg [options] set pkgname
+#
 # Registers a syspkg in the database directory,
 # and optionally creates a binary package.
+#
 # Options:
 #   -q		Quiet.
 #   -v		Verbose.
 #   -f		Force.
 #   -m		Ignore errors from missing files.
 #   -u		Update.
 #   -c		Use cached information from ${BUILD_INFO_CACHE}.
 #   -d destdir	Sets DESTDIR.
 #   -t binpkgdir Create a binary package (in *.tgz format) in the
 #		specified directory.  Without this option, a binary
 #		package is not created.
 #   -M metalog	Use the specified metalog file to override file
 #		or directory attributes when creating a binary package.
 #   -N etcdir	Use the specified directory for passwd and group files.
+#
 # When -f is set:  If the desired syspkg already exists, it is overwritten.
 # When -u is set:  If the desired syspkg already exists, it might be
 #		overwritten or left alone, depending on whether it's older
 #		or newer than the files that belong to the syspkg.
 # When neither -u nor -f are set:  It's an error for the desired syspkg
 #		to already exist.
 prog="${0##*/}"
 toppid=$$
 rundir="$(dirname "$0")" # ${0%/*} isn't good enough when there's no "/"
 . "${rundir}/sets.subr"
 bomb()
+{
 	#echo "${prog}: bomb: start, toppid=${toppid} \$\$=$$"
 	kill ${toppid}		# in case we were invoked from a subshell
 	#echo "${prog}: bomb: killed ${toppid}"
 	exit 1
+}
 # A literal newline
 nl='
+'
 # A literal tab
 tab='	'
 # Prefixes for error messages, warnings, and important informational
 # messages.
 ERROR="${prog}: ERROR: "
 WARNING="${prog}: WARNING: "
 NOTE="${prog}: NOTE: "
 ERRWARN="${ERROR}"	# may be changed by "-f" (force) command line flag
 ERRWARNNOTE="${ERROR}"	# may be changed by "-u" (update) command line flag
+#
 # All temporary files will go in ${SCRATCH}, which will be deleted on
 # exit.
+#
 SCRATCH="$(${MKTEMP} -d "/var/tmp/${0##*/}.XXXXXX")"
 if [ $? -ne 0 -o \! -d "${SCRATCH}" ]; then
 	echo >&2 "${prog}: Could not create scratch directory."
 	bomb
 fi
+#
 # cleanup() always deletes the SCRATCH directory, and might also
 # delete other files or directories.
+#
 es=0
 cleanup_must_delete_binpkgfile=false
 cleanup_must_delete_dbsubdir=false
 cleanup()
+{
 	trap - 0
 	#echo "${prog}: cleanup start"
 	if ${cleanup_must_delete_binpkgfile:-false} && [ -e "${binpkgfile}" ]
 	then
 		echo >&2 "${prog}: deleting partially-created ${binpkgfile}"
 		rm -f "${binpkgfile}"
 	fi
 	if ${cleanup_must_delete_dbsubdir:-false} \
 	   && [ -e "${SYSPKG_DB_SUBDIR}" ]
 	then
 		echo >&2 "${prog}: deleting partially-created ${SYSPKG_DB_SUBDIR}"
 		rm -rf "${SYSPKG_DB_SUBDIR}"
 	fi
 	rm -rf "${SCRATCH}"
 	#echo "${prog}: cleanup done, exit ${es}"
 	exit ${es}
+}
 trap 'es=128; cleanup' 1 2 3 13 15	# HUP INT QUIT PIPE TERM
 trap 'es=$?; cleanup' 0 		# EXIT
+#
 # Parse command line args.
+#
 verbose=false
 verbosity=0
 quiet=false
 force=false
 update=false
 allowmissing=false
 DESTDIR="${DESTDIR}"
 binpkgdir=""
 metalog=""
 etcdir=""
 SYSPKG_DB_TOPDIR=""
 pkgset=""
 pkg=""
 parse_args()
+{
 	while [ $# -gt 2 ]; do
 		case "$1" in
 		-q)	quiet=true; verbose=false ;;
 		-v)	verbose=true; quiet=false
 			verbosity=$(( ${verbosity} + 1 ))
 			;;
 		-f)	force=true ;;
 		-u)	update=true ;;
 		-m)	allowmissing=true ;;
 		-c)	# The -c option is ignored.  The BUILD_INFO_CACHE
 			# environment variable is used instead.
 			;;
 		-d)	DESTDIR="$2"; shift ;;
 		-d*)	DESTDIR="${1#-?}" ;;
 		-t)	binpkgdir="$2"; shift ;;
 		-t*)	binpkgdir="${1#-?}" ;;
 		-M)	metalog="$2"; shift ;;
 		-M*)	metalog="${1#-?}" ;;
 		-N)	etcdir="$2"; shift ;;
 		-N*)	etcdir="${1#-?}" ;;
 		*)	break ;;
 		esac
 		shift
 	done
 	if ${force}; then
 		ERRWARN="${WARNING}"
 	else
 		ERRWARN="${ERROR}"
 	fi
 	if ${update}; then
 		ERRWARNNOTE="${NOTE}"
 	else
 		ERRWARNNOTE="${ERRWARN}"
 	fi
 	DESTDIR="${DESTDIR%/}" # delete trailing "/" if any
 	if [ \! -n "${etcdir}" ]; then
 		etcdir="${DESTDIR}/etc"
 	fi
 	if [ -n "${binpkgdir}" -a \! -d "${binpkgdir}" ]; then
 		echo >&2 "${ERROR}binary pkg directory ${binpkgdir} does not exist"
 		bomb
 	fi
+	#
 	# SYSPKG_DB_TOPDIR is the top level directory for registering
 	# syspkgs.  It defaults to ${DESTDIR}/var/db/syspkg, but can be
 	# overridden by environment variables SYSPKG_DBDIR or PKG_DBDIR.
+	#
 	# Note that this corresponds to the default value of PKG_DBDIR
 	# set in .../distrib/syspkg/mk/bsd.syspkg.mk.
+	#
 	SYSPKG_DB_TOPDIR="${SYSPKG_DBDIR:-${PKG_DBDIR:-${DESTDIR}/var/db/syspkg}}"
 	if [ $# -ne 2 ]; then
 		echo "Usage: regpkg [options] set pkgname"
 		bomb
 	fi
 	pkgset="$1"
 	pkg="$2"
+}
+#
 # make_PLIST() creates a skeleton PLIST from the pkgset description.
+#
 # The result is stored in the file ${PLIST}.
+#
 PLIST="${SCRATCH}/PLIST"
 make_PLIST()
+{
 	if ${verbose}; then
 		echo "Making PLIST for \"${pkg}\" package (part of ${pkgset} set)"
 	fi
 	prefix="${DESTDIR:-/}"
 	realprefix=/
 	${HOST_SH} "${rundir}/makeplist" -p "${prefix}" -I "${realprefix}" \
 		"${pkgset}" "${pkg}" \
 		>"${PLIST}" 2>"${SCRATCH}/makeplist-errors"
 	if ${EGREP} -v '^DEBUG:' "${SCRATCH}/makeplist-errors"; then
 		# "find" invoked from makeplist sometimes reports
 		# errors about missing files or directories, and
 		# makeplist ignores the errors.  Catch them here.
 		echo >&2 "${ERROR}makeplist reported errors for ${pkg}:"
 		cat >&2 "${SCRATCH}/makeplist-errors"
 		echo >&2 "${ERROR}see above for errors from makeplist"
 		if ${allowmissing}; then
 			echo >&2 "${prog}: ${NOTE}: ignoring above errors, due to '-m' option."
 		else
 			${force} || bomb
 		fi
 	fi
+}
+#
 # init_allfiles() converts the PLIST (which contains relative filenames)
 # into a list of absolute filenames.  Directories are excluded from the
 # result.
+#
 # The result is stored in the variable ${allfiles}.
+#
 allfiles=''
 init_allfiles()
+{
 	[ -f "${PLIST}" ] || make_PLIST
 	allfiles="$(${AWK} '
 		BEGIN { destdir = "'"${DESTDIR%/}"'" }
 		/^@cwd/ { prefix = $2; next }
 		/^@dirrm/ { next }
 		{ printf("%s%s%s\n", destdir, prefix, $0) }' "${PLIST}")"
+}
+#
 # init_newestfile() finds the newest file (most recent mtime).
+#
 # The result is stored in the variable ${newestfile}.
+#
 newestfile=''
 init_newestfile()
+{
 	[ -s "${allfiles}" ] || init_allfiles
 	# We assume no shell special characters in ${allfiles},
 	# and spaces only between file names, not inside file names.
 	# This should be safe, because it has no no user-specified parts.
 	newestfile="$(${LS} -1dt ${allfiles} | ${SED} '1q')"
+}
+#
 # Various ways of getting parts of the syspkg version number:
+#
 # get_osvers() - get the OS version number from osrelease.sh or $(uname -r),
 #		return it in ${osvers}, and set ${method}.
 # get_tinyvers() - get the tiny version number from the "versions" file,
 #		and return it in ${tinyvers}.  Does not set ${method}.
 # get_newest_rcsid_date() - get the newest RCS date,
 #		and return it in ${newest}.  Does not set ${method}.
 # get_newest_mtime_date() - get the newest file modification date,
 #		and return it in ${newest}.  Does not set ${method}.
 # get_newest_date() - get date from rcsid or mtime, return it in ${newest},
 #		and set ${method}.
+#
 get_osvers()
+{
 	if [ -f ../../sys/conf/osrelease.sh ]; then
 		osvers="$(${HOST_SH} ../../sys/conf/osrelease.sh)"
 		method=osreleases
 	else
 		osvers="$(${UNAME} -r)"
 		method=uname
 	fi
 	#echo "${osvers}"
+}
 get_tinyvers()
+{
 	tinyvers="$(${AWK} '$1 ~ '/"${pkg}"/' { print $2 }' \
 			"${rundir}/versions")"
 	case "${tinyvers}" in
 	"")	tinyvers=0
 		;;
 	esac
 	#echo "${tinyvers}"
+}
 get_newest_rcsid_date()
+{
 	[ -s "${allfiles}" ] || init_allfiles
 	# Old RCS identifiers might have 2-digit years, so we match both
 	# YY/MM/DD and YYYY/MM/DD.  We also try to deal with the Y10K
 	# problem by allowing >4 digit years.
 	newest=0
 	case "${allfiles}" in
 	"")	;;
 	*)	newest="$(${IDENT} ${allfiles} 2>/dev/null | ${AWK} '
 			BEGIN { last = 0 }
 			$2 == "crt0.c,v" { next }
 			NF == 8 && \
 			$4 ~ /^[0-9][0-9]\/[0-9][0-9]\/[0-9][0-9]$/ \
 				{ t = "19" $4; gsub("/", "", t);
 				  if (t > last) last = t; }
 			NF == 8 && \
 			$4 ~ /^[0-9][0-9][0-9][0-9][0-9]*\/[0-9][0-9]\/[0-9][0-9]$/ \
 				{ t = $4; gsub("/", "", t);
 				  if (t > last) last = t; }
 			END { print last }')"
 		method=ident
 		;;
 	esac
 	#echo "${newest}"
+}
 get_newest_mtime_date()
+{
 	[ -s "${newestfile}" ] || init_newestfile
 	# We could simplify the awk program to take advantage of the
 	# fact thet it should have exactly one line of input.
 	newest="$(${ENV_CMD} TZ=UTC LOCALE=C ${LS} -lT "${newestfile}" \
 		| ${AWK} '
 		BEGIN { newest = 0 }
+		{
 			t = $9 "";
 			if ($6 == "Jan") t = t "01";
 			if ($6 == "Feb") t = t "02";
 			if ($6 == "Mar") t = t "03";
 			if ($6 == "Apr") t = t "04";
 			if ($6 == "May") t = t "05";
 			if ($6 == "Jun") t = t "06";
 			if ($6 == "Jul") t = t "07";
 			if ($6 == "Aug") t = t "08";
 			if ($6 == "Sep") t = t "09";
 			if ($6 == "Oct") t = t "10";
 			if ($6 == "Nov") t = t "11";
 			if ($6 == "Dec") t = t "12";
 			if ($7 < 10) t = t "0";
 			t = t $7;
 			#these next two lines add the 24h clock onto the date
 			#gsub(":", "", $8);
 			#t = sprintf("%s.%4.4s", t, $8);
 			if (t > newest) newest = t;
+		}
 		END { print newest }')"
 	#echo "${newest}"
+}
 get_newest_date()
+{
 	get_newest_rcsid_date
 	case "${newest}" in
 	""|0)	get_newest_mtime_date
 		method=ls
 		;;
 	*)	method=rcsid
 		;;
 	esac
 	#echo "${newest}"
+}
+#
 # choose_version_number() chooses the syspkg version number,
 # by concatenating several components (OS version, syspkg "tiny"
 # version and date).  We end up with something like
 # osvers="3.99.15", tinyvers="0", newest="20060104",
 # and t="3.99.15.0.20060104".
+#
 # The result is stored in the variables ${t} and ${method}.
+#
 method=''
 t=''
 choose_version_number()
+{
 	get_osvers; m1="${method}"
 	get_tinyvers # does not set ${method}
 	get_newest_date; m2="${method}"
 	t="${osvers}.${tinyvers}.${newest}"
 	method="${m1}.${m2}"
 	# print version number that we're using
 	if ${verbose}; then
 		echo "${pkg} - ${t} version using ${method} method"
 	fi
+}
+#
 # init_db_opts() sets the dbfile, dbtype and db_opts variables,
 # used for accessing the pkgdb.byfile.db database.
+#
 init_db_opts()
+{
 	dbfile="${SYSPKG_DB_TOPDIR}/pkgdb.byfile.db"
 	dbtype="btree"
 	db_opts=''
 	: ${TARGET_ENDIANNESS:="$(arch_to_endian "${MACHINE_ARCH}")"}
 	case "${TARGET_ENDIANNESS}" in
 )	db_opts="${db_opts} -E B" # big-endian
 		;;
 )	db_opts="${db_opts} -E L" # little-endian
 		;;
 	*)
 		echo >&2 "${WARNING}Unknown or unsupported target endianness"
 		echo >&2 "${NOTE}Using host endianness"
 		;;
 	esac
 	if ${update} || ${force}; then
 		# overwriting an existing entry is not an error
 		db_opts="${db_opts} -R"
 	fi
 	if [ ${verbosity} -lt 2 ]; then
 		# don't print all the keys added to the database
 		db_opts="${db_opts} -q"
 	fi
+}
+#
 # print_dir_exec_lines outputs an "@exec install" line for each
 # directory in ${PLIST}
+#
 print_dir_exec_lines()
+{
 	local dir uname gname mode
 	local dot_slash_dir
 	local no_dot_dir
 	local word line
 	${AWK} '/^@dirrm/ { print $2 }' <"${PLIST}" | \
 	${SORT} | \
 	while read dir; do
 		# Sanitise the name. ${dir} could be an absolute or
 		# relative name, with or without a leading "./".
 		# ${dot_slash_dir} always has a leading "./" (except when
 		# it's exactly equal to "."). ${no_dot_dir} never has a
 		# leading "." or "/" (except when it's exactly equal to
 		# ".").
 		case "${dir}" in
 		.|./|/)	dot_slash_dir=.  ;;
 		./*)	dot_slash_dir="${dir}" ;;
 		/*)	dot_slash_dir=".${dir}" ;;
 		*)	dot_slash_dir="./${dir}" ;;
 		esac
 		no_dot_dir="${dot_slash_dir#./}"
 		# Get the directory's owner, group, and mode
 		# from the live file system, or let it be overridden
 		# by the metalog.
 		eval "$(${STAT} -f 'uname=%Su gname=%Sg mode=%#OLp' \
 				"${DESTDIR}/${dot_slash_dir}")"
 		if [ -n "${metalog}" ]; then
 			line="$(echo "${dot_slash_dir}" | \
 				${AWK} -f "${rundir}/join.awk" \
 					/dev/stdin "${metalog}")"
 			for word in ${line}; do
 				case "${word}" in
 				uname=*|gname=*|mode=*)	eval "${word}" ;;
 				esac
 			done
 		fi
 		# XXX: Work around yet another pkg_add bug: @cwd lines
 		# do not actually cause the working directory to change,
 		# so file names in @exec lines need to be qualified by
 		# %D, which (in our case, since we know there's an
 		# "@cwd /" line) will be the dir name passed to
 		# "pkg_add -p PREFIX".
 		case "${no_dot_dir}" in
 		.) d="%D" ;;
 		*) d="%D/${no_dot_dir}" ;;
 		esac
 		cat <<EOF
 @exec install -d -o ${uname} -g ${gname} -m ${mode} ${d}
 EOF
 	done
+}
+#
 # register_syspkg() registers the syspkg in ${SYSPKG_DB_TOPDIR}.
 # This involves creating the subdirectory ${SYSPKG_DB_SUBDIR}
 # and populating it with several files.
+#
 register_syspkg()
+{
 	cleanup_must_delete_dbsubdir=true
 	[ -n "${SYSPKG_DB_SUBDIR}" ] || bomb
 	mkdir -p "${SYSPKG_DB_SUBDIR}"
+	#
 	# Guess what versions of other packages to depend on.
+	#
 	# If we are using the OS version as part of the pkg
 	# version, then depend on any version ">=${osvers}".  For
 	# example, etc-sys-etc-1.6ZI.0.20040206 might depend on
 	# base-sys-root>=1.6ZI.
+	#
 	# Failing that, depend on any version "-[0-9]*".
+	#
 	# XXX: We could extend the format of the "deps" file to carry
 	# this sort of information, so we wouldn't have to guess.
+	#
 	case "${t}" in
 	${osvers}.*)	depversion=">=${osvers}" ;;
 	*)		depversion="-[0-9]*" ;;
 	esac
+	#
 	# Add the dependencies.
+	#
 	# We always add a "@pkgdep" line for each prerequisite package.
+	#
 	# If the prerequisite pkg is already registered (as it should be
 	# if our caller is doing things in the right order), then we put
 	# its exact version number in a "@blddep" line.
+	#
 	${AWK} '$1 ~ '/"${pkg}"/' { print $2 }' "${rundir}/deps" | ${SORT} | \
 	while read depname; do
 		# ${pkgdepglob} is a shell glob pattern that should match
 		# any version of a pkg.  ${pkgdep} uses the special syntax
 		# for pkg dependencies, and is not usable as a shell
 		# glob pattern.
 		pkgdepglob="${depname}-[0-9]*"
 		pkgdep="${depname}${depversion}"
 		echo "@pkgdep ${pkgdep}"
 		blddep="$(cd "${SYSPKG_DB_TOPDIR}" && echo ${pkgdepglob} \
 			|| bomb)"
 		case "${blddep}" in
 		*\*)	# pkgdepglob did not match anything
 			echo >&2 "${WARNING}${pkg} depends on '${pkgdep}' but there is no matching syspkg in ${SYSPKG_DB_TOPDIR}"
 			;;
 		*\ *)	# pkgdepglob matched more than once.
 			echo >&2 "${ERRWARN}${pkg} depends on '${pkgdep}' but there are multiple matching syspkgs in ${SYSPKG_DB_TOPDIR}"
 			${force} || bomb
 			# If ${force} is set, then assume that the last
 			# match is the most recent.
 			# XXX: This might be wrong, because of
 			# differences between lexical sorting and
 			# numeric sorting.
 			lastmatch="${blddep##* }"
 			echo "@blddep ${lastmatch}"
 			;;
 		*)	# exactly one match.
 			# XXX: We ignore the possibility that the
 			# version we found via ${pkgdepglob} might not
 			# satisfy ${pkgdep}.  We could conceivably use
 			# "pkg_admin pmatch" to check, but that's not a
 			# host tool so we can't assume that it will be
 			# available.
 			echo "@blddep ${blddep}"
 			;;
 		esac
 	done >>"${PLIST}"
 	# create the comment (should be one line)
 	comment="$(${AWK} '$1 ~ '/"${pkg}"/' \
 			{ print substr($0, length($1) + 2) }' \
 			"${rundir}/comments")"
 	case "${comment}" in
 	"")	echo >&2 "${WARNING}no comment for \"${pkg}\" (using placeholder)"
 		comment="System package for ${pkg}"
 		;;
 	*"${nl}"*)
 		echo >&2 "${ERRWARN}multi-line comment for \"${pkg}\""
 		${force} || bomb
 		;;
 	esac
 	echo "${comment}" > "${SYSPKG_DB_SUBDIR}/+COMMENT"
 	# create the description (could be multiple lines)
 	descr="$(${AWK} '$1 ~ '/"${pkg}"/' {
 			print substr($0, length($1) + 2) }' \
 			"${rundir}/descrs")"
 	case "${descr}" in
 	"")	echo >&2 "${WARNING}no description for \"${pkg}\" (re-using comment)" 2>&1
 		descr="${comment}"
 		;;
 	esac
 	echo "${descr}" > "${SYSPKG_DB_SUBDIR}/+DESC"
 	${PRINTF} "\nHomepage:\nhttp://www.NetBSD.org/\n" >> "${SYSPKG_DB_SUBDIR}/+DESC"
 	# create the build information
 	if [ x"${BUILD_INFO_CACHE}" = x ]; then
+		{
 		# These variables describe the build
 		# environment, not the target.
 		echo "OPSYS=$(${UNAME} -s)"
 		echo "OS_VERSION=$(${UNAME} -r)"
 		${MAKE} -B -f- all <<EOF
 .include <bsd.own.mk>
 all:
 	@echo OBJECT_FMT=${OBJECT_FMT}
 	@echo MACHINE_ARCH=${MACHINE_ARCH}
 	@echo MACHINE_GNU_ARCH=${MACHINE_GNU_ARCH}
 EOF
 		# XXX: what's the point of reporting _PKGTOOLS_VER
 		# when we roll everything by hand without using
 		# the pkg tools?
 		echo "_PKGTOOLS_VER=$(${PKG_CREATE} -V)"
 		} > "${SYSPKG_DB_SUBDIR}/+BUILD_INFO"
 	else
 		cp "${BUILD_INFO_CACHE}" "${SYSPKG_DB_SUBDIR}/+BUILD_INFO"
 	fi
 	# test for attributes
 	args=""
 	attrs="$(${AWK} '$1 ~ '/"${pkg}"/' { \
 			print substr($0, length($1) + 2) }' \
 		"${rundir}/attrs")"
 	for a in "${attrs}"; do
 		case "${attrs}" in
 		"")	;;
 		preserve)
 			echo "${pkg}-${t}" >"${SYSPKG_DB_SUBDIR}/+PRESERVE"
 			args="${args} -n ${SYSPKG_DB_SUBDIR}/+PRESERVE"
 			;;
 		esac
 	done
+	#
 	# Create ${SYSPKGSIR}/+CONTENTS from ${PLIST}, by adding an
 	# "@name" line and a lot of "@comment MD5:" lines.
+	#
+	{
-		rcsid='$NetBSD: regpkg,v 1.17 2009/10/17 23:43:22 agc Exp $'
+		rcsid='$NetBSD: regpkg,v 1.18 2009/12/01 15:49:21 apb Exp $'
 		utcdate="$(${ENV_CMD} TZ=UTC LOCALE=C \
 			${DATE} '+%Y-%m-%d %H:%M')"
 		user="${USER:-root}"
 		host="$(${HOSTNAME})"
 		echo "@name ${pkg}-${t}"
 		echo "@comment Packaged at ${utcdate} UTC by ${user}@${host}"
 		echo "@comment Packaged using ${prog} ${rcsid}"
 		# XXX: "option extract-in-place" might help to get
 		#	pkg_add to create directories.
 		# XXX: no, it doesn't work.  Yet another pkg_add bug.
 		## echo "@option extract-in-place"
 		# Move the @pkgdep and @blddep lines up, so that
 		# they are easy to see when people do "less
 		# ${DESTDIR}/var/db/syspkg/*/+CONTENTS".
 		${EGREP} '^(@pkgdep|@blddep)' "${PLIST}" || true
 		# Now do the remainder of the file.
 		while read line; do
 			case "${line}" in
 			@pkgdep*|@blddep*)
 				# already handled by grep above
 				;;
 			@cwd*)
 				# There should be exactly one @cwd line.
 				# Just after it, add an "@exec mkdir"
 				# line for every directory.  This is to
 				# work around a pkg-add bug (see
 				# <http://mail-index.NetBSD.org/tech-pkg/2003/12/11/0018.html>)
 				echo "${line}"
 				print_dir_exec_lines
 				;;
 			@*)
 				# just pass through all other @foo lines
 				echo "${line}"
 				;;
 			*)
 				# This should be a file name.  Pass it
 				# through, and append "@comment MD5:".
 				# XXX why not SHA256 ?
 				echo "${line}"
 				file="${DESTDIR}${line}"
 				if [ -f "${file}" -a -r "${file}" ];
 				then
 					md5sum="$(${CKSUM} -n -m "${file}" \
 						   | ${AWK} '{print $1}'
 						)"
 					echo "@comment MD5:${md5sum}"
 				fi
 				;;
 			esac
 		done <"${PLIST}"
 	} >"${SYSPKG_DB_SUBDIR}/+CONTENTS"
+	#
 	#  Update ${SYSPKG_DB_TOPDIR}/pkgdb.byfile.db.
+	#
+	{
 		init_db_opts # sets dbfile, dbtype, and db_opts
 		# Transform ${PLIST} into a form to be used as keys in
 		# ${dbfile}.  The results look like absolute paths,
 		# but they are really relative to ${DESTDIR}.
+		#
 		# "@dirrm ."		-> "/"
 		# "@dirrm foo/bar"	-> "/foo/bar"
 		# "@dirrm ./foo/bar"	-> "/foo/bar"
 		# "foo/bar/baz"		-> "/foo/bar/baz"
 		# "./foo/bar/baz"	-> "/foo/bar/baz"
+		#
 		dblist="${SCRATCH}/dblist"
 		${AWK} '/^@dirrm \.\//	{gsub("^.", "", $2); print $2; next}
 			/^@dirrm \.$/	{print "/"; next}
 			/^@dirrm/	{print "/" $2; next}
 			/^@/		{next}
 			/^\.\//		{gsub("^.", "", $0); print $0; next}
 			/./		{print "/" $0; next}' \
 			<"${PLIST}" >"${dblist}"
 		# Add all the path names to the database.
 		${AWK} '{print $1 "\t" "'"${pkg}-${t}"'"}' <"${dblist}" \
 		| ${DB} -w ${db_opts} -F "${tab}" -f - "${dbtype}" "${dbfile}"
+	}
 	if ${verbose}; then
 		echo "Registered ${pkg}-${t} in ${SYSPKG_DB_TOPDIR}"
 	elif ! ${quiet}; then
 		echo "Registered ${pkg}-${t}"
 	fi
 	cleanup_must_delete_dbsubdir=false
+}
+#
 # create_syspkg_tgz() creates the *.tgz file for the package.
+#
 # The output file is ${binpkgdir}/${pkg}-${t}.tgz.
+#
 create_syspkg_tgz()
+{
+	#
 	# pkg_create does not understand metalog files, so we have to
 	# use pax directly.
+	#
 	# We create two specfiles: specfile_overhead describes the
 	# special files that are part of the package system's metadata
 	# (+CONTENTS, +COMMENT, +DESCR, and more); and specfile_payload
 	# describes the files and directories that we actually want as
 	# part of the package's payload.
+	#
 	# We then use the specfiles to create a compressed tarball that
 	# contains both the overhead files and the payload files.
+	#
 	# There's no trivial way to get a single pax run to do
 	# everything we want, so we run pax twice, with a different
 	# working directory and a different specfile each time.
+	#
 	# We could conceivably make clever use of pax's "-s" option to
 	# get what we want from a single pax run with a single (more
 	# complicated) specfile, but the extra trouble doesn't seem
 	# warranted.
+	#
 	cleanup_must_delete_binpkgfile=true
 	specfile_overhead="${SCRATCH}/spec_overhead"
 	specfile_payload="${SCRATCH}/spec_payload"
 	tarball_uncompressed="${SCRATCH}/tarball_uncompressed"
 	# Create a specfile for all the overhead files (+CONTENTS and
 	# friends).
+	{
 		plusnames_first="${SCRATCH}/plusnames_first"
 		plusnames_rest="${SCRATCH}/plusnames_rest"
 		# Ensure that the first few files are in the same order
 		# that "pkg_create" would have used, just in case anything
 		# depends on that.  Other files in alphabetical order.
 		SHOULD_BE_FIRST="+CONTENTS +COMMENT +DESC"
+		(
 			cd "${SYSPKG_DB_SUBDIR}" || bomb
 			for file in ${SHOULD_BE_FIRST}; do
 				[ -e "./${file}" ] && echo "${file}"
 			done >"${plusnames_first}"
 			${LS} -1 | ${FGREP} -v -f "${plusnames_first}" \
 				>"${plusnames_rest}" \
 				|| true
+		)
 		# Convert the file list to specfile format, and override the
 		# uid/gid/mode.
+		{
 			echo ". optional type=dir"
 			${AWK} '{print "./" $0 " type=file uid=0 gid=0 mode=0444"
 				}' "${plusnames_first}" "${plusnames_rest}"
 		} >"${specfile_overhead}"
+	}
 	# Create a specfile for the payload of the package.
+	{
 		spec1="${SCRATCH}/spec1"
 		spec2="${SCRATCH}/spec2"
 		# Transform ${PLIST} into simple specfile format:
+		#
 		# "@dirrm ."		-> ". type=dir"
 		# "@dirrm foo/bar"	-> "./foo/bar type=dir"
 		# "@dirrm ./foo/bar"	-> "./foo/bar type=dir"
 		# "foo/bar/baz"		-> "./foo/bar/baz"
 		# "./foo/bar/baz"	-> "./foo/bar/baz"
+		#
 		# Ignores @cwd lines.  This should be safe, given how
 		# makeplist works.
 		${AWK} '/^@dirrm \.\//	{print $2 " type=dir"; next}
 			/^@dirrm \.$/	{print ". type=dir"; next}
 			/^@dirrm/	{print "./" $2 " type=dir"; next}
 			/^@/		{next}
 			/^\.\//		{print $0; next}
 			/./		{print "./" $0; next}' \
 			<"${PLIST}" >"${spec1}"
 		# If metalog was specified, attributes from metalog override
 		# attributes in the file system.  We also fake up an
 		# entry for the ./etc/mtree/set.${pkgset} file.
+		{
 			if [ -n "${metalog}" ]; then
 				${AWK} -f "${rundir}/join.awk" \
 					"${spec1}" "${metalog}"
 				${AWK} -f "${rundir}/join.awk" \
 					"${spec1}" /dev/stdin <<EOF
 ./etc/mtree/set.${pkgset} type=file mode=0444 uname=root gname=wheel
 EOF
 			else
 				cat "${spec1}"
 			fi
 		} >"${spec2}"
+		#
 		# If a file or directory to was mentioned explicitly
 		# in ${PLIST} but not mentioned in ${metalog}, then the
 		# file or directory will not be mentioned in ${spec2}.
 		# This is an error, and means that the metalog was
 		# not built correctly.
+		#
 		if [ -n "${metalog}" ]; then
 			names1="${SCRATCH}/names1"
 			names2="${SCRATCH}/names2"
 			${AWK} '{print $1}' <"${spec1}" | ${SORT} >"${names1}"
 			${AWK} '{print $1}' <"${spec2}" | ${SORT} >"${names2}"
 			if ${FGREP} -v -f "${names2}" "${spec1}" >/dev/null
 			then
 				cat >&2 <<EOM
 ${ERRWARN}The metalog file (${metalog}) does not
 	contain entries for the following files or directories
 	which should be part of the ${pkg} syspkg:
 EOM
 				${FGREP} -v -f "${names2}" "${spec1}" >&2
 				${force} || bomb
 			fi
 			if ${FGREP} -v -f "${names1}" "${spec2}" >/dev/null
 			then
 				cat >&2 <<EOM
 ${ERRWARN}The following lines are in the metalog file
 	(${metalog}), and the corresponding files or directories
 	should be in the ${pkg} syspkg, but something is wrong:
 EOM
 				${FGREP} -v -f "${names1}" "${spec2}" >&2
 				bomb
 			fi
 		fi
 		# Add lines (tagged "optional") for any implicit directories.
+		#
 		# For example, if we have a file ./foo/bar/baz, then we add
 		# "./foo/bar optional type=dir", "./foo optional type=dir",
 		# and ". optional type=dir", unless those directories were
 		# already mentioned explicitly.
+		#
 		${AWK} -f "${rundir}/getdirs.awk" "${spec2}" \
 		| ${SORT} -u >"${specfile_payload}"
+	}
 	# Use two pax invocations followed by gzip to create
 	# the tgz file.
+	#
 	# Remove any leading "./" from path names, because that
 	# could confuse tools that work with binary packages.
+	(
 		cd "${SYSPKG_DB_SUBDIR}" && \
 		${PAX} -O -w -d -N"${etcdir}" -M '-s,^\./,,' \
 			-f "${tarball_uncompressed}" \
 			<"${specfile_overhead}" \
 		|| bomb
+	)
+	(
 		cd "${DESTDIR:-/}" && \
 		${PAX} -O -w -d -N"${etcdir}" -M '-s,^\./,,' \
 			-a -f "${tarball_uncompressed}" \
 			<"${specfile_payload}" \
 		|| bomb
+	)
 	${GZIP_CMD} -9n <"${tarball_uncompressed}" >"${binpkgfile}" || bomb
 	# (Extra space is to make message line up with "Registered" message.)
 	if ${verbose}; then
 		echo "  Packaged ${binpkgfile}"
 	elif ! ${quiet}; then
 		echo "  Packaged ${binpkgfile##*/}"
 	fi
 	cleanup_must_delete_binpkgfile=false
+}
+#
 # do_register_syspkg() registers the syspkg if appropriate.
+#
 # If SYSPKG_DB_SUBDIR already exists, that might be an error, depending
 # on ${force} and ${update} flags.
+#
 do_register_syspkg()
+{
 	# Check that necessary variables are defined
 	[ -n "${SYSPKG_DB_TOPDIR}" ] || bomb
 	[ -n "${SYSPKG_DB_SUBDIR}" ] || bomb
 	# Create SYSPKG_DB_TOPDIR if necessary
 	[ -d "${SYSPKG_DB_TOPDIR}" ] || mkdir -p "${SYSPKG_DB_TOPDIR}" || bomb
 	# A function to delete db entries referring to any version of ${pkg}
 	delete_old_db_entries()
+	{
 		init_db_opts # sets dbfile, dbtype, and db_opts
 		dblist="${SCRATCH}/dblist"
 		${DB} ${db_opts} -O "${tab}" "${dbtype}" "${dbfile}" \
 		| ${AWK} -F "${tab}" '$2 ~ /^'"${pkg}"'-[0-9]/ { print $1 }' \
 			>"${dblist}"
 		${DB} -d ${db_opts} -f "${dblist}" "${dbtype}" "${dbfile}"
+	}
 	# A function to delete any old version of ${pkg}
 	delete_old_pkg()
+	{
 		pattern="${pkg}-[0-9]*"
 		matches="$(cd "${SYSPKG_DB_TOPDIR}" && echo ${pattern} \
 			|| bomb)"
 		echo >&2 "${NOTE}deleting old pkg (${matches})"
 		cleanup_must_delete_dbsubdir=true
 		delete_old_db_entries
 		( cd "${SYSPKG_DB_TOPDIR}" && rm -rf ${matches} )
+	}
 	# Check whether another version of ${pkg} is already registered.
 	pattern="${pkg}-[0-9]*"
 	matches="$(cd "${SYSPKG_DB_TOPDIR}" && echo ${pattern} || bomb)"
 	case "${matches}" in
 	*\*)		;;	# wildcard did not match anything
 	"${pkg}-${t}")	;;	# exact match
 	*)	echo >&2 "${ERRWARNNOTE}another version of ${pkg} is already registered"
 		${verbose} && echo >&2 "	in ${SYSPKG_DB_TOPDIR}"
 		${verbose} && echo >&2 "	(while registering ${pkg}-${t})"
 		${force} || ${update} || bomb
 		delete_old_pkg
 		;;
 	esac
 	# Check whether the desired version of ${pkg} is already registered,
 	# and create it if appropriate.
 	if [ -d "${SYSPKG_DB_SUBDIR}" ]; then
 		echo >&2 "${ERRWARNNOTE}${pkg}-${t} is already registered"
 		${verbose} && echo >&2 "	in ${SYSPKG_DB_TOPDIR}"
 		if ${force}; then
 			delete_old_pkg
 			register_syspkg
 		elif ${update}; then
+			#
 			# If all files in SYSPKG_DB_SUBDIR are newer
 			# than all files in the pkg, then do nothing.
 			# Else delete and re-register the pkg.
+			#
 			[ -n "${newestfile}" ] || init_newestfile
 			if [ -n "${newestfile}" ]; then
 				case "$(${FIND} "${SYSPKG_DB_SUBDIR}" -type f \
 					! -newer "${newestfile}" -print)" \
 				in
 				"")	;;
 				*)
 					echo >&2 "${NOTE}some files are newer but pkg version is unchanged"
 					delete_old_pkg
 					register_syspkg
 					;;
 				esac
 			else
 				# No files in the pkg?  (This could happen
 				# if a pkg contains only directories.)
 				# Do nothing (keep the already-registered pkg).
 			fi
 		else
 			bomb
 		fi
 	else
 		register_syspkg
 	fi
+}
+#
 # do_create_syspkg_tgz() creates the the binary pkg (*.tgz) if
 # appropriate.
+#
 # If binpkgfile already exists, that might be an error, depending on
 # ${force} and ${update} flags.
+#
 do_create_syspkg_tgz()
+{
 	[ -n "${binpkgfile}" ] || bomb
 	delete_and_recreate()
+	{
 		echo >&2 "${ERRWARNNOTE}deleting and re-creating ${pkg}-${t}.tgz"
 		rm -f "${binpkgfile}"
 		create_syspkg_tgz
+	}
 	# Check whether another version of ${pkg} already exists.
 	pattern="${pkg}-[0-9]*"
 	matches="$(cd "${binpkgdir}" && echo ${pattern} || bomb)"
 	case "${matches}" in
 	*\*)	;;	# wildcard did not match anything
 	"${pkg}-${t}.tgz") ;;	# exact match
 	*)	echo >&2 "${ERRWARNNOTE}another version of ${pkg} binary pkg already exists"
 		${verbose} && echo >&2 "	in ${binpkgdir}"
 		${verbose} && echo >&2 "	(while creating ${pkg}-${t}.tgz)"
 		# If neither force nor update, this is a fatal error.
 		# If force but not update, then leave old .tgz in place.
 		# If update, then delete the old .tgz.
 		${force} || ${update} || bomb
 		if ${update}; then
 			echo >&2 "${NOTE}deleting old binary pkg (${matches})"
 			( cd "${binpkgdir}" && rm -f ${matches} || bomb )
 		fi
 		;;
 	esac
 	# Check whether the desired version of ${pkg} already exists,
 	# and create it if appropriate.
 	if [ -e "${binpkgfile}" ]; then
 		echo >&2 "${ERRWARNNOTE}${pkg}-${t}.tgz already exists"
 		${verbose} && echo >&2 "	in ${binpkgdir}"
 		if ${force}; then
 			delete_and_recreate
 		elif ${update}; then
+			#
 			# If all files in SYSPKG_DB_SUBDIR are older
 			# than ${binpkgfile}, then do nothing.
 			# Else delete and re-create the tgz.
+			#
 			case "$(${FIND} "${SYSPKG_DB_SUBDIR}" -type f \
 				-newer "${binpkgfile}" -print)" \
 			in
 			"")	;;
 			*)	delete_and_recreate ;;
 			esac
 		else
 			bomb
 		fi
 	else
 		create_syspkg_tgz
 	fi
+}
 ####################
 # begin main program
 parse_args ${1+"$@"}
 make_PLIST
 choose_version_number
 SYSPKG_DB_SUBDIR="${SYSPKG_DB_TOPDIR}/${pkg}-${t}"
 do_register_syspkg
 if [ -n "${binpkgdir}" ]; then
 	binpkgfile="${binpkgdir}/${pkg}-${t}.tgz"
 	do_create_syspkg_tgz
 fi
 exit 0

 @@ -1,571 +1,570 @@
-#	$NetBSD: sets.subr,v 1.92 2009/11/30 16:13:23 uebayasi Exp $
+#	$NetBSD: sets.subr,v 1.93 2009/12/01 15:49:21 apb Exp $
+#
+#
 # The following variables contain defaults for sets.subr functions and callers:
 #	setsdir			path to src/distrib/sets
 #	nlists			list of base sets
 #	xlists			list of x11 sets
 #	extlists		list of extsrc sets
 #	obsolete		controls if obsolete files are selected instead
 #	module			if != "no", enable MODULE sets
 #	shlib			shared library format (a.out, elf, or "")
 #	stlib			static library format (a.out, elf)
+#
 # The following <bsd.own.mk> variables are exported to the environment:
 #	MACHINE
 #	MACHINE_ARCH
 #	MACHINE_CPU
 #	HAVE_BINUTILS
 #	HAVE_GCC
 #	HAVE_GDB
 #	TOOLCHAIN_MISSING
 #	OBJECT_FMT
 # as well as:
+#
 MKVARS="\
 	MKBFD		\
 	MKBINUTILS	\
 	MKCATPAGES	\
 	MKCOMPAT	\
 	MKCRYPTO	\
 	MKCRYPTO_IDEA	\
 	MKCRYPTO_MDC2	\
 	MKCRYPTO_RC5	\
 	MKCVS		\
 	MKDEBUG		\
 	MKDEBUGLIB	\
 	MKDOC		\
 	MKDYNAMICROOT	\
 	MKEXTSRC	\
 	MKGCC		\
 	MKGCCCMDS	\
 	MKGDB		\
 	MKHESIOD	\
 	MKHTML		\
 	MKINET6		\
 	MKINFO		\
 	MKIPFILTER	\
 	MKISCSI		\
 	MKKERBEROS	\
 	MKKMOD		\
 	MKLDAP		\
 	MKLINT		\
 	MKLVM		\
 	MKMAN		\
 	MKMANPAGES	\
 	MKMANZ		\
 	MKMDNS		\
 	MKNLS		\
 	MKNVI		\
 	MKPAM		\
 	MKPF		\
 	MKPIC		\
 	MKPOSTFIX	\
 	MKPROFILE	\
 	MKSHARE		\
 	MKSKEY		\
 	MKX11		\
 	MKX11FONTS	\
 	MKXORG		\
 	MKYP		\
 	MKZFS		\
 	USE_INET6	\
 	USE_KERBEROS	\
 	USE_LDAP	\
 	USE_YP		\
 	NETBSDSRCDIR	\
 	MAKEVERBOSE	\
+"
+#
 # The following variables refer to tools that are used when building sets:
+#
 : ${AWK:=awk}
 : ${CKSUM:=cksum}
 : ${COMM:=comm}
 : ${DATE:=date}
 : ${DB:=db}
 : ${EGREP:=egrep}
 : ${ENV_CMD:=env}       # ${ENV} is special to sh(1), ksh(1), etc.
 : ${FGREP:=fgrep}
 : ${FIND:=find}
 : ${GREP:=grep}
 : ${GZIP_CMD:=gzip}     # ${GZIP} is special to gzip(1)
 : ${HOSTNAME:=hostname}
 : ${HOST_SH:=sh}
 : ${IDENT:=ident}
 : ${JOIN:=join}
 : ${LS:=ls}
 : ${MAKE:=make}
 : ${MKTEMP:=mktemp}
 : ${MTREE:=mtree}
 : ${PASTE:=paste}
 : ${PAX:=pax}
 : ${PKG_CREATE:=pkg_create}
 : ${PRINTF:=printf}
 : ${SED:=sed}
 : ${SORT:=sort}
 : ${STAT:=stat}
 : ${TSORT:=tsort}
 : ${UNAME:=uname}
 : ${WC:=wc}
+#
 # If printf is a shell builtin command, then we can
 # implement cheaper versions of basename and dirname
 # that do not involve any fork/exec overhead.
 # If printf is not builtin, approximate it using echo,
 # and hope there are no weird file names that cause
 # some versions of echo to do the wrong thing.
 # (Converting to this version of dirname speeded up the
 # syspkgdeps script by an order of magnitude, from 68
 # seconds to 6.3 seconds on one particular host.)
+#
 # Note that naive approximations for dirname
 # using ${foo%/*} do not do the right thing in cases
 # where the result should be "/" or ".".
+#
 case "$(type printf)" in
 *builtin*)
 	basename ()
+	{
 		local bn
 		bn="${1##*/}"
 		bn="${bn%$2}"
 		printf "%s\n" "$bn"
+	}
 	dirname ()
+	{
 		local dn
 		case "$1" in
 		?*/*)	dn="${1%/*}" ;;
 		/*)	dn=/ ;;
 		*)	dn=. ;;
 		esac
 		printf "%s\n" "$dn"
+	}
 	;;
 *)
 	basename ()
+	{
 		local bn
 		bn="${1##*/}"
 		bn="${bn%$2}"
 		echo "$bn"
+	}
 	dirname ()
+	{
 		local dn
 		case "$1" in
 		?*/*)	dn="${1%/*}" ;;
 		/*)	dn=/ ;;
 		*)	dn=. ;;
 		esac
 		echo "$dn"
+	}
 	;;
 esac
 oIFS=$IFS
 IFS="
+"
 for x in $(
 ${MAKE} -B -f- all <<EOMAKE
 .include <bsd.own.mk>
 .if (\${MKMAN} == "no" || empty(MANINSTALL:Mmaninstall))
 MKMANPAGES=no
 .else
 MKMANPAGES=yes
 .endif
 .if \${MKX11} != "no"
 . if \${X11FLAVOUR} == "Xorg"
 MKXORG:=yes
 MKX11:=no
 . else
 MKXORG:=no
 . endif
 .endif
 all:
 .for i in MACHINE MACHINE_ARCH MACHINE_CPU \
 		HAVE_BINUTILS HAVE_GCC HAVE_GDB OBJECT_FMT TOOLCHAIN_MISSING \
 		${MKVARS}
 	@echo "export \$i=\${\$i}"
 .endfor
 EOMAKE
 ); do
 #	echo 1>&2 "DEBUG: read $x"
 	eval $x
 done
 IFS=$oIFS
 setsdir=${0%/*}
 obsolete=0
 module=yes
 if [ "${MKKMOD}" = "no" ]; then
 	module=no			# MODULEs are off.
 elif [ "${MACHINE}" = "evbppc" ]; then
 	module=no			# Turn off MODULEs for some ports.
 fi
 # Determine lib type. Do this first so stlib also gets set.
 if [ "${OBJECT_FMT}" = "ELF" ]; then
 	shlib=elf
 else
 	shlib=aout
 fi
 stlib=$shlib
 # Now check for MKPIC or specials and turn off shlib if need be.
 if [ "${MKPIC}" = "no" ]; then
 	shlib=no
 fi
 if [ "${MACHINE_ARCH}" = "m68000" ]; then
 	shlib=no			# Turn off shlibs for some ports.
 fi
 if [ "$module" != "no" ]; then
 	nlists="base comp etc games man misc modules tests text"
 else
 	nlists="base comp etc games man misc tests text"
 fi
 xlists="xbase xcomp xetc xfont xserver"
 extlists="extbase extcomp extetc"
 OSRELEASE=`${HOST_SH} ${NETBSDSRCDIR}/sys/conf/osrelease.sh`
 MODULEDIR="stand/${MACHINE}/${OSRELEASE}/modules"
 SUBST="s#@MODULEDIR@#${MODULEDIR}#g"
 SUBST="${SUBST};s#@OSRELEASE@#${OSRELEASE}#g"
 SUBST="${SUBST};s#@MACHINE@#${MACHINE}#g"
+#
 # list_set_files setfile [...]
+#
 # Produce a packing list for setfile(s).
 # In each file, a record consists of a path and a System Package name,
 # separated by whitespace. E.g.,
+#
-# 	# $NetBSD: sets.subr,v 1.92 2009/11/30 16:13:23 uebayasi Exp $
+# 	# $NetBSD: sets.subr,v 1.93 2009/12/01 15:49:21 apb Exp $
 # 	.			base-sys-root	[keyword[,...]]
 # 	./altroot		base-sys-root
 # 	./bin			base-sys-root
 # 	./bin/[			base-util-root
 # 	./bin/cat		base-util-root
 #		[...]
+#
 # A # in the first column marks a comment.
+#
 # If ${obsolete} != 0, only entries with an "obsolete" keyword will
 # be printed.  All other keywords must be present.
+#
 # The third field is an optional comma separated list of keywords to
 # control if a record is printed; every keyword listed must be enabled
 # for the record to be printed.  The following keywords are available:
 #	dummy			dummy entry (ignored)
 #	obsolete		file is obsolete, and only printed if
 #				${obsolete} != 0
+#
 #	bfd			obsolete, use binutils.
 #	binutils		${MKBINUTILS} != no
 #	catpages		${MKCATPAGES} != no
 #	compat			${MKCOMPAT} != no
 #	crypto			${MKCRYPTO} != no
 #	crypto_idea		${MKCRYPTO_IDEA} != no
 #	crypto_mdc2		${MKCRYPTO_MDC2} != no
 #	crypto_rc5		${MKCRYPTO_RC5} != no
 #	cvs			${MKCVS} != no
 #	debug			${MKDEBUG} != no
 #	debuglib		${MKDEBUGLIB} != no
 #	doc			${MKDOC} != no
 #	dynamicroot		${MKDYNAMICROOT} != no
 #	extsrc			${MKEXTSRC} != no
 #	gcc			${MKGCC} != no
 #	gcccmds			${MKGCCCMDS} != no
 #	gdb			${MKGDB} != no
 #	hesiod			${MKHESIOD} != no
 #	html			${MKHTML} != no
 #	inet6			${MKINET6} != no
 #	info			${MKINFO} != no
 #	ipfilter		${MKIPFILTER} != no
 #	iscsi			${MKISCSI} != no
 #	kerberos		${MKKERBEROS} != no
 #	kmod			${MKKMOD} != no
 #	ldap			${MKLDAP} != no
 #	lint			${MKLINT} != no
 #	lvm			${MKLVM} != no
 #	man			${MKMAN} != no
 #	manpages		${MKMANPAGES} != no
 #	manz			${MKMANZ} != no
 #	mdns			${MKMDNS} != no
 #	nls			${MKNLS} != no
 #	nvi			${MKNVI} != no
 #	pam			${MKPAM} != no
 #	pf			${MKPF} != no
 #	pic			${MKPIC} != no
 #	postfix			${MKPOSTFIX} != no
 #	profile			${MKPROFILE} != no
 #	share			${MKSHARE} != no
 #	skey			${MKSKEY} != no
 #	x11			${MKX11} != no && ${X11FLAVOUR} != "Xorg"
 #	xorg			${MKX11} != no && ${X11FLAVOUR} == "Xorg"
 #	yp			${MKYP} != no
 #	zfs			${MKZFS} != no
+#
 #	binutils=<n>		<n> = value of ${HAVE_BINUTILS}
 #	gcc=<n>			<n> = value of ${HAVE_GCC}
 #	gdb=<n>			<n> = value of ${HAVE_GDB}
+#
 #	use_inet6		${USE_INET6} != no
 #	use_kerberos		${USE_KERBEROS} != no
 #	use_yp			${USE_YP} != no
+#
 #	.cat			if ${MKMANZ} != "no" && ${MKCATPAGES} != "no"
 #				  automatically append ".gz" to the filename
+#
 #	.man			if ${MKMANZ} != "no" && ${MKMAN} != "no"
 #				  automatically append ".gz" to the filename
+#
 list_set_files()
+{
 	if [ ${MAKEVERBOSE:-2} -lt 3 ]; then
 		verbose=false
 	else
 		verbose=true
 	fi
 	for setname; do
 		list=`list_set_lists $setname`
 		for l in $list; do
 			echo $l
 			if $verbose; then
 				echo >&2 "DEBUG: list_set_files: $l"
 			fi
 		done
 	done | xargs cat | ${SED} ${SUBST} | \
 	${AWK} -v obsolete=${obsolete} '
 		BEGIN {
 			if (obsolete)
 				wanted["obsolete"] = 1
 			split("'"${MKVARS}"'", needvars)
 			for (vi in needvars) {
 				nv = needvars[vi]
 				kw = tolower(nv)
 				sub(/^mk/, "", kw)
 				if (ENVIRON[nv] != "no")
 					wanted[kw] = 1
+			}
 			if ("'"${TOOLCHAIN_MISSING}"'" != "yes") {
 				if ("binutils" in wanted)
 					wanted["binutils=" "'"${HAVE_BINUTILS}"'"] = 1
 				if ("gcc" in wanted)
 					wanted["gcc=" "'"${HAVE_GCC}"'"] = 1
 				if ("gdb" in wanted)
 					wanted["gdb=" "'"${HAVE_GDB}"'"] = 1
+			}
 			if (("man" in wanted) && ("catpages" in wanted))
 				wanted[".cat"] = 1
 			if (("man" in wanted) && ("manpages" in wanted))
 				wanted[".man"] = 1
+		}
 		/^#/ {
 			next;
+		}
 		NF > 2 && $3 != "-" {
 			split($3, keywords, ",")
 			show = 1
 			haveobs = 0
 			for (ki in keywords) {
 				kw = keywords[ki]
 				if (("manz" in wanted) &&
 				    (kw == ".cat" || kw == ".man"))
 					$1 = $1 ".gz"
 				negated = match(kw, "! *")
 				if (negated > 0) {
 					kw = substr(kw, RSTART + RLENGTH)
 					if (kw in wanted)
 						show = 0
 				} else {
 					if (! (kw in wanted))
 						show = 0
+				}
 				if (kw == "obsolete")
 					haveobs = 1
+			}
 			if (obsolete && ! haveobs)
 				next
 			if (show)
 				print
 			next
+		}
+		{
 			if (! obsolete)
 				print
 		}'
+}
+#
 # list_set_lists setname
+#
 # Print to stdout a list of files, one filename per line, which
 # concatenate to create the packing list for setname. E.g.,
+#
 # 	.../lists/base/mi
 # 	.../lists/base/rescue.mi
 # 	.../lists/base/md.i386
 #		[...]
+#
 # For a given setname $set, the following files may be selected from
 # .../list/$set:
 #	mi
 #	mi.ext.*
 #	ad.${MACHINE_ARCH}
 # (or)	ad.${MACHINE_CPU}
 #	ad.${MACHINE_CPU}.shl
 #	md.${MACHINE}.${MACHINE_ARCH}
 # (or)	md.${MACHINE}
 #	stl.mi
 #	stl.${stlib}
 #	shl.mi
 #	shl.mi.ext.*
 #	shl.${shlib}
 #	shl.${shlib}.ext.*
 #	module.mi			if ${module} != no
 #	module.${MACHINE}		if ${module} != no
 #	module.ad.${MACHINE_ARCH}	if ${module} != no
 # (or)	module.ad.${MACHINE_CPU}	if ${module} != no
 #	rescue.shl
 #	rescue.${MACHINE}
 #	rescue.ad.${MACHINE_ARCH}
 # (or)	rescue.ad.${MACHINE_CPU}
 # 	rescue.ad.${MACHINE_CPU}.shl
+#
 # Environment:
 # 	shlib
 # 	stlib
+#
 list_set_lists()
+{
 	setname=$1
 	setdir=$setsdir/lists/$setname
 	echo $setdir/mi
 	for _extsrc_pkg in ${EXTSRCS}; do
 		if [ -f $setdir/mi.ext.${_extsrc_pkg} ]; then
 			echo $setdir/mi.ext.${_extsrc_pkg}
 		fi
 	done
 	if [ "${MACHINE}" != "${MACHINE_ARCH}" ]; then
 		# Prefer an ad.${MACHINE_ARCH} over an ad.${MACHINE_CPU},
 		# since the arch-specific one will be more specific than
 		# the cpu-specific one.
 		if [ -f $setdir/ad.${MACHINE_ARCH} ]; then
 			echo $setdir/ad.${MACHINE_ARCH}
 		elif [ -f $setdir/ad.${MACHINE_CPU} ]; then
 			echo $setdir/ad.${MACHINE_CPU}
 		fi
 		if [ "$shlib" != "no" -a \
 		     -f $setdir/ad.${MACHINE_CPU}.shl ]; then
 			echo $setdir/ad.${MACHINE_CPU}.shl
 		fi
 	fi
 	if [ -f $setdir/md.${MACHINE}.${MACHINE_ARCH} ]; then
 		echo $setdir/md.${MACHINE}.${MACHINE_ARCH}
 	elif [ -f $setdir/md.${MACHINE} ]; then
 		echo $setdir/md.${MACHINE}
 	fi
 	if [ -f $setdir/stl.mi ]; then
 		echo $setdir/stl.mi
 	fi
 	if [ -f $setdir/stl.${stlib} ]; then
 		echo $setdir/stl.${stlib}
 	fi
 	if [ "$shlib" != "no" ]; then
 		if [ -f $setdir/shl.mi ]; then
 			echo $setdir/shl.mi
 		fi
 		for _extsrc_pkg in ${EXTSRCS}; do
 			if [ -f $setdir/shl.mi.ext.${_extsrc_pkg} ]; then
 				echo $setdir/shl.mi.ext.${_extsrc_pkg}
 			fi
 		done
 		if [ -f $setdir/shl.${shlib} ]; then
 			echo $setdir/shl.${shlib}
 		fi
 		for _extsrc_pkg in ${EXTSRCS}; do
 			if [ -f $setdir/shl.${shlib}.ext.${_extsrc_pkg} ]; then
 				echo $setdir/shl.${shlib}.ext.${_extsrc_pkg}
 			fi
 		done
 	fi
 	if [ "$module" != "no" ]; then
 		if [ -f $setdir/module.mi ]; then
 			echo $setdir/module.mi
 		fi
 		if [ -f $setdir/module.${MACHINE} ]; then
 			echo $setdir/module.${MACHINE}
 		fi
 		if [ "${MACHINE}" != "${MACHINE_ARCH}" ]; then
 			# Prefer a module.ad.${MACHINE_ARCH} over a
 			# module.ad.${MACHINE_CPU}, since the arch-
 			# specific one will be more specific than the
 			# cpu-specific one.
 			if [ -f $setdir/module.ad.${MACHINE_ARCH} ]; then
 				echo $setdir/module.ad.${MACHINE_ARCH}
 			elif [ -f $setdir/module.ad.${MACHINE_CPU} ]; then
 				echo $setdir/module.ad.${MACHINE_CPU}
 			fi
 		fi
 	fi
 	if [ -f $setdir/rescue.mi ]; then
 		echo $setdir/rescue.mi
 	fi
 	if [ -f $setdir/rescue.${MACHINE} ]; then
 		echo $setdir/rescue.${MACHINE}
 	fi
 	if [ "${MACHINE}" != "${MACHINE_ARCH}" ]; then
 		# Prefer a rescue.ad.${MACHINE_ARCH} over a
 		# rescue.ad.${MACHINE_CPU}, since the arch-
 		# specific one will be more specific than the
 		# cpu-specific one.
 		if [ -f $setdir/rescue.ad.${MACHINE_ARCH} ]; then
 			echo $setdir/rescue.ad.${MACHINE_ARCH}
 		elif [ -f $setdir/rescue.ad.${MACHINE_CPU} ]; then
 			echo $setdir/rescue.ad.${MACHINE_CPU}
 		fi
 		if [ "$shlib" != "no" -a \
 		     -f $setdir/rescue.ad.${MACHINE_CPU}.shl ]; then
 			echo $setdir/rescue.ad.${MACHINE_CPU}.shl
 		fi
 	fi
+}
 # arch_to_cpu mach
+#
 # Print the ${MACHINE_CPU} for ${MACHINE_ARCH}=mach,
 # as determined by <bsd.own.mk>.
+#
 arch_to_cpu()
+{
 	MACHINE_ARCH=${1} ${MAKE} -B -f- all <<EOMAKE
 .include <bsd.own.mk>
 all:
 	@echo \${MACHINE_CPU}
 EOMAKE
+}
 # arch_to_endian mach
+#
 # Print the ${TARGET_ENDIANNESS} for ${MACHINE_ARCH}=mach,
 # as determined by <bsd.endian.mk>.
+#
 arch_to_endian()
+{
 	MACHINE_ARCH=${1} ${MAKE} -B -f- all <<EOMAKE
 .include <bsd.endian.mk>
 all:
 	@echo \${TARGET_ENDIANNESS}
 EOMAKE
+}