# This is a replacement for bsd.lib.mk for the libc project to get it
# doing the Right Thing in XBS, which is substantially different than
# the BSD build system.
#
# The main problems arise when libc.a isn't meant to be static, but
# libc_static.a is.  We also build a debug version of the library
# in addition to shared, static, and profile.  Also, we build all 
# versions of libc with debugging enabled, unstripped.  The BSD style
# is to strip every object file after it is built but here, libc.a
# will get merged into the larger libSystem.dylib, which will eventually
# be stripped.  We also don't build a libc.dylib, since it will be
# munged into libSystem.dylib.
#
# And another difference, B&I wishes to build the 4 incarnations of Libc
# in parallel on different machines.  To do this, we must look at the
# RC_ProjectName variable (which B&I sets) to determine which of the 4
# versions of Libc we will be building.  Remember that the installhdrs
# pass should only be invoked on one of the 4 versions, and man pages
# should only be installed once as well.  Both of these get done when
# we're invoked as "Libc".

BSDMAKE = bsdmake -f Makefile

.PATH: .
.MAIN: all
all: libc.a libc_static.a libc_debug.a libc_profile.a
install: installhdrs install_libc.a install_libc_static.a \
	 install_libc_profile.a install_libc_debug.a \
	 autopatchman maninstall

.SUFFIXES:
.SUFFIXES: .o .po .So .do
.SUFFIXES: .S .s .c .cc .cpp .cxx .m .C
.SUFFIXES: -fbsd.c -nbsd.c -obsd.c -uuid.c
.SUFFIXES: .f .y .l .defs .h
.SUFFIXES: User.c User.o User.po User.So User.do
.SUFFIXES: Server.c Server.o Server.po Server.So Server.do

OBJS+=  ${SRCS:N*.h:R:S/$/.o/g}
DOBJS+= ${OBJS:.o=.do}
POBJS+= ${OBJS:.o=.po} ${STATICOBJS:.o=.po}
SOBJS+= ${OBJS:.o=.So}

#### Variant Rules ####################################################
# The following magic is used for variants to avoid the exponental explosion
# of suffix rules.  To add a variant, select a name (typically all-caps).
# Add that name to the VARIANTS variable.  Create a CFLAGS_XXX variable
# (XXX is the variant name) that contains the extra flags to pass to the
# compiler (currently, no slashes are permitted in the flags).  Then, just
# define a XXXSRCS variable with the names of the files to recompile with the
# additional flags.  For auto-patched files, don't use the auto-patched file
# name.  Just use the original file name.
#
# Note that this magic also deals with combinations of variants; e.g.,
# for two variants XXX and YYY, there are three variant combinations,
# XXX, XXX-YYY and YYY.  In this example, you can use XXX-YYYSRCS to
# specify sources that will build with both the CFLAGS_XXX and CFLAGS_YYY
# flags set.  The variants are always in alphabetic order.
#
VARIANTS= DARWINEXTSN INODE32 CANCELABLE PRE1050
# Append the 64-bit long double sources (ppc only)
.if (${MACHINE_ARCH} == ppc)
VARIANTS+= LDBL
MDSRCS += ldbl64.s
.endif
# build LEGACY variant except on LP64
.ifndef LP64
VARIANTS+= LEGACY
.endif

CFLAGS_LEGACY= -U__DARWIN_UNIX03 -D__DARWIN_UNIX03=0 -U__DARWIN_64_BIT_INO_T -D__DARWIN_64_BIT_INO_T=0 -DVARIANT_LEGACY
CFLAGS_LDBL= -mlong-double-64 -DLDBL_COMPAT
CFLAGS_DARWINEXTSN= -DVARIANT_DARWINEXTSN
CFLAGS_INODE32= -U__DARWIN_64_BIT_INO_T -D__DARWIN_64_BIT_INO_T=0 -DVARIANT_INODE32
CFLAGS_CANCELABLE= -DVARIANT_CANCELABLE
CFLAGS_PRE1050= -U__DARWIN_VERS_1050 -D__DARWIN_VERS_1050=0 -DVARIANT_PRE1050

