24796718b9
* Introduce build variable HAIKU_IMAGE_ADDITIONAL_PACKAGES which can be set to add additional packages to the image. * Use HAIKU_IMAGE_ADDITIONAL_PACKAGES to support specifying a list of additional packages via the build-package-list build profile action. * Add htmldoc and texi2html when building the list of the packages for which we need source packages when building the bootstrap Haiku image. We don't want them on the regular image, but they are needed to build some packages that are on it.
619 lines
19 KiB
Plaintext
619 lines
19 KiB
Plaintext
#pragma mark - Private
|
|
|
|
|
|
rule PackageFamily packageBaseName
|
|
{
|
|
return $(packageBaseName:G=package-family) ;
|
|
}
|
|
|
|
|
|
rule SetRepositoryMethod repository : methodName : method
|
|
{
|
|
HAIKU_REPOSITORY_METHOD_$(methodName) on $(repository) = $(method) ;
|
|
}
|
|
|
|
rule InvokeRepositoryMethod repository : methodName : arg1 : arg2 : arg3 : arg4
|
|
: arg5 : arg6 : arg7
|
|
{
|
|
local method
|
|
= [ on $(repository) return $(HAIKU_REPOSITORY_METHOD_$(methodName)) ] ;
|
|
if ! $(method) {
|
|
Exit "Method" $(methodName) " not defined for repository"
|
|
$(repository) ;
|
|
}
|
|
|
|
return [ $(method) $(repository) : $(arg1) : $(arg2) : $(arg3) : $(arg4)
|
|
: $(arg5) : $(arg6) : $(arg7) ] ;
|
|
}
|
|
|
|
|
|
rule AddRepositoryPackage repository : architecture : baseName : version
|
|
{
|
|
local package = $(baseName)-$(version) ;
|
|
package = $(package:E=$(baseName):G=package-in-$(repository:G=)) ;
|
|
HAIKU_PACKAGE_REPOSITORY on $(package) = $(repository) ;
|
|
HAIKU_PACKAGE_ARCHITECTURE on $(package) = $(architecture) ;
|
|
HAIKU_PACKAGE_FILE_NAME on $(package) = $(package:G=)-$(architecture).hpkg ;
|
|
|
|
local packageFamily = [ InvokeRepositoryMethod $(repository) : PackageFamily
|
|
: $(baseName) ] ;
|
|
baseName = $(packageFamily:G=) ;
|
|
|
|
if ! $(baseName) in $(HAIKU_AVAILABLE_PACKAGES) {
|
|
HAIKU_AVAILABLE_PACKAGES += $(baseName) ;
|
|
}
|
|
|
|
HAIKU_PACKAGE_VERSIONS on $(packageFamily) += $(package) ;
|
|
HAIKU_REPOSITORY_PACKAGES on $(repository) += $(package) ;
|
|
|
|
return $(package) ;
|
|
}
|
|
|
|
|
|
rule AddRepositoryPackages repository : architecture : packages : sourcePackages
|
|
: debugInfoPackages
|
|
{
|
|
local packageTargets ;
|
|
local package ;
|
|
for package in $(packages) {
|
|
local splitName = [ Match "([^-]*)-(.*)" : $(package) ] ;
|
|
local baseName = $(splitName[1]:E=$(package)) ;
|
|
local version = $(splitName[2]) ;
|
|
packageTargets += [ AddRepositoryPackage $(repository) : $(architecture)
|
|
: $(baseName) : $(version) ] ;
|
|
if $(baseName) in $(sourcePackages) {
|
|
AddRepositoryPackage $(repository) : source : $(baseName)_source
|
|
: $(version) ;
|
|
}
|
|
if $(baseName) in $(debugInfoPackages) {
|
|
packageTargets += [ AddRepositoryPackage $(repository)
|
|
: $(architecture) : $(baseName)_debuginfo : $(version) ] ;
|
|
}
|
|
}
|
|
|
|
return $(packageTargets) ;
|
|
}
|
|
|
|
|
|
rule PackageRepository repository : architecture : anyPackages : packages
|
|
: sourcePackages : debugInfoPackages
|
|
{
|
|
if $(architecture) != $(HAIKU_PACKAGING_ARCHS[1]) {
|
|
return ;
|
|
}
|
|
|
|
HAIKU_REPOSITORIES += $(repository) ;
|
|
HAIKU_REPOSITORY_DEFINITION_FILE on $(repository)
|
|
= $(HAIKU_REPOSITORY_JAMFILE) ;
|
|
|
|
return [ AddRepositoryPackages $(repository) : any : $(anyPackages)
|
|
: $(sourcePackages) : $(debugInfoPackages) ]
|
|
[ AddRepositoryPackages $(repository) : $(architecture) : $(packages)
|
|
: $(sourcePackages) : $(debugInfoPackages) ] ;
|
|
}
|
|
|
|
|
|
#pragma mark - Remote Repository
|
|
|
|
|
|
rule RemoteRepositoryPackageFamily repository : packageBaseName
|
|
{
|
|
return [ PackageFamily $(packageBaseName) ] ;
|
|
}
|
|
|
|
|
|
rule RemoteRepositoryFetchPackage repository : package : fileName
|
|
{
|
|
local baseUrl = [ on $(repository) return $(HAIKU_REPOSITORY_URL) ] ;
|
|
local packagesChecksumFile
|
|
= [ on $(repository)
|
|
return $(HAIKU_REPOSITORY_PACKAGES_CHECKSUM_FILE) ] ;
|
|
|
|
local downloadedFile = [ DownloadFile $(fileName)
|
|
: "$(baseUrl)/`cat $source`/packages/$(fileName)"
|
|
: $(packagesChecksumFile) ] ;
|
|
NoUpdate $(downloadedFile) ;
|
|
# Don't download the file again when something in the repository
|
|
# changes. It is (supposed to be) still the same file.
|
|
return $(downloadedFile) ;
|
|
}
|
|
|
|
|
|
rule RemotePackageRepository repository : architecture : repositoryUrl
|
|
: anyPackages : packages : sourcePackages : debugInfoPackages
|
|
{
|
|
repository = $(repository:G=repository) ;
|
|
|
|
SetRepositoryMethod $(repository) : PackageFamily
|
|
: RemoteRepositoryPackageFamily ;
|
|
SetRepositoryMethod $(repository) : FetchPackage
|
|
: RemoteRepositoryFetchPackage ;
|
|
|
|
HAIKU_REPOSITORY_URL on $(repository) = $(repositoryUrl) ;
|
|
|
|
PackageRepository $(repository) : $(architecture) : $(anyPackages)
|
|
: $(packages) : $(sourcePackages) : $(debugInfoPackages) ;
|
|
|
|
# build package list file
|
|
local packageListFile = $(repository:G=repository-package-list)-packages ;
|
|
local repositoriesDir = $(HAIKU_PACKAGE_REPOSITORIES_DIR_$(architecture)) ;
|
|
MakeLocate $(packageListFile) : $(repositoriesDir) ;
|
|
GeneratedRepositoryPackageList $(packageListFile) : $(repository) ;
|
|
|
|
# build package list checksum file
|
|
local packagesChecksumFile
|
|
= $(repository:G=repository-package-checksum)-checksum ;
|
|
MakeLocate $(packagesChecksumFile) : $(repositoriesDir) ;
|
|
Depends $(packagesChecksumFile) : $(packageListFile) ;
|
|
ChecksumFileSHA256 $(packagesChecksumFile) : $(packageListFile) ;
|
|
|
|
# download repository info file
|
|
local repositoryInfo = $(repository:G=repository-info)-info ;
|
|
MakeLocate $(repositoryInfo) : $(repositoriesDir) ;
|
|
local repoUrl = [ on $(repository) return $(HAIKU_REPOSITORY_URL) ] ;
|
|
DownloadLocatedFile $(repositoryInfo)
|
|
: "$(repoUrl)/`cat $source`/repo.info"
|
|
: $(packagesChecksumFile) ;
|
|
|
|
# download repository file
|
|
local repositoryFile = $(repository:G=repository-cache) ;
|
|
MakeLocate $(repositoryFile) : $(repositoriesDir) ;
|
|
local repoUrl = [ on $(repository) return $(HAIKU_REPOSITORY_URL) ] ;
|
|
DownloadLocatedFile $(repositoryFile)
|
|
: "$(repoUrl)/`cat $source`/repo"
|
|
: $(packagesChecksumFile) ;
|
|
|
|
# build repository config file
|
|
local repositoryConfig = $(repository:G=repository-config)-config ;
|
|
MakeLocate $(repositoryConfig) : $(repositoriesDir) ;
|
|
RepositoryConfig $(repositoryConfig) : $(repositoryInfo)
|
|
: $(packagesChecksumFile) : $(repository) ;
|
|
|
|
HAIKU_REPOSITORY_CACHE_FILE on $(repository) = $(repositoryFile) ;
|
|
HAIKU_REPOSITORY_CONFIG_FILE on $(repository) = $(repositoryConfig) ;
|
|
HAIKU_REPOSITORY_PACKAGES_CHECKSUM_FILE on $(repository)
|
|
= $(packagesChecksumFile) ;
|
|
}
|
|
|
|
|
|
rule GeneratedRepositoryPackageList target : repository
|
|
{
|
|
repository = $(repository:G=repository) ;
|
|
|
|
# construct a list of file names
|
|
local fileNames ;
|
|
local package ;
|
|
for package in [ on $(repository) return $(HAIKU_REPOSITORY_PACKAGES) ] {
|
|
fileNames += [ on $(package) return $(HAIKU_PACKAGE_FILE_NAME) ] ;
|
|
}
|
|
|
|
local definitionFile
|
|
= [ on $(repository) return $(HAIKU_REPOSITORY_DEFINITION_FILE) ] ;
|
|
Depends $(target) : $(definitionFile) ;
|
|
|
|
HAIKU_REPOSITORY_PACKAGE_FILE_NAMES on $(target) = $(fileNames) ;
|
|
GeneratedRepositoryPackageList1 $(target) ;
|
|
}
|
|
|
|
|
|
actions GeneratedRepositoryPackageList1
|
|
{
|
|
(for file in $(HAIKU_REPOSITORY_PACKAGE_FILE_NAMES) ; do
|
|
echo $file
|
|
done) | LC_ALL=C sort -u > $(1)
|
|
}
|
|
|
|
|
|
rule RepositoryConfig repoConfig : repoInfo : packagesChecksumFile : repository
|
|
{
|
|
repository = $(repository:G=repository) ;
|
|
|
|
HAIKU_REPOSITORY_URL on $(repoConfig)
|
|
= [ on $(repository) return $(HAIKU_REPOSITORY_URL) ] ;
|
|
Depends $(repoConfig)
|
|
: <build>create_repository_config $(repoInfo) $(packagesChecksumFile) ;
|
|
RepositoryConfig1 $(repoConfig)
|
|
: <build>create_repository_config $(repoInfo) $(packagesChecksumFile) ;
|
|
}
|
|
|
|
|
|
actions RepositoryConfig1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) $(HAIKU_REPOSITORY_URL)/`cat $(2[3])` $(2[2]) $(1)
|
|
}
|
|
|
|
|
|
#pragma mark - Bootstrap Repository
|
|
|
|
|
|
rule BootstrapRepositoryPackageFamily repository : packageBaseName
|
|
{
|
|
local splitBaseName = [ Match "(.*)_bootstrap(.*)" : $(packageBaseName) ] ;
|
|
if $(splitBaseName) {
|
|
packageBaseName = $(splitBaseName[1])$(splitBaseName[2]) ;
|
|
}
|
|
|
|
return [ PackageFamily $(packageBaseName) ] ;
|
|
}
|
|
|
|
|
|
rule BootstrapRepositoryFetchPackage repository : package : fileName
|
|
{
|
|
local outputDir
|
|
= [ on $(repository) return $(HAIKU_REPOSITORY_BUILD_DIRECTORY) ] ;
|
|
local configFile
|
|
= [ on $(repository) return $(HAIKU_REPOSITORY_BUILD_CONFIG_FILE) ] ;
|
|
local haikuCrossDevelPackages = [ on $(package)
|
|
return $(HAIKU_REPOSITORY_HAIKU_CROSS_DEVEL_PACKAGES) ] ;
|
|
|
|
local packageFile = <cross-built>$(fileName) ;
|
|
if [ on $(packageFile) return $(HAIKU_REPOSITORY_BUILD_DIRECTORY) ] {
|
|
# rule already called for this package
|
|
return $(packageFile) ;
|
|
}
|
|
|
|
HAIKU_REPOSITORY_BUILD_DIRECTORY on $(packageFile) = $(outputDir) ;
|
|
|
|
MakeLocate $(packageFile) : [ FDirName $(outputDir) packages ] ;
|
|
NoUpdate $(packageFile) ;
|
|
# Don't rebuild the file. Since the haiku cross devel package is
|
|
# a dependency and is updated always, this package would otherwise be
|
|
# rebuilt always as well.
|
|
|
|
Depends $(packageFile) : $(haikuCrossDevelPackages) $(configFile) ;
|
|
BootstrapRepositoryFetchPackage1 $(packageFile)
|
|
: $(haikuCrossDevelPackages) ;
|
|
|
|
return $(packageFile) ;
|
|
}
|
|
|
|
|
|
actions BootstrapRepositoryFetchPackage1
|
|
{
|
|
# don't rebuild existing package
|
|
package="$(1)"
|
|
if [ -e "$package" ]; then
|
|
exit 0
|
|
fi
|
|
|
|
# make Haiku cross devel package path absolute
|
|
haikuCrossDevelPackage="$(2[1])"
|
|
if [[ "$haikuCrossDevelPackage" != /* ]]; then
|
|
haikuCrossDevelPackage="`pwd`/$haikuCrossDevelPackage"
|
|
fi
|
|
|
|
# make secondary Haiku cross devel packages path absolute
|
|
secondaryCrossDevelPackages=
|
|
if [ -n "$(2[2-]:J)" ]; then
|
|
for secondaryCrossDevelPackage in "$(2[2-])" ; do
|
|
if [[ "$secondaryCrossDevelPackage" != /* ]]; then
|
|
secondaryCrossDevelPackage="`pwd`/$secondaryCrossDevelPackage"
|
|
fi
|
|
if [ -n "$secondaryCrossDevelPackages" ]; then
|
|
secondaryCrossDevelPackages="secondaryCrossDevelPackages,$secondaryCrossDevelPackage"
|
|
else
|
|
secondaryCrossDevelPackages="--secondary-cross-devel-package=$secondaryCrossDevelPackage"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# determine the portName
|
|
portName=`basename "$package" | sed 's@-.*@@'`
|
|
case $portName in
|
|
*_devel|*_doc|*_source|*_debuginfo)
|
|
portName=`echo $portName | sed 's@_[^_]*$@@'`
|
|
;;
|
|
esac
|
|
|
|
cd $(HAIKU_REPOSITORY_BUILD_DIRECTORY)
|
|
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
if [ -n "$secondaryCrossDevelPackages" ]; then
|
|
$(HOST_HAIKU_PORTER) -j$(HAIKU_PORTER_CONCURRENT_JOBS) \
|
|
--cross-devel-package "$haikuCrossDevelPackage" \
|
|
"$secondaryCrossDevelPackages" $portName
|
|
else
|
|
$(HOST_HAIKU_PORTER) -j$(HAIKU_PORTER_CONCURRENT_JOBS) \
|
|
--cross-devel-package "$haikuCrossDevelPackage" $portName
|
|
fi
|
|
}
|
|
|
|
|
|
actions BuildBootstrapRepositoryConfig
|
|
{
|
|
cat > $(1) << EOF
|
|
PACKAGER="The Haiku build system <build-system@haiku-os.org>"
|
|
TREE_PATH="$(HAIKU_REPOSITORY_TREE_PATH)"
|
|
TARGET_ARCHITECTURE="$(HAIKU_PACKAGING_ARCH)"
|
|
|
|
DOWNLOAD_IN_PORT_DIRECTORY="yes"
|
|
PACKAGE_COMMAND="$(2[1])"
|
|
MIMESET_COMMAND="$(2[2])"
|
|
SYSTEM_MIME_DB="$(2[3])"
|
|
LICENSES_DIRECTORY="$(HAIKU_TOP)/data/system/data/licenses"
|
|
OUTPUT_DIRECTORY="$(HAIKU_REPOSITORY_BUILD_DIRECTORY)"
|
|
EOF
|
|
|
|
# If we have cross tools, add the cross tools directory.
|
|
gcc=$(HAIKU_CC_$(HAIKU_PACKAGING_ARCH))
|
|
if [[ "$gcc" = /* ]]; then
|
|
if [ `basename $gcc` = \
|
|
$(HAIKU_GCC_MACHINE_$(HAIKU_PACKAGING_ARCH))-gcc ]; then
|
|
dir=`dirname $gcc`
|
|
dir=`dirname $dir`
|
|
echo CROSS_TOOLS=\"$dir\" >> $(1)
|
|
fi
|
|
fi
|
|
|
|
# Add secondary architectures and cross tools.
|
|
secondaryArchs="$(HAIKU_PACKAGING_ARCHS[2-]:E=)"
|
|
if [ -n "$secondaryArchs" ]; then
|
|
echo SECONDARY_TARGET_ARCHITECTURES=\" >> $(1)
|
|
for arch in $secondaryArchs; do
|
|
echo " $arch" >> $(1)
|
|
done
|
|
echo \" >> $(1)
|
|
|
|
echo SECONDARY_CROSS_TOOLS=\" >> $(1)
|
|
for gcc in $(HAIKU_CC_$(HAIKU_PACKAGING_ARCHS[2-])) ; do
|
|
dir=`dirname $gcc`
|
|
dir=`dirname $dir`
|
|
echo " $dir" >> $(1)
|
|
done
|
|
echo \" >> $(1)
|
|
fi
|
|
}
|
|
|
|
|
|
rule BootstrapPackageRepository repository : architecture
|
|
: anyPackages : packagesStage1 : packagesStage2 : sourcePackages
|
|
: debugInfoPackages
|
|
{
|
|
repository = $(repository:G=repository) ;
|
|
packagesStage1 = [ FFilterByBuildFeatures $(packagesStage1) ] ;
|
|
packagesStage2 = [ FFilterByBuildFeatures $(packagesStage2) ] ;
|
|
sourcePackages = [ FFilterByBuildFeatures $(sourcePackages) ] ;
|
|
debugInfoPackages = [ FFilterByBuildFeatures $(debugInfoPackages) ] ;
|
|
|
|
SetRepositoryMethod $(repository) : PackageFamily
|
|
: BootstrapRepositoryPackageFamily ;
|
|
SetRepositoryMethod $(repository) : FetchPackage
|
|
: BootstrapRepositoryFetchPackage ;
|
|
|
|
# register repository with stage 1 packages
|
|
local stage1PackageTargets = [ PackageRepository $(repository)
|
|
: $(architecture) : $(anyPackages) : $(packagesStage1)
|
|
: $(sourcePackages) : $(debugInfoPackages) ] ;
|
|
if ! $(stage1PackageTargets) {
|
|
return ;
|
|
}
|
|
local crossDevelPackageSuffixes = $(architecture)
|
|
$(architecture)_$(HAIKU_PACKAGING_ARCHS[2-]) ;
|
|
HAIKU_REPOSITORY_HAIKU_CROSS_DEVEL_PACKAGES on $(stage1PackageTargets)
|
|
= haiku_cross_devel_sysroot_stage1_$(crossDevelPackageSuffixes).hpkg ;
|
|
|
|
# add stage 2 packages
|
|
local stage2PackageTargets = [ AddRepositoryPackages $(repository)
|
|
: $(architecture) : $(packagesStage2) : $(sourcePackages)
|
|
: $(debugInfoPackages) ] ;
|
|
HAIKU_REPOSITORY_HAIKU_CROSS_DEVEL_PACKAGES on $(stage2PackageTargets)
|
|
= haiku_cross_devel_sysroot_$(crossDevelPackageSuffixes).hpkg ;
|
|
|
|
# prepare the config file for the HaikuPorts cross build
|
|
local outputDir = [ FDirName
|
|
$(HAIKU_PACKAGE_REPOSITORIES_DIR_$(architecture))
|
|
$(repository:G=)-build ] ;
|
|
local configFile = haikuports.conf ;
|
|
configFile = $(configFile:G=repository-config-$(repository:G=)) ;
|
|
MakeLocate $(configFile) : $(outputDir) ;
|
|
NoUpdate $(configFile) ;
|
|
Depends $(configFile) : <build>package <build>mimeset <mimedb>mime_db ;
|
|
HAIKU_REPOSITORY_BUILD_DIRECTORY on $(configFile) = $(outputDir) ;
|
|
HAIKU_PACKAGING_ARCH on $(configFile) = $(architecture) ;
|
|
HAIKU_REPOSITORY_TREE_PATH on $(configFile) = $(HAIKU_PORTS_CROSS) ;
|
|
BuildBootstrapRepositoryConfig $(configFile)
|
|
: <build>package <build>mimeset <mimedb>mime_db ;
|
|
|
|
HAIKU_REPOSITORY_BUILD_CONFIG_FILE on $(repository) = $(configFile) ;
|
|
HAIKU_REPOSITORY_BUILD_DIRECTORY on $(repository) = $(outputDir) ;
|
|
|
|
# Serialize all package file targets. We need to do this, since
|
|
# haikuporter uses a common directory for building the ports, so building
|
|
# two ports concurrently isn't possible.
|
|
local previousPackageFile ;
|
|
local package ;
|
|
for package in $(stage1PackageTargets) $(stage2PackageTargets) {
|
|
local fileName = [ on $(package) return $(HAIKU_PACKAGE_FILE_NAME) ] ;
|
|
local packageFile = [ BootstrapRepositoryFetchPackage $(repository)
|
|
: $(package) : $(fileName) ] ;
|
|
Depends $(packageFile) : $(previousPackageFile) ;
|
|
|
|
previousPackageFile = $(packageFile) ;
|
|
}
|
|
}
|
|
|
|
|
|
#pragma mark - Public
|
|
|
|
|
|
rule FSplitPackageName packageName
|
|
{
|
|
local splitName = [ Match "(.*)_([^_]*)" : $(packageName) ] ;
|
|
local knownPackageSuffixes = devel doc source debuginfo ;
|
|
if $(splitName[2]) && $(splitName[2]) in $(knownPackageSuffixes) {
|
|
return $(splitName) ;
|
|
}
|
|
|
|
return $(packageName) ;
|
|
}
|
|
|
|
|
|
rule IsPackageAvailable package : flags
|
|
{
|
|
# for a secondary architecture adjust the package name
|
|
if $(TARGET_PACKAGING_ARCH) != $(TARGET_PACKAGING_ARCHS[1])
|
|
&& ! nameResolved in $(flags) {
|
|
local splitName = [ FSplitPackageName $(package) ] ;
|
|
splitName = $(splitName[1]) $(TARGET_PACKAGING_ARCH) $(splitName[2-]) ;
|
|
package = $(splitName:J=_) ;
|
|
}
|
|
|
|
if $(package) in $(HAIKU_AVAILABLE_PACKAGES) {
|
|
return $(package) ;
|
|
}
|
|
|
|
return ;
|
|
}
|
|
|
|
|
|
rule FetchPackage packageName : flags
|
|
{
|
|
local foundPackageName = [ IsPackageAvailable $(packageName) : $(flags) ] ;
|
|
if ! $(foundPackageName) {
|
|
Exit "DownloadPackage: package" $(packageName) "not available!" ;
|
|
return ;
|
|
}
|
|
packageName = $(foundPackageName) ;
|
|
|
|
# TODO: We should support explicitly specified versions (or partial/minimum
|
|
# versions like gcc-2 or gcc-4).
|
|
|
|
local packageFamily = [ PackageFamily $(packageName) ] ;
|
|
local package
|
|
= [ on $(packageFamily) return $(HAIKU_PACKAGE_VERSIONS[1]) ] ;
|
|
local fileName = [ on $(package) return $(HAIKU_PACKAGE_FILE_NAME) ] ;
|
|
local repository = [ on $(package) return $(HAIKU_PACKAGE_REPOSITORY) ] ;
|
|
|
|
return [ InvokeRepositoryMethod $(repository) : FetchPackage : $(package)
|
|
: $(fileName) ] ;
|
|
}
|
|
|
|
|
|
rule BuildHaikuPortsSourcePackageDirectory
|
|
{
|
|
local architecture = $(TARGET_PACKAGING_ARCH) ;
|
|
local outputDir = [ FDirName
|
|
$(HAIKU_PACKAGE_REPOSITORIES_DIR_$(architecture))
|
|
HaikuPorts-sources-build ] ;
|
|
|
|
local sourcePackageDir = <HaikuPorts-repository-source-packages>packages ;
|
|
MakeLocate $(sourcePackageDir) : $(outputDir) ;
|
|
|
|
# build the package list file
|
|
local packageList
|
|
= <repository-package-list-HaikuPorts-sources>package_list ;
|
|
MakeLocate $(packageList) : $(outputDir) ;
|
|
Depends $(packageList) :
|
|
[ FDirName $(HAIKU_BUILD_RULES_DIR) repositories HaikuPorts
|
|
$(architecture) ] ;
|
|
# Note: Those are packages we need for building on the bootstrap Haiku. They
|
|
# are build-pre-requires and as such won't be detected by haikuporter as
|
|
# required dependencies when building the source packages.
|
|
HAIKU_REPOSITORY_BUILD_ADDITIONAL_PACKAGES on $(packageList) =
|
|
htmldoc
|
|
texi2html
|
|
;
|
|
BuildHaikuPortsPackageList $(packageList) ;
|
|
|
|
# prepare the config file for the HaikuPorts build
|
|
local configFile = <repository-config-HaikuPorts-sources>haikuports.conf ;
|
|
MakeLocate $(configFile) : $(outputDir) ;
|
|
NoUpdate $(configFile) ;
|
|
Depends $(configFile) : <build>package <build>mimeset <mimedb>mime_db ;
|
|
HAIKU_REPOSITORY_BUILD_DIRECTORY on $(configFile) = $(outputDir) ;
|
|
HAIKU_PACKAGING_ARCH on $(configFile) = $(architecture) ;
|
|
HAIKU_REPOSITORY_TREE_PATH on $(configFile) = $(HAIKU_PORTS) ;
|
|
BuildBootstrapRepositoryConfig $(configFile)
|
|
: <build>package <build>mimeset <mimedb>mime_db ;
|
|
|
|
# get Haiku cross-devel packages and build the sources
|
|
local crossDevelPackageSuffixes = $(architecture)
|
|
$(architecture)_$(HAIKU_PACKAGING_ARCHS[2-]) ;
|
|
local haikuCrossDevelPackages
|
|
= haiku_cross_devel_sysroot_stage1_$(crossDevelPackageSuffixes).hpkg ;
|
|
|
|
HAIKU_REPOSITORY_BUILD_DIRECTORY on $(sourcePackageDir) = $(outputDir) ;
|
|
|
|
Depends $(sourcePackageDir) : $(packageList) $(haikuCrossDevelPackages)
|
|
$(configFile) ;
|
|
BuildHaikuPortsSourcePackageDirectory1 $(sourcePackageDir)
|
|
: $(packageList) $(haikuCrossDevelPackages) ;
|
|
|
|
return $(sourcePackageDir) ;
|
|
}
|
|
|
|
|
|
actions BuildHaikuPortsPackageList
|
|
{
|
|
HAIKU_BOOTSTRAP_BUILD= $(JAM:E=jam) @alpha-raw build-package-list $(1) \
|
|
$(HAIKU_REPOSITORY_BUILD_ADDITIONAL_PACKAGES)
|
|
}
|
|
|
|
|
|
actions BuildHaikuPortsSourcePackageDirectory1
|
|
{
|
|
packageList="$(2[1])"
|
|
|
|
# make Haiku cross devel package path absolute
|
|
haikuCrossDevelPackage="$(2[2])"
|
|
if [[ "$haikuCrossDevelPackage" != /* ]]; then
|
|
haikuCrossDevelPackage="`pwd`/$haikuCrossDevelPackage"
|
|
fi
|
|
|
|
# make secondary Haiku cross devel packages path absolute
|
|
secondaryCrossDevelPackages=
|
|
if [ -n "$(2[3-]:J)" ]; then
|
|
for secondaryCrossDevelPackage in "$(2[3-])" ; do
|
|
if [[ "$secondaryCrossDevelPackage" != /* ]]; then
|
|
secondaryCrossDevelPackage="`pwd`/$secondaryCrossDevelPackage"
|
|
fi
|
|
if [ -n "$secondaryCrossDevelPackages" ]; then
|
|
secondaryCrossDevelPackages="secondaryCrossDevelPackages,$secondaryCrossDevelPackage"
|
|
else
|
|
secondaryCrossDevelPackages="--secondary-cross-devel-package=$secondaryCrossDevelPackage"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
cd $(HAIKU_REPOSITORY_BUILD_DIRECTORY)
|
|
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
if [ -n "$secondaryCrossDevelPackages" ]; then
|
|
$(HOST_HAIKU_PORTER) --cross-devel-package "$haikuCrossDevelPackage" \
|
|
"$secondaryCrossDevelPackages" \
|
|
--create-source-packages-for-bootstrap --portsfile $packageList
|
|
else
|
|
$(HOST_HAIKU_PORTER) --cross-devel-package "$haikuCrossDevelPackage" \
|
|
--create-source-packages-for-bootstrap --portsfile $packageList
|
|
fi
|
|
}
|
|
|
|
|
|
rule BuildHaikuPortsRepositoryConfig treePath
|
|
{
|
|
local architecture = $(TARGET_PACKAGING_ARCH) ;
|
|
local outputDir = [ FDirName
|
|
$(HAIKU_PACKAGE_REPOSITORIES_DIR_$(architecture))
|
|
HaikuPorts-bootstrap ] ;
|
|
|
|
local configFile = <repository-config-HaikuPorts-bootstrap>haikuports.conf ;
|
|
MakeLocate $(configFile) : $(outputDir) ;
|
|
NoUpdate $(configFile) ;
|
|
|
|
HAIKU_REPOSITORY_TREE_PATH on $(configFile) = $(treePath) ;
|
|
BuildHaikuPortsRepositoryConfig1 $(configFile) ;
|
|
|
|
return $(configFile) ;
|
|
}
|
|
|
|
|
|
actions BuildHaikuPortsRepositoryConfig1
|
|
{
|
|
cat > $(1) << EOF
|
|
PACKAGER="The Haiku build system <build-system@haiku-os.org>"
|
|
TREE_PATH="$(HAIKU_REPOSITORY_TREE_PATH)"
|
|
TARGET_ARCHITECTURE="$(HAIKU_PACKAGING_ARCH)"
|
|
EOF
|
|
}
|