Index: head/share/mk/bsd.files.mk
===================================================================
--- head/share/mk/bsd.files.mk	(revision 99342)
+++ head/share/mk/bsd.files.mk	(revision 99343)
@@ -1,68 +1,69 @@
 # $FreeBSD$
 
 .if !target(__<bsd.init.mk>__)
 .error bsd.files.mk cannot be included directly.
 .endif
 
 FILESGROUPS?=	FILES
 
 .if !target(buildfiles)
 .for group in ${FILESGROUPS}
 buildfiles: ${${group}}
 .endfor
 .endif
 
 all: buildfiles
 
 .if !target(installfiles)
 .for group in ${FILESGROUPS}
 .if defined(${group}) && !empty(${group})
 
 ${group}OWN?=	${SHAREOWN}
 ${group}GRP?=	${SHAREGRP}
 ${group}MODE?=	${SHAREMODE}
 ${group}DIR?=	${BINDIR}
 
 _${group}FILES=
 .for file in ${${group}}
 .if defined(${group}OWN_${file:T}) || defined(${group}GRP_${file:T}) || \
     defined(${group}MODE_${file:T}) || defined(${group}DIR_${file:T}) || \
     defined(${group}NAME_${file:T})
 ${group}OWN_${file:T}?=	${${group}OWN}
 ${group}GRP_${file:T}?=	${${group}GRP}
 ${group}MODE_${file:T}?=	${${group}MODE}
 ${group}DIR_${file:T}?=	${${group}DIR}
 .if defined(${group}NAME)
 ${group}NAME_${file:T}?=	${${group}NAME}
 .else
 ${group}NAME_${file:T}?=	${file:T}
 .endif
 installfiles: _${group}INS_${file:T}
 _${group}INS_${file:T}: ${file}
 	${INSTALL} ${COPY} -o ${${group}OWN_${.ALLSRC:T}} \
 	    -g ${${group}GRP_${.ALLSRC:T}} -m ${${group}MODE_${.ALLSRC:T}} \
 	    ${.ALLSRC} \
 	    ${DESTDIR}${${group}DIR_${.ALLSRC:T}}/${${group}NAME_${.ALLSRC:T}}
 .else
 _${group}FILES+= ${file}
 .endif
 .endfor
 .if !empty(_${group}FILES)
 installfiles: _${group}INS
 _${group}INS: ${_${group}FILES}
 .if defined(${group}NAME)
 	${INSTALL} ${COPY} -o ${${group}OWN} -g ${${group}GRP} \
 	    -m ${${group}MODE} ${.ALLSRC} \
 	    ${DESTDIR}${${group}DIR}/${${group}NAME}
 .else
 	${INSTALL} ${COPY} -o ${${group}OWN} -g ${${group}GRP} \
 	    -m ${${group}MODE} ${.ALLSRC} ${DESTDIR}${${group}DIR}
 .endif
 .endif
 
 .endif defined(${group}) && !empty(${group})
 .endfor
 
 .endif !target(installfiles)
 
 realinstall: installfiles