.for _v in ${VARIANTS}
COMBOARGS+= ${_v}/${CFLAGS_${_v}}
.endfor
.ifdef COMBOARGS
# makeCombos is a perl script that creates all the variant combinations
# and all the combinations of flags
VARIANTCOMBOCFLAGS != ${.CURDIR}/makeCombos ${COMBOARGS}
.endif
# For each of the variant combinations as target (and possibly suffixed with
# _D, _P, and _S for the four kinds on compile styles, we create a subdirectory
# to do the compiling in, and then call $(BSDMAKE) with the new directory, and
# setting VARIANTCFLAGS, which are the extra flags to be added to CFLAGS.
.for _v in ${VARIANTCOMBOCFLAGS}
VARIANTCOMBOS+= ${_v:H:S,/,,}
${_v:H:S,/,,}:
.ifdef ${_v:H:S,/,,}SRCS
	mkdir -p ${MAKEOBJDIR}/${_v:H:S,/,,}; \
	MAKEOBJDIR="$(MAKEOBJDIR)/${_v:H:S,/,,}" VARIANTCFLAGS="-DBUILDING_VARIANT ${_v:T:S/@/ /g}" $(BSDMAKE) -C "${.CURDIR}" build_${_v:H:S,/,,}
.endif
${_v:H:S,/,,}_D:
.ifdef ${_v:H:S,/,,}SRCS
	mkdir -p ${MAKEOBJDIR}/${_v:H:S,/,,}; \
	MAKEOBJDIR="$(MAKEOBJDIR)/${_v:H:S,/,,}" VARIANTCFLAGS="-DBUILDING_VARIANT ${_v:T:S/@/ /g}" $(BSDMAKE) -C "${.CURDIR}" build_${_v:H:S,/,,}_D
.endif
${_v:H:S,/,,}_P:
.ifdef ${_v:H:S,/,,}SRCS
	mkdir -p ${MAKEOBJDIR}/${_v:H:S,/,,}; \
	MAKEOBJDIR="$(MAKEOBJDIR)/${_v:H:S,/,,}" VARIANTCFLAGS="-DBUILDING_VARIANT ${_v:T:S/@/ /g}" $(BSDMAKE) -C "${.CURDIR}" build_${_v:H:S,/,,}_P
.endif
${_v:H:S,/,,}_S:
.ifdef ${_v:H:S,/,,}SRCS
	mkdir -p ${MAKEOBJDIR}/${_v:H:S,/,,}; \
	MAKEOBJDIR="$(MAKEOBJDIR)/${_v:H:S,/,,}" VARIANTCFLAGS="-DBUILDING_VARIANT ${_v:T:S/@/ /g}" $(BSDMAKE) -C "${.CURDIR}" build_${_v:H:S,/,,}_S
.endif
.endfor

.for _v in ${VARIANTCOMBOS}
# Variant suffix rules so the filenames are unique and Libsystem won't complain
# because of ambiguities with -sectorder
.SUFFIXES: -${_v}.o -${_v}.do -${_v}.po -${_v}.So
.o-${_v}.o .do-${_v}.do .po-${_v}.po .So-${_v}.So:
	mv ${.IMPSRC} ${.TARGET}

# These are the build targets of the above $(BSDMAKE) calls, which just builds
# using the standard rules, but with the additional flags.
VARIANTOBJS+=  ${${_v}SRCS:N*.h:R:S/$/-${_v}.o/g:S,^,${_v}/,g}
build_${_v}:   ${${_v}SRCS:N*.h:R:S/$/-${_v}.o/g}
build_${_v}_D: ${${_v}SRCS:N*.h:R:S/$/-${_v}.do/g} ${${_v}SRCS2:N*.h:R:S/$/-${_v}.do/g}
build_${_v}_P: ${${_v}SRCS:N*.h:R:S/$/-${_v}.po/g} ${${_v}SRCS2:N*.h:R:S/$/-${_v}.po/g}
build_${_v}_S: ${${_v}SRCS:N*.h:R:S/$/-${_v}.So/g} ${${_v}SRCS2:N*.h:R:S/$/-${_v}.So/g}
.endfor
# These variables, plus VARIANTOBJS above, are the extra binaries that get
# added to the .a files.  Note that these objects are in subdirectories
# of the main build directory.
VARIANTDOBJS+= ${VARIANTOBJS:.o=.do}
VARIANTPOBJS+= ${VARIANTOBJS:.o=.po}
VARIANTSOBJS+= ${VARIANTOBJS:.o=.So}
#### FreeBSD Rules ##################################################
PREFBSDFLAGS= -I${.CURDIR}/fbsdcompat
FBSDFLAGS= -include _fbsd_compat_.h

