diff --git a/share/mk/doc.html.mk b/share/mk/doc.html.mk
index 06cec7c31f..7df44b2747 100644
--- a/share/mk/doc.html.mk
+++ b/share/mk/doc.html.mk
@@ -1,387 +1,388 @@
 #
 # $FreeBSD$
 #
 # This include file <doc.html.mk> handles building and installing of
 # HTML documentation in the FreeBSD Documentation Project.
 #
 # Documentation using DOCFORMAT=html is expected to be marked up
 # according to the HTML DTD
 #
 
 # ------------------------------------------------------------------------
 #
 # Document-specific variables
 #
 #	DOC		This should be set to the name of the HTML
 #			marked-up file, without the .sgml or .docb suffix.
 #			
 #			It also determins the name of the output files -
 #			${DOC}.html.
 #
 #	DOCBOOKSUFFIX	The suffix of your document, defaulting to .sgml
 #
 #	SRCS		The names of all the files that are needed to
 #			build this document - This is useful if any of
 #			them need to be generated.  Changing any file in
 #			SRCS causes the documents to be rebuilt.
 #
 
 # ------------------------------------------------------------------------
 #
 # Variables used by both users and documents:
 #
 #	TIDYFLAGS	Additional flags to pass to Tidy.  Typically
 #			used to set "-raw" flag to handle 8bit characters.
 #
 #	EXTRA_CATALOGS	Additional catalog files that should be used by
 #			any SGML processing applications.
 #
 #	NO_TIDY		If you do not want to use tidy, set this to "YES".
 #
 # Documents should use the += format to access these.
 #
 
 MASTERDOC?=	${.CURDIR}/${DOC}.sgml
 
 KNOWN_FORMATS=	html txt tar pdb
 
 CSS_SHEET?=
 
 HTMLCATALOG=	${PREFIX}/share/sgml/html/catalog
 
 IMAGES_LIB?=
 
 .if ${MACHINE_ARCH} == "alpha"
 OPENJADE=	yes
 .endif
 
 .if defined(OPENJADE)
 NSGMLS?=	${PREFIX}/bin/onsgmls
 SGMLNORM?=	${PREFIX}/bin/osgmlnorm
 .else
 NSGMLS?=	${PREFIX}/bin/nsgmls
 SGMLNORM?=	${PREFIX}/bin/sgmlnorm
 .endif
  
 PKG_CREATE?=	/usr/sbin/pkg_create
 TAR?=		/usr/bin/tar
 XARGS?=		/usr/bin/xargs
 
 TIDY?=		${PREFIX}/bin/tidy
 TIDYOPTS?=	-i -m -raw -preserve -f /dev/null ${TIDYFLAGS}
 HTML2TXT?=	${PREFIX}/bin/links
 HTML2TXTOPTS?=	-dump ${HTML2TXTFLAGS}
 HTML2PDB?=	${PREFIX}/bin/iSiloBSD
 HTML2PDBOPTS?=	-y -d0 -Idef ${HTML2PDBFLAGS}
 
 GZIP?=	-9
 GZIP_CMD?=	gzip -qf ${GZIP}
 BZIP2?=	-9
 BZIP2_CMD?=	bzip2 -qf ${BZIP2}
 ZIP?=	-9
 ZIP_CMD?=	${PREFIX}/bin/zip -j ${ZIP}
 
 
 # ------------------------------------------------------------------------
 #
 
 .if ${.OBJDIR} != ${.CURDIR}
 LOCAL_CSS_SHEET=	${.OBJDIR}/${CSS_SHEET:T}
