662 lines
21 KiB
Plaintext
662 lines
21 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) ;
|
|
|
|
if ! $(HOST_EXTENDED_REGEX_SED) {
|
|
ECHO "Variable HOST_EXTENDED_REGEX_SED not set. Please run ./configure or" ;
|
|
EXIT "specify it manually." ;
|
|
}
|
|
|
|
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 [ "x$haikuCrossDevelPackage" = "x${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 [ "x$secondaryCrossDevelPackage" = "x${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@_[^_]*$@@'`
|
|
;;
|
|
*_source_rigged)
|
|
portName=`echo $portName | sed 's@_source_rigged$@@'`
|
|
;;
|
|
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 [ "x$gcc" != "x${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 [ "x$haikuCrossDevelPackage" = "x${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 [ "x$secondaryCrossDevelPackage" = "x${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
|
|
}
|
|
|
|
|
|
rule BuildRemoteHaikuPortsRepository target : packages
|
|
{
|
|
local packageListFile = <repository-package-list>HaikuPorts-packages ;
|
|
Depends $(target) : $(packageListFile) ;
|
|
|
|
HAIKU_REMOTE_REPOSITORY_PACKAGES on $(target) = $(packages) ;
|
|
BuildRemoteHaikuPortsRepository1 $(target) : $(packageListFile) ;
|
|
}
|
|
|
|
|
|
actions BuildRemoteHaikuPortsRepository1
|
|
{
|
|
remote=haiku_files@haiku-files.org
|
|
|
|
if [ -n "$(HAIKU_REMOTE_REPOSITORY_PACKAGES:E=:J)" ]; then
|
|
for package in $(HAIKU_REMOTE_REPOSITORY_PACKAGES) ; do
|
|
file=`basename $package`
|
|
if ! grep -q $file $(2); then
|
|
echo "Error: $file is not being referenced in $(2)"
|
|
exit 1
|
|
fi
|
|
done
|
|
scp $(HAIKU_REMOTE_REPOSITORY_PACKAGES) \
|
|
$remote:haiku-files.org/files/hpkg/
|
|
fi
|
|
|
|
packageList=package-list.$(TARGET_PACKAGING_ARCH)
|
|
scp $(2) $remote:build_repository/$packageList
|
|
|
|
ssh $remote \
|
|
"cd build_repository \
|
|
&& ./build_repo.sh $(TARGET_PACKAGING_ARCH) $packageList"
|
|
}
|