+.ORDER: beforeinstall installfiles
Index: head/share/mk/bsd.incs.mk
===================================================================
--- head/share/mk/bsd.incs.mk	(revision 99342)
+++ head/share/mk/bsd.incs.mk	(revision 99343)
@@ -1,79 +1,80 @@
 # $FreeBSD$
 
 .if !target(__<bsd.init.mk>__)
 .error bsd.incs.mk cannot be included directly.
 .endif
 
 INCSGROUPS?=	INCS
 
 .if !target(buildincludes)
 .for group in ${INCSGROUPS}
 buildincludes: ${${group}}
 .endfor
 .endif
 
 all: buildincludes
 
 .if !target(installincludes)
 .for group in ${INCSGROUPS}
 .if defined(${group}) && !empty(${group})
 
 ${group}OWN?=	${BINOWN}
 ${group}GRP?=	${BINGRP}
 ${group}MODE?=	${NOBINMODE}
 ${group}DIR?=	${INCLUDEDIR}
 
 _${group}INCS=
 .for header in ${${group}}
 .if defined(${group}OWN_${header:T}) || defined(${group}GRP_${header:T}) || \
     defined(${group}MODE_${header:T}) || defined(${group}DIR_${header:T}) || \
     defined(${group}NAME_${header:T})
 ${group}OWN_${header:T}?=	${${group}OWN}
 ${group}GRP_${header:T}?=	${${group}GRP}
 ${group}MODE_${header:T}?=	${${group}MODE}
 ${group}DIR_${header:T}?=	${${group}DIR}
 .if defined(${group}NAME)
 ${group}NAME_${header:T}?=	${${group}NAME}
 .else
 ${group}NAME_${header:T}?=	${header:T}
 .endif
 installincludes: _${group}INS_${header:T}
 _${group}INS_${header:T}: ${header}
 	${INSTALL} -C -o ${${group}OWN_${.ALLSRC:T}} \
 	    -g ${${group}GRP_${.ALLSRC:T}} -m ${${group}MODE_${.ALLSRC:T}} \
 	    ${.ALLSRC} \
 	    ${DESTDIR}${${group}DIR_${.ALLSRC:T}}/${${group}NAME_${.ALLSRC:T}}
 .else
 _${group}INCS+= ${header}
 .endif
 .endfor
 .if !empty(_${group}INCS)
 installincludes: _${group}INS
 _${group}INS: ${_${group}INCS}
 .if defined(${group}NAME)
 	${INSTALL} -C -o ${${group}OWN} -g ${${group}GRP} -m ${${group}MODE} \
 	    ${.ALLSRC} ${DESTDIR}${${group}DIR}/${${group}NAME}
 .else
 	${INSTALL} -C -o ${${group}OWN} -g ${${group}GRP} -m ${${group}MODE} \
 	    ${.ALLSRC} ${DESTDIR}${${group}DIR}
 .endif
 .endif
 
 .endif defined(${group}) && !empty(${group})
 .endfor
 
 .if defined(INCSLINKS) && !empty(INCSLINKS)
 installincludes:
 	@set ${INCSLINKS}; \
 	while test $$# -ge 2; do \
 		l=$$1; \
 		shift; \
 		t=${DESTDIR}$$1; \
 		shift; \
 		${ECHO} $$t -\> $$l; \
 		ln -fs $$l $$t; \
 	done; true
 .endif
 .endif !target(installincludes)
 
 realinstall: installincludes