-fbsd.c.o:
	${CC} -static \
	    ${PREFBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${FBSDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-fbsd.c.po:
	${CC} -pg -DPROFILE \
	    ${PREFBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${FBSDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-fbsd.c.So: 
	${CC} \
	    ${PREFBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${FBSDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-fbsd.c.do:
	${CC} -g -DDEBUG \
	    ${PREFBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${FBSDFLAGS} ${LIBCFLAGS} \
	    -c ${.IMPSRC} -o ${.TARGET}

#### NetBSD Rules ##################################################
PRENBSDFLAGS= -I${.CURDIR}/nbsdcompat
NBSDFLAGS= -include _nbsd_compat_.h

-nbsd.c.o:
	${CC} -static \
	    ${PRENBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${NBSDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-nbsd.c.po:
	${CC} -pg -DPROFILE \
	    ${PRENBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${NBSDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-nbsd.c.So: 
	${CC} \
	    ${PRENBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${NBSDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-nbsd.c.do:
	${CC} -g -DDEBUG \
	    ${PRENBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${NBSDFLAGS} ${LIBCFLAGS} \
	    -c ${.IMPSRC} -o ${.TARGET}

#### OpenBSD Rules ##################################################
PREOBSDFLAGS=
OBSDFLAGS=

-obsd.c.o:
	${CC} -static \
	    ${PREOBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${OBSDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-obsd.c.po:
	${CC} -pg -DPROFILE \
	    ${PREOBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${OBSDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-obsd.c.So: 
	${CC} \
	    ${PREOBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${OBSDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-obsd.c.do:
	${CC} -g -DDEBUG \
	    ${PREOBSDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${OBSDFLAGS} ${LIBCFLAGS} \
	    -c ${.IMPSRC} -o ${.TARGET}

#### UUID Rules ######################################################
PREUUIDFLAGS= -I${.CURDIR}/uuid
UUIDFLAGS= -include uuid-config.h

-uuid.c.o:
	${CC} -static \
	    ${PREUUIDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${UUIDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-uuid.c.po:
	${CC} -pg -DPROFILE \
	    ${PREUUIDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${UUIDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-uuid.c.So: 
	${CC} \
	    ${PREUUIDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${UUIDFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
-uuid.c.do:
	${CC} -g -DDEBUG \
	    ${PREUUIDFLAGS} ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${UUIDFLAGS} ${LIBCFLAGS} \
	    -c ${.IMPSRC} -o ${.TARGET}

#### Standard C Rules #################################################
# If you change any of these standard rule, make corresponding changes
# to the _STANDARD_* macros in Makefile.inc
#######################################################################
.c.o User.cUser.o Server.cServer.o:
	${CC} -static \
	    ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
.c.po User.cUser.po Server.cServer.po:
	${CC} -pg -DPROFILE \
	    ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
.c.So User.cUser.So Server.cServer.So: 
	${CC} \
	    ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${LIBCFLAGS} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
.c.do User.cUser.do Server.cServer.do:
	${CC} -g -DDEBUG \
	    ${PRECFLAGS} ${PRECFLAGS-${.IMPSRC:T}} \
	    ${CFLAGS} ${CFLAGS-${.IMPSRC:T}} \
	    ${VARIANTCFLAGS} ${LIBCFLAGS} \
	    -c ${.IMPSRC} -o ${.TARGET}

#### Standard Assembler Rules #########################################
.s.o .S.o:
	${CC} -static -x assembler-with-cpp \
	    ${PRECFLAGS:M-[BIDFU]*} ${PRECFLAGS-${.IMPSRC:T}:M-[BIDFU]*} \
	    ${CFLAGS:M-[BIDFU]*} ${CFLAGS-${.IMPSRC:T}:M-[BIDFU]*} ${AINC} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
.s.po .S.po:
	${CC} -pg -x assembler-with-cpp -DPROFILE \
	    ${PRECFLAGS:M-[BIDFU]*} ${PRECFLAGS-${.IMPSRC:T}:M-[BIDFU]*} \
	    ${CFLAGS:M-[BIDFU]*} ${CFLAGS-${.IMPSRC:T}:M-[BIDFU]*} ${AINC} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
.s.So .S.So:
	${CC} -x assembler-with-cpp \
	    ${PRECFLAGS:M-[BIDFU]*} ${PRECFLAGS-${.IMPSRC:T}:M-[BIDFU]*} \
	    ${CFLAGS:M-[BIDFU]*} ${CFLAGS-${.IMPSRC:T}:M-[BIDFU]*} ${AINC} \
	    -Os ${OPTIMIZE-${.IMPSRC:T}} -c ${.IMPSRC} -o ${.TARGET}
.s.do .S.do:
	${CC} -g -x assembler-with-cpp -DDEBUG \
	    ${PRECFLAGS:M-[BIDFU]*} ${PRECFLAGS-${.IMPSRC:T}:M-[BIDFU]*} \
	    ${CFLAGS:M-[BIDFU]*} ${CFLAGS-${.IMPSRC:T}:M-[BIDFU]*} ${AINC} \
	    -c ${.IMPSRC} -o ${.TARGET}

#### mig Rules ########################################################
.defs.h .defsUser.c .defsServer.c:
	mig -arch ${MACHINE_ARCH} -cc ${CC} -user ${.PREFIX}User.c -server ${.PREFIX}Server.c -header ${.PREFIX}.h ${.IMPSRC}

gen_mig_defs: ${SRVMIGHDRS} ${MIGHDRS}
gen_md_mig_defs: ${MD_MIGHDRS}

#### Library Rules ####################################################
lib${LIB}_static.a:: ${VARIANTCOMBOS} ${OBJS} ${STATICOBJS} 
	@${ECHO} building static ${LIB} library
	@rm -f lib${LIB}_static.a
	@${AR} cq lib${LIB}_static.a `lorder ${OBJS} ${STATICOBJS} ${VARIANTOBJS} | tsort -q` ${ARADD}
	${RANLIB} lib${LIB}_static.a

lib${LIB}_profile.a:: ${VARIANTCOMBOS:S/$/_P/g} ${POBJS} ${POBJS2}
	@${ECHO} building profiled ${LIB} library
	@rm -f lib${LIB}_profile.a
	@${AR} cq lib${LIB}_profile.a `lorder ${POBJS} ${VARIANTPOBJS} | tsort -q` ${ARADD}
	${RANLIB} lib${LIB}_profile.a

lib${LIB}_debug.a:: ${VARIANTCOMBOS:S/$/_D/g} ${DOBJS} ${DOBJS2}
	@${ECHO} building debug ${LIB} library
	@rm -f lib${LIB}_debug.a
	@${AR} cq lib${LIB}_debug.a `lorder ${DOBJS} ${VARIANTDOBJS} | tsort -q` ${ARADD}
	${RANLIB} lib${LIB}_debug.a

lib${LIB}.a:: ${VARIANTCOMBOS:S/$/_S/g} ${SOBJS} ${SOBJS2}
	@${ECHO} building standard ${LIB} library
	@rm -f lib${LIB}.a
	@${AR} cq lib${LIB}.a `lorder ${SOBJS} ${VARIANTSOBJS} | tsort -q` ${ARADD}
	${RANLIB} lib${LIB}.a

CLEANFILES += ${DOBJS} libc_static.a libc_profile.a libc_debug.a

INCDIR = ${DESTDIR}/usr/include
LOCINCDIR = ${DESTDIR}/usr/local/include
SYSTEMFRAMEWORK = ${DESTDIR}/System/Library/Frameworks/System.framework
PRIVHDRS = ${SYSTEMFRAMEWORK}/Versions/B/PrivateHeaders
KERNELFRAMEWORK = ${DESTDIR}/System/Library/Frameworks/Kernel.framework
PRIVKERNELHDRS = ${KERNELFRAMEWORK}/Versions/A/PrivateHeaders
INSTALLMODE != test `id -u` -eq 0 && echo 444 || echo 644

installhdrs-md: gen_md_mig_defs

installhdrs: gen_mig_defs
	mkdir -p ${INCDIR}/arpa
	mkdir -p ${INCDIR}/libkern
	mkdir -p ${INCDIR}/machine
	mkdir -p ${INCDIR}/malloc
	mkdir -p ${INCDIR}/objc
	mkdir -p ${INCDIR}/protocols
	mkdir -p ${INCDIR}/secure
	mkdir -p ${INCDIR}/sys
	mkdir -p ${INCDIR}/xlocale
	${INSTALL} -c -m ${INSTALLMODE} ${INSTHDRS} ${INCDIR}
	${INSTALL} -c -m ${INSTALLMODE} ${ARPA_INSTHDRS} ${INCDIR}/arpa
	${INSTALL} -c -m ${INSTALLMODE} ${LIBKERN_INSTHDRS} ${INCDIR}/libkern
	${INSTALL} -c -m ${INSTALLMODE} ${MACHINE_INSTHDRS} ${INCDIR}/machine
	${INSTALL} -c -m ${INSTALLMODE} ${MALLOC_INSTHDRS} ${INCDIR}/malloc
	${INSTALL} -c -m ${INSTALLMODE} ${OBJC_INSTHDRS} ${INCDIR}/objc
	${INSTALL} -c -m ${INSTALLMODE} ${PROTO_INSTHDRS} ${INCDIR}/protocols
	${INSTALL} -c -m ${INSTALLMODE} ${SECURE_INSTHDRS} ${INCDIR}/secure
	${INSTALL} -c -m ${INSTALLMODE} ${SYS_INSTHDRS} ${INCDIR}/sys
	${INSTALL} -c -m ${INSTALLMODE} ${XLOCALE_INSTHDRS} ${INCDIR}/xlocale
	mkdir -p ${LOCINCDIR}
	${INSTALL} -c -m ${INSTALLMODE} ${LOCALHDRS} ${LOCINCDIR}
	mkdir -p ${PRIVHDRS}/btree
	mkdir -p ${PRIVHDRS}/machine
	mkdir -p ${PRIVHDRS}/objc
	mkdir -p ${PRIVHDRS}/uuid
	mkdir -p ${PRIVHDRS}/sys
	mkdir -p ${PRIVKERNELHDRS}/uuid
	${INSTALL} -c -m ${INSTALLMODE} ${PRIV_INSTHDRS} ${PRIVHDRS}
	${INSTALL} -c -m ${INSTALLMODE} ${INSTBTREEPRIVHDRS_AUTOPATCH} ${PRIVHDRS}/btree
	${INSTALL} -c -m ${INSTALLMODE} ${SRCROOT}/internat/NXCType.h ${PRIVHDRS}/objc
	mv ${DESTDIR}/usr/include/asm.h ${PRIVHDRS}/machine
	${INSTALL} -c -m ${INSTALLMODE} ${SYS_INSTHDRS} ${PRIVHDRS}/sys
	${INSTALL} -c -m ${INSTALLMODE} ${PRIVUUID_INSTHDRS} ${PRIVHDRS}/uuid
	${INSTALL} -c -m ${INSTALLMODE} ${PRIVUUID_INSTHDRS} ${PRIVKERNELHDRS}/uuid
.for _h in ${STRIP_HDRS}
	chmod u+w ${INCDIR}/${_h}
	ed - ${INCDIR}/${_h} < ${.CURDIR}/strip-header.ed
	chmod u-w ${INCDIR}/${_h}
.endfor
	${INSTALL} -c -m 644 /usr/include/AvailabilityMacros.h ${OBJROOT}/available.h
	ex - ${OBJROOT}/available.h < ${.CURDIR}/available.ex
	${INSTALL} -c -m ${INSTALLMODE} ${OBJROOT}/available.h ${INCDIR}

install_lib${LIB}_static.a:
	${INSTALL} -c -m ${INSTALLMODE} lib${LIB}_static.a ${DESTDIR}/usr/local/lib/system/
install_lib${LIB}_profile.a:
	${INSTALL} -c -m ${INSTALLMODE} lib${LIB}_profile.a ${DESTDIR}/usr/local/lib/system
install_lib${LIB}_debug.a:
	${INSTALL} -c -m ${INSTALLMODE} lib${LIB}_debug.a ${DESTDIR}/usr/local/lib/system/
install_lib${LIB}.a:
	${INSTALL} -c -m ${INSTALLMODE} lib${LIB}.a ${DESTDIR}/usr/local/lib/system/

autopatchman: ${AUTOPATCHMAN}

copyfiles:
.if !empty $(COPYFILES)
	$(INSTALL) -c -m 444 ${COPYFILES} ${DESTDIR}/usr/local/lib/system
.endif
.if !empty $(MDCOPYFILES)
	$(INSTALL) -c -m 444 ${MDCOPYFILES} ${DESTDIR}/usr/local/lib/system
.endif

clean:
	rm -f ${OBJS} ${POBJS} ${DOBJS} ${SOBJS} ${CLEANFILES}
	rm -f lib${LIB}.a lib${LIB}_static.a lib${LIB}_profile.a \
		lib${LIB}_debug.a