+CLEANFILES+=		${LOCAL_CSS_SHEET}
 .else
 LOCAL_CSS_SHEET=	${CSS_SHEET:T}
 .endif
 
 .for _curformat in ${FORMATS}
 _cf=${_curformat}
 
 # Create a 'bogus' doc for any format we support or not.  This is so
 # that we can fake up a target for it later on, and this target can print
 # the warning message about the unsupported format. 
 _docs+= ${DOC}.${_curformat}
 CLEANFILES+= ${DOC}.${_curformat}
 CLEANFILES+= PLIST.${_curformat}
 
 .if ${_cf} == "txt"
 .if ${LOCAL_CSS_SHEET} != ${CSS_SHEET}
 CLEANFILES+= ${LOCAL_CSS_SHEET}
 .endif
 
 .elif ${_cf} == "txt"
 CLEANFILES+= ${DOC}.html
 
 .elif ${_cf} == "pdb"
 _docs+= ${.CURDIR:T}.pdb
 CLEANFILES+= ${.CURDIR:T}.pdb
 
 .endif
 .endfor
 
 #
 # Build a list of install-${format}.${compress_format} targets to be
 # by "make install". Also, add ${DOC}.${format}.${compress_format} to
 # ${_docs} and ${CLEANFILES} so they get built/cleaned by "all" and
 # "clean".
 #
 
 .if defined(INSTALL_COMPRESSED) && !empty(INSTALL_COMPRESSED)
 .for _curformat in ${FORMATS}
 _cf=${_curformat}
 .for _curcomp in ${INSTALL_COMPRESSED}
 
 .if ${_cf} != "html-split"
 _curinst+= install-${_curformat}.${_curcomp}
 _docs+= ${DOC}.${_curformat}.${_curcomp}
 CLEANFILES+= ${DOC}.${_curformat}.${_curcomp}
 
 .if  ${_cf} == "pdb"
 _docs+= ${.CURDIR:T}.${_curformat}.${_curcomp}
 CLEANFILES+= ${.CURDIR:T}.${_curformat}.${_curcomp}
 
 .endif
 .endif
 .endfor
 .endfor
 .endif
 
 .MAIN: all
 
 all: ${_docs}
 
 ${DOC}.html: ${SRCS} ${LOCAL_IMAGES_LIB} ${LOCAL_IMAGES_PNG} ${LOCAL_CSS_SHEET}
 	${SGMLNORM} -c ${HTMLCATALOG} ${SRCS:S|^|${.CURDIR}/|} > ${.TARGET}
 .if !defined(NO_TIDY)
 	-${TIDY} ${TIDYOPTS} ${.TARGET}
 .endif
 
 ${DOC}.txt: ${DOC}.html
 	${HTML2TXT} ${HTML2TXTOPTS} ${.ALLSRC} > ${.TARGET}
 
 ${DOC}.pdb: ${DOC}.html ${LOCAL_IMAGES_LIB} ${LOCAL_IMAGES_PNG}
 	${HTML2PDB} ${HTML2PDBOPTS} ${DOC}.html ${.TARGET}
 
 ${.CURDIR:T}.pdb: ${DOC}.pdb
 	${LN} -f ${.ALLSRC} ${.TARGET}
 
 .if defined(INSTALL_COMPRESSED) && !empty(INSTALL_COMPRESSED)
 .for _curcomp in ${INSTALL_COMPRESSED}
 ${.CURDIR:T}.pdb.${_curcomp}: ${DOC}.pdb.${_curcomp}
 	${LN} -f ${.ALLSRC} ${.TARGET}
 .endfor
 .endif
 
 ${DOC}.tar: ${SRCS} ${LOCAL_IMAGES} ${LOCAL_CSS_SHEET}
 	${TAR} cf ${.TARGET} -C ${.CURDIR} ${SRCS} \
 		-C ${.OBJDIR} ${IMAGES} ${CSS_SHEET:T}
 
 #
 # Build targets for any formats we've missed that we don't handle.
 #
 .for _curformat in ${ALL_FORMATS}
 .if !target(${DOC}.${_curformat})
 ${DOC}.${_curformat}:
 	@${ECHO_CMD} \"${_curformat}\" is not a valid output format for this document.
 .endif
 .endfor
 
 
 # ------------------------------------------------------------------------
 #
 # Validation targets
 #
 
 #
 # Lets you quickly check that the document conforms to the DTD without
 # having to convert it to any other formats
 #
 
 lint validate:
 	${NSGMLS} -s -c ${HTMLCATALOG} ${MASTERDOC}
 
 
 # ------------------------------------------------------------------------
 #
 # Compress targets
 #
 
 #
 # The list of compression extensions this Makefile knows about. If you
 # add new compression schemes, add to this list (which is a list of
 # extensions, hence bz2, *not* bzip2) and extend the _PROG_COMPRESS_*
 # targets.
 #
 
 KNOWN_COMPRESS=	gz bz2 zip
 
 #
 # You can't build suffix rules to do compression, since you can't
 # wildcard the source suffix. So these are defined .USE, to be tacked on
 # as dependencies of the compress-* targets.
 #
 
 _PROG_COMPRESS_gz: .USE
 	${GZIP_CMD} < ${.ALLSRC} > ${.TARGET}
 
 _PROG_COMPRESS_bz2: .USE
 	${BZIP2_CMD} < ${.ALLSRC} > ${.TARGET}
 
 _PROG_COMPRESS_zip: .USE
 	${ZIP_CMD} ${.TARGET} ${.ALLSRC}
 
 #
 # Build a list of targets for each compression scheme and output format.
 # Don't compress the html-split output format.
 #
 .for _curformat in ${KNOWN_FORMATS}
 _cf=${_curformat}
 .for _curcompress in ${KNOWN_COMPRESS}
 ${DOC}.${_cf}.${_curcompress}: ${DOC}.${_cf} _PROG_COMPRESS_${_curcompress}
 .endfor
 .endfor
 
 #
 # Build targets for any formats we've missed that we don't handle.
 #
 .for _curformat in ${ALL_FORMATS}
 .for _curcompress in ${KNOWN_COMPRESS}
 .if !target(${DOC}.${_curformat}.${_curcompress})
 ${DOC}.${_curformat}.${_curcompress}:
 	@${ECHO_CMD} \"${_curformat}.${_curcompress}\" is not a valid output format for this document.
 .endif
 .endfor
 .endfor
 
 
 # ------------------------------------------------------------------------
 #
 # Install targets
 #
 # Build install-* targets, one per allowed value in FORMATS.
 #
 # "beforeinstall" and "afterinstall" are hooks in to this process.
 # Redefine them to do things before and after the files are installed,
 # respectively.
 
 #
 # Build a list of install-format targets to be installed. These will be
 # dependencies for the "realinstall" target.
 #
 
 .if !defined(INSTALL_ONLY_COMPRESSED) || empty(INSTALL_ONLY_COMPRESSED)
 _curinst+= ${FORMATS:S/^/install-/g}
 .endif
 
 realinstall: ${_curinst}
 
 .for _curformat in ${KNOWN_FORMATS}
 _cf=${_curformat}
 .if !target(install-${_cf})
 install-${_curformat}: ${DOC}.${_curformat}
 	@[ -d ${DESTDIR} ] || ${MKDIR} -p ${DESTDIR}
 	${INSTALL_DOCS} ${.ALLSRC} ${DESTDIR}
 .if !empty(CSS_SHEET)
 	${INSTALL_DOCS} ${CSS_SHEET} ${DESTDIR}
 .endif
 .for _curimage in ${IMAGES_LIB}
 	@[ -d ${DESTDIR}/${LOCAL_IMAGES_LIB_DIR}/${_curimage:H} ] || \
 		${MKDIR} -p ${DESTDIR}/${LOCAL_IMAGES_LIB_DIR}/${_curimage:H}
 	${INSTALL_DOCS} ${LOCAL_IMAGES_LIB_DIR}/${_curimage} \
 			${DESTDIR}/${LOCAL_IMAGES_LIB_DIR}/${_curimage:H}
 .endfor
 # Install the images.  First, loop over all the image names that contain a
 # directory seperator, make the subdirectories, and install.  Then loop over
 # the ones that don't contain a directory separator, and install them in the
 # top level.
 .for _curimage in ${IMAGES_PNG:M*/*}
 	${MKDIR} -p ${DESTDIR}/${_curimage:H}
 	${INSTALL_DOCS} ${.CURDIR}/${_curimage} ${DESTDIR}/${_curimage:H}
 .endfor
 .for _curimage in ${IMAGES_PNG:N*/*}
 	${INSTALL_DOCS} ${.CURDIR}/${_curimage} ${DESTDIR}
 .endfor
 .if ${_cf} == "pdb"
 	${LN} -f ${DESTDIR}/${.ALLSRC} ${DESTDIR}/${.CURDIR:T}.${_curformat}
 .endif
 
 .for _compressext in ${KNOWN_COMPRESS}
 install-${_cf}.${_compressext}: ${DOC}.${_cf}.${_compressext}
 	@[ -d ${DESTDIR} ] || ${MKDIR} -p ${DESTDIR}
 	${INSTALL_DOCS} ${.ALLSRC} ${DESTDIR}
 .endfor
 .endif
 .endfor
 
 #
 # Build install- targets for any formats we've missed that we don't handle.
 #
 
 .for _curformat in ${ALL_FORMATS}
 .if !target(install-${_curformat})
 install-${_curformat}:
 	@${ECHO_CMD} \"${_curformat}\" is not a valid output format for this document.
 
 .for _compressext in ${KNOWN_COMPRESS}
 install-${_curformat}.${_compressext}:
 	@${ECHO_CMD} \"${_curformat}.${_compressext}\" is not a valid output format for this document.
 .endfor
 .endif
 .endfor
 
 
 # ------------------------------------------------------------------------
 #
 # Package building
 #
 
 #
 # realpackage is what is called in each subdirectory when a package
 # target is called, or, rather, package calls realpackage in each
 # subdirectory as it goes.
 #
 # packagelist returns the list of targets that would be called during
 # package building.
 #
 
 realpackage: ${FORMATS:S/^/package-/}
 packagelist:
 	@${ECHO_CMD} ${FORMATS:S/^/package-/}
 
 #
 # Build a list of package targets for each output target.  Each package
 # target depends on the corresponding install target running.
 #
 
 .for _curformat in ${KNOWN_FORMATS}
 _cf=${_curformat}
 PLIST.${_curformat}: ${DOC}.${_curformat}
 	@${ECHO_CMD} ${DOC}.${_curformat} > PLIST.${_curformat}
 .if ${_cf} == "html" && \
     (!empty(LOCAL_IMAGES_LIB) || !empty(IMAGES_PNG) || !empty(CSS_SHEET))
 	@${ECHO_CMD} ${LOCAL_IMAGES_LIB} ${IMAGES_PNG} ${CSS_SHEET} | \
 		${XARGS} -n1 >> PLIST.${_curformat}
 .elif ${_cf} == "pdb"
 	@${ECHO_CMD} ${.CURDIR:T}.${_curformat} >> PLIST.${_curformat}
 .endif
 
 ${PACKAGES}/${.CURDIR:T}.${LANGCODE}.${_curformat}.tgz: PLIST.${_curformat}
 	@${PKG_CREATE} -v -f PLIST.${_curformat} -p ${DESTDIR} -s ${.OBJDIR} \
 		-c -"FDP ${.CURDIR:T} ${_curformat} package" \
 		-d -"FDP ${.CURDIR:T} ${_curformat} package" ${.TARGET}
 
 package-${_curformat}: ${PACKAGES}/${.CURDIR:T}.${LANGCODE}.${_curformat}.tgz
 .endfor
 
 #
 # Build install- targets for any formats we've missed that we don't handle.
 #
 
 .for _curformat in ${ALL_FORMATS}
 .if !target(package-${_curformat})
 package-${_curformat}:
 	@${ECHO_CMD} \"${_curformat}\" is not a valid output format for this document.
 .endif
 .endfor
 
 .if ${LOCAL_CSS_SHEET} != ${CSS_SHEET}
 ${LOCAL_CSS_SHEET}: ${CSS_SHEET}
 	${CP} -p ${.ALLSRC} ${.TARGET}
 .endif