+.ORDER: beforeinstall installincludes
Index: head/share/mk/bsd.lib.mk
===================================================================
--- head/share/mk/bsd.lib.mk	(revision 99342)
+++ head/share/mk/bsd.lib.mk	(revision 99343)
@@ -1,349 +1,351 @@
 #	from: @(#)bsd.lib.mk	5.26 (Berkeley) 5/2/91
 # $FreeBSD$
 #
 
 .include <bsd.init.mk>
 
 # Set up the variables controlling shared libraries.  After this section,
 # SHLIB_NAME will be defined only if we are to create a shared library.
 # SHLIB_LINK will be defined only if we are to create a link to it.
 # INSTALL_PIC_ARCHIVE will be defined only if we are to create a PIC archive.
 .if defined(NOPIC)
 .undef SHLIB_NAME
 .undef INSTALL_PIC_ARCHIVE
 .else
 .if ${OBJFORMAT} == elf
 .if !defined(SHLIB_NAME) && defined(SHLIB_MAJOR)
 SHLIB_NAME=	lib${LIB}.so.${SHLIB_MAJOR}
 SHLIB_LINK?=	lib${LIB}.so
 .endif
 SONAME?=	${SHLIB_NAME}
 .else
 .if defined(SHLIB_MAJOR) && defined(SHLIB_MINOR)
 SHLIB_NAME?=	lib${LIB}.so.${SHLIB_MAJOR}.${SHLIB_MINOR}
 .endif
 .endif
 .endif
 
 .if defined(DEBUG_FLAGS)
 CFLAGS+= ${DEBUG_FLAGS}
 .endif
 
 .if !defined(DEBUG_FLAGS)
 STRIP?=	-s
 .endif
 
 .if ${OBJFORMAT} != aout || make(checkdpadd) || defined(NEED_LIBNAMES)
 .include <bsd.libnames.mk>
 .endif
 
 # prefer .s to a .c, add .po, remove stuff not used in the BSD libraries
 # .So used for PIC object files
 .SUFFIXES:
 .SUFFIXES: .out .o .po .So .S .s .asm .c .cc .cpp .cxx .m .C .f .y .l .ln
 
 .if !defined(PICFLAG)
 .if ${MACHINE_ARCH} == "sparc64"
 PICFLAG=-fPIC
 .else
 PICFLAG=-fpic
 .endif
 .endif
 
 .c.ln:
 	${LINT} ${LINTOBJFLAGS} ${CFLAGS:M-[DIU]*} ${.IMPSRC} || \
 	    touch ${.TARGET}
 
 .cc.ln .C.ln .cpp.ln .cxx.ln:
 	${LINT} ${LINTOBJFLAGS} ${CXXFLAGS:M-[DIU]*} ${.IMPSRC} || \
 	    touch ${.TARGET}
 
 .c.o:
 	${CC} ${CFLAGS} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .c.po:
 	${CC} -pg ${CFLAGS} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} -o ${.TARGET}.tmp -X -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .c.So:
 	${CC} ${PICFLAG} -DPIC ${CFLAGS} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} ${LDFLAGS} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .cc.o .C.o .cpp.o .cxx.o:
 	${CXX} ${CXXFLAGS} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .cc.po .C.po .cpp.po .cxx.po:
 	${CXX} -pg ${CXXFLAGS} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} -o ${.TARGET}.tmp -X -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .cc.So .C.So .cpp.So .cxx.So:
 	${CXX} ${PICFLAG} -DPIC ${CXXFLAGS} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} ${LDFLAGS} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .f.o:
 	${FC} ${FFLAGS} -o ${.TARGET} -c ${.IMPSRC} 
 	@${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .f.po:
 	${FC} -pg ${FFLAGS} -o ${.TARGET} -c ${.IMPSRC} 
 	@${LD} -o ${.TARGET}.tmp -X -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .f.So:
 	${FC} ${PICFLAG} -DPIC ${FFLAGS} -o ${.TARGET} -c ${.IMPSRC}
 	@${LD} ${LDFLAGS} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .m.o:
 	${OBJC} ${OBJCFLAGS} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .m.po:
 	${OBJC} ${OBJCFLAGS} -pg -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} -o ${.TARGET}.tmp -X -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .m.So:
 	${OBJC} ${PICFLAG} -DPIC ${OBJCFLAGS} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} ${LDFLAGS} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .s.o .asm.o:
 	${CC} -x assembler-with-cpp ${CFLAGS} ${AINC} -c \
 	    ${.IMPSRC} -o ${.TARGET}
 	@${LD} ${LDFLAGS} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .s.po .asm.po:
 	${CC} -x assembler-with-cpp -DPROF ${CFLAGS} ${AINC} -c \
 	    ${.IMPSRC} -o ${.TARGET}
 	@${LD} ${LDFLAGS} -o ${.TARGET}.tmp -X -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .s.So .asm.So:
 	${CC} -x assembler-with-cpp ${PICFLAG} -DPIC ${CFLAGS} \
 	    ${AINC} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .S.o:
 	${CC} ${CFLAGS} ${AINC} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} ${LDFLAGS} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .S.po:
 	${CC} -DPROF ${CFLAGS} ${AINC} -c ${.IMPSRC} -o ${.TARGET}
 	@${LD} ${LDFLAGS} -o ${.TARGET}.tmp -X -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 .S.So:
 	${CC} ${PICFLAG} -DPIC ${CFLAGS} ${AINC} -c ${.IMPSRC} \
 	    -o ${.TARGET}
 	@${LD} -o ${.TARGET}.tmp -x -r ${.TARGET}
 	@mv ${.TARGET}.tmp ${.TARGET}
 
 all: objwarn
 
 .if defined(LIB) && !empty(LIB)
 _LIBS=		lib${LIB}.a
 OBJS+=		${SRCS:N*.h:R:S/$/.o/}
 
 lib${LIB}.a: ${OBJS} ${STATICOBJS}
 	@${ECHO} building static ${LIB} library
 	@rm -f ${.TARGET}
 	@${AR} cq ${.TARGET} `lorder ${OBJS} ${STATICOBJS} | tsort -q` ${ARADD}
 	${RANLIB} ${.TARGET}
 
 .if !defined(INTERNALLIB)
 
 .if !defined(NOPROFILE)
 _LIBS+=		lib${LIB}_p.a
 POBJS+=		${OBJS:.o=.po} ${STATICOBJS:.o=.po}
 
 lib${LIB}_p.a: ${POBJS}
 	@${ECHO} building profiled ${LIB} library
 	@rm -f ${.TARGET}
 	@${AR} cq ${.TARGET} `lorder ${POBJS} | tsort -q` ${ARADD}
 	${RANLIB} ${.TARGET}
 .endif
 
 SOBJS+=		${OBJS:.o=.So}
 
 .if defined(SHLIB_NAME)
 _LIBS+=		${SHLIB_NAME}
 
 ${SHLIB_NAME}: ${SOBJS}
 	@${ECHO} building shared library ${SHLIB_NAME}
 	@rm -f ${.TARGET} ${SHLIB_LINK}
 .if defined(SHLIB_LINK)
 	@ln -fs ${.TARGET} ${SHLIB_LINK}
 .endif
 .if ${OBJFORMAT} == aout
 	@${CC} -shared -Wl,-x,-assert,pure-text \
 	    -o ${.TARGET} \
 	    `lorder ${SOBJS} | tsort -q` ${LDADD}
 .else
 	@${CC} ${LDFLAGS} -shared -Wl,-x \
 	    -o ${.TARGET} -Wl,-soname,${SONAME} \
 	    `lorder ${SOBJS} | tsort -q` ${LDADD}
 .endif
 .endif
 
 .if defined(INSTALL_PIC_ARCHIVE)
 _LIBS+=		lib${LIB}_pic.a
 
 lib${LIB}_pic.a: ${SOBJS}
 	@${ECHO} building special pic ${LIB} library
 	@rm -f ${.TARGET}
 	@${AR} cq ${.TARGET} ${SOBJS} ${ARADD}
 	${RANLIB} ${.TARGET}
 .endif
 
 .if defined(WANT_LINT)
 LINTLIB=	llib-l${LIB}.ln
 _LIBS+=		${LINTLIB}
 LINTOBJS+=	${SRCS:M*.c:.c=.ln}
 
 ${LINTLIB}: ${LINTOBJS}
 	@${ECHO} building lint library ${.TARGET}
 	@rm -f ${.TARGET}
 	${LINT} ${LINTLIBFLAGS} ${CFLAGS:M-[DIU]*} ${.ALLSRC}
 .endif
 
 .endif !defined(INTERNALLIB)
 
 all: ${_LIBS}
 
 .endif defined(LIB) && !empty(LIB)
 
 .if !defined(NOMAN)
 all: _manpages
 .endif
 
 .if !target(clean)
 clean:
 .if defined(CLEANFILES) && !empty(CLEANFILES)
 	rm -f ${CLEANFILES}
 .endif
 .if defined(LIB) && !empty(LIB)
 	rm -f a.out ${OBJS} ${OBJS:S/$/.tmp/} ${STATICOBJS}
 .if !defined(INTERNALLIB)
 .if !defined(NOPROFILE)
 	rm -f ${POBJS} ${POBJS:S/$/.tmp/}
 .endif
 	rm -f ${SOBJS} ${SOBJS:.So=.so} ${SOBJS:S/$/.tmp/}
 .if defined(SHLIB_NAME)
 	rm -f ${SHLIB_LINK} lib${LIB}.so.* lib${LIB}.so
 .endif
 .if defined(WANT_LINT)
 	rm -f ${LINTOBJS}
 .endif
 .endif !defined(INTERNALLIB)
 	rm -f ${_LIBS}
 .endif defined(LIB) && !empty(LIB)
 .if defined(CLEANDIRS) && !empty(CLEANDIRS)
 	rm -rf ${CLEANDIRS}
 .endif
 .endif
 
 _EXTRADEPEND:
 	@TMP=_depend$$$$; \
 	sed -e 's/^\([^\.]*\).o[ ]*:/\1.o \1.po \1.So:/' < ${DEPENDFILE} \
 	    > $$TMP; \
 	mv $$TMP ${DEPENDFILE}
 .if !defined(NOEXTRADEPEND) && defined(SHLIB_NAME)
 .if ${OBJFORMAT} == aout
 	echo ${SHLIB_NAME}: \
 	    `${CC} -shared -Wl,-f ${LDADD}` \
 	    >> ${DEPENDFILE}
 .else
 .if defined(DPADD) && !empty(DPADD)
 	echo ${SHLIB_NAME}: ${DPADD} >> ${DEPENDFILE}
 .endif
 .endif
 .endif
 
 .if !target(install)
 
 .if defined(PRECIOUSLIB) && !defined(NOFSCHG)
 SHLINSTALLFLAGS+= -fschg
 .endif
 
 _INSTALLFLAGS:=	${INSTALLFLAGS}
 .for ie in ${INSTALLFLAGS_EDIT}
 _INSTALLFLAGS:=	${_INSTALLFLAGS${ie}}
 .endfor
 _SHLINSTALLFLAGS:=	${SHLINSTALLFLAGS}
 .for ie in ${INSTALLFLAGS_EDIT}
 _SHLINSTALLFLAGS:=	${_SHLINSTALLFLAGS${ie}}
 .endfor
 
 .if defined(LIB) && !empty(LIB) && !defined(INTERNALLIB)
 realinstall: _libinstall
+.ORDER: beforeinstall _libinstall
 _libinstall:
 .if !defined(NOINSTALLLIB)
 	${INSTALL} -C -o ${LIBOWN} -g ${LIBGRP} -m ${LIBMODE} \
 	    ${_INSTALLFLAGS} lib${LIB}.a ${DESTDIR}${LIBDIR}
 .endif
 .if !defined(NOPROFILE)
 	${INSTALL} -C -o ${LIBOWN} -g ${LIBGRP} -m ${LIBMODE} \
 	    ${_INSTALLFLAGS} lib${LIB}_p.a ${DESTDIR}${LIBDIR}
 .endif
 .if defined(SHLIB_NAME)
 	${INSTALL} ${COPY} ${STRIP} -o ${LIBOWN} -g ${LIBGRP} -m ${LIBMODE} \
 	    ${_INSTALLFLAGS} ${_SHLINSTALLFLAGS} \
 	    ${SHLIB_NAME} ${DESTDIR}${SHLIBDIR}
 .if defined(SHLIB_LINK)
 	ln -fs ${SHLIB_NAME} ${DESTDIR}${SHLIBDIR}/${SHLIB_LINK}
 .endif
 .endif
 .if defined(INSTALL_PIC_ARCHIVE)
 	${INSTALL} ${COPY} -o ${LIBOWN} -g ${LIBGRP} -m ${LIBMODE} \
 	    ${_INSTALLFLAGS} lib${LIB}_pic.a ${DESTDIR}${LIBDIR}
 .endif
 .if defined(WANT_LINT)
 	${INSTALL} ${COPY} -o ${LIBOWN} -g ${LIBGRP} -m ${LIBMODE} \
 	    ${_INSTALLFLAGS} ${LINTLIB} ${DESTDIR}${LINTLIBDIR}
 .endif
 .endif defined(LIB) && !empty(LIB) && !defined(INTERNALLIB)
 
 .include <bsd.files.mk>
 .include <bsd.incs.mk>
 .include <bsd.links.mk>
 
 .if !defined(NOMAN)
 realinstall: _maninstall
+.ORDER: beforeinstall _maninstall
 .endif
 
 .endif
 
 .if !target(lint)
 lint: ${SRCS:M*.c}
 	${LINT} ${LINTOBJFLAGS} ${CFLAGS:M-[DIU]*} ${.ALLSRC}
 .endif
 
 .if !defined(NOMAN)
 .include <bsd.man.mk>
 .endif
 
 .include <bsd.dep.mk>
 
 .if defined(LIB) && !empty(LIB)
 .if !exists(${.OBJDIR}/${DEPENDFILE})
 ${OBJS} ${STATICOBJS} ${POBJS} ${SOBJS}: ${SRCS:M*.h}
 .endif
 .endif
 
 .include <bsd.obj.mk>
 
 .include <bsd.sys.mk>
Index: head/share/mk/bsd.links.mk
===================================================================
--- head/share/mk/bsd.links.mk	(revision 99342)
+++ head/share/mk/bsd.links.mk	(revision 99343)
@@ -1,30 +1,31 @@
 # $FreeBSD$
 
 .if !target(__<bsd.init.mk>__)
 .error bsd.links.mk cannot be included directly.
 .endif
 
 afterinstall: _installlinks
+.ORDER: realinstall _installlinks
 _installlinks:
 .if defined(LINKS) && !empty(LINKS)
 	@set ${LINKS}; \
 	while test $$# -ge 2; do \
 		l=${DESTDIR}$$1; \
 		shift; \
 		t=${DESTDIR}$$1; \
 		shift; \
 		${ECHO} $$t -\> $$l; \
 		ln -f $$l $$t; \
 	done; true
 .endif
 .if defined(SYMLINKS) && !empty(SYMLINKS)
 	@set ${SYMLINKS}; \
 	while test $$# -ge 2; do \
 		l=$$1; \
 		shift; \
 		t=${DESTDIR}$$1; \
 		shift; \
 		${ECHO} $$t -\> $$l; \
 		ln -fs $$l $$t; \
 	done; true
 .endif
Index: head/share/mk/bsd.prog.mk
===================================================================
--- head/share/mk/bsd.prog.mk	(revision 99342)
+++ head/share/mk/bsd.prog.mk	(revision 99343)
@@ -1,198 +1,201 @@
 #	from: @(#)bsd.prog.mk	5.26 (Berkeley) 6/25/91
 # $FreeBSD$
 
 .include <bsd.init.mk>
 
 .SUFFIXES: .out .o .c .cc .cpp .cxx .C .m .y .l .s .S .asm
 
 CFLAGS+=${COPTS} ${DEBUG_FLAGS}
 
 .if !defined(DEBUG_FLAGS)
 STRIP?=	-s
 .endif
 
 .if defined(NOSHARED) && ( ${NOSHARED} != "no" && ${NOSHARED} != "NO" )
 LDFLAGS+= -static
 .endif
 
 .if defined(PROG_CXX)
 PROG=	${PROG_CXX}
 .endif
 
 .if defined(PROG)
 .if defined(SRCS)
 
 # If there are Objective C sources, link with Objective C libraries.
 .if ${SRCS:M*.m} != ""
 OBJCLIBS?= -lobjc
 LDADD+=	${OBJCLIBS}
 .endif
 
 OBJS+=  ${SRCS:N*.h:R:S/$/.o/g}
 
 ${PROG}: ${OBJS}
 .if defined(PROG_CXX)
 	${CXX} ${CXXFLAGS} ${LDFLAGS} -o ${.TARGET} ${OBJS} ${LDADD}
 .else
 	${CC} ${CFLAGS} ${LDFLAGS} -o ${.TARGET} ${OBJS} ${LDADD}
 .endif
 
 .else !defined(SRCS)
 
 .if !target(${PROG})
 .if defined(PROG_CXX)
 SRCS=	${PROG}.cc
 .else
 SRCS=	${PROG}.c
 .endif
 
 # Always make an intermediate object file because:
 # - it saves time rebuilding when only the library has changed
 # - the name of the object gets put into the executable symbol table instead of
 #   the name of a variable temporary object.
 # - it's useful to keep objects around for crunching.
 OBJS=	${PROG}.o
 
 ${PROG}: ${OBJS}
 .if defined(PROG_CXX)
 	${CXX} ${CXXFLAGS} ${LDFLAGS} -o ${.TARGET} ${OBJS} ${LDADD}
 .else
 	${CC} ${CFLAGS} ${LDFLAGS} -o ${.TARGET} ${OBJS} ${LDADD}
 .endif
 .endif
 
 .endif
 
 .if	!defined(NOMAN) && !defined(MAN) && \
 	!defined(MAN1) && !defined(MAN2) && !defined(MAN3) && \
 	!defined(MAN4) && !defined(MAN5) && !defined(MAN6) && \
 	!defined(MAN7) && !defined(MAN8) && !defined(MAN9) && \
 	!defined(MAN1aout)
 MAN=	${PROG}.1
 MAN1=	${MAN}
 .endif
 .endif
 
 all: objwarn ${PROG} ${SCRIPTS}
 .if !defined(NOMAN)
 all: _manpages
 .endif
 
 CLEANFILES+= ${PROG} ${OBJS}
 
 .if defined(PROG)
 _EXTRADEPEND:
 .if ${OBJFORMAT} == aout
 	echo ${PROG}: `${CC} -Wl,-f ${CFLAGS} ${LDFLAGS} \
 	    ${LDADD:S/^/-Wl,/}` >> ${DEPENDFILE}
 .else
 	echo ${PROG}: ${LIBC} ${DPADD} >> ${DEPENDFILE}
 .if defined(PROG_CXX)
 	echo ${PROG}: ${LIBSTDCPLUSPLUS} >> ${DEPENDFILE}
 .endif
 .endif
 .endif
 
 .if !target(install)
 
 _INSTALLFLAGS:=	${INSTALLFLAGS}
 .for ie in ${INSTALLFLAGS_EDIT}
 _INSTALLFLAGS:=	${_INSTALLFLAGS${ie}}
 .endfor
 
 .if !target(realinstall)
 realinstall: _proginstall
+.ORDER: beforeinstall _proginstall
 _proginstall:
 .if defined(PROG)
 .if defined(PROGNAME)
 	${INSTALL} ${COPY} ${STRIP} -o ${BINOWN} -g ${BINGRP} -m ${BINMODE} \
 	    ${_INSTALLFLAGS} ${PROG} ${DESTDIR}${BINDIR}/${PROGNAME}
 .else
 	${INSTALL} ${COPY} ${STRIP} -o ${BINOWN} -g ${BINGRP} -m ${BINMODE} \
 	    ${_INSTALLFLAGS} ${PROG} ${DESTDIR}${BINDIR}
 .endif
 .endif
 .if defined(HIDEGAME)
 	(cd ${DESTDIR}${ORIGBINDIR}; ln -fs dm ${PROG}; \
 	    chown -h ${BINOWN}:${ORIGBINGRP} ${PROG})
 .endif
 .endif !target(realinstall)
 
 .if defined(SCRIPTS) && !empty(SCRIPTS)
 realinstall: _scriptsinstall
+.ORDER: beforeinstall _scriptsinstall
 
 SCRIPTSDIR?=	${BINDIR}
 SCRIPTSOWN?=	${BINOWN}
 SCRIPTSGRP?=	${BINGRP}
 SCRIPTSMODE?=	${BINMODE}
 
 .for script in ${SCRIPTS}
 .if defined(SCRIPTSNAME)
 SCRIPTSNAME_${script:T}?=	${SCRIPTSNAME}
 .else
 SCRIPTSNAME_${script:T}?=	${script:T:R}
 .endif
 SCRIPTSDIR_${script:T}?=	${SCRIPTSDIR}
 SCRIPTSOWN_${script:T}?=	${SCRIPTSOWN}
 SCRIPTSGRP_${script:T}?=	${SCRIPTSGRP}
 SCRIPTSMODE_${script:T}?=	${SCRIPTSMODE}
 _scriptsinstall: _SCRIPTSINS_${script:T}
 _SCRIPTSINS_${script:T}: ${script}
 	${INSTALL} ${COPY} -o ${SCRIPTSOWN_${.ALLSRC:T}} \
 	    -g ${SCRIPTSGRP_${.ALLSRC:T}} -m ${SCRIPTSMODE_${.ALLSRC:T}} \
 	    ${.ALLSRC} \
 	    ${DESTDIR}${SCRIPTSDIR_${.ALLSRC:T}}/${SCRIPTSNAME_${.ALLSRC:T}}
 .endfor
 .endif
 
 NLSNAME?=	${PROG}
 .include <bsd.nls.mk>
 
 .include <bsd.files.mk>
 .include <bsd.incs.mk>
 .include <bsd.links.mk>
 
 .if !defined(NOMAN)
 realinstall: _maninstall
+.ORDER: beforeinstall _maninstall
 .endif
 
 .endif
 
 .if !target(lint)
 lint: ${SRCS}
 .if defined(PROG)
 	${LINT} ${LINTFLAGS} ${CFLAGS:M-[DIU]*} ${.ALLSRC} | more 2>&1
 .endif
 .endif
 
 .if defined(NOTAGS)
 tags:
 .endif
 
 .if !target(tags)
 tags: ${SRCS}
 .if defined(PROG)
 	@cd ${.CURDIR} && gtags ${GTAGSFLAGS} ${.OBJDIR}
 .if defined(HTML)
 	@cd ${.CURDIR} && htags ${HTAGSFLAGS} -d ${.OBJDIR} ${.OBJDIR}
 .endif
 .endif
 .endif
 
 .if !defined(NOMAN)
 .include <bsd.man.mk>
 .endif
 
 .if ${OBJFORMAT} != aout || make(checkdpadd) || defined(NEED_LIBNAMES)
 .include <bsd.libnames.mk>
 .endif
 
 .include <bsd.dep.mk>
 
 .if defined(PROG) && !exists(${.OBJDIR}/${DEPENDFILE})
 ${OBJS}: ${SRCS:M*.h}
 .endif
 
 .include <bsd.obj.mk>
 
 .include <bsd.sys.